1 /* MIPS-specific support for 32-bit ELF
2 Copyright 1993, 94, 95, 96, 97, 98, 1999 Free Software Foundation, Inc.
4 Most of the information added by Ian Lance Taylor, Cygnus Support,
6 N32/64 ABI support added by Mark Mitchell, CodeSourcery, LLC.
7 <mark@codesourcery.com>
8 Traditional MIPS targets support added by Koundinya.K, Dansk Data
9 Elektronik & Operations Research Group. <kk@ddeorg.soft.net>
11 This file is part of BFD, the Binary File Descriptor library.
13 This program is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 2 of the License, or
16 (at your option) any later version.
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
27 /* This file handles MIPS ELF targets. SGI Irix 5 uses a slightly
28 different MIPS ELF from other targets. This matters when linking.
29 This file supports both, switching at runtime. */
39 /* Get the ECOFF swapping routines. */
41 #include "coff/symconst.h"
42 #include "coff/internal.h"
43 #include "coff/ecoff.h"
44 #include "coff/mips.h"
45 #define ECOFF_SIGNED_32
46 #include "ecoffswap.h"
48 /* This structure is used to hold .got information when linking. It
49 is stored in the tdata field of the bfd_elf_section_data structure. */
53 /* The global symbol in the GOT with the lowest index in the dynamic
55 struct elf_link_hash_entry
*global_gotsym
;
56 /* The number of global .got entries. */
57 unsigned int global_gotno
;
58 /* The number of local .got entries. */
59 unsigned int local_gotno
;
60 /* The number of local .got entries we have used. */
61 unsigned int assigned_gotno
;
64 /* The MIPS ELF linker needs additional information for each symbol in
65 the global hash table. */
67 struct mips_elf_link_hash_entry
69 struct elf_link_hash_entry root
;
71 /* External symbol information. */
74 /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
76 unsigned int possibly_dynamic_relocs
;
78 /* The index of the first dynamic relocation (in the .rel.dyn
79 section) against this symbol. */
80 unsigned int min_dyn_reloc_index
;
82 /* If there is a stub that 32 bit functions should use to call this
83 16 bit function, this points to the section containing the stub. */
86 /* Whether we need the fn_stub; this is set if this symbol appears
87 in any relocs other than a 16 bit call. */
90 /* If there is a stub that 16 bit functions should use to call this
91 32 bit function, this points to the section containing the stub. */
94 /* This is like the call_stub field, but it is used if the function
95 being called returns a floating point value. */
96 asection
*call_fp_stub
;
99 static bfd_reloc_status_type mips32_64bit_reloc
100 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
101 static reloc_howto_type
*bfd_elf32_bfd_reloc_type_lookup
102 PARAMS ((bfd
*, bfd_reloc_code_real_type
));
103 static reloc_howto_type
*mips_rtype_to_howto
104 PARAMS ((unsigned int));
105 static void mips_info_to_howto_rel
106 PARAMS ((bfd
*, arelent
*, Elf32_Internal_Rel
*));
107 static void mips_info_to_howto_rela
108 PARAMS ((bfd
*, arelent
*, Elf32_Internal_Rela
*));
109 static void bfd_mips_elf32_swap_gptab_in
110 PARAMS ((bfd
*, const Elf32_External_gptab
*, Elf32_gptab
*));
111 static void bfd_mips_elf32_swap_gptab_out
112 PARAMS ((bfd
*, const Elf32_gptab
*, Elf32_External_gptab
*));
114 static void bfd_mips_elf_swap_msym_in
115 PARAMS ((bfd
*, const Elf32_External_Msym
*, Elf32_Internal_Msym
*));
117 static void bfd_mips_elf_swap_msym_out
118 PARAMS ((bfd
*, const Elf32_Internal_Msym
*, Elf32_External_Msym
*));
119 static boolean mips_elf_sym_is_global
PARAMS ((bfd
*, asymbol
*));
120 static boolean mips_elf_create_procedure_table
121 PARAMS ((PTR
, bfd
*, struct bfd_link_info
*, asection
*,
122 struct ecoff_debug_info
*));
123 static INLINE
int elf_mips_isa
PARAMS ((flagword
));
124 static INLINE
int elf_mips_mach
PARAMS ((flagword
));
125 static INLINE
char* elf_mips_abi_name
PARAMS ((bfd
*));
126 static boolean mips_elf_is_local_label_name
127 PARAMS ((bfd
*, const char *));
128 static struct bfd_hash_entry
*mips_elf_link_hash_newfunc
129 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
130 static int gptab_compare
PARAMS ((const void *, const void *));
131 static bfd_reloc_status_type mips16_jump_reloc
132 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
133 static bfd_reloc_status_type mips16_gprel_reloc
134 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
135 static boolean mips_elf_create_compact_rel_section
136 PARAMS ((bfd
*, struct bfd_link_info
*));
137 static boolean mips_elf_create_got_section
138 PARAMS ((bfd
*, struct bfd_link_info
*));
139 static bfd_reloc_status_type mips_elf_final_gp
140 PARAMS ((bfd
*, asymbol
*, boolean
, char **, bfd_vma
*));
141 static bfd_byte
*elf32_mips_get_relocated_section_contents
142 PARAMS ((bfd
*, struct bfd_link_info
*, struct bfd_link_order
*,
143 bfd_byte
*, boolean
, asymbol
**));
144 static asection
*mips_elf_create_msym_section
146 static void mips_elf_irix6_finish_dynamic_symbol
147 PARAMS ((bfd
*, const char *, Elf_Internal_Sym
*));
148 static bfd_vma mips_elf_sign_extend
PARAMS ((bfd_vma
, int));
149 static boolean mips_elf_overflow_p
PARAMS ((bfd_vma
, int));
150 static bfd_vma mips_elf_high
PARAMS ((bfd_vma
));
151 static bfd_vma mips_elf_higher
PARAMS ((bfd_vma
));
152 static bfd_vma mips_elf_highest
PARAMS ((bfd_vma
));
153 static bfd_vma mips_elf_global_got_index
154 PARAMS ((bfd
*, struct elf_link_hash_entry
*));
155 static bfd_vma mips_elf_local_got_index
156 PARAMS ((bfd
*, struct bfd_link_info
*, bfd_vma
));
157 static bfd_vma mips_elf_got_offset_from_index
158 PARAMS ((bfd
*, bfd
*, bfd_vma
));
159 static boolean mips_elf_record_global_got_symbol
160 PARAMS ((struct elf_link_hash_entry
*, struct bfd_link_info
*,
161 struct mips_got_info
*));
162 static bfd_vma mips_elf_got_page
163 PARAMS ((bfd
*, struct bfd_link_info
*, bfd_vma
, bfd_vma
*));
164 static const Elf_Internal_Rela
*mips_elf_next_relocation
165 PARAMS ((unsigned int, const Elf_Internal_Rela
*,
166 const Elf_Internal_Rela
*));
167 static bfd_reloc_status_type mips_elf_calculate_relocation
168 PARAMS ((bfd
*, bfd
*, asection
*, struct bfd_link_info
*,
169 const Elf_Internal_Rela
*, bfd_vma
, reloc_howto_type
*,
170 Elf_Internal_Sym
*, asection
**, bfd_vma
*, const char **,
172 static bfd_vma mips_elf_obtain_contents
173 PARAMS ((reloc_howto_type
*, const Elf_Internal_Rela
*, bfd
*, bfd_byte
*));
174 static boolean mips_elf_perform_relocation
175 PARAMS ((struct bfd_link_info
*, reloc_howto_type
*,
176 const Elf_Internal_Rela
*, bfd_vma
,
177 bfd
*, asection
*, bfd_byte
*, boolean
));
178 static boolean mips_elf_assign_gp
PARAMS ((bfd
*, bfd_vma
*));
179 static boolean mips_elf_sort_hash_table_f
180 PARAMS ((struct mips_elf_link_hash_entry
*, PTR
));
181 static boolean mips_elf_sort_hash_table
182 PARAMS ((struct bfd_link_info
*, unsigned long));
183 static asection
* mips_elf_got_section
PARAMS ((bfd
*));
184 static struct mips_got_info
*mips_elf_got_info
185 PARAMS ((bfd
*, asection
**));
186 static boolean mips_elf_local_relocation_p
187 PARAMS ((bfd
*, const Elf_Internal_Rela
*, asection
**, boolean
));
188 static bfd_vma mips_elf_create_local_got_entry
189 PARAMS ((bfd
*, struct mips_got_info
*, asection
*, bfd_vma
));
190 static bfd_vma mips_elf_got16_entry
191 PARAMS ((bfd
*, struct bfd_link_info
*, bfd_vma
, boolean
));
192 static boolean mips_elf_create_dynamic_relocation
193 PARAMS ((bfd
*, struct bfd_link_info
*, const Elf_Internal_Rela
*,
194 struct mips_elf_link_hash_entry
*, asection
*,
195 bfd_vma
, bfd_vma
*, asection
*));
196 static void mips_elf_allocate_dynamic_relocations
197 PARAMS ((bfd
*, unsigned int));
198 static boolean mips_elf_stub_section_p
199 PARAMS ((bfd
*, asection
*));
200 static int sort_dynamic_relocs
201 PARAMS ((const void *, const void *));
203 extern const bfd_target bfd_elf32_tradbigmips_vec
;
205 /* The level of IRIX compatibility we're striving for. */
213 /* This will be used when we sort the dynamic relocation records. */
214 static bfd
*reldyn_sorting_bfd
;
216 /* Nonzero if ABFD is using the N32 ABI. */
218 #define ABI_N32_P(abfd) \
219 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
221 /* Nonzero if ABFD is using the 64-bit ABI. FIXME: This is never
223 #define ABI_64_P(abfd) \
224 ((elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64) != 0)
226 /* Depending on the target vector we generate some version of Irix
227 executables or "normal" MIPS ELF ABI executables. */
229 #define IRIX_COMPAT(abfd) \
230 (abfd->xvec == &bfd_elf32_tradbigmips_vec ? ict_none : \
231 ((ABI_N32_P (abfd) || ABI_64_P (abfd)) ? ict_irix6 : ict_irix5))
233 /* Whether we are trying to be compatible with IRIX at all. */
235 #define SGI_COMPAT(abfd) \
236 (IRIX_COMPAT (abfd) != ict_none)
238 /* The name of the msym section. */
239 #define MIPS_ELF_MSYM_SECTION_NAME(abfd) ".msym"
241 /* The name of the srdata section. */
242 #define MIPS_ELF_SRDATA_SECTION_NAME(abfd) ".srdata"
244 /* The name of the options section. */
245 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
246 (IRIX_COMPAT (abfd) == ict_irix6 ? ".MIPS.options" : ".options")
248 /* The name of the stub section. */
249 #define MIPS_ELF_STUB_SECTION_NAME(abfd) \
250 (IRIX_COMPAT (abfd) == ict_irix6 ? ".MIPS.stubs" : ".stub")
252 /* The name of the dynamic relocation section. */
253 #define MIPS_ELF_REL_DYN_SECTION_NAME(abfd) ".rel.dyn"
255 /* The size of an external REL relocation. */
256 #define MIPS_ELF_REL_SIZE(abfd) \
257 (get_elf_backend_data (abfd)->s->sizeof_rel)
259 /* The size of an external dynamic table entry. */
260 #define MIPS_ELF_DYN_SIZE(abfd) \
261 (get_elf_backend_data (abfd)->s->sizeof_dyn)
263 /* The size of a GOT entry. */
264 #define MIPS_ELF_GOT_SIZE(abfd) \
265 (get_elf_backend_data (abfd)->s->arch_size / 8)
267 /* The size of a symbol-table entry. */
268 #define MIPS_ELF_SYM_SIZE(abfd) \
269 (get_elf_backend_data (abfd)->s->sizeof_sym)
271 /* The default alignment for sections, as a power of two. */
272 #define MIPS_ELF_LOG_FILE_ALIGN(abfd) \
273 (get_elf_backend_data (abfd)->s->file_align == 8 ? 3 : 2)
275 /* Get word-sized data. */
276 #define MIPS_ELF_GET_WORD(abfd, ptr) \
277 (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
279 /* Put out word-sized data. */
280 #define MIPS_ELF_PUT_WORD(abfd, val, ptr) \
282 ? bfd_put_64 (abfd, val, ptr) \
283 : bfd_put_32 (abfd, val, ptr))
285 /* Add a dynamic symbol table-entry. */
287 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
288 (ABI_64_P (elf_hash_table (info)->dynobj) \
289 ? bfd_elf64_add_dynamic_entry (info, tag, val) \
290 : bfd_elf32_add_dynamic_entry (info, tag, val))
292 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
293 (ABI_64_P (elf_hash_table (info)->dynobj) \
294 ? (abort (), false) \
295 : bfd_elf32_add_dynamic_entry (info, tag, val))
298 /* The number of local .got entries we reserve. */
299 #define MIPS_RESERVED_GOTNO (2)
301 /* Instructions which appear in a stub. For some reason the stub is
302 slightly different on an SGI system. */
303 #define ELF_MIPS_GP_OFFSET(abfd) (SGI_COMPAT (abfd) ? 0x7ff0 : 0x8000)
304 #define STUB_LW(abfd) \
307 ? 0xdf998010 /* ld t9,0x8010(gp) */ \
308 : 0x8f998010) /* lw t9,0x8010(gp) */ \
309 : 0x8f998010) /* lw t9,0x8000(gp) */
310 #define STUB_MOVE(abfd) \
311 (SGI_COMPAT (abfd) ? 0x03e07825 : 0x03e07821) /* move t7,ra */
312 #define STUB_JALR 0x0320f809 /* jal t9 */
313 #define STUB_LI16(abfd) \
314 (SGI_COMPAT (abfd) ? 0x34180000 : 0x24180000) /* ori t8,zero,0 */
315 #define MIPS_FUNCTION_STUB_SIZE (16)
318 /* We no longer try to identify particular sections for the .dynsym
319 section. When we do, we wind up crashing if there are other random
320 sections with relocations. */
322 /* Names of sections which appear in the .dynsym section in an Irix 5
325 static const char * const mips_elf_dynsym_sec_names
[] =
338 #define SIZEOF_MIPS_DYNSYM_SECNAMES \
339 (sizeof mips_elf_dynsym_sec_names / sizeof mips_elf_dynsym_sec_names[0])
341 /* The number of entries in mips_elf_dynsym_sec_names which go in the
344 #define MIPS_TEXT_DYNSYM_SECNO (3)
348 /* The names of the runtime procedure table symbols used on Irix 5. */
350 static const char * const mips_elf_dynsym_rtproc_names
[] =
353 "_procedure_string_table",
354 "_procedure_table_size",
358 /* These structures are used to generate the .compact_rel section on
363 unsigned long id1
; /* Always one? */
364 unsigned long num
; /* Number of compact relocation entries. */
365 unsigned long id2
; /* Always two? */
366 unsigned long offset
; /* The file offset of the first relocation. */
367 unsigned long reserved0
; /* Zero? */
368 unsigned long reserved1
; /* Zero? */
377 bfd_byte reserved0
[4];
378 bfd_byte reserved1
[4];
379 } Elf32_External_compact_rel
;
383 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
384 unsigned int rtype
: 4; /* Relocation types. See below. */
385 unsigned int dist2to
: 8;
386 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
387 unsigned long konst
; /* KONST field. See below. */
388 unsigned long vaddr
; /* VADDR to be relocated. */
393 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
394 unsigned int rtype
: 4; /* Relocation types. See below. */
395 unsigned int dist2to
: 8;
396 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
397 unsigned long konst
; /* KONST field. See below. */
405 } Elf32_External_crinfo
;
411 } Elf32_External_crinfo2
;
413 /* These are the constants used to swap the bitfields in a crinfo. */
415 #define CRINFO_CTYPE (0x1)
416 #define CRINFO_CTYPE_SH (31)
417 #define CRINFO_RTYPE (0xf)
418 #define CRINFO_RTYPE_SH (27)
419 #define CRINFO_DIST2TO (0xff)
420 #define CRINFO_DIST2TO_SH (19)
421 #define CRINFO_RELVADDR (0x7ffff)
422 #define CRINFO_RELVADDR_SH (0)
424 /* A compact relocation info has long (3 words) or short (2 words)
425 formats. A short format doesn't have VADDR field and relvaddr
426 fields contains ((VADDR - vaddr of the previous entry) >> 2). */
427 #define CRF_MIPS_LONG 1
428 #define CRF_MIPS_SHORT 0
430 /* There are 4 types of compact relocation at least. The value KONST
431 has different meaning for each type:
434 CT_MIPS_REL32 Address in data
435 CT_MIPS_WORD Address in word (XXX)
436 CT_MIPS_GPHI_LO GP - vaddr
437 CT_MIPS_JMPAD Address to jump
440 #define CRT_MIPS_REL32 0xa
441 #define CRT_MIPS_WORD 0xb
442 #define CRT_MIPS_GPHI_LO 0xc
443 #define CRT_MIPS_JMPAD 0xd
445 #define mips_elf_set_cr_format(x,format) ((x).ctype = (format))
446 #define mips_elf_set_cr_type(x,type) ((x).rtype = (type))
447 #define mips_elf_set_cr_dist2to(x,v) ((x).dist2to = (v))
448 #define mips_elf_set_cr_relvaddr(x,d) ((x).relvaddr = (d)<<2)
450 static void bfd_elf32_swap_compact_rel_out
451 PARAMS ((bfd
*, const Elf32_compact_rel
*, Elf32_External_compact_rel
*));
452 static void bfd_elf32_swap_crinfo_out
453 PARAMS ((bfd
*, const Elf32_crinfo
*, Elf32_External_crinfo
*));
455 #define USE_REL 1 /* MIPS uses REL relocations instead of RELA */
457 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
458 from smaller values. Start with zero, widen, *then* decrement. */
459 #define MINUS_ONE (((bfd_vma)0) - 1)
461 static reloc_howto_type elf_mips_howto_table
[] =
464 HOWTO (R_MIPS_NONE
, /* type */
466 0, /* size (0 = byte, 1 = short, 2 = long) */
468 false, /* pc_relative */
470 complain_overflow_dont
, /* complain_on_overflow */
471 bfd_elf_generic_reloc
, /* special_function */
472 "R_MIPS_NONE", /* name */
473 false, /* partial_inplace */
476 false), /* pcrel_offset */
478 /* 16 bit relocation. */
479 HOWTO (R_MIPS_16
, /* type */
481 1, /* size (0 = byte, 1 = short, 2 = long) */
483 false, /* pc_relative */
485 complain_overflow_bitfield
, /* complain_on_overflow */
486 bfd_elf_generic_reloc
, /* special_function */
487 "R_MIPS_16", /* name */
488 true, /* partial_inplace */
489 0xffff, /* src_mask */
490 0xffff, /* dst_mask */
491 false), /* pcrel_offset */
493 /* 32 bit relocation. */
494 HOWTO (R_MIPS_32
, /* type */
496 2, /* size (0 = byte, 1 = short, 2 = long) */
498 false, /* pc_relative */
500 complain_overflow_bitfield
, /* complain_on_overflow */
501 bfd_elf_generic_reloc
, /* special_function */
502 "R_MIPS_32", /* name */
503 true, /* partial_inplace */
504 0xffffffff, /* src_mask */
505 0xffffffff, /* dst_mask */
506 false), /* pcrel_offset */
508 /* 32 bit symbol relative relocation. */
509 HOWTO (R_MIPS_REL32
, /* type */
511 2, /* size (0 = byte, 1 = short, 2 = long) */
513 false, /* pc_relative */
515 complain_overflow_bitfield
, /* complain_on_overflow */
516 bfd_elf_generic_reloc
, /* special_function */
517 "R_MIPS_REL32", /* name */
518 true, /* partial_inplace */
519 0xffffffff, /* src_mask */
520 0xffffffff, /* dst_mask */
521 false), /* pcrel_offset */
523 /* 26 bit branch address. */
524 HOWTO (R_MIPS_26
, /* type */
526 2, /* size (0 = byte, 1 = short, 2 = long) */
528 false, /* pc_relative */
530 complain_overflow_dont
, /* complain_on_overflow */
531 /* This needs complex overflow
532 detection, because the upper four
533 bits must match the PC. */
534 bfd_elf_generic_reloc
, /* special_function */
535 "R_MIPS_26", /* name */
536 true, /* partial_inplace */
537 0x3ffffff, /* src_mask */
538 0x3ffffff, /* dst_mask */
539 false), /* pcrel_offset */
541 /* High 16 bits of symbol value. */
542 HOWTO (R_MIPS_HI16
, /* type */
544 2, /* size (0 = byte, 1 = short, 2 = long) */
546 false, /* pc_relative */
548 complain_overflow_dont
, /* complain_on_overflow */
549 _bfd_mips_elf_hi16_reloc
, /* special_function */
550 "R_MIPS_HI16", /* name */
551 true, /* partial_inplace */
552 0xffff, /* src_mask */
553 0xffff, /* dst_mask */
554 false), /* pcrel_offset */
556 /* Low 16 bits of symbol value. */
557 HOWTO (R_MIPS_LO16
, /* type */
559 2, /* size (0 = byte, 1 = short, 2 = long) */
561 false, /* pc_relative */
563 complain_overflow_dont
, /* complain_on_overflow */
564 _bfd_mips_elf_lo16_reloc
, /* special_function */
565 "R_MIPS_LO16", /* name */
566 true, /* partial_inplace */
567 0xffff, /* src_mask */
568 0xffff, /* dst_mask */
569 false), /* pcrel_offset */
571 /* GP relative reference. */
572 HOWTO (R_MIPS_GPREL16
, /* type */
574 2, /* size (0 = byte, 1 = short, 2 = long) */
576 false, /* pc_relative */
578 complain_overflow_signed
, /* complain_on_overflow */
579 _bfd_mips_elf_gprel16_reloc
, /* special_function */
580 "R_MIPS_GPREL16", /* name */
581 true, /* partial_inplace */
582 0xffff, /* src_mask */
583 0xffff, /* dst_mask */
584 false), /* pcrel_offset */
586 /* Reference to literal section. */
587 HOWTO (R_MIPS_LITERAL
, /* type */
589 2, /* size (0 = byte, 1 = short, 2 = long) */
591 false, /* pc_relative */
593 complain_overflow_signed
, /* complain_on_overflow */
594 _bfd_mips_elf_gprel16_reloc
, /* special_function */
595 "R_MIPS_LITERAL", /* name */
596 true, /* partial_inplace */
597 0xffff, /* src_mask */
598 0xffff, /* dst_mask */
599 false), /* pcrel_offset */
601 /* Reference to global offset table. */
602 HOWTO (R_MIPS_GOT16
, /* type */
604 2, /* size (0 = byte, 1 = short, 2 = long) */
606 false, /* pc_relative */
608 complain_overflow_signed
, /* complain_on_overflow */
609 _bfd_mips_elf_got16_reloc
, /* special_function */
610 "R_MIPS_GOT16", /* name */
611 false, /* partial_inplace */
612 0xffff, /* src_mask */
613 0xffff, /* dst_mask */
614 false), /* pcrel_offset */
616 /* 16 bit PC relative reference. */
617 HOWTO (R_MIPS_PC16
, /* type */
619 2, /* size (0 = byte, 1 = short, 2 = long) */
621 true, /* pc_relative */
623 complain_overflow_signed
, /* complain_on_overflow */
624 bfd_elf_generic_reloc
, /* special_function */
625 "R_MIPS_PC16", /* name */
626 true, /* partial_inplace */
627 0xffff, /* src_mask */
628 0xffff, /* dst_mask */
629 true), /* pcrel_offset */
631 /* 16 bit call through global offset table. */
632 HOWTO (R_MIPS_CALL16
, /* type */
634 2, /* size (0 = byte, 1 = short, 2 = long) */
636 false, /* pc_relative */
638 complain_overflow_signed
, /* complain_on_overflow */
639 bfd_elf_generic_reloc
, /* special_function */
640 "R_MIPS_CALL16", /* name */
641 false, /* partial_inplace */
642 0xffff, /* src_mask */
643 0xffff, /* dst_mask */
644 false), /* pcrel_offset */
646 /* 32 bit GP relative reference. */
647 HOWTO (R_MIPS_GPREL32
, /* type */
649 2, /* size (0 = byte, 1 = short, 2 = long) */
651 false, /* pc_relative */
653 complain_overflow_bitfield
, /* complain_on_overflow */
654 _bfd_mips_elf_gprel32_reloc
, /* special_function */
655 "R_MIPS_GPREL32", /* name */
656 true, /* partial_inplace */
657 0xffffffff, /* src_mask */
658 0xffffffff, /* dst_mask */
659 false), /* pcrel_offset */
661 /* The remaining relocs are defined on Irix 5, although they are
662 not defined by the ABI. */
667 /* A 5 bit shift field. */
668 HOWTO (R_MIPS_SHIFT5
, /* type */
670 2, /* size (0 = byte, 1 = short, 2 = long) */
672 false, /* pc_relative */
674 complain_overflow_bitfield
, /* complain_on_overflow */
675 bfd_elf_generic_reloc
, /* special_function */
676 "R_MIPS_SHIFT5", /* name */
677 true, /* partial_inplace */
678 0x000007c0, /* src_mask */
679 0x000007c0, /* dst_mask */
680 false), /* pcrel_offset */
682 /* A 6 bit shift field. */
683 /* FIXME: This is not handled correctly; a special function is
684 needed to put the most significant bit in the right place. */
685 HOWTO (R_MIPS_SHIFT6
, /* type */
687 2, /* size (0 = byte, 1 = short, 2 = long) */
689 false, /* pc_relative */
691 complain_overflow_bitfield
, /* complain_on_overflow */
692 bfd_elf_generic_reloc
, /* special_function */
693 "R_MIPS_SHIFT6", /* name */
694 true, /* partial_inplace */
695 0x000007c4, /* src_mask */
696 0x000007c4, /* dst_mask */
697 false), /* pcrel_offset */
699 /* A 64 bit relocation. */
700 HOWTO (R_MIPS_64
, /* type */
702 4, /* size (0 = byte, 1 = short, 2 = long) */
704 false, /* pc_relative */
706 complain_overflow_bitfield
, /* complain_on_overflow */
707 mips32_64bit_reloc
, /* special_function */
708 "R_MIPS_64", /* name */
709 true, /* partial_inplace */
710 MINUS_ONE
, /* src_mask */
711 MINUS_ONE
, /* dst_mask */
712 false), /* pcrel_offset */
714 /* Displacement in the global offset table. */
715 HOWTO (R_MIPS_GOT_DISP
, /* type */
717 2, /* size (0 = byte, 1 = short, 2 = long) */
719 false, /* pc_relative */
721 complain_overflow_bitfield
, /* complain_on_overflow */
722 bfd_elf_generic_reloc
, /* special_function */
723 "R_MIPS_GOT_DISP", /* name */
724 true, /* partial_inplace */
725 0x0000ffff, /* src_mask */
726 0x0000ffff, /* dst_mask */
727 false), /* pcrel_offset */
729 /* Displacement to page pointer in the global offset table. */
730 HOWTO (R_MIPS_GOT_PAGE
, /* type */
732 2, /* size (0 = byte, 1 = short, 2 = long) */
734 false, /* pc_relative */
736 complain_overflow_bitfield
, /* complain_on_overflow */
737 bfd_elf_generic_reloc
, /* special_function */
738 "R_MIPS_GOT_PAGE", /* name */
739 true, /* partial_inplace */
740 0x0000ffff, /* src_mask */
741 0x0000ffff, /* dst_mask */
742 false), /* pcrel_offset */
744 /* Offset from page pointer in the global offset table. */
745 HOWTO (R_MIPS_GOT_OFST
, /* type */
747 2, /* size (0 = byte, 1 = short, 2 = long) */
749 false, /* pc_relative */
751 complain_overflow_bitfield
, /* complain_on_overflow */
752 bfd_elf_generic_reloc
, /* special_function */
753 "R_MIPS_GOT_OFST", /* name */
754 true, /* partial_inplace */
755 0x0000ffff, /* src_mask */
756 0x0000ffff, /* dst_mask */
757 false), /* pcrel_offset */
759 /* High 16 bits of displacement in global offset table. */
760 HOWTO (R_MIPS_GOT_HI16
, /* type */
762 2, /* size (0 = byte, 1 = short, 2 = long) */
764 false, /* pc_relative */
766 complain_overflow_dont
, /* complain_on_overflow */
767 bfd_elf_generic_reloc
, /* special_function */
768 "R_MIPS_GOT_HI16", /* name */
769 true, /* partial_inplace */
770 0x0000ffff, /* src_mask */
771 0x0000ffff, /* dst_mask */
772 false), /* pcrel_offset */
774 /* Low 16 bits of displacement in global offset table. */
775 HOWTO (R_MIPS_GOT_LO16
, /* type */
777 2, /* size (0 = byte, 1 = short, 2 = long) */
779 false, /* pc_relative */
781 complain_overflow_dont
, /* complain_on_overflow */
782 bfd_elf_generic_reloc
, /* special_function */
783 "R_MIPS_GOT_LO16", /* name */
784 true, /* partial_inplace */
785 0x0000ffff, /* src_mask */
786 0x0000ffff, /* dst_mask */
787 false), /* pcrel_offset */
789 /* 64 bit subtraction. Used in the N32 ABI. */
790 HOWTO (R_MIPS_SUB
, /* type */
792 4, /* size (0 = byte, 1 = short, 2 = long) */
794 false, /* pc_relative */
796 complain_overflow_bitfield
, /* complain_on_overflow */
797 bfd_elf_generic_reloc
, /* special_function */
798 "R_MIPS_SUB", /* name */
799 true, /* partial_inplace */
800 MINUS_ONE
, /* src_mask */
801 MINUS_ONE
, /* dst_mask */
802 false), /* pcrel_offset */
804 /* Used to cause the linker to insert and delete instructions? */
805 EMPTY_HOWTO (R_MIPS_INSERT_A
),
806 EMPTY_HOWTO (R_MIPS_INSERT_B
),
807 EMPTY_HOWTO (R_MIPS_DELETE
),
809 /* Get the higher value of a 64 bit addend. */
810 HOWTO (R_MIPS_HIGHER
, /* type */
812 2, /* size (0 = byte, 1 = short, 2 = long) */
814 false, /* pc_relative */
816 complain_overflow_dont
, /* complain_on_overflow */
817 bfd_elf_generic_reloc
, /* special_function */
818 "R_MIPS_HIGHER", /* name */
819 true, /* partial_inplace */
821 0xffff, /* dst_mask */
822 false), /* pcrel_offset */
824 /* Get the highest value of a 64 bit addend. */
825 HOWTO (R_MIPS_HIGHEST
, /* type */
827 2, /* size (0 = byte, 1 = short, 2 = long) */
829 false, /* pc_relative */
831 complain_overflow_dont
, /* complain_on_overflow */
832 bfd_elf_generic_reloc
, /* special_function */
833 "R_MIPS_HIGHEST", /* name */
834 true, /* partial_inplace */
836 0xffff, /* dst_mask */
837 false), /* pcrel_offset */
839 /* High 16 bits of displacement in global offset table. */
840 HOWTO (R_MIPS_CALL_HI16
, /* type */
842 2, /* size (0 = byte, 1 = short, 2 = long) */
844 false, /* pc_relative */
846 complain_overflow_dont
, /* complain_on_overflow */
847 bfd_elf_generic_reloc
, /* special_function */
848 "R_MIPS_CALL_HI16", /* name */
849 true, /* partial_inplace */
850 0x0000ffff, /* src_mask */
851 0x0000ffff, /* dst_mask */
852 false), /* pcrel_offset */
854 /* Low 16 bits of displacement in global offset table. */
855 HOWTO (R_MIPS_CALL_LO16
, /* type */
857 2, /* size (0 = byte, 1 = short, 2 = long) */
859 false, /* pc_relative */
861 complain_overflow_dont
, /* complain_on_overflow */
862 bfd_elf_generic_reloc
, /* special_function */
863 "R_MIPS_CALL_LO16", /* name */
864 true, /* partial_inplace */
865 0x0000ffff, /* src_mask */
866 0x0000ffff, /* dst_mask */
867 false), /* pcrel_offset */
869 /* Section displacement. */
870 HOWTO (R_MIPS_SCN_DISP
, /* type */
872 2, /* size (0 = byte, 1 = short, 2 = long) */
874 false, /* pc_relative */
876 complain_overflow_dont
, /* complain_on_overflow */
877 bfd_elf_generic_reloc
, /* special_function */
878 "R_MIPS_SCN_DISP", /* name */
879 false, /* partial_inplace */
880 0xffffffff, /* src_mask */
881 0xffffffff, /* dst_mask */
882 false), /* pcrel_offset */
884 EMPTY_HOWTO (R_MIPS_REL16
),
885 EMPTY_HOWTO (R_MIPS_ADD_IMMEDIATE
),
886 EMPTY_HOWTO (R_MIPS_PJUMP
),
887 EMPTY_HOWTO (R_MIPS_RELGOT
),
889 /* Protected jump conversion. This is an optimization hint. No
890 relocation is required for correctness. */
891 HOWTO (R_MIPS_JALR
, /* type */
893 0, /* size (0 = byte, 1 = short, 2 = long) */
895 false, /* pc_relative */
897 complain_overflow_dont
, /* complain_on_overflow */
898 bfd_elf_generic_reloc
, /* special_function */
899 "R_MIPS_JALR", /* name */
900 false, /* partial_inplace */
901 0x00000000, /* src_mask */
902 0x00000000, /* dst_mask */
903 false), /* pcrel_offset */
906 /* The reloc used for BFD_RELOC_CTOR when doing a 64 bit link. This
907 is a hack to make the linker think that we need 64 bit values. */
908 static reloc_howto_type elf_mips_ctor64_howto
=
909 HOWTO (R_MIPS_64
, /* type */
911 4, /* size (0 = byte, 1 = short, 2 = long) */
913 false, /* pc_relative */
915 complain_overflow_signed
, /* complain_on_overflow */
916 mips32_64bit_reloc
, /* special_function */
917 "R_MIPS_64", /* name */
918 true, /* partial_inplace */
919 0xffffffff, /* src_mask */
920 0xffffffff, /* dst_mask */
921 false); /* pcrel_offset */
923 /* The reloc used for the mips16 jump instruction. */
924 static reloc_howto_type elf_mips16_jump_howto
=
925 HOWTO (R_MIPS16_26
, /* type */
927 2, /* size (0 = byte, 1 = short, 2 = long) */
929 false, /* pc_relative */
931 complain_overflow_dont
, /* complain_on_overflow */
932 /* This needs complex overflow
933 detection, because the upper four
934 bits must match the PC. */
935 mips16_jump_reloc
, /* special_function */
936 "R_MIPS16_26", /* name */
937 true, /* partial_inplace */
938 0x3ffffff, /* src_mask */
939 0x3ffffff, /* dst_mask */
940 false); /* pcrel_offset */
942 /* The reloc used for the mips16 gprel instruction. */
943 static reloc_howto_type elf_mips16_gprel_howto
=
944 HOWTO (R_MIPS16_GPREL
, /* type */
946 2, /* size (0 = byte, 1 = short, 2 = long) */
948 false, /* pc_relative */
950 complain_overflow_signed
, /* complain_on_overflow */
951 mips16_gprel_reloc
, /* special_function */
952 "R_MIPS16_GPREL", /* name */
953 true, /* partial_inplace */
954 0x07ff001f, /* src_mask */
955 0x07ff001f, /* dst_mask */
956 false); /* pcrel_offset */
958 /* GNU extensions for embedded-pic. */
959 /* High 16 bits of symbol value, pc-relative. */
960 static reloc_howto_type elf_mips_gnu_rel_hi16
=
961 HOWTO (R_MIPS_GNU_REL_HI16
, /* type */
963 2, /* size (0 = byte, 1 = short, 2 = long) */
965 true, /* pc_relative */
967 complain_overflow_dont
, /* complain_on_overflow */
968 _bfd_mips_elf_hi16_reloc
, /* special_function */
969 "R_MIPS_GNU_REL_HI16", /* name */
970 true, /* partial_inplace */
971 0xffff, /* src_mask */
972 0xffff, /* dst_mask */
973 true); /* pcrel_offset */
975 /* Low 16 bits of symbol value, pc-relative. */
976 static reloc_howto_type elf_mips_gnu_rel_lo16
=
977 HOWTO (R_MIPS_GNU_REL_LO16
, /* type */
979 2, /* size (0 = byte, 1 = short, 2 = long) */
981 true, /* pc_relative */
983 complain_overflow_dont
, /* complain_on_overflow */
984 _bfd_mips_elf_lo16_reloc
, /* special_function */
985 "R_MIPS_GNU_REL_LO16", /* name */
986 true, /* partial_inplace */
987 0xffff, /* src_mask */
988 0xffff, /* dst_mask */
989 true); /* pcrel_offset */
991 /* 16 bit offset for pc-relative branches. */
992 static reloc_howto_type elf_mips_gnu_rel16_s2
=
993 HOWTO (R_MIPS_GNU_REL16_S2
, /* type */
995 2, /* size (0 = byte, 1 = short, 2 = long) */
997 true, /* pc_relative */
999 complain_overflow_signed
, /* complain_on_overflow */
1000 bfd_elf_generic_reloc
, /* special_function */
1001 "R_MIPS_GNU_REL16_S2", /* name */
1002 true, /* partial_inplace */
1003 0xffff, /* src_mask */
1004 0xffff, /* dst_mask */
1005 true); /* pcrel_offset */
1007 /* 64 bit pc-relative. */
1008 static reloc_howto_type elf_mips_gnu_pcrel64
=
1009 HOWTO (R_MIPS_PC64
, /* type */
1011 4, /* size (0 = byte, 1 = short, 2 = long) */
1013 true, /* pc_relative */
1015 complain_overflow_signed
, /* complain_on_overflow */
1016 bfd_elf_generic_reloc
, /* special_function */
1017 "R_MIPS_PC64", /* name */
1018 true, /* partial_inplace */
1019 MINUS_ONE
, /* src_mask */
1020 MINUS_ONE
, /* dst_mask */
1021 true); /* pcrel_offset */
1023 /* 32 bit pc-relative. */
1024 static reloc_howto_type elf_mips_gnu_pcrel32
=
1025 HOWTO (R_MIPS_PC32
, /* 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_PC32", /* name */
1034 true, /* partial_inplace */
1035 0xffffffff, /* src_mask */
1036 0xffffffff, /* dst_mask */
1037 true); /* pcrel_offset */
1039 /* GNU extension to record C++ vtable hierarchy */
1040 static reloc_howto_type elf_mips_gnu_vtinherit_howto
=
1041 HOWTO (R_MIPS_GNU_VTINHERIT
, /* type */
1043 2, /* size (0 = byte, 1 = short, 2 = long) */
1045 false, /* pc_relative */
1047 complain_overflow_dont
, /* complain_on_overflow */
1048 NULL
, /* special_function */
1049 "R_MIPS_GNU_VTINHERIT", /* name */
1050 false, /* partial_inplace */
1053 false); /* pcrel_offset */
1055 /* GNU extension to record C++ vtable member usage */
1056 static reloc_howto_type elf_mips_gnu_vtentry_howto
=
1057 HOWTO (R_MIPS_GNU_VTENTRY
, /* type */
1059 2, /* size (0 = byte, 1 = short, 2 = long) */
1061 false, /* pc_relative */
1063 complain_overflow_dont
, /* complain_on_overflow */
1064 _bfd_elf_rel_vtable_reloc_fn
, /* special_function */
1065 "R_MIPS_GNU_VTENTRY", /* name */
1066 false, /* partial_inplace */
1069 false); /* pcrel_offset */
1071 /* Do a R_MIPS_HI16 relocation. This has to be done in combination
1072 with a R_MIPS_LO16 reloc, because there is a carry from the LO16 to
1073 the HI16. Here we just save the information we need; we do the
1074 actual relocation when we see the LO16. MIPS ELF requires that the
1075 LO16 immediately follow the HI16. As a GNU extension, we permit an
1076 arbitrary number of HI16 relocs to be associated with a single LO16
1077 reloc. This extension permits gcc to output the HI and LO relocs
1082 struct mips_hi16
*next
;
1087 /* FIXME: This should not be a static variable. */
1089 static struct mips_hi16
*mips_hi16_list
;
1091 bfd_reloc_status_type
1092 _bfd_mips_elf_hi16_reloc (abfd
,
1099 bfd
*abfd ATTRIBUTE_UNUSED
;
1100 arelent
*reloc_entry
;
1103 asection
*input_section
;
1105 char **error_message
;
1107 bfd_reloc_status_type ret
;
1109 struct mips_hi16
*n
;
1111 /* If we're relocating, and this an external symbol, we don't want
1112 to change anything. */
1113 if (output_bfd
!= (bfd
*) NULL
1114 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1115 && reloc_entry
->addend
== 0)
1117 reloc_entry
->address
+= input_section
->output_offset
;
1118 return bfd_reloc_ok
;
1123 if (strcmp (bfd_asymbol_name (symbol
), "_gp_disp") == 0)
1125 boolean relocateable
;
1128 if (ret
== bfd_reloc_undefined
)
1131 if (output_bfd
!= NULL
)
1132 relocateable
= true;
1135 relocateable
= false;
1136 output_bfd
= symbol
->section
->output_section
->owner
;
1139 ret
= mips_elf_final_gp (output_bfd
, symbol
, relocateable
,
1140 error_message
, &gp
);
1141 if (ret
!= bfd_reloc_ok
)
1144 relocation
= gp
- reloc_entry
->address
;
1148 if (bfd_is_und_section (symbol
->section
)
1149 && output_bfd
== (bfd
*) NULL
)
1150 ret
= bfd_reloc_undefined
;
1152 if (bfd_is_com_section (symbol
->section
))
1155 relocation
= symbol
->value
;
1158 relocation
+= symbol
->section
->output_section
->vma
;
1159 relocation
+= symbol
->section
->output_offset
;
1160 relocation
+= reloc_entry
->addend
;
1162 if (reloc_entry
->address
> input_section
->_cooked_size
)
1163 return bfd_reloc_outofrange
;
1165 /* Save the information, and let LO16 do the actual relocation. */
1166 n
= (struct mips_hi16
*) bfd_malloc (sizeof *n
);
1168 return bfd_reloc_outofrange
;
1169 n
->addr
= (bfd_byte
*) data
+ reloc_entry
->address
;
1170 n
->addend
= relocation
;
1171 n
->next
= mips_hi16_list
;
1174 if (output_bfd
!= (bfd
*) NULL
)
1175 reloc_entry
->address
+= input_section
->output_offset
;
1180 /* Do a R_MIPS_LO16 relocation. This is a straightforward 16 bit
1181 inplace relocation; this function exists in order to do the
1182 R_MIPS_HI16 relocation described above. */
1184 bfd_reloc_status_type
1185 _bfd_mips_elf_lo16_reloc (abfd
,
1193 arelent
*reloc_entry
;
1196 asection
*input_section
;
1198 char **error_message
;
1200 arelent gp_disp_relent
;
1202 if (mips_hi16_list
!= NULL
)
1204 struct mips_hi16
*l
;
1211 unsigned long vallo
;
1212 struct mips_hi16
*next
;
1214 /* Do the HI16 relocation. Note that we actually don't need
1215 to know anything about the LO16 itself, except where to
1216 find the low 16 bits of the addend needed by the LO16. */
1217 insn
= bfd_get_32 (abfd
, l
->addr
);
1218 vallo
= (bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
)
1220 val
= ((insn
& 0xffff) << 16) + vallo
;
1223 /* The low order 16 bits are always treated as a signed
1224 value. Therefore, a negative value in the low order bits
1225 requires an adjustment in the high order bits. We need
1226 to make this adjustment in two ways: once for the bits we
1227 took from the data, and once for the bits we are putting
1228 back in to the data. */
1229 if ((vallo
& 0x8000) != 0)
1231 if ((val
& 0x8000) != 0)
1234 insn
= (insn
&~ 0xffff) | ((val
>> 16) & 0xffff);
1235 bfd_put_32 (abfd
, insn
, l
->addr
);
1237 if (strcmp (bfd_asymbol_name (symbol
), "_gp_disp") == 0)
1239 gp_disp_relent
= *reloc_entry
;
1240 reloc_entry
= &gp_disp_relent
;
1241 reloc_entry
->addend
= l
->addend
;
1249 mips_hi16_list
= NULL
;
1251 else if (strcmp (bfd_asymbol_name (symbol
), "_gp_disp") == 0)
1253 bfd_reloc_status_type ret
;
1254 bfd_vma gp
, relocation
;
1256 /* FIXME: Does this case ever occur? */
1258 ret
= mips_elf_final_gp (output_bfd
, symbol
, true, error_message
, &gp
);
1259 if (ret
!= bfd_reloc_ok
)
1262 relocation
= gp
- reloc_entry
->address
;
1263 relocation
+= symbol
->section
->output_section
->vma
;
1264 relocation
+= symbol
->section
->output_offset
;
1265 relocation
+= reloc_entry
->addend
;
1267 if (reloc_entry
->address
> input_section
->_cooked_size
)
1268 return bfd_reloc_outofrange
;
1270 gp_disp_relent
= *reloc_entry
;
1271 reloc_entry
= &gp_disp_relent
;
1272 reloc_entry
->addend
= relocation
- 4;
1275 /* Now do the LO16 reloc in the usual way. */
1276 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1277 input_section
, output_bfd
, error_message
);
1280 /* Do a R_MIPS_GOT16 reloc. This is a reloc against the global offset
1281 table used for PIC code. If the symbol is an external symbol, the
1282 instruction is modified to contain the offset of the appropriate
1283 entry in the global offset table. If the symbol is a section
1284 symbol, the next reloc is a R_MIPS_LO16 reloc. The two 16 bit
1285 addends are combined to form the real addend against the section
1286 symbol; the GOT16 is modified to contain the offset of an entry in
1287 the global offset table, and the LO16 is modified to offset it
1288 appropriately. Thus an offset larger than 16 bits requires a
1289 modified value in the global offset table.
1291 This implementation suffices for the assembler, but the linker does
1292 not yet know how to create global offset tables. */
1294 bfd_reloc_status_type
1295 _bfd_mips_elf_got16_reloc (abfd
,
1303 arelent
*reloc_entry
;
1306 asection
*input_section
;
1308 char **error_message
;
1310 /* If we're relocating, and this an external symbol, we don't want
1311 to change anything. */
1312 if (output_bfd
!= (bfd
*) NULL
1313 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1314 && reloc_entry
->addend
== 0)
1316 reloc_entry
->address
+= input_section
->output_offset
;
1317 return bfd_reloc_ok
;
1320 /* If we're relocating, and this is a local symbol, we can handle it
1322 if (output_bfd
!= (bfd
*) NULL
1323 && (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1324 return _bfd_mips_elf_hi16_reloc (abfd
, reloc_entry
, symbol
, data
,
1325 input_section
, output_bfd
, error_message
);
1330 /* Set the GP value for OUTPUT_BFD. Returns false if this is a
1331 dangerous relocation. */
1334 mips_elf_assign_gp (output_bfd
, pgp
)
1342 /* If we've already figured out what GP will be, just return it. */
1343 *pgp
= _bfd_get_gp_value (output_bfd
);
1347 count
= bfd_get_symcount (output_bfd
);
1348 sym
= bfd_get_outsymbols (output_bfd
);
1350 /* The linker script will have created a symbol named `_gp' with the
1351 appropriate value. */
1352 if (sym
== (asymbol
**) NULL
)
1356 for (i
= 0; i
< count
; i
++, sym
++)
1358 register CONST
char *name
;
1360 name
= bfd_asymbol_name (*sym
);
1361 if (*name
== '_' && strcmp (name
, "_gp") == 0)
1363 *pgp
= bfd_asymbol_value (*sym
);
1364 _bfd_set_gp_value (output_bfd
, *pgp
);
1372 /* Only get the error once. */
1374 _bfd_set_gp_value (output_bfd
, *pgp
);
1381 /* We have to figure out the gp value, so that we can adjust the
1382 symbol value correctly. We look up the symbol _gp in the output
1383 BFD. If we can't find it, we're stuck. We cache it in the ELF
1384 target data. We don't need to adjust the symbol value for an
1385 external symbol if we are producing relocateable output. */
1387 static bfd_reloc_status_type
1388 mips_elf_final_gp (output_bfd
, symbol
, relocateable
, error_message
, pgp
)
1391 boolean relocateable
;
1392 char **error_message
;
1395 if (bfd_is_und_section (symbol
->section
)
1399 return bfd_reloc_undefined
;
1402 *pgp
= _bfd_get_gp_value (output_bfd
);
1405 || (symbol
->flags
& BSF_SECTION_SYM
) != 0))
1409 /* Make up a value. */
1410 *pgp
= symbol
->section
->output_section
->vma
+ 0x4000;
1411 _bfd_set_gp_value (output_bfd
, *pgp
);
1413 else if (!mips_elf_assign_gp (output_bfd
, pgp
))
1416 (char *) _("GP relative relocation when _gp not defined");
1417 return bfd_reloc_dangerous
;
1421 return bfd_reloc_ok
;
1424 /* Do a R_MIPS_GPREL16 relocation. This is a 16 bit value which must
1425 become the offset from the gp register. This function also handles
1426 R_MIPS_LITERAL relocations, although those can be handled more
1427 cleverly because the entries in the .lit8 and .lit4 sections can be
1430 static bfd_reloc_status_type gprel16_with_gp
PARAMS ((bfd
*, asymbol
*,
1431 arelent
*, asection
*,
1432 boolean
, PTR
, bfd_vma
));
1434 bfd_reloc_status_type
1435 _bfd_mips_elf_gprel16_reloc (abfd
, reloc_entry
, symbol
, data
, input_section
,
1436 output_bfd
, error_message
)
1438 arelent
*reloc_entry
;
1441 asection
*input_section
;
1443 char **error_message
;
1445 boolean relocateable
;
1446 bfd_reloc_status_type ret
;
1449 /* If we're relocating, and this is an external symbol with no
1450 addend, we don't want to change anything. We will only have an
1451 addend if this is a newly created reloc, not read from an ELF
1453 if (output_bfd
!= (bfd
*) NULL
1454 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1455 && reloc_entry
->addend
== 0)
1457 reloc_entry
->address
+= input_section
->output_offset
;
1458 return bfd_reloc_ok
;
1461 if (output_bfd
!= (bfd
*) NULL
)
1462 relocateable
= true;
1465 relocateable
= false;
1466 output_bfd
= symbol
->section
->output_section
->owner
;
1469 ret
= mips_elf_final_gp (output_bfd
, symbol
, relocateable
, error_message
,
1471 if (ret
!= bfd_reloc_ok
)
1474 return gprel16_with_gp (abfd
, symbol
, reloc_entry
, input_section
,
1475 relocateable
, data
, gp
);
1478 static bfd_reloc_status_type
1479 gprel16_with_gp (abfd
, symbol
, reloc_entry
, input_section
, relocateable
, data
,
1483 arelent
*reloc_entry
;
1484 asection
*input_section
;
1485 boolean relocateable
;
1493 if (bfd_is_com_section (symbol
->section
))
1496 relocation
= symbol
->value
;
1498 relocation
+= symbol
->section
->output_section
->vma
;
1499 relocation
+= symbol
->section
->output_offset
;
1501 if (reloc_entry
->address
> input_section
->_cooked_size
)
1502 return bfd_reloc_outofrange
;
1504 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1506 /* Set val to the offset into the section or symbol. */
1507 if (reloc_entry
->howto
->src_mask
== 0)
1509 /* This case occurs with the 64-bit MIPS ELF ABI. */
1510 val
= reloc_entry
->addend
;
1514 val
= ((insn
& 0xffff) + reloc_entry
->addend
) & 0xffff;
1519 /* Adjust val for the final section location and GP value. If we
1520 are producing relocateable output, we don't want to do this for
1521 an external symbol. */
1523 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1524 val
+= relocation
- gp
;
1526 insn
= (insn
&~ 0xffff) | (val
& 0xffff);
1527 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
);
1530 reloc_entry
->address
+= input_section
->output_offset
;
1532 /* Make sure it fit in 16 bits. */
1533 if ((long) val
>= 0x8000 || (long) val
< -0x8000)
1534 return bfd_reloc_overflow
;
1536 return bfd_reloc_ok
;
1539 /* Do a R_MIPS_GPREL32 relocation. Is this 32 bit value the offset
1540 from the gp register? XXX */
1542 static bfd_reloc_status_type gprel32_with_gp
PARAMS ((bfd
*, asymbol
*,
1543 arelent
*, asection
*,
1544 boolean
, PTR
, bfd_vma
));
1546 bfd_reloc_status_type
1547 _bfd_mips_elf_gprel32_reloc (abfd
,
1555 arelent
*reloc_entry
;
1558 asection
*input_section
;
1560 char **error_message
;
1562 boolean relocateable
;
1563 bfd_reloc_status_type ret
;
1566 /* If we're relocating, and this is an external symbol with no
1567 addend, we don't want to change anything. We will only have an
1568 addend if this is a newly created reloc, not read from an ELF
1570 if (output_bfd
!= (bfd
*) NULL
1571 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1572 && reloc_entry
->addend
== 0)
1574 *error_message
= (char *)
1575 _("32bits gp relative relocation occurs for an external symbol");
1576 return bfd_reloc_outofrange
;
1579 if (output_bfd
!= (bfd
*) NULL
)
1581 relocateable
= true;
1582 gp
= _bfd_get_gp_value (output_bfd
);
1586 relocateable
= false;
1587 output_bfd
= symbol
->section
->output_section
->owner
;
1589 ret
= mips_elf_final_gp (output_bfd
, symbol
, relocateable
,
1590 error_message
, &gp
);
1591 if (ret
!= bfd_reloc_ok
)
1595 return gprel32_with_gp (abfd
, symbol
, reloc_entry
, input_section
,
1596 relocateable
, data
, gp
);
1599 static bfd_reloc_status_type
1600 gprel32_with_gp (abfd
, symbol
, reloc_entry
, input_section
, relocateable
, data
,
1604 arelent
*reloc_entry
;
1605 asection
*input_section
;
1606 boolean relocateable
;
1613 if (bfd_is_com_section (symbol
->section
))
1616 relocation
= symbol
->value
;
1618 relocation
+= symbol
->section
->output_section
->vma
;
1619 relocation
+= symbol
->section
->output_offset
;
1621 if (reloc_entry
->address
> input_section
->_cooked_size
)
1622 return bfd_reloc_outofrange
;
1624 if (reloc_entry
->howto
->src_mask
== 0)
1626 /* This case arises with the 64-bit MIPS ELF ABI. */
1630 val
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1632 /* Set val to the offset into the section or symbol. */
1633 val
+= reloc_entry
->addend
;
1635 /* Adjust val for the final section location and GP value. If we
1636 are producing relocateable output, we don't want to do this for
1637 an external symbol. */
1639 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1640 val
+= relocation
- gp
;
1642 bfd_put_32 (abfd
, val
, (bfd_byte
*) data
+ reloc_entry
->address
);
1645 reloc_entry
->address
+= input_section
->output_offset
;
1647 return bfd_reloc_ok
;
1650 /* Handle a 64 bit reloc in a 32 bit MIPS ELF file. These are
1651 generated when addreses are 64 bits. The upper 32 bits are a simle
1654 static bfd_reloc_status_type
1655 mips32_64bit_reloc (abfd
, reloc_entry
, symbol
, data
, input_section
,
1656 output_bfd
, error_message
)
1658 arelent
*reloc_entry
;
1661 asection
*input_section
;
1663 char **error_message
;
1665 bfd_reloc_status_type r
;
1670 r
= bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1671 input_section
, output_bfd
, error_message
);
1672 if (r
!= bfd_reloc_continue
)
1675 /* Do a normal 32 bit relocation on the lower 32 bits. */
1676 reloc32
= *reloc_entry
;
1677 if (bfd_big_endian (abfd
))
1678 reloc32
.address
+= 4;
1679 reloc32
.howto
= &elf_mips_howto_table
[R_MIPS_32
];
1680 r
= bfd_perform_relocation (abfd
, &reloc32
, data
, input_section
,
1681 output_bfd
, error_message
);
1683 /* Sign extend into the upper 32 bits. */
1684 val
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc32
.address
);
1685 if ((val
& 0x80000000) != 0)
1689 addr
= reloc_entry
->address
;
1690 if (bfd_little_endian (abfd
))
1692 bfd_put_32 (abfd
, val
, (bfd_byte
*) data
+ addr
);
1697 /* Handle a mips16 jump. */
1699 static bfd_reloc_status_type
1700 mips16_jump_reloc (abfd
, reloc_entry
, symbol
, data
, input_section
,
1701 output_bfd
, error_message
)
1702 bfd
*abfd ATTRIBUTE_UNUSED
;
1703 arelent
*reloc_entry
;
1705 PTR data ATTRIBUTE_UNUSED
;
1706 asection
*input_section
;
1708 char **error_message ATTRIBUTE_UNUSED
;
1710 if (output_bfd
!= (bfd
*) NULL
1711 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1712 && reloc_entry
->addend
== 0)
1714 reloc_entry
->address
+= input_section
->output_offset
;
1715 return bfd_reloc_ok
;
1720 static boolean warned
;
1723 (*_bfd_error_handler
)
1724 (_("Linking mips16 objects into %s format is not supported"),
1725 bfd_get_target (input_section
->output_section
->owner
));
1729 return bfd_reloc_undefined
;
1732 /* Handle a mips16 GP relative reloc. */
1734 static bfd_reloc_status_type
1735 mips16_gprel_reloc (abfd
, reloc_entry
, symbol
, data
, input_section
,
1736 output_bfd
, error_message
)
1738 arelent
*reloc_entry
;
1741 asection
*input_section
;
1743 char **error_message
;
1745 boolean relocateable
;
1746 bfd_reloc_status_type ret
;
1748 unsigned short extend
, insn
;
1749 unsigned long final
;
1751 /* If we're relocating, and this is an external symbol with no
1752 addend, we don't want to change anything. We will only have an
1753 addend if this is a newly created reloc, not read from an ELF
1755 if (output_bfd
!= NULL
1756 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1757 && reloc_entry
->addend
== 0)
1759 reloc_entry
->address
+= input_section
->output_offset
;
1760 return bfd_reloc_ok
;
1763 if (output_bfd
!= NULL
)
1764 relocateable
= true;
1767 relocateable
= false;
1768 output_bfd
= symbol
->section
->output_section
->owner
;
1771 ret
= mips_elf_final_gp (output_bfd
, symbol
, relocateable
, error_message
,
1773 if (ret
!= bfd_reloc_ok
)
1776 if (reloc_entry
->address
> input_section
->_cooked_size
)
1777 return bfd_reloc_outofrange
;
1779 /* Pick up the mips16 extend instruction and the real instruction. */
1780 extend
= bfd_get_16 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1781 insn
= bfd_get_16 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
+ 2);
1783 /* Stuff the current addend back as a 32 bit value, do the usual
1784 relocation, and then clean up. */
1786 (((extend
& 0x1f) << 11)
1789 (bfd_byte
*) data
+ reloc_entry
->address
);
1791 ret
= gprel16_with_gp (abfd
, symbol
, reloc_entry
, input_section
,
1792 relocateable
, data
, gp
);
1794 final
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1797 | ((final
>> 11) & 0x1f)
1799 (bfd_byte
*) data
+ reloc_entry
->address
);
1803 (bfd_byte
*) data
+ reloc_entry
->address
+ 2);
1808 /* Return the ISA for a MIPS e_flags value. */
1811 elf_mips_isa (flags
)
1814 switch (flags
& EF_MIPS_ARCH
)
1828 /* Return the MACH for a MIPS e_flags value. */
1831 elf_mips_mach (flags
)
1834 switch (flags
& EF_MIPS_MACH
)
1836 case E_MIPS_MACH_3900
:
1837 return bfd_mach_mips3900
;
1839 case E_MIPS_MACH_4010
:
1840 return bfd_mach_mips4010
;
1842 case E_MIPS_MACH_4100
:
1843 return bfd_mach_mips4100
;
1845 case E_MIPS_MACH_4111
:
1846 return bfd_mach_mips4111
;
1848 case E_MIPS_MACH_4650
:
1849 return bfd_mach_mips4650
;
1851 case E_MIPS_MACH_MIPS32
:
1852 return bfd_mach_mips4K
;
1855 switch (flags
& EF_MIPS_ARCH
)
1859 return bfd_mach_mips3000
;
1863 return bfd_mach_mips6000
;
1867 return bfd_mach_mips4000
;
1871 return bfd_mach_mips8000
;
1879 /* Return printable name for ABI. */
1882 elf_mips_abi_name (abfd
)
1887 if (ABI_N32_P (abfd
))
1889 else if (ABI_64_P (abfd
))
1892 flags
= elf_elfheader (abfd
)->e_flags
;
1893 switch (flags
& EF_MIPS_ABI
)
1897 case E_MIPS_ABI_O32
:
1899 case E_MIPS_ABI_O64
:
1901 case E_MIPS_ABI_EABI32
:
1903 case E_MIPS_ABI_EABI64
:
1906 return "unknown abi";
1910 /* A mapping from BFD reloc types to MIPS ELF reloc types. */
1912 struct elf_reloc_map
{
1913 bfd_reloc_code_real_type bfd_reloc_val
;
1914 enum elf_mips_reloc_type elf_reloc_val
;
1917 static CONST
struct elf_reloc_map mips_reloc_map
[] =
1919 { BFD_RELOC_NONE
, R_MIPS_NONE
, },
1920 { BFD_RELOC_16
, R_MIPS_16
},
1921 { BFD_RELOC_32
, R_MIPS_32
},
1922 { BFD_RELOC_64
, R_MIPS_64
},
1923 { BFD_RELOC_MIPS_JMP
, R_MIPS_26
},
1924 { BFD_RELOC_HI16_S
, R_MIPS_HI16
},
1925 { BFD_RELOC_LO16
, R_MIPS_LO16
},
1926 { BFD_RELOC_MIPS_GPREL
, R_MIPS_GPREL16
},
1927 { BFD_RELOC_MIPS_LITERAL
, R_MIPS_LITERAL
},
1928 { BFD_RELOC_MIPS_GOT16
, R_MIPS_GOT16
},
1929 { BFD_RELOC_16_PCREL
, R_MIPS_PC16
},
1930 { BFD_RELOC_MIPS_CALL16
, R_MIPS_CALL16
},
1931 { BFD_RELOC_MIPS_GPREL32
, R_MIPS_GPREL32
},
1932 { BFD_RELOC_MIPS_GOT_HI16
, R_MIPS_GOT_HI16
},
1933 { BFD_RELOC_MIPS_GOT_LO16
, R_MIPS_GOT_LO16
},
1934 { BFD_RELOC_MIPS_CALL_HI16
, R_MIPS_CALL_HI16
},
1935 { BFD_RELOC_MIPS_CALL_LO16
, R_MIPS_CALL_LO16
},
1936 { BFD_RELOC_MIPS_SUB
, R_MIPS_SUB
},
1937 { BFD_RELOC_MIPS_GOT_PAGE
, R_MIPS_GOT_PAGE
},
1938 { BFD_RELOC_MIPS_GOT_OFST
, R_MIPS_GOT_OFST
},
1939 { BFD_RELOC_MIPS_GOT_DISP
, R_MIPS_GOT_DISP
}
1942 /* Given a BFD reloc type, return a howto structure. */
1944 static reloc_howto_type
*
1945 bfd_elf32_bfd_reloc_type_lookup (abfd
, code
)
1947 bfd_reloc_code_real_type code
;
1951 for (i
= 0; i
< sizeof (mips_reloc_map
) / sizeof (struct elf_reloc_map
); i
++)
1953 if (mips_reloc_map
[i
].bfd_reloc_val
== code
)
1954 return &elf_mips_howto_table
[(int) mips_reloc_map
[i
].elf_reloc_val
];
1960 bfd_set_error (bfd_error_bad_value
);
1963 case BFD_RELOC_CTOR
:
1964 /* We need to handle BFD_RELOC_CTOR specially.
1965 Select the right relocation (R_MIPS_32 or R_MIPS_64) based on the
1966 size of addresses on this architecture. */
1967 if (bfd_arch_bits_per_address (abfd
) == 32)
1968 return &elf_mips_howto_table
[(int) R_MIPS_32
];
1970 return &elf_mips_ctor64_howto
;
1972 case BFD_RELOC_MIPS16_JMP
:
1973 return &elf_mips16_jump_howto
;
1974 case BFD_RELOC_MIPS16_GPREL
:
1975 return &elf_mips16_gprel_howto
;
1976 case BFD_RELOC_VTABLE_INHERIT
:
1977 return &elf_mips_gnu_vtinherit_howto
;
1978 case BFD_RELOC_VTABLE_ENTRY
:
1979 return &elf_mips_gnu_vtentry_howto
;
1980 case BFD_RELOC_PCREL_HI16_S
:
1981 return &elf_mips_gnu_rel_hi16
;
1982 case BFD_RELOC_PCREL_LO16
:
1983 return &elf_mips_gnu_rel_lo16
;
1984 case BFD_RELOC_16_PCREL_S2
:
1985 return &elf_mips_gnu_rel16_s2
;
1986 case BFD_RELOC_64_PCREL
:
1987 return &elf_mips_gnu_pcrel64
;
1988 case BFD_RELOC_32_PCREL
:
1989 return &elf_mips_gnu_pcrel32
;
1993 /* Given a MIPS Elf32_Internal_Rel, fill in an arelent structure. */
1995 static reloc_howto_type
*
1996 mips_rtype_to_howto (r_type
)
1997 unsigned int r_type
;
2002 return &elf_mips16_jump_howto
;
2004 case R_MIPS16_GPREL
:
2005 return &elf_mips16_gprel_howto
;
2007 case R_MIPS_GNU_VTINHERIT
:
2008 return &elf_mips_gnu_vtinherit_howto
;
2010 case R_MIPS_GNU_VTENTRY
:
2011 return &elf_mips_gnu_vtentry_howto
;
2013 case R_MIPS_GNU_REL_HI16
:
2014 return &elf_mips_gnu_rel_hi16
;
2016 case R_MIPS_GNU_REL_LO16
:
2017 return &elf_mips_gnu_rel_lo16
;
2019 case R_MIPS_GNU_REL16_S2
:
2020 return &elf_mips_gnu_rel16_s2
;
2023 return &elf_mips_gnu_pcrel64
;
2026 return &elf_mips_gnu_pcrel32
;
2030 BFD_ASSERT (r_type
< (unsigned int) R_MIPS_max
);
2031 return &elf_mips_howto_table
[r_type
];
2036 /* Given a MIPS Elf32_Internal_Rel, fill in an arelent structure. */
2039 mips_info_to_howto_rel (abfd
, cache_ptr
, dst
)
2042 Elf32_Internal_Rel
*dst
;
2044 unsigned int r_type
;
2046 r_type
= ELF32_R_TYPE (dst
->r_info
);
2047 cache_ptr
->howto
= mips_rtype_to_howto (r_type
);
2049 /* The addend for a GPREL16 or LITERAL relocation comes from the GP
2050 value for the object file. We get the addend now, rather than
2051 when we do the relocation, because the symbol manipulations done
2052 by the linker may cause us to lose track of the input BFD. */
2053 if (((*cache_ptr
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) != 0
2054 && (r_type
== (unsigned int) R_MIPS_GPREL16
2055 || r_type
== (unsigned int) R_MIPS_LITERAL
))
2056 cache_ptr
->addend
= elf_gp (abfd
);
2059 /* Given a MIPS Elf32_Internal_Rela, fill in an arelent structure. */
2062 mips_info_to_howto_rela (abfd
, cache_ptr
, dst
)
2065 Elf32_Internal_Rela
*dst
;
2067 /* Since an Elf32_Internal_Rel is an initial prefix of an
2068 Elf32_Internal_Rela, we can just use mips_info_to_howto_rel
2070 mips_info_to_howto_rel (abfd
, cache_ptr
, (Elf32_Internal_Rel
*) dst
);
2072 /* If we ever need to do any extra processing with dst->r_addend
2073 (the field omitted in an Elf32_Internal_Rel) we can do it here. */
2076 /* A .reginfo section holds a single Elf32_RegInfo structure. These
2077 routines swap this structure in and out. They are used outside of
2078 BFD, so they are globally visible. */
2081 bfd_mips_elf32_swap_reginfo_in (abfd
, ex
, in
)
2083 const Elf32_External_RegInfo
*ex
;
2086 in
->ri_gprmask
= bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_gprmask
);
2087 in
->ri_cprmask
[0] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[0]);
2088 in
->ri_cprmask
[1] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[1]);
2089 in
->ri_cprmask
[2] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[2]);
2090 in
->ri_cprmask
[3] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[3]);
2091 in
->ri_gp_value
= bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_gp_value
);
2095 bfd_mips_elf32_swap_reginfo_out (abfd
, in
, ex
)
2097 const Elf32_RegInfo
*in
;
2098 Elf32_External_RegInfo
*ex
;
2100 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_gprmask
,
2101 (bfd_byte
*) ex
->ri_gprmask
);
2102 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[0],
2103 (bfd_byte
*) ex
->ri_cprmask
[0]);
2104 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[1],
2105 (bfd_byte
*) ex
->ri_cprmask
[1]);
2106 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[2],
2107 (bfd_byte
*) ex
->ri_cprmask
[2]);
2108 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[3],
2109 (bfd_byte
*) ex
->ri_cprmask
[3]);
2110 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_gp_value
,
2111 (bfd_byte
*) ex
->ri_gp_value
);
2114 /* In the 64 bit ABI, the .MIPS.options section holds register
2115 information in an Elf64_Reginfo structure. These routines swap
2116 them in and out. They are globally visible because they are used
2117 outside of BFD. These routines are here so that gas can call them
2118 without worrying about whether the 64 bit ABI has been included. */
2121 bfd_mips_elf64_swap_reginfo_in (abfd
, ex
, in
)
2123 const Elf64_External_RegInfo
*ex
;
2124 Elf64_Internal_RegInfo
*in
;
2126 in
->ri_gprmask
= bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_gprmask
);
2127 in
->ri_pad
= bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_pad
);
2128 in
->ri_cprmask
[0] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[0]);
2129 in
->ri_cprmask
[1] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[1]);
2130 in
->ri_cprmask
[2] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[2]);
2131 in
->ri_cprmask
[3] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[3]);
2132 in
->ri_gp_value
= bfd_h_get_64 (abfd
, (bfd_byte
*) ex
->ri_gp_value
);
2136 bfd_mips_elf64_swap_reginfo_out (abfd
, in
, ex
)
2138 const Elf64_Internal_RegInfo
*in
;
2139 Elf64_External_RegInfo
*ex
;
2141 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_gprmask
,
2142 (bfd_byte
*) ex
->ri_gprmask
);
2143 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_pad
,
2144 (bfd_byte
*) ex
->ri_pad
);
2145 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[0],
2146 (bfd_byte
*) ex
->ri_cprmask
[0]);
2147 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[1],
2148 (bfd_byte
*) ex
->ri_cprmask
[1]);
2149 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[2],
2150 (bfd_byte
*) ex
->ri_cprmask
[2]);
2151 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[3],
2152 (bfd_byte
*) ex
->ri_cprmask
[3]);
2153 bfd_h_put_64 (abfd
, (bfd_vma
) in
->ri_gp_value
,
2154 (bfd_byte
*) ex
->ri_gp_value
);
2157 /* Swap an entry in a .gptab section. Note that these routines rely
2158 on the equivalence of the two elements of the union. */
2161 bfd_mips_elf32_swap_gptab_in (abfd
, ex
, in
)
2163 const Elf32_External_gptab
*ex
;
2166 in
->gt_entry
.gt_g_value
= bfd_h_get_32 (abfd
, ex
->gt_entry
.gt_g_value
);
2167 in
->gt_entry
.gt_bytes
= bfd_h_get_32 (abfd
, ex
->gt_entry
.gt_bytes
);
2171 bfd_mips_elf32_swap_gptab_out (abfd
, in
, ex
)
2173 const Elf32_gptab
*in
;
2174 Elf32_External_gptab
*ex
;
2176 bfd_h_put_32 (abfd
, (bfd_vma
) in
->gt_entry
.gt_g_value
,
2177 ex
->gt_entry
.gt_g_value
);
2178 bfd_h_put_32 (abfd
, (bfd_vma
) in
->gt_entry
.gt_bytes
,
2179 ex
->gt_entry
.gt_bytes
);
2183 bfd_elf32_swap_compact_rel_out (abfd
, in
, ex
)
2185 const Elf32_compact_rel
*in
;
2186 Elf32_External_compact_rel
*ex
;
2188 bfd_h_put_32 (abfd
, (bfd_vma
) in
->id1
, ex
->id1
);
2189 bfd_h_put_32 (abfd
, (bfd_vma
) in
->num
, ex
->num
);
2190 bfd_h_put_32 (abfd
, (bfd_vma
) in
->id2
, ex
->id2
);
2191 bfd_h_put_32 (abfd
, (bfd_vma
) in
->offset
, ex
->offset
);
2192 bfd_h_put_32 (abfd
, (bfd_vma
) in
->reserved0
, ex
->reserved0
);
2193 bfd_h_put_32 (abfd
, (bfd_vma
) in
->reserved1
, ex
->reserved1
);
2197 bfd_elf32_swap_crinfo_out (abfd
, in
, ex
)
2199 const Elf32_crinfo
*in
;
2200 Elf32_External_crinfo
*ex
;
2204 l
= (((in
->ctype
& CRINFO_CTYPE
) << CRINFO_CTYPE_SH
)
2205 | ((in
->rtype
& CRINFO_RTYPE
) << CRINFO_RTYPE_SH
)
2206 | ((in
->dist2to
& CRINFO_DIST2TO
) << CRINFO_DIST2TO_SH
)
2207 | ((in
->relvaddr
& CRINFO_RELVADDR
) << CRINFO_RELVADDR_SH
));
2208 bfd_h_put_32 (abfd
, (bfd_vma
) l
, ex
->info
);
2209 bfd_h_put_32 (abfd
, (bfd_vma
) in
->konst
, ex
->konst
);
2210 bfd_h_put_32 (abfd
, (bfd_vma
) in
->vaddr
, ex
->vaddr
);
2213 /* Swap in an options header. */
2216 bfd_mips_elf_swap_options_in (abfd
, ex
, in
)
2218 const Elf_External_Options
*ex
;
2219 Elf_Internal_Options
*in
;
2221 in
->kind
= bfd_h_get_8 (abfd
, ex
->kind
);
2222 in
->size
= bfd_h_get_8 (abfd
, ex
->size
);
2223 in
->section
= bfd_h_get_16 (abfd
, ex
->section
);
2224 in
->info
= bfd_h_get_32 (abfd
, ex
->info
);
2227 /* Swap out an options header. */
2230 bfd_mips_elf_swap_options_out (abfd
, in
, ex
)
2232 const Elf_Internal_Options
*in
;
2233 Elf_External_Options
*ex
;
2235 bfd_h_put_8 (abfd
, in
->kind
, ex
->kind
);
2236 bfd_h_put_8 (abfd
, in
->size
, ex
->size
);
2237 bfd_h_put_16 (abfd
, in
->section
, ex
->section
);
2238 bfd_h_put_32 (abfd
, in
->info
, ex
->info
);
2241 /* Swap in an MSYM entry. */
2244 bfd_mips_elf_swap_msym_in (abfd
, ex
, in
)
2246 const Elf32_External_Msym
*ex
;
2247 Elf32_Internal_Msym
*in
;
2249 in
->ms_hash_value
= bfd_h_get_32 (abfd
, ex
->ms_hash_value
);
2250 in
->ms_info
= bfd_h_get_32 (abfd
, ex
->ms_info
);
2253 /* Swap out an MSYM entry. */
2256 bfd_mips_elf_swap_msym_out (abfd
, in
, ex
)
2258 const Elf32_Internal_Msym
*in
;
2259 Elf32_External_Msym
*ex
;
2261 bfd_h_put_32 (abfd
, in
->ms_hash_value
, ex
->ms_hash_value
);
2262 bfd_h_put_32 (abfd
, in
->ms_info
, ex
->ms_info
);
2266 /* Determine whether a symbol is global for the purposes of splitting
2267 the symbol table into global symbols and local symbols. At least
2268 on Irix 5, this split must be between section symbols and all other
2269 symbols. On most ELF targets the split is between static symbols
2270 and externally visible symbols. */
2274 mips_elf_sym_is_global (abfd
, sym
)
2275 bfd
*abfd ATTRIBUTE_UNUSED
;
2278 return (sym
->flags
& BSF_SECTION_SYM
) == 0 ? true : false;
2281 /* Set the right machine number for a MIPS ELF file. This is used for
2282 both the 32-bit and the 64-bit ABI. */
2285 _bfd_mips_elf_object_p (abfd
)
2288 /* Irix 5 and 6 is broken. Object file symbol tables are not always
2289 sorted correctly such that local symbols precede global symbols,
2290 and the sh_info field in the symbol table is not always right. */
2291 elf_bad_symtab (abfd
) = true;
2293 bfd_default_set_arch_mach (abfd
, bfd_arch_mips
,
2294 elf_mips_mach (elf_elfheader (abfd
)->e_flags
));
2298 /* The final processing done just before writing out a MIPS ELF object
2299 file. This gets the MIPS architecture right based on the machine
2300 number. This is used by both the 32-bit and the 64-bit ABI. */
2304 _bfd_mips_elf_final_write_processing (abfd
, linker
)
2306 boolean linker ATTRIBUTE_UNUSED
;
2310 Elf_Internal_Shdr
**hdrpp
;
2314 switch (bfd_get_mach (abfd
))
2317 case bfd_mach_mips3000
:
2318 val
= E_MIPS_ARCH_1
;
2321 case bfd_mach_mips3900
:
2322 val
= E_MIPS_ARCH_1
| E_MIPS_MACH_3900
;
2325 case bfd_mach_mips6000
:
2326 val
= E_MIPS_ARCH_2
;
2329 case bfd_mach_mips4000
:
2330 case bfd_mach_mips4300
:
2331 val
= E_MIPS_ARCH_3
;
2334 case bfd_mach_mips4010
:
2335 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4010
;
2338 case bfd_mach_mips4100
:
2339 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4100
;
2342 case bfd_mach_mips4111
:
2343 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4111
;
2346 case bfd_mach_mips4650
:
2347 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4650
;
2350 case bfd_mach_mips8000
:
2351 val
= E_MIPS_ARCH_4
;
2354 case bfd_mach_mips4K
:
2355 val
= E_MIPS_ARCH_2
| E_MIPS_MACH_MIPS32
;
2359 elf_elfheader (abfd
)->e_flags
&= ~ (EF_MIPS_ARCH
| EF_MIPS_MACH
);
2360 elf_elfheader (abfd
)->e_flags
|= val
;
2362 /* Set the sh_info field for .gptab sections and other appropriate
2363 info for each special section. */
2364 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
2365 i
< elf_elfheader (abfd
)->e_shnum
;
2368 switch ((*hdrpp
)->sh_type
)
2371 case SHT_MIPS_LIBLIST
:
2372 sec
= bfd_get_section_by_name (abfd
, ".dynstr");
2374 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
2377 case SHT_MIPS_GPTAB
:
2378 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
2379 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
2380 BFD_ASSERT (name
!= NULL
2381 && strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0);
2382 sec
= bfd_get_section_by_name (abfd
, name
+ sizeof ".gptab" - 1);
2383 BFD_ASSERT (sec
!= NULL
);
2384 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
2387 case SHT_MIPS_CONTENT
:
2388 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
2389 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
2390 BFD_ASSERT (name
!= NULL
2391 && strncmp (name
, ".MIPS.content",
2392 sizeof ".MIPS.content" - 1) == 0);
2393 sec
= bfd_get_section_by_name (abfd
,
2394 name
+ sizeof ".MIPS.content" - 1);
2395 BFD_ASSERT (sec
!= NULL
);
2396 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
2399 case SHT_MIPS_SYMBOL_LIB
:
2400 sec
= bfd_get_section_by_name (abfd
, ".dynsym");
2402 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
2403 sec
= bfd_get_section_by_name (abfd
, ".liblist");
2405 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
2408 case SHT_MIPS_EVENTS
:
2409 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
2410 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
2411 BFD_ASSERT (name
!= NULL
);
2412 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0)
2413 sec
= bfd_get_section_by_name (abfd
,
2414 name
+ sizeof ".MIPS.events" - 1);
2417 BFD_ASSERT (strncmp (name
, ".MIPS.post_rel",
2418 sizeof ".MIPS.post_rel" - 1) == 0);
2419 sec
= bfd_get_section_by_name (abfd
,
2421 + sizeof ".MIPS.post_rel" - 1));
2423 BFD_ASSERT (sec
!= NULL
);
2424 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
2431 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
2434 _bfd_mips_elf_set_private_flags (abfd
, flags
)
2438 BFD_ASSERT (!elf_flags_init (abfd
)
2439 || elf_elfheader (abfd
)->e_flags
== flags
);
2441 elf_elfheader (abfd
)->e_flags
= flags
;
2442 elf_flags_init (abfd
) = true;
2446 /* Copy backend specific data from one object module to another */
2449 _bfd_mips_elf_copy_private_bfd_data (ibfd
, obfd
)
2453 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2454 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2457 BFD_ASSERT (!elf_flags_init (obfd
)
2458 || (elf_elfheader (obfd
)->e_flags
2459 == elf_elfheader (ibfd
)->e_flags
));
2461 elf_gp (obfd
) = elf_gp (ibfd
);
2462 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
2463 elf_flags_init (obfd
) = true;
2467 /* Merge backend specific data from an object file to the output
2468 object file when linking. */
2471 _bfd_mips_elf_merge_private_bfd_data (ibfd
, obfd
)
2479 /* Check if we have the same endianess */
2480 if (_bfd_generic_verify_endian_match (ibfd
, obfd
) == false)
2483 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2484 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2487 new_flags
= elf_elfheader (ibfd
)->e_flags
;
2488 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_NOREORDER
;
2489 old_flags
= elf_elfheader (obfd
)->e_flags
;
2491 if (! elf_flags_init (obfd
))
2493 elf_flags_init (obfd
) = true;
2494 elf_elfheader (obfd
)->e_flags
= new_flags
;
2495 elf_elfheader (obfd
)->e_ident
[EI_CLASS
]
2496 = elf_elfheader (ibfd
)->e_ident
[EI_CLASS
];
2498 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
2499 && bfd_get_arch_info (obfd
)->the_default
)
2501 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
2502 bfd_get_mach (ibfd
)))
2509 /* Check flag compatibility. */
2511 new_flags
&= ~EF_MIPS_NOREORDER
;
2512 old_flags
&= ~EF_MIPS_NOREORDER
;
2514 if (new_flags
== old_flags
)
2519 if ((new_flags
& EF_MIPS_PIC
) != (old_flags
& EF_MIPS_PIC
))
2521 new_flags
&= ~EF_MIPS_PIC
;
2522 old_flags
&= ~EF_MIPS_PIC
;
2523 (*_bfd_error_handler
)
2524 (_("%s: linking PIC files with non-PIC files"),
2525 bfd_get_filename (ibfd
));
2529 if ((new_flags
& EF_MIPS_CPIC
) != (old_flags
& EF_MIPS_CPIC
))
2531 new_flags
&= ~EF_MIPS_CPIC
;
2532 old_flags
&= ~EF_MIPS_CPIC
;
2533 (*_bfd_error_handler
)
2534 (_("%s: linking abicalls files with non-abicalls files"),
2535 bfd_get_filename (ibfd
));
2539 /* Compare the ISA's. */
2540 if ((new_flags
& (EF_MIPS_ARCH
| EF_MIPS_MACH
))
2541 != (old_flags
& (EF_MIPS_ARCH
| EF_MIPS_MACH
)))
2543 int new_mach
= new_flags
& EF_MIPS_MACH
;
2544 int old_mach
= old_flags
& EF_MIPS_MACH
;
2545 int new_isa
= elf_mips_isa (new_flags
);
2546 int old_isa
= elf_mips_isa (old_flags
);
2548 /* If either has no machine specified, just compare the general isa's.
2549 Some combinations of machines are ok, if the isa's match. */
2552 || new_mach
== old_mach
2555 /* Don't warn about mixing -mips1 and -mips2 code, or mixing -mips3
2556 and -mips4 code. They will normally use the same data sizes and
2557 calling conventions. */
2559 if ((new_isa
== 1 || new_isa
== 2)
2560 ? (old_isa
!= 1 && old_isa
!= 2)
2561 : (old_isa
== 1 || old_isa
== 2))
2563 (*_bfd_error_handler
)
2564 (_("%s: ISA mismatch (-mips%d) with previous modules (-mips%d)"),
2565 bfd_get_filename (ibfd
), new_isa
, old_isa
);
2572 (*_bfd_error_handler
)
2573 (_("%s: ISA mismatch (%d) with previous modules (%d)"),
2574 bfd_get_filename (ibfd
),
2575 elf_mips_mach (new_flags
),
2576 elf_mips_mach (old_flags
));
2580 new_flags
&= ~ (EF_MIPS_ARCH
| EF_MIPS_MACH
);
2581 old_flags
&= ~ (EF_MIPS_ARCH
| EF_MIPS_MACH
);
2584 /* Compare ABI's. The 64-bit ABI does not use EF_MIPS_ABI. But, it
2585 does set EI_CLASS differently from any 32-bit ABI. */
2586 if ((new_flags
& EF_MIPS_ABI
) != (old_flags
& EF_MIPS_ABI
)
2587 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
2588 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
2590 /* Only error if both are set (to different values). */
2591 if (((new_flags
& EF_MIPS_ABI
) && (old_flags
& EF_MIPS_ABI
))
2592 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
2593 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
2595 (*_bfd_error_handler
)
2596 (_("%s: ABI mismatch: linking %s module with previous %s modules"),
2597 bfd_get_filename (ibfd
),
2598 elf_mips_abi_name (ibfd
),
2599 elf_mips_abi_name (obfd
));
2602 new_flags
&= ~EF_MIPS_ABI
;
2603 old_flags
&= ~EF_MIPS_ABI
;
2606 /* Warn about any other mismatches */
2607 if (new_flags
!= old_flags
)
2609 (*_bfd_error_handler
)
2610 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
2611 bfd_get_filename (ibfd
), (unsigned long) new_flags
,
2612 (unsigned long) old_flags
);
2618 bfd_set_error (bfd_error_bad_value
);
2626 _bfd_mips_elf_print_private_bfd_data (abfd
, ptr
)
2630 FILE *file
= (FILE *) ptr
;
2632 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
2634 /* Print normal ELF private data. */
2635 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
2637 /* xgettext:c-format */
2638 fprintf (file
, _ ("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
2640 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
)
2641 fprintf (file
, _ (" [abi=O32]"));
2642 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O64
)
2643 fprintf (file
, _ (" [abi=O64]"));
2644 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
)
2645 fprintf (file
, _ (" [abi=EABI32]"));
2646 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
2647 fprintf (file
, _ (" [abi=EABI64]"));
2648 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
))
2649 fprintf (file
, _ (" [abi unknown]"));
2650 else if (ABI_N32_P (abfd
))
2651 fprintf (file
, _ (" [abi=N32]"));
2652 else if (ABI_64_P (abfd
))
2653 fprintf (file
, _ (" [abi=64]"));
2655 fprintf (file
, _ (" [no abi set]"));
2657 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
2658 fprintf (file
, _ (" [mips1]"));
2659 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
2660 fprintf (file
, _ (" [mips2]"));
2661 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
2662 fprintf (file
, _ (" [mips3]"));
2663 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
2664 fprintf (file
, _ (" [mips4]"));
2666 fprintf (file
, _ (" [unknown ISA]"));
2668 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_32BITMODE
)
2669 fprintf (file
, _ (" [32bitmode]"));
2671 fprintf (file
, _ (" [not 32bitmode]"));
2678 /* Handle a MIPS specific section when reading an object file. This
2679 is called when elfcode.h finds a section with an unknown type.
2680 This routine supports both the 32-bit and 64-bit ELF ABI.
2682 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
2686 _bfd_mips_elf_section_from_shdr (abfd
, hdr
, name
)
2688 Elf_Internal_Shdr
*hdr
;
2693 /* There ought to be a place to keep ELF backend specific flags, but
2694 at the moment there isn't one. We just keep track of the
2695 sections by their name, instead. Fortunately, the ABI gives
2696 suggested names for all the MIPS specific sections, so we will
2697 probably get away with this. */
2698 switch (hdr
->sh_type
)
2700 case SHT_MIPS_LIBLIST
:
2701 if (strcmp (name
, ".liblist") != 0)
2705 if (strcmp (name
, MIPS_ELF_MSYM_SECTION_NAME (abfd
)) != 0)
2708 case SHT_MIPS_CONFLICT
:
2709 if (strcmp (name
, ".conflict") != 0)
2712 case SHT_MIPS_GPTAB
:
2713 if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) != 0)
2716 case SHT_MIPS_UCODE
:
2717 if (strcmp (name
, ".ucode") != 0)
2720 case SHT_MIPS_DEBUG
:
2721 if (strcmp (name
, ".mdebug") != 0)
2723 flags
= SEC_DEBUGGING
;
2725 case SHT_MIPS_REGINFO
:
2726 if (strcmp (name
, ".reginfo") != 0
2727 || hdr
->sh_size
!= sizeof (Elf32_External_RegInfo
))
2729 flags
= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_SIZE
);
2731 case SHT_MIPS_IFACE
:
2732 if (strcmp (name
, ".MIPS.interfaces") != 0)
2735 case SHT_MIPS_CONTENT
:
2736 if (strncmp (name
, ".MIPS.content", sizeof ".MIPS.content" - 1) != 0)
2739 case SHT_MIPS_OPTIONS
:
2740 if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) != 0)
2743 case SHT_MIPS_DWARF
:
2744 if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) != 0)
2747 case SHT_MIPS_SYMBOL_LIB
:
2748 if (strcmp (name
, ".MIPS.symlib") != 0)
2751 case SHT_MIPS_EVENTS
:
2752 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) != 0
2753 && strncmp (name
, ".MIPS.post_rel",
2754 sizeof ".MIPS.post_rel" - 1) != 0)
2761 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
2766 if (! bfd_set_section_flags (abfd
, hdr
->bfd_section
,
2767 (bfd_get_section_flags (abfd
,
2773 /* FIXME: We should record sh_info for a .gptab section. */
2775 /* For a .reginfo section, set the gp value in the tdata information
2776 from the contents of this section. We need the gp value while
2777 processing relocs, so we just get it now. The .reginfo section
2778 is not used in the 64-bit MIPS ELF ABI. */
2779 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
2781 Elf32_External_RegInfo ext
;
2784 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, (PTR
) &ext
,
2785 (file_ptr
) 0, sizeof ext
))
2787 bfd_mips_elf32_swap_reginfo_in (abfd
, &ext
, &s
);
2788 elf_gp (abfd
) = s
.ri_gp_value
;
2791 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
2792 set the gp value based on what we find. We may see both
2793 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
2794 they should agree. */
2795 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
)
2797 bfd_byte
*contents
, *l
, *lend
;
2799 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
2800 if (contents
== NULL
)
2802 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
,
2803 (file_ptr
) 0, hdr
->sh_size
))
2809 lend
= contents
+ hdr
->sh_size
;
2810 while (l
+ sizeof (Elf_External_Options
) <= lend
)
2812 Elf_Internal_Options intopt
;
2814 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
2816 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
2818 Elf64_Internal_RegInfo intreg
;
2820 bfd_mips_elf64_swap_reginfo_in
2822 ((Elf64_External_RegInfo
*)
2823 (l
+ sizeof (Elf_External_Options
))),
2825 elf_gp (abfd
) = intreg
.ri_gp_value
;
2827 else if (intopt
.kind
== ODK_REGINFO
)
2829 Elf32_RegInfo intreg
;
2831 bfd_mips_elf32_swap_reginfo_in
2833 ((Elf32_External_RegInfo
*)
2834 (l
+ sizeof (Elf_External_Options
))),
2836 elf_gp (abfd
) = intreg
.ri_gp_value
;
2846 /* Set the correct type for a MIPS ELF section. We do this by the
2847 section name, which is a hack, but ought to work. This routine is
2848 used by both the 32-bit and the 64-bit ABI. */
2851 _bfd_mips_elf_fake_sections (abfd
, hdr
, sec
)
2853 Elf32_Internal_Shdr
*hdr
;
2856 register const char *name
;
2858 name
= bfd_get_section_name (abfd
, sec
);
2860 if (strcmp (name
, ".liblist") == 0)
2862 hdr
->sh_type
= SHT_MIPS_LIBLIST
;
2863 hdr
->sh_info
= sec
->_raw_size
/ sizeof (Elf32_Lib
);
2864 /* The sh_link field is set in final_write_processing. */
2866 else if (strcmp (name
, ".conflict") == 0)
2867 hdr
->sh_type
= SHT_MIPS_CONFLICT
;
2868 else if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0)
2870 hdr
->sh_type
= SHT_MIPS_GPTAB
;
2871 hdr
->sh_entsize
= sizeof (Elf32_External_gptab
);
2872 /* The sh_info field is set in final_write_processing. */
2874 else if (strcmp (name
, ".ucode") == 0)
2875 hdr
->sh_type
= SHT_MIPS_UCODE
;
2876 else if (strcmp (name
, ".mdebug") == 0)
2878 hdr
->sh_type
= SHT_MIPS_DEBUG
;
2879 /* In a shared object on Irix 5.3, the .mdebug section has an
2880 entsize of 0. FIXME: Does this matter? */
2881 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
2882 hdr
->sh_entsize
= 0;
2884 hdr
->sh_entsize
= 1;
2886 else if (strcmp (name
, ".reginfo") == 0)
2888 hdr
->sh_type
= SHT_MIPS_REGINFO
;
2889 /* In a shared object on Irix 5.3, the .reginfo section has an
2890 entsize of 0x18. FIXME: Does this matter? */
2891 if (SGI_COMPAT (abfd
))
2893 if ((abfd
->flags
& DYNAMIC
) != 0)
2894 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
2896 hdr
->sh_entsize
= 1;
2899 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
2901 else if (SGI_COMPAT (abfd
)
2902 && (strcmp (name
, ".hash") == 0
2903 || strcmp (name
, ".dynamic") == 0
2904 || strcmp (name
, ".dynstr") == 0))
2906 if ( SGI_COMPAT(abfd
))
2907 hdr
->sh_entsize
= 0;
2909 /* This isn't how the Irix 6 linker behaves. */
2910 hdr
->sh_info
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
2913 else if (strcmp (name
, ".got") == 0
2914 || strcmp (name
, MIPS_ELF_SRDATA_SECTION_NAME (abfd
)) == 0
2915 || strcmp (name
, ".sdata") == 0
2916 || strcmp (name
, ".sbss") == 0
2917 || strcmp (name
, ".lit4") == 0
2918 || strcmp (name
, ".lit8") == 0)
2919 hdr
->sh_flags
|= SHF_MIPS_GPREL
;
2920 else if (strcmp (name
, ".MIPS.interfaces") == 0)
2922 hdr
->sh_type
= SHT_MIPS_IFACE
;
2923 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
2925 else if (strncmp (name
, ".MIPS.content", strlen (".MIPS.content")) == 0)
2927 hdr
->sh_type
= SHT_MIPS_CONTENT
;
2928 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
2929 /* The sh_info field is set in final_write_processing. */
2931 else if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
2933 hdr
->sh_type
= SHT_MIPS_OPTIONS
;
2934 hdr
->sh_entsize
= 1;
2935 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
2937 else if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) == 0)
2938 hdr
->sh_type
= SHT_MIPS_DWARF
;
2939 else if (strcmp (name
, ".MIPS.symlib") == 0)
2941 hdr
->sh_type
= SHT_MIPS_SYMBOL_LIB
;
2942 /* The sh_link and sh_info fields are set in
2943 final_write_processing. */
2945 else if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0
2946 || strncmp (name
, ".MIPS.post_rel",
2947 sizeof ".MIPS.post_rel" - 1) == 0)
2949 hdr
->sh_type
= SHT_MIPS_EVENTS
;
2950 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
2951 /* The sh_link field is set in final_write_processing. */
2953 else if (strcmp (name
, MIPS_ELF_MSYM_SECTION_NAME (abfd
)) == 0)
2955 hdr
->sh_type
= SHT_MIPS_MSYM
;
2956 hdr
->sh_flags
|= SHF_ALLOC
;
2957 hdr
->sh_entsize
= 8;
2960 /* The generic elf_fake_sections will set up REL_HDR using the
2961 default kind of relocations. But, we may actually need both
2962 kinds of relocations, so we set up the second header here. */
2963 if ((sec
->flags
& SEC_RELOC
) != 0)
2965 struct bfd_elf_section_data
*esd
;
2967 esd
= elf_section_data (sec
);
2968 BFD_ASSERT (esd
->rel_hdr2
== NULL
);
2970 = (Elf_Internal_Shdr
*) bfd_zalloc (abfd
, sizeof (Elf_Internal_Shdr
));
2973 _bfd_elf_init_reloc_shdr (abfd
, esd
->rel_hdr2
, sec
,
2974 !elf_section_data (sec
)->use_rela_p
);
2980 /* Given a BFD section, try to locate the corresponding ELF section
2981 index. This is used by both the 32-bit and the 64-bit ABI.
2982 Actually, it's not clear to me that the 64-bit ABI supports these,
2983 but for non-PIC objects we will certainly want support for at least
2984 the .scommon section. */
2987 _bfd_mips_elf_section_from_bfd_section (abfd
, hdr
, sec
, retval
)
2988 bfd
*abfd ATTRIBUTE_UNUSED
;
2989 Elf32_Internal_Shdr
*hdr ATTRIBUTE_UNUSED
;
2993 if (strcmp (bfd_get_section_name (abfd
, sec
), ".scommon") == 0)
2995 *retval
= SHN_MIPS_SCOMMON
;
2998 if (strcmp (bfd_get_section_name (abfd
, sec
), ".acommon") == 0)
3000 *retval
= SHN_MIPS_ACOMMON
;
3006 /* When are writing out the .options or .MIPS.options section,
3007 remember the bytes we are writing out, so that we can install the
3008 GP value in the section_processing routine. */
3011 _bfd_mips_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3016 bfd_size_type count
;
3018 if (strcmp (section
->name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
3022 if (elf_section_data (section
) == NULL
)
3024 section
->used_by_bfd
=
3025 (PTR
) bfd_zalloc (abfd
, sizeof (struct bfd_elf_section_data
));
3026 if (elf_section_data (section
) == NULL
)
3029 c
= (bfd_byte
*) elf_section_data (section
)->tdata
;
3034 if (section
->_cooked_size
!= 0)
3035 size
= section
->_cooked_size
;
3037 size
= section
->_raw_size
;
3038 c
= (bfd_byte
*) bfd_zalloc (abfd
, size
);
3041 elf_section_data (section
)->tdata
= (PTR
) c
;
3044 memcpy (c
+ offset
, location
, count
);
3047 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
,
3051 /* Work over a section just before writing it out. This routine is
3052 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
3053 sections that need the SHF_MIPS_GPREL flag by name; there has to be
3057 _bfd_mips_elf_section_processing (abfd
, hdr
)
3059 Elf_Internal_Shdr
*hdr
;
3061 if (hdr
->sh_type
== SHT_MIPS_REGINFO
3062 && hdr
->sh_size
> 0)
3066 BFD_ASSERT (hdr
->sh_size
== sizeof (Elf32_External_RegInfo
));
3067 BFD_ASSERT (hdr
->contents
== NULL
);
3070 hdr
->sh_offset
+ sizeof (Elf32_External_RegInfo
) - 4,
3073 bfd_h_put_32 (abfd
, (bfd_vma
) elf_gp (abfd
), buf
);
3074 if (bfd_write (buf
, (bfd_size_type
) 1, (bfd_size_type
) 4, abfd
) != 4)
3078 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
3079 && hdr
->bfd_section
!= NULL
3080 && elf_section_data (hdr
->bfd_section
) != NULL
3081 && elf_section_data (hdr
->bfd_section
)->tdata
!= NULL
)
3083 bfd_byte
*contents
, *l
, *lend
;
3085 /* We stored the section contents in the elf_section_data tdata
3086 field in the set_section_contents routine. We save the
3087 section contents so that we don't have to read them again.
3088 At this point we know that elf_gp is set, so we can look
3089 through the section contents to see if there is an
3090 ODK_REGINFO structure. */
3092 contents
= (bfd_byte
*) elf_section_data (hdr
->bfd_section
)->tdata
;
3094 lend
= contents
+ hdr
->sh_size
;
3095 while (l
+ sizeof (Elf_External_Options
) <= lend
)
3097 Elf_Internal_Options intopt
;
3099 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
3101 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
3108 + sizeof (Elf_External_Options
)
3109 + (sizeof (Elf64_External_RegInfo
) - 8)),
3112 bfd_h_put_64 (abfd
, elf_gp (abfd
), buf
);
3113 if (bfd_write (buf
, 1, 8, abfd
) != 8)
3116 else if (intopt
.kind
== ODK_REGINFO
)
3123 + sizeof (Elf_External_Options
)
3124 + (sizeof (Elf32_External_RegInfo
) - 4)),
3127 bfd_h_put_32 (abfd
, elf_gp (abfd
), buf
);
3128 if (bfd_write (buf
, 1, 4, abfd
) != 4)
3135 if (hdr
->bfd_section
!= NULL
)
3137 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
3139 if (strcmp (name
, ".sdata") == 0
3140 || strcmp (name
, ".lit8") == 0
3141 || strcmp (name
, ".lit4") == 0)
3143 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
3144 hdr
->sh_type
= SHT_PROGBITS
;
3146 else if (strcmp (name
, ".sbss") == 0)
3148 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
3149 hdr
->sh_type
= SHT_NOBITS
;
3151 else if (strcmp (name
, MIPS_ELF_SRDATA_SECTION_NAME (abfd
)) == 0)
3153 hdr
->sh_flags
|= SHF_ALLOC
| SHF_MIPS_GPREL
;
3154 hdr
->sh_type
= SHT_PROGBITS
;
3156 else if (strcmp (name
, ".compact_rel") == 0)
3159 hdr
->sh_type
= SHT_PROGBITS
;
3161 else if (strcmp (name
, ".rtproc") == 0)
3163 if (hdr
->sh_addralign
!= 0 && hdr
->sh_entsize
== 0)
3165 unsigned int adjust
;
3167 adjust
= hdr
->sh_size
% hdr
->sh_addralign
;
3169 hdr
->sh_size
+= hdr
->sh_addralign
- adjust
;
3178 /* MIPS ELF uses two common sections. One is the usual one, and the
3179 other is for small objects. All the small objects are kept
3180 together, and then referenced via the gp pointer, which yields
3181 faster assembler code. This is what we use for the small common
3182 section. This approach is copied from ecoff.c. */
3183 static asection mips_elf_scom_section
;
3184 static asymbol mips_elf_scom_symbol
;
3185 static asymbol
*mips_elf_scom_symbol_ptr
;
3187 /* MIPS ELF also uses an acommon section, which represents an
3188 allocated common symbol which may be overridden by a
3189 definition in a shared library. */
3190 static asection mips_elf_acom_section
;
3191 static asymbol mips_elf_acom_symbol
;
3192 static asymbol
*mips_elf_acom_symbol_ptr
;
3194 /* Handle the special MIPS section numbers that a symbol may use.
3195 This is used for both the 32-bit and the 64-bit ABI. */
3198 _bfd_mips_elf_symbol_processing (abfd
, asym
)
3202 elf_symbol_type
*elfsym
;
3204 elfsym
= (elf_symbol_type
*) asym
;
3205 switch (elfsym
->internal_elf_sym
.st_shndx
)
3207 case SHN_MIPS_ACOMMON
:
3208 /* This section is used in a dynamically linked executable file.
3209 It is an allocated common section. The dynamic linker can
3210 either resolve these symbols to something in a shared
3211 library, or it can just leave them here. For our purposes,
3212 we can consider these symbols to be in a new section. */
3213 if (mips_elf_acom_section
.name
== NULL
)
3215 /* Initialize the acommon section. */
3216 mips_elf_acom_section
.name
= ".acommon";
3217 mips_elf_acom_section
.flags
= SEC_ALLOC
;
3218 mips_elf_acom_section
.output_section
= &mips_elf_acom_section
;
3219 mips_elf_acom_section
.symbol
= &mips_elf_acom_symbol
;
3220 mips_elf_acom_section
.symbol_ptr_ptr
= &mips_elf_acom_symbol_ptr
;
3221 mips_elf_acom_symbol
.name
= ".acommon";
3222 mips_elf_acom_symbol
.flags
= BSF_SECTION_SYM
;
3223 mips_elf_acom_symbol
.section
= &mips_elf_acom_section
;
3224 mips_elf_acom_symbol_ptr
= &mips_elf_acom_symbol
;
3226 asym
->section
= &mips_elf_acom_section
;
3230 /* Common symbols less than the GP size are automatically
3231 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
3232 if (asym
->value
> elf_gp_size (abfd
)
3233 || IRIX_COMPAT (abfd
) == ict_irix6
)
3236 case SHN_MIPS_SCOMMON
:
3237 if (mips_elf_scom_section
.name
== NULL
)
3239 /* Initialize the small common section. */
3240 mips_elf_scom_section
.name
= ".scommon";
3241 mips_elf_scom_section
.flags
= SEC_IS_COMMON
;
3242 mips_elf_scom_section
.output_section
= &mips_elf_scom_section
;
3243 mips_elf_scom_section
.symbol
= &mips_elf_scom_symbol
;
3244 mips_elf_scom_section
.symbol_ptr_ptr
= &mips_elf_scom_symbol_ptr
;
3245 mips_elf_scom_symbol
.name
= ".scommon";
3246 mips_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
3247 mips_elf_scom_symbol
.section
= &mips_elf_scom_section
;
3248 mips_elf_scom_symbol_ptr
= &mips_elf_scom_symbol
;
3250 asym
->section
= &mips_elf_scom_section
;
3251 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
3254 case SHN_MIPS_SUNDEFINED
:
3255 asym
->section
= bfd_und_section_ptr
;
3258 #if 0 /* for SGI_COMPAT */
3260 asym
->section
= mips_elf_text_section_ptr
;
3264 asym
->section
= mips_elf_data_section_ptr
;
3270 /* When creating an Irix 5 executable, we need REGINFO and RTPROC
3274 _bfd_mips_elf_additional_program_headers (abfd
)
3280 /* See if we need a PT_MIPS_REGINFO segment. */
3281 s
= bfd_get_section_by_name (abfd
, ".reginfo");
3282 if (s
&& (s
->flags
& SEC_LOAD
))
3285 /* See if we need a PT_MIPS_OPTIONS segment. */
3286 if (IRIX_COMPAT (abfd
) == ict_irix6
3287 && bfd_get_section_by_name (abfd
,
3288 MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)))
3291 /* See if we need a PT_MIPS_RTPROC segment. */
3292 if (IRIX_COMPAT (abfd
) == ict_irix5
3293 && bfd_get_section_by_name (abfd
, ".dynamic")
3294 && bfd_get_section_by_name (abfd
, ".mdebug"))
3300 /* Modify the segment map for an Irix 5 executable. */
3303 _bfd_mips_elf_modify_segment_map (abfd
)
3307 struct elf_segment_map
*m
, **pm
;
3309 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
3311 s
= bfd_get_section_by_name (abfd
, ".reginfo");
3312 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3314 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
3315 if (m
->p_type
== PT_MIPS_REGINFO
)
3319 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, sizeof *m
);
3323 m
->p_type
= PT_MIPS_REGINFO
;
3327 /* We want to put it after the PHDR and INTERP segments. */
3328 pm
= &elf_tdata (abfd
)->segment_map
;
3330 && ((*pm
)->p_type
== PT_PHDR
3331 || (*pm
)->p_type
== PT_INTERP
))
3339 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
3340 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
3341 PT_OPTIONS segement immediately following the program header
3343 if (IRIX_COMPAT (abfd
) == ict_irix6
)
3347 for (s
= abfd
->sections
; s
; s
= s
->next
)
3348 if (elf_section_data (s
)->this_hdr
.sh_type
== SHT_MIPS_OPTIONS
)
3353 struct elf_segment_map
*options_segment
;
3355 /* Usually, there's a program header table. But, sometimes
3356 there's not (like when running the `ld' testsuite). So,
3357 if there's no program header table, we just put the
3358 options segement at the end. */
3359 for (pm
= &elf_tdata (abfd
)->segment_map
;
3362 if ((*pm
)->p_type
== PT_PHDR
)
3365 options_segment
= bfd_zalloc (abfd
,
3366 sizeof (struct elf_segment_map
));
3367 options_segment
->next
= *pm
;
3368 options_segment
->p_type
= PT_MIPS_OPTIONS
;
3369 options_segment
->p_flags
= PF_R
;
3370 options_segment
->p_flags_valid
= true;
3371 options_segment
->count
= 1;
3372 options_segment
->sections
[0] = s
;
3373 *pm
= options_segment
;
3378 if (IRIX_COMPAT (abfd
) == ict_irix5
)
3380 /* If there are .dynamic and .mdebug sections, we make a room
3381 for the RTPROC header. FIXME: Rewrite without section names. */
3382 if (bfd_get_section_by_name (abfd
, ".interp") == NULL
3383 && bfd_get_section_by_name (abfd
, ".dynamic") != NULL
3384 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
3386 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
3387 if (m
->p_type
== PT_MIPS_RTPROC
)
3391 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, sizeof *m
);
3395 m
->p_type
= PT_MIPS_RTPROC
;
3397 s
= bfd_get_section_by_name (abfd
, ".rtproc");
3402 m
->p_flags_valid
= 1;
3410 /* We want to put it after the DYNAMIC segment. */
3411 pm
= &elf_tdata (abfd
)->segment_map
;
3412 while (*pm
!= NULL
&& (*pm
)->p_type
!= PT_DYNAMIC
)
3422 /* On Irix 5, the PT_DYNAMIC segment includes the .dynamic,
3423 .dynstr, .dynsym, and .hash sections, and everything in
3425 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
;
3427 if ((*pm
)->p_type
== PT_DYNAMIC
)
3430 if (IRIX_COMPAT (abfd
) == ict_none
)
3432 /* For a normal mips executable the permissions for the PT_DYNAMIC
3433 segment are read, write and execute. We do that here since
3434 the code in elf.c sets only the read permission. This matters
3435 sometimes for the dynamic linker. */
3436 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
3438 m
->p_flags
= PF_R
| PF_W
| PF_X
;
3439 m
->p_flags_valid
= 1;
3443 && m
->count
== 1 && strcmp (m
->sections
[0]->name
, ".dynamic") == 0)
3445 static const char *sec_names
[] =
3446 { ".dynamic", ".dynstr", ".dynsym", ".hash" };
3449 struct elf_segment_map
*n
;
3453 for (i
= 0; i
< sizeof sec_names
/ sizeof sec_names
[0]; i
++)
3455 s
= bfd_get_section_by_name (abfd
, sec_names
[i
]);
3456 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3462 sz
= s
->_cooked_size
;
3465 if (high
< s
->vma
+ sz
)
3471 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3472 if ((s
->flags
& SEC_LOAD
) != 0
3475 + (s
->_cooked_size
!=
3476 0 ? s
->_cooked_size
: s
->_raw_size
)) <= high
))
3479 n
= ((struct elf_segment_map
*)
3480 bfd_zalloc (abfd
, sizeof *n
+ (c
- 1) * sizeof (asection
*)));
3487 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3489 if ((s
->flags
& SEC_LOAD
) != 0
3492 + (s
->_cooked_size
!= 0 ?
3493 s
->_cooked_size
: s
->_raw_size
)) <= high
))
3507 /* The structure of the runtime procedure descriptor created by the
3508 loader for use by the static exception system. */
3510 typedef struct runtime_pdr
{
3511 bfd_vma adr
; /* memory address of start of procedure */
3512 long regmask
; /* save register mask */
3513 long regoffset
; /* save register offset */
3514 long fregmask
; /* save floating point register mask */
3515 long fregoffset
; /* save floating point register offset */
3516 long frameoffset
; /* frame size */
3517 short framereg
; /* frame pointer register */
3518 short pcreg
; /* offset or reg of return pc */
3519 long irpss
; /* index into the runtime string table */
3521 struct exception_info
*exception_info
;/* pointer to exception array */
3523 #define cbRPDR sizeof(RPDR)
3524 #define rpdNil ((pRPDR) 0)
3526 /* Swap RPDR (runtime procedure table entry) for output. */
3528 static void ecoff_swap_rpdr_out
3529 PARAMS ((bfd
*, const RPDR
*, struct rpdr_ext
*));
3532 ecoff_swap_rpdr_out (abfd
, in
, ex
)
3535 struct rpdr_ext
*ex
;
3537 /* ecoff_put_off was defined in ecoffswap.h. */
3538 ecoff_put_off (abfd
, in
->adr
, (bfd_byte
*) ex
->p_adr
);
3539 bfd_h_put_32 (abfd
, in
->regmask
, (bfd_byte
*) ex
->p_regmask
);
3540 bfd_h_put_32 (abfd
, in
->regoffset
, (bfd_byte
*) ex
->p_regoffset
);
3541 bfd_h_put_32 (abfd
, in
->fregmask
, (bfd_byte
*) ex
->p_fregmask
);
3542 bfd_h_put_32 (abfd
, in
->fregoffset
, (bfd_byte
*) ex
->p_fregoffset
);
3543 bfd_h_put_32 (abfd
, in
->frameoffset
, (bfd_byte
*) ex
->p_frameoffset
);
3545 bfd_h_put_16 (abfd
, in
->framereg
, (bfd_byte
*) ex
->p_framereg
);
3546 bfd_h_put_16 (abfd
, in
->pcreg
, (bfd_byte
*) ex
->p_pcreg
);
3548 bfd_h_put_32 (abfd
, in
->irpss
, (bfd_byte
*) ex
->p_irpss
);
3550 ecoff_put_off (abfd
, in
->exception_info
, (bfd_byte
*) ex
->p_exception_info
);
3554 /* Read ECOFF debugging information from a .mdebug section into a
3555 ecoff_debug_info structure. */
3558 _bfd_mips_elf_read_ecoff_info (abfd
, section
, debug
)
3561 struct ecoff_debug_info
*debug
;
3564 const struct ecoff_debug_swap
*swap
;
3565 char *ext_hdr
= NULL
;
3567 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
3568 memset (debug
, 0, sizeof(*debug
));
3570 ext_hdr
= (char *) bfd_malloc ((size_t) swap
->external_hdr_size
);
3571 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
3574 if (bfd_get_section_contents (abfd
, section
, ext_hdr
, (file_ptr
) 0,
3575 swap
->external_hdr_size
)
3579 symhdr
= &debug
->symbolic_header
;
3580 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
3582 /* The symbolic header contains absolute file offsets and sizes to
3584 #define READ(ptr, offset, count, size, type) \
3585 if (symhdr->count == 0) \
3586 debug->ptr = NULL; \
3589 debug->ptr = (type) bfd_malloc ((size_t) (size * symhdr->count)); \
3590 if (debug->ptr == NULL) \
3591 goto error_return; \
3592 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
3593 || (bfd_read (debug->ptr, size, symhdr->count, \
3594 abfd) != size * symhdr->count)) \
3595 goto error_return; \
3598 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
3599 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, PTR
);
3600 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, PTR
);
3601 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, PTR
);
3602 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, PTR
);
3603 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
3605 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
3606 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
3607 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, PTR
);
3608 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, PTR
);
3609 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, PTR
);
3613 debug
->adjust
= NULL
;
3618 if (ext_hdr
!= NULL
)
3620 if (debug
->line
!= NULL
)
3622 if (debug
->external_dnr
!= NULL
)
3623 free (debug
->external_dnr
);
3624 if (debug
->external_pdr
!= NULL
)
3625 free (debug
->external_pdr
);
3626 if (debug
->external_sym
!= NULL
)
3627 free (debug
->external_sym
);
3628 if (debug
->external_opt
!= NULL
)
3629 free (debug
->external_opt
);
3630 if (debug
->external_aux
!= NULL
)
3631 free (debug
->external_aux
);
3632 if (debug
->ss
!= NULL
)
3634 if (debug
->ssext
!= NULL
)
3635 free (debug
->ssext
);
3636 if (debug
->external_fdr
!= NULL
)
3637 free (debug
->external_fdr
);
3638 if (debug
->external_rfd
!= NULL
)
3639 free (debug
->external_rfd
);
3640 if (debug
->external_ext
!= NULL
)
3641 free (debug
->external_ext
);
3645 /* MIPS ELF local labels start with '$', not 'L'. */
3649 mips_elf_is_local_label_name (abfd
, name
)
3656 /* On Irix 6, the labels go back to starting with '.', so we accept
3657 the generic ELF local label syntax as well. */
3658 return _bfd_elf_is_local_label_name (abfd
, name
);
3661 /* MIPS ELF uses a special find_nearest_line routine in order the
3662 handle the ECOFF debugging information. */
3664 struct mips_elf_find_line
3666 struct ecoff_debug_info d
;
3667 struct ecoff_find_line i
;
3671 _bfd_mips_elf_find_nearest_line (abfd
, section
, symbols
, offset
, filename_ptr
,
3672 functionname_ptr
, line_ptr
)
3677 const char **filename_ptr
;
3678 const char **functionname_ptr
;
3679 unsigned int *line_ptr
;
3683 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
3684 filename_ptr
, functionname_ptr
,
3688 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
3689 filename_ptr
, functionname_ptr
,
3691 ABI_64_P (abfd
) ? 8 : 0))
3694 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
3698 struct mips_elf_find_line
*fi
;
3699 const struct ecoff_debug_swap
* const swap
=
3700 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
3702 /* If we are called during a link, mips_elf_final_link may have
3703 cleared the SEC_HAS_CONTENTS field. We force it back on here
3704 if appropriate (which it normally will be). */
3705 origflags
= msec
->flags
;
3706 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
3707 msec
->flags
|= SEC_HAS_CONTENTS
;
3709 fi
= elf_tdata (abfd
)->find_line_info
;
3712 bfd_size_type external_fdr_size
;
3715 struct fdr
*fdr_ptr
;
3717 fi
= ((struct mips_elf_find_line
*)
3718 bfd_zalloc (abfd
, sizeof (struct mips_elf_find_line
)));
3721 msec
->flags
= origflags
;
3725 if (! _bfd_mips_elf_read_ecoff_info (abfd
, msec
, &fi
->d
))
3727 msec
->flags
= origflags
;
3731 /* Swap in the FDR information. */
3732 fi
->d
.fdr
= ((struct fdr
*)
3734 (fi
->d
.symbolic_header
.ifdMax
*
3735 sizeof (struct fdr
))));
3736 if (fi
->d
.fdr
== NULL
)
3738 msec
->flags
= origflags
;
3741 external_fdr_size
= swap
->external_fdr_size
;
3742 fdr_ptr
= fi
->d
.fdr
;
3743 fraw_src
= (char *) fi
->d
.external_fdr
;
3744 fraw_end
= (fraw_src
3745 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
3746 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
3747 (*swap
->swap_fdr_in
) (abfd
, (PTR
) fraw_src
, fdr_ptr
);
3749 elf_tdata (abfd
)->find_line_info
= fi
;
3751 /* Note that we don't bother to ever free this information.
3752 find_nearest_line is either called all the time, as in
3753 objdump -l, so the information should be saved, or it is
3754 rarely called, as in ld error messages, so the memory
3755 wasted is unimportant. Still, it would probably be a
3756 good idea for free_cached_info to throw it away. */
3759 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
3760 &fi
->i
, filename_ptr
, functionname_ptr
,
3763 msec
->flags
= origflags
;
3767 msec
->flags
= origflags
;
3770 /* Fall back on the generic ELF find_nearest_line routine. */
3772 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
3773 filename_ptr
, functionname_ptr
,
3777 /* The mips16 compiler uses a couple of special sections to handle
3778 floating point arguments.
3780 Section names that look like .mips16.fn.FNNAME contain stubs that
3781 copy floating point arguments from the fp regs to the gp regs and
3782 then jump to FNNAME. If any 32 bit function calls FNNAME, the
3783 call should be redirected to the stub instead. If no 32 bit
3784 function calls FNNAME, the stub should be discarded. We need to
3785 consider any reference to the function, not just a call, because
3786 if the address of the function is taken we will need the stub,
3787 since the address might be passed to a 32 bit function.
3789 Section names that look like .mips16.call.FNNAME contain stubs
3790 that copy floating point arguments from the gp regs to the fp
3791 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
3792 then any 16 bit function that calls FNNAME should be redirected
3793 to the stub instead. If FNNAME is not a 32 bit function, the
3794 stub should be discarded.
3796 .mips16.call.fp.FNNAME sections are similar, but contain stubs
3797 which call FNNAME and then copy the return value from the fp regs
3798 to the gp regs. These stubs store the return value in $18 while
3799 calling FNNAME; any function which might call one of these stubs
3800 must arrange to save $18 around the call. (This case is not
3801 needed for 32 bit functions that call 16 bit functions, because
3802 16 bit functions always return floating point values in both
3805 Note that in all cases FNNAME might be defined statically.
3806 Therefore, FNNAME is not used literally. Instead, the relocation
3807 information will indicate which symbol the section is for.
3809 We record any stubs that we find in the symbol table. */
3811 #define FN_STUB ".mips16.fn."
3812 #define CALL_STUB ".mips16.call."
3813 #define CALL_FP_STUB ".mips16.call.fp."
3815 /* MIPS ELF linker hash table. */
3817 struct mips_elf_link_hash_table
3819 struct elf_link_hash_table root
;
3821 /* We no longer use this. */
3822 /* String section indices for the dynamic section symbols. */
3823 bfd_size_type dynsym_sec_strindex
[SIZEOF_MIPS_DYNSYM_SECNAMES
];
3825 /* The number of .rtproc entries. */
3826 bfd_size_type procedure_count
;
3827 /* The size of the .compact_rel section (if SGI_COMPAT). */
3828 bfd_size_type compact_rel_size
;
3829 /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic
3830 entry is set to the address of __rld_obj_head as in Irix 5. */
3831 boolean use_rld_obj_head
;
3832 /* This is the value of the __rld_map or __rld_obj_head symbol. */
3834 /* This is set if we see any mips16 stub sections. */
3835 boolean mips16_stubs_seen
;
3838 /* Look up an entry in a MIPS ELF linker hash table. */
3840 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
3841 ((struct mips_elf_link_hash_entry *) \
3842 elf_link_hash_lookup (&(table)->root, (string), (create), \
3845 /* Traverse a MIPS ELF linker hash table. */
3847 #define mips_elf_link_hash_traverse(table, func, info) \
3848 (elf_link_hash_traverse \
3850 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
3853 /* Get the MIPS ELF linker hash table from a link_info structure. */
3855 #define mips_elf_hash_table(p) \
3856 ((struct mips_elf_link_hash_table *) ((p)->hash))
3858 static boolean mips_elf_output_extsym
3859 PARAMS ((struct mips_elf_link_hash_entry
*, PTR
));
3861 /* Create an entry in a MIPS ELF linker hash table. */
3863 static struct bfd_hash_entry
*
3864 mips_elf_link_hash_newfunc (entry
, table
, string
)
3865 struct bfd_hash_entry
*entry
;
3866 struct bfd_hash_table
*table
;
3869 struct mips_elf_link_hash_entry
*ret
=
3870 (struct mips_elf_link_hash_entry
*) entry
;
3872 /* Allocate the structure if it has not already been allocated by a
3874 if (ret
== (struct mips_elf_link_hash_entry
*) NULL
)
3875 ret
= ((struct mips_elf_link_hash_entry
*)
3876 bfd_hash_allocate (table
,
3877 sizeof (struct mips_elf_link_hash_entry
)));
3878 if (ret
== (struct mips_elf_link_hash_entry
*) NULL
)
3879 return (struct bfd_hash_entry
*) ret
;
3881 /* Call the allocation method of the superclass. */
3882 ret
= ((struct mips_elf_link_hash_entry
*)
3883 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
3885 if (ret
!= (struct mips_elf_link_hash_entry
*) NULL
)
3887 /* Set local fields. */
3888 memset (&ret
->esym
, 0, sizeof (EXTR
));
3889 /* We use -2 as a marker to indicate that the information has
3890 not been set. -1 means there is no associated ifd. */
3892 ret
->possibly_dynamic_relocs
= 0;
3893 ret
->min_dyn_reloc_index
= 0;
3894 ret
->fn_stub
= NULL
;
3895 ret
->need_fn_stub
= false;
3896 ret
->call_stub
= NULL
;
3897 ret
->call_fp_stub
= NULL
;
3900 return (struct bfd_hash_entry
*) ret
;
3904 _bfd_mips_elf_hide_symbol(info
, h
)
3905 struct bfd_link_info
*info
;
3906 struct mips_elf_link_hash_entry
*h
;
3910 struct mips_got_info
*g
;
3911 dynobj
= elf_hash_table (info
)->dynobj
;
3912 got
= bfd_get_section_by_name (dynobj
, ".got");
3913 g
= (struct mips_got_info
*) elf_section_data (got
)->tdata
;
3915 h
->root
.elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
3916 h
->root
.plt
.offset
= (bfd_vma
) -1;
3917 h
->root
.dynindx
= -1;
3919 /* FIXME: Do we allocate too much GOT space here? */
3921 got
->_raw_size
+= MIPS_ELF_GOT_SIZE (dynobj
);
3924 /* Create a MIPS ELF linker hash table. */
3926 struct bfd_link_hash_table
*
3927 _bfd_mips_elf_link_hash_table_create (abfd
)
3930 struct mips_elf_link_hash_table
*ret
;
3932 ret
= ((struct mips_elf_link_hash_table
*)
3933 bfd_alloc (abfd
, sizeof (struct mips_elf_link_hash_table
)));
3934 if (ret
== (struct mips_elf_link_hash_table
*) NULL
)
3937 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
3938 mips_elf_link_hash_newfunc
))
3940 bfd_release (abfd
, ret
);
3945 /* We no longer use this. */
3946 for (i
= 0; i
< SIZEOF_MIPS_DYNSYM_SECNAMES
; i
++)
3947 ret
->dynsym_sec_strindex
[i
] = (bfd_size_type
) -1;
3949 ret
->procedure_count
= 0;
3950 ret
->compact_rel_size
= 0;
3951 ret
->use_rld_obj_head
= false;
3953 ret
->mips16_stubs_seen
= false;
3955 return &ret
->root
.root
;
3958 /* Hook called by the linker routine which adds symbols from an object
3959 file. We must handle the special MIPS section numbers here. */
3963 _bfd_mips_elf_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
, secp
, valp
)
3965 struct bfd_link_info
*info
;
3966 const Elf_Internal_Sym
*sym
;
3968 flagword
*flagsp ATTRIBUTE_UNUSED
;
3972 if (SGI_COMPAT (abfd
)
3973 && (abfd
->flags
& DYNAMIC
) != 0
3974 && strcmp (*namep
, "_rld_new_interface") == 0)
3976 /* Skip Irix 5 rld entry name. */
3981 switch (sym
->st_shndx
)
3984 /* Common symbols less than the GP size are automatically
3985 treated as SHN_MIPS_SCOMMON symbols. */
3986 if (sym
->st_size
> elf_gp_size (abfd
)
3987 || IRIX_COMPAT (abfd
) == ict_irix6
)
3990 case SHN_MIPS_SCOMMON
:
3991 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
3992 (*secp
)->flags
|= SEC_IS_COMMON
;
3993 *valp
= sym
->st_size
;
3997 /* This section is used in a shared object. */
3998 if (elf_tdata (abfd
)->elf_text_section
== NULL
)
4000 asymbol
*elf_text_symbol
;
4001 asection
*elf_text_section
;
4003 elf_text_section
= bfd_zalloc (abfd
, sizeof (asection
));
4004 if (elf_text_section
== NULL
)
4007 elf_text_symbol
= bfd_zalloc (abfd
, sizeof (asymbol
));
4008 if (elf_text_symbol
== NULL
)
4011 /* Initialize the section. */
4013 elf_tdata (abfd
)->elf_text_section
= elf_text_section
;
4014 elf_tdata (abfd
)->elf_text_symbol
= elf_text_symbol
;
4016 elf_text_section
->symbol
= elf_text_symbol
;
4017 elf_text_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_text_symbol
;
4019 elf_text_section
->name
= ".text";
4020 elf_text_section
->flags
= SEC_NO_FLAGS
;
4021 elf_text_section
->output_section
= NULL
;
4022 elf_text_section
->owner
= abfd
;
4023 elf_text_symbol
->name
= ".text";
4024 elf_text_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
4025 elf_text_symbol
->section
= elf_text_section
;
4027 /* This code used to do *secp = bfd_und_section_ptr if
4028 info->shared. I don't know why, and that doesn't make sense,
4029 so I took it out. */
4030 *secp
= elf_tdata (abfd
)->elf_text_section
;
4033 case SHN_MIPS_ACOMMON
:
4034 /* Fall through. XXX Can we treat this as allocated data? */
4036 /* This section is used in a shared object. */
4037 if (elf_tdata (abfd
)->elf_data_section
== NULL
)
4039 asymbol
*elf_data_symbol
;
4040 asection
*elf_data_section
;
4042 elf_data_section
= bfd_zalloc (abfd
, sizeof (asection
));
4043 if (elf_data_section
== NULL
)
4046 elf_data_symbol
= bfd_zalloc (abfd
, sizeof (asymbol
));
4047 if (elf_data_symbol
== NULL
)
4050 /* Initialize the section. */
4052 elf_tdata (abfd
)->elf_data_section
= elf_data_section
;
4053 elf_tdata (abfd
)->elf_data_symbol
= elf_data_symbol
;
4055 elf_data_section
->symbol
= elf_data_symbol
;
4056 elf_data_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_data_symbol
;
4058 elf_data_section
->name
= ".data";
4059 elf_data_section
->flags
= SEC_NO_FLAGS
;
4060 elf_data_section
->output_section
= NULL
;
4061 elf_data_section
->owner
= abfd
;
4062 elf_data_symbol
->name
= ".data";
4063 elf_data_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
4064 elf_data_symbol
->section
= elf_data_section
;
4066 /* This code used to do *secp = bfd_und_section_ptr if
4067 info->shared. I don't know why, and that doesn't make sense,
4068 so I took it out. */
4069 *secp
= elf_tdata (abfd
)->elf_data_section
;
4072 case SHN_MIPS_SUNDEFINED
:
4073 *secp
= bfd_und_section_ptr
;
4077 if (SGI_COMPAT (abfd
)
4079 && info
->hash
->creator
== abfd
->xvec
4080 && strcmp (*namep
, "__rld_obj_head") == 0)
4082 struct elf_link_hash_entry
*h
;
4084 /* Mark __rld_obj_head as dynamic. */
4086 if (! (_bfd_generic_link_add_one_symbol
4087 (info
, abfd
, *namep
, BSF_GLOBAL
, *secp
,
4088 (bfd_vma
) *valp
, (const char *) NULL
, false,
4089 get_elf_backend_data (abfd
)->collect
,
4090 (struct bfd_link_hash_entry
**) &h
)))
4092 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
4093 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4094 h
->type
= STT_OBJECT
;
4096 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
4099 mips_elf_hash_table (info
)->use_rld_obj_head
= true;
4102 /* If this is a mips16 text symbol, add 1 to the value to make it
4103 odd. This will cause something like .word SYM to come up with
4104 the right value when it is loaded into the PC. */
4105 if (sym
->st_other
== STO_MIPS16
)
4111 /* Structure used to pass information to mips_elf_output_extsym. */
4116 struct bfd_link_info
*info
;
4117 struct ecoff_debug_info
*debug
;
4118 const struct ecoff_debug_swap
*swap
;
4122 /* This routine is used to write out ECOFF debugging external symbol
4123 information. It is called via mips_elf_link_hash_traverse. The
4124 ECOFF external symbol information must match the ELF external
4125 symbol information. Unfortunately, at this point we don't know
4126 whether a symbol is required by reloc information, so the two
4127 tables may wind up being different. We must sort out the external
4128 symbol information before we can set the final size of the .mdebug
4129 section, and we must set the size of the .mdebug section before we
4130 can relocate any sections, and we can't know which symbols are
4131 required by relocation until we relocate the sections.
4132 Fortunately, it is relatively unlikely that any symbol will be
4133 stripped but required by a reloc. In particular, it can not happen
4134 when generating a final executable. */
4137 mips_elf_output_extsym (h
, data
)
4138 struct mips_elf_link_hash_entry
*h
;
4141 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
4143 asection
*sec
, *output_section
;
4145 if (h
->root
.indx
== -2)
4147 else if (((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
4148 || (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
4149 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
4150 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
4152 else if (einfo
->info
->strip
== strip_all
4153 || (einfo
->info
->strip
== strip_some
4154 && bfd_hash_lookup (einfo
->info
->keep_hash
,
4155 h
->root
.root
.root
.string
,
4156 false, false) == NULL
))
4164 if (h
->esym
.ifd
== -2)
4167 h
->esym
.cobol_main
= 0;
4168 h
->esym
.weakext
= 0;
4169 h
->esym
.reserved
= 0;
4170 h
->esym
.ifd
= ifdNil
;
4171 h
->esym
.asym
.value
= 0;
4172 h
->esym
.asym
.st
= stGlobal
;
4174 if (h
->root
.root
.type
== bfd_link_hash_undefined
4175 || h
->root
.root
.type
== bfd_link_hash_undefweak
)
4179 /* Use undefined class. Also, set class and type for some
4181 name
= h
->root
.root
.root
.string
;
4182 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
4183 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
4185 h
->esym
.asym
.sc
= scData
;
4186 h
->esym
.asym
.st
= stLabel
;
4187 h
->esym
.asym
.value
= 0;
4189 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
4191 h
->esym
.asym
.sc
= scAbs
;
4192 h
->esym
.asym
.st
= stLabel
;
4193 h
->esym
.asym
.value
=
4194 mips_elf_hash_table (einfo
->info
)->procedure_count
;
4196 else if (strcmp (name
, "_gp_disp") == 0)
4198 h
->esym
.asym
.sc
= scAbs
;
4199 h
->esym
.asym
.st
= stLabel
;
4200 h
->esym
.asym
.value
= elf_gp (einfo
->abfd
);
4203 h
->esym
.asym
.sc
= scUndefined
;
4205 else if (h
->root
.root
.type
!= bfd_link_hash_defined
4206 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
4207 h
->esym
.asym
.sc
= scAbs
;
4212 sec
= h
->root
.root
.u
.def
.section
;
4213 output_section
= sec
->output_section
;
4215 /* When making a shared library and symbol h is the one from
4216 the another shared library, OUTPUT_SECTION may be null. */
4217 if (output_section
== NULL
)
4218 h
->esym
.asym
.sc
= scUndefined
;
4221 name
= bfd_section_name (output_section
->owner
, output_section
);
4223 if (strcmp (name
, ".text") == 0)
4224 h
->esym
.asym
.sc
= scText
;
4225 else if (strcmp (name
, ".data") == 0)
4226 h
->esym
.asym
.sc
= scData
;
4227 else if (strcmp (name
, ".sdata") == 0)
4228 h
->esym
.asym
.sc
= scSData
;
4229 else if (strcmp (name
, ".rodata") == 0
4230 || strcmp (name
, ".rdata") == 0)
4231 h
->esym
.asym
.sc
= scRData
;
4232 else if (strcmp (name
, ".bss") == 0)
4233 h
->esym
.asym
.sc
= scBss
;
4234 else if (strcmp (name
, ".sbss") == 0)
4235 h
->esym
.asym
.sc
= scSBss
;
4236 else if (strcmp (name
, ".init") == 0)
4237 h
->esym
.asym
.sc
= scInit
;
4238 else if (strcmp (name
, ".fini") == 0)
4239 h
->esym
.asym
.sc
= scFini
;
4241 h
->esym
.asym
.sc
= scAbs
;
4245 h
->esym
.asym
.reserved
= 0;
4246 h
->esym
.asym
.index
= indexNil
;
4249 if (h
->root
.root
.type
== bfd_link_hash_common
)
4250 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
4251 else if (h
->root
.root
.type
== bfd_link_hash_defined
4252 || h
->root
.root
.type
== bfd_link_hash_defweak
)
4254 if (h
->esym
.asym
.sc
== scCommon
)
4255 h
->esym
.asym
.sc
= scBss
;
4256 else if (h
->esym
.asym
.sc
== scSCommon
)
4257 h
->esym
.asym
.sc
= scSBss
;
4259 sec
= h
->root
.root
.u
.def
.section
;
4260 output_section
= sec
->output_section
;
4261 if (output_section
!= NULL
)
4262 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
4263 + sec
->output_offset
4264 + output_section
->vma
);
4266 h
->esym
.asym
.value
= 0;
4268 else if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
4270 /* Set type and value for a symbol with a function stub. */
4271 h
->esym
.asym
.st
= stProc
;
4272 sec
= h
->root
.root
.u
.def
.section
;
4274 h
->esym
.asym
.value
= 0;
4277 output_section
= sec
->output_section
;
4278 if (output_section
!= NULL
)
4279 h
->esym
.asym
.value
= (h
->root
.plt
.offset
4280 + sec
->output_offset
4281 + output_section
->vma
);
4283 h
->esym
.asym
.value
= 0;
4290 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
4291 h
->root
.root
.root
.string
,
4294 einfo
->failed
= true;
4301 /* Create a runtime procedure table from the .mdebug section. */
4304 mips_elf_create_procedure_table (handle
, abfd
, info
, s
, debug
)
4307 struct bfd_link_info
*info
;
4309 struct ecoff_debug_info
*debug
;
4311 const struct ecoff_debug_swap
*swap
;
4312 HDRR
*hdr
= &debug
->symbolic_header
;
4314 struct rpdr_ext
*erp
;
4316 struct pdr_ext
*epdr
;
4317 struct sym_ext
*esym
;
4320 unsigned long size
, count
;
4321 unsigned long sindex
;
4325 const char *no_name_func
= _("static procedure (no name)");
4333 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
4335 sindex
= strlen (no_name_func
) + 1;
4336 count
= hdr
->ipdMax
;
4339 size
= swap
->external_pdr_size
;
4341 epdr
= (struct pdr_ext
*) bfd_malloc (size
* count
);
4345 if (! _bfd_ecoff_get_accumulated_pdr (handle
, (PTR
) epdr
))
4348 size
= sizeof (RPDR
);
4349 rp
= rpdr
= (RPDR
*) bfd_malloc (size
* count
);
4353 sv
= (char **) bfd_malloc (sizeof (char *) * count
);
4357 count
= hdr
->isymMax
;
4358 size
= swap
->external_sym_size
;
4359 esym
= (struct sym_ext
*) bfd_malloc (size
* count
);
4363 if (! _bfd_ecoff_get_accumulated_sym (handle
, (PTR
) esym
))
4366 count
= hdr
->issMax
;
4367 ss
= (char *) bfd_malloc (count
);
4370 if (! _bfd_ecoff_get_accumulated_ss (handle
, (PTR
) ss
))
4373 count
= hdr
->ipdMax
;
4374 for (i
= 0; i
< count
; i
++, rp
++)
4376 (*swap
->swap_pdr_in
) (abfd
, (PTR
) (epdr
+ i
), &pdr
);
4377 (*swap
->swap_sym_in
) (abfd
, (PTR
) &esym
[pdr
.isym
], &sym
);
4378 rp
->adr
= sym
.value
;
4379 rp
->regmask
= pdr
.regmask
;
4380 rp
->regoffset
= pdr
.regoffset
;
4381 rp
->fregmask
= pdr
.fregmask
;
4382 rp
->fregoffset
= pdr
.fregoffset
;
4383 rp
->frameoffset
= pdr
.frameoffset
;
4384 rp
->framereg
= pdr
.framereg
;
4385 rp
->pcreg
= pdr
.pcreg
;
4387 sv
[i
] = ss
+ sym
.iss
;
4388 sindex
+= strlen (sv
[i
]) + 1;
4392 size
= sizeof (struct rpdr_ext
) * (count
+ 2) + sindex
;
4393 size
= BFD_ALIGN (size
, 16);
4394 rtproc
= (PTR
) bfd_alloc (abfd
, size
);
4397 mips_elf_hash_table (info
)->procedure_count
= 0;
4401 mips_elf_hash_table (info
)->procedure_count
= count
+ 2;
4403 erp
= (struct rpdr_ext
*) rtproc
;
4404 memset (erp
, 0, sizeof (struct rpdr_ext
));
4406 str
= (char *) rtproc
+ sizeof (struct rpdr_ext
) * (count
+ 2);
4407 strcpy (str
, no_name_func
);
4408 str
+= strlen (no_name_func
) + 1;
4409 for (i
= 0; i
< count
; i
++)
4411 ecoff_swap_rpdr_out (abfd
, rpdr
+ i
, erp
+ i
);
4412 strcpy (str
, sv
[i
]);
4413 str
+= strlen (sv
[i
]) + 1;
4415 ecoff_put_off (abfd
, (bfd_vma
) -1, (bfd_byte
*) (erp
+ count
)->p_adr
);
4417 /* Set the size and contents of .rtproc section. */
4418 s
->_raw_size
= size
;
4419 s
->contents
= (bfd_byte
*) rtproc
;
4421 /* Skip this section later on (I don't think this currently
4422 matters, but someday it might). */
4423 s
->link_order_head
= (struct bfd_link_order
*) NULL
;
4452 /* A comparison routine used to sort .gptab entries. */
4455 gptab_compare (p1
, p2
)
4459 const Elf32_gptab
*a1
= (const Elf32_gptab
*) p1
;
4460 const Elf32_gptab
*a2
= (const Elf32_gptab
*) p2
;
4462 return a1
->gt_entry
.gt_g_value
- a2
->gt_entry
.gt_g_value
;
4465 /* We need to use a special link routine to handle the .reginfo and
4466 the .mdebug sections. We need to merge all instances of these
4467 sections together, not write them all out sequentially. */
4470 _bfd_mips_elf_final_link (abfd
, info
)
4472 struct bfd_link_info
*info
;
4476 struct bfd_link_order
*p
;
4477 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
4478 asection
*rtproc_sec
;
4479 Elf32_RegInfo reginfo
;
4480 struct ecoff_debug_info debug
;
4481 const struct ecoff_debug_swap
*swap
4482 = get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
4483 HDRR
*symhdr
= &debug
.symbolic_header
;
4484 PTR mdebug_handle
= NULL
;
4489 static const char * const name
[] =
4490 { ".text", ".init", ".fini", ".data",
4491 ".rodata", ".sdata", ".sbss", ".bss" };
4492 static const int sc
[] = { scText
, scInit
, scFini
, scData
,
4493 scRData
, scSData
, scSBss
, scBss
};
4495 /* If all the things we linked together were PIC, but we're
4496 producing an executable (rather than a shared object), then the
4497 resulting file is CPIC (i.e., it calls PIC code.) */
4499 && !info
->relocateable
4500 && elf_elfheader (abfd
)->e_flags
& EF_MIPS_PIC
)
4502 elf_elfheader (abfd
)->e_flags
&= ~EF_MIPS_PIC
;
4503 elf_elfheader (abfd
)->e_flags
|= EF_MIPS_CPIC
;
4506 /* We'd carefully arranged the dynamic symbol indices, and then the
4507 generic size_dynamic_sections renumbered them out from under us.
4508 Rather than trying somehow to prevent the renumbering, just do
4510 if (elf_hash_table (info
)->dynamic_sections_created
)
4514 struct mips_got_info
*g
;
4516 /* When we resort, we must tell mips_elf_sort_hash_table what
4517 the lowest index it may use is. That's the number of section
4518 symbols we're going to add. The generic ELF linker only
4519 adds these symbols when building a shared object. Note that
4520 we count the sections after (possibly) removing the .options
4522 if (!mips_elf_sort_hash_table (info
, (info
->shared
4523 ? bfd_count_sections (abfd
) + 1
4527 /* Make sure we didn't grow the global .got region. */
4528 dynobj
= elf_hash_table (info
)->dynobj
;
4529 got
= bfd_get_section_by_name (dynobj
, ".got");
4530 g
= (struct mips_got_info
*) elf_section_data (got
)->tdata
;
4532 if (g
->global_gotsym
!= NULL
)
4533 BFD_ASSERT ((elf_hash_table (info
)->dynsymcount
4534 - g
->global_gotsym
->dynindx
)
4535 <= g
->global_gotno
);
4538 /* On IRIX5, we omit the .options section. On IRIX6, however, we
4539 include it, even though we don't process it quite right. (Some
4540 entries are supposed to be merged.) Empirically, we seem to be
4541 better off including it then not. */
4542 if (IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
4543 for (secpp
= &abfd
->sections
; *secpp
!= NULL
; secpp
= &(*secpp
)->next
)
4545 if (strcmp ((*secpp
)->name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
4547 for (p
= (*secpp
)->link_order_head
; p
!= NULL
; p
= p
->next
)
4548 if (p
->type
== bfd_indirect_link_order
)
4549 p
->u
.indirect
.section
->flags
&=~ SEC_HAS_CONTENTS
;
4550 (*secpp
)->link_order_head
= NULL
;
4551 *secpp
= (*secpp
)->next
;
4552 --abfd
->section_count
;
4558 /* Get a value for the GP register. */
4559 if (elf_gp (abfd
) == 0)
4561 struct bfd_link_hash_entry
*h
;
4563 h
= bfd_link_hash_lookup (info
->hash
, "_gp", false, false, true);
4564 if (h
!= (struct bfd_link_hash_entry
*) NULL
4565 && h
->type
== bfd_link_hash_defined
)
4566 elf_gp (abfd
) = (h
->u
.def
.value
4567 + h
->u
.def
.section
->output_section
->vma
4568 + h
->u
.def
.section
->output_offset
);
4569 else if (info
->relocateable
)
4573 /* Find the GP-relative section with the lowest offset. */
4575 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
4577 && (elf_section_data (o
)->this_hdr
.sh_flags
& SHF_MIPS_GPREL
))
4580 /* And calculate GP relative to that. */
4581 elf_gp (abfd
) = lo
+ ELF_MIPS_GP_OFFSET (abfd
);
4585 /* If the relocate_section function needs to do a reloc
4586 involving the GP value, it should make a reloc_dangerous
4587 callback to warn that GP is not defined. */
4591 /* Go through the sections and collect the .reginfo and .mdebug
4595 gptab_data_sec
= NULL
;
4596 gptab_bss_sec
= NULL
;
4597 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
4599 if (strcmp (o
->name
, ".reginfo") == 0)
4601 memset (®info
, 0, sizeof reginfo
);
4603 /* We have found the .reginfo section in the output file.
4604 Look through all the link_orders comprising it and merge
4605 the information together. */
4606 for (p
= o
->link_order_head
;
4607 p
!= (struct bfd_link_order
*) NULL
;
4610 asection
*input_section
;
4612 Elf32_External_RegInfo ext
;
4615 if (p
->type
!= bfd_indirect_link_order
)
4617 if (p
->type
== bfd_fill_link_order
)
4622 input_section
= p
->u
.indirect
.section
;
4623 input_bfd
= input_section
->owner
;
4625 /* The linker emulation code has probably clobbered the
4626 size to be zero bytes. */
4627 if (input_section
->_raw_size
== 0)
4628 input_section
->_raw_size
= sizeof (Elf32_External_RegInfo
);
4630 if (! bfd_get_section_contents (input_bfd
, input_section
,
4636 bfd_mips_elf32_swap_reginfo_in (input_bfd
, &ext
, &sub
);
4638 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
4639 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
4640 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
4641 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
4642 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
4644 /* ri_gp_value is set by the function
4645 mips_elf32_section_processing when the section is
4646 finally written out. */
4648 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4649 elf_link_input_bfd ignores this section. */
4650 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
4653 /* Size has been set in mips_elf_always_size_sections */
4654 BFD_ASSERT(o
->_raw_size
== sizeof (Elf32_External_RegInfo
));
4656 /* Skip this section later on (I don't think this currently
4657 matters, but someday it might). */
4658 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
4663 if (strcmp (o
->name
, ".mdebug") == 0)
4665 struct extsym_info einfo
;
4667 /* We have found the .mdebug section in the output file.
4668 Look through all the link_orders comprising it and merge
4669 the information together. */
4670 symhdr
->magic
= swap
->sym_magic
;
4671 /* FIXME: What should the version stamp be? */
4673 symhdr
->ilineMax
= 0;
4677 symhdr
->isymMax
= 0;
4678 symhdr
->ioptMax
= 0;
4679 symhdr
->iauxMax
= 0;
4681 symhdr
->issExtMax
= 0;
4684 symhdr
->iextMax
= 0;
4686 /* We accumulate the debugging information itself in the
4687 debug_info structure. */
4689 debug
.external_dnr
= NULL
;
4690 debug
.external_pdr
= NULL
;
4691 debug
.external_sym
= NULL
;
4692 debug
.external_opt
= NULL
;
4693 debug
.external_aux
= NULL
;
4695 debug
.ssext
= debug
.ssext_end
= NULL
;
4696 debug
.external_fdr
= NULL
;
4697 debug
.external_rfd
= NULL
;
4698 debug
.external_ext
= debug
.external_ext_end
= NULL
;
4700 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
4701 if (mdebug_handle
== (PTR
) NULL
)
4705 esym
.cobol_main
= 0;
4709 esym
.asym
.iss
= issNil
;
4710 esym
.asym
.st
= stLocal
;
4711 esym
.asym
.reserved
= 0;
4712 esym
.asym
.index
= indexNil
;
4714 for (i
= 0; i
< 8; i
++)
4716 esym
.asym
.sc
= sc
[i
];
4717 s
= bfd_get_section_by_name (abfd
, name
[i
]);
4720 esym
.asym
.value
= s
->vma
;
4721 last
= s
->vma
+ s
->_raw_size
;
4724 esym
.asym
.value
= last
;
4725 if (!bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
4730 for (p
= o
->link_order_head
;
4731 p
!= (struct bfd_link_order
*) NULL
;
4734 asection
*input_section
;
4736 const struct ecoff_debug_swap
*input_swap
;
4737 struct ecoff_debug_info input_debug
;
4741 if (p
->type
!= bfd_indirect_link_order
)
4743 if (p
->type
== bfd_fill_link_order
)
4748 input_section
= p
->u
.indirect
.section
;
4749 input_bfd
= input_section
->owner
;
4751 if (bfd_get_flavour (input_bfd
) != bfd_target_elf_flavour
4752 || (get_elf_backend_data (input_bfd
)
4753 ->elf_backend_ecoff_debug_swap
) == NULL
)
4755 /* I don't know what a non MIPS ELF bfd would be
4756 doing with a .mdebug section, but I don't really
4757 want to deal with it. */
4761 input_swap
= (get_elf_backend_data (input_bfd
)
4762 ->elf_backend_ecoff_debug_swap
);
4764 BFD_ASSERT (p
->size
== input_section
->_raw_size
);
4766 /* The ECOFF linking code expects that we have already
4767 read in the debugging information and set up an
4768 ecoff_debug_info structure, so we do that now. */
4769 if (! _bfd_mips_elf_read_ecoff_info (input_bfd
, input_section
,
4773 if (! (bfd_ecoff_debug_accumulate
4774 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
4775 &input_debug
, input_swap
, info
)))
4778 /* Loop through the external symbols. For each one with
4779 interesting information, try to find the symbol in
4780 the linker global hash table and save the information
4781 for the output external symbols. */
4782 eraw_src
= input_debug
.external_ext
;
4783 eraw_end
= (eraw_src
4784 + (input_debug
.symbolic_header
.iextMax
4785 * input_swap
->external_ext_size
));
4787 eraw_src
< eraw_end
;
4788 eraw_src
+= input_swap
->external_ext_size
)
4792 struct mips_elf_link_hash_entry
*h
;
4794 (*input_swap
->swap_ext_in
) (input_bfd
, (PTR
) eraw_src
, &ext
);
4795 if (ext
.asym
.sc
== scNil
4796 || ext
.asym
.sc
== scUndefined
4797 || ext
.asym
.sc
== scSUndefined
)
4800 name
= input_debug
.ssext
+ ext
.asym
.iss
;
4801 h
= mips_elf_link_hash_lookup (mips_elf_hash_table (info
),
4802 name
, false, false, true);
4803 if (h
== NULL
|| h
->esym
.ifd
!= -2)
4809 < input_debug
.symbolic_header
.ifdMax
);
4810 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
4816 /* Free up the information we just read. */
4817 free (input_debug
.line
);
4818 free (input_debug
.external_dnr
);
4819 free (input_debug
.external_pdr
);
4820 free (input_debug
.external_sym
);
4821 free (input_debug
.external_opt
);
4822 free (input_debug
.external_aux
);
4823 free (input_debug
.ss
);
4824 free (input_debug
.ssext
);
4825 free (input_debug
.external_fdr
);
4826 free (input_debug
.external_rfd
);
4827 free (input_debug
.external_ext
);
4829 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4830 elf_link_input_bfd ignores this section. */
4831 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
4834 if (SGI_COMPAT (abfd
) && info
->shared
)
4836 /* Create .rtproc section. */
4837 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
4838 if (rtproc_sec
== NULL
)
4840 flagword flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
4841 | SEC_LINKER_CREATED
| SEC_READONLY
);
4843 rtproc_sec
= bfd_make_section (abfd
, ".rtproc");
4844 if (rtproc_sec
== NULL
4845 || ! bfd_set_section_flags (abfd
, rtproc_sec
, flags
)
4846 || ! bfd_set_section_alignment (abfd
, rtproc_sec
, 4))
4850 if (! mips_elf_create_procedure_table (mdebug_handle
, abfd
,
4851 info
, rtproc_sec
, &debug
))
4855 /* Build the external symbol information. */
4858 einfo
.debug
= &debug
;
4860 einfo
.failed
= false;
4861 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
4862 mips_elf_output_extsym
,
4867 /* Set the size of the .mdebug section. */
4868 o
->_raw_size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
4870 /* Skip this section later on (I don't think this currently
4871 matters, but someday it might). */
4872 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
4877 if (strncmp (o
->name
, ".gptab.", sizeof ".gptab." - 1) == 0)
4879 const char *subname
;
4882 Elf32_External_gptab
*ext_tab
;
4885 /* The .gptab.sdata and .gptab.sbss sections hold
4886 information describing how the small data area would
4887 change depending upon the -G switch. These sections
4888 not used in executables files. */
4889 if (! info
->relocateable
)
4893 for (p
= o
->link_order_head
;
4894 p
!= (struct bfd_link_order
*) NULL
;
4897 asection
*input_section
;
4899 if (p
->type
!= bfd_indirect_link_order
)
4901 if (p
->type
== bfd_fill_link_order
)
4906 input_section
= p
->u
.indirect
.section
;
4908 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4909 elf_link_input_bfd ignores this section. */
4910 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
4913 /* Skip this section later on (I don't think this
4914 currently matters, but someday it might). */
4915 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
4917 /* Really remove the section. */
4918 for (secpp
= &abfd
->sections
;
4920 secpp
= &(*secpp
)->next
)
4922 *secpp
= (*secpp
)->next
;
4923 --abfd
->section_count
;
4928 /* There is one gptab for initialized data, and one for
4929 uninitialized data. */
4930 if (strcmp (o
->name
, ".gptab.sdata") == 0)
4932 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
4936 (*_bfd_error_handler
)
4937 (_("%s: illegal section name `%s'"),
4938 bfd_get_filename (abfd
), o
->name
);
4939 bfd_set_error (bfd_error_nonrepresentable_section
);
4943 /* The linker script always combines .gptab.data and
4944 .gptab.sdata into .gptab.sdata, and likewise for
4945 .gptab.bss and .gptab.sbss. It is possible that there is
4946 no .sdata or .sbss section in the output file, in which
4947 case we must change the name of the output section. */
4948 subname
= o
->name
+ sizeof ".gptab" - 1;
4949 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
4951 if (o
== gptab_data_sec
)
4952 o
->name
= ".gptab.data";
4954 o
->name
= ".gptab.bss";
4955 subname
= o
->name
+ sizeof ".gptab" - 1;
4956 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
4959 /* Set up the first entry. */
4961 tab
= (Elf32_gptab
*) bfd_malloc (c
* sizeof (Elf32_gptab
));
4964 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
4965 tab
[0].gt_header
.gt_unused
= 0;
4967 /* Combine the input sections. */
4968 for (p
= o
->link_order_head
;
4969 p
!= (struct bfd_link_order
*) NULL
;
4972 asection
*input_section
;
4976 bfd_size_type gpentry
;
4978 if (p
->type
!= bfd_indirect_link_order
)
4980 if (p
->type
== bfd_fill_link_order
)
4985 input_section
= p
->u
.indirect
.section
;
4986 input_bfd
= input_section
->owner
;
4988 /* Combine the gptab entries for this input section one
4989 by one. We know that the input gptab entries are
4990 sorted by ascending -G value. */
4991 size
= bfd_section_size (input_bfd
, input_section
);
4993 for (gpentry
= sizeof (Elf32_External_gptab
);
4995 gpentry
+= sizeof (Elf32_External_gptab
))
4997 Elf32_External_gptab ext_gptab
;
4998 Elf32_gptab int_gptab
;
5004 if (! (bfd_get_section_contents
5005 (input_bfd
, input_section
, (PTR
) &ext_gptab
,
5006 gpentry
, sizeof (Elf32_External_gptab
))))
5012 bfd_mips_elf32_swap_gptab_in (input_bfd
, &ext_gptab
,
5014 val
= int_gptab
.gt_entry
.gt_g_value
;
5015 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
5018 for (look
= 1; look
< c
; look
++)
5020 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
5021 tab
[look
].gt_entry
.gt_bytes
+= add
;
5023 if (tab
[look
].gt_entry
.gt_g_value
== val
)
5029 Elf32_gptab
*new_tab
;
5032 /* We need a new table entry. */
5033 new_tab
= ((Elf32_gptab
*)
5034 bfd_realloc ((PTR
) tab
,
5035 (c
+ 1) * sizeof (Elf32_gptab
)));
5036 if (new_tab
== NULL
)
5042 tab
[c
].gt_entry
.gt_g_value
= val
;
5043 tab
[c
].gt_entry
.gt_bytes
= add
;
5045 /* Merge in the size for the next smallest -G
5046 value, since that will be implied by this new
5049 for (look
= 1; look
< c
; look
++)
5051 if (tab
[look
].gt_entry
.gt_g_value
< val
5053 || (tab
[look
].gt_entry
.gt_g_value
5054 > tab
[max
].gt_entry
.gt_g_value
)))
5058 tab
[c
].gt_entry
.gt_bytes
+=
5059 tab
[max
].gt_entry
.gt_bytes
;
5064 last
= int_gptab
.gt_entry
.gt_bytes
;
5067 /* Hack: reset the SEC_HAS_CONTENTS flag so that
5068 elf_link_input_bfd ignores this section. */
5069 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
5072 /* The table must be sorted by -G value. */
5074 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
5076 /* Swap out the table. */
5077 ext_tab
= ((Elf32_External_gptab
*)
5078 bfd_alloc (abfd
, c
* sizeof (Elf32_External_gptab
)));
5079 if (ext_tab
== NULL
)
5085 for (i
= 0; i
< c
; i
++)
5086 bfd_mips_elf32_swap_gptab_out (abfd
, tab
+ i
, ext_tab
+ i
);
5089 o
->_raw_size
= c
* sizeof (Elf32_External_gptab
);
5090 o
->contents
= (bfd_byte
*) ext_tab
;
5092 /* Skip this section later on (I don't think this currently
5093 matters, but someday it might). */
5094 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
5098 /* Invoke the regular ELF backend linker to do all the work. */
5099 if (ABI_64_P (abfd
))
5102 if (!bfd_elf64_bfd_final_link (abfd
, info
))
5109 else if (!bfd_elf32_bfd_final_link (abfd
, info
))
5112 /* Now write out the computed sections. */
5114 if (reginfo_sec
!= (asection
*) NULL
)
5116 Elf32_External_RegInfo ext
;
5118 bfd_mips_elf32_swap_reginfo_out (abfd
, ®info
, &ext
);
5119 if (! bfd_set_section_contents (abfd
, reginfo_sec
, (PTR
) &ext
,
5120 (file_ptr
) 0, sizeof ext
))
5124 if (mdebug_sec
!= (asection
*) NULL
)
5126 BFD_ASSERT (abfd
->output_has_begun
);
5127 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
5129 mdebug_sec
->filepos
))
5132 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
5135 if (gptab_data_sec
!= (asection
*) NULL
)
5137 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
5138 gptab_data_sec
->contents
,
5140 gptab_data_sec
->_raw_size
))
5144 if (gptab_bss_sec
!= (asection
*) NULL
)
5146 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
5147 gptab_bss_sec
->contents
,
5149 gptab_bss_sec
->_raw_size
))
5153 if (SGI_COMPAT (abfd
))
5155 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
5156 if (rtproc_sec
!= NULL
)
5158 if (! bfd_set_section_contents (abfd
, rtproc_sec
,
5159 rtproc_sec
->contents
,
5161 rtproc_sec
->_raw_size
))
5169 /* This function is called via qsort() to sort the dynamic relocation
5170 entries by increasing r_symndx value. */
5173 sort_dynamic_relocs (arg1
,arg2
)
5177 const Elf32_External_Rel
*ext_reloc1
= (const Elf32_External_Rel
*) arg1
;
5178 const Elf32_External_Rel
*ext_reloc2
= (const Elf32_External_Rel
*) arg2
;
5180 Elf_Internal_Rel int_reloc1
;
5181 Elf_Internal_Rel int_reloc2
;
5183 bfd_elf32_swap_reloc_in(reldyn_sorting_bfd
, ext_reloc1
, &int_reloc1
);
5184 bfd_elf32_swap_reloc_in(reldyn_sorting_bfd
, ext_reloc2
, &int_reloc2
);
5186 return (ELF32_R_SYM(int_reloc1
.r_info
) - ELF32_R_SYM(int_reloc2
.r_info
));
5189 /* Returns the GOT section for ABFD. */
5192 mips_elf_got_section (abfd
)
5195 return bfd_get_section_by_name (abfd
, ".got");
5198 /* Returns the GOT information associated with the link indicated by
5199 INFO. If SGOTP is non-NULL, it is filled in with the GOT
5202 static struct mips_got_info
*
5203 mips_elf_got_info (abfd
, sgotp
)
5208 struct mips_got_info
*g
;
5210 sgot
= mips_elf_got_section (abfd
);
5211 BFD_ASSERT (sgot
!= NULL
);
5212 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
5213 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
5214 BFD_ASSERT (g
!= NULL
);
5221 /* Return whether a relocation is against a local symbol. */
5224 mips_elf_local_relocation_p (input_bfd
, relocation
, local_sections
,
5227 const Elf_Internal_Rela
*relocation
;
5228 asection
**local_sections
;
5229 boolean check_forced
;
5231 unsigned long r_symndx
;
5232 Elf_Internal_Shdr
*symtab_hdr
;
5233 struct mips_elf_link_hash_entry
* h
;
5236 r_symndx
= ELF32_R_SYM (relocation
->r_info
);
5237 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
5238 extsymoff
= (elf_bad_symtab (input_bfd
)) ? 0 : symtab_hdr
->sh_info
;
5240 if (r_symndx
< extsymoff
)
5242 if (elf_bad_symtab (input_bfd
) && local_sections
[r_symndx
] != NULL
)
5247 /* Look up the hash table to check whether the symbol
5248 was forced local. */
5249 h
= (struct mips_elf_link_hash_entry
*)
5250 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
];
5251 /* Find the real hash-table entry for this symbol. */
5252 while (h
->root
.root
.type
== bfd_link_hash_indirect
5253 || h
->root
.root
.type
== bfd_link_hash_warning
)
5254 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
5255 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0)
5262 /* Sign-extend VALUE, which has the indicated number of BITS. */
5265 mips_elf_sign_extend (value
, bits
)
5269 if (value
& ((bfd_vma
)1 << (bits
- 1)))
5270 /* VALUE is negative. */
5271 value
|= ((bfd_vma
) - 1) << bits
;
5276 /* Return non-zero if the indicated VALUE has overflowed the maximum
5277 range expressable by a signed number with the indicated number of
5281 mips_elf_overflow_p (value
, bits
)
5285 bfd_signed_vma svalue
= (bfd_signed_vma
) value
;
5287 if (svalue
> (1 << (bits
- 1)) - 1)
5288 /* The value is too big. */
5290 else if (svalue
< -(1 << (bits
- 1)))
5291 /* The value is too small. */
5298 /* Calculate the %high function. */
5301 mips_elf_high (value
)
5304 return ((value
+ (bfd_vma
) 0x8000) >> 16) & 0xffff;
5307 /* Calculate the %higher function. */
5310 mips_elf_higher (value
)
5311 bfd_vma value ATTRIBUTE_UNUSED
;
5314 return ((value
+ (bfd_vma
) 0x80008000) >> 32) & 0xffff;
5317 return (bfd_vma
) -1;
5321 /* Calculate the %highest function. */
5324 mips_elf_highest (value
)
5325 bfd_vma value ATTRIBUTE_UNUSED
;
5328 return ((value
+ (bfd_vma
) 0x800080008000) >> 48) & 0xffff;
5331 return (bfd_vma
) -1;
5335 /* Returns the GOT index for the global symbol indicated by H. */
5338 mips_elf_global_got_index (abfd
, h
)
5340 struct elf_link_hash_entry
*h
;
5344 struct mips_got_info
*g
;
5346 g
= mips_elf_got_info (abfd
, &sgot
);
5348 /* Once we determine the global GOT entry with the lowest dynamic
5349 symbol table index, we must put all dynamic symbols with greater
5350 indices into the GOT. That makes it easy to calculate the GOT
5352 BFD_ASSERT (h
->dynindx
>= g
->global_gotsym
->dynindx
);
5353 index
= ((h
->dynindx
- g
->global_gotsym
->dynindx
+ g
->local_gotno
)
5354 * MIPS_ELF_GOT_SIZE (abfd
));
5355 BFD_ASSERT (index
< sgot
->_raw_size
);
5360 /* Returns the offset for the entry at the INDEXth position
5364 mips_elf_got_offset_from_index (dynobj
, output_bfd
, index
)
5372 sgot
= mips_elf_got_section (dynobj
);
5373 gp
= _bfd_get_gp_value (output_bfd
);
5374 return (sgot
->output_section
->vma
+ sgot
->output_offset
+ index
-
5378 /* If H is a symbol that needs a global GOT entry, but has a dynamic
5379 symbol table index lower than any we've seen to date, record it for
5383 mips_elf_record_global_got_symbol (h
, info
, g
)
5384 struct elf_link_hash_entry
*h
;
5385 struct bfd_link_info
*info
;
5386 struct mips_got_info
*g ATTRIBUTE_UNUSED
;
5388 /* A global symbol in the GOT must also be in the dynamic symbol
5390 if (h
->dynindx
== -1
5391 && !bfd_elf32_link_record_dynamic_symbol (info
, h
))
5394 /* If we've already marked this entry as need GOT space, we don't
5395 need to do it again. */
5396 if (h
->got
.offset
!= (bfd_vma
) - 1)
5399 /* By setting this to a value other than -1, we are indicating that
5400 there needs to be a GOT entry for H. */
5406 /* This structure is passed to mips_elf_sort_hash_table_f when sorting
5407 the dynamic symbols. */
5409 struct mips_elf_hash_sort_data
5411 /* The symbol in the global GOT with the lowest dynamic symbol table
5413 struct elf_link_hash_entry
*low
;
5414 /* The least dynamic symbol table index corresponding to a symbol
5415 with a GOT entry. */
5416 long min_got_dynindx
;
5417 /* The greatest dynamic symbol table index not corresponding to a
5418 symbol without a GOT entry. */
5419 long max_non_got_dynindx
;
5422 /* If H needs a GOT entry, assign it the highest available dynamic
5423 index. Otherwise, assign it the lowest available dynamic
5427 mips_elf_sort_hash_table_f (h
, data
)
5428 struct mips_elf_link_hash_entry
*h
;
5431 struct mips_elf_hash_sort_data
*hsd
5432 = (struct mips_elf_hash_sort_data
*) data
;
5434 /* Symbols without dynamic symbol table entries aren't interesting
5436 if (h
->root
.dynindx
== -1)
5439 if (h
->root
.got
.offset
!= 0)
5440 h
->root
.dynindx
= hsd
->max_non_got_dynindx
++;
5443 h
->root
.dynindx
= --hsd
->min_got_dynindx
;
5444 hsd
->low
= (struct elf_link_hash_entry
*) h
;
5450 /* Sort the dynamic symbol table so that symbols that need GOT entries
5451 appear towards the end. This reduces the amount of GOT space
5452 required. MAX_LOCAL is used to set the number of local symbols
5453 known to be in the dynamic symbol table. During
5454 mips_elf_size_dynamic_sections, this value is 1. Afterward, the
5455 section symbols are added and the count is higher. */
5458 mips_elf_sort_hash_table (info
, max_local
)
5459 struct bfd_link_info
*info
;
5460 unsigned long max_local
;
5462 struct mips_elf_hash_sort_data hsd
;
5463 struct mips_got_info
*g
;
5466 dynobj
= elf_hash_table (info
)->dynobj
;
5469 hsd
.min_got_dynindx
= elf_hash_table (info
)->dynsymcount
;
5470 hsd
.max_non_got_dynindx
= max_local
;
5471 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table
*)
5472 elf_hash_table (info
)),
5473 mips_elf_sort_hash_table_f
,
5476 /* There shoud have been enough room in the symbol table to
5477 accomodate both the GOT and non-GOT symbols. */
5478 BFD_ASSERT (hsd
.max_non_got_dynindx
<= hsd
.min_got_dynindx
);
5480 /* Now we know which dynamic symbol has the lowest dynamic symbol
5481 table index in the GOT. */
5482 g
= mips_elf_got_info (dynobj
, NULL
);
5483 g
->global_gotsym
= hsd
.low
;
5488 /* Create a local GOT entry for VALUE. Return the index of the entry,
5489 or -1 if it could not be created. */
5492 mips_elf_create_local_got_entry (abfd
, g
, sgot
, value
)
5494 struct mips_got_info
*g
;
5498 if (g
->assigned_gotno
>= g
->local_gotno
)
5500 /* We didn't allocate enough space in the GOT. */
5501 (*_bfd_error_handler
)
5502 (_("not enough GOT space for local GOT entries"));
5503 bfd_set_error (bfd_error_bad_value
);
5504 return (bfd_vma
) -1;
5507 MIPS_ELF_PUT_WORD (abfd
, value
,
5509 + MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
));
5510 return MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
++;
5513 /* Returns the GOT offset at which the indicated address can be found.
5514 If there is not yet a GOT entry for this value, create one. Returns
5515 -1 if no satisfactory GOT offset can be found. */
5518 mips_elf_local_got_index (abfd
, info
, value
)
5520 struct bfd_link_info
*info
;
5524 struct mips_got_info
*g
;
5527 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
5529 /* Look to see if we already have an appropriate entry. */
5530 for (entry
= (sgot
->contents
5531 + MIPS_ELF_GOT_SIZE (abfd
) * MIPS_RESERVED_GOTNO
);
5532 entry
!= sgot
->contents
+ MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
;
5533 entry
+= MIPS_ELF_GOT_SIZE (abfd
))
5535 bfd_vma address
= MIPS_ELF_GET_WORD (abfd
, entry
);
5536 if (address
== value
)
5537 return entry
- sgot
->contents
;
5540 return mips_elf_create_local_got_entry (abfd
, g
, sgot
, value
);
5543 /* Find a GOT entry that is within 32KB of the VALUE. These entries
5544 are supposed to be placed at small offsets in the GOT, i.e.,
5545 within 32KB of GP. Return the index into the GOT for this page,
5546 and store the offset from this entry to the desired address in
5547 OFFSETP, if it is non-NULL. */
5550 mips_elf_got_page (abfd
, info
, value
, offsetp
)
5552 struct bfd_link_info
*info
;
5557 struct mips_got_info
*g
;
5559 bfd_byte
*last_entry
;
5563 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
5565 /* Look to see if we aleady have an appropriate entry. */
5566 last_entry
= sgot
->contents
+ MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
;
5567 for (entry
= (sgot
->contents
5568 + MIPS_ELF_GOT_SIZE (abfd
) * MIPS_RESERVED_GOTNO
);
5569 entry
!= last_entry
;
5570 entry
+= MIPS_ELF_GOT_SIZE (abfd
))
5572 address
= MIPS_ELF_GET_WORD (abfd
, entry
);
5574 if (!mips_elf_overflow_p (value
- address
, 16))
5576 /* This entry will serve as the page pointer. We can add a
5577 16-bit number to it to get the actual address. */
5578 index
= entry
- sgot
->contents
;
5583 /* If we didn't have an appropriate entry, we create one now. */
5584 if (entry
== last_entry
)
5585 index
= mips_elf_create_local_got_entry (abfd
, g
, sgot
, value
);
5589 address
= MIPS_ELF_GET_WORD (abfd
, entry
);
5590 *offsetp
= value
- address
;
5596 /* Find a GOT entry whose higher-order 16 bits are the same as those
5597 for value. Return the index into the GOT for this entry. */
5600 mips_elf_got16_entry (abfd
, info
, value
, external
)
5602 struct bfd_link_info
*info
;
5607 struct mips_got_info
*g
;
5609 bfd_byte
*last_entry
;
5615 /* Although the ABI says that it is "the high-order 16 bits" that we
5616 want, it is really the %high value. The complete value is
5617 calculated with a `addiu' of a LO16 relocation, just as with a
5619 value
= mips_elf_high (value
) << 16;
5622 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
5624 /* Look to see if we already have an appropriate entry. */
5625 last_entry
= sgot
->contents
+ MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
;
5626 for (entry
= (sgot
->contents
5627 + MIPS_ELF_GOT_SIZE (abfd
) * MIPS_RESERVED_GOTNO
);
5628 entry
!= last_entry
;
5629 entry
+= MIPS_ELF_GOT_SIZE (abfd
))
5631 address
= MIPS_ELF_GET_WORD (abfd
, entry
);
5632 if (address
== value
)
5634 /* This entry has the right high-order 16 bits, and the low-order
5635 16 bits are set to zero. */
5636 index
= entry
- sgot
->contents
;
5641 /* If we didn't have an appropriate entry, we create one now. */
5642 if (entry
== last_entry
)
5643 index
= mips_elf_create_local_got_entry (abfd
, g
, sgot
, value
);
5648 /* Returns the first relocation of type r_type found, beginning with
5649 RELOCATION. RELEND is one-past-the-end of the relocation table. */
5651 static const Elf_Internal_Rela
*
5652 mips_elf_next_relocation (r_type
, relocation
, relend
)
5653 unsigned int r_type
;
5654 const Elf_Internal_Rela
*relocation
;
5655 const Elf_Internal_Rela
*relend
;
5657 /* According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must be
5658 immediately following. However, for the IRIX6 ABI, the next
5659 relocation may be a composed relocation consisting of several
5660 relocations for the same address. In that case, the R_MIPS_LO16
5661 relocation may occur as one of these. We permit a similar
5662 extension in general, as that is useful for GCC. */
5663 while (relocation
< relend
)
5665 if (ELF32_R_TYPE (relocation
->r_info
) == r_type
)
5671 /* We didn't find it. */
5672 bfd_set_error (bfd_error_bad_value
);
5676 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
5677 is the original relocation, which is now being transformed into a
5678 dynamic relocation. The ADDENDP is adjusted if necessary; the
5679 caller should store the result in place of the original addend. */
5682 mips_elf_create_dynamic_relocation (output_bfd
, info
, rel
, h
, sec
,
5683 symbol
, addendp
, input_section
)
5685 struct bfd_link_info
*info
;
5686 const Elf_Internal_Rela
*rel
;
5687 struct mips_elf_link_hash_entry
*h
;
5691 asection
*input_section
;
5693 Elf_Internal_Rel outrel
;
5699 r_type
= ELF32_R_TYPE (rel
->r_info
);
5700 dynobj
= elf_hash_table (info
)->dynobj
;
5702 = bfd_get_section_by_name (dynobj
,
5703 MIPS_ELF_REL_DYN_SECTION_NAME (output_bfd
));
5704 BFD_ASSERT (sreloc
!= NULL
);
5705 BFD_ASSERT (sreloc
->contents
!= NULL
);
5709 /* We begin by assuming that the offset for the dynamic relocation
5710 is the same as for the original relocation. We'll adjust this
5711 later to reflect the correct output offsets. */
5712 if (elf_section_data (input_section
)->stab_info
== NULL
)
5713 outrel
.r_offset
= rel
->r_offset
;
5716 /* Except that in a stab section things are more complex.
5717 Because we compress stab information, the offset given in the
5718 relocation may not be the one we want; we must let the stabs
5719 machinery tell us the offset. */
5721 = (_bfd_stab_section_offset
5722 (output_bfd
, &elf_hash_table (info
)->stab_info
,
5724 &elf_section_data (input_section
)->stab_info
,
5726 /* If we didn't need the relocation at all, this value will be
5728 if (outrel
.r_offset
== (bfd_vma
) -1)
5732 /* If we've decided to skip this relocation, just output an empty
5733 record. Note that R_MIPS_NONE == 0, so that this call to memset
5734 is a way of setting R_TYPE to R_MIPS_NONE. */
5736 memset (&outrel
, 0, sizeof (outrel
));
5740 bfd_vma section_offset
;
5742 /* We must now calculate the dynamic symbol table index to use
5743 in the relocation. */
5745 && (! info
->symbolic
|| (h
->root
.elf_link_hash_flags
5746 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
5748 indx
= h
->root
.dynindx
;
5749 /* h->root.dynindx may be -1 if this symbol was marked to
5756 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
5758 else if (sec
== NULL
|| sec
->owner
== NULL
)
5760 bfd_set_error (bfd_error_bad_value
);
5765 indx
= elf_section_data (sec
->output_section
)->dynindx
;
5770 /* Figure out how far the target of the relocation is from
5771 the beginning of its section. */
5772 section_offset
= symbol
- sec
->output_section
->vma
;
5773 /* The relocation we're building is section-relative.
5774 Therefore, the original addend must be adjusted by the
5776 *addendp
+= symbol
- sec
->output_section
->vma
;
5777 /* Now, the relocation is just against the section. */
5778 symbol
= sec
->output_section
->vma
;
5781 /* If the relocation was previously an absolute relocation, we
5782 must adjust it by the value we give it in the dynamic symbol
5784 if (r_type
!= R_MIPS_REL32
)
5787 /* The relocation is always an REL32 relocation because we don't
5788 know where the shared library will wind up at load-time. */
5789 outrel
.r_info
= ELF32_R_INFO (indx
, R_MIPS_REL32
);
5791 /* Adjust the output offset of the relocation to reference the
5792 correct location in the output file. */
5793 outrel
.r_offset
+= (input_section
->output_section
->vma
5794 + input_section
->output_offset
);
5797 /* Put the relocation back out. We have to use the special
5798 relocation outputter in the 64-bit case since the 64-bit
5799 relocation format is non-standard. */
5800 if (ABI_64_P (output_bfd
))
5802 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
5803 (output_bfd
, &outrel
,
5805 + sreloc
->reloc_count
* sizeof (Elf64_Mips_External_Rel
)));
5808 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
5809 (((Elf32_External_Rel
*)
5811 + sreloc
->reloc_count
));
5813 /* Record the index of the first relocation referencing H. This
5814 information is later emitted in the .msym section. */
5816 && (h
->min_dyn_reloc_index
== 0
5817 || sreloc
->reloc_count
< h
->min_dyn_reloc_index
))
5818 h
->min_dyn_reloc_index
= sreloc
->reloc_count
;
5820 /* We've now added another relocation. */
5821 ++sreloc
->reloc_count
;
5823 /* Make sure the output section is writable. The dynamic linker
5824 will be writing to it. */
5825 elf_section_data (input_section
->output_section
)->this_hdr
.sh_flags
5828 /* On IRIX5, make an entry of compact relocation info. */
5829 if (! skip
&& IRIX_COMPAT (output_bfd
) == ict_irix5
)
5831 asection
* scpt
= bfd_get_section_by_name (dynobj
, ".compact_rel");
5836 Elf32_crinfo cptrel
;
5838 mips_elf_set_cr_format (cptrel
, CRF_MIPS_LONG
);
5839 cptrel
.vaddr
= (rel
->r_offset
5840 + input_section
->output_section
->vma
5841 + input_section
->output_offset
);
5842 if (r_type
== R_MIPS_REL32
)
5843 mips_elf_set_cr_type (cptrel
, CRT_MIPS_REL32
);
5845 mips_elf_set_cr_type (cptrel
, CRT_MIPS_WORD
);
5846 mips_elf_set_cr_dist2to (cptrel
, 0);
5847 cptrel
.konst
= *addendp
;
5849 cr
= (scpt
->contents
5850 + sizeof (Elf32_External_compact_rel
));
5851 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
5852 ((Elf32_External_crinfo
*) cr
5853 + scpt
->reloc_count
));
5854 ++scpt
->reloc_count
;
5861 /* Calculate the value produced by the RELOCATION (which comes from
5862 the INPUT_BFD). The ADDEND is the addend to use for this
5863 RELOCATION; RELOCATION->R_ADDEND is ignored.
5865 The result of the relocation calculation is stored in VALUEP.
5866 REQUIRE_JALXP indicates whether or not the opcode used with this
5867 relocation must be JALX.
5869 This function returns bfd_reloc_continue if the caller need take no
5870 further action regarding this relocation, bfd_reloc_notsupported if
5871 something goes dramatically wrong, bfd_reloc_overflow if an
5872 overflow occurs, and bfd_reloc_ok to indicate success. */
5874 static bfd_reloc_status_type
5875 mips_elf_calculate_relocation (abfd
,
5889 asection
*input_section
;
5890 struct bfd_link_info
*info
;
5891 const Elf_Internal_Rela
*relocation
;
5893 reloc_howto_type
*howto
;
5894 Elf_Internal_Sym
*local_syms
;
5895 asection
**local_sections
;
5898 boolean
*require_jalxp
;
5900 /* The eventual value we will return. */
5902 /* The address of the symbol against which the relocation is
5905 /* The final GP value to be used for the relocatable, executable, or
5906 shared object file being produced. */
5907 bfd_vma gp
= (bfd_vma
) - 1;
5908 /* The place (section offset or address) of the storage unit being
5911 /* The value of GP used to create the relocatable object. */
5912 bfd_vma gp0
= (bfd_vma
) - 1;
5913 /* The offset into the global offset table at which the address of
5914 the relocation entry symbol, adjusted by the addend, resides
5915 during execution. */
5916 bfd_vma g
= (bfd_vma
) - 1;
5917 /* The section in which the symbol referenced by the relocation is
5919 asection
*sec
= NULL
;
5920 struct mips_elf_link_hash_entry
* h
= NULL
;
5921 /* True if the symbol referred to by this relocation is a local
5924 /* True if the symbol referred to by this relocation is "_gp_disp". */
5925 boolean gp_disp_p
= false;
5926 Elf_Internal_Shdr
*symtab_hdr
;
5928 unsigned long r_symndx
;
5930 /* True if overflow occurred during the calculation of the
5931 relocation value. */
5932 boolean overflowed_p
;
5933 /* True if this relocation refers to a MIPS16 function. */
5934 boolean target_is_16_bit_code_p
= false;
5936 /* Parse the relocation. */
5937 r_symndx
= ELF32_R_SYM (relocation
->r_info
);
5938 r_type
= ELF32_R_TYPE (relocation
->r_info
);
5939 p
= (input_section
->output_section
->vma
5940 + input_section
->output_offset
5941 + relocation
->r_offset
);
5943 /* Assume that there will be no overflow. */
5944 overflowed_p
= false;
5946 /* Figure out whether or not the symbol is local, and get the offset
5947 used in the array of hash table entries. */
5948 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
5949 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
5950 local_sections
, false);
5951 if (! elf_bad_symtab (input_bfd
))
5952 extsymoff
= symtab_hdr
->sh_info
;
5955 /* The symbol table does not follow the rule that local symbols
5956 must come before globals. */
5960 /* Figure out the value of the symbol. */
5963 Elf_Internal_Sym
*sym
;
5965 sym
= local_syms
+ r_symndx
;
5966 sec
= local_sections
[r_symndx
];
5968 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
5969 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
)
5970 symbol
+= sym
->st_value
;
5972 /* MIPS16 text labels should be treated as odd. */
5973 if (sym
->st_other
== STO_MIPS16
)
5976 /* Record the name of this symbol, for our caller. */
5977 *namep
= bfd_elf_string_from_elf_section (input_bfd
,
5978 symtab_hdr
->sh_link
,
5981 *namep
= bfd_section_name (input_bfd
, sec
);
5983 target_is_16_bit_code_p
= (sym
->st_other
== STO_MIPS16
);
5987 /* For global symbols we look up the symbol in the hash-table. */
5988 h
= ((struct mips_elf_link_hash_entry
*)
5989 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
]);
5990 /* Find the real hash-table entry for this symbol. */
5991 while (h
->root
.root
.type
== bfd_link_hash_indirect
5992 || h
->root
.root
.type
== bfd_link_hash_warning
)
5993 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
5995 /* Record the name of this symbol, for our caller. */
5996 *namep
= h
->root
.root
.root
.string
;
5998 /* See if this is the special _gp_disp symbol. Note that such a
5999 symbol must always be a global symbol. */
6000 if (strcmp (h
->root
.root
.root
.string
, "_gp_disp") == 0)
6002 /* Relocations against _gp_disp are permitted only with
6003 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
6004 if (r_type
!= R_MIPS_HI16
&& r_type
!= R_MIPS_LO16
)
6005 return bfd_reloc_notsupported
;
6009 /* If this symbol is defined, calculate its address. Note that
6010 _gp_disp is a magic symbol, always implicitly defined by the
6011 linker, so it's inappropriate to check to see whether or not
6013 else if ((h
->root
.root
.type
== bfd_link_hash_defined
6014 || h
->root
.root
.type
== bfd_link_hash_defweak
)
6015 && h
->root
.root
.u
.def
.section
)
6017 sec
= h
->root
.root
.u
.def
.section
;
6018 if (sec
->output_section
)
6019 symbol
= (h
->root
.root
.u
.def
.value
6020 + sec
->output_section
->vma
6021 + sec
->output_offset
);
6023 symbol
= h
->root
.root
.u
.def
.value
;
6025 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
6026 /* We allow relocations against undefined weak symbols, giving
6027 it the value zero, so that you can undefined weak functions
6028 and check to see if they exist by looking at their
6031 else if (info
->shared
&& !info
->symbolic
&& !info
->no_undefined
6032 && ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
6034 else if (strcmp (h
->root
.root
.root
.string
, "_DYNAMIC_LINK") == 0 ||
6035 strcmp (h
->root
.root
.root
.string
, "_DYNAMIC_LINKING") == 0)
6037 /* If this is a dynamic link, we should have created a
6038 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
6039 in in mips_elf_create_dynamic_sections.
6040 Otherwise, we should define the symbol with a value of 0.
6041 FIXME: It should probably get into the symbol table
6043 BFD_ASSERT (! info
->shared
);
6044 BFD_ASSERT (bfd_get_section_by_name (abfd
, ".dynamic") == NULL
);
6049 if (! ((*info
->callbacks
->undefined_symbol
)
6050 (info
, h
->root
.root
.root
.string
, input_bfd
,
6051 input_section
, relocation
->r_offset
,
6052 (!info
->shared
|| info
->no_undefined
6053 || ELF_ST_VISIBILITY (h
->root
.other
)))))
6054 return bfd_reloc_undefined
;
6058 target_is_16_bit_code_p
= (h
->root
.other
== STO_MIPS16
);
6061 /* If this is a 32-bit call to a 16-bit function with a stub, we
6062 need to redirect the call to the stub, unless we're already *in*
6064 if (r_type
!= R_MIPS16_26
&& !info
->relocateable
6065 && ((h
!= NULL
&& h
->fn_stub
!= NULL
)
6066 || (local_p
&& elf_tdata (input_bfd
)->local_stubs
!= NULL
6067 && elf_tdata (input_bfd
)->local_stubs
[r_symndx
] != NULL
))
6068 && !mips_elf_stub_section_p (input_bfd
, input_section
))
6070 /* This is a 32-bit call to a 16-bit function. We should
6071 have already noticed that we were going to need the
6074 sec
= elf_tdata (input_bfd
)->local_stubs
[r_symndx
];
6077 BFD_ASSERT (h
->need_fn_stub
);
6081 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
6083 /* If this is a 16-bit call to a 32-bit function with a stub, we
6084 need to redirect the call to the stub. */
6085 else if (r_type
== R_MIPS16_26
&& !info
->relocateable
6087 && (h
->call_stub
!= NULL
|| h
->call_fp_stub
!= NULL
)
6088 && !target_is_16_bit_code_p
)
6090 /* If both call_stub and call_fp_stub are defined, we can figure
6091 out which one to use by seeing which one appears in the input
6093 if (h
->call_stub
!= NULL
&& h
->call_fp_stub
!= NULL
)
6098 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6100 if (strncmp (bfd_get_section_name (input_bfd
, o
),
6101 CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
6103 sec
= h
->call_fp_stub
;
6110 else if (h
->call_stub
!= NULL
)
6113 sec
= h
->call_fp_stub
;
6115 BFD_ASSERT (sec
->_raw_size
> 0);
6116 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
6119 /* Calls from 16-bit code to 32-bit code and vice versa require the
6120 special jalx instruction. */
6121 *require_jalxp
= (!info
->relocateable
6122 && ((r_type
== R_MIPS16_26
) != target_is_16_bit_code_p
));
6124 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
6125 local_sections
, true);
6127 /* If we haven't already determined the GOT offset, or the GP value,
6128 and we're going to need it, get it now. */
6133 case R_MIPS_GOT_DISP
:
6134 case R_MIPS_GOT_HI16
:
6135 case R_MIPS_CALL_HI16
:
6136 case R_MIPS_GOT_LO16
:
6137 case R_MIPS_CALL_LO16
:
6138 /* Find the index into the GOT where this value is located. */
6141 BFD_ASSERT (addend
== 0);
6142 g
= mips_elf_global_got_index
6143 (elf_hash_table (info
)->dynobj
,
6144 (struct elf_link_hash_entry
*) h
);
6145 if (! elf_hash_table(info
)->dynamic_sections_created
6147 && (info
->symbolic
|| h
->root
.dynindx
== -1)
6148 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
6150 /* This is a static link or a -Bsymbolic link. The
6151 symbol is defined locally, or was forced to be local.
6152 We must initialize this entry in the GOT. */
6153 asection
*sgot
= mips_elf_got_section(elf_hash_table
6155 MIPS_ELF_PUT_WORD (elf_hash_table (info
)->dynobj
,
6156 symbol
+ addend
, sgot
->contents
+ g
);
6159 else if (r_type
== R_MIPS_GOT16
)
6160 /* There's no need to create a local GOT entry here; the
6161 calculation for a local GOT16 entry does not involve G. */
6165 g
= mips_elf_local_got_index (abfd
, info
, symbol
+ addend
);
6166 if (g
== (bfd_vma
) -1)
6170 /* Convert GOT indices to actual offsets. */
6171 g
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
6177 case R_MIPS_GPREL16
:
6178 case R_MIPS_GPREL32
:
6179 case R_MIPS_LITERAL
:
6180 gp0
= _bfd_get_gp_value (input_bfd
);
6181 gp
= _bfd_get_gp_value (abfd
);
6188 /* Figure out what kind of relocation is being performed. */
6192 return bfd_reloc_continue
;
6195 value
= symbol
+ mips_elf_sign_extend (addend
, 16);
6196 overflowed_p
= mips_elf_overflow_p (value
, 16);
6203 || (elf_hash_table (info
)->dynamic_sections_created
6205 && ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
)
6207 && (input_section
->flags
& SEC_ALLOC
) != 0)
6209 /* If we're creating a shared library, or this relocation is
6210 against a symbol in a shared library, then we can't know
6211 where the symbol will end up. So, we create a relocation
6212 record in the output, and leave the job up to the dynamic
6215 if (!mips_elf_create_dynamic_relocation (abfd
,
6227 if (r_type
!= R_MIPS_REL32
)
6228 value
= symbol
+ addend
;
6232 value
&= howto
->dst_mask
;
6237 case R_MIPS_GNU_REL_LO16
:
6238 value
= symbol
+ addend
- p
;
6239 value
&= howto
->dst_mask
;
6242 case R_MIPS_GNU_REL16_S2
:
6243 value
= symbol
+ mips_elf_sign_extend (addend
<< 2, 18) - p
;
6244 overflowed_p
= mips_elf_overflow_p (value
, 18);
6245 value
= (value
>> 2) & howto
->dst_mask
;
6248 case R_MIPS_GNU_REL_HI16
:
6249 value
= mips_elf_high (addend
+ symbol
- p
);
6250 value
&= howto
->dst_mask
;
6254 /* The calculation for R_MIPS_26 is just the same as for an
6255 R_MIPS_26. It's only the storage of the relocated field into
6256 the output file that's different. That's handled in
6257 mips_elf_perform_relocation. So, we just fall through to the
6258 R_MIPS_26 case here. */
6261 value
= (((addend
<< 2) | (p
& 0xf0000000)) + symbol
) >> 2;
6263 value
= (mips_elf_sign_extend (addend
<< 2, 28) + symbol
) >> 2;
6264 value
&= howto
->dst_mask
;
6270 value
= mips_elf_high (addend
+ symbol
);
6271 value
&= howto
->dst_mask
;
6275 value
= mips_elf_high (addend
+ gp
- p
);
6276 overflowed_p
= mips_elf_overflow_p (value
, 16);
6282 value
= (symbol
+ addend
) & howto
->dst_mask
;
6285 value
= addend
+ gp
- p
+ 4;
6286 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
6287 for overflow. But, on, say, Irix 5, relocations against
6288 _gp_disp are normally generated from the .cpload
6289 pseudo-op. It generates code that normally looks like
6292 lui $gp,%hi(_gp_disp)
6293 addiu $gp,$gp,%lo(_gp_disp)
6296 Here $t9 holds the address of the function being called,
6297 as required by the MIPS ELF ABI. The R_MIPS_LO16
6298 relocation can easily overflow in this situation, but the
6299 R_MIPS_HI16 relocation will handle the overflow.
6300 Therefore, we consider this a bug in the MIPS ABI, and do
6301 not check for overflow here. */
6305 case R_MIPS_LITERAL
:
6306 /* Because we don't merge literal sections, we can handle this
6307 just like R_MIPS_GPREL16. In the long run, we should merge
6308 shared literals, and then we will need to additional work
6313 case R_MIPS16_GPREL
:
6314 /* The R_MIPS16_GPREL performs the same calculation as
6315 R_MIPS_GPREL16, but stores the relocated bits in a different
6316 order. We don't need to do anything special here; the
6317 differences are handled in mips_elf_perform_relocation. */
6318 case R_MIPS_GPREL16
:
6320 value
= mips_elf_sign_extend (addend
, 16) + symbol
+ gp0
- gp
;
6322 value
= mips_elf_sign_extend (addend
, 16) + symbol
- gp
;
6323 overflowed_p
= mips_elf_overflow_p (value
, 16);
6331 /* The special case is when the symbol is forced to be local. We
6332 need the full address in the GOT since no R_MIPS_LO16 relocation
6334 forced
= ! mips_elf_local_relocation_p (input_bfd
, relocation
,
6335 local_sections
, false);
6336 value
= mips_elf_got16_entry (abfd
, info
, symbol
+ addend
, forced
);
6337 if (value
== (bfd_vma
) -1)
6340 = mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
6343 overflowed_p
= mips_elf_overflow_p (value
, 16);
6350 case R_MIPS_GOT_DISP
:
6352 overflowed_p
= mips_elf_overflow_p (value
, 16);
6355 case R_MIPS_GPREL32
:
6356 value
= (addend
+ symbol
+ gp0
- gp
) & howto
->dst_mask
;
6360 value
= mips_elf_sign_extend (addend
, 16) + symbol
- p
;
6361 value
= (bfd_vma
) ((bfd_signed_vma
) value
/ 4);
6362 overflowed_p
= mips_elf_overflow_p (value
, 16);
6365 case R_MIPS_GOT_HI16
:
6366 case R_MIPS_CALL_HI16
:
6367 /* We're allowed to handle these two relocations identically.
6368 The dynamic linker is allowed to handle the CALL relocations
6369 differently by creating a lazy evaluation stub. */
6371 value
= mips_elf_high (value
);
6372 value
&= howto
->dst_mask
;
6375 case R_MIPS_GOT_LO16
:
6376 case R_MIPS_CALL_LO16
:
6377 value
= g
& howto
->dst_mask
;
6380 case R_MIPS_GOT_PAGE
:
6381 value
= mips_elf_got_page (abfd
, info
, symbol
+ addend
, NULL
);
6382 if (value
== (bfd_vma
) -1)
6384 value
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
6387 overflowed_p
= mips_elf_overflow_p (value
, 16);
6390 case R_MIPS_GOT_OFST
:
6391 mips_elf_got_page (abfd
, info
, symbol
+ addend
, &value
);
6392 overflowed_p
= mips_elf_overflow_p (value
, 16);
6396 value
= symbol
- addend
;
6397 value
&= howto
->dst_mask
;
6401 value
= mips_elf_higher (addend
+ symbol
);
6402 value
&= howto
->dst_mask
;
6405 case R_MIPS_HIGHEST
:
6406 value
= mips_elf_highest (addend
+ symbol
);
6407 value
&= howto
->dst_mask
;
6410 case R_MIPS_SCN_DISP
:
6411 value
= symbol
+ addend
- sec
->output_offset
;
6412 value
&= howto
->dst_mask
;
6417 /* Both of these may be ignored. R_MIPS_JALR is an optimization
6418 hint; we could improve performance by honoring that hint. */
6419 return bfd_reloc_continue
;
6421 case R_MIPS_GNU_VTINHERIT
:
6422 case R_MIPS_GNU_VTENTRY
:
6423 /* We don't do anything with these at present. */
6424 return bfd_reloc_continue
;
6427 /* An unrecognized relocation type. */
6428 return bfd_reloc_notsupported
;
6431 /* Store the VALUE for our caller. */
6433 return overflowed_p
? bfd_reloc_overflow
: bfd_reloc_ok
;
6436 /* Obtain the field relocated by RELOCATION. */
6439 mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
)
6440 reloc_howto_type
*howto
;
6441 const Elf_Internal_Rela
*relocation
;
6446 bfd_byte
*location
= contents
+ relocation
->r_offset
;
6448 /* Obtain the bytes. */
6449 x
= bfd_get (8 * bfd_get_reloc_size (howto
), input_bfd
, location
);
6451 if ((ELF32_R_TYPE (relocation
->r_info
) == R_MIPS16_26
6452 || ELF32_R_TYPE (relocation
->r_info
) == R_MIPS16_GPREL
)
6453 && bfd_little_endian (input_bfd
))
6454 /* The two 16-bit words will be reversed on a little-endian
6455 system. See mips_elf_perform_relocation for more details. */
6456 x
= (((x
& 0xffff) << 16) | ((x
& 0xffff0000) >> 16));
6461 /* It has been determined that the result of the RELOCATION is the
6462 VALUE. Use HOWTO to place VALUE into the output file at the
6463 appropriate position. The SECTION is the section to which the
6464 relocation applies. If REQUIRE_JALX is true, then the opcode used
6465 for the relocation must be either JAL or JALX, and it is
6466 unconditionally converted to JALX.
6468 Returns false if anything goes wrong. */
6471 mips_elf_perform_relocation (info
, howto
, relocation
, value
,
6472 input_bfd
, input_section
,
6473 contents
, require_jalx
)
6474 struct bfd_link_info
*info
;
6475 reloc_howto_type
*howto
;
6476 const Elf_Internal_Rela
*relocation
;
6479 asection
*input_section
;
6481 boolean require_jalx
;
6485 int r_type
= ELF32_R_TYPE (relocation
->r_info
);
6487 /* Figure out where the relocation is occurring. */
6488 location
= contents
+ relocation
->r_offset
;
6490 /* Obtain the current value. */
6491 x
= mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
);
6493 /* Clear the field we are setting. */
6494 x
&= ~howto
->dst_mask
;
6496 /* If this is the R_MIPS16_26 relocation, we must store the
6497 value in a funny way. */
6498 if (r_type
== R_MIPS16_26
)
6500 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
6501 Most mips16 instructions are 16 bits, but these instructions
6504 The format of these instructions is:
6506 +--------------+--------------------------------+
6507 ! JALX ! X! Imm 20:16 ! Imm 25:21 !
6508 +--------------+--------------------------------+
6510 +-----------------------------------------------+
6512 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
6513 Note that the immediate value in the first word is swapped.
6515 When producing a relocateable object file, R_MIPS16_26 is
6516 handled mostly like R_MIPS_26. In particular, the addend is
6517 stored as a straight 26-bit value in a 32-bit instruction.
6518 (gas makes life simpler for itself by never adjusting a
6519 R_MIPS16_26 reloc to be against a section, so the addend is
6520 always zero). However, the 32 bit instruction is stored as 2
6521 16-bit values, rather than a single 32-bit value. In a
6522 big-endian file, the result is the same; in a little-endian
6523 file, the two 16-bit halves of the 32 bit value are swapped.
6524 This is so that a disassembler can recognize the jal
6527 When doing a final link, R_MIPS16_26 is treated as a 32 bit
6528 instruction stored as two 16-bit values. The addend A is the
6529 contents of the targ26 field. The calculation is the same as
6530 R_MIPS_26. When storing the calculated value, reorder the
6531 immediate value as shown above, and don't forget to store the
6532 value as two 16-bit values.
6534 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
6538 +--------+----------------------+
6542 +--------+----------------------+
6545 +----------+------+-------------+
6549 +----------+--------------------+
6550 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
6551 ((sub1 << 16) | sub2)).
6553 When producing a relocateable object file, the calculation is
6554 (((A < 2) | (P & 0xf0000000) + S) >> 2)
6555 When producing a fully linked file, the calculation is
6556 let R = (((A < 2) | (P & 0xf0000000) + S) >> 2)
6557 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff) */
6559 if (!info
->relocateable
)
6560 /* Shuffle the bits according to the formula above. */
6561 value
= (((value
& 0x1f0000) << 5)
6562 | ((value
& 0x3e00000) >> 5)
6563 | (value
& 0xffff));
6566 else if (r_type
== R_MIPS16_GPREL
)
6568 /* R_MIPS16_GPREL is used for GP-relative addressing in mips16
6569 mode. A typical instruction will have a format like this:
6571 +--------------+--------------------------------+
6572 ! EXTEND ! Imm 10:5 ! Imm 15:11 !
6573 +--------------+--------------------------------+
6574 ! Major ! rx ! ry ! Imm 4:0 !
6575 +--------------+--------------------------------+
6577 EXTEND is the five bit value 11110. Major is the instruction
6580 This is handled exactly like R_MIPS_GPREL16, except that the
6581 addend is retrieved and stored as shown in this diagram; that
6582 is, the Imm fields above replace the V-rel16 field.
6584 All we need to do here is shuffle the bits appropriately. As
6585 above, the two 16-bit halves must be swapped on a
6586 little-endian system. */
6587 value
= (((value
& 0x7e0) << 16)
6588 | ((value
& 0xf800) << 5)
6592 /* Set the field. */
6593 x
|= (value
& howto
->dst_mask
);
6595 /* If required, turn JAL into JALX. */
6599 bfd_vma opcode
= x
>> 26;
6600 bfd_vma jalx_opcode
;
6602 /* Check to see if the opcode is already JAL or JALX. */
6603 if (r_type
== R_MIPS16_26
)
6605 ok
= ((opcode
== 0x6) || (opcode
== 0x7));
6610 ok
= ((opcode
== 0x3) || (opcode
== 0x1d));
6614 /* If the opcode is not JAL or JALX, there's a problem. */
6617 (*_bfd_error_handler
)
6618 (_("%s: %s+0x%lx: jump to stub routine which is not jal"),
6619 bfd_get_filename (input_bfd
),
6620 input_section
->name
,
6621 (unsigned long) relocation
->r_offset
);
6622 bfd_set_error (bfd_error_bad_value
);
6626 /* Make this the JALX opcode. */
6627 x
= (x
& ~(0x3f << 26)) | (jalx_opcode
<< 26);
6630 /* Swap the high- and low-order 16 bits on little-endian systems
6631 when doing a MIPS16 relocation. */
6632 if ((r_type
== R_MIPS16_GPREL
|| r_type
== R_MIPS16_26
)
6633 && bfd_little_endian (input_bfd
))
6634 x
= (((x
& 0xffff) << 16) | ((x
& 0xffff0000) >> 16));
6636 /* Put the value into the output. */
6637 bfd_put (8 * bfd_get_reloc_size (howto
), input_bfd
, x
, location
);
6641 /* Returns true if SECTION is a MIPS16 stub section. */
6644 mips_elf_stub_section_p (abfd
, section
)
6645 bfd
*abfd ATTRIBUTE_UNUSED
;
6648 const char *name
= bfd_get_section_name (abfd
, section
);
6650 return (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0
6651 || strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
6652 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0);
6655 /* Relocate a MIPS ELF section. */
6658 _bfd_mips_elf_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
6659 contents
, relocs
, local_syms
, local_sections
)
6661 struct bfd_link_info
*info
;
6663 asection
*input_section
;
6665 Elf_Internal_Rela
*relocs
;
6666 Elf_Internal_Sym
*local_syms
;
6667 asection
**local_sections
;
6669 Elf_Internal_Rela
*rel
;
6670 const Elf_Internal_Rela
*relend
;
6672 boolean use_saved_addend_p
= false;
6673 struct elf_backend_data
*bed
;
6675 bed
= get_elf_backend_data (output_bfd
);
6676 relend
= relocs
+ input_section
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
6677 for (rel
= relocs
; rel
< relend
; ++rel
)
6681 reloc_howto_type
*howto
;
6682 boolean require_jalx
;
6683 /* True if the relocation is a RELA relocation, rather than a
6685 boolean rela_relocation_p
= true;
6686 int r_type
= ELF32_R_TYPE (rel
->r_info
);
6688 /* Find the relocation howto for this relocation. */
6689 if (r_type
== R_MIPS_64
&& !ABI_64_P (output_bfd
))
6691 /* Some 32-bit code uses R_MIPS_64. In particular, people use
6692 64-bit code, but make sure all their addresses are in the
6693 lowermost or uppermost 32-bit section of the 64-bit address
6694 space. Thus, when they use an R_MIPS_64 they mean what is
6695 usually meant by R_MIPS_32, with the exception that the
6696 stored value is sign-extended to 64 bits. */
6697 howto
= elf_mips_howto_table
+ R_MIPS_32
;
6699 /* On big-endian systems, we need to lie about the position
6701 if (bfd_big_endian (input_bfd
))
6705 howto
= mips_rtype_to_howto (r_type
);
6707 if (!use_saved_addend_p
)
6709 Elf_Internal_Shdr
*rel_hdr
;
6711 /* If these relocations were originally of the REL variety,
6712 we must pull the addend out of the field that will be
6713 relocated. Otherwise, we simply use the contents of the
6714 RELA relocation. To determine which flavor or relocation
6715 this is, we depend on the fact that the INPUT_SECTION's
6716 REL_HDR is read before its REL_HDR2. */
6717 rel_hdr
= &elf_section_data (input_section
)->rel_hdr
;
6718 if ((size_t) (rel
- relocs
)
6719 >= (rel_hdr
->sh_size
/ rel_hdr
->sh_entsize
6720 * bed
->s
->int_rels_per_ext_rel
))
6721 rel_hdr
= elf_section_data (input_section
)->rel_hdr2
;
6722 if (rel_hdr
->sh_entsize
== MIPS_ELF_REL_SIZE (input_bfd
))
6724 /* Note that this is a REL relocation. */
6725 rela_relocation_p
= false;
6727 /* Get the addend, which is stored in the input file. */
6728 addend
= mips_elf_obtain_contents (howto
,
6732 addend
&= howto
->src_mask
;
6734 /* For some kinds of relocations, the ADDEND is a
6735 combination of the addend stored in two different
6737 if (r_type
== R_MIPS_HI16
6738 || r_type
== R_MIPS_GNU_REL_HI16
6739 || (r_type
== R_MIPS_GOT16
6740 && mips_elf_local_relocation_p (input_bfd
, rel
,
6741 local_sections
, false)))
6744 const Elf_Internal_Rela
*lo16_relocation
;
6745 reloc_howto_type
*lo16_howto
;
6748 /* The combined value is the sum of the HI16 addend,
6749 left-shifted by sixteen bits, and the LO16
6750 addend, sign extended. (Usually, the code does
6751 a `lui' of the HI16 value, and then an `addiu' of
6754 Scan ahead to find a matching LO16 relocation. */
6755 if (r_type
== R_MIPS_GNU_REL_HI16
)
6756 lo
= R_MIPS_GNU_REL_LO16
;
6760 = mips_elf_next_relocation (lo
, rel
, relend
);
6761 if (lo16_relocation
== NULL
)
6764 /* Obtain the addend kept there. */
6765 lo16_howto
= mips_rtype_to_howto (lo
);
6766 l
= mips_elf_obtain_contents (lo16_howto
,
6768 input_bfd
, contents
);
6769 l
&= lo16_howto
->src_mask
;
6770 l
= mips_elf_sign_extend (l
, 16);
6774 /* Compute the combined addend. */
6777 else if (r_type
== R_MIPS16_GPREL
)
6779 /* The addend is scrambled in the object file. See
6780 mips_elf_perform_relocation for details on the
6782 addend
= (((addend
& 0x1f0000) >> 5)
6783 | ((addend
& 0x7e00000) >> 16)
6788 addend
= rel
->r_addend
;
6791 if (info
->relocateable
)
6793 Elf_Internal_Sym
*sym
;
6794 unsigned long r_symndx
;
6796 if (r_type
== R_MIPS_64
&& !ABI_64_P (output_bfd
)
6797 && bfd_big_endian (input_bfd
))
6800 /* Since we're just relocating, all we need to do is copy
6801 the relocations back out to the object file, unless
6802 they're against a section symbol, in which case we need
6803 to adjust by the section offset, or unless they're GP
6804 relative in which case we need to adjust by the amount
6805 that we're adjusting GP in this relocateable object. */
6807 if (!mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
,
6809 /* There's nothing to do for non-local relocations. */
6812 if (r_type
== R_MIPS16_GPREL
6813 || r_type
== R_MIPS_GPREL16
6814 || r_type
== R_MIPS_GPREL32
6815 || r_type
== R_MIPS_LITERAL
)
6816 addend
-= (_bfd_get_gp_value (output_bfd
)
6817 - _bfd_get_gp_value (input_bfd
));
6818 else if (r_type
== R_MIPS_26
|| r_type
== R_MIPS16_26
6819 || r_type
== R_MIPS_GNU_REL16_S2
)
6820 /* The addend is stored without its two least
6821 significant bits (which are always zero.) In a
6822 non-relocateable link, calculate_relocation will do
6823 this shift; here, we must do it ourselves. */
6826 r_symndx
= ELF32_R_SYM (rel
->r_info
);
6827 sym
= local_syms
+ r_symndx
;
6828 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6829 /* Adjust the addend appropriately. */
6830 addend
+= local_sections
[r_symndx
]->output_offset
;
6832 /* If the relocation is for a R_MIPS_HI16 or R_MIPS_GOT16,
6833 then we only want to write out the high-order 16 bits.
6834 The subsequent R_MIPS_LO16 will handle the low-order bits. */
6835 if (r_type
== R_MIPS_HI16
|| r_type
== R_MIPS_GOT16
6836 || r_type
== R_MIPS_GNU_REL_HI16
)
6837 addend
= mips_elf_high (addend
);
6838 /* If the relocation is for an R_MIPS_26 relocation, then
6839 the two low-order bits are not stored in the object file;
6840 they are implicitly zero. */
6841 else if (r_type
== R_MIPS_26
|| r_type
== R_MIPS16_26
6842 || r_type
== R_MIPS_GNU_REL16_S2
)
6845 if (rela_relocation_p
)
6846 /* If this is a RELA relocation, just update the addend.
6847 We have to cast away constness for REL. */
6848 rel
->r_addend
= addend
;
6851 /* Otherwise, we have to write the value back out. Note
6852 that we use the source mask, rather than the
6853 destination mask because the place to which we are
6854 writing will be source of the addend in the final
6856 addend
&= howto
->src_mask
;
6858 if (r_type
== R_MIPS_64
&& !ABI_64_P (output_bfd
))
6859 /* See the comment above about using R_MIPS_64 in the 32-bit
6860 ABI. Here, we need to update the addend. It would be
6861 possible to get away with just using the R_MIPS_32 reloc
6862 but for endianness. */
6868 if (addend
& ((bfd_vma
) 1 << 31))
6869 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
6873 /* If we don't know that we have a 64-bit type,
6874 do two separate stores. */
6875 if (bfd_big_endian (input_bfd
))
6877 /* Store the sign-bits (which are most significant)
6879 low_bits
= sign_bits
;
6885 high_bits
= sign_bits
;
6887 bfd_put_32 (input_bfd
, low_bits
,
6888 contents
+ rel
->r_offset
);
6889 bfd_put_32 (input_bfd
, high_bits
,
6890 contents
+ rel
->r_offset
+ 4);
6894 if (!mips_elf_perform_relocation (info
, howto
, rel
, addend
,
6895 input_bfd
, input_section
,
6900 /* Go on to the next relocation. */
6904 /* In the N32 and 64-bit ABIs there may be multiple consecutive
6905 relocations for the same offset. In that case we are
6906 supposed to treat the output of each relocation as the addend
6908 if (rel
+ 1 < relend
6909 && rel
->r_offset
== rel
[1].r_offset
6910 && ELF32_R_TYPE (rel
[1].r_info
) != R_MIPS_NONE
)
6911 use_saved_addend_p
= true;
6913 use_saved_addend_p
= false;
6915 /* Figure out what value we are supposed to relocate. */
6916 switch (mips_elf_calculate_relocation (output_bfd
,
6929 case bfd_reloc_continue
:
6930 /* There's nothing to do. */
6933 case bfd_reloc_undefined
:
6934 /* mips_elf_calculate_relocation already called the
6935 undefined_symbol callback. There's no real point in
6936 trying to perform the relocation at this point, so we
6937 just skip ahead to the next relocation. */
6940 case bfd_reloc_notsupported
:
6944 case bfd_reloc_overflow
:
6945 if (use_saved_addend_p
)
6946 /* Ignore overflow until we reach the last relocation for
6947 a given location. */
6951 BFD_ASSERT (name
!= NULL
);
6952 if (! ((*info
->callbacks
->reloc_overflow
)
6953 (info
, name
, howto
->name
, (bfd_vma
) 0,
6954 input_bfd
, input_section
, rel
->r_offset
)))
6967 /* If we've got another relocation for the address, keep going
6968 until we reach the last one. */
6969 if (use_saved_addend_p
)
6975 if (r_type
== R_MIPS_64
&& !ABI_64_P (output_bfd
))
6976 /* See the comment above about using R_MIPS_64 in the 32-bit
6977 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
6978 that calculated the right value. Now, however, we
6979 sign-extend the 32-bit result to 64-bits, and store it as a
6980 64-bit value. We are especially generous here in that we
6981 go to extreme lengths to support this usage on systems with
6982 only a 32-bit VMA. */
6988 if (value
& ((bfd_vma
) 1 << 31))
6989 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
6993 /* If we don't know that we have a 64-bit type,
6994 do two separate stores. */
6995 if (bfd_big_endian (input_bfd
))
6997 /* Undo what we did above. */
6999 /* Store the sign-bits (which are most significant)
7001 low_bits
= sign_bits
;
7007 high_bits
= sign_bits
;
7009 bfd_put_32 (input_bfd
, low_bits
,
7010 contents
+ rel
->r_offset
);
7011 bfd_put_32 (input_bfd
, high_bits
,
7012 contents
+ rel
->r_offset
+ 4);
7016 /* Actually perform the relocation. */
7017 if (!mips_elf_perform_relocation (info
, howto
, rel
, value
, input_bfd
,
7018 input_section
, contents
,
7026 /* This hook function is called before the linker writes out a global
7027 symbol. We mark symbols as small common if appropriate. This is
7028 also where we undo the increment of the value for a mips16 symbol. */
7032 _bfd_mips_elf_link_output_symbol_hook (abfd
, info
, name
, sym
, input_sec
)
7033 bfd
*abfd ATTRIBUTE_UNUSED
;
7034 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
7035 const char *name ATTRIBUTE_UNUSED
;
7036 Elf_Internal_Sym
*sym
;
7037 asection
*input_sec
;
7039 /* If we see a common symbol, which implies a relocatable link, then
7040 if a symbol was small common in an input file, mark it as small
7041 common in the output file. */
7042 if (sym
->st_shndx
== SHN_COMMON
7043 && strcmp (input_sec
->name
, ".scommon") == 0)
7044 sym
->st_shndx
= SHN_MIPS_SCOMMON
;
7046 if (sym
->st_other
== STO_MIPS16
7047 && (sym
->st_value
& 1) != 0)
7053 /* Functions for the dynamic linker. */
7055 /* The name of the dynamic interpreter. This is put in the .interp
7058 #define ELF_DYNAMIC_INTERPRETER(abfd) \
7059 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
7060 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
7061 : "/usr/lib/libc.so.1")
7063 /* Create dynamic sections when linking against a dynamic object. */
7066 _bfd_mips_elf_create_dynamic_sections (abfd
, info
)
7068 struct bfd_link_info
*info
;
7070 struct elf_link_hash_entry
*h
;
7072 register asection
*s
;
7073 const char * const *namep
;
7075 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
7076 | SEC_LINKER_CREATED
| SEC_READONLY
);
7078 /* Mips ABI requests the .dynamic section to be read only. */
7079 s
= bfd_get_section_by_name (abfd
, ".dynamic");
7082 if (! bfd_set_section_flags (abfd
, s
, flags
))
7086 /* We need to create .got section. */
7087 if (! mips_elf_create_got_section (abfd
, info
))
7090 /* Create the .msym section on IRIX6. It is used by the dynamic
7091 linker to speed up dynamic relocations, and to avoid computing
7092 the ELF hash for symbols. */
7093 if (IRIX_COMPAT (abfd
) == ict_irix6
7094 && !mips_elf_create_msym_section (abfd
))
7097 /* Create .stub section. */
7098 if (bfd_get_section_by_name (abfd
,
7099 MIPS_ELF_STUB_SECTION_NAME (abfd
)) == NULL
)
7101 s
= bfd_make_section (abfd
, MIPS_ELF_STUB_SECTION_NAME (abfd
));
7103 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_CODE
)
7104 || ! bfd_set_section_alignment (abfd
, s
,
7105 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
7109 if ((IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
7111 && bfd_get_section_by_name (abfd
, ".rld_map") == NULL
)
7113 s
= bfd_make_section (abfd
, ".rld_map");
7115 || ! bfd_set_section_flags (abfd
, s
, flags
& ~SEC_READONLY
)
7116 || ! bfd_set_section_alignment (abfd
, s
,
7117 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
7121 /* On IRIX5, we adjust add some additional symbols and change the
7122 alignments of several sections. There is no ABI documentation
7123 indicating that this is necessary on IRIX6, nor any evidence that
7124 the linker takes such action. */
7125 if (IRIX_COMPAT (abfd
) == ict_irix5
)
7127 for (namep
= mips_elf_dynsym_rtproc_names
; *namep
!= NULL
; namep
++)
7130 if (! (_bfd_generic_link_add_one_symbol
7131 (info
, abfd
, *namep
, BSF_GLOBAL
, bfd_und_section_ptr
,
7132 (bfd_vma
) 0, (const char *) NULL
, false,
7133 get_elf_backend_data (abfd
)->collect
,
7134 (struct bfd_link_hash_entry
**) &h
)))
7136 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
7137 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
7138 h
->type
= STT_SECTION
;
7140 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
7144 /* We need to create a .compact_rel section. */
7145 if (SGI_COMPAT (abfd
))
7147 if (!mips_elf_create_compact_rel_section (abfd
, info
))
7151 /* Change aligments of some sections. */
7152 s
= bfd_get_section_by_name (abfd
, ".hash");
7154 bfd_set_section_alignment (abfd
, s
, 4);
7155 s
= bfd_get_section_by_name (abfd
, ".dynsym");
7157 bfd_set_section_alignment (abfd
, s
, 4);
7158 s
= bfd_get_section_by_name (abfd
, ".dynstr");
7160 bfd_set_section_alignment (abfd
, s
, 4);
7161 s
= bfd_get_section_by_name (abfd
, ".reginfo");
7163 bfd_set_section_alignment (abfd
, s
, 4);
7164 s
= bfd_get_section_by_name (abfd
, ".dynamic");
7166 bfd_set_section_alignment (abfd
, s
, 4);
7172 if (SGI_COMPAT (abfd
))
7174 if (!(_bfd_generic_link_add_one_symbol
7175 (info
, abfd
, "_DYNAMIC_LINK", BSF_GLOBAL
, bfd_abs_section_ptr
,
7176 (bfd_vma
) 0, (const char *) NULL
, false,
7177 get_elf_backend_data (abfd
)->collect
,
7178 (struct bfd_link_hash_entry
**) &h
)))
7183 /* For normal mips it is _DYNAMIC_LINKING. */
7184 if (!(_bfd_generic_link_add_one_symbol
7185 (info
, abfd
, "_DYNAMIC_LINKING", BSF_GLOBAL
,
7186 bfd_abs_section_ptr
, (bfd_vma
) 0, (const char *) NULL
, false,
7187 get_elf_backend_data (abfd
)->collect
,
7188 (struct bfd_link_hash_entry
**) &h
)))
7191 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
7192 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
7193 h
->type
= STT_SECTION
;
7195 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
7198 if (! mips_elf_hash_table (info
)->use_rld_obj_head
)
7200 /* __rld_map is a four byte word located in the .data section
7201 and is filled in by the rtld to contain a pointer to
7202 the _r_debug structure. Its symbol value will be set in
7203 mips_elf_finish_dynamic_symbol. */
7204 s
= bfd_get_section_by_name (abfd
, ".rld_map");
7205 BFD_ASSERT (s
!= NULL
);
7208 if (SGI_COMPAT (abfd
))
7210 if (!(_bfd_generic_link_add_one_symbol
7211 (info
, abfd
, "__rld_map", BSF_GLOBAL
, s
,
7212 (bfd_vma
) 0, (const char *) NULL
, false,
7213 get_elf_backend_data (abfd
)->collect
,
7214 (struct bfd_link_hash_entry
**) &h
)))
7219 /* For normal mips the symbol is __RLD_MAP. */
7220 if (!(_bfd_generic_link_add_one_symbol
7221 (info
, abfd
, "__RLD_MAP", BSF_GLOBAL
, s
,
7222 (bfd_vma
) 0, (const char *) NULL
, false,
7223 get_elf_backend_data (abfd
)->collect
,
7224 (struct bfd_link_hash_entry
**) &h
)))
7227 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
7228 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
7229 h
->type
= STT_OBJECT
;
7231 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
7239 /* Create the .compact_rel section. */
7242 mips_elf_create_compact_rel_section (abfd
, info
)
7244 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
7247 register asection
*s
;
7249 if (bfd_get_section_by_name (abfd
, ".compact_rel") == NULL
)
7251 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
7254 s
= bfd_make_section (abfd
, ".compact_rel");
7256 || ! bfd_set_section_flags (abfd
, s
, flags
)
7257 || ! bfd_set_section_alignment (abfd
, s
,
7258 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
7261 s
->_raw_size
= sizeof (Elf32_External_compact_rel
);
7267 /* Create the .got section to hold the global offset table. */
7270 mips_elf_create_got_section (abfd
, info
)
7272 struct bfd_link_info
*info
;
7275 register asection
*s
;
7276 struct elf_link_hash_entry
*h
;
7277 struct mips_got_info
*g
;
7279 /* This function may be called more than once. */
7280 if (mips_elf_got_section (abfd
))
7283 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
7284 | SEC_LINKER_CREATED
);
7286 s
= bfd_make_section (abfd
, ".got");
7288 || ! bfd_set_section_flags (abfd
, s
, flags
)
7289 || ! bfd_set_section_alignment (abfd
, s
, 4))
7292 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
7293 linker script because we don't want to define the symbol if we
7294 are not creating a global offset table. */
7296 if (! (_bfd_generic_link_add_one_symbol
7297 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
7298 (bfd_vma
) 0, (const char *) NULL
, false,
7299 get_elf_backend_data (abfd
)->collect
,
7300 (struct bfd_link_hash_entry
**) &h
)))
7302 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
7303 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
7304 h
->type
= STT_OBJECT
;
7307 && ! bfd_elf32_link_record_dynamic_symbol (info
, h
))
7310 /* The first several global offset table entries are reserved. */
7311 s
->_raw_size
= MIPS_RESERVED_GOTNO
* MIPS_ELF_GOT_SIZE (abfd
);
7313 g
= (struct mips_got_info
*) bfd_alloc (abfd
,
7314 sizeof (struct mips_got_info
));
7317 g
->global_gotsym
= NULL
;
7318 g
->local_gotno
= MIPS_RESERVED_GOTNO
;
7319 g
->assigned_gotno
= MIPS_RESERVED_GOTNO
;
7320 if (elf_section_data (s
) == NULL
)
7323 (PTR
) bfd_zalloc (abfd
, sizeof (struct bfd_elf_section_data
));
7324 if (elf_section_data (s
) == NULL
)
7327 elf_section_data (s
)->tdata
= (PTR
) g
;
7328 elf_section_data (s
)->this_hdr
.sh_flags
7329 |= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
7334 /* Returns the .msym section for ABFD, creating it if it does not
7335 already exist. Returns NULL to indicate error. */
7338 mips_elf_create_msym_section (abfd
)
7343 s
= bfd_get_section_by_name (abfd
, MIPS_ELF_MSYM_SECTION_NAME (abfd
));
7346 s
= bfd_make_section (abfd
, MIPS_ELF_MSYM_SECTION_NAME (abfd
));
7348 || !bfd_set_section_flags (abfd
, s
,
7352 | SEC_LINKER_CREATED
7354 || !bfd_set_section_alignment (abfd
, s
,
7355 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
7362 /* Add room for N relocations to the .rel.dyn section in ABFD. */
7365 mips_elf_allocate_dynamic_relocations (abfd
, n
)
7371 s
= bfd_get_section_by_name (abfd
, MIPS_ELF_REL_DYN_SECTION_NAME (abfd
));
7372 BFD_ASSERT (s
!= NULL
);
7374 if (s
->_raw_size
== 0)
7376 /* Make room for a null element. */
7377 s
->_raw_size
+= MIPS_ELF_REL_SIZE (abfd
);
7380 s
->_raw_size
+= n
* MIPS_ELF_REL_SIZE (abfd
);
7383 /* Look through the relocs for a section during the first phase, and
7384 allocate space in the global offset table. */
7387 _bfd_mips_elf_check_relocs (abfd
, info
, sec
, relocs
)
7389 struct bfd_link_info
*info
;
7391 const Elf_Internal_Rela
*relocs
;
7395 Elf_Internal_Shdr
*symtab_hdr
;
7396 struct elf_link_hash_entry
**sym_hashes
;
7397 struct mips_got_info
*g
;
7399 const Elf_Internal_Rela
*rel
;
7400 const Elf_Internal_Rela
*rel_end
;
7403 struct elf_backend_data
*bed
;
7405 if (info
->relocateable
)
7408 dynobj
= elf_hash_table (info
)->dynobj
;
7409 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7410 sym_hashes
= elf_sym_hashes (abfd
);
7411 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
7413 /* Check for the mips16 stub sections. */
7415 name
= bfd_get_section_name (abfd
, sec
);
7416 if (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0)
7418 unsigned long r_symndx
;
7420 /* Look at the relocation information to figure out which symbol
7423 r_symndx
= ELF32_R_SYM (relocs
->r_info
);
7425 if (r_symndx
< extsymoff
7426 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
7430 /* This stub is for a local symbol. This stub will only be
7431 needed if there is some relocation in this BFD, other
7432 than a 16 bit function call, which refers to this symbol. */
7433 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
7435 Elf_Internal_Rela
*sec_relocs
;
7436 const Elf_Internal_Rela
*r
, *rend
;
7438 /* We can ignore stub sections when looking for relocs. */
7439 if ((o
->flags
& SEC_RELOC
) == 0
7440 || o
->reloc_count
== 0
7441 || strncmp (bfd_get_section_name (abfd
, o
), FN_STUB
,
7442 sizeof FN_STUB
- 1) == 0
7443 || strncmp (bfd_get_section_name (abfd
, o
), CALL_STUB
,
7444 sizeof CALL_STUB
- 1) == 0
7445 || strncmp (bfd_get_section_name (abfd
, o
), CALL_FP_STUB
,
7446 sizeof CALL_FP_STUB
- 1) == 0)
7449 sec_relocs
= (_bfd_elf32_link_read_relocs
7450 (abfd
, o
, (PTR
) NULL
,
7451 (Elf_Internal_Rela
*) NULL
,
7452 info
->keep_memory
));
7453 if (sec_relocs
== NULL
)
7456 rend
= sec_relocs
+ o
->reloc_count
;
7457 for (r
= sec_relocs
; r
< rend
; r
++)
7458 if (ELF32_R_SYM (r
->r_info
) == r_symndx
7459 && ELF32_R_TYPE (r
->r_info
) != R_MIPS16_26
)
7462 if (! info
->keep_memory
)
7471 /* There is no non-call reloc for this stub, so we do
7472 not need it. Since this function is called before
7473 the linker maps input sections to output sections, we
7474 can easily discard it by setting the SEC_EXCLUDE
7476 sec
->flags
|= SEC_EXCLUDE
;
7480 /* Record this stub in an array of local symbol stubs for
7482 if (elf_tdata (abfd
)->local_stubs
== NULL
)
7484 unsigned long symcount
;
7487 if (elf_bad_symtab (abfd
))
7488 symcount
= symtab_hdr
->sh_size
/ symtab_hdr
->sh_entsize
;
7490 symcount
= symtab_hdr
->sh_info
;
7491 n
= (asection
**) bfd_zalloc (abfd
,
7492 symcount
* sizeof (asection
*));
7495 elf_tdata (abfd
)->local_stubs
= n
;
7498 elf_tdata (abfd
)->local_stubs
[r_symndx
] = sec
;
7500 /* We don't need to set mips16_stubs_seen in this case.
7501 That flag is used to see whether we need to look through
7502 the global symbol table for stubs. We don't need to set
7503 it here, because we just have a local stub. */
7507 struct mips_elf_link_hash_entry
*h
;
7509 h
= ((struct mips_elf_link_hash_entry
*)
7510 sym_hashes
[r_symndx
- extsymoff
]);
7512 /* H is the symbol this stub is for. */
7515 mips_elf_hash_table (info
)->mips16_stubs_seen
= true;
7518 else if (strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
7519 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
7521 unsigned long r_symndx
;
7522 struct mips_elf_link_hash_entry
*h
;
7525 /* Look at the relocation information to figure out which symbol
7528 r_symndx
= ELF32_R_SYM (relocs
->r_info
);
7530 if (r_symndx
< extsymoff
7531 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
7533 /* This stub was actually built for a static symbol defined
7534 in the same file. We assume that all static symbols in
7535 mips16 code are themselves mips16, so we can simply
7536 discard this stub. Since this function is called before
7537 the linker maps input sections to output sections, we can
7538 easily discard it by setting the SEC_EXCLUDE flag. */
7539 sec
->flags
|= SEC_EXCLUDE
;
7543 h
= ((struct mips_elf_link_hash_entry
*)
7544 sym_hashes
[r_symndx
- extsymoff
]);
7546 /* H is the symbol this stub is for. */
7548 if (strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
7549 loc
= &h
->call_fp_stub
;
7551 loc
= &h
->call_stub
;
7553 /* If we already have an appropriate stub for this function, we
7554 don't need another one, so we can discard this one. Since
7555 this function is called before the linker maps input sections
7556 to output sections, we can easily discard it by setting the
7557 SEC_EXCLUDE flag. We can also discard this section if we
7558 happen to already know that this is a mips16 function; it is
7559 not necessary to check this here, as it is checked later, but
7560 it is slightly faster to check now. */
7561 if (*loc
!= NULL
|| h
->root
.other
== STO_MIPS16
)
7563 sec
->flags
|= SEC_EXCLUDE
;
7568 mips_elf_hash_table (info
)->mips16_stubs_seen
= true;
7578 sgot
= mips_elf_got_section (dynobj
);
7583 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
7584 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
7585 BFD_ASSERT (g
!= NULL
);
7590 bed
= get_elf_backend_data (abfd
);
7591 rel_end
= relocs
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
7592 for (rel
= relocs
; rel
< rel_end
; ++rel
)
7594 unsigned long r_symndx
;
7596 struct elf_link_hash_entry
*h
;
7598 r_symndx
= ELF32_R_SYM (rel
->r_info
);
7599 r_type
= ELF32_R_TYPE (rel
->r_info
);
7601 if (r_symndx
< extsymoff
)
7603 else if (r_symndx
>= extsymoff
+ (symtab_hdr
->sh_size
/ symtab_hdr
->sh_entsize
))
7605 (*_bfd_error_handler
)
7606 (_("Malformed reloc detected for section %s"), name
);
7607 bfd_set_error (bfd_error_bad_value
);
7612 h
= sym_hashes
[r_symndx
- extsymoff
];
7614 /* This may be an indirect symbol created because of a version. */
7617 while (h
->root
.type
== bfd_link_hash_indirect
)
7618 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
7622 /* Some relocs require a global offset table. */
7623 if (dynobj
== NULL
|| sgot
== NULL
)
7629 case R_MIPS_CALL_HI16
:
7630 case R_MIPS_CALL_LO16
:
7631 case R_MIPS_GOT_HI16
:
7632 case R_MIPS_GOT_LO16
:
7633 case R_MIPS_GOT_PAGE
:
7634 case R_MIPS_GOT_OFST
:
7635 case R_MIPS_GOT_DISP
:
7637 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
7638 if (! mips_elf_create_got_section (dynobj
, info
))
7640 g
= mips_elf_got_info (dynobj
, &sgot
);
7647 && (info
->shared
|| h
!= NULL
)
7648 && (sec
->flags
& SEC_ALLOC
) != 0)
7649 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
7657 if (!h
&& (r_type
== R_MIPS_CALL_LO16
7658 || r_type
== R_MIPS_GOT_LO16
7659 || r_type
== R_MIPS_GOT_DISP
))
7661 /* We may need a local GOT entry for this relocation. We
7662 don't count R_MIPS_GOT_PAGE because we can estimate the
7663 maximum number of pages needed by looking at the size of
7664 the segment. Similar comments apply to R_MIPS_GOT16. We
7665 don't count R_MIPS_GOT_HI16, or R_MIPS_CALL_HI16 because
7666 these are always followed by an R_MIPS_GOT_LO16 or
7669 This estimation is very conservative since we can merge
7670 duplicate entries in the GOT. In order to be less
7671 conservative, we could actually build the GOT here,
7672 rather than in relocate_section. */
7674 sgot
->_raw_size
+= MIPS_ELF_GOT_SIZE (dynobj
);
7682 (*_bfd_error_handler
)
7683 (_("%s: CALL16 reloc at 0x%lx not against global symbol"),
7684 bfd_get_filename (abfd
), (unsigned long) rel
->r_offset
);
7685 bfd_set_error (bfd_error_bad_value
);
7690 case R_MIPS_CALL_HI16
:
7691 case R_MIPS_CALL_LO16
:
7694 /* This symbol requires a global offset table entry. */
7695 if (!mips_elf_record_global_got_symbol (h
, info
, g
))
7698 /* We need a stub, not a plt entry for the undefined
7699 function. But we record it as if it needs plt. See
7700 elf_adjust_dynamic_symbol in elflink.h. */
7701 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
7707 case R_MIPS_GOT_HI16
:
7708 case R_MIPS_GOT_LO16
:
7709 case R_MIPS_GOT_DISP
:
7710 /* This symbol requires a global offset table entry. */
7711 if (h
&& !mips_elf_record_global_got_symbol (h
, info
, g
))
7718 if ((info
->shared
|| h
!= NULL
)
7719 && (sec
->flags
& SEC_ALLOC
) != 0)
7723 const char *name
= MIPS_ELF_REL_DYN_SECTION_NAME (dynobj
);
7725 sreloc
= bfd_get_section_by_name (dynobj
, name
);
7728 sreloc
= bfd_make_section (dynobj
, name
);
7730 || ! bfd_set_section_flags (dynobj
, sreloc
,
7735 | SEC_LINKER_CREATED
7737 || ! bfd_set_section_alignment (dynobj
, sreloc
,
7743 /* When creating a shared object, we must copy these
7744 reloc types into the output file as R_MIPS_REL32
7745 relocs. We make room for this reloc in the
7746 .rel.dyn reloc section. */
7747 mips_elf_allocate_dynamic_relocations (dynobj
, 1);
7750 struct mips_elf_link_hash_entry
*hmips
;
7752 /* We only need to copy this reloc if the symbol is
7753 defined in a dynamic object. */
7754 hmips
= (struct mips_elf_link_hash_entry
*) h
;
7755 ++hmips
->possibly_dynamic_relocs
;
7758 /* Even though we don't directly need a GOT entry for
7759 this symbol, a symbol must have a dynamic symbol
7760 table index greater that DT_MIPS_GOTSYM if there are
7761 dynamic relocations against it. */
7763 && !mips_elf_record_global_got_symbol (h
, info
, g
))
7767 if (SGI_COMPAT (abfd
))
7768 mips_elf_hash_table (info
)->compact_rel_size
+=
7769 sizeof (Elf32_External_crinfo
);
7773 case R_MIPS_GPREL16
:
7774 case R_MIPS_LITERAL
:
7775 case R_MIPS_GPREL32
:
7776 if (SGI_COMPAT (abfd
))
7777 mips_elf_hash_table (info
)->compact_rel_size
+=
7778 sizeof (Elf32_External_crinfo
);
7781 /* This relocation describes the C++ object vtable hierarchy.
7782 Reconstruct it for later use during GC. */
7783 case R_MIPS_GNU_VTINHERIT
:
7784 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
7788 /* This relocation describes which C++ vtable entries are actually
7789 used. Record for later use during GC. */
7790 case R_MIPS_GNU_VTENTRY
:
7791 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
7799 /* If this reloc is not a 16 bit call, and it has a global
7800 symbol, then we will need the fn_stub if there is one.
7801 References from a stub section do not count. */
7803 && r_type
!= R_MIPS16_26
7804 && strncmp (bfd_get_section_name (abfd
, sec
), FN_STUB
,
7805 sizeof FN_STUB
- 1) != 0
7806 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_STUB
,
7807 sizeof CALL_STUB
- 1) != 0
7808 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_FP_STUB
,
7809 sizeof CALL_FP_STUB
- 1) != 0)
7811 struct mips_elf_link_hash_entry
*mh
;
7813 mh
= (struct mips_elf_link_hash_entry
*) h
;
7814 mh
->need_fn_stub
= true;
7821 /* Return the section that should be marked against GC for a given
7825 _bfd_mips_elf_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
7827 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
7828 Elf_Internal_Rela
*rel
;
7829 struct elf_link_hash_entry
*h
;
7830 Elf_Internal_Sym
*sym
;
7832 /* ??? Do mips16 stub sections need to be handled special? */
7836 switch (ELF32_R_TYPE (rel
->r_info
))
7838 case R_MIPS_GNU_VTINHERIT
:
7839 case R_MIPS_GNU_VTENTRY
:
7843 switch (h
->root
.type
)
7845 case bfd_link_hash_defined
:
7846 case bfd_link_hash_defweak
:
7847 return h
->root
.u
.def
.section
;
7849 case bfd_link_hash_common
:
7850 return h
->root
.u
.c
.p
->section
;
7859 if (!(elf_bad_symtab (abfd
)
7860 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
7861 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
7862 && sym
->st_shndx
!= SHN_COMMON
))
7864 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
7871 /* Update the got entry reference counts for the section being removed. */
7874 _bfd_mips_elf_gc_sweep_hook (abfd
, info
, sec
, relocs
)
7875 bfd
*abfd ATTRIBUTE_UNUSED
;
7876 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
7877 asection
*sec ATTRIBUTE_UNUSED
;
7878 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
;
7881 Elf_Internal_Shdr
*symtab_hdr
;
7882 struct elf_link_hash_entry
**sym_hashes
;
7883 bfd_signed_vma
*local_got_refcounts
;
7884 const Elf_Internal_Rela
*rel
, *relend
;
7885 unsigned long r_symndx
;
7886 struct elf_link_hash_entry
*h
;
7888 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7889 sym_hashes
= elf_sym_hashes (abfd
);
7890 local_got_refcounts
= elf_local_got_refcounts (abfd
);
7892 relend
= relocs
+ sec
->reloc_count
;
7893 for (rel
= relocs
; rel
< relend
; rel
++)
7894 switch (ELF32_R_TYPE (rel
->r_info
))
7898 case R_MIPS_CALL_HI16
:
7899 case R_MIPS_CALL_LO16
:
7900 case R_MIPS_GOT_HI16
:
7901 case R_MIPS_GOT_LO16
:
7902 /* ??? It would seem that the existing MIPS code does no sort
7903 of reference counting or whatnot on its GOT and PLT entries,
7904 so it is not possible to garbage collect them at this time. */
7915 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
7916 hiding the old indirect symbol. Process additional relocation
7920 _bfd_mips_elf_copy_indirect_symbol (dir
, ind
)
7921 struct elf_link_hash_entry
*dir
, *ind
;
7923 struct mips_elf_link_hash_entry
*dirmips
, *indmips
;
7925 _bfd_elf_link_hash_copy_indirect (dir
, ind
);
7927 dirmips
= (struct mips_elf_link_hash_entry
*) dir
;
7928 indmips
= (struct mips_elf_link_hash_entry
*) ind
;
7929 dirmips
->possibly_dynamic_relocs
+= indmips
->possibly_dynamic_relocs
;
7930 if (dirmips
->min_dyn_reloc_index
== 0
7931 || (indmips
->min_dyn_reloc_index
!= 0
7932 && indmips
->min_dyn_reloc_index
< dirmips
->min_dyn_reloc_index
))
7933 dirmips
->min_dyn_reloc_index
= indmips
->min_dyn_reloc_index
;
7936 /* Adjust a symbol defined by a dynamic object and referenced by a
7937 regular object. The current definition is in some section of the
7938 dynamic object, but we're not including those sections. We have to
7939 change the definition to something the rest of the link can
7943 _bfd_mips_elf_adjust_dynamic_symbol (info
, h
)
7944 struct bfd_link_info
*info
;
7945 struct elf_link_hash_entry
*h
;
7948 struct mips_elf_link_hash_entry
*hmips
;
7951 dynobj
= elf_hash_table (info
)->dynobj
;
7953 /* Make sure we know what is going on here. */
7954 BFD_ASSERT (dynobj
!= NULL
7955 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
7956 || h
->weakdef
!= NULL
7957 || ((h
->elf_link_hash_flags
7958 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
7959 && (h
->elf_link_hash_flags
7960 & ELF_LINK_HASH_REF_REGULAR
) != 0
7961 && (h
->elf_link_hash_flags
7962 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
7964 /* If this symbol is defined in a dynamic object, we need to copy
7965 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
7967 hmips
= (struct mips_elf_link_hash_entry
*) h
;
7968 if (! info
->relocateable
7969 && hmips
->possibly_dynamic_relocs
!= 0
7970 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
7971 mips_elf_allocate_dynamic_relocations (dynobj
,
7972 hmips
->possibly_dynamic_relocs
);
7974 /* For a function, create a stub, if needed. */
7975 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
7977 if (! elf_hash_table (info
)->dynamic_sections_created
)
7980 /* If this symbol is not defined in a regular file, then set
7981 the symbol to the stub location. This is required to make
7982 function pointers compare as equal between the normal
7983 executable and the shared library. */
7984 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
7986 /* We need .stub section. */
7987 s
= bfd_get_section_by_name (dynobj
,
7988 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
7989 BFD_ASSERT (s
!= NULL
);
7991 h
->root
.u
.def
.section
= s
;
7992 h
->root
.u
.def
.value
= s
->_raw_size
;
7994 /* XXX Write this stub address somewhere. */
7995 h
->plt
.offset
= s
->_raw_size
;
7997 /* Make room for this stub code. */
7998 s
->_raw_size
+= MIPS_FUNCTION_STUB_SIZE
;
8000 /* The last half word of the stub will be filled with the index
8001 of this symbol in .dynsym section. */
8005 else if ((h
->type
== STT_FUNC
)
8006 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0)
8008 /* This will set the entry for this symbol in the GOT to 0, and
8009 the dynamic linker will take care of this. */
8010 h
->root
.u
.def
.value
= 0;
8014 /* If this is a weak symbol, and there is a real definition, the
8015 processor independent code will have arranged for us to see the
8016 real definition first, and we can just use the same value. */
8017 if (h
->weakdef
!= NULL
)
8019 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
8020 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
8021 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
8022 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
8026 /* This is a reference to a symbol defined by a dynamic object which
8027 is not a function. */
8032 /* This function is called after all the input files have been read,
8033 and the input sections have been assigned to output sections. We
8034 check for any mips16 stub sections that we can discard. */
8036 static boolean mips_elf_check_mips16_stubs
8037 PARAMS ((struct mips_elf_link_hash_entry
*, PTR
));
8040 _bfd_mips_elf_always_size_sections (output_bfd
, info
)
8042 struct bfd_link_info
*info
;
8046 /* The .reginfo section has a fixed size. */
8047 ri
= bfd_get_section_by_name (output_bfd
, ".reginfo");
8049 bfd_set_section_size (output_bfd
, ri
, sizeof (Elf32_External_RegInfo
));
8051 if (info
->relocateable
8052 || ! mips_elf_hash_table (info
)->mips16_stubs_seen
)
8055 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
8056 mips_elf_check_mips16_stubs
,
8062 /* Check the mips16 stubs for a particular symbol, and see if we can
8067 mips_elf_check_mips16_stubs (h
, data
)
8068 struct mips_elf_link_hash_entry
*h
;
8069 PTR data ATTRIBUTE_UNUSED
;
8071 if (h
->fn_stub
!= NULL
8072 && ! h
->need_fn_stub
)
8074 /* We don't need the fn_stub; the only references to this symbol
8075 are 16 bit calls. Clobber the size to 0 to prevent it from
8076 being included in the link. */
8077 h
->fn_stub
->_raw_size
= 0;
8078 h
->fn_stub
->_cooked_size
= 0;
8079 h
->fn_stub
->flags
&= ~ SEC_RELOC
;
8080 h
->fn_stub
->reloc_count
= 0;
8081 h
->fn_stub
->flags
|= SEC_EXCLUDE
;
8084 if (h
->call_stub
!= NULL
8085 && h
->root
.other
== STO_MIPS16
)
8087 /* We don't need the call_stub; this is a 16 bit function, so
8088 calls from other 16 bit functions are OK. Clobber the size
8089 to 0 to prevent it from being included in the link. */
8090 h
->call_stub
->_raw_size
= 0;
8091 h
->call_stub
->_cooked_size
= 0;
8092 h
->call_stub
->flags
&= ~ SEC_RELOC
;
8093 h
->call_stub
->reloc_count
= 0;
8094 h
->call_stub
->flags
|= SEC_EXCLUDE
;
8097 if (h
->call_fp_stub
!= NULL
8098 && h
->root
.other
== STO_MIPS16
)
8100 /* We don't need the call_stub; this is a 16 bit function, so
8101 calls from other 16 bit functions are OK. Clobber the size
8102 to 0 to prevent it from being included in the link. */
8103 h
->call_fp_stub
->_raw_size
= 0;
8104 h
->call_fp_stub
->_cooked_size
= 0;
8105 h
->call_fp_stub
->flags
&= ~ SEC_RELOC
;
8106 h
->call_fp_stub
->reloc_count
= 0;
8107 h
->call_fp_stub
->flags
|= SEC_EXCLUDE
;
8113 /* Set the sizes of the dynamic sections. */
8116 _bfd_mips_elf_size_dynamic_sections (output_bfd
, info
)
8118 struct bfd_link_info
*info
;
8123 struct mips_got_info
*g
= NULL
;
8125 dynobj
= elf_hash_table (info
)->dynobj
;
8126 BFD_ASSERT (dynobj
!= NULL
);
8128 if (elf_hash_table (info
)->dynamic_sections_created
)
8130 /* Set the contents of the .interp section to the interpreter. */
8133 s
= bfd_get_section_by_name (dynobj
, ".interp");
8134 BFD_ASSERT (s
!= NULL
);
8136 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd
)) + 1;
8138 = (bfd_byte
*) ELF_DYNAMIC_INTERPRETER (output_bfd
);
8142 /* The check_relocs and adjust_dynamic_symbol entry points have
8143 determined the sizes of the various dynamic sections. Allocate
8146 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
8151 /* It's OK to base decisions on the section name, because none
8152 of the dynobj section names depend upon the input files. */
8153 name
= bfd_get_section_name (dynobj
, s
);
8155 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
8160 if (strncmp (name
, ".rel", 4) == 0)
8162 if (s
->_raw_size
== 0)
8164 /* We only strip the section if the output section name
8165 has the same name. Otherwise, there might be several
8166 input sections for this output section. FIXME: This
8167 code is probably not needed these days anyhow, since
8168 the linker now does not create empty output sections. */
8169 if (s
->output_section
!= NULL
8171 bfd_get_section_name (s
->output_section
->owner
,
8172 s
->output_section
)) == 0)
8177 const char *outname
;
8180 /* If this relocation section applies to a read only
8181 section, then we probably need a DT_TEXTREL entry.
8182 If the relocation section is .rel.dyn, we always
8183 assert a DT_TEXTREL entry rather than testing whether
8184 there exists a relocation to a read only section or
8186 outname
= bfd_get_section_name (output_bfd
,
8188 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
8190 && (target
->flags
& SEC_READONLY
) != 0
8191 && (target
->flags
& SEC_ALLOC
) != 0)
8193 MIPS_ELF_REL_DYN_SECTION_NAME (output_bfd
)) == 0)
8196 /* We use the reloc_count field as a counter if we need
8197 to copy relocs into the output file. */
8199 MIPS_ELF_REL_DYN_SECTION_NAME (output_bfd
)) != 0)
8203 else if (strncmp (name
, ".got", 4) == 0)
8206 bfd_size_type loadable_size
= 0;
8207 bfd_size_type local_gotno
;
8210 BFD_ASSERT (elf_section_data (s
) != NULL
);
8211 g
= (struct mips_got_info
*) elf_section_data (s
)->tdata
;
8212 BFD_ASSERT (g
!= NULL
);
8214 /* Calculate the total loadable size of the output. That
8215 will give us the maximum number of GOT_PAGE entries
8217 for (sub
= info
->input_bfds
; sub
; sub
= sub
->link_next
)
8219 asection
*subsection
;
8221 for (subsection
= sub
->sections
;
8223 subsection
= subsection
->next
)
8225 if ((subsection
->flags
& SEC_ALLOC
) == 0)
8227 loadable_size
+= (subsection
->_raw_size
+ 0xf) & ~0xf;
8230 loadable_size
+= MIPS_FUNCTION_STUB_SIZE
;
8232 /* Assume there are two loadable segments consisting of
8233 contiguous sections. Is 5 enough? */
8234 local_gotno
= (loadable_size
>> 16) + 5;
8235 if (IRIX_COMPAT (output_bfd
) == ict_irix6
)
8236 /* It's possible we will need GOT_PAGE entries as well as
8237 GOT16 entries. Often, these will be able to share GOT
8238 entries, but not always. */
8241 g
->local_gotno
+= local_gotno
;
8242 s
->_raw_size
+= local_gotno
* MIPS_ELF_GOT_SIZE (dynobj
);
8244 /* There has to be a global GOT entry for every symbol with
8245 a dynamic symbol table index of DT_MIPS_GOTSYM or
8246 higher. Therefore, it make sense to put those symbols
8247 that need GOT entries at the end of the symbol table. We
8249 if (!mips_elf_sort_hash_table (info
, 1))
8252 if (g
->global_gotsym
!= NULL
)
8253 i
= elf_hash_table (info
)->dynsymcount
- g
->global_gotsym
->dynindx
;
8255 /* If there are no global symbols, or none requiring
8256 relocations, then GLOBAL_GOTSYM will be NULL. */
8258 g
->global_gotno
= i
;
8259 s
->_raw_size
+= i
* MIPS_ELF_GOT_SIZE (dynobj
);
8261 else if (strcmp (name
, MIPS_ELF_STUB_SECTION_NAME (output_bfd
)) == 0)
8263 /* Irix rld assumes that the function stub isn't at the end
8264 of .text section. So put a dummy. XXX */
8265 s
->_raw_size
+= MIPS_FUNCTION_STUB_SIZE
;
8267 else if (! info
->shared
8268 && ! mips_elf_hash_table (info
)->use_rld_obj_head
8269 && strncmp (name
, ".rld_map", 8) == 0)
8271 /* We add a room for __rld_map. It will be filled in by the
8272 rtld to contain a pointer to the _r_debug structure. */
8275 else if (SGI_COMPAT (output_bfd
)
8276 && strncmp (name
, ".compact_rel", 12) == 0)
8277 s
->_raw_size
+= mips_elf_hash_table (info
)->compact_rel_size
;
8278 else if (strcmp (name
, MIPS_ELF_MSYM_SECTION_NAME (output_bfd
))
8280 s
->_raw_size
= (sizeof (Elf32_External_Msym
)
8281 * (elf_hash_table (info
)->dynsymcount
8282 + bfd_count_sections (output_bfd
)));
8283 else if (strncmp (name
, ".init", 5) != 0)
8285 /* It's not one of our sections, so don't allocate space. */
8291 _bfd_strip_section_from_output (info
, s
);
8295 /* Allocate memory for the section contents. */
8296 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
8297 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
8299 bfd_set_error (bfd_error_no_memory
);
8304 if (elf_hash_table (info
)->dynamic_sections_created
)
8306 /* Add some entries to the .dynamic section. We fill in the
8307 values later, in elf_mips_finish_dynamic_sections, but we
8308 must add the entries now so that we get the correct size for
8309 the .dynamic section. The DT_DEBUG entry is filled in by the
8310 dynamic linker and used by the debugger. */
8313 /* SGI object has the equivalence of DT_DEBUG in the
8314 DT_MIPS_RLD_MAP entry. */
8315 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_MAP
, 0))
8317 if (!SGI_COMPAT (output_bfd
))
8319 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
8325 /* Shared libraries on traditional mips have DT_DEBUG. */
8326 if (!SGI_COMPAT (output_bfd
))
8328 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
8332 if (reltext
&& SGI_COMPAT(output_bfd
))
8334 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_TEXTREL
, 0))
8336 info
->flags
|= DF_TEXTREL
;
8339 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTGOT
, 0))
8342 if (bfd_get_section_by_name (dynobj
,
8343 MIPS_ELF_REL_DYN_SECTION_NAME (dynobj
)))
8345 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_REL
, 0))
8348 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELSZ
, 0))
8351 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELENT
, 0))
8355 if (SGI_COMPAT (output_bfd
))
8357 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_CONFLICTNO
, 0))
8361 if (SGI_COMPAT (output_bfd
))
8363 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LIBLISTNO
, 0))
8367 if (bfd_get_section_by_name (dynobj
, ".conflict") != NULL
)
8369 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_CONFLICT
, 0))
8372 s
= bfd_get_section_by_name (dynobj
, ".liblist");
8373 BFD_ASSERT (s
!= NULL
);
8375 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LIBLIST
, 0))
8379 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_VERSION
, 0))
8382 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_FLAGS
, 0))
8386 /* Time stamps in executable files are a bad idea. */
8387 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_TIME_STAMP
, 0))
8392 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_ICHECKSUM
, 0))
8397 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_IVERSION
, 0))
8401 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_BASE_ADDRESS
, 0))
8404 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LOCAL_GOTNO
, 0))
8407 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_SYMTABNO
, 0))
8410 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_UNREFEXTNO
, 0))
8413 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_GOTSYM
, 0))
8416 if (IRIX_COMPAT (dynobj
) == ict_irix5
8417 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_HIPAGENO
, 0))
8420 if (IRIX_COMPAT (dynobj
) == ict_irix6
8421 && (bfd_get_section_by_name
8422 (dynobj
, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj
)))
8423 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_OPTIONS
, 0))
8426 if (bfd_get_section_by_name (dynobj
,
8427 MIPS_ELF_MSYM_SECTION_NAME (dynobj
))
8428 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_MSYM
, 0))
8435 /* If NAME is one of the special IRIX6 symbols defined by the linker,
8436 adjust it appropriately now. */
8439 mips_elf_irix6_finish_dynamic_symbol (abfd
, name
, sym
)
8440 bfd
*abfd ATTRIBUTE_UNUSED
;
8442 Elf_Internal_Sym
*sym
;
8444 /* The linker script takes care of providing names and values for
8445 these, but we must place them into the right sections. */
8446 static const char* const text_section_symbols
[] = {
8449 "__dso_displacement",
8451 "__program_header_table",
8455 static const char* const data_section_symbols
[] = {
8463 const char* const *p
;
8466 for (i
= 0; i
< 2; ++i
)
8467 for (p
= (i
== 0) ? text_section_symbols
: data_section_symbols
;
8470 if (strcmp (*p
, name
) == 0)
8472 /* All of these symbols are given type STT_SECTION by the
8474 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8476 /* The IRIX linker puts these symbols in special sections. */
8478 sym
->st_shndx
= SHN_MIPS_TEXT
;
8480 sym
->st_shndx
= SHN_MIPS_DATA
;
8486 /* Finish up dynamic symbol handling. We set the contents of various
8487 dynamic sections here. */
8490 _bfd_mips_elf_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
8492 struct bfd_link_info
*info
;
8493 struct elf_link_hash_entry
*h
;
8494 Elf_Internal_Sym
*sym
;
8500 struct mips_got_info
*g
;
8502 struct mips_elf_link_hash_entry
*mh
;
8504 dynobj
= elf_hash_table (info
)->dynobj
;
8505 gval
= sym
->st_value
;
8506 mh
= (struct mips_elf_link_hash_entry
*) h
;
8508 if (h
->plt
.offset
!= (bfd_vma
) -1)
8512 bfd_byte stub
[MIPS_FUNCTION_STUB_SIZE
];
8514 /* This symbol has a stub. Set it up. */
8516 BFD_ASSERT (h
->dynindx
!= -1);
8518 s
= bfd_get_section_by_name (dynobj
,
8519 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
8520 BFD_ASSERT (s
!= NULL
);
8522 /* Fill the stub. */
8524 bfd_put_32 (output_bfd
, STUB_LW(output_bfd
), p
);
8526 bfd_put_32 (output_bfd
, STUB_MOVE(output_bfd
), p
);
8529 /* FIXME: Can h->dynindex be more than 64K? */
8530 if (h
->dynindx
& 0xffff0000)
8533 bfd_put_32 (output_bfd
, STUB_JALR
, p
);
8535 bfd_put_32 (output_bfd
, STUB_LI16(output_bfd
) + h
->dynindx
, p
);
8537 BFD_ASSERT (h
->plt
.offset
<= s
->_raw_size
);
8538 memcpy (s
->contents
+ h
->plt
.offset
, stub
, MIPS_FUNCTION_STUB_SIZE
);
8540 /* Mark the symbol as undefined. plt.offset != -1 occurs
8541 only for the referenced symbol. */
8542 sym
->st_shndx
= SHN_UNDEF
;
8544 /* The run-time linker uses the st_value field of the symbol
8545 to reset the global offset table entry for this external
8546 to its stub address when unlinking a shared object. */
8547 gval
= s
->output_section
->vma
+ s
->output_offset
+ h
->plt
.offset
;
8548 sym
->st_value
= gval
;
8551 BFD_ASSERT (h
->dynindx
!= -1
8552 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0);
8554 sgot
= mips_elf_got_section (dynobj
);
8555 BFD_ASSERT (sgot
!= NULL
);
8556 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
8557 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
8558 BFD_ASSERT (g
!= NULL
);
8560 /* Run through the global symbol table, creating GOT entries for all
8561 the symbols that need them. */
8562 if (g
->global_gotsym
!= NULL
8563 && h
->dynindx
>= g
->global_gotsym
->dynindx
)
8569 value
= sym
->st_value
;
8572 /* For an entity defined in a shared object, this will be
8573 NULL. (For functions in shared objects for
8574 which we have created stubs, ST_VALUE will be non-NULL.
8575 That's because such the functions are now no longer defined
8576 in a shared object.) */
8578 if (info
->shared
&& h
->root
.type
== bfd_link_hash_undefined
)
8581 value
= h
->root
.u
.def
.value
;
8583 offset
= mips_elf_global_got_index (dynobj
, h
);
8584 MIPS_ELF_PUT_WORD (output_bfd
, value
, sgot
->contents
+ offset
);
8587 /* Create a .msym entry, if appropriate. */
8588 smsym
= bfd_get_section_by_name (dynobj
,
8589 MIPS_ELF_MSYM_SECTION_NAME (dynobj
));
8592 Elf32_Internal_Msym msym
;
8594 msym
.ms_hash_value
= bfd_elf_hash (h
->root
.root
.string
);
8595 /* It is undocumented what the `1' indicates, but IRIX6 uses
8597 msym
.ms_info
= ELF32_MS_INFO (mh
->min_dyn_reloc_index
, 1);
8598 bfd_mips_elf_swap_msym_out
8600 ((Elf32_External_Msym
*) smsym
->contents
) + h
->dynindx
);
8603 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
8604 name
= h
->root
.root
.string
;
8605 if (strcmp (name
, "_DYNAMIC") == 0
8606 || strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
8607 sym
->st_shndx
= SHN_ABS
;
8608 else if (strcmp (name
, "_DYNAMIC_LINK") == 0
8609 || strcmp (name
, "_DYNAMIC_LINKING") == 0)
8611 sym
->st_shndx
= SHN_ABS
;
8612 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8615 else if (strcmp (name
, "_gp_disp") == 0)
8617 sym
->st_shndx
= SHN_ABS
;
8618 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8619 sym
->st_value
= elf_gp (output_bfd
);
8621 else if (SGI_COMPAT (output_bfd
))
8623 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
8624 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
8626 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8627 sym
->st_other
= STO_PROTECTED
;
8629 sym
->st_shndx
= SHN_MIPS_DATA
;
8631 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
8633 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8634 sym
->st_other
= STO_PROTECTED
;
8635 sym
->st_value
= mips_elf_hash_table (info
)->procedure_count
;
8636 sym
->st_shndx
= SHN_ABS
;
8638 else if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
!= SHN_ABS
)
8640 if (h
->type
== STT_FUNC
)
8641 sym
->st_shndx
= SHN_MIPS_TEXT
;
8642 else if (h
->type
== STT_OBJECT
)
8643 sym
->st_shndx
= SHN_MIPS_DATA
;
8647 /* Handle the IRIX6-specific symbols. */
8648 if (IRIX_COMPAT (output_bfd
) == ict_irix6
)
8649 mips_elf_irix6_finish_dynamic_symbol (output_bfd
, name
, sym
);
8653 if (! mips_elf_hash_table (info
)->use_rld_obj_head
8654 && (strcmp (name
, "__rld_map") == 0
8655 || strcmp (name
, "__RLD_MAP") == 0))
8657 asection
*s
= bfd_get_section_by_name (dynobj
, ".rld_map");
8658 BFD_ASSERT (s
!= NULL
);
8659 sym
->st_value
= s
->output_section
->vma
+ s
->output_offset
;
8660 bfd_put_32 (output_bfd
, (bfd_vma
) 0, s
->contents
);
8661 if (mips_elf_hash_table (info
)->rld_value
== 0)
8662 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
8664 else if (mips_elf_hash_table (info
)->use_rld_obj_head
8665 && strcmp (name
, "__rld_obj_head") == 0)
8667 /* IRIX6 does not use a .rld_map section. */
8668 if (IRIX_COMPAT (output_bfd
) == ict_irix5
8669 || IRIX_COMPAT (output_bfd
) == ict_none
)
8670 BFD_ASSERT (bfd_get_section_by_name (dynobj
, ".rld_map")
8672 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
8676 /* If this is a mips16 symbol, force the value to be even. */
8677 if (sym
->st_other
== STO_MIPS16
8678 && (sym
->st_value
& 1) != 0)
8684 /* Finish up the dynamic sections. */
8687 _bfd_mips_elf_finish_dynamic_sections (output_bfd
, info
)
8689 struct bfd_link_info
*info
;
8694 struct mips_got_info
*g
;
8696 dynobj
= elf_hash_table (info
)->dynobj
;
8698 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
8700 sgot
= mips_elf_got_section (dynobj
);
8705 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
8706 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
8707 BFD_ASSERT (g
!= NULL
);
8710 if (elf_hash_table (info
)->dynamic_sections_created
)
8714 BFD_ASSERT (sdyn
!= NULL
);
8715 BFD_ASSERT (g
!= NULL
);
8717 for (b
= sdyn
->contents
;
8718 b
< sdyn
->contents
+ sdyn
->_raw_size
;
8719 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
8721 Elf_Internal_Dyn dyn
;
8727 /* Read in the current dynamic entry. */
8728 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
8730 /* Assume that we're going to modify it and write it out. */
8736 s
= (bfd_get_section_by_name
8738 MIPS_ELF_REL_DYN_SECTION_NAME (dynobj
)));
8739 BFD_ASSERT (s
!= NULL
);
8740 dyn
.d_un
.d_val
= MIPS_ELF_REL_SIZE (dynobj
);
8744 /* Rewrite DT_STRSZ. */
8746 _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
8752 case DT_MIPS_CONFLICT
:
8755 case DT_MIPS_LIBLIST
:
8758 s
= bfd_get_section_by_name (output_bfd
, name
);
8759 BFD_ASSERT (s
!= NULL
);
8760 dyn
.d_un
.d_ptr
= s
->vma
;
8763 case DT_MIPS_RLD_VERSION
:
8764 dyn
.d_un
.d_val
= 1; /* XXX */
8768 dyn
.d_un
.d_val
= RHF_NOTPOT
; /* XXX */
8771 case DT_MIPS_CONFLICTNO
:
8773 elemsize
= sizeof (Elf32_Conflict
);
8776 case DT_MIPS_LIBLISTNO
:
8778 elemsize
= sizeof (Elf32_Lib
);
8780 s
= bfd_get_section_by_name (output_bfd
, name
);
8783 if (s
->_cooked_size
!= 0)
8784 dyn
.d_un
.d_val
= s
->_cooked_size
/ elemsize
;
8786 dyn
.d_un
.d_val
= s
->_raw_size
/ elemsize
;
8792 case DT_MIPS_TIME_STAMP
:
8793 time ((time_t *) &dyn
.d_un
.d_val
);
8796 case DT_MIPS_ICHECKSUM
:
8801 case DT_MIPS_IVERSION
:
8806 case DT_MIPS_BASE_ADDRESS
:
8807 s
= output_bfd
->sections
;
8808 BFD_ASSERT (s
!= NULL
);
8809 dyn
.d_un
.d_ptr
= s
->vma
& ~(0xffff);
8812 case DT_MIPS_LOCAL_GOTNO
:
8813 dyn
.d_un
.d_val
= g
->local_gotno
;
8816 case DT_MIPS_UNREFEXTNO
:
8817 /* The index into the dynamic symbol table which is the
8818 entry of the first external symbol that is not
8819 referenced within the same object. */
8820 dyn
.d_un
.d_val
= bfd_count_sections (output_bfd
) + 1;
8823 case DT_MIPS_GOTSYM
:
8824 if (g
->global_gotsym
)
8826 dyn
.d_un
.d_val
= g
->global_gotsym
->dynindx
;
8829 /* In case if we don't have global got symbols we default
8830 to setting DT_MIPS_GOTSYM to the same value as
8831 DT_MIPS_SYMTABNO, so we just fall through. */
8833 case DT_MIPS_SYMTABNO
:
8835 elemsize
= MIPS_ELF_SYM_SIZE (output_bfd
);
8836 s
= bfd_get_section_by_name (output_bfd
, name
);
8837 BFD_ASSERT (s
!= NULL
);
8839 if (s
->_cooked_size
!= 0)
8840 dyn
.d_un
.d_val
= s
->_cooked_size
/ elemsize
;
8842 dyn
.d_un
.d_val
= s
->_raw_size
/ elemsize
;
8845 case DT_MIPS_HIPAGENO
:
8846 dyn
.d_un
.d_val
= g
->local_gotno
- MIPS_RESERVED_GOTNO
;
8849 case DT_MIPS_RLD_MAP
:
8850 dyn
.d_un
.d_ptr
= mips_elf_hash_table (info
)->rld_value
;
8853 case DT_MIPS_OPTIONS
:
8854 s
= (bfd_get_section_by_name
8855 (output_bfd
, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd
)));
8856 dyn
.d_un
.d_ptr
= s
->vma
;
8860 s
= (bfd_get_section_by_name
8861 (output_bfd
, MIPS_ELF_MSYM_SECTION_NAME (output_bfd
)));
8862 dyn
.d_un
.d_ptr
= s
->vma
;
8871 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
8876 /* The first entry of the global offset table will be filled at
8877 runtime. The second entry will be used by some runtime loaders.
8878 This isn't the case of Irix rld. */
8879 if (sgot
!= NULL
&& sgot
->_raw_size
> 0)
8881 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
8882 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0x80000001,
8883 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
8887 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
8888 = MIPS_ELF_GOT_SIZE (output_bfd
);
8893 Elf32_compact_rel cpt
;
8895 /* ??? The section symbols for the output sections were set up in
8896 _bfd_elf_final_link. SGI sets the STT_NOTYPE attribute for these
8897 symbols. Should we do so? */
8899 smsym
= bfd_get_section_by_name (dynobj
,
8900 MIPS_ELF_MSYM_SECTION_NAME (dynobj
));
8903 Elf32_Internal_Msym msym
;
8905 msym
.ms_hash_value
= 0;
8906 msym
.ms_info
= ELF32_MS_INFO (0, 1);
8908 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
8910 long dynindx
= elf_section_data (s
)->dynindx
;
8912 bfd_mips_elf_swap_msym_out
8914 (((Elf32_External_Msym
*) smsym
->contents
)
8919 if (SGI_COMPAT (output_bfd
))
8921 /* Write .compact_rel section out. */
8922 s
= bfd_get_section_by_name (dynobj
, ".compact_rel");
8926 cpt
.num
= s
->reloc_count
;
8928 cpt
.offset
= (s
->output_section
->filepos
8929 + sizeof (Elf32_External_compact_rel
));
8932 bfd_elf32_swap_compact_rel_out (output_bfd
, &cpt
,
8933 ((Elf32_External_compact_rel
*)
8936 /* Clean up a dummy stub function entry in .text. */
8937 s
= bfd_get_section_by_name (dynobj
,
8938 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
8941 file_ptr dummy_offset
;
8943 BFD_ASSERT (s
->_raw_size
>= MIPS_FUNCTION_STUB_SIZE
);
8944 dummy_offset
= s
->_raw_size
- MIPS_FUNCTION_STUB_SIZE
;
8945 memset (s
->contents
+ dummy_offset
, 0,
8946 MIPS_FUNCTION_STUB_SIZE
);
8951 /* We need to sort the entries of the dynamic relocation section. */
8953 if (!ABI_64_P (output_bfd
))
8957 reldyn
= bfd_get_section_by_name (dynobj
,
8958 MIPS_ELF_REL_DYN_SECTION_NAME (dynobj
));
8959 if (reldyn
!= NULL
&& reldyn
->reloc_count
> 2)
8961 reldyn_sorting_bfd
= output_bfd
;
8962 qsort ((Elf32_External_Rel
*) reldyn
->contents
+ 1,
8963 (size_t) reldyn
->reloc_count
- 1,
8964 sizeof (Elf32_External_Rel
), sort_dynamic_relocs
);
8968 /* Clean up a first relocation in .rel.dyn. */
8969 s
= bfd_get_section_by_name (dynobj
,
8970 MIPS_ELF_REL_DYN_SECTION_NAME (dynobj
));
8971 if (s
!= NULL
&& s
->_raw_size
> 0)
8972 memset (s
->contents
, 0, MIPS_ELF_REL_SIZE (dynobj
));
8978 /* This is almost identical to bfd_generic_get_... except that some
8979 MIPS relocations need to be handled specially. Sigh. */
8982 elf32_mips_get_relocated_section_contents (abfd
, link_info
, link_order
, data
,
8983 relocateable
, symbols
)
8985 struct bfd_link_info
*link_info
;
8986 struct bfd_link_order
*link_order
;
8988 boolean relocateable
;
8991 /* Get enough memory to hold the stuff */
8992 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
8993 asection
*input_section
= link_order
->u
.indirect
.section
;
8995 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
8996 arelent
**reloc_vector
= NULL
;
9002 reloc_vector
= (arelent
**) bfd_malloc (reloc_size
);
9003 if (reloc_vector
== NULL
&& reloc_size
!= 0)
9006 /* read in the section */
9007 if (!bfd_get_section_contents (input_bfd
,
9011 input_section
->_raw_size
))
9014 /* We're not relaxing the section, so just copy the size info */
9015 input_section
->_cooked_size
= input_section
->_raw_size
;
9016 input_section
->reloc_done
= true;
9018 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
9022 if (reloc_count
< 0)
9025 if (reloc_count
> 0)
9030 bfd_vma gp
= 0x12345678; /* initialize just to shut gcc up */
9033 struct bfd_hash_entry
*h
;
9034 struct bfd_link_hash_entry
*lh
;
9035 /* Skip all this stuff if we aren't mixing formats. */
9036 if (abfd
&& input_bfd
9037 && abfd
->xvec
== input_bfd
->xvec
)
9041 h
= bfd_hash_lookup (&link_info
->hash
->table
, "_gp", false, false);
9042 lh
= (struct bfd_link_hash_entry
*) h
;
9049 case bfd_link_hash_undefined
:
9050 case bfd_link_hash_undefweak
:
9051 case bfd_link_hash_common
:
9054 case bfd_link_hash_defined
:
9055 case bfd_link_hash_defweak
:
9057 gp
= lh
->u
.def
.value
;
9059 case bfd_link_hash_indirect
:
9060 case bfd_link_hash_warning
:
9062 /* @@FIXME ignoring warning for now */
9064 case bfd_link_hash_new
:
9073 for (parent
= reloc_vector
; *parent
!= (arelent
*) NULL
;
9076 char *error_message
= (char *) NULL
;
9077 bfd_reloc_status_type r
;
9079 /* Specific to MIPS: Deal with relocation types that require
9080 knowing the gp of the output bfd. */
9081 asymbol
*sym
= *(*parent
)->sym_ptr_ptr
;
9082 if (bfd_is_abs_section (sym
->section
) && abfd
)
9084 /* The special_function wouldn't get called anyways. */
9088 /* The gp isn't there; let the special function code
9089 fall over on its own. */
9091 else if ((*parent
)->howto
->special_function
9092 == _bfd_mips_elf_gprel16_reloc
)
9094 /* bypass special_function call */
9095 r
= gprel16_with_gp (input_bfd
, sym
, *parent
, input_section
,
9096 relocateable
, (PTR
) data
, gp
);
9097 goto skip_bfd_perform_relocation
;
9099 /* end mips specific stuff */
9101 r
= bfd_perform_relocation (input_bfd
,
9105 relocateable
? abfd
: (bfd
*) NULL
,
9107 skip_bfd_perform_relocation
:
9111 asection
*os
= input_section
->output_section
;
9113 /* A partial link, so keep the relocs */
9114 os
->orelocation
[os
->reloc_count
] = *parent
;
9118 if (r
!= bfd_reloc_ok
)
9122 case bfd_reloc_undefined
:
9123 if (!((*link_info
->callbacks
->undefined_symbol
)
9124 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
9125 input_bfd
, input_section
, (*parent
)->address
,
9129 case bfd_reloc_dangerous
:
9130 BFD_ASSERT (error_message
!= (char *) NULL
);
9131 if (!((*link_info
->callbacks
->reloc_dangerous
)
9132 (link_info
, error_message
, input_bfd
, input_section
,
9133 (*parent
)->address
)))
9136 case bfd_reloc_overflow
:
9137 if (!((*link_info
->callbacks
->reloc_overflow
)
9138 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
9139 (*parent
)->howto
->name
, (*parent
)->addend
,
9140 input_bfd
, input_section
, (*parent
)->address
)))
9143 case bfd_reloc_outofrange
:
9152 if (reloc_vector
!= NULL
)
9153 free (reloc_vector
);
9157 if (reloc_vector
!= NULL
)
9158 free (reloc_vector
);
9161 #define bfd_elf32_bfd_get_relocated_section_contents \
9162 elf32_mips_get_relocated_section_contents
9164 /* ECOFF swapping routines. These are used when dealing with the
9165 .mdebug section, which is in the ECOFF debugging format. */
9166 static const struct ecoff_debug_swap mips_elf32_ecoff_debug_swap
=
9168 /* Symbol table magic number. */
9170 /* Alignment of debugging information. E.g., 4. */
9172 /* Sizes of external symbolic information. */
9173 sizeof (struct hdr_ext
),
9174 sizeof (struct dnr_ext
),
9175 sizeof (struct pdr_ext
),
9176 sizeof (struct sym_ext
),
9177 sizeof (struct opt_ext
),
9178 sizeof (struct fdr_ext
),
9179 sizeof (struct rfd_ext
),
9180 sizeof (struct ext_ext
),
9181 /* Functions to swap in external symbolic data. */
9190 _bfd_ecoff_swap_tir_in
,
9191 _bfd_ecoff_swap_rndx_in
,
9192 /* Functions to swap out external symbolic data. */
9201 _bfd_ecoff_swap_tir_out
,
9202 _bfd_ecoff_swap_rndx_out
,
9203 /* Function to read in symbolic data. */
9204 _bfd_mips_elf_read_ecoff_info
9207 #define TARGET_LITTLE_SYM bfd_elf32_littlemips_vec
9208 #define TARGET_LITTLE_NAME "elf32-littlemips"
9209 #define TARGET_BIG_SYM bfd_elf32_bigmips_vec
9210 #define TARGET_BIG_NAME "elf32-bigmips"
9211 #define ELF_ARCH bfd_arch_mips
9212 #define ELF_MACHINE_CODE EM_MIPS
9214 /* The SVR4 MIPS ABI says that this should be 0x10000, but Irix 5 uses
9215 a value of 0x1000, and we are compatible. */
9216 #define ELF_MAXPAGESIZE 0x1000
9218 #define elf_backend_collect true
9219 #define elf_backend_type_change_ok true
9220 #define elf_backend_can_gc_sections true
9221 #define elf_backend_sign_extend_vma true
9222 #define elf_info_to_howto mips_info_to_howto_rela
9223 #define elf_info_to_howto_rel mips_info_to_howto_rel
9224 #define elf_backend_sym_is_global mips_elf_sym_is_global
9225 #define elf_backend_object_p _bfd_mips_elf_object_p
9226 #define elf_backend_section_from_shdr _bfd_mips_elf_section_from_shdr
9227 #define elf_backend_fake_sections _bfd_mips_elf_fake_sections
9228 #define elf_backend_section_from_bfd_section \
9229 _bfd_mips_elf_section_from_bfd_section
9230 #define elf_backend_section_processing _bfd_mips_elf_section_processing
9231 #define elf_backend_symbol_processing _bfd_mips_elf_symbol_processing
9232 #define elf_backend_additional_program_headers \
9233 _bfd_mips_elf_additional_program_headers
9234 #define elf_backend_modify_segment_map _bfd_mips_elf_modify_segment_map
9235 #define elf_backend_final_write_processing \
9236 _bfd_mips_elf_final_write_processing
9237 #define elf_backend_ecoff_debug_swap &mips_elf32_ecoff_debug_swap
9238 #define elf_backend_add_symbol_hook _bfd_mips_elf_add_symbol_hook
9239 #define elf_backend_create_dynamic_sections \
9240 _bfd_mips_elf_create_dynamic_sections
9241 #define elf_backend_check_relocs _bfd_mips_elf_check_relocs
9242 #define elf_backend_adjust_dynamic_symbol \
9243 _bfd_mips_elf_adjust_dynamic_symbol
9244 #define elf_backend_always_size_sections \
9245 _bfd_mips_elf_always_size_sections
9246 #define elf_backend_size_dynamic_sections \
9247 _bfd_mips_elf_size_dynamic_sections
9248 #define elf_backend_relocate_section _bfd_mips_elf_relocate_section
9249 #define elf_backend_link_output_symbol_hook \
9250 _bfd_mips_elf_link_output_symbol_hook
9251 #define elf_backend_finish_dynamic_symbol \
9252 _bfd_mips_elf_finish_dynamic_symbol
9253 #define elf_backend_finish_dynamic_sections \
9254 _bfd_mips_elf_finish_dynamic_sections
9255 #define elf_backend_gc_mark_hook _bfd_mips_elf_gc_mark_hook
9256 #define elf_backend_gc_sweep_hook _bfd_mips_elf_gc_sweep_hook
9258 #define elf_backend_got_header_size (4*MIPS_RESERVED_GOTNO)
9259 #define elf_backend_plt_header_size 0
9261 #define elf_backend_copy_indirect_symbol \
9262 _bfd_mips_elf_copy_indirect_symbol
9264 #define elf_backend_hide_symbol _bfd_mips_elf_hide_symbol
9266 #define bfd_elf32_bfd_is_local_label_name \
9267 mips_elf_is_local_label_name
9268 #define bfd_elf32_find_nearest_line _bfd_mips_elf_find_nearest_line
9269 #define bfd_elf32_set_section_contents _bfd_mips_elf_set_section_contents
9270 #define bfd_elf32_bfd_link_hash_table_create \
9271 _bfd_mips_elf_link_hash_table_create
9272 #define bfd_elf32_bfd_final_link _bfd_mips_elf_final_link
9273 #define bfd_elf32_bfd_copy_private_bfd_data \
9274 _bfd_mips_elf_copy_private_bfd_data
9275 #define bfd_elf32_bfd_merge_private_bfd_data \
9276 _bfd_mips_elf_merge_private_bfd_data
9277 #define bfd_elf32_bfd_set_private_flags _bfd_mips_elf_set_private_flags
9278 #define bfd_elf32_bfd_print_private_bfd_data \
9279 _bfd_mips_elf_print_private_bfd_data
9280 #include "elf32-target.h"
9282 /* Support for traditional mips targets */
9284 #define INCLUDED_TARGET_FILE /* More a type of flag */
9286 #undef TARGET_LITTLE_SYM
9287 #undef TARGET_LITTLE_NAME
9288 #undef TARGET_BIG_SYM
9289 #undef TARGET_BIG_NAME
9291 #define TARGET_LITTLE_SYM bfd_elf32_tradlittlemips_vec
9292 #define TARGET_LITTLE_NAME "elf32-tradlittlemips"
9293 #define TARGET_BIG_SYM bfd_elf32_tradbigmips_vec
9294 #define TARGET_BIG_NAME "elf32-tradbigmips"
9296 /* Include the target file again for this target */
9297 #include "elf32-target.h"