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_32_PCREL
, R_MIPS_REL32
},
1242 { BFD_RELOC_MIPS_JMP
, R_MIPS_26
},
1243 { BFD_RELOC_HI16_S
, R_MIPS_HI16
},
1244 { BFD_RELOC_LO16
, R_MIPS_LO16
},
1245 { BFD_RELOC_MIPS_GPREL
, R_MIPS_GPREL16
},
1246 { BFD_RELOC_MIPS_LITERAL
, R_MIPS_LITERAL
},
1247 { BFD_RELOC_MIPS_GOT16
, R_MIPS_GOT16
},
1248 { BFD_RELOC_16_PCREL
, R_MIPS_PC16
},
1249 { BFD_RELOC_MIPS_CALL16
, R_MIPS_CALL16
},
1250 { BFD_RELOC_MIPS_GPREL32
, R_MIPS_GPREL32
},
1251 { BFD_RELOC_MIPS_GOT_HI16
, R_MIPS_GOT_HI16
},
1252 { BFD_RELOC_MIPS_GOT_LO16
, R_MIPS_GOT_LO16
},
1253 { BFD_RELOC_MIPS_CALL_HI16
, R_MIPS_CALL_HI16
},
1254 { BFD_RELOC_MIPS_CALL_LO16
, R_MIPS_CALL_LO16
}
1257 /* Given a BFD reloc type, return a howto structure. */
1259 static reloc_howto_type
*
1260 bfd_elf32_bfd_reloc_type_lookup (abfd
, code
)
1262 bfd_reloc_code_real_type code
;
1266 for (i
= 0; i
< sizeof (mips_reloc_map
) / sizeof (struct elf_reloc_map
); i
++)
1268 if (mips_reloc_map
[i
].bfd_reloc_val
== code
)
1269 return &elf_mips_howto_table
[(int) mips_reloc_map
[i
].elf_reloc_val
];
1274 /* Given a MIPS reloc type, fill in an arelent structure. */
1277 mips_info_to_howto_rel (abfd
, cache_ptr
, dst
)
1280 Elf32_Internal_Rel
*dst
;
1282 unsigned int r_type
;
1284 r_type
= ELF32_R_TYPE (dst
->r_info
);
1285 BFD_ASSERT (r_type
< (unsigned int) R_MIPS_max
);
1286 cache_ptr
->howto
= &elf_mips_howto_table
[r_type
];
1288 /* The addend for a GPREL16 or LITERAL relocation comes from the GP
1289 value for the object file. We get the addend now, rather than
1290 when we do the relocation, because the symbol manipulations done
1291 by the linker may cause us to lose track of the input BFD. */
1292 if (((*cache_ptr
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) != 0
1293 && (r_type
== (unsigned int) R_MIPS_GPREL16
1294 || r_type
== (unsigned int) R_MIPS_LITERAL
))
1295 cache_ptr
->addend
= elf_gp (abfd
);
1298 /* A .reginfo section holds a single Elf32_RegInfo structure. These
1299 routines swap this structure in and out. They are used outside of
1300 BFD, so they are globally visible. */
1303 bfd_mips_elf32_swap_reginfo_in (abfd
, ex
, in
)
1305 const Elf32_External_RegInfo
*ex
;
1308 in
->ri_gprmask
= bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_gprmask
);
1309 in
->ri_cprmask
[0] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[0]);
1310 in
->ri_cprmask
[1] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[1]);
1311 in
->ri_cprmask
[2] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[2]);
1312 in
->ri_cprmask
[3] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[3]);
1313 in
->ri_gp_value
= bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_gp_value
);
1317 bfd_mips_elf32_swap_reginfo_out (abfd
, in
, ex
)
1319 const Elf32_RegInfo
*in
;
1320 Elf32_External_RegInfo
*ex
;
1322 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_gprmask
,
1323 (bfd_byte
*) ex
->ri_gprmask
);
1324 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[0],
1325 (bfd_byte
*) ex
->ri_cprmask
[0]);
1326 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[1],
1327 (bfd_byte
*) ex
->ri_cprmask
[1]);
1328 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[2],
1329 (bfd_byte
*) ex
->ri_cprmask
[2]);
1330 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[3],
1331 (bfd_byte
*) ex
->ri_cprmask
[3]);
1332 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_gp_value
,
1333 (bfd_byte
*) ex
->ri_gp_value
);
1336 /* In the 64 bit ABI, the .MIPS.options section holds register
1337 information in an Elf64_Reginfo structure. These routines swap
1338 them in and out. They are globally visible because they are used
1339 outside of BFD. These routines are here so that gas can call them
1340 without worrying about whether the 64 bit ABI has been included. */
1343 bfd_mips_elf64_swap_reginfo_in (abfd
, ex
, in
)
1345 const Elf64_External_RegInfo
*ex
;
1346 Elf64_Internal_RegInfo
*in
;
1348 in
->ri_gprmask
= bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_gprmask
);
1349 in
->ri_pad
= bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_pad
);
1350 in
->ri_cprmask
[0] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[0]);
1351 in
->ri_cprmask
[1] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[1]);
1352 in
->ri_cprmask
[2] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[2]);
1353 in
->ri_cprmask
[3] = bfd_h_get_32 (abfd
, (bfd_byte
*) ex
->ri_cprmask
[3]);
1354 in
->ri_gp_value
= bfd_h_get_64 (abfd
, (bfd_byte
*) ex
->ri_gp_value
);
1358 bfd_mips_elf64_swap_reginfo_out (abfd
, in
, ex
)
1360 const Elf64_Internal_RegInfo
*in
;
1361 Elf64_External_RegInfo
*ex
;
1363 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_gprmask
,
1364 (bfd_byte
*) ex
->ri_gprmask
);
1365 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_pad
,
1366 (bfd_byte
*) ex
->ri_pad
);
1367 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[0],
1368 (bfd_byte
*) ex
->ri_cprmask
[0]);
1369 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[1],
1370 (bfd_byte
*) ex
->ri_cprmask
[1]);
1371 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[2],
1372 (bfd_byte
*) ex
->ri_cprmask
[2]);
1373 bfd_h_put_32 (abfd
, (bfd_vma
) in
->ri_cprmask
[3],
1374 (bfd_byte
*) ex
->ri_cprmask
[3]);
1375 bfd_h_put_64 (abfd
, (bfd_vma
) in
->ri_gp_value
,
1376 (bfd_byte
*) ex
->ri_gp_value
);
1379 /* Swap an entry in a .gptab section. Note that these routines rely
1380 on the equivalence of the two elements of the union. */
1383 bfd_mips_elf32_swap_gptab_in (abfd
, ex
, in
)
1385 const Elf32_External_gptab
*ex
;
1388 in
->gt_entry
.gt_g_value
= bfd_h_get_32 (abfd
, ex
->gt_entry
.gt_g_value
);
1389 in
->gt_entry
.gt_bytes
= bfd_h_get_32 (abfd
, ex
->gt_entry
.gt_bytes
);
1393 bfd_mips_elf32_swap_gptab_out (abfd
, in
, ex
)
1395 const Elf32_gptab
*in
;
1396 Elf32_External_gptab
*ex
;
1398 bfd_h_put_32 (abfd
, (bfd_vma
) in
->gt_entry
.gt_g_value
,
1399 ex
->gt_entry
.gt_g_value
);
1400 bfd_h_put_32 (abfd
, (bfd_vma
) in
->gt_entry
.gt_bytes
,
1401 ex
->gt_entry
.gt_bytes
);
1405 bfd_elf32_swap_compact_rel_out (abfd
, in
, ex
)
1407 const Elf32_compact_rel
*in
;
1408 Elf32_External_compact_rel
*ex
;
1410 bfd_h_put_32 (abfd
, (bfd_vma
) in
->id1
, ex
->id1
);
1411 bfd_h_put_32 (abfd
, (bfd_vma
) in
->num
, ex
->num
);
1412 bfd_h_put_32 (abfd
, (bfd_vma
) in
->id2
, ex
->id2
);
1413 bfd_h_put_32 (abfd
, (bfd_vma
) in
->offset
, ex
->offset
);
1414 bfd_h_put_32 (abfd
, (bfd_vma
) in
->reserved0
, ex
->reserved0
);
1415 bfd_h_put_32 (abfd
, (bfd_vma
) in
->reserved1
, ex
->reserved1
);
1419 bfd_elf32_swap_crinfo_out (abfd
, in
, ex
)
1421 const Elf32_crinfo
*in
;
1422 Elf32_External_crinfo
*ex
;
1426 l
= (((in
->ctype
& CRINFO_CTYPE
) << CRINFO_CTYPE_SH
)
1427 | ((in
->rtype
& CRINFO_RTYPE
) << CRINFO_RTYPE_SH
)
1428 | ((in
->dist2to
& CRINFO_DIST2TO
) << CRINFO_DIST2TO_SH
)
1429 | ((in
->relvaddr
& CRINFO_RELVADDR
) << CRINFO_RELVADDR_SH
));
1430 bfd_h_put_32 (abfd
, (bfd_vma
) l
, ex
->info
);
1431 bfd_h_put_32 (abfd
, (bfd_vma
) in
->konst
, ex
->konst
);
1432 bfd_h_put_32 (abfd
, (bfd_vma
) in
->vaddr
, ex
->vaddr
);
1435 /* Swap in an options header. */
1438 bfd_mips_elf_swap_options_in (abfd
, ex
, in
)
1440 const Elf_External_Options
*ex
;
1441 Elf_Internal_Options
*in
;
1443 in
->kind
= bfd_h_get_8 (abfd
, ex
->kind
);
1444 in
->size
= bfd_h_get_8 (abfd
, ex
->size
);
1445 in
->section
= bfd_h_get_16 (abfd
, ex
->section
);
1446 in
->info
= bfd_h_get_32 (abfd
, ex
->info
);
1449 /* Swap out an options header. */
1452 bfd_mips_elf_swap_options_out (abfd
, in
, ex
)
1454 const Elf_Internal_Options
*in
;
1455 Elf_External_Options
*ex
;
1457 bfd_h_put_8 (abfd
, in
->kind
, ex
->kind
);
1458 bfd_h_put_8 (abfd
, in
->size
, ex
->size
);
1459 bfd_h_put_16 (abfd
, in
->section
, ex
->section
);
1460 bfd_h_put_32 (abfd
, in
->info
, ex
->info
);
1463 /* Determine whether a symbol is global for the purposes of splitting
1464 the symbol table into global symbols and local symbols. At least
1465 on Irix 5, this split must be between section symbols and all other
1466 symbols. On most ELF targets the split is between static symbols
1467 and externally visible symbols. */
1471 mips_elf_sym_is_global (abfd
, sym
)
1475 return (sym
->flags
& BSF_SECTION_SYM
) == 0 ? true : false;
1478 /* Set the right machine number for a MIPS ELF file. This is used for
1479 both the 32-bit and the 64-bit ABI. */
1482 _bfd_mips_elf_object_p (abfd
)
1485 switch (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
)
1489 /* Just use the default, which was set in elfcode.h. */
1493 (void) bfd_default_set_arch_mach (abfd
, bfd_arch_mips
, 6000);
1497 (void) bfd_default_set_arch_mach (abfd
, bfd_arch_mips
, 4000);
1501 (void) bfd_default_set_arch_mach (abfd
, bfd_arch_mips
, 8000);
1508 /* Set the right machine number for a 32-bit MIPS ELF file. */
1511 mips_elf32_object_p (abfd
)
1514 /* Irix 5 is broken. Object file symbol tables are not always
1515 sorted correctly such that local symbols precede global symbols,
1516 and the sh_info field in the symbol table is not always right. */
1517 elf_bad_symtab (abfd
) = true;
1519 return _bfd_mips_elf_object_p (abfd
);
1522 /* The final processing done just before writing out a MIPS ELF object
1523 file. This gets the MIPS architecture right based on the machine
1524 number. This is used by both the 32-bit and the 64-bit ABI. */
1528 _bfd_mips_elf_final_write_processing (abfd
, linker
)
1534 Elf_Internal_Shdr
**hdrpp
;
1536 switch (bfd_get_mach (abfd
))
1539 val
= E_MIPS_ARCH_1
;
1543 val
= E_MIPS_ARCH_2
;
1547 val
= E_MIPS_ARCH_3
;
1551 val
= E_MIPS_ARCH_4
;
1559 elf_elfheader (abfd
)->e_flags
&=~ EF_MIPS_ARCH
;
1560 elf_elfheader (abfd
)->e_flags
|= val
;
1562 /* Set the sh_info field for .gptab sections. */
1563 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
1564 i
< elf_elfheader (abfd
)->e_shnum
;
1567 if ((*hdrpp
)->sh_type
== SHT_MIPS_GPTAB
)
1572 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
1573 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
1574 BFD_ASSERT (name
!= NULL
1575 && strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0);
1576 sec
= bfd_get_section_by_name (abfd
, name
+ sizeof ".gptab" - 1);
1577 BFD_ASSERT (sec
!= NULL
);
1578 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
1583 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
1586 _bfd_mips_elf_set_private_flags (abfd
, flags
)
1590 BFD_ASSERT (!elf_flags_init (abfd
)
1591 || elf_elfheader (abfd
)->e_flags
== flags
);
1593 elf_elfheader (abfd
)->e_flags
= flags
;
1594 elf_flags_init (abfd
) = true;
1598 /* Copy backend specific data from one object module to another */
1601 _bfd_mips_elf_copy_private_bfd_data (ibfd
, obfd
)
1605 /* This function is selected based on the input vector. We only
1606 want to copy information over if the output BFD also uses Elf
1608 if (bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1611 BFD_ASSERT (!elf_flags_init (obfd
)
1612 || (elf_elfheader (obfd
)->e_flags
1613 == elf_elfheader (ibfd
)->e_flags
));
1615 elf_gp (obfd
) = elf_gp (ibfd
);
1616 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
1617 elf_flags_init (obfd
) = true;
1621 /* Merge backend specific data from an object file to the output
1622 object file when linking. */
1625 _bfd_mips_elf_merge_private_bfd_data (ibfd
, obfd
)
1632 /* Check if we have the same endianess */
1633 if (ibfd
->xvec
->byteorder
!= obfd
->xvec
->byteorder
1634 && obfd
->xvec
->byteorder
!= BFD_ENDIAN_UNKNOWN
)
1636 (*_bfd_error_handler
)
1637 ("%s: compiled for a %s endian system and target is %s endian",
1638 bfd_get_filename (ibfd
),
1639 bfd_big_endian (ibfd
) ? "big" : "little",
1640 bfd_big_endian (obfd
) ? "big" : "little");
1642 bfd_set_error (bfd_error_wrong_format
);
1646 /* This function is selected based on the input vector. We only
1647 want to copy information over if the output BFD also uses Elf
1649 if (bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1652 new_flags
= elf_elfheader (ibfd
)->e_flags
;
1653 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_NOREORDER
;
1654 old_flags
= elf_elfheader (obfd
)->e_flags
;
1656 if (!elf_flags_init (obfd
)) /* First call, no flags set */
1658 elf_flags_init (obfd
) = true;
1659 elf_elfheader (obfd
)->e_flags
= new_flags
;
1661 else if (((new_flags
^ old_flags
) & ~EF_MIPS_NOREORDER
)
1662 == 0) /* Compatible flags are ok */
1664 else /* Incompatible flags */
1666 /* Warn about -fPIC mismatch */
1667 if ((new_flags
& EF_MIPS_PIC
) != (old_flags
& EF_MIPS_PIC
))
1669 new_flags
&= ~EF_MIPS_PIC
;
1670 (*_bfd_error_handler
)
1671 ("%s: needs all files compiled with -fPIC",
1672 bfd_get_filename (ibfd
));
1675 if ((new_flags
& EF_MIPS_CPIC
) != (old_flags
& EF_MIPS_CPIC
))
1677 new_flags
&= ~EF_MIPS_CPIC
;
1678 (*_bfd_error_handler
)
1679 ("%s: needs all files compiled with -mabicalls",
1680 bfd_get_filename (ibfd
));
1683 /* Warn about any other mismatches */
1684 if (new_flags
!= old_flags
)
1685 (*_bfd_error_handler
)
1686 ("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)",
1687 bfd_get_filename (ibfd
), (unsigned long) new_flags
,
1688 (unsigned long) old_flags
);
1690 bfd_set_error (bfd_error_bad_value
);
1697 /* Handle a MIPS specific section when reading an object file. This
1698 is called when elfcode.h finds a section with an unknown type.
1699 This routine supports both the 32-bit and 64-bit ELF ABI.
1701 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
1705 _bfd_mips_elf_section_from_shdr (abfd
, hdr
, name
)
1707 Elf_Internal_Shdr
*hdr
;
1710 /* There ought to be a place to keep ELF backend specific flags, but
1711 at the moment there isn't one. We just keep track of the
1712 sections by their name, instead. Fortunately, the ABI gives
1713 suggested names for all the MIPS specific sections, so we will
1714 probably get away with this. */
1715 switch (hdr
->sh_type
)
1717 case SHT_MIPS_LIBLIST
:
1718 if (strcmp (name
, ".liblist") != 0)
1722 if (strcmp (name
, ".msym") != 0)
1725 case SHT_MIPS_CONFLICT
:
1726 if (strcmp (name
, ".conflict") != 0)
1729 case SHT_MIPS_GPTAB
:
1730 if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) != 0)
1733 case SHT_MIPS_UCODE
:
1734 if (strcmp (name
, ".ucode") != 0)
1737 case SHT_MIPS_DEBUG
:
1738 if (strcmp (name
, ".mdebug") != 0)
1741 case SHT_MIPS_REGINFO
:
1742 if (strcmp (name
, ".reginfo") != 0
1743 || hdr
->sh_size
!= sizeof (Elf32_External_RegInfo
))
1746 case SHT_MIPS_OPTIONS
:
1747 if (strcmp (name
, ".options") != 0
1748 && strcmp (name
, ".MIPS.options") != 0)
1751 case SHT_MIPS_DWARF
:
1752 if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) != 0)
1755 case SHT_MIPS_EVENTS
:
1756 if (strncmp (name
, ".MIPS.events.", sizeof ".MIPS.events." - 1) != 0)
1763 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
1766 if (hdr
->sh_type
== SHT_MIPS_DEBUG
)
1768 if (! bfd_set_section_flags (abfd
, hdr
->bfd_section
,
1769 (bfd_get_section_flags (abfd
,
1778 /* Handle a 32-bit MIPS ELF specific section. */
1781 mips_elf32_section_from_shdr (abfd
, hdr
, name
)
1783 Elf_Internal_Shdr
*hdr
;
1786 if (! _bfd_mips_elf_section_from_shdr (abfd
, hdr
, name
))
1789 /* FIXME: We should record sh_info for a .gptab section. */
1791 /* For a .reginfo section, set the gp value in the tdata information
1792 from the contents of this section. We need the gp value while
1793 processing relocs, so we just get it now. The .reginfo section
1794 is not used in the 64-bit MIPS ELF ABI. */
1795 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
1797 Elf32_External_RegInfo ext
;
1800 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, (PTR
) &ext
,
1801 (file_ptr
) 0, sizeof ext
))
1803 bfd_mips_elf32_swap_reginfo_in (abfd
, &ext
, &s
);
1804 elf_gp (abfd
) = s
.ri_gp_value
;
1807 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
1808 set the gp value based on what we find. We may see both
1809 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
1810 they should agree. */
1811 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
)
1813 bfd_byte
*contents
, *l
, *lend
;
1815 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
1816 if (contents
== NULL
)
1818 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
,
1819 (file_ptr
) 0, hdr
->sh_size
))
1825 lend
= contents
+ hdr
->sh_size
;
1826 while (l
+ sizeof (Elf_External_Options
) <= lend
)
1828 Elf_Internal_Options intopt
;
1830 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
1832 if (intopt
.kind
== ODK_REGINFO
)
1834 Elf32_RegInfo intreg
;
1836 bfd_mips_elf32_swap_reginfo_in
1838 ((Elf32_External_RegInfo
*)
1839 (l
+ sizeof (Elf_External_Options
))),
1841 elf_gp (abfd
) = intreg
.ri_gp_value
;
1851 /* Set the correct type for a MIPS ELF section. We do this by the
1852 section name, which is a hack, but ought to work. This routine is
1853 used by both the 32-bit and the 64-bit ABI. */
1856 _bfd_mips_elf_fake_sections (abfd
, hdr
, sec
)
1858 Elf32_Internal_Shdr
*hdr
;
1861 register const char *name
;
1863 name
= bfd_get_section_name (abfd
, sec
);
1865 if (strcmp (name
, ".liblist") == 0)
1867 hdr
->sh_type
= SHT_MIPS_LIBLIST
;
1868 hdr
->sh_info
= sec
->_raw_size
/ sizeof (Elf32_Lib
);
1869 /* FIXME: Set the sh_link field. */
1871 else if (strcmp (name
, ".msym") == 0)
1873 hdr
->sh_type
= SHT_MIPS_MSYM
;
1874 hdr
->sh_entsize
= 8;
1875 /* FIXME: Set the sh_info field. */
1877 else if (strcmp (name
, ".conflict") == 0)
1878 hdr
->sh_type
= SHT_MIPS_CONFLICT
;
1879 else if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0)
1881 hdr
->sh_type
= SHT_MIPS_GPTAB
;
1882 hdr
->sh_entsize
= sizeof (Elf32_External_gptab
);
1883 /* The sh_info field is set in final_write_processing. */
1885 else if (strcmp (name
, ".ucode") == 0)
1886 hdr
->sh_type
= SHT_MIPS_UCODE
;
1887 else if (strcmp (name
, ".mdebug") == 0)
1889 hdr
->sh_type
= SHT_MIPS_DEBUG
;
1890 /* In a shared object on Irix 5.3, the .mdebug section has an
1891 entsize of 0. FIXME: Does this matter? */
1892 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
1893 hdr
->sh_entsize
= 0;
1895 hdr
->sh_entsize
= 1;
1897 else if (strcmp (name
, ".reginfo") == 0)
1899 hdr
->sh_type
= SHT_MIPS_REGINFO
;
1900 /* In a shared object on Irix 5.3, the .reginfo section has an
1901 entsize of 0x18. FIXME: Does this matter? */
1902 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
1903 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
1905 hdr
->sh_entsize
= 1;
1907 /* Force the section size to the correct value, even if the
1908 linker thinks it is larger. The link routine below will only
1909 write out this much data for .reginfo. */
1910 hdr
->sh_size
= sec
->_raw_size
= sizeof (Elf32_External_RegInfo
);
1912 else if (SGI_COMPAT (abfd
)
1913 && (strcmp (name
, ".hash") == 0
1914 || strcmp (name
, ".dynamic") == 0
1915 || strcmp (name
, ".dynstr") == 0))
1917 hdr
->sh_entsize
= 0;
1918 hdr
->sh_info
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
1920 else if (strcmp (name
, ".got") == 0
1921 || strcmp (name
, ".sdata") == 0
1922 || strcmp (name
, ".sbss") == 0
1923 || strcmp (name
, ".lit4") == 0
1924 || strcmp (name
, ".lit8") == 0)
1925 hdr
->sh_flags
|= SHF_MIPS_GPREL
;
1926 else if (strcmp (name
, ".options") == 0
1927 || strcmp (name
, ".MIPS.options") == 0)
1929 hdr
->sh_type
= SHT_MIPS_OPTIONS
;
1930 hdr
->sh_entsize
= 1;
1932 else if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) == 0)
1933 hdr
->sh_type
= SHT_MIPS_DWARF
;
1934 else if (strncmp (name
, ".MIPS.events.", sizeof ".MIPS.events." - 1) == 0)
1935 hdr
->sh_type
= SHT_MIPS_EVENTS
;
1940 /* Given a BFD section, try to locate the corresponding ELF section
1941 index. This is used by both the 32-bit and the 64-bit ABI.
1942 Actually, it's not clear to me that the 64-bit ABI supports these,
1943 but for non-PIC objects we will certainly want support for at least
1944 the .scommon section. */
1947 _bfd_mips_elf_section_from_bfd_section (abfd
, hdr
, sec
, retval
)
1949 Elf32_Internal_Shdr
*hdr
;
1953 if (strcmp (bfd_get_section_name (abfd
, sec
), ".scommon") == 0)
1955 *retval
= SHN_MIPS_SCOMMON
;
1958 if (strcmp (bfd_get_section_name (abfd
, sec
), ".acommon") == 0)
1960 *retval
= SHN_MIPS_ACOMMON
;
1966 /* When are writing out the .options or .MIPS.options section,
1967 remember the bytes we are writing out, so that we can install the
1968 GP value in the section_processing routine. */
1971 _bfd_mips_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
1976 bfd_size_type count
;
1978 if (strcmp (section
->name
, ".options") == 0
1979 || strcmp (section
->name
, ".MIPS.options") == 0)
1983 if (elf_section_data (section
) == NULL
)
1985 section
->used_by_bfd
=
1986 (PTR
) bfd_zalloc (abfd
, sizeof (struct bfd_elf_section_data
));
1987 if (elf_section_data (section
) == NULL
)
1990 c
= (bfd_byte
*) elf_section_data (section
)->tdata
;
1995 if (section
->_cooked_size
!= 0)
1996 size
= section
->_cooked_size
;
1998 size
= section
->_raw_size
;
1999 c
= (PTR
) bfd_zalloc (abfd
, size
);
2002 elf_section_data (section
)->tdata
= (PTR
) c
;
2005 memcpy (c
+ offset
, location
, count
);
2008 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
,
2012 /* Work over a section just before writing it out. This routine is
2013 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
2014 sections that need the SHF_MIPS_GPREL flag by name; there has to be
2018 _bfd_mips_elf_section_processing (abfd
, hdr
)
2020 Elf_Internal_Shdr
*hdr
;
2022 if (hdr
->bfd_section
!= NULL
)
2024 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
2026 if (strcmp (name
, ".sdata") == 0)
2028 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
2029 hdr
->sh_type
= SHT_PROGBITS
;
2031 else if (strcmp (name
, ".sbss") == 0)
2033 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
2034 hdr
->sh_type
= SHT_NOBITS
;
2036 else if (strcmp (name
, ".lit8") == 0
2037 || strcmp (name
, ".lit4") == 0)
2039 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
2040 hdr
->sh_type
= SHT_PROGBITS
;
2042 else if (strcmp (name
, ".compact_rel") == 0)
2045 hdr
->sh_type
= SHT_PROGBITS
;
2047 else if (strcmp (name
, ".rtproc") == 0)
2049 if (hdr
->sh_addralign
!= 0 && hdr
->sh_entsize
== 0)
2051 unsigned int adjust
;
2053 adjust
= hdr
->sh_size
% hdr
->sh_addralign
;
2055 hdr
->sh_size
+= hdr
->sh_addralign
- adjust
;
2063 /* Work over a section just before writing it out. We update the GP
2064 value in the SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS sections based
2065 on the value we are using. */
2068 mips_elf32_section_processing (abfd
, hdr
)
2070 Elf32_Internal_Shdr
*hdr
;
2072 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
2076 BFD_ASSERT (hdr
->sh_size
== sizeof (Elf32_External_RegInfo
));
2077 BFD_ASSERT (hdr
->contents
== NULL
);
2080 hdr
->sh_offset
+ sizeof (Elf32_External_RegInfo
) - 4,
2083 bfd_h_put_32 (abfd
, (bfd_vma
) elf_gp (abfd
), buf
);
2084 if (bfd_write (buf
, (bfd_size_type
) 1, (bfd_size_type
) 4, abfd
) != 4)
2088 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
2089 && hdr
->bfd_section
!= NULL
2090 && elf_section_data (hdr
->bfd_section
) != NULL
2091 && elf_section_data (hdr
->bfd_section
)->tdata
!= NULL
)
2093 bfd_byte
*contents
, *l
, *lend
;
2095 /* We stored the section contents in the elf_section_data tdata
2096 field in the set_section_contents routine. We save the
2097 section contents so that we don't have to read them again.
2098 At this point we know that elf_gp is set, so we can look
2099 through the section contents to see if there is an
2100 ODK_REGINFO structure. */
2102 contents
= (bfd_byte
*) elf_section_data (hdr
->bfd_section
)->tdata
;
2104 lend
= contents
+ hdr
->sh_size
;
2105 while (l
+ sizeof (Elf_External_Options
) <= lend
)
2107 Elf_Internal_Options intopt
;
2109 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
2111 if (intopt
.kind
== ODK_REGINFO
)
2118 + sizeof (Elf_External_Options
)
2119 + (sizeof (Elf32_External_RegInfo
) - 4)),
2122 bfd_h_put_32 (abfd
, elf_gp (abfd
), buf
);
2123 if (bfd_write (buf
, 1, 4, abfd
) != 4)
2130 return _bfd_mips_elf_section_processing (abfd
, hdr
);
2133 /* MIPS ELF uses two common sections. One is the usual one, and the
2134 other is for small objects. All the small objects are kept
2135 together, and then referenced via the gp pointer, which yields
2136 faster assembler code. This is what we use for the small common
2137 section. This approach is copied from ecoff.c. */
2138 static asection mips_elf_scom_section
;
2139 static asymbol mips_elf_scom_symbol
;
2140 static asymbol
*mips_elf_scom_symbol_ptr
;
2142 /* MIPS ELF also uses an acommon section, which represents an
2143 allocated common symbol which may be overridden by a
2144 definition in a shared library. */
2145 static asection mips_elf_acom_section
;
2146 static asymbol mips_elf_acom_symbol
;
2147 static asymbol
*mips_elf_acom_symbol_ptr
;
2149 /* The Irix 5 support uses two virtual sections, which represent
2150 text/data symbols defined in dynamic objects. */
2151 static asection mips_elf_text_section
;
2152 static asection
*mips_elf_text_section_ptr
;
2153 static asymbol mips_elf_text_symbol
;
2154 static asymbol
*mips_elf_text_symbol_ptr
;
2156 static asection mips_elf_data_section
;
2157 static asection
*mips_elf_data_section_ptr
;
2158 static asymbol mips_elf_data_symbol
;
2159 static asymbol
*mips_elf_data_symbol_ptr
;
2161 /* Handle the special MIPS section numbers that a symbol may use.
2162 This is used for both the 32-bit and the 64-bit ABI. */
2165 _bfd_mips_elf_symbol_processing (abfd
, asym
)
2169 elf_symbol_type
*elfsym
;
2171 elfsym
= (elf_symbol_type
*) asym
;
2172 switch (elfsym
->internal_elf_sym
.st_shndx
)
2174 case SHN_MIPS_ACOMMON
:
2175 /* This section is used in a dynamically linked executable file.
2176 It is an allocated common section. The dynamic linker can
2177 either resolve these symbols to something in a shared
2178 library, or it can just leave them here. For our purposes,
2179 we can consider these symbols to be in a new section. */
2180 if (mips_elf_acom_section
.name
== NULL
)
2182 /* Initialize the acommon section. */
2183 mips_elf_acom_section
.name
= ".acommon";
2184 mips_elf_acom_section
.flags
= SEC_ALLOC
;
2185 mips_elf_acom_section
.output_section
= &mips_elf_acom_section
;
2186 mips_elf_acom_section
.symbol
= &mips_elf_acom_symbol
;
2187 mips_elf_acom_section
.symbol_ptr_ptr
= &mips_elf_acom_symbol_ptr
;
2188 mips_elf_acom_symbol
.name
= ".acommon";
2189 mips_elf_acom_symbol
.flags
= BSF_SECTION_SYM
;
2190 mips_elf_acom_symbol
.section
= &mips_elf_acom_section
;
2191 mips_elf_acom_symbol_ptr
= &mips_elf_acom_symbol
;
2193 asym
->section
= &mips_elf_acom_section
;
2197 /* Common symbols less than the GP size are automatically
2198 treated as SHN_MIPS_SCOMMON symbols. */
2199 if (asym
->value
> elf_gp_size (abfd
))
2202 case SHN_MIPS_SCOMMON
:
2203 if (mips_elf_scom_section
.name
== NULL
)
2205 /* Initialize the small common section. */
2206 mips_elf_scom_section
.name
= ".scommon";
2207 mips_elf_scom_section
.flags
= SEC_IS_COMMON
;
2208 mips_elf_scom_section
.output_section
= &mips_elf_scom_section
;
2209 mips_elf_scom_section
.symbol
= &mips_elf_scom_symbol
;
2210 mips_elf_scom_section
.symbol_ptr_ptr
= &mips_elf_scom_symbol_ptr
;
2211 mips_elf_scom_symbol
.name
= ".scommon";
2212 mips_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
2213 mips_elf_scom_symbol
.section
= &mips_elf_scom_section
;
2214 mips_elf_scom_symbol_ptr
= &mips_elf_scom_symbol
;
2216 asym
->section
= &mips_elf_scom_section
;
2217 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
2220 case SHN_MIPS_SUNDEFINED
:
2221 asym
->section
= bfd_und_section_ptr
;
2224 #if 0 /* for SGI_COMPAT */
2226 asym
->section
= mips_elf_text_section_ptr
;
2230 asym
->section
= mips_elf_data_section_ptr
;
2236 /* When creating an Irix 5 executable, we need REGINFO and RTPROC
2240 mips_elf_additional_program_headers (abfd
)
2248 if (! SGI_COMPAT (abfd
))
2251 s
= bfd_get_section_by_name (abfd
, ".reginfo");
2252 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2254 /* We need a PT_MIPS_REGINFO segment. */
2258 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
2259 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
2261 /* We need a PT_MIPS_RTPROC segment. */
2268 /* Modify the segment map for an Irix 5 executable. */
2271 mips_elf_modify_segment_map (abfd
)
2275 struct elf_segment_map
*m
, **pm
;
2277 if (! SGI_COMPAT (abfd
))
2280 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
2282 s
= bfd_get_section_by_name (abfd
, ".reginfo");
2283 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2285 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2286 if (m
->p_type
== PT_MIPS_REGINFO
)
2290 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, sizeof *m
);
2294 m
->p_type
= PT_MIPS_REGINFO
;
2298 /* We want to put it after the PHDR and INTERP segments. */
2299 pm
= &elf_tdata (abfd
)->segment_map
;
2301 && ((*pm
)->p_type
== PT_PHDR
2302 || (*pm
)->p_type
== PT_INTERP
))
2310 /* If there are .dynamic and .mdebug sections, we make a room for
2311 the RTPROC header. FIXME: Rewrite without section names. */
2312 if (bfd_get_section_by_name (abfd
, ".interp") == NULL
2313 && bfd_get_section_by_name (abfd
, ".dynamic") != NULL
2314 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
2316 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2317 if (m
->p_type
== PT_MIPS_RTPROC
)
2321 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, sizeof *m
);
2325 m
->p_type
= PT_MIPS_RTPROC
;
2327 s
= bfd_get_section_by_name (abfd
, ".rtproc");
2332 m
->p_flags_valid
= 1;
2340 /* We want to put it after the DYNAMIC segment. */
2341 pm
= &elf_tdata (abfd
)->segment_map
;
2342 while (*pm
!= NULL
&& (*pm
)->p_type
!= PT_DYNAMIC
)
2352 /* On Irix 5, the PT_DYNAMIC segment includes the .dynamic, .dynstr,
2353 .dynsym, and .hash sections, and everything in between. */
2354 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
; pm
= &(*pm
)->next
)
2355 if ((*pm
)->p_type
== PT_DYNAMIC
)
2360 && strcmp (m
->sections
[0]->name
, ".dynamic") == 0)
2362 static const char *sec_names
[] =
2363 { ".dynamic", ".dynstr", ".dynsym", ".hash" };
2366 struct elf_segment_map
*n
;
2370 for (i
= 0; i
< sizeof sec_names
/ sizeof sec_names
[0]; i
++)
2372 s
= bfd_get_section_by_name (abfd
, sec_names
[i
]);
2373 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2379 sz
= s
->_cooked_size
;
2382 if (high
< s
->vma
+ sz
)
2388 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2389 if ((s
->flags
& SEC_LOAD
) != 0
2392 + (s
->_cooked_size
!= 0 ? s
->_cooked_size
: s
->_raw_size
))
2396 n
= ((struct elf_segment_map
*)
2397 bfd_zalloc (abfd
, sizeof *n
+ (c
- 1) * sizeof (asection
*)));
2404 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2406 if ((s
->flags
& SEC_LOAD
) != 0
2409 + (s
->_cooked_size
!= 0 ? s
->_cooked_size
: s
->_raw_size
))
2423 /* The structure of the runtime procedure descriptor created by the
2424 loader for use by the static exception system. */
2426 typedef struct runtime_pdr
{
2427 bfd_vma adr
; /* memory address of start of procedure */
2428 long regmask
; /* save register mask */
2429 long regoffset
; /* save register offset */
2430 long fregmask
; /* save floating point register mask */
2431 long fregoffset
; /* save floating point register offset */
2432 long frameoffset
; /* frame size */
2433 short framereg
; /* frame pointer register */
2434 short pcreg
; /* offset or reg of return pc */
2435 long irpss
; /* index into the runtime string table */
2437 struct exception_info
*exception_info
;/* pointer to exception array */
2439 #define cbRPDR sizeof(RPDR)
2440 #define rpdNil ((pRPDR) 0)
2442 /* Swap RPDR (runtime procedure table entry) for output. */
2444 static void ecoff_swap_rpdr_out
2445 PARAMS ((bfd
*, const RPDR
*, struct rpdr_ext
*));
2448 ecoff_swap_rpdr_out (abfd
, in
, ex
)
2451 struct rpdr_ext
*ex
;
2453 /* ecoff_put_off was defined in ecoffswap.h. */
2454 ecoff_put_off (abfd
, in
->adr
, (bfd_byte
*) ex
->p_adr
);
2455 bfd_h_put_32 (abfd
, in
->regmask
, (bfd_byte
*) ex
->p_regmask
);
2456 bfd_h_put_32 (abfd
, in
->regoffset
, (bfd_byte
*) ex
->p_regoffset
);
2457 bfd_h_put_32 (abfd
, in
->fregmask
, (bfd_byte
*) ex
->p_fregmask
);
2458 bfd_h_put_32 (abfd
, in
->fregoffset
, (bfd_byte
*) ex
->p_fregoffset
);
2459 bfd_h_put_32 (abfd
, in
->frameoffset
, (bfd_byte
*) ex
->p_frameoffset
);
2461 bfd_h_put_16 (abfd
, in
->framereg
, (bfd_byte
*) ex
->p_framereg
);
2462 bfd_h_put_16 (abfd
, in
->pcreg
, (bfd_byte
*) ex
->p_pcreg
);
2464 bfd_h_put_32 (abfd
, in
->irpss
, (bfd_byte
*) ex
->p_irpss
);
2466 ecoff_put_off (abfd
, in
->exception_info
, (bfd_byte
*) ex
->p_exception_info
);
2470 /* Read ECOFF debugging information from a .mdebug section into a
2471 ecoff_debug_info structure. */
2474 _bfd_mips_elf_read_ecoff_info (abfd
, section
, debug
)
2477 struct ecoff_debug_info
*debug
;
2480 const struct ecoff_debug_swap
*swap
;
2481 char *ext_hdr
= NULL
;
2483 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
2485 ext_hdr
= (char *) bfd_malloc ((size_t) swap
->external_hdr_size
);
2486 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
2489 if (bfd_get_section_contents (abfd
, section
, ext_hdr
, (file_ptr
) 0,
2490 swap
->external_hdr_size
)
2494 symhdr
= &debug
->symbolic_header
;
2495 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
2497 /* The symbolic header contains absolute file offsets and sizes to
2499 #define READ(ptr, offset, count, size, type) \
2500 if (symhdr->count == 0) \
2501 debug->ptr = NULL; \
2504 debug->ptr = (type) bfd_malloc ((size_t) (size * symhdr->count)); \
2505 if (debug->ptr == NULL) \
2506 goto error_return; \
2507 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
2508 || (bfd_read (debug->ptr, size, symhdr->count, \
2509 abfd) != size * symhdr->count)) \
2510 goto error_return; \
2513 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
2514 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, PTR
);
2515 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, PTR
);
2516 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, PTR
);
2517 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, PTR
);
2518 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
2520 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
2521 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
2522 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, PTR
);
2523 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, PTR
);
2524 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, PTR
);
2528 debug
->adjust
= NULL
;
2533 if (ext_hdr
!= NULL
)
2535 if (debug
->line
!= NULL
)
2537 if (debug
->external_dnr
!= NULL
)
2538 free (debug
->external_dnr
);
2539 if (debug
->external_pdr
!= NULL
)
2540 free (debug
->external_pdr
);
2541 if (debug
->external_sym
!= NULL
)
2542 free (debug
->external_sym
);
2543 if (debug
->external_opt
!= NULL
)
2544 free (debug
->external_opt
);
2545 if (debug
->external_aux
!= NULL
)
2546 free (debug
->external_aux
);
2547 if (debug
->ss
!= NULL
)
2549 if (debug
->ssext
!= NULL
)
2550 free (debug
->ssext
);
2551 if (debug
->external_fdr
!= NULL
)
2552 free (debug
->external_fdr
);
2553 if (debug
->external_rfd
!= NULL
)
2554 free (debug
->external_rfd
);
2555 if (debug
->external_ext
!= NULL
)
2556 free (debug
->external_ext
);
2560 /* MIPS ELF local labels start with '$', not 'L'. */
2564 mips_elf_is_local_label (abfd
, symbol
)
2568 return symbol
->name
[0] == '$';
2571 /* MIPS ELF uses a special find_nearest_line routine in order the
2572 handle the ECOFF debugging information. */
2574 struct mips_elf_find_line
2576 struct ecoff_debug_info d
;
2577 struct ecoff_find_line i
;
2581 _bfd_mips_elf_find_nearest_line (abfd
, section
, symbols
, offset
, filename_ptr
,
2582 functionname_ptr
, line_ptr
)
2587 const char **filename_ptr
;
2588 const char **functionname_ptr
;
2589 unsigned int *line_ptr
;
2593 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
2597 struct mips_elf_find_line
*fi
;
2598 const struct ecoff_debug_swap
* const swap
=
2599 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
2601 /* If we are called during a link, mips_elf_final_link may have
2602 cleared the SEC_HAS_CONTENTS field. We force it back on here
2603 if appropriate (which it normally will be). */
2604 origflags
= msec
->flags
;
2605 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
2606 msec
->flags
|= SEC_HAS_CONTENTS
;
2608 fi
= elf_tdata (abfd
)->find_line_info
;
2611 bfd_size_type external_fdr_size
;
2614 struct fdr
*fdr_ptr
;
2616 fi
= ((struct mips_elf_find_line
*)
2617 bfd_zalloc (abfd
, sizeof (struct mips_elf_find_line
)));
2620 msec
->flags
= origflags
;
2624 if (! _bfd_mips_elf_read_ecoff_info (abfd
, msec
, &fi
->d
))
2626 msec
->flags
= origflags
;
2630 /* Swap in the FDR information. */
2631 fi
->d
.fdr
= ((struct fdr
*)
2633 (fi
->d
.symbolic_header
.ifdMax
*
2634 sizeof (struct fdr
))));
2635 if (fi
->d
.fdr
== NULL
)
2637 msec
->flags
= origflags
;
2640 external_fdr_size
= swap
->external_fdr_size
;
2641 fdr_ptr
= fi
->d
.fdr
;
2642 fraw_src
= (char *) fi
->d
.external_fdr
;
2643 fraw_end
= (fraw_src
2644 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
2645 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
2646 (*swap
->swap_fdr_in
) (abfd
, (PTR
) fraw_src
, fdr_ptr
);
2648 elf_tdata (abfd
)->find_line_info
= fi
;
2650 /* Note that we don't bother to ever free this information.
2651 find_nearest_line is either called all the time, as in
2652 objdump -l, so the information should be saved, or it is
2653 rarely called, as in ld error messages, so the memory
2654 wasted is unimportant. Still, it would probably be a
2655 good idea for free_cached_info to throw it away. */
2658 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
2659 &fi
->i
, filename_ptr
, functionname_ptr
,
2662 msec
->flags
= origflags
;
2666 msec
->flags
= origflags
;
2669 /* Fall back on the generic ELF find_nearest_line routine. */
2671 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
2672 filename_ptr
, functionname_ptr
,
2676 /* The MIPS ELF linker needs additional information for each symbol in
2677 the global hash table. */
2679 struct mips_elf_link_hash_entry
2681 struct elf_link_hash_entry root
;
2683 /* External symbol information. */
2686 /* Number of MIPS_32 or MIPS_REL32 relocs against this symbol. */
2687 unsigned int mips_32_relocs
;
2690 /* MIPS ELF linker hash table. */
2692 struct mips_elf_link_hash_table
2694 struct elf_link_hash_table root
;
2695 /* String section indices for the dynamic section symbols. */
2696 bfd_size_type dynsym_sec_strindex
[SIZEOF_MIPS_DYNSYM_SECNAMES
];
2697 /* The number of .rtproc entries. */
2698 bfd_size_type procedure_count
;
2699 /* The size of the .compact_rel section (if SGI_COMPAT). */
2700 bfd_size_type compact_rel_size
;
2703 /* Look up an entry in a MIPS ELF linker hash table. */
2705 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
2706 ((struct mips_elf_link_hash_entry *) \
2707 elf_link_hash_lookup (&(table)->root, (string), (create), \
2710 /* Traverse a MIPS ELF linker hash table. */
2712 #define mips_elf_link_hash_traverse(table, func, info) \
2713 (elf_link_hash_traverse \
2715 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
2718 /* Get the MIPS ELF linker hash table from a link_info structure. */
2720 #define mips_elf_hash_table(p) \
2721 ((struct mips_elf_link_hash_table *) ((p)->hash))
2723 static boolean mips_elf_output_extsym
2724 PARAMS ((struct mips_elf_link_hash_entry
*, PTR
));
2726 /* Create an entry in a MIPS ELF linker hash table. */
2728 static struct bfd_hash_entry
*
2729 mips_elf_link_hash_newfunc (entry
, table
, string
)
2730 struct bfd_hash_entry
*entry
;
2731 struct bfd_hash_table
*table
;
2734 struct mips_elf_link_hash_entry
*ret
=
2735 (struct mips_elf_link_hash_entry
*) entry
;
2737 /* Allocate the structure if it has not already been allocated by a
2739 if (ret
== (struct mips_elf_link_hash_entry
*) NULL
)
2740 ret
= ((struct mips_elf_link_hash_entry
*)
2741 bfd_hash_allocate (table
,
2742 sizeof (struct mips_elf_link_hash_entry
)));
2743 if (ret
== (struct mips_elf_link_hash_entry
*) NULL
)
2744 return (struct bfd_hash_entry
*) ret
;
2746 /* Call the allocation method of the superclass. */
2747 ret
= ((struct mips_elf_link_hash_entry
*)
2748 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
2750 if (ret
!= (struct mips_elf_link_hash_entry
*) NULL
)
2752 /* Set local fields. */
2753 memset (&ret
->esym
, 0, sizeof (EXTR
));
2754 /* We use -2 as a marker to indicate that the information has
2755 not been set. -1 means there is no associated ifd. */
2757 ret
->mips_32_relocs
= 0;
2760 return (struct bfd_hash_entry
*) ret
;
2763 /* Create a MIPS ELF linker hash table. */
2765 static struct bfd_link_hash_table
*
2766 mips_elf_link_hash_table_create (abfd
)
2769 struct mips_elf_link_hash_table
*ret
;
2772 ret
= ((struct mips_elf_link_hash_table
*)
2773 bfd_alloc (abfd
, sizeof (struct mips_elf_link_hash_table
)));
2774 if (ret
== (struct mips_elf_link_hash_table
*) NULL
)
2777 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
2778 mips_elf_link_hash_newfunc
))
2780 bfd_release (abfd
, ret
);
2784 for (i
= 0; i
< SIZEOF_MIPS_DYNSYM_SECNAMES
; i
++)
2785 ret
->dynsym_sec_strindex
[i
] = (bfd_size_type
) -1;
2786 ret
->procedure_count
= 0;
2787 ret
->compact_rel_size
= 0;
2789 return &ret
->root
.root
;
2792 /* Hook called by the linker routine which adds symbols from an object
2793 file. We must handle the special MIPS section numbers here. */
2797 mips_elf_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
, secp
, valp
)
2799 struct bfd_link_info
*info
;
2800 const Elf_Internal_Sym
*sym
;
2806 if (SGI_COMPAT (abfd
)
2807 && (abfd
->flags
& DYNAMIC
) != 0
2808 && strcmp (*namep
, "_rld_new_interface") == 0)
2810 /* Skip Irix 5 rld entry name. */
2815 switch (sym
->st_shndx
)
2818 /* Common symbols less than the GP size are automatically
2819 treated as SHN_MIPS_SCOMMON symbols. */
2820 if (sym
->st_size
> elf_gp_size (abfd
))
2823 case SHN_MIPS_SCOMMON
:
2824 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
2825 (*secp
)->flags
|= SEC_IS_COMMON
;
2826 *valp
= sym
->st_size
;
2830 /* This section is used in a shared object. */
2831 if (mips_elf_text_section_ptr
== NULL
)
2833 /* Initialize the section. */
2834 mips_elf_text_section
.name
= ".text";
2835 mips_elf_text_section
.flags
= SEC_NO_FLAGS
;
2836 mips_elf_text_section
.output_section
= NULL
;
2837 mips_elf_text_section
.owner
= abfd
;
2838 mips_elf_text_section
.symbol
= &mips_elf_text_symbol
;
2839 mips_elf_text_section
.symbol_ptr_ptr
= &mips_elf_text_symbol_ptr
;
2840 mips_elf_text_symbol
.name
= ".text";
2841 mips_elf_text_symbol
.flags
= BSF_SECTION_SYM
;
2842 mips_elf_text_symbol
.section
= &mips_elf_text_section
;
2843 mips_elf_text_symbol_ptr
= &mips_elf_text_symbol
;
2844 mips_elf_text_section_ptr
= &mips_elf_text_section
;
2847 *secp
= bfd_und_section_ptr
;
2849 *secp
= mips_elf_text_section_ptr
;
2852 case SHN_MIPS_ACOMMON
:
2853 /* Fall through. XXX Can we treat this as allocated data? */
2855 /* This section is used in a shared object. */
2856 if (mips_elf_data_section_ptr
== NULL
)
2858 /* Initialize the section. */
2859 mips_elf_data_section
.name
= ".data";
2860 mips_elf_data_section
.flags
= SEC_NO_FLAGS
;
2861 mips_elf_data_section
.output_section
= NULL
;
2862 mips_elf_data_section
.owner
= abfd
;
2863 mips_elf_data_section
.symbol
= &mips_elf_data_symbol
;
2864 mips_elf_data_section
.symbol_ptr_ptr
= &mips_elf_data_symbol_ptr
;
2865 mips_elf_data_symbol
.name
= ".data";
2866 mips_elf_data_symbol
.flags
= BSF_SECTION_SYM
;
2867 mips_elf_data_symbol
.section
= &mips_elf_data_section
;
2868 mips_elf_data_symbol_ptr
= &mips_elf_data_symbol
;
2869 mips_elf_data_section_ptr
= &mips_elf_data_section
;
2872 *secp
= bfd_und_section_ptr
;
2874 *secp
= mips_elf_data_section_ptr
;
2877 case SHN_MIPS_SUNDEFINED
:
2878 *secp
= bfd_und_section_ptr
;
2885 /* Structure used to pass information to mips_elf_output_extsym. */
2890 struct bfd_link_info
*info
;
2891 struct ecoff_debug_info
*debug
;
2892 const struct ecoff_debug_swap
*swap
;
2896 /* This routine is used to write out ECOFF debugging external symbol
2897 information. It is called via mips_elf_link_hash_traverse. The
2898 ECOFF external symbol information must match the ELF external
2899 symbol information. Unfortunately, at this point we don't know
2900 whether a symbol is required by reloc information, so the two
2901 tables may wind up being different. We must sort out the external
2902 symbol information before we can set the final size of the .mdebug
2903 section, and we must set the size of the .mdebug section before we
2904 can relocate any sections, and we can't know which symbols are
2905 required by relocation until we relocate the sections.
2906 Fortunately, it is relatively unlikely that any symbol will be
2907 stripped but required by a reloc. In particular, it can not happen
2908 when generating a final executable. */
2911 mips_elf_output_extsym (h
, data
)
2912 struct mips_elf_link_hash_entry
*h
;
2915 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
2917 asection
*sec
, *output_section
;
2919 if (h
->root
.indx
== -2)
2921 else if (((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2922 || (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
2923 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2924 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2926 else if (einfo
->info
->strip
== strip_all
2927 || (einfo
->info
->strip
== strip_some
2928 && bfd_hash_lookup (einfo
->info
->keep_hash
,
2929 h
->root
.root
.root
.string
,
2930 false, false) == NULL
))
2938 if (h
->esym
.ifd
== -2)
2941 h
->esym
.cobol_main
= 0;
2942 h
->esym
.weakext
= 0;
2943 h
->esym
.reserved
= 0;
2944 h
->esym
.ifd
= ifdNil
;
2945 h
->esym
.asym
.value
= 0;
2946 h
->esym
.asym
.st
= stGlobal
;
2948 if (SGI_COMPAT (einfo
->abfd
)
2949 && (h
->root
.root
.type
== bfd_link_hash_undefined
2950 || h
->root
.root
.type
== bfd_link_hash_undefweak
))
2954 /* Use undefined class. Also, set class and type for some
2956 name
= h
->root
.root
.root
.string
;
2957 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
2958 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
2960 h
->esym
.asym
.sc
= scData
;
2961 h
->esym
.asym
.st
= stLabel
;
2962 h
->esym
.asym
.value
= 0;
2964 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
2966 h
->esym
.asym
.sc
= scAbs
;
2967 h
->esym
.asym
.st
= stLabel
;
2968 h
->esym
.asym
.value
=
2969 mips_elf_hash_table (einfo
->info
)->procedure_count
;
2971 else if (strcmp (name
, "_gp_disp") == 0)
2973 h
->esym
.asym
.sc
= scAbs
;
2974 h
->esym
.asym
.st
= stLabel
;
2975 h
->esym
.asym
.value
= elf_gp (einfo
->abfd
);
2978 h
->esym
.asym
.sc
= scUndefined
;
2980 else if (h
->root
.root
.type
!= bfd_link_hash_defined
2981 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
2982 h
->esym
.asym
.sc
= scAbs
;
2987 sec
= h
->root
.root
.u
.def
.section
;
2988 output_section
= sec
->output_section
;
2990 /* When making a shared library and symbol h is the one from
2991 the another shared library, OUTPUT_SECTION may be null. */
2992 if (output_section
== NULL
)
2993 h
->esym
.asym
.sc
= scUndefined
;
2996 name
= bfd_section_name (output_section
->owner
, output_section
);
2998 if (strcmp (name
, ".text") == 0)
2999 h
->esym
.asym
.sc
= scText
;
3000 else if (strcmp (name
, ".data") == 0)
3001 h
->esym
.asym
.sc
= scData
;
3002 else if (strcmp (name
, ".sdata") == 0)
3003 h
->esym
.asym
.sc
= scSData
;
3004 else if (strcmp (name
, ".rodata") == 0
3005 || strcmp (name
, ".rdata") == 0)
3006 h
->esym
.asym
.sc
= scRData
;
3007 else if (strcmp (name
, ".bss") == 0)
3008 h
->esym
.asym
.sc
= scBss
;
3009 else if (strcmp (name
, ".sbss") == 0)
3010 h
->esym
.asym
.sc
= scSBss
;
3011 else if (strcmp (name
, ".init") == 0)
3012 h
->esym
.asym
.sc
= scInit
;
3013 else if (strcmp (name
, ".fini") == 0)
3014 h
->esym
.asym
.sc
= scFini
;
3016 h
->esym
.asym
.sc
= scAbs
;
3020 h
->esym
.asym
.reserved
= 0;
3021 h
->esym
.asym
.index
= indexNil
;
3024 if (h
->root
.root
.type
== bfd_link_hash_common
)
3025 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
3026 else if (h
->root
.root
.type
== bfd_link_hash_defined
3027 || h
->root
.root
.type
== bfd_link_hash_defweak
)
3029 if (h
->esym
.asym
.sc
== scCommon
)
3030 h
->esym
.asym
.sc
= scBss
;
3031 else if (h
->esym
.asym
.sc
== scSCommon
)
3032 h
->esym
.asym
.sc
= scSBss
;
3034 sec
= h
->root
.root
.u
.def
.section
;
3035 output_section
= sec
->output_section
;
3036 if (output_section
!= NULL
)
3037 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
3038 + sec
->output_offset
3039 + output_section
->vma
);
3041 h
->esym
.asym
.value
= 0;
3043 else if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
3045 /* Set type and value for a symbol with a function stub. */
3046 h
->esym
.asym
.st
= stProc
;
3047 sec
= h
->root
.root
.u
.def
.section
;
3049 h
->esym
.asym
.value
= 0;
3052 output_section
= sec
->output_section
;
3053 if (output_section
!= NULL
)
3054 h
->esym
.asym
.value
= (h
->root
.plt_offset
3055 + sec
->output_offset
3056 + output_section
->vma
);
3058 h
->esym
.asym
.value
= 0;
3065 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
3066 h
->root
.root
.root
.string
,
3069 einfo
->failed
= true;
3076 /* Create a runtime procedure table from the .mdebug section. */
3079 mips_elf_create_procedure_table (handle
, abfd
, info
, s
, debug
)
3082 struct bfd_link_info
*info
;
3084 struct ecoff_debug_info
*debug
;
3086 const struct ecoff_debug_swap
*swap
;
3087 HDRR
*hdr
= &debug
->symbolic_header
;
3089 struct rpdr_ext
*erp
;
3091 struct pdr_ext
*epdr
;
3092 struct sym_ext
*esym
;
3095 unsigned long size
, count
;
3096 unsigned long sindex
;
3100 const char *no_name_func
= "static procedure (no name)";
3108 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
3110 sindex
= strlen (no_name_func
) + 1;
3111 count
= hdr
->ipdMax
;
3114 size
= swap
->external_pdr_size
;
3116 epdr
= (struct pdr_ext
*) bfd_malloc (size
* count
);
3120 if (! _bfd_ecoff_get_accumulated_pdr (handle
, (PTR
) epdr
))
3123 size
= sizeof (RPDR
);
3124 rp
= rpdr
= (RPDR
*) bfd_malloc (size
* count
);
3128 sv
= (char **) bfd_malloc (sizeof (char *) * count
);
3132 count
= hdr
->isymMax
;
3133 size
= swap
->external_sym_size
;
3134 esym
= (struct sym_ext
*) bfd_malloc (size
* count
);
3138 if (! _bfd_ecoff_get_accumulated_sym (handle
, (PTR
) esym
))
3141 count
= hdr
->issMax
;
3142 ss
= (char *) bfd_malloc (count
);
3145 if (! _bfd_ecoff_get_accumulated_ss (handle
, (PTR
) ss
))
3148 count
= hdr
->ipdMax
;
3149 for (i
= 0; i
< count
; i
++, rp
++)
3151 (*swap
->swap_pdr_in
) (abfd
, (PTR
) (epdr
+ i
), &pdr
);
3152 (*swap
->swap_sym_in
) (abfd
, (PTR
) &esym
[pdr
.isym
], &sym
);
3153 rp
->adr
= sym
.value
;
3154 rp
->regmask
= pdr
.regmask
;
3155 rp
->regoffset
= pdr
.regoffset
;
3156 rp
->fregmask
= pdr
.fregmask
;
3157 rp
->fregoffset
= pdr
.fregoffset
;
3158 rp
->frameoffset
= pdr
.frameoffset
;
3159 rp
->framereg
= pdr
.framereg
;
3160 rp
->pcreg
= pdr
.pcreg
;
3162 sv
[i
] = ss
+ sym
.iss
;
3163 sindex
+= strlen (sv
[i
]) + 1;
3167 size
= sizeof (struct rpdr_ext
) * (count
+ 2) + sindex
;
3168 size
= BFD_ALIGN (size
, 16);
3169 rtproc
= (PTR
) bfd_alloc (abfd
, size
);
3172 mips_elf_hash_table (info
)->procedure_count
= 0;
3176 mips_elf_hash_table (info
)->procedure_count
= count
+ 2;
3178 erp
= (struct rpdr_ext
*) rtproc
;
3179 memset (erp
, 0, sizeof (struct rpdr_ext
));
3181 str
= (char *) rtproc
+ sizeof (struct rpdr_ext
) * (count
+ 2);
3182 strcpy (str
, no_name_func
);
3183 str
+= strlen (no_name_func
) + 1;
3184 for (i
= 0; i
< count
; i
++)
3186 ecoff_swap_rpdr_out (abfd
, rpdr
+ i
, erp
+ i
);
3187 strcpy (str
, sv
[i
]);
3188 str
+= strlen (sv
[i
]) + 1;
3190 ecoff_put_off (abfd
, (bfd_vma
) -1, (bfd_byte
*) (erp
+ count
)->p_adr
);
3192 /* Set the size and contents of .rtproc section. */
3193 s
->_raw_size
= size
;
3194 s
->contents
= rtproc
;
3196 /* Skip this section later on (I don't think this currently
3197 matters, but someday it might). */
3198 s
->link_order_head
= (struct bfd_link_order
*) NULL
;
3227 /* A comparison routine used to sort .gptab entries. */
3230 gptab_compare (p1
, p2
)
3234 const Elf32_gptab
*a1
= (const Elf32_gptab
*) p1
;
3235 const Elf32_gptab
*a2
= (const Elf32_gptab
*) p2
;
3237 return a1
->gt_entry
.gt_g_value
- a2
->gt_entry
.gt_g_value
;
3240 /* We need to use a special link routine to handle the .reginfo and
3241 the .mdebug sections. We need to merge all instances of these
3242 sections together, not write them all out sequentially. */
3245 mips_elf_final_link (abfd
, info
)
3247 struct bfd_link_info
*info
;
3251 struct bfd_link_order
*p
;
3252 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
3253 asection
*rtproc_sec
;
3254 Elf32_RegInfo reginfo
;
3255 struct ecoff_debug_info debug
;
3256 const struct ecoff_debug_swap
*swap
3257 = get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
3258 HDRR
*symhdr
= &debug
.symbolic_header
;
3259 PTR mdebug_handle
= NULL
;
3261 /* Drop the .options section, since it has special semantics which I
3262 haven't bothered to figure out. */
3263 for (secpp
= &abfd
->sections
; *secpp
!= NULL
; secpp
= &(*secpp
)->next
)
3265 if (strcmp ((*secpp
)->name
, ".options") == 0)
3267 for (p
= (*secpp
)->link_order_head
; p
!= NULL
; p
= p
->next
)
3268 if (p
->type
== bfd_indirect_link_order
)
3269 p
->u
.indirect
.section
->flags
&=~ SEC_HAS_CONTENTS
;
3270 (*secpp
)->link_order_head
= NULL
;
3271 *secpp
= (*secpp
)->next
;
3272 --abfd
->section_count
;
3277 /* Get a value for the GP register. */
3278 if (elf_gp (abfd
) == 0)
3280 struct bfd_link_hash_entry
*h
;
3282 h
= bfd_link_hash_lookup (info
->hash
, "_gp", false, false, true);
3283 if (h
!= (struct bfd_link_hash_entry
*) NULL
3284 && h
->type
== bfd_link_hash_defined
)
3285 elf_gp (abfd
) = (h
->u
.def
.value
3286 + h
->u
.def
.section
->output_section
->vma
3287 + h
->u
.def
.section
->output_offset
);
3288 else if (info
->relocateable
)
3292 /* Make up a value. */
3294 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
3297 && (strcmp (o
->name
, ".sbss") == 0
3298 || strcmp (o
->name
, ".sdata") == 0
3299 || strcmp (o
->name
, ".lit4") == 0
3300 || strcmp (o
->name
, ".lit8") == 0))
3303 elf_gp (abfd
) = lo
+ ELF_MIPS_GP_OFFSET (abfd
);
3307 /* If the relocate_section function needs to do a reloc
3308 involving the GP value, it should make a reloc_dangerous
3309 callback to warn that GP is not defined. */
3313 /* Go through the sections and collect the .reginfo and .mdebug
3317 gptab_data_sec
= NULL
;
3318 gptab_bss_sec
= NULL
;
3319 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
3321 if (strcmp (o
->name
, ".reginfo") == 0)
3323 memset (®info
, 0, sizeof reginfo
);
3325 /* We have found the .reginfo section in the output file.
3326 Look through all the link_orders comprising it and merge
3327 the information together. */
3328 for (p
= o
->link_order_head
;
3329 p
!= (struct bfd_link_order
*) NULL
;
3332 asection
*input_section
;
3334 Elf32_External_RegInfo ext
;
3337 if (p
->type
!= bfd_indirect_link_order
)
3339 if (p
->type
== bfd_fill_link_order
)
3344 input_section
= p
->u
.indirect
.section
;
3345 input_bfd
= input_section
->owner
;
3347 /* The linker emulation code has probably clobbered the
3348 size to be zero bytes. */
3349 if (input_section
->_raw_size
== 0)
3350 input_section
->_raw_size
= sizeof (Elf32_External_RegInfo
);
3352 if (! bfd_get_section_contents (input_bfd
, input_section
,
3358 bfd_mips_elf32_swap_reginfo_in (input_bfd
, &ext
, &sub
);
3360 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
3361 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
3362 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
3363 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
3364 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
3366 /* ri_gp_value is set by the function
3367 mips_elf32_section_processing when the section is
3368 finally written out. */
3370 /* Hack: reset the SEC_HAS_CONTENTS flag so that
3371 elf_link_input_bfd ignores this section. */
3372 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
3375 /* Force the section size to the value we want. */
3376 o
->_raw_size
= sizeof (Elf32_External_RegInfo
);
3378 /* Skip this section later on (I don't think this currently
3379 matters, but someday it might). */
3380 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
3385 if (strcmp (o
->name
, ".mdebug") == 0)
3387 struct extsym_info einfo
;
3389 /* We have found the .mdebug section in the output file.
3390 Look through all the link_orders comprising it and merge
3391 the information together. */
3392 symhdr
->magic
= swap
->sym_magic
;
3393 /* FIXME: What should the version stamp be? */
3395 symhdr
->ilineMax
= 0;
3399 symhdr
->isymMax
= 0;
3400 symhdr
->ioptMax
= 0;
3401 symhdr
->iauxMax
= 0;
3403 symhdr
->issExtMax
= 0;
3406 symhdr
->iextMax
= 0;
3408 /* We accumulate the debugging information itself in the
3409 debug_info structure. */
3411 debug
.external_dnr
= NULL
;
3412 debug
.external_pdr
= NULL
;
3413 debug
.external_sym
= NULL
;
3414 debug
.external_opt
= NULL
;
3415 debug
.external_aux
= NULL
;
3417 debug
.ssext
= debug
.ssext_end
= NULL
;
3418 debug
.external_fdr
= NULL
;
3419 debug
.external_rfd
= NULL
;
3420 debug
.external_ext
= debug
.external_ext_end
= NULL
;
3422 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
3423 if (mdebug_handle
== (PTR
) NULL
)
3426 if (SGI_COMPAT (abfd
))
3432 static const char * const name
[] =
3433 { ".text", ".init", ".fini", ".data",
3434 ".rodata", ".sdata", ".sbss", ".bss" };
3435 static const int sc
[] = { scText
, scInit
, scFini
, scData
,
3436 scRData
, scSData
, scSBss
, scBss
};
3439 esym
.cobol_main
= 0;
3443 esym
.asym
.iss
= issNil
;
3444 esym
.asym
.st
= stLocal
;
3445 esym
.asym
.reserved
= 0;
3446 esym
.asym
.index
= indexNil
;
3447 for (i
= 0; i
< 8; i
++)
3449 esym
.asym
.sc
= sc
[i
];
3450 s
= bfd_get_section_by_name (abfd
, name
[i
]);
3453 esym
.asym
.value
= s
->vma
;
3454 last
= s
->vma
+ s
->_raw_size
;
3457 esym
.asym
.value
= last
;
3459 if (! bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
3465 for (p
= o
->link_order_head
;
3466 p
!= (struct bfd_link_order
*) NULL
;
3469 asection
*input_section
;
3471 const struct ecoff_debug_swap
*input_swap
;
3472 struct ecoff_debug_info input_debug
;
3476 if (p
->type
!= bfd_indirect_link_order
)
3478 if (p
->type
== bfd_fill_link_order
)
3483 input_section
= p
->u
.indirect
.section
;
3484 input_bfd
= input_section
->owner
;
3486 if (bfd_get_flavour (input_bfd
) != bfd_target_elf_flavour
3487 || (get_elf_backend_data (input_bfd
)
3488 ->elf_backend_ecoff_debug_swap
) == NULL
)
3490 /* I don't know what a non MIPS ELF bfd would be
3491 doing with a .mdebug section, but I don't really
3492 want to deal with it. */
3496 input_swap
= (get_elf_backend_data (input_bfd
)
3497 ->elf_backend_ecoff_debug_swap
);
3499 BFD_ASSERT (p
->size
== input_section
->_raw_size
);
3501 /* The ECOFF linking code expects that we have already
3502 read in the debugging information and set up an
3503 ecoff_debug_info structure, so we do that now. */
3504 if (! _bfd_mips_elf_read_ecoff_info (input_bfd
, input_section
,
3508 if (! (bfd_ecoff_debug_accumulate
3509 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
3510 &input_debug
, input_swap
, info
)))
3513 /* Loop through the external symbols. For each one with
3514 interesting information, try to find the symbol in
3515 the linker global hash table and save the information
3516 for the output external symbols. */
3517 eraw_src
= input_debug
.external_ext
;
3518 eraw_end
= (eraw_src
3519 + (input_debug
.symbolic_header
.iextMax
3520 * input_swap
->external_ext_size
));
3522 eraw_src
< eraw_end
;
3523 eraw_src
+= input_swap
->external_ext_size
)
3527 struct mips_elf_link_hash_entry
*h
;
3529 (*input_swap
->swap_ext_in
) (input_bfd
, (PTR
) eraw_src
, &ext
);
3530 if (ext
.asym
.sc
== scNil
3531 || ext
.asym
.sc
== scUndefined
3532 || ext
.asym
.sc
== scSUndefined
)
3535 name
= input_debug
.ssext
+ ext
.asym
.iss
;
3536 h
= mips_elf_link_hash_lookup (mips_elf_hash_table (info
),
3537 name
, false, false, true);
3538 if (h
== NULL
|| h
->esym
.ifd
!= -2)
3544 < input_debug
.symbolic_header
.ifdMax
);
3545 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
3551 /* Free up the information we just read. */
3552 free (input_debug
.line
);
3553 free (input_debug
.external_dnr
);
3554 free (input_debug
.external_pdr
);
3555 free (input_debug
.external_sym
);
3556 free (input_debug
.external_opt
);
3557 free (input_debug
.external_aux
);
3558 free (input_debug
.ss
);
3559 free (input_debug
.ssext
);
3560 free (input_debug
.external_fdr
);
3561 free (input_debug
.external_rfd
);
3562 free (input_debug
.external_ext
);
3564 /* Hack: reset the SEC_HAS_CONTENTS flag so that
3565 elf_link_input_bfd ignores this section. */
3566 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
3569 if (SGI_COMPAT (abfd
) && info
->shared
)
3571 /* Create .rtproc section. */
3572 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
3573 if (rtproc_sec
== NULL
)
3575 flagword flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3578 rtproc_sec
= bfd_make_section (abfd
, ".rtproc");
3579 if (rtproc_sec
== NULL
3580 || ! bfd_set_section_flags (abfd
, rtproc_sec
, flags
)
3581 || ! bfd_set_section_alignment (abfd
, rtproc_sec
, 12))
3585 if (! mips_elf_create_procedure_table (mdebug_handle
, abfd
,
3586 info
, rtproc_sec
, &debug
))
3590 /* Build the external symbol information. */
3593 einfo
.debug
= &debug
;
3595 einfo
.failed
= false;
3596 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
3597 mips_elf_output_extsym
,
3602 /* Set the size of the .mdebug section. */
3603 o
->_raw_size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
3605 /* Skip this section later on (I don't think this currently
3606 matters, but someday it might). */
3607 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
3612 if (strncmp (o
->name
, ".gptab.", sizeof ".gptab." - 1) == 0)
3614 const char *subname
;
3617 Elf32_External_gptab
*ext_tab
;
3620 /* The .gptab.sdata and .gptab.sbss sections hold
3621 information describing how the small data area would
3622 change depending upon the -G switch. These sections
3623 not used in executables files. */
3624 if (! info
->relocateable
)
3628 for (p
= o
->link_order_head
;
3629 p
!= (struct bfd_link_order
*) NULL
;
3632 asection
*input_section
;
3634 if (p
->type
!= bfd_indirect_link_order
)
3636 if (p
->type
== bfd_fill_link_order
)
3641 input_section
= p
->u
.indirect
.section
;
3643 /* Hack: reset the SEC_HAS_CONTENTS flag so that
3644 elf_link_input_bfd ignores this section. */
3645 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
3648 /* Skip this section later on (I don't think this
3649 currently matters, but someday it might). */
3650 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
3652 /* Really remove the section. */
3653 for (secpp
= &abfd
->sections
;
3655 secpp
= &(*secpp
)->next
)
3657 *secpp
= (*secpp
)->next
;
3658 --abfd
->section_count
;
3663 /* There is one gptab for initialized data, and one for
3664 uninitialized data. */
3665 if (strcmp (o
->name
, ".gptab.sdata") == 0)
3667 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
3671 (*_bfd_error_handler
)
3672 ("%s: illegal section name `%s'",
3673 bfd_get_filename (abfd
), o
->name
);
3674 bfd_set_error (bfd_error_nonrepresentable_section
);
3678 /* The linker script always combines .gptab.data and
3679 .gptab.sdata into .gptab.sdata, and likewise for
3680 .gptab.bss and .gptab.sbss. It is possible that there is
3681 no .sdata or .sbss section in the output file, in which
3682 case we must change the name of the output section. */
3683 subname
= o
->name
+ sizeof ".gptab" - 1;
3684 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
3686 if (o
== gptab_data_sec
)
3687 o
->name
= ".gptab.data";
3689 o
->name
= ".gptab.bss";
3690 subname
= o
->name
+ sizeof ".gptab" - 1;
3691 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
3694 /* Set up the first entry. */
3696 tab
= (Elf32_gptab
*) bfd_malloc (c
* sizeof (Elf32_gptab
));
3699 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
3700 tab
[0].gt_header
.gt_unused
= 0;
3702 /* Combine the input sections. */
3703 for (p
= o
->link_order_head
;
3704 p
!= (struct bfd_link_order
*) NULL
;
3707 asection
*input_section
;
3711 bfd_size_type gpentry
;
3713 if (p
->type
!= bfd_indirect_link_order
)
3715 if (p
->type
== bfd_fill_link_order
)
3720 input_section
= p
->u
.indirect
.section
;
3721 input_bfd
= input_section
->owner
;
3723 /* Combine the gptab entries for this input section one
3724 by one. We know that the input gptab entries are
3725 sorted by ascending -G value. */
3726 size
= bfd_section_size (input_bfd
, input_section
);
3728 for (gpentry
= sizeof (Elf32_External_gptab
);
3730 gpentry
+= sizeof (Elf32_External_gptab
))
3732 Elf32_External_gptab ext_gptab
;
3733 Elf32_gptab int_gptab
;
3739 if (! (bfd_get_section_contents
3740 (input_bfd
, input_section
, (PTR
) &ext_gptab
,
3741 gpentry
, sizeof (Elf32_External_gptab
))))
3747 bfd_mips_elf32_swap_gptab_in (input_bfd
, &ext_gptab
,
3749 val
= int_gptab
.gt_entry
.gt_g_value
;
3750 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
3753 for (look
= 1; look
< c
; look
++)
3755 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
3756 tab
[look
].gt_entry
.gt_bytes
+= add
;
3758 if (tab
[look
].gt_entry
.gt_g_value
== val
)
3764 Elf32_gptab
*new_tab
;
3767 /* We need a new table entry. */
3768 new_tab
= ((Elf32_gptab
*)
3769 bfd_realloc ((PTR
) tab
,
3770 (c
+ 1) * sizeof (Elf32_gptab
)));
3771 if (new_tab
== NULL
)
3777 tab
[c
].gt_entry
.gt_g_value
= val
;
3778 tab
[c
].gt_entry
.gt_bytes
= add
;
3780 /* Merge in the size for the next smallest -G
3781 value, since that will be implied by this new
3784 for (look
= 1; look
< c
; look
++)
3786 if (tab
[look
].gt_entry
.gt_g_value
< val
3788 || (tab
[look
].gt_entry
.gt_g_value
3789 > tab
[max
].gt_entry
.gt_g_value
)))
3793 tab
[c
].gt_entry
.gt_bytes
+=
3794 tab
[max
].gt_entry
.gt_bytes
;
3799 last
= int_gptab
.gt_entry
.gt_bytes
;
3802 /* Hack: reset the SEC_HAS_CONTENTS flag so that
3803 elf_link_input_bfd ignores this section. */
3804 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
3807 /* The table must be sorted by -G value. */
3809 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
3811 /* Swap out the table. */
3812 ext_tab
= ((Elf32_External_gptab
*)
3813 bfd_alloc (abfd
, c
* sizeof (Elf32_External_gptab
)));
3814 if (ext_tab
== NULL
)
3820 for (i
= 0; i
< c
; i
++)
3821 bfd_mips_elf32_swap_gptab_out (abfd
, tab
+ i
, ext_tab
+ i
);
3824 o
->_raw_size
= c
* sizeof (Elf32_External_gptab
);
3825 o
->contents
= (bfd_byte
*) ext_tab
;
3827 /* Skip this section later on (I don't think this currently
3828 matters, but someday it might). */
3829 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
3833 /* Invoke the regular ELF backend linker to do all the work. */
3834 if (! bfd_elf32_bfd_final_link (abfd
, info
))
3837 /* Now write out the computed sections. */
3839 if (reginfo_sec
!= (asection
*) NULL
)
3841 Elf32_External_RegInfo ext
;
3843 bfd_mips_elf32_swap_reginfo_out (abfd
, ®info
, &ext
);
3844 if (! bfd_set_section_contents (abfd
, reginfo_sec
, (PTR
) &ext
,
3845 (file_ptr
) 0, sizeof ext
))
3849 if (mdebug_sec
!= (asection
*) NULL
)
3851 BFD_ASSERT (abfd
->output_has_begun
);
3852 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
3854 mdebug_sec
->filepos
))
3857 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
3860 if (gptab_data_sec
!= (asection
*) NULL
)
3862 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
3863 gptab_data_sec
->contents
,
3865 gptab_data_sec
->_raw_size
))
3869 if (gptab_bss_sec
!= (asection
*) NULL
)
3871 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
3872 gptab_bss_sec
->contents
,
3874 gptab_bss_sec
->_raw_size
))
3878 if (SGI_COMPAT (abfd
))
3880 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
3881 if (rtproc_sec
!= NULL
)
3883 if (! bfd_set_section_contents (abfd
, rtproc_sec
,
3884 rtproc_sec
->contents
,
3886 rtproc_sec
->_raw_size
))
3894 /* Handle a MIPS ELF HI16 reloc. */
3897 mips_elf_relocate_hi16 (input_bfd
, relhi
, rello
, contents
, addend
)
3899 Elf_Internal_Rela
*relhi
;
3900 Elf_Internal_Rela
*rello
;
3907 insn
= bfd_get_32 (input_bfd
, contents
+ relhi
->r_offset
);
3909 addlo
= bfd_get_32 (input_bfd
, contents
+ rello
->r_offset
);
3912 addend
+= ((insn
& 0xffff) << 16) + addlo
;
3914 if ((addlo
& 0x8000) != 0)
3916 if ((addend
& 0x8000) != 0)
3919 bfd_put_32 (input_bfd
,
3920 (insn
& 0xffff0000) | ((addend
>> 16) & 0xffff),
3921 contents
+ relhi
->r_offset
);
3924 /* Handle a MIPS ELF local GOT16 reloc. */
3927 mips_elf_relocate_got_local (output_bfd
, input_bfd
, sgot
, relhi
, rello
,
3932 Elf_Internal_Rela
*relhi
;
3933 Elf_Internal_Rela
*rello
;
3943 bfd_byte
*got_contents
;
3944 struct mips_got_info
*g
;
3946 insn
= bfd_get_32 (input_bfd
, contents
+ relhi
->r_offset
);
3948 addlo
= bfd_get_32 (input_bfd
, contents
+ rello
->r_offset
);
3951 addend
+= ((insn
& 0xffff) << 16) + addlo
;
3953 if ((addlo
& 0x8000) != 0)
3955 if ((addend
& 0x8000) != 0)
3958 /* Get a got entry representing requested hipage. */
3959 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
3960 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
3961 BFD_ASSERT (g
!= NULL
);
3963 local_gotno
= g
->local_gotno
;
3964 got_contents
= sgot
->contents
;
3965 hipage
= addend
& 0xffff0000;
3967 for (i
= MIPS_RESERVED_GOTNO
; i
< local_gotno
; i
++)
3969 address
= bfd_get_32 (input_bfd
, got_contents
+ i
* 4);
3970 if (hipage
== (address
& 0xffff0000))
3972 if (address
== (bfd_vma
) 0)
3974 bfd_put_32 (input_bfd
, hipage
, got_contents
+ i
* 4);
3979 BFD_ASSERT (i
< local_gotno
);
3981 if (i
== local_gotno
)
3982 (*_bfd_error_handler
)
3983 ("ELF MIPS linker: more got entries are needed for hipage: %x",
3987 i
= - ELF_MIPS_GP_OFFSET (output_bfd
) + i
* 4;
3988 bfd_put_32 (input_bfd
, (insn
& 0xffff0000) | (i
& 0xffff),
3989 contents
+ relhi
->r_offset
);
3992 /* Handle MIPS ELF CALL16 reloc and global GOT16 reloc. */
3995 mips_elf_relocate_global_got (input_bfd
, rel
, contents
, offset
)
3997 Elf_Internal_Rela
*rel
;
4003 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
4004 bfd_put_32 (input_bfd
,
4005 (insn
& 0xffff0000) | (offset
& 0xffff),
4006 contents
+ rel
->r_offset
);
4009 /* Relocate a MIPS ELF section. */
4012 mips_elf_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
4013 contents
, relocs
, local_syms
, local_sections
)
4015 struct bfd_link_info
*info
;
4017 asection
*input_section
;
4019 Elf_Internal_Rela
*relocs
;
4020 Elf_Internal_Sym
*local_syms
;
4021 asection
**local_sections
;
4023 Elf_Internal_Shdr
*symtab_hdr
;
4026 asection
*sgot
, *sreloc
, *scpt
;
4029 Elf_Internal_Rela
*rel
;
4030 Elf_Internal_Rela
*relend
;
4031 struct mips_got_info
*g
;
4033 dynobj
= elf_hash_table (info
)->dynobj
;
4034 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
4038 if (dynobj
== NULL
|| ! SGI_COMPAT (output_bfd
))
4041 scpt
= bfd_get_section_by_name (dynobj
, ".compact_rel");
4044 if (elf_bad_symtab (input_bfd
))
4046 locsymcount
= symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
4051 locsymcount
= symtab_hdr
->sh_info
;
4052 extsymoff
= symtab_hdr
->sh_info
;
4055 gp
= _bfd_get_gp_value (output_bfd
);
4058 relend
= relocs
+ input_section
->reloc_count
;
4059 for (; rel
< relend
; rel
++)
4062 reloc_howto_type
*howto
;
4063 unsigned long r_symndx
;
4065 struct elf_link_hash_entry
*h
;
4067 Elf_Internal_Sym
*sym
;
4068 bfd_reloc_status_type r
;
4070 r_type
= ELF32_R_TYPE (rel
->r_info
);
4071 if (r_type
< 0 || r_type
>= (int) R_MIPS_max
)
4073 bfd_set_error (bfd_error_bad_value
);
4076 howto
= elf_mips_howto_table
+ r_type
;
4079 && (r_type
== R_MIPS_CALL16
4080 || r_type
== R_MIPS_GOT16
4081 || r_type
== R_MIPS_CALL_HI16
4082 || r_type
== R_MIPS_CALL_LO16
4083 || r_type
== R_MIPS_GOT_HI16
4084 || r_type
== R_MIPS_GOT_LO16
))
4086 /* We need the .got section. */
4089 sgot
= bfd_get_section_by_name (dynobj
, ".got");
4090 BFD_ASSERT (sgot
!= NULL
);
4091 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
4092 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
4093 BFD_ASSERT (g
!= NULL
);
4097 r_symndx
= ELF32_R_SYM (rel
->r_info
);
4099 /* Mix in the change in GP address for a GP relative reloc. */
4100 if (r_type
!= R_MIPS_GPREL16
4101 && r_type
!= R_MIPS_LITERAL
4102 && r_type
!= R_MIPS_GPREL32
)
4108 if (! ((*info
->callbacks
->reloc_dangerous
)
4110 "GP relative relocation when GP not defined",
4111 input_bfd
, input_section
,
4114 /* Only give the error once per link. */
4116 _bfd_set_gp_value (output_bfd
, gp
);
4119 if (r_symndx
< extsymoff
4120 || (elf_bad_symtab (input_bfd
)
4121 && local_sections
[r_symndx
] != NULL
))
4123 /* This is a relocation against a section. The current
4124 addend in the instruction is the difference between
4125 INPUT_SECTION->vma and the GP value of INPUT_BFD. We
4126 must change this to be the difference between the
4127 final definition (which will end up in RELOCATION)
4128 and the GP value of OUTPUT_BFD (which is in GP). */
4129 addend
= elf_gp (input_bfd
) - gp
;
4131 else if (! info
->relocateable
)
4133 /* We are doing a final link. The current addend in the
4134 instruction is simply the desired offset into the
4135 symbol (normally zero). We want the instruction to
4136 hold the difference between the final definition of
4137 the symbol (which will end up in RELOCATION) and the
4138 GP value of OUTPUT_BFD (which is in GP). */
4143 /* We are generating relocateable output, and we aren't
4144 going to define this symbol, so we just leave the
4145 instruction alone. */
4153 if (info
->relocateable
)
4155 /* This is a relocateable link. We don't have to change
4156 anything, unless the reloc is against a section symbol,
4157 in which case we have to adjust according to where the
4158 section symbol winds up in the output section. */
4159 if (r_symndx
>= locsymcount
4160 || (elf_bad_symtab (input_bfd
)
4161 && local_sections
[r_symndx
] == NULL
))
4165 sym
= local_syms
+ r_symndx
;
4166 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4170 sec
= local_sections
[r_symndx
];
4172 /* It would be logical to add sym->st_value here,
4173 but Irix 5 sometimes generates a garbage symbol
4175 addend
+= sec
->output_offset
;
4177 /* If this is HI16 or GOT16 with an associated LO16,
4178 adjust the addend accordingly. Otherwise, just
4180 if (r_type
!= R_MIPS_HI16
&& r_type
!= R_MIPS_GOT16
)
4181 r
= _bfd_relocate_contents (howto
, input_bfd
,
4183 contents
+ rel
->r_offset
);
4186 Elf_Internal_Rela
*lorel
;
4188 /* As a GNU extension, permit an arbitrary
4189 number of R_MIPS_HI16 relocs before the
4190 R_MIPS_LO16 reloc. This permits gcc to emit
4191 the HI and LO relocs itself. */
4192 if (r_type
== R_MIPS_GOT16
)
4196 for (lorel
= rel
+ 1;
4198 && (ELF32_R_TYPE (lorel
->r_info
)
4204 && ELF32_R_TYPE (lorel
->r_info
) == R_MIPS_LO16
)
4206 mips_elf_relocate_hi16 (input_bfd
, rel
, lorel
,
4211 r
= _bfd_relocate_contents (howto
, input_bfd
,
4213 contents
+ rel
->r_offset
);
4223 /* This is a final link. */
4225 if (r_symndx
< extsymoff
4226 || (elf_bad_symtab (input_bfd
)
4227 && local_sections
[r_symndx
] != NULL
))
4230 sym
= local_syms
+ r_symndx
;
4231 sec
= local_sections
[r_symndx
];
4232 relocation
= (sec
->output_section
->vma
4233 + sec
->output_offset
);
4235 /* It would be logical to always add sym->st_value here,
4236 but Irix 5 sometimes generates a garbage symbol
4238 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
)
4239 relocation
+= sym
->st_value
;
4246 indx
= r_symndx
- extsymoff
;
4247 h
= elf_sym_hashes (input_bfd
)[indx
];
4248 while (h
->root
.type
== bfd_link_hash_indirect
4249 || h
->root
.type
== bfd_link_hash_warning
)
4250 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4251 if (strcmp (h
->root
.root
.string
, "_gp_disp") == 0)
4255 if (! ((*info
->callbacks
->reloc_dangerous
)
4257 "_gp_disp used when GP not defined",
4258 input_bfd
, input_section
,
4261 /* Only give the error once per link. */
4263 _bfd_set_gp_value (output_bfd
, gp
);
4268 sec
= input_section
;
4269 if (sec
->output_section
!= NULL
)
4272 + sec
->output_section
->vma
4273 + sec
->output_offset
));
4275 relocation
= gp
- rel
->r_offset
;
4276 if (r_type
== R_MIPS_LO16
)
4280 else if (h
->root
.type
== bfd_link_hash_defined
4281 || h
->root
.type
== bfd_link_hash_defweak
)
4283 sec
= h
->root
.u
.def
.section
;
4284 if (sec
->output_section
== NULL
)
4287 relocation
= (h
->root
.u
.def
.value
4288 + sec
->output_section
->vma
4289 + sec
->output_offset
);
4291 else if (h
->root
.type
== bfd_link_hash_undefweak
)
4293 else if (info
->shared
&& ! info
->symbolic
)
4295 else if (strcmp (h
->root
.root
.string
, "_DYNAMIC_LINK") == 0)
4297 /* If this is a dynamic link, we should have created
4298 a _DYNAMIC_LINK symbol in
4299 mips_elf_create_dynamic_sections. Otherwise, we
4300 should define the symbol with a value of 0.
4301 FIXME: It should probably get into the symbol
4302 table somehow as well. */
4303 BFD_ASSERT (! info
->shared
);
4304 BFD_ASSERT (bfd_get_section_by_name (output_bfd
,
4305 ".dynamic") == NULL
);
4310 if (! ((*info
->callbacks
->undefined_symbol
)
4311 (info
, h
->root
.root
.string
, input_bfd
,
4312 input_section
, rel
->r_offset
)))
4318 if (r_type
== R_MIPS_HI16
)
4320 Elf_Internal_Rela
*lorel
;
4322 /* As a GNU extension, permit an arbitrary number of
4323 R_MIPS_HI16 relocs before the R_MIPS_LO16 reloc.
4324 This permits gcc to emit the HI and LO relocs itself. */
4325 for (lorel
= rel
+ 1;
4327 && ELF32_R_TYPE (lorel
->r_info
) == R_MIPS_HI16
);
4331 && ELF32_R_TYPE (lorel
->r_info
) == R_MIPS_LO16
)
4333 mips_elf_relocate_hi16 (input_bfd
, rel
, lorel
,
4334 contents
, relocation
+ addend
);
4338 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4339 contents
, rel
->r_offset
,
4340 relocation
, addend
);
4342 else if (r_type
== R_MIPS_GOT16
&& local
)
4344 /* GOT16 must also have an associated LO16 in the local
4345 case. In this case, the addend is extracted and the
4346 section in which the referenced object is determined.
4347 Then the final address of the object is computed and
4348 the GOT entry for the hipage (an aligned 64kb chunk)
4349 is added to .got section if needed. The offset field
4350 of the GOT16-relocated instruction is replaced by the
4351 index of this GOT entry for the hipage. */
4352 if ((rel
+ 1) < relend
4353 && ELF32_R_TYPE ((rel
+ 1)->r_info
) == R_MIPS_LO16
)
4355 mips_elf_relocate_got_local (output_bfd
, input_bfd
, sgot
,
4358 relocation
+ addend
);
4362 r
= bfd_reloc_outofrange
;
4364 else if (r_type
== R_MIPS_CALL16
4365 || r_type
== R_MIPS_GOT16
4366 || r_type
== R_MIPS_CALL_LO16
4367 || r_type
== R_MIPS_GOT_LO16
)
4371 /* This symbol must be registered as a global symbol
4372 having the corresponding got entry. */
4373 BFD_ASSERT (h
->got_offset
!= (bfd_vma
) -1);
4375 offset
= (h
->dynindx
- g
->global_gotsym
+ g
->local_gotno
) * 4;
4376 BFD_ASSERT (g
->local_gotno
<= offset
4377 && offset
< sgot
->_raw_size
);
4378 bfd_put_32 (output_bfd
, relocation
+ addend
,
4379 sgot
->contents
+ offset
);
4380 offset
= (sgot
->output_section
->vma
+ sgot
->output_offset
4382 mips_elf_relocate_global_got (input_bfd
, rel
, contents
,
4386 else if (r_type
== R_MIPS_CALL_HI16
4387 || r_type
== R_MIPS_GOT_HI16
)
4391 /* This must be a global symbol with a got entry. The
4392 next reloc must be the corresponding LO16 reloc. */
4393 BFD_ASSERT (h
!= NULL
&& h
->got_offset
!= (bfd_vma
) -1);
4394 BFD_ASSERT ((rel
+ 1) < relend
);
4395 BFD_ASSERT (ELF32_R_TYPE ((rel
+ 1)->r_info
)
4396 == (r_type
== R_MIPS_CALL_HI16
4398 : R_MIPS_GOT_LO16
));
4400 offset
= (h
->dynindx
- g
->global_gotsym
+ g
->local_gotno
) * 4;
4401 BFD_ASSERT (g
->local_gotno
<= offset
4402 && offset
< sgot
->_raw_size
);
4403 bfd_put_32 (output_bfd
, relocation
+ addend
,
4404 sgot
->contents
+ offset
);
4405 offset
= (sgot
->output_section
->vma
+ sgot
->output_offset
4407 mips_elf_relocate_hi16 (input_bfd
, rel
, rel
+ 1, contents
,
4411 else if (r_type
== R_MIPS_REL32
4412 || r_type
== R_MIPS_32
)
4414 Elf_Internal_Rel outrel
;
4415 Elf32_crinfo cptrel
;
4420 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)
4422 && (input_section
->flags
& SEC_ALLOC
) != 0)
4424 /* When generating a shared object, these
4425 relocations are copied into the output file to be
4426 resolved at run time. */
4429 sreloc
= bfd_get_section_by_name (dynobj
, ".rel.dyn");
4430 BFD_ASSERT (sreloc
!= NULL
);
4433 outrel
.r_offset
= (rel
->r_offset
4434 + input_section
->output_section
->vma
4435 + input_section
->output_offset
);
4437 addend
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
4440 && (! info
->symbolic
4441 || (h
->elf_link_hash_flags
4442 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
4444 BFD_ASSERT (h
->dynindx
!= -1);
4445 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_REL32
);
4446 sec
= input_section
;
4453 sec
= local_sections
[r_symndx
];
4456 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
4458 == bfd_link_hash_defweak
));
4459 sec
= h
->root
.u
.def
.section
;
4461 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
4463 else if (sec
== NULL
|| sec
->owner
== NULL
)
4465 bfd_set_error (bfd_error_bad_value
);
4472 osec
= sec
->output_section
;
4473 indx
= elf_section_data (osec
)->dynindx
;
4478 outrel
.r_info
= ELF32_R_INFO (indx
, R_MIPS_REL32
);
4479 addend
+= relocation
;
4482 bfd_put_32 (output_bfd
, addend
, contents
+ rel
->r_offset
);
4483 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
4484 (((Elf32_External_Rel
*)
4486 + sreloc
->reloc_count
));
4487 ++sreloc
->reloc_count
;
4489 if (SGI_COMPAT (output_bfd
))
4494 /* Make an entry of compact relocation info. */
4495 mips_elf_set_cr_format (cptrel
, CRF_MIPS_LONG
);
4496 cptrel
.vaddr
= (rel
->r_offset
4497 + input_section
->output_section
->vma
4498 + input_section
->output_offset
);
4499 if (r_type
== R_MIPS_REL32
)
4500 mips_elf_set_cr_type (cptrel
, CRT_MIPS_REL32
);
4502 mips_elf_set_cr_type (cptrel
, CRT_MIPS_WORD
);
4503 mips_elf_set_cr_dist2to (cptrel
, 0);
4504 cptrel
.konst
= addend
;
4506 cr
= (scpt
->contents
4507 + sizeof (Elf32_External_compact_rel
));
4508 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
4509 ((Elf32_External_crinfo
*) cr
4510 + scpt
->reloc_count
));
4511 ++scpt
->reloc_count
;
4514 /* This reloc will be computed at runtime, so
4515 there's no need to do anything now. */
4519 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4520 contents
, rel
->r_offset
,
4521 relocation
, addend
);
4524 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4525 contents
, rel
->r_offset
,
4526 relocation
, addend
);
4528 if (SGI_COMPAT (abfd
)
4530 && (input_section
->flags
& SEC_ALLOC
) != 0)
4532 Elf32_crinfo cptrel
;
4535 /* Make an entry of compact relocation info. */
4536 mips_elf_set_cr_format (cptrel
, CRF_MIPS_LONG
);
4537 cptrel
.vaddr
= (rel
->r_offset
4538 + input_section
->output_section
->vma
4539 + input_section
->output_offset
);
4544 mips_elf_set_cr_type (cptrel
, CRT_MIPS_JMPAD
);
4545 /* XXX How should we set dist2to in this case. */
4546 mips_elf_set_cr_dist2to (cptrel
, 8);
4547 cptrel
.konst
= addend
+ relocation
;
4548 cr
= scpt
->contents
+ sizeof (Elf32_External_compact_rel
);
4549 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
4550 ((Elf32_External_crinfo
*) cr
4551 + scpt
->reloc_count
));
4552 ++scpt
->reloc_count
;
4555 case R_MIPS_GPREL16
:
4556 case R_MIPS_LITERAL
:
4557 case R_MIPS_GPREL32
:
4558 mips_elf_set_cr_type (cptrel
, CRT_MIPS_GPHI_LO
);
4559 cptrel
.konst
= gp
- cptrel
.vaddr
;
4560 mips_elf_set_cr_dist2to (cptrel
, 4);
4561 cr
= scpt
->contents
+ sizeof (Elf32_External_compact_rel
);
4562 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
4563 ((Elf32_External_crinfo
*) cr
4564 + scpt
->reloc_count
));
4565 ++scpt
->reloc_count
;
4574 if (r
!= bfd_reloc_ok
)
4579 case bfd_reloc_outofrange
:
4581 case bfd_reloc_overflow
:
4586 name
= h
->root
.root
.string
;
4589 name
= bfd_elf_string_from_elf_section (input_bfd
,
4590 symtab_hdr
->sh_link
,
4595 name
= bfd_section_name (input_bfd
, sec
);
4597 if (! ((*info
->callbacks
->reloc_overflow
)
4598 (info
, name
, howto
->name
, (bfd_vma
) 0,
4599 input_bfd
, input_section
, rel
->r_offset
)))
4610 /* Functions for the dynamic linker. */
4612 /* The name of the dynamic interpreter. This is put in the .interp
4615 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
4617 /* Create dynamic sections when linking against a dynamic object. */
4620 mips_elf_create_dynamic_sections (abfd
, info
)
4622 struct bfd_link_info
*info
;
4624 struct elf_link_hash_entry
*h
;
4626 register asection
*s
;
4627 const char * const *namep
;
4629 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
4632 /* Mips ABI requests the .dynamic section to be read only. */
4633 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4636 if (! bfd_set_section_flags (abfd
, s
, flags
))
4640 /* We need to create .got section. */
4641 if (! mips_elf_create_got_section (abfd
, info
))
4644 /* Create .stub section. */
4645 if (bfd_get_section_by_name (abfd
, ".stub") == NULL
)
4647 s
= bfd_make_section (abfd
, ".stub");
4649 || ! bfd_set_section_flags (abfd
, s
, flags
)
4650 || ! bfd_set_section_alignment (abfd
, s
, 2))
4654 if (SGI_COMPAT (abfd
))
4656 for (namep
= mips_elf_dynsym_rtproc_names
; *namep
!= NULL
; namep
++)
4659 if (! (_bfd_generic_link_add_one_symbol
4660 (info
, abfd
, *namep
, BSF_GLOBAL
, bfd_und_section_ptr
,
4661 (bfd_vma
) 0, (const char *) NULL
, false,
4662 get_elf_backend_data (abfd
)->collect
,
4663 (struct bfd_link_hash_entry
**) &h
)))
4665 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
4666 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4667 h
->type
= STT_SECTION
;
4669 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
4673 /* We need to create a .compact_rel section. */
4674 if (! mips_elf_create_compact_rel_section (abfd
, info
))
4677 /* Change aligments of some sections. */
4678 s
= bfd_get_section_by_name (abfd
, ".hash");
4680 bfd_set_section_alignment (abfd
, s
, 4);
4681 s
= bfd_get_section_by_name (abfd
, ".dynsym");
4683 bfd_set_section_alignment (abfd
, s
, 4);
4684 s
= bfd_get_section_by_name (abfd
, ".dynstr");
4686 bfd_set_section_alignment (abfd
, s
, 4);
4687 s
= bfd_get_section_by_name (abfd
, ".reginfo");
4689 bfd_set_section_alignment (abfd
, s
, 4);
4690 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4692 bfd_set_section_alignment (abfd
, s
, 4);
4698 if (! (_bfd_generic_link_add_one_symbol
4699 (info
, abfd
, "_DYNAMIC_LINK", BSF_GLOBAL
, bfd_abs_section_ptr
,
4700 (bfd_vma
) 0, (const char *) NULL
, false,
4701 get_elf_backend_data (abfd
)->collect
,
4702 (struct bfd_link_hash_entry
**) &h
)))
4704 h
->elf_link_hash_flags
^=~ ELF_LINK_NON_ELF
;
4705 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4706 h
->type
= STT_SECTION
;
4708 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
4715 /* Create the .compact_rel section. */
4718 mips_elf_create_compact_rel_section (abfd
, info
)
4720 struct bfd_link_info
*info
;
4723 register asection
*s
;
4725 if (bfd_get_section_by_name (abfd
, ".compact_rel") == NULL
)
4727 flags
= SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_READONLY
;
4729 s
= bfd_make_section (abfd
, ".compact_rel");
4731 || ! bfd_set_section_flags (abfd
, s
, flags
)
4732 || ! bfd_set_section_alignment (abfd
, s
, 2))
4735 s
->_raw_size
= sizeof (Elf32_External_compact_rel
);
4741 /* Create the .got section to hold the global offset table. */
4744 mips_elf_create_got_section (abfd
, info
)
4746 struct bfd_link_info
*info
;
4749 register asection
*s
;
4750 struct elf_link_hash_entry
*h
;
4751 struct mips_got_info
*g
;
4753 /* This function may be called more than once. */
4754 if (bfd_get_section_by_name (abfd
, ".got") != NULL
)
4757 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
4759 s
= bfd_make_section (abfd
, ".got");
4761 || ! bfd_set_section_flags (abfd
, s
, flags
)
4762 || ! bfd_set_section_alignment (abfd
, s
, 4))
4765 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
4766 linker script because we don't want to define the symbol if we
4767 are not creating a global offset table. */
4769 if (! (_bfd_generic_link_add_one_symbol
4770 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
4771 (bfd_vma
) 0, (const char *) NULL
, false,
4772 get_elf_backend_data (abfd
)->collect
,
4773 (struct bfd_link_hash_entry
**) &h
)))
4775 h
->elf_link_hash_flags
&=~ ELF_LINK_NON_ELF
;
4776 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4777 h
->type
= STT_OBJECT
;
4780 && ! bfd_elf32_link_record_dynamic_symbol (info
, h
))
4783 /* The first several global offset table entries are reserved. */
4784 s
->_raw_size
= MIPS_RESERVED_GOTNO
* 4;
4786 g
= (struct mips_got_info
*) bfd_alloc (abfd
,
4787 sizeof (struct mips_got_info
));
4790 g
->global_gotsym
= 0;
4791 g
->local_gotno
= MIPS_RESERVED_GOTNO
;
4792 if (elf_section_data (s
) == NULL
)
4795 (PTR
) bfd_zalloc (abfd
, sizeof (struct bfd_elf_section_data
));
4796 if (elf_section_data (s
) == NULL
)
4799 elf_section_data (s
)->tdata
= (PTR
) g
;
4804 /* Look through the relocs for a section during the first phase, and
4805 allocate space in the global offset table. */
4808 mips_elf_check_relocs (abfd
, info
, sec
, relocs
)
4810 struct bfd_link_info
*info
;
4812 const Elf_Internal_Rela
*relocs
;
4815 Elf_Internal_Shdr
*symtab_hdr
;
4816 struct elf_link_hash_entry
**sym_hashes
;
4817 struct mips_got_info
*g
;
4819 const Elf_Internal_Rela
*rel
;
4820 const Elf_Internal_Rela
*rel_end
;
4824 if (info
->relocateable
)
4827 dynobj
= elf_hash_table (info
)->dynobj
;
4828 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4829 sym_hashes
= elf_sym_hashes (abfd
);
4830 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
4835 rel_end
= relocs
+ sec
->reloc_count
;
4836 for (rel
= relocs
; rel
< rel_end
; rel
++)
4838 unsigned long r_symndx
;
4839 struct elf_link_hash_entry
*h
;
4841 r_symndx
= ELF32_R_SYM (rel
->r_info
);
4843 if (r_symndx
< extsymoff
)
4846 h
= sym_hashes
[r_symndx
- extsymoff
];
4848 /* Some relocs require a global offset table. */
4851 switch (ELF32_R_TYPE (rel
->r_info
))
4855 case R_MIPS_CALL_HI16
:
4856 case R_MIPS_CALL_LO16
:
4857 case R_MIPS_GOT_HI16
:
4858 case R_MIPS_GOT_LO16
:
4859 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
4860 if (! mips_elf_create_got_section (dynobj
, info
))
4869 switch (ELF32_R_TYPE (rel
->r_info
))
4872 case R_MIPS_CALL_HI16
:
4873 case R_MIPS_CALL_LO16
:
4874 /* This symbol requires a global offset table entry. */
4877 sgot
= bfd_get_section_by_name (dynobj
, ".got");
4878 BFD_ASSERT (sgot
!= NULL
);
4879 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
4880 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
4881 BFD_ASSERT (g
!= NULL
);
4884 BFD_ASSERT (h
!= NULL
);
4886 /* Make sure this symbol is output as a dynamic symbol. */
4887 if (h
->dynindx
== -1)
4889 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
4893 if (h
->got_offset
!= (bfd_vma
) -1)
4895 /* We have already allocated space in the .got. */
4899 /* Note the index of the first global got symbol in .dynsym. */
4900 if (g
->global_gotsym
== 0
4901 || g
->global_gotsym
> (unsigned long) h
->dynindx
)
4902 g
->global_gotsym
= h
->dynindx
;
4904 /* Make this symbol to have the corresponding got entry. */
4907 /* We need a stub, not a plt entry for the undefined
4908 function. But we record it as if it needs plt. See
4909 elf_adjust_dynamic_symbol in elflink.h. */
4910 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
4916 case R_MIPS_GOT_HI16
:
4917 case R_MIPS_GOT_LO16
:
4918 /* This symbol requires a global offset table entry. */
4921 sgot
= bfd_get_section_by_name (dynobj
, ".got");
4922 BFD_ASSERT (sgot
!= NULL
);
4923 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
4924 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
4925 BFD_ASSERT (g
!= NULL
);
4930 /* Make sure this symbol is output as a dynamic symbol. */
4931 if (h
->dynindx
== -1)
4933 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
4937 if (h
->got_offset
!= (bfd_vma
) -1)
4939 /* We have already allocated space in the .got. */
4942 /* Note the index of the first global got symbol in
4944 if (g
->global_gotsym
== 0
4945 || g
->global_gotsym
> (unsigned long) h
->dynindx
)
4946 g
->global_gotsym
= h
->dynindx
;
4948 /* Make this symbol to be the global got symbol. */
4956 if ((info
->shared
|| h
!= NULL
)
4957 && (sec
->flags
& SEC_ALLOC
) != 0)
4959 /* When creating a shared object, we must copy these
4960 reloc types into the output file as R_MIPS_REL32
4961 relocs. We create the .rel.dyn reloc section in
4962 dynobj and make room for this reloc. */
4965 const char *name
= ".rel.dyn";
4967 sreloc
= bfd_get_section_by_name (dynobj
, name
);
4970 sreloc
= bfd_make_section (dynobj
, name
);
4972 || ! bfd_set_section_flags (dynobj
, sreloc
,
4978 || ! bfd_set_section_alignment (dynobj
, sreloc
, 4))
4981 /* Add a null element. */
4982 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
4983 ++sreloc
->reloc_count
;
4988 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
4991 struct mips_elf_link_hash_entry
*hmips
;
4993 /* We only need to copy this reloc if the symbol is
4994 defined in a dynamic object. */
4995 hmips
= (struct mips_elf_link_hash_entry
*) h
;
4996 ++hmips
->mips_32_relocs
;
5000 if (SGI_COMPAT (abfd
))
5001 mips_elf_hash_table (info
)->compact_rel_size
+=
5002 sizeof (Elf32_External_crinfo
);
5007 case R_MIPS_GPREL16
:
5008 case R_MIPS_LITERAL
:
5009 case R_MIPS_GPREL32
:
5010 if (SGI_COMPAT (abfd
))
5011 mips_elf_hash_table (info
)->compact_rel_size
+=
5012 sizeof (Elf32_External_crinfo
);
5023 /* Adjust a symbol defined by a dynamic object and referenced by a
5024 regular object. The current definition is in some section of the
5025 dynamic object, but we're not including those sections. We have to
5026 change the definition to something the rest of the link can
5030 mips_elf_adjust_dynamic_symbol (info
, h
)
5031 struct bfd_link_info
*info
;
5032 struct elf_link_hash_entry
*h
;
5035 struct mips_elf_link_hash_entry
*hmips
;
5038 dynobj
= elf_hash_table (info
)->dynobj
;
5040 /* Make sure we know what is going on here. */
5041 BFD_ASSERT (dynobj
!= NULL
5042 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
5043 || h
->weakdef
!= NULL
5044 || ((h
->elf_link_hash_flags
5045 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
5046 && (h
->elf_link_hash_flags
5047 & ELF_LINK_HASH_REF_REGULAR
) != 0
5048 && (h
->elf_link_hash_flags
5049 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
5051 /* If this symbol is defined in a dynamic object, we need to copy
5052 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
5054 hmips
= (struct mips_elf_link_hash_entry
*) h
;
5055 if (! info
->relocateable
5056 && hmips
->mips_32_relocs
!= 0
5057 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
5059 s
= bfd_get_section_by_name (dynobj
, ".rel.dyn");
5060 BFD_ASSERT (s
!= NULL
);
5062 s
->_raw_size
+= hmips
->mips_32_relocs
* sizeof (Elf32_External_Rel
);
5065 /* For a function, create a stub, if needed. */
5066 if (h
->type
== STT_FUNC
5067 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
5069 if (! elf_hash_table (info
)->dynamic_sections_created
)
5072 /* If this symbol is not defined in a regular file, then set
5073 the symbol to the stub location. This is required to make
5074 function pointers compare as equal between the normal
5075 executable and the shared library. */
5076 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
5078 /* We need .stub section. */
5079 s
= bfd_get_section_by_name (dynobj
, ".stub");
5080 BFD_ASSERT (s
!= NULL
);
5082 h
->root
.u
.def
.section
= s
;
5083 h
->root
.u
.def
.value
= s
->_raw_size
;
5085 /* XXX Write this stub address somewhere. */
5086 h
->plt_offset
= s
->_raw_size
;
5088 /* Make room for this stub code. */
5089 s
->_raw_size
+= MIPS_FUNCTION_STUB_SIZE
;
5091 /* The last half word of the stub will be filled with the index
5092 of this symbol in .dynsym section. */
5097 /* If this is a weak symbol, and there is a real definition, the
5098 processor independent code will have arranged for us to see the
5099 real definition first, and we can just use the same value. */
5100 if (h
->weakdef
!= NULL
)
5102 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
5103 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
5104 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
5105 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
5109 /* This is a reference to a symbol defined by a dynamic object which
5110 is not a function. */
5115 /* Set the sizes of the dynamic sections. */
5118 mips_elf_size_dynamic_sections (output_bfd
, info
)
5120 struct bfd_link_info
*info
;
5126 struct mips_got_info
*g
;
5128 dynobj
= elf_hash_table (info
)->dynobj
;
5129 BFD_ASSERT (dynobj
!= NULL
);
5131 if (elf_hash_table (info
)->dynamic_sections_created
)
5133 /* Set the contents of the .interp section to the interpreter. */
5136 s
= bfd_get_section_by_name (dynobj
, ".interp");
5137 BFD_ASSERT (s
!= NULL
);
5138 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
5139 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
5143 /* Recompute the size of .got for local entires (reserved and
5144 hipages) if needed. To estimate it, get the upper bound of total
5145 size of loadable sections. */
5146 sgot
= bfd_get_section_by_name (dynobj
, ".got");
5150 bfd_size_type loadable_size
= 0;
5151 bfd_size_type local_gotno
;
5154 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
5155 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
5156 BFD_ASSERT (g
!= NULL
);
5158 for (sub
= info
->input_bfds
; sub
; sub
= sub
->link_next
)
5159 for (s
= sub
->sections
; s
!= NULL
; s
= s
->next
)
5161 if ((s
->flags
& SEC_ALLOC
) == 0)
5163 loadable_size
+= (s
->_raw_size
+ 0xf) & ~0xf;
5166 loadable_size
+= MIPS_FUNCTION_STUB_SIZE
;
5168 /* Assume there are two loadable segments consisting of
5169 contiguous sections. Is 5 enough? */
5170 local_gotno
= (loadable_size
>> 16) + 5 + MIPS_RESERVED_GOTNO
;
5171 g
->local_gotno
= local_gotno
;
5172 sgot
->_raw_size
+= local_gotno
* 4;
5175 /* The check_relocs and adjust_dynamic_symbol entry points have
5176 determined the sizes of the various dynamic sections. Allocate
5179 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
5184 /* It's OK to base decisions on the section name, because none
5185 of the dynobj section names depend upon the input files. */
5186 name
= bfd_get_section_name (dynobj
, s
);
5188 if ((s
->flags
& SEC_IN_MEMORY
) == 0)
5193 if (strncmp (name
, ".rel", 4) == 0)
5195 if (s
->_raw_size
== 0)
5201 /* If this relocation section applies to a read only
5202 section, then we probably need a DT_TEXTREL entry.
5203 If the relocation section is .rel.dyn, we always
5204 assert a DT_TEXTREL entry rather than testing whether
5205 there exists a relocation to a read only section or
5207 target
= bfd_get_section_by_name (output_bfd
, name
+ 4);
5208 if ((target
!= NULL
&& (target
->flags
& SEC_READONLY
) != 0)
5209 || strcmp (name
, ".rel.dyn") == 0)
5212 /* We use the reloc_count field as a counter if we need
5213 to copy relocs into the output file. */
5214 if (strcmp (name
, ".rel.dyn") != 0)
5218 else if (strncmp (name
, ".got", 4) == 0)
5222 BFD_ASSERT (elf_section_data (s
) != NULL
);
5223 g
= (struct mips_got_info
*) elf_section_data (s
)->tdata
;
5224 BFD_ASSERT (g
!= NULL
);
5226 /* Fix the size of .got section for the correspondence of
5227 global symbols and got entries. This adds some useless
5228 got entries. Is this required by ABI really? */
5229 i
= elf_hash_table (info
)->dynsymcount
- g
->global_gotsym
;
5230 s
->_raw_size
+= i
* 4;
5232 else if (strncmp (name
, ".stub", 5) == 0)
5234 /* Irix rld assumes that the function stub isn't at the end
5235 of .text section. So put a dummy. XXX */
5236 s
->_raw_size
+= MIPS_FUNCTION_STUB_SIZE
;
5238 else if (SGI_COMPAT (output_bfd
)
5239 && strncmp (name
, ".compact_rel", 12) == 0)
5240 s
->_raw_size
+= mips_elf_hash_table (info
)->compact_rel_size
;
5241 else if (strncmp (name
, ".init", 5) != 0)
5243 /* It's not one of our sections, so don't allocate space. */
5251 for (spp
= &s
->output_section
->owner
->sections
;
5252 *spp
!= s
->output_section
;
5253 spp
= &(*spp
)->next
)
5255 *spp
= s
->output_section
->next
;
5256 --s
->output_section
->owner
->section_count
;
5261 /* Allocate memory for the section contents. */
5262 s
->contents
= (bfd_byte
*) bfd_alloc (dynobj
, s
->_raw_size
);
5263 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
5265 bfd_set_error (bfd_error_no_memory
);
5268 memset (s
->contents
, 0, s
->_raw_size
);
5271 if (elf_hash_table (info
)->dynamic_sections_created
)
5273 /* Add some entries to the .dynamic section. We fill in the
5274 values later, in elf_mips_finish_dynamic_sections, but we
5275 must add the entries now so that we get the correct size for
5276 the .dynamic section. The DT_DEBUG entry is filled in by the
5277 dynamic linker and used by the debugger. */
5280 if (! bfd_elf32_add_dynamic_entry (info
, DT_DEBUG
, 0))
5286 if (! bfd_elf32_add_dynamic_entry (info
, DT_TEXTREL
, 0))
5290 if (! bfd_elf32_add_dynamic_entry (info
, DT_PLTGOT
, 0))
5293 if (bfd_get_section_by_name (dynobj
, ".rel.dyn"))
5295 if (! bfd_elf32_add_dynamic_entry (info
, DT_REL
, 0))
5298 if (! bfd_elf32_add_dynamic_entry (info
, DT_RELSZ
, 0))
5301 if (! bfd_elf32_add_dynamic_entry (info
, DT_RELENT
, 0))
5305 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_CONFLICTNO
, 0))
5308 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_LIBLISTNO
, 0))
5311 if (bfd_get_section_by_name (dynobj
, ".conflict") != NULL
)
5313 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_CONFLICT
, 0))
5316 s
= bfd_get_section_by_name (dynobj
, ".liblist");
5317 BFD_ASSERT (s
!= NULL
);
5319 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_LIBLIST
, 0))
5323 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_RLD_VERSION
, 0))
5326 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_FLAGS
, 0))
5330 /* Time stamps in executable files are a bad idea. */
5331 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_TIME_STAMP
, 0))
5336 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_ICHECKSUM
, 0))
5341 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_IVERSION
, 0))
5345 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_BASE_ADDRESS
, 0))
5348 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_LOCAL_GOTNO
, 0))
5351 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_SYMTABNO
, 0))
5354 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_UNREFEXTNO
, 0))
5357 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_GOTSYM
, 0))
5360 if (! bfd_elf32_add_dynamic_entry (info
, DT_MIPS_HIPAGENO
, 0))
5363 #if 0 /* (SGI_COMPAT) */
5364 if (! bfd_get_section_by_name (dynobj
, ".init"))
5365 if (! bfd_elf32_add_dynamic_entry (info
, DT_INIT
, 0))
5368 if (! bfd_get_section_by_name (dynobj
, ".fini"))
5369 if (! bfd_elf32_add_dynamic_entry (info
, DT_FINI
, 0))
5374 /* If we use dynamic linking, we generate a section symbol for each
5375 output section. These are local symbols, which means that they
5376 must come first in the dynamic symbol table.
5377 That means we must increment the dynamic symbol index of every
5378 other dynamic symbol. */
5380 const char * const *namep
;
5382 bfd_size_type strindex
;
5383 struct bfd_strtab_hash
*dynstr
;
5384 struct mips_got_info
*g
;
5386 if (elf_hash_table (info
)->dynamic_sections_created
)
5388 if (SGI_COMPAT (output_bfd
))
5390 c
= SIZEOF_MIPS_DYNSYM_SECNAMES
- 1;
5391 elf_link_hash_traverse (elf_hash_table (info
),
5392 mips_elf_adjust_dynindx
,
5394 elf_hash_table (info
)->dynsymcount
+= c
;
5396 dynstr
= elf_hash_table (info
)->dynstr
;
5397 BFD_ASSERT (dynstr
!= NULL
);
5399 for (i
= 1, namep
= mips_elf_dynsym_sec_names
;
5403 s
= bfd_get_section_by_name (output_bfd
, *namep
);
5405 elf_section_data (s
)->dynindx
= i
;
5407 strindex
= _bfd_stringtab_add (dynstr
, *namep
, true, false);
5408 if (strindex
== (bfd_size_type
) -1)
5411 mips_elf_hash_table (info
)->dynsym_sec_strindex
[i
] = strindex
;
5416 c
= bfd_count_sections (output_bfd
);
5417 elf_link_hash_traverse (elf_hash_table (info
),
5418 mips_elf_adjust_dynindx
,
5420 elf_hash_table (info
)->dynsymcount
+= c
;
5422 for (i
= 1, s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
, i
++)
5424 elf_section_data (s
)->dynindx
= i
;
5425 /* These symbols will have no names, so we don't need to
5426 fiddle with dynstr_index. */
5431 s
= bfd_get_section_by_name (dynobj
, ".got");
5432 BFD_ASSERT (s
!= NULL
);
5433 BFD_ASSERT (elf_section_data (s
) != NULL
);
5434 g
= (struct mips_got_info
*) elf_section_data (s
)->tdata
;
5435 BFD_ASSERT (g
!= NULL
);
5437 /* If there are no global got symbols, fake the last symbol so for
5439 if (g
->global_gotsym
)
5440 g
->global_gotsym
+= c
;
5442 g
->global_gotsym
= elf_hash_table (info
)->dynsymcount
- 1;
5448 /* Increment the index of a dynamic symbol by a given amount. Called
5449 via elf_link_hash_traverse. */
5452 mips_elf_adjust_dynindx (h
, cparg
)
5453 struct elf_link_hash_entry
*h
;
5456 unsigned int *cp
= (unsigned int *) cparg
;
5458 if (h
->dynindx
!= -1)
5463 /* Finish up dynamic symbol handling. We set the contents of various
5464 dynamic sections here. */
5467 mips_elf_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
5469 struct bfd_link_info
*info
;
5470 struct elf_link_hash_entry
*h
;
5471 Elf_Internal_Sym
*sym
;
5476 struct mips_got_info
*g
;
5479 dynobj
= elf_hash_table (info
)->dynobj
;
5480 gval
= sym
->st_value
;
5482 if (h
->plt_offset
!= (bfd_vma
) -1)
5486 bfd_byte stub
[MIPS_FUNCTION_STUB_SIZE
];
5488 /* This symbol has a stub. Set it up. */
5490 BFD_ASSERT (h
->dynindx
!= -1);
5492 s
= bfd_get_section_by_name (dynobj
, ".stub");
5493 BFD_ASSERT (s
!= NULL
);
5495 /* Fill the stub. */
5497 bfd_put_32 (output_bfd
, STUB_LW(output_bfd
), p
);
5499 bfd_put_32 (output_bfd
, STUB_MOVE
, p
);
5502 /* FIXME: Can h->dynindex be more than 64K? */
5503 if (h
->dynindx
& 0xffff0000)
5506 bfd_put_32 (output_bfd
, STUB_JALR
, p
);
5508 bfd_put_32 (output_bfd
, STUB_LI16
+ h
->dynindx
, p
);
5510 BFD_ASSERT (h
->plt_offset
<= s
->_raw_size
);
5511 memcpy (s
->contents
+ h
->plt_offset
, stub
, MIPS_FUNCTION_STUB_SIZE
);
5513 /* Mark the symbol as undefined. plt_offset != -1 occurs
5514 only for the referenced symbol. */
5515 sym
->st_shndx
= SHN_UNDEF
;
5517 /* The run-time linker uses the st_value field of the symbol
5518 to reset the global offset table entry for this external
5519 to its stub address when unlinking a shared object. */
5520 gval
= s
->output_section
->vma
+ s
->output_offset
+ h
->plt_offset
;
5521 sym
->st_value
= gval
;
5524 BFD_ASSERT (h
->dynindx
!= -1);
5526 sgot
= bfd_get_section_by_name (dynobj
, ".got");
5527 BFD_ASSERT (sgot
!= NULL
);
5528 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
5529 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
5530 BFD_ASSERT (g
!= NULL
);
5532 if ((unsigned long) h
->dynindx
>= g
->global_gotsym
)
5534 bfd_size_type offset
;
5536 /* This symbol has an entry in the global offset table. Set its
5537 value to the corresponding got entry, if needed. */
5538 if (h
->got_offset
== (bfd_vma
) -1)
5540 offset
= (h
->dynindx
- g
->global_gotsym
+ g
->local_gotno
) * 4;
5541 BFD_ASSERT (g
->local_gotno
* 4 <= offset
5542 && offset
< sgot
->_raw_size
);
5543 bfd_put_32 (output_bfd
, gval
, sgot
->contents
+ offset
);
5547 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
5548 name
= h
->root
.root
.string
;
5549 if (strcmp (name
, "_DYNAMIC") == 0
5550 || strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
5551 sym
->st_shndx
= SHN_ABS
;
5552 else if (strcmp (name
, "_DYNAMIC_LINK") == 0)
5554 sym
->st_shndx
= SHN_ABS
;
5555 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
5558 else if (SGI_COMPAT (output_bfd
))
5560 if (strcmp (name
, "_gp_disp") == 0)
5562 sym
->st_shndx
= SHN_ABS
;
5563 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
5564 sym
->st_value
= elf_gp (output_bfd
);
5566 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
5567 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
5569 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
5570 sym
->st_other
= STO_PROTECTED
;
5572 sym
->st_shndx
= SHN_MIPS_DATA
;
5574 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
5576 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
5577 sym
->st_other
= STO_PROTECTED
;
5578 sym
->st_value
= mips_elf_hash_table (info
)->procedure_count
;
5579 sym
->st_shndx
= SHN_ABS
;
5581 else if (sym
->st_shndx
!= SHN_UNDEF
)
5583 if (h
->type
== STT_FUNC
)
5584 sym
->st_shndx
= SHN_MIPS_TEXT
;
5585 else if (h
->type
== STT_OBJECT
)
5586 sym
->st_shndx
= SHN_MIPS_DATA
;
5593 /* Finish up the dynamic sections. */
5596 mips_elf_finish_dynamic_sections (output_bfd
, info
)
5598 struct bfd_link_info
*info
;
5603 struct mips_got_info
*g
;
5605 dynobj
= elf_hash_table (info
)->dynobj
;
5607 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
5609 sgot
= bfd_get_section_by_name (dynobj
, ".got");
5610 BFD_ASSERT (sgot
!= NULL
);
5612 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
5613 g
= (struct mips_got_info
*) elf_section_data (sgot
)->tdata
;
5614 BFD_ASSERT (g
!= NULL
);
5616 if (elf_hash_table (info
)->dynamic_sections_created
)
5618 Elf32_External_Dyn
*dyncon
, *dynconend
;
5620 BFD_ASSERT (sdyn
!= NULL
);
5622 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
5623 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
5624 for (; dyncon
< dynconend
; dyncon
++)
5626 Elf_Internal_Dyn dyn
;
5631 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5639 s
= bfd_get_section_by_name (dynobj
, ".rel.dyn");
5640 BFD_ASSERT (s
!= NULL
);
5641 dyn
.d_un
.d_val
= sizeof (Elf32_External_Rel
);
5642 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5646 /* Rewrite DT_STRSZ. */
5648 _bfd_stringtab_size (elf_hash_table (info
)->dynstr
);
5649 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5655 case DT_MIPS_CONFLICT
:
5658 case DT_MIPS_LIBLIST
:
5661 s
= bfd_get_section_by_name (output_bfd
, name
);
5662 BFD_ASSERT (s
!= NULL
);
5663 dyn
.d_un
.d_ptr
= s
->vma
;
5664 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5667 case DT_MIPS_RLD_VERSION
:
5668 dyn
.d_un
.d_val
= 1; /* XXX */
5669 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5673 dyn
.d_un
.d_val
= RHF_NOTPOT
; /* XXX */
5674 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5677 case DT_MIPS_CONFLICTNO
:
5679 elemsize
= sizeof (Elf32_Conflict
);
5682 case DT_MIPS_LIBLISTNO
:
5684 elemsize
= sizeof (Elf32_Lib
);
5686 s
= bfd_get_section_by_name (output_bfd
, name
);
5689 if (s
->_cooked_size
!= 0)
5690 dyn
.d_un
.d_val
= s
->_cooked_size
/ elemsize
;
5692 dyn
.d_un
.d_val
= s
->_raw_size
/ elemsize
;
5697 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5700 case DT_MIPS_TIME_STAMP
:
5701 time ((time_t *) &dyn
.d_un
.d_val
);
5702 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5705 case DT_MIPS_ICHECKSUM
:
5709 case DT_MIPS_IVERSION
:
5713 case DT_MIPS_BASE_ADDRESS
:
5714 s
= output_bfd
->sections
;
5715 BFD_ASSERT (s
!= NULL
);
5716 dyn
.d_un
.d_ptr
= s
->vma
& ~(0xffff);
5717 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5720 case DT_MIPS_LOCAL_GOTNO
:
5721 dyn
.d_un
.d_val
= g
->local_gotno
;
5722 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5725 case DT_MIPS_SYMTABNO
:
5727 elemsize
= sizeof (Elf32_External_Sym
);
5728 s
= bfd_get_section_by_name (output_bfd
, name
);
5729 BFD_ASSERT (s
!= NULL
);
5731 if (s
->_cooked_size
!= 0)
5732 dyn
.d_un
.d_val
= s
->_cooked_size
/ elemsize
;
5734 dyn
.d_un
.d_val
= s
->_raw_size
/ elemsize
;
5735 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5738 case DT_MIPS_UNREFEXTNO
:
5740 dyn
.d_un
.d_val
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
5741 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5744 case DT_MIPS_GOTSYM
:
5745 dyn
.d_un
.d_val
= g
->global_gotsym
;
5746 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5749 case DT_MIPS_HIPAGENO
:
5750 dyn
.d_un
.d_val
= g
->local_gotno
- MIPS_RESERVED_GOTNO
;
5751 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5758 /* The first entry of the global offset table will be filled at
5759 runtime. The second entry will be used by some runtime loaders.
5760 This isn't the case of Irix rld. */
5761 if (sgot
->_raw_size
> 0)
5763 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
5764 bfd_put_32 (output_bfd
, (bfd_vma
) 0x80000000, sgot
->contents
+ 4);
5767 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
5774 Elf_Internal_Sym sym
;
5777 const char * const * namep
= mips_elf_dynsym_sec_names
;
5778 Elf32_compact_rel cpt
;
5780 /* Set up the section symbols for the output sections. SGI sets
5781 the STT_NOTYPE attribute for these symbols. Should we do so? */
5783 sdynsym
= bfd_get_section_by_name (dynobj
, ".dynsym");
5784 if (sdynsym
!= NULL
)
5786 if (SGI_COMPAT (output_bfd
))
5790 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_NOTYPE
);
5794 while ((name
= *namep
++) != NULL
)
5796 s
= bfd_get_section_by_name (output_bfd
, name
);
5799 sym
.st_value
= s
->vma
;
5800 dindx
= elf_section_data (s
)->dynindx
;
5801 last
= s
->vma
+ s
->_raw_size
;
5805 sym
.st_value
= last
;
5809 sym
.st_shndx
= (i
< MIPS_TEXT_DYNSYM_SECNO
5814 mips_elf_hash_table (info
)->dynsym_sec_strindex
[dindx
];
5816 bfd_elf32_swap_symbol_out (output_bfd
, &sym
,
5817 (((Elf32_External_Sym
*)
5822 /* Set the sh_info field of the output .dynsym section to
5823 the index of the first global symbol. */
5824 elf_section_data (sdynsym
->output_section
)->this_hdr
.sh_info
=
5825 SIZEOF_MIPS_DYNSYM_SECNAMES
;
5831 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5834 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5838 sym
.st_value
= s
->vma
;
5840 indx
= elf_section_data (s
)->this_idx
;
5841 BFD_ASSERT (indx
> 0);
5842 sym
.st_shndx
= indx
;
5844 bfd_elf32_swap_symbol_out (output_bfd
, &sym
,
5845 (((Elf32_External_Sym
*)
5847 + elf_section_data (s
)->dynindx
));
5850 /* Set the sh_info field of the output .dynsym section to
5851 the index of the first global symbol. */
5852 elf_section_data (sdynsym
->output_section
)->this_hdr
.sh_info
=
5853 bfd_count_sections (output_bfd
) + 1;
5857 if (SGI_COMPAT (output_bfd
))
5859 /* Write .compact_rel section out. */
5860 s
= bfd_get_section_by_name (dynobj
, ".compact_rel");
5864 cpt
.num
= s
->reloc_count
;
5866 cpt
.offset
= (s
->output_section
->filepos
5867 + sizeof (Elf32_External_compact_rel
));
5870 bfd_elf32_swap_compact_rel_out (output_bfd
, &cpt
,
5871 ((Elf32_External_compact_rel
*)
5874 /* Clean up a dummy stub function entry in .text. */
5875 s
= bfd_get_section_by_name (dynobj
, ".stub");
5878 file_ptr dummy_offset
;
5880 BFD_ASSERT (s
->_raw_size
>= MIPS_FUNCTION_STUB_SIZE
);
5881 dummy_offset
= s
->_raw_size
- MIPS_FUNCTION_STUB_SIZE
;
5882 memset (s
->contents
+ dummy_offset
, 0,
5883 MIPS_FUNCTION_STUB_SIZE
);
5888 /* Clean up a first relocation in .rel.dyn. */
5889 s
= bfd_get_section_by_name (dynobj
, ".rel.dyn");
5891 memset (s
->contents
, 0, sizeof (Elf32_External_Rel
));
5897 /* This is almost identical to bfd_generic_get_... except that some
5898 MIPS relocations need to be handled specially. Sigh. */
5901 elf32_mips_get_relocated_section_contents (abfd
, link_info
, link_order
, data
,
5902 relocateable
, symbols
)
5904 struct bfd_link_info
*link_info
;
5905 struct bfd_link_order
*link_order
;
5907 boolean relocateable
;
5910 /* Get enough memory to hold the stuff */
5911 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
5912 asection
*input_section
= link_order
->u
.indirect
.section
;
5914 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
5915 arelent
**reloc_vector
= NULL
;
5921 reloc_vector
= (arelent
**) bfd_malloc (reloc_size
);
5922 if (reloc_vector
== NULL
&& reloc_size
!= 0)
5925 /* read in the section */
5926 if (!bfd_get_section_contents (input_bfd
,
5930 input_section
->_raw_size
))
5933 /* We're not relaxing the section, so just copy the size info */
5934 input_section
->_cooked_size
= input_section
->_raw_size
;
5935 input_section
->reloc_done
= true;
5937 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
5941 if (reloc_count
< 0)
5944 if (reloc_count
> 0)
5949 bfd_vma gp
= 0x12345678; /* initialize just to shut gcc up */
5952 struct bfd_hash_entry
*h
;
5953 struct bfd_link_hash_entry
*lh
;
5954 /* Skip all this stuff if we aren't mixing formats. */
5955 if (abfd
&& input_bfd
5956 && abfd
->xvec
== input_bfd
->xvec
)
5960 h
= bfd_hash_lookup (&link_info
->hash
->table
, "_gp", false, false);
5961 lh
= (struct bfd_link_hash_entry
*) h
;
5968 case bfd_link_hash_undefined
:
5969 case bfd_link_hash_undefweak
:
5970 case bfd_link_hash_common
:
5973 case bfd_link_hash_defined
:
5974 case bfd_link_hash_defweak
:
5976 gp
= lh
->u
.def
.value
;
5978 case bfd_link_hash_indirect
:
5979 case bfd_link_hash_warning
:
5981 /* @@FIXME ignoring warning for now */
5983 case bfd_link_hash_new
:
5992 for (parent
= reloc_vector
; *parent
!= (arelent
*) NULL
;
5995 char *error_message
= (char *) NULL
;
5996 bfd_reloc_status_type r
;
5998 /* Specific to MIPS: Deal with relocation types that require
5999 knowing the gp of the output bfd. */
6000 asymbol
*sym
= *(*parent
)->sym_ptr_ptr
;
6001 if (bfd_is_abs_section (sym
->section
) && abfd
)
6003 /* The special_function wouldn't get called anyways. */
6007 /* The gp isn't there; let the special function code
6008 fall over on its own. */
6010 else if ((*parent
)->howto
->special_function
6011 == _bfd_mips_elf_gprel16_reloc
)
6013 /* bypass special_function call */
6014 r
= gprel16_with_gp (input_bfd
, sym
, *parent
, input_section
,
6015 relocateable
, (PTR
) data
, gp
);
6016 goto skip_bfd_perform_relocation
;
6018 /* end mips specific stuff */
6020 r
= bfd_perform_relocation (input_bfd
,
6024 relocateable
? abfd
: (bfd
*) NULL
,
6026 skip_bfd_perform_relocation
:
6030 asection
*os
= input_section
->output_section
;
6032 /* A partial link, so keep the relocs */
6033 os
->orelocation
[os
->reloc_count
] = *parent
;
6037 if (r
!= bfd_reloc_ok
)
6041 case bfd_reloc_undefined
:
6042 if (!((*link_info
->callbacks
->undefined_symbol
)
6043 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
6044 input_bfd
, input_section
, (*parent
)->address
)))
6047 case bfd_reloc_dangerous
:
6048 BFD_ASSERT (error_message
!= (char *) NULL
);
6049 if (!((*link_info
->callbacks
->reloc_dangerous
)
6050 (link_info
, error_message
, input_bfd
, input_section
,
6051 (*parent
)->address
)))
6054 case bfd_reloc_overflow
:
6055 if (!((*link_info
->callbacks
->reloc_overflow
)
6056 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
6057 (*parent
)->howto
->name
, (*parent
)->addend
,
6058 input_bfd
, input_section
, (*parent
)->address
)))
6061 case bfd_reloc_outofrange
:
6070 if (reloc_vector
!= NULL
)
6071 free (reloc_vector
);
6075 if (reloc_vector
!= NULL
)
6076 free (reloc_vector
);
6079 #define bfd_elf32_bfd_get_relocated_section_contents \
6080 elf32_mips_get_relocated_section_contents
6082 /* ECOFF swapping routines. These are used when dealing with the
6083 .mdebug section, which is in the ECOFF debugging format. */
6084 static const struct ecoff_debug_swap mips_elf32_ecoff_debug_swap
=
6086 /* Symbol table magic number. */
6088 /* Alignment of debugging information. E.g., 4. */
6090 /* Sizes of external symbolic information. */
6091 sizeof (struct hdr_ext
),
6092 sizeof (struct dnr_ext
),
6093 sizeof (struct pdr_ext
),
6094 sizeof (struct sym_ext
),
6095 sizeof (struct opt_ext
),
6096 sizeof (struct fdr_ext
),
6097 sizeof (struct rfd_ext
),
6098 sizeof (struct ext_ext
),
6099 /* Functions to swap in external symbolic data. */
6108 _bfd_ecoff_swap_tir_in
,
6109 _bfd_ecoff_swap_rndx_in
,
6110 /* Functions to swap out external symbolic data. */
6119 _bfd_ecoff_swap_tir_out
,
6120 _bfd_ecoff_swap_rndx_out
,
6121 /* Function to read in symbolic data. */
6122 _bfd_mips_elf_read_ecoff_info
6125 #define TARGET_LITTLE_SYM bfd_elf32_littlemips_vec
6126 #define TARGET_LITTLE_NAME "elf32-littlemips"
6127 #define TARGET_BIG_SYM bfd_elf32_bigmips_vec
6128 #define TARGET_BIG_NAME "elf32-bigmips"
6129 #define ELF_ARCH bfd_arch_mips
6130 #define ELF_MACHINE_CODE EM_MIPS
6131 #define ELF_MAXPAGESIZE 0x10000
6132 #define elf_backend_collect true
6133 #define elf_backend_type_change_ok true
6134 #define elf_info_to_howto 0
6135 #define elf_info_to_howto_rel mips_info_to_howto_rel
6136 #define elf_backend_sym_is_global mips_elf_sym_is_global
6137 #define elf_backend_object_p mips_elf32_object_p
6138 #define elf_backend_section_from_shdr mips_elf32_section_from_shdr
6139 #define elf_backend_fake_sections _bfd_mips_elf_fake_sections
6140 #define elf_backend_section_from_bfd_section \
6141 _bfd_mips_elf_section_from_bfd_section
6142 #define elf_backend_section_processing mips_elf32_section_processing
6143 #define elf_backend_symbol_processing _bfd_mips_elf_symbol_processing
6144 #define elf_backend_additional_program_headers \
6145 mips_elf_additional_program_headers
6146 #define elf_backend_modify_segment_map mips_elf_modify_segment_map
6147 #define elf_backend_final_write_processing \
6148 _bfd_mips_elf_final_write_processing
6149 #define elf_backend_ecoff_debug_swap &mips_elf32_ecoff_debug_swap
6151 #define bfd_elf32_bfd_is_local_label mips_elf_is_local_label
6152 #define bfd_elf32_find_nearest_line _bfd_mips_elf_find_nearest_line
6153 #define bfd_elf32_set_section_contents _bfd_mips_elf_set_section_contents
6154 #define bfd_elf32_bfd_link_hash_table_create \
6155 mips_elf_link_hash_table_create
6156 #define bfd_elf32_bfd_final_link mips_elf_final_link
6157 #define bfd_elf32_bfd_copy_private_bfd_data \
6158 _bfd_mips_elf_copy_private_bfd_data
6159 #define bfd_elf32_bfd_merge_private_bfd_data \
6160 _bfd_mips_elf_merge_private_bfd_data
6161 #define bfd_elf32_bfd_set_private_flags _bfd_mips_elf_set_private_flags
6162 #define elf_backend_add_symbol_hook mips_elf_add_symbol_hook
6163 #define elf_backend_create_dynamic_sections \
6164 mips_elf_create_dynamic_sections
6165 #define elf_backend_check_relocs mips_elf_check_relocs
6166 #define elf_backend_adjust_dynamic_symbol \
6167 mips_elf_adjust_dynamic_symbol
6168 #define elf_backend_size_dynamic_sections \
6169 mips_elf_size_dynamic_sections
6170 #define elf_backend_relocate_section mips_elf_relocate_section
6171 #define elf_backend_finish_dynamic_symbol \
6172 mips_elf_finish_dynamic_symbol
6173 #define elf_backend_finish_dynamic_sections \
6174 mips_elf_finish_dynamic_sections
6176 #include "elf32-target.h"