1 /* MIPS-specific support for ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004 Free Software Foundation, Inc.
5 Most of the information added by Ian Lance Taylor, Cygnus Support,
7 N32/64 ABI support added by Mark Mitchell, CodeSourcery, LLC.
8 <mark@codesourcery.com>
9 Traditional MIPS targets support added by Koundinya.K, Dansk Data
10 Elektronik & Operations Research Group. <kk@ddeorg.soft.net>
12 This file is part of BFD, the Binary File Descriptor library.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 2 of the License, or
17 (at your option) any later version.
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 /* This file handles functionality common to the different MIPS ABI's. */
33 #include "libiberty.h"
35 #include "elfxx-mips.h"
38 /* Get the ECOFF swapping routines. */
40 #include "coff/symconst.h"
41 #include "coff/ecoff.h"
42 #include "coff/mips.h"
46 /* This structure is used to hold .got entries while estimating got
50 /* The input bfd in which the symbol is defined. */
52 /* The index of the symbol, as stored in the relocation r_info, if
53 we have a local symbol; -1 otherwise. */
57 /* If abfd == NULL, an address that must be stored in the got. */
59 /* If abfd != NULL && symndx != -1, the addend of the relocation
60 that should be added to the symbol value. */
62 /* If abfd != NULL && symndx == -1, the hash table entry
63 corresponding to a global symbol in the got (or, local, if
65 struct mips_elf_link_hash_entry
*h
;
67 /* The offset from the beginning of the .got section to the entry
68 corresponding to this symbol+addend. If it's a global symbol
69 whose offset is yet to be decided, it's going to be -1. */
73 /* This structure is used to hold .got information when linking. */
77 /* The global symbol in the GOT with the lowest index in the dynamic
79 struct elf_link_hash_entry
*global_gotsym
;
80 /* The number of global .got entries. */
81 unsigned int global_gotno
;
82 /* The number of local .got entries. */
83 unsigned int local_gotno
;
84 /* The number of local .got entries we have used. */
85 unsigned int assigned_gotno
;
86 /* A hash table holding members of the got. */
87 struct htab
*got_entries
;
88 /* A hash table mapping input bfds to other mips_got_info. NULL
89 unless multi-got was necessary. */
91 /* In multi-got links, a pointer to the next got (err, rather, most
92 of the time, it points to the previous got). */
93 struct mips_got_info
*next
;
96 /* Map an input bfd to a got in a multi-got link. */
98 struct mips_elf_bfd2got_hash
{
100 struct mips_got_info
*g
;
103 /* Structure passed when traversing the bfd2got hash table, used to
104 create and merge bfd's gots. */
106 struct mips_elf_got_per_bfd_arg
108 /* A hashtable that maps bfds to gots. */
110 /* The output bfd. */
112 /* The link information. */
113 struct bfd_link_info
*info
;
114 /* A pointer to the primary got, i.e., the one that's going to get
115 the implicit relocations from DT_MIPS_LOCAL_GOTNO and
117 struct mips_got_info
*primary
;
118 /* A non-primary got we're trying to merge with other input bfd's
120 struct mips_got_info
*current
;
121 /* The maximum number of got entries that can be addressed with a
123 unsigned int max_count
;
124 /* The number of local and global entries in the primary got. */
125 unsigned int primary_count
;
126 /* The number of local and global entries in the current got. */
127 unsigned int current_count
;
130 /* Another structure used to pass arguments for got entries traversal. */
132 struct mips_elf_set_global_got_offset_arg
134 struct mips_got_info
*g
;
136 unsigned int needed_relocs
;
137 struct bfd_link_info
*info
;
140 struct _mips_elf_section_data
142 struct bfd_elf_section_data elf
;
145 struct mips_got_info
*got_info
;
150 #define mips_elf_section_data(sec) \
151 ((struct _mips_elf_section_data *) elf_section_data (sec))
153 /* This structure is passed to mips_elf_sort_hash_table_f when sorting
154 the dynamic symbols. */
156 struct mips_elf_hash_sort_data
158 /* The symbol in the global GOT with the lowest dynamic symbol table
160 struct elf_link_hash_entry
*low
;
161 /* The least dynamic symbol table index corresponding to a symbol
163 long min_got_dynindx
;
164 /* The greatest dynamic symbol table index corresponding to a symbol
165 with a GOT entry that is not referenced (e.g., a dynamic symbol
166 with dynamic relocations pointing to it from non-primary GOTs). */
167 long max_unref_got_dynindx
;
168 /* The greatest dynamic symbol table index not corresponding to a
169 symbol without a GOT entry. */
170 long max_non_got_dynindx
;
173 /* The MIPS ELF linker needs additional information for each symbol in
174 the global hash table. */
176 struct mips_elf_link_hash_entry
178 struct elf_link_hash_entry root
;
180 /* External symbol information. */
183 /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
185 unsigned int possibly_dynamic_relocs
;
187 /* If the R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 reloc is against
188 a readonly section. */
189 bfd_boolean readonly_reloc
;
191 /* We must not create a stub for a symbol that has relocations
192 related to taking the function's address, i.e. any but
193 R_MIPS_CALL*16 ones -- see "MIPS ABI Supplement, 3rd Edition",
195 bfd_boolean no_fn_stub
;
197 /* If there is a stub that 32 bit functions should use to call this
198 16 bit function, this points to the section containing the stub. */
201 /* Whether we need the fn_stub; this is set if this symbol appears
202 in any relocs other than a 16 bit call. */
203 bfd_boolean need_fn_stub
;
205 /* If there is a stub that 16 bit functions should use to call this
206 32 bit function, this points to the section containing the stub. */
209 /* This is like the call_stub field, but it is used if the function
210 being called returns a floating point value. */
211 asection
*call_fp_stub
;
213 /* Are we forced local? .*/
214 bfd_boolean forced_local
;
217 /* MIPS ELF linker hash table. */
219 struct mips_elf_link_hash_table
221 struct elf_link_hash_table root
;
223 /* We no longer use this. */
224 /* String section indices for the dynamic section symbols. */
225 bfd_size_type dynsym_sec_strindex
[SIZEOF_MIPS_DYNSYM_SECNAMES
];
227 /* The number of .rtproc entries. */
228 bfd_size_type procedure_count
;
229 /* The size of the .compact_rel section (if SGI_COMPAT). */
230 bfd_size_type compact_rel_size
;
231 /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic
232 entry is set to the address of __rld_obj_head as in IRIX5. */
233 bfd_boolean use_rld_obj_head
;
234 /* This is the value of the __rld_map or __rld_obj_head symbol. */
236 /* This is set if we see any mips16 stub sections. */
237 bfd_boolean mips16_stubs_seen
;
240 /* Structure used to pass information to mips_elf_output_extsym. */
245 struct bfd_link_info
*info
;
246 struct ecoff_debug_info
*debug
;
247 const struct ecoff_debug_swap
*swap
;
251 /* The names of the runtime procedure table symbols used on IRIX5. */
253 static const char * const mips_elf_dynsym_rtproc_names
[] =
256 "_procedure_string_table",
257 "_procedure_table_size",
261 /* These structures are used to generate the .compact_rel section on
266 unsigned long id1
; /* Always one? */
267 unsigned long num
; /* Number of compact relocation entries. */
268 unsigned long id2
; /* Always two? */
269 unsigned long offset
; /* The file offset of the first relocation. */
270 unsigned long reserved0
; /* Zero? */
271 unsigned long reserved1
; /* Zero? */
280 bfd_byte reserved0
[4];
281 bfd_byte reserved1
[4];
282 } Elf32_External_compact_rel
;
286 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
287 unsigned int rtype
: 4; /* Relocation types. See below. */
288 unsigned int dist2to
: 8;
289 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
290 unsigned long konst
; /* KONST field. See below. */
291 unsigned long vaddr
; /* VADDR to be relocated. */
296 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
297 unsigned int rtype
: 4; /* Relocation types. See below. */
298 unsigned int dist2to
: 8;
299 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
300 unsigned long konst
; /* KONST field. See below. */
308 } Elf32_External_crinfo
;
314 } Elf32_External_crinfo2
;
316 /* These are the constants used to swap the bitfields in a crinfo. */
318 #define CRINFO_CTYPE (0x1)
319 #define CRINFO_CTYPE_SH (31)
320 #define CRINFO_RTYPE (0xf)
321 #define CRINFO_RTYPE_SH (27)
322 #define CRINFO_DIST2TO (0xff)
323 #define CRINFO_DIST2TO_SH (19)
324 #define CRINFO_RELVADDR (0x7ffff)
325 #define CRINFO_RELVADDR_SH (0)
327 /* A compact relocation info has long (3 words) or short (2 words)
328 formats. A short format doesn't have VADDR field and relvaddr
329 fields contains ((VADDR - vaddr of the previous entry) >> 2). */
330 #define CRF_MIPS_LONG 1
331 #define CRF_MIPS_SHORT 0
333 /* There are 4 types of compact relocation at least. The value KONST
334 has different meaning for each type:
337 CT_MIPS_REL32 Address in data
338 CT_MIPS_WORD Address in word (XXX)
339 CT_MIPS_GPHI_LO GP - vaddr
340 CT_MIPS_JMPAD Address to jump
343 #define CRT_MIPS_REL32 0xa
344 #define CRT_MIPS_WORD 0xb
345 #define CRT_MIPS_GPHI_LO 0xc
346 #define CRT_MIPS_JMPAD 0xd
348 #define mips_elf_set_cr_format(x,format) ((x).ctype = (format))
349 #define mips_elf_set_cr_type(x,type) ((x).rtype = (type))
350 #define mips_elf_set_cr_dist2to(x,v) ((x).dist2to = (v))
351 #define mips_elf_set_cr_relvaddr(x,d) ((x).relvaddr = (d)<<2)
353 /* The structure of the runtime procedure descriptor created by the
354 loader for use by the static exception system. */
356 typedef struct runtime_pdr
{
357 bfd_vma adr
; /* Memory address of start of procedure. */
358 long regmask
; /* Save register mask. */
359 long regoffset
; /* Save register offset. */
360 long fregmask
; /* Save floating point register mask. */
361 long fregoffset
; /* Save floating point register offset. */
362 long frameoffset
; /* Frame size. */
363 short framereg
; /* Frame pointer register. */
364 short pcreg
; /* Offset or reg of return pc. */
365 long irpss
; /* Index into the runtime string table. */
367 struct exception_info
*exception_info
;/* Pointer to exception array. */
369 #define cbRPDR sizeof (RPDR)
370 #define rpdNil ((pRPDR) 0)
372 static struct bfd_hash_entry
*mips_elf_link_hash_newfunc
373 (struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *);
374 static void ecoff_swap_rpdr_out
375 (bfd
*, const RPDR
*, struct rpdr_ext
*);
376 static bfd_boolean mips_elf_create_procedure_table
377 (void *, bfd
*, struct bfd_link_info
*, asection
*,
378 struct ecoff_debug_info
*);
379 static bfd_boolean mips_elf_check_mips16_stubs
380 (struct mips_elf_link_hash_entry
*, void *);
381 static void bfd_mips_elf32_swap_gptab_in
382 (bfd
*, const Elf32_External_gptab
*, Elf32_gptab
*);
383 static void bfd_mips_elf32_swap_gptab_out
384 (bfd
*, const Elf32_gptab
*, Elf32_External_gptab
*);
385 static void bfd_elf32_swap_compact_rel_out
386 (bfd
*, const Elf32_compact_rel
*, Elf32_External_compact_rel
*);
387 static void bfd_elf32_swap_crinfo_out
388 (bfd
*, const Elf32_crinfo
*, Elf32_External_crinfo
*);
389 static int sort_dynamic_relocs
390 (const void *, const void *);
391 static int sort_dynamic_relocs_64
392 (const void *, const void *);
393 static bfd_boolean mips_elf_output_extsym
394 (struct mips_elf_link_hash_entry
*, void *);
395 static int gptab_compare
396 (const void *, const void *);
397 static asection
*mips_elf_rel_dyn_section
398 (bfd
*, bfd_boolean
);
399 static asection
*mips_elf_got_section
400 (bfd
*, bfd_boolean
);
401 static struct mips_got_info
*mips_elf_got_info
402 (bfd
*, asection
**);
403 static bfd_vma mips_elf_local_got_index
404 (bfd
*, bfd
*, struct bfd_link_info
*, bfd_vma
);
405 static bfd_vma mips_elf_global_got_index
406 (bfd
*, bfd
*, struct elf_link_hash_entry
*);
407 static bfd_vma mips_elf_got_page
408 (bfd
*, bfd
*, struct bfd_link_info
*, bfd_vma
, bfd_vma
*);
409 static bfd_vma mips_elf_got16_entry
410 (bfd
*, bfd
*, struct bfd_link_info
*, bfd_vma
, bfd_boolean
);
411 static bfd_vma mips_elf_got_offset_from_index
412 (bfd
*, bfd
*, bfd
*, bfd_vma
);
413 static struct mips_got_entry
*mips_elf_create_local_got_entry
414 (bfd
*, bfd
*, struct mips_got_info
*, asection
*, bfd_vma
);
415 static bfd_boolean mips_elf_sort_hash_table
416 (struct bfd_link_info
*, unsigned long);
417 static bfd_boolean mips_elf_sort_hash_table_f
418 (struct mips_elf_link_hash_entry
*, void *);
419 static bfd_boolean mips_elf_record_local_got_symbol
420 (bfd
*, long, bfd_vma
, struct mips_got_info
*);
421 static bfd_boolean mips_elf_record_global_got_symbol
422 (struct elf_link_hash_entry
*, bfd
*, struct bfd_link_info
*,
423 struct mips_got_info
*);
424 static const Elf_Internal_Rela
*mips_elf_next_relocation
425 (bfd
*, unsigned int, const Elf_Internal_Rela
*, const Elf_Internal_Rela
*);
426 static bfd_boolean mips_elf_local_relocation_p
427 (bfd
*, const Elf_Internal_Rela
*, asection
**, bfd_boolean
);
428 static bfd_boolean mips_elf_overflow_p
430 static bfd_vma mips_elf_high
432 static bfd_vma mips_elf_higher
434 static bfd_vma mips_elf_highest
436 static bfd_boolean mips_elf_create_compact_rel_section
437 (bfd
*, struct bfd_link_info
*);
438 static bfd_boolean mips_elf_create_got_section
439 (bfd
*, struct bfd_link_info
*, bfd_boolean
);
440 static bfd_reloc_status_type mips_elf_calculate_relocation
441 (bfd
*, bfd
*, asection
*, struct bfd_link_info
*,
442 const Elf_Internal_Rela
*, bfd_vma
, reloc_howto_type
*,
443 Elf_Internal_Sym
*, asection
**, bfd_vma
*, const char **,
444 bfd_boolean
*, bfd_boolean
);
445 static bfd_vma mips_elf_obtain_contents
446 (reloc_howto_type
*, const Elf_Internal_Rela
*, bfd
*, bfd_byte
*);
447 static bfd_boolean mips_elf_perform_relocation
448 (struct bfd_link_info
*, reloc_howto_type
*, const Elf_Internal_Rela
*,
449 bfd_vma
, bfd
*, asection
*, bfd_byte
*, bfd_boolean
);
450 static bfd_boolean mips_elf_stub_section_p
452 static void mips_elf_allocate_dynamic_relocations
453 (bfd
*, unsigned int);
454 static bfd_boolean mips_elf_create_dynamic_relocation
455 (bfd
*, struct bfd_link_info
*, const Elf_Internal_Rela
*,
456 struct mips_elf_link_hash_entry
*, asection
*, bfd_vma
,
457 bfd_vma
*, asection
*);
458 static void mips_set_isa_flags
460 static INLINE
char *elf_mips_abi_name
462 static void mips_elf_irix6_finish_dynamic_symbol
463 (bfd
*, const char *, Elf_Internal_Sym
*);
464 static bfd_boolean mips_mach_extends_p
465 (unsigned long, unsigned long);
466 static bfd_boolean mips_32bit_flags_p
468 static INLINE hashval_t mips_elf_hash_bfd_vma
470 static hashval_t mips_elf_got_entry_hash
472 static int mips_elf_got_entry_eq
473 (const void *, const void *);
475 static bfd_boolean mips_elf_multi_got
476 (bfd
*, struct bfd_link_info
*, struct mips_got_info
*,
477 asection
*, bfd_size_type
);
478 static hashval_t mips_elf_multi_got_entry_hash
480 static int mips_elf_multi_got_entry_eq
481 (const void *, const void *);
482 static hashval_t mips_elf_bfd2got_entry_hash
484 static int mips_elf_bfd2got_entry_eq
485 (const void *, const void *);
486 static int mips_elf_make_got_per_bfd
488 static int mips_elf_merge_gots
490 static int mips_elf_set_global_got_offset
492 static int mips_elf_set_no_stub
494 static int mips_elf_resolve_final_got_entry
496 static void mips_elf_resolve_final_got_entries
497 (struct mips_got_info
*);
498 static bfd_vma mips_elf_adjust_gp
499 (bfd
*, struct mips_got_info
*, bfd
*);
500 static struct mips_got_info
*mips_elf_got_for_ibfd
501 (struct mips_got_info
*, bfd
*);
503 /* This will be used when we sort the dynamic relocation records. */
504 static bfd
*reldyn_sorting_bfd
;
506 /* Nonzero if ABFD is using the N32 ABI. */
508 #define ABI_N32_P(abfd) \
509 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
511 /* Nonzero if ABFD is using the N64 ABI. */
512 #define ABI_64_P(abfd) \
513 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
515 /* Nonzero if ABFD is using NewABI conventions. */
516 #define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
518 /* The IRIX compatibility level we are striving for. */
519 #define IRIX_COMPAT(abfd) \
520 (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
522 /* Whether we are trying to be compatible with IRIX at all. */
523 #define SGI_COMPAT(abfd) \
524 (IRIX_COMPAT (abfd) != ict_none)
526 /* The name of the options section. */
527 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
528 (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
530 /* The name of the stub section. */
531 #define MIPS_ELF_STUB_SECTION_NAME(abfd) ".MIPS.stubs"
533 /* The size of an external REL relocation. */
534 #define MIPS_ELF_REL_SIZE(abfd) \
535 (get_elf_backend_data (abfd)->s->sizeof_rel)
537 /* The size of an external dynamic table entry. */
538 #define MIPS_ELF_DYN_SIZE(abfd) \
539 (get_elf_backend_data (abfd)->s->sizeof_dyn)
541 /* The size of a GOT entry. */
542 #define MIPS_ELF_GOT_SIZE(abfd) \
543 (get_elf_backend_data (abfd)->s->arch_size / 8)
545 /* The size of a symbol-table entry. */
546 #define MIPS_ELF_SYM_SIZE(abfd) \
547 (get_elf_backend_data (abfd)->s->sizeof_sym)
549 /* The default alignment for sections, as a power of two. */
550 #define MIPS_ELF_LOG_FILE_ALIGN(abfd) \
551 (get_elf_backend_data (abfd)->s->log_file_align)
553 /* Get word-sized data. */
554 #define MIPS_ELF_GET_WORD(abfd, ptr) \
555 (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
557 /* Put out word-sized data. */
558 #define MIPS_ELF_PUT_WORD(abfd, val, ptr) \
560 ? bfd_put_64 (abfd, val, ptr) \
561 : bfd_put_32 (abfd, val, ptr))
563 /* Add a dynamic symbol table-entry. */
564 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
565 _bfd_elf_add_dynamic_entry (info, tag, val)
567 #define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela) \
568 (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela))
570 /* Determine whether the internal relocation of index REL_IDX is REL
571 (zero) or RELA (non-zero). The assumption is that, if there are
572 two relocation sections for this section, one of them is REL and
573 the other is RELA. If the index of the relocation we're testing is
574 in range for the first relocation section, check that the external
575 relocation size is that for RELA. It is also assumed that, if
576 rel_idx is not in range for the first section, and this first
577 section contains REL relocs, then the relocation is in the second
578 section, that is RELA. */
579 #define MIPS_RELOC_RELA_P(abfd, sec, rel_idx) \
580 ((NUM_SHDR_ENTRIES (&elf_section_data (sec)->rel_hdr) \
581 * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel \
582 > (bfd_vma)(rel_idx)) \
583 == (elf_section_data (sec)->rel_hdr.sh_entsize \
584 == (ABI_64_P (abfd) ? sizeof (Elf64_External_Rela) \
585 : sizeof (Elf32_External_Rela))))
587 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
588 from smaller values. Start with zero, widen, *then* decrement. */
589 #define MINUS_ONE (((bfd_vma)0) - 1)
590 #define MINUS_TWO (((bfd_vma)0) - 2)
592 /* The number of local .got entries we reserve. */
593 #define MIPS_RESERVED_GOTNO (2)
595 /* The offset of $gp from the beginning of the .got section. */
596 #define ELF_MIPS_GP_OFFSET(abfd) (0x7ff0)
598 /* The maximum size of the GOT for it to be addressable using 16-bit
600 #define MIPS_ELF_GOT_MAX_SIZE(abfd) (ELF_MIPS_GP_OFFSET(abfd) + 0x7fff)
602 /* Instructions which appear in a stub. */
603 #define STUB_LW(abfd) \
605 ? 0xdf998010 /* ld t9,0x8010(gp) */ \
606 : 0x8f998010)) /* lw t9,0x8010(gp) */
607 #define STUB_MOVE(abfd) \
609 ? 0x03e0782d /* daddu t7,ra */ \
610 : 0x03e07821)) /* addu t7,ra */
611 #define STUB_JALR 0x0320f809 /* jalr t9,ra */
612 #define STUB_LI16(abfd) \
614 ? 0x64180000 /* daddiu t8,zero,0 */ \
615 : 0x24180000)) /* addiu t8,zero,0 */
616 #define MIPS_FUNCTION_STUB_SIZE (16)
618 /* The name of the dynamic interpreter. This is put in the .interp
621 #define ELF_DYNAMIC_INTERPRETER(abfd) \
622 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
623 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
624 : "/usr/lib/libc.so.1")
627 #define MNAME(bfd,pre,pos) \
628 (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
629 #define ELF_R_SYM(bfd, i) \
630 (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
631 #define ELF_R_TYPE(bfd, i) \
632 (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
633 #define ELF_R_INFO(bfd, s, t) \
634 (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
636 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
637 #define ELF_R_SYM(bfd, i) \
639 #define ELF_R_TYPE(bfd, i) \
641 #define ELF_R_INFO(bfd, s, t) \
642 (ELF32_R_INFO (s, t))
645 /* The mips16 compiler uses a couple of special sections to handle
646 floating point arguments.
648 Section names that look like .mips16.fn.FNNAME contain stubs that
649 copy floating point arguments from the fp regs to the gp regs and
650 then jump to FNNAME. If any 32 bit function calls FNNAME, the
651 call should be redirected to the stub instead. If no 32 bit
652 function calls FNNAME, the stub should be discarded. We need to
653 consider any reference to the function, not just a call, because
654 if the address of the function is taken we will need the stub,
655 since the address might be passed to a 32 bit function.
657 Section names that look like .mips16.call.FNNAME contain stubs
658 that copy floating point arguments from the gp regs to the fp
659 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
660 then any 16 bit function that calls FNNAME should be redirected
661 to the stub instead. If FNNAME is not a 32 bit function, the
662 stub should be discarded.
664 .mips16.call.fp.FNNAME sections are similar, but contain stubs
665 which call FNNAME and then copy the return value from the fp regs
666 to the gp regs. These stubs store the return value in $18 while
667 calling FNNAME; any function which might call one of these stubs
668 must arrange to save $18 around the call. (This case is not
669 needed for 32 bit functions that call 16 bit functions, because
670 16 bit functions always return floating point values in both
673 Note that in all cases FNNAME might be defined statically.
674 Therefore, FNNAME is not used literally. Instead, the relocation
675 information will indicate which symbol the section is for.
677 We record any stubs that we find in the symbol table. */
679 #define FN_STUB ".mips16.fn."
680 #define CALL_STUB ".mips16.call."
681 #define CALL_FP_STUB ".mips16.call.fp."
683 /* Look up an entry in a MIPS ELF linker hash table. */
685 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
686 ((struct mips_elf_link_hash_entry *) \
687 elf_link_hash_lookup (&(table)->root, (string), (create), \
690 /* Traverse a MIPS ELF linker hash table. */
692 #define mips_elf_link_hash_traverse(table, func, info) \
693 (elf_link_hash_traverse \
695 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
698 /* Get the MIPS ELF linker hash table from a link_info structure. */
700 #define mips_elf_hash_table(p) \
701 ((struct mips_elf_link_hash_table *) ((p)->hash))
703 /* Create an entry in a MIPS ELF linker hash table. */
705 static struct bfd_hash_entry
*
706 mips_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
707 struct bfd_hash_table
*table
, const char *string
)
709 struct mips_elf_link_hash_entry
*ret
=
710 (struct mips_elf_link_hash_entry
*) entry
;
712 /* Allocate the structure if it has not already been allocated by a
715 ret
= bfd_hash_allocate (table
, sizeof (struct mips_elf_link_hash_entry
));
717 return (struct bfd_hash_entry
*) ret
;
719 /* Call the allocation method of the superclass. */
720 ret
= ((struct mips_elf_link_hash_entry
*)
721 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
725 /* Set local fields. */
726 memset (&ret
->esym
, 0, sizeof (EXTR
));
727 /* We use -2 as a marker to indicate that the information has
728 not been set. -1 means there is no associated ifd. */
730 ret
->possibly_dynamic_relocs
= 0;
731 ret
->readonly_reloc
= FALSE
;
732 ret
->no_fn_stub
= FALSE
;
734 ret
->need_fn_stub
= FALSE
;
735 ret
->call_stub
= NULL
;
736 ret
->call_fp_stub
= NULL
;
737 ret
->forced_local
= FALSE
;
740 return (struct bfd_hash_entry
*) ret
;
744 _bfd_mips_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
746 struct _mips_elf_section_data
*sdata
;
747 bfd_size_type amt
= sizeof (*sdata
);
749 sdata
= bfd_zalloc (abfd
, amt
);
752 sec
->used_by_bfd
= sdata
;
754 return _bfd_elf_new_section_hook (abfd
, sec
);
757 /* Read ECOFF debugging information from a .mdebug section into a
758 ecoff_debug_info structure. */
761 _bfd_mips_elf_read_ecoff_info (bfd
*abfd
, asection
*section
,
762 struct ecoff_debug_info
*debug
)
765 const struct ecoff_debug_swap
*swap
;
768 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
769 memset (debug
, 0, sizeof (*debug
));
771 ext_hdr
= bfd_malloc (swap
->external_hdr_size
);
772 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
775 if (! bfd_get_section_contents (abfd
, section
, ext_hdr
, 0,
776 swap
->external_hdr_size
))
779 symhdr
= &debug
->symbolic_header
;
780 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
782 /* The symbolic header contains absolute file offsets and sizes to
784 #define READ(ptr, offset, count, size, type) \
785 if (symhdr->count == 0) \
789 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
790 debug->ptr = bfd_malloc (amt); \
791 if (debug->ptr == NULL) \
793 if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0 \
794 || bfd_bread (debug->ptr, amt, abfd) != amt) \
798 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
799 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, void *);
800 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, void *);
801 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, void *);
802 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, void *);
803 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
805 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
806 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
807 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, void *);
808 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, void *);
809 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, void *);
819 if (debug
->line
!= NULL
)
821 if (debug
->external_dnr
!= NULL
)
822 free (debug
->external_dnr
);
823 if (debug
->external_pdr
!= NULL
)
824 free (debug
->external_pdr
);
825 if (debug
->external_sym
!= NULL
)
826 free (debug
->external_sym
);
827 if (debug
->external_opt
!= NULL
)
828 free (debug
->external_opt
);
829 if (debug
->external_aux
!= NULL
)
830 free (debug
->external_aux
);
831 if (debug
->ss
!= NULL
)
833 if (debug
->ssext
!= NULL
)
835 if (debug
->external_fdr
!= NULL
)
836 free (debug
->external_fdr
);
837 if (debug
->external_rfd
!= NULL
)
838 free (debug
->external_rfd
);
839 if (debug
->external_ext
!= NULL
)
840 free (debug
->external_ext
);
844 /* Swap RPDR (runtime procedure table entry) for output. */
847 ecoff_swap_rpdr_out (bfd
*abfd
, const RPDR
*in
, struct rpdr_ext
*ex
)
849 H_PUT_S32 (abfd
, in
->adr
, ex
->p_adr
);
850 H_PUT_32 (abfd
, in
->regmask
, ex
->p_regmask
);
851 H_PUT_32 (abfd
, in
->regoffset
, ex
->p_regoffset
);
852 H_PUT_32 (abfd
, in
->fregmask
, ex
->p_fregmask
);
853 H_PUT_32 (abfd
, in
->fregoffset
, ex
->p_fregoffset
);
854 H_PUT_32 (abfd
, in
->frameoffset
, ex
->p_frameoffset
);
856 H_PUT_16 (abfd
, in
->framereg
, ex
->p_framereg
);
857 H_PUT_16 (abfd
, in
->pcreg
, ex
->p_pcreg
);
859 H_PUT_32 (abfd
, in
->irpss
, ex
->p_irpss
);
861 H_PUT_S32 (abfd
, in
->exception_info
, ex
->p_exception_info
);
865 /* Create a runtime procedure table from the .mdebug section. */
868 mips_elf_create_procedure_table (void *handle
, bfd
*abfd
,
869 struct bfd_link_info
*info
, asection
*s
,
870 struct ecoff_debug_info
*debug
)
872 const struct ecoff_debug_swap
*swap
;
873 HDRR
*hdr
= &debug
->symbolic_header
;
875 struct rpdr_ext
*erp
;
877 struct pdr_ext
*epdr
;
878 struct sym_ext
*esym
;
883 unsigned long sindex
;
887 const char *no_name_func
= _("static procedure (no name)");
895 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
897 sindex
= strlen (no_name_func
) + 1;
901 size
= swap
->external_pdr_size
;
903 epdr
= bfd_malloc (size
* count
);
907 if (! _bfd_ecoff_get_accumulated_pdr (handle
, (bfd_byte
*) epdr
))
910 size
= sizeof (RPDR
);
911 rp
= rpdr
= bfd_malloc (size
* count
);
915 size
= sizeof (char *);
916 sv
= bfd_malloc (size
* count
);
920 count
= hdr
->isymMax
;
921 size
= swap
->external_sym_size
;
922 esym
= bfd_malloc (size
* count
);
926 if (! _bfd_ecoff_get_accumulated_sym (handle
, (bfd_byte
*) esym
))
930 ss
= bfd_malloc (count
);
933 if (! _bfd_ecoff_get_accumulated_ss (handle
, ss
))
937 for (i
= 0; i
< (unsigned long) count
; i
++, rp
++)
939 (*swap
->swap_pdr_in
) (abfd
, epdr
+ i
, &pdr
);
940 (*swap
->swap_sym_in
) (abfd
, &esym
[pdr
.isym
], &sym
);
942 rp
->regmask
= pdr
.regmask
;
943 rp
->regoffset
= pdr
.regoffset
;
944 rp
->fregmask
= pdr
.fregmask
;
945 rp
->fregoffset
= pdr
.fregoffset
;
946 rp
->frameoffset
= pdr
.frameoffset
;
947 rp
->framereg
= pdr
.framereg
;
948 rp
->pcreg
= pdr
.pcreg
;
950 sv
[i
] = ss
+ sym
.iss
;
951 sindex
+= strlen (sv
[i
]) + 1;
955 size
= sizeof (struct rpdr_ext
) * (count
+ 2) + sindex
;
956 size
= BFD_ALIGN (size
, 16);
957 rtproc
= bfd_alloc (abfd
, size
);
960 mips_elf_hash_table (info
)->procedure_count
= 0;
964 mips_elf_hash_table (info
)->procedure_count
= count
+ 2;
967 memset (erp
, 0, sizeof (struct rpdr_ext
));
969 str
= (char *) rtproc
+ sizeof (struct rpdr_ext
) * (count
+ 2);
970 strcpy (str
, no_name_func
);
971 str
+= strlen (no_name_func
) + 1;
972 for (i
= 0; i
< count
; i
++)
974 ecoff_swap_rpdr_out (abfd
, rpdr
+ i
, erp
+ i
);
976 str
+= strlen (sv
[i
]) + 1;
978 H_PUT_S32 (abfd
, -1, (erp
+ count
)->p_adr
);
980 /* Set the size and contents of .rtproc section. */
982 s
->contents
= rtproc
;
984 /* Skip this section later on (I don't think this currently
985 matters, but someday it might). */
986 s
->link_order_head
= NULL
;
1015 /* Check the mips16 stubs for a particular symbol, and see if we can
1019 mips_elf_check_mips16_stubs (struct mips_elf_link_hash_entry
*h
,
1020 void *data ATTRIBUTE_UNUSED
)
1022 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1023 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1025 if (h
->fn_stub
!= NULL
1026 && ! h
->need_fn_stub
)
1028 /* We don't need the fn_stub; the only references to this symbol
1029 are 16 bit calls. Clobber the size to 0 to prevent it from
1030 being included in the link. */
1031 h
->fn_stub
->_raw_size
= 0;
1032 h
->fn_stub
->_cooked_size
= 0;
1033 h
->fn_stub
->flags
&= ~SEC_RELOC
;
1034 h
->fn_stub
->reloc_count
= 0;
1035 h
->fn_stub
->flags
|= SEC_EXCLUDE
;
1038 if (h
->call_stub
!= NULL
1039 && h
->root
.other
== STO_MIPS16
)
1041 /* We don't need the call_stub; this is a 16 bit function, so
1042 calls from other 16 bit functions are OK. Clobber the size
1043 to 0 to prevent it from being included in the link. */
1044 h
->call_stub
->_raw_size
= 0;
1045 h
->call_stub
->_cooked_size
= 0;
1046 h
->call_stub
->flags
&= ~SEC_RELOC
;
1047 h
->call_stub
->reloc_count
= 0;
1048 h
->call_stub
->flags
|= SEC_EXCLUDE
;
1051 if (h
->call_fp_stub
!= NULL
1052 && h
->root
.other
== STO_MIPS16
)
1054 /* We don't need the call_stub; this is a 16 bit function, so
1055 calls from other 16 bit functions are OK. Clobber the size
1056 to 0 to prevent it from being included in the link. */
1057 h
->call_fp_stub
->_raw_size
= 0;
1058 h
->call_fp_stub
->_cooked_size
= 0;
1059 h
->call_fp_stub
->flags
&= ~SEC_RELOC
;
1060 h
->call_fp_stub
->reloc_count
= 0;
1061 h
->call_fp_stub
->flags
|= SEC_EXCLUDE
;
1067 bfd_reloc_status_type
1068 _bfd_mips_elf_gprel16_with_gp (bfd
*abfd
, asymbol
*symbol
,
1069 arelent
*reloc_entry
, asection
*input_section
,
1070 bfd_boolean relocatable
, void *data
, bfd_vma gp
)
1074 bfd_reloc_status_type status
;
1076 if (bfd_is_com_section (symbol
->section
))
1079 relocation
= symbol
->value
;
1081 relocation
+= symbol
->section
->output_section
->vma
;
1082 relocation
+= symbol
->section
->output_offset
;
1084 if (reloc_entry
->address
> input_section
->_cooked_size
)
1085 return bfd_reloc_outofrange
;
1087 /* Set val to the offset into the section or symbol. */
1088 val
= reloc_entry
->addend
;
1090 _bfd_mips_elf_sign_extend (val
, 16);
1092 /* Adjust val for the final section location and GP value. If we
1093 are producing relocatable output, we don't want to do this for
1094 an external symbol. */
1096 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1097 val
+= relocation
- gp
;
1099 if (reloc_entry
->howto
->partial_inplace
)
1101 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
1103 + reloc_entry
->address
);
1104 if (status
!= bfd_reloc_ok
)
1108 reloc_entry
->addend
= val
;
1111 reloc_entry
->address
+= input_section
->output_offset
;
1113 return bfd_reloc_ok
;
1116 /* Used to store a REL high-part relocation such as R_MIPS_HI16 or
1117 R_MIPS_GOT16. REL is the relocation, INPUT_SECTION is the section
1118 that contains the relocation field and DATA points to the start of
1123 struct mips_hi16
*next
;
1125 asection
*input_section
;
1129 /* FIXME: This should not be a static variable. */
1131 static struct mips_hi16
*mips_hi16_list
;
1133 /* A howto special_function for REL *HI16 relocations. We can only
1134 calculate the correct value once we've seen the partnering
1135 *LO16 relocation, so just save the information for later.
1137 The ABI requires that the *LO16 immediately follow the *HI16.
1138 However, as a GNU extension, we permit an arbitrary number of
1139 *HI16s to be associated with a single *LO16. This significantly
1140 simplies the relocation handling in gcc. */
1142 bfd_reloc_status_type
1143 _bfd_mips_elf_hi16_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
1144 asymbol
*symbol ATTRIBUTE_UNUSED
, void *data
,
1145 asection
*input_section
, bfd
*output_bfd
,
1146 char **error_message ATTRIBUTE_UNUSED
)
1148 struct mips_hi16
*n
;
1150 if (reloc_entry
->address
> input_section
->_cooked_size
)
1151 return bfd_reloc_outofrange
;
1153 n
= bfd_malloc (sizeof *n
);
1155 return bfd_reloc_outofrange
;
1157 n
->next
= mips_hi16_list
;
1159 n
->input_section
= input_section
;
1160 n
->rel
= *reloc_entry
;
1163 if (output_bfd
!= NULL
)
1164 reloc_entry
->address
+= input_section
->output_offset
;
1166 return bfd_reloc_ok
;
1169 /* A howto special_function for REL R_MIPS_GOT16 relocations. This is just
1170 like any other 16-bit relocation when applied to global symbols, but is
1171 treated in the same as R_MIPS_HI16 when applied to local symbols. */
1173 bfd_reloc_status_type
1174 _bfd_mips_elf_got16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1175 void *data
, asection
*input_section
,
1176 bfd
*output_bfd
, char **error_message
)
1178 if ((symbol
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
1179 || bfd_is_und_section (bfd_get_section (symbol
))
1180 || bfd_is_com_section (bfd_get_section (symbol
)))
1181 /* The relocation is against a global symbol. */
1182 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1183 input_section
, output_bfd
,
1186 return _bfd_mips_elf_hi16_reloc (abfd
, reloc_entry
, symbol
, data
,
1187 input_section
, output_bfd
, error_message
);
1190 /* A howto special_function for REL *LO16 relocations. The *LO16 itself
1191 is a straightforward 16 bit inplace relocation, but we must deal with
1192 any partnering high-part relocations as well. */
1194 bfd_reloc_status_type
1195 _bfd_mips_elf_lo16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1196 void *data
, asection
*input_section
,
1197 bfd
*output_bfd
, char **error_message
)
1201 if (reloc_entry
->address
> input_section
->_cooked_size
)
1202 return bfd_reloc_outofrange
;
1204 vallo
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1205 while (mips_hi16_list
!= NULL
)
1207 bfd_reloc_status_type ret
;
1208 struct mips_hi16
*hi
;
1210 hi
= mips_hi16_list
;
1212 /* R_MIPS_GOT16 relocations are something of a special case. We
1213 want to install the addend in the same way as for a R_MIPS_HI16
1214 relocation (with a rightshift of 16). However, since GOT16
1215 relocations can also be used with global symbols, their howto
1216 has a rightshift of 0. */
1217 if (hi
->rel
.howto
->type
== R_MIPS_GOT16
)
1218 hi
->rel
.howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, R_MIPS_HI16
, FALSE
);
1220 /* VALLO is a signed 16-bit number. Bias it by 0x8000 so that any
1221 carry or borrow will induce a change of +1 or -1 in the high part. */
1222 hi
->rel
.addend
+= (vallo
+ 0x8000) & 0xffff;
1224 ret
= _bfd_mips_elf_generic_reloc (abfd
, &hi
->rel
, symbol
, hi
->data
,
1225 hi
->input_section
, output_bfd
,
1227 if (ret
!= bfd_reloc_ok
)
1230 mips_hi16_list
= hi
->next
;
1234 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1235 input_section
, output_bfd
,
1239 /* A generic howto special_function. This calculates and installs the
1240 relocation itself, thus avoiding the oft-discussed problems in
1241 bfd_perform_relocation and bfd_install_relocation. */
1243 bfd_reloc_status_type
1244 _bfd_mips_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
1245 asymbol
*symbol
, void *data ATTRIBUTE_UNUSED
,
1246 asection
*input_section
, bfd
*output_bfd
,
1247 char **error_message ATTRIBUTE_UNUSED
)
1250 bfd_reloc_status_type status
;
1251 bfd_boolean relocatable
;
1253 relocatable
= (output_bfd
!= NULL
);
1255 if (reloc_entry
->address
> input_section
->_cooked_size
)
1256 return bfd_reloc_outofrange
;
1258 /* Build up the field adjustment in VAL. */
1260 if (!relocatable
|| (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1262 /* Either we're calculating the final field value or we have a
1263 relocation against a section symbol. Add in the section's
1264 offset or address. */
1265 val
+= symbol
->section
->output_section
->vma
;
1266 val
+= symbol
->section
->output_offset
;
1271 /* We're calculating the final field value. Add in the symbol's value
1272 and, if pc-relative, subtract the address of the field itself. */
1273 val
+= symbol
->value
;
1274 if (reloc_entry
->howto
->pc_relative
)
1276 val
-= input_section
->output_section
->vma
;
1277 val
-= input_section
->output_offset
;
1278 val
-= reloc_entry
->address
;
1282 /* VAL is now the final adjustment. If we're keeping this relocation
1283 in the output file, and if the relocation uses a separate addend,
1284 we just need to add VAL to that addend. Otherwise we need to add
1285 VAL to the relocation field itself. */
1286 if (relocatable
&& !reloc_entry
->howto
->partial_inplace
)
1287 reloc_entry
->addend
+= val
;
1290 /* Add in the separate addend, if any. */
1291 val
+= reloc_entry
->addend
;
1293 /* Add VAL to the relocation field. */
1294 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
1296 + reloc_entry
->address
);
1297 if (status
!= bfd_reloc_ok
)
1302 reloc_entry
->address
+= input_section
->output_offset
;
1304 return bfd_reloc_ok
;
1307 /* Swap an entry in a .gptab section. Note that these routines rely
1308 on the equivalence of the two elements of the union. */
1311 bfd_mips_elf32_swap_gptab_in (bfd
*abfd
, const Elf32_External_gptab
*ex
,
1314 in
->gt_entry
.gt_g_value
= H_GET_32 (abfd
, ex
->gt_entry
.gt_g_value
);
1315 in
->gt_entry
.gt_bytes
= H_GET_32 (abfd
, ex
->gt_entry
.gt_bytes
);
1319 bfd_mips_elf32_swap_gptab_out (bfd
*abfd
, const Elf32_gptab
*in
,
1320 Elf32_External_gptab
*ex
)
1322 H_PUT_32 (abfd
, in
->gt_entry
.gt_g_value
, ex
->gt_entry
.gt_g_value
);
1323 H_PUT_32 (abfd
, in
->gt_entry
.gt_bytes
, ex
->gt_entry
.gt_bytes
);
1327 bfd_elf32_swap_compact_rel_out (bfd
*abfd
, const Elf32_compact_rel
*in
,
1328 Elf32_External_compact_rel
*ex
)
1330 H_PUT_32 (abfd
, in
->id1
, ex
->id1
);
1331 H_PUT_32 (abfd
, in
->num
, ex
->num
);
1332 H_PUT_32 (abfd
, in
->id2
, ex
->id2
);
1333 H_PUT_32 (abfd
, in
->offset
, ex
->offset
);
1334 H_PUT_32 (abfd
, in
->reserved0
, ex
->reserved0
);
1335 H_PUT_32 (abfd
, in
->reserved1
, ex
->reserved1
);
1339 bfd_elf32_swap_crinfo_out (bfd
*abfd
, const Elf32_crinfo
*in
,
1340 Elf32_External_crinfo
*ex
)
1344 l
= (((in
->ctype
& CRINFO_CTYPE
) << CRINFO_CTYPE_SH
)
1345 | ((in
->rtype
& CRINFO_RTYPE
) << CRINFO_RTYPE_SH
)
1346 | ((in
->dist2to
& CRINFO_DIST2TO
) << CRINFO_DIST2TO_SH
)
1347 | ((in
->relvaddr
& CRINFO_RELVADDR
) << CRINFO_RELVADDR_SH
));
1348 H_PUT_32 (abfd
, l
, ex
->info
);
1349 H_PUT_32 (abfd
, in
->konst
, ex
->konst
);
1350 H_PUT_32 (abfd
, in
->vaddr
, ex
->vaddr
);
1353 /* A .reginfo section holds a single Elf32_RegInfo structure. These
1354 routines swap this structure in and out. They are used outside of
1355 BFD, so they are globally visible. */
1358 bfd_mips_elf32_swap_reginfo_in (bfd
*abfd
, const Elf32_External_RegInfo
*ex
,
1361 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1362 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1363 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1364 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1365 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1366 in
->ri_gp_value
= H_GET_32 (abfd
, ex
->ri_gp_value
);
1370 bfd_mips_elf32_swap_reginfo_out (bfd
*abfd
, const Elf32_RegInfo
*in
,
1371 Elf32_External_RegInfo
*ex
)
1373 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1374 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1375 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1376 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1377 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1378 H_PUT_32 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1381 /* In the 64 bit ABI, the .MIPS.options section holds register
1382 information in an Elf64_Reginfo structure. These routines swap
1383 them in and out. They are globally visible because they are used
1384 outside of BFD. These routines are here so that gas can call them
1385 without worrying about whether the 64 bit ABI has been included. */
1388 bfd_mips_elf64_swap_reginfo_in (bfd
*abfd
, const Elf64_External_RegInfo
*ex
,
1389 Elf64_Internal_RegInfo
*in
)
1391 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1392 in
->ri_pad
= H_GET_32 (abfd
, ex
->ri_pad
);
1393 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1394 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1395 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1396 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1397 in
->ri_gp_value
= H_GET_64 (abfd
, ex
->ri_gp_value
);
1401 bfd_mips_elf64_swap_reginfo_out (bfd
*abfd
, const Elf64_Internal_RegInfo
*in
,
1402 Elf64_External_RegInfo
*ex
)
1404 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1405 H_PUT_32 (abfd
, in
->ri_pad
, ex
->ri_pad
);
1406 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1407 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1408 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1409 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1410 H_PUT_64 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1413 /* Swap in an options header. */
1416 bfd_mips_elf_swap_options_in (bfd
*abfd
, const Elf_External_Options
*ex
,
1417 Elf_Internal_Options
*in
)
1419 in
->kind
= H_GET_8 (abfd
, ex
->kind
);
1420 in
->size
= H_GET_8 (abfd
, ex
->size
);
1421 in
->section
= H_GET_16 (abfd
, ex
->section
);
1422 in
->info
= H_GET_32 (abfd
, ex
->info
);
1425 /* Swap out an options header. */
1428 bfd_mips_elf_swap_options_out (bfd
*abfd
, const Elf_Internal_Options
*in
,
1429 Elf_External_Options
*ex
)
1431 H_PUT_8 (abfd
, in
->kind
, ex
->kind
);
1432 H_PUT_8 (abfd
, in
->size
, ex
->size
);
1433 H_PUT_16 (abfd
, in
->section
, ex
->section
);
1434 H_PUT_32 (abfd
, in
->info
, ex
->info
);
1437 /* This function is called via qsort() to sort the dynamic relocation
1438 entries by increasing r_symndx value. */
1441 sort_dynamic_relocs (const void *arg1
, const void *arg2
)
1443 Elf_Internal_Rela int_reloc1
;
1444 Elf_Internal_Rela int_reloc2
;
1446 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg1
, &int_reloc1
);
1447 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg2
, &int_reloc2
);
1449 return ELF32_R_SYM (int_reloc1
.r_info
) - ELF32_R_SYM (int_reloc2
.r_info
);
1452 /* Like sort_dynamic_relocs, but used for elf64 relocations. */
1455 sort_dynamic_relocs_64 (const void *arg1
, const void *arg2
)
1457 Elf_Internal_Rela int_reloc1
[3];
1458 Elf_Internal_Rela int_reloc2
[3];
1460 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1461 (reldyn_sorting_bfd
, arg1
, int_reloc1
);
1462 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1463 (reldyn_sorting_bfd
, arg2
, int_reloc2
);
1465 return (ELF64_R_SYM (int_reloc1
[0].r_info
)
1466 - ELF64_R_SYM (int_reloc2
[0].r_info
));
1470 /* This routine is used to write out ECOFF debugging external symbol
1471 information. It is called via mips_elf_link_hash_traverse. The
1472 ECOFF external symbol information must match the ELF external
1473 symbol information. Unfortunately, at this point we don't know
1474 whether a symbol is required by reloc information, so the two
1475 tables may wind up being different. We must sort out the external
1476 symbol information before we can set the final size of the .mdebug
1477 section, and we must set the size of the .mdebug section before we
1478 can relocate any sections, and we can't know which symbols are
1479 required by relocation until we relocate the sections.
1480 Fortunately, it is relatively unlikely that any symbol will be
1481 stripped but required by a reloc. In particular, it can not happen
1482 when generating a final executable. */
1485 mips_elf_output_extsym (struct mips_elf_link_hash_entry
*h
, void *data
)
1487 struct extsym_info
*einfo
= data
;
1489 asection
*sec
, *output_section
;
1491 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1492 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1494 if (h
->root
.indx
== -2)
1496 else if (((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1497 || (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
1498 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1499 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
1501 else if (einfo
->info
->strip
== strip_all
1502 || (einfo
->info
->strip
== strip_some
1503 && bfd_hash_lookup (einfo
->info
->keep_hash
,
1504 h
->root
.root
.root
.string
,
1505 FALSE
, FALSE
) == NULL
))
1513 if (h
->esym
.ifd
== -2)
1516 h
->esym
.cobol_main
= 0;
1517 h
->esym
.weakext
= 0;
1518 h
->esym
.reserved
= 0;
1519 h
->esym
.ifd
= ifdNil
;
1520 h
->esym
.asym
.value
= 0;
1521 h
->esym
.asym
.st
= stGlobal
;
1523 if (h
->root
.root
.type
== bfd_link_hash_undefined
1524 || h
->root
.root
.type
== bfd_link_hash_undefweak
)
1528 /* Use undefined class. Also, set class and type for some
1530 name
= h
->root
.root
.root
.string
;
1531 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
1532 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
1534 h
->esym
.asym
.sc
= scData
;
1535 h
->esym
.asym
.st
= stLabel
;
1536 h
->esym
.asym
.value
= 0;
1538 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
1540 h
->esym
.asym
.sc
= scAbs
;
1541 h
->esym
.asym
.st
= stLabel
;
1542 h
->esym
.asym
.value
=
1543 mips_elf_hash_table (einfo
->info
)->procedure_count
;
1545 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (einfo
->abfd
))
1547 h
->esym
.asym
.sc
= scAbs
;
1548 h
->esym
.asym
.st
= stLabel
;
1549 h
->esym
.asym
.value
= elf_gp (einfo
->abfd
);
1552 h
->esym
.asym
.sc
= scUndefined
;
1554 else if (h
->root
.root
.type
!= bfd_link_hash_defined
1555 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
1556 h
->esym
.asym
.sc
= scAbs
;
1561 sec
= h
->root
.root
.u
.def
.section
;
1562 output_section
= sec
->output_section
;
1564 /* When making a shared library and symbol h is the one from
1565 the another shared library, OUTPUT_SECTION may be null. */
1566 if (output_section
== NULL
)
1567 h
->esym
.asym
.sc
= scUndefined
;
1570 name
= bfd_section_name (output_section
->owner
, output_section
);
1572 if (strcmp (name
, ".text") == 0)
1573 h
->esym
.asym
.sc
= scText
;
1574 else if (strcmp (name
, ".data") == 0)
1575 h
->esym
.asym
.sc
= scData
;
1576 else if (strcmp (name
, ".sdata") == 0)
1577 h
->esym
.asym
.sc
= scSData
;
1578 else if (strcmp (name
, ".rodata") == 0
1579 || strcmp (name
, ".rdata") == 0)
1580 h
->esym
.asym
.sc
= scRData
;
1581 else if (strcmp (name
, ".bss") == 0)
1582 h
->esym
.asym
.sc
= scBss
;
1583 else if (strcmp (name
, ".sbss") == 0)
1584 h
->esym
.asym
.sc
= scSBss
;
1585 else if (strcmp (name
, ".init") == 0)
1586 h
->esym
.asym
.sc
= scInit
;
1587 else if (strcmp (name
, ".fini") == 0)
1588 h
->esym
.asym
.sc
= scFini
;
1590 h
->esym
.asym
.sc
= scAbs
;
1594 h
->esym
.asym
.reserved
= 0;
1595 h
->esym
.asym
.index
= indexNil
;
1598 if (h
->root
.root
.type
== bfd_link_hash_common
)
1599 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
1600 else if (h
->root
.root
.type
== bfd_link_hash_defined
1601 || h
->root
.root
.type
== bfd_link_hash_defweak
)
1603 if (h
->esym
.asym
.sc
== scCommon
)
1604 h
->esym
.asym
.sc
= scBss
;
1605 else if (h
->esym
.asym
.sc
== scSCommon
)
1606 h
->esym
.asym
.sc
= scSBss
;
1608 sec
= h
->root
.root
.u
.def
.section
;
1609 output_section
= sec
->output_section
;
1610 if (output_section
!= NULL
)
1611 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
1612 + sec
->output_offset
1613 + output_section
->vma
);
1615 h
->esym
.asym
.value
= 0;
1617 else if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
1619 struct mips_elf_link_hash_entry
*hd
= h
;
1620 bfd_boolean no_fn_stub
= h
->no_fn_stub
;
1622 while (hd
->root
.root
.type
== bfd_link_hash_indirect
)
1624 hd
= (struct mips_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
1625 no_fn_stub
= no_fn_stub
|| hd
->no_fn_stub
;
1630 /* Set type and value for a symbol with a function stub. */
1631 h
->esym
.asym
.st
= stProc
;
1632 sec
= hd
->root
.root
.u
.def
.section
;
1634 h
->esym
.asym
.value
= 0;
1637 output_section
= sec
->output_section
;
1638 if (output_section
!= NULL
)
1639 h
->esym
.asym
.value
= (hd
->root
.plt
.offset
1640 + sec
->output_offset
1641 + output_section
->vma
);
1643 h
->esym
.asym
.value
= 0;
1651 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
1652 h
->root
.root
.root
.string
,
1655 einfo
->failed
= TRUE
;
1662 /* A comparison routine used to sort .gptab entries. */
1665 gptab_compare (const void *p1
, const void *p2
)
1667 const Elf32_gptab
*a1
= p1
;
1668 const Elf32_gptab
*a2
= p2
;
1670 return a1
->gt_entry
.gt_g_value
- a2
->gt_entry
.gt_g_value
;
1673 /* Functions to manage the got entry hash table. */
1675 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
1678 static INLINE hashval_t
1679 mips_elf_hash_bfd_vma (bfd_vma addr
)
1682 return addr
+ (addr
>> 32);
1688 /* got_entries only match if they're identical, except for gotidx, so
1689 use all fields to compute the hash, and compare the appropriate
1693 mips_elf_got_entry_hash (const void *entry_
)
1695 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
1697 return entry
->symndx
1698 + (! entry
->abfd
? mips_elf_hash_bfd_vma (entry
->d
.address
)
1700 + (entry
->symndx
>= 0 ? mips_elf_hash_bfd_vma (entry
->d
.addend
)
1701 : entry
->d
.h
->root
.root
.root
.hash
));
1705 mips_elf_got_entry_eq (const void *entry1
, const void *entry2
)
1707 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
1708 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
1710 return e1
->abfd
== e2
->abfd
&& e1
->symndx
== e2
->symndx
1711 && (! e1
->abfd
? e1
->d
.address
== e2
->d
.address
1712 : e1
->symndx
>= 0 ? e1
->d
.addend
== e2
->d
.addend
1713 : e1
->d
.h
== e2
->d
.h
);
1716 /* multi_got_entries are still a match in the case of global objects,
1717 even if the input bfd in which they're referenced differs, so the
1718 hash computation and compare functions are adjusted
1722 mips_elf_multi_got_entry_hash (const void *entry_
)
1724 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
1726 return entry
->symndx
1728 ? mips_elf_hash_bfd_vma (entry
->d
.address
)
1729 : entry
->symndx
>= 0
1731 + mips_elf_hash_bfd_vma (entry
->d
.addend
))
1732 : entry
->d
.h
->root
.root
.root
.hash
);
1736 mips_elf_multi_got_entry_eq (const void *entry1
, const void *entry2
)
1738 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
1739 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
1741 return e1
->symndx
== e2
->symndx
1742 && (e1
->symndx
>= 0 ? e1
->abfd
== e2
->abfd
&& e1
->d
.addend
== e2
->d
.addend
1743 : e1
->abfd
== NULL
|| e2
->abfd
== NULL
1744 ? e1
->abfd
== e2
->abfd
&& e1
->d
.address
== e2
->d
.address
1745 : e1
->d
.h
== e2
->d
.h
);
1748 /* Returns the dynamic relocation section for DYNOBJ. */
1751 mips_elf_rel_dyn_section (bfd
*dynobj
, bfd_boolean create_p
)
1753 static const char dname
[] = ".rel.dyn";
1756 sreloc
= bfd_get_section_by_name (dynobj
, dname
);
1757 if (sreloc
== NULL
&& create_p
)
1759 sreloc
= bfd_make_section (dynobj
, dname
);
1761 || ! bfd_set_section_flags (dynobj
, sreloc
,
1766 | SEC_LINKER_CREATED
1768 || ! bfd_set_section_alignment (dynobj
, sreloc
,
1769 MIPS_ELF_LOG_FILE_ALIGN (dynobj
)))
1775 /* Returns the GOT section for ABFD. */
1778 mips_elf_got_section (bfd
*abfd
, bfd_boolean maybe_excluded
)
1780 asection
*sgot
= bfd_get_section_by_name (abfd
, ".got");
1782 || (! maybe_excluded
&& (sgot
->flags
& SEC_EXCLUDE
) != 0))
1787 /* Returns the GOT information associated with the link indicated by
1788 INFO. If SGOTP is non-NULL, it is filled in with the GOT
1791 static struct mips_got_info
*
1792 mips_elf_got_info (bfd
*abfd
, asection
**sgotp
)
1795 struct mips_got_info
*g
;
1797 sgot
= mips_elf_got_section (abfd
, TRUE
);
1798 BFD_ASSERT (sgot
!= NULL
);
1799 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
1800 g
= mips_elf_section_data (sgot
)->u
.got_info
;
1801 BFD_ASSERT (g
!= NULL
);
1804 *sgotp
= (sgot
->flags
& SEC_EXCLUDE
) == 0 ? sgot
: NULL
;
1809 /* Returns the GOT offset at which the indicated address can be found.
1810 If there is not yet a GOT entry for this value, create one. Returns
1811 -1 if no satisfactory GOT offset can be found. */
1814 mips_elf_local_got_index (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
1818 struct mips_got_info
*g
;
1819 struct mips_got_entry
*entry
;
1821 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1823 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
, value
);
1825 return entry
->gotidx
;
1830 /* Returns the GOT index for the global symbol indicated by H. */
1833 mips_elf_global_got_index (bfd
*abfd
, bfd
*ibfd
, struct elf_link_hash_entry
*h
)
1837 struct mips_got_info
*g
, *gg
;
1838 long global_got_dynindx
= 0;
1840 gg
= g
= mips_elf_got_info (abfd
, &sgot
);
1841 if (g
->bfd2got
&& ibfd
)
1843 struct mips_got_entry e
, *p
;
1845 BFD_ASSERT (h
->dynindx
>= 0);
1847 g
= mips_elf_got_for_ibfd (g
, ibfd
);
1852 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
1854 p
= htab_find (g
->got_entries
, &e
);
1856 BFD_ASSERT (p
->gotidx
> 0);
1861 if (gg
->global_gotsym
!= NULL
)
1862 global_got_dynindx
= gg
->global_gotsym
->dynindx
;
1864 /* Once we determine the global GOT entry with the lowest dynamic
1865 symbol table index, we must put all dynamic symbols with greater
1866 indices into the GOT. That makes it easy to calculate the GOT
1868 BFD_ASSERT (h
->dynindx
>= global_got_dynindx
);
1869 index
= ((h
->dynindx
- global_got_dynindx
+ g
->local_gotno
)
1870 * MIPS_ELF_GOT_SIZE (abfd
));
1871 BFD_ASSERT (index
< sgot
->_raw_size
);
1876 /* Find a GOT entry that is within 32KB of the VALUE. These entries
1877 are supposed to be placed at small offsets in the GOT, i.e.,
1878 within 32KB of GP. Return the index into the GOT for this page,
1879 and store the offset from this entry to the desired address in
1880 OFFSETP, if it is non-NULL. */
1883 mips_elf_got_page (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
1884 bfd_vma value
, bfd_vma
*offsetp
)
1887 struct mips_got_info
*g
;
1889 struct mips_got_entry
*entry
;
1891 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1893 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
,
1895 & (~(bfd_vma
)0xffff));
1900 index
= entry
->gotidx
;
1903 *offsetp
= value
- entry
->d
.address
;
1908 /* Find a GOT entry whose higher-order 16 bits are the same as those
1909 for value. Return the index into the GOT for this entry. */
1912 mips_elf_got16_entry (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
1913 bfd_vma value
, bfd_boolean external
)
1916 struct mips_got_info
*g
;
1917 struct mips_got_entry
*entry
;
1921 /* Although the ABI says that it is "the high-order 16 bits" that we
1922 want, it is really the %high value. The complete value is
1923 calculated with a `addiu' of a LO16 relocation, just as with a
1925 value
= mips_elf_high (value
) << 16;
1928 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1930 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
, value
);
1932 return entry
->gotidx
;
1937 /* Returns the offset for the entry at the INDEXth position
1941 mips_elf_got_offset_from_index (bfd
*dynobj
, bfd
*output_bfd
,
1942 bfd
*input_bfd
, bfd_vma index
)
1946 struct mips_got_info
*g
;
1948 g
= mips_elf_got_info (dynobj
, &sgot
);
1949 gp
= _bfd_get_gp_value (output_bfd
)
1950 + mips_elf_adjust_gp (output_bfd
, g
, input_bfd
);
1952 return sgot
->output_section
->vma
+ sgot
->output_offset
+ index
- gp
;
1955 /* Create a local GOT entry for VALUE. Return the index of the entry,
1956 or -1 if it could not be created. */
1958 static struct mips_got_entry
*
1959 mips_elf_create_local_got_entry (bfd
*abfd
, bfd
*ibfd
,
1960 struct mips_got_info
*gg
,
1961 asection
*sgot
, bfd_vma value
)
1963 struct mips_got_entry entry
, **loc
;
1964 struct mips_got_info
*g
;
1968 entry
.d
.address
= value
;
1970 g
= mips_elf_got_for_ibfd (gg
, ibfd
);
1973 g
= mips_elf_got_for_ibfd (gg
, abfd
);
1974 BFD_ASSERT (g
!= NULL
);
1977 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
1982 entry
.gotidx
= MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
++;
1984 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
1989 memcpy (*loc
, &entry
, sizeof entry
);
1991 if (g
->assigned_gotno
>= g
->local_gotno
)
1993 (*loc
)->gotidx
= -1;
1994 /* We didn't allocate enough space in the GOT. */
1995 (*_bfd_error_handler
)
1996 (_("not enough GOT space for local GOT entries"));
1997 bfd_set_error (bfd_error_bad_value
);
2001 MIPS_ELF_PUT_WORD (abfd
, value
,
2002 (sgot
->contents
+ entry
.gotidx
));
2007 /* Sort the dynamic symbol table so that symbols that need GOT entries
2008 appear towards the end. This reduces the amount of GOT space
2009 required. MAX_LOCAL is used to set the number of local symbols
2010 known to be in the dynamic symbol table. During
2011 _bfd_mips_elf_size_dynamic_sections, this value is 1. Afterward, the
2012 section symbols are added and the count is higher. */
2015 mips_elf_sort_hash_table (struct bfd_link_info
*info
, unsigned long max_local
)
2017 struct mips_elf_hash_sort_data hsd
;
2018 struct mips_got_info
*g
;
2021 dynobj
= elf_hash_table (info
)->dynobj
;
2023 g
= mips_elf_got_info (dynobj
, NULL
);
2026 hsd
.max_unref_got_dynindx
=
2027 hsd
.min_got_dynindx
= elf_hash_table (info
)->dynsymcount
2028 /* In the multi-got case, assigned_gotno of the master got_info
2029 indicate the number of entries that aren't referenced in the
2030 primary GOT, but that must have entries because there are
2031 dynamic relocations that reference it. Since they aren't
2032 referenced, we move them to the end of the GOT, so that they
2033 don't prevent other entries that are referenced from getting
2034 too large offsets. */
2035 - (g
->next
? g
->assigned_gotno
: 0);
2036 hsd
.max_non_got_dynindx
= max_local
;
2037 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table
*)
2038 elf_hash_table (info
)),
2039 mips_elf_sort_hash_table_f
,
2042 /* There should have been enough room in the symbol table to
2043 accommodate both the GOT and non-GOT symbols. */
2044 BFD_ASSERT (hsd
.max_non_got_dynindx
<= hsd
.min_got_dynindx
);
2045 BFD_ASSERT ((unsigned long)hsd
.max_unref_got_dynindx
2046 <= elf_hash_table (info
)->dynsymcount
);
2048 /* Now we know which dynamic symbol has the lowest dynamic symbol
2049 table index in the GOT. */
2050 g
->global_gotsym
= hsd
.low
;
2055 /* If H needs a GOT entry, assign it the highest available dynamic
2056 index. Otherwise, assign it the lowest available dynamic
2060 mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry
*h
, void *data
)
2062 struct mips_elf_hash_sort_data
*hsd
= data
;
2064 if (h
->root
.root
.type
== bfd_link_hash_warning
)
2065 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2067 /* Symbols without dynamic symbol table entries aren't interesting
2069 if (h
->root
.dynindx
== -1)
2072 /* Global symbols that need GOT entries that are not explicitly
2073 referenced are marked with got offset 2. Those that are
2074 referenced get a 1, and those that don't need GOT entries get
2076 if (h
->root
.got
.offset
== 2)
2078 if (hsd
->max_unref_got_dynindx
== hsd
->min_got_dynindx
)
2079 hsd
->low
= (struct elf_link_hash_entry
*) h
;
2080 h
->root
.dynindx
= hsd
->max_unref_got_dynindx
++;
2082 else if (h
->root
.got
.offset
!= 1)
2083 h
->root
.dynindx
= hsd
->max_non_got_dynindx
++;
2086 h
->root
.dynindx
= --hsd
->min_got_dynindx
;
2087 hsd
->low
= (struct elf_link_hash_entry
*) h
;
2093 /* If H is a symbol that needs a global GOT entry, but has a dynamic
2094 symbol table index lower than any we've seen to date, record it for
2098 mips_elf_record_global_got_symbol (struct elf_link_hash_entry
*h
,
2099 bfd
*abfd
, struct bfd_link_info
*info
,
2100 struct mips_got_info
*g
)
2102 struct mips_got_entry entry
, **loc
;
2104 /* A global symbol in the GOT must also be in the dynamic symbol
2106 if (h
->dynindx
== -1)
2108 switch (ELF_ST_VISIBILITY (h
->other
))
2112 _bfd_mips_elf_hide_symbol (info
, h
, TRUE
);
2115 if (!bfd_elf_link_record_dynamic_symbol (info
, h
))
2121 entry
.d
.h
= (struct mips_elf_link_hash_entry
*) h
;
2123 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
2126 /* If we've already marked this entry as needing GOT space, we don't
2127 need to do it again. */
2131 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2137 memcpy (*loc
, &entry
, sizeof entry
);
2139 if (h
->got
.offset
!= MINUS_ONE
)
2142 /* By setting this to a value other than -1, we are indicating that
2143 there needs to be a GOT entry for H. Avoid using zero, as the
2144 generic ELF copy_indirect_symbol tests for <= 0. */
2150 /* Reserve space in G for a GOT entry containing the value of symbol
2151 SYMNDX in input bfd ABDF, plus ADDEND. */
2154 mips_elf_record_local_got_symbol (bfd
*abfd
, long symndx
, bfd_vma addend
,
2155 struct mips_got_info
*g
)
2157 struct mips_got_entry entry
, **loc
;
2160 entry
.symndx
= symndx
;
2161 entry
.d
.addend
= addend
;
2162 loc
= (struct mips_got_entry
**)
2163 htab_find_slot (g
->got_entries
, &entry
, INSERT
);
2168 entry
.gotidx
= g
->local_gotno
++;
2170 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2175 memcpy (*loc
, &entry
, sizeof entry
);
2180 /* Compute the hash value of the bfd in a bfd2got hash entry. */
2183 mips_elf_bfd2got_entry_hash (const void *entry_
)
2185 const struct mips_elf_bfd2got_hash
*entry
2186 = (struct mips_elf_bfd2got_hash
*)entry_
;
2188 return entry
->bfd
->id
;
2191 /* Check whether two hash entries have the same bfd. */
2194 mips_elf_bfd2got_entry_eq (const void *entry1
, const void *entry2
)
2196 const struct mips_elf_bfd2got_hash
*e1
2197 = (const struct mips_elf_bfd2got_hash
*)entry1
;
2198 const struct mips_elf_bfd2got_hash
*e2
2199 = (const struct mips_elf_bfd2got_hash
*)entry2
;
2201 return e1
->bfd
== e2
->bfd
;
2204 /* In a multi-got link, determine the GOT to be used for IBDF. G must
2205 be the master GOT data. */
2207 static struct mips_got_info
*
2208 mips_elf_got_for_ibfd (struct mips_got_info
*g
, bfd
*ibfd
)
2210 struct mips_elf_bfd2got_hash e
, *p
;
2216 p
= htab_find (g
->bfd2got
, &e
);
2217 return p
? p
->g
: NULL
;
2220 /* Create one separate got for each bfd that has entries in the global
2221 got, such that we can tell how many local and global entries each
2225 mips_elf_make_got_per_bfd (void **entryp
, void *p
)
2227 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2228 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
2229 htab_t bfd2got
= arg
->bfd2got
;
2230 struct mips_got_info
*g
;
2231 struct mips_elf_bfd2got_hash bfdgot_entry
, *bfdgot
;
2234 /* Find the got_info for this GOT entry's input bfd. Create one if
2236 bfdgot_entry
.bfd
= entry
->abfd
;
2237 bfdgotp
= htab_find_slot (bfd2got
, &bfdgot_entry
, INSERT
);
2238 bfdgot
= (struct mips_elf_bfd2got_hash
*)*bfdgotp
;
2244 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
2245 (arg
->obfd
, sizeof (struct mips_elf_bfd2got_hash
));
2255 bfdgot
->bfd
= entry
->abfd
;
2256 bfdgot
->g
= g
= (struct mips_got_info
*)
2257 bfd_alloc (arg
->obfd
, sizeof (struct mips_got_info
));
2264 g
->global_gotsym
= NULL
;
2265 g
->global_gotno
= 0;
2267 g
->assigned_gotno
= -1;
2268 g
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
2269 mips_elf_multi_got_entry_eq
, NULL
);
2270 if (g
->got_entries
== NULL
)
2280 /* Insert the GOT entry in the bfd's got entry hash table. */
2281 entryp
= htab_find_slot (g
->got_entries
, entry
, INSERT
);
2282 if (*entryp
!= NULL
)
2287 if (entry
->symndx
>= 0 || entry
->d
.h
->forced_local
)
2295 /* Attempt to merge gots of different input bfds. Try to use as much
2296 as possible of the primary got, since it doesn't require explicit
2297 dynamic relocations, but don't use bfds that would reference global
2298 symbols out of the addressable range. Failing the primary got,
2299 attempt to merge with the current got, or finish the current got
2300 and then make make the new got current. */
2303 mips_elf_merge_gots (void **bfd2got_
, void *p
)
2305 struct mips_elf_bfd2got_hash
*bfd2got
2306 = (struct mips_elf_bfd2got_hash
*)*bfd2got_
;
2307 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
2308 unsigned int lcount
= bfd2got
->g
->local_gotno
;
2309 unsigned int gcount
= bfd2got
->g
->global_gotno
;
2310 unsigned int maxcnt
= arg
->max_count
;
2312 /* If we don't have a primary GOT and this is not too big, use it as
2313 a starting point for the primary GOT. */
2314 if (! arg
->primary
&& lcount
+ gcount
<= maxcnt
)
2316 arg
->primary
= bfd2got
->g
;
2317 arg
->primary_count
= lcount
+ gcount
;
2319 /* If it looks like we can merge this bfd's entries with those of
2320 the primary, merge them. The heuristics is conservative, but we
2321 don't have to squeeze it too hard. */
2322 else if (arg
->primary
2323 && (arg
->primary_count
+ lcount
+ gcount
) <= maxcnt
)
2325 struct mips_got_info
*g
= bfd2got
->g
;
2326 int old_lcount
= arg
->primary
->local_gotno
;
2327 int old_gcount
= arg
->primary
->global_gotno
;
2329 bfd2got
->g
= arg
->primary
;
2331 htab_traverse (g
->got_entries
,
2332 mips_elf_make_got_per_bfd
,
2334 if (arg
->obfd
== NULL
)
2337 htab_delete (g
->got_entries
);
2338 /* We don't have to worry about releasing memory of the actual
2339 got entries, since they're all in the master got_entries hash
2342 BFD_ASSERT (old_lcount
+ lcount
>= arg
->primary
->local_gotno
);
2343 BFD_ASSERT (old_gcount
+ gcount
>= arg
->primary
->global_gotno
);
2345 arg
->primary_count
= arg
->primary
->local_gotno
2346 + arg
->primary
->global_gotno
;
2348 /* If we can merge with the last-created got, do it. */
2349 else if (arg
->current
2350 && arg
->current_count
+ lcount
+ gcount
<= maxcnt
)
2352 struct mips_got_info
*g
= bfd2got
->g
;
2353 int old_lcount
= arg
->current
->local_gotno
;
2354 int old_gcount
= arg
->current
->global_gotno
;
2356 bfd2got
->g
= arg
->current
;
2358 htab_traverse (g
->got_entries
,
2359 mips_elf_make_got_per_bfd
,
2361 if (arg
->obfd
== NULL
)
2364 htab_delete (g
->got_entries
);
2366 BFD_ASSERT (old_lcount
+ lcount
>= arg
->current
->local_gotno
);
2367 BFD_ASSERT (old_gcount
+ gcount
>= arg
->current
->global_gotno
);
2369 arg
->current_count
= arg
->current
->local_gotno
2370 + arg
->current
->global_gotno
;
2372 /* Well, we couldn't merge, so create a new GOT. Don't check if it
2373 fits; if it turns out that it doesn't, we'll get relocation
2374 overflows anyway. */
2377 bfd2got
->g
->next
= arg
->current
;
2378 arg
->current
= bfd2got
->g
;
2380 arg
->current_count
= lcount
+ gcount
;
2386 /* If passed a NULL mips_got_info in the argument, set the marker used
2387 to tell whether a global symbol needs a got entry (in the primary
2388 got) to the given VALUE.
2390 If passed a pointer G to a mips_got_info in the argument (it must
2391 not be the primary GOT), compute the offset from the beginning of
2392 the (primary) GOT section to the entry in G corresponding to the
2393 global symbol. G's assigned_gotno must contain the index of the
2394 first available global GOT entry in G. VALUE must contain the size
2395 of a GOT entry in bytes. For each global GOT entry that requires a
2396 dynamic relocation, NEEDED_RELOCS is incremented, and the symbol is
2397 marked as not eligible for lazy resolution through a function
2400 mips_elf_set_global_got_offset (void **entryp
, void *p
)
2402 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2403 struct mips_elf_set_global_got_offset_arg
*arg
2404 = (struct mips_elf_set_global_got_offset_arg
*)p
;
2405 struct mips_got_info
*g
= arg
->g
;
2407 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1
2408 && entry
->d
.h
->root
.dynindx
!= -1)
2412 BFD_ASSERT (g
->global_gotsym
== NULL
);
2414 entry
->gotidx
= arg
->value
* (long) g
->assigned_gotno
++;
2415 if (arg
->info
->shared
2416 || (elf_hash_table (arg
->info
)->dynamic_sections_created
2417 && ((entry
->d
.h
->root
.elf_link_hash_flags
2418 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0)
2419 && ((entry
->d
.h
->root
.elf_link_hash_flags
2420 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
2421 ++arg
->needed_relocs
;
2424 entry
->d
.h
->root
.got
.offset
= arg
->value
;
2430 /* Mark any global symbols referenced in the GOT we are iterating over
2431 as inelligible for lazy resolution stubs. */
2433 mips_elf_set_no_stub (void **entryp
, void *p ATTRIBUTE_UNUSED
)
2435 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2437 if (entry
->abfd
!= NULL
2438 && entry
->symndx
== -1
2439 && entry
->d
.h
->root
.dynindx
!= -1)
2440 entry
->d
.h
->no_fn_stub
= TRUE
;
2445 /* Follow indirect and warning hash entries so that each got entry
2446 points to the final symbol definition. P must point to a pointer
2447 to the hash table we're traversing. Since this traversal may
2448 modify the hash table, we set this pointer to NULL to indicate
2449 we've made a potentially-destructive change to the hash table, so
2450 the traversal must be restarted. */
2452 mips_elf_resolve_final_got_entry (void **entryp
, void *p
)
2454 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2455 htab_t got_entries
= *(htab_t
*)p
;
2457 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1)
2459 struct mips_elf_link_hash_entry
*h
= entry
->d
.h
;
2461 while (h
->root
.root
.type
== bfd_link_hash_indirect
2462 || h
->root
.root
.type
== bfd_link_hash_warning
)
2463 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2465 if (entry
->d
.h
== h
)
2470 /* If we can't find this entry with the new bfd hash, re-insert
2471 it, and get the traversal restarted. */
2472 if (! htab_find (got_entries
, entry
))
2474 htab_clear_slot (got_entries
, entryp
);
2475 entryp
= htab_find_slot (got_entries
, entry
, INSERT
);
2478 /* Abort the traversal, since the whole table may have
2479 moved, and leave it up to the parent to restart the
2481 *(htab_t
*)p
= NULL
;
2484 /* We might want to decrement the global_gotno count, but it's
2485 either too early or too late for that at this point. */
2491 /* Turn indirect got entries in a got_entries table into their final
2494 mips_elf_resolve_final_got_entries (struct mips_got_info
*g
)
2500 got_entries
= g
->got_entries
;
2502 htab_traverse (got_entries
,
2503 mips_elf_resolve_final_got_entry
,
2506 while (got_entries
== NULL
);
2509 /* Return the offset of an input bfd IBFD's GOT from the beginning of
2512 mips_elf_adjust_gp (bfd
*abfd
, struct mips_got_info
*g
, bfd
*ibfd
)
2514 if (g
->bfd2got
== NULL
)
2517 g
= mips_elf_got_for_ibfd (g
, ibfd
);
2521 BFD_ASSERT (g
->next
);
2525 return (g
->local_gotno
+ g
->global_gotno
) * MIPS_ELF_GOT_SIZE (abfd
);
2528 /* Turn a single GOT that is too big for 16-bit addressing into
2529 a sequence of GOTs, each one 16-bit addressable. */
2532 mips_elf_multi_got (bfd
*abfd
, struct bfd_link_info
*info
,
2533 struct mips_got_info
*g
, asection
*got
,
2534 bfd_size_type pages
)
2536 struct mips_elf_got_per_bfd_arg got_per_bfd_arg
;
2537 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
2538 struct mips_got_info
*gg
;
2539 unsigned int assign
;
2541 g
->bfd2got
= htab_try_create (1, mips_elf_bfd2got_entry_hash
,
2542 mips_elf_bfd2got_entry_eq
, NULL
);
2543 if (g
->bfd2got
== NULL
)
2546 got_per_bfd_arg
.bfd2got
= g
->bfd2got
;
2547 got_per_bfd_arg
.obfd
= abfd
;
2548 got_per_bfd_arg
.info
= info
;
2550 /* Count how many GOT entries each input bfd requires, creating a
2551 map from bfd to got info while at that. */
2552 mips_elf_resolve_final_got_entries (g
);
2553 htab_traverse (g
->got_entries
, mips_elf_make_got_per_bfd
, &got_per_bfd_arg
);
2554 if (got_per_bfd_arg
.obfd
== NULL
)
2557 got_per_bfd_arg
.current
= NULL
;
2558 got_per_bfd_arg
.primary
= NULL
;
2559 /* Taking out PAGES entries is a worst-case estimate. We could
2560 compute the maximum number of pages that each separate input bfd
2561 uses, but it's probably not worth it. */
2562 got_per_bfd_arg
.max_count
= ((MIPS_ELF_GOT_MAX_SIZE (abfd
)
2563 / MIPS_ELF_GOT_SIZE (abfd
))
2564 - MIPS_RESERVED_GOTNO
- pages
);
2566 /* Try to merge the GOTs of input bfds together, as long as they
2567 don't seem to exceed the maximum GOT size, choosing one of them
2568 to be the primary GOT. */
2569 htab_traverse (g
->bfd2got
, mips_elf_merge_gots
, &got_per_bfd_arg
);
2570 if (got_per_bfd_arg
.obfd
== NULL
)
2573 /* If we find any suitable primary GOT, create an empty one. */
2574 if (got_per_bfd_arg
.primary
== NULL
)
2576 g
->next
= (struct mips_got_info
*)
2577 bfd_alloc (abfd
, sizeof (struct mips_got_info
));
2578 if (g
->next
== NULL
)
2581 g
->next
->global_gotsym
= NULL
;
2582 g
->next
->global_gotno
= 0;
2583 g
->next
->local_gotno
= 0;
2584 g
->next
->assigned_gotno
= 0;
2585 g
->next
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
2586 mips_elf_multi_got_entry_eq
,
2588 if (g
->next
->got_entries
== NULL
)
2590 g
->next
->bfd2got
= NULL
;
2593 g
->next
= got_per_bfd_arg
.primary
;
2594 g
->next
->next
= got_per_bfd_arg
.current
;
2596 /* GG is now the master GOT, and G is the primary GOT. */
2600 /* Map the output bfd to the primary got. That's what we're going
2601 to use for bfds that use GOT16 or GOT_PAGE relocations that we
2602 didn't mark in check_relocs, and we want a quick way to find it.
2603 We can't just use gg->next because we're going to reverse the
2606 struct mips_elf_bfd2got_hash
*bfdgot
;
2609 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
2610 (abfd
, sizeof (struct mips_elf_bfd2got_hash
));
2617 bfdgotp
= htab_find_slot (gg
->bfd2got
, bfdgot
, INSERT
);
2619 BFD_ASSERT (*bfdgotp
== NULL
);
2623 /* The IRIX dynamic linker requires every symbol that is referenced
2624 in a dynamic relocation to be present in the primary GOT, so
2625 arrange for them to appear after those that are actually
2628 GNU/Linux could very well do without it, but it would slow down
2629 the dynamic linker, since it would have to resolve every dynamic
2630 symbol referenced in other GOTs more than once, without help from
2631 the cache. Also, knowing that every external symbol has a GOT
2632 helps speed up the resolution of local symbols too, so GNU/Linux
2633 follows IRIX's practice.
2635 The number 2 is used by mips_elf_sort_hash_table_f to count
2636 global GOT symbols that are unreferenced in the primary GOT, with
2637 an initial dynamic index computed from gg->assigned_gotno, where
2638 the number of unreferenced global entries in the primary GOT is
2642 gg
->assigned_gotno
= gg
->global_gotno
- g
->global_gotno
;
2643 g
->global_gotno
= gg
->global_gotno
;
2644 set_got_offset_arg
.value
= 2;
2648 /* This could be used for dynamic linkers that don't optimize
2649 symbol resolution while applying relocations so as to use
2650 primary GOT entries or assuming the symbol is locally-defined.
2651 With this code, we assign lower dynamic indices to global
2652 symbols that are not referenced in the primary GOT, so that
2653 their entries can be omitted. */
2654 gg
->assigned_gotno
= 0;
2655 set_got_offset_arg
.value
= -1;
2658 /* Reorder dynamic symbols as described above (which behavior
2659 depends on the setting of VALUE). */
2660 set_got_offset_arg
.g
= NULL
;
2661 htab_traverse (gg
->got_entries
, mips_elf_set_global_got_offset
,
2662 &set_got_offset_arg
);
2663 set_got_offset_arg
.value
= 1;
2664 htab_traverse (g
->got_entries
, mips_elf_set_global_got_offset
,
2665 &set_got_offset_arg
);
2666 if (! mips_elf_sort_hash_table (info
, 1))
2669 /* Now go through the GOTs assigning them offset ranges.
2670 [assigned_gotno, local_gotno[ will be set to the range of local
2671 entries in each GOT. We can then compute the end of a GOT by
2672 adding local_gotno to global_gotno. We reverse the list and make
2673 it circular since then we'll be able to quickly compute the
2674 beginning of a GOT, by computing the end of its predecessor. To
2675 avoid special cases for the primary GOT, while still preserving
2676 assertions that are valid for both single- and multi-got links,
2677 we arrange for the main got struct to have the right number of
2678 global entries, but set its local_gotno such that the initial
2679 offset of the primary GOT is zero. Remember that the primary GOT
2680 will become the last item in the circular linked list, so it
2681 points back to the master GOT. */
2682 gg
->local_gotno
= -g
->global_gotno
;
2683 gg
->global_gotno
= g
->global_gotno
;
2689 struct mips_got_info
*gn
;
2691 assign
+= MIPS_RESERVED_GOTNO
;
2692 g
->assigned_gotno
= assign
;
2693 g
->local_gotno
+= assign
+ pages
;
2694 assign
= g
->local_gotno
+ g
->global_gotno
;
2696 /* Take g out of the direct list, and push it onto the reversed
2697 list that gg points to. */
2703 /* Mark global symbols in every non-primary GOT as ineligible for
2706 htab_traverse (g
->got_entries
, mips_elf_set_no_stub
, NULL
);
2710 got
->_raw_size
= (gg
->next
->local_gotno
2711 + gg
->next
->global_gotno
) * MIPS_ELF_GOT_SIZE (abfd
);
2717 /* Returns the first relocation of type r_type found, beginning with
2718 RELOCATION. RELEND is one-past-the-end of the relocation table. */
2720 static const Elf_Internal_Rela
*
2721 mips_elf_next_relocation (bfd
*abfd ATTRIBUTE_UNUSED
, unsigned int r_type
,
2722 const Elf_Internal_Rela
*relocation
,
2723 const Elf_Internal_Rela
*relend
)
2725 while (relocation
< relend
)
2727 if (ELF_R_TYPE (abfd
, relocation
->r_info
) == r_type
)
2733 /* We didn't find it. */
2734 bfd_set_error (bfd_error_bad_value
);
2738 /* Return whether a relocation is against a local symbol. */
2741 mips_elf_local_relocation_p (bfd
*input_bfd
,
2742 const Elf_Internal_Rela
*relocation
,
2743 asection
**local_sections
,
2744 bfd_boolean check_forced
)
2746 unsigned long r_symndx
;
2747 Elf_Internal_Shdr
*symtab_hdr
;
2748 struct mips_elf_link_hash_entry
*h
;
2751 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
2752 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2753 extsymoff
= (elf_bad_symtab (input_bfd
)) ? 0 : symtab_hdr
->sh_info
;
2755 if (r_symndx
< extsymoff
)
2757 if (elf_bad_symtab (input_bfd
) && local_sections
[r_symndx
] != NULL
)
2762 /* Look up the hash table to check whether the symbol
2763 was forced local. */
2764 h
= (struct mips_elf_link_hash_entry
*)
2765 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
];
2766 /* Find the real hash-table entry for this symbol. */
2767 while (h
->root
.root
.type
== bfd_link_hash_indirect
2768 || h
->root
.root
.type
== bfd_link_hash_warning
)
2769 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2770 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0)
2777 /* Sign-extend VALUE, which has the indicated number of BITS. */
2780 _bfd_mips_elf_sign_extend (bfd_vma value
, int bits
)
2782 if (value
& ((bfd_vma
) 1 << (bits
- 1)))
2783 /* VALUE is negative. */
2784 value
|= ((bfd_vma
) - 1) << bits
;
2789 /* Return non-zero if the indicated VALUE has overflowed the maximum
2790 range expressible by a signed number with the indicated number of
2794 mips_elf_overflow_p (bfd_vma value
, int bits
)
2796 bfd_signed_vma svalue
= (bfd_signed_vma
) value
;
2798 if (svalue
> (1 << (bits
- 1)) - 1)
2799 /* The value is too big. */
2801 else if (svalue
< -(1 << (bits
- 1)))
2802 /* The value is too small. */
2809 /* Calculate the %high function. */
2812 mips_elf_high (bfd_vma value
)
2814 return ((value
+ (bfd_vma
) 0x8000) >> 16) & 0xffff;
2817 /* Calculate the %higher function. */
2820 mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED
)
2823 return ((value
+ (bfd_vma
) 0x80008000) >> 32) & 0xffff;
2830 /* Calculate the %highest function. */
2833 mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED
)
2836 return ((value
+ (((bfd_vma
) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
2843 /* Create the .compact_rel section. */
2846 mips_elf_create_compact_rel_section
2847 (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2850 register asection
*s
;
2852 if (bfd_get_section_by_name (abfd
, ".compact_rel") == NULL
)
2854 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
2857 s
= bfd_make_section (abfd
, ".compact_rel");
2859 || ! bfd_set_section_flags (abfd
, s
, flags
)
2860 || ! bfd_set_section_alignment (abfd
, s
,
2861 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
2864 s
->_raw_size
= sizeof (Elf32_External_compact_rel
);
2870 /* Create the .got section to hold the global offset table. */
2873 mips_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
,
2874 bfd_boolean maybe_exclude
)
2877 register asection
*s
;
2878 struct elf_link_hash_entry
*h
;
2879 struct bfd_link_hash_entry
*bh
;
2880 struct mips_got_info
*g
;
2883 /* This function may be called more than once. */
2884 s
= mips_elf_got_section (abfd
, TRUE
);
2887 if (! maybe_exclude
)
2888 s
->flags
&= ~SEC_EXCLUDE
;
2892 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2893 | SEC_LINKER_CREATED
);
2896 flags
|= SEC_EXCLUDE
;
2898 /* We have to use an alignment of 2**4 here because this is hardcoded
2899 in the function stub generation and in the linker script. */
2900 s
= bfd_make_section (abfd
, ".got");
2902 || ! bfd_set_section_flags (abfd
, s
, flags
)
2903 || ! bfd_set_section_alignment (abfd
, s
, 4))
2906 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
2907 linker script because we don't want to define the symbol if we
2908 are not creating a global offset table. */
2910 if (! (_bfd_generic_link_add_one_symbol
2911 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
2912 0, NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
2915 h
= (struct elf_link_hash_entry
*) bh
;
2916 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
2917 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2918 h
->type
= STT_OBJECT
;
2921 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2924 amt
= sizeof (struct mips_got_info
);
2925 g
= bfd_alloc (abfd
, amt
);
2928 g
->global_gotsym
= NULL
;
2929 g
->global_gotno
= 0;
2930 g
->local_gotno
= MIPS_RESERVED_GOTNO
;
2931 g
->assigned_gotno
= MIPS_RESERVED_GOTNO
;
2934 g
->got_entries
= htab_try_create (1, mips_elf_got_entry_hash
,
2935 mips_elf_got_entry_eq
, NULL
);
2936 if (g
->got_entries
== NULL
)
2938 mips_elf_section_data (s
)->u
.got_info
= g
;
2939 mips_elf_section_data (s
)->elf
.this_hdr
.sh_flags
2940 |= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
2945 /* Calculate the value produced by the RELOCATION (which comes from
2946 the INPUT_BFD). The ADDEND is the addend to use for this
2947 RELOCATION; RELOCATION->R_ADDEND is ignored.
2949 The result of the relocation calculation is stored in VALUEP.
2950 REQUIRE_JALXP indicates whether or not the opcode used with this
2951 relocation must be JALX.
2953 This function returns bfd_reloc_continue if the caller need take no
2954 further action regarding this relocation, bfd_reloc_notsupported if
2955 something goes dramatically wrong, bfd_reloc_overflow if an
2956 overflow occurs, and bfd_reloc_ok to indicate success. */
2958 static bfd_reloc_status_type
2959 mips_elf_calculate_relocation (bfd
*abfd
, bfd
*input_bfd
,
2960 asection
*input_section
,
2961 struct bfd_link_info
*info
,
2962 const Elf_Internal_Rela
*relocation
,
2963 bfd_vma addend
, reloc_howto_type
*howto
,
2964 Elf_Internal_Sym
*local_syms
,
2965 asection
**local_sections
, bfd_vma
*valuep
,
2966 const char **namep
, bfd_boolean
*require_jalxp
,
2967 bfd_boolean save_addend
)
2969 /* The eventual value we will return. */
2971 /* The address of the symbol against which the relocation is
2974 /* The final GP value to be used for the relocatable, executable, or
2975 shared object file being produced. */
2976 bfd_vma gp
= MINUS_ONE
;
2977 /* The place (section offset or address) of the storage unit being
2980 /* The value of GP used to create the relocatable object. */
2981 bfd_vma gp0
= MINUS_ONE
;
2982 /* The offset into the global offset table at which the address of
2983 the relocation entry symbol, adjusted by the addend, resides
2984 during execution. */
2985 bfd_vma g
= MINUS_ONE
;
2986 /* The section in which the symbol referenced by the relocation is
2988 asection
*sec
= NULL
;
2989 struct mips_elf_link_hash_entry
*h
= NULL
;
2990 /* TRUE if the symbol referred to by this relocation is a local
2992 bfd_boolean local_p
, was_local_p
;
2993 /* TRUE if the symbol referred to by this relocation is "_gp_disp". */
2994 bfd_boolean gp_disp_p
= FALSE
;
2995 Elf_Internal_Shdr
*symtab_hdr
;
2997 unsigned long r_symndx
;
2999 /* TRUE if overflow occurred during the calculation of the
3000 relocation value. */
3001 bfd_boolean overflowed_p
;
3002 /* TRUE if this relocation refers to a MIPS16 function. */
3003 bfd_boolean target_is_16_bit_code_p
= FALSE
;
3005 /* Parse the relocation. */
3006 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
3007 r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
3008 p
= (input_section
->output_section
->vma
3009 + input_section
->output_offset
3010 + relocation
->r_offset
);
3012 /* Assume that there will be no overflow. */
3013 overflowed_p
= FALSE
;
3015 /* Figure out whether or not the symbol is local, and get the offset
3016 used in the array of hash table entries. */
3017 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3018 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
3019 local_sections
, FALSE
);
3020 was_local_p
= local_p
;
3021 if (! elf_bad_symtab (input_bfd
))
3022 extsymoff
= symtab_hdr
->sh_info
;
3025 /* The symbol table does not follow the rule that local symbols
3026 must come before globals. */
3030 /* Figure out the value of the symbol. */
3033 Elf_Internal_Sym
*sym
;
3035 sym
= local_syms
+ r_symndx
;
3036 sec
= local_sections
[r_symndx
];
3038 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3039 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
3040 || (sec
->flags
& SEC_MERGE
))
3041 symbol
+= sym
->st_value
;
3042 if ((sec
->flags
& SEC_MERGE
)
3043 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3045 addend
= _bfd_elf_rel_local_sym (abfd
, sym
, &sec
, addend
);
3047 addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
3050 /* MIPS16 text labels should be treated as odd. */
3051 if (sym
->st_other
== STO_MIPS16
)
3054 /* Record the name of this symbol, for our caller. */
3055 *namep
= bfd_elf_string_from_elf_section (input_bfd
,
3056 symtab_hdr
->sh_link
,
3059 *namep
= bfd_section_name (input_bfd
, sec
);
3061 target_is_16_bit_code_p
= (sym
->st_other
== STO_MIPS16
);
3065 /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ? */
3067 /* For global symbols we look up the symbol in the hash-table. */
3068 h
= ((struct mips_elf_link_hash_entry
*)
3069 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
]);
3070 /* Find the real hash-table entry for this symbol. */
3071 while (h
->root
.root
.type
== bfd_link_hash_indirect
3072 || h
->root
.root
.type
== bfd_link_hash_warning
)
3073 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3075 /* Record the name of this symbol, for our caller. */
3076 *namep
= h
->root
.root
.root
.string
;
3078 /* See if this is the special _gp_disp symbol. Note that such a
3079 symbol must always be a global symbol. */
3080 if (strcmp (*namep
, "_gp_disp") == 0
3081 && ! NEWABI_P (input_bfd
))
3083 /* Relocations against _gp_disp are permitted only with
3084 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
3085 if (r_type
!= R_MIPS_HI16
&& r_type
!= R_MIPS_LO16
)
3086 return bfd_reloc_notsupported
;
3090 /* If this symbol is defined, calculate its address. Note that
3091 _gp_disp is a magic symbol, always implicitly defined by the
3092 linker, so it's inappropriate to check to see whether or not
3094 else if ((h
->root
.root
.type
== bfd_link_hash_defined
3095 || h
->root
.root
.type
== bfd_link_hash_defweak
)
3096 && h
->root
.root
.u
.def
.section
)
3098 sec
= h
->root
.root
.u
.def
.section
;
3099 if (sec
->output_section
)
3100 symbol
= (h
->root
.root
.u
.def
.value
3101 + sec
->output_section
->vma
3102 + sec
->output_offset
);
3104 symbol
= h
->root
.root
.u
.def
.value
;
3106 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
3107 /* We allow relocations against undefined weak symbols, giving
3108 it the value zero, so that you can undefined weak functions
3109 and check to see if they exist by looking at their
3112 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
3113 && ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
3115 else if (strcmp (*namep
, "_DYNAMIC_LINK") == 0 ||
3116 strcmp (*namep
, "_DYNAMIC_LINKING") == 0)
3118 /* If this is a dynamic link, we should have created a
3119 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
3120 in in _bfd_mips_elf_create_dynamic_sections.
3121 Otherwise, we should define the symbol with a value of 0.
3122 FIXME: It should probably get into the symbol table
3124 BFD_ASSERT (! info
->shared
);
3125 BFD_ASSERT (bfd_get_section_by_name (abfd
, ".dynamic") == NULL
);
3130 if (! ((*info
->callbacks
->undefined_symbol
)
3131 (info
, h
->root
.root
.root
.string
, input_bfd
,
3132 input_section
, relocation
->r_offset
,
3133 (info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
)
3134 || ELF_ST_VISIBILITY (h
->root
.other
))))
3135 return bfd_reloc_undefined
;
3139 target_is_16_bit_code_p
= (h
->root
.other
== STO_MIPS16
);
3142 /* If this is a 32- or 64-bit call to a 16-bit function with a stub, we
3143 need to redirect the call to the stub, unless we're already *in*
3145 if (r_type
!= R_MIPS16_26
&& !info
->relocatable
3146 && ((h
!= NULL
&& h
->fn_stub
!= NULL
)
3147 || (local_p
&& elf_tdata (input_bfd
)->local_stubs
!= NULL
3148 && elf_tdata (input_bfd
)->local_stubs
[r_symndx
] != NULL
))
3149 && !mips_elf_stub_section_p (input_bfd
, input_section
))
3151 /* This is a 32- or 64-bit call to a 16-bit function. We should
3152 have already noticed that we were going to need the
3155 sec
= elf_tdata (input_bfd
)->local_stubs
[r_symndx
];
3158 BFD_ASSERT (h
->need_fn_stub
);
3162 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3164 /* If this is a 16-bit call to a 32- or 64-bit function with a stub, we
3165 need to redirect the call to the stub. */
3166 else if (r_type
== R_MIPS16_26
&& !info
->relocatable
3168 && (h
->call_stub
!= NULL
|| h
->call_fp_stub
!= NULL
)
3169 && !target_is_16_bit_code_p
)
3171 /* If both call_stub and call_fp_stub are defined, we can figure
3172 out which one to use by seeing which one appears in the input
3174 if (h
->call_stub
!= NULL
&& h
->call_fp_stub
!= NULL
)
3179 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
3181 if (strncmp (bfd_get_section_name (input_bfd
, o
),
3182 CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
3184 sec
= h
->call_fp_stub
;
3191 else if (h
->call_stub
!= NULL
)
3194 sec
= h
->call_fp_stub
;
3196 BFD_ASSERT (sec
->_raw_size
> 0);
3197 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3200 /* Calls from 16-bit code to 32-bit code and vice versa require the
3201 special jalx instruction. */
3202 *require_jalxp
= (!info
->relocatable
3203 && (((r_type
== R_MIPS16_26
) && !target_is_16_bit_code_p
)
3204 || ((r_type
== R_MIPS_26
) && target_is_16_bit_code_p
)));
3206 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
3207 local_sections
, TRUE
);
3209 /* If we haven't already determined the GOT offset, or the GP value,
3210 and we're going to need it, get it now. */
3213 case R_MIPS_GOT_PAGE
:
3214 case R_MIPS_GOT_OFST
:
3215 /* We need to decay to GOT_DISP/addend if the symbol doesn't
3217 local_p
= local_p
|| _bfd_elf_symbol_refs_local_p (&h
->root
, info
, 1);
3218 if (local_p
|| r_type
== R_MIPS_GOT_OFST
)
3224 case R_MIPS_GOT_DISP
:
3225 case R_MIPS_GOT_HI16
:
3226 case R_MIPS_CALL_HI16
:
3227 case R_MIPS_GOT_LO16
:
3228 case R_MIPS_CALL_LO16
:
3229 /* Find the index into the GOT where this value is located. */
3232 /* GOT_PAGE may take a non-zero addend, that is ignored in a
3233 GOT_PAGE relocation that decays to GOT_DISP because the
3234 symbol turns out to be global. The addend is then added
3236 BFD_ASSERT (addend
== 0 || r_type
== R_MIPS_GOT_PAGE
);
3237 g
= mips_elf_global_got_index (elf_hash_table (info
)->dynobj
,
3239 (struct elf_link_hash_entry
*) h
);
3240 if (! elf_hash_table(info
)->dynamic_sections_created
3242 && (info
->symbolic
|| h
->root
.dynindx
== -1)
3243 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
3245 /* This is a static link or a -Bsymbolic link. The
3246 symbol is defined locally, or was forced to be local.
3247 We must initialize this entry in the GOT. */
3248 bfd
*tmpbfd
= elf_hash_table (info
)->dynobj
;
3249 asection
*sgot
= mips_elf_got_section (tmpbfd
, FALSE
);
3250 MIPS_ELF_PUT_WORD (tmpbfd
, symbol
, sgot
->contents
+ g
);
3253 else if (r_type
== R_MIPS_GOT16
|| r_type
== R_MIPS_CALL16
)
3254 /* There's no need to create a local GOT entry here; the
3255 calculation for a local GOT16 entry does not involve G. */
3259 g
= mips_elf_local_got_index (abfd
, input_bfd
,
3260 info
, symbol
+ addend
);
3262 return bfd_reloc_outofrange
;
3265 /* Convert GOT indices to actual offsets. */
3266 g
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3267 abfd
, input_bfd
, g
);
3272 case R_MIPS16_GPREL
:
3273 case R_MIPS_GPREL16
:
3274 case R_MIPS_GPREL32
:
3275 case R_MIPS_LITERAL
:
3276 gp0
= _bfd_get_gp_value (input_bfd
);
3277 gp
= _bfd_get_gp_value (abfd
);
3278 if (elf_hash_table (info
)->dynobj
)
3279 gp
+= mips_elf_adjust_gp (abfd
,
3281 (elf_hash_table (info
)->dynobj
, NULL
),
3289 /* Figure out what kind of relocation is being performed. */
3293 return bfd_reloc_continue
;
3296 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 16);
3297 overflowed_p
= mips_elf_overflow_p (value
, 16);
3304 || (elf_hash_table (info
)->dynamic_sections_created
3306 && ((h
->root
.elf_link_hash_flags
3307 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0)
3308 && ((h
->root
.elf_link_hash_flags
3309 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
3311 && (input_section
->flags
& SEC_ALLOC
) != 0)
3313 /* If we're creating a shared library, or this relocation is
3314 against a symbol in a shared library, then we can't know
3315 where the symbol will end up. So, we create a relocation
3316 record in the output, and leave the job up to the dynamic
3319 if (!mips_elf_create_dynamic_relocation (abfd
,
3327 return bfd_reloc_undefined
;
3331 if (r_type
!= R_MIPS_REL32
)
3332 value
= symbol
+ addend
;
3336 value
&= howto
->dst_mask
;
3340 value
= symbol
+ addend
- p
;
3341 value
&= howto
->dst_mask
;
3344 case R_MIPS_GNU_REL16_S2
:
3345 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 18) - p
;
3346 overflowed_p
= mips_elf_overflow_p (value
, 18);
3347 value
= (value
>> 2) & howto
->dst_mask
;
3351 /* The calculation for R_MIPS16_26 is just the same as for an
3352 R_MIPS_26. It's only the storage of the relocated field into
3353 the output file that's different. That's handled in
3354 mips_elf_perform_relocation. So, we just fall through to the
3355 R_MIPS_26 case here. */
3358 value
= ((addend
| ((p
+ 4) & 0xf0000000)) + symbol
) >> 2;
3360 value
= (_bfd_mips_elf_sign_extend (addend
, 28) + symbol
) >> 2;
3361 value
&= howto
->dst_mask
;
3367 value
= mips_elf_high (addend
+ symbol
);
3368 value
&= howto
->dst_mask
;
3372 value
= mips_elf_high (addend
+ gp
- p
);
3373 overflowed_p
= mips_elf_overflow_p (value
, 16);
3379 value
= (symbol
+ addend
) & howto
->dst_mask
;
3382 value
= addend
+ gp
- p
+ 4;
3383 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
3384 for overflow. But, on, say, IRIX5, relocations against
3385 _gp_disp are normally generated from the .cpload
3386 pseudo-op. It generates code that normally looks like
3389 lui $gp,%hi(_gp_disp)
3390 addiu $gp,$gp,%lo(_gp_disp)
3393 Here $t9 holds the address of the function being called,
3394 as required by the MIPS ELF ABI. The R_MIPS_LO16
3395 relocation can easily overflow in this situation, but the
3396 R_MIPS_HI16 relocation will handle the overflow.
3397 Therefore, we consider this a bug in the MIPS ABI, and do
3398 not check for overflow here. */
3402 case R_MIPS_LITERAL
:
3403 /* Because we don't merge literal sections, we can handle this
3404 just like R_MIPS_GPREL16. In the long run, we should merge
3405 shared literals, and then we will need to additional work
3410 case R_MIPS16_GPREL
:
3411 /* The R_MIPS16_GPREL performs the same calculation as
3412 R_MIPS_GPREL16, but stores the relocated bits in a different
3413 order. We don't need to do anything special here; the
3414 differences are handled in mips_elf_perform_relocation. */
3415 case R_MIPS_GPREL16
:
3416 /* Only sign-extend the addend if it was extracted from the
3417 instruction. If the addend was separate, leave it alone,
3418 otherwise we may lose significant bits. */
3419 if (howto
->partial_inplace
)
3420 addend
= _bfd_mips_elf_sign_extend (addend
, 16);
3421 value
= symbol
+ addend
- gp
;
3422 /* If the symbol was local, any earlier relocatable links will
3423 have adjusted its addend with the gp offset, so compensate
3424 for that now. Don't do it for symbols forced local in this
3425 link, though, since they won't have had the gp offset applied
3429 overflowed_p
= mips_elf_overflow_p (value
, 16);
3438 /* The special case is when the symbol is forced to be local. We
3439 need the full address in the GOT since no R_MIPS_LO16 relocation
3441 forced
= ! mips_elf_local_relocation_p (input_bfd
, relocation
,
3442 local_sections
, FALSE
);
3443 value
= mips_elf_got16_entry (abfd
, input_bfd
, info
,
3444 symbol
+ addend
, forced
);
3445 if (value
== MINUS_ONE
)
3446 return bfd_reloc_outofrange
;
3448 = mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3449 abfd
, input_bfd
, value
);
3450 overflowed_p
= mips_elf_overflow_p (value
, 16);
3456 case R_MIPS_GOT_DISP
:
3459 overflowed_p
= mips_elf_overflow_p (value
, 16);
3462 case R_MIPS_GPREL32
:
3463 value
= (addend
+ symbol
+ gp0
- gp
);
3465 value
&= howto
->dst_mask
;
3469 value
= _bfd_mips_elf_sign_extend (addend
, 16) + symbol
- p
;
3470 overflowed_p
= mips_elf_overflow_p (value
, 16);
3473 case R_MIPS_GOT_HI16
:
3474 case R_MIPS_CALL_HI16
:
3475 /* We're allowed to handle these two relocations identically.
3476 The dynamic linker is allowed to handle the CALL relocations
3477 differently by creating a lazy evaluation stub. */
3479 value
= mips_elf_high (value
);
3480 value
&= howto
->dst_mask
;
3483 case R_MIPS_GOT_LO16
:
3484 case R_MIPS_CALL_LO16
:
3485 value
= g
& howto
->dst_mask
;
3488 case R_MIPS_GOT_PAGE
:
3489 /* GOT_PAGE relocations that reference non-local symbols decay
3490 to GOT_DISP. The corresponding GOT_OFST relocation decays to
3494 value
= mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, NULL
);
3495 if (value
== MINUS_ONE
)
3496 return bfd_reloc_outofrange
;
3497 value
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3498 abfd
, input_bfd
, value
);
3499 overflowed_p
= mips_elf_overflow_p (value
, 16);
3502 case R_MIPS_GOT_OFST
:
3504 mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, &value
);
3507 overflowed_p
= mips_elf_overflow_p (value
, 16);
3511 value
= symbol
- addend
;
3512 value
&= howto
->dst_mask
;
3516 value
= mips_elf_higher (addend
+ symbol
);
3517 value
&= howto
->dst_mask
;
3520 case R_MIPS_HIGHEST
:
3521 value
= mips_elf_highest (addend
+ symbol
);
3522 value
&= howto
->dst_mask
;
3525 case R_MIPS_SCN_DISP
:
3526 value
= symbol
+ addend
- sec
->output_offset
;
3527 value
&= howto
->dst_mask
;
3532 /* Both of these may be ignored. R_MIPS_JALR is an optimization
3533 hint; we could improve performance by honoring that hint. */
3534 return bfd_reloc_continue
;
3536 case R_MIPS_GNU_VTINHERIT
:
3537 case R_MIPS_GNU_VTENTRY
:
3538 /* We don't do anything with these at present. */
3539 return bfd_reloc_continue
;
3542 /* An unrecognized relocation type. */
3543 return bfd_reloc_notsupported
;
3546 /* Store the VALUE for our caller. */
3548 return overflowed_p
? bfd_reloc_overflow
: bfd_reloc_ok
;
3551 /* Obtain the field relocated by RELOCATION. */
3554 mips_elf_obtain_contents (reloc_howto_type
*howto
,
3555 const Elf_Internal_Rela
*relocation
,
3556 bfd
*input_bfd
, bfd_byte
*contents
)
3559 bfd_byte
*location
= contents
+ relocation
->r_offset
;
3561 /* Obtain the bytes. */
3562 x
= bfd_get ((8 * bfd_get_reloc_size (howto
)), input_bfd
, location
);
3564 if ((ELF_R_TYPE (input_bfd
, relocation
->r_info
) == R_MIPS16_26
3565 || ELF_R_TYPE (input_bfd
, relocation
->r_info
) == R_MIPS16_GPREL
)
3566 && bfd_little_endian (input_bfd
))
3567 /* The two 16-bit words will be reversed on a little-endian system.
3568 See mips_elf_perform_relocation for more details. */
3569 x
= (((x
& 0xffff) << 16) | ((x
& 0xffff0000) >> 16));
3574 /* It has been determined that the result of the RELOCATION is the
3575 VALUE. Use HOWTO to place VALUE into the output file at the
3576 appropriate position. The SECTION is the section to which the
3577 relocation applies. If REQUIRE_JALX is TRUE, then the opcode used
3578 for the relocation must be either JAL or JALX, and it is
3579 unconditionally converted to JALX.
3581 Returns FALSE if anything goes wrong. */
3584 mips_elf_perform_relocation (struct bfd_link_info
*info
,
3585 reloc_howto_type
*howto
,
3586 const Elf_Internal_Rela
*relocation
,
3587 bfd_vma value
, bfd
*input_bfd
,
3588 asection
*input_section
, bfd_byte
*contents
,
3589 bfd_boolean require_jalx
)
3593 int r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
3595 /* Figure out where the relocation is occurring. */
3596 location
= contents
+ relocation
->r_offset
;
3598 /* Obtain the current value. */
3599 x
= mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
);
3601 /* Clear the field we are setting. */
3602 x
&= ~howto
->dst_mask
;
3604 /* If this is the R_MIPS16_26 relocation, we must store the
3605 value in a funny way. */
3606 if (r_type
== R_MIPS16_26
)
3608 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
3609 Most mips16 instructions are 16 bits, but these instructions
3612 The format of these instructions is:
3614 +--------------+--------------------------------+
3615 ! JALX ! X! Imm 20:16 ! Imm 25:21 !
3616 +--------------+--------------------------------+
3618 +-----------------------------------------------+
3620 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
3621 Note that the immediate value in the first word is swapped.
3623 When producing a relocatable object file, R_MIPS16_26 is
3624 handled mostly like R_MIPS_26. In particular, the addend is
3625 stored as a straight 26-bit value in a 32-bit instruction.
3626 (gas makes life simpler for itself by never adjusting a
3627 R_MIPS16_26 reloc to be against a section, so the addend is
3628 always zero). However, the 32 bit instruction is stored as 2
3629 16-bit values, rather than a single 32-bit value. In a
3630 big-endian file, the result is the same; in a little-endian
3631 file, the two 16-bit halves of the 32 bit value are swapped.
3632 This is so that a disassembler can recognize the jal
3635 When doing a final link, R_MIPS16_26 is treated as a 32 bit
3636 instruction stored as two 16-bit values. The addend A is the
3637 contents of the targ26 field. The calculation is the same as
3638 R_MIPS_26. When storing the calculated value, reorder the
3639 immediate value as shown above, and don't forget to store the
3640 value as two 16-bit values.
3642 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
3646 +--------+----------------------+
3650 +--------+----------------------+
3653 +----------+------+-------------+
3657 +----------+--------------------+
3658 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
3659 ((sub1 << 16) | sub2)).
3661 When producing a relocatable object file, the calculation is
3662 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
3663 When producing a fully linked file, the calculation is
3664 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
3665 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff) */
3667 if (!info
->relocatable
)
3668 /* Shuffle the bits according to the formula above. */
3669 value
= (((value
& 0x1f0000) << 5)
3670 | ((value
& 0x3e00000) >> 5)
3671 | (value
& 0xffff));
3673 else if (r_type
== R_MIPS16_GPREL
)
3675 /* R_MIPS16_GPREL is used for GP-relative addressing in mips16
3676 mode. A typical instruction will have a format like this:
3678 +--------------+--------------------------------+
3679 ! EXTEND ! Imm 10:5 ! Imm 15:11 !
3680 +--------------+--------------------------------+
3681 ! Major ! rx ! ry ! Imm 4:0 !
3682 +--------------+--------------------------------+
3684 EXTEND is the five bit value 11110. Major is the instruction
3687 This is handled exactly like R_MIPS_GPREL16, except that the
3688 addend is retrieved and stored as shown in this diagram; that
3689 is, the Imm fields above replace the V-rel16 field.
3691 All we need to do here is shuffle the bits appropriately. As
3692 above, the two 16-bit halves must be swapped on a
3693 little-endian system. */
3694 value
= (((value
& 0x7e0) << 16)
3695 | ((value
& 0xf800) << 5)
3699 /* Set the field. */
3700 x
|= (value
& howto
->dst_mask
);
3702 /* If required, turn JAL into JALX. */
3706 bfd_vma opcode
= x
>> 26;
3707 bfd_vma jalx_opcode
;
3709 /* Check to see if the opcode is already JAL or JALX. */
3710 if (r_type
== R_MIPS16_26
)
3712 ok
= ((opcode
== 0x6) || (opcode
== 0x7));
3717 ok
= ((opcode
== 0x3) || (opcode
== 0x1d));
3721 /* If the opcode is not JAL or JALX, there's a problem. */
3724 (*_bfd_error_handler
)
3725 (_("%s: %s+0x%lx: jump to stub routine which is not jal"),
3726 bfd_archive_filename (input_bfd
),
3727 input_section
->name
,
3728 (unsigned long) relocation
->r_offset
);
3729 bfd_set_error (bfd_error_bad_value
);
3733 /* Make this the JALX opcode. */
3734 x
= (x
& ~(0x3f << 26)) | (jalx_opcode
<< 26);
3737 /* Swap the high- and low-order 16 bits on little-endian systems
3738 when doing a MIPS16 relocation. */
3739 if ((r_type
== R_MIPS16_GPREL
|| r_type
== R_MIPS16_26
)
3740 && bfd_little_endian (input_bfd
))
3741 x
= (((x
& 0xffff) << 16) | ((x
& 0xffff0000) >> 16));
3743 /* Put the value into the output. */
3744 bfd_put (8 * bfd_get_reloc_size (howto
), input_bfd
, x
, location
);
3748 /* Returns TRUE if SECTION is a MIPS16 stub section. */
3751 mips_elf_stub_section_p (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*section
)
3753 const char *name
= bfd_get_section_name (abfd
, section
);
3755 return (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0
3756 || strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
3757 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0);
3760 /* Add room for N relocations to the .rel.dyn section in ABFD. */
3763 mips_elf_allocate_dynamic_relocations (bfd
*abfd
, unsigned int n
)
3767 s
= mips_elf_rel_dyn_section (abfd
, FALSE
);
3768 BFD_ASSERT (s
!= NULL
);
3770 if (s
->_raw_size
== 0)
3772 /* Make room for a null element. */
3773 s
->_raw_size
+= MIPS_ELF_REL_SIZE (abfd
);
3776 s
->_raw_size
+= n
* MIPS_ELF_REL_SIZE (abfd
);
3779 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
3780 is the original relocation, which is now being transformed into a
3781 dynamic relocation. The ADDENDP is adjusted if necessary; the
3782 caller should store the result in place of the original addend. */
3785 mips_elf_create_dynamic_relocation (bfd
*output_bfd
,
3786 struct bfd_link_info
*info
,
3787 const Elf_Internal_Rela
*rel
,
3788 struct mips_elf_link_hash_entry
*h
,
3789 asection
*sec
, bfd_vma symbol
,
3790 bfd_vma
*addendp
, asection
*input_section
)
3792 Elf_Internal_Rela outrel
[3];
3798 r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
3799 dynobj
= elf_hash_table (info
)->dynobj
;
3800 sreloc
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
3801 BFD_ASSERT (sreloc
!= NULL
);
3802 BFD_ASSERT (sreloc
->contents
!= NULL
);
3803 BFD_ASSERT (sreloc
->reloc_count
* MIPS_ELF_REL_SIZE (output_bfd
)
3804 < sreloc
->_raw_size
);
3807 outrel
[0].r_offset
=
3808 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[0].r_offset
);
3809 outrel
[1].r_offset
=
3810 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[1].r_offset
);
3811 outrel
[2].r_offset
=
3812 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[2].r_offset
);
3815 /* We begin by assuming that the offset for the dynamic relocation
3816 is the same as for the original relocation. We'll adjust this
3817 later to reflect the correct output offsets. */
3818 if (input_section
->sec_info_type
!= ELF_INFO_TYPE_STABS
)
3820 outrel
[1].r_offset
= rel
[1].r_offset
;
3821 outrel
[2].r_offset
= rel
[2].r_offset
;
3825 /* Except that in a stab section things are more complex.
3826 Because we compress stab information, the offset given in the
3827 relocation may not be the one we want; we must let the stabs
3828 machinery tell us the offset. */
3829 outrel
[1].r_offset
= outrel
[0].r_offset
;
3830 outrel
[2].r_offset
= outrel
[0].r_offset
;
3831 /* If we didn't need the relocation at all, this value will be
3833 if (outrel
[0].r_offset
== MINUS_ONE
)
3838 if (outrel
[0].r_offset
== MINUS_ONE
)
3839 /* The relocation field has been deleted. */
3841 else if (outrel
[0].r_offset
== MINUS_TWO
)
3843 /* The relocation field has been converted into a relative value of
3844 some sort. Functions like _bfd_elf_write_section_eh_frame expect
3845 the field to be fully relocated, so add in the symbol's value. */
3850 /* If we've decided to skip this relocation, just output an empty
3851 record. Note that R_MIPS_NONE == 0, so that this call to memset
3852 is a way of setting R_TYPE to R_MIPS_NONE. */
3854 memset (outrel
, 0, sizeof (Elf_Internal_Rela
) * 3);
3858 bfd_boolean defined_p
;
3860 /* We must now calculate the dynamic symbol table index to use
3861 in the relocation. */
3863 && (! info
->symbolic
|| (h
->root
.elf_link_hash_flags
3864 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
3865 /* h->root.dynindx may be -1 if this symbol was marked to
3867 && h
->root
.dynindx
!= -1)
3869 indx
= h
->root
.dynindx
;
3870 if (SGI_COMPAT (output_bfd
))
3871 defined_p
= ((h
->root
.elf_link_hash_flags
3872 & ELF_LINK_HASH_DEF_REGULAR
) != 0);
3874 /* ??? glibc's ld.so just adds the final GOT entry to the
3875 relocation field. It therefore treats relocs against
3876 defined symbols in the same way as relocs against
3877 undefined symbols. */
3882 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
3884 else if (sec
== NULL
|| sec
->owner
== NULL
)
3886 bfd_set_error (bfd_error_bad_value
);
3891 indx
= elf_section_data (sec
->output_section
)->dynindx
;
3896 /* Instead of generating a relocation using the section
3897 symbol, we may as well make it a fully relative
3898 relocation. We want to avoid generating relocations to
3899 local symbols because we used to generate them
3900 incorrectly, without adding the original symbol value,
3901 which is mandated by the ABI for section symbols. In
3902 order to give dynamic loaders and applications time to
3903 phase out the incorrect use, we refrain from emitting
3904 section-relative relocations. It's not like they're
3905 useful, after all. This should be a bit more efficient
3907 /* ??? Although this behavior is compatible with glibc's ld.so,
3908 the ABI says that relocations against STN_UNDEF should have
3909 a symbol value of 0. Irix rld honors this, so relocations
3910 against STN_UNDEF have no effect. */
3911 if (!SGI_COMPAT (output_bfd
))
3916 /* If the relocation was previously an absolute relocation and
3917 this symbol will not be referred to by the relocation, we must
3918 adjust it by the value we give it in the dynamic symbol table.
3919 Otherwise leave the job up to the dynamic linker. */
3920 if (defined_p
&& r_type
!= R_MIPS_REL32
)
3923 /* The relocation is always an REL32 relocation because we don't
3924 know where the shared library will wind up at load-time. */
3925 outrel
[0].r_info
= ELF_R_INFO (output_bfd
, (unsigned long) indx
,
3927 /* For strict adherence to the ABI specification, we should
3928 generate a R_MIPS_64 relocation record by itself before the
3929 _REL32/_64 record as well, such that the addend is read in as
3930 a 64-bit value (REL32 is a 32-bit relocation, after all).
3931 However, since none of the existing ELF64 MIPS dynamic
3932 loaders seems to care, we don't waste space with these
3933 artificial relocations. If this turns out to not be true,
3934 mips_elf_allocate_dynamic_relocation() should be tweaked so
3935 as to make room for a pair of dynamic relocations per
3936 invocation if ABI_64_P, and here we should generate an
3937 additional relocation record with R_MIPS_64 by itself for a
3938 NULL symbol before this relocation record. */
3939 outrel
[1].r_info
= ELF_R_INFO (output_bfd
, 0,
3940 ABI_64_P (output_bfd
)
3943 outrel
[2].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_NONE
);
3945 /* Adjust the output offset of the relocation to reference the
3946 correct location in the output file. */
3947 outrel
[0].r_offset
+= (input_section
->output_section
->vma
3948 + input_section
->output_offset
);
3949 outrel
[1].r_offset
+= (input_section
->output_section
->vma
3950 + input_section
->output_offset
);
3951 outrel
[2].r_offset
+= (input_section
->output_section
->vma
3952 + input_section
->output_offset
);
3955 /* Put the relocation back out. We have to use the special
3956 relocation outputter in the 64-bit case since the 64-bit
3957 relocation format is non-standard. */
3958 if (ABI_64_P (output_bfd
))
3960 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
3961 (output_bfd
, &outrel
[0],
3963 + sreloc
->reloc_count
* sizeof (Elf64_Mips_External_Rel
)));
3966 bfd_elf32_swap_reloc_out
3967 (output_bfd
, &outrel
[0],
3968 (sreloc
->contents
+ sreloc
->reloc_count
* sizeof (Elf32_External_Rel
)));
3970 /* We've now added another relocation. */
3971 ++sreloc
->reloc_count
;
3973 /* Make sure the output section is writable. The dynamic linker
3974 will be writing to it. */
3975 elf_section_data (input_section
->output_section
)->this_hdr
.sh_flags
3978 /* On IRIX5, make an entry of compact relocation info. */
3979 if (! skip
&& IRIX_COMPAT (output_bfd
) == ict_irix5
)
3981 asection
*scpt
= bfd_get_section_by_name (dynobj
, ".compact_rel");
3986 Elf32_crinfo cptrel
;
3988 mips_elf_set_cr_format (cptrel
, CRF_MIPS_LONG
);
3989 cptrel
.vaddr
= (rel
->r_offset
3990 + input_section
->output_section
->vma
3991 + input_section
->output_offset
);
3992 if (r_type
== R_MIPS_REL32
)
3993 mips_elf_set_cr_type (cptrel
, CRT_MIPS_REL32
);
3995 mips_elf_set_cr_type (cptrel
, CRT_MIPS_WORD
);
3996 mips_elf_set_cr_dist2to (cptrel
, 0);
3997 cptrel
.konst
= *addendp
;
3999 cr
= (scpt
->contents
4000 + sizeof (Elf32_External_compact_rel
));
4001 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
4002 ((Elf32_External_crinfo
*) cr
4003 + scpt
->reloc_count
));
4004 ++scpt
->reloc_count
;
4011 /* Return the MACH for a MIPS e_flags value. */
4014 _bfd_elf_mips_mach (flagword flags
)
4016 switch (flags
& EF_MIPS_MACH
)
4018 case E_MIPS_MACH_3900
:
4019 return bfd_mach_mips3900
;
4021 case E_MIPS_MACH_4010
:
4022 return bfd_mach_mips4010
;
4024 case E_MIPS_MACH_4100
:
4025 return bfd_mach_mips4100
;
4027 case E_MIPS_MACH_4111
:
4028 return bfd_mach_mips4111
;
4030 case E_MIPS_MACH_4120
:
4031 return bfd_mach_mips4120
;
4033 case E_MIPS_MACH_4650
:
4034 return bfd_mach_mips4650
;
4036 case E_MIPS_MACH_5400
:
4037 return bfd_mach_mips5400
;
4039 case E_MIPS_MACH_5500
:
4040 return bfd_mach_mips5500
;
4042 case E_MIPS_MACH_SB1
:
4043 return bfd_mach_mips_sb1
;
4046 switch (flags
& EF_MIPS_ARCH
)
4050 return bfd_mach_mips3000
;
4054 return bfd_mach_mips6000
;
4058 return bfd_mach_mips4000
;
4062 return bfd_mach_mips8000
;
4066 return bfd_mach_mips5
;
4069 case E_MIPS_ARCH_32
:
4070 return bfd_mach_mipsisa32
;
4073 case E_MIPS_ARCH_64
:
4074 return bfd_mach_mipsisa64
;
4077 case E_MIPS_ARCH_32R2
:
4078 return bfd_mach_mipsisa32r2
;
4081 case E_MIPS_ARCH_64R2
:
4082 return bfd_mach_mipsisa64r2
;
4090 /* Return printable name for ABI. */
4092 static INLINE
char *
4093 elf_mips_abi_name (bfd
*abfd
)
4097 flags
= elf_elfheader (abfd
)->e_flags
;
4098 switch (flags
& EF_MIPS_ABI
)
4101 if (ABI_N32_P (abfd
))
4103 else if (ABI_64_P (abfd
))
4107 case E_MIPS_ABI_O32
:
4109 case E_MIPS_ABI_O64
:
4111 case E_MIPS_ABI_EABI32
:
4113 case E_MIPS_ABI_EABI64
:
4116 return "unknown abi";
4120 /* MIPS ELF uses two common sections. One is the usual one, and the
4121 other is for small objects. All the small objects are kept
4122 together, and then referenced via the gp pointer, which yields
4123 faster assembler code. This is what we use for the small common
4124 section. This approach is copied from ecoff.c. */
4125 static asection mips_elf_scom_section
;
4126 static asymbol mips_elf_scom_symbol
;
4127 static asymbol
*mips_elf_scom_symbol_ptr
;
4129 /* MIPS ELF also uses an acommon section, which represents an
4130 allocated common symbol which may be overridden by a
4131 definition in a shared library. */
4132 static asection mips_elf_acom_section
;
4133 static asymbol mips_elf_acom_symbol
;
4134 static asymbol
*mips_elf_acom_symbol_ptr
;
4136 /* Handle the special MIPS section numbers that a symbol may use.
4137 This is used for both the 32-bit and the 64-bit ABI. */
4140 _bfd_mips_elf_symbol_processing (bfd
*abfd
, asymbol
*asym
)
4142 elf_symbol_type
*elfsym
;
4144 elfsym
= (elf_symbol_type
*) asym
;
4145 switch (elfsym
->internal_elf_sym
.st_shndx
)
4147 case SHN_MIPS_ACOMMON
:
4148 /* This section is used in a dynamically linked executable file.
4149 It is an allocated common section. The dynamic linker can
4150 either resolve these symbols to something in a shared
4151 library, or it can just leave them here. For our purposes,
4152 we can consider these symbols to be in a new section. */
4153 if (mips_elf_acom_section
.name
== NULL
)
4155 /* Initialize the acommon section. */
4156 mips_elf_acom_section
.name
= ".acommon";
4157 mips_elf_acom_section
.flags
= SEC_ALLOC
;
4158 mips_elf_acom_section
.output_section
= &mips_elf_acom_section
;
4159 mips_elf_acom_section
.symbol
= &mips_elf_acom_symbol
;
4160 mips_elf_acom_section
.symbol_ptr_ptr
= &mips_elf_acom_symbol_ptr
;
4161 mips_elf_acom_symbol
.name
= ".acommon";
4162 mips_elf_acom_symbol
.flags
= BSF_SECTION_SYM
;
4163 mips_elf_acom_symbol
.section
= &mips_elf_acom_section
;
4164 mips_elf_acom_symbol_ptr
= &mips_elf_acom_symbol
;
4166 asym
->section
= &mips_elf_acom_section
;
4170 /* Common symbols less than the GP size are automatically
4171 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
4172 if (asym
->value
> elf_gp_size (abfd
)
4173 || IRIX_COMPAT (abfd
) == ict_irix6
)
4176 case SHN_MIPS_SCOMMON
:
4177 if (mips_elf_scom_section
.name
== NULL
)
4179 /* Initialize the small common section. */
4180 mips_elf_scom_section
.name
= ".scommon";
4181 mips_elf_scom_section
.flags
= SEC_IS_COMMON
;
4182 mips_elf_scom_section
.output_section
= &mips_elf_scom_section
;
4183 mips_elf_scom_section
.symbol
= &mips_elf_scom_symbol
;
4184 mips_elf_scom_section
.symbol_ptr_ptr
= &mips_elf_scom_symbol_ptr
;
4185 mips_elf_scom_symbol
.name
= ".scommon";
4186 mips_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
4187 mips_elf_scom_symbol
.section
= &mips_elf_scom_section
;
4188 mips_elf_scom_symbol_ptr
= &mips_elf_scom_symbol
;
4190 asym
->section
= &mips_elf_scom_section
;
4191 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
4194 case SHN_MIPS_SUNDEFINED
:
4195 asym
->section
= bfd_und_section_ptr
;
4198 #if 0 /* for SGI_COMPAT */
4200 asym
->section
= mips_elf_text_section_ptr
;
4204 asym
->section
= mips_elf_data_section_ptr
;
4210 /* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
4211 relocations against two unnamed section symbols to resolve to the
4212 same address. For example, if we have code like:
4214 lw $4,%got_disp(.data)($gp)
4215 lw $25,%got_disp(.text)($gp)
4218 then the linker will resolve both relocations to .data and the program
4219 will jump there rather than to .text.
4221 We can work around this problem by giving names to local section symbols.
4222 This is also what the MIPSpro tools do. */
4225 _bfd_mips_elf_name_local_section_symbols (bfd
*abfd
)
4227 return SGI_COMPAT (abfd
);
4230 /* Work over a section just before writing it out. This routine is
4231 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
4232 sections that need the SHF_MIPS_GPREL flag by name; there has to be
4236 _bfd_mips_elf_section_processing (bfd
*abfd
, Elf_Internal_Shdr
*hdr
)
4238 if (hdr
->sh_type
== SHT_MIPS_REGINFO
4239 && hdr
->sh_size
> 0)
4243 BFD_ASSERT (hdr
->sh_size
== sizeof (Elf32_External_RegInfo
));
4244 BFD_ASSERT (hdr
->contents
== NULL
);
4247 hdr
->sh_offset
+ sizeof (Elf32_External_RegInfo
) - 4,
4250 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
4251 if (bfd_bwrite (buf
, 4, abfd
) != 4)
4255 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
4256 && hdr
->bfd_section
!= NULL
4257 && mips_elf_section_data (hdr
->bfd_section
) != NULL
4258 && mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
!= NULL
)
4260 bfd_byte
*contents
, *l
, *lend
;
4262 /* We stored the section contents in the tdata field in the
4263 set_section_contents routine. We save the section contents
4264 so that we don't have to read them again.
4265 At this point we know that elf_gp is set, so we can look
4266 through the section contents to see if there is an
4267 ODK_REGINFO structure. */
4269 contents
= mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
;
4271 lend
= contents
+ hdr
->sh_size
;
4272 while (l
+ sizeof (Elf_External_Options
) <= lend
)
4274 Elf_Internal_Options intopt
;
4276 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
4278 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
4285 + sizeof (Elf_External_Options
)
4286 + (sizeof (Elf64_External_RegInfo
) - 8)),
4289 H_PUT_64 (abfd
, elf_gp (abfd
), buf
);
4290 if (bfd_bwrite (buf
, 8, abfd
) != 8)
4293 else if (intopt
.kind
== ODK_REGINFO
)
4300 + sizeof (Elf_External_Options
)
4301 + (sizeof (Elf32_External_RegInfo
) - 4)),
4304 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
4305 if (bfd_bwrite (buf
, 4, abfd
) != 4)
4312 if (hdr
->bfd_section
!= NULL
)
4314 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
4316 if (strcmp (name
, ".sdata") == 0
4317 || strcmp (name
, ".lit8") == 0
4318 || strcmp (name
, ".lit4") == 0)
4320 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
4321 hdr
->sh_type
= SHT_PROGBITS
;
4323 else if (strcmp (name
, ".sbss") == 0)
4325 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
4326 hdr
->sh_type
= SHT_NOBITS
;
4328 else if (strcmp (name
, ".srdata") == 0)
4330 hdr
->sh_flags
|= SHF_ALLOC
| SHF_MIPS_GPREL
;
4331 hdr
->sh_type
= SHT_PROGBITS
;
4333 else if (strcmp (name
, ".compact_rel") == 0)
4336 hdr
->sh_type
= SHT_PROGBITS
;
4338 else if (strcmp (name
, ".rtproc") == 0)
4340 if (hdr
->sh_addralign
!= 0 && hdr
->sh_entsize
== 0)
4342 unsigned int adjust
;
4344 adjust
= hdr
->sh_size
% hdr
->sh_addralign
;
4346 hdr
->sh_size
+= hdr
->sh_addralign
- adjust
;
4354 /* Handle a MIPS specific section when reading an object file. This
4355 is called when elfcode.h finds a section with an unknown type.
4356 This routine supports both the 32-bit and 64-bit ELF ABI.
4358 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
4362 _bfd_mips_elf_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
4367 /* There ought to be a place to keep ELF backend specific flags, but
4368 at the moment there isn't one. We just keep track of the
4369 sections by their name, instead. Fortunately, the ABI gives
4370 suggested names for all the MIPS specific sections, so we will
4371 probably get away with this. */
4372 switch (hdr
->sh_type
)
4374 case SHT_MIPS_LIBLIST
:
4375 if (strcmp (name
, ".liblist") != 0)
4379 if (strcmp (name
, ".msym") != 0)
4382 case SHT_MIPS_CONFLICT
:
4383 if (strcmp (name
, ".conflict") != 0)
4386 case SHT_MIPS_GPTAB
:
4387 if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) != 0)
4390 case SHT_MIPS_UCODE
:
4391 if (strcmp (name
, ".ucode") != 0)
4394 case SHT_MIPS_DEBUG
:
4395 if (strcmp (name
, ".mdebug") != 0)
4397 flags
= SEC_DEBUGGING
;
4399 case SHT_MIPS_REGINFO
:
4400 if (strcmp (name
, ".reginfo") != 0
4401 || hdr
->sh_size
!= sizeof (Elf32_External_RegInfo
))
4403 flags
= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_SIZE
);
4405 case SHT_MIPS_IFACE
:
4406 if (strcmp (name
, ".MIPS.interfaces") != 0)
4409 case SHT_MIPS_CONTENT
:
4410 if (strncmp (name
, ".MIPS.content", sizeof ".MIPS.content" - 1) != 0)
4413 case SHT_MIPS_OPTIONS
:
4414 if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) != 0)
4417 case SHT_MIPS_DWARF
:
4418 if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) != 0)
4421 case SHT_MIPS_SYMBOL_LIB
:
4422 if (strcmp (name
, ".MIPS.symlib") != 0)
4425 case SHT_MIPS_EVENTS
:
4426 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) != 0
4427 && strncmp (name
, ".MIPS.post_rel",
4428 sizeof ".MIPS.post_rel" - 1) != 0)
4435 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
4440 if (! bfd_set_section_flags (abfd
, hdr
->bfd_section
,
4441 (bfd_get_section_flags (abfd
,
4447 /* FIXME: We should record sh_info for a .gptab section. */
4449 /* For a .reginfo section, set the gp value in the tdata information
4450 from the contents of this section. We need the gp value while
4451 processing relocs, so we just get it now. The .reginfo section
4452 is not used in the 64-bit MIPS ELF ABI. */
4453 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
4455 Elf32_External_RegInfo ext
;
4458 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
,
4459 &ext
, 0, sizeof ext
))
4461 bfd_mips_elf32_swap_reginfo_in (abfd
, &ext
, &s
);
4462 elf_gp (abfd
) = s
.ri_gp_value
;
4465 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
4466 set the gp value based on what we find. We may see both
4467 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
4468 they should agree. */
4469 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
)
4471 bfd_byte
*contents
, *l
, *lend
;
4473 contents
= bfd_malloc (hdr
->sh_size
);
4474 if (contents
== NULL
)
4476 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
,
4483 lend
= contents
+ hdr
->sh_size
;
4484 while (l
+ sizeof (Elf_External_Options
) <= lend
)
4486 Elf_Internal_Options intopt
;
4488 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
4490 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
4492 Elf64_Internal_RegInfo intreg
;
4494 bfd_mips_elf64_swap_reginfo_in
4496 ((Elf64_External_RegInfo
*)
4497 (l
+ sizeof (Elf_External_Options
))),
4499 elf_gp (abfd
) = intreg
.ri_gp_value
;
4501 else if (intopt
.kind
== ODK_REGINFO
)
4503 Elf32_RegInfo intreg
;
4505 bfd_mips_elf32_swap_reginfo_in
4507 ((Elf32_External_RegInfo
*)
4508 (l
+ sizeof (Elf_External_Options
))),
4510 elf_gp (abfd
) = intreg
.ri_gp_value
;
4520 /* Set the correct type for a MIPS ELF section. We do this by the
4521 section name, which is a hack, but ought to work. This routine is
4522 used by both the 32-bit and the 64-bit ABI. */
4525 _bfd_mips_elf_fake_sections (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*sec
)
4527 register const char *name
;
4529 name
= bfd_get_section_name (abfd
, sec
);
4531 if (strcmp (name
, ".liblist") == 0)
4533 hdr
->sh_type
= SHT_MIPS_LIBLIST
;
4534 hdr
->sh_info
= sec
->_raw_size
/ sizeof (Elf32_Lib
);
4535 /* The sh_link field is set in final_write_processing. */
4537 else if (strcmp (name
, ".conflict") == 0)
4538 hdr
->sh_type
= SHT_MIPS_CONFLICT
;
4539 else if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0)
4541 hdr
->sh_type
= SHT_MIPS_GPTAB
;
4542 hdr
->sh_entsize
= sizeof (Elf32_External_gptab
);
4543 /* The sh_info field is set in final_write_processing. */
4545 else if (strcmp (name
, ".ucode") == 0)
4546 hdr
->sh_type
= SHT_MIPS_UCODE
;
4547 else if (strcmp (name
, ".mdebug") == 0)
4549 hdr
->sh_type
= SHT_MIPS_DEBUG
;
4550 /* In a shared object on IRIX 5.3, the .mdebug section has an
4551 entsize of 0. FIXME: Does this matter? */
4552 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
4553 hdr
->sh_entsize
= 0;
4555 hdr
->sh_entsize
= 1;
4557 else if (strcmp (name
, ".reginfo") == 0)
4559 hdr
->sh_type
= SHT_MIPS_REGINFO
;
4560 /* In a shared object on IRIX 5.3, the .reginfo section has an
4561 entsize of 0x18. FIXME: Does this matter? */
4562 if (SGI_COMPAT (abfd
))
4564 if ((abfd
->flags
& DYNAMIC
) != 0)
4565 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
4567 hdr
->sh_entsize
= 1;
4570 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
4572 else if (SGI_COMPAT (abfd
)
4573 && (strcmp (name
, ".hash") == 0
4574 || strcmp (name
, ".dynamic") == 0
4575 || strcmp (name
, ".dynstr") == 0))
4577 if (SGI_COMPAT (abfd
))
4578 hdr
->sh_entsize
= 0;
4580 /* This isn't how the IRIX6 linker behaves. */
4581 hdr
->sh_info
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
4584 else if (strcmp (name
, ".got") == 0
4585 || strcmp (name
, ".srdata") == 0
4586 || strcmp (name
, ".sdata") == 0
4587 || strcmp (name
, ".sbss") == 0
4588 || strcmp (name
, ".lit4") == 0
4589 || strcmp (name
, ".lit8") == 0)
4590 hdr
->sh_flags
|= SHF_MIPS_GPREL
;
4591 else if (strcmp (name
, ".MIPS.interfaces") == 0)
4593 hdr
->sh_type
= SHT_MIPS_IFACE
;
4594 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4596 else if (strncmp (name
, ".MIPS.content", strlen (".MIPS.content")) == 0)
4598 hdr
->sh_type
= SHT_MIPS_CONTENT
;
4599 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4600 /* The sh_info field is set in final_write_processing. */
4602 else if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
4604 hdr
->sh_type
= SHT_MIPS_OPTIONS
;
4605 hdr
->sh_entsize
= 1;
4606 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4608 else if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) == 0)
4609 hdr
->sh_type
= SHT_MIPS_DWARF
;
4610 else if (strcmp (name
, ".MIPS.symlib") == 0)
4612 hdr
->sh_type
= SHT_MIPS_SYMBOL_LIB
;
4613 /* The sh_link and sh_info fields are set in
4614 final_write_processing. */
4616 else if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0
4617 || strncmp (name
, ".MIPS.post_rel",
4618 sizeof ".MIPS.post_rel" - 1) == 0)
4620 hdr
->sh_type
= SHT_MIPS_EVENTS
;
4621 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4622 /* The sh_link field is set in final_write_processing. */
4624 else if (strcmp (name
, ".msym") == 0)
4626 hdr
->sh_type
= SHT_MIPS_MSYM
;
4627 hdr
->sh_flags
|= SHF_ALLOC
;
4628 hdr
->sh_entsize
= 8;
4631 /* The generic elf_fake_sections will set up REL_HDR using the default
4632 kind of relocations. We used to set up a second header for the
4633 non-default kind of relocations here, but only NewABI would use
4634 these, and the IRIX ld doesn't like resulting empty RELA sections.
4635 Thus we create those header only on demand now. */
4640 /* Given a BFD section, try to locate the corresponding ELF section
4641 index. This is used by both the 32-bit and the 64-bit ABI.
4642 Actually, it's not clear to me that the 64-bit ABI supports these,
4643 but for non-PIC objects we will certainly want support for at least
4644 the .scommon section. */
4647 _bfd_mips_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
4648 asection
*sec
, int *retval
)
4650 if (strcmp (bfd_get_section_name (abfd
, sec
), ".scommon") == 0)
4652 *retval
= SHN_MIPS_SCOMMON
;
4655 if (strcmp (bfd_get_section_name (abfd
, sec
), ".acommon") == 0)
4657 *retval
= SHN_MIPS_ACOMMON
;
4663 /* Hook called by the linker routine which adds symbols from an object
4664 file. We must handle the special MIPS section numbers here. */
4667 _bfd_mips_elf_add_symbol_hook (bfd
*abfd
, struct bfd_link_info
*info
,
4668 Elf_Internal_Sym
*sym
, const char **namep
,
4669 flagword
*flagsp ATTRIBUTE_UNUSED
,
4670 asection
**secp
, bfd_vma
*valp
)
4672 if (SGI_COMPAT (abfd
)
4673 && (abfd
->flags
& DYNAMIC
) != 0
4674 && strcmp (*namep
, "_rld_new_interface") == 0)
4676 /* Skip IRIX5 rld entry name. */
4681 switch (sym
->st_shndx
)
4684 /* Common symbols less than the GP size are automatically
4685 treated as SHN_MIPS_SCOMMON symbols. */
4686 if (sym
->st_size
> elf_gp_size (abfd
)
4687 || IRIX_COMPAT (abfd
) == ict_irix6
)
4690 case SHN_MIPS_SCOMMON
:
4691 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
4692 (*secp
)->flags
|= SEC_IS_COMMON
;
4693 *valp
= sym
->st_size
;
4697 /* This section is used in a shared object. */
4698 if (elf_tdata (abfd
)->elf_text_section
== NULL
)
4700 asymbol
*elf_text_symbol
;
4701 asection
*elf_text_section
;
4702 bfd_size_type amt
= sizeof (asection
);
4704 elf_text_section
= bfd_zalloc (abfd
, amt
);
4705 if (elf_text_section
== NULL
)
4708 amt
= sizeof (asymbol
);
4709 elf_text_symbol
= bfd_zalloc (abfd
, amt
);
4710 if (elf_text_symbol
== NULL
)
4713 /* Initialize the section. */
4715 elf_tdata (abfd
)->elf_text_section
= elf_text_section
;
4716 elf_tdata (abfd
)->elf_text_symbol
= elf_text_symbol
;
4718 elf_text_section
->symbol
= elf_text_symbol
;
4719 elf_text_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_text_symbol
;
4721 elf_text_section
->name
= ".text";
4722 elf_text_section
->flags
= SEC_NO_FLAGS
;
4723 elf_text_section
->output_section
= NULL
;
4724 elf_text_section
->owner
= abfd
;
4725 elf_text_symbol
->name
= ".text";
4726 elf_text_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
4727 elf_text_symbol
->section
= elf_text_section
;
4729 /* This code used to do *secp = bfd_und_section_ptr if
4730 info->shared. I don't know why, and that doesn't make sense,
4731 so I took it out. */
4732 *secp
= elf_tdata (abfd
)->elf_text_section
;
4735 case SHN_MIPS_ACOMMON
:
4736 /* Fall through. XXX Can we treat this as allocated data? */
4738 /* This section is used in a shared object. */
4739 if (elf_tdata (abfd
)->elf_data_section
== NULL
)
4741 asymbol
*elf_data_symbol
;
4742 asection
*elf_data_section
;
4743 bfd_size_type amt
= sizeof (asection
);
4745 elf_data_section
= bfd_zalloc (abfd
, amt
);
4746 if (elf_data_section
== NULL
)
4749 amt
= sizeof (asymbol
);
4750 elf_data_symbol
= bfd_zalloc (abfd
, amt
);
4751 if (elf_data_symbol
== NULL
)
4754 /* Initialize the section. */
4756 elf_tdata (abfd
)->elf_data_section
= elf_data_section
;
4757 elf_tdata (abfd
)->elf_data_symbol
= elf_data_symbol
;
4759 elf_data_section
->symbol
= elf_data_symbol
;
4760 elf_data_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_data_symbol
;
4762 elf_data_section
->name
= ".data";
4763 elf_data_section
->flags
= SEC_NO_FLAGS
;
4764 elf_data_section
->output_section
= NULL
;
4765 elf_data_section
->owner
= abfd
;
4766 elf_data_symbol
->name
= ".data";
4767 elf_data_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
4768 elf_data_symbol
->section
= elf_data_section
;
4770 /* This code used to do *secp = bfd_und_section_ptr if
4771 info->shared. I don't know why, and that doesn't make sense,
4772 so I took it out. */
4773 *secp
= elf_tdata (abfd
)->elf_data_section
;
4776 case SHN_MIPS_SUNDEFINED
:
4777 *secp
= bfd_und_section_ptr
;
4781 if (SGI_COMPAT (abfd
)
4783 && info
->hash
->creator
== abfd
->xvec
4784 && strcmp (*namep
, "__rld_obj_head") == 0)
4786 struct elf_link_hash_entry
*h
;
4787 struct bfd_link_hash_entry
*bh
;
4789 /* Mark __rld_obj_head as dynamic. */
4791 if (! (_bfd_generic_link_add_one_symbol
4792 (info
, abfd
, *namep
, BSF_GLOBAL
, *secp
, *valp
, NULL
, FALSE
,
4793 get_elf_backend_data (abfd
)->collect
, &bh
)))
4796 h
= (struct elf_link_hash_entry
*) bh
;
4797 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
4798 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4799 h
->type
= STT_OBJECT
;
4801 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
4804 mips_elf_hash_table (info
)->use_rld_obj_head
= TRUE
;
4807 /* If this is a mips16 text symbol, add 1 to the value to make it
4808 odd. This will cause something like .word SYM to come up with
4809 the right value when it is loaded into the PC. */
4810 if (sym
->st_other
== STO_MIPS16
)
4816 /* This hook function is called before the linker writes out a global
4817 symbol. We mark symbols as small common if appropriate. This is
4818 also where we undo the increment of the value for a mips16 symbol. */
4821 _bfd_mips_elf_link_output_symbol_hook
4822 (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4823 const char *name ATTRIBUTE_UNUSED
, Elf_Internal_Sym
*sym
,
4824 asection
*input_sec
, struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
)
4826 /* If we see a common symbol, which implies a relocatable link, then
4827 if a symbol was small common in an input file, mark it as small
4828 common in the output file. */
4829 if (sym
->st_shndx
== SHN_COMMON
4830 && strcmp (input_sec
->name
, ".scommon") == 0)
4831 sym
->st_shndx
= SHN_MIPS_SCOMMON
;
4833 if (sym
->st_other
== STO_MIPS16
)
4834 sym
->st_value
&= ~1;
4839 /* Functions for the dynamic linker. */
4841 /* Create dynamic sections when linking against a dynamic object. */
4844 _bfd_mips_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
4846 struct elf_link_hash_entry
*h
;
4847 struct bfd_link_hash_entry
*bh
;
4849 register asection
*s
;
4850 const char * const *namep
;
4852 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
4853 | SEC_LINKER_CREATED
| SEC_READONLY
);
4855 /* Mips ABI requests the .dynamic section to be read only. */
4856 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4859 if (! bfd_set_section_flags (abfd
, s
, flags
))
4863 /* We need to create .got section. */
4864 if (! mips_elf_create_got_section (abfd
, info
, FALSE
))
4867 if (! mips_elf_rel_dyn_section (elf_hash_table (info
)->dynobj
, TRUE
))
4870 /* Create .stub section. */
4871 if (bfd_get_section_by_name (abfd
,
4872 MIPS_ELF_STUB_SECTION_NAME (abfd
)) == NULL
)
4874 s
= bfd_make_section (abfd
, MIPS_ELF_STUB_SECTION_NAME (abfd
));
4876 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_CODE
)
4877 || ! bfd_set_section_alignment (abfd
, s
,
4878 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
4882 if ((IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
4884 && bfd_get_section_by_name (abfd
, ".rld_map") == NULL
)
4886 s
= bfd_make_section (abfd
, ".rld_map");
4888 || ! bfd_set_section_flags (abfd
, s
, flags
&~ (flagword
) SEC_READONLY
)
4889 || ! bfd_set_section_alignment (abfd
, s
,
4890 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
4894 /* On IRIX5, we adjust add some additional symbols and change the
4895 alignments of several sections. There is no ABI documentation
4896 indicating that this is necessary on IRIX6, nor any evidence that
4897 the linker takes such action. */
4898 if (IRIX_COMPAT (abfd
) == ict_irix5
)
4900 for (namep
= mips_elf_dynsym_rtproc_names
; *namep
!= NULL
; namep
++)
4903 if (! (_bfd_generic_link_add_one_symbol
4904 (info
, abfd
, *namep
, BSF_GLOBAL
, bfd_und_section_ptr
, 0,
4905 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
4908 h
= (struct elf_link_hash_entry
*) bh
;
4909 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
4910 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4911 h
->type
= STT_SECTION
;
4913 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
4917 /* We need to create a .compact_rel section. */
4918 if (SGI_COMPAT (abfd
))
4920 if (!mips_elf_create_compact_rel_section (abfd
, info
))
4924 /* Change alignments of some sections. */
4925 s
= bfd_get_section_by_name (abfd
, ".hash");
4927 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4928 s
= bfd_get_section_by_name (abfd
, ".dynsym");
4930 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4931 s
= bfd_get_section_by_name (abfd
, ".dynstr");
4933 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4934 s
= bfd_get_section_by_name (abfd
, ".reginfo");
4936 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4937 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4939 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4946 name
= SGI_COMPAT (abfd
) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
4948 if (!(_bfd_generic_link_add_one_symbol
4949 (info
, abfd
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
, 0,
4950 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
4953 h
= (struct elf_link_hash_entry
*) bh
;
4954 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
4955 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4956 h
->type
= STT_SECTION
;
4958 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
4961 if (! mips_elf_hash_table (info
)->use_rld_obj_head
)
4963 /* __rld_map is a four byte word located in the .data section
4964 and is filled in by the rtld to contain a pointer to
4965 the _r_debug structure. Its symbol value will be set in
4966 _bfd_mips_elf_finish_dynamic_symbol. */
4967 s
= bfd_get_section_by_name (abfd
, ".rld_map");
4968 BFD_ASSERT (s
!= NULL
);
4970 name
= SGI_COMPAT (abfd
) ? "__rld_map" : "__RLD_MAP";
4972 if (!(_bfd_generic_link_add_one_symbol
4973 (info
, abfd
, name
, BSF_GLOBAL
, s
, 0, NULL
, FALSE
,
4974 get_elf_backend_data (abfd
)->collect
, &bh
)))
4977 h
= (struct elf_link_hash_entry
*) bh
;
4978 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
4979 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4980 h
->type
= STT_OBJECT
;
4982 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
4990 /* Look through the relocs for a section during the first phase, and
4991 allocate space in the global offset table. */
4994 _bfd_mips_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
4995 asection
*sec
, const Elf_Internal_Rela
*relocs
)
4999 Elf_Internal_Shdr
*symtab_hdr
;
5000 struct elf_link_hash_entry
**sym_hashes
;
5001 struct mips_got_info
*g
;
5003 const Elf_Internal_Rela
*rel
;
5004 const Elf_Internal_Rela
*rel_end
;
5007 const struct elf_backend_data
*bed
;
5009 if (info
->relocatable
)
5012 dynobj
= elf_hash_table (info
)->dynobj
;
5013 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5014 sym_hashes
= elf_sym_hashes (abfd
);
5015 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
5017 /* Check for the mips16 stub sections. */
5019 name
= bfd_get_section_name (abfd
, sec
);
5020 if (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0)
5022 unsigned long r_symndx
;
5024 /* Look at the relocation information to figure out which symbol
5027 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
5029 if (r_symndx
< extsymoff
5030 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
5034 /* This stub is for a local symbol. This stub will only be
5035 needed if there is some relocation in this BFD, other
5036 than a 16 bit function call, which refers to this symbol. */
5037 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5039 Elf_Internal_Rela
*sec_relocs
;
5040 const Elf_Internal_Rela
*r
, *rend
;
5042 /* We can ignore stub sections when looking for relocs. */
5043 if ((o
->flags
& SEC_RELOC
) == 0
5044 || o
->reloc_count
== 0
5045 || strncmp (bfd_get_section_name (abfd
, o
), FN_STUB
,
5046 sizeof FN_STUB
- 1) == 0
5047 || strncmp (bfd_get_section_name (abfd
, o
), CALL_STUB
,
5048 sizeof CALL_STUB
- 1) == 0
5049 || strncmp (bfd_get_section_name (abfd
, o
), CALL_FP_STUB
,
5050 sizeof CALL_FP_STUB
- 1) == 0)
5054 = _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
5056 if (sec_relocs
== NULL
)
5059 rend
= sec_relocs
+ o
->reloc_count
;
5060 for (r
= sec_relocs
; r
< rend
; r
++)
5061 if (ELF_R_SYM (abfd
, r
->r_info
) == r_symndx
5062 && ELF_R_TYPE (abfd
, r
->r_info
) != R_MIPS16_26
)
5065 if (elf_section_data (o
)->relocs
!= sec_relocs
)
5074 /* There is no non-call reloc for this stub, so we do
5075 not need it. Since this function is called before
5076 the linker maps input sections to output sections, we
5077 can easily discard it by setting the SEC_EXCLUDE
5079 sec
->flags
|= SEC_EXCLUDE
;
5083 /* Record this stub in an array of local symbol stubs for
5085 if (elf_tdata (abfd
)->local_stubs
== NULL
)
5087 unsigned long symcount
;
5091 if (elf_bad_symtab (abfd
))
5092 symcount
= NUM_SHDR_ENTRIES (symtab_hdr
);
5094 symcount
= symtab_hdr
->sh_info
;
5095 amt
= symcount
* sizeof (asection
*);
5096 n
= bfd_zalloc (abfd
, amt
);
5099 elf_tdata (abfd
)->local_stubs
= n
;
5102 elf_tdata (abfd
)->local_stubs
[r_symndx
] = sec
;
5104 /* We don't need to set mips16_stubs_seen in this case.
5105 That flag is used to see whether we need to look through
5106 the global symbol table for stubs. We don't need to set
5107 it here, because we just have a local stub. */
5111 struct mips_elf_link_hash_entry
*h
;
5113 h
= ((struct mips_elf_link_hash_entry
*)
5114 sym_hashes
[r_symndx
- extsymoff
]);
5116 /* H is the symbol this stub is for. */
5119 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
5122 else if (strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
5123 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
5125 unsigned long r_symndx
;
5126 struct mips_elf_link_hash_entry
*h
;
5129 /* Look at the relocation information to figure out which symbol
5132 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
5134 if (r_symndx
< extsymoff
5135 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
5137 /* This stub was actually built for a static symbol defined
5138 in the same file. We assume that all static symbols in
5139 mips16 code are themselves mips16, so we can simply
5140 discard this stub. Since this function is called before
5141 the linker maps input sections to output sections, we can
5142 easily discard it by setting the SEC_EXCLUDE flag. */
5143 sec
->flags
|= SEC_EXCLUDE
;
5147 h
= ((struct mips_elf_link_hash_entry
*)
5148 sym_hashes
[r_symndx
- extsymoff
]);
5150 /* H is the symbol this stub is for. */
5152 if (strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
5153 loc
= &h
->call_fp_stub
;
5155 loc
= &h
->call_stub
;
5157 /* If we already have an appropriate stub for this function, we
5158 don't need another one, so we can discard this one. Since
5159 this function is called before the linker maps input sections
5160 to output sections, we can easily discard it by setting the
5161 SEC_EXCLUDE flag. We can also discard this section if we
5162 happen to already know that this is a mips16 function; it is
5163 not necessary to check this here, as it is checked later, but
5164 it is slightly faster to check now. */
5165 if (*loc
!= NULL
|| h
->root
.other
== STO_MIPS16
)
5167 sec
->flags
|= SEC_EXCLUDE
;
5172 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
5182 sgot
= mips_elf_got_section (dynobj
, FALSE
);
5187 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
5188 g
= mips_elf_section_data (sgot
)->u
.got_info
;
5189 BFD_ASSERT (g
!= NULL
);
5194 bed
= get_elf_backend_data (abfd
);
5195 rel_end
= relocs
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
5196 for (rel
= relocs
; rel
< rel_end
; ++rel
)
5198 unsigned long r_symndx
;
5199 unsigned int r_type
;
5200 struct elf_link_hash_entry
*h
;
5202 r_symndx
= ELF_R_SYM (abfd
, rel
->r_info
);
5203 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
5205 if (r_symndx
< extsymoff
)
5207 else if (r_symndx
>= extsymoff
+ NUM_SHDR_ENTRIES (symtab_hdr
))
5209 (*_bfd_error_handler
)
5210 (_("%s: Malformed reloc detected for section %s"),
5211 bfd_archive_filename (abfd
), name
);
5212 bfd_set_error (bfd_error_bad_value
);
5217 h
= sym_hashes
[r_symndx
- extsymoff
];
5219 /* This may be an indirect symbol created because of a version. */
5222 while (h
->root
.type
== bfd_link_hash_indirect
)
5223 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5227 /* Some relocs require a global offset table. */
5228 if (dynobj
== NULL
|| sgot
== NULL
)
5234 case R_MIPS_CALL_HI16
:
5235 case R_MIPS_CALL_LO16
:
5236 case R_MIPS_GOT_HI16
:
5237 case R_MIPS_GOT_LO16
:
5238 case R_MIPS_GOT_PAGE
:
5239 case R_MIPS_GOT_OFST
:
5240 case R_MIPS_GOT_DISP
:
5242 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5243 if (! mips_elf_create_got_section (dynobj
, info
, FALSE
))
5245 g
= mips_elf_got_info (dynobj
, &sgot
);
5252 && (info
->shared
|| h
!= NULL
)
5253 && (sec
->flags
& SEC_ALLOC
) != 0)
5254 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5262 if (!h
&& (r_type
== R_MIPS_CALL_LO16
5263 || r_type
== R_MIPS_GOT_LO16
5264 || r_type
== R_MIPS_GOT_DISP
))
5266 /* We may need a local GOT entry for this relocation. We
5267 don't count R_MIPS_GOT_PAGE because we can estimate the
5268 maximum number of pages needed by looking at the size of
5269 the segment. Similar comments apply to R_MIPS_GOT16 and
5270 R_MIPS_CALL16. We don't count R_MIPS_GOT_HI16, or
5271 R_MIPS_CALL_HI16 because these are always followed by an
5272 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
5273 if (! mips_elf_record_local_got_symbol (abfd
, r_symndx
,
5283 (*_bfd_error_handler
)
5284 (_("%s: CALL16 reloc at 0x%lx not against global symbol"),
5285 bfd_archive_filename (abfd
), (unsigned long) rel
->r_offset
);
5286 bfd_set_error (bfd_error_bad_value
);
5291 case R_MIPS_CALL_HI16
:
5292 case R_MIPS_CALL_LO16
:
5295 /* This symbol requires a global offset table entry. */
5296 if (! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5299 /* We need a stub, not a plt entry for the undefined
5300 function. But we record it as if it needs plt. See
5301 _bfd_elf_adjust_dynamic_symbol. */
5302 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
5307 case R_MIPS_GOT_PAGE
:
5308 /* If this is a global, overridable symbol, GOT_PAGE will
5309 decay to GOT_DISP, so we'll need a GOT entry for it. */
5314 struct mips_elf_link_hash_entry
*hmips
=
5315 (struct mips_elf_link_hash_entry
*) h
;
5317 while (hmips
->root
.root
.type
== bfd_link_hash_indirect
5318 || hmips
->root
.root
.type
== bfd_link_hash_warning
)
5319 hmips
= (struct mips_elf_link_hash_entry
*)
5320 hmips
->root
.root
.u
.i
.link
;
5322 if ((hmips
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)
5323 && ! (info
->shared
&& ! info
->symbolic
5324 && ! (hmips
->root
.elf_link_hash_flags
5325 & ELF_LINK_FORCED_LOCAL
)))
5331 case R_MIPS_GOT_HI16
:
5332 case R_MIPS_GOT_LO16
:
5333 case R_MIPS_GOT_DISP
:
5334 /* This symbol requires a global offset table entry. */
5335 if (h
&& ! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5342 if ((info
->shared
|| h
!= NULL
)
5343 && (sec
->flags
& SEC_ALLOC
) != 0)
5347 sreloc
= mips_elf_rel_dyn_section (dynobj
, TRUE
);
5351 #define MIPS_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
5354 /* When creating a shared object, we must copy these
5355 reloc types into the output file as R_MIPS_REL32
5356 relocs. We make room for this reloc in the
5357 .rel.dyn reloc section. */
5358 mips_elf_allocate_dynamic_relocations (dynobj
, 1);
5359 if ((sec
->flags
& MIPS_READONLY_SECTION
)
5360 == MIPS_READONLY_SECTION
)
5361 /* We tell the dynamic linker that there are
5362 relocations against the text segment. */
5363 info
->flags
|= DF_TEXTREL
;
5367 struct mips_elf_link_hash_entry
*hmips
;
5369 /* We only need to copy this reloc if the symbol is
5370 defined in a dynamic object. */
5371 hmips
= (struct mips_elf_link_hash_entry
*) h
;
5372 ++hmips
->possibly_dynamic_relocs
;
5373 if ((sec
->flags
& MIPS_READONLY_SECTION
)
5374 == MIPS_READONLY_SECTION
)
5375 /* We need it to tell the dynamic linker if there
5376 are relocations against the text segment. */
5377 hmips
->readonly_reloc
= TRUE
;
5380 /* Even though we don't directly need a GOT entry for
5381 this symbol, a symbol must have a dynamic symbol
5382 table index greater that DT_MIPS_GOTSYM if there are
5383 dynamic relocations against it. */
5387 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5388 if (! mips_elf_create_got_section (dynobj
, info
, TRUE
))
5390 g
= mips_elf_got_info (dynobj
, &sgot
);
5391 if (! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5396 if (SGI_COMPAT (abfd
))
5397 mips_elf_hash_table (info
)->compact_rel_size
+=
5398 sizeof (Elf32_External_crinfo
);
5402 case R_MIPS_GPREL16
:
5403 case R_MIPS_LITERAL
:
5404 case R_MIPS_GPREL32
:
5405 if (SGI_COMPAT (abfd
))
5406 mips_elf_hash_table (info
)->compact_rel_size
+=
5407 sizeof (Elf32_External_crinfo
);
5410 /* This relocation describes the C++ object vtable hierarchy.
5411 Reconstruct it for later use during GC. */
5412 case R_MIPS_GNU_VTINHERIT
:
5413 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
5417 /* This relocation describes which C++ vtable entries are actually
5418 used. Record for later use during GC. */
5419 case R_MIPS_GNU_VTENTRY
:
5420 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
5428 /* We must not create a stub for a symbol that has relocations
5429 related to taking the function's address. */
5435 struct mips_elf_link_hash_entry
*mh
;
5437 mh
= (struct mips_elf_link_hash_entry
*) h
;
5438 mh
->no_fn_stub
= TRUE
;
5442 case R_MIPS_CALL_HI16
:
5443 case R_MIPS_CALL_LO16
:
5448 /* If this reloc is not a 16 bit call, and it has a global
5449 symbol, then we will need the fn_stub if there is one.
5450 References from a stub section do not count. */
5452 && r_type
!= R_MIPS16_26
5453 && strncmp (bfd_get_section_name (abfd
, sec
), FN_STUB
,
5454 sizeof FN_STUB
- 1) != 0
5455 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_STUB
,
5456 sizeof CALL_STUB
- 1) != 0
5457 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_FP_STUB
,
5458 sizeof CALL_FP_STUB
- 1) != 0)
5460 struct mips_elf_link_hash_entry
*mh
;
5462 mh
= (struct mips_elf_link_hash_entry
*) h
;
5463 mh
->need_fn_stub
= TRUE
;
5471 _bfd_mips_relax_section (bfd
*abfd
, asection
*sec
,
5472 struct bfd_link_info
*link_info
,
5475 Elf_Internal_Rela
*internal_relocs
;
5476 Elf_Internal_Rela
*irel
, *irelend
;
5477 Elf_Internal_Shdr
*symtab_hdr
;
5478 bfd_byte
*contents
= NULL
;
5479 bfd_byte
*free_contents
= NULL
;
5481 bfd_boolean changed_contents
= FALSE
;
5482 bfd_vma sec_start
= sec
->output_section
->vma
+ sec
->output_offset
;
5483 Elf_Internal_Sym
*isymbuf
= NULL
;
5485 /* We are not currently changing any sizes, so only one pass. */
5488 if (link_info
->relocatable
)
5491 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
5492 link_info
->keep_memory
);
5493 if (internal_relocs
== NULL
)
5496 irelend
= internal_relocs
+ sec
->reloc_count
5497 * get_elf_backend_data (abfd
)->s
->int_rels_per_ext_rel
;
5498 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5499 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
5501 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
5504 bfd_signed_vma sym_offset
;
5505 unsigned int r_type
;
5506 unsigned long r_symndx
;
5508 unsigned long instruction
;
5510 /* Turn jalr into bgezal, and jr into beq, if they're marked
5511 with a JALR relocation, that indicate where they jump to.
5512 This saves some pipeline bubbles. */
5513 r_type
= ELF_R_TYPE (abfd
, irel
->r_info
);
5514 if (r_type
!= R_MIPS_JALR
)
5517 r_symndx
= ELF_R_SYM (abfd
, irel
->r_info
);
5518 /* Compute the address of the jump target. */
5519 if (r_symndx
>= extsymoff
)
5521 struct mips_elf_link_hash_entry
*h
5522 = ((struct mips_elf_link_hash_entry
*)
5523 elf_sym_hashes (abfd
) [r_symndx
- extsymoff
]);
5525 while (h
->root
.root
.type
== bfd_link_hash_indirect
5526 || h
->root
.root
.type
== bfd_link_hash_warning
)
5527 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
5529 /* If a symbol is undefined, or if it may be overridden,
5531 if (! ((h
->root
.root
.type
== bfd_link_hash_defined
5532 || h
->root
.root
.type
== bfd_link_hash_defweak
)
5533 && h
->root
.root
.u
.def
.section
)
5534 || (link_info
->shared
&& ! link_info
->symbolic
5535 && ! (h
->root
.elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
)))
5538 sym_sec
= h
->root
.root
.u
.def
.section
;
5539 if (sym_sec
->output_section
)
5540 symval
= (h
->root
.root
.u
.def
.value
5541 + sym_sec
->output_section
->vma
5542 + sym_sec
->output_offset
);
5544 symval
= h
->root
.root
.u
.def
.value
;
5548 Elf_Internal_Sym
*isym
;
5550 /* Read this BFD's symbols if we haven't done so already. */
5551 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
5553 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5554 if (isymbuf
== NULL
)
5555 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
5556 symtab_hdr
->sh_info
, 0,
5558 if (isymbuf
== NULL
)
5562 isym
= isymbuf
+ r_symndx
;
5563 if (isym
->st_shndx
== SHN_UNDEF
)
5565 else if (isym
->st_shndx
== SHN_ABS
)
5566 sym_sec
= bfd_abs_section_ptr
;
5567 else if (isym
->st_shndx
== SHN_COMMON
)
5568 sym_sec
= bfd_com_section_ptr
;
5571 = bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
5572 symval
= isym
->st_value
5573 + sym_sec
->output_section
->vma
5574 + sym_sec
->output_offset
;
5577 /* Compute branch offset, from delay slot of the jump to the
5579 sym_offset
= (symval
+ irel
->r_addend
)
5580 - (sec_start
+ irel
->r_offset
+ 4);
5582 /* Branch offset must be properly aligned. */
5583 if ((sym_offset
& 3) != 0)
5588 /* Check that it's in range. */
5589 if (sym_offset
< -0x8000 || sym_offset
>= 0x8000)
5592 /* Get the section contents if we haven't done so already. */
5593 if (contents
== NULL
)
5595 /* Get cached copy if it exists. */
5596 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
5597 contents
= elf_section_data (sec
)->this_hdr
.contents
;
5600 contents
= bfd_malloc (sec
->_raw_size
);
5601 if (contents
== NULL
)
5604 free_contents
= contents
;
5605 if (! bfd_get_section_contents (abfd
, sec
, contents
,
5611 instruction
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
5613 /* If it was jalr <reg>, turn it into bgezal $zero, <target>. */
5614 if ((instruction
& 0xfc1fffff) == 0x0000f809)
5615 instruction
= 0x04110000;
5616 /* If it was jr <reg>, turn it into b <target>. */
5617 else if ((instruction
& 0xfc1fffff) == 0x00000008)
5618 instruction
= 0x10000000;
5622 instruction
|= (sym_offset
& 0xffff);
5623 bfd_put_32 (abfd
, instruction
, contents
+ irel
->r_offset
);
5624 changed_contents
= TRUE
;
5627 if (contents
!= NULL
5628 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
5630 if (!changed_contents
&& !link_info
->keep_memory
)
5634 /* Cache the section contents for elf_link_input_bfd. */
5635 elf_section_data (sec
)->this_hdr
.contents
= contents
;
5641 if (free_contents
!= NULL
)
5642 free (free_contents
);
5646 /* Adjust a symbol defined by a dynamic object and referenced by a
5647 regular object. The current definition is in some section of the
5648 dynamic object, but we're not including those sections. We have to
5649 change the definition to something the rest of the link can
5653 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
5654 struct elf_link_hash_entry
*h
)
5657 struct mips_elf_link_hash_entry
*hmips
;
5660 dynobj
= elf_hash_table (info
)->dynobj
;
5662 /* Make sure we know what is going on here. */
5663 BFD_ASSERT (dynobj
!= NULL
5664 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
5665 || h
->weakdef
!= NULL
5666 || ((h
->elf_link_hash_flags
5667 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
5668 && (h
->elf_link_hash_flags
5669 & ELF_LINK_HASH_REF_REGULAR
) != 0
5670 && (h
->elf_link_hash_flags
5671 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
5673 /* If this symbol is defined in a dynamic object, we need to copy
5674 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
5676 hmips
= (struct mips_elf_link_hash_entry
*) h
;
5677 if (! info
->relocatable
5678 && hmips
->possibly_dynamic_relocs
!= 0
5679 && (h
->root
.type
== bfd_link_hash_defweak
5680 || (h
->elf_link_hash_flags
5681 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
5683 mips_elf_allocate_dynamic_relocations (dynobj
,
5684 hmips
->possibly_dynamic_relocs
);
5685 if (hmips
->readonly_reloc
)
5686 /* We tell the dynamic linker that there are relocations
5687 against the text segment. */
5688 info
->flags
|= DF_TEXTREL
;
5691 /* For a function, create a stub, if allowed. */
5692 if (! hmips
->no_fn_stub
5693 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
5695 if (! elf_hash_table (info
)->dynamic_sections_created
)
5698 /* If this symbol is not defined in a regular file, then set
5699 the symbol to the stub location. This is required to make
5700 function pointers compare as equal between the normal
5701 executable and the shared library. */
5702 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
5704 /* We need .stub section. */
5705 s
= bfd_get_section_by_name (dynobj
,
5706 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
5707 BFD_ASSERT (s
!= NULL
);
5709 h
->root
.u
.def
.section
= s
;
5710 h
->root
.u
.def
.value
= s
->_raw_size
;
5712 /* XXX Write this stub address somewhere. */
5713 h
->plt
.offset
= s
->_raw_size
;
5715 /* Make room for this stub code. */
5716 s
->_raw_size
+= MIPS_FUNCTION_STUB_SIZE
;
5718 /* The last half word of the stub will be filled with the index
5719 of this symbol in .dynsym section. */
5723 else if ((h
->type
== STT_FUNC
)
5724 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0)
5726 /* This will set the entry for this symbol in the GOT to 0, and
5727 the dynamic linker will take care of this. */
5728 h
->root
.u
.def
.value
= 0;
5732 /* If this is a weak symbol, and there is a real definition, the
5733 processor independent code will have arranged for us to see the
5734 real definition first, and we can just use the same value. */
5735 if (h
->weakdef
!= NULL
)
5737 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
5738 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
5739 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
5740 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
5744 /* This is a reference to a symbol defined by a dynamic object which
5745 is not a function. */
5750 /* This function is called after all the input files have been read,
5751 and the input sections have been assigned to output sections. We
5752 check for any mips16 stub sections that we can discard. */
5755 _bfd_mips_elf_always_size_sections (bfd
*output_bfd
,
5756 struct bfd_link_info
*info
)
5762 struct mips_got_info
*g
;
5764 bfd_size_type loadable_size
= 0;
5765 bfd_size_type local_gotno
;
5768 /* The .reginfo section has a fixed size. */
5769 ri
= bfd_get_section_by_name (output_bfd
, ".reginfo");
5771 bfd_set_section_size (output_bfd
, ri
, sizeof (Elf32_External_RegInfo
));
5773 if (! (info
->relocatable
5774 || ! mips_elf_hash_table (info
)->mips16_stubs_seen
))
5775 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
5776 mips_elf_check_mips16_stubs
, NULL
);
5778 dynobj
= elf_hash_table (info
)->dynobj
;
5780 /* Relocatable links don't have it. */
5783 g
= mips_elf_got_info (dynobj
, &s
);
5787 /* Calculate the total loadable size of the output. That
5788 will give us the maximum number of GOT_PAGE entries
5790 for (sub
= info
->input_bfds
; sub
; sub
= sub
->link_next
)
5792 asection
*subsection
;
5794 for (subsection
= sub
->sections
;
5796 subsection
= subsection
->next
)
5798 if ((subsection
->flags
& SEC_ALLOC
) == 0)
5800 loadable_size
+= ((subsection
->_raw_size
+ 0xf)
5801 &~ (bfd_size_type
) 0xf);
5805 /* There has to be a global GOT entry for every symbol with
5806 a dynamic symbol table index of DT_MIPS_GOTSYM or
5807 higher. Therefore, it make sense to put those symbols
5808 that need GOT entries at the end of the symbol table. We
5810 if (! mips_elf_sort_hash_table (info
, 1))
5813 if (g
->global_gotsym
!= NULL
)
5814 i
= elf_hash_table (info
)->dynsymcount
- g
->global_gotsym
->dynindx
;
5816 /* If there are no global symbols, or none requiring
5817 relocations, then GLOBAL_GOTSYM will be NULL. */
5820 /* In the worst case, we'll get one stub per dynamic symbol, plus
5821 one to account for the dummy entry at the end required by IRIX
5823 loadable_size
+= MIPS_FUNCTION_STUB_SIZE
* (i
+ 1);
5825 /* Assume there are two loadable segments consisting of
5826 contiguous sections. Is 5 enough? */
5827 local_gotno
= (loadable_size
>> 16) + 5;
5829 g
->local_gotno
+= local_gotno
;
5830 s
->_raw_size
+= g
->local_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
5832 g
->global_gotno
= i
;
5833 s
->_raw_size
+= i
* MIPS_ELF_GOT_SIZE (output_bfd
);
5835 if (s
->_raw_size
> MIPS_ELF_GOT_MAX_SIZE (output_bfd
)
5836 && ! mips_elf_multi_got (output_bfd
, info
, g
, s
, local_gotno
))
5842 /* Set the sizes of the dynamic sections. */
5845 _bfd_mips_elf_size_dynamic_sections (bfd
*output_bfd
,
5846 struct bfd_link_info
*info
)
5850 bfd_boolean reltext
;
5852 dynobj
= elf_hash_table (info
)->dynobj
;
5853 BFD_ASSERT (dynobj
!= NULL
);
5855 if (elf_hash_table (info
)->dynamic_sections_created
)
5857 /* Set the contents of the .interp section to the interpreter. */
5858 if (info
->executable
)
5860 s
= bfd_get_section_by_name (dynobj
, ".interp");
5861 BFD_ASSERT (s
!= NULL
);
5863 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd
)) + 1;
5865 = (bfd_byte
*) ELF_DYNAMIC_INTERPRETER (output_bfd
);
5869 /* The check_relocs and adjust_dynamic_symbol entry points have
5870 determined the sizes of the various dynamic sections. Allocate
5873 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
5878 /* It's OK to base decisions on the section name, because none
5879 of the dynobj section names depend upon the input files. */
5880 name
= bfd_get_section_name (dynobj
, s
);
5882 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
5887 if (strncmp (name
, ".rel", 4) == 0)
5889 if (s
->_raw_size
== 0)
5891 /* We only strip the section if the output section name
5892 has the same name. Otherwise, there might be several
5893 input sections for this output section. FIXME: This
5894 code is probably not needed these days anyhow, since
5895 the linker now does not create empty output sections. */
5896 if (s
->output_section
!= NULL
5898 bfd_get_section_name (s
->output_section
->owner
,
5899 s
->output_section
)) == 0)
5904 const char *outname
;
5907 /* If this relocation section applies to a read only
5908 section, then we probably need a DT_TEXTREL entry.
5909 If the relocation section is .rel.dyn, we always
5910 assert a DT_TEXTREL entry rather than testing whether
5911 there exists a relocation to a read only section or
5913 outname
= bfd_get_section_name (output_bfd
,
5915 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
5917 && (target
->flags
& SEC_READONLY
) != 0
5918 && (target
->flags
& SEC_ALLOC
) != 0)
5919 || strcmp (outname
, ".rel.dyn") == 0)
5922 /* We use the reloc_count field as a counter if we need
5923 to copy relocs into the output file. */
5924 if (strcmp (name
, ".rel.dyn") != 0)
5927 /* If combreloc is enabled, elf_link_sort_relocs() will
5928 sort relocations, but in a different way than we do,
5929 and before we're done creating relocations. Also, it
5930 will move them around between input sections'
5931 relocation's contents, so our sorting would be
5932 broken, so don't let it run. */
5933 info
->combreloc
= 0;
5936 else if (strncmp (name
, ".got", 4) == 0)
5938 /* _bfd_mips_elf_always_size_sections() has already done
5939 most of the work, but some symbols may have been mapped
5940 to versions that we must now resolve in the got_entries
5942 struct mips_got_info
*gg
= mips_elf_got_info (dynobj
, NULL
);
5943 struct mips_got_info
*g
= gg
;
5944 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
5945 unsigned int needed_relocs
= 0;
5949 set_got_offset_arg
.value
= MIPS_ELF_GOT_SIZE (output_bfd
);
5950 set_got_offset_arg
.info
= info
;
5952 mips_elf_resolve_final_got_entries (gg
);
5953 for (g
= gg
->next
; g
&& g
->next
!= gg
; g
= g
->next
)
5955 unsigned int save_assign
;
5957 mips_elf_resolve_final_got_entries (g
);
5959 /* Assign offsets to global GOT entries. */
5960 save_assign
= g
->assigned_gotno
;
5961 g
->assigned_gotno
= g
->local_gotno
;
5962 set_got_offset_arg
.g
= g
;
5963 set_got_offset_arg
.needed_relocs
= 0;
5964 htab_traverse (g
->got_entries
,
5965 mips_elf_set_global_got_offset
,
5966 &set_got_offset_arg
);
5967 needed_relocs
+= set_got_offset_arg
.needed_relocs
;
5968 BFD_ASSERT (g
->assigned_gotno
- g
->local_gotno
5969 <= g
->global_gotno
);
5971 g
->assigned_gotno
= save_assign
;
5974 needed_relocs
+= g
->local_gotno
- g
->assigned_gotno
;
5975 BFD_ASSERT (g
->assigned_gotno
== g
->next
->local_gotno
5976 + g
->next
->global_gotno
5977 + MIPS_RESERVED_GOTNO
);
5982 mips_elf_allocate_dynamic_relocations (dynobj
, needed_relocs
);
5985 else if (strcmp (name
, MIPS_ELF_STUB_SECTION_NAME (output_bfd
)) == 0)
5987 /* IRIX rld assumes that the function stub isn't at the end
5988 of .text section. So put a dummy. XXX */
5989 s
->_raw_size
+= MIPS_FUNCTION_STUB_SIZE
;
5991 else if (! info
->shared
5992 && ! mips_elf_hash_table (info
)->use_rld_obj_head
5993 && strncmp (name
, ".rld_map", 8) == 0)
5995 /* We add a room for __rld_map. It will be filled in by the
5996 rtld to contain a pointer to the _r_debug structure. */
5999 else if (SGI_COMPAT (output_bfd
)
6000 && strncmp (name
, ".compact_rel", 12) == 0)
6001 s
->_raw_size
+= mips_elf_hash_table (info
)->compact_rel_size
;
6002 else if (strncmp (name
, ".init", 5) != 0)
6004 /* It's not one of our sections, so don't allocate space. */
6010 _bfd_strip_section_from_output (info
, s
);
6014 /* Allocate memory for the section contents. */
6015 s
->contents
= bfd_zalloc (dynobj
, s
->_raw_size
);
6016 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
6018 bfd_set_error (bfd_error_no_memory
);
6023 if (elf_hash_table (info
)->dynamic_sections_created
)
6025 /* Add some entries to the .dynamic section. We fill in the
6026 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
6027 must add the entries now so that we get the correct size for
6028 the .dynamic section. The DT_DEBUG entry is filled in by the
6029 dynamic linker and used by the debugger. */
6032 /* SGI object has the equivalence of DT_DEBUG in the
6033 DT_MIPS_RLD_MAP entry. */
6034 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_MAP
, 0))
6036 if (!SGI_COMPAT (output_bfd
))
6038 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
6044 /* Shared libraries on traditional mips have DT_DEBUG. */
6045 if (!SGI_COMPAT (output_bfd
))
6047 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
6052 if (reltext
&& SGI_COMPAT (output_bfd
))
6053 info
->flags
|= DF_TEXTREL
;
6055 if ((info
->flags
& DF_TEXTREL
) != 0)
6057 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_TEXTREL
, 0))
6061 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTGOT
, 0))
6064 if (mips_elf_rel_dyn_section (dynobj
, FALSE
))
6066 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_REL
, 0))
6069 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELSZ
, 0))
6072 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELENT
, 0))
6076 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_VERSION
, 0))
6079 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_FLAGS
, 0))
6083 /* Time stamps in executable files are a bad idea. */
6084 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_TIME_STAMP
, 0))
6089 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_ICHECKSUM
, 0))
6094 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_IVERSION
, 0))
6098 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_BASE_ADDRESS
, 0))
6101 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LOCAL_GOTNO
, 0))
6104 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_SYMTABNO
, 0))
6107 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_UNREFEXTNO
, 0))
6110 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_GOTSYM
, 0))
6113 if (IRIX_COMPAT (dynobj
) == ict_irix5
6114 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_HIPAGENO
, 0))
6117 if (IRIX_COMPAT (dynobj
) == ict_irix6
6118 && (bfd_get_section_by_name
6119 (dynobj
, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj
)))
6120 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_OPTIONS
, 0))
6127 /* Relocate a MIPS ELF section. */
6130 _bfd_mips_elf_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
6131 bfd
*input_bfd
, asection
*input_section
,
6132 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
6133 Elf_Internal_Sym
*local_syms
,
6134 asection
**local_sections
)
6136 Elf_Internal_Rela
*rel
;
6137 const Elf_Internal_Rela
*relend
;
6139 bfd_boolean use_saved_addend_p
= FALSE
;
6140 const struct elf_backend_data
*bed
;
6142 bed
= get_elf_backend_data (output_bfd
);
6143 relend
= relocs
+ input_section
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
6144 for (rel
= relocs
; rel
< relend
; ++rel
)
6148 reloc_howto_type
*howto
;
6149 bfd_boolean require_jalx
;
6150 /* TRUE if the relocation is a RELA relocation, rather than a
6152 bfd_boolean rela_relocation_p
= TRUE
;
6153 unsigned int r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
6156 /* Find the relocation howto for this relocation. */
6157 if (r_type
== R_MIPS_64
&& ! NEWABI_P (input_bfd
))
6159 /* Some 32-bit code uses R_MIPS_64. In particular, people use
6160 64-bit code, but make sure all their addresses are in the
6161 lowermost or uppermost 32-bit section of the 64-bit address
6162 space. Thus, when they use an R_MIPS_64 they mean what is
6163 usually meant by R_MIPS_32, with the exception that the
6164 stored value is sign-extended to 64 bits. */
6165 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, R_MIPS_32
, FALSE
);
6167 /* On big-endian systems, we need to lie about the position
6169 if (bfd_big_endian (input_bfd
))
6173 /* NewABI defaults to RELA relocations. */
6174 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, r_type
,
6175 NEWABI_P (input_bfd
)
6176 && (MIPS_RELOC_RELA_P
6177 (input_bfd
, input_section
,
6180 if (!use_saved_addend_p
)
6182 Elf_Internal_Shdr
*rel_hdr
;
6184 /* If these relocations were originally of the REL variety,
6185 we must pull the addend out of the field that will be
6186 relocated. Otherwise, we simply use the contents of the
6187 RELA relocation. To determine which flavor or relocation
6188 this is, we depend on the fact that the INPUT_SECTION's
6189 REL_HDR is read before its REL_HDR2. */
6190 rel_hdr
= &elf_section_data (input_section
)->rel_hdr
;
6191 if ((size_t) (rel
- relocs
)
6192 >= (NUM_SHDR_ENTRIES (rel_hdr
) * bed
->s
->int_rels_per_ext_rel
))
6193 rel_hdr
= elf_section_data (input_section
)->rel_hdr2
;
6194 if (rel_hdr
->sh_entsize
== MIPS_ELF_REL_SIZE (input_bfd
))
6196 /* Note that this is a REL relocation. */
6197 rela_relocation_p
= FALSE
;
6199 /* Get the addend, which is stored in the input file. */
6200 addend
= mips_elf_obtain_contents (howto
, rel
, input_bfd
,
6202 addend
&= howto
->src_mask
;
6204 /* For some kinds of relocations, the ADDEND is a
6205 combination of the addend stored in two different
6207 if (r_type
== R_MIPS_HI16
6208 || (r_type
== R_MIPS_GOT16
6209 && mips_elf_local_relocation_p (input_bfd
, rel
,
6210 local_sections
, FALSE
)))
6213 const Elf_Internal_Rela
*lo16_relocation
;
6214 reloc_howto_type
*lo16_howto
;
6216 /* The combined value is the sum of the HI16 addend,
6217 left-shifted by sixteen bits, and the LO16
6218 addend, sign extended. (Usually, the code does
6219 a `lui' of the HI16 value, and then an `addiu' of
6222 Scan ahead to find a matching LO16 relocation.
6224 According to the MIPS ELF ABI, the R_MIPS_LO16
6225 relocation must be immediately following.
6226 However, for the IRIX6 ABI, the next relocation
6227 may be a composed relocation consisting of
6228 several relocations for the same address. In
6229 that case, the R_MIPS_LO16 relocation may occur
6230 as one of these. We permit a similar extension
6231 in general, as that is useful for GCC. */
6232 lo16_relocation
= mips_elf_next_relocation (input_bfd
,
6235 if (lo16_relocation
== NULL
)
6238 /* Obtain the addend kept there. */
6239 lo16_howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
,
6240 R_MIPS_LO16
, FALSE
);
6241 l
= mips_elf_obtain_contents (lo16_howto
, lo16_relocation
,
6242 input_bfd
, contents
);
6243 l
&= lo16_howto
->src_mask
;
6244 l
<<= lo16_howto
->rightshift
;
6245 l
= _bfd_mips_elf_sign_extend (l
, 16);
6249 /* Compute the combined addend. */
6252 else if (r_type
== R_MIPS16_GPREL
)
6254 /* The addend is scrambled in the object file. See
6255 mips_elf_perform_relocation for details on the
6257 addend
= (((addend
& 0x1f0000) >> 5)
6258 | ((addend
& 0x7e00000) >> 16)
6262 addend
<<= howto
->rightshift
;
6265 addend
= rel
->r_addend
;
6268 if (info
->relocatable
)
6270 Elf_Internal_Sym
*sym
;
6271 unsigned long r_symndx
;
6273 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
)
6274 && bfd_big_endian (input_bfd
))
6277 /* Since we're just relocating, all we need to do is copy
6278 the relocations back out to the object file, unless
6279 they're against a section symbol, in which case we need
6280 to adjust by the section offset, or unless they're GP
6281 relative in which case we need to adjust by the amount
6282 that we're adjusting GP in this relocatable object. */
6284 if (! mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
,
6286 /* There's nothing to do for non-local relocations. */
6289 if (r_type
== R_MIPS16_GPREL
6290 || r_type
== R_MIPS_GPREL16
6291 || r_type
== R_MIPS_GPREL32
6292 || r_type
== R_MIPS_LITERAL
)
6293 addend
-= (_bfd_get_gp_value (output_bfd
)
6294 - _bfd_get_gp_value (input_bfd
));
6296 r_symndx
= ELF_R_SYM (output_bfd
, rel
->r_info
);
6297 sym
= local_syms
+ r_symndx
;
6298 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6299 /* Adjust the addend appropriately. */
6300 addend
+= local_sections
[r_symndx
]->output_offset
;
6302 if (rela_relocation_p
)
6303 /* If this is a RELA relocation, just update the addend. */
6304 rel
->r_addend
= addend
;
6307 if (r_type
== R_MIPS_HI16
6308 || r_type
== R_MIPS_GOT16
)
6309 addend
= mips_elf_high (addend
);
6310 else if (r_type
== R_MIPS_HIGHER
)
6311 addend
= mips_elf_higher (addend
);
6312 else if (r_type
== R_MIPS_HIGHEST
)
6313 addend
= mips_elf_highest (addend
);
6315 addend
>>= howto
->rightshift
;
6317 /* We use the source mask, rather than the destination
6318 mask because the place to which we are writing will be
6319 source of the addend in the final link. */
6320 addend
&= howto
->src_mask
;
6322 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
6323 /* See the comment above about using R_MIPS_64 in the 32-bit
6324 ABI. Here, we need to update the addend. It would be
6325 possible to get away with just using the R_MIPS_32 reloc
6326 but for endianness. */
6332 if (addend
& ((bfd_vma
) 1 << 31))
6334 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
6341 /* If we don't know that we have a 64-bit type,
6342 do two separate stores. */
6343 if (bfd_big_endian (input_bfd
))
6345 /* Store the sign-bits (which are most significant)
6347 low_bits
= sign_bits
;
6353 high_bits
= sign_bits
;
6355 bfd_put_32 (input_bfd
, low_bits
,
6356 contents
+ rel
->r_offset
);
6357 bfd_put_32 (input_bfd
, high_bits
,
6358 contents
+ rel
->r_offset
+ 4);
6362 if (! mips_elf_perform_relocation (info
, howto
, rel
, addend
,
6363 input_bfd
, input_section
,
6368 /* Go on to the next relocation. */
6372 /* In the N32 and 64-bit ABIs there may be multiple consecutive
6373 relocations for the same offset. In that case we are
6374 supposed to treat the output of each relocation as the addend
6376 if (rel
+ 1 < relend
6377 && rel
->r_offset
== rel
[1].r_offset
6378 && ELF_R_TYPE (input_bfd
, rel
[1].r_info
) != R_MIPS_NONE
)
6379 use_saved_addend_p
= TRUE
;
6381 use_saved_addend_p
= FALSE
;
6383 /* Figure out what value we are supposed to relocate. */
6384 switch (mips_elf_calculate_relocation (output_bfd
, input_bfd
,
6385 input_section
, info
, rel
,
6386 addend
, howto
, local_syms
,
6387 local_sections
, &value
,
6388 &name
, &require_jalx
,
6389 use_saved_addend_p
))
6391 case bfd_reloc_continue
:
6392 /* There's nothing to do. */
6395 case bfd_reloc_undefined
:
6396 /* mips_elf_calculate_relocation already called the
6397 undefined_symbol callback. There's no real point in
6398 trying to perform the relocation at this point, so we
6399 just skip ahead to the next relocation. */
6402 case bfd_reloc_notsupported
:
6403 msg
= _("internal error: unsupported relocation error");
6404 info
->callbacks
->warning
6405 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
6408 case bfd_reloc_overflow
:
6409 if (use_saved_addend_p
)
6410 /* Ignore overflow until we reach the last relocation for
6411 a given location. */
6415 BFD_ASSERT (name
!= NULL
);
6416 if (! ((*info
->callbacks
->reloc_overflow
)
6417 (info
, name
, howto
->name
, 0,
6418 input_bfd
, input_section
, rel
->r_offset
)))
6431 /* If we've got another relocation for the address, keep going
6432 until we reach the last one. */
6433 if (use_saved_addend_p
)
6439 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
6440 /* See the comment above about using R_MIPS_64 in the 32-bit
6441 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
6442 that calculated the right value. Now, however, we
6443 sign-extend the 32-bit result to 64-bits, and store it as a
6444 64-bit value. We are especially generous here in that we
6445 go to extreme lengths to support this usage on systems with
6446 only a 32-bit VMA. */
6452 if (value
& ((bfd_vma
) 1 << 31))
6454 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
6461 /* If we don't know that we have a 64-bit type,
6462 do two separate stores. */
6463 if (bfd_big_endian (input_bfd
))
6465 /* Undo what we did above. */
6467 /* Store the sign-bits (which are most significant)
6469 low_bits
= sign_bits
;
6475 high_bits
= sign_bits
;
6477 bfd_put_32 (input_bfd
, low_bits
,
6478 contents
+ rel
->r_offset
);
6479 bfd_put_32 (input_bfd
, high_bits
,
6480 contents
+ rel
->r_offset
+ 4);
6484 /* Actually perform the relocation. */
6485 if (! mips_elf_perform_relocation (info
, howto
, rel
, value
,
6486 input_bfd
, input_section
,
6487 contents
, require_jalx
))
6494 /* If NAME is one of the special IRIX6 symbols defined by the linker,
6495 adjust it appropriately now. */
6498 mips_elf_irix6_finish_dynamic_symbol (bfd
*abfd ATTRIBUTE_UNUSED
,
6499 const char *name
, Elf_Internal_Sym
*sym
)
6501 /* The linker script takes care of providing names and values for
6502 these, but we must place them into the right sections. */
6503 static const char* const text_section_symbols
[] = {
6506 "__dso_displacement",
6508 "__program_header_table",
6512 static const char* const data_section_symbols
[] = {
6520 const char* const *p
;
6523 for (i
= 0; i
< 2; ++i
)
6524 for (p
= (i
== 0) ? text_section_symbols
: data_section_symbols
;
6527 if (strcmp (*p
, name
) == 0)
6529 /* All of these symbols are given type STT_SECTION by the
6531 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6532 sym
->st_other
= STO_PROTECTED
;
6534 /* The IRIX linker puts these symbols in special sections. */
6536 sym
->st_shndx
= SHN_MIPS_TEXT
;
6538 sym
->st_shndx
= SHN_MIPS_DATA
;
6544 /* Finish up dynamic symbol handling. We set the contents of various
6545 dynamic sections here. */
6548 _bfd_mips_elf_finish_dynamic_symbol (bfd
*output_bfd
,
6549 struct bfd_link_info
*info
,
6550 struct elf_link_hash_entry
*h
,
6551 Elf_Internal_Sym
*sym
)
6555 struct mips_got_info
*g
, *gg
;
6558 dynobj
= elf_hash_table (info
)->dynobj
;
6560 if (h
->plt
.offset
!= MINUS_ONE
)
6563 bfd_byte stub
[MIPS_FUNCTION_STUB_SIZE
];
6565 /* This symbol has a stub. Set it up. */
6567 BFD_ASSERT (h
->dynindx
!= -1);
6569 s
= bfd_get_section_by_name (dynobj
,
6570 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
6571 BFD_ASSERT (s
!= NULL
);
6573 /* FIXME: Can h->dynindex be more than 64K? */
6574 if (h
->dynindx
& 0xffff0000)
6577 /* Fill the stub. */
6578 bfd_put_32 (output_bfd
, STUB_LW (output_bfd
), stub
);
6579 bfd_put_32 (output_bfd
, STUB_MOVE (output_bfd
), stub
+ 4);
6580 bfd_put_32 (output_bfd
, STUB_JALR
, stub
+ 8);
6581 bfd_put_32 (output_bfd
, STUB_LI16 (output_bfd
) + h
->dynindx
, stub
+ 12);
6583 BFD_ASSERT (h
->plt
.offset
<= s
->_raw_size
);
6584 memcpy (s
->contents
+ h
->plt
.offset
, stub
, MIPS_FUNCTION_STUB_SIZE
);
6586 /* Mark the symbol as undefined. plt.offset != -1 occurs
6587 only for the referenced symbol. */
6588 sym
->st_shndx
= SHN_UNDEF
;
6590 /* The run-time linker uses the st_value field of the symbol
6591 to reset the global offset table entry for this external
6592 to its stub address when unlinking a shared object. */
6593 sym
->st_value
= (s
->output_section
->vma
+ s
->output_offset
6597 BFD_ASSERT (h
->dynindx
!= -1
6598 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0);
6600 sgot
= mips_elf_got_section (dynobj
, FALSE
);
6601 BFD_ASSERT (sgot
!= NULL
);
6602 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
6603 g
= mips_elf_section_data (sgot
)->u
.got_info
;
6604 BFD_ASSERT (g
!= NULL
);
6606 /* Run through the global symbol table, creating GOT entries for all
6607 the symbols that need them. */
6608 if (g
->global_gotsym
!= NULL
6609 && h
->dynindx
>= g
->global_gotsym
->dynindx
)
6614 value
= sym
->st_value
;
6615 offset
= mips_elf_global_got_index (dynobj
, output_bfd
, h
);
6616 MIPS_ELF_PUT_WORD (output_bfd
, value
, sgot
->contents
+ offset
);
6619 if (g
->next
&& h
->dynindx
!= -1)
6621 struct mips_got_entry e
, *p
;
6627 e
.abfd
= output_bfd
;
6629 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
6631 for (g
= g
->next
; g
->next
!= gg
; g
= g
->next
)
6634 && (p
= (struct mips_got_entry
*) htab_find (g
->got_entries
,
6639 || (elf_hash_table (info
)->dynamic_sections_created
6641 && ((p
->d
.h
->root
.elf_link_hash_flags
6642 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0)
6643 && ((p
->d
.h
->root
.elf_link_hash_flags
6644 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
6646 /* Create an R_MIPS_REL32 relocation for this entry. Due to
6647 the various compatibility problems, it's easier to mock
6648 up an R_MIPS_32 or R_MIPS_64 relocation and leave
6649 mips_elf_create_dynamic_relocation to calculate the
6650 appropriate addend. */
6651 Elf_Internal_Rela rel
[3];
6653 memset (rel
, 0, sizeof (rel
));
6654 if (ABI_64_P (output_bfd
))
6655 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_64
);
6657 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_32
);
6658 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
6661 if (! (mips_elf_create_dynamic_relocation
6662 (output_bfd
, info
, rel
,
6663 e
.d
.h
, NULL
, sym
->st_value
, &entry
, sgot
)))
6667 entry
= sym
->st_value
;
6668 MIPS_ELF_PUT_WORD (output_bfd
, entry
, sgot
->contents
+ offset
);
6673 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
6674 name
= h
->root
.root
.string
;
6675 if (strcmp (name
, "_DYNAMIC") == 0
6676 || strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
6677 sym
->st_shndx
= SHN_ABS
;
6678 else if (strcmp (name
, "_DYNAMIC_LINK") == 0
6679 || strcmp (name
, "_DYNAMIC_LINKING") == 0)
6681 sym
->st_shndx
= SHN_ABS
;
6682 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6685 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (output_bfd
))
6687 sym
->st_shndx
= SHN_ABS
;
6688 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6689 sym
->st_value
= elf_gp (output_bfd
);
6691 else if (SGI_COMPAT (output_bfd
))
6693 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
6694 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
6696 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6697 sym
->st_other
= STO_PROTECTED
;
6699 sym
->st_shndx
= SHN_MIPS_DATA
;
6701 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
6703 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6704 sym
->st_other
= STO_PROTECTED
;
6705 sym
->st_value
= mips_elf_hash_table (info
)->procedure_count
;
6706 sym
->st_shndx
= SHN_ABS
;
6708 else if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
!= SHN_ABS
)
6710 if (h
->type
== STT_FUNC
)
6711 sym
->st_shndx
= SHN_MIPS_TEXT
;
6712 else if (h
->type
== STT_OBJECT
)
6713 sym
->st_shndx
= SHN_MIPS_DATA
;
6717 /* Handle the IRIX6-specific symbols. */
6718 if (IRIX_COMPAT (output_bfd
) == ict_irix6
)
6719 mips_elf_irix6_finish_dynamic_symbol (output_bfd
, name
, sym
);
6723 if (! mips_elf_hash_table (info
)->use_rld_obj_head
6724 && (strcmp (name
, "__rld_map") == 0
6725 || strcmp (name
, "__RLD_MAP") == 0))
6727 asection
*s
= bfd_get_section_by_name (dynobj
, ".rld_map");
6728 BFD_ASSERT (s
!= NULL
);
6729 sym
->st_value
= s
->output_section
->vma
+ s
->output_offset
;
6730 bfd_put_32 (output_bfd
, 0, s
->contents
);
6731 if (mips_elf_hash_table (info
)->rld_value
== 0)
6732 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
6734 else if (mips_elf_hash_table (info
)->use_rld_obj_head
6735 && strcmp (name
, "__rld_obj_head") == 0)
6737 /* IRIX6 does not use a .rld_map section. */
6738 if (IRIX_COMPAT (output_bfd
) == ict_irix5
6739 || IRIX_COMPAT (output_bfd
) == ict_none
)
6740 BFD_ASSERT (bfd_get_section_by_name (dynobj
, ".rld_map")
6742 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
6746 /* If this is a mips16 symbol, force the value to be even. */
6747 if (sym
->st_other
== STO_MIPS16
)
6748 sym
->st_value
&= ~1;
6753 /* Finish up the dynamic sections. */
6756 _bfd_mips_elf_finish_dynamic_sections (bfd
*output_bfd
,
6757 struct bfd_link_info
*info
)
6762 struct mips_got_info
*gg
, *g
;
6764 dynobj
= elf_hash_table (info
)->dynobj
;
6766 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
6768 sgot
= mips_elf_got_section (dynobj
, FALSE
);
6773 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
6774 gg
= mips_elf_section_data (sgot
)->u
.got_info
;
6775 BFD_ASSERT (gg
!= NULL
);
6776 g
= mips_elf_got_for_ibfd (gg
, output_bfd
);
6777 BFD_ASSERT (g
!= NULL
);
6780 if (elf_hash_table (info
)->dynamic_sections_created
)
6784 BFD_ASSERT (sdyn
!= NULL
);
6785 BFD_ASSERT (g
!= NULL
);
6787 for (b
= sdyn
->contents
;
6788 b
< sdyn
->contents
+ sdyn
->_raw_size
;
6789 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
6791 Elf_Internal_Dyn dyn
;
6795 bfd_boolean swap_out_p
;
6797 /* Read in the current dynamic entry. */
6798 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
6800 /* Assume that we're going to modify it and write it out. */
6806 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
6807 BFD_ASSERT (s
!= NULL
);
6808 dyn
.d_un
.d_val
= MIPS_ELF_REL_SIZE (dynobj
);
6812 /* Rewrite DT_STRSZ. */
6814 _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
6819 s
= bfd_get_section_by_name (output_bfd
, name
);
6820 BFD_ASSERT (s
!= NULL
);
6821 dyn
.d_un
.d_ptr
= s
->vma
;
6824 case DT_MIPS_RLD_VERSION
:
6825 dyn
.d_un
.d_val
= 1; /* XXX */
6829 dyn
.d_un
.d_val
= RHF_NOTPOT
; /* XXX */
6832 case DT_MIPS_TIME_STAMP
:
6833 time ((time_t *) &dyn
.d_un
.d_val
);
6836 case DT_MIPS_ICHECKSUM
:
6841 case DT_MIPS_IVERSION
:
6846 case DT_MIPS_BASE_ADDRESS
:
6847 s
= output_bfd
->sections
;
6848 BFD_ASSERT (s
!= NULL
);
6849 dyn
.d_un
.d_ptr
= s
->vma
& ~(bfd_vma
) 0xffff;
6852 case DT_MIPS_LOCAL_GOTNO
:
6853 dyn
.d_un
.d_val
= g
->local_gotno
;
6856 case DT_MIPS_UNREFEXTNO
:
6857 /* The index into the dynamic symbol table which is the
6858 entry of the first external symbol that is not
6859 referenced within the same object. */
6860 dyn
.d_un
.d_val
= bfd_count_sections (output_bfd
) + 1;
6863 case DT_MIPS_GOTSYM
:
6864 if (gg
->global_gotsym
)
6866 dyn
.d_un
.d_val
= gg
->global_gotsym
->dynindx
;
6869 /* In case if we don't have global got symbols we default
6870 to setting DT_MIPS_GOTSYM to the same value as
6871 DT_MIPS_SYMTABNO, so we just fall through. */
6873 case DT_MIPS_SYMTABNO
:
6875 elemsize
= MIPS_ELF_SYM_SIZE (output_bfd
);
6876 s
= bfd_get_section_by_name (output_bfd
, name
);
6877 BFD_ASSERT (s
!= NULL
);
6879 if (s
->_cooked_size
!= 0)
6880 dyn
.d_un
.d_val
= s
->_cooked_size
/ elemsize
;
6882 dyn
.d_un
.d_val
= s
->_raw_size
/ elemsize
;
6885 case DT_MIPS_HIPAGENO
:
6886 dyn
.d_un
.d_val
= g
->local_gotno
- MIPS_RESERVED_GOTNO
;
6889 case DT_MIPS_RLD_MAP
:
6890 dyn
.d_un
.d_ptr
= mips_elf_hash_table (info
)->rld_value
;
6893 case DT_MIPS_OPTIONS
:
6894 s
= (bfd_get_section_by_name
6895 (output_bfd
, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd
)));
6896 dyn
.d_un
.d_ptr
= s
->vma
;
6900 /* Reduce DT_RELSZ to account for any relocations we
6901 decided not to make. This is for the n64 irix rld,
6902 which doesn't seem to apply any relocations if there
6903 are trailing null entries. */
6904 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
6905 dyn
.d_un
.d_val
= (s
->reloc_count
6906 * (ABI_64_P (output_bfd
)
6907 ? sizeof (Elf64_Mips_External_Rel
)
6908 : sizeof (Elf32_External_Rel
)));
6917 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
6922 /* The first entry of the global offset table will be filled at
6923 runtime. The second entry will be used by some runtime loaders.
6924 This isn't the case of IRIX rld. */
6925 if (sgot
!= NULL
&& sgot
->_raw_size
> 0)
6927 MIPS_ELF_PUT_WORD (output_bfd
, 0, sgot
->contents
);
6928 MIPS_ELF_PUT_WORD (output_bfd
, 0x80000000,
6929 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
6933 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
6934 = MIPS_ELF_GOT_SIZE (output_bfd
);
6936 /* Generate dynamic relocations for the non-primary gots. */
6937 if (gg
!= NULL
&& gg
->next
)
6939 Elf_Internal_Rela rel
[3];
6942 memset (rel
, 0, sizeof (rel
));
6943 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_REL32
);
6945 for (g
= gg
->next
; g
->next
!= gg
; g
= g
->next
)
6947 bfd_vma index
= g
->next
->local_gotno
+ g
->next
->global_gotno
;
6949 MIPS_ELF_PUT_WORD (output_bfd
, 0, sgot
->contents
6950 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
6951 MIPS_ELF_PUT_WORD (output_bfd
, 0x80000000, sgot
->contents
6952 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
6957 while (index
< g
->assigned_gotno
)
6959 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
6960 = index
++ * MIPS_ELF_GOT_SIZE (output_bfd
);
6961 if (!(mips_elf_create_dynamic_relocation
6962 (output_bfd
, info
, rel
, NULL
,
6963 bfd_abs_section_ptr
,
6966 BFD_ASSERT (addend
== 0);
6973 Elf32_compact_rel cpt
;
6975 if (SGI_COMPAT (output_bfd
))
6977 /* Write .compact_rel section out. */
6978 s
= bfd_get_section_by_name (dynobj
, ".compact_rel");
6982 cpt
.num
= s
->reloc_count
;
6984 cpt
.offset
= (s
->output_section
->filepos
6985 + sizeof (Elf32_External_compact_rel
));
6988 bfd_elf32_swap_compact_rel_out (output_bfd
, &cpt
,
6989 ((Elf32_External_compact_rel
*)
6992 /* Clean up a dummy stub function entry in .text. */
6993 s
= bfd_get_section_by_name (dynobj
,
6994 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
6997 file_ptr dummy_offset
;
6999 BFD_ASSERT (s
->_raw_size
>= MIPS_FUNCTION_STUB_SIZE
);
7000 dummy_offset
= s
->_raw_size
- MIPS_FUNCTION_STUB_SIZE
;
7001 memset (s
->contents
+ dummy_offset
, 0,
7002 MIPS_FUNCTION_STUB_SIZE
);
7007 /* We need to sort the entries of the dynamic relocation section. */
7009 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
7012 && s
->_raw_size
> (bfd_vma
)2 * MIPS_ELF_REL_SIZE (output_bfd
))
7014 reldyn_sorting_bfd
= output_bfd
;
7016 if (ABI_64_P (output_bfd
))
7017 qsort ((Elf64_External_Rel
*) s
->contents
+ 1, s
->reloc_count
- 1,
7018 sizeof (Elf64_Mips_External_Rel
), sort_dynamic_relocs_64
);
7020 qsort ((Elf32_External_Rel
*) s
->contents
+ 1, s
->reloc_count
- 1,
7021 sizeof (Elf32_External_Rel
), sort_dynamic_relocs
);
7029 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
7032 mips_set_isa_flags (bfd
*abfd
)
7036 switch (bfd_get_mach (abfd
))
7039 case bfd_mach_mips3000
:
7040 val
= E_MIPS_ARCH_1
;
7043 case bfd_mach_mips3900
:
7044 val
= E_MIPS_ARCH_1
| E_MIPS_MACH_3900
;
7047 case bfd_mach_mips6000
:
7048 val
= E_MIPS_ARCH_2
;
7051 case bfd_mach_mips4000
:
7052 case bfd_mach_mips4300
:
7053 case bfd_mach_mips4400
:
7054 case bfd_mach_mips4600
:
7055 val
= E_MIPS_ARCH_3
;
7058 case bfd_mach_mips4010
:
7059 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4010
;
7062 case bfd_mach_mips4100
:
7063 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4100
;
7066 case bfd_mach_mips4111
:
7067 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4111
;
7070 case bfd_mach_mips4120
:
7071 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4120
;
7074 case bfd_mach_mips4650
:
7075 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4650
;
7078 case bfd_mach_mips5400
:
7079 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5400
;
7082 case bfd_mach_mips5500
:
7083 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5500
;
7086 case bfd_mach_mips5000
:
7087 case bfd_mach_mips7000
:
7088 case bfd_mach_mips8000
:
7089 case bfd_mach_mips10000
:
7090 case bfd_mach_mips12000
:
7091 val
= E_MIPS_ARCH_4
;
7094 case bfd_mach_mips5
:
7095 val
= E_MIPS_ARCH_5
;
7098 case bfd_mach_mips_sb1
:
7099 val
= E_MIPS_ARCH_64
| E_MIPS_MACH_SB1
;
7102 case bfd_mach_mipsisa32
:
7103 val
= E_MIPS_ARCH_32
;
7106 case bfd_mach_mipsisa64
:
7107 val
= E_MIPS_ARCH_64
;
7110 case bfd_mach_mipsisa32r2
:
7111 val
= E_MIPS_ARCH_32R2
;
7114 case bfd_mach_mipsisa64r2
:
7115 val
= E_MIPS_ARCH_64R2
;
7118 elf_elfheader (abfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
7119 elf_elfheader (abfd
)->e_flags
|= val
;
7124 /* The final processing done just before writing out a MIPS ELF object
7125 file. This gets the MIPS architecture right based on the machine
7126 number. This is used by both the 32-bit and the 64-bit ABI. */
7129 _bfd_mips_elf_final_write_processing (bfd
*abfd
,
7130 bfd_boolean linker ATTRIBUTE_UNUSED
)
7133 Elf_Internal_Shdr
**hdrpp
;
7137 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
7138 is nonzero. This is for compatibility with old objects, which used
7139 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
7140 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_MACH
) == 0)
7141 mips_set_isa_flags (abfd
);
7143 /* Set the sh_info field for .gptab sections and other appropriate
7144 info for each special section. */
7145 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
7146 i
< elf_numsections (abfd
);
7149 switch ((*hdrpp
)->sh_type
)
7152 case SHT_MIPS_LIBLIST
:
7153 sec
= bfd_get_section_by_name (abfd
, ".dynstr");
7155 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7158 case SHT_MIPS_GPTAB
:
7159 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7160 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7161 BFD_ASSERT (name
!= NULL
7162 && strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0);
7163 sec
= bfd_get_section_by_name (abfd
, name
+ sizeof ".gptab" - 1);
7164 BFD_ASSERT (sec
!= NULL
);
7165 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
7168 case SHT_MIPS_CONTENT
:
7169 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7170 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7171 BFD_ASSERT (name
!= NULL
7172 && strncmp (name
, ".MIPS.content",
7173 sizeof ".MIPS.content" - 1) == 0);
7174 sec
= bfd_get_section_by_name (abfd
,
7175 name
+ sizeof ".MIPS.content" - 1);
7176 BFD_ASSERT (sec
!= NULL
);
7177 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7180 case SHT_MIPS_SYMBOL_LIB
:
7181 sec
= bfd_get_section_by_name (abfd
, ".dynsym");
7183 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7184 sec
= bfd_get_section_by_name (abfd
, ".liblist");
7186 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
7189 case SHT_MIPS_EVENTS
:
7190 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7191 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7192 BFD_ASSERT (name
!= NULL
);
7193 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0)
7194 sec
= bfd_get_section_by_name (abfd
,
7195 name
+ sizeof ".MIPS.events" - 1);
7198 BFD_ASSERT (strncmp (name
, ".MIPS.post_rel",
7199 sizeof ".MIPS.post_rel" - 1) == 0);
7200 sec
= bfd_get_section_by_name (abfd
,
7202 + sizeof ".MIPS.post_rel" - 1));
7204 BFD_ASSERT (sec
!= NULL
);
7205 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7212 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
7216 _bfd_mips_elf_additional_program_headers (bfd
*abfd
)
7221 /* See if we need a PT_MIPS_REGINFO segment. */
7222 s
= bfd_get_section_by_name (abfd
, ".reginfo");
7223 if (s
&& (s
->flags
& SEC_LOAD
))
7226 /* See if we need a PT_MIPS_OPTIONS segment. */
7227 if (IRIX_COMPAT (abfd
) == ict_irix6
7228 && bfd_get_section_by_name (abfd
,
7229 MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)))
7232 /* See if we need a PT_MIPS_RTPROC segment. */
7233 if (IRIX_COMPAT (abfd
) == ict_irix5
7234 && bfd_get_section_by_name (abfd
, ".dynamic")
7235 && bfd_get_section_by_name (abfd
, ".mdebug"))
7241 /* Modify the segment map for an IRIX5 executable. */
7244 _bfd_mips_elf_modify_segment_map (bfd
*abfd
,
7245 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
7248 struct elf_segment_map
*m
, **pm
;
7251 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
7253 s
= bfd_get_section_by_name (abfd
, ".reginfo");
7254 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
7256 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
7257 if (m
->p_type
== PT_MIPS_REGINFO
)
7262 m
= bfd_zalloc (abfd
, amt
);
7266 m
->p_type
= PT_MIPS_REGINFO
;
7270 /* We want to put it after the PHDR and INTERP segments. */
7271 pm
= &elf_tdata (abfd
)->segment_map
;
7273 && ((*pm
)->p_type
== PT_PHDR
7274 || (*pm
)->p_type
== PT_INTERP
))
7282 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
7283 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
7284 PT_MIPS_OPTIONS segment immediately following the program header
7287 /* On non-IRIX6 new abi, we'll have already created a segment
7288 for this section, so don't create another. I'm not sure this
7289 is not also the case for IRIX 6, but I can't test it right
7291 && IRIX_COMPAT (abfd
) == ict_irix6
)
7293 for (s
= abfd
->sections
; s
; s
= s
->next
)
7294 if (elf_section_data (s
)->this_hdr
.sh_type
== SHT_MIPS_OPTIONS
)
7299 struct elf_segment_map
*options_segment
;
7301 pm
= &elf_tdata (abfd
)->segment_map
;
7303 && ((*pm
)->p_type
== PT_PHDR
7304 || (*pm
)->p_type
== PT_INTERP
))
7307 amt
= sizeof (struct elf_segment_map
);
7308 options_segment
= bfd_zalloc (abfd
, amt
);
7309 options_segment
->next
= *pm
;
7310 options_segment
->p_type
= PT_MIPS_OPTIONS
;
7311 options_segment
->p_flags
= PF_R
;
7312 options_segment
->p_flags_valid
= TRUE
;
7313 options_segment
->count
= 1;
7314 options_segment
->sections
[0] = s
;
7315 *pm
= options_segment
;
7320 if (IRIX_COMPAT (abfd
) == ict_irix5
)
7322 /* If there are .dynamic and .mdebug sections, we make a room
7323 for the RTPROC header. FIXME: Rewrite without section names. */
7324 if (bfd_get_section_by_name (abfd
, ".interp") == NULL
7325 && bfd_get_section_by_name (abfd
, ".dynamic") != NULL
7326 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
7328 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
7329 if (m
->p_type
== PT_MIPS_RTPROC
)
7334 m
= bfd_zalloc (abfd
, amt
);
7338 m
->p_type
= PT_MIPS_RTPROC
;
7340 s
= bfd_get_section_by_name (abfd
, ".rtproc");
7345 m
->p_flags_valid
= 1;
7353 /* We want to put it after the DYNAMIC segment. */
7354 pm
= &elf_tdata (abfd
)->segment_map
;
7355 while (*pm
!= NULL
&& (*pm
)->p_type
!= PT_DYNAMIC
)
7365 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
7366 .dynstr, .dynsym, and .hash sections, and everything in
7368 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
;
7370 if ((*pm
)->p_type
== PT_DYNAMIC
)
7373 if (m
!= NULL
&& IRIX_COMPAT (abfd
) == ict_none
)
7375 /* For a normal mips executable the permissions for the PT_DYNAMIC
7376 segment are read, write and execute. We do that here since
7377 the code in elf.c sets only the read permission. This matters
7378 sometimes for the dynamic linker. */
7379 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
7381 m
->p_flags
= PF_R
| PF_W
| PF_X
;
7382 m
->p_flags_valid
= 1;
7386 && m
->count
== 1 && strcmp (m
->sections
[0]->name
, ".dynamic") == 0)
7388 static const char *sec_names
[] =
7390 ".dynamic", ".dynstr", ".dynsym", ".hash"
7394 struct elf_segment_map
*n
;
7398 for (i
= 0; i
< sizeof sec_names
/ sizeof sec_names
[0]; i
++)
7400 s
= bfd_get_section_by_name (abfd
, sec_names
[i
]);
7401 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
7407 sz
= s
->_cooked_size
;
7410 if (high
< s
->vma
+ sz
)
7416 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
7417 if ((s
->flags
& SEC_LOAD
) != 0
7420 + (s
->_cooked_size
!=
7421 0 ? s
->_cooked_size
: s
->_raw_size
)) <= high
))
7424 amt
= sizeof *n
+ (bfd_size_type
) (c
- 1) * sizeof (asection
*);
7425 n
= bfd_zalloc (abfd
, amt
);
7432 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
7434 if ((s
->flags
& SEC_LOAD
) != 0
7437 + (s
->_cooked_size
!= 0 ?
7438 s
->_cooked_size
: s
->_raw_size
)) <= high
))
7452 /* Return the section that should be marked against GC for a given
7456 _bfd_mips_elf_gc_mark_hook (asection
*sec
,
7457 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
7458 Elf_Internal_Rela
*rel
,
7459 struct elf_link_hash_entry
*h
,
7460 Elf_Internal_Sym
*sym
)
7462 /* ??? Do mips16 stub sections need to be handled special? */
7466 switch (ELF_R_TYPE (sec
->owner
, rel
->r_info
))
7468 case R_MIPS_GNU_VTINHERIT
:
7469 case R_MIPS_GNU_VTENTRY
:
7473 switch (h
->root
.type
)
7475 case bfd_link_hash_defined
:
7476 case bfd_link_hash_defweak
:
7477 return h
->root
.u
.def
.section
;
7479 case bfd_link_hash_common
:
7480 return h
->root
.u
.c
.p
->section
;
7488 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
7493 /* Update the got entry reference counts for the section being removed. */
7496 _bfd_mips_elf_gc_sweep_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
7497 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
7498 asection
*sec ATTRIBUTE_UNUSED
,
7499 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
)
7502 Elf_Internal_Shdr
*symtab_hdr
;
7503 struct elf_link_hash_entry
**sym_hashes
;
7504 bfd_signed_vma
*local_got_refcounts
;
7505 const Elf_Internal_Rela
*rel
, *relend
;
7506 unsigned long r_symndx
;
7507 struct elf_link_hash_entry
*h
;
7509 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7510 sym_hashes
= elf_sym_hashes (abfd
);
7511 local_got_refcounts
= elf_local_got_refcounts (abfd
);
7513 relend
= relocs
+ sec
->reloc_count
;
7514 for (rel
= relocs
; rel
< relend
; rel
++)
7515 switch (ELF_R_TYPE (abfd
, rel
->r_info
))
7519 case R_MIPS_CALL_HI16
:
7520 case R_MIPS_CALL_LO16
:
7521 case R_MIPS_GOT_HI16
:
7522 case R_MIPS_GOT_LO16
:
7523 case R_MIPS_GOT_DISP
:
7524 case R_MIPS_GOT_PAGE
:
7525 case R_MIPS_GOT_OFST
:
7526 /* ??? It would seem that the existing MIPS code does no sort
7527 of reference counting or whatnot on its GOT and PLT entries,
7528 so it is not possible to garbage collect them at this time. */
7539 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
7540 hiding the old indirect symbol. Process additional relocation
7541 information. Also called for weakdefs, in which case we just let
7542 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
7545 _bfd_mips_elf_copy_indirect_symbol (const struct elf_backend_data
*bed
,
7546 struct elf_link_hash_entry
*dir
,
7547 struct elf_link_hash_entry
*ind
)
7549 struct mips_elf_link_hash_entry
*dirmips
, *indmips
;
7551 _bfd_elf_link_hash_copy_indirect (bed
, dir
, ind
);
7553 if (ind
->root
.type
!= bfd_link_hash_indirect
)
7556 dirmips
= (struct mips_elf_link_hash_entry
*) dir
;
7557 indmips
= (struct mips_elf_link_hash_entry
*) ind
;
7558 dirmips
->possibly_dynamic_relocs
+= indmips
->possibly_dynamic_relocs
;
7559 if (indmips
->readonly_reloc
)
7560 dirmips
->readonly_reloc
= TRUE
;
7561 if (indmips
->no_fn_stub
)
7562 dirmips
->no_fn_stub
= TRUE
;
7566 _bfd_mips_elf_hide_symbol (struct bfd_link_info
*info
,
7567 struct elf_link_hash_entry
*entry
,
7568 bfd_boolean force_local
)
7572 struct mips_got_info
*g
;
7573 struct mips_elf_link_hash_entry
*h
;
7575 h
= (struct mips_elf_link_hash_entry
*) entry
;
7576 if (h
->forced_local
)
7578 h
->forced_local
= force_local
;
7580 dynobj
= elf_hash_table (info
)->dynobj
;
7581 if (dynobj
!= NULL
&& force_local
)
7583 got
= mips_elf_got_section (dynobj
, FALSE
);
7584 g
= mips_elf_section_data (got
)->u
.got_info
;
7588 struct mips_got_entry e
;
7589 struct mips_got_info
*gg
= g
;
7591 /* Since we're turning what used to be a global symbol into a
7592 local one, bump up the number of local entries of each GOT
7593 that had an entry for it. This will automatically decrease
7594 the number of global entries, since global_gotno is actually
7595 the upper limit of global entries. */
7600 for (g
= g
->next
; g
!= gg
; g
= g
->next
)
7601 if (htab_find (g
->got_entries
, &e
))
7603 BFD_ASSERT (g
->global_gotno
> 0);
7608 /* If this was a global symbol forced into the primary GOT, we
7609 no longer need an entry for it. We can't release the entry
7610 at this point, but we must at least stop counting it as one
7611 of the symbols that required a forced got entry. */
7612 if (h
->root
.got
.offset
== 2)
7614 BFD_ASSERT (gg
->assigned_gotno
> 0);
7615 gg
->assigned_gotno
--;
7618 else if (g
->global_gotno
== 0 && g
->global_gotsym
== NULL
)
7619 /* If we haven't got through GOT allocation yet, just bump up the
7620 number of local entries, as this symbol won't be counted as
7623 else if (h
->root
.got
.offset
== 1)
7625 /* If we're past non-multi-GOT allocation and this symbol had
7626 been marked for a global got entry, give it a local entry
7628 BFD_ASSERT (g
->global_gotno
> 0);
7634 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
7640 _bfd_mips_elf_discard_info (bfd
*abfd
, struct elf_reloc_cookie
*cookie
,
7641 struct bfd_link_info
*info
)
7644 bfd_boolean ret
= FALSE
;
7645 unsigned char *tdata
;
7648 o
= bfd_get_section_by_name (abfd
, ".pdr");
7651 if (o
->_raw_size
== 0)
7653 if (o
->_raw_size
% PDR_SIZE
!= 0)
7655 if (o
->output_section
!= NULL
7656 && bfd_is_abs_section (o
->output_section
))
7659 tdata
= bfd_zmalloc (o
->_raw_size
/ PDR_SIZE
);
7663 cookie
->rels
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
7671 cookie
->rel
= cookie
->rels
;
7672 cookie
->relend
= cookie
->rels
+ o
->reloc_count
;
7674 for (i
= 0, skip
= 0; i
< o
->_raw_size
/ PDR_SIZE
; i
++)
7676 if (bfd_elf_reloc_symbol_deleted_p (i
* PDR_SIZE
, cookie
))
7685 mips_elf_section_data (o
)->u
.tdata
= tdata
;
7686 o
->_cooked_size
= o
->_raw_size
- skip
* PDR_SIZE
;
7692 if (! info
->keep_memory
)
7693 free (cookie
->rels
);
7699 _bfd_mips_elf_ignore_discarded_relocs (asection
*sec
)
7701 if (strcmp (sec
->name
, ".pdr") == 0)
7707 _bfd_mips_elf_write_section (bfd
*output_bfd
, asection
*sec
,
7710 bfd_byte
*to
, *from
, *end
;
7713 if (strcmp (sec
->name
, ".pdr") != 0)
7716 if (mips_elf_section_data (sec
)->u
.tdata
== NULL
)
7720 end
= contents
+ sec
->_raw_size
;
7721 for (from
= contents
, i
= 0;
7723 from
+= PDR_SIZE
, i
++)
7725 if ((mips_elf_section_data (sec
)->u
.tdata
)[i
] == 1)
7728 memcpy (to
, from
, PDR_SIZE
);
7731 bfd_set_section_contents (output_bfd
, sec
->output_section
, contents
,
7732 sec
->output_offset
, sec
->_cooked_size
);
7736 /* MIPS ELF uses a special find_nearest_line routine in order the
7737 handle the ECOFF debugging information. */
7739 struct mips_elf_find_line
7741 struct ecoff_debug_info d
;
7742 struct ecoff_find_line i
;
7746 _bfd_mips_elf_find_nearest_line (bfd
*abfd
, asection
*section
,
7747 asymbol
**symbols
, bfd_vma offset
,
7748 const char **filename_ptr
,
7749 const char **functionname_ptr
,
7750 unsigned int *line_ptr
)
7754 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
7755 filename_ptr
, functionname_ptr
,
7759 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
7760 filename_ptr
, functionname_ptr
,
7761 line_ptr
, ABI_64_P (abfd
) ? 8 : 0,
7762 &elf_tdata (abfd
)->dwarf2_find_line_info
))
7765 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
7769 struct mips_elf_find_line
*fi
;
7770 const struct ecoff_debug_swap
* const swap
=
7771 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
7773 /* If we are called during a link, mips_elf_final_link may have
7774 cleared the SEC_HAS_CONTENTS field. We force it back on here
7775 if appropriate (which it normally will be). */
7776 origflags
= msec
->flags
;
7777 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
7778 msec
->flags
|= SEC_HAS_CONTENTS
;
7780 fi
= elf_tdata (abfd
)->find_line_info
;
7783 bfd_size_type external_fdr_size
;
7786 struct fdr
*fdr_ptr
;
7787 bfd_size_type amt
= sizeof (struct mips_elf_find_line
);
7789 fi
= bfd_zalloc (abfd
, amt
);
7792 msec
->flags
= origflags
;
7796 if (! _bfd_mips_elf_read_ecoff_info (abfd
, msec
, &fi
->d
))
7798 msec
->flags
= origflags
;
7802 /* Swap in the FDR information. */
7803 amt
= fi
->d
.symbolic_header
.ifdMax
* sizeof (struct fdr
);
7804 fi
->d
.fdr
= bfd_alloc (abfd
, amt
);
7805 if (fi
->d
.fdr
== NULL
)
7807 msec
->flags
= origflags
;
7810 external_fdr_size
= swap
->external_fdr_size
;
7811 fdr_ptr
= fi
->d
.fdr
;
7812 fraw_src
= (char *) fi
->d
.external_fdr
;
7813 fraw_end
= (fraw_src
7814 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
7815 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
7816 (*swap
->swap_fdr_in
) (abfd
, fraw_src
, fdr_ptr
);
7818 elf_tdata (abfd
)->find_line_info
= fi
;
7820 /* Note that we don't bother to ever free this information.
7821 find_nearest_line is either called all the time, as in
7822 objdump -l, so the information should be saved, or it is
7823 rarely called, as in ld error messages, so the memory
7824 wasted is unimportant. Still, it would probably be a
7825 good idea for free_cached_info to throw it away. */
7828 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
7829 &fi
->i
, filename_ptr
, functionname_ptr
,
7832 msec
->flags
= origflags
;
7836 msec
->flags
= origflags
;
7839 /* Fall back on the generic ELF find_nearest_line routine. */
7841 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
7842 filename_ptr
, functionname_ptr
,
7846 /* When are writing out the .options or .MIPS.options section,
7847 remember the bytes we are writing out, so that we can install the
7848 GP value in the section_processing routine. */
7851 _bfd_mips_elf_set_section_contents (bfd
*abfd
, sec_ptr section
,
7852 const void *location
,
7853 file_ptr offset
, bfd_size_type count
)
7855 if (strcmp (section
->name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
7859 if (elf_section_data (section
) == NULL
)
7861 bfd_size_type amt
= sizeof (struct bfd_elf_section_data
);
7862 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
7863 if (elf_section_data (section
) == NULL
)
7866 c
= mips_elf_section_data (section
)->u
.tdata
;
7871 if (section
->_cooked_size
!= 0)
7872 size
= section
->_cooked_size
;
7874 size
= section
->_raw_size
;
7875 c
= bfd_zalloc (abfd
, size
);
7878 mips_elf_section_data (section
)->u
.tdata
= c
;
7881 memcpy (c
+ offset
, location
, count
);
7884 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
,
7888 /* This is almost identical to bfd_generic_get_... except that some
7889 MIPS relocations need to be handled specially. Sigh. */
7892 _bfd_elf_mips_get_relocated_section_contents
7894 struct bfd_link_info
*link_info
,
7895 struct bfd_link_order
*link_order
,
7897 bfd_boolean relocatable
,
7900 /* Get enough memory to hold the stuff */
7901 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
7902 asection
*input_section
= link_order
->u
.indirect
.section
;
7904 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
7905 arelent
**reloc_vector
= NULL
;
7911 reloc_vector
= bfd_malloc (reloc_size
);
7912 if (reloc_vector
== NULL
&& reloc_size
!= 0)
7915 /* read in the section */
7916 if (!bfd_get_section_contents (input_bfd
, input_section
, data
, 0,
7917 input_section
->_raw_size
))
7920 /* We're not relaxing the section, so just copy the size info */
7921 input_section
->_cooked_size
= input_section
->_raw_size
;
7922 input_section
->reloc_done
= TRUE
;
7924 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
7928 if (reloc_count
< 0)
7931 if (reloc_count
> 0)
7936 bfd_vma gp
= 0x12345678; /* initialize just to shut gcc up */
7939 struct bfd_hash_entry
*h
;
7940 struct bfd_link_hash_entry
*lh
;
7941 /* Skip all this stuff if we aren't mixing formats. */
7942 if (abfd
&& input_bfd
7943 && abfd
->xvec
== input_bfd
->xvec
)
7947 h
= bfd_hash_lookup (&link_info
->hash
->table
, "_gp", FALSE
, FALSE
);
7948 lh
= (struct bfd_link_hash_entry
*) h
;
7955 case bfd_link_hash_undefined
:
7956 case bfd_link_hash_undefweak
:
7957 case bfd_link_hash_common
:
7960 case bfd_link_hash_defined
:
7961 case bfd_link_hash_defweak
:
7963 gp
= lh
->u
.def
.value
;
7965 case bfd_link_hash_indirect
:
7966 case bfd_link_hash_warning
:
7968 /* @@FIXME ignoring warning for now */
7970 case bfd_link_hash_new
:
7979 for (parent
= reloc_vector
; *parent
!= NULL
; parent
++)
7981 char *error_message
= NULL
;
7982 bfd_reloc_status_type r
;
7984 /* Specific to MIPS: Deal with relocation types that require
7985 knowing the gp of the output bfd. */
7986 asymbol
*sym
= *(*parent
)->sym_ptr_ptr
;
7987 if (bfd_is_abs_section (sym
->section
) && abfd
)
7989 /* The special_function wouldn't get called anyway. */
7993 /* The gp isn't there; let the special function code
7994 fall over on its own. */
7996 else if ((*parent
)->howto
->special_function
7997 == _bfd_mips_elf32_gprel16_reloc
)
7999 /* bypass special_function call */
8000 r
= _bfd_mips_elf_gprel16_with_gp (input_bfd
, sym
, *parent
,
8001 input_section
, relocatable
,
8003 goto skip_bfd_perform_relocation
;
8005 /* end mips specific stuff */
8007 r
= bfd_perform_relocation (input_bfd
, *parent
, data
, input_section
,
8008 relocatable
? abfd
: NULL
,
8010 skip_bfd_perform_relocation
:
8014 asection
*os
= input_section
->output_section
;
8016 /* A partial link, so keep the relocs */
8017 os
->orelocation
[os
->reloc_count
] = *parent
;
8021 if (r
!= bfd_reloc_ok
)
8025 case bfd_reloc_undefined
:
8026 if (!((*link_info
->callbacks
->undefined_symbol
)
8027 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
8028 input_bfd
, input_section
, (*parent
)->address
,
8032 case bfd_reloc_dangerous
:
8033 BFD_ASSERT (error_message
!= NULL
);
8034 if (!((*link_info
->callbacks
->reloc_dangerous
)
8035 (link_info
, error_message
, input_bfd
, input_section
,
8036 (*parent
)->address
)))
8039 case bfd_reloc_overflow
:
8040 if (!((*link_info
->callbacks
->reloc_overflow
)
8041 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
8042 (*parent
)->howto
->name
, (*parent
)->addend
,
8043 input_bfd
, input_section
, (*parent
)->address
)))
8046 case bfd_reloc_outofrange
:
8055 if (reloc_vector
!= NULL
)
8056 free (reloc_vector
);
8060 if (reloc_vector
!= NULL
)
8061 free (reloc_vector
);
8065 /* Create a MIPS ELF linker hash table. */
8067 struct bfd_link_hash_table
*
8068 _bfd_mips_elf_link_hash_table_create (bfd
*abfd
)
8070 struct mips_elf_link_hash_table
*ret
;
8071 bfd_size_type amt
= sizeof (struct mips_elf_link_hash_table
);
8073 ret
= bfd_malloc (amt
);
8077 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
8078 mips_elf_link_hash_newfunc
))
8085 /* We no longer use this. */
8086 for (i
= 0; i
< SIZEOF_MIPS_DYNSYM_SECNAMES
; i
++)
8087 ret
->dynsym_sec_strindex
[i
] = (bfd_size_type
) -1;
8089 ret
->procedure_count
= 0;
8090 ret
->compact_rel_size
= 0;
8091 ret
->use_rld_obj_head
= FALSE
;
8093 ret
->mips16_stubs_seen
= FALSE
;
8095 return &ret
->root
.root
;
8098 /* We need to use a special link routine to handle the .reginfo and
8099 the .mdebug sections. We need to merge all instances of these
8100 sections together, not write them all out sequentially. */
8103 _bfd_mips_elf_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
8107 struct bfd_link_order
*p
;
8108 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
8109 asection
*rtproc_sec
;
8110 Elf32_RegInfo reginfo
;
8111 struct ecoff_debug_info debug
;
8112 const struct ecoff_debug_swap
*swap
8113 = get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
8114 HDRR
*symhdr
= &debug
.symbolic_header
;
8115 void *mdebug_handle
= NULL
;
8121 static const char * const secname
[] =
8123 ".text", ".init", ".fini", ".data",
8124 ".rodata", ".sdata", ".sbss", ".bss"
8126 static const int sc
[] =
8128 scText
, scInit
, scFini
, scData
,
8129 scRData
, scSData
, scSBss
, scBss
8132 /* We'd carefully arranged the dynamic symbol indices, and then the
8133 generic size_dynamic_sections renumbered them out from under us.
8134 Rather than trying somehow to prevent the renumbering, just do
8136 if (elf_hash_table (info
)->dynamic_sections_created
)
8140 struct mips_got_info
*g
;
8142 /* When we resort, we must tell mips_elf_sort_hash_table what
8143 the lowest index it may use is. That's the number of section
8144 symbols we're going to add. The generic ELF linker only
8145 adds these symbols when building a shared object. Note that
8146 we count the sections after (possibly) removing the .options
8148 if (! mips_elf_sort_hash_table (info
, (info
->shared
8149 ? bfd_count_sections (abfd
) + 1
8153 /* Make sure we didn't grow the global .got region. */
8154 dynobj
= elf_hash_table (info
)->dynobj
;
8155 got
= mips_elf_got_section (dynobj
, FALSE
);
8156 g
= mips_elf_section_data (got
)->u
.got_info
;
8158 if (g
->global_gotsym
!= NULL
)
8159 BFD_ASSERT ((elf_hash_table (info
)->dynsymcount
8160 - g
->global_gotsym
->dynindx
)
8161 <= g
->global_gotno
);
8165 /* We want to set the GP value for ld -r. */
8166 /* On IRIX5, we omit the .options section. On IRIX6, however, we
8167 include it, even though we don't process it quite right. (Some
8168 entries are supposed to be merged.) Empirically, we seem to be
8169 better off including it then not. */
8170 if (IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
8171 for (secpp
= &abfd
->sections
; *secpp
!= NULL
; secpp
= &(*secpp
)->next
)
8173 if (strcmp ((*secpp
)->name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
8175 for (p
= (*secpp
)->link_order_head
; p
!= NULL
; p
= p
->next
)
8176 if (p
->type
== bfd_indirect_link_order
)
8177 p
->u
.indirect
.section
->flags
&= ~SEC_HAS_CONTENTS
;
8178 (*secpp
)->link_order_head
= NULL
;
8179 bfd_section_list_remove (abfd
, secpp
);
8180 --abfd
->section_count
;
8186 /* We include .MIPS.options, even though we don't process it quite right.
8187 (Some entries are supposed to be merged.) At IRIX6 empirically we seem
8188 to be better off including it than not. */
8189 for (secpp
= &abfd
->sections
; *secpp
!= NULL
; secpp
= &(*secpp
)->next
)
8191 if (strcmp ((*secpp
)->name
, ".MIPS.options") == 0)
8193 for (p
= (*secpp
)->link_order_head
; p
!= NULL
; p
= p
->next
)
8194 if (p
->type
== bfd_indirect_link_order
)
8195 p
->u
.indirect
.section
->flags
&=~ SEC_HAS_CONTENTS
;
8196 (*secpp
)->link_order_head
= NULL
;
8197 bfd_section_list_remove (abfd
, secpp
);
8198 --abfd
->section_count
;
8205 /* Get a value for the GP register. */
8206 if (elf_gp (abfd
) == 0)
8208 struct bfd_link_hash_entry
*h
;
8210 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
8211 if (h
!= NULL
&& h
->type
== bfd_link_hash_defined
)
8212 elf_gp (abfd
) = (h
->u
.def
.value
8213 + h
->u
.def
.section
->output_section
->vma
8214 + h
->u
.def
.section
->output_offset
);
8215 else if (info
->relocatable
)
8217 bfd_vma lo
= MINUS_ONE
;
8219 /* Find the GP-relative section with the lowest offset. */
8220 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
8222 && (elf_section_data (o
)->this_hdr
.sh_flags
& SHF_MIPS_GPREL
))
8225 /* And calculate GP relative to that. */
8226 elf_gp (abfd
) = lo
+ ELF_MIPS_GP_OFFSET (abfd
);
8230 /* If the relocate_section function needs to do a reloc
8231 involving the GP value, it should make a reloc_dangerous
8232 callback to warn that GP is not defined. */
8236 /* Go through the sections and collect the .reginfo and .mdebug
8240 gptab_data_sec
= NULL
;
8241 gptab_bss_sec
= NULL
;
8242 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
8244 if (strcmp (o
->name
, ".reginfo") == 0)
8246 memset (®info
, 0, sizeof reginfo
);
8248 /* We have found the .reginfo section in the output file.
8249 Look through all the link_orders comprising it and merge
8250 the information together. */
8251 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8253 asection
*input_section
;
8255 Elf32_External_RegInfo ext
;
8258 if (p
->type
!= bfd_indirect_link_order
)
8260 if (p
->type
== bfd_data_link_order
)
8265 input_section
= p
->u
.indirect
.section
;
8266 input_bfd
= input_section
->owner
;
8268 /* The linker emulation code has probably clobbered the
8269 size to be zero bytes. */
8270 if (input_section
->_raw_size
== 0)
8271 input_section
->_raw_size
= sizeof (Elf32_External_RegInfo
);
8273 if (! bfd_get_section_contents (input_bfd
, input_section
,
8274 &ext
, 0, sizeof ext
))
8277 bfd_mips_elf32_swap_reginfo_in (input_bfd
, &ext
, &sub
);
8279 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
8280 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
8281 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
8282 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
8283 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
8285 /* ri_gp_value is set by the function
8286 mips_elf32_section_processing when the section is
8287 finally written out. */
8289 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8290 elf_link_input_bfd ignores this section. */
8291 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8294 /* Size has been set in _bfd_mips_elf_always_size_sections. */
8295 BFD_ASSERT(o
->_raw_size
== sizeof (Elf32_External_RegInfo
));
8297 /* Skip this section later on (I don't think this currently
8298 matters, but someday it might). */
8299 o
->link_order_head
= NULL
;
8304 if (strcmp (o
->name
, ".mdebug") == 0)
8306 struct extsym_info einfo
;
8309 /* We have found the .mdebug section in the output file.
8310 Look through all the link_orders comprising it and merge
8311 the information together. */
8312 symhdr
->magic
= swap
->sym_magic
;
8313 /* FIXME: What should the version stamp be? */
8315 symhdr
->ilineMax
= 0;
8319 symhdr
->isymMax
= 0;
8320 symhdr
->ioptMax
= 0;
8321 symhdr
->iauxMax
= 0;
8323 symhdr
->issExtMax
= 0;
8326 symhdr
->iextMax
= 0;
8328 /* We accumulate the debugging information itself in the
8329 debug_info structure. */
8331 debug
.external_dnr
= NULL
;
8332 debug
.external_pdr
= NULL
;
8333 debug
.external_sym
= NULL
;
8334 debug
.external_opt
= NULL
;
8335 debug
.external_aux
= NULL
;
8337 debug
.ssext
= debug
.ssext_end
= NULL
;
8338 debug
.external_fdr
= NULL
;
8339 debug
.external_rfd
= NULL
;
8340 debug
.external_ext
= debug
.external_ext_end
= NULL
;
8342 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
8343 if (mdebug_handle
== NULL
)
8347 esym
.cobol_main
= 0;
8351 esym
.asym
.iss
= issNil
;
8352 esym
.asym
.st
= stLocal
;
8353 esym
.asym
.reserved
= 0;
8354 esym
.asym
.index
= indexNil
;
8356 for (i
= 0; i
< sizeof (secname
) / sizeof (secname
[0]); i
++)
8358 esym
.asym
.sc
= sc
[i
];
8359 s
= bfd_get_section_by_name (abfd
, secname
[i
]);
8362 esym
.asym
.value
= s
->vma
;
8363 last
= s
->vma
+ s
->_raw_size
;
8366 esym
.asym
.value
= last
;
8367 if (!bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
8372 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8374 asection
*input_section
;
8376 const struct ecoff_debug_swap
*input_swap
;
8377 struct ecoff_debug_info input_debug
;
8381 if (p
->type
!= bfd_indirect_link_order
)
8383 if (p
->type
== bfd_data_link_order
)
8388 input_section
= p
->u
.indirect
.section
;
8389 input_bfd
= input_section
->owner
;
8391 if (bfd_get_flavour (input_bfd
) != bfd_target_elf_flavour
8392 || (get_elf_backend_data (input_bfd
)
8393 ->elf_backend_ecoff_debug_swap
) == NULL
)
8395 /* I don't know what a non MIPS ELF bfd would be
8396 doing with a .mdebug section, but I don't really
8397 want to deal with it. */
8401 input_swap
= (get_elf_backend_data (input_bfd
)
8402 ->elf_backend_ecoff_debug_swap
);
8404 BFD_ASSERT (p
->size
== input_section
->_raw_size
);
8406 /* The ECOFF linking code expects that we have already
8407 read in the debugging information and set up an
8408 ecoff_debug_info structure, so we do that now. */
8409 if (! _bfd_mips_elf_read_ecoff_info (input_bfd
, input_section
,
8413 if (! (bfd_ecoff_debug_accumulate
8414 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
8415 &input_debug
, input_swap
, info
)))
8418 /* Loop through the external symbols. For each one with
8419 interesting information, try to find the symbol in
8420 the linker global hash table and save the information
8421 for the output external symbols. */
8422 eraw_src
= input_debug
.external_ext
;
8423 eraw_end
= (eraw_src
8424 + (input_debug
.symbolic_header
.iextMax
8425 * input_swap
->external_ext_size
));
8427 eraw_src
< eraw_end
;
8428 eraw_src
+= input_swap
->external_ext_size
)
8432 struct mips_elf_link_hash_entry
*h
;
8434 (*input_swap
->swap_ext_in
) (input_bfd
, eraw_src
, &ext
);
8435 if (ext
.asym
.sc
== scNil
8436 || ext
.asym
.sc
== scUndefined
8437 || ext
.asym
.sc
== scSUndefined
)
8440 name
= input_debug
.ssext
+ ext
.asym
.iss
;
8441 h
= mips_elf_link_hash_lookup (mips_elf_hash_table (info
),
8442 name
, FALSE
, FALSE
, TRUE
);
8443 if (h
== NULL
|| h
->esym
.ifd
!= -2)
8449 < input_debug
.symbolic_header
.ifdMax
);
8450 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
8456 /* Free up the information we just read. */
8457 free (input_debug
.line
);
8458 free (input_debug
.external_dnr
);
8459 free (input_debug
.external_pdr
);
8460 free (input_debug
.external_sym
);
8461 free (input_debug
.external_opt
);
8462 free (input_debug
.external_aux
);
8463 free (input_debug
.ss
);
8464 free (input_debug
.ssext
);
8465 free (input_debug
.external_fdr
);
8466 free (input_debug
.external_rfd
);
8467 free (input_debug
.external_ext
);
8469 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8470 elf_link_input_bfd ignores this section. */
8471 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8474 if (SGI_COMPAT (abfd
) && info
->shared
)
8476 /* Create .rtproc section. */
8477 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
8478 if (rtproc_sec
== NULL
)
8480 flagword flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
8481 | SEC_LINKER_CREATED
| SEC_READONLY
);
8483 rtproc_sec
= bfd_make_section (abfd
, ".rtproc");
8484 if (rtproc_sec
== NULL
8485 || ! bfd_set_section_flags (abfd
, rtproc_sec
, flags
)
8486 || ! bfd_set_section_alignment (abfd
, rtproc_sec
, 4))
8490 if (! mips_elf_create_procedure_table (mdebug_handle
, abfd
,
8496 /* Build the external symbol information. */
8499 einfo
.debug
= &debug
;
8501 einfo
.failed
= FALSE
;
8502 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
8503 mips_elf_output_extsym
, &einfo
);
8507 /* Set the size of the .mdebug section. */
8508 o
->_raw_size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
8510 /* Skip this section later on (I don't think this currently
8511 matters, but someday it might). */
8512 o
->link_order_head
= NULL
;
8517 if (strncmp (o
->name
, ".gptab.", sizeof ".gptab." - 1) == 0)
8519 const char *subname
;
8522 Elf32_External_gptab
*ext_tab
;
8525 /* The .gptab.sdata and .gptab.sbss sections hold
8526 information describing how the small data area would
8527 change depending upon the -G switch. These sections
8528 not used in executables files. */
8529 if (! info
->relocatable
)
8531 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8533 asection
*input_section
;
8535 if (p
->type
!= bfd_indirect_link_order
)
8537 if (p
->type
== bfd_data_link_order
)
8542 input_section
= p
->u
.indirect
.section
;
8544 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8545 elf_link_input_bfd ignores this section. */
8546 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8549 /* Skip this section later on (I don't think this
8550 currently matters, but someday it might). */
8551 o
->link_order_head
= NULL
;
8553 /* Really remove the section. */
8554 for (secpp
= &abfd
->sections
;
8556 secpp
= &(*secpp
)->next
)
8558 bfd_section_list_remove (abfd
, secpp
);
8559 --abfd
->section_count
;
8564 /* There is one gptab for initialized data, and one for
8565 uninitialized data. */
8566 if (strcmp (o
->name
, ".gptab.sdata") == 0)
8568 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
8572 (*_bfd_error_handler
)
8573 (_("%s: illegal section name `%s'"),
8574 bfd_get_filename (abfd
), o
->name
);
8575 bfd_set_error (bfd_error_nonrepresentable_section
);
8579 /* The linker script always combines .gptab.data and
8580 .gptab.sdata into .gptab.sdata, and likewise for
8581 .gptab.bss and .gptab.sbss. It is possible that there is
8582 no .sdata or .sbss section in the output file, in which
8583 case we must change the name of the output section. */
8584 subname
= o
->name
+ sizeof ".gptab" - 1;
8585 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
8587 if (o
== gptab_data_sec
)
8588 o
->name
= ".gptab.data";
8590 o
->name
= ".gptab.bss";
8591 subname
= o
->name
+ sizeof ".gptab" - 1;
8592 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
8595 /* Set up the first entry. */
8597 amt
= c
* sizeof (Elf32_gptab
);
8598 tab
= bfd_malloc (amt
);
8601 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
8602 tab
[0].gt_header
.gt_unused
= 0;
8604 /* Combine the input sections. */
8605 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8607 asection
*input_section
;
8611 bfd_size_type gpentry
;
8613 if (p
->type
!= bfd_indirect_link_order
)
8615 if (p
->type
== bfd_data_link_order
)
8620 input_section
= p
->u
.indirect
.section
;
8621 input_bfd
= input_section
->owner
;
8623 /* Combine the gptab entries for this input section one
8624 by one. We know that the input gptab entries are
8625 sorted by ascending -G value. */
8626 size
= bfd_section_size (input_bfd
, input_section
);
8628 for (gpentry
= sizeof (Elf32_External_gptab
);
8630 gpentry
+= sizeof (Elf32_External_gptab
))
8632 Elf32_External_gptab ext_gptab
;
8633 Elf32_gptab int_gptab
;
8639 if (! (bfd_get_section_contents
8640 (input_bfd
, input_section
, &ext_gptab
, gpentry
,
8641 sizeof (Elf32_External_gptab
))))
8647 bfd_mips_elf32_swap_gptab_in (input_bfd
, &ext_gptab
,
8649 val
= int_gptab
.gt_entry
.gt_g_value
;
8650 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
8653 for (look
= 1; look
< c
; look
++)
8655 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
8656 tab
[look
].gt_entry
.gt_bytes
+= add
;
8658 if (tab
[look
].gt_entry
.gt_g_value
== val
)
8664 Elf32_gptab
*new_tab
;
8667 /* We need a new table entry. */
8668 amt
= (bfd_size_type
) (c
+ 1) * sizeof (Elf32_gptab
);
8669 new_tab
= bfd_realloc (tab
, amt
);
8670 if (new_tab
== NULL
)
8676 tab
[c
].gt_entry
.gt_g_value
= val
;
8677 tab
[c
].gt_entry
.gt_bytes
= add
;
8679 /* Merge in the size for the next smallest -G
8680 value, since that will be implied by this new
8683 for (look
= 1; look
< c
; look
++)
8685 if (tab
[look
].gt_entry
.gt_g_value
< val
8687 || (tab
[look
].gt_entry
.gt_g_value
8688 > tab
[max
].gt_entry
.gt_g_value
)))
8692 tab
[c
].gt_entry
.gt_bytes
+=
8693 tab
[max
].gt_entry
.gt_bytes
;
8698 last
= int_gptab
.gt_entry
.gt_bytes
;
8701 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8702 elf_link_input_bfd ignores this section. */
8703 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8706 /* The table must be sorted by -G value. */
8708 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
8710 /* Swap out the table. */
8711 amt
= (bfd_size_type
) c
* sizeof (Elf32_External_gptab
);
8712 ext_tab
= bfd_alloc (abfd
, amt
);
8713 if (ext_tab
== NULL
)
8719 for (j
= 0; j
< c
; j
++)
8720 bfd_mips_elf32_swap_gptab_out (abfd
, tab
+ j
, ext_tab
+ j
);
8723 o
->_raw_size
= c
* sizeof (Elf32_External_gptab
);
8724 o
->contents
= (bfd_byte
*) ext_tab
;
8726 /* Skip this section later on (I don't think this currently
8727 matters, but someday it might). */
8728 o
->link_order_head
= NULL
;
8732 /* Invoke the regular ELF backend linker to do all the work. */
8733 if (!bfd_elf_final_link (abfd
, info
))
8736 /* Now write out the computed sections. */
8738 if (reginfo_sec
!= NULL
)
8740 Elf32_External_RegInfo ext
;
8742 bfd_mips_elf32_swap_reginfo_out (abfd
, ®info
, &ext
);
8743 if (! bfd_set_section_contents (abfd
, reginfo_sec
, &ext
, 0, sizeof ext
))
8747 if (mdebug_sec
!= NULL
)
8749 BFD_ASSERT (abfd
->output_has_begun
);
8750 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
8752 mdebug_sec
->filepos
))
8755 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
8758 if (gptab_data_sec
!= NULL
)
8760 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
8761 gptab_data_sec
->contents
,
8762 0, gptab_data_sec
->_raw_size
))
8766 if (gptab_bss_sec
!= NULL
)
8768 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
8769 gptab_bss_sec
->contents
,
8770 0, gptab_bss_sec
->_raw_size
))
8774 if (SGI_COMPAT (abfd
))
8776 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
8777 if (rtproc_sec
!= NULL
)
8779 if (! bfd_set_section_contents (abfd
, rtproc_sec
,
8780 rtproc_sec
->contents
,
8781 0, rtproc_sec
->_raw_size
))
8789 /* Structure for saying that BFD machine EXTENSION extends BASE. */
8791 struct mips_mach_extension
{
8792 unsigned long extension
, base
;
8796 /* An array describing how BFD machines relate to one another. The entries
8797 are ordered topologically with MIPS I extensions listed last. */
8799 static const struct mips_mach_extension mips_mach_extensions
[] = {
8800 /* MIPS64 extensions. */
8801 { bfd_mach_mipsisa64r2
, bfd_mach_mipsisa64
},
8802 { bfd_mach_mips_sb1
, bfd_mach_mipsisa64
},
8804 /* MIPS V extensions. */
8805 { bfd_mach_mipsisa64
, bfd_mach_mips5
},
8807 /* R10000 extensions. */
8808 { bfd_mach_mips12000
, bfd_mach_mips10000
},
8810 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
8811 vr5400 ISA, but doesn't include the multimedia stuff. It seems
8812 better to allow vr5400 and vr5500 code to be merged anyway, since
8813 many libraries will just use the core ISA. Perhaps we could add
8814 some sort of ASE flag if this ever proves a problem. */
8815 { bfd_mach_mips5500
, bfd_mach_mips5400
},
8816 { bfd_mach_mips5400
, bfd_mach_mips5000
},
8818 /* MIPS IV extensions. */
8819 { bfd_mach_mips5
, bfd_mach_mips8000
},
8820 { bfd_mach_mips10000
, bfd_mach_mips8000
},
8821 { bfd_mach_mips5000
, bfd_mach_mips8000
},
8822 { bfd_mach_mips7000
, bfd_mach_mips8000
},
8824 /* VR4100 extensions. */
8825 { bfd_mach_mips4120
, bfd_mach_mips4100
},
8826 { bfd_mach_mips4111
, bfd_mach_mips4100
},
8828 /* MIPS III extensions. */
8829 { bfd_mach_mips8000
, bfd_mach_mips4000
},
8830 { bfd_mach_mips4650
, bfd_mach_mips4000
},
8831 { bfd_mach_mips4600
, bfd_mach_mips4000
},
8832 { bfd_mach_mips4400
, bfd_mach_mips4000
},
8833 { bfd_mach_mips4300
, bfd_mach_mips4000
},
8834 { bfd_mach_mips4100
, bfd_mach_mips4000
},
8835 { bfd_mach_mips4010
, bfd_mach_mips4000
},
8837 /* MIPS32 extensions. */
8838 { bfd_mach_mipsisa32r2
, bfd_mach_mipsisa32
},
8840 /* MIPS II extensions. */
8841 { bfd_mach_mips4000
, bfd_mach_mips6000
},
8842 { bfd_mach_mipsisa32
, bfd_mach_mips6000
},
8844 /* MIPS I extensions. */
8845 { bfd_mach_mips6000
, bfd_mach_mips3000
},
8846 { bfd_mach_mips3900
, bfd_mach_mips3000
}
8850 /* Return true if bfd machine EXTENSION is an extension of machine BASE. */
8853 mips_mach_extends_p (unsigned long base
, unsigned long extension
)
8857 for (i
= 0; extension
!= base
&& i
< ARRAY_SIZE (mips_mach_extensions
); i
++)
8858 if (extension
== mips_mach_extensions
[i
].extension
)
8859 extension
= mips_mach_extensions
[i
].base
;
8861 return extension
== base
;
8865 /* Return true if the given ELF header flags describe a 32-bit binary. */
8868 mips_32bit_flags_p (flagword flags
)
8870 return ((flags
& EF_MIPS_32BITMODE
) != 0
8871 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
8872 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
8873 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
8874 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
8875 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
8876 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
);
8880 /* Merge backend specific data from an object file to the output
8881 object file when linking. */
8884 _bfd_mips_elf_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
8889 bfd_boolean null_input_bfd
= TRUE
;
8892 /* Check if we have the same endianess */
8893 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
8895 (*_bfd_error_handler
)
8896 (_("%s: endianness incompatible with that of the selected emulation"),
8897 bfd_archive_filename (ibfd
));
8901 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
8902 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
8905 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
8907 (*_bfd_error_handler
)
8908 (_("%s: ABI is incompatible with that of the selected emulation"),
8909 bfd_archive_filename (ibfd
));
8913 new_flags
= elf_elfheader (ibfd
)->e_flags
;
8914 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_NOREORDER
;
8915 old_flags
= elf_elfheader (obfd
)->e_flags
;
8917 if (! elf_flags_init (obfd
))
8919 elf_flags_init (obfd
) = TRUE
;
8920 elf_elfheader (obfd
)->e_flags
= new_flags
;
8921 elf_elfheader (obfd
)->e_ident
[EI_CLASS
]
8922 = elf_elfheader (ibfd
)->e_ident
[EI_CLASS
];
8924 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
8925 && bfd_get_arch_info (obfd
)->the_default
)
8927 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
8928 bfd_get_mach (ibfd
)))
8935 /* Check flag compatibility. */
8937 new_flags
&= ~EF_MIPS_NOREORDER
;
8938 old_flags
&= ~EF_MIPS_NOREORDER
;
8940 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
8941 doesn't seem to matter. */
8942 new_flags
&= ~EF_MIPS_XGOT
;
8943 old_flags
&= ~EF_MIPS_XGOT
;
8945 /* MIPSpro generates ucode info in n64 objects. Again, we should
8946 just be able to ignore this. */
8947 new_flags
&= ~EF_MIPS_UCODE
;
8948 old_flags
&= ~EF_MIPS_UCODE
;
8950 if (new_flags
== old_flags
)
8953 /* Check to see if the input BFD actually contains any sections.
8954 If not, its flags may not have been initialised either, but it cannot
8955 actually cause any incompatibility. */
8956 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
8958 /* Ignore synthetic sections and empty .text, .data and .bss sections
8959 which are automatically generated by gas. */
8960 if (strcmp (sec
->name
, ".reginfo")
8961 && strcmp (sec
->name
, ".mdebug")
8962 && (sec
->_raw_size
!= 0
8963 || (strcmp (sec
->name
, ".text")
8964 && strcmp (sec
->name
, ".data")
8965 && strcmp (sec
->name
, ".bss"))))
8967 null_input_bfd
= FALSE
;
8976 if (((new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0)
8977 != ((old_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0))
8979 (*_bfd_error_handler
)
8980 (_("%s: warning: linking PIC files with non-PIC files"),
8981 bfd_archive_filename (ibfd
));
8985 if (new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
))
8986 elf_elfheader (obfd
)->e_flags
|= EF_MIPS_CPIC
;
8987 if (! (new_flags
& EF_MIPS_PIC
))
8988 elf_elfheader (obfd
)->e_flags
&= ~EF_MIPS_PIC
;
8990 new_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
8991 old_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
8993 /* Compare the ISAs. */
8994 if (mips_32bit_flags_p (old_flags
) != mips_32bit_flags_p (new_flags
))
8996 (*_bfd_error_handler
)
8997 (_("%s: linking 32-bit code with 64-bit code"),
8998 bfd_archive_filename (ibfd
));
9001 else if (!mips_mach_extends_p (bfd_get_mach (ibfd
), bfd_get_mach (obfd
)))
9003 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
9004 if (mips_mach_extends_p (bfd_get_mach (obfd
), bfd_get_mach (ibfd
)))
9006 /* Copy the architecture info from IBFD to OBFD. Also copy
9007 the 32-bit flag (if set) so that we continue to recognise
9008 OBFD as a 32-bit binary. */
9009 bfd_set_arch_info (obfd
, bfd_get_arch_info (ibfd
));
9010 elf_elfheader (obfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
9011 elf_elfheader (obfd
)->e_flags
9012 |= new_flags
& (EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9014 /* Copy across the ABI flags if OBFD doesn't use them
9015 and if that was what caused us to treat IBFD as 32-bit. */
9016 if ((old_flags
& EF_MIPS_ABI
) == 0
9017 && mips_32bit_flags_p (new_flags
)
9018 && !mips_32bit_flags_p (new_flags
& ~EF_MIPS_ABI
))
9019 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ABI
;
9023 /* The ISAs aren't compatible. */
9024 (*_bfd_error_handler
)
9025 (_("%s: linking %s module with previous %s modules"),
9026 bfd_archive_filename (ibfd
),
9027 bfd_printable_name (ibfd
),
9028 bfd_printable_name (obfd
));
9033 new_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9034 old_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9036 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
9037 does set EI_CLASS differently from any 32-bit ABI. */
9038 if ((new_flags
& EF_MIPS_ABI
) != (old_flags
& EF_MIPS_ABI
)
9039 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
9040 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
9042 /* Only error if both are set (to different values). */
9043 if (((new_flags
& EF_MIPS_ABI
) && (old_flags
& EF_MIPS_ABI
))
9044 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
9045 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
9047 (*_bfd_error_handler
)
9048 (_("%s: ABI mismatch: linking %s module with previous %s modules"),
9049 bfd_archive_filename (ibfd
),
9050 elf_mips_abi_name (ibfd
),
9051 elf_mips_abi_name (obfd
));
9054 new_flags
&= ~EF_MIPS_ABI
;
9055 old_flags
&= ~EF_MIPS_ABI
;
9058 /* For now, allow arbitrary mixing of ASEs (retain the union). */
9059 if ((new_flags
& EF_MIPS_ARCH_ASE
) != (old_flags
& EF_MIPS_ARCH_ASE
))
9061 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ARCH_ASE
;
9063 new_flags
&= ~ EF_MIPS_ARCH_ASE
;
9064 old_flags
&= ~ EF_MIPS_ARCH_ASE
;
9067 /* Warn about any other mismatches */
9068 if (new_flags
!= old_flags
)
9070 (*_bfd_error_handler
)
9071 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
9072 bfd_archive_filename (ibfd
), (unsigned long) new_flags
,
9073 (unsigned long) old_flags
);
9079 bfd_set_error (bfd_error_bad_value
);
9086 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
9089 _bfd_mips_elf_set_private_flags (bfd
*abfd
, flagword flags
)
9091 BFD_ASSERT (!elf_flags_init (abfd
)
9092 || elf_elfheader (abfd
)->e_flags
== flags
);
9094 elf_elfheader (abfd
)->e_flags
= flags
;
9095 elf_flags_init (abfd
) = TRUE
;
9100 _bfd_mips_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
9104 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
9106 /* Print normal ELF private data. */
9107 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
9109 /* xgettext:c-format */
9110 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
9112 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
)
9113 fprintf (file
, _(" [abi=O32]"));
9114 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O64
)
9115 fprintf (file
, _(" [abi=O64]"));
9116 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
)
9117 fprintf (file
, _(" [abi=EABI32]"));
9118 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
9119 fprintf (file
, _(" [abi=EABI64]"));
9120 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
))
9121 fprintf (file
, _(" [abi unknown]"));
9122 else if (ABI_N32_P (abfd
))
9123 fprintf (file
, _(" [abi=N32]"));
9124 else if (ABI_64_P (abfd
))
9125 fprintf (file
, _(" [abi=64]"));
9127 fprintf (file
, _(" [no abi set]"));
9129 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
9130 fprintf (file
, _(" [mips1]"));
9131 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
9132 fprintf (file
, _(" [mips2]"));
9133 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
9134 fprintf (file
, _(" [mips3]"));
9135 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
9136 fprintf (file
, _(" [mips4]"));
9137 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_5
)
9138 fprintf (file
, _(" [mips5]"));
9139 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
)
9140 fprintf (file
, _(" [mips32]"));
9141 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64
)
9142 fprintf (file
, _(" [mips64]"));
9143 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
)
9144 fprintf (file
, _(" [mips32r2]"));
9145 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64R2
)
9146 fprintf (file
, _(" [mips64r2]"));
9148 fprintf (file
, _(" [unknown ISA]"));
9150 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
9151 fprintf (file
, _(" [mdmx]"));
9153 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_M16
)
9154 fprintf (file
, _(" [mips16]"));
9156 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_32BITMODE
)
9157 fprintf (file
, _(" [32bitmode]"));
9159 fprintf (file
, _(" [not 32bitmode]"));
9166 struct bfd_elf_special_section
const _bfd_mips_elf_special_sections
[]=
9168 { ".sdata", 6, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9169 { ".sbss", 5, -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9170 { ".lit4", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9171 { ".lit8", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9172 { ".ucode", 6, 0, SHT_MIPS_UCODE
, 0 },
9173 { ".mdebug", 7, 0, SHT_MIPS_DEBUG
, 0 },
9174 { NULL
, 0, 0, 0, 0 }