1 /* MIPS-specific support for 32-bit ELF
2 Copyright 1993, 94, 95, 96, 97, 98, 1999 Free Software Foundation, Inc.
4 Most of the information added by Ian Lance Taylor, Cygnus Support,
6 N32/64 ABI support added by Mark Mitchell, CodeSourcery, LLC.
7 <mark@codesourcery.com>
9 This file is part of BFD, the Binary File Descriptor library.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 /* This file handles MIPS ELF targets. SGI Irix 5 uses a slightly
26 different MIPS ELF from other targets. This matters when linking.
27 This file supports both, switching at runtime. */
37 /* Get the ECOFF swapping routines. */
39 #include "coff/symconst.h"
40 #include "coff/internal.h"
41 #include "coff/ecoff.h"
42 #include "coff/mips.h"
44 #include "ecoffswap.h"
46 /* This structure is used to hold .got information when linking. It
47 is stored in the tdata field of the bfd_elf_section_data structure. */
51 /* The global symbol in the GOT with the lowest index in the dynamic
53 struct elf_link_hash_entry
*global_gotsym
;
54 /* The number of global .got entries. */
55 unsigned int global_gotno
;
56 /* The number of local .got entries. */
57 unsigned int local_gotno
;
58 /* The number of local .got entries we have used. */
59 unsigned int assigned_gotno
;
62 /* The MIPS ELF linker needs additional information for each symbol in
63 the global hash table. */
65 struct mips_elf_link_hash_entry
67 struct elf_link_hash_entry root
;
69 /* External symbol information. */
72 /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
74 unsigned int possibly_dynamic_relocs
;
76 /* The index of the first dynamic relocation (in the .rel.dyn
77 section) against this symbol. */
78 unsigned int min_dyn_reloc_index
;
80 /* If there is a stub that 32 bit functions should use to call this
81 16 bit function, this points to the section containing the stub. */
84 /* Whether we need the fn_stub; this is set if this symbol appears
85 in any relocs other than a 16 bit call. */
88 /* If there is a stub that 16 bit functions should use to call this
89 32 bit function, this points to the section containing the stub. */
92 /* This is like the call_stub field, but it is used if the function
93 being called returns a floating point value. */
94 asection
*call_fp_stub
;
97 static bfd_reloc_status_type mips32_64bit_reloc
98 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
99 static reloc_howto_type
*bfd_elf32_bfd_reloc_type_lookup
100 PARAMS ((bfd
*, bfd_reloc_code_real_type
));
101 static reloc_howto_type
*mips_rtype_to_howto
102 PARAMS ((unsigned int));
103 static void mips_info_to_howto_rel
104 PARAMS ((bfd
*, arelent
*, Elf32_Internal_Rel
*));
105 static void mips_info_to_howto_rela
106 PARAMS ((bfd
*, arelent
*, Elf32_Internal_Rela
*));
107 static void bfd_mips_elf32_swap_gptab_in
108 PARAMS ((bfd
*, const Elf32_External_gptab
*, Elf32_gptab
*));
109 static void bfd_mips_elf32_swap_gptab_out
110 PARAMS ((bfd
*, const Elf32_gptab
*, Elf32_External_gptab
*));
111 static void bfd_mips_elf_swap_msym_in
112 PARAMS ((bfd
*, const Elf32_External_Msym
*, Elf32_Internal_Msym
*));
113 static void bfd_mips_elf_swap_msym_out
114 PARAMS ((bfd
*, const Elf32_Internal_Msym
*, Elf32_External_Msym
*));
115 static boolean mips_elf_sym_is_global
PARAMS ((bfd
*, asymbol
*));
116 static boolean mips_elf_create_procedure_table
117 PARAMS ((PTR
, bfd
*, struct bfd_link_info
*, asection
*,
118 struct ecoff_debug_info
*));
119 static INLINE
int elf_mips_isa
PARAMS ((flagword
));
120 static INLINE
int elf_mips_mach
PARAMS ((flagword
));
121 static INLINE
char* elf_mips_abi_name
PARAMS ((bfd
*));
122 static boolean mips_elf_is_local_label_name
123 PARAMS ((bfd
*, const char *));
124 static struct bfd_hash_entry
*mips_elf_link_hash_newfunc
125 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
126 static int gptab_compare
PARAMS ((const void *, const void *));
127 static void mips_elf_relocate_hi16
128 PARAMS ((bfd
*, Elf_Internal_Rela
*, Elf_Internal_Rela
*, bfd_byte
*,
130 static boolean mips_elf_relocate_got_local
131 PARAMS ((bfd
*, bfd
*, asection
*, Elf_Internal_Rela
*,
132 Elf_Internal_Rela
*, bfd_byte
*, bfd_vma
));
133 static void mips_elf_relocate_global_got
134 PARAMS ((bfd
*, Elf_Internal_Rela
*, bfd_byte
*, bfd_vma
));
135 static bfd_reloc_status_type mips16_jump_reloc
136 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
137 static bfd_reloc_status_type mips16_gprel_reloc
138 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
139 static boolean mips_elf_create_compact_rel_section
140 PARAMS ((bfd
*, struct bfd_link_info
*));
141 static boolean mips_elf_create_got_section
142 PARAMS ((bfd
*, struct bfd_link_info
*));
143 static bfd_reloc_status_type mips_elf_final_gp
144 PARAMS ((bfd
*, asymbol
*, boolean
, char **, bfd_vma
*));
145 static bfd_byte
*elf32_mips_get_relocated_section_contents
146 PARAMS ((bfd
*, struct bfd_link_info
*, struct bfd_link_order
*,
147 bfd_byte
*, boolean
, asymbol
**));
148 static asection
*mips_elf_create_msym_section
150 static void mips_elf_irix6_finish_dynamic_symbol
151 PARAMS ((bfd
*, const char *, Elf_Internal_Sym
*));
152 static bfd_vma mips_elf_sign_extend
PARAMS ((bfd_vma
, int));
153 static boolean mips_elf_overflow_p
PARAMS ((bfd_vma
, int));
154 static bfd_vma mips_elf_high
PARAMS ((bfd_vma
));
155 static bfd_vma mips_elf_higher
PARAMS ((bfd_vma
));
156 static bfd_vma mips_elf_highest
PARAMS ((bfd_vma
));
157 static bfd_vma mips_elf_global_got_index
158 PARAMS ((bfd
*, struct elf_link_hash_entry
*));
159 static bfd_vma mips_elf_local_got_index
160 PARAMS ((bfd
*, struct bfd_link_info
*, bfd_vma
));
161 static bfd_vma mips_elf_got_offset_from_index
162 PARAMS ((bfd
*, bfd
*, bfd_vma
));
163 static boolean mips_elf_record_global_got_symbol
164 PARAMS ((struct elf_link_hash_entry
*, struct bfd_link_info
*,
165 struct mips_got_info
*));
166 static bfd_vma mips_elf_got_page
167 PARAMS ((bfd
*, struct bfd_link_info
*, bfd_vma
, bfd_vma
*));
168 static boolean mips_elf_next_lo16_addend
169 PARAMS ((const Elf_Internal_Rela
*, const Elf_Internal_Rela
*, bfd_vma
*));
170 static bfd_reloc_status_type mips_elf_calculate_relocation
171 PARAMS ((bfd
*, bfd
*, asection
*, struct bfd_link_info
*,
172 const Elf_Internal_Rela
*, bfd_vma
, reloc_howto_type
*,
173 Elf_Internal_Sym
*, asection
**, bfd_vma
*, const char **,
175 static bfd_vma mips_elf_obtain_contents
176 PARAMS ((reloc_howto_type
*, const Elf_Internal_Rela
*, bfd
*, bfd_byte
*));
177 static boolean mips_elf_perform_relocation
178 PARAMS ((struct bfd_link_info
*, reloc_howto_type
*,
179 const Elf_Internal_Rela
*, bfd_vma
,
180 bfd
*, asection
*, bfd_byte
*, boolean
));
181 static boolean mips_elf_assign_gp
PARAMS ((bfd
*, bfd_vma
*));
182 static boolean mips_elf_sort_hash_table_f
183 PARAMS ((struct mips_elf_link_hash_entry
*, PTR
));
184 static boolean mips_elf_sort_hash_table
185 PARAMS ((struct bfd_link_info
*, unsigned long));
186 static asection
* mips_elf_got_section
PARAMS ((bfd
*));
187 static struct mips_got_info
*mips_elf_got_info
188 PARAMS ((bfd
*, asection
**));
189 static boolean mips_elf_local_relocation_p
190 PARAMS ((bfd
*, const Elf_Internal_Rela
*, asection
**));
191 static bfd_vma mips_elf_create_local_got_entry
192 PARAMS ((bfd
*, struct mips_got_info
*, asection
*, bfd_vma
));
193 static bfd_vma mips_elf_got16_entry
194 PARAMS ((bfd
*, struct bfd_link_info
*, bfd_vma
));
195 static unsigned int mips_elf_create_dynamic_relocation
196 PARAMS ((bfd
*, struct bfd_link_info
*, const Elf_Internal_Rela
*,
197 long, bfd_vma
, asection
*));
198 static void mips_elf_allocate_dynamic_relocations
199 PARAMS ((bfd
*, unsigned int));
200 static boolean mips_elf_stub_section_p
201 PARAMS ((bfd
*, asection
*));
203 /* The level of IRIX compatibility we're striving for. */
211 /* Nonzero if ABFD is using the N32 ABI. */
213 #define ABI_N32_P(abfd) \
214 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
216 /* Nonzero if ABFD is using the 64-bit ABI. FIXME: This is never
218 #define ABI_64_P(abfd) \
219 ((elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64) != 0)
221 /* What version of Irix we are trying to be compatible with. FIXME:
222 At the moment, we never generate "normal" MIPS ELF ABI executables;
223 we always use some version of Irix. */
225 #define IRIX_COMPAT(abfd) \
226 ((ABI_N32_P (abfd) || ABI_64_P (abfd)) ? ict_irix6 : ict_irix5)
228 /* Whether we are trying to be compatible with IRIX at all. */
230 #define SGI_COMPAT(abfd) \
231 (IRIX_COMPAT (abfd) != ict_none)
233 /* The name of the msym section. */
234 #define MIPS_ELF_MSYM_SECTION_NAME(abfd) ".msym"
236 /* The name of the srdata section. */
237 #define MIPS_ELF_SRDATA_SECTION_NAME(abfd) ".srdata"
239 /* The name of the options section. */
240 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
241 (IRIX_COMPAT (abfd) == ict_irix6 ? ".MIPS.options" : ".options")
243 /* The name of the stub section. */
244 #define MIPS_ELF_STUB_SECTION_NAME(abfd) \
245 (IRIX_COMPAT (abfd) == ict_irix6 ? ".MIPS.stubs" : ".stub")
247 /* The name of the dynamic relocation section. */
248 #define MIPS_ELF_REL_DYN_SECTION_NAME(abfd) ".rel.dyn"
250 /* The size of an external REL relocation. */
251 #define MIPS_ELF_REL_SIZE(abfd) \
252 (get_elf_backend_data (abfd)->s->sizeof_rel)
254 /* The size of an external dynamic table entry. */
255 #define MIPS_ELF_DYN_SIZE(abfd) \
256 (get_elf_backend_data (abfd)->s->sizeof_dyn)
258 /* The size of a GOT entry. */
259 #define MIPS_ELF_GOT_SIZE(abfd) \
260 (get_elf_backend_data (abfd)->s->arch_size / 8)
262 /* The size of a symbol-table entry. */
263 #define MIPS_ELF_SYM_SIZE(abfd) \
264 (get_elf_backend_data (abfd)->s->sizeof_sym)
266 /* The default alignment for sections, as a power of two. */
267 #define MIPS_ELF_LOG_FILE_ALIGN(abfd) \
268 (get_elf_backend_data (abfd)->s->file_align == 8 ? 3 : 2)
270 /* Get word-sized data. */
271 #define MIPS_ELF_GET_WORD(abfd, ptr) \
272 (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
274 /* Put out word-sized data. */
275 #define MIPS_ELF_PUT_WORD(abfd, val, ptr) \
277 ? bfd_put_64 (abfd, val, ptr) \
278 : bfd_put_32 (abfd, val, ptr))
280 /* Add a dynamic symbol table-entry. */
282 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
283 (ABI_64_P (elf_hash_table (info)->dynobj) \
284 ? bfd_elf64_add_dynamic_entry (info, tag, val) \
285 : bfd_elf32_add_dynamic_entry (info, tag, val))
287 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
288 (ABI_64_P (elf_hash_table (info)->dynobj) \
289 ? (abort (), false) \
290 : bfd_elf32_add_dynamic_entry (info, tag, val))
293 /* The number of local .got entries we reserve. */
294 #define MIPS_RESERVED_GOTNO (2)
296 /* Instructions which appear in a stub. For some reason the stub is
297 slightly different on an SGI system. */
298 #define ELF_MIPS_GP_OFFSET(abfd) (SGI_COMPAT (abfd) ? 0x7ff0 : 0x8000)
299 #define STUB_LW(abfd) \
302 ? 0xdf998010 /* ld t9,0x8010(gp) */ \
303 : 0x8f998010) /* lw t9,0x8010(gp) */ \
304 : 0x8f998000) /* lw t9,0x8000(gp) */
305 #define STUB_MOVE 0x03e07825 /* move t7,ra */
306 #define STUB_JALR 0x0320f809 /* jal t9 */
307 #define STUB_LI16 0x34180000 /* ori t8,zero,0 */
308 #define MIPS_FUNCTION_STUB_SIZE (16)
311 /* We no longer try to identify particular sections for the .dynsym
312 section. When we do, we wind up crashing if there are other random
313 sections with relocations. */
315 /* Names of sections which appear in the .dynsym section in an Irix 5
318 static const char * const mips_elf_dynsym_sec_names
[] =
331 #define SIZEOF_MIPS_DYNSYM_SECNAMES \
332 (sizeof mips_elf_dynsym_sec_names / sizeof mips_elf_dynsym_sec_names[0])
334 /* The number of entries in mips_elf_dynsym_sec_names which go in the
337 #define MIPS_TEXT_DYNSYM_SECNO (3)
341 /* The names of the runtime procedure table symbols used on Irix 5. */
343 static const char * const mips_elf_dynsym_rtproc_names
[] =
346 "_procedure_string_table",
347 "_procedure_table_size",
351 /* These structures are used to generate the .compact_rel section on
356 unsigned long id1
; /* Always one? */
357 unsigned long num
; /* Number of compact relocation entries. */
358 unsigned long id2
; /* Always two? */
359 unsigned long offset
; /* The file offset of the first relocation. */
360 unsigned long reserved0
; /* Zero? */
361 unsigned long reserved1
; /* Zero? */
370 bfd_byte reserved0
[4];
371 bfd_byte reserved1
[4];
372 } Elf32_External_compact_rel
;
376 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
377 unsigned int rtype
: 4; /* Relocation types. See below. */
378 unsigned int dist2to
: 8;
379 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
380 unsigned long konst
; /* KONST field. See below. */
381 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. */
398 } Elf32_External_crinfo
;
404 } Elf32_External_crinfo2
;
406 /* These are the constants used to swap the bitfields in a crinfo. */
408 #define CRINFO_CTYPE (0x1)
409 #define CRINFO_CTYPE_SH (31)
410 #define CRINFO_RTYPE (0xf)
411 #define CRINFO_RTYPE_SH (27)
412 #define CRINFO_DIST2TO (0xff)
413 #define CRINFO_DIST2TO_SH (19)
414 #define CRINFO_RELVADDR (0x7ffff)
415 #define CRINFO_RELVADDR_SH (0)
417 /* A compact relocation info has long (3 words) or short (2 words)
418 formats. A short format doesn't have VADDR field and relvaddr
419 fields contains ((VADDR - vaddr of the previous entry) >> 2). */
420 #define CRF_MIPS_LONG 1
421 #define CRF_MIPS_SHORT 0
423 /* There are 4 types of compact relocation at least. The value KONST
424 has different meaning for each type:
427 CT_MIPS_REL32 Address in data
428 CT_MIPS_WORD Address in word (XXX)
429 CT_MIPS_GPHI_LO GP - vaddr
430 CT_MIPS_JMPAD Address to jump
433 #define CRT_MIPS_REL32 0xa
434 #define CRT_MIPS_WORD 0xb
435 #define CRT_MIPS_GPHI_LO 0xc
436 #define CRT_MIPS_JMPAD 0xd
438 #define mips_elf_set_cr_format(x,format) ((x).ctype = (format))
439 #define mips_elf_set_cr_type(x,type) ((x).rtype = (type))
440 #define mips_elf_set_cr_dist2to(x,v) ((x).dist2to = (v))
441 #define mips_elf_set_cr_relvaddr(x,d) ((x).relvaddr = (d)<<2)
443 static void bfd_elf32_swap_compact_rel_out
444 PARAMS ((bfd
*, const Elf32_compact_rel
*, Elf32_External_compact_rel
*));
445 static void bfd_elf32_swap_crinfo_out
446 PARAMS ((bfd
*, const Elf32_crinfo
*, Elf32_External_crinfo
*));
448 #define USE_REL 1 /* MIPS uses REL relocations instead of RELA */
450 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
451 from smaller values. Start with zero, widen, *then* decrement. */
452 #define MINUS_ONE (((bfd_vma)0) - 1)
454 static reloc_howto_type elf_mips_howto_table
[] =
457 HOWTO (R_MIPS_NONE
, /* type */
459 0, /* size (0 = byte, 1 = short, 2 = long) */
461 false, /* pc_relative */
463 complain_overflow_dont
, /* complain_on_overflow */
464 bfd_elf_generic_reloc
, /* special_function */
465 "R_MIPS_NONE", /* name */
466 false, /* partial_inplace */
469 false), /* pcrel_offset */
471 /* 16 bit relocation. */
472 HOWTO (R_MIPS_16
, /* type */
474 1, /* size (0 = byte, 1 = short, 2 = long) */
476 false, /* pc_relative */
478 complain_overflow_bitfield
, /* complain_on_overflow */
479 bfd_elf_generic_reloc
, /* special_function */
480 "R_MIPS_16", /* name */
481 true, /* partial_inplace */
482 0xffff, /* src_mask */
483 0xffff, /* dst_mask */
484 false), /* pcrel_offset */
486 /* 32 bit relocation. */
487 HOWTO (R_MIPS_32
, /* type */
489 2, /* size (0 = byte, 1 = short, 2 = long) */
491 false, /* pc_relative */
493 complain_overflow_bitfield
, /* complain_on_overflow */
494 bfd_elf_generic_reloc
, /* special_function */
495 "R_MIPS_32", /* name */
496 true, /* partial_inplace */
497 0xffffffff, /* src_mask */
498 0xffffffff, /* dst_mask */
499 false), /* pcrel_offset */
501 /* 32 bit symbol relative relocation. */
502 HOWTO (R_MIPS_REL32
, /* type */
504 2, /* size (0 = byte, 1 = short, 2 = long) */
506 false, /* pc_relative */
508 complain_overflow_bitfield
, /* complain_on_overflow */
509 bfd_elf_generic_reloc
, /* special_function */
510 "R_MIPS_REL32", /* name */
511 true, /* partial_inplace */
512 0xffffffff, /* src_mask */
513 0xffffffff, /* dst_mask */
514 false), /* pcrel_offset */
516 /* 26 bit branch address. */
517 HOWTO (R_MIPS_26
, /* type */
519 2, /* size (0 = byte, 1 = short, 2 = long) */
521 false, /* pc_relative */
523 complain_overflow_dont
, /* complain_on_overflow */
524 /* This needs complex overflow
525 detection, because the upper four
526 bits must match the PC. */
527 bfd_elf_generic_reloc
, /* special_function */
528 "R_MIPS_26", /* name */
529 true, /* partial_inplace */
530 0x3ffffff, /* src_mask */
531 0x3ffffff, /* dst_mask */
532 false), /* pcrel_offset */
534 /* High 16 bits of symbol value. */
535 HOWTO (R_MIPS_HI16
, /* type */
537 2, /* size (0 = byte, 1 = short, 2 = long) */
539 false, /* pc_relative */
541 complain_overflow_dont
, /* complain_on_overflow */
542 _bfd_mips_elf_hi16_reloc
, /* special_function */
543 "R_MIPS_HI16", /* name */
544 true, /* partial_inplace */
545 0xffff, /* src_mask */
546 0xffff, /* dst_mask */
547 false), /* pcrel_offset */
549 /* Low 16 bits of symbol value. */
550 HOWTO (R_MIPS_LO16
, /* type */
552 2, /* size (0 = byte, 1 = short, 2 = long) */
554 false, /* pc_relative */
556 complain_overflow_dont
, /* complain_on_overflow */
557 _bfd_mips_elf_lo16_reloc
, /* special_function */
558 "R_MIPS_LO16", /* name */
559 true, /* partial_inplace */
560 0xffff, /* src_mask */
561 0xffff, /* dst_mask */
562 false), /* pcrel_offset */
564 /* GP relative reference. */
565 HOWTO (R_MIPS_GPREL16
, /* type */
567 2, /* size (0 = byte, 1 = short, 2 = long) */
569 false, /* pc_relative */
571 complain_overflow_signed
, /* complain_on_overflow */
572 _bfd_mips_elf_gprel16_reloc
, /* special_function */
573 "R_MIPS_GPREL16", /* name */
574 true, /* partial_inplace */
575 0xffff, /* src_mask */
576 0xffff, /* dst_mask */
577 false), /* pcrel_offset */
579 /* Reference to literal section. */
580 HOWTO (R_MIPS_LITERAL
, /* type */
582 2, /* size (0 = byte, 1 = short, 2 = long) */
584 false, /* pc_relative */
586 complain_overflow_signed
, /* complain_on_overflow */
587 _bfd_mips_elf_gprel16_reloc
, /* special_function */
588 "R_MIPS_LITERAL", /* name */
589 true, /* partial_inplace */
590 0xffff, /* src_mask */
591 0xffff, /* dst_mask */
592 false), /* pcrel_offset */
594 /* Reference to global offset table. */
595 HOWTO (R_MIPS_GOT16
, /* type */
597 2, /* size (0 = byte, 1 = short, 2 = long) */
599 false, /* pc_relative */
601 complain_overflow_signed
, /* complain_on_overflow */
602 _bfd_mips_elf_got16_reloc
, /* special_function */
603 "R_MIPS_GOT16", /* name */
604 false, /* partial_inplace */
606 0xffff, /* dst_mask */
607 false), /* pcrel_offset */
609 /* 16 bit PC relative reference. */
610 HOWTO (R_MIPS_PC16
, /* type */
612 2, /* size (0 = byte, 1 = short, 2 = long) */
614 true, /* pc_relative */
616 complain_overflow_signed
, /* complain_on_overflow */
617 bfd_elf_generic_reloc
, /* special_function */
618 "R_MIPS_PC16", /* name */
619 true, /* partial_inplace */
620 0xffff, /* src_mask */
621 0xffff, /* dst_mask */
622 false), /* pcrel_offset */
624 /* 16 bit call through global offset table. */
625 HOWTO (R_MIPS_CALL16
, /* type */
627 2, /* size (0 = byte, 1 = short, 2 = long) */
629 false, /* pc_relative */
631 complain_overflow_signed
, /* complain_on_overflow */
632 bfd_elf_generic_reloc
, /* special_function */
633 "R_MIPS_CALL16", /* name */
634 false, /* partial_inplace */
636 0xffff, /* dst_mask */
637 false), /* pcrel_offset */
639 /* 32 bit GP relative reference. */
640 HOWTO (R_MIPS_GPREL32
, /* type */
642 2, /* size (0 = byte, 1 = short, 2 = long) */
644 false, /* pc_relative */
646 complain_overflow_bitfield
, /* complain_on_overflow */
647 _bfd_mips_elf_gprel32_reloc
, /* special_function */
648 "R_MIPS_GPREL32", /* name */
649 true, /* partial_inplace */
650 0xffffffff, /* src_mask */
651 0xffffffff, /* dst_mask */
652 false), /* pcrel_offset */
654 /* The remaining relocs are defined on Irix 5, although they are
655 not defined by the ABI. */
660 /* A 5 bit shift field. */
661 HOWTO (R_MIPS_SHIFT5
, /* type */
663 2, /* size (0 = byte, 1 = short, 2 = long) */
665 false, /* pc_relative */
667 complain_overflow_bitfield
, /* complain_on_overflow */
668 bfd_elf_generic_reloc
, /* special_function */
669 "R_MIPS_SHIFT5", /* name */
670 true, /* partial_inplace */
671 0x000007c0, /* src_mask */
672 0x000007c0, /* dst_mask */
673 false), /* pcrel_offset */
675 /* A 6 bit shift field. */
676 /* FIXME: This is not handled correctly; a special function is
677 needed to put the most significant bit in the right place. */
678 HOWTO (R_MIPS_SHIFT6
, /* type */
680 2, /* size (0 = byte, 1 = short, 2 = long) */
682 false, /* pc_relative */
684 complain_overflow_bitfield
, /* complain_on_overflow */
685 bfd_elf_generic_reloc
, /* special_function */
686 "R_MIPS_SHIFT6", /* name */
687 true, /* partial_inplace */
688 0x000007c4, /* src_mask */
689 0x000007c4, /* dst_mask */
690 false), /* pcrel_offset */
692 /* A 64 bit relocation. */
693 HOWTO (R_MIPS_64
, /* type */
695 4, /* size (0 = byte, 1 = short, 2 = long) */
697 false, /* pc_relative */
699 complain_overflow_bitfield
, /* complain_on_overflow */
700 mips32_64bit_reloc
, /* special_function */
701 "R_MIPS_64", /* name */
702 true, /* partial_inplace */
703 MINUS_ONE
, /* src_mask */
704 MINUS_ONE
, /* dst_mask */
705 false), /* pcrel_offset */
707 /* Displacement in the global offset table. */
708 HOWTO (R_MIPS_GOT_DISP
, /* type */
710 2, /* size (0 = byte, 1 = short, 2 = long) */
712 false, /* pc_relative */
714 complain_overflow_bitfield
, /* complain_on_overflow */
715 bfd_elf_generic_reloc
, /* special_function */
716 "R_MIPS_GOT_DISP", /* name */
717 true, /* partial_inplace */
718 0x0000ffff, /* src_mask */
719 0x0000ffff, /* dst_mask */
720 false), /* pcrel_offset */
722 /* Displacement to page pointer in the global offset table. */
723 HOWTO (R_MIPS_GOT_PAGE
, /* type */
725 2, /* size (0 = byte, 1 = short, 2 = long) */
727 false, /* pc_relative */
729 complain_overflow_bitfield
, /* complain_on_overflow */
730 bfd_elf_generic_reloc
, /* special_function */
731 "R_MIPS_GOT_PAGE", /* name */
732 true, /* partial_inplace */
733 0x0000ffff, /* src_mask */
734 0x0000ffff, /* dst_mask */
735 false), /* pcrel_offset */
737 /* Offset from page pointer in the global offset table. */
738 HOWTO (R_MIPS_GOT_OFST
, /* type */
740 2, /* size (0 = byte, 1 = short, 2 = long) */
742 false, /* pc_relative */
744 complain_overflow_bitfield
, /* complain_on_overflow */
745 bfd_elf_generic_reloc
, /* special_function */
746 "R_MIPS_GOT_OFST", /* name */
747 true, /* partial_inplace */
748 0x0000ffff, /* src_mask */
749 0x0000ffff, /* dst_mask */
750 false), /* pcrel_offset */
752 /* High 16 bits of displacement in global offset table. */
753 HOWTO (R_MIPS_GOT_HI16
, /* type */
755 2, /* size (0 = byte, 1 = short, 2 = long) */
757 false, /* pc_relative */
759 complain_overflow_dont
, /* complain_on_overflow */
760 bfd_elf_generic_reloc
, /* special_function */
761 "R_MIPS_GOT_HI16", /* name */
762 true, /* partial_inplace */
763 0x0000ffff, /* src_mask */
764 0x0000ffff, /* dst_mask */
765 false), /* pcrel_offset */
767 /* Low 16 bits of displacement in global offset table. */
768 HOWTO (R_MIPS_GOT_LO16
, /* type */
770 2, /* size (0 = byte, 1 = short, 2 = long) */
772 false, /* pc_relative */
774 complain_overflow_dont
, /* complain_on_overflow */
775 bfd_elf_generic_reloc
, /* special_function */
776 "R_MIPS_GOT_LO16", /* name */
777 true, /* partial_inplace */
778 0x0000ffff, /* src_mask */
779 0x0000ffff, /* dst_mask */
780 false), /* pcrel_offset */
782 /* 64 bit subtraction. Used in the N32 ABI. */
783 HOWTO (R_MIPS_SUB
, /* type */
785 4, /* size (0 = byte, 1 = short, 2 = long) */
787 false, /* pc_relative */
789 complain_overflow_bitfield
, /* complain_on_overflow */
790 bfd_elf_generic_reloc
, /* special_function */
791 "R_MIPS_SUB", /* name */
792 true, /* partial_inplace */
793 MINUS_ONE
, /* src_mask */
794 MINUS_ONE
, /* dst_mask */
795 false), /* pcrel_offset */
797 /* Used to cause the linker to insert and delete instructions? */
798 EMPTY_HOWTO (R_MIPS_INSERT_A
),
799 EMPTY_HOWTO (R_MIPS_INSERT_B
),
800 EMPTY_HOWTO (R_MIPS_DELETE
),
802 /* Get the higher value of a 64 bit addend. */
803 HOWTO (R_MIPS_HIGHER
, /* type */
805 2, /* size (0 = byte, 1 = short, 2 = long) */
807 false, /* pc_relative */
809 complain_overflow_dont
, /* complain_on_overflow */
810 bfd_elf_generic_reloc
, /* special_function */
811 "R_MIPS_HIGHER", /* name */
812 true, /* partial_inplace */
814 0xffff, /* dst_mask */
815 false), /* pcrel_offset */
817 /* Get the highest value of a 64 bit addend. */
818 HOWTO (R_MIPS_HIGHEST
, /* type */
820 2, /* size (0 = byte, 1 = short, 2 = long) */
822 false, /* pc_relative */
824 complain_overflow_dont
, /* complain_on_overflow */
825 bfd_elf_generic_reloc
, /* special_function */
826 "R_MIPS_HIGHEST", /* name */
827 true, /* partial_inplace */
829 0xffff, /* dst_mask */
830 false), /* pcrel_offset */
832 /* High 16 bits of displacement in global offset table. */
833 HOWTO (R_MIPS_CALL_HI16
, /* type */
835 2, /* size (0 = byte, 1 = short, 2 = long) */
837 false, /* pc_relative */
839 complain_overflow_dont
, /* complain_on_overflow */
840 bfd_elf_generic_reloc
, /* special_function */
841 "R_MIPS_CALL_HI16", /* name */
842 true, /* partial_inplace */
843 0x0000ffff, /* src_mask */
844 0x0000ffff, /* dst_mask */
845 false), /* pcrel_offset */
847 /* Low 16 bits of displacement in global offset table. */
848 HOWTO (R_MIPS_CALL_LO16
, /* type */
850 2, /* size (0 = byte, 1 = short, 2 = long) */
852 false, /* pc_relative */
854 complain_overflow_dont
, /* complain_on_overflow */
855 bfd_elf_generic_reloc
, /* special_function */
856 "R_MIPS_CALL_LO16", /* name */
857 true, /* partial_inplace */
858 0x0000ffff, /* src_mask */
859 0x0000ffff, /* dst_mask */
860 false), /* pcrel_offset */
862 /* Section displacement. */
863 HOWTO (R_MIPS_SCN_DISP
, /* type */
865 2, /* size (0 = byte, 1 = short, 2 = long) */
867 false, /* pc_relative */
869 complain_overflow_dont
, /* complain_on_overflow */
870 bfd_elf_generic_reloc
, /* special_function */
871 "R_MIPS_SCN_DISP", /* name */
872 false, /* partial_inplace */
873 0xffffffff, /* src_mask */
874 0xffffffff, /* dst_mask */
875 false), /* pcrel_offset */
877 EMPTY_HOWTO (R_MIPS_REL16
),
878 EMPTY_HOWTO (R_MIPS_ADD_IMMEDIATE
),
879 EMPTY_HOWTO (R_MIPS_PJUMP
),
880 EMPTY_HOWTO (R_MIPS_RELGOT
),
882 /* Protected jump conversion. This is an optimization hint. No
883 relocation is required for correctness. */
884 HOWTO (R_MIPS_JALR
, /* type */
886 0, /* size (0 = byte, 1 = short, 2 = long) */
888 false, /* pc_relative */
890 complain_overflow_dont
, /* complain_on_overflow */
891 bfd_elf_generic_reloc
, /* special_function */
892 "R_MIPS_JALR", /* name */
893 false, /* partial_inplace */
894 0x00000000, /* src_mask */
895 0x00000000, /* dst_mask */
896 false), /* pcrel_offset */
899 /* The reloc used for BFD_RELOC_CTOR when doing a 64 bit link. This
900 is a hack to make the linker think that we need 64 bit values. */
901 static reloc_howto_type elf_mips_ctor64_howto
=
902 HOWTO (R_MIPS_64
, /* type */
904 4, /* size (0 = byte, 1 = short, 2 = long) */
906 false, /* pc_relative */
908 complain_overflow_signed
, /* complain_on_overflow */
909 mips32_64bit_reloc
, /* special_function */
910 "R_MIPS_64", /* name */
911 true, /* partial_inplace */
912 0xffffffff, /* src_mask */
913 0xffffffff, /* dst_mask */
914 false); /* pcrel_offset */
916 /* The reloc used for the mips16 jump instruction. */
917 static reloc_howto_type elf_mips16_jump_howto
=
918 HOWTO (R_MIPS16_26
, /* type */
920 2, /* size (0 = byte, 1 = short, 2 = long) */
922 false, /* pc_relative */
924 complain_overflow_dont
, /* complain_on_overflow */
925 /* This needs complex overflow
926 detection, because the upper four
927 bits must match the PC. */
928 mips16_jump_reloc
, /* special_function */
929 "R_MIPS16_26", /* name */
930 true, /* partial_inplace */
931 0x3ffffff, /* src_mask */
932 0x3ffffff, /* dst_mask */
933 false); /* pcrel_offset */
935 /* The reloc used for the mips16 gprel instruction. */
936 static reloc_howto_type elf_mips16_gprel_howto
=
937 HOWTO (R_MIPS16_GPREL
, /* type */
939 2, /* size (0 = byte, 1 = short, 2 = long) */
941 false, /* pc_relative */
943 complain_overflow_signed
, /* complain_on_overflow */
944 mips16_gprel_reloc
, /* special_function */
945 "R_MIPS16_GPREL", /* name */
946 true, /* partial_inplace */
947 0x07ff001f, /* src_mask */
948 0x07ff001f, /* dst_mask */
949 false); /* pcrel_offset */
952 /* GNU extension to record C++ vtable hierarchy */
953 static reloc_howto_type elf_mips_gnu_vtinherit_howto
=
954 HOWTO (R_MIPS_GNU_VTINHERIT
, /* type */
956 2, /* size (0 = byte, 1 = short, 2 = long) */
958 false, /* pc_relative */
960 complain_overflow_dont
, /* complain_on_overflow */
961 NULL
, /* special_function */
962 "R_MIPS_GNU_VTINHERIT", /* name */
963 false, /* partial_inplace */
966 false); /* pcrel_offset */
968 /* GNU extension to record C++ vtable member usage */
969 static reloc_howto_type elf_mips_gnu_vtentry_howto
=
970 HOWTO (R_MIPS_GNU_VTENTRY
, /* type */
972 2, /* size (0 = byte, 1 = short, 2 = long) */
974 false, /* pc_relative */
976 complain_overflow_dont
, /* complain_on_overflow */
977 _bfd_elf_rel_vtable_reloc_fn
, /* special_function */
978 "R_MIPS_GNU_VTENTRY", /* name */
979 false, /* partial_inplace */
982 false); /* pcrel_offset */
984 /* Do a R_MIPS_HI16 relocation. This has to be done in combination
985 with a R_MIPS_LO16 reloc, because there is a carry from the LO16 to
986 the HI16. Here we just save the information we need; we do the
987 actual relocation when we see the LO16. MIPS ELF requires that the
988 LO16 immediately follow the HI16. As a GNU extension, we permit an
989 arbitrary number of HI16 relocs to be associated with a single LO16
990 reloc. This extension permits gcc to output the HI and LO relocs
995 struct mips_hi16
*next
;
1000 /* FIXME: This should not be a static variable. */
1002 static struct mips_hi16
*mips_hi16_list
;
1004 bfd_reloc_status_type
1005 _bfd_mips_elf_hi16_reloc (abfd
,
1012 bfd
*abfd ATTRIBUTE_UNUSED
;
1013 arelent
*reloc_entry
;
1016 asection
*input_section
;
1018 char **error_message
;
1020 bfd_reloc_status_type ret
;
1022 struct mips_hi16
*n
;
1024 /* If we're relocating, and this an external symbol, we don't want
1025 to change anything. */
1026 if (output_bfd
!= (bfd
*) NULL
1027 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1028 && reloc_entry
->addend
== 0)
1030 reloc_entry
->address
+= input_section
->output_offset
;
1031 return bfd_reloc_ok
;
1036 if (strcmp (bfd_asymbol_name (symbol
), "_gp_disp") == 0)
1038 boolean relocateable
;
1041 if (ret
== bfd_reloc_undefined
)
1044 if (output_bfd
!= NULL
)
1045 relocateable
= true;
1048 relocateable
= false;
1049 output_bfd
= symbol
->section
->output_section
->owner
;
1052 ret
= mips_elf_final_gp (output_bfd
, symbol
, relocateable
,
1053 error_message
, &gp
);
1054 if (ret
!= bfd_reloc_ok
)
1057 relocation
= gp
- reloc_entry
->address
;
1061 if (bfd_is_und_section (symbol
->section
)
1062 && output_bfd
== (bfd
*) NULL
)
1063 ret
= bfd_reloc_undefined
;
1065 if (bfd_is_com_section (symbol
->section
))
1068 relocation
= symbol
->value
;
1071 relocation
+= symbol
->section
->output_section
->vma
;
1072 relocation
+= symbol
->section
->output_offset
;
1073 relocation
+= reloc_entry
->addend
;
1075 if (reloc_entry
->address
> input_section
->_cooked_size
)
1076 return bfd_reloc_outofrange
;
1078 /* Save the information, and let LO16 do the actual relocation. */
1079 n
= (struct mips_hi16
*) bfd_malloc (sizeof *n
);
1081 return bfd_reloc_outofrange
;
1082 n
->addr
= (bfd_byte
*) data
+ reloc_entry
->address
;
1083 n
->addend
= relocation
;
1084 n
->next
= mips_hi16_list
;
1087 if (output_bfd
!= (bfd
*) NULL
)
1088 reloc_entry
->address
+= input_section
->output_offset
;
1093 /* Do a R_MIPS_LO16 relocation. This is a straightforward 16 bit
1094 inplace relocation; this function exists in order to do the
1095 R_MIPS_HI16 relocation described above. */
1097 bfd_reloc_status_type
1098 _bfd_mips_elf_lo16_reloc (abfd
,
1106 arelent
*reloc_entry
;
1109 asection
*input_section
;
1111 char **error_message
;
1113 arelent gp_disp_relent
;
1115 if (mips_hi16_list
!= NULL
)
1117 struct mips_hi16
*l
;
1124 unsigned long vallo
;
1125 struct mips_hi16
*next
;
1127 /* Do the HI16 relocation. Note that we actually don't need
1128 to know anything about the LO16 itself, except where to
1129 find the low 16 bits of the addend needed by the LO16. */
1130 insn
= bfd_get_32 (abfd
, l
->addr
);
1131 vallo
= (bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
)
1133 val
= ((insn
& 0xffff) << 16) + vallo
;
1136 /* The low order 16 bits are always treated as a signed
1137 value. Therefore, a negative value in the low order bits
1138 requires an adjustment in the high order bits. We need
1139 to make this adjustment in two ways: once for the bits we
1140 took from the data, and once for the bits we are putting
1141 back in to the data. */
1142 if ((vallo
& 0x8000) != 0)
1144 if ((val
& 0x8000) != 0)
1147 insn
= (insn
&~ 0xffff) | ((val
>> 16) & 0xffff);
1148 bfd_put_32 (abfd
, insn
, l
->addr
);
1150 if (strcmp (bfd_asymbol_name (symbol
), "_gp_disp") == 0)
1152 gp_disp_relent
= *reloc_entry
;
1153 reloc_entry
= &gp_disp_relent
;
1154 reloc_entry
->addend
= l
->addend
;
1162 mips_hi16_list
= NULL
;
1164 else if (strcmp (bfd_asymbol_name (symbol
), "_gp_disp") == 0)
1166 bfd_reloc_status_type ret
;
1167 bfd_vma gp
, relocation
;
1169 /* FIXME: Does this case ever occur? */
1171 ret
= mips_elf_final_gp (output_bfd
, symbol
, true, error_message
, &gp
);
1172 if (ret
!= bfd_reloc_ok
)
1175 relocation
= gp
- reloc_entry
->address
;
1176 relocation
+= symbol
->section
->output_section
->vma
;
1177 relocation
+= symbol
->section
->output_offset
;
1178 relocation
+= reloc_entry
->addend
;
1180 if (reloc_entry
->address
> input_section
->_cooked_size
)
1181 return bfd_reloc_outofrange
;
1183 gp_disp_relent
= *reloc_entry
;
1184 reloc_entry
= &gp_disp_relent
;
1185 reloc_entry
->addend
= relocation
- 4;
1188 /* Now do the LO16 reloc in the usual way. */
1189 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1190 input_section
, output_bfd
, error_message
);
1193 /* Do a R_MIPS_GOT16 reloc. This is a reloc against the global offset
1194 table used for PIC code. If the symbol is an external symbol, the
1195 instruction is modified to contain the offset of the appropriate
1196 entry in the global offset table. If the symbol is a section
1197 symbol, the next reloc is a R_MIPS_LO16 reloc. The two 16 bit
1198 addends are combined to form the real addend against the section
1199 symbol; the GOT16 is modified to contain the offset of an entry in
1200 the global offset table, and the LO16 is modified to offset it
1201 appropriately. Thus an offset larger than 16 bits requires a
1202 modified value in the global offset table.
1204 This implementation suffices for the assembler, but the linker does
1205 not yet know how to create global offset tables. */
1207 bfd_reloc_status_type
1208 _bfd_mips_elf_got16_reloc (abfd
,
1216 arelent
*reloc_entry
;
1219 asection
*input_section
;
1221 char **error_message
;
1223 /* If we're relocating, and this an external symbol, we don't want
1224 to change anything. */
1225 if (output_bfd
!= (bfd
*) NULL
1226 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1227 && reloc_entry
->addend
== 0)
1229 reloc_entry
->address
+= input_section
->output_offset
;
1230 return bfd_reloc_ok
;
1233 /* If we're relocating, and this is a local symbol, we can handle it
1235 if (output_bfd
!= (bfd
*) NULL
1236 && (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1237 return _bfd_mips_elf_hi16_reloc (abfd
, reloc_entry
, symbol
, data
,
1238 input_section
, output_bfd
, error_message
);
1243 /* Set the GP value for OUTPUT_BFD. Returns false if this is a
1244 dangerous relocation. */
1247 mips_elf_assign_gp (output_bfd
, pgp
)
1255 /* If we've already figured out what GP will be, just return it. */
1256 *pgp
= _bfd_get_gp_value (output_bfd
);
1260 count
= bfd_get_symcount (output_bfd
);
1261 sym
= bfd_get_outsymbols (output_bfd
);
1263 /* The linker script will have created a symbol named `_gp' with the
1264 appropriate value. */
1265 if (sym
== (asymbol
**) NULL
)
1269 for (i
= 0; i
< count
; i
++, sym
++)
1271 register CONST
char *name
;
1273 name
= bfd_asymbol_name (*sym
);
1274 if (*name
== '_' && strcmp (name
, "_gp") == 0)
1276 *pgp
= bfd_asymbol_value (*sym
);
1277 _bfd_set_gp_value (output_bfd
, *pgp
);
1285 /* Only get the error once. */
1287 _bfd_set_gp_value (output_bfd
, *pgp
);
1294 /* We have to figure out the gp value, so that we can adjust the
1295 symbol value correctly. We look up the symbol _gp in the output
1296 BFD. If we can't find it, we're stuck. We cache it in the ELF
1297 target data. We don't need to adjust the symbol value for an
1298 external symbol if we are producing relocateable output. */
1300 static bfd_reloc_status_type
1301 mips_elf_final_gp (output_bfd
, symbol
, relocateable
, error_message
, pgp
)
1304 boolean relocateable
;
1305 char **error_message
;
1308 if (bfd_is_und_section (symbol
->section
)
1312 return bfd_reloc_undefined
;
1315 *pgp
= _bfd_get_gp_value (output_bfd
);
1318 || (symbol
->flags
& BSF_SECTION_SYM
) != 0))
1322 /* Make up a value. */
1323 *pgp
= symbol
->section
->output_section
->vma
+ 0x4000;
1324 _bfd_set_gp_value (output_bfd
, *pgp
);
1326 else if (!mips_elf_assign_gp (output_bfd
, pgp
))
1329 (char *) _("GP relative relocation when _gp not defined");
1330 return bfd_reloc_dangerous
;
1334 return bfd_reloc_ok
;
1337 /* Do a R_MIPS_GPREL16 relocation. This is a 16 bit value which must
1338 become the offset from the gp register. This function also handles
1339 R_MIPS_LITERAL relocations, although those can be handled more
1340 cleverly because the entries in the .lit8 and .lit4 sections can be
1343 static bfd_reloc_status_type gprel16_with_gp
PARAMS ((bfd
*, asymbol
*,
1344 arelent
*, asection
*,
1345 boolean
, PTR
, bfd_vma
));
1347 bfd_reloc_status_type
1348 _bfd_mips_elf_gprel16_reloc (abfd
, reloc_entry
, symbol
, data
, input_section
,
1349 output_bfd
, error_message
)
1351 arelent
*reloc_entry
;
1354 asection
*input_section
;
1356 char **error_message
;
1358 boolean relocateable
;
1359 bfd_reloc_status_type ret
;
1362 /* If we're relocating, and this is an external symbol with no
1363 addend, we don't want to change anything. We will only have an
1364 addend if this is a newly created reloc, not read from an ELF
1366 if (output_bfd
!= (bfd
*) NULL
1367 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1368 && reloc_entry
->addend
== 0)
1370 reloc_entry
->address
+= input_section
->output_offset
;
1371 return bfd_reloc_ok
;
1374 if (output_bfd
!= (bfd
*) NULL
)
1375 relocateable
= true;
1378 relocateable
= false;
1379 output_bfd
= symbol
->section
->output_section
->owner
;
1382 ret
= mips_elf_final_gp (output_bfd
, symbol
, relocateable
, error_message
,
1384 if (ret
!= bfd_reloc_ok
)
1387 return gprel16_with_gp (abfd
, symbol
, reloc_entry
, input_section
,
1388 relocateable
, data
, gp
);
1391 static bfd_reloc_status_type
1392 gprel16_with_gp (abfd
, symbol
, reloc_entry
, input_section
, relocateable
, data
,
1396 arelent
*reloc_entry
;
1397 asection
*input_section
;
1398 boolean relocateable
;
1406 if (bfd_is_com_section (symbol
->section
))
1409 relocation
= symbol
->value
;
1411 relocation
+= symbol
->section
->output_section
->vma
;
1412 relocation
+= symbol
->section
->output_offset
;
1414 if (reloc_entry
->address
> input_section
->_cooked_size
)
1415 return bfd_reloc_outofrange
;
1417 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1419 /* Set val to the offset into the section or symbol. */
1420 if (reloc_entry
->howto
->src_mask
== 0)
1422 /* This case occurs with the 64-bit MIPS ELF ABI. */
1423 val
= reloc_entry
->addend
;
1427 val
= ((insn
& 0xffff) + reloc_entry
->addend
) & 0xffff;
1432 /* Adjust val for the final section location and GP value. If we
1433 are producing relocateable output, we don't want to do this for
1434 an external symbol. */
1436 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1437 val
+= relocation
- gp
;
1439 insn
= (insn
&~ 0xffff) | (val
& 0xffff);
1440 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
);
1443 reloc_entry
->address
+= input_section
->output_offset
;
1445 /* Make sure it fit in 16 bits. */
1446 if (val
>= 0x8000 && val
< 0xffff8000)
1447 return bfd_reloc_overflow
;
1449 return bfd_reloc_ok
;
1452 /* Do a R_MIPS_GPREL32 relocation. Is this 32 bit value the offset
1453 from the gp register? XXX */
1455 static bfd_reloc_status_type gprel32_with_gp
PARAMS ((bfd
*, asymbol
*,
1456 arelent
*, asection
*,
1457 boolean
, PTR
, bfd_vma
));
1459 bfd_reloc_status_type
1460 _bfd_mips_elf_gprel32_reloc (abfd
,
1468 arelent
*reloc_entry
;
1471 asection
*input_section
;
1473 char **error_message
;
1475 boolean relocateable
;
1476 bfd_reloc_status_type ret
;
1479 /* If we're relocating, and this is an external symbol with no
1480 addend, we don't want to change anything. We will only have an
1481 addend if this is a newly created reloc, not read from an ELF
1483 if (output_bfd
!= (bfd
*) NULL
1484 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1485 && reloc_entry
->addend
== 0)
1487 *error_message
= (char *)
1488 _("32bits gp relative relocation occurs for an external symbol");
1489 return bfd_reloc_outofrange
;
1492 if (output_bfd
!= (bfd
*) NULL
)
1494 relocateable
= true;
1495 gp
= _bfd_get_gp_value (output_bfd
);
1499 relocateable
= false;
1500 output_bfd
= symbol
->section
->output_section
->owner
;
1502 ret
= mips_elf_final_gp (output_bfd
, symbol
, relocateable
,
1503 error_message
, &gp
);
1504 if (ret
!= bfd_reloc_ok
)
1508 return gprel32_with_gp (abfd
, symbol
, reloc_entry
, input_section
,
1509 relocateable
, data
, gp
);
1512 static bfd_reloc_status_type
1513 gprel32_with_gp (abfd
, symbol
, reloc_entry
, input_section
, relocateable
, data
,
1517 arelent
*reloc_entry
;
1518 asection
*input_section
;
1519 boolean relocateable
;
1526 if (bfd_is_com_section (symbol
->section
))
1529 relocation
= symbol
->value
;
1531 relocation
+= symbol
->section
->output_section
->vma
;
1532 relocation
+= symbol
->section
->output_offset
;
1534 if (reloc_entry
->address
> input_section
->_cooked_size
)
1535 return bfd_reloc_outofrange
;
1537 if (reloc_entry
->howto
->src_mask
== 0)
1539 /* This case arises with the 64-bit MIPS ELF ABI. */
1543 val
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1545 /* Set val to the offset into the section or symbol. */
1546 val
+= reloc_entry
->addend
;
1548 /* Adjust val for the final section location and GP value. If we
1549 are producing relocateable output, we don't want to do this for
1550 an external symbol. */
1552 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1553 val
+= relocation
- gp
;
1555 bfd_put_32 (abfd
, val
, (bfd_byte
*) data
+ reloc_entry
->address
);
1558 reloc_entry
->address
+= input_section
->output_offset
;
1560 return bfd_reloc_ok
;
1563 /* Handle a 64 bit reloc in a 32 bit MIPS ELF file. These are
1564 generated when addreses are 64 bits. The upper 32 bits are a simle
1567 static bfd_reloc_status_type
1568 mips32_64bit_reloc (abfd
, reloc_entry
, symbol
, data
, input_section
,
1569 output_bfd
, error_message
)
1571 arelent
*reloc_entry
;
1574 asection
*input_section
;
1576 char **error_message
;
1578 bfd_reloc_status_type r
;
1583 r
= bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1584 input_section
, output_bfd
, error_message
);
1585 if (r
!= bfd_reloc_continue
)
1588 /* Do a normal 32 bit relocation on the lower 32 bits. */
1589 reloc32
= *reloc_entry
;
1590 if (bfd_big_endian (abfd
))
1591 reloc32
.address
+= 4;
1592 reloc32
.howto
= &elf_mips_howto_table
[R_MIPS_32
];
1593 r
= bfd_perform_relocation (abfd
, &reloc32
, data
, input_section
,
1594 output_bfd
, error_message
);
1596 /* Sign extend into the upper 32 bits. */
1597 val
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc32
.address
);
1598 if ((val
& 0x80000000) != 0)
1602 addr
= reloc_entry
->address
;
1603 if (bfd_little_endian (abfd
))
1605 bfd_put_32 (abfd
, val
, (bfd_byte
*) data
+ addr
);
1610 /* Handle a mips16 jump. */
1612 static bfd_reloc_status_type
1613 mips16_jump_reloc (abfd
, reloc_entry
, symbol
, data
, input_section
,
1614 output_bfd
, error_message
)
1615 bfd
*abfd ATTRIBUTE_UNUSED
;
1616 arelent
*reloc_entry
;
1618 PTR data ATTRIBUTE_UNUSED
;
1619 asection
*input_section
;
1621 char **error_message ATTRIBUTE_UNUSED
;
1623 if (output_bfd
!= (bfd
*) NULL
1624 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1625 && reloc_entry
->addend
== 0)
1627 reloc_entry
->address
+= input_section
->output_offset
;
1628 return bfd_reloc_ok
;
1633 static boolean warned
;
1636 (*_bfd_error_handler
)
1637 (_("Linking mips16 objects into %s format is not supported"),
1638 bfd_get_target (input_section
->output_section
->owner
));
1642 return bfd_reloc_undefined
;
1645 /* Handle a mips16 GP relative reloc. */
1647 static bfd_reloc_status_type
1648 mips16_gprel_reloc (abfd
, reloc_entry
, symbol
, data
, input_section
,
1649 output_bfd
, error_message
)
1651 arelent
*reloc_entry
;
1654 asection
*input_section
;
1656 char **error_message
;
1658 boolean relocateable
;
1659 bfd_reloc_status_type ret
;
1661 unsigned short extend
, insn
;
1662 unsigned long final
;
1664 /* If we're relocating, and this is an external symbol with no
1665 addend, we don't want to change anything. We will only have an
1666 addend if this is a newly created reloc, not read from an ELF
1668 if (output_bfd
!= NULL
1669 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1670 && reloc_entry
->addend
== 0)
1672 reloc_entry
->address
+= input_section
->output_offset
;
1673 return bfd_reloc_ok
;
1676 if (output_bfd
!= NULL
)
1677 relocateable
= true;
1680 relocateable
= false;
1681 output_bfd
= symbol
->section
->output_section
->owner
;
1684 ret
= mips_elf_final_gp (output_bfd
, symbol
, relocateable
, error_message
,
1686 if (ret
!= bfd_reloc_ok
)
1689 if (reloc_entry
->address
> input_section
->_cooked_size
)
1690 return bfd_reloc_outofrange
;
1692 /* Pick up the mips16 extend instruction and the real instruction. */
1693 extend
= bfd_get_16 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1694 insn
= bfd_get_16 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
+ 2);
1696 /* Stuff the current addend back as a 32 bit value, do the usual
1697 relocation, and then clean up. */
1699 (((extend
& 0x1f) << 11)
1702 (bfd_byte
*) data
+ reloc_entry
->address
);
1704 ret
= gprel16_with_gp (abfd
, symbol
, reloc_entry
, input_section
,
1705 relocateable
, data
, gp
);
1707 final
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1710 | ((final
>> 11) & 0x1f)
1712 (bfd_byte
*) data
+ reloc_entry
->address
);
1716 (bfd_byte
*) data
+ reloc_entry
->address
+ 2);
1721 /* Return the ISA for a MIPS e_flags value. */
1724 elf_mips_isa (flags
)
1727 switch (flags
& EF_MIPS_ARCH
)
1741 /* Return the MACH for a MIPS e_flags value. */
1744 elf_mips_mach (flags
)
1747 switch (flags
& EF_MIPS_MACH
)
1749 case E_MIPS_MACH_3900
:
1750 return bfd_mach_mips3900
;
1752 case E_MIPS_MACH_4010
:
1753 return bfd_mach_mips4010
;
1755 case E_MIPS_MACH_4100
:
1756 return bfd_mach_mips4100
;
1758 case E_MIPS_MACH_4111
:
1759 return bfd_mach_mips4111
;
1761 case E_MIPS_MACH_4650
:
1762 return bfd_mach_mips4650
;
1765 switch (flags
& EF_MIPS_ARCH
)
1769 return bfd_mach_mips3000
;
1773 return bfd_mach_mips6000
;
1777 return bfd_mach_mips4000
;
1781 return bfd_mach_mips8000
;
1789 /* Return printable name for ABI. */
1792 elf_mips_abi_name (abfd
)
1797 if (ABI_N32_P (abfd
))
1799 else if (ABI_64_P (abfd
))
1802 flags
= elf_elfheader (abfd
)->e_flags
;
1803 switch (flags
& EF_MIPS_ABI
)
1807 case E_MIPS_ABI_O32
:
1809 case E_MIPS_ABI_O64
:
1811 case E_MIPS_ABI_EABI32
:
1813 case E_MIPS_ABI_EABI64
:
1816 return "unknown abi";
1820 /* A mapping from BFD reloc types to MIPS ELF reloc types. */
1822 struct elf_reloc_map
{
1823 bfd_reloc_code_real_type bfd_reloc_val
;
1824 enum elf_mips_reloc_type elf_reloc_val
;
1827 static CONST
struct elf_reloc_map mips_reloc_map
[] =
1829 { BFD_RELOC_NONE
, R_MIPS_NONE
, },
1830 { BFD_RELOC_16
, R_MIPS_16
},
1831 { BFD_RELOC_32
, R_MIPS_32
},
1832 { BFD_RELOC_64
, R_MIPS_64
},
1833 { BFD_RELOC_MIPS_JMP
, R_MIPS_26
},
1834 { BFD_RELOC_HI16_S
, R_MIPS_HI16
},
1835 { BFD_RELOC_LO16
, R_MIPS_LO16
},
1836 { BFD_RELOC_MIPS_GPREL
, R_MIPS_GPREL16
},
1837 { BFD_RELOC_MIPS_LITERAL
, R_MIPS_LITERAL
},
1838 { BFD_RELOC_MIPS_GOT16
, R_MIPS_GOT16
},
1839 { BFD_RELOC_16_PCREL
, R_MIPS_PC16
},
1840 { BFD_RELOC_MIPS_CALL16
, R_MIPS_CALL16
},
1841 { BFD_RELOC_MIPS_GPREL32
, R_MIPS_GPREL32
},
1842 { BFD_RELOC_MIPS_GOT_HI16
, R_MIPS_GOT_HI16
},
1843 { BFD_RELOC_MIPS_GOT_LO16
, R_MIPS_GOT_LO16
},
1844 { BFD_RELOC_MIPS_CALL_HI16
, R_MIPS_CALL_HI16
},
1845 { BFD_RELOC_MIPS_CALL_LO16
, R_MIPS_CALL_LO16
},
1846 { BFD_RELOC_MIPS_SUB
, R_MIPS_SUB
},
1847 { BFD_RELOC_MIPS_GOT_PAGE
, R_MIPS_GOT_PAGE
},
1848 { BFD_RELOC_MIPS_GOT_OFST
, R_MIPS_GOT_OFST
},
1849 { BFD_RELOC_MIPS_GOT_DISP
, R_MIPS_GOT_DISP
}
1852 /* Given a BFD reloc type, return a howto structure. */
1854 static reloc_howto_type
*
1855 bfd_elf32_bfd_reloc_type_lookup (abfd
, code
)
1857 bfd_reloc_code_real_type code
;
1861 for (i
= 0; i
< sizeof (mips_reloc_map
) / sizeof (struct elf_reloc_map
); i
++)
1863 if (mips_reloc_map
[i
].bfd_reloc_val
== code
)
1864 return &elf_mips_howto_table
[(int) mips_reloc_map
[i
].elf_reloc_val
];
1870 bfd_set_error (bfd_error_bad_value
);
1873 case BFD_RELOC_CTOR
:
1874 /* We need to handle BFD_RELOC_CTOR specially.
1875 Select the right relocation (R_MIPS_32 or R_MIPS_64) based on the
1876 size of addresses on this architecture. */
1877 if (bfd_arch_bits_per_address (abfd
) == 32)
1878 return &elf_mips_howto_table
[(int) R_MIPS_32
];
1880 return &elf_mips_ctor64_howto
;
1882 case BFD_RELOC_MIPS16_JMP
:
1883 return &elf_mips16_jump_howto
;
1884 case BFD_RELOC_MIPS16_GPREL
:
1885 return &elf_mips16_gprel_howto
;
1886 case BFD_RELOC_VTABLE_INHERIT
:
1887 return &elf_mips_gnu_vtinherit_howto
;
1888 case BFD_RELOC_VTABLE_ENTRY
:
1889 return &elf_mips_gnu_vtentry_howto
;
1893 /* Given a MIPS Elf32_Internal_Rel, fill in an arelent structure. */
1895 static reloc_howto_type
*
1896 mips_rtype_to_howto (r_type
)
1897 unsigned int r_type
;
1902 return &elf_mips16_jump_howto
;
1904 case R_MIPS16_GPREL
:
1905 return &elf_mips16_gprel_howto
;
1907 case R_MIPS_GNU_VTINHERIT
:
1908 return &elf_mips_gnu_vtinherit_howto
;
1910 case R_MIPS_GNU_VTENTRY
:
1911 return &elf_mips_gnu_vtentry_howto
;
1915 BFD_ASSERT (r_type
< (unsigned int) R_MIPS_max
);
1916 return &elf_mips_howto_table
[r_type
];
1921 /* Given a MIPS Elf32_Internal_Rel, fill in an arelent structure. */
1924 mips_info_to_howto_rel (abfd
, cache_ptr
, dst
)
1927 Elf32_Internal_Rel
*dst
;
1929 unsigned int r_type
;
1931 r_type
= ELF32_R_TYPE (dst
->r_info
);
1932 cache_ptr
->howto
= mips_rtype_to_howto (r_type
);
1934 /* The addend for a GPREL16 or LITERAL relocation comes from the GP
1935 value for the object file. We get the addend now, rather than
1936 when we do the relocation, because the symbol manipulations done
1937 by the linker may cause us to lose track of the input BFD. */
1938 if (((*cache_ptr
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) != 0
1939 && (r_type
== (unsigned int) R_MIPS_GPREL16
1940 || r_type
== (unsigned int) R_MIPS_LITERAL
))
1941 cache_ptr
->addend
= elf_gp (abfd
);
1944 /* Given a MIPS Elf32_Internal_Rela, fill in an arelent structure. */
1947 mips_info_to_howto_rela (abfd
, cache_ptr
, dst
)
1950 Elf32_Internal_Rela
*dst
;
1952 /* Since an Elf32_Internal_Rel is an initial prefix of an
1953 Elf32_Internal_Rela, we can just use mips_info_to_howto_rel
1955 mips_info_to_howto_rel (abfd
, cache_ptr
, (Elf32_Internal_Rel
*) dst
);
1957 /* If we ever need to do any extra processing with dst->r_addend
1958 (the field omitted in an Elf32_Internal_Rel) we can do it here. */
1961 /* A .reginfo section holds a single Elf32_RegInfo structure. These
1962 routines swap this structure in and out. They are used outside of
1963 BFD, so they are globally visible. */
1966 bfd_mips_elf32_swap_reginfo_in (abfd
, ex
, in
)
1968 const Elf32_External_RegInfo
*ex
;
1971 in
->ri_gprmask
= bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_gprmask
);
1972 in
->ri_cprmask
[0] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[0]);
1973 in
->ri_cprmask
[1] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[1]);
1974 in
->ri_cprmask
[2] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[2]);
1975 in
->ri_cprmask
[3] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[3]);
1976 in
->ri_gp_value
= bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_gp_value
);
1980 bfd_mips_elf32_swap_reginfo_out (abfd
, in
, ex
)
1982 const Elf32_RegInfo
*in
;
1983 Elf32_External_RegInfo
*ex
;
1985 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_gprmask
,
1986 (bfd_byte
*) ex
->ri_gprmask
);
1987 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[0],
1988 (bfd_byte
*) ex
->ri_cprmask
[0]);
1989 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[1],
1990 (bfd_byte
*) ex
->ri_cprmask
[1]);
1991 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[2],
1992 (bfd_byte
*) ex
->ri_cprmask
[2]);
1993 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[3],
1994 (bfd_byte
*) ex
->ri_cprmask
[3]);
1995 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_gp_value
,
1996 (bfd_byte
*) ex
->ri_gp_value
);
1999 /* In the 64 bit ABI, the .MIPS.options section holds register
2000 information in an Elf64_Reginfo structure. These routines swap
2001 them in and out. They are globally visible because they are used
2002 outside of BFD. These routines are here so that gas can call them
2003 without worrying about whether the 64 bit ABI has been included. */
2006 bfd_mips_elf64_swap_reginfo_in (abfd
, ex
, in
)
2008 const Elf64_External_RegInfo
*ex
;
2009 Elf64_Internal_RegInfo
*in
;
2011 in
->ri_gprmask
= bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_gprmask
);
2012 in
->ri_pad
= bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_pad
);
2013 in
->ri_cprmask
[0] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[0]);
2014 in
->ri_cprmask
[1] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[1]);
2015 in
->ri_cprmask
[2] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[2]);
2016 in
->ri_cprmask
[3] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[3]);
2017 in
->ri_gp_value
= bfd_h_get_64 (abfd
, (bfd_byte
*) ex
->ri_gp_value
);
2021 bfd_mips_elf64_swap_reginfo_out (abfd
, in
, ex
)
2023 const Elf64_Internal_RegInfo
*in
;
2024 Elf64_External_RegInfo
*ex
;
2026 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_gprmask
,
2027 (bfd_byte
*) ex
->ri_gprmask
);
2028 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_pad
,
2029 (bfd_byte
*) ex
->ri_pad
);
2030 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[0],
2031 (bfd_byte
*) ex
->ri_cprmask
[0]);
2032 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[1],
2033 (bfd_byte
*) ex
->ri_cprmask
[1]);
2034 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[2],
2035 (bfd_byte
*) ex
->ri_cprmask
[2]);
2036 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[3],
2037 (bfd_byte
*) ex
->ri_cprmask
[3]);
2038 bfd_h_put_64 (abfd
, (bfd_vma
) in
->ri_gp_value
,
2039 (bfd_byte
*) ex
->ri_gp_value
);
2042 /* Swap an entry in a .gptab section. Note that these routines rely
2043 on the equivalence of the two elements of the union. */
2046 bfd_mips_elf32_swap_gptab_in (abfd
, ex
, in
)
2048 const Elf32_External_gptab
*ex
;
2051 in
->gt_entry
.gt_g_value
= bfd_h_get_32 (abfd
, ex
->gt_entry
.gt_g_value
);
2052 in
->gt_entry
.gt_bytes
= bfd_h_get_32 (abfd
, ex
->gt_entry
.gt_bytes
);
2056 bfd_mips_elf32_swap_gptab_out (abfd
, in
, ex
)
2058 const Elf32_gptab
*in
;
2059 Elf32_External_gptab
*ex
;
2061 bfd_h_put_32 (abfd
, (bfd_vma
) in
->gt_entry
.gt_g_value
,
2062 ex
->gt_entry
.gt_g_value
);
2063 bfd_h_put_32 (abfd
, (bfd_vma
) in
->gt_entry
.gt_bytes
,
2064 ex
->gt_entry
.gt_bytes
);
2068 bfd_elf32_swap_compact_rel_out (abfd
, in
, ex
)
2070 const Elf32_compact_rel
*in
;
2071 Elf32_External_compact_rel
*ex
;
2073 bfd_h_put_32 (abfd
, (bfd_vma
) in
->id1
, ex
->id1
);
2074 bfd_h_put_32 (abfd
, (bfd_vma
) in
->num
, ex
->num
);
2075 bfd_h_put_32 (abfd
, (bfd_vma
) in
->id2
, ex
->id2
);
2076 bfd_h_put_32 (abfd
, (bfd_vma
) in
->offset
, ex
->offset
);
2077 bfd_h_put_32 (abfd
, (bfd_vma
) in
->reserved0
, ex
->reserved0
);
2078 bfd_h_put_32 (abfd
, (bfd_vma
) in
->reserved1
, ex
->reserved1
);
2082 bfd_elf32_swap_crinfo_out (abfd
, in
, ex
)
2084 const Elf32_crinfo
*in
;
2085 Elf32_External_crinfo
*ex
;
2089 l
= (((in
->ctype
& CRINFO_CTYPE
) << CRINFO_CTYPE_SH
)
2090 | ((in
->rtype
& CRINFO_RTYPE
) << CRINFO_RTYPE_SH
)
2091 | ((in
->dist2to
& CRINFO_DIST2TO
) << CRINFO_DIST2TO_SH
)
2092 | ((in
->relvaddr
& CRINFO_RELVADDR
) << CRINFO_RELVADDR_SH
));
2093 bfd_h_put_32 (abfd
, (bfd_vma
) l
, ex
->info
);
2094 bfd_h_put_32 (abfd
, (bfd_vma
) in
->konst
, ex
->konst
);
2095 bfd_h_put_32 (abfd
, (bfd_vma
) in
->vaddr
, ex
->vaddr
);
2098 /* Swap in an options header. */
2101 bfd_mips_elf_swap_options_in (abfd
, ex
, in
)
2103 const Elf_External_Options
*ex
;
2104 Elf_Internal_Options
*in
;
2106 in
->kind
= bfd_h_get_8 (abfd
, ex
->kind
);
2107 in
->size
= bfd_h_get_8 (abfd
, ex
->size
);
2108 in
->section
= bfd_h_get_16 (abfd
, ex
->section
);
2109 in
->info
= bfd_h_get_32 (abfd
, ex
->info
);
2112 /* Swap out an options header. */
2115 bfd_mips_elf_swap_options_out (abfd
, in
, ex
)
2117 const Elf_Internal_Options
*in
;
2118 Elf_External_Options
*ex
;
2120 bfd_h_put_8 (abfd
, in
->kind
, ex
->kind
);
2121 bfd_h_put_8 (abfd
, in
->size
, ex
->size
);
2122 bfd_h_put_16 (abfd
, in
->section
, ex
->section
);
2123 bfd_h_put_32 (abfd
, in
->info
, ex
->info
);
2126 /* Swap in an MSYM entry. */
2129 bfd_mips_elf_swap_msym_in (abfd
, ex
, in
)
2131 const Elf32_External_Msym
*ex
;
2132 Elf32_Internal_Msym
*in
;
2134 in
->ms_hash_value
= bfd_h_get_32 (abfd
, ex
->ms_hash_value
);
2135 in
->ms_info
= bfd_h_get_32 (abfd
, ex
->ms_info
);
2138 /* Swap out an MSYM entry. */
2141 bfd_mips_elf_swap_msym_out (abfd
, in
, ex
)
2143 const Elf32_Internal_Msym
*in
;
2144 Elf32_External_Msym
*ex
;
2146 bfd_h_put_32 (abfd
, in
->ms_hash_value
, ex
->ms_hash_value
);
2147 bfd_h_put_32 (abfd
, in
->ms_info
, ex
->ms_info
);
2151 /* Determine whether a symbol is global for the purposes of splitting
2152 the symbol table into global symbols and local symbols. At least
2153 on Irix 5, this split must be between section symbols and all other
2154 symbols. On most ELF targets the split is between static symbols
2155 and externally visible symbols. */
2159 mips_elf_sym_is_global (abfd
, sym
)
2160 bfd
*abfd ATTRIBUTE_UNUSED
;
2163 return (sym
->flags
& BSF_SECTION_SYM
) == 0 ? true : false;
2166 /* Set the right machine number for a MIPS ELF file. This is used for
2167 both the 32-bit and the 64-bit ABI. */
2170 _bfd_mips_elf_object_p (abfd
)
2173 /* Irix 5 and 6 is broken. Object file symbol tables are not always
2174 sorted correctly such that local symbols precede global symbols,
2175 and the sh_info field in the symbol table is not always right. */
2176 elf_bad_symtab (abfd
) = true;
2178 bfd_default_set_arch_mach (abfd
, bfd_arch_mips
,
2179 elf_mips_mach (elf_elfheader (abfd
)->e_flags
));
2183 /* The final processing done just before writing out a MIPS ELF object
2184 file. This gets the MIPS architecture right based on the machine
2185 number. This is used by both the 32-bit and the 64-bit ABI. */
2189 _bfd_mips_elf_final_write_processing (abfd
, linker
)
2191 boolean linker ATTRIBUTE_UNUSED
;
2195 Elf_Internal_Shdr
**hdrpp
;
2199 switch (bfd_get_mach (abfd
))
2202 case bfd_mach_mips3000
:
2203 val
= E_MIPS_ARCH_1
;
2206 case bfd_mach_mips3900
:
2207 val
= E_MIPS_ARCH_1
| E_MIPS_MACH_3900
;
2210 case bfd_mach_mips6000
:
2211 val
= E_MIPS_ARCH_2
;
2214 case bfd_mach_mips4000
:
2215 case bfd_mach_mips4300
:
2216 val
= E_MIPS_ARCH_3
;
2219 case bfd_mach_mips4010
:
2220 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4010
;
2223 case bfd_mach_mips4100
:
2224 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4100
;
2227 case bfd_mach_mips4111
:
2228 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4111
;
2231 case bfd_mach_mips4650
:
2232 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4650
;
2235 case bfd_mach_mips8000
:
2236 val
= E_MIPS_ARCH_4
;
2240 elf_elfheader (abfd
)->e_flags
&= ~ (EF_MIPS_ARCH
| EF_MIPS_MACH
);
2241 elf_elfheader (abfd
)->e_flags
|= val
;
2243 /* Set the sh_info field for .gptab sections and other appropriate
2244 info for each special section. */
2245 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
2246 i
< elf_elfheader (abfd
)->e_shnum
;
2249 switch ((*hdrpp
)->sh_type
)
2252 case SHT_MIPS_LIBLIST
:
2253 sec
= bfd_get_section_by_name (abfd
, ".dynstr");
2255 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
2258 case SHT_MIPS_GPTAB
:
2259 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
2260 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
2261 BFD_ASSERT (name
!= NULL
2262 && strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0);
2263 sec
= bfd_get_section_by_name (abfd
, name
+ sizeof ".gptab" - 1);
2264 BFD_ASSERT (sec
!= NULL
);
2265 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
2268 case SHT_MIPS_CONTENT
:
2269 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
2270 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
2271 BFD_ASSERT (name
!= NULL
2272 && strncmp (name
, ".MIPS.content",
2273 sizeof ".MIPS.content" - 1) == 0);
2274 sec
= bfd_get_section_by_name (abfd
,
2275 name
+ sizeof ".MIPS.content" - 1);
2276 BFD_ASSERT (sec
!= NULL
);
2277 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
2280 case SHT_MIPS_SYMBOL_LIB
:
2281 sec
= bfd_get_section_by_name (abfd
, ".dynsym");
2283 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
2284 sec
= bfd_get_section_by_name (abfd
, ".liblist");
2286 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
2289 case SHT_MIPS_EVENTS
:
2290 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
2291 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
2292 BFD_ASSERT (name
!= NULL
);
2293 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0)
2294 sec
= bfd_get_section_by_name (abfd
,
2295 name
+ sizeof ".MIPS.events" - 1);
2298 BFD_ASSERT (strncmp (name
, ".MIPS.post_rel",
2299 sizeof ".MIPS.post_rel" - 1) == 0);
2300 sec
= bfd_get_section_by_name (abfd
,
2302 + sizeof ".MIPS.post_rel" - 1));
2304 BFD_ASSERT (sec
!= NULL
);
2305 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
2312 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
2315 _bfd_mips_elf_set_private_flags (abfd
, flags
)
2319 BFD_ASSERT (!elf_flags_init (abfd
)
2320 || elf_elfheader (abfd
)->e_flags
== flags
);
2322 elf_elfheader (abfd
)->e_flags
= flags
;
2323 elf_flags_init (abfd
) = true;
2327 /* Copy backend specific data from one object module to another */
2330 _bfd_mips_elf_copy_private_bfd_data (ibfd
, obfd
)
2334 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2335 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2338 BFD_ASSERT (!elf_flags_init (obfd
)
2339 || (elf_elfheader (obfd
)->e_flags
2340 == elf_elfheader (ibfd
)->e_flags
));
2342 elf_gp (obfd
) = elf_gp (ibfd
);
2343 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
2344 elf_flags_init (obfd
) = true;
2348 /* Merge backend specific data from an object file to the output
2349 object file when linking. */
2352 _bfd_mips_elf_merge_private_bfd_data (ibfd
, obfd
)
2360 /* Check if we have the same endianess */
2361 if (ibfd
->xvec
->byteorder
!= obfd
->xvec
->byteorder
2362 && obfd
->xvec
->byteorder
!= BFD_ENDIAN_UNKNOWN
)
2366 if (bfd_big_endian (ibfd
))
2367 msg
= _("%s: compiled for a big endian system and target is little endian");
2369 msg
= _("%s: compiled for a little endian system and target is big endian");
2371 (*_bfd_error_handler
) (msg
, bfd_get_filename (ibfd
));
2373 bfd_set_error (bfd_error_wrong_format
);
2377 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2378 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2381 new_flags
= elf_elfheader (ibfd
)->e_flags
;
2382 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_NOREORDER
;
2383 old_flags
= elf_elfheader (obfd
)->e_flags
;
2385 if (! elf_flags_init (obfd
))
2387 elf_flags_init (obfd
) = true;
2388 elf_elfheader (obfd
)->e_flags
= new_flags
;
2389 elf_elfheader (obfd
)->e_ident
[EI_CLASS
]
2390 = elf_elfheader (ibfd
)->e_ident
[EI_CLASS
];
2392 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
2393 && bfd_get_arch_info (obfd
)->the_default
)
2395 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
2396 bfd_get_mach (ibfd
)))
2403 /* Check flag compatibility. */
2405 new_flags
&= ~EF_MIPS_NOREORDER
;
2406 old_flags
&= ~EF_MIPS_NOREORDER
;
2408 if (new_flags
== old_flags
)
2413 if ((new_flags
& EF_MIPS_PIC
) != (old_flags
& EF_MIPS_PIC
))
2415 new_flags
&= ~EF_MIPS_PIC
;
2416 old_flags
&= ~EF_MIPS_PIC
;
2417 (*_bfd_error_handler
)
2418 (_("%s: linking PIC files with non-PIC files"),
2419 bfd_get_filename (ibfd
));
2423 if ((new_flags
& EF_MIPS_CPIC
) != (old_flags
& EF_MIPS_CPIC
))
2425 new_flags
&= ~EF_MIPS_CPIC
;
2426 old_flags
&= ~EF_MIPS_CPIC
;
2427 (*_bfd_error_handler
)
2428 (_("%s: linking abicalls files with non-abicalls files"),
2429 bfd_get_filename (ibfd
));
2433 /* Compare the ISA's. */
2434 if ((new_flags
& (EF_MIPS_ARCH
| EF_MIPS_MACH
))
2435 != (old_flags
& (EF_MIPS_ARCH
| EF_MIPS_MACH
)))
2437 int new_mach
= new_flags
& EF_MIPS_MACH
;
2438 int old_mach
= old_flags
& EF_MIPS_MACH
;
2439 int new_isa
= elf_mips_isa (new_flags
);
2440 int old_isa
= elf_mips_isa (old_flags
);
2442 /* If either has no machine specified, just compare the general isa's.
2443 Some combinations of machines are ok, if the isa's match. */
2446 || new_mach
== old_mach
2449 /* Don't warn about mixing -mips1 and -mips2 code, or mixing -mips3
2450 and -mips4 code. They will normally use the same data sizes and
2451 calling conventions. */
2453 if ((new_isa
== 1 || new_isa
== 2)
2454 ? (old_isa
!= 1 && old_isa
!= 2)
2455 : (old_isa
== 1 || old_isa
== 2))
2457 (*_bfd_error_handler
)
2458 (_("%s: ISA mismatch (-mips%d) with previous modules (-mips%d)"),
2459 bfd_get_filename (ibfd
), new_isa
, old_isa
);
2466 (*_bfd_error_handler
)
2467 (_("%s: ISA mismatch (%d) with previous modules (%d)"),
2468 bfd_get_filename (ibfd
),
2469 elf_mips_mach (new_flags
),
2470 elf_mips_mach (old_flags
));
2474 new_flags
&= ~ (EF_MIPS_ARCH
| EF_MIPS_MACH
);
2475 old_flags
&= ~ (EF_MIPS_ARCH
| EF_MIPS_MACH
);
2478 /* Compare ABI's. The 64-bit ABI does not use EF_MIPS_ABI. But, it
2479 does set EI_CLASS differently from any 32-bit ABI. */
2480 if ((new_flags
& EF_MIPS_ABI
) != (old_flags
& EF_MIPS_ABI
)
2481 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
2482 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
2484 /* Only error if both are set (to different values). */
2485 if (((new_flags
& EF_MIPS_ABI
) && (old_flags
& EF_MIPS_ABI
))
2486 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
2487 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
2489 (*_bfd_error_handler
)
2490 (_("%s: ABI mismatch: linking %s module with previous %s modules"),
2491 bfd_get_filename (ibfd
),
2492 elf_mips_abi_name (ibfd
),
2493 elf_mips_abi_name (obfd
));
2496 new_flags
&= ~EF_MIPS_ABI
;
2497 old_flags
&= ~EF_MIPS_ABI
;
2500 /* Warn about any other mismatches */
2501 if (new_flags
!= old_flags
)
2503 (*_bfd_error_handler
)
2504 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
2505 bfd_get_filename (ibfd
), (unsigned long) new_flags
,
2506 (unsigned long) old_flags
);
2512 bfd_set_error (bfd_error_bad_value
);
2520 _bfd_mips_elf_print_private_bfd_data (abfd
, ptr
)
2524 FILE *file
= (FILE *) ptr
;
2526 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
2528 /* Print normal ELF private data. */
2529 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
2531 /* xgettext:c-format */
2532 fprintf (file
, _ ("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
2534 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
)
2535 fprintf (file
, _ (" [abi=O32]"));
2536 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O64
)
2537 fprintf (file
, _ (" [abi=O64]"));
2538 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
)
2539 fprintf (file
, _ (" [abi=EABI32]"));
2540 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
2541 fprintf (file
, _ (" [abi=EABI64]"));
2542 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
))
2543 fprintf (file
, _ (" [abi unknown]"));
2544 else if (ABI_N32_P (abfd
))
2545 fprintf (file
, _ (" [abi=N32]"));
2546 else if (ABI_64_P (abfd
))
2547 fprintf (file
, _ (" [abi=64]"));
2549 fprintf (file
, _ (" [no abi set]"));
2551 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
2552 fprintf (file
, _ (" [mips1]"));
2553 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
2554 fprintf (file
, _ (" [mips2]"));
2555 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
2556 fprintf (file
, _ (" [mips3]"));
2557 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
2558 fprintf (file
, _ (" [mips4]"));
2560 fprintf (file
, _ (" [unknown ISA]"));
2562 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_32BITMODE
)
2563 fprintf (file
, _ (" [32bitmode]"));
2565 fprintf (file
, _ (" [not 32bitmode]"));
2572 /* Handle a MIPS specific section when reading an object file. This
2573 is called when elfcode.h finds a section with an unknown type.
2574 This routine supports both the 32-bit and 64-bit ELF ABI.
2576 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
2580 _bfd_mips_elf_section_from_shdr (abfd
, hdr
, name
)
2582 Elf_Internal_Shdr
*hdr
;
2587 /* There ought to be a place to keep ELF backend specific flags, but
2588 at the moment there isn't one. We just keep track of the
2589 sections by their name, instead. Fortunately, the ABI gives
2590 suggested names for all the MIPS specific sections, so we will
2591 probably get away with this. */
2592 switch (hdr
->sh_type
)
2594 case SHT_MIPS_LIBLIST
:
2595 if (strcmp (name
, ".liblist") != 0)
2599 if (strcmp (name
, MIPS_ELF_MSYM_SECTION_NAME (abfd
)) != 0)
2602 case SHT_MIPS_CONFLICT
:
2603 if (strcmp (name
, ".conflict") != 0)
2606 case SHT_MIPS_GPTAB
:
2607 if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) != 0)
2610 case SHT_MIPS_UCODE
:
2611 if (strcmp (name
, ".ucode") != 0)
2614 case SHT_MIPS_DEBUG
:
2615 if (strcmp (name
, ".mdebug") != 0)
2617 flags
= SEC_DEBUGGING
;
2619 case SHT_MIPS_REGINFO
:
2620 if (strcmp (name
, ".reginfo") != 0
2621 || hdr
->sh_size
!= sizeof (Elf32_External_RegInfo
))
2623 flags
= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_SIZE
);
2625 case SHT_MIPS_IFACE
:
2626 if (strcmp (name
, ".MIPS.interfaces") != 0)
2629 case SHT_MIPS_CONTENT
:
2630 if (strncmp (name
, ".MIPS.content", sizeof ".MIPS.content" - 1) != 0)
2633 case SHT_MIPS_OPTIONS
:
2634 if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) != 0)
2637 case SHT_MIPS_DWARF
:
2638 if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) != 0)
2641 case SHT_MIPS_SYMBOL_LIB
:
2642 if (strcmp (name
, ".MIPS.symlib") != 0)
2645 case SHT_MIPS_EVENTS
:
2646 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) != 0
2647 && strncmp (name
, ".MIPS.post_rel",
2648 sizeof ".MIPS.post_rel" - 1) != 0)
2655 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
2660 if (! bfd_set_section_flags (abfd
, hdr
->bfd_section
,
2661 (bfd_get_section_flags (abfd
,
2667 /* FIXME: We should record sh_info for a .gptab section. */
2669 /* For a .reginfo section, set the gp value in the tdata information
2670 from the contents of this section. We need the gp value while
2671 processing relocs, so we just get it now. The .reginfo section
2672 is not used in the 64-bit MIPS ELF ABI. */
2673 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
2675 Elf32_External_RegInfo ext
;
2678 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, (PTR
) &ext
,
2679 (file_ptr
) 0, sizeof ext
))
2681 bfd_mips_elf32_swap_reginfo_in (abfd
, &ext
, &s
);
2682 elf_gp (abfd
) = s
.ri_gp_value
;
2685 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
2686 set the gp value based on what we find. We may see both
2687 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
2688 they should agree. */
2689 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
)
2691 bfd_byte
*contents
, *l
, *lend
;
2693 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
2694 if (contents
== NULL
)
2696 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
,
2697 (file_ptr
) 0, hdr
->sh_size
))
2703 lend
= contents
+ hdr
->sh_size
;
2704 while (l
+ sizeof (Elf_External_Options
) <= lend
)
2706 Elf_Internal_Options intopt
;
2708 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
2710 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
2712 Elf64_Internal_RegInfo intreg
;
2714 bfd_mips_elf64_swap_reginfo_in
2716 ((Elf64_External_RegInfo
*)
2717 (l
+ sizeof (Elf_External_Options
))),
2719 elf_gp (abfd
) = intreg
.ri_gp_value
;
2721 else if (intopt
.kind
== ODK_REGINFO
)
2723 Elf32_RegInfo intreg
;
2725 bfd_mips_elf32_swap_reginfo_in
2727 ((Elf32_External_RegInfo
*)
2728 (l
+ sizeof (Elf_External_Options
))),
2730 elf_gp (abfd
) = intreg
.ri_gp_value
;
2740 /* Set the correct type for a MIPS ELF section. We do this by the
2741 section name, which is a hack, but ought to work. This routine is
2742 used by both the 32-bit and the 64-bit ABI. */
2745 _bfd_mips_elf_fake_sections (abfd
, hdr
, sec
)
2747 Elf32_Internal_Shdr
*hdr
;
2750 register const char *name
;
2752 name
= bfd_get_section_name (abfd
, sec
);
2754 if (strcmp (name
, ".liblist") == 0)
2756 hdr
->sh_type
= SHT_MIPS_LIBLIST
;
2757 hdr
->sh_info
= sec
->_raw_size
/ sizeof (Elf32_Lib
);
2758 /* The sh_link field is set in final_write_processing. */
2760 else if (strcmp (name
, ".conflict") == 0)
2761 hdr
->sh_type
= SHT_MIPS_CONFLICT
;
2762 else if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0)
2764 hdr
->sh_type
= SHT_MIPS_GPTAB
;
2765 hdr
->sh_entsize
= sizeof (Elf32_External_gptab
);
2766 /* The sh_info field is set in final_write_processing. */
2768 else if (strcmp (name
, ".ucode") == 0)
2769 hdr
->sh_type
= SHT_MIPS_UCODE
;
2770 else if (strcmp (name
, ".mdebug") == 0)
2772 hdr
->sh_type
= SHT_MIPS_DEBUG
;
2773 /* In a shared object on Irix 5.3, the .mdebug section has an
2774 entsize of 0. FIXME: Does this matter? */
2775 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
2776 hdr
->sh_entsize
= 0;
2778 hdr
->sh_entsize
= 1;
2780 else if (strcmp (name
, ".reginfo") == 0)
2782 hdr
->sh_type
= SHT_MIPS_REGINFO
;
2783 /* In a shared object on Irix 5.3, the .reginfo section has an
2784 entsize of 0x18. FIXME: Does this matter? */
2785 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
2786 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
2788 hdr
->sh_entsize
= 1;
2790 else if (SGI_COMPAT (abfd
)
2791 && (strcmp (name
, ".hash") == 0
2792 || strcmp (name
, ".dynamic") == 0
2793 || strcmp (name
, ".dynstr") == 0))
2795 hdr
->sh_entsize
= 0;
2797 /* This isn't how the Irix 6 linker behaves. */
2798 hdr
->sh_info
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
2801 else if (strcmp (name
, ".got") == 0
2802 || strcmp (name
, MIPS_ELF_SRDATA_SECTION_NAME (abfd
)) == 0
2803 || strcmp (name
, ".sdata") == 0
2804 || strcmp (name
, ".sbss") == 0
2805 || strcmp (name
, ".lit4") == 0
2806 || strcmp (name
, ".lit8") == 0)
2807 hdr
->sh_flags
|= SHF_MIPS_GPREL
;
2808 else if (strcmp (name
, ".MIPS.interfaces") == 0)
2810 hdr
->sh_type
= SHT_MIPS_IFACE
;
2811 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
2813 else if (strncmp (name
, ".MIPS.content", strlen (".MIPS.content")) == 0)
2815 hdr
->sh_type
= SHT_MIPS_CONTENT
;
2816 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
2817 /* The sh_info field is set in final_write_processing. */
2819 else if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
2821 hdr
->sh_type
= SHT_MIPS_OPTIONS
;
2822 hdr
->sh_entsize
= 1;
2823 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
2825 else if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) == 0)
2826 hdr
->sh_type
= SHT_MIPS_DWARF
;
2827 else if (strcmp (name
, ".MIPS.symlib") == 0)
2829 hdr
->sh_type
= SHT_MIPS_SYMBOL_LIB
;
2830 /* The sh_link and sh_info fields are set in
2831 final_write_processing. */
2833 else if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0
2834 || strncmp (name
, ".MIPS.post_rel",
2835 sizeof ".MIPS.post_rel" - 1) == 0)
2837 hdr
->sh_type
= SHT_MIPS_EVENTS
;
2838 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
2839 /* The sh_link field is set in final_write_processing. */
2841 else if (strcmp (name
, MIPS_ELF_MSYM_SECTION_NAME (abfd
)) == 0)
2843 hdr
->sh_type
= SHT_MIPS_MSYM
;
2844 hdr
->sh_flags
|= SHF_ALLOC
;
2845 hdr
->sh_entsize
= 8;
2848 /* The generic elf_fake_sections will set up REL_HDR using the
2849 default kind of relocations. But, we may actually need both
2850 kinds of relocations, so we set up the second header here. */
2851 if ((sec
->flags
& SEC_RELOC
) != 0)
2853 struct bfd_elf_section_data
*esd
;
2855 esd
= elf_section_data (sec
);
2856 BFD_ASSERT (esd
->rel_hdr2
== NULL
);
2858 = (Elf_Internal_Shdr
*) bfd_zalloc (abfd
, sizeof (Elf_Internal_Shdr
));
2861 _bfd_elf_init_reloc_shdr (abfd
, esd
->rel_hdr2
, sec
,
2862 !elf_section_data (sec
)->use_rela_p
);
2868 /* Given a BFD section, try to locate the corresponding ELF section
2869 index. This is used by both the 32-bit and the 64-bit ABI.
2870 Actually, it's not clear to me that the 64-bit ABI supports these,
2871 but for non-PIC objects we will certainly want support for at least
2872 the .scommon section. */
2875 _bfd_mips_elf_section_from_bfd_section (abfd
, hdr
, sec
, retval
)
2876 bfd
*abfd ATTRIBUTE_UNUSED
;
2877 Elf32_Internal_Shdr
*hdr ATTRIBUTE_UNUSED
;
2881 if (strcmp (bfd_get_section_name (abfd
, sec
), ".scommon") == 0)
2883 *retval
= SHN_MIPS_SCOMMON
;
2886 if (strcmp (bfd_get_section_name (abfd
, sec
), ".acommon") == 0)
2888 *retval
= SHN_MIPS_ACOMMON
;
2894 /* When are writing out the .options or .MIPS.options section,
2895 remember the bytes we are writing out, so that we can install the
2896 GP value in the section_processing routine. */
2899 _bfd_mips_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
2904 bfd_size_type count
;
2906 if (strcmp (section
->name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
2910 if (elf_section_data (section
) == NULL
)
2912 section
->used_by_bfd
=
2913 (PTR
) bfd_zalloc (abfd
, sizeof (struct bfd_elf_section_data
));
2914 if (elf_section_data (section
) == NULL
)
2917 c
= (bfd_byte
*) elf_section_data (section
)->tdata
;
2922 if (section
->_cooked_size
!= 0)
2923 size
= section
->_cooked_size
;
2925 size
= section
->_raw_size
;
2926 c
= (bfd_byte
*) bfd_zalloc (abfd
, size
);
2929 elf_section_data (section
)->tdata
= (PTR
) c
;
2932 memcpy (c
+ offset
, location
, count
);
2935 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
,
2939 /* Work over a section just before writing it out. This routine is
2940 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
2941 sections that need the SHF_MIPS_GPREL flag by name; there has to be
2945 _bfd_mips_elf_section_processing (abfd
, hdr
)
2947 Elf_Internal_Shdr
*hdr
;
2949 if (hdr
->sh_type
== SHT_MIPS_REGINFO
2950 && hdr
->sh_size
> 0)
2954 BFD_ASSERT (hdr
->sh_size
== sizeof (Elf32_External_RegInfo
));
2955 BFD_ASSERT (hdr
->contents
== NULL
);
2958 hdr
->sh_offset
+ sizeof (Elf32_External_RegInfo
) - 4,
2961 bfd_h_put_32 (abfd
, (bfd_vma
) elf_gp (abfd
), buf
);
2962 if (bfd_write (buf
, (bfd_size_type
) 1, (bfd_size_type
) 4, abfd
) != 4)
2966 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
2967 && hdr
->bfd_section
!= NULL
2968 && elf_section_data (hdr
->bfd_section
) != NULL
2969 && elf_section_data (hdr
->bfd_section
)->tdata
!= NULL
)
2971 bfd_byte
*contents
, *l
, *lend
;
2973 /* We stored the section contents in the elf_section_data tdata
2974 field in the set_section_contents routine. We save the
2975 section contents so that we don't have to read them again.
2976 At this point we know that elf_gp is set, so we can look
2977 through the section contents to see if there is an
2978 ODK_REGINFO structure. */
2980 contents
= (bfd_byte
*) elf_section_data (hdr
->bfd_section
)->tdata
;
2982 lend
= contents
+ hdr
->sh_size
;
2983 while (l
+ sizeof (Elf_External_Options
) <= lend
)
2985 Elf_Internal_Options intopt
;
2987 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
2989 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
2996 + sizeof (Elf_External_Options
)
2997 + (sizeof (Elf64_External_RegInfo
) - 8)),
3000 bfd_h_put_64 (abfd
, elf_gp (abfd
), buf
);
3001 if (bfd_write (buf
, 1, 8, abfd
) != 8)
3004 else if (intopt
.kind
== ODK_REGINFO
)
3011 + sizeof (Elf_External_Options
)
3012 + (sizeof (Elf32_External_RegInfo
) - 4)),
3015 bfd_h_put_32 (abfd
, elf_gp (abfd
), buf
);
3016 if (bfd_write (buf
, 1, 4, abfd
) != 4)
3023 if (hdr
->bfd_section
!= NULL
)
3025 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
3027 if (strcmp (name
, ".sdata") == 0
3028 || strcmp (name
, ".lit8") == 0
3029 || strcmp (name
, ".lit4") == 0)
3031 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
3032 hdr
->sh_type
= SHT_PROGBITS
;
3034 else if (strcmp (name
, ".sbss") == 0)
3036 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
3037 hdr
->sh_type
= SHT_NOBITS
;
3039 else if (strcmp (name
, MIPS_ELF_SRDATA_SECTION_NAME (abfd
)) == 0)
3041 hdr
->sh_flags
|= SHF_ALLOC
| SHF_MIPS_GPREL
;
3042 hdr
->sh_type
= SHT_PROGBITS
;
3044 else if (strcmp (name
, ".compact_rel") == 0)
3047 hdr
->sh_type
= SHT_PROGBITS
;
3049 else if (strcmp (name
, ".rtproc") == 0)
3051 if (hdr
->sh_addralign
!= 0 && hdr
->sh_entsize
== 0)
3053 unsigned int adjust
;
3055 adjust
= hdr
->sh_size
% hdr
->sh_addralign
;
3057 hdr
->sh_size
+= hdr
->sh_addralign
- adjust
;
3066 /* MIPS ELF uses two common sections. One is the usual one, and the
3067 other is for small objects. All the small objects are kept
3068 together, and then referenced via the gp pointer, which yields
3069 faster assembler code. This is what we use for the small common
3070 section. This approach is copied from ecoff.c. */
3071 static asection mips_elf_scom_section
;
3072 static asymbol mips_elf_scom_symbol
;
3073 static asymbol
*mips_elf_scom_symbol_ptr
;
3075 /* MIPS ELF also uses an acommon section, which represents an
3076 allocated common symbol which may be overridden by a
3077 definition in a shared library. */
3078 static asection mips_elf_acom_section
;
3079 static asymbol mips_elf_acom_symbol
;
3080 static asymbol
*mips_elf_acom_symbol_ptr
;
3082 /* The Irix 5 support uses two virtual sections, which represent
3083 text/data symbols defined in dynamic objects. */
3084 static asection mips_elf_text_section
;
3085 static asection
*mips_elf_text_section_ptr
;
3086 static asymbol mips_elf_text_symbol
;
3087 static asymbol
*mips_elf_text_symbol_ptr
;
3089 static asection mips_elf_data_section
;
3090 static asection
*mips_elf_data_section_ptr
;
3091 static asymbol mips_elf_data_symbol
;
3092 static asymbol
*mips_elf_data_symbol_ptr
;
3094 /* Handle the special MIPS section numbers that a symbol may use.
3095 This is used for both the 32-bit and the 64-bit ABI. */
3098 _bfd_mips_elf_symbol_processing (abfd
, asym
)
3102 elf_symbol_type
*elfsym
;
3104 elfsym
= (elf_symbol_type
*) asym
;
3105 switch (elfsym
->internal_elf_sym
.st_shndx
)
3107 case SHN_MIPS_ACOMMON
:
3108 /* This section is used in a dynamically linked executable file.
3109 It is an allocated common section. The dynamic linker can
3110 either resolve these symbols to something in a shared
3111 library, or it can just leave them here. For our purposes,
3112 we can consider these symbols to be in a new section. */
3113 if (mips_elf_acom_section
.name
== NULL
)
3115 /* Initialize the acommon section. */
3116 mips_elf_acom_section
.name
= ".acommon";
3117 mips_elf_acom_section
.flags
= SEC_ALLOC
;
3118 mips_elf_acom_section
.output_section
= &mips_elf_acom_section
;
3119 mips_elf_acom_section
.symbol
= &mips_elf_acom_symbol
;
3120 mips_elf_acom_section
.symbol_ptr_ptr
= &mips_elf_acom_symbol_ptr
;
3121 mips_elf_acom_symbol
.name
= ".acommon";
3122 mips_elf_acom_symbol
.flags
= BSF_SECTION_SYM
;
3123 mips_elf_acom_symbol
.section
= &mips_elf_acom_section
;
3124 mips_elf_acom_symbol_ptr
= &mips_elf_acom_symbol
;
3126 asym
->section
= &mips_elf_acom_section
;
3130 /* Common symbols less than the GP size are automatically
3131 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
3132 if (asym
->value
> elf_gp_size (abfd
)
3133 || IRIX_COMPAT (abfd
) == ict_irix6
)
3136 case SHN_MIPS_SCOMMON
:
3137 if (mips_elf_scom_section
.name
== NULL
)
3139 /* Initialize the small common section. */
3140 mips_elf_scom_section
.name
= ".scommon";
3141 mips_elf_scom_section
.flags
= SEC_IS_COMMON
;
3142 mips_elf_scom_section
.output_section
= &mips_elf_scom_section
;
3143 mips_elf_scom_section
.symbol
= &mips_elf_scom_symbol
;
3144 mips_elf_scom_section
.symbol_ptr_ptr
= &mips_elf_scom_symbol_ptr
;
3145 mips_elf_scom_symbol
.name
= ".scommon";
3146 mips_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
3147 mips_elf_scom_symbol
.section
= &mips_elf_scom_section
;
3148 mips_elf_scom_symbol_ptr
= &mips_elf_scom_symbol
;
3150 asym
->section
= &mips_elf_scom_section
;
3151 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
3154 case SHN_MIPS_SUNDEFINED
:
3155 asym
->section
= bfd_und_section_ptr
;
3158 #if 0 /* for SGI_COMPAT */
3160 asym
->section
= mips_elf_text_section_ptr
;
3164 asym
->section
= mips_elf_data_section_ptr
;
3170 /* When creating an Irix 5 executable, we need REGINFO and RTPROC
3174 _bfd_mips_elf_additional_program_headers (abfd
)
3180 if (!SGI_COMPAT (abfd
))
3183 /* See if we need a PT_MIPS_REGINFO segment. */
3184 s
= bfd_get_section_by_name (abfd
, ".reginfo");
3185 if (s
&& (s
->flags
& SEC_LOAD
))
3188 /* See if we need a PT_MIPS_OPTIONS segment. */
3189 if (IRIX_COMPAT (abfd
) == ict_irix6
3190 && bfd_get_section_by_name (abfd
,
3191 MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)))
3194 /* See if we need a PT_MIPS_RTPROC segment. */
3195 if (IRIX_COMPAT (abfd
) == ict_irix5
3196 && bfd_get_section_by_name (abfd
, ".dynamic")
3197 && bfd_get_section_by_name (abfd
, ".mdebug"))
3203 /* Modify the segment map for an Irix 5 executable. */
3206 _bfd_mips_elf_modify_segment_map (abfd
)
3210 struct elf_segment_map
*m
, **pm
;
3212 if (! SGI_COMPAT (abfd
))
3215 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
3217 s
= bfd_get_section_by_name (abfd
, ".reginfo");
3218 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3220 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
3221 if (m
->p_type
== PT_MIPS_REGINFO
)
3225 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, sizeof *m
);
3229 m
->p_type
= PT_MIPS_REGINFO
;
3233 /* We want to put it after the PHDR and INTERP segments. */
3234 pm
= &elf_tdata (abfd
)->segment_map
;
3236 && ((*pm
)->p_type
== PT_PHDR
3237 || (*pm
)->p_type
== PT_INTERP
))
3245 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
3246 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
3247 PT_OPTIONS segement immediately following the program header
3249 if (IRIX_COMPAT (abfd
) == ict_irix6
)
3253 for (s
= abfd
->sections
; s
; s
= s
->next
)
3254 if (elf_section_data (s
)->this_hdr
.sh_type
== SHT_MIPS_OPTIONS
)
3259 struct elf_segment_map
*options_segment
;
3261 /* Usually, there's a program header table. But, sometimes
3262 there's not (like when running the `ld' testsuite). So,
3263 if there's no program header table, we just put the
3264 options segement at the end. */
3265 for (pm
= &elf_tdata (abfd
)->segment_map
;
3268 if ((*pm
)->p_type
== PT_PHDR
)
3271 options_segment
= bfd_zalloc (abfd
,
3272 sizeof (struct elf_segment_map
));
3273 options_segment
->next
= *pm
;
3274 options_segment
->p_type
= PT_MIPS_OPTIONS
;
3275 options_segment
->p_flags
= PF_R
;
3276 options_segment
->p_flags_valid
= true;
3277 options_segment
->count
= 1;
3278 options_segment
->sections
[0] = s
;
3279 *pm
= options_segment
;
3284 /* If there are .dynamic and .mdebug sections, we make a room
3285 for the RTPROC header. FIXME: Rewrite without section names. */
3286 if (bfd_get_section_by_name (abfd
, ".interp") == NULL
3287 && bfd_get_section_by_name (abfd
, ".dynamic") != NULL
3288 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
3290 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
3291 if (m
->p_type
== PT_MIPS_RTPROC
)
3295 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, sizeof *m
);
3299 m
->p_type
= PT_MIPS_RTPROC
;
3301 s
= bfd_get_section_by_name (abfd
, ".rtproc");
3306 m
->p_flags_valid
= 1;
3314 /* We want to put it after the DYNAMIC segment. */
3315 pm
= &elf_tdata (abfd
)->segment_map
;
3316 while (*pm
!= NULL
&& (*pm
)->p_type
!= PT_DYNAMIC
)
3326 /* On Irix 5, the PT_DYNAMIC segment includes the .dynamic,
3327 .dynstr, .dynsym, and .hash sections, and everything in
3329 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
; pm
= &(*pm
)->next
)
3330 if ((*pm
)->p_type
== PT_DYNAMIC
)
3335 && strcmp (m
->sections
[0]->name
, ".dynamic") == 0)
3337 static const char *sec_names
[] =
3338 { ".dynamic", ".dynstr", ".dynsym", ".hash" };
3341 struct elf_segment_map
*n
;
3345 for (i
= 0; i
< sizeof sec_names
/ sizeof sec_names
[0]; i
++)
3347 s
= bfd_get_section_by_name (abfd
, sec_names
[i
]);
3348 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3354 sz
= s
->_cooked_size
;
3357 if (high
< s
->vma
+ sz
)
3363 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3364 if ((s
->flags
& SEC_LOAD
) != 0
3367 + (s
->_cooked_size
!= 0 ? s
->_cooked_size
: s
->_raw_size
))
3371 n
= ((struct elf_segment_map
*)
3372 bfd_zalloc (abfd
, sizeof *n
+ (c
- 1) * sizeof (asection
*)));
3379 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3381 if ((s
->flags
& SEC_LOAD
) != 0
3384 + (s
->_cooked_size
!= 0 ?
3385 s
->_cooked_size
: s
->_raw_size
))
3400 /* The structure of the runtime procedure descriptor created by the
3401 loader for use by the static exception system. */
3403 typedef struct runtime_pdr
{
3404 bfd_vma adr
; /* memory address of start of procedure */
3405 long regmask
; /* save register mask */
3406 long regoffset
; /* save register offset */
3407 long fregmask
; /* save floating point register mask */
3408 long fregoffset
; /* save floating point register offset */
3409 long frameoffset
; /* frame size */
3410 short framereg
; /* frame pointer register */
3411 short pcreg
; /* offset or reg of return pc */
3412 long irpss
; /* index into the runtime string table */
3414 struct exception_info
*exception_info
;/* pointer to exception array */
3416 #define cbRPDR sizeof(RPDR)
3417 #define rpdNil ((pRPDR) 0)
3419 /* Swap RPDR (runtime procedure table entry) for output. */
3421 static void ecoff_swap_rpdr_out
3422 PARAMS ((bfd
*, const RPDR
*, struct rpdr_ext
*));
3425 ecoff_swap_rpdr_out (abfd
, in
, ex
)
3428 struct rpdr_ext
*ex
;
3430 /* ecoff_put_off was defined in ecoffswap.h. */
3431 ecoff_put_off (abfd
, in
->adr
, (bfd_byte
*) ex
->p_adr
);
3432 bfd_h_put_32 (abfd
, in
->regmask
, (bfd_byte
*) ex
->p_regmask
);
3433 bfd_h_put_32 (abfd
, in
->regoffset
, (bfd_byte
*) ex
->p_regoffset
);
3434 bfd_h_put_32 (abfd
, in
->fregmask
, (bfd_byte
*) ex
->p_fregmask
);
3435 bfd_h_put_32 (abfd
, in
->fregoffset
, (bfd_byte
*) ex
->p_fregoffset
);
3436 bfd_h_put_32 (abfd
, in
->frameoffset
, (bfd_byte
*) ex
->p_frameoffset
);
3438 bfd_h_put_16 (abfd
, in
->framereg
, (bfd_byte
*) ex
->p_framereg
);
3439 bfd_h_put_16 (abfd
, in
->pcreg
, (bfd_byte
*) ex
->p_pcreg
);
3441 bfd_h_put_32 (abfd
, in
->irpss
, (bfd_byte
*) ex
->p_irpss
);
3443 ecoff_put_off (abfd
, in
->exception_info
, (bfd_byte
*) ex
->p_exception_info
);
3447 /* Read ECOFF debugging information from a .mdebug section into a
3448 ecoff_debug_info structure. */
3451 _bfd_mips_elf_read_ecoff_info (abfd
, section
, debug
)
3454 struct ecoff_debug_info
*debug
;
3457 const struct ecoff_debug_swap
*swap
;
3458 char *ext_hdr
= NULL
;
3460 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
3461 memset (debug
, 0, sizeof(*debug
));
3463 ext_hdr
= (char *) bfd_malloc ((size_t) swap
->external_hdr_size
);
3464 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
3467 if (bfd_get_section_contents (abfd
, section
, ext_hdr
, (file_ptr
) 0,
3468 swap
->external_hdr_size
)
3472 symhdr
= &debug
->symbolic_header
;
3473 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
3475 /* The symbolic header contains absolute file offsets and sizes to
3477 #define READ(ptr, offset, count, size, type) \
3478 if (symhdr->count == 0) \
3479 debug->ptr = NULL; \
3482 debug->ptr = (type) bfd_malloc ((size_t) (size * symhdr->count)); \
3483 if (debug->ptr == NULL) \
3484 goto error_return; \
3485 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
3486 || (bfd_read (debug->ptr, size, symhdr->count, \
3487 abfd) != size * symhdr->count)) \
3488 goto error_return; \
3491 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
3492 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, PTR
);
3493 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, PTR
);
3494 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, PTR
);
3495 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, PTR
);
3496 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
3498 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
3499 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
3500 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, PTR
);
3501 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, PTR
);
3502 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, PTR
);
3506 debug
->adjust
= NULL
;
3511 if (ext_hdr
!= NULL
)
3513 if (debug
->line
!= NULL
)
3515 if (debug
->external_dnr
!= NULL
)
3516 free (debug
->external_dnr
);
3517 if (debug
->external_pdr
!= NULL
)
3518 free (debug
->external_pdr
);
3519 if (debug
->external_sym
!= NULL
)
3520 free (debug
->external_sym
);
3521 if (debug
->external_opt
!= NULL
)
3522 free (debug
->external_opt
);
3523 if (debug
->external_aux
!= NULL
)
3524 free (debug
->external_aux
);
3525 if (debug
->ss
!= NULL
)
3527 if (debug
->ssext
!= NULL
)
3528 free (debug
->ssext
);
3529 if (debug
->external_fdr
!= NULL
)
3530 free (debug
->external_fdr
);
3531 if (debug
->external_rfd
!= NULL
)
3532 free (debug
->external_rfd
);
3533 if (debug
->external_ext
!= NULL
)
3534 free (debug
->external_ext
);
3538 /* MIPS ELF local labels start with '$', not 'L'. */
3542 mips_elf_is_local_label_name (abfd
, name
)
3549 /* On Irix 6, the labels go back to starting with '.', so we accept
3550 the generic ELF local label syntax as well. */
3551 return _bfd_elf_is_local_label_name (abfd
, name
);
3554 /* MIPS ELF uses a special find_nearest_line routine in order the
3555 handle the ECOFF debugging information. */
3557 struct mips_elf_find_line
3559 struct ecoff_debug_info d
;
3560 struct ecoff_find_line i
;
3564 _bfd_mips_elf_find_nearest_line (abfd
, section
, symbols
, offset
, filename_ptr
,
3565 functionname_ptr
, line_ptr
)
3570 const char **filename_ptr
;
3571 const char **functionname_ptr
;
3572 unsigned int *line_ptr
;
3576 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
3577 filename_ptr
, functionname_ptr
,
3581 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
3582 filename_ptr
, functionname_ptr
,
3584 ABI_64_P (abfd
) ? 8 : 0))
3587 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
3591 struct mips_elf_find_line
*fi
;
3592 const struct ecoff_debug_swap
* const swap
=
3593 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
3595 /* If we are called during a link, mips_elf_final_link may have
3596 cleared the SEC_HAS_CONTENTS field. We force it back on here
3597 if appropriate (which it normally will be). */
3598 origflags
= msec
->flags
;
3599 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
3600 msec
->flags
|= SEC_HAS_CONTENTS
;
3602 fi
= elf_tdata (abfd
)->find_line_info
;
3605 bfd_size_type external_fdr_size
;
3608 struct fdr
*fdr_ptr
;
3610 fi
= ((struct mips_elf_find_line
*)
3611 bfd_zalloc (abfd
, sizeof (struct mips_elf_find_line
)));
3614 msec
->flags
= origflags
;
3618 if (! _bfd_mips_elf_read_ecoff_info (abfd
, msec
, &fi
->d
))
3620 msec
->flags
= origflags
;
3624 /* Swap in the FDR information. */
3625 fi
->d
.fdr
= ((struct fdr
*)
3627 (fi
->d
.symbolic_header
.ifdMax
*
3628 sizeof (struct fdr
))));
3629 if (fi
->d
.fdr
== NULL
)
3631 msec
->flags
= origflags
;
3634 external_fdr_size
= swap
->external_fdr_size
;
3635 fdr_ptr
= fi
->d
.fdr
;
3636 fraw_src
= (char *) fi
->d
.external_fdr
;
3637 fraw_end
= (fraw_src
3638 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
3639 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
3640 (*swap
->swap_fdr_in
) (abfd
, (PTR
) fraw_src
, fdr_ptr
);
3642 elf_tdata (abfd
)->find_line_info
= fi
;
3644 /* Note that we don't bother to ever free this information.
3645 find_nearest_line is either called all the time, as in
3646 objdump -l, so the information should be saved, or it is
3647 rarely called, as in ld error messages, so the memory
3648 wasted is unimportant. Still, it would probably be a
3649 good idea for free_cached_info to throw it away. */
3652 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
3653 &fi
->i
, filename_ptr
, functionname_ptr
,
3656 msec
->flags
= origflags
;
3660 msec
->flags
= origflags
;
3663 /* Fall back on the generic ELF find_nearest_line routine. */
3665 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
3666 filename_ptr
, functionname_ptr
,
3670 /* The mips16 compiler uses a couple of special sections to handle
3671 floating point arguments.
3673 Section names that look like .mips16.fn.FNNAME contain stubs that
3674 copy floating point arguments from the fp regs to the gp regs and
3675 then jump to FNNAME. If any 32 bit function calls FNNAME, the
3676 call should be redirected to the stub instead. If no 32 bit
3677 function calls FNNAME, the stub should be discarded. We need to
3678 consider any reference to the function, not just a call, because
3679 if the address of the function is taken we will need the stub,
3680 since the address might be passed to a 32 bit function.
3682 Section names that look like .mips16.call.FNNAME contain stubs
3683 that copy floating point arguments from the gp regs to the fp
3684 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
3685 then any 16 bit function that calls FNNAME should be redirected
3686 to the stub instead. If FNNAME is not a 32 bit function, the
3687 stub should be discarded.
3689 .mips16.call.fp.FNNAME sections are similar, but contain stubs
3690 which call FNNAME and then copy the return value from the fp regs
3691 to the gp regs. These stubs store the return value in $18 while
3692 calling FNNAME; any function which might call one of these stubs
3693 must arrange to save $18 around the call. (This case is not
3694 needed for 32 bit functions that call 16 bit functions, because
3695 16 bit functions always return floating point values in both
3698 Note that in all cases FNNAME might be defined statically.
3699 Therefore, FNNAME is not used literally. Instead, the relocation
3700 information will indicate which symbol the section is for.
3702 We record any stubs that we find in the symbol table. */
3704 #define FN_STUB ".mips16.fn."
3705 #define CALL_STUB ".mips16.call."
3706 #define CALL_FP_STUB ".mips16.call.fp."
3708 /* MIPS ELF linker hash table. */
3710 struct mips_elf_link_hash_table
3712 struct elf_link_hash_table root
;
3714 /* We no longer use this. */
3715 /* String section indices for the dynamic section symbols. */
3716 bfd_size_type dynsym_sec_strindex
[SIZEOF_MIPS_DYNSYM_SECNAMES
];
3718 /* The number of .rtproc entries. */
3719 bfd_size_type procedure_count
;
3720 /* The size of the .compact_rel section (if SGI_COMPAT). */
3721 bfd_size_type compact_rel_size
;
3722 /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic
3723 entry is set to the address of __rld_obj_head as in Irix 5. */
3724 boolean use_rld_obj_head
;
3725 /* This is the value of the __rld_map or __rld_obj_head symbol. */
3727 /* This is set if we see any mips16 stub sections. */
3728 boolean mips16_stubs_seen
;
3731 /* Look up an entry in a MIPS ELF linker hash table. */
3733 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
3734 ((struct mips_elf_link_hash_entry *) \
3735 elf_link_hash_lookup (&(table)->root, (string), (create), \
3738 /* Traverse a MIPS ELF linker hash table. */
3740 #define mips_elf_link_hash_traverse(table, func, info) \
3741 (elf_link_hash_traverse \
3743 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
3746 /* Get the MIPS ELF linker hash table from a link_info structure. */
3748 #define mips_elf_hash_table(p) \
3749 ((struct mips_elf_link_hash_table *) ((p)->hash))
3751 static boolean mips_elf_output_extsym
3752 PARAMS ((struct mips_elf_link_hash_entry
*, PTR
));
3754 /* Create an entry in a MIPS ELF linker hash table. */
3756 static struct bfd_hash_entry
*
3757 mips_elf_link_hash_newfunc (entry
, table
, string
)
3758 struct bfd_hash_entry
*entry
;
3759 struct bfd_hash_table
*table
;
3762 struct mips_elf_link_hash_entry
*ret
=
3763 (struct mips_elf_link_hash_entry
*) entry
;
3765 /* Allocate the structure if it has not already been allocated by a
3767 if (ret
== (struct mips_elf_link_hash_entry
*) NULL
)
3768 ret
= ((struct mips_elf_link_hash_entry
*)
3769 bfd_hash_allocate (table
,
3770 sizeof (struct mips_elf_link_hash_entry
)));
3771 if (ret
== (struct mips_elf_link_hash_entry
*) NULL
)
3772 return (struct bfd_hash_entry
*) ret
;
3774 /* Call the allocation method of the superclass. */
3775 ret
= ((struct mips_elf_link_hash_entry
*)
3776 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
3778 if (ret
!= (struct mips_elf_link_hash_entry
*) NULL
)
3780 /* Set local fields. */
3781 memset (&ret
->esym
, 0, sizeof (EXTR
));
3782 /* We use -2 as a marker to indicate that the information has
3783 not been set. -1 means there is no associated ifd. */
3785 ret
->possibly_dynamic_relocs
= 0;
3786 ret
->min_dyn_reloc_index
= 0;
3787 ret
->fn_stub
= NULL
;
3788 ret
->need_fn_stub
= false;
3789 ret
->call_stub
= NULL
;
3790 ret
->call_fp_stub
= NULL
;
3793 return (struct bfd_hash_entry
*) ret
;
3796 /* Create a MIPS ELF linker hash table. */
3798 struct bfd_link_hash_table
*
3799 _bfd_mips_elf_link_hash_table_create (abfd
)
3802 struct mips_elf_link_hash_table
*ret
;
3804 ret
= ((struct mips_elf_link_hash_table
*)
3805 bfd_alloc (abfd
, sizeof (struct mips_elf_link_hash_table
)));
3806 if (ret
== (struct mips_elf_link_hash_table
*) NULL
)
3809 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
3810 mips_elf_link_hash_newfunc
))
3812 bfd_release (abfd
, ret
);
3817 /* We no longer use this. */
3818 for (i
= 0; i
< SIZEOF_MIPS_DYNSYM_SECNAMES
; i
++)
3819 ret
->dynsym_sec_strindex
[i
] = (bfd_size_type
) -1;
3821 ret
->procedure_count
= 0;
3822 ret
->compact_rel_size
= 0;
3823 ret
->use_rld_obj_head
= false;
3825 ret
->mips16_stubs_seen
= false;
3827 return &ret
->root
.root
;
3830 /* Hook called by the linker routine which adds symbols from an object
3831 file. We must handle the special MIPS section numbers here. */
3835 _bfd_mips_elf_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
, secp
, valp
)
3837 struct bfd_link_info
*info
;
3838 const Elf_Internal_Sym
*sym
;
3840 flagword
*flagsp ATTRIBUTE_UNUSED
;
3844 if (SGI_COMPAT (abfd
)
3845 && (abfd
->flags
& DYNAMIC
) != 0
3846 && strcmp (*namep
, "_rld_new_interface") == 0)
3848 /* Skip Irix 5 rld entry name. */
3853 switch (sym
->st_shndx
)
3856 /* Common symbols less than the GP size are automatically
3857 treated as SHN_MIPS_SCOMMON symbols. */
3858 if (sym
->st_size
> elf_gp_size (abfd
)
3859 || IRIX_COMPAT (abfd
) == ict_irix6
)
3862 case SHN_MIPS_SCOMMON
:
3863 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
3864 (*secp
)->flags
|= SEC_IS_COMMON
;
3865 *valp
= sym
->st_size
;
3869 /* This section is used in a shared object. */
3870 if (mips_elf_text_section_ptr
== NULL
)
3872 /* Initialize the section. */
3873 mips_elf_text_section
.name
= ".text";
3874 mips_elf_text_section
.flags
= SEC_NO_FLAGS
;
3875 mips_elf_text_section
.output_section
= NULL
;
3876 mips_elf_text_section
.symbol
= &mips_elf_text_symbol
;
3877 mips_elf_text_section
.symbol_ptr_ptr
= &mips_elf_text_symbol_ptr
;
3878 mips_elf_text_symbol
.name
= ".text";
3879 mips_elf_text_symbol
.flags
= BSF_SECTION_SYM
;
3880 mips_elf_text_symbol
.section
= &mips_elf_text_section
;
3881 mips_elf_text_symbol_ptr
= &mips_elf_text_symbol
;
3882 mips_elf_text_section_ptr
= &mips_elf_text_section
;
3884 /* This code used to do *secp = bfd_und_section_ptr if
3885 info->shared. I don't know why, and that doesn't make sense,
3886 so I took it out. */
3887 *secp
= mips_elf_text_section_ptr
;
3890 case SHN_MIPS_ACOMMON
:
3891 /* Fall through. XXX Can we treat this as allocated data? */
3893 /* This section is used in a shared object. */
3894 if (mips_elf_data_section_ptr
== NULL
)
3896 /* Initialize the section. */
3897 mips_elf_data_section
.name
= ".data";
3898 mips_elf_data_section
.flags
= SEC_NO_FLAGS
;
3899 mips_elf_data_section
.output_section
= NULL
;
3900 mips_elf_data_section
.symbol
= &mips_elf_data_symbol
;
3901 mips_elf_data_section
.symbol_ptr_ptr
= &mips_elf_data_symbol_ptr
;
3902 mips_elf_data_symbol
.name
= ".data";
3903 mips_elf_data_symbol
.flags
= BSF_SECTION_SYM
;
3904 mips_elf_data_symbol
.section
= &mips_elf_data_section
;
3905 mips_elf_data_symbol_ptr
= &mips_elf_data_symbol
;
3906 mips_elf_data_section_ptr
= &mips_elf_data_section
;
3908 /* This code used to do *secp = bfd_und_section_ptr if
3909 info->shared. I don't know why, and that doesn't make sense,
3910 so I took it out. */
3911 *secp
= mips_elf_data_section_ptr
;
3914 case SHN_MIPS_SUNDEFINED
:
3915 *secp
= bfd_und_section_ptr
;
3919 if (SGI_COMPAT (abfd
)
3921 && info
->hash
->creator
== abfd
->xvec
3922 && strcmp (*namep
, "__rld_obj_head") == 0)
3924 struct elf_link_hash_entry
*h
;
3926 /* Mark __rld_obj_head as dynamic. */
3928 if (! (_bfd_generic_link_add_one_symbol
3929 (info
, abfd
, *namep
, BSF_GLOBAL
, *secp
,
3930 (bfd_vma
) *valp
, (const char *) NULL
, false,
3931 get_elf_backend_data (abfd
)->collect
,
3932 (struct bfd_link_hash_entry
**) &h
)))
3934 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
3935 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
3936 h
->type
= STT_OBJECT
;
3938 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
3941 mips_elf_hash_table (info
)->use_rld_obj_head
= true;
3944 /* If this is a mips16 text symbol, add 1 to the value to make it
3945 odd. This will cause something like .word SYM to come up with
3946 the right value when it is loaded into the PC. */
3947 if (sym
->st_other
== STO_MIPS16
)
3953 /* Structure used to pass information to mips_elf_output_extsym. */
3958 struct bfd_link_info
*info
;
3959 struct ecoff_debug_info
*debug
;
3960 const struct ecoff_debug_swap
*swap
;
3964 /* This routine is used to write out ECOFF debugging external symbol
3965 information. It is called via mips_elf_link_hash_traverse. The
3966 ECOFF external symbol information must match the ELF external
3967 symbol information. Unfortunately, at this point we don't know
3968 whether a symbol is required by reloc information, so the two
3969 tables may wind up being different. We must sort out the external
3970 symbol information before we can set the final size of the .mdebug
3971 section, and we must set the size of the .mdebug section before we
3972 can relocate any sections, and we can't know which symbols are
3973 required by relocation until we relocate the sections.
3974 Fortunately, it is relatively unlikely that any symbol will be
3975 stripped but required by a reloc. In particular, it can not happen
3976 when generating a final executable. */
3979 mips_elf_output_extsym (h
, data
)
3980 struct mips_elf_link_hash_entry
*h
;
3983 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
3985 asection
*sec
, *output_section
;
3987 if (h
->root
.indx
== -2)
3989 else if (((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
3990 || (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
3991 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
3992 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
3994 else if (einfo
->info
->strip
== strip_all
3995 || (einfo
->info
->strip
== strip_some
3996 && bfd_hash_lookup (einfo
->info
->keep_hash
,
3997 h
->root
.root
.root
.string
,
3998 false, false) == NULL
))
4006 if (h
->esym
.ifd
== -2)
4009 h
->esym
.cobol_main
= 0;
4010 h
->esym
.weakext
= 0;
4011 h
->esym
.reserved
= 0;
4012 h
->esym
.ifd
= ifdNil
;
4013 h
->esym
.asym
.value
= 0;
4014 h
->esym
.asym
.st
= stGlobal
;
4016 if (SGI_COMPAT (einfo
->abfd
)
4017 && (h
->root
.root
.type
== bfd_link_hash_undefined
4018 || h
->root
.root
.type
== bfd_link_hash_undefweak
))
4022 /* Use undefined class. Also, set class and type for some
4024 name
= h
->root
.root
.root
.string
;
4025 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
4026 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
4028 h
->esym
.asym
.sc
= scData
;
4029 h
->esym
.asym
.st
= stLabel
;
4030 h
->esym
.asym
.value
= 0;
4032 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
4034 h
->esym
.asym
.sc
= scAbs
;
4035 h
->esym
.asym
.st
= stLabel
;
4036 h
->esym
.asym
.value
=
4037 mips_elf_hash_table (einfo
->info
)->procedure_count
;
4039 else if (strcmp (name
, "_gp_disp") == 0)
4041 h
->esym
.asym
.sc
= scAbs
;
4042 h
->esym
.asym
.st
= stLabel
;
4043 h
->esym
.asym
.value
= elf_gp (einfo
->abfd
);
4046 h
->esym
.asym
.sc
= scUndefined
;
4048 else if (h
->root
.root
.type
!= bfd_link_hash_defined
4049 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
4050 h
->esym
.asym
.sc
= scAbs
;
4055 sec
= h
->root
.root
.u
.def
.section
;
4056 output_section
= sec
->output_section
;
4058 /* When making a shared library and symbol h is the one from
4059 the another shared library, OUTPUT_SECTION may be null. */
4060 if (output_section
== NULL
)
4061 h
->esym
.asym
.sc
= scUndefined
;
4064 name
= bfd_section_name (output_section
->owner
, output_section
);
4066 if (strcmp (name
, ".text") == 0)
4067 h
->esym
.asym
.sc
= scText
;
4068 else if (strcmp (name
, ".data") == 0)
4069 h
->esym
.asym
.sc
= scData
;
4070 else if (strcmp (name
, ".sdata") == 0)
4071 h
->esym
.asym
.sc
= scSData
;
4072 else if (strcmp (name
, ".rodata") == 0
4073 || strcmp (name
, ".rdata") == 0)
4074 h
->esym
.asym
.sc
= scRData
;
4075 else if (strcmp (name
, ".bss") == 0)
4076 h
->esym
.asym
.sc
= scBss
;
4077 else if (strcmp (name
, ".sbss") == 0)
4078 h
->esym
.asym
.sc
= scSBss
;
4079 else if (strcmp (name
, ".init") == 0)
4080 h
->esym
.asym
.sc
= scInit
;
4081 else if (strcmp (name
, ".fini") == 0)
4082 h
->esym
.asym
.sc
= scFini
;
4084 h
->esym
.asym
.sc
= scAbs
;
4088 h
->esym
.asym
.reserved
= 0;
4089 h
->esym
.asym
.index
= indexNil
;
4092 if (h
->root
.root
.type
== bfd_link_hash_common
)
4093 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
4094 else if (h
->root
.root
.type
== bfd_link_hash_defined
4095 || h
->root
.root
.type
== bfd_link_hash_defweak
)
4097 if (h
->esym
.asym
.sc
== scCommon
)
4098 h
->esym
.asym
.sc
= scBss
;
4099 else if (h
->esym
.asym
.sc
== scSCommon
)
4100 h
->esym
.asym
.sc
= scSBss
;
4102 sec
= h
->root
.root
.u
.def
.section
;
4103 output_section
= sec
->output_section
;
4104 if (output_section
!= NULL
)
4105 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
4106 + sec
->output_offset
4107 + output_section
->vma
);
4109 h
->esym
.asym
.value
= 0;
4111 else if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
4113 /* Set type and value for a symbol with a function stub. */
4114 h
->esym
.asym
.st
= stProc
;
4115 sec
= h
->root
.root
.u
.def
.section
;
4117 h
->esym
.asym
.value
= 0;
4120 output_section
= sec
->output_section
;
4121 if (output_section
!= NULL
)
4122 h
->esym
.asym
.value
= (h
->root
.plt
.offset
4123 + sec
->output_offset
4124 + output_section
->vma
);
4126 h
->esym
.asym
.value
= 0;
4133 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
4134 h
->root
.root
.root
.string
,
4137 einfo
->failed
= true;
4144 /* Create a runtime procedure table from the .mdebug section. */
4147 mips_elf_create_procedure_table (handle
, abfd
, info
, s
, debug
)
4150 struct bfd_link_info
*info
;
4152 struct ecoff_debug_info
*debug
;
4154 const struct ecoff_debug_swap
*swap
;
4155 HDRR
*hdr
= &debug
->symbolic_header
;
4157 struct rpdr_ext
*erp
;
4159 struct pdr_ext
*epdr
;
4160 struct sym_ext
*esym
;
4163 unsigned long size
, count
;
4164 unsigned long sindex
;
4168 const char *no_name_func
= _("static procedure (no name)");
4176 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
4178 sindex
= strlen (no_name_func
) + 1;
4179 count
= hdr
->ipdMax
;
4182 size
= swap
->external_pdr_size
;
4184 epdr
= (struct pdr_ext
*) bfd_malloc (size
* count
);
4188 if (! _bfd_ecoff_get_accumulated_pdr (handle
, (PTR
) epdr
))
4191 size
= sizeof (RPDR
);
4192 rp
= rpdr
= (RPDR
*) bfd_malloc (size
* count
);
4196 sv
= (char **) bfd_malloc (sizeof (char *) * count
);
4200 count
= hdr
->isymMax
;
4201 size
= swap
->external_sym_size
;
4202 esym
= (struct sym_ext
*) bfd_malloc (size
* count
);
4206 if (! _bfd_ecoff_get_accumulated_sym (handle
, (PTR
) esym
))
4209 count
= hdr
->issMax
;
4210 ss
= (char *) bfd_malloc (count
);
4213 if (! _bfd_ecoff_get_accumulated_ss (handle
, (PTR
) ss
))
4216 count
= hdr
->ipdMax
;
4217 for (i
= 0; i
< count
; i
++, rp
++)
4219 (*swap
->swap_pdr_in
) (abfd
, (PTR
) (epdr
+ i
), &pdr
);
4220 (*swap
->swap_sym_in
) (abfd
, (PTR
) &esym
[pdr
.isym
], &sym
);
4221 rp
->adr
= sym
.value
;
4222 rp
->regmask
= pdr
.regmask
;
4223 rp
->regoffset
= pdr
.regoffset
;
4224 rp
->fregmask
= pdr
.fregmask
;
4225 rp
->fregoffset
= pdr
.fregoffset
;
4226 rp
->frameoffset
= pdr
.frameoffset
;
4227 rp
->framereg
= pdr
.framereg
;
4228 rp
->pcreg
= pdr
.pcreg
;
4230 sv
[i
] = ss
+ sym
.iss
;
4231 sindex
+= strlen (sv
[i
]) + 1;
4235 size
= sizeof (struct rpdr_ext
) * (count
+ 2) + sindex
;
4236 size
= BFD_ALIGN (size
, 16);
4237 rtproc
= (PTR
) bfd_alloc (abfd
, size
);
4240 mips_elf_hash_table (info
)->procedure_count
= 0;
4244 mips_elf_hash_table (info
)->procedure_count
= count
+ 2;
4246 erp
= (struct rpdr_ext
*) rtproc
;
4247 memset (erp
, 0, sizeof (struct rpdr_ext
));
4249 str
= (char *) rtproc
+ sizeof (struct rpdr_ext
) * (count
+ 2);
4250 strcpy (str
, no_name_func
);
4251 str
+= strlen (no_name_func
) + 1;
4252 for (i
= 0; i
< count
; i
++)
4254 ecoff_swap_rpdr_out (abfd
, rpdr
+ i
, erp
+ i
);
4255 strcpy (str
, sv
[i
]);
4256 str
+= strlen (sv
[i
]) + 1;
4258 ecoff_put_off (abfd
, (bfd_vma
) -1, (bfd_byte
*) (erp
+ count
)->p_adr
);
4260 /* Set the size and contents of .rtproc section. */
4261 s
->_raw_size
= size
;
4262 s
->contents
= (bfd_byte
*) rtproc
;
4264 /* Skip this section later on (I don't think this currently
4265 matters, but someday it might). */
4266 s
->link_order_head
= (struct bfd_link_order
*) NULL
;
4295 /* A comparison routine used to sort .gptab entries. */
4298 gptab_compare (p1
, p2
)
4302 const Elf32_gptab
*a1
= (const Elf32_gptab
*) p1
;
4303 const Elf32_gptab
*a2
= (const Elf32_gptab
*) p2
;
4305 return a1
->gt_entry
.gt_g_value
- a2
->gt_entry
.gt_g_value
;
4308 /* We need to use a special link routine to handle the .reginfo and
4309 the .mdebug sections. We need to merge all instances of these
4310 sections together, not write them all out sequentially. */
4313 _bfd_mips_elf_final_link (abfd
, info
)
4315 struct bfd_link_info
*info
;
4319 struct bfd_link_order
*p
;
4320 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
4321 asection
*rtproc_sec
;
4322 Elf32_RegInfo reginfo
;
4323 struct ecoff_debug_info debug
;
4324 const struct ecoff_debug_swap
*swap
4325 = get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
4326 HDRR
*symhdr
= &debug
.symbolic_header
;
4327 PTR mdebug_handle
= NULL
;
4329 /* If all the things we linked together were PIC, but we're
4330 producing an executable (rather than a shared object), then the
4331 resulting file is CPIC (i.e., it calls PIC code.) */
4333 && !info
->relocateable
4334 && elf_elfheader (abfd
)->e_flags
& EF_MIPS_PIC
)
4336 elf_elfheader (abfd
)->e_flags
&= ~EF_MIPS_PIC
;
4337 elf_elfheader (abfd
)->e_flags
|= EF_MIPS_CPIC
;
4340 /* We'd carefully arranged the dynamic symbol indices, and then the
4341 generic size_dynamic_sections renumbered them out from under us.
4342 Rather than trying somehow to prevent the renumbering, just do
4344 if (elf_hash_table (info
)->dynamic_sections_created
)
4348 struct mips_got_info
*g
;
4350 /* When we resort, we must tell mips_elf_sort_hash_table what
4351 the lowest index it may use is. That's the number of section
4352 symbols we're going to add. The generic ELF linker only
4353 adds these symbols when building a shared object. Note that
4354 we count the sections after (possibly) removing the .options
4356 if (!mips_elf_sort_hash_table (info
, (info
->shared
4357 ? bfd_count_sections (abfd
) + 1
4361 /* Make sure we didn't grow the global .got region. */
4362 dynobj
= elf_hash_table (info
)->dynobj
;
4363 got
= bfd_get_section_by_name (dynobj
, ".got");
4364 g
= (struct mips_got_info
*) elf_section_data (got
)->tdata
;
4366 BFD_ASSERT ((elf_hash_table (info
)->dynsymcount
4367 - g
->global_gotsym
->dynindx
)
4368 <= g
->global_gotno
);
4371 /* On IRIX5, we omit the .options section. On IRIX6, however, we
4372 include it, even though we don't process it quite right. (Some
4373 entries are supposed to be merged.) Empirically, we seem to be
4374 better off including it then not. */
4375 if (IRIX_COMPAT (abfd
) == ict_irix5
)
4376 for (secpp
= &abfd
->sections
; *secpp
!= NULL
; secpp
= &(*secpp
)->next
)
4378 if (strcmp ((*secpp
)->name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
4380 for (p
= (*secpp
)->link_order_head
; p
!= NULL
; p
= p
->next
)
4381 if (p
->type
== bfd_indirect_link_order
)
4382 p
->u
.indirect
.section
->flags
&=~ SEC_HAS_CONTENTS
;
4383 (*secpp
)->link_order_head
= NULL
;
4384 *secpp
= (*secpp
)->next
;
4385 --abfd
->section_count
;
4391 /* Get a value for the GP register. */
4392 if (elf_gp (abfd
) == 0)
4394 struct bfd_link_hash_entry
*h
;
4396 h
= bfd_link_hash_lookup (info
->hash
, "_gp", false, false, true);
4397 if (h
!= (struct bfd_link_hash_entry
*) NULL
4398 && h
->type
== bfd_link_hash_defined
)
4399 elf_gp (abfd
) = (h
->u
.def
.value
4400 + h
->u
.def
.section
->output_section
->vma
4401 + h
->u
.def
.section
->output_offset
);
4402 else if (info
->relocateable
)
4406 /* Find the GP-relative section with the lowest offset. */
4408 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
4410 && (elf_section_data (o
)->this_hdr
.sh_flags
& SHF_MIPS_GPREL
))
4413 /* And calculate GP relative to that. */
4414 elf_gp (abfd
) = lo
+ ELF_MIPS_GP_OFFSET (abfd
);
4418 /* If the relocate_section function needs to do a reloc
4419 involving the GP value, it should make a reloc_dangerous
4420 callback to warn that GP is not defined. */
4424 /* Go through the sections and collect the .reginfo and .mdebug
4428 gptab_data_sec
= NULL
;
4429 gptab_bss_sec
= NULL
;
4430 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
4432 if (strcmp (o
->name
, ".reginfo") == 0)
4434 memset (®info
, 0, sizeof reginfo
);
4436 /* We have found the .reginfo section in the output file.
4437 Look through all the link_orders comprising it and merge
4438 the information together. */
4439 for (p
= o
->link_order_head
;
4440 p
!= (struct bfd_link_order
*) NULL
;
4443 asection
*input_section
;
4445 Elf32_External_RegInfo ext
;
4448 if (p
->type
!= bfd_indirect_link_order
)
4450 if (p
->type
== bfd_fill_link_order
)
4455 input_section
= p
->u
.indirect
.section
;
4456 input_bfd
= input_section
->owner
;
4458 /* The linker emulation code has probably clobbered the
4459 size to be zero bytes. */
4460 if (input_section
->_raw_size
== 0)
4461 input_section
->_raw_size
= sizeof (Elf32_External_RegInfo
);
4463 if (! bfd_get_section_contents (input_bfd
, input_section
,
4469 bfd_mips_elf32_swap_reginfo_in (input_bfd
, &ext
, &sub
);
4471 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
4472 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
4473 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
4474 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
4475 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
4477 /* ri_gp_value is set by the function
4478 mips_elf32_section_processing when the section is
4479 finally written out. */
4481 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4482 elf_link_input_bfd ignores this section. */
4483 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
4486 /* Size has been set in mips_elf_always_size_sections */
4487 BFD_ASSERT(o
->_raw_size
== sizeof (Elf32_External_RegInfo
));
4489 /* Skip this section later on (I don't think this currently
4490 matters, but someday it might). */
4491 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
4496 if (strcmp (o
->name
, ".mdebug") == 0)
4498 struct extsym_info einfo
;
4500 /* We have found the .mdebug section in the output file.
4501 Look through all the link_orders comprising it and merge
4502 the information together. */
4503 symhdr
->magic
= swap
->sym_magic
;
4504 /* FIXME: What should the version stamp be? */
4506 symhdr
->ilineMax
= 0;
4510 symhdr
->isymMax
= 0;
4511 symhdr
->ioptMax
= 0;
4512 symhdr
->iauxMax
= 0;
4514 symhdr
->issExtMax
= 0;
4517 symhdr
->iextMax
= 0;
4519 /* We accumulate the debugging information itself in the
4520 debug_info structure. */
4522 debug
.external_dnr
= NULL
;
4523 debug
.external_pdr
= NULL
;
4524 debug
.external_sym
= NULL
;
4525 debug
.external_opt
= NULL
;
4526 debug
.external_aux
= NULL
;
4528 debug
.ssext
= debug
.ssext_end
= NULL
;
4529 debug
.external_fdr
= NULL
;
4530 debug
.external_rfd
= NULL
;
4531 debug
.external_ext
= debug
.external_ext_end
= NULL
;
4533 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
4534 if (mdebug_handle
== (PTR
) NULL
)
4537 if (SGI_COMPAT (abfd
))
4543 static const char * const name
[] =
4544 { ".text", ".init", ".fini", ".data",
4545 ".rodata", ".sdata", ".sbss", ".bss" };
4546 static const int sc
[] = { scText
, scInit
, scFini
, scData
,
4547 scRData
, scSData
, scSBss
, scBss
};
4550 esym
.cobol_main
= 0;
4554 esym
.asym
.iss
= issNil
;
4555 esym
.asym
.st
= stLocal
;
4556 esym
.asym
.reserved
= 0;
4557 esym
.asym
.index
= indexNil
;
4559 for (i
= 0; i
< 8; i
++)
4561 esym
.asym
.sc
= sc
[i
];
4562 s
= bfd_get_section_by_name (abfd
, name
[i
]);
4565 esym
.asym
.value
= s
->vma
;
4566 last
= s
->vma
+ s
->_raw_size
;
4569 esym
.asym
.value
= last
;
4571 if (! bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
4577 for (p
= o
->link_order_head
;
4578 p
!= (struct bfd_link_order
*) NULL
;
4581 asection
*input_section
;
4583 const struct ecoff_debug_swap
*input_swap
;
4584 struct ecoff_debug_info input_debug
;
4588 if (p
->type
!= bfd_indirect_link_order
)
4590 if (p
->type
== bfd_fill_link_order
)
4595 input_section
= p
->u
.indirect
.section
;
4596 input_bfd
= input_section
->owner
;
4598 if (bfd_get_flavour (input_bfd
) != bfd_target_elf_flavour
4599 || (get_elf_backend_data (input_bfd
)
4600 ->elf_backend_ecoff_debug_swap
) == NULL
)
4602 /* I don't know what a non MIPS ELF bfd would be
4603 doing with a .mdebug section, but I don't really
4604 want to deal with it. */
4608 input_swap
= (get_elf_backend_data (input_bfd
)
4609 ->elf_backend_ecoff_debug_swap
);
4611 BFD_ASSERT (p
->size
== input_section
->_raw_size
);
4613 /* The ECOFF linking code expects that we have already
4614 read in the debugging information and set up an
4615 ecoff_debug_info structure, so we do that now. */
4616 if (! _bfd_mips_elf_read_ecoff_info (input_bfd
, input_section
,
4620 if (! (bfd_ecoff_debug_accumulate
4621 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
4622 &input_debug
, input_swap
, info
)))
4625 /* Loop through the external symbols. For each one with
4626 interesting information, try to find the symbol in
4627 the linker global hash table and save the information
4628 for the output external symbols. */
4629 eraw_src
= input_debug
.external_ext
;
4630 eraw_end
= (eraw_src
4631 + (input_debug
.symbolic_header
.iextMax
4632 * input_swap
->external_ext_size
));
4634 eraw_src
< eraw_end
;
4635 eraw_src
+= input_swap
->external_ext_size
)
4639 struct mips_elf_link_hash_entry
*h
;
4641 (*input_swap
->swap_ext_in
) (input_bfd
, (PTR
) eraw_src
, &ext
);
4642 if (ext
.asym
.sc
== scNil
4643 || ext
.asym
.sc
== scUndefined
4644 || ext
.asym
.sc
== scSUndefined
)
4647 name
= input_debug
.ssext
+ ext
.asym
.iss
;
4648 h
= mips_elf_link_hash_lookup (mips_elf_hash_table (info
),
4649 name
, false, false, true);
4650 if (h
== NULL
|| h
->esym
.ifd
!= -2)
4656 < input_debug
.symbolic_header
.ifdMax
);
4657 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
4663 /* Free up the information we just read. */
4664 free (input_debug
.line
);
4665 free (input_debug
.external_dnr
);
4666 free (input_debug
.external_pdr
);
4667 free (input_debug
.external_sym
);
4668 free (input_debug
.external_opt
);
4669 free (input_debug
.external_aux
);
4670 free (input_debug
.ss
);
4671 free (input_debug
.ssext
);
4672 free (input_debug
.external_fdr
);
4673 free (input_debug
.external_rfd
);
4674 free (input_debug
.external_ext
);
4676 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4677 elf_link_input_bfd ignores this section. */
4678 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
4681 if (SGI_COMPAT (abfd
) && info
->shared
)
4683 /* Create .rtproc section. */
4684 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
4685 if (rtproc_sec
== NULL
)
4687 flagword flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
4688 | SEC_LINKER_CREATED
| SEC_READONLY
);
4690 rtproc_sec
= bfd_make_section (abfd
, ".rtproc");
4691 if (rtproc_sec
== NULL
4692 || ! bfd_set_section_flags (abfd
, rtproc_sec
, flags
)
4693 || ! bfd_set_section_alignment (abfd
, rtproc_sec
, 4))
4697 if (! mips_elf_create_procedure_table (mdebug_handle
, abfd
,
4698 info
, rtproc_sec
, &debug
))
4702 /* Build the external symbol information. */
4705 einfo
.debug
= &debug
;
4707 einfo
.failed
= false;
4708 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
4709 mips_elf_output_extsym
,
4714 /* Set the size of the .mdebug section. */
4715 o
->_raw_size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
4717 /* Skip this section later on (I don't think this currently
4718 matters, but someday it might). */
4719 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
4724 if (strncmp (o
->name
, ".gptab.", sizeof ".gptab." - 1) == 0)
4726 const char *subname
;
4729 Elf32_External_gptab
*ext_tab
;
4732 /* The .gptab.sdata and .gptab.sbss sections hold
4733 information describing how the small data area would
4734 change depending upon the -G switch. These sections
4735 not used in executables files. */
4736 if (! info
->relocateable
)
4740 for (p
= o
->link_order_head
;
4741 p
!= (struct bfd_link_order
*) NULL
;
4744 asection
*input_section
;
4746 if (p
->type
!= bfd_indirect_link_order
)
4748 if (p
->type
== bfd_fill_link_order
)
4753 input_section
= p
->u
.indirect
.section
;
4755 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4756 elf_link_input_bfd ignores this section. */
4757 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
4760 /* Skip this section later on (I don't think this
4761 currently matters, but someday it might). */
4762 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
4764 /* Really remove the section. */
4765 for (secpp
= &abfd
->sections
;
4767 secpp
= &(*secpp
)->next
)
4769 *secpp
= (*secpp
)->next
;
4770 --abfd
->section_count
;
4775 /* There is one gptab for initialized data, and one for
4776 uninitialized data. */
4777 if (strcmp (o
->name
, ".gptab.sdata") == 0)
4779 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
4783 (*_bfd_error_handler
)
4784 (_("%s: illegal section name `%s'"),
4785 bfd_get_filename (abfd
), o
->name
);
4786 bfd_set_error (bfd_error_nonrepresentable_section
);
4790 /* The linker script always combines .gptab.data and
4791 .gptab.sdata into .gptab.sdata, and likewise for
4792 .gptab.bss and .gptab.sbss. It is possible that there is
4793 no .sdata or .sbss section in the output file, in which
4794 case we must change the name of the output section. */
4795 subname
= o
->name
+ sizeof ".gptab" - 1;
4796 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
4798 if (o
== gptab_data_sec
)
4799 o
->name
= ".gptab.data";
4801 o
->name
= ".gptab.bss";
4802 subname
= o
->name
+ sizeof ".gptab" - 1;
4803 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
4806 /* Set up the first entry. */
4808 tab
= (Elf32_gptab
*) bfd_malloc (c
* sizeof (Elf32_gptab
));
4811 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
4812 tab
[0].gt_header
.gt_unused
= 0;
4814 /* Combine the input sections. */
4815 for (p
= o
->link_order_head
;
4816 p
!= (struct bfd_link_order
*) NULL
;
4819 asection
*input_section
;
4823 bfd_size_type gpentry
;
4825 if (p
->type
!= bfd_indirect_link_order
)
4827 if (p
->type
== bfd_fill_link_order
)
4832 input_section
= p
->u
.indirect
.section
;
4833 input_bfd
= input_section
->owner
;
4835 /* Combine the gptab entries for this input section one
4836 by one. We know that the input gptab entries are
4837 sorted by ascending -G value. */
4838 size
= bfd_section_size (input_bfd
, input_section
);
4840 for (gpentry
= sizeof (Elf32_External_gptab
);
4842 gpentry
+= sizeof (Elf32_External_gptab
))
4844 Elf32_External_gptab ext_gptab
;
4845 Elf32_gptab int_gptab
;
4851 if (! (bfd_get_section_contents
4852 (input_bfd
, input_section
, (PTR
) &ext_gptab
,
4853 gpentry
, sizeof (Elf32_External_gptab
))))
4859 bfd_mips_elf32_swap_gptab_in (input_bfd
, &ext_gptab
,
4861 val
= int_gptab
.gt_entry
.gt_g_value
;
4862 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
4865 for (look
= 1; look
< c
; look
++)
4867 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
4868 tab
[look
].gt_entry
.gt_bytes
+= add
;
4870 if (tab
[look
].gt_entry
.gt_g_value
== val
)
4876 Elf32_gptab
*new_tab
;
4879 /* We need a new table entry. */
4880 new_tab
= ((Elf32_gptab
*)
4881 bfd_realloc ((PTR
) tab
,
4882 (c
+ 1) * sizeof (Elf32_gptab
)));
4883 if (new_tab
== NULL
)
4889 tab
[c
].gt_entry
.gt_g_value
= val
;
4890 tab
[c
].gt_entry
.gt_bytes
= add
;
4892 /* Merge in the size for the next smallest -G
4893 value, since that will be implied by this new
4896 for (look
= 1; look
< c
; look
++)
4898 if (tab
[look
].gt_entry
.gt_g_value
< val
4900 || (tab
[look
].gt_entry
.gt_g_value
4901 > tab
[max
].gt_entry
.gt_g_value
)))
4905 tab
[c
].gt_entry
.gt_bytes
+=
4906 tab
[max
].gt_entry
.gt_bytes
;
4911 last
= int_gptab
.gt_entry
.gt_bytes
;
4914 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4915 elf_link_input_bfd ignores this section. */
4916 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
4919 /* The table must be sorted by -G value. */
4921 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
4923 /* Swap out the table. */
4924 ext_tab
= ((Elf32_External_gptab
*)
4925 bfd_alloc (abfd
, c
* sizeof (Elf32_External_gptab
)));
4926 if (ext_tab
== NULL
)
4932 for (i
= 0; i
< c
; i
++)
4933 bfd_mips_elf32_swap_gptab_out (abfd
, tab
+ i
, ext_tab
+ i
);
4936 o
->_raw_size
= c
* sizeof (Elf32_External_gptab
);
4937 o
->contents
= (bfd_byte
*) ext_tab
;
4939 /* Skip this section later on (I don't think this currently
4940 matters, but someday it might). */
4941 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
4945 /* Invoke the regular ELF backend linker to do all the work. */
4946 if (ABI_64_P (abfd
))
4949 if (!bfd_elf64_bfd_final_link (abfd
, info
))
4956 else if (!bfd_elf32_bfd_final_link (abfd
, info
))
4959 /* Now write out the computed sections. */
4961 if (reginfo_sec
!= (asection
*) NULL
)
4963 Elf32_External_RegInfo ext
;
4965 bfd_mips_elf32_swap_reginfo_out (abfd
, ®info
, &ext
);
4966 if (! bfd_set_section_contents (abfd
, reginfo_sec
, (PTR
) &ext
,
4967 (file_ptr
) 0, sizeof ext
))
4971 if (mdebug_sec
!= (asection
*) NULL
)
4973 BFD_ASSERT (abfd
->output_has_begun
);
4974 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
4976 mdebug_sec
->filepos
))
4979 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
4982 if (gptab_data_sec
!= (asection
*) NULL
)
4984 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
4985 gptab_data_sec
->contents
,
4987 gptab_data_sec
->_raw_size
))
4991 if (gptab_bss_sec
!= (asection
*) NULL
)
4993 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
4994 gptab_bss_sec
->contents
,
4996 gptab_bss_sec
->_raw_size
))
5000 if (SGI_COMPAT (abfd
))
5002 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
5003 if (rtproc_sec
!= NULL
)
5005 if (! bfd_set_section_contents (abfd
, rtproc_sec
,
5006 rtproc_sec
->contents
,
5008 rtproc_sec
->_raw_size
))
5016 /* Handle a MIPS ELF HI16 reloc. */
5019 mips_elf_relocate_hi16 (input_bfd
, relhi
, rello
, contents
, addend
)
5021 Elf_Internal_Rela
*relhi
;
5022 Elf_Internal_Rela
*rello
;
5029 insn
= bfd_get_32 (input_bfd
, contents
+ relhi
->r_offset
);
5031 addlo
= bfd_get_32 (input_bfd
, contents
+ rello
->r_offset
);
5034 addend
+= ((insn
& 0xffff) << 16) + addlo
;
5036 if ((addlo
& 0x8000) != 0)
5038 if ((addend
& 0x8000) != 0)
5041 bfd_put_32 (input_bfd
,
5042 (insn
& 0xffff0000) | ((addend
>> 16) & 0xffff),
5043 contents
+ relhi
->r_offset
);
5046 /* Handle a MIPS ELF local GOT16 reloc. */
5049 mips_elf_relocate_got_local (output_bfd
, input_bfd
, sgot
, relhi
, rello
,
5054 Elf_Internal_Rela
*relhi
;
5055 Elf_Internal_Rela
*rello
;
5059 unsigned int assigned_gotno
;
5065 bfd_byte
*got_contents
;
5066 struct mips_got_info
*g
;
5068 insn
= bfd_get_32 (input_bfd
, contents
+ relhi
->r_offset
);
5070 addlo
= bfd_get_32 (input_bfd
, contents
+ rello
->r_offset
);
5073 addend
+= ((insn
& 0xffff) << 16) + addlo
;
5075 if ((addlo
& 0x8000) != 0)
5077 if ((addend
& 0x8000) != 0)
5080 /* Get a got entry representing requested hipage. */
5081 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
5082 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
5083 BFD_ASSERT (g
!= NULL
);
5085 assigned_gotno
= g
->assigned_gotno
;
5086 got_contents
= sgot
->contents
;
5087 hipage
= addend
& 0xffff0000;
5089 for (i
= MIPS_RESERVED_GOTNO
; i
< assigned_gotno
; i
++)
5091 address
= bfd_get_32 (input_bfd
, got_contents
+ i
* 4);
5092 if (hipage
== (address
& 0xffff0000))
5096 if (i
== assigned_gotno
)
5098 if (assigned_gotno
>= g
->local_gotno
)
5100 (*_bfd_error_handler
)
5101 (_("more got entries are needed for hipage relocations"));
5102 bfd_set_error (bfd_error_bad_value
);
5106 bfd_put_32 (input_bfd
, hipage
, got_contents
+ assigned_gotno
* 4);
5107 ++g
->assigned_gotno
;
5110 i
= - ELF_MIPS_GP_OFFSET (output_bfd
) + i
* 4;
5111 bfd_put_32 (input_bfd
, (insn
& 0xffff0000) | (i
& 0xffff),
5112 contents
+ relhi
->r_offset
);
5117 /* Handle MIPS ELF CALL16 reloc and global GOT16 reloc. */
5120 mips_elf_relocate_global_got (input_bfd
, rel
, contents
, offset
)
5122 Elf_Internal_Rela
*rel
;
5128 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
5129 bfd_put_32 (input_bfd
,
5130 (insn
& 0xffff0000) | (offset
& 0xffff),
5131 contents
+ rel
->r_offset
);
5134 /* Returns the GOT section for ABFD. */
5137 mips_elf_got_section (abfd
)
5140 return bfd_get_section_by_name (abfd
, ".got");
5143 /* Returns the GOT information associated with the link indicated by
5144 INFO. If SGOTP is non-NULL, it is filled in with the GOT
5147 static struct mips_got_info
*
5148 mips_elf_got_info (abfd
, sgotp
)
5153 struct mips_got_info
*g
;
5155 sgot
= mips_elf_got_section (abfd
);
5156 BFD_ASSERT (sgot
!= NULL
);
5157 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
5158 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
5159 BFD_ASSERT (g
!= NULL
);
5166 /* Return whether a relocation is against a local symbol. */
5169 mips_elf_local_relocation_p (input_bfd
, relocation
, local_sections
)
5171 const Elf_Internal_Rela
*relocation
;
5172 asection
**local_sections
;
5174 unsigned long r_symndx
;
5175 Elf_Internal_Shdr
*symtab_hdr
;
5177 r_symndx
= ELF32_R_SYM (relocation
->r_info
);
5178 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
5179 if (! elf_bad_symtab (input_bfd
))
5180 return r_symndx
< symtab_hdr
->sh_info
;
5183 /* The symbol table does not follow the rule that local symbols
5184 must come before globals. */
5185 return local_sections
[r_symndx
] != NULL
;
5189 /* Sign-extend VALUE, which has the indicated number of BITS. */
5192 mips_elf_sign_extend (value
, bits
)
5196 if (value
& (1 << (bits
- 1)))
5197 /* VALUE is negative. */
5198 value
|= ((bfd_vma
) - 1) << bits
;
5203 /* Return non-zero if the indicated VALUE has overflowed the maximum
5204 range expressable by a signed number with the indicated number of
5208 mips_elf_overflow_p (value
, bits
)
5212 bfd_signed_vma svalue
= (bfd_signed_vma
) value
;
5214 if (svalue
> (1 << (bits
- 1)) - 1)
5215 /* The value is too big. */
5217 else if (svalue
< -(1 << (bits
- 1)))
5218 /* The value is too small. */
5225 /* Calculate the %high function. */
5228 mips_elf_high (value
)
5231 return ((value
+ (bfd_vma
) 0x8000) >> 16) & 0xffff;
5234 /* Calculate the %higher function. */
5237 mips_elf_higher (value
)
5238 bfd_vma value ATTRIBUTE_UNUSED
;
5241 return ((value
+ (bfd_vma
) 0x80008000) >> 32) & 0xffff;
5244 return (bfd_vma
) -1;
5248 /* Calculate the %highest function. */
5251 mips_elf_highest (value
)
5252 bfd_vma value ATTRIBUTE_UNUSED
;
5255 return ((value
+ (bfd_vma
) 0x800080008000) > 48) & 0xffff;
5258 return (bfd_vma
) -1;
5262 /* Returns the GOT index for the global symbol indicated by H. */
5265 mips_elf_global_got_index (abfd
, h
)
5267 struct elf_link_hash_entry
*h
;
5271 struct mips_got_info
*g
;
5273 g
= mips_elf_got_info (abfd
, &sgot
);
5275 /* Once we determine the global GOT entry with the lowest dynamic
5276 symbol table index, we must put all dynamic symbols with greater
5277 indices into the GOT. That makes it easy to calculate the GOT
5279 BFD_ASSERT (h
->dynindx
>= g
->global_gotsym
->dynindx
);
5280 index
= ((h
->dynindx
- g
->global_gotsym
->dynindx
+ g
->local_gotno
)
5281 * MIPS_ELF_GOT_SIZE (abfd
));
5282 BFD_ASSERT (index
< sgot
->_raw_size
);
5287 /* Returns the offset for the entry at the INDEXth position
5291 mips_elf_got_offset_from_index (dynobj
, output_bfd
, index
)
5299 sgot
= mips_elf_got_section (dynobj
);
5300 gp
= _bfd_get_gp_value (output_bfd
);
5301 return (sgot
->output_section
->vma
+ sgot
->output_offset
+ index
-
5305 /* If H is a symbol that needs a global GOT entry, but has a dynamic
5306 symbol table index lower than any we've seen to date, record it for
5310 mips_elf_record_global_got_symbol (h
, info
, g
)
5311 struct elf_link_hash_entry
*h
;
5312 struct bfd_link_info
*info
;
5313 struct mips_got_info
*g ATTRIBUTE_UNUSED
;
5315 /* A global symbol in the GOT must also be in the dynamic symbol
5317 if (h
->dynindx
== -1
5318 && !bfd_elf32_link_record_dynamic_symbol (info
, h
))
5321 /* If we've already marked this entry as need GOT space, we don't
5322 need to do it again. */
5323 if (h
->got
.offset
!= (bfd_vma
) - 1)
5326 /* By setting this to a value other than -1, we are indicating that
5327 there needs to be a GOT entry for H. */
5333 /* This structure is passed to mips_elf_sort_hash_table_f when sorting
5334 the dynamic symbols. */
5336 struct mips_elf_hash_sort_data
5338 /* The symbol in the global GOT with the lowest dynamic symbol table
5340 struct elf_link_hash_entry
*low
;
5341 /* The least dynamic symbol table index corresponding to a symbol
5342 with a GOT entry. */
5343 long min_got_dynindx
;
5344 /* The greatest dynamic symbol table index not corresponding to a
5345 symbol without a GOT entry. */
5346 long max_non_got_dynindx
;
5349 /* If H needs a GOT entry, assign it the highest available dynamic
5350 index. Otherwise, assign it the lowest available dynamic
5354 mips_elf_sort_hash_table_f (h
, data
)
5355 struct mips_elf_link_hash_entry
*h
;
5358 struct mips_elf_hash_sort_data
*hsd
5359 = (struct mips_elf_hash_sort_data
*) data
;
5361 /* Symbols without dynamic symbol table entries aren't interesting
5363 if (h
->root
.dynindx
== -1)
5366 if (h
->root
.got
.offset
!= 0)
5367 h
->root
.dynindx
= hsd
->max_non_got_dynindx
++;
5370 h
->root
.dynindx
= --hsd
->min_got_dynindx
;
5371 hsd
->low
= (struct elf_link_hash_entry
*) h
;
5377 /* Sort the dynamic symbol table so that symbols that need GOT entries
5378 appear towards the end. This reduces the amount of GOT space
5379 required. MAX_LOCAL is used to set the number of local symbols
5380 known to be in the dynamic symbol table. During
5381 mips_elf_size_dynamic_sections, this value is 1. Afterward, the
5382 section symbols are added and the count is higher. */
5385 mips_elf_sort_hash_table (info
, max_local
)
5386 struct bfd_link_info
*info
;
5387 unsigned long max_local
;
5389 struct mips_elf_hash_sort_data hsd
;
5390 struct mips_got_info
*g
;
5393 dynobj
= elf_hash_table (info
)->dynobj
;
5396 hsd
.min_got_dynindx
= elf_hash_table (info
)->dynsymcount
;
5397 hsd
.max_non_got_dynindx
= max_local
;
5398 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table
*)
5399 elf_hash_table (info
)),
5400 mips_elf_sort_hash_table_f
,
5403 /* There shoud have been enough room in the symbol table to
5404 accomodate both the GOT and non-GOT symbols. */
5405 BFD_ASSERT (hsd
.min_got_dynindx
== hsd
.max_non_got_dynindx
);
5407 /* Now we know which dynamic symbol has the lowest dynamic symbol
5408 table index in the GOT. */
5409 g
= mips_elf_got_info (dynobj
, NULL
);
5410 g
->global_gotsym
= hsd
.low
;
5415 /* Create a local GOT entry for VALUE. Return the index of the entry,
5416 or -1 if it could not be created. */
5419 mips_elf_create_local_got_entry (abfd
, g
, sgot
, value
)
5421 struct mips_got_info
*g
;
5425 if (g
->assigned_gotno
>= g
->local_gotno
)
5427 /* We didn't allocate enough space in the GOT. */
5428 (*_bfd_error_handler
)
5429 (_("not enough GOT space for local GOT entries"));
5430 bfd_set_error (bfd_error_bad_value
);
5431 return (bfd_vma
) -1;
5434 MIPS_ELF_PUT_WORD (abfd
, value
,
5436 + MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
));
5437 return MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
++;
5440 /* Returns the GOT offset at which the indicated address can be found.
5441 If there is not yet a GOT entry for this value, create one. Returns
5442 -1 if no satisfactory GOT offset can be found. */
5445 mips_elf_local_got_index (abfd
, info
, value
)
5447 struct bfd_link_info
*info
;
5451 struct mips_got_info
*g
;
5454 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
5456 /* Look to see if we already have an appropriate entry. */
5457 for (entry
= (sgot
->contents
5458 + MIPS_ELF_GOT_SIZE (abfd
) * MIPS_RESERVED_GOTNO
);
5459 entry
!= sgot
->contents
+ MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
;
5460 entry
+= MIPS_ELF_GOT_SIZE (abfd
))
5462 bfd_vma address
= MIPS_ELF_GET_WORD (abfd
, entry
);
5463 if (address
== value
)
5464 return entry
- sgot
->contents
;
5467 return mips_elf_create_local_got_entry (abfd
, g
, sgot
, value
);
5470 /* Find a GOT entry that is within 32KB of the VALUE. These entries
5471 are supposed to be placed at small offsets in the GOT, i.e.,
5472 within 32KB of GP. Return the index into the GOT for this page,
5473 and store the offset from this entry to the desired address in
5474 OFFSETP, if it is non-NULL. */
5477 mips_elf_got_page (abfd
, info
, value
, offsetp
)
5479 struct bfd_link_info
*info
;
5484 struct mips_got_info
*g
;
5486 bfd_byte
*last_entry
;
5490 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
5492 /* Look to see if we aleady have an appropriate entry. */
5493 last_entry
= sgot
->contents
+ MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
;
5494 for (entry
= (sgot
->contents
5495 + MIPS_ELF_GOT_SIZE (abfd
) * MIPS_RESERVED_GOTNO
);
5496 entry
!= last_entry
;
5497 entry
+= MIPS_ELF_GOT_SIZE (abfd
))
5499 address
= MIPS_ELF_GET_WORD (abfd
, entry
);
5501 if (!mips_elf_overflow_p (value
- address
, 16))
5503 /* This entry will serve as the page pointer. We can add a
5504 16-bit number to it to get the actual address. */
5505 index
= entry
- sgot
->contents
;
5510 /* If we didn't have an appropriate entry, we create one now. */
5511 if (entry
== last_entry
)
5512 index
= mips_elf_create_local_got_entry (abfd
, g
, sgot
, value
);
5516 address
= MIPS_ELF_GET_WORD (abfd
, entry
);
5517 *offsetp
= value
- address
;
5523 /* Find a GOT entry whose higher-order 16 bits are the same as those
5524 for value. Return the index into the GOT for this entry. */
5527 mips_elf_got16_entry (abfd
, info
, value
)
5529 struct bfd_link_info
*info
;
5533 struct mips_got_info
*g
;
5535 bfd_byte
*last_entry
;
5539 value
&= 0xffff0000;
5540 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
5542 /* Look to see if we already have an appropriate entry. */
5543 last_entry
= sgot
->contents
+ MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
;
5544 for (entry
= (sgot
->contents
5545 + MIPS_ELF_GOT_SIZE (abfd
) * MIPS_RESERVED_GOTNO
);
5546 entry
!= last_entry
;
5547 entry
+= MIPS_ELF_GOT_SIZE (abfd
))
5549 address
= MIPS_ELF_GET_WORD (abfd
, entry
);
5550 if ((address
& 0xffff0000) == value
)
5552 /* This entry has the right high-order 16 bits. */
5553 index
= MIPS_ELF_GOT_SIZE (abfd
) * (entry
- sgot
->contents
);
5558 /* If we didn't have an appropriate entry, we create one now. */
5559 if (entry
== last_entry
)
5560 index
= mips_elf_create_local_got_entry (abfd
, g
, sgot
, value
);
5565 /* Sets *ADDENDP to the addend for the first R_MIPS_LO16 relocation
5566 found, beginning with RELOCATION. RELEND is one-past-the-end of
5567 the relocation table. */
5570 mips_elf_next_lo16_addend (relocation
, relend
, addendp
)
5571 const Elf_Internal_Rela
*relocation
;
5572 const Elf_Internal_Rela
*relend
;
5575 /* According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must be
5576 immediately following. However, for the IRIX6 ABI, the next
5577 relocation may be a composed relocation consisting of several
5578 relocations for the same address. In that case, the R_MIPS_LO16
5579 relocation may occur as one of these. We permit a similar
5580 extension in general, as that is useful for GCC. */
5581 while (relocation
< relend
)
5583 if (ELF32_R_TYPE (relocation
->r_info
) == R_MIPS_LO16
)
5585 *addendp
= relocation
->r_addend
;
5592 /* We didn't find it. */
5593 bfd_set_error (bfd_error_bad_value
);
5597 /* Create a rel.dyn relocation for the dynamic linker to resolve. The
5598 relocatin is against the symbol with the dynamic symbol table index
5599 DYNINDX. REL is the original relocation, which is now being made
5603 mips_elf_create_dynamic_relocation (output_bfd
, info
, rel
, dynindx
,
5604 addend
, input_section
)
5606 struct bfd_link_info
*info
;
5607 const Elf_Internal_Rela
*rel
;
5610 asection
*input_section
;
5612 Elf_Internal_Rel outrel
;
5618 r_type
= ELF32_R_TYPE (rel
->r_info
);
5619 dynobj
= elf_hash_table (info
)->dynobj
;
5621 = bfd_get_section_by_name (dynobj
,
5622 MIPS_ELF_REL_DYN_SECTION_NAME (output_bfd
));
5623 BFD_ASSERT (sreloc
!= NULL
);
5627 /* The symbol for the relocation is the same as it was for the
5628 original relocation. */
5629 outrel
.r_info
= ELF32_R_INFO (dynindx
, R_MIPS_REL32
);
5631 /* The offset for the dynamic relocation is the same as for the
5632 original relocation, adjusted by the offset at which the original
5633 section is output. */
5634 if (elf_section_data (input_section
)->stab_info
== NULL
)
5635 outrel
.r_offset
= rel
->r_offset
;
5640 off
= (_bfd_stab_section_offset
5641 (output_bfd
, &elf_hash_table (info
)->stab_info
,
5643 &elf_section_data (input_section
)->stab_info
,
5645 if (off
== (bfd_vma
) -1)
5647 outrel
.r_offset
= off
;
5649 outrel
.r_offset
+= (input_section
->output_section
->vma
5650 + input_section
->output_offset
);
5652 /* If we've decided to skip this relocation, just output an emtpy
5655 memset (&outrel
, 0, sizeof (outrel
));
5657 if (ABI_64_P (output_bfd
))
5659 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
5660 (output_bfd
, &outrel
,
5662 + sreloc
->reloc_count
* sizeof (Elf64_Mips_External_Rel
)));
5665 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
5666 (((Elf32_External_Rel
*)
5668 + sreloc
->reloc_count
));
5669 ++sreloc
->reloc_count
;
5671 /* Make sure the output section is writable. The dynamic linker
5672 will be writing to it. */
5673 elf_section_data (input_section
->output_section
)->this_hdr
.sh_flags
5676 /* On IRIX5, make an entry of compact relocation info. */
5677 if (! skip
&& IRIX_COMPAT (output_bfd
) == ict_irix5
)
5679 asection
* scpt
= bfd_get_section_by_name (dynobj
, ".compact_rel");
5684 Elf32_crinfo cptrel
;
5686 mips_elf_set_cr_format (cptrel
, CRF_MIPS_LONG
);
5687 cptrel
.vaddr
= (rel
->r_offset
5688 + input_section
->output_section
->vma
5689 + input_section
->output_offset
);
5690 if (r_type
== R_MIPS_REL32
)
5691 mips_elf_set_cr_type (cptrel
, CRT_MIPS_REL32
);
5693 mips_elf_set_cr_type (cptrel
, CRT_MIPS_WORD
);
5694 mips_elf_set_cr_dist2to (cptrel
, 0);
5695 cptrel
.konst
= addend
;
5697 cr
= (scpt
->contents
5698 + sizeof (Elf32_External_compact_rel
));
5699 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
5700 ((Elf32_External_crinfo
*) cr
5701 + scpt
->reloc_count
));
5702 ++scpt
->reloc_count
;
5706 return sreloc
->reloc_count
- 1;
5709 /* Calculate the value produced by the RELOCATION (which comes from
5710 the INPUT_BFD). The ADDEND is the addend to use for this
5711 RELOCATION; RELOCATION->R_ADDEND is ignored.
5713 The result of the relocation calculation is stored in VALUEP.
5714 REQUIRE_JALXP indicates whether or not the opcode used with this
5715 relocation must be JALX.
5717 This function returns bfd_reloc_continue if the caller need take no
5718 further action regarding this relocation, bfd_reloc_notsupported if
5719 something goes dramatically wrong, bfd_reloc_overflow if an
5720 overflow occurs, and bfd_reloc_ok to indicate success. */
5722 static bfd_reloc_status_type
5723 mips_elf_calculate_relocation (abfd
,
5737 asection
*input_section
;
5738 struct bfd_link_info
*info
;
5739 const Elf_Internal_Rela
*relocation
;
5741 reloc_howto_type
*howto
;
5742 Elf_Internal_Sym
*local_syms
;
5743 asection
**local_sections
;
5746 boolean
*require_jalxp
;
5748 /* The eventual value we will return. */
5750 /* The address of the symbol against which the relocation is
5753 /* The final GP value to be used for the relocatable, executable, or
5754 shared object file being produced. */
5755 bfd_vma gp
= (bfd_vma
) - 1;
5756 /* The place (section offset or address) of the storage unit being
5759 /* The value of GP used to create the relocatable object. */
5760 bfd_vma gp0
= (bfd_vma
) - 1;
5761 /* The offset into the global offset table at which the address of
5762 the relocation entry symbol, adjusted by the addend, resides
5763 during execution. */
5764 bfd_vma g
= (bfd_vma
) - 1;
5765 /* The section in which the symbol referenced by the relocation is
5767 asection
*sec
= NULL
;
5768 struct mips_elf_link_hash_entry
* h
= NULL
;
5769 /* True if the symbol referred to by this relocation is a local
5772 /* True if the symbol referred to by this relocation is "_gp_disp". */
5773 boolean gp_disp_p
= false;
5774 Elf_Internal_Shdr
*symtab_hdr
;
5776 unsigned long r_symndx
;
5778 /* True if overflow occurred during the calculation of the
5779 relocation value. */
5780 boolean overflowed_p
;
5781 /* True if this relocation refers to a MIPS16 function. */
5782 boolean target_is_16_bit_code_p
= false;
5784 /* Parse the relocation. */
5785 r_symndx
= ELF32_R_SYM (relocation
->r_info
);
5786 r_type
= ELF32_R_TYPE (relocation
->r_info
);
5787 p
= (input_section
->output_section
->vma
5788 + input_section
->output_offset
5789 + relocation
->r_offset
);
5791 /* Assume that there will be no overflow. */
5792 overflowed_p
= false;
5794 /* Figure out whether or not the symbol is local, and get the offset
5795 used in the array of hash table entries. */
5796 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
5797 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
5799 if (! elf_bad_symtab (input_bfd
))
5800 extsymoff
= symtab_hdr
->sh_info
;
5803 /* The symbol table does not follow the rule that local symbols
5804 must come before globals. */
5808 /* Figure out the value of the symbol. */
5811 Elf_Internal_Sym
*sym
;
5813 sym
= local_syms
+ r_symndx
;
5814 sec
= local_sections
[r_symndx
];
5816 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
5817 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
)
5818 symbol
+= sym
->st_value
;
5820 /* MIPS16 text labels should be treated as odd. */
5821 if (sym
->st_other
== STO_MIPS16
)
5824 /* Record the name of this symbol, for our caller. */
5825 *namep
= bfd_elf_string_from_elf_section (input_bfd
,
5826 symtab_hdr
->sh_link
,
5829 *namep
= bfd_section_name (input_bfd
, sec
);
5831 target_is_16_bit_code_p
= (sym
->st_other
== STO_MIPS16
);
5835 /* For global symbols we look up the symbol in the hash-table. */
5836 h
= ((struct mips_elf_link_hash_entry
*)
5837 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
]);
5838 /* Find the real hash-table entry for this symbol. */
5839 while (h
->root
.type
== bfd_link_hash_indirect
5840 || h
->root
.type
== bfd_link_hash_warning
)
5841 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
5843 /* Record the name of this symbol, for our caller. */
5844 *namep
= h
->root
.root
.root
.string
;
5846 /* See if this is the special _gp_disp symbol. Note that such a
5847 symbol must always be a global symbol. */
5848 if (strcmp (h
->root
.root
.root
.string
, "_gp_disp") == 0)
5850 /* Relocations against _gp_disp are permitted only with
5851 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
5852 if (r_type
!= R_MIPS_HI16
&& r_type
!= R_MIPS_LO16
)
5853 return bfd_reloc_notsupported
;
5857 /* If this symbol is defined, calculate its address. Note that
5858 _gp_disp is a magic symbol, always implicitly defined by the
5859 linker, so it's inappropriate to check to see whether or not
5861 else if ((h
->root
.root
.type
== bfd_link_hash_defined
5862 || h
->root
.root
.type
== bfd_link_hash_defweak
)
5863 && h
->root
.root
.u
.def
.section
)
5865 sec
= h
->root
.root
.u
.def
.section
;
5866 if (sec
->output_section
)
5867 symbol
= (h
->root
.root
.u
.def
.value
5868 + sec
->output_section
->vma
5869 + sec
->output_offset
);
5871 symbol
= h
->root
.root
.u
.def
.value
;
5873 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
5874 /* We allow relocations against undefined weak symbols, giving
5875 it the value zero, so that you can undefined weak functions
5876 and check to see if they exist by looking at their
5881 (*info
->callbacks
->undefined_symbol
)
5882 (info
, h
->root
.root
.root
.string
, input_bfd
,
5883 input_section
, relocation
->r_offset
);
5884 return bfd_reloc_undefined
;
5887 target_is_16_bit_code_p
= (h
->root
.other
== STO_MIPS16
);
5890 /* If this is a 32-bit call to a 16-bit function with a stub, we
5891 need to redirect the call to the stub, unless we're already *in*
5893 if (r_type
!= R_MIPS16_26
&& !info
->relocateable
5894 && ((h
!= NULL
&& h
->fn_stub
!= NULL
)
5895 || (local_p
&& elf_tdata (input_bfd
)->local_stubs
!= NULL
5896 && elf_tdata (input_bfd
)->local_stubs
[r_symndx
] != NULL
))
5897 && !mips_elf_stub_section_p (input_bfd
, input_section
))
5899 /* This is a 32-bit call to a 16-bit function. We should
5900 have already noticed that we were going to need the
5903 sec
= elf_tdata (input_bfd
)->local_stubs
[r_symndx
];
5906 BFD_ASSERT (h
->need_fn_stub
);
5910 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
5912 /* If this is a 16-bit call to a 32-bit function with a stub, we
5913 need to redirect the call to the stub. */
5914 else if (r_type
== R_MIPS16_26
&& !info
->relocateable
5916 && (h
->call_stub
!= NULL
|| h
->call_fp_stub
!= NULL
)
5917 && !target_is_16_bit_code_p
)
5919 /* If both call_stub and call_fp_stub are defined, we can figure
5920 out which one to use by seeing which one appears in the input
5922 if (h
->call_stub
!= NULL
&& h
->call_fp_stub
!= NULL
)
5927 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
5929 if (strncmp (bfd_get_section_name (input_bfd
, o
),
5930 CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
5932 sec
= h
->call_fp_stub
;
5939 else if (h
->call_stub
!= NULL
)
5942 sec
= h
->call_fp_stub
;
5944 BFD_ASSERT (sec
->_raw_size
> 0);
5945 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
5948 /* Calls from 16-bit code to 32-bit code and vice versa require the
5949 special jalx instruction. */
5950 *require_jalxp
= (!info
->relocateable
5951 && ((r_type
== R_MIPS16_26
) != target_is_16_bit_code_p
));
5953 /* If we haven't already determined the GOT offset, or the GP value,
5954 and we're going to need it, get it now. */
5959 case R_MIPS_GOT_DISP
:
5960 case R_MIPS_GOT_HI16
:
5961 case R_MIPS_CALL_HI16
:
5962 case R_MIPS_GOT_LO16
:
5963 case R_MIPS_CALL_LO16
:
5964 /* Find the index into the GOT where this value is located. */
5967 BFD_ASSERT (addend
== 0);
5968 g
= mips_elf_global_got_index
5969 (elf_hash_table (info
)->dynobj
,
5970 (struct elf_link_hash_entry
*) h
);
5974 g
= mips_elf_local_got_index (abfd
, info
, symbol
+ addend
);
5975 if (g
== (bfd_vma
) -1)
5979 /* Convert GOT indices to actual offsets. */
5980 g
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
5986 case R_MIPS_GPREL16
:
5987 case R_MIPS_GPREL32
:
5988 gp0
= _bfd_get_gp_value (input_bfd
);
5989 gp
= _bfd_get_gp_value (abfd
);
5996 /* Figure out what kind of relocation is being performed. */
6000 return bfd_reloc_continue
;
6003 value
= symbol
+ mips_elf_sign_extend (addend
, 16);
6004 overflowed_p
= mips_elf_overflow_p (value
, 16);
6010 /* If we're creating a shared library, or this relocation is
6011 against a symbol in a shared library, then we can't know
6012 where the symbol will end up. So, we create a relocation
6013 record in the output, and leave the job up to the dynamic
6015 if (info
->shared
|| !sec
->output_section
)
6017 unsigned int reloc_index
;
6019 BFD_ASSERT (h
!= NULL
);
6021 = mips_elf_create_dynamic_relocation (abfd
,
6027 if (h
->min_dyn_reloc_index
== 0
6028 || reloc_index
< h
->min_dyn_reloc_index
)
6029 h
->min_dyn_reloc_index
= reloc_index
;
6030 value
= symbol
+ addend
;
6034 if (r_type
!= R_MIPS_REL32
)
6035 value
= symbol
+ addend
;
6039 value
&= howto
->dst_mask
;
6043 /* The calculation for R_MIPS_26 is just the same as for an
6044 R_MIPS_26. It's only the storage of the relocated field into
6045 the output file that's different. That's handled in
6046 mips_elf_perform_relocation. So, we just fall through to the
6047 R_MIPS_26 case here. */
6050 value
= (((addend
<< 2) | (p
& 0xf0000000)) + symbol
) >> 2;
6052 value
= (mips_elf_sign_extend (addend
<< 2, 28) + symbol
) >> 2;
6053 value
&= howto
->dst_mask
;
6059 value
= mips_elf_high (addend
+ symbol
);
6060 value
&= howto
->dst_mask
;
6064 value
= mips_elf_high (addend
+ gp
- p
);
6065 overflowed_p
= mips_elf_overflow_p (value
, 16);
6071 value
= (symbol
+ addend
) & howto
->dst_mask
;
6074 value
= addend
+ gp
- p
+ 4;
6075 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
6076 for overflow. But, on, say, Irix 5, relocations against
6077 _gp_disp are normally generated from the .cpload
6078 pseudo-op. It generates code that normally looks like
6081 lui $gp,%hi(_gp_disp)
6082 addiu $gp,$gp,%lo(_gp_disp)
6085 Here $t9 holds the address of the function being called,
6086 as required by the MIPS ELF ABI. The R_MIPS_LO16
6087 relocation can easily overflow in this situation, but the
6088 R_MIPS_HI16 relocation will handle the overflow.
6089 Therefore, we consider this a bug in the MIPS ABI, and do
6090 not check for overflow here. */
6094 case R_MIPS_LITERAL
:
6095 /* Because we don't merge literal sections, we can handle this
6096 just like R_MIPS_GPREL16. In the long run, we should merge
6097 shared literals, and then we will need to additional work
6102 case R_MIPS16_GPREL
:
6103 /* The R_MIPS16_GPREL performs the same calculation as
6104 R_MIPS_GPREL16, but stores the relocated bits in a different
6105 order. We don't need to do anything special here; the
6106 differences are handled in mips_elf_perform_relocation. */
6107 case R_MIPS_GPREL16
:
6109 value
= mips_elf_sign_extend (addend
, 16) + symbol
+ gp0
- gp
;
6111 value
= mips_elf_sign_extend (addend
, 16) + symbol
- gp
;
6112 overflowed_p
= mips_elf_overflow_p (value
, 16);
6118 value
= mips_elf_got16_entry (abfd
, info
, symbol
+ addend
);
6119 if (value
== (bfd_vma
) -1)
6122 = mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
6125 overflowed_p
= mips_elf_overflow_p (value
, 16);
6132 case R_MIPS_GOT_DISP
:
6134 overflowed_p
= mips_elf_overflow_p (value
, 16);
6137 case R_MIPS_GPREL32
:
6138 value
= (addend
+ symbol
+ gp0
- gp
) & howto
->dst_mask
;
6142 value
= mips_elf_sign_extend (addend
, 16) + symbol
- p
;
6143 overflowed_p
= mips_elf_overflow_p (value
, 16);
6146 case R_MIPS_GOT_HI16
:
6147 case R_MIPS_CALL_HI16
:
6148 /* We're allowed to handle these two relocations identically.
6149 The dynamic linker is allowed to handle the CALL relocations
6150 differently by creating a lazy evaluation stub. */
6152 value
= mips_elf_high (value
);
6153 value
&= howto
->dst_mask
;
6156 case R_MIPS_GOT_LO16
:
6157 case R_MIPS_CALL_LO16
:
6158 value
= g
& howto
->dst_mask
;
6161 case R_MIPS_GOT_PAGE
:
6162 value
= mips_elf_got_page (abfd
, info
, symbol
+ addend
, NULL
);
6163 if (value
== (bfd_vma
) -1)
6165 value
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
6168 overflowed_p
= mips_elf_overflow_p (value
, 16);
6171 case R_MIPS_GOT_OFST
:
6172 mips_elf_got_page (abfd
, info
, symbol
+ addend
, &value
);
6173 overflowed_p
= mips_elf_overflow_p (value
, 16);
6177 value
= symbol
- addend
;
6178 value
&= howto
->dst_mask
;
6182 value
= mips_elf_higher (addend
+ symbol
);
6183 value
&= howto
->dst_mask
;
6186 case R_MIPS_HIGHEST
:
6187 value
= mips_elf_highest (addend
+ symbol
);
6188 value
&= howto
->dst_mask
;
6191 case R_MIPS_SCN_DISP
:
6192 value
= symbol
+ addend
- sec
->output_offset
;
6193 value
&= howto
->dst_mask
;
6198 /* Both of these may be ignored. R_MIPS_JALR is an optimization
6199 hint; we could improve performance by honoring that hint. */
6200 return bfd_reloc_continue
;
6202 case R_MIPS_GNU_VTINHERIT
:
6203 case R_MIPS_GNU_VTENTRY
:
6204 /* We don't do anything with these at present. */
6205 return bfd_reloc_continue
;
6208 /* An unrecognized relocation type. */
6209 return bfd_reloc_notsupported
;
6212 /* Store the VALUE for our caller. */
6214 return overflowed_p
? bfd_reloc_overflow
: bfd_reloc_ok
;
6217 /* Obtain the field relocated by RELOCATION. */
6220 mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
)
6221 reloc_howto_type
*howto
;
6222 const Elf_Internal_Rela
*relocation
;
6227 bfd_byte
*location
= contents
+ relocation
->r_offset
;
6229 /* Obtain the bytes. */
6230 x
= bfd_get (8 * bfd_get_reloc_size (howto
), input_bfd
, location
);
6232 if ((ELF32_R_TYPE (relocation
->r_info
) == R_MIPS16_26
6233 || ELF32_R_TYPE (relocation
->r_info
) == R_MIPS16_GPREL
)
6234 && bfd_little_endian (input_bfd
))
6235 /* The two 16-bit words will be reversed on a little-endian
6236 system. See mips_elf_perform_relocation for more details. */
6237 x
= (((x
& 0xffff) << 16) | ((x
& 0xffff0000) >> 16));
6242 /* It has been determined that the result of the RELOCATION is the
6243 VALUE. Use HOWTO to place VALUE into the output file at the
6244 appropriate position. The SECTION is the section to which the
6245 relocation applies. If REQUIRE_JALX is true, then the opcode used
6246 for the relocation must be either JAL or JALX, and it is
6247 unconditionally converted to JALX.
6249 Returns false if anything goes wrong. */
6252 mips_elf_perform_relocation (info
, howto
, relocation
, value
,
6253 input_bfd
, input_section
,
6254 contents
, require_jalx
)
6255 struct bfd_link_info
*info
;
6256 reloc_howto_type
*howto
;
6257 const Elf_Internal_Rela
*relocation
;
6260 asection
*input_section
;
6262 boolean require_jalx
;
6266 int r_type
= ELF32_R_TYPE (relocation
->r_info
);
6268 /* Figure out where the relocation is occurring. */
6269 location
= contents
+ relocation
->r_offset
;
6271 /* Obtain the current value. */
6272 x
= mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
);
6274 /* Clear the field we are setting. */
6275 x
&= ~howto
->dst_mask
;
6277 /* If this is the R_MIPS16_26 relocation, we must store the
6278 value in a funny way. */
6279 if (r_type
== R_MIPS16_26
)
6281 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
6282 Most mips16 instructions are 16 bits, but these instructions
6285 The format of these instructions is:
6287 +--------------+--------------------------------+
6288 ! JALX ! X! Imm 20:16 ! Imm 25:21 !
6289 +--------------+--------------------------------+
6291 +-----------------------------------------------+
6293 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
6294 Note that the immediate value in the first word is swapped.
6296 When producing a relocateable object file, R_MIPS16_26 is
6297 handled mostly like R_MIPS_26. In particular, the addend is
6298 stored as a straight 26-bit value in a 32-bit instruction.
6299 (gas makes life simpler for itself by never adjusting a
6300 R_MIPS16_26 reloc to be against a section, so the addend is
6301 always zero). However, the 32 bit instruction is stored as 2
6302 16-bit values, rather than a single 32-bit value. In a
6303 big-endian file, the result is the same; in a little-endian
6304 file, the two 16-bit halves of the 32 bit value are swapped.
6305 This is so that a disassembler can recognize the jal
6308 When doing a final link, R_MIPS16_26 is treated as a 32 bit
6309 instruction stored as two 16-bit values. The addend A is the
6310 contents of the targ26 field. The calculation is the same as
6311 R_MIPS_26. When storing the calculated value, reorder the
6312 immediate value as shown above, and don't forget to store the
6313 value as two 16-bit values.
6315 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
6319 +--------+----------------------+
6323 +--------+----------------------+
6326 +----------+------+-------------+
6330 +----------+--------------------+
6331 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
6332 ((sub1 << 16) | sub2)).
6334 When producing a relocateable object file, the calculation is
6335 (((A < 2) | (P & 0xf0000000) + S) >> 2)
6336 When producing a fully linked file, the calculation is
6337 let R = (((A < 2) | (P & 0xf0000000) + S) >> 2)
6338 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff) */
6340 if (!info
->relocateable
)
6341 /* Shuffle the bits according to the formula above. */
6342 value
= (((value
& 0x1f0000) << 5)
6343 | ((value
& 0x3e00000) >> 5)
6344 | (value
& 0xffff));
6347 else if (r_type
== R_MIPS16_GPREL
)
6349 /* R_MIPS16_GPREL is used for GP-relative addressing in mips16
6350 mode. A typical instruction will have a format like this:
6352 +--------------+--------------------------------+
6353 ! EXTEND ! Imm 10:5 ! Imm 15:11 !
6354 +--------------+--------------------------------+
6355 ! Major ! rx ! ry ! Imm 4:0 !
6356 +--------------+--------------------------------+
6358 EXTEND is the five bit value 11110. Major is the instruction
6361 This is handled exactly like R_MIPS_GPREL16, except that the
6362 addend is retrieved and stored as shown in this diagram; that
6363 is, the Imm fields above replace the V-rel16 field.
6365 All we need to do here is shuffle the bits appropriately. As
6366 above, the two 16-bit halves must be swapped on a
6367 little-endian system. */
6368 value
= (((value
& 0x7e0) << 16)
6369 | ((value
& 0xf800) << 5)
6373 /* Set the field. */
6374 x
|= (value
& howto
->dst_mask
);
6376 /* If required, turn JAL into JALX. */
6380 bfd_vma opcode
= x
>> 26;
6381 bfd_vma jalx_opcode
;
6383 /* Check to see if the opcode is already JAL or JALX. */
6384 if (r_type
== R_MIPS16_26
)
6386 ok
= ((opcode
== 0x6) || (opcode
== 0x7));
6391 ok
= ((opcode
== 0x3) || (opcode
== 0x1d));
6395 /* If the opcode is not JAL or JALX, there's a problem. */
6398 (*_bfd_error_handler
)
6399 (_("%s: %s+0x%lx: jump to stub routine which is not jal"),
6400 bfd_get_filename (input_bfd
),
6401 input_section
->name
,
6402 (unsigned long) relocation
->r_offset
);
6403 bfd_set_error (bfd_error_bad_value
);
6407 /* Make this the JALX opcode. */
6408 x
= (x
& ~(0x3f << 26)) | (jalx_opcode
<< 26);
6411 /* Swap the high- and low-order 16 bits on little-endian systems
6412 when doing a MIPS16 relocation. */
6413 if ((r_type
== R_MIPS16_GPREL
|| r_type
== R_MIPS16_26
)
6414 && bfd_little_endian (input_bfd
))
6415 x
= (((x
& 0xffff) << 16) | ((x
& 0xffff0000) >> 16));
6417 /* Put the value into the output. */
6418 bfd_put (8 * bfd_get_reloc_size (howto
), input_bfd
, x
, location
);
6422 /* Returns true if SECTION is a MIPS16 stub section. */
6425 mips_elf_stub_section_p (abfd
, section
)
6426 bfd
*abfd ATTRIBUTE_UNUSED
;
6429 const char *name
= bfd_get_section_name (abfd
, section
);
6431 return (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0
6432 || strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
6433 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0);
6436 /* Relocate a MIPS ELF section. */
6439 _bfd_mips_elf_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
6440 contents
, relocs
, local_syms
, local_sections
)
6442 struct bfd_link_info
*info
;
6444 asection
*input_section
;
6446 Elf_Internal_Rela
*relocs
;
6447 Elf_Internal_Sym
*local_syms
;
6448 asection
**local_sections
;
6450 Elf_Internal_Rela
*rel
;
6451 const Elf_Internal_Rela
*relend
;
6453 bfd_vma last_hi16_addend
;
6454 boolean use_saved_addend_p
= false;
6455 boolean last_hi16_addend_valid_p
= false;
6456 struct elf_backend_data
*bed
;
6458 bed
= get_elf_backend_data (output_bfd
);
6459 relend
= relocs
+ input_section
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
6460 for (rel
= relocs
; rel
< relend
; ++rel
)
6464 reloc_howto_type
*howto
;
6465 boolean require_jalx
;
6466 /* True if the relocation is a RELA relocation, rather than a
6468 boolean rela_relocation_p
= true;
6469 int r_type
= ELF32_R_TYPE (rel
->r_info
);
6471 /* Find the relocation howto for this relocation. */
6472 if (r_type
== R_MIPS_64
&& !ABI_64_P (output_bfd
))
6473 /* Some 32-bit code uses R_MIPS_64. In particular, people use
6474 64-bit code, but make sure all their addresses are in the
6475 lowermost or uppermost 32-bit section of the 64-bit address
6476 space. Thus, when they use an R_MIPS_64 they mean what is
6477 usually meant by R_MIPS_32, with the exception that the
6478 stored value is sign-extended to 64 bits. */
6479 howto
= elf_mips_howto_table
+ R_MIPS_32
;
6481 howto
= mips_rtype_to_howto (r_type
);
6483 if (!use_saved_addend_p
)
6485 Elf_Internal_Shdr
*rel_hdr
;
6487 /* If these relocations were originally of the REL variety,
6488 we must pull the addend out of the field that will be
6489 relocated. Otherwise, we simply use the contents of the
6490 RELA relocation. To determine which flavor or relocation
6491 this is, we depend on the fact that the INPUT_SECTION's
6492 REL_HDR is read before its REL_HDR2. */
6493 rel_hdr
= &elf_section_data (input_section
)->rel_hdr
;
6494 if ((size_t) (rel
- relocs
)
6495 >= (rel_hdr
->sh_size
/ rel_hdr
->sh_entsize
6496 * bed
->s
->int_rels_per_ext_rel
))
6497 rel_hdr
= elf_section_data (input_section
)->rel_hdr2
;
6498 if (rel_hdr
->sh_entsize
== MIPS_ELF_REL_SIZE (input_bfd
))
6500 /* Note that this is a REL relocation. */
6501 rela_relocation_p
= false;
6503 /* Get the addend, which is stored in the input file. */
6504 addend
= mips_elf_obtain_contents (howto
,
6508 addend
&= howto
->src_mask
;
6510 /* For some kinds of relocations, the ADDEND is a
6511 combination of the addend stored in two different
6513 if (r_type
== R_MIPS_HI16
6514 || (r_type
== R_MIPS_GOT16
6515 && mips_elf_local_relocation_p (input_bfd
, rel
,
6518 /* Scan ahead to find a matching R_MIPS_LO16
6522 if (!mips_elf_next_lo16_addend (rel
, relend
, &l
))
6525 /* Save the high-order bit for later. When we
6526 encounter the R_MIPS_LO16 relocation we will need
6529 last_hi16_addend
= addend
;
6530 last_hi16_addend_valid_p
= true;
6532 /* Compute the combined addend. */
6535 else if (r_type
== R_MIPS_LO16
)
6537 /* Used the saved HI16 addend. */
6538 if (!last_hi16_addend_valid_p
)
6540 bfd_set_error (bfd_error_bad_value
);
6543 addend
|= last_hi16_addend
;
6545 else if (r_type
== R_MIPS16_GPREL
)
6547 /* The addend is scrambled in the object file. See
6548 mips_elf_perform_relocation for details on the
6550 addend
= (((addend
& 0x1f0000) >> 5)
6551 | ((addend
& 0x7e00000) >> 16)
6556 addend
= rel
->r_addend
;
6559 if (info
->relocateable
)
6561 Elf_Internal_Sym
*sym
;
6562 unsigned long r_symndx
;
6564 /* Since we're just relocating, all we need to do is copy
6565 the relocations back out to the object file, unless
6566 they're against a section symbol, in which case we need
6567 to adjust by the section offset, or unless they're GP
6568 relative in which case we need to adjust by the amount
6569 that we're adjusting GP in this relocateable object. */
6571 if (!mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
))
6572 /* There's nothing to do for non-local relocations. */
6575 r_symndx
= ELF32_R_SYM (rel
->r_info
);
6576 sym
= local_syms
+ r_symndx
;
6577 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6578 /* Adjust the addend appropriately. */
6579 addend
+= local_sections
[r_symndx
]->output_offset
;
6581 if (r_type
== R_MIPS16_GPREL
6582 || r_type
== R_MIPS_GPREL16
6583 || r_type
== R_MIPS_GPREL32
)
6584 addend
-= (_bfd_get_gp_value (output_bfd
)
6585 - _bfd_get_gp_value (input_bfd
));
6587 /* If the relocation is for a R_MIPS_HI16 or R_MIPS_GOT16,
6588 then we only want to write out the high-order 16 bits.
6589 The subsequent R_MIPS_LO16 will handle the low-order bits. */
6590 if (r_type
== R_MIPS_HI16
|| r_type
== R_MIPS_GOT16
)
6593 if (rela_relocation_p
)
6594 /* If this is a RELA relocation, just update the addend.
6595 We have to cast away constness for REL. */
6596 rel
->r_addend
= addend
;
6599 /* Otherwise, we have to write the value back out. Note
6600 that we use the source mask, rather than the
6601 destination mask because the place to which we are
6602 writing will be source of the addend in the final
6604 addend
&= howto
->src_mask
;
6605 if (!mips_elf_perform_relocation (info
, howto
, rel
, addend
,
6606 input_bfd
, input_section
,
6611 /* Go on to the next relocation. */
6615 /* In the N32 and 64-bit ABIs there may be multiple consecutive
6616 relocations for the same offset. In that case we are
6617 supposed to treat the output of each relocation as the addend
6619 if (rel
+ 1 < relend
6620 && rel
->r_offset
== rel
[1].r_offset
6621 && ELF32_R_TYPE (rel
[1].r_info
) != R_MIPS_NONE
)
6622 use_saved_addend_p
= true;
6624 use_saved_addend_p
= false;
6626 /* Figure out what value we are supposed to relocate. */
6627 switch (mips_elf_calculate_relocation (output_bfd
,
6640 case bfd_reloc_continue
:
6641 /* There's nothing to do. */
6644 case bfd_reloc_undefined
:
6645 /* mips_elf_calculate_relocation already called the
6646 undefined_symbol callback. There's no real point in
6647 trying to perform the relocation at this point, so we
6648 just skip ahead to the next relocation. */
6651 case bfd_reloc_notsupported
:
6655 case bfd_reloc_overflow
:
6656 if (use_saved_addend_p
)
6657 /* Ignore overflow until we reach the last relocation for
6658 a given location. */
6662 BFD_ASSERT (name
!= NULL
);
6663 if (! ((*info
->callbacks
->reloc_overflow
)
6664 (info
, name
, howto
->name
, (bfd_vma
) 0,
6665 input_bfd
, input_section
, rel
->r_offset
)))
6678 /* If we've got another relocation for the address, keep going
6679 until we reach the last one. */
6680 if (use_saved_addend_p
)
6686 if (r_type
== R_MIPS_64
&& !ABI_64_P (output_bfd
))
6687 /* See the comment above about using R_MIPS_64 in the 32-bit
6688 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
6689 that calculated the right value. Now, however, we
6690 sign-extend the 32-bit result to 64-bits, and store it as a
6691 64-bit value. We are especially generous here in that we
6692 go to extreme lengths to support this usage on systems with
6693 only a 32-bit VMA. */
6696 /* Just sign-extend the value, and then fall through to the
6697 normal case, using the R_MIPS_64 howto. That will store
6698 the 64-bit value into a 64-bit area. */
6699 value
= mips_elf_sign_extend (value
, 64);
6700 howto
= elf_mips_howto_table
+ R_MIPS_64
;
6702 /* In the 32-bit VMA case, we must handle sign-extension and
6703 endianness manually. */
6708 if (value
& 0x80000000)
6709 sign_bits
= 0xffffffff;
6713 /* If only a 32-bit VMA is available do two separate
6715 if (bfd_big_endian (input_bfd
))
6717 /* Store the sign-bits (which are most significant)
6719 low_bits
= sign_bits
;
6725 high_bits
= sign_bits
;
6727 bfd_put_32 (input_bfd
, low_bits
,
6728 contents
+ rel
->r_offset
);
6729 bfd_put_32 (input_bfd
, high_bits
,
6730 contents
+ rel
->r_offset
+ 4);
6735 /* Actually perform the relocation. */
6736 if (!mips_elf_perform_relocation (info
, howto
, rel
, value
, input_bfd
,
6737 input_section
, contents
,
6745 /* This hook function is called before the linker writes out a global
6746 symbol. We mark symbols as small common if appropriate. This is
6747 also where we undo the increment of the value for a mips16 symbol. */
6751 _bfd_mips_elf_link_output_symbol_hook (abfd
, info
, name
, sym
, input_sec
)
6752 bfd
*abfd ATTRIBUTE_UNUSED
;
6753 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
6754 const char *name ATTRIBUTE_UNUSED
;
6755 Elf_Internal_Sym
*sym
;
6756 asection
*input_sec
;
6758 /* If we see a common symbol, which implies a relocatable link, then
6759 if a symbol was small common in an input file, mark it as small
6760 common in the output file. */
6761 if (sym
->st_shndx
== SHN_COMMON
6762 && strcmp (input_sec
->name
, ".scommon") == 0)
6763 sym
->st_shndx
= SHN_MIPS_SCOMMON
;
6765 if (sym
->st_other
== STO_MIPS16
6766 && (sym
->st_value
& 1) != 0)
6772 /* Functions for the dynamic linker. */
6774 /* The name of the dynamic interpreter. This is put in the .interp
6777 #define ELF_DYNAMIC_INTERPRETER(abfd) \
6778 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
6779 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
6780 : "/usr/lib/libc.so.1")
6782 /* Create dynamic sections when linking against a dynamic object. */
6785 _bfd_mips_elf_create_dynamic_sections (abfd
, info
)
6787 struct bfd_link_info
*info
;
6789 struct elf_link_hash_entry
*h
;
6791 register asection
*s
;
6792 const char * const *namep
;
6794 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
6795 | SEC_LINKER_CREATED
| SEC_READONLY
);
6797 /* Mips ABI requests the .dynamic section to be read only. */
6798 s
= bfd_get_section_by_name (abfd
, ".dynamic");
6801 if (! bfd_set_section_flags (abfd
, s
, flags
))
6805 /* We need to create .got section. */
6806 if (! mips_elf_create_got_section (abfd
, info
))
6809 /* Create the .msym section on IRIX6. It is used by the dynamic
6810 linker to speed up dynamic relocations, and to avoid computing
6811 the ELF hash for symbols. */
6812 if (IRIX_COMPAT (abfd
) == ict_irix6
6813 && !mips_elf_create_msym_section (abfd
))
6816 /* Create .stub section. */
6817 if (bfd_get_section_by_name (abfd
,
6818 MIPS_ELF_STUB_SECTION_NAME (abfd
)) == NULL
)
6820 s
= bfd_make_section (abfd
, MIPS_ELF_STUB_SECTION_NAME (abfd
));
6822 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_CODE
)
6823 || ! bfd_set_section_alignment (abfd
, s
,
6824 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
6828 if (IRIX_COMPAT (abfd
) == ict_irix5
6830 && bfd_get_section_by_name (abfd
, ".rld_map") == NULL
)
6832 s
= bfd_make_section (abfd
, ".rld_map");
6834 || ! bfd_set_section_flags (abfd
, s
, flags
& ~SEC_READONLY
)
6835 || ! bfd_set_section_alignment (abfd
, s
,
6836 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
6840 /* On IRIX5, we adjust add some additional symbols and change the
6841 alignments of several sections. There is no ABI documentation
6842 indicating that this is necessary on IRIX6, nor any evidence that
6843 the linker takes such action. */
6844 if (IRIX_COMPAT (abfd
) == ict_irix5
)
6846 for (namep
= mips_elf_dynsym_rtproc_names
; *namep
!= NULL
; namep
++)
6849 if (! (_bfd_generic_link_add_one_symbol
6850 (info
, abfd
, *namep
, BSF_GLOBAL
, bfd_und_section_ptr
,
6851 (bfd_vma
) 0, (const char *) NULL
, false,
6852 get_elf_backend_data (abfd
)->collect
,
6853 (struct bfd_link_hash_entry
**) &h
)))
6855 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
6856 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
6857 h
->type
= STT_SECTION
;
6859 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
6863 /* We need to create a .compact_rel section. */
6864 if (! mips_elf_create_compact_rel_section (abfd
, info
))
6867 /* Change aligments of some sections. */
6868 s
= bfd_get_section_by_name (abfd
, ".hash");
6870 bfd_set_section_alignment (abfd
, s
, 4);
6871 s
= bfd_get_section_by_name (abfd
, ".dynsym");
6873 bfd_set_section_alignment (abfd
, s
, 4);
6874 s
= bfd_get_section_by_name (abfd
, ".dynstr");
6876 bfd_set_section_alignment (abfd
, s
, 4);
6877 s
= bfd_get_section_by_name (abfd
, ".reginfo");
6879 bfd_set_section_alignment (abfd
, s
, 4);
6880 s
= bfd_get_section_by_name (abfd
, ".dynamic");
6882 bfd_set_section_alignment (abfd
, s
, 4);
6888 if (! (_bfd_generic_link_add_one_symbol
6889 (info
, abfd
, "_DYNAMIC_LINK", BSF_GLOBAL
, bfd_abs_section_ptr
,
6890 (bfd_vma
) 0, (const char *) NULL
, false,
6891 get_elf_backend_data (abfd
)->collect
,
6892 (struct bfd_link_hash_entry
**) &h
)))
6894 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
6895 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
6896 h
->type
= STT_SECTION
;
6898 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
6901 if (! mips_elf_hash_table (info
)->use_rld_obj_head
)
6903 /* __rld_map is a four byte word located in the .data section
6904 and is filled in by the rtld to contain a pointer to
6905 the _r_debug structure. Its symbol value will be set in
6906 mips_elf_finish_dynamic_symbol. */
6907 s
= bfd_get_section_by_name (abfd
, ".rld_map");
6908 BFD_ASSERT (s
!= NULL
);
6911 if (! (_bfd_generic_link_add_one_symbol
6912 (info
, abfd
, "__rld_map", BSF_GLOBAL
, s
,
6913 (bfd_vma
) 0, (const char *) NULL
, false,
6914 get_elf_backend_data (abfd
)->collect
,
6915 (struct bfd_link_hash_entry
**) &h
)))
6917 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
6918 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
6919 h
->type
= STT_OBJECT
;
6921 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
6929 /* Create the .compact_rel section. */
6932 mips_elf_create_compact_rel_section (abfd
, info
)
6934 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
6937 register asection
*s
;
6939 if (bfd_get_section_by_name (abfd
, ".compact_rel") == NULL
)
6941 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
6944 s
= bfd_make_section (abfd
, ".compact_rel");
6946 || ! bfd_set_section_flags (abfd
, s
, flags
)
6947 || ! bfd_set_section_alignment (abfd
, s
,
6948 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
6951 s
->_raw_size
= sizeof (Elf32_External_compact_rel
);
6957 /* Create the .got section to hold the global offset table. */
6960 mips_elf_create_got_section (abfd
, info
)
6962 struct bfd_link_info
*info
;
6965 register asection
*s
;
6966 struct elf_link_hash_entry
*h
;
6967 struct mips_got_info
*g
;
6969 /* This function may be called more than once. */
6970 if (mips_elf_got_section (abfd
))
6973 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
6974 | SEC_LINKER_CREATED
);
6976 s
= bfd_make_section (abfd
, ".got");
6978 || ! bfd_set_section_flags (abfd
, s
, flags
)
6979 || ! bfd_set_section_alignment (abfd
, s
, 4))
6982 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
6983 linker script because we don't want to define the symbol if we
6984 are not creating a global offset table. */
6986 if (! (_bfd_generic_link_add_one_symbol
6987 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
6988 (bfd_vma
) 0, (const char *) NULL
, false,
6989 get_elf_backend_data (abfd
)->collect
,
6990 (struct bfd_link_hash_entry
**) &h
)))
6992 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
6993 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
6994 h
->type
= STT_OBJECT
;
6997 && ! bfd_elf32_link_record_dynamic_symbol (info
, h
))
7000 /* The first several global offset table entries are reserved. */
7001 s
->_raw_size
= MIPS_RESERVED_GOTNO
* MIPS_ELF_GOT_SIZE (abfd
);
7003 g
= (struct mips_got_info
*) bfd_alloc (abfd
,
7004 sizeof (struct mips_got_info
));
7007 g
->global_gotsym
= NULL
;
7008 g
->local_gotno
= MIPS_RESERVED_GOTNO
;
7009 g
->assigned_gotno
= MIPS_RESERVED_GOTNO
;
7010 if (elf_section_data (s
) == NULL
)
7013 (PTR
) bfd_zalloc (abfd
, sizeof (struct bfd_elf_section_data
));
7014 if (elf_section_data (s
) == NULL
)
7017 elf_section_data (s
)->tdata
= (PTR
) g
;
7018 elf_section_data (s
)->this_hdr
.sh_flags
7019 |= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
7024 /* Returns the .msym section for ABFD, creating it if it does not
7025 already exist. Returns NULL to indicate error. */
7028 mips_elf_create_msym_section (abfd
)
7033 s
= bfd_get_section_by_name (abfd
, MIPS_ELF_MSYM_SECTION_NAME (abfd
));
7036 s
= bfd_make_section (abfd
, MIPS_ELF_MSYM_SECTION_NAME (abfd
));
7038 || !bfd_set_section_flags (abfd
, s
,
7042 | SEC_LINKER_CREATED
7044 || !bfd_set_section_alignment (abfd
, s
,
7045 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
7052 /* Add room for N relocations to the .rel.dyn section in ABFD. */
7055 mips_elf_allocate_dynamic_relocations (abfd
, n
)
7061 s
= bfd_get_section_by_name (abfd
, MIPS_ELF_REL_DYN_SECTION_NAME (abfd
));
7062 BFD_ASSERT (s
!= NULL
);
7064 if (s
->_raw_size
== 0)
7066 /* Make room for a null element. */
7067 s
->_raw_size
+= MIPS_ELF_REL_SIZE (abfd
);
7070 s
->_raw_size
+= n
* MIPS_ELF_REL_SIZE (abfd
);
7073 /* Look through the relocs for a section during the first phase, and
7074 allocate space in the global offset table. */
7077 _bfd_mips_elf_check_relocs (abfd
, info
, sec
, relocs
)
7079 struct bfd_link_info
*info
;
7081 const Elf_Internal_Rela
*relocs
;
7085 Elf_Internal_Shdr
*symtab_hdr
;
7086 struct elf_link_hash_entry
**sym_hashes
;
7087 struct mips_got_info
*g
;
7089 const Elf_Internal_Rela
*rel
;
7090 const Elf_Internal_Rela
*rel_end
;
7093 struct elf_backend_data
*bed
;
7095 if (info
->relocateable
)
7098 dynobj
= elf_hash_table (info
)->dynobj
;
7099 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7100 sym_hashes
= elf_sym_hashes (abfd
);
7101 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
7103 /* Check for the mips16 stub sections. */
7105 name
= bfd_get_section_name (abfd
, sec
);
7106 if (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0)
7108 unsigned long r_symndx
;
7110 /* Look at the relocation information to figure out which symbol
7113 r_symndx
= ELF32_R_SYM (relocs
->r_info
);
7115 if (r_symndx
< extsymoff
7116 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
7120 /* This stub is for a local symbol. This stub will only be
7121 needed if there is some relocation in this BFD, other
7122 than a 16 bit function call, which refers to this symbol. */
7123 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
7125 Elf_Internal_Rela
*sec_relocs
;
7126 const Elf_Internal_Rela
*r
, *rend
;
7128 /* We can ignore stub sections when looking for relocs. */
7129 if ((o
->flags
& SEC_RELOC
) == 0
7130 || o
->reloc_count
== 0
7131 || strncmp (bfd_get_section_name (abfd
, o
), FN_STUB
,
7132 sizeof FN_STUB
- 1) == 0
7133 || strncmp (bfd_get_section_name (abfd
, o
), CALL_STUB
,
7134 sizeof CALL_STUB
- 1) == 0
7135 || strncmp (bfd_get_section_name (abfd
, o
), CALL_FP_STUB
,
7136 sizeof CALL_FP_STUB
- 1) == 0)
7139 sec_relocs
= (_bfd_elf32_link_read_relocs
7140 (abfd
, o
, (PTR
) NULL
,
7141 (Elf_Internal_Rela
*) NULL
,
7142 info
->keep_memory
));
7143 if (sec_relocs
== NULL
)
7146 rend
= sec_relocs
+ o
->reloc_count
;
7147 for (r
= sec_relocs
; r
< rend
; r
++)
7148 if (ELF32_R_SYM (r
->r_info
) == r_symndx
7149 && ELF32_R_TYPE (r
->r_info
) != R_MIPS16_26
)
7152 if (! info
->keep_memory
)
7161 /* There is no non-call reloc for this stub, so we do
7162 not need it. Since this function is called before
7163 the linker maps input sections to output sections, we
7164 can easily discard it by setting the SEC_EXCLUDE
7166 sec
->flags
|= SEC_EXCLUDE
;
7170 /* Record this stub in an array of local symbol stubs for
7172 if (elf_tdata (abfd
)->local_stubs
== NULL
)
7174 unsigned long symcount
;
7177 if (elf_bad_symtab (abfd
))
7178 symcount
= symtab_hdr
->sh_size
/ symtab_hdr
->sh_entsize
;
7180 symcount
= symtab_hdr
->sh_info
;
7181 n
= (asection
**) bfd_zalloc (abfd
,
7182 symcount
* sizeof (asection
*));
7185 elf_tdata (abfd
)->local_stubs
= n
;
7188 elf_tdata (abfd
)->local_stubs
[r_symndx
] = sec
;
7190 /* We don't need to set mips16_stubs_seen in this case.
7191 That flag is used to see whether we need to look through
7192 the global symbol table for stubs. We don't need to set
7193 it here, because we just have a local stub. */
7197 struct mips_elf_link_hash_entry
*h
;
7199 h
= ((struct mips_elf_link_hash_entry
*)
7200 sym_hashes
[r_symndx
- extsymoff
]);
7202 /* H is the symbol this stub is for. */
7205 mips_elf_hash_table (info
)->mips16_stubs_seen
= true;
7208 else if (strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
7209 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
7211 unsigned long r_symndx
;
7212 struct mips_elf_link_hash_entry
*h
;
7215 /* Look at the relocation information to figure out which symbol
7218 r_symndx
= ELF32_R_SYM (relocs
->r_info
);
7220 if (r_symndx
< extsymoff
7221 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
7223 /* This stub was actually built for a static symbol defined
7224 in the same file. We assume that all static symbols in
7225 mips16 code are themselves mips16, so we can simply
7226 discard this stub. Since this function is called before
7227 the linker maps input sections to output sections, we can
7228 easily discard it by setting the SEC_EXCLUDE flag. */
7229 sec
->flags
|= SEC_EXCLUDE
;
7233 h
= ((struct mips_elf_link_hash_entry
*)
7234 sym_hashes
[r_symndx
- extsymoff
]);
7236 /* H is the symbol this stub is for. */
7238 if (strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
7239 loc
= &h
->call_fp_stub
;
7241 loc
= &h
->call_stub
;
7243 /* If we already have an appropriate stub for this function, we
7244 don't need another one, so we can discard this one. Since
7245 this function is called before the linker maps input sections
7246 to output sections, we can easily discard it by setting the
7247 SEC_EXCLUDE flag. We can also discard this section if we
7248 happen to already know that this is a mips16 function; it is
7249 not necessary to check this here, as it is checked later, but
7250 it is slightly faster to check now. */
7251 if (*loc
!= NULL
|| h
->root
.other
== STO_MIPS16
)
7253 sec
->flags
|= SEC_EXCLUDE
;
7258 mips_elf_hash_table (info
)->mips16_stubs_seen
= true;
7268 sgot
= mips_elf_got_section (dynobj
);
7273 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
7274 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
7275 BFD_ASSERT (g
!= NULL
);
7280 bed
= get_elf_backend_data (abfd
);
7281 rel_end
= relocs
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
7282 for (rel
= relocs
; rel
< rel_end
; ++rel
)
7284 unsigned long r_symndx
;
7286 struct elf_link_hash_entry
*h
;
7288 r_symndx
= ELF32_R_SYM (rel
->r_info
);
7289 r_type
= ELF32_R_TYPE (rel
->r_info
);
7291 if (r_symndx
< extsymoff
)
7295 h
= sym_hashes
[r_symndx
- extsymoff
];
7297 /* This may be an indirect symbol created because of a version. */
7300 while (h
->root
.type
== bfd_link_hash_indirect
)
7301 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
7305 /* Some relocs require a global offset table. */
7306 if (dynobj
== NULL
|| sgot
== NULL
)
7312 case R_MIPS_CALL_HI16
:
7313 case R_MIPS_CALL_LO16
:
7314 case R_MIPS_GOT_HI16
:
7315 case R_MIPS_GOT_LO16
:
7316 case R_MIPS_GOT_PAGE
:
7317 case R_MIPS_GOT_OFST
:
7318 case R_MIPS_GOT_DISP
:
7320 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
7321 if (! mips_elf_create_got_section (dynobj
, info
))
7323 g
= mips_elf_got_info (dynobj
, &sgot
);
7330 && (info
->shared
|| h
!= NULL
)
7331 && (sec
->flags
& SEC_ALLOC
) != 0)
7332 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
7340 if (!h
&& (r_type
== R_MIPS_CALL_LO16
7341 || r_type
== R_MIPS_GOT_LO16
7342 || r_type
== R_MIPS_GOT_DISP
7343 || r_type
== R_MIPS_GOT16
))
7345 /* We may need a local GOT entry for this relocation. We
7346 don't count R_MIPS_GOT_PAGE because we can estimate the
7347 maximum number of pages needed by looking at the size of
7348 the segment. We don't count R_MIPS_GOT_HI16, or
7349 R_MIPS_CALL_HI16 because these are always followed by an
7350 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16.
7352 This estimation is very conservative since we can merge
7353 duplicate entries in the GOT. In order to be less
7354 conservative, we could actually build the GOT here,
7355 rather than in relocate_section. */
7357 sgot
->_raw_size
+= MIPS_ELF_GOT_SIZE (dynobj
);
7365 (*_bfd_error_handler
)
7366 (_("%s: CALL16 reloc at 0x%lx not against global symbol"),
7367 bfd_get_filename (abfd
), (unsigned long) rel
->r_offset
);
7368 bfd_set_error (bfd_error_bad_value
);
7373 case R_MIPS_CALL_HI16
:
7374 case R_MIPS_CALL_LO16
:
7375 /* This symbol requires a global offset table entry. */
7376 if (!mips_elf_record_global_got_symbol (h
, info
, g
))
7379 /* We need a stub, not a plt entry for the undefined
7380 function. But we record it as if it needs plt. See
7381 elf_adjust_dynamic_symbol in elflink.h. */
7382 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
7388 case R_MIPS_GOT_HI16
:
7389 case R_MIPS_GOT_LO16
:
7390 case R_MIPS_GOT_DISP
:
7391 /* This symbol requires a global offset table entry. */
7392 if (h
&& !mips_elf_record_global_got_symbol (h
, info
, g
))
7399 if ((info
->shared
|| h
!= NULL
)
7400 && (sec
->flags
& SEC_ALLOC
) != 0)
7404 const char *name
= MIPS_ELF_REL_DYN_SECTION_NAME (dynobj
);
7406 sreloc
= bfd_get_section_by_name (dynobj
, name
);
7409 sreloc
= bfd_make_section (dynobj
, name
);
7411 || ! bfd_set_section_flags (dynobj
, sreloc
,
7416 | SEC_LINKER_CREATED
7418 || ! bfd_set_section_alignment (dynobj
, sreloc
,
7424 /* When creating a shared object, we must copy these
7425 reloc types into the output file as R_MIPS_REL32
7426 relocs. We make room for this reloc in the
7427 .rel.dyn reloc section. */
7428 mips_elf_allocate_dynamic_relocations (dynobj
, 1);
7431 struct mips_elf_link_hash_entry
*hmips
;
7433 /* We only need to copy this reloc if the symbol is
7434 defined in a dynamic object. */
7435 hmips
= (struct mips_elf_link_hash_entry
*) h
;
7436 ++hmips
->possibly_dynamic_relocs
;
7439 /* Even though we don't directly need a GOT entry for
7440 this symbol, a symbol must have a dynamic symbol
7441 table index greater that DT_GOTSYM if there are
7442 dynamic relocations against it. */
7443 if (!mips_elf_record_global_got_symbol (h
, info
, g
))
7447 if (SGI_COMPAT (dynobj
))
7448 mips_elf_hash_table (info
)->compact_rel_size
+=
7449 sizeof (Elf32_External_crinfo
);
7453 case R_MIPS_GPREL16
:
7454 case R_MIPS_LITERAL
:
7455 case R_MIPS_GPREL32
:
7456 if (SGI_COMPAT (dynobj
))
7457 mips_elf_hash_table (info
)->compact_rel_size
+=
7458 sizeof (Elf32_External_crinfo
);
7461 /* This relocation describes the C++ object vtable hierarchy.
7462 Reconstruct it for later use during GC. */
7463 case R_MIPS_GNU_VTINHERIT
:
7464 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
7468 /* This relocation describes which C++ vtable entries are actually
7469 used. Record for later use during GC. */
7470 case R_MIPS_GNU_VTENTRY
:
7471 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
7479 /* If this reloc is not a 16 bit call, and it has a global
7480 symbol, then we will need the fn_stub if there is one.
7481 References from a stub section do not count. */
7483 && r_type
!= R_MIPS16_26
7484 && strncmp (bfd_get_section_name (abfd
, sec
), FN_STUB
,
7485 sizeof FN_STUB
- 1) != 0
7486 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_STUB
,
7487 sizeof CALL_STUB
- 1) != 0
7488 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_FP_STUB
,
7489 sizeof CALL_FP_STUB
- 1) != 0)
7491 struct mips_elf_link_hash_entry
*mh
;
7493 mh
= (struct mips_elf_link_hash_entry
*) h
;
7494 mh
->need_fn_stub
= true;
7501 /* Return the section that should be marked against GC for a given
7505 _bfd_mips_elf_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
7507 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
7508 Elf_Internal_Rela
*rel
;
7509 struct elf_link_hash_entry
*h
;
7510 Elf_Internal_Sym
*sym
;
7512 /* ??? Do mips16 stub sections need to be handled special? */
7516 switch (ELF32_R_TYPE (rel
->r_info
))
7518 case R_MIPS_GNU_VTINHERIT
:
7519 case R_MIPS_GNU_VTENTRY
:
7523 switch (h
->root
.type
)
7525 case bfd_link_hash_defined
:
7526 case bfd_link_hash_defweak
:
7527 return h
->root
.u
.def
.section
;
7529 case bfd_link_hash_common
:
7530 return h
->root
.u
.c
.p
->section
;
7539 if (!(elf_bad_symtab (abfd
)
7540 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
7541 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
7542 && sym
->st_shndx
!= SHN_COMMON
))
7544 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
7551 /* Update the got entry reference counts for the section being removed. */
7554 _bfd_mips_elf_gc_sweep_hook (abfd
, info
, sec
, relocs
)
7555 bfd
*abfd ATTRIBUTE_UNUSED
;
7556 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
7557 asection
*sec ATTRIBUTE_UNUSED
;
7558 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
;
7561 Elf_Internal_Shdr
*symtab_hdr
;
7562 struct elf_link_hash_entry
**sym_hashes
;
7563 bfd_signed_vma
*local_got_refcounts
;
7564 const Elf_Internal_Rela
*rel
, *relend
;
7565 unsigned long r_symndx
;
7566 struct elf_link_hash_entry
*h
;
7568 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7569 sym_hashes
= elf_sym_hashes (abfd
);
7570 local_got_refcounts
= elf_local_got_refcounts (abfd
);
7572 relend
= relocs
+ sec
->reloc_count
;
7573 for (rel
= relocs
; rel
< relend
; rel
++)
7574 switch (ELF32_R_TYPE (rel
->r_info
))
7578 case R_MIPS_CALL_HI16
:
7579 case R_MIPS_CALL_LO16
:
7580 case R_MIPS_GOT_HI16
:
7581 case R_MIPS_GOT_LO16
:
7582 /* ??? It would seem that the existing MIPS code does no sort
7583 of reference counting or whatnot on its GOT and PLT entries,
7584 so it is not possible to garbage collect them at this time. */
7596 /* Adjust a symbol defined by a dynamic object and referenced by a
7597 regular object. The current definition is in some section of the
7598 dynamic object, but we're not including those sections. We have to
7599 change the definition to something the rest of the link can
7603 _bfd_mips_elf_adjust_dynamic_symbol (info
, h
)
7604 struct bfd_link_info
*info
;
7605 struct elf_link_hash_entry
*h
;
7608 struct mips_elf_link_hash_entry
*hmips
;
7611 dynobj
= elf_hash_table (info
)->dynobj
;
7613 /* Make sure we know what is going on here. */
7614 BFD_ASSERT (dynobj
!= NULL
7615 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
7616 || h
->weakdef
!= NULL
7617 || ((h
->elf_link_hash_flags
7618 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
7619 && (h
->elf_link_hash_flags
7620 & ELF_LINK_HASH_REF_REGULAR
) != 0
7621 && (h
->elf_link_hash_flags
7622 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
7624 /* If this symbol is defined in a dynamic object, we need to copy
7625 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
7627 hmips
= (struct mips_elf_link_hash_entry
*) h
;
7628 if (! info
->relocateable
7629 && hmips
->possibly_dynamic_relocs
!= 0
7630 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
7631 mips_elf_allocate_dynamic_relocations (dynobj
,
7632 hmips
->possibly_dynamic_relocs
);
7634 /* For a function, create a stub, if needed. */
7635 if (h
->type
== STT_FUNC
7636 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
7638 if (! elf_hash_table (info
)->dynamic_sections_created
)
7641 /* If this symbol is not defined in a regular file, then set
7642 the symbol to the stub location. This is required to make
7643 function pointers compare as equal between the normal
7644 executable and the shared library. */
7645 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
7647 /* We need .stub section. */
7648 s
= bfd_get_section_by_name (dynobj
,
7649 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
7650 BFD_ASSERT (s
!= NULL
);
7652 h
->root
.u
.def
.section
= s
;
7653 h
->root
.u
.def
.value
= s
->_raw_size
;
7655 /* XXX Write this stub address somewhere. */
7656 h
->plt
.offset
= s
->_raw_size
;
7658 /* Make room for this stub code. */
7659 s
->_raw_size
+= MIPS_FUNCTION_STUB_SIZE
;
7661 /* The last half word of the stub will be filled with the index
7662 of this symbol in .dynsym section. */
7667 /* If this is a weak symbol, and there is a real definition, the
7668 processor independent code will have arranged for us to see the
7669 real definition first, and we can just use the same value. */
7670 if (h
->weakdef
!= NULL
)
7672 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
7673 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
7674 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
7675 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
7679 /* This is a reference to a symbol defined by a dynamic object which
7680 is not a function. */
7685 /* This function is called after all the input files have been read,
7686 and the input sections have been assigned to output sections. We
7687 check for any mips16 stub sections that we can discard. */
7689 static boolean mips_elf_check_mips16_stubs
7690 PARAMS ((struct mips_elf_link_hash_entry
*, PTR
));
7693 _bfd_mips_elf_always_size_sections (output_bfd
, info
)
7695 struct bfd_link_info
*info
;
7699 /* The .reginfo section has a fixed size. */
7700 ri
= bfd_get_section_by_name (output_bfd
, ".reginfo");
7702 bfd_set_section_size (output_bfd
, ri
, sizeof (Elf32_External_RegInfo
));
7704 if (info
->relocateable
7705 || ! mips_elf_hash_table (info
)->mips16_stubs_seen
)
7708 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
7709 mips_elf_check_mips16_stubs
,
7715 /* Check the mips16 stubs for a particular symbol, and see if we can
7720 mips_elf_check_mips16_stubs (h
, data
)
7721 struct mips_elf_link_hash_entry
*h
;
7722 PTR data ATTRIBUTE_UNUSED
;
7724 if (h
->fn_stub
!= NULL
7725 && ! h
->need_fn_stub
)
7727 /* We don't need the fn_stub; the only references to this symbol
7728 are 16 bit calls. Clobber the size to 0 to prevent it from
7729 being included in the link. */
7730 h
->fn_stub
->_raw_size
= 0;
7731 h
->fn_stub
->_cooked_size
= 0;
7732 h
->fn_stub
->flags
&= ~ SEC_RELOC
;
7733 h
->fn_stub
->reloc_count
= 0;
7734 h
->fn_stub
->flags
|= SEC_EXCLUDE
;
7737 if (h
->call_stub
!= NULL
7738 && h
->root
.other
== STO_MIPS16
)
7740 /* We don't need the call_stub; this is a 16 bit function, so
7741 calls from other 16 bit functions are OK. Clobber the size
7742 to 0 to prevent it from being included in the link. */
7743 h
->call_stub
->_raw_size
= 0;
7744 h
->call_stub
->_cooked_size
= 0;
7745 h
->call_stub
->flags
&= ~ SEC_RELOC
;
7746 h
->call_stub
->reloc_count
= 0;
7747 h
->call_stub
->flags
|= SEC_EXCLUDE
;
7750 if (h
->call_fp_stub
!= NULL
7751 && h
->root
.other
== STO_MIPS16
)
7753 /* We don't need the call_stub; this is a 16 bit function, so
7754 calls from other 16 bit functions are OK. Clobber the size
7755 to 0 to prevent it from being included in the link. */
7756 h
->call_fp_stub
->_raw_size
= 0;
7757 h
->call_fp_stub
->_cooked_size
= 0;
7758 h
->call_fp_stub
->flags
&= ~ SEC_RELOC
;
7759 h
->call_fp_stub
->reloc_count
= 0;
7760 h
->call_fp_stub
->flags
|= SEC_EXCLUDE
;
7766 /* Set the sizes of the dynamic sections. */
7769 _bfd_mips_elf_size_dynamic_sections (output_bfd
, info
)
7771 struct bfd_link_info
*info
;
7776 struct mips_got_info
*g
;
7778 dynobj
= elf_hash_table (info
)->dynobj
;
7779 BFD_ASSERT (dynobj
!= NULL
);
7781 if (elf_hash_table (info
)->dynamic_sections_created
)
7783 /* Set the contents of the .interp section to the interpreter. */
7786 s
= bfd_get_section_by_name (dynobj
, ".interp");
7787 BFD_ASSERT (s
!= NULL
);
7789 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd
)) + 1;
7791 = (bfd_byte
*) ELF_DYNAMIC_INTERPRETER (output_bfd
);
7795 /* The check_relocs and adjust_dynamic_symbol entry points have
7796 determined the sizes of the various dynamic sections. Allocate
7799 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
7804 /* It's OK to base decisions on the section name, because none
7805 of the dynobj section names depend upon the input files. */
7806 name
= bfd_get_section_name (dynobj
, s
);
7808 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
7813 if (strncmp (name
, ".rel", 4) == 0)
7815 if (s
->_raw_size
== 0)
7817 /* We only strip the section if the output section name
7818 has the same name. Otherwise, there might be several
7819 input sections for this output section. FIXME: This
7820 code is probably not needed these days anyhow, since
7821 the linker now does not create empty output sections. */
7822 if (s
->output_section
!= NULL
7824 bfd_get_section_name (s
->output_section
->owner
,
7825 s
->output_section
)) == 0)
7830 const char *outname
;
7833 /* If this relocation section applies to a read only
7834 section, then we probably need a DT_TEXTREL entry.
7835 If the relocation section is .rel.dyn, we always
7836 assert a DT_TEXTREL entry rather than testing whether
7837 there exists a relocation to a read only section or
7839 outname
= bfd_get_section_name (output_bfd
,
7841 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
7843 && (target
->flags
& SEC_READONLY
) != 0
7844 && (target
->flags
& SEC_ALLOC
) != 0)
7846 MIPS_ELF_REL_DYN_SECTION_NAME (output_bfd
)) == 0)
7849 /* We use the reloc_count field as a counter if we need
7850 to copy relocs into the output file. */
7852 MIPS_ELF_REL_DYN_SECTION_NAME (output_bfd
)) != 0)
7856 else if (strncmp (name
, ".got", 4) == 0)
7859 bfd_size_type loadable_size
= 0;
7860 bfd_size_type local_gotno
;
7863 BFD_ASSERT (elf_section_data (s
) != NULL
);
7864 g
= (struct mips_got_info
*) elf_section_data (s
)->tdata
;
7865 BFD_ASSERT (g
!= NULL
);
7867 /* Calculate the total loadable size of the output. That
7868 will give us the maximum number of GOT_PAGE entries
7870 for (sub
= info
->input_bfds
; sub
; sub
= sub
->link_next
)
7872 asection
*subsection
;
7874 for (subsection
= sub
->sections
;
7876 subsection
= subsection
->next
)
7878 if ((subsection
->flags
& SEC_ALLOC
) == 0)
7880 loadable_size
+= (subsection
->_raw_size
+ 0xf) & ~0xf;
7883 loadable_size
+= MIPS_FUNCTION_STUB_SIZE
;
7885 /* Assume there are two loadable segments consisting of
7886 contiguous sections. Is 5 enough? */
7887 local_gotno
= (loadable_size
>> 16) + 5;
7888 g
->local_gotno
+= local_gotno
;
7889 s
->_raw_size
+= local_gotno
* MIPS_ELF_GOT_SIZE (dynobj
);
7891 /* There has to be a global GOT entry for every symbol with
7892 a dynamic symbol table index of DT_MIPS_GOTSYM or
7893 higher. Therefore, it make sense to put those symbols
7894 that need GOT entries at the end of the symbol table. We
7896 if (!mips_elf_sort_hash_table (info
, 1))
7899 i
= elf_hash_table (info
)->dynsymcount
- g
->global_gotsym
->dynindx
;
7900 g
->global_gotno
= i
;
7901 s
->_raw_size
+= i
* MIPS_ELF_GOT_SIZE (dynobj
);
7903 else if (strcmp (name
, MIPS_ELF_STUB_SECTION_NAME (output_bfd
)) == 0)
7905 /* Irix rld assumes that the function stub isn't at the end
7906 of .text section. So put a dummy. XXX */
7907 s
->_raw_size
+= MIPS_FUNCTION_STUB_SIZE
;
7909 else if (! info
->shared
7910 && ! mips_elf_hash_table (info
)->use_rld_obj_head
7911 && strncmp (name
, ".rld_map", 8) == 0)
7913 /* We add a room for __rld_map. It will be filled in by the
7914 rtld to contain a pointer to the _r_debug structure. */
7917 else if (SGI_COMPAT (output_bfd
)
7918 && strncmp (name
, ".compact_rel", 12) == 0)
7919 s
->_raw_size
+= mips_elf_hash_table (info
)->compact_rel_size
;
7920 else if (strcmp (name
, MIPS_ELF_MSYM_SECTION_NAME (output_bfd
))
7922 s
->_raw_size
= (sizeof (Elf32_External_Msym
)
7923 * (elf_hash_table (info
)->dynsymcount
7924 + bfd_count_sections (output_bfd
)));
7925 else if (strncmp (name
, ".init", 5) != 0)
7927 /* It's not one of our sections, so don't allocate space. */
7933 _bfd_strip_section_from_output (s
);
7937 /* Allocate memory for the section contents. */
7938 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
7939 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
7941 bfd_set_error (bfd_error_no_memory
);
7946 if (elf_hash_table (info
)->dynamic_sections_created
)
7948 /* Add some entries to the .dynamic section. We fill in the
7949 values later, in elf_mips_finish_dynamic_sections, but we
7950 must add the entries now so that we get the correct size for
7951 the .dynamic section. The DT_DEBUG entry is filled in by the
7952 dynamic linker and used by the debugger. */
7955 if (SGI_COMPAT (output_bfd
))
7957 /* SGI object has the equivalence of DT_DEBUG in the
7958 DT_MIPS_RLD_MAP entry. */
7959 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_MAP
, 0))
7963 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
7969 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_TEXTREL
, 0))
7973 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTGOT
, 0))
7976 if (bfd_get_section_by_name (dynobj
,
7977 MIPS_ELF_REL_DYN_SECTION_NAME (dynobj
)))
7979 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_REL
, 0))
7982 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELSZ
, 0))
7985 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELENT
, 0))
7989 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_CONFLICTNO
, 0))
7992 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LIBLISTNO
, 0))
7995 if (bfd_get_section_by_name (dynobj
, ".conflict") != NULL
)
7997 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_CONFLICT
, 0))
8000 s
= bfd_get_section_by_name (dynobj
, ".liblist");
8001 BFD_ASSERT (s
!= NULL
);
8003 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LIBLIST
, 0))
8007 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_VERSION
, 0))
8010 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_FLAGS
, 0))
8014 /* Time stamps in executable files are a bad idea. */
8015 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_TIME_STAMP
, 0))
8020 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_ICHECKSUM
, 0))
8025 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_IVERSION
, 0))
8029 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_BASE_ADDRESS
, 0))
8032 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LOCAL_GOTNO
, 0))
8035 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_SYMTABNO
, 0))
8038 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_UNREFEXTNO
, 0))
8041 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_GOTSYM
, 0))
8044 if (IRIX_COMPAT (dynobj
) == ict_irix5
8045 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_HIPAGENO
, 0))
8048 if (IRIX_COMPAT (dynobj
) == ict_irix6
8049 && (bfd_get_section_by_name
8050 (dynobj
, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj
)))
8051 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_OPTIONS
, 0))
8054 if (bfd_get_section_by_name (dynobj
,
8055 MIPS_ELF_MSYM_SECTION_NAME (dynobj
))
8056 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_MSYM
, 0))
8063 /* If NAME is one of the special IRIX6 symbols defined by the linker,
8064 adjust it appropriately now. */
8067 mips_elf_irix6_finish_dynamic_symbol (abfd
, name
, sym
)
8068 bfd
*abfd ATTRIBUTE_UNUSED
;
8070 Elf_Internal_Sym
*sym
;
8072 /* The linker script takes care of providing names and values for
8073 these, but we must place them into the right sections. */
8074 static const char* const text_section_symbols
[] = {
8077 "__dso_displacement",
8079 "__program_header_table",
8083 static const char* const data_section_symbols
[] = {
8091 const char* const *p
;
8094 for (i
= 0; i
< 2; ++i
)
8095 for (p
= (i
== 0) ? text_section_symbols
: data_section_symbols
;
8098 if (strcmp (*p
, name
) == 0)
8100 /* All of these symbols are given type STT_SECTION by the
8102 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8104 /* The IRIX linker puts these symbols in special sections. */
8106 sym
->st_shndx
= SHN_MIPS_TEXT
;
8108 sym
->st_shndx
= SHN_MIPS_DATA
;
8114 /* Finish up dynamic symbol handling. We set the contents of various
8115 dynamic sections here. */
8118 _bfd_mips_elf_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
8120 struct bfd_link_info
*info
;
8121 struct elf_link_hash_entry
*h
;
8122 Elf_Internal_Sym
*sym
;
8128 struct mips_got_info
*g
;
8130 struct mips_elf_link_hash_entry
*mh
;
8132 dynobj
= elf_hash_table (info
)->dynobj
;
8133 gval
= sym
->st_value
;
8134 mh
= (struct mips_elf_link_hash_entry
*) h
;
8136 if (h
->plt
.offset
!= (bfd_vma
) -1)
8140 bfd_byte stub
[MIPS_FUNCTION_STUB_SIZE
];
8142 /* This symbol has a stub. Set it up. */
8144 BFD_ASSERT (h
->dynindx
!= -1);
8146 s
= bfd_get_section_by_name (dynobj
,
8147 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
8148 BFD_ASSERT (s
!= NULL
);
8150 /* Fill the stub. */
8152 bfd_put_32 (output_bfd
, STUB_LW(output_bfd
), p
);
8154 bfd_put_32 (output_bfd
, STUB_MOVE
, p
);
8157 /* FIXME: Can h->dynindex be more than 64K? */
8158 if (h
->dynindx
& 0xffff0000)
8161 bfd_put_32 (output_bfd
, STUB_JALR
, p
);
8163 bfd_put_32 (output_bfd
, STUB_LI16
+ h
->dynindx
, p
);
8165 BFD_ASSERT (h
->plt
.offset
<= s
->_raw_size
);
8166 memcpy (s
->contents
+ h
->plt
.offset
, stub
, MIPS_FUNCTION_STUB_SIZE
);
8168 /* Mark the symbol as undefined. plt.offset != -1 occurs
8169 only for the referenced symbol. */
8170 sym
->st_shndx
= SHN_UNDEF
;
8172 /* The run-time linker uses the st_value field of the symbol
8173 to reset the global offset table entry for this external
8174 to its stub address when unlinking a shared object. */
8175 gval
= s
->output_section
->vma
+ s
->output_offset
+ h
->plt
.offset
;
8176 sym
->st_value
= gval
;
8179 BFD_ASSERT (h
->dynindx
!= -1);
8181 sgot
= mips_elf_got_section (dynobj
);
8182 BFD_ASSERT (sgot
!= NULL
);
8183 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
8184 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
8185 BFD_ASSERT (g
!= NULL
);
8187 /* Run through the global symbol table, creating GOT entries for all
8188 the symbols that need them. */
8189 if (h
->dynindx
>= g
->global_gotsym
->dynindx
)
8195 value
= sym
->st_value
;
8197 /* For an entity defined in a shared object, this will be
8198 NULL. (For functions in shared objects for
8199 which we have created stubs, ST_VALUE will be non-NULL.
8200 That's because such the functions are now no longer defined
8201 in a shared object.) */
8202 value
= h
->root
.u
.def
.value
;
8204 offset
= mips_elf_global_got_index (dynobj
, h
);
8205 MIPS_ELF_PUT_WORD (output_bfd
, value
, sgot
->contents
+ offset
);
8208 /* Create a .msym entry, if appropriate. */
8209 smsym
= bfd_get_section_by_name (dynobj
,
8210 MIPS_ELF_MSYM_SECTION_NAME (dynobj
));
8213 Elf32_Internal_Msym msym
;
8215 msym
.ms_hash_value
= bfd_elf_hash (h
->root
.root
.string
);
8216 /* It is undocumented what the `1' indicates, but IRIX6 uses
8218 msym
.ms_info
= ELF32_MS_INFO (mh
->min_dyn_reloc_index
, 1);
8219 bfd_mips_elf_swap_msym_out
8221 ((Elf32_External_Msym
*) smsym
->contents
) + h
->dynindx
);
8224 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
8225 name
= h
->root
.root
.string
;
8226 if (strcmp (name
, "_DYNAMIC") == 0
8227 || strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
8228 sym
->st_shndx
= SHN_ABS
;
8229 else if (strcmp (name
, "_DYNAMIC_LINK") == 0)
8231 sym
->st_shndx
= SHN_ABS
;
8232 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8235 else if (SGI_COMPAT (output_bfd
))
8237 if (strcmp (name
, "_gp_disp") == 0)
8239 sym
->st_shndx
= SHN_ABS
;
8240 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8241 sym
->st_value
= elf_gp (output_bfd
);
8243 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
8244 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
8246 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8247 sym
->st_other
= STO_PROTECTED
;
8249 sym
->st_shndx
= SHN_MIPS_DATA
;
8251 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
8253 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8254 sym
->st_other
= STO_PROTECTED
;
8255 sym
->st_value
= mips_elf_hash_table (info
)->procedure_count
;
8256 sym
->st_shndx
= SHN_ABS
;
8258 else if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
!= SHN_ABS
)
8260 if (h
->type
== STT_FUNC
)
8261 sym
->st_shndx
= SHN_MIPS_TEXT
;
8262 else if (h
->type
== STT_OBJECT
)
8263 sym
->st_shndx
= SHN_MIPS_DATA
;
8267 /* Handle the IRIX6-specific symbols. */
8268 if (IRIX_COMPAT (output_bfd
) == ict_irix6
)
8269 mips_elf_irix6_finish_dynamic_symbol (output_bfd
, name
, sym
);
8271 if (SGI_COMPAT (output_bfd
)
8274 if (! mips_elf_hash_table (info
)->use_rld_obj_head
8275 && strcmp (name
, "__rld_map") == 0)
8277 asection
*s
= bfd_get_section_by_name (dynobj
, ".rld_map");
8278 BFD_ASSERT (s
!= NULL
);
8279 sym
->st_value
= s
->output_section
->vma
+ s
->output_offset
;
8280 bfd_put_32 (output_bfd
, (bfd_vma
) 0, s
->contents
);
8281 if (mips_elf_hash_table (info
)->rld_value
== 0)
8282 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
8284 else if (mips_elf_hash_table (info
)->use_rld_obj_head
8285 && strcmp (name
, "__rld_obj_head") == 0)
8287 /* IRIX6 does not use a .rld_map section. */
8288 if (IRIX_COMPAT (output_bfd
) == ict_irix5
)
8289 BFD_ASSERT (bfd_get_section_by_name (dynobj
, ".rld_map")
8291 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
8295 /* If this is a mips16 symbol, force the value to be even. */
8296 if (sym
->st_other
== STO_MIPS16
8297 && (sym
->st_value
& 1) != 0)
8303 /* Finish up the dynamic sections. */
8306 _bfd_mips_elf_finish_dynamic_sections (output_bfd
, info
)
8308 struct bfd_link_info
*info
;
8313 struct mips_got_info
*g
;
8315 dynobj
= elf_hash_table (info
)->dynobj
;
8317 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
8319 sgot
= mips_elf_got_section (dynobj
);
8324 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
8325 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
8326 BFD_ASSERT (g
!= NULL
);
8329 if (elf_hash_table (info
)->dynamic_sections_created
)
8333 BFD_ASSERT (sdyn
!= NULL
);
8334 BFD_ASSERT (g
!= NULL
);
8336 for (b
= sdyn
->contents
;
8337 b
< sdyn
->contents
+ sdyn
->_raw_size
;
8338 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
8340 Elf_Internal_Dyn dyn
;
8346 /* Read in the current dynamic entry. */
8347 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
8349 /* Assume that we're going to modify it and write it out. */
8355 s
= (bfd_get_section_by_name
8357 MIPS_ELF_REL_DYN_SECTION_NAME (dynobj
)));
8358 BFD_ASSERT (s
!= NULL
);
8359 dyn
.d_un
.d_val
= MIPS_ELF_REL_SIZE (dynobj
);
8363 /* Rewrite DT_STRSZ. */
8365 _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
8371 case DT_MIPS_CONFLICT
:
8374 case DT_MIPS_LIBLIST
:
8377 s
= bfd_get_section_by_name (output_bfd
, name
);
8378 BFD_ASSERT (s
!= NULL
);
8379 dyn
.d_un
.d_ptr
= s
->vma
;
8382 case DT_MIPS_RLD_VERSION
:
8383 dyn
.d_un
.d_val
= 1; /* XXX */
8387 dyn
.d_un
.d_val
= RHF_NOTPOT
; /* XXX */
8390 case DT_MIPS_CONFLICTNO
:
8392 elemsize
= sizeof (Elf32_Conflict
);
8395 case DT_MIPS_LIBLISTNO
:
8397 elemsize
= sizeof (Elf32_Lib
);
8399 s
= bfd_get_section_by_name (output_bfd
, name
);
8402 if (s
->_cooked_size
!= 0)
8403 dyn
.d_un
.d_val
= s
->_cooked_size
/ elemsize
;
8405 dyn
.d_un
.d_val
= s
->_raw_size
/ elemsize
;
8411 case DT_MIPS_TIME_STAMP
:
8412 time ((time_t *) &dyn
.d_un
.d_val
);
8415 case DT_MIPS_ICHECKSUM
:
8420 case DT_MIPS_IVERSION
:
8425 case DT_MIPS_BASE_ADDRESS
:
8426 s
= output_bfd
->sections
;
8427 BFD_ASSERT (s
!= NULL
);
8428 dyn
.d_un
.d_ptr
= s
->vma
& ~(0xffff);
8431 case DT_MIPS_LOCAL_GOTNO
:
8432 dyn
.d_un
.d_val
= g
->local_gotno
;
8435 case DT_MIPS_SYMTABNO
:
8437 elemsize
= MIPS_ELF_SYM_SIZE (output_bfd
);
8438 s
= bfd_get_section_by_name (output_bfd
, name
);
8439 BFD_ASSERT (s
!= NULL
);
8441 if (s
->_cooked_size
!= 0)
8442 dyn
.d_un
.d_val
= s
->_cooked_size
/ elemsize
;
8444 dyn
.d_un
.d_val
= s
->_raw_size
/ elemsize
;
8447 case DT_MIPS_UNREFEXTNO
:
8448 /* The index into the dynamic symbol table which is the
8449 entry of the first external symbol that is not
8450 referenced within the same object. */
8451 dyn
.d_un
.d_val
= bfd_count_sections (output_bfd
) + 1;
8454 case DT_MIPS_GOTSYM
:
8455 dyn
.d_un
.d_val
= g
->global_gotsym
->dynindx
;
8458 case DT_MIPS_HIPAGENO
:
8459 dyn
.d_un
.d_val
= g
->local_gotno
- MIPS_RESERVED_GOTNO
;
8462 case DT_MIPS_RLD_MAP
:
8463 dyn
.d_un
.d_ptr
= mips_elf_hash_table (info
)->rld_value
;
8466 case DT_MIPS_OPTIONS
:
8467 s
= (bfd_get_section_by_name
8468 (output_bfd
, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd
)));
8469 dyn
.d_un
.d_ptr
= s
->vma
;
8473 s
= (bfd_get_section_by_name
8474 (output_bfd
, MIPS_ELF_MSYM_SECTION_NAME (output_bfd
)));
8475 dyn
.d_un
.d_ptr
= s
->vma
;
8484 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
8489 /* The first entry of the global offset table will be filled at
8490 runtime. The second entry will be used by some runtime loaders.
8491 This isn't the case of Irix rld. */
8492 if (sgot
!= NULL
&& sgot
->_raw_size
> 0)
8494 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
8495 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0x80000000,
8496 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
8500 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
8501 = MIPS_ELF_GOT_SIZE (output_bfd
);
8506 Elf32_compact_rel cpt
;
8508 /* ??? The section symbols for the output sections were set up in
8509 _bfd_elf_final_link. SGI sets the STT_NOTYPE attribute for these
8510 symbols. Should we do so? */
8512 smsym
= bfd_get_section_by_name (dynobj
,
8513 MIPS_ELF_MSYM_SECTION_NAME (dynobj
));
8516 Elf32_Internal_Msym msym
;
8518 msym
.ms_hash_value
= 0;
8519 msym
.ms_info
= ELF32_MS_INFO (0, 1);
8521 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
8523 long dynindx
= elf_section_data (s
)->dynindx
;
8525 bfd_mips_elf_swap_msym_out
8527 (((Elf32_External_Msym
*) smsym
->contents
)
8532 if (SGI_COMPAT (output_bfd
))
8534 /* Write .compact_rel section out. */
8535 s
= bfd_get_section_by_name (dynobj
, ".compact_rel");
8539 cpt
.num
= s
->reloc_count
;
8541 cpt
.offset
= (s
->output_section
->filepos
8542 + sizeof (Elf32_External_compact_rel
));
8545 bfd_elf32_swap_compact_rel_out (output_bfd
, &cpt
,
8546 ((Elf32_External_compact_rel
*)
8549 /* Clean up a dummy stub function entry in .text. */
8550 s
= bfd_get_section_by_name (dynobj
,
8551 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
8554 file_ptr dummy_offset
;
8556 BFD_ASSERT (s
->_raw_size
>= MIPS_FUNCTION_STUB_SIZE
);
8557 dummy_offset
= s
->_raw_size
- MIPS_FUNCTION_STUB_SIZE
;
8558 memset (s
->contents
+ dummy_offset
, 0,
8559 MIPS_FUNCTION_STUB_SIZE
);
8564 /* Clean up a first relocation in .rel.dyn. */
8565 s
= bfd_get_section_by_name (dynobj
,
8566 MIPS_ELF_REL_DYN_SECTION_NAME (dynobj
));
8567 if (s
!= NULL
&& s
->_raw_size
> 0)
8568 memset (s
->contents
, 0, MIPS_ELF_REL_SIZE (dynobj
));
8574 /* This is almost identical to bfd_generic_get_... except that some
8575 MIPS relocations need to be handled specially. Sigh. */
8578 elf32_mips_get_relocated_section_contents (abfd
, link_info
, link_order
, data
,
8579 relocateable
, symbols
)
8581 struct bfd_link_info
*link_info
;
8582 struct bfd_link_order
*link_order
;
8584 boolean relocateable
;
8587 /* Get enough memory to hold the stuff */
8588 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
8589 asection
*input_section
= link_order
->u
.indirect
.section
;
8591 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
8592 arelent
**reloc_vector
= NULL
;
8598 reloc_vector
= (arelent
**) bfd_malloc (reloc_size
);
8599 if (reloc_vector
== NULL
&& reloc_size
!= 0)
8602 /* read in the section */
8603 if (!bfd_get_section_contents (input_bfd
,
8607 input_section
->_raw_size
))
8610 /* We're not relaxing the section, so just copy the size info */
8611 input_section
->_cooked_size
= input_section
->_raw_size
;
8612 input_section
->reloc_done
= true;
8614 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
8618 if (reloc_count
< 0)
8621 if (reloc_count
> 0)
8626 bfd_vma gp
= 0x12345678; /* initialize just to shut gcc up */
8629 struct bfd_hash_entry
*h
;
8630 struct bfd_link_hash_entry
*lh
;
8631 /* Skip all this stuff if we aren't mixing formats. */
8632 if (abfd
&& input_bfd
8633 && abfd
->xvec
== input_bfd
->xvec
)
8637 h
= bfd_hash_lookup (&link_info
->hash
->table
, "_gp", false, false);
8638 lh
= (struct bfd_link_hash_entry
*) h
;
8645 case bfd_link_hash_undefined
:
8646 case bfd_link_hash_undefweak
:
8647 case bfd_link_hash_common
:
8650 case bfd_link_hash_defined
:
8651 case bfd_link_hash_defweak
:
8653 gp
= lh
->u
.def
.value
;
8655 case bfd_link_hash_indirect
:
8656 case bfd_link_hash_warning
:
8658 /* @@FIXME ignoring warning for now */
8660 case bfd_link_hash_new
:
8669 for (parent
= reloc_vector
; *parent
!= (arelent
*) NULL
;
8672 char *error_message
= (char *) NULL
;
8673 bfd_reloc_status_type r
;
8675 /* Specific to MIPS: Deal with relocation types that require
8676 knowing the gp of the output bfd. */
8677 asymbol
*sym
= *(*parent
)->sym_ptr_ptr
;
8678 if (bfd_is_abs_section (sym
->section
) && abfd
)
8680 /* The special_function wouldn't get called anyways. */
8684 /* The gp isn't there; let the special function code
8685 fall over on its own. */
8687 else if ((*parent
)->howto
->special_function
8688 == _bfd_mips_elf_gprel16_reloc
)
8690 /* bypass special_function call */
8691 r
= gprel16_with_gp (input_bfd
, sym
, *parent
, input_section
,
8692 relocateable
, (PTR
) data
, gp
);
8693 goto skip_bfd_perform_relocation
;
8695 /* end mips specific stuff */
8697 r
= bfd_perform_relocation (input_bfd
,
8701 relocateable
? abfd
: (bfd
*) NULL
,
8703 skip_bfd_perform_relocation
:
8707 asection
*os
= input_section
->output_section
;
8709 /* A partial link, so keep the relocs */
8710 os
->orelocation
[os
->reloc_count
] = *parent
;
8714 if (r
!= bfd_reloc_ok
)
8718 case bfd_reloc_undefined
:
8719 if (!((*link_info
->callbacks
->undefined_symbol
)
8720 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
8721 input_bfd
, input_section
, (*parent
)->address
)))
8724 case bfd_reloc_dangerous
:
8725 BFD_ASSERT (error_message
!= (char *) NULL
);
8726 if (!((*link_info
->callbacks
->reloc_dangerous
)
8727 (link_info
, error_message
, input_bfd
, input_section
,
8728 (*parent
)->address
)))
8731 case bfd_reloc_overflow
:
8732 if (!((*link_info
->callbacks
->reloc_overflow
)
8733 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
8734 (*parent
)->howto
->name
, (*parent
)->addend
,
8735 input_bfd
, input_section
, (*parent
)->address
)))
8738 case bfd_reloc_outofrange
:
8747 if (reloc_vector
!= NULL
)
8748 free (reloc_vector
);
8752 if (reloc_vector
!= NULL
)
8753 free (reloc_vector
);
8756 #define bfd_elf32_bfd_get_relocated_section_contents \
8757 elf32_mips_get_relocated_section_contents
8759 /* ECOFF swapping routines. These are used when dealing with the
8760 .mdebug section, which is in the ECOFF debugging format. */
8761 static const struct ecoff_debug_swap mips_elf32_ecoff_debug_swap
=
8763 /* Symbol table magic number. */
8765 /* Alignment of debugging information. E.g., 4. */
8767 /* Sizes of external symbolic information. */
8768 sizeof (struct hdr_ext
),
8769 sizeof (struct dnr_ext
),
8770 sizeof (struct pdr_ext
),
8771 sizeof (struct sym_ext
),
8772 sizeof (struct opt_ext
),
8773 sizeof (struct fdr_ext
),
8774 sizeof (struct rfd_ext
),
8775 sizeof (struct ext_ext
),
8776 /* Functions to swap in external symbolic data. */
8785 _bfd_ecoff_swap_tir_in
,
8786 _bfd_ecoff_swap_rndx_in
,
8787 /* Functions to swap out external symbolic data. */
8796 _bfd_ecoff_swap_tir_out
,
8797 _bfd_ecoff_swap_rndx_out
,
8798 /* Function to read in symbolic data. */
8799 _bfd_mips_elf_read_ecoff_info
8802 #define TARGET_LITTLE_SYM bfd_elf32_littlemips_vec
8803 #define TARGET_LITTLE_NAME "elf32-littlemips"
8804 #define TARGET_BIG_SYM bfd_elf32_bigmips_vec
8805 #define TARGET_BIG_NAME "elf32-bigmips"
8806 #define ELF_ARCH bfd_arch_mips
8807 #define ELF_MACHINE_CODE EM_MIPS
8809 /* The SVR4 MIPS ABI says that this should be 0x10000, but Irix 5 uses
8810 a value of 0x1000, and we are compatible. */
8811 #define ELF_MAXPAGESIZE 0x1000
8813 #define elf_backend_collect true
8814 #define elf_backend_type_change_ok true
8815 #define elf_backend_can_gc_sections true
8816 #define elf_info_to_howto mips_info_to_howto_rela
8817 #define elf_info_to_howto_rel mips_info_to_howto_rel
8818 #define elf_backend_sym_is_global mips_elf_sym_is_global
8819 #define elf_backend_object_p _bfd_mips_elf_object_p
8820 #define elf_backend_section_from_shdr _bfd_mips_elf_section_from_shdr
8821 #define elf_backend_fake_sections _bfd_mips_elf_fake_sections
8822 #define elf_backend_section_from_bfd_section \
8823 _bfd_mips_elf_section_from_bfd_section
8824 #define elf_backend_section_processing _bfd_mips_elf_section_processing
8825 #define elf_backend_symbol_processing _bfd_mips_elf_symbol_processing
8826 #define elf_backend_additional_program_headers \
8827 _bfd_mips_elf_additional_program_headers
8828 #define elf_backend_modify_segment_map _bfd_mips_elf_modify_segment_map
8829 #define elf_backend_final_write_processing \
8830 _bfd_mips_elf_final_write_processing
8831 #define elf_backend_ecoff_debug_swap &mips_elf32_ecoff_debug_swap
8832 #define elf_backend_add_symbol_hook _bfd_mips_elf_add_symbol_hook
8833 #define elf_backend_create_dynamic_sections \
8834 _bfd_mips_elf_create_dynamic_sections
8835 #define elf_backend_check_relocs _bfd_mips_elf_check_relocs
8836 #define elf_backend_adjust_dynamic_symbol \
8837 _bfd_mips_elf_adjust_dynamic_symbol
8838 #define elf_backend_always_size_sections \
8839 _bfd_mips_elf_always_size_sections
8840 #define elf_backend_size_dynamic_sections \
8841 _bfd_mips_elf_size_dynamic_sections
8842 #define elf_backend_relocate_section _bfd_mips_elf_relocate_section
8843 #define elf_backend_link_output_symbol_hook \
8844 _bfd_mips_elf_link_output_symbol_hook
8845 #define elf_backend_finish_dynamic_symbol \
8846 _bfd_mips_elf_finish_dynamic_symbol
8847 #define elf_backend_finish_dynamic_sections \
8848 _bfd_mips_elf_finish_dynamic_sections
8849 #define elf_backend_gc_mark_hook _bfd_mips_elf_gc_mark_hook
8850 #define elf_backend_gc_sweep_hook _bfd_mips_elf_gc_sweep_hook
8852 #define elf_backend_got_header_size (4*MIPS_RESERVED_GOTNO)
8853 #define elf_backend_plt_header_size 0
8855 #define bfd_elf32_bfd_is_local_label_name \
8856 mips_elf_is_local_label_name
8857 #define bfd_elf32_find_nearest_line _bfd_mips_elf_find_nearest_line
8858 #define bfd_elf32_set_section_contents _bfd_mips_elf_set_section_contents
8859 #define bfd_elf32_bfd_link_hash_table_create \
8860 _bfd_mips_elf_link_hash_table_create
8861 #define bfd_elf32_bfd_final_link _bfd_mips_elf_final_link
8862 #define bfd_elf32_bfd_copy_private_bfd_data \
8863 _bfd_mips_elf_copy_private_bfd_data
8864 #define bfd_elf32_bfd_merge_private_bfd_data \
8865 _bfd_mips_elf_merge_private_bfd_data
8866 #define bfd_elf32_bfd_set_private_flags _bfd_mips_elf_set_private_flags
8867 #define bfd_elf32_bfd_print_private_bfd_data \
8868 _bfd_mips_elf_print_private_bfd_data
8869 #include "elf32-target.h"