1 /* MIPS-specific support for 32-bit ELF
2 Copyright 1993, 94, 95, 96, 97, 98, 99, 2000
3 Free Software Foundation, Inc.
5 Most of the information added by Ian Lance Taylor, Cygnus Support,
7 N32/64 ABI support added by Mark Mitchell, CodeSourcery, LLC.
8 <mark@codesourcery.com>
9 Traditional MIPS targets support added by Koundinya.K, Dansk Data
10 Elektronik & Operations Research Group. <kk@ddeorg.soft.net>
12 This file is part of BFD, the Binary File Descriptor library.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 2 of the License, or
17 (at your option) any later version.
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 /* This file handles MIPS ELF targets. SGI Irix 5 uses a slightly
29 different MIPS ELF from other targets. This matters when linking.
30 This file supports both, switching at runtime. */
40 /* Get the ECOFF swapping routines. */
42 #include "coff/symconst.h"
43 #include "coff/internal.h"
44 #include "coff/ecoff.h"
45 #include "coff/mips.h"
46 #define ECOFF_SIGNED_32
47 #include "ecoffswap.h"
49 /* This structure is used to hold .got information when linking. It
50 is stored in the tdata field of the bfd_elf_section_data structure. */
52 struct mips_got_info
{
53 /* The global symbol in the GOT with the lowest index in the dynamic
55 struct elf_link_hash_entry
*global_gotsym
;
56 /* The number of global .got entries. */
57 unsigned int global_gotno
;
58 /* The number of local .got entries. */
59 unsigned int local_gotno
;
60 /* The number of local .got entries we have used. */
61 unsigned int assigned_gotno
;
64 /* The MIPS ELF linker needs additional information for each symbol in
65 the global hash table. */
67 struct mips_elf_link_hash_entry
{
68 struct elf_link_hash_entry root
;
70 /* External symbol information. */
73 /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
75 unsigned int possibly_dynamic_relocs
;
77 /* The index of the first dynamic relocation (in the .rel.dyn
78 section) against this symbol. */
79 unsigned int min_dyn_reloc_index
;
81 /* If there is a stub that 32 bit functions should use to call this
82 16 bit function, this points to the section containing the stub. */
85 /* Whether we need the fn_stub; this is set if this symbol appears
86 in any relocs other than a 16 bit call. */
89 /* If there is a stub that 16 bit functions should use to call this
90 32 bit function, this points to the section containing the stub. */
93 /* This is like the call_stub field, but it is used if the function
94 being called returns a floating point value. */
95 asection
*call_fp_stub
;
98 static bfd_reloc_status_type mips32_64bit_reloc
99 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
100 static reloc_howto_type
*bfd_elf32_bfd_reloc_type_lookup
101 PARAMS ((bfd
*, bfd_reloc_code_real_type
));
102 static reloc_howto_type
*mips_rtype_to_howto
103 PARAMS ((unsigned int));
104 static void mips_info_to_howto_rel
105 PARAMS ((bfd
*, arelent
*, Elf32_Internal_Rel
*));
106 static void mips_info_to_howto_rela
107 PARAMS ((bfd
*, arelent
*, Elf32_Internal_Rela
*));
108 static void bfd_mips_elf32_swap_gptab_in
109 PARAMS ((bfd
*, const Elf32_External_gptab
*, Elf32_gptab
*));
110 static void bfd_mips_elf32_swap_gptab_out
111 PARAMS ((bfd
*, const Elf32_gptab
*, Elf32_External_gptab
*));
113 static void bfd_mips_elf_swap_msym_in
114 PARAMS ((bfd
*, const Elf32_External_Msym
*, Elf32_Internal_Msym
*));
116 static void bfd_mips_elf_swap_msym_out
117 PARAMS ((bfd
*, const Elf32_Internal_Msym
*, Elf32_External_Msym
*));
118 static boolean mips_elf_sym_is_global
PARAMS ((bfd
*, asymbol
*));
119 static boolean mips_elf_create_procedure_table
120 PARAMS ((PTR
, bfd
*, struct bfd_link_info
*, asection
*,
121 struct ecoff_debug_info
*));
122 static INLINE
int elf_mips_isa
PARAMS ((flagword
));
123 static INLINE
int elf_mips_mach
PARAMS ((flagword
));
124 static INLINE
char* elf_mips_abi_name
PARAMS ((bfd
*));
125 static boolean mips_elf_is_local_label_name
126 PARAMS ((bfd
*, const char *));
127 static struct bfd_hash_entry
*mips_elf_link_hash_newfunc
128 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
129 static int gptab_compare
PARAMS ((const void *, const void *));
130 static bfd_reloc_status_type mips16_jump_reloc
131 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
132 static bfd_reloc_status_type mips16_gprel_reloc
133 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
134 static boolean mips_elf_create_compact_rel_section
135 PARAMS ((bfd
*, struct bfd_link_info
*));
136 static boolean mips_elf_create_got_section
137 PARAMS ((bfd
*, struct bfd_link_info
*));
138 static bfd_reloc_status_type mips_elf_final_gp
139 PARAMS ((bfd
*, asymbol
*, boolean
, char **, bfd_vma
*));
140 static bfd_byte
*elf32_mips_get_relocated_section_contents
141 PARAMS ((bfd
*, struct bfd_link_info
*, struct bfd_link_order
*,
142 bfd_byte
*, boolean
, asymbol
**));
143 static asection
*mips_elf_create_msym_section
145 static void mips_elf_irix6_finish_dynamic_symbol
146 PARAMS ((bfd
*, const char *, Elf_Internal_Sym
*));
147 static bfd_vma mips_elf_sign_extend
PARAMS ((bfd_vma
, int));
148 static boolean mips_elf_overflow_p
PARAMS ((bfd_vma
, int));
149 static bfd_vma mips_elf_high
PARAMS ((bfd_vma
));
150 static bfd_vma mips_elf_higher
PARAMS ((bfd_vma
));
151 static bfd_vma mips_elf_highest
PARAMS ((bfd_vma
));
152 static bfd_vma mips_elf_global_got_index
153 PARAMS ((bfd
*, struct elf_link_hash_entry
*));
154 static bfd_vma mips_elf_local_got_index
155 PARAMS ((bfd
*, struct bfd_link_info
*, bfd_vma
));
156 static bfd_vma mips_elf_got_offset_from_index
157 PARAMS ((bfd
*, bfd
*, bfd_vma
));
158 static boolean mips_elf_record_global_got_symbol
159 PARAMS ((struct elf_link_hash_entry
*, struct bfd_link_info
*,
160 struct mips_got_info
*));
161 static bfd_vma mips_elf_got_page
162 PARAMS ((bfd
*, struct bfd_link_info
*, bfd_vma
, bfd_vma
*));
163 static const Elf_Internal_Rela
*mips_elf_next_relocation
164 PARAMS ((unsigned int, const Elf_Internal_Rela
*,
165 const Elf_Internal_Rela
*));
166 static bfd_reloc_status_type mips_elf_calculate_relocation
167 PARAMS ((bfd
*, bfd
*, asection
*, struct bfd_link_info
*,
168 const Elf_Internal_Rela
*, bfd_vma
, reloc_howto_type
*,
169 Elf_Internal_Sym
*, asection
**, bfd_vma
*, const char **,
171 static bfd_vma mips_elf_obtain_contents
172 PARAMS ((reloc_howto_type
*, const Elf_Internal_Rela
*, bfd
*, bfd_byte
*));
173 static boolean mips_elf_perform_relocation
174 PARAMS ((struct bfd_link_info
*, reloc_howto_type
*,
175 const Elf_Internal_Rela
*, bfd_vma
,
176 bfd
*, asection
*, bfd_byte
*, boolean
));
177 static boolean mips_elf_assign_gp
PARAMS ((bfd
*, bfd_vma
*));
178 static boolean mips_elf_sort_hash_table_f
179 PARAMS ((struct mips_elf_link_hash_entry
*, PTR
));
180 static boolean mips_elf_sort_hash_table
181 PARAMS ((struct bfd_link_info
*, unsigned long));
182 static asection
* mips_elf_got_section
PARAMS ((bfd
*));
183 static struct mips_got_info
*mips_elf_got_info
184 PARAMS ((bfd
*, asection
**));
185 static boolean mips_elf_local_relocation_p
186 PARAMS ((bfd
*, const Elf_Internal_Rela
*, asection
**, boolean
));
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
, boolean
));
191 static boolean mips_elf_create_dynamic_relocation
192 PARAMS ((bfd
*, struct bfd_link_info
*, const Elf_Internal_Rela
*,
193 struct mips_elf_link_hash_entry
*, asection
*,
194 bfd_vma
, bfd_vma
*, asection
*, boolean local_p
));
195 static void mips_elf_allocate_dynamic_relocations
196 PARAMS ((bfd
*, unsigned int));
197 static boolean mips_elf_stub_section_p
198 PARAMS ((bfd
*, asection
*));
199 static int sort_dynamic_relocs
200 PARAMS ((const void *, const void *));
202 extern const bfd_target bfd_elf32_tradbigmips_vec
;
204 /* The level of IRIX compatibility we're striving for. */
212 /* This will be used when we sort the dynamic relocation records. */
213 static bfd
*reldyn_sorting_bfd
;
215 /* Nonzero if ABFD is using the N32 ABI. */
217 #define ABI_N32_P(abfd) \
218 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
220 /* Nonzero if ABFD is using the 64-bit ABI. FIXME: This is never
222 #define ABI_64_P(abfd) \
223 ((elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64) != 0)
225 /* Depending on the target vector we generate some version of Irix
226 executables or "normal" MIPS ELF ABI executables. */
228 #define IRIX_COMPAT(abfd) \
229 (abfd->xvec == &bfd_elf32_tradbigmips_vec ? ict_none : \
230 ((ABI_N32_P (abfd) || ABI_64_P (abfd)) ? ict_irix6 : ict_irix5))
232 /* Whether we are trying to be compatible with IRIX at all. */
234 #define SGI_COMPAT(abfd) \
235 (IRIX_COMPAT (abfd) != ict_none)
237 /* The name of the msym section. */
238 #define MIPS_ELF_MSYM_SECTION_NAME(abfd) ".msym"
240 /* The name of the srdata section. */
241 #define MIPS_ELF_SRDATA_SECTION_NAME(abfd) ".srdata"
243 /* The name of the options section. */
244 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
245 (IRIX_COMPAT (abfd) == ict_irix6 ? ".MIPS.options" : ".options")
247 /* The name of the stub section. */
248 #define MIPS_ELF_STUB_SECTION_NAME(abfd) \
249 (IRIX_COMPAT (abfd) == ict_irix6 ? ".MIPS.stubs" : ".stub")
251 /* The name of the dynamic relocation section. */
252 #define MIPS_ELF_REL_DYN_SECTION_NAME(abfd) ".rel.dyn"
254 /* The size of an external REL relocation. */
255 #define MIPS_ELF_REL_SIZE(abfd) \
256 (get_elf_backend_data (abfd)->s->sizeof_rel)
258 /* The size of an external dynamic table entry. */
259 #define MIPS_ELF_DYN_SIZE(abfd) \
260 (get_elf_backend_data (abfd)->s->sizeof_dyn)
262 /* The size of a GOT entry. */
263 #define MIPS_ELF_GOT_SIZE(abfd) \
264 (get_elf_backend_data (abfd)->s->arch_size / 8)
266 /* The size of a symbol-table entry. */
267 #define MIPS_ELF_SYM_SIZE(abfd) \
268 (get_elf_backend_data (abfd)->s->sizeof_sym)
270 /* The default alignment for sections, as a power of two. */
271 #define MIPS_ELF_LOG_FILE_ALIGN(abfd) \
272 (get_elf_backend_data (abfd)->s->file_align == 8 ? 3 : 2)
274 /* Get word-sized data. */
275 #define MIPS_ELF_GET_WORD(abfd, ptr) \
276 (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
278 /* Put out word-sized data. */
279 #define MIPS_ELF_PUT_WORD(abfd, val, ptr) \
281 ? bfd_put_64 (abfd, val, ptr) \
282 : bfd_put_32 (abfd, val, ptr))
284 /* Add a dynamic symbol table-entry. */
286 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
287 (ABI_64_P (elf_hash_table (info)->dynobj) \
288 ? bfd_elf64_add_dynamic_entry (info, tag, val) \
289 : bfd_elf32_add_dynamic_entry (info, tag, val))
291 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
292 (ABI_64_P (elf_hash_table (info)->dynobj) \
293 ? (abort (), false) \
294 : bfd_elf32_add_dynamic_entry (info, tag, val))
297 /* The number of local .got entries we reserve. */
298 #define MIPS_RESERVED_GOTNO (2)
300 /* Instructions which appear in a stub. For some reason the stub is
301 slightly different on an SGI system. */
302 #define ELF_MIPS_GP_OFFSET(abfd) (SGI_COMPAT (abfd) ? 0x7ff0 : 0x8000)
303 #define STUB_LW(abfd) \
306 ? 0xdf998010 /* ld t9,0x8010(gp) */ \
307 : 0x8f998010) /* lw t9,0x8010(gp) */ \
308 : 0x8f998010) /* lw t9,0x8000(gp) */
309 #define STUB_MOVE(abfd) \
310 (SGI_COMPAT (abfd) ? 0x03e07825 : 0x03e07821) /* move t7,ra */
311 #define STUB_JALR 0x0320f809 /* jal t9 */
312 #define STUB_LI16(abfd) \
313 (SGI_COMPAT (abfd) ? 0x34180000 : 0x24180000) /* ori t8,zero,0 */
314 #define MIPS_FUNCTION_STUB_SIZE (16)
317 /* We no longer try to identify particular sections for the .dynsym
318 section. When we do, we wind up crashing if there are other random
319 sections with relocations. */
321 /* Names of sections which appear in the .dynsym section in an Irix 5
324 static const char * const mips_elf_dynsym_sec_names
[] = {
336 #define SIZEOF_MIPS_DYNSYM_SECNAMES \
337 (sizeof mips_elf_dynsym_sec_names / sizeof mips_elf_dynsym_sec_names[0])
339 /* The number of entries in mips_elf_dynsym_sec_names which go in the
342 #define MIPS_TEXT_DYNSYM_SECNO (3)
346 /* The names of the runtime procedure table symbols used on Irix 5. */
348 static const char * const mips_elf_dynsym_rtproc_names
[] = {
350 "_procedure_string_table",
351 "_procedure_table_size",
355 /* These structures are used to generate the .compact_rel section on
359 unsigned long id1
; /* Always one? */
360 unsigned long num
; /* Number of compact relocation entries. */
361 unsigned long id2
; /* Always two? */
362 unsigned long offset
; /* The file offset of the first relocation. */
363 unsigned long reserved0
; /* Zero? */
364 unsigned long reserved1
; /* Zero? */
372 bfd_byte reserved0
[4];
373 bfd_byte reserved1
[4];
374 } Elf32_External_compact_rel
;
377 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
378 unsigned int rtype
: 4; /* Relocation types. See below. */
379 unsigned int dist2to
: 8;
380 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
381 unsigned long konst
; /* KONST field. See below. */
382 unsigned long vaddr
; /* VADDR to be relocated. */
386 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
387 unsigned int rtype
: 4; /* Relocation types. See below. */
388 unsigned int dist2to
: 8;
389 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
390 unsigned long konst
; /* KONST field. See below. */
397 } Elf32_External_crinfo
;
402 } Elf32_External_crinfo2
;
404 /* These are the constants used to swap the bitfields in a crinfo. */
406 #define CRINFO_CTYPE (0x1)
407 #define CRINFO_CTYPE_SH (31)
408 #define CRINFO_RTYPE (0xf)
409 #define CRINFO_RTYPE_SH (27)
410 #define CRINFO_DIST2TO (0xff)
411 #define CRINFO_DIST2TO_SH (19)
412 #define CRINFO_RELVADDR (0x7ffff)
413 #define CRINFO_RELVADDR_SH (0)
415 /* A compact relocation info has long (3 words) or short (2 words)
416 formats. A short format doesn't have VADDR field and relvaddr
417 fields contains ((VADDR - vaddr of the previous entry) >> 2). */
418 #define CRF_MIPS_LONG 1
419 #define CRF_MIPS_SHORT 0
421 /* There are 4 types of compact relocation at least. The value KONST
422 has different meaning for each type:
425 CT_MIPS_REL32 Address in data
426 CT_MIPS_WORD Address in word (XXX)
427 CT_MIPS_GPHI_LO GP - vaddr
428 CT_MIPS_JMPAD Address to jump
431 #define CRT_MIPS_REL32 0xa
432 #define CRT_MIPS_WORD 0xb
433 #define CRT_MIPS_GPHI_LO 0xc
434 #define CRT_MIPS_JMPAD 0xd
436 #define mips_elf_set_cr_format(x,format) ((x).ctype = (format))
437 #define mips_elf_set_cr_type(x,type) ((x).rtype = (type))
438 #define mips_elf_set_cr_dist2to(x,v) ((x).dist2to = (v))
439 #define mips_elf_set_cr_relvaddr(x,d) ((x).relvaddr = (d)<<2)
441 static void bfd_elf32_swap_compact_rel_out
442 PARAMS ((bfd
*, const Elf32_compact_rel
*, Elf32_External_compact_rel
*));
443 static void bfd_elf32_swap_crinfo_out
444 PARAMS ((bfd
*, const Elf32_crinfo
*, Elf32_External_crinfo
*));
446 #define USE_REL 1 /* MIPS uses REL relocations instead of RELA */
448 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
449 from smaller values. Start with zero, widen, *then* decrement. */
450 #define MINUS_ONE (((bfd_vma)0) - 1)
452 static reloc_howto_type elf_mips_howto_table
[] = {
454 HOWTO (R_MIPS_NONE
, /* type */
456 0, /* size (0 = byte, 1 = short, 2 = long) */
458 false, /* pc_relative */
460 complain_overflow_dont
, /* complain_on_overflow */
461 bfd_elf_generic_reloc
, /* special_function */
462 "R_MIPS_NONE", /* name */
463 false, /* partial_inplace */
466 false), /* pcrel_offset */
468 /* 16 bit relocation. */
469 HOWTO (R_MIPS_16
, /* type */
471 1, /* size (0 = byte, 1 = short, 2 = long) */
473 false, /* pc_relative */
475 complain_overflow_bitfield
, /* complain_on_overflow */
476 bfd_elf_generic_reloc
, /* special_function */
477 "R_MIPS_16", /* name */
478 true, /* partial_inplace */
479 0xffff, /* src_mask */
480 0xffff, /* dst_mask */
481 false), /* pcrel_offset */
483 /* 32 bit relocation. */
484 HOWTO (R_MIPS_32
, /* type */
486 2, /* size (0 = byte, 1 = short, 2 = long) */
488 false, /* pc_relative */
490 complain_overflow_bitfield
, /* complain_on_overflow */
491 bfd_elf_generic_reloc
, /* special_function */
492 "R_MIPS_32", /* name */
493 true, /* partial_inplace */
494 0xffffffff, /* src_mask */
495 0xffffffff, /* dst_mask */
496 false), /* pcrel_offset */
498 /* 32 bit symbol relative relocation. */
499 HOWTO (R_MIPS_REL32
, /* type */
501 2, /* size (0 = byte, 1 = short, 2 = long) */
503 false, /* pc_relative */
505 complain_overflow_bitfield
, /* complain_on_overflow */
506 bfd_elf_generic_reloc
, /* special_function */
507 "R_MIPS_REL32", /* name */
508 true, /* partial_inplace */
509 0xffffffff, /* src_mask */
510 0xffffffff, /* dst_mask */
511 false), /* pcrel_offset */
513 /* 26 bit branch address. */
514 HOWTO (R_MIPS_26
, /* type */
516 2, /* size (0 = byte, 1 = short, 2 = long) */
518 false, /* pc_relative */
520 complain_overflow_dont
, /* complain_on_overflow */
521 /* This needs complex overflow
522 detection, because the upper four
523 bits must match the PC. */
524 bfd_elf_generic_reloc
, /* special_function */
525 "R_MIPS_26", /* name */
526 true, /* partial_inplace */
527 0x3ffffff, /* src_mask */
528 0x3ffffff, /* dst_mask */
529 false), /* pcrel_offset */
531 /* High 16 bits of symbol value. */
532 HOWTO (R_MIPS_HI16
, /* type */
534 2, /* size (0 = byte, 1 = short, 2 = long) */
536 false, /* pc_relative */
538 complain_overflow_dont
, /* complain_on_overflow */
539 _bfd_mips_elf_hi16_reloc
, /* special_function */
540 "R_MIPS_HI16", /* name */
541 true, /* partial_inplace */
542 0xffff, /* src_mask */
543 0xffff, /* dst_mask */
544 false), /* pcrel_offset */
546 /* Low 16 bits of symbol value. */
547 HOWTO (R_MIPS_LO16
, /* type */
549 2, /* size (0 = byte, 1 = short, 2 = long) */
551 false, /* pc_relative */
553 complain_overflow_dont
, /* complain_on_overflow */
554 _bfd_mips_elf_lo16_reloc
, /* special_function */
555 "R_MIPS_LO16", /* name */
556 true, /* partial_inplace */
557 0xffff, /* src_mask */
558 0xffff, /* dst_mask */
559 false), /* pcrel_offset */
561 /* GP relative reference. */
562 HOWTO (R_MIPS_GPREL16
, /* type */
564 2, /* size (0 = byte, 1 = short, 2 = long) */
566 false, /* pc_relative */
568 complain_overflow_signed
, /* complain_on_overflow */
569 _bfd_mips_elf_gprel16_reloc
, /* special_function */
570 "R_MIPS_GPREL16", /* name */
571 true, /* partial_inplace */
572 0xffff, /* src_mask */
573 0xffff, /* dst_mask */
574 false), /* pcrel_offset */
576 /* Reference to literal section. */
577 HOWTO (R_MIPS_LITERAL
, /* type */
579 2, /* size (0 = byte, 1 = short, 2 = long) */
581 false, /* pc_relative */
583 complain_overflow_signed
, /* complain_on_overflow */
584 _bfd_mips_elf_gprel16_reloc
, /* special_function */
585 "R_MIPS_LITERAL", /* name */
586 true, /* partial_inplace */
587 0xffff, /* src_mask */
588 0xffff, /* dst_mask */
589 false), /* pcrel_offset */
591 /* Reference to global offset table. */
592 HOWTO (R_MIPS_GOT16
, /* type */
594 2, /* size (0 = byte, 1 = short, 2 = long) */
596 false, /* pc_relative */
598 complain_overflow_signed
, /* complain_on_overflow */
599 _bfd_mips_elf_got16_reloc
, /* special_function */
600 "R_MIPS_GOT16", /* name */
601 false, /* partial_inplace */
602 0xffff, /* src_mask */
603 0xffff, /* dst_mask */
604 false), /* pcrel_offset */
606 /* 16 bit PC relative reference. */
607 HOWTO (R_MIPS_PC16
, /* type */
609 2, /* size (0 = byte, 1 = short, 2 = long) */
611 true, /* pc_relative */
613 complain_overflow_signed
, /* complain_on_overflow */
614 bfd_elf_generic_reloc
, /* special_function */
615 "R_MIPS_PC16", /* name */
616 true, /* partial_inplace */
617 0xffff, /* src_mask */
618 0xffff, /* dst_mask */
619 true), /* pcrel_offset */
621 /* 16 bit call through global offset table. */
622 HOWTO (R_MIPS_CALL16
, /* type */
624 2, /* size (0 = byte, 1 = short, 2 = long) */
626 false, /* pc_relative */
628 complain_overflow_signed
, /* complain_on_overflow */
629 bfd_elf_generic_reloc
, /* special_function */
630 "R_MIPS_CALL16", /* name */
631 false, /* partial_inplace */
632 0xffff, /* src_mask */
633 0xffff, /* dst_mask */
634 false), /* pcrel_offset */
636 /* 32 bit GP relative reference. */
637 HOWTO (R_MIPS_GPREL32
, /* type */
639 2, /* size (0 = byte, 1 = short, 2 = long) */
641 false, /* pc_relative */
643 complain_overflow_bitfield
, /* complain_on_overflow */
644 _bfd_mips_elf_gprel32_reloc
, /* special_function */
645 "R_MIPS_GPREL32", /* name */
646 true, /* partial_inplace */
647 0xffffffff, /* src_mask */
648 0xffffffff, /* dst_mask */
649 false), /* pcrel_offset */
651 /* The remaining relocs are defined on Irix 5, although they are
652 not defined by the ABI. */
657 /* A 5 bit shift field. */
658 HOWTO (R_MIPS_SHIFT5
, /* type */
660 2, /* size (0 = byte, 1 = short, 2 = long) */
662 false, /* pc_relative */
664 complain_overflow_bitfield
, /* complain_on_overflow */
665 bfd_elf_generic_reloc
, /* special_function */
666 "R_MIPS_SHIFT5", /* name */
667 true, /* partial_inplace */
668 0x000007c0, /* src_mask */
669 0x000007c0, /* dst_mask */
670 false), /* pcrel_offset */
672 /* A 6 bit shift field. */
673 /* FIXME: This is not handled correctly; a special function is
674 needed to put the most significant bit in the right place. */
675 HOWTO (R_MIPS_SHIFT6
, /* type */
677 2, /* size (0 = byte, 1 = short, 2 = long) */
679 false, /* pc_relative */
681 complain_overflow_bitfield
, /* complain_on_overflow */
682 bfd_elf_generic_reloc
, /* special_function */
683 "R_MIPS_SHIFT6", /* name */
684 true, /* partial_inplace */
685 0x000007c4, /* src_mask */
686 0x000007c4, /* dst_mask */
687 false), /* pcrel_offset */
689 /* A 64 bit relocation. */
690 HOWTO (R_MIPS_64
, /* type */
692 4, /* size (0 = byte, 1 = short, 2 = long) */
694 false, /* pc_relative */
696 complain_overflow_bitfield
, /* complain_on_overflow */
697 mips32_64bit_reloc
, /* special_function */
698 "R_MIPS_64", /* name */
699 true, /* partial_inplace */
700 MINUS_ONE
, /* src_mask */
701 MINUS_ONE
, /* dst_mask */
702 false), /* pcrel_offset */
704 /* Displacement in the global offset table. */
705 HOWTO (R_MIPS_GOT_DISP
, /* type */
707 2, /* size (0 = byte, 1 = short, 2 = long) */
709 false, /* pc_relative */
711 complain_overflow_bitfield
, /* complain_on_overflow */
712 bfd_elf_generic_reloc
, /* special_function */
713 "R_MIPS_GOT_DISP", /* name */
714 true, /* partial_inplace */
715 0x0000ffff, /* src_mask */
716 0x0000ffff, /* dst_mask */
717 false), /* pcrel_offset */
719 /* Displacement to page pointer in the global offset table. */
720 HOWTO (R_MIPS_GOT_PAGE
, /* type */
722 2, /* size (0 = byte, 1 = short, 2 = long) */
724 false, /* pc_relative */
726 complain_overflow_bitfield
, /* complain_on_overflow */
727 bfd_elf_generic_reloc
, /* special_function */
728 "R_MIPS_GOT_PAGE", /* name */
729 true, /* partial_inplace */
730 0x0000ffff, /* src_mask */
731 0x0000ffff, /* dst_mask */
732 false), /* pcrel_offset */
734 /* Offset from page pointer in the global offset table. */
735 HOWTO (R_MIPS_GOT_OFST
, /* type */
737 2, /* size (0 = byte, 1 = short, 2 = long) */
739 false, /* pc_relative */
741 complain_overflow_bitfield
, /* complain_on_overflow */
742 bfd_elf_generic_reloc
, /* special_function */
743 "R_MIPS_GOT_OFST", /* name */
744 true, /* partial_inplace */
745 0x0000ffff, /* src_mask */
746 0x0000ffff, /* dst_mask */
747 false), /* pcrel_offset */
749 /* High 16 bits of displacement in global offset table. */
750 HOWTO (R_MIPS_GOT_HI16
, /* type */
752 2, /* size (0 = byte, 1 = short, 2 = long) */
754 false, /* pc_relative */
756 complain_overflow_dont
, /* complain_on_overflow */
757 bfd_elf_generic_reloc
, /* special_function */
758 "R_MIPS_GOT_HI16", /* name */
759 true, /* partial_inplace */
760 0x0000ffff, /* src_mask */
761 0x0000ffff, /* dst_mask */
762 false), /* pcrel_offset */
764 /* Low 16 bits of displacement in global offset table. */
765 HOWTO (R_MIPS_GOT_LO16
, /* type */
767 2, /* size (0 = byte, 1 = short, 2 = long) */
769 false, /* pc_relative */
771 complain_overflow_dont
, /* complain_on_overflow */
772 bfd_elf_generic_reloc
, /* special_function */
773 "R_MIPS_GOT_LO16", /* name */
774 true, /* partial_inplace */
775 0x0000ffff, /* src_mask */
776 0x0000ffff, /* dst_mask */
777 false), /* pcrel_offset */
779 /* 64 bit subtraction. Used in the N32 ABI. */
780 HOWTO (R_MIPS_SUB
, /* type */
782 4, /* size (0 = byte, 1 = short, 2 = long) */
784 false, /* pc_relative */
786 complain_overflow_bitfield
, /* complain_on_overflow */
787 bfd_elf_generic_reloc
, /* special_function */
788 "R_MIPS_SUB", /* name */
789 true, /* partial_inplace */
790 MINUS_ONE
, /* src_mask */
791 MINUS_ONE
, /* dst_mask */
792 false), /* pcrel_offset */
794 /* Used to cause the linker to insert and delete instructions? */
795 EMPTY_HOWTO (R_MIPS_INSERT_A
),
796 EMPTY_HOWTO (R_MIPS_INSERT_B
),
797 EMPTY_HOWTO (R_MIPS_DELETE
),
799 /* Get the higher value of a 64 bit addend. */
800 HOWTO (R_MIPS_HIGHER
, /* type */
802 2, /* size (0 = byte, 1 = short, 2 = long) */
804 false, /* pc_relative */
806 complain_overflow_dont
, /* complain_on_overflow */
807 bfd_elf_generic_reloc
, /* special_function */
808 "R_MIPS_HIGHER", /* name */
809 true, /* partial_inplace */
811 0xffff, /* dst_mask */
812 false), /* pcrel_offset */
814 /* Get the highest value of a 64 bit addend. */
815 HOWTO (R_MIPS_HIGHEST
, /* type */
817 2, /* size (0 = byte, 1 = short, 2 = long) */
819 false, /* pc_relative */
821 complain_overflow_dont
, /* complain_on_overflow */
822 bfd_elf_generic_reloc
, /* special_function */
823 "R_MIPS_HIGHEST", /* name */
824 true, /* partial_inplace */
826 0xffff, /* dst_mask */
827 false), /* pcrel_offset */
829 /* High 16 bits of displacement in global offset table. */
830 HOWTO (R_MIPS_CALL_HI16
, /* type */
832 2, /* size (0 = byte, 1 = short, 2 = long) */
834 false, /* pc_relative */
836 complain_overflow_dont
, /* complain_on_overflow */
837 bfd_elf_generic_reloc
, /* special_function */
838 "R_MIPS_CALL_HI16", /* name */
839 true, /* partial_inplace */
840 0x0000ffff, /* src_mask */
841 0x0000ffff, /* dst_mask */
842 false), /* pcrel_offset */
844 /* Low 16 bits of displacement in global offset table. */
845 HOWTO (R_MIPS_CALL_LO16
, /* type */
847 2, /* size (0 = byte, 1 = short, 2 = long) */
849 false, /* pc_relative */
851 complain_overflow_dont
, /* complain_on_overflow */
852 bfd_elf_generic_reloc
, /* special_function */
853 "R_MIPS_CALL_LO16", /* name */
854 true, /* partial_inplace */
855 0x0000ffff, /* src_mask */
856 0x0000ffff, /* dst_mask */
857 false), /* pcrel_offset */
859 /* Section displacement. */
860 HOWTO (R_MIPS_SCN_DISP
, /* type */
862 2, /* size (0 = byte, 1 = short, 2 = long) */
864 false, /* pc_relative */
866 complain_overflow_dont
, /* complain_on_overflow */
867 bfd_elf_generic_reloc
, /* special_function */
868 "R_MIPS_SCN_DISP", /* name */
869 false, /* partial_inplace */
870 0xffffffff, /* src_mask */
871 0xffffffff, /* dst_mask */
872 false), /* pcrel_offset */
874 EMPTY_HOWTO (R_MIPS_REL16
),
875 EMPTY_HOWTO (R_MIPS_ADD_IMMEDIATE
),
876 EMPTY_HOWTO (R_MIPS_PJUMP
),
877 EMPTY_HOWTO (R_MIPS_RELGOT
),
879 /* Protected jump conversion. This is an optimization hint. No
880 relocation is required for correctness. */
881 HOWTO (R_MIPS_JALR
, /* type */
883 0, /* size (0 = byte, 1 = short, 2 = long) */
885 false, /* pc_relative */
887 complain_overflow_dont
, /* complain_on_overflow */
888 bfd_elf_generic_reloc
, /* special_function */
889 "R_MIPS_JALR", /* name */
890 false, /* partial_inplace */
891 0x00000000, /* src_mask */
892 0x00000000, /* dst_mask */
893 false), /* pcrel_offset */
896 /* The reloc used for BFD_RELOC_CTOR when doing a 64 bit link. This
897 is a hack to make the linker think that we need 64 bit values. */
898 static reloc_howto_type elf_mips_ctor64_howto
=
899 HOWTO (R_MIPS_64
, /* type */
901 4, /* size (0 = byte, 1 = short, 2 = long) */
903 false, /* pc_relative */
905 complain_overflow_signed
, /* complain_on_overflow */
906 mips32_64bit_reloc
, /* special_function */
907 "R_MIPS_64", /* name */
908 true, /* partial_inplace */
909 0xffffffff, /* src_mask */
910 0xffffffff, /* dst_mask */
911 false); /* pcrel_offset */
913 /* The reloc used for the mips16 jump instruction. */
914 static reloc_howto_type elf_mips16_jump_howto
=
915 HOWTO (R_MIPS16_26
, /* type */
917 2, /* size (0 = byte, 1 = short, 2 = long) */
919 false, /* pc_relative */
921 complain_overflow_dont
, /* complain_on_overflow */
922 /* This needs complex overflow
923 detection, because the upper four
924 bits must match the PC. */
925 mips16_jump_reloc
, /* special_function */
926 "R_MIPS16_26", /* name */
927 true, /* partial_inplace */
928 0x3ffffff, /* src_mask */
929 0x3ffffff, /* dst_mask */
930 false); /* pcrel_offset */
932 /* The reloc used for the mips16 gprel instruction. */
933 static reloc_howto_type elf_mips16_gprel_howto
=
934 HOWTO (R_MIPS16_GPREL
, /* type */
936 2, /* size (0 = byte, 1 = short, 2 = long) */
938 false, /* pc_relative */
940 complain_overflow_signed
, /* complain_on_overflow */
941 mips16_gprel_reloc
, /* special_function */
942 "R_MIPS16_GPREL", /* name */
943 true, /* partial_inplace */
944 0x07ff001f, /* src_mask */
945 0x07ff001f, /* dst_mask */
946 false); /* pcrel_offset */
948 /* GNU extensions for embedded-pic. */
949 /* High 16 bits of symbol value, pc-relative. */
950 static reloc_howto_type elf_mips_gnu_rel_hi16
=
951 HOWTO (R_MIPS_GNU_REL_HI16
, /* type */
953 2, /* size (0 = byte, 1 = short, 2 = long) */
955 true, /* pc_relative */
957 complain_overflow_dont
, /* complain_on_overflow */
958 _bfd_mips_elf_hi16_reloc
, /* special_function */
959 "R_MIPS_GNU_REL_HI16", /* name */
960 true, /* partial_inplace */
961 0xffff, /* src_mask */
962 0xffff, /* dst_mask */
963 true); /* pcrel_offset */
965 /* Low 16 bits of symbol value, pc-relative. */
966 static reloc_howto_type elf_mips_gnu_rel_lo16
=
967 HOWTO (R_MIPS_GNU_REL_LO16
, /* type */
969 2, /* size (0 = byte, 1 = short, 2 = long) */
971 true, /* pc_relative */
973 complain_overflow_dont
, /* complain_on_overflow */
974 _bfd_mips_elf_lo16_reloc
, /* special_function */
975 "R_MIPS_GNU_REL_LO16", /* name */
976 true, /* partial_inplace */
977 0xffff, /* src_mask */
978 0xffff, /* dst_mask */
979 true); /* pcrel_offset */
981 /* 16 bit offset for pc-relative branches. */
982 static reloc_howto_type elf_mips_gnu_rel16_s2
=
983 HOWTO (R_MIPS_GNU_REL16_S2
, /* type */
985 2, /* size (0 = byte, 1 = short, 2 = long) */
987 true, /* pc_relative */
989 complain_overflow_signed
, /* complain_on_overflow */
990 bfd_elf_generic_reloc
, /* special_function */
991 "R_MIPS_GNU_REL16_S2", /* name */
992 true, /* partial_inplace */
993 0xffff, /* src_mask */
994 0xffff, /* dst_mask */
995 true); /* pcrel_offset */
997 /* 64 bit pc-relative. */
998 static reloc_howto_type elf_mips_gnu_pcrel64
=
999 HOWTO (R_MIPS_PC64
, /* type */
1001 4, /* size (0 = byte, 1 = short, 2 = long) */
1003 true, /* pc_relative */
1005 complain_overflow_signed
, /* complain_on_overflow */
1006 bfd_elf_generic_reloc
, /* special_function */
1007 "R_MIPS_PC64", /* name */
1008 true, /* partial_inplace */
1009 MINUS_ONE
, /* src_mask */
1010 MINUS_ONE
, /* dst_mask */
1011 true); /* pcrel_offset */
1013 /* 32 bit pc-relative. */
1014 static reloc_howto_type elf_mips_gnu_pcrel32
=
1015 HOWTO (R_MIPS_PC32
, /* type */
1017 2, /* size (0 = byte, 1 = short, 2 = long) */
1019 true, /* pc_relative */
1021 complain_overflow_signed
, /* complain_on_overflow */
1022 bfd_elf_generic_reloc
, /* special_function */
1023 "R_MIPS_PC32", /* name */
1024 true, /* partial_inplace */
1025 0xffffffff, /* src_mask */
1026 0xffffffff, /* dst_mask */
1027 true); /* pcrel_offset */
1029 /* GNU extension to record C++ vtable hierarchy */
1030 static reloc_howto_type elf_mips_gnu_vtinherit_howto
=
1031 HOWTO (R_MIPS_GNU_VTINHERIT
, /* type */
1033 2, /* size (0 = byte, 1 = short, 2 = long) */
1035 false, /* pc_relative */
1037 complain_overflow_dont
, /* complain_on_overflow */
1038 NULL
, /* special_function */
1039 "R_MIPS_GNU_VTINHERIT", /* name */
1040 false, /* partial_inplace */
1043 false); /* pcrel_offset */
1045 /* GNU extension to record C++ vtable member usage */
1046 static reloc_howto_type elf_mips_gnu_vtentry_howto
=
1047 HOWTO (R_MIPS_GNU_VTENTRY
, /* type */
1049 2, /* size (0 = byte, 1 = short, 2 = long) */
1051 false, /* pc_relative */
1053 complain_overflow_dont
, /* complain_on_overflow */
1054 _bfd_elf_rel_vtable_reloc_fn
, /* special_function */
1055 "R_MIPS_GNU_VTENTRY", /* name */
1056 false, /* partial_inplace */
1059 false); /* pcrel_offset */
1061 /* Do a R_MIPS_HI16 relocation. This has to be done in combination
1062 with a R_MIPS_LO16 reloc, because there is a carry from the LO16 to
1063 the HI16. Here we just save the information we need; we do the
1064 actual relocation when we see the LO16. MIPS ELF requires that the
1065 LO16 immediately follow the HI16. As a GNU extension, we permit an
1066 arbitrary number of HI16 relocs to be associated with a single LO16
1067 reloc. This extension permits gcc to output the HI and LO relocs
1071 struct mips_hi16
*next
;
1076 /* FIXME: This should not be a static variable. */
1078 static struct mips_hi16
*mips_hi16_list
;
1080 bfd_reloc_status_type
1081 _bfd_mips_elf_hi16_reloc (abfd
,
1088 bfd
*abfd ATTRIBUTE_UNUSED
;
1089 arelent
*reloc_entry
;
1092 asection
*input_section
;
1094 char **error_message
;
1096 bfd_reloc_status_type ret
;
1098 struct mips_hi16
*n
;
1100 /* If we're relocating, and this an external symbol, we don't want
1101 to change anything. */
1102 if (output_bfd
!= (bfd
*) NULL
1103 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1104 && reloc_entry
->addend
== 0)
1106 reloc_entry
->address
+= input_section
->output_offset
;
1107 return bfd_reloc_ok
;
1112 if (strcmp (bfd_asymbol_name (symbol
), "_gp_disp") == 0)
1114 boolean relocateable
;
1117 if (ret
== bfd_reloc_undefined
)
1120 if (output_bfd
!= NULL
)
1121 relocateable
= true;
1124 relocateable
= false;
1125 output_bfd
= symbol
->section
->output_section
->owner
;
1128 ret
= mips_elf_final_gp (output_bfd
, symbol
, relocateable
,
1129 error_message
, &gp
);
1130 if (ret
!= bfd_reloc_ok
)
1133 relocation
= gp
- reloc_entry
->address
;
1137 if (bfd_is_und_section (symbol
->section
)
1138 && output_bfd
== (bfd
*) NULL
)
1139 ret
= bfd_reloc_undefined
;
1141 if (bfd_is_com_section (symbol
->section
))
1144 relocation
= symbol
->value
;
1147 relocation
+= symbol
->section
->output_section
->vma
;
1148 relocation
+= symbol
->section
->output_offset
;
1149 relocation
+= reloc_entry
->addend
;
1151 if (reloc_entry
->address
> input_section
->_cooked_size
)
1152 return bfd_reloc_outofrange
;
1154 /* Save the information, and let LO16 do the actual relocation. */
1155 n
= (struct mips_hi16
*) bfd_malloc (sizeof *n
);
1157 return bfd_reloc_outofrange
;
1158 n
->addr
= (bfd_byte
*) data
+ reloc_entry
->address
;
1159 n
->addend
= relocation
;
1160 n
->next
= mips_hi16_list
;
1163 if (output_bfd
!= (bfd
*) NULL
)
1164 reloc_entry
->address
+= input_section
->output_offset
;
1169 /* Do a R_MIPS_LO16 relocation. This is a straightforward 16 bit
1170 inplace relocation; this function exists in order to do the
1171 R_MIPS_HI16 relocation described above. */
1173 bfd_reloc_status_type
1174 _bfd_mips_elf_lo16_reloc (abfd
,
1182 arelent
*reloc_entry
;
1185 asection
*input_section
;
1187 char **error_message
;
1189 arelent gp_disp_relent
;
1191 if (mips_hi16_list
!= NULL
)
1193 struct mips_hi16
*l
;
1200 unsigned long vallo
;
1201 struct mips_hi16
*next
;
1203 /* Do the HI16 relocation. Note that we actually don't need
1204 to know anything about the LO16 itself, except where to
1205 find the low 16 bits of the addend needed by the LO16. */
1206 insn
= bfd_get_32 (abfd
, l
->addr
);
1207 vallo
= (bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
)
1209 val
= ((insn
& 0xffff) << 16) + vallo
;
1212 /* The low order 16 bits are always treated as a signed
1213 value. Therefore, a negative value in the low order bits
1214 requires an adjustment in the high order bits. We need
1215 to make this adjustment in two ways: once for the bits we
1216 took from the data, and once for the bits we are putting
1217 back in to the data. */
1218 if ((vallo
& 0x8000) != 0)
1220 if ((val
& 0x8000) != 0)
1223 insn
= (insn
& ~0xffff) | ((val
>> 16) & 0xffff);
1224 bfd_put_32 (abfd
, insn
, l
->addr
);
1226 if (strcmp (bfd_asymbol_name (symbol
), "_gp_disp") == 0)
1228 gp_disp_relent
= *reloc_entry
;
1229 reloc_entry
= &gp_disp_relent
;
1230 reloc_entry
->addend
= l
->addend
;
1238 mips_hi16_list
= NULL
;
1240 else if (strcmp (bfd_asymbol_name (symbol
), "_gp_disp") == 0)
1242 bfd_reloc_status_type ret
;
1243 bfd_vma gp
, relocation
;
1245 /* FIXME: Does this case ever occur? */
1247 ret
= mips_elf_final_gp (output_bfd
, symbol
, true, error_message
, &gp
);
1248 if (ret
!= bfd_reloc_ok
)
1251 relocation
= gp
- reloc_entry
->address
;
1252 relocation
+= symbol
->section
->output_section
->vma
;
1253 relocation
+= symbol
->section
->output_offset
;
1254 relocation
+= reloc_entry
->addend
;
1256 if (reloc_entry
->address
> input_section
->_cooked_size
)
1257 return bfd_reloc_outofrange
;
1259 gp_disp_relent
= *reloc_entry
;
1260 reloc_entry
= &gp_disp_relent
;
1261 reloc_entry
->addend
= relocation
- 4;
1264 /* Now do the LO16 reloc in the usual way. */
1265 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1266 input_section
, output_bfd
, error_message
);
1269 /* Do a R_MIPS_GOT16 reloc. This is a reloc against the global offset
1270 table used for PIC code. If the symbol is an external symbol, the
1271 instruction is modified to contain the offset of the appropriate
1272 entry in the global offset table. If the symbol is a section
1273 symbol, the next reloc is a R_MIPS_LO16 reloc. The two 16 bit
1274 addends are combined to form the real addend against the section
1275 symbol; the GOT16 is modified to contain the offset of an entry in
1276 the global offset table, and the LO16 is modified to offset it
1277 appropriately. Thus an offset larger than 16 bits requires a
1278 modified value in the global offset table.
1280 This implementation suffices for the assembler, but the linker does
1281 not yet know how to create global offset tables. */
1283 bfd_reloc_status_type
1284 _bfd_mips_elf_got16_reloc (abfd
,
1292 arelent
*reloc_entry
;
1295 asection
*input_section
;
1297 char **error_message
;
1299 /* If we're relocating, and this an external symbol, we don't want
1300 to change anything. */
1301 if (output_bfd
!= (bfd
*) NULL
1302 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1303 && reloc_entry
->addend
== 0)
1305 reloc_entry
->address
+= input_section
->output_offset
;
1306 return bfd_reloc_ok
;
1309 /* If we're relocating, and this is a local symbol, we can handle it
1311 if (output_bfd
!= (bfd
*) NULL
1312 && (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1313 return _bfd_mips_elf_hi16_reloc (abfd
, reloc_entry
, symbol
, data
,
1314 input_section
, output_bfd
, error_message
);
1319 /* Set the GP value for OUTPUT_BFD. Returns false if this is a
1320 dangerous relocation. */
1323 mips_elf_assign_gp (output_bfd
, pgp
)
1331 /* If we've already figured out what GP will be, just return it. */
1332 *pgp
= _bfd_get_gp_value (output_bfd
);
1336 count
= bfd_get_symcount (output_bfd
);
1337 sym
= bfd_get_outsymbols (output_bfd
);
1339 /* The linker script will have created a symbol named `_gp' with the
1340 appropriate value. */
1341 if (sym
== (asymbol
**) NULL
)
1345 for (i
= 0; i
< count
; i
++, sym
++)
1347 register CONST
char *name
;
1349 name
= bfd_asymbol_name (*sym
);
1350 if (*name
== '_' && strcmp (name
, "_gp") == 0)
1352 *pgp
= bfd_asymbol_value (*sym
);
1353 _bfd_set_gp_value (output_bfd
, *pgp
);
1361 /* Only get the error once. */
1363 _bfd_set_gp_value (output_bfd
, *pgp
);
1370 /* We have to figure out the gp value, so that we can adjust the
1371 symbol value correctly. We look up the symbol _gp in the output
1372 BFD. If we can't find it, we're stuck. We cache it in the ELF
1373 target data. We don't need to adjust the symbol value for an
1374 external symbol if we are producing relocateable output. */
1376 static bfd_reloc_status_type
1377 mips_elf_final_gp (output_bfd
, symbol
, relocateable
, error_message
, pgp
)
1380 boolean relocateable
;
1381 char **error_message
;
1384 if (bfd_is_und_section (symbol
->section
)
1388 return bfd_reloc_undefined
;
1391 *pgp
= _bfd_get_gp_value (output_bfd
);
1394 || (symbol
->flags
& BSF_SECTION_SYM
) != 0))
1398 /* Make up a value. */
1399 *pgp
= symbol
->section
->output_section
->vma
+ 0x4000;
1400 _bfd_set_gp_value (output_bfd
, *pgp
);
1402 else if (!mips_elf_assign_gp (output_bfd
, pgp
))
1405 (char *) _("GP relative relocation when _gp not defined");
1406 return bfd_reloc_dangerous
;
1410 return bfd_reloc_ok
;
1413 /* Do a R_MIPS_GPREL16 relocation. This is a 16 bit value which must
1414 become the offset from the gp register. This function also handles
1415 R_MIPS_LITERAL relocations, although those can be handled more
1416 cleverly because the entries in the .lit8 and .lit4 sections can be
1419 static bfd_reloc_status_type gprel16_with_gp
PARAMS ((bfd
*, asymbol
*,
1420 arelent
*, asection
*,
1421 boolean
, PTR
, bfd_vma
));
1423 bfd_reloc_status_type
1424 _bfd_mips_elf_gprel16_reloc (abfd
, reloc_entry
, symbol
, data
, input_section
,
1425 output_bfd
, error_message
)
1427 arelent
*reloc_entry
;
1430 asection
*input_section
;
1432 char **error_message
;
1434 boolean relocateable
;
1435 bfd_reloc_status_type ret
;
1438 /* If we're relocating, and this is an external symbol with no
1439 addend, we don't want to change anything. We will only have an
1440 addend if this is a newly created reloc, not read from an ELF
1442 if (output_bfd
!= (bfd
*) NULL
1443 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1444 && reloc_entry
->addend
== 0)
1446 reloc_entry
->address
+= input_section
->output_offset
;
1447 return bfd_reloc_ok
;
1450 if (output_bfd
!= (bfd
*) NULL
)
1451 relocateable
= true;
1454 relocateable
= false;
1455 output_bfd
= symbol
->section
->output_section
->owner
;
1458 ret
= mips_elf_final_gp (output_bfd
, symbol
, relocateable
, error_message
,
1460 if (ret
!= bfd_reloc_ok
)
1463 return gprel16_with_gp (abfd
, symbol
, reloc_entry
, input_section
,
1464 relocateable
, data
, gp
);
1467 static bfd_reloc_status_type
1468 gprel16_with_gp (abfd
, symbol
, reloc_entry
, input_section
, relocateable
, data
,
1472 arelent
*reloc_entry
;
1473 asection
*input_section
;
1474 boolean relocateable
;
1482 if (bfd_is_com_section (symbol
->section
))
1485 relocation
= symbol
->value
;
1487 relocation
+= symbol
->section
->output_section
->vma
;
1488 relocation
+= symbol
->section
->output_offset
;
1490 if (reloc_entry
->address
> input_section
->_cooked_size
)
1491 return bfd_reloc_outofrange
;
1493 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1495 /* Set val to the offset into the section or symbol. */
1496 if (reloc_entry
->howto
->src_mask
== 0)
1498 /* This case occurs with the 64-bit MIPS ELF ABI. */
1499 val
= reloc_entry
->addend
;
1503 val
= ((insn
& 0xffff) + reloc_entry
->addend
) & 0xffff;
1508 /* Adjust val for the final section location and GP value. If we
1509 are producing relocateable output, we don't want to do this for
1510 an external symbol. */
1512 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1513 val
+= relocation
- gp
;
1515 insn
= (insn
& ~0xffff) | (val
& 0xffff);
1516 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
);
1519 reloc_entry
->address
+= input_section
->output_offset
;
1521 /* Make sure it fit in 16 bits. */
1522 if ((long) val
>= 0x8000 || (long) val
< -0x8000)
1523 return bfd_reloc_overflow
;
1525 return bfd_reloc_ok
;
1528 /* Do a R_MIPS_GPREL32 relocation. Is this 32 bit value the offset
1529 from the gp register? XXX */
1531 static bfd_reloc_status_type gprel32_with_gp
PARAMS ((bfd
*, asymbol
*,
1532 arelent
*, asection
*,
1533 boolean
, PTR
, bfd_vma
));
1535 bfd_reloc_status_type
1536 _bfd_mips_elf_gprel32_reloc (abfd
,
1544 arelent
*reloc_entry
;
1547 asection
*input_section
;
1549 char **error_message
;
1551 boolean relocateable
;
1552 bfd_reloc_status_type ret
;
1555 /* If we're relocating, and this is an external symbol with no
1556 addend, we don't want to change anything. We will only have an
1557 addend if this is a newly created reloc, not read from an ELF
1559 if (output_bfd
!= (bfd
*) NULL
1560 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1561 && reloc_entry
->addend
== 0)
1563 *error_message
= (char *)
1564 _("32bits gp relative relocation occurs for an external symbol");
1565 return bfd_reloc_outofrange
;
1568 if (output_bfd
!= (bfd
*) NULL
)
1570 relocateable
= true;
1571 gp
= _bfd_get_gp_value (output_bfd
);
1575 relocateable
= false;
1576 output_bfd
= symbol
->section
->output_section
->owner
;
1578 ret
= mips_elf_final_gp (output_bfd
, symbol
, relocateable
,
1579 error_message
, &gp
);
1580 if (ret
!= bfd_reloc_ok
)
1584 return gprel32_with_gp (abfd
, symbol
, reloc_entry
, input_section
,
1585 relocateable
, data
, gp
);
1588 static bfd_reloc_status_type
1589 gprel32_with_gp (abfd
, symbol
, reloc_entry
, input_section
, relocateable
, data
,
1593 arelent
*reloc_entry
;
1594 asection
*input_section
;
1595 boolean relocateable
;
1602 if (bfd_is_com_section (symbol
->section
))
1605 relocation
= symbol
->value
;
1607 relocation
+= symbol
->section
->output_section
->vma
;
1608 relocation
+= symbol
->section
->output_offset
;
1610 if (reloc_entry
->address
> input_section
->_cooked_size
)
1611 return bfd_reloc_outofrange
;
1613 if (reloc_entry
->howto
->src_mask
== 0)
1615 /* This case arises with the 64-bit MIPS ELF ABI. */
1619 val
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1621 /* Set val to the offset into the section or symbol. */
1622 val
+= reloc_entry
->addend
;
1624 /* Adjust val for the final section location and GP value. If we
1625 are producing relocateable output, we don't want to do this for
1626 an external symbol. */
1628 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1629 val
+= relocation
- gp
;
1631 bfd_put_32 (abfd
, val
, (bfd_byte
*) data
+ reloc_entry
->address
);
1634 reloc_entry
->address
+= input_section
->output_offset
;
1636 return bfd_reloc_ok
;
1639 /* Handle a 64 bit reloc in a 32 bit MIPS ELF file. These are
1640 generated when addreses are 64 bits. The upper 32 bits are a simle
1643 static bfd_reloc_status_type
1644 mips32_64bit_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 bfd_reloc_status_type r
;
1659 r
= bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1660 input_section
, output_bfd
, error_message
);
1661 if (r
!= bfd_reloc_continue
)
1664 /* Do a normal 32 bit relocation on the lower 32 bits. */
1665 reloc32
= *reloc_entry
;
1666 if (bfd_big_endian (abfd
))
1667 reloc32
.address
+= 4;
1668 reloc32
.howto
= &elf_mips_howto_table
[R_MIPS_32
];
1669 r
= bfd_perform_relocation (abfd
, &reloc32
, data
, input_section
,
1670 output_bfd
, error_message
);
1672 /* Sign extend into the upper 32 bits. */
1673 val
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc32
.address
);
1674 if ((val
& 0x80000000) != 0)
1678 addr
= reloc_entry
->address
;
1679 if (bfd_little_endian (abfd
))
1681 bfd_put_32 (abfd
, val
, (bfd_byte
*) data
+ addr
);
1686 /* Handle a mips16 jump. */
1688 static bfd_reloc_status_type
1689 mips16_jump_reloc (abfd
, reloc_entry
, symbol
, data
, input_section
,
1690 output_bfd
, error_message
)
1691 bfd
*abfd ATTRIBUTE_UNUSED
;
1692 arelent
*reloc_entry
;
1694 PTR data ATTRIBUTE_UNUSED
;
1695 asection
*input_section
;
1697 char **error_message ATTRIBUTE_UNUSED
;
1699 if (output_bfd
!= (bfd
*) NULL
1700 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1701 && reloc_entry
->addend
== 0)
1703 reloc_entry
->address
+= input_section
->output_offset
;
1704 return bfd_reloc_ok
;
1709 static boolean warned
;
1712 (*_bfd_error_handler
)
1713 (_("Linking mips16 objects into %s format is not supported"),
1714 bfd_get_target (input_section
->output_section
->owner
));
1718 return bfd_reloc_undefined
;
1721 /* Handle a mips16 GP relative reloc. */
1723 static bfd_reloc_status_type
1724 mips16_gprel_reloc (abfd
, reloc_entry
, symbol
, data
, input_section
,
1725 output_bfd
, error_message
)
1727 arelent
*reloc_entry
;
1730 asection
*input_section
;
1732 char **error_message
;
1734 boolean relocateable
;
1735 bfd_reloc_status_type ret
;
1737 unsigned short extend
, insn
;
1738 unsigned long final
;
1740 /* If we're relocating, and this is an external symbol with no
1741 addend, we don't want to change anything. We will only have an
1742 addend if this is a newly created reloc, not read from an ELF
1744 if (output_bfd
!= NULL
1745 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1746 && reloc_entry
->addend
== 0)
1748 reloc_entry
->address
+= input_section
->output_offset
;
1749 return bfd_reloc_ok
;
1752 if (output_bfd
!= NULL
)
1753 relocateable
= true;
1756 relocateable
= false;
1757 output_bfd
= symbol
->section
->output_section
->owner
;
1760 ret
= mips_elf_final_gp (output_bfd
, symbol
, relocateable
, error_message
,
1762 if (ret
!= bfd_reloc_ok
)
1765 if (reloc_entry
->address
> input_section
->_cooked_size
)
1766 return bfd_reloc_outofrange
;
1768 /* Pick up the mips16 extend instruction and the real instruction. */
1769 extend
= bfd_get_16 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1770 insn
= bfd_get_16 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
+ 2);
1772 /* Stuff the current addend back as a 32 bit value, do the usual
1773 relocation, and then clean up. */
1775 (((extend
& 0x1f) << 11)
1778 (bfd_byte
*) data
+ reloc_entry
->address
);
1780 ret
= gprel16_with_gp (abfd
, symbol
, reloc_entry
, input_section
,
1781 relocateable
, data
, gp
);
1783 final
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1786 | ((final
>> 11) & 0x1f)
1788 (bfd_byte
*) data
+ reloc_entry
->address
);
1792 (bfd_byte
*) data
+ reloc_entry
->address
+ 2);
1797 /* Return the ISA for a MIPS e_flags value. */
1800 elf_mips_isa (flags
)
1803 switch (flags
& EF_MIPS_ARCH
)
1815 case E_MIPS_ARCH_32
:
1817 case E_MIPS_ARCH_64
:
1823 /* Return the MACH for a MIPS e_flags value. */
1826 elf_mips_mach (flags
)
1829 switch (flags
& EF_MIPS_MACH
)
1831 case E_MIPS_MACH_3900
:
1832 return bfd_mach_mips3900
;
1834 case E_MIPS_MACH_4010
:
1835 return bfd_mach_mips4010
;
1837 case E_MIPS_MACH_4100
:
1838 return bfd_mach_mips4100
;
1840 case E_MIPS_MACH_4111
:
1841 return bfd_mach_mips4111
;
1843 case E_MIPS_MACH_4650
:
1844 return bfd_mach_mips4650
;
1846 case E_MIPS_MACH_MIPS32_4K
:
1847 return bfd_mach_mips32_4k
;
1850 switch (flags
& EF_MIPS_ARCH
)
1854 return bfd_mach_mips3000
;
1858 return bfd_mach_mips6000
;
1862 return bfd_mach_mips4000
;
1866 return bfd_mach_mips8000
;
1870 return bfd_mach_mips5
;
1873 case E_MIPS_ARCH_32
:
1874 return bfd_mach_mips32
;
1877 case E_MIPS_ARCH_64
:
1878 return bfd_mach_mips64
;
1886 /* Return printable name for ABI. */
1888 static INLINE
char *
1889 elf_mips_abi_name (abfd
)
1894 if (ABI_N32_P (abfd
))
1896 else if (ABI_64_P (abfd
))
1899 flags
= elf_elfheader (abfd
)->e_flags
;
1900 switch (flags
& EF_MIPS_ABI
)
1904 case E_MIPS_ABI_O32
:
1906 case E_MIPS_ABI_O64
:
1908 case E_MIPS_ABI_EABI32
:
1910 case E_MIPS_ABI_EABI64
:
1913 return "unknown abi";
1917 /* A mapping from BFD reloc types to MIPS ELF reloc types. */
1919 struct elf_reloc_map
{
1920 bfd_reloc_code_real_type bfd_reloc_val
;
1921 enum elf_mips_reloc_type elf_reloc_val
;
1924 static CONST
struct elf_reloc_map mips_reloc_map
[] = {
1925 { BFD_RELOC_NONE
, R_MIPS_NONE
, },
1926 { BFD_RELOC_16
, R_MIPS_16
},
1927 { BFD_RELOC_32
, R_MIPS_32
},
1928 { BFD_RELOC_64
, R_MIPS_64
},
1929 { BFD_RELOC_MIPS_JMP
, R_MIPS_26
},
1930 { BFD_RELOC_HI16_S
, R_MIPS_HI16
},
1931 { BFD_RELOC_LO16
, R_MIPS_LO16
},
1932 { BFD_RELOC_MIPS_GPREL
, R_MIPS_GPREL16
},
1933 { BFD_RELOC_MIPS_LITERAL
, R_MIPS_LITERAL
},
1934 { BFD_RELOC_MIPS_GOT16
, R_MIPS_GOT16
},
1935 { BFD_RELOC_16_PCREL
, R_MIPS_PC16
},
1936 { BFD_RELOC_MIPS_CALL16
, R_MIPS_CALL16
},
1937 { BFD_RELOC_MIPS_GPREL32
, R_MIPS_GPREL32
},
1938 { BFD_RELOC_MIPS_GOT_HI16
, R_MIPS_GOT_HI16
},
1939 { BFD_RELOC_MIPS_GOT_LO16
, R_MIPS_GOT_LO16
},
1940 { BFD_RELOC_MIPS_CALL_HI16
, R_MIPS_CALL_HI16
},
1941 { BFD_RELOC_MIPS_CALL_LO16
, R_MIPS_CALL_LO16
},
1942 { BFD_RELOC_MIPS_SUB
, R_MIPS_SUB
},
1943 { BFD_RELOC_MIPS_GOT_PAGE
, R_MIPS_GOT_PAGE
},
1944 { BFD_RELOC_MIPS_GOT_OFST
, R_MIPS_GOT_OFST
},
1945 { BFD_RELOC_MIPS_GOT_DISP
, R_MIPS_GOT_DISP
}
1948 /* Given a BFD reloc type, return a howto structure. */
1950 static reloc_howto_type
*
1951 bfd_elf32_bfd_reloc_type_lookup (abfd
, code
)
1953 bfd_reloc_code_real_type code
;
1957 for (i
= 0; i
< sizeof (mips_reloc_map
) / sizeof (struct elf_reloc_map
); i
++)
1959 if (mips_reloc_map
[i
].bfd_reloc_val
== code
)
1960 return &elf_mips_howto_table
[(int) mips_reloc_map
[i
].elf_reloc_val
];
1966 bfd_set_error (bfd_error_bad_value
);
1969 case BFD_RELOC_CTOR
:
1970 /* We need to handle BFD_RELOC_CTOR specially.
1971 Select the right relocation (R_MIPS_32 or R_MIPS_64) based on the
1972 size of addresses on this architecture. */
1973 if (bfd_arch_bits_per_address (abfd
) == 32)
1974 return &elf_mips_howto_table
[(int) R_MIPS_32
];
1976 return &elf_mips_ctor64_howto
;
1978 case BFD_RELOC_MIPS16_JMP
:
1979 return &elf_mips16_jump_howto
;
1980 case BFD_RELOC_MIPS16_GPREL
:
1981 return &elf_mips16_gprel_howto
;
1982 case BFD_RELOC_VTABLE_INHERIT
:
1983 return &elf_mips_gnu_vtinherit_howto
;
1984 case BFD_RELOC_VTABLE_ENTRY
:
1985 return &elf_mips_gnu_vtentry_howto
;
1986 case BFD_RELOC_PCREL_HI16_S
:
1987 return &elf_mips_gnu_rel_hi16
;
1988 case BFD_RELOC_PCREL_LO16
:
1989 return &elf_mips_gnu_rel_lo16
;
1990 case BFD_RELOC_16_PCREL_S2
:
1991 return &elf_mips_gnu_rel16_s2
;
1992 case BFD_RELOC_64_PCREL
:
1993 return &elf_mips_gnu_pcrel64
;
1994 case BFD_RELOC_32_PCREL
:
1995 return &elf_mips_gnu_pcrel32
;
1999 /* Given a MIPS Elf32_Internal_Rel, fill in an arelent structure. */
2001 static reloc_howto_type
*
2002 mips_rtype_to_howto (r_type
)
2003 unsigned int r_type
;
2008 return &elf_mips16_jump_howto
;
2010 case R_MIPS16_GPREL
:
2011 return &elf_mips16_gprel_howto
;
2013 case R_MIPS_GNU_VTINHERIT
:
2014 return &elf_mips_gnu_vtinherit_howto
;
2016 case R_MIPS_GNU_VTENTRY
:
2017 return &elf_mips_gnu_vtentry_howto
;
2019 case R_MIPS_GNU_REL_HI16
:
2020 return &elf_mips_gnu_rel_hi16
;
2022 case R_MIPS_GNU_REL_LO16
:
2023 return &elf_mips_gnu_rel_lo16
;
2025 case R_MIPS_GNU_REL16_S2
:
2026 return &elf_mips_gnu_rel16_s2
;
2029 return &elf_mips_gnu_pcrel64
;
2032 return &elf_mips_gnu_pcrel32
;
2036 BFD_ASSERT (r_type
< (unsigned int) R_MIPS_max
);
2037 return &elf_mips_howto_table
[r_type
];
2042 /* Given a MIPS Elf32_Internal_Rel, fill in an arelent structure. */
2045 mips_info_to_howto_rel (abfd
, cache_ptr
, dst
)
2048 Elf32_Internal_Rel
*dst
;
2050 unsigned int r_type
;
2052 r_type
= ELF32_R_TYPE (dst
->r_info
);
2053 cache_ptr
->howto
= mips_rtype_to_howto (r_type
);
2055 /* The addend for a GPREL16 or LITERAL relocation comes from the GP
2056 value for the object file. We get the addend now, rather than
2057 when we do the relocation, because the symbol manipulations done
2058 by the linker may cause us to lose track of the input BFD. */
2059 if (((*cache_ptr
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) != 0
2060 && (r_type
== (unsigned int) R_MIPS_GPREL16
2061 || r_type
== (unsigned int) R_MIPS_LITERAL
))
2062 cache_ptr
->addend
= elf_gp (abfd
);
2065 /* Given a MIPS Elf32_Internal_Rela, fill in an arelent structure. */
2068 mips_info_to_howto_rela (abfd
, cache_ptr
, dst
)
2071 Elf32_Internal_Rela
*dst
;
2073 /* Since an Elf32_Internal_Rel is an initial prefix of an
2074 Elf32_Internal_Rela, we can just use mips_info_to_howto_rel
2076 mips_info_to_howto_rel (abfd
, cache_ptr
, (Elf32_Internal_Rel
*) dst
);
2078 /* If we ever need to do any extra processing with dst->r_addend
2079 (the field omitted in an Elf32_Internal_Rel) we can do it here. */
2082 /* A .reginfo section holds a single Elf32_RegInfo structure. These
2083 routines swap this structure in and out. They are used outside of
2084 BFD, so they are globally visible. */
2087 bfd_mips_elf32_swap_reginfo_in (abfd
, ex
, in
)
2089 const Elf32_External_RegInfo
*ex
;
2092 in
->ri_gprmask
= bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_gprmask
);
2093 in
->ri_cprmask
[0] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[0]);
2094 in
->ri_cprmask
[1] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[1]);
2095 in
->ri_cprmask
[2] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[2]);
2096 in
->ri_cprmask
[3] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[3]);
2097 in
->ri_gp_value
= bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_gp_value
);
2101 bfd_mips_elf32_swap_reginfo_out (abfd
, in
, ex
)
2103 const Elf32_RegInfo
*in
;
2104 Elf32_External_RegInfo
*ex
;
2106 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_gprmask
,
2107 (bfd_byte
*) ex
->ri_gprmask
);
2108 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[0],
2109 (bfd_byte
*) ex
->ri_cprmask
[0]);
2110 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[1],
2111 (bfd_byte
*) ex
->ri_cprmask
[1]);
2112 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[2],
2113 (bfd_byte
*) ex
->ri_cprmask
[2]);
2114 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[3],
2115 (bfd_byte
*) ex
->ri_cprmask
[3]);
2116 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_gp_value
,
2117 (bfd_byte
*) ex
->ri_gp_value
);
2120 /* In the 64 bit ABI, the .MIPS.options section holds register
2121 information in an Elf64_Reginfo structure. These routines swap
2122 them in and out. They are globally visible because they are used
2123 outside of BFD. These routines are here so that gas can call them
2124 without worrying about whether the 64 bit ABI has been included. */
2127 bfd_mips_elf64_swap_reginfo_in (abfd
, ex
, in
)
2129 const Elf64_External_RegInfo
*ex
;
2130 Elf64_Internal_RegInfo
*in
;
2132 in
->ri_gprmask
= bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_gprmask
);
2133 in
->ri_pad
= bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_pad
);
2134 in
->ri_cprmask
[0] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[0]);
2135 in
->ri_cprmask
[1] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[1]);
2136 in
->ri_cprmask
[2] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[2]);
2137 in
->ri_cprmask
[3] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[3]);
2138 in
->ri_gp_value
= bfd_h_get_64 (abfd
, (bfd_byte
*) ex
->ri_gp_value
);
2142 bfd_mips_elf64_swap_reginfo_out (abfd
, in
, ex
)
2144 const Elf64_Internal_RegInfo
*in
;
2145 Elf64_External_RegInfo
*ex
;
2147 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_gprmask
,
2148 (bfd_byte
*) ex
->ri_gprmask
);
2149 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_pad
,
2150 (bfd_byte
*) ex
->ri_pad
);
2151 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[0],
2152 (bfd_byte
*) ex
->ri_cprmask
[0]);
2153 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[1],
2154 (bfd_byte
*) ex
->ri_cprmask
[1]);
2155 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[2],
2156 (bfd_byte
*) ex
->ri_cprmask
[2]);
2157 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[3],
2158 (bfd_byte
*) ex
->ri_cprmask
[3]);
2159 bfd_h_put_64 (abfd
, (bfd_vma
) in
->ri_gp_value
,
2160 (bfd_byte
*) ex
->ri_gp_value
);
2163 /* Swap an entry in a .gptab section. Note that these routines rely
2164 on the equivalence of the two elements of the union. */
2167 bfd_mips_elf32_swap_gptab_in (abfd
, ex
, in
)
2169 const Elf32_External_gptab
*ex
;
2172 in
->gt_entry
.gt_g_value
= bfd_h_get_32 (abfd
, ex
->gt_entry
.gt_g_value
);
2173 in
->gt_entry
.gt_bytes
= bfd_h_get_32 (abfd
, ex
->gt_entry
.gt_bytes
);
2177 bfd_mips_elf32_swap_gptab_out (abfd
, in
, ex
)
2179 const Elf32_gptab
*in
;
2180 Elf32_External_gptab
*ex
;
2182 bfd_h_put_32 (abfd
, (bfd_vma
) in
->gt_entry
.gt_g_value
,
2183 ex
->gt_entry
.gt_g_value
);
2184 bfd_h_put_32 (abfd
, (bfd_vma
) in
->gt_entry
.gt_bytes
,
2185 ex
->gt_entry
.gt_bytes
);
2189 bfd_elf32_swap_compact_rel_out (abfd
, in
, ex
)
2191 const Elf32_compact_rel
*in
;
2192 Elf32_External_compact_rel
*ex
;
2194 bfd_h_put_32 (abfd
, (bfd_vma
) in
->id1
, ex
->id1
);
2195 bfd_h_put_32 (abfd
, (bfd_vma
) in
->num
, ex
->num
);
2196 bfd_h_put_32 (abfd
, (bfd_vma
) in
->id2
, ex
->id2
);
2197 bfd_h_put_32 (abfd
, (bfd_vma
) in
->offset
, ex
->offset
);
2198 bfd_h_put_32 (abfd
, (bfd_vma
) in
->reserved0
, ex
->reserved0
);
2199 bfd_h_put_32 (abfd
, (bfd_vma
) in
->reserved1
, ex
->reserved1
);
2203 bfd_elf32_swap_crinfo_out (abfd
, in
, ex
)
2205 const Elf32_crinfo
*in
;
2206 Elf32_External_crinfo
*ex
;
2210 l
= (((in
->ctype
& CRINFO_CTYPE
) << CRINFO_CTYPE_SH
)
2211 | ((in
->rtype
& CRINFO_RTYPE
) << CRINFO_RTYPE_SH
)
2212 | ((in
->dist2to
& CRINFO_DIST2TO
) << CRINFO_DIST2TO_SH
)
2213 | ((in
->relvaddr
& CRINFO_RELVADDR
) << CRINFO_RELVADDR_SH
));
2214 bfd_h_put_32 (abfd
, (bfd_vma
) l
, ex
->info
);
2215 bfd_h_put_32 (abfd
, (bfd_vma
) in
->konst
, ex
->konst
);
2216 bfd_h_put_32 (abfd
, (bfd_vma
) in
->vaddr
, ex
->vaddr
);
2219 /* Swap in an options header. */
2222 bfd_mips_elf_swap_options_in (abfd
, ex
, in
)
2224 const Elf_External_Options
*ex
;
2225 Elf_Internal_Options
*in
;
2227 in
->kind
= bfd_h_get_8 (abfd
, ex
->kind
);
2228 in
->size
= bfd_h_get_8 (abfd
, ex
->size
);
2229 in
->section
= bfd_h_get_16 (abfd
, ex
->section
);
2230 in
->info
= bfd_h_get_32 (abfd
, ex
->info
);
2233 /* Swap out an options header. */
2236 bfd_mips_elf_swap_options_out (abfd
, in
, ex
)
2238 const Elf_Internal_Options
*in
;
2239 Elf_External_Options
*ex
;
2241 bfd_h_put_8 (abfd
, in
->kind
, ex
->kind
);
2242 bfd_h_put_8 (abfd
, in
->size
, ex
->size
);
2243 bfd_h_put_16 (abfd
, in
->section
, ex
->section
);
2244 bfd_h_put_32 (abfd
, in
->info
, ex
->info
);
2247 /* Swap in an MSYM entry. */
2250 bfd_mips_elf_swap_msym_in (abfd
, ex
, in
)
2252 const Elf32_External_Msym
*ex
;
2253 Elf32_Internal_Msym
*in
;
2255 in
->ms_hash_value
= bfd_h_get_32 (abfd
, ex
->ms_hash_value
);
2256 in
->ms_info
= bfd_h_get_32 (abfd
, ex
->ms_info
);
2259 /* Swap out an MSYM entry. */
2262 bfd_mips_elf_swap_msym_out (abfd
, in
, ex
)
2264 const Elf32_Internal_Msym
*in
;
2265 Elf32_External_Msym
*ex
;
2267 bfd_h_put_32 (abfd
, in
->ms_hash_value
, ex
->ms_hash_value
);
2268 bfd_h_put_32 (abfd
, in
->ms_info
, ex
->ms_info
);
2271 /* Determine whether a symbol is global for the purposes of splitting
2272 the symbol table into global symbols and local symbols. At least
2273 on Irix 5, this split must be between section symbols and all other
2274 symbols. On most ELF targets the split is between static symbols
2275 and externally visible symbols. */
2278 mips_elf_sym_is_global (abfd
, sym
)
2279 bfd
*abfd ATTRIBUTE_UNUSED
;
2282 return (sym
->flags
& BSF_SECTION_SYM
) == 0 ? true : false;
2285 /* Set the right machine number for a MIPS ELF file. This is used for
2286 both the 32-bit and the 64-bit ABI. */
2289 _bfd_mips_elf_object_p (abfd
)
2292 /* Irix 5 and 6 is broken. Object file symbol tables are not always
2293 sorted correctly such that local symbols precede global symbols,
2294 and the sh_info field in the symbol table is not always right. */
2295 elf_bad_symtab (abfd
) = true;
2297 bfd_default_set_arch_mach (abfd
, bfd_arch_mips
,
2298 elf_mips_mach (elf_elfheader (abfd
)->e_flags
));
2302 /* The final processing done just before writing out a MIPS ELF object
2303 file. This gets the MIPS architecture right based on the machine
2304 number. This is used by both the 32-bit and the 64-bit ABI. */
2307 _bfd_mips_elf_final_write_processing (abfd
, linker
)
2309 boolean linker ATTRIBUTE_UNUSED
;
2313 Elf_Internal_Shdr
**hdrpp
;
2317 switch (bfd_get_mach (abfd
))
2320 case bfd_mach_mips3000
:
2321 val
= E_MIPS_ARCH_1
;
2324 case bfd_mach_mips3900
:
2325 val
= E_MIPS_ARCH_1
| E_MIPS_MACH_3900
;
2328 case bfd_mach_mips6000
:
2329 val
= E_MIPS_ARCH_2
;
2332 case bfd_mach_mips4000
:
2333 case bfd_mach_mips4300
:
2334 val
= E_MIPS_ARCH_3
;
2337 case bfd_mach_mips4010
:
2338 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4010
;
2341 case bfd_mach_mips4100
:
2342 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4100
;
2345 case bfd_mach_mips4111
:
2346 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4111
;
2349 case bfd_mach_mips4650
:
2350 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4650
;
2353 case bfd_mach_mips8000
:
2354 val
= E_MIPS_ARCH_4
;
2357 case bfd_mach_mips32
:
2358 val
= E_MIPS_ARCH_32
;
2361 case bfd_mach_mips32_4k
:
2362 val
= E_MIPS_ARCH_32
| E_MIPS_MACH_MIPS32_4K
;
2365 case bfd_mach_mips5
:
2366 val
= E_MIPS_ARCH_5
;
2369 case bfd_mach_mips64
:
2370 val
= E_MIPS_ARCH_64
;
2374 elf_elfheader (abfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
2375 elf_elfheader (abfd
)->e_flags
|= val
;
2377 /* Set the sh_info field for .gptab sections and other appropriate
2378 info for each special section. */
2379 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
2380 i
< elf_elfheader (abfd
)->e_shnum
;
2383 switch ((*hdrpp
)->sh_type
)
2386 case SHT_MIPS_LIBLIST
:
2387 sec
= bfd_get_section_by_name (abfd
, ".dynstr");
2389 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
2392 case SHT_MIPS_GPTAB
:
2393 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
2394 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
2395 BFD_ASSERT (name
!= NULL
2396 && strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0);
2397 sec
= bfd_get_section_by_name (abfd
, name
+ sizeof ".gptab" - 1);
2398 BFD_ASSERT (sec
!= NULL
);
2399 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
2402 case SHT_MIPS_CONTENT
:
2403 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
2404 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
2405 BFD_ASSERT (name
!= NULL
2406 && strncmp (name
, ".MIPS.content",
2407 sizeof ".MIPS.content" - 1) == 0);
2408 sec
= bfd_get_section_by_name (abfd
,
2409 name
+ sizeof ".MIPS.content" - 1);
2410 BFD_ASSERT (sec
!= NULL
);
2411 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
2414 case SHT_MIPS_SYMBOL_LIB
:
2415 sec
= bfd_get_section_by_name (abfd
, ".dynsym");
2417 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
2418 sec
= bfd_get_section_by_name (abfd
, ".liblist");
2420 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
2423 case SHT_MIPS_EVENTS
:
2424 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
2425 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
2426 BFD_ASSERT (name
!= NULL
);
2427 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0)
2428 sec
= bfd_get_section_by_name (abfd
,
2429 name
+ sizeof ".MIPS.events" - 1);
2432 BFD_ASSERT (strncmp (name
, ".MIPS.post_rel",
2433 sizeof ".MIPS.post_rel" - 1) == 0);
2434 sec
= bfd_get_section_by_name (abfd
,
2436 + sizeof ".MIPS.post_rel" - 1));
2438 BFD_ASSERT (sec
!= NULL
);
2439 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
2446 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
2449 _bfd_mips_elf_set_private_flags (abfd
, flags
)
2453 BFD_ASSERT (!elf_flags_init (abfd
)
2454 || elf_elfheader (abfd
)->e_flags
== flags
);
2456 elf_elfheader (abfd
)->e_flags
= flags
;
2457 elf_flags_init (abfd
) = true;
2461 /* Copy backend specific data from one object module to another */
2464 _bfd_mips_elf_copy_private_bfd_data (ibfd
, obfd
)
2468 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2469 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2472 BFD_ASSERT (!elf_flags_init (obfd
)
2473 || (elf_elfheader (obfd
)->e_flags
2474 == elf_elfheader (ibfd
)->e_flags
));
2476 elf_gp (obfd
) = elf_gp (ibfd
);
2477 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
2478 elf_flags_init (obfd
) = true;
2482 /* Merge backend specific data from an object file to the output
2483 object file when linking. */
2486 _bfd_mips_elf_merge_private_bfd_data (ibfd
, obfd
)
2494 /* Check if we have the same endianess */
2495 if (_bfd_generic_verify_endian_match (ibfd
, obfd
) == false)
2498 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2499 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2502 new_flags
= elf_elfheader (ibfd
)->e_flags
;
2503 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_NOREORDER
;
2504 old_flags
= elf_elfheader (obfd
)->e_flags
;
2506 if (! elf_flags_init (obfd
))
2508 elf_flags_init (obfd
) = true;
2509 elf_elfheader (obfd
)->e_flags
= new_flags
;
2510 elf_elfheader (obfd
)->e_ident
[EI_CLASS
]
2511 = elf_elfheader (ibfd
)->e_ident
[EI_CLASS
];
2513 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
2514 && bfd_get_arch_info (obfd
)->the_default
)
2516 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
2517 bfd_get_mach (ibfd
)))
2524 /* Check flag compatibility. */
2526 new_flags
&= ~EF_MIPS_NOREORDER
;
2527 old_flags
&= ~EF_MIPS_NOREORDER
;
2529 if (new_flags
== old_flags
)
2534 if ((new_flags
& EF_MIPS_PIC
) != (old_flags
& EF_MIPS_PIC
))
2536 new_flags
&= ~EF_MIPS_PIC
;
2537 old_flags
&= ~EF_MIPS_PIC
;
2538 (*_bfd_error_handler
)
2539 (_("%s: linking PIC files with non-PIC files"),
2540 bfd_get_filename (ibfd
));
2544 if ((new_flags
& EF_MIPS_CPIC
) != (old_flags
& EF_MIPS_CPIC
))
2546 new_flags
&= ~EF_MIPS_CPIC
;
2547 old_flags
&= ~EF_MIPS_CPIC
;
2548 (*_bfd_error_handler
)
2549 (_("%s: linking abicalls files with non-abicalls files"),
2550 bfd_get_filename (ibfd
));
2554 /* Compare the ISA's. */
2555 if ((new_flags
& (EF_MIPS_ARCH
| EF_MIPS_MACH
))
2556 != (old_flags
& (EF_MIPS_ARCH
| EF_MIPS_MACH
)))
2558 int new_mach
= new_flags
& EF_MIPS_MACH
;
2559 int old_mach
= old_flags
& EF_MIPS_MACH
;
2560 int new_isa
= elf_mips_isa (new_flags
);
2561 int old_isa
= elf_mips_isa (old_flags
);
2563 /* If either has no machine specified, just compare the general isa's.
2564 Some combinations of machines are ok, if the isa's match. */
2567 || new_mach
== old_mach
2570 /* Don't warn about mixing code using 32-bit ISAs, or mixing code
2571 using 64-bit ISAs. They will normally use the same data sizes
2572 and calling conventions. */
2574 if (( (new_isa
== 1 || new_isa
== 2 || new_isa
== 32)
2575 ^ (old_isa
== 1 || old_isa
== 2 || old_isa
== 32)) != 0)
2577 (*_bfd_error_handler
)
2578 (_("%s: ISA mismatch (-mips%d) with previous modules (-mips%d)"),
2579 bfd_get_filename (ibfd
), new_isa
, old_isa
);
2586 (*_bfd_error_handler
)
2587 (_("%s: ISA mismatch (%d) with previous modules (%d)"),
2588 bfd_get_filename (ibfd
),
2589 elf_mips_mach (new_flags
),
2590 elf_mips_mach (old_flags
));
2594 new_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
2595 old_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
2598 /* Compare ABI's. The 64-bit ABI does not use EF_MIPS_ABI. But, it
2599 does set EI_CLASS differently from any 32-bit ABI. */
2600 if ((new_flags
& EF_MIPS_ABI
) != (old_flags
& EF_MIPS_ABI
)
2601 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
2602 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
2604 /* Only error if both are set (to different values). */
2605 if (((new_flags
& EF_MIPS_ABI
) && (old_flags
& EF_MIPS_ABI
))
2606 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
2607 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
2609 (*_bfd_error_handler
)
2610 (_("%s: ABI mismatch: linking %s module with previous %s modules"),
2611 bfd_get_filename (ibfd
),
2612 elf_mips_abi_name (ibfd
),
2613 elf_mips_abi_name (obfd
));
2616 new_flags
&= ~EF_MIPS_ABI
;
2617 old_flags
&= ~EF_MIPS_ABI
;
2620 /* Warn about any other mismatches */
2621 if (new_flags
!= old_flags
)
2623 (*_bfd_error_handler
)
2624 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
2625 bfd_get_filename (ibfd
), (unsigned long) new_flags
,
2626 (unsigned long) old_flags
);
2632 bfd_set_error (bfd_error_bad_value
);
2640 _bfd_mips_elf_print_private_bfd_data (abfd
, ptr
)
2644 FILE *file
= (FILE *) ptr
;
2646 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
2648 /* Print normal ELF private data. */
2649 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
2651 /* xgettext:c-format */
2652 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
2654 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
)
2655 fprintf (file
, _(" [abi=O32]"));
2656 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O64
)
2657 fprintf (file
, _(" [abi=O64]"));
2658 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
)
2659 fprintf (file
, _(" [abi=EABI32]"));
2660 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
2661 fprintf (file
, _(" [abi=EABI64]"));
2662 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
))
2663 fprintf (file
, _(" [abi unknown]"));
2664 else if (ABI_N32_P (abfd
))
2665 fprintf (file
, _(" [abi=N32]"));
2666 else if (ABI_64_P (abfd
))
2667 fprintf (file
, _(" [abi=64]"));
2669 fprintf (file
, _(" [no abi set]"));
2671 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
2672 fprintf (file
, _(" [mips1]"));
2673 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
2674 fprintf (file
, _(" [mips2]"));
2675 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
2676 fprintf (file
, _(" [mips3]"));
2677 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
2678 fprintf (file
, _(" [mips4]"));
2679 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_5
)
2680 fprintf (file
, _ (" [mips5]"));
2681 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
)
2682 fprintf (file
, _ (" [mips32]"));
2683 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64
)
2684 fprintf (file
, _ (" [mips64]"));
2686 fprintf (file
, _(" [unknown ISA]"));
2688 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_32BITMODE
)
2689 fprintf (file
, _(" [32bitmode]"));
2691 fprintf (file
, _(" [not 32bitmode]"));
2698 /* Handle a MIPS specific section when reading an object file. This
2699 is called when elfcode.h finds a section with an unknown type.
2700 This routine supports both the 32-bit and 64-bit ELF ABI.
2702 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
2706 _bfd_mips_elf_section_from_shdr (abfd
, hdr
, name
)
2708 Elf_Internal_Shdr
*hdr
;
2713 /* There ought to be a place to keep ELF backend specific flags, but
2714 at the moment there isn't one. We just keep track of the
2715 sections by their name, instead. Fortunately, the ABI gives
2716 suggested names for all the MIPS specific sections, so we will
2717 probably get away with this. */
2718 switch (hdr
->sh_type
)
2720 case SHT_MIPS_LIBLIST
:
2721 if (strcmp (name
, ".liblist") != 0)
2725 if (strcmp (name
, MIPS_ELF_MSYM_SECTION_NAME (abfd
)) != 0)
2728 case SHT_MIPS_CONFLICT
:
2729 if (strcmp (name
, ".conflict") != 0)
2732 case SHT_MIPS_GPTAB
:
2733 if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) != 0)
2736 case SHT_MIPS_UCODE
:
2737 if (strcmp (name
, ".ucode") != 0)
2740 case SHT_MIPS_DEBUG
:
2741 if (strcmp (name
, ".mdebug") != 0)
2743 flags
= SEC_DEBUGGING
;
2745 case SHT_MIPS_REGINFO
:
2746 if (strcmp (name
, ".reginfo") != 0
2747 || hdr
->sh_size
!= sizeof (Elf32_External_RegInfo
))
2749 flags
= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_SIZE
);
2751 case SHT_MIPS_IFACE
:
2752 if (strcmp (name
, ".MIPS.interfaces") != 0)
2755 case SHT_MIPS_CONTENT
:
2756 if (strncmp (name
, ".MIPS.content", sizeof ".MIPS.content" - 1) != 0)
2759 case SHT_MIPS_OPTIONS
:
2760 if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) != 0)
2763 case SHT_MIPS_DWARF
:
2764 if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) != 0)
2767 case SHT_MIPS_SYMBOL_LIB
:
2768 if (strcmp (name
, ".MIPS.symlib") != 0)
2771 case SHT_MIPS_EVENTS
:
2772 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) != 0
2773 && strncmp (name
, ".MIPS.post_rel",
2774 sizeof ".MIPS.post_rel" - 1) != 0)
2781 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
2786 if (! bfd_set_section_flags (abfd
, hdr
->bfd_section
,
2787 (bfd_get_section_flags (abfd
,
2793 /* FIXME: We should record sh_info for a .gptab section. */
2795 /* For a .reginfo section, set the gp value in the tdata information
2796 from the contents of this section. We need the gp value while
2797 processing relocs, so we just get it now. The .reginfo section
2798 is not used in the 64-bit MIPS ELF ABI. */
2799 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
2801 Elf32_External_RegInfo ext
;
2804 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, (PTR
) &ext
,
2805 (file_ptr
) 0, sizeof ext
))
2807 bfd_mips_elf32_swap_reginfo_in (abfd
, &ext
, &s
);
2808 elf_gp (abfd
) = s
.ri_gp_value
;
2811 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
2812 set the gp value based on what we find. We may see both
2813 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
2814 they should agree. */
2815 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
)
2817 bfd_byte
*contents
, *l
, *lend
;
2819 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
2820 if (contents
== NULL
)
2822 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
,
2823 (file_ptr
) 0, hdr
->sh_size
))
2829 lend
= contents
+ hdr
->sh_size
;
2830 while (l
+ sizeof (Elf_External_Options
) <= lend
)
2832 Elf_Internal_Options intopt
;
2834 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
2836 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
2838 Elf64_Internal_RegInfo intreg
;
2840 bfd_mips_elf64_swap_reginfo_in
2842 ((Elf64_External_RegInfo
*)
2843 (l
+ sizeof (Elf_External_Options
))),
2845 elf_gp (abfd
) = intreg
.ri_gp_value
;
2847 else if (intopt
.kind
== ODK_REGINFO
)
2849 Elf32_RegInfo intreg
;
2851 bfd_mips_elf32_swap_reginfo_in
2853 ((Elf32_External_RegInfo
*)
2854 (l
+ sizeof (Elf_External_Options
))),
2856 elf_gp (abfd
) = intreg
.ri_gp_value
;
2866 /* Set the correct type for a MIPS ELF section. We do this by the
2867 section name, which is a hack, but ought to work. This routine is
2868 used by both the 32-bit and the 64-bit ABI. */
2871 _bfd_mips_elf_fake_sections (abfd
, hdr
, sec
)
2873 Elf32_Internal_Shdr
*hdr
;
2876 register const char *name
;
2878 name
= bfd_get_section_name (abfd
, sec
);
2880 if (strcmp (name
, ".liblist") == 0)
2882 hdr
->sh_type
= SHT_MIPS_LIBLIST
;
2883 hdr
->sh_info
= sec
->_raw_size
/ sizeof (Elf32_Lib
);
2884 /* The sh_link field is set in final_write_processing. */
2886 else if (strcmp (name
, ".conflict") == 0)
2887 hdr
->sh_type
= SHT_MIPS_CONFLICT
;
2888 else if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0)
2890 hdr
->sh_type
= SHT_MIPS_GPTAB
;
2891 hdr
->sh_entsize
= sizeof (Elf32_External_gptab
);
2892 /* The sh_info field is set in final_write_processing. */
2894 else if (strcmp (name
, ".ucode") == 0)
2895 hdr
->sh_type
= SHT_MIPS_UCODE
;
2896 else if (strcmp (name
, ".mdebug") == 0)
2898 hdr
->sh_type
= SHT_MIPS_DEBUG
;
2899 /* In a shared object on Irix 5.3, the .mdebug section has an
2900 entsize of 0. FIXME: Does this matter? */
2901 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
2902 hdr
->sh_entsize
= 0;
2904 hdr
->sh_entsize
= 1;
2906 else if (strcmp (name
, ".reginfo") == 0)
2908 hdr
->sh_type
= SHT_MIPS_REGINFO
;
2909 /* In a shared object on Irix 5.3, the .reginfo section has an
2910 entsize of 0x18. FIXME: Does this matter? */
2911 if (SGI_COMPAT (abfd
))
2913 if ((abfd
->flags
& DYNAMIC
) != 0)
2914 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
2916 hdr
->sh_entsize
= 1;
2919 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
2921 else if (SGI_COMPAT (abfd
)
2922 && (strcmp (name
, ".hash") == 0
2923 || strcmp (name
, ".dynamic") == 0
2924 || strcmp (name
, ".dynstr") == 0))
2926 if (SGI_COMPAT (abfd
))
2927 hdr
->sh_entsize
= 0;
2929 /* This isn't how the Irix 6 linker behaves. */
2930 hdr
->sh_info
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
2933 else if (strcmp (name
, ".got") == 0
2934 || strcmp (name
, MIPS_ELF_SRDATA_SECTION_NAME (abfd
)) == 0
2935 || strcmp (name
, ".sdata") == 0
2936 || strcmp (name
, ".sbss") == 0
2937 || strcmp (name
, ".lit4") == 0
2938 || strcmp (name
, ".lit8") == 0)
2939 hdr
->sh_flags
|= SHF_MIPS_GPREL
;
2940 else if (strcmp (name
, ".MIPS.interfaces") == 0)
2942 hdr
->sh_type
= SHT_MIPS_IFACE
;
2943 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
2945 else if (strncmp (name
, ".MIPS.content", strlen (".MIPS.content")) == 0)
2947 hdr
->sh_type
= SHT_MIPS_CONTENT
;
2948 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
2949 /* The sh_info field is set in final_write_processing. */
2951 else if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
2953 hdr
->sh_type
= SHT_MIPS_OPTIONS
;
2954 hdr
->sh_entsize
= 1;
2955 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
2957 else if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) == 0)
2958 hdr
->sh_type
= SHT_MIPS_DWARF
;
2959 else if (strcmp (name
, ".MIPS.symlib") == 0)
2961 hdr
->sh_type
= SHT_MIPS_SYMBOL_LIB
;
2962 /* The sh_link and sh_info fields are set in
2963 final_write_processing. */
2965 else if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0
2966 || strncmp (name
, ".MIPS.post_rel",
2967 sizeof ".MIPS.post_rel" - 1) == 0)
2969 hdr
->sh_type
= SHT_MIPS_EVENTS
;
2970 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
2971 /* The sh_link field is set in final_write_processing. */
2973 else if (strcmp (name
, MIPS_ELF_MSYM_SECTION_NAME (abfd
)) == 0)
2975 hdr
->sh_type
= SHT_MIPS_MSYM
;
2976 hdr
->sh_flags
|= SHF_ALLOC
;
2977 hdr
->sh_entsize
= 8;
2980 /* The generic elf_fake_sections will set up REL_HDR using the
2981 default kind of relocations. But, we may actually need both
2982 kinds of relocations, so we set up the second header here. */
2983 if ((sec
->flags
& SEC_RELOC
) != 0)
2985 struct bfd_elf_section_data
*esd
;
2987 esd
= elf_section_data (sec
);
2988 BFD_ASSERT (esd
->rel_hdr2
== NULL
);
2990 = (Elf_Internal_Shdr
*) bfd_zalloc (abfd
, sizeof (Elf_Internal_Shdr
));
2993 _bfd_elf_init_reloc_shdr (abfd
, esd
->rel_hdr2
, sec
,
2994 !elf_section_data (sec
)->use_rela_p
);
3000 /* Given a BFD section, try to locate the corresponding ELF section
3001 index. This is used by both the 32-bit and the 64-bit ABI.
3002 Actually, it's not clear to me that the 64-bit ABI supports these,
3003 but for non-PIC objects we will certainly want support for at least
3004 the .scommon section. */
3007 _bfd_mips_elf_section_from_bfd_section (abfd
, hdr
, sec
, retval
)
3008 bfd
*abfd ATTRIBUTE_UNUSED
;
3009 Elf32_Internal_Shdr
*hdr ATTRIBUTE_UNUSED
;
3013 if (strcmp (bfd_get_section_name (abfd
, sec
), ".scommon") == 0)
3015 *retval
= SHN_MIPS_SCOMMON
;
3018 if (strcmp (bfd_get_section_name (abfd
, sec
), ".acommon") == 0)
3020 *retval
= SHN_MIPS_ACOMMON
;
3026 /* When are writing out the .options or .MIPS.options section,
3027 remember the bytes we are writing out, so that we can install the
3028 GP value in the section_processing routine. */
3031 _bfd_mips_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3036 bfd_size_type count
;
3038 if (strcmp (section
->name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
3042 if (elf_section_data (section
) == NULL
)
3044 section
->used_by_bfd
=
3045 (PTR
) bfd_zalloc (abfd
, sizeof (struct bfd_elf_section_data
));
3046 if (elf_section_data (section
) == NULL
)
3049 c
= (bfd_byte
*) elf_section_data (section
)->tdata
;
3054 if (section
->_cooked_size
!= 0)
3055 size
= section
->_cooked_size
;
3057 size
= section
->_raw_size
;
3058 c
= (bfd_byte
*) bfd_zalloc (abfd
, size
);
3061 elf_section_data (section
)->tdata
= (PTR
) c
;
3064 memcpy (c
+ offset
, location
, count
);
3067 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
,
3071 /* Work over a section just before writing it out. This routine is
3072 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
3073 sections that need the SHF_MIPS_GPREL flag by name; there has to be
3077 _bfd_mips_elf_section_processing (abfd
, hdr
)
3079 Elf_Internal_Shdr
*hdr
;
3081 if (hdr
->sh_type
== SHT_MIPS_REGINFO
3082 && hdr
->sh_size
> 0)
3086 BFD_ASSERT (hdr
->sh_size
== sizeof (Elf32_External_RegInfo
));
3087 BFD_ASSERT (hdr
->contents
== NULL
);
3090 hdr
->sh_offset
+ sizeof (Elf32_External_RegInfo
) - 4,
3093 bfd_h_put_32 (abfd
, (bfd_vma
) elf_gp (abfd
), buf
);
3094 if (bfd_write (buf
, (bfd_size_type
) 1, (bfd_size_type
) 4, abfd
) != 4)
3098 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
3099 && hdr
->bfd_section
!= NULL
3100 && elf_section_data (hdr
->bfd_section
) != NULL
3101 && elf_section_data (hdr
->bfd_section
)->tdata
!= NULL
)
3103 bfd_byte
*contents
, *l
, *lend
;
3105 /* We stored the section contents in the elf_section_data tdata
3106 field in the set_section_contents routine. We save the
3107 section contents so that we don't have to read them again.
3108 At this point we know that elf_gp is set, so we can look
3109 through the section contents to see if there is an
3110 ODK_REGINFO structure. */
3112 contents
= (bfd_byte
*) elf_section_data (hdr
->bfd_section
)->tdata
;
3114 lend
= contents
+ hdr
->sh_size
;
3115 while (l
+ sizeof (Elf_External_Options
) <= lend
)
3117 Elf_Internal_Options intopt
;
3119 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
3121 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
3128 + sizeof (Elf_External_Options
)
3129 + (sizeof (Elf64_External_RegInfo
) - 8)),
3132 bfd_h_put_64 (abfd
, elf_gp (abfd
), buf
);
3133 if (bfd_write (buf
, 1, 8, abfd
) != 8)
3136 else if (intopt
.kind
== ODK_REGINFO
)
3143 + sizeof (Elf_External_Options
)
3144 + (sizeof (Elf32_External_RegInfo
) - 4)),
3147 bfd_h_put_32 (abfd
, elf_gp (abfd
), buf
);
3148 if (bfd_write (buf
, 1, 4, abfd
) != 4)
3155 if (hdr
->bfd_section
!= NULL
)
3157 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
3159 if (strcmp (name
, ".sdata") == 0
3160 || strcmp (name
, ".lit8") == 0
3161 || strcmp (name
, ".lit4") == 0)
3163 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
3164 hdr
->sh_type
= SHT_PROGBITS
;
3166 else if (strcmp (name
, ".sbss") == 0)
3168 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
3169 hdr
->sh_type
= SHT_NOBITS
;
3171 else if (strcmp (name
, MIPS_ELF_SRDATA_SECTION_NAME (abfd
)) == 0)
3173 hdr
->sh_flags
|= SHF_ALLOC
| SHF_MIPS_GPREL
;
3174 hdr
->sh_type
= SHT_PROGBITS
;
3176 else if (strcmp (name
, ".compact_rel") == 0)
3179 hdr
->sh_type
= SHT_PROGBITS
;
3181 else if (strcmp (name
, ".rtproc") == 0)
3183 if (hdr
->sh_addralign
!= 0 && hdr
->sh_entsize
== 0)
3185 unsigned int adjust
;
3187 adjust
= hdr
->sh_size
% hdr
->sh_addralign
;
3189 hdr
->sh_size
+= hdr
->sh_addralign
- adjust
;
3197 /* MIPS ELF uses two common sections. One is the usual one, and the
3198 other is for small objects. All the small objects are kept
3199 together, and then referenced via the gp pointer, which yields
3200 faster assembler code. This is what we use for the small common
3201 section. This approach is copied from ecoff.c. */
3202 static asection mips_elf_scom_section
;
3203 static asymbol mips_elf_scom_symbol
;
3204 static asymbol
*mips_elf_scom_symbol_ptr
;
3206 /* MIPS ELF also uses an acommon section, which represents an
3207 allocated common symbol which may be overridden by a
3208 definition in a shared library. */
3209 static asection mips_elf_acom_section
;
3210 static asymbol mips_elf_acom_symbol
;
3211 static asymbol
*mips_elf_acom_symbol_ptr
;
3213 /* Handle the special MIPS section numbers that a symbol may use.
3214 This is used for both the 32-bit and the 64-bit ABI. */
3217 _bfd_mips_elf_symbol_processing (abfd
, asym
)
3221 elf_symbol_type
*elfsym
;
3223 elfsym
= (elf_symbol_type
*) asym
;
3224 switch (elfsym
->internal_elf_sym
.st_shndx
)
3226 case SHN_MIPS_ACOMMON
:
3227 /* This section is used in a dynamically linked executable file.
3228 It is an allocated common section. The dynamic linker can
3229 either resolve these symbols to something in a shared
3230 library, or it can just leave them here. For our purposes,
3231 we can consider these symbols to be in a new section. */
3232 if (mips_elf_acom_section
.name
== NULL
)
3234 /* Initialize the acommon section. */
3235 mips_elf_acom_section
.name
= ".acommon";
3236 mips_elf_acom_section
.flags
= SEC_ALLOC
;
3237 mips_elf_acom_section
.output_section
= &mips_elf_acom_section
;
3238 mips_elf_acom_section
.symbol
= &mips_elf_acom_symbol
;
3239 mips_elf_acom_section
.symbol_ptr_ptr
= &mips_elf_acom_symbol_ptr
;
3240 mips_elf_acom_symbol
.name
= ".acommon";
3241 mips_elf_acom_symbol
.flags
= BSF_SECTION_SYM
;
3242 mips_elf_acom_symbol
.section
= &mips_elf_acom_section
;
3243 mips_elf_acom_symbol_ptr
= &mips_elf_acom_symbol
;
3245 asym
->section
= &mips_elf_acom_section
;
3249 /* Common symbols less than the GP size are automatically
3250 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
3251 if (asym
->value
> elf_gp_size (abfd
)
3252 || IRIX_COMPAT (abfd
) == ict_irix6
)
3255 case SHN_MIPS_SCOMMON
:
3256 if (mips_elf_scom_section
.name
== NULL
)
3258 /* Initialize the small common section. */
3259 mips_elf_scom_section
.name
= ".scommon";
3260 mips_elf_scom_section
.flags
= SEC_IS_COMMON
;
3261 mips_elf_scom_section
.output_section
= &mips_elf_scom_section
;
3262 mips_elf_scom_section
.symbol
= &mips_elf_scom_symbol
;
3263 mips_elf_scom_section
.symbol_ptr_ptr
= &mips_elf_scom_symbol_ptr
;
3264 mips_elf_scom_symbol
.name
= ".scommon";
3265 mips_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
3266 mips_elf_scom_symbol
.section
= &mips_elf_scom_section
;
3267 mips_elf_scom_symbol_ptr
= &mips_elf_scom_symbol
;
3269 asym
->section
= &mips_elf_scom_section
;
3270 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
3273 case SHN_MIPS_SUNDEFINED
:
3274 asym
->section
= bfd_und_section_ptr
;
3277 #if 0 /* for SGI_COMPAT */
3279 asym
->section
= mips_elf_text_section_ptr
;
3283 asym
->section
= mips_elf_data_section_ptr
;
3289 /* When creating an Irix 5 executable, we need REGINFO and RTPROC
3293 _bfd_mips_elf_additional_program_headers (abfd
)
3299 /* See if we need a PT_MIPS_REGINFO segment. */
3300 s
= bfd_get_section_by_name (abfd
, ".reginfo");
3301 if (s
&& (s
->flags
& SEC_LOAD
))
3304 /* See if we need a PT_MIPS_OPTIONS segment. */
3305 if (IRIX_COMPAT (abfd
) == ict_irix6
3306 && bfd_get_section_by_name (abfd
,
3307 MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)))
3310 /* See if we need a PT_MIPS_RTPROC segment. */
3311 if (IRIX_COMPAT (abfd
) == ict_irix5
3312 && bfd_get_section_by_name (abfd
, ".dynamic")
3313 && bfd_get_section_by_name (abfd
, ".mdebug"))
3319 /* Modify the segment map for an Irix 5 executable. */
3322 _bfd_mips_elf_modify_segment_map (abfd
)
3326 struct elf_segment_map
*m
, **pm
;
3328 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
3330 s
= bfd_get_section_by_name (abfd
, ".reginfo");
3331 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3333 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
3334 if (m
->p_type
== PT_MIPS_REGINFO
)
3338 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, sizeof *m
);
3342 m
->p_type
= PT_MIPS_REGINFO
;
3346 /* We want to put it after the PHDR and INTERP segments. */
3347 pm
= &elf_tdata (abfd
)->segment_map
;
3349 && ((*pm
)->p_type
== PT_PHDR
3350 || (*pm
)->p_type
== PT_INTERP
))
3358 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
3359 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
3360 PT_OPTIONS segement immediately following the program header
3362 if (IRIX_COMPAT (abfd
) == ict_irix6
)
3366 for (s
= abfd
->sections
; s
; s
= s
->next
)
3367 if (elf_section_data (s
)->this_hdr
.sh_type
== SHT_MIPS_OPTIONS
)
3372 struct elf_segment_map
*options_segment
;
3374 /* Usually, there's a program header table. But, sometimes
3375 there's not (like when running the `ld' testsuite). So,
3376 if there's no program header table, we just put the
3377 options segement at the end. */
3378 for (pm
= &elf_tdata (abfd
)->segment_map
;
3381 if ((*pm
)->p_type
== PT_PHDR
)
3384 options_segment
= bfd_zalloc (abfd
,
3385 sizeof (struct elf_segment_map
));
3386 options_segment
->next
= *pm
;
3387 options_segment
->p_type
= PT_MIPS_OPTIONS
;
3388 options_segment
->p_flags
= PF_R
;
3389 options_segment
->p_flags_valid
= true;
3390 options_segment
->count
= 1;
3391 options_segment
->sections
[0] = s
;
3392 *pm
= options_segment
;
3397 if (IRIX_COMPAT (abfd
) == ict_irix5
)
3399 /* If there are .dynamic and .mdebug sections, we make a room
3400 for the RTPROC header. FIXME: Rewrite without section names. */
3401 if (bfd_get_section_by_name (abfd
, ".interp") == NULL
3402 && bfd_get_section_by_name (abfd
, ".dynamic") != NULL
3403 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
3405 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
3406 if (m
->p_type
== PT_MIPS_RTPROC
)
3410 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, sizeof *m
);
3414 m
->p_type
= PT_MIPS_RTPROC
;
3416 s
= bfd_get_section_by_name (abfd
, ".rtproc");
3421 m
->p_flags_valid
= 1;
3429 /* We want to put it after the DYNAMIC segment. */
3430 pm
= &elf_tdata (abfd
)->segment_map
;
3431 while (*pm
!= NULL
&& (*pm
)->p_type
!= PT_DYNAMIC
)
3441 /* On Irix 5, the PT_DYNAMIC segment includes the .dynamic,
3442 .dynstr, .dynsym, and .hash sections, and everything in
3444 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
;
3446 if ((*pm
)->p_type
== PT_DYNAMIC
)
3449 if (IRIX_COMPAT (abfd
) == ict_none
)
3451 /* For a normal mips executable the permissions for the PT_DYNAMIC
3452 segment are read, write and execute. We do that here since
3453 the code in elf.c sets only the read permission. This matters
3454 sometimes for the dynamic linker. */
3455 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
3457 m
->p_flags
= PF_R
| PF_W
| PF_X
;
3458 m
->p_flags_valid
= 1;
3462 && m
->count
== 1 && strcmp (m
->sections
[0]->name
, ".dynamic") == 0)
3464 static const char *sec_names
[] = {
3465 ".dynamic", ".dynstr", ".dynsym", ".hash"
3469 struct elf_segment_map
*n
;
3473 for (i
= 0; i
< sizeof sec_names
/ sizeof sec_names
[0]; i
++)
3475 s
= bfd_get_section_by_name (abfd
, sec_names
[i
]);
3476 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3482 sz
= s
->_cooked_size
;
3485 if (high
< s
->vma
+ sz
)
3491 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3492 if ((s
->flags
& SEC_LOAD
) != 0
3495 + (s
->_cooked_size
!=
3496 0 ? s
->_cooked_size
: s
->_raw_size
)) <= high
))
3499 n
= ((struct elf_segment_map
*)
3500 bfd_zalloc (abfd
, sizeof *n
+ (c
- 1) * sizeof (asection
*)));
3507 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3509 if ((s
->flags
& SEC_LOAD
) != 0
3512 + (s
->_cooked_size
!= 0 ?
3513 s
->_cooked_size
: s
->_raw_size
)) <= high
))
3527 /* The structure of the runtime procedure descriptor created by the
3528 loader for use by the static exception system. */
3530 typedef struct runtime_pdr
{
3531 bfd_vma adr
; /* memory address of start of procedure */
3532 long regmask
; /* save register mask */
3533 long regoffset
; /* save register offset */
3534 long fregmask
; /* save floating point register mask */
3535 long fregoffset
; /* save floating point register offset */
3536 long frameoffset
; /* frame size */
3537 short framereg
; /* frame pointer register */
3538 short pcreg
; /* offset or reg of return pc */
3539 long irpss
; /* index into the runtime string table */
3541 struct exception_info
*exception_info
;/* pointer to exception array */
3543 #define cbRPDR sizeof (RPDR)
3544 #define rpdNil ((pRPDR) 0)
3546 /* Swap RPDR (runtime procedure table entry) for output. */
3548 static void ecoff_swap_rpdr_out
3549 PARAMS ((bfd
*, const RPDR
*, struct rpdr_ext
*));
3552 ecoff_swap_rpdr_out (abfd
, in
, ex
)
3555 struct rpdr_ext
*ex
;
3557 /* ecoff_put_off was defined in ecoffswap.h. */
3558 ecoff_put_off (abfd
, in
->adr
, (bfd_byte
*) ex
->p_adr
);
3559 bfd_h_put_32 (abfd
, in
->regmask
, (bfd_byte
*) ex
->p_regmask
);
3560 bfd_h_put_32 (abfd
, in
->regoffset
, (bfd_byte
*) ex
->p_regoffset
);
3561 bfd_h_put_32 (abfd
, in
->fregmask
, (bfd_byte
*) ex
->p_fregmask
);
3562 bfd_h_put_32 (abfd
, in
->fregoffset
, (bfd_byte
*) ex
->p_fregoffset
);
3563 bfd_h_put_32 (abfd
, in
->frameoffset
, (bfd_byte
*) ex
->p_frameoffset
);
3565 bfd_h_put_16 (abfd
, in
->framereg
, (bfd_byte
*) ex
->p_framereg
);
3566 bfd_h_put_16 (abfd
, in
->pcreg
, (bfd_byte
*) ex
->p_pcreg
);
3568 bfd_h_put_32 (abfd
, in
->irpss
, (bfd_byte
*) ex
->p_irpss
);
3570 ecoff_put_off (abfd
, in
->exception_info
, (bfd_byte
*) ex
->p_exception_info
);
3574 /* Read ECOFF debugging information from a .mdebug section into a
3575 ecoff_debug_info structure. */
3578 _bfd_mips_elf_read_ecoff_info (abfd
, section
, debug
)
3581 struct ecoff_debug_info
*debug
;
3584 const struct ecoff_debug_swap
*swap
;
3585 char *ext_hdr
= NULL
;
3587 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
3588 memset (debug
, 0, sizeof (*debug
));
3590 ext_hdr
= (char *) bfd_malloc ((size_t) swap
->external_hdr_size
);
3591 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
3594 if (bfd_get_section_contents (abfd
, section
, ext_hdr
, (file_ptr
) 0,
3595 swap
->external_hdr_size
)
3599 symhdr
= &debug
->symbolic_header
;
3600 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
3602 /* The symbolic header contains absolute file offsets and sizes to
3604 #define READ(ptr, offset, count, size, type) \
3605 if (symhdr->count == 0) \
3606 debug->ptr = NULL; \
3609 debug->ptr = (type) bfd_malloc ((size_t) (size * symhdr->count)); \
3610 if (debug->ptr == NULL) \
3611 goto error_return; \
3612 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
3613 || (bfd_read (debug->ptr, size, symhdr->count, \
3614 abfd) != size * symhdr->count)) \
3615 goto error_return; \
3618 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
3619 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, PTR
);
3620 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, PTR
);
3621 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, PTR
);
3622 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, PTR
);
3623 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
3625 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
3626 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
3627 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, PTR
);
3628 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, PTR
);
3629 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, PTR
);
3633 debug
->adjust
= NULL
;
3638 if (ext_hdr
!= NULL
)
3640 if (debug
->line
!= NULL
)
3642 if (debug
->external_dnr
!= NULL
)
3643 free (debug
->external_dnr
);
3644 if (debug
->external_pdr
!= NULL
)
3645 free (debug
->external_pdr
);
3646 if (debug
->external_sym
!= NULL
)
3647 free (debug
->external_sym
);
3648 if (debug
->external_opt
!= NULL
)
3649 free (debug
->external_opt
);
3650 if (debug
->external_aux
!= NULL
)
3651 free (debug
->external_aux
);
3652 if (debug
->ss
!= NULL
)
3654 if (debug
->ssext
!= NULL
)
3655 free (debug
->ssext
);
3656 if (debug
->external_fdr
!= NULL
)
3657 free (debug
->external_fdr
);
3658 if (debug
->external_rfd
!= NULL
)
3659 free (debug
->external_rfd
);
3660 if (debug
->external_ext
!= NULL
)
3661 free (debug
->external_ext
);
3665 /* MIPS ELF local labels start with '$', not 'L'. */
3668 mips_elf_is_local_label_name (abfd
, name
)
3675 /* On Irix 6, the labels go back to starting with '.', so we accept
3676 the generic ELF local label syntax as well. */
3677 return _bfd_elf_is_local_label_name (abfd
, name
);
3680 /* MIPS ELF uses a special find_nearest_line routine in order the
3681 handle the ECOFF debugging information. */
3683 struct mips_elf_find_line
{
3684 struct ecoff_debug_info d
;
3685 struct ecoff_find_line i
;
3689 _bfd_mips_elf_find_nearest_line (abfd
, section
, symbols
, offset
, filename_ptr
,
3690 functionname_ptr
, line_ptr
)
3695 const char **filename_ptr
;
3696 const char **functionname_ptr
;
3697 unsigned int *line_ptr
;
3701 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
3702 filename_ptr
, functionname_ptr
,
3706 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
3707 filename_ptr
, functionname_ptr
,
3709 ABI_64_P (abfd
) ? 8 : 0))
3712 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
3716 struct mips_elf_find_line
*fi
;
3717 const struct ecoff_debug_swap
* const swap
=
3718 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
3720 /* If we are called during a link, mips_elf_final_link may have
3721 cleared the SEC_HAS_CONTENTS field. We force it back on here
3722 if appropriate (which it normally will be). */
3723 origflags
= msec
->flags
;
3724 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
3725 msec
->flags
|= SEC_HAS_CONTENTS
;
3727 fi
= elf_tdata (abfd
)->find_line_info
;
3730 bfd_size_type external_fdr_size
;
3733 struct fdr
*fdr_ptr
;
3735 fi
= ((struct mips_elf_find_line
*)
3736 bfd_zalloc (abfd
, sizeof (struct mips_elf_find_line
)));
3739 msec
->flags
= origflags
;
3743 if (! _bfd_mips_elf_read_ecoff_info (abfd
, msec
, &fi
->d
))
3745 msec
->flags
= origflags
;
3749 /* Swap in the FDR information. */
3750 fi
->d
.fdr
= ((struct fdr
*)
3752 (fi
->d
.symbolic_header
.ifdMax
*
3753 sizeof (struct fdr
))));
3754 if (fi
->d
.fdr
== NULL
)
3756 msec
->flags
= origflags
;
3759 external_fdr_size
= swap
->external_fdr_size
;
3760 fdr_ptr
= fi
->d
.fdr
;
3761 fraw_src
= (char *) fi
->d
.external_fdr
;
3762 fraw_end
= (fraw_src
3763 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
3764 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
3765 (*swap
->swap_fdr_in
) (abfd
, (PTR
) fraw_src
, fdr_ptr
);
3767 elf_tdata (abfd
)->find_line_info
= fi
;
3769 /* Note that we don't bother to ever free this information.
3770 find_nearest_line is either called all the time, as in
3771 objdump -l, so the information should be saved, or it is
3772 rarely called, as in ld error messages, so the memory
3773 wasted is unimportant. Still, it would probably be a
3774 good idea for free_cached_info to throw it away. */
3777 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
3778 &fi
->i
, filename_ptr
, functionname_ptr
,
3781 msec
->flags
= origflags
;
3785 msec
->flags
= origflags
;
3788 /* Fall back on the generic ELF find_nearest_line routine. */
3790 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
3791 filename_ptr
, functionname_ptr
,
3795 /* The mips16 compiler uses a couple of special sections to handle
3796 floating point arguments.
3798 Section names that look like .mips16.fn.FNNAME contain stubs that
3799 copy floating point arguments from the fp regs to the gp regs and
3800 then jump to FNNAME. If any 32 bit function calls FNNAME, the
3801 call should be redirected to the stub instead. If no 32 bit
3802 function calls FNNAME, the stub should be discarded. We need to
3803 consider any reference to the function, not just a call, because
3804 if the address of the function is taken we will need the stub,
3805 since the address might be passed to a 32 bit function.
3807 Section names that look like .mips16.call.FNNAME contain stubs
3808 that copy floating point arguments from the gp regs to the fp
3809 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
3810 then any 16 bit function that calls FNNAME should be redirected
3811 to the stub instead. If FNNAME is not a 32 bit function, the
3812 stub should be discarded.
3814 .mips16.call.fp.FNNAME sections are similar, but contain stubs
3815 which call FNNAME and then copy the return value from the fp regs
3816 to the gp regs. These stubs store the return value in $18 while
3817 calling FNNAME; any function which might call one of these stubs
3818 must arrange to save $18 around the call. (This case is not
3819 needed for 32 bit functions that call 16 bit functions, because
3820 16 bit functions always return floating point values in both
3823 Note that in all cases FNNAME might be defined statically.
3824 Therefore, FNNAME is not used literally. Instead, the relocation
3825 information will indicate which symbol the section is for.
3827 We record any stubs that we find in the symbol table. */
3829 #define FN_STUB ".mips16.fn."
3830 #define CALL_STUB ".mips16.call."
3831 #define CALL_FP_STUB ".mips16.call.fp."
3833 /* MIPS ELF linker hash table. */
3835 struct mips_elf_link_hash_table
{
3836 struct elf_link_hash_table root
;
3838 /* We no longer use this. */
3839 /* String section indices for the dynamic section symbols. */
3840 bfd_size_type dynsym_sec_strindex
[SIZEOF_MIPS_DYNSYM_SECNAMES
];
3842 /* The number of .rtproc entries. */
3843 bfd_size_type procedure_count
;
3844 /* The size of the .compact_rel section (if SGI_COMPAT). */
3845 bfd_size_type compact_rel_size
;
3846 /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic
3847 entry is set to the address of __rld_obj_head as in Irix 5. */
3848 boolean use_rld_obj_head
;
3849 /* This is the value of the __rld_map or __rld_obj_head symbol. */
3851 /* This is set if we see any mips16 stub sections. */
3852 boolean mips16_stubs_seen
;
3855 /* Look up an entry in a MIPS ELF linker hash table. */
3857 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
3858 ((struct mips_elf_link_hash_entry *) \
3859 elf_link_hash_lookup (&(table)->root, (string), (create), \
3862 /* Traverse a MIPS ELF linker hash table. */
3864 #define mips_elf_link_hash_traverse(table, func, info) \
3865 (elf_link_hash_traverse \
3867 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
3870 /* Get the MIPS ELF linker hash table from a link_info structure. */
3872 #define mips_elf_hash_table(p) \
3873 ((struct mips_elf_link_hash_table *) ((p)->hash))
3875 static boolean mips_elf_output_extsym
3876 PARAMS ((struct mips_elf_link_hash_entry
*, PTR
));
3878 /* Create an entry in a MIPS ELF linker hash table. */
3880 static struct bfd_hash_entry
*
3881 mips_elf_link_hash_newfunc (entry
, table
, string
)
3882 struct bfd_hash_entry
*entry
;
3883 struct bfd_hash_table
*table
;
3886 struct mips_elf_link_hash_entry
*ret
=
3887 (struct mips_elf_link_hash_entry
*) entry
;
3889 /* Allocate the structure if it has not already been allocated by a
3891 if (ret
== (struct mips_elf_link_hash_entry
*) NULL
)
3892 ret
= ((struct mips_elf_link_hash_entry
*)
3893 bfd_hash_allocate (table
,
3894 sizeof (struct mips_elf_link_hash_entry
)));
3895 if (ret
== (struct mips_elf_link_hash_entry
*) NULL
)
3896 return (struct bfd_hash_entry
*) ret
;
3898 /* Call the allocation method of the superclass. */
3899 ret
= ((struct mips_elf_link_hash_entry
*)
3900 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
3902 if (ret
!= (struct mips_elf_link_hash_entry
*) NULL
)
3904 /* Set local fields. */
3905 memset (&ret
->esym
, 0, sizeof (EXTR
));
3906 /* We use -2 as a marker to indicate that the information has
3907 not been set. -1 means there is no associated ifd. */
3909 ret
->possibly_dynamic_relocs
= 0;
3910 ret
->min_dyn_reloc_index
= 0;
3911 ret
->fn_stub
= NULL
;
3912 ret
->need_fn_stub
= false;
3913 ret
->call_stub
= NULL
;
3914 ret
->call_fp_stub
= NULL
;
3917 return (struct bfd_hash_entry
*) ret
;
3921 _bfd_mips_elf_hide_symbol (info
, h
)
3922 struct bfd_link_info
*info
;
3923 struct mips_elf_link_hash_entry
*h
;
3927 struct mips_got_info
*g
;
3928 dynobj
= elf_hash_table (info
)->dynobj
;
3929 got
= bfd_get_section_by_name (dynobj
, ".got");
3930 g
= (struct mips_got_info
*) elf_section_data (got
)->tdata
;
3932 h
->root
.elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
3933 h
->root
.plt
.offset
= (bfd_vma
) -1;
3934 h
->root
.dynindx
= -1;
3936 /* FIXME: Do we allocate too much GOT space here? */
3938 got
->_raw_size
+= MIPS_ELF_GOT_SIZE (dynobj
);
3941 /* Create a MIPS ELF linker hash table. */
3943 struct bfd_link_hash_table
*
3944 _bfd_mips_elf_link_hash_table_create (abfd
)
3947 struct mips_elf_link_hash_table
*ret
;
3949 ret
= ((struct mips_elf_link_hash_table
*)
3950 bfd_alloc (abfd
, sizeof (struct mips_elf_link_hash_table
)));
3951 if (ret
== (struct mips_elf_link_hash_table
*) NULL
)
3954 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
3955 mips_elf_link_hash_newfunc
))
3957 bfd_release (abfd
, ret
);
3962 /* We no longer use this. */
3963 for (i
= 0; i
< SIZEOF_MIPS_DYNSYM_SECNAMES
; i
++)
3964 ret
->dynsym_sec_strindex
[i
] = (bfd_size_type
) -1;
3966 ret
->procedure_count
= 0;
3967 ret
->compact_rel_size
= 0;
3968 ret
->use_rld_obj_head
= false;
3970 ret
->mips16_stubs_seen
= false;
3972 return &ret
->root
.root
;
3975 /* Hook called by the linker routine which adds symbols from an object
3976 file. We must handle the special MIPS section numbers here. */
3979 _bfd_mips_elf_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
, secp
, valp
)
3981 struct bfd_link_info
*info
;
3982 const Elf_Internal_Sym
*sym
;
3984 flagword
*flagsp ATTRIBUTE_UNUSED
;
3988 if (SGI_COMPAT (abfd
)
3989 && (abfd
->flags
& DYNAMIC
) != 0
3990 && strcmp (*namep
, "_rld_new_interface") == 0)
3992 /* Skip Irix 5 rld entry name. */
3997 switch (sym
->st_shndx
)
4000 /* Common symbols less than the GP size are automatically
4001 treated as SHN_MIPS_SCOMMON symbols. */
4002 if (sym
->st_size
> elf_gp_size (abfd
)
4003 || IRIX_COMPAT (abfd
) == ict_irix6
)
4006 case SHN_MIPS_SCOMMON
:
4007 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
4008 (*secp
)->flags
|= SEC_IS_COMMON
;
4009 *valp
= sym
->st_size
;
4013 /* This section is used in a shared object. */
4014 if (elf_tdata (abfd
)->elf_text_section
== NULL
)
4016 asymbol
*elf_text_symbol
;
4017 asection
*elf_text_section
;
4019 elf_text_section
= bfd_zalloc (abfd
, sizeof (asection
));
4020 if (elf_text_section
== NULL
)
4023 elf_text_symbol
= bfd_zalloc (abfd
, sizeof (asymbol
));
4024 if (elf_text_symbol
== NULL
)
4027 /* Initialize the section. */
4029 elf_tdata (abfd
)->elf_text_section
= elf_text_section
;
4030 elf_tdata (abfd
)->elf_text_symbol
= elf_text_symbol
;
4032 elf_text_section
->symbol
= elf_text_symbol
;
4033 elf_text_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_text_symbol
;
4035 elf_text_section
->name
= ".text";
4036 elf_text_section
->flags
= SEC_NO_FLAGS
;
4037 elf_text_section
->output_section
= NULL
;
4038 elf_text_section
->owner
= abfd
;
4039 elf_text_symbol
->name
= ".text";
4040 elf_text_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
4041 elf_text_symbol
->section
= elf_text_section
;
4043 /* This code used to do *secp = bfd_und_section_ptr if
4044 info->shared. I don't know why, and that doesn't make sense,
4045 so I took it out. */
4046 *secp
= elf_tdata (abfd
)->elf_text_section
;
4049 case SHN_MIPS_ACOMMON
:
4050 /* Fall through. XXX Can we treat this as allocated data? */
4052 /* This section is used in a shared object. */
4053 if (elf_tdata (abfd
)->elf_data_section
== NULL
)
4055 asymbol
*elf_data_symbol
;
4056 asection
*elf_data_section
;
4058 elf_data_section
= bfd_zalloc (abfd
, sizeof (asection
));
4059 if (elf_data_section
== NULL
)
4062 elf_data_symbol
= bfd_zalloc (abfd
, sizeof (asymbol
));
4063 if (elf_data_symbol
== NULL
)
4066 /* Initialize the section. */
4068 elf_tdata (abfd
)->elf_data_section
= elf_data_section
;
4069 elf_tdata (abfd
)->elf_data_symbol
= elf_data_symbol
;
4071 elf_data_section
->symbol
= elf_data_symbol
;
4072 elf_data_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_data_symbol
;
4074 elf_data_section
->name
= ".data";
4075 elf_data_section
->flags
= SEC_NO_FLAGS
;
4076 elf_data_section
->output_section
= NULL
;
4077 elf_data_section
->owner
= abfd
;
4078 elf_data_symbol
->name
= ".data";
4079 elf_data_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
4080 elf_data_symbol
->section
= elf_data_section
;
4082 /* This code used to do *secp = bfd_und_section_ptr if
4083 info->shared. I don't know why, and that doesn't make sense,
4084 so I took it out. */
4085 *secp
= elf_tdata (abfd
)->elf_data_section
;
4088 case SHN_MIPS_SUNDEFINED
:
4089 *secp
= bfd_und_section_ptr
;
4093 if (SGI_COMPAT (abfd
)
4095 && info
->hash
->creator
== abfd
->xvec
4096 && strcmp (*namep
, "__rld_obj_head") == 0)
4098 struct elf_link_hash_entry
*h
;
4100 /* Mark __rld_obj_head as dynamic. */
4102 if (! (_bfd_generic_link_add_one_symbol
4103 (info
, abfd
, *namep
, BSF_GLOBAL
, *secp
,
4104 (bfd_vma
) *valp
, (const char *) NULL
, false,
4105 get_elf_backend_data (abfd
)->collect
,
4106 (struct bfd_link_hash_entry
**) &h
)))
4108 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
4109 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4110 h
->type
= STT_OBJECT
;
4112 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
4115 mips_elf_hash_table (info
)->use_rld_obj_head
= true;
4118 /* If this is a mips16 text symbol, add 1 to the value to make it
4119 odd. This will cause something like .word SYM to come up with
4120 the right value when it is loaded into the PC. */
4121 if (sym
->st_other
== STO_MIPS16
)
4127 /* Structure used to pass information to mips_elf_output_extsym. */
4129 struct extsym_info
{
4131 struct bfd_link_info
*info
;
4132 struct ecoff_debug_info
*debug
;
4133 const struct ecoff_debug_swap
*swap
;
4137 /* This routine is used to write out ECOFF debugging external symbol
4138 information. It is called via mips_elf_link_hash_traverse. The
4139 ECOFF external symbol information must match the ELF external
4140 symbol information. Unfortunately, at this point we don't know
4141 whether a symbol is required by reloc information, so the two
4142 tables may wind up being different. We must sort out the external
4143 symbol information before we can set the final size of the .mdebug
4144 section, and we must set the size of the .mdebug section before we
4145 can relocate any sections, and we can't know which symbols are
4146 required by relocation until we relocate the sections.
4147 Fortunately, it is relatively unlikely that any symbol will be
4148 stripped but required by a reloc. In particular, it can not happen
4149 when generating a final executable. */
4152 mips_elf_output_extsym (h
, data
)
4153 struct mips_elf_link_hash_entry
*h
;
4156 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
4158 asection
*sec
, *output_section
;
4160 if (h
->root
.indx
== -2)
4162 else if (((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
4163 || (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
4164 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
4165 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
4167 else if (einfo
->info
->strip
== strip_all
4168 || (einfo
->info
->strip
== strip_some
4169 && bfd_hash_lookup (einfo
->info
->keep_hash
,
4170 h
->root
.root
.root
.string
,
4171 false, false) == NULL
))
4179 if (h
->esym
.ifd
== -2)
4182 h
->esym
.cobol_main
= 0;
4183 h
->esym
.weakext
= 0;
4184 h
->esym
.reserved
= 0;
4185 h
->esym
.ifd
= ifdNil
;
4186 h
->esym
.asym
.value
= 0;
4187 h
->esym
.asym
.st
= stGlobal
;
4189 if (h
->root
.root
.type
== bfd_link_hash_undefined
4190 || h
->root
.root
.type
== bfd_link_hash_undefweak
)
4194 /* Use undefined class. Also, set class and type for some
4196 name
= h
->root
.root
.root
.string
;
4197 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
4198 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
4200 h
->esym
.asym
.sc
= scData
;
4201 h
->esym
.asym
.st
= stLabel
;
4202 h
->esym
.asym
.value
= 0;
4204 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
4206 h
->esym
.asym
.sc
= scAbs
;
4207 h
->esym
.asym
.st
= stLabel
;
4208 h
->esym
.asym
.value
=
4209 mips_elf_hash_table (einfo
->info
)->procedure_count
;
4211 else if (strcmp (name
, "_gp_disp") == 0)
4213 h
->esym
.asym
.sc
= scAbs
;
4214 h
->esym
.asym
.st
= stLabel
;
4215 h
->esym
.asym
.value
= elf_gp (einfo
->abfd
);
4218 h
->esym
.asym
.sc
= scUndefined
;
4220 else if (h
->root
.root
.type
!= bfd_link_hash_defined
4221 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
4222 h
->esym
.asym
.sc
= scAbs
;
4227 sec
= h
->root
.root
.u
.def
.section
;
4228 output_section
= sec
->output_section
;
4230 /* When making a shared library and symbol h is the one from
4231 the another shared library, OUTPUT_SECTION may be null. */
4232 if (output_section
== NULL
)
4233 h
->esym
.asym
.sc
= scUndefined
;
4236 name
= bfd_section_name (output_section
->owner
, output_section
);
4238 if (strcmp (name
, ".text") == 0)
4239 h
->esym
.asym
.sc
= scText
;
4240 else if (strcmp (name
, ".data") == 0)
4241 h
->esym
.asym
.sc
= scData
;
4242 else if (strcmp (name
, ".sdata") == 0)
4243 h
->esym
.asym
.sc
= scSData
;
4244 else if (strcmp (name
, ".rodata") == 0
4245 || strcmp (name
, ".rdata") == 0)
4246 h
->esym
.asym
.sc
= scRData
;
4247 else if (strcmp (name
, ".bss") == 0)
4248 h
->esym
.asym
.sc
= scBss
;
4249 else if (strcmp (name
, ".sbss") == 0)
4250 h
->esym
.asym
.sc
= scSBss
;
4251 else if (strcmp (name
, ".init") == 0)
4252 h
->esym
.asym
.sc
= scInit
;
4253 else if (strcmp (name
, ".fini") == 0)
4254 h
->esym
.asym
.sc
= scFini
;
4256 h
->esym
.asym
.sc
= scAbs
;
4260 h
->esym
.asym
.reserved
= 0;
4261 h
->esym
.asym
.index
= indexNil
;
4264 if (h
->root
.root
.type
== bfd_link_hash_common
)
4265 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
4266 else if (h
->root
.root
.type
== bfd_link_hash_defined
4267 || h
->root
.root
.type
== bfd_link_hash_defweak
)
4269 if (h
->esym
.asym
.sc
== scCommon
)
4270 h
->esym
.asym
.sc
= scBss
;
4271 else if (h
->esym
.asym
.sc
== scSCommon
)
4272 h
->esym
.asym
.sc
= scSBss
;
4274 sec
= h
->root
.root
.u
.def
.section
;
4275 output_section
= sec
->output_section
;
4276 if (output_section
!= NULL
)
4277 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
4278 + sec
->output_offset
4279 + output_section
->vma
);
4281 h
->esym
.asym
.value
= 0;
4283 else if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
4285 /* Set type and value for a symbol with a function stub. */
4286 h
->esym
.asym
.st
= stProc
;
4287 sec
= h
->root
.root
.u
.def
.section
;
4289 h
->esym
.asym
.value
= 0;
4292 output_section
= sec
->output_section
;
4293 if (output_section
!= NULL
)
4294 h
->esym
.asym
.value
= (h
->root
.plt
.offset
4295 + sec
->output_offset
4296 + output_section
->vma
);
4298 h
->esym
.asym
.value
= 0;
4305 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
4306 h
->root
.root
.root
.string
,
4309 einfo
->failed
= true;
4316 /* Create a runtime procedure table from the .mdebug section. */
4319 mips_elf_create_procedure_table (handle
, abfd
, info
, s
, debug
)
4322 struct bfd_link_info
*info
;
4324 struct ecoff_debug_info
*debug
;
4326 const struct ecoff_debug_swap
*swap
;
4327 HDRR
*hdr
= &debug
->symbolic_header
;
4329 struct rpdr_ext
*erp
;
4331 struct pdr_ext
*epdr
;
4332 struct sym_ext
*esym
;
4335 unsigned long size
, count
;
4336 unsigned long sindex
;
4340 const char *no_name_func
= _("static procedure (no name)");
4348 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
4350 sindex
= strlen (no_name_func
) + 1;
4351 count
= hdr
->ipdMax
;
4354 size
= swap
->external_pdr_size
;
4356 epdr
= (struct pdr_ext
*) bfd_malloc (size
* count
);
4360 if (! _bfd_ecoff_get_accumulated_pdr (handle
, (PTR
) epdr
))
4363 size
= sizeof (RPDR
);
4364 rp
= rpdr
= (RPDR
*) bfd_malloc (size
* count
);
4368 sv
= (char **) bfd_malloc (sizeof (char *) * count
);
4372 count
= hdr
->isymMax
;
4373 size
= swap
->external_sym_size
;
4374 esym
= (struct sym_ext
*) bfd_malloc (size
* count
);
4378 if (! _bfd_ecoff_get_accumulated_sym (handle
, (PTR
) esym
))
4381 count
= hdr
->issMax
;
4382 ss
= (char *) bfd_malloc (count
);
4385 if (! _bfd_ecoff_get_accumulated_ss (handle
, (PTR
) ss
))
4388 count
= hdr
->ipdMax
;
4389 for (i
= 0; i
< count
; i
++, rp
++)
4391 (*swap
->swap_pdr_in
) (abfd
, (PTR
) (epdr
+ i
), &pdr
);
4392 (*swap
->swap_sym_in
) (abfd
, (PTR
) &esym
[pdr
.isym
], &sym
);
4393 rp
->adr
= sym
.value
;
4394 rp
->regmask
= pdr
.regmask
;
4395 rp
->regoffset
= pdr
.regoffset
;
4396 rp
->fregmask
= pdr
.fregmask
;
4397 rp
->fregoffset
= pdr
.fregoffset
;
4398 rp
->frameoffset
= pdr
.frameoffset
;
4399 rp
->framereg
= pdr
.framereg
;
4400 rp
->pcreg
= pdr
.pcreg
;
4402 sv
[i
] = ss
+ sym
.iss
;
4403 sindex
+= strlen (sv
[i
]) + 1;
4407 size
= sizeof (struct rpdr_ext
) * (count
+ 2) + sindex
;
4408 size
= BFD_ALIGN (size
, 16);
4409 rtproc
= (PTR
) bfd_alloc (abfd
, size
);
4412 mips_elf_hash_table (info
)->procedure_count
= 0;
4416 mips_elf_hash_table (info
)->procedure_count
= count
+ 2;
4418 erp
= (struct rpdr_ext
*) rtproc
;
4419 memset (erp
, 0, sizeof (struct rpdr_ext
));
4421 str
= (char *) rtproc
+ sizeof (struct rpdr_ext
) * (count
+ 2);
4422 strcpy (str
, no_name_func
);
4423 str
+= strlen (no_name_func
) + 1;
4424 for (i
= 0; i
< count
; i
++)
4426 ecoff_swap_rpdr_out (abfd
, rpdr
+ i
, erp
+ i
);
4427 strcpy (str
, sv
[i
]);
4428 str
+= strlen (sv
[i
]) + 1;
4430 ecoff_put_off (abfd
, (bfd_vma
) -1, (bfd_byte
*) (erp
+ count
)->p_adr
);
4432 /* Set the size and contents of .rtproc section. */
4433 s
->_raw_size
= size
;
4434 s
->contents
= (bfd_byte
*) rtproc
;
4436 /* Skip this section later on (I don't think this currently
4437 matters, but someday it might). */
4438 s
->link_order_head
= (struct bfd_link_order
*) NULL
;
4467 /* A comparison routine used to sort .gptab entries. */
4470 gptab_compare (p1
, p2
)
4474 const Elf32_gptab
*a1
= (const Elf32_gptab
*) p1
;
4475 const Elf32_gptab
*a2
= (const Elf32_gptab
*) p2
;
4477 return a1
->gt_entry
.gt_g_value
- a2
->gt_entry
.gt_g_value
;
4480 /* We need to use a special link routine to handle the .reginfo and
4481 the .mdebug sections. We need to merge all instances of these
4482 sections together, not write them all out sequentially. */
4485 _bfd_mips_elf_final_link (abfd
, info
)
4487 struct bfd_link_info
*info
;
4491 struct bfd_link_order
*p
;
4492 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
4493 asection
*rtproc_sec
;
4494 Elf32_RegInfo reginfo
;
4495 struct ecoff_debug_info debug
;
4496 const struct ecoff_debug_swap
*swap
4497 = get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
4498 HDRR
*symhdr
= &debug
.symbolic_header
;
4499 PTR mdebug_handle
= NULL
;
4504 static const char * const name
[] = {
4505 ".text", ".init", ".fini", ".data",
4506 ".rodata", ".sdata", ".sbss", ".bss"
4508 static const int sc
[] = {
4509 scText
, scInit
, scFini
, scData
,
4510 scRData
, scSData
, scSBss
, scBss
4513 /* If all the things we linked together were PIC, but we're
4514 producing an executable (rather than a shared object), then the
4515 resulting file is CPIC (i.e., it calls PIC code.) */
4517 && !info
->relocateable
4518 && elf_elfheader (abfd
)->e_flags
& EF_MIPS_PIC
)
4520 elf_elfheader (abfd
)->e_flags
&= ~EF_MIPS_PIC
;
4521 elf_elfheader (abfd
)->e_flags
|= EF_MIPS_CPIC
;
4524 /* We'd carefully arranged the dynamic symbol indices, and then the
4525 generic size_dynamic_sections renumbered them out from under us.
4526 Rather than trying somehow to prevent the renumbering, just do
4528 if (elf_hash_table (info
)->dynamic_sections_created
)
4532 struct mips_got_info
*g
;
4534 /* When we resort, we must tell mips_elf_sort_hash_table what
4535 the lowest index it may use is. That's the number of section
4536 symbols we're going to add. The generic ELF linker only
4537 adds these symbols when building a shared object. Note that
4538 we count the sections after (possibly) removing the .options
4540 if (!mips_elf_sort_hash_table (info
, (info
->shared
4541 ? bfd_count_sections (abfd
) + 1
4545 /* Make sure we didn't grow the global .got region. */
4546 dynobj
= elf_hash_table (info
)->dynobj
;
4547 got
= bfd_get_section_by_name (dynobj
, ".got");
4548 g
= (struct mips_got_info
*) elf_section_data (got
)->tdata
;
4550 if (g
->global_gotsym
!= NULL
)
4551 BFD_ASSERT ((elf_hash_table (info
)->dynsymcount
4552 - g
->global_gotsym
->dynindx
)
4553 <= g
->global_gotno
);
4556 /* On IRIX5, we omit the .options section. On IRIX6, however, we
4557 include it, even though we don't process it quite right. (Some
4558 entries are supposed to be merged.) Empirically, we seem to be
4559 better off including it then not. */
4560 if (IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
4561 for (secpp
= &abfd
->sections
; *secpp
!= NULL
; secpp
= &(*secpp
)->next
)
4563 if (strcmp ((*secpp
)->name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
4565 for (p
= (*secpp
)->link_order_head
; p
!= NULL
; p
= p
->next
)
4566 if (p
->type
== bfd_indirect_link_order
)
4567 p
->u
.indirect
.section
->flags
&= ~SEC_HAS_CONTENTS
;
4568 (*secpp
)->link_order_head
= NULL
;
4569 *secpp
= (*secpp
)->next
;
4570 --abfd
->section_count
;
4576 /* Get a value for the GP register. */
4577 if (elf_gp (abfd
) == 0)
4579 struct bfd_link_hash_entry
*h
;
4581 h
= bfd_link_hash_lookup (info
->hash
, "_gp", false, false, true);
4582 if (h
!= (struct bfd_link_hash_entry
*) NULL
4583 && h
->type
== bfd_link_hash_defined
)
4584 elf_gp (abfd
) = (h
->u
.def
.value
4585 + h
->u
.def
.section
->output_section
->vma
4586 + h
->u
.def
.section
->output_offset
);
4587 else if (info
->relocateable
)
4591 /* Find the GP-relative section with the lowest offset. */
4593 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
4595 && (elf_section_data (o
)->this_hdr
.sh_flags
& SHF_MIPS_GPREL
))
4598 /* And calculate GP relative to that. */
4599 elf_gp (abfd
) = lo
+ ELF_MIPS_GP_OFFSET (abfd
);
4603 /* If the relocate_section function needs to do a reloc
4604 involving the GP value, it should make a reloc_dangerous
4605 callback to warn that GP is not defined. */
4609 /* Go through the sections and collect the .reginfo and .mdebug
4613 gptab_data_sec
= NULL
;
4614 gptab_bss_sec
= NULL
;
4615 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
4617 if (strcmp (o
->name
, ".reginfo") == 0)
4619 memset (®info
, 0, sizeof reginfo
);
4621 /* We have found the .reginfo section in the output file.
4622 Look through all the link_orders comprising it and merge
4623 the information together. */
4624 for (p
= o
->link_order_head
;
4625 p
!= (struct bfd_link_order
*) NULL
;
4628 asection
*input_section
;
4630 Elf32_External_RegInfo ext
;
4633 if (p
->type
!= bfd_indirect_link_order
)
4635 if (p
->type
== bfd_fill_link_order
)
4640 input_section
= p
->u
.indirect
.section
;
4641 input_bfd
= input_section
->owner
;
4643 /* The linker emulation code has probably clobbered the
4644 size to be zero bytes. */
4645 if (input_section
->_raw_size
== 0)
4646 input_section
->_raw_size
= sizeof (Elf32_External_RegInfo
);
4648 if (! bfd_get_section_contents (input_bfd
, input_section
,
4654 bfd_mips_elf32_swap_reginfo_in (input_bfd
, &ext
, &sub
);
4656 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
4657 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
4658 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
4659 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
4660 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
4662 /* ri_gp_value is set by the function
4663 mips_elf32_section_processing when the section is
4664 finally written out. */
4666 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4667 elf_link_input_bfd ignores this section. */
4668 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
4671 /* Size has been set in mips_elf_always_size_sections */
4672 BFD_ASSERT(o
->_raw_size
== sizeof (Elf32_External_RegInfo
));
4674 /* Skip this section later on (I don't think this currently
4675 matters, but someday it might). */
4676 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
4681 if (strcmp (o
->name
, ".mdebug") == 0)
4683 struct extsym_info einfo
;
4685 /* We have found the .mdebug section in the output file.
4686 Look through all the link_orders comprising it and merge
4687 the information together. */
4688 symhdr
->magic
= swap
->sym_magic
;
4689 /* FIXME: What should the version stamp be? */
4691 symhdr
->ilineMax
= 0;
4695 symhdr
->isymMax
= 0;
4696 symhdr
->ioptMax
= 0;
4697 symhdr
->iauxMax
= 0;
4699 symhdr
->issExtMax
= 0;
4702 symhdr
->iextMax
= 0;
4704 /* We accumulate the debugging information itself in the
4705 debug_info structure. */
4707 debug
.external_dnr
= NULL
;
4708 debug
.external_pdr
= NULL
;
4709 debug
.external_sym
= NULL
;
4710 debug
.external_opt
= NULL
;
4711 debug
.external_aux
= NULL
;
4713 debug
.ssext
= debug
.ssext_end
= NULL
;
4714 debug
.external_fdr
= NULL
;
4715 debug
.external_rfd
= NULL
;
4716 debug
.external_ext
= debug
.external_ext_end
= NULL
;
4718 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
4719 if (mdebug_handle
== (PTR
) NULL
)
4723 esym
.cobol_main
= 0;
4727 esym
.asym
.iss
= issNil
;
4728 esym
.asym
.st
= stLocal
;
4729 esym
.asym
.reserved
= 0;
4730 esym
.asym
.index
= indexNil
;
4732 for (i
= 0; i
< 8; i
++)
4734 esym
.asym
.sc
= sc
[i
];
4735 s
= bfd_get_section_by_name (abfd
, name
[i
]);
4738 esym
.asym
.value
= s
->vma
;
4739 last
= s
->vma
+ s
->_raw_size
;
4742 esym
.asym
.value
= last
;
4743 if (!bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
4748 for (p
= o
->link_order_head
;
4749 p
!= (struct bfd_link_order
*) NULL
;
4752 asection
*input_section
;
4754 const struct ecoff_debug_swap
*input_swap
;
4755 struct ecoff_debug_info input_debug
;
4759 if (p
->type
!= bfd_indirect_link_order
)
4761 if (p
->type
== bfd_fill_link_order
)
4766 input_section
= p
->u
.indirect
.section
;
4767 input_bfd
= input_section
->owner
;
4769 if (bfd_get_flavour (input_bfd
) != bfd_target_elf_flavour
4770 || (get_elf_backend_data (input_bfd
)
4771 ->elf_backend_ecoff_debug_swap
) == NULL
)
4773 /* I don't know what a non MIPS ELF bfd would be
4774 doing with a .mdebug section, but I don't really
4775 want to deal with it. */
4779 input_swap
= (get_elf_backend_data (input_bfd
)
4780 ->elf_backend_ecoff_debug_swap
);
4782 BFD_ASSERT (p
->size
== input_section
->_raw_size
);
4784 /* The ECOFF linking code expects that we have already
4785 read in the debugging information and set up an
4786 ecoff_debug_info structure, so we do that now. */
4787 if (! _bfd_mips_elf_read_ecoff_info (input_bfd
, input_section
,
4791 if (! (bfd_ecoff_debug_accumulate
4792 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
4793 &input_debug
, input_swap
, info
)))
4796 /* Loop through the external symbols. For each one with
4797 interesting information, try to find the symbol in
4798 the linker global hash table and save the information
4799 for the output external symbols. */
4800 eraw_src
= input_debug
.external_ext
;
4801 eraw_end
= (eraw_src
4802 + (input_debug
.symbolic_header
.iextMax
4803 * input_swap
->external_ext_size
));
4805 eraw_src
< eraw_end
;
4806 eraw_src
+= input_swap
->external_ext_size
)
4810 struct mips_elf_link_hash_entry
*h
;
4812 (*input_swap
->swap_ext_in
) (input_bfd
, (PTR
) eraw_src
, &ext
);
4813 if (ext
.asym
.sc
== scNil
4814 || ext
.asym
.sc
== scUndefined
4815 || ext
.asym
.sc
== scSUndefined
)
4818 name
= input_debug
.ssext
+ ext
.asym
.iss
;
4819 h
= mips_elf_link_hash_lookup (mips_elf_hash_table (info
),
4820 name
, false, false, true);
4821 if (h
== NULL
|| h
->esym
.ifd
!= -2)
4827 < input_debug
.symbolic_header
.ifdMax
);
4828 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
4834 /* Free up the information we just read. */
4835 free (input_debug
.line
);
4836 free (input_debug
.external_dnr
);
4837 free (input_debug
.external_pdr
);
4838 free (input_debug
.external_sym
);
4839 free (input_debug
.external_opt
);
4840 free (input_debug
.external_aux
);
4841 free (input_debug
.ss
);
4842 free (input_debug
.ssext
);
4843 free (input_debug
.external_fdr
);
4844 free (input_debug
.external_rfd
);
4845 free (input_debug
.external_ext
);
4847 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4848 elf_link_input_bfd ignores this section. */
4849 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
4852 if (SGI_COMPAT (abfd
) && info
->shared
)
4854 /* Create .rtproc section. */
4855 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
4856 if (rtproc_sec
== NULL
)
4858 flagword flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
4859 | SEC_LINKER_CREATED
| SEC_READONLY
);
4861 rtproc_sec
= bfd_make_section (abfd
, ".rtproc");
4862 if (rtproc_sec
== NULL
4863 || ! bfd_set_section_flags (abfd
, rtproc_sec
, flags
)
4864 || ! bfd_set_section_alignment (abfd
, rtproc_sec
, 4))
4868 if (! mips_elf_create_procedure_table (mdebug_handle
, abfd
,
4869 info
, rtproc_sec
, &debug
))
4873 /* Build the external symbol information. */
4876 einfo
.debug
= &debug
;
4878 einfo
.failed
= false;
4879 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
4880 mips_elf_output_extsym
,
4885 /* Set the size of the .mdebug section. */
4886 o
->_raw_size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
4888 /* Skip this section later on (I don't think this currently
4889 matters, but someday it might). */
4890 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
4895 if (strncmp (o
->name
, ".gptab.", sizeof ".gptab." - 1) == 0)
4897 const char *subname
;
4900 Elf32_External_gptab
*ext_tab
;
4903 /* The .gptab.sdata and .gptab.sbss sections hold
4904 information describing how the small data area would
4905 change depending upon the -G switch. These sections
4906 not used in executables files. */
4907 if (! info
->relocateable
)
4911 for (p
= o
->link_order_head
;
4912 p
!= (struct bfd_link_order
*) NULL
;
4915 asection
*input_section
;
4917 if (p
->type
!= bfd_indirect_link_order
)
4919 if (p
->type
== bfd_fill_link_order
)
4924 input_section
= p
->u
.indirect
.section
;
4926 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4927 elf_link_input_bfd ignores this section. */
4928 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
4931 /* Skip this section later on (I don't think this
4932 currently matters, but someday it might). */
4933 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
4935 /* Really remove the section. */
4936 for (secpp
= &abfd
->sections
;
4938 secpp
= &(*secpp
)->next
)
4940 *secpp
= (*secpp
)->next
;
4941 --abfd
->section_count
;
4946 /* There is one gptab for initialized data, and one for
4947 uninitialized data. */
4948 if (strcmp (o
->name
, ".gptab.sdata") == 0)
4950 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
4954 (*_bfd_error_handler
)
4955 (_("%s: illegal section name `%s'"),
4956 bfd_get_filename (abfd
), o
->name
);
4957 bfd_set_error (bfd_error_nonrepresentable_section
);
4961 /* The linker script always combines .gptab.data and
4962 .gptab.sdata into .gptab.sdata, and likewise for
4963 .gptab.bss and .gptab.sbss. It is possible that there is
4964 no .sdata or .sbss section in the output file, in which
4965 case we must change the name of the output section. */
4966 subname
= o
->name
+ sizeof ".gptab" - 1;
4967 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
4969 if (o
== gptab_data_sec
)
4970 o
->name
= ".gptab.data";
4972 o
->name
= ".gptab.bss";
4973 subname
= o
->name
+ sizeof ".gptab" - 1;
4974 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
4977 /* Set up the first entry. */
4979 tab
= (Elf32_gptab
*) bfd_malloc (c
* sizeof (Elf32_gptab
));
4982 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
4983 tab
[0].gt_header
.gt_unused
= 0;
4985 /* Combine the input sections. */
4986 for (p
= o
->link_order_head
;
4987 p
!= (struct bfd_link_order
*) NULL
;
4990 asection
*input_section
;
4994 bfd_size_type gpentry
;
4996 if (p
->type
!= bfd_indirect_link_order
)
4998 if (p
->type
== bfd_fill_link_order
)
5003 input_section
= p
->u
.indirect
.section
;
5004 input_bfd
= input_section
->owner
;
5006 /* Combine the gptab entries for this input section one
5007 by one. We know that the input gptab entries are
5008 sorted by ascending -G value. */
5009 size
= bfd_section_size (input_bfd
, input_section
);
5011 for (gpentry
= sizeof (Elf32_External_gptab
);
5013 gpentry
+= sizeof (Elf32_External_gptab
))
5015 Elf32_External_gptab ext_gptab
;
5016 Elf32_gptab int_gptab
;
5022 if (! (bfd_get_section_contents
5023 (input_bfd
, input_section
, (PTR
) &ext_gptab
,
5024 gpentry
, sizeof (Elf32_External_gptab
))))
5030 bfd_mips_elf32_swap_gptab_in (input_bfd
, &ext_gptab
,
5032 val
= int_gptab
.gt_entry
.gt_g_value
;
5033 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
5036 for (look
= 1; look
< c
; look
++)
5038 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
5039 tab
[look
].gt_entry
.gt_bytes
+= add
;
5041 if (tab
[look
].gt_entry
.gt_g_value
== val
)
5047 Elf32_gptab
*new_tab
;
5050 /* We need a new table entry. */
5051 new_tab
= ((Elf32_gptab
*)
5052 bfd_realloc ((PTR
) tab
,
5053 (c
+ 1) * sizeof (Elf32_gptab
)));
5054 if (new_tab
== NULL
)
5060 tab
[c
].gt_entry
.gt_g_value
= val
;
5061 tab
[c
].gt_entry
.gt_bytes
= add
;
5063 /* Merge in the size for the next smallest -G
5064 value, since that will be implied by this new
5067 for (look
= 1; look
< c
; look
++)
5069 if (tab
[look
].gt_entry
.gt_g_value
< val
5071 || (tab
[look
].gt_entry
.gt_g_value
5072 > tab
[max
].gt_entry
.gt_g_value
)))
5076 tab
[c
].gt_entry
.gt_bytes
+=
5077 tab
[max
].gt_entry
.gt_bytes
;
5082 last
= int_gptab
.gt_entry
.gt_bytes
;
5085 /* Hack: reset the SEC_HAS_CONTENTS flag so that
5086 elf_link_input_bfd ignores this section. */
5087 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
5090 /* The table must be sorted by -G value. */
5092 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
5094 /* Swap out the table. */
5095 ext_tab
= ((Elf32_External_gptab
*)
5096 bfd_alloc (abfd
, c
* sizeof (Elf32_External_gptab
)));
5097 if (ext_tab
== NULL
)
5103 for (i
= 0; i
< c
; i
++)
5104 bfd_mips_elf32_swap_gptab_out (abfd
, tab
+ i
, ext_tab
+ i
);
5107 o
->_raw_size
= c
* sizeof (Elf32_External_gptab
);
5108 o
->contents
= (bfd_byte
*) ext_tab
;
5110 /* Skip this section later on (I don't think this currently
5111 matters, but someday it might). */
5112 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
5116 /* Invoke the regular ELF backend linker to do all the work. */
5117 if (ABI_64_P (abfd
))
5120 if (!bfd_elf64_bfd_final_link (abfd
, info
))
5127 else if (!bfd_elf32_bfd_final_link (abfd
, info
))
5130 /* Now write out the computed sections. */
5132 if (reginfo_sec
!= (asection
*) NULL
)
5134 Elf32_External_RegInfo ext
;
5136 bfd_mips_elf32_swap_reginfo_out (abfd
, ®info
, &ext
);
5137 if (! bfd_set_section_contents (abfd
, reginfo_sec
, (PTR
) &ext
,
5138 (file_ptr
) 0, sizeof ext
))
5142 if (mdebug_sec
!= (asection
*) NULL
)
5144 BFD_ASSERT (abfd
->output_has_begun
);
5145 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
5147 mdebug_sec
->filepos
))
5150 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
5153 if (gptab_data_sec
!= (asection
*) NULL
)
5155 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
5156 gptab_data_sec
->contents
,
5158 gptab_data_sec
->_raw_size
))
5162 if (gptab_bss_sec
!= (asection
*) NULL
)
5164 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
5165 gptab_bss_sec
->contents
,
5167 gptab_bss_sec
->_raw_size
))
5171 if (SGI_COMPAT (abfd
))
5173 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
5174 if (rtproc_sec
!= NULL
)
5176 if (! bfd_set_section_contents (abfd
, rtproc_sec
,
5177 rtproc_sec
->contents
,
5179 rtproc_sec
->_raw_size
))
5187 /* This function is called via qsort() to sort the dynamic relocation
5188 entries by increasing r_symndx value. */
5191 sort_dynamic_relocs (arg1
, arg2
)
5195 const Elf32_External_Rel
*ext_reloc1
= (const Elf32_External_Rel
*) arg1
;
5196 const Elf32_External_Rel
*ext_reloc2
= (const Elf32_External_Rel
*) arg2
;
5198 Elf_Internal_Rel int_reloc1
;
5199 Elf_Internal_Rel int_reloc2
;
5201 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, ext_reloc1
, &int_reloc1
);
5202 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, ext_reloc2
, &int_reloc2
);
5204 return (ELF32_R_SYM (int_reloc1
.r_info
) - ELF32_R_SYM (int_reloc2
.r_info
));
5207 /* Returns the GOT section for ABFD. */
5210 mips_elf_got_section (abfd
)
5213 return bfd_get_section_by_name (abfd
, ".got");
5216 /* Returns the GOT information associated with the link indicated by
5217 INFO. If SGOTP is non-NULL, it is filled in with the GOT
5220 static struct mips_got_info
*
5221 mips_elf_got_info (abfd
, sgotp
)
5226 struct mips_got_info
*g
;
5228 sgot
= mips_elf_got_section (abfd
);
5229 BFD_ASSERT (sgot
!= NULL
);
5230 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
5231 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
5232 BFD_ASSERT (g
!= NULL
);
5239 /* Return whether a relocation is against a local symbol. */
5242 mips_elf_local_relocation_p (input_bfd
, relocation
, local_sections
,
5245 const Elf_Internal_Rela
*relocation
;
5246 asection
**local_sections
;
5247 boolean check_forced
;
5249 unsigned long r_symndx
;
5250 Elf_Internal_Shdr
*symtab_hdr
;
5251 struct mips_elf_link_hash_entry
*h
;
5254 r_symndx
= ELF32_R_SYM (relocation
->r_info
);
5255 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
5256 extsymoff
= (elf_bad_symtab (input_bfd
)) ? 0 : symtab_hdr
->sh_info
;
5258 if (r_symndx
< extsymoff
)
5260 if (elf_bad_symtab (input_bfd
) && local_sections
[r_symndx
] != NULL
)
5265 /* Look up the hash table to check whether the symbol
5266 was forced local. */
5267 h
= (struct mips_elf_link_hash_entry
*)
5268 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
];
5269 /* Find the real hash-table entry for this symbol. */
5270 while (h
->root
.root
.type
== bfd_link_hash_indirect
5271 || h
->root
.root
.type
== bfd_link_hash_warning
)
5272 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
5273 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0)
5280 /* Sign-extend VALUE, which has the indicated number of BITS. */
5283 mips_elf_sign_extend (value
, bits
)
5287 if (value
& ((bfd_vma
) 1 << (bits
- 1)))
5288 /* VALUE is negative. */
5289 value
|= ((bfd_vma
) - 1) << bits
;
5294 /* Return non-zero if the indicated VALUE has overflowed the maximum
5295 range expressable by a signed number with the indicated number of
5299 mips_elf_overflow_p (value
, bits
)
5303 bfd_signed_vma svalue
= (bfd_signed_vma
) value
;
5305 if (svalue
> (1 << (bits
- 1)) - 1)
5306 /* The value is too big. */
5308 else if (svalue
< -(1 << (bits
- 1)))
5309 /* The value is too small. */
5316 /* Calculate the %high function. */
5319 mips_elf_high (value
)
5322 return ((value
+ (bfd_vma
) 0x8000) >> 16) & 0xffff;
5325 /* Calculate the %higher function. */
5328 mips_elf_higher (value
)
5329 bfd_vma value ATTRIBUTE_UNUSED
;
5332 return ((value
+ (bfd_vma
) 0x80008000) >> 32) & 0xffff;
5335 return (bfd_vma
) -1;
5339 /* Calculate the %highest function. */
5342 mips_elf_highest (value
)
5343 bfd_vma value ATTRIBUTE_UNUSED
;
5346 return ((value
+ (bfd_vma
) 0x800080008000) >> 48) & 0xffff;
5349 return (bfd_vma
) -1;
5353 /* Returns the GOT index for the global symbol indicated by H. */
5356 mips_elf_global_got_index (abfd
, h
)
5358 struct elf_link_hash_entry
*h
;
5362 struct mips_got_info
*g
;
5364 g
= mips_elf_got_info (abfd
, &sgot
);
5366 /* Once we determine the global GOT entry with the lowest dynamic
5367 symbol table index, we must put all dynamic symbols with greater
5368 indices into the GOT. That makes it easy to calculate the GOT
5370 BFD_ASSERT (h
->dynindx
>= g
->global_gotsym
->dynindx
);
5371 index
= ((h
->dynindx
- g
->global_gotsym
->dynindx
+ g
->local_gotno
)
5372 * MIPS_ELF_GOT_SIZE (abfd
));
5373 BFD_ASSERT (index
< sgot
->_raw_size
);
5378 /* Returns the offset for the entry at the INDEXth position
5382 mips_elf_got_offset_from_index (dynobj
, output_bfd
, index
)
5390 sgot
= mips_elf_got_section (dynobj
);
5391 gp
= _bfd_get_gp_value (output_bfd
);
5392 return (sgot
->output_section
->vma
+ sgot
->output_offset
+ index
-
5396 /* If H is a symbol that needs a global GOT entry, but has a dynamic
5397 symbol table index lower than any we've seen to date, record it for
5401 mips_elf_record_global_got_symbol (h
, info
, g
)
5402 struct elf_link_hash_entry
*h
;
5403 struct bfd_link_info
*info
;
5404 struct mips_got_info
*g ATTRIBUTE_UNUSED
;
5406 /* A global symbol in the GOT must also be in the dynamic symbol
5408 if (h
->dynindx
== -1
5409 && !bfd_elf32_link_record_dynamic_symbol (info
, h
))
5412 /* If we've already marked this entry as need GOT space, we don't
5413 need to do it again. */
5414 if (h
->got
.offset
!= (bfd_vma
) - 1)
5417 /* By setting this to a value other than -1, we are indicating that
5418 there needs to be a GOT entry for H. */
5424 /* This structure is passed to mips_elf_sort_hash_table_f when sorting
5425 the dynamic symbols. */
5427 struct mips_elf_hash_sort_data
{
5428 /* The symbol in the global GOT with the lowest dynamic symbol table
5430 struct elf_link_hash_entry
*low
;
5431 /* The least dynamic symbol table index corresponding to a symbol
5432 with a GOT entry. */
5433 long min_got_dynindx
;
5434 /* The greatest dynamic symbol table index not corresponding to a
5435 symbol without a GOT entry. */
5436 long max_non_got_dynindx
;
5439 /* If H needs a GOT entry, assign it the highest available dynamic
5440 index. Otherwise, assign it the lowest available dynamic
5444 mips_elf_sort_hash_table_f (h
, data
)
5445 struct mips_elf_link_hash_entry
*h
;
5448 struct mips_elf_hash_sort_data
*hsd
5449 = (struct mips_elf_hash_sort_data
*) data
;
5451 /* Symbols without dynamic symbol table entries aren't interesting
5453 if (h
->root
.dynindx
== -1)
5456 if (h
->root
.got
.offset
!= 0)
5457 h
->root
.dynindx
= hsd
->max_non_got_dynindx
++;
5460 h
->root
.dynindx
= --hsd
->min_got_dynindx
;
5461 hsd
->low
= (struct elf_link_hash_entry
*) h
;
5467 /* Sort the dynamic symbol table so that symbols that need GOT entries
5468 appear towards the end. This reduces the amount of GOT space
5469 required. MAX_LOCAL is used to set the number of local symbols
5470 known to be in the dynamic symbol table. During
5471 mips_elf_size_dynamic_sections, this value is 1. Afterward, the
5472 section symbols are added and the count is higher. */
5475 mips_elf_sort_hash_table (info
, max_local
)
5476 struct bfd_link_info
*info
;
5477 unsigned long max_local
;
5479 struct mips_elf_hash_sort_data hsd
;
5480 struct mips_got_info
*g
;
5483 dynobj
= elf_hash_table (info
)->dynobj
;
5486 hsd
.min_got_dynindx
= elf_hash_table (info
)->dynsymcount
;
5487 hsd
.max_non_got_dynindx
= max_local
;
5488 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table
*)
5489 elf_hash_table (info
)),
5490 mips_elf_sort_hash_table_f
,
5493 /* There shoud have been enough room in the symbol table to
5494 accomodate both the GOT and non-GOT symbols. */
5495 BFD_ASSERT (hsd
.max_non_got_dynindx
<= hsd
.min_got_dynindx
);
5497 /* Now we know which dynamic symbol has the lowest dynamic symbol
5498 table index in the GOT. */
5499 g
= mips_elf_got_info (dynobj
, NULL
);
5500 g
->global_gotsym
= hsd
.low
;
5505 /* Create a local GOT entry for VALUE. Return the index of the entry,
5506 or -1 if it could not be created. */
5509 mips_elf_create_local_got_entry (abfd
, g
, sgot
, value
)
5511 struct mips_got_info
*g
;
5515 if (g
->assigned_gotno
>= g
->local_gotno
)
5517 /* We didn't allocate enough space in the GOT. */
5518 (*_bfd_error_handler
)
5519 (_("not enough GOT space for local GOT entries"));
5520 bfd_set_error (bfd_error_bad_value
);
5521 return (bfd_vma
) -1;
5524 MIPS_ELF_PUT_WORD (abfd
, value
,
5526 + MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
));
5527 return MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
++;
5530 /* Returns the GOT offset at which the indicated address can be found.
5531 If there is not yet a GOT entry for this value, create one. Returns
5532 -1 if no satisfactory GOT offset can be found. */
5535 mips_elf_local_got_index (abfd
, info
, value
)
5537 struct bfd_link_info
*info
;
5541 struct mips_got_info
*g
;
5544 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
5546 /* Look to see if we already have an appropriate entry. */
5547 for (entry
= (sgot
->contents
5548 + MIPS_ELF_GOT_SIZE (abfd
) * MIPS_RESERVED_GOTNO
);
5549 entry
!= sgot
->contents
+ MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
;
5550 entry
+= MIPS_ELF_GOT_SIZE (abfd
))
5552 bfd_vma address
= MIPS_ELF_GET_WORD (abfd
, entry
);
5553 if (address
== value
)
5554 return entry
- sgot
->contents
;
5557 return mips_elf_create_local_got_entry (abfd
, g
, sgot
, value
);
5560 /* Find a GOT entry that is within 32KB of the VALUE. These entries
5561 are supposed to be placed at small offsets in the GOT, i.e.,
5562 within 32KB of GP. Return the index into the GOT for this page,
5563 and store the offset from this entry to the desired address in
5564 OFFSETP, if it is non-NULL. */
5567 mips_elf_got_page (abfd
, info
, value
, offsetp
)
5569 struct bfd_link_info
*info
;
5574 struct mips_got_info
*g
;
5576 bfd_byte
*last_entry
;
5580 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
5582 /* Look to see if we aleady have an appropriate entry. */
5583 last_entry
= sgot
->contents
+ MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
;
5584 for (entry
= (sgot
->contents
5585 + MIPS_ELF_GOT_SIZE (abfd
) * MIPS_RESERVED_GOTNO
);
5586 entry
!= last_entry
;
5587 entry
+= MIPS_ELF_GOT_SIZE (abfd
))
5589 address
= MIPS_ELF_GET_WORD (abfd
, entry
);
5591 if (!mips_elf_overflow_p (value
- address
, 16))
5593 /* This entry will serve as the page pointer. We can add a
5594 16-bit number to it to get the actual address. */
5595 index
= entry
- sgot
->contents
;
5600 /* If we didn't have an appropriate entry, we create one now. */
5601 if (entry
== last_entry
)
5602 index
= mips_elf_create_local_got_entry (abfd
, g
, sgot
, value
);
5606 address
= MIPS_ELF_GET_WORD (abfd
, entry
);
5607 *offsetp
= value
- address
;
5613 /* Find a GOT entry whose higher-order 16 bits are the same as those
5614 for value. Return the index into the GOT for this entry. */
5617 mips_elf_got16_entry (abfd
, info
, value
, external
)
5619 struct bfd_link_info
*info
;
5624 struct mips_got_info
*g
;
5626 bfd_byte
*last_entry
;
5632 /* Although the ABI says that it is "the high-order 16 bits" that we
5633 want, it is really the %high value. The complete value is
5634 calculated with a `addiu' of a LO16 relocation, just as with a
5636 value
= mips_elf_high (value
) << 16;
5639 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
5641 /* Look to see if we already have an appropriate entry. */
5642 last_entry
= sgot
->contents
+ MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
;
5643 for (entry
= (sgot
->contents
5644 + MIPS_ELF_GOT_SIZE (abfd
) * MIPS_RESERVED_GOTNO
);
5645 entry
!= last_entry
;
5646 entry
+= MIPS_ELF_GOT_SIZE (abfd
))
5648 address
= MIPS_ELF_GET_WORD (abfd
, entry
);
5649 if (address
== value
)
5651 /* This entry has the right high-order 16 bits, and the low-order
5652 16 bits are set to zero. */
5653 index
= entry
- sgot
->contents
;
5658 /* If we didn't have an appropriate entry, we create one now. */
5659 if (entry
== last_entry
)
5660 index
= mips_elf_create_local_got_entry (abfd
, g
, sgot
, value
);
5665 /* Returns the first relocation of type r_type found, beginning with
5666 RELOCATION. RELEND is one-past-the-end of the relocation table. */
5668 static const Elf_Internal_Rela
*
5669 mips_elf_next_relocation (r_type
, relocation
, relend
)
5670 unsigned int r_type
;
5671 const Elf_Internal_Rela
*relocation
;
5672 const Elf_Internal_Rela
*relend
;
5674 /* According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must be
5675 immediately following. However, for the IRIX6 ABI, the next
5676 relocation may be a composed relocation consisting of several
5677 relocations for the same address. In that case, the R_MIPS_LO16
5678 relocation may occur as one of these. We permit a similar
5679 extension in general, as that is useful for GCC. */
5680 while (relocation
< relend
)
5682 if (ELF32_R_TYPE (relocation
->r_info
) == r_type
)
5688 /* We didn't find it. */
5689 bfd_set_error (bfd_error_bad_value
);
5693 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
5694 is the original relocation, which is now being transformed into a
5695 dynamic relocation. The ADDENDP is adjusted if necessary; the
5696 caller should store the result in place of the original addend. */
5699 mips_elf_create_dynamic_relocation (output_bfd
, info
, rel
, h
, sec
,
5700 symbol
, addendp
, input_section
, local_p
)
5702 struct bfd_link_info
*info
;
5703 const Elf_Internal_Rela
*rel
;
5704 struct mips_elf_link_hash_entry
*h
;
5708 asection
*input_section
;
5711 Elf_Internal_Rel outrel
;
5717 r_type
= ELF32_R_TYPE (rel
->r_info
);
5718 dynobj
= elf_hash_table (info
)->dynobj
;
5720 = bfd_get_section_by_name (dynobj
,
5721 MIPS_ELF_REL_DYN_SECTION_NAME (output_bfd
));
5722 BFD_ASSERT (sreloc
!= NULL
);
5723 BFD_ASSERT (sreloc
->contents
!= NULL
);
5727 /* We begin by assuming that the offset for the dynamic relocation
5728 is the same as for the original relocation. We'll adjust this
5729 later to reflect the correct output offsets. */
5730 if (elf_section_data (input_section
)->stab_info
== NULL
)
5731 outrel
.r_offset
= rel
->r_offset
;
5734 /* Except that in a stab section things are more complex.
5735 Because we compress stab information, the offset given in the
5736 relocation may not be the one we want; we must let the stabs
5737 machinery tell us the offset. */
5739 = (_bfd_stab_section_offset
5740 (output_bfd
, &elf_hash_table (info
)->stab_info
,
5742 &elf_section_data (input_section
)->stab_info
,
5744 /* If we didn't need the relocation at all, this value will be
5746 if (outrel
.r_offset
== (bfd_vma
) -1)
5750 /* If we've decided to skip this relocation, just output an empty
5751 record. Note that R_MIPS_NONE == 0, so that this call to memset
5752 is a way of setting R_TYPE to R_MIPS_NONE. */
5754 memset (&outrel
, 0, sizeof (outrel
));
5758 bfd_vma section_offset
;
5760 /* We must now calculate the dynamic symbol table index to use
5761 in the relocation. */
5763 && (! info
->symbolic
|| (h
->root
.elf_link_hash_flags
5764 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
5766 indx
= h
->root
.dynindx
;
5767 /* h->root.dynindx may be -1 if this symbol was marked to
5774 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
5776 else if (sec
== NULL
|| sec
->owner
== NULL
)
5778 bfd_set_error (bfd_error_bad_value
);
5783 indx
= elf_section_data (sec
->output_section
)->dynindx
;
5788 /* Figure out how far the target of the relocation is from
5789 the beginning of its section. */
5790 section_offset
= symbol
- sec
->output_section
->vma
;
5791 /* The relocation we're building is section-relative.
5792 Therefore, the original addend must be adjusted by the
5794 *addendp
+= symbol
- sec
->output_section
->vma
;
5795 /* Now, the relocation is just against the section. */
5796 symbol
= sec
->output_section
->vma
;
5799 /* If the relocation is against a local symbol was previously an
5800 absolute relocation, we must adjust it by the value we give
5801 it in the dynamic symbol table. */
5802 if (local_p
&& r_type
!= R_MIPS_REL32
)
5805 /* The relocation is always an REL32 relocation because we don't
5806 know where the shared library will wind up at load-time. */
5807 outrel
.r_info
= ELF32_R_INFO (indx
, R_MIPS_REL32
);
5809 /* Adjust the output offset of the relocation to reference the
5810 correct location in the output file. */
5811 outrel
.r_offset
+= (input_section
->output_section
->vma
5812 + input_section
->output_offset
);
5815 /* Put the relocation back out. We have to use the special
5816 relocation outputter in the 64-bit case since the 64-bit
5817 relocation format is non-standard. */
5818 if (ABI_64_P (output_bfd
))
5820 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
5821 (output_bfd
, &outrel
,
5823 + sreloc
->reloc_count
* sizeof (Elf64_Mips_External_Rel
)));
5826 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
5827 (((Elf32_External_Rel
*)
5829 + sreloc
->reloc_count
));
5831 /* Record the index of the first relocation referencing H. This
5832 information is later emitted in the .msym section. */
5834 && (h
->min_dyn_reloc_index
== 0
5835 || sreloc
->reloc_count
< h
->min_dyn_reloc_index
))
5836 h
->min_dyn_reloc_index
= sreloc
->reloc_count
;
5838 /* We've now added another relocation. */
5839 ++sreloc
->reloc_count
;
5841 /* Make sure the output section is writable. The dynamic linker
5842 will be writing to it. */
5843 elf_section_data (input_section
->output_section
)->this_hdr
.sh_flags
5846 /* On IRIX5, make an entry of compact relocation info. */
5847 if (! skip
&& IRIX_COMPAT (output_bfd
) == ict_irix5
)
5849 asection
*scpt
= bfd_get_section_by_name (dynobj
, ".compact_rel");
5854 Elf32_crinfo cptrel
;
5856 mips_elf_set_cr_format (cptrel
, CRF_MIPS_LONG
);
5857 cptrel
.vaddr
= (rel
->r_offset
5858 + input_section
->output_section
->vma
5859 + input_section
->output_offset
);
5860 if (r_type
== R_MIPS_REL32
)
5861 mips_elf_set_cr_type (cptrel
, CRT_MIPS_REL32
);
5863 mips_elf_set_cr_type (cptrel
, CRT_MIPS_WORD
);
5864 mips_elf_set_cr_dist2to (cptrel
, 0);
5865 cptrel
.konst
= *addendp
;
5867 cr
= (scpt
->contents
5868 + sizeof (Elf32_External_compact_rel
));
5869 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
5870 ((Elf32_External_crinfo
*) cr
5871 + scpt
->reloc_count
));
5872 ++scpt
->reloc_count
;
5879 /* Calculate the value produced by the RELOCATION (which comes from
5880 the INPUT_BFD). The ADDEND is the addend to use for this
5881 RELOCATION; RELOCATION->R_ADDEND is ignored.
5883 The result of the relocation calculation is stored in VALUEP.
5884 REQUIRE_JALXP indicates whether or not the opcode used with this
5885 relocation must be JALX.
5887 This function returns bfd_reloc_continue if the caller need take no
5888 further action regarding this relocation, bfd_reloc_notsupported if
5889 something goes dramatically wrong, bfd_reloc_overflow if an
5890 overflow occurs, and bfd_reloc_ok to indicate success. */
5892 static bfd_reloc_status_type
5893 mips_elf_calculate_relocation (abfd
,
5907 asection
*input_section
;
5908 struct bfd_link_info
*info
;
5909 const Elf_Internal_Rela
*relocation
;
5911 reloc_howto_type
*howto
;
5912 Elf_Internal_Sym
*local_syms
;
5913 asection
**local_sections
;
5916 boolean
*require_jalxp
;
5918 /* The eventual value we will return. */
5920 /* The address of the symbol against which the relocation is
5923 /* The final GP value to be used for the relocatable, executable, or
5924 shared object file being produced. */
5925 bfd_vma gp
= (bfd_vma
) - 1;
5926 /* The place (section offset or address) of the storage unit being
5929 /* The value of GP used to create the relocatable object. */
5930 bfd_vma gp0
= (bfd_vma
) - 1;
5931 /* The offset into the global offset table at which the address of
5932 the relocation entry symbol, adjusted by the addend, resides
5933 during execution. */
5934 bfd_vma g
= (bfd_vma
) - 1;
5935 /* The section in which the symbol referenced by the relocation is
5937 asection
*sec
= NULL
;
5938 struct mips_elf_link_hash_entry
*h
= NULL
;
5939 /* True if the symbol referred to by this relocation is a local
5942 /* True if the symbol referred to by this relocation is "_gp_disp". */
5943 boolean gp_disp_p
= false;
5944 Elf_Internal_Shdr
*symtab_hdr
;
5946 unsigned long r_symndx
;
5948 /* True if overflow occurred during the calculation of the
5949 relocation value. */
5950 boolean overflowed_p
;
5951 /* True if this relocation refers to a MIPS16 function. */
5952 boolean target_is_16_bit_code_p
= false;
5954 /* Parse the relocation. */
5955 r_symndx
= ELF32_R_SYM (relocation
->r_info
);
5956 r_type
= ELF32_R_TYPE (relocation
->r_info
);
5957 p
= (input_section
->output_section
->vma
5958 + input_section
->output_offset
5959 + relocation
->r_offset
);
5961 /* Assume that there will be no overflow. */
5962 overflowed_p
= false;
5964 /* Figure out whether or not the symbol is local, and get the offset
5965 used in the array of hash table entries. */
5966 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
5967 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
5968 local_sections
, false);
5969 if (! elf_bad_symtab (input_bfd
))
5970 extsymoff
= symtab_hdr
->sh_info
;
5973 /* The symbol table does not follow the rule that local symbols
5974 must come before globals. */
5978 /* Figure out the value of the symbol. */
5981 Elf_Internal_Sym
*sym
;
5983 sym
= local_syms
+ r_symndx
;
5984 sec
= local_sections
[r_symndx
];
5986 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
5987 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
)
5988 symbol
+= sym
->st_value
;
5990 /* MIPS16 text labels should be treated as odd. */
5991 if (sym
->st_other
== STO_MIPS16
)
5994 /* Record the name of this symbol, for our caller. */
5995 *namep
= bfd_elf_string_from_elf_section (input_bfd
,
5996 symtab_hdr
->sh_link
,
5999 *namep
= bfd_section_name (input_bfd
, sec
);
6001 target_is_16_bit_code_p
= (sym
->st_other
== STO_MIPS16
);
6005 /* For global symbols we look up the symbol in the hash-table. */
6006 h
= ((struct mips_elf_link_hash_entry
*)
6007 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
]);
6008 /* Find the real hash-table entry for this symbol. */
6009 while (h
->root
.root
.type
== bfd_link_hash_indirect
6010 || h
->root
.root
.type
== bfd_link_hash_warning
)
6011 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
6013 /* Record the name of this symbol, for our caller. */
6014 *namep
= h
->root
.root
.root
.string
;
6016 /* See if this is the special _gp_disp symbol. Note that such a
6017 symbol must always be a global symbol. */
6018 if (strcmp (h
->root
.root
.root
.string
, "_gp_disp") == 0)
6020 /* Relocations against _gp_disp are permitted only with
6021 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
6022 if (r_type
!= R_MIPS_HI16
&& r_type
!= R_MIPS_LO16
)
6023 return bfd_reloc_notsupported
;
6027 /* If this symbol is defined, calculate its address. Note that
6028 _gp_disp is a magic symbol, always implicitly defined by the
6029 linker, so it's inappropriate to check to see whether or not
6031 else if ((h
->root
.root
.type
== bfd_link_hash_defined
6032 || h
->root
.root
.type
== bfd_link_hash_defweak
)
6033 && h
->root
.root
.u
.def
.section
)
6035 sec
= h
->root
.root
.u
.def
.section
;
6036 if (sec
->output_section
)
6037 symbol
= (h
->root
.root
.u
.def
.value
6038 + sec
->output_section
->vma
6039 + sec
->output_offset
);
6041 symbol
= h
->root
.root
.u
.def
.value
;
6043 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
6044 /* We allow relocations against undefined weak symbols, giving
6045 it the value zero, so that you can undefined weak functions
6046 and check to see if they exist by looking at their
6049 else if (info
->shared
&& !info
->symbolic
&& !info
->no_undefined
6050 && ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
6052 else if (strcmp (h
->root
.root
.root
.string
, "_DYNAMIC_LINK") == 0 ||
6053 strcmp (h
->root
.root
.root
.string
, "_DYNAMIC_LINKING") == 0)
6055 /* If this is a dynamic link, we should have created a
6056 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
6057 in in mips_elf_create_dynamic_sections.
6058 Otherwise, we should define the symbol with a value of 0.
6059 FIXME: It should probably get into the symbol table
6061 BFD_ASSERT (! info
->shared
);
6062 BFD_ASSERT (bfd_get_section_by_name (abfd
, ".dynamic") == NULL
);
6067 if (! ((*info
->callbacks
->undefined_symbol
)
6068 (info
, h
->root
.root
.root
.string
, input_bfd
,
6069 input_section
, relocation
->r_offset
,
6070 (!info
->shared
|| info
->no_undefined
6071 || ELF_ST_VISIBILITY (h
->root
.other
)))))
6072 return bfd_reloc_undefined
;
6076 target_is_16_bit_code_p
= (h
->root
.other
== STO_MIPS16
);
6079 /* If this is a 32-bit call to a 16-bit function with a stub, we
6080 need to redirect the call to the stub, unless we're already *in*
6082 if (r_type
!= R_MIPS16_26
&& !info
->relocateable
6083 && ((h
!= NULL
&& h
->fn_stub
!= NULL
)
6084 || (local_p
&& elf_tdata (input_bfd
)->local_stubs
!= NULL
6085 && elf_tdata (input_bfd
)->local_stubs
[r_symndx
] != NULL
))
6086 && !mips_elf_stub_section_p (input_bfd
, input_section
))
6088 /* This is a 32-bit call to a 16-bit function. We should
6089 have already noticed that we were going to need the
6092 sec
= elf_tdata (input_bfd
)->local_stubs
[r_symndx
];
6095 BFD_ASSERT (h
->need_fn_stub
);
6099 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
6101 /* If this is a 16-bit call to a 32-bit function with a stub, we
6102 need to redirect the call to the stub. */
6103 else if (r_type
== R_MIPS16_26
&& !info
->relocateable
6105 && (h
->call_stub
!= NULL
|| h
->call_fp_stub
!= NULL
)
6106 && !target_is_16_bit_code_p
)
6108 /* If both call_stub and call_fp_stub are defined, we can figure
6109 out which one to use by seeing which one appears in the input
6111 if (h
->call_stub
!= NULL
&& h
->call_fp_stub
!= NULL
)
6116 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6118 if (strncmp (bfd_get_section_name (input_bfd
, o
),
6119 CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
6121 sec
= h
->call_fp_stub
;
6128 else if (h
->call_stub
!= NULL
)
6131 sec
= h
->call_fp_stub
;
6133 BFD_ASSERT (sec
->_raw_size
> 0);
6134 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
6137 /* Calls from 16-bit code to 32-bit code and vice versa require the
6138 special jalx instruction. */
6139 *require_jalxp
= (!info
->relocateable
6140 && ((r_type
== R_MIPS16_26
) != target_is_16_bit_code_p
));
6142 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
6143 local_sections
, true);
6145 /* If we haven't already determined the GOT offset, or the GP value,
6146 and we're going to need it, get it now. */
6151 case R_MIPS_GOT_DISP
:
6152 case R_MIPS_GOT_HI16
:
6153 case R_MIPS_CALL_HI16
:
6154 case R_MIPS_GOT_LO16
:
6155 case R_MIPS_CALL_LO16
:
6156 /* Find the index into the GOT where this value is located. */
6159 BFD_ASSERT (addend
== 0);
6160 g
= mips_elf_global_got_index
6161 (elf_hash_table (info
)->dynobj
,
6162 (struct elf_link_hash_entry
*) h
);
6163 if (! elf_hash_table(info
)->dynamic_sections_created
6165 && (info
->symbolic
|| h
->root
.dynindx
== -1)
6166 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
6168 /* This is a static link or a -Bsymbolic link. The
6169 symbol is defined locally, or was forced to be local.
6170 We must initialize this entry in the GOT. */
6171 asection
*sgot
= mips_elf_got_section(elf_hash_table
6173 MIPS_ELF_PUT_WORD (elf_hash_table (info
)->dynobj
,
6174 symbol
+ addend
, sgot
->contents
+ g
);
6177 else if (r_type
== R_MIPS_GOT16
)
6178 /* There's no need to create a local GOT entry here; the
6179 calculation for a local GOT16 entry does not involve G. */
6183 g
= mips_elf_local_got_index (abfd
, info
, symbol
+ addend
);
6184 if (g
== (bfd_vma
) -1)
6188 /* Convert GOT indices to actual offsets. */
6189 g
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
6195 case R_MIPS_GPREL16
:
6196 case R_MIPS_GPREL32
:
6197 case R_MIPS_LITERAL
:
6198 gp0
= _bfd_get_gp_value (input_bfd
);
6199 gp
= _bfd_get_gp_value (abfd
);
6206 /* Figure out what kind of relocation is being performed. */
6210 return bfd_reloc_continue
;
6213 value
= symbol
+ mips_elf_sign_extend (addend
, 16);
6214 overflowed_p
= mips_elf_overflow_p (value
, 16);
6221 || (elf_hash_table (info
)->dynamic_sections_created
6223 && ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
)
6225 && (input_section
->flags
& SEC_ALLOC
) != 0)
6227 /* If we're creating a shared library, or this relocation is
6228 against a symbol in a shared library, then we can't know
6229 where the symbol will end up. So, we create a relocation
6230 record in the output, and leave the job up to the dynamic
6233 if (!mips_elf_create_dynamic_relocation (abfd
,
6240 input_section
, local_p
))
6245 if (r_type
!= R_MIPS_REL32
)
6246 value
= symbol
+ addend
;
6250 value
&= howto
->dst_mask
;
6255 case R_MIPS_GNU_REL_LO16
:
6256 value
= symbol
+ addend
- p
;
6257 value
&= howto
->dst_mask
;
6260 case R_MIPS_GNU_REL16_S2
:
6261 value
= symbol
+ mips_elf_sign_extend (addend
<< 2, 18) - p
;
6262 overflowed_p
= mips_elf_overflow_p (value
, 18);
6263 value
= (value
>> 2) & howto
->dst_mask
;
6266 case R_MIPS_GNU_REL_HI16
:
6267 value
= mips_elf_high (addend
+ symbol
- p
);
6268 value
&= howto
->dst_mask
;
6272 /* The calculation for R_MIPS_26 is just the same as for an
6273 R_MIPS_26. It's only the storage of the relocated field into
6274 the output file that's different. That's handled in
6275 mips_elf_perform_relocation. So, we just fall through to the
6276 R_MIPS_26 case here. */
6279 value
= (((addend
<< 2) | (p
& 0xf0000000)) + symbol
) >> 2;
6281 value
= (mips_elf_sign_extend (addend
<< 2, 28) + symbol
) >> 2;
6282 value
&= howto
->dst_mask
;
6288 value
= mips_elf_high (addend
+ symbol
);
6289 value
&= howto
->dst_mask
;
6293 value
= mips_elf_high (addend
+ gp
- p
);
6294 overflowed_p
= mips_elf_overflow_p (value
, 16);
6300 value
= (symbol
+ addend
) & howto
->dst_mask
;
6303 value
= addend
+ gp
- p
+ 4;
6304 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
6305 for overflow. But, on, say, Irix 5, relocations against
6306 _gp_disp are normally generated from the .cpload
6307 pseudo-op. It generates code that normally looks like
6310 lui $gp,%hi(_gp_disp)
6311 addiu $gp,$gp,%lo(_gp_disp)
6314 Here $t9 holds the address of the function being called,
6315 as required by the MIPS ELF ABI. The R_MIPS_LO16
6316 relocation can easily overflow in this situation, but the
6317 R_MIPS_HI16 relocation will handle the overflow.
6318 Therefore, we consider this a bug in the MIPS ABI, and do
6319 not check for overflow here. */
6323 case R_MIPS_LITERAL
:
6324 /* Because we don't merge literal sections, we can handle this
6325 just like R_MIPS_GPREL16. In the long run, we should merge
6326 shared literals, and then we will need to additional work
6331 case R_MIPS16_GPREL
:
6332 /* The R_MIPS16_GPREL performs the same calculation as
6333 R_MIPS_GPREL16, but stores the relocated bits in a different
6334 order. We don't need to do anything special here; the
6335 differences are handled in mips_elf_perform_relocation. */
6336 case R_MIPS_GPREL16
:
6338 value
= mips_elf_sign_extend (addend
, 16) + symbol
+ gp0
- gp
;
6340 value
= mips_elf_sign_extend (addend
, 16) + symbol
- gp
;
6341 overflowed_p
= mips_elf_overflow_p (value
, 16);
6349 /* The special case is when the symbol is forced to be local. We
6350 need the full address in the GOT since no R_MIPS_LO16 relocation
6352 forced
= ! mips_elf_local_relocation_p (input_bfd
, relocation
,
6353 local_sections
, false);
6354 value
= mips_elf_got16_entry (abfd
, info
, symbol
+ addend
, forced
);
6355 if (value
== (bfd_vma
) -1)
6358 = mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
6361 overflowed_p
= mips_elf_overflow_p (value
, 16);
6368 case R_MIPS_GOT_DISP
:
6370 overflowed_p
= mips_elf_overflow_p (value
, 16);
6373 case R_MIPS_GPREL32
:
6374 value
= (addend
+ symbol
+ gp0
- gp
) & howto
->dst_mask
;
6378 value
= mips_elf_sign_extend (addend
, 16) + symbol
- p
;
6379 value
= (bfd_vma
) ((bfd_signed_vma
) value
/ 4);
6380 overflowed_p
= mips_elf_overflow_p (value
, 16);
6383 case R_MIPS_GOT_HI16
:
6384 case R_MIPS_CALL_HI16
:
6385 /* We're allowed to handle these two relocations identically.
6386 The dynamic linker is allowed to handle the CALL relocations
6387 differently by creating a lazy evaluation stub. */
6389 value
= mips_elf_high (value
);
6390 value
&= howto
->dst_mask
;
6393 case R_MIPS_GOT_LO16
:
6394 case R_MIPS_CALL_LO16
:
6395 value
= g
& howto
->dst_mask
;
6398 case R_MIPS_GOT_PAGE
:
6399 value
= mips_elf_got_page (abfd
, info
, symbol
+ addend
, NULL
);
6400 if (value
== (bfd_vma
) -1)
6402 value
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
6405 overflowed_p
= mips_elf_overflow_p (value
, 16);
6408 case R_MIPS_GOT_OFST
:
6409 mips_elf_got_page (abfd
, info
, symbol
+ addend
, &value
);
6410 overflowed_p
= mips_elf_overflow_p (value
, 16);
6414 value
= symbol
- addend
;
6415 value
&= howto
->dst_mask
;
6419 value
= mips_elf_higher (addend
+ symbol
);
6420 value
&= howto
->dst_mask
;
6423 case R_MIPS_HIGHEST
:
6424 value
= mips_elf_highest (addend
+ symbol
);
6425 value
&= howto
->dst_mask
;
6428 case R_MIPS_SCN_DISP
:
6429 value
= symbol
+ addend
- sec
->output_offset
;
6430 value
&= howto
->dst_mask
;
6435 /* Both of these may be ignored. R_MIPS_JALR is an optimization
6436 hint; we could improve performance by honoring that hint. */
6437 return bfd_reloc_continue
;
6439 case R_MIPS_GNU_VTINHERIT
:
6440 case R_MIPS_GNU_VTENTRY
:
6441 /* We don't do anything with these at present. */
6442 return bfd_reloc_continue
;
6445 /* An unrecognized relocation type. */
6446 return bfd_reloc_notsupported
;
6449 /* Store the VALUE for our caller. */
6451 return overflowed_p
? bfd_reloc_overflow
: bfd_reloc_ok
;
6454 /* Obtain the field relocated by RELOCATION. */
6457 mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
)
6458 reloc_howto_type
*howto
;
6459 const Elf_Internal_Rela
*relocation
;
6464 bfd_byte
*location
= contents
+ relocation
->r_offset
;
6466 /* Obtain the bytes. */
6467 x
= bfd_get (8 * bfd_get_reloc_size (howto
), input_bfd
, location
);
6469 if ((ELF32_R_TYPE (relocation
->r_info
) == R_MIPS16_26
6470 || ELF32_R_TYPE (relocation
->r_info
) == R_MIPS16_GPREL
)
6471 && bfd_little_endian (input_bfd
))
6472 /* The two 16-bit words will be reversed on a little-endian
6473 system. See mips_elf_perform_relocation for more details. */
6474 x
= (((x
& 0xffff) << 16) | ((x
& 0xffff0000) >> 16));
6479 /* It has been determined that the result of the RELOCATION is the
6480 VALUE. Use HOWTO to place VALUE into the output file at the
6481 appropriate position. The SECTION is the section to which the
6482 relocation applies. If REQUIRE_JALX is true, then the opcode used
6483 for the relocation must be either JAL or JALX, and it is
6484 unconditionally converted to JALX.
6486 Returns false if anything goes wrong. */
6489 mips_elf_perform_relocation (info
, howto
, relocation
, value
,
6490 input_bfd
, input_section
,
6491 contents
, require_jalx
)
6492 struct bfd_link_info
*info
;
6493 reloc_howto_type
*howto
;
6494 const Elf_Internal_Rela
*relocation
;
6497 asection
*input_section
;
6499 boolean require_jalx
;
6503 int r_type
= ELF32_R_TYPE (relocation
->r_info
);
6505 /* Figure out where the relocation is occurring. */
6506 location
= contents
+ relocation
->r_offset
;
6508 /* Obtain the current value. */
6509 x
= mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
);
6511 /* Clear the field we are setting. */
6512 x
&= ~howto
->dst_mask
;
6514 /* If this is the R_MIPS16_26 relocation, we must store the
6515 value in a funny way. */
6516 if (r_type
== R_MIPS16_26
)
6518 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
6519 Most mips16 instructions are 16 bits, but these instructions
6522 The format of these instructions is:
6524 +--------------+--------------------------------+
6525 ! JALX ! X! Imm 20:16 ! Imm 25:21 !
6526 +--------------+--------------------------------+
6528 +-----------------------------------------------+
6530 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
6531 Note that the immediate value in the first word is swapped.
6533 When producing a relocateable object file, R_MIPS16_26 is
6534 handled mostly like R_MIPS_26. In particular, the addend is
6535 stored as a straight 26-bit value in a 32-bit instruction.
6536 (gas makes life simpler for itself by never adjusting a
6537 R_MIPS16_26 reloc to be against a section, so the addend is
6538 always zero). However, the 32 bit instruction is stored as 2
6539 16-bit values, rather than a single 32-bit value. In a
6540 big-endian file, the result is the same; in a little-endian
6541 file, the two 16-bit halves of the 32 bit value are swapped.
6542 This is so that a disassembler can recognize the jal
6545 When doing a final link, R_MIPS16_26 is treated as a 32 bit
6546 instruction stored as two 16-bit values. The addend A is the
6547 contents of the targ26 field. The calculation is the same as
6548 R_MIPS_26. When storing the calculated value, reorder the
6549 immediate value as shown above, and don't forget to store the
6550 value as two 16-bit values.
6552 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
6556 +--------+----------------------+
6560 +--------+----------------------+
6563 +----------+------+-------------+
6567 +----------+--------------------+
6568 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
6569 ((sub1 << 16) | sub2)).
6571 When producing a relocateable object file, the calculation is
6572 (((A < 2) | (P & 0xf0000000) + S) >> 2)
6573 When producing a fully linked file, the calculation is
6574 let R = (((A < 2) | (P & 0xf0000000) + S) >> 2)
6575 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff) */
6577 if (!info
->relocateable
)
6578 /* Shuffle the bits according to the formula above. */
6579 value
= (((value
& 0x1f0000) << 5)
6580 | ((value
& 0x3e00000) >> 5)
6581 | (value
& 0xffff));
6584 else if (r_type
== R_MIPS16_GPREL
)
6586 /* R_MIPS16_GPREL is used for GP-relative addressing in mips16
6587 mode. A typical instruction will have a format like this:
6589 +--------------+--------------------------------+
6590 ! EXTEND ! Imm 10:5 ! Imm 15:11 !
6591 +--------------+--------------------------------+
6592 ! Major ! rx ! ry ! Imm 4:0 !
6593 +--------------+--------------------------------+
6595 EXTEND is the five bit value 11110. Major is the instruction
6598 This is handled exactly like R_MIPS_GPREL16, except that the
6599 addend is retrieved and stored as shown in this diagram; that
6600 is, the Imm fields above replace the V-rel16 field.
6602 All we need to do here is shuffle the bits appropriately. As
6603 above, the two 16-bit halves must be swapped on a
6604 little-endian system. */
6605 value
= (((value
& 0x7e0) << 16)
6606 | ((value
& 0xf800) << 5)
6610 /* Set the field. */
6611 x
|= (value
& howto
->dst_mask
);
6613 /* If required, turn JAL into JALX. */
6617 bfd_vma opcode
= x
>> 26;
6618 bfd_vma jalx_opcode
;
6620 /* Check to see if the opcode is already JAL or JALX. */
6621 if (r_type
== R_MIPS16_26
)
6623 ok
= ((opcode
== 0x6) || (opcode
== 0x7));
6628 ok
= ((opcode
== 0x3) || (opcode
== 0x1d));
6632 /* If the opcode is not JAL or JALX, there's a problem. */
6635 (*_bfd_error_handler
)
6636 (_("%s: %s+0x%lx: jump to stub routine which is not jal"),
6637 bfd_get_filename (input_bfd
),
6638 input_section
->name
,
6639 (unsigned long) relocation
->r_offset
);
6640 bfd_set_error (bfd_error_bad_value
);
6644 /* Make this the JALX opcode. */
6645 x
= (x
& ~(0x3f << 26)) | (jalx_opcode
<< 26);
6648 /* Swap the high- and low-order 16 bits on little-endian systems
6649 when doing a MIPS16 relocation. */
6650 if ((r_type
== R_MIPS16_GPREL
|| r_type
== R_MIPS16_26
)
6651 && bfd_little_endian (input_bfd
))
6652 x
= (((x
& 0xffff) << 16) | ((x
& 0xffff0000) >> 16));
6654 /* Put the value into the output. */
6655 bfd_put (8 * bfd_get_reloc_size (howto
), input_bfd
, x
, location
);
6659 /* Returns true if SECTION is a MIPS16 stub section. */
6662 mips_elf_stub_section_p (abfd
, section
)
6663 bfd
*abfd ATTRIBUTE_UNUSED
;
6666 const char *name
= bfd_get_section_name (abfd
, section
);
6668 return (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0
6669 || strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
6670 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0);
6673 /* Relocate a MIPS ELF section. */
6676 _bfd_mips_elf_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
6677 contents
, relocs
, local_syms
, local_sections
)
6679 struct bfd_link_info
*info
;
6681 asection
*input_section
;
6683 Elf_Internal_Rela
*relocs
;
6684 Elf_Internal_Sym
*local_syms
;
6685 asection
**local_sections
;
6687 Elf_Internal_Rela
*rel
;
6688 const Elf_Internal_Rela
*relend
;
6690 boolean use_saved_addend_p
= false;
6691 struct elf_backend_data
*bed
;
6693 bed
= get_elf_backend_data (output_bfd
);
6694 relend
= relocs
+ input_section
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
6695 for (rel
= relocs
; rel
< relend
; ++rel
)
6699 reloc_howto_type
*howto
;
6700 boolean require_jalx
;
6701 /* True if the relocation is a RELA relocation, rather than a
6703 boolean rela_relocation_p
= true;
6704 int r_type
= ELF32_R_TYPE (rel
->r_info
);
6706 /* Find the relocation howto for this relocation. */
6707 if (r_type
== R_MIPS_64
&& !ABI_64_P (output_bfd
))
6709 /* Some 32-bit code uses R_MIPS_64. In particular, people use
6710 64-bit code, but make sure all their addresses are in the
6711 lowermost or uppermost 32-bit section of the 64-bit address
6712 space. Thus, when they use an R_MIPS_64 they mean what is
6713 usually meant by R_MIPS_32, with the exception that the
6714 stored value is sign-extended to 64 bits. */
6715 howto
= elf_mips_howto_table
+ R_MIPS_32
;
6717 /* On big-endian systems, we need to lie about the position
6719 if (bfd_big_endian (input_bfd
))
6723 howto
= mips_rtype_to_howto (r_type
);
6725 if (!use_saved_addend_p
)
6727 Elf_Internal_Shdr
*rel_hdr
;
6729 /* If these relocations were originally of the REL variety,
6730 we must pull the addend out of the field that will be
6731 relocated. Otherwise, we simply use the contents of the
6732 RELA relocation. To determine which flavor or relocation
6733 this is, we depend on the fact that the INPUT_SECTION's
6734 REL_HDR is read before its REL_HDR2. */
6735 rel_hdr
= &elf_section_data (input_section
)->rel_hdr
;
6736 if ((size_t) (rel
- relocs
)
6737 >= (rel_hdr
->sh_size
/ rel_hdr
->sh_entsize
6738 * bed
->s
->int_rels_per_ext_rel
))
6739 rel_hdr
= elf_section_data (input_section
)->rel_hdr2
;
6740 if (rel_hdr
->sh_entsize
== MIPS_ELF_REL_SIZE (input_bfd
))
6742 /* Note that this is a REL relocation. */
6743 rela_relocation_p
= false;
6745 /* Get the addend, which is stored in the input file. */
6746 addend
= mips_elf_obtain_contents (howto
,
6750 addend
&= howto
->src_mask
;
6752 /* For some kinds of relocations, the ADDEND is a
6753 combination of the addend stored in two different
6755 if (r_type
== R_MIPS_HI16
6756 || r_type
== R_MIPS_GNU_REL_HI16
6757 || (r_type
== R_MIPS_GOT16
6758 && mips_elf_local_relocation_p (input_bfd
, rel
,
6759 local_sections
, false)))
6762 const Elf_Internal_Rela
*lo16_relocation
;
6763 reloc_howto_type
*lo16_howto
;
6766 /* The combined value is the sum of the HI16 addend,
6767 left-shifted by sixteen bits, and the LO16
6768 addend, sign extended. (Usually, the code does
6769 a `lui' of the HI16 value, and then an `addiu' of
6772 Scan ahead to find a matching LO16 relocation. */
6773 if (r_type
== R_MIPS_GNU_REL_HI16
)
6774 lo
= R_MIPS_GNU_REL_LO16
;
6778 = mips_elf_next_relocation (lo
, rel
, relend
);
6779 if (lo16_relocation
== NULL
)
6782 /* Obtain the addend kept there. */
6783 lo16_howto
= mips_rtype_to_howto (lo
);
6784 l
= mips_elf_obtain_contents (lo16_howto
,
6786 input_bfd
, contents
);
6787 l
&= lo16_howto
->src_mask
;
6788 l
= mips_elf_sign_extend (l
, 16);
6792 /* Compute the combined addend. */
6795 else if (r_type
== R_MIPS16_GPREL
)
6797 /* The addend is scrambled in the object file. See
6798 mips_elf_perform_relocation for details on the
6800 addend
= (((addend
& 0x1f0000) >> 5)
6801 | ((addend
& 0x7e00000) >> 16)
6806 addend
= rel
->r_addend
;
6809 if (info
->relocateable
)
6811 Elf_Internal_Sym
*sym
;
6812 unsigned long r_symndx
;
6814 if (r_type
== R_MIPS_64
&& !ABI_64_P (output_bfd
)
6815 && bfd_big_endian (input_bfd
))
6818 /* Since we're just relocating, all we need to do is copy
6819 the relocations back out to the object file, unless
6820 they're against a section symbol, in which case we need
6821 to adjust by the section offset, or unless they're GP
6822 relative in which case we need to adjust by the amount
6823 that we're adjusting GP in this relocateable object. */
6825 if (!mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
,
6827 /* There's nothing to do for non-local relocations. */
6830 if (r_type
== R_MIPS16_GPREL
6831 || r_type
== R_MIPS_GPREL16
6832 || r_type
== R_MIPS_GPREL32
6833 || r_type
== R_MIPS_LITERAL
)
6834 addend
-= (_bfd_get_gp_value (output_bfd
)
6835 - _bfd_get_gp_value (input_bfd
));
6836 else if (r_type
== R_MIPS_26
|| r_type
== R_MIPS16_26
6837 || r_type
== R_MIPS_GNU_REL16_S2
)
6838 /* The addend is stored without its two least
6839 significant bits (which are always zero.) In a
6840 non-relocateable link, calculate_relocation will do
6841 this shift; here, we must do it ourselves. */
6844 r_symndx
= ELF32_R_SYM (rel
->r_info
);
6845 sym
= local_syms
+ r_symndx
;
6846 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6847 /* Adjust the addend appropriately. */
6848 addend
+= local_sections
[r_symndx
]->output_offset
;
6850 /* If the relocation is for a R_MIPS_HI16 or R_MIPS_GOT16,
6851 then we only want to write out the high-order 16 bits.
6852 The subsequent R_MIPS_LO16 will handle the low-order bits. */
6853 if (r_type
== R_MIPS_HI16
|| r_type
== R_MIPS_GOT16
6854 || r_type
== R_MIPS_GNU_REL_HI16
)
6855 addend
= mips_elf_high (addend
);
6856 /* If the relocation is for an R_MIPS_26 relocation, then
6857 the two low-order bits are not stored in the object file;
6858 they are implicitly zero. */
6859 else if (r_type
== R_MIPS_26
|| r_type
== R_MIPS16_26
6860 || r_type
== R_MIPS_GNU_REL16_S2
)
6863 if (rela_relocation_p
)
6864 /* If this is a RELA relocation, just update the addend.
6865 We have to cast away constness for REL. */
6866 rel
->r_addend
= addend
;
6869 /* Otherwise, we have to write the value back out. Note
6870 that we use the source mask, rather than the
6871 destination mask because the place to which we are
6872 writing will be source of the addend in the final
6874 addend
&= howto
->src_mask
;
6876 if (r_type
== R_MIPS_64
&& !ABI_64_P (output_bfd
))
6877 /* See the comment above about using R_MIPS_64 in the 32-bit
6878 ABI. Here, we need to update the addend. It would be
6879 possible to get away with just using the R_MIPS_32 reloc
6880 but for endianness. */
6886 if (addend
& ((bfd_vma
) 1 << 31))
6887 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
6891 /* If we don't know that we have a 64-bit type,
6892 do two separate stores. */
6893 if (bfd_big_endian (input_bfd
))
6895 /* Store the sign-bits (which are most significant)
6897 low_bits
= sign_bits
;
6903 high_bits
= sign_bits
;
6905 bfd_put_32 (input_bfd
, low_bits
,
6906 contents
+ rel
->r_offset
);
6907 bfd_put_32 (input_bfd
, high_bits
,
6908 contents
+ rel
->r_offset
+ 4);
6912 if (!mips_elf_perform_relocation (info
, howto
, rel
, addend
,
6913 input_bfd
, input_section
,
6918 /* Go on to the next relocation. */
6922 /* In the N32 and 64-bit ABIs there may be multiple consecutive
6923 relocations for the same offset. In that case we are
6924 supposed to treat the output of each relocation as the addend
6926 if (rel
+ 1 < relend
6927 && rel
->r_offset
== rel
[1].r_offset
6928 && ELF32_R_TYPE (rel
[1].r_info
) != R_MIPS_NONE
)
6929 use_saved_addend_p
= true;
6931 use_saved_addend_p
= false;
6933 /* Figure out what value we are supposed to relocate. */
6934 switch (mips_elf_calculate_relocation (output_bfd
,
6947 case bfd_reloc_continue
:
6948 /* There's nothing to do. */
6951 case bfd_reloc_undefined
:
6952 /* mips_elf_calculate_relocation already called the
6953 undefined_symbol callback. There's no real point in
6954 trying to perform the relocation at this point, so we
6955 just skip ahead to the next relocation. */
6958 case bfd_reloc_notsupported
:
6962 case bfd_reloc_overflow
:
6963 if (use_saved_addend_p
)
6964 /* Ignore overflow until we reach the last relocation for
6965 a given location. */
6969 BFD_ASSERT (name
!= NULL
);
6970 if (! ((*info
->callbacks
->reloc_overflow
)
6971 (info
, name
, howto
->name
, (bfd_vma
) 0,
6972 input_bfd
, input_section
, rel
->r_offset
)))
6985 /* If we've got another relocation for the address, keep going
6986 until we reach the last one. */
6987 if (use_saved_addend_p
)
6993 if (r_type
== R_MIPS_64
&& !ABI_64_P (output_bfd
))
6994 /* See the comment above about using R_MIPS_64 in the 32-bit
6995 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
6996 that calculated the right value. Now, however, we
6997 sign-extend the 32-bit result to 64-bits, and store it as a
6998 64-bit value. We are especially generous here in that we
6999 go to extreme lengths to support this usage on systems with
7000 only a 32-bit VMA. */
7006 if (value
& ((bfd_vma
) 1 << 31))
7007 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
7011 /* If we don't know that we have a 64-bit type,
7012 do two separate stores. */
7013 if (bfd_big_endian (input_bfd
))
7015 /* Undo what we did above. */
7017 /* Store the sign-bits (which are most significant)
7019 low_bits
= sign_bits
;
7025 high_bits
= sign_bits
;
7027 bfd_put_32 (input_bfd
, low_bits
,
7028 contents
+ rel
->r_offset
);
7029 bfd_put_32 (input_bfd
, high_bits
,
7030 contents
+ rel
->r_offset
+ 4);
7034 /* Actually perform the relocation. */
7035 if (!mips_elf_perform_relocation (info
, howto
, rel
, value
, input_bfd
,
7036 input_section
, contents
,
7044 /* This hook function is called before the linker writes out a global
7045 symbol. We mark symbols as small common if appropriate. This is
7046 also where we undo the increment of the value for a mips16 symbol. */
7049 _bfd_mips_elf_link_output_symbol_hook (abfd
, info
, name
, sym
, input_sec
)
7050 bfd
*abfd ATTRIBUTE_UNUSED
;
7051 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
7052 const char *name ATTRIBUTE_UNUSED
;
7053 Elf_Internal_Sym
*sym
;
7054 asection
*input_sec
;
7056 /* If we see a common symbol, which implies a relocatable link, then
7057 if a symbol was small common in an input file, mark it as small
7058 common in the output file. */
7059 if (sym
->st_shndx
== SHN_COMMON
7060 && strcmp (input_sec
->name
, ".scommon") == 0)
7061 sym
->st_shndx
= SHN_MIPS_SCOMMON
;
7063 if (sym
->st_other
== STO_MIPS16
7064 && (sym
->st_value
& 1) != 0)
7070 /* Functions for the dynamic linker. */
7072 /* The name of the dynamic interpreter. This is put in the .interp
7075 #define ELF_DYNAMIC_INTERPRETER(abfd) \
7076 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
7077 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
7078 : "/usr/lib/libc.so.1")
7080 /* Create dynamic sections when linking against a dynamic object. */
7083 _bfd_mips_elf_create_dynamic_sections (abfd
, info
)
7085 struct bfd_link_info
*info
;
7087 struct elf_link_hash_entry
*h
;
7089 register asection
*s
;
7090 const char * const *namep
;
7092 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
7093 | SEC_LINKER_CREATED
| SEC_READONLY
);
7095 /* Mips ABI requests the .dynamic section to be read only. */
7096 s
= bfd_get_section_by_name (abfd
, ".dynamic");
7099 if (! bfd_set_section_flags (abfd
, s
, flags
))
7103 /* We need to create .got section. */
7104 if (! mips_elf_create_got_section (abfd
, info
))
7107 /* Create the .msym section on IRIX6. It is used by the dynamic
7108 linker to speed up dynamic relocations, and to avoid computing
7109 the ELF hash for symbols. */
7110 if (IRIX_COMPAT (abfd
) == ict_irix6
7111 && !mips_elf_create_msym_section (abfd
))
7114 /* Create .stub section. */
7115 if (bfd_get_section_by_name (abfd
,
7116 MIPS_ELF_STUB_SECTION_NAME (abfd
)) == NULL
)
7118 s
= bfd_make_section (abfd
, MIPS_ELF_STUB_SECTION_NAME (abfd
));
7120 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_CODE
)
7121 || ! bfd_set_section_alignment (abfd
, s
,
7122 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
7126 if ((IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
7128 && bfd_get_section_by_name (abfd
, ".rld_map") == NULL
)
7130 s
= bfd_make_section (abfd
, ".rld_map");
7132 || ! bfd_set_section_flags (abfd
, s
, flags
& ~SEC_READONLY
)
7133 || ! bfd_set_section_alignment (abfd
, s
,
7134 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
7138 /* On IRIX5, we adjust add some additional symbols and change the
7139 alignments of several sections. There is no ABI documentation
7140 indicating that this is necessary on IRIX6, nor any evidence that
7141 the linker takes such action. */
7142 if (IRIX_COMPAT (abfd
) == ict_irix5
)
7144 for (namep
= mips_elf_dynsym_rtproc_names
; *namep
!= NULL
; namep
++)
7147 if (! (_bfd_generic_link_add_one_symbol
7148 (info
, abfd
, *namep
, BSF_GLOBAL
, bfd_und_section_ptr
,
7149 (bfd_vma
) 0, (const char *) NULL
, false,
7150 get_elf_backend_data (abfd
)->collect
,
7151 (struct bfd_link_hash_entry
**) &h
)))
7153 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
7154 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
7155 h
->type
= STT_SECTION
;
7157 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
7161 /* We need to create a .compact_rel section. */
7162 if (SGI_COMPAT (abfd
))
7164 if (!mips_elf_create_compact_rel_section (abfd
, info
))
7168 /* Change aligments of some sections. */
7169 s
= bfd_get_section_by_name (abfd
, ".hash");
7171 bfd_set_section_alignment (abfd
, s
, 4);
7172 s
= bfd_get_section_by_name (abfd
, ".dynsym");
7174 bfd_set_section_alignment (abfd
, s
, 4);
7175 s
= bfd_get_section_by_name (abfd
, ".dynstr");
7177 bfd_set_section_alignment (abfd
, s
, 4);
7178 s
= bfd_get_section_by_name (abfd
, ".reginfo");
7180 bfd_set_section_alignment (abfd
, s
, 4);
7181 s
= bfd_get_section_by_name (abfd
, ".dynamic");
7183 bfd_set_section_alignment (abfd
, s
, 4);
7189 if (SGI_COMPAT (abfd
))
7191 if (!(_bfd_generic_link_add_one_symbol
7192 (info
, abfd
, "_DYNAMIC_LINK", BSF_GLOBAL
, bfd_abs_section_ptr
,
7193 (bfd_vma
) 0, (const char *) NULL
, false,
7194 get_elf_backend_data (abfd
)->collect
,
7195 (struct bfd_link_hash_entry
**) &h
)))
7200 /* For normal mips it is _DYNAMIC_LINKING. */
7201 if (!(_bfd_generic_link_add_one_symbol
7202 (info
, abfd
, "_DYNAMIC_LINKING", BSF_GLOBAL
,
7203 bfd_abs_section_ptr
, (bfd_vma
) 0, (const char *) NULL
, false,
7204 get_elf_backend_data (abfd
)->collect
,
7205 (struct bfd_link_hash_entry
**) &h
)))
7208 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
7209 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
7210 h
->type
= STT_SECTION
;
7212 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
7215 if (! mips_elf_hash_table (info
)->use_rld_obj_head
)
7217 /* __rld_map is a four byte word located in the .data section
7218 and is filled in by the rtld to contain a pointer to
7219 the _r_debug structure. Its symbol value will be set in
7220 mips_elf_finish_dynamic_symbol. */
7221 s
= bfd_get_section_by_name (abfd
, ".rld_map");
7222 BFD_ASSERT (s
!= NULL
);
7225 if (SGI_COMPAT (abfd
))
7227 if (!(_bfd_generic_link_add_one_symbol
7228 (info
, abfd
, "__rld_map", BSF_GLOBAL
, s
,
7229 (bfd_vma
) 0, (const char *) NULL
, false,
7230 get_elf_backend_data (abfd
)->collect
,
7231 (struct bfd_link_hash_entry
**) &h
)))
7236 /* For normal mips the symbol is __RLD_MAP. */
7237 if (!(_bfd_generic_link_add_one_symbol
7238 (info
, abfd
, "__RLD_MAP", BSF_GLOBAL
, s
,
7239 (bfd_vma
) 0, (const char *) NULL
, false,
7240 get_elf_backend_data (abfd
)->collect
,
7241 (struct bfd_link_hash_entry
**) &h
)))
7244 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
7245 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
7246 h
->type
= STT_OBJECT
;
7248 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
7256 /* Create the .compact_rel section. */
7259 mips_elf_create_compact_rel_section (abfd
, info
)
7261 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
7264 register asection
*s
;
7266 if (bfd_get_section_by_name (abfd
, ".compact_rel") == NULL
)
7268 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
7271 s
= bfd_make_section (abfd
, ".compact_rel");
7273 || ! bfd_set_section_flags (abfd
, s
, flags
)
7274 || ! bfd_set_section_alignment (abfd
, s
,
7275 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
7278 s
->_raw_size
= sizeof (Elf32_External_compact_rel
);
7284 /* Create the .got section to hold the global offset table. */
7287 mips_elf_create_got_section (abfd
, info
)
7289 struct bfd_link_info
*info
;
7292 register asection
*s
;
7293 struct elf_link_hash_entry
*h
;
7294 struct mips_got_info
*g
;
7296 /* This function may be called more than once. */
7297 if (mips_elf_got_section (abfd
))
7300 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
7301 | SEC_LINKER_CREATED
);
7303 s
= bfd_make_section (abfd
, ".got");
7305 || ! bfd_set_section_flags (abfd
, s
, flags
)
7306 || ! bfd_set_section_alignment (abfd
, s
, 4))
7309 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
7310 linker script because we don't want to define the symbol if we
7311 are not creating a global offset table. */
7313 if (! (_bfd_generic_link_add_one_symbol
7314 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
7315 (bfd_vma
) 0, (const char *) NULL
, false,
7316 get_elf_backend_data (abfd
)->collect
,
7317 (struct bfd_link_hash_entry
**) &h
)))
7319 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
7320 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
7321 h
->type
= STT_OBJECT
;
7324 && ! bfd_elf32_link_record_dynamic_symbol (info
, h
))
7327 /* The first several global offset table entries are reserved. */
7328 s
->_raw_size
= MIPS_RESERVED_GOTNO
* MIPS_ELF_GOT_SIZE (abfd
);
7330 g
= (struct mips_got_info
*) bfd_alloc (abfd
,
7331 sizeof (struct mips_got_info
));
7334 g
->global_gotsym
= NULL
;
7335 g
->local_gotno
= MIPS_RESERVED_GOTNO
;
7336 g
->assigned_gotno
= MIPS_RESERVED_GOTNO
;
7337 if (elf_section_data (s
) == NULL
)
7340 (PTR
) bfd_zalloc (abfd
, sizeof (struct bfd_elf_section_data
));
7341 if (elf_section_data (s
) == NULL
)
7344 elf_section_data (s
)->tdata
= (PTR
) g
;
7345 elf_section_data (s
)->this_hdr
.sh_flags
7346 |= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
7351 /* Returns the .msym section for ABFD, creating it if it does not
7352 already exist. Returns NULL to indicate error. */
7355 mips_elf_create_msym_section (abfd
)
7360 s
= bfd_get_section_by_name (abfd
, MIPS_ELF_MSYM_SECTION_NAME (abfd
));
7363 s
= bfd_make_section (abfd
, MIPS_ELF_MSYM_SECTION_NAME (abfd
));
7365 || !bfd_set_section_flags (abfd
, s
,
7369 | SEC_LINKER_CREATED
7371 || !bfd_set_section_alignment (abfd
, s
,
7372 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
7379 /* Add room for N relocations to the .rel.dyn section in ABFD. */
7382 mips_elf_allocate_dynamic_relocations (abfd
, n
)
7388 s
= bfd_get_section_by_name (abfd
, MIPS_ELF_REL_DYN_SECTION_NAME (abfd
));
7389 BFD_ASSERT (s
!= NULL
);
7391 if (s
->_raw_size
== 0)
7393 /* Make room for a null element. */
7394 s
->_raw_size
+= MIPS_ELF_REL_SIZE (abfd
);
7397 s
->_raw_size
+= n
* MIPS_ELF_REL_SIZE (abfd
);
7400 /* Look through the relocs for a section during the first phase, and
7401 allocate space in the global offset table. */
7404 _bfd_mips_elf_check_relocs (abfd
, info
, sec
, relocs
)
7406 struct bfd_link_info
*info
;
7408 const Elf_Internal_Rela
*relocs
;
7412 Elf_Internal_Shdr
*symtab_hdr
;
7413 struct elf_link_hash_entry
**sym_hashes
;
7414 struct mips_got_info
*g
;
7416 const Elf_Internal_Rela
*rel
;
7417 const Elf_Internal_Rela
*rel_end
;
7420 struct elf_backend_data
*bed
;
7422 if (info
->relocateable
)
7425 dynobj
= elf_hash_table (info
)->dynobj
;
7426 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7427 sym_hashes
= elf_sym_hashes (abfd
);
7428 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
7430 /* Check for the mips16 stub sections. */
7432 name
= bfd_get_section_name (abfd
, sec
);
7433 if (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0)
7435 unsigned long r_symndx
;
7437 /* Look at the relocation information to figure out which symbol
7440 r_symndx
= ELF32_R_SYM (relocs
->r_info
);
7442 if (r_symndx
< extsymoff
7443 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
7447 /* This stub is for a local symbol. This stub will only be
7448 needed if there is some relocation in this BFD, other
7449 than a 16 bit function call, which refers to this symbol. */
7450 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
7452 Elf_Internal_Rela
*sec_relocs
;
7453 const Elf_Internal_Rela
*r
, *rend
;
7455 /* We can ignore stub sections when looking for relocs. */
7456 if ((o
->flags
& SEC_RELOC
) == 0
7457 || o
->reloc_count
== 0
7458 || strncmp (bfd_get_section_name (abfd
, o
), FN_STUB
,
7459 sizeof FN_STUB
- 1) == 0
7460 || strncmp (bfd_get_section_name (abfd
, o
), CALL_STUB
,
7461 sizeof CALL_STUB
- 1) == 0
7462 || strncmp (bfd_get_section_name (abfd
, o
), CALL_FP_STUB
,
7463 sizeof CALL_FP_STUB
- 1) == 0)
7466 sec_relocs
= (_bfd_elf32_link_read_relocs
7467 (abfd
, o
, (PTR
) NULL
,
7468 (Elf_Internal_Rela
*) NULL
,
7469 info
->keep_memory
));
7470 if (sec_relocs
== NULL
)
7473 rend
= sec_relocs
+ o
->reloc_count
;
7474 for (r
= sec_relocs
; r
< rend
; r
++)
7475 if (ELF32_R_SYM (r
->r_info
) == r_symndx
7476 && ELF32_R_TYPE (r
->r_info
) != R_MIPS16_26
)
7479 if (! info
->keep_memory
)
7488 /* There is no non-call reloc for this stub, so we do
7489 not need it. Since this function is called before
7490 the linker maps input sections to output sections, we
7491 can easily discard it by setting the SEC_EXCLUDE
7493 sec
->flags
|= SEC_EXCLUDE
;
7497 /* Record this stub in an array of local symbol stubs for
7499 if (elf_tdata (abfd
)->local_stubs
== NULL
)
7501 unsigned long symcount
;
7504 if (elf_bad_symtab (abfd
))
7505 symcount
= symtab_hdr
->sh_size
/ symtab_hdr
->sh_entsize
;
7507 symcount
= symtab_hdr
->sh_info
;
7508 n
= (asection
**) bfd_zalloc (abfd
,
7509 symcount
* sizeof (asection
*));
7512 elf_tdata (abfd
)->local_stubs
= n
;
7515 elf_tdata (abfd
)->local_stubs
[r_symndx
] = sec
;
7517 /* We don't need to set mips16_stubs_seen in this case.
7518 That flag is used to see whether we need to look through
7519 the global symbol table for stubs. We don't need to set
7520 it here, because we just have a local stub. */
7524 struct mips_elf_link_hash_entry
*h
;
7526 h
= ((struct mips_elf_link_hash_entry
*)
7527 sym_hashes
[r_symndx
- extsymoff
]);
7529 /* H is the symbol this stub is for. */
7532 mips_elf_hash_table (info
)->mips16_stubs_seen
= true;
7535 else if (strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
7536 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
7538 unsigned long r_symndx
;
7539 struct mips_elf_link_hash_entry
*h
;
7542 /* Look at the relocation information to figure out which symbol
7545 r_symndx
= ELF32_R_SYM (relocs
->r_info
);
7547 if (r_symndx
< extsymoff
7548 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
7550 /* This stub was actually built for a static symbol defined
7551 in the same file. We assume that all static symbols in
7552 mips16 code are themselves mips16, so we can simply
7553 discard this stub. Since this function is called before
7554 the linker maps input sections to output sections, we can
7555 easily discard it by setting the SEC_EXCLUDE flag. */
7556 sec
->flags
|= SEC_EXCLUDE
;
7560 h
= ((struct mips_elf_link_hash_entry
*)
7561 sym_hashes
[r_symndx
- extsymoff
]);
7563 /* H is the symbol this stub is for. */
7565 if (strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
7566 loc
= &h
->call_fp_stub
;
7568 loc
= &h
->call_stub
;
7570 /* If we already have an appropriate stub for this function, we
7571 don't need another one, so we can discard this one. Since
7572 this function is called before the linker maps input sections
7573 to output sections, we can easily discard it by setting the
7574 SEC_EXCLUDE flag. We can also discard this section if we
7575 happen to already know that this is a mips16 function; it is
7576 not necessary to check this here, as it is checked later, but
7577 it is slightly faster to check now. */
7578 if (*loc
!= NULL
|| h
->root
.other
== STO_MIPS16
)
7580 sec
->flags
|= SEC_EXCLUDE
;
7585 mips_elf_hash_table (info
)->mips16_stubs_seen
= true;
7595 sgot
= mips_elf_got_section (dynobj
);
7600 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
7601 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
7602 BFD_ASSERT (g
!= NULL
);
7607 bed
= get_elf_backend_data (abfd
);
7608 rel_end
= relocs
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
7609 for (rel
= relocs
; rel
< rel_end
; ++rel
)
7611 unsigned long r_symndx
;
7613 struct elf_link_hash_entry
*h
;
7615 r_symndx
= ELF32_R_SYM (rel
->r_info
);
7616 r_type
= ELF32_R_TYPE (rel
->r_info
);
7618 if (r_symndx
< extsymoff
)
7620 else if (r_symndx
>= extsymoff
+ (symtab_hdr
->sh_size
/ symtab_hdr
->sh_entsize
))
7622 (*_bfd_error_handler
)
7623 (_("Malformed reloc detected for section %s"), name
);
7624 bfd_set_error (bfd_error_bad_value
);
7629 h
= sym_hashes
[r_symndx
- extsymoff
];
7631 /* This may be an indirect symbol created because of a version. */
7634 while (h
->root
.type
== bfd_link_hash_indirect
)
7635 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
7639 /* Some relocs require a global offset table. */
7640 if (dynobj
== NULL
|| sgot
== NULL
)
7646 case R_MIPS_CALL_HI16
:
7647 case R_MIPS_CALL_LO16
:
7648 case R_MIPS_GOT_HI16
:
7649 case R_MIPS_GOT_LO16
:
7650 case R_MIPS_GOT_PAGE
:
7651 case R_MIPS_GOT_OFST
:
7652 case R_MIPS_GOT_DISP
:
7654 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
7655 if (! mips_elf_create_got_section (dynobj
, info
))
7657 g
= mips_elf_got_info (dynobj
, &sgot
);
7664 && (info
->shared
|| h
!= NULL
)
7665 && (sec
->flags
& SEC_ALLOC
) != 0)
7666 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
7674 if (!h
&& (r_type
== R_MIPS_CALL_LO16
7675 || r_type
== R_MIPS_GOT_LO16
7676 || r_type
== R_MIPS_GOT_DISP
))
7678 /* We may need a local GOT entry for this relocation. We
7679 don't count R_MIPS_GOT_PAGE because we can estimate the
7680 maximum number of pages needed by looking at the size of
7681 the segment. Similar comments apply to R_MIPS_GOT16. We
7682 don't count R_MIPS_GOT_HI16, or R_MIPS_CALL_HI16 because
7683 these are always followed by an R_MIPS_GOT_LO16 or
7686 This estimation is very conservative since we can merge
7687 duplicate entries in the GOT. In order to be less
7688 conservative, we could actually build the GOT here,
7689 rather than in relocate_section. */
7691 sgot
->_raw_size
+= MIPS_ELF_GOT_SIZE (dynobj
);
7699 (*_bfd_error_handler
)
7700 (_("%s: CALL16 reloc at 0x%lx not against global symbol"),
7701 bfd_get_filename (abfd
), (unsigned long) rel
->r_offset
);
7702 bfd_set_error (bfd_error_bad_value
);
7707 case R_MIPS_CALL_HI16
:
7708 case R_MIPS_CALL_LO16
:
7711 /* This symbol requires a global offset table entry. */
7712 if (!mips_elf_record_global_got_symbol (h
, info
, g
))
7715 /* We need a stub, not a plt entry for the undefined
7716 function. But we record it as if it needs plt. See
7717 elf_adjust_dynamic_symbol in elflink.h. */
7718 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
7724 case R_MIPS_GOT_HI16
:
7725 case R_MIPS_GOT_LO16
:
7726 case R_MIPS_GOT_DISP
:
7727 /* This symbol requires a global offset table entry. */
7728 if (h
&& !mips_elf_record_global_got_symbol (h
, info
, g
))
7735 if ((info
->shared
|| h
!= NULL
)
7736 && (sec
->flags
& SEC_ALLOC
) != 0)
7740 const char *name
= MIPS_ELF_REL_DYN_SECTION_NAME (dynobj
);
7742 sreloc
= bfd_get_section_by_name (dynobj
, name
);
7745 sreloc
= bfd_make_section (dynobj
, name
);
7747 || ! bfd_set_section_flags (dynobj
, sreloc
,
7752 | SEC_LINKER_CREATED
7754 || ! bfd_set_section_alignment (dynobj
, sreloc
,
7760 /* When creating a shared object, we must copy these
7761 reloc types into the output file as R_MIPS_REL32
7762 relocs. We make room for this reloc in the
7763 .rel.dyn reloc section. */
7764 mips_elf_allocate_dynamic_relocations (dynobj
, 1);
7767 struct mips_elf_link_hash_entry
*hmips
;
7769 /* We only need to copy this reloc if the symbol is
7770 defined in a dynamic object. */
7771 hmips
= (struct mips_elf_link_hash_entry
*) h
;
7772 ++hmips
->possibly_dynamic_relocs
;
7775 /* Even though we don't directly need a GOT entry for
7776 this symbol, a symbol must have a dynamic symbol
7777 table index greater that DT_MIPS_GOTSYM if there are
7778 dynamic relocations against it. */
7780 && !mips_elf_record_global_got_symbol (h
, info
, g
))
7784 if (SGI_COMPAT (abfd
))
7785 mips_elf_hash_table (info
)->compact_rel_size
+=
7786 sizeof (Elf32_External_crinfo
);
7790 case R_MIPS_GPREL16
:
7791 case R_MIPS_LITERAL
:
7792 case R_MIPS_GPREL32
:
7793 if (SGI_COMPAT (abfd
))
7794 mips_elf_hash_table (info
)->compact_rel_size
+=
7795 sizeof (Elf32_External_crinfo
);
7798 /* This relocation describes the C++ object vtable hierarchy.
7799 Reconstruct it for later use during GC. */
7800 case R_MIPS_GNU_VTINHERIT
:
7801 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
7805 /* This relocation describes which C++ vtable entries are actually
7806 used. Record for later use during GC. */
7807 case R_MIPS_GNU_VTENTRY
:
7808 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
7816 /* If this reloc is not a 16 bit call, and it has a global
7817 symbol, then we will need the fn_stub if there is one.
7818 References from a stub section do not count. */
7820 && r_type
!= R_MIPS16_26
7821 && strncmp (bfd_get_section_name (abfd
, sec
), FN_STUB
,
7822 sizeof FN_STUB
- 1) != 0
7823 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_STUB
,
7824 sizeof CALL_STUB
- 1) != 0
7825 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_FP_STUB
,
7826 sizeof CALL_FP_STUB
- 1) != 0)
7828 struct mips_elf_link_hash_entry
*mh
;
7830 mh
= (struct mips_elf_link_hash_entry
*) h
;
7831 mh
->need_fn_stub
= true;
7838 /* Return the section that should be marked against GC for a given
7842 _bfd_mips_elf_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
7844 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
7845 Elf_Internal_Rela
*rel
;
7846 struct elf_link_hash_entry
*h
;
7847 Elf_Internal_Sym
*sym
;
7849 /* ??? Do mips16 stub sections need to be handled special? */
7853 switch (ELF32_R_TYPE (rel
->r_info
))
7855 case R_MIPS_GNU_VTINHERIT
:
7856 case R_MIPS_GNU_VTENTRY
:
7860 switch (h
->root
.type
)
7862 case bfd_link_hash_defined
:
7863 case bfd_link_hash_defweak
:
7864 return h
->root
.u
.def
.section
;
7866 case bfd_link_hash_common
:
7867 return h
->root
.u
.c
.p
->section
;
7876 if (!(elf_bad_symtab (abfd
)
7877 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
7878 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
7879 && sym
->st_shndx
!= SHN_COMMON
))
7881 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
7888 /* Update the got entry reference counts for the section being removed. */
7891 _bfd_mips_elf_gc_sweep_hook (abfd
, info
, sec
, relocs
)
7892 bfd
*abfd ATTRIBUTE_UNUSED
;
7893 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
7894 asection
*sec ATTRIBUTE_UNUSED
;
7895 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
;
7898 Elf_Internal_Shdr
*symtab_hdr
;
7899 struct elf_link_hash_entry
**sym_hashes
;
7900 bfd_signed_vma
*local_got_refcounts
;
7901 const Elf_Internal_Rela
*rel
, *relend
;
7902 unsigned long r_symndx
;
7903 struct elf_link_hash_entry
*h
;
7905 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7906 sym_hashes
= elf_sym_hashes (abfd
);
7907 local_got_refcounts
= elf_local_got_refcounts (abfd
);
7909 relend
= relocs
+ sec
->reloc_count
;
7910 for (rel
= relocs
; rel
< relend
; rel
++)
7911 switch (ELF32_R_TYPE (rel
->r_info
))
7915 case R_MIPS_CALL_HI16
:
7916 case R_MIPS_CALL_LO16
:
7917 case R_MIPS_GOT_HI16
:
7918 case R_MIPS_GOT_LO16
:
7919 /* ??? It would seem that the existing MIPS code does no sort
7920 of reference counting or whatnot on its GOT and PLT entries,
7921 so it is not possible to garbage collect them at this time. */
7932 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
7933 hiding the old indirect symbol. Process additional relocation
7937 _bfd_mips_elf_copy_indirect_symbol (dir
, ind
)
7938 struct elf_link_hash_entry
*dir
, *ind
;
7940 struct mips_elf_link_hash_entry
*dirmips
, *indmips
;
7942 _bfd_elf_link_hash_copy_indirect (dir
, ind
);
7944 dirmips
= (struct mips_elf_link_hash_entry
*) dir
;
7945 indmips
= (struct mips_elf_link_hash_entry
*) ind
;
7946 dirmips
->possibly_dynamic_relocs
+= indmips
->possibly_dynamic_relocs
;
7947 if (dirmips
->min_dyn_reloc_index
== 0
7948 || (indmips
->min_dyn_reloc_index
!= 0
7949 && indmips
->min_dyn_reloc_index
< dirmips
->min_dyn_reloc_index
))
7950 dirmips
->min_dyn_reloc_index
= indmips
->min_dyn_reloc_index
;
7953 /* Adjust a symbol defined by a dynamic object and referenced by a
7954 regular object. The current definition is in some section of the
7955 dynamic object, but we're not including those sections. We have to
7956 change the definition to something the rest of the link can
7960 _bfd_mips_elf_adjust_dynamic_symbol (info
, h
)
7961 struct bfd_link_info
*info
;
7962 struct elf_link_hash_entry
*h
;
7965 struct mips_elf_link_hash_entry
*hmips
;
7968 dynobj
= elf_hash_table (info
)->dynobj
;
7970 /* Make sure we know what is going on here. */
7971 BFD_ASSERT (dynobj
!= NULL
7972 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
7973 || h
->weakdef
!= NULL
7974 || ((h
->elf_link_hash_flags
7975 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
7976 && (h
->elf_link_hash_flags
7977 & ELF_LINK_HASH_REF_REGULAR
) != 0
7978 && (h
->elf_link_hash_flags
7979 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
7981 /* If this symbol is defined in a dynamic object, we need to copy
7982 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
7984 hmips
= (struct mips_elf_link_hash_entry
*) h
;
7985 if (! info
->relocateable
7986 && hmips
->possibly_dynamic_relocs
!= 0
7987 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
7988 mips_elf_allocate_dynamic_relocations (dynobj
,
7989 hmips
->possibly_dynamic_relocs
);
7991 /* For a function, create a stub, if needed. */
7992 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
7994 if (! elf_hash_table (info
)->dynamic_sections_created
)
7997 /* If this symbol is not defined in a regular file, then set
7998 the symbol to the stub location. This is required to make
7999 function pointers compare as equal between the normal
8000 executable and the shared library. */
8001 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
8003 /* We need .stub section. */
8004 s
= bfd_get_section_by_name (dynobj
,
8005 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
8006 BFD_ASSERT (s
!= NULL
);
8008 h
->root
.u
.def
.section
= s
;
8009 h
->root
.u
.def
.value
= s
->_raw_size
;
8011 /* XXX Write this stub address somewhere. */
8012 h
->plt
.offset
= s
->_raw_size
;
8014 /* Make room for this stub code. */
8015 s
->_raw_size
+= MIPS_FUNCTION_STUB_SIZE
;
8017 /* The last half word of the stub will be filled with the index
8018 of this symbol in .dynsym section. */
8022 else if ((h
->type
== STT_FUNC
)
8023 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0)
8025 /* This will set the entry for this symbol in the GOT to 0, and
8026 the dynamic linker will take care of this. */
8027 h
->root
.u
.def
.value
= 0;
8031 /* If this is a weak symbol, and there is a real definition, the
8032 processor independent code will have arranged for us to see the
8033 real definition first, and we can just use the same value. */
8034 if (h
->weakdef
!= NULL
)
8036 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
8037 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
8038 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
8039 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
8043 /* This is a reference to a symbol defined by a dynamic object which
8044 is not a function. */
8049 /* This function is called after all the input files have been read,
8050 and the input sections have been assigned to output sections. We
8051 check for any mips16 stub sections that we can discard. */
8053 static boolean mips_elf_check_mips16_stubs
8054 PARAMS ((struct mips_elf_link_hash_entry
*, PTR
));
8057 _bfd_mips_elf_always_size_sections (output_bfd
, info
)
8059 struct bfd_link_info
*info
;
8063 /* The .reginfo section has a fixed size. */
8064 ri
= bfd_get_section_by_name (output_bfd
, ".reginfo");
8066 bfd_set_section_size (output_bfd
, ri
, sizeof (Elf32_External_RegInfo
));
8068 if (info
->relocateable
8069 || ! mips_elf_hash_table (info
)->mips16_stubs_seen
)
8072 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
8073 mips_elf_check_mips16_stubs
,
8079 /* Check the mips16 stubs for a particular symbol, and see if we can
8083 mips_elf_check_mips16_stubs (h
, data
)
8084 struct mips_elf_link_hash_entry
*h
;
8085 PTR data ATTRIBUTE_UNUSED
;
8087 if (h
->fn_stub
!= NULL
8088 && ! h
->need_fn_stub
)
8090 /* We don't need the fn_stub; the only references to this symbol
8091 are 16 bit calls. Clobber the size to 0 to prevent it from
8092 being included in the link. */
8093 h
->fn_stub
->_raw_size
= 0;
8094 h
->fn_stub
->_cooked_size
= 0;
8095 h
->fn_stub
->flags
&= ~SEC_RELOC
;
8096 h
->fn_stub
->reloc_count
= 0;
8097 h
->fn_stub
->flags
|= SEC_EXCLUDE
;
8100 if (h
->call_stub
!= NULL
8101 && h
->root
.other
== STO_MIPS16
)
8103 /* We don't need the call_stub; this is a 16 bit function, so
8104 calls from other 16 bit functions are OK. Clobber the size
8105 to 0 to prevent it from being included in the link. */
8106 h
->call_stub
->_raw_size
= 0;
8107 h
->call_stub
->_cooked_size
= 0;
8108 h
->call_stub
->flags
&= ~SEC_RELOC
;
8109 h
->call_stub
->reloc_count
= 0;
8110 h
->call_stub
->flags
|= SEC_EXCLUDE
;
8113 if (h
->call_fp_stub
!= NULL
8114 && h
->root
.other
== STO_MIPS16
)
8116 /* We don't need the call_stub; this is a 16 bit function, so
8117 calls from other 16 bit functions are OK. Clobber the size
8118 to 0 to prevent it from being included in the link. */
8119 h
->call_fp_stub
->_raw_size
= 0;
8120 h
->call_fp_stub
->_cooked_size
= 0;
8121 h
->call_fp_stub
->flags
&= ~SEC_RELOC
;
8122 h
->call_fp_stub
->reloc_count
= 0;
8123 h
->call_fp_stub
->flags
|= SEC_EXCLUDE
;
8129 /* Set the sizes of the dynamic sections. */
8132 _bfd_mips_elf_size_dynamic_sections (output_bfd
, info
)
8134 struct bfd_link_info
*info
;
8139 struct mips_got_info
*g
= NULL
;
8141 dynobj
= elf_hash_table (info
)->dynobj
;
8142 BFD_ASSERT (dynobj
!= NULL
);
8144 if (elf_hash_table (info
)->dynamic_sections_created
)
8146 /* Set the contents of the .interp section to the interpreter. */
8149 s
= bfd_get_section_by_name (dynobj
, ".interp");
8150 BFD_ASSERT (s
!= NULL
);
8152 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd
)) + 1;
8154 = (bfd_byte
*) ELF_DYNAMIC_INTERPRETER (output_bfd
);
8158 /* The check_relocs and adjust_dynamic_symbol entry points have
8159 determined the sizes of the various dynamic sections. Allocate
8162 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
8167 /* It's OK to base decisions on the section name, because none
8168 of the dynobj section names depend upon the input files. */
8169 name
= bfd_get_section_name (dynobj
, s
);
8171 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
8176 if (strncmp (name
, ".rel", 4) == 0)
8178 if (s
->_raw_size
== 0)
8180 /* We only strip the section if the output section name
8181 has the same name. Otherwise, there might be several
8182 input sections for this output section. FIXME: This
8183 code is probably not needed these days anyhow, since
8184 the linker now does not create empty output sections. */
8185 if (s
->output_section
!= NULL
8187 bfd_get_section_name (s
->output_section
->owner
,
8188 s
->output_section
)) == 0)
8193 const char *outname
;
8196 /* If this relocation section applies to a read only
8197 section, then we probably need a DT_TEXTREL entry.
8198 If the relocation section is .rel.dyn, we always
8199 assert a DT_TEXTREL entry rather than testing whether
8200 there exists a relocation to a read only section or
8202 outname
= bfd_get_section_name (output_bfd
,
8204 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
8206 && (target
->flags
& SEC_READONLY
) != 0
8207 && (target
->flags
& SEC_ALLOC
) != 0)
8209 MIPS_ELF_REL_DYN_SECTION_NAME (output_bfd
)) == 0)
8212 /* We use the reloc_count field as a counter if we need
8213 to copy relocs into the output file. */
8215 MIPS_ELF_REL_DYN_SECTION_NAME (output_bfd
)) != 0)
8219 else if (strncmp (name
, ".got", 4) == 0)
8222 bfd_size_type loadable_size
= 0;
8223 bfd_size_type local_gotno
;
8226 BFD_ASSERT (elf_section_data (s
) != NULL
);
8227 g
= (struct mips_got_info
*) elf_section_data (s
)->tdata
;
8228 BFD_ASSERT (g
!= NULL
);
8230 /* Calculate the total loadable size of the output. That
8231 will give us the maximum number of GOT_PAGE entries
8233 for (sub
= info
->input_bfds
; sub
; sub
= sub
->link_next
)
8235 asection
*subsection
;
8237 for (subsection
= sub
->sections
;
8239 subsection
= subsection
->next
)
8241 if ((subsection
->flags
& SEC_ALLOC
) == 0)
8243 loadable_size
+= (subsection
->_raw_size
+ 0xf) & ~0xf;
8246 loadable_size
+= MIPS_FUNCTION_STUB_SIZE
;
8248 /* Assume there are two loadable segments consisting of
8249 contiguous sections. Is 5 enough? */
8250 local_gotno
= (loadable_size
>> 16) + 5;
8251 if (IRIX_COMPAT (output_bfd
) == ict_irix6
)
8252 /* It's possible we will need GOT_PAGE entries as well as
8253 GOT16 entries. Often, these will be able to share GOT
8254 entries, but not always. */
8257 g
->local_gotno
+= local_gotno
;
8258 s
->_raw_size
+= local_gotno
* MIPS_ELF_GOT_SIZE (dynobj
);
8260 /* There has to be a global GOT entry for every symbol with
8261 a dynamic symbol table index of DT_MIPS_GOTSYM or
8262 higher. Therefore, it make sense to put those symbols
8263 that need GOT entries at the end of the symbol table. We
8265 if (!mips_elf_sort_hash_table (info
, 1))
8268 if (g
->global_gotsym
!= NULL
)
8269 i
= elf_hash_table (info
)->dynsymcount
- g
->global_gotsym
->dynindx
;
8271 /* If there are no global symbols, or none requiring
8272 relocations, then GLOBAL_GOTSYM will be NULL. */
8274 g
->global_gotno
= i
;
8275 s
->_raw_size
+= i
* MIPS_ELF_GOT_SIZE (dynobj
);
8277 else if (strcmp (name
, MIPS_ELF_STUB_SECTION_NAME (output_bfd
)) == 0)
8279 /* Irix rld assumes that the function stub isn't at the end
8280 of .text section. So put a dummy. XXX */
8281 s
->_raw_size
+= MIPS_FUNCTION_STUB_SIZE
;
8283 else if (! info
->shared
8284 && ! mips_elf_hash_table (info
)->use_rld_obj_head
8285 && strncmp (name
, ".rld_map", 8) == 0)
8287 /* We add a room for __rld_map. It will be filled in by the
8288 rtld to contain a pointer to the _r_debug structure. */
8291 else if (SGI_COMPAT (output_bfd
)
8292 && strncmp (name
, ".compact_rel", 12) == 0)
8293 s
->_raw_size
+= mips_elf_hash_table (info
)->compact_rel_size
;
8294 else if (strcmp (name
, MIPS_ELF_MSYM_SECTION_NAME (output_bfd
))
8296 s
->_raw_size
= (sizeof (Elf32_External_Msym
)
8297 * (elf_hash_table (info
)->dynsymcount
8298 + bfd_count_sections (output_bfd
)));
8299 else if (strncmp (name
, ".init", 5) != 0)
8301 /* It's not one of our sections, so don't allocate space. */
8307 _bfd_strip_section_from_output (info
, s
);
8311 /* Allocate memory for the section contents. */
8312 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
8313 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
8315 bfd_set_error (bfd_error_no_memory
);
8320 if (elf_hash_table (info
)->dynamic_sections_created
)
8322 /* Add some entries to the .dynamic section. We fill in the
8323 values later, in elf_mips_finish_dynamic_sections, but we
8324 must add the entries now so that we get the correct size for
8325 the .dynamic section. The DT_DEBUG entry is filled in by the
8326 dynamic linker and used by the debugger. */
8329 /* SGI object has the equivalence of DT_DEBUG in the
8330 DT_MIPS_RLD_MAP entry. */
8331 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_MAP
, 0))
8333 if (!SGI_COMPAT (output_bfd
))
8335 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
8341 /* Shared libraries on traditional mips have DT_DEBUG. */
8342 if (!SGI_COMPAT (output_bfd
))
8344 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
8348 if (reltext
&& SGI_COMPAT (output_bfd
))
8350 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_TEXTREL
, 0))
8352 info
->flags
|= DF_TEXTREL
;
8355 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTGOT
, 0))
8358 if (bfd_get_section_by_name (dynobj
,
8359 MIPS_ELF_REL_DYN_SECTION_NAME (dynobj
)))
8361 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_REL
, 0))
8364 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELSZ
, 0))
8367 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELENT
, 0))
8371 if (SGI_COMPAT (output_bfd
))
8373 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_CONFLICTNO
, 0))
8377 if (SGI_COMPAT (output_bfd
))
8379 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LIBLISTNO
, 0))
8383 if (bfd_get_section_by_name (dynobj
, ".conflict") != NULL
)
8385 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_CONFLICT
, 0))
8388 s
= bfd_get_section_by_name (dynobj
, ".liblist");
8389 BFD_ASSERT (s
!= NULL
);
8391 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LIBLIST
, 0))
8395 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_VERSION
, 0))
8398 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_FLAGS
, 0))
8402 /* Time stamps in executable files are a bad idea. */
8403 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_TIME_STAMP
, 0))
8408 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_ICHECKSUM
, 0))
8413 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_IVERSION
, 0))
8417 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_BASE_ADDRESS
, 0))
8420 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LOCAL_GOTNO
, 0))
8423 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_SYMTABNO
, 0))
8426 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_UNREFEXTNO
, 0))
8429 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_GOTSYM
, 0))
8432 if (IRIX_COMPAT (dynobj
) == ict_irix5
8433 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_HIPAGENO
, 0))
8436 if (IRIX_COMPAT (dynobj
) == ict_irix6
8437 && (bfd_get_section_by_name
8438 (dynobj
, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj
)))
8439 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_OPTIONS
, 0))
8442 if (bfd_get_section_by_name (dynobj
,
8443 MIPS_ELF_MSYM_SECTION_NAME (dynobj
))
8444 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_MSYM
, 0))
8451 /* If NAME is one of the special IRIX6 symbols defined by the linker,
8452 adjust it appropriately now. */
8455 mips_elf_irix6_finish_dynamic_symbol (abfd
, name
, sym
)
8456 bfd
*abfd ATTRIBUTE_UNUSED
;
8458 Elf_Internal_Sym
*sym
;
8460 /* The linker script takes care of providing names and values for
8461 these, but we must place them into the right sections. */
8462 static const char* const text_section_symbols
[] = {
8465 "__dso_displacement",
8467 "__program_header_table",
8471 static const char* const data_section_symbols
[] = {
8479 const char* const *p
;
8482 for (i
= 0; i
< 2; ++i
)
8483 for (p
= (i
== 0) ? text_section_symbols
: data_section_symbols
;
8486 if (strcmp (*p
, name
) == 0)
8488 /* All of these symbols are given type STT_SECTION by the
8490 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8492 /* The IRIX linker puts these symbols in special sections. */
8494 sym
->st_shndx
= SHN_MIPS_TEXT
;
8496 sym
->st_shndx
= SHN_MIPS_DATA
;
8502 /* Finish up dynamic symbol handling. We set the contents of various
8503 dynamic sections here. */
8506 _bfd_mips_elf_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
8508 struct bfd_link_info
*info
;
8509 struct elf_link_hash_entry
*h
;
8510 Elf_Internal_Sym
*sym
;
8516 struct mips_got_info
*g
;
8518 struct mips_elf_link_hash_entry
*mh
;
8520 dynobj
= elf_hash_table (info
)->dynobj
;
8521 gval
= sym
->st_value
;
8522 mh
= (struct mips_elf_link_hash_entry
*) h
;
8524 if (h
->plt
.offset
!= (bfd_vma
) -1)
8528 bfd_byte stub
[MIPS_FUNCTION_STUB_SIZE
];
8530 /* This symbol has a stub. Set it up. */
8532 BFD_ASSERT (h
->dynindx
!= -1);
8534 s
= bfd_get_section_by_name (dynobj
,
8535 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
8536 BFD_ASSERT (s
!= NULL
);
8538 /* Fill the stub. */
8540 bfd_put_32 (output_bfd
, STUB_LW (output_bfd
), p
);
8542 bfd_put_32 (output_bfd
, STUB_MOVE (output_bfd
), p
);
8545 /* FIXME: Can h->dynindex be more than 64K? */
8546 if (h
->dynindx
& 0xffff0000)
8549 bfd_put_32 (output_bfd
, STUB_JALR
, p
);
8551 bfd_put_32 (output_bfd
, STUB_LI16 (output_bfd
) + h
->dynindx
, p
);
8553 BFD_ASSERT (h
->plt
.offset
<= s
->_raw_size
);
8554 memcpy (s
->contents
+ h
->plt
.offset
, stub
, MIPS_FUNCTION_STUB_SIZE
);
8556 /* Mark the symbol as undefined. plt.offset != -1 occurs
8557 only for the referenced symbol. */
8558 sym
->st_shndx
= SHN_UNDEF
;
8560 /* The run-time linker uses the st_value field of the symbol
8561 to reset the global offset table entry for this external
8562 to its stub address when unlinking a shared object. */
8563 gval
= s
->output_section
->vma
+ s
->output_offset
+ h
->plt
.offset
;
8564 sym
->st_value
= gval
;
8567 BFD_ASSERT (h
->dynindx
!= -1
8568 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0);
8570 sgot
= mips_elf_got_section (dynobj
);
8571 BFD_ASSERT (sgot
!= NULL
);
8572 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
8573 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
8574 BFD_ASSERT (g
!= NULL
);
8576 /* Run through the global symbol table, creating GOT entries for all
8577 the symbols that need them. */
8578 if (g
->global_gotsym
!= NULL
8579 && h
->dynindx
>= g
->global_gotsym
->dynindx
)
8585 value
= sym
->st_value
;
8588 /* For an entity defined in a shared object, this will be
8589 NULL. (For functions in shared objects for
8590 which we have created stubs, ST_VALUE will be non-NULL.
8591 That's because such the functions are now no longer defined
8592 in a shared object.) */
8594 if (info
->shared
&& h
->root
.type
== bfd_link_hash_undefined
)
8597 value
= h
->root
.u
.def
.value
;
8599 offset
= mips_elf_global_got_index (dynobj
, h
);
8600 MIPS_ELF_PUT_WORD (output_bfd
, value
, sgot
->contents
+ offset
);
8603 /* Create a .msym entry, if appropriate. */
8604 smsym
= bfd_get_section_by_name (dynobj
,
8605 MIPS_ELF_MSYM_SECTION_NAME (dynobj
));
8608 Elf32_Internal_Msym msym
;
8610 msym
.ms_hash_value
= bfd_elf_hash (h
->root
.root
.string
);
8611 /* It is undocumented what the `1' indicates, but IRIX6 uses
8613 msym
.ms_info
= ELF32_MS_INFO (mh
->min_dyn_reloc_index
, 1);
8614 bfd_mips_elf_swap_msym_out
8616 ((Elf32_External_Msym
*) smsym
->contents
) + h
->dynindx
);
8619 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
8620 name
= h
->root
.root
.string
;
8621 if (strcmp (name
, "_DYNAMIC") == 0
8622 || strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
8623 sym
->st_shndx
= SHN_ABS
;
8624 else if (strcmp (name
, "_DYNAMIC_LINK") == 0
8625 || strcmp (name
, "_DYNAMIC_LINKING") == 0)
8627 sym
->st_shndx
= SHN_ABS
;
8628 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8631 else if (strcmp (name
, "_gp_disp") == 0)
8633 sym
->st_shndx
= SHN_ABS
;
8634 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8635 sym
->st_value
= elf_gp (output_bfd
);
8637 else if (SGI_COMPAT (output_bfd
))
8639 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
8640 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
8642 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8643 sym
->st_other
= STO_PROTECTED
;
8645 sym
->st_shndx
= SHN_MIPS_DATA
;
8647 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
8649 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8650 sym
->st_other
= STO_PROTECTED
;
8651 sym
->st_value
= mips_elf_hash_table (info
)->procedure_count
;
8652 sym
->st_shndx
= SHN_ABS
;
8654 else if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
!= SHN_ABS
)
8656 if (h
->type
== STT_FUNC
)
8657 sym
->st_shndx
= SHN_MIPS_TEXT
;
8658 else if (h
->type
== STT_OBJECT
)
8659 sym
->st_shndx
= SHN_MIPS_DATA
;
8663 /* Handle the IRIX6-specific symbols. */
8664 if (IRIX_COMPAT (output_bfd
) == ict_irix6
)
8665 mips_elf_irix6_finish_dynamic_symbol (output_bfd
, name
, sym
);
8669 if (! mips_elf_hash_table (info
)->use_rld_obj_head
8670 && (strcmp (name
, "__rld_map") == 0
8671 || strcmp (name
, "__RLD_MAP") == 0))
8673 asection
*s
= bfd_get_section_by_name (dynobj
, ".rld_map");
8674 BFD_ASSERT (s
!= NULL
);
8675 sym
->st_value
= s
->output_section
->vma
+ s
->output_offset
;
8676 bfd_put_32 (output_bfd
, (bfd_vma
) 0, s
->contents
);
8677 if (mips_elf_hash_table (info
)->rld_value
== 0)
8678 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
8680 else if (mips_elf_hash_table (info
)->use_rld_obj_head
8681 && strcmp (name
, "__rld_obj_head") == 0)
8683 /* IRIX6 does not use a .rld_map section. */
8684 if (IRIX_COMPAT (output_bfd
) == ict_irix5
8685 || IRIX_COMPAT (output_bfd
) == ict_none
)
8686 BFD_ASSERT (bfd_get_section_by_name (dynobj
, ".rld_map")
8688 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
8692 /* If this is a mips16 symbol, force the value to be even. */
8693 if (sym
->st_other
== STO_MIPS16
8694 && (sym
->st_value
& 1) != 0)
8700 /* Finish up the dynamic sections. */
8703 _bfd_mips_elf_finish_dynamic_sections (output_bfd
, info
)
8705 struct bfd_link_info
*info
;
8710 struct mips_got_info
*g
;
8712 dynobj
= elf_hash_table (info
)->dynobj
;
8714 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
8716 sgot
= mips_elf_got_section (dynobj
);
8721 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
8722 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
8723 BFD_ASSERT (g
!= NULL
);
8726 if (elf_hash_table (info
)->dynamic_sections_created
)
8730 BFD_ASSERT (sdyn
!= NULL
);
8731 BFD_ASSERT (g
!= NULL
);
8733 for (b
= sdyn
->contents
;
8734 b
< sdyn
->contents
+ sdyn
->_raw_size
;
8735 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
8737 Elf_Internal_Dyn dyn
;
8743 /* Read in the current dynamic entry. */
8744 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
8746 /* Assume that we're going to modify it and write it out. */
8752 s
= (bfd_get_section_by_name
8754 MIPS_ELF_REL_DYN_SECTION_NAME (dynobj
)));
8755 BFD_ASSERT (s
!= NULL
);
8756 dyn
.d_un
.d_val
= MIPS_ELF_REL_SIZE (dynobj
);
8760 /* Rewrite DT_STRSZ. */
8762 _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
8768 case DT_MIPS_CONFLICT
:
8771 case DT_MIPS_LIBLIST
:
8774 s
= bfd_get_section_by_name (output_bfd
, name
);
8775 BFD_ASSERT (s
!= NULL
);
8776 dyn
.d_un
.d_ptr
= s
->vma
;
8779 case DT_MIPS_RLD_VERSION
:
8780 dyn
.d_un
.d_val
= 1; /* XXX */
8784 dyn
.d_un
.d_val
= RHF_NOTPOT
; /* XXX */
8787 case DT_MIPS_CONFLICTNO
:
8789 elemsize
= sizeof (Elf32_Conflict
);
8792 case DT_MIPS_LIBLISTNO
:
8794 elemsize
= sizeof (Elf32_Lib
);
8796 s
= bfd_get_section_by_name (output_bfd
, name
);
8799 if (s
->_cooked_size
!= 0)
8800 dyn
.d_un
.d_val
= s
->_cooked_size
/ elemsize
;
8802 dyn
.d_un
.d_val
= s
->_raw_size
/ elemsize
;
8808 case DT_MIPS_TIME_STAMP
:
8809 time ((time_t *) &dyn
.d_un
.d_val
);
8812 case DT_MIPS_ICHECKSUM
:
8817 case DT_MIPS_IVERSION
:
8822 case DT_MIPS_BASE_ADDRESS
:
8823 s
= output_bfd
->sections
;
8824 BFD_ASSERT (s
!= NULL
);
8825 dyn
.d_un
.d_ptr
= s
->vma
& ~(0xffff);
8828 case DT_MIPS_LOCAL_GOTNO
:
8829 dyn
.d_un
.d_val
= g
->local_gotno
;
8832 case DT_MIPS_UNREFEXTNO
:
8833 /* The index into the dynamic symbol table which is the
8834 entry of the first external symbol that is not
8835 referenced within the same object. */
8836 dyn
.d_un
.d_val
= bfd_count_sections (output_bfd
) + 1;
8839 case DT_MIPS_GOTSYM
:
8840 if (g
->global_gotsym
)
8842 dyn
.d_un
.d_val
= g
->global_gotsym
->dynindx
;
8845 /* In case if we don't have global got symbols we default
8846 to setting DT_MIPS_GOTSYM to the same value as
8847 DT_MIPS_SYMTABNO, so we just fall through. */
8849 case DT_MIPS_SYMTABNO
:
8851 elemsize
= MIPS_ELF_SYM_SIZE (output_bfd
);
8852 s
= bfd_get_section_by_name (output_bfd
, name
);
8853 BFD_ASSERT (s
!= NULL
);
8855 if (s
->_cooked_size
!= 0)
8856 dyn
.d_un
.d_val
= s
->_cooked_size
/ elemsize
;
8858 dyn
.d_un
.d_val
= s
->_raw_size
/ elemsize
;
8861 case DT_MIPS_HIPAGENO
:
8862 dyn
.d_un
.d_val
= g
->local_gotno
- MIPS_RESERVED_GOTNO
;
8865 case DT_MIPS_RLD_MAP
:
8866 dyn
.d_un
.d_ptr
= mips_elf_hash_table (info
)->rld_value
;
8869 case DT_MIPS_OPTIONS
:
8870 s
= (bfd_get_section_by_name
8871 (output_bfd
, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd
)));
8872 dyn
.d_un
.d_ptr
= s
->vma
;
8876 s
= (bfd_get_section_by_name
8877 (output_bfd
, MIPS_ELF_MSYM_SECTION_NAME (output_bfd
)));
8878 dyn
.d_un
.d_ptr
= s
->vma
;
8887 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
8892 /* The first entry of the global offset table will be filled at
8893 runtime. The second entry will be used by some runtime loaders.
8894 This isn't the case of Irix rld. */
8895 if (sgot
!= NULL
&& sgot
->_raw_size
> 0)
8897 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
8898 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0x80000000,
8899 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
8903 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
8904 = MIPS_ELF_GOT_SIZE (output_bfd
);
8909 Elf32_compact_rel cpt
;
8911 /* ??? The section symbols for the output sections were set up in
8912 _bfd_elf_final_link. SGI sets the STT_NOTYPE attribute for these
8913 symbols. Should we do so? */
8915 smsym
= bfd_get_section_by_name (dynobj
,
8916 MIPS_ELF_MSYM_SECTION_NAME (dynobj
));
8919 Elf32_Internal_Msym msym
;
8921 msym
.ms_hash_value
= 0;
8922 msym
.ms_info
= ELF32_MS_INFO (0, 1);
8924 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
8926 long dynindx
= elf_section_data (s
)->dynindx
;
8928 bfd_mips_elf_swap_msym_out
8930 (((Elf32_External_Msym
*) smsym
->contents
)
8935 if (SGI_COMPAT (output_bfd
))
8937 /* Write .compact_rel section out. */
8938 s
= bfd_get_section_by_name (dynobj
, ".compact_rel");
8942 cpt
.num
= s
->reloc_count
;
8944 cpt
.offset
= (s
->output_section
->filepos
8945 + sizeof (Elf32_External_compact_rel
));
8948 bfd_elf32_swap_compact_rel_out (output_bfd
, &cpt
,
8949 ((Elf32_External_compact_rel
*)
8952 /* Clean up a dummy stub function entry in .text. */
8953 s
= bfd_get_section_by_name (dynobj
,
8954 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
8957 file_ptr dummy_offset
;
8959 BFD_ASSERT (s
->_raw_size
>= MIPS_FUNCTION_STUB_SIZE
);
8960 dummy_offset
= s
->_raw_size
- MIPS_FUNCTION_STUB_SIZE
;
8961 memset (s
->contents
+ dummy_offset
, 0,
8962 MIPS_FUNCTION_STUB_SIZE
);
8967 /* We need to sort the entries of the dynamic relocation section. */
8969 if (!ABI_64_P (output_bfd
))
8973 reldyn
= bfd_get_section_by_name (dynobj
,
8974 MIPS_ELF_REL_DYN_SECTION_NAME (dynobj
));
8975 if (reldyn
!= NULL
&& reldyn
->reloc_count
> 2)
8977 reldyn_sorting_bfd
= output_bfd
;
8978 qsort ((Elf32_External_Rel
*) reldyn
->contents
+ 1,
8979 (size_t) reldyn
->reloc_count
- 1,
8980 sizeof (Elf32_External_Rel
), sort_dynamic_relocs
);
8984 /* Clean up a first relocation in .rel.dyn. */
8985 s
= bfd_get_section_by_name (dynobj
,
8986 MIPS_ELF_REL_DYN_SECTION_NAME (dynobj
));
8987 if (s
!= NULL
&& s
->_raw_size
> 0)
8988 memset (s
->contents
, 0, MIPS_ELF_REL_SIZE (dynobj
));
8994 /* This is almost identical to bfd_generic_get_... except that some
8995 MIPS relocations need to be handled specially. Sigh. */
8998 elf32_mips_get_relocated_section_contents (abfd
, link_info
, link_order
, data
,
8999 relocateable
, symbols
)
9001 struct bfd_link_info
*link_info
;
9002 struct bfd_link_order
*link_order
;
9004 boolean relocateable
;
9007 /* Get enough memory to hold the stuff */
9008 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
9009 asection
*input_section
= link_order
->u
.indirect
.section
;
9011 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
9012 arelent
**reloc_vector
= NULL
;
9018 reloc_vector
= (arelent
**) bfd_malloc (reloc_size
);
9019 if (reloc_vector
== NULL
&& reloc_size
!= 0)
9022 /* read in the section */
9023 if (!bfd_get_section_contents (input_bfd
,
9027 input_section
->_raw_size
))
9030 /* We're not relaxing the section, so just copy the size info */
9031 input_section
->_cooked_size
= input_section
->_raw_size
;
9032 input_section
->reloc_done
= true;
9034 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
9038 if (reloc_count
< 0)
9041 if (reloc_count
> 0)
9046 bfd_vma gp
= 0x12345678; /* initialize just to shut gcc up */
9049 struct bfd_hash_entry
*h
;
9050 struct bfd_link_hash_entry
*lh
;
9051 /* Skip all this stuff if we aren't mixing formats. */
9052 if (abfd
&& input_bfd
9053 && abfd
->xvec
== input_bfd
->xvec
)
9057 h
= bfd_hash_lookup (&link_info
->hash
->table
, "_gp", false, false);
9058 lh
= (struct bfd_link_hash_entry
*) h
;
9065 case bfd_link_hash_undefined
:
9066 case bfd_link_hash_undefweak
:
9067 case bfd_link_hash_common
:
9070 case bfd_link_hash_defined
:
9071 case bfd_link_hash_defweak
:
9073 gp
= lh
->u
.def
.value
;
9075 case bfd_link_hash_indirect
:
9076 case bfd_link_hash_warning
:
9078 /* @@FIXME ignoring warning for now */
9080 case bfd_link_hash_new
:
9089 for (parent
= reloc_vector
; *parent
!= (arelent
*) NULL
;
9092 char *error_message
= (char *) NULL
;
9093 bfd_reloc_status_type r
;
9095 /* Specific to MIPS: Deal with relocation types that require
9096 knowing the gp of the output bfd. */
9097 asymbol
*sym
= *(*parent
)->sym_ptr_ptr
;
9098 if (bfd_is_abs_section (sym
->section
) && abfd
)
9100 /* The special_function wouldn't get called anyways. */
9104 /* The gp isn't there; let the special function code
9105 fall over on its own. */
9107 else if ((*parent
)->howto
->special_function
9108 == _bfd_mips_elf_gprel16_reloc
)
9110 /* bypass special_function call */
9111 r
= gprel16_with_gp (input_bfd
, sym
, *parent
, input_section
,
9112 relocateable
, (PTR
) data
, gp
);
9113 goto skip_bfd_perform_relocation
;
9115 /* end mips specific stuff */
9117 r
= bfd_perform_relocation (input_bfd
,
9121 relocateable
? abfd
: (bfd
*) NULL
,
9123 skip_bfd_perform_relocation
:
9127 asection
*os
= input_section
->output_section
;
9129 /* A partial link, so keep the relocs */
9130 os
->orelocation
[os
->reloc_count
] = *parent
;
9134 if (r
!= bfd_reloc_ok
)
9138 case bfd_reloc_undefined
:
9139 if (!((*link_info
->callbacks
->undefined_symbol
)
9140 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
9141 input_bfd
, input_section
, (*parent
)->address
,
9145 case bfd_reloc_dangerous
:
9146 BFD_ASSERT (error_message
!= (char *) NULL
);
9147 if (!((*link_info
->callbacks
->reloc_dangerous
)
9148 (link_info
, error_message
, input_bfd
, input_section
,
9149 (*parent
)->address
)))
9152 case bfd_reloc_overflow
:
9153 if (!((*link_info
->callbacks
->reloc_overflow
)
9154 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
9155 (*parent
)->howto
->name
, (*parent
)->addend
,
9156 input_bfd
, input_section
, (*parent
)->address
)))
9159 case bfd_reloc_outofrange
:
9168 if (reloc_vector
!= NULL
)
9169 free (reloc_vector
);
9173 if (reloc_vector
!= NULL
)
9174 free (reloc_vector
);
9178 #define bfd_elf32_bfd_get_relocated_section_contents \
9179 elf32_mips_get_relocated_section_contents
9181 /* ECOFF swapping routines. These are used when dealing with the
9182 .mdebug section, which is in the ECOFF debugging format. */
9183 static const struct ecoff_debug_swap mips_elf32_ecoff_debug_swap
= {
9184 /* Symbol table magic number. */
9186 /* Alignment of debugging information. E.g., 4. */
9188 /* Sizes of external symbolic information. */
9189 sizeof (struct hdr_ext
),
9190 sizeof (struct dnr_ext
),
9191 sizeof (struct pdr_ext
),
9192 sizeof (struct sym_ext
),
9193 sizeof (struct opt_ext
),
9194 sizeof (struct fdr_ext
),
9195 sizeof (struct rfd_ext
),
9196 sizeof (struct ext_ext
),
9197 /* Functions to swap in external symbolic data. */
9206 _bfd_ecoff_swap_tir_in
,
9207 _bfd_ecoff_swap_rndx_in
,
9208 /* Functions to swap out external symbolic data. */
9217 _bfd_ecoff_swap_tir_out
,
9218 _bfd_ecoff_swap_rndx_out
,
9219 /* Function to read in symbolic data. */
9220 _bfd_mips_elf_read_ecoff_info
9223 #define TARGET_LITTLE_SYM bfd_elf32_littlemips_vec
9224 #define TARGET_LITTLE_NAME "elf32-littlemips"
9225 #define TARGET_BIG_SYM bfd_elf32_bigmips_vec
9226 #define TARGET_BIG_NAME "elf32-bigmips"
9227 #define ELF_ARCH bfd_arch_mips
9228 #define ELF_MACHINE_CODE EM_MIPS
9230 /* The SVR4 MIPS ABI says that this should be 0x10000, but Irix 5 uses
9231 a value of 0x1000, and we are compatible. */
9232 #define ELF_MAXPAGESIZE 0x1000
9234 #define elf_backend_collect true
9235 #define elf_backend_type_change_ok true
9236 #define elf_backend_can_gc_sections true
9237 #define elf_backend_sign_extend_vma true
9238 #define elf_info_to_howto mips_info_to_howto_rela
9239 #define elf_info_to_howto_rel mips_info_to_howto_rel
9240 #define elf_backend_sym_is_global mips_elf_sym_is_global
9241 #define elf_backend_object_p _bfd_mips_elf_object_p
9242 #define elf_backend_section_from_shdr _bfd_mips_elf_section_from_shdr
9243 #define elf_backend_fake_sections _bfd_mips_elf_fake_sections
9244 #define elf_backend_section_from_bfd_section \
9245 _bfd_mips_elf_section_from_bfd_section
9246 #define elf_backend_section_processing _bfd_mips_elf_section_processing
9247 #define elf_backend_symbol_processing _bfd_mips_elf_symbol_processing
9248 #define elf_backend_additional_program_headers \
9249 _bfd_mips_elf_additional_program_headers
9250 #define elf_backend_modify_segment_map _bfd_mips_elf_modify_segment_map
9251 #define elf_backend_final_write_processing \
9252 _bfd_mips_elf_final_write_processing
9253 #define elf_backend_ecoff_debug_swap &mips_elf32_ecoff_debug_swap
9254 #define elf_backend_add_symbol_hook _bfd_mips_elf_add_symbol_hook
9255 #define elf_backend_create_dynamic_sections \
9256 _bfd_mips_elf_create_dynamic_sections
9257 #define elf_backend_check_relocs _bfd_mips_elf_check_relocs
9258 #define elf_backend_adjust_dynamic_symbol \
9259 _bfd_mips_elf_adjust_dynamic_symbol
9260 #define elf_backend_always_size_sections \
9261 _bfd_mips_elf_always_size_sections
9262 #define elf_backend_size_dynamic_sections \
9263 _bfd_mips_elf_size_dynamic_sections
9264 #define elf_backend_relocate_section _bfd_mips_elf_relocate_section
9265 #define elf_backend_link_output_symbol_hook \
9266 _bfd_mips_elf_link_output_symbol_hook
9267 #define elf_backend_finish_dynamic_symbol \
9268 _bfd_mips_elf_finish_dynamic_symbol
9269 #define elf_backend_finish_dynamic_sections \
9270 _bfd_mips_elf_finish_dynamic_sections
9271 #define elf_backend_gc_mark_hook _bfd_mips_elf_gc_mark_hook
9272 #define elf_backend_gc_sweep_hook _bfd_mips_elf_gc_sweep_hook
9274 #define elf_backend_got_header_size (4*MIPS_RESERVED_GOTNO)
9275 #define elf_backend_plt_header_size 0
9277 #define elf_backend_copy_indirect_symbol \
9278 _bfd_mips_elf_copy_indirect_symbol
9280 #define elf_backend_hide_symbol _bfd_mips_elf_hide_symbol
9282 #define bfd_elf32_bfd_is_local_label_name \
9283 mips_elf_is_local_label_name
9284 #define bfd_elf32_find_nearest_line _bfd_mips_elf_find_nearest_line
9285 #define bfd_elf32_set_section_contents _bfd_mips_elf_set_section_contents
9286 #define bfd_elf32_bfd_link_hash_table_create \
9287 _bfd_mips_elf_link_hash_table_create
9288 #define bfd_elf32_bfd_final_link _bfd_mips_elf_final_link
9289 #define bfd_elf32_bfd_copy_private_bfd_data \
9290 _bfd_mips_elf_copy_private_bfd_data
9291 #define bfd_elf32_bfd_merge_private_bfd_data \
9292 _bfd_mips_elf_merge_private_bfd_data
9293 #define bfd_elf32_bfd_set_private_flags _bfd_mips_elf_set_private_flags
9294 #define bfd_elf32_bfd_print_private_bfd_data \
9295 _bfd_mips_elf_print_private_bfd_data
9296 #include "elf32-target.h"
9298 /* Support for traditional mips targets */
9300 #define INCLUDED_TARGET_FILE /* More a type of flag */
9302 #undef TARGET_LITTLE_SYM
9303 #undef TARGET_LITTLE_NAME
9304 #undef TARGET_BIG_SYM
9305 #undef TARGET_BIG_NAME
9307 #define TARGET_LITTLE_SYM bfd_elf32_tradlittlemips_vec
9308 #define TARGET_LITTLE_NAME "elf32-tradlittlemips"
9309 #define TARGET_BIG_SYM bfd_elf32_tradbigmips_vec
9310 #define TARGET_BIG_NAME "elf32-tradbigmips"
9312 /* Include the target file again for this target */
9313 #include "elf32-target.h"