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>
9 This file is part of BFD, the Binary File Descriptor library.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 /* This file handles MIPS ELF targets. SGI Irix 5 uses a slightly
26 different MIPS ELF from other targets. This matters when linking.
27 This file supports both, switching at runtime. */
37 /* Get the ECOFF swapping routines. */
39 #include "coff/symconst.h"
40 #include "coff/internal.h"
41 #include "coff/ecoff.h"
42 #include "coff/mips.h"
44 #include "ecoffswap.h"
46 /* This structure is used to hold .got information when linking. It
47 is stored in the tdata field of the bfd_elf_section_data structure. */
51 /* The global symbol in the GOT with the lowest index in the dynamic
53 struct elf_link_hash_entry
*global_gotsym
;
54 /* The number of global .got entries. */
55 unsigned int global_gotno
;
56 /* The number of local .got entries. */
57 unsigned int local_gotno
;
58 /* The number of local .got entries we have used. */
59 unsigned int assigned_gotno
;
62 /* The MIPS ELF linker needs additional information for each symbol in
63 the global hash table. */
65 struct mips_elf_link_hash_entry
67 struct elf_link_hash_entry root
;
69 /* External symbol information. */
72 /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
74 unsigned int possibly_dynamic_relocs
;
76 /* The index of the first dynamic relocation (in the .rel.dyn
77 section) against this symbol. */
78 unsigned int min_dyn_reloc_index
;
80 /* If there is a stub that 32 bit functions should use to call this
81 16 bit function, this points to the section containing the stub. */
84 /* Whether we need the fn_stub; this is set if this symbol appears
85 in any relocs other than a 16 bit call. */
88 /* If there is a stub that 16 bit functions should use to call this
89 32 bit function, this points to the section containing the stub. */
92 /* This is like the call_stub field, but it is used if the function
93 being called returns a floating point value. */
94 asection
*call_fp_stub
;
97 static bfd_reloc_status_type mips32_64bit_reloc
98 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
99 static reloc_howto_type
*bfd_elf32_bfd_reloc_type_lookup
100 PARAMS ((bfd
*, bfd_reloc_code_real_type
));
101 static void mips_info_to_howto_rel
102 PARAMS ((bfd
*, arelent
*, Elf32_Internal_Rel
*));
103 static void mips_info_to_howto_rela
104 PARAMS ((bfd
*, arelent
*, Elf32_Internal_Rela
*));
105 static void bfd_mips_elf32_swap_gptab_in
106 PARAMS ((bfd
*, const Elf32_External_gptab
*, Elf32_gptab
*));
107 static void bfd_mips_elf32_swap_gptab_out
108 PARAMS ((bfd
*, const Elf32_gptab
*, Elf32_External_gptab
*));
109 static void bfd_mips_elf_swap_msym_in
110 PARAMS ((bfd
*, const Elf32_External_Msym
*, Elf32_Internal_Msym
*));
111 static void bfd_mips_elf_swap_msym_out
112 PARAMS ((bfd
*, const Elf32_Internal_Msym
*, Elf32_External_Msym
*));
113 static boolean mips_elf_sym_is_global
PARAMS ((bfd
*, asymbol
*));
114 static boolean mips_elf_create_procedure_table
115 PARAMS ((PTR
, bfd
*, struct bfd_link_info
*, asection
*,
116 struct ecoff_debug_info
*));
117 static INLINE
int elf_mips_isa
PARAMS ((flagword
));
118 static INLINE
int elf_mips_mach
PARAMS ((flagword
));
119 static INLINE
char* elf_mips_abi_name
PARAMS ((bfd
*));
120 static boolean mips_elf_is_local_label_name
121 PARAMS ((bfd
*, const char *));
122 static struct bfd_hash_entry
*mips_elf_link_hash_newfunc
123 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
124 static int gptab_compare
PARAMS ((const void *, const void *));
125 static void mips_elf_relocate_hi16
126 PARAMS ((bfd
*, Elf_Internal_Rela
*, Elf_Internal_Rela
*, bfd_byte
*,
128 static boolean mips_elf_relocate_got_local
129 PARAMS ((bfd
*, bfd
*, asection
*, Elf_Internal_Rela
*,
130 Elf_Internal_Rela
*, bfd_byte
*, bfd_vma
));
131 static void mips_elf_relocate_global_got
132 PARAMS ((bfd
*, Elf_Internal_Rela
*, bfd_byte
*, bfd_vma
));
133 static bfd_reloc_status_type mips16_jump_reloc
134 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
135 static bfd_reloc_status_type mips16_gprel_reloc
136 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
137 static boolean mips_elf_create_compact_rel_section
138 PARAMS ((bfd
*, struct bfd_link_info
*));
139 static boolean mips_elf_create_got_section
140 PARAMS ((bfd
*, struct bfd_link_info
*));
141 static bfd_reloc_status_type mips_elf_final_gp
142 PARAMS ((bfd
*, asymbol
*, boolean
, char **, bfd_vma
*));
143 static bfd_byte
*elf32_mips_get_relocated_section_contents
144 PARAMS ((bfd
*, struct bfd_link_info
*, struct bfd_link_order
*,
145 bfd_byte
*, boolean
, asymbol
**));
146 static asection
*mips_elf_create_msym_section
148 static void mips_elf_irix6_finish_dynamic_symbol
149 PARAMS ((bfd
*, const char *, Elf_Internal_Sym
*));
150 static bfd_vma mips_elf_sign_extend
PARAMS ((bfd_vma
, int));
151 static boolean mips_elf_overflow_p
PARAMS ((bfd_vma
, int));
152 static bfd_vma mips_elf_high
PARAMS ((bfd_vma
));
153 static bfd_vma mips_elf_higher
PARAMS ((bfd_vma
));
154 static bfd_vma mips_elf_highest
PARAMS ((bfd_vma
));
155 static bfd_vma mips_elf_global_got_index
156 PARAMS ((bfd
*, struct elf_link_hash_entry
*));
157 static bfd_vma mips_elf_local_got_index
158 PARAMS ((bfd
*, struct bfd_link_info
*, bfd_vma
));
159 static bfd_vma mips_elf_got_offset_from_index
160 PARAMS ((bfd
*, bfd
*, bfd_vma
));
161 static boolean mips_elf_record_global_got_symbol
162 PARAMS ((struct elf_link_hash_entry
*, struct bfd_link_info
*,
163 struct mips_got_info
*));
164 static bfd_vma mips_elf_got_page
165 PARAMS ((bfd
*, struct bfd_link_info
*, bfd_vma
, bfd_vma
*));
166 static boolean mips_elf_next_lo16_addend
167 PARAMS ((const Elf_Internal_Rela
*, const Elf_Internal_Rela
*, bfd_vma
*));
168 static bfd_reloc_status_type mips_elf_calculate_relocation
169 PARAMS ((bfd
*, bfd
*, asection
*, struct bfd_link_info
*,
170 const Elf_Internal_Rela
*, bfd_vma
, reloc_howto_type
*,
171 Elf_Internal_Sym
*, asection
**, bfd_vma
*, const char **,
173 static bfd_vma mips_elf_obtain_contents
174 PARAMS ((reloc_howto_type
*, const Elf_Internal_Rela
*, bfd
*, bfd_byte
*));
175 static boolean mips_elf_perform_relocation
176 PARAMS ((struct bfd_link_info
*, reloc_howto_type
*,
177 const Elf_Internal_Rela
*, bfd_vma
,
178 bfd
*, asection
*, bfd_byte
*, boolean
));
179 static boolean mips_elf_assign_gp
PARAMS ((bfd
*, bfd_vma
*));
180 static boolean mips_elf_sort_hash_table_f
181 PARAMS ((struct mips_elf_link_hash_entry
*, PTR
));
182 static boolean mips_elf_sort_hash_table
183 PARAMS ((struct bfd_link_info
*, unsigned long));
184 static asection
* mips_elf_got_section
PARAMS ((bfd
*));
185 static struct mips_got_info
*mips_elf_got_info
186 PARAMS ((bfd
*, asection
**));
187 static bfd_vma mips_elf_create_local_got_entry
188 PARAMS ((bfd
*, struct mips_got_info
*, asection
*, bfd_vma
));
189 static bfd_vma mips_elf_got16_entry
190 PARAMS ((bfd
*, struct bfd_link_info
*, bfd_vma
));
191 static unsigned int mips_elf_create_dynamic_relocation
192 PARAMS ((bfd
*, struct bfd_link_info
*, const Elf_Internal_Rela
*,
193 long, bfd_vma
, asection
*));
194 static void mips_elf_allocate_dynamic_relocations
195 PARAMS ((bfd
*, unsigned int));
196 static boolean mips_elf_stub_section_p
197 PARAMS ((bfd
*, asection
*));
199 /* The level of IRIX compatibility we're striving for. */
207 /* Nonzero if ABFD is using the N32 ABI. */
209 #define ABI_N32_P(abfd) \
210 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
212 /* Nonzero if ABFD is using the 64-bit ABI. FIXME: This is never
214 #define ABI_64_P(abfd) \
215 ((elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64) != 0)
217 /* What version of Irix we are trying to be compatible with. FIXME:
218 At the moment, we never generate "normal" MIPS ELF ABI executables;
219 we always use some version of Irix. */
221 #define IRIX_COMPAT(abfd) \
222 ((ABI_N32_P (abfd) || ABI_64_P (abfd)) ? ict_irix6 : ict_irix5)
224 /* Whether we are trying to be compatible with IRIX at all. */
226 #define SGI_COMPAT(abfd) \
227 (IRIX_COMPAT (abfd) != ict_none)
229 /* The name of the msym section. */
230 #define MIPS_ELF_MSYM_SECTION_NAME(abfd) ".msym"
232 /* The name of the srdata section. */
233 #define MIPS_ELF_SRDATA_SECTION_NAME(abfd) ".srdata"
235 /* The name of the options section. */
236 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
237 (IRIX_COMPAT (abfd) == ict_irix6 ? ".MIPS.options" : ".options")
239 /* The name of the stub section. */
240 #define MIPS_ELF_STUB_SECTION_NAME(abfd) \
241 (IRIX_COMPAT (abfd) == ict_irix6 ? ".MIPS.stubs" : ".stub")
243 /* The name of the dynamic relocation section. */
244 #define MIPS_ELF_REL_DYN_SECTION_NAME(abfd) ".rel.dyn"
246 /* The size of an external REL relocation. */
247 #define MIPS_ELF_REL_SIZE(abfd) \
248 (get_elf_backend_data (abfd)->s->sizeof_rel)
250 /* The size of an external dynamic table entry. */
251 #define MIPS_ELF_DYN_SIZE(abfd) \
252 (get_elf_backend_data (abfd)->s->sizeof_dyn)
254 /* The size of a GOT entry. */
255 #define MIPS_ELF_GOT_SIZE(abfd) \
256 (get_elf_backend_data (abfd)->s->arch_size / 8)
258 /* The size of a symbol-table entry. */
259 #define MIPS_ELF_SYM_SIZE(abfd) \
260 (get_elf_backend_data (abfd)->s->sizeof_sym)
262 /* The default alignment for sections, as a power of two. */
263 #define MIPS_ELF_LOG_FILE_ALIGN(abfd) \
264 (get_elf_backend_data (abfd)->s->file_align == 8 ? 3 : 2)
266 /* Get word-sized data. */
267 #define MIPS_ELF_GET_WORD(abfd, ptr) \
268 (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
270 /* Put out word-sized data. */
271 #define MIPS_ELF_PUT_WORD(abfd, val, ptr) \
273 ? bfd_put_64 (abfd, val, ptr) \
274 : bfd_put_32 (abfd, val, ptr))
276 /* Add a dynamic symbol table-entry. */
278 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
279 (ABI_64_P (elf_hash_table (info)->dynobj) \
280 ? bfd_elf64_add_dynamic_entry (info, tag, val) \
281 : bfd_elf32_add_dynamic_entry (info, tag, val))
283 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
284 (ABI_64_P (elf_hash_table (info)->dynobj) \
285 ? (abort (), false) \
286 : bfd_elf32_add_dynamic_entry (info, tag, val))
289 /* The number of local .got entries we reserve. */
290 #define MIPS_RESERVED_GOTNO (2)
292 /* Instructions which appear in a stub. For some reason the stub is
293 slightly different on an SGI system. */
294 #define ELF_MIPS_GP_OFFSET(abfd) (SGI_COMPAT (abfd) ? 0x7ff0 : 0x8000)
295 #define STUB_LW(abfd) \
298 ? 0xdf998010 /* ld t9,0x8010(gp) */ \
299 : 0x8f998010) /* lw t9,0x8010(gp) */ \
300 : 0x8f998000) /* lw t9,0x8000(gp) */
301 #define STUB_MOVE 0x03e07825 /* move t7,ra */
302 #define STUB_JALR 0x0320f809 /* jal t9 */
303 #define STUB_LI16 0x34180000 /* ori t8,zero,0 */
304 #define MIPS_FUNCTION_STUB_SIZE (16)
307 /* We no longer try to identify particular sections for the .dynsym
308 section. When we do, we wind up crashing if there are other random
309 sections with relocations. */
311 /* Names of sections which appear in the .dynsym section in an Irix 5
314 static const char * const mips_elf_dynsym_sec_names
[] =
327 #define SIZEOF_MIPS_DYNSYM_SECNAMES \
328 (sizeof mips_elf_dynsym_sec_names / sizeof mips_elf_dynsym_sec_names[0])
330 /* The number of entries in mips_elf_dynsym_sec_names which go in the
333 #define MIPS_TEXT_DYNSYM_SECNO (3)
337 /* The names of the runtime procedure table symbols used on Irix 5. */
339 static const char * const mips_elf_dynsym_rtproc_names
[] =
342 "_procedure_string_table",
343 "_procedure_table_size",
347 /* These structures are used to generate the .compact_rel section on
352 unsigned long id1
; /* Always one? */
353 unsigned long num
; /* Number of compact relocation entries. */
354 unsigned long id2
; /* Always two? */
355 unsigned long offset
; /* The file offset of the first relocation. */
356 unsigned long reserved0
; /* Zero? */
357 unsigned long reserved1
; /* Zero? */
366 bfd_byte reserved0
[4];
367 bfd_byte reserved1
[4];
368 } Elf32_External_compact_rel
;
372 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
373 unsigned int rtype
: 4; /* Relocation types. See below. */
374 unsigned int dist2to
: 8;
375 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
376 unsigned long konst
; /* KONST field. See below. */
377 unsigned long vaddr
; /* VADDR to be relocated. */
382 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
383 unsigned int rtype
: 4; /* Relocation types. See below. */
384 unsigned int dist2to
: 8;
385 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
386 unsigned long konst
; /* KONST field. See below. */
394 } Elf32_External_crinfo
;
400 } Elf32_External_crinfo2
;
402 /* These are the constants used to swap the bitfields in a crinfo. */
404 #define CRINFO_CTYPE (0x1)
405 #define CRINFO_CTYPE_SH (31)
406 #define CRINFO_RTYPE (0xf)
407 #define CRINFO_RTYPE_SH (27)
408 #define CRINFO_DIST2TO (0xff)
409 #define CRINFO_DIST2TO_SH (19)
410 #define CRINFO_RELVADDR (0x7ffff)
411 #define CRINFO_RELVADDR_SH (0)
413 /* A compact relocation info has long (3 words) or short (2 words)
414 formats. A short format doesn't have VADDR field and relvaddr
415 fields contains ((VADDR - vaddr of the previous entry) >> 2). */
416 #define CRF_MIPS_LONG 1
417 #define CRF_MIPS_SHORT 0
419 /* There are 4 types of compact relocation at least. The value KONST
420 has different meaning for each type:
423 CT_MIPS_REL32 Address in data
424 CT_MIPS_WORD Address in word (XXX)
425 CT_MIPS_GPHI_LO GP - vaddr
426 CT_MIPS_JMPAD Address to jump
429 #define CRT_MIPS_REL32 0xa
430 #define CRT_MIPS_WORD 0xb
431 #define CRT_MIPS_GPHI_LO 0xc
432 #define CRT_MIPS_JMPAD 0xd
434 #define mips_elf_set_cr_format(x,format) ((x).ctype = (format))
435 #define mips_elf_set_cr_type(x,type) ((x).rtype = (type))
436 #define mips_elf_set_cr_dist2to(x,v) ((x).dist2to = (v))
437 #define mips_elf_set_cr_relvaddr(x,d) ((x).relvaddr = (d)<<2)
439 static void bfd_elf32_swap_compact_rel_out
440 PARAMS ((bfd
*, const Elf32_compact_rel
*, Elf32_External_compact_rel
*));
441 static void bfd_elf32_swap_crinfo_out
442 PARAMS ((bfd
*, const Elf32_crinfo
*, Elf32_External_crinfo
*));
444 #define USE_REL 1 /* MIPS uses REL relocations instead of RELA */
446 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
447 from smaller values. Start with zero, widen, *then* decrement. */
448 #define MINUS_ONE (((bfd_vma)0) - 1)
450 static reloc_howto_type elf_mips_howto_table
[] =
453 HOWTO (R_MIPS_NONE
, /* type */
455 0, /* size (0 = byte, 1 = short, 2 = long) */
457 false, /* pc_relative */
459 complain_overflow_dont
, /* complain_on_overflow */
460 bfd_elf_generic_reloc
, /* special_function */
461 "R_MIPS_NONE", /* name */
462 false, /* partial_inplace */
465 false), /* pcrel_offset */
467 /* 16 bit relocation. */
468 HOWTO (R_MIPS_16
, /* type */
470 1, /* size (0 = byte, 1 = short, 2 = long) */
472 false, /* pc_relative */
474 complain_overflow_bitfield
, /* complain_on_overflow */
475 bfd_elf_generic_reloc
, /* special_function */
476 "R_MIPS_16", /* name */
477 true, /* partial_inplace */
478 0xffff, /* src_mask */
479 0xffff, /* dst_mask */
480 false), /* pcrel_offset */
482 /* 32 bit relocation. */
483 HOWTO (R_MIPS_32
, /* type */
485 2, /* size (0 = byte, 1 = short, 2 = long) */
487 false, /* pc_relative */
489 complain_overflow_bitfield
, /* complain_on_overflow */
490 bfd_elf_generic_reloc
, /* special_function */
491 "R_MIPS_32", /* name */
492 true, /* partial_inplace */
493 0xffffffff, /* src_mask */
494 0xffffffff, /* dst_mask */
495 false), /* pcrel_offset */
497 /* 32 bit symbol relative relocation. */
498 HOWTO (R_MIPS_REL32
, /* type */
500 2, /* size (0 = byte, 1 = short, 2 = long) */
502 false, /* pc_relative */
504 complain_overflow_bitfield
, /* complain_on_overflow */
505 bfd_elf_generic_reloc
, /* special_function */
506 "R_MIPS_REL32", /* name */
507 true, /* partial_inplace */
508 0xffffffff, /* src_mask */
509 0xffffffff, /* dst_mask */
510 false), /* pcrel_offset */
512 /* 26 bit branch address. */
513 HOWTO (R_MIPS_26
, /* type */
515 2, /* size (0 = byte, 1 = short, 2 = long) */
517 false, /* pc_relative */
519 complain_overflow_dont
, /* complain_on_overflow */
520 /* This needs complex overflow
521 detection, because the upper four
522 bits must match the PC. */
523 bfd_elf_generic_reloc
, /* special_function */
524 "R_MIPS_26", /* name */
525 true, /* partial_inplace */
526 0x3ffffff, /* src_mask */
527 0x3ffffff, /* dst_mask */
528 false), /* pcrel_offset */
530 /* High 16 bits of symbol value. */
531 HOWTO (R_MIPS_HI16
, /* type */
533 2, /* size (0 = byte, 1 = short, 2 = long) */
535 false, /* pc_relative */
537 complain_overflow_dont
, /* complain_on_overflow */
538 _bfd_mips_elf_hi16_reloc
, /* special_function */
539 "R_MIPS_HI16", /* name */
540 true, /* partial_inplace */
541 0xffff, /* src_mask */
542 0xffff, /* dst_mask */
543 false), /* pcrel_offset */
545 /* Low 16 bits of symbol value. */
546 HOWTO (R_MIPS_LO16
, /* type */
548 2, /* size (0 = byte, 1 = short, 2 = long) */
550 false, /* pc_relative */
552 complain_overflow_dont
, /* complain_on_overflow */
553 _bfd_mips_elf_lo16_reloc
, /* special_function */
554 "R_MIPS_LO16", /* name */
555 true, /* partial_inplace */
556 0xffff, /* src_mask */
557 0xffff, /* dst_mask */
558 false), /* pcrel_offset */
560 /* GP relative reference. */
561 HOWTO (R_MIPS_GPREL16
, /* type */
563 2, /* size (0 = byte, 1 = short, 2 = long) */
565 false, /* pc_relative */
567 complain_overflow_signed
, /* complain_on_overflow */
568 _bfd_mips_elf_gprel16_reloc
, /* special_function */
569 "R_MIPS_GPREL16", /* name */
570 true, /* partial_inplace */
571 0xffff, /* src_mask */
572 0xffff, /* dst_mask */
573 false), /* pcrel_offset */
575 /* Reference to literal section. */
576 HOWTO (R_MIPS_LITERAL
, /* type */
578 2, /* size (0 = byte, 1 = short, 2 = long) */
580 false, /* pc_relative */
582 complain_overflow_signed
, /* complain_on_overflow */
583 _bfd_mips_elf_gprel16_reloc
, /* special_function */
584 "R_MIPS_LITERAL", /* name */
585 true, /* partial_inplace */
586 0xffff, /* src_mask */
587 0xffff, /* dst_mask */
588 false), /* pcrel_offset */
590 /* Reference to global offset table. */
591 HOWTO (R_MIPS_GOT16
, /* type */
593 2, /* size (0 = byte, 1 = short, 2 = long) */
595 false, /* pc_relative */
597 complain_overflow_signed
, /* complain_on_overflow */
598 _bfd_mips_elf_got16_reloc
, /* special_function */
599 "R_MIPS_GOT16", /* name */
600 false, /* partial_inplace */
602 0xffff, /* dst_mask */
603 false), /* pcrel_offset */
605 /* 16 bit PC relative reference. */
606 HOWTO (R_MIPS_PC16
, /* type */
608 2, /* size (0 = byte, 1 = short, 2 = long) */
610 true, /* pc_relative */
612 complain_overflow_signed
, /* complain_on_overflow */
613 bfd_elf_generic_reloc
, /* special_function */
614 "R_MIPS_PC16", /* name */
615 true, /* partial_inplace */
616 0xffff, /* src_mask */
617 0xffff, /* dst_mask */
618 false), /* pcrel_offset */
620 /* 16 bit call through global offset table. */
621 HOWTO (R_MIPS_CALL16
, /* type */
623 2, /* size (0 = byte, 1 = short, 2 = long) */
625 false, /* pc_relative */
627 complain_overflow_signed
, /* complain_on_overflow */
628 bfd_elf_generic_reloc
, /* special_function */
629 "R_MIPS_CALL16", /* name */
630 false, /* partial_inplace */
632 0xffff, /* dst_mask */
633 false), /* pcrel_offset */
635 /* 32 bit GP relative reference. */
636 HOWTO (R_MIPS_GPREL32
, /* type */
638 2, /* size (0 = byte, 1 = short, 2 = long) */
640 false, /* pc_relative */
642 complain_overflow_bitfield
, /* complain_on_overflow */
643 _bfd_mips_elf_gprel32_reloc
, /* special_function */
644 "R_MIPS_GPREL32", /* name */
645 true, /* partial_inplace */
646 0xffffffff, /* src_mask */
647 0xffffffff, /* dst_mask */
648 false), /* pcrel_offset */
650 /* The remaining relocs are defined on Irix 5, although they are
651 not defined by the ABI. */
656 /* A 5 bit shift field. */
657 HOWTO (R_MIPS_SHIFT5
, /* type */
659 2, /* size (0 = byte, 1 = short, 2 = long) */
661 false, /* pc_relative */
663 complain_overflow_bitfield
, /* complain_on_overflow */
664 bfd_elf_generic_reloc
, /* special_function */
665 "R_MIPS_SHIFT5", /* name */
666 true, /* partial_inplace */
667 0x000007c0, /* src_mask */
668 0x000007c0, /* dst_mask */
669 false), /* pcrel_offset */
671 /* A 6 bit shift field. */
672 /* FIXME: This is not handled correctly; a special function is
673 needed to put the most significant bit in the right place. */
674 HOWTO (R_MIPS_SHIFT6
, /* type */
676 2, /* size (0 = byte, 1 = short, 2 = long) */
678 false, /* pc_relative */
680 complain_overflow_bitfield
, /* complain_on_overflow */
681 bfd_elf_generic_reloc
, /* special_function */
682 "R_MIPS_SHIFT6", /* name */
683 true, /* partial_inplace */
684 0x000007c4, /* src_mask */
685 0x000007c4, /* dst_mask */
686 false), /* pcrel_offset */
688 /* A 64 bit relocation. */
689 HOWTO (R_MIPS_64
, /* type */
691 4, /* size (0 = byte, 1 = short, 2 = long) */
693 false, /* pc_relative */
695 complain_overflow_bitfield
, /* complain_on_overflow */
696 mips32_64bit_reloc
, /* special_function */
697 "R_MIPS_64", /* name */
698 true, /* partial_inplace */
699 MINUS_ONE
, /* src_mask */
700 MINUS_ONE
, /* dst_mask */
701 false), /* pcrel_offset */
703 /* Displacement in the global offset table. */
704 HOWTO (R_MIPS_GOT_DISP
, /* type */
706 2, /* size (0 = byte, 1 = short, 2 = long) */
708 false, /* pc_relative */
710 complain_overflow_bitfield
, /* complain_on_overflow */
711 bfd_elf_generic_reloc
, /* special_function */
712 "R_MIPS_GOT_DISP", /* name */
713 true, /* partial_inplace */
714 0x0000ffff, /* src_mask */
715 0x0000ffff, /* dst_mask */
716 false), /* pcrel_offset */
718 /* Displacement to page pointer in the global offset table. */
719 HOWTO (R_MIPS_GOT_PAGE
, /* type */
721 2, /* size (0 = byte, 1 = short, 2 = long) */
723 false, /* pc_relative */
725 complain_overflow_bitfield
, /* complain_on_overflow */
726 bfd_elf_generic_reloc
, /* special_function */
727 "R_MIPS_GOT_PAGE", /* name */
728 true, /* partial_inplace */
729 0x0000ffff, /* src_mask */
730 0x0000ffff, /* dst_mask */
731 false), /* pcrel_offset */
733 /* Offset from page pointer in the global offset table. */
734 HOWTO (R_MIPS_GOT_OFST
, /* type */
736 2, /* size (0 = byte, 1 = short, 2 = long) */
738 false, /* pc_relative */
740 complain_overflow_bitfield
, /* complain_on_overflow */
741 bfd_elf_generic_reloc
, /* special_function */
742 "R_MIPS_GOT_OFST", /* name */
743 true, /* partial_inplace */
744 0x0000ffff, /* src_mask */
745 0x0000ffff, /* dst_mask */
746 false), /* pcrel_offset */
748 /* High 16 bits of displacement in global offset table. */
749 HOWTO (R_MIPS_GOT_HI16
, /* type */
751 2, /* size (0 = byte, 1 = short, 2 = long) */
753 false, /* pc_relative */
755 complain_overflow_dont
, /* complain_on_overflow */
756 bfd_elf_generic_reloc
, /* special_function */
757 "R_MIPS_GOT_HI16", /* name */
758 true, /* partial_inplace */
759 0x0000ffff, /* src_mask */
760 0x0000ffff, /* dst_mask */
761 false), /* pcrel_offset */
763 /* Low 16 bits of displacement in global offset table. */
764 HOWTO (R_MIPS_GOT_LO16
, /* type */
766 2, /* size (0 = byte, 1 = short, 2 = long) */
768 false, /* pc_relative */
770 complain_overflow_dont
, /* complain_on_overflow */
771 bfd_elf_generic_reloc
, /* special_function */
772 "R_MIPS_GOT_LO16", /* name */
773 true, /* partial_inplace */
774 0x0000ffff, /* src_mask */
775 0x0000ffff, /* dst_mask */
776 false), /* pcrel_offset */
778 /* 64 bit subtraction. Used in the N32 ABI. */
779 HOWTO (R_MIPS_SUB
, /* type */
781 4, /* size (0 = byte, 1 = short, 2 = long) */
783 false, /* pc_relative */
785 complain_overflow_bitfield
, /* complain_on_overflow */
786 bfd_elf_generic_reloc
, /* special_function */
787 "R_MIPS_SUB", /* name */
788 true, /* partial_inplace */
789 MINUS_ONE
, /* src_mask */
790 MINUS_ONE
, /* dst_mask */
791 false), /* pcrel_offset */
793 /* Used to cause the linker to insert and delete instructions? */
794 EMPTY_HOWTO (R_MIPS_INSERT_A
),
795 EMPTY_HOWTO (R_MIPS_INSERT_B
),
796 EMPTY_HOWTO (R_MIPS_DELETE
),
798 /* Get the higher value of a 64 bit addend. */
799 HOWTO (R_MIPS_HIGHER
, /* type */
801 2, /* size (0 = byte, 1 = short, 2 = long) */
803 false, /* pc_relative */
805 complain_overflow_dont
, /* complain_on_overflow */
806 bfd_elf_generic_reloc
, /* special_function */
807 "R_MIPS_HIGHER", /* name */
808 true, /* partial_inplace */
810 0xffff, /* dst_mask */
811 false), /* pcrel_offset */
813 /* Get the highest value of a 64 bit addend. */
814 HOWTO (R_MIPS_HIGHEST
, /* type */
816 2, /* size (0 = byte, 1 = short, 2 = long) */
818 false, /* pc_relative */
820 complain_overflow_dont
, /* complain_on_overflow */
821 bfd_elf_generic_reloc
, /* special_function */
822 "R_MIPS_HIGHEST", /* name */
823 true, /* partial_inplace */
825 0xffff, /* dst_mask */
826 false), /* pcrel_offset */
828 /* High 16 bits of displacement in global offset table. */
829 HOWTO (R_MIPS_CALL_HI16
, /* type */
831 2, /* size (0 = byte, 1 = short, 2 = long) */
833 false, /* pc_relative */
835 complain_overflow_dont
, /* complain_on_overflow */
836 bfd_elf_generic_reloc
, /* special_function */
837 "R_MIPS_CALL_HI16", /* name */
838 true, /* partial_inplace */
839 0x0000ffff, /* src_mask */
840 0x0000ffff, /* dst_mask */
841 false), /* pcrel_offset */
843 /* Low 16 bits of displacement in global offset table. */
844 HOWTO (R_MIPS_CALL_LO16
, /* type */
846 2, /* size (0 = byte, 1 = short, 2 = long) */
848 false, /* pc_relative */
850 complain_overflow_dont
, /* complain_on_overflow */
851 bfd_elf_generic_reloc
, /* special_function */
852 "R_MIPS_CALL_LO16", /* name */
853 true, /* partial_inplace */
854 0x0000ffff, /* src_mask */
855 0x0000ffff, /* dst_mask */
856 false), /* pcrel_offset */
858 /* Section displacement. */
859 HOWTO (R_MIPS_SCN_DISP
, /* type */
861 2, /* size (0 = byte, 1 = short, 2 = long) */
863 false, /* pc_relative */
865 complain_overflow_dont
, /* complain_on_overflow */
866 bfd_elf_generic_reloc
, /* special_function */
867 "R_MIPS_SCN_DISP", /* name */
868 false, /* partial_inplace */
869 0xffffffff, /* src_mask */
870 0xffffffff, /* dst_mask */
871 false), /* pcrel_offset */
873 EMPTY_HOWTO (R_MIPS_REL16
),
874 EMPTY_HOWTO (R_MIPS_ADD_IMMEDIATE
),
875 EMPTY_HOWTO (R_MIPS_PJUMP
),
876 EMPTY_HOWTO (R_MIPS_RELGOT
),
878 /* Protected jump conversion. This is an optimization hint. No
879 relocation is required for correctness. */
880 HOWTO (R_MIPS_JALR
, /* type */
882 0, /* size (0 = byte, 1 = short, 2 = long) */
884 false, /* pc_relative */
886 complain_overflow_dont
, /* complain_on_overflow */
887 bfd_elf_generic_reloc
, /* special_function */
888 "R_MIPS_JALR", /* name */
889 false, /* partial_inplace */
890 0x00000000, /* src_mask */
891 0x00000000, /* dst_mask */
892 false), /* pcrel_offset */
895 /* The reloc used for BFD_RELOC_CTOR when doing a 64 bit link. This
896 is a hack to make the linker think that we need 64 bit values. */
897 static reloc_howto_type elf_mips_ctor64_howto
=
898 HOWTO (R_MIPS_64
, /* type */
900 4, /* size (0 = byte, 1 = short, 2 = long) */
902 false, /* pc_relative */
904 complain_overflow_signed
, /* complain_on_overflow */
905 mips32_64bit_reloc
, /* special_function */
906 "R_MIPS_64", /* name */
907 true, /* partial_inplace */
908 0xffffffff, /* src_mask */
909 0xffffffff, /* dst_mask */
910 false); /* pcrel_offset */
912 /* The reloc used for the mips16 jump instruction. */
913 static reloc_howto_type elf_mips16_jump_howto
=
914 HOWTO (R_MIPS16_26
, /* type */
916 2, /* size (0 = byte, 1 = short, 2 = long) */
918 false, /* pc_relative */
920 complain_overflow_dont
, /* complain_on_overflow */
921 /* This needs complex overflow
922 detection, because the upper four
923 bits must match the PC. */
924 mips16_jump_reloc
, /* special_function */
925 "R_MIPS16_26", /* name */
926 true, /* partial_inplace */
927 0x3ffffff, /* src_mask */
928 0x3ffffff, /* dst_mask */
929 false); /* pcrel_offset */
931 /* The reloc used for the mips16 gprel instruction. */
932 static reloc_howto_type elf_mips16_gprel_howto
=
933 HOWTO (R_MIPS16_GPREL
, /* type */
935 2, /* size (0 = byte, 1 = short, 2 = long) */
937 false, /* pc_relative */
939 complain_overflow_signed
, /* complain_on_overflow */
940 mips16_gprel_reloc
, /* special_function */
941 "R_MIPS16_GPREL", /* name */
942 true, /* partial_inplace */
943 0x07ff001f, /* src_mask */
944 0x07ff001f, /* dst_mask */
945 false); /* pcrel_offset */
948 /* GNU extension to record C++ vtable hierarchy */
949 static reloc_howto_type elf_mips_gnu_vtinherit_howto
=
950 HOWTO (R_MIPS_GNU_VTINHERIT
, /* type */
952 2, /* size (0 = byte, 1 = short, 2 = long) */
954 false, /* pc_relative */
956 complain_overflow_dont
, /* complain_on_overflow */
957 NULL
, /* special_function */
958 "R_MIPS_GNU_VTINHERIT", /* name */
959 false, /* partial_inplace */
962 false); /* pcrel_offset */
964 /* GNU extension to record C++ vtable member usage */
965 static reloc_howto_type elf_mips_gnu_vtentry_howto
=
966 HOWTO (R_MIPS_GNU_VTENTRY
, /* type */
968 2, /* size (0 = byte, 1 = short, 2 = long) */
970 false, /* pc_relative */
972 complain_overflow_dont
, /* complain_on_overflow */
973 _bfd_elf_rel_vtable_reloc_fn
, /* special_function */
974 "R_MIPS_GNU_VTENTRY", /* name */
975 false, /* partial_inplace */
978 false); /* pcrel_offset */
980 /* Do a R_MIPS_HI16 relocation. This has to be done in combination
981 with a R_MIPS_LO16 reloc, because there is a carry from the LO16 to
982 the HI16. Here we just save the information we need; we do the
983 actual relocation when we see the LO16. MIPS ELF requires that the
984 LO16 immediately follow the HI16. As a GNU extension, we permit an
985 arbitrary number of HI16 relocs to be associated with a single LO16
986 reloc. This extension permits gcc to output the HI and LO relocs
991 struct mips_hi16
*next
;
996 /* FIXME: This should not be a static variable. */
998 static struct mips_hi16
*mips_hi16_list
;
1000 bfd_reloc_status_type
1001 _bfd_mips_elf_hi16_reloc (abfd
,
1008 bfd
*abfd ATTRIBUTE_UNUSED
;
1009 arelent
*reloc_entry
;
1012 asection
*input_section
;
1014 char **error_message
;
1016 bfd_reloc_status_type ret
;
1018 struct mips_hi16
*n
;
1020 /* If we're relocating, and this an external symbol, we don't want
1021 to change anything. */
1022 if (output_bfd
!= (bfd
*) NULL
1023 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1024 && reloc_entry
->addend
== 0)
1026 reloc_entry
->address
+= input_section
->output_offset
;
1027 return bfd_reloc_ok
;
1032 if (strcmp (bfd_asymbol_name (symbol
), "_gp_disp") == 0)
1034 boolean relocateable
;
1037 if (ret
== bfd_reloc_undefined
)
1040 if (output_bfd
!= NULL
)
1041 relocateable
= true;
1044 relocateable
= false;
1045 output_bfd
= symbol
->section
->output_section
->owner
;
1048 ret
= mips_elf_final_gp (output_bfd
, symbol
, relocateable
,
1049 error_message
, &gp
);
1050 if (ret
!= bfd_reloc_ok
)
1053 relocation
= gp
- reloc_entry
->address
;
1057 if (bfd_is_und_section (symbol
->section
)
1058 && output_bfd
== (bfd
*) NULL
)
1059 ret
= bfd_reloc_undefined
;
1061 if (bfd_is_com_section (symbol
->section
))
1064 relocation
= symbol
->value
;
1067 relocation
+= symbol
->section
->output_section
->vma
;
1068 relocation
+= symbol
->section
->output_offset
;
1069 relocation
+= reloc_entry
->addend
;
1071 if (reloc_entry
->address
> input_section
->_cooked_size
)
1072 return bfd_reloc_outofrange
;
1074 /* Save the information, and let LO16 do the actual relocation. */
1075 n
= (struct mips_hi16
*) bfd_malloc (sizeof *n
);
1077 return bfd_reloc_outofrange
;
1078 n
->addr
= (bfd_byte
*) data
+ reloc_entry
->address
;
1079 n
->addend
= relocation
;
1080 n
->next
= mips_hi16_list
;
1083 if (output_bfd
!= (bfd
*) NULL
)
1084 reloc_entry
->address
+= input_section
->output_offset
;
1089 /* Do a R_MIPS_LO16 relocation. This is a straightforward 16 bit
1090 inplace relocation; this function exists in order to do the
1091 R_MIPS_HI16 relocation described above. */
1093 bfd_reloc_status_type
1094 _bfd_mips_elf_lo16_reloc (abfd
,
1102 arelent
*reloc_entry
;
1105 asection
*input_section
;
1107 char **error_message
;
1109 arelent gp_disp_relent
;
1111 if (mips_hi16_list
!= NULL
)
1113 struct mips_hi16
*l
;
1120 unsigned long vallo
;
1121 struct mips_hi16
*next
;
1123 /* Do the HI16 relocation. Note that we actually don't need
1124 to know anything about the LO16 itself, except where to
1125 find the low 16 bits of the addend needed by the LO16. */
1126 insn
= bfd_get_32 (abfd
, l
->addr
);
1127 vallo
= (bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
)
1129 val
= ((insn
& 0xffff) << 16) + vallo
;
1132 /* The low order 16 bits are always treated as a signed
1133 value. Therefore, a negative value in the low order bits
1134 requires an adjustment in the high order bits. We need
1135 to make this adjustment in two ways: once for the bits we
1136 took from the data, and once for the bits we are putting
1137 back in to the data. */
1138 if ((vallo
& 0x8000) != 0)
1140 if ((val
& 0x8000) != 0)
1143 insn
= (insn
&~ 0xffff) | ((val
>> 16) & 0xffff);
1144 bfd_put_32 (abfd
, insn
, l
->addr
);
1146 if (strcmp (bfd_asymbol_name (symbol
), "_gp_disp") == 0)
1148 gp_disp_relent
= *reloc_entry
;
1149 reloc_entry
= &gp_disp_relent
;
1150 reloc_entry
->addend
= l
->addend
;
1158 mips_hi16_list
= NULL
;
1160 else if (strcmp (bfd_asymbol_name (symbol
), "_gp_disp") == 0)
1162 bfd_reloc_status_type ret
;
1163 bfd_vma gp
, relocation
;
1165 /* FIXME: Does this case ever occur? */
1167 ret
= mips_elf_final_gp (output_bfd
, symbol
, true, error_message
, &gp
);
1168 if (ret
!= bfd_reloc_ok
)
1171 relocation
= gp
- reloc_entry
->address
;
1172 relocation
+= symbol
->section
->output_section
->vma
;
1173 relocation
+= symbol
->section
->output_offset
;
1174 relocation
+= reloc_entry
->addend
;
1176 if (reloc_entry
->address
> input_section
->_cooked_size
)
1177 return bfd_reloc_outofrange
;
1179 gp_disp_relent
= *reloc_entry
;
1180 reloc_entry
= &gp_disp_relent
;
1181 reloc_entry
->addend
= relocation
- 4;
1184 /* Now do the LO16 reloc in the usual way. */
1185 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1186 input_section
, output_bfd
, error_message
);
1189 /* Do a R_MIPS_GOT16 reloc. This is a reloc against the global offset
1190 table used for PIC code. If the symbol is an external symbol, the
1191 instruction is modified to contain the offset of the appropriate
1192 entry in the global offset table. If the symbol is a section
1193 symbol, the next reloc is a R_MIPS_LO16 reloc. The two 16 bit
1194 addends are combined to form the real addend against the section
1195 symbol; the GOT16 is modified to contain the offset of an entry in
1196 the global offset table, and the LO16 is modified to offset it
1197 appropriately. Thus an offset larger than 16 bits requires a
1198 modified value in the global offset table.
1200 This implementation suffices for the assembler, but the linker does
1201 not yet know how to create global offset tables. */
1203 bfd_reloc_status_type
1204 _bfd_mips_elf_got16_reloc (abfd
,
1212 arelent
*reloc_entry
;
1215 asection
*input_section
;
1217 char **error_message
;
1219 /* If we're relocating, and this an external symbol, we don't want
1220 to change anything. */
1221 if (output_bfd
!= (bfd
*) NULL
1222 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1223 && reloc_entry
->addend
== 0)
1225 reloc_entry
->address
+= input_section
->output_offset
;
1226 return bfd_reloc_ok
;
1229 /* If we're relocating, and this is a local symbol, we can handle it
1231 if (output_bfd
!= (bfd
*) NULL
1232 && (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1233 return _bfd_mips_elf_hi16_reloc (abfd
, reloc_entry
, symbol
, data
,
1234 input_section
, output_bfd
, error_message
);
1239 /* Set the GP value for OUTPUT_BFD. Returns false if this is a
1240 dangerous relocation. */
1243 mips_elf_assign_gp (output_bfd
, pgp
)
1251 /* If we've already figured out what GP will be, just return it. */
1252 *pgp
= _bfd_get_gp_value (output_bfd
);
1256 count
= bfd_get_symcount (output_bfd
);
1257 sym
= bfd_get_outsymbols (output_bfd
);
1259 /* The linker script will have created a symbol named `_gp' with the
1260 appropriate value. */
1261 if (sym
== (asymbol
**) NULL
)
1265 for (i
= 0; i
< count
; i
++, sym
++)
1267 register CONST
char *name
;
1269 name
= bfd_asymbol_name (*sym
);
1270 if (*name
== '_' && strcmp (name
, "_gp") == 0)
1272 *pgp
= bfd_asymbol_value (*sym
);
1273 _bfd_set_gp_value (output_bfd
, *pgp
);
1281 /* Only get the error once. */
1283 _bfd_set_gp_value (output_bfd
, *pgp
);
1290 /* We have to figure out the gp value, so that we can adjust the
1291 symbol value correctly. We look up the symbol _gp in the output
1292 BFD. If we can't find it, we're stuck. We cache it in the ELF
1293 target data. We don't need to adjust the symbol value for an
1294 external symbol if we are producing relocateable output. */
1296 static bfd_reloc_status_type
1297 mips_elf_final_gp (output_bfd
, symbol
, relocateable
, error_message
, pgp
)
1300 boolean relocateable
;
1301 char **error_message
;
1304 if (bfd_is_und_section (symbol
->section
)
1308 return bfd_reloc_undefined
;
1311 *pgp
= _bfd_get_gp_value (output_bfd
);
1314 || (symbol
->flags
& BSF_SECTION_SYM
) != 0))
1318 /* Make up a value. */
1319 *pgp
= symbol
->section
->output_section
->vma
+ 0x4000;
1320 _bfd_set_gp_value (output_bfd
, *pgp
);
1322 else if (!mips_elf_assign_gp (output_bfd
, pgp
))
1325 (char *) _("GP relative relocation when _gp not defined");
1326 return bfd_reloc_dangerous
;
1330 return bfd_reloc_ok
;
1333 /* Do a R_MIPS_GPREL16 relocation. This is a 16 bit value which must
1334 become the offset from the gp register. This function also handles
1335 R_MIPS_LITERAL relocations, although those can be handled more
1336 cleverly because the entries in the .lit8 and .lit4 sections can be
1339 static bfd_reloc_status_type gprel16_with_gp
PARAMS ((bfd
*, asymbol
*,
1340 arelent
*, asection
*,
1341 boolean
, PTR
, bfd_vma
));
1343 bfd_reloc_status_type
1344 _bfd_mips_elf_gprel16_reloc (abfd
, reloc_entry
, symbol
, data
, input_section
,
1345 output_bfd
, error_message
)
1347 arelent
*reloc_entry
;
1350 asection
*input_section
;
1352 char **error_message
;
1354 boolean relocateable
;
1355 bfd_reloc_status_type ret
;
1358 /* If we're relocating, and this is an external symbol with no
1359 addend, we don't want to change anything. We will only have an
1360 addend if this is a newly created reloc, not read from an ELF
1362 if (output_bfd
!= (bfd
*) NULL
1363 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1364 && reloc_entry
->addend
== 0)
1366 reloc_entry
->address
+= input_section
->output_offset
;
1367 return bfd_reloc_ok
;
1370 if (output_bfd
!= (bfd
*) NULL
)
1371 relocateable
= true;
1374 relocateable
= false;
1375 output_bfd
= symbol
->section
->output_section
->owner
;
1378 ret
= mips_elf_final_gp (output_bfd
, symbol
, relocateable
, error_message
,
1380 if (ret
!= bfd_reloc_ok
)
1383 return gprel16_with_gp (abfd
, symbol
, reloc_entry
, input_section
,
1384 relocateable
, data
, gp
);
1387 static bfd_reloc_status_type
1388 gprel16_with_gp (abfd
, symbol
, reloc_entry
, input_section
, relocateable
, data
,
1392 arelent
*reloc_entry
;
1393 asection
*input_section
;
1394 boolean relocateable
;
1402 if (bfd_is_com_section (symbol
->section
))
1405 relocation
= symbol
->value
;
1407 relocation
+= symbol
->section
->output_section
->vma
;
1408 relocation
+= symbol
->section
->output_offset
;
1410 if (reloc_entry
->address
> input_section
->_cooked_size
)
1411 return bfd_reloc_outofrange
;
1413 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1415 /* Set val to the offset into the section or symbol. */
1416 if (reloc_entry
->howto
->src_mask
== 0)
1418 /* This case occurs with the 64-bit MIPS ELF ABI. */
1419 val
= reloc_entry
->addend
;
1423 val
= ((insn
& 0xffff) + reloc_entry
->addend
) & 0xffff;
1428 /* Adjust val for the final section location and GP value. If we
1429 are producing relocateable output, we don't want to do this for
1430 an external symbol. */
1432 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1433 val
+= relocation
- gp
;
1435 insn
= (insn
&~ 0xffff) | (val
& 0xffff);
1436 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
);
1439 reloc_entry
->address
+= input_section
->output_offset
;
1441 /* Make sure it fit in 16 bits. */
1442 if (val
>= 0x8000 && val
< 0xffff8000)
1443 return bfd_reloc_overflow
;
1445 return bfd_reloc_ok
;
1448 /* Do a R_MIPS_GPREL32 relocation. Is this 32 bit value the offset
1449 from the gp register? XXX */
1451 static bfd_reloc_status_type gprel32_with_gp
PARAMS ((bfd
*, asymbol
*,
1452 arelent
*, asection
*,
1453 boolean
, PTR
, bfd_vma
));
1455 bfd_reloc_status_type
1456 _bfd_mips_elf_gprel32_reloc (abfd
,
1464 arelent
*reloc_entry
;
1467 asection
*input_section
;
1469 char **error_message
;
1471 boolean relocateable
;
1472 bfd_reloc_status_type ret
;
1475 /* If we're relocating, and this is an external symbol with no
1476 addend, we don't want to change anything. We will only have an
1477 addend if this is a newly created reloc, not read from an ELF
1479 if (output_bfd
!= (bfd
*) NULL
1480 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1481 && reloc_entry
->addend
== 0)
1483 *error_message
= (char *)
1484 _("32bits gp relative relocation occurs for an external symbol");
1485 return bfd_reloc_outofrange
;
1488 if (output_bfd
!= (bfd
*) NULL
)
1490 relocateable
= true;
1491 gp
= _bfd_get_gp_value (output_bfd
);
1495 relocateable
= false;
1496 output_bfd
= symbol
->section
->output_section
->owner
;
1498 ret
= mips_elf_final_gp (output_bfd
, symbol
, relocateable
,
1499 error_message
, &gp
);
1500 if (ret
!= bfd_reloc_ok
)
1504 return gprel32_with_gp (abfd
, symbol
, reloc_entry
, input_section
,
1505 relocateable
, data
, gp
);
1508 static bfd_reloc_status_type
1509 gprel32_with_gp (abfd
, symbol
, reloc_entry
, input_section
, relocateable
, data
,
1513 arelent
*reloc_entry
;
1514 asection
*input_section
;
1515 boolean relocateable
;
1522 if (bfd_is_com_section (symbol
->section
))
1525 relocation
= symbol
->value
;
1527 relocation
+= symbol
->section
->output_section
->vma
;
1528 relocation
+= symbol
->section
->output_offset
;
1530 if (reloc_entry
->address
> input_section
->_cooked_size
)
1531 return bfd_reloc_outofrange
;
1533 if (reloc_entry
->howto
->src_mask
== 0)
1535 /* This case arises with the 64-bit MIPS ELF ABI. */
1539 val
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1541 /* Set val to the offset into the section or symbol. */
1542 val
+= reloc_entry
->addend
;
1544 /* Adjust val for the final section location and GP value. If we
1545 are producing relocateable output, we don't want to do this for
1546 an external symbol. */
1548 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1549 val
+= relocation
- gp
;
1551 bfd_put_32 (abfd
, val
, (bfd_byte
*) data
+ reloc_entry
->address
);
1554 reloc_entry
->address
+= input_section
->output_offset
;
1556 return bfd_reloc_ok
;
1559 /* Handle a 64 bit reloc in a 32 bit MIPS ELF file. These are
1560 generated when addreses are 64 bits. The upper 32 bits are a simle
1563 static bfd_reloc_status_type
1564 mips32_64bit_reloc (abfd
, reloc_entry
, symbol
, data
, input_section
,
1565 output_bfd
, error_message
)
1567 arelent
*reloc_entry
;
1570 asection
*input_section
;
1572 char **error_message
;
1574 bfd_reloc_status_type r
;
1579 r
= bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1580 input_section
, output_bfd
, error_message
);
1581 if (r
!= bfd_reloc_continue
)
1584 /* Do a normal 32 bit relocation on the lower 32 bits. */
1585 reloc32
= *reloc_entry
;
1586 if (bfd_big_endian (abfd
))
1587 reloc32
.address
+= 4;
1588 reloc32
.howto
= &elf_mips_howto_table
[R_MIPS_32
];
1589 r
= bfd_perform_relocation (abfd
, &reloc32
, data
, input_section
,
1590 output_bfd
, error_message
);
1592 /* Sign extend into the upper 32 bits. */
1593 val
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc32
.address
);
1594 if ((val
& 0x80000000) != 0)
1598 addr
= reloc_entry
->address
;
1599 if (bfd_little_endian (abfd
))
1601 bfd_put_32 (abfd
, val
, (bfd_byte
*) data
+ addr
);
1606 /* Handle a mips16 jump. */
1608 static bfd_reloc_status_type
1609 mips16_jump_reloc (abfd
, reloc_entry
, symbol
, data
, input_section
,
1610 output_bfd
, error_message
)
1611 bfd
*abfd ATTRIBUTE_UNUSED
;
1612 arelent
*reloc_entry
;
1614 PTR data ATTRIBUTE_UNUSED
;
1615 asection
*input_section
;
1617 char **error_message ATTRIBUTE_UNUSED
;
1619 if (output_bfd
!= (bfd
*) NULL
1620 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1621 && reloc_entry
->addend
== 0)
1623 reloc_entry
->address
+= input_section
->output_offset
;
1624 return bfd_reloc_ok
;
1629 static boolean warned
;
1632 (*_bfd_error_handler
)
1633 (_("Linking mips16 objects into %s format is not supported"),
1634 bfd_get_target (input_section
->output_section
->owner
));
1638 return bfd_reloc_undefined
;
1641 /* Handle a mips16 GP relative reloc. */
1643 static bfd_reloc_status_type
1644 mips16_gprel_reloc (abfd
, reloc_entry
, symbol
, data
, input_section
,
1645 output_bfd
, error_message
)
1647 arelent
*reloc_entry
;
1650 asection
*input_section
;
1652 char **error_message
;
1654 boolean relocateable
;
1655 bfd_reloc_status_type ret
;
1657 unsigned short extend
, insn
;
1658 unsigned long final
;
1660 /* If we're relocating, and this is an external symbol with no
1661 addend, we don't want to change anything. We will only have an
1662 addend if this is a newly created reloc, not read from an ELF
1664 if (output_bfd
!= NULL
1665 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1666 && reloc_entry
->addend
== 0)
1668 reloc_entry
->address
+= input_section
->output_offset
;
1669 return bfd_reloc_ok
;
1672 if (output_bfd
!= NULL
)
1673 relocateable
= true;
1676 relocateable
= false;
1677 output_bfd
= symbol
->section
->output_section
->owner
;
1680 ret
= mips_elf_final_gp (output_bfd
, symbol
, relocateable
, error_message
,
1682 if (ret
!= bfd_reloc_ok
)
1685 if (reloc_entry
->address
> input_section
->_cooked_size
)
1686 return bfd_reloc_outofrange
;
1688 /* Pick up the mips16 extend instruction and the real instruction. */
1689 extend
= bfd_get_16 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1690 insn
= bfd_get_16 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
+ 2);
1692 /* Stuff the current addend back as a 32 bit value, do the usual
1693 relocation, and then clean up. */
1695 (((extend
& 0x1f) << 11)
1698 (bfd_byte
*) data
+ reloc_entry
->address
);
1700 ret
= gprel16_with_gp (abfd
, symbol
, reloc_entry
, input_section
,
1701 relocateable
, data
, gp
);
1703 final
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1706 | ((final
>> 11) & 0x1f)
1708 (bfd_byte
*) data
+ reloc_entry
->address
);
1712 (bfd_byte
*) data
+ reloc_entry
->address
+ 2);
1717 /* Return the ISA for a MIPS e_flags value. */
1720 elf_mips_isa (flags
)
1723 switch (flags
& EF_MIPS_ARCH
)
1737 /* Return the MACH for a MIPS e_flags value. */
1740 elf_mips_mach (flags
)
1743 switch (flags
& EF_MIPS_MACH
)
1745 case E_MIPS_MACH_3900
:
1746 return bfd_mach_mips3900
;
1748 case E_MIPS_MACH_4010
:
1749 return bfd_mach_mips4010
;
1751 case E_MIPS_MACH_4100
:
1752 return bfd_mach_mips4100
;
1754 case E_MIPS_MACH_4111
:
1755 return bfd_mach_mips4111
;
1757 case E_MIPS_MACH_4650
:
1758 return bfd_mach_mips4650
;
1761 switch (flags
& EF_MIPS_ARCH
)
1765 return bfd_mach_mips3000
;
1769 return bfd_mach_mips6000
;
1773 return bfd_mach_mips4000
;
1777 return bfd_mach_mips8000
;
1785 /* Return printable name for ABI. */
1788 elf_mips_abi_name (abfd
)
1793 if (ABI_N32_P (abfd
))
1795 else if (ABI_64_P (abfd
))
1798 flags
= elf_elfheader (abfd
)->e_flags
;
1799 switch (flags
& EF_MIPS_ABI
)
1803 case E_MIPS_ABI_O32
:
1805 case E_MIPS_ABI_O64
:
1807 case E_MIPS_ABI_EABI32
:
1809 case E_MIPS_ABI_EABI64
:
1812 return "unknown abi";
1816 /* A mapping from BFD reloc types to MIPS ELF reloc types. */
1818 struct elf_reloc_map
{
1819 bfd_reloc_code_real_type bfd_reloc_val
;
1820 enum elf_mips_reloc_type elf_reloc_val
;
1823 static CONST
struct elf_reloc_map mips_reloc_map
[] =
1825 { BFD_RELOC_NONE
, R_MIPS_NONE
, },
1826 { BFD_RELOC_16
, R_MIPS_16
},
1827 { BFD_RELOC_32
, R_MIPS_32
},
1828 { BFD_RELOC_64
, R_MIPS_64
},
1829 { BFD_RELOC_MIPS_JMP
, R_MIPS_26
},
1830 { BFD_RELOC_HI16_S
, R_MIPS_HI16
},
1831 { BFD_RELOC_LO16
, R_MIPS_LO16
},
1832 { BFD_RELOC_MIPS_GPREL
, R_MIPS_GPREL16
},
1833 { BFD_RELOC_MIPS_LITERAL
, R_MIPS_LITERAL
},
1834 { BFD_RELOC_MIPS_GOT16
, R_MIPS_GOT16
},
1835 { BFD_RELOC_16_PCREL
, R_MIPS_PC16
},
1836 { BFD_RELOC_MIPS_CALL16
, R_MIPS_CALL16
},
1837 { BFD_RELOC_MIPS_GPREL32
, R_MIPS_GPREL32
},
1838 { BFD_RELOC_MIPS_GOT_HI16
, R_MIPS_GOT_HI16
},
1839 { BFD_RELOC_MIPS_GOT_LO16
, R_MIPS_GOT_LO16
},
1840 { BFD_RELOC_MIPS_CALL_HI16
, R_MIPS_CALL_HI16
},
1841 { BFD_RELOC_MIPS_CALL_LO16
, R_MIPS_CALL_LO16
},
1842 { BFD_RELOC_MIPS_SUB
, R_MIPS_SUB
},
1843 { BFD_RELOC_MIPS_GOT_PAGE
, R_MIPS_GOT_PAGE
},
1844 { BFD_RELOC_MIPS_GOT_OFST
, R_MIPS_GOT_OFST
},
1845 { BFD_RELOC_MIPS_GOT_DISP
, R_MIPS_GOT_DISP
}
1848 /* Given a BFD reloc type, return a howto structure. */
1850 static reloc_howto_type
*
1851 bfd_elf32_bfd_reloc_type_lookup (abfd
, code
)
1853 bfd_reloc_code_real_type code
;
1857 for (i
= 0; i
< sizeof (mips_reloc_map
) / sizeof (struct elf_reloc_map
); i
++)
1859 if (mips_reloc_map
[i
].bfd_reloc_val
== code
)
1860 return &elf_mips_howto_table
[(int) mips_reloc_map
[i
].elf_reloc_val
];
1866 bfd_set_error (bfd_error_bad_value
);
1869 case BFD_RELOC_CTOR
:
1870 /* We need to handle BFD_RELOC_CTOR specially.
1871 Select the right relocation (R_MIPS_32 or R_MIPS_64) based on the
1872 size of addresses on this architecture. */
1873 if (bfd_arch_bits_per_address (abfd
) == 32)
1874 return &elf_mips_howto_table
[(int) R_MIPS_32
];
1876 return &elf_mips_ctor64_howto
;
1878 case BFD_RELOC_MIPS16_JMP
:
1879 return &elf_mips16_jump_howto
;
1880 case BFD_RELOC_MIPS16_GPREL
:
1881 return &elf_mips16_gprel_howto
;
1882 case BFD_RELOC_VTABLE_INHERIT
:
1883 return &elf_mips_gnu_vtinherit_howto
;
1884 case BFD_RELOC_VTABLE_ENTRY
:
1885 return &elf_mips_gnu_vtentry_howto
;
1889 /* Given a MIPS Elf32_Internal_Rel, fill in an arelent structure. */
1892 mips_info_to_howto_rel (abfd
, cache_ptr
, dst
)
1895 Elf32_Internal_Rel
*dst
;
1897 unsigned int r_type
;
1899 r_type
= ELF32_R_TYPE (dst
->r_info
);
1903 cache_ptr
->howto
= &elf_mips16_jump_howto
;
1905 case R_MIPS16_GPREL
:
1906 cache_ptr
->howto
= &elf_mips16_gprel_howto
;
1908 case R_MIPS_GNU_VTINHERIT
:
1909 cache_ptr
->howto
= &elf_mips_gnu_vtinherit_howto
;
1911 case R_MIPS_GNU_VTENTRY
:
1912 cache_ptr
->howto
= &elf_mips_gnu_vtentry_howto
;
1916 BFD_ASSERT (r_type
< (unsigned int) R_MIPS_max
);
1917 cache_ptr
->howto
= &elf_mips_howto_table
[r_type
];
1921 /* The addend for a GPREL16 or LITERAL relocation comes from the GP
1922 value for the object file. We get the addend now, rather than
1923 when we do the relocation, because the symbol manipulations done
1924 by the linker may cause us to lose track of the input BFD. */
1925 if (((*cache_ptr
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) != 0
1926 && (r_type
== (unsigned int) R_MIPS_GPREL16
1927 || r_type
== (unsigned int) R_MIPS_LITERAL
))
1928 cache_ptr
->addend
= elf_gp (abfd
);
1931 /* Given a MIPS Elf32_Internal_Rela, fill in an arelent structure. */
1934 mips_info_to_howto_rela (abfd
, cache_ptr
, dst
)
1937 Elf32_Internal_Rela
*dst
;
1939 /* Since an Elf32_Internal_Rel is an initial prefix of an
1940 Elf32_Internal_Rela, we can just use mips_info_to_howto_rel
1942 mips_info_to_howto_rel (abfd
, cache_ptr
, (Elf32_Internal_Rel
*) dst
);
1944 /* If we ever need to do any extra processing with dst->r_addend
1945 (the field omitted in an Elf32_Internal_Rel) we can do it here. */
1948 /* A .reginfo section holds a single Elf32_RegInfo structure. These
1949 routines swap this structure in and out. They are used outside of
1950 BFD, so they are globally visible. */
1953 bfd_mips_elf32_swap_reginfo_in (abfd
, ex
, in
)
1955 const Elf32_External_RegInfo
*ex
;
1958 in
->ri_gprmask
= bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_gprmask
);
1959 in
->ri_cprmask
[0] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[0]);
1960 in
->ri_cprmask
[1] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[1]);
1961 in
->ri_cprmask
[2] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[2]);
1962 in
->ri_cprmask
[3] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[3]);
1963 in
->ri_gp_value
= bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_gp_value
);
1967 bfd_mips_elf32_swap_reginfo_out (abfd
, in
, ex
)
1969 const Elf32_RegInfo
*in
;
1970 Elf32_External_RegInfo
*ex
;
1972 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_gprmask
,
1973 (bfd_byte
*) ex
->ri_gprmask
);
1974 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[0],
1975 (bfd_byte
*) ex
->ri_cprmask
[0]);
1976 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[1],
1977 (bfd_byte
*) ex
->ri_cprmask
[1]);
1978 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[2],
1979 (bfd_byte
*) ex
->ri_cprmask
[2]);
1980 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[3],
1981 (bfd_byte
*) ex
->ri_cprmask
[3]);
1982 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_gp_value
,
1983 (bfd_byte
*) ex
->ri_gp_value
);
1986 /* In the 64 bit ABI, the .MIPS.options section holds register
1987 information in an Elf64_Reginfo structure. These routines swap
1988 them in and out. They are globally visible because they are used
1989 outside of BFD. These routines are here so that gas can call them
1990 without worrying about whether the 64 bit ABI has been included. */
1993 bfd_mips_elf64_swap_reginfo_in (abfd
, ex
, in
)
1995 const Elf64_External_RegInfo
*ex
;
1996 Elf64_Internal_RegInfo
*in
;
1998 in
->ri_gprmask
= bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_gprmask
);
1999 in
->ri_pad
= bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_pad
);
2000 in
->ri_cprmask
[0] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[0]);
2001 in
->ri_cprmask
[1] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[1]);
2002 in
->ri_cprmask
[2] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[2]);
2003 in
->ri_cprmask
[3] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[3]);
2004 in
->ri_gp_value
= bfd_h_get_64 (abfd
, (bfd_byte
*) ex
->ri_gp_value
);
2008 bfd_mips_elf64_swap_reginfo_out (abfd
, in
, ex
)
2010 const Elf64_Internal_RegInfo
*in
;
2011 Elf64_External_RegInfo
*ex
;
2013 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_gprmask
,
2014 (bfd_byte
*) ex
->ri_gprmask
);
2015 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_pad
,
2016 (bfd_byte
*) ex
->ri_pad
);
2017 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[0],
2018 (bfd_byte
*) ex
->ri_cprmask
[0]);
2019 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[1],
2020 (bfd_byte
*) ex
->ri_cprmask
[1]);
2021 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[2],
2022 (bfd_byte
*) ex
->ri_cprmask
[2]);
2023 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[3],
2024 (bfd_byte
*) ex
->ri_cprmask
[3]);
2025 bfd_h_put_64 (abfd
, (bfd_vma
) in
->ri_gp_value
,
2026 (bfd_byte
*) ex
->ri_gp_value
);
2029 /* Swap an entry in a .gptab section. Note that these routines rely
2030 on the equivalence of the two elements of the union. */
2033 bfd_mips_elf32_swap_gptab_in (abfd
, ex
, in
)
2035 const Elf32_External_gptab
*ex
;
2038 in
->gt_entry
.gt_g_value
= bfd_h_get_32 (abfd
, ex
->gt_entry
.gt_g_value
);
2039 in
->gt_entry
.gt_bytes
= bfd_h_get_32 (abfd
, ex
->gt_entry
.gt_bytes
);
2043 bfd_mips_elf32_swap_gptab_out (abfd
, in
, ex
)
2045 const Elf32_gptab
*in
;
2046 Elf32_External_gptab
*ex
;
2048 bfd_h_put_32 (abfd
, (bfd_vma
) in
->gt_entry
.gt_g_value
,
2049 ex
->gt_entry
.gt_g_value
);
2050 bfd_h_put_32 (abfd
, (bfd_vma
) in
->gt_entry
.gt_bytes
,
2051 ex
->gt_entry
.gt_bytes
);
2055 bfd_elf32_swap_compact_rel_out (abfd
, in
, ex
)
2057 const Elf32_compact_rel
*in
;
2058 Elf32_External_compact_rel
*ex
;
2060 bfd_h_put_32 (abfd
, (bfd_vma
) in
->id1
, ex
->id1
);
2061 bfd_h_put_32 (abfd
, (bfd_vma
) in
->num
, ex
->num
);
2062 bfd_h_put_32 (abfd
, (bfd_vma
) in
->id2
, ex
->id2
);
2063 bfd_h_put_32 (abfd
, (bfd_vma
) in
->offset
, ex
->offset
);
2064 bfd_h_put_32 (abfd
, (bfd_vma
) in
->reserved0
, ex
->reserved0
);
2065 bfd_h_put_32 (abfd
, (bfd_vma
) in
->reserved1
, ex
->reserved1
);
2069 bfd_elf32_swap_crinfo_out (abfd
, in
, ex
)
2071 const Elf32_crinfo
*in
;
2072 Elf32_External_crinfo
*ex
;
2076 l
= (((in
->ctype
& CRINFO_CTYPE
) << CRINFO_CTYPE_SH
)
2077 | ((in
->rtype
& CRINFO_RTYPE
) << CRINFO_RTYPE_SH
)
2078 | ((in
->dist2to
& CRINFO_DIST2TO
) << CRINFO_DIST2TO_SH
)
2079 | ((in
->relvaddr
& CRINFO_RELVADDR
) << CRINFO_RELVADDR_SH
));
2080 bfd_h_put_32 (abfd
, (bfd_vma
) l
, ex
->info
);
2081 bfd_h_put_32 (abfd
, (bfd_vma
) in
->konst
, ex
->konst
);
2082 bfd_h_put_32 (abfd
, (bfd_vma
) in
->vaddr
, ex
->vaddr
);
2085 /* Swap in an options header. */
2088 bfd_mips_elf_swap_options_in (abfd
, ex
, in
)
2090 const Elf_External_Options
*ex
;
2091 Elf_Internal_Options
*in
;
2093 in
->kind
= bfd_h_get_8 (abfd
, ex
->kind
);
2094 in
->size
= bfd_h_get_8 (abfd
, ex
->size
);
2095 in
->section
= bfd_h_get_16 (abfd
, ex
->section
);
2096 in
->info
= bfd_h_get_32 (abfd
, ex
->info
);
2099 /* Swap out an options header. */
2102 bfd_mips_elf_swap_options_out (abfd
, in
, ex
)
2104 const Elf_Internal_Options
*in
;
2105 Elf_External_Options
*ex
;
2107 bfd_h_put_8 (abfd
, in
->kind
, ex
->kind
);
2108 bfd_h_put_8 (abfd
, in
->size
, ex
->size
);
2109 bfd_h_put_16 (abfd
, in
->section
, ex
->section
);
2110 bfd_h_put_32 (abfd
, in
->info
, ex
->info
);
2113 /* Swap in an MSYM entry. */
2116 bfd_mips_elf_swap_msym_in (abfd
, ex
, in
)
2118 const Elf32_External_Msym
*ex
;
2119 Elf32_Internal_Msym
*in
;
2121 in
->ms_hash_value
= bfd_h_get_32 (abfd
, ex
->ms_hash_value
);
2122 in
->ms_info
= bfd_h_get_32 (abfd
, ex
->ms_info
);
2125 /* Swap out an MSYM entry. */
2128 bfd_mips_elf_swap_msym_out (abfd
, in
, ex
)
2130 const Elf32_Internal_Msym
*in
;
2131 Elf32_External_Msym
*ex
;
2133 bfd_h_put_32 (abfd
, in
->ms_hash_value
, ex
->ms_hash_value
);
2134 bfd_h_put_32 (abfd
, in
->ms_info
, ex
->ms_info
);
2138 /* Determine whether a symbol is global for the purposes of splitting
2139 the symbol table into global symbols and local symbols. At least
2140 on Irix 5, this split must be between section symbols and all other
2141 symbols. On most ELF targets the split is between static symbols
2142 and externally visible symbols. */
2146 mips_elf_sym_is_global (abfd
, sym
)
2147 bfd
*abfd ATTRIBUTE_UNUSED
;
2150 return (sym
->flags
& BSF_SECTION_SYM
) == 0 ? true : false;
2153 /* Set the right machine number for a MIPS ELF file. This is used for
2154 both the 32-bit and the 64-bit ABI. */
2157 _bfd_mips_elf_object_p (abfd
)
2160 /* Irix 5 and 6 is broken. Object file symbol tables are not always
2161 sorted correctly such that local symbols precede global symbols,
2162 and the sh_info field in the symbol table is not always right. */
2163 elf_bad_symtab (abfd
) = true;
2165 bfd_default_set_arch_mach (abfd
, bfd_arch_mips
,
2166 elf_mips_mach (elf_elfheader (abfd
)->e_flags
));
2170 /* The final processing done just before writing out a MIPS ELF object
2171 file. This gets the MIPS architecture right based on the machine
2172 number. This is used by both the 32-bit and the 64-bit ABI. */
2176 _bfd_mips_elf_final_write_processing (abfd
, linker
)
2178 boolean linker ATTRIBUTE_UNUSED
;
2182 Elf_Internal_Shdr
**hdrpp
;
2186 switch (bfd_get_mach (abfd
))
2189 case bfd_mach_mips3000
:
2190 val
= E_MIPS_ARCH_1
;
2193 case bfd_mach_mips3900
:
2194 val
= E_MIPS_ARCH_1
| E_MIPS_MACH_3900
;
2197 case bfd_mach_mips6000
:
2198 val
= E_MIPS_ARCH_2
;
2201 case bfd_mach_mips4000
:
2202 case bfd_mach_mips4300
:
2203 val
= E_MIPS_ARCH_3
;
2206 case bfd_mach_mips4010
:
2207 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4010
;
2210 case bfd_mach_mips4100
:
2211 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4100
;
2214 case bfd_mach_mips4111
:
2215 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4111
;
2218 case bfd_mach_mips4650
:
2219 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4650
;
2222 case bfd_mach_mips8000
:
2223 val
= E_MIPS_ARCH_4
;
2227 elf_elfheader (abfd
)->e_flags
&= ~ (EF_MIPS_ARCH
| EF_MIPS_MACH
);
2228 elf_elfheader (abfd
)->e_flags
|= val
;
2230 /* Set the sh_info field for .gptab sections and other appropriate
2231 info for each special section. */
2232 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
2233 i
< elf_elfheader (abfd
)->e_shnum
;
2236 switch ((*hdrpp
)->sh_type
)
2239 case SHT_MIPS_LIBLIST
:
2240 sec
= bfd_get_section_by_name (abfd
, ".dynstr");
2242 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
2245 case SHT_MIPS_GPTAB
:
2246 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
2247 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
2248 BFD_ASSERT (name
!= NULL
2249 && strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0);
2250 sec
= bfd_get_section_by_name (abfd
, name
+ sizeof ".gptab" - 1);
2251 BFD_ASSERT (sec
!= NULL
);
2252 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
2255 case SHT_MIPS_CONTENT
:
2256 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
2257 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
2258 BFD_ASSERT (name
!= NULL
2259 && strncmp (name
, ".MIPS.content",
2260 sizeof ".MIPS.content" - 1) == 0);
2261 sec
= bfd_get_section_by_name (abfd
,
2262 name
+ sizeof ".MIPS.content" - 1);
2263 BFD_ASSERT (sec
!= NULL
);
2264 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
2267 case SHT_MIPS_SYMBOL_LIB
:
2268 sec
= bfd_get_section_by_name (abfd
, ".dynsym");
2270 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
2271 sec
= bfd_get_section_by_name (abfd
, ".liblist");
2273 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
2276 case SHT_MIPS_EVENTS
:
2277 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
2278 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
2279 BFD_ASSERT (name
!= NULL
);
2280 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0)
2281 sec
= bfd_get_section_by_name (abfd
,
2282 name
+ sizeof ".MIPS.events" - 1);
2285 BFD_ASSERT (strncmp (name
, ".MIPS.post_rel",
2286 sizeof ".MIPS.post_rel" - 1) == 0);
2287 sec
= bfd_get_section_by_name (abfd
,
2289 + sizeof ".MIPS.post_rel" - 1));
2291 BFD_ASSERT (sec
!= NULL
);
2292 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
2299 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
2302 _bfd_mips_elf_set_private_flags (abfd
, flags
)
2306 BFD_ASSERT (!elf_flags_init (abfd
)
2307 || elf_elfheader (abfd
)->e_flags
== flags
);
2309 elf_elfheader (abfd
)->e_flags
= flags
;
2310 elf_flags_init (abfd
) = true;
2314 /* Copy backend specific data from one object module to another */
2317 _bfd_mips_elf_copy_private_bfd_data (ibfd
, obfd
)
2321 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2322 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2325 BFD_ASSERT (!elf_flags_init (obfd
)
2326 || (elf_elfheader (obfd
)->e_flags
2327 == elf_elfheader (ibfd
)->e_flags
));
2329 elf_gp (obfd
) = elf_gp (ibfd
);
2330 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
2331 elf_flags_init (obfd
) = true;
2335 /* Merge backend specific data from an object file to the output
2336 object file when linking. */
2339 _bfd_mips_elf_merge_private_bfd_data (ibfd
, obfd
)
2347 /* Check if we have the same endianess */
2348 if (ibfd
->xvec
->byteorder
!= obfd
->xvec
->byteorder
2349 && obfd
->xvec
->byteorder
!= BFD_ENDIAN_UNKNOWN
)
2353 if (bfd_big_endian (ibfd
))
2354 msg
= _("%s: compiled for a big endian system and target is little endian");
2356 msg
= _("%s: compiled for a little endian system and target is big endian");
2358 (*_bfd_error_handler
) (msg
, bfd_get_filename (ibfd
));
2360 bfd_set_error (bfd_error_wrong_format
);
2364 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2365 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2368 new_flags
= elf_elfheader (ibfd
)->e_flags
;
2369 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_NOREORDER
;
2370 old_flags
= elf_elfheader (obfd
)->e_flags
;
2372 if (! elf_flags_init (obfd
))
2374 elf_flags_init (obfd
) = true;
2375 elf_elfheader (obfd
)->e_flags
= new_flags
;
2376 elf_elfheader (obfd
)->e_ident
[EI_CLASS
]
2377 = elf_elfheader (ibfd
)->e_ident
[EI_CLASS
];
2379 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
2380 && bfd_get_arch_info (obfd
)->the_default
)
2382 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
2383 bfd_get_mach (ibfd
)))
2390 /* Check flag compatibility. */
2392 new_flags
&= ~EF_MIPS_NOREORDER
;
2393 old_flags
&= ~EF_MIPS_NOREORDER
;
2395 if (new_flags
== old_flags
)
2400 if ((new_flags
& EF_MIPS_PIC
) != (old_flags
& EF_MIPS_PIC
))
2402 new_flags
&= ~EF_MIPS_PIC
;
2403 old_flags
&= ~EF_MIPS_PIC
;
2404 (*_bfd_error_handler
)
2405 (_("%s: linking PIC files with non-PIC files"),
2406 bfd_get_filename (ibfd
));
2410 if ((new_flags
& EF_MIPS_CPIC
) != (old_flags
& EF_MIPS_CPIC
))
2412 new_flags
&= ~EF_MIPS_CPIC
;
2413 old_flags
&= ~EF_MIPS_CPIC
;
2414 (*_bfd_error_handler
)
2415 (_("%s: linking abicalls files with non-abicalls files"),
2416 bfd_get_filename (ibfd
));
2420 /* Compare the ISA's. */
2421 if ((new_flags
& (EF_MIPS_ARCH
| EF_MIPS_MACH
))
2422 != (old_flags
& (EF_MIPS_ARCH
| EF_MIPS_MACH
)))
2424 int new_mach
= new_flags
& EF_MIPS_MACH
;
2425 int old_mach
= old_flags
& EF_MIPS_MACH
;
2426 int new_isa
= elf_mips_isa (new_flags
);
2427 int old_isa
= elf_mips_isa (old_flags
);
2429 /* If either has no machine specified, just compare the general isa's.
2430 Some combinations of machines are ok, if the isa's match. */
2433 || new_mach
== old_mach
2436 /* Don't warn about mixing -mips1 and -mips2 code, or mixing -mips3
2437 and -mips4 code. They will normally use the same data sizes and
2438 calling conventions. */
2440 if ((new_isa
== 1 || new_isa
== 2)
2441 ? (old_isa
!= 1 && old_isa
!= 2)
2442 : (old_isa
== 1 || old_isa
== 2))
2444 (*_bfd_error_handler
)
2445 (_("%s: ISA mismatch (-mips%d) with previous modules (-mips%d)"),
2446 bfd_get_filename (ibfd
), new_isa
, old_isa
);
2453 (*_bfd_error_handler
)
2454 (_("%s: ISA mismatch (%d) with previous modules (%d)"),
2455 bfd_get_filename (ibfd
),
2456 elf_mips_mach (new_flags
),
2457 elf_mips_mach (old_flags
));
2461 new_flags
&= ~ (EF_MIPS_ARCH
| EF_MIPS_MACH
);
2462 old_flags
&= ~ (EF_MIPS_ARCH
| EF_MIPS_MACH
);
2465 /* Compare ABI's. The 64-bit ABI does not use EF_MIPS_ABI. But, it
2466 does set EI_CLASS differently from any 32-bit ABI. */
2467 if ((new_flags
& EF_MIPS_ABI
) != (old_flags
& EF_MIPS_ABI
)
2468 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
2469 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
2471 /* Only error if both are set (to different values). */
2472 if (((new_flags
& EF_MIPS_ABI
) && (old_flags
& EF_MIPS_ABI
))
2473 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
2474 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
2476 (*_bfd_error_handler
)
2477 (_("%s: ABI mismatch: linking %s module with previous %s modules"),
2478 bfd_get_filename (ibfd
),
2479 elf_mips_abi_name (ibfd
),
2480 elf_mips_abi_name (obfd
));
2483 new_flags
&= ~EF_MIPS_ABI
;
2484 old_flags
&= ~EF_MIPS_ABI
;
2487 /* Warn about any other mismatches */
2488 if (new_flags
!= old_flags
)
2490 (*_bfd_error_handler
)
2491 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
2492 bfd_get_filename (ibfd
), (unsigned long) new_flags
,
2493 (unsigned long) old_flags
);
2499 bfd_set_error (bfd_error_bad_value
);
2507 _bfd_mips_elf_print_private_bfd_data (abfd
, ptr
)
2511 FILE *file
= (FILE *) ptr
;
2513 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
2515 /* Print normal ELF private data. */
2516 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
2518 /* xgettext:c-format */
2519 fprintf (file
, _ ("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
2521 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
)
2522 fprintf (file
, _ (" [abi=O32]"));
2523 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O64
)
2524 fprintf (file
, _ (" [abi=O64]"));
2525 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
)
2526 fprintf (file
, _ (" [abi=EABI32]"));
2527 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
2528 fprintf (file
, _ (" [abi=EABI64]"));
2529 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
))
2530 fprintf (file
, _ (" [abi unknown]"));
2531 else if (ABI_N32_P (abfd
))
2532 fprintf (file
, _ (" [abi=N32]"));
2533 else if (ABI_64_P (abfd
))
2534 fprintf (file
, _ (" [abi=64]"));
2536 fprintf (file
, _ (" [no abi set]"));
2538 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
2539 fprintf (file
, _ (" [mips1]"));
2540 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
2541 fprintf (file
, _ (" [mips2]"));
2542 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
2543 fprintf (file
, _ (" [mips3]"));
2544 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
2545 fprintf (file
, _ (" [mips4]"));
2547 fprintf (file
, _ (" [unknown ISA]"));
2549 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_32BITMODE
)
2550 fprintf (file
, _ (" [32bitmode]"));
2552 fprintf (file
, _ (" [not 32bitmode]"));
2559 /* Handle a MIPS specific section when reading an object file. This
2560 is called when elfcode.h finds a section with an unknown type.
2561 This routine supports both the 32-bit and 64-bit ELF ABI.
2563 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
2567 _bfd_mips_elf_section_from_shdr (abfd
, hdr
, name
)
2569 Elf_Internal_Shdr
*hdr
;
2574 /* There ought to be a place to keep ELF backend specific flags, but
2575 at the moment there isn't one. We just keep track of the
2576 sections by their name, instead. Fortunately, the ABI gives
2577 suggested names for all the MIPS specific sections, so we will
2578 probably get away with this. */
2579 switch (hdr
->sh_type
)
2581 case SHT_MIPS_LIBLIST
:
2582 if (strcmp (name
, ".liblist") != 0)
2586 if (strcmp (name
, MIPS_ELF_MSYM_SECTION_NAME (abfd
)) != 0)
2589 case SHT_MIPS_CONFLICT
:
2590 if (strcmp (name
, ".conflict") != 0)
2593 case SHT_MIPS_GPTAB
:
2594 if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) != 0)
2597 case SHT_MIPS_UCODE
:
2598 if (strcmp (name
, ".ucode") != 0)
2601 case SHT_MIPS_DEBUG
:
2602 if (strcmp (name
, ".mdebug") != 0)
2604 flags
= SEC_DEBUGGING
;
2606 case SHT_MIPS_REGINFO
:
2607 if (strcmp (name
, ".reginfo") != 0
2608 || hdr
->sh_size
!= sizeof (Elf32_External_RegInfo
))
2610 flags
= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_SIZE
);
2612 case SHT_MIPS_IFACE
:
2613 if (strcmp (name
, ".MIPS.interfaces") != 0)
2616 case SHT_MIPS_CONTENT
:
2617 if (strncmp (name
, ".MIPS.content", sizeof ".MIPS.content" - 1) != 0)
2620 case SHT_MIPS_OPTIONS
:
2621 if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) != 0)
2624 case SHT_MIPS_DWARF
:
2625 if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) != 0)
2628 case SHT_MIPS_SYMBOL_LIB
:
2629 if (strcmp (name
, ".MIPS.symlib") != 0)
2632 case SHT_MIPS_EVENTS
:
2633 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) != 0
2634 && strncmp (name
, ".MIPS.post_rel",
2635 sizeof ".MIPS.post_rel" - 1) != 0)
2642 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
2647 if (! bfd_set_section_flags (abfd
, hdr
->bfd_section
,
2648 (bfd_get_section_flags (abfd
,
2654 /* FIXME: We should record sh_info for a .gptab section. */
2656 /* For a .reginfo section, set the gp value in the tdata information
2657 from the contents of this section. We need the gp value while
2658 processing relocs, so we just get it now. The .reginfo section
2659 is not used in the 64-bit MIPS ELF ABI. */
2660 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
2662 Elf32_External_RegInfo ext
;
2665 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, (PTR
) &ext
,
2666 (file_ptr
) 0, sizeof ext
))
2668 bfd_mips_elf32_swap_reginfo_in (abfd
, &ext
, &s
);
2669 elf_gp (abfd
) = s
.ri_gp_value
;
2672 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
2673 set the gp value based on what we find. We may see both
2674 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
2675 they should agree. */
2676 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
)
2678 bfd_byte
*contents
, *l
, *lend
;
2680 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
2681 if (contents
== NULL
)
2683 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
,
2684 (file_ptr
) 0, hdr
->sh_size
))
2690 lend
= contents
+ hdr
->sh_size
;
2691 while (l
+ sizeof (Elf_External_Options
) <= lend
)
2693 Elf_Internal_Options intopt
;
2695 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
2697 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
2699 Elf64_Internal_RegInfo intreg
;
2701 bfd_mips_elf64_swap_reginfo_in
2703 ((Elf64_External_RegInfo
*)
2704 (l
+ sizeof (Elf_External_Options
))),
2706 elf_gp (abfd
) = intreg
.ri_gp_value
;
2708 else if (intopt
.kind
== ODK_REGINFO
)
2710 Elf32_RegInfo intreg
;
2712 bfd_mips_elf32_swap_reginfo_in
2714 ((Elf32_External_RegInfo
*)
2715 (l
+ sizeof (Elf_External_Options
))),
2717 elf_gp (abfd
) = intreg
.ri_gp_value
;
2727 /* Set the correct type for a MIPS ELF section. We do this by the
2728 section name, which is a hack, but ought to work. This routine is
2729 used by both the 32-bit and the 64-bit ABI. */
2732 _bfd_mips_elf_fake_sections (abfd
, hdr
, sec
)
2734 Elf32_Internal_Shdr
*hdr
;
2737 register const char *name
;
2739 name
= bfd_get_section_name (abfd
, sec
);
2741 if (strcmp (name
, ".liblist") == 0)
2743 hdr
->sh_type
= SHT_MIPS_LIBLIST
;
2744 hdr
->sh_info
= sec
->_raw_size
/ sizeof (Elf32_Lib
);
2745 /* The sh_link field is set in final_write_processing. */
2747 else if (strcmp (name
, ".conflict") == 0)
2748 hdr
->sh_type
= SHT_MIPS_CONFLICT
;
2749 else if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0)
2751 hdr
->sh_type
= SHT_MIPS_GPTAB
;
2752 hdr
->sh_entsize
= sizeof (Elf32_External_gptab
);
2753 /* The sh_info field is set in final_write_processing. */
2755 else if (strcmp (name
, ".ucode") == 0)
2756 hdr
->sh_type
= SHT_MIPS_UCODE
;
2757 else if (strcmp (name
, ".mdebug") == 0)
2759 hdr
->sh_type
= SHT_MIPS_DEBUG
;
2760 /* In a shared object on Irix 5.3, the .mdebug section has an
2761 entsize of 0. FIXME: Does this matter? */
2762 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
2763 hdr
->sh_entsize
= 0;
2765 hdr
->sh_entsize
= 1;
2767 else if (strcmp (name
, ".reginfo") == 0)
2769 hdr
->sh_type
= SHT_MIPS_REGINFO
;
2770 /* In a shared object on Irix 5.3, the .reginfo section has an
2771 entsize of 0x18. FIXME: Does this matter? */
2772 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
2773 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
2775 hdr
->sh_entsize
= 1;
2777 else if (SGI_COMPAT (abfd
)
2778 && (strcmp (name
, ".hash") == 0
2779 || strcmp (name
, ".dynamic") == 0
2780 || strcmp (name
, ".dynstr") == 0))
2782 hdr
->sh_entsize
= 0;
2784 /* This isn't how the Irix 6 linker behaves. */
2785 hdr
->sh_info
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
2788 else if (strcmp (name
, ".got") == 0
2789 || strcmp (name
, MIPS_ELF_SRDATA_SECTION_NAME (abfd
)) == 0
2790 || strcmp (name
, ".sdata") == 0
2791 || strcmp (name
, ".sbss") == 0
2792 || strcmp (name
, ".lit4") == 0
2793 || strcmp (name
, ".lit8") == 0)
2794 hdr
->sh_flags
|= SHF_MIPS_GPREL
;
2795 else if (strcmp (name
, ".MIPS.interfaces") == 0)
2797 hdr
->sh_type
= SHT_MIPS_IFACE
;
2798 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
2800 else if (strncmp (name
, ".MIPS.content", strlen (".MIPS.content")) == 0)
2802 hdr
->sh_type
= SHT_MIPS_CONTENT
;
2803 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
2804 /* The sh_info field is set in final_write_processing. */
2806 else if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
2808 hdr
->sh_type
= SHT_MIPS_OPTIONS
;
2809 hdr
->sh_entsize
= 1;
2810 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
2812 else if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) == 0)
2813 hdr
->sh_type
= SHT_MIPS_DWARF
;
2814 else if (strcmp (name
, ".MIPS.symlib") == 0)
2816 hdr
->sh_type
= SHT_MIPS_SYMBOL_LIB
;
2817 /* The sh_link and sh_info fields are set in
2818 final_write_processing. */
2820 else if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0
2821 || strncmp (name
, ".MIPS.post_rel",
2822 sizeof ".MIPS.post_rel" - 1) == 0)
2824 hdr
->sh_type
= SHT_MIPS_EVENTS
;
2825 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
2826 /* The sh_link field is set in final_write_processing. */
2828 else if (strcmp (name
, MIPS_ELF_MSYM_SECTION_NAME (abfd
)) == 0)
2830 hdr
->sh_type
= SHT_MIPS_MSYM
;
2831 hdr
->sh_flags
|= SHF_ALLOC
;
2832 hdr
->sh_entsize
= 8;
2835 /* The generic elf_fake_sections will set up REL_HDR using the
2836 default kind of relocations. But, we may actually need both
2837 kinds of relocations, so we set up the second header here. */
2838 if ((sec
->flags
& SEC_RELOC
) != 0)
2840 struct bfd_elf_section_data
*esd
;
2842 esd
= elf_section_data (sec
);
2843 BFD_ASSERT (esd
->rel_hdr2
== NULL
);
2845 = (Elf_Internal_Shdr
*) bfd_zalloc (abfd
, sizeof (Elf_Internal_Shdr
));
2848 _bfd_elf_init_reloc_shdr (abfd
, esd
->rel_hdr2
, sec
,
2849 !elf_section_data (sec
)->use_rela_p
);
2855 /* Given a BFD section, try to locate the corresponding ELF section
2856 index. This is used by both the 32-bit and the 64-bit ABI.
2857 Actually, it's not clear to me that the 64-bit ABI supports these,
2858 but for non-PIC objects we will certainly want support for at least
2859 the .scommon section. */
2862 _bfd_mips_elf_section_from_bfd_section (abfd
, hdr
, sec
, retval
)
2863 bfd
*abfd ATTRIBUTE_UNUSED
;
2864 Elf32_Internal_Shdr
*hdr ATTRIBUTE_UNUSED
;
2868 if (strcmp (bfd_get_section_name (abfd
, sec
), ".scommon") == 0)
2870 *retval
= SHN_MIPS_SCOMMON
;
2873 if (strcmp (bfd_get_section_name (abfd
, sec
), ".acommon") == 0)
2875 *retval
= SHN_MIPS_ACOMMON
;
2881 /* When are writing out the .options or .MIPS.options section,
2882 remember the bytes we are writing out, so that we can install the
2883 GP value in the section_processing routine. */
2886 _bfd_mips_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
2891 bfd_size_type count
;
2893 if (strcmp (section
->name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
2897 if (elf_section_data (section
) == NULL
)
2899 section
->used_by_bfd
=
2900 (PTR
) bfd_zalloc (abfd
, sizeof (struct bfd_elf_section_data
));
2901 if (elf_section_data (section
) == NULL
)
2904 c
= (bfd_byte
*) elf_section_data (section
)->tdata
;
2909 if (section
->_cooked_size
!= 0)
2910 size
= section
->_cooked_size
;
2912 size
= section
->_raw_size
;
2913 c
= (bfd_byte
*) bfd_zalloc (abfd
, size
);
2916 elf_section_data (section
)->tdata
= (PTR
) c
;
2919 memcpy (c
+ offset
, location
, count
);
2922 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
,
2926 /* Work over a section just before writing it out. This routine is
2927 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
2928 sections that need the SHF_MIPS_GPREL flag by name; there has to be
2932 _bfd_mips_elf_section_processing (abfd
, hdr
)
2934 Elf_Internal_Shdr
*hdr
;
2936 if (hdr
->sh_type
== SHT_MIPS_REGINFO
2937 && hdr
->sh_size
> 0)
2941 BFD_ASSERT (hdr
->sh_size
== sizeof (Elf32_External_RegInfo
));
2942 BFD_ASSERT (hdr
->contents
== NULL
);
2945 hdr
->sh_offset
+ sizeof (Elf32_External_RegInfo
) - 4,
2948 bfd_h_put_32 (abfd
, (bfd_vma
) elf_gp (abfd
), buf
);
2949 if (bfd_write (buf
, (bfd_size_type
) 1, (bfd_size_type
) 4, abfd
) != 4)
2953 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
2954 && hdr
->bfd_section
!= NULL
2955 && elf_section_data (hdr
->bfd_section
) != NULL
2956 && elf_section_data (hdr
->bfd_section
)->tdata
!= NULL
)
2958 bfd_byte
*contents
, *l
, *lend
;
2960 /* We stored the section contents in the elf_section_data tdata
2961 field in the set_section_contents routine. We save the
2962 section contents so that we don't have to read them again.
2963 At this point we know that elf_gp is set, so we can look
2964 through the section contents to see if there is an
2965 ODK_REGINFO structure. */
2967 contents
= (bfd_byte
*) elf_section_data (hdr
->bfd_section
)->tdata
;
2969 lend
= contents
+ hdr
->sh_size
;
2970 while (l
+ sizeof (Elf_External_Options
) <= lend
)
2972 Elf_Internal_Options intopt
;
2974 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
2976 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
2983 + sizeof (Elf_External_Options
)
2984 + (sizeof (Elf64_External_RegInfo
) - 8)),
2987 bfd_h_put_64 (abfd
, elf_gp (abfd
), buf
);
2988 if (bfd_write (buf
, 1, 8, abfd
) != 8)
2991 else if (intopt
.kind
== ODK_REGINFO
)
2998 + sizeof (Elf_External_Options
)
2999 + (sizeof (Elf32_External_RegInfo
) - 4)),
3002 bfd_h_put_32 (abfd
, elf_gp (abfd
), buf
);
3003 if (bfd_write (buf
, 1, 4, abfd
) != 4)
3010 if (hdr
->bfd_section
!= NULL
)
3012 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
3014 if (strcmp (name
, ".sdata") == 0
3015 || strcmp (name
, ".lit8") == 0
3016 || strcmp (name
, ".lit4") == 0)
3018 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
3019 hdr
->sh_type
= SHT_PROGBITS
;
3021 else if (strcmp (name
, ".sbss") == 0)
3023 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
3024 hdr
->sh_type
= SHT_NOBITS
;
3026 else if (strcmp (name
, MIPS_ELF_SRDATA_SECTION_NAME (abfd
)) == 0)
3028 hdr
->sh_flags
|= SHF_ALLOC
| SHF_MIPS_GPREL
;
3029 hdr
->sh_type
= SHT_PROGBITS
;
3031 else if (strcmp (name
, ".compact_rel") == 0)
3034 hdr
->sh_type
= SHT_PROGBITS
;
3036 else if (strcmp (name
, ".rtproc") == 0)
3038 if (hdr
->sh_addralign
!= 0 && hdr
->sh_entsize
== 0)
3040 unsigned int adjust
;
3042 adjust
= hdr
->sh_size
% hdr
->sh_addralign
;
3044 hdr
->sh_size
+= hdr
->sh_addralign
- adjust
;
3053 /* MIPS ELF uses two common sections. One is the usual one, and the
3054 other is for small objects. All the small objects are kept
3055 together, and then referenced via the gp pointer, which yields
3056 faster assembler code. This is what we use for the small common
3057 section. This approach is copied from ecoff.c. */
3058 static asection mips_elf_scom_section
;
3059 static asymbol mips_elf_scom_symbol
;
3060 static asymbol
*mips_elf_scom_symbol_ptr
;
3062 /* MIPS ELF also uses an acommon section, which represents an
3063 allocated common symbol which may be overridden by a
3064 definition in a shared library. */
3065 static asection mips_elf_acom_section
;
3066 static asymbol mips_elf_acom_symbol
;
3067 static asymbol
*mips_elf_acom_symbol_ptr
;
3069 /* The Irix 5 support uses two virtual sections, which represent
3070 text/data symbols defined in dynamic objects. */
3071 static asection mips_elf_text_section
;
3072 static asection
*mips_elf_text_section_ptr
;
3073 static asymbol mips_elf_text_symbol
;
3074 static asymbol
*mips_elf_text_symbol_ptr
;
3076 static asection mips_elf_data_section
;
3077 static asection
*mips_elf_data_section_ptr
;
3078 static asymbol mips_elf_data_symbol
;
3079 static asymbol
*mips_elf_data_symbol_ptr
;
3081 /* Handle the special MIPS section numbers that a symbol may use.
3082 This is used for both the 32-bit and the 64-bit ABI. */
3085 _bfd_mips_elf_symbol_processing (abfd
, asym
)
3089 elf_symbol_type
*elfsym
;
3091 elfsym
= (elf_symbol_type
*) asym
;
3092 switch (elfsym
->internal_elf_sym
.st_shndx
)
3094 case SHN_MIPS_ACOMMON
:
3095 /* This section is used in a dynamically linked executable file.
3096 It is an allocated common section. The dynamic linker can
3097 either resolve these symbols to something in a shared
3098 library, or it can just leave them here. For our purposes,
3099 we can consider these symbols to be in a new section. */
3100 if (mips_elf_acom_section
.name
== NULL
)
3102 /* Initialize the acommon section. */
3103 mips_elf_acom_section
.name
= ".acommon";
3104 mips_elf_acom_section
.flags
= SEC_ALLOC
;
3105 mips_elf_acom_section
.output_section
= &mips_elf_acom_section
;
3106 mips_elf_acom_section
.symbol
= &mips_elf_acom_symbol
;
3107 mips_elf_acom_section
.symbol_ptr_ptr
= &mips_elf_acom_symbol_ptr
;
3108 mips_elf_acom_symbol
.name
= ".acommon";
3109 mips_elf_acom_symbol
.flags
= BSF_SECTION_SYM
;
3110 mips_elf_acom_symbol
.section
= &mips_elf_acom_section
;
3111 mips_elf_acom_symbol_ptr
= &mips_elf_acom_symbol
;
3113 asym
->section
= &mips_elf_acom_section
;
3117 /* Common symbols less than the GP size are automatically
3118 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
3119 if (asym
->value
> elf_gp_size (abfd
)
3120 || IRIX_COMPAT (abfd
) == ict_irix6
)
3123 case SHN_MIPS_SCOMMON
:
3124 if (mips_elf_scom_section
.name
== NULL
)
3126 /* Initialize the small common section. */
3127 mips_elf_scom_section
.name
= ".scommon";
3128 mips_elf_scom_section
.flags
= SEC_IS_COMMON
;
3129 mips_elf_scom_section
.output_section
= &mips_elf_scom_section
;
3130 mips_elf_scom_section
.symbol
= &mips_elf_scom_symbol
;
3131 mips_elf_scom_section
.symbol_ptr_ptr
= &mips_elf_scom_symbol_ptr
;
3132 mips_elf_scom_symbol
.name
= ".scommon";
3133 mips_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
3134 mips_elf_scom_symbol
.section
= &mips_elf_scom_section
;
3135 mips_elf_scom_symbol_ptr
= &mips_elf_scom_symbol
;
3137 asym
->section
= &mips_elf_scom_section
;
3138 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
3141 case SHN_MIPS_SUNDEFINED
:
3142 asym
->section
= bfd_und_section_ptr
;
3145 #if 0 /* for SGI_COMPAT */
3147 asym
->section
= mips_elf_text_section_ptr
;
3151 asym
->section
= mips_elf_data_section_ptr
;
3157 /* When creating an Irix 5 executable, we need REGINFO and RTPROC
3161 _bfd_mips_elf_additional_program_headers (abfd
)
3167 if (!SGI_COMPAT (abfd
))
3170 /* See if we need a PT_MIPS_REGINFO segment. */
3171 s
= bfd_get_section_by_name (abfd
, ".reginfo");
3172 if (s
&& (s
->flags
& SEC_LOAD
))
3175 /* See if we need a PT_MIPS_OPTIONS segment. */
3176 if (IRIX_COMPAT (abfd
) == ict_irix6
3177 && bfd_get_section_by_name (abfd
,
3178 MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)))
3181 /* See if we need a PT_MIPS_RTPROC segment. */
3182 if (IRIX_COMPAT (abfd
) == ict_irix5
3183 && bfd_get_section_by_name (abfd
, ".dynamic")
3184 && bfd_get_section_by_name (abfd
, ".mdebug"))
3190 /* Modify the segment map for an Irix 5 executable. */
3193 _bfd_mips_elf_modify_segment_map (abfd
)
3197 struct elf_segment_map
*m
, **pm
;
3199 if (! SGI_COMPAT (abfd
))
3202 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
3204 s
= bfd_get_section_by_name (abfd
, ".reginfo");
3205 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3207 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
3208 if (m
->p_type
== PT_MIPS_REGINFO
)
3212 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, sizeof *m
);
3216 m
->p_type
= PT_MIPS_REGINFO
;
3220 /* We want to put it after the PHDR and INTERP segments. */
3221 pm
= &elf_tdata (abfd
)->segment_map
;
3223 && ((*pm
)->p_type
== PT_PHDR
3224 || (*pm
)->p_type
== PT_INTERP
))
3232 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
3233 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
3234 PT_OPTIONS segement immediately following the program header
3236 if (IRIX_COMPAT (abfd
) == ict_irix6
)
3240 for (s
= abfd
->sections
; s
; s
= s
->next
)
3241 if (elf_section_data (s
)->this_hdr
.sh_type
== SHT_MIPS_OPTIONS
)
3246 struct elf_segment_map
*options_segment
;
3248 /* Usually, there's a program header table. But, sometimes
3249 there's not (like when running the `ld' testsuite). So,
3250 if there's no program header table, we just put the
3251 options segement at the end. */
3252 for (pm
= &elf_tdata (abfd
)->segment_map
;
3255 if ((*pm
)->p_type
== PT_PHDR
)
3258 options_segment
= bfd_zalloc (abfd
,
3259 sizeof (struct elf_segment_map
));
3260 options_segment
->next
= *pm
;
3261 options_segment
->p_type
= PT_MIPS_OPTIONS
;
3262 options_segment
->p_flags
= PF_R
;
3263 options_segment
->p_flags_valid
= true;
3264 options_segment
->count
= 1;
3265 options_segment
->sections
[0] = s
;
3266 *pm
= options_segment
;
3271 /* If there are .dynamic and .mdebug sections, we make a room
3272 for the RTPROC header. FIXME: Rewrite without section names. */
3273 if (bfd_get_section_by_name (abfd
, ".interp") == NULL
3274 && bfd_get_section_by_name (abfd
, ".dynamic") != NULL
3275 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
3277 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
3278 if (m
->p_type
== PT_MIPS_RTPROC
)
3282 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, sizeof *m
);
3286 m
->p_type
= PT_MIPS_RTPROC
;
3288 s
= bfd_get_section_by_name (abfd
, ".rtproc");
3293 m
->p_flags_valid
= 1;
3301 /* We want to put it after the DYNAMIC segment. */
3302 pm
= &elf_tdata (abfd
)->segment_map
;
3303 while (*pm
!= NULL
&& (*pm
)->p_type
!= PT_DYNAMIC
)
3313 /* On Irix 5, the PT_DYNAMIC segment includes the .dynamic,
3314 .dynstr, .dynsym, and .hash sections, and everything in
3316 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
; pm
= &(*pm
)->next
)
3317 if ((*pm
)->p_type
== PT_DYNAMIC
)
3322 && strcmp (m
->sections
[0]->name
, ".dynamic") == 0)
3324 static const char *sec_names
[] =
3325 { ".dynamic", ".dynstr", ".dynsym", ".hash" };
3328 struct elf_segment_map
*n
;
3332 for (i
= 0; i
< sizeof sec_names
/ sizeof sec_names
[0]; i
++)
3334 s
= bfd_get_section_by_name (abfd
, sec_names
[i
]);
3335 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3341 sz
= s
->_cooked_size
;
3344 if (high
< s
->vma
+ sz
)
3350 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3351 if ((s
->flags
& SEC_LOAD
) != 0
3354 + (s
->_cooked_size
!= 0 ? s
->_cooked_size
: s
->_raw_size
))
3358 n
= ((struct elf_segment_map
*)
3359 bfd_zalloc (abfd
, sizeof *n
+ (c
- 1) * sizeof (asection
*)));
3366 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3368 if ((s
->flags
& SEC_LOAD
) != 0
3371 + (s
->_cooked_size
!= 0 ?
3372 s
->_cooked_size
: s
->_raw_size
))
3387 /* The structure of the runtime procedure descriptor created by the
3388 loader for use by the static exception system. */
3390 typedef struct runtime_pdr
{
3391 bfd_vma adr
; /* memory address of start of procedure */
3392 long regmask
; /* save register mask */
3393 long regoffset
; /* save register offset */
3394 long fregmask
; /* save floating point register mask */
3395 long fregoffset
; /* save floating point register offset */
3396 long frameoffset
; /* frame size */
3397 short framereg
; /* frame pointer register */
3398 short pcreg
; /* offset or reg of return pc */
3399 long irpss
; /* index into the runtime string table */
3401 struct exception_info
*exception_info
;/* pointer to exception array */
3403 #define cbRPDR sizeof(RPDR)
3404 #define rpdNil ((pRPDR) 0)
3406 /* Swap RPDR (runtime procedure table entry) for output. */
3408 static void ecoff_swap_rpdr_out
3409 PARAMS ((bfd
*, const RPDR
*, struct rpdr_ext
*));
3412 ecoff_swap_rpdr_out (abfd
, in
, ex
)
3415 struct rpdr_ext
*ex
;
3417 /* ecoff_put_off was defined in ecoffswap.h. */
3418 ecoff_put_off (abfd
, in
->adr
, (bfd_byte
*) ex
->p_adr
);
3419 bfd_h_put_32 (abfd
, in
->regmask
, (bfd_byte
*) ex
->p_regmask
);
3420 bfd_h_put_32 (abfd
, in
->regoffset
, (bfd_byte
*) ex
->p_regoffset
);
3421 bfd_h_put_32 (abfd
, in
->fregmask
, (bfd_byte
*) ex
->p_fregmask
);
3422 bfd_h_put_32 (abfd
, in
->fregoffset
, (bfd_byte
*) ex
->p_fregoffset
);
3423 bfd_h_put_32 (abfd
, in
->frameoffset
, (bfd_byte
*) ex
->p_frameoffset
);
3425 bfd_h_put_16 (abfd
, in
->framereg
, (bfd_byte
*) ex
->p_framereg
);
3426 bfd_h_put_16 (abfd
, in
->pcreg
, (bfd_byte
*) ex
->p_pcreg
);
3428 bfd_h_put_32 (abfd
, in
->irpss
, (bfd_byte
*) ex
->p_irpss
);
3430 ecoff_put_off (abfd
, in
->exception_info
, (bfd_byte
*) ex
->p_exception_info
);
3434 /* Read ECOFF debugging information from a .mdebug section into a
3435 ecoff_debug_info structure. */
3438 _bfd_mips_elf_read_ecoff_info (abfd
, section
, debug
)
3441 struct ecoff_debug_info
*debug
;
3444 const struct ecoff_debug_swap
*swap
;
3445 char *ext_hdr
= NULL
;
3447 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
3448 memset (debug
, 0, sizeof(*debug
));
3450 ext_hdr
= (char *) bfd_malloc ((size_t) swap
->external_hdr_size
);
3451 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
3454 if (bfd_get_section_contents (abfd
, section
, ext_hdr
, (file_ptr
) 0,
3455 swap
->external_hdr_size
)
3459 symhdr
= &debug
->symbolic_header
;
3460 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
3462 /* The symbolic header contains absolute file offsets and sizes to
3464 #define READ(ptr, offset, count, size, type) \
3465 if (symhdr->count == 0) \
3466 debug->ptr = NULL; \
3469 debug->ptr = (type) bfd_malloc ((size_t) (size * symhdr->count)); \
3470 if (debug->ptr == NULL) \
3471 goto error_return; \
3472 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
3473 || (bfd_read (debug->ptr, size, symhdr->count, \
3474 abfd) != size * symhdr->count)) \
3475 goto error_return; \
3478 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
3479 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, PTR
);
3480 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, PTR
);
3481 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, PTR
);
3482 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, PTR
);
3483 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
3485 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
3486 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
3487 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, PTR
);
3488 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, PTR
);
3489 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, PTR
);
3493 debug
->adjust
= NULL
;
3498 if (ext_hdr
!= NULL
)
3500 if (debug
->line
!= NULL
)
3502 if (debug
->external_dnr
!= NULL
)
3503 free (debug
->external_dnr
);
3504 if (debug
->external_pdr
!= NULL
)
3505 free (debug
->external_pdr
);
3506 if (debug
->external_sym
!= NULL
)
3507 free (debug
->external_sym
);
3508 if (debug
->external_opt
!= NULL
)
3509 free (debug
->external_opt
);
3510 if (debug
->external_aux
!= NULL
)
3511 free (debug
->external_aux
);
3512 if (debug
->ss
!= NULL
)
3514 if (debug
->ssext
!= NULL
)
3515 free (debug
->ssext
);
3516 if (debug
->external_fdr
!= NULL
)
3517 free (debug
->external_fdr
);
3518 if (debug
->external_rfd
!= NULL
)
3519 free (debug
->external_rfd
);
3520 if (debug
->external_ext
!= NULL
)
3521 free (debug
->external_ext
);
3525 /* MIPS ELF local labels start with '$', not 'L'. */
3529 mips_elf_is_local_label_name (abfd
, name
)
3536 /* On Irix 6, the labels go back to starting with '.', so we accept
3537 the generic ELF local label syntax as well. */
3538 return _bfd_elf_is_local_label_name (abfd
, name
);
3541 /* MIPS ELF uses a special find_nearest_line routine in order the
3542 handle the ECOFF debugging information. */
3544 struct mips_elf_find_line
3546 struct ecoff_debug_info d
;
3547 struct ecoff_find_line i
;
3551 _bfd_mips_elf_find_nearest_line (abfd
, section
, symbols
, offset
, filename_ptr
,
3552 functionname_ptr
, line_ptr
)
3557 const char **filename_ptr
;
3558 const char **functionname_ptr
;
3559 unsigned int *line_ptr
;
3563 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
3564 filename_ptr
, functionname_ptr
,
3568 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
3569 filename_ptr
, functionname_ptr
,
3571 ABI_64_P (abfd
) ? 8 : 0))
3574 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
3578 struct mips_elf_find_line
*fi
;
3579 const struct ecoff_debug_swap
* const swap
=
3580 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
3582 /* If we are called during a link, mips_elf_final_link may have
3583 cleared the SEC_HAS_CONTENTS field. We force it back on here
3584 if appropriate (which it normally will be). */
3585 origflags
= msec
->flags
;
3586 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
3587 msec
->flags
|= SEC_HAS_CONTENTS
;
3589 fi
= elf_tdata (abfd
)->find_line_info
;
3592 bfd_size_type external_fdr_size
;
3595 struct fdr
*fdr_ptr
;
3597 fi
= ((struct mips_elf_find_line
*)
3598 bfd_zalloc (abfd
, sizeof (struct mips_elf_find_line
)));
3601 msec
->flags
= origflags
;
3605 if (! _bfd_mips_elf_read_ecoff_info (abfd
, msec
, &fi
->d
))
3607 msec
->flags
= origflags
;
3611 /* Swap in the FDR information. */
3612 fi
->d
.fdr
= ((struct fdr
*)
3614 (fi
->d
.symbolic_header
.ifdMax
*
3615 sizeof (struct fdr
))));
3616 if (fi
->d
.fdr
== NULL
)
3618 msec
->flags
= origflags
;
3621 external_fdr_size
= swap
->external_fdr_size
;
3622 fdr_ptr
= fi
->d
.fdr
;
3623 fraw_src
= (char *) fi
->d
.external_fdr
;
3624 fraw_end
= (fraw_src
3625 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
3626 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
3627 (*swap
->swap_fdr_in
) (abfd
, (PTR
) fraw_src
, fdr_ptr
);
3629 elf_tdata (abfd
)->find_line_info
= fi
;
3631 /* Note that we don't bother to ever free this information.
3632 find_nearest_line is either called all the time, as in
3633 objdump -l, so the information should be saved, or it is
3634 rarely called, as in ld error messages, so the memory
3635 wasted is unimportant. Still, it would probably be a
3636 good idea for free_cached_info to throw it away. */
3639 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
3640 &fi
->i
, filename_ptr
, functionname_ptr
,
3643 msec
->flags
= origflags
;
3647 msec
->flags
= origflags
;
3650 /* Fall back on the generic ELF find_nearest_line routine. */
3652 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
3653 filename_ptr
, functionname_ptr
,
3657 /* The mips16 compiler uses a couple of special sections to handle
3658 floating point arguments.
3660 Section names that look like .mips16.fn.FNNAME contain stubs that
3661 copy floating point arguments from the fp regs to the gp regs and
3662 then jump to FNNAME. If any 32 bit function calls FNNAME, the
3663 call should be redirected to the stub instead. If no 32 bit
3664 function calls FNNAME, the stub should be discarded. We need to
3665 consider any reference to the function, not just a call, because
3666 if the address of the function is taken we will need the stub,
3667 since the address might be passed to a 32 bit function.
3669 Section names that look like .mips16.call.FNNAME contain stubs
3670 that copy floating point arguments from the gp regs to the fp
3671 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
3672 then any 16 bit function that calls FNNAME should be redirected
3673 to the stub instead. If FNNAME is not a 32 bit function, the
3674 stub should be discarded.
3676 .mips16.call.fp.FNNAME sections are similar, but contain stubs
3677 which call FNNAME and then copy the return value from the fp regs
3678 to the gp regs. These stubs store the return value in $18 while
3679 calling FNNAME; any function which might call one of these stubs
3680 must arrange to save $18 around the call. (This case is not
3681 needed for 32 bit functions that call 16 bit functions, because
3682 16 bit functions always return floating point values in both
3685 Note that in all cases FNNAME might be defined statically.
3686 Therefore, FNNAME is not used literally. Instead, the relocation
3687 information will indicate which symbol the section is for.
3689 We record any stubs that we find in the symbol table. */
3691 #define FN_STUB ".mips16.fn."
3692 #define CALL_STUB ".mips16.call."
3693 #define CALL_FP_STUB ".mips16.call.fp."
3695 /* MIPS ELF linker hash table. */
3697 struct mips_elf_link_hash_table
3699 struct elf_link_hash_table root
;
3701 /* We no longer use this. */
3702 /* String section indices for the dynamic section symbols. */
3703 bfd_size_type dynsym_sec_strindex
[SIZEOF_MIPS_DYNSYM_SECNAMES
];
3705 /* The number of .rtproc entries. */
3706 bfd_size_type procedure_count
;
3707 /* The size of the .compact_rel section (if SGI_COMPAT). */
3708 bfd_size_type compact_rel_size
;
3709 /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic
3710 entry is set to the address of __rld_obj_head as in Irix 5. */
3711 boolean use_rld_obj_head
;
3712 /* This is the value of the __rld_map or __rld_obj_head symbol. */
3714 /* This is set if we see any mips16 stub sections. */
3715 boolean mips16_stubs_seen
;
3718 /* Look up an entry in a MIPS ELF linker hash table. */
3720 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
3721 ((struct mips_elf_link_hash_entry *) \
3722 elf_link_hash_lookup (&(table)->root, (string), (create), \
3725 /* Traverse a MIPS ELF linker hash table. */
3727 #define mips_elf_link_hash_traverse(table, func, info) \
3728 (elf_link_hash_traverse \
3730 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
3733 /* Get the MIPS ELF linker hash table from a link_info structure. */
3735 #define mips_elf_hash_table(p) \
3736 ((struct mips_elf_link_hash_table *) ((p)->hash))
3738 static boolean mips_elf_output_extsym
3739 PARAMS ((struct mips_elf_link_hash_entry
*, PTR
));
3741 /* Create an entry in a MIPS ELF linker hash table. */
3743 static struct bfd_hash_entry
*
3744 mips_elf_link_hash_newfunc (entry
, table
, string
)
3745 struct bfd_hash_entry
*entry
;
3746 struct bfd_hash_table
*table
;
3749 struct mips_elf_link_hash_entry
*ret
=
3750 (struct mips_elf_link_hash_entry
*) entry
;
3752 /* Allocate the structure if it has not already been allocated by a
3754 if (ret
== (struct mips_elf_link_hash_entry
*) NULL
)
3755 ret
= ((struct mips_elf_link_hash_entry
*)
3756 bfd_hash_allocate (table
,
3757 sizeof (struct mips_elf_link_hash_entry
)));
3758 if (ret
== (struct mips_elf_link_hash_entry
*) NULL
)
3759 return (struct bfd_hash_entry
*) ret
;
3761 /* Call the allocation method of the superclass. */
3762 ret
= ((struct mips_elf_link_hash_entry
*)
3763 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
3765 if (ret
!= (struct mips_elf_link_hash_entry
*) NULL
)
3767 /* Set local fields. */
3768 memset (&ret
->esym
, 0, sizeof (EXTR
));
3769 /* We use -2 as a marker to indicate that the information has
3770 not been set. -1 means there is no associated ifd. */
3772 ret
->possibly_dynamic_relocs
= 0;
3773 ret
->min_dyn_reloc_index
= 0;
3774 ret
->fn_stub
= NULL
;
3775 ret
->need_fn_stub
= false;
3776 ret
->call_stub
= NULL
;
3777 ret
->call_fp_stub
= NULL
;
3780 return (struct bfd_hash_entry
*) ret
;
3783 /* Create a MIPS ELF linker hash table. */
3785 struct bfd_link_hash_table
*
3786 _bfd_mips_elf_link_hash_table_create (abfd
)
3789 struct mips_elf_link_hash_table
*ret
;
3791 ret
= ((struct mips_elf_link_hash_table
*)
3792 bfd_alloc (abfd
, sizeof (struct mips_elf_link_hash_table
)));
3793 if (ret
== (struct mips_elf_link_hash_table
*) NULL
)
3796 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
3797 mips_elf_link_hash_newfunc
))
3799 bfd_release (abfd
, ret
);
3804 /* We no longer use this. */
3805 for (i
= 0; i
< SIZEOF_MIPS_DYNSYM_SECNAMES
; i
++)
3806 ret
->dynsym_sec_strindex
[i
] = (bfd_size_type
) -1;
3808 ret
->procedure_count
= 0;
3809 ret
->compact_rel_size
= 0;
3810 ret
->use_rld_obj_head
= false;
3812 ret
->mips16_stubs_seen
= false;
3814 return &ret
->root
.root
;
3817 /* Hook called by the linker routine which adds symbols from an object
3818 file. We must handle the special MIPS section numbers here. */
3822 _bfd_mips_elf_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
, secp
, valp
)
3824 struct bfd_link_info
*info
;
3825 const Elf_Internal_Sym
*sym
;
3827 flagword
*flagsp ATTRIBUTE_UNUSED
;
3831 if (SGI_COMPAT (abfd
)
3832 && (abfd
->flags
& DYNAMIC
) != 0
3833 && strcmp (*namep
, "_rld_new_interface") == 0)
3835 /* Skip Irix 5 rld entry name. */
3840 switch (sym
->st_shndx
)
3843 /* Common symbols less than the GP size are automatically
3844 treated as SHN_MIPS_SCOMMON symbols. */
3845 if (sym
->st_size
> elf_gp_size (abfd
)
3846 || IRIX_COMPAT (abfd
) == ict_irix6
)
3849 case SHN_MIPS_SCOMMON
:
3850 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
3851 (*secp
)->flags
|= SEC_IS_COMMON
;
3852 *valp
= sym
->st_size
;
3856 /* This section is used in a shared object. */
3857 if (mips_elf_text_section_ptr
== NULL
)
3859 /* Initialize the section. */
3860 mips_elf_text_section
.name
= ".text";
3861 mips_elf_text_section
.flags
= SEC_NO_FLAGS
;
3862 mips_elf_text_section
.output_section
= NULL
;
3863 mips_elf_text_section
.symbol
= &mips_elf_text_symbol
;
3864 mips_elf_text_section
.symbol_ptr_ptr
= &mips_elf_text_symbol_ptr
;
3865 mips_elf_text_symbol
.name
= ".text";
3866 mips_elf_text_symbol
.flags
= BSF_SECTION_SYM
;
3867 mips_elf_text_symbol
.section
= &mips_elf_text_section
;
3868 mips_elf_text_symbol_ptr
= &mips_elf_text_symbol
;
3869 mips_elf_text_section_ptr
= &mips_elf_text_section
;
3871 /* This code used to do *secp = bfd_und_section_ptr if
3872 info->shared. I don't know why, and that doesn't make sense,
3873 so I took it out. */
3874 *secp
= mips_elf_text_section_ptr
;
3877 case SHN_MIPS_ACOMMON
:
3878 /* Fall through. XXX Can we treat this as allocated data? */
3880 /* This section is used in a shared object. */
3881 if (mips_elf_data_section_ptr
== NULL
)
3883 /* Initialize the section. */
3884 mips_elf_data_section
.name
= ".data";
3885 mips_elf_data_section
.flags
= SEC_NO_FLAGS
;
3886 mips_elf_data_section
.output_section
= NULL
;
3887 mips_elf_data_section
.symbol
= &mips_elf_data_symbol
;
3888 mips_elf_data_section
.symbol_ptr_ptr
= &mips_elf_data_symbol_ptr
;
3889 mips_elf_data_symbol
.name
= ".data";
3890 mips_elf_data_symbol
.flags
= BSF_SECTION_SYM
;
3891 mips_elf_data_symbol
.section
= &mips_elf_data_section
;
3892 mips_elf_data_symbol_ptr
= &mips_elf_data_symbol
;
3893 mips_elf_data_section_ptr
= &mips_elf_data_section
;
3895 /* This code used to do *secp = bfd_und_section_ptr if
3896 info->shared. I don't know why, and that doesn't make sense,
3897 so I took it out. */
3898 *secp
= mips_elf_data_section_ptr
;
3901 case SHN_MIPS_SUNDEFINED
:
3902 *secp
= bfd_und_section_ptr
;
3906 if (SGI_COMPAT (abfd
)
3908 && info
->hash
->creator
== abfd
->xvec
3909 && strcmp (*namep
, "__rld_obj_head") == 0)
3911 struct elf_link_hash_entry
*h
;
3913 /* Mark __rld_obj_head as dynamic. */
3915 if (! (_bfd_generic_link_add_one_symbol
3916 (info
, abfd
, *namep
, BSF_GLOBAL
, *secp
,
3917 (bfd_vma
) *valp
, (const char *) NULL
, false,
3918 get_elf_backend_data (abfd
)->collect
,
3919 (struct bfd_link_hash_entry
**) &h
)))
3921 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
3922 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
3923 h
->type
= STT_OBJECT
;
3925 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
3928 mips_elf_hash_table (info
)->use_rld_obj_head
= true;
3931 /* If this is a mips16 text symbol, add 1 to the value to make it
3932 odd. This will cause something like .word SYM to come up with
3933 the right value when it is loaded into the PC. */
3934 if (sym
->st_other
== STO_MIPS16
)
3940 /* Structure used to pass information to mips_elf_output_extsym. */
3945 struct bfd_link_info
*info
;
3946 struct ecoff_debug_info
*debug
;
3947 const struct ecoff_debug_swap
*swap
;
3951 /* This routine is used to write out ECOFF debugging external symbol
3952 information. It is called via mips_elf_link_hash_traverse. The
3953 ECOFF external symbol information must match the ELF external
3954 symbol information. Unfortunately, at this point we don't know
3955 whether a symbol is required by reloc information, so the two
3956 tables may wind up being different. We must sort out the external
3957 symbol information before we can set the final size of the .mdebug
3958 section, and we must set the size of the .mdebug section before we
3959 can relocate any sections, and we can't know which symbols are
3960 required by relocation until we relocate the sections.
3961 Fortunately, it is relatively unlikely that any symbol will be
3962 stripped but required by a reloc. In particular, it can not happen
3963 when generating a final executable. */
3966 mips_elf_output_extsym (h
, data
)
3967 struct mips_elf_link_hash_entry
*h
;
3970 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
3972 asection
*sec
, *output_section
;
3974 if (h
->root
.indx
== -2)
3976 else if (((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
3977 || (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
3978 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
3979 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
3981 else if (einfo
->info
->strip
== strip_all
3982 || (einfo
->info
->strip
== strip_some
3983 && bfd_hash_lookup (einfo
->info
->keep_hash
,
3984 h
->root
.root
.root
.string
,
3985 false, false) == NULL
))
3993 if (h
->esym
.ifd
== -2)
3996 h
->esym
.cobol_main
= 0;
3997 h
->esym
.weakext
= 0;
3998 h
->esym
.reserved
= 0;
3999 h
->esym
.ifd
= ifdNil
;
4000 h
->esym
.asym
.value
= 0;
4001 h
->esym
.asym
.st
= stGlobal
;
4003 if (SGI_COMPAT (einfo
->abfd
)
4004 && (h
->root
.root
.type
== bfd_link_hash_undefined
4005 || h
->root
.root
.type
== bfd_link_hash_undefweak
))
4009 /* Use undefined class. Also, set class and type for some
4011 name
= h
->root
.root
.root
.string
;
4012 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
4013 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
4015 h
->esym
.asym
.sc
= scData
;
4016 h
->esym
.asym
.st
= stLabel
;
4017 h
->esym
.asym
.value
= 0;
4019 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
4021 h
->esym
.asym
.sc
= scAbs
;
4022 h
->esym
.asym
.st
= stLabel
;
4023 h
->esym
.asym
.value
=
4024 mips_elf_hash_table (einfo
->info
)->procedure_count
;
4026 else if (strcmp (name
, "_gp_disp") == 0)
4028 h
->esym
.asym
.sc
= scAbs
;
4029 h
->esym
.asym
.st
= stLabel
;
4030 h
->esym
.asym
.value
= elf_gp (einfo
->abfd
);
4033 h
->esym
.asym
.sc
= scUndefined
;
4035 else if (h
->root
.root
.type
!= bfd_link_hash_defined
4036 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
4037 h
->esym
.asym
.sc
= scAbs
;
4042 sec
= h
->root
.root
.u
.def
.section
;
4043 output_section
= sec
->output_section
;
4045 /* When making a shared library and symbol h is the one from
4046 the another shared library, OUTPUT_SECTION may be null. */
4047 if (output_section
== NULL
)
4048 h
->esym
.asym
.sc
= scUndefined
;
4051 name
= bfd_section_name (output_section
->owner
, output_section
);
4053 if (strcmp (name
, ".text") == 0)
4054 h
->esym
.asym
.sc
= scText
;
4055 else if (strcmp (name
, ".data") == 0)
4056 h
->esym
.asym
.sc
= scData
;
4057 else if (strcmp (name
, ".sdata") == 0)
4058 h
->esym
.asym
.sc
= scSData
;
4059 else if (strcmp (name
, ".rodata") == 0
4060 || strcmp (name
, ".rdata") == 0)
4061 h
->esym
.asym
.sc
= scRData
;
4062 else if (strcmp (name
, ".bss") == 0)
4063 h
->esym
.asym
.sc
= scBss
;
4064 else if (strcmp (name
, ".sbss") == 0)
4065 h
->esym
.asym
.sc
= scSBss
;
4066 else if (strcmp (name
, ".init") == 0)
4067 h
->esym
.asym
.sc
= scInit
;
4068 else if (strcmp (name
, ".fini") == 0)
4069 h
->esym
.asym
.sc
= scFini
;
4071 h
->esym
.asym
.sc
= scAbs
;
4075 h
->esym
.asym
.reserved
= 0;
4076 h
->esym
.asym
.index
= indexNil
;
4079 if (h
->root
.root
.type
== bfd_link_hash_common
)
4080 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
4081 else if (h
->root
.root
.type
== bfd_link_hash_defined
4082 || h
->root
.root
.type
== bfd_link_hash_defweak
)
4084 if (h
->esym
.asym
.sc
== scCommon
)
4085 h
->esym
.asym
.sc
= scBss
;
4086 else if (h
->esym
.asym
.sc
== scSCommon
)
4087 h
->esym
.asym
.sc
= scSBss
;
4089 sec
= h
->root
.root
.u
.def
.section
;
4090 output_section
= sec
->output_section
;
4091 if (output_section
!= NULL
)
4092 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
4093 + sec
->output_offset
4094 + output_section
->vma
);
4096 h
->esym
.asym
.value
= 0;
4098 else if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
4100 /* Set type and value for a symbol with a function stub. */
4101 h
->esym
.asym
.st
= stProc
;
4102 sec
= h
->root
.root
.u
.def
.section
;
4104 h
->esym
.asym
.value
= 0;
4107 output_section
= sec
->output_section
;
4108 if (output_section
!= NULL
)
4109 h
->esym
.asym
.value
= (h
->root
.plt
.offset
4110 + sec
->output_offset
4111 + output_section
->vma
);
4113 h
->esym
.asym
.value
= 0;
4120 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
4121 h
->root
.root
.root
.string
,
4124 einfo
->failed
= true;
4131 /* Create a runtime procedure table from the .mdebug section. */
4134 mips_elf_create_procedure_table (handle
, abfd
, info
, s
, debug
)
4137 struct bfd_link_info
*info
;
4139 struct ecoff_debug_info
*debug
;
4141 const struct ecoff_debug_swap
*swap
;
4142 HDRR
*hdr
= &debug
->symbolic_header
;
4144 struct rpdr_ext
*erp
;
4146 struct pdr_ext
*epdr
;
4147 struct sym_ext
*esym
;
4150 unsigned long size
, count
;
4151 unsigned long sindex
;
4155 const char *no_name_func
= _("static procedure (no name)");
4163 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
4165 sindex
= strlen (no_name_func
) + 1;
4166 count
= hdr
->ipdMax
;
4169 size
= swap
->external_pdr_size
;
4171 epdr
= (struct pdr_ext
*) bfd_malloc (size
* count
);
4175 if (! _bfd_ecoff_get_accumulated_pdr (handle
, (PTR
) epdr
))
4178 size
= sizeof (RPDR
);
4179 rp
= rpdr
= (RPDR
*) bfd_malloc (size
* count
);
4183 sv
= (char **) bfd_malloc (sizeof (char *) * count
);
4187 count
= hdr
->isymMax
;
4188 size
= swap
->external_sym_size
;
4189 esym
= (struct sym_ext
*) bfd_malloc (size
* count
);
4193 if (! _bfd_ecoff_get_accumulated_sym (handle
, (PTR
) esym
))
4196 count
= hdr
->issMax
;
4197 ss
= (char *) bfd_malloc (count
);
4200 if (! _bfd_ecoff_get_accumulated_ss (handle
, (PTR
) ss
))
4203 count
= hdr
->ipdMax
;
4204 for (i
= 0; i
< count
; i
++, rp
++)
4206 (*swap
->swap_pdr_in
) (abfd
, (PTR
) (epdr
+ i
), &pdr
);
4207 (*swap
->swap_sym_in
) (abfd
, (PTR
) &esym
[pdr
.isym
], &sym
);
4208 rp
->adr
= sym
.value
;
4209 rp
->regmask
= pdr
.regmask
;
4210 rp
->regoffset
= pdr
.regoffset
;
4211 rp
->fregmask
= pdr
.fregmask
;
4212 rp
->fregoffset
= pdr
.fregoffset
;
4213 rp
->frameoffset
= pdr
.frameoffset
;
4214 rp
->framereg
= pdr
.framereg
;
4215 rp
->pcreg
= pdr
.pcreg
;
4217 sv
[i
] = ss
+ sym
.iss
;
4218 sindex
+= strlen (sv
[i
]) + 1;
4222 size
= sizeof (struct rpdr_ext
) * (count
+ 2) + sindex
;
4223 size
= BFD_ALIGN (size
, 16);
4224 rtproc
= (PTR
) bfd_alloc (abfd
, size
);
4227 mips_elf_hash_table (info
)->procedure_count
= 0;
4231 mips_elf_hash_table (info
)->procedure_count
= count
+ 2;
4233 erp
= (struct rpdr_ext
*) rtproc
;
4234 memset (erp
, 0, sizeof (struct rpdr_ext
));
4236 str
= (char *) rtproc
+ sizeof (struct rpdr_ext
) * (count
+ 2);
4237 strcpy (str
, no_name_func
);
4238 str
+= strlen (no_name_func
) + 1;
4239 for (i
= 0; i
< count
; i
++)
4241 ecoff_swap_rpdr_out (abfd
, rpdr
+ i
, erp
+ i
);
4242 strcpy (str
, sv
[i
]);
4243 str
+= strlen (sv
[i
]) + 1;
4245 ecoff_put_off (abfd
, (bfd_vma
) -1, (bfd_byte
*) (erp
+ count
)->p_adr
);
4247 /* Set the size and contents of .rtproc section. */
4248 s
->_raw_size
= size
;
4249 s
->contents
= (bfd_byte
*) rtproc
;
4251 /* Skip this section later on (I don't think this currently
4252 matters, but someday it might). */
4253 s
->link_order_head
= (struct bfd_link_order
*) NULL
;
4282 /* A comparison routine used to sort .gptab entries. */
4285 gptab_compare (p1
, p2
)
4289 const Elf32_gptab
*a1
= (const Elf32_gptab
*) p1
;
4290 const Elf32_gptab
*a2
= (const Elf32_gptab
*) p2
;
4292 return a1
->gt_entry
.gt_g_value
- a2
->gt_entry
.gt_g_value
;
4295 /* We need to use a special link routine to handle the .reginfo and
4296 the .mdebug sections. We need to merge all instances of these
4297 sections together, not write them all out sequentially. */
4300 _bfd_mips_elf_final_link (abfd
, info
)
4302 struct bfd_link_info
*info
;
4306 struct bfd_link_order
*p
;
4307 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
4308 asection
*rtproc_sec
;
4309 Elf32_RegInfo reginfo
;
4310 struct ecoff_debug_info debug
;
4311 const struct ecoff_debug_swap
*swap
4312 = get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
4313 HDRR
*symhdr
= &debug
.symbolic_header
;
4314 PTR mdebug_handle
= NULL
;
4316 /* If all the things we linked together were PIC, but we're
4317 producing an executable (rather than a shared object), then the
4318 resulting file is CPIC (i.e., it calls PIC code.) */
4320 && !info
->relocateable
4321 && elf_elfheader (abfd
)->e_flags
& EF_MIPS_PIC
)
4323 elf_elfheader (abfd
)->e_flags
&= ~EF_MIPS_PIC
;
4324 elf_elfheader (abfd
)->e_flags
|= EF_MIPS_CPIC
;
4327 /* We'd carefully arranged the dynamic symbol indices, and then the
4328 generic size_dynamic_sections renumbered them out from under us.
4329 Rather than trying somehow to prevent the renumbering, just do
4331 if (elf_hash_table (info
)->dynobj
)
4335 struct mips_got_info
*g
;
4337 /* When we resort, we must tell mips_elf_sort_hash_table what
4338 the lowest index it may use is. That's the number of section
4339 symbols we're going to add. The generic ELF linker only
4340 adds these symbols when building a shared object. Note that
4341 we count the sections after (possibly) removing the .options
4343 if (!mips_elf_sort_hash_table (info
, (info
->shared
4344 ? bfd_count_sections (abfd
) + 1
4348 /* Make sure we didn't grow the global .got region. */
4349 dynobj
= elf_hash_table (info
)->dynobj
;
4350 got
= bfd_get_section_by_name (dynobj
, ".got");
4351 g
= (struct mips_got_info
*) elf_section_data (got
)->tdata
;
4353 BFD_ASSERT ((elf_hash_table (info
)->dynsymcount
4354 - g
->global_gotsym
->dynindx
)
4355 <= g
->global_gotno
);
4358 /* On IRIX5, we omit the .options section. On IRIX6, however, we
4359 include it, even though we don't process it quite right. (Some
4360 entries are supposed to be merged.) Empirically, we seem to be
4361 better off including it then not. */
4362 if (IRIX_COMPAT (abfd
) == ict_irix5
)
4363 for (secpp
= &abfd
->sections
; *secpp
!= NULL
; secpp
= &(*secpp
)->next
)
4365 if (strcmp ((*secpp
)->name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
4367 for (p
= (*secpp
)->link_order_head
; p
!= NULL
; p
= p
->next
)
4368 if (p
->type
== bfd_indirect_link_order
)
4369 p
->u
.indirect
.section
->flags
&=~ SEC_HAS_CONTENTS
;
4370 (*secpp
)->link_order_head
= NULL
;
4371 *secpp
= (*secpp
)->next
;
4372 --abfd
->section_count
;
4378 /* Get a value for the GP register. */
4379 if (elf_gp (abfd
) == 0)
4381 struct bfd_link_hash_entry
*h
;
4383 h
= bfd_link_hash_lookup (info
->hash
, "_gp", false, false, true);
4384 if (h
!= (struct bfd_link_hash_entry
*) NULL
4385 && h
->type
== bfd_link_hash_defined
)
4386 elf_gp (abfd
) = (h
->u
.def
.value
4387 + h
->u
.def
.section
->output_section
->vma
4388 + h
->u
.def
.section
->output_offset
);
4389 else if (info
->relocateable
)
4393 /* Find the GP-relative section with the lowest offset. */
4395 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
4397 && (elf_section_data (o
)->this_hdr
.sh_flags
& SHF_MIPS_GPREL
))
4400 /* And calculate GP relative to that. */
4401 elf_gp (abfd
) = lo
+ ELF_MIPS_GP_OFFSET (abfd
);
4405 /* If the relocate_section function needs to do a reloc
4406 involving the GP value, it should make a reloc_dangerous
4407 callback to warn that GP is not defined. */
4411 /* Go through the sections and collect the .reginfo and .mdebug
4415 gptab_data_sec
= NULL
;
4416 gptab_bss_sec
= NULL
;
4417 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
4419 if (strcmp (o
->name
, ".reginfo") == 0)
4421 memset (®info
, 0, sizeof reginfo
);
4423 /* We have found the .reginfo section in the output file.
4424 Look through all the link_orders comprising it and merge
4425 the information together. */
4426 for (p
= o
->link_order_head
;
4427 p
!= (struct bfd_link_order
*) NULL
;
4430 asection
*input_section
;
4432 Elf32_External_RegInfo ext
;
4435 if (p
->type
!= bfd_indirect_link_order
)
4437 if (p
->type
== bfd_fill_link_order
)
4442 input_section
= p
->u
.indirect
.section
;
4443 input_bfd
= input_section
->owner
;
4445 /* The linker emulation code has probably clobbered the
4446 size to be zero bytes. */
4447 if (input_section
->_raw_size
== 0)
4448 input_section
->_raw_size
= sizeof (Elf32_External_RegInfo
);
4450 if (! bfd_get_section_contents (input_bfd
, input_section
,
4456 bfd_mips_elf32_swap_reginfo_in (input_bfd
, &ext
, &sub
);
4458 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
4459 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
4460 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
4461 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
4462 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
4464 /* ri_gp_value is set by the function
4465 mips_elf32_section_processing when the section is
4466 finally written out. */
4468 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4469 elf_link_input_bfd ignores this section. */
4470 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
4473 /* Size has been set in mips_elf_always_size_sections */
4474 BFD_ASSERT(o
->_raw_size
== sizeof (Elf32_External_RegInfo
));
4476 /* Skip this section later on (I don't think this currently
4477 matters, but someday it might). */
4478 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
4483 if (strcmp (o
->name
, ".mdebug") == 0)
4485 struct extsym_info einfo
;
4487 /* We have found the .mdebug section in the output file.
4488 Look through all the link_orders comprising it and merge
4489 the information together. */
4490 symhdr
->magic
= swap
->sym_magic
;
4491 /* FIXME: What should the version stamp be? */
4493 symhdr
->ilineMax
= 0;
4497 symhdr
->isymMax
= 0;
4498 symhdr
->ioptMax
= 0;
4499 symhdr
->iauxMax
= 0;
4501 symhdr
->issExtMax
= 0;
4504 symhdr
->iextMax
= 0;
4506 /* We accumulate the debugging information itself in the
4507 debug_info structure. */
4509 debug
.external_dnr
= NULL
;
4510 debug
.external_pdr
= NULL
;
4511 debug
.external_sym
= NULL
;
4512 debug
.external_opt
= NULL
;
4513 debug
.external_aux
= NULL
;
4515 debug
.ssext
= debug
.ssext_end
= NULL
;
4516 debug
.external_fdr
= NULL
;
4517 debug
.external_rfd
= NULL
;
4518 debug
.external_ext
= debug
.external_ext_end
= NULL
;
4520 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
4521 if (mdebug_handle
== (PTR
) NULL
)
4524 if (SGI_COMPAT (abfd
))
4530 static const char * const name
[] =
4531 { ".text", ".init", ".fini", ".data",
4532 ".rodata", ".sdata", ".sbss", ".bss" };
4533 static const int sc
[] = { scText
, scInit
, scFini
, scData
,
4534 scRData
, scSData
, scSBss
, scBss
};
4537 esym
.cobol_main
= 0;
4541 esym
.asym
.iss
= issNil
;
4542 esym
.asym
.st
= stLocal
;
4543 esym
.asym
.reserved
= 0;
4544 esym
.asym
.index
= indexNil
;
4546 for (i
= 0; i
< 8; i
++)
4548 esym
.asym
.sc
= sc
[i
];
4549 s
= bfd_get_section_by_name (abfd
, name
[i
]);
4552 esym
.asym
.value
= s
->vma
;
4553 last
= s
->vma
+ s
->_raw_size
;
4556 esym
.asym
.value
= last
;
4558 if (! bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
4564 for (p
= o
->link_order_head
;
4565 p
!= (struct bfd_link_order
*) NULL
;
4568 asection
*input_section
;
4570 const struct ecoff_debug_swap
*input_swap
;
4571 struct ecoff_debug_info input_debug
;
4575 if (p
->type
!= bfd_indirect_link_order
)
4577 if (p
->type
== bfd_fill_link_order
)
4582 input_section
= p
->u
.indirect
.section
;
4583 input_bfd
= input_section
->owner
;
4585 if (bfd_get_flavour (input_bfd
) != bfd_target_elf_flavour
4586 || (get_elf_backend_data (input_bfd
)
4587 ->elf_backend_ecoff_debug_swap
) == NULL
)
4589 /* I don't know what a non MIPS ELF bfd would be
4590 doing with a .mdebug section, but I don't really
4591 want to deal with it. */
4595 input_swap
= (get_elf_backend_data (input_bfd
)
4596 ->elf_backend_ecoff_debug_swap
);
4598 BFD_ASSERT (p
->size
== input_section
->_raw_size
);
4600 /* The ECOFF linking code expects that we have already
4601 read in the debugging information and set up an
4602 ecoff_debug_info structure, so we do that now. */
4603 if (! _bfd_mips_elf_read_ecoff_info (input_bfd
, input_section
,
4607 if (! (bfd_ecoff_debug_accumulate
4608 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
4609 &input_debug
, input_swap
, info
)))
4612 /* Loop through the external symbols. For each one with
4613 interesting information, try to find the symbol in
4614 the linker global hash table and save the information
4615 for the output external symbols. */
4616 eraw_src
= input_debug
.external_ext
;
4617 eraw_end
= (eraw_src
4618 + (input_debug
.symbolic_header
.iextMax
4619 * input_swap
->external_ext_size
));
4621 eraw_src
< eraw_end
;
4622 eraw_src
+= input_swap
->external_ext_size
)
4626 struct mips_elf_link_hash_entry
*h
;
4628 (*input_swap
->swap_ext_in
) (input_bfd
, (PTR
) eraw_src
, &ext
);
4629 if (ext
.asym
.sc
== scNil
4630 || ext
.asym
.sc
== scUndefined
4631 || ext
.asym
.sc
== scSUndefined
)
4634 name
= input_debug
.ssext
+ ext
.asym
.iss
;
4635 h
= mips_elf_link_hash_lookup (mips_elf_hash_table (info
),
4636 name
, false, false, true);
4637 if (h
== NULL
|| h
->esym
.ifd
!= -2)
4643 < input_debug
.symbolic_header
.ifdMax
);
4644 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
4650 /* Free up the information we just read. */
4651 free (input_debug
.line
);
4652 free (input_debug
.external_dnr
);
4653 free (input_debug
.external_pdr
);
4654 free (input_debug
.external_sym
);
4655 free (input_debug
.external_opt
);
4656 free (input_debug
.external_aux
);
4657 free (input_debug
.ss
);
4658 free (input_debug
.ssext
);
4659 free (input_debug
.external_fdr
);
4660 free (input_debug
.external_rfd
);
4661 free (input_debug
.external_ext
);
4663 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4664 elf_link_input_bfd ignores this section. */
4665 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
4668 if (SGI_COMPAT (abfd
) && info
->shared
)
4670 /* Create .rtproc section. */
4671 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
4672 if (rtproc_sec
== NULL
)
4674 flagword flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
4675 | SEC_LINKER_CREATED
| SEC_READONLY
);
4677 rtproc_sec
= bfd_make_section (abfd
, ".rtproc");
4678 if (rtproc_sec
== NULL
4679 || ! bfd_set_section_flags (abfd
, rtproc_sec
, flags
)
4680 || ! bfd_set_section_alignment (abfd
, rtproc_sec
, 4))
4684 if (! mips_elf_create_procedure_table (mdebug_handle
, abfd
,
4685 info
, rtproc_sec
, &debug
))
4689 /* Build the external symbol information. */
4692 einfo
.debug
= &debug
;
4694 einfo
.failed
= false;
4695 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
4696 mips_elf_output_extsym
,
4701 /* Set the size of the .mdebug section. */
4702 o
->_raw_size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
4704 /* Skip this section later on (I don't think this currently
4705 matters, but someday it might). */
4706 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
4711 if (strncmp (o
->name
, ".gptab.", sizeof ".gptab." - 1) == 0)
4713 const char *subname
;
4716 Elf32_External_gptab
*ext_tab
;
4719 /* The .gptab.sdata and .gptab.sbss sections hold
4720 information describing how the small data area would
4721 change depending upon the -G switch. These sections
4722 not used in executables files. */
4723 if (! info
->relocateable
)
4727 for (p
= o
->link_order_head
;
4728 p
!= (struct bfd_link_order
*) NULL
;
4731 asection
*input_section
;
4733 if (p
->type
!= bfd_indirect_link_order
)
4735 if (p
->type
== bfd_fill_link_order
)
4740 input_section
= p
->u
.indirect
.section
;
4742 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4743 elf_link_input_bfd ignores this section. */
4744 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
4747 /* Skip this section later on (I don't think this
4748 currently matters, but someday it might). */
4749 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
4751 /* Really remove the section. */
4752 for (secpp
= &abfd
->sections
;
4754 secpp
= &(*secpp
)->next
)
4756 *secpp
= (*secpp
)->next
;
4757 --abfd
->section_count
;
4762 /* There is one gptab for initialized data, and one for
4763 uninitialized data. */
4764 if (strcmp (o
->name
, ".gptab.sdata") == 0)
4766 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
4770 (*_bfd_error_handler
)
4771 (_("%s: illegal section name `%s'"),
4772 bfd_get_filename (abfd
), o
->name
);
4773 bfd_set_error (bfd_error_nonrepresentable_section
);
4777 /* The linker script always combines .gptab.data and
4778 .gptab.sdata into .gptab.sdata, and likewise for
4779 .gptab.bss and .gptab.sbss. It is possible that there is
4780 no .sdata or .sbss section in the output file, in which
4781 case we must change the name of the output section. */
4782 subname
= o
->name
+ sizeof ".gptab" - 1;
4783 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
4785 if (o
== gptab_data_sec
)
4786 o
->name
= ".gptab.data";
4788 o
->name
= ".gptab.bss";
4789 subname
= o
->name
+ sizeof ".gptab" - 1;
4790 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
4793 /* Set up the first entry. */
4795 tab
= (Elf32_gptab
*) bfd_malloc (c
* sizeof (Elf32_gptab
));
4798 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
4799 tab
[0].gt_header
.gt_unused
= 0;
4801 /* Combine the input sections. */
4802 for (p
= o
->link_order_head
;
4803 p
!= (struct bfd_link_order
*) NULL
;
4806 asection
*input_section
;
4810 bfd_size_type gpentry
;
4812 if (p
->type
!= bfd_indirect_link_order
)
4814 if (p
->type
== bfd_fill_link_order
)
4819 input_section
= p
->u
.indirect
.section
;
4820 input_bfd
= input_section
->owner
;
4822 /* Combine the gptab entries for this input section one
4823 by one. We know that the input gptab entries are
4824 sorted by ascending -G value. */
4825 size
= bfd_section_size (input_bfd
, input_section
);
4827 for (gpentry
= sizeof (Elf32_External_gptab
);
4829 gpentry
+= sizeof (Elf32_External_gptab
))
4831 Elf32_External_gptab ext_gptab
;
4832 Elf32_gptab int_gptab
;
4838 if (! (bfd_get_section_contents
4839 (input_bfd
, input_section
, (PTR
) &ext_gptab
,
4840 gpentry
, sizeof (Elf32_External_gptab
))))
4846 bfd_mips_elf32_swap_gptab_in (input_bfd
, &ext_gptab
,
4848 val
= int_gptab
.gt_entry
.gt_g_value
;
4849 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
4852 for (look
= 1; look
< c
; look
++)
4854 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
4855 tab
[look
].gt_entry
.gt_bytes
+= add
;
4857 if (tab
[look
].gt_entry
.gt_g_value
== val
)
4863 Elf32_gptab
*new_tab
;
4866 /* We need a new table entry. */
4867 new_tab
= ((Elf32_gptab
*)
4868 bfd_realloc ((PTR
) tab
,
4869 (c
+ 1) * sizeof (Elf32_gptab
)));
4870 if (new_tab
== NULL
)
4876 tab
[c
].gt_entry
.gt_g_value
= val
;
4877 tab
[c
].gt_entry
.gt_bytes
= add
;
4879 /* Merge in the size for the next smallest -G
4880 value, since that will be implied by this new
4883 for (look
= 1; look
< c
; look
++)
4885 if (tab
[look
].gt_entry
.gt_g_value
< val
4887 || (tab
[look
].gt_entry
.gt_g_value
4888 > tab
[max
].gt_entry
.gt_g_value
)))
4892 tab
[c
].gt_entry
.gt_bytes
+=
4893 tab
[max
].gt_entry
.gt_bytes
;
4898 last
= int_gptab
.gt_entry
.gt_bytes
;
4901 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4902 elf_link_input_bfd ignores this section. */
4903 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
4906 /* The table must be sorted by -G value. */
4908 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
4910 /* Swap out the table. */
4911 ext_tab
= ((Elf32_External_gptab
*)
4912 bfd_alloc (abfd
, c
* sizeof (Elf32_External_gptab
)));
4913 if (ext_tab
== NULL
)
4919 for (i
= 0; i
< c
; i
++)
4920 bfd_mips_elf32_swap_gptab_out (abfd
, tab
+ i
, ext_tab
+ i
);
4923 o
->_raw_size
= c
* sizeof (Elf32_External_gptab
);
4924 o
->contents
= (bfd_byte
*) ext_tab
;
4926 /* Skip this section later on (I don't think this currently
4927 matters, but someday it might). */
4928 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
4932 /* Invoke the regular ELF backend linker to do all the work. */
4933 if (ABI_64_P (abfd
))
4936 if (!bfd_elf64_bfd_final_link (abfd
, info
))
4943 else if (!bfd_elf32_bfd_final_link (abfd
, info
))
4946 /* Now write out the computed sections. */
4948 if (reginfo_sec
!= (asection
*) NULL
)
4950 Elf32_External_RegInfo ext
;
4952 bfd_mips_elf32_swap_reginfo_out (abfd
, ®info
, &ext
);
4953 if (! bfd_set_section_contents (abfd
, reginfo_sec
, (PTR
) &ext
,
4954 (file_ptr
) 0, sizeof ext
))
4958 if (mdebug_sec
!= (asection
*) NULL
)
4960 BFD_ASSERT (abfd
->output_has_begun
);
4961 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
4963 mdebug_sec
->filepos
))
4966 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
4969 if (gptab_data_sec
!= (asection
*) NULL
)
4971 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
4972 gptab_data_sec
->contents
,
4974 gptab_data_sec
->_raw_size
))
4978 if (gptab_bss_sec
!= (asection
*) NULL
)
4980 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
4981 gptab_bss_sec
->contents
,
4983 gptab_bss_sec
->_raw_size
))
4987 if (SGI_COMPAT (abfd
))
4989 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
4990 if (rtproc_sec
!= NULL
)
4992 if (! bfd_set_section_contents (abfd
, rtproc_sec
,
4993 rtproc_sec
->contents
,
4995 rtproc_sec
->_raw_size
))
5003 /* Handle a MIPS ELF HI16 reloc. */
5006 mips_elf_relocate_hi16 (input_bfd
, relhi
, rello
, contents
, addend
)
5008 Elf_Internal_Rela
*relhi
;
5009 Elf_Internal_Rela
*rello
;
5016 insn
= bfd_get_32 (input_bfd
, contents
+ relhi
->r_offset
);
5018 addlo
= bfd_get_32 (input_bfd
, contents
+ rello
->r_offset
);
5021 addend
+= ((insn
& 0xffff) << 16) + addlo
;
5023 if ((addlo
& 0x8000) != 0)
5025 if ((addend
& 0x8000) != 0)
5028 bfd_put_32 (input_bfd
,
5029 (insn
& 0xffff0000) | ((addend
>> 16) & 0xffff),
5030 contents
+ relhi
->r_offset
);
5033 /* Handle a MIPS ELF local GOT16 reloc. */
5036 mips_elf_relocate_got_local (output_bfd
, input_bfd
, sgot
, relhi
, rello
,
5041 Elf_Internal_Rela
*relhi
;
5042 Elf_Internal_Rela
*rello
;
5046 unsigned int assigned_gotno
;
5052 bfd_byte
*got_contents
;
5053 struct mips_got_info
*g
;
5055 insn
= bfd_get_32 (input_bfd
, contents
+ relhi
->r_offset
);
5057 addlo
= bfd_get_32 (input_bfd
, contents
+ rello
->r_offset
);
5060 addend
+= ((insn
& 0xffff) << 16) + addlo
;
5062 if ((addlo
& 0x8000) != 0)
5064 if ((addend
& 0x8000) != 0)
5067 /* Get a got entry representing requested hipage. */
5068 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
5069 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
5070 BFD_ASSERT (g
!= NULL
);
5072 assigned_gotno
= g
->assigned_gotno
;
5073 got_contents
= sgot
->contents
;
5074 hipage
= addend
& 0xffff0000;
5076 for (i
= MIPS_RESERVED_GOTNO
; i
< assigned_gotno
; i
++)
5078 address
= bfd_get_32 (input_bfd
, got_contents
+ i
* 4);
5079 if (hipage
== (address
& 0xffff0000))
5083 if (i
== assigned_gotno
)
5085 if (assigned_gotno
>= g
->local_gotno
)
5087 (*_bfd_error_handler
)
5088 (_("more got entries are needed for hipage relocations"));
5089 bfd_set_error (bfd_error_bad_value
);
5093 bfd_put_32 (input_bfd
, hipage
, got_contents
+ assigned_gotno
* 4);
5094 ++g
->assigned_gotno
;
5097 i
= - ELF_MIPS_GP_OFFSET (output_bfd
) + i
* 4;
5098 bfd_put_32 (input_bfd
, (insn
& 0xffff0000) | (i
& 0xffff),
5099 contents
+ relhi
->r_offset
);
5104 /* Handle MIPS ELF CALL16 reloc and global GOT16 reloc. */
5107 mips_elf_relocate_global_got (input_bfd
, rel
, contents
, offset
)
5109 Elf_Internal_Rela
*rel
;
5115 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
5116 bfd_put_32 (input_bfd
,
5117 (insn
& 0xffff0000) | (offset
& 0xffff),
5118 contents
+ rel
->r_offset
);
5121 /* Returns the GOT section for ABFD. */
5124 mips_elf_got_section (abfd
)
5127 return bfd_get_section_by_name (abfd
, ".got");
5130 /* Returns the GOT information associated with the link indicated by
5131 INFO. If SGOTP is non-NULL, it is filled in with the GOT
5134 static struct mips_got_info
*
5135 mips_elf_got_info (abfd
, sgotp
)
5140 struct mips_got_info
*g
;
5142 sgot
= mips_elf_got_section (abfd
);
5143 BFD_ASSERT (sgot
!= NULL
);
5144 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
5145 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
5146 BFD_ASSERT (g
!= NULL
);
5153 /* Sign-extend VALUE, which has the indicated number of BITS. */
5156 mips_elf_sign_extend (value
, bits
)
5160 if (value
& (1 << (bits
- 1)))
5161 /* VALUE is negative. */
5162 value
|= ((bfd_vma
) - 1) << bits
;
5167 /* Return non-zero if the indicated VALUE has overflowed the maximum
5168 range expressable by a signed number with the indicated number of
5172 mips_elf_overflow_p (value
, bits
)
5176 bfd_signed_vma svalue
= (bfd_signed_vma
) value
;
5178 if (svalue
> (1 << (bits
- 1)) - 1)
5179 /* The value is too big. */
5181 else if (svalue
< -(1 << (bits
- 1)))
5182 /* The value is too small. */
5189 /* Calculate the %high function. */
5192 mips_elf_high (value
)
5195 return ((value
+ (bfd_vma
) 0x8000) >> 16) & 0xffff;
5198 /* Calculate the %higher function. */
5201 mips_elf_higher (value
)
5202 bfd_vma value ATTRIBUTE_UNUSED
;
5205 return ((value
+ (bfd_vma
) 0x80008000) >> 32) & 0xffff;
5208 return (bfd_vma
) -1;
5212 /* Calculate the %highest function. */
5215 mips_elf_highest (value
)
5216 bfd_vma value ATTRIBUTE_UNUSED
;
5219 return ((value
+ (bfd_vma
) 0x800080008000) > 48) & 0xffff;
5222 return (bfd_vma
) -1;
5226 /* Returns the GOT index for the global symbol indicated by H. */
5229 mips_elf_global_got_index (abfd
, h
)
5231 struct elf_link_hash_entry
*h
;
5235 struct mips_got_info
*g
;
5237 g
= mips_elf_got_info (abfd
, &sgot
);
5239 /* Once we determine the global GOT entry with the lowest dynamic
5240 symbol table index, we must put all dynamic symbols with greater
5241 indices into the GOT. That makes it easy to calculate the GOT
5243 BFD_ASSERT (h
->dynindx
>= g
->global_gotsym
->dynindx
);
5244 index
= ((h
->dynindx
- g
->global_gotsym
->dynindx
+ g
->local_gotno
)
5245 * MIPS_ELF_GOT_SIZE (abfd
));
5246 BFD_ASSERT (index
< sgot
->_raw_size
);
5251 /* Returns the offset for the entry at the INDEXth position
5255 mips_elf_got_offset_from_index (dynobj
, output_bfd
, index
)
5263 sgot
= mips_elf_got_section (dynobj
);
5264 gp
= _bfd_get_gp_value (output_bfd
);
5265 return (sgot
->output_section
->vma
+ sgot
->output_offset
+ index
-
5269 /* If H is a symbol that needs a global GOT entry, but has a dynamic
5270 symbol table index lower than any we've seen to date, record it for
5274 mips_elf_record_global_got_symbol (h
, info
, g
)
5275 struct elf_link_hash_entry
*h
;
5276 struct bfd_link_info
*info
;
5277 struct mips_got_info
*g ATTRIBUTE_UNUSED
;
5279 /* A global symbol in the GOT must also be in the dynamic symbol
5281 if (h
->dynindx
== -1
5282 && !bfd_elf32_link_record_dynamic_symbol (info
, h
))
5285 /* If we've already marked this entry as need GOT space, we don't
5286 need to do it again. */
5287 if (h
->got
.offset
!= (bfd_vma
) - 1)
5290 /* By setting this to a value other than -1, we are indicating that
5291 there needs to be a GOT entry for H. */
5297 /* This structure is passed to mips_elf_sort_hash_table_f when sorting
5298 the dynamic symbols. */
5300 struct mips_elf_hash_sort_data
5302 /* The symbol in the global GOT with the lowest dynamic symbol table
5304 struct elf_link_hash_entry
*low
;
5305 /* The least dynamic symbol table index corresponding to a symbol
5306 with a GOT entry. */
5307 long min_got_dynindx
;
5308 /* The greatest dynamic symbol table index not corresponding to a
5309 symbol without a GOT entry. */
5310 long max_non_got_dynindx
;
5313 /* If H needs a GOT entry, assign it the highest available dynamic
5314 index. Otherwise, assign it the lowest available dynamic
5318 mips_elf_sort_hash_table_f (h
, data
)
5319 struct mips_elf_link_hash_entry
*h
;
5322 struct mips_elf_hash_sort_data
*hsd
5323 = (struct mips_elf_hash_sort_data
*) data
;
5325 /* Symbols without dynamic symbol table entries aren't interesting
5327 if (h
->root
.dynindx
== -1)
5330 if (h
->root
.got
.offset
!= 0)
5331 h
->root
.dynindx
= hsd
->max_non_got_dynindx
++;
5334 h
->root
.dynindx
= --hsd
->min_got_dynindx
;
5335 hsd
->low
= (struct elf_link_hash_entry
*) h
;
5341 /* Sort the dynamic symbol table so that symbols that need GOT entries
5342 appear towards the end. This reduces the amount of GOT space
5343 required. MAX_LOCAL is used to set the number of local symbols
5344 known to be in the dynamic symbol table. During
5345 mips_elf_size_dynamic_sections, this value is 1. Afterward, the
5346 section symbols are added and the count is higher. */
5349 mips_elf_sort_hash_table (info
, max_local
)
5350 struct bfd_link_info
*info
;
5351 unsigned long max_local
;
5353 struct mips_elf_hash_sort_data hsd
;
5354 struct mips_got_info
*g
;
5357 dynobj
= elf_hash_table (info
)->dynobj
;
5360 hsd
.min_got_dynindx
= elf_hash_table (info
)->dynsymcount
;
5361 hsd
.max_non_got_dynindx
= max_local
;
5362 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table
*)
5363 elf_hash_table (info
)),
5364 mips_elf_sort_hash_table_f
,
5367 /* There shoud have been enough room in the symbol table to
5368 accomodate both the GOT and non-GOT symbols. */
5369 BFD_ASSERT (hsd
.min_got_dynindx
== hsd
.max_non_got_dynindx
);
5371 /* Now we know which dynamic symbol has the lowest dynamic symbol
5372 table index in the GOT. */
5373 g
= mips_elf_got_info (dynobj
, NULL
);
5374 g
->global_gotsym
= hsd
.low
;
5379 /* Create a local GOT entry for VALUE. Return the index of the entry,
5380 or -1 if it could not be created. */
5383 mips_elf_create_local_got_entry (abfd
, g
, sgot
, value
)
5385 struct mips_got_info
*g
;
5389 if (g
->assigned_gotno
>= g
->local_gotno
)
5391 /* We didn't allocate enough space in the GOT. */
5392 (*_bfd_error_handler
)
5393 (_("not enough GOT space for local GOT entries"));
5394 bfd_set_error (bfd_error_bad_value
);
5395 return (bfd_vma
) -1;
5398 MIPS_ELF_PUT_WORD (abfd
, value
,
5400 + MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
));
5401 return MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
++;
5404 /* Returns the GOT offset at which the indicated address can be found.
5405 If there is not yet a GOT entry for this value, create one. Returns
5406 -1 if no satisfactory GOT offset can be found. */
5409 mips_elf_local_got_index (abfd
, info
, value
)
5411 struct bfd_link_info
*info
;
5415 struct mips_got_info
*g
;
5418 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
5420 /* Look to see if we already have an appropriate entry. */
5421 for (entry
= (sgot
->contents
5422 + MIPS_ELF_GOT_SIZE (abfd
) * MIPS_RESERVED_GOTNO
);
5423 entry
!= sgot
->contents
+ MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
;
5424 entry
+= MIPS_ELF_GOT_SIZE (abfd
))
5426 bfd_vma address
= MIPS_ELF_GET_WORD (abfd
, entry
);
5427 if (address
== value
)
5428 return entry
- sgot
->contents
;
5431 return mips_elf_create_local_got_entry (abfd
, g
, sgot
, value
);
5434 /* Find a GOT entry that is within 32KB of the VALUE. These entries
5435 are supposed to be placed at small offsets in the GOT, i.e.,
5436 within 32KB of GP. Return the index into the GOT for this page,
5437 and store the offset from this entry to the desired address in
5438 OFFSETP, if it is non-NULL. */
5441 mips_elf_got_page (abfd
, info
, value
, offsetp
)
5443 struct bfd_link_info
*info
;
5448 struct mips_got_info
*g
;
5450 bfd_byte
*last_entry
;
5454 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
5456 /* Look to see if we aleady have an appropriate entry. */
5457 last_entry
= sgot
->contents
+ MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
;
5458 for (entry
= (sgot
->contents
5459 + MIPS_ELF_GOT_SIZE (abfd
) * MIPS_RESERVED_GOTNO
);
5460 entry
!= last_entry
;
5461 entry
+= MIPS_ELF_GOT_SIZE (abfd
))
5463 address
= MIPS_ELF_GET_WORD (abfd
, entry
);
5465 if (!mips_elf_overflow_p (value
- address
, 16))
5467 /* This entry will serve as the page pointer. We can add a
5468 16-bit number to it to get the actual address. */
5469 index
= entry
- sgot
->contents
;
5474 /* If we didn't have an appropriate entry, we create one now. */
5475 if (entry
== last_entry
)
5476 index
= mips_elf_create_local_got_entry (abfd
, g
, sgot
, value
);
5480 address
= MIPS_ELF_GET_WORD (abfd
, entry
);
5481 *offsetp
= value
- address
;
5487 /* Find a GOT entry whose higher-order 16 bits are the same as those
5488 for value. Return the index into the GOT for this entry. */
5491 mips_elf_got16_entry (abfd
, info
, value
)
5493 struct bfd_link_info
*info
;
5497 struct mips_got_info
*g
;
5499 bfd_byte
*last_entry
;
5503 value
&= 0xffff0000;
5504 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
5506 /* Look to see if we already have an appropriate entry. */
5507 last_entry
= sgot
->contents
+ MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
;
5508 for (entry
= (sgot
->contents
5509 + MIPS_ELF_GOT_SIZE (abfd
) * MIPS_RESERVED_GOTNO
);
5510 entry
!= last_entry
;
5511 entry
+= MIPS_ELF_GOT_SIZE (abfd
))
5513 address
= MIPS_ELF_GET_WORD (abfd
, entry
);
5514 if ((address
& 0xffff0000) == value
)
5516 /* This entry has the right high-order 16 bits. */
5517 index
= MIPS_ELF_GOT_SIZE (abfd
) * (entry
- sgot
->contents
);
5522 /* If we didn't have an appropriate entry, we create one now. */
5523 if (entry
== last_entry
)
5524 index
= mips_elf_create_local_got_entry (abfd
, g
, sgot
, value
);
5529 /* Sets *ADDENDP to the addend for the first R_MIPS_LO16 relocation
5530 found, beginning with RELOCATION. RELEND is one-past-the-end of
5531 the relocation table. */
5534 mips_elf_next_lo16_addend (relocation
, relend
, addendp
)
5535 const Elf_Internal_Rela
*relocation
;
5536 const Elf_Internal_Rela
*relend
;
5539 /* According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must be
5540 immediately following. However, for the IRIX6 ABI, the next
5541 relocation may be a composed relocation consisting of several
5542 relocations for the same address. In that case, the R_MIPS_LO16
5543 relocation may occur as one of these. We permit a similar
5544 extension in general, as that is useful for GCC. */
5545 while (relocation
< relend
)
5547 if (ELF32_R_TYPE (relocation
->r_info
) == R_MIPS_LO16
)
5549 *addendp
= relocation
->r_addend
;
5556 /* We didn't find it. */
5560 /* Create a rel.dyn relocation for the dynamic linker to resolve. The
5561 relocatin is against the symbol with the dynamic symbol table index
5562 DYNINDX. REL is the original relocation, which is now being made
5566 mips_elf_create_dynamic_relocation (output_bfd
, info
, rel
, dynindx
,
5567 addend
, input_section
)
5569 struct bfd_link_info
*info
;
5570 const Elf_Internal_Rela
*rel
;
5573 asection
*input_section
;
5575 Elf_Internal_Rel outrel
;
5581 r_type
= ELF32_R_TYPE (rel
->r_info
);
5582 dynobj
= elf_hash_table (info
)->dynobj
;
5584 = bfd_get_section_by_name (dynobj
,
5585 MIPS_ELF_REL_DYN_SECTION_NAME (output_bfd
));
5586 BFD_ASSERT (sreloc
!= NULL
);
5590 /* The symbol for the relocation is the same as it was for the
5591 original relocation. */
5592 outrel
.r_info
= ELF32_R_INFO (dynindx
, R_MIPS_REL32
);
5594 /* The offset for the dynamic relocation is the same as for the
5595 original relocation, adjusted by the offset at which the original
5596 section is output. */
5597 if (elf_section_data (input_section
)->stab_info
== NULL
)
5598 outrel
.r_offset
= rel
->r_offset
;
5603 off
= (_bfd_stab_section_offset
5604 (output_bfd
, &elf_hash_table (info
)->stab_info
,
5606 &elf_section_data (input_section
)->stab_info
,
5608 if (off
== (bfd_vma
) -1)
5610 outrel
.r_offset
= off
;
5612 outrel
.r_offset
+= (input_section
->output_section
->vma
5613 + input_section
->output_offset
);
5615 /* If we've decided to skip this relocation, just output an emtpy
5618 memset (&outrel
, 0, sizeof (outrel
));
5620 if (ABI_64_P (output_bfd
))
5622 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
5623 (output_bfd
, &outrel
,
5625 + sreloc
->reloc_count
* sizeof (Elf64_Mips_External_Rel
)));
5628 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
5629 (((Elf32_External_Rel
*)
5631 + sreloc
->reloc_count
));
5632 ++sreloc
->reloc_count
;
5634 /* Make sure the output section is writable. The dynamic linker
5635 will be writing to it. */
5636 elf_section_data (input_section
->output_section
)->this_hdr
.sh_flags
5639 /* On IRIX5, make an entry of compact relocation info. */
5640 if (! skip
&& IRIX_COMPAT (output_bfd
) == ict_irix5
)
5642 asection
* scpt
= bfd_get_section_by_name (dynobj
, ".compact_rel");
5647 Elf32_crinfo cptrel
;
5649 mips_elf_set_cr_format (cptrel
, CRF_MIPS_LONG
);
5650 cptrel
.vaddr
= (rel
->r_offset
5651 + input_section
->output_section
->vma
5652 + input_section
->output_offset
);
5653 if (r_type
== R_MIPS_REL32
)
5654 mips_elf_set_cr_type (cptrel
, CRT_MIPS_REL32
);
5656 mips_elf_set_cr_type (cptrel
, CRT_MIPS_WORD
);
5657 mips_elf_set_cr_dist2to (cptrel
, 0);
5658 cptrel
.konst
= addend
;
5660 cr
= (scpt
->contents
5661 + sizeof (Elf32_External_compact_rel
));
5662 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
5663 ((Elf32_External_crinfo
*) cr
5664 + scpt
->reloc_count
));
5665 ++scpt
->reloc_count
;
5669 return sreloc
->reloc_count
- 1;
5672 /* Calculate the value produced by the RELOCATION (which comes from
5673 the INPUT_BFD). The ADDEND is the addend to use for this
5674 RELOCATION; RELOCATION->R_ADDEND is ignored.
5676 The result of the relocation calculation is stored in VALUEP.
5677 REQUIRE_JALXP indicates whether or not the opcode used with this
5678 relocation must be JALX.
5680 This function returns bfd_reloc_continue if the caller need take no
5681 further action regarding this relocation, bfd_reloc_notsupported if
5682 something goes dramatically wrong, bfd_reloc_overflow if an
5683 overflow occurs, and bfd_reloc_ok to indicate success. */
5685 static bfd_reloc_status_type
5686 mips_elf_calculate_relocation (abfd
,
5700 asection
*input_section
;
5701 struct bfd_link_info
*info
;
5702 const Elf_Internal_Rela
*relocation
;
5704 reloc_howto_type
*howto
;
5705 Elf_Internal_Sym
*local_syms
;
5706 asection
**local_sections
;
5709 boolean
*require_jalxp
;
5711 /* The eventual value we will return. */
5713 /* The address of the symbol against which the relocation is
5716 /* The final GP value to be used for the relocatable, executable, or
5717 shared object file being produced. */
5718 bfd_vma gp
= (bfd_vma
) - 1;
5719 /* The place (section offset or address) of the storage unit being
5722 /* The value of GP used to create the relocatable object. */
5723 bfd_vma gp0
= (bfd_vma
) - 1;
5724 /* The offset into the global offset table at which the address of
5725 the relocation entry symbol, adjusted by the addend, resides
5726 during execution. */
5727 bfd_vma g
= (bfd_vma
) - 1;
5728 /* The section in which the symbol referenced by the relocation is
5730 asection
*sec
= NULL
;
5731 struct mips_elf_link_hash_entry
* h
= NULL
;
5732 /* True if the symbol referred to by this relocation is a local
5735 /* True if the symbol referred to by this relocation is "_gp_disp". */
5736 boolean gp_disp_p
= false;
5737 Elf_Internal_Shdr
*symtab_hdr
;
5739 unsigned long r_symndx
;
5741 /* True if overflow occurred during the calculation of the
5742 relocation value. */
5743 boolean overflowed_p
;
5744 /* True if this relocation refers to a MIPS16 function. */
5745 boolean target_is_16_bit_code_p
= false;
5747 /* Parse the relocation. */
5748 r_symndx
= ELF32_R_SYM (relocation
->r_info
);
5749 r_type
= ELF32_R_TYPE (relocation
->r_info
);
5750 p
= (input_section
->output_section
->vma
5751 + input_section
->output_offset
5752 + relocation
->r_offset
);
5754 /* Assume that there will be no overflow. */
5755 overflowed_p
= false;
5757 /* Figure out whether or not the symbol is local. */
5758 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
5759 if (elf_bad_symtab (input_bfd
))
5761 /* The symbol table does not follow the rule that local symbols
5762 must come before globals. */
5764 local_p
= local_sections
[r_symndx
] != NULL
;
5768 extsymoff
= symtab_hdr
->sh_info
;
5769 local_p
= r_symndx
< extsymoff
;
5772 /* Figure out the value of the symbol. */
5775 Elf_Internal_Sym
*sym
;
5777 sym
= local_syms
+ r_symndx
;
5778 sec
= local_sections
[r_symndx
];
5780 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
5781 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
)
5782 symbol
+= sym
->st_value
;
5784 /* MIPS16 text labels should be treated as odd. */
5785 if (sym
->st_other
== STO_MIPS16
)
5788 /* Record the name of this symbol, for our caller. */
5789 *namep
= bfd_elf_string_from_elf_section (input_bfd
,
5790 symtab_hdr
->sh_link
,
5793 *namep
= bfd_section_name (input_bfd
, sec
);
5795 target_is_16_bit_code_p
= (sym
->st_other
== STO_MIPS16
);
5799 /* For global symbols we look up the symbol in the hash-table. */
5800 h
= ((struct mips_elf_link_hash_entry
*)
5801 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
]);
5802 /* Find the real hash-table entry for this symbol. */
5803 while (h
->root
.type
== bfd_link_hash_indirect
5804 || h
->root
.type
== bfd_link_hash_warning
)
5805 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
5807 /* Record the name of this symbol, for our caller. */
5808 *namep
= h
->root
.root
.root
.string
;
5810 /* See if this is the special _gp_disp symbol. Note that such a
5811 symbol must always be a global symbol. */
5812 if (strcmp (h
->root
.root
.root
.string
, "_gp_disp") == 0)
5814 /* Relocations against _gp_disp are permitted only with
5815 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
5816 if (r_type
!= R_MIPS_HI16
&& r_type
!= R_MIPS_LO16
)
5817 return bfd_reloc_notsupported
;
5821 /* If this symbol is defined, calculate its address. Note that
5822 _gp_disp is a magic symbol, always implicitly defined by the
5823 linker, so it's inappropriate to check to see whether or not
5825 else if ((h
->root
.root
.type
== bfd_link_hash_defined
5826 || h
->root
.root
.type
== bfd_link_hash_defweak
)
5827 && h
->root
.root
.u
.def
.section
)
5829 sec
= h
->root
.root
.u
.def
.section
;
5830 if (sec
->output_section
)
5831 symbol
= (h
->root
.root
.u
.def
.value
5832 + sec
->output_section
->vma
5833 + sec
->output_offset
);
5835 symbol
= h
->root
.root
.u
.def
.value
;
5839 (*info
->callbacks
->undefined_symbol
)
5840 (info
, h
->root
.root
.root
.string
, input_bfd
,
5841 input_section
, relocation
->r_offset
);
5842 return bfd_reloc_undefined
;
5845 target_is_16_bit_code_p
= (h
->root
.other
== STO_MIPS16
);
5848 /* If this is a 32-bit call to a 16-bit function with a stub, we
5849 need to redirect the call to the stub, unless we're already *in*
5851 if (r_type
!= R_MIPS16_26
&& !info
->relocateable
5852 && ((h
!= NULL
&& h
->fn_stub
!= NULL
)
5853 || (local_p
&& elf_tdata (input_bfd
)->local_stubs
!= NULL
5854 && elf_tdata (input_bfd
)->local_stubs
[r_symndx
] != NULL
))
5855 && !mips_elf_stub_section_p (input_bfd
, input_section
))
5857 /* This is a 32-bit call to a 16-bit function. We should
5858 have already noticed that we were going to need the
5861 sec
= elf_tdata (input_bfd
)->local_stubs
[r_symndx
];
5864 BFD_ASSERT (h
->need_fn_stub
);
5868 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
5870 /* If this is a 16-bit call to a 32-bit function with a stub, we
5871 need to redirect the call to the stub. */
5872 else if (r_type
== R_MIPS16_26
&& !info
->relocateable
5874 && (h
->call_stub
!= NULL
|| h
->call_fp_stub
!= NULL
)
5875 && !target_is_16_bit_code_p
)
5877 /* If both call_stub and call_fp_stub are defined, we can figure
5878 out which one to use by seeing which one appears in the input
5880 if (h
->call_stub
!= NULL
&& h
->call_fp_stub
!= NULL
)
5885 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
5887 if (strncmp (bfd_get_section_name (input_bfd
, o
),
5888 CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
5890 sec
= h
->call_fp_stub
;
5897 else if (h
->call_stub
!= NULL
)
5900 sec
= h
->call_fp_stub
;
5902 BFD_ASSERT (sec
->_raw_size
> 0);
5903 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
5906 /* Calls from 16-bit code to 32-bit code and vice versa require the
5907 special jalx instruction. */
5908 if (!info
->relocateable
5909 && ((r_type
== R_MIPS16_26
) != target_is_16_bit_code_p
))
5910 *require_jalxp
= true;
5912 /* If we haven't already determined the GOT offset, or the GP value,
5913 and we're going to need it, get it now. */
5917 case R_MIPS_GOT_DISP
:
5918 case R_MIPS_GOT_HI16
:
5919 case R_MIPS_CALL_HI16
:
5920 case R_MIPS_GOT_LO16
:
5921 case R_MIPS_CALL_LO16
:
5922 /* Find the index into the GOT where this value is located. */
5925 BFD_ASSERT (addend
== 0);
5926 g
= mips_elf_global_got_index
5927 (elf_hash_table (info
)->dynobj
,
5928 (struct elf_link_hash_entry
*) h
);
5932 g
= mips_elf_local_got_index (abfd
, info
, symbol
+ addend
);
5933 if (g
== (bfd_vma
) -1)
5937 /* Convert GOT indices to actual offsets. */
5938 g
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
5944 case R_MIPS_GPREL16
:
5945 case R_MIPS_GPREL32
:
5946 gp0
= _bfd_get_gp_value (input_bfd
);
5947 gp
= _bfd_get_gp_value (abfd
);
5954 /* Figure out what kind of relocation is being performed. */
5958 return bfd_reloc_continue
;
5961 value
= symbol
+ mips_elf_sign_extend (addend
, 16);
5962 overflowed_p
= mips_elf_overflow_p (value
, 16);
5968 /* If we're creating a shared library, or this relocation is
5969 against a symbol in a shared library, then we can't know
5970 where the symbol will end up. So, we create a relocation
5971 record in the output, and leave the job up to the dynamic
5973 if (info
->shared
|| !sec
->output_section
)
5975 unsigned int reloc_index
;
5977 BFD_ASSERT (h
!= NULL
);
5979 = mips_elf_create_dynamic_relocation (abfd
,
5985 if (h
->min_dyn_reloc_index
== 0
5986 || reloc_index
< h
->min_dyn_reloc_index
)
5987 h
->min_dyn_reloc_index
= reloc_index
;
5988 value
= symbol
+ addend
;
5992 if (r_type
!= R_MIPS_REL32
)
5993 value
= symbol
+ addend
;
5997 value
&= howto
->dst_mask
;
6001 /* The calculation for R_MIPS_26 is just the same as for an
6002 R_MIPS_26. It's only the storage of the relocated field into
6003 the output file that's different. That's handled in
6004 mips_elf_perform_relocation. So, we just fall through to the
6005 R_MIPS_26 case here. */
6008 value
= (((addend
<< 2) | (p
& 0xf0000000)) + symbol
) >> 2;
6010 value
= (mips_elf_sign_extend (addend
<< 2, 28) + symbol
) >> 2;
6011 value
&= howto
->dst_mask
;
6017 value
= mips_elf_high (addend
+ symbol
);
6018 value
&= howto
->dst_mask
;
6022 value
= mips_elf_high (addend
+ gp
- p
);
6023 overflowed_p
= mips_elf_overflow_p (value
, 16);
6029 value
= (symbol
+ addend
) & howto
->dst_mask
;
6032 value
= addend
+ gp
- p
+ 4;
6033 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
6034 for overflow. But, on, say, Irix 5, relocations against
6035 _gp_disp are normally generated from the .cpload
6036 pseudo-op. It generates code that normally looks like
6039 lui $gp,%hi(_gp_disp)
6040 addiu $gp,$gp,%lo(_gp_disp)
6043 Here $t9 holds the address of the function being called,
6044 as required by the MIPS ELF ABI. The R_MIPS_LO16
6045 relocation can easily overflow in this situation, but the
6046 R_MIPS_HI16 relocation will handle the overflow.
6047 Therefore, we consider this a bug in the MIPS ABI, and do
6048 not check for overflow here. */
6052 case R_MIPS_LITERAL
:
6053 /* Because we don't merge literal sections, we can handle this
6054 just like R_MIPS_GPREL16. In the long run, we should merge
6055 shared literals, and then we will need to additional work
6060 case R_MIPS16_GPREL
:
6061 /* The R_MIPS16_GPREL performs the same calculation as
6062 R_MIPS_GPREL16, but stores the relocated bits in a different
6063 order. We don't need to do anything special here; the
6064 differences are handled in mips_elf_perform_relocation. */
6065 case R_MIPS_GPREL16
:
6067 value
= mips_elf_sign_extend (addend
, 16) + symbol
+ gp0
- gp
;
6069 value
= mips_elf_sign_extend (addend
, 16) + symbol
- gp
;
6070 overflowed_p
= mips_elf_overflow_p (value
, 16);
6076 value
= mips_elf_got16_entry (abfd
, info
, symbol
+ addend
);
6077 if (value
== (bfd_vma
) -1)
6080 = mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
6083 overflowed_p
= mips_elf_overflow_p (value
, 16);
6090 case R_MIPS_GOT_DISP
:
6092 overflowed_p
= mips_elf_overflow_p (value
, 16);
6095 case R_MIPS_GPREL32
:
6096 value
= (addend
+ symbol
+ gp0
- gp
) & howto
->dst_mask
;
6100 value
= mips_elf_sign_extend (addend
, 16) + symbol
- p
;
6101 overflowed_p
= mips_elf_overflow_p (value
, 16);
6104 case R_MIPS_GOT_HI16
:
6105 case R_MIPS_CALL_HI16
:
6106 /* We're allowed to handle these two relocations identically.
6107 The dynamic linker is allowed to handle the CALL relocations
6108 differently by creating a lazy evaluation stub. */
6110 value
= mips_elf_high (value
);
6111 value
&= howto
->dst_mask
;
6114 case R_MIPS_GOT_LO16
:
6115 case R_MIPS_CALL_LO16
:
6116 value
= g
& howto
->dst_mask
;
6119 case R_MIPS_GOT_PAGE
:
6120 value
= mips_elf_got_page (abfd
, info
, symbol
+ addend
, NULL
);
6121 if (value
== (bfd_vma
) -1)
6123 value
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
6126 overflowed_p
= mips_elf_overflow_p (value
, 16);
6129 case R_MIPS_GOT_OFST
:
6130 mips_elf_got_page (abfd
, info
, symbol
+ addend
, &value
);
6131 overflowed_p
= mips_elf_overflow_p (value
, 16);
6135 value
= symbol
- addend
;
6136 value
&= howto
->dst_mask
;
6140 value
= mips_elf_higher (addend
+ symbol
);
6141 value
&= howto
->dst_mask
;
6144 case R_MIPS_HIGHEST
:
6145 value
= mips_elf_highest (addend
+ symbol
);
6146 value
&= howto
->dst_mask
;
6149 case R_MIPS_SCN_DISP
:
6150 value
= symbol
+ addend
- sec
->output_offset
;
6151 value
&= howto
->dst_mask
;
6156 /* Both of these may be ignored. R_MIPS_JALR is an optimization
6157 hint; we could improve performance by honoring that hint. */
6158 return bfd_reloc_continue
;
6160 case R_MIPS_GNU_VTINHERIT
:
6161 case R_MIPS_GNU_VTENTRY
:
6162 /* We don't do anything with these at present. */
6163 return bfd_reloc_continue
;
6166 /* An unrecognized relocation type. */
6167 return bfd_reloc_notsupported
;
6170 /* Store the VALUE for our caller. */
6172 return overflowed_p
? bfd_reloc_overflow
: bfd_reloc_ok
;
6175 /* Obtain the field relocated by RELOCATION. */
6178 mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
)
6179 reloc_howto_type
*howto
;
6180 const Elf_Internal_Rela
*relocation
;
6185 bfd_byte
*location
= contents
+ relocation
->r_offset
;
6187 /* Obtain the bytes. */
6188 x
= bfd_get (8 * bfd_get_reloc_size (howto
), input_bfd
, location
);
6190 if ((ELF32_R_TYPE (relocation
->r_info
) == R_MIPS16_26
6191 || ELF32_R_TYPE (relocation
->r_info
) == R_MIPS16_GPREL
)
6192 && bfd_little_endian (input_bfd
))
6193 /* The two 16-bit words will be reversed on a little-endian
6194 system. See mips_elf_perform_relocation for more details. */
6195 x
= (((x
& 0xffff) << 16) | ((x
& 0xffff0000) >> 16));
6200 /* It has been determined that the result of the RELOCATION is the
6201 VALUE. Use HOWTO to place VALUE into the output file at the
6202 appropriate position. The SECTION is the section to which the
6203 relocation applies. If REQUIRE_JALX is true, then the opcode used
6204 for the relocation must be either JAL or JALX, and it is
6205 unconditionally converted to JALX.
6207 Returns false if anything goes wrong. */
6210 mips_elf_perform_relocation (info
, howto
, relocation
, value
,
6211 input_bfd
, input_section
,
6212 contents
, require_jalx
)
6213 struct bfd_link_info
*info
;
6214 reloc_howto_type
*howto
;
6215 const Elf_Internal_Rela
*relocation
;
6218 asection
*input_section
;
6220 boolean require_jalx
;
6224 int r_type
= ELF32_R_TYPE (relocation
->r_info
);
6226 /* Figure out where the relocation is occurring. */
6227 location
= contents
+ relocation
->r_offset
;
6229 /* Obtain the current value. */
6230 x
= mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
);
6232 /* Clear the field we are setting. */
6233 x
&= ~howto
->dst_mask
;
6235 /* If this is the R_MIPS16_26 relocation, we must store the
6236 value in a funny way. */
6237 if (r_type
== R_MIPS16_26
)
6239 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
6240 Most mips16 instructions are 16 bits, but these instructions
6243 The format of these instructions is:
6245 +--------------+--------------------------------+
6246 ! JALX ! X! Imm 20:16 ! Imm 25:21 !
6247 +--------------+--------------------------------+
6249 +-----------------------------------------------+
6251 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
6252 Note that the immediate value in the first word is swapped.
6254 When producing a relocateable object file, R_MIPS16_26 is
6255 handled mostly like R_MIPS_26. In particular, the addend is
6256 stored as a straight 26-bit value in a 32-bit instruction.
6257 (gas makes life simpler for itself by never adjusting a
6258 R_MIPS16_26 reloc to be against a section, so the addend is
6259 always zero). However, the 32 bit instruction is stored as 2
6260 16-bit values, rather than a single 32-bit value. In a
6261 big-endian file, the result is the same; in a little-endian
6262 file, the two 16-bit halves of the 32 bit value are swapped.
6263 This is so that a disassembler can recognize the jal
6266 When doing a final link, R_MIPS16_26 is treated as a 32 bit
6267 instruction stored as two 16-bit values. The addend A is the
6268 contents of the targ26 field. The calculation is the same as
6269 R_MIPS_26. When storing the calculated value, reorder the
6270 immediate value as shown above, and don't forget to store the
6271 value as two 16-bit values.
6273 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
6277 +--------+----------------------+
6281 +--------+----------------------+
6284 +----------+------+-------------+
6288 +----------+--------------------+
6289 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
6290 ((sub1 << 16) | sub2)).
6292 When producing a relocateable object file, the calculation is
6293 (((A < 2) | (P & 0xf0000000) + S) >> 2)
6294 When producing a fully linked file, the calculation is
6295 let R = (((A < 2) | (P & 0xf0000000) + S) >> 2)
6296 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff) */
6298 if (!info
->relocateable
)
6299 /* Shuffle the bits according to the formula above. */
6300 value
= (((value
& 0x1f0000) << 5)
6301 | ((value
& 0x3e00000) >> 5)
6302 | (value
& 0xffff));
6305 else if (r_type
== R_MIPS16_GPREL
)
6307 /* R_MIPS16_GPREL is used for GP-relative addressing in mips16
6308 mode. A typical instruction will have a format like this:
6310 +--------------+--------------------------------+
6311 ! EXTEND ! Imm 10:5 ! Imm 15:11 !
6312 +--------------+--------------------------------+
6313 ! Major ! rx ! ry ! Imm 4:0 !
6314 +--------------+--------------------------------+
6316 EXTEND is the five bit value 11110. Major is the instruction
6319 This is handled exactly like R_MIPS_GPREL16, except that the
6320 addend is retrieved and stored as shown in this diagram; that
6321 is, the Imm fields above replace the V-rel16 field.
6323 All we need to do here is shuffle the bits appropriately. As
6324 above, the two 16-bit halves must be swapped on a
6325 little-endian system. */
6326 value
= (((value
& 0x7e0) << 16)
6327 | ((value
& 0xf800) << 5)
6331 /* Set the field. */
6332 x
|= (value
& howto
->dst_mask
);
6334 /* If required, turn JAL into JALX. */
6338 bfd_vma opcode
= x
>> 26;
6339 bfd_vma jalx_opcode
;
6341 /* Check to see if the opcode is already JAL or JALX. */
6342 if (r_type
== R_MIPS16_26
)
6344 ok
= ((opcode
== 0x6) || (opcode
== 0x7));
6349 ok
= ((opcode
== 0x3) || (opcode
== 0x1d));
6353 /* If the opcode is not JAL or JALX, there's a problem. */
6356 (*_bfd_error_handler
)
6357 (_("%s: %s+0x%lx: jump to stub routine which is not jal"),
6358 bfd_get_filename (input_bfd
),
6359 input_section
->name
,
6360 (unsigned long) relocation
->r_offset
);
6361 bfd_set_error (bfd_error_bad_value
);
6365 /* Make this the JALX opcode. */
6366 x
= (x
& ~(0x3f << 26)) | (jalx_opcode
<< 26);
6369 /* Swap the high- and low-order 16 bits on little-endian systems
6370 when doing a MIPS16 relocation. */
6371 if ((r_type
== R_MIPS16_GPREL
|| r_type
== R_MIPS16_26
)
6372 && bfd_little_endian (input_bfd
))
6373 x
= (((x
& 0xffff) << 16) | ((x
& 0xffff0000) >> 16));
6375 /* Put the value into the output. */
6376 bfd_put (8 * bfd_get_reloc_size (howto
), input_bfd
, x
, location
);
6380 /* Returns true if SECTION is a MIPS16 stub section. */
6383 mips_elf_stub_section_p (abfd
, section
)
6387 const char *name
= bfd_get_section_name (abfd
, section
);
6389 return (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0
6390 || strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
6391 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0);
6394 /* Relocate a MIPS ELF section. */
6397 _bfd_mips_elf_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
6398 contents
, relocs
, local_syms
, local_sections
)
6400 struct bfd_link_info
*info
;
6402 asection
*input_section
;
6404 Elf_Internal_Rela
*relocs
;
6405 Elf_Internal_Sym
*local_syms
;
6406 asection
**local_sections
;
6408 const Elf_Internal_Rela
*rel
;
6409 const Elf_Internal_Rela
*relend
;
6411 bfd_vma last_hi16_addend
;
6412 boolean use_saved_addend_p
= false;
6413 boolean last_hi16_addend_valid_p
= false;
6414 struct elf_backend_data
*bed
;
6416 bed
= get_elf_backend_data (output_bfd
);
6417 relend
= relocs
+ input_section
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
6418 for (rel
= relocs
; rel
< relend
; ++rel
)
6422 reloc_howto_type
*howto
;
6423 boolean require_jalx
;
6425 /* Find the relocation howto for this relocation. */
6426 if (ELF32_R_TYPE (rel
->r_info
) == R_MIPS_64
6427 && !ABI_64_P (output_bfd
))
6428 /* Some 32-bit code uses R_MIPS_64. In particular, people use
6429 64-bit code, but make sure all their addresses are in the
6430 lowermost or uppermost 32-bit section of the 64-bit address
6431 space. Thus, when they use an R_MIPS_64 they mean what is
6432 usually meant by R_MIPS_32, with the exception that the
6433 stored value is sign-extended to 64 bits. */
6434 howto
= elf_mips_howto_table
+ R_MIPS_32
;
6436 howto
= elf_mips_howto_table
+ ELF32_R_TYPE (rel
->r_info
);
6438 if (!use_saved_addend_p
)
6440 Elf_Internal_Shdr
*rel_hdr
;
6442 /* If these relocations were originally of the REL variety,
6443 we must pull the addend out of the field that will be
6444 relocated. Otherwise, we simply use the contents of the
6445 RELA relocation. To determine which flavor or relocation
6446 this is, we depend on the fact that the INPUT_SECTION's
6447 REL_HDR is read before its REL_HDR2. */
6448 rel_hdr
= &elf_section_data (input_section
)->rel_hdr
;
6449 if ((size_t) (rel
- relocs
)
6450 >= (rel_hdr
->sh_size
/ rel_hdr
->sh_entsize
6451 * bed
->s
->int_rels_per_ext_rel
))
6452 rel_hdr
= elf_section_data (input_section
)->rel_hdr2
;
6453 if (rel_hdr
->sh_entsize
== MIPS_ELF_REL_SIZE (input_bfd
))
6455 int r_type
= ELF32_R_TYPE (rel
->r_info
);
6457 addend
= mips_elf_obtain_contents (howto
,
6461 addend
&= howto
->src_mask
;
6463 /* For some kinds of relocations, the ADDEND is a
6464 combination of the addend stored in two different
6466 if (r_type
== R_MIPS_HI16
|| r_type
== R_MIPS_GOT16
)
6468 /* Scan ahead to find a matching R_MIPS_LO16
6472 if (!mips_elf_next_lo16_addend (rel
, relend
, &l
))
6475 /* Save the high-order bit for later. When we
6476 encounter the R_MIPS_LO16 relocation we will need
6479 last_hi16_addend
= addend
;
6480 last_hi16_addend_valid_p
= true;
6482 /* Compute the combined addend. */
6485 else if (r_type
== R_MIPS_LO16
)
6487 /* Used the saved HI16 addend. */
6488 if (!last_hi16_addend_valid_p
)
6490 addend
|= last_hi16_addend
;
6492 else if (r_type
== R_MIPS16_GPREL
)
6494 /* The addend is scrambled in the object file. See
6495 mips_elf_perform_relocation for details on the
6497 addend
= (((addend
& 0x1f0000) >> 5)
6498 | ((addend
& 0x7e00000) >> 16)
6503 addend
= rel
->r_addend
;
6506 /* In the N32 and 64-bit ABIs there may be multiple consecutive
6507 relocations for the same offset. In that case we are
6508 supposed to treat the output of each relocation as the addend
6510 if (rel
+ 1 < relend
6511 && rel
->r_offset
== rel
[1].r_offset
6512 && ELF32_R_TYPE (rel
[1].r_info
) != R_MIPS_NONE
)
6513 use_saved_addend_p
= true;
6515 use_saved_addend_p
= false;
6517 /* Figure out what value we are supposed to relocate. */
6518 switch (mips_elf_calculate_relocation (output_bfd
,
6531 case bfd_reloc_continue
:
6532 /* There's nothing to do. */
6535 case bfd_reloc_undefined
:
6538 case bfd_reloc_notsupported
:
6542 case bfd_reloc_overflow
:
6543 if (use_saved_addend_p
)
6544 /* Ignore overflow until we reach the last relocation for
6545 a given location. */
6548 || ! ((*info
->callbacks
->reloc_overflow
)
6549 (info
, name
, howto
->name
, (bfd_vma
) 0,
6550 input_bfd
, input_section
, rel
->r_offset
)))
6563 /* If we've got another relocation for the address, keep going
6564 until we reach the last one. */
6565 if (use_saved_addend_p
)
6571 if (ELF32_R_TYPE (rel
->r_info
) == R_MIPS_64
6572 && !ABI_64_P (output_bfd
))
6573 /* See the comment above about using R_MIPS_64 in the 32-bit
6574 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
6575 that calculated the right value. Now, however, we
6576 sign-extend the 32-bit result to 64-bits, and store it as a
6577 64-bit value. We are especially generous here in that we
6578 go to extreme lengths to support this usage on systems with
6579 only a 32-bit VMA. */
6582 /* Just sign-extend the value, and then fall through to the
6583 normal case, using the R_MIPS_64 howto. That will store
6584 the 64-bit value into a 64-bit area. */
6585 value
= mips_elf_sign_extend (value
, 64);
6586 howto
= elf_mips_howto_table
+ R_MIPS_64
;
6588 /* In the 32-bit VMA case, we must handle sign-extension and
6589 endianness manually. */
6594 if (value
& 0x80000000)
6595 sign_bits
= 0xffffffff;
6599 /* If only a 32-bit VMA is available do two separate
6601 if (bfd_big_endian (input_bfd
))
6603 /* Store the sign-bits (which are most significant)
6605 low_bits
= sign_bits
;
6611 high_bits
= sign_bits
;
6613 bfd_put_32 (input_bfd
, low_bits
,
6614 contents
+ rel
->r_offset
);
6615 bfd_put_32 (input_bfd
, high_bits
,
6616 contents
+ rel
->r_offset
+ 4);
6621 /* Actually perform the relocation. */
6622 if (!mips_elf_perform_relocation (info
, howto
, rel
, value
, input_bfd
,
6623 input_section
, contents
,
6631 /* This hook function is called before the linker writes out a global
6632 symbol. We mark symbols as small common if appropriate. This is
6633 also where we undo the increment of the value for a mips16 symbol. */
6637 _bfd_mips_elf_link_output_symbol_hook (abfd
, info
, name
, sym
, input_sec
)
6638 bfd
*abfd ATTRIBUTE_UNUSED
;
6639 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
6640 const char *name ATTRIBUTE_UNUSED
;
6641 Elf_Internal_Sym
*sym
;
6642 asection
*input_sec
;
6644 /* If we see a common symbol, which implies a relocatable link, then
6645 if a symbol was small common in an input file, mark it as small
6646 common in the output file. */
6647 if (sym
->st_shndx
== SHN_COMMON
6648 && strcmp (input_sec
->name
, ".scommon") == 0)
6649 sym
->st_shndx
= SHN_MIPS_SCOMMON
;
6651 if (sym
->st_other
== STO_MIPS16
6652 && (sym
->st_value
& 1) != 0)
6658 /* Functions for the dynamic linker. */
6660 /* The name of the dynamic interpreter. This is put in the .interp
6663 #define ELF_DYNAMIC_INTERPRETER(abfd) \
6664 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
6665 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
6666 : "/usr/lib/libc.so.1")
6668 /* Create dynamic sections when linking against a dynamic object. */
6671 _bfd_mips_elf_create_dynamic_sections (abfd
, info
)
6673 struct bfd_link_info
*info
;
6675 struct elf_link_hash_entry
*h
;
6677 register asection
*s
;
6678 const char * const *namep
;
6680 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
6681 | SEC_LINKER_CREATED
| SEC_READONLY
);
6683 /* Mips ABI requests the .dynamic section to be read only. */
6684 s
= bfd_get_section_by_name (abfd
, ".dynamic");
6687 if (! bfd_set_section_flags (abfd
, s
, flags
))
6691 /* We need to create .got section. */
6692 if (! mips_elf_create_got_section (abfd
, info
))
6695 /* Create the .msym section on IRIX6. It is used by the dynamic
6696 linker to speed up dynamic relocations, and to avoid computing
6697 the ELF hash for symbols. */
6698 if (IRIX_COMPAT (abfd
) == ict_irix6
6699 && !mips_elf_create_msym_section (abfd
))
6702 /* Create .stub section. */
6703 if (bfd_get_section_by_name (abfd
,
6704 MIPS_ELF_STUB_SECTION_NAME (abfd
)) == NULL
)
6706 s
= bfd_make_section (abfd
, MIPS_ELF_STUB_SECTION_NAME (abfd
));
6708 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_CODE
)
6709 || ! bfd_set_section_alignment (abfd
, s
,
6710 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
6714 if (IRIX_COMPAT (abfd
) == ict_irix5
6716 && bfd_get_section_by_name (abfd
, ".rld_map") == NULL
)
6718 s
= bfd_make_section (abfd
, ".rld_map");
6720 || ! bfd_set_section_flags (abfd
, s
, flags
& ~SEC_READONLY
)
6721 || ! bfd_set_section_alignment (abfd
, s
,
6722 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
6726 /* On IRIX5, we adjust add some additional symbols and change the
6727 alignments of several sections. There is no ABI documentation
6728 indicating that this is necessary on IRIX6, nor any evidence that
6729 the linker takes such action. */
6730 if (IRIX_COMPAT (abfd
) == ict_irix5
)
6732 for (namep
= mips_elf_dynsym_rtproc_names
; *namep
!= NULL
; namep
++)
6735 if (! (_bfd_generic_link_add_one_symbol
6736 (info
, abfd
, *namep
, BSF_GLOBAL
, bfd_und_section_ptr
,
6737 (bfd_vma
) 0, (const char *) NULL
, false,
6738 get_elf_backend_data (abfd
)->collect
,
6739 (struct bfd_link_hash_entry
**) &h
)))
6741 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
6742 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
6743 h
->type
= STT_SECTION
;
6745 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
6749 /* We need to create a .compact_rel section. */
6750 if (! mips_elf_create_compact_rel_section (abfd
, info
))
6753 /* Change aligments of some sections. */
6754 s
= bfd_get_section_by_name (abfd
, ".hash");
6756 bfd_set_section_alignment (abfd
, s
, 4);
6757 s
= bfd_get_section_by_name (abfd
, ".dynsym");
6759 bfd_set_section_alignment (abfd
, s
, 4);
6760 s
= bfd_get_section_by_name (abfd
, ".dynstr");
6762 bfd_set_section_alignment (abfd
, s
, 4);
6763 s
= bfd_get_section_by_name (abfd
, ".reginfo");
6765 bfd_set_section_alignment (abfd
, s
, 4);
6766 s
= bfd_get_section_by_name (abfd
, ".dynamic");
6768 bfd_set_section_alignment (abfd
, s
, 4);
6774 if (! (_bfd_generic_link_add_one_symbol
6775 (info
, abfd
, "_DYNAMIC_LINK", BSF_GLOBAL
, bfd_abs_section_ptr
,
6776 (bfd_vma
) 0, (const char *) NULL
, false,
6777 get_elf_backend_data (abfd
)->collect
,
6778 (struct bfd_link_hash_entry
**) &h
)))
6780 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
6781 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
6782 h
->type
= STT_SECTION
;
6784 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
6787 if (! mips_elf_hash_table (info
)->use_rld_obj_head
)
6789 /* __rld_map is a four byte word located in the .data section
6790 and is filled in by the rtld to contain a pointer to
6791 the _r_debug structure. Its symbol value will be set in
6792 mips_elf_finish_dynamic_symbol. */
6793 s
= bfd_get_section_by_name (abfd
, ".rld_map");
6794 BFD_ASSERT (s
!= NULL
);
6797 if (! (_bfd_generic_link_add_one_symbol
6798 (info
, abfd
, "__rld_map", BSF_GLOBAL
, s
,
6799 (bfd_vma
) 0, (const char *) NULL
, false,
6800 get_elf_backend_data (abfd
)->collect
,
6801 (struct bfd_link_hash_entry
**) &h
)))
6803 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
6804 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
6805 h
->type
= STT_OBJECT
;
6807 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
6815 /* Create the .compact_rel section. */
6818 mips_elf_create_compact_rel_section (abfd
, info
)
6820 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
6823 register asection
*s
;
6825 if (bfd_get_section_by_name (abfd
, ".compact_rel") == NULL
)
6827 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
6830 s
= bfd_make_section (abfd
, ".compact_rel");
6832 || ! bfd_set_section_flags (abfd
, s
, flags
)
6833 || ! bfd_set_section_alignment (abfd
, s
,
6834 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
6837 s
->_raw_size
= sizeof (Elf32_External_compact_rel
);
6843 /* Create the .got section to hold the global offset table. */
6846 mips_elf_create_got_section (abfd
, info
)
6848 struct bfd_link_info
*info
;
6851 register asection
*s
;
6852 struct elf_link_hash_entry
*h
;
6853 struct mips_got_info
*g
;
6855 /* This function may be called more than once. */
6856 if (mips_elf_got_section (abfd
))
6859 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
6860 | SEC_LINKER_CREATED
);
6862 s
= bfd_make_section (abfd
, ".got");
6864 || ! bfd_set_section_flags (abfd
, s
, flags
)
6865 || ! bfd_set_section_alignment (abfd
, s
, 4))
6868 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
6869 linker script because we don't want to define the symbol if we
6870 are not creating a global offset table. */
6872 if (! (_bfd_generic_link_add_one_symbol
6873 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
6874 (bfd_vma
) 0, (const char *) NULL
, false,
6875 get_elf_backend_data (abfd
)->collect
,
6876 (struct bfd_link_hash_entry
**) &h
)))
6878 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
6879 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
6880 h
->type
= STT_OBJECT
;
6883 && ! bfd_elf32_link_record_dynamic_symbol (info
, h
))
6886 /* The first several global offset table entries are reserved. */
6887 s
->_raw_size
= MIPS_RESERVED_GOTNO
* MIPS_ELF_GOT_SIZE (abfd
);
6889 g
= (struct mips_got_info
*) bfd_alloc (abfd
,
6890 sizeof (struct mips_got_info
));
6893 g
->global_gotsym
= NULL
;
6894 g
->local_gotno
= MIPS_RESERVED_GOTNO
;
6895 g
->assigned_gotno
= MIPS_RESERVED_GOTNO
;
6896 if (elf_section_data (s
) == NULL
)
6899 (PTR
) bfd_zalloc (abfd
, sizeof (struct bfd_elf_section_data
));
6900 if (elf_section_data (s
) == NULL
)
6903 elf_section_data (s
)->tdata
= (PTR
) g
;
6904 elf_section_data (s
)->this_hdr
.sh_flags
6905 |= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
6910 /* Returns the .msym section for ABFD, creating it if it does not
6911 already exist. Returns NULL to indicate error. */
6914 mips_elf_create_msym_section (abfd
)
6919 s
= bfd_get_section_by_name (abfd
, MIPS_ELF_MSYM_SECTION_NAME (abfd
));
6922 s
= bfd_make_section (abfd
, MIPS_ELF_MSYM_SECTION_NAME (abfd
));
6924 || !bfd_set_section_flags (abfd
, s
,
6928 | SEC_LINKER_CREATED
6930 || !bfd_set_section_alignment (abfd
, s
,
6931 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
6938 /* Add room for N relocations to the .rel.dyn section in ABFD. */
6941 mips_elf_allocate_dynamic_relocations (abfd
, n
)
6947 s
= bfd_get_section_by_name (abfd
, MIPS_ELF_REL_DYN_SECTION_NAME (abfd
));
6948 BFD_ASSERT (s
!= NULL
);
6950 if (s
->_raw_size
== 0)
6952 /* Make room for a null element. */
6953 s
->_raw_size
+= MIPS_ELF_REL_SIZE (abfd
);
6956 s
->_raw_size
+= n
* MIPS_ELF_REL_SIZE (abfd
);
6959 /* Look through the relocs for a section during the first phase, and
6960 allocate space in the global offset table. */
6963 _bfd_mips_elf_check_relocs (abfd
, info
, sec
, relocs
)
6965 struct bfd_link_info
*info
;
6967 const Elf_Internal_Rela
*relocs
;
6971 Elf_Internal_Shdr
*symtab_hdr
;
6972 struct elf_link_hash_entry
**sym_hashes
;
6973 struct mips_got_info
*g
;
6975 const Elf_Internal_Rela
*rel
;
6976 const Elf_Internal_Rela
*rel_end
;
6979 struct elf_backend_data
*bed
;
6981 if (info
->relocateable
)
6984 dynobj
= elf_hash_table (info
)->dynobj
;
6985 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
6986 sym_hashes
= elf_sym_hashes (abfd
);
6987 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
6989 /* Check for the mips16 stub sections. */
6991 name
= bfd_get_section_name (abfd
, sec
);
6992 if (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0)
6994 unsigned long r_symndx
;
6996 /* Look at the relocation information to figure out which symbol
6999 r_symndx
= ELF32_R_SYM (relocs
->r_info
);
7001 if (r_symndx
< extsymoff
7002 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
7006 /* This stub is for a local symbol. This stub will only be
7007 needed if there is some relocation in this BFD, other
7008 than a 16 bit function call, which refers to this symbol. */
7009 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
7011 Elf_Internal_Rela
*sec_relocs
;
7012 const Elf_Internal_Rela
*r
, *rend
;
7014 /* We can ignore stub sections when looking for relocs. */
7015 if ((o
->flags
& SEC_RELOC
) == 0
7016 || o
->reloc_count
== 0
7017 || strncmp (bfd_get_section_name (abfd
, o
), FN_STUB
,
7018 sizeof FN_STUB
- 1) == 0
7019 || strncmp (bfd_get_section_name (abfd
, o
), CALL_STUB
,
7020 sizeof CALL_STUB
- 1) == 0
7021 || strncmp (bfd_get_section_name (abfd
, o
), CALL_FP_STUB
,
7022 sizeof CALL_FP_STUB
- 1) == 0)
7025 sec_relocs
= (_bfd_elf32_link_read_relocs
7026 (abfd
, o
, (PTR
) NULL
,
7027 (Elf_Internal_Rela
*) NULL
,
7028 info
->keep_memory
));
7029 if (sec_relocs
== NULL
)
7032 rend
= sec_relocs
+ o
->reloc_count
;
7033 for (r
= sec_relocs
; r
< rend
; r
++)
7034 if (ELF32_R_SYM (r
->r_info
) == r_symndx
7035 && ELF32_R_TYPE (r
->r_info
) != R_MIPS16_26
)
7038 if (! info
->keep_memory
)
7047 /* There is no non-call reloc for this stub, so we do
7048 not need it. Since this function is called before
7049 the linker maps input sections to output sections, we
7050 can easily discard it by setting the SEC_EXCLUDE
7052 sec
->flags
|= SEC_EXCLUDE
;
7056 /* Record this stub in an array of local symbol stubs for
7058 if (elf_tdata (abfd
)->local_stubs
== NULL
)
7060 unsigned long symcount
;
7063 if (elf_bad_symtab (abfd
))
7064 symcount
= symtab_hdr
->sh_size
/ symtab_hdr
->sh_entsize
;
7066 symcount
= symtab_hdr
->sh_info
;
7067 n
= (asection
**) bfd_zalloc (abfd
,
7068 symcount
* sizeof (asection
*));
7071 elf_tdata (abfd
)->local_stubs
= n
;
7074 elf_tdata (abfd
)->local_stubs
[r_symndx
] = sec
;
7076 /* We don't need to set mips16_stubs_seen in this case.
7077 That flag is used to see whether we need to look through
7078 the global symbol table for stubs. We don't need to set
7079 it here, because we just have a local stub. */
7083 struct mips_elf_link_hash_entry
*h
;
7085 h
= ((struct mips_elf_link_hash_entry
*)
7086 sym_hashes
[r_symndx
- extsymoff
]);
7088 /* H is the symbol this stub is for. */
7091 mips_elf_hash_table (info
)->mips16_stubs_seen
= true;
7094 else if (strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
7095 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
7097 unsigned long r_symndx
;
7098 struct mips_elf_link_hash_entry
*h
;
7101 /* Look at the relocation information to figure out which symbol
7104 r_symndx
= ELF32_R_SYM (relocs
->r_info
);
7106 if (r_symndx
< extsymoff
7107 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
7109 /* This stub was actually built for a static symbol defined
7110 in the same file. We assume that all static symbols in
7111 mips16 code are themselves mips16, so we can simply
7112 discard this stub. Since this function is called before
7113 the linker maps input sections to output sections, we can
7114 easily discard it by setting the SEC_EXCLUDE flag. */
7115 sec
->flags
|= SEC_EXCLUDE
;
7119 h
= ((struct mips_elf_link_hash_entry
*)
7120 sym_hashes
[r_symndx
- extsymoff
]);
7122 /* H is the symbol this stub is for. */
7124 if (strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
7125 loc
= &h
->call_fp_stub
;
7127 loc
= &h
->call_stub
;
7129 /* If we already have an appropriate stub for this function, we
7130 don't need another one, so we can discard this one. Since
7131 this function is called before the linker maps input sections
7132 to output sections, we can easily discard it by setting the
7133 SEC_EXCLUDE flag. We can also discard this section if we
7134 happen to already know that this is a mips16 function; it is
7135 not necessary to check this here, as it is checked later, but
7136 it is slightly faster to check now. */
7137 if (*loc
!= NULL
|| h
->root
.other
== STO_MIPS16
)
7139 sec
->flags
|= SEC_EXCLUDE
;
7144 mips_elf_hash_table (info
)->mips16_stubs_seen
= true;
7154 sgot
= mips_elf_got_section (dynobj
);
7159 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
7160 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
7161 BFD_ASSERT (g
!= NULL
);
7166 bed
= get_elf_backend_data (abfd
);
7167 rel_end
= relocs
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
7168 for (rel
= relocs
; rel
< rel_end
; ++rel
)
7170 unsigned long r_symndx
;
7172 struct elf_link_hash_entry
*h
;
7174 r_symndx
= ELF32_R_SYM (rel
->r_info
);
7175 r_type
= ELF32_R_TYPE (rel
->r_info
);
7177 if (r_symndx
< extsymoff
)
7181 h
= sym_hashes
[r_symndx
- extsymoff
];
7183 /* This may be an indirect symbol created because of a version. */
7186 while (h
->root
.type
== bfd_link_hash_indirect
)
7187 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
7191 /* Some relocs require a global offset table. */
7192 if (dynobj
== NULL
|| sgot
== NULL
)
7198 case R_MIPS_CALL_HI16
:
7199 case R_MIPS_CALL_LO16
:
7200 case R_MIPS_GOT_HI16
:
7201 case R_MIPS_GOT_LO16
:
7202 case R_MIPS_GOT_PAGE
:
7203 case R_MIPS_GOT_OFST
:
7204 case R_MIPS_GOT_DISP
:
7206 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
7207 if (! mips_elf_create_got_section (dynobj
, info
))
7209 g
= mips_elf_got_info (dynobj
, &sgot
);
7216 && (info
->shared
|| h
!= NULL
)
7217 && (sec
->flags
& SEC_ALLOC
) != 0)
7218 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
7226 if (!h
&& (r_type
== R_MIPS_CALL_LO16
7227 || r_type
== R_MIPS_GOT_LO16
7228 || r_type
== R_MIPS_GOT_DISP
))
7230 /* We may need a local GOT entry for this relocation. We
7231 don't count R_MIPS_HI16 or R_MIPS_GOT16 relocations
7232 because they are always followed by a R_MIPS_LO16
7233 relocation for the value. We don't R_MIPS_GOT_PAGE
7234 because we can estimate the maximum number of pages
7235 needed by looking at the size of the segment.
7237 This estimation is very conservative since we can merge
7238 duplicate entries in the GOT. In order to be less
7239 conservative, we could actually build the GOT here,
7240 rather than in relocate_section. */
7242 sgot
->_raw_size
+= MIPS_ELF_GOT_SIZE (dynobj
);
7250 (*_bfd_error_handler
)
7251 (_("%s: CALL16 reloc at 0x%lx not against global symbol"),
7252 bfd_get_filename (abfd
), (unsigned long) rel
->r_offset
);
7253 bfd_set_error (bfd_error_bad_value
);
7258 case R_MIPS_CALL_HI16
:
7259 case R_MIPS_CALL_LO16
:
7260 /* This symbol requires a global offset table entry. */
7261 if (!mips_elf_record_global_got_symbol (h
, info
, g
))
7264 /* We need a stub, not a plt entry for the undefined
7265 function. But we record it as if it needs plt. See
7266 elf_adjust_dynamic_symbol in elflink.h. */
7267 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
7273 case R_MIPS_GOT_HI16
:
7274 case R_MIPS_GOT_LO16
:
7275 case R_MIPS_GOT_DISP
:
7276 /* This symbol requires a global offset table entry. */
7277 if (h
&& !mips_elf_record_global_got_symbol (h
, info
, g
))
7284 if ((info
->shared
|| h
!= NULL
)
7285 && (sec
->flags
& SEC_ALLOC
) != 0)
7289 const char *name
= MIPS_ELF_REL_DYN_SECTION_NAME (dynobj
);
7291 sreloc
= bfd_get_section_by_name (dynobj
, name
);
7294 sreloc
= bfd_make_section (dynobj
, name
);
7296 || ! bfd_set_section_flags (dynobj
, sreloc
,
7301 | SEC_LINKER_CREATED
7303 || ! bfd_set_section_alignment (dynobj
, sreloc
,
7309 /* When creating a shared object, we must copy these
7310 reloc types into the output file as R_MIPS_REL32
7311 relocs. We make room for this reloc in the
7312 .rel.dyn reloc section. */
7313 mips_elf_allocate_dynamic_relocations (dynobj
, 1);
7316 struct mips_elf_link_hash_entry
*hmips
;
7318 /* We only need to copy this reloc if the symbol is
7319 defined in a dynamic object. */
7320 hmips
= (struct mips_elf_link_hash_entry
*) h
;
7321 ++hmips
->possibly_dynamic_relocs
;
7324 /* Even though we don't directly need a GOT entry for
7325 this symbol, a symbol must have a dynamic symbol
7326 table index greater that DT_GOTSYM if there are
7327 dynamic relocations against it. */
7328 if (!mips_elf_record_global_got_symbol (h
, info
, g
))
7332 if (SGI_COMPAT (dynobj
))
7333 mips_elf_hash_table (info
)->compact_rel_size
+=
7334 sizeof (Elf32_External_crinfo
);
7338 case R_MIPS_GPREL16
:
7339 case R_MIPS_LITERAL
:
7340 case R_MIPS_GPREL32
:
7341 if (SGI_COMPAT (dynobj
))
7342 mips_elf_hash_table (info
)->compact_rel_size
+=
7343 sizeof (Elf32_External_crinfo
);
7346 /* This relocation describes the C++ object vtable hierarchy.
7347 Reconstruct it for later use during GC. */
7348 case R_MIPS_GNU_VTINHERIT
:
7349 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
7353 /* This relocation describes which C++ vtable entries are actually
7354 used. Record for later use during GC. */
7355 case R_MIPS_GNU_VTENTRY
:
7356 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
7364 /* If this reloc is not a 16 bit call, and it has a global
7365 symbol, then we will need the fn_stub if there is one.
7366 References from a stub section do not count. */
7368 && r_type
!= R_MIPS16_26
7369 && strncmp (bfd_get_section_name (abfd
, sec
), FN_STUB
,
7370 sizeof FN_STUB
- 1) != 0
7371 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_STUB
,
7372 sizeof CALL_STUB
- 1) != 0
7373 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_FP_STUB
,
7374 sizeof CALL_FP_STUB
- 1) != 0)
7376 struct mips_elf_link_hash_entry
*mh
;
7378 mh
= (struct mips_elf_link_hash_entry
*) h
;
7379 mh
->need_fn_stub
= true;
7386 /* Return the section that should be marked against GC for a given
7390 _bfd_mips_elf_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
7392 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
7393 Elf_Internal_Rela
*rel
;
7394 struct elf_link_hash_entry
*h
;
7395 Elf_Internal_Sym
*sym
;
7397 /* ??? Do mips16 stub sections need to be handled special? */
7401 switch (ELF32_R_TYPE (rel
->r_info
))
7403 case R_MIPS_GNU_VTINHERIT
:
7404 case R_MIPS_GNU_VTENTRY
:
7408 switch (h
->root
.type
)
7410 case bfd_link_hash_defined
:
7411 case bfd_link_hash_defweak
:
7412 return h
->root
.u
.def
.section
;
7414 case bfd_link_hash_common
:
7415 return h
->root
.u
.c
.p
->section
;
7424 if (!(elf_bad_symtab (abfd
)
7425 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
7426 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
7427 && sym
->st_shndx
!= SHN_COMMON
))
7429 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
7436 /* Update the got entry reference counts for the section being removed. */
7439 _bfd_mips_elf_gc_sweep_hook (abfd
, info
, sec
, relocs
)
7440 bfd
*abfd ATTRIBUTE_UNUSED
;
7441 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
7442 asection
*sec ATTRIBUTE_UNUSED
;
7443 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
;
7446 Elf_Internal_Shdr
*symtab_hdr
;
7447 struct elf_link_hash_entry
**sym_hashes
;
7448 bfd_signed_vma
*local_got_refcounts
;
7449 const Elf_Internal_Rela
*rel
, *relend
;
7450 unsigned long r_symndx
;
7451 struct elf_link_hash_entry
*h
;
7453 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7454 sym_hashes
= elf_sym_hashes (abfd
);
7455 local_got_refcounts
= elf_local_got_refcounts (abfd
);
7457 relend
= relocs
+ sec
->reloc_count
;
7458 for (rel
= relocs
; rel
< relend
; rel
++)
7459 switch (ELF32_R_TYPE (rel
->r_info
))
7463 case R_MIPS_CALL_HI16
:
7464 case R_MIPS_CALL_LO16
:
7465 case R_MIPS_GOT_HI16
:
7466 case R_MIPS_GOT_LO16
:
7467 /* ??? It would seem that the existing MIPS code does no sort
7468 of reference counting or whatnot on its GOT and PLT entries,
7469 so it is not possible to garbage collect them at this time. */
7481 /* Adjust a symbol defined by a dynamic object and referenced by a
7482 regular object. The current definition is in some section of the
7483 dynamic object, but we're not including those sections. We have to
7484 change the definition to something the rest of the link can
7488 _bfd_mips_elf_adjust_dynamic_symbol (info
, h
)
7489 struct bfd_link_info
*info
;
7490 struct elf_link_hash_entry
*h
;
7493 struct mips_elf_link_hash_entry
*hmips
;
7496 dynobj
= elf_hash_table (info
)->dynobj
;
7498 /* Make sure we know what is going on here. */
7499 BFD_ASSERT (dynobj
!= NULL
7500 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
7501 || h
->weakdef
!= NULL
7502 || ((h
->elf_link_hash_flags
7503 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
7504 && (h
->elf_link_hash_flags
7505 & ELF_LINK_HASH_REF_REGULAR
) != 0
7506 && (h
->elf_link_hash_flags
7507 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
7509 /* If this symbol is defined in a dynamic object, we need to copy
7510 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
7512 hmips
= (struct mips_elf_link_hash_entry
*) h
;
7513 if (! info
->relocateable
7514 && hmips
->possibly_dynamic_relocs
!= 0
7515 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
7516 mips_elf_allocate_dynamic_relocations (dynobj
,
7517 hmips
->possibly_dynamic_relocs
);
7519 /* For a function, create a stub, if needed. */
7520 if (h
->type
== STT_FUNC
7521 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
7523 if (! elf_hash_table (info
)->dynamic_sections_created
)
7526 /* If this symbol is not defined in a regular file, then set
7527 the symbol to the stub location. This is required to make
7528 function pointers compare as equal between the normal
7529 executable and the shared library. */
7530 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
7532 /* We need .stub section. */
7533 s
= bfd_get_section_by_name (dynobj
,
7534 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
7535 BFD_ASSERT (s
!= NULL
);
7537 h
->root
.u
.def
.section
= s
;
7538 h
->root
.u
.def
.value
= s
->_raw_size
;
7540 /* XXX Write this stub address somewhere. */
7541 h
->plt
.offset
= s
->_raw_size
;
7543 /* Make room for this stub code. */
7544 s
->_raw_size
+= MIPS_FUNCTION_STUB_SIZE
;
7546 /* The last half word of the stub will be filled with the index
7547 of this symbol in .dynsym section. */
7552 /* If this is a weak symbol, and there is a real definition, the
7553 processor independent code will have arranged for us to see the
7554 real definition first, and we can just use the same value. */
7555 if (h
->weakdef
!= NULL
)
7557 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
7558 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
7559 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
7560 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
7564 /* This is a reference to a symbol defined by a dynamic object which
7565 is not a function. */
7570 /* This function is called after all the input files have been read,
7571 and the input sections have been assigned to output sections. We
7572 check for any mips16 stub sections that we can discard. */
7574 static boolean mips_elf_check_mips16_stubs
7575 PARAMS ((struct mips_elf_link_hash_entry
*, PTR
));
7578 _bfd_mips_elf_always_size_sections (output_bfd
, info
)
7580 struct bfd_link_info
*info
;
7584 /* The .reginfo section has a fixed size. */
7585 ri
= bfd_get_section_by_name (output_bfd
, ".reginfo");
7587 bfd_set_section_size (output_bfd
, ri
, sizeof (Elf32_External_RegInfo
));
7589 if (info
->relocateable
7590 || ! mips_elf_hash_table (info
)->mips16_stubs_seen
)
7593 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
7594 mips_elf_check_mips16_stubs
,
7600 /* Check the mips16 stubs for a particular symbol, and see if we can
7605 mips_elf_check_mips16_stubs (h
, data
)
7606 struct mips_elf_link_hash_entry
*h
;
7607 PTR data ATTRIBUTE_UNUSED
;
7609 if (h
->fn_stub
!= NULL
7610 && ! h
->need_fn_stub
)
7612 /* We don't need the fn_stub; the only references to this symbol
7613 are 16 bit calls. Clobber the size to 0 to prevent it from
7614 being included in the link. */
7615 h
->fn_stub
->_raw_size
= 0;
7616 h
->fn_stub
->_cooked_size
= 0;
7617 h
->fn_stub
->flags
&= ~ SEC_RELOC
;
7618 h
->fn_stub
->reloc_count
= 0;
7619 h
->fn_stub
->flags
|= SEC_EXCLUDE
;
7622 if (h
->call_stub
!= NULL
7623 && h
->root
.other
== STO_MIPS16
)
7625 /* We don't need the call_stub; this is a 16 bit function, so
7626 calls from other 16 bit functions are OK. Clobber the size
7627 to 0 to prevent it from being included in the link. */
7628 h
->call_stub
->_raw_size
= 0;
7629 h
->call_stub
->_cooked_size
= 0;
7630 h
->call_stub
->flags
&= ~ SEC_RELOC
;
7631 h
->call_stub
->reloc_count
= 0;
7632 h
->call_stub
->flags
|= SEC_EXCLUDE
;
7635 if (h
->call_fp_stub
!= NULL
7636 && h
->root
.other
== STO_MIPS16
)
7638 /* We don't need the call_stub; this is a 16 bit function, so
7639 calls from other 16 bit functions are OK. Clobber the size
7640 to 0 to prevent it from being included in the link. */
7641 h
->call_fp_stub
->_raw_size
= 0;
7642 h
->call_fp_stub
->_cooked_size
= 0;
7643 h
->call_fp_stub
->flags
&= ~ SEC_RELOC
;
7644 h
->call_fp_stub
->reloc_count
= 0;
7645 h
->call_fp_stub
->flags
|= SEC_EXCLUDE
;
7651 /* Set the sizes of the dynamic sections. */
7654 _bfd_mips_elf_size_dynamic_sections (output_bfd
, info
)
7656 struct bfd_link_info
*info
;
7661 struct mips_got_info
*g
;
7663 dynobj
= elf_hash_table (info
)->dynobj
;
7664 BFD_ASSERT (dynobj
!= NULL
);
7666 if (elf_hash_table (info
)->dynamic_sections_created
)
7668 /* Set the contents of the .interp section to the interpreter. */
7671 s
= bfd_get_section_by_name (dynobj
, ".interp");
7672 BFD_ASSERT (s
!= NULL
);
7674 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd
)) + 1;
7676 = (bfd_byte
*) ELF_DYNAMIC_INTERPRETER (output_bfd
);
7680 /* The check_relocs and adjust_dynamic_symbol entry points have
7681 determined the sizes of the various dynamic sections. Allocate
7684 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
7689 /* It's OK to base decisions on the section name, because none
7690 of the dynobj section names depend upon the input files. */
7691 name
= bfd_get_section_name (dynobj
, s
);
7693 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
7698 if (strncmp (name
, ".rel", 4) == 0)
7700 if (s
->_raw_size
== 0)
7702 /* We only strip the section if the output section name
7703 has the same name. Otherwise, there might be several
7704 input sections for this output section. FIXME: This
7705 code is probably not needed these days anyhow, since
7706 the linker now does not create empty output sections. */
7707 if (s
->output_section
!= NULL
7709 bfd_get_section_name (s
->output_section
->owner
,
7710 s
->output_section
)) == 0)
7715 const char *outname
;
7718 /* If this relocation section applies to a read only
7719 section, then we probably need a DT_TEXTREL entry.
7720 If the relocation section is .rel.dyn, we always
7721 assert a DT_TEXTREL entry rather than testing whether
7722 there exists a relocation to a read only section or
7724 outname
= bfd_get_section_name (output_bfd
,
7726 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
7728 && (target
->flags
& SEC_READONLY
) != 0
7729 && (target
->flags
& SEC_ALLOC
) != 0)
7731 MIPS_ELF_REL_DYN_SECTION_NAME (output_bfd
)) == 0)
7734 /* We use the reloc_count field as a counter if we need
7735 to copy relocs into the output file. */
7737 MIPS_ELF_REL_DYN_SECTION_NAME (output_bfd
)) != 0)
7741 else if (strncmp (name
, ".got", 4) == 0)
7744 bfd_size_type loadable_size
= 0;
7745 bfd_size_type local_gotno
;
7748 BFD_ASSERT (elf_section_data (s
) != NULL
);
7749 g
= (struct mips_got_info
*) elf_section_data (s
)->tdata
;
7750 BFD_ASSERT (g
!= NULL
);
7752 /* Calculate the total loadable size of the output. That
7753 will give us the maximum number of GOT_PAGE entries
7755 for (sub
= info
->input_bfds
; sub
; sub
= sub
->link_next
)
7757 asection
*subsection
;
7759 for (subsection
= sub
->sections
;
7761 subsection
= subsection
->next
)
7763 if ((subsection
->flags
& SEC_ALLOC
) == 0)
7765 loadable_size
+= (subsection
->_raw_size
+ 0xf) & ~0xf;
7768 loadable_size
+= MIPS_FUNCTION_STUB_SIZE
;
7770 /* Assume there are two loadable segments consisting of
7771 contiguous sections. Is 5 enough? */
7772 local_gotno
= (loadable_size
>> 16) + 5;
7773 g
->local_gotno
+= local_gotno
;
7774 s
->_raw_size
+= local_gotno
* MIPS_ELF_GOT_SIZE (dynobj
);
7776 /* There has to be a global GOT entry for every symbol with
7777 a dynamic symbol table index of DT_MIPS_GOTSYM or
7778 higher. Therefore, it make sense to put those symbols
7779 that need GOT entries at the end of the symbol table. We
7781 if (!mips_elf_sort_hash_table (info
, 1))
7784 i
= elf_hash_table (info
)->dynsymcount
- g
->global_gotsym
->dynindx
;
7785 g
->global_gotno
= i
;
7786 s
->_raw_size
+= i
* MIPS_ELF_GOT_SIZE (dynobj
);
7788 else if (strcmp (name
, MIPS_ELF_STUB_SECTION_NAME (output_bfd
)) == 0)
7790 /* Irix rld assumes that the function stub isn't at the end
7791 of .text section. So put a dummy. XXX */
7792 s
->_raw_size
+= MIPS_FUNCTION_STUB_SIZE
;
7794 else if (! info
->shared
7795 && ! mips_elf_hash_table (info
)->use_rld_obj_head
7796 && strncmp (name
, ".rld_map", 8) == 0)
7798 /* We add a room for __rld_map. It will be filled in by the
7799 rtld to contain a pointer to the _r_debug structure. */
7802 else if (SGI_COMPAT (output_bfd
)
7803 && strncmp (name
, ".compact_rel", 12) == 0)
7804 s
->_raw_size
+= mips_elf_hash_table (info
)->compact_rel_size
;
7805 else if (strcmp (name
, MIPS_ELF_MSYM_SECTION_NAME (output_bfd
))
7807 s
->_raw_size
= (sizeof (Elf32_External_Msym
)
7808 * (elf_hash_table (info
)->dynsymcount
7809 + bfd_count_sections (output_bfd
)));
7810 else if (strncmp (name
, ".init", 5) != 0)
7812 /* It's not one of our sections, so don't allocate space. */
7818 _bfd_strip_section_from_output (s
);
7822 /* Allocate memory for the section contents. */
7823 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
7824 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
7826 bfd_set_error (bfd_error_no_memory
);
7831 if (elf_hash_table (info
)->dynamic_sections_created
)
7833 /* Add some entries to the .dynamic section. We fill in the
7834 values later, in elf_mips_finish_dynamic_sections, but we
7835 must add the entries now so that we get the correct size for
7836 the .dynamic section. The DT_DEBUG entry is filled in by the
7837 dynamic linker and used by the debugger. */
7840 if (SGI_COMPAT (output_bfd
))
7842 /* SGI object has the equivalence of DT_DEBUG in the
7843 DT_MIPS_RLD_MAP entry. */
7844 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_MAP
, 0))
7848 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
7854 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_TEXTREL
, 0))
7858 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTGOT
, 0))
7861 if (bfd_get_section_by_name (dynobj
,
7862 MIPS_ELF_REL_DYN_SECTION_NAME (dynobj
)))
7864 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_REL
, 0))
7867 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELSZ
, 0))
7870 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELENT
, 0))
7874 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_CONFLICTNO
, 0))
7877 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LIBLISTNO
, 0))
7880 if (bfd_get_section_by_name (dynobj
, ".conflict") != NULL
)
7882 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_CONFLICT
, 0))
7885 s
= bfd_get_section_by_name (dynobj
, ".liblist");
7886 BFD_ASSERT (s
!= NULL
);
7888 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LIBLIST
, 0))
7892 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_VERSION
, 0))
7895 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_FLAGS
, 0))
7899 /* Time stamps in executable files are a bad idea. */
7900 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_TIME_STAMP
, 0))
7905 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_ICHECKSUM
, 0))
7910 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_IVERSION
, 0))
7914 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_BASE_ADDRESS
, 0))
7917 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LOCAL_GOTNO
, 0))
7920 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_SYMTABNO
, 0))
7923 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_UNREFEXTNO
, 0))
7926 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_GOTSYM
, 0))
7929 if (IRIX_COMPAT (dynobj
) == ict_irix5
7930 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_HIPAGENO
, 0))
7933 if (IRIX_COMPAT (dynobj
) == ict_irix6
7934 && (bfd_get_section_by_name
7935 (dynobj
, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj
)))
7936 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_OPTIONS
, 0))
7939 if (bfd_get_section_by_name (dynobj
,
7940 MIPS_ELF_MSYM_SECTION_NAME (dynobj
))
7941 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_MSYM
, 0))
7948 /* If NAME is one of the special IRIX6 symbols defined by the linker,
7949 adjust it appropriately now. */
7952 mips_elf_irix6_finish_dynamic_symbol (abfd
, name
, sym
)
7953 bfd
*abfd ATTRIBUTE_UNUSED
;
7955 Elf_Internal_Sym
*sym
;
7957 /* The linker script takes care of providing names and values for
7958 these, but we must place them into the right sections. */
7959 static const char* const text_section_symbols
[] = {
7962 "__dso_displacement",
7964 "__program_header_table",
7968 static const char* const data_section_symbols
[] = {
7976 const char* const *p
;
7979 for (i
= 0; i
< 2; ++i
)
7980 for (p
= (i
== 0) ? text_section_symbols
: data_section_symbols
;
7983 if (strcmp (*p
, name
) == 0)
7985 /* All of these symbols are given type STT_SECTION by the
7987 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
7989 /* The IRIX linker puts these symbols in special sections. */
7991 sym
->st_shndx
= SHN_MIPS_TEXT
;
7993 sym
->st_shndx
= SHN_MIPS_DATA
;
7999 /* Finish up dynamic symbol handling. We set the contents of various
8000 dynamic sections here. */
8003 _bfd_mips_elf_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
8005 struct bfd_link_info
*info
;
8006 struct elf_link_hash_entry
*h
;
8007 Elf_Internal_Sym
*sym
;
8013 struct mips_got_info
*g
;
8015 struct mips_elf_link_hash_entry
*mh
;
8017 dynobj
= elf_hash_table (info
)->dynobj
;
8018 gval
= sym
->st_value
;
8019 mh
= (struct mips_elf_link_hash_entry
*) h
;
8021 if (h
->plt
.offset
!= (bfd_vma
) -1)
8025 bfd_byte stub
[MIPS_FUNCTION_STUB_SIZE
];
8027 /* This symbol has a stub. Set it up. */
8029 BFD_ASSERT (h
->dynindx
!= -1);
8031 s
= bfd_get_section_by_name (dynobj
,
8032 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
8033 BFD_ASSERT (s
!= NULL
);
8035 /* Fill the stub. */
8037 bfd_put_32 (output_bfd
, STUB_LW(output_bfd
), p
);
8039 bfd_put_32 (output_bfd
, STUB_MOVE
, p
);
8042 /* FIXME: Can h->dynindex be more than 64K? */
8043 if (h
->dynindx
& 0xffff0000)
8046 bfd_put_32 (output_bfd
, STUB_JALR
, p
);
8048 bfd_put_32 (output_bfd
, STUB_LI16
+ h
->dynindx
, p
);
8050 BFD_ASSERT (h
->plt
.offset
<= s
->_raw_size
);
8051 memcpy (s
->contents
+ h
->plt
.offset
, stub
, MIPS_FUNCTION_STUB_SIZE
);
8053 /* Mark the symbol as undefined. plt.offset != -1 occurs
8054 only for the referenced symbol. */
8055 sym
->st_shndx
= SHN_UNDEF
;
8057 /* The run-time linker uses the st_value field of the symbol
8058 to reset the global offset table entry for this external
8059 to its stub address when unlinking a shared object. */
8060 gval
= s
->output_section
->vma
+ s
->output_offset
+ h
->plt
.offset
;
8061 sym
->st_value
= gval
;
8064 BFD_ASSERT (h
->dynindx
!= -1);
8066 sgot
= mips_elf_got_section (dynobj
);
8067 BFD_ASSERT (sgot
!= NULL
);
8068 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
8069 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
8070 BFD_ASSERT (g
!= NULL
);
8072 /* Run through the global symbol table, creating GOT entries for all
8073 the symbols that need them. */
8074 if (h
->dynindx
>= g
->global_gotsym
->dynindx
)
8080 value
= sym
->st_value
;
8082 /* For an entity defined in a shared object, this will be
8083 NULL. (For functions in shared objects for
8084 which we have created stubs, ST_VALUE will be non-NULL.
8085 That's because such the functions are now no longer defined
8086 in a shared object.) */
8087 value
= h
->root
.u
.def
.value
;
8089 offset
= mips_elf_global_got_index (dynobj
, h
);
8090 MIPS_ELF_PUT_WORD (output_bfd
, value
, sgot
->contents
+ offset
);
8093 /* Create a .msym entry, if appropriate. */
8094 smsym
= bfd_get_section_by_name (dynobj
,
8095 MIPS_ELF_MSYM_SECTION_NAME (dynobj
));
8098 Elf32_Internal_Msym msym
;
8100 msym
.ms_hash_value
= bfd_elf_hash (h
->root
.root
.string
);
8101 /* It is undocumented what the `1' indicates, but IRIX6 uses
8103 msym
.ms_info
= ELF32_MS_INFO (mh
->min_dyn_reloc_index
, 1);
8104 bfd_mips_elf_swap_msym_out
8106 ((Elf32_External_Msym
*) smsym
->contents
) + h
->dynindx
);
8109 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
8110 name
= h
->root
.root
.string
;
8111 if (strcmp (name
, "_DYNAMIC") == 0
8112 || strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
8113 sym
->st_shndx
= SHN_ABS
;
8114 else if (strcmp (name
, "_DYNAMIC_LINK") == 0)
8116 sym
->st_shndx
= SHN_ABS
;
8117 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8120 else if (SGI_COMPAT (output_bfd
))
8122 if (strcmp (name
, "_gp_disp") == 0)
8124 sym
->st_shndx
= SHN_ABS
;
8125 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8126 sym
->st_value
= elf_gp (output_bfd
);
8128 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
8129 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
8131 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8132 sym
->st_other
= STO_PROTECTED
;
8134 sym
->st_shndx
= SHN_MIPS_DATA
;
8136 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
8138 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8139 sym
->st_other
= STO_PROTECTED
;
8140 sym
->st_value
= mips_elf_hash_table (info
)->procedure_count
;
8141 sym
->st_shndx
= SHN_ABS
;
8143 else if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
!= SHN_ABS
)
8145 if (h
->type
== STT_FUNC
)
8146 sym
->st_shndx
= SHN_MIPS_TEXT
;
8147 else if (h
->type
== STT_OBJECT
)
8148 sym
->st_shndx
= SHN_MIPS_DATA
;
8152 /* Handle the IRIX6-specific symbols. */
8153 if (IRIX_COMPAT (output_bfd
) == ict_irix6
)
8154 mips_elf_irix6_finish_dynamic_symbol (output_bfd
, name
, sym
);
8156 if (SGI_COMPAT (output_bfd
)
8159 if (! mips_elf_hash_table (info
)->use_rld_obj_head
8160 && strcmp (name
, "__rld_map") == 0)
8162 asection
*s
= bfd_get_section_by_name (dynobj
, ".rld_map");
8163 BFD_ASSERT (s
!= NULL
);
8164 sym
->st_value
= s
->output_section
->vma
+ s
->output_offset
;
8165 bfd_put_32 (output_bfd
, (bfd_vma
) 0, s
->contents
);
8166 if (mips_elf_hash_table (info
)->rld_value
== 0)
8167 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
8169 else if (mips_elf_hash_table (info
)->use_rld_obj_head
8170 && strcmp (name
, "__rld_obj_head") == 0)
8172 /* IRIX6 does not use a .rld_map section. */
8173 if (IRIX_COMPAT (output_bfd
) == ict_irix5
)
8174 BFD_ASSERT (bfd_get_section_by_name (dynobj
, ".rld_map")
8176 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
8180 /* If this is a mips16 symbol, force the value to be even. */
8181 if (sym
->st_other
== STO_MIPS16
8182 && (sym
->st_value
& 1) != 0)
8188 /* Finish up the dynamic sections. */
8191 _bfd_mips_elf_finish_dynamic_sections (output_bfd
, info
)
8193 struct bfd_link_info
*info
;
8198 struct mips_got_info
*g
;
8200 dynobj
= elf_hash_table (info
)->dynobj
;
8202 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
8204 sgot
= mips_elf_got_section (dynobj
);
8209 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
8210 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
8211 BFD_ASSERT (g
!= NULL
);
8214 if (elf_hash_table (info
)->dynamic_sections_created
)
8218 BFD_ASSERT (sdyn
!= NULL
);
8219 BFD_ASSERT (g
!= NULL
);
8221 for (b
= sdyn
->contents
;
8222 b
< sdyn
->contents
+ sdyn
->_raw_size
;
8223 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
8225 Elf_Internal_Dyn dyn
;
8231 /* Read in the current dynamic entry. */
8232 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
8234 /* Assume that we're going to modify it and write it out. */
8240 s
= (bfd_get_section_by_name
8242 MIPS_ELF_REL_DYN_SECTION_NAME (dynobj
)));
8243 BFD_ASSERT (s
!= NULL
);
8244 dyn
.d_un
.d_val
= MIPS_ELF_REL_SIZE (dynobj
);
8248 /* Rewrite DT_STRSZ. */
8250 _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
8256 case DT_MIPS_CONFLICT
:
8259 case DT_MIPS_LIBLIST
:
8262 s
= bfd_get_section_by_name (output_bfd
, name
);
8263 BFD_ASSERT (s
!= NULL
);
8264 dyn
.d_un
.d_ptr
= s
->vma
;
8267 case DT_MIPS_RLD_VERSION
:
8268 dyn
.d_un
.d_val
= 1; /* XXX */
8272 dyn
.d_un
.d_val
= RHF_NOTPOT
; /* XXX */
8275 case DT_MIPS_CONFLICTNO
:
8277 elemsize
= sizeof (Elf32_Conflict
);
8280 case DT_MIPS_LIBLISTNO
:
8282 elemsize
= sizeof (Elf32_Lib
);
8284 s
= bfd_get_section_by_name (output_bfd
, name
);
8287 if (s
->_cooked_size
!= 0)
8288 dyn
.d_un
.d_val
= s
->_cooked_size
/ elemsize
;
8290 dyn
.d_un
.d_val
= s
->_raw_size
/ elemsize
;
8296 case DT_MIPS_TIME_STAMP
:
8297 time ((time_t *) &dyn
.d_un
.d_val
);
8300 case DT_MIPS_ICHECKSUM
:
8305 case DT_MIPS_IVERSION
:
8310 case DT_MIPS_BASE_ADDRESS
:
8311 s
= output_bfd
->sections
;
8312 BFD_ASSERT (s
!= NULL
);
8313 dyn
.d_un
.d_ptr
= s
->vma
& ~(0xffff);
8316 case DT_MIPS_LOCAL_GOTNO
:
8317 dyn
.d_un
.d_val
= g
->local_gotno
;
8320 case DT_MIPS_SYMTABNO
:
8322 elemsize
= MIPS_ELF_SYM_SIZE (output_bfd
);
8323 s
= bfd_get_section_by_name (output_bfd
, name
);
8324 BFD_ASSERT (s
!= NULL
);
8326 if (s
->_cooked_size
!= 0)
8327 dyn
.d_un
.d_val
= s
->_cooked_size
/ elemsize
;
8329 dyn
.d_un
.d_val
= s
->_raw_size
/ elemsize
;
8332 case DT_MIPS_UNREFEXTNO
:
8333 /* The index into the dynamic symbol table which is the
8334 entry of the first external symbol that is not
8335 referenced within the same object. */
8336 dyn
.d_un
.d_val
= bfd_count_sections (output_bfd
) + 1;
8339 case DT_MIPS_GOTSYM
:
8340 dyn
.d_un
.d_val
= g
->global_gotsym
->dynindx
;
8343 case DT_MIPS_HIPAGENO
:
8344 dyn
.d_un
.d_val
= g
->local_gotno
- MIPS_RESERVED_GOTNO
;
8347 case DT_MIPS_RLD_MAP
:
8348 dyn
.d_un
.d_ptr
= mips_elf_hash_table (info
)->rld_value
;
8351 case DT_MIPS_OPTIONS
:
8352 s
= (bfd_get_section_by_name
8353 (output_bfd
, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd
)));
8354 dyn
.d_un
.d_ptr
= s
->vma
;
8358 s
= (bfd_get_section_by_name
8359 (output_bfd
, MIPS_ELF_MSYM_SECTION_NAME (output_bfd
)));
8360 dyn
.d_un
.d_ptr
= s
->vma
;
8369 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
8374 /* The first entry of the global offset table will be filled at
8375 runtime. The second entry will be used by some runtime loaders.
8376 This isn't the case of Irix rld. */
8377 if (sgot
!= NULL
&& sgot
->_raw_size
> 0)
8379 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
8380 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0x80000000,
8381 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
8385 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
8386 = MIPS_ELF_GOT_SIZE (output_bfd
);
8391 Elf32_compact_rel cpt
;
8393 /* ??? The section symbols for the output sections were set up in
8394 _bfd_elf_final_link. SGI sets the STT_NOTYPE attribute for these
8395 symbols. Should we do so? */
8397 smsym
= bfd_get_section_by_name (dynobj
,
8398 MIPS_ELF_MSYM_SECTION_NAME (dynobj
));
8401 Elf32_Internal_Msym msym
;
8403 msym
.ms_hash_value
= 0;
8404 msym
.ms_info
= ELF32_MS_INFO (0, 1);
8406 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
8408 long dynindx
= elf_section_data (s
)->dynindx
;
8410 bfd_mips_elf_swap_msym_out
8412 (((Elf32_External_Msym
*) smsym
->contents
)
8417 if (SGI_COMPAT (output_bfd
))
8419 /* Write .compact_rel section out. */
8420 s
= bfd_get_section_by_name (dynobj
, ".compact_rel");
8424 cpt
.num
= s
->reloc_count
;
8426 cpt
.offset
= (s
->output_section
->filepos
8427 + sizeof (Elf32_External_compact_rel
));
8430 bfd_elf32_swap_compact_rel_out (output_bfd
, &cpt
,
8431 ((Elf32_External_compact_rel
*)
8434 /* Clean up a dummy stub function entry in .text. */
8435 s
= bfd_get_section_by_name (dynobj
,
8436 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
8439 file_ptr dummy_offset
;
8441 BFD_ASSERT (s
->_raw_size
>= MIPS_FUNCTION_STUB_SIZE
);
8442 dummy_offset
= s
->_raw_size
- MIPS_FUNCTION_STUB_SIZE
;
8443 memset (s
->contents
+ dummy_offset
, 0,
8444 MIPS_FUNCTION_STUB_SIZE
);
8449 /* Clean up a first relocation in .rel.dyn. */
8450 s
= bfd_get_section_by_name (dynobj
,
8451 MIPS_ELF_REL_DYN_SECTION_NAME (dynobj
));
8452 if (s
!= NULL
&& s
->_raw_size
> 0)
8453 memset (s
->contents
, 0, MIPS_ELF_REL_SIZE (dynobj
));
8459 /* This is almost identical to bfd_generic_get_... except that some
8460 MIPS relocations need to be handled specially. Sigh. */
8463 elf32_mips_get_relocated_section_contents (abfd
, link_info
, link_order
, data
,
8464 relocateable
, symbols
)
8466 struct bfd_link_info
*link_info
;
8467 struct bfd_link_order
*link_order
;
8469 boolean relocateable
;
8472 /* Get enough memory to hold the stuff */
8473 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
8474 asection
*input_section
= link_order
->u
.indirect
.section
;
8476 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
8477 arelent
**reloc_vector
= NULL
;
8483 reloc_vector
= (arelent
**) bfd_malloc (reloc_size
);
8484 if (reloc_vector
== NULL
&& reloc_size
!= 0)
8487 /* read in the section */
8488 if (!bfd_get_section_contents (input_bfd
,
8492 input_section
->_raw_size
))
8495 /* We're not relaxing the section, so just copy the size info */
8496 input_section
->_cooked_size
= input_section
->_raw_size
;
8497 input_section
->reloc_done
= true;
8499 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
8503 if (reloc_count
< 0)
8506 if (reloc_count
> 0)
8511 bfd_vma gp
= 0x12345678; /* initialize just to shut gcc up */
8514 struct bfd_hash_entry
*h
;
8515 struct bfd_link_hash_entry
*lh
;
8516 /* Skip all this stuff if we aren't mixing formats. */
8517 if (abfd
&& input_bfd
8518 && abfd
->xvec
== input_bfd
->xvec
)
8522 h
= bfd_hash_lookup (&link_info
->hash
->table
, "_gp", false, false);
8523 lh
= (struct bfd_link_hash_entry
*) h
;
8530 case bfd_link_hash_undefined
:
8531 case bfd_link_hash_undefweak
:
8532 case bfd_link_hash_common
:
8535 case bfd_link_hash_defined
:
8536 case bfd_link_hash_defweak
:
8538 gp
= lh
->u
.def
.value
;
8540 case bfd_link_hash_indirect
:
8541 case bfd_link_hash_warning
:
8543 /* @@FIXME ignoring warning for now */
8545 case bfd_link_hash_new
:
8554 for (parent
= reloc_vector
; *parent
!= (arelent
*) NULL
;
8557 char *error_message
= (char *) NULL
;
8558 bfd_reloc_status_type r
;
8560 /* Specific to MIPS: Deal with relocation types that require
8561 knowing the gp of the output bfd. */
8562 asymbol
*sym
= *(*parent
)->sym_ptr_ptr
;
8563 if (bfd_is_abs_section (sym
->section
) && abfd
)
8565 /* The special_function wouldn't get called anyways. */
8569 /* The gp isn't there; let the special function code
8570 fall over on its own. */
8572 else if ((*parent
)->howto
->special_function
8573 == _bfd_mips_elf_gprel16_reloc
)
8575 /* bypass special_function call */
8576 r
= gprel16_with_gp (input_bfd
, sym
, *parent
, input_section
,
8577 relocateable
, (PTR
) data
, gp
);
8578 goto skip_bfd_perform_relocation
;
8580 /* end mips specific stuff */
8582 r
= bfd_perform_relocation (input_bfd
,
8586 relocateable
? abfd
: (bfd
*) NULL
,
8588 skip_bfd_perform_relocation
:
8592 asection
*os
= input_section
->output_section
;
8594 /* A partial link, so keep the relocs */
8595 os
->orelocation
[os
->reloc_count
] = *parent
;
8599 if (r
!= bfd_reloc_ok
)
8603 case bfd_reloc_undefined
:
8604 if (!((*link_info
->callbacks
->undefined_symbol
)
8605 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
8606 input_bfd
, input_section
, (*parent
)->address
)))
8609 case bfd_reloc_dangerous
:
8610 BFD_ASSERT (error_message
!= (char *) NULL
);
8611 if (!((*link_info
->callbacks
->reloc_dangerous
)
8612 (link_info
, error_message
, input_bfd
, input_section
,
8613 (*parent
)->address
)))
8616 case bfd_reloc_overflow
:
8617 if (!((*link_info
->callbacks
->reloc_overflow
)
8618 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
8619 (*parent
)->howto
->name
, (*parent
)->addend
,
8620 input_bfd
, input_section
, (*parent
)->address
)))
8623 case bfd_reloc_outofrange
:
8632 if (reloc_vector
!= NULL
)
8633 free (reloc_vector
);
8637 if (reloc_vector
!= NULL
)
8638 free (reloc_vector
);
8641 #define bfd_elf32_bfd_get_relocated_section_contents \
8642 elf32_mips_get_relocated_section_contents
8644 /* ECOFF swapping routines. These are used when dealing with the
8645 .mdebug section, which is in the ECOFF debugging format. */
8646 static const struct ecoff_debug_swap mips_elf32_ecoff_debug_swap
=
8648 /* Symbol table magic number. */
8650 /* Alignment of debugging information. E.g., 4. */
8652 /* Sizes of external symbolic information. */
8653 sizeof (struct hdr_ext
),
8654 sizeof (struct dnr_ext
),
8655 sizeof (struct pdr_ext
),
8656 sizeof (struct sym_ext
),
8657 sizeof (struct opt_ext
),
8658 sizeof (struct fdr_ext
),
8659 sizeof (struct rfd_ext
),
8660 sizeof (struct ext_ext
),
8661 /* Functions to swap in external symbolic data. */
8670 _bfd_ecoff_swap_tir_in
,
8671 _bfd_ecoff_swap_rndx_in
,
8672 /* Functions to swap out external symbolic data. */
8681 _bfd_ecoff_swap_tir_out
,
8682 _bfd_ecoff_swap_rndx_out
,
8683 /* Function to read in symbolic data. */
8684 _bfd_mips_elf_read_ecoff_info
8687 #define TARGET_LITTLE_SYM bfd_elf32_littlemips_vec
8688 #define TARGET_LITTLE_NAME "elf32-littlemips"
8689 #define TARGET_BIG_SYM bfd_elf32_bigmips_vec
8690 #define TARGET_BIG_NAME "elf32-bigmips"
8691 #define ELF_ARCH bfd_arch_mips
8692 #define ELF_MACHINE_CODE EM_MIPS
8694 /* The SVR4 MIPS ABI says that this should be 0x10000, but Irix 5 uses
8695 a value of 0x1000, and we are compatible. */
8696 #define ELF_MAXPAGESIZE 0x1000
8698 #define elf_backend_collect true
8699 #define elf_backend_type_change_ok true
8700 #define elf_backend_can_gc_sections true
8701 #define elf_info_to_howto mips_info_to_howto_rela
8702 #define elf_info_to_howto_rel mips_info_to_howto_rel
8703 #define elf_backend_sym_is_global mips_elf_sym_is_global
8704 #define elf_backend_object_p _bfd_mips_elf_object_p
8705 #define elf_backend_section_from_shdr _bfd_mips_elf_section_from_shdr
8706 #define elf_backend_fake_sections _bfd_mips_elf_fake_sections
8707 #define elf_backend_section_from_bfd_section \
8708 _bfd_mips_elf_section_from_bfd_section
8709 #define elf_backend_section_processing _bfd_mips_elf_section_processing
8710 #define elf_backend_symbol_processing _bfd_mips_elf_symbol_processing
8711 #define elf_backend_additional_program_headers \
8712 _bfd_mips_elf_additional_program_headers
8713 #define elf_backend_modify_segment_map _bfd_mips_elf_modify_segment_map
8714 #define elf_backend_final_write_processing \
8715 _bfd_mips_elf_final_write_processing
8716 #define elf_backend_ecoff_debug_swap &mips_elf32_ecoff_debug_swap
8717 #define elf_backend_add_symbol_hook _bfd_mips_elf_add_symbol_hook
8718 #define elf_backend_create_dynamic_sections \
8719 _bfd_mips_elf_create_dynamic_sections
8720 #define elf_backend_check_relocs _bfd_mips_elf_check_relocs
8721 #define elf_backend_adjust_dynamic_symbol \
8722 _bfd_mips_elf_adjust_dynamic_symbol
8723 #define elf_backend_always_size_sections \
8724 _bfd_mips_elf_always_size_sections
8725 #define elf_backend_size_dynamic_sections \
8726 _bfd_mips_elf_size_dynamic_sections
8727 #define elf_backend_relocate_section _bfd_mips_elf_relocate_section
8728 #define elf_backend_link_output_symbol_hook \
8729 _bfd_mips_elf_link_output_symbol_hook
8730 #define elf_backend_finish_dynamic_symbol \
8731 _bfd_mips_elf_finish_dynamic_symbol
8732 #define elf_backend_finish_dynamic_sections \
8733 _bfd_mips_elf_finish_dynamic_sections
8734 #define elf_backend_gc_mark_hook _bfd_mips_elf_gc_mark_hook
8735 #define elf_backend_gc_sweep_hook _bfd_mips_elf_gc_sweep_hook
8737 #define elf_backend_got_header_size (4*MIPS_RESERVED_GOTNO)
8738 #define elf_backend_plt_header_size 0
8740 #define bfd_elf32_bfd_is_local_label_name \
8741 mips_elf_is_local_label_name
8742 #define bfd_elf32_find_nearest_line _bfd_mips_elf_find_nearest_line
8743 #define bfd_elf32_set_section_contents _bfd_mips_elf_set_section_contents
8744 #define bfd_elf32_bfd_link_hash_table_create \
8745 _bfd_mips_elf_link_hash_table_create
8746 #define bfd_elf32_bfd_final_link _bfd_mips_elf_final_link
8747 #define bfd_elf32_bfd_copy_private_bfd_data \
8748 _bfd_mips_elf_copy_private_bfd_data
8749 #define bfd_elf32_bfd_merge_private_bfd_data \
8750 _bfd_mips_elf_merge_private_bfd_data
8751 #define bfd_elf32_bfd_set_private_flags _bfd_mips_elf_set_private_flags
8752 #define bfd_elf32_bfd_print_private_bfd_data \
8753 _bfd_mips_elf_print_private_bfd_data
8754 #include "elf32-target.h"