1 /* MIPS-specific support for 32-bit ELF
2 Copyright 1993, 1994, 1995, 1996 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 reloc_howto_type
*bfd_elf32_bfd_reloc_type_lookup
45 PARAMS ((bfd
*, bfd_reloc_code_real_type
));
46 static void mips_info_to_howto_rel
47 PARAMS ((bfd
*, arelent
*, Elf32_Internal_Rel
*));
48 static void bfd_mips_elf32_swap_gptab_in
49 PARAMS ((bfd
*, const Elf32_External_gptab
*, Elf32_gptab
*));
50 static void bfd_mips_elf32_swap_gptab_out
51 PARAMS ((bfd
*, const Elf32_gptab
*, Elf32_External_gptab
*));
52 static boolean mips_elf_sym_is_global
PARAMS ((bfd
*, asymbol
*));
53 static boolean mips_elf32_object_p
PARAMS ((bfd
*));
54 static boolean mips_elf_create_procedure_table
55 PARAMS ((PTR
, bfd
*, struct bfd_link_info
*, asection
*,
56 struct ecoff_debug_info
*));
57 static int mips_elf_additional_program_headers
PARAMS ((bfd
*));
58 static boolean mips_elf_modify_segment_map
PARAMS ((bfd
*));
59 static boolean mips_elf32_section_from_shdr
60 PARAMS ((bfd
*, Elf32_Internal_Shdr
*, char *));
61 static boolean mips_elf32_section_processing
62 PARAMS ((bfd
*, Elf32_Internal_Shdr
*));
63 static boolean mips_elf_is_local_label
64 PARAMS ((bfd
*, asymbol
*));
65 static struct bfd_hash_entry
*mips_elf_link_hash_newfunc
66 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
67 static struct bfd_link_hash_table
*mips_elf_link_hash_table_create
69 static int gptab_compare
PARAMS ((const void *, const void *));
70 static boolean mips_elf_final_link
71 PARAMS ((bfd
*, struct bfd_link_info
*));
72 static void mips_elf_relocate_hi16
73 PARAMS ((bfd
*, Elf_Internal_Rela
*, Elf_Internal_Rela
*, bfd_byte
*,
75 static void mips_elf_relocate_got_local
76 PARAMS ((bfd
*, bfd
*, asection
*, Elf_Internal_Rela
*,
77 Elf_Internal_Rela
*, bfd_byte
*, bfd_vma
));
78 static void mips_elf_relocate_global_got
79 PARAMS ((bfd
*, Elf_Internal_Rela
*, bfd_byte
*, bfd_vma
));
80 static boolean mips_elf_adjust_dynindx
81 PARAMS ((struct elf_link_hash_entry
*, PTR
));
82 static boolean mips_elf_relocate_section
83 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
84 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
85 static boolean mips_elf_create_dynamic_sections
86 PARAMS ((bfd
*, struct bfd_link_info
*));
87 static boolean mips_elf_create_compact_rel_section
88 PARAMS ((bfd
*, struct bfd_link_info
*));
89 static boolean mips_elf_create_got_section
90 PARAMS ((bfd
*, struct bfd_link_info
*));
91 static boolean mips_elf_check_relocs
92 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
93 const Elf_Internal_Rela
*));
94 static boolean mips_elf_adjust_dynamic_symbol
95 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
96 static boolean mips_elf_size_dynamic_sections
97 PARAMS ((bfd
*, struct bfd_link_info
*));
98 static boolean mips_elf_finish_dynamic_symbol
99 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
100 Elf_Internal_Sym
*));
101 static boolean mips_elf_finish_dynamic_sections
102 PARAMS ((bfd
*, struct bfd_link_info
*));
103 static boolean mips_elf_add_symbol_hook
104 PARAMS ((bfd
*, struct bfd_link_info
*, const Elf_Internal_Sym
*,
105 const char **, flagword
*, asection
**, bfd_vma
*));
106 static bfd_reloc_status_type mips_elf_final_gp
107 PARAMS ((bfd
*, asymbol
*, boolean
, char **, bfd_vma
*));
108 static bfd_byte
*elf32_mips_get_relocated_section_contents
109 PARAMS ((bfd
*, struct bfd_link_info
*, struct bfd_link_order
*,
110 bfd_byte
*, boolean
, asymbol
**));
112 /* This is true for Irix 5 executables, false for normal MIPS ELF ABI
113 executables. FIXME: At the moment, we default to always generating
114 Irix 5 executables. */
116 #define SGI_COMPAT(abfd) (1)
118 /* This structure is used to hold .got information when linking. It
119 is stored in the tdata field of the bfd_elf_section_data structure. */
123 /* The symbol index of the first global .got symbol. */
124 unsigned long global_gotsym
;
125 /* The number of local .got entries. */
126 unsigned int local_gotno
;
129 /* The number of local .got entries we reserve. */
130 #define MIPS_RESERVED_GOTNO (2)
132 /* Instructions which appear in a stub. For some reason the stub is
133 slightly different on an SGI system. */
134 #define ELF_MIPS_GP_OFFSET(abfd) (SGI_COMPAT (abfd) ? 0x7ff0 : 0x8000)
135 #define STUB_LW(abfd) \
137 ? 0x8f998010 /* lw t9,0x8010(gp) */ \
138 : 0x8f998000) /* lw t9,0x8000(gp) */
139 #define STUB_MOVE 0x03e07825 /* move t7,ra */
140 #define STUB_JALR 0x0320f809 /* jal t9 */
141 #define STUB_LI16 0x34180000 /* ori t8,zero,0 */
142 #define MIPS_FUNCTION_STUB_SIZE (16)
144 /* Names of sections which appear in the .dynsym section in an Irix 5
147 static const char * const mips_elf_dynsym_sec_names
[] =
160 #define SIZEOF_MIPS_DYNSYM_SECNAMES \
161 (sizeof mips_elf_dynsym_sec_names / sizeof mips_elf_dynsym_sec_names[0])
163 /* The number of entries in mips_elf_dynsym_sec_names which go in the
166 #define MIPS_TEXT_DYNSYM_SECNO (3)
168 /* The names of the runtime procedure table symbols used on Irix 5. */
170 static const char * const mips_elf_dynsym_rtproc_names
[] =
173 "_procedure_string_table",
174 "_procedure_table_size",
178 /* These structures are used to generate the .compact_rel section on
183 unsigned long id1
; /* Always one? */
184 unsigned long num
; /* Number of compact relocation entries. */
185 unsigned long id2
; /* Always two? */
186 unsigned long offset
; /* The file offset of the first relocation. */
187 unsigned long reserved0
; /* Zero? */
188 unsigned long reserved1
; /* Zero? */
197 bfd_byte reserved0
[4];
198 bfd_byte reserved1
[4];
199 } Elf32_External_compact_rel
;
203 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
204 unsigned int rtype
: 4; /* Relocation types. See below. */
205 unsigned int dist2to
: 8;
206 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
207 unsigned long konst
; /* KONST field. See below. */
208 unsigned long vaddr
; /* VADDR to be relocated. */
213 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
214 unsigned int rtype
: 4; /* Relocation types. See below. */
215 unsigned int dist2to
: 8;
216 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
217 unsigned long konst
; /* KONST field. See below. */
225 } Elf32_External_crinfo
;
231 } Elf32_External_crinfo2
;
233 /* These are the constants used to swap the bitfields in a crinfo. */
235 #define CRINFO_CTYPE (0x1)
236 #define CRINFO_CTYPE_SH (31)
237 #define CRINFO_RTYPE (0xf)
238 #define CRINFO_RTYPE_SH (27)
239 #define CRINFO_DIST2TO (0xff)
240 #define CRINFO_DIST2TO_SH (19)
241 #define CRINFO_RELVADDR (0x7ffff)
242 #define CRINFO_RELVADDR_SH (0)
244 /* A compact relocation info has long (3 words) or short (2 words)
245 formats. A short format doesn't have VADDR field and relvaddr
246 fields contains ((VADDR - vaddr of the previous entry) >> 2). */
247 #define CRF_MIPS_LONG 1
248 #define CRF_MIPS_SHORT 0
250 /* There are 4 types of compact relocation at least. The value KONST
251 has different meaning for each type:
254 CT_MIPS_REL32 Address in data
255 CT_MIPS_WORD Address in word (XXX)
256 CT_MIPS_GPHI_LO GP - vaddr
257 CT_MIPS_JMPAD Address to jump
260 #define CRT_MIPS_REL32 0xa
261 #define CRT_MIPS_WORD 0xb
262 #define CRT_MIPS_GPHI_LO 0xc
263 #define CRT_MIPS_JMPAD 0xd
265 #define mips_elf_set_cr_format(x,format) ((x).ctype = (format))
266 #define mips_elf_set_cr_type(x,type) ((x).rtype = (type))
267 #define mips_elf_set_cr_dist2to(x,v) ((x).dist2to = (v))
268 #define mips_elf_set_cr_relvaddr(x,d) ((x).relvaddr = (d)<<2)
270 static void bfd_elf32_swap_compact_rel_out
271 PARAMS ((bfd
*, const Elf32_compact_rel
*, Elf32_External_compact_rel
*));
272 static void bfd_elf32_swap_crinfo_out
273 PARAMS ((bfd
*, const Elf32_crinfo
*, Elf32_External_crinfo
*));
275 #define USE_REL 1 /* MIPS uses REL relocations instead of RELA */
280 R_MIPS_16
, R_MIPS_32
,
281 R_MIPS_REL32
, R_MIPS_26
,
282 R_MIPS_HI16
, R_MIPS_LO16
,
283 R_MIPS_GPREL16
, R_MIPS_LITERAL
,
284 R_MIPS_GOT16
, R_MIPS_PC16
,
285 R_MIPS_CALL16
, R_MIPS_GPREL32
,
286 /* The remaining relocs are defined on Irix, although they are not
287 in the MIPS ELF ABI. */
288 R_MIPS_UNUSED1
, R_MIPS_UNUSED2
,
290 R_MIPS_SHIFT5
, R_MIPS_SHIFT6
,
291 R_MIPS_64
, R_MIPS_GOT_DISP
,
292 R_MIPS_GOT_PAGE
, R_MIPS_GOT_OFST
,
293 R_MIPS_GOT_HI16
, R_MIPS_GOT_LO16
,
294 R_MIPS_SUB
, R_MIPS_INSERT_A
,
295 R_MIPS_INSERT_B
, R_MIPS_DELETE
,
296 R_MIPS_HIGHER
, R_MIPS_HIGHEST
,
297 R_MIPS_CALL_HI16
, R_MIPS_CALL_LO16
,
301 static reloc_howto_type elf_mips_howto_table
[] =
304 HOWTO (R_MIPS_NONE
, /* type */
306 0, /* size (0 = byte, 1 = short, 2 = long) */
308 false, /* pc_relative */
310 complain_overflow_dont
, /* complain_on_overflow */
311 bfd_elf_generic_reloc
, /* special_function */
312 "R_MIPS_NONE", /* name */
313 false, /* partial_inplace */
316 false), /* pcrel_offset */
318 /* 16 bit relocation. */
319 HOWTO (R_MIPS_16
, /* type */
321 1, /* size (0 = byte, 1 = short, 2 = long) */
323 false, /* pc_relative */
325 complain_overflow_bitfield
, /* complain_on_overflow */
326 bfd_elf_generic_reloc
, /* special_function */
327 "R_MIPS_16", /* name */
328 true, /* partial_inplace */
329 0xffff, /* src_mask */
330 0xffff, /* dst_mask */
331 false), /* pcrel_offset */
333 /* 32 bit relocation. */
334 HOWTO (R_MIPS_32
, /* type */
336 2, /* size (0 = byte, 1 = short, 2 = long) */
338 false, /* pc_relative */
340 complain_overflow_bitfield
, /* complain_on_overflow */
341 bfd_elf_generic_reloc
, /* special_function */
342 "R_MIPS_32", /* name */
343 true, /* partial_inplace */
344 0xffffffff, /* src_mask */
345 0xffffffff, /* dst_mask */
346 false), /* pcrel_offset */
348 /* 32 bit symbol relative relocation. */
349 HOWTO (R_MIPS_REL32
, /* type */
351 2, /* size (0 = byte, 1 = short, 2 = long) */
353 false, /* pc_relative */
355 complain_overflow_bitfield
, /* complain_on_overflow */
356 bfd_elf_generic_reloc
, /* special_function */
357 "R_MIPS_REL32", /* name */
358 true, /* partial_inplace */
359 0xffffffff, /* src_mask */
360 0xffffffff, /* dst_mask */
361 false), /* pcrel_offset */
363 /* 26 bit branch address. */
364 HOWTO (R_MIPS_26
, /* type */
366 2, /* size (0 = byte, 1 = short, 2 = long) */
368 false, /* pc_relative */
370 complain_overflow_dont
, /* complain_on_overflow */
371 /* This needs complex overflow
372 detection, because the upper four
373 bits must match the PC. */
374 bfd_elf_generic_reloc
, /* special_function */
375 "R_MIPS_26", /* name */
376 true, /* partial_inplace */
377 0x3ffffff, /* src_mask */
378 0x3ffffff, /* dst_mask */
379 false), /* pcrel_offset */
381 /* High 16 bits of symbol value. */
382 HOWTO (R_MIPS_HI16
, /* type */
384 2, /* size (0 = byte, 1 = short, 2 = long) */
386 false, /* pc_relative */
388 complain_overflow_dont
, /* complain_on_overflow */
389 _bfd_mips_elf_hi16_reloc
, /* special_function */
390 "R_MIPS_HI16", /* name */
391 true, /* partial_inplace */
392 0xffff, /* src_mask */
393 0xffff, /* dst_mask */
394 false), /* pcrel_offset */
396 /* Low 16 bits of symbol value. */
397 HOWTO (R_MIPS_LO16
, /* type */
399 2, /* size (0 = byte, 1 = short, 2 = long) */
401 false, /* pc_relative */
403 complain_overflow_dont
, /* complain_on_overflow */
404 _bfd_mips_elf_lo16_reloc
, /* special_function */
405 "R_MIPS_LO16", /* name */
406 true, /* partial_inplace */
407 0xffff, /* src_mask */
408 0xffff, /* dst_mask */
409 false), /* pcrel_offset */
411 /* GP relative reference. */
412 HOWTO (R_MIPS_GPREL16
, /* type */
414 2, /* size (0 = byte, 1 = short, 2 = long) */
416 false, /* pc_relative */
418 complain_overflow_signed
, /* complain_on_overflow */
419 _bfd_mips_elf_gprel16_reloc
, /* special_function */
420 "R_MIPS_GPREL16", /* name */
421 true, /* partial_inplace */
422 0xffff, /* src_mask */
423 0xffff, /* dst_mask */
424 false), /* pcrel_offset */
426 /* Reference to literal section. */
427 HOWTO (R_MIPS_LITERAL
, /* type */
429 2, /* size (0 = byte, 1 = short, 2 = long) */
431 false, /* pc_relative */
433 complain_overflow_signed
, /* complain_on_overflow */
434 _bfd_mips_elf_gprel16_reloc
, /* special_function */
435 "R_MIPS_LITERAL", /* name */
436 true, /* partial_inplace */
437 0xffff, /* src_mask */
438 0xffff, /* dst_mask */
439 false), /* pcrel_offset */
441 /* Reference to global offset table. */
442 HOWTO (R_MIPS_GOT16
, /* type */
444 2, /* size (0 = byte, 1 = short, 2 = long) */
446 false, /* pc_relative */
448 complain_overflow_signed
, /* complain_on_overflow */
449 _bfd_mips_elf_got16_reloc
, /* special_function */
450 "R_MIPS_GOT16", /* name */
451 false, /* partial_inplace */
453 0xffff, /* dst_mask */
454 false), /* pcrel_offset */
456 /* 16 bit PC relative reference. */
457 HOWTO (R_MIPS_PC16
, /* type */
459 2, /* size (0 = byte, 1 = short, 2 = long) */
461 true, /* pc_relative */
463 complain_overflow_signed
, /* complain_on_overflow */
464 bfd_elf_generic_reloc
, /* special_function */
465 "R_MIPS_PC16", /* name */
466 true, /* partial_inplace */
467 0xffff, /* src_mask */
468 0xffff, /* dst_mask */
469 false), /* pcrel_offset */
471 /* 16 bit call through global offset table. */
472 /* FIXME: This is not handled correctly. */
473 HOWTO (R_MIPS_CALL16
, /* type */
475 2, /* size (0 = byte, 1 = short, 2 = long) */
477 false, /* pc_relative */
479 complain_overflow_signed
, /* complain_on_overflow */
480 bfd_elf_generic_reloc
, /* special_function */
481 "R_MIPS_CALL16", /* name */
482 false, /* partial_inplace */
484 0xffff, /* dst_mask */
485 false), /* pcrel_offset */
487 /* 32 bit GP relative reference. */
488 HOWTO (R_MIPS_GPREL32
, /* type */
490 2, /* size (0 = byte, 1 = short, 2 = long) */
492 false, /* pc_relative */
494 complain_overflow_bitfield
, /* complain_on_overflow */
495 _bfd_mips_elf_gprel32_reloc
, /* special_function */
496 "R_MIPS_GPREL32", /* name */
497 true, /* partial_inplace */
498 0xffffffff, /* src_mask */
499 0xffffffff, /* dst_mask */
500 false), /* pcrel_offset */
502 /* The remaining relocs are defined on Irix 5, although they are
503 not defined by the ABI. */
508 /* A 5 bit shift field. */
509 HOWTO (R_MIPS_SHIFT5
, /* type */
511 2, /* size (0 = byte, 1 = short, 2 = long) */
513 false, /* pc_relative */
515 complain_overflow_bitfield
, /* complain_on_overflow */
516 bfd_elf_generic_reloc
, /* special_function */
517 "R_MIPS_SHIFT5", /* name */
518 true, /* partial_inplace */
519 0x000007c0, /* src_mask */
520 0x000007c0, /* dst_mask */
521 false), /* pcrel_offset */
523 /* A 6 bit shift field. */
524 /* FIXME: This is not handled correctly; a special function is
525 needed to put the most significant bit in the right place. */
526 HOWTO (R_MIPS_SHIFT6
, /* 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_SHIFT6", /* name */
535 true, /* partial_inplace */
536 0x000007c4, /* src_mask */
537 0x000007c4, /* dst_mask */
538 false), /* pcrel_offset */
540 /* A 64 bit relocation. Presumably not used in 32 bit ELF. */
543 /* Displacement in the global offset table. */
544 /* FIXME: Not handled correctly. */
545 HOWTO (R_MIPS_GOT_DISP
, /* type */
547 2, /* size (0 = byte, 1 = short, 2 = long) */
549 false, /* pc_relative */
551 complain_overflow_bitfield
, /* complain_on_overflow */
552 bfd_elf_generic_reloc
, /* special_function */
553 "R_MIPS_GOT_DISP", /* name */
554 true, /* partial_inplace */
555 0x0000ffff, /* src_mask */
556 0x0000ffff, /* dst_mask */
557 false), /* pcrel_offset */
559 /* Displacement to page pointer in the global offset table. */
560 /* FIXME: Not handled correctly. */
561 HOWTO (R_MIPS_GOT_PAGE
, /* type */
563 2, /* size (0 = byte, 1 = short, 2 = long) */
565 false, /* pc_relative */
567 complain_overflow_bitfield
, /* complain_on_overflow */
568 bfd_elf_generic_reloc
, /* special_function */
569 "R_MIPS_GOT_PAGE", /* name */
570 true, /* partial_inplace */
571 0x0000ffff, /* src_mask */
572 0x0000ffff, /* dst_mask */
573 false), /* pcrel_offset */
575 /* Offset from page pointer in the global offset table. */
576 /* FIXME: Not handled correctly. */
577 HOWTO (R_MIPS_GOT_OFST
, /* 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_OFST", /* name */
586 true, /* partial_inplace */
587 0x0000ffff, /* src_mask */
588 0x0000ffff, /* dst_mask */
589 false), /* pcrel_offset */
591 /* High 16 bits of displacement in global offset table. */
592 /* FIXME: Not handled correctly. */
593 HOWTO (R_MIPS_GOT_HI16
, /* type */
595 2, /* size (0 = byte, 1 = short, 2 = long) */
597 false, /* pc_relative */
599 complain_overflow_dont
, /* complain_on_overflow */
600 bfd_elf_generic_reloc
, /* special_function */
601 "R_MIPS_GOT_HI16", /* name */
602 true, /* partial_inplace */
603 0x0000ffff, /* src_mask */
604 0x0000ffff, /* dst_mask */
605 false), /* pcrel_offset */
607 /* Low 16 bits of displacement in global offset table. */
608 /* FIXME: Not handled correctly. */
609 HOWTO (R_MIPS_GOT_LO16
, /* type */
611 2, /* size (0 = byte, 1 = short, 2 = long) */
613 false, /* pc_relative */
615 complain_overflow_dont
, /* complain_on_overflow */
616 bfd_elf_generic_reloc
, /* special_function */
617 "R_MIPS_GOT_LO16", /* name */
618 true, /* partial_inplace */
619 0x0000ffff, /* src_mask */
620 0x0000ffff, /* dst_mask */
621 false), /* pcrel_offset */
623 /* 64 bit subtraction. Presumably not used in 32 bit ELF. */
626 /* Used to cause the linker to insert and delete instructions? */
631 /* Get the higher values of a 64 bit addend. Presumably not used in
636 /* High 16 bits of displacement in global offset table. */
637 /* FIXME: Not handled correctly. */
638 HOWTO (R_MIPS_CALL_HI16
, /* type */
640 2, /* size (0 = byte, 1 = short, 2 = long) */
642 false, /* pc_relative */
644 complain_overflow_dont
, /* complain_on_overflow */
645 bfd_elf_generic_reloc
, /* special_function */
646 "R_MIPS_CALL_HI16", /* name */
647 true, /* partial_inplace */
648 0x0000ffff, /* src_mask */
649 0x0000ffff, /* dst_mask */
650 false), /* pcrel_offset */
652 /* Low 16 bits of displacement in global offset table. */
653 /* FIXME: Not handled correctly. */
654 HOWTO (R_MIPS_CALL_LO16
, /* type */
656 2, /* size (0 = byte, 1 = short, 2 = long) */
658 false, /* pc_relative */
660 complain_overflow_dont
, /* complain_on_overflow */
661 bfd_elf_generic_reloc
, /* special_function */
662 "R_MIPS_CALL_LO16", /* name */
663 true, /* partial_inplace */
664 0x0000ffff, /* src_mask */
665 0x0000ffff, /* dst_mask */
666 false) /* pcrel_offset */
669 /* Do a R_MIPS_HI16 relocation. This has to be done in combination
670 with a R_MIPS_LO16 reloc, because there is a carry from the LO16 to
671 the HI16. Here we just save the information we need; we do the
672 actual relocation when we see the LO16. MIPS ELF requires that the
673 LO16 immediately follow the HI16. As a GNU extension, we permit an
674 arbitrary number of HI16 relocs to be associated with a single LO16
675 reloc. This extension permits gcc to output the HI and LO relocs
680 struct mips_hi16
*next
;
685 /* FIXME: This should not be a static variable. */
687 static struct mips_hi16
*mips_hi16_list
;
689 bfd_reloc_status_type
690 _bfd_mips_elf_hi16_reloc (abfd
,
698 arelent
*reloc_entry
;
701 asection
*input_section
;
703 char **error_message
;
705 bfd_reloc_status_type ret
;
709 /* If we're relocating, and this an external symbol, we don't want
710 to change anything. */
711 if (output_bfd
!= (bfd
*) NULL
712 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
713 && reloc_entry
->addend
== 0)
715 reloc_entry
->address
+= input_section
->output_offset
;
721 if (strcmp (bfd_asymbol_name (symbol
), "_gp_disp") == 0)
723 boolean relocateable
;
726 if (ret
== bfd_reloc_undefined
)
729 if (output_bfd
!= NULL
)
733 relocateable
= false;
734 output_bfd
= symbol
->section
->output_section
->owner
;
737 ret
= mips_elf_final_gp (output_bfd
, symbol
, relocateable
,
739 if (ret
!= bfd_reloc_ok
)
742 relocation
= gp
- reloc_entry
->address
;
746 if (bfd_is_und_section (symbol
->section
)
747 && output_bfd
== (bfd
*) NULL
)
748 ret
= bfd_reloc_undefined
;
750 if (bfd_is_com_section (symbol
->section
))
753 relocation
= symbol
->value
;
756 relocation
+= symbol
->section
->output_section
->vma
;
757 relocation
+= symbol
->section
->output_offset
;
758 relocation
+= reloc_entry
->addend
;
760 if (reloc_entry
->address
> input_section
->_cooked_size
)
761 return bfd_reloc_outofrange
;
763 /* Save the information, and let LO16 do the actual relocation. */
764 n
= (struct mips_hi16
*) bfd_malloc (sizeof *n
);
766 return bfd_reloc_outofrange
;
767 n
->addr
= (bfd_byte
*) data
+ reloc_entry
->address
;
768 n
->addend
= relocation
;
769 n
->next
= mips_hi16_list
;
772 if (output_bfd
!= (bfd
*) NULL
)
773 reloc_entry
->address
+= input_section
->output_offset
;
778 /* Do a R_MIPS_LO16 relocation. This is a straightforward 16 bit
779 inplace relocation; this function exists in order to do the
780 R_MIPS_HI16 relocation described above. */
782 bfd_reloc_status_type
783 _bfd_mips_elf_lo16_reloc (abfd
,
791 arelent
*reloc_entry
;
794 asection
*input_section
;
796 char **error_message
;
798 arelent gp_disp_relent
;
800 if (mips_hi16_list
!= NULL
)
810 struct mips_hi16
*next
;
812 /* Do the HI16 relocation. Note that we actually don't need
813 to know anything about the LO16 itself, except where to
814 find the low 16 bits of the addend needed by the LO16. */
815 insn
= bfd_get_32 (abfd
, l
->addr
);
816 vallo
= (bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
)
818 val
= ((insn
& 0xffff) << 16) + vallo
;
821 /* The low order 16 bits are always treated as a signed
822 value. Therefore, a negative value in the low order bits
823 requires an adjustment in the high order bits. We need
824 to make this adjustment in two ways: once for the bits we
825 took from the data, and once for the bits we are putting
826 back in to the data. */
827 if ((vallo
& 0x8000) != 0)
829 if ((val
& 0x8000) != 0)
832 insn
= (insn
&~ 0xffff) | ((val
>> 16) & 0xffff);
833 bfd_put_32 (abfd
, insn
, l
->addr
);
835 if (strcmp (bfd_asymbol_name (symbol
), "_gp_disp") == 0)
837 gp_disp_relent
= *reloc_entry
;
838 reloc_entry
= &gp_disp_relent
;
839 reloc_entry
->addend
= l
->addend
;
847 mips_hi16_list
= NULL
;
849 else if (strcmp (bfd_asymbol_name (symbol
), "_gp_disp") == 0)
851 bfd_reloc_status_type ret
;
852 bfd_vma gp
, relocation
;
854 /* FIXME: Does this case ever occur? */
856 ret
= mips_elf_final_gp (output_bfd
, symbol
, true, error_message
, &gp
);
857 if (ret
!= bfd_reloc_ok
)
860 relocation
= gp
- reloc_entry
->address
;
861 relocation
+= symbol
->section
->output_section
->vma
;
862 relocation
+= symbol
->section
->output_offset
;
863 relocation
+= reloc_entry
->addend
;
865 if (reloc_entry
->address
> input_section
->_cooked_size
)
866 return bfd_reloc_outofrange
;
868 gp_disp_relent
= *reloc_entry
;
869 reloc_entry
= &gp_disp_relent
;
870 reloc_entry
->addend
= relocation
- 4;
873 /* Now do the LO16 reloc in the usual way. */
874 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
875 input_section
, output_bfd
, error_message
);
878 /* Do a R_MIPS_GOT16 reloc. This is a reloc against the global offset
879 table used for PIC code. If the symbol is an external symbol, the
880 instruction is modified to contain the offset of the appropriate
881 entry in the global offset table. If the symbol is a section
882 symbol, the next reloc is a R_MIPS_LO16 reloc. The two 16 bit
883 addends are combined to form the real addend against the section
884 symbol; the GOT16 is modified to contain the offset of an entry in
885 the global offset table, and the LO16 is modified to offset it
886 appropriately. Thus an offset larger than 16 bits requires a
887 modified value in the global offset table.
889 This implementation suffices for the assembler, but the linker does
890 not yet know how to create global offset tables. */
892 bfd_reloc_status_type
893 _bfd_mips_elf_got16_reloc (abfd
,
901 arelent
*reloc_entry
;
904 asection
*input_section
;
906 char **error_message
;
908 /* If we're relocating, and this an external symbol, we don't want
909 to change anything. */
910 if (output_bfd
!= (bfd
*) NULL
911 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
912 && reloc_entry
->addend
== 0)
914 reloc_entry
->address
+= input_section
->output_offset
;
918 /* If we're relocating, and this is a local symbol, we can handle it
920 if (output_bfd
!= (bfd
*) NULL
921 && (symbol
->flags
& BSF_SECTION_SYM
) != 0)
922 return _bfd_mips_elf_hi16_reloc (abfd
, reloc_entry
, symbol
, data
,
923 input_section
, output_bfd
, error_message
);
928 /* We have to figure out the gp value, so that we can adjust the
929 symbol value correctly. We look up the symbol _gp in the output
930 BFD. If we can't find it, we're stuck. We cache it in the ELF
931 target data. We don't need to adjust the symbol value for an
932 external symbol if we are producing relocateable output. */
934 static bfd_reloc_status_type
935 mips_elf_final_gp (output_bfd
, symbol
, relocateable
, error_message
, pgp
)
938 boolean relocateable
;
939 char **error_message
;
942 if (bfd_is_und_section (symbol
->section
)
946 return bfd_reloc_undefined
;
949 *pgp
= _bfd_get_gp_value (output_bfd
);
952 || (symbol
->flags
& BSF_SECTION_SYM
) != 0))
956 /* Make up a value. */
957 *pgp
= symbol
->section
->output_section
->vma
+ 0x4000;
958 _bfd_set_gp_value (output_bfd
, *pgp
);
966 count
= bfd_get_symcount (output_bfd
);
967 sym
= bfd_get_outsymbols (output_bfd
);
969 if (sym
== (asymbol
**) NULL
)
973 for (i
= 0; i
< count
; i
++, sym
++)
975 register CONST
char *name
;
977 name
= bfd_asymbol_name (*sym
);
978 if (*name
== '_' && strcmp (name
, "_gp") == 0)
980 *pgp
= bfd_asymbol_value (*sym
);
981 _bfd_set_gp_value (output_bfd
, *pgp
);
989 /* Only get the error once. */
991 _bfd_set_gp_value (output_bfd
, *pgp
);
993 (char *) "GP relative relocation when _gp not defined";
994 return bfd_reloc_dangerous
;
1002 /* Do a R_MIPS_GPREL16 relocation. This is a 16 bit value which must
1003 become the offset from the gp register. This function also handles
1004 R_MIPS_LITERAL relocations, although those can be handled more
1005 cleverly because the entries in the .lit8 and .lit4 sections can be
1008 static bfd_reloc_status_type gprel16_with_gp
PARAMS ((bfd
*, asymbol
*,
1009 arelent
*, asection
*,
1010 boolean
, PTR
, bfd_vma
));
1012 bfd_reloc_status_type
1013 _bfd_mips_elf_gprel16_reloc (abfd
, reloc_entry
, symbol
, data
, input_section
,
1014 output_bfd
, error_message
)
1016 arelent
*reloc_entry
;
1019 asection
*input_section
;
1021 char **error_message
;
1023 boolean relocateable
;
1024 bfd_reloc_status_type ret
;
1027 /* If we're relocating, and this is an external symbol with no
1028 addend, we don't want to change anything. We will only have an
1029 addend if this is a newly created reloc, not read from an ELF
1031 if (output_bfd
!= (bfd
*) NULL
1032 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1033 && reloc_entry
->addend
== 0)
1035 reloc_entry
->address
+= input_section
->output_offset
;
1036 return bfd_reloc_ok
;
1039 if (output_bfd
!= (bfd
*) NULL
)
1040 relocateable
= true;
1043 relocateable
= false;
1044 output_bfd
= symbol
->section
->output_section
->owner
;
1047 ret
= mips_elf_final_gp (output_bfd
, symbol
, relocateable
, error_message
,
1049 if (ret
!= bfd_reloc_ok
)
1052 return gprel16_with_gp (abfd
, symbol
, reloc_entry
, input_section
,
1053 relocateable
, data
, gp
);
1056 static bfd_reloc_status_type
1057 gprel16_with_gp (abfd
, symbol
, reloc_entry
, input_section
, relocateable
, data
,
1061 arelent
*reloc_entry
;
1062 asection
*input_section
;
1063 boolean relocateable
;
1071 if (bfd_is_com_section (symbol
->section
))
1074 relocation
= symbol
->value
;
1076 relocation
+= symbol
->section
->output_section
->vma
;
1077 relocation
+= symbol
->section
->output_offset
;
1079 if (reloc_entry
->address
> input_section
->_cooked_size
)
1080 return bfd_reloc_outofrange
;
1082 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1084 /* Set val to the offset into the section or symbol. */
1085 if (reloc_entry
->howto
->src_mask
== 0)
1087 /* This case occurs with the 64-bit MIPS ELF ABI. */
1088 val
= reloc_entry
->addend
;
1092 val
= ((insn
& 0xffff) + reloc_entry
->addend
) & 0xffff;
1097 /* Adjust val for the final section location and GP value. If we
1098 are producing relocateable output, we don't want to do this for
1099 an external symbol. */
1101 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1102 val
+= relocation
- gp
;
1104 insn
= (insn
&~ 0xffff) | (val
& 0xffff);
1105 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
);
1108 reloc_entry
->address
+= input_section
->output_offset
;
1110 /* Make sure it fit in 16 bits. */
1111 if (val
>= 0x8000 && val
< 0xffff8000)
1112 return bfd_reloc_overflow
;
1114 return bfd_reloc_ok
;
1117 /* Do a R_MIPS_GPREL32 relocation. Is this 32 bit value the offset
1118 from the gp register? XXX */
1120 static bfd_reloc_status_type gprel32_with_gp
PARAMS ((bfd
*, asymbol
*,
1121 arelent
*, asection
*,
1122 boolean
, PTR
, bfd_vma
));
1124 bfd_reloc_status_type
1125 _bfd_mips_elf_gprel32_reloc (abfd
,
1133 arelent
*reloc_entry
;
1136 asection
*input_section
;
1138 char **error_message
;
1140 boolean relocateable
;
1141 bfd_reloc_status_type ret
;
1144 /* If we're relocating, and this is an external symbol with no
1145 addend, we don't want to change anything. We will only have an
1146 addend if this is a newly created reloc, not read from an ELF
1148 if (output_bfd
!= (bfd
*) NULL
1149 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1150 && reloc_entry
->addend
== 0)
1152 *error_message
= (char *)
1153 "32bits gp relative relocation occurs for an external symbol";
1154 return bfd_reloc_outofrange
;
1157 if (output_bfd
!= (bfd
*) NULL
)
1159 relocateable
= true;
1160 gp
= _bfd_get_gp_value (output_bfd
);
1164 relocateable
= false;
1165 output_bfd
= symbol
->section
->output_section
->owner
;
1167 ret
= mips_elf_final_gp (output_bfd
, symbol
, relocateable
,
1168 error_message
, &gp
);
1169 if (ret
!= bfd_reloc_ok
)
1173 return gprel32_with_gp (abfd
, symbol
, reloc_entry
, input_section
,
1174 relocateable
, data
, gp
);
1177 static bfd_reloc_status_type
1178 gprel32_with_gp (abfd
, symbol
, reloc_entry
, input_section
, relocateable
, data
,
1182 arelent
*reloc_entry
;
1183 asection
*input_section
;
1184 boolean relocateable
;
1191 if (bfd_is_com_section (symbol
->section
))
1194 relocation
= symbol
->value
;
1196 relocation
+= symbol
->section
->output_section
->vma
;
1197 relocation
+= symbol
->section
->output_offset
;
1199 if (reloc_entry
->address
> input_section
->_cooked_size
)
1200 return bfd_reloc_outofrange
;
1202 if (reloc_entry
->howto
->src_mask
== 0)
1204 /* This case arises with the 64-bit MIPS ELF ABI. */
1208 val
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1210 /* Set val to the offset into the section or symbol. */
1211 val
+= reloc_entry
->addend
;
1213 /* Adjust val for the final section location and GP value. If we
1214 are producing relocateable output, we don't want to do this for
1215 an external symbol. */
1217 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1218 val
+= relocation
- gp
;
1220 bfd_put_32 (abfd
, val
, (bfd_byte
*) data
+ reloc_entry
->address
);
1223 reloc_entry
->address
+= input_section
->output_offset
;
1225 return bfd_reloc_ok
;
1228 /* A mapping from BFD reloc types to MIPS ELF reloc types. */
1230 struct elf_reloc_map
{
1231 bfd_reloc_code_real_type bfd_reloc_val
;
1232 enum reloc_type elf_reloc_val
;
1235 static CONST
struct elf_reloc_map mips_reloc_map
[] =
1237 { BFD_RELOC_NONE
, R_MIPS_NONE
, },
1238 { BFD_RELOC_16
, R_MIPS_16
},
1239 { BFD_RELOC_32
, R_MIPS_32
},
1240 { BFD_RELOC_CTOR
, R_MIPS_32
},
1241 { BFD_RELOC_MIPS_JMP
, R_MIPS_26
},
1242 { BFD_RELOC_HI16_S
, R_MIPS_HI16
},
1243 { BFD_RELOC_LO16
, R_MIPS_LO16
},
1244 { BFD_RELOC_MIPS_GPREL
, R_MIPS_GPREL16
},
1245 { BFD_RELOC_MIPS_LITERAL
, R_MIPS_LITERAL
},
1246 { BFD_RELOC_MIPS_GOT16
, R_MIPS_GOT16
},
1247 { BFD_RELOC_16_PCREL
, R_MIPS_PC16
},
1248 { BFD_RELOC_MIPS_CALL16
, R_MIPS_CALL16
},
1249 { BFD_RELOC_MIPS_GPREL32
, R_MIPS_GPREL32
},
1250 { BFD_RELOC_MIPS_GOT_HI16
, R_MIPS_GOT_HI16
},
1251 { BFD_RELOC_MIPS_GOT_LO16
, R_MIPS_GOT_LO16
},
1252 { BFD_RELOC_MIPS_CALL_HI16
, R_MIPS_CALL_HI16
},
1253 { BFD_RELOC_MIPS_CALL_LO16
, R_MIPS_CALL_LO16
}
1256 /* Given a BFD reloc type, return a howto structure. */
1258 static reloc_howto_type
*
1259 bfd_elf32_bfd_reloc_type_lookup (abfd
, code
)
1261 bfd_reloc_code_real_type code
;
1265 for (i
= 0; i
< sizeof (mips_reloc_map
) / sizeof (struct elf_reloc_map
); i
++)
1267 if (mips_reloc_map
[i
].bfd_reloc_val
== code
)
1268 return &elf_mips_howto_table
[(int) mips_reloc_map
[i
].elf_reloc_val
];
1273 /* Given a MIPS reloc type, fill in an arelent structure. */
1276 mips_info_to_howto_rel (abfd
, cache_ptr
, dst
)
1279 Elf32_Internal_Rel
*dst
;
1281 unsigned int r_type
;
1283 r_type
= ELF32_R_TYPE (dst
->r_info
);
1284 BFD_ASSERT (r_type
< (unsigned int) R_MIPS_max
);
1285 cache_ptr
->howto
= &elf_mips_howto_table
[r_type
];
1287 /* The addend for a GPREL16 or LITERAL relocation comes from the GP
1288 value for the object file. We get the addend now, rather than
1289 when we do the relocation, because the symbol manipulations done
1290 by the linker may cause us to lose track of the input BFD. */
1291 if (((*cache_ptr
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) != 0
1292 && (r_type
== (unsigned int) R_MIPS_GPREL16
1293 || r_type
== (unsigned int) R_MIPS_LITERAL
))
1294 cache_ptr
->addend
= elf_gp (abfd
);
1297 /* A .reginfo section holds a single Elf32_RegInfo structure. These
1298 routines swap this structure in and out. They are used outside of
1299 BFD, so they are globally visible. */
1302 bfd_mips_elf32_swap_reginfo_in (abfd
, ex
, in
)
1304 const Elf32_External_RegInfo
*ex
;
1307 in
->ri_gprmask
= bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_gprmask
);
1308 in
->ri_cprmask
[0] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[0]);
1309 in
->ri_cprmask
[1] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[1]);
1310 in
->ri_cprmask
[2] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[2]);
1311 in
->ri_cprmask
[3] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[3]);
1312 in
->ri_gp_value
= bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_gp_value
);
1316 bfd_mips_elf32_swap_reginfo_out (abfd
, in
, ex
)
1318 const Elf32_RegInfo
*in
;
1319 Elf32_External_RegInfo
*ex
;
1321 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_gprmask
,
1322 (bfd_byte
*) ex
->ri_gprmask
);
1323 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[0],
1324 (bfd_byte
*) ex
->ri_cprmask
[0]);
1325 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[1],
1326 (bfd_byte
*) ex
->ri_cprmask
[1]);
1327 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[2],
1328 (bfd_byte
*) ex
->ri_cprmask
[2]);
1329 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[3],
1330 (bfd_byte
*) ex
->ri_cprmask
[3]);
1331 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_gp_value
,
1332 (bfd_byte
*) ex
->ri_gp_value
);
1335 /* In the 64 bit ABI, the .MIPS.options section holds register
1336 information in an Elf64_Reginfo structure. These routines swap
1337 them in and out. They are globally visible because they are used
1338 outside of BFD. These routines are here so that gas can call them
1339 without worrying about whether the 64 bit ABI has been included. */
1342 bfd_mips_elf64_swap_reginfo_in (abfd
, ex
, in
)
1344 const Elf64_External_RegInfo
*ex
;
1345 Elf64_Internal_RegInfo
*in
;
1347 in
->ri_gprmask
= bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_gprmask
);
1348 in
->ri_pad
= bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_pad
);
1349 in
->ri_cprmask
[0] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[0]);
1350 in
->ri_cprmask
[1] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[1]);
1351 in
->ri_cprmask
[2] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[2]);
1352 in
->ri_cprmask
[3] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[3]);
1353 in
->ri_gp_value
= bfd_h_get_64 (abfd
, (bfd_byte
*) ex
->ri_gp_value
);
1357 bfd_mips_elf64_swap_reginfo_out (abfd
, in
, ex
)
1359 const Elf64_Internal_RegInfo
*in
;
1360 Elf64_External_RegInfo
*ex
;
1362 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_gprmask
,
1363 (bfd_byte
*) ex
->ri_gprmask
);
1364 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_pad
,
1365 (bfd_byte
*) ex
->ri_pad
);
1366 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[0],
1367 (bfd_byte
*) ex
->ri_cprmask
[0]);
1368 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[1],
1369 (bfd_byte
*) ex
->ri_cprmask
[1]);
1370 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[2],
1371 (bfd_byte
*) ex
->ri_cprmask
[2]);
1372 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[3],
1373 (bfd_byte
*) ex
->ri_cprmask
[3]);
1374 bfd_h_put_64 (abfd
, (bfd_vma
) in
->ri_gp_value
,
1375 (bfd_byte
*) ex
->ri_gp_value
);
1378 /* Swap an entry in a .gptab section. Note that these routines rely
1379 on the equivalence of the two elements of the union. */
1382 bfd_mips_elf32_swap_gptab_in (abfd
, ex
, in
)
1384 const Elf32_External_gptab
*ex
;
1387 in
->gt_entry
.gt_g_value
= bfd_h_get_32 (abfd
, ex
->gt_entry
.gt_g_value
);
1388 in
->gt_entry
.gt_bytes
= bfd_h_get_32 (abfd
, ex
->gt_entry
.gt_bytes
);
1392 bfd_mips_elf32_swap_gptab_out (abfd
, in
, ex
)
1394 const Elf32_gptab
*in
;
1395 Elf32_External_gptab
*ex
;
1397 bfd_h_put_32 (abfd
, (bfd_vma
) in
->gt_entry
.gt_g_value
,
1398 ex
->gt_entry
.gt_g_value
);
1399 bfd_h_put_32 (abfd
, (bfd_vma
) in
->gt_entry
.gt_bytes
,
1400 ex
->gt_entry
.gt_bytes
);
1404 bfd_elf32_swap_compact_rel_out (abfd
, in
, ex
)
1406 const Elf32_compact_rel
*in
;
1407 Elf32_External_compact_rel
*ex
;
1409 bfd_h_put_32 (abfd
, (bfd_vma
) in
->id1
, ex
->id1
);
1410 bfd_h_put_32 (abfd
, (bfd_vma
) in
->num
, ex
->num
);
1411 bfd_h_put_32 (abfd
, (bfd_vma
) in
->id2
, ex
->id2
);
1412 bfd_h_put_32 (abfd
, (bfd_vma
) in
->offset
, ex
->offset
);
1413 bfd_h_put_32 (abfd
, (bfd_vma
) in
->reserved0
, ex
->reserved0
);
1414 bfd_h_put_32 (abfd
, (bfd_vma
) in
->reserved1
, ex
->reserved1
);
1418 bfd_elf32_swap_crinfo_out (abfd
, in
, ex
)
1420 const Elf32_crinfo
*in
;
1421 Elf32_External_crinfo
*ex
;
1425 l
= (((in
->ctype
& CRINFO_CTYPE
) << CRINFO_CTYPE_SH
)
1426 | ((in
->rtype
& CRINFO_RTYPE
) << CRINFO_RTYPE_SH
)
1427 | ((in
->dist2to
& CRINFO_DIST2TO
) << CRINFO_DIST2TO_SH
)
1428 | ((in
->relvaddr
& CRINFO_RELVADDR
) << CRINFO_RELVADDR_SH
));
1429 bfd_h_put_32 (abfd
, (bfd_vma
) l
, ex
->info
);
1430 bfd_h_put_32 (abfd
, (bfd_vma
) in
->konst
, ex
->konst
);
1431 bfd_h_put_32 (abfd
, (bfd_vma
) in
->vaddr
, ex
->vaddr
);
1434 /* Swap in an options header. */
1437 bfd_mips_elf_swap_options_in (abfd
, ex
, in
)
1439 const Elf_External_Options
*ex
;
1440 Elf_Internal_Options
*in
;
1442 in
->kind
= bfd_h_get_8 (abfd
, ex
->kind
);
1443 in
->size
= bfd_h_get_8 (abfd
, ex
->size
);
1444 in
->section
= bfd_h_get_16 (abfd
, ex
->section
);
1445 in
->info
= bfd_h_get_32 (abfd
, ex
->info
);
1448 /* Swap out an options header. */
1451 bfd_mips_elf_swap_options_out (abfd
, in
, ex
)
1453 const Elf_Internal_Options
*in
;
1454 Elf_External_Options
*ex
;
1456 bfd_h_put_8 (abfd
, in
->kind
, ex
->kind
);
1457 bfd_h_put_8 (abfd
, in
->size
, ex
->size
);
1458 bfd_h_put_16 (abfd
, in
->section
, ex
->section
);
1459 bfd_h_put_32 (abfd
, in
->info
, ex
->info
);
1462 /* Determine whether a symbol is global for the purposes of splitting
1463 the symbol table into global symbols and local symbols. At least
1464 on Irix 5, this split must be between section symbols and all other
1465 symbols. On most ELF targets the split is between static symbols
1466 and externally visible symbols. */
1470 mips_elf_sym_is_global (abfd
, sym
)
1474 return (sym
->flags
& BSF_SECTION_SYM
) == 0 ? true : false;
1477 /* Set the right machine number for a MIPS ELF file. This is used for
1478 both the 32-bit and the 64-bit ABI. */
1481 _bfd_mips_elf_object_p (abfd
)
1484 switch (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
)
1488 /* Just use the default, which was set in elfcode.h. */
1492 (void) bfd_default_set_arch_mach (abfd
, bfd_arch_mips
, 6000);
1496 (void) bfd_default_set_arch_mach (abfd
, bfd_arch_mips
, 4000);
1500 (void) bfd_default_set_arch_mach (abfd
, bfd_arch_mips
, 8000);
1507 /* Set the right machine number for a 32-bit MIPS ELF file. */
1510 mips_elf32_object_p (abfd
)
1513 /* Irix 5 is broken. Object file symbol tables are not always
1514 sorted correctly such that local symbols precede global symbols,
1515 and the sh_info field in the symbol table is not always right. */
1516 elf_bad_symtab (abfd
) = true;
1518 return _bfd_mips_elf_object_p (abfd
);
1521 /* The final processing done just before writing out a MIPS ELF object
1522 file. This gets the MIPS architecture right based on the machine
1523 number. This is used by both the 32-bit and the 64-bit ABI. */
1527 _bfd_mips_elf_final_write_processing (abfd
, linker
)
1533 Elf_Internal_Shdr
**hdrpp
;
1537 switch (bfd_get_mach (abfd
))
1540 val
= E_MIPS_ARCH_1
;
1544 val
= E_MIPS_ARCH_2
;
1548 val
= E_MIPS_ARCH_3
;
1552 val
= E_MIPS_ARCH_4
;
1560 elf_elfheader (abfd
)->e_flags
&=~ EF_MIPS_ARCH
;
1561 elf_elfheader (abfd
)->e_flags
|= val
;
1563 /* Set the sh_info field for .gptab sections. */
1564 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
1565 i
< elf_elfheader (abfd
)->e_shnum
;
1568 switch ((*hdrpp
)->sh_type
)
1570 case SHT_MIPS_LIBLIST
:
1571 sec
= bfd_get_section_by_name (abfd
, ".dynstr");
1573 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
1576 case SHT_MIPS_GPTAB
:
1577 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
1578 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
1579 BFD_ASSERT (name
!= NULL
1580 && strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0);
1581 sec
= bfd_get_section_by_name (abfd
, name
+ sizeof ".gptab" - 1);
1582 BFD_ASSERT (sec
!= NULL
);
1583 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
1586 case SHT_MIPS_CONTENT
:
1587 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
1588 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
1589 BFD_ASSERT (name
!= NULL
1590 && strncmp (name
, ".MIPS.content",
1591 sizeof ".MIPS.content" - 1) == 0);
1592 sec
= bfd_get_section_by_name (abfd
,
1593 name
+ sizeof ".MIPS.content" - 1);
1594 BFD_ASSERT (sec
!= NULL
);
1595 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
1598 case SHT_MIPS_SYMBOL_LIB
:
1599 sec
= bfd_get_section_by_name (abfd
, ".dynsym");
1601 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
1602 sec
= bfd_get_section_by_name (abfd
, ".liblist");
1604 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
1607 case SHT_MIPS_EVENTS
:
1608 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
1609 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
1610 BFD_ASSERT (name
!= NULL
);
1611 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0)
1612 sec
= bfd_get_section_by_name (abfd
,
1613 name
+ sizeof ".MIPS.events" - 1);
1616 BFD_ASSERT (strncmp (name
, ".MIPS.post_rel",
1617 sizeof ".MIPS.post_rel" - 1) == 0);
1618 sec
= bfd_get_section_by_name (abfd
,
1620 + sizeof ".MIPS.post_rel" - 1));
1622 BFD_ASSERT (sec
!= NULL
);
1623 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
1629 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
1632 _bfd_mips_elf_set_private_flags (abfd
, flags
)
1636 BFD_ASSERT (!elf_flags_init (abfd
)
1637 || elf_elfheader (abfd
)->e_flags
== flags
);
1639 elf_elfheader (abfd
)->e_flags
= flags
;
1640 elf_flags_init (abfd
) = true;
1644 /* Copy backend specific data from one object module to another */
1647 _bfd_mips_elf_copy_private_bfd_data (ibfd
, obfd
)
1651 /* This function is selected based on the input vector. We only
1652 want to copy information over if the output BFD also uses Elf
1654 if (bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1657 BFD_ASSERT (!elf_flags_init (obfd
)
1658 || (elf_elfheader (obfd
)->e_flags
1659 == elf_elfheader (ibfd
)->e_flags
));
1661 elf_gp (obfd
) = elf_gp (ibfd
);
1662 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
1663 elf_flags_init (obfd
) = true;
1667 /* Merge backend specific data from an object file to the output
1668 object file when linking. */
1671 _bfd_mips_elf_merge_private_bfd_data (ibfd
, obfd
)
1678 /* Check if we have the same endianess */
1679 if (ibfd
->xvec
->byteorder
!= obfd
->xvec
->byteorder
1680 && obfd
->xvec
->byteorder
!= BFD_ENDIAN_UNKNOWN
)
1682 (*_bfd_error_handler
)
1683 ("%s: compiled for a %s endian system and target is %s endian",
1684 bfd_get_filename (ibfd
),
1685 bfd_big_endian (ibfd
) ? "big" : "little",
1686 bfd_big_endian (obfd
) ? "big" : "little");
1688 bfd_set_error (bfd_error_wrong_format
);
1692 /* This function is selected based on the input vector. We only
1693 want to copy information over if the output BFD also uses Elf
1695 if (bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1698 new_flags
= elf_elfheader (ibfd
)->e_flags
;
1699 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_NOREORDER
;
1700 old_flags
= elf_elfheader (obfd
)->e_flags
;
1702 if (!elf_flags_init (obfd
)) /* First call, no flags set */
1704 elf_flags_init (obfd
) = true;
1705 elf_elfheader (obfd
)->e_flags
= new_flags
;
1707 else if (((new_flags
^ old_flags
) & ~EF_MIPS_NOREORDER
)
1708 == 0) /* Compatible flags are ok */
1710 else /* Incompatible flags */
1712 /* Warn about -fPIC mismatch */
1713 if ((new_flags
& EF_MIPS_PIC
) != (old_flags
& EF_MIPS_PIC
))
1715 new_flags
&= ~EF_MIPS_PIC
;
1716 (*_bfd_error_handler
)
1717 ("%s: needs all files compiled with -fPIC",
1718 bfd_get_filename (ibfd
));
1721 if ((new_flags
& EF_MIPS_CPIC
) != (old_flags
& EF_MIPS_CPIC
))
1723 new_flags
&= ~EF_MIPS_CPIC
;
1724 (*_bfd_error_handler
)
1725 ("%s: needs all files compiled with -mabicalls",
1726 bfd_get_filename (ibfd
));
1729 /* Warn about any other mismatches */
1730 if (new_flags
!= old_flags
)
1731 (*_bfd_error_handler
)
1732 ("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)",
1733 bfd_get_filename (ibfd
), (unsigned long) new_flags
,
1734 (unsigned long) old_flags
);
1736 bfd_set_error (bfd_error_bad_value
);
1743 /* Handle a MIPS specific section when reading an object file. This
1744 is called when elfcode.h finds a section with an unknown type.
1745 This routine supports both the 32-bit and 64-bit ELF ABI.
1747 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
1751 _bfd_mips_elf_section_from_shdr (abfd
, hdr
, name
)
1753 Elf_Internal_Shdr
*hdr
;
1756 /* There ought to be a place to keep ELF backend specific flags, but
1757 at the moment there isn't one. We just keep track of the
1758 sections by their name, instead. Fortunately, the ABI gives
1759 suggested names for all the MIPS specific sections, so we will
1760 probably get away with this. */
1761 switch (hdr
->sh_type
)
1763 case SHT_MIPS_LIBLIST
:
1764 if (strcmp (name
, ".liblist") != 0)
1768 if (strcmp (name
, ".msym") != 0)
1771 case SHT_MIPS_CONFLICT
:
1772 if (strcmp (name
, ".conflict") != 0)
1775 case SHT_MIPS_GPTAB
:
1776 if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) != 0)
1779 case SHT_MIPS_UCODE
:
1780 if (strcmp (name
, ".ucode") != 0)
1783 case SHT_MIPS_DEBUG
:
1784 if (strcmp (name
, ".mdebug") != 0)
1787 case SHT_MIPS_REGINFO
:
1788 if (strcmp (name
, ".reginfo") != 0
1789 || hdr
->sh_size
!= sizeof (Elf32_External_RegInfo
))
1792 case SHT_MIPS_IFACE
:
1793 if (strcmp (name
, ".MIPS.interfaces") != 0)
1796 case SHT_MIPS_CONTENT
:
1797 if (strncmp (name
, ".MIPS.content", sizeof ".MIPS.content" - 1) != 0)
1800 case SHT_MIPS_OPTIONS
:
1801 if (strcmp (name
, ".options") != 0
1802 && strcmp (name
, ".MIPS.options") != 0)
1805 case SHT_MIPS_DWARF
:
1806 if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) != 0)
1809 case SHT_MIPS_SYMBOL_LIB
:
1810 if (strcmp (name
, ".MIPS.symlib") != 0)
1813 case SHT_MIPS_EVENTS
:
1814 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) != 0
1815 && strncmp (name
, ".MIPS.post_rel",
1816 sizeof ".MIPS.post_rel" - 1) != 0)
1823 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
1826 if (hdr
->sh_type
== SHT_MIPS_DEBUG
)
1828 if (! bfd_set_section_flags (abfd
, hdr
->bfd_section
,
1829 (bfd_get_section_flags (abfd
,
1838 /* Handle a 32-bit MIPS ELF specific section. */
1841 mips_elf32_section_from_shdr (abfd
, hdr
, name
)
1843 Elf_Internal_Shdr
*hdr
;
1846 if (! _bfd_mips_elf_section_from_shdr (abfd
, hdr
, name
))
1849 /* FIXME: We should record sh_info for a .gptab section. */
1851 /* For a .reginfo section, set the gp value in the tdata information
1852 from the contents of this section. We need the gp value while
1853 processing relocs, so we just get it now. The .reginfo section
1854 is not used in the 64-bit MIPS ELF ABI. */
1855 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
1857 Elf32_External_RegInfo ext
;
1860 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, (PTR
) &ext
,
1861 (file_ptr
) 0, sizeof ext
))
1863 bfd_mips_elf32_swap_reginfo_in (abfd
, &ext
, &s
);
1864 elf_gp (abfd
) = s
.ri_gp_value
;
1867 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
1868 set the gp value based on what we find. We may see both
1869 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
1870 they should agree. */
1871 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
)
1873 bfd_byte
*contents
, *l
, *lend
;
1875 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
1876 if (contents
== NULL
)
1878 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
,
1879 (file_ptr
) 0, hdr
->sh_size
))
1885 lend
= contents
+ hdr
->sh_size
;
1886 while (l
+ sizeof (Elf_External_Options
) <= lend
)
1888 Elf_Internal_Options intopt
;
1890 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
1892 if (intopt
.kind
== ODK_REGINFO
)
1894 Elf32_RegInfo intreg
;
1896 bfd_mips_elf32_swap_reginfo_in
1898 ((Elf32_External_RegInfo
*)
1899 (l
+ sizeof (Elf_External_Options
))),
1901 elf_gp (abfd
) = intreg
.ri_gp_value
;
1911 /* Set the correct type for a MIPS ELF section. We do this by the
1912 section name, which is a hack, but ought to work. This routine is
1913 used by both the 32-bit and the 64-bit ABI. */
1916 _bfd_mips_elf_fake_sections (abfd
, hdr
, sec
)
1918 Elf32_Internal_Shdr
*hdr
;
1921 register const char *name
;
1923 name
= bfd_get_section_name (abfd
, sec
);
1925 if (strcmp (name
, ".liblist") == 0)
1927 hdr
->sh_type
= SHT_MIPS_LIBLIST
;
1928 hdr
->sh_info
= sec
->_raw_size
/ sizeof (Elf32_Lib
);
1929 /* The sh_link field is set in final_write_processing. */
1931 else if (strcmp (name
, ".msym") == 0)
1933 hdr
->sh_type
= SHT_MIPS_MSYM
;
1934 hdr
->sh_entsize
= 8;
1935 /* FIXME: Set the sh_info field. */
1937 else if (strcmp (name
, ".conflict") == 0)
1938 hdr
->sh_type
= SHT_MIPS_CONFLICT
;
1939 else if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0)
1941 hdr
->sh_type
= SHT_MIPS_GPTAB
;
1942 hdr
->sh_entsize
= sizeof (Elf32_External_gptab
);
1943 /* The sh_info field is set in final_write_processing. */
1945 else if (strcmp (name
, ".ucode") == 0)
1946 hdr
->sh_type
= SHT_MIPS_UCODE
;
1947 else if (strcmp (name
, ".mdebug") == 0)
1949 hdr
->sh_type
= SHT_MIPS_DEBUG
;
1950 /* In a shared object on Irix 5.3, the .mdebug section has an
1951 entsize of 0. FIXME: Does this matter? */
1952 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
1953 hdr
->sh_entsize
= 0;
1955 hdr
->sh_entsize
= 1;
1957 else if (strcmp (name
, ".reginfo") == 0)
1959 hdr
->sh_type
= SHT_MIPS_REGINFO
;
1960 /* In a shared object on Irix 5.3, the .reginfo section has an
1961 entsize of 0x18. FIXME: Does this matter? */
1962 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
1963 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
1965 hdr
->sh_entsize
= 1;
1967 /* Force the section size to the correct value, even if the
1968 linker thinks it is larger. The link routine below will only
1969 write out this much data for .reginfo. */
1970 hdr
->sh_size
= sec
->_raw_size
= sizeof (Elf32_External_RegInfo
);
1972 else if (SGI_COMPAT (abfd
)
1973 && (strcmp (name
, ".hash") == 0
1974 || strcmp (name
, ".dynamic") == 0
1975 || strcmp (name
, ".dynstr") == 0))
1977 hdr
->sh_entsize
= 0;
1978 hdr
->sh_info
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
1980 else if (strcmp (name
, ".got") == 0
1981 || strcmp (name
, ".sdata") == 0
1982 || strcmp (name
, ".sbss") == 0
1983 || strcmp (name
, ".lit4") == 0
1984 || strcmp (name
, ".lit8") == 0)
1985 hdr
->sh_flags
|= SHF_MIPS_GPREL
;
1986 else if (strcmp (name
, ".MIPS.interfaces") == 0)
1988 hdr
->sh_type
= SHT_MIPS_IFACE
;
1989 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
1991 else if (strcmp (name
, ".MIPS.content") == 0)
1993 hdr
->sh_type
= SHT_MIPS_CONTENT
;
1994 /* The sh_info field is set in final_write_processing. */
1996 else if (strcmp (name
, ".options") == 0
1997 || strcmp (name
, ".MIPS.options") == 0)
1999 hdr
->sh_type
= SHT_MIPS_OPTIONS
;
2000 hdr
->sh_entsize
= 1;
2001 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
2003 else if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) == 0)
2004 hdr
->sh_type
= SHT_MIPS_DWARF
;
2005 else if (strcmp (name
, ".MIPS.symlib") == 0)
2007 hdr
->sh_type
= SHT_MIPS_SYMBOL_LIB
;
2008 /* The sh_link and sh_info fields are set in
2009 final_write_processing. */
2011 else if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0
2012 || strncmp (name
, ".MIPS.post_rel",
2013 sizeof ".MIPS.post_rel" - 1) == 0)
2015 hdr
->sh_type
= SHT_MIPS_EVENTS
;
2016 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
2017 /* The sh_link field is set in final_write_processing. */
2023 /* Given a BFD section, try to locate the corresponding ELF section
2024 index. This is used by both the 32-bit and the 64-bit ABI.
2025 Actually, it's not clear to me that the 64-bit ABI supports these,
2026 but for non-PIC objects we will certainly want support for at least
2027 the .scommon section. */
2030 _bfd_mips_elf_section_from_bfd_section (abfd
, hdr
, sec
, retval
)
2032 Elf32_Internal_Shdr
*hdr
;
2036 if (strcmp (bfd_get_section_name (abfd
, sec
), ".scommon") == 0)
2038 *retval
= SHN_MIPS_SCOMMON
;
2041 if (strcmp (bfd_get_section_name (abfd
, sec
), ".acommon") == 0)
2043 *retval
= SHN_MIPS_ACOMMON
;
2049 /* When are writing out the .options or .MIPS.options section,
2050 remember the bytes we are writing out, so that we can install the
2051 GP value in the section_processing routine. */
2054 _bfd_mips_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
2059 bfd_size_type count
;
2061 if (strcmp (section
->name
, ".options") == 0
2062 || strcmp (section
->name
, ".MIPS.options") == 0)
2066 if (elf_section_data (section
) == NULL
)
2068 section
->used_by_bfd
=
2069 (PTR
) bfd_zalloc (abfd
, sizeof (struct bfd_elf_section_data
));
2070 if (elf_section_data (section
) == NULL
)
2073 c
= (bfd_byte
*) elf_section_data (section
)->tdata
;
2078 if (section
->_cooked_size
!= 0)
2079 size
= section
->_cooked_size
;
2081 size
= section
->_raw_size
;
2082 c
= (PTR
) bfd_zalloc (abfd
, size
);
2085 elf_section_data (section
)->tdata
= (PTR
) c
;
2088 memcpy (c
+ offset
, location
, count
);
2091 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
,
2095 /* Work over a section just before writing it out. This routine is
2096 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
2097 sections that need the SHF_MIPS_GPREL flag by name; there has to be
2101 _bfd_mips_elf_section_processing (abfd
, hdr
)
2103 Elf_Internal_Shdr
*hdr
;
2105 if (hdr
->bfd_section
!= NULL
)
2107 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
2109 if (strcmp (name
, ".sdata") == 0)
2111 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
2112 hdr
->sh_type
= SHT_PROGBITS
;
2114 else if (strcmp (name
, ".sbss") == 0)
2116 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
2117 hdr
->sh_type
= SHT_NOBITS
;
2119 else if (strcmp (name
, ".lit8") == 0
2120 || strcmp (name
, ".lit4") == 0)
2122 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
2123 hdr
->sh_type
= SHT_PROGBITS
;
2125 else if (strcmp (name
, ".compact_rel") == 0)
2128 hdr
->sh_type
= SHT_PROGBITS
;
2130 else if (strcmp (name
, ".rtproc") == 0)
2132 if (hdr
->sh_addralign
!= 0 && hdr
->sh_entsize
== 0)
2134 unsigned int adjust
;
2136 adjust
= hdr
->sh_size
% hdr
->sh_addralign
;
2138 hdr
->sh_size
+= hdr
->sh_addralign
- adjust
;
2146 /* Work over a section just before writing it out. We update the GP
2147 value in the SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS sections based
2148 on the value we are using. */
2151 mips_elf32_section_processing (abfd
, hdr
)
2153 Elf32_Internal_Shdr
*hdr
;
2155 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
2159 BFD_ASSERT (hdr
->sh_size
== sizeof (Elf32_External_RegInfo
));
2160 BFD_ASSERT (hdr
->contents
== NULL
);
2163 hdr
->sh_offset
+ sizeof (Elf32_External_RegInfo
) - 4,
2166 bfd_h_put_32 (abfd
, (bfd_vma
) elf_gp (abfd
), buf
);
2167 if (bfd_write (buf
, (bfd_size_type
) 1, (bfd_size_type
) 4, abfd
) != 4)
2171 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
2172 && hdr
->bfd_section
!= NULL
2173 && elf_section_data (hdr
->bfd_section
) != NULL
2174 && elf_section_data (hdr
->bfd_section
)->tdata
!= NULL
)
2176 bfd_byte
*contents
, *l
, *lend
;
2178 /* We stored the section contents in the elf_section_data tdata
2179 field in the set_section_contents routine. We save the
2180 section contents so that we don't have to read them again.
2181 At this point we know that elf_gp is set, so we can look
2182 through the section contents to see if there is an
2183 ODK_REGINFO structure. */
2185 contents
= (bfd_byte
*) elf_section_data (hdr
->bfd_section
)->tdata
;
2187 lend
= contents
+ hdr
->sh_size
;
2188 while (l
+ sizeof (Elf_External_Options
) <= lend
)
2190 Elf_Internal_Options intopt
;
2192 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
2194 if (intopt
.kind
== ODK_REGINFO
)
2201 + sizeof (Elf_External_Options
)
2202 + (sizeof (Elf32_External_RegInfo
) - 4)),
2205 bfd_h_put_32 (abfd
, elf_gp (abfd
), buf
);
2206 if (bfd_write (buf
, 1, 4, abfd
) != 4)
2213 return _bfd_mips_elf_section_processing (abfd
, hdr
);
2216 /* MIPS ELF uses two common sections. One is the usual one, and the
2217 other is for small objects. All the small objects are kept
2218 together, and then referenced via the gp pointer, which yields
2219 faster assembler code. This is what we use for the small common
2220 section. This approach is copied from ecoff.c. */
2221 static asection mips_elf_scom_section
;
2222 static asymbol mips_elf_scom_symbol
;
2223 static asymbol
*mips_elf_scom_symbol_ptr
;
2225 /* MIPS ELF also uses an acommon section, which represents an
2226 allocated common symbol which may be overridden by a
2227 definition in a shared library. */
2228 static asection mips_elf_acom_section
;
2229 static asymbol mips_elf_acom_symbol
;
2230 static asymbol
*mips_elf_acom_symbol_ptr
;
2232 /* The Irix 5 support uses two virtual sections, which represent
2233 text/data symbols defined in dynamic objects. */
2234 static asection mips_elf_text_section
;
2235 static asection
*mips_elf_text_section_ptr
;
2236 static asymbol mips_elf_text_symbol
;
2237 static asymbol
*mips_elf_text_symbol_ptr
;
2239 static asection mips_elf_data_section
;
2240 static asection
*mips_elf_data_section_ptr
;
2241 static asymbol mips_elf_data_symbol
;
2242 static asymbol
*mips_elf_data_symbol_ptr
;
2244 /* Handle the special MIPS section numbers that a symbol may use.
2245 This is used for both the 32-bit and the 64-bit ABI. */
2248 _bfd_mips_elf_symbol_processing (abfd
, asym
)
2252 elf_symbol_type
*elfsym
;
2254 elfsym
= (elf_symbol_type
*) asym
;
2255 switch (elfsym
->internal_elf_sym
.st_shndx
)
2257 case SHN_MIPS_ACOMMON
:
2258 /* This section is used in a dynamically linked executable file.
2259 It is an allocated common section. The dynamic linker can
2260 either resolve these symbols to something in a shared
2261 library, or it can just leave them here. For our purposes,
2262 we can consider these symbols to be in a new section. */
2263 if (mips_elf_acom_section
.name
== NULL
)
2265 /* Initialize the acommon section. */
2266 mips_elf_acom_section
.name
= ".acommon";
2267 mips_elf_acom_section
.flags
= SEC_ALLOC
;
2268 mips_elf_acom_section
.output_section
= &mips_elf_acom_section
;
2269 mips_elf_acom_section
.symbol
= &mips_elf_acom_symbol
;
2270 mips_elf_acom_section
.symbol_ptr_ptr
= &mips_elf_acom_symbol_ptr
;
2271 mips_elf_acom_symbol
.name
= ".acommon";
2272 mips_elf_acom_symbol
.flags
= BSF_SECTION_SYM
;
2273 mips_elf_acom_symbol
.section
= &mips_elf_acom_section
;
2274 mips_elf_acom_symbol_ptr
= &mips_elf_acom_symbol
;
2276 asym
->section
= &mips_elf_acom_section
;
2280 /* Common symbols less than the GP size are automatically
2281 treated as SHN_MIPS_SCOMMON symbols. */
2282 if (asym
->value
> elf_gp_size (abfd
))
2285 case SHN_MIPS_SCOMMON
:
2286 if (mips_elf_scom_section
.name
== NULL
)
2288 /* Initialize the small common section. */
2289 mips_elf_scom_section
.name
= ".scommon";
2290 mips_elf_scom_section
.flags
= SEC_IS_COMMON
;
2291 mips_elf_scom_section
.output_section
= &mips_elf_scom_section
;
2292 mips_elf_scom_section
.symbol
= &mips_elf_scom_symbol
;
2293 mips_elf_scom_section
.symbol_ptr_ptr
= &mips_elf_scom_symbol_ptr
;
2294 mips_elf_scom_symbol
.name
= ".scommon";
2295 mips_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
2296 mips_elf_scom_symbol
.section
= &mips_elf_scom_section
;
2297 mips_elf_scom_symbol_ptr
= &mips_elf_scom_symbol
;
2299 asym
->section
= &mips_elf_scom_section
;
2300 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
2303 case SHN_MIPS_SUNDEFINED
:
2304 asym
->section
= bfd_und_section_ptr
;
2307 #if 0 /* for SGI_COMPAT */
2309 asym
->section
= mips_elf_text_section_ptr
;
2313 asym
->section
= mips_elf_data_section_ptr
;
2319 /* When creating an Irix 5 executable, we need REGINFO and RTPROC
2323 mips_elf_additional_program_headers (abfd
)
2331 if (! SGI_COMPAT (abfd
))
2334 s
= bfd_get_section_by_name (abfd
, ".reginfo");
2335 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2337 /* We need a PT_MIPS_REGINFO segment. */
2341 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
2342 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
2344 /* We need a PT_MIPS_RTPROC segment. */
2351 /* Modify the segment map for an Irix 5 executable. */
2354 mips_elf_modify_segment_map (abfd
)
2358 struct elf_segment_map
*m
, **pm
;
2360 if (! SGI_COMPAT (abfd
))
2363 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
2365 s
= bfd_get_section_by_name (abfd
, ".reginfo");
2366 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2368 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2369 if (m
->p_type
== PT_MIPS_REGINFO
)
2373 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, sizeof *m
);
2377 m
->p_type
= PT_MIPS_REGINFO
;
2381 /* We want to put it after the PHDR and INTERP segments. */
2382 pm
= &elf_tdata (abfd
)->segment_map
;
2384 && ((*pm
)->p_type
== PT_PHDR
2385 || (*pm
)->p_type
== PT_INTERP
))
2393 /* If there are .dynamic and .mdebug sections, we make a room for
2394 the RTPROC header. FIXME: Rewrite without section names. */
2395 if (bfd_get_section_by_name (abfd
, ".interp") == NULL
2396 && bfd_get_section_by_name (abfd
, ".dynamic") != NULL
2397 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
2399 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2400 if (m
->p_type
== PT_MIPS_RTPROC
)
2404 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, sizeof *m
);
2408 m
->p_type
= PT_MIPS_RTPROC
;
2410 s
= bfd_get_section_by_name (abfd
, ".rtproc");
2415 m
->p_flags_valid
= 1;
2423 /* We want to put it after the DYNAMIC segment. */
2424 pm
= &elf_tdata (abfd
)->segment_map
;
2425 while (*pm
!= NULL
&& (*pm
)->p_type
!= PT_DYNAMIC
)
2435 /* On Irix 5, the PT_DYNAMIC segment includes the .dynamic, .dynstr,
2436 .dynsym, and .hash sections, and everything in between. */
2437 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
; pm
= &(*pm
)->next
)
2438 if ((*pm
)->p_type
== PT_DYNAMIC
)
2443 && strcmp (m
->sections
[0]->name
, ".dynamic") == 0)
2445 static const char *sec_names
[] =
2446 { ".dynamic", ".dynstr", ".dynsym", ".hash" };
2449 struct elf_segment_map
*n
;
2453 for (i
= 0; i
< sizeof sec_names
/ sizeof sec_names
[0]; i
++)
2455 s
= bfd_get_section_by_name (abfd
, sec_names
[i
]);
2456 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2462 sz
= s
->_cooked_size
;
2465 if (high
< s
->vma
+ sz
)
2471 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2472 if ((s
->flags
& SEC_LOAD
) != 0
2475 + (s
->_cooked_size
!= 0 ? s
->_cooked_size
: s
->_raw_size
))
2479 n
= ((struct elf_segment_map
*)
2480 bfd_zalloc (abfd
, sizeof *n
+ (c
- 1) * sizeof (asection
*)));
2487 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2489 if ((s
->flags
& SEC_LOAD
) != 0
2492 + (s
->_cooked_size
!= 0 ? s
->_cooked_size
: s
->_raw_size
))
2506 /* The structure of the runtime procedure descriptor created by the
2507 loader for use by the static exception system. */
2509 typedef struct runtime_pdr
{
2510 bfd_vma adr
; /* memory address of start of procedure */
2511 long regmask
; /* save register mask */
2512 long regoffset
; /* save register offset */
2513 long fregmask
; /* save floating point register mask */
2514 long fregoffset
; /* save floating point register offset */
2515 long frameoffset
; /* frame size */
2516 short framereg
; /* frame pointer register */
2517 short pcreg
; /* offset or reg of return pc */
2518 long irpss
; /* index into the runtime string table */
2520 struct exception_info
*exception_info
;/* pointer to exception array */
2522 #define cbRPDR sizeof(RPDR)
2523 #define rpdNil ((pRPDR) 0)
2525 /* Swap RPDR (runtime procedure table entry) for output. */
2527 static void ecoff_swap_rpdr_out
2528 PARAMS ((bfd
*, const RPDR
*, struct rpdr_ext
*));
2531 ecoff_swap_rpdr_out (abfd
, in
, ex
)
2534 struct rpdr_ext
*ex
;
2536 /* ecoff_put_off was defined in ecoffswap.h. */
2537 ecoff_put_off (abfd
, in
->adr
, (bfd_byte
*) ex
->p_adr
);
2538 bfd_h_put_32 (abfd
, in
->regmask
, (bfd_byte
*) ex
->p_regmask
);
2539 bfd_h_put_32 (abfd
, in
->regoffset
, (bfd_byte
*) ex
->p_regoffset
);
2540 bfd_h_put_32 (abfd
, in
->fregmask
, (bfd_byte
*) ex
->p_fregmask
);
2541 bfd_h_put_32 (abfd
, in
->fregoffset
, (bfd_byte
*) ex
->p_fregoffset
);
2542 bfd_h_put_32 (abfd
, in
->frameoffset
, (bfd_byte
*) ex
->p_frameoffset
);
2544 bfd_h_put_16 (abfd
, in
->framereg
, (bfd_byte
*) ex
->p_framereg
);
2545 bfd_h_put_16 (abfd
, in
->pcreg
, (bfd_byte
*) ex
->p_pcreg
);
2547 bfd_h_put_32 (abfd
, in
->irpss
, (bfd_byte
*) ex
->p_irpss
);
2549 ecoff_put_off (abfd
, in
->exception_info
, (bfd_byte
*) ex
->p_exception_info
);
2553 /* Read ECOFF debugging information from a .mdebug section into a
2554 ecoff_debug_info structure. */
2557 _bfd_mips_elf_read_ecoff_info (abfd
, section
, debug
)
2560 struct ecoff_debug_info
*debug
;
2563 const struct ecoff_debug_swap
*swap
;
2564 char *ext_hdr
= NULL
;
2566 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
2568 ext_hdr
= (char *) bfd_malloc ((size_t) swap
->external_hdr_size
);
2569 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
2572 if (bfd_get_section_contents (abfd
, section
, ext_hdr
, (file_ptr
) 0,
2573 swap
->external_hdr_size
)
2577 symhdr
= &debug
->symbolic_header
;
2578 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
2580 /* The symbolic header contains absolute file offsets and sizes to
2582 #define READ(ptr, offset, count, size, type) \
2583 if (symhdr->count == 0) \
2584 debug->ptr = NULL; \
2587 debug->ptr = (type) bfd_malloc ((size_t) (size * symhdr->count)); \
2588 if (debug->ptr == NULL) \
2589 goto error_return; \
2590 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
2591 || (bfd_read (debug->ptr, size, symhdr->count, \
2592 abfd) != size * symhdr->count)) \
2593 goto error_return; \
2596 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
2597 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, PTR
);
2598 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, PTR
);
2599 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, PTR
);
2600 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, PTR
);
2601 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
2603 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
2604 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
2605 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, PTR
);
2606 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, PTR
);
2607 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, PTR
);
2611 debug
->adjust
= NULL
;
2616 if (ext_hdr
!= NULL
)
2618 if (debug
->line
!= NULL
)
2620 if (debug
->external_dnr
!= NULL
)
2621 free (debug
->external_dnr
);
2622 if (debug
->external_pdr
!= NULL
)
2623 free (debug
->external_pdr
);
2624 if (debug
->external_sym
!= NULL
)
2625 free (debug
->external_sym
);
2626 if (debug
->external_opt
!= NULL
)
2627 free (debug
->external_opt
);
2628 if (debug
->external_aux
!= NULL
)
2629 free (debug
->external_aux
);
2630 if (debug
->ss
!= NULL
)
2632 if (debug
->ssext
!= NULL
)
2633 free (debug
->ssext
);
2634 if (debug
->external_fdr
!= NULL
)
2635 free (debug
->external_fdr
);
2636 if (debug
->external_rfd
!= NULL
)
2637 free (debug
->external_rfd
);
2638 if (debug
->external_ext
!= NULL
)
2639 free (debug
->external_ext
);
2643 /* MIPS ELF local labels start with '$', not 'L'. */
2647 mips_elf_is_local_label (abfd
, symbol
)
2651 return symbol
->name
[0] == '$';
2654 /* MIPS ELF uses a special find_nearest_line routine in order the
2655 handle the ECOFF debugging information. */
2657 struct mips_elf_find_line
2659 struct ecoff_debug_info d
;
2660 struct ecoff_find_line i
;
2664 _bfd_mips_elf_find_nearest_line (abfd
, section
, symbols
, offset
, filename_ptr
,
2665 functionname_ptr
, line_ptr
)
2670 const char **filename_ptr
;
2671 const char **functionname_ptr
;
2672 unsigned int *line_ptr
;
2676 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
2680 struct mips_elf_find_line
*fi
;
2681 const struct ecoff_debug_swap
* const swap
=
2682 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
2684 /* If we are called during a link, mips_elf_final_link may have
2685 cleared the SEC_HAS_CONTENTS field. We force it back on here
2686 if appropriate (which it normally will be). */
2687 origflags
= msec
->flags
;
2688 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
2689 msec
->flags
|= SEC_HAS_CONTENTS
;
2691 fi
= elf_tdata (abfd
)->find_line_info
;
2694 bfd_size_type external_fdr_size
;
2697 struct fdr
*fdr_ptr
;
2699 fi
= ((struct mips_elf_find_line
*)
2700 bfd_zalloc (abfd
, sizeof (struct mips_elf_find_line
)));
2703 msec
->flags
= origflags
;
2707 if (! _bfd_mips_elf_read_ecoff_info (abfd
, msec
, &fi
->d
))
2709 msec
->flags
= origflags
;
2713 /* Swap in the FDR information. */
2714 fi
->d
.fdr
= ((struct fdr
*)
2716 (fi
->d
.symbolic_header
.ifdMax
*
2717 sizeof (struct fdr
))));
2718 if (fi
->d
.fdr
== NULL
)
2720 msec
->flags
= origflags
;
2723 external_fdr_size
= swap
->external_fdr_size
;
2724 fdr_ptr
= fi
->d
.fdr
;
2725 fraw_src
= (char *) fi
->d
.external_fdr
;
2726 fraw_end
= (fraw_src
2727 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
2728 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
2729 (*swap
->swap_fdr_in
) (abfd
, (PTR
) fraw_src
, fdr_ptr
);
2731 elf_tdata (abfd
)->find_line_info
= fi
;
2733 /* Note that we don't bother to ever free this information.
2734 find_nearest_line is either called all the time, as in
2735 objdump -l, so the information should be saved, or it is
2736 rarely called, as in ld error messages, so the memory
2737 wasted is unimportant. Still, it would probably be a
2738 good idea for free_cached_info to throw it away. */
2741 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
2742 &fi
->i
, filename_ptr
, functionname_ptr
,
2745 msec
->flags
= origflags
;
2749 msec
->flags
= origflags
;
2752 /* Fall back on the generic ELF find_nearest_line routine. */
2754 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
2755 filename_ptr
, functionname_ptr
,
2759 /* The MIPS ELF linker needs additional information for each symbol in
2760 the global hash table. */
2762 struct mips_elf_link_hash_entry
2764 struct elf_link_hash_entry root
;
2766 /* External symbol information. */
2769 /* Number of MIPS_32 or MIPS_REL32 relocs against this symbol. */
2770 unsigned int mips_32_relocs
;
2773 /* MIPS ELF linker hash table. */
2775 struct mips_elf_link_hash_table
2777 struct elf_link_hash_table root
;
2778 /* String section indices for the dynamic section symbols. */
2779 bfd_size_type dynsym_sec_strindex
[SIZEOF_MIPS_DYNSYM_SECNAMES
];
2780 /* The number of .rtproc entries. */
2781 bfd_size_type procedure_count
;
2782 /* The size of the .compact_rel section (if SGI_COMPAT). */
2783 bfd_size_type compact_rel_size
;
2784 /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic
2785 entry is set to the address of __rld_obj_head as in Irix 5. */
2786 boolean use_rld_obj_head
;
2787 /* This is the value of the __rld_map or __rld_obj_head symbol. */
2791 /* Look up an entry in a MIPS ELF linker hash table. */
2793 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
2794 ((struct mips_elf_link_hash_entry *) \
2795 elf_link_hash_lookup (&(table)->root, (string), (create), \
2798 /* Traverse a MIPS ELF linker hash table. */
2800 #define mips_elf_link_hash_traverse(table, func, info) \
2801 (elf_link_hash_traverse \
2803 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
2806 /* Get the MIPS ELF linker hash table from a link_info structure. */
2808 #define mips_elf_hash_table(p) \
2809 ((struct mips_elf_link_hash_table *) ((p)->hash))
2811 static boolean mips_elf_output_extsym
2812 PARAMS ((struct mips_elf_link_hash_entry
*, PTR
));
2814 /* Create an entry in a MIPS ELF linker hash table. */
2816 static struct bfd_hash_entry
*
2817 mips_elf_link_hash_newfunc (entry
, table
, string
)
2818 struct bfd_hash_entry
*entry
;
2819 struct bfd_hash_table
*table
;
2822 struct mips_elf_link_hash_entry
*ret
=
2823 (struct mips_elf_link_hash_entry
*) entry
;
2825 /* Allocate the structure if it has not already been allocated by a
2827 if (ret
== (struct mips_elf_link_hash_entry
*) NULL
)
2828 ret
= ((struct mips_elf_link_hash_entry
*)
2829 bfd_hash_allocate (table
,
2830 sizeof (struct mips_elf_link_hash_entry
)));
2831 if (ret
== (struct mips_elf_link_hash_entry
*) NULL
)
2832 return (struct bfd_hash_entry
*) ret
;
2834 /* Call the allocation method of the superclass. */
2835 ret
= ((struct mips_elf_link_hash_entry
*)
2836 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
2838 if (ret
!= (struct mips_elf_link_hash_entry
*) NULL
)
2840 /* Set local fields. */
2841 memset (&ret
->esym
, 0, sizeof (EXTR
));
2842 /* We use -2 as a marker to indicate that the information has
2843 not been set. -1 means there is no associated ifd. */
2845 ret
->mips_32_relocs
= 0;
2848 return (struct bfd_hash_entry
*) ret
;
2851 /* Create a MIPS ELF linker hash table. */
2853 static struct bfd_link_hash_table
*
2854 mips_elf_link_hash_table_create (abfd
)
2857 struct mips_elf_link_hash_table
*ret
;
2860 ret
= ((struct mips_elf_link_hash_table
*)
2861 bfd_alloc (abfd
, sizeof (struct mips_elf_link_hash_table
)));
2862 if (ret
== (struct mips_elf_link_hash_table
*) NULL
)
2865 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
2866 mips_elf_link_hash_newfunc
))
2868 bfd_release (abfd
, ret
);
2872 for (i
= 0; i
< SIZEOF_MIPS_DYNSYM_SECNAMES
; i
++)
2873 ret
->dynsym_sec_strindex
[i
] = (bfd_size_type
) -1;
2874 ret
->procedure_count
= 0;
2875 ret
->compact_rel_size
= 0;
2876 ret
->use_rld_obj_head
= false;
2879 return &ret
->root
.root
;
2882 /* Hook called by the linker routine which adds symbols from an object
2883 file. We must handle the special MIPS section numbers here. */
2887 mips_elf_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
, secp
, valp
)
2889 struct bfd_link_info
*info
;
2890 const Elf_Internal_Sym
*sym
;
2896 if (SGI_COMPAT (abfd
)
2897 && (abfd
->flags
& DYNAMIC
) != 0
2898 && strcmp (*namep
, "_rld_new_interface") == 0)
2900 /* Skip Irix 5 rld entry name. */
2905 switch (sym
->st_shndx
)
2908 /* Common symbols less than the GP size are automatically
2909 treated as SHN_MIPS_SCOMMON symbols. */
2910 if (sym
->st_size
> elf_gp_size (abfd
))
2913 case SHN_MIPS_SCOMMON
:
2914 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
2915 (*secp
)->flags
|= SEC_IS_COMMON
;
2916 *valp
= sym
->st_size
;
2920 /* This section is used in a shared object. */
2921 if (mips_elf_text_section_ptr
== NULL
)
2923 /* Initialize the section. */
2924 mips_elf_text_section
.name
= ".text";
2925 mips_elf_text_section
.flags
= SEC_NO_FLAGS
;
2926 mips_elf_text_section
.output_section
= NULL
;
2927 mips_elf_text_section
.owner
= abfd
;
2928 mips_elf_text_section
.symbol
= &mips_elf_text_symbol
;
2929 mips_elf_text_section
.symbol_ptr_ptr
= &mips_elf_text_symbol_ptr
;
2930 mips_elf_text_symbol
.name
= ".text";
2931 mips_elf_text_symbol
.flags
= BSF_SECTION_SYM
;
2932 mips_elf_text_symbol
.section
= &mips_elf_text_section
;
2933 mips_elf_text_symbol_ptr
= &mips_elf_text_symbol
;
2934 mips_elf_text_section_ptr
= &mips_elf_text_section
;
2937 *secp
= bfd_und_section_ptr
;
2939 *secp
= mips_elf_text_section_ptr
;
2942 case SHN_MIPS_ACOMMON
:
2943 /* Fall through. XXX Can we treat this as allocated data? */
2945 /* This section is used in a shared object. */
2946 if (mips_elf_data_section_ptr
== NULL
)
2948 /* Initialize the section. */
2949 mips_elf_data_section
.name
= ".data";
2950 mips_elf_data_section
.flags
= SEC_NO_FLAGS
;
2951 mips_elf_data_section
.output_section
= NULL
;
2952 mips_elf_data_section
.owner
= abfd
;
2953 mips_elf_data_section
.symbol
= &mips_elf_data_symbol
;
2954 mips_elf_data_section
.symbol_ptr_ptr
= &mips_elf_data_symbol_ptr
;
2955 mips_elf_data_symbol
.name
= ".data";
2956 mips_elf_data_symbol
.flags
= BSF_SECTION_SYM
;
2957 mips_elf_data_symbol
.section
= &mips_elf_data_section
;
2958 mips_elf_data_symbol_ptr
= &mips_elf_data_symbol
;
2959 mips_elf_data_section_ptr
= &mips_elf_data_section
;
2962 *secp
= bfd_und_section_ptr
;
2964 *secp
= mips_elf_data_section_ptr
;
2967 case SHN_MIPS_SUNDEFINED
:
2968 *secp
= bfd_und_section_ptr
;
2972 if (SGI_COMPAT (abfd
)
2974 && info
->hash
->creator
== abfd
->xvec
2975 && strcmp (*namep
, "__rld_obj_head") == 0)
2977 struct elf_link_hash_entry
*h
;
2979 /* Mark __rld_obj_head as dynamic. */
2981 if (! (_bfd_generic_link_add_one_symbol
2982 (info
, abfd
, *namep
, BSF_GLOBAL
, *secp
,
2983 (bfd_vma
) *valp
, (const char *) NULL
, false,
2984 get_elf_backend_data (abfd
)->collect
,
2985 (struct bfd_link_hash_entry
**) &h
)))
2987 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
2988 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2989 h
->type
= STT_OBJECT
;
2991 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2994 mips_elf_hash_table (info
)->use_rld_obj_head
= true;
3000 /* Structure used to pass information to mips_elf_output_extsym. */
3005 struct bfd_link_info
*info
;
3006 struct ecoff_debug_info
*debug
;
3007 const struct ecoff_debug_swap
*swap
;
3011 /* This routine is used to write out ECOFF debugging external symbol
3012 information. It is called via mips_elf_link_hash_traverse. The
3013 ECOFF external symbol information must match the ELF external
3014 symbol information. Unfortunately, at this point we don't know
3015 whether a symbol is required by reloc information, so the two
3016 tables may wind up being different. We must sort out the external
3017 symbol information before we can set the final size of the .mdebug
3018 section, and we must set the size of the .mdebug section before we
3019 can relocate any sections, and we can't know which symbols are
3020 required by relocation until we relocate the sections.
3021 Fortunately, it is relatively unlikely that any symbol will be
3022 stripped but required by a reloc. In particular, it can not happen
3023 when generating a final executable. */
3026 mips_elf_output_extsym (h
, data
)
3027 struct mips_elf_link_hash_entry
*h
;
3030 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
3032 asection
*sec
, *output_section
;
3034 if (h
->root
.indx
== -2)
3036 else if (((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
3037 || (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
3038 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
3039 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
3041 else if (einfo
->info
->strip
== strip_all
3042 || (einfo
->info
->strip
== strip_some
3043 && bfd_hash_lookup (einfo
->info
->keep_hash
,
3044 h
->root
.root
.root
.string
,
3045 false, false) == NULL
))
3053 if (h
->esym
.ifd
== -2)
3056 h
->esym
.cobol_main
= 0;
3057 h
->esym
.weakext
= 0;
3058 h
->esym
.reserved
= 0;
3059 h
->esym
.ifd
= ifdNil
;
3060 h
->esym
.asym
.value
= 0;
3061 h
->esym
.asym
.st
= stGlobal
;
3063 if (SGI_COMPAT (einfo
->abfd
)
3064 && (h
->root
.root
.type
== bfd_link_hash_undefined
3065 || h
->root
.root
.type
== bfd_link_hash_undefweak
))
3069 /* Use undefined class. Also, set class and type for some
3071 name
= h
->root
.root
.root
.string
;
3072 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
3073 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
3075 h
->esym
.asym
.sc
= scData
;
3076 h
->esym
.asym
.st
= stLabel
;
3077 h
->esym
.asym
.value
= 0;
3079 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
3081 h
->esym
.asym
.sc
= scAbs
;
3082 h
->esym
.asym
.st
= stLabel
;
3083 h
->esym
.asym
.value
=
3084 mips_elf_hash_table (einfo
->info
)->procedure_count
;
3086 else if (strcmp (name
, "_gp_disp") == 0)
3088 h
->esym
.asym
.sc
= scAbs
;
3089 h
->esym
.asym
.st
= stLabel
;
3090 h
->esym
.asym
.value
= elf_gp (einfo
->abfd
);
3093 h
->esym
.asym
.sc
= scUndefined
;
3095 else if (h
->root
.root
.type
!= bfd_link_hash_defined
3096 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
3097 h
->esym
.asym
.sc
= scAbs
;
3102 sec
= h
->root
.root
.u
.def
.section
;
3103 output_section
= sec
->output_section
;
3105 /* When making a shared library and symbol h is the one from
3106 the another shared library, OUTPUT_SECTION may be null. */
3107 if (output_section
== NULL
)
3108 h
->esym
.asym
.sc
= scUndefined
;
3111 name
= bfd_section_name (output_section
->owner
, output_section
);
3113 if (strcmp (name
, ".text") == 0)
3114 h
->esym
.asym
.sc
= scText
;
3115 else if (strcmp (name
, ".data") == 0)
3116 h
->esym
.asym
.sc
= scData
;
3117 else if (strcmp (name
, ".sdata") == 0)
3118 h
->esym
.asym
.sc
= scSData
;
3119 else if (strcmp (name
, ".rodata") == 0
3120 || strcmp (name
, ".rdata") == 0)
3121 h
->esym
.asym
.sc
= scRData
;
3122 else if (strcmp (name
, ".bss") == 0)
3123 h
->esym
.asym
.sc
= scBss
;
3124 else if (strcmp (name
, ".sbss") == 0)
3125 h
->esym
.asym
.sc
= scSBss
;
3126 else if (strcmp (name
, ".init") == 0)
3127 h
->esym
.asym
.sc
= scInit
;
3128 else if (strcmp (name
, ".fini") == 0)
3129 h
->esym
.asym
.sc
= scFini
;
3131 h
->esym
.asym
.sc
= scAbs
;
3135 h
->esym
.asym
.reserved
= 0;
3136 h
->esym
.asym
.index
= indexNil
;
3139 if (h
->root
.root
.type
== bfd_link_hash_common
)
3140 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
3141 else if (h
->root
.root
.type
== bfd_link_hash_defined
3142 || h
->root
.root
.type
== bfd_link_hash_defweak
)
3144 if (h
->esym
.asym
.sc
== scCommon
)
3145 h
->esym
.asym
.sc
= scBss
;
3146 else if (h
->esym
.asym
.sc
== scSCommon
)
3147 h
->esym
.asym
.sc
= scSBss
;
3149 sec
= h
->root
.root
.u
.def
.section
;
3150 output_section
= sec
->output_section
;
3151 if (output_section
!= NULL
)
3152 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
3153 + sec
->output_offset
3154 + output_section
->vma
);
3156 h
->esym
.asym
.value
= 0;
3158 else if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
3160 /* Set type and value for a symbol with a function stub. */
3161 h
->esym
.asym
.st
= stProc
;
3162 sec
= h
->root
.root
.u
.def
.section
;
3164 h
->esym
.asym
.value
= 0;
3167 output_section
= sec
->output_section
;
3168 if (output_section
!= NULL
)
3169 h
->esym
.asym
.value
= (h
->root
.plt_offset
3170 + sec
->output_offset
3171 + output_section
->vma
);
3173 h
->esym
.asym
.value
= 0;
3180 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
3181 h
->root
.root
.root
.string
,
3184 einfo
->failed
= true;
3191 /* Create a runtime procedure table from the .mdebug section. */
3194 mips_elf_create_procedure_table (handle
, abfd
, info
, s
, debug
)
3197 struct bfd_link_info
*info
;
3199 struct ecoff_debug_info
*debug
;
3201 const struct ecoff_debug_swap
*swap
;
3202 HDRR
*hdr
= &debug
->symbolic_header
;
3204 struct rpdr_ext
*erp
;
3206 struct pdr_ext
*epdr
;
3207 struct sym_ext
*esym
;
3210 unsigned long size
, count
;
3211 unsigned long sindex
;
3215 const char *no_name_func
= "static procedure (no name)";
3223 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
3225 sindex
= strlen (no_name_func
) + 1;
3226 count
= hdr
->ipdMax
;
3229 size
= swap
->external_pdr_size
;
3231 epdr
= (struct pdr_ext
*) bfd_malloc (size
* count
);
3235 if (! _bfd_ecoff_get_accumulated_pdr (handle
, (PTR
) epdr
))
3238 size
= sizeof (RPDR
);
3239 rp
= rpdr
= (RPDR
*) bfd_malloc (size
* count
);
3243 sv
= (char **) bfd_malloc (sizeof (char *) * count
);
3247 count
= hdr
->isymMax
;
3248 size
= swap
->external_sym_size
;
3249 esym
= (struct sym_ext
*) bfd_malloc (size
* count
);
3253 if (! _bfd_ecoff_get_accumulated_sym (handle
, (PTR
) esym
))
3256 count
= hdr
->issMax
;
3257 ss
= (char *) bfd_malloc (count
);
3260 if (! _bfd_ecoff_get_accumulated_ss (handle
, (PTR
) ss
))
3263 count
= hdr
->ipdMax
;
3264 for (i
= 0; i
< count
; i
++, rp
++)
3266 (*swap
->swap_pdr_in
) (abfd
, (PTR
) (epdr
+ i
), &pdr
);
3267 (*swap
->swap_sym_in
) (abfd
, (PTR
) &esym
[pdr
.isym
], &sym
);
3268 rp
->adr
= sym
.value
;
3269 rp
->regmask
= pdr
.regmask
;
3270 rp
->regoffset
= pdr
.regoffset
;
3271 rp
->fregmask
= pdr
.fregmask
;
3272 rp
->fregoffset
= pdr
.fregoffset
;
3273 rp
->frameoffset
= pdr
.frameoffset
;
3274 rp
->framereg
= pdr
.framereg
;
3275 rp
->pcreg
= pdr
.pcreg
;
3277 sv
[i
] = ss
+ sym
.iss
;
3278 sindex
+= strlen (sv
[i
]) + 1;
3282 size
= sizeof (struct rpdr_ext
) * (count
+ 2) + sindex
;
3283 size
= BFD_ALIGN (size
, 16);
3284 rtproc
= (PTR
) bfd_alloc (abfd
, size
);
3287 mips_elf_hash_table (info
)->procedure_count
= 0;
3291 mips_elf_hash_table (info
)->procedure_count
= count
+ 2;
3293 erp
= (struct rpdr_ext
*) rtproc
;
3294 memset (erp
, 0, sizeof (struct rpdr_ext
));
3296 str
= (char *) rtproc
+ sizeof (struct rpdr_ext
) * (count
+ 2);
3297 strcpy (str
, no_name_func
);
3298 str
+= strlen (no_name_func
) + 1;
3299 for (i
= 0; i
< count
; i
++)
3301 ecoff_swap_rpdr_out (abfd
, rpdr
+ i
, erp
+ i
);
3302 strcpy (str
, sv
[i
]);
3303 str
+= strlen (sv
[i
]) + 1;
3305 ecoff_put_off (abfd
, (bfd_vma
) -1, (bfd_byte
*) (erp
+ count
)->p_adr
);
3307 /* Set the size and contents of .rtproc section. */
3308 s
->_raw_size
= size
;
3309 s
->contents
= rtproc
;
3311 /* Skip this section later on (I don't think this currently
3312 matters, but someday it might). */
3313 s
->link_order_head
= (struct bfd_link_order
*) NULL
;
3342 /* A comparison routine used to sort .gptab entries. */
3345 gptab_compare (p1
, p2
)
3349 const Elf32_gptab
*a1
= (const Elf32_gptab
*) p1
;
3350 const Elf32_gptab
*a2
= (const Elf32_gptab
*) p2
;
3352 return a1
->gt_entry
.gt_g_value
- a2
->gt_entry
.gt_g_value
;
3355 /* We need to use a special link routine to handle the .reginfo and
3356 the .mdebug sections. We need to merge all instances of these
3357 sections together, not write them all out sequentially. */
3360 mips_elf_final_link (abfd
, info
)
3362 struct bfd_link_info
*info
;
3366 struct bfd_link_order
*p
;
3367 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
3368 asection
*rtproc_sec
;
3369 Elf32_RegInfo reginfo
;
3370 struct ecoff_debug_info debug
;
3371 const struct ecoff_debug_swap
*swap
3372 = get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
3373 HDRR
*symhdr
= &debug
.symbolic_header
;
3374 PTR mdebug_handle
= NULL
;
3376 /* Drop the .options section, since it has special semantics which I
3377 haven't bothered to figure out. */
3378 for (secpp
= &abfd
->sections
; *secpp
!= NULL
; secpp
= &(*secpp
)->next
)
3380 if (strcmp ((*secpp
)->name
, ".options") == 0)
3382 for (p
= (*secpp
)->link_order_head
; p
!= NULL
; p
= p
->next
)
3383 if (p
->type
== bfd_indirect_link_order
)
3384 p
->u
.indirect
.section
->flags
&=~ SEC_HAS_CONTENTS
;
3385 (*secpp
)->link_order_head
= NULL
;
3386 *secpp
= (*secpp
)->next
;
3387 --abfd
->section_count
;
3392 /* Get a value for the GP register. */
3393 if (elf_gp (abfd
) == 0)
3395 struct bfd_link_hash_entry
*h
;
3397 h
= bfd_link_hash_lookup (info
->hash
, "_gp", false, false, true);
3398 if (h
!= (struct bfd_link_hash_entry
*) NULL
3399 && h
->type
== bfd_link_hash_defined
)
3400 elf_gp (abfd
) = (h
->u
.def
.value
3401 + h
->u
.def
.section
->output_section
->vma
3402 + h
->u
.def
.section
->output_offset
);
3403 else if (info
->relocateable
)
3407 /* Make up a value. */
3409 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
3412 && (strcmp (o
->name
, ".sbss") == 0
3413 || strcmp (o
->name
, ".sdata") == 0
3414 || strcmp (o
->name
, ".lit4") == 0
3415 || strcmp (o
->name
, ".lit8") == 0))
3418 elf_gp (abfd
) = lo
+ ELF_MIPS_GP_OFFSET (abfd
);
3422 /* If the relocate_section function needs to do a reloc
3423 involving the GP value, it should make a reloc_dangerous
3424 callback to warn that GP is not defined. */
3428 /* Go through the sections and collect the .reginfo and .mdebug
3432 gptab_data_sec
= NULL
;
3433 gptab_bss_sec
= NULL
;
3434 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
3436 if (strcmp (o
->name
, ".reginfo") == 0)
3438 memset (®info
, 0, sizeof reginfo
);
3440 /* We have found the .reginfo section in the output file.
3441 Look through all the link_orders comprising it and merge
3442 the information together. */
3443 for (p
= o
->link_order_head
;
3444 p
!= (struct bfd_link_order
*) NULL
;
3447 asection
*input_section
;
3449 Elf32_External_RegInfo ext
;
3452 if (p
->type
!= bfd_indirect_link_order
)
3454 if (p
->type
== bfd_fill_link_order
)
3459 input_section
= p
->u
.indirect
.section
;
3460 input_bfd
= input_section
->owner
;
3462 /* The linker emulation code has probably clobbered the
3463 size to be zero bytes. */
3464 if (input_section
->_raw_size
== 0)
3465 input_section
->_raw_size
= sizeof (Elf32_External_RegInfo
);
3467 if (! bfd_get_section_contents (input_bfd
, input_section
,
3473 bfd_mips_elf32_swap_reginfo_in (input_bfd
, &ext
, &sub
);
3475 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
3476 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
3477 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
3478 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
3479 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
3481 /* ri_gp_value is set by the function
3482 mips_elf32_section_processing when the section is
3483 finally written out. */
3485 /* Hack: reset the SEC_HAS_CONTENTS flag so that
3486 elf_link_input_bfd ignores this section. */
3487 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
3490 /* Force the section size to the value we want. */
3491 o
->_raw_size
= sizeof (Elf32_External_RegInfo
);
3493 /* Skip this section later on (I don't think this currently
3494 matters, but someday it might). */
3495 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
3500 if (strcmp (o
->name
, ".mdebug") == 0)
3502 struct extsym_info einfo
;
3504 /* We have found the .mdebug section in the output file.
3505 Look through all the link_orders comprising it and merge
3506 the information together. */
3507 symhdr
->magic
= swap
->sym_magic
;
3508 /* FIXME: What should the version stamp be? */
3510 symhdr
->ilineMax
= 0;
3514 symhdr
->isymMax
= 0;
3515 symhdr
->ioptMax
= 0;
3516 symhdr
->iauxMax
= 0;
3518 symhdr
->issExtMax
= 0;
3521 symhdr
->iextMax
= 0;
3523 /* We accumulate the debugging information itself in the
3524 debug_info structure. */
3526 debug
.external_dnr
= NULL
;
3527 debug
.external_pdr
= NULL
;
3528 debug
.external_sym
= NULL
;
3529 debug
.external_opt
= NULL
;
3530 debug
.external_aux
= NULL
;
3532 debug
.ssext
= debug
.ssext_end
= NULL
;
3533 debug
.external_fdr
= NULL
;
3534 debug
.external_rfd
= NULL
;
3535 debug
.external_ext
= debug
.external_ext_end
= NULL
;
3537 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
3538 if (mdebug_handle
== (PTR
) NULL
)
3541 if (SGI_COMPAT (abfd
))
3547 static const char * const name
[] =
3548 { ".text", ".init", ".fini", ".data",
3549 ".rodata", ".sdata", ".sbss", ".bss" };
3550 static const int sc
[] = { scText
, scInit
, scFini
, scData
,
3551 scRData
, scSData
, scSBss
, scBss
};
3554 esym
.cobol_main
= 0;
3558 esym
.asym
.iss
= issNil
;
3559 esym
.asym
.st
= stLocal
;
3560 esym
.asym
.reserved
= 0;
3561 esym
.asym
.index
= indexNil
;
3562 for (i
= 0; i
< 8; i
++)
3564 esym
.asym
.sc
= sc
[i
];
3565 s
= bfd_get_section_by_name (abfd
, name
[i
]);
3568 esym
.asym
.value
= s
->vma
;
3569 last
= s
->vma
+ s
->_raw_size
;
3572 esym
.asym
.value
= last
;
3574 if (! bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
3580 for (p
= o
->link_order_head
;
3581 p
!= (struct bfd_link_order
*) NULL
;
3584 asection
*input_section
;
3586 const struct ecoff_debug_swap
*input_swap
;
3587 struct ecoff_debug_info input_debug
;
3591 if (p
->type
!= bfd_indirect_link_order
)
3593 if (p
->type
== bfd_fill_link_order
)
3598 input_section
= p
->u
.indirect
.section
;
3599 input_bfd
= input_section
->owner
;
3601 if (bfd_get_flavour (input_bfd
) != bfd_target_elf_flavour
3602 || (get_elf_backend_data (input_bfd
)
3603 ->elf_backend_ecoff_debug_swap
) == NULL
)
3605 /* I don't know what a non MIPS ELF bfd would be
3606 doing with a .mdebug section, but I don't really
3607 want to deal with it. */
3611 input_swap
= (get_elf_backend_data (input_bfd
)
3612 ->elf_backend_ecoff_debug_swap
);
3614 BFD_ASSERT (p
->size
== input_section
->_raw_size
);
3616 /* The ECOFF linking code expects that we have already
3617 read in the debugging information and set up an
3618 ecoff_debug_info structure, so we do that now. */
3619 if (! _bfd_mips_elf_read_ecoff_info (input_bfd
, input_section
,
3623 if (! (bfd_ecoff_debug_accumulate
3624 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
3625 &input_debug
, input_swap
, info
)))
3628 /* Loop through the external symbols. For each one with
3629 interesting information, try to find the symbol in
3630 the linker global hash table and save the information
3631 for the output external symbols. */
3632 eraw_src
= input_debug
.external_ext
;
3633 eraw_end
= (eraw_src
3634 + (input_debug
.symbolic_header
.iextMax
3635 * input_swap
->external_ext_size
));
3637 eraw_src
< eraw_end
;
3638 eraw_src
+= input_swap
->external_ext_size
)
3642 struct mips_elf_link_hash_entry
*h
;
3644 (*input_swap
->swap_ext_in
) (input_bfd
, (PTR
) eraw_src
, &ext
);
3645 if (ext
.asym
.sc
== scNil
3646 || ext
.asym
.sc
== scUndefined
3647 || ext
.asym
.sc
== scSUndefined
)
3650 name
= input_debug
.ssext
+ ext
.asym
.iss
;
3651 h
= mips_elf_link_hash_lookup (mips_elf_hash_table (info
),
3652 name
, false, false, true);
3653 if (h
== NULL
|| h
->esym
.ifd
!= -2)
3659 < input_debug
.symbolic_header
.ifdMax
);
3660 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
3666 /* Free up the information we just read. */
3667 free (input_debug
.line
);
3668 free (input_debug
.external_dnr
);
3669 free (input_debug
.external_pdr
);
3670 free (input_debug
.external_sym
);
3671 free (input_debug
.external_opt
);
3672 free (input_debug
.external_aux
);
3673 free (input_debug
.ss
);
3674 free (input_debug
.ssext
);
3675 free (input_debug
.external_fdr
);
3676 free (input_debug
.external_rfd
);
3677 free (input_debug
.external_ext
);
3679 /* Hack: reset the SEC_HAS_CONTENTS flag so that
3680 elf_link_input_bfd ignores this section. */
3681 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
3684 if (SGI_COMPAT (abfd
) && info
->shared
)
3686 /* Create .rtproc section. */
3687 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
3688 if (rtproc_sec
== NULL
)
3690 flagword flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3693 rtproc_sec
= bfd_make_section (abfd
, ".rtproc");
3694 if (rtproc_sec
== NULL
3695 || ! bfd_set_section_flags (abfd
, rtproc_sec
, flags
)
3696 || ! bfd_set_section_alignment (abfd
, rtproc_sec
, 12))
3700 if (! mips_elf_create_procedure_table (mdebug_handle
, abfd
,
3701 info
, rtproc_sec
, &debug
))
3705 /* Build the external symbol information. */
3708 einfo
.debug
= &debug
;
3710 einfo
.failed
= false;
3711 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
3712 mips_elf_output_extsym
,
3717 /* Set the size of the .mdebug section. */
3718 o
->_raw_size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
3720 /* Skip this section later on (I don't think this currently
3721 matters, but someday it might). */
3722 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
3727 if (strncmp (o
->name
, ".gptab.", sizeof ".gptab." - 1) == 0)
3729 const char *subname
;
3732 Elf32_External_gptab
*ext_tab
;
3735 /* The .gptab.sdata and .gptab.sbss sections hold
3736 information describing how the small data area would
3737 change depending upon the -G switch. These sections
3738 not used in executables files. */
3739 if (! info
->relocateable
)
3743 for (p
= o
->link_order_head
;
3744 p
!= (struct bfd_link_order
*) NULL
;
3747 asection
*input_section
;
3749 if (p
->type
!= bfd_indirect_link_order
)
3751 if (p
->type
== bfd_fill_link_order
)
3756 input_section
= p
->u
.indirect
.section
;
3758 /* Hack: reset the SEC_HAS_CONTENTS flag so that
3759 elf_link_input_bfd ignores this section. */
3760 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
3763 /* Skip this section later on (I don't think this
3764 currently matters, but someday it might). */
3765 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
3767 /* Really remove the section. */
3768 for (secpp
= &abfd
->sections
;
3770 secpp
= &(*secpp
)->next
)
3772 *secpp
= (*secpp
)->next
;
3773 --abfd
->section_count
;
3778 /* There is one gptab for initialized data, and one for
3779 uninitialized data. */
3780 if (strcmp (o
->name
, ".gptab.sdata") == 0)
3782 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
3786 (*_bfd_error_handler
)
3787 ("%s: illegal section name `%s'",
3788 bfd_get_filename (abfd
), o
->name
);
3789 bfd_set_error (bfd_error_nonrepresentable_section
);
3793 /* The linker script always combines .gptab.data and
3794 .gptab.sdata into .gptab.sdata, and likewise for
3795 .gptab.bss and .gptab.sbss. It is possible that there is
3796 no .sdata or .sbss section in the output file, in which
3797 case we must change the name of the output section. */
3798 subname
= o
->name
+ sizeof ".gptab" - 1;
3799 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
3801 if (o
== gptab_data_sec
)
3802 o
->name
= ".gptab.data";
3804 o
->name
= ".gptab.bss";
3805 subname
= o
->name
+ sizeof ".gptab" - 1;
3806 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
3809 /* Set up the first entry. */
3811 tab
= (Elf32_gptab
*) bfd_malloc (c
* sizeof (Elf32_gptab
));
3814 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
3815 tab
[0].gt_header
.gt_unused
= 0;
3817 /* Combine the input sections. */
3818 for (p
= o
->link_order_head
;
3819 p
!= (struct bfd_link_order
*) NULL
;
3822 asection
*input_section
;
3826 bfd_size_type gpentry
;
3828 if (p
->type
!= bfd_indirect_link_order
)
3830 if (p
->type
== bfd_fill_link_order
)
3835 input_section
= p
->u
.indirect
.section
;
3836 input_bfd
= input_section
->owner
;
3838 /* Combine the gptab entries for this input section one
3839 by one. We know that the input gptab entries are
3840 sorted by ascending -G value. */
3841 size
= bfd_section_size (input_bfd
, input_section
);
3843 for (gpentry
= sizeof (Elf32_External_gptab
);
3845 gpentry
+= sizeof (Elf32_External_gptab
))
3847 Elf32_External_gptab ext_gptab
;
3848 Elf32_gptab int_gptab
;
3854 if (! (bfd_get_section_contents
3855 (input_bfd
, input_section
, (PTR
) &ext_gptab
,
3856 gpentry
, sizeof (Elf32_External_gptab
))))
3862 bfd_mips_elf32_swap_gptab_in (input_bfd
, &ext_gptab
,
3864 val
= int_gptab
.gt_entry
.gt_g_value
;
3865 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
3868 for (look
= 1; look
< c
; look
++)
3870 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
3871 tab
[look
].gt_entry
.gt_bytes
+= add
;
3873 if (tab
[look
].gt_entry
.gt_g_value
== val
)
3879 Elf32_gptab
*new_tab
;
3882 /* We need a new table entry. */
3883 new_tab
= ((Elf32_gptab
*)
3884 bfd_realloc ((PTR
) tab
,
3885 (c
+ 1) * sizeof (Elf32_gptab
)));
3886 if (new_tab
== NULL
)
3892 tab
[c
].gt_entry
.gt_g_value
= val
;
3893 tab
[c
].gt_entry
.gt_bytes
= add
;
3895 /* Merge in the size for the next smallest -G
3896 value, since that will be implied by this new
3899 for (look
= 1; look
< c
; look
++)
3901 if (tab
[look
].gt_entry
.gt_g_value
< val
3903 || (tab
[look
].gt_entry
.gt_g_value
3904 > tab
[max
].gt_entry
.gt_g_value
)))
3908 tab
[c
].gt_entry
.gt_bytes
+=
3909 tab
[max
].gt_entry
.gt_bytes
;
3914 last
= int_gptab
.gt_entry
.gt_bytes
;
3917 /* Hack: reset the SEC_HAS_CONTENTS flag so that
3918 elf_link_input_bfd ignores this section. */
3919 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
3922 /* The table must be sorted by -G value. */
3924 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
3926 /* Swap out the table. */
3927 ext_tab
= ((Elf32_External_gptab
*)
3928 bfd_alloc (abfd
, c
* sizeof (Elf32_External_gptab
)));
3929 if (ext_tab
== NULL
)
3935 for (i
= 0; i
< c
; i
++)
3936 bfd_mips_elf32_swap_gptab_out (abfd
, tab
+ i
, ext_tab
+ i
);
3939 o
->_raw_size
= c
* sizeof (Elf32_External_gptab
);
3940 o
->contents
= (bfd_byte
*) ext_tab
;
3942 /* Skip this section later on (I don't think this currently
3943 matters, but someday it might). */
3944 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
3948 /* Invoke the regular ELF backend linker to do all the work. */
3949 if (! bfd_elf32_bfd_final_link (abfd
, info
))
3952 /* Now write out the computed sections. */
3954 if (reginfo_sec
!= (asection
*) NULL
)
3956 Elf32_External_RegInfo ext
;
3958 bfd_mips_elf32_swap_reginfo_out (abfd
, ®info
, &ext
);
3959 if (! bfd_set_section_contents (abfd
, reginfo_sec
, (PTR
) &ext
,
3960 (file_ptr
) 0, sizeof ext
))
3964 if (mdebug_sec
!= (asection
*) NULL
)
3966 BFD_ASSERT (abfd
->output_has_begun
);
3967 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
3969 mdebug_sec
->filepos
))
3972 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
3975 if (gptab_data_sec
!= (asection
*) NULL
)
3977 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
3978 gptab_data_sec
->contents
,
3980 gptab_data_sec
->_raw_size
))
3984 if (gptab_bss_sec
!= (asection
*) NULL
)
3986 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
3987 gptab_bss_sec
->contents
,
3989 gptab_bss_sec
->_raw_size
))
3993 if (SGI_COMPAT (abfd
))
3995 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
3996 if (rtproc_sec
!= NULL
)
3998 if (! bfd_set_section_contents (abfd
, rtproc_sec
,
3999 rtproc_sec
->contents
,
4001 rtproc_sec
->_raw_size
))
4009 /* Handle a MIPS ELF HI16 reloc. */
4012 mips_elf_relocate_hi16 (input_bfd
, relhi
, rello
, contents
, addend
)
4014 Elf_Internal_Rela
*relhi
;
4015 Elf_Internal_Rela
*rello
;
4022 insn
= bfd_get_32 (input_bfd
, contents
+ relhi
->r_offset
);
4024 addlo
= bfd_get_32 (input_bfd
, contents
+ rello
->r_offset
);
4027 addend
+= ((insn
& 0xffff) << 16) + addlo
;
4029 if ((addlo
& 0x8000) != 0)
4031 if ((addend
& 0x8000) != 0)
4034 bfd_put_32 (input_bfd
,
4035 (insn
& 0xffff0000) | ((addend
>> 16) & 0xffff),
4036 contents
+ relhi
->r_offset
);
4039 /* Handle a MIPS ELF local GOT16 reloc. */
4042 mips_elf_relocate_got_local (output_bfd
, input_bfd
, sgot
, relhi
, rello
,
4047 Elf_Internal_Rela
*relhi
;
4048 Elf_Internal_Rela
*rello
;
4058 bfd_byte
*got_contents
;
4059 struct mips_got_info
*g
;
4061 insn
= bfd_get_32 (input_bfd
, contents
+ relhi
->r_offset
);
4063 addlo
= bfd_get_32 (input_bfd
, contents
+ rello
->r_offset
);
4066 addend
+= ((insn
& 0xffff) << 16) + addlo
;
4068 if ((addlo
& 0x8000) != 0)
4070 if ((addend
& 0x8000) != 0)
4073 /* Get a got entry representing requested hipage. */
4074 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
4075 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
4076 BFD_ASSERT (g
!= NULL
);
4078 local_gotno
= g
->local_gotno
;
4079 got_contents
= sgot
->contents
;
4080 hipage
= addend
& 0xffff0000;
4082 for (i
= MIPS_RESERVED_GOTNO
; i
< local_gotno
; i
++)
4084 address
= bfd_get_32 (input_bfd
, got_contents
+ i
* 4);
4085 if (hipage
== (address
& 0xffff0000))
4087 if (address
== (bfd_vma
) 0)
4089 bfd_put_32 (input_bfd
, hipage
, got_contents
+ i
* 4);
4094 BFD_ASSERT (i
< local_gotno
);
4096 if (i
== local_gotno
)
4097 (*_bfd_error_handler
)
4098 ("ELF MIPS linker: more got entries are needed for hipage: %x",
4102 i
= - ELF_MIPS_GP_OFFSET (output_bfd
) + i
* 4;
4103 bfd_put_32 (input_bfd
, (insn
& 0xffff0000) | (i
& 0xffff),
4104 contents
+ relhi
->r_offset
);
4107 /* Handle MIPS ELF CALL16 reloc and global GOT16 reloc. */
4110 mips_elf_relocate_global_got (input_bfd
, rel
, contents
, offset
)
4112 Elf_Internal_Rela
*rel
;
4118 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
4119 bfd_put_32 (input_bfd
,
4120 (insn
& 0xffff0000) | (offset
& 0xffff),
4121 contents
+ rel
->r_offset
);
4124 /* Relocate a MIPS ELF section. */
4127 mips_elf_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
4128 contents
, relocs
, local_syms
, local_sections
)
4130 struct bfd_link_info
*info
;
4132 asection
*input_section
;
4134 Elf_Internal_Rela
*relocs
;
4135 Elf_Internal_Sym
*local_syms
;
4136 asection
**local_sections
;
4138 Elf_Internal_Shdr
*symtab_hdr
;
4141 asection
*sgot
, *sreloc
, *scpt
;
4144 Elf_Internal_Rela
*rel
;
4145 Elf_Internal_Rela
*relend
;
4146 struct mips_got_info
*g
;
4148 dynobj
= elf_hash_table (info
)->dynobj
;
4149 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
4153 if (dynobj
== NULL
|| ! SGI_COMPAT (output_bfd
))
4156 scpt
= bfd_get_section_by_name (dynobj
, ".compact_rel");
4159 if (elf_bad_symtab (input_bfd
))
4161 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
4166 locsymcount
= symtab_hdr
->sh_info
;
4167 extsymoff
= symtab_hdr
->sh_info
;
4170 gp
= _bfd_get_gp_value (output_bfd
);
4173 relend
= relocs
+ input_section
->reloc_count
;
4174 for (; rel
< relend
; rel
++)
4177 reloc_howto_type
*howto
;
4178 unsigned long r_symndx
;
4180 struct elf_link_hash_entry
*h
;
4182 Elf_Internal_Sym
*sym
;
4183 bfd_reloc_status_type r
;
4185 r_type
= ELF32_R_TYPE (rel
->r_info
);
4186 if (r_type
< 0 || r_type
>= (int) R_MIPS_max
)
4188 bfd_set_error (bfd_error_bad_value
);
4191 howto
= elf_mips_howto_table
+ r_type
;
4194 && (r_type
== R_MIPS_CALL16
4195 || r_type
== R_MIPS_GOT16
4196 || r_type
== R_MIPS_CALL_HI16
4197 || r_type
== R_MIPS_CALL_LO16
4198 || r_type
== R_MIPS_GOT_HI16
4199 || r_type
== R_MIPS_GOT_LO16
))
4201 /* We need the .got section. */
4204 sgot
= bfd_get_section_by_name (dynobj
, ".got");
4205 BFD_ASSERT (sgot
!= NULL
);
4206 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
4207 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
4208 BFD_ASSERT (g
!= NULL
);
4212 r_symndx
= ELF32_R_SYM (rel
->r_info
);
4214 /* Mix in the change in GP address for a GP relative reloc. */
4215 if (r_type
!= R_MIPS_GPREL16
4216 && r_type
!= R_MIPS_LITERAL
4217 && r_type
!= R_MIPS_GPREL32
)
4223 if (! ((*info
->callbacks
->reloc_dangerous
)
4225 "GP relative relocation when GP not defined",
4226 input_bfd
, input_section
,
4229 /* Only give the error once per link. */
4231 _bfd_set_gp_value (output_bfd
, gp
);
4234 if (r_symndx
< extsymoff
4235 || (elf_bad_symtab (input_bfd
)
4236 && local_sections
[r_symndx
] != NULL
))
4238 /* This is a relocation against a section. The current
4239 addend in the instruction is the difference between
4240 INPUT_SECTION->vma and the GP value of INPUT_BFD. We
4241 must change this to be the difference between the
4242 final definition (which will end up in RELOCATION)
4243 and the GP value of OUTPUT_BFD (which is in GP). */
4244 addend
= elf_gp (input_bfd
) - gp
;
4246 else if (! info
->relocateable
)
4248 /* We are doing a final link. The current addend in the
4249 instruction is simply the desired offset into the
4250 symbol (normally zero). We want the instruction to
4251 hold the difference between the final definition of
4252 the symbol (which will end up in RELOCATION) and the
4253 GP value of OUTPUT_BFD (which is in GP). */
4258 /* We are generating relocateable output, and we aren't
4259 going to define this symbol, so we just leave the
4260 instruction alone. */
4268 if (info
->relocateable
)
4270 /* This is a relocateable link. We don't have to change
4271 anything, unless the reloc is against a section symbol,
4272 in which case we have to adjust according to where the
4273 section symbol winds up in the output section. */
4274 if (r_symndx
>= locsymcount
4275 || (elf_bad_symtab (input_bfd
)
4276 && local_sections
[r_symndx
] == NULL
))
4280 sym
= local_syms
+ r_symndx
;
4281 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4285 sec
= local_sections
[r_symndx
];
4287 /* It would be logical to add sym->st_value here,
4288 but Irix 5 sometimes generates a garbage symbol
4290 addend
+= sec
->output_offset
;
4292 /* If this is HI16 or GOT16 with an associated LO16,
4293 adjust the addend accordingly. Otherwise, just
4295 if (r_type
!= R_MIPS_HI16
&& r_type
!= R_MIPS_GOT16
)
4296 r
= _bfd_relocate_contents (howto
, input_bfd
,
4298 contents
+ rel
->r_offset
);
4301 Elf_Internal_Rela
*lorel
;
4303 /* As a GNU extension, permit an arbitrary
4304 number of R_MIPS_HI16 relocs before the
4305 R_MIPS_LO16 reloc. This permits gcc to emit
4306 the HI and LO relocs itself. */
4307 if (r_type
== R_MIPS_GOT16
)
4311 for (lorel
= rel
+ 1;
4313 && (ELF32_R_TYPE (lorel
->r_info
)
4319 && ELF32_R_TYPE (lorel
->r_info
) == R_MIPS_LO16
)
4321 mips_elf_relocate_hi16 (input_bfd
, rel
, lorel
,
4326 r
= _bfd_relocate_contents (howto
, input_bfd
,
4328 contents
+ rel
->r_offset
);
4338 /* This is a final link. */
4340 if (r_symndx
< extsymoff
4341 || (elf_bad_symtab (input_bfd
)
4342 && local_sections
[r_symndx
] != NULL
))
4345 sym
= local_syms
+ r_symndx
;
4346 sec
= local_sections
[r_symndx
];
4347 relocation
= (sec
->output_section
->vma
4348 + sec
->output_offset
);
4350 /* It would be logical to always add sym->st_value here,
4351 but Irix 5 sometimes generates a garbage symbol
4353 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4354 relocation
+= sym
->st_value
;
4361 indx
= r_symndx
- extsymoff
;
4362 h
= elf_sym_hashes (input_bfd
)[indx
];
4363 while (h
->root
.type
== bfd_link_hash_indirect
4364 || h
->root
.type
== bfd_link_hash_warning
)
4365 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4366 if (strcmp (h
->root
.root
.string
, "_gp_disp") == 0)
4370 if (! ((*info
->callbacks
->reloc_dangerous
)
4372 "_gp_disp used when GP not defined",
4373 input_bfd
, input_section
,
4376 /* Only give the error once per link. */
4378 _bfd_set_gp_value (output_bfd
, gp
);
4383 sec
= input_section
;
4384 if (sec
->output_section
!= NULL
)
4387 + sec
->output_section
->vma
4388 + sec
->output_offset
));
4390 relocation
= gp
- rel
->r_offset
;
4391 if (r_type
== R_MIPS_LO16
)
4395 else if (h
->root
.type
== bfd_link_hash_defined
4396 || h
->root
.type
== bfd_link_hash_defweak
)
4398 sec
= h
->root
.u
.def
.section
;
4399 if (sec
->output_section
== NULL
)
4402 relocation
= (h
->root
.u
.def
.value
4403 + sec
->output_section
->vma
4404 + sec
->output_offset
);
4406 else if (h
->root
.type
== bfd_link_hash_undefweak
)
4408 else if (info
->shared
&& ! info
->symbolic
)
4410 else if (strcmp (h
->root
.root
.string
, "_DYNAMIC_LINK") == 0)
4412 /* If this is a dynamic link, we should have created
4413 a _DYNAMIC_LINK symbol in
4414 mips_elf_create_dynamic_sections. Otherwise, we
4415 should define the symbol with a value of 0.
4416 FIXME: It should probably get into the symbol
4417 table somehow as well. */
4418 BFD_ASSERT (! info
->shared
);
4419 BFD_ASSERT (bfd_get_section_by_name (output_bfd
,
4420 ".dynamic") == NULL
);
4425 if (! ((*info
->callbacks
->undefined_symbol
)
4426 (info
, h
->root
.root
.string
, input_bfd
,
4427 input_section
, rel
->r_offset
)))
4433 if (r_type
== R_MIPS_HI16
)
4435 Elf_Internal_Rela
*lorel
;
4437 /* As a GNU extension, permit an arbitrary number of
4438 R_MIPS_HI16 relocs before the R_MIPS_LO16 reloc.
4439 This permits gcc to emit the HI and LO relocs itself. */
4440 for (lorel
= rel
+ 1;
4442 && ELF32_R_TYPE (lorel
->r_info
) == R_MIPS_HI16
);
4446 && ELF32_R_TYPE (lorel
->r_info
) == R_MIPS_LO16
)
4448 mips_elf_relocate_hi16 (input_bfd
, rel
, lorel
,
4449 contents
, relocation
+ addend
);
4453 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4454 contents
, rel
->r_offset
,
4455 relocation
, addend
);
4457 else if (r_type
== R_MIPS_GOT16
&& local
)
4459 /* GOT16 must also have an associated LO16 in the local
4460 case. In this case, the addend is extracted and the
4461 section in which the referenced object is determined.
4462 Then the final address of the object is computed and
4463 the GOT entry for the hipage (an aligned 64kb chunk)
4464 is added to .got section if needed. The offset field
4465 of the GOT16-relocated instruction is replaced by the
4466 index of this GOT entry for the hipage. */
4467 if ((rel
+ 1) < relend
4468 && ELF32_R_TYPE ((rel
+ 1)->r_info
) == R_MIPS_LO16
)
4470 mips_elf_relocate_got_local (output_bfd
, input_bfd
, sgot
,
4473 relocation
+ addend
);
4477 r
= bfd_reloc_outofrange
;
4479 else if (r_type
== R_MIPS_CALL16
4480 || r_type
== R_MIPS_GOT16
4481 || r_type
== R_MIPS_CALL_LO16
4482 || r_type
== R_MIPS_GOT_LO16
)
4486 /* This symbol must be registered as a global symbol
4487 having the corresponding got entry. */
4488 BFD_ASSERT (h
->got_offset
!= (bfd_vma
) -1);
4490 offset
= (h
->dynindx
- g
->global_gotsym
+ g
->local_gotno
) * 4;
4491 BFD_ASSERT (g
->local_gotno
<= offset
4492 && offset
< sgot
->_raw_size
);
4493 bfd_put_32 (output_bfd
, relocation
+ addend
,
4494 sgot
->contents
+ offset
);
4495 offset
= (sgot
->output_section
->vma
+ sgot
->output_offset
4497 mips_elf_relocate_global_got (input_bfd
, rel
, contents
,
4501 else if (r_type
== R_MIPS_CALL_HI16
4502 || r_type
== R_MIPS_GOT_HI16
)
4506 /* This must be a global symbol with a got entry. The
4507 next reloc must be the corresponding LO16 reloc. */
4508 BFD_ASSERT (h
!= NULL
&& h
->got_offset
!= (bfd_vma
) -1);
4509 BFD_ASSERT ((rel
+ 1) < relend
);
4510 BFD_ASSERT (ELF32_R_TYPE ((rel
+ 1)->r_info
)
4511 == (r_type
== R_MIPS_CALL_HI16
4513 : R_MIPS_GOT_LO16
));
4515 offset
= (h
->dynindx
- g
->global_gotsym
+ g
->local_gotno
) * 4;
4516 BFD_ASSERT (g
->local_gotno
<= offset
4517 && offset
< sgot
->_raw_size
);
4518 bfd_put_32 (output_bfd
, relocation
+ addend
,
4519 sgot
->contents
+ offset
);
4520 offset
= (sgot
->output_section
->vma
+ sgot
->output_offset
4522 mips_elf_relocate_hi16 (input_bfd
, rel
, rel
+ 1, contents
,
4526 else if (r_type
== R_MIPS_REL32
4527 || r_type
== R_MIPS_32
)
4529 Elf_Internal_Rel outrel
;
4530 Elf32_crinfo cptrel
;
4534 || (elf_hash_table (info
)->dynamic_sections_created
4536 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)
4538 && (input_section
->flags
& SEC_ALLOC
) != 0)
4540 /* When generating a shared object, these
4541 relocations are copied into the output file to be
4542 resolved at run time. */
4545 sreloc
= bfd_get_section_by_name (dynobj
, ".rel.dyn");
4546 BFD_ASSERT (sreloc
!= NULL
);
4549 outrel
.r_offset
= (rel
->r_offset
4550 + input_section
->output_section
->vma
4551 + input_section
->output_offset
);
4553 addend
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
4556 && (! info
->symbolic
4557 || (h
->elf_link_hash_flags
4558 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
4560 BFD_ASSERT (h
->dynindx
!= -1);
4561 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_REL32
);
4562 sec
= input_section
;
4569 sec
= local_sections
[r_symndx
];
4572 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
4574 == bfd_link_hash_defweak
));
4575 sec
= h
->root
.u
.def
.section
;
4577 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
4579 else if (sec
== NULL
|| sec
->owner
== NULL
)
4581 bfd_set_error (bfd_error_bad_value
);
4588 osec
= sec
->output_section
;
4589 indx
= elf_section_data (osec
)->dynindx
;
4594 outrel
.r_info
= ELF32_R_INFO (indx
, R_MIPS_REL32
);
4595 addend
+= relocation
;
4598 bfd_put_32 (output_bfd
, addend
, contents
+ rel
->r_offset
);
4599 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
4600 (((Elf32_External_Rel
*)
4602 + sreloc
->reloc_count
));
4603 ++sreloc
->reloc_count
;
4605 if (SGI_COMPAT (output_bfd
))
4610 /* Make an entry of compact relocation info. */
4611 mips_elf_set_cr_format (cptrel
, CRF_MIPS_LONG
);
4612 cptrel
.vaddr
= (rel
->r_offset
4613 + input_section
->output_section
->vma
4614 + input_section
->output_offset
);
4615 if (r_type
== R_MIPS_REL32
)
4616 mips_elf_set_cr_type (cptrel
, CRT_MIPS_REL32
);
4618 mips_elf_set_cr_type (cptrel
, CRT_MIPS_WORD
);
4619 mips_elf_set_cr_dist2to (cptrel
, 0);
4620 cptrel
.konst
= addend
;
4622 cr
= (scpt
->contents
4623 + sizeof (Elf32_External_compact_rel
));
4624 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
4625 ((Elf32_External_crinfo
*) cr
4626 + scpt
->reloc_count
));
4627 ++scpt
->reloc_count
;
4630 /* This reloc will be computed at runtime, so
4631 there's no need to do anything now. */
4635 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4636 contents
, rel
->r_offset
,
4637 relocation
, addend
);
4640 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4641 contents
, rel
->r_offset
,
4642 relocation
, addend
);
4644 if (SGI_COMPAT (abfd
)
4646 && (input_section
->flags
& SEC_ALLOC
) != 0)
4648 Elf32_crinfo cptrel
;
4651 /* Make an entry of compact relocation info. */
4652 mips_elf_set_cr_format (cptrel
, CRF_MIPS_LONG
);
4653 cptrel
.vaddr
= (rel
->r_offset
4654 + input_section
->output_section
->vma
4655 + input_section
->output_offset
);
4660 mips_elf_set_cr_type (cptrel
, CRT_MIPS_JMPAD
);
4661 /* XXX How should we set dist2to in this case. */
4662 mips_elf_set_cr_dist2to (cptrel
, 8);
4663 cptrel
.konst
= addend
+ relocation
;
4664 cr
= scpt
->contents
+ sizeof (Elf32_External_compact_rel
);
4665 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
4666 ((Elf32_External_crinfo
*) cr
4667 + scpt
->reloc_count
));
4668 ++scpt
->reloc_count
;
4671 case R_MIPS_GPREL16
:
4672 case R_MIPS_LITERAL
:
4673 case R_MIPS_GPREL32
:
4674 mips_elf_set_cr_type (cptrel
, CRT_MIPS_GPHI_LO
);
4675 cptrel
.konst
= gp
- cptrel
.vaddr
;
4676 mips_elf_set_cr_dist2to (cptrel
, 4);
4677 cr
= scpt
->contents
+ sizeof (Elf32_External_compact_rel
);
4678 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
4679 ((Elf32_External_crinfo
*) cr
4680 + scpt
->reloc_count
));
4681 ++scpt
->reloc_count
;
4690 if (r
!= bfd_reloc_ok
)
4695 case bfd_reloc_outofrange
:
4697 case bfd_reloc_overflow
:
4702 name
= h
->root
.root
.string
;
4705 name
= bfd_elf_string_from_elf_section (input_bfd
,
4706 symtab_hdr
->sh_link
,
4711 name
= bfd_section_name (input_bfd
, sec
);
4713 if (! ((*info
->callbacks
->reloc_overflow
)
4714 (info
, name
, howto
->name
, (bfd_vma
) 0,
4715 input_bfd
, input_section
, rel
->r_offset
)))
4726 /* Functions for the dynamic linker. */
4728 /* The name of the dynamic interpreter. This is put in the .interp
4731 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
4733 /* Create dynamic sections when linking against a dynamic object. */
4736 mips_elf_create_dynamic_sections (abfd
, info
)
4738 struct bfd_link_info
*info
;
4740 struct elf_link_hash_entry
*h
;
4742 register asection
*s
;
4743 const char * const *namep
;
4745 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
4748 /* Mips ABI requests the .dynamic section to be read only. */
4749 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4752 if (! bfd_set_section_flags (abfd
, s
, flags
))
4756 /* We need to create .got section. */
4757 if (! mips_elf_create_got_section (abfd
, info
))
4760 /* Create .stub section. */
4761 if (bfd_get_section_by_name (abfd
, ".stub") == NULL
)
4763 s
= bfd_make_section (abfd
, ".stub");
4765 || ! bfd_set_section_flags (abfd
, s
, flags
)
4766 || ! bfd_set_section_alignment (abfd
, s
, 2))
4770 if (SGI_COMPAT (abfd
)
4772 && bfd_get_section_by_name (abfd
, ".rld_map") == NULL
)
4774 s
= bfd_make_section (abfd
, ".rld_map");
4776 || ! bfd_set_section_flags (abfd
, s
, flags
& ~SEC_READONLY
)
4777 || ! bfd_set_section_alignment (abfd
, s
, 2))
4781 if (SGI_COMPAT (abfd
))
4783 for (namep
= mips_elf_dynsym_rtproc_names
; *namep
!= NULL
; namep
++)
4786 if (! (_bfd_generic_link_add_one_symbol
4787 (info
, abfd
, *namep
, BSF_GLOBAL
, bfd_und_section_ptr
,
4788 (bfd_vma
) 0, (const char *) NULL
, false,
4789 get_elf_backend_data (abfd
)->collect
,
4790 (struct bfd_link_hash_entry
**) &h
)))
4792 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
4793 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4794 h
->type
= STT_SECTION
;
4796 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
4800 /* We need to create a .compact_rel section. */
4801 if (! mips_elf_create_compact_rel_section (abfd
, info
))
4804 /* Change aligments of some sections. */
4805 s
= bfd_get_section_by_name (abfd
, ".hash");
4807 bfd_set_section_alignment (abfd
, s
, 4);
4808 s
= bfd_get_section_by_name (abfd
, ".dynsym");
4810 bfd_set_section_alignment (abfd
, s
, 4);
4811 s
= bfd_get_section_by_name (abfd
, ".dynstr");
4813 bfd_set_section_alignment (abfd
, s
, 4);
4814 s
= bfd_get_section_by_name (abfd
, ".reginfo");
4816 bfd_set_section_alignment (abfd
, s
, 4);
4817 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4819 bfd_set_section_alignment (abfd
, s
, 4);
4825 if (! (_bfd_generic_link_add_one_symbol
4826 (info
, abfd
, "_DYNAMIC_LINK", BSF_GLOBAL
, bfd_abs_section_ptr
,
4827 (bfd_vma
) 0, (const char *) NULL
, false,
4828 get_elf_backend_data (abfd
)->collect
,
4829 (struct bfd_link_hash_entry
**) &h
)))
4831 h
->elf_link_hash_flags
^=~ ELF_LINK_NON_ELF
;
4832 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4833 h
->type
= STT_SECTION
;
4835 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
4838 if (! mips_elf_hash_table (info
)->use_rld_obj_head
)
4840 /* __rld_map is a four byte word located in the .data section
4841 and is filled in by the rtld to contain a pointer to
4842 the _r_debug structure. Its symbol value will be set in
4843 mips_elf_finish_dynamic_symbol. */
4844 s
= bfd_get_section_by_name (abfd
, ".rld_map");
4845 BFD_ASSERT (s
!= NULL
);
4848 if (! (_bfd_generic_link_add_one_symbol
4849 (info
, abfd
, "__rld_map", BSF_GLOBAL
, s
,
4850 (bfd_vma
) 0, (const char *) NULL
, false,
4851 get_elf_backend_data (abfd
)->collect
,
4852 (struct bfd_link_hash_entry
**) &h
)))
4854 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
4855 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4856 h
->type
= STT_OBJECT
;
4858 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
4866 /* Create the .compact_rel section. */
4869 mips_elf_create_compact_rel_section (abfd
, info
)
4871 struct bfd_link_info
*info
;
4874 register asection
*s
;
4876 if (bfd_get_section_by_name (abfd
, ".compact_rel") == NULL
)
4878 flags
= SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_READONLY
;
4880 s
= bfd_make_section (abfd
, ".compact_rel");
4882 || ! bfd_set_section_flags (abfd
, s
, flags
)
4883 || ! bfd_set_section_alignment (abfd
, s
, 2))
4886 s
->_raw_size
= sizeof (Elf32_External_compact_rel
);
4892 /* Create the .got section to hold the global offset table. */
4895 mips_elf_create_got_section (abfd
, info
)
4897 struct bfd_link_info
*info
;
4900 register asection
*s
;
4901 struct elf_link_hash_entry
*h
;
4902 struct mips_got_info
*g
;
4904 /* This function may be called more than once. */
4905 if (bfd_get_section_by_name (abfd
, ".got") != NULL
)
4908 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
4910 s
= bfd_make_section (abfd
, ".got");
4912 || ! bfd_set_section_flags (abfd
, s
, flags
)
4913 || ! bfd_set_section_alignment (abfd
, s
, 4))
4916 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
4917 linker script because we don't want to define the symbol if we
4918 are not creating a global offset table. */
4920 if (! (_bfd_generic_link_add_one_symbol
4921 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
4922 (bfd_vma
) 0, (const char *) NULL
, false,
4923 get_elf_backend_data (abfd
)->collect
,
4924 (struct bfd_link_hash_entry
**) &h
)))
4926 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
4927 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4928 h
->type
= STT_OBJECT
;
4931 && ! bfd_elf32_link_record_dynamic_symbol (info
, h
))
4934 /* The first several global offset table entries are reserved. */
4935 s
->_raw_size
= MIPS_RESERVED_GOTNO
* 4;
4937 g
= (struct mips_got_info
*) bfd_alloc (abfd
,
4938 sizeof (struct mips_got_info
));
4941 g
->global_gotsym
= 0;
4942 g
->local_gotno
= MIPS_RESERVED_GOTNO
;
4943 if (elf_section_data (s
) == NULL
)
4946 (PTR
) bfd_zalloc (abfd
, sizeof (struct bfd_elf_section_data
));
4947 if (elf_section_data (s
) == NULL
)
4950 elf_section_data (s
)->tdata
= (PTR
) g
;
4955 /* Look through the relocs for a section during the first phase, and
4956 allocate space in the global offset table. */
4959 mips_elf_check_relocs (abfd
, info
, sec
, relocs
)
4961 struct bfd_link_info
*info
;
4963 const Elf_Internal_Rela
*relocs
;
4966 Elf_Internal_Shdr
*symtab_hdr
;
4967 struct elf_link_hash_entry
**sym_hashes
;
4968 struct mips_got_info
*g
;
4970 const Elf_Internal_Rela
*rel
;
4971 const Elf_Internal_Rela
*rel_end
;
4975 if (info
->relocateable
)
4978 dynobj
= elf_hash_table (info
)->dynobj
;
4979 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4980 sym_hashes
= elf_sym_hashes (abfd
);
4981 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
4990 sgot
= bfd_get_section_by_name (dynobj
, ".got");
4991 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
4992 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
4993 BFD_ASSERT (g
!= NULL
);
4998 rel_end
= relocs
+ sec
->reloc_count
;
4999 for (rel
= relocs
; rel
< rel_end
; rel
++)
5001 unsigned long r_symndx
;
5002 struct elf_link_hash_entry
*h
;
5004 r_symndx
= ELF32_R_SYM (rel
->r_info
);
5006 if (r_symndx
< extsymoff
)
5009 h
= sym_hashes
[r_symndx
- extsymoff
];
5011 /* Some relocs require a global offset table. */
5012 if (dynobj
== NULL
|| sgot
== NULL
)
5014 switch (ELF32_R_TYPE (rel
->r_info
))
5018 case R_MIPS_CALL_HI16
:
5019 case R_MIPS_CALL_LO16
:
5020 case R_MIPS_GOT_HI16
:
5021 case R_MIPS_GOT_LO16
:
5023 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5024 if (! mips_elf_create_got_section (dynobj
, info
))
5026 sgot
= bfd_get_section_by_name (dynobj
, ".got");
5027 BFD_ASSERT (sgot
!= NULL
);
5028 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
5029 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
5030 BFD_ASSERT (g
!= NULL
);
5036 && (info
->shared
|| h
!= NULL
)
5037 && (sec
->flags
& SEC_ALLOC
) != 0)
5038 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5046 switch (ELF32_R_TYPE (rel
->r_info
))
5049 case R_MIPS_CALL_HI16
:
5050 case R_MIPS_CALL_LO16
:
5051 /* This symbol requires a global offset table entry. */
5053 BFD_ASSERT (h
!= NULL
);
5055 /* Make sure this symbol is output as a dynamic symbol. */
5056 if (h
->dynindx
== -1)
5058 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
5062 if (h
->got_offset
!= (bfd_vma
) -1)
5064 /* We have already allocated space in the .got. */
5068 /* Note the index of the first global got symbol in .dynsym. */
5069 if (g
->global_gotsym
== 0
5070 || g
->global_gotsym
> (unsigned long) h
->dynindx
)
5071 g
->global_gotsym
= h
->dynindx
;
5073 /* Make this symbol to have the corresponding got entry. */
5076 /* We need a stub, not a plt entry for the undefined
5077 function. But we record it as if it needs plt. See
5078 elf_adjust_dynamic_symbol in elflink.h. */
5079 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
5085 case R_MIPS_GOT_HI16
:
5086 case R_MIPS_GOT_LO16
:
5087 /* This symbol requires a global offset table entry. */
5091 /* Make sure this symbol is output as a dynamic symbol. */
5092 if (h
->dynindx
== -1)
5094 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
5098 if (h
->got_offset
!= (bfd_vma
) -1)
5100 /* We have already allocated space in the .got. */
5103 /* Note the index of the first global got symbol in
5105 if (g
->global_gotsym
== 0
5106 || g
->global_gotsym
> (unsigned long) h
->dynindx
)
5107 g
->global_gotsym
= h
->dynindx
;
5109 /* Make this symbol to be the global got symbol. */
5117 if ((info
->shared
|| h
!= NULL
)
5118 && (sec
->flags
& SEC_ALLOC
) != 0)
5122 const char *name
= ".rel.dyn";
5124 sreloc
= bfd_get_section_by_name (dynobj
, name
);
5127 sreloc
= bfd_make_section (dynobj
, name
);
5129 || ! bfd_set_section_flags (dynobj
, sreloc
,
5135 || ! bfd_set_section_alignment (dynobj
, sreloc
,
5142 /* When creating a shared object, we must copy these
5143 reloc types into the output file as R_MIPS_REL32
5144 relocs. We make room for this reloc in the
5145 .rel.dyn reloc section */
5146 if (sreloc
->_raw_size
== 0)
5148 /* Add a null element. */
5149 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
5150 ++sreloc
->reloc_count
;
5152 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
5156 struct mips_elf_link_hash_entry
*hmips
;
5158 /* We only need to copy this reloc if the symbol is
5159 defined in a dynamic object. */
5160 hmips
= (struct mips_elf_link_hash_entry
*) h
;
5161 ++hmips
->mips_32_relocs
;
5165 if (SGI_COMPAT (abfd
))
5166 mips_elf_hash_table (info
)->compact_rel_size
+=
5167 sizeof (Elf32_External_crinfo
);
5172 case R_MIPS_GPREL16
:
5173 case R_MIPS_LITERAL
:
5174 case R_MIPS_GPREL32
:
5175 if (SGI_COMPAT (abfd
))
5176 mips_elf_hash_table (info
)->compact_rel_size
+=
5177 sizeof (Elf32_External_crinfo
);
5188 /* Adjust a symbol defined by a dynamic object and referenced by a
5189 regular object. The current definition is in some section of the
5190 dynamic object, but we're not including those sections. We have to
5191 change the definition to something the rest of the link can
5195 mips_elf_adjust_dynamic_symbol (info
, h
)
5196 struct bfd_link_info
*info
;
5197 struct elf_link_hash_entry
*h
;
5200 struct mips_elf_link_hash_entry
*hmips
;
5203 dynobj
= elf_hash_table (info
)->dynobj
;
5205 /* Make sure we know what is going on here. */
5206 BFD_ASSERT (dynobj
!= NULL
5207 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
5208 || h
->weakdef
!= NULL
5209 || ((h
->elf_link_hash_flags
5210 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
5211 && (h
->elf_link_hash_flags
5212 & ELF_LINK_HASH_REF_REGULAR
) != 0
5213 && (h
->elf_link_hash_flags
5214 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
5216 /* If this symbol is defined in a dynamic object, we need to copy
5217 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
5219 hmips
= (struct mips_elf_link_hash_entry
*) h
;
5220 if (! info
->relocateable
5221 && hmips
->mips_32_relocs
!= 0
5222 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
5224 s
= bfd_get_section_by_name (dynobj
, ".rel.dyn");
5225 BFD_ASSERT (s
!= NULL
);
5227 if (s
->_raw_size
== 0)
5229 /* Make room for a null element. */
5230 s
->_raw_size
+= sizeof (Elf32_External_Rel
);
5233 s
->_raw_size
+= hmips
->mips_32_relocs
* sizeof (Elf32_External_Rel
);
5236 /* For a function, create a stub, if needed. */
5237 if (h
->type
== STT_FUNC
5238 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
5240 if (! elf_hash_table (info
)->dynamic_sections_created
)
5243 /* If this symbol is not defined in a regular file, then set
5244 the symbol to the stub location. This is required to make
5245 function pointers compare as equal between the normal
5246 executable and the shared library. */
5247 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
5249 /* We need .stub section. */
5250 s
= bfd_get_section_by_name (dynobj
, ".stub");
5251 BFD_ASSERT (s
!= NULL
);
5253 h
->root
.u
.def
.section
= s
;
5254 h
->root
.u
.def
.value
= s
->_raw_size
;
5256 /* XXX Write this stub address somewhere. */
5257 h
->plt_offset
= s
->_raw_size
;
5259 /* Make room for this stub code. */
5260 s
->_raw_size
+= MIPS_FUNCTION_STUB_SIZE
;
5262 /* The last half word of the stub will be filled with the index
5263 of this symbol in .dynsym section. */
5268 /* If this is a weak symbol, and there is a real definition, the
5269 processor independent code will have arranged for us to see the
5270 real definition first, and we can just use the same value. */
5271 if (h
->weakdef
!= NULL
)
5273 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
5274 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
5275 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
5276 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
5280 /* This is a reference to a symbol defined by a dynamic object which
5281 is not a function. */
5286 /* Set the sizes of the dynamic sections. */
5289 mips_elf_size_dynamic_sections (output_bfd
, info
)
5291 struct bfd_link_info
*info
;
5297 struct mips_got_info
*g
;
5299 dynobj
= elf_hash_table (info
)->dynobj
;
5300 BFD_ASSERT (dynobj
!= NULL
);
5302 if (elf_hash_table (info
)->dynamic_sections_created
)
5304 /* Set the contents of the .interp section to the interpreter. */
5307 s
= bfd_get_section_by_name (dynobj
, ".interp");
5308 BFD_ASSERT (s
!= NULL
);
5309 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
5310 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
5314 /* Recompute the size of .got for local entires (reserved and
5315 hipages) if needed. To estimate it, get the upper bound of total
5316 size of loadable sections. */
5317 sgot
= bfd_get_section_by_name (dynobj
, ".got");
5321 bfd_size_type loadable_size
= 0;
5322 bfd_size_type local_gotno
;
5325 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
5326 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
5327 BFD_ASSERT (g
!= NULL
);
5329 for (sub
= info
->input_bfds
; sub
; sub
= sub
->link_next
)
5330 for (s
= sub
->sections
; s
!= NULL
; s
= s
->next
)
5332 if ((s
->flags
& SEC_ALLOC
) == 0)
5334 loadable_size
+= (s
->_raw_size
+ 0xf) & ~0xf;
5337 loadable_size
+= MIPS_FUNCTION_STUB_SIZE
;
5339 /* Assume there are two loadable segments consisting of
5340 contiguous sections. Is 5 enough? */
5341 local_gotno
= (loadable_size
>> 16) + 5 + MIPS_RESERVED_GOTNO
;
5342 g
->local_gotno
= local_gotno
;
5343 sgot
->_raw_size
+= local_gotno
* 4;
5346 /* The check_relocs and adjust_dynamic_symbol entry points have
5347 determined the sizes of the various dynamic sections. Allocate
5350 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
5355 /* It's OK to base decisions on the section name, because none
5356 of the dynobj section names depend upon the input files. */
5357 name
= bfd_get_section_name (dynobj
, s
);
5359 if ((s
->flags
& SEC_IN_MEMORY
) == 0)
5364 if (strncmp (name
, ".rel", 4) == 0)
5366 if (s
->_raw_size
== 0)
5372 /* If this relocation section applies to a read only
5373 section, then we probably need a DT_TEXTREL entry.
5374 If the relocation section is .rel.dyn, we always
5375 assert a DT_TEXTREL entry rather than testing whether
5376 there exists a relocation to a read only section or
5378 target
= bfd_get_section_by_name (output_bfd
, name
+ 4);
5379 if ((target
!= NULL
&& (target
->flags
& SEC_READONLY
) != 0)
5380 || strcmp (name
, ".rel.dyn") == 0)
5383 /* We use the reloc_count field as a counter if we need
5384 to copy relocs into the output file. */
5385 if (strcmp (name
, ".rel.dyn") != 0)
5389 else if (strncmp (name
, ".got", 4) == 0)
5393 BFD_ASSERT (elf_section_data (s
) != NULL
);
5394 g
= (struct mips_got_info
*) elf_section_data (s
)->tdata
;
5395 BFD_ASSERT (g
!= NULL
);
5397 /* Fix the size of .got section for the correspondence of
5398 global symbols and got entries. This adds some useless
5399 got entries. Is this required by ABI really? */
5400 i
= elf_hash_table (info
)->dynsymcount
- g
->global_gotsym
;
5401 s
->_raw_size
+= i
* 4;
5403 else if (strncmp (name
, ".stub", 5) == 0)
5405 /* Irix rld assumes that the function stub isn't at the end
5406 of .text section. So put a dummy. XXX */
5407 s
->_raw_size
+= MIPS_FUNCTION_STUB_SIZE
;
5409 else if (! info
->shared
5410 && ! mips_elf_hash_table (info
)->use_rld_obj_head
5411 && strncmp (name
, ".rld_map", 8) == 0)
5413 /* We add a room for __rld_map. It will be filled in by the
5414 rtld to contain a pointer to the _r_debug structure. */
5417 else if (SGI_COMPAT (output_bfd
)
5418 && strncmp (name
, ".compact_rel", 12) == 0)
5419 s
->_raw_size
+= mips_elf_hash_table (info
)->compact_rel_size
;
5420 else if (strncmp (name
, ".init", 5) != 0)
5422 /* It's not one of our sections, so don't allocate space. */
5430 for (spp
= &s
->output_section
->owner
->sections
;
5431 *spp
!= s
->output_section
;
5432 spp
= &(*spp
)->next
)
5434 *spp
= s
->output_section
->next
;
5435 --s
->output_section
->owner
->section_count
;
5440 /* Allocate memory for the section contents. */
5441 s
->contents
= (bfd_byte
*) bfd_alloc (dynobj
, s
->_raw_size
);
5442 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
5444 bfd_set_error (bfd_error_no_memory
);
5447 memset (s
->contents
, 0, s
->_raw_size
);
5450 if (elf_hash_table (info
)->dynamic_sections_created
)
5452 /* Add some entries to the .dynamic section. We fill in the
5453 values later, in elf_mips_finish_dynamic_sections, but we
5454 must add the entries now so that we get the correct size for
5455 the .dynamic section. The DT_DEBUG entry is filled in by the
5456 dynamic linker and used by the debugger. */
5459 if (SGI_COMPAT (output_bfd
))
5461 /* SGI object has the equivalence of DT_DEBUG in the
5462 DT_MIPS_RLD_MAP entry. */
5463 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_RLD_MAP
, 0))
5467 if (! bfd_elf32_add_dynamic_entry (info
, DT_DEBUG
, 0))
5473 if (! bfd_elf32_add_dynamic_entry (info
, DT_TEXTREL
, 0))
5477 if (! bfd_elf32_add_dynamic_entry (info
, DT_PLTGOT
, 0))
5480 if (bfd_get_section_by_name (dynobj
, ".rel.dyn"))
5482 if (! bfd_elf32_add_dynamic_entry (info
, DT_REL
, 0))
5485 if (! bfd_elf32_add_dynamic_entry (info
, DT_RELSZ
, 0))
5488 if (! bfd_elf32_add_dynamic_entry (info
, DT_RELENT
, 0))
5492 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_CONFLICTNO
, 0))
5495 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_LIBLISTNO
, 0))
5498 if (bfd_get_section_by_name (dynobj
, ".conflict") != NULL
)
5500 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_CONFLICT
, 0))
5503 s
= bfd_get_section_by_name (dynobj
, ".liblist");
5504 BFD_ASSERT (s
!= NULL
);
5506 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_LIBLIST
, 0))
5510 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_RLD_VERSION
, 0))
5513 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_FLAGS
, 0))
5517 /* Time stamps in executable files are a bad idea. */
5518 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_TIME_STAMP
, 0))
5523 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_ICHECKSUM
, 0))
5528 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_IVERSION
, 0))
5532 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_BASE_ADDRESS
, 0))
5535 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_LOCAL_GOTNO
, 0))
5538 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_SYMTABNO
, 0))
5541 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_UNREFEXTNO
, 0))
5544 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_GOTSYM
, 0))
5547 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_HIPAGENO
, 0))
5550 #if 0 /* (SGI_COMPAT) */
5551 if (! bfd_get_section_by_name (dynobj
, ".init"))
5552 if (! bfd_elf32_add_dynamic_entry (info
, DT_INIT
, 0))
5555 if (! bfd_get_section_by_name (dynobj
, ".fini"))
5556 if (! bfd_elf32_add_dynamic_entry (info
, DT_FINI
, 0))
5561 /* If we use dynamic linking, we generate a section symbol for each
5562 output section. These are local symbols, which means that they
5563 must come first in the dynamic symbol table.
5564 That means we must increment the dynamic symbol index of every
5565 other dynamic symbol. */
5567 const char * const *namep
;
5569 bfd_size_type strindex
;
5570 struct bfd_strtab_hash
*dynstr
;
5571 struct mips_got_info
*g
;
5574 if (elf_hash_table (info
)->dynamic_sections_created
)
5576 if (SGI_COMPAT (output_bfd
))
5578 c
= SIZEOF_MIPS_DYNSYM_SECNAMES
- 1;
5579 elf_link_hash_traverse (elf_hash_table (info
),
5580 mips_elf_adjust_dynindx
,
5582 elf_hash_table (info
)->dynsymcount
+= c
;
5584 dynstr
= elf_hash_table (info
)->dynstr
;
5585 BFD_ASSERT (dynstr
!= NULL
);
5587 for (i
= 1, namep
= mips_elf_dynsym_sec_names
;
5591 s
= bfd_get_section_by_name (output_bfd
, *namep
);
5593 elf_section_data (s
)->dynindx
= i
;
5595 strindex
= _bfd_stringtab_add (dynstr
, *namep
, true, false);
5596 if (strindex
== (bfd_size_type
) -1)
5599 mips_elf_hash_table (info
)->dynsym_sec_strindex
[i
] = strindex
;
5604 c
= bfd_count_sections (output_bfd
);
5605 elf_link_hash_traverse (elf_hash_table (info
),
5606 mips_elf_adjust_dynindx
,
5608 elf_hash_table (info
)->dynsymcount
+= c
;
5610 for (i
= 1, s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
, i
++)
5612 elf_section_data (s
)->dynindx
= i
;
5613 /* These symbols will have no names, so we don't need to
5614 fiddle with dynstr_index. */
5621 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
5622 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
5623 BFD_ASSERT (g
!= NULL
);
5625 /* If there are no global got symbols, fake the last symbol so
5627 if (g
->global_gotsym
)
5628 g
->global_gotsym
+= c
;
5630 g
->global_gotsym
= elf_hash_table (info
)->dynsymcount
- 1;
5637 /* Increment the index of a dynamic symbol by a given amount. Called
5638 via elf_link_hash_traverse. */
5641 mips_elf_adjust_dynindx (h
, cparg
)
5642 struct elf_link_hash_entry
*h
;
5645 unsigned int *cp
= (unsigned int *) cparg
;
5647 if (h
->dynindx
!= -1)
5652 /* Finish up dynamic symbol handling. We set the contents of various
5653 dynamic sections here. */
5656 mips_elf_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
5658 struct bfd_link_info
*info
;
5659 struct elf_link_hash_entry
*h
;
5660 Elf_Internal_Sym
*sym
;
5665 struct mips_got_info
*g
;
5668 dynobj
= elf_hash_table (info
)->dynobj
;
5669 gval
= sym
->st_value
;
5671 if (h
->plt_offset
!= (bfd_vma
) -1)
5675 bfd_byte stub
[MIPS_FUNCTION_STUB_SIZE
];
5677 /* This symbol has a stub. Set it up. */
5679 BFD_ASSERT (h
->dynindx
!= -1);
5681 s
= bfd_get_section_by_name (dynobj
, ".stub");
5682 BFD_ASSERT (s
!= NULL
);
5684 /* Fill the stub. */
5686 bfd_put_32 (output_bfd
, STUB_LW(output_bfd
), p
);
5688 bfd_put_32 (output_bfd
, STUB_MOVE
, p
);
5691 /* FIXME: Can h->dynindex be more than 64K? */
5692 if (h
->dynindx
& 0xffff0000)
5695 bfd_put_32 (output_bfd
, STUB_JALR
, p
);
5697 bfd_put_32 (output_bfd
, STUB_LI16
+ h
->dynindx
, p
);
5699 BFD_ASSERT (h
->plt_offset
<= s
->_raw_size
);
5700 memcpy (s
->contents
+ h
->plt_offset
, stub
, MIPS_FUNCTION_STUB_SIZE
);
5702 /* Mark the symbol as undefined. plt_offset != -1 occurs
5703 only for the referenced symbol. */
5704 sym
->st_shndx
= SHN_UNDEF
;
5706 /* The run-time linker uses the st_value field of the symbol
5707 to reset the global offset table entry for this external
5708 to its stub address when unlinking a shared object. */
5709 gval
= s
->output_section
->vma
+ s
->output_offset
+ h
->plt_offset
;
5710 sym
->st_value
= gval
;
5713 BFD_ASSERT (h
->dynindx
!= -1);
5715 sgot
= bfd_get_section_by_name (dynobj
, ".got");
5716 BFD_ASSERT (sgot
!= NULL
);
5717 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
5718 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
5719 BFD_ASSERT (g
!= NULL
);
5721 if ((unsigned long) h
->dynindx
>= g
->global_gotsym
)
5723 bfd_size_type offset
;
5725 /* This symbol has an entry in the global offset table. Set its
5726 value to the corresponding got entry, if needed. */
5727 if (h
->got_offset
== (bfd_vma
) -1)
5729 offset
= (h
->dynindx
- g
->global_gotsym
+ g
->local_gotno
) * 4;
5730 BFD_ASSERT (g
->local_gotno
* 4 <= offset
5731 && offset
< sgot
->_raw_size
);
5732 bfd_put_32 (output_bfd
, gval
, sgot
->contents
+ offset
);
5736 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
5737 name
= h
->root
.root
.string
;
5738 if (strcmp (name
, "_DYNAMIC") == 0
5739 || strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
5740 sym
->st_shndx
= SHN_ABS
;
5741 else if (strcmp (name
, "_DYNAMIC_LINK") == 0)
5743 sym
->st_shndx
= SHN_ABS
;
5744 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
5747 else if (SGI_COMPAT (output_bfd
))
5749 if (strcmp (name
, "_gp_disp") == 0)
5751 sym
->st_shndx
= SHN_ABS
;
5752 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
5753 sym
->st_value
= elf_gp (output_bfd
);
5755 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
5756 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
5758 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
5759 sym
->st_other
= STO_PROTECTED
;
5761 sym
->st_shndx
= SHN_MIPS_DATA
;
5763 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
5765 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
5766 sym
->st_other
= STO_PROTECTED
;
5767 sym
->st_value
= mips_elf_hash_table (info
)->procedure_count
;
5768 sym
->st_shndx
= SHN_ABS
;
5770 else if (sym
->st_shndx
!= SHN_UNDEF
)
5772 if (h
->type
== STT_FUNC
)
5773 sym
->st_shndx
= SHN_MIPS_TEXT
;
5774 else if (h
->type
== STT_OBJECT
)
5775 sym
->st_shndx
= SHN_MIPS_DATA
;
5779 if (SGI_COMPAT (output_bfd
)
5782 if (! mips_elf_hash_table (info
)->use_rld_obj_head
5783 && strcmp (name
, "__rld_map") == 0)
5785 asection
*s
= bfd_get_section_by_name (dynobj
, ".rld_map");
5786 BFD_ASSERT (s
!= NULL
);
5787 sym
->st_value
= s
->output_section
->vma
+ s
->output_offset
;
5788 bfd_put_32 (output_bfd
, (bfd_vma
) 0, s
->contents
);
5789 if (mips_elf_hash_table (info
)->rld_value
== 0)
5790 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
5792 else if (mips_elf_hash_table (info
)->use_rld_obj_head
5793 && strcmp (name
, "__rld_obj_head") == 0)
5795 asection
*s
= bfd_get_section_by_name (dynobj
, ".rld_map");
5796 BFD_ASSERT (s
!= NULL
);
5797 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
5804 /* Finish up the dynamic sections. */
5807 mips_elf_finish_dynamic_sections (output_bfd
, info
)
5809 struct bfd_link_info
*info
;
5814 struct mips_got_info
*g
;
5816 dynobj
= elf_hash_table (info
)->dynobj
;
5818 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
5820 sgot
= bfd_get_section_by_name (dynobj
, ".got");
5825 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
5826 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
5827 BFD_ASSERT (g
!= NULL
);
5830 if (elf_hash_table (info
)->dynamic_sections_created
)
5832 Elf32_External_Dyn
*dyncon
, *dynconend
;
5834 BFD_ASSERT (sdyn
!= NULL
);
5835 BFD_ASSERT (g
!= NULL
);
5837 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
5838 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
5839 for (; dyncon
< dynconend
; dyncon
++)
5841 Elf_Internal_Dyn dyn
;
5846 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5854 s
= bfd_get_section_by_name (dynobj
, ".rel.dyn");
5855 BFD_ASSERT (s
!= NULL
);
5856 dyn
.d_un
.d_val
= sizeof (Elf32_External_Rel
);
5857 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5861 /* Rewrite DT_STRSZ. */
5863 _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
5864 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5870 case DT_MIPS_CONFLICT
:
5873 case DT_MIPS_LIBLIST
:
5876 s
= bfd_get_section_by_name (output_bfd
, name
);
5877 BFD_ASSERT (s
!= NULL
);
5878 dyn
.d_un
.d_ptr
= s
->vma
;
5879 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5882 case DT_MIPS_RLD_VERSION
:
5883 dyn
.d_un
.d_val
= 1; /* XXX */
5884 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5888 dyn
.d_un
.d_val
= RHF_NOTPOT
; /* XXX */
5889 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5892 case DT_MIPS_CONFLICTNO
:
5894 elemsize
= sizeof (Elf32_Conflict
);
5897 case DT_MIPS_LIBLISTNO
:
5899 elemsize
= sizeof (Elf32_Lib
);
5901 s
= bfd_get_section_by_name (output_bfd
, name
);
5904 if (s
->_cooked_size
!= 0)
5905 dyn
.d_un
.d_val
= s
->_cooked_size
/ elemsize
;
5907 dyn
.d_un
.d_val
= s
->_raw_size
/ elemsize
;
5912 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5915 case DT_MIPS_TIME_STAMP
:
5916 time ((time_t *) &dyn
.d_un
.d_val
);
5917 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5920 case DT_MIPS_ICHECKSUM
:
5924 case DT_MIPS_IVERSION
:
5928 case DT_MIPS_BASE_ADDRESS
:
5929 s
= output_bfd
->sections
;
5930 BFD_ASSERT (s
!= NULL
);
5931 dyn
.d_un
.d_ptr
= s
->vma
& ~(0xffff);
5932 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5935 case DT_MIPS_LOCAL_GOTNO
:
5936 dyn
.d_un
.d_val
= g
->local_gotno
;
5937 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5940 case DT_MIPS_SYMTABNO
:
5942 elemsize
= sizeof (Elf32_External_Sym
);
5943 s
= bfd_get_section_by_name (output_bfd
, name
);
5944 BFD_ASSERT (s
!= NULL
);
5946 if (s
->_cooked_size
!= 0)
5947 dyn
.d_un
.d_val
= s
->_cooked_size
/ elemsize
;
5949 dyn
.d_un
.d_val
= s
->_raw_size
/ elemsize
;
5950 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5953 case DT_MIPS_UNREFEXTNO
:
5955 dyn
.d_un
.d_val
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
5956 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5959 case DT_MIPS_GOTSYM
:
5960 dyn
.d_un
.d_val
= g
->global_gotsym
;
5961 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5964 case DT_MIPS_HIPAGENO
:
5965 dyn
.d_un
.d_val
= g
->local_gotno
- MIPS_RESERVED_GOTNO
;
5966 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5969 case DT_MIPS_RLD_MAP
:
5970 dyn
.d_un
.d_ptr
= mips_elf_hash_table (info
)->rld_value
;
5971 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5978 /* The first entry of the global offset table will be filled at
5979 runtime. The second entry will be used by some runtime loaders.
5980 This isn't the case of Irix rld. */
5981 if (sgot
!= NULL
&& sgot
->_raw_size
> 0)
5983 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
5984 bfd_put_32 (output_bfd
, (bfd_vma
) 0x80000000, sgot
->contents
+ 4);
5988 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
5995 Elf_Internal_Sym sym
;
5998 const char * const * namep
= mips_elf_dynsym_sec_names
;
5999 Elf32_compact_rel cpt
;
6001 /* Set up the section symbols for the output sections. SGI sets
6002 the STT_NOTYPE attribute for these symbols. Should we do so? */
6004 sdynsym
= bfd_get_section_by_name (dynobj
, ".dynsym");
6005 if (sdynsym
!= NULL
)
6007 if (SGI_COMPAT (output_bfd
))
6011 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_NOTYPE
);
6015 while ((name
= *namep
++) != NULL
)
6017 s
= bfd_get_section_by_name (output_bfd
, name
);
6020 sym
.st_value
= s
->vma
;
6021 dindx
= elf_section_data (s
)->dynindx
;
6022 last
= s
->vma
+ s
->_raw_size
;
6026 sym
.st_value
= last
;
6030 sym
.st_shndx
= (i
< MIPS_TEXT_DYNSYM_SECNO
6035 mips_elf_hash_table (info
)->dynsym_sec_strindex
[dindx
];
6037 bfd_elf32_swap_symbol_out (output_bfd
, &sym
,
6038 (((Elf32_External_Sym
*)
6043 /* Set the sh_info field of the output .dynsym section to
6044 the index of the first global symbol. */
6045 elf_section_data (sdynsym
->output_section
)->this_hdr
.sh_info
=
6046 SIZEOF_MIPS_DYNSYM_SECNAMES
;
6052 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
6055 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6059 sym
.st_value
= s
->vma
;
6061 indx
= elf_section_data (s
)->this_idx
;
6062 BFD_ASSERT (indx
> 0);
6063 sym
.st_shndx
= indx
;
6065 bfd_elf32_swap_symbol_out (output_bfd
, &sym
,
6066 (((Elf32_External_Sym
*)
6068 + elf_section_data (s
)->dynindx
));
6071 /* Set the sh_info field of the output .dynsym section to
6072 the index of the first global symbol. */
6073 elf_section_data (sdynsym
->output_section
)->this_hdr
.sh_info
=
6074 bfd_count_sections (output_bfd
) + 1;
6078 if (SGI_COMPAT (output_bfd
))
6080 /* Write .compact_rel section out. */
6081 s
= bfd_get_section_by_name (dynobj
, ".compact_rel");
6085 cpt
.num
= s
->reloc_count
;
6087 cpt
.offset
= (s
->output_section
->filepos
6088 + sizeof (Elf32_External_compact_rel
));
6091 bfd_elf32_swap_compact_rel_out (output_bfd
, &cpt
,
6092 ((Elf32_External_compact_rel
*)
6095 /* Clean up a dummy stub function entry in .text. */
6096 s
= bfd_get_section_by_name (dynobj
, ".stub");
6099 file_ptr dummy_offset
;
6101 BFD_ASSERT (s
->_raw_size
>= MIPS_FUNCTION_STUB_SIZE
);
6102 dummy_offset
= s
->_raw_size
- MIPS_FUNCTION_STUB_SIZE
;
6103 memset (s
->contents
+ dummy_offset
, 0,
6104 MIPS_FUNCTION_STUB_SIZE
);
6109 /* Clean up a first relocation in .rel.dyn. */
6110 s
= bfd_get_section_by_name (dynobj
, ".rel.dyn");
6111 if (s
!= NULL
&& s
->_raw_size
> 0)
6112 memset (s
->contents
, 0, sizeof (Elf32_External_Rel
));
6118 /* This is almost identical to bfd_generic_get_... except that some
6119 MIPS relocations need to be handled specially. Sigh. */
6122 elf32_mips_get_relocated_section_contents (abfd
, link_info
, link_order
, data
,
6123 relocateable
, symbols
)
6125 struct bfd_link_info
*link_info
;
6126 struct bfd_link_order
*link_order
;
6128 boolean relocateable
;
6131 /* Get enough memory to hold the stuff */
6132 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
6133 asection
*input_section
= link_order
->u
.indirect
.section
;
6135 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
6136 arelent
**reloc_vector
= NULL
;
6142 reloc_vector
= (arelent
**) bfd_malloc (reloc_size
);
6143 if (reloc_vector
== NULL
&& reloc_size
!= 0)
6146 /* read in the section */
6147 if (!bfd_get_section_contents (input_bfd
,
6151 input_section
->_raw_size
))
6154 /* We're not relaxing the section, so just copy the size info */
6155 input_section
->_cooked_size
= input_section
->_raw_size
;
6156 input_section
->reloc_done
= true;
6158 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
6162 if (reloc_count
< 0)
6165 if (reloc_count
> 0)
6170 bfd_vma gp
= 0x12345678; /* initialize just to shut gcc up */
6173 struct bfd_hash_entry
*h
;
6174 struct bfd_link_hash_entry
*lh
;
6175 /* Skip all this stuff if we aren't mixing formats. */
6176 if (abfd
&& input_bfd
6177 && abfd
->xvec
== input_bfd
->xvec
)
6181 h
= bfd_hash_lookup (&link_info
->hash
->table
, "_gp", false, false);
6182 lh
= (struct bfd_link_hash_entry
*) h
;
6189 case bfd_link_hash_undefined
:
6190 case bfd_link_hash_undefweak
:
6191 case bfd_link_hash_common
:
6194 case bfd_link_hash_defined
:
6195 case bfd_link_hash_defweak
:
6197 gp
= lh
->u
.def
.value
;
6199 case bfd_link_hash_indirect
:
6200 case bfd_link_hash_warning
:
6202 /* @@FIXME ignoring warning for now */
6204 case bfd_link_hash_new
:
6213 for (parent
= reloc_vector
; *parent
!= (arelent
*) NULL
;
6216 char *error_message
= (char *) NULL
;
6217 bfd_reloc_status_type r
;
6219 /* Specific to MIPS: Deal with relocation types that require
6220 knowing the gp of the output bfd. */
6221 asymbol
*sym
= *(*parent
)->sym_ptr_ptr
;
6222 if (bfd_is_abs_section (sym
->section
) && abfd
)
6224 /* The special_function wouldn't get called anyways. */
6228 /* The gp isn't there; let the special function code
6229 fall over on its own. */
6231 else if ((*parent
)->howto
->special_function
6232 == _bfd_mips_elf_gprel16_reloc
)
6234 /* bypass special_function call */
6235 r
= gprel16_with_gp (input_bfd
, sym
, *parent
, input_section
,
6236 relocateable
, (PTR
) data
, gp
);
6237 goto skip_bfd_perform_relocation
;
6239 /* end mips specific stuff */
6241 r
= bfd_perform_relocation (input_bfd
,
6245 relocateable
? abfd
: (bfd
*) NULL
,
6247 skip_bfd_perform_relocation
:
6251 asection
*os
= input_section
->output_section
;
6253 /* A partial link, so keep the relocs */
6254 os
->orelocation
[os
->reloc_count
] = *parent
;
6258 if (r
!= bfd_reloc_ok
)
6262 case bfd_reloc_undefined
:
6263 if (!((*link_info
->callbacks
->undefined_symbol
)
6264 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
6265 input_bfd
, input_section
, (*parent
)->address
)))
6268 case bfd_reloc_dangerous
:
6269 BFD_ASSERT (error_message
!= (char *) NULL
);
6270 if (!((*link_info
->callbacks
->reloc_dangerous
)
6271 (link_info
, error_message
, input_bfd
, input_section
,
6272 (*parent
)->address
)))
6275 case bfd_reloc_overflow
:
6276 if (!((*link_info
->callbacks
->reloc_overflow
)
6277 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
6278 (*parent
)->howto
->name
, (*parent
)->addend
,
6279 input_bfd
, input_section
, (*parent
)->address
)))
6282 case bfd_reloc_outofrange
:
6291 if (reloc_vector
!= NULL
)
6292 free (reloc_vector
);
6296 if (reloc_vector
!= NULL
)
6297 free (reloc_vector
);
6300 #define bfd_elf32_bfd_get_relocated_section_contents \
6301 elf32_mips_get_relocated_section_contents
6303 /* ECOFF swapping routines. These are used when dealing with the
6304 .mdebug section, which is in the ECOFF debugging format. */
6305 static const struct ecoff_debug_swap mips_elf32_ecoff_debug_swap
=
6307 /* Symbol table magic number. */
6309 /* Alignment of debugging information. E.g., 4. */
6311 /* Sizes of external symbolic information. */
6312 sizeof (struct hdr_ext
),
6313 sizeof (struct dnr_ext
),
6314 sizeof (struct pdr_ext
),
6315 sizeof (struct sym_ext
),
6316 sizeof (struct opt_ext
),
6317 sizeof (struct fdr_ext
),
6318 sizeof (struct rfd_ext
),
6319 sizeof (struct ext_ext
),
6320 /* Functions to swap in external symbolic data. */
6329 _bfd_ecoff_swap_tir_in
,
6330 _bfd_ecoff_swap_rndx_in
,
6331 /* Functions to swap out external symbolic data. */
6340 _bfd_ecoff_swap_tir_out
,
6341 _bfd_ecoff_swap_rndx_out
,
6342 /* Function to read in symbolic data. */
6343 _bfd_mips_elf_read_ecoff_info
6346 #define TARGET_LITTLE_SYM bfd_elf32_littlemips_vec
6347 #define TARGET_LITTLE_NAME "elf32-littlemips"
6348 #define TARGET_BIG_SYM bfd_elf32_bigmips_vec
6349 #define TARGET_BIG_NAME "elf32-bigmips"
6350 #define ELF_ARCH bfd_arch_mips
6351 #define ELF_MACHINE_CODE EM_MIPS
6353 /* The SVR4 MIPS ABI says that this should be 0x10000, but Irix 5 uses
6354 a value of 0x1000, and we are compatible. */
6355 #define ELF_MAXPAGESIZE 0x1000
6357 #define elf_backend_collect true
6358 #define elf_backend_type_change_ok true
6359 #define elf_info_to_howto 0
6360 #define elf_info_to_howto_rel mips_info_to_howto_rel
6361 #define elf_backend_sym_is_global mips_elf_sym_is_global
6362 #define elf_backend_object_p mips_elf32_object_p
6363 #define elf_backend_section_from_shdr mips_elf32_section_from_shdr
6364 #define elf_backend_fake_sections _bfd_mips_elf_fake_sections
6365 #define elf_backend_section_from_bfd_section \
6366 _bfd_mips_elf_section_from_bfd_section
6367 #define elf_backend_section_processing mips_elf32_section_processing
6368 #define elf_backend_symbol_processing _bfd_mips_elf_symbol_processing
6369 #define elf_backend_additional_program_headers \
6370 mips_elf_additional_program_headers
6371 #define elf_backend_modify_segment_map mips_elf_modify_segment_map
6372 #define elf_backend_final_write_processing \
6373 _bfd_mips_elf_final_write_processing
6374 #define elf_backend_ecoff_debug_swap &mips_elf32_ecoff_debug_swap
6376 #define bfd_elf32_bfd_is_local_label mips_elf_is_local_label
6377 #define bfd_elf32_find_nearest_line _bfd_mips_elf_find_nearest_line
6378 #define bfd_elf32_set_section_contents _bfd_mips_elf_set_section_contents
6379 #define bfd_elf32_bfd_link_hash_table_create \
6380 mips_elf_link_hash_table_create
6381 #define bfd_elf32_bfd_final_link mips_elf_final_link
6382 #define bfd_elf32_bfd_copy_private_bfd_data \
6383 _bfd_mips_elf_copy_private_bfd_data
6384 #define bfd_elf32_bfd_merge_private_bfd_data \
6385 _bfd_mips_elf_merge_private_bfd_data
6386 #define bfd_elf32_bfd_set_private_flags _bfd_mips_elf_set_private_flags
6387 #define elf_backend_add_symbol_hook mips_elf_add_symbol_hook
6388 #define elf_backend_create_dynamic_sections \
6389 mips_elf_create_dynamic_sections
6390 #define elf_backend_check_relocs mips_elf_check_relocs
6391 #define elf_backend_adjust_dynamic_symbol \
6392 mips_elf_adjust_dynamic_symbol
6393 #define elf_backend_size_dynamic_sections \
6394 mips_elf_size_dynamic_sections
6395 #define elf_backend_relocate_section mips_elf_relocate_section
6396 #define elf_backend_finish_dynamic_symbol \
6397 mips_elf_finish_dynamic_symbol
6398 #define elf_backend_finish_dynamic_sections \
6399 mips_elf_finish_dynamic_sections
6401 #include "elf32-target.h"