1 /* MIPS-specific support for 32-bit ELF
2 Copyright 1993, 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
4 Most of the information added by Ian Lance Taylor, Cygnus Support,
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23 /* This file handles MIPS ELF targets. SGI Irix 5 uses a slightly
24 different MIPS ELF from other targets. This matters when linking.
25 This file supports both, switching at runtime. */
35 /* Get the ECOFF swapping routines. */
37 #include "coff/symconst.h"
38 #include "coff/internal.h"
39 #include "coff/ecoff.h"
40 #include "coff/mips.h"
42 #include "ecoffswap.h"
44 static bfd_reloc_status_type mips32_64bit_reloc
45 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
46 static reloc_howto_type
*bfd_elf32_bfd_reloc_type_lookup
47 PARAMS ((bfd
*, bfd_reloc_code_real_type
));
48 static void mips_info_to_howto_rel
49 PARAMS ((bfd
*, arelent
*, Elf32_Internal_Rel
*));
50 static void bfd_mips_elf32_swap_gptab_in
51 PARAMS ((bfd
*, const Elf32_External_gptab
*, Elf32_gptab
*));
52 static void bfd_mips_elf32_swap_gptab_out
53 PARAMS ((bfd
*, const Elf32_gptab
*, Elf32_External_gptab
*));
54 static boolean mips_elf_sym_is_global
PARAMS ((bfd
*, asymbol
*));
55 static boolean mips_elf32_object_p
PARAMS ((bfd
*));
56 static boolean mips_elf_create_procedure_table
57 PARAMS ((PTR
, bfd
*, struct bfd_link_info
*, asection
*,
58 struct ecoff_debug_info
*));
59 static int mips_elf_additional_program_headers
PARAMS ((bfd
*));
60 static boolean mips_elf_modify_segment_map
PARAMS ((bfd
*));
61 static INLINE
int elf_mips_isa
PARAMS ((flagword
));
62 static boolean mips_elf32_section_from_shdr
63 PARAMS ((bfd
*, Elf32_Internal_Shdr
*, char *));
64 static boolean mips_elf32_section_processing
65 PARAMS ((bfd
*, Elf32_Internal_Shdr
*));
66 static boolean mips_elf_is_local_label_name
67 PARAMS ((bfd
*, const char *));
68 static struct bfd_hash_entry
*mips_elf_link_hash_newfunc
69 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
70 static struct bfd_link_hash_table
*mips_elf_link_hash_table_create
72 static int gptab_compare
PARAMS ((const void *, const void *));
73 static boolean mips_elf_final_link
74 PARAMS ((bfd
*, struct bfd_link_info
*));
75 static void mips_elf_relocate_hi16
76 PARAMS ((bfd
*, Elf_Internal_Rela
*, Elf_Internal_Rela
*, bfd_byte
*,
78 static boolean mips_elf_relocate_got_local
79 PARAMS ((bfd
*, bfd
*, asection
*, Elf_Internal_Rela
*,
80 Elf_Internal_Rela
*, bfd_byte
*, bfd_vma
));
81 static void mips_elf_relocate_global_got
82 PARAMS ((bfd
*, Elf_Internal_Rela
*, bfd_byte
*, bfd_vma
));
83 static bfd_reloc_status_type mips16_jump_reloc
84 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
85 static bfd_reloc_status_type mips16_gprel_reloc
86 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
87 static boolean mips_elf_adjust_dynindx
88 PARAMS ((struct elf_link_hash_entry
*, PTR
));
89 static boolean mips_elf_relocate_section
90 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
91 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
92 static boolean mips_elf_link_output_symbol_hook
93 PARAMS ((bfd
*, struct bfd_link_info
*, const char *, Elf_Internal_Sym
*,
95 static boolean mips_elf_create_dynamic_sections
96 PARAMS ((bfd
*, struct bfd_link_info
*));
97 static boolean mips_elf_create_compact_rel_section
98 PARAMS ((bfd
*, struct bfd_link_info
*));
99 static boolean mips_elf_create_got_section
100 PARAMS ((bfd
*, struct bfd_link_info
*));
101 static boolean mips_elf_check_relocs
102 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
103 const Elf_Internal_Rela
*));
104 static boolean mips_elf_adjust_dynamic_symbol
105 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
106 static boolean mips_elf_always_size_sections
107 PARAMS ((bfd
*, struct bfd_link_info
*));
108 static boolean mips_elf_size_dynamic_sections
109 PARAMS ((bfd
*, struct bfd_link_info
*));
110 static boolean mips_elf_finish_dynamic_symbol
111 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
112 Elf_Internal_Sym
*));
113 static boolean mips_elf_finish_dynamic_sections
114 PARAMS ((bfd
*, struct bfd_link_info
*));
115 static boolean mips_elf_add_symbol_hook
116 PARAMS ((bfd
*, struct bfd_link_info
*, const Elf_Internal_Sym
*,
117 const char **, flagword
*, asection
**, bfd_vma
*));
118 static bfd_reloc_status_type mips_elf_final_gp
119 PARAMS ((bfd
*, asymbol
*, boolean
, char **, bfd_vma
*));
120 static bfd_byte
*elf32_mips_get_relocated_section_contents
121 PARAMS ((bfd
*, struct bfd_link_info
*, struct bfd_link_order
*,
122 bfd_byte
*, boolean
, asymbol
**));
124 /* This is true for Irix 5 executables, false for normal MIPS ELF ABI
125 executables. FIXME: At the moment, we default to always generating
126 Irix 5 executables. */
128 #define SGI_COMPAT(abfd) (1)
130 /* This structure is used to hold .got information when linking. It
131 is stored in the tdata field of the bfd_elf_section_data structure. */
135 /* The symbol index of the first global .got symbol. */
136 unsigned long global_gotsym
;
137 /* The number of local .got entries. */
138 unsigned int local_gotno
;
139 /* The number of local .got entries we have used. */
140 unsigned int assigned_gotno
;
143 /* The number of local .got entries we reserve. */
144 #define MIPS_RESERVED_GOTNO (2)
146 /* Instructions which appear in a stub. For some reason the stub is
147 slightly different on an SGI system. */
148 #define ELF_MIPS_GP_OFFSET(abfd) (SGI_COMPAT (abfd) ? 0x7ff0 : 0x8000)
149 #define STUB_LW(abfd) \
151 ? 0x8f998010 /* lw t9,0x8010(gp) */ \
152 : 0x8f998000) /* lw t9,0x8000(gp) */
153 #define STUB_MOVE 0x03e07825 /* move t7,ra */
154 #define STUB_JALR 0x0320f809 /* jal t9 */
155 #define STUB_LI16 0x34180000 /* ori t8,zero,0 */
156 #define MIPS_FUNCTION_STUB_SIZE (16)
158 /* Names of sections which appear in the .dynsym section in an Irix 5
161 static const char * const mips_elf_dynsym_sec_names
[] =
174 #define SIZEOF_MIPS_DYNSYM_SECNAMES \
175 (sizeof mips_elf_dynsym_sec_names / sizeof mips_elf_dynsym_sec_names[0])
177 /* The number of entries in mips_elf_dynsym_sec_names which go in the
180 #define MIPS_TEXT_DYNSYM_SECNO (3)
182 /* The names of the runtime procedure table symbols used on Irix 5. */
184 static const char * const mips_elf_dynsym_rtproc_names
[] =
187 "_procedure_string_table",
188 "_procedure_table_size",
192 /* These structures are used to generate the .compact_rel section on
197 unsigned long id1
; /* Always one? */
198 unsigned long num
; /* Number of compact relocation entries. */
199 unsigned long id2
; /* Always two? */
200 unsigned long offset
; /* The file offset of the first relocation. */
201 unsigned long reserved0
; /* Zero? */
202 unsigned long reserved1
; /* Zero? */
211 bfd_byte reserved0
[4];
212 bfd_byte reserved1
[4];
213 } Elf32_External_compact_rel
;
217 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
218 unsigned int rtype
: 4; /* Relocation types. See below. */
219 unsigned int dist2to
: 8;
220 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
221 unsigned long konst
; /* KONST field. See below. */
222 unsigned long vaddr
; /* VADDR to be relocated. */
227 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
228 unsigned int rtype
: 4; /* Relocation types. See below. */
229 unsigned int dist2to
: 8;
230 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
231 unsigned long konst
; /* KONST field. See below. */
239 } Elf32_External_crinfo
;
245 } Elf32_External_crinfo2
;
247 /* These are the constants used to swap the bitfields in a crinfo. */
249 #define CRINFO_CTYPE (0x1)
250 #define CRINFO_CTYPE_SH (31)
251 #define CRINFO_RTYPE (0xf)
252 #define CRINFO_RTYPE_SH (27)
253 #define CRINFO_DIST2TO (0xff)
254 #define CRINFO_DIST2TO_SH (19)
255 #define CRINFO_RELVADDR (0x7ffff)
256 #define CRINFO_RELVADDR_SH (0)
258 /* A compact relocation info has long (3 words) or short (2 words)
259 formats. A short format doesn't have VADDR field and relvaddr
260 fields contains ((VADDR - vaddr of the previous entry) >> 2). */
261 #define CRF_MIPS_LONG 1
262 #define CRF_MIPS_SHORT 0
264 /* There are 4 types of compact relocation at least. The value KONST
265 has different meaning for each type:
268 CT_MIPS_REL32 Address in data
269 CT_MIPS_WORD Address in word (XXX)
270 CT_MIPS_GPHI_LO GP - vaddr
271 CT_MIPS_JMPAD Address to jump
274 #define CRT_MIPS_REL32 0xa
275 #define CRT_MIPS_WORD 0xb
276 #define CRT_MIPS_GPHI_LO 0xc
277 #define CRT_MIPS_JMPAD 0xd
279 #define mips_elf_set_cr_format(x,format) ((x).ctype = (format))
280 #define mips_elf_set_cr_type(x,type) ((x).rtype = (type))
281 #define mips_elf_set_cr_dist2to(x,v) ((x).dist2to = (v))
282 #define mips_elf_set_cr_relvaddr(x,d) ((x).relvaddr = (d)<<2)
284 static void bfd_elf32_swap_compact_rel_out
285 PARAMS ((bfd
*, const Elf32_compact_rel
*, Elf32_External_compact_rel
*));
286 static void bfd_elf32_swap_crinfo_out
287 PARAMS ((bfd
*, const Elf32_crinfo
*, Elf32_External_crinfo
*));
289 #define USE_REL 1 /* MIPS uses REL relocations instead of RELA */
294 R_MIPS_16
, R_MIPS_32
,
295 R_MIPS_REL32
, R_MIPS_26
,
296 R_MIPS_HI16
, R_MIPS_LO16
,
297 R_MIPS_GPREL16
, R_MIPS_LITERAL
,
298 R_MIPS_GOT16
, R_MIPS_PC16
,
299 R_MIPS_CALL16
, R_MIPS_GPREL32
,
300 /* The remaining relocs are defined on Irix, although they are not
301 in the MIPS ELF ABI. */
302 R_MIPS_UNUSED1
, R_MIPS_UNUSED2
,
304 R_MIPS_SHIFT5
, R_MIPS_SHIFT6
,
305 R_MIPS_64
, R_MIPS_GOT_DISP
,
306 R_MIPS_GOT_PAGE
, R_MIPS_GOT_OFST
,
307 R_MIPS_GOT_HI16
, R_MIPS_GOT_LO16
,
308 R_MIPS_SUB
, R_MIPS_INSERT_A
,
309 R_MIPS_INSERT_B
, R_MIPS_DELETE
,
310 R_MIPS_HIGHER
, R_MIPS_HIGHEST
,
311 R_MIPS_CALL_HI16
, R_MIPS_CALL_LO16
,
313 /* These relocs are used for the mips16. */
318 static reloc_howto_type elf_mips_howto_table
[] =
321 HOWTO (R_MIPS_NONE
, /* type */
323 0, /* size (0 = byte, 1 = short, 2 = long) */
325 false, /* pc_relative */
327 complain_overflow_dont
, /* complain_on_overflow */
328 bfd_elf_generic_reloc
, /* special_function */
329 "R_MIPS_NONE", /* name */
330 false, /* partial_inplace */
333 false), /* pcrel_offset */
335 /* 16 bit relocation. */
336 HOWTO (R_MIPS_16
, /* type */
338 1, /* size (0 = byte, 1 = short, 2 = long) */
340 false, /* pc_relative */
342 complain_overflow_bitfield
, /* complain_on_overflow */
343 bfd_elf_generic_reloc
, /* special_function */
344 "R_MIPS_16", /* name */
345 true, /* partial_inplace */
346 0xffff, /* src_mask */
347 0xffff, /* dst_mask */
348 false), /* pcrel_offset */
350 /* 32 bit relocation. */
351 HOWTO (R_MIPS_32
, /* type */
353 2, /* size (0 = byte, 1 = short, 2 = long) */
355 false, /* pc_relative */
357 complain_overflow_bitfield
, /* complain_on_overflow */
358 bfd_elf_generic_reloc
, /* special_function */
359 "R_MIPS_32", /* name */
360 true, /* partial_inplace */
361 0xffffffff, /* src_mask */
362 0xffffffff, /* dst_mask */
363 false), /* pcrel_offset */
365 /* 32 bit symbol relative relocation. */
366 HOWTO (R_MIPS_REL32
, /* type */
368 2, /* size (0 = byte, 1 = short, 2 = long) */
370 false, /* pc_relative */
372 complain_overflow_bitfield
, /* complain_on_overflow */
373 bfd_elf_generic_reloc
, /* special_function */
374 "R_MIPS_REL32", /* name */
375 true, /* partial_inplace */
376 0xffffffff, /* src_mask */
377 0xffffffff, /* dst_mask */
378 false), /* pcrel_offset */
380 /* 26 bit branch address. */
381 HOWTO (R_MIPS_26
, /* type */
383 2, /* size (0 = byte, 1 = short, 2 = long) */
385 false, /* pc_relative */
387 complain_overflow_dont
, /* complain_on_overflow */
388 /* This needs complex overflow
389 detection, because the upper four
390 bits must match the PC. */
391 bfd_elf_generic_reloc
, /* special_function */
392 "R_MIPS_26", /* name */
393 true, /* partial_inplace */
394 0x3ffffff, /* src_mask */
395 0x3ffffff, /* dst_mask */
396 false), /* pcrel_offset */
398 /* High 16 bits of symbol value. */
399 HOWTO (R_MIPS_HI16
, /* type */
401 2, /* size (0 = byte, 1 = short, 2 = long) */
403 false, /* pc_relative */
405 complain_overflow_dont
, /* complain_on_overflow */
406 _bfd_mips_elf_hi16_reloc
, /* special_function */
407 "R_MIPS_HI16", /* name */
408 true, /* partial_inplace */
409 0xffff, /* src_mask */
410 0xffff, /* dst_mask */
411 false), /* pcrel_offset */
413 /* Low 16 bits of symbol value. */
414 HOWTO (R_MIPS_LO16
, /* type */
416 2, /* size (0 = byte, 1 = short, 2 = long) */
418 false, /* pc_relative */
420 complain_overflow_dont
, /* complain_on_overflow */
421 _bfd_mips_elf_lo16_reloc
, /* special_function */
422 "R_MIPS_LO16", /* name */
423 true, /* partial_inplace */
424 0xffff, /* src_mask */
425 0xffff, /* dst_mask */
426 false), /* pcrel_offset */
428 /* GP relative reference. */
429 HOWTO (R_MIPS_GPREL16
, /* type */
431 2, /* size (0 = byte, 1 = short, 2 = long) */
433 false, /* pc_relative */
435 complain_overflow_signed
, /* complain_on_overflow */
436 _bfd_mips_elf_gprel16_reloc
, /* special_function */
437 "R_MIPS_GPREL16", /* name */
438 true, /* partial_inplace */
439 0xffff, /* src_mask */
440 0xffff, /* dst_mask */
441 false), /* pcrel_offset */
443 /* Reference to literal section. */
444 HOWTO (R_MIPS_LITERAL
, /* type */
446 2, /* size (0 = byte, 1 = short, 2 = long) */
448 false, /* pc_relative */
450 complain_overflow_signed
, /* complain_on_overflow */
451 _bfd_mips_elf_gprel16_reloc
, /* special_function */
452 "R_MIPS_LITERAL", /* name */
453 true, /* partial_inplace */
454 0xffff, /* src_mask */
455 0xffff, /* dst_mask */
456 false), /* pcrel_offset */
458 /* Reference to global offset table. */
459 HOWTO (R_MIPS_GOT16
, /* type */
461 2, /* size (0 = byte, 1 = short, 2 = long) */
463 false, /* pc_relative */
465 complain_overflow_signed
, /* complain_on_overflow */
466 _bfd_mips_elf_got16_reloc
, /* special_function */
467 "R_MIPS_GOT16", /* name */
468 false, /* partial_inplace */
470 0xffff, /* dst_mask */
471 false), /* pcrel_offset */
473 /* 16 bit PC relative reference. */
474 HOWTO (R_MIPS_PC16
, /* type */
476 2, /* size (0 = byte, 1 = short, 2 = long) */
478 true, /* pc_relative */
480 complain_overflow_signed
, /* complain_on_overflow */
481 bfd_elf_generic_reloc
, /* special_function */
482 "R_MIPS_PC16", /* name */
483 true, /* partial_inplace */
484 0xffff, /* src_mask */
485 0xffff, /* dst_mask */
486 false), /* pcrel_offset */
488 /* 16 bit call through global offset table. */
489 /* FIXME: This is not handled correctly. */
490 HOWTO (R_MIPS_CALL16
, /* type */
492 2, /* size (0 = byte, 1 = short, 2 = long) */
494 false, /* pc_relative */
496 complain_overflow_signed
, /* complain_on_overflow */
497 bfd_elf_generic_reloc
, /* special_function */
498 "R_MIPS_CALL16", /* name */
499 false, /* partial_inplace */
501 0xffff, /* dst_mask */
502 false), /* pcrel_offset */
504 /* 32 bit GP relative reference. */
505 HOWTO (R_MIPS_GPREL32
, /* type */
507 2, /* size (0 = byte, 1 = short, 2 = long) */
509 false, /* pc_relative */
511 complain_overflow_bitfield
, /* complain_on_overflow */
512 _bfd_mips_elf_gprel32_reloc
, /* special_function */
513 "R_MIPS_GPREL32", /* name */
514 true, /* partial_inplace */
515 0xffffffff, /* src_mask */
516 0xffffffff, /* dst_mask */
517 false), /* pcrel_offset */
519 /* The remaining relocs are defined on Irix 5, although they are
520 not defined by the ABI. */
525 /* A 5 bit shift field. */
526 HOWTO (R_MIPS_SHIFT5
, /* type */
528 2, /* size (0 = byte, 1 = short, 2 = long) */
530 false, /* pc_relative */
532 complain_overflow_bitfield
, /* complain_on_overflow */
533 bfd_elf_generic_reloc
, /* special_function */
534 "R_MIPS_SHIFT5", /* name */
535 true, /* partial_inplace */
536 0x000007c0, /* src_mask */
537 0x000007c0, /* dst_mask */
538 false), /* pcrel_offset */
540 /* A 6 bit shift field. */
541 /* FIXME: This is not handled correctly; a special function is
542 needed to put the most significant bit in the right place. */
543 HOWTO (R_MIPS_SHIFT6
, /* type */
545 2, /* size (0 = byte, 1 = short, 2 = long) */
547 false, /* pc_relative */
549 complain_overflow_bitfield
, /* complain_on_overflow */
550 bfd_elf_generic_reloc
, /* special_function */
551 "R_MIPS_SHIFT6", /* name */
552 true, /* partial_inplace */
553 0x000007c4, /* src_mask */
554 0x000007c4, /* dst_mask */
555 false), /* pcrel_offset */
557 /* A 64 bit relocation. This is used in 32 bit ELF when addresses
558 are 64 bits long; the upper 32 bits are simply a sign extension.
559 The fields of the howto should be the same as for R_MIPS_32,
560 other than the type, name, and special_function. */
561 HOWTO (R_MIPS_64
, /* type */
563 2, /* size (0 = byte, 1 = short, 2 = long) */
565 false, /* pc_relative */
567 complain_overflow_bitfield
, /* complain_on_overflow */
568 mips32_64bit_reloc
, /* special_function */
569 "R_MIPS_64", /* name */
570 true, /* partial_inplace */
571 0xffffffff, /* src_mask */
572 0xffffffff, /* dst_mask */
573 false), /* pcrel_offset */
575 /* Displacement in the global offset table. */
576 /* FIXME: Not handled correctly. */
577 HOWTO (R_MIPS_GOT_DISP
, /* type */
579 2, /* size (0 = byte, 1 = short, 2 = long) */
581 false, /* pc_relative */
583 complain_overflow_bitfield
, /* complain_on_overflow */
584 bfd_elf_generic_reloc
, /* special_function */
585 "R_MIPS_GOT_DISP", /* name */
586 true, /* partial_inplace */
587 0x0000ffff, /* src_mask */
588 0x0000ffff, /* dst_mask */
589 false), /* pcrel_offset */
591 /* Displacement to page pointer in the global offset table. */
592 /* FIXME: Not handled correctly. */
593 HOWTO (R_MIPS_GOT_PAGE
, /* type */
595 2, /* size (0 = byte, 1 = short, 2 = long) */
597 false, /* pc_relative */
599 complain_overflow_bitfield
, /* complain_on_overflow */
600 bfd_elf_generic_reloc
, /* special_function */
601 "R_MIPS_GOT_PAGE", /* name */
602 true, /* partial_inplace */
603 0x0000ffff, /* src_mask */
604 0x0000ffff, /* dst_mask */
605 false), /* pcrel_offset */
607 /* Offset from page pointer in the global offset table. */
608 /* FIXME: Not handled correctly. */
609 HOWTO (R_MIPS_GOT_OFST
, /* type */
611 2, /* size (0 = byte, 1 = short, 2 = long) */
613 false, /* pc_relative */
615 complain_overflow_bitfield
, /* complain_on_overflow */
616 bfd_elf_generic_reloc
, /* special_function */
617 "R_MIPS_GOT_OFST", /* name */
618 true, /* partial_inplace */
619 0x0000ffff, /* src_mask */
620 0x0000ffff, /* dst_mask */
621 false), /* pcrel_offset */
623 /* High 16 bits of displacement in global offset table. */
624 /* FIXME: Not handled correctly. */
625 HOWTO (R_MIPS_GOT_HI16
, /* type */
627 2, /* size (0 = byte, 1 = short, 2 = long) */
629 false, /* pc_relative */
631 complain_overflow_dont
, /* complain_on_overflow */
632 bfd_elf_generic_reloc
, /* special_function */
633 "R_MIPS_GOT_HI16", /* name */
634 true, /* partial_inplace */
635 0x0000ffff, /* src_mask */
636 0x0000ffff, /* dst_mask */
637 false), /* pcrel_offset */
639 /* Low 16 bits of displacement in global offset table. */
640 /* FIXME: Not handled correctly. */
641 HOWTO (R_MIPS_GOT_LO16
, /* type */
643 2, /* size (0 = byte, 1 = short, 2 = long) */
645 false, /* pc_relative */
647 complain_overflow_dont
, /* complain_on_overflow */
648 bfd_elf_generic_reloc
, /* special_function */
649 "R_MIPS_GOT_LO16", /* name */
650 true, /* partial_inplace */
651 0x0000ffff, /* src_mask */
652 0x0000ffff, /* dst_mask */
653 false), /* pcrel_offset */
655 /* 64 bit subtraction. Presumably not used in 32 bit ELF. */
658 /* Used to cause the linker to insert and delete instructions? */
663 /* Get the higher values of a 64 bit addend. Presumably not used in
668 /* High 16 bits of displacement in global offset table. */
669 /* FIXME: Not handled correctly. */
670 HOWTO (R_MIPS_CALL_HI16
, /* type */
672 2, /* size (0 = byte, 1 = short, 2 = long) */
674 false, /* pc_relative */
676 complain_overflow_dont
, /* complain_on_overflow */
677 bfd_elf_generic_reloc
, /* special_function */
678 "R_MIPS_CALL_HI16", /* name */
679 true, /* partial_inplace */
680 0x0000ffff, /* src_mask */
681 0x0000ffff, /* dst_mask */
682 false), /* pcrel_offset */
684 /* Low 16 bits of displacement in global offset table. */
685 /* FIXME: Not handled correctly. */
686 HOWTO (R_MIPS_CALL_LO16
, /* type */
688 2, /* size (0 = byte, 1 = short, 2 = long) */
690 false, /* pc_relative */
692 complain_overflow_dont
, /* complain_on_overflow */
693 bfd_elf_generic_reloc
, /* special_function */
694 "R_MIPS_CALL_LO16", /* name */
695 true, /* partial_inplace */
696 0x0000ffff, /* src_mask */
697 0x0000ffff, /* dst_mask */
698 false) /* pcrel_offset */
701 /* The reloc used for the mips16 jump instruction. */
702 static reloc_howto_type elf_mips16_jump_howto
=
703 HOWTO (R_MIPS16_26
, /* type */
705 2, /* size (0 = byte, 1 = short, 2 = long) */
707 false, /* pc_relative */
709 complain_overflow_dont
, /* complain_on_overflow */
710 /* This needs complex overflow
711 detection, because the upper four
712 bits must match the PC. */
713 mips16_jump_reloc
, /* special_function */
714 "R_MIPS16_26", /* name */
715 true, /* partial_inplace */
716 0x3ffffff, /* src_mask */
717 0x3ffffff, /* dst_mask */
718 false); /* pcrel_offset */
720 /* The reloc used for the mips16 gprel instruction. The src_mask and
721 dsk_mask for this howto do not reflect the actual instruction, in
722 which the value is not contiguous; the masks are for the
723 convenience of the relocate_section routine. */
724 static reloc_howto_type elf_mips16_gprel_howto
=
725 HOWTO (R_MIPS16_GPREL
, /* type */
727 2, /* size (0 = byte, 1 = short, 2 = long) */
729 false, /* pc_relative */
731 complain_overflow_signed
, /* complain_on_overflow */
732 mips16_gprel_reloc
, /* special_function */
733 "R_MIPS16_GPREL", /* name */
734 true, /* partial_inplace */
735 0xffff, /* src_mask */
736 0xffff, /* dst_mask */
737 false); /* pcrel_offset */
739 /* Do a R_MIPS_HI16 relocation. This has to be done in combination
740 with a R_MIPS_LO16 reloc, because there is a carry from the LO16 to
741 the HI16. Here we just save the information we need; we do the
742 actual relocation when we see the LO16. MIPS ELF requires that the
743 LO16 immediately follow the HI16. As a GNU extension, we permit an
744 arbitrary number of HI16 relocs to be associated with a single LO16
745 reloc. This extension permits gcc to output the HI and LO relocs
750 struct mips_hi16
*next
;
755 /* FIXME: This should not be a static variable. */
757 static struct mips_hi16
*mips_hi16_list
;
759 bfd_reloc_status_type
760 _bfd_mips_elf_hi16_reloc (abfd
,
768 arelent
*reloc_entry
;
771 asection
*input_section
;
773 char **error_message
;
775 bfd_reloc_status_type ret
;
779 /* If we're relocating, and this an external symbol, we don't want
780 to change anything. */
781 if (output_bfd
!= (bfd
*) NULL
782 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
783 && reloc_entry
->addend
== 0)
785 reloc_entry
->address
+= input_section
->output_offset
;
791 if (strcmp (bfd_asymbol_name (symbol
), "_gp_disp") == 0)
793 boolean relocateable
;
796 if (ret
== bfd_reloc_undefined
)
799 if (output_bfd
!= NULL
)
803 relocateable
= false;
804 output_bfd
= symbol
->section
->output_section
->owner
;
807 ret
= mips_elf_final_gp (output_bfd
, symbol
, relocateable
,
809 if (ret
!= bfd_reloc_ok
)
812 relocation
= gp
- reloc_entry
->address
;
816 if (bfd_is_und_section (symbol
->section
)
817 && output_bfd
== (bfd
*) NULL
)
818 ret
= bfd_reloc_undefined
;
820 if (bfd_is_com_section (symbol
->section
))
823 relocation
= symbol
->value
;
826 relocation
+= symbol
->section
->output_section
->vma
;
827 relocation
+= symbol
->section
->output_offset
;
828 relocation
+= reloc_entry
->addend
;
830 if (reloc_entry
->address
> input_section
->_cooked_size
)
831 return bfd_reloc_outofrange
;
833 /* Save the information, and let LO16 do the actual relocation. */
834 n
= (struct mips_hi16
*) bfd_malloc (sizeof *n
);
836 return bfd_reloc_outofrange
;
837 n
->addr
= (bfd_byte
*) data
+ reloc_entry
->address
;
838 n
->addend
= relocation
;
839 n
->next
= mips_hi16_list
;
842 if (output_bfd
!= (bfd
*) NULL
)
843 reloc_entry
->address
+= input_section
->output_offset
;
848 /* Do a R_MIPS_LO16 relocation. This is a straightforward 16 bit
849 inplace relocation; this function exists in order to do the
850 R_MIPS_HI16 relocation described above. */
852 bfd_reloc_status_type
853 _bfd_mips_elf_lo16_reloc (abfd
,
861 arelent
*reloc_entry
;
864 asection
*input_section
;
866 char **error_message
;
868 arelent gp_disp_relent
;
870 if (mips_hi16_list
!= NULL
)
880 struct mips_hi16
*next
;
882 /* Do the HI16 relocation. Note that we actually don't need
883 to know anything about the LO16 itself, except where to
884 find the low 16 bits of the addend needed by the LO16. */
885 insn
= bfd_get_32 (abfd
, l
->addr
);
886 vallo
= (bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
)
888 val
= ((insn
& 0xffff) << 16) + vallo
;
891 /* The low order 16 bits are always treated as a signed
892 value. Therefore, a negative value in the low order bits
893 requires an adjustment in the high order bits. We need
894 to make this adjustment in two ways: once for the bits we
895 took from the data, and once for the bits we are putting
896 back in to the data. */
897 if ((vallo
& 0x8000) != 0)
899 if ((val
& 0x8000) != 0)
902 insn
= (insn
&~ 0xffff) | ((val
>> 16) & 0xffff);
903 bfd_put_32 (abfd
, insn
, l
->addr
);
905 if (strcmp (bfd_asymbol_name (symbol
), "_gp_disp") == 0)
907 gp_disp_relent
= *reloc_entry
;
908 reloc_entry
= &gp_disp_relent
;
909 reloc_entry
->addend
= l
->addend
;
917 mips_hi16_list
= NULL
;
919 else if (strcmp (bfd_asymbol_name (symbol
), "_gp_disp") == 0)
921 bfd_reloc_status_type ret
;
922 bfd_vma gp
, relocation
;
924 /* FIXME: Does this case ever occur? */
926 ret
= mips_elf_final_gp (output_bfd
, symbol
, true, error_message
, &gp
);
927 if (ret
!= bfd_reloc_ok
)
930 relocation
= gp
- reloc_entry
->address
;
931 relocation
+= symbol
->section
->output_section
->vma
;
932 relocation
+= symbol
->section
->output_offset
;
933 relocation
+= reloc_entry
->addend
;
935 if (reloc_entry
->address
> input_section
->_cooked_size
)
936 return bfd_reloc_outofrange
;
938 gp_disp_relent
= *reloc_entry
;
939 reloc_entry
= &gp_disp_relent
;
940 reloc_entry
->addend
= relocation
- 4;
943 /* Now do the LO16 reloc in the usual way. */
944 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
945 input_section
, output_bfd
, error_message
);
948 /* Do a R_MIPS_GOT16 reloc. This is a reloc against the global offset
949 table used for PIC code. If the symbol is an external symbol, the
950 instruction is modified to contain the offset of the appropriate
951 entry in the global offset table. If the symbol is a section
952 symbol, the next reloc is a R_MIPS_LO16 reloc. The two 16 bit
953 addends are combined to form the real addend against the section
954 symbol; the GOT16 is modified to contain the offset of an entry in
955 the global offset table, and the LO16 is modified to offset it
956 appropriately. Thus an offset larger than 16 bits requires a
957 modified value in the global offset table.
959 This implementation suffices for the assembler, but the linker does
960 not yet know how to create global offset tables. */
962 bfd_reloc_status_type
963 _bfd_mips_elf_got16_reloc (abfd
,
971 arelent
*reloc_entry
;
974 asection
*input_section
;
976 char **error_message
;
978 /* If we're relocating, and this an external symbol, we don't want
979 to change anything. */
980 if (output_bfd
!= (bfd
*) NULL
981 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
982 && reloc_entry
->addend
== 0)
984 reloc_entry
->address
+= input_section
->output_offset
;
988 /* If we're relocating, and this is a local symbol, we can handle it
990 if (output_bfd
!= (bfd
*) NULL
991 && (symbol
->flags
& BSF_SECTION_SYM
) != 0)
992 return _bfd_mips_elf_hi16_reloc (abfd
, reloc_entry
, symbol
, data
,
993 input_section
, output_bfd
, error_message
);
998 /* We have to figure out the gp value, so that we can adjust the
999 symbol value correctly. We look up the symbol _gp in the output
1000 BFD. If we can't find it, we're stuck. We cache it in the ELF
1001 target data. We don't need to adjust the symbol value for an
1002 external symbol if we are producing relocateable output. */
1004 static bfd_reloc_status_type
1005 mips_elf_final_gp (output_bfd
, symbol
, relocateable
, error_message
, pgp
)
1008 boolean relocateable
;
1009 char **error_message
;
1012 if (bfd_is_und_section (symbol
->section
)
1016 return bfd_reloc_undefined
;
1019 *pgp
= _bfd_get_gp_value (output_bfd
);
1022 || (symbol
->flags
& BSF_SECTION_SYM
) != 0))
1026 /* Make up a value. */
1027 *pgp
= symbol
->section
->output_section
->vma
+ 0x4000;
1028 _bfd_set_gp_value (output_bfd
, *pgp
);
1036 count
= bfd_get_symcount (output_bfd
);
1037 sym
= bfd_get_outsymbols (output_bfd
);
1039 if (sym
== (asymbol
**) NULL
)
1043 for (i
= 0; i
< count
; i
++, sym
++)
1045 register CONST
char *name
;
1047 name
= bfd_asymbol_name (*sym
);
1048 if (*name
== '_' && strcmp (name
, "_gp") == 0)
1050 *pgp
= bfd_asymbol_value (*sym
);
1051 _bfd_set_gp_value (output_bfd
, *pgp
);
1059 /* Only get the error once. */
1061 _bfd_set_gp_value (output_bfd
, *pgp
);
1063 (char *) "GP relative relocation when _gp not defined";
1064 return bfd_reloc_dangerous
;
1069 return bfd_reloc_ok
;
1072 /* Do a R_MIPS_GPREL16 relocation. This is a 16 bit value which must
1073 become the offset from the gp register. This function also handles
1074 R_MIPS_LITERAL relocations, although those can be handled more
1075 cleverly because the entries in the .lit8 and .lit4 sections can be
1078 static bfd_reloc_status_type gprel16_with_gp
PARAMS ((bfd
*, asymbol
*,
1079 arelent
*, asection
*,
1080 boolean
, PTR
, bfd_vma
));
1082 bfd_reloc_status_type
1083 _bfd_mips_elf_gprel16_reloc (abfd
, reloc_entry
, symbol
, data
, input_section
,
1084 output_bfd
, error_message
)
1086 arelent
*reloc_entry
;
1089 asection
*input_section
;
1091 char **error_message
;
1093 boolean relocateable
;
1094 bfd_reloc_status_type ret
;
1097 /* If we're relocating, and this is an external symbol with no
1098 addend, we don't want to change anything. We will only have an
1099 addend if this is a newly created reloc, not read from an ELF
1101 if (output_bfd
!= (bfd
*) NULL
1102 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1103 && reloc_entry
->addend
== 0)
1105 reloc_entry
->address
+= input_section
->output_offset
;
1106 return bfd_reloc_ok
;
1109 if (output_bfd
!= (bfd
*) NULL
)
1110 relocateable
= true;
1113 relocateable
= false;
1114 output_bfd
= symbol
->section
->output_section
->owner
;
1117 ret
= mips_elf_final_gp (output_bfd
, symbol
, relocateable
, error_message
,
1119 if (ret
!= bfd_reloc_ok
)
1122 return gprel16_with_gp (abfd
, symbol
, reloc_entry
, input_section
,
1123 relocateable
, data
, gp
);
1126 static bfd_reloc_status_type
1127 gprel16_with_gp (abfd
, symbol
, reloc_entry
, input_section
, relocateable
, data
,
1131 arelent
*reloc_entry
;
1132 asection
*input_section
;
1133 boolean relocateable
;
1141 if (bfd_is_com_section (symbol
->section
))
1144 relocation
= symbol
->value
;
1146 relocation
+= symbol
->section
->output_section
->vma
;
1147 relocation
+= symbol
->section
->output_offset
;
1149 if (reloc_entry
->address
> input_section
->_cooked_size
)
1150 return bfd_reloc_outofrange
;
1152 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1154 /* Set val to the offset into the section or symbol. */
1155 if (reloc_entry
->howto
->src_mask
== 0)
1157 /* This case occurs with the 64-bit MIPS ELF ABI. */
1158 val
= reloc_entry
->addend
;
1162 val
= ((insn
& 0xffff) + reloc_entry
->addend
) & 0xffff;
1167 /* Adjust val for the final section location and GP value. If we
1168 are producing relocateable output, we don't want to do this for
1169 an external symbol. */
1171 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1172 val
+= relocation
- gp
;
1174 insn
= (insn
&~ 0xffff) | (val
& 0xffff);
1175 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
);
1178 reloc_entry
->address
+= input_section
->output_offset
;
1180 /* Make sure it fit in 16 bits. */
1181 if (val
>= 0x8000 && val
< 0xffff8000)
1182 return bfd_reloc_overflow
;
1184 return bfd_reloc_ok
;
1187 /* Do a R_MIPS_GPREL32 relocation. Is this 32 bit value the offset
1188 from the gp register? XXX */
1190 static bfd_reloc_status_type gprel32_with_gp
PARAMS ((bfd
*, asymbol
*,
1191 arelent
*, asection
*,
1192 boolean
, PTR
, bfd_vma
));
1194 bfd_reloc_status_type
1195 _bfd_mips_elf_gprel32_reloc (abfd
,
1203 arelent
*reloc_entry
;
1206 asection
*input_section
;
1208 char **error_message
;
1210 boolean relocateable
;
1211 bfd_reloc_status_type ret
;
1214 /* If we're relocating, and this is an external symbol with no
1215 addend, we don't want to change anything. We will only have an
1216 addend if this is a newly created reloc, not read from an ELF
1218 if (output_bfd
!= (bfd
*) NULL
1219 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1220 && reloc_entry
->addend
== 0)
1222 *error_message
= (char *)
1223 "32bits gp relative relocation occurs for an external symbol";
1224 return bfd_reloc_outofrange
;
1227 if (output_bfd
!= (bfd
*) NULL
)
1229 relocateable
= true;
1230 gp
= _bfd_get_gp_value (output_bfd
);
1234 relocateable
= false;
1235 output_bfd
= symbol
->section
->output_section
->owner
;
1237 ret
= mips_elf_final_gp (output_bfd
, symbol
, relocateable
,
1238 error_message
, &gp
);
1239 if (ret
!= bfd_reloc_ok
)
1243 return gprel32_with_gp (abfd
, symbol
, reloc_entry
, input_section
,
1244 relocateable
, data
, gp
);
1247 static bfd_reloc_status_type
1248 gprel32_with_gp (abfd
, symbol
, reloc_entry
, input_section
, relocateable
, data
,
1252 arelent
*reloc_entry
;
1253 asection
*input_section
;
1254 boolean relocateable
;
1261 if (bfd_is_com_section (symbol
->section
))
1264 relocation
= symbol
->value
;
1266 relocation
+= symbol
->section
->output_section
->vma
;
1267 relocation
+= symbol
->section
->output_offset
;
1269 if (reloc_entry
->address
> input_section
->_cooked_size
)
1270 return bfd_reloc_outofrange
;
1272 if (reloc_entry
->howto
->src_mask
== 0)
1274 /* This case arises with the 64-bit MIPS ELF ABI. */
1278 val
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1280 /* Set val to the offset into the section or symbol. */
1281 val
+= reloc_entry
->addend
;
1283 /* Adjust val for the final section location and GP value. If we
1284 are producing relocateable output, we don't want to do this for
1285 an external symbol. */
1287 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1288 val
+= relocation
- gp
;
1290 bfd_put_32 (abfd
, val
, (bfd_byte
*) data
+ reloc_entry
->address
);
1293 reloc_entry
->address
+= input_section
->output_offset
;
1295 return bfd_reloc_ok
;
1298 /* Handle a 64 bit reloc in a 32 bit MIPS ELF file. These are
1299 generated when addreses are 64 bits. The upper 32 bits are a simle
1302 static bfd_reloc_status_type
1303 mips32_64bit_reloc (abfd
, reloc_entry
, symbol
, data
, input_section
,
1304 output_bfd
, error_message
)
1306 arelent
*reloc_entry
;
1309 asection
*input_section
;
1311 char **error_message
;
1313 bfd_reloc_status_type r
;
1318 r
= bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1319 input_section
, output_bfd
, error_message
);
1320 if (r
!= bfd_reloc_continue
)
1323 /* Do a normal 32 bit relocation on the lower 32 bits. */
1324 reloc32
= *reloc_entry
;
1325 if (bfd_big_endian (abfd
))
1326 reloc32
.address
+= 4;
1327 reloc32
.howto
= &elf_mips_howto_table
[R_MIPS_32
];
1328 r
= bfd_perform_relocation (abfd
, &reloc32
, data
, input_section
,
1329 output_bfd
, error_message
);
1331 /* Sign extend into the upper 32 bits. */
1332 val
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc32
.address
);
1333 if ((val
& 0x80000000) != 0)
1337 addr
= reloc_entry
->address
;
1338 if (bfd_little_endian (abfd
))
1340 bfd_put_32 (abfd
, val
, (bfd_byte
*) data
+ addr
);
1345 /* Handle a mips16 jump. */
1347 static bfd_reloc_status_type
1348 mips16_jump_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 if (output_bfd
!= (bfd
*) NULL
1359 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1360 && reloc_entry
->addend
== 0)
1362 reloc_entry
->address
+= input_section
->output_offset
;
1363 return bfd_reloc_ok
;
1370 /* Handle a mips16 GP relative reloc. */
1372 static bfd_reloc_status_type
1373 mips16_gprel_reloc (abfd
, reloc_entry
, symbol
, data
, input_section
,
1374 output_bfd
, error_message
)
1376 arelent
*reloc_entry
;
1379 asection
*input_section
;
1381 char **error_message
;
1383 boolean relocateable
;
1384 bfd_reloc_status_type ret
;
1386 unsigned short extend
, insn
;
1387 unsigned long final
;
1389 /* If we're relocating, and this is an external symbol with no
1390 addend, we don't want to change anything. We will only have an
1391 addend if this is a newly created reloc, not read from an ELF
1393 if (output_bfd
!= NULL
1394 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1395 && reloc_entry
->addend
== 0)
1397 reloc_entry
->address
+= input_section
->output_offset
;
1398 return bfd_reloc_ok
;
1401 if (output_bfd
!= NULL
)
1402 relocateable
= true;
1405 relocateable
= false;
1406 output_bfd
= symbol
->section
->output_section
->owner
;
1409 ret
= mips_elf_final_gp (output_bfd
, symbol
, relocateable
, error_message
,
1411 if (ret
!= bfd_reloc_ok
)
1414 if (reloc_entry
->address
> input_section
->_cooked_size
)
1415 return bfd_reloc_outofrange
;
1417 /* Pick up the mips16 extend instruction and the real instruction. */
1418 extend
= bfd_get_16 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1419 insn
= bfd_get_16 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
+ 2);
1421 /* Stuff the current addend back as a 32 bit value, do the usual
1422 relocation, and then clean up. */
1424 (((extend
& 0x1f) << 11)
1427 (bfd_byte
*) data
+ reloc_entry
->address
);
1429 ret
= gprel16_with_gp (abfd
, symbol
, reloc_entry
, input_section
,
1430 relocateable
, data
, gp
);
1432 final
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1435 | ((final
>> 11) & 0x1f)
1437 (bfd_byte
*) data
+ reloc_entry
->address
);
1441 (bfd_byte
*) data
+ reloc_entry
->address
+ 2);
1446 /* A mapping from BFD reloc types to MIPS ELF reloc types. */
1448 struct elf_reloc_map
{
1449 bfd_reloc_code_real_type bfd_reloc_val
;
1450 enum reloc_type elf_reloc_val
;
1453 static CONST
struct elf_reloc_map mips_reloc_map
[] =
1455 { BFD_RELOC_NONE
, R_MIPS_NONE
, },
1456 { BFD_RELOC_16
, R_MIPS_16
},
1457 { BFD_RELOC_32
, R_MIPS_32
},
1458 { BFD_RELOC_CTOR
, R_MIPS_32
},
1459 { BFD_RELOC_64
, R_MIPS_64
},
1460 { BFD_RELOC_MIPS_JMP
, R_MIPS_26
},
1461 { BFD_RELOC_HI16_S
, R_MIPS_HI16
},
1462 { BFD_RELOC_LO16
, R_MIPS_LO16
},
1463 { BFD_RELOC_MIPS_GPREL
, R_MIPS_GPREL16
},
1464 { BFD_RELOC_MIPS_LITERAL
, R_MIPS_LITERAL
},
1465 { BFD_RELOC_MIPS_GOT16
, R_MIPS_GOT16
},
1466 { BFD_RELOC_16_PCREL
, R_MIPS_PC16
},
1467 { BFD_RELOC_MIPS_CALL16
, R_MIPS_CALL16
},
1468 { BFD_RELOC_MIPS_GPREL32
, R_MIPS_GPREL32
},
1469 { BFD_RELOC_MIPS_GOT_HI16
, R_MIPS_GOT_HI16
},
1470 { BFD_RELOC_MIPS_GOT_LO16
, R_MIPS_GOT_LO16
},
1471 { BFD_RELOC_MIPS_CALL_HI16
, R_MIPS_CALL_HI16
},
1472 { BFD_RELOC_MIPS_CALL_LO16
, R_MIPS_CALL_LO16
}
1475 /* Given a BFD reloc type, return a howto structure. */
1477 static reloc_howto_type
*
1478 bfd_elf32_bfd_reloc_type_lookup (abfd
, code
)
1480 bfd_reloc_code_real_type code
;
1484 for (i
= 0; i
< sizeof (mips_reloc_map
) / sizeof (struct elf_reloc_map
); i
++)
1486 if (mips_reloc_map
[i
].bfd_reloc_val
== code
)
1487 return &elf_mips_howto_table
[(int) mips_reloc_map
[i
].elf_reloc_val
];
1490 /* Special handling for the MIPS16 relocs, since they are made up
1491 reloc types with a large value. */
1492 if (code
== BFD_RELOC_MIPS16_JMP
)
1493 return &elf_mips16_jump_howto
;
1494 else if (code
== BFD_RELOC_MIPS16_GPREL
)
1495 return &elf_mips16_gprel_howto
;
1500 /* Given a MIPS reloc type, fill in an arelent structure. */
1503 mips_info_to_howto_rel (abfd
, cache_ptr
, dst
)
1506 Elf32_Internal_Rel
*dst
;
1508 unsigned int r_type
;
1510 r_type
= ELF32_R_TYPE (dst
->r_info
);
1511 if (r_type
== R_MIPS16_26
)
1512 cache_ptr
->howto
= &elf_mips16_jump_howto
;
1513 else if (r_type
== R_MIPS16_GPREL
)
1514 cache_ptr
->howto
= &elf_mips16_gprel_howto
;
1517 BFD_ASSERT (r_type
< (unsigned int) R_MIPS_max
);
1518 cache_ptr
->howto
= &elf_mips_howto_table
[r_type
];
1521 /* The addend for a GPREL16 or LITERAL relocation comes from the GP
1522 value for the object file. We get the addend now, rather than
1523 when we do the relocation, because the symbol manipulations done
1524 by the linker may cause us to lose track of the input BFD. */
1525 if (((*cache_ptr
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) != 0
1526 && (r_type
== (unsigned int) R_MIPS_GPREL16
1527 || r_type
== (unsigned int) R_MIPS_LITERAL
))
1528 cache_ptr
->addend
= elf_gp (abfd
);
1531 /* A .reginfo section holds a single Elf32_RegInfo structure. These
1532 routines swap this structure in and out. They are used outside of
1533 BFD, so they are globally visible. */
1536 bfd_mips_elf32_swap_reginfo_in (abfd
, ex
, in
)
1538 const Elf32_External_RegInfo
*ex
;
1541 in
->ri_gprmask
= bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_gprmask
);
1542 in
->ri_cprmask
[0] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[0]);
1543 in
->ri_cprmask
[1] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[1]);
1544 in
->ri_cprmask
[2] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[2]);
1545 in
->ri_cprmask
[3] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[3]);
1546 in
->ri_gp_value
= bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_gp_value
);
1550 bfd_mips_elf32_swap_reginfo_out (abfd
, in
, ex
)
1552 const Elf32_RegInfo
*in
;
1553 Elf32_External_RegInfo
*ex
;
1555 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_gprmask
,
1556 (bfd_byte
*) ex
->ri_gprmask
);
1557 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[0],
1558 (bfd_byte
*) ex
->ri_cprmask
[0]);
1559 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[1],
1560 (bfd_byte
*) ex
->ri_cprmask
[1]);
1561 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[2],
1562 (bfd_byte
*) ex
->ri_cprmask
[2]);
1563 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[3],
1564 (bfd_byte
*) ex
->ri_cprmask
[3]);
1565 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_gp_value
,
1566 (bfd_byte
*) ex
->ri_gp_value
);
1569 /* In the 64 bit ABI, the .MIPS.options section holds register
1570 information in an Elf64_Reginfo structure. These routines swap
1571 them in and out. They are globally visible because they are used
1572 outside of BFD. These routines are here so that gas can call them
1573 without worrying about whether the 64 bit ABI has been included. */
1576 bfd_mips_elf64_swap_reginfo_in (abfd
, ex
, in
)
1578 const Elf64_External_RegInfo
*ex
;
1579 Elf64_Internal_RegInfo
*in
;
1581 in
->ri_gprmask
= bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_gprmask
);
1582 in
->ri_pad
= bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_pad
);
1583 in
->ri_cprmask
[0] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[0]);
1584 in
->ri_cprmask
[1] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[1]);
1585 in
->ri_cprmask
[2] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[2]);
1586 in
->ri_cprmask
[3] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[3]);
1587 in
->ri_gp_value
= bfd_h_get_64 (abfd
, (bfd_byte
*) ex
->ri_gp_value
);
1591 bfd_mips_elf64_swap_reginfo_out (abfd
, in
, ex
)
1593 const Elf64_Internal_RegInfo
*in
;
1594 Elf64_External_RegInfo
*ex
;
1596 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_gprmask
,
1597 (bfd_byte
*) ex
->ri_gprmask
);
1598 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_pad
,
1599 (bfd_byte
*) ex
->ri_pad
);
1600 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[0],
1601 (bfd_byte
*) ex
->ri_cprmask
[0]);
1602 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[1],
1603 (bfd_byte
*) ex
->ri_cprmask
[1]);
1604 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[2],
1605 (bfd_byte
*) ex
->ri_cprmask
[2]);
1606 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[3],
1607 (bfd_byte
*) ex
->ri_cprmask
[3]);
1608 bfd_h_put_64 (abfd
, (bfd_vma
) in
->ri_gp_value
,
1609 (bfd_byte
*) ex
->ri_gp_value
);
1612 /* Swap an entry in a .gptab section. Note that these routines rely
1613 on the equivalence of the two elements of the union. */
1616 bfd_mips_elf32_swap_gptab_in (abfd
, ex
, in
)
1618 const Elf32_External_gptab
*ex
;
1621 in
->gt_entry
.gt_g_value
= bfd_h_get_32 (abfd
, ex
->gt_entry
.gt_g_value
);
1622 in
->gt_entry
.gt_bytes
= bfd_h_get_32 (abfd
, ex
->gt_entry
.gt_bytes
);
1626 bfd_mips_elf32_swap_gptab_out (abfd
, in
, ex
)
1628 const Elf32_gptab
*in
;
1629 Elf32_External_gptab
*ex
;
1631 bfd_h_put_32 (abfd
, (bfd_vma
) in
->gt_entry
.gt_g_value
,
1632 ex
->gt_entry
.gt_g_value
);
1633 bfd_h_put_32 (abfd
, (bfd_vma
) in
->gt_entry
.gt_bytes
,
1634 ex
->gt_entry
.gt_bytes
);
1638 bfd_elf32_swap_compact_rel_out (abfd
, in
, ex
)
1640 const Elf32_compact_rel
*in
;
1641 Elf32_External_compact_rel
*ex
;
1643 bfd_h_put_32 (abfd
, (bfd_vma
) in
->id1
, ex
->id1
);
1644 bfd_h_put_32 (abfd
, (bfd_vma
) in
->num
, ex
->num
);
1645 bfd_h_put_32 (abfd
, (bfd_vma
) in
->id2
, ex
->id2
);
1646 bfd_h_put_32 (abfd
, (bfd_vma
) in
->offset
, ex
->offset
);
1647 bfd_h_put_32 (abfd
, (bfd_vma
) in
->reserved0
, ex
->reserved0
);
1648 bfd_h_put_32 (abfd
, (bfd_vma
) in
->reserved1
, ex
->reserved1
);
1652 bfd_elf32_swap_crinfo_out (abfd
, in
, ex
)
1654 const Elf32_crinfo
*in
;
1655 Elf32_External_crinfo
*ex
;
1659 l
= (((in
->ctype
& CRINFO_CTYPE
) << CRINFO_CTYPE_SH
)
1660 | ((in
->rtype
& CRINFO_RTYPE
) << CRINFO_RTYPE_SH
)
1661 | ((in
->dist2to
& CRINFO_DIST2TO
) << CRINFO_DIST2TO_SH
)
1662 | ((in
->relvaddr
& CRINFO_RELVADDR
) << CRINFO_RELVADDR_SH
));
1663 bfd_h_put_32 (abfd
, (bfd_vma
) l
, ex
->info
);
1664 bfd_h_put_32 (abfd
, (bfd_vma
) in
->konst
, ex
->konst
);
1665 bfd_h_put_32 (abfd
, (bfd_vma
) in
->vaddr
, ex
->vaddr
);
1668 /* Swap in an options header. */
1671 bfd_mips_elf_swap_options_in (abfd
, ex
, in
)
1673 const Elf_External_Options
*ex
;
1674 Elf_Internal_Options
*in
;
1676 in
->kind
= bfd_h_get_8 (abfd
, ex
->kind
);
1677 in
->size
= bfd_h_get_8 (abfd
, ex
->size
);
1678 in
->section
= bfd_h_get_16 (abfd
, ex
->section
);
1679 in
->info
= bfd_h_get_32 (abfd
, ex
->info
);
1682 /* Swap out an options header. */
1685 bfd_mips_elf_swap_options_out (abfd
, in
, ex
)
1687 const Elf_Internal_Options
*in
;
1688 Elf_External_Options
*ex
;
1690 bfd_h_put_8 (abfd
, in
->kind
, ex
->kind
);
1691 bfd_h_put_8 (abfd
, in
->size
, ex
->size
);
1692 bfd_h_put_16 (abfd
, in
->section
, ex
->section
);
1693 bfd_h_put_32 (abfd
, in
->info
, ex
->info
);
1696 /* Determine whether a symbol is global for the purposes of splitting
1697 the symbol table into global symbols and local symbols. At least
1698 on Irix 5, this split must be between section symbols and all other
1699 symbols. On most ELF targets the split is between static symbols
1700 and externally visible symbols. */
1704 mips_elf_sym_is_global (abfd
, sym
)
1708 return (sym
->flags
& BSF_SECTION_SYM
) == 0 ? true : false;
1711 /* Set the right machine number for a MIPS ELF file. This is used for
1712 both the 32-bit and the 64-bit ABI. */
1715 _bfd_mips_elf_object_p (abfd
)
1718 switch (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
)
1722 (void) bfd_default_set_arch_mach (abfd
, bfd_arch_mips
, 3000);
1726 (void) bfd_default_set_arch_mach (abfd
, bfd_arch_mips
, 6000);
1730 (void) bfd_default_set_arch_mach (abfd
, bfd_arch_mips
, 4000);
1734 (void) bfd_default_set_arch_mach (abfd
, bfd_arch_mips
, 8000);
1741 /* Set the right machine number for a 32-bit MIPS ELF file. */
1744 mips_elf32_object_p (abfd
)
1747 /* Irix 5 is broken. Object file symbol tables are not always
1748 sorted correctly such that local symbols precede global symbols,
1749 and the sh_info field in the symbol table is not always right. */
1750 elf_bad_symtab (abfd
) = true;
1752 return _bfd_mips_elf_object_p (abfd
);
1755 /* The final processing done just before writing out a MIPS ELF object
1756 file. This gets the MIPS architecture right based on the machine
1757 number. This is used by both the 32-bit and the 64-bit ABI. */
1761 _bfd_mips_elf_final_write_processing (abfd
, linker
)
1767 Elf_Internal_Shdr
**hdrpp
;
1771 switch (bfd_get_mach (abfd
))
1774 val
= E_MIPS_ARCH_1
;
1778 val
= E_MIPS_ARCH_2
;
1782 val
= E_MIPS_ARCH_3
;
1786 val
= E_MIPS_ARCH_4
;
1794 elf_elfheader (abfd
)->e_flags
&=~ EF_MIPS_ARCH
;
1795 elf_elfheader (abfd
)->e_flags
|= val
;
1797 /* Set the sh_info field for .gptab sections. */
1798 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
1799 i
< elf_elfheader (abfd
)->e_shnum
;
1802 switch ((*hdrpp
)->sh_type
)
1804 case SHT_MIPS_LIBLIST
:
1805 sec
= bfd_get_section_by_name (abfd
, ".dynstr");
1807 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
1810 case SHT_MIPS_GPTAB
:
1811 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
1812 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
1813 BFD_ASSERT (name
!= NULL
1814 && strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0);
1815 sec
= bfd_get_section_by_name (abfd
, name
+ sizeof ".gptab" - 1);
1816 BFD_ASSERT (sec
!= NULL
);
1817 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
1820 case SHT_MIPS_CONTENT
:
1821 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
1822 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
1823 BFD_ASSERT (name
!= NULL
1824 && strncmp (name
, ".MIPS.content",
1825 sizeof ".MIPS.content" - 1) == 0);
1826 sec
= bfd_get_section_by_name (abfd
,
1827 name
+ sizeof ".MIPS.content" - 1);
1828 BFD_ASSERT (sec
!= NULL
);
1829 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
1832 case SHT_MIPS_SYMBOL_LIB
:
1833 sec
= bfd_get_section_by_name (abfd
, ".dynsym");
1835 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
1836 sec
= bfd_get_section_by_name (abfd
, ".liblist");
1838 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
1841 case SHT_MIPS_EVENTS
:
1842 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
1843 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
1844 BFD_ASSERT (name
!= NULL
);
1845 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0)
1846 sec
= bfd_get_section_by_name (abfd
,
1847 name
+ sizeof ".MIPS.events" - 1);
1850 BFD_ASSERT (strncmp (name
, ".MIPS.post_rel",
1851 sizeof ".MIPS.post_rel" - 1) == 0);
1852 sec
= bfd_get_section_by_name (abfd
,
1854 + sizeof ".MIPS.post_rel" - 1));
1856 BFD_ASSERT (sec
!= NULL
);
1857 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
1863 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
1866 _bfd_mips_elf_set_private_flags (abfd
, flags
)
1870 BFD_ASSERT (!elf_flags_init (abfd
)
1871 || elf_elfheader (abfd
)->e_flags
== flags
);
1873 elf_elfheader (abfd
)->e_flags
= flags
;
1874 elf_flags_init (abfd
) = true;
1878 /* Copy backend specific data from one object module to another */
1881 _bfd_mips_elf_copy_private_bfd_data (ibfd
, obfd
)
1885 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1886 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1889 BFD_ASSERT (!elf_flags_init (obfd
)
1890 || (elf_elfheader (obfd
)->e_flags
1891 == elf_elfheader (ibfd
)->e_flags
));
1893 elf_gp (obfd
) = elf_gp (ibfd
);
1894 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
1895 elf_flags_init (obfd
) = true;
1899 /* Return the ISA for a MIPS e_flags value. */
1902 elf_mips_isa (flags
)
1905 switch (flags
& EF_MIPS_ARCH
)
1919 /* Merge backend specific data from an object file to the output
1920 object file when linking. */
1923 _bfd_mips_elf_merge_private_bfd_data (ibfd
, obfd
)
1931 /* Check if we have the same endianess */
1932 if (ibfd
->xvec
->byteorder
!= obfd
->xvec
->byteorder
1933 && obfd
->xvec
->byteorder
!= BFD_ENDIAN_UNKNOWN
)
1935 (*_bfd_error_handler
)
1936 ("%s: compiled for a %s endian system and target is %s endian",
1937 bfd_get_filename (ibfd
),
1938 bfd_big_endian (ibfd
) ? "big" : "little",
1939 bfd_big_endian (obfd
) ? "big" : "little");
1941 bfd_set_error (bfd_error_wrong_format
);
1945 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1946 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1949 new_flags
= elf_elfheader (ibfd
)->e_flags
;
1950 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_NOREORDER
;
1951 old_flags
= elf_elfheader (obfd
)->e_flags
;
1953 if (! elf_flags_init (obfd
))
1955 elf_flags_init (obfd
) = true;
1956 elf_elfheader (obfd
)->e_flags
= new_flags
;
1958 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
1959 && bfd_get_arch_info (obfd
)->the_default
)
1961 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
1962 bfd_get_mach (ibfd
)))
1969 /* Check flag compatibility. */
1971 new_flags
&= ~EF_MIPS_NOREORDER
;
1972 old_flags
&= ~EF_MIPS_NOREORDER
;
1974 if (new_flags
== old_flags
)
1979 if ((new_flags
& EF_MIPS_PIC
) != (old_flags
& EF_MIPS_PIC
))
1981 new_flags
&= ~EF_MIPS_PIC
;
1982 old_flags
&= ~EF_MIPS_PIC
;
1983 (*_bfd_error_handler
)
1984 ("%s: linking PIC files with non-PIC files",
1985 bfd_get_filename (ibfd
));
1989 if ((new_flags
& EF_MIPS_CPIC
) != (old_flags
& EF_MIPS_CPIC
))
1991 new_flags
&= ~EF_MIPS_CPIC
;
1992 old_flags
&= ~EF_MIPS_CPIC
;
1993 (*_bfd_error_handler
)
1994 ("%s: linking abicalls files with non-abicalls files",
1995 bfd_get_filename (ibfd
));
1999 /* Don't warn about mixing -mips1 and -mips2 code, or mixing -mips3
2000 and -mips4 code. They will normally use the same data sizes and
2001 calling conventions. */
2002 if ((new_flags
& EF_MIPS_ARCH
) != (old_flags
& EF_MIPS_ARCH
))
2004 int new_isa
, old_isa
;
2006 new_isa
= elf_mips_isa (new_flags
);
2007 old_isa
= elf_mips_isa (old_flags
);
2008 if ((new_isa
== 1 || new_isa
== 2)
2009 ? (old_isa
!= 1 && old_isa
!= 2)
2010 : (old_isa
== 1 || old_isa
== 2))
2012 (*_bfd_error_handler
)
2013 ("%s: ISA mismatch (-mips%d) with previous modules (-mips%d)",
2014 bfd_get_filename (ibfd
), new_isa
, old_isa
);
2018 new_flags
&= ~ EF_MIPS_ARCH
;
2019 old_flags
&= ~ EF_MIPS_ARCH
;
2022 /* Warn about any other mismatches */
2023 if (new_flags
!= old_flags
)
2025 (*_bfd_error_handler
)
2026 ("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)",
2027 bfd_get_filename (ibfd
), (unsigned long) new_flags
,
2028 (unsigned long) old_flags
);
2034 bfd_set_error (bfd_error_bad_value
);
2041 /* Handle a MIPS specific section when reading an object file. This
2042 is called when elfcode.h finds a section with an unknown type.
2043 This routine supports both the 32-bit and 64-bit ELF ABI.
2045 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
2049 _bfd_mips_elf_section_from_shdr (abfd
, hdr
, name
)
2051 Elf_Internal_Shdr
*hdr
;
2054 /* There ought to be a place to keep ELF backend specific flags, but
2055 at the moment there isn't one. We just keep track of the
2056 sections by their name, instead. Fortunately, the ABI gives
2057 suggested names for all the MIPS specific sections, so we will
2058 probably get away with this. */
2059 switch (hdr
->sh_type
)
2061 case SHT_MIPS_LIBLIST
:
2062 if (strcmp (name
, ".liblist") != 0)
2066 if (strcmp (name
, ".msym") != 0)
2069 case SHT_MIPS_CONFLICT
:
2070 if (strcmp (name
, ".conflict") != 0)
2073 case SHT_MIPS_GPTAB
:
2074 if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) != 0)
2077 case SHT_MIPS_UCODE
:
2078 if (strcmp (name
, ".ucode") != 0)
2081 case SHT_MIPS_DEBUG
:
2082 if (strcmp (name
, ".mdebug") != 0)
2085 case SHT_MIPS_REGINFO
:
2086 if (strcmp (name
, ".reginfo") != 0
2087 || hdr
->sh_size
!= sizeof (Elf32_External_RegInfo
))
2090 case SHT_MIPS_IFACE
:
2091 if (strcmp (name
, ".MIPS.interfaces") != 0)
2094 case SHT_MIPS_CONTENT
:
2095 if (strncmp (name
, ".MIPS.content", sizeof ".MIPS.content" - 1) != 0)
2098 case SHT_MIPS_OPTIONS
:
2099 if (strcmp (name
, ".options") != 0
2100 && strcmp (name
, ".MIPS.options") != 0)
2103 case SHT_MIPS_DWARF
:
2104 if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) != 0)
2107 case SHT_MIPS_SYMBOL_LIB
:
2108 if (strcmp (name
, ".MIPS.symlib") != 0)
2111 case SHT_MIPS_EVENTS
:
2112 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) != 0
2113 && strncmp (name
, ".MIPS.post_rel",
2114 sizeof ".MIPS.post_rel" - 1) != 0)
2121 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
2124 if (hdr
->sh_type
== SHT_MIPS_DEBUG
)
2126 if (! bfd_set_section_flags (abfd
, hdr
->bfd_section
,
2127 (bfd_get_section_flags (abfd
,
2136 /* Handle a 32-bit MIPS ELF specific section. */
2139 mips_elf32_section_from_shdr (abfd
, hdr
, name
)
2141 Elf_Internal_Shdr
*hdr
;
2144 if (! _bfd_mips_elf_section_from_shdr (abfd
, hdr
, name
))
2147 /* FIXME: We should record sh_info for a .gptab section. */
2149 /* For a .reginfo section, set the gp value in the tdata information
2150 from the contents of this section. We need the gp value while
2151 processing relocs, so we just get it now. The .reginfo section
2152 is not used in the 64-bit MIPS ELF ABI. */
2153 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
2155 Elf32_External_RegInfo ext
;
2158 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, (PTR
) &ext
,
2159 (file_ptr
) 0, sizeof ext
))
2161 bfd_mips_elf32_swap_reginfo_in (abfd
, &ext
, &s
);
2162 elf_gp (abfd
) = s
.ri_gp_value
;
2165 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
2166 set the gp value based on what we find. We may see both
2167 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
2168 they should agree. */
2169 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
)
2171 bfd_byte
*contents
, *l
, *lend
;
2173 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
2174 if (contents
== NULL
)
2176 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
,
2177 (file_ptr
) 0, hdr
->sh_size
))
2183 lend
= contents
+ hdr
->sh_size
;
2184 while (l
+ sizeof (Elf_External_Options
) <= lend
)
2186 Elf_Internal_Options intopt
;
2188 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
2190 if (intopt
.kind
== ODK_REGINFO
)
2192 Elf32_RegInfo intreg
;
2194 bfd_mips_elf32_swap_reginfo_in
2196 ((Elf32_External_RegInfo
*)
2197 (l
+ sizeof (Elf_External_Options
))),
2199 elf_gp (abfd
) = intreg
.ri_gp_value
;
2209 /* Set the correct type for a MIPS ELF section. We do this by the
2210 section name, which is a hack, but ought to work. This routine is
2211 used by both the 32-bit and the 64-bit ABI. */
2214 _bfd_mips_elf_fake_sections (abfd
, hdr
, sec
)
2216 Elf32_Internal_Shdr
*hdr
;
2219 register const char *name
;
2221 name
= bfd_get_section_name (abfd
, sec
);
2223 if (strcmp (name
, ".liblist") == 0)
2225 hdr
->sh_type
= SHT_MIPS_LIBLIST
;
2226 hdr
->sh_info
= sec
->_raw_size
/ sizeof (Elf32_Lib
);
2227 /* The sh_link field is set in final_write_processing. */
2229 else if (strcmp (name
, ".msym") == 0)
2231 hdr
->sh_type
= SHT_MIPS_MSYM
;
2232 hdr
->sh_entsize
= 8;
2233 /* FIXME: Set the sh_info field. */
2235 else if (strcmp (name
, ".conflict") == 0)
2236 hdr
->sh_type
= SHT_MIPS_CONFLICT
;
2237 else if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0)
2239 hdr
->sh_type
= SHT_MIPS_GPTAB
;
2240 hdr
->sh_entsize
= sizeof (Elf32_External_gptab
);
2241 /* The sh_info field is set in final_write_processing. */
2243 else if (strcmp (name
, ".ucode") == 0)
2244 hdr
->sh_type
= SHT_MIPS_UCODE
;
2245 else if (strcmp (name
, ".mdebug") == 0)
2247 hdr
->sh_type
= SHT_MIPS_DEBUG
;
2248 /* In a shared object on Irix 5.3, the .mdebug section has an
2249 entsize of 0. FIXME: Does this matter? */
2250 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
2251 hdr
->sh_entsize
= 0;
2253 hdr
->sh_entsize
= 1;
2255 else if (strcmp (name
, ".reginfo") == 0)
2257 hdr
->sh_type
= SHT_MIPS_REGINFO
;
2258 /* In a shared object on Irix 5.3, the .reginfo section has an
2259 entsize of 0x18. FIXME: Does this matter? */
2260 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
2261 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
2263 hdr
->sh_entsize
= 1;
2265 /* Force the section size to the correct value, even if the
2266 linker thinks it is larger. The link routine below will only
2267 write out this much data for .reginfo. */
2268 hdr
->sh_size
= sec
->_raw_size
= sizeof (Elf32_External_RegInfo
);
2270 else if (SGI_COMPAT (abfd
)
2271 && (strcmp (name
, ".hash") == 0
2272 || strcmp (name
, ".dynamic") == 0
2273 || strcmp (name
, ".dynstr") == 0))
2275 hdr
->sh_entsize
= 0;
2276 hdr
->sh_info
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
2278 else if (strcmp (name
, ".got") == 0
2279 || strcmp (name
, ".sdata") == 0
2280 || strcmp (name
, ".sbss") == 0
2281 || strcmp (name
, ".lit4") == 0
2282 || strcmp (name
, ".lit8") == 0)
2283 hdr
->sh_flags
|= SHF_MIPS_GPREL
;
2284 else if (strcmp (name
, ".MIPS.interfaces") == 0)
2286 hdr
->sh_type
= SHT_MIPS_IFACE
;
2287 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
2289 else if (strcmp (name
, ".MIPS.content") == 0)
2291 hdr
->sh_type
= SHT_MIPS_CONTENT
;
2292 /* The sh_info field is set in final_write_processing. */
2294 else if (strcmp (name
, ".options") == 0
2295 || strcmp (name
, ".MIPS.options") == 0)
2297 hdr
->sh_type
= SHT_MIPS_OPTIONS
;
2298 hdr
->sh_entsize
= 1;
2299 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
2301 else if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) == 0)
2302 hdr
->sh_type
= SHT_MIPS_DWARF
;
2303 else if (strcmp (name
, ".MIPS.symlib") == 0)
2305 hdr
->sh_type
= SHT_MIPS_SYMBOL_LIB
;
2306 /* The sh_link and sh_info fields are set in
2307 final_write_processing. */
2309 else if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0
2310 || strncmp (name
, ".MIPS.post_rel",
2311 sizeof ".MIPS.post_rel" - 1) == 0)
2313 hdr
->sh_type
= SHT_MIPS_EVENTS
;
2314 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
2315 /* The sh_link field is set in final_write_processing. */
2321 /* Given a BFD section, try to locate the corresponding ELF section
2322 index. This is used by both the 32-bit and the 64-bit ABI.
2323 Actually, it's not clear to me that the 64-bit ABI supports these,
2324 but for non-PIC objects we will certainly want support for at least
2325 the .scommon section. */
2328 _bfd_mips_elf_section_from_bfd_section (abfd
, hdr
, sec
, retval
)
2330 Elf32_Internal_Shdr
*hdr
;
2334 if (strcmp (bfd_get_section_name (abfd
, sec
), ".scommon") == 0)
2336 *retval
= SHN_MIPS_SCOMMON
;
2339 if (strcmp (bfd_get_section_name (abfd
, sec
), ".acommon") == 0)
2341 *retval
= SHN_MIPS_ACOMMON
;
2347 /* When are writing out the .options or .MIPS.options section,
2348 remember the bytes we are writing out, so that we can install the
2349 GP value in the section_processing routine. */
2352 _bfd_mips_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
2357 bfd_size_type count
;
2359 if (strcmp (section
->name
, ".options") == 0
2360 || strcmp (section
->name
, ".MIPS.options") == 0)
2364 if (elf_section_data (section
) == NULL
)
2366 section
->used_by_bfd
=
2367 (PTR
) bfd_zalloc (abfd
, sizeof (struct bfd_elf_section_data
));
2368 if (elf_section_data (section
) == NULL
)
2371 c
= (bfd_byte
*) elf_section_data (section
)->tdata
;
2376 if (section
->_cooked_size
!= 0)
2377 size
= section
->_cooked_size
;
2379 size
= section
->_raw_size
;
2380 c
= (PTR
) bfd_zalloc (abfd
, size
);
2383 elf_section_data (section
)->tdata
= (PTR
) c
;
2386 memcpy (c
+ offset
, location
, count
);
2389 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
,
2393 /* Work over a section just before writing it out. This routine is
2394 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
2395 sections that need the SHF_MIPS_GPREL flag by name; there has to be
2399 _bfd_mips_elf_section_processing (abfd
, hdr
)
2401 Elf_Internal_Shdr
*hdr
;
2403 if (hdr
->bfd_section
!= NULL
)
2405 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
2407 if (strcmp (name
, ".sdata") == 0)
2409 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
2410 hdr
->sh_type
= SHT_PROGBITS
;
2412 else if (strcmp (name
, ".sbss") == 0)
2414 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
2415 hdr
->sh_type
= SHT_NOBITS
;
2417 else if (strcmp (name
, ".lit8") == 0
2418 || strcmp (name
, ".lit4") == 0)
2420 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
2421 hdr
->sh_type
= SHT_PROGBITS
;
2423 else if (strcmp (name
, ".compact_rel") == 0)
2426 hdr
->sh_type
= SHT_PROGBITS
;
2428 else if (strcmp (name
, ".rtproc") == 0)
2430 if (hdr
->sh_addralign
!= 0 && hdr
->sh_entsize
== 0)
2432 unsigned int adjust
;
2434 adjust
= hdr
->sh_size
% hdr
->sh_addralign
;
2436 hdr
->sh_size
+= hdr
->sh_addralign
- adjust
;
2444 /* Work over a section just before writing it out. We update the GP
2445 value in the SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS sections based
2446 on the value we are using. */
2449 mips_elf32_section_processing (abfd
, hdr
)
2451 Elf32_Internal_Shdr
*hdr
;
2453 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
2457 BFD_ASSERT (hdr
->sh_size
== sizeof (Elf32_External_RegInfo
));
2458 BFD_ASSERT (hdr
->contents
== NULL
);
2461 hdr
->sh_offset
+ sizeof (Elf32_External_RegInfo
) - 4,
2464 bfd_h_put_32 (abfd
, (bfd_vma
) elf_gp (abfd
), buf
);
2465 if (bfd_write (buf
, (bfd_size_type
) 1, (bfd_size_type
) 4, abfd
) != 4)
2469 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
2470 && hdr
->bfd_section
!= NULL
2471 && elf_section_data (hdr
->bfd_section
) != NULL
2472 && elf_section_data (hdr
->bfd_section
)->tdata
!= NULL
)
2474 bfd_byte
*contents
, *l
, *lend
;
2476 /* We stored the section contents in the elf_section_data tdata
2477 field in the set_section_contents routine. We save the
2478 section contents so that we don't have to read them again.
2479 At this point we know that elf_gp is set, so we can look
2480 through the section contents to see if there is an
2481 ODK_REGINFO structure. */
2483 contents
= (bfd_byte
*) elf_section_data (hdr
->bfd_section
)->tdata
;
2485 lend
= contents
+ hdr
->sh_size
;
2486 while (l
+ sizeof (Elf_External_Options
) <= lend
)
2488 Elf_Internal_Options intopt
;
2490 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
2492 if (intopt
.kind
== ODK_REGINFO
)
2499 + sizeof (Elf_External_Options
)
2500 + (sizeof (Elf32_External_RegInfo
) - 4)),
2503 bfd_h_put_32 (abfd
, elf_gp (abfd
), buf
);
2504 if (bfd_write (buf
, 1, 4, abfd
) != 4)
2511 return _bfd_mips_elf_section_processing (abfd
, hdr
);
2514 /* MIPS ELF uses two common sections. One is the usual one, and the
2515 other is for small objects. All the small objects are kept
2516 together, and then referenced via the gp pointer, which yields
2517 faster assembler code. This is what we use for the small common
2518 section. This approach is copied from ecoff.c. */
2519 static asection mips_elf_scom_section
;
2520 static asymbol mips_elf_scom_symbol
;
2521 static asymbol
*mips_elf_scom_symbol_ptr
;
2523 /* MIPS ELF also uses an acommon section, which represents an
2524 allocated common symbol which may be overridden by a
2525 definition in a shared library. */
2526 static asection mips_elf_acom_section
;
2527 static asymbol mips_elf_acom_symbol
;
2528 static asymbol
*mips_elf_acom_symbol_ptr
;
2530 /* The Irix 5 support uses two virtual sections, which represent
2531 text/data symbols defined in dynamic objects. */
2532 static asection mips_elf_text_section
;
2533 static asection
*mips_elf_text_section_ptr
;
2534 static asymbol mips_elf_text_symbol
;
2535 static asymbol
*mips_elf_text_symbol_ptr
;
2537 static asection mips_elf_data_section
;
2538 static asection
*mips_elf_data_section_ptr
;
2539 static asymbol mips_elf_data_symbol
;
2540 static asymbol
*mips_elf_data_symbol_ptr
;
2542 /* Handle the special MIPS section numbers that a symbol may use.
2543 This is used for both the 32-bit and the 64-bit ABI. */
2546 _bfd_mips_elf_symbol_processing (abfd
, asym
)
2550 elf_symbol_type
*elfsym
;
2552 elfsym
= (elf_symbol_type
*) asym
;
2553 switch (elfsym
->internal_elf_sym
.st_shndx
)
2555 case SHN_MIPS_ACOMMON
:
2556 /* This section is used in a dynamically linked executable file.
2557 It is an allocated common section. The dynamic linker can
2558 either resolve these symbols to something in a shared
2559 library, or it can just leave them here. For our purposes,
2560 we can consider these symbols to be in a new section. */
2561 if (mips_elf_acom_section
.name
== NULL
)
2563 /* Initialize the acommon section. */
2564 mips_elf_acom_section
.name
= ".acommon";
2565 mips_elf_acom_section
.flags
= SEC_ALLOC
;
2566 mips_elf_acom_section
.output_section
= &mips_elf_acom_section
;
2567 mips_elf_acom_section
.symbol
= &mips_elf_acom_symbol
;
2568 mips_elf_acom_section
.symbol_ptr_ptr
= &mips_elf_acom_symbol_ptr
;
2569 mips_elf_acom_symbol
.name
= ".acommon";
2570 mips_elf_acom_symbol
.flags
= BSF_SECTION_SYM
;
2571 mips_elf_acom_symbol
.section
= &mips_elf_acom_section
;
2572 mips_elf_acom_symbol_ptr
= &mips_elf_acom_symbol
;
2574 asym
->section
= &mips_elf_acom_section
;
2578 /* Common symbols less than the GP size are automatically
2579 treated as SHN_MIPS_SCOMMON symbols. */
2580 if (asym
->value
> elf_gp_size (abfd
))
2583 case SHN_MIPS_SCOMMON
:
2584 if (mips_elf_scom_section
.name
== NULL
)
2586 /* Initialize the small common section. */
2587 mips_elf_scom_section
.name
= ".scommon";
2588 mips_elf_scom_section
.flags
= SEC_IS_COMMON
;
2589 mips_elf_scom_section
.output_section
= &mips_elf_scom_section
;
2590 mips_elf_scom_section
.symbol
= &mips_elf_scom_symbol
;
2591 mips_elf_scom_section
.symbol_ptr_ptr
= &mips_elf_scom_symbol_ptr
;
2592 mips_elf_scom_symbol
.name
= ".scommon";
2593 mips_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
2594 mips_elf_scom_symbol
.section
= &mips_elf_scom_section
;
2595 mips_elf_scom_symbol_ptr
= &mips_elf_scom_symbol
;
2597 asym
->section
= &mips_elf_scom_section
;
2598 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
2601 case SHN_MIPS_SUNDEFINED
:
2602 asym
->section
= bfd_und_section_ptr
;
2605 #if 0 /* for SGI_COMPAT */
2607 asym
->section
= mips_elf_text_section_ptr
;
2611 asym
->section
= mips_elf_data_section_ptr
;
2617 /* When creating an Irix 5 executable, we need REGINFO and RTPROC
2621 mips_elf_additional_program_headers (abfd
)
2629 if (! SGI_COMPAT (abfd
))
2632 s
= bfd_get_section_by_name (abfd
, ".reginfo");
2633 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2635 /* We need a PT_MIPS_REGINFO segment. */
2639 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
2640 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
2642 /* We need a PT_MIPS_RTPROC segment. */
2649 /* Modify the segment map for an Irix 5 executable. */
2652 mips_elf_modify_segment_map (abfd
)
2656 struct elf_segment_map
*m
, **pm
;
2658 if (! SGI_COMPAT (abfd
))
2661 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
2663 s
= bfd_get_section_by_name (abfd
, ".reginfo");
2664 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2666 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2667 if (m
->p_type
== PT_MIPS_REGINFO
)
2671 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, sizeof *m
);
2675 m
->p_type
= PT_MIPS_REGINFO
;
2679 /* We want to put it after the PHDR and INTERP segments. */
2680 pm
= &elf_tdata (abfd
)->segment_map
;
2682 && ((*pm
)->p_type
== PT_PHDR
2683 || (*pm
)->p_type
== PT_INTERP
))
2691 /* If there are .dynamic and .mdebug sections, we make a room for
2692 the RTPROC header. FIXME: Rewrite without section names. */
2693 if (bfd_get_section_by_name (abfd
, ".interp") == NULL
2694 && bfd_get_section_by_name (abfd
, ".dynamic") != NULL
2695 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
2697 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2698 if (m
->p_type
== PT_MIPS_RTPROC
)
2702 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, sizeof *m
);
2706 m
->p_type
= PT_MIPS_RTPROC
;
2708 s
= bfd_get_section_by_name (abfd
, ".rtproc");
2713 m
->p_flags_valid
= 1;
2721 /* We want to put it after the DYNAMIC segment. */
2722 pm
= &elf_tdata (abfd
)->segment_map
;
2723 while (*pm
!= NULL
&& (*pm
)->p_type
!= PT_DYNAMIC
)
2733 /* On Irix 5, the PT_DYNAMIC segment includes the .dynamic, .dynstr,
2734 .dynsym, and .hash sections, and everything in between. */
2735 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
; pm
= &(*pm
)->next
)
2736 if ((*pm
)->p_type
== PT_DYNAMIC
)
2741 && strcmp (m
->sections
[0]->name
, ".dynamic") == 0)
2743 static const char *sec_names
[] =
2744 { ".dynamic", ".dynstr", ".dynsym", ".hash" };
2747 struct elf_segment_map
*n
;
2751 for (i
= 0; i
< sizeof sec_names
/ sizeof sec_names
[0]; i
++)
2753 s
= bfd_get_section_by_name (abfd
, sec_names
[i
]);
2754 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2760 sz
= s
->_cooked_size
;
2763 if (high
< s
->vma
+ sz
)
2769 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2770 if ((s
->flags
& SEC_LOAD
) != 0
2773 + (s
->_cooked_size
!= 0 ? s
->_cooked_size
: s
->_raw_size
))
2777 n
= ((struct elf_segment_map
*)
2778 bfd_zalloc (abfd
, sizeof *n
+ (c
- 1) * sizeof (asection
*)));
2785 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2787 if ((s
->flags
& SEC_LOAD
) != 0
2790 + (s
->_cooked_size
!= 0 ? s
->_cooked_size
: s
->_raw_size
))
2804 /* The structure of the runtime procedure descriptor created by the
2805 loader for use by the static exception system. */
2807 typedef struct runtime_pdr
{
2808 bfd_vma adr
; /* memory address of start of procedure */
2809 long regmask
; /* save register mask */
2810 long regoffset
; /* save register offset */
2811 long fregmask
; /* save floating point register mask */
2812 long fregoffset
; /* save floating point register offset */
2813 long frameoffset
; /* frame size */
2814 short framereg
; /* frame pointer register */
2815 short pcreg
; /* offset or reg of return pc */
2816 long irpss
; /* index into the runtime string table */
2818 struct exception_info
*exception_info
;/* pointer to exception array */
2820 #define cbRPDR sizeof(RPDR)
2821 #define rpdNil ((pRPDR) 0)
2823 /* Swap RPDR (runtime procedure table entry) for output. */
2825 static void ecoff_swap_rpdr_out
2826 PARAMS ((bfd
*, const RPDR
*, struct rpdr_ext
*));
2829 ecoff_swap_rpdr_out (abfd
, in
, ex
)
2832 struct rpdr_ext
*ex
;
2834 /* ecoff_put_off was defined in ecoffswap.h. */
2835 ecoff_put_off (abfd
, in
->adr
, (bfd_byte
*) ex
->p_adr
);
2836 bfd_h_put_32 (abfd
, in
->regmask
, (bfd_byte
*) ex
->p_regmask
);
2837 bfd_h_put_32 (abfd
, in
->regoffset
, (bfd_byte
*) ex
->p_regoffset
);
2838 bfd_h_put_32 (abfd
, in
->fregmask
, (bfd_byte
*) ex
->p_fregmask
);
2839 bfd_h_put_32 (abfd
, in
->fregoffset
, (bfd_byte
*) ex
->p_fregoffset
);
2840 bfd_h_put_32 (abfd
, in
->frameoffset
, (bfd_byte
*) ex
->p_frameoffset
);
2842 bfd_h_put_16 (abfd
, in
->framereg
, (bfd_byte
*) ex
->p_framereg
);
2843 bfd_h_put_16 (abfd
, in
->pcreg
, (bfd_byte
*) ex
->p_pcreg
);
2845 bfd_h_put_32 (abfd
, in
->irpss
, (bfd_byte
*) ex
->p_irpss
);
2847 ecoff_put_off (abfd
, in
->exception_info
, (bfd_byte
*) ex
->p_exception_info
);
2851 /* Read ECOFF debugging information from a .mdebug section into a
2852 ecoff_debug_info structure. */
2855 _bfd_mips_elf_read_ecoff_info (abfd
, section
, debug
)
2858 struct ecoff_debug_info
*debug
;
2861 const struct ecoff_debug_swap
*swap
;
2862 char *ext_hdr
= NULL
;
2864 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
2866 ext_hdr
= (char *) bfd_malloc ((size_t) swap
->external_hdr_size
);
2867 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
2870 if (bfd_get_section_contents (abfd
, section
, ext_hdr
, (file_ptr
) 0,
2871 swap
->external_hdr_size
)
2875 symhdr
= &debug
->symbolic_header
;
2876 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
2878 /* The symbolic header contains absolute file offsets and sizes to
2880 #define READ(ptr, offset, count, size, type) \
2881 if (symhdr->count == 0) \
2882 debug->ptr = NULL; \
2885 debug->ptr = (type) bfd_malloc ((size_t) (size * symhdr->count)); \
2886 if (debug->ptr == NULL) \
2887 goto error_return; \
2888 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
2889 || (bfd_read (debug->ptr, size, symhdr->count, \
2890 abfd) != size * symhdr->count)) \
2891 goto error_return; \
2894 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
2895 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, PTR
);
2896 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, PTR
);
2897 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, PTR
);
2898 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, PTR
);
2899 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
2901 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
2902 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
2903 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, PTR
);
2904 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, PTR
);
2905 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, PTR
);
2909 debug
->adjust
= NULL
;
2914 if (ext_hdr
!= NULL
)
2916 if (debug
->line
!= NULL
)
2918 if (debug
->external_dnr
!= NULL
)
2919 free (debug
->external_dnr
);
2920 if (debug
->external_pdr
!= NULL
)
2921 free (debug
->external_pdr
);
2922 if (debug
->external_sym
!= NULL
)
2923 free (debug
->external_sym
);
2924 if (debug
->external_opt
!= NULL
)
2925 free (debug
->external_opt
);
2926 if (debug
->external_aux
!= NULL
)
2927 free (debug
->external_aux
);
2928 if (debug
->ss
!= NULL
)
2930 if (debug
->ssext
!= NULL
)
2931 free (debug
->ssext
);
2932 if (debug
->external_fdr
!= NULL
)
2933 free (debug
->external_fdr
);
2934 if (debug
->external_rfd
!= NULL
)
2935 free (debug
->external_rfd
);
2936 if (debug
->external_ext
!= NULL
)
2937 free (debug
->external_ext
);
2941 /* MIPS ELF local labels start with '$', not 'L'. */
2945 mips_elf_is_local_label_name (abfd
, name
)
2949 return name
[0] == '$';
2952 /* MIPS ELF uses a special find_nearest_line routine in order the
2953 handle the ECOFF debugging information. */
2955 struct mips_elf_find_line
2957 struct ecoff_debug_info d
;
2958 struct ecoff_find_line i
;
2962 _bfd_mips_elf_find_nearest_line (abfd
, section
, symbols
, offset
, filename_ptr
,
2963 functionname_ptr
, line_ptr
)
2968 const char **filename_ptr
;
2969 const char **functionname_ptr
;
2970 unsigned int *line_ptr
;
2974 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
2978 struct mips_elf_find_line
*fi
;
2979 const struct ecoff_debug_swap
* const swap
=
2980 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
2982 /* If we are called during a link, mips_elf_final_link may have
2983 cleared the SEC_HAS_CONTENTS field. We force it back on here
2984 if appropriate (which it normally will be). */
2985 origflags
= msec
->flags
;
2986 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
2987 msec
->flags
|= SEC_HAS_CONTENTS
;
2989 fi
= elf_tdata (abfd
)->find_line_info
;
2992 bfd_size_type external_fdr_size
;
2995 struct fdr
*fdr_ptr
;
2997 fi
= ((struct mips_elf_find_line
*)
2998 bfd_zalloc (abfd
, sizeof (struct mips_elf_find_line
)));
3001 msec
->flags
= origflags
;
3005 if (! _bfd_mips_elf_read_ecoff_info (abfd
, msec
, &fi
->d
))
3007 msec
->flags
= origflags
;
3011 /* Swap in the FDR information. */
3012 fi
->d
.fdr
= ((struct fdr
*)
3014 (fi
->d
.symbolic_header
.ifdMax
*
3015 sizeof (struct fdr
))));
3016 if (fi
->d
.fdr
== NULL
)
3018 msec
->flags
= origflags
;
3021 external_fdr_size
= swap
->external_fdr_size
;
3022 fdr_ptr
= fi
->d
.fdr
;
3023 fraw_src
= (char *) fi
->d
.external_fdr
;
3024 fraw_end
= (fraw_src
3025 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
3026 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
3027 (*swap
->swap_fdr_in
) (abfd
, (PTR
) fraw_src
, fdr_ptr
);
3029 elf_tdata (abfd
)->find_line_info
= fi
;
3031 /* Note that we don't bother to ever free this information.
3032 find_nearest_line is either called all the time, as in
3033 objdump -l, so the information should be saved, or it is
3034 rarely called, as in ld error messages, so the memory
3035 wasted is unimportant. Still, it would probably be a
3036 good idea for free_cached_info to throw it away. */
3039 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
3040 &fi
->i
, filename_ptr
, functionname_ptr
,
3043 msec
->flags
= origflags
;
3047 msec
->flags
= origflags
;
3050 /* Fall back on the generic ELF find_nearest_line routine. */
3052 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
3053 filename_ptr
, functionname_ptr
,
3057 /* The mips16 compiler uses a couple of special sections to handle
3058 floating point arguments.
3060 Section names that look like .mips16.fn.FNNAME contain stubs that
3061 copy floating point arguments from the fp regs to the gp regs and
3062 then jump to FNNAME. If any 32 bit function calls FNNAME, the
3063 call should be redirected to the stub instead. If no 32 bit
3064 function calls FNNAME, the stub should be discarded. We need to
3065 consider any reference to the function, not just a call, because
3066 if the address of the function is taken we will need the stub,
3067 since the address might be passed to a 32 bit function.
3069 Section names that look like .mips16.call.FNNAME contain stubs
3070 that copy floating point arguments from the gp regs to the fp
3071 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
3072 then any 16 bit function that calls FNNAME should be redirected
3073 to the stub instead. If FNNAME is not a 32 bit function, the
3074 stub should be discarded.
3076 .mips16.call.fp.FNNAME sections are similar, but contain stubs
3077 which call FNNAME and then copy the return value from the fp regs
3078 to the gp regs. These stubs store the return value in $18 while
3079 calling FNNAME; any function which might call one of these stubs
3080 must arrange to save $18 around the call. (This case is not
3081 needed for 32 bit functions that call 16 bit functions, because
3082 16 bit functions always return floating point values in both
3085 Note that in all cases FNNAME might be defined statically.
3086 Therefore, FNNAME is not used literally. Instead, the relocation
3087 information will indicate which symbol the section is for.
3089 We record any stubs that we find in the symbol table. */
3091 #define FN_STUB ".mips16.fn."
3092 #define CALL_STUB ".mips16.call."
3093 #define CALL_FP_STUB ".mips16.call.fp."
3095 /* The MIPS ELF linker needs additional information for each symbol in
3096 the global hash table. */
3098 struct mips_elf_link_hash_entry
3100 struct elf_link_hash_entry root
;
3102 /* External symbol information. */
3105 /* Number of MIPS_32 or MIPS_REL32 relocs against this symbol. */
3106 unsigned int mips_32_relocs
;
3108 /* If there is a stub that 32 bit functions should use to call this
3109 16 bit function, this points to the section containing the stub. */
3112 /* Whether we need the fn_stub; this is set if this symbol appears
3113 in any relocs other than a 16 bit call. */
3114 boolean need_fn_stub
;
3116 /* If there is a stub that 16 bit functions should use to call this
3117 32 bit function, this points to the section containing the stub. */
3118 asection
*call_stub
;
3120 /* This is like the call_stub field, but it is used if the function
3121 being called returns a floating point value. */
3122 asection
*call_fp_stub
;
3125 /* MIPS ELF linker hash table. */
3127 struct mips_elf_link_hash_table
3129 struct elf_link_hash_table root
;
3130 /* String section indices for the dynamic section symbols. */
3131 bfd_size_type dynsym_sec_strindex
[SIZEOF_MIPS_DYNSYM_SECNAMES
];
3132 /* The number of .rtproc entries. */
3133 bfd_size_type procedure_count
;
3134 /* The size of the .compact_rel section (if SGI_COMPAT). */
3135 bfd_size_type compact_rel_size
;
3136 /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic
3137 entry is set to the address of __rld_obj_head as in Irix 5. */
3138 boolean use_rld_obj_head
;
3139 /* This is the value of the __rld_map or __rld_obj_head symbol. */
3141 /* This is set if we see any mips16 stub sections. */
3142 boolean mips16_stubs_seen
;
3145 /* Look up an entry in a MIPS ELF linker hash table. */
3147 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
3148 ((struct mips_elf_link_hash_entry *) \
3149 elf_link_hash_lookup (&(table)->root, (string), (create), \
3152 /* Traverse a MIPS ELF linker hash table. */
3154 #define mips_elf_link_hash_traverse(table, func, info) \
3155 (elf_link_hash_traverse \
3157 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
3160 /* Get the MIPS ELF linker hash table from a link_info structure. */
3162 #define mips_elf_hash_table(p) \
3163 ((struct mips_elf_link_hash_table *) ((p)->hash))
3165 static boolean mips_elf_output_extsym
3166 PARAMS ((struct mips_elf_link_hash_entry
*, PTR
));
3168 /* Create an entry in a MIPS ELF linker hash table. */
3170 static struct bfd_hash_entry
*
3171 mips_elf_link_hash_newfunc (entry
, table
, string
)
3172 struct bfd_hash_entry
*entry
;
3173 struct bfd_hash_table
*table
;
3176 struct mips_elf_link_hash_entry
*ret
=
3177 (struct mips_elf_link_hash_entry
*) entry
;
3179 /* Allocate the structure if it has not already been allocated by a
3181 if (ret
== (struct mips_elf_link_hash_entry
*) NULL
)
3182 ret
= ((struct mips_elf_link_hash_entry
*)
3183 bfd_hash_allocate (table
,
3184 sizeof (struct mips_elf_link_hash_entry
)));
3185 if (ret
== (struct mips_elf_link_hash_entry
*) NULL
)
3186 return (struct bfd_hash_entry
*) ret
;
3188 /* Call the allocation method of the superclass. */
3189 ret
= ((struct mips_elf_link_hash_entry
*)
3190 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
3192 if (ret
!= (struct mips_elf_link_hash_entry
*) NULL
)
3194 /* Set local fields. */
3195 memset (&ret
->esym
, 0, sizeof (EXTR
));
3196 /* We use -2 as a marker to indicate that the information has
3197 not been set. -1 means there is no associated ifd. */
3199 ret
->mips_32_relocs
= 0;
3200 ret
->fn_stub
= NULL
;
3201 ret
->need_fn_stub
= false;
3202 ret
->call_stub
= NULL
;
3203 ret
->call_fp_stub
= NULL
;
3206 return (struct bfd_hash_entry
*) ret
;
3209 /* Create a MIPS ELF linker hash table. */
3211 static struct bfd_link_hash_table
*
3212 mips_elf_link_hash_table_create (abfd
)
3215 struct mips_elf_link_hash_table
*ret
;
3218 ret
= ((struct mips_elf_link_hash_table
*)
3219 bfd_alloc (abfd
, sizeof (struct mips_elf_link_hash_table
)));
3220 if (ret
== (struct mips_elf_link_hash_table
*) NULL
)
3223 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
3224 mips_elf_link_hash_newfunc
))
3226 bfd_release (abfd
, ret
);
3230 for (i
= 0; i
< SIZEOF_MIPS_DYNSYM_SECNAMES
; i
++)
3231 ret
->dynsym_sec_strindex
[i
] = (bfd_size_type
) -1;
3232 ret
->procedure_count
= 0;
3233 ret
->compact_rel_size
= 0;
3234 ret
->use_rld_obj_head
= false;
3236 ret
->mips16_stubs_seen
= false;
3238 return &ret
->root
.root
;
3241 /* Hook called by the linker routine which adds symbols from an object
3242 file. We must handle the special MIPS section numbers here. */
3246 mips_elf_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
, secp
, valp
)
3248 struct bfd_link_info
*info
;
3249 const Elf_Internal_Sym
*sym
;
3255 if (SGI_COMPAT (abfd
)
3256 && (abfd
->flags
& DYNAMIC
) != 0
3257 && strcmp (*namep
, "_rld_new_interface") == 0)
3259 /* Skip Irix 5 rld entry name. */
3264 switch (sym
->st_shndx
)
3267 /* Common symbols less than the GP size are automatically
3268 treated as SHN_MIPS_SCOMMON symbols. */
3269 if (sym
->st_size
> elf_gp_size (abfd
))
3272 case SHN_MIPS_SCOMMON
:
3273 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
3274 (*secp
)->flags
|= SEC_IS_COMMON
;
3275 *valp
= sym
->st_size
;
3279 /* This section is used in a shared object. */
3280 if (mips_elf_text_section_ptr
== NULL
)
3282 /* Initialize the section. */
3283 mips_elf_text_section
.name
= ".text";
3284 mips_elf_text_section
.flags
= SEC_NO_FLAGS
;
3285 mips_elf_text_section
.output_section
= NULL
;
3286 mips_elf_text_section
.symbol
= &mips_elf_text_symbol
;
3287 mips_elf_text_section
.symbol_ptr_ptr
= &mips_elf_text_symbol_ptr
;
3288 mips_elf_text_symbol
.name
= ".text";
3289 mips_elf_text_symbol
.flags
= BSF_SECTION_SYM
;
3290 mips_elf_text_symbol
.section
= &mips_elf_text_section
;
3291 mips_elf_text_symbol_ptr
= &mips_elf_text_symbol
;
3292 mips_elf_text_section_ptr
= &mips_elf_text_section
;
3294 /* This code used to do *secp = bfd_und_section_ptr if
3295 info->shared. I don't know why, and that doesn't make sense,
3296 so I took it out. */
3297 *secp
= mips_elf_text_section_ptr
;
3300 case SHN_MIPS_ACOMMON
:
3301 /* Fall through. XXX Can we treat this as allocated data? */
3303 /* This section is used in a shared object. */
3304 if (mips_elf_data_section_ptr
== NULL
)
3306 /* Initialize the section. */
3307 mips_elf_data_section
.name
= ".data";
3308 mips_elf_data_section
.flags
= SEC_NO_FLAGS
;
3309 mips_elf_data_section
.output_section
= NULL
;
3310 mips_elf_data_section
.symbol
= &mips_elf_data_symbol
;
3311 mips_elf_data_section
.symbol_ptr_ptr
= &mips_elf_data_symbol_ptr
;
3312 mips_elf_data_symbol
.name
= ".data";
3313 mips_elf_data_symbol
.flags
= BSF_SECTION_SYM
;
3314 mips_elf_data_symbol
.section
= &mips_elf_data_section
;
3315 mips_elf_data_symbol_ptr
= &mips_elf_data_symbol
;
3316 mips_elf_data_section_ptr
= &mips_elf_data_section
;
3318 /* This code used to do *secp = bfd_und_section_ptr if
3319 info->shared. I don't know why, and that doesn't make sense,
3320 so I took it out. */
3321 *secp
= mips_elf_data_section_ptr
;
3324 case SHN_MIPS_SUNDEFINED
:
3325 *secp
= bfd_und_section_ptr
;
3329 if (SGI_COMPAT (abfd
)
3331 && info
->hash
->creator
== abfd
->xvec
3332 && strcmp (*namep
, "__rld_obj_head") == 0)
3334 struct elf_link_hash_entry
*h
;
3336 /* Mark __rld_obj_head as dynamic. */
3338 if (! (_bfd_generic_link_add_one_symbol
3339 (info
, abfd
, *namep
, BSF_GLOBAL
, *secp
,
3340 (bfd_vma
) *valp
, (const char *) NULL
, false,
3341 get_elf_backend_data (abfd
)->collect
,
3342 (struct bfd_link_hash_entry
**) &h
)))
3344 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
3345 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
3346 h
->type
= STT_OBJECT
;
3348 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
3351 mips_elf_hash_table (info
)->use_rld_obj_head
= true;
3354 /* If this is a mips16 text symbol, add 1 to the value to make it
3355 odd. This will cause something like .word SYM to come up with
3356 the right value when it is loaded into the PC. */
3357 if (sym
->st_other
== STO_MIPS16
)
3363 /* Structure used to pass information to mips_elf_output_extsym. */
3368 struct bfd_link_info
*info
;
3369 struct ecoff_debug_info
*debug
;
3370 const struct ecoff_debug_swap
*swap
;
3374 /* This routine is used to write out ECOFF debugging external symbol
3375 information. It is called via mips_elf_link_hash_traverse. The
3376 ECOFF external symbol information must match the ELF external
3377 symbol information. Unfortunately, at this point we don't know
3378 whether a symbol is required by reloc information, so the two
3379 tables may wind up being different. We must sort out the external
3380 symbol information before we can set the final size of the .mdebug
3381 section, and we must set the size of the .mdebug section before we
3382 can relocate any sections, and we can't know which symbols are
3383 required by relocation until we relocate the sections.
3384 Fortunately, it is relatively unlikely that any symbol will be
3385 stripped but required by a reloc. In particular, it can not happen
3386 when generating a final executable. */
3389 mips_elf_output_extsym (h
, data
)
3390 struct mips_elf_link_hash_entry
*h
;
3393 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
3395 asection
*sec
, *output_section
;
3397 if (h
->root
.indx
== -2)
3399 else if (((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
3400 || (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
3401 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
3402 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
3404 else if (einfo
->info
->strip
== strip_all
3405 || (einfo
->info
->strip
== strip_some
3406 && bfd_hash_lookup (einfo
->info
->keep_hash
,
3407 h
->root
.root
.root
.string
,
3408 false, false) == NULL
))
3416 if (h
->esym
.ifd
== -2)
3419 h
->esym
.cobol_main
= 0;
3420 h
->esym
.weakext
= 0;
3421 h
->esym
.reserved
= 0;
3422 h
->esym
.ifd
= ifdNil
;
3423 h
->esym
.asym
.value
= 0;
3424 h
->esym
.asym
.st
= stGlobal
;
3426 if (SGI_COMPAT (einfo
->abfd
)
3427 && (h
->root
.root
.type
== bfd_link_hash_undefined
3428 || h
->root
.root
.type
== bfd_link_hash_undefweak
))
3432 /* Use undefined class. Also, set class and type for some
3434 name
= h
->root
.root
.root
.string
;
3435 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
3436 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
3438 h
->esym
.asym
.sc
= scData
;
3439 h
->esym
.asym
.st
= stLabel
;
3440 h
->esym
.asym
.value
= 0;
3442 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
3444 h
->esym
.asym
.sc
= scAbs
;
3445 h
->esym
.asym
.st
= stLabel
;
3446 h
->esym
.asym
.value
=
3447 mips_elf_hash_table (einfo
->info
)->procedure_count
;
3449 else if (strcmp (name
, "_gp_disp") == 0)
3451 h
->esym
.asym
.sc
= scAbs
;
3452 h
->esym
.asym
.st
= stLabel
;
3453 h
->esym
.asym
.value
= elf_gp (einfo
->abfd
);
3456 h
->esym
.asym
.sc
= scUndefined
;
3458 else if (h
->root
.root
.type
!= bfd_link_hash_defined
3459 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
3460 h
->esym
.asym
.sc
= scAbs
;
3465 sec
= h
->root
.root
.u
.def
.section
;
3466 output_section
= sec
->output_section
;
3468 /* When making a shared library and symbol h is the one from
3469 the another shared library, OUTPUT_SECTION may be null. */
3470 if (output_section
== NULL
)
3471 h
->esym
.asym
.sc
= scUndefined
;
3474 name
= bfd_section_name (output_section
->owner
, output_section
);
3476 if (strcmp (name
, ".text") == 0)
3477 h
->esym
.asym
.sc
= scText
;
3478 else if (strcmp (name
, ".data") == 0)
3479 h
->esym
.asym
.sc
= scData
;
3480 else if (strcmp (name
, ".sdata") == 0)
3481 h
->esym
.asym
.sc
= scSData
;
3482 else if (strcmp (name
, ".rodata") == 0
3483 || strcmp (name
, ".rdata") == 0)
3484 h
->esym
.asym
.sc
= scRData
;
3485 else if (strcmp (name
, ".bss") == 0)
3486 h
->esym
.asym
.sc
= scBss
;
3487 else if (strcmp (name
, ".sbss") == 0)
3488 h
->esym
.asym
.sc
= scSBss
;
3489 else if (strcmp (name
, ".init") == 0)
3490 h
->esym
.asym
.sc
= scInit
;
3491 else if (strcmp (name
, ".fini") == 0)
3492 h
->esym
.asym
.sc
= scFini
;
3494 h
->esym
.asym
.sc
= scAbs
;
3498 h
->esym
.asym
.reserved
= 0;
3499 h
->esym
.asym
.index
= indexNil
;
3502 if (h
->root
.root
.type
== bfd_link_hash_common
)
3503 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
3504 else if (h
->root
.root
.type
== bfd_link_hash_defined
3505 || h
->root
.root
.type
== bfd_link_hash_defweak
)
3507 if (h
->esym
.asym
.sc
== scCommon
)
3508 h
->esym
.asym
.sc
= scBss
;
3509 else if (h
->esym
.asym
.sc
== scSCommon
)
3510 h
->esym
.asym
.sc
= scSBss
;
3512 sec
= h
->root
.root
.u
.def
.section
;
3513 output_section
= sec
->output_section
;
3514 if (output_section
!= NULL
)
3515 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
3516 + sec
->output_offset
3517 + output_section
->vma
);
3519 h
->esym
.asym
.value
= 0;
3521 else if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
3523 /* Set type and value for a symbol with a function stub. */
3524 h
->esym
.asym
.st
= stProc
;
3525 sec
= h
->root
.root
.u
.def
.section
;
3527 h
->esym
.asym
.value
= 0;
3530 output_section
= sec
->output_section
;
3531 if (output_section
!= NULL
)
3532 h
->esym
.asym
.value
= (h
->root
.plt_offset
3533 + sec
->output_offset
3534 + output_section
->vma
);
3536 h
->esym
.asym
.value
= 0;
3543 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
3544 h
->root
.root
.root
.string
,
3547 einfo
->failed
= true;
3554 /* Create a runtime procedure table from the .mdebug section. */
3557 mips_elf_create_procedure_table (handle
, abfd
, info
, s
, debug
)
3560 struct bfd_link_info
*info
;
3562 struct ecoff_debug_info
*debug
;
3564 const struct ecoff_debug_swap
*swap
;
3565 HDRR
*hdr
= &debug
->symbolic_header
;
3567 struct rpdr_ext
*erp
;
3569 struct pdr_ext
*epdr
;
3570 struct sym_ext
*esym
;
3573 unsigned long size
, count
;
3574 unsigned long sindex
;
3578 const char *no_name_func
= "static procedure (no name)";
3586 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
3588 sindex
= strlen (no_name_func
) + 1;
3589 count
= hdr
->ipdMax
;
3592 size
= swap
->external_pdr_size
;
3594 epdr
= (struct pdr_ext
*) bfd_malloc (size
* count
);
3598 if (! _bfd_ecoff_get_accumulated_pdr (handle
, (PTR
) epdr
))
3601 size
= sizeof (RPDR
);
3602 rp
= rpdr
= (RPDR
*) bfd_malloc (size
* count
);
3606 sv
= (char **) bfd_malloc (sizeof (char *) * count
);
3610 count
= hdr
->isymMax
;
3611 size
= swap
->external_sym_size
;
3612 esym
= (struct sym_ext
*) bfd_malloc (size
* count
);
3616 if (! _bfd_ecoff_get_accumulated_sym (handle
, (PTR
) esym
))
3619 count
= hdr
->issMax
;
3620 ss
= (char *) bfd_malloc (count
);
3623 if (! _bfd_ecoff_get_accumulated_ss (handle
, (PTR
) ss
))
3626 count
= hdr
->ipdMax
;
3627 for (i
= 0; i
< count
; i
++, rp
++)
3629 (*swap
->swap_pdr_in
) (abfd
, (PTR
) (epdr
+ i
), &pdr
);
3630 (*swap
->swap_sym_in
) (abfd
, (PTR
) &esym
[pdr
.isym
], &sym
);
3631 rp
->adr
= sym
.value
;
3632 rp
->regmask
= pdr
.regmask
;
3633 rp
->regoffset
= pdr
.regoffset
;
3634 rp
->fregmask
= pdr
.fregmask
;
3635 rp
->fregoffset
= pdr
.fregoffset
;
3636 rp
->frameoffset
= pdr
.frameoffset
;
3637 rp
->framereg
= pdr
.framereg
;
3638 rp
->pcreg
= pdr
.pcreg
;
3640 sv
[i
] = ss
+ sym
.iss
;
3641 sindex
+= strlen (sv
[i
]) + 1;
3645 size
= sizeof (struct rpdr_ext
) * (count
+ 2) + sindex
;
3646 size
= BFD_ALIGN (size
, 16);
3647 rtproc
= (PTR
) bfd_alloc (abfd
, size
);
3650 mips_elf_hash_table (info
)->procedure_count
= 0;
3654 mips_elf_hash_table (info
)->procedure_count
= count
+ 2;
3656 erp
= (struct rpdr_ext
*) rtproc
;
3657 memset (erp
, 0, sizeof (struct rpdr_ext
));
3659 str
= (char *) rtproc
+ sizeof (struct rpdr_ext
) * (count
+ 2);
3660 strcpy (str
, no_name_func
);
3661 str
+= strlen (no_name_func
) + 1;
3662 for (i
= 0; i
< count
; i
++)
3664 ecoff_swap_rpdr_out (abfd
, rpdr
+ i
, erp
+ i
);
3665 strcpy (str
, sv
[i
]);
3666 str
+= strlen (sv
[i
]) + 1;
3668 ecoff_put_off (abfd
, (bfd_vma
) -1, (bfd_byte
*) (erp
+ count
)->p_adr
);
3670 /* Set the size and contents of .rtproc section. */
3671 s
->_raw_size
= size
;
3672 s
->contents
= rtproc
;
3674 /* Skip this section later on (I don't think this currently
3675 matters, but someday it might). */
3676 s
->link_order_head
= (struct bfd_link_order
*) NULL
;
3705 /* A comparison routine used to sort .gptab entries. */
3708 gptab_compare (p1
, p2
)
3712 const Elf32_gptab
*a1
= (const Elf32_gptab
*) p1
;
3713 const Elf32_gptab
*a2
= (const Elf32_gptab
*) p2
;
3715 return a1
->gt_entry
.gt_g_value
- a2
->gt_entry
.gt_g_value
;
3718 /* We need to use a special link routine to handle the .reginfo and
3719 the .mdebug sections. We need to merge all instances of these
3720 sections together, not write them all out sequentially. */
3723 mips_elf_final_link (abfd
, info
)
3725 struct bfd_link_info
*info
;
3729 struct bfd_link_order
*p
;
3730 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
3731 asection
*rtproc_sec
;
3732 Elf32_RegInfo reginfo
;
3733 struct ecoff_debug_info debug
;
3734 const struct ecoff_debug_swap
*swap
3735 = get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
3736 HDRR
*symhdr
= &debug
.symbolic_header
;
3737 PTR mdebug_handle
= NULL
;
3739 /* Drop the .options section, since it has special semantics which I
3740 haven't bothered to figure out. */
3741 for (secpp
= &abfd
->sections
; *secpp
!= NULL
; secpp
= &(*secpp
)->next
)
3743 if (strcmp ((*secpp
)->name
, ".options") == 0)
3745 for (p
= (*secpp
)->link_order_head
; p
!= NULL
; p
= p
->next
)
3746 if (p
->type
== bfd_indirect_link_order
)
3747 p
->u
.indirect
.section
->flags
&=~ SEC_HAS_CONTENTS
;
3748 (*secpp
)->link_order_head
= NULL
;
3749 *secpp
= (*secpp
)->next
;
3750 --abfd
->section_count
;
3755 /* Get a value for the GP register. */
3756 if (elf_gp (abfd
) == 0)
3758 struct bfd_link_hash_entry
*h
;
3760 h
= bfd_link_hash_lookup (info
->hash
, "_gp", false, false, true);
3761 if (h
!= (struct bfd_link_hash_entry
*) NULL
3762 && h
->type
== bfd_link_hash_defined
)
3763 elf_gp (abfd
) = (h
->u
.def
.value
3764 + h
->u
.def
.section
->output_section
->vma
3765 + h
->u
.def
.section
->output_offset
);
3766 else if (info
->relocateable
)
3770 /* Make up a value. */
3772 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
3775 && (strcmp (o
->name
, ".sbss") == 0
3776 || strcmp (o
->name
, ".sdata") == 0
3777 || strcmp (o
->name
, ".lit4") == 0
3778 || strcmp (o
->name
, ".lit8") == 0))
3781 elf_gp (abfd
) = lo
+ ELF_MIPS_GP_OFFSET (abfd
);
3785 /* If the relocate_section function needs to do a reloc
3786 involving the GP value, it should make a reloc_dangerous
3787 callback to warn that GP is not defined. */
3791 /* Go through the sections and collect the .reginfo and .mdebug
3795 gptab_data_sec
= NULL
;
3796 gptab_bss_sec
= NULL
;
3797 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
3799 if (strcmp (o
->name
, ".reginfo") == 0)
3801 memset (®info
, 0, sizeof reginfo
);
3803 /* We have found the .reginfo section in the output file.
3804 Look through all the link_orders comprising it and merge
3805 the information together. */
3806 for (p
= o
->link_order_head
;
3807 p
!= (struct bfd_link_order
*) NULL
;
3810 asection
*input_section
;
3812 Elf32_External_RegInfo ext
;
3815 if (p
->type
!= bfd_indirect_link_order
)
3817 if (p
->type
== bfd_fill_link_order
)
3822 input_section
= p
->u
.indirect
.section
;
3823 input_bfd
= input_section
->owner
;
3825 /* The linker emulation code has probably clobbered the
3826 size to be zero bytes. */
3827 if (input_section
->_raw_size
== 0)
3828 input_section
->_raw_size
= sizeof (Elf32_External_RegInfo
);
3830 if (! bfd_get_section_contents (input_bfd
, input_section
,
3836 bfd_mips_elf32_swap_reginfo_in (input_bfd
, &ext
, &sub
);
3838 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
3839 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
3840 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
3841 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
3842 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
3844 /* ri_gp_value is set by the function
3845 mips_elf32_section_processing when the section is
3846 finally written out. */
3848 /* Hack: reset the SEC_HAS_CONTENTS flag so that
3849 elf_link_input_bfd ignores this section. */
3850 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
3853 /* Force the section size to the value we want. */
3854 o
->_raw_size
= sizeof (Elf32_External_RegInfo
);
3856 /* Skip this section later on (I don't think this currently
3857 matters, but someday it might). */
3858 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
3863 if (strcmp (o
->name
, ".mdebug") == 0)
3865 struct extsym_info einfo
;
3867 /* We have found the .mdebug section in the output file.
3868 Look through all the link_orders comprising it and merge
3869 the information together. */
3870 symhdr
->magic
= swap
->sym_magic
;
3871 /* FIXME: What should the version stamp be? */
3873 symhdr
->ilineMax
= 0;
3877 symhdr
->isymMax
= 0;
3878 symhdr
->ioptMax
= 0;
3879 symhdr
->iauxMax
= 0;
3881 symhdr
->issExtMax
= 0;
3884 symhdr
->iextMax
= 0;
3886 /* We accumulate the debugging information itself in the
3887 debug_info structure. */
3889 debug
.external_dnr
= NULL
;
3890 debug
.external_pdr
= NULL
;
3891 debug
.external_sym
= NULL
;
3892 debug
.external_opt
= NULL
;
3893 debug
.external_aux
= NULL
;
3895 debug
.ssext
= debug
.ssext_end
= NULL
;
3896 debug
.external_fdr
= NULL
;
3897 debug
.external_rfd
= NULL
;
3898 debug
.external_ext
= debug
.external_ext_end
= NULL
;
3900 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
3901 if (mdebug_handle
== (PTR
) NULL
)
3904 if (SGI_COMPAT (abfd
))
3910 static const char * const name
[] =
3911 { ".text", ".init", ".fini", ".data",
3912 ".rodata", ".sdata", ".sbss", ".bss" };
3913 static const int sc
[] = { scText
, scInit
, scFini
, scData
,
3914 scRData
, scSData
, scSBss
, scBss
};
3917 esym
.cobol_main
= 0;
3921 esym
.asym
.iss
= issNil
;
3922 esym
.asym
.st
= stLocal
;
3923 esym
.asym
.reserved
= 0;
3924 esym
.asym
.index
= indexNil
;
3925 for (i
= 0; i
< 8; i
++)
3927 esym
.asym
.sc
= sc
[i
];
3928 s
= bfd_get_section_by_name (abfd
, name
[i
]);
3931 esym
.asym
.value
= s
->vma
;
3932 last
= s
->vma
+ s
->_raw_size
;
3935 esym
.asym
.value
= last
;
3937 if (! bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
3943 for (p
= o
->link_order_head
;
3944 p
!= (struct bfd_link_order
*) NULL
;
3947 asection
*input_section
;
3949 const struct ecoff_debug_swap
*input_swap
;
3950 struct ecoff_debug_info input_debug
;
3954 if (p
->type
!= bfd_indirect_link_order
)
3956 if (p
->type
== bfd_fill_link_order
)
3961 input_section
= p
->u
.indirect
.section
;
3962 input_bfd
= input_section
->owner
;
3964 if (bfd_get_flavour (input_bfd
) != bfd_target_elf_flavour
3965 || (get_elf_backend_data (input_bfd
)
3966 ->elf_backend_ecoff_debug_swap
) == NULL
)
3968 /* I don't know what a non MIPS ELF bfd would be
3969 doing with a .mdebug section, but I don't really
3970 want to deal with it. */
3974 input_swap
= (get_elf_backend_data (input_bfd
)
3975 ->elf_backend_ecoff_debug_swap
);
3977 BFD_ASSERT (p
->size
== input_section
->_raw_size
);
3979 /* The ECOFF linking code expects that we have already
3980 read in the debugging information and set up an
3981 ecoff_debug_info structure, so we do that now. */
3982 if (! _bfd_mips_elf_read_ecoff_info (input_bfd
, input_section
,
3986 if (! (bfd_ecoff_debug_accumulate
3987 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
3988 &input_debug
, input_swap
, info
)))
3991 /* Loop through the external symbols. For each one with
3992 interesting information, try to find the symbol in
3993 the linker global hash table and save the information
3994 for the output external symbols. */
3995 eraw_src
= input_debug
.external_ext
;
3996 eraw_end
= (eraw_src
3997 + (input_debug
.symbolic_header
.iextMax
3998 * input_swap
->external_ext_size
));
4000 eraw_src
< eraw_end
;
4001 eraw_src
+= input_swap
->external_ext_size
)
4005 struct mips_elf_link_hash_entry
*h
;
4007 (*input_swap
->swap_ext_in
) (input_bfd
, (PTR
) eraw_src
, &ext
);
4008 if (ext
.asym
.sc
== scNil
4009 || ext
.asym
.sc
== scUndefined
4010 || ext
.asym
.sc
== scSUndefined
)
4013 name
= input_debug
.ssext
+ ext
.asym
.iss
;
4014 h
= mips_elf_link_hash_lookup (mips_elf_hash_table (info
),
4015 name
, false, false, true);
4016 if (h
== NULL
|| h
->esym
.ifd
!= -2)
4022 < input_debug
.symbolic_header
.ifdMax
);
4023 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
4029 /* Free up the information we just read. */
4030 free (input_debug
.line
);
4031 free (input_debug
.external_dnr
);
4032 free (input_debug
.external_pdr
);
4033 free (input_debug
.external_sym
);
4034 free (input_debug
.external_opt
);
4035 free (input_debug
.external_aux
);
4036 free (input_debug
.ss
);
4037 free (input_debug
.ssext
);
4038 free (input_debug
.external_fdr
);
4039 free (input_debug
.external_rfd
);
4040 free (input_debug
.external_ext
);
4042 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4043 elf_link_input_bfd ignores this section. */
4044 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
4047 if (SGI_COMPAT (abfd
) && info
->shared
)
4049 /* Create .rtproc section. */
4050 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
4051 if (rtproc_sec
== NULL
)
4053 flagword flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
4054 | SEC_LINKER_CREATED
| SEC_READONLY
);
4056 rtproc_sec
= bfd_make_section (abfd
, ".rtproc");
4057 if (rtproc_sec
== NULL
4058 || ! bfd_set_section_flags (abfd
, rtproc_sec
, flags
)
4059 || ! bfd_set_section_alignment (abfd
, rtproc_sec
, 4))
4063 if (! mips_elf_create_procedure_table (mdebug_handle
, abfd
,
4064 info
, rtproc_sec
, &debug
))
4068 /* Build the external symbol information. */
4071 einfo
.debug
= &debug
;
4073 einfo
.failed
= false;
4074 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
4075 mips_elf_output_extsym
,
4080 /* Set the size of the .mdebug section. */
4081 o
->_raw_size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
4083 /* Skip this section later on (I don't think this currently
4084 matters, but someday it might). */
4085 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
4090 if (strncmp (o
->name
, ".gptab.", sizeof ".gptab." - 1) == 0)
4092 const char *subname
;
4095 Elf32_External_gptab
*ext_tab
;
4098 /* The .gptab.sdata and .gptab.sbss sections hold
4099 information describing how the small data area would
4100 change depending upon the -G switch. These sections
4101 not used in executables files. */
4102 if (! info
->relocateable
)
4106 for (p
= o
->link_order_head
;
4107 p
!= (struct bfd_link_order
*) NULL
;
4110 asection
*input_section
;
4112 if (p
->type
!= bfd_indirect_link_order
)
4114 if (p
->type
== bfd_fill_link_order
)
4119 input_section
= p
->u
.indirect
.section
;
4121 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4122 elf_link_input_bfd ignores this section. */
4123 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
4126 /* Skip this section later on (I don't think this
4127 currently matters, but someday it might). */
4128 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
4130 /* Really remove the section. */
4131 for (secpp
= &abfd
->sections
;
4133 secpp
= &(*secpp
)->next
)
4135 *secpp
= (*secpp
)->next
;
4136 --abfd
->section_count
;
4141 /* There is one gptab for initialized data, and one for
4142 uninitialized data. */
4143 if (strcmp (o
->name
, ".gptab.sdata") == 0)
4145 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
4149 (*_bfd_error_handler
)
4150 ("%s: illegal section name `%s'",
4151 bfd_get_filename (abfd
), o
->name
);
4152 bfd_set_error (bfd_error_nonrepresentable_section
);
4156 /* The linker script always combines .gptab.data and
4157 .gptab.sdata into .gptab.sdata, and likewise for
4158 .gptab.bss and .gptab.sbss. It is possible that there is
4159 no .sdata or .sbss section in the output file, in which
4160 case we must change the name of the output section. */
4161 subname
= o
->name
+ sizeof ".gptab" - 1;
4162 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
4164 if (o
== gptab_data_sec
)
4165 o
->name
= ".gptab.data";
4167 o
->name
= ".gptab.bss";
4168 subname
= o
->name
+ sizeof ".gptab" - 1;
4169 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
4172 /* Set up the first entry. */
4174 tab
= (Elf32_gptab
*) bfd_malloc (c
* sizeof (Elf32_gptab
));
4177 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
4178 tab
[0].gt_header
.gt_unused
= 0;
4180 /* Combine the input sections. */
4181 for (p
= o
->link_order_head
;
4182 p
!= (struct bfd_link_order
*) NULL
;
4185 asection
*input_section
;
4189 bfd_size_type gpentry
;
4191 if (p
->type
!= bfd_indirect_link_order
)
4193 if (p
->type
== bfd_fill_link_order
)
4198 input_section
= p
->u
.indirect
.section
;
4199 input_bfd
= input_section
->owner
;
4201 /* Combine the gptab entries for this input section one
4202 by one. We know that the input gptab entries are
4203 sorted by ascending -G value. */
4204 size
= bfd_section_size (input_bfd
, input_section
);
4206 for (gpentry
= sizeof (Elf32_External_gptab
);
4208 gpentry
+= sizeof (Elf32_External_gptab
))
4210 Elf32_External_gptab ext_gptab
;
4211 Elf32_gptab int_gptab
;
4217 if (! (bfd_get_section_contents
4218 (input_bfd
, input_section
, (PTR
) &ext_gptab
,
4219 gpentry
, sizeof (Elf32_External_gptab
))))
4225 bfd_mips_elf32_swap_gptab_in (input_bfd
, &ext_gptab
,
4227 val
= int_gptab
.gt_entry
.gt_g_value
;
4228 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
4231 for (look
= 1; look
< c
; look
++)
4233 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
4234 tab
[look
].gt_entry
.gt_bytes
+= add
;
4236 if (tab
[look
].gt_entry
.gt_g_value
== val
)
4242 Elf32_gptab
*new_tab
;
4245 /* We need a new table entry. */
4246 new_tab
= ((Elf32_gptab
*)
4247 bfd_realloc ((PTR
) tab
,
4248 (c
+ 1) * sizeof (Elf32_gptab
)));
4249 if (new_tab
== NULL
)
4255 tab
[c
].gt_entry
.gt_g_value
= val
;
4256 tab
[c
].gt_entry
.gt_bytes
= add
;
4258 /* Merge in the size for the next smallest -G
4259 value, since that will be implied by this new
4262 for (look
= 1; look
< c
; look
++)
4264 if (tab
[look
].gt_entry
.gt_g_value
< val
4266 || (tab
[look
].gt_entry
.gt_g_value
4267 > tab
[max
].gt_entry
.gt_g_value
)))
4271 tab
[c
].gt_entry
.gt_bytes
+=
4272 tab
[max
].gt_entry
.gt_bytes
;
4277 last
= int_gptab
.gt_entry
.gt_bytes
;
4280 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4281 elf_link_input_bfd ignores this section. */
4282 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
4285 /* The table must be sorted by -G value. */
4287 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
4289 /* Swap out the table. */
4290 ext_tab
= ((Elf32_External_gptab
*)
4291 bfd_alloc (abfd
, c
* sizeof (Elf32_External_gptab
)));
4292 if (ext_tab
== NULL
)
4298 for (i
= 0; i
< c
; i
++)
4299 bfd_mips_elf32_swap_gptab_out (abfd
, tab
+ i
, ext_tab
+ i
);
4302 o
->_raw_size
= c
* sizeof (Elf32_External_gptab
);
4303 o
->contents
= (bfd_byte
*) ext_tab
;
4305 /* Skip this section later on (I don't think this currently
4306 matters, but someday it might). */
4307 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
4311 /* Invoke the regular ELF backend linker to do all the work. */
4312 if (! bfd_elf32_bfd_final_link (abfd
, info
))
4315 /* Now write out the computed sections. */
4317 if (reginfo_sec
!= (asection
*) NULL
)
4319 Elf32_External_RegInfo ext
;
4321 bfd_mips_elf32_swap_reginfo_out (abfd
, ®info
, &ext
);
4322 if (! bfd_set_section_contents (abfd
, reginfo_sec
, (PTR
) &ext
,
4323 (file_ptr
) 0, sizeof ext
))
4327 if (mdebug_sec
!= (asection
*) NULL
)
4329 BFD_ASSERT (abfd
->output_has_begun
);
4330 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
4332 mdebug_sec
->filepos
))
4335 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
4338 if (gptab_data_sec
!= (asection
*) NULL
)
4340 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
4341 gptab_data_sec
->contents
,
4343 gptab_data_sec
->_raw_size
))
4347 if (gptab_bss_sec
!= (asection
*) NULL
)
4349 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
4350 gptab_bss_sec
->contents
,
4352 gptab_bss_sec
->_raw_size
))
4356 if (SGI_COMPAT (abfd
))
4358 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
4359 if (rtproc_sec
!= NULL
)
4361 if (! bfd_set_section_contents (abfd
, rtproc_sec
,
4362 rtproc_sec
->contents
,
4364 rtproc_sec
->_raw_size
))
4372 /* Handle a MIPS ELF HI16 reloc. */
4375 mips_elf_relocate_hi16 (input_bfd
, relhi
, rello
, contents
, addend
)
4377 Elf_Internal_Rela
*relhi
;
4378 Elf_Internal_Rela
*rello
;
4385 insn
= bfd_get_32 (input_bfd
, contents
+ relhi
->r_offset
);
4387 addlo
= bfd_get_32 (input_bfd
, contents
+ rello
->r_offset
);
4390 addend
+= ((insn
& 0xffff) << 16) + addlo
;
4392 if ((addlo
& 0x8000) != 0)
4394 if ((addend
& 0x8000) != 0)
4397 bfd_put_32 (input_bfd
,
4398 (insn
& 0xffff0000) | ((addend
>> 16) & 0xffff),
4399 contents
+ relhi
->r_offset
);
4402 /* Handle a MIPS ELF local GOT16 reloc. */
4405 mips_elf_relocate_got_local (output_bfd
, input_bfd
, sgot
, relhi
, rello
,
4410 Elf_Internal_Rela
*relhi
;
4411 Elf_Internal_Rela
*rello
;
4415 unsigned int assigned_gotno
;
4421 bfd_byte
*got_contents
;
4422 struct mips_got_info
*g
;
4424 insn
= bfd_get_32 (input_bfd
, contents
+ relhi
->r_offset
);
4426 addlo
= bfd_get_32 (input_bfd
, contents
+ rello
->r_offset
);
4429 addend
+= ((insn
& 0xffff) << 16) + addlo
;
4431 if ((addlo
& 0x8000) != 0)
4433 if ((addend
& 0x8000) != 0)
4436 /* Get a got entry representing requested hipage. */
4437 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
4438 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
4439 BFD_ASSERT (g
!= NULL
);
4441 assigned_gotno
= g
->assigned_gotno
;
4442 got_contents
= sgot
->contents
;
4443 hipage
= addend
& 0xffff0000;
4445 for (i
= MIPS_RESERVED_GOTNO
; i
< assigned_gotno
; i
++)
4447 address
= bfd_get_32 (input_bfd
, got_contents
+ i
* 4);
4448 if (hipage
== (address
& 0xffff0000))
4452 if (i
== assigned_gotno
)
4454 if (assigned_gotno
>= g
->local_gotno
)
4456 (*_bfd_error_handler
)
4457 ("more got entries are needed for hipage relocations");
4458 bfd_set_error (bfd_error_bad_value
);
4462 bfd_put_32 (input_bfd
, hipage
, got_contents
+ assigned_gotno
* 4);
4463 ++g
->assigned_gotno
;
4466 i
= - ELF_MIPS_GP_OFFSET (output_bfd
) + i
* 4;
4467 bfd_put_32 (input_bfd
, (insn
& 0xffff0000) | (i
& 0xffff),
4468 contents
+ relhi
->r_offset
);
4473 /* Handle MIPS ELF CALL16 reloc and global GOT16 reloc. */
4476 mips_elf_relocate_global_got (input_bfd
, rel
, contents
, offset
)
4478 Elf_Internal_Rela
*rel
;
4484 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
4485 bfd_put_32 (input_bfd
,
4486 (insn
& 0xffff0000) | (offset
& 0xffff),
4487 contents
+ rel
->r_offset
);
4490 /* Relocate a MIPS ELF section. */
4493 mips_elf_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
4494 contents
, relocs
, local_syms
, local_sections
)
4496 struct bfd_link_info
*info
;
4498 asection
*input_section
;
4500 Elf_Internal_Rela
*relocs
;
4501 Elf_Internal_Sym
*local_syms
;
4502 asection
**local_sections
;
4504 Elf_Internal_Shdr
*symtab_hdr
;
4507 asection
*sgot
, *sreloc
, *scpt
;
4510 Elf_Internal_Rela
*rel
;
4511 Elf_Internal_Rela
*relend
;
4512 struct mips_got_info
*g
;
4514 dynobj
= elf_hash_table (info
)->dynobj
;
4515 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
4519 if (dynobj
== NULL
|| ! SGI_COMPAT (output_bfd
))
4522 scpt
= bfd_get_section_by_name (dynobj
, ".compact_rel");
4525 if (elf_bad_symtab (input_bfd
))
4527 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
4532 locsymcount
= symtab_hdr
->sh_info
;
4533 extsymoff
= symtab_hdr
->sh_info
;
4536 gp
= _bfd_get_gp_value (output_bfd
);
4539 relend
= relocs
+ input_section
->reloc_count
;
4540 for (; rel
< relend
; rel
++)
4543 reloc_howto_type
*howto
;
4544 unsigned long r_symndx
;
4546 struct elf_link_hash_entry
*h
;
4548 Elf_Internal_Sym
*sym
;
4549 struct mips_elf_link_hash_entry
*mh
;
4551 bfd_reloc_status_type r
;
4553 r_type
= ELF32_R_TYPE (rel
->r_info
);
4554 if ((r_type
< 0 || r_type
>= (int) R_MIPS_max
)
4555 && r_type
!= R_MIPS16_26
4556 && r_type
!= R_MIPS16_GPREL
)
4558 bfd_set_error (bfd_error_bad_value
);
4561 if (r_type
== R_MIPS16_26
)
4562 howto
= &elf_mips16_jump_howto
;
4563 else if (r_type
== R_MIPS16_GPREL
)
4564 howto
= &elf_mips16_gprel_howto
;
4566 howto
= elf_mips_howto_table
+ r_type
;
4569 && (r_type
== R_MIPS_CALL16
4570 || r_type
== R_MIPS_GOT16
4571 || r_type
== R_MIPS_CALL_HI16
4572 || r_type
== R_MIPS_CALL_LO16
4573 || r_type
== R_MIPS_GOT_HI16
4574 || r_type
== R_MIPS_GOT_LO16
))
4576 /* We need the .got section. */
4579 sgot
= bfd_get_section_by_name (dynobj
, ".got");
4580 BFD_ASSERT (sgot
!= NULL
);
4581 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
4582 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
4583 BFD_ASSERT (g
!= NULL
);
4587 r_symndx
= ELF32_R_SYM (rel
->r_info
);
4589 /* Mix in the change in GP address for a GP relative reloc. */
4590 if (r_type
!= R_MIPS_GPREL16
4591 && r_type
!= R_MIPS_LITERAL
4592 && r_type
!= R_MIPS_GPREL32
4593 && r_type
!= R_MIPS16_GPREL
)
4599 if (! ((*info
->callbacks
->reloc_dangerous
)
4601 "GP relative relocation when GP not defined",
4602 input_bfd
, input_section
,
4605 /* Only give the error once per link. */
4607 _bfd_set_gp_value (output_bfd
, gp
);
4610 if (r_symndx
< extsymoff
4611 || (elf_bad_symtab (input_bfd
)
4612 && local_sections
[r_symndx
] != NULL
))
4614 /* This is a relocation against a section. The current
4615 addend in the instruction is the difference between
4616 INPUT_SECTION->vma and the GP value of INPUT_BFD. We
4617 must change this to be the difference between the
4618 final definition (which will end up in RELOCATION)
4619 and the GP value of OUTPUT_BFD (which is in GP). */
4620 addend
= elf_gp (input_bfd
) - gp
;
4622 else if (! info
->relocateable
)
4624 /* We are doing a final link. The current addend in the
4625 instruction is simply the desired offset into the
4626 symbol (normally zero). We want the instruction to
4627 hold the difference between the final definition of
4628 the symbol (which will end up in RELOCATION) and the
4629 GP value of OUTPUT_BFD (which is in GP). */
4634 /* We are generating relocateable output, and we aren't
4635 going to define this symbol, so we just leave the
4636 instruction alone. */
4644 if (info
->relocateable
)
4646 /* This is a relocateable link. We don't have to change
4647 anything, unless the reloc is against a section symbol,
4648 in which case we have to adjust according to where the
4649 section symbol winds up in the output section. */
4650 if (r_symndx
>= locsymcount
4651 || (elf_bad_symtab (input_bfd
)
4652 && local_sections
[r_symndx
] == NULL
))
4656 sym
= local_syms
+ r_symndx
;
4657 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4661 sec
= local_sections
[r_symndx
];
4663 /* It would be logical to add sym->st_value here,
4664 but Irix 5 sometimes generates a garbage symbol
4666 addend
+= sec
->output_offset
;
4668 /* If this is HI16 or GOT16 with an associated LO16,
4669 adjust the addend accordingly. Otherwise, just
4671 if (r_type
== R_MIPS_64
&& bfd_big_endian (input_bfd
))
4672 r
= _bfd_relocate_contents (howto
, input_bfd
,
4674 contents
+ rel
->r_offset
+ 4);
4675 else if (r_type
!= R_MIPS_HI16
&& r_type
!= R_MIPS_GOT16
)
4676 r
= _bfd_relocate_contents (howto
, input_bfd
,
4678 contents
+ rel
->r_offset
);
4681 Elf_Internal_Rela
*lorel
;
4683 /* As a GNU extension, permit an arbitrary
4684 number of R_MIPS_HI16 relocs before the
4685 R_MIPS_LO16 reloc. This permits gcc to emit
4686 the HI and LO relocs itself. */
4687 if (r_type
== R_MIPS_GOT16
)
4691 for (lorel
= rel
+ 1;
4693 && (ELF32_R_TYPE (lorel
->r_info
)
4699 && ELF32_R_TYPE (lorel
->r_info
) == R_MIPS_LO16
)
4701 mips_elf_relocate_hi16 (input_bfd
, rel
, lorel
,
4706 r
= _bfd_relocate_contents (howto
, input_bfd
,
4708 contents
+ rel
->r_offset
);
4718 /* This is a final link. */
4720 if (r_symndx
< extsymoff
4721 || (elf_bad_symtab (input_bfd
)
4722 && local_sections
[r_symndx
] != NULL
))
4725 sym
= local_syms
+ r_symndx
;
4726 sec
= local_sections
[r_symndx
];
4727 relocation
= (sec
->output_section
->vma
4728 + sec
->output_offset
);
4730 /* It would be logical to always add sym->st_value here,
4731 but Irix 5 sometimes generates a garbage symbol
4733 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4734 relocation
+= sym
->st_value
;
4736 /* mips16 text labels should be treated as odd. */
4737 if (sym
->st_other
== STO_MIPS16
)
4745 indx
= r_symndx
- extsymoff
;
4746 h
= elf_sym_hashes (input_bfd
)[indx
];
4747 while (h
->root
.type
== bfd_link_hash_indirect
4748 || h
->root
.type
== bfd_link_hash_warning
)
4749 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4750 if (strcmp (h
->root
.root
.string
, "_gp_disp") == 0)
4754 if (! ((*info
->callbacks
->reloc_dangerous
)
4756 "_gp_disp used when GP not defined",
4757 input_bfd
, input_section
,
4760 /* Only give the error once per link. */
4762 _bfd_set_gp_value (output_bfd
, gp
);
4767 sec
= input_section
;
4768 if (sec
->output_section
!= NULL
)
4771 + sec
->output_section
->vma
4772 + sec
->output_offset
));
4774 relocation
= gp
- rel
->r_offset
;
4775 if (r_type
== R_MIPS_LO16
)
4779 else if (h
->root
.type
== bfd_link_hash_defined
4780 || h
->root
.type
== bfd_link_hash_defweak
)
4782 sec
= h
->root
.u
.def
.section
;
4783 if (sec
->output_section
== NULL
)
4786 relocation
= (h
->root
.u
.def
.value
4787 + sec
->output_section
->vma
4788 + sec
->output_offset
);
4790 else if (h
->root
.type
== bfd_link_hash_undefweak
)
4792 else if (info
->shared
&& ! info
->symbolic
)
4794 else if (strcmp (h
->root
.root
.string
, "_DYNAMIC_LINK") == 0)
4796 /* If this is a dynamic link, we should have created
4797 a _DYNAMIC_LINK symbol in
4798 mips_elf_create_dynamic_sections. Otherwise, we
4799 should define the symbol with a value of 0.
4800 FIXME: It should probably get into the symbol
4801 table somehow as well. */
4802 BFD_ASSERT (! info
->shared
);
4803 BFD_ASSERT (bfd_get_section_by_name (output_bfd
,
4804 ".dynamic") == NULL
);
4809 if (! ((*info
->callbacks
->undefined_symbol
)
4810 (info
, h
->root
.root
.string
, input_bfd
,
4811 input_section
, rel
->r_offset
)))
4817 mh
= (struct mips_elf_link_hash_entry
*) h
;
4820 else if (sym
!= NULL
)
4821 other
= sym
->st_other
;
4825 /* If this function has an fn_stub, then it is a mips16
4826 function which needs a stub if it is called by a 32 bit
4827 function. If this reloc is anything other than a 16 bit
4828 call, redirect the reloc to the stub. We don't redirect
4829 relocs from other stub functions. */
4830 if (r_type
!= R_MIPS16_26
4832 && mh
->fn_stub
!= NULL
)
4834 && elf_tdata (input_bfd
)->local_stubs
!= NULL
4835 && elf_tdata (input_bfd
)->local_stubs
[r_symndx
] != NULL
))
4836 && strncmp (bfd_get_section_name (input_bfd
, input_section
),
4837 FN_STUB
, sizeof FN_STUB
- 1) != 0
4838 && strncmp (bfd_get_section_name (input_bfd
, input_section
),
4839 CALL_STUB
, sizeof CALL_STUB
- 1) != 0
4840 && strncmp (bfd_get_section_name (input_bfd
, input_section
),
4841 CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) != 0)
4845 BFD_ASSERT (mh
->need_fn_stub
);
4846 relocation
= (mh
->fn_stub
->output_section
->vma
4847 + mh
->fn_stub
->output_offset
);
4853 fn_stub
= elf_tdata (input_bfd
)->local_stubs
[r_symndx
];
4854 relocation
= (fn_stub
->output_section
->vma
4855 + fn_stub
->output_offset
);
4858 /* RELOCATION now points to 32 bit code. */
4862 /* If this function has a call_stub, then it is called by a
4863 mips16 function; the call needs to go through a stub if
4864 this function is a 32 bit function. If this reloc is a
4865 16 bit call, and the symbol is not a 16 bit function,
4866 then redirect the reloc to the stub. Note that we don't
4867 need to worry about calling the function through a
4868 function pointer; such calls are handled by routing
4869 through a special mips16 routine. We don't have to check
4870 whether this call is from a stub; it can't be, because a
4871 stub contains 32 bit code, and hence can not have a 16
4873 if (r_type
== R_MIPS16_26
4875 && (mh
->call_stub
!= NULL
|| mh
->call_fp_stub
!= NULL
)
4876 && other
!= STO_MIPS16
)
4880 /* If both call_stub and call_fp_stub are defined, we
4881 can figure out which one to use by seeing which one
4882 appears in the input file. */
4883 if (mh
->call_stub
!= NULL
&& mh
->call_fp_stub
!= NULL
)
4888 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
4890 if (strncmp (bfd_get_section_name (input_bfd
, o
),
4891 CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
4893 stub
= mh
->call_fp_stub
;
4898 stub
= mh
->call_stub
;
4900 else if (mh
->call_stub
!= NULL
)
4901 stub
= mh
->call_stub
;
4903 stub
= mh
->call_fp_stub
;
4905 BFD_ASSERT (stub
->_raw_size
> 0);
4906 relocation
= stub
->output_section
->vma
+ stub
->output_offset
;
4909 if (r_type
== R_MIPS_HI16
)
4911 Elf_Internal_Rela
*lorel
;
4913 /* As a GNU extension, permit an arbitrary number of
4914 R_MIPS_HI16 relocs before the R_MIPS_LO16 reloc.
4915 This permits gcc to emit the HI and LO relocs itself. */
4916 for (lorel
= rel
+ 1;
4918 && ELF32_R_TYPE (lorel
->r_info
) == R_MIPS_HI16
);
4922 && ELF32_R_TYPE (lorel
->r_info
) == R_MIPS_LO16
)
4924 mips_elf_relocate_hi16 (input_bfd
, rel
, lorel
,
4925 contents
, relocation
+ addend
);
4929 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4930 contents
, rel
->r_offset
,
4931 relocation
, addend
);
4933 else if (r_type
== R_MIPS_GOT16
&& local
)
4935 /* GOT16 must also have an associated LO16 in the local
4936 case. In this case, the addend is extracted and the
4937 section in which the referenced object is determined.
4938 Then the final address of the object is computed and
4939 the GOT entry for the hipage (an aligned 64kb chunk)
4940 is added to .got section if needed. The offset field
4941 of the GOT16-relocated instruction is replaced by the
4942 index of this GOT entry for the hipage. */
4943 if ((rel
+ 1) < relend
4944 && ELF32_R_TYPE ((rel
+ 1)->r_info
) == R_MIPS_LO16
)
4946 if (! mips_elf_relocate_got_local (output_bfd
, input_bfd
,
4949 relocation
+ addend
))
4954 r
= bfd_reloc_outofrange
;
4956 else if (r_type
== R_MIPS_CALL16
4957 || r_type
== R_MIPS_GOT16
4958 || r_type
== R_MIPS_CALL_LO16
4959 || r_type
== R_MIPS_GOT_LO16
)
4963 /* This symbol must be registered as a global symbol
4964 having the corresponding got entry. */
4965 BFD_ASSERT (h
->got_offset
!= (bfd_vma
) -1);
4967 offset
= (h
->dynindx
- g
->global_gotsym
+ g
->local_gotno
) * 4;
4968 BFD_ASSERT (g
->local_gotno
<= offset
4969 && offset
< sgot
->_raw_size
);
4970 bfd_put_32 (output_bfd
, relocation
+ addend
,
4971 sgot
->contents
+ offset
);
4972 offset
= (sgot
->output_section
->vma
+ sgot
->output_offset
4974 mips_elf_relocate_global_got (input_bfd
, rel
, contents
,
4978 else if (r_type
== R_MIPS_CALL_HI16
4979 || r_type
== R_MIPS_GOT_HI16
)
4983 /* This must be a global symbol with a got entry. The
4984 next reloc must be the corresponding LO16 reloc. */
4985 BFD_ASSERT (h
!= NULL
&& h
->got_offset
!= (bfd_vma
) -1);
4986 BFD_ASSERT ((rel
+ 1) < relend
);
4987 BFD_ASSERT (ELF32_R_TYPE ((rel
+ 1)->r_info
)
4988 == (r_type
== R_MIPS_CALL_HI16
4990 : R_MIPS_GOT_LO16
));
4992 offset
= (h
->dynindx
- g
->global_gotsym
+ g
->local_gotno
) * 4;
4993 BFD_ASSERT (g
->local_gotno
<= offset
4994 && offset
< sgot
->_raw_size
);
4995 bfd_put_32 (output_bfd
, relocation
+ addend
,
4996 sgot
->contents
+ offset
);
4997 offset
= (sgot
->output_section
->vma
+ sgot
->output_offset
4999 mips_elf_relocate_hi16 (input_bfd
, rel
, rel
+ 1, contents
,
5003 else if (r_type
== R_MIPS_REL32
5004 || r_type
== R_MIPS_32
)
5006 Elf_Internal_Rel outrel
;
5007 Elf32_crinfo cptrel
;
5011 || (elf_hash_table (info
)->dynamic_sections_created
5013 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)
5015 && (input_section
->flags
& SEC_ALLOC
) != 0)
5017 /* When generating a shared object, these
5018 relocations are copied into the output file to be
5019 resolved at run time. */
5022 sreloc
= bfd_get_section_by_name (dynobj
, ".rel.dyn");
5023 BFD_ASSERT (sreloc
!= NULL
);
5026 outrel
.r_offset
= (rel
->r_offset
5027 + input_section
->output_section
->vma
5028 + input_section
->output_offset
);
5030 addend
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
5033 && (! info
->symbolic
5034 || (h
->elf_link_hash_flags
5035 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
5037 BFD_ASSERT (h
->dynindx
!= -1);
5038 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_REL32
);
5039 sec
= input_section
;
5046 sec
= local_sections
[r_symndx
];
5049 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
5051 == bfd_link_hash_defweak
));
5052 sec
= h
->root
.u
.def
.section
;
5054 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
5056 else if (sec
== NULL
|| sec
->owner
== NULL
)
5058 bfd_set_error (bfd_error_bad_value
);
5065 osec
= sec
->output_section
;
5066 indx
= elf_section_data (osec
)->dynindx
;
5071 outrel
.r_info
= ELF32_R_INFO (indx
, R_MIPS_REL32
);
5072 addend
+= relocation
;
5075 bfd_put_32 (output_bfd
, addend
, contents
+ rel
->r_offset
);
5076 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
5077 (((Elf32_External_Rel
*)
5079 + sreloc
->reloc_count
));
5080 ++sreloc
->reloc_count
;
5082 if (SGI_COMPAT (output_bfd
))
5087 /* Make an entry of compact relocation info. */
5088 mips_elf_set_cr_format (cptrel
, CRF_MIPS_LONG
);
5089 cptrel
.vaddr
= (rel
->r_offset
5090 + input_section
->output_section
->vma
5091 + input_section
->output_offset
);
5092 if (r_type
== R_MIPS_REL32
)
5093 mips_elf_set_cr_type (cptrel
, CRT_MIPS_REL32
);
5095 mips_elf_set_cr_type (cptrel
, CRT_MIPS_WORD
);
5096 mips_elf_set_cr_dist2to (cptrel
, 0);
5097 cptrel
.konst
= addend
;
5099 cr
= (scpt
->contents
5100 + sizeof (Elf32_External_compact_rel
));
5101 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
5102 ((Elf32_External_crinfo
*) cr
5103 + scpt
->reloc_count
));
5104 ++scpt
->reloc_count
;
5107 /* This reloc will be computed at runtime, so
5108 there's no need to do anything now. */
5112 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5113 contents
, rel
->r_offset
,
5114 relocation
, addend
);
5116 else if (r_type
== R_MIPS_64
)
5121 /* Do a 32 bit relocation, and sign extend to 64 bits. */
5122 addr
= rel
->r_offset
;
5123 if (bfd_big_endian (input_bfd
))
5125 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5126 contents
, addr
, relocation
,
5128 val
= bfd_get_32 (input_bfd
, contents
+ addr
);
5129 if ((val
& 0x80000000) != 0)
5133 addr
= rel
->r_offset
;
5134 if (bfd_little_endian (input_bfd
))
5136 bfd_put_32 (input_bfd
, val
, contents
+ addr
);
5138 else if (r_type
== R_MIPS_26
&& other
== STO_MIPS16
)
5142 /* This is a jump to a mips16 routine from a mips32
5143 routine. We need to change jal into jalx. */
5144 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
5145 if (((insn
>> 26) & 0x3f) != 0x3
5146 && ((insn
>> 26) & 0x3f) != 0x1d)
5148 (*_bfd_error_handler
)
5149 ("%s: %s+0x%lx: jump to mips16 routine which is not jal",
5150 bfd_get_filename (input_bfd
),
5151 input_section
->name
,
5152 (unsigned long) rel
->r_offset
);
5153 bfd_set_error (bfd_error_bad_value
);
5156 insn
= (insn
& 0x3ffffff) | (0x1d << 26);
5157 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
5158 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5159 contents
, rel
->r_offset
,
5160 relocation
, addend
);
5162 else if (r_type
== R_MIPS16_26
)
5164 /* It's easiest to do the normal relocation, and then
5165 dig out the instruction and swap the first word the
5166 way the mips16 expects it. If this is little endian,
5167 though, we need to swap the two words first, and then
5168 swap them back again later, so that the address looks
5171 if (bfd_little_endian (input_bfd
))
5175 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
5176 insn
= ((insn
>> 16) & 0xffff) | ((insn
& 0xffff) << 16);
5177 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
5180 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5181 contents
, rel
->r_offset
,
5182 relocation
, addend
);
5183 if (r
== bfd_reloc_ok
)
5187 if (bfd_little_endian (input_bfd
))
5189 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
5190 insn
= ((insn
>> 16) & 0xffff) | ((insn
& 0xffff) << 16);
5191 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
5194 insn
= bfd_get_16 (input_bfd
, contents
+ rel
->r_offset
);
5195 insn
= ((insn
& 0xfc00)
5196 | ((insn
& 0x1f) << 5)
5197 | ((insn
& 0x3e0) >> 5));
5198 /* If this is a jump to a 32 bit routine, then make
5200 if (other
!= STO_MIPS16
)
5202 bfd_put_16 (input_bfd
, insn
, contents
+ rel
->r_offset
);
5205 else if (r_type
== R_MIPS16_GPREL
)
5207 unsigned short extend
, insn
;
5209 unsigned long final
;
5211 /* Extract the addend into buf, run the regular reloc,
5212 and stuff the resulting value back into the
5214 if (rel
->r_offset
> input_section
->_raw_size
)
5215 r
= bfd_reloc_outofrange
;
5218 extend
= bfd_get_16 (input_bfd
, contents
+ rel
->r_offset
);
5219 insn
= bfd_get_16 (input_bfd
, contents
+ rel
->r_offset
+ 2);
5220 bfd_put_32 (input_bfd
,
5221 (((extend
& 0x1f) << 11)
5225 r
= _bfd_final_link_relocate (howto
, input_bfd
,
5227 (bfd_vma
) 0, relocation
,
5229 final
= bfd_get_32 (input_bfd
, buf
);
5230 bfd_put_16 (input_bfd
,
5232 | ((final
>> 11) & 0x1f)
5234 contents
+ rel
->r_offset
);
5235 bfd_put_16 (input_bfd
,
5238 contents
+ rel
->r_offset
+ 2);
5242 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5243 contents
, rel
->r_offset
,
5244 relocation
, addend
);
5246 /* The jal instruction can only jump to an address which is
5247 divisible by 4, and it can only jump to an address with
5248 the same upper 4 bits as the PC. */
5249 if (r
== bfd_reloc_ok
5250 && (r_type
== R_MIPS16_26
|| r_type
== R_MIPS_26
))
5255 if (other
== STO_MIPS16
)
5256 addr
&= ~ (bfd_vma
) 1;
5259 || ((addr
& 0xf0000000)
5260 != ((input_section
->output_section
->vma
5261 + input_section
->output_offset
5264 r
= bfd_reloc_overflow
;
5267 if (SGI_COMPAT (abfd
)
5269 && (input_section
->flags
& SEC_ALLOC
) != 0)
5271 Elf32_crinfo cptrel
;
5274 /* Make an entry of compact relocation info. */
5275 mips_elf_set_cr_format (cptrel
, CRF_MIPS_LONG
);
5276 cptrel
.vaddr
= (rel
->r_offset
5277 + input_section
->output_section
->vma
5278 + input_section
->output_offset
);
5283 mips_elf_set_cr_type (cptrel
, CRT_MIPS_JMPAD
);
5284 /* XXX How should we set dist2to in this case. */
5285 mips_elf_set_cr_dist2to (cptrel
, 8);
5286 cptrel
.konst
= addend
+ relocation
;
5287 cr
= scpt
->contents
+ sizeof (Elf32_External_compact_rel
);
5288 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
5289 ((Elf32_External_crinfo
*) cr
5290 + scpt
->reloc_count
));
5291 ++scpt
->reloc_count
;
5294 case R_MIPS_GPREL16
:
5295 case R_MIPS_LITERAL
:
5296 case R_MIPS_GPREL32
:
5297 mips_elf_set_cr_type (cptrel
, CRT_MIPS_GPHI_LO
);
5298 cptrel
.konst
= gp
- cptrel
.vaddr
;
5299 mips_elf_set_cr_dist2to (cptrel
, 4);
5300 cr
= scpt
->contents
+ sizeof (Elf32_External_compact_rel
);
5301 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
5302 ((Elf32_External_crinfo
*) cr
5303 + scpt
->reloc_count
));
5304 ++scpt
->reloc_count
;
5313 if (r
!= bfd_reloc_ok
)
5318 case bfd_reloc_outofrange
:
5320 case bfd_reloc_overflow
:
5325 name
= h
->root
.root
.string
;
5328 name
= bfd_elf_string_from_elf_section (input_bfd
,
5329 symtab_hdr
->sh_link
,
5334 name
= bfd_section_name (input_bfd
, sec
);
5336 if (! ((*info
->callbacks
->reloc_overflow
)
5337 (info
, name
, howto
->name
, (bfd_vma
) 0,
5338 input_bfd
, input_section
, rel
->r_offset
)))
5349 /* This hook function is called before the linker writes out a global
5350 symbol. This is where we undo the increment of the value for a
5355 mips_elf_link_output_symbol_hook (abfd
, info
, name
, sym
, input_sec
)
5357 struct bfd_link_info
*info
;
5359 Elf_Internal_Sym
*sym
;
5360 asection
*input_sec
;
5362 if (sym
->st_other
== STO_MIPS16
5363 && (sym
->st_value
& 1) != 0)
5368 /* Functions for the dynamic linker. */
5370 /* The name of the dynamic interpreter. This is put in the .interp
5373 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
5375 /* Create dynamic sections when linking against a dynamic object. */
5378 mips_elf_create_dynamic_sections (abfd
, info
)
5380 struct bfd_link_info
*info
;
5382 struct elf_link_hash_entry
*h
;
5384 register asection
*s
;
5385 const char * const *namep
;
5387 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
5388 | SEC_LINKER_CREATED
| SEC_READONLY
);
5390 /* Mips ABI requests the .dynamic section to be read only. */
5391 s
= bfd_get_section_by_name (abfd
, ".dynamic");
5394 if (! bfd_set_section_flags (abfd
, s
, flags
))
5398 /* We need to create .got section. */
5399 if (! mips_elf_create_got_section (abfd
, info
))
5402 /* Create .stub section. */
5403 if (bfd_get_section_by_name (abfd
, ".stub") == NULL
)
5405 s
= bfd_make_section (abfd
, ".stub");
5407 || ! bfd_set_section_flags (abfd
, s
, flags
)
5408 || ! bfd_set_section_alignment (abfd
, s
, 2))
5412 if (SGI_COMPAT (abfd
)
5414 && bfd_get_section_by_name (abfd
, ".rld_map") == NULL
)
5416 s
= bfd_make_section (abfd
, ".rld_map");
5418 || ! bfd_set_section_flags (abfd
, s
, flags
& ~SEC_READONLY
)
5419 || ! bfd_set_section_alignment (abfd
, s
, 2))
5423 if (SGI_COMPAT (abfd
))
5425 for (namep
= mips_elf_dynsym_rtproc_names
; *namep
!= NULL
; namep
++)
5428 if (! (_bfd_generic_link_add_one_symbol
5429 (info
, abfd
, *namep
, BSF_GLOBAL
, bfd_und_section_ptr
,
5430 (bfd_vma
) 0, (const char *) NULL
, false,
5431 get_elf_backend_data (abfd
)->collect
,
5432 (struct bfd_link_hash_entry
**) &h
)))
5434 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
5435 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
5436 h
->type
= STT_SECTION
;
5438 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
5442 /* We need to create a .compact_rel section. */
5443 if (! mips_elf_create_compact_rel_section (abfd
, info
))
5446 /* Change aligments of some sections. */
5447 s
= bfd_get_section_by_name (abfd
, ".hash");
5449 bfd_set_section_alignment (abfd
, s
, 4);
5450 s
= bfd_get_section_by_name (abfd
, ".dynsym");
5452 bfd_set_section_alignment (abfd
, s
, 4);
5453 s
= bfd_get_section_by_name (abfd
, ".dynstr");
5455 bfd_set_section_alignment (abfd
, s
, 4);
5456 s
= bfd_get_section_by_name (abfd
, ".reginfo");
5458 bfd_set_section_alignment (abfd
, s
, 4);
5459 s
= bfd_get_section_by_name (abfd
, ".dynamic");
5461 bfd_set_section_alignment (abfd
, s
, 4);
5467 if (! (_bfd_generic_link_add_one_symbol
5468 (info
, abfd
, "_DYNAMIC_LINK", BSF_GLOBAL
, bfd_abs_section_ptr
,
5469 (bfd_vma
) 0, (const char *) NULL
, false,
5470 get_elf_backend_data (abfd
)->collect
,
5471 (struct bfd_link_hash_entry
**) &h
)))
5473 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
5474 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
5475 h
->type
= STT_SECTION
;
5477 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
5480 if (! mips_elf_hash_table (info
)->use_rld_obj_head
)
5482 /* __rld_map is a four byte word located in the .data section
5483 and is filled in by the rtld to contain a pointer to
5484 the _r_debug structure. Its symbol value will be set in
5485 mips_elf_finish_dynamic_symbol. */
5486 s
= bfd_get_section_by_name (abfd
, ".rld_map");
5487 BFD_ASSERT (s
!= NULL
);
5490 if (! (_bfd_generic_link_add_one_symbol
5491 (info
, abfd
, "__rld_map", BSF_GLOBAL
, s
,
5492 (bfd_vma
) 0, (const char *) NULL
, false,
5493 get_elf_backend_data (abfd
)->collect
,
5494 (struct bfd_link_hash_entry
**) &h
)))
5496 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
5497 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
5498 h
->type
= STT_OBJECT
;
5500 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
5508 /* Create the .compact_rel section. */
5511 mips_elf_create_compact_rel_section (abfd
, info
)
5513 struct bfd_link_info
*info
;
5516 register asection
*s
;
5518 if (bfd_get_section_by_name (abfd
, ".compact_rel") == NULL
)
5520 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
5523 s
= bfd_make_section (abfd
, ".compact_rel");
5525 || ! bfd_set_section_flags (abfd
, s
, flags
)
5526 || ! bfd_set_section_alignment (abfd
, s
, 2))
5529 s
->_raw_size
= sizeof (Elf32_External_compact_rel
);
5535 /* Create the .got section to hold the global offset table. */
5538 mips_elf_create_got_section (abfd
, info
)
5540 struct bfd_link_info
*info
;
5543 register asection
*s
;
5544 struct elf_link_hash_entry
*h
;
5545 struct mips_got_info
*g
;
5547 /* This function may be called more than once. */
5548 if (bfd_get_section_by_name (abfd
, ".got") != NULL
)
5551 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
5552 | SEC_LINKER_CREATED
);
5554 s
= bfd_make_section (abfd
, ".got");
5556 || ! bfd_set_section_flags (abfd
, s
, flags
)
5557 || ! bfd_set_section_alignment (abfd
, s
, 4))
5560 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
5561 linker script because we don't want to define the symbol if we
5562 are not creating a global offset table. */
5564 if (! (_bfd_generic_link_add_one_symbol
5565 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
5566 (bfd_vma
) 0, (const char *) NULL
, false,
5567 get_elf_backend_data (abfd
)->collect
,
5568 (struct bfd_link_hash_entry
**) &h
)))
5570 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
5571 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
5572 h
->type
= STT_OBJECT
;
5575 && ! bfd_elf32_link_record_dynamic_symbol (info
, h
))
5578 /* The first several global offset table entries are reserved. */
5579 s
->_raw_size
= MIPS_RESERVED_GOTNO
* 4;
5581 g
= (struct mips_got_info
*) bfd_alloc (abfd
,
5582 sizeof (struct mips_got_info
));
5585 g
->global_gotsym
= 0;
5586 g
->local_gotno
= MIPS_RESERVED_GOTNO
;
5587 g
->assigned_gotno
= MIPS_RESERVED_GOTNO
;
5588 if (elf_section_data (s
) == NULL
)
5591 (PTR
) bfd_zalloc (abfd
, sizeof (struct bfd_elf_section_data
));
5592 if (elf_section_data (s
) == NULL
)
5595 elf_section_data (s
)->tdata
= (PTR
) g
;
5600 /* Look through the relocs for a section during the first phase, and
5601 allocate space in the global offset table. */
5604 mips_elf_check_relocs (abfd
, info
, sec
, relocs
)
5606 struct bfd_link_info
*info
;
5608 const Elf_Internal_Rela
*relocs
;
5612 Elf_Internal_Shdr
*symtab_hdr
;
5613 struct elf_link_hash_entry
**sym_hashes
;
5614 struct mips_got_info
*g
;
5616 const Elf_Internal_Rela
*rel
;
5617 const Elf_Internal_Rela
*rel_end
;
5621 if (info
->relocateable
)
5624 dynobj
= elf_hash_table (info
)->dynobj
;
5625 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5626 sym_hashes
= elf_sym_hashes (abfd
);
5627 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
5629 /* Check for the mips16 stub sections. */
5631 name
= bfd_get_section_name (abfd
, sec
);
5632 if (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0)
5634 unsigned long r_symndx
;
5636 /* Look at the relocation information to figure out which symbol
5639 r_symndx
= ELF32_R_SYM (relocs
->r_info
);
5641 if (r_symndx
< extsymoff
5642 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
5646 /* This stub is for a local symbol. This stub will only be
5647 needed if there is some relocation in this BFD, other
5648 than a 16 bit function call, which refers to this symbol. */
5649 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5651 Elf_Internal_Rela
*sec_relocs
;
5652 const Elf_Internal_Rela
*r
, *rend
;
5654 /* We can ignore stub sections when looking for relocs. */
5655 if ((o
->flags
& SEC_RELOC
) == 0
5656 || o
->reloc_count
== 0
5657 || strncmp (bfd_get_section_name (abfd
, o
), FN_STUB
,
5658 sizeof FN_STUB
- 1) == 0
5659 || strncmp (bfd_get_section_name (abfd
, o
), CALL_STUB
,
5660 sizeof CALL_STUB
- 1) == 0
5661 || strncmp (bfd_get_section_name (abfd
, o
), CALL_FP_STUB
,
5662 sizeof CALL_FP_STUB
- 1) == 0)
5665 sec_relocs
= (_bfd_elf32_link_read_relocs
5666 (abfd
, o
, (PTR
) NULL
,
5667 (Elf_Internal_Rela
*) NULL
,
5668 info
->keep_memory
));
5669 if (sec_relocs
== NULL
)
5672 rend
= sec_relocs
+ o
->reloc_count
;
5673 for (r
= sec_relocs
; r
< rend
; r
++)
5674 if (ELF32_R_SYM (r
->r_info
) == r_symndx
5675 && ELF32_R_TYPE (r
->r_info
) != R_MIPS16_26
)
5678 if (! info
->keep_memory
)
5687 /* There is no non-call reloc for this stub, so we do
5688 not need it. Since this function is called before
5689 the linker maps input sections to output sections, we
5690 can easily discard it by setting the SEC_EXCLUDE
5692 sec
->flags
|= SEC_EXCLUDE
;
5696 /* Record this stub in an array of local symbol stubs for
5698 if (elf_tdata (abfd
)->local_stubs
== NULL
)
5700 unsigned long symcount
;
5703 if (elf_bad_symtab (abfd
))
5704 symcount
= symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
5706 symcount
= symtab_hdr
->sh_info
;
5707 n
= (asection
**) bfd_zalloc (abfd
,
5708 symcount
* sizeof (asection
*));
5711 elf_tdata (abfd
)->local_stubs
= n
;
5714 elf_tdata (abfd
)->local_stubs
[r_symndx
] = sec
;
5716 /* We don't need to set mips16_stubs_seen in this case.
5717 That flag is used to see whether we need to look through
5718 the global symbol table for stubs. We don't need to set
5719 it here, because we just have a local stub. */
5723 struct mips_elf_link_hash_entry
*h
;
5725 h
= ((struct mips_elf_link_hash_entry
*)
5726 sym_hashes
[r_symndx
- extsymoff
]);
5728 /* H is the symbol this stub is for. */
5731 mips_elf_hash_table (info
)->mips16_stubs_seen
= true;
5734 else if (strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
5735 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
5737 unsigned long r_symndx
;
5738 struct mips_elf_link_hash_entry
*h
;
5741 /* Look at the relocation information to figure out which symbol
5744 r_symndx
= ELF32_R_SYM (relocs
->r_info
);
5746 if (r_symndx
< extsymoff
5747 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
5749 /* This stub was actually built for a static symbol defined
5750 in the same file. We assume that all static symbols in
5751 mips16 code are themselves mips16, so we can simply
5752 discard this stub. Since this function is called before
5753 the linker maps input sections to output sections, we can
5754 easily discard it by setting the SEC_EXCLUDE flag. */
5755 sec
->flags
|= SEC_EXCLUDE
;
5759 h
= ((struct mips_elf_link_hash_entry
*)
5760 sym_hashes
[r_symndx
- extsymoff
]);
5762 /* H is the symbol this stub is for. */
5764 if (strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
5765 loc
= &h
->call_fp_stub
;
5767 loc
= &h
->call_stub
;
5769 /* If we already have an appropriate stub for this function, we
5770 don't need another one, so we can discard this one. Since
5771 this function is called before the linker maps input sections
5772 to output sections, we can easily discard it by setting the
5773 SEC_EXCLUDE flag. We can also discard this section if we
5774 happen to already know that this is a mips16 function; it is
5775 not necessary to check this here, as it is checked later, but
5776 it is slightly faster to check now. */
5777 if (*loc
!= NULL
|| h
->root
.other
== STO_MIPS16
)
5779 sec
->flags
|= SEC_EXCLUDE
;
5784 mips_elf_hash_table (info
)->mips16_stubs_seen
= true;
5794 sgot
= bfd_get_section_by_name (dynobj
, ".got");
5799 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
5800 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
5801 BFD_ASSERT (g
!= NULL
);
5807 rel_end
= relocs
+ sec
->reloc_count
;
5808 for (rel
= relocs
; rel
< rel_end
; rel
++)
5810 unsigned long r_symndx
;
5811 struct elf_link_hash_entry
*h
;
5813 r_symndx
= ELF32_R_SYM (rel
->r_info
);
5815 if (r_symndx
< extsymoff
)
5819 h
= sym_hashes
[r_symndx
- extsymoff
];
5821 /* This may be an indirect symbol created because of a version. */
5824 while (h
->root
.type
== bfd_link_hash_indirect
)
5825 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5829 /* Some relocs require a global offset table. */
5830 if (dynobj
== NULL
|| sgot
== NULL
)
5832 switch (ELF32_R_TYPE (rel
->r_info
))
5836 case R_MIPS_CALL_HI16
:
5837 case R_MIPS_CALL_LO16
:
5838 case R_MIPS_GOT_HI16
:
5839 case R_MIPS_GOT_LO16
:
5841 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5842 if (! mips_elf_create_got_section (dynobj
, info
))
5844 sgot
= bfd_get_section_by_name (dynobj
, ".got");
5845 BFD_ASSERT (sgot
!= NULL
);
5846 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
5847 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
5848 BFD_ASSERT (g
!= NULL
);
5854 && (info
->shared
|| h
!= NULL
)
5855 && (sec
->flags
& SEC_ALLOC
) != 0)
5856 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5864 switch (ELF32_R_TYPE (rel
->r_info
))
5867 case R_MIPS_CALL_HI16
:
5868 case R_MIPS_CALL_LO16
:
5869 /* This symbol requires a global offset table entry. */
5871 BFD_ASSERT (h
!= NULL
);
5873 /* Make sure this symbol is output as a dynamic symbol. */
5874 if (h
->dynindx
== -1)
5876 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
5880 if (h
->got_offset
!= (bfd_vma
) -1)
5882 /* We have already allocated space in the .got. */
5886 /* Note the index of the first global got symbol in .dynsym. */
5887 if (g
->global_gotsym
== 0
5888 || g
->global_gotsym
> (unsigned long) h
->dynindx
)
5889 g
->global_gotsym
= h
->dynindx
;
5891 /* Make this symbol to have the corresponding got entry. */
5894 /* We need a stub, not a plt entry for the undefined
5895 function. But we record it as if it needs plt. See
5896 elf_adjust_dynamic_symbol in elflink.h. */
5897 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
5903 case R_MIPS_GOT_HI16
:
5904 case R_MIPS_GOT_LO16
:
5905 /* This symbol requires a global offset table entry. */
5909 /* Make sure this symbol is output as a dynamic symbol. */
5910 if (h
->dynindx
== -1)
5912 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
5916 if (h
->got_offset
!= (bfd_vma
) -1)
5918 /* We have already allocated space in the .got. */
5921 /* Note the index of the first global got symbol in
5923 if (g
->global_gotsym
== 0
5924 || g
->global_gotsym
> (unsigned long) h
->dynindx
)
5925 g
->global_gotsym
= h
->dynindx
;
5927 /* Make this symbol to be the global got symbol. */
5935 if ((info
->shared
|| h
!= NULL
)
5936 && (sec
->flags
& SEC_ALLOC
) != 0)
5940 const char *name
= ".rel.dyn";
5942 sreloc
= bfd_get_section_by_name (dynobj
, name
);
5945 sreloc
= bfd_make_section (dynobj
, name
);
5947 || ! bfd_set_section_flags (dynobj
, sreloc
,
5952 | SEC_LINKER_CREATED
5954 || ! bfd_set_section_alignment (dynobj
, sreloc
,
5961 /* When creating a shared object, we must copy these
5962 reloc types into the output file as R_MIPS_REL32
5963 relocs. We make room for this reloc in the
5964 .rel.dyn reloc section */
5965 if (sreloc
->_raw_size
== 0)
5967 /* Add a null element. */
5968 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
5969 ++sreloc
->reloc_count
;
5971 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
5975 struct mips_elf_link_hash_entry
*hmips
;
5977 /* We only need to copy this reloc if the symbol is
5978 defined in a dynamic object. */
5979 hmips
= (struct mips_elf_link_hash_entry
*) h
;
5980 ++hmips
->mips_32_relocs
;
5984 if (SGI_COMPAT (abfd
))
5985 mips_elf_hash_table (info
)->compact_rel_size
+=
5986 sizeof (Elf32_External_crinfo
);
5991 case R_MIPS_GPREL16
:
5992 case R_MIPS_LITERAL
:
5993 case R_MIPS_GPREL32
:
5994 if (SGI_COMPAT (abfd
))
5995 mips_elf_hash_table (info
)->compact_rel_size
+=
5996 sizeof (Elf32_External_crinfo
);
6003 /* If this reloc is not a 16 bit call, and it has a global
6004 symbol, then we will need the fn_stub if there is one.
6005 References from a stub section do not count. */
6007 && ELF32_R_TYPE (rel
->r_info
) != R_MIPS16_26
6008 && strncmp (bfd_get_section_name (abfd
, sec
), FN_STUB
,
6009 sizeof FN_STUB
- 1) != 0
6010 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_STUB
,
6011 sizeof CALL_STUB
- 1) != 0
6012 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_FP_STUB
,
6013 sizeof CALL_FP_STUB
- 1) != 0)
6015 struct mips_elf_link_hash_entry
*mh
;
6017 mh
= (struct mips_elf_link_hash_entry
*) h
;
6018 mh
->need_fn_stub
= true;
6025 /* Adjust a symbol defined by a dynamic object and referenced by a
6026 regular object. The current definition is in some section of the
6027 dynamic object, but we're not including those sections. We have to
6028 change the definition to something the rest of the link can
6032 mips_elf_adjust_dynamic_symbol (info
, h
)
6033 struct bfd_link_info
*info
;
6034 struct elf_link_hash_entry
*h
;
6037 struct mips_elf_link_hash_entry
*hmips
;
6040 dynobj
= elf_hash_table (info
)->dynobj
;
6042 /* Make sure we know what is going on here. */
6043 BFD_ASSERT (dynobj
!= NULL
6044 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
6045 || h
->weakdef
!= NULL
6046 || ((h
->elf_link_hash_flags
6047 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
6048 && (h
->elf_link_hash_flags
6049 & ELF_LINK_HASH_REF_REGULAR
) != 0
6050 && (h
->elf_link_hash_flags
6051 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
6053 /* If this symbol is defined in a dynamic object, we need to copy
6054 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
6056 hmips
= (struct mips_elf_link_hash_entry
*) h
;
6057 if (! info
->relocateable
6058 && hmips
->mips_32_relocs
!= 0
6059 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
6061 s
= bfd_get_section_by_name (dynobj
, ".rel.dyn");
6062 BFD_ASSERT (s
!= NULL
);
6064 if (s
->_raw_size
== 0)
6066 /* Make room for a null element. */
6067 s
->_raw_size
+= sizeof (Elf32_External_Rel
);
6070 s
->_raw_size
+= hmips
->mips_32_relocs
* sizeof (Elf32_External_Rel
);
6073 /* For a function, create a stub, if needed. */
6074 if (h
->type
== STT_FUNC
6075 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
6077 if (! elf_hash_table (info
)->dynamic_sections_created
)
6080 /* If this symbol is not defined in a regular file, then set
6081 the symbol to the stub location. This is required to make
6082 function pointers compare as equal between the normal
6083 executable and the shared library. */
6084 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
6086 /* We need .stub section. */
6087 s
= bfd_get_section_by_name (dynobj
, ".stub");
6088 BFD_ASSERT (s
!= NULL
);
6090 h
->root
.u
.def
.section
= s
;
6091 h
->root
.u
.def
.value
= s
->_raw_size
;
6093 /* XXX Write this stub address somewhere. */
6094 h
->plt_offset
= s
->_raw_size
;
6096 /* Make room for this stub code. */
6097 s
->_raw_size
+= MIPS_FUNCTION_STUB_SIZE
;
6099 /* The last half word of the stub will be filled with the index
6100 of this symbol in .dynsym section. */
6105 /* If this is a weak symbol, and there is a real definition, the
6106 processor independent code will have arranged for us to see the
6107 real definition first, and we can just use the same value. */
6108 if (h
->weakdef
!= NULL
)
6110 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
6111 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
6112 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
6113 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
6117 /* This is a reference to a symbol defined by a dynamic object which
6118 is not a function. */
6123 /* This function is called after all the input files have been read,
6124 and the input sections have been assigned to output sections. We
6125 check for any mips16 stub sections that we can discard. */
6127 static boolean mips_elf_check_mips16_stubs
6128 PARAMS ((struct mips_elf_link_hash_entry
*, PTR
));
6131 mips_elf_always_size_sections (output_bfd
, info
)
6133 struct bfd_link_info
*info
;
6135 if (info
->relocateable
6136 || ! mips_elf_hash_table (info
)->mips16_stubs_seen
)
6139 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
6140 mips_elf_check_mips16_stubs
,
6146 /* Check the mips16 stubs for a particular symbol, and see if we can
6151 mips_elf_check_mips16_stubs (h
, data
)
6152 struct mips_elf_link_hash_entry
*h
;
6155 if (h
->fn_stub
!= NULL
6156 && ! h
->need_fn_stub
)
6158 /* We don't need the fn_stub; the only references to this symbol
6159 are 16 bit calls. Clobber the size to 0 to prevent it from
6160 being included in the link. */
6161 h
->fn_stub
->_raw_size
= 0;
6162 h
->fn_stub
->_cooked_size
= 0;
6163 h
->fn_stub
->flags
&= ~ SEC_RELOC
;
6164 h
->fn_stub
->reloc_count
= 0;
6165 h
->fn_stub
->flags
|= SEC_EXCLUDE
;
6168 if (h
->call_stub
!= NULL
6169 && h
->root
.other
== STO_MIPS16
)
6171 /* We don't need the call_stub; this is a 16 bit function, so
6172 calls from other 16 bit functions are OK. Clobber the size
6173 to 0 to prevent it from being included in the link. */
6174 h
->call_stub
->_raw_size
= 0;
6175 h
->call_stub
->_cooked_size
= 0;
6176 h
->call_stub
->flags
&= ~ SEC_RELOC
;
6177 h
->call_stub
->reloc_count
= 0;
6178 h
->call_stub
->flags
|= SEC_EXCLUDE
;
6181 if (h
->call_fp_stub
!= NULL
6182 && h
->root
.other
== STO_MIPS16
)
6184 /* We don't need the call_stub; this is a 16 bit function, so
6185 calls from other 16 bit functions are OK. Clobber the size
6186 to 0 to prevent it from being included in the link. */
6187 h
->call_fp_stub
->_raw_size
= 0;
6188 h
->call_fp_stub
->_cooked_size
= 0;
6189 h
->call_fp_stub
->flags
&= ~ SEC_RELOC
;
6190 h
->call_fp_stub
->reloc_count
= 0;
6191 h
->call_fp_stub
->flags
|= SEC_EXCLUDE
;
6197 /* Set the sizes of the dynamic sections. */
6200 mips_elf_size_dynamic_sections (output_bfd
, info
)
6202 struct bfd_link_info
*info
;
6208 struct mips_got_info
*g
;
6210 dynobj
= elf_hash_table (info
)->dynobj
;
6211 BFD_ASSERT (dynobj
!= NULL
);
6213 if (elf_hash_table (info
)->dynamic_sections_created
)
6215 /* Set the contents of the .interp section to the interpreter. */
6218 s
= bfd_get_section_by_name (dynobj
, ".interp");
6219 BFD_ASSERT (s
!= NULL
);
6220 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
6221 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
6225 /* Recompute the size of .got for local entires (reserved and
6226 hipages) if needed. To estimate it, get the upper bound of total
6227 size of loadable sections. */
6228 sgot
= bfd_get_section_by_name (dynobj
, ".got");
6232 bfd_size_type loadable_size
= 0;
6233 bfd_size_type local_gotno
;
6236 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
6237 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
6238 BFD_ASSERT (g
!= NULL
);
6240 for (sub
= info
->input_bfds
; sub
; sub
= sub
->link_next
)
6241 for (s
= sub
->sections
; s
!= NULL
; s
= s
->next
)
6243 if ((s
->flags
& SEC_ALLOC
) == 0)
6245 loadable_size
+= (s
->_raw_size
+ 0xf) & ~0xf;
6248 loadable_size
+= MIPS_FUNCTION_STUB_SIZE
;
6250 /* Assume there are two loadable segments consisting of
6251 contiguous sections. Is 5 enough? */
6252 local_gotno
= (loadable_size
>> 16) + 5 + MIPS_RESERVED_GOTNO
;
6253 g
->local_gotno
= local_gotno
;
6254 sgot
->_raw_size
+= local_gotno
* 4;
6257 /* The check_relocs and adjust_dynamic_symbol entry points have
6258 determined the sizes of the various dynamic sections. Allocate
6261 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
6266 /* It's OK to base decisions on the section name, because none
6267 of the dynobj section names depend upon the input files. */
6268 name
= bfd_get_section_name (dynobj
, s
);
6270 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
6275 if (strncmp (name
, ".rel", 4) == 0)
6277 if (s
->_raw_size
== 0)
6281 const char *outname
;
6284 /* If this relocation section applies to a read only
6285 section, then we probably need a DT_TEXTREL entry.
6286 If the relocation section is .rel.dyn, we always
6287 assert a DT_TEXTREL entry rather than testing whether
6288 there exists a relocation to a read only section or
6290 outname
= bfd_get_section_name (output_bfd
,
6292 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
6293 if ((target
!= NULL
&& (target
->flags
& SEC_READONLY
) != 0)
6294 || strcmp (outname
, ".rel.dyn") == 0)
6297 /* We use the reloc_count field as a counter if we need
6298 to copy relocs into the output file. */
6299 if (strcmp (name
, ".rel.dyn") != 0)
6303 else if (strncmp (name
, ".got", 4) == 0)
6307 BFD_ASSERT (elf_section_data (s
) != NULL
);
6308 g
= (struct mips_got_info
*) elf_section_data (s
)->tdata
;
6309 BFD_ASSERT (g
!= NULL
);
6311 /* Fix the size of .got section for the correspondence of
6312 global symbols and got entries. This adds some useless
6313 got entries. Is this required by ABI really? */
6314 i
= elf_hash_table (info
)->dynsymcount
- g
->global_gotsym
;
6315 s
->_raw_size
+= i
* 4;
6317 else if (strncmp (name
, ".stub", 5) == 0)
6319 /* Irix rld assumes that the function stub isn't at the end
6320 of .text section. So put a dummy. XXX */
6321 s
->_raw_size
+= MIPS_FUNCTION_STUB_SIZE
;
6323 else if (! info
->shared
6324 && ! mips_elf_hash_table (info
)->use_rld_obj_head
6325 && strncmp (name
, ".rld_map", 8) == 0)
6327 /* We add a room for __rld_map. It will be filled in by the
6328 rtld to contain a pointer to the _r_debug structure. */
6331 else if (SGI_COMPAT (output_bfd
)
6332 && strncmp (name
, ".compact_rel", 12) == 0)
6333 s
->_raw_size
+= mips_elf_hash_table (info
)->compact_rel_size
;
6334 else if (strncmp (name
, ".init", 5) != 0)
6336 /* It's not one of our sections, so don't allocate space. */
6344 for (spp
= &s
->output_section
->owner
->sections
;
6345 *spp
!= s
->output_section
;
6346 spp
= &(*spp
)->next
)
6348 *spp
= s
->output_section
->next
;
6349 --s
->output_section
->owner
->section_count
;
6354 /* Allocate memory for the section contents. */
6355 s
->contents
= (bfd_byte
*) bfd_alloc (dynobj
, s
->_raw_size
);
6356 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
6358 bfd_set_error (bfd_error_no_memory
);
6361 memset (s
->contents
, 0, s
->_raw_size
);
6364 if (elf_hash_table (info
)->dynamic_sections_created
)
6366 /* Add some entries to the .dynamic section. We fill in the
6367 values later, in elf_mips_finish_dynamic_sections, but we
6368 must add the entries now so that we get the correct size for
6369 the .dynamic section. The DT_DEBUG entry is filled in by the
6370 dynamic linker and used by the debugger. */
6373 if (SGI_COMPAT (output_bfd
))
6375 /* SGI object has the equivalence of DT_DEBUG in the
6376 DT_MIPS_RLD_MAP entry. */
6377 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_RLD_MAP
, 0))
6381 if (! bfd_elf32_add_dynamic_entry (info
, DT_DEBUG
, 0))
6387 if (! bfd_elf32_add_dynamic_entry (info
, DT_TEXTREL
, 0))
6391 if (! bfd_elf32_add_dynamic_entry (info
, DT_PLTGOT
, 0))
6394 if (bfd_get_section_by_name (dynobj
, ".rel.dyn"))
6396 if (! bfd_elf32_add_dynamic_entry (info
, DT_REL
, 0))
6399 if (! bfd_elf32_add_dynamic_entry (info
, DT_RELSZ
, 0))
6402 if (! bfd_elf32_add_dynamic_entry (info
, DT_RELENT
, 0))
6406 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_CONFLICTNO
, 0))
6409 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_LIBLISTNO
, 0))
6412 if (bfd_get_section_by_name (dynobj
, ".conflict") != NULL
)
6414 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_CONFLICT
, 0))
6417 s
= bfd_get_section_by_name (dynobj
, ".liblist");
6418 BFD_ASSERT (s
!= NULL
);
6420 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_LIBLIST
, 0))
6424 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_RLD_VERSION
, 0))
6427 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_FLAGS
, 0))
6431 /* Time stamps in executable files are a bad idea. */
6432 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_TIME_STAMP
, 0))
6437 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_ICHECKSUM
, 0))
6442 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_IVERSION
, 0))
6446 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_BASE_ADDRESS
, 0))
6449 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_LOCAL_GOTNO
, 0))
6452 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_SYMTABNO
, 0))
6455 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_UNREFEXTNO
, 0))
6458 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_GOTSYM
, 0))
6461 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_HIPAGENO
, 0))
6464 #if 0 /* (SGI_COMPAT) */
6465 if (! bfd_get_section_by_name (dynobj
, ".init"))
6466 if (! bfd_elf32_add_dynamic_entry (info
, DT_INIT
, 0))
6469 if (! bfd_get_section_by_name (dynobj
, ".fini"))
6470 if (! bfd_elf32_add_dynamic_entry (info
, DT_FINI
, 0))
6475 /* If we use dynamic linking, we generate a section symbol for each
6476 output section. These are local symbols, which means that they
6477 must come first in the dynamic symbol table.
6478 That means we must increment the dynamic symbol index of every
6479 other dynamic symbol. */
6481 const char * const *namep
;
6483 bfd_size_type strindex
;
6484 struct bfd_strtab_hash
*dynstr
;
6485 struct mips_got_info
*g
;
6488 if (elf_hash_table (info
)->dynamic_sections_created
)
6490 if (SGI_COMPAT (output_bfd
))
6492 c
= SIZEOF_MIPS_DYNSYM_SECNAMES
- 1;
6493 elf_link_hash_traverse (elf_hash_table (info
),
6494 mips_elf_adjust_dynindx
,
6496 elf_hash_table (info
)->dynsymcount
+= c
;
6498 dynstr
= elf_hash_table (info
)->dynstr
;
6499 BFD_ASSERT (dynstr
!= NULL
);
6501 for (i
= 1, namep
= mips_elf_dynsym_sec_names
;
6505 s
= bfd_get_section_by_name (output_bfd
, *namep
);
6507 elf_section_data (s
)->dynindx
= i
;
6509 strindex
= _bfd_stringtab_add (dynstr
, *namep
, true, false);
6510 if (strindex
== (bfd_size_type
) -1)
6513 mips_elf_hash_table (info
)->dynsym_sec_strindex
[i
] = strindex
;
6518 c
= bfd_count_sections (output_bfd
);
6519 elf_link_hash_traverse (elf_hash_table (info
),
6520 mips_elf_adjust_dynindx
,
6522 elf_hash_table (info
)->dynsymcount
+= c
;
6524 for (i
= 1, s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
, i
++)
6526 elf_section_data (s
)->dynindx
= i
;
6527 /* These symbols will have no names, so we don't need to
6528 fiddle with dynstr_index. */
6535 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
6536 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
6537 BFD_ASSERT (g
!= NULL
);
6539 /* If there are no global got symbols, fake the last symbol so
6541 if (g
->global_gotsym
)
6542 g
->global_gotsym
+= c
;
6544 g
->global_gotsym
= elf_hash_table (info
)->dynsymcount
- 1;
6551 /* Increment the index of a dynamic symbol by a given amount. Called
6552 via elf_link_hash_traverse. */
6555 mips_elf_adjust_dynindx (h
, cparg
)
6556 struct elf_link_hash_entry
*h
;
6559 unsigned int *cp
= (unsigned int *) cparg
;
6561 if (h
->dynindx
!= -1)
6566 /* Finish up dynamic symbol handling. We set the contents of various
6567 dynamic sections here. */
6570 mips_elf_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
6572 struct bfd_link_info
*info
;
6573 struct elf_link_hash_entry
*h
;
6574 Elf_Internal_Sym
*sym
;
6579 struct mips_got_info
*g
;
6582 dynobj
= elf_hash_table (info
)->dynobj
;
6583 gval
= sym
->st_value
;
6585 if (h
->plt_offset
!= (bfd_vma
) -1)
6589 bfd_byte stub
[MIPS_FUNCTION_STUB_SIZE
];
6591 /* This symbol has a stub. Set it up. */
6593 BFD_ASSERT (h
->dynindx
!= -1);
6595 s
= bfd_get_section_by_name (dynobj
, ".stub");
6596 BFD_ASSERT (s
!= NULL
);
6598 /* Fill the stub. */
6600 bfd_put_32 (output_bfd
, STUB_LW(output_bfd
), p
);
6602 bfd_put_32 (output_bfd
, STUB_MOVE
, p
);
6605 /* FIXME: Can h->dynindex be more than 64K? */
6606 if (h
->dynindx
& 0xffff0000)
6609 bfd_put_32 (output_bfd
, STUB_JALR
, p
);
6611 bfd_put_32 (output_bfd
, STUB_LI16
+ h
->dynindx
, p
);
6613 BFD_ASSERT (h
->plt_offset
<= s
->_raw_size
);
6614 memcpy (s
->contents
+ h
->plt_offset
, stub
, MIPS_FUNCTION_STUB_SIZE
);
6616 /* Mark the symbol as undefined. plt_offset != -1 occurs
6617 only for the referenced symbol. */
6618 sym
->st_shndx
= SHN_UNDEF
;
6620 /* The run-time linker uses the st_value field of the symbol
6621 to reset the global offset table entry for this external
6622 to its stub address when unlinking a shared object. */
6623 gval
= s
->output_section
->vma
+ s
->output_offset
+ h
->plt_offset
;
6624 sym
->st_value
= gval
;
6627 BFD_ASSERT (h
->dynindx
!= -1);
6629 sgot
= bfd_get_section_by_name (dynobj
, ".got");
6630 BFD_ASSERT (sgot
!= NULL
);
6631 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
6632 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
6633 BFD_ASSERT (g
!= NULL
);
6635 if ((unsigned long) h
->dynindx
>= g
->global_gotsym
)
6637 bfd_size_type offset
;
6639 /* This symbol has an entry in the global offset table. Set its
6640 value to the corresponding got entry, if needed. */
6641 if (h
->got_offset
== (bfd_vma
) -1)
6643 offset
= (h
->dynindx
- g
->global_gotsym
+ g
->local_gotno
) * 4;
6644 BFD_ASSERT (g
->local_gotno
* 4 <= offset
6645 && offset
< sgot
->_raw_size
);
6646 bfd_put_32 (output_bfd
, gval
, sgot
->contents
+ offset
);
6650 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
6651 name
= h
->root
.root
.string
;
6652 if (strcmp (name
, "_DYNAMIC") == 0
6653 || strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
6654 sym
->st_shndx
= SHN_ABS
;
6655 else if (strcmp (name
, "_DYNAMIC_LINK") == 0)
6657 sym
->st_shndx
= SHN_ABS
;
6658 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6661 else if (SGI_COMPAT (output_bfd
))
6663 if (strcmp (name
, "_gp_disp") == 0)
6665 sym
->st_shndx
= SHN_ABS
;
6666 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6667 sym
->st_value
= elf_gp (output_bfd
);
6669 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
6670 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
6672 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6673 sym
->st_other
= STO_PROTECTED
;
6675 sym
->st_shndx
= SHN_MIPS_DATA
;
6677 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
6679 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6680 sym
->st_other
= STO_PROTECTED
;
6681 sym
->st_value
= mips_elf_hash_table (info
)->procedure_count
;
6682 sym
->st_shndx
= SHN_ABS
;
6684 else if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
!= SHN_ABS
)
6686 if (h
->type
== STT_FUNC
)
6687 sym
->st_shndx
= SHN_MIPS_TEXT
;
6688 else if (h
->type
== STT_OBJECT
)
6689 sym
->st_shndx
= SHN_MIPS_DATA
;
6693 if (SGI_COMPAT (output_bfd
)
6696 if (! mips_elf_hash_table (info
)->use_rld_obj_head
6697 && strcmp (name
, "__rld_map") == 0)
6699 asection
*s
= bfd_get_section_by_name (dynobj
, ".rld_map");
6700 BFD_ASSERT (s
!= NULL
);
6701 sym
->st_value
= s
->output_section
->vma
+ s
->output_offset
;
6702 bfd_put_32 (output_bfd
, (bfd_vma
) 0, s
->contents
);
6703 if (mips_elf_hash_table (info
)->rld_value
== 0)
6704 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
6706 else if (mips_elf_hash_table (info
)->use_rld_obj_head
6707 && strcmp (name
, "__rld_obj_head") == 0)
6709 asection
*s
= bfd_get_section_by_name (dynobj
, ".rld_map");
6710 BFD_ASSERT (s
!= NULL
);
6711 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
6715 /* If this is a mips16 symbol, force the value to be even. */
6716 if (sym
->st_other
== STO_MIPS16
6717 && (sym
->st_value
& 1) != 0)
6723 /* Finish up the dynamic sections. */
6726 mips_elf_finish_dynamic_sections (output_bfd
, info
)
6728 struct bfd_link_info
*info
;
6733 struct mips_got_info
*g
;
6735 dynobj
= elf_hash_table (info
)->dynobj
;
6737 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
6739 sgot
= bfd_get_section_by_name (dynobj
, ".got");
6744 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
6745 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
6746 BFD_ASSERT (g
!= NULL
);
6749 if (elf_hash_table (info
)->dynamic_sections_created
)
6751 Elf32_External_Dyn
*dyncon
, *dynconend
;
6753 BFD_ASSERT (sdyn
!= NULL
);
6754 BFD_ASSERT (g
!= NULL
);
6756 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
6757 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
6758 for (; dyncon
< dynconend
; dyncon
++)
6760 Elf_Internal_Dyn dyn
;
6765 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
6773 s
= bfd_get_section_by_name (dynobj
, ".rel.dyn");
6774 BFD_ASSERT (s
!= NULL
);
6775 dyn
.d_un
.d_val
= sizeof (Elf32_External_Rel
);
6776 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6780 /* Rewrite DT_STRSZ. */
6782 _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
6783 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6789 case DT_MIPS_CONFLICT
:
6792 case DT_MIPS_LIBLIST
:
6795 s
= bfd_get_section_by_name (output_bfd
, name
);
6796 BFD_ASSERT (s
!= NULL
);
6797 dyn
.d_un
.d_ptr
= s
->vma
;
6798 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6801 case DT_MIPS_RLD_VERSION
:
6802 dyn
.d_un
.d_val
= 1; /* XXX */
6803 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6807 dyn
.d_un
.d_val
= RHF_NOTPOT
; /* XXX */
6808 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6811 case DT_MIPS_CONFLICTNO
:
6813 elemsize
= sizeof (Elf32_Conflict
);
6816 case DT_MIPS_LIBLISTNO
:
6818 elemsize
= sizeof (Elf32_Lib
);
6820 s
= bfd_get_section_by_name (output_bfd
, name
);
6823 if (s
->_cooked_size
!= 0)
6824 dyn
.d_un
.d_val
= s
->_cooked_size
/ elemsize
;
6826 dyn
.d_un
.d_val
= s
->_raw_size
/ elemsize
;
6831 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6834 case DT_MIPS_TIME_STAMP
:
6835 time ((time_t *) &dyn
.d_un
.d_val
);
6836 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6839 case DT_MIPS_ICHECKSUM
:
6843 case DT_MIPS_IVERSION
:
6847 case DT_MIPS_BASE_ADDRESS
:
6848 s
= output_bfd
->sections
;
6849 BFD_ASSERT (s
!= NULL
);
6850 dyn
.d_un
.d_ptr
= s
->vma
& ~(0xffff);
6851 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6854 case DT_MIPS_LOCAL_GOTNO
:
6855 dyn
.d_un
.d_val
= g
->local_gotno
;
6856 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6859 case DT_MIPS_SYMTABNO
:
6861 elemsize
= sizeof (Elf32_External_Sym
);
6862 s
= bfd_get_section_by_name (output_bfd
, name
);
6863 BFD_ASSERT (s
!= NULL
);
6865 if (s
->_cooked_size
!= 0)
6866 dyn
.d_un
.d_val
= s
->_cooked_size
/ elemsize
;
6868 dyn
.d_un
.d_val
= s
->_raw_size
/ elemsize
;
6869 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6872 case DT_MIPS_UNREFEXTNO
:
6874 dyn
.d_un
.d_val
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
6875 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6878 case DT_MIPS_GOTSYM
:
6879 dyn
.d_un
.d_val
= g
->global_gotsym
;
6880 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6883 case DT_MIPS_HIPAGENO
:
6884 dyn
.d_un
.d_val
= g
->local_gotno
- MIPS_RESERVED_GOTNO
;
6885 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6888 case DT_MIPS_RLD_MAP
:
6889 dyn
.d_un
.d_ptr
= mips_elf_hash_table (info
)->rld_value
;
6890 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
6897 /* The first entry of the global offset table will be filled at
6898 runtime. The second entry will be used by some runtime loaders.
6899 This isn't the case of Irix rld. */
6900 if (sgot
!= NULL
&& sgot
->_raw_size
> 0)
6902 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
6903 bfd_put_32 (output_bfd
, (bfd_vma
) 0x80000000, sgot
->contents
+ 4);
6907 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
6914 Elf_Internal_Sym sym
;
6917 const char * const * namep
= mips_elf_dynsym_sec_names
;
6918 Elf32_compact_rel cpt
;
6920 /* Set up the section symbols for the output sections. SGI sets
6921 the STT_NOTYPE attribute for these symbols. Should we do so? */
6923 sdynsym
= bfd_get_section_by_name (dynobj
, ".dynsym");
6924 if (sdynsym
!= NULL
)
6926 if (SGI_COMPAT (output_bfd
))
6930 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_NOTYPE
);
6934 while ((name
= *namep
++) != NULL
)
6936 s
= bfd_get_section_by_name (output_bfd
, name
);
6939 sym
.st_value
= s
->vma
;
6940 dindx
= elf_section_data (s
)->dynindx
;
6941 last
= s
->vma
+ s
->_raw_size
;
6945 sym
.st_value
= last
;
6949 sym
.st_shndx
= (i
< MIPS_TEXT_DYNSYM_SECNO
6954 mips_elf_hash_table (info
)->dynsym_sec_strindex
[dindx
];
6956 bfd_elf32_swap_symbol_out (output_bfd
, &sym
,
6957 (((Elf32_External_Sym
*)
6962 /* Set the sh_info field of the output .dynsym section to
6963 the index of the first global symbol. */
6964 elf_section_data (sdynsym
->output_section
)->this_hdr
.sh_info
=
6965 SIZEOF_MIPS_DYNSYM_SECNAMES
;
6971 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
6974 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6978 sym
.st_value
= s
->vma
;
6980 indx
= elf_section_data (s
)->this_idx
;
6981 BFD_ASSERT (indx
> 0);
6982 sym
.st_shndx
= indx
;
6984 bfd_elf32_swap_symbol_out (output_bfd
, &sym
,
6985 (((Elf32_External_Sym
*)
6987 + elf_section_data (s
)->dynindx
));
6990 /* Set the sh_info field of the output .dynsym section to
6991 the index of the first global symbol. */
6992 elf_section_data (sdynsym
->output_section
)->this_hdr
.sh_info
=
6993 bfd_count_sections (output_bfd
) + 1;
6997 if (SGI_COMPAT (output_bfd
))
6999 /* Write .compact_rel section out. */
7000 s
= bfd_get_section_by_name (dynobj
, ".compact_rel");
7004 cpt
.num
= s
->reloc_count
;
7006 cpt
.offset
= (s
->output_section
->filepos
7007 + sizeof (Elf32_External_compact_rel
));
7010 bfd_elf32_swap_compact_rel_out (output_bfd
, &cpt
,
7011 ((Elf32_External_compact_rel
*)
7014 /* Clean up a dummy stub function entry in .text. */
7015 s
= bfd_get_section_by_name (dynobj
, ".stub");
7018 file_ptr dummy_offset
;
7020 BFD_ASSERT (s
->_raw_size
>= MIPS_FUNCTION_STUB_SIZE
);
7021 dummy_offset
= s
->_raw_size
- MIPS_FUNCTION_STUB_SIZE
;
7022 memset (s
->contents
+ dummy_offset
, 0,
7023 MIPS_FUNCTION_STUB_SIZE
);
7028 /* Clean up a first relocation in .rel.dyn. */
7029 s
= bfd_get_section_by_name (dynobj
, ".rel.dyn");
7030 if (s
!= NULL
&& s
->_raw_size
> 0)
7031 memset (s
->contents
, 0, sizeof (Elf32_External_Rel
));
7037 /* This is almost identical to bfd_generic_get_... except that some
7038 MIPS relocations need to be handled specially. Sigh. */
7041 elf32_mips_get_relocated_section_contents (abfd
, link_info
, link_order
, data
,
7042 relocateable
, symbols
)
7044 struct bfd_link_info
*link_info
;
7045 struct bfd_link_order
*link_order
;
7047 boolean relocateable
;
7050 /* Get enough memory to hold the stuff */
7051 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
7052 asection
*input_section
= link_order
->u
.indirect
.section
;
7054 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
7055 arelent
**reloc_vector
= NULL
;
7061 reloc_vector
= (arelent
**) bfd_malloc (reloc_size
);
7062 if (reloc_vector
== NULL
&& reloc_size
!= 0)
7065 /* read in the section */
7066 if (!bfd_get_section_contents (input_bfd
,
7070 input_section
->_raw_size
))
7073 /* We're not relaxing the section, so just copy the size info */
7074 input_section
->_cooked_size
= input_section
->_raw_size
;
7075 input_section
->reloc_done
= true;
7077 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
7081 if (reloc_count
< 0)
7084 if (reloc_count
> 0)
7089 bfd_vma gp
= 0x12345678; /* initialize just to shut gcc up */
7092 struct bfd_hash_entry
*h
;
7093 struct bfd_link_hash_entry
*lh
;
7094 /* Skip all this stuff if we aren't mixing formats. */
7095 if (abfd
&& input_bfd
7096 && abfd
->xvec
== input_bfd
->xvec
)
7100 h
= bfd_hash_lookup (&link_info
->hash
->table
, "_gp", false, false);
7101 lh
= (struct bfd_link_hash_entry
*) h
;
7108 case bfd_link_hash_undefined
:
7109 case bfd_link_hash_undefweak
:
7110 case bfd_link_hash_common
:
7113 case bfd_link_hash_defined
:
7114 case bfd_link_hash_defweak
:
7116 gp
= lh
->u
.def
.value
;
7118 case bfd_link_hash_indirect
:
7119 case bfd_link_hash_warning
:
7121 /* @@FIXME ignoring warning for now */
7123 case bfd_link_hash_new
:
7132 for (parent
= reloc_vector
; *parent
!= (arelent
*) NULL
;
7135 char *error_message
= (char *) NULL
;
7136 bfd_reloc_status_type r
;
7138 /* Specific to MIPS: Deal with relocation types that require
7139 knowing the gp of the output bfd. */
7140 asymbol
*sym
= *(*parent
)->sym_ptr_ptr
;
7141 if (bfd_is_abs_section (sym
->section
) && abfd
)
7143 /* The special_function wouldn't get called anyways. */
7147 /* The gp isn't there; let the special function code
7148 fall over on its own. */
7150 else if ((*parent
)->howto
->special_function
7151 == _bfd_mips_elf_gprel16_reloc
)
7153 /* bypass special_function call */
7154 r
= gprel16_with_gp (input_bfd
, sym
, *parent
, input_section
,
7155 relocateable
, (PTR
) data
, gp
);
7156 goto skip_bfd_perform_relocation
;
7158 /* end mips specific stuff */
7160 r
= bfd_perform_relocation (input_bfd
,
7164 relocateable
? abfd
: (bfd
*) NULL
,
7166 skip_bfd_perform_relocation
:
7170 asection
*os
= input_section
->output_section
;
7172 /* A partial link, so keep the relocs */
7173 os
->orelocation
[os
->reloc_count
] = *parent
;
7177 if (r
!= bfd_reloc_ok
)
7181 case bfd_reloc_undefined
:
7182 if (!((*link_info
->callbacks
->undefined_symbol
)
7183 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
7184 input_bfd
, input_section
, (*parent
)->address
)))
7187 case bfd_reloc_dangerous
:
7188 BFD_ASSERT (error_message
!= (char *) NULL
);
7189 if (!((*link_info
->callbacks
->reloc_dangerous
)
7190 (link_info
, error_message
, input_bfd
, input_section
,
7191 (*parent
)->address
)))
7194 case bfd_reloc_overflow
:
7195 if (!((*link_info
->callbacks
->reloc_overflow
)
7196 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
7197 (*parent
)->howto
->name
, (*parent
)->addend
,
7198 input_bfd
, input_section
, (*parent
)->address
)))
7201 case bfd_reloc_outofrange
:
7210 if (reloc_vector
!= NULL
)
7211 free (reloc_vector
);
7215 if (reloc_vector
!= NULL
)
7216 free (reloc_vector
);
7219 #define bfd_elf32_bfd_get_relocated_section_contents \
7220 elf32_mips_get_relocated_section_contents
7222 /* ECOFF swapping routines. These are used when dealing with the
7223 .mdebug section, which is in the ECOFF debugging format. */
7224 static const struct ecoff_debug_swap mips_elf32_ecoff_debug_swap
=
7226 /* Symbol table magic number. */
7228 /* Alignment of debugging information. E.g., 4. */
7230 /* Sizes of external symbolic information. */
7231 sizeof (struct hdr_ext
),
7232 sizeof (struct dnr_ext
),
7233 sizeof (struct pdr_ext
),
7234 sizeof (struct sym_ext
),
7235 sizeof (struct opt_ext
),
7236 sizeof (struct fdr_ext
),
7237 sizeof (struct rfd_ext
),
7238 sizeof (struct ext_ext
),
7239 /* Functions to swap in external symbolic data. */
7248 _bfd_ecoff_swap_tir_in
,
7249 _bfd_ecoff_swap_rndx_in
,
7250 /* Functions to swap out external symbolic data. */
7259 _bfd_ecoff_swap_tir_out
,
7260 _bfd_ecoff_swap_rndx_out
,
7261 /* Function to read in symbolic data. */
7262 _bfd_mips_elf_read_ecoff_info
7265 #define TARGET_LITTLE_SYM bfd_elf32_littlemips_vec
7266 #define TARGET_LITTLE_NAME "elf32-littlemips"
7267 #define TARGET_BIG_SYM bfd_elf32_bigmips_vec
7268 #define TARGET_BIG_NAME "elf32-bigmips"
7269 #define ELF_ARCH bfd_arch_mips
7270 #define ELF_MACHINE_CODE EM_MIPS
7272 /* The SVR4 MIPS ABI says that this should be 0x10000, but Irix 5 uses
7273 a value of 0x1000, and we are compatible. */
7274 #define ELF_MAXPAGESIZE 0x1000
7276 #define elf_backend_collect true
7277 #define elf_backend_type_change_ok true
7278 #define elf_info_to_howto 0
7279 #define elf_info_to_howto_rel mips_info_to_howto_rel
7280 #define elf_backend_sym_is_global mips_elf_sym_is_global
7281 #define elf_backend_object_p mips_elf32_object_p
7282 #define elf_backend_section_from_shdr mips_elf32_section_from_shdr
7283 #define elf_backend_fake_sections _bfd_mips_elf_fake_sections
7284 #define elf_backend_section_from_bfd_section \
7285 _bfd_mips_elf_section_from_bfd_section
7286 #define elf_backend_section_processing mips_elf32_section_processing
7287 #define elf_backend_symbol_processing _bfd_mips_elf_symbol_processing
7288 #define elf_backend_additional_program_headers \
7289 mips_elf_additional_program_headers
7290 #define elf_backend_modify_segment_map mips_elf_modify_segment_map
7291 #define elf_backend_final_write_processing \
7292 _bfd_mips_elf_final_write_processing
7293 #define elf_backend_ecoff_debug_swap &mips_elf32_ecoff_debug_swap
7295 #define bfd_elf32_bfd_is_local_label_name \
7296 mips_elf_is_local_label_name
7297 #define bfd_elf32_find_nearest_line _bfd_mips_elf_find_nearest_line
7298 #define bfd_elf32_set_section_contents _bfd_mips_elf_set_section_contents
7299 #define bfd_elf32_bfd_link_hash_table_create \
7300 mips_elf_link_hash_table_create
7301 #define bfd_elf32_bfd_final_link mips_elf_final_link
7302 #define bfd_elf32_bfd_copy_private_bfd_data \
7303 _bfd_mips_elf_copy_private_bfd_data
7304 #define bfd_elf32_bfd_merge_private_bfd_data \
7305 _bfd_mips_elf_merge_private_bfd_data
7306 #define bfd_elf32_bfd_set_private_flags _bfd_mips_elf_set_private_flags
7307 #define elf_backend_add_symbol_hook mips_elf_add_symbol_hook
7308 #define elf_backend_create_dynamic_sections \
7309 mips_elf_create_dynamic_sections
7310 #define elf_backend_check_relocs mips_elf_check_relocs
7311 #define elf_backend_adjust_dynamic_symbol \
7312 mips_elf_adjust_dynamic_symbol
7313 #define elf_backend_always_size_sections \
7314 mips_elf_always_size_sections
7315 #define elf_backend_size_dynamic_sections \
7316 mips_elf_size_dynamic_sections
7317 #define elf_backend_relocate_section mips_elf_relocate_section
7318 #define elf_backend_link_output_symbol_hook \
7319 mips_elf_link_output_symbol_hook
7320 #define elf_backend_finish_dynamic_symbol \
7321 mips_elf_finish_dynamic_symbol
7322 #define elf_backend_finish_dynamic_sections \
7323 mips_elf_finish_dynamic_sections
7325 #include "elf32-target.h"