1 /* MIPS-specific support for 32-bit ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
5 Most of the information added by Ian Lance Taylor, Cygnus Support,
7 N32/64 ABI support added by Mark Mitchell, CodeSourcery, LLC.
8 <mark@codesourcery.com>
9 Traditional MIPS targets support added by Koundinya.K, Dansk Data
10 Elektronik & Operations Research Group. <kk@ddeorg.soft.net>
12 This file is part of BFD, the Binary File Descriptor library.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 2 of the License, or
17 (at your option) any later version.
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 /* This file handles MIPS ELF targets. SGI Irix 5 uses a slightly
29 different MIPS ELF from other targets. This matters when linking.
30 This file supports both, switching at runtime. */
40 /* Get the ECOFF swapping routines. */
42 #include "coff/symconst.h"
43 #include "coff/internal.h"
44 #include "coff/ecoff.h"
45 #include "coff/mips.h"
46 #define ECOFF_SIGNED_32
47 #include "ecoffswap.h"
49 /* This structure is used to hold .got information when linking. It
50 is stored in the tdata field of the bfd_elf_section_data structure. */
54 /* The global symbol in the GOT with the lowest index in the dynamic
56 struct elf_link_hash_entry *global_gotsym;
57 /* The number of global .got entries. */
58 unsigned int global_gotno;
59 /* The number of local .got entries. */
60 unsigned int local_gotno;
61 /* The number of local .got entries we have used. */
62 unsigned int assigned_gotno;
65 /* The MIPS ELF linker needs additional information for each symbol in
66 the global hash table. */
68 struct mips_elf_link_hash_entry
70 struct elf_link_hash_entry root;
72 /* External symbol information. */
75 /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
77 unsigned int possibly_dynamic_relocs;
79 /* If the R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 reloc is against
80 a readonly section. */
81 boolean readonly_reloc;
83 /* The index of the first dynamic relocation (in the .rel.dyn
84 section) against this symbol. */
85 unsigned int min_dyn_reloc_index;
87 /* We must not create a stub for a symbol that has relocations
88 related to taking the function's address, i.e. any but
89 R_MIPS_CALL*16 ones -- see "MIPS ABI Supplement, 3rd Edition",
93 /* If there is a stub that 32 bit functions should use to call this
94 16 bit function, this points to the section containing the stub. */
97 /* Whether we need the fn_stub; this is set if this symbol appears
98 in any relocs other than a 16 bit call. */
101 /* If there is a stub that 16 bit functions should use to call this
102 32 bit function, this points to the section containing the stub. */
105 /* This is like the call_stub field, but it is used if the function
106 being called returns a floating point value. */
107 asection *call_fp_stub;
110 static bfd_reloc_status_type mips32_64bit_reloc
111 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
112 static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
113 PARAMS ((bfd *, bfd_reloc_code_real_type));
114 static reloc_howto_type *mips_rtype_to_howto
115 PARAMS ((unsigned int));
116 static void mips_info_to_howto_rel
117 PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *));
118 static void mips_info_to_howto_rela
119 PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
120 static void bfd_mips_elf32_swap_gptab_in
121 PARAMS ((bfd *, const Elf32_External_gptab *, Elf32_gptab *));
122 static void bfd_mips_elf32_swap_gptab_out
123 PARAMS ((bfd *, const Elf32_gptab *, Elf32_External_gptab *));
125 static void bfd_mips_elf_swap_msym_in
126 PARAMS ((bfd *, const Elf32_External_Msym *, Elf32_Internal_Msym *));
128 static void bfd_mips_elf_swap_msym_out
129 PARAMS ((bfd *, const Elf32_Internal_Msym *, Elf32_External_Msym *));
130 static boolean mips_elf_sym_is_global PARAMS ((bfd *, asymbol *));
131 static boolean mips_elf_create_procedure_table
132 PARAMS ((PTR, bfd *, struct bfd_link_info *, asection *,
133 struct ecoff_debug_info *));
134 static INLINE int elf_mips_isa PARAMS ((flagword));
135 static INLINE int elf_mips_mach PARAMS ((flagword));
136 static INLINE char* elf_mips_abi_name PARAMS ((bfd *));
137 static boolean mips_elf_is_local_label_name
138 PARAMS ((bfd *, const char *));
139 static struct bfd_hash_entry *mips_elf_link_hash_newfunc
140 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
141 static int gptab_compare PARAMS ((const void *, const void *));
142 static bfd_reloc_status_type mips16_jump_reloc
143 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
144 static bfd_reloc_status_type mips16_gprel_reloc
145 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
146 static boolean mips_elf_create_compact_rel_section
147 PARAMS ((bfd *, struct bfd_link_info *));
148 static boolean mips_elf_create_got_section
149 PARAMS ((bfd *, struct bfd_link_info *));
150 static bfd_reloc_status_type mips_elf_final_gp
151 PARAMS ((bfd *, asymbol *, boolean, char **, bfd_vma *));
152 static bfd_byte *elf32_mips_get_relocated_section_contents
153 PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *,
154 bfd_byte *, boolean, asymbol **));
155 static asection *mips_elf_create_msym_section
157 static void mips_elf_irix6_finish_dynamic_symbol
158 PARAMS ((bfd *, const char *, Elf_Internal_Sym *));
159 static bfd_vma mips_elf_sign_extend PARAMS ((bfd_vma, int));
160 static boolean mips_elf_overflow_p PARAMS ((bfd_vma, int));
161 static bfd_vma mips_elf_high PARAMS ((bfd_vma));
162 static bfd_vma mips_elf_higher PARAMS ((bfd_vma));
163 static bfd_vma mips_elf_highest PARAMS ((bfd_vma));
164 static bfd_vma mips_elf_global_got_index
165 PARAMS ((bfd *, struct elf_link_hash_entry *));
166 static bfd_vma mips_elf_local_got_index
167 PARAMS ((bfd *, struct bfd_link_info *, bfd_vma));
168 static bfd_vma mips_elf_got_offset_from_index
169 PARAMS ((bfd *, bfd *, bfd_vma));
170 static boolean mips_elf_record_global_got_symbol
171 PARAMS ((struct elf_link_hash_entry *, struct bfd_link_info *,
172 struct mips_got_info *));
173 static bfd_vma mips_elf_got_page
174 PARAMS ((bfd *, struct bfd_link_info *, bfd_vma, bfd_vma *));
175 static const Elf_Internal_Rela *mips_elf_next_relocation
176 PARAMS ((unsigned int, const Elf_Internal_Rela *,
177 const Elf_Internal_Rela *));
178 static bfd_reloc_status_type mips_elf_calculate_relocation
179 PARAMS ((bfd *, bfd *, asection *, struct bfd_link_info *,
180 const Elf_Internal_Rela *, bfd_vma, reloc_howto_type *,
181 Elf_Internal_Sym *, asection **, bfd_vma *, const char **,
183 static bfd_vma mips_elf_obtain_contents
184 PARAMS ((reloc_howto_type *, const Elf_Internal_Rela *, bfd *, bfd_byte *));
185 static boolean mips_elf_perform_relocation
186 PARAMS ((struct bfd_link_info *, reloc_howto_type *,
187 const Elf_Internal_Rela *, bfd_vma,
188 bfd *, asection *, bfd_byte *, boolean));
189 static boolean mips_elf_assign_gp PARAMS ((bfd *, bfd_vma *));
190 static boolean mips_elf_sort_hash_table_f
191 PARAMS ((struct mips_elf_link_hash_entry *, PTR));
192 static boolean mips_elf_sort_hash_table
193 PARAMS ((struct bfd_link_info *, unsigned long));
194 static asection * mips_elf_got_section PARAMS ((bfd *));
195 static struct mips_got_info *mips_elf_got_info
196 PARAMS ((bfd *, asection **));
197 static boolean mips_elf_local_relocation_p
198 PARAMS ((bfd *, const Elf_Internal_Rela *, asection **, boolean));
199 static bfd_vma mips_elf_create_local_got_entry
200 PARAMS ((bfd *, struct mips_got_info *, asection *, bfd_vma));
201 static bfd_vma mips_elf_got16_entry
202 PARAMS ((bfd *, struct bfd_link_info *, bfd_vma, boolean));
203 static boolean mips_elf_create_dynamic_relocation
204 PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Rela *,
205 struct mips_elf_link_hash_entry *, asection *,
206 bfd_vma, bfd_vma *, asection *));
207 static void mips_elf_allocate_dynamic_relocations
208 PARAMS ((bfd *, unsigned int));
209 static boolean mips_elf_stub_section_p
210 PARAMS ((bfd *, asection *));
211 static int sort_dynamic_relocs
212 PARAMS ((const void *, const void *));
213 static void _bfd_mips_elf_hide_symbol
214 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
215 static void _bfd_mips_elf_copy_indirect_symbol
216 PARAMS ((struct elf_link_hash_entry *,
217 struct elf_link_hash_entry *));
218 static boolean _bfd_elf32_mips_grok_prstatus
219 PARAMS ((bfd *, Elf_Internal_Note *));
220 static boolean _bfd_elf32_mips_grok_psinfo
221 PARAMS ((bfd *, Elf_Internal_Note *));
223 extern const bfd_target bfd_elf32_tradbigmips_vec;
224 extern const bfd_target bfd_elf32_tradlittlemips_vec;
226 extern const bfd_target bfd_elf64_tradbigmips_vec;
227 extern const bfd_target bfd_elf64_tradlittlemips_vec;
230 /* The level of IRIX compatibility we're striving for. */
238 /* This will be used when we sort the dynamic relocation records. */
239 static bfd *reldyn_sorting_bfd;
241 /* Nonzero if ABFD is using the N32 ABI. */
243 #define ABI_N32_P(abfd) \
244 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
246 /* Nonzero if ABFD is using the 64-bit ABI. */
247 #define ABI_64_P(abfd) \
248 ((elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64) != 0)
250 /* Depending on the target vector we generate some version of Irix
251 executables or "normal" MIPS ELF ABI executables. */
253 #define IRIX_COMPAT(abfd) \
254 (((abfd->xvec == &bfd_elf64_tradbigmips_vec) || \
255 (abfd->xvec == &bfd_elf64_tradlittlemips_vec) || \
256 (abfd->xvec == &bfd_elf32_tradbigmips_vec) || \
257 (abfd->xvec == &bfd_elf32_tradlittlemips_vec)) ? ict_none : \
258 ((ABI_N32_P (abfd) || ABI_64_P (abfd)) ? ict_irix6 : ict_irix5))
260 #define IRIX_COMPAT(abfd) \
261 (((abfd->xvec == &bfd_elf32_tradbigmips_vec) || \
262 (abfd->xvec == &bfd_elf32_tradlittlemips_vec)) ? ict_none : \
263 ((ABI_N32_P (abfd) || ABI_64_P (abfd)) ? ict_irix6 : ict_irix5))
266 /* Whether we are trying to be compatible with IRIX at all. */
267 #define SGI_COMPAT(abfd) \
268 (IRIX_COMPAT (abfd) != ict_none)
270 /* The name of the msym section. */
271 #define MIPS_ELF_MSYM_SECTION_NAME(abfd) ".msym"
273 /* The name of the srdata section. */
274 #define MIPS_ELF_SRDATA_SECTION_NAME(abfd) ".srdata"
276 /* The name of the options section. */
277 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
278 (IRIX_COMPAT (abfd) == ict_irix6 ? ".MIPS.options" : ".options")
280 /* The name of the stub section. */
281 #define MIPS_ELF_STUB_SECTION_NAME(abfd) \
282 (IRIX_COMPAT (abfd) == ict_irix6 ? ".MIPS.stubs" : ".stub")
284 /* The name of the dynamic relocation section. */
285 #define MIPS_ELF_REL_DYN_SECTION_NAME(abfd) ".rel.dyn"
287 /* The size of an external REL relocation. */
288 #define MIPS_ELF_REL_SIZE(abfd) \
289 (get_elf_backend_data (abfd)->s->sizeof_rel)
291 /* The size of an external dynamic table entry. */
292 #define MIPS_ELF_DYN_SIZE(abfd) \
293 (get_elf_backend_data (abfd)->s->sizeof_dyn)
295 /* The size of a GOT entry. */
296 #define MIPS_ELF_GOT_SIZE(abfd) \
297 (get_elf_backend_data (abfd)->s->arch_size / 8)
299 /* The size of a symbol-table entry. */
300 #define MIPS_ELF_SYM_SIZE(abfd) \
301 (get_elf_backend_data (abfd)->s->sizeof_sym)
303 /* The default alignment for sections, as a power of two. */
304 #define MIPS_ELF_LOG_FILE_ALIGN(abfd) \
305 (get_elf_backend_data (abfd)->s->file_align == 8 ? 3 : 2)
307 /* Get word-sized data. */
308 #define MIPS_ELF_GET_WORD(abfd, ptr) \
309 (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
311 /* Put out word-sized data. */
312 #define MIPS_ELF_PUT_WORD(abfd, val, ptr) \
314 ? bfd_put_64 (abfd, val, ptr) \
315 : bfd_put_32 (abfd, val, ptr))
317 /* Add a dynamic symbol table-entry. */
319 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
320 (ABI_64_P (elf_hash_table (info)->dynobj) \
321 ? bfd_elf64_add_dynamic_entry (info, tag, val) \
322 : bfd_elf32_add_dynamic_entry (info, tag, val))
324 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
325 (ABI_64_P (elf_hash_table (info)->dynobj) \
326 ? (abort (), false) \
327 : bfd_elf32_add_dynamic_entry (info, tag, val))
330 /* The number of local .got entries we reserve. */
331 #define MIPS_RESERVED_GOTNO (2)
333 /* Instructions which appear in a stub. For some reason the stub is
334 slightly different on an SGI system. */
335 #define ELF_MIPS_GP_OFFSET(abfd) (SGI_COMPAT (abfd) ? 0x7ff0 : 0x8000)
336 #define STUB_LW(abfd) \
339 ? 0xdf998010 /* ld t9,0x8010(gp) */ \
340 : 0x8f998010) /* lw t9,0x8010(gp) */ \
341 : 0x8f998010) /* lw t9,0x8000(gp) */
342 #define STUB_MOVE(abfd) \
343 (SGI_COMPAT (abfd) ? 0x03e07825 : 0x03e07821) /* move t7,ra */
344 #define STUB_JALR 0x0320f809 /* jal t9 */
345 #define STUB_LI16(abfd) \
346 (SGI_COMPAT (abfd) ? 0x34180000 : 0x24180000) /* ori t8,zero,0 */
347 #define MIPS_FUNCTION_STUB_SIZE (16)
350 /* We no longer try to identify particular sections for the .dynsym
351 section. When we do, we wind up crashing if there are other random
352 sections with relocations. */
354 /* Names of sections which appear in the .dynsym section in an Irix 5
357 static const char * const mips_elf_dynsym_sec_names[] =
370 #define SIZEOF_MIPS_DYNSYM_SECNAMES \
371 (sizeof mips_elf_dynsym_sec_names / sizeof mips_elf_dynsym_sec_names[0])
373 /* The number of entries in mips_elf_dynsym_sec_names which go in the
376 #define MIPS_TEXT_DYNSYM_SECNO (3)
380 /* The names of the runtime procedure table symbols used on Irix 5. */
382 static const char * const mips_elf_dynsym_rtproc_names[] =
385 "_procedure_string_table",
386 "_procedure_table_size",
390 /* These structures are used to generate the .compact_rel section on
395 unsigned long id1; /* Always one? */
396 unsigned long num; /* Number of compact relocation entries. */
397 unsigned long id2; /* Always two? */
398 unsigned long offset; /* The file offset of the first relocation. */
399 unsigned long reserved0; /* Zero? */
400 unsigned long reserved1; /* Zero? */
409 bfd_byte reserved0[4];
410 bfd_byte reserved1[4];
411 } Elf32_External_compact_rel;
415 unsigned int ctype : 1; /* 1: long 0: short format. See below. */
416 unsigned int rtype : 4; /* Relocation types. See below. */
417 unsigned int dist2to : 8;
418 unsigned int relvaddr : 19; /* (VADDR - vaddr of the previous entry)/ 4 */
419 unsigned long konst; /* KONST field. See below. */
420 unsigned long vaddr; /* VADDR to be relocated. */
425 unsigned int ctype : 1; /* 1: long 0: short format. See below. */
426 unsigned int rtype : 4; /* Relocation types. See below. */
427 unsigned int dist2to : 8;
428 unsigned int relvaddr : 19; /* (VADDR - vaddr of the previous entry)/ 4 */
429 unsigned long konst; /* KONST field. See below. */
437 } Elf32_External_crinfo;
443 } Elf32_External_crinfo2;
445 /* These are the constants used to swap the bitfields in a crinfo. */
447 #define CRINFO_CTYPE (0x1)
448 #define CRINFO_CTYPE_SH (31)
449 #define CRINFO_RTYPE (0xf)
450 #define CRINFO_RTYPE_SH (27)
451 #define CRINFO_DIST2TO (0xff)
452 #define CRINFO_DIST2TO_SH (19)
453 #define CRINFO_RELVADDR (0x7ffff)
454 #define CRINFO_RELVADDR_SH (0)
456 /* A compact relocation info has long (3 words) or short (2 words)
457 formats. A short format doesn't have VADDR field and relvaddr
458 fields contains ((VADDR - vaddr of the previous entry) >> 2). */
459 #define CRF_MIPS_LONG 1
460 #define CRF_MIPS_SHORT 0
462 /* There are 4 types of compact relocation at least. The value KONST
463 has different meaning for each type:
466 CT_MIPS_REL32 Address in data
467 CT_MIPS_WORD Address in word (XXX)
468 CT_MIPS_GPHI_LO GP - vaddr
469 CT_MIPS_JMPAD Address to jump
472 #define CRT_MIPS_REL32 0xa
473 #define CRT_MIPS_WORD 0xb
474 #define CRT_MIPS_GPHI_LO 0xc
475 #define CRT_MIPS_JMPAD 0xd
477 #define mips_elf_set_cr_format(x,format) ((x).ctype = (format))
478 #define mips_elf_set_cr_type(x,type) ((x).rtype = (type))
479 #define mips_elf_set_cr_dist2to(x,v) ((x).dist2to = (v))
480 #define mips_elf_set_cr_relvaddr(x,d) ((x).relvaddr = (d)<<2)
482 static void bfd_elf32_swap_compact_rel_out
483 PARAMS ((bfd *, const Elf32_compact_rel *, Elf32_External_compact_rel *));
484 static void bfd_elf32_swap_crinfo_out
485 PARAMS ((bfd *, const Elf32_crinfo *, Elf32_External_crinfo *));
487 #define USE_REL 1 /* MIPS uses REL relocations instead of RELA */
489 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
490 from smaller values. Start with zero, widen, *then* decrement. */
491 #define MINUS_ONE (((bfd_vma)0) - 1)
493 static reloc_howto_type elf_mips_howto_table[] =
496 HOWTO (R_MIPS_NONE, /* type */
498 0, /* size (0 = byte, 1 = short, 2 = long) */
500 false, /* pc_relative */
502 complain_overflow_dont, /* complain_on_overflow */
503 bfd_elf_generic_reloc, /* special_function */
504 "R_MIPS_NONE", /* name */
505 false, /* partial_inplace */
508 false), /* pcrel_offset */
510 /* 16 bit relocation. */
511 HOWTO (R_MIPS_16, /* type */
513 1, /* size (0 = byte, 1 = short, 2 = long) */
515 false, /* pc_relative */
517 complain_overflow_bitfield, /* complain_on_overflow */
518 bfd_elf_generic_reloc, /* special_function */
519 "R_MIPS_16", /* name */
520 true, /* partial_inplace */
521 0xffff, /* src_mask */
522 0xffff, /* dst_mask */
523 false), /* pcrel_offset */
525 /* 32 bit relocation. */
526 HOWTO (R_MIPS_32, /* type */
528 2, /* size (0 = byte, 1 = short, 2 = long) */
530 false, /* pc_relative */
532 complain_overflow_bitfield, /* complain_on_overflow */
533 bfd_elf_generic_reloc, /* special_function */
534 "R_MIPS_32", /* name */
535 true, /* partial_inplace */
536 0xffffffff, /* src_mask */
537 0xffffffff, /* dst_mask */
538 false), /* pcrel_offset */
540 /* 32 bit symbol relative relocation. */
541 HOWTO (R_MIPS_REL32, /* type */
543 2, /* size (0 = byte, 1 = short, 2 = long) */
545 false, /* pc_relative */
547 complain_overflow_bitfield, /* complain_on_overflow */
548 bfd_elf_generic_reloc, /* special_function */
549 "R_MIPS_REL32", /* name */
550 true, /* partial_inplace */
551 0xffffffff, /* src_mask */
552 0xffffffff, /* dst_mask */
553 false), /* pcrel_offset */
555 /* 26 bit jump address. */
556 HOWTO (R_MIPS_26, /* type */
558 2, /* size (0 = byte, 1 = short, 2 = long) */
560 false, /* pc_relative */
562 complain_overflow_dont, /* complain_on_overflow */
563 /* This needs complex overflow
564 detection, because the upper four
565 bits must match the PC + 4. */
566 bfd_elf_generic_reloc, /* special_function */
567 "R_MIPS_26", /* name */
568 true, /* partial_inplace */
569 0x3ffffff, /* src_mask */
570 0x3ffffff, /* dst_mask */
571 false), /* pcrel_offset */
573 /* High 16 bits of symbol value. */
574 HOWTO (R_MIPS_HI16, /* type */
576 2, /* size (0 = byte, 1 = short, 2 = long) */
578 false, /* pc_relative */
580 complain_overflow_dont, /* complain_on_overflow */
581 _bfd_mips_elf_hi16_reloc, /* special_function */
582 "R_MIPS_HI16", /* name */
583 true, /* partial_inplace */
584 0xffff, /* src_mask */
585 0xffff, /* dst_mask */
586 false), /* pcrel_offset */
588 /* Low 16 bits of symbol value. */
589 HOWTO (R_MIPS_LO16, /* type */
591 2, /* size (0 = byte, 1 = short, 2 = long) */
593 false, /* pc_relative */
595 complain_overflow_dont, /* complain_on_overflow */
596 _bfd_mips_elf_lo16_reloc, /* special_function */
597 "R_MIPS_LO16", /* name */
598 true, /* partial_inplace */
599 0xffff, /* src_mask */
600 0xffff, /* dst_mask */
601 false), /* pcrel_offset */
603 /* GP relative reference. */
604 HOWTO (R_MIPS_GPREL16, /* type */
606 2, /* size (0 = byte, 1 = short, 2 = long) */
608 false, /* pc_relative */
610 complain_overflow_signed, /* complain_on_overflow */
611 _bfd_mips_elf_gprel16_reloc, /* special_function */
612 "R_MIPS_GPREL16", /* name */
613 true, /* partial_inplace */
614 0xffff, /* src_mask */
615 0xffff, /* dst_mask */
616 false), /* pcrel_offset */
618 /* Reference to literal section. */
619 HOWTO (R_MIPS_LITERAL, /* type */
621 2, /* size (0 = byte, 1 = short, 2 = long) */
623 false, /* pc_relative */
625 complain_overflow_signed, /* complain_on_overflow */
626 _bfd_mips_elf_gprel16_reloc, /* special_function */
627 "R_MIPS_LITERAL", /* name */
628 true, /* partial_inplace */
629 0xffff, /* src_mask */
630 0xffff, /* dst_mask */
631 false), /* pcrel_offset */
633 /* Reference to global offset table. */
634 HOWTO (R_MIPS_GOT16, /* type */
636 2, /* size (0 = byte, 1 = short, 2 = long) */
638 false, /* pc_relative */
640 complain_overflow_signed, /* complain_on_overflow */
641 _bfd_mips_elf_got16_reloc, /* special_function */
642 "R_MIPS_GOT16", /* name */
643 false, /* partial_inplace */
644 0xffff, /* src_mask */
645 0xffff, /* dst_mask */
646 false), /* pcrel_offset */
648 /* 16 bit PC relative reference. */
649 HOWTO (R_MIPS_PC16, /* type */
651 2, /* size (0 = byte, 1 = short, 2 = long) */
653 true, /* pc_relative */
655 complain_overflow_signed, /* complain_on_overflow */
656 bfd_elf_generic_reloc, /* special_function */
657 "R_MIPS_PC16", /* name */
658 true, /* partial_inplace */
659 0xffff, /* src_mask */
660 0xffff, /* dst_mask */
661 true), /* pcrel_offset */
663 /* 16 bit call through global offset table. */
664 HOWTO (R_MIPS_CALL16, /* type */
666 2, /* size (0 = byte, 1 = short, 2 = long) */
668 false, /* pc_relative */
670 complain_overflow_signed, /* complain_on_overflow */
671 bfd_elf_generic_reloc, /* special_function */
672 "R_MIPS_CALL16", /* name */
673 false, /* partial_inplace */
674 0xffff, /* src_mask */
675 0xffff, /* dst_mask */
676 false), /* pcrel_offset */
678 /* 32 bit GP relative reference. */
679 HOWTO (R_MIPS_GPREL32, /* type */
681 2, /* size (0 = byte, 1 = short, 2 = long) */
683 false, /* pc_relative */
685 complain_overflow_bitfield, /* complain_on_overflow */
686 _bfd_mips_elf_gprel32_reloc, /* special_function */
687 "R_MIPS_GPREL32", /* name */
688 true, /* partial_inplace */
689 0xffffffff, /* src_mask */
690 0xffffffff, /* dst_mask */
691 false), /* pcrel_offset */
693 /* The remaining relocs are defined on Irix 5, although they are
694 not defined by the ABI. */
699 /* A 5 bit shift field. */
700 HOWTO (R_MIPS_SHIFT5, /* type */
702 2, /* size (0 = byte, 1 = short, 2 = long) */
704 false, /* pc_relative */
706 complain_overflow_bitfield, /* complain_on_overflow */
707 bfd_elf_generic_reloc, /* special_function */
708 "R_MIPS_SHIFT5", /* name */
709 true, /* partial_inplace */
710 0x000007c0, /* src_mask */
711 0x000007c0, /* dst_mask */
712 false), /* pcrel_offset */
714 /* A 6 bit shift field. */
715 /* FIXME: This is not handled correctly; a special function is
716 needed to put the most significant bit in the right place. */
717 HOWTO (R_MIPS_SHIFT6, /* type */
719 2, /* size (0 = byte, 1 = short, 2 = long) */
721 false, /* pc_relative */
723 complain_overflow_bitfield, /* complain_on_overflow */
724 bfd_elf_generic_reloc, /* special_function */
725 "R_MIPS_SHIFT6", /* name */
726 true, /* partial_inplace */
727 0x000007c4, /* src_mask */
728 0x000007c4, /* dst_mask */
729 false), /* pcrel_offset */
731 /* A 64 bit relocation. */
732 HOWTO (R_MIPS_64, /* type */
734 4, /* size (0 = byte, 1 = short, 2 = long) */
736 false, /* pc_relative */
738 complain_overflow_bitfield, /* complain_on_overflow */
739 mips32_64bit_reloc, /* special_function */
740 "R_MIPS_64", /* name */
741 true, /* partial_inplace */
742 MINUS_ONE, /* src_mask */
743 MINUS_ONE, /* dst_mask */
744 false), /* pcrel_offset */
746 /* Displacement in the global offset table. */
747 HOWTO (R_MIPS_GOT_DISP, /* type */
749 2, /* size (0 = byte, 1 = short, 2 = long) */
751 false, /* pc_relative */
753 complain_overflow_bitfield, /* complain_on_overflow */
754 bfd_elf_generic_reloc, /* special_function */
755 "R_MIPS_GOT_DISP", /* name */
756 true, /* partial_inplace */
757 0x0000ffff, /* src_mask */
758 0x0000ffff, /* dst_mask */
759 false), /* pcrel_offset */
761 /* Displacement to page pointer in the global offset table. */
762 HOWTO (R_MIPS_GOT_PAGE, /* type */
764 2, /* size (0 = byte, 1 = short, 2 = long) */
766 false, /* pc_relative */
768 complain_overflow_bitfield, /* complain_on_overflow */
769 bfd_elf_generic_reloc, /* special_function */
770 "R_MIPS_GOT_PAGE", /* name */
771 true, /* partial_inplace */
772 0x0000ffff, /* src_mask */
773 0x0000ffff, /* dst_mask */
774 false), /* pcrel_offset */
776 /* Offset from page pointer in the global offset table. */
777 HOWTO (R_MIPS_GOT_OFST, /* type */
779 2, /* size (0 = byte, 1 = short, 2 = long) */
781 false, /* pc_relative */
783 complain_overflow_bitfield, /* complain_on_overflow */
784 bfd_elf_generic_reloc, /* special_function */
785 "R_MIPS_GOT_OFST", /* name */
786 true, /* partial_inplace */
787 0x0000ffff, /* src_mask */
788 0x0000ffff, /* dst_mask */
789 false), /* pcrel_offset */
791 /* High 16 bits of displacement in global offset table. */
792 HOWTO (R_MIPS_GOT_HI16, /* type */
794 2, /* size (0 = byte, 1 = short, 2 = long) */
796 false, /* pc_relative */
798 complain_overflow_dont, /* complain_on_overflow */
799 bfd_elf_generic_reloc, /* special_function */
800 "R_MIPS_GOT_HI16", /* name */
801 true, /* partial_inplace */
802 0x0000ffff, /* src_mask */
803 0x0000ffff, /* dst_mask */
804 false), /* pcrel_offset */
806 /* Low 16 bits of displacement in global offset table. */
807 HOWTO (R_MIPS_GOT_LO16, /* type */
809 2, /* size (0 = byte, 1 = short, 2 = long) */
811 false, /* pc_relative */
813 complain_overflow_dont, /* complain_on_overflow */
814 bfd_elf_generic_reloc, /* special_function */
815 "R_MIPS_GOT_LO16", /* name */
816 true, /* partial_inplace */
817 0x0000ffff, /* src_mask */
818 0x0000ffff, /* dst_mask */
819 false), /* pcrel_offset */
821 /* 64 bit subtraction. Used in the N32 ABI. */
822 HOWTO (R_MIPS_SUB, /* type */
824 4, /* size (0 = byte, 1 = short, 2 = long) */
826 false, /* pc_relative */
828 complain_overflow_bitfield, /* complain_on_overflow */
829 bfd_elf_generic_reloc, /* special_function */
830 "R_MIPS_SUB", /* name */
831 true, /* partial_inplace */
832 MINUS_ONE, /* src_mask */
833 MINUS_ONE, /* dst_mask */
834 false), /* pcrel_offset */
836 /* Used to cause the linker to insert and delete instructions? */
837 EMPTY_HOWTO (R_MIPS_INSERT_A),
838 EMPTY_HOWTO (R_MIPS_INSERT_B),
839 EMPTY_HOWTO (R_MIPS_DELETE),
841 /* Get the higher value of a 64 bit addend. */
842 HOWTO (R_MIPS_HIGHER, /* type */
844 2, /* size (0 = byte, 1 = short, 2 = long) */
846 false, /* pc_relative */
848 complain_overflow_dont, /* complain_on_overflow */
849 bfd_elf_generic_reloc, /* special_function */
850 "R_MIPS_HIGHER", /* name */
851 true, /* partial_inplace */
853 0xffff, /* dst_mask */
854 false), /* pcrel_offset */
856 /* Get the highest value of a 64 bit addend. */
857 HOWTO (R_MIPS_HIGHEST, /* type */
859 2, /* size (0 = byte, 1 = short, 2 = long) */
861 false, /* pc_relative */
863 complain_overflow_dont, /* complain_on_overflow */
864 bfd_elf_generic_reloc, /* special_function */
865 "R_MIPS_HIGHEST", /* name */
866 true, /* partial_inplace */
868 0xffff, /* dst_mask */
869 false), /* pcrel_offset */
871 /* High 16 bits of displacement in global offset table. */
872 HOWTO (R_MIPS_CALL_HI16, /* type */
874 2, /* size (0 = byte, 1 = short, 2 = long) */
876 false, /* pc_relative */
878 complain_overflow_dont, /* complain_on_overflow */
879 bfd_elf_generic_reloc, /* special_function */
880 "R_MIPS_CALL_HI16", /* name */
881 true, /* partial_inplace */
882 0x0000ffff, /* src_mask */
883 0x0000ffff, /* dst_mask */
884 false), /* pcrel_offset */
886 /* Low 16 bits of displacement in global offset table. */
887 HOWTO (R_MIPS_CALL_LO16, /* type */
889 2, /* size (0 = byte, 1 = short, 2 = long) */
891 false, /* pc_relative */
893 complain_overflow_dont, /* complain_on_overflow */
894 bfd_elf_generic_reloc, /* special_function */
895 "R_MIPS_CALL_LO16", /* name */
896 true, /* partial_inplace */
897 0x0000ffff, /* src_mask */
898 0x0000ffff, /* dst_mask */
899 false), /* pcrel_offset */
901 /* Section displacement. */
902 HOWTO (R_MIPS_SCN_DISP, /* type */
904 2, /* size (0 = byte, 1 = short, 2 = long) */
906 false, /* pc_relative */
908 complain_overflow_dont, /* complain_on_overflow */
909 bfd_elf_generic_reloc, /* special_function */
910 "R_MIPS_SCN_DISP", /* name */
911 false, /* partial_inplace */
912 0xffffffff, /* src_mask */
913 0xffffffff, /* dst_mask */
914 false), /* pcrel_offset */
916 EMPTY_HOWTO (R_MIPS_REL16),
917 EMPTY_HOWTO (R_MIPS_ADD_IMMEDIATE),
918 EMPTY_HOWTO (R_MIPS_PJUMP),
919 EMPTY_HOWTO (R_MIPS_RELGOT),
921 /* Protected jump conversion. This is an optimization hint. No
922 relocation is required for correctness. */
923 HOWTO (R_MIPS_JALR, /* type */
925 0, /* size (0 = byte, 1 = short, 2 = long) */
927 false, /* pc_relative */
929 complain_overflow_dont, /* complain_on_overflow */
930 bfd_elf_generic_reloc, /* special_function */
931 "R_MIPS_JALR", /* name */
932 false, /* partial_inplace */
933 0x00000000, /* src_mask */
934 0x00000000, /* dst_mask */
935 false), /* pcrel_offset */
938 /* The reloc used for BFD_RELOC_CTOR when doing a 64 bit link. This
939 is a hack to make the linker think that we need 64 bit values. */
940 static reloc_howto_type elf_mips_ctor64_howto =
941 HOWTO (R_MIPS_64, /* type */
943 4, /* size (0 = byte, 1 = short, 2 = long) */
945 false, /* pc_relative */
947 complain_overflow_signed, /* complain_on_overflow */
948 mips32_64bit_reloc, /* special_function */
949 "R_MIPS_64", /* name */
950 true, /* partial_inplace */
951 0xffffffff, /* src_mask */
952 0xffffffff, /* dst_mask */
953 false); /* pcrel_offset */
955 /* The reloc used for the mips16 jump instruction. */
956 static reloc_howto_type elf_mips16_jump_howto =
957 HOWTO (R_MIPS16_26, /* type */
959 2, /* size (0 = byte, 1 = short, 2 = long) */
961 false, /* pc_relative */
963 complain_overflow_dont, /* complain_on_overflow */
964 /* This needs complex overflow
965 detection, because the upper four
966 bits must match the PC. */
967 mips16_jump_reloc, /* special_function */
968 "R_MIPS16_26", /* name */
969 true, /* partial_inplace */
970 0x3ffffff, /* src_mask */
971 0x3ffffff, /* dst_mask */
972 false); /* pcrel_offset */
974 /* The reloc used for the mips16 gprel instruction. */
975 static reloc_howto_type elf_mips16_gprel_howto =
976 HOWTO (R_MIPS16_GPREL, /* type */
978 2, /* size (0 = byte, 1 = short, 2 = long) */
980 false, /* pc_relative */
982 complain_overflow_signed, /* complain_on_overflow */
983 mips16_gprel_reloc, /* special_function */
984 "R_MIPS16_GPREL", /* name */
985 true, /* partial_inplace */
986 0x07ff001f, /* src_mask */
987 0x07ff001f, /* dst_mask */
988 false); /* pcrel_offset */
990 /* GNU extensions for embedded-pic. */
991 /* High 16 bits of symbol value, pc-relative. */
992 static reloc_howto_type elf_mips_gnu_rel_hi16 =
993 HOWTO (R_MIPS_GNU_REL_HI16, /* type */
995 2, /* size (0 = byte, 1 = short, 2 = long) */
997 true, /* pc_relative */
999 complain_overflow_dont, /* complain_on_overflow */
1000 _bfd_mips_elf_hi16_reloc, /* special_function */
1001 "R_MIPS_GNU_REL_HI16", /* name */
1002 true, /* partial_inplace */
1003 0xffff, /* src_mask */
1004 0xffff, /* dst_mask */
1005 true); /* pcrel_offset */
1007 /* Low 16 bits of symbol value, pc-relative. */
1008 static reloc_howto_type elf_mips_gnu_rel_lo16 =
1009 HOWTO (R_MIPS_GNU_REL_LO16, /* type */
1011 2, /* size (0 = byte, 1 = short, 2 = long) */
1013 true, /* pc_relative */
1015 complain_overflow_dont, /* complain_on_overflow */
1016 _bfd_mips_elf_lo16_reloc, /* special_function */
1017 "R_MIPS_GNU_REL_LO16", /* name */
1018 true, /* partial_inplace */
1019 0xffff, /* src_mask */
1020 0xffff, /* dst_mask */
1021 true); /* pcrel_offset */
1023 /* 16 bit offset for pc-relative branches. */
1024 static reloc_howto_type elf_mips_gnu_rel16_s2 =
1025 HOWTO (R_MIPS_GNU_REL16_S2, /* type */
1027 2, /* size (0 = byte, 1 = short, 2 = long) */
1029 true, /* pc_relative */
1031 complain_overflow_signed, /* complain_on_overflow */
1032 bfd_elf_generic_reloc, /* special_function */
1033 "R_MIPS_GNU_REL16_S2", /* name */
1034 true, /* partial_inplace */
1035 0xffff, /* src_mask */
1036 0xffff, /* dst_mask */
1037 true); /* pcrel_offset */
1039 /* 64 bit pc-relative. */
1040 static reloc_howto_type elf_mips_gnu_pcrel64 =
1041 HOWTO (R_MIPS_PC64, /* type */
1043 4, /* size (0 = byte, 1 = short, 2 = long) */
1045 true, /* pc_relative */
1047 complain_overflow_signed, /* complain_on_overflow */
1048 bfd_elf_generic_reloc, /* special_function */
1049 "R_MIPS_PC64", /* name */
1050 true, /* partial_inplace */
1051 MINUS_ONE, /* src_mask */
1052 MINUS_ONE, /* dst_mask */
1053 true); /* pcrel_offset */
1055 /* 32 bit pc-relative. */
1056 static reloc_howto_type elf_mips_gnu_pcrel32 =
1057 HOWTO (R_MIPS_PC32, /* type */
1059 2, /* size (0 = byte, 1 = short, 2 = long) */
1061 true, /* pc_relative */
1063 complain_overflow_signed, /* complain_on_overflow */
1064 bfd_elf_generic_reloc, /* special_function */
1065 "R_MIPS_PC32", /* name */
1066 true, /* partial_inplace */
1067 0xffffffff, /* src_mask */
1068 0xffffffff, /* dst_mask */
1069 true); /* pcrel_offset */
1071 /* GNU extension to record C++ vtable hierarchy */
1072 static reloc_howto_type elf_mips_gnu_vtinherit_howto =
1073 HOWTO (R_MIPS_GNU_VTINHERIT, /* type */
1075 2, /* size (0 = byte, 1 = short, 2 = long) */
1077 false, /* pc_relative */
1079 complain_overflow_dont, /* complain_on_overflow */
1080 NULL, /* special_function */
1081 "R_MIPS_GNU_VTINHERIT", /* name */
1082 false, /* partial_inplace */
1085 false); /* pcrel_offset */
1087 /* GNU extension to record C++ vtable member usage */
1088 static reloc_howto_type elf_mips_gnu_vtentry_howto =
1089 HOWTO (R_MIPS_GNU_VTENTRY, /* type */
1091 2, /* size (0 = byte, 1 = short, 2 = long) */
1093 false, /* pc_relative */
1095 complain_overflow_dont, /* complain_on_overflow */
1096 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
1097 "R_MIPS_GNU_VTENTRY", /* name */
1098 false, /* partial_inplace */
1101 false); /* pcrel_offset */
1103 /* Do a R_MIPS_HI16 relocation. This has to be done in combination
1104 with a R_MIPS_LO16 reloc, because there is a carry from the LO16 to
1105 the HI16. Here we just save the information we need; we do the
1106 actual relocation when we see the LO16. MIPS ELF requires that the
1107 LO16 immediately follow the HI16. As a GNU extension, we permit an
1108 arbitrary number of HI16 relocs to be associated with a single LO16
1109 reloc. This extension permits gcc to output the HI and LO relocs
1114 struct mips_hi16 *next;
1119 /* FIXME: This should not be a static variable. */
1121 static struct mips_hi16 *mips_hi16_list;
1123 bfd_reloc_status_type
1124 _bfd_mips_elf_hi16_reloc (abfd,
1131 bfd *abfd ATTRIBUTE_UNUSED;
1132 arelent *reloc_entry;
1135 asection *input_section;
1137 char **error_message;
1139 bfd_reloc_status_type ret;
1141 struct mips_hi16 *n;
1143 /* If we're relocating, and this an external symbol, we don't want
1144 to change anything. */
1145 if (output_bfd != (bfd *) NULL
1146 && (symbol->flags & BSF_SECTION_SYM) == 0
1147 && reloc_entry->addend == 0)
1149 reloc_entry->address += input_section->output_offset;
1150 return bfd_reloc_ok;
1155 if (strcmp (bfd_asymbol_name (symbol), "_gp_disp") == 0)
1157 boolean relocateable;
1160 if (ret == bfd_reloc_undefined)
1163 if (output_bfd != NULL)
1164 relocateable = true;
1167 relocateable = false;
1168 output_bfd = symbol->section->output_section->owner;
1171 ret = mips_elf_final_gp (output_bfd, symbol, relocateable,
1172 error_message, &gp);
1173 if (ret != bfd_reloc_ok)
1176 relocation = gp - reloc_entry->address;
1180 if (bfd_is_und_section (symbol->section)
1181 && output_bfd == (bfd *) NULL)
1182 ret = bfd_reloc_undefined;
1184 if (bfd_is_com_section (symbol->section))
1187 relocation = symbol->value;
1190 relocation += symbol->section->output_section->vma;
1191 relocation += symbol->section->output_offset;
1192 relocation += reloc_entry->addend;
1194 if (reloc_entry->address > input_section->_cooked_size)
1195 return bfd_reloc_outofrange;
1197 /* Save the information, and let LO16 do the actual relocation. */
1198 n = (struct mips_hi16 *) bfd_malloc (sizeof *n);
1200 return bfd_reloc_outofrange;
1201 n->addr = (bfd_byte *) data + reloc_entry->address;
1202 n->addend = relocation;
1203 n->next = mips_hi16_list;
1206 if (output_bfd != (bfd *) NULL)
1207 reloc_entry->address += input_section->output_offset;
1212 /* Do a R_MIPS_LO16 relocation. This is a straightforward 16 bit
1213 inplace relocation; this function exists in order to do the
1214 R_MIPS_HI16 relocation described above. */
1216 bfd_reloc_status_type
1217 _bfd_mips_elf_lo16_reloc (abfd,
1225 arelent *reloc_entry;
1228 asection *input_section;
1230 char **error_message;
1232 arelent gp_disp_relent;
1234 if (mips_hi16_list != NULL)
1236 struct mips_hi16 *l;
1243 unsigned long vallo;
1244 struct mips_hi16 *next;
1246 /* Do the HI16 relocation. Note that we actually don't need
1247 to know anything about the LO16 itself, except where to
1248 find the low 16 bits of the addend needed by the LO16. */
1249 insn = bfd_get_32 (abfd, l->addr);
1250 vallo = (bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address)
1252 val = ((insn & 0xffff) << 16) + vallo;
1255 /* The low order 16 bits are always treated as a signed
1256 value. Therefore, a negative value in the low order bits
1257 requires an adjustment in the high order bits. We need
1258 to make this adjustment in two ways: once for the bits we
1259 took from the data, and once for the bits we are putting
1260 back in to the data. */
1261 if ((vallo & 0x8000) != 0)
1263 if ((val & 0x8000) != 0)
1266 insn = (insn & ~0xffff) | ((val >> 16) & 0xffff);
1267 bfd_put_32 (abfd, insn, l->addr);
1269 if (strcmp (bfd_asymbol_name (symbol), "_gp_disp") == 0)
1271 gp_disp_relent = *reloc_entry;
1272 reloc_entry = &gp_disp_relent;
1273 reloc_entry->addend = l->addend;
1281 mips_hi16_list = NULL;
1283 else if (strcmp (bfd_asymbol_name (symbol), "_gp_disp") == 0)
1285 bfd_reloc_status_type ret;
1286 bfd_vma gp, relocation;
1288 /* FIXME: Does this case ever occur? */
1290 ret = mips_elf_final_gp (output_bfd, symbol, true, error_message, &gp);
1291 if (ret != bfd_reloc_ok)
1294 relocation = gp - reloc_entry->address;
1295 relocation += symbol->section->output_section->vma;
1296 relocation += symbol->section->output_offset;
1297 relocation += reloc_entry->addend;
1299 if (reloc_entry->address > input_section->_cooked_size)
1300 return bfd_reloc_outofrange;
1302 gp_disp_relent = *reloc_entry;
1303 reloc_entry = &gp_disp_relent;
1304 reloc_entry->addend = relocation - 4;
1307 /* Now do the LO16 reloc in the usual way. */
1308 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1309 input_section, output_bfd, error_message);
1312 /* Do a R_MIPS_GOT16 reloc. This is a reloc against the global offset
1313 table used for PIC code. If the symbol is an external symbol, the
1314 instruction is modified to contain the offset of the appropriate
1315 entry in the global offset table. If the symbol is a section
1316 symbol, the next reloc is a R_MIPS_LO16 reloc. The two 16 bit
1317 addends are combined to form the real addend against the section
1318 symbol; the GOT16 is modified to contain the offset of an entry in
1319 the global offset table, and the LO16 is modified to offset it
1320 appropriately. Thus an offset larger than 16 bits requires a
1321 modified value in the global offset table.
1323 This implementation suffices for the assembler, but the linker does
1324 not yet know how to create global offset tables. */
1326 bfd_reloc_status_type
1327 _bfd_mips_elf_got16_reloc (abfd,
1335 arelent *reloc_entry;
1338 asection *input_section;
1340 char **error_message;
1342 /* If we're relocating, and this an external symbol, we don't want
1343 to change anything. */
1344 if (output_bfd != (bfd *) NULL
1345 && (symbol->flags & BSF_SECTION_SYM) == 0
1346 && reloc_entry->addend == 0)
1348 reloc_entry->address += input_section->output_offset;
1349 return bfd_reloc_ok;
1352 /* If we're relocating, and this is a local symbol, we can handle it
1354 if (output_bfd != (bfd *) NULL
1355 && (symbol->flags & BSF_SECTION_SYM) != 0)
1356 return _bfd_mips_elf_hi16_reloc (abfd, reloc_entry, symbol, data,
1357 input_section, output_bfd, error_message);
1362 /* Set the GP value for OUTPUT_BFD. Returns false if this is a
1363 dangerous relocation. */
1366 mips_elf_assign_gp (output_bfd, pgp)
1374 /* If we've already figured out what GP will be, just return it. */
1375 *pgp = _bfd_get_gp_value (output_bfd);
1379 count = bfd_get_symcount (output_bfd);
1380 sym = bfd_get_outsymbols (output_bfd);
1382 /* The linker script will have created a symbol named `_gp' with the
1383 appropriate value. */
1384 if (sym == (asymbol **) NULL)
1388 for (i = 0; i < count; i++, sym++)
1390 register CONST char *name;
1392 name = bfd_asymbol_name (*sym);
1393 if (*name == '_' && strcmp (name, "_gp") == 0)
1395 *pgp = bfd_asymbol_value (*sym);
1396 _bfd_set_gp_value (output_bfd, *pgp);
1404 /* Only get the error once. */
1406 _bfd_set_gp_value (output_bfd, *pgp);
1413 /* We have to figure out the gp value, so that we can adjust the
1414 symbol value correctly. We look up the symbol _gp in the output
1415 BFD. If we can't find it, we're stuck. We cache it in the ELF
1416 target data. We don't need to adjust the symbol value for an
1417 external symbol if we are producing relocateable output. */
1419 static bfd_reloc_status_type
1420 mips_elf_final_gp (output_bfd, symbol, relocateable, error_message, pgp)
1423 boolean relocateable;
1424 char **error_message;
1427 if (bfd_is_und_section (symbol->section)
1431 return bfd_reloc_undefined;
1434 *pgp = _bfd_get_gp_value (output_bfd);
1437 || (symbol->flags & BSF_SECTION_SYM) != 0))
1441 /* Make up a value. */
1442 *pgp = symbol->section->output_section->vma + 0x4000;
1443 _bfd_set_gp_value (output_bfd, *pgp);
1445 else if (!mips_elf_assign_gp (output_bfd, pgp))
1448 (char *) _("GP relative relocation when _gp not defined");
1449 return bfd_reloc_dangerous;
1453 return bfd_reloc_ok;
1456 /* Do a R_MIPS_GPREL16 relocation. This is a 16 bit value which must
1457 become the offset from the gp register. This function also handles
1458 R_MIPS_LITERAL relocations, although those can be handled more
1459 cleverly because the entries in the .lit8 and .lit4 sections can be
1462 static bfd_reloc_status_type gprel16_with_gp PARAMS ((bfd *, asymbol *,
1463 arelent *, asection *,
1464 boolean, PTR, bfd_vma));
1466 bfd_reloc_status_type
1467 _bfd_mips_elf_gprel16_reloc (abfd, reloc_entry, symbol, data, input_section,
1468 output_bfd, error_message)
1470 arelent *reloc_entry;
1473 asection *input_section;
1475 char **error_message;
1477 boolean relocateable;
1478 bfd_reloc_status_type ret;
1481 /* If we're relocating, and this is an external symbol with no
1482 addend, we don't want to change anything. We will only have an
1483 addend if this is a newly created reloc, not read from an ELF
1485 if (output_bfd != (bfd *) NULL
1486 && (symbol->flags & BSF_SECTION_SYM) == 0
1487 && reloc_entry->addend == 0)
1489 reloc_entry->address += input_section->output_offset;
1490 return bfd_reloc_ok;
1493 if (output_bfd != (bfd *) NULL)
1494 relocateable = true;
1497 relocateable = false;
1498 output_bfd = symbol->section->output_section->owner;
1501 ret = mips_elf_final_gp (output_bfd, symbol, relocateable, error_message,
1503 if (ret != bfd_reloc_ok)
1506 return gprel16_with_gp (abfd, symbol, reloc_entry, input_section,
1507 relocateable, data, gp);
1510 static bfd_reloc_status_type
1511 gprel16_with_gp (abfd, symbol, reloc_entry, input_section, relocateable, data,
1515 arelent *reloc_entry;
1516 asection *input_section;
1517 boolean relocateable;
1525 if (bfd_is_com_section (symbol->section))
1528 relocation = symbol->value;
1530 relocation += symbol->section->output_section->vma;
1531 relocation += symbol->section->output_offset;
1533 if (reloc_entry->address > input_section->_cooked_size)
1534 return bfd_reloc_outofrange;
1536 insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
1538 /* Set val to the offset into the section or symbol. */
1539 if (reloc_entry->howto->src_mask == 0)
1541 /* This case occurs with the 64-bit MIPS ELF ABI. */
1542 val = reloc_entry->addend;
1546 val = ((insn & 0xffff) + reloc_entry->addend) & 0xffff;
1551 /* Adjust val for the final section location and GP value. If we
1552 are producing relocateable output, we don't want to do this for
1553 an external symbol. */
1555 || (symbol->flags & BSF_SECTION_SYM) != 0)
1556 val += relocation - gp;
1558 insn = (insn & ~0xffff) | (val & 0xffff);
1559 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
1562 reloc_entry->address += input_section->output_offset;
1564 /* Make sure it fit in 16 bits. */
1565 if ((long) val >= 0x8000 || (long) val < -0x8000)
1566 return bfd_reloc_overflow;
1568 return bfd_reloc_ok;
1571 /* Do a R_MIPS_GPREL32 relocation. Is this 32 bit value the offset
1572 from the gp register? XXX */
1574 static bfd_reloc_status_type gprel32_with_gp PARAMS ((bfd *, asymbol *,
1575 arelent *, asection *,
1576 boolean, PTR, bfd_vma));
1578 bfd_reloc_status_type
1579 _bfd_mips_elf_gprel32_reloc (abfd,
1587 arelent *reloc_entry;
1590 asection *input_section;
1592 char **error_message;
1594 boolean relocateable;
1595 bfd_reloc_status_type ret;
1598 /* If we're relocating, and this is an external symbol with no
1599 addend, we don't want to change anything. We will only have an
1600 addend if this is a newly created reloc, not read from an ELF
1602 if (output_bfd != (bfd *) NULL
1603 && (symbol->flags & BSF_SECTION_SYM) == 0
1604 && reloc_entry->addend == 0)
1606 *error_message = (char *)
1607 _("32bits gp relative relocation occurs for an external symbol");
1608 return bfd_reloc_outofrange;
1611 if (output_bfd != (bfd *) NULL)
1613 relocateable = true;
1614 gp = _bfd_get_gp_value (output_bfd);
1618 relocateable = false;
1619 output_bfd = symbol->section->output_section->owner;
1621 ret = mips_elf_final_gp (output_bfd, symbol, relocateable,
1622 error_message, &gp);
1623 if (ret != bfd_reloc_ok)
1627 return gprel32_with_gp (abfd, symbol, reloc_entry, input_section,
1628 relocateable, data, gp);
1631 static bfd_reloc_status_type
1632 gprel32_with_gp (abfd, symbol, reloc_entry, input_section, relocateable, data,
1636 arelent *reloc_entry;
1637 asection *input_section;
1638 boolean relocateable;
1645 if (bfd_is_com_section (symbol->section))
1648 relocation = symbol->value;
1650 relocation += symbol->section->output_section->vma;
1651 relocation += symbol->section->output_offset;
1653 if (reloc_entry->address > input_section->_cooked_size)
1654 return bfd_reloc_outofrange;
1656 if (reloc_entry->howto->src_mask == 0)
1658 /* This case arises with the 64-bit MIPS ELF ABI. */
1662 val = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
1664 /* Set val to the offset into the section or symbol. */
1665 val += reloc_entry->addend;
1667 /* Adjust val for the final section location and GP value. If we
1668 are producing relocateable output, we don't want to do this for
1669 an external symbol. */
1671 || (symbol->flags & BSF_SECTION_SYM) != 0)
1672 val += relocation - gp;
1674 bfd_put_32 (abfd, val, (bfd_byte *) data + reloc_entry->address);
1677 reloc_entry->address += input_section->output_offset;
1679 return bfd_reloc_ok;
1682 /* Handle a 64 bit reloc in a 32 bit MIPS ELF file. These are
1683 generated when addresses are 64 bits. The upper 32 bits are a simple
1686 static bfd_reloc_status_type
1687 mips32_64bit_reloc (abfd, reloc_entry, symbol, data, input_section,
1688 output_bfd, error_message)
1690 arelent *reloc_entry;
1693 asection *input_section;
1695 char **error_message;
1697 bfd_reloc_status_type r;
1702 r = bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1703 input_section, output_bfd, error_message);
1704 if (r != bfd_reloc_continue)
1707 /* Do a normal 32 bit relocation on the lower 32 bits. */
1708 reloc32 = *reloc_entry;
1709 if (bfd_big_endian (abfd))
1710 reloc32.address += 4;
1711 reloc32.howto = &elf_mips_howto_table[R_MIPS_32];
1712 r = bfd_perform_relocation (abfd, &reloc32, data, input_section,
1713 output_bfd, error_message);
1715 /* Sign extend into the upper 32 bits. */
1716 val = bfd_get_32 (abfd, (bfd_byte *) data + reloc32.address);
1717 if ((val & 0x80000000) != 0)
1721 addr = reloc_entry->address;
1722 if (bfd_little_endian (abfd))
1724 bfd_put_32 (abfd, val, (bfd_byte *) data + addr);
1729 /* Handle a mips16 jump. */
1731 static bfd_reloc_status_type
1732 mips16_jump_reloc (abfd, reloc_entry, symbol, data, input_section,
1733 output_bfd, error_message)
1734 bfd *abfd ATTRIBUTE_UNUSED;
1735 arelent *reloc_entry;
1737 PTR data ATTRIBUTE_UNUSED;
1738 asection *input_section;
1740 char **error_message ATTRIBUTE_UNUSED;
1742 if (output_bfd != (bfd *) NULL
1743 && (symbol->flags & BSF_SECTION_SYM) == 0
1744 && reloc_entry->addend == 0)
1746 reloc_entry->address += input_section->output_offset;
1747 return bfd_reloc_ok;
1752 static boolean warned;
1755 (*_bfd_error_handler)
1756 (_("Linking mips16 objects into %s format is not supported"),
1757 bfd_get_target (input_section->output_section->owner));
1761 return bfd_reloc_undefined;
1764 /* Handle a mips16 GP relative reloc. */
1766 static bfd_reloc_status_type
1767 mips16_gprel_reloc (abfd, reloc_entry, symbol, data, input_section,
1768 output_bfd, error_message)
1770 arelent *reloc_entry;
1773 asection *input_section;
1775 char **error_message;
1777 boolean relocateable;
1778 bfd_reloc_status_type ret;
1780 unsigned short extend, insn;
1781 unsigned long final;
1783 /* If we're relocating, and this is an external symbol with no
1784 addend, we don't want to change anything. We will only have an
1785 addend if this is a newly created reloc, not read from an ELF
1787 if (output_bfd != NULL
1788 && (symbol->flags & BSF_SECTION_SYM) == 0
1789 && reloc_entry->addend == 0)
1791 reloc_entry->address += input_section->output_offset;
1792 return bfd_reloc_ok;
1795 if (output_bfd != NULL)
1796 relocateable = true;
1799 relocateable = false;
1800 output_bfd = symbol->section->output_section->owner;
1803 ret = mips_elf_final_gp (output_bfd, symbol, relocateable, error_message,
1805 if (ret != bfd_reloc_ok)
1808 if (reloc_entry->address > input_section->_cooked_size)
1809 return bfd_reloc_outofrange;
1811 /* Pick up the mips16 extend instruction and the real instruction. */
1812 extend = bfd_get_16 (abfd, (bfd_byte *) data + reloc_entry->address);
1813 insn = bfd_get_16 (abfd, (bfd_byte *) data + reloc_entry->address + 2);
1815 /* Stuff the current addend back as a 32 bit value, do the usual
1816 relocation, and then clean up. */
1818 (((extend & 0x1f) << 11)
1821 (bfd_byte *) data + reloc_entry->address);
1823 ret = gprel16_with_gp (abfd, symbol, reloc_entry, input_section,
1824 relocateable, data, gp);
1826 final = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
1829 | ((final >> 11) & 0x1f)
1831 (bfd_byte *) data + reloc_entry->address);
1835 (bfd_byte *) data + reloc_entry->address + 2);
1840 /* Return the ISA for a MIPS e_flags value. */
1843 elf_mips_isa (flags)
1846 switch (flags & EF_MIPS_ARCH)
1858 case E_MIPS_ARCH_32:
1860 case E_MIPS_ARCH_64:
1866 /* Return the MACH for a MIPS e_flags value. */
1869 elf_mips_mach (flags)
1872 switch (flags & EF_MIPS_MACH)
1874 case E_MIPS_MACH_3900:
1875 return bfd_mach_mips3900;
1877 case E_MIPS_MACH_4010:
1878 return bfd_mach_mips4010;
1880 case E_MIPS_MACH_4100:
1881 return bfd_mach_mips4100;
1883 case E_MIPS_MACH_4111:
1884 return bfd_mach_mips4111;
1886 case E_MIPS_MACH_4650:
1887 return bfd_mach_mips4650;
1889 case E_MIPS_MACH_SB1:
1890 return bfd_mach_mips_sb1;
1893 switch (flags & EF_MIPS_ARCH)
1897 return bfd_mach_mips3000;
1901 return bfd_mach_mips6000;
1905 return bfd_mach_mips4000;
1909 return bfd_mach_mips8000;
1913 return bfd_mach_mips5;
1916 case E_MIPS_ARCH_32:
1917 return bfd_mach_mipsisa32;
1920 case E_MIPS_ARCH_64:
1921 return bfd_mach_mipsisa64;
1929 /* Return printable name for ABI. */
1931 static INLINE char *
1932 elf_mips_abi_name (abfd)
1937 flags = elf_elfheader (abfd)->e_flags;
1938 switch (flags & EF_MIPS_ABI)
1941 if (ABI_N32_P (abfd))
1943 else if (ABI_64_P (abfd))
1947 case E_MIPS_ABI_O32:
1949 case E_MIPS_ABI_O64:
1951 case E_MIPS_ABI_EABI32:
1953 case E_MIPS_ABI_EABI64:
1956 return "unknown abi";
1960 /* A mapping from BFD reloc types to MIPS ELF reloc types. */
1962 struct elf_reloc_map {
1963 bfd_reloc_code_real_type bfd_reloc_val;
1964 enum elf_mips_reloc_type elf_reloc_val;
1967 static CONST struct elf_reloc_map mips_reloc_map[] =
1969 { BFD_RELOC_NONE, R_MIPS_NONE, },
1970 { BFD_RELOC_16, R_MIPS_16 },
1971 { BFD_RELOC_32, R_MIPS_32 },
1972 { BFD_RELOC_64, R_MIPS_64 },
1973 { BFD_RELOC_MIPS_JMP, R_MIPS_26 },
1974 { BFD_RELOC_HI16_S, R_MIPS_HI16 },
1975 { BFD_RELOC_LO16, R_MIPS_LO16 },
1976 { BFD_RELOC_MIPS_GPREL, R_MIPS_GPREL16 },
1977 { BFD_RELOC_MIPS_LITERAL, R_MIPS_LITERAL },
1978 { BFD_RELOC_MIPS_GOT16, R_MIPS_GOT16 },
1979 { BFD_RELOC_16_PCREL, R_MIPS_PC16 },
1980 { BFD_RELOC_MIPS_CALL16, R_MIPS_CALL16 },
1981 { BFD_RELOC_MIPS_GPREL32, R_MIPS_GPREL32 },
1982 { BFD_RELOC_MIPS_GOT_HI16, R_MIPS_GOT_HI16 },
1983 { BFD_RELOC_MIPS_GOT_LO16, R_MIPS_GOT_LO16 },
1984 { BFD_RELOC_MIPS_CALL_HI16, R_MIPS_CALL_HI16 },
1985 { BFD_RELOC_MIPS_CALL_LO16, R_MIPS_CALL_LO16 },
1986 { BFD_RELOC_MIPS_SUB, R_MIPS_SUB },
1987 { BFD_RELOC_MIPS_GOT_PAGE, R_MIPS_GOT_PAGE },
1988 { BFD_RELOC_MIPS_GOT_OFST, R_MIPS_GOT_OFST },
1989 { BFD_RELOC_MIPS_GOT_DISP, R_MIPS_GOT_DISP }
1992 /* Given a BFD reloc type, return a howto structure. */
1994 static reloc_howto_type *
1995 bfd_elf32_bfd_reloc_type_lookup (abfd, code)
1997 bfd_reloc_code_real_type code;
2001 for (i = 0; i < sizeof (mips_reloc_map) / sizeof (struct elf_reloc_map); i++)
2003 if (mips_reloc_map[i].bfd_reloc_val == code)
2004 return &elf_mips_howto_table[(int) mips_reloc_map[i].elf_reloc_val];
2010 bfd_set_error (bfd_error_bad_value);
2013 case BFD_RELOC_CTOR:
2014 /* We need to handle BFD_RELOC_CTOR specially.
2015 Select the right relocation (R_MIPS_32 or R_MIPS_64) based on the
2016 size of addresses on this architecture. */
2017 if (bfd_arch_bits_per_address (abfd) == 32)
2018 return &elf_mips_howto_table[(int) R_MIPS_32];
2020 return &elf_mips_ctor64_howto;
2022 case BFD_RELOC_MIPS16_JMP:
2023 return &elf_mips16_jump_howto;
2024 case BFD_RELOC_MIPS16_GPREL:
2025 return &elf_mips16_gprel_howto;
2026 case BFD_RELOC_VTABLE_INHERIT:
2027 return &elf_mips_gnu_vtinherit_howto;
2028 case BFD_RELOC_VTABLE_ENTRY:
2029 return &elf_mips_gnu_vtentry_howto;
2030 case BFD_RELOC_PCREL_HI16_S:
2031 return &elf_mips_gnu_rel_hi16;
2032 case BFD_RELOC_PCREL_LO16:
2033 return &elf_mips_gnu_rel_lo16;
2034 case BFD_RELOC_16_PCREL_S2:
2035 return &elf_mips_gnu_rel16_s2;
2036 case BFD_RELOC_64_PCREL:
2037 return &elf_mips_gnu_pcrel64;
2038 case BFD_RELOC_32_PCREL:
2039 return &elf_mips_gnu_pcrel32;
2043 /* Given a MIPS Elf32_Internal_Rel, fill in an arelent structure. */
2045 static reloc_howto_type *
2046 mips_rtype_to_howto (r_type)
2047 unsigned int r_type;
2052 return &elf_mips16_jump_howto;
2054 case R_MIPS16_GPREL:
2055 return &elf_mips16_gprel_howto;
2057 case R_MIPS_GNU_VTINHERIT:
2058 return &elf_mips_gnu_vtinherit_howto;
2060 case R_MIPS_GNU_VTENTRY:
2061 return &elf_mips_gnu_vtentry_howto;
2063 case R_MIPS_GNU_REL_HI16:
2064 return &elf_mips_gnu_rel_hi16;
2066 case R_MIPS_GNU_REL_LO16:
2067 return &elf_mips_gnu_rel_lo16;
2069 case R_MIPS_GNU_REL16_S2:
2070 return &elf_mips_gnu_rel16_s2;
2073 return &elf_mips_gnu_pcrel64;
2076 return &elf_mips_gnu_pcrel32;
2080 BFD_ASSERT (r_type < (unsigned int) R_MIPS_max);
2081 return &elf_mips_howto_table[r_type];
2086 /* Given a MIPS Elf32_Internal_Rel, fill in an arelent structure. */
2089 mips_info_to_howto_rel (abfd, cache_ptr, dst)
2092 Elf32_Internal_Rel *dst;
2094 unsigned int r_type;
2096 r_type = ELF32_R_TYPE (dst->r_info);
2097 cache_ptr->howto = mips_rtype_to_howto (r_type);
2099 /* The addend for a GPREL16 or LITERAL relocation comes from the GP
2100 value for the object file. We get the addend now, rather than
2101 when we do the relocation, because the symbol manipulations done
2102 by the linker may cause us to lose track of the input BFD. */
2103 if (((*cache_ptr->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0
2104 && (r_type == (unsigned int) R_MIPS_GPREL16
2105 || r_type == (unsigned int) R_MIPS_LITERAL))
2106 cache_ptr->addend = elf_gp (abfd);
2109 /* Given a MIPS Elf32_Internal_Rela, fill in an arelent structure. */
2112 mips_info_to_howto_rela (abfd, cache_ptr, dst)
2115 Elf32_Internal_Rela *dst;
2117 /* Since an Elf32_Internal_Rel is an initial prefix of an
2118 Elf32_Internal_Rela, we can just use mips_info_to_howto_rel
2120 mips_info_to_howto_rel (abfd, cache_ptr, (Elf32_Internal_Rel *) dst);
2122 /* If we ever need to do any extra processing with dst->r_addend
2123 (the field omitted in an Elf32_Internal_Rel) we can do it here. */
2126 /* A .reginfo section holds a single Elf32_RegInfo structure. These
2127 routines swap this structure in and out. They are used outside of
2128 BFD, so they are globally visible. */
2131 bfd_mips_elf32_swap_reginfo_in (abfd, ex, in)
2133 const Elf32_External_RegInfo *ex;
2136 in->ri_gprmask = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_gprmask);
2137 in->ri_cprmask[0] = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_cprmask[0]);
2138 in->ri_cprmask[1] = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_cprmask[1]);
2139 in->ri_cprmask[2] = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_cprmask[2]);
2140 in->ri_cprmask[3] = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_cprmask[3]);
2141 in->ri_gp_value = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_gp_value);
2145 bfd_mips_elf32_swap_reginfo_out (abfd, in, ex)
2147 const Elf32_RegInfo *in;
2148 Elf32_External_RegInfo *ex;
2150 bfd_h_put_32 (abfd, (bfd_vma) in->ri_gprmask,
2151 (bfd_byte *) ex->ri_gprmask);
2152 bfd_h_put_32 (abfd, (bfd_vma) in->ri_cprmask[0],
2153 (bfd_byte *) ex->ri_cprmask[0]);
2154 bfd_h_put_32 (abfd, (bfd_vma) in->ri_cprmask[1],
2155 (bfd_byte *) ex->ri_cprmask[1]);
2156 bfd_h_put_32 (abfd, (bfd_vma) in->ri_cprmask[2],
2157 (bfd_byte *) ex->ri_cprmask[2]);
2158 bfd_h_put_32 (abfd, (bfd_vma) in->ri_cprmask[3],
2159 (bfd_byte *) ex->ri_cprmask[3]);
2160 bfd_h_put_32 (abfd, (bfd_vma) in->ri_gp_value,
2161 (bfd_byte *) ex->ri_gp_value);
2164 /* In the 64 bit ABI, the .MIPS.options section holds register
2165 information in an Elf64_Reginfo structure. These routines swap
2166 them in and out. They are globally visible because they are used
2167 outside of BFD. These routines are here so that gas can call them
2168 without worrying about whether the 64 bit ABI has been included. */
2171 bfd_mips_elf64_swap_reginfo_in (abfd, ex, in)
2173 const Elf64_External_RegInfo *ex;
2174 Elf64_Internal_RegInfo *in;
2176 in->ri_gprmask = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_gprmask);
2177 in->ri_pad = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_pad);
2178 in->ri_cprmask[0] = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_cprmask[0]);
2179 in->ri_cprmask[1] = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_cprmask[1]);
2180 in->ri_cprmask[2] = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_cprmask[2]);
2181 in->ri_cprmask[3] = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_cprmask[3]);
2182 in->ri_gp_value = bfd_h_get_64 (abfd, (bfd_byte *) ex->ri_gp_value);
2186 bfd_mips_elf64_swap_reginfo_out (abfd, in, ex)
2188 const Elf64_Internal_RegInfo *in;
2189 Elf64_External_RegInfo *ex;
2191 bfd_h_put_32 (abfd, (bfd_vma) in->ri_gprmask,
2192 (bfd_byte *) ex->ri_gprmask);
2193 bfd_h_put_32 (abfd, (bfd_vma) in->ri_pad,
2194 (bfd_byte *) ex->ri_pad);
2195 bfd_h_put_32 (abfd, (bfd_vma) in->ri_cprmask[0],
2196 (bfd_byte *) ex->ri_cprmask[0]);
2197 bfd_h_put_32 (abfd, (bfd_vma) in->ri_cprmask[1],
2198 (bfd_byte *) ex->ri_cprmask[1]);
2199 bfd_h_put_32 (abfd, (bfd_vma) in->ri_cprmask[2],
2200 (bfd_byte *) ex->ri_cprmask[2]);
2201 bfd_h_put_32 (abfd, (bfd_vma) in->ri_cprmask[3],
2202 (bfd_byte *) ex->ri_cprmask[3]);
2203 bfd_h_put_64 (abfd, (bfd_vma) in->ri_gp_value,
2204 (bfd_byte *) ex->ri_gp_value);
2207 /* Swap an entry in a .gptab section. Note that these routines rely
2208 on the equivalence of the two elements of the union. */
2211 bfd_mips_elf32_swap_gptab_in (abfd, ex, in)
2213 const Elf32_External_gptab *ex;
2216 in->gt_entry.gt_g_value = bfd_h_get_32 (abfd, ex->gt_entry.gt_g_value);
2217 in->gt_entry.gt_bytes = bfd_h_get_32 (abfd, ex->gt_entry.gt_bytes);
2221 bfd_mips_elf32_swap_gptab_out (abfd, in, ex)
2223 const Elf32_gptab *in;
2224 Elf32_External_gptab *ex;
2226 bfd_h_put_32 (abfd, (bfd_vma) in->gt_entry.gt_g_value,
2227 ex->gt_entry.gt_g_value);
2228 bfd_h_put_32 (abfd, (bfd_vma) in->gt_entry.gt_bytes,
2229 ex->gt_entry.gt_bytes);
2233 bfd_elf32_swap_compact_rel_out (abfd, in, ex)
2235 const Elf32_compact_rel *in;
2236 Elf32_External_compact_rel *ex;
2238 bfd_h_put_32 (abfd, (bfd_vma) in->id1, ex->id1);
2239 bfd_h_put_32 (abfd, (bfd_vma) in->num, ex->num);
2240 bfd_h_put_32 (abfd, (bfd_vma) in->id2, ex->id2);
2241 bfd_h_put_32 (abfd, (bfd_vma) in->offset, ex->offset);
2242 bfd_h_put_32 (abfd, (bfd_vma) in->reserved0, ex->reserved0);
2243 bfd_h_put_32 (abfd, (bfd_vma) in->reserved1, ex->reserved1);
2247 bfd_elf32_swap_crinfo_out (abfd, in, ex)
2249 const Elf32_crinfo *in;
2250 Elf32_External_crinfo *ex;
2254 l = (((in->ctype & CRINFO_CTYPE) << CRINFO_CTYPE_SH)
2255 | ((in->rtype & CRINFO_RTYPE) << CRINFO_RTYPE_SH)
2256 | ((in->dist2to & CRINFO_DIST2TO) << CRINFO_DIST2TO_SH)
2257 | ((in->relvaddr & CRINFO_RELVADDR) << CRINFO_RELVADDR_SH));
2258 bfd_h_put_32 (abfd, (bfd_vma) l, ex->info);
2259 bfd_h_put_32 (abfd, (bfd_vma) in->konst, ex->konst);
2260 bfd_h_put_32 (abfd, (bfd_vma) in->vaddr, ex->vaddr);
2263 /* Swap in an options header. */
2266 bfd_mips_elf_swap_options_in (abfd, ex, in)
2268 const Elf_External_Options *ex;
2269 Elf_Internal_Options *in;
2271 in->kind = bfd_h_get_8 (abfd, ex->kind);
2272 in->size = bfd_h_get_8 (abfd, ex->size);
2273 in->section = bfd_h_get_16 (abfd, ex->section);
2274 in->info = bfd_h_get_32 (abfd, ex->info);
2277 /* Swap out an options header. */
2280 bfd_mips_elf_swap_options_out (abfd, in, ex)
2282 const Elf_Internal_Options *in;
2283 Elf_External_Options *ex;
2285 bfd_h_put_8 (abfd, in->kind, ex->kind);
2286 bfd_h_put_8 (abfd, in->size, ex->size);
2287 bfd_h_put_16 (abfd, in->section, ex->section);
2288 bfd_h_put_32 (abfd, in->info, ex->info);
2291 /* Swap in an MSYM entry. */
2294 bfd_mips_elf_swap_msym_in (abfd, ex, in)
2296 const Elf32_External_Msym *ex;
2297 Elf32_Internal_Msym *in;
2299 in->ms_hash_value = bfd_h_get_32 (abfd, ex->ms_hash_value);
2300 in->ms_info = bfd_h_get_32 (abfd, ex->ms_info);
2303 /* Swap out an MSYM entry. */
2306 bfd_mips_elf_swap_msym_out (abfd, in, ex)
2308 const Elf32_Internal_Msym *in;
2309 Elf32_External_Msym *ex;
2311 bfd_h_put_32 (abfd, in->ms_hash_value, ex->ms_hash_value);
2312 bfd_h_put_32 (abfd, in->ms_info, ex->ms_info);
2315 /* Determine whether a symbol is global for the purposes of splitting
2316 the symbol table into global symbols and local symbols. At least
2317 on Irix 5, this split must be between section symbols and all other
2318 symbols. On most ELF targets the split is between static symbols
2319 and externally visible symbols. */
2322 mips_elf_sym_is_global (abfd, sym)
2323 bfd *abfd ATTRIBUTE_UNUSED;
2326 if (SGI_COMPAT (abfd))
2327 return (sym->flags & BSF_SECTION_SYM) == 0;
2329 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
2330 || bfd_is_und_section (bfd_get_section (sym))
2331 || bfd_is_com_section (bfd_get_section (sym)));
2334 /* Set the right machine number for a MIPS ELF file. This is used for
2335 both the 32-bit and the 64-bit ABI. */
2338 _bfd_mips_elf_object_p (abfd)
2341 /* Irix 5 and 6 is broken. Object file symbol tables are not always
2342 sorted correctly such that local symbols precede global symbols,
2343 and the sh_info field in the symbol table is not always right. */
2344 if (SGI_COMPAT(abfd))
2345 elf_bad_symtab (abfd) = true;
2347 bfd_default_set_arch_mach (abfd, bfd_arch_mips,
2348 elf_mips_mach (elf_elfheader (abfd)->e_flags));
2352 /* The final processing done just before writing out a MIPS ELF object
2353 file. This gets the MIPS architecture right based on the machine
2354 number. This is used by both the 32-bit and the 64-bit ABI. */
2357 _bfd_mips_elf_final_write_processing (abfd, linker)
2359 boolean linker ATTRIBUTE_UNUSED;
2363 Elf_Internal_Shdr **hdrpp;
2367 switch (bfd_get_mach (abfd))
2370 case bfd_mach_mips3000:
2371 val = E_MIPS_ARCH_1;
2374 case bfd_mach_mips3900:
2375 val = E_MIPS_ARCH_1 | E_MIPS_MACH_3900;
2378 case bfd_mach_mips6000:
2379 val = E_MIPS_ARCH_2;
2382 case bfd_mach_mips4000:
2383 case bfd_mach_mips4300:
2384 case bfd_mach_mips4400:
2385 case bfd_mach_mips4600:
2386 val = E_MIPS_ARCH_3;
2389 case bfd_mach_mips4010:
2390 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4010;
2393 case bfd_mach_mips4100:
2394 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4100;
2397 case bfd_mach_mips4111:
2398 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4111;
2401 case bfd_mach_mips4650:
2402 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4650;
2405 case bfd_mach_mips5000:
2406 case bfd_mach_mips8000:
2407 case bfd_mach_mips10000:
2408 case bfd_mach_mips12000:
2409 val = E_MIPS_ARCH_4;
2412 case bfd_mach_mips5:
2413 val = E_MIPS_ARCH_5;
2416 case bfd_mach_mips_sb1:
2417 val = E_MIPS_ARCH_64 | E_MIPS_MACH_SB1;
2420 case bfd_mach_mipsisa32:
2421 val = E_MIPS_ARCH_32;
2424 case bfd_mach_mipsisa64:
2425 val = E_MIPS_ARCH_64;
2428 elf_elfheader (abfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
2429 elf_elfheader (abfd)->e_flags |= val;
2431 /* Set the sh_info field for .gptab sections and other appropriate
2432 info for each special section. */
2433 for (i = 1, hdrpp = elf_elfsections (abfd) + 1;
2434 i < elf_elfheader (abfd)->e_shnum;
2437 switch ((*hdrpp)->sh_type)
2440 case SHT_MIPS_LIBLIST:
2441 sec = bfd_get_section_by_name (abfd, ".dynstr");
2443 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
2446 case SHT_MIPS_GPTAB:
2447 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
2448 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
2449 BFD_ASSERT (name != NULL
2450 && strncmp (name, ".gptab.", sizeof ".gptab." - 1) == 0);
2451 sec = bfd_get_section_by_name (abfd, name + sizeof ".gptab" - 1);
2452 BFD_ASSERT (sec != NULL);
2453 (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
2456 case SHT_MIPS_CONTENT:
2457 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
2458 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
2459 BFD_ASSERT (name != NULL
2460 && strncmp (name, ".MIPS.content",
2461 sizeof ".MIPS.content" - 1) == 0);
2462 sec = bfd_get_section_by_name (abfd,
2463 name + sizeof ".MIPS.content" - 1);
2464 BFD_ASSERT (sec != NULL);
2465 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
2468 case SHT_MIPS_SYMBOL_LIB:
2469 sec = bfd_get_section_by_name (abfd, ".dynsym");
2471 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
2472 sec = bfd_get_section_by_name (abfd, ".liblist");
2474 (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
2477 case SHT_MIPS_EVENTS:
2478 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
2479 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
2480 BFD_ASSERT (name != NULL);
2481 if (strncmp (name, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0)
2482 sec = bfd_get_section_by_name (abfd,
2483 name + sizeof ".MIPS.events" - 1);
2486 BFD_ASSERT (strncmp (name, ".MIPS.post_rel",
2487 sizeof ".MIPS.post_rel" - 1) == 0);
2488 sec = bfd_get_section_by_name (abfd,
2490 + sizeof ".MIPS.post_rel" - 1));
2492 BFD_ASSERT (sec != NULL);
2493 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
2500 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
2503 _bfd_mips_elf_set_private_flags (abfd, flags)
2507 BFD_ASSERT (!elf_flags_init (abfd)
2508 || elf_elfheader (abfd)->e_flags == flags);
2510 elf_elfheader (abfd)->e_flags = flags;
2511 elf_flags_init (abfd) = true;
2515 /* Copy backend specific data from one object module to another */
2518 _bfd_mips_elf_copy_private_bfd_data (ibfd, obfd)
2522 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2523 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2526 BFD_ASSERT (!elf_flags_init (obfd)
2527 || (elf_elfheader (obfd)->e_flags
2528 == elf_elfheader (ibfd)->e_flags));
2530 elf_gp (obfd) = elf_gp (ibfd);
2531 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
2532 elf_flags_init (obfd) = true;
2536 /* Merge backend specific data from an object file to the output
2537 object file when linking. */
2540 _bfd_mips_elf_merge_private_bfd_data (ibfd, obfd)
2547 boolean null_input_bfd = true;
2550 /* Check if we have the same endianess */
2551 if (_bfd_generic_verify_endian_match (ibfd, obfd) == false)
2554 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2555 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2558 new_flags = elf_elfheader (ibfd)->e_flags;
2559 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_NOREORDER;
2560 old_flags = elf_elfheader (obfd)->e_flags;
2562 if (! elf_flags_init (obfd))
2564 elf_flags_init (obfd) = true;
2565 elf_elfheader (obfd)->e_flags = new_flags;
2566 elf_elfheader (obfd)->e_ident[EI_CLASS]
2567 = elf_elfheader (ibfd)->e_ident[EI_CLASS];
2569 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2570 && bfd_get_arch_info (obfd)->the_default)
2572 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
2573 bfd_get_mach (ibfd)))
2580 /* Check flag compatibility. */
2582 new_flags &= ~EF_MIPS_NOREORDER;
2583 old_flags &= ~EF_MIPS_NOREORDER;
2585 if (new_flags == old_flags)
2588 /* Check to see if the input BFD actually contains any sections.
2589 If not, its flags may not have been initialised either, but it cannot
2590 actually cause any incompatibility. */
2591 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
2593 /* Ignore synthetic sections and empty .text, .data and .bss sections
2594 which are automatically generated by gas. */
2595 if (strcmp (sec->name, ".reginfo")
2596 && strcmp (sec->name, ".mdebug")
2597 && ((!strcmp (sec->name, ".text")
2598 || !strcmp (sec->name, ".data")
2599 || !strcmp (sec->name, ".bss"))
2600 && sec->_raw_size != 0))
2602 null_input_bfd = false;
2611 if ((new_flags & EF_MIPS_PIC) != (old_flags & EF_MIPS_PIC))
2613 new_flags &= ~EF_MIPS_PIC;
2614 old_flags &= ~EF_MIPS_PIC;
2615 (*_bfd_error_handler)
2616 (_("%s: linking PIC files with non-PIC files"),
2617 bfd_get_filename (ibfd));
2621 if ((new_flags & EF_MIPS_CPIC) != (old_flags & EF_MIPS_CPIC))
2623 new_flags &= ~EF_MIPS_CPIC;
2624 old_flags &= ~EF_MIPS_CPIC;
2625 (*_bfd_error_handler)
2626 (_("%s: linking abicalls files with non-abicalls files"),
2627 bfd_get_filename (ibfd));
2631 /* Compare the ISA's. */
2632 if ((new_flags & (EF_MIPS_ARCH | EF_MIPS_MACH))
2633 != (old_flags & (EF_MIPS_ARCH | EF_MIPS_MACH)))
2635 int new_mach = new_flags & EF_MIPS_MACH;
2636 int old_mach = old_flags & EF_MIPS_MACH;
2637 int new_isa = elf_mips_isa (new_flags);
2638 int old_isa = elf_mips_isa (old_flags);
2640 /* If either has no machine specified, just compare the general isa's.
2641 Some combinations of machines are ok, if the isa's match. */
2644 || new_mach == old_mach
2647 /* Don't warn about mixing code using 32-bit ISAs, or mixing code
2648 using 64-bit ISAs. They will normally use the same data sizes
2649 and calling conventions. */
2651 if (( (new_isa == 1 || new_isa == 2 || new_isa == 32)
2652 ^ (old_isa == 1 || old_isa == 2 || old_isa == 32)) != 0)
2654 (*_bfd_error_handler)
2655 (_("%s: ISA mismatch (-mips%d) with previous modules (-mips%d)"),
2656 bfd_get_filename (ibfd), new_isa, old_isa);
2663 (*_bfd_error_handler)
2664 (_("%s: ISA mismatch (%d) with previous modules (%d)"),
2665 bfd_get_filename (ibfd),
2666 elf_mips_mach (new_flags),
2667 elf_mips_mach (old_flags));
2671 new_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
2672 old_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
2675 /* Compare ABI's. The 64-bit ABI does not use EF_MIPS_ABI. But, it
2676 does set EI_CLASS differently from any 32-bit ABI. */
2677 if ((new_flags & EF_MIPS_ABI) != (old_flags & EF_MIPS_ABI)
2678 || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
2679 != elf_elfheader (obfd)->e_ident[EI_CLASS]))
2681 /* Only error if both are set (to different values). */
2682 if (((new_flags & EF_MIPS_ABI) && (old_flags & EF_MIPS_ABI))
2683 || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
2684 != elf_elfheader (obfd)->e_ident[EI_CLASS]))
2686 (*_bfd_error_handler)
2687 (_("%s: ABI mismatch: linking %s module with previous %s modules"),
2688 bfd_get_filename (ibfd),
2689 elf_mips_abi_name (ibfd),
2690 elf_mips_abi_name (obfd));
2693 new_flags &= ~EF_MIPS_ABI;
2694 old_flags &= ~EF_MIPS_ABI;
2697 /* Warn about any other mismatches */
2698 if (new_flags != old_flags)
2700 (*_bfd_error_handler)
2701 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
2702 bfd_get_filename (ibfd), (unsigned long) new_flags,
2703 (unsigned long) old_flags);
2709 bfd_set_error (bfd_error_bad_value);
2717 _bfd_mips_elf_print_private_bfd_data (abfd, ptr)
2721 FILE *file = (FILE *) ptr;
2723 BFD_ASSERT (abfd != NULL && ptr != NULL);
2725 /* Print normal ELF private data. */
2726 _bfd_elf_print_private_bfd_data (abfd, ptr);
2728 /* xgettext:c-format */
2729 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
2731 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32)
2732 fprintf (file, _(" [abi=O32]"));
2733 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O64)
2734 fprintf (file, _(" [abi=O64]"));
2735 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32)
2736 fprintf (file, _(" [abi=EABI32]"));
2737 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
2738 fprintf (file, _(" [abi=EABI64]"));
2739 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI))
2740 fprintf (file, _(" [abi unknown]"));
2741 else if (ABI_N32_P (abfd))
2742 fprintf (file, _(" [abi=N32]"));
2743 else if (ABI_64_P (abfd))
2744 fprintf (file, _(" [abi=64]"));
2746 fprintf (file, _(" [no abi set]"));
2748 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
2749 fprintf (file, _(" [mips1]"));
2750 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
2751 fprintf (file, _(" [mips2]"));
2752 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
2753 fprintf (file, _(" [mips3]"));
2754 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
2755 fprintf (file, _(" [mips4]"));
2756 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5)
2757 fprintf (file, _ (" [mips5]"));
2758 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32)
2759 fprintf (file, _ (" [mips32]"));
2760 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64)
2761 fprintf (file, _ (" [mips64]"));
2763 fprintf (file, _(" [unknown ISA]"));
2765 if (elf_elfheader (abfd)->e_flags & EF_MIPS_32BITMODE)
2766 fprintf (file, _(" [32bitmode]"));
2768 fprintf (file, _(" [not 32bitmode]"));
2775 /* Handle a MIPS specific section when reading an object file. This
2776 is called when elfcode.h finds a section with an unknown type.
2777 This routine supports both the 32-bit and 64-bit ELF ABI.
2779 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
2783 _bfd_mips_elf_section_from_shdr (abfd, hdr, name)
2785 Elf_Internal_Shdr *hdr;
2790 /* There ought to be a place to keep ELF backend specific flags, but
2791 at the moment there isn't one. We just keep track of the
2792 sections by their name, instead. Fortunately, the ABI gives
2793 suggested names for all the MIPS specific sections, so we will
2794 probably get away with this. */
2795 switch (hdr->sh_type)
2797 case SHT_MIPS_LIBLIST:
2798 if (strcmp (name, ".liblist") != 0)
2802 if (strcmp (name, MIPS_ELF_MSYM_SECTION_NAME (abfd)) != 0)
2805 case SHT_MIPS_CONFLICT:
2806 if (strcmp (name, ".conflict") != 0)
2809 case SHT_MIPS_GPTAB:
2810 if (strncmp (name, ".gptab.", sizeof ".gptab." - 1) != 0)
2813 case SHT_MIPS_UCODE:
2814 if (strcmp (name, ".ucode") != 0)
2817 case SHT_MIPS_DEBUG:
2818 if (strcmp (name, ".mdebug") != 0)
2820 flags = SEC_DEBUGGING;
2822 case SHT_MIPS_REGINFO:
2823 if (strcmp (name, ".reginfo") != 0
2824 || hdr->sh_size != sizeof (Elf32_External_RegInfo))
2826 flags = (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_SIZE);
2828 case SHT_MIPS_IFACE:
2829 if (strcmp (name, ".MIPS.interfaces") != 0)
2832 case SHT_MIPS_CONTENT:
2833 if (strncmp (name, ".MIPS.content", sizeof ".MIPS.content" - 1) != 0)
2836 case SHT_MIPS_OPTIONS:
2837 if (strcmp (name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) != 0)
2840 case SHT_MIPS_DWARF:
2841 if (strncmp (name, ".debug_", sizeof ".debug_" - 1) != 0)
2844 case SHT_MIPS_SYMBOL_LIB:
2845 if (strcmp (name, ".MIPS.symlib") != 0)
2848 case SHT_MIPS_EVENTS:
2849 if (strncmp (name, ".MIPS.events", sizeof ".MIPS.events" - 1) != 0
2850 && strncmp (name, ".MIPS.post_rel",
2851 sizeof ".MIPS.post_rel" - 1) != 0)
2858 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
2863 if (! bfd_set_section_flags (abfd, hdr->bfd_section,
2864 (bfd_get_section_flags (abfd,
2870 /* FIXME: We should record sh_info for a .gptab section. */
2872 /* For a .reginfo section, set the gp value in the tdata information
2873 from the contents of this section. We need the gp value while
2874 processing relocs, so we just get it now. The .reginfo section
2875 is not used in the 64-bit MIPS ELF ABI. */
2876 if (hdr->sh_type == SHT_MIPS_REGINFO)
2878 Elf32_External_RegInfo ext;
2881 if (! bfd_get_section_contents (abfd, hdr->bfd_section, (PTR) &ext,
2882 (file_ptr) 0, sizeof ext))
2884 bfd_mips_elf32_swap_reginfo_in (abfd, &ext, &s);
2885 elf_gp (abfd) = s.ri_gp_value;
2888 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
2889 set the gp value based on what we find. We may see both
2890 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
2891 they should agree. */
2892 if (hdr->sh_type == SHT_MIPS_OPTIONS)
2894 bfd_byte *contents, *l, *lend;
2896 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
2897 if (contents == NULL)
2899 if (! bfd_get_section_contents (abfd, hdr->bfd_section, contents,
2900 (file_ptr) 0, hdr->sh_size))
2906 lend = contents + hdr->sh_size;
2907 while (l + sizeof (Elf_External_Options) <= lend)
2909 Elf_Internal_Options intopt;
2911 bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
2913 if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
2915 Elf64_Internal_RegInfo intreg;
2917 bfd_mips_elf64_swap_reginfo_in
2919 ((Elf64_External_RegInfo *)
2920 (l + sizeof (Elf_External_Options))),
2922 elf_gp (abfd) = intreg.ri_gp_value;
2924 else if (intopt.kind == ODK_REGINFO)
2926 Elf32_RegInfo intreg;
2928 bfd_mips_elf32_swap_reginfo_in
2930 ((Elf32_External_RegInfo *)
2931 (l + sizeof (Elf_External_Options))),
2933 elf_gp (abfd) = intreg.ri_gp_value;
2943 /* Set the correct type for a MIPS ELF section. We do this by the
2944 section name, which is a hack, but ought to work. This routine is
2945 used by both the 32-bit and the 64-bit ABI. */
2948 _bfd_mips_elf_fake_sections (abfd, hdr, sec)
2950 Elf32_Internal_Shdr *hdr;
2953 register const char *name;
2955 name = bfd_get_section_name (abfd, sec);
2957 if (strcmp (name, ".liblist") == 0)
2959 hdr->sh_type = SHT_MIPS_LIBLIST;
2960 hdr->sh_info = sec->_raw_size / sizeof (Elf32_Lib);
2961 /* The sh_link field is set in final_write_processing. */
2963 else if (strcmp (name, ".conflict") == 0)
2964 hdr->sh_type = SHT_MIPS_CONFLICT;
2965 else if (strncmp (name, ".gptab.", sizeof ".gptab." - 1) == 0)
2967 hdr->sh_type = SHT_MIPS_GPTAB;
2968 hdr->sh_entsize = sizeof (Elf32_External_gptab);
2969 /* The sh_info field is set in final_write_processing. */
2971 else if (strcmp (name, ".ucode") == 0)
2972 hdr->sh_type = SHT_MIPS_UCODE;
2973 else if (strcmp (name, ".mdebug") == 0)
2975 hdr->sh_type = SHT_MIPS_DEBUG;
2976 /* In a shared object on Irix 5.3, the .mdebug section has an
2977 entsize of 0. FIXME: Does this matter? */
2978 if (SGI_COMPAT (abfd) && (abfd->flags & DYNAMIC) != 0)
2979 hdr->sh_entsize = 0;
2981 hdr->sh_entsize = 1;
2983 else if (strcmp (name, ".reginfo") == 0)
2985 hdr->sh_type = SHT_MIPS_REGINFO;
2986 /* In a shared object on Irix 5.3, the .reginfo section has an
2987 entsize of 0x18. FIXME: Does this matter? */
2988 if (SGI_COMPAT (abfd))
2990 if ((abfd->flags & DYNAMIC) != 0)
2991 hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
2993 hdr->sh_entsize = 1;
2996 hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
2998 else if (SGI_COMPAT (abfd)
2999 && (strcmp (name, ".hash") == 0
3000 || strcmp (name, ".dynamic") == 0
3001 || strcmp (name, ".dynstr") == 0))
3003 if (SGI_COMPAT (abfd))
3004 hdr->sh_entsize = 0;
3006 /* This isn't how the Irix 6 linker behaves. */
3007 hdr->sh_info = SIZEOF_MIPS_DYNSYM_SECNAMES;
3010 else if (strcmp (name, ".got") == 0
3011 || strcmp (name, MIPS_ELF_SRDATA_SECTION_NAME (abfd)) == 0
3012 || strcmp (name, ".sdata") == 0
3013 || strcmp (name, ".sbss") == 0
3014 || strcmp (name, ".lit4") == 0
3015 || strcmp (name, ".lit8") == 0)
3016 hdr->sh_flags |= SHF_MIPS_GPREL;
3017 else if (strcmp (name, ".MIPS.interfaces") == 0)
3019 hdr->sh_type = SHT_MIPS_IFACE;
3020 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
3022 else if (strncmp (name, ".MIPS.content", strlen (".MIPS.content")) == 0)
3024 hdr->sh_type = SHT_MIPS_CONTENT;
3025 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
3026 /* The sh_info field is set in final_write_processing. */
3028 else if (strcmp (name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) == 0)
3030 hdr->sh_type = SHT_MIPS_OPTIONS;
3031 hdr->sh_entsize = 1;
3032 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
3034 else if (strncmp (name, ".debug_", sizeof ".debug_" - 1) == 0)
3035 hdr->sh_type = SHT_MIPS_DWARF;
3036 else if (strcmp (name, ".MIPS.symlib") == 0)
3038 hdr->sh_type = SHT_MIPS_SYMBOL_LIB;
3039 /* The sh_link and sh_info fields are set in
3040 final_write_processing. */
3042 else if (strncmp (name, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0
3043 || strncmp (name, ".MIPS.post_rel",
3044 sizeof ".MIPS.post_rel" - 1) == 0)
3046 hdr->sh_type = SHT_MIPS_EVENTS;
3047 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
3048 /* The sh_link field is set in final_write_processing. */
3050 else if (strcmp (name, MIPS_ELF_MSYM_SECTION_NAME (abfd)) == 0)
3052 hdr->sh_type = SHT_MIPS_MSYM;
3053 hdr->sh_flags |= SHF_ALLOC;
3054 hdr->sh_entsize = 8;
3057 /* The generic elf_fake_sections will set up REL_HDR using the
3058 default kind of relocations. But, we may actually need both
3059 kinds of relocations, so we set up the second header here. */
3060 if ((sec->flags & SEC_RELOC) != 0)
3062 struct bfd_elf_section_data *esd;
3064 esd = elf_section_data (sec);
3065 BFD_ASSERT (esd->rel_hdr2 == NULL);
3067 = (Elf_Internal_Shdr *) bfd_zalloc (abfd, sizeof (Elf_Internal_Shdr));
3070 _bfd_elf_init_reloc_shdr (abfd, esd->rel_hdr2, sec,
3071 !elf_section_data (sec)->use_rela_p);
3077 /* Given a BFD section, try to locate the corresponding ELF section
3078 index. This is used by both the 32-bit and the 64-bit ABI.
3079 Actually, it's not clear to me that the 64-bit ABI supports these,
3080 but for non-PIC objects we will certainly want support for at least
3081 the .scommon section. */
3084 _bfd_mips_elf_section_from_bfd_section (abfd, hdr, sec, retval)
3085 bfd *abfd ATTRIBUTE_UNUSED;
3086 Elf_Internal_Shdr *hdr ATTRIBUTE_UNUSED;
3090 if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
3092 *retval = SHN_MIPS_SCOMMON;
3095 if (strcmp (bfd_get_section_name (abfd, sec), ".acommon") == 0)
3097 *retval = SHN_MIPS_ACOMMON;
3103 /* When are writing out the .options or .MIPS.options section,
3104 remember the bytes we are writing out, so that we can install the
3105 GP value in the section_processing routine. */
3108 _bfd_mips_elf_set_section_contents (abfd, section, location, offset, count)
3113 bfd_size_type count;
3115 if (strcmp (section->name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) == 0)
3119 if (elf_section_data (section) == NULL)
3121 section->used_by_bfd =
3122 (PTR) bfd_zalloc (abfd, sizeof (struct bfd_elf_section_data));
3123 if (elf_section_data (section) == NULL)
3126 c = (bfd_byte *) elf_section_data (section)->tdata;
3131 if (section->_cooked_size != 0)
3132 size = section->_cooked_size;
3134 size = section->_raw_size;
3135 c = (bfd_byte *) bfd_zalloc (abfd, size);
3138 elf_section_data (section)->tdata = (PTR) c;
3141 memcpy (c + offset, location, count);
3144 return _bfd_elf_set_section_contents (abfd, section, location, offset,
3148 /* Work over a section just before writing it out. This routine is
3149 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
3150 sections that need the SHF_MIPS_GPREL flag by name; there has to be
3154 _bfd_mips_elf_section_processing (abfd, hdr)
3156 Elf_Internal_Shdr *hdr;
3158 if (hdr->sh_type == SHT_MIPS_REGINFO
3159 && hdr->sh_size > 0)
3163 BFD_ASSERT (hdr->sh_size == sizeof (Elf32_External_RegInfo));
3164 BFD_ASSERT (hdr->contents == NULL);
3167 hdr->sh_offset + sizeof (Elf32_External_RegInfo) - 4,
3170 bfd_h_put_32 (abfd, (bfd_vma) elf_gp (abfd), buf);
3171 if (bfd_write (buf, (bfd_size_type) 1, (bfd_size_type) 4, abfd) != 4)
3175 if (hdr->sh_type == SHT_MIPS_OPTIONS
3176 && hdr->bfd_section != NULL
3177 && elf_section_data (hdr->bfd_section) != NULL
3178 && elf_section_data (hdr->bfd_section)->tdata != NULL)
3180 bfd_byte *contents, *l, *lend;
3182 /* We stored the section contents in the elf_section_data tdata
3183 field in the set_section_contents routine. We save the
3184 section contents so that we don't have to read them again.
3185 At this point we know that elf_gp is set, so we can look
3186 through the section contents to see if there is an
3187 ODK_REGINFO structure. */
3189 contents = (bfd_byte *) elf_section_data (hdr->bfd_section)->tdata;
3191 lend = contents + hdr->sh_size;
3192 while (l + sizeof (Elf_External_Options) <= lend)
3194 Elf_Internal_Options intopt;
3196 bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
3198 if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
3205 + sizeof (Elf_External_Options)
3206 + (sizeof (Elf64_External_RegInfo) - 8)),
3209 bfd_h_put_64 (abfd, elf_gp (abfd), buf);
3210 if (bfd_write (buf, 1, 8, abfd) != 8)
3213 else if (intopt.kind == ODK_REGINFO)
3220 + sizeof (Elf_External_Options)
3221 + (sizeof (Elf32_External_RegInfo) - 4)),
3224 bfd_h_put_32 (abfd, elf_gp (abfd), buf);
3225 if (bfd_write (buf, 1, 4, abfd) != 4)
3232 if (hdr->bfd_section != NULL)
3234 const char *name = bfd_get_section_name (abfd, hdr->bfd_section);
3236 if (strcmp (name, ".sdata") == 0
3237 || strcmp (name, ".lit8") == 0
3238 || strcmp (name, ".lit4") == 0)
3240 hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
3241 hdr->sh_type = SHT_PROGBITS;
3243 else if (strcmp (name, ".sbss") == 0)
3245 hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
3246 hdr->sh_type = SHT_NOBITS;
3248 else if (strcmp (name, MIPS_ELF_SRDATA_SECTION_NAME (abfd)) == 0)
3250 hdr->sh_flags |= SHF_ALLOC | SHF_MIPS_GPREL;
3251 hdr->sh_type = SHT_PROGBITS;
3253 else if (strcmp (name, ".compact_rel") == 0)
3256 hdr->sh_type = SHT_PROGBITS;
3258 else if (strcmp (name, ".rtproc") == 0)
3260 if (hdr->sh_addralign != 0 && hdr->sh_entsize == 0)
3262 unsigned int adjust;
3264 adjust = hdr->sh_size % hdr->sh_addralign;
3266 hdr->sh_size += hdr->sh_addralign - adjust;
3274 /* MIPS ELF uses two common sections. One is the usual one, and the
3275 other is for small objects. All the small objects are kept
3276 together, and then referenced via the gp pointer, which yields
3277 faster assembler code. This is what we use for the small common
3278 section. This approach is copied from ecoff.c. */
3279 static asection mips_elf_scom_section;
3280 static asymbol mips_elf_scom_symbol;
3281 static asymbol *mips_elf_scom_symbol_ptr;
3283 /* MIPS ELF also uses an acommon section, which represents an
3284 allocated common symbol which may be overridden by a
3285 definition in a shared library. */
3286 static asection mips_elf_acom_section;
3287 static asymbol mips_elf_acom_symbol;
3288 static asymbol *mips_elf_acom_symbol_ptr;
3290 /* Handle the special MIPS section numbers that a symbol may use.
3291 This is used for both the 32-bit and the 64-bit ABI. */
3294 _bfd_mips_elf_symbol_processing (abfd, asym)
3298 elf_symbol_type *elfsym;
3300 elfsym = (elf_symbol_type *) asym;
3301 switch (elfsym->internal_elf_sym.st_shndx)
3303 case SHN_MIPS_ACOMMON:
3304 /* This section is used in a dynamically linked executable file.
3305 It is an allocated common section. The dynamic linker can
3306 either resolve these symbols to something in a shared
3307 library, or it can just leave them here. For our purposes,
3308 we can consider these symbols to be in a new section. */
3309 if (mips_elf_acom_section.name == NULL)
3311 /* Initialize the acommon section. */
3312 mips_elf_acom_section.name = ".acommon";
3313 mips_elf_acom_section.flags = SEC_ALLOC;
3314 mips_elf_acom_section.output_section = &mips_elf_acom_section;
3315 mips_elf_acom_section.symbol = &mips_elf_acom_symbol;
3316 mips_elf_acom_section.symbol_ptr_ptr = &mips_elf_acom_symbol_ptr;
3317 mips_elf_acom_symbol.name = ".acommon";
3318 mips_elf_acom_symbol.flags = BSF_SECTION_SYM;
3319 mips_elf_acom_symbol.section = &mips_elf_acom_section;
3320 mips_elf_acom_symbol_ptr = &mips_elf_acom_symbol;
3322 asym->section = &mips_elf_acom_section;
3326 /* Common symbols less than the GP size are automatically
3327 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
3328 if (asym->value > elf_gp_size (abfd)
3329 || IRIX_COMPAT (abfd) == ict_irix6)
3332 case SHN_MIPS_SCOMMON:
3333 if (mips_elf_scom_section.name == NULL)
3335 /* Initialize the small common section. */
3336 mips_elf_scom_section.name = ".scommon";
3337 mips_elf_scom_section.flags = SEC_IS_COMMON;
3338 mips_elf_scom_section.output_section = &mips_elf_scom_section;
3339 mips_elf_scom_section.symbol = &mips_elf_scom_symbol;
3340 mips_elf_scom_section.symbol_ptr_ptr = &mips_elf_scom_symbol_ptr;
3341 mips_elf_scom_symbol.name = ".scommon";
3342 mips_elf_scom_symbol.flags = BSF_SECTION_SYM;
3343 mips_elf_scom_symbol.section = &mips_elf_scom_section;
3344 mips_elf_scom_symbol_ptr = &mips_elf_scom_symbol;
3346 asym->section = &mips_elf_scom_section;
3347 asym->value = elfsym->internal_elf_sym.st_size;
3350 case SHN_MIPS_SUNDEFINED:
3351 asym->section = bfd_und_section_ptr;
3354 #if 0 /* for SGI_COMPAT */
3356 asym->section = mips_elf_text_section_ptr;
3360 asym->section = mips_elf_data_section_ptr;
3366 /* When creating an Irix 5 executable, we need REGINFO and RTPROC
3370 _bfd_mips_elf_additional_program_headers (abfd)
3376 /* See if we need a PT_MIPS_REGINFO segment. */
3377 s = bfd_get_section_by_name (abfd, ".reginfo");
3378 if (s && (s->flags & SEC_LOAD))
3381 /* See if we need a PT_MIPS_OPTIONS segment. */
3382 if (IRIX_COMPAT (abfd) == ict_irix6
3383 && bfd_get_section_by_name (abfd,
3384 MIPS_ELF_OPTIONS_SECTION_NAME (abfd)))
3387 /* See if we need a PT_MIPS_RTPROC segment. */
3388 if (IRIX_COMPAT (abfd) == ict_irix5
3389 && bfd_get_section_by_name (abfd, ".dynamic")
3390 && bfd_get_section_by_name (abfd, ".mdebug"))
3396 /* Modify the segment map for an Irix 5 executable. */
3399 _bfd_mips_elf_modify_segment_map (abfd)
3403 struct elf_segment_map *m, **pm;
3405 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
3407 s = bfd_get_section_by_name (abfd, ".reginfo");
3408 if (s != NULL && (s->flags & SEC_LOAD) != 0)
3410 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
3411 if (m->p_type == PT_MIPS_REGINFO)
3415 m = (struct elf_segment_map *) bfd_zalloc (abfd, sizeof *m);
3419 m->p_type = PT_MIPS_REGINFO;
3423 /* We want to put it after the PHDR and INTERP segments. */
3424 pm = &elf_tdata (abfd)->segment_map;
3426 && ((*pm)->p_type == PT_PHDR
3427 || (*pm)->p_type == PT_INTERP))
3435 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
3436 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
3437 PT_OPTIONS segement immediately following the program header
3439 if (IRIX_COMPAT (abfd) == ict_irix6)
3443 for (s = abfd->sections; s; s = s->next)
3444 if (elf_section_data (s)->this_hdr.sh_type == SHT_MIPS_OPTIONS)
3449 struct elf_segment_map *options_segment;
3451 /* Usually, there's a program header table. But, sometimes
3452 there's not (like when running the `ld' testsuite). So,
3453 if there's no program header table, we just put the
3454 options segement at the end. */
3455 for (pm = &elf_tdata (abfd)->segment_map;
3458 if ((*pm)->p_type == PT_PHDR)
3461 options_segment = bfd_zalloc (abfd,
3462 sizeof (struct elf_segment_map));
3463 options_segment->next = *pm;
3464 options_segment->p_type = PT_MIPS_OPTIONS;
3465 options_segment->p_flags = PF_R;
3466 options_segment->p_flags_valid = true;
3467 options_segment->count = 1;
3468 options_segment->sections[0] = s;
3469 *pm = options_segment;
3474 if (IRIX_COMPAT (abfd) == ict_irix5)
3476 /* If there are .dynamic and .mdebug sections, we make a room
3477 for the RTPROC header. FIXME: Rewrite without section names. */
3478 if (bfd_get_section_by_name (abfd, ".interp") == NULL
3479 && bfd_get_section_by_name (abfd, ".dynamic") != NULL
3480 && bfd_get_section_by_name (abfd, ".mdebug") != NULL)
3482 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
3483 if (m->p_type == PT_MIPS_RTPROC)
3487 m = (struct elf_segment_map *) bfd_zalloc (abfd, sizeof *m);
3491 m->p_type = PT_MIPS_RTPROC;
3493 s = bfd_get_section_by_name (abfd, ".rtproc");
3498 m->p_flags_valid = 1;
3506 /* We want to put it after the DYNAMIC segment. */
3507 pm = &elf_tdata (abfd)->segment_map;
3508 while (*pm != NULL && (*pm)->p_type != PT_DYNAMIC)
3518 /* On Irix 5, the PT_DYNAMIC segment includes the .dynamic,
3519 .dynstr, .dynsym, and .hash sections, and everything in
3521 for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL;
3523 if ((*pm)->p_type == PT_DYNAMIC)
3526 if (IRIX_COMPAT (abfd) == ict_none)
3528 /* For a normal mips executable the permissions for the PT_DYNAMIC
3529 segment are read, write and execute. We do that here since
3530 the code in elf.c sets only the read permission. This matters
3531 sometimes for the dynamic linker. */
3532 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
3534 m->p_flags = PF_R | PF_W | PF_X;
3535 m->p_flags_valid = 1;
3539 && m->count == 1 && strcmp (m->sections[0]->name, ".dynamic") == 0)
3541 static const char *sec_names[] =
3543 ".dynamic", ".dynstr", ".dynsym", ".hash"
3547 struct elf_segment_map *n;
3551 for (i = 0; i < sizeof sec_names / sizeof sec_names[0]; i++)
3553 s = bfd_get_section_by_name (abfd, sec_names[i]);
3554 if (s != NULL && (s->flags & SEC_LOAD) != 0)
3560 sz = s->_cooked_size;
3563 if (high < s->vma + sz)
3569 for (s = abfd->sections; s != NULL; s = s->next)
3570 if ((s->flags & SEC_LOAD) != 0
3573 + (s->_cooked_size !=
3574 0 ? s->_cooked_size : s->_raw_size)) <= high))
3577 n = ((struct elf_segment_map *)
3578 bfd_zalloc (abfd, sizeof *n + (c - 1) * sizeof (asection *)));
3585 for (s = abfd->sections; s != NULL; s = s->next)
3587 if ((s->flags & SEC_LOAD) != 0
3590 + (s->_cooked_size != 0 ?
3591 s->_cooked_size : s->_raw_size)) <= high))
3605 /* The structure of the runtime procedure descriptor created by the
3606 loader for use by the static exception system. */
3608 typedef struct runtime_pdr {
3609 bfd_vma adr; /* memory address of start of procedure */
3610 long regmask; /* save register mask */
3611 long regoffset; /* save register offset */
3612 long fregmask; /* save floating point register mask */
3613 long fregoffset; /* save floating point register offset */
3614 long frameoffset; /* frame size */
3615 short framereg; /* frame pointer register */
3616 short pcreg; /* offset or reg of return pc */
3617 long irpss; /* index into the runtime string table */
3619 struct exception_info *exception_info;/* pointer to exception array */
3621 #define cbRPDR sizeof (RPDR)
3622 #define rpdNil ((pRPDR) 0)
3624 /* Swap RPDR (runtime procedure table entry) for output. */
3626 static void ecoff_swap_rpdr_out
3627 PARAMS ((bfd *, const RPDR *, struct rpdr_ext *));
3630 ecoff_swap_rpdr_out (abfd, in, ex)
3633 struct rpdr_ext *ex;
3635 /* ecoff_put_off was defined in ecoffswap.h. */
3636 ecoff_put_off (abfd, in->adr, (bfd_byte *) ex->p_adr);
3637 bfd_h_put_32 (abfd, in->regmask, (bfd_byte *) ex->p_regmask);
3638 bfd_h_put_32 (abfd, in->regoffset, (bfd_byte *) ex->p_regoffset);
3639 bfd_h_put_32 (abfd, in->fregmask, (bfd_byte *) ex->p_fregmask);
3640 bfd_h_put_32 (abfd, in->fregoffset, (bfd_byte *) ex->p_fregoffset);
3641 bfd_h_put_32 (abfd, in->frameoffset, (bfd_byte *) ex->p_frameoffset);
3643 bfd_h_put_16 (abfd, in->framereg, (bfd_byte *) ex->p_framereg);
3644 bfd_h_put_16 (abfd, in->pcreg, (bfd_byte *) ex->p_pcreg);
3646 bfd_h_put_32 (abfd, in->irpss, (bfd_byte *) ex->p_irpss);
3648 ecoff_put_off (abfd, in->exception_info, (bfd_byte *) ex->p_exception_info);
3652 /* Read ECOFF debugging information from a .mdebug section into a
3653 ecoff_debug_info structure. */
3656 _bfd_mips_elf_read_ecoff_info (abfd, section, debug)
3659 struct ecoff_debug_info *debug;
3662 const struct ecoff_debug_swap *swap;
3663 char *ext_hdr = NULL;
3665 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
3666 memset (debug, 0, sizeof (*debug));
3668 ext_hdr = (char *) bfd_malloc ((size_t) swap->external_hdr_size);
3669 if (ext_hdr == NULL && swap->external_hdr_size != 0)
3672 if (bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
3673 swap->external_hdr_size)
3677 symhdr = &debug->symbolic_header;
3678 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
3680 /* The symbolic header contains absolute file offsets and sizes to
3682 #define READ(ptr, offset, count, size, type) \
3683 if (symhdr->count == 0) \
3684 debug->ptr = NULL; \
3687 debug->ptr = (type) bfd_malloc ((size_t) (size * symhdr->count)); \
3688 if (debug->ptr == NULL) \
3689 goto error_return; \
3690 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
3691 || (bfd_read (debug->ptr, size, symhdr->count, \
3692 abfd) != size * symhdr->count)) \
3693 goto error_return; \
3696 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
3697 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR);
3698 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR);
3699 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR);
3700 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR);
3701 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
3703 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
3704 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
3705 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR);
3706 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR);
3707 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, PTR);
3711 debug->adjust = NULL;
3716 if (ext_hdr != NULL)
3718 if (debug->line != NULL)
3720 if (debug->external_dnr != NULL)
3721 free (debug->external_dnr);
3722 if (debug->external_pdr != NULL)
3723 free (debug->external_pdr);
3724 if (debug->external_sym != NULL)
3725 free (debug->external_sym);
3726 if (debug->external_opt != NULL)
3727 free (debug->external_opt);
3728 if (debug->external_aux != NULL)
3729 free (debug->external_aux);
3730 if (debug->ss != NULL)
3732 if (debug->ssext != NULL)
3733 free (debug->ssext);
3734 if (debug->external_fdr != NULL)
3735 free (debug->external_fdr);
3736 if (debug->external_rfd != NULL)
3737 free (debug->external_rfd);
3738 if (debug->external_ext != NULL)
3739 free (debug->external_ext);
3743 /* MIPS ELF local labels start with '$', not 'L'. */
3746 mips_elf_is_local_label_name (abfd, name)
3753 /* On Irix 6, the labels go back to starting with '.', so we accept
3754 the generic ELF local label syntax as well. */
3755 return _bfd_elf_is_local_label_name (abfd, name);
3758 /* MIPS ELF uses a special find_nearest_line routine in order the
3759 handle the ECOFF debugging information. */
3761 struct mips_elf_find_line
3763 struct ecoff_debug_info d;
3764 struct ecoff_find_line i;
3768 _bfd_mips_elf_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
3769 functionname_ptr, line_ptr)
3774 const char **filename_ptr;
3775 const char **functionname_ptr;
3776 unsigned int *line_ptr;
3780 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
3781 filename_ptr, functionname_ptr,
3785 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
3786 filename_ptr, functionname_ptr,
3788 ABI_64_P (abfd) ? 8 : 0,
3789 &elf_tdata (abfd)->dwarf2_find_line_info))
3792 msec = bfd_get_section_by_name (abfd, ".mdebug");
3796 struct mips_elf_find_line *fi;
3797 const struct ecoff_debug_swap * const swap =
3798 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
3800 /* If we are called during a link, mips_elf_final_link may have
3801 cleared the SEC_HAS_CONTENTS field. We force it back on here
3802 if appropriate (which it normally will be). */
3803 origflags = msec->flags;
3804 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
3805 msec->flags |= SEC_HAS_CONTENTS;
3807 fi = elf_tdata (abfd)->find_line_info;
3810 bfd_size_type external_fdr_size;
3813 struct fdr *fdr_ptr;
3815 fi = ((struct mips_elf_find_line *)
3816 bfd_zalloc (abfd, sizeof (struct mips_elf_find_line)));
3819 msec->flags = origflags;
3823 if (! _bfd_mips_elf_read_ecoff_info (abfd, msec, &fi->d))
3825 msec->flags = origflags;
3829 /* Swap in the FDR information. */
3830 fi->d.fdr = ((struct fdr *)
3832 (fi->d.symbolic_header.ifdMax *
3833 sizeof (struct fdr))));
3834 if (fi->d.fdr == NULL)
3836 msec->flags = origflags;
3839 external_fdr_size = swap->external_fdr_size;
3840 fdr_ptr = fi->d.fdr;
3841 fraw_src = (char *) fi->d.external_fdr;
3842 fraw_end = (fraw_src
3843 + fi->d.symbolic_header.ifdMax * external_fdr_size);
3844 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
3845 (*swap->swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
3847 elf_tdata (abfd)->find_line_info = fi;
3849 /* Note that we don't bother to ever free this information.
3850 find_nearest_line is either called all the time, as in
3851 objdump -l, so the information should be saved, or it is
3852 rarely called, as in ld error messages, so the memory
3853 wasted is unimportant. Still, it would probably be a
3854 good idea for free_cached_info to throw it away. */
3857 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
3858 &fi->i, filename_ptr, functionname_ptr,
3861 msec->flags = origflags;
3865 msec->flags = origflags;
3868 /* Fall back on the generic ELF find_nearest_line routine. */
3870 return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
3871 filename_ptr, functionname_ptr,
3875 /* The mips16 compiler uses a couple of special sections to handle
3876 floating point arguments.
3878 Section names that look like .mips16.fn.FNNAME contain stubs that
3879 copy floating point arguments from the fp regs to the gp regs and
3880 then jump to FNNAME. If any 32 bit function calls FNNAME, the
3881 call should be redirected to the stub instead. If no 32 bit
3882 function calls FNNAME, the stub should be discarded. We need to
3883 consider any reference to the function, not just a call, because
3884 if the address of the function is taken we will need the stub,
3885 since the address might be passed to a 32 bit function.
3887 Section names that look like .mips16.call.FNNAME contain stubs
3888 that copy floating point arguments from the gp regs to the fp
3889 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
3890 then any 16 bit function that calls FNNAME should be redirected
3891 to the stub instead. If FNNAME is not a 32 bit function, the
3892 stub should be discarded.
3894 .mips16.call.fp.FNNAME sections are similar, but contain stubs
3895 which call FNNAME and then copy the return value from the fp regs
3896 to the gp regs. These stubs store the return value in $18 while
3897 calling FNNAME; any function which might call one of these stubs
3898 must arrange to save $18 around the call. (This case is not
3899 needed for 32 bit functions that call 16 bit functions, because
3900 16 bit functions always return floating point values in both
3903 Note that in all cases FNNAME might be defined statically.
3904 Therefore, FNNAME is not used literally. Instead, the relocation
3905 information will indicate which symbol the section is for.
3907 We record any stubs that we find in the symbol table. */
3909 #define FN_STUB ".mips16.fn."
3910 #define CALL_STUB ".mips16.call."
3911 #define CALL_FP_STUB ".mips16.call.fp."
3913 /* MIPS ELF linker hash table. */
3915 struct mips_elf_link_hash_table
3917 struct elf_link_hash_table root;
3919 /* We no longer use this. */
3920 /* String section indices for the dynamic section symbols. */
3921 bfd_size_type dynsym_sec_strindex[SIZEOF_MIPS_DYNSYM_SECNAMES];
3923 /* The number of .rtproc entries. */
3924 bfd_size_type procedure_count;
3925 /* The size of the .compact_rel section (if SGI_COMPAT). */
3926 bfd_size_type compact_rel_size;
3927 /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic
3928 entry is set to the address of __rld_obj_head as in Irix 5. */
3929 boolean use_rld_obj_head;
3930 /* This is the value of the __rld_map or __rld_obj_head symbol. */
3932 /* This is set if we see any mips16 stub sections. */
3933 boolean mips16_stubs_seen;
3936 /* Look up an entry in a MIPS ELF linker hash table. */
3938 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
3939 ((struct mips_elf_link_hash_entry *) \
3940 elf_link_hash_lookup (&(table)->root, (string), (create), \
3943 /* Traverse a MIPS ELF linker hash table. */
3945 #define mips_elf_link_hash_traverse(table, func, info) \
3946 (elf_link_hash_traverse \
3948 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
3951 /* Get the MIPS ELF linker hash table from a link_info structure. */
3953 #define mips_elf_hash_table(p) \
3954 ((struct mips_elf_link_hash_table *) ((p)->hash))
3956 static boolean mips_elf_output_extsym
3957 PARAMS ((struct mips_elf_link_hash_entry *, PTR));
3959 /* Create an entry in a MIPS ELF linker hash table. */
3961 static struct bfd_hash_entry *
3962 mips_elf_link_hash_newfunc (entry, table, string)
3963 struct bfd_hash_entry *entry;
3964 struct bfd_hash_table *table;
3967 struct mips_elf_link_hash_entry *ret =
3968 (struct mips_elf_link_hash_entry *) entry;
3970 /* Allocate the structure if it has not already been allocated by a
3972 if (ret == (struct mips_elf_link_hash_entry *) NULL)
3973 ret = ((struct mips_elf_link_hash_entry *)
3974 bfd_hash_allocate (table,
3975 sizeof (struct mips_elf_link_hash_entry)));
3976 if (ret == (struct mips_elf_link_hash_entry *) NULL)
3977 return (struct bfd_hash_entry *) ret;
3979 /* Call the allocation method of the superclass. */
3980 ret = ((struct mips_elf_link_hash_entry *)
3981 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
3983 if (ret != (struct mips_elf_link_hash_entry *) NULL)
3985 /* Set local fields. */
3986 memset (&ret->esym, 0, sizeof (EXTR));
3987 /* We use -2 as a marker to indicate that the information has
3988 not been set. -1 means there is no associated ifd. */
3990 ret->possibly_dynamic_relocs = 0;
3991 ret->readonly_reloc = false;
3992 ret->min_dyn_reloc_index = 0;
3993 ret->no_fn_stub = false;
3994 ret->fn_stub = NULL;
3995 ret->need_fn_stub = false;
3996 ret->call_stub = NULL;
3997 ret->call_fp_stub = NULL;
4000 return (struct bfd_hash_entry *) ret;
4004 _bfd_mips_elf_hide_symbol (info, entry)
4005 struct bfd_link_info *info;
4006 struct elf_link_hash_entry *entry;
4010 struct mips_got_info *g;
4011 struct mips_elf_link_hash_entry *h;
4012 h = (struct mips_elf_link_hash_entry *) entry;
4013 dynobj = elf_hash_table (info)->dynobj;
4014 got = bfd_get_section_by_name (dynobj, ".got");
4015 g = (struct mips_got_info *) elf_section_data (got)->tdata;
4017 h->root.elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
4018 h->root.plt.offset = (bfd_vma) -1;
4019 if ((h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)
4020 h->root.dynindx = -1;
4022 /* FIXME: Do we allocate too much GOT space here? */
4024 got->_raw_size += MIPS_ELF_GOT_SIZE (dynobj);
4027 /* Create a MIPS ELF linker hash table. */
4029 struct bfd_link_hash_table *
4030 _bfd_mips_elf_link_hash_table_create (abfd)
4033 struct mips_elf_link_hash_table *ret;
4035 ret = ((struct mips_elf_link_hash_table *)
4036 bfd_alloc (abfd, sizeof (struct mips_elf_link_hash_table)));
4037 if (ret == (struct mips_elf_link_hash_table *) NULL)
4040 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
4041 mips_elf_link_hash_newfunc))
4043 bfd_release (abfd, ret);
4048 /* We no longer use this. */
4049 for (i = 0; i < SIZEOF_MIPS_DYNSYM_SECNAMES; i++)
4050 ret->dynsym_sec_strindex[i] = (bfd_size_type) -1;
4052 ret->procedure_count = 0;
4053 ret->compact_rel_size = 0;
4054 ret->use_rld_obj_head = false;
4056 ret->mips16_stubs_seen = false;
4058 return &ret->root.root;
4061 /* Hook called by the linker routine which adds symbols from an object
4062 file. We must handle the special MIPS section numbers here. */
4065 _bfd_mips_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
4067 struct bfd_link_info *info;
4068 const Elf_Internal_Sym *sym;
4070 flagword *flagsp ATTRIBUTE_UNUSED;
4074 if (SGI_COMPAT (abfd)
4075 && (abfd->flags & DYNAMIC) != 0
4076 && strcmp (*namep, "_rld_new_interface") == 0)
4078 /* Skip Irix 5 rld entry name. */
4083 switch (sym->st_shndx)
4086 /* Common symbols less than the GP size are automatically
4087 treated as SHN_MIPS_SCOMMON symbols. */
4088 if (sym->st_size > elf_gp_size (abfd)
4089 || IRIX_COMPAT (abfd) == ict_irix6)
4092 case SHN_MIPS_SCOMMON:
4093 *secp = bfd_make_section_old_way (abfd, ".scommon");
4094 (*secp)->flags |= SEC_IS_COMMON;
4095 *valp = sym->st_size;
4099 /* This section is used in a shared object. */
4100 if (elf_tdata (abfd)->elf_text_section == NULL)
4102 asymbol *elf_text_symbol;
4103 asection *elf_text_section;
4105 elf_text_section = bfd_zalloc (abfd, sizeof (asection));
4106 if (elf_text_section == NULL)
4109 elf_text_symbol = bfd_zalloc (abfd, sizeof (asymbol));
4110 if (elf_text_symbol == NULL)
4113 /* Initialize the section. */
4115 elf_tdata (abfd)->elf_text_section = elf_text_section;
4116 elf_tdata (abfd)->elf_text_symbol = elf_text_symbol;
4118 elf_text_section->symbol = elf_text_symbol;
4119 elf_text_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_text_symbol;
4121 elf_text_section->name = ".text";
4122 elf_text_section->flags = SEC_NO_FLAGS;
4123 elf_text_section->output_section = NULL;
4124 elf_text_section->owner = abfd;
4125 elf_text_symbol->name = ".text";
4126 elf_text_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
4127 elf_text_symbol->section = elf_text_section;
4129 /* This code used to do *secp = bfd_und_section_ptr if
4130 info->shared. I don't know why, and that doesn't make sense,
4131 so I took it out. */
4132 *secp = elf_tdata (abfd)->elf_text_section;
4135 case SHN_MIPS_ACOMMON:
4136 /* Fall through. XXX Can we treat this as allocated data? */
4138 /* This section is used in a shared object. */
4139 if (elf_tdata (abfd)->elf_data_section == NULL)
4141 asymbol *elf_data_symbol;
4142 asection *elf_data_section;
4144 elf_data_section = bfd_zalloc (abfd, sizeof (asection));
4145 if (elf_data_section == NULL)
4148 elf_data_symbol = bfd_zalloc (abfd, sizeof (asymbol));
4149 if (elf_data_symbol == NULL)
4152 /* Initialize the section. */
4154 elf_tdata (abfd)->elf_data_section = elf_data_section;
4155 elf_tdata (abfd)->elf_data_symbol = elf_data_symbol;
4157 elf_data_section->symbol = elf_data_symbol;
4158 elf_data_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_data_symbol;
4160 elf_data_section->name = ".data";
4161 elf_data_section->flags = SEC_NO_FLAGS;
4162 elf_data_section->output_section = NULL;
4163 elf_data_section->owner = abfd;
4164 elf_data_symbol->name = ".data";
4165 elf_data_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
4166 elf_data_symbol->section = elf_data_section;
4168 /* This code used to do *secp = bfd_und_section_ptr if
4169 info->shared. I don't know why, and that doesn't make sense,
4170 so I took it out. */
4171 *secp = elf_tdata (abfd)->elf_data_section;
4174 case SHN_MIPS_SUNDEFINED:
4175 *secp = bfd_und_section_ptr;
4179 if (SGI_COMPAT (abfd)
4181 && info->hash->creator == abfd->xvec
4182 && strcmp (*namep, "__rld_obj_head") == 0)
4184 struct elf_link_hash_entry *h;
4186 /* Mark __rld_obj_head as dynamic. */
4188 if (! (_bfd_generic_link_add_one_symbol
4189 (info, abfd, *namep, BSF_GLOBAL, *secp,
4190 (bfd_vma) *valp, (const char *) NULL, false,
4191 get_elf_backend_data (abfd)->collect,
4192 (struct bfd_link_hash_entry **) &h)))
4194 h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
4195 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
4196 h->type = STT_OBJECT;
4198 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
4201 mips_elf_hash_table (info)->use_rld_obj_head = true;
4204 /* If this is a mips16 text symbol, add 1 to the value to make it
4205 odd. This will cause something like .word SYM to come up with
4206 the right value when it is loaded into the PC. */
4207 if (sym->st_other == STO_MIPS16)
4213 /* Structure used to pass information to mips_elf_output_extsym. */
4218 struct bfd_link_info *info;
4219 struct ecoff_debug_info *debug;
4220 const struct ecoff_debug_swap *swap;
4224 /* This routine is used to write out ECOFF debugging external symbol
4225 information. It is called via mips_elf_link_hash_traverse. The
4226 ECOFF external symbol information must match the ELF external
4227 symbol information. Unfortunately, at this point we don't know
4228 whether a symbol is required by reloc information, so the two
4229 tables may wind up being different. We must sort out the external
4230 symbol information before we can set the final size of the .mdebug
4231 section, and we must set the size of the .mdebug section before we
4232 can relocate any sections, and we can't know which symbols are
4233 required by relocation until we relocate the sections.
4234 Fortunately, it is relatively unlikely that any symbol will be
4235 stripped but required by a reloc. In particular, it can not happen
4236 when generating a final executable. */
4239 mips_elf_output_extsym (h, data)
4240 struct mips_elf_link_hash_entry *h;
4243 struct extsym_info *einfo = (struct extsym_info *) data;
4245 asection *sec, *output_section;
4247 if (h->root.indx == -2)
4249 else if (((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
4250 || (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
4251 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
4252 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
4254 else if (einfo->info->strip == strip_all
4255 || (einfo->info->strip == strip_some
4256 && bfd_hash_lookup (einfo->info->keep_hash,
4257 h->root.root.root.string,
4258 false, false) == NULL))
4266 if (h->esym.ifd == -2)
4269 h->esym.cobol_main = 0;
4270 h->esym.weakext = 0;
4271 h->esym.reserved = 0;
4272 h->esym.ifd = ifdNil;
4273 h->esym.asym.value = 0;
4274 h->esym.asym.st = stGlobal;
4276 if (h->root.root.type == bfd_link_hash_undefined
4277 || h->root.root.type == bfd_link_hash_undefweak)
4281 /* Use undefined class. Also, set class and type for some
4283 name = h->root.root.root.string;
4284 if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
4285 || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
4287 h->esym.asym.sc = scData;
4288 h->esym.asym.st = stLabel;
4289 h->esym.asym.value = 0;
4291 else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
4293 h->esym.asym.sc = scAbs;
4294 h->esym.asym.st = stLabel;
4295 h->esym.asym.value =
4296 mips_elf_hash_table (einfo->info)->procedure_count;
4298 else if (strcmp (name, "_gp_disp") == 0)
4300 h->esym.asym.sc = scAbs;
4301 h->esym.asym.st = stLabel;
4302 h->esym.asym.value = elf_gp (einfo->abfd);
4305 h->esym.asym.sc = scUndefined;
4307 else if (h->root.root.type != bfd_link_hash_defined
4308 && h->root.root.type != bfd_link_hash_defweak)
4309 h->esym.asym.sc = scAbs;
4314 sec = h->root.root.u.def.section;
4315 output_section = sec->output_section;
4317 /* When making a shared library and symbol h is the one from
4318 the another shared library, OUTPUT_SECTION may be null. */
4319 if (output_section == NULL)
4320 h->esym.asym.sc = scUndefined;
4323 name = bfd_section_name (output_section->owner, output_section);
4325 if (strcmp (name, ".text") == 0)
4326 h->esym.asym.sc = scText;
4327 else if (strcmp (name, ".data") == 0)
4328 h->esym.asym.sc = scData;
4329 else if (strcmp (name, ".sdata") == 0)
4330 h->esym.asym.sc = scSData;
4331 else if (strcmp (name, ".rodata") == 0
4332 || strcmp (name, ".rdata") == 0)
4333 h->esym.asym.sc = scRData;
4334 else if (strcmp (name, ".bss") == 0)
4335 h->esym.asym.sc = scBss;
4336 else if (strcmp (name, ".sbss") == 0)
4337 h->esym.asym.sc = scSBss;
4338 else if (strcmp (name, ".init") == 0)
4339 h->esym.asym.sc = scInit;
4340 else if (strcmp (name, ".fini") == 0)
4341 h->esym.asym.sc = scFini;
4343 h->esym.asym.sc = scAbs;
4347 h->esym.asym.reserved = 0;
4348 h->esym.asym.index = indexNil;
4351 if (h->root.root.type == bfd_link_hash_common)
4352 h->esym.asym.value = h->root.root.u.c.size;
4353 else if (h->root.root.type == bfd_link_hash_defined
4354 || h->root.root.type == bfd_link_hash_defweak)
4356 if (h->esym.asym.sc == scCommon)
4357 h->esym.asym.sc = scBss;
4358 else if (h->esym.asym.sc == scSCommon)
4359 h->esym.asym.sc = scSBss;
4361 sec = h->root.root.u.def.section;
4362 output_section = sec->output_section;
4363 if (output_section != NULL)
4364 h->esym.asym.value = (h->root.root.u.def.value
4365 + sec->output_offset
4366 + output_section->vma);
4368 h->esym.asym.value = 0;
4370 else if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
4372 struct mips_elf_link_hash_entry *hd = h;
4373 boolean no_fn_stub = h->no_fn_stub;
4375 while (hd->root.root.type == bfd_link_hash_indirect)
4377 hd = (struct mips_elf_link_hash_entry *)h->root.root.u.i.link;
4378 no_fn_stub = no_fn_stub || hd->no_fn_stub;
4383 /* Set type and value for a symbol with a function stub. */
4384 h->esym.asym.st = stProc;
4385 sec = hd->root.root.u.def.section;
4387 h->esym.asym.value = 0;
4390 output_section = sec->output_section;
4391 if (output_section != NULL)
4392 h->esym.asym.value = (hd->root.plt.offset
4393 + sec->output_offset
4394 + output_section->vma);
4396 h->esym.asym.value = 0;
4404 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
4405 h->root.root.root.string,
4408 einfo->failed = true;
4415 /* Create a runtime procedure table from the .mdebug section. */
4418 mips_elf_create_procedure_table (handle, abfd, info, s, debug)
4421 struct bfd_link_info *info;
4423 struct ecoff_debug_info *debug;
4425 const struct ecoff_debug_swap *swap;
4426 HDRR *hdr = &debug->symbolic_header;
4428 struct rpdr_ext *erp;
4430 struct pdr_ext *epdr;
4431 struct sym_ext *esym;
4434 unsigned long size, count;
4435 unsigned long sindex;
4439 const char *no_name_func = _("static procedure (no name)");
4447 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
4449 sindex = strlen (no_name_func) + 1;
4450 count = hdr->ipdMax;
4453 size = swap->external_pdr_size;
4455 epdr = (struct pdr_ext *) bfd_malloc (size * count);
4459 if (! _bfd_ecoff_get_accumulated_pdr (handle, (PTR) epdr))
4462 size = sizeof (RPDR);
4463 rp = rpdr = (RPDR *) bfd_malloc (size * count);
4467 sv = (char **) bfd_malloc (sizeof (char *) * count);
4471 count = hdr->isymMax;
4472 size = swap->external_sym_size;
4473 esym = (struct sym_ext *) bfd_malloc (size * count);
4477 if (! _bfd_ecoff_get_accumulated_sym (handle, (PTR) esym))
4480 count = hdr->issMax;
4481 ss = (char *) bfd_malloc (count);
4484 if (! _bfd_ecoff_get_accumulated_ss (handle, (PTR) ss))
4487 count = hdr->ipdMax;
4488 for (i = 0; i < count; i++, rp++)
4490 (*swap->swap_pdr_in) (abfd, (PTR) (epdr + i), &pdr);
4491 (*swap->swap_sym_in) (abfd, (PTR) &esym[pdr.isym], &sym);
4492 rp->adr = sym.value;
4493 rp->regmask = pdr.regmask;
4494 rp->regoffset = pdr.regoffset;
4495 rp->fregmask = pdr.fregmask;
4496 rp->fregoffset = pdr.fregoffset;
4497 rp->frameoffset = pdr.frameoffset;
4498 rp->framereg = pdr.framereg;
4499 rp->pcreg = pdr.pcreg;
4501 sv[i] = ss + sym.iss;
4502 sindex += strlen (sv[i]) + 1;
4506 size = sizeof (struct rpdr_ext) * (count + 2) + sindex;
4507 size = BFD_ALIGN (size, 16);
4508 rtproc = (PTR) bfd_alloc (abfd, size);
4511 mips_elf_hash_table (info)->procedure_count = 0;
4515 mips_elf_hash_table (info)->procedure_count = count + 2;
4517 erp = (struct rpdr_ext *) rtproc;
4518 memset (erp, 0, sizeof (struct rpdr_ext));
4520 str = (char *) rtproc + sizeof (struct rpdr_ext) * (count + 2);
4521 strcpy (str, no_name_func);
4522 str += strlen (no_name_func) + 1;
4523 for (i = 0; i < count; i++)
4525 ecoff_swap_rpdr_out (abfd, rpdr + i, erp + i);
4526 strcpy (str, sv[i]);
4527 str += strlen (sv[i]) + 1;
4529 ecoff_put_off (abfd, (bfd_vma) -1, (bfd_byte *) (erp + count)->p_adr);
4531 /* Set the size and contents of .rtproc section. */
4532 s->_raw_size = size;
4533 s->contents = (bfd_byte *) rtproc;
4535 /* Skip this section later on (I don't think this currently
4536 matters, but someday it might). */
4537 s->link_order_head = (struct bfd_link_order *) NULL;
4566 /* A comparison routine used to sort .gptab entries. */
4569 gptab_compare (p1, p2)
4573 const Elf32_gptab *a1 = (const Elf32_gptab *) p1;
4574 const Elf32_gptab *a2 = (const Elf32_gptab *) p2;
4576 return a1->gt_entry.gt_g_value - a2->gt_entry.gt_g_value;
4579 /* We need to use a special link routine to handle the .reginfo and
4580 the .mdebug sections. We need to merge all instances of these
4581 sections together, not write them all out sequentially. */
4584 _bfd_mips_elf_final_link (abfd, info)
4586 struct bfd_link_info *info;
4590 struct bfd_link_order *p;
4591 asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
4592 asection *rtproc_sec;
4593 Elf32_RegInfo reginfo;
4594 struct ecoff_debug_info debug;
4595 const struct ecoff_debug_swap *swap
4596 = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
4597 HDRR *symhdr = &debug.symbolic_header;
4598 PTR mdebug_handle = NULL;
4603 static const char * const name[] =
4605 ".text", ".init", ".fini", ".data",
4606 ".rodata", ".sdata", ".sbss", ".bss"
4608 static const int sc[] =
4610 scText, scInit, scFini, scData,
4611 scRData, scSData, scSBss, scBss
4614 /* If all the things we linked together were PIC, but we're
4615 producing an executable (rather than a shared object), then the
4616 resulting file is CPIC (i.e., it calls PIC code.) */
4618 && !info->relocateable
4619 && elf_elfheader (abfd)->e_flags & EF_MIPS_PIC)
4621 elf_elfheader (abfd)->e_flags &= ~EF_MIPS_PIC;
4622 elf_elfheader (abfd)->e_flags |= EF_MIPS_CPIC;
4625 /* We'd carefully arranged the dynamic symbol indices, and then the
4626 generic size_dynamic_sections renumbered them out from under us.
4627 Rather than trying somehow to prevent the renumbering, just do
4629 if (elf_hash_table (info)->dynamic_sections_created)
4633 struct mips_got_info *g;
4635 /* When we resort, we must tell mips_elf_sort_hash_table what
4636 the lowest index it may use is. That's the number of section
4637 symbols we're going to add. The generic ELF linker only
4638 adds these symbols when building a shared object. Note that
4639 we count the sections after (possibly) removing the .options
4641 if (!mips_elf_sort_hash_table (info, (info->shared
4642 ? bfd_count_sections (abfd) + 1
4646 /* Make sure we didn't grow the global .got region. */
4647 dynobj = elf_hash_table (info)->dynobj;
4648 got = bfd_get_section_by_name (dynobj, ".got");
4649 g = (struct mips_got_info *) elf_section_data (got)->tdata;
4651 if (g->global_gotsym != NULL)
4652 BFD_ASSERT ((elf_hash_table (info)->dynsymcount
4653 - g->global_gotsym->dynindx)
4654 <= g->global_gotno);
4657 /* On IRIX5, we omit the .options section. On IRIX6, however, we
4658 include it, even though we don't process it quite right. (Some
4659 entries are supposed to be merged.) Empirically, we seem to be
4660 better off including it then not. */
4661 if (IRIX_COMPAT (abfd) == ict_irix5 || IRIX_COMPAT (abfd) == ict_none)
4662 for (secpp = &abfd->sections; *secpp != NULL; secpp = &(*secpp)->next)
4664 if (strcmp ((*secpp)->name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) == 0)
4666 for (p = (*secpp)->link_order_head; p != NULL; p = p->next)
4667 if (p->type == bfd_indirect_link_order)
4668 p->u.indirect.section->flags &= ~SEC_HAS_CONTENTS;
4669 (*secpp)->link_order_head = NULL;
4670 *secpp = (*secpp)->next;
4671 --abfd->section_count;
4677 /* Get a value for the GP register. */
4678 if (elf_gp (abfd) == 0)
4680 struct bfd_link_hash_entry *h;
4682 h = bfd_link_hash_lookup (info->hash, "_gp", false, false, true);
4683 if (h != (struct bfd_link_hash_entry *) NULL
4684 && h->type == bfd_link_hash_defined)
4685 elf_gp (abfd) = (h->u.def.value
4686 + h->u.def.section->output_section->vma
4687 + h->u.def.section->output_offset);
4688 else if (info->relocateable)
4692 /* Find the GP-relative section with the lowest offset. */
4694 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4696 && (elf_section_data (o)->this_hdr.sh_flags & SHF_MIPS_GPREL))
4699 /* And calculate GP relative to that. */
4700 elf_gp (abfd) = lo + ELF_MIPS_GP_OFFSET (abfd);
4704 /* If the relocate_section function needs to do a reloc
4705 involving the GP value, it should make a reloc_dangerous
4706 callback to warn that GP is not defined. */
4710 /* Go through the sections and collect the .reginfo and .mdebug
4714 gptab_data_sec = NULL;
4715 gptab_bss_sec = NULL;
4716 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4718 if (strcmp (o->name, ".reginfo") == 0)
4720 memset (®info, 0, sizeof reginfo);
4722 /* We have found the .reginfo section in the output file.
4723 Look through all the link_orders comprising it and merge
4724 the information together. */
4725 for (p = o->link_order_head;
4726 p != (struct bfd_link_order *) NULL;
4729 asection *input_section;
4731 Elf32_External_RegInfo ext;
4734 if (p->type != bfd_indirect_link_order)
4736 if (p->type == bfd_fill_link_order)
4741 input_section = p->u.indirect.section;
4742 input_bfd = input_section->owner;
4744 /* The linker emulation code has probably clobbered the
4745 size to be zero bytes. */
4746 if (input_section->_raw_size == 0)
4747 input_section->_raw_size = sizeof (Elf32_External_RegInfo);
4749 if (! bfd_get_section_contents (input_bfd, input_section,
4755 bfd_mips_elf32_swap_reginfo_in (input_bfd, &ext, &sub);
4757 reginfo.ri_gprmask |= sub.ri_gprmask;
4758 reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
4759 reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
4760 reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
4761 reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
4763 /* ri_gp_value is set by the function
4764 mips_elf32_section_processing when the section is
4765 finally written out. */
4767 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4768 elf_link_input_bfd ignores this section. */
4769 input_section->flags &= ~SEC_HAS_CONTENTS;
4772 /* Size has been set in mips_elf_always_size_sections */
4773 BFD_ASSERT(o->_raw_size == sizeof (Elf32_External_RegInfo));
4775 /* Skip this section later on (I don't think this currently
4776 matters, but someday it might). */
4777 o->link_order_head = (struct bfd_link_order *) NULL;
4782 if (strcmp (o->name, ".mdebug") == 0)
4784 struct extsym_info einfo;
4786 /* We have found the .mdebug section in the output file.
4787 Look through all the link_orders comprising it and merge
4788 the information together. */
4789 symhdr->magic = swap->sym_magic;
4790 /* FIXME: What should the version stamp be? */
4792 symhdr->ilineMax = 0;
4796 symhdr->isymMax = 0;
4797 symhdr->ioptMax = 0;
4798 symhdr->iauxMax = 0;
4800 symhdr->issExtMax = 0;
4803 symhdr->iextMax = 0;
4805 /* We accumulate the debugging information itself in the
4806 debug_info structure. */
4808 debug.external_dnr = NULL;
4809 debug.external_pdr = NULL;
4810 debug.external_sym = NULL;
4811 debug.external_opt = NULL;
4812 debug.external_aux = NULL;
4814 debug.ssext = debug.ssext_end = NULL;
4815 debug.external_fdr = NULL;
4816 debug.external_rfd = NULL;
4817 debug.external_ext = debug.external_ext_end = NULL;
4819 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
4820 if (mdebug_handle == (PTR) NULL)
4824 esym.cobol_main = 0;
4828 esym.asym.iss = issNil;
4829 esym.asym.st = stLocal;
4830 esym.asym.reserved = 0;
4831 esym.asym.index = indexNil;
4833 for (i = 0; i < 8; i++)
4835 esym.asym.sc = sc[i];
4836 s = bfd_get_section_by_name (abfd, name[i]);
4839 esym.asym.value = s->vma;
4840 last = s->vma + s->_raw_size;
4843 esym.asym.value = last;
4844 if (!bfd_ecoff_debug_one_external (abfd, &debug, swap,
4849 for (p = o->link_order_head;
4850 p != (struct bfd_link_order *) NULL;
4853 asection *input_section;
4855 const struct ecoff_debug_swap *input_swap;
4856 struct ecoff_debug_info input_debug;
4860 if (p->type != bfd_indirect_link_order)
4862 if (p->type == bfd_fill_link_order)
4867 input_section = p->u.indirect.section;
4868 input_bfd = input_section->owner;
4870 if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
4871 || (get_elf_backend_data (input_bfd)
4872 ->elf_backend_ecoff_debug_swap) == NULL)
4874 /* I don't know what a non MIPS ELF bfd would be
4875 doing with a .mdebug section, but I don't really
4876 want to deal with it. */
4880 input_swap = (get_elf_backend_data (input_bfd)
4881 ->elf_backend_ecoff_debug_swap);
4883 BFD_ASSERT (p->size == input_section->_raw_size);
4885 /* The ECOFF linking code expects that we have already
4886 read in the debugging information and set up an
4887 ecoff_debug_info structure, so we do that now. */
4888 if (! _bfd_mips_elf_read_ecoff_info (input_bfd, input_section,
4892 if (! (bfd_ecoff_debug_accumulate
4893 (mdebug_handle, abfd, &debug, swap, input_bfd,
4894 &input_debug, input_swap, info)))
4897 /* Loop through the external symbols. For each one with
4898 interesting information, try to find the symbol in
4899 the linker global hash table and save the information
4900 for the output external symbols. */
4901 eraw_src = input_debug.external_ext;
4902 eraw_end = (eraw_src
4903 + (input_debug.symbolic_header.iextMax
4904 * input_swap->external_ext_size));
4906 eraw_src < eraw_end;
4907 eraw_src += input_swap->external_ext_size)
4911 struct mips_elf_link_hash_entry *h;
4913 (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
4914 if (ext.asym.sc == scNil
4915 || ext.asym.sc == scUndefined
4916 || ext.asym.sc == scSUndefined)
4919 name = input_debug.ssext + ext.asym.iss;
4920 h = mips_elf_link_hash_lookup (mips_elf_hash_table (info),
4921 name, false, false, true);
4922 if (h == NULL || h->esym.ifd != -2)
4928 < input_debug.symbolic_header.ifdMax);
4929 ext.ifd = input_debug.ifdmap[ext.ifd];
4935 /* Free up the information we just read. */
4936 free (input_debug.line);
4937 free (input_debug.external_dnr);
4938 free (input_debug.external_pdr);
4939 free (input_debug.external_sym);
4940 free (input_debug.external_opt);
4941 free (input_debug.external_aux);
4942 free (input_debug.ss);
4943 free (input_debug.ssext);
4944 free (input_debug.external_fdr);
4945 free (input_debug.external_rfd);
4946 free (input_debug.external_ext);
4948 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4949 elf_link_input_bfd ignores this section. */
4950 input_section->flags &= ~SEC_HAS_CONTENTS;
4953 if (SGI_COMPAT (abfd) && info->shared)
4955 /* Create .rtproc section. */
4956 rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
4957 if (rtproc_sec == NULL)
4959 flagword flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
4960 | SEC_LINKER_CREATED | SEC_READONLY);
4962 rtproc_sec = bfd_make_section (abfd, ".rtproc");
4963 if (rtproc_sec == NULL
4964 || ! bfd_set_section_flags (abfd, rtproc_sec, flags)
4965 || ! bfd_set_section_alignment (abfd, rtproc_sec, 4))
4969 if (! mips_elf_create_procedure_table (mdebug_handle, abfd,
4970 info, rtproc_sec, &debug))
4974 /* Build the external symbol information. */
4977 einfo.debug = &debug;
4979 einfo.failed = false;
4980 mips_elf_link_hash_traverse (mips_elf_hash_table (info),
4981 mips_elf_output_extsym,
4986 /* Set the size of the .mdebug section. */
4987 o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
4989 /* Skip this section later on (I don't think this currently
4990 matters, but someday it might). */
4991 o->link_order_head = (struct bfd_link_order *) NULL;
4996 if (strncmp (o->name, ".gptab.", sizeof ".gptab." - 1) == 0)
4998 const char *subname;
5001 Elf32_External_gptab *ext_tab;
5004 /* The .gptab.sdata and .gptab.sbss sections hold
5005 information describing how the small data area would
5006 change depending upon the -G switch. These sections
5007 not used in executables files. */
5008 if (! info->relocateable)
5012 for (p = o->link_order_head;
5013 p != (struct bfd_link_order *) NULL;
5016 asection *input_section;
5018 if (p->type != bfd_indirect_link_order)
5020 if (p->type == bfd_fill_link_order)
5025 input_section = p->u.indirect.section;
5027 /* Hack: reset the SEC_HAS_CONTENTS flag so that
5028 elf_link_input_bfd ignores this section. */
5029 input_section->flags &= ~SEC_HAS_CONTENTS;
5032 /* Skip this section later on (I don't think this
5033 currently matters, but someday it might). */
5034 o->link_order_head = (struct bfd_link_order *) NULL;
5036 /* Really remove the section. */
5037 for (secpp = &abfd->sections;
5039 secpp = &(*secpp)->next)
5041 *secpp = (*secpp)->next;
5042 --abfd->section_count;
5047 /* There is one gptab for initialized data, and one for
5048 uninitialized data. */
5049 if (strcmp (o->name, ".gptab.sdata") == 0)
5051 else if (strcmp (o->name, ".gptab.sbss") == 0)
5055 (*_bfd_error_handler)
5056 (_("%s: illegal section name `%s'"),
5057 bfd_get_filename (abfd), o->name);
5058 bfd_set_error (bfd_error_nonrepresentable_section);
5062 /* The linker script always combines .gptab.data and
5063 .gptab.sdata into .gptab.sdata, and likewise for
5064 .gptab.bss and .gptab.sbss. It is possible that there is
5065 no .sdata or .sbss section in the output file, in which
5066 case we must change the name of the output section. */
5067 subname = o->name + sizeof ".gptab" - 1;
5068 if (bfd_get_section_by_name (abfd, subname) == NULL)
5070 if (o == gptab_data_sec)
5071 o->name = ".gptab.data";
5073 o->name = ".gptab.bss";
5074 subname = o->name + sizeof ".gptab" - 1;
5075 BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
5078 /* Set up the first entry. */
5080 tab = (Elf32_gptab *) bfd_malloc (c * sizeof (Elf32_gptab));
5083 tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
5084 tab[0].gt_header.gt_unused = 0;
5086 /* Combine the input sections. */
5087 for (p = o->link_order_head;
5088 p != (struct bfd_link_order *) NULL;
5091 asection *input_section;
5095 bfd_size_type gpentry;
5097 if (p->type != bfd_indirect_link_order)
5099 if (p->type == bfd_fill_link_order)
5104 input_section = p->u.indirect.section;
5105 input_bfd = input_section->owner;
5107 /* Combine the gptab entries for this input section one
5108 by one. We know that the input gptab entries are
5109 sorted by ascending -G value. */
5110 size = bfd_section_size (input_bfd, input_section);
5112 for (gpentry = sizeof (Elf32_External_gptab);
5114 gpentry += sizeof (Elf32_External_gptab))
5116 Elf32_External_gptab ext_gptab;
5117 Elf32_gptab int_gptab;
5123 if (! (bfd_get_section_contents
5124 (input_bfd, input_section, (PTR) &ext_gptab,
5125 gpentry, sizeof (Elf32_External_gptab))))
5131 bfd_mips_elf32_swap_gptab_in (input_bfd, &ext_gptab,
5133 val = int_gptab.gt_entry.gt_g_value;
5134 add = int_gptab.gt_entry.gt_bytes - last;
5137 for (look = 1; look < c; look++)
5139 if (tab[look].gt_entry.gt_g_value >= val)
5140 tab[look].gt_entry.gt_bytes += add;
5142 if (tab[look].gt_entry.gt_g_value == val)
5148 Elf32_gptab *new_tab;
5151 /* We need a new table entry. */
5152 new_tab = ((Elf32_gptab *)
5153 bfd_realloc ((PTR) tab,
5154 (c + 1) * sizeof (Elf32_gptab)));
5155 if (new_tab == NULL)
5161 tab[c].gt_entry.gt_g_value = val;
5162 tab[c].gt_entry.gt_bytes = add;
5164 /* Merge in the size for the next smallest -G
5165 value, since that will be implied by this new
5168 for (look = 1; look < c; look++)
5170 if (tab[look].gt_entry.gt_g_value < val
5172 || (tab[look].gt_entry.gt_g_value
5173 > tab[max].gt_entry.gt_g_value)))
5177 tab[c].gt_entry.gt_bytes +=
5178 tab[max].gt_entry.gt_bytes;
5183 last = int_gptab.gt_entry.gt_bytes;
5186 /* Hack: reset the SEC_HAS_CONTENTS flag so that
5187 elf_link_input_bfd ignores this section. */
5188 input_section->flags &= ~SEC_HAS_CONTENTS;
5191 /* The table must be sorted by -G value. */
5193 qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
5195 /* Swap out the table. */
5196 ext_tab = ((Elf32_External_gptab *)
5197 bfd_alloc (abfd, c * sizeof (Elf32_External_gptab)));
5198 if (ext_tab == NULL)
5204 for (i = 0; i < c; i++)
5205 bfd_mips_elf32_swap_gptab_out (abfd, tab + i, ext_tab + i);
5208 o->_raw_size = c * sizeof (Elf32_External_gptab);
5209 o->contents = (bfd_byte *) ext_tab;
5211 /* Skip this section later on (I don't think this currently
5212 matters, but someday it might). */
5213 o->link_order_head = (struct bfd_link_order *) NULL;
5217 /* Invoke the regular ELF backend linker to do all the work. */
5218 if (ABI_64_P (abfd))
5221 if (!bfd_elf64_bfd_final_link (abfd, info))
5228 else if (!bfd_elf32_bfd_final_link (abfd, info))
5231 /* Now write out the computed sections. */
5233 if (reginfo_sec != (asection *) NULL)
5235 Elf32_External_RegInfo ext;
5237 bfd_mips_elf32_swap_reginfo_out (abfd, ®info, &ext);
5238 if (! bfd_set_section_contents (abfd, reginfo_sec, (PTR) &ext,
5239 (file_ptr) 0, sizeof ext))
5243 if (mdebug_sec != (asection *) NULL)
5245 BFD_ASSERT (abfd->output_has_begun);
5246 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
5248 mdebug_sec->filepos))
5251 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
5254 if (gptab_data_sec != (asection *) NULL)
5256 if (! bfd_set_section_contents (abfd, gptab_data_sec,
5257 gptab_data_sec->contents,
5259 gptab_data_sec->_raw_size))
5263 if (gptab_bss_sec != (asection *) NULL)
5265 if (! bfd_set_section_contents (abfd, gptab_bss_sec,
5266 gptab_bss_sec->contents,
5268 gptab_bss_sec->_raw_size))
5272 if (SGI_COMPAT (abfd))
5274 rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
5275 if (rtproc_sec != NULL)
5277 if (! bfd_set_section_contents (abfd, rtproc_sec,
5278 rtproc_sec->contents,
5280 rtproc_sec->_raw_size))
5288 /* This function is called via qsort() to sort the dynamic relocation
5289 entries by increasing r_symndx value. */
5292 sort_dynamic_relocs (arg1, arg2)
5296 const Elf32_External_Rel *ext_reloc1 = (const Elf32_External_Rel *) arg1;
5297 const Elf32_External_Rel *ext_reloc2 = (const Elf32_External_Rel *) arg2;
5299 Elf_Internal_Rel int_reloc1;
5300 Elf_Internal_Rel int_reloc2;
5302 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, ext_reloc1, &int_reloc1);
5303 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, ext_reloc2, &int_reloc2);
5305 return (ELF32_R_SYM (int_reloc1.r_info) - ELF32_R_SYM (int_reloc2.r_info));
5308 /* Returns the GOT section for ABFD. */
5311 mips_elf_got_section (abfd)
5314 return bfd_get_section_by_name (abfd, ".got");
5317 /* Returns the GOT information associated with the link indicated by
5318 INFO. If SGOTP is non-NULL, it is filled in with the GOT
5321 static struct mips_got_info *
5322 mips_elf_got_info (abfd, sgotp)
5327 struct mips_got_info *g;
5329 sgot = mips_elf_got_section (abfd);
5330 BFD_ASSERT (sgot != NULL);
5331 BFD_ASSERT (elf_section_data (sgot) != NULL);
5332 g = (struct mips_got_info *) elf_section_data (sgot)->tdata;
5333 BFD_ASSERT (g != NULL);
5340 /* Return whether a relocation is against a local symbol. */
5343 mips_elf_local_relocation_p (input_bfd, relocation, local_sections,
5346 const Elf_Internal_Rela *relocation;
5347 asection **local_sections;
5348 boolean check_forced;
5350 unsigned long r_symndx;
5351 Elf_Internal_Shdr *symtab_hdr;
5352 struct mips_elf_link_hash_entry *h;
5355 r_symndx = ELF32_R_SYM (relocation->r_info);
5356 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5357 extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
5359 if (r_symndx < extsymoff)
5361 if (elf_bad_symtab (input_bfd) && local_sections[r_symndx] != NULL)
5366 /* Look up the hash table to check whether the symbol
5367 was forced local. */
5368 h = (struct mips_elf_link_hash_entry *)
5369 elf_sym_hashes (input_bfd) [r_symndx - extsymoff];
5370 /* Find the real hash-table entry for this symbol. */
5371 while (h->root.root.type == bfd_link_hash_indirect
5372 || h->root.root.type == bfd_link_hash_warning)
5373 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
5374 if ((h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)
5381 /* Sign-extend VALUE, which has the indicated number of BITS. */
5384 mips_elf_sign_extend (value, bits)
5388 if (value & ((bfd_vma) 1 << (bits - 1)))
5389 /* VALUE is negative. */
5390 value |= ((bfd_vma) - 1) << bits;
5395 /* Return non-zero if the indicated VALUE has overflowed the maximum
5396 range expressable by a signed number with the indicated number of
5400 mips_elf_overflow_p (value, bits)
5404 bfd_signed_vma svalue = (bfd_signed_vma) value;
5406 if (svalue > (1 << (bits - 1)) - 1)
5407 /* The value is too big. */
5409 else if (svalue < -(1 << (bits - 1)))
5410 /* The value is too small. */
5417 /* Calculate the %high function. */
5420 mips_elf_high (value)
5423 return ((value + (bfd_vma) 0x8000) >> 16) & 0xffff;
5426 /* Calculate the %higher function. */
5429 mips_elf_higher (value)
5430 bfd_vma value ATTRIBUTE_UNUSED;
5433 return ((value + (bfd_vma) 0x80008000) >> 32) & 0xffff;
5436 return (bfd_vma) -1;
5440 /* Calculate the %highest function. */
5443 mips_elf_highest (value)
5444 bfd_vma value ATTRIBUTE_UNUSED;
5447 return ((value + (bfd_vma) 0x800080008000) >> 48) & 0xffff;
5450 return (bfd_vma) -1;
5454 /* Returns the GOT index for the global symbol indicated by H. */
5457 mips_elf_global_got_index (abfd, h)
5459 struct elf_link_hash_entry *h;
5463 struct mips_got_info *g;
5465 g = mips_elf_got_info (abfd, &sgot);
5467 /* Once we determine the global GOT entry with the lowest dynamic
5468 symbol table index, we must put all dynamic symbols with greater
5469 indices into the GOT. That makes it easy to calculate the GOT
5471 BFD_ASSERT (h->dynindx >= g->global_gotsym->dynindx);
5472 index = ((h->dynindx - g->global_gotsym->dynindx + g->local_gotno)
5473 * MIPS_ELF_GOT_SIZE (abfd));
5474 BFD_ASSERT (index < sgot->_raw_size);
5479 /* Returns the offset for the entry at the INDEXth position
5483 mips_elf_got_offset_from_index (dynobj, output_bfd, index)
5491 sgot = mips_elf_got_section (dynobj);
5492 gp = _bfd_get_gp_value (output_bfd);
5493 return (sgot->output_section->vma + sgot->output_offset + index -
5497 /* If H is a symbol that needs a global GOT entry, but has a dynamic
5498 symbol table index lower than any we've seen to date, record it for
5502 mips_elf_record_global_got_symbol (h, info, g)
5503 struct elf_link_hash_entry *h;
5504 struct bfd_link_info *info;
5505 struct mips_got_info *g ATTRIBUTE_UNUSED;
5507 /* A global symbol in the GOT must also be in the dynamic symbol
5509 if (h->dynindx == -1
5510 && !bfd_elf32_link_record_dynamic_symbol (info, h))
5513 /* If we've already marked this entry as need GOT space, we don't
5514 need to do it again. */
5515 if (h->got.offset != (bfd_vma) - 1)
5518 /* By setting this to a value other than -1, we are indicating that
5519 there needs to be a GOT entry for H. */
5525 /* This structure is passed to mips_elf_sort_hash_table_f when sorting
5526 the dynamic symbols. */
5528 struct mips_elf_hash_sort_data
5530 /* The symbol in the global GOT with the lowest dynamic symbol table
5532 struct elf_link_hash_entry *low;
5533 /* The least dynamic symbol table index corresponding to a symbol
5534 with a GOT entry. */
5535 long min_got_dynindx;
5536 /* The greatest dynamic symbol table index not corresponding to a
5537 symbol without a GOT entry. */
5538 long max_non_got_dynindx;
5541 /* If H needs a GOT entry, assign it the highest available dynamic
5542 index. Otherwise, assign it the lowest available dynamic
5546 mips_elf_sort_hash_table_f (h, data)
5547 struct mips_elf_link_hash_entry *h;
5550 struct mips_elf_hash_sort_data *hsd
5551 = (struct mips_elf_hash_sort_data *) data;
5553 /* Symbols without dynamic symbol table entries aren't interesting
5555 if (h->root.dynindx == -1)
5558 if (h->root.got.offset != 0)
5559 h->root.dynindx = hsd->max_non_got_dynindx++;
5562 h->root.dynindx = --hsd->min_got_dynindx;
5563 hsd->low = (struct elf_link_hash_entry *) h;
5569 /* Sort the dynamic symbol table so that symbols that need GOT entries
5570 appear towards the end. This reduces the amount of GOT space
5571 required. MAX_LOCAL is used to set the number of local symbols
5572 known to be in the dynamic symbol table. During
5573 mips_elf_size_dynamic_sections, this value is 1. Afterward, the
5574 section symbols are added and the count is higher. */
5577 mips_elf_sort_hash_table (info, max_local)
5578 struct bfd_link_info *info;
5579 unsigned long max_local;
5581 struct mips_elf_hash_sort_data hsd;
5582 struct mips_got_info *g;
5585 dynobj = elf_hash_table (info)->dynobj;
5588 hsd.min_got_dynindx = elf_hash_table (info)->dynsymcount;
5589 hsd.max_non_got_dynindx = max_local;
5590 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table *)
5591 elf_hash_table (info)),
5592 mips_elf_sort_hash_table_f,
5595 /* There shoud have been enough room in the symbol table to
5596 accomodate both the GOT and non-GOT symbols. */
5597 BFD_ASSERT (hsd.max_non_got_dynindx <= hsd.min_got_dynindx);
5599 /* Now we know which dynamic symbol has the lowest dynamic symbol
5600 table index in the GOT. */
5601 g = mips_elf_got_info (dynobj, NULL);
5602 g->global_gotsym = hsd.low;
5607 /* Create a local GOT entry for VALUE. Return the index of the entry,
5608 or -1 if it could not be created. */
5611 mips_elf_create_local_got_entry (abfd, g, sgot, value)
5613 struct mips_got_info *g;
5617 if (g->assigned_gotno >= g->local_gotno)
5619 /* We didn't allocate enough space in the GOT. */
5620 (*_bfd_error_handler)
5621 (_("not enough GOT space for local GOT entries"));
5622 bfd_set_error (bfd_error_bad_value);
5623 return (bfd_vma) -1;
5626 MIPS_ELF_PUT_WORD (abfd, value,
5628 + MIPS_ELF_GOT_SIZE (abfd) * g->assigned_gotno));
5629 return MIPS_ELF_GOT_SIZE (abfd) * g->assigned_gotno++;
5632 /* Returns the GOT offset at which the indicated address can be found.
5633 If there is not yet a GOT entry for this value, create one. Returns
5634 -1 if no satisfactory GOT offset can be found. */
5637 mips_elf_local_got_index (abfd, info, value)
5639 struct bfd_link_info *info;
5643 struct mips_got_info *g;
5646 g = mips_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
5648 /* Look to see if we already have an appropriate entry. */
5649 for (entry = (sgot->contents
5650 + MIPS_ELF_GOT_SIZE (abfd) * MIPS_RESERVED_GOTNO);
5651 entry != sgot->contents + MIPS_ELF_GOT_SIZE (abfd) * g->assigned_gotno;
5652 entry += MIPS_ELF_GOT_SIZE (abfd))
5654 bfd_vma address = MIPS_ELF_GET_WORD (abfd, entry);
5655 if (address == value)
5656 return entry - sgot->contents;
5659 return mips_elf_create_local_got_entry (abfd, g, sgot, value);
5662 /* Find a GOT entry that is within 32KB of the VALUE. These entries
5663 are supposed to be placed at small offsets in the GOT, i.e.,
5664 within 32KB of GP. Return the index into the GOT for this page,
5665 and store the offset from this entry to the desired address in
5666 OFFSETP, if it is non-NULL. */
5669 mips_elf_got_page (abfd, info, value, offsetp)
5671 struct bfd_link_info *info;
5676 struct mips_got_info *g;
5678 bfd_byte *last_entry;
5682 g = mips_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
5684 /* Look to see if we aleady have an appropriate entry. */
5685 last_entry = sgot->contents + MIPS_ELF_GOT_SIZE (abfd) * g->assigned_gotno;
5686 for (entry = (sgot->contents
5687 + MIPS_ELF_GOT_SIZE (abfd) * MIPS_RESERVED_GOTNO);
5688 entry != last_entry;
5689 entry += MIPS_ELF_GOT_SIZE (abfd))
5691 address = MIPS_ELF_GET_WORD (abfd, entry);
5693 if (!mips_elf_overflow_p (value - address, 16))
5695 /* This entry will serve as the page pointer. We can add a
5696 16-bit number to it to get the actual address. */
5697 index = entry - sgot->contents;
5702 /* If we didn't have an appropriate entry, we create one now. */
5703 if (entry == last_entry)
5704 index = mips_elf_create_local_got_entry (abfd, g, sgot, value);
5708 address = MIPS_ELF_GET_WORD (abfd, entry);
5709 *offsetp = value - address;
5715 /* Find a GOT entry whose higher-order 16 bits are the same as those
5716 for value. Return the index into the GOT for this entry. */
5719 mips_elf_got16_entry (abfd, info, value, external)
5721 struct bfd_link_info *info;
5726 struct mips_got_info *g;
5728 bfd_byte *last_entry;
5734 /* Although the ABI says that it is "the high-order 16 bits" that we
5735 want, it is really the %high value. The complete value is
5736 calculated with a `addiu' of a LO16 relocation, just as with a
5738 value = mips_elf_high (value) << 16;
5741 g = mips_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
5743 /* Look to see if we already have an appropriate entry. */
5744 last_entry = sgot->contents + MIPS_ELF_GOT_SIZE (abfd) * g->assigned_gotno;
5745 for (entry = (sgot->contents
5746 + MIPS_ELF_GOT_SIZE (abfd) * MIPS_RESERVED_GOTNO);
5747 entry != last_entry;
5748 entry += MIPS_ELF_GOT_SIZE (abfd))
5750 address = MIPS_ELF_GET_WORD (abfd, entry);
5751 if (address == value)
5753 /* This entry has the right high-order 16 bits, and the low-order
5754 16 bits are set to zero. */
5755 index = entry - sgot->contents;
5760 /* If we didn't have an appropriate entry, we create one now. */
5761 if (entry == last_entry)
5762 index = mips_elf_create_local_got_entry (abfd, g, sgot, value);
5767 /* Returns the first relocation of type r_type found, beginning with
5768 RELOCATION. RELEND is one-past-the-end of the relocation table. */
5770 static const Elf_Internal_Rela *
5771 mips_elf_next_relocation (r_type, relocation, relend)
5772 unsigned int r_type;
5773 const Elf_Internal_Rela *relocation;
5774 const Elf_Internal_Rela *relend;
5776 /* According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must be
5777 immediately following. However, for the IRIX6 ABI, the next
5778 relocation may be a composed relocation consisting of several
5779 relocations for the same address. In that case, the R_MIPS_LO16
5780 relocation may occur as one of these. We permit a similar
5781 extension in general, as that is useful for GCC. */
5782 while (relocation < relend)
5784 if (ELF32_R_TYPE (relocation->r_info) == r_type)
5790 /* We didn't find it. */
5791 bfd_set_error (bfd_error_bad_value);
5795 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
5796 is the original relocation, which is now being transformed into a
5797 dynamic relocation. The ADDENDP is adjusted if necessary; the
5798 caller should store the result in place of the original addend. */
5801 mips_elf_create_dynamic_relocation (output_bfd, info, rel, h, sec,
5802 symbol, addendp, input_section)
5804 struct bfd_link_info *info;
5805 const Elf_Internal_Rela *rel;
5806 struct mips_elf_link_hash_entry *h;
5810 asection *input_section;
5812 Elf_Internal_Rel outrel;
5818 r_type = ELF32_R_TYPE (rel->r_info);
5819 dynobj = elf_hash_table (info)->dynobj;
5821 = bfd_get_section_by_name (dynobj,
5822 MIPS_ELF_REL_DYN_SECTION_NAME (output_bfd));
5823 BFD_ASSERT (sreloc != NULL);
5824 BFD_ASSERT (sreloc->contents != NULL);
5825 BFD_ASSERT (sreloc->reloc_count * MIPS_ELF_REL_SIZE (output_bfd)
5826 < sreloc->_raw_size);
5830 /* We begin by assuming that the offset for the dynamic relocation
5831 is the same as for the original relocation. We'll adjust this
5832 later to reflect the correct output offsets. */
5833 if (elf_section_data (input_section)->stab_info == NULL)
5834 outrel.r_offset = rel->r_offset;
5837 /* Except that in a stab section things are more complex.
5838 Because we compress stab information, the offset given in the
5839 relocation may not be the one we want; we must let the stabs
5840 machinery tell us the offset. */
5842 = (_bfd_stab_section_offset
5843 (output_bfd, &elf_hash_table (info)->stab_info,
5845 &elf_section_data (input_section)->stab_info,
5847 /* If we didn't need the relocation at all, this value will be
5849 if (outrel.r_offset == (bfd_vma) -1)
5853 /* If we've decided to skip this relocation, just output an empty
5854 record. Note that R_MIPS_NONE == 0, so that this call to memset
5855 is a way of setting R_TYPE to R_MIPS_NONE. */
5857 memset (&outrel, 0, sizeof (outrel));
5861 bfd_vma section_offset;
5863 /* We must now calculate the dynamic symbol table index to use
5864 in the relocation. */
5866 && (! info->symbolic || (h->root.elf_link_hash_flags
5867 & ELF_LINK_HASH_DEF_REGULAR) == 0))
5869 indx = h->root.dynindx;
5870 /* h->root.dynindx may be -1 if this symbol was marked to
5877 if (sec != NULL && bfd_is_abs_section (sec))
5879 else if (sec == NULL || sec->owner == NULL)
5881 bfd_set_error (bfd_error_bad_value);
5886 indx = elf_section_data (sec->output_section)->dynindx;
5891 /* Figure out how far the target of the relocation is from
5892 the beginning of its section. */
5893 section_offset = symbol - sec->output_section->vma;
5894 /* The relocation we're building is section-relative.
5895 Therefore, the original addend must be adjusted by the
5897 *addendp += section_offset;
5898 /* Now, the relocation is just against the section. */
5899 symbol = sec->output_section->vma;
5902 /* If the relocation was previously an absolute relocation and
5903 this symbol will not be referred to by the relocation, we must
5904 adjust it by the value we give it in the dynamic symbol table.
5905 Otherwise leave the job up to the dynamic linker. */
5906 if (!indx && r_type != R_MIPS_REL32)
5909 /* The relocation is always an REL32 relocation because we don't
5910 know where the shared library will wind up at load-time. */
5911 outrel.r_info = ELF32_R_INFO (indx, R_MIPS_REL32);
5913 /* Adjust the output offset of the relocation to reference the
5914 correct location in the output file. */
5915 outrel.r_offset += (input_section->output_section->vma
5916 + input_section->output_offset);
5919 /* Put the relocation back out. We have to use the special
5920 relocation outputter in the 64-bit case since the 64-bit
5921 relocation format is non-standard. */
5922 if (ABI_64_P (output_bfd))
5924 (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
5925 (output_bfd, &outrel,
5927 + sreloc->reloc_count * sizeof (Elf64_Mips_External_Rel)));
5930 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
5931 (((Elf32_External_Rel *)
5933 + sreloc->reloc_count));
5935 /* Record the index of the first relocation referencing H. This
5936 information is later emitted in the .msym section. */
5938 && (h->min_dyn_reloc_index == 0
5939 || sreloc->reloc_count < h->min_dyn_reloc_index))
5940 h->min_dyn_reloc_index = sreloc->reloc_count;
5942 /* We've now added another relocation. */
5943 ++sreloc->reloc_count;
5945 /* Make sure the output section is writable. The dynamic linker
5946 will be writing to it. */
5947 elf_section_data (input_section->output_section)->this_hdr.sh_flags
5950 /* On IRIX5, make an entry of compact relocation info. */
5951 if (! skip && IRIX_COMPAT (output_bfd) == ict_irix5)
5953 asection *scpt = bfd_get_section_by_name (dynobj, ".compact_rel");
5958 Elf32_crinfo cptrel;
5960 mips_elf_set_cr_format (cptrel, CRF_MIPS_LONG);
5961 cptrel.vaddr = (rel->r_offset
5962 + input_section->output_section->vma
5963 + input_section->output_offset);
5964 if (r_type == R_MIPS_REL32)
5965 mips_elf_set_cr_type (cptrel, CRT_MIPS_REL32);
5967 mips_elf_set_cr_type (cptrel, CRT_MIPS_WORD);
5968 mips_elf_set_cr_dist2to (cptrel, 0);
5969 cptrel.konst = *addendp;
5971 cr = (scpt->contents
5972 + sizeof (Elf32_External_compact_rel));
5973 bfd_elf32_swap_crinfo_out (output_bfd, &cptrel,
5974 ((Elf32_External_crinfo *) cr
5975 + scpt->reloc_count));
5976 ++scpt->reloc_count;
5983 /* Calculate the value produced by the RELOCATION (which comes from
5984 the INPUT_BFD). The ADDEND is the addend to use for this
5985 RELOCATION; RELOCATION->R_ADDEND is ignored.
5987 The result of the relocation calculation is stored in VALUEP.
5988 REQUIRE_JALXP indicates whether or not the opcode used with this
5989 relocation must be JALX.
5991 This function returns bfd_reloc_continue if the caller need take no
5992 further action regarding this relocation, bfd_reloc_notsupported if
5993 something goes dramatically wrong, bfd_reloc_overflow if an
5994 overflow occurs, and bfd_reloc_ok to indicate success. */
5996 static bfd_reloc_status_type
5997 mips_elf_calculate_relocation (abfd,
6011 asection *input_section;
6012 struct bfd_link_info *info;
6013 const Elf_Internal_Rela *relocation;
6015 reloc_howto_type *howto;
6016 Elf_Internal_Sym *local_syms;
6017 asection **local_sections;
6020 boolean *require_jalxp;
6022 /* The eventual value we will return. */
6024 /* The address of the symbol against which the relocation is
6027 /* The final GP value to be used for the relocatable, executable, or
6028 shared object file being produced. */
6029 bfd_vma gp = (bfd_vma) - 1;
6030 /* The place (section offset or address) of the storage unit being
6033 /* The value of GP used to create the relocatable object. */
6034 bfd_vma gp0 = (bfd_vma) - 1;
6035 /* The offset into the global offset table at which the address of
6036 the relocation entry symbol, adjusted by the addend, resides
6037 during execution. */
6038 bfd_vma g = (bfd_vma) - 1;
6039 /* The section in which the symbol referenced by the relocation is
6041 asection *sec = NULL;
6042 struct mips_elf_link_hash_entry *h = NULL;
6043 /* True if the symbol referred to by this relocation is a local
6046 /* True if the symbol referred to by this relocation is "_gp_disp". */
6047 boolean gp_disp_p = false;
6048 Elf_Internal_Shdr *symtab_hdr;
6050 unsigned long r_symndx;
6052 /* True if overflow occurred during the calculation of the
6053 relocation value. */
6054 boolean overflowed_p;
6055 /* True if this relocation refers to a MIPS16 function. */
6056 boolean target_is_16_bit_code_p = false;
6058 /* Parse the relocation. */
6059 r_symndx = ELF32_R_SYM (relocation->r_info);
6060 r_type = ELF32_R_TYPE (relocation->r_info);
6061 p = (input_section->output_section->vma
6062 + input_section->output_offset
6063 + relocation->r_offset);
6065 /* Assume that there will be no overflow. */
6066 overflowed_p = false;
6068 /* Figure out whether or not the symbol is local, and get the offset
6069 used in the array of hash table entries. */
6070 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
6071 local_p = mips_elf_local_relocation_p (input_bfd, relocation,
6072 local_sections, false);
6073 if (! elf_bad_symtab (input_bfd))
6074 extsymoff = symtab_hdr->sh_info;
6077 /* The symbol table does not follow the rule that local symbols
6078 must come before globals. */
6082 /* Figure out the value of the symbol. */
6085 Elf_Internal_Sym *sym;
6087 sym = local_syms + r_symndx;
6088 sec = local_sections[r_symndx];
6090 symbol = sec->output_section->vma + sec->output_offset;
6091 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
6092 symbol += sym->st_value;
6094 /* MIPS16 text labels should be treated as odd. */
6095 if (sym->st_other == STO_MIPS16)
6098 /* Record the name of this symbol, for our caller. */
6099 *namep = bfd_elf_string_from_elf_section (input_bfd,
6100 symtab_hdr->sh_link,
6103 *namep = bfd_section_name (input_bfd, sec);
6105 target_is_16_bit_code_p = (sym->st_other == STO_MIPS16);
6109 /* For global symbols we look up the symbol in the hash-table. */
6110 h = ((struct mips_elf_link_hash_entry *)
6111 elf_sym_hashes (input_bfd) [r_symndx - extsymoff]);
6112 /* Find the real hash-table entry for this symbol. */
6113 while (h->root.root.type == bfd_link_hash_indirect
6114 || h->root.root.type == bfd_link_hash_warning)
6115 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
6117 /* Record the name of this symbol, for our caller. */
6118 *namep = h->root.root.root.string;
6120 /* See if this is the special _gp_disp symbol. Note that such a
6121 symbol must always be a global symbol. */
6122 if (strcmp (h->root.root.root.string, "_gp_disp") == 0)
6124 /* Relocations against _gp_disp are permitted only with
6125 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
6126 if (r_type != R_MIPS_HI16 && r_type != R_MIPS_LO16)
6127 return bfd_reloc_notsupported;
6131 /* If this symbol is defined, calculate its address. Note that
6132 _gp_disp is a magic symbol, always implicitly defined by the
6133 linker, so it's inappropriate to check to see whether or not
6135 else if ((h->root.root.type == bfd_link_hash_defined
6136 || h->root.root.type == bfd_link_hash_defweak)
6137 && h->root.root.u.def.section)
6139 sec = h->root.root.u.def.section;
6140 if (sec->output_section)
6141 symbol = (h->root.root.u.def.value
6142 + sec->output_section->vma
6143 + sec->output_offset);
6145 symbol = h->root.root.u.def.value;
6147 else if (h->root.root.type == bfd_link_hash_undefweak)
6148 /* We allow relocations against undefined weak symbols, giving
6149 it the value zero, so that you can undefined weak functions
6150 and check to see if they exist by looking at their
6153 else if (info->shared && !info->symbolic && !info->no_undefined
6154 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
6156 else if (strcmp (h->root.root.root.string, "_DYNAMIC_LINK") == 0 ||
6157 strcmp (h->root.root.root.string, "_DYNAMIC_LINKING") == 0)
6159 /* If this is a dynamic link, we should have created a
6160 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
6161 in in mips_elf_create_dynamic_sections.
6162 Otherwise, we should define the symbol with a value of 0.
6163 FIXME: It should probably get into the symbol table
6165 BFD_ASSERT (! info->shared);
6166 BFD_ASSERT (bfd_get_section_by_name (abfd, ".dynamic") == NULL);
6171 if (! ((*info->callbacks->undefined_symbol)
6172 (info, h->root.root.root.string, input_bfd,
6173 input_section, relocation->r_offset,
6174 (!info->shared || info->no_undefined
6175 || ELF_ST_VISIBILITY (h->root.other)))))
6176 return bfd_reloc_undefined;
6180 target_is_16_bit_code_p = (h->root.other == STO_MIPS16);
6183 /* If this is a 32-bit call to a 16-bit function with a stub, we
6184 need to redirect the call to the stub, unless we're already *in*
6186 if (r_type != R_MIPS16_26 && !info->relocateable
6187 && ((h != NULL && h->fn_stub != NULL)
6188 || (local_p && elf_tdata (input_bfd)->local_stubs != NULL
6189 && elf_tdata (input_bfd)->local_stubs[r_symndx] != NULL))
6190 && !mips_elf_stub_section_p (input_bfd, input_section))
6192 /* This is a 32-bit call to a 16-bit function. We should
6193 have already noticed that we were going to need the
6196 sec = elf_tdata (input_bfd)->local_stubs[r_symndx];
6199 BFD_ASSERT (h->need_fn_stub);
6203 symbol = sec->output_section->vma + sec->output_offset;
6205 /* If this is a 16-bit call to a 32-bit function with a stub, we
6206 need to redirect the call to the stub. */
6207 else if (r_type == R_MIPS16_26 && !info->relocateable
6209 && (h->call_stub != NULL || h->call_fp_stub != NULL)
6210 && !target_is_16_bit_code_p)
6212 /* If both call_stub and call_fp_stub are defined, we can figure
6213 out which one to use by seeing which one appears in the input
6215 if (h->call_stub != NULL && h->call_fp_stub != NULL)
6220 for (o = input_bfd->sections; o != NULL; o = o->next)
6222 if (strncmp (bfd_get_section_name (input_bfd, o),
6223 CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
6225 sec = h->call_fp_stub;
6232 else if (h->call_stub != NULL)
6235 sec = h->call_fp_stub;
6237 BFD_ASSERT (sec->_raw_size > 0);
6238 symbol = sec->output_section->vma + sec->output_offset;
6241 /* Calls from 16-bit code to 32-bit code and vice versa require the
6242 special jalx instruction. */
6243 *require_jalxp = (!info->relocateable
6244 && ((r_type == R_MIPS16_26) != target_is_16_bit_code_p));
6246 local_p = mips_elf_local_relocation_p (input_bfd, relocation,
6247 local_sections, true);
6249 /* If we haven't already determined the GOT offset, or the GP value,
6250 and we're going to need it, get it now. */
6255 case R_MIPS_GOT_DISP:
6256 case R_MIPS_GOT_HI16:
6257 case R_MIPS_CALL_HI16:
6258 case R_MIPS_GOT_LO16:
6259 case R_MIPS_CALL_LO16:
6260 /* Find the index into the GOT where this value is located. */
6263 BFD_ASSERT (addend == 0);
6264 g = mips_elf_global_got_index
6265 (elf_hash_table (info)->dynobj,
6266 (struct elf_link_hash_entry *) h);
6267 if (! elf_hash_table(info)->dynamic_sections_created
6269 && (info->symbolic || h->root.dynindx == -1)
6270 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
6272 /* This is a static link or a -Bsymbolic link. The
6273 symbol is defined locally, or was forced to be local.
6274 We must initialize this entry in the GOT. */
6275 asection *sgot = mips_elf_got_section(elf_hash_table
6277 MIPS_ELF_PUT_WORD (elf_hash_table (info)->dynobj,
6278 symbol + addend, sgot->contents + g);
6281 else if (r_type == R_MIPS_GOT16 || r_type == R_MIPS_CALL16)
6282 /* There's no need to create a local GOT entry here; the
6283 calculation for a local GOT16 entry does not involve G. */
6287 g = mips_elf_local_got_index (abfd, info, symbol + addend);
6288 if (g == (bfd_vma) -1)
6292 /* Convert GOT indices to actual offsets. */
6293 g = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
6299 case R_MIPS_GPREL16:
6300 case R_MIPS_GPREL32:
6301 case R_MIPS_LITERAL:
6302 gp0 = _bfd_get_gp_value (input_bfd);
6303 gp = _bfd_get_gp_value (abfd);
6310 /* Figure out what kind of relocation is being performed. */
6314 return bfd_reloc_continue;
6317 value = symbol + mips_elf_sign_extend (addend, 16);
6318 overflowed_p = mips_elf_overflow_p (value, 16);
6325 || (elf_hash_table (info)->dynamic_sections_created
6327 && ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC)
6329 && (input_section->flags & SEC_ALLOC) != 0)
6331 /* If we're creating a shared library, or this relocation is
6332 against a symbol in a shared library, then we can't know
6333 where the symbol will end up. So, we create a relocation
6334 record in the output, and leave the job up to the dynamic
6337 if (!mips_elf_create_dynamic_relocation (abfd,
6349 if (r_type != R_MIPS_REL32)
6350 value = symbol + addend;
6354 value &= howto->dst_mask;
6359 case R_MIPS_GNU_REL_LO16:
6360 value = symbol + addend - p;
6361 value &= howto->dst_mask;
6364 case R_MIPS_GNU_REL16_S2:
6365 value = symbol + mips_elf_sign_extend (addend << 2, 18) - p;
6366 overflowed_p = mips_elf_overflow_p (value, 18);
6367 value = (value >> 2) & howto->dst_mask;
6370 case R_MIPS_GNU_REL_HI16:
6371 value = mips_elf_high (addend + symbol - p);
6372 value &= howto->dst_mask;
6376 /* The calculation for R_MIPS16_26 is just the same as for an
6377 R_MIPS_26. It's only the storage of the relocated field into
6378 the output file that's different. That's handled in
6379 mips_elf_perform_relocation. So, we just fall through to the
6380 R_MIPS_26 case here. */
6383 value = (((addend << 2) | ((p + 4) & 0xf0000000)) + symbol) >> 2;
6385 value = (mips_elf_sign_extend (addend << 2, 28) + symbol) >> 2;
6386 value &= howto->dst_mask;
6392 value = mips_elf_high (addend + symbol);
6393 value &= howto->dst_mask;
6397 value = mips_elf_high (addend + gp - p);
6398 overflowed_p = mips_elf_overflow_p (value, 16);
6404 value = (symbol + addend) & howto->dst_mask;
6407 value = addend + gp - p + 4;
6408 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
6409 for overflow. But, on, say, Irix 5, relocations against
6410 _gp_disp are normally generated from the .cpload
6411 pseudo-op. It generates code that normally looks like
6414 lui $gp,%hi(_gp_disp)
6415 addiu $gp,$gp,%lo(_gp_disp)
6418 Here $t9 holds the address of the function being called,
6419 as required by the MIPS ELF ABI. The R_MIPS_LO16
6420 relocation can easily overflow in this situation, but the
6421 R_MIPS_HI16 relocation will handle the overflow.
6422 Therefore, we consider this a bug in the MIPS ABI, and do
6423 not check for overflow here. */
6427 case R_MIPS_LITERAL:
6428 /* Because we don't merge literal sections, we can handle this
6429 just like R_MIPS_GPREL16. In the long run, we should merge
6430 shared literals, and then we will need to additional work
6435 case R_MIPS16_GPREL:
6436 /* The R_MIPS16_GPREL performs the same calculation as
6437 R_MIPS_GPREL16, but stores the relocated bits in a different
6438 order. We don't need to do anything special here; the
6439 differences are handled in mips_elf_perform_relocation. */
6440 case R_MIPS_GPREL16:
6442 value = mips_elf_sign_extend (addend, 16) + symbol + gp0 - gp;
6444 value = mips_elf_sign_extend (addend, 16) + symbol - gp;
6445 overflowed_p = mips_elf_overflow_p (value, 16);
6454 /* The special case is when the symbol is forced to be local. We
6455 need the full address in the GOT since no R_MIPS_LO16 relocation
6457 forced = ! mips_elf_local_relocation_p (input_bfd, relocation,
6458 local_sections, false);
6459 value = mips_elf_got16_entry (abfd, info, symbol + addend, forced);
6460 if (value == (bfd_vma) -1)
6463 = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
6466 overflowed_p = mips_elf_overflow_p (value, 16);
6472 case R_MIPS_GOT_DISP:
6474 overflowed_p = mips_elf_overflow_p (value, 16);
6477 case R_MIPS_GPREL32:
6478 value = (addend + symbol + gp0 - gp) & howto->dst_mask;
6482 value = mips_elf_sign_extend (addend, 16) + symbol - p;
6483 value = (bfd_vma) ((bfd_signed_vma) value / 4);
6484 overflowed_p = mips_elf_overflow_p (value, 16);
6487 case R_MIPS_GOT_HI16:
6488 case R_MIPS_CALL_HI16:
6489 /* We're allowed to handle these two relocations identically.
6490 The dynamic linker is allowed to handle the CALL relocations
6491 differently by creating a lazy evaluation stub. */
6493 value = mips_elf_high (value);
6494 value &= howto->dst_mask;
6497 case R_MIPS_GOT_LO16:
6498 case R_MIPS_CALL_LO16:
6499 value = g & howto->dst_mask;
6502 case R_MIPS_GOT_PAGE:
6503 value = mips_elf_got_page (abfd, info, symbol + addend, NULL);
6504 if (value == (bfd_vma) -1)
6506 value = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
6509 overflowed_p = mips_elf_overflow_p (value, 16);
6512 case R_MIPS_GOT_OFST:
6513 mips_elf_got_page (abfd, info, symbol + addend, &value);
6514 overflowed_p = mips_elf_overflow_p (value, 16);
6518 value = symbol - addend;
6519 value &= howto->dst_mask;
6523 value = mips_elf_higher (addend + symbol);
6524 value &= howto->dst_mask;
6527 case R_MIPS_HIGHEST:
6528 value = mips_elf_highest (addend + symbol);
6529 value &= howto->dst_mask;
6532 case R_MIPS_SCN_DISP:
6533 value = symbol + addend - sec->output_offset;
6534 value &= howto->dst_mask;
6539 /* Both of these may be ignored. R_MIPS_JALR is an optimization
6540 hint; we could improve performance by honoring that hint. */
6541 return bfd_reloc_continue;
6543 case R_MIPS_GNU_VTINHERIT:
6544 case R_MIPS_GNU_VTENTRY:
6545 /* We don't do anything with these at present. */
6546 return bfd_reloc_continue;
6549 /* An unrecognized relocation type. */
6550 return bfd_reloc_notsupported;
6553 /* Store the VALUE for our caller. */
6555 return overflowed_p ? bfd_reloc_overflow : bfd_reloc_ok;
6558 /* Obtain the field relocated by RELOCATION. */
6561 mips_elf_obtain_contents (howto, relocation, input_bfd, contents)
6562 reloc_howto_type *howto;
6563 const Elf_Internal_Rela *relocation;
6568 bfd_byte *location = contents + relocation->r_offset;
6570 /* Obtain the bytes. */
6571 x = bfd_get (8 * bfd_get_reloc_size (howto), input_bfd, location);
6573 if ((ELF32_R_TYPE (relocation->r_info) == R_MIPS16_26
6574 || ELF32_R_TYPE (relocation->r_info) == R_MIPS16_GPREL)
6575 && bfd_little_endian (input_bfd))
6576 /* The two 16-bit words will be reversed on a little-endian
6577 system. See mips_elf_perform_relocation for more details. */
6578 x = (((x & 0xffff) << 16) | ((x & 0xffff0000) >> 16));
6583 /* It has been determined that the result of the RELOCATION is the
6584 VALUE. Use HOWTO to place VALUE into the output file at the
6585 appropriate position. The SECTION is the section to which the
6586 relocation applies. If REQUIRE_JALX is true, then the opcode used
6587 for the relocation must be either JAL or JALX, and it is
6588 unconditionally converted to JALX.
6590 Returns false if anything goes wrong. */
6593 mips_elf_perform_relocation (info, howto, relocation, value,
6594 input_bfd, input_section,
6595 contents, require_jalx)
6596 struct bfd_link_info *info;
6597 reloc_howto_type *howto;
6598 const Elf_Internal_Rela *relocation;
6601 asection *input_section;
6603 boolean require_jalx;
6607 int r_type = ELF32_R_TYPE (relocation->r_info);
6609 /* Figure out where the relocation is occurring. */
6610 location = contents + relocation->r_offset;
6612 /* Obtain the current value. */
6613 x = mips_elf_obtain_contents (howto, relocation, input_bfd, contents);
6615 /* Clear the field we are setting. */
6616 x &= ~howto->dst_mask;
6618 /* If this is the R_MIPS16_26 relocation, we must store the
6619 value in a funny way. */
6620 if (r_type == R_MIPS16_26)
6622 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
6623 Most mips16 instructions are 16 bits, but these instructions
6626 The format of these instructions is:
6628 +--------------+--------------------------------+
6629 ! JALX ! X! Imm 20:16 ! Imm 25:21 !
6630 +--------------+--------------------------------+
6632 +-----------------------------------------------+
6634 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
6635 Note that the immediate value in the first word is swapped.
6637 When producing a relocateable object file, R_MIPS16_26 is
6638 handled mostly like R_MIPS_26. In particular, the addend is
6639 stored as a straight 26-bit value in a 32-bit instruction.
6640 (gas makes life simpler for itself by never adjusting a
6641 R_MIPS16_26 reloc to be against a section, so the addend is
6642 always zero). However, the 32 bit instruction is stored as 2
6643 16-bit values, rather than a single 32-bit value. In a
6644 big-endian file, the result is the same; in a little-endian
6645 file, the two 16-bit halves of the 32 bit value are swapped.
6646 This is so that a disassembler can recognize the jal
6649 When doing a final link, R_MIPS16_26 is treated as a 32 bit
6650 instruction stored as two 16-bit values. The addend A is the
6651 contents of the targ26 field. The calculation is the same as
6652 R_MIPS_26. When storing the calculated value, reorder the
6653 immediate value as shown above, and don't forget to store the
6654 value as two 16-bit values.
6656 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
6660 +--------+----------------------+
6664 +--------+----------------------+
6667 +----------+------+-------------+
6671 +----------+--------------------+
6672 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
6673 ((sub1 << 16) | sub2)).
6675 When producing a relocateable object file, the calculation is
6676 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
6677 When producing a fully linked file, the calculation is
6678 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
6679 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff) */
6681 if (!info->relocateable)
6682 /* Shuffle the bits according to the formula above. */
6683 value = (((value & 0x1f0000) << 5)
6684 | ((value & 0x3e00000) >> 5)
6685 | (value & 0xffff));
6687 else if (r_type == R_MIPS16_GPREL)
6689 /* R_MIPS16_GPREL is used for GP-relative addressing in mips16
6690 mode. A typical instruction will have a format like this:
6692 +--------------+--------------------------------+
6693 ! EXTEND ! Imm 10:5 ! Imm 15:11 !
6694 +--------------+--------------------------------+
6695 ! Major ! rx ! ry ! Imm 4:0 !
6696 +--------------+--------------------------------+
6698 EXTEND is the five bit value 11110. Major is the instruction
6701 This is handled exactly like R_MIPS_GPREL16, except that the
6702 addend is retrieved and stored as shown in this diagram; that
6703 is, the Imm fields above replace the V-rel16 field.
6705 All we need to do here is shuffle the bits appropriately. As
6706 above, the two 16-bit halves must be swapped on a
6707 little-endian system. */
6708 value = (((value & 0x7e0) << 16)
6709 | ((value & 0xf800) << 5)
6713 /* Set the field. */
6714 x |= (value & howto->dst_mask);
6716 /* If required, turn JAL into JALX. */
6720 bfd_vma opcode = x >> 26;
6721 bfd_vma jalx_opcode;
6723 /* Check to see if the opcode is already JAL or JALX. */
6724 if (r_type == R_MIPS16_26)
6726 ok = ((opcode == 0x6) || (opcode == 0x7));
6731 ok = ((opcode == 0x3) || (opcode == 0x1d));
6735 /* If the opcode is not JAL or JALX, there's a problem. */
6738 (*_bfd_error_handler)
6739 (_("%s: %s+0x%lx: jump to stub routine which is not jal"),
6740 bfd_get_filename (input_bfd),
6741 input_section->name,
6742 (unsigned long) relocation->r_offset);
6743 bfd_set_error (bfd_error_bad_value);
6747 /* Make this the JALX opcode. */
6748 x = (x & ~(0x3f << 26)) | (jalx_opcode << 26);
6751 /* Swap the high- and low-order 16 bits on little-endian systems
6752 when doing a MIPS16 relocation. */
6753 if ((r_type == R_MIPS16_GPREL || r_type == R_MIPS16_26)
6754 && bfd_little_endian (input_bfd))
6755 x = (((x & 0xffff) << 16) | ((x & 0xffff0000) >> 16));
6757 /* Put the value into the output. */
6758 bfd_put (8 * bfd_get_reloc_size (howto), input_bfd, x, location);
6762 /* Returns true if SECTION is a MIPS16 stub section. */
6765 mips_elf_stub_section_p (abfd, section)
6766 bfd *abfd ATTRIBUTE_UNUSED;
6769 const char *name = bfd_get_section_name (abfd, section);
6771 return (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0
6772 || strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0
6773 || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0);
6776 /* Relocate a MIPS ELF section. */
6779 _bfd_mips_elf_relocate_section (output_bfd, info, input_bfd, input_section,
6780 contents, relocs, local_syms, local_sections)
6782 struct bfd_link_info *info;
6784 asection *input_section;
6786 Elf_Internal_Rela *relocs;
6787 Elf_Internal_Sym *local_syms;
6788 asection **local_sections;
6790 Elf_Internal_Rela *rel;
6791 const Elf_Internal_Rela *relend;
6793 boolean use_saved_addend_p = false;
6794 struct elf_backend_data *bed;
6796 bed = get_elf_backend_data (output_bfd);
6797 relend = relocs + input_section->reloc_count * bed->s->int_rels_per_ext_rel;
6798 for (rel = relocs; rel < relend; ++rel)
6802 reloc_howto_type *howto;
6803 boolean require_jalx;
6804 /* True if the relocation is a RELA relocation, rather than a
6806 boolean rela_relocation_p = true;
6807 int r_type = ELF32_R_TYPE (rel->r_info);
6808 const char * msg = (const char *) NULL;
6810 /* Find the relocation howto for this relocation. */
6811 if (r_type == R_MIPS_64 && !ABI_64_P (output_bfd))
6813 /* Some 32-bit code uses R_MIPS_64. In particular, people use
6814 64-bit code, but make sure all their addresses are in the
6815 lowermost or uppermost 32-bit section of the 64-bit address
6816 space. Thus, when they use an R_MIPS_64 they mean what is
6817 usually meant by R_MIPS_32, with the exception that the
6818 stored value is sign-extended to 64 bits. */
6819 howto = elf_mips_howto_table + R_MIPS_32;
6821 /* On big-endian systems, we need to lie about the position
6823 if (bfd_big_endian (input_bfd))
6827 howto = mips_rtype_to_howto (r_type);
6829 if (!use_saved_addend_p)
6831 Elf_Internal_Shdr *rel_hdr;
6833 /* If these relocations were originally of the REL variety,
6834 we must pull the addend out of the field that will be
6835 relocated. Otherwise, we simply use the contents of the
6836 RELA relocation. To determine which flavor or relocation
6837 this is, we depend on the fact that the INPUT_SECTION's
6838 REL_HDR is read before its REL_HDR2. */
6839 rel_hdr = &elf_section_data (input_section)->rel_hdr;
6840 if ((size_t) (rel - relocs)
6841 >= (NUM_SHDR_ENTRIES (rel_hdr) * bed->s->int_rels_per_ext_rel))
6842 rel_hdr = elf_section_data (input_section)->rel_hdr2;
6843 if (rel_hdr->sh_entsize == MIPS_ELF_REL_SIZE (input_bfd))
6845 /* Note that this is a REL relocation. */
6846 rela_relocation_p = false;
6848 /* Get the addend, which is stored in the input file. */
6849 addend = mips_elf_obtain_contents (howto,
6853 addend &= howto->src_mask;
6855 /* For some kinds of relocations, the ADDEND is a
6856 combination of the addend stored in two different
6858 if (r_type == R_MIPS_HI16
6859 || r_type == R_MIPS_GNU_REL_HI16
6860 || (r_type == R_MIPS_GOT16
6861 && mips_elf_local_relocation_p (input_bfd, rel,
6862 local_sections, false)))
6865 const Elf_Internal_Rela *lo16_relocation;
6866 reloc_howto_type *lo16_howto;
6869 /* The combined value is the sum of the HI16 addend,
6870 left-shifted by sixteen bits, and the LO16
6871 addend, sign extended. (Usually, the code does
6872 a `lui' of the HI16 value, and then an `addiu' of
6875 Scan ahead to find a matching LO16 relocation. */
6876 if (r_type == R_MIPS_GNU_REL_HI16)
6877 lo = R_MIPS_GNU_REL_LO16;
6881 = mips_elf_next_relocation (lo, rel, relend);
6882 if (lo16_relocation == NULL)
6885 /* Obtain the addend kept there. */
6886 lo16_howto = mips_rtype_to_howto (lo);
6887 l = mips_elf_obtain_contents (lo16_howto,
6889 input_bfd, contents);
6890 l &= lo16_howto->src_mask;
6891 l = mips_elf_sign_extend (l, 16);
6895 /* Compute the combined addend. */
6898 else if (r_type == R_MIPS16_GPREL)
6900 /* The addend is scrambled in the object file. See
6901 mips_elf_perform_relocation for details on the
6903 addend = (((addend & 0x1f0000) >> 5)
6904 | ((addend & 0x7e00000) >> 16)
6909 addend = rel->r_addend;
6912 if (info->relocateable)
6914 Elf_Internal_Sym *sym;
6915 unsigned long r_symndx;
6917 if (r_type == R_MIPS_64 && !ABI_64_P (output_bfd)
6918 && bfd_big_endian (input_bfd))
6921 /* Since we're just relocating, all we need to do is copy
6922 the relocations back out to the object file, unless
6923 they're against a section symbol, in which case we need
6924 to adjust by the section offset, or unless they're GP
6925 relative in which case we need to adjust by the amount
6926 that we're adjusting GP in this relocateable object. */
6928 if (!mips_elf_local_relocation_p (input_bfd, rel, local_sections,
6930 /* There's nothing to do for non-local relocations. */
6933 if (r_type == R_MIPS16_GPREL
6934 || r_type == R_MIPS_GPREL16
6935 || r_type == R_MIPS_GPREL32
6936 || r_type == R_MIPS_LITERAL)
6937 addend -= (_bfd_get_gp_value (output_bfd)
6938 - _bfd_get_gp_value (input_bfd));
6939 else if (r_type == R_MIPS_26 || r_type == R_MIPS16_26
6940 || r_type == R_MIPS_GNU_REL16_S2)
6941 /* The addend is stored without its two least
6942 significant bits (which are always zero.) In a
6943 non-relocateable link, calculate_relocation will do
6944 this shift; here, we must do it ourselves. */
6947 r_symndx = ELF32_R_SYM (rel->r_info);
6948 sym = local_syms + r_symndx;
6949 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6950 /* Adjust the addend appropriately. */
6951 addend += local_sections[r_symndx]->output_offset;
6953 /* If the relocation is for a R_MIPS_HI16 or R_MIPS_GOT16,
6954 then we only want to write out the high-order 16 bits.
6955 The subsequent R_MIPS_LO16 will handle the low-order bits. */
6956 if (r_type == R_MIPS_HI16 || r_type == R_MIPS_GOT16
6957 || r_type == R_MIPS_GNU_REL_HI16)
6958 addend = mips_elf_high (addend);
6959 /* If the relocation is for an R_MIPS_26 relocation, then
6960 the two low-order bits are not stored in the object file;
6961 they are implicitly zero. */
6962 else if (r_type == R_MIPS_26 || r_type == R_MIPS16_26
6963 || r_type == R_MIPS_GNU_REL16_S2)
6966 if (rela_relocation_p)
6967 /* If this is a RELA relocation, just update the addend.
6968 We have to cast away constness for REL. */
6969 rel->r_addend = addend;
6972 /* Otherwise, we have to write the value back out. Note
6973 that we use the source mask, rather than the
6974 destination mask because the place to which we are
6975 writing will be source of the addend in the final
6977 addend &= howto->src_mask;
6979 if (r_type == R_MIPS_64 && !ABI_64_P (output_bfd))
6980 /* See the comment above about using R_MIPS_64 in the 32-bit
6981 ABI. Here, we need to update the addend. It would be
6982 possible to get away with just using the R_MIPS_32 reloc
6983 but for endianness. */
6989 if (addend & ((bfd_vma) 1 << 31))
6990 sign_bits = ((bfd_vma) 1 << 32) - 1;
6994 /* If we don't know that we have a 64-bit type,
6995 do two separate stores. */
6996 if (bfd_big_endian (input_bfd))
6998 /* Store the sign-bits (which are most significant)
7000 low_bits = sign_bits;
7006 high_bits = sign_bits;
7008 bfd_put_32 (input_bfd, low_bits,
7009 contents + rel->r_offset);
7010 bfd_put_32 (input_bfd, high_bits,
7011 contents + rel->r_offset + 4);
7015 if (!mips_elf_perform_relocation (info, howto, rel, addend,
7016 input_bfd, input_section,
7021 /* Go on to the next relocation. */
7025 /* In the N32 and 64-bit ABIs there may be multiple consecutive
7026 relocations for the same offset. In that case we are
7027 supposed to treat the output of each relocation as the addend
7029 if (rel + 1 < relend
7030 && rel->r_offset == rel[1].r_offset
7031 && ELF32_R_TYPE (rel[1].r_info) != R_MIPS_NONE)
7032 use_saved_addend_p = true;
7034 use_saved_addend_p = false;
7036 /* Figure out what value we are supposed to relocate. */
7037 switch (mips_elf_calculate_relocation (output_bfd,
7050 case bfd_reloc_continue:
7051 /* There's nothing to do. */
7054 case bfd_reloc_undefined:
7055 /* mips_elf_calculate_relocation already called the
7056 undefined_symbol callback. There's no real point in
7057 trying to perform the relocation at this point, so we
7058 just skip ahead to the next relocation. */
7061 case bfd_reloc_notsupported:
7062 msg = _("internal error: unsupported relocation error");
7063 info->callbacks->warning
7064 (info, msg, name, input_bfd, input_section, rel->r_offset);
7067 case bfd_reloc_overflow:
7068 if (use_saved_addend_p)
7069 /* Ignore overflow until we reach the last relocation for
7070 a given location. */
7074 BFD_ASSERT (name != NULL);
7075 if (! ((*info->callbacks->reloc_overflow)
7076 (info, name, howto->name, (bfd_vma) 0,
7077 input_bfd, input_section, rel->r_offset)))
7090 /* If we've got another relocation for the address, keep going
7091 until we reach the last one. */
7092 if (use_saved_addend_p)
7098 if (r_type == R_MIPS_64 && !ABI_64_P (output_bfd))
7099 /* See the comment above about using R_MIPS_64 in the 32-bit
7100 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
7101 that calculated the right value. Now, however, we
7102 sign-extend the 32-bit result to 64-bits, and store it as a
7103 64-bit value. We are especially generous here in that we
7104 go to extreme lengths to support this usage on systems with
7105 only a 32-bit VMA. */
7111 if (value & ((bfd_vma) 1 << 31))
7112 sign_bits = ((bfd_vma) 1 << 32) - 1;
7116 /* If we don't know that we have a 64-bit type,
7117 do two separate stores. */
7118 if (bfd_big_endian (input_bfd))
7120 /* Undo what we did above. */
7122 /* Store the sign-bits (which are most significant)
7124 low_bits = sign_bits;
7130 high_bits = sign_bits;
7132 bfd_put_32 (input_bfd, low_bits,
7133 contents + rel->r_offset);
7134 bfd_put_32 (input_bfd, high_bits,
7135 contents + rel->r_offset + 4);
7139 /* Actually perform the relocation. */
7140 if (!mips_elf_perform_relocation (info, howto, rel, value, input_bfd,
7141 input_section, contents,
7149 /* This hook function is called before the linker writes out a global
7150 symbol. We mark symbols as small common if appropriate. This is
7151 also where we undo the increment of the value for a mips16 symbol. */
7154 _bfd_mips_elf_link_output_symbol_hook (abfd, info, name, sym, input_sec)
7155 bfd *abfd ATTRIBUTE_UNUSED;
7156 struct bfd_link_info *info ATTRIBUTE_UNUSED;
7157 const char *name ATTRIBUTE_UNUSED;
7158 Elf_Internal_Sym *sym;
7159 asection *input_sec;
7161 /* If we see a common symbol, which implies a relocatable link, then
7162 if a symbol was small common in an input file, mark it as small
7163 common in the output file. */
7164 if (sym->st_shndx == SHN_COMMON
7165 && strcmp (input_sec->name, ".scommon") == 0)
7166 sym->st_shndx = SHN_MIPS_SCOMMON;
7168 if (sym->st_other == STO_MIPS16
7169 && (sym->st_value & 1) != 0)
7175 /* Functions for the dynamic linker. */
7177 /* The name of the dynamic interpreter. This is put in the .interp
7180 #define ELF_DYNAMIC_INTERPRETER(abfd) \
7181 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
7182 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
7183 : "/usr/lib/libc.so.1")
7185 /* Create dynamic sections when linking against a dynamic object. */
7188 _bfd_mips_elf_create_dynamic_sections (abfd, info)
7190 struct bfd_link_info *info;
7192 struct elf_link_hash_entry *h;
7194 register asection *s;
7195 const char * const *namep;
7197 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
7198 | SEC_LINKER_CREATED | SEC_READONLY);
7200 /* Mips ABI requests the .dynamic section to be read only. */
7201 s = bfd_get_section_by_name (abfd, ".dynamic");
7204 if (! bfd_set_section_flags (abfd, s, flags))
7208 /* We need to create .got section. */
7209 if (! mips_elf_create_got_section (abfd, info))
7212 /* Create the .msym section on IRIX6. It is used by the dynamic
7213 linker to speed up dynamic relocations, and to avoid computing
7214 the ELF hash for symbols. */
7215 if (IRIX_COMPAT (abfd) == ict_irix6
7216 && !mips_elf_create_msym_section (abfd))
7219 /* Create .stub section. */
7220 if (bfd_get_section_by_name (abfd,
7221 MIPS_ELF_STUB_SECTION_NAME (abfd)) == NULL)
7223 s = bfd_make_section (abfd, MIPS_ELF_STUB_SECTION_NAME (abfd));
7225 || ! bfd_set_section_flags (abfd, s, flags | SEC_CODE)
7226 || ! bfd_set_section_alignment (abfd, s,
7227 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
7231 if ((IRIX_COMPAT (abfd) == ict_irix5 || IRIX_COMPAT (abfd) == ict_none)
7233 && bfd_get_section_by_name (abfd, ".rld_map") == NULL)
7235 s = bfd_make_section (abfd, ".rld_map");
7237 || ! bfd_set_section_flags (abfd, s, flags & ~SEC_READONLY)
7238 || ! bfd_set_section_alignment (abfd, s,
7239 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
7243 /* On IRIX5, we adjust add some additional symbols and change the
7244 alignments of several sections. There is no ABI documentation
7245 indicating that this is necessary on IRIX6, nor any evidence that
7246 the linker takes such action. */
7247 if (IRIX_COMPAT (abfd) == ict_irix5)
7249 for (namep = mips_elf_dynsym_rtproc_names; *namep != NULL; namep++)
7252 if (! (_bfd_generic_link_add_one_symbol
7253 (info, abfd, *namep, BSF_GLOBAL, bfd_und_section_ptr,
7254 (bfd_vma) 0, (const char *) NULL, false,
7255 get_elf_backend_data (abfd)->collect,
7256 (struct bfd_link_hash_entry **) &h)))
7258 h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
7259 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
7260 h->type = STT_SECTION;
7262 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
7266 /* We need to create a .compact_rel section. */
7267 if (SGI_COMPAT (abfd))
7269 if (!mips_elf_create_compact_rel_section (abfd, info))
7273 /* Change aligments of some sections. */
7274 s = bfd_get_section_by_name (abfd, ".hash");
7276 bfd_set_section_alignment (abfd, s, 4);
7277 s = bfd_get_section_by_name (abfd, ".dynsym");
7279 bfd_set_section_alignment (abfd, s, 4);
7280 s = bfd_get_section_by_name (abfd, ".dynstr");
7282 bfd_set_section_alignment (abfd, s, 4);
7283 s = bfd_get_section_by_name (abfd, ".reginfo");
7285 bfd_set_section_alignment (abfd, s, 4);
7286 s = bfd_get_section_by_name (abfd, ".dynamic");
7288 bfd_set_section_alignment (abfd, s, 4);
7294 if (SGI_COMPAT (abfd))
7296 if (!(_bfd_generic_link_add_one_symbol
7297 (info, abfd, "_DYNAMIC_LINK", BSF_GLOBAL, bfd_abs_section_ptr,
7298 (bfd_vma) 0, (const char *) NULL, false,
7299 get_elf_backend_data (abfd)->collect,
7300 (struct bfd_link_hash_entry **) &h)))
7305 /* For normal mips it is _DYNAMIC_LINKING. */
7306 if (!(_bfd_generic_link_add_one_symbol
7307 (info, abfd, "_DYNAMIC_LINKING", BSF_GLOBAL,
7308 bfd_abs_section_ptr, (bfd_vma) 0, (const char *) NULL, false,
7309 get_elf_backend_data (abfd)->collect,
7310 (struct bfd_link_hash_entry **) &h)))
7313 h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
7314 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
7315 h->type = STT_SECTION;
7317 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
7320 if (! mips_elf_hash_table (info)->use_rld_obj_head)
7322 /* __rld_map is a four byte word located in the .data section
7323 and is filled in by the rtld to contain a pointer to
7324 the _r_debug structure. Its symbol value will be set in
7325 mips_elf_finish_dynamic_symbol. */
7326 s = bfd_get_section_by_name (abfd, ".rld_map");
7327 BFD_ASSERT (s != NULL);
7330 if (SGI_COMPAT (abfd))
7332 if (!(_bfd_generic_link_add_one_symbol
7333 (info, abfd, "__rld_map", BSF_GLOBAL, s,
7334 (bfd_vma) 0, (const char *) NULL, false,
7335 get_elf_backend_data (abfd)->collect,
7336 (struct bfd_link_hash_entry **) &h)))
7341 /* For normal mips the symbol is __RLD_MAP. */
7342 if (!(_bfd_generic_link_add_one_symbol
7343 (info, abfd, "__RLD_MAP", BSF_GLOBAL, s,
7344 (bfd_vma) 0, (const char *) NULL, false,
7345 get_elf_backend_data (abfd)->collect,
7346 (struct bfd_link_hash_entry **) &h)))
7349 h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
7350 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
7351 h->type = STT_OBJECT;
7353 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
7361 /* Create the .compact_rel section. */
7364 mips_elf_create_compact_rel_section (abfd, info)
7366 struct bfd_link_info *info ATTRIBUTE_UNUSED;
7369 register asection *s;
7371 if (bfd_get_section_by_name (abfd, ".compact_rel") == NULL)
7373 flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED
7376 s = bfd_make_section (abfd, ".compact_rel");
7378 || ! bfd_set_section_flags (abfd, s, flags)
7379 || ! bfd_set_section_alignment (abfd, s,
7380 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
7383 s->_raw_size = sizeof (Elf32_External_compact_rel);
7389 /* Create the .got section to hold the global offset table. */
7392 mips_elf_create_got_section (abfd, info)
7394 struct bfd_link_info *info;
7397 register asection *s;
7398 struct elf_link_hash_entry *h;
7399 struct mips_got_info *g;
7401 /* This function may be called more than once. */
7402 if (mips_elf_got_section (abfd))
7405 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
7406 | SEC_LINKER_CREATED);
7408 s = bfd_make_section (abfd, ".got");
7410 || ! bfd_set_section_flags (abfd, s, flags)
7411 || ! bfd_set_section_alignment (abfd, s, 4))
7414 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
7415 linker script because we don't want to define the symbol if we
7416 are not creating a global offset table. */
7418 if (! (_bfd_generic_link_add_one_symbol
7419 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
7420 (bfd_vma) 0, (const char *) NULL, false,
7421 get_elf_backend_data (abfd)->collect,
7422 (struct bfd_link_hash_entry **) &h)))
7424 h->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
7425 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
7426 h->type = STT_OBJECT;
7429 && ! bfd_elf32_link_record_dynamic_symbol (info, h))
7432 /* The first several global offset table entries are reserved. */
7433 s->_raw_size = MIPS_RESERVED_GOTNO * MIPS_ELF_GOT_SIZE (abfd);
7435 g = (struct mips_got_info *) bfd_alloc (abfd,
7436 sizeof (struct mips_got_info));
7439 g->global_gotsym = NULL;
7440 g->local_gotno = MIPS_RESERVED_GOTNO;
7441 g->assigned_gotno = MIPS_RESERVED_GOTNO;
7442 if (elf_section_data (s) == NULL)
7445 (PTR) bfd_zalloc (abfd, sizeof (struct bfd_elf_section_data));
7446 if (elf_section_data (s) == NULL)
7449 elf_section_data (s)->tdata = (PTR) g;
7450 elf_section_data (s)->this_hdr.sh_flags
7451 |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
7456 /* Returns the .msym section for ABFD, creating it if it does not
7457 already exist. Returns NULL to indicate error. */
7460 mips_elf_create_msym_section (abfd)
7465 s = bfd_get_section_by_name (abfd, MIPS_ELF_MSYM_SECTION_NAME (abfd));
7468 s = bfd_make_section (abfd, MIPS_ELF_MSYM_SECTION_NAME (abfd));
7470 || !bfd_set_section_flags (abfd, s,
7474 | SEC_LINKER_CREATED
7476 || !bfd_set_section_alignment (abfd, s,
7477 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
7484 /* Add room for N relocations to the .rel.dyn section in ABFD. */
7487 mips_elf_allocate_dynamic_relocations (abfd, n)
7493 s = bfd_get_section_by_name (abfd, MIPS_ELF_REL_DYN_SECTION_NAME (abfd));
7494 BFD_ASSERT (s != NULL);
7496 if (s->_raw_size == 0)
7498 /* Make room for a null element. */
7499 s->_raw_size += MIPS_ELF_REL_SIZE (abfd);
7502 s->_raw_size += n * MIPS_ELF_REL_SIZE (abfd);
7505 /* Look through the relocs for a section during the first phase, and
7506 allocate space in the global offset table. */
7509 _bfd_mips_elf_check_relocs (abfd, info, sec, relocs)
7511 struct bfd_link_info *info;
7513 const Elf_Internal_Rela *relocs;
7517 Elf_Internal_Shdr *symtab_hdr;
7518 struct elf_link_hash_entry **sym_hashes;
7519 struct mips_got_info *g;
7521 const Elf_Internal_Rela *rel;
7522 const Elf_Internal_Rela *rel_end;
7525 struct elf_backend_data *bed;
7527 if (info->relocateable)
7530 dynobj = elf_hash_table (info)->dynobj;
7531 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7532 sym_hashes = elf_sym_hashes (abfd);
7533 extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
7535 /* Check for the mips16 stub sections. */
7537 name = bfd_get_section_name (abfd, sec);
7538 if (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0)
7540 unsigned long r_symndx;
7542 /* Look at the relocation information to figure out which symbol
7545 r_symndx = ELF32_R_SYM (relocs->r_info);
7547 if (r_symndx < extsymoff
7548 || sym_hashes[r_symndx - extsymoff] == NULL)
7552 /* This stub is for a local symbol. This stub will only be
7553 needed if there is some relocation in this BFD, other
7554 than a 16 bit function call, which refers to this symbol. */
7555 for (o = abfd->sections; o != NULL; o = o->next)
7557 Elf_Internal_Rela *sec_relocs;
7558 const Elf_Internal_Rela *r, *rend;
7560 /* We can ignore stub sections when looking for relocs. */
7561 if ((o->flags & SEC_RELOC) == 0
7562 || o->reloc_count == 0
7563 || strncmp (bfd_get_section_name (abfd, o), FN_STUB,
7564 sizeof FN_STUB - 1) == 0
7565 || strncmp (bfd_get_section_name (abfd, o), CALL_STUB,
7566 sizeof CALL_STUB - 1) == 0
7567 || strncmp (bfd_get_section_name (abfd, o), CALL_FP_STUB,
7568 sizeof CALL_FP_STUB - 1) == 0)
7571 sec_relocs = (_bfd_elf32_link_read_relocs
7572 (abfd, o, (PTR) NULL,
7573 (Elf_Internal_Rela *) NULL,
7574 info->keep_memory));
7575 if (sec_relocs == NULL)
7578 rend = sec_relocs + o->reloc_count;
7579 for (r = sec_relocs; r < rend; r++)
7580 if (ELF32_R_SYM (r->r_info) == r_symndx
7581 && ELF32_R_TYPE (r->r_info) != R_MIPS16_26)
7584 if (! info->keep_memory)
7593 /* There is no non-call reloc for this stub, so we do
7594 not need it. Since this function is called before
7595 the linker maps input sections to output sections, we
7596 can easily discard it by setting the SEC_EXCLUDE
7598 sec->flags |= SEC_EXCLUDE;
7602 /* Record this stub in an array of local symbol stubs for
7604 if (elf_tdata (abfd)->local_stubs == NULL)
7606 unsigned long symcount;
7609 if (elf_bad_symtab (abfd))
7610 symcount = NUM_SHDR_ENTRIES (symtab_hdr);
7612 symcount = symtab_hdr->sh_info;
7613 n = (asection **) bfd_zalloc (abfd,
7614 symcount * sizeof (asection *));
7617 elf_tdata (abfd)->local_stubs = n;
7620 elf_tdata (abfd)->local_stubs[r_symndx] = sec;
7622 /* We don't need to set mips16_stubs_seen in this case.
7623 That flag is used to see whether we need to look through
7624 the global symbol table for stubs. We don't need to set
7625 it here, because we just have a local stub. */
7629 struct mips_elf_link_hash_entry *h;
7631 h = ((struct mips_elf_link_hash_entry *)
7632 sym_hashes[r_symndx - extsymoff]);
7634 /* H is the symbol this stub is for. */
7637 mips_elf_hash_table (info)->mips16_stubs_seen = true;
7640 else if (strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0
7641 || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
7643 unsigned long r_symndx;
7644 struct mips_elf_link_hash_entry *h;
7647 /* Look at the relocation information to figure out which symbol
7650 r_symndx = ELF32_R_SYM (relocs->r_info);
7652 if (r_symndx < extsymoff
7653 || sym_hashes[r_symndx - extsymoff] == NULL)
7655 /* This stub was actually built for a static symbol defined
7656 in the same file. We assume that all static symbols in
7657 mips16 code are themselves mips16, so we can simply
7658 discard this stub. Since this function is called before
7659 the linker maps input sections to output sections, we can
7660 easily discard it by setting the SEC_EXCLUDE flag. */
7661 sec->flags |= SEC_EXCLUDE;
7665 h = ((struct mips_elf_link_hash_entry *)
7666 sym_hashes[r_symndx - extsymoff]);
7668 /* H is the symbol this stub is for. */
7670 if (strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
7671 loc = &h->call_fp_stub;
7673 loc = &h->call_stub;
7675 /* If we already have an appropriate stub for this function, we
7676 don't need another one, so we can discard this one. Since
7677 this function is called before the linker maps input sections
7678 to output sections, we can easily discard it by setting the
7679 SEC_EXCLUDE flag. We can also discard this section if we
7680 happen to already know that this is a mips16 function; it is
7681 not necessary to check this here, as it is checked later, but
7682 it is slightly faster to check now. */
7683 if (*loc != NULL || h->root.other == STO_MIPS16)
7685 sec->flags |= SEC_EXCLUDE;
7690 mips_elf_hash_table (info)->mips16_stubs_seen = true;
7700 sgot = mips_elf_got_section (dynobj);
7705 BFD_ASSERT (elf_section_data (sgot) != NULL);
7706 g = (struct mips_got_info *) elf_section_data (sgot)->tdata;
7707 BFD_ASSERT (g != NULL);
7712 bed = get_elf_backend_data (abfd);
7713 rel_end = relocs + sec->reloc_count * bed->s->int_rels_per_ext_rel;
7714 for (rel = relocs; rel < rel_end; ++rel)
7716 unsigned long r_symndx;
7718 struct elf_link_hash_entry *h;
7720 r_symndx = ELF32_R_SYM (rel->r_info);
7721 r_type = ELF32_R_TYPE (rel->r_info);
7723 if (r_symndx < extsymoff)
7725 else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
7727 (*_bfd_error_handler)
7728 (_("Malformed reloc detected for section %s"), name);
7729 bfd_set_error (bfd_error_bad_value);
7734 h = sym_hashes[r_symndx - extsymoff];
7736 /* This may be an indirect symbol created because of a version. */
7739 while (h->root.type == bfd_link_hash_indirect)
7740 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7744 /* Some relocs require a global offset table. */
7745 if (dynobj == NULL || sgot == NULL)
7751 case R_MIPS_CALL_HI16:
7752 case R_MIPS_CALL_LO16:
7753 case R_MIPS_GOT_HI16:
7754 case R_MIPS_GOT_LO16:
7755 case R_MIPS_GOT_PAGE:
7756 case R_MIPS_GOT_OFST:
7757 case R_MIPS_GOT_DISP:
7759 elf_hash_table (info)->dynobj = dynobj = abfd;
7760 if (! mips_elf_create_got_section (dynobj, info))
7762 g = mips_elf_got_info (dynobj, &sgot);
7769 && (info->shared || h != NULL)
7770 && (sec->flags & SEC_ALLOC) != 0)
7771 elf_hash_table (info)->dynobj = dynobj = abfd;
7779 if (!h && (r_type == R_MIPS_CALL_LO16
7780 || r_type == R_MIPS_GOT_LO16
7781 || r_type == R_MIPS_GOT_DISP))
7783 /* We may need a local GOT entry for this relocation. We
7784 don't count R_MIPS_GOT_PAGE because we can estimate the
7785 maximum number of pages needed by looking at the size of
7786 the segment. Similar comments apply to R_MIPS_GOT16 and
7787 R_MIPS_CALL16. We don't count R_MIPS_GOT_HI16, or
7788 R_MIPS_CALL_HI16 because these are always followed by an
7789 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16.
7791 This estimation is very conservative since we can merge
7792 duplicate entries in the GOT. In order to be less
7793 conservative, we could actually build the GOT here,
7794 rather than in relocate_section. */
7796 sgot->_raw_size += MIPS_ELF_GOT_SIZE (dynobj);
7804 (*_bfd_error_handler)
7805 (_("%s: CALL16 reloc at 0x%lx not against global symbol"),
7806 bfd_get_filename (abfd), (unsigned long) rel->r_offset);
7807 bfd_set_error (bfd_error_bad_value);
7812 case R_MIPS_CALL_HI16:
7813 case R_MIPS_CALL_LO16:
7816 /* This symbol requires a global offset table entry. */
7817 if (!mips_elf_record_global_got_symbol (h, info, g))
7820 /* We need a stub, not a plt entry for the undefined
7821 function. But we record it as if it needs plt. See
7822 elf_adjust_dynamic_symbol in elflink.h. */
7823 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
7829 case R_MIPS_GOT_HI16:
7830 case R_MIPS_GOT_LO16:
7831 case R_MIPS_GOT_DISP:
7832 /* This symbol requires a global offset table entry. */
7833 if (h && !mips_elf_record_global_got_symbol (h, info, g))
7840 if ((info->shared || h != NULL)
7841 && (sec->flags & SEC_ALLOC) != 0)
7845 const char *name = MIPS_ELF_REL_DYN_SECTION_NAME (dynobj);
7847 sreloc = bfd_get_section_by_name (dynobj, name);
7850 sreloc = bfd_make_section (dynobj, name);
7852 || ! bfd_set_section_flags (dynobj, sreloc,
7857 | SEC_LINKER_CREATED
7859 || ! bfd_set_section_alignment (dynobj, sreloc,
7864 #define MIPS_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
7867 /* When creating a shared object, we must copy these
7868 reloc types into the output file as R_MIPS_REL32
7869 relocs. We make room for this reloc in the
7870 .rel.dyn reloc section. */
7871 mips_elf_allocate_dynamic_relocations (dynobj, 1);
7872 if ((sec->flags & MIPS_READONLY_SECTION)
7873 == MIPS_READONLY_SECTION)
7874 /* We tell the dynamic linker that there are
7875 relocations against the text segment. */
7876 info->flags |= DF_TEXTREL;
7880 struct mips_elf_link_hash_entry *hmips;
7882 /* We only need to copy this reloc if the symbol is
7883 defined in a dynamic object. */
7884 hmips = (struct mips_elf_link_hash_entry *) h;
7885 ++hmips->possibly_dynamic_relocs;
7886 if ((sec->flags & MIPS_READONLY_SECTION)
7887 == MIPS_READONLY_SECTION)
7888 /* We need it to tell the dynamic linker if there
7889 are relocations against the text segment. */
7890 hmips->readonly_reloc = true;
7893 /* Even though we don't directly need a GOT entry for
7894 this symbol, a symbol must have a dynamic symbol
7895 table index greater that DT_MIPS_GOTSYM if there are
7896 dynamic relocations against it. */
7898 && !mips_elf_record_global_got_symbol (h, info, g))
7902 if (SGI_COMPAT (abfd))
7903 mips_elf_hash_table (info)->compact_rel_size +=
7904 sizeof (Elf32_External_crinfo);
7908 case R_MIPS_GPREL16:
7909 case R_MIPS_LITERAL:
7910 case R_MIPS_GPREL32:
7911 if (SGI_COMPAT (abfd))
7912 mips_elf_hash_table (info)->compact_rel_size +=
7913 sizeof (Elf32_External_crinfo);
7916 /* This relocation describes the C++ object vtable hierarchy.
7917 Reconstruct it for later use during GC. */
7918 case R_MIPS_GNU_VTINHERIT:
7919 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
7923 /* This relocation describes which C++ vtable entries are actually
7924 used. Record for later use during GC. */
7925 case R_MIPS_GNU_VTENTRY:
7926 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
7934 /* We must not create a stub for a symbol that has relocations
7935 related to taking the function's address. */
7941 struct mips_elf_link_hash_entry *mh;
7943 mh = (struct mips_elf_link_hash_entry *) h;
7944 mh->no_fn_stub = true;
7948 case R_MIPS_CALL_HI16:
7949 case R_MIPS_CALL_LO16:
7953 /* If this reloc is not a 16 bit call, and it has a global
7954 symbol, then we will need the fn_stub if there is one.
7955 References from a stub section do not count. */
7957 && r_type != R_MIPS16_26
7958 && strncmp (bfd_get_section_name (abfd, sec), FN_STUB,
7959 sizeof FN_STUB - 1) != 0
7960 && strncmp (bfd_get_section_name (abfd, sec), CALL_STUB,
7961 sizeof CALL_STUB - 1) != 0
7962 && strncmp (bfd_get_section_name (abfd, sec), CALL_FP_STUB,
7963 sizeof CALL_FP_STUB - 1) != 0)
7965 struct mips_elf_link_hash_entry *mh;
7967 mh = (struct mips_elf_link_hash_entry *) h;
7968 mh->need_fn_stub = true;
7975 /* Return the section that should be marked against GC for a given
7979 _bfd_mips_elf_gc_mark_hook (abfd, info, rel, h, sym)
7981 struct bfd_link_info *info ATTRIBUTE_UNUSED;
7982 Elf_Internal_Rela *rel;
7983 struct elf_link_hash_entry *h;
7984 Elf_Internal_Sym *sym;
7986 /* ??? Do mips16 stub sections need to be handled special? */
7990 switch (ELF32_R_TYPE (rel->r_info))
7992 case R_MIPS_GNU_VTINHERIT:
7993 case R_MIPS_GNU_VTENTRY:
7997 switch (h->root.type)
7999 case bfd_link_hash_defined:
8000 case bfd_link_hash_defweak:
8001 return h->root.u.def.section;
8003 case bfd_link_hash_common:
8004 return h->root.u.c.p->section;
8013 if (!(elf_bad_symtab (abfd)
8014 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
8015 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
8016 && sym->st_shndx != SHN_COMMON))
8018 return bfd_section_from_elf_index (abfd, sym->st_shndx);
8025 /* Update the got entry reference counts for the section being removed. */
8028 _bfd_mips_elf_gc_sweep_hook (abfd, info, sec, relocs)
8029 bfd *abfd ATTRIBUTE_UNUSED;
8030 struct bfd_link_info *info ATTRIBUTE_UNUSED;
8031 asection *sec ATTRIBUTE_UNUSED;
8032 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
8035 Elf_Internal_Shdr *symtab_hdr;
8036 struct elf_link_hash_entry **sym_hashes;
8037 bfd_signed_vma *local_got_refcounts;
8038 const Elf_Internal_Rela *rel, *relend;
8039 unsigned long r_symndx;
8040 struct elf_link_hash_entry *h;
8042 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8043 sym_hashes = elf_sym_hashes (abfd);
8044 local_got_refcounts = elf_local_got_refcounts (abfd);
8046 relend = relocs + sec->reloc_count;
8047 for (rel = relocs; rel < relend; rel++)
8048 switch (ELF32_R_TYPE (rel->r_info))
8052 case R_MIPS_CALL_HI16:
8053 case R_MIPS_CALL_LO16:
8054 case R_MIPS_GOT_HI16:
8055 case R_MIPS_GOT_LO16:
8056 /* ??? It would seem that the existing MIPS code does no sort
8057 of reference counting or whatnot on its GOT and PLT entries,
8058 so it is not possible to garbage collect them at this time. */
8069 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
8070 hiding the old indirect symbol. Process additional relocation
8074 _bfd_mips_elf_copy_indirect_symbol (dir, ind)
8075 struct elf_link_hash_entry *dir, *ind;
8077 struct mips_elf_link_hash_entry *dirmips, *indmips;
8079 _bfd_elf_link_hash_copy_indirect (dir, ind);
8081 dirmips = (struct mips_elf_link_hash_entry *) dir;
8082 indmips = (struct mips_elf_link_hash_entry *) ind;
8083 dirmips->possibly_dynamic_relocs += indmips->possibly_dynamic_relocs;
8084 if (indmips->readonly_reloc)
8085 dirmips->readonly_reloc = true;
8086 if (dirmips->min_dyn_reloc_index == 0
8087 || (indmips->min_dyn_reloc_index != 0
8088 && indmips->min_dyn_reloc_index < dirmips->min_dyn_reloc_index))
8089 dirmips->min_dyn_reloc_index = indmips->min_dyn_reloc_index;
8090 if (indmips->no_fn_stub)
8091 dirmips->no_fn_stub = true;
8094 /* Adjust a symbol defined by a dynamic object and referenced by a
8095 regular object. The current definition is in some section of the
8096 dynamic object, but we're not including those sections. We have to
8097 change the definition to something the rest of the link can
8101 _bfd_mips_elf_adjust_dynamic_symbol (info, h)
8102 struct bfd_link_info *info;
8103 struct elf_link_hash_entry *h;
8106 struct mips_elf_link_hash_entry *hmips;
8109 dynobj = elf_hash_table (info)->dynobj;
8111 /* Make sure we know what is going on here. */
8112 BFD_ASSERT (dynobj != NULL
8113 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
8114 || h->weakdef != NULL
8115 || ((h->elf_link_hash_flags
8116 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
8117 && (h->elf_link_hash_flags
8118 & ELF_LINK_HASH_REF_REGULAR) != 0
8119 && (h->elf_link_hash_flags
8120 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
8122 /* If this symbol is defined in a dynamic object, we need to copy
8123 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
8125 hmips = (struct mips_elf_link_hash_entry *) h;
8126 if (! info->relocateable
8127 && hmips->possibly_dynamic_relocs != 0
8128 && (h->root.type == bfd_link_hash_defweak
8129 || (h->elf_link_hash_flags
8130 & ELF_LINK_HASH_DEF_REGULAR) == 0))
8132 mips_elf_allocate_dynamic_relocations (dynobj,
8133 hmips->possibly_dynamic_relocs);
8134 if (hmips->readonly_reloc)
8135 /* We tell the dynamic linker that there are relocations
8136 against the text segment. */
8137 info->flags |= DF_TEXTREL;
8140 /* For a function, create a stub, if allowed. */
8141 if (! hmips->no_fn_stub
8142 && (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
8144 if (! elf_hash_table (info)->dynamic_sections_created)
8147 /* If this symbol is not defined in a regular file, then set
8148 the symbol to the stub location. This is required to make
8149 function pointers compare as equal between the normal
8150 executable and the shared library. */
8151 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
8153 /* We need .stub section. */
8154 s = bfd_get_section_by_name (dynobj,
8155 MIPS_ELF_STUB_SECTION_NAME (dynobj));
8156 BFD_ASSERT (s != NULL);
8158 h->root.u.def.section = s;
8159 h->root.u.def.value = s->_raw_size;
8161 /* XXX Write this stub address somewhere. */
8162 h->plt.offset = s->_raw_size;
8164 /* Make room for this stub code. */
8165 s->_raw_size += MIPS_FUNCTION_STUB_SIZE;
8167 /* The last half word of the stub will be filled with the index
8168 of this symbol in .dynsym section. */
8172 else if ((h->type == STT_FUNC)
8173 && (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) == 0)
8175 /* This will set the entry for this symbol in the GOT to 0, and
8176 the dynamic linker will take care of this. */
8177 h->root.u.def.value = 0;
8181 /* If this is a weak symbol, and there is a real definition, the
8182 processor independent code will have arranged for us to see the
8183 real definition first, and we can just use the same value. */
8184 if (h->weakdef != NULL)
8186 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
8187 || h->weakdef->root.type == bfd_link_hash_defweak);
8188 h->root.u.def.section = h->weakdef->root.u.def.section;
8189 h->root.u.def.value = h->weakdef->root.u.def.value;
8193 /* This is a reference to a symbol defined by a dynamic object which
8194 is not a function. */
8199 /* This function is called after all the input files have been read,
8200 and the input sections have been assigned to output sections. We
8201 check for any mips16 stub sections that we can discard. */
8203 static boolean mips_elf_check_mips16_stubs
8204 PARAMS ((struct mips_elf_link_hash_entry *, PTR));
8207 _bfd_mips_elf_always_size_sections (output_bfd, info)
8209 struct bfd_link_info *info;
8213 /* The .reginfo section has a fixed size. */
8214 ri = bfd_get_section_by_name (output_bfd, ".reginfo");
8216 bfd_set_section_size (output_bfd, ri, sizeof (Elf32_External_RegInfo));
8218 if (info->relocateable
8219 || ! mips_elf_hash_table (info)->mips16_stubs_seen)
8222 mips_elf_link_hash_traverse (mips_elf_hash_table (info),
8223 mips_elf_check_mips16_stubs,
8229 /* Check the mips16 stubs for a particular symbol, and see if we can
8233 mips_elf_check_mips16_stubs (h, data)
8234 struct mips_elf_link_hash_entry *h;
8235 PTR data ATTRIBUTE_UNUSED;
8237 if (h->fn_stub != NULL
8238 && ! h->need_fn_stub)
8240 /* We don't need the fn_stub; the only references to this symbol
8241 are 16 bit calls. Clobber the size to 0 to prevent it from
8242 being included in the link. */
8243 h->fn_stub->_raw_size = 0;
8244 h->fn_stub->_cooked_size = 0;
8245 h->fn_stub->flags &= ~SEC_RELOC;
8246 h->fn_stub->reloc_count = 0;
8247 h->fn_stub->flags |= SEC_EXCLUDE;
8250 if (h->call_stub != NULL
8251 && h->root.other == STO_MIPS16)
8253 /* We don't need the call_stub; this is a 16 bit function, so
8254 calls from other 16 bit functions are OK. Clobber the size
8255 to 0 to prevent it from being included in the link. */
8256 h->call_stub->_raw_size = 0;
8257 h->call_stub->_cooked_size = 0;
8258 h->call_stub->flags &= ~SEC_RELOC;
8259 h->call_stub->reloc_count = 0;
8260 h->call_stub->flags |= SEC_EXCLUDE;
8263 if (h->call_fp_stub != NULL
8264 && h->root.other == STO_MIPS16)
8266 /* We don't need the call_stub; this is a 16 bit function, so
8267 calls from other 16 bit functions are OK. Clobber the size
8268 to 0 to prevent it from being included in the link. */
8269 h->call_fp_stub->_raw_size = 0;
8270 h->call_fp_stub->_cooked_size = 0;
8271 h->call_fp_stub->flags &= ~SEC_RELOC;
8272 h->call_fp_stub->reloc_count = 0;
8273 h->call_fp_stub->flags |= SEC_EXCLUDE;
8279 /* Set the sizes of the dynamic sections. */
8282 _bfd_mips_elf_size_dynamic_sections (output_bfd, info)
8284 struct bfd_link_info *info;
8289 struct mips_got_info *g = NULL;
8291 dynobj = elf_hash_table (info)->dynobj;
8292 BFD_ASSERT (dynobj != NULL);
8294 if (elf_hash_table (info)->dynamic_sections_created)
8296 /* Set the contents of the .interp section to the interpreter. */
8299 s = bfd_get_section_by_name (dynobj, ".interp");
8300 BFD_ASSERT (s != NULL);
8302 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd)) + 1;
8304 = (bfd_byte *) ELF_DYNAMIC_INTERPRETER (output_bfd);
8308 /* The check_relocs and adjust_dynamic_symbol entry points have
8309 determined the sizes of the various dynamic sections. Allocate
8312 for (s = dynobj->sections; s != NULL; s = s->next)
8317 /* It's OK to base decisions on the section name, because none
8318 of the dynobj section names depend upon the input files. */
8319 name = bfd_get_section_name (dynobj, s);
8321 if ((s->flags & SEC_LINKER_CREATED) == 0)
8326 if (strncmp (name, ".rel", 4) == 0)
8328 if (s->_raw_size == 0)
8330 /* We only strip the section if the output section name
8331 has the same name. Otherwise, there might be several
8332 input sections for this output section. FIXME: This
8333 code is probably not needed these days anyhow, since
8334 the linker now does not create empty output sections. */
8335 if (s->output_section != NULL
8337 bfd_get_section_name (s->output_section->owner,
8338 s->output_section)) == 0)
8343 const char *outname;
8346 /* If this relocation section applies to a read only
8347 section, then we probably need a DT_TEXTREL entry.
8348 If the relocation section is .rel.dyn, we always
8349 assert a DT_TEXTREL entry rather than testing whether
8350 there exists a relocation to a read only section or
8352 outname = bfd_get_section_name (output_bfd,
8354 target = bfd_get_section_by_name (output_bfd, outname + 4);
8356 && (target->flags & SEC_READONLY) != 0
8357 && (target->flags & SEC_ALLOC) != 0)
8359 MIPS_ELF_REL_DYN_SECTION_NAME (output_bfd)) == 0)
8362 /* We use the reloc_count field as a counter if we need
8363 to copy relocs into the output file. */
8365 MIPS_ELF_REL_DYN_SECTION_NAME (output_bfd)) != 0)
8369 else if (strncmp (name, ".got", 4) == 0)
8372 bfd_size_type loadable_size = 0;
8373 bfd_size_type local_gotno;
8376 BFD_ASSERT (elf_section_data (s) != NULL);
8377 g = (struct mips_got_info *) elf_section_data (s)->tdata;
8378 BFD_ASSERT (g != NULL);
8380 /* Calculate the total loadable size of the output. That
8381 will give us the maximum number of GOT_PAGE entries
8383 for (sub = info->input_bfds; sub; sub = sub->link_next)
8385 asection *subsection;
8387 for (subsection = sub->sections;
8389 subsection = subsection->next)
8391 if ((subsection->flags & SEC_ALLOC) == 0)
8393 loadable_size += (subsection->_raw_size + 0xf) & ~0xf;
8396 loadable_size += MIPS_FUNCTION_STUB_SIZE;
8398 /* Assume there are two loadable segments consisting of
8399 contiguous sections. Is 5 enough? */
8400 local_gotno = (loadable_size >> 16) + 5;
8401 if (IRIX_COMPAT (output_bfd) == ict_irix6)
8402 /* It's possible we will need GOT_PAGE entries as well as
8403 GOT16 entries. Often, these will be able to share GOT
8404 entries, but not always. */
8407 g->local_gotno += local_gotno;
8408 s->_raw_size += local_gotno * MIPS_ELF_GOT_SIZE (dynobj);
8410 /* There has to be a global GOT entry for every symbol with
8411 a dynamic symbol table index of DT_MIPS_GOTSYM or
8412 higher. Therefore, it make sense to put those symbols
8413 that need GOT entries at the end of the symbol table. We
8415 if (!mips_elf_sort_hash_table (info, 1))
8418 if (g->global_gotsym != NULL)
8419 i = elf_hash_table (info)->dynsymcount - g->global_gotsym->dynindx;
8421 /* If there are no global symbols, or none requiring
8422 relocations, then GLOBAL_GOTSYM will be NULL. */
8424 g->global_gotno = i;
8425 s->_raw_size += i * MIPS_ELF_GOT_SIZE (dynobj);
8427 else if (strcmp (name, MIPS_ELF_STUB_SECTION_NAME (output_bfd)) == 0)
8429 /* Irix rld assumes that the function stub isn't at the end
8430 of .text section. So put a dummy. XXX */
8431 s->_raw_size += MIPS_FUNCTION_STUB_SIZE;
8433 else if (! info->shared
8434 && ! mips_elf_hash_table (info)->use_rld_obj_head
8435 && strncmp (name, ".rld_map", 8) == 0)
8437 /* We add a room for __rld_map. It will be filled in by the
8438 rtld to contain a pointer to the _r_debug structure. */
8441 else if (SGI_COMPAT (output_bfd)
8442 && strncmp (name, ".compact_rel", 12) == 0)
8443 s->_raw_size += mips_elf_hash_table (info)->compact_rel_size;
8444 else if (strcmp (name, MIPS_ELF_MSYM_SECTION_NAME (output_bfd))
8446 s->_raw_size = (sizeof (Elf32_External_Msym)
8447 * (elf_hash_table (info)->dynsymcount
8448 + bfd_count_sections (output_bfd)));
8449 else if (strncmp (name, ".init", 5) != 0)
8451 /* It's not one of our sections, so don't allocate space. */
8457 _bfd_strip_section_from_output (info, s);
8461 /* Allocate memory for the section contents. */
8462 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
8463 if (s->contents == NULL && s->_raw_size != 0)
8465 bfd_set_error (bfd_error_no_memory);
8470 if (elf_hash_table (info)->dynamic_sections_created)
8472 /* Add some entries to the .dynamic section. We fill in the
8473 values later, in elf_mips_finish_dynamic_sections, but we
8474 must add the entries now so that we get the correct size for
8475 the .dynamic section. The DT_DEBUG entry is filled in by the
8476 dynamic linker and used by the debugger. */
8479 /* SGI object has the equivalence of DT_DEBUG in the
8480 DT_MIPS_RLD_MAP entry. */
8481 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP, 0))
8483 if (!SGI_COMPAT (output_bfd))
8485 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
8491 /* Shared libraries on traditional mips have DT_DEBUG. */
8492 if (!SGI_COMPAT (output_bfd))
8494 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
8499 if (reltext && SGI_COMPAT (output_bfd))
8500 info->flags |= DF_TEXTREL;
8502 if ((info->flags & DF_TEXTREL) != 0)
8504 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0))
8508 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0))
8511 if (bfd_get_section_by_name (dynobj,
8512 MIPS_ELF_REL_DYN_SECTION_NAME (dynobj)))
8514 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0))
8517 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0))
8520 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0))
8524 if (SGI_COMPAT (output_bfd))
8526 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_CONFLICTNO, 0))
8530 if (SGI_COMPAT (output_bfd))
8532 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LIBLISTNO, 0))
8536 if (bfd_get_section_by_name (dynobj, ".conflict") != NULL)
8538 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_CONFLICT, 0))
8541 s = bfd_get_section_by_name (dynobj, ".liblist");
8542 BFD_ASSERT (s != NULL);
8544 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LIBLIST, 0))
8548 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_VERSION, 0))
8551 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_FLAGS, 0))
8555 /* Time stamps in executable files are a bad idea. */
8556 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_TIME_STAMP, 0))
8561 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_ICHECKSUM, 0))
8566 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_IVERSION, 0))
8570 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_BASE_ADDRESS, 0))
8573 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LOCAL_GOTNO, 0))
8576 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_SYMTABNO, 0))
8579 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_UNREFEXTNO, 0))
8582 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_GOTSYM, 0))
8585 if (IRIX_COMPAT (dynobj) == ict_irix5
8586 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_HIPAGENO, 0))
8589 if (IRIX_COMPAT (dynobj) == ict_irix6
8590 && (bfd_get_section_by_name
8591 (dynobj, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj)))
8592 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_OPTIONS, 0))
8595 if (bfd_get_section_by_name (dynobj,
8596 MIPS_ELF_MSYM_SECTION_NAME (dynobj))
8597 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_MSYM, 0))
8604 /* If NAME is one of the special IRIX6 symbols defined by the linker,
8605 adjust it appropriately now. */
8608 mips_elf_irix6_finish_dynamic_symbol (abfd, name, sym)
8609 bfd *abfd ATTRIBUTE_UNUSED;
8611 Elf_Internal_Sym *sym;
8613 /* The linker script takes care of providing names and values for
8614 these, but we must place them into the right sections. */
8615 static const char* const text_section_symbols[] = {
8618 "__dso_displacement",
8620 "__program_header_table",
8624 static const char* const data_section_symbols[] = {
8632 const char* const *p;
8635 for (i = 0; i < 2; ++i)
8636 for (p = (i == 0) ? text_section_symbols : data_section_symbols;
8639 if (strcmp (*p, name) == 0)
8641 /* All of these symbols are given type STT_SECTION by the
8643 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8645 /* The IRIX linker puts these symbols in special sections. */
8647 sym->st_shndx = SHN_MIPS_TEXT;
8649 sym->st_shndx = SHN_MIPS_DATA;
8655 /* Finish up dynamic symbol handling. We set the contents of various
8656 dynamic sections here. */
8659 _bfd_mips_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
8661 struct bfd_link_info *info;
8662 struct elf_link_hash_entry *h;
8663 Elf_Internal_Sym *sym;
8669 struct mips_got_info *g;
8671 struct mips_elf_link_hash_entry *mh;
8673 dynobj = elf_hash_table (info)->dynobj;
8674 gval = sym->st_value;
8675 mh = (struct mips_elf_link_hash_entry *) h;
8677 if (h->plt.offset != (bfd_vma) -1)
8681 bfd_byte stub[MIPS_FUNCTION_STUB_SIZE];
8683 /* This symbol has a stub. Set it up. */
8685 BFD_ASSERT (h->dynindx != -1);
8687 s = bfd_get_section_by_name (dynobj,
8688 MIPS_ELF_STUB_SECTION_NAME (dynobj));
8689 BFD_ASSERT (s != NULL);
8691 /* Fill the stub. */
8693 bfd_put_32 (output_bfd, STUB_LW (output_bfd), p);
8695 bfd_put_32 (output_bfd, STUB_MOVE (output_bfd), p);
8698 /* FIXME: Can h->dynindex be more than 64K? */
8699 if (h->dynindx & 0xffff0000)
8702 bfd_put_32 (output_bfd, STUB_JALR, p);
8704 bfd_put_32 (output_bfd, STUB_LI16 (output_bfd) + h->dynindx, p);
8706 BFD_ASSERT (h->plt.offset <= s->_raw_size);
8707 memcpy (s->contents + h->plt.offset, stub, MIPS_FUNCTION_STUB_SIZE);
8709 /* Mark the symbol as undefined. plt.offset != -1 occurs
8710 only for the referenced symbol. */
8711 sym->st_shndx = SHN_UNDEF;
8713 /* The run-time linker uses the st_value field of the symbol
8714 to reset the global offset table entry for this external
8715 to its stub address when unlinking a shared object. */
8716 gval = s->output_section->vma + s->output_offset + h->plt.offset;
8717 sym->st_value = gval;
8720 BFD_ASSERT (h->dynindx != -1
8721 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0);
8723 sgot = mips_elf_got_section (dynobj);
8724 BFD_ASSERT (sgot != NULL);
8725 BFD_ASSERT (elf_section_data (sgot) != NULL);
8726 g = (struct mips_got_info *) elf_section_data (sgot)->tdata;
8727 BFD_ASSERT (g != NULL);
8729 /* Run through the global symbol table, creating GOT entries for all
8730 the symbols that need them. */
8731 if (g->global_gotsym != NULL
8732 && h->dynindx >= g->global_gotsym->dynindx)
8738 value = sym->st_value;
8741 /* For an entity defined in a shared object, this will be
8742 NULL. (For functions in shared objects for
8743 which we have created stubs, ST_VALUE will be non-NULL.
8744 That's because such the functions are now no longer defined
8745 in a shared object.) */
8747 if (info->shared && h->root.type == bfd_link_hash_undefined)
8750 value = h->root.u.def.value;
8752 offset = mips_elf_global_got_index (dynobj, h);
8753 MIPS_ELF_PUT_WORD (output_bfd, value, sgot->contents + offset);
8756 /* Create a .msym entry, if appropriate. */
8757 smsym = bfd_get_section_by_name (dynobj,
8758 MIPS_ELF_MSYM_SECTION_NAME (dynobj));
8761 Elf32_Internal_Msym msym;
8763 msym.ms_hash_value = bfd_elf_hash (h->root.root.string);
8764 /* It is undocumented what the `1' indicates, but IRIX6 uses
8766 msym.ms_info = ELF32_MS_INFO (mh->min_dyn_reloc_index, 1);
8767 bfd_mips_elf_swap_msym_out
8769 ((Elf32_External_Msym *) smsym->contents) + h->dynindx);
8772 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
8773 name = h->root.root.string;
8774 if (strcmp (name, "_DYNAMIC") == 0
8775 || strcmp (name, "_GLOBAL_OFFSET_TABLE_") == 0)
8776 sym->st_shndx = SHN_ABS;
8777 else if (strcmp (name, "_DYNAMIC_LINK") == 0
8778 || strcmp (name, "_DYNAMIC_LINKING") == 0)
8780 sym->st_shndx = SHN_ABS;
8781 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8784 else if (strcmp (name, "_gp_disp") == 0)
8786 sym->st_shndx = SHN_ABS;
8787 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8788 sym->st_value = elf_gp (output_bfd);
8790 else if (SGI_COMPAT (output_bfd))
8792 if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
8793 || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
8795 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8796 sym->st_other = STO_PROTECTED;
8798 sym->st_shndx = SHN_MIPS_DATA;
8800 else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
8802 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8803 sym->st_other = STO_PROTECTED;
8804 sym->st_value = mips_elf_hash_table (info)->procedure_count;
8805 sym->st_shndx = SHN_ABS;
8807 else if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS)
8809 if (h->type == STT_FUNC)
8810 sym->st_shndx = SHN_MIPS_TEXT;
8811 else if (h->type == STT_OBJECT)
8812 sym->st_shndx = SHN_MIPS_DATA;
8816 /* Handle the IRIX6-specific symbols. */
8817 if (IRIX_COMPAT (output_bfd) == ict_irix6)
8818 mips_elf_irix6_finish_dynamic_symbol (output_bfd, name, sym);
8822 if (! mips_elf_hash_table (info)->use_rld_obj_head
8823 && (strcmp (name, "__rld_map") == 0
8824 || strcmp (name, "__RLD_MAP") == 0))
8826 asection *s = bfd_get_section_by_name (dynobj, ".rld_map");
8827 BFD_ASSERT (s != NULL);
8828 sym->st_value = s->output_section->vma + s->output_offset;
8829 bfd_put_32 (output_bfd, (bfd_vma) 0, s->contents);
8830 if (mips_elf_hash_table (info)->rld_value == 0)
8831 mips_elf_hash_table (info)->rld_value = sym->st_value;
8833 else if (mips_elf_hash_table (info)->use_rld_obj_head
8834 && strcmp (name, "__rld_obj_head") == 0)
8836 /* IRIX6 does not use a .rld_map section. */
8837 if (IRIX_COMPAT (output_bfd) == ict_irix5
8838 || IRIX_COMPAT (output_bfd) == ict_none)
8839 BFD_ASSERT (bfd_get_section_by_name (dynobj, ".rld_map")
8841 mips_elf_hash_table (info)->rld_value = sym->st_value;
8845 /* If this is a mips16 symbol, force the value to be even. */
8846 if (sym->st_other == STO_MIPS16
8847 && (sym->st_value & 1) != 0)
8853 /* Finish up the dynamic sections. */
8856 _bfd_mips_elf_finish_dynamic_sections (output_bfd, info)
8858 struct bfd_link_info *info;
8863 struct mips_got_info *g;
8865 dynobj = elf_hash_table (info)->dynobj;
8867 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
8869 sgot = mips_elf_got_section (dynobj);
8874 BFD_ASSERT (elf_section_data (sgot) != NULL);
8875 g = (struct mips_got_info *) elf_section_data (sgot)->tdata;
8876 BFD_ASSERT (g != NULL);
8879 if (elf_hash_table (info)->dynamic_sections_created)
8883 BFD_ASSERT (sdyn != NULL);
8884 BFD_ASSERT (g != NULL);
8886 for (b = sdyn->contents;
8887 b < sdyn->contents + sdyn->_raw_size;
8888 b += MIPS_ELF_DYN_SIZE (dynobj))
8890 Elf_Internal_Dyn dyn;
8896 /* Read in the current dynamic entry. */
8897 (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
8899 /* Assume that we're going to modify it and write it out. */
8905 s = (bfd_get_section_by_name
8907 MIPS_ELF_REL_DYN_SECTION_NAME (dynobj)));
8908 BFD_ASSERT (s != NULL);
8909 dyn.d_un.d_val = MIPS_ELF_REL_SIZE (dynobj);
8913 /* Rewrite DT_STRSZ. */
8915 _bfd_stringtab_size (elf_hash_table (info)->dynstr);
8921 case DT_MIPS_CONFLICT:
8924 case DT_MIPS_LIBLIST:
8927 s = bfd_get_section_by_name (output_bfd, name);
8928 BFD_ASSERT (s != NULL);
8929 dyn.d_un.d_ptr = s->vma;
8932 case DT_MIPS_RLD_VERSION:
8933 dyn.d_un.d_val = 1; /* XXX */
8937 dyn.d_un.d_val = RHF_NOTPOT; /* XXX */
8940 case DT_MIPS_CONFLICTNO:
8942 elemsize = sizeof (Elf32_Conflict);
8945 case DT_MIPS_LIBLISTNO:
8947 elemsize = sizeof (Elf32_Lib);
8949 s = bfd_get_section_by_name (output_bfd, name);
8952 if (s->_cooked_size != 0)
8953 dyn.d_un.d_val = s->_cooked_size / elemsize;
8955 dyn.d_un.d_val = s->_raw_size / elemsize;
8961 case DT_MIPS_TIME_STAMP:
8962 time ((time_t *) &dyn.d_un.d_val);
8965 case DT_MIPS_ICHECKSUM:
8970 case DT_MIPS_IVERSION:
8975 case DT_MIPS_BASE_ADDRESS:
8976 s = output_bfd->sections;
8977 BFD_ASSERT (s != NULL);
8978 dyn.d_un.d_ptr = s->vma & ~(0xffff);
8981 case DT_MIPS_LOCAL_GOTNO:
8982 dyn.d_un.d_val = g->local_gotno;
8985 case DT_MIPS_UNREFEXTNO:
8986 /* The index into the dynamic symbol table which is the
8987 entry of the first external symbol that is not
8988 referenced within the same object. */
8989 dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
8992 case DT_MIPS_GOTSYM:
8993 if (g->global_gotsym)
8995 dyn.d_un.d_val = g->global_gotsym->dynindx;
8998 /* In case if we don't have global got symbols we default
8999 to setting DT_MIPS_GOTSYM to the same value as
9000 DT_MIPS_SYMTABNO, so we just fall through. */
9002 case DT_MIPS_SYMTABNO:
9004 elemsize = MIPS_ELF_SYM_SIZE (output_bfd);
9005 s = bfd_get_section_by_name (output_bfd, name);
9006 BFD_ASSERT (s != NULL);
9008 if (s->_cooked_size != 0)
9009 dyn.d_un.d_val = s->_cooked_size / elemsize;
9011 dyn.d_un.d_val = s->_raw_size / elemsize;
9014 case DT_MIPS_HIPAGENO:
9015 dyn.d_un.d_val = g->local_gotno - MIPS_RESERVED_GOTNO;
9018 case DT_MIPS_RLD_MAP:
9019 dyn.d_un.d_ptr = mips_elf_hash_table (info)->rld_value;
9022 case DT_MIPS_OPTIONS:
9023 s = (bfd_get_section_by_name
9024 (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd)));
9025 dyn.d_un.d_ptr = s->vma;
9029 s = (bfd_get_section_by_name
9030 (output_bfd, MIPS_ELF_MSYM_SECTION_NAME (output_bfd)));
9031 dyn.d_un.d_ptr = s->vma;
9040 (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
9045 /* The first entry of the global offset table will be filled at
9046 runtime. The second entry will be used by some runtime loaders.
9047 This isn't the case of Irix rld. */
9048 if (sgot != NULL && sgot->_raw_size > 0)
9050 MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0, sgot->contents);
9051 MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0x80000000,
9052 sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
9056 elf_section_data (sgot->output_section)->this_hdr.sh_entsize
9057 = MIPS_ELF_GOT_SIZE (output_bfd);
9062 Elf32_compact_rel cpt;
9064 /* ??? The section symbols for the output sections were set up in
9065 _bfd_elf_final_link. SGI sets the STT_NOTYPE attribute for these
9066 symbols. Should we do so? */
9068 smsym = bfd_get_section_by_name (dynobj,
9069 MIPS_ELF_MSYM_SECTION_NAME (dynobj));
9072 Elf32_Internal_Msym msym;
9074 msym.ms_hash_value = 0;
9075 msym.ms_info = ELF32_MS_INFO (0, 1);
9077 for (s = output_bfd->sections; s != NULL; s = s->next)
9079 long dynindx = elf_section_data (s)->dynindx;
9081 bfd_mips_elf_swap_msym_out
9083 (((Elf32_External_Msym *) smsym->contents)
9088 if (SGI_COMPAT (output_bfd))
9090 /* Write .compact_rel section out. */
9091 s = bfd_get_section_by_name (dynobj, ".compact_rel");
9095 cpt.num = s->reloc_count;
9097 cpt.offset = (s->output_section->filepos
9098 + sizeof (Elf32_External_compact_rel));
9101 bfd_elf32_swap_compact_rel_out (output_bfd, &cpt,
9102 ((Elf32_External_compact_rel *)
9105 /* Clean up a dummy stub function entry in .text. */
9106 s = bfd_get_section_by_name (dynobj,
9107 MIPS_ELF_STUB_SECTION_NAME (dynobj));
9110 file_ptr dummy_offset;
9112 BFD_ASSERT (s->_raw_size >= MIPS_FUNCTION_STUB_SIZE);
9113 dummy_offset = s->_raw_size - MIPS_FUNCTION_STUB_SIZE;
9114 memset (s->contents + dummy_offset, 0,
9115 MIPS_FUNCTION_STUB_SIZE);
9120 /* We need to sort the entries of the dynamic relocation section. */
9122 if (!ABI_64_P (output_bfd))
9126 reldyn = bfd_get_section_by_name (dynobj,
9127 MIPS_ELF_REL_DYN_SECTION_NAME (dynobj));
9128 if (reldyn != NULL && reldyn->reloc_count > 2)
9130 reldyn_sorting_bfd = output_bfd;
9131 qsort ((Elf32_External_Rel *) reldyn->contents + 1,
9132 (size_t) reldyn->reloc_count - 1,
9133 sizeof (Elf32_External_Rel), sort_dynamic_relocs);
9137 /* Clean up a first relocation in .rel.dyn. */
9138 s = bfd_get_section_by_name (dynobj,
9139 MIPS_ELF_REL_DYN_SECTION_NAME (dynobj));
9140 if (s != NULL && s->_raw_size > 0)
9141 memset (s->contents, 0, MIPS_ELF_REL_SIZE (dynobj));
9147 /* Support for core dump NOTE sections */
9149 _bfd_elf32_mips_grok_prstatus (abfd, note)
9151 Elf_Internal_Note *note;
9156 switch (note->descsz)
9161 case 256: /* Linux/MIPS */
9163 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
9166 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
9175 /* Make a ".reg/999" section. */
9176 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
9177 raw_size, note->descpos + offset);
9181 _bfd_elf32_mips_grok_psinfo (abfd, note)
9183 Elf_Internal_Note *note;
9185 switch (note->descsz)
9190 case 128: /* Linux/MIPS elf_prpsinfo */
9191 elf_tdata (abfd)->core_program
9192 = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);
9193 elf_tdata (abfd)->core_command
9194 = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
9197 /* Note that for some reason, a spurious space is tacked
9198 onto the end of the args in some (at least one anyway)
9199 implementations, so strip it off if it exists. */
9202 char *command = elf_tdata (abfd)->core_command;
9203 int n = strlen (command);
9205 if (0 < n && command[n - 1] == ' ')
9206 command[n - 1] = '\0';
9212 /* This is almost identical to bfd_generic_get_... except that some
9213 MIPS relocations need to be handled specially. Sigh. */
9216 elf32_mips_get_relocated_section_contents (abfd, link_info, link_order, data,
9217 relocateable, symbols)
9219 struct bfd_link_info *link_info;
9220 struct bfd_link_order *link_order;
9222 boolean relocateable;
9225 /* Get enough memory to hold the stuff */
9226 bfd *input_bfd = link_order->u.indirect.section->owner;
9227 asection *input_section = link_order->u.indirect.section;
9229 long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
9230 arelent **reloc_vector = NULL;
9236 reloc_vector = (arelent **) bfd_malloc (reloc_size);
9237 if (reloc_vector == NULL && reloc_size != 0)
9240 /* read in the section */
9241 if (!bfd_get_section_contents (input_bfd,
9245 input_section->_raw_size))
9248 /* We're not relaxing the section, so just copy the size info */
9249 input_section->_cooked_size = input_section->_raw_size;
9250 input_section->reloc_done = true;
9252 reloc_count = bfd_canonicalize_reloc (input_bfd,
9256 if (reloc_count < 0)
9259 if (reloc_count > 0)
9264 bfd_vma gp = 0x12345678; /* initialize just to shut gcc up */
9267 struct bfd_hash_entry *h;
9268 struct bfd_link_hash_entry *lh;
9269 /* Skip all this stuff if we aren't mixing formats. */
9270 if (abfd && input_bfd
9271 && abfd->xvec == input_bfd->xvec)
9275 h = bfd_hash_lookup (&link_info->hash->table, "_gp", false, false);
9276 lh = (struct bfd_link_hash_entry *) h;
9283 case bfd_link_hash_undefined:
9284 case bfd_link_hash_undefweak:
9285 case bfd_link_hash_common:
9288 case bfd_link_hash_defined:
9289 case bfd_link_hash_defweak:
9291 gp = lh->u.def.value;
9293 case bfd_link_hash_indirect:
9294 case bfd_link_hash_warning:
9296 /* @@FIXME ignoring warning for now */
9298 case bfd_link_hash_new:
9307 for (parent = reloc_vector; *parent != (arelent *) NULL;
9310 char *error_message = (char *) NULL;
9311 bfd_reloc_status_type r;
9313 /* Specific to MIPS: Deal with relocation types that require
9314 knowing the gp of the output bfd. */
9315 asymbol *sym = *(*parent)->sym_ptr_ptr;
9316 if (bfd_is_abs_section (sym->section) && abfd)
9318 /* The special_function wouldn't get called anyways. */
9322 /* The gp isn't there; let the special function code
9323 fall over on its own. */
9325 else if ((*parent)->howto->special_function
9326 == _bfd_mips_elf_gprel16_reloc)
9328 /* bypass special_function call */
9329 r = gprel16_with_gp (input_bfd, sym, *parent, input_section,
9330 relocateable, (PTR) data, gp);
9331 goto skip_bfd_perform_relocation;
9333 /* end mips specific stuff */
9335 r = bfd_perform_relocation (input_bfd,
9339 relocateable ? abfd : (bfd *) NULL,
9341 skip_bfd_perform_relocation:
9345 asection *os = input_section->output_section;
9347 /* A partial link, so keep the relocs */
9348 os->orelocation[os->reloc_count] = *parent;
9352 if (r != bfd_reloc_ok)
9356 case bfd_reloc_undefined:
9357 if (!((*link_info->callbacks->undefined_symbol)
9358 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
9359 input_bfd, input_section, (*parent)->address,
9363 case bfd_reloc_dangerous:
9364 BFD_ASSERT (error_message != (char *) NULL);
9365 if (!((*link_info->callbacks->reloc_dangerous)
9366 (link_info, error_message, input_bfd, input_section,
9367 (*parent)->address)))
9370 case bfd_reloc_overflow:
9371 if (!((*link_info->callbacks->reloc_overflow)
9372 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
9373 (*parent)->howto->name, (*parent)->addend,
9374 input_bfd, input_section, (*parent)->address)))
9377 case bfd_reloc_outofrange:
9386 if (reloc_vector != NULL)
9387 free (reloc_vector);
9391 if (reloc_vector != NULL)
9392 free (reloc_vector);
9396 #define bfd_elf32_bfd_get_relocated_section_contents \
9397 elf32_mips_get_relocated_section_contents
9399 /* ECOFF swapping routines. These are used when dealing with the
9400 .mdebug section, which is in the ECOFF debugging format. */
9401 static const struct ecoff_debug_swap mips_elf32_ecoff_debug_swap = {
9402 /* Symbol table magic number. */
9404 /* Alignment of debugging information. E.g., 4. */
9406 /* Sizes of external symbolic information. */
9407 sizeof (struct hdr_ext),
9408 sizeof (struct dnr_ext),
9409 sizeof (struct pdr_ext),
9410 sizeof (struct sym_ext),
9411 sizeof (struct opt_ext),
9412 sizeof (struct fdr_ext),
9413 sizeof (struct rfd_ext),
9414 sizeof (struct ext_ext),
9415 /* Functions to swap in external symbolic data. */
9424 _bfd_ecoff_swap_tir_in,
9425 _bfd_ecoff_swap_rndx_in,
9426 /* Functions to swap out external symbolic data. */
9435 _bfd_ecoff_swap_tir_out,
9436 _bfd_ecoff_swap_rndx_out,
9437 /* Function to read in symbolic data. */
9438 _bfd_mips_elf_read_ecoff_info
9441 #define TARGET_LITTLE_SYM bfd_elf32_littlemips_vec
9442 #define TARGET_LITTLE_NAME "elf32-littlemips"
9443 #define TARGET_BIG_SYM bfd_elf32_bigmips_vec
9444 #define TARGET_BIG_NAME "elf32-bigmips"
9445 #define ELF_ARCH bfd_arch_mips
9446 #define ELF_MACHINE_CODE EM_MIPS
9448 /* The SVR4 MIPS ABI says that this should be 0x10000, but Irix 5 uses
9449 a value of 0x1000, and we are compatible. */
9450 #define ELF_MAXPAGESIZE 0x1000
9452 #define elf_backend_collect true
9453 #define elf_backend_type_change_ok true
9454 #define elf_backend_can_gc_sections true
9455 #define elf_backend_sign_extend_vma true
9456 #define elf_info_to_howto mips_info_to_howto_rela
9457 #define elf_info_to_howto_rel mips_info_to_howto_rel
9458 #define elf_backend_sym_is_global mips_elf_sym_is_global
9459 #define elf_backend_object_p _bfd_mips_elf_object_p
9460 #define elf_backend_section_from_shdr _bfd_mips_elf_section_from_shdr
9461 #define elf_backend_fake_sections _bfd_mips_elf_fake_sections
9462 #define elf_backend_section_from_bfd_section \
9463 _bfd_mips_elf_section_from_bfd_section
9464 #define elf_backend_section_processing _bfd_mips_elf_section_processing
9465 #define elf_backend_symbol_processing _bfd_mips_elf_symbol_processing
9466 #define elf_backend_additional_program_headers \
9467 _bfd_mips_elf_additional_program_headers
9468 #define elf_backend_modify_segment_map _bfd_mips_elf_modify_segment_map
9469 #define elf_backend_final_write_processing \
9470 _bfd_mips_elf_final_write_processing
9471 #define elf_backend_ecoff_debug_swap &mips_elf32_ecoff_debug_swap
9472 #define elf_backend_add_symbol_hook _bfd_mips_elf_add_symbol_hook
9473 #define elf_backend_create_dynamic_sections \
9474 _bfd_mips_elf_create_dynamic_sections
9475 #define elf_backend_check_relocs _bfd_mips_elf_check_relocs
9476 #define elf_backend_adjust_dynamic_symbol \
9477 _bfd_mips_elf_adjust_dynamic_symbol
9478 #define elf_backend_always_size_sections \
9479 _bfd_mips_elf_always_size_sections
9480 #define elf_backend_size_dynamic_sections \
9481 _bfd_mips_elf_size_dynamic_sections
9482 #define elf_backend_relocate_section _bfd_mips_elf_relocate_section
9483 #define elf_backend_link_output_symbol_hook \
9484 _bfd_mips_elf_link_output_symbol_hook
9485 #define elf_backend_finish_dynamic_symbol \
9486 _bfd_mips_elf_finish_dynamic_symbol
9487 #define elf_backend_finish_dynamic_sections \
9488 _bfd_mips_elf_finish_dynamic_sections
9489 #define elf_backend_gc_mark_hook _bfd_mips_elf_gc_mark_hook
9490 #define elf_backend_gc_sweep_hook _bfd_mips_elf_gc_sweep_hook
9492 #define elf_backend_got_header_size (4*MIPS_RESERVED_GOTNO)
9493 #define elf_backend_plt_header_size 0
9495 #define elf_backend_copy_indirect_symbol \
9496 _bfd_mips_elf_copy_indirect_symbol
9498 #define elf_backend_hide_symbol _bfd_mips_elf_hide_symbol
9499 #define elf_backend_grok_prstatus _bfd_elf32_mips_grok_prstatus
9500 #define elf_backend_grok_psinfo _bfd_elf32_mips_grok_psinfo
9502 #define bfd_elf32_bfd_is_local_label_name \
9503 mips_elf_is_local_label_name
9504 #define bfd_elf32_find_nearest_line _bfd_mips_elf_find_nearest_line
9505 #define bfd_elf32_set_section_contents _bfd_mips_elf_set_section_contents
9506 #define bfd_elf32_bfd_link_hash_table_create \
9507 _bfd_mips_elf_link_hash_table_create
9508 #define bfd_elf32_bfd_final_link _bfd_mips_elf_final_link
9509 #define bfd_elf32_bfd_copy_private_bfd_data \
9510 _bfd_mips_elf_copy_private_bfd_data
9511 #define bfd_elf32_bfd_merge_private_bfd_data \
9512 _bfd_mips_elf_merge_private_bfd_data
9513 #define bfd_elf32_bfd_set_private_flags _bfd_mips_elf_set_private_flags
9514 #define bfd_elf32_bfd_print_private_bfd_data \
9515 _bfd_mips_elf_print_private_bfd_data
9516 #include "elf32-target.h"
9518 /* Support for traditional mips targets */
9520 #define INCLUDED_TARGET_FILE /* More a type of flag */
9522 #undef TARGET_LITTLE_SYM
9523 #undef TARGET_LITTLE_NAME
9524 #undef TARGET_BIG_SYM
9525 #undef TARGET_BIG_NAME
9527 #define TARGET_LITTLE_SYM bfd_elf32_tradlittlemips_vec
9528 #define TARGET_LITTLE_NAME "elf32-tradlittlemips"
9529 #define TARGET_BIG_SYM bfd_elf32_tradbigmips_vec
9530 #define TARGET_BIG_NAME "elf32-tradbigmips"
9532 /* Include the target file again for this target */
9533 #include "elf32-target.h"