1 /* MIPS-specific support for ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2005 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
->size
= 0;
1032 h
->fn_stub
->flags
&= ~SEC_RELOC
;
1033 h
->fn_stub
->reloc_count
= 0;
1034 h
->fn_stub
->flags
|= SEC_EXCLUDE
;
1037 if (h
->call_stub
!= NULL
1038 && h
->root
.other
== STO_MIPS16
)
1040 /* We don't need the call_stub; this is a 16 bit function, so
1041 calls from other 16 bit functions are OK. Clobber the size
1042 to 0 to prevent it from being included in the link. */
1043 h
->call_stub
->size
= 0;
1044 h
->call_stub
->flags
&= ~SEC_RELOC
;
1045 h
->call_stub
->reloc_count
= 0;
1046 h
->call_stub
->flags
|= SEC_EXCLUDE
;
1049 if (h
->call_fp_stub
!= NULL
1050 && h
->root
.other
== STO_MIPS16
)
1052 /* We don't need the call_stub; this is a 16 bit function, so
1053 calls from other 16 bit functions are OK. Clobber the size
1054 to 0 to prevent it from being included in the link. */
1055 h
->call_fp_stub
->size
= 0;
1056 h
->call_fp_stub
->flags
&= ~SEC_RELOC
;
1057 h
->call_fp_stub
->reloc_count
= 0;
1058 h
->call_fp_stub
->flags
|= SEC_EXCLUDE
;
1064 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
1065 Most mips16 instructions are 16 bits, but these instructions
1068 The format of these instructions is:
1070 +--------------+--------------------------------+
1071 | JALX | X| Imm 20:16 | Imm 25:21 |
1072 +--------------+--------------------------------+
1074 +-----------------------------------------------+
1076 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
1077 Note that the immediate value in the first word is swapped.
1079 When producing a relocatable object file, R_MIPS16_26 is
1080 handled mostly like R_MIPS_26. In particular, the addend is
1081 stored as a straight 26-bit value in a 32-bit instruction.
1082 (gas makes life simpler for itself by never adjusting a
1083 R_MIPS16_26 reloc to be against a section, so the addend is
1084 always zero). However, the 32 bit instruction is stored as 2
1085 16-bit values, rather than a single 32-bit value. In a
1086 big-endian file, the result is the same; in a little-endian
1087 file, the two 16-bit halves of the 32 bit value are swapped.
1088 This is so that a disassembler can recognize the jal
1091 When doing a final link, R_MIPS16_26 is treated as a 32 bit
1092 instruction stored as two 16-bit values. The addend A is the
1093 contents of the targ26 field. The calculation is the same as
1094 R_MIPS_26. When storing the calculated value, reorder the
1095 immediate value as shown above, and don't forget to store the
1096 value as two 16-bit values.
1098 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
1102 +--------+----------------------+
1106 +--------+----------------------+
1109 +----------+------+-------------+
1113 +----------+--------------------+
1114 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
1115 ((sub1 << 16) | sub2)).
1117 When producing a relocatable object file, the calculation is
1118 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1119 When producing a fully linked file, the calculation is
1120 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1121 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)
1123 R_MIPS16_GPREL is used for GP-relative addressing in mips16
1124 mode. A typical instruction will have a format like this:
1126 +--------------+--------------------------------+
1127 | EXTEND | Imm 10:5 | Imm 15:11 |
1128 +--------------+--------------------------------+
1129 | Major | rx | ry | Imm 4:0 |
1130 +--------------+--------------------------------+
1132 EXTEND is the five bit value 11110. Major is the instruction
1135 This is handled exactly like R_MIPS_GPREL16, except that the
1136 addend is retrieved and stored as shown in this diagram; that
1137 is, the Imm fields above replace the V-rel16 field.
1139 All we need to do here is shuffle the bits appropriately. As
1140 above, the two 16-bit halves must be swapped on a
1141 little-endian system.
1143 R_MIPS16_HI16 and R_MIPS16_LO16 are used in mips16 mode to
1144 access data when neither GP-relative nor PC-relative addressing
1145 can be used. They are handled like R_MIPS_HI16 and R_MIPS_LO16,
1146 except that the addend is retrieved and stored as shown above
1150 _bfd_mips16_elf_reloc_unshuffle (bfd
*abfd
, int r_type
,
1151 bfd_boolean jal_shuffle
, bfd_byte
*data
)
1153 bfd_vma extend
, insn
, val
;
1155 if (r_type
!= R_MIPS16_26
&& r_type
!= R_MIPS16_GPREL
1156 && r_type
!= R_MIPS16_HI16
&& r_type
!= R_MIPS16_LO16
)
1159 /* Pick up the mips16 extend instruction and the real instruction. */
1160 extend
= bfd_get_16 (abfd
, data
);
1161 insn
= bfd_get_16 (abfd
, data
+ 2);
1162 if (r_type
== R_MIPS16_26
)
1165 val
= ((extend
& 0xfc00) << 16) | ((extend
& 0x3e0) << 11)
1166 | ((extend
& 0x1f) << 21) | insn
;
1168 val
= extend
<< 16 | insn
;
1171 val
= ((extend
& 0xf800) << 16) | ((insn
& 0xffe0) << 11)
1172 | ((extend
& 0x1f) << 11) | (extend
& 0x7e0) | (insn
& 0x1f);
1173 bfd_put_32 (abfd
, val
, data
);
1177 _bfd_mips16_elf_reloc_shuffle (bfd
*abfd
, int r_type
,
1178 bfd_boolean jal_shuffle
, bfd_byte
*data
)
1180 bfd_vma extend
, insn
, val
;
1182 if (r_type
!= R_MIPS16_26
&& r_type
!= R_MIPS16_GPREL
1183 && r_type
!= R_MIPS16_HI16
&& r_type
!= R_MIPS16_LO16
)
1186 val
= bfd_get_32 (abfd
, data
);
1187 if (r_type
== R_MIPS16_26
)
1191 insn
= val
& 0xffff;
1192 extend
= ((val
>> 16) & 0xfc00) | ((val
>> 11) & 0x3e0)
1193 | ((val
>> 21) & 0x1f);
1197 insn
= val
& 0xffff;
1203 insn
= ((val
>> 11) & 0xffe0) | (val
& 0x1f);
1204 extend
= ((val
>> 16) & 0xf800) | ((val
>> 11) & 0x1f) | (val
& 0x7e0);
1206 bfd_put_16 (abfd
, insn
, data
+ 2);
1207 bfd_put_16 (abfd
, extend
, data
);
1210 bfd_reloc_status_type
1211 _bfd_mips_elf_gprel16_with_gp (bfd
*abfd
, asymbol
*symbol
,
1212 arelent
*reloc_entry
, asection
*input_section
,
1213 bfd_boolean relocatable
, void *data
, bfd_vma gp
)
1217 bfd_reloc_status_type status
;
1219 if (bfd_is_com_section (symbol
->section
))
1222 relocation
= symbol
->value
;
1224 relocation
+= symbol
->section
->output_section
->vma
;
1225 relocation
+= symbol
->section
->output_offset
;
1227 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1228 return bfd_reloc_outofrange
;
1230 /* Set val to the offset into the section or symbol. */
1231 val
= reloc_entry
->addend
;
1233 _bfd_mips_elf_sign_extend (val
, 16);
1235 /* Adjust val for the final section location and GP value. If we
1236 are producing relocatable output, we don't want to do this for
1237 an external symbol. */
1239 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1240 val
+= relocation
- gp
;
1242 if (reloc_entry
->howto
->partial_inplace
)
1244 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
1246 + reloc_entry
->address
);
1247 if (status
!= bfd_reloc_ok
)
1251 reloc_entry
->addend
= val
;
1254 reloc_entry
->address
+= input_section
->output_offset
;
1256 return bfd_reloc_ok
;
1259 /* Used to store a REL high-part relocation such as R_MIPS_HI16 or
1260 R_MIPS_GOT16. REL is the relocation, INPUT_SECTION is the section
1261 that contains the relocation field and DATA points to the start of
1266 struct mips_hi16
*next
;
1268 asection
*input_section
;
1272 /* FIXME: This should not be a static variable. */
1274 static struct mips_hi16
*mips_hi16_list
;
1276 /* A howto special_function for REL *HI16 relocations. We can only
1277 calculate the correct value once we've seen the partnering
1278 *LO16 relocation, so just save the information for later.
1280 The ABI requires that the *LO16 immediately follow the *HI16.
1281 However, as a GNU extension, we permit an arbitrary number of
1282 *HI16s to be associated with a single *LO16. This significantly
1283 simplies the relocation handling in gcc. */
1285 bfd_reloc_status_type
1286 _bfd_mips_elf_hi16_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
1287 asymbol
*symbol ATTRIBUTE_UNUSED
, void *data
,
1288 asection
*input_section
, bfd
*output_bfd
,
1289 char **error_message ATTRIBUTE_UNUSED
)
1291 struct mips_hi16
*n
;
1293 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1294 return bfd_reloc_outofrange
;
1296 n
= bfd_malloc (sizeof *n
);
1298 return bfd_reloc_outofrange
;
1300 n
->next
= mips_hi16_list
;
1302 n
->input_section
= input_section
;
1303 n
->rel
= *reloc_entry
;
1306 if (output_bfd
!= NULL
)
1307 reloc_entry
->address
+= input_section
->output_offset
;
1309 return bfd_reloc_ok
;
1312 /* A howto special_function for REL R_MIPS_GOT16 relocations. This is just
1313 like any other 16-bit relocation when applied to global symbols, but is
1314 treated in the same as R_MIPS_HI16 when applied to local symbols. */
1316 bfd_reloc_status_type
1317 _bfd_mips_elf_got16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1318 void *data
, asection
*input_section
,
1319 bfd
*output_bfd
, char **error_message
)
1321 if ((symbol
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
1322 || bfd_is_und_section (bfd_get_section (symbol
))
1323 || bfd_is_com_section (bfd_get_section (symbol
)))
1324 /* The relocation is against a global symbol. */
1325 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1326 input_section
, output_bfd
,
1329 return _bfd_mips_elf_hi16_reloc (abfd
, reloc_entry
, symbol
, data
,
1330 input_section
, output_bfd
, error_message
);
1333 /* A howto special_function for REL *LO16 relocations. The *LO16 itself
1334 is a straightforward 16 bit inplace relocation, but we must deal with
1335 any partnering high-part relocations as well. */
1337 bfd_reloc_status_type
1338 _bfd_mips_elf_lo16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1339 void *data
, asection
*input_section
,
1340 bfd
*output_bfd
, char **error_message
)
1343 bfd_byte
*location
= (bfd_byte
*) data
+ reloc_entry
->address
;
1345 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1346 return bfd_reloc_outofrange
;
1348 _bfd_mips16_elf_reloc_unshuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1350 vallo
= bfd_get_32 (abfd
, location
);
1351 _bfd_mips16_elf_reloc_shuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1354 while (mips_hi16_list
!= NULL
)
1356 bfd_reloc_status_type ret
;
1357 struct mips_hi16
*hi
;
1359 hi
= mips_hi16_list
;
1361 /* R_MIPS_GOT16 relocations are something of a special case. We
1362 want to install the addend in the same way as for a R_MIPS_HI16
1363 relocation (with a rightshift of 16). However, since GOT16
1364 relocations can also be used with global symbols, their howto
1365 has a rightshift of 0. */
1366 if (hi
->rel
.howto
->type
== R_MIPS_GOT16
)
1367 hi
->rel
.howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, R_MIPS_HI16
, FALSE
);
1369 /* VALLO is a signed 16-bit number. Bias it by 0x8000 so that any
1370 carry or borrow will induce a change of +1 or -1 in the high part. */
1371 hi
->rel
.addend
+= (vallo
+ 0x8000) & 0xffff;
1373 ret
= _bfd_mips_elf_generic_reloc (abfd
, &hi
->rel
, symbol
, hi
->data
,
1374 hi
->input_section
, output_bfd
,
1376 if (ret
!= bfd_reloc_ok
)
1379 mips_hi16_list
= hi
->next
;
1383 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1384 input_section
, output_bfd
,
1388 /* A generic howto special_function. This calculates and installs the
1389 relocation itself, thus avoiding the oft-discussed problems in
1390 bfd_perform_relocation and bfd_install_relocation. */
1392 bfd_reloc_status_type
1393 _bfd_mips_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
1394 asymbol
*symbol
, void *data ATTRIBUTE_UNUSED
,
1395 asection
*input_section
, bfd
*output_bfd
,
1396 char **error_message ATTRIBUTE_UNUSED
)
1399 bfd_reloc_status_type status
;
1400 bfd_boolean relocatable
;
1402 relocatable
= (output_bfd
!= NULL
);
1404 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1405 return bfd_reloc_outofrange
;
1407 /* Build up the field adjustment in VAL. */
1409 if (!relocatable
|| (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1411 /* Either we're calculating the final field value or we have a
1412 relocation against a section symbol. Add in the section's
1413 offset or address. */
1414 val
+= symbol
->section
->output_section
->vma
;
1415 val
+= symbol
->section
->output_offset
;
1420 /* We're calculating the final field value. Add in the symbol's value
1421 and, if pc-relative, subtract the address of the field itself. */
1422 val
+= symbol
->value
;
1423 if (reloc_entry
->howto
->pc_relative
)
1425 val
-= input_section
->output_section
->vma
;
1426 val
-= input_section
->output_offset
;
1427 val
-= reloc_entry
->address
;
1431 /* VAL is now the final adjustment. If we're keeping this relocation
1432 in the output file, and if the relocation uses a separate addend,
1433 we just need to add VAL to that addend. Otherwise we need to add
1434 VAL to the relocation field itself. */
1435 if (relocatable
&& !reloc_entry
->howto
->partial_inplace
)
1436 reloc_entry
->addend
+= val
;
1439 bfd_byte
*location
= (bfd_byte
*) data
+ reloc_entry
->address
;
1441 /* Add in the separate addend, if any. */
1442 val
+= reloc_entry
->addend
;
1444 /* Add VAL to the relocation field. */
1445 _bfd_mips16_elf_reloc_unshuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1447 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
1449 _bfd_mips16_elf_reloc_shuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1452 if (status
!= bfd_reloc_ok
)
1457 reloc_entry
->address
+= input_section
->output_offset
;
1459 return bfd_reloc_ok
;
1462 /* Swap an entry in a .gptab section. Note that these routines rely
1463 on the equivalence of the two elements of the union. */
1466 bfd_mips_elf32_swap_gptab_in (bfd
*abfd
, const Elf32_External_gptab
*ex
,
1469 in
->gt_entry
.gt_g_value
= H_GET_32 (abfd
, ex
->gt_entry
.gt_g_value
);
1470 in
->gt_entry
.gt_bytes
= H_GET_32 (abfd
, ex
->gt_entry
.gt_bytes
);
1474 bfd_mips_elf32_swap_gptab_out (bfd
*abfd
, const Elf32_gptab
*in
,
1475 Elf32_External_gptab
*ex
)
1477 H_PUT_32 (abfd
, in
->gt_entry
.gt_g_value
, ex
->gt_entry
.gt_g_value
);
1478 H_PUT_32 (abfd
, in
->gt_entry
.gt_bytes
, ex
->gt_entry
.gt_bytes
);
1482 bfd_elf32_swap_compact_rel_out (bfd
*abfd
, const Elf32_compact_rel
*in
,
1483 Elf32_External_compact_rel
*ex
)
1485 H_PUT_32 (abfd
, in
->id1
, ex
->id1
);
1486 H_PUT_32 (abfd
, in
->num
, ex
->num
);
1487 H_PUT_32 (abfd
, in
->id2
, ex
->id2
);
1488 H_PUT_32 (abfd
, in
->offset
, ex
->offset
);
1489 H_PUT_32 (abfd
, in
->reserved0
, ex
->reserved0
);
1490 H_PUT_32 (abfd
, in
->reserved1
, ex
->reserved1
);
1494 bfd_elf32_swap_crinfo_out (bfd
*abfd
, const Elf32_crinfo
*in
,
1495 Elf32_External_crinfo
*ex
)
1499 l
= (((in
->ctype
& CRINFO_CTYPE
) << CRINFO_CTYPE_SH
)
1500 | ((in
->rtype
& CRINFO_RTYPE
) << CRINFO_RTYPE_SH
)
1501 | ((in
->dist2to
& CRINFO_DIST2TO
) << CRINFO_DIST2TO_SH
)
1502 | ((in
->relvaddr
& CRINFO_RELVADDR
) << CRINFO_RELVADDR_SH
));
1503 H_PUT_32 (abfd
, l
, ex
->info
);
1504 H_PUT_32 (abfd
, in
->konst
, ex
->konst
);
1505 H_PUT_32 (abfd
, in
->vaddr
, ex
->vaddr
);
1508 /* A .reginfo section holds a single Elf32_RegInfo structure. These
1509 routines swap this structure in and out. They are used outside of
1510 BFD, so they are globally visible. */
1513 bfd_mips_elf32_swap_reginfo_in (bfd
*abfd
, const Elf32_External_RegInfo
*ex
,
1516 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1517 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1518 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1519 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1520 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1521 in
->ri_gp_value
= H_GET_32 (abfd
, ex
->ri_gp_value
);
1525 bfd_mips_elf32_swap_reginfo_out (bfd
*abfd
, const Elf32_RegInfo
*in
,
1526 Elf32_External_RegInfo
*ex
)
1528 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1529 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1530 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1531 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1532 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1533 H_PUT_32 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1536 /* In the 64 bit ABI, the .MIPS.options section holds register
1537 information in an Elf64_Reginfo structure. These routines swap
1538 them in and out. They are globally visible because they are used
1539 outside of BFD. These routines are here so that gas can call them
1540 without worrying about whether the 64 bit ABI has been included. */
1543 bfd_mips_elf64_swap_reginfo_in (bfd
*abfd
, const Elf64_External_RegInfo
*ex
,
1544 Elf64_Internal_RegInfo
*in
)
1546 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1547 in
->ri_pad
= H_GET_32 (abfd
, ex
->ri_pad
);
1548 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1549 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1550 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1551 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1552 in
->ri_gp_value
= H_GET_64 (abfd
, ex
->ri_gp_value
);
1556 bfd_mips_elf64_swap_reginfo_out (bfd
*abfd
, const Elf64_Internal_RegInfo
*in
,
1557 Elf64_External_RegInfo
*ex
)
1559 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1560 H_PUT_32 (abfd
, in
->ri_pad
, ex
->ri_pad
);
1561 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1562 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1563 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1564 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1565 H_PUT_64 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1568 /* Swap in an options header. */
1571 bfd_mips_elf_swap_options_in (bfd
*abfd
, const Elf_External_Options
*ex
,
1572 Elf_Internal_Options
*in
)
1574 in
->kind
= H_GET_8 (abfd
, ex
->kind
);
1575 in
->size
= H_GET_8 (abfd
, ex
->size
);
1576 in
->section
= H_GET_16 (abfd
, ex
->section
);
1577 in
->info
= H_GET_32 (abfd
, ex
->info
);
1580 /* Swap out an options header. */
1583 bfd_mips_elf_swap_options_out (bfd
*abfd
, const Elf_Internal_Options
*in
,
1584 Elf_External_Options
*ex
)
1586 H_PUT_8 (abfd
, in
->kind
, ex
->kind
);
1587 H_PUT_8 (abfd
, in
->size
, ex
->size
);
1588 H_PUT_16 (abfd
, in
->section
, ex
->section
);
1589 H_PUT_32 (abfd
, in
->info
, ex
->info
);
1592 /* This function is called via qsort() to sort the dynamic relocation
1593 entries by increasing r_symndx value. */
1596 sort_dynamic_relocs (const void *arg1
, const void *arg2
)
1598 Elf_Internal_Rela int_reloc1
;
1599 Elf_Internal_Rela int_reloc2
;
1601 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg1
, &int_reloc1
);
1602 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg2
, &int_reloc2
);
1604 return ELF32_R_SYM (int_reloc1
.r_info
) - ELF32_R_SYM (int_reloc2
.r_info
);
1607 /* Like sort_dynamic_relocs, but used for elf64 relocations. */
1610 sort_dynamic_relocs_64 (const void *arg1
, const void *arg2
)
1612 Elf_Internal_Rela int_reloc1
[3];
1613 Elf_Internal_Rela int_reloc2
[3];
1615 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1616 (reldyn_sorting_bfd
, arg1
, int_reloc1
);
1617 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1618 (reldyn_sorting_bfd
, arg2
, int_reloc2
);
1620 return (ELF64_R_SYM (int_reloc1
[0].r_info
)
1621 - ELF64_R_SYM (int_reloc2
[0].r_info
));
1625 /* This routine is used to write out ECOFF debugging external symbol
1626 information. It is called via mips_elf_link_hash_traverse. The
1627 ECOFF external symbol information must match the ELF external
1628 symbol information. Unfortunately, at this point we don't know
1629 whether a symbol is required by reloc information, so the two
1630 tables may wind up being different. We must sort out the external
1631 symbol information before we can set the final size of the .mdebug
1632 section, and we must set the size of the .mdebug section before we
1633 can relocate any sections, and we can't know which symbols are
1634 required by relocation until we relocate the sections.
1635 Fortunately, it is relatively unlikely that any symbol will be
1636 stripped but required by a reloc. In particular, it can not happen
1637 when generating a final executable. */
1640 mips_elf_output_extsym (struct mips_elf_link_hash_entry
*h
, void *data
)
1642 struct extsym_info
*einfo
= data
;
1644 asection
*sec
, *output_section
;
1646 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1647 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1649 if (h
->root
.indx
== -2)
1651 else if ((h
->root
.def_dynamic
1652 || h
->root
.ref_dynamic
1653 || h
->root
.type
== bfd_link_hash_new
)
1654 && !h
->root
.def_regular
1655 && !h
->root
.ref_regular
)
1657 else if (einfo
->info
->strip
== strip_all
1658 || (einfo
->info
->strip
== strip_some
1659 && bfd_hash_lookup (einfo
->info
->keep_hash
,
1660 h
->root
.root
.root
.string
,
1661 FALSE
, FALSE
) == NULL
))
1669 if (h
->esym
.ifd
== -2)
1672 h
->esym
.cobol_main
= 0;
1673 h
->esym
.weakext
= 0;
1674 h
->esym
.reserved
= 0;
1675 h
->esym
.ifd
= ifdNil
;
1676 h
->esym
.asym
.value
= 0;
1677 h
->esym
.asym
.st
= stGlobal
;
1679 if (h
->root
.root
.type
== bfd_link_hash_undefined
1680 || h
->root
.root
.type
== bfd_link_hash_undefweak
)
1684 /* Use undefined class. Also, set class and type for some
1686 name
= h
->root
.root
.root
.string
;
1687 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
1688 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
1690 h
->esym
.asym
.sc
= scData
;
1691 h
->esym
.asym
.st
= stLabel
;
1692 h
->esym
.asym
.value
= 0;
1694 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
1696 h
->esym
.asym
.sc
= scAbs
;
1697 h
->esym
.asym
.st
= stLabel
;
1698 h
->esym
.asym
.value
=
1699 mips_elf_hash_table (einfo
->info
)->procedure_count
;
1701 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (einfo
->abfd
))
1703 h
->esym
.asym
.sc
= scAbs
;
1704 h
->esym
.asym
.st
= stLabel
;
1705 h
->esym
.asym
.value
= elf_gp (einfo
->abfd
);
1708 h
->esym
.asym
.sc
= scUndefined
;
1710 else if (h
->root
.root
.type
!= bfd_link_hash_defined
1711 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
1712 h
->esym
.asym
.sc
= scAbs
;
1717 sec
= h
->root
.root
.u
.def
.section
;
1718 output_section
= sec
->output_section
;
1720 /* When making a shared library and symbol h is the one from
1721 the another shared library, OUTPUT_SECTION may be null. */
1722 if (output_section
== NULL
)
1723 h
->esym
.asym
.sc
= scUndefined
;
1726 name
= bfd_section_name (output_section
->owner
, output_section
);
1728 if (strcmp (name
, ".text") == 0)
1729 h
->esym
.asym
.sc
= scText
;
1730 else if (strcmp (name
, ".data") == 0)
1731 h
->esym
.asym
.sc
= scData
;
1732 else if (strcmp (name
, ".sdata") == 0)
1733 h
->esym
.asym
.sc
= scSData
;
1734 else if (strcmp (name
, ".rodata") == 0
1735 || strcmp (name
, ".rdata") == 0)
1736 h
->esym
.asym
.sc
= scRData
;
1737 else if (strcmp (name
, ".bss") == 0)
1738 h
->esym
.asym
.sc
= scBss
;
1739 else if (strcmp (name
, ".sbss") == 0)
1740 h
->esym
.asym
.sc
= scSBss
;
1741 else if (strcmp (name
, ".init") == 0)
1742 h
->esym
.asym
.sc
= scInit
;
1743 else if (strcmp (name
, ".fini") == 0)
1744 h
->esym
.asym
.sc
= scFini
;
1746 h
->esym
.asym
.sc
= scAbs
;
1750 h
->esym
.asym
.reserved
= 0;
1751 h
->esym
.asym
.index
= indexNil
;
1754 if (h
->root
.root
.type
== bfd_link_hash_common
)
1755 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
1756 else if (h
->root
.root
.type
== bfd_link_hash_defined
1757 || h
->root
.root
.type
== bfd_link_hash_defweak
)
1759 if (h
->esym
.asym
.sc
== scCommon
)
1760 h
->esym
.asym
.sc
= scBss
;
1761 else if (h
->esym
.asym
.sc
== scSCommon
)
1762 h
->esym
.asym
.sc
= scSBss
;
1764 sec
= h
->root
.root
.u
.def
.section
;
1765 output_section
= sec
->output_section
;
1766 if (output_section
!= NULL
)
1767 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
1768 + sec
->output_offset
1769 + output_section
->vma
);
1771 h
->esym
.asym
.value
= 0;
1773 else if (h
->root
.needs_plt
)
1775 struct mips_elf_link_hash_entry
*hd
= h
;
1776 bfd_boolean no_fn_stub
= h
->no_fn_stub
;
1778 while (hd
->root
.root
.type
== bfd_link_hash_indirect
)
1780 hd
= (struct mips_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
1781 no_fn_stub
= no_fn_stub
|| hd
->no_fn_stub
;
1786 /* Set type and value for a symbol with a function stub. */
1787 h
->esym
.asym
.st
= stProc
;
1788 sec
= hd
->root
.root
.u
.def
.section
;
1790 h
->esym
.asym
.value
= 0;
1793 output_section
= sec
->output_section
;
1794 if (output_section
!= NULL
)
1795 h
->esym
.asym
.value
= (hd
->root
.plt
.offset
1796 + sec
->output_offset
1797 + output_section
->vma
);
1799 h
->esym
.asym
.value
= 0;
1807 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
1808 h
->root
.root
.root
.string
,
1811 einfo
->failed
= TRUE
;
1818 /* A comparison routine used to sort .gptab entries. */
1821 gptab_compare (const void *p1
, const void *p2
)
1823 const Elf32_gptab
*a1
= p1
;
1824 const Elf32_gptab
*a2
= p2
;
1826 return a1
->gt_entry
.gt_g_value
- a2
->gt_entry
.gt_g_value
;
1829 /* Functions to manage the got entry hash table. */
1831 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
1834 static INLINE hashval_t
1835 mips_elf_hash_bfd_vma (bfd_vma addr
)
1838 return addr
+ (addr
>> 32);
1844 /* got_entries only match if they're identical, except for gotidx, so
1845 use all fields to compute the hash, and compare the appropriate
1849 mips_elf_got_entry_hash (const void *entry_
)
1851 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
1853 return entry
->symndx
1854 + (! entry
->abfd
? mips_elf_hash_bfd_vma (entry
->d
.address
)
1856 + (entry
->symndx
>= 0 ? mips_elf_hash_bfd_vma (entry
->d
.addend
)
1857 : entry
->d
.h
->root
.root
.root
.hash
));
1861 mips_elf_got_entry_eq (const void *entry1
, const void *entry2
)
1863 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
1864 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
1866 return e1
->abfd
== e2
->abfd
&& e1
->symndx
== e2
->symndx
1867 && (! e1
->abfd
? e1
->d
.address
== e2
->d
.address
1868 : e1
->symndx
>= 0 ? e1
->d
.addend
== e2
->d
.addend
1869 : e1
->d
.h
== e2
->d
.h
);
1872 /* multi_got_entries are still a match in the case of global objects,
1873 even if the input bfd in which they're referenced differs, so the
1874 hash computation and compare functions are adjusted
1878 mips_elf_multi_got_entry_hash (const void *entry_
)
1880 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
1882 return entry
->symndx
1884 ? mips_elf_hash_bfd_vma (entry
->d
.address
)
1885 : entry
->symndx
>= 0
1887 + mips_elf_hash_bfd_vma (entry
->d
.addend
))
1888 : entry
->d
.h
->root
.root
.root
.hash
);
1892 mips_elf_multi_got_entry_eq (const void *entry1
, const void *entry2
)
1894 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
1895 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
1897 return e1
->symndx
== e2
->symndx
1898 && (e1
->symndx
>= 0 ? e1
->abfd
== e2
->abfd
&& e1
->d
.addend
== e2
->d
.addend
1899 : e1
->abfd
== NULL
|| e2
->abfd
== NULL
1900 ? e1
->abfd
== e2
->abfd
&& e1
->d
.address
== e2
->d
.address
1901 : e1
->d
.h
== e2
->d
.h
);
1904 /* Returns the dynamic relocation section for DYNOBJ. */
1907 mips_elf_rel_dyn_section (bfd
*dynobj
, bfd_boolean create_p
)
1909 static const char dname
[] = ".rel.dyn";
1912 sreloc
= bfd_get_section_by_name (dynobj
, dname
);
1913 if (sreloc
== NULL
&& create_p
)
1915 sreloc
= bfd_make_section (dynobj
, dname
);
1917 || ! bfd_set_section_flags (dynobj
, sreloc
,
1922 | SEC_LINKER_CREATED
1924 || ! bfd_set_section_alignment (dynobj
, sreloc
,
1925 MIPS_ELF_LOG_FILE_ALIGN (dynobj
)))
1931 /* Returns the GOT section for ABFD. */
1934 mips_elf_got_section (bfd
*abfd
, bfd_boolean maybe_excluded
)
1936 asection
*sgot
= bfd_get_section_by_name (abfd
, ".got");
1938 || (! maybe_excluded
&& (sgot
->flags
& SEC_EXCLUDE
) != 0))
1943 /* Returns the GOT information associated with the link indicated by
1944 INFO. If SGOTP is non-NULL, it is filled in with the GOT
1947 static struct mips_got_info
*
1948 mips_elf_got_info (bfd
*abfd
, asection
**sgotp
)
1951 struct mips_got_info
*g
;
1953 sgot
= mips_elf_got_section (abfd
, TRUE
);
1954 BFD_ASSERT (sgot
!= NULL
);
1955 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
1956 g
= mips_elf_section_data (sgot
)->u
.got_info
;
1957 BFD_ASSERT (g
!= NULL
);
1960 *sgotp
= (sgot
->flags
& SEC_EXCLUDE
) == 0 ? sgot
: NULL
;
1965 /* Returns the GOT offset at which the indicated address can be found.
1966 If there is not yet a GOT entry for this value, create one. Returns
1967 -1 if no satisfactory GOT offset can be found. */
1970 mips_elf_local_got_index (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
1974 struct mips_got_info
*g
;
1975 struct mips_got_entry
*entry
;
1977 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1979 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
, value
);
1981 return entry
->gotidx
;
1986 /* Returns the GOT index for the global symbol indicated by H. */
1989 mips_elf_global_got_index (bfd
*abfd
, bfd
*ibfd
, struct elf_link_hash_entry
*h
)
1993 struct mips_got_info
*g
, *gg
;
1994 long global_got_dynindx
= 0;
1996 gg
= g
= mips_elf_got_info (abfd
, &sgot
);
1997 if (g
->bfd2got
&& ibfd
)
1999 struct mips_got_entry e
, *p
;
2001 BFD_ASSERT (h
->dynindx
>= 0);
2003 g
= mips_elf_got_for_ibfd (g
, ibfd
);
2008 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
2010 p
= htab_find (g
->got_entries
, &e
);
2012 BFD_ASSERT (p
->gotidx
> 0);
2017 if (gg
->global_gotsym
!= NULL
)
2018 global_got_dynindx
= gg
->global_gotsym
->dynindx
;
2020 /* Once we determine the global GOT entry with the lowest dynamic
2021 symbol table index, we must put all dynamic symbols with greater
2022 indices into the GOT. That makes it easy to calculate the GOT
2024 BFD_ASSERT (h
->dynindx
>= global_got_dynindx
);
2025 index
= ((h
->dynindx
- global_got_dynindx
+ g
->local_gotno
)
2026 * MIPS_ELF_GOT_SIZE (abfd
));
2027 BFD_ASSERT (index
< sgot
->size
);
2032 /* Find a GOT entry that is within 32KB of the VALUE. These entries
2033 are supposed to be placed at small offsets in the GOT, i.e.,
2034 within 32KB of GP. Return the index into the GOT for this page,
2035 and store the offset from this entry to the desired address in
2036 OFFSETP, if it is non-NULL. */
2039 mips_elf_got_page (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
2040 bfd_vma value
, bfd_vma
*offsetp
)
2043 struct mips_got_info
*g
;
2045 struct mips_got_entry
*entry
;
2047 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
2049 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
,
2051 & (~(bfd_vma
)0xffff));
2056 index
= entry
->gotidx
;
2059 *offsetp
= value
- entry
->d
.address
;
2064 /* Find a GOT entry whose higher-order 16 bits are the same as those
2065 for value. Return the index into the GOT for this entry. */
2068 mips_elf_got16_entry (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
2069 bfd_vma value
, bfd_boolean external
)
2072 struct mips_got_info
*g
;
2073 struct mips_got_entry
*entry
;
2077 /* Although the ABI says that it is "the high-order 16 bits" that we
2078 want, it is really the %high value. The complete value is
2079 calculated with a `addiu' of a LO16 relocation, just as with a
2081 value
= mips_elf_high (value
) << 16;
2084 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
2086 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
, value
);
2088 return entry
->gotidx
;
2093 /* Returns the offset for the entry at the INDEXth position
2097 mips_elf_got_offset_from_index (bfd
*dynobj
, bfd
*output_bfd
,
2098 bfd
*input_bfd
, bfd_vma index
)
2102 struct mips_got_info
*g
;
2104 g
= mips_elf_got_info (dynobj
, &sgot
);
2105 gp
= _bfd_get_gp_value (output_bfd
)
2106 + mips_elf_adjust_gp (output_bfd
, g
, input_bfd
);
2108 return sgot
->output_section
->vma
+ sgot
->output_offset
+ index
- gp
;
2111 /* Create a local GOT entry for VALUE. Return the index of the entry,
2112 or -1 if it could not be created. */
2114 static struct mips_got_entry
*
2115 mips_elf_create_local_got_entry (bfd
*abfd
, bfd
*ibfd
,
2116 struct mips_got_info
*gg
,
2117 asection
*sgot
, bfd_vma value
)
2119 struct mips_got_entry entry
, **loc
;
2120 struct mips_got_info
*g
;
2124 entry
.d
.address
= value
;
2126 g
= mips_elf_got_for_ibfd (gg
, ibfd
);
2129 g
= mips_elf_got_for_ibfd (gg
, abfd
);
2130 BFD_ASSERT (g
!= NULL
);
2133 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
2138 entry
.gotidx
= MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
++;
2140 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2145 memcpy (*loc
, &entry
, sizeof entry
);
2147 if (g
->assigned_gotno
>= g
->local_gotno
)
2149 (*loc
)->gotidx
= -1;
2150 /* We didn't allocate enough space in the GOT. */
2151 (*_bfd_error_handler
)
2152 (_("not enough GOT space for local GOT entries"));
2153 bfd_set_error (bfd_error_bad_value
);
2157 MIPS_ELF_PUT_WORD (abfd
, value
,
2158 (sgot
->contents
+ entry
.gotidx
));
2163 /* Sort the dynamic symbol table so that symbols that need GOT entries
2164 appear towards the end. This reduces the amount of GOT space
2165 required. MAX_LOCAL is used to set the number of local symbols
2166 known to be in the dynamic symbol table. During
2167 _bfd_mips_elf_size_dynamic_sections, this value is 1. Afterward, the
2168 section symbols are added and the count is higher. */
2171 mips_elf_sort_hash_table (struct bfd_link_info
*info
, unsigned long max_local
)
2173 struct mips_elf_hash_sort_data hsd
;
2174 struct mips_got_info
*g
;
2177 dynobj
= elf_hash_table (info
)->dynobj
;
2179 g
= mips_elf_got_info (dynobj
, NULL
);
2182 hsd
.max_unref_got_dynindx
=
2183 hsd
.min_got_dynindx
= elf_hash_table (info
)->dynsymcount
2184 /* In the multi-got case, assigned_gotno of the master got_info
2185 indicate the number of entries that aren't referenced in the
2186 primary GOT, but that must have entries because there are
2187 dynamic relocations that reference it. Since they aren't
2188 referenced, we move them to the end of the GOT, so that they
2189 don't prevent other entries that are referenced from getting
2190 too large offsets. */
2191 - (g
->next
? g
->assigned_gotno
: 0);
2192 hsd
.max_non_got_dynindx
= max_local
;
2193 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table
*)
2194 elf_hash_table (info
)),
2195 mips_elf_sort_hash_table_f
,
2198 /* There should have been enough room in the symbol table to
2199 accommodate both the GOT and non-GOT symbols. */
2200 BFD_ASSERT (hsd
.max_non_got_dynindx
<= hsd
.min_got_dynindx
);
2201 BFD_ASSERT ((unsigned long)hsd
.max_unref_got_dynindx
2202 <= elf_hash_table (info
)->dynsymcount
);
2204 /* Now we know which dynamic symbol has the lowest dynamic symbol
2205 table index in the GOT. */
2206 g
->global_gotsym
= hsd
.low
;
2211 /* If H needs a GOT entry, assign it the highest available dynamic
2212 index. Otherwise, assign it the lowest available dynamic
2216 mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry
*h
, void *data
)
2218 struct mips_elf_hash_sort_data
*hsd
= data
;
2220 if (h
->root
.root
.type
== bfd_link_hash_warning
)
2221 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2223 /* Symbols without dynamic symbol table entries aren't interesting
2225 if (h
->root
.dynindx
== -1)
2228 /* Global symbols that need GOT entries that are not explicitly
2229 referenced are marked with got offset 2. Those that are
2230 referenced get a 1, and those that don't need GOT entries get
2232 if (h
->root
.got
.offset
== 2)
2234 if (hsd
->max_unref_got_dynindx
== hsd
->min_got_dynindx
)
2235 hsd
->low
= (struct elf_link_hash_entry
*) h
;
2236 h
->root
.dynindx
= hsd
->max_unref_got_dynindx
++;
2238 else if (h
->root
.got
.offset
!= 1)
2239 h
->root
.dynindx
= hsd
->max_non_got_dynindx
++;
2242 h
->root
.dynindx
= --hsd
->min_got_dynindx
;
2243 hsd
->low
= (struct elf_link_hash_entry
*) h
;
2249 /* If H is a symbol that needs a global GOT entry, but has a dynamic
2250 symbol table index lower than any we've seen to date, record it for
2254 mips_elf_record_global_got_symbol (struct elf_link_hash_entry
*h
,
2255 bfd
*abfd
, struct bfd_link_info
*info
,
2256 struct mips_got_info
*g
)
2258 struct mips_got_entry entry
, **loc
;
2260 /* A global symbol in the GOT must also be in the dynamic symbol
2262 if (h
->dynindx
== -1)
2264 switch (ELF_ST_VISIBILITY (h
->other
))
2268 _bfd_mips_elf_hide_symbol (info
, h
, TRUE
);
2271 if (!bfd_elf_link_record_dynamic_symbol (info
, h
))
2277 entry
.d
.h
= (struct mips_elf_link_hash_entry
*) h
;
2279 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
2282 /* If we've already marked this entry as needing GOT space, we don't
2283 need to do it again. */
2287 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2293 memcpy (*loc
, &entry
, sizeof entry
);
2295 if (h
->got
.offset
!= MINUS_ONE
)
2298 /* By setting this to a value other than -1, we are indicating that
2299 there needs to be a GOT entry for H. Avoid using zero, as the
2300 generic ELF copy_indirect_symbol tests for <= 0. */
2306 /* Reserve space in G for a GOT entry containing the value of symbol
2307 SYMNDX in input bfd ABDF, plus ADDEND. */
2310 mips_elf_record_local_got_symbol (bfd
*abfd
, long symndx
, bfd_vma addend
,
2311 struct mips_got_info
*g
)
2313 struct mips_got_entry entry
, **loc
;
2316 entry
.symndx
= symndx
;
2317 entry
.d
.addend
= addend
;
2318 loc
= (struct mips_got_entry
**)
2319 htab_find_slot (g
->got_entries
, &entry
, INSERT
);
2324 entry
.gotidx
= g
->local_gotno
++;
2326 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2331 memcpy (*loc
, &entry
, sizeof entry
);
2336 /* Compute the hash value of the bfd in a bfd2got hash entry. */
2339 mips_elf_bfd2got_entry_hash (const void *entry_
)
2341 const struct mips_elf_bfd2got_hash
*entry
2342 = (struct mips_elf_bfd2got_hash
*)entry_
;
2344 return entry
->bfd
->id
;
2347 /* Check whether two hash entries have the same bfd. */
2350 mips_elf_bfd2got_entry_eq (const void *entry1
, const void *entry2
)
2352 const struct mips_elf_bfd2got_hash
*e1
2353 = (const struct mips_elf_bfd2got_hash
*)entry1
;
2354 const struct mips_elf_bfd2got_hash
*e2
2355 = (const struct mips_elf_bfd2got_hash
*)entry2
;
2357 return e1
->bfd
== e2
->bfd
;
2360 /* In a multi-got link, determine the GOT to be used for IBDF. G must
2361 be the master GOT data. */
2363 static struct mips_got_info
*
2364 mips_elf_got_for_ibfd (struct mips_got_info
*g
, bfd
*ibfd
)
2366 struct mips_elf_bfd2got_hash e
, *p
;
2372 p
= htab_find (g
->bfd2got
, &e
);
2373 return p
? p
->g
: NULL
;
2376 /* Create one separate got for each bfd that has entries in the global
2377 got, such that we can tell how many local and global entries each
2381 mips_elf_make_got_per_bfd (void **entryp
, void *p
)
2383 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2384 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
2385 htab_t bfd2got
= arg
->bfd2got
;
2386 struct mips_got_info
*g
;
2387 struct mips_elf_bfd2got_hash bfdgot_entry
, *bfdgot
;
2390 /* Find the got_info for this GOT entry's input bfd. Create one if
2392 bfdgot_entry
.bfd
= entry
->abfd
;
2393 bfdgotp
= htab_find_slot (bfd2got
, &bfdgot_entry
, INSERT
);
2394 bfdgot
= (struct mips_elf_bfd2got_hash
*)*bfdgotp
;
2400 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
2401 (arg
->obfd
, sizeof (struct mips_elf_bfd2got_hash
));
2411 bfdgot
->bfd
= entry
->abfd
;
2412 bfdgot
->g
= g
= (struct mips_got_info
*)
2413 bfd_alloc (arg
->obfd
, sizeof (struct mips_got_info
));
2420 g
->global_gotsym
= NULL
;
2421 g
->global_gotno
= 0;
2423 g
->assigned_gotno
= -1;
2424 g
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
2425 mips_elf_multi_got_entry_eq
, NULL
);
2426 if (g
->got_entries
== NULL
)
2436 /* Insert the GOT entry in the bfd's got entry hash table. */
2437 entryp
= htab_find_slot (g
->got_entries
, entry
, INSERT
);
2438 if (*entryp
!= NULL
)
2443 if (entry
->symndx
>= 0 || entry
->d
.h
->forced_local
)
2451 /* Attempt to merge gots of different input bfds. Try to use as much
2452 as possible of the primary got, since it doesn't require explicit
2453 dynamic relocations, but don't use bfds that would reference global
2454 symbols out of the addressable range. Failing the primary got,
2455 attempt to merge with the current got, or finish the current got
2456 and then make make the new got current. */
2459 mips_elf_merge_gots (void **bfd2got_
, void *p
)
2461 struct mips_elf_bfd2got_hash
*bfd2got
2462 = (struct mips_elf_bfd2got_hash
*)*bfd2got_
;
2463 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
2464 unsigned int lcount
= bfd2got
->g
->local_gotno
;
2465 unsigned int gcount
= bfd2got
->g
->global_gotno
;
2466 unsigned int maxcnt
= arg
->max_count
;
2468 /* If we don't have a primary GOT and this is not too big, use it as
2469 a starting point for the primary GOT. */
2470 if (! arg
->primary
&& lcount
+ gcount
<= maxcnt
)
2472 arg
->primary
= bfd2got
->g
;
2473 arg
->primary_count
= lcount
+ gcount
;
2475 /* If it looks like we can merge this bfd's entries with those of
2476 the primary, merge them. The heuristics is conservative, but we
2477 don't have to squeeze it too hard. */
2478 else if (arg
->primary
2479 && (arg
->primary_count
+ lcount
+ gcount
) <= maxcnt
)
2481 struct mips_got_info
*g
= bfd2got
->g
;
2482 int old_lcount
= arg
->primary
->local_gotno
;
2483 int old_gcount
= arg
->primary
->global_gotno
;
2485 bfd2got
->g
= arg
->primary
;
2487 htab_traverse (g
->got_entries
,
2488 mips_elf_make_got_per_bfd
,
2490 if (arg
->obfd
== NULL
)
2493 htab_delete (g
->got_entries
);
2494 /* We don't have to worry about releasing memory of the actual
2495 got entries, since they're all in the master got_entries hash
2498 BFD_ASSERT (old_lcount
+ lcount
>= arg
->primary
->local_gotno
);
2499 BFD_ASSERT (old_gcount
+ gcount
>= arg
->primary
->global_gotno
);
2501 arg
->primary_count
= arg
->primary
->local_gotno
2502 + arg
->primary
->global_gotno
;
2504 /* If we can merge with the last-created got, do it. */
2505 else if (arg
->current
2506 && arg
->current_count
+ lcount
+ gcount
<= maxcnt
)
2508 struct mips_got_info
*g
= bfd2got
->g
;
2509 int old_lcount
= arg
->current
->local_gotno
;
2510 int old_gcount
= arg
->current
->global_gotno
;
2512 bfd2got
->g
= arg
->current
;
2514 htab_traverse (g
->got_entries
,
2515 mips_elf_make_got_per_bfd
,
2517 if (arg
->obfd
== NULL
)
2520 htab_delete (g
->got_entries
);
2522 BFD_ASSERT (old_lcount
+ lcount
>= arg
->current
->local_gotno
);
2523 BFD_ASSERT (old_gcount
+ gcount
>= arg
->current
->global_gotno
);
2525 arg
->current_count
= arg
->current
->local_gotno
2526 + arg
->current
->global_gotno
;
2528 /* Well, we couldn't merge, so create a new GOT. Don't check if it
2529 fits; if it turns out that it doesn't, we'll get relocation
2530 overflows anyway. */
2533 bfd2got
->g
->next
= arg
->current
;
2534 arg
->current
= bfd2got
->g
;
2536 arg
->current_count
= lcount
+ gcount
;
2542 /* If passed a NULL mips_got_info in the argument, set the marker used
2543 to tell whether a global symbol needs a got entry (in the primary
2544 got) to the given VALUE.
2546 If passed a pointer G to a mips_got_info in the argument (it must
2547 not be the primary GOT), compute the offset from the beginning of
2548 the (primary) GOT section to the entry in G corresponding to the
2549 global symbol. G's assigned_gotno must contain the index of the
2550 first available global GOT entry in G. VALUE must contain the size
2551 of a GOT entry in bytes. For each global GOT entry that requires a
2552 dynamic relocation, NEEDED_RELOCS is incremented, and the symbol is
2553 marked as not eligible for lazy resolution through a function
2556 mips_elf_set_global_got_offset (void **entryp
, void *p
)
2558 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2559 struct mips_elf_set_global_got_offset_arg
*arg
2560 = (struct mips_elf_set_global_got_offset_arg
*)p
;
2561 struct mips_got_info
*g
= arg
->g
;
2563 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1
2564 && entry
->d
.h
->root
.dynindx
!= -1)
2568 BFD_ASSERT (g
->global_gotsym
== NULL
);
2570 entry
->gotidx
= arg
->value
* (long) g
->assigned_gotno
++;
2571 if (arg
->info
->shared
2572 || (elf_hash_table (arg
->info
)->dynamic_sections_created
2573 && entry
->d
.h
->root
.def_dynamic
2574 && !entry
->d
.h
->root
.def_regular
))
2575 ++arg
->needed_relocs
;
2578 entry
->d
.h
->root
.got
.offset
= arg
->value
;
2584 /* Mark any global symbols referenced in the GOT we are iterating over
2585 as inelligible for lazy resolution stubs. */
2587 mips_elf_set_no_stub (void **entryp
, void *p ATTRIBUTE_UNUSED
)
2589 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2591 if (entry
->abfd
!= NULL
2592 && entry
->symndx
== -1
2593 && entry
->d
.h
->root
.dynindx
!= -1)
2594 entry
->d
.h
->no_fn_stub
= TRUE
;
2599 /* Follow indirect and warning hash entries so that each got entry
2600 points to the final symbol definition. P must point to a pointer
2601 to the hash table we're traversing. Since this traversal may
2602 modify the hash table, we set this pointer to NULL to indicate
2603 we've made a potentially-destructive change to the hash table, so
2604 the traversal must be restarted. */
2606 mips_elf_resolve_final_got_entry (void **entryp
, void *p
)
2608 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2609 htab_t got_entries
= *(htab_t
*)p
;
2611 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1)
2613 struct mips_elf_link_hash_entry
*h
= entry
->d
.h
;
2615 while (h
->root
.root
.type
== bfd_link_hash_indirect
2616 || h
->root
.root
.type
== bfd_link_hash_warning
)
2617 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2619 if (entry
->d
.h
== h
)
2624 /* If we can't find this entry with the new bfd hash, re-insert
2625 it, and get the traversal restarted. */
2626 if (! htab_find (got_entries
, entry
))
2628 htab_clear_slot (got_entries
, entryp
);
2629 entryp
= htab_find_slot (got_entries
, entry
, INSERT
);
2632 /* Abort the traversal, since the whole table may have
2633 moved, and leave it up to the parent to restart the
2635 *(htab_t
*)p
= NULL
;
2638 /* We might want to decrement the global_gotno count, but it's
2639 either too early or too late for that at this point. */
2645 /* Turn indirect got entries in a got_entries table into their final
2648 mips_elf_resolve_final_got_entries (struct mips_got_info
*g
)
2654 got_entries
= g
->got_entries
;
2656 htab_traverse (got_entries
,
2657 mips_elf_resolve_final_got_entry
,
2660 while (got_entries
== NULL
);
2663 /* Return the offset of an input bfd IBFD's GOT from the beginning of
2666 mips_elf_adjust_gp (bfd
*abfd
, struct mips_got_info
*g
, bfd
*ibfd
)
2668 if (g
->bfd2got
== NULL
)
2671 g
= mips_elf_got_for_ibfd (g
, ibfd
);
2675 BFD_ASSERT (g
->next
);
2679 return (g
->local_gotno
+ g
->global_gotno
) * MIPS_ELF_GOT_SIZE (abfd
);
2682 /* Turn a single GOT that is too big for 16-bit addressing into
2683 a sequence of GOTs, each one 16-bit addressable. */
2686 mips_elf_multi_got (bfd
*abfd
, struct bfd_link_info
*info
,
2687 struct mips_got_info
*g
, asection
*got
,
2688 bfd_size_type pages
)
2690 struct mips_elf_got_per_bfd_arg got_per_bfd_arg
;
2691 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
2692 struct mips_got_info
*gg
;
2693 unsigned int assign
;
2695 g
->bfd2got
= htab_try_create (1, mips_elf_bfd2got_entry_hash
,
2696 mips_elf_bfd2got_entry_eq
, NULL
);
2697 if (g
->bfd2got
== NULL
)
2700 got_per_bfd_arg
.bfd2got
= g
->bfd2got
;
2701 got_per_bfd_arg
.obfd
= abfd
;
2702 got_per_bfd_arg
.info
= info
;
2704 /* Count how many GOT entries each input bfd requires, creating a
2705 map from bfd to got info while at that. */
2706 mips_elf_resolve_final_got_entries (g
);
2707 htab_traverse (g
->got_entries
, mips_elf_make_got_per_bfd
, &got_per_bfd_arg
);
2708 if (got_per_bfd_arg
.obfd
== NULL
)
2711 got_per_bfd_arg
.current
= NULL
;
2712 got_per_bfd_arg
.primary
= NULL
;
2713 /* Taking out PAGES entries is a worst-case estimate. We could
2714 compute the maximum number of pages that each separate input bfd
2715 uses, but it's probably not worth it. */
2716 got_per_bfd_arg
.max_count
= ((MIPS_ELF_GOT_MAX_SIZE (abfd
)
2717 / MIPS_ELF_GOT_SIZE (abfd
))
2718 - MIPS_RESERVED_GOTNO
- pages
);
2720 /* Try to merge the GOTs of input bfds together, as long as they
2721 don't seem to exceed the maximum GOT size, choosing one of them
2722 to be the primary GOT. */
2723 htab_traverse (g
->bfd2got
, mips_elf_merge_gots
, &got_per_bfd_arg
);
2724 if (got_per_bfd_arg
.obfd
== NULL
)
2727 /* If we find any suitable primary GOT, create an empty one. */
2728 if (got_per_bfd_arg
.primary
== NULL
)
2730 g
->next
= (struct mips_got_info
*)
2731 bfd_alloc (abfd
, sizeof (struct mips_got_info
));
2732 if (g
->next
== NULL
)
2735 g
->next
->global_gotsym
= NULL
;
2736 g
->next
->global_gotno
= 0;
2737 g
->next
->local_gotno
= 0;
2738 g
->next
->assigned_gotno
= 0;
2739 g
->next
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
2740 mips_elf_multi_got_entry_eq
,
2742 if (g
->next
->got_entries
== NULL
)
2744 g
->next
->bfd2got
= NULL
;
2747 g
->next
= got_per_bfd_arg
.primary
;
2748 g
->next
->next
= got_per_bfd_arg
.current
;
2750 /* GG is now the master GOT, and G is the primary GOT. */
2754 /* Map the output bfd to the primary got. That's what we're going
2755 to use for bfds that use GOT16 or GOT_PAGE relocations that we
2756 didn't mark in check_relocs, and we want a quick way to find it.
2757 We can't just use gg->next because we're going to reverse the
2760 struct mips_elf_bfd2got_hash
*bfdgot
;
2763 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
2764 (abfd
, sizeof (struct mips_elf_bfd2got_hash
));
2771 bfdgotp
= htab_find_slot (gg
->bfd2got
, bfdgot
, INSERT
);
2773 BFD_ASSERT (*bfdgotp
== NULL
);
2777 /* The IRIX dynamic linker requires every symbol that is referenced
2778 in a dynamic relocation to be present in the primary GOT, so
2779 arrange for them to appear after those that are actually
2782 GNU/Linux could very well do without it, but it would slow down
2783 the dynamic linker, since it would have to resolve every dynamic
2784 symbol referenced in other GOTs more than once, without help from
2785 the cache. Also, knowing that every external symbol has a GOT
2786 helps speed up the resolution of local symbols too, so GNU/Linux
2787 follows IRIX's practice.
2789 The number 2 is used by mips_elf_sort_hash_table_f to count
2790 global GOT symbols that are unreferenced in the primary GOT, with
2791 an initial dynamic index computed from gg->assigned_gotno, where
2792 the number of unreferenced global entries in the primary GOT is
2796 gg
->assigned_gotno
= gg
->global_gotno
- g
->global_gotno
;
2797 g
->global_gotno
= gg
->global_gotno
;
2798 set_got_offset_arg
.value
= 2;
2802 /* This could be used for dynamic linkers that don't optimize
2803 symbol resolution while applying relocations so as to use
2804 primary GOT entries or assuming the symbol is locally-defined.
2805 With this code, we assign lower dynamic indices to global
2806 symbols that are not referenced in the primary GOT, so that
2807 their entries can be omitted. */
2808 gg
->assigned_gotno
= 0;
2809 set_got_offset_arg
.value
= -1;
2812 /* Reorder dynamic symbols as described above (which behavior
2813 depends on the setting of VALUE). */
2814 set_got_offset_arg
.g
= NULL
;
2815 htab_traverse (gg
->got_entries
, mips_elf_set_global_got_offset
,
2816 &set_got_offset_arg
);
2817 set_got_offset_arg
.value
= 1;
2818 htab_traverse (g
->got_entries
, mips_elf_set_global_got_offset
,
2819 &set_got_offset_arg
);
2820 if (! mips_elf_sort_hash_table (info
, 1))
2823 /* Now go through the GOTs assigning them offset ranges.
2824 [assigned_gotno, local_gotno[ will be set to the range of local
2825 entries in each GOT. We can then compute the end of a GOT by
2826 adding local_gotno to global_gotno. We reverse the list and make
2827 it circular since then we'll be able to quickly compute the
2828 beginning of a GOT, by computing the end of its predecessor. To
2829 avoid special cases for the primary GOT, while still preserving
2830 assertions that are valid for both single- and multi-got links,
2831 we arrange for the main got struct to have the right number of
2832 global entries, but set its local_gotno such that the initial
2833 offset of the primary GOT is zero. Remember that the primary GOT
2834 will become the last item in the circular linked list, so it
2835 points back to the master GOT. */
2836 gg
->local_gotno
= -g
->global_gotno
;
2837 gg
->global_gotno
= g
->global_gotno
;
2843 struct mips_got_info
*gn
;
2845 assign
+= MIPS_RESERVED_GOTNO
;
2846 g
->assigned_gotno
= assign
;
2847 g
->local_gotno
+= assign
+ pages
;
2848 assign
= g
->local_gotno
+ g
->global_gotno
;
2850 /* Take g out of the direct list, and push it onto the reversed
2851 list that gg points to. */
2857 /* Mark global symbols in every non-primary GOT as ineligible for
2860 htab_traverse (g
->got_entries
, mips_elf_set_no_stub
, NULL
);
2864 got
->size
= (gg
->next
->local_gotno
2865 + gg
->next
->global_gotno
) * MIPS_ELF_GOT_SIZE (abfd
);
2871 /* Returns the first relocation of type r_type found, beginning with
2872 RELOCATION. RELEND is one-past-the-end of the relocation table. */
2874 static const Elf_Internal_Rela
*
2875 mips_elf_next_relocation (bfd
*abfd ATTRIBUTE_UNUSED
, unsigned int r_type
,
2876 const Elf_Internal_Rela
*relocation
,
2877 const Elf_Internal_Rela
*relend
)
2879 while (relocation
< relend
)
2881 if (ELF_R_TYPE (abfd
, relocation
->r_info
) == r_type
)
2887 /* We didn't find it. */
2888 bfd_set_error (bfd_error_bad_value
);
2892 /* Return whether a relocation is against a local symbol. */
2895 mips_elf_local_relocation_p (bfd
*input_bfd
,
2896 const Elf_Internal_Rela
*relocation
,
2897 asection
**local_sections
,
2898 bfd_boolean check_forced
)
2900 unsigned long r_symndx
;
2901 Elf_Internal_Shdr
*symtab_hdr
;
2902 struct mips_elf_link_hash_entry
*h
;
2905 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
2906 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2907 extsymoff
= (elf_bad_symtab (input_bfd
)) ? 0 : symtab_hdr
->sh_info
;
2909 if (r_symndx
< extsymoff
)
2911 if (elf_bad_symtab (input_bfd
) && local_sections
[r_symndx
] != NULL
)
2916 /* Look up the hash table to check whether the symbol
2917 was forced local. */
2918 h
= (struct mips_elf_link_hash_entry
*)
2919 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
];
2920 /* Find the real hash-table entry for this symbol. */
2921 while (h
->root
.root
.type
== bfd_link_hash_indirect
2922 || h
->root
.root
.type
== bfd_link_hash_warning
)
2923 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2924 if (h
->root
.forced_local
)
2931 /* Sign-extend VALUE, which has the indicated number of BITS. */
2934 _bfd_mips_elf_sign_extend (bfd_vma value
, int bits
)
2936 if (value
& ((bfd_vma
) 1 << (bits
- 1)))
2937 /* VALUE is negative. */
2938 value
|= ((bfd_vma
) - 1) << bits
;
2943 /* Return non-zero if the indicated VALUE has overflowed the maximum
2944 range expressible by a signed number with the indicated number of
2948 mips_elf_overflow_p (bfd_vma value
, int bits
)
2950 bfd_signed_vma svalue
= (bfd_signed_vma
) value
;
2952 if (svalue
> (1 << (bits
- 1)) - 1)
2953 /* The value is too big. */
2955 else if (svalue
< -(1 << (bits
- 1)))
2956 /* The value is too small. */
2963 /* Calculate the %high function. */
2966 mips_elf_high (bfd_vma value
)
2968 return ((value
+ (bfd_vma
) 0x8000) >> 16) & 0xffff;
2971 /* Calculate the %higher function. */
2974 mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED
)
2977 return ((value
+ (bfd_vma
) 0x80008000) >> 32) & 0xffff;
2984 /* Calculate the %highest function. */
2987 mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED
)
2990 return ((value
+ (((bfd_vma
) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
2997 /* Create the .compact_rel section. */
3000 mips_elf_create_compact_rel_section
3001 (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3004 register asection
*s
;
3006 if (bfd_get_section_by_name (abfd
, ".compact_rel") == NULL
)
3008 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
3011 s
= bfd_make_section (abfd
, ".compact_rel");
3013 || ! bfd_set_section_flags (abfd
, s
, flags
)
3014 || ! bfd_set_section_alignment (abfd
, s
,
3015 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
3018 s
->size
= sizeof (Elf32_External_compact_rel
);
3024 /* Create the .got section to hold the global offset table. */
3027 mips_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
,
3028 bfd_boolean maybe_exclude
)
3031 register asection
*s
;
3032 struct elf_link_hash_entry
*h
;
3033 struct bfd_link_hash_entry
*bh
;
3034 struct mips_got_info
*g
;
3037 /* This function may be called more than once. */
3038 s
= mips_elf_got_section (abfd
, TRUE
);
3041 if (! maybe_exclude
)
3042 s
->flags
&= ~SEC_EXCLUDE
;
3046 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3047 | SEC_LINKER_CREATED
);
3050 flags
|= SEC_EXCLUDE
;
3052 /* We have to use an alignment of 2**4 here because this is hardcoded
3053 in the function stub generation and in the linker script. */
3054 s
= bfd_make_section (abfd
, ".got");
3056 || ! bfd_set_section_flags (abfd
, s
, flags
)
3057 || ! bfd_set_section_alignment (abfd
, s
, 4))
3060 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
3061 linker script because we don't want to define the symbol if we
3062 are not creating a global offset table. */
3064 if (! (_bfd_generic_link_add_one_symbol
3065 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
3066 0, NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
3069 h
= (struct elf_link_hash_entry
*) bh
;
3072 h
->type
= STT_OBJECT
;
3075 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3078 amt
= sizeof (struct mips_got_info
);
3079 g
= bfd_alloc (abfd
, amt
);
3082 g
->global_gotsym
= NULL
;
3083 g
->global_gotno
= 0;
3084 g
->local_gotno
= MIPS_RESERVED_GOTNO
;
3085 g
->assigned_gotno
= MIPS_RESERVED_GOTNO
;
3088 g
->got_entries
= htab_try_create (1, mips_elf_got_entry_hash
,
3089 mips_elf_got_entry_eq
, NULL
);
3090 if (g
->got_entries
== NULL
)
3092 mips_elf_section_data (s
)->u
.got_info
= g
;
3093 mips_elf_section_data (s
)->elf
.this_hdr
.sh_flags
3094 |= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
3099 /* Calculate the value produced by the RELOCATION (which comes from
3100 the INPUT_BFD). The ADDEND is the addend to use for this
3101 RELOCATION; RELOCATION->R_ADDEND is ignored.
3103 The result of the relocation calculation is stored in VALUEP.
3104 REQUIRE_JALXP indicates whether or not the opcode used with this
3105 relocation must be JALX.
3107 This function returns bfd_reloc_continue if the caller need take no
3108 further action regarding this relocation, bfd_reloc_notsupported if
3109 something goes dramatically wrong, bfd_reloc_overflow if an
3110 overflow occurs, and bfd_reloc_ok to indicate success. */
3112 static bfd_reloc_status_type
3113 mips_elf_calculate_relocation (bfd
*abfd
, bfd
*input_bfd
,
3114 asection
*input_section
,
3115 struct bfd_link_info
*info
,
3116 const Elf_Internal_Rela
*relocation
,
3117 bfd_vma addend
, reloc_howto_type
*howto
,
3118 Elf_Internal_Sym
*local_syms
,
3119 asection
**local_sections
, bfd_vma
*valuep
,
3120 const char **namep
, bfd_boolean
*require_jalxp
,
3121 bfd_boolean save_addend
)
3123 /* The eventual value we will return. */
3125 /* The address of the symbol against which the relocation is
3128 /* The final GP value to be used for the relocatable, executable, or
3129 shared object file being produced. */
3130 bfd_vma gp
= MINUS_ONE
;
3131 /* The place (section offset or address) of the storage unit being
3134 /* The value of GP used to create the relocatable object. */
3135 bfd_vma gp0
= MINUS_ONE
;
3136 /* The offset into the global offset table at which the address of
3137 the relocation entry symbol, adjusted by the addend, resides
3138 during execution. */
3139 bfd_vma g
= MINUS_ONE
;
3140 /* The section in which the symbol referenced by the relocation is
3142 asection
*sec
= NULL
;
3143 struct mips_elf_link_hash_entry
*h
= NULL
;
3144 /* TRUE if the symbol referred to by this relocation is a local
3146 bfd_boolean local_p
, was_local_p
;
3147 /* TRUE if the symbol referred to by this relocation is "_gp_disp". */
3148 bfd_boolean gp_disp_p
= FALSE
;
3149 Elf_Internal_Shdr
*symtab_hdr
;
3151 unsigned long r_symndx
;
3153 /* TRUE if overflow occurred during the calculation of the
3154 relocation value. */
3155 bfd_boolean overflowed_p
;
3156 /* TRUE if this relocation refers to a MIPS16 function. */
3157 bfd_boolean target_is_16_bit_code_p
= FALSE
;
3159 /* Parse the relocation. */
3160 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
3161 r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
3162 p
= (input_section
->output_section
->vma
3163 + input_section
->output_offset
3164 + relocation
->r_offset
);
3166 /* Assume that there will be no overflow. */
3167 overflowed_p
= FALSE
;
3169 /* Figure out whether or not the symbol is local, and get the offset
3170 used in the array of hash table entries. */
3171 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3172 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
3173 local_sections
, FALSE
);
3174 was_local_p
= local_p
;
3175 if (! elf_bad_symtab (input_bfd
))
3176 extsymoff
= symtab_hdr
->sh_info
;
3179 /* The symbol table does not follow the rule that local symbols
3180 must come before globals. */
3184 /* Figure out the value of the symbol. */
3187 Elf_Internal_Sym
*sym
;
3189 sym
= local_syms
+ r_symndx
;
3190 sec
= local_sections
[r_symndx
];
3192 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3193 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
3194 || (sec
->flags
& SEC_MERGE
))
3195 symbol
+= sym
->st_value
;
3196 if ((sec
->flags
& SEC_MERGE
)
3197 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3199 addend
= _bfd_elf_rel_local_sym (abfd
, sym
, &sec
, addend
);
3201 addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
3204 /* MIPS16 text labels should be treated as odd. */
3205 if (sym
->st_other
== STO_MIPS16
)
3208 /* Record the name of this symbol, for our caller. */
3209 *namep
= bfd_elf_string_from_elf_section (input_bfd
,
3210 symtab_hdr
->sh_link
,
3213 *namep
= bfd_section_name (input_bfd
, sec
);
3215 target_is_16_bit_code_p
= (sym
->st_other
== STO_MIPS16
);
3219 /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ? */
3221 /* For global symbols we look up the symbol in the hash-table. */
3222 h
= ((struct mips_elf_link_hash_entry
*)
3223 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
]);
3224 /* Find the real hash-table entry for this symbol. */
3225 while (h
->root
.root
.type
== bfd_link_hash_indirect
3226 || h
->root
.root
.type
== bfd_link_hash_warning
)
3227 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3229 /* Record the name of this symbol, for our caller. */
3230 *namep
= h
->root
.root
.root
.string
;
3232 /* See if this is the special _gp_disp symbol. Note that such a
3233 symbol must always be a global symbol. */
3234 if (strcmp (*namep
, "_gp_disp") == 0
3235 && ! NEWABI_P (input_bfd
))
3237 /* Relocations against _gp_disp are permitted only with
3238 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
3239 if (r_type
!= R_MIPS_HI16
&& r_type
!= R_MIPS_LO16
3240 && r_type
!= R_MIPS16_HI16
&& r_type
!= R_MIPS16_LO16
)
3241 return bfd_reloc_notsupported
;
3245 /* If this symbol is defined, calculate its address. Note that
3246 _gp_disp is a magic symbol, always implicitly defined by the
3247 linker, so it's inappropriate to check to see whether or not
3249 else if ((h
->root
.root
.type
== bfd_link_hash_defined
3250 || h
->root
.root
.type
== bfd_link_hash_defweak
)
3251 && h
->root
.root
.u
.def
.section
)
3253 sec
= h
->root
.root
.u
.def
.section
;
3254 if (sec
->output_section
)
3255 symbol
= (h
->root
.root
.u
.def
.value
3256 + sec
->output_section
->vma
3257 + sec
->output_offset
);
3259 symbol
= h
->root
.root
.u
.def
.value
;
3261 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
3262 /* We allow relocations against undefined weak symbols, giving
3263 it the value zero, so that you can undefined weak functions
3264 and check to see if they exist by looking at their
3267 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
3268 && ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
3270 else if (strcmp (*namep
, SGI_COMPAT (input_bfd
)
3271 ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING") == 0)
3273 /* If this is a dynamic link, we should have created a
3274 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
3275 in in _bfd_mips_elf_create_dynamic_sections.
3276 Otherwise, we should define the symbol with a value of 0.
3277 FIXME: It should probably get into the symbol table
3279 BFD_ASSERT (! info
->shared
);
3280 BFD_ASSERT (bfd_get_section_by_name (abfd
, ".dynamic") == NULL
);
3285 if (! ((*info
->callbacks
->undefined_symbol
)
3286 (info
, h
->root
.root
.root
.string
, input_bfd
,
3287 input_section
, relocation
->r_offset
,
3288 (info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
)
3289 || ELF_ST_VISIBILITY (h
->root
.other
))))
3290 return bfd_reloc_undefined
;
3294 target_is_16_bit_code_p
= (h
->root
.other
== STO_MIPS16
);
3297 /* If this is a 32- or 64-bit call to a 16-bit function with a stub, we
3298 need to redirect the call to the stub, unless we're already *in*
3300 if (r_type
!= R_MIPS16_26
&& !info
->relocatable
3301 && ((h
!= NULL
&& h
->fn_stub
!= NULL
)
3302 || (local_p
&& elf_tdata (input_bfd
)->local_stubs
!= NULL
3303 && elf_tdata (input_bfd
)->local_stubs
[r_symndx
] != NULL
))
3304 && !mips_elf_stub_section_p (input_bfd
, input_section
))
3306 /* This is a 32- or 64-bit call to a 16-bit function. We should
3307 have already noticed that we were going to need the
3310 sec
= elf_tdata (input_bfd
)->local_stubs
[r_symndx
];
3313 BFD_ASSERT (h
->need_fn_stub
);
3317 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3319 /* If this is a 16-bit call to a 32- or 64-bit function with a stub, we
3320 need to redirect the call to the stub. */
3321 else if (r_type
== R_MIPS16_26
&& !info
->relocatable
3323 && (h
->call_stub
!= NULL
|| h
->call_fp_stub
!= NULL
)
3324 && !target_is_16_bit_code_p
)
3326 /* If both call_stub and call_fp_stub are defined, we can figure
3327 out which one to use by seeing which one appears in the input
3329 if (h
->call_stub
!= NULL
&& h
->call_fp_stub
!= NULL
)
3334 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
3336 if (strncmp (bfd_get_section_name (input_bfd
, o
),
3337 CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
3339 sec
= h
->call_fp_stub
;
3346 else if (h
->call_stub
!= NULL
)
3349 sec
= h
->call_fp_stub
;
3351 BFD_ASSERT (sec
->size
> 0);
3352 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3355 /* Calls from 16-bit code to 32-bit code and vice versa require the
3356 special jalx instruction. */
3357 *require_jalxp
= (!info
->relocatable
3358 && (((r_type
== R_MIPS16_26
) && !target_is_16_bit_code_p
)
3359 || ((r_type
== R_MIPS_26
) && target_is_16_bit_code_p
)));
3361 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
3362 local_sections
, TRUE
);
3364 /* If we haven't already determined the GOT offset, or the GP value,
3365 and we're going to need it, get it now. */
3368 case R_MIPS_GOT_PAGE
:
3369 case R_MIPS_GOT_OFST
:
3370 /* We need to decay to GOT_DISP/addend if the symbol doesn't
3372 local_p
= local_p
|| _bfd_elf_symbol_refs_local_p (&h
->root
, info
, 1);
3373 if (local_p
|| r_type
== R_MIPS_GOT_OFST
)
3379 case R_MIPS_GOT_DISP
:
3380 case R_MIPS_GOT_HI16
:
3381 case R_MIPS_CALL_HI16
:
3382 case R_MIPS_GOT_LO16
:
3383 case R_MIPS_CALL_LO16
:
3384 /* Find the index into the GOT where this value is located. */
3387 /* GOT_PAGE may take a non-zero addend, that is ignored in a
3388 GOT_PAGE relocation that decays to GOT_DISP because the
3389 symbol turns out to be global. The addend is then added
3391 BFD_ASSERT (addend
== 0 || r_type
== R_MIPS_GOT_PAGE
);
3392 g
= mips_elf_global_got_index (elf_hash_table (info
)->dynobj
,
3394 (struct elf_link_hash_entry
*) h
);
3395 if (! elf_hash_table(info
)->dynamic_sections_created
3397 && (info
->symbolic
|| h
->root
.dynindx
== -1)
3398 && h
->root
.def_regular
))
3400 /* This is a static link or a -Bsymbolic link. The
3401 symbol is defined locally, or was forced to be local.
3402 We must initialize this entry in the GOT. */
3403 bfd
*tmpbfd
= elf_hash_table (info
)->dynobj
;
3404 asection
*sgot
= mips_elf_got_section (tmpbfd
, FALSE
);
3405 MIPS_ELF_PUT_WORD (tmpbfd
, symbol
, sgot
->contents
+ g
);
3408 else if (r_type
== R_MIPS_GOT16
|| r_type
== R_MIPS_CALL16
)
3409 /* There's no need to create a local GOT entry here; the
3410 calculation for a local GOT16 entry does not involve G. */
3414 g
= mips_elf_local_got_index (abfd
, input_bfd
,
3415 info
, symbol
+ addend
);
3417 return bfd_reloc_outofrange
;
3420 /* Convert GOT indices to actual offsets. */
3421 g
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3422 abfd
, input_bfd
, g
);
3427 case R_MIPS_GPREL16
:
3428 case R_MIPS_GPREL32
:
3429 case R_MIPS_LITERAL
:
3432 case R_MIPS16_GPREL
:
3433 gp0
= _bfd_get_gp_value (input_bfd
);
3434 gp
= _bfd_get_gp_value (abfd
);
3435 if (elf_hash_table (info
)->dynobj
)
3436 gp
+= mips_elf_adjust_gp (abfd
,
3438 (elf_hash_table (info
)->dynobj
, NULL
),
3446 /* Figure out what kind of relocation is being performed. */
3450 return bfd_reloc_continue
;
3453 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 16);
3454 overflowed_p
= mips_elf_overflow_p (value
, 16);
3461 || (elf_hash_table (info
)->dynamic_sections_created
3463 && h
->root
.def_dynamic
3464 && !h
->root
.def_regular
))
3466 && (input_section
->flags
& SEC_ALLOC
) != 0)
3468 /* If we're creating a shared library, or this relocation is
3469 against a symbol in a shared library, then we can't know
3470 where the symbol will end up. So, we create a relocation
3471 record in the output, and leave the job up to the dynamic
3474 if (!mips_elf_create_dynamic_relocation (abfd
,
3482 return bfd_reloc_undefined
;
3486 if (r_type
!= R_MIPS_REL32
)
3487 value
= symbol
+ addend
;
3491 value
&= howto
->dst_mask
;
3495 value
= symbol
+ addend
- p
;
3496 value
&= howto
->dst_mask
;
3499 case R_MIPS_GNU_REL16_S2
:
3500 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 18) - p
;
3501 overflowed_p
= mips_elf_overflow_p (value
, 18);
3502 value
= (value
>> 2) & howto
->dst_mask
;
3506 /* The calculation for R_MIPS16_26 is just the same as for an
3507 R_MIPS_26. It's only the storage of the relocated field into
3508 the output file that's different. That's handled in
3509 mips_elf_perform_relocation. So, we just fall through to the
3510 R_MIPS_26 case here. */
3513 value
= ((addend
| ((p
+ 4) & 0xf0000000)) + symbol
) >> 2;
3516 value
= (_bfd_mips_elf_sign_extend (addend
, 28) + symbol
) >> 2;
3517 if (h
->root
.root
.type
!= bfd_link_hash_undefweak
)
3518 overflowed_p
= (value
>> 26) != ((p
+ 4) >> 28);
3520 value
&= howto
->dst_mask
;
3527 value
= mips_elf_high (addend
+ symbol
);
3528 value
&= howto
->dst_mask
;
3532 /* For MIPS16 ABI code we generate this sequence
3533 0: li $v0,%hi(_gp_disp)
3534 4: addiupc $v1,%lo(_gp_disp)
3538 So the offsets of hi and lo relocs are the same, but the
3539 $pc is four higher than $t9 would be, so reduce
3540 both reloc addends by 4. */
3541 if (r_type
== R_MIPS16_HI16
)
3542 value
= mips_elf_high (addend
+ gp
- p
- 4);
3544 value
= mips_elf_high (addend
+ gp
- p
);
3545 overflowed_p
= mips_elf_overflow_p (value
, 16);
3552 value
= (symbol
+ addend
) & howto
->dst_mask
;
3555 /* See the comment for R_MIPS16_HI16 above for the reason
3556 for this conditional. */
3557 if (r_type
== R_MIPS16_LO16
)
3558 value
= addend
+ gp
- p
;
3560 value
= addend
+ gp
- p
+ 4;
3561 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
3562 for overflow. But, on, say, IRIX5, relocations against
3563 _gp_disp are normally generated from the .cpload
3564 pseudo-op. It generates code that normally looks like
3567 lui $gp,%hi(_gp_disp)
3568 addiu $gp,$gp,%lo(_gp_disp)
3571 Here $t9 holds the address of the function being called,
3572 as required by the MIPS ELF ABI. The R_MIPS_LO16
3573 relocation can easily overflow in this situation, but the
3574 R_MIPS_HI16 relocation will handle the overflow.
3575 Therefore, we consider this a bug in the MIPS ABI, and do
3576 not check for overflow here. */
3580 case R_MIPS_LITERAL
:
3581 /* Because we don't merge literal sections, we can handle this
3582 just like R_MIPS_GPREL16. In the long run, we should merge
3583 shared literals, and then we will need to additional work
3588 case R_MIPS16_GPREL
:
3589 /* The R_MIPS16_GPREL performs the same calculation as
3590 R_MIPS_GPREL16, but stores the relocated bits in a different
3591 order. We don't need to do anything special here; the
3592 differences are handled in mips_elf_perform_relocation. */
3593 case R_MIPS_GPREL16
:
3594 /* Only sign-extend the addend if it was extracted from the
3595 instruction. If the addend was separate, leave it alone,
3596 otherwise we may lose significant bits. */
3597 if (howto
->partial_inplace
)
3598 addend
= _bfd_mips_elf_sign_extend (addend
, 16);
3599 value
= symbol
+ addend
- gp
;
3600 /* If the symbol was local, any earlier relocatable links will
3601 have adjusted its addend with the gp offset, so compensate
3602 for that now. Don't do it for symbols forced local in this
3603 link, though, since they won't have had the gp offset applied
3607 overflowed_p
= mips_elf_overflow_p (value
, 16);
3616 /* The special case is when the symbol is forced to be local. We
3617 need the full address in the GOT since no R_MIPS_LO16 relocation
3619 forced
= ! mips_elf_local_relocation_p (input_bfd
, relocation
,
3620 local_sections
, FALSE
);
3621 value
= mips_elf_got16_entry (abfd
, input_bfd
, info
,
3622 symbol
+ addend
, forced
);
3623 if (value
== MINUS_ONE
)
3624 return bfd_reloc_outofrange
;
3626 = mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3627 abfd
, input_bfd
, value
);
3628 overflowed_p
= mips_elf_overflow_p (value
, 16);
3634 case R_MIPS_GOT_DISP
:
3637 overflowed_p
= mips_elf_overflow_p (value
, 16);
3640 case R_MIPS_GPREL32
:
3641 value
= (addend
+ symbol
+ gp0
- gp
);
3643 value
&= howto
->dst_mask
;
3647 value
= _bfd_mips_elf_sign_extend (addend
, 16) + symbol
- p
;
3648 overflowed_p
= mips_elf_overflow_p (value
, 16);
3651 case R_MIPS_GOT_HI16
:
3652 case R_MIPS_CALL_HI16
:
3653 /* We're allowed to handle these two relocations identically.
3654 The dynamic linker is allowed to handle the CALL relocations
3655 differently by creating a lazy evaluation stub. */
3657 value
= mips_elf_high (value
);
3658 value
&= howto
->dst_mask
;
3661 case R_MIPS_GOT_LO16
:
3662 case R_MIPS_CALL_LO16
:
3663 value
= g
& howto
->dst_mask
;
3666 case R_MIPS_GOT_PAGE
:
3667 /* GOT_PAGE relocations that reference non-local symbols decay
3668 to GOT_DISP. The corresponding GOT_OFST relocation decays to
3672 value
= mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, NULL
);
3673 if (value
== MINUS_ONE
)
3674 return bfd_reloc_outofrange
;
3675 value
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3676 abfd
, input_bfd
, value
);
3677 overflowed_p
= mips_elf_overflow_p (value
, 16);
3680 case R_MIPS_GOT_OFST
:
3682 mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, &value
);
3685 overflowed_p
= mips_elf_overflow_p (value
, 16);
3689 value
= symbol
- addend
;
3690 value
&= howto
->dst_mask
;
3694 value
= mips_elf_higher (addend
+ symbol
);
3695 value
&= howto
->dst_mask
;
3698 case R_MIPS_HIGHEST
:
3699 value
= mips_elf_highest (addend
+ symbol
);
3700 value
&= howto
->dst_mask
;
3703 case R_MIPS_SCN_DISP
:
3704 value
= symbol
+ addend
- sec
->output_offset
;
3705 value
&= howto
->dst_mask
;
3709 /* This relocation is only a hint. In some cases, we optimize
3710 it into a bal instruction. But we don't try to optimize
3711 branches to the PLT; that will wind up wasting time. */
3712 if (h
!= NULL
&& h
->root
.plt
.offset
!= (bfd_vma
) -1)
3713 return bfd_reloc_continue
;
3714 value
= symbol
+ addend
;
3718 case R_MIPS_GNU_VTINHERIT
:
3719 case R_MIPS_GNU_VTENTRY
:
3720 /* We don't do anything with these at present. */
3721 return bfd_reloc_continue
;
3724 /* An unrecognized relocation type. */
3725 return bfd_reloc_notsupported
;
3728 /* Store the VALUE for our caller. */
3730 return overflowed_p
? bfd_reloc_overflow
: bfd_reloc_ok
;
3733 /* Obtain the field relocated by RELOCATION. */
3736 mips_elf_obtain_contents (reloc_howto_type
*howto
,
3737 const Elf_Internal_Rela
*relocation
,
3738 bfd
*input_bfd
, bfd_byte
*contents
)
3741 bfd_byte
*location
= contents
+ relocation
->r_offset
;
3743 /* Obtain the bytes. */
3744 x
= bfd_get ((8 * bfd_get_reloc_size (howto
)), input_bfd
, location
);
3749 /* It has been determined that the result of the RELOCATION is the
3750 VALUE. Use HOWTO to place VALUE into the output file at the
3751 appropriate position. The SECTION is the section to which the
3752 relocation applies. If REQUIRE_JALX is TRUE, then the opcode used
3753 for the relocation must be either JAL or JALX, and it is
3754 unconditionally converted to JALX.
3756 Returns FALSE if anything goes wrong. */
3759 mips_elf_perform_relocation (struct bfd_link_info
*info
,
3760 reloc_howto_type
*howto
,
3761 const Elf_Internal_Rela
*relocation
,
3762 bfd_vma value
, bfd
*input_bfd
,
3763 asection
*input_section
, bfd_byte
*contents
,
3764 bfd_boolean require_jalx
)
3768 int r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
3770 /* Figure out where the relocation is occurring. */
3771 location
= contents
+ relocation
->r_offset
;
3773 _bfd_mips16_elf_reloc_unshuffle (input_bfd
, r_type
, FALSE
, location
);
3775 /* Obtain the current value. */
3776 x
= mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
);
3778 /* Clear the field we are setting. */
3779 x
&= ~howto
->dst_mask
;
3781 /* Set the field. */
3782 x
|= (value
& howto
->dst_mask
);
3784 /* If required, turn JAL into JALX. */
3788 bfd_vma opcode
= x
>> 26;
3789 bfd_vma jalx_opcode
;
3791 /* Check to see if the opcode is already JAL or JALX. */
3792 if (r_type
== R_MIPS16_26
)
3794 ok
= ((opcode
== 0x6) || (opcode
== 0x7));
3799 ok
= ((opcode
== 0x3) || (opcode
== 0x1d));
3803 /* If the opcode is not JAL or JALX, there's a problem. */
3806 (*_bfd_error_handler
)
3807 (_("%B: %A+0x%lx: jump to stub routine which is not jal"),
3810 (unsigned long) relocation
->r_offset
);
3811 bfd_set_error (bfd_error_bad_value
);
3815 /* Make this the JALX opcode. */
3816 x
= (x
& ~(0x3f << 26)) | (jalx_opcode
<< 26);
3819 /* On the RM9000, bal is faster than jal, because bal uses branch
3820 prediction hardware. If we are linking for the RM9000, and we
3821 see jal, and bal fits, use it instead. Note that this
3822 transformation should be safe for all architectures. */
3823 if (bfd_get_mach (input_bfd
) == bfd_mach_mips9000
3824 && !info
->relocatable
3826 && ((r_type
== R_MIPS_26
&& (x
>> 26) == 0x3) /* jal addr */
3827 || (r_type
== R_MIPS_JALR
&& x
== 0x0320f809))) /* jalr t9 */
3833 addr
= (input_section
->output_section
->vma
3834 + input_section
->output_offset
3835 + relocation
->r_offset
3837 if (r_type
== R_MIPS_26
)
3838 dest
= (value
<< 2) | ((addr
>> 28) << 28);
3842 if (off
<= 0x1ffff && off
>= -0x20000)
3843 x
= 0x04110000 | (((bfd_vma
) off
>> 2) & 0xffff); /* bal addr */
3846 /* Put the value into the output. */
3847 bfd_put (8 * bfd_get_reloc_size (howto
), input_bfd
, x
, location
);
3849 _bfd_mips16_elf_reloc_shuffle(input_bfd
, r_type
, !info
->relocatable
,
3855 /* Returns TRUE if SECTION is a MIPS16 stub section. */
3858 mips_elf_stub_section_p (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*section
)
3860 const char *name
= bfd_get_section_name (abfd
, section
);
3862 return (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0
3863 || strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
3864 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0);
3867 /* Add room for N relocations to the .rel.dyn section in ABFD. */
3870 mips_elf_allocate_dynamic_relocations (bfd
*abfd
, unsigned int n
)
3874 s
= mips_elf_rel_dyn_section (abfd
, FALSE
);
3875 BFD_ASSERT (s
!= NULL
);
3879 /* Make room for a null element. */
3880 s
->size
+= MIPS_ELF_REL_SIZE (abfd
);
3883 s
->size
+= n
* MIPS_ELF_REL_SIZE (abfd
);
3886 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
3887 is the original relocation, which is now being transformed into a
3888 dynamic relocation. The ADDENDP is adjusted if necessary; the
3889 caller should store the result in place of the original addend. */
3892 mips_elf_create_dynamic_relocation (bfd
*output_bfd
,
3893 struct bfd_link_info
*info
,
3894 const Elf_Internal_Rela
*rel
,
3895 struct mips_elf_link_hash_entry
*h
,
3896 asection
*sec
, bfd_vma symbol
,
3897 bfd_vma
*addendp
, asection
*input_section
)
3899 Elf_Internal_Rela outrel
[3];
3904 bfd_boolean defined_p
;
3906 r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
3907 dynobj
= elf_hash_table (info
)->dynobj
;
3908 sreloc
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
3909 BFD_ASSERT (sreloc
!= NULL
);
3910 BFD_ASSERT (sreloc
->contents
!= NULL
);
3911 BFD_ASSERT (sreloc
->reloc_count
* MIPS_ELF_REL_SIZE (output_bfd
)
3914 outrel
[0].r_offset
=
3915 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[0].r_offset
);
3916 outrel
[1].r_offset
=
3917 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[1].r_offset
);
3918 outrel
[2].r_offset
=
3919 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[2].r_offset
);
3922 /* We begin by assuming that the offset for the dynamic relocation
3923 is the same as for the original relocation. We'll adjust this
3924 later to reflect the correct output offsets. */
3925 if (input_section
->sec_info_type
!= ELF_INFO_TYPE_STABS
)
3927 outrel
[1].r_offset
= rel
[1].r_offset
;
3928 outrel
[2].r_offset
= rel
[2].r_offset
;
3932 /* Except that in a stab section things are more complex.
3933 Because we compress stab information, the offset given in the
3934 relocation may not be the one we want; we must let the stabs
3935 machinery tell us the offset. */
3936 outrel
[1].r_offset
= outrel
[0].r_offset
;
3937 outrel
[2].r_offset
= outrel
[0].r_offset
;
3938 /* If we didn't need the relocation at all, this value will be
3940 if (outrel
[0].r_offset
== MINUS_ONE
)
3945 if (outrel
[0].r_offset
== MINUS_ONE
)
3946 /* The relocation field has been deleted. */
3949 if (outrel
[0].r_offset
== MINUS_TWO
)
3951 /* The relocation field has been converted into a relative value of
3952 some sort. Functions like _bfd_elf_write_section_eh_frame expect
3953 the field to be fully relocated, so add in the symbol's value. */
3958 /* We must now calculate the dynamic symbol table index to use
3959 in the relocation. */
3961 && (! info
->symbolic
|| !h
->root
.def_regular
)
3962 /* h->root.dynindx may be -1 if this symbol was marked to
3964 && h
->root
.dynindx
!= -1)
3966 indx
= h
->root
.dynindx
;
3967 if (SGI_COMPAT (output_bfd
))
3968 defined_p
= h
->root
.def_regular
;
3970 /* ??? glibc's ld.so just adds the final GOT entry to the
3971 relocation field. It therefore treats relocs against
3972 defined symbols in the same way as relocs against
3973 undefined symbols. */
3978 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
3980 else if (sec
== NULL
|| sec
->owner
== NULL
)
3982 bfd_set_error (bfd_error_bad_value
);
3987 indx
= elf_section_data (sec
->output_section
)->dynindx
;
3992 /* Instead of generating a relocation using the section
3993 symbol, we may as well make it a fully relative
3994 relocation. We want to avoid generating relocations to
3995 local symbols because we used to generate them
3996 incorrectly, without adding the original symbol value,
3997 which is mandated by the ABI for section symbols. In
3998 order to give dynamic loaders and applications time to
3999 phase out the incorrect use, we refrain from emitting
4000 section-relative relocations. It's not like they're
4001 useful, after all. This should be a bit more efficient
4003 /* ??? Although this behavior is compatible with glibc's ld.so,
4004 the ABI says that relocations against STN_UNDEF should have
4005 a symbol value of 0. Irix rld honors this, so relocations
4006 against STN_UNDEF have no effect. */
4007 if (!SGI_COMPAT (output_bfd
))
4012 /* If the relocation was previously an absolute relocation and
4013 this symbol will not be referred to by the relocation, we must
4014 adjust it by the value we give it in the dynamic symbol table.
4015 Otherwise leave the job up to the dynamic linker. */
4016 if (defined_p
&& r_type
!= R_MIPS_REL32
)
4019 /* The relocation is always an REL32 relocation because we don't
4020 know where the shared library will wind up at load-time. */
4021 outrel
[0].r_info
= ELF_R_INFO (output_bfd
, (unsigned long) indx
,
4023 /* For strict adherence to the ABI specification, we should
4024 generate a R_MIPS_64 relocation record by itself before the
4025 _REL32/_64 record as well, such that the addend is read in as
4026 a 64-bit value (REL32 is a 32-bit relocation, after all).
4027 However, since none of the existing ELF64 MIPS dynamic
4028 loaders seems to care, we don't waste space with these
4029 artificial relocations. If this turns out to not be true,
4030 mips_elf_allocate_dynamic_relocation() should be tweaked so
4031 as to make room for a pair of dynamic relocations per
4032 invocation if ABI_64_P, and here we should generate an
4033 additional relocation record with R_MIPS_64 by itself for a
4034 NULL symbol before this relocation record. */
4035 outrel
[1].r_info
= ELF_R_INFO (output_bfd
, 0,
4036 ABI_64_P (output_bfd
)
4039 outrel
[2].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_NONE
);
4041 /* Adjust the output offset of the relocation to reference the
4042 correct location in the output file. */
4043 outrel
[0].r_offset
+= (input_section
->output_section
->vma
4044 + input_section
->output_offset
);
4045 outrel
[1].r_offset
+= (input_section
->output_section
->vma
4046 + input_section
->output_offset
);
4047 outrel
[2].r_offset
+= (input_section
->output_section
->vma
4048 + input_section
->output_offset
);
4050 /* Put the relocation back out. We have to use the special
4051 relocation outputter in the 64-bit case since the 64-bit
4052 relocation format is non-standard. */
4053 if (ABI_64_P (output_bfd
))
4055 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
4056 (output_bfd
, &outrel
[0],
4058 + sreloc
->reloc_count
* sizeof (Elf64_Mips_External_Rel
)));
4061 bfd_elf32_swap_reloc_out
4062 (output_bfd
, &outrel
[0],
4063 (sreloc
->contents
+ sreloc
->reloc_count
* sizeof (Elf32_External_Rel
)));
4065 /* We've now added another relocation. */
4066 ++sreloc
->reloc_count
;
4068 /* Make sure the output section is writable. The dynamic linker
4069 will be writing to it. */
4070 elf_section_data (input_section
->output_section
)->this_hdr
.sh_flags
4073 /* On IRIX5, make an entry of compact relocation info. */
4074 if (IRIX_COMPAT (output_bfd
) == ict_irix5
)
4076 asection
*scpt
= bfd_get_section_by_name (dynobj
, ".compact_rel");
4081 Elf32_crinfo cptrel
;
4083 mips_elf_set_cr_format (cptrel
, CRF_MIPS_LONG
);
4084 cptrel
.vaddr
= (rel
->r_offset
4085 + input_section
->output_section
->vma
4086 + input_section
->output_offset
);
4087 if (r_type
== R_MIPS_REL32
)
4088 mips_elf_set_cr_type (cptrel
, CRT_MIPS_REL32
);
4090 mips_elf_set_cr_type (cptrel
, CRT_MIPS_WORD
);
4091 mips_elf_set_cr_dist2to (cptrel
, 0);
4092 cptrel
.konst
= *addendp
;
4094 cr
= (scpt
->contents
4095 + sizeof (Elf32_External_compact_rel
));
4096 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
4097 ((Elf32_External_crinfo
*) cr
4098 + scpt
->reloc_count
));
4099 ++scpt
->reloc_count
;
4106 /* Return the MACH for a MIPS e_flags value. */
4109 _bfd_elf_mips_mach (flagword flags
)
4111 switch (flags
& EF_MIPS_MACH
)
4113 case E_MIPS_MACH_3900
:
4114 return bfd_mach_mips3900
;
4116 case E_MIPS_MACH_4010
:
4117 return bfd_mach_mips4010
;
4119 case E_MIPS_MACH_4100
:
4120 return bfd_mach_mips4100
;
4122 case E_MIPS_MACH_4111
:
4123 return bfd_mach_mips4111
;
4125 case E_MIPS_MACH_4120
:
4126 return bfd_mach_mips4120
;
4128 case E_MIPS_MACH_4650
:
4129 return bfd_mach_mips4650
;
4131 case E_MIPS_MACH_5400
:
4132 return bfd_mach_mips5400
;
4134 case E_MIPS_MACH_5500
:
4135 return bfd_mach_mips5500
;
4137 case E_MIPS_MACH_9000
:
4138 return bfd_mach_mips9000
;
4140 case E_MIPS_MACH_SB1
:
4141 return bfd_mach_mips_sb1
;
4144 switch (flags
& EF_MIPS_ARCH
)
4148 return bfd_mach_mips3000
;
4152 return bfd_mach_mips6000
;
4156 return bfd_mach_mips4000
;
4160 return bfd_mach_mips8000
;
4164 return bfd_mach_mips5
;
4167 case E_MIPS_ARCH_32
:
4168 return bfd_mach_mipsisa32
;
4171 case E_MIPS_ARCH_64
:
4172 return bfd_mach_mipsisa64
;
4175 case E_MIPS_ARCH_32R2
:
4176 return bfd_mach_mipsisa32r2
;
4179 case E_MIPS_ARCH_64R2
:
4180 return bfd_mach_mipsisa64r2
;
4188 /* Return printable name for ABI. */
4190 static INLINE
char *
4191 elf_mips_abi_name (bfd
*abfd
)
4195 flags
= elf_elfheader (abfd
)->e_flags
;
4196 switch (flags
& EF_MIPS_ABI
)
4199 if (ABI_N32_P (abfd
))
4201 else if (ABI_64_P (abfd
))
4205 case E_MIPS_ABI_O32
:
4207 case E_MIPS_ABI_O64
:
4209 case E_MIPS_ABI_EABI32
:
4211 case E_MIPS_ABI_EABI64
:
4214 return "unknown abi";
4218 /* MIPS ELF uses two common sections. One is the usual one, and the
4219 other is for small objects. All the small objects are kept
4220 together, and then referenced via the gp pointer, which yields
4221 faster assembler code. This is what we use for the small common
4222 section. This approach is copied from ecoff.c. */
4223 static asection mips_elf_scom_section
;
4224 static asymbol mips_elf_scom_symbol
;
4225 static asymbol
*mips_elf_scom_symbol_ptr
;
4227 /* MIPS ELF also uses an acommon section, which represents an
4228 allocated common symbol which may be overridden by a
4229 definition in a shared library. */
4230 static asection mips_elf_acom_section
;
4231 static asymbol mips_elf_acom_symbol
;
4232 static asymbol
*mips_elf_acom_symbol_ptr
;
4234 /* Handle the special MIPS section numbers that a symbol may use.
4235 This is used for both the 32-bit and the 64-bit ABI. */
4238 _bfd_mips_elf_symbol_processing (bfd
*abfd
, asymbol
*asym
)
4240 elf_symbol_type
*elfsym
;
4242 elfsym
= (elf_symbol_type
*) asym
;
4243 switch (elfsym
->internal_elf_sym
.st_shndx
)
4245 case SHN_MIPS_ACOMMON
:
4246 /* This section is used in a dynamically linked executable file.
4247 It is an allocated common section. The dynamic linker can
4248 either resolve these symbols to something in a shared
4249 library, or it can just leave them here. For our purposes,
4250 we can consider these symbols to be in a new section. */
4251 if (mips_elf_acom_section
.name
== NULL
)
4253 /* Initialize the acommon section. */
4254 mips_elf_acom_section
.name
= ".acommon";
4255 mips_elf_acom_section
.flags
= SEC_ALLOC
;
4256 mips_elf_acom_section
.output_section
= &mips_elf_acom_section
;
4257 mips_elf_acom_section
.symbol
= &mips_elf_acom_symbol
;
4258 mips_elf_acom_section
.symbol_ptr_ptr
= &mips_elf_acom_symbol_ptr
;
4259 mips_elf_acom_symbol
.name
= ".acommon";
4260 mips_elf_acom_symbol
.flags
= BSF_SECTION_SYM
;
4261 mips_elf_acom_symbol
.section
= &mips_elf_acom_section
;
4262 mips_elf_acom_symbol_ptr
= &mips_elf_acom_symbol
;
4264 asym
->section
= &mips_elf_acom_section
;
4268 /* Common symbols less than the GP size are automatically
4269 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
4270 if (asym
->value
> elf_gp_size (abfd
)
4271 || IRIX_COMPAT (abfd
) == ict_irix6
)
4274 case SHN_MIPS_SCOMMON
:
4275 if (mips_elf_scom_section
.name
== NULL
)
4277 /* Initialize the small common section. */
4278 mips_elf_scom_section
.name
= ".scommon";
4279 mips_elf_scom_section
.flags
= SEC_IS_COMMON
;
4280 mips_elf_scom_section
.output_section
= &mips_elf_scom_section
;
4281 mips_elf_scom_section
.symbol
= &mips_elf_scom_symbol
;
4282 mips_elf_scom_section
.symbol_ptr_ptr
= &mips_elf_scom_symbol_ptr
;
4283 mips_elf_scom_symbol
.name
= ".scommon";
4284 mips_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
4285 mips_elf_scom_symbol
.section
= &mips_elf_scom_section
;
4286 mips_elf_scom_symbol_ptr
= &mips_elf_scom_symbol
;
4288 asym
->section
= &mips_elf_scom_section
;
4289 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
4292 case SHN_MIPS_SUNDEFINED
:
4293 asym
->section
= bfd_und_section_ptr
;
4298 asection
*section
= bfd_get_section_by_name (abfd
, ".text");
4300 BFD_ASSERT (SGI_COMPAT (abfd
));
4301 if (section
!= NULL
)
4303 asym
->section
= section
;
4304 /* MIPS_TEXT is a bit special, the address is not an offset
4305 to the base of the .text section. So substract the section
4306 base address to make it an offset. */
4307 asym
->value
-= section
->vma
;
4314 asection
*section
= bfd_get_section_by_name (abfd
, ".data");
4316 BFD_ASSERT (SGI_COMPAT (abfd
));
4317 if (section
!= NULL
)
4319 asym
->section
= section
;
4320 /* MIPS_DATA is a bit special, the address is not an offset
4321 to the base of the .data section. So substract the section
4322 base address to make it an offset. */
4323 asym
->value
-= section
->vma
;
4330 /* Implement elf_backend_eh_frame_address_size. This differs from
4331 the default in the way it handles EABI64.
4333 EABI64 was originally specified as an LP64 ABI, and that is what
4334 -mabi=eabi normally gives on a 64-bit target. However, gcc has
4335 historically accepted the combination of -mabi=eabi and -mlong32,
4336 and this ILP32 variation has become semi-official over time.
4337 Both forms use elf32 and have pointer-sized FDE addresses.
4339 If an EABI object was generated by GCC 4.0 or above, it will have
4340 an empty .gcc_compiled_longXX section, where XX is the size of longs
4341 in bits. Unfortunately, ILP32 objects generated by earlier compilers
4342 have no special marking to distinguish them from LP64 objects.
4344 We don't want users of the official LP64 ABI to be punished for the
4345 existence of the ILP32 variant, but at the same time, we don't want
4346 to mistakenly interpret pre-4.0 ILP32 objects as being LP64 objects.
4347 We therefore take the following approach:
4349 - If ABFD contains a .gcc_compiled_longXX section, use it to
4350 determine the pointer size.
4352 - Otherwise check the type of the first relocation. Assume that
4353 the LP64 ABI is being used if the relocation is of type R_MIPS_64.
4357 The second check is enough to detect LP64 objects generated by pre-4.0
4358 compilers because, in the kind of output generated by those compilers,
4359 the first relocation will be associated with either a CIE personality
4360 routine or an FDE start address. Furthermore, the compilers never
4361 used a special (non-pointer) encoding for this ABI.
4363 Checking the relocation type should also be safe because there is no
4364 reason to use R_MIPS_64 in an ILP32 object. Pre-4.0 compilers never
4368 _bfd_mips_elf_eh_frame_address_size (bfd
*abfd
, asection
*sec
)
4370 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
4372 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
4374 bfd_boolean long32_p
, long64_p
;
4376 long32_p
= bfd_get_section_by_name (abfd
, ".gcc_compiled_long32") != 0;
4377 long64_p
= bfd_get_section_by_name (abfd
, ".gcc_compiled_long64") != 0;
4378 if (long32_p
&& long64_p
)
4385 if (sec
->reloc_count
> 0
4386 && elf_section_data (sec
)->relocs
!= NULL
4387 && (ELF32_R_TYPE (elf_section_data (sec
)->relocs
[0].r_info
)
4396 /* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
4397 relocations against two unnamed section symbols to resolve to the
4398 same address. For example, if we have code like:
4400 lw $4,%got_disp(.data)($gp)
4401 lw $25,%got_disp(.text)($gp)
4404 then the linker will resolve both relocations to .data and the program
4405 will jump there rather than to .text.
4407 We can work around this problem by giving names to local section symbols.
4408 This is also what the MIPSpro tools do. */
4411 _bfd_mips_elf_name_local_section_symbols (bfd
*abfd
)
4413 return SGI_COMPAT (abfd
);
4416 /* Work over a section just before writing it out. This routine is
4417 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
4418 sections that need the SHF_MIPS_GPREL flag by name; there has to be
4422 _bfd_mips_elf_section_processing (bfd
*abfd
, Elf_Internal_Shdr
*hdr
)
4424 if (hdr
->sh_type
== SHT_MIPS_REGINFO
4425 && hdr
->sh_size
> 0)
4429 BFD_ASSERT (hdr
->sh_size
== sizeof (Elf32_External_RegInfo
));
4430 BFD_ASSERT (hdr
->contents
== NULL
);
4433 hdr
->sh_offset
+ sizeof (Elf32_External_RegInfo
) - 4,
4436 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
4437 if (bfd_bwrite (buf
, 4, abfd
) != 4)
4441 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
4442 && hdr
->bfd_section
!= NULL
4443 && mips_elf_section_data (hdr
->bfd_section
) != NULL
4444 && mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
!= NULL
)
4446 bfd_byte
*contents
, *l
, *lend
;
4448 /* We stored the section contents in the tdata field in the
4449 set_section_contents routine. We save the section contents
4450 so that we don't have to read them again.
4451 At this point we know that elf_gp is set, so we can look
4452 through the section contents to see if there is an
4453 ODK_REGINFO structure. */
4455 contents
= mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
;
4457 lend
= contents
+ hdr
->sh_size
;
4458 while (l
+ sizeof (Elf_External_Options
) <= lend
)
4460 Elf_Internal_Options intopt
;
4462 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
4464 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
4471 + sizeof (Elf_External_Options
)
4472 + (sizeof (Elf64_External_RegInfo
) - 8)),
4475 H_PUT_64 (abfd
, elf_gp (abfd
), buf
);
4476 if (bfd_bwrite (buf
, 8, abfd
) != 8)
4479 else if (intopt
.kind
== ODK_REGINFO
)
4486 + sizeof (Elf_External_Options
)
4487 + (sizeof (Elf32_External_RegInfo
) - 4)),
4490 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
4491 if (bfd_bwrite (buf
, 4, abfd
) != 4)
4498 if (hdr
->bfd_section
!= NULL
)
4500 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
4502 if (strcmp (name
, ".sdata") == 0
4503 || strcmp (name
, ".lit8") == 0
4504 || strcmp (name
, ".lit4") == 0)
4506 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
4507 hdr
->sh_type
= SHT_PROGBITS
;
4509 else if (strcmp (name
, ".sbss") == 0)
4511 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
4512 hdr
->sh_type
= SHT_NOBITS
;
4514 else if (strcmp (name
, ".srdata") == 0)
4516 hdr
->sh_flags
|= SHF_ALLOC
| SHF_MIPS_GPREL
;
4517 hdr
->sh_type
= SHT_PROGBITS
;
4519 else if (strcmp (name
, ".compact_rel") == 0)
4522 hdr
->sh_type
= SHT_PROGBITS
;
4524 else if (strcmp (name
, ".rtproc") == 0)
4526 if (hdr
->sh_addralign
!= 0 && hdr
->sh_entsize
== 0)
4528 unsigned int adjust
;
4530 adjust
= hdr
->sh_size
% hdr
->sh_addralign
;
4532 hdr
->sh_size
+= hdr
->sh_addralign
- adjust
;
4540 /* Handle a MIPS specific section when reading an object file. This
4541 is called when elfcode.h finds a section with an unknown type.
4542 This routine supports both the 32-bit and 64-bit ELF ABI.
4544 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
4548 _bfd_mips_elf_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
4553 /* There ought to be a place to keep ELF backend specific flags, but
4554 at the moment there isn't one. We just keep track of the
4555 sections by their name, instead. Fortunately, the ABI gives
4556 suggested names for all the MIPS specific sections, so we will
4557 probably get away with this. */
4558 switch (hdr
->sh_type
)
4560 case SHT_MIPS_LIBLIST
:
4561 if (strcmp (name
, ".liblist") != 0)
4565 if (strcmp (name
, ".msym") != 0)
4568 case SHT_MIPS_CONFLICT
:
4569 if (strcmp (name
, ".conflict") != 0)
4572 case SHT_MIPS_GPTAB
:
4573 if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) != 0)
4576 case SHT_MIPS_UCODE
:
4577 if (strcmp (name
, ".ucode") != 0)
4580 case SHT_MIPS_DEBUG
:
4581 if (strcmp (name
, ".mdebug") != 0)
4583 flags
= SEC_DEBUGGING
;
4585 case SHT_MIPS_REGINFO
:
4586 if (strcmp (name
, ".reginfo") != 0
4587 || hdr
->sh_size
!= sizeof (Elf32_External_RegInfo
))
4589 flags
= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_SIZE
);
4591 case SHT_MIPS_IFACE
:
4592 if (strcmp (name
, ".MIPS.interfaces") != 0)
4595 case SHT_MIPS_CONTENT
:
4596 if (strncmp (name
, ".MIPS.content", sizeof ".MIPS.content" - 1) != 0)
4599 case SHT_MIPS_OPTIONS
:
4600 if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) != 0)
4603 case SHT_MIPS_DWARF
:
4604 if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) != 0)
4607 case SHT_MIPS_SYMBOL_LIB
:
4608 if (strcmp (name
, ".MIPS.symlib") != 0)
4611 case SHT_MIPS_EVENTS
:
4612 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) != 0
4613 && strncmp (name
, ".MIPS.post_rel",
4614 sizeof ".MIPS.post_rel" - 1) != 0)
4621 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
4626 if (! bfd_set_section_flags (abfd
, hdr
->bfd_section
,
4627 (bfd_get_section_flags (abfd
,
4633 /* FIXME: We should record sh_info for a .gptab section. */
4635 /* For a .reginfo section, set the gp value in the tdata information
4636 from the contents of this section. We need the gp value while
4637 processing relocs, so we just get it now. The .reginfo section
4638 is not used in the 64-bit MIPS ELF ABI. */
4639 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
4641 Elf32_External_RegInfo ext
;
4644 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
,
4645 &ext
, 0, sizeof ext
))
4647 bfd_mips_elf32_swap_reginfo_in (abfd
, &ext
, &s
);
4648 elf_gp (abfd
) = s
.ri_gp_value
;
4651 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
4652 set the gp value based on what we find. We may see both
4653 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
4654 they should agree. */
4655 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
)
4657 bfd_byte
*contents
, *l
, *lend
;
4659 contents
= bfd_malloc (hdr
->sh_size
);
4660 if (contents
== NULL
)
4662 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
,
4669 lend
= contents
+ hdr
->sh_size
;
4670 while (l
+ sizeof (Elf_External_Options
) <= lend
)
4672 Elf_Internal_Options intopt
;
4674 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
4676 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
4678 Elf64_Internal_RegInfo intreg
;
4680 bfd_mips_elf64_swap_reginfo_in
4682 ((Elf64_External_RegInfo
*)
4683 (l
+ sizeof (Elf_External_Options
))),
4685 elf_gp (abfd
) = intreg
.ri_gp_value
;
4687 else if (intopt
.kind
== ODK_REGINFO
)
4689 Elf32_RegInfo intreg
;
4691 bfd_mips_elf32_swap_reginfo_in
4693 ((Elf32_External_RegInfo
*)
4694 (l
+ sizeof (Elf_External_Options
))),
4696 elf_gp (abfd
) = intreg
.ri_gp_value
;
4706 /* Set the correct type for a MIPS ELF section. We do this by the
4707 section name, which is a hack, but ought to work. This routine is
4708 used by both the 32-bit and the 64-bit ABI. */
4711 _bfd_mips_elf_fake_sections (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*sec
)
4713 register const char *name
;
4715 name
= bfd_get_section_name (abfd
, sec
);
4717 if (strcmp (name
, ".liblist") == 0)
4719 hdr
->sh_type
= SHT_MIPS_LIBLIST
;
4720 hdr
->sh_info
= sec
->size
/ sizeof (Elf32_Lib
);
4721 /* The sh_link field is set in final_write_processing. */
4723 else if (strcmp (name
, ".conflict") == 0)
4724 hdr
->sh_type
= SHT_MIPS_CONFLICT
;
4725 else if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0)
4727 hdr
->sh_type
= SHT_MIPS_GPTAB
;
4728 hdr
->sh_entsize
= sizeof (Elf32_External_gptab
);
4729 /* The sh_info field is set in final_write_processing. */
4731 else if (strcmp (name
, ".ucode") == 0)
4732 hdr
->sh_type
= SHT_MIPS_UCODE
;
4733 else if (strcmp (name
, ".mdebug") == 0)
4735 hdr
->sh_type
= SHT_MIPS_DEBUG
;
4736 /* In a shared object on IRIX 5.3, the .mdebug section has an
4737 entsize of 0. FIXME: Does this matter? */
4738 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
4739 hdr
->sh_entsize
= 0;
4741 hdr
->sh_entsize
= 1;
4743 else if (strcmp (name
, ".reginfo") == 0)
4745 hdr
->sh_type
= SHT_MIPS_REGINFO
;
4746 /* In a shared object on IRIX 5.3, the .reginfo section has an
4747 entsize of 0x18. FIXME: Does this matter? */
4748 if (SGI_COMPAT (abfd
))
4750 if ((abfd
->flags
& DYNAMIC
) != 0)
4751 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
4753 hdr
->sh_entsize
= 1;
4756 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
4758 else if (SGI_COMPAT (abfd
)
4759 && (strcmp (name
, ".hash") == 0
4760 || strcmp (name
, ".dynamic") == 0
4761 || strcmp (name
, ".dynstr") == 0))
4763 if (SGI_COMPAT (abfd
))
4764 hdr
->sh_entsize
= 0;
4766 /* This isn't how the IRIX6 linker behaves. */
4767 hdr
->sh_info
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
4770 else if (strcmp (name
, ".got") == 0
4771 || strcmp (name
, ".srdata") == 0
4772 || strcmp (name
, ".sdata") == 0
4773 || strcmp (name
, ".sbss") == 0
4774 || strcmp (name
, ".lit4") == 0
4775 || strcmp (name
, ".lit8") == 0)
4776 hdr
->sh_flags
|= SHF_MIPS_GPREL
;
4777 else if (strcmp (name
, ".MIPS.interfaces") == 0)
4779 hdr
->sh_type
= SHT_MIPS_IFACE
;
4780 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4782 else if (strncmp (name
, ".MIPS.content", strlen (".MIPS.content")) == 0)
4784 hdr
->sh_type
= SHT_MIPS_CONTENT
;
4785 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4786 /* The sh_info field is set in final_write_processing. */
4788 else if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
4790 hdr
->sh_type
= SHT_MIPS_OPTIONS
;
4791 hdr
->sh_entsize
= 1;
4792 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4794 else if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) == 0)
4795 hdr
->sh_type
= SHT_MIPS_DWARF
;
4796 else if (strcmp (name
, ".MIPS.symlib") == 0)
4798 hdr
->sh_type
= SHT_MIPS_SYMBOL_LIB
;
4799 /* The sh_link and sh_info fields are set in
4800 final_write_processing. */
4802 else if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0
4803 || strncmp (name
, ".MIPS.post_rel",
4804 sizeof ".MIPS.post_rel" - 1) == 0)
4806 hdr
->sh_type
= SHT_MIPS_EVENTS
;
4807 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4808 /* The sh_link field is set in final_write_processing. */
4810 else if (strcmp (name
, ".msym") == 0)
4812 hdr
->sh_type
= SHT_MIPS_MSYM
;
4813 hdr
->sh_flags
|= SHF_ALLOC
;
4814 hdr
->sh_entsize
= 8;
4817 /* The generic elf_fake_sections will set up REL_HDR using the default
4818 kind of relocations. We used to set up a second header for the
4819 non-default kind of relocations here, but only NewABI would use
4820 these, and the IRIX ld doesn't like resulting empty RELA sections.
4821 Thus we create those header only on demand now. */
4826 /* Given a BFD section, try to locate the corresponding ELF section
4827 index. This is used by both the 32-bit and the 64-bit ABI.
4828 Actually, it's not clear to me that the 64-bit ABI supports these,
4829 but for non-PIC objects we will certainly want support for at least
4830 the .scommon section. */
4833 _bfd_mips_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
4834 asection
*sec
, int *retval
)
4836 if (strcmp (bfd_get_section_name (abfd
, sec
), ".scommon") == 0)
4838 *retval
= SHN_MIPS_SCOMMON
;
4841 if (strcmp (bfd_get_section_name (abfd
, sec
), ".acommon") == 0)
4843 *retval
= SHN_MIPS_ACOMMON
;
4849 /* Hook called by the linker routine which adds symbols from an object
4850 file. We must handle the special MIPS section numbers here. */
4853 _bfd_mips_elf_add_symbol_hook (bfd
*abfd
, struct bfd_link_info
*info
,
4854 Elf_Internal_Sym
*sym
, const char **namep
,
4855 flagword
*flagsp ATTRIBUTE_UNUSED
,
4856 asection
**secp
, bfd_vma
*valp
)
4858 if (SGI_COMPAT (abfd
)
4859 && (abfd
->flags
& DYNAMIC
) != 0
4860 && strcmp (*namep
, "_rld_new_interface") == 0)
4862 /* Skip IRIX5 rld entry name. */
4867 switch (sym
->st_shndx
)
4870 /* Common symbols less than the GP size are automatically
4871 treated as SHN_MIPS_SCOMMON symbols. */
4872 if (sym
->st_size
> elf_gp_size (abfd
)
4873 || IRIX_COMPAT (abfd
) == ict_irix6
)
4876 case SHN_MIPS_SCOMMON
:
4877 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
4878 (*secp
)->flags
|= SEC_IS_COMMON
;
4879 *valp
= sym
->st_size
;
4883 /* This section is used in a shared object. */
4884 if (elf_tdata (abfd
)->elf_text_section
== NULL
)
4886 asymbol
*elf_text_symbol
;
4887 asection
*elf_text_section
;
4888 bfd_size_type amt
= sizeof (asection
);
4890 elf_text_section
= bfd_zalloc (abfd
, amt
);
4891 if (elf_text_section
== NULL
)
4894 amt
= sizeof (asymbol
);
4895 elf_text_symbol
= bfd_zalloc (abfd
, amt
);
4896 if (elf_text_symbol
== NULL
)
4899 /* Initialize the section. */
4901 elf_tdata (abfd
)->elf_text_section
= elf_text_section
;
4902 elf_tdata (abfd
)->elf_text_symbol
= elf_text_symbol
;
4904 elf_text_section
->symbol
= elf_text_symbol
;
4905 elf_text_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_text_symbol
;
4907 elf_text_section
->name
= ".text";
4908 elf_text_section
->flags
= SEC_NO_FLAGS
;
4909 elf_text_section
->output_section
= NULL
;
4910 elf_text_section
->owner
= abfd
;
4911 elf_text_symbol
->name
= ".text";
4912 elf_text_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
4913 elf_text_symbol
->section
= elf_text_section
;
4915 /* This code used to do *secp = bfd_und_section_ptr if
4916 info->shared. I don't know why, and that doesn't make sense,
4917 so I took it out. */
4918 *secp
= elf_tdata (abfd
)->elf_text_section
;
4921 case SHN_MIPS_ACOMMON
:
4922 /* Fall through. XXX Can we treat this as allocated data? */
4924 /* This section is used in a shared object. */
4925 if (elf_tdata (abfd
)->elf_data_section
== NULL
)
4927 asymbol
*elf_data_symbol
;
4928 asection
*elf_data_section
;
4929 bfd_size_type amt
= sizeof (asection
);
4931 elf_data_section
= bfd_zalloc (abfd
, amt
);
4932 if (elf_data_section
== NULL
)
4935 amt
= sizeof (asymbol
);
4936 elf_data_symbol
= bfd_zalloc (abfd
, amt
);
4937 if (elf_data_symbol
== NULL
)
4940 /* Initialize the section. */
4942 elf_tdata (abfd
)->elf_data_section
= elf_data_section
;
4943 elf_tdata (abfd
)->elf_data_symbol
= elf_data_symbol
;
4945 elf_data_section
->symbol
= elf_data_symbol
;
4946 elf_data_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_data_symbol
;
4948 elf_data_section
->name
= ".data";
4949 elf_data_section
->flags
= SEC_NO_FLAGS
;
4950 elf_data_section
->output_section
= NULL
;
4951 elf_data_section
->owner
= abfd
;
4952 elf_data_symbol
->name
= ".data";
4953 elf_data_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
4954 elf_data_symbol
->section
= elf_data_section
;
4956 /* This code used to do *secp = bfd_und_section_ptr if
4957 info->shared. I don't know why, and that doesn't make sense,
4958 so I took it out. */
4959 *secp
= elf_tdata (abfd
)->elf_data_section
;
4962 case SHN_MIPS_SUNDEFINED
:
4963 *secp
= bfd_und_section_ptr
;
4967 if (SGI_COMPAT (abfd
)
4969 && info
->hash
->creator
== abfd
->xvec
4970 && strcmp (*namep
, "__rld_obj_head") == 0)
4972 struct elf_link_hash_entry
*h
;
4973 struct bfd_link_hash_entry
*bh
;
4975 /* Mark __rld_obj_head as dynamic. */
4977 if (! (_bfd_generic_link_add_one_symbol
4978 (info
, abfd
, *namep
, BSF_GLOBAL
, *secp
, *valp
, NULL
, FALSE
,
4979 get_elf_backend_data (abfd
)->collect
, &bh
)))
4982 h
= (struct elf_link_hash_entry
*) bh
;
4985 h
->type
= STT_OBJECT
;
4987 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
4990 mips_elf_hash_table (info
)->use_rld_obj_head
= TRUE
;
4993 /* If this is a mips16 text symbol, add 1 to the value to make it
4994 odd. This will cause something like .word SYM to come up with
4995 the right value when it is loaded into the PC. */
4996 if (sym
->st_other
== STO_MIPS16
)
5002 /* This hook function is called before the linker writes out a global
5003 symbol. We mark symbols as small common if appropriate. This is
5004 also where we undo the increment of the value for a mips16 symbol. */
5007 _bfd_mips_elf_link_output_symbol_hook
5008 (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5009 const char *name ATTRIBUTE_UNUSED
, Elf_Internal_Sym
*sym
,
5010 asection
*input_sec
, struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
)
5012 /* If we see a common symbol, which implies a relocatable link, then
5013 if a symbol was small common in an input file, mark it as small
5014 common in the output file. */
5015 if (sym
->st_shndx
== SHN_COMMON
5016 && strcmp (input_sec
->name
, ".scommon") == 0)
5017 sym
->st_shndx
= SHN_MIPS_SCOMMON
;
5019 if (sym
->st_other
== STO_MIPS16
)
5020 sym
->st_value
&= ~1;
5025 /* Functions for the dynamic linker. */
5027 /* Create dynamic sections when linking against a dynamic object. */
5030 _bfd_mips_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
5032 struct elf_link_hash_entry
*h
;
5033 struct bfd_link_hash_entry
*bh
;
5035 register asection
*s
;
5036 const char * const *namep
;
5038 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
5039 | SEC_LINKER_CREATED
| SEC_READONLY
);
5041 /* Mips ABI requests the .dynamic section to be read only. */
5042 s
= bfd_get_section_by_name (abfd
, ".dynamic");
5045 if (! bfd_set_section_flags (abfd
, s
, flags
))
5049 /* We need to create .got section. */
5050 if (! mips_elf_create_got_section (abfd
, info
, FALSE
))
5053 if (! mips_elf_rel_dyn_section (elf_hash_table (info
)->dynobj
, TRUE
))
5056 /* Create .stub section. */
5057 if (bfd_get_section_by_name (abfd
,
5058 MIPS_ELF_STUB_SECTION_NAME (abfd
)) == NULL
)
5060 s
= bfd_make_section (abfd
, MIPS_ELF_STUB_SECTION_NAME (abfd
));
5062 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_CODE
)
5063 || ! bfd_set_section_alignment (abfd
, s
,
5064 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
5068 if ((IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
5070 && bfd_get_section_by_name (abfd
, ".rld_map") == NULL
)
5072 s
= bfd_make_section (abfd
, ".rld_map");
5074 || ! bfd_set_section_flags (abfd
, s
, flags
&~ (flagword
) SEC_READONLY
)
5075 || ! bfd_set_section_alignment (abfd
, s
,
5076 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
5080 /* On IRIX5, we adjust add some additional symbols and change the
5081 alignments of several sections. There is no ABI documentation
5082 indicating that this is necessary on IRIX6, nor any evidence that
5083 the linker takes such action. */
5084 if (IRIX_COMPAT (abfd
) == ict_irix5
)
5086 for (namep
= mips_elf_dynsym_rtproc_names
; *namep
!= NULL
; namep
++)
5089 if (! (_bfd_generic_link_add_one_symbol
5090 (info
, abfd
, *namep
, BSF_GLOBAL
, bfd_und_section_ptr
, 0,
5091 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
5094 h
= (struct elf_link_hash_entry
*) bh
;
5097 h
->type
= STT_SECTION
;
5099 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
5103 /* We need to create a .compact_rel section. */
5104 if (SGI_COMPAT (abfd
))
5106 if (!mips_elf_create_compact_rel_section (abfd
, info
))
5110 /* Change alignments of some sections. */
5111 s
= bfd_get_section_by_name (abfd
, ".hash");
5113 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
5114 s
= bfd_get_section_by_name (abfd
, ".dynsym");
5116 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
5117 s
= bfd_get_section_by_name (abfd
, ".dynstr");
5119 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
5120 s
= bfd_get_section_by_name (abfd
, ".reginfo");
5122 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
5123 s
= bfd_get_section_by_name (abfd
, ".dynamic");
5125 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
5132 name
= SGI_COMPAT (abfd
) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
5134 if (!(_bfd_generic_link_add_one_symbol
5135 (info
, abfd
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
, 0,
5136 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
5139 h
= (struct elf_link_hash_entry
*) bh
;
5142 h
->type
= STT_SECTION
;
5144 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
5147 if (! mips_elf_hash_table (info
)->use_rld_obj_head
)
5149 /* __rld_map is a four byte word located in the .data section
5150 and is filled in by the rtld to contain a pointer to
5151 the _r_debug structure. Its symbol value will be set in
5152 _bfd_mips_elf_finish_dynamic_symbol. */
5153 s
= bfd_get_section_by_name (abfd
, ".rld_map");
5154 BFD_ASSERT (s
!= NULL
);
5156 name
= SGI_COMPAT (abfd
) ? "__rld_map" : "__RLD_MAP";
5158 if (!(_bfd_generic_link_add_one_symbol
5159 (info
, abfd
, name
, BSF_GLOBAL
, s
, 0, NULL
, FALSE
,
5160 get_elf_backend_data (abfd
)->collect
, &bh
)))
5163 h
= (struct elf_link_hash_entry
*) bh
;
5166 h
->type
= STT_OBJECT
;
5168 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
5176 /* Look through the relocs for a section during the first phase, and
5177 allocate space in the global offset table. */
5180 _bfd_mips_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
5181 asection
*sec
, const Elf_Internal_Rela
*relocs
)
5185 Elf_Internal_Shdr
*symtab_hdr
;
5186 struct elf_link_hash_entry
**sym_hashes
;
5187 struct mips_got_info
*g
;
5189 const Elf_Internal_Rela
*rel
;
5190 const Elf_Internal_Rela
*rel_end
;
5193 const struct elf_backend_data
*bed
;
5195 if (info
->relocatable
)
5198 dynobj
= elf_hash_table (info
)->dynobj
;
5199 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5200 sym_hashes
= elf_sym_hashes (abfd
);
5201 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
5203 /* Check for the mips16 stub sections. */
5205 name
= bfd_get_section_name (abfd
, sec
);
5206 if (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0)
5208 unsigned long r_symndx
;
5210 /* Look at the relocation information to figure out which symbol
5213 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
5215 if (r_symndx
< extsymoff
5216 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
5220 /* This stub is for a local symbol. This stub will only be
5221 needed if there is some relocation in this BFD, other
5222 than a 16 bit function call, which refers to this symbol. */
5223 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5225 Elf_Internal_Rela
*sec_relocs
;
5226 const Elf_Internal_Rela
*r
, *rend
;
5228 /* We can ignore stub sections when looking for relocs. */
5229 if ((o
->flags
& SEC_RELOC
) == 0
5230 || o
->reloc_count
== 0
5231 || strncmp (bfd_get_section_name (abfd
, o
), FN_STUB
,
5232 sizeof FN_STUB
- 1) == 0
5233 || strncmp (bfd_get_section_name (abfd
, o
), CALL_STUB
,
5234 sizeof CALL_STUB
- 1) == 0
5235 || strncmp (bfd_get_section_name (abfd
, o
), CALL_FP_STUB
,
5236 sizeof CALL_FP_STUB
- 1) == 0)
5240 = _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
5242 if (sec_relocs
== NULL
)
5245 rend
= sec_relocs
+ o
->reloc_count
;
5246 for (r
= sec_relocs
; r
< rend
; r
++)
5247 if (ELF_R_SYM (abfd
, r
->r_info
) == r_symndx
5248 && ELF_R_TYPE (abfd
, r
->r_info
) != R_MIPS16_26
)
5251 if (elf_section_data (o
)->relocs
!= sec_relocs
)
5260 /* There is no non-call reloc for this stub, so we do
5261 not need it. Since this function is called before
5262 the linker maps input sections to output sections, we
5263 can easily discard it by setting the SEC_EXCLUDE
5265 sec
->flags
|= SEC_EXCLUDE
;
5269 /* Record this stub in an array of local symbol stubs for
5271 if (elf_tdata (abfd
)->local_stubs
== NULL
)
5273 unsigned long symcount
;
5277 if (elf_bad_symtab (abfd
))
5278 symcount
= NUM_SHDR_ENTRIES (symtab_hdr
);
5280 symcount
= symtab_hdr
->sh_info
;
5281 amt
= symcount
* sizeof (asection
*);
5282 n
= bfd_zalloc (abfd
, amt
);
5285 elf_tdata (abfd
)->local_stubs
= n
;
5288 elf_tdata (abfd
)->local_stubs
[r_symndx
] = sec
;
5290 /* We don't need to set mips16_stubs_seen in this case.
5291 That flag is used to see whether we need to look through
5292 the global symbol table for stubs. We don't need to set
5293 it here, because we just have a local stub. */
5297 struct mips_elf_link_hash_entry
*h
;
5299 h
= ((struct mips_elf_link_hash_entry
*)
5300 sym_hashes
[r_symndx
- extsymoff
]);
5302 /* H is the symbol this stub is for. */
5305 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
5308 else if (strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
5309 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
5311 unsigned long r_symndx
;
5312 struct mips_elf_link_hash_entry
*h
;
5315 /* Look at the relocation information to figure out which symbol
5318 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
5320 if (r_symndx
< extsymoff
5321 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
5323 /* This stub was actually built for a static symbol defined
5324 in the same file. We assume that all static symbols in
5325 mips16 code are themselves mips16, so we can simply
5326 discard this stub. Since this function is called before
5327 the linker maps input sections to output sections, we can
5328 easily discard it by setting the SEC_EXCLUDE flag. */
5329 sec
->flags
|= SEC_EXCLUDE
;
5333 h
= ((struct mips_elf_link_hash_entry
*)
5334 sym_hashes
[r_symndx
- extsymoff
]);
5336 /* H is the symbol this stub is for. */
5338 if (strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
5339 loc
= &h
->call_fp_stub
;
5341 loc
= &h
->call_stub
;
5343 /* If we already have an appropriate stub for this function, we
5344 don't need another one, so we can discard this one. Since
5345 this function is called before the linker maps input sections
5346 to output sections, we can easily discard it by setting the
5347 SEC_EXCLUDE flag. We can also discard this section if we
5348 happen to already know that this is a mips16 function; it is
5349 not necessary to check this here, as it is checked later, but
5350 it is slightly faster to check now. */
5351 if (*loc
!= NULL
|| h
->root
.other
== STO_MIPS16
)
5353 sec
->flags
|= SEC_EXCLUDE
;
5358 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
5368 sgot
= mips_elf_got_section (dynobj
, FALSE
);
5373 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
5374 g
= mips_elf_section_data (sgot
)->u
.got_info
;
5375 BFD_ASSERT (g
!= NULL
);
5380 bed
= get_elf_backend_data (abfd
);
5381 rel_end
= relocs
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
5382 for (rel
= relocs
; rel
< rel_end
; ++rel
)
5384 unsigned long r_symndx
;
5385 unsigned int r_type
;
5386 struct elf_link_hash_entry
*h
;
5388 r_symndx
= ELF_R_SYM (abfd
, rel
->r_info
);
5389 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
5391 if (r_symndx
< extsymoff
)
5393 else if (r_symndx
>= extsymoff
+ NUM_SHDR_ENTRIES (symtab_hdr
))
5395 (*_bfd_error_handler
)
5396 (_("%B: Malformed reloc detected for section %s"),
5398 bfd_set_error (bfd_error_bad_value
);
5403 h
= sym_hashes
[r_symndx
- extsymoff
];
5405 /* This may be an indirect symbol created because of a version. */
5408 while (h
->root
.type
== bfd_link_hash_indirect
)
5409 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5413 /* Some relocs require a global offset table. */
5414 if (dynobj
== NULL
|| sgot
== NULL
)
5420 case R_MIPS_CALL_HI16
:
5421 case R_MIPS_CALL_LO16
:
5422 case R_MIPS_GOT_HI16
:
5423 case R_MIPS_GOT_LO16
:
5424 case R_MIPS_GOT_PAGE
:
5425 case R_MIPS_GOT_OFST
:
5426 case R_MIPS_GOT_DISP
:
5428 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5429 if (! mips_elf_create_got_section (dynobj
, info
, FALSE
))
5431 g
= mips_elf_got_info (dynobj
, &sgot
);
5438 && (info
->shared
|| h
!= NULL
)
5439 && (sec
->flags
& SEC_ALLOC
) != 0)
5440 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5448 if (!h
&& (r_type
== R_MIPS_CALL_LO16
5449 || r_type
== R_MIPS_GOT_LO16
5450 || r_type
== R_MIPS_GOT_DISP
))
5452 /* We may need a local GOT entry for this relocation. We
5453 don't count R_MIPS_GOT_PAGE because we can estimate the
5454 maximum number of pages needed by looking at the size of
5455 the segment. Similar comments apply to R_MIPS_GOT16 and
5456 R_MIPS_CALL16. We don't count R_MIPS_GOT_HI16, or
5457 R_MIPS_CALL_HI16 because these are always followed by an
5458 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
5459 if (! mips_elf_record_local_got_symbol (abfd
, r_symndx
,
5469 (*_bfd_error_handler
)
5470 (_("%B: CALL16 reloc at 0x%lx not against global symbol"),
5471 abfd
, (unsigned long) rel
->r_offset
);
5472 bfd_set_error (bfd_error_bad_value
);
5477 case R_MIPS_CALL_HI16
:
5478 case R_MIPS_CALL_LO16
:
5481 /* This symbol requires a global offset table entry. */
5482 if (! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5485 /* We need a stub, not a plt entry for the undefined
5486 function. But we record it as if it needs plt. See
5487 _bfd_elf_adjust_dynamic_symbol. */
5493 case R_MIPS_GOT_PAGE
:
5494 /* If this is a global, overridable symbol, GOT_PAGE will
5495 decay to GOT_DISP, so we'll need a GOT entry for it. */
5500 struct mips_elf_link_hash_entry
*hmips
=
5501 (struct mips_elf_link_hash_entry
*) h
;
5503 while (hmips
->root
.root
.type
== bfd_link_hash_indirect
5504 || hmips
->root
.root
.type
== bfd_link_hash_warning
)
5505 hmips
= (struct mips_elf_link_hash_entry
*)
5506 hmips
->root
.root
.u
.i
.link
;
5508 if (hmips
->root
.def_regular
5509 && ! (info
->shared
&& ! info
->symbolic
5510 && ! hmips
->root
.forced_local
))
5516 case R_MIPS_GOT_HI16
:
5517 case R_MIPS_GOT_LO16
:
5518 case R_MIPS_GOT_DISP
:
5519 /* This symbol requires a global offset table entry. */
5520 if (h
&& ! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5527 if ((info
->shared
|| h
!= NULL
)
5528 && (sec
->flags
& SEC_ALLOC
) != 0)
5532 sreloc
= mips_elf_rel_dyn_section (dynobj
, TRUE
);
5536 #define MIPS_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
5539 /* When creating a shared object, we must copy these
5540 reloc types into the output file as R_MIPS_REL32
5541 relocs. We make room for this reloc in the
5542 .rel.dyn reloc section. */
5543 mips_elf_allocate_dynamic_relocations (dynobj
, 1);
5544 if ((sec
->flags
& MIPS_READONLY_SECTION
)
5545 == MIPS_READONLY_SECTION
)
5546 /* We tell the dynamic linker that there are
5547 relocations against the text segment. */
5548 info
->flags
|= DF_TEXTREL
;
5552 struct mips_elf_link_hash_entry
*hmips
;
5554 /* We only need to copy this reloc if the symbol is
5555 defined in a dynamic object. */
5556 hmips
= (struct mips_elf_link_hash_entry
*) h
;
5557 ++hmips
->possibly_dynamic_relocs
;
5558 if ((sec
->flags
& MIPS_READONLY_SECTION
)
5559 == MIPS_READONLY_SECTION
)
5560 /* We need it to tell the dynamic linker if there
5561 are relocations against the text segment. */
5562 hmips
->readonly_reloc
= TRUE
;
5565 /* Even though we don't directly need a GOT entry for
5566 this symbol, a symbol must have a dynamic symbol
5567 table index greater that DT_MIPS_GOTSYM if there are
5568 dynamic relocations against it. */
5572 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5573 if (! mips_elf_create_got_section (dynobj
, info
, TRUE
))
5575 g
= mips_elf_got_info (dynobj
, &sgot
);
5576 if (! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5581 if (SGI_COMPAT (abfd
))
5582 mips_elf_hash_table (info
)->compact_rel_size
+=
5583 sizeof (Elf32_External_crinfo
);
5587 case R_MIPS_GPREL16
:
5588 case R_MIPS_LITERAL
:
5589 case R_MIPS_GPREL32
:
5590 if (SGI_COMPAT (abfd
))
5591 mips_elf_hash_table (info
)->compact_rel_size
+=
5592 sizeof (Elf32_External_crinfo
);
5595 /* This relocation describes the C++ object vtable hierarchy.
5596 Reconstruct it for later use during GC. */
5597 case R_MIPS_GNU_VTINHERIT
:
5598 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
5602 /* This relocation describes which C++ vtable entries are actually
5603 used. Record for later use during GC. */
5604 case R_MIPS_GNU_VTENTRY
:
5605 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
5613 /* We must not create a stub for a symbol that has relocations
5614 related to taking the function's address. */
5620 struct mips_elf_link_hash_entry
*mh
;
5622 mh
= (struct mips_elf_link_hash_entry
*) h
;
5623 mh
->no_fn_stub
= TRUE
;
5627 case R_MIPS_CALL_HI16
:
5628 case R_MIPS_CALL_LO16
:
5633 /* If this reloc is not a 16 bit call, and it has a global
5634 symbol, then we will need the fn_stub if there is one.
5635 References from a stub section do not count. */
5637 && r_type
!= R_MIPS16_26
5638 && strncmp (bfd_get_section_name (abfd
, sec
), FN_STUB
,
5639 sizeof FN_STUB
- 1) != 0
5640 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_STUB
,
5641 sizeof CALL_STUB
- 1) != 0
5642 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_FP_STUB
,
5643 sizeof CALL_FP_STUB
- 1) != 0)
5645 struct mips_elf_link_hash_entry
*mh
;
5647 mh
= (struct mips_elf_link_hash_entry
*) h
;
5648 mh
->need_fn_stub
= TRUE
;
5656 _bfd_mips_relax_section (bfd
*abfd
, asection
*sec
,
5657 struct bfd_link_info
*link_info
,
5660 Elf_Internal_Rela
*internal_relocs
;
5661 Elf_Internal_Rela
*irel
, *irelend
;
5662 Elf_Internal_Shdr
*symtab_hdr
;
5663 bfd_byte
*contents
= NULL
;
5665 bfd_boolean changed_contents
= FALSE
;
5666 bfd_vma sec_start
= sec
->output_section
->vma
+ sec
->output_offset
;
5667 Elf_Internal_Sym
*isymbuf
= NULL
;
5669 /* We are not currently changing any sizes, so only one pass. */
5672 if (link_info
->relocatable
)
5675 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
5676 link_info
->keep_memory
);
5677 if (internal_relocs
== NULL
)
5680 irelend
= internal_relocs
+ sec
->reloc_count
5681 * get_elf_backend_data (abfd
)->s
->int_rels_per_ext_rel
;
5682 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5683 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
5685 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
5688 bfd_signed_vma sym_offset
;
5689 unsigned int r_type
;
5690 unsigned long r_symndx
;
5692 unsigned long instruction
;
5694 /* Turn jalr into bgezal, and jr into beq, if they're marked
5695 with a JALR relocation, that indicate where they jump to.
5696 This saves some pipeline bubbles. */
5697 r_type
= ELF_R_TYPE (abfd
, irel
->r_info
);
5698 if (r_type
!= R_MIPS_JALR
)
5701 r_symndx
= ELF_R_SYM (abfd
, irel
->r_info
);
5702 /* Compute the address of the jump target. */
5703 if (r_symndx
>= extsymoff
)
5705 struct mips_elf_link_hash_entry
*h
5706 = ((struct mips_elf_link_hash_entry
*)
5707 elf_sym_hashes (abfd
) [r_symndx
- extsymoff
]);
5709 while (h
->root
.root
.type
== bfd_link_hash_indirect
5710 || h
->root
.root
.type
== bfd_link_hash_warning
)
5711 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
5713 /* If a symbol is undefined, or if it may be overridden,
5715 if (! ((h
->root
.root
.type
== bfd_link_hash_defined
5716 || h
->root
.root
.type
== bfd_link_hash_defweak
)
5717 && h
->root
.root
.u
.def
.section
)
5718 || (link_info
->shared
&& ! link_info
->symbolic
5719 && !h
->root
.forced_local
))
5722 sym_sec
= h
->root
.root
.u
.def
.section
;
5723 if (sym_sec
->output_section
)
5724 symval
= (h
->root
.root
.u
.def
.value
5725 + sym_sec
->output_section
->vma
5726 + sym_sec
->output_offset
);
5728 symval
= h
->root
.root
.u
.def
.value
;
5732 Elf_Internal_Sym
*isym
;
5734 /* Read this BFD's symbols if we haven't done so already. */
5735 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
5737 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5738 if (isymbuf
== NULL
)
5739 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
5740 symtab_hdr
->sh_info
, 0,
5742 if (isymbuf
== NULL
)
5746 isym
= isymbuf
+ r_symndx
;
5747 if (isym
->st_shndx
== SHN_UNDEF
)
5749 else if (isym
->st_shndx
== SHN_ABS
)
5750 sym_sec
= bfd_abs_section_ptr
;
5751 else if (isym
->st_shndx
== SHN_COMMON
)
5752 sym_sec
= bfd_com_section_ptr
;
5755 = bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
5756 symval
= isym
->st_value
5757 + sym_sec
->output_section
->vma
5758 + sym_sec
->output_offset
;
5761 /* Compute branch offset, from delay slot of the jump to the
5763 sym_offset
= (symval
+ irel
->r_addend
)
5764 - (sec_start
+ irel
->r_offset
+ 4);
5766 /* Branch offset must be properly aligned. */
5767 if ((sym_offset
& 3) != 0)
5772 /* Check that it's in range. */
5773 if (sym_offset
< -0x8000 || sym_offset
>= 0x8000)
5776 /* Get the section contents if we haven't done so already. */
5777 if (contents
== NULL
)
5779 /* Get cached copy if it exists. */
5780 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
5781 contents
= elf_section_data (sec
)->this_hdr
.contents
;
5784 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
5789 instruction
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
5791 /* If it was jalr <reg>, turn it into bgezal $zero, <target>. */
5792 if ((instruction
& 0xfc1fffff) == 0x0000f809)
5793 instruction
= 0x04110000;
5794 /* If it was jr <reg>, turn it into b <target>. */
5795 else if ((instruction
& 0xfc1fffff) == 0x00000008)
5796 instruction
= 0x10000000;
5800 instruction
|= (sym_offset
& 0xffff);
5801 bfd_put_32 (abfd
, instruction
, contents
+ irel
->r_offset
);
5802 changed_contents
= TRUE
;
5805 if (contents
!= NULL
5806 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
5808 if (!changed_contents
&& !link_info
->keep_memory
)
5812 /* Cache the section contents for elf_link_input_bfd. */
5813 elf_section_data (sec
)->this_hdr
.contents
= contents
;
5819 if (contents
!= NULL
5820 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
5825 /* Adjust a symbol defined by a dynamic object and referenced by a
5826 regular object. The current definition is in some section of the
5827 dynamic object, but we're not including those sections. We have to
5828 change the definition to something the rest of the link can
5832 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
5833 struct elf_link_hash_entry
*h
)
5836 struct mips_elf_link_hash_entry
*hmips
;
5839 dynobj
= elf_hash_table (info
)->dynobj
;
5841 /* Make sure we know what is going on here. */
5842 BFD_ASSERT (dynobj
!= NULL
5844 || h
->u
.weakdef
!= NULL
5847 && !h
->def_regular
)));
5849 /* If this symbol is defined in a dynamic object, we need to copy
5850 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
5852 hmips
= (struct mips_elf_link_hash_entry
*) h
;
5853 if (! info
->relocatable
5854 && hmips
->possibly_dynamic_relocs
!= 0
5855 && (h
->root
.type
== bfd_link_hash_defweak
5856 || !h
->def_regular
))
5858 mips_elf_allocate_dynamic_relocations (dynobj
,
5859 hmips
->possibly_dynamic_relocs
);
5860 if (hmips
->readonly_reloc
)
5861 /* We tell the dynamic linker that there are relocations
5862 against the text segment. */
5863 info
->flags
|= DF_TEXTREL
;
5866 /* For a function, create a stub, if allowed. */
5867 if (! hmips
->no_fn_stub
5870 if (! elf_hash_table (info
)->dynamic_sections_created
)
5873 /* If this symbol is not defined in a regular file, then set
5874 the symbol to the stub location. This is required to make
5875 function pointers compare as equal between the normal
5876 executable and the shared library. */
5877 if (!h
->def_regular
)
5879 /* We need .stub section. */
5880 s
= bfd_get_section_by_name (dynobj
,
5881 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
5882 BFD_ASSERT (s
!= NULL
);
5884 h
->root
.u
.def
.section
= s
;
5885 h
->root
.u
.def
.value
= s
->size
;
5887 /* XXX Write this stub address somewhere. */
5888 h
->plt
.offset
= s
->size
;
5890 /* Make room for this stub code. */
5891 s
->size
+= MIPS_FUNCTION_STUB_SIZE
;
5893 /* The last half word of the stub will be filled with the index
5894 of this symbol in .dynsym section. */
5898 else if ((h
->type
== STT_FUNC
)
5901 /* This will set the entry for this symbol in the GOT to 0, and
5902 the dynamic linker will take care of this. */
5903 h
->root
.u
.def
.value
= 0;
5907 /* If this is a weak symbol, and there is a real definition, the
5908 processor independent code will have arranged for us to see the
5909 real definition first, and we can just use the same value. */
5910 if (h
->u
.weakdef
!= NULL
)
5912 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
5913 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
5914 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
5915 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
5919 /* This is a reference to a symbol defined by a dynamic object which
5920 is not a function. */
5925 /* This function is called after all the input files have been read,
5926 and the input sections have been assigned to output sections. We
5927 check for any mips16 stub sections that we can discard. */
5930 _bfd_mips_elf_always_size_sections (bfd
*output_bfd
,
5931 struct bfd_link_info
*info
)
5937 struct mips_got_info
*g
;
5939 bfd_size_type loadable_size
= 0;
5940 bfd_size_type local_gotno
;
5943 /* The .reginfo section has a fixed size. */
5944 ri
= bfd_get_section_by_name (output_bfd
, ".reginfo");
5946 bfd_set_section_size (output_bfd
, ri
, sizeof (Elf32_External_RegInfo
));
5948 if (! (info
->relocatable
5949 || ! mips_elf_hash_table (info
)->mips16_stubs_seen
))
5950 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
5951 mips_elf_check_mips16_stubs
, NULL
);
5953 dynobj
= elf_hash_table (info
)->dynobj
;
5955 /* Relocatable links don't have it. */
5958 g
= mips_elf_got_info (dynobj
, &s
);
5962 /* Calculate the total loadable size of the output. That
5963 will give us the maximum number of GOT_PAGE entries
5965 for (sub
= info
->input_bfds
; sub
; sub
= sub
->link_next
)
5967 asection
*subsection
;
5969 for (subsection
= sub
->sections
;
5971 subsection
= subsection
->next
)
5973 if ((subsection
->flags
& SEC_ALLOC
) == 0)
5975 loadable_size
+= ((subsection
->size
+ 0xf)
5976 &~ (bfd_size_type
) 0xf);
5980 /* There has to be a global GOT entry for every symbol with
5981 a dynamic symbol table index of DT_MIPS_GOTSYM or
5982 higher. Therefore, it make sense to put those symbols
5983 that need GOT entries at the end of the symbol table. We
5985 if (! mips_elf_sort_hash_table (info
, 1))
5988 if (g
->global_gotsym
!= NULL
)
5989 i
= elf_hash_table (info
)->dynsymcount
- g
->global_gotsym
->dynindx
;
5991 /* If there are no global symbols, or none requiring
5992 relocations, then GLOBAL_GOTSYM will be NULL. */
5995 /* In the worst case, we'll get one stub per dynamic symbol, plus
5996 one to account for the dummy entry at the end required by IRIX
5998 loadable_size
+= MIPS_FUNCTION_STUB_SIZE
* (i
+ 1);
6000 /* Assume there are two loadable segments consisting of
6001 contiguous sections. Is 5 enough? */
6002 local_gotno
= (loadable_size
>> 16) + 5;
6004 g
->local_gotno
+= local_gotno
;
6005 s
->size
+= g
->local_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
6007 g
->global_gotno
= i
;
6008 s
->size
+= i
* MIPS_ELF_GOT_SIZE (output_bfd
);
6010 if (s
->size
> MIPS_ELF_GOT_MAX_SIZE (output_bfd
)
6011 && ! mips_elf_multi_got (output_bfd
, info
, g
, s
, local_gotno
))
6017 /* Set the sizes of the dynamic sections. */
6020 _bfd_mips_elf_size_dynamic_sections (bfd
*output_bfd
,
6021 struct bfd_link_info
*info
)
6025 bfd_boolean reltext
;
6027 dynobj
= elf_hash_table (info
)->dynobj
;
6028 BFD_ASSERT (dynobj
!= NULL
);
6030 if (elf_hash_table (info
)->dynamic_sections_created
)
6032 /* Set the contents of the .interp section to the interpreter. */
6033 if (info
->executable
)
6035 s
= bfd_get_section_by_name (dynobj
, ".interp");
6036 BFD_ASSERT (s
!= NULL
);
6038 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd
)) + 1;
6040 = (bfd_byte
*) ELF_DYNAMIC_INTERPRETER (output_bfd
);
6044 /* The check_relocs and adjust_dynamic_symbol entry points have
6045 determined the sizes of the various dynamic sections. Allocate
6048 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
6053 /* It's OK to base decisions on the section name, because none
6054 of the dynobj section names depend upon the input files. */
6055 name
= bfd_get_section_name (dynobj
, s
);
6057 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
6062 if (strncmp (name
, ".rel", 4) == 0)
6066 /* We only strip the section if the output section name
6067 has the same name. Otherwise, there might be several
6068 input sections for this output section. FIXME: This
6069 code is probably not needed these days anyhow, since
6070 the linker now does not create empty output sections. */
6071 if (s
->output_section
!= NULL
6073 bfd_get_section_name (s
->output_section
->owner
,
6074 s
->output_section
)) == 0)
6079 const char *outname
;
6082 /* If this relocation section applies to a read only
6083 section, then we probably need a DT_TEXTREL entry.
6084 If the relocation section is .rel.dyn, we always
6085 assert a DT_TEXTREL entry rather than testing whether
6086 there exists a relocation to a read only section or
6088 outname
= bfd_get_section_name (output_bfd
,
6090 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
6092 && (target
->flags
& SEC_READONLY
) != 0
6093 && (target
->flags
& SEC_ALLOC
) != 0)
6094 || strcmp (outname
, ".rel.dyn") == 0)
6097 /* We use the reloc_count field as a counter if we need
6098 to copy relocs into the output file. */
6099 if (strcmp (name
, ".rel.dyn") != 0)
6102 /* If combreloc is enabled, elf_link_sort_relocs() will
6103 sort relocations, but in a different way than we do,
6104 and before we're done creating relocations. Also, it
6105 will move them around between input sections'
6106 relocation's contents, so our sorting would be
6107 broken, so don't let it run. */
6108 info
->combreloc
= 0;
6111 else if (strncmp (name
, ".got", 4) == 0)
6113 /* _bfd_mips_elf_always_size_sections() has already done
6114 most of the work, but some symbols may have been mapped
6115 to versions that we must now resolve in the got_entries
6117 struct mips_got_info
*gg
= mips_elf_got_info (dynobj
, NULL
);
6118 struct mips_got_info
*g
= gg
;
6119 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
6120 unsigned int needed_relocs
= 0;
6124 set_got_offset_arg
.value
= MIPS_ELF_GOT_SIZE (output_bfd
);
6125 set_got_offset_arg
.info
= info
;
6127 mips_elf_resolve_final_got_entries (gg
);
6128 for (g
= gg
->next
; g
&& g
->next
!= gg
; g
= g
->next
)
6130 unsigned int save_assign
;
6132 mips_elf_resolve_final_got_entries (g
);
6134 /* Assign offsets to global GOT entries. */
6135 save_assign
= g
->assigned_gotno
;
6136 g
->assigned_gotno
= g
->local_gotno
;
6137 set_got_offset_arg
.g
= g
;
6138 set_got_offset_arg
.needed_relocs
= 0;
6139 htab_traverse (g
->got_entries
,
6140 mips_elf_set_global_got_offset
,
6141 &set_got_offset_arg
);
6142 needed_relocs
+= set_got_offset_arg
.needed_relocs
;
6143 BFD_ASSERT (g
->assigned_gotno
- g
->local_gotno
6144 <= g
->global_gotno
);
6146 g
->assigned_gotno
= save_assign
;
6149 needed_relocs
+= g
->local_gotno
- g
->assigned_gotno
;
6150 BFD_ASSERT (g
->assigned_gotno
== g
->next
->local_gotno
6151 + g
->next
->global_gotno
6152 + MIPS_RESERVED_GOTNO
);
6157 mips_elf_allocate_dynamic_relocations (dynobj
, needed_relocs
);
6160 else if (strcmp (name
, MIPS_ELF_STUB_SECTION_NAME (output_bfd
)) == 0)
6162 /* IRIX rld assumes that the function stub isn't at the end
6163 of .text section. So put a dummy. XXX */
6164 s
->size
+= MIPS_FUNCTION_STUB_SIZE
;
6166 else if (! info
->shared
6167 && ! mips_elf_hash_table (info
)->use_rld_obj_head
6168 && strncmp (name
, ".rld_map", 8) == 0)
6170 /* We add a room for __rld_map. It will be filled in by the
6171 rtld to contain a pointer to the _r_debug structure. */
6174 else if (SGI_COMPAT (output_bfd
)
6175 && strncmp (name
, ".compact_rel", 12) == 0)
6176 s
->size
+= mips_elf_hash_table (info
)->compact_rel_size
;
6177 else if (strncmp (name
, ".init", 5) != 0)
6179 /* It's not one of our sections, so don't allocate space. */
6185 _bfd_strip_section_from_output (info
, s
);
6189 /* Allocate memory for the section contents. */
6190 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
6191 if (s
->contents
== NULL
&& s
->size
!= 0)
6193 bfd_set_error (bfd_error_no_memory
);
6198 if (elf_hash_table (info
)->dynamic_sections_created
)
6200 /* Add some entries to the .dynamic section. We fill in the
6201 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
6202 must add the entries now so that we get the correct size for
6203 the .dynamic section. The DT_DEBUG entry is filled in by the
6204 dynamic linker and used by the debugger. */
6207 /* SGI object has the equivalence of DT_DEBUG in the
6208 DT_MIPS_RLD_MAP entry. */
6209 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_MAP
, 0))
6211 if (!SGI_COMPAT (output_bfd
))
6213 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
6219 /* Shared libraries on traditional mips have DT_DEBUG. */
6220 if (!SGI_COMPAT (output_bfd
))
6222 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
6227 if (reltext
&& SGI_COMPAT (output_bfd
))
6228 info
->flags
|= DF_TEXTREL
;
6230 if ((info
->flags
& DF_TEXTREL
) != 0)
6232 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_TEXTREL
, 0))
6236 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTGOT
, 0))
6239 if (mips_elf_rel_dyn_section (dynobj
, FALSE
))
6241 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_REL
, 0))
6244 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELSZ
, 0))
6247 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELENT
, 0))
6251 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_VERSION
, 0))
6254 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_FLAGS
, 0))
6258 /* Time stamps in executable files are a bad idea. */
6259 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_TIME_STAMP
, 0))
6264 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_ICHECKSUM
, 0))
6269 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_IVERSION
, 0))
6273 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_BASE_ADDRESS
, 0))
6276 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LOCAL_GOTNO
, 0))
6279 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_SYMTABNO
, 0))
6282 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_UNREFEXTNO
, 0))
6285 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_GOTSYM
, 0))
6288 if (IRIX_COMPAT (dynobj
) == ict_irix5
6289 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_HIPAGENO
, 0))
6292 if (IRIX_COMPAT (dynobj
) == ict_irix6
6293 && (bfd_get_section_by_name
6294 (dynobj
, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj
)))
6295 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_OPTIONS
, 0))
6302 /* Relocate a MIPS ELF section. */
6305 _bfd_mips_elf_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
6306 bfd
*input_bfd
, asection
*input_section
,
6307 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
6308 Elf_Internal_Sym
*local_syms
,
6309 asection
**local_sections
)
6311 Elf_Internal_Rela
*rel
;
6312 const Elf_Internal_Rela
*relend
;
6314 bfd_boolean use_saved_addend_p
= FALSE
;
6315 const struct elf_backend_data
*bed
;
6317 bed
= get_elf_backend_data (output_bfd
);
6318 relend
= relocs
+ input_section
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
6319 for (rel
= relocs
; rel
< relend
; ++rel
)
6323 reloc_howto_type
*howto
;
6324 bfd_boolean require_jalx
;
6325 /* TRUE if the relocation is a RELA relocation, rather than a
6327 bfd_boolean rela_relocation_p
= TRUE
;
6328 unsigned int r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
6331 /* Find the relocation howto for this relocation. */
6332 if (r_type
== R_MIPS_64
&& ! NEWABI_P (input_bfd
))
6334 /* Some 32-bit code uses R_MIPS_64. In particular, people use
6335 64-bit code, but make sure all their addresses are in the
6336 lowermost or uppermost 32-bit section of the 64-bit address
6337 space. Thus, when they use an R_MIPS_64 they mean what is
6338 usually meant by R_MIPS_32, with the exception that the
6339 stored value is sign-extended to 64 bits. */
6340 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, R_MIPS_32
, FALSE
);
6342 /* On big-endian systems, we need to lie about the position
6344 if (bfd_big_endian (input_bfd
))
6348 /* NewABI defaults to RELA relocations. */
6349 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, r_type
,
6350 NEWABI_P (input_bfd
)
6351 && (MIPS_RELOC_RELA_P
6352 (input_bfd
, input_section
,
6355 if (!use_saved_addend_p
)
6357 Elf_Internal_Shdr
*rel_hdr
;
6359 /* If these relocations were originally of the REL variety,
6360 we must pull the addend out of the field that will be
6361 relocated. Otherwise, we simply use the contents of the
6362 RELA relocation. To determine which flavor or relocation
6363 this is, we depend on the fact that the INPUT_SECTION's
6364 REL_HDR is read before its REL_HDR2. */
6365 rel_hdr
= &elf_section_data (input_section
)->rel_hdr
;
6366 if ((size_t) (rel
- relocs
)
6367 >= (NUM_SHDR_ENTRIES (rel_hdr
) * bed
->s
->int_rels_per_ext_rel
))
6368 rel_hdr
= elf_section_data (input_section
)->rel_hdr2
;
6369 if (rel_hdr
->sh_entsize
== MIPS_ELF_REL_SIZE (input_bfd
))
6371 bfd_byte
*location
= contents
+ rel
->r_offset
;
6373 /* Note that this is a REL relocation. */
6374 rela_relocation_p
= FALSE
;
6376 /* Get the addend, which is stored in the input file. */
6377 _bfd_mips16_elf_reloc_unshuffle (input_bfd
, r_type
, FALSE
,
6379 addend
= mips_elf_obtain_contents (howto
, rel
, input_bfd
,
6381 _bfd_mips16_elf_reloc_shuffle(input_bfd
, r_type
, FALSE
,
6384 addend
&= howto
->src_mask
;
6386 /* For some kinds of relocations, the ADDEND is a
6387 combination of the addend stored in two different
6389 if (r_type
== R_MIPS_HI16
|| r_type
== R_MIPS16_HI16
6390 || (r_type
== R_MIPS_GOT16
6391 && mips_elf_local_relocation_p (input_bfd
, rel
,
6392 local_sections
, FALSE
)))
6395 const Elf_Internal_Rela
*lo16_relocation
;
6396 reloc_howto_type
*lo16_howto
;
6397 bfd_byte
*lo16_location
;
6400 if (r_type
== R_MIPS16_HI16
)
6401 lo16_type
= R_MIPS16_LO16
;
6403 lo16_type
= R_MIPS_LO16
;
6405 /* The combined value is the sum of the HI16 addend,
6406 left-shifted by sixteen bits, and the LO16
6407 addend, sign extended. (Usually, the code does
6408 a `lui' of the HI16 value, and then an `addiu' of
6411 Scan ahead to find a matching LO16 relocation.
6413 According to the MIPS ELF ABI, the R_MIPS_LO16
6414 relocation must be immediately following.
6415 However, for the IRIX6 ABI, the next relocation
6416 may be a composed relocation consisting of
6417 several relocations for the same address. In
6418 that case, the R_MIPS_LO16 relocation may occur
6419 as one of these. We permit a similar extension
6420 in general, as that is useful for GCC. */
6421 lo16_relocation
= mips_elf_next_relocation (input_bfd
,
6424 if (lo16_relocation
== NULL
)
6427 lo16_location
= contents
+ lo16_relocation
->r_offset
;
6429 /* Obtain the addend kept there. */
6430 lo16_howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
,
6432 _bfd_mips16_elf_reloc_unshuffle (input_bfd
, lo16_type
, FALSE
,
6434 l
= mips_elf_obtain_contents (lo16_howto
, lo16_relocation
,
6435 input_bfd
, contents
);
6436 _bfd_mips16_elf_reloc_shuffle (input_bfd
, lo16_type
, FALSE
,
6438 l
&= lo16_howto
->src_mask
;
6439 l
<<= lo16_howto
->rightshift
;
6440 l
= _bfd_mips_elf_sign_extend (l
, 16);
6444 /* Compute the combined addend. */
6448 addend
<<= howto
->rightshift
;
6451 addend
= rel
->r_addend
;
6454 if (info
->relocatable
)
6456 Elf_Internal_Sym
*sym
;
6457 unsigned long r_symndx
;
6459 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
)
6460 && bfd_big_endian (input_bfd
))
6463 /* Since we're just relocating, all we need to do is copy
6464 the relocations back out to the object file, unless
6465 they're against a section symbol, in which case we need
6466 to adjust by the section offset, or unless they're GP
6467 relative in which case we need to adjust by the amount
6468 that we're adjusting GP in this relocatable object. */
6470 if (! mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
,
6472 /* There's nothing to do for non-local relocations. */
6475 if (r_type
== R_MIPS16_GPREL
6476 || r_type
== R_MIPS_GPREL16
6477 || r_type
== R_MIPS_GPREL32
6478 || r_type
== R_MIPS_LITERAL
)
6479 addend
-= (_bfd_get_gp_value (output_bfd
)
6480 - _bfd_get_gp_value (input_bfd
));
6482 r_symndx
= ELF_R_SYM (output_bfd
, rel
->r_info
);
6483 sym
= local_syms
+ r_symndx
;
6484 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6485 /* Adjust the addend appropriately. */
6486 addend
+= local_sections
[r_symndx
]->output_offset
;
6488 if (rela_relocation_p
)
6489 /* If this is a RELA relocation, just update the addend. */
6490 rel
->r_addend
= addend
;
6493 if (r_type
== R_MIPS_HI16
6494 || r_type
== R_MIPS_GOT16
)
6495 addend
= mips_elf_high (addend
);
6496 else if (r_type
== R_MIPS_HIGHER
)
6497 addend
= mips_elf_higher (addend
);
6498 else if (r_type
== R_MIPS_HIGHEST
)
6499 addend
= mips_elf_highest (addend
);
6501 addend
>>= howto
->rightshift
;
6503 /* We use the source mask, rather than the destination
6504 mask because the place to which we are writing will be
6505 source of the addend in the final link. */
6506 addend
&= howto
->src_mask
;
6508 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
6509 /* See the comment above about using R_MIPS_64 in the 32-bit
6510 ABI. Here, we need to update the addend. It would be
6511 possible to get away with just using the R_MIPS_32 reloc
6512 but for endianness. */
6518 if (addend
& ((bfd_vma
) 1 << 31))
6520 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
6527 /* If we don't know that we have a 64-bit type,
6528 do two separate stores. */
6529 if (bfd_big_endian (input_bfd
))
6531 /* Store the sign-bits (which are most significant)
6533 low_bits
= sign_bits
;
6539 high_bits
= sign_bits
;
6541 bfd_put_32 (input_bfd
, low_bits
,
6542 contents
+ rel
->r_offset
);
6543 bfd_put_32 (input_bfd
, high_bits
,
6544 contents
+ rel
->r_offset
+ 4);
6548 if (! mips_elf_perform_relocation (info
, howto
, rel
, addend
,
6549 input_bfd
, input_section
,
6554 /* Go on to the next relocation. */
6558 /* In the N32 and 64-bit ABIs there may be multiple consecutive
6559 relocations for the same offset. In that case we are
6560 supposed to treat the output of each relocation as the addend
6562 if (rel
+ 1 < relend
6563 && rel
->r_offset
== rel
[1].r_offset
6564 && ELF_R_TYPE (input_bfd
, rel
[1].r_info
) != R_MIPS_NONE
)
6565 use_saved_addend_p
= TRUE
;
6567 use_saved_addend_p
= FALSE
;
6569 /* Figure out what value we are supposed to relocate. */
6570 switch (mips_elf_calculate_relocation (output_bfd
, input_bfd
,
6571 input_section
, info
, rel
,
6572 addend
, howto
, local_syms
,
6573 local_sections
, &value
,
6574 &name
, &require_jalx
,
6575 use_saved_addend_p
))
6577 case bfd_reloc_continue
:
6578 /* There's nothing to do. */
6581 case bfd_reloc_undefined
:
6582 /* mips_elf_calculate_relocation already called the
6583 undefined_symbol callback. There's no real point in
6584 trying to perform the relocation at this point, so we
6585 just skip ahead to the next relocation. */
6588 case bfd_reloc_notsupported
:
6589 msg
= _("internal error: unsupported relocation error");
6590 info
->callbacks
->warning
6591 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
6594 case bfd_reloc_overflow
:
6595 if (use_saved_addend_p
)
6596 /* Ignore overflow until we reach the last relocation for
6597 a given location. */
6601 BFD_ASSERT (name
!= NULL
);
6602 if (! ((*info
->callbacks
->reloc_overflow
)
6603 (info
, NULL
, name
, howto
->name
, (bfd_vma
) 0,
6604 input_bfd
, input_section
, rel
->r_offset
)))
6617 /* If we've got another relocation for the address, keep going
6618 until we reach the last one. */
6619 if (use_saved_addend_p
)
6625 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
6626 /* See the comment above about using R_MIPS_64 in the 32-bit
6627 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
6628 that calculated the right value. Now, however, we
6629 sign-extend the 32-bit result to 64-bits, and store it as a
6630 64-bit value. We are especially generous here in that we
6631 go to extreme lengths to support this usage on systems with
6632 only a 32-bit VMA. */
6638 if (value
& ((bfd_vma
) 1 << 31))
6640 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
6647 /* If we don't know that we have a 64-bit type,
6648 do two separate stores. */
6649 if (bfd_big_endian (input_bfd
))
6651 /* Undo what we did above. */
6653 /* Store the sign-bits (which are most significant)
6655 low_bits
= sign_bits
;
6661 high_bits
= sign_bits
;
6663 bfd_put_32 (input_bfd
, low_bits
,
6664 contents
+ rel
->r_offset
);
6665 bfd_put_32 (input_bfd
, high_bits
,
6666 contents
+ rel
->r_offset
+ 4);
6670 /* Actually perform the relocation. */
6671 if (! mips_elf_perform_relocation (info
, howto
, rel
, value
,
6672 input_bfd
, input_section
,
6673 contents
, require_jalx
))
6680 /* If NAME is one of the special IRIX6 symbols defined by the linker,
6681 adjust it appropriately now. */
6684 mips_elf_irix6_finish_dynamic_symbol (bfd
*abfd ATTRIBUTE_UNUSED
,
6685 const char *name
, Elf_Internal_Sym
*sym
)
6687 /* The linker script takes care of providing names and values for
6688 these, but we must place them into the right sections. */
6689 static const char* const text_section_symbols
[] = {
6692 "__dso_displacement",
6694 "__program_header_table",
6698 static const char* const data_section_symbols
[] = {
6706 const char* const *p
;
6709 for (i
= 0; i
< 2; ++i
)
6710 for (p
= (i
== 0) ? text_section_symbols
: data_section_symbols
;
6713 if (strcmp (*p
, name
) == 0)
6715 /* All of these symbols are given type STT_SECTION by the
6717 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6718 sym
->st_other
= STO_PROTECTED
;
6720 /* The IRIX linker puts these symbols in special sections. */
6722 sym
->st_shndx
= SHN_MIPS_TEXT
;
6724 sym
->st_shndx
= SHN_MIPS_DATA
;
6730 /* Finish up dynamic symbol handling. We set the contents of various
6731 dynamic sections here. */
6734 _bfd_mips_elf_finish_dynamic_symbol (bfd
*output_bfd
,
6735 struct bfd_link_info
*info
,
6736 struct elf_link_hash_entry
*h
,
6737 Elf_Internal_Sym
*sym
)
6741 struct mips_got_info
*g
, *gg
;
6744 dynobj
= elf_hash_table (info
)->dynobj
;
6746 if (h
->plt
.offset
!= MINUS_ONE
)
6749 bfd_byte stub
[MIPS_FUNCTION_STUB_SIZE
];
6751 /* This symbol has a stub. Set it up. */
6753 BFD_ASSERT (h
->dynindx
!= -1);
6755 s
= bfd_get_section_by_name (dynobj
,
6756 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
6757 BFD_ASSERT (s
!= NULL
);
6759 /* FIXME: Can h->dynindex be more than 64K? */
6760 if (h
->dynindx
& 0xffff0000)
6763 /* Fill the stub. */
6764 bfd_put_32 (output_bfd
, STUB_LW (output_bfd
), stub
);
6765 bfd_put_32 (output_bfd
, STUB_MOVE (output_bfd
), stub
+ 4);
6766 bfd_put_32 (output_bfd
, STUB_JALR
, stub
+ 8);
6767 bfd_put_32 (output_bfd
, STUB_LI16 (output_bfd
) + h
->dynindx
, stub
+ 12);
6769 BFD_ASSERT (h
->plt
.offset
<= s
->size
);
6770 memcpy (s
->contents
+ h
->plt
.offset
, stub
, MIPS_FUNCTION_STUB_SIZE
);
6772 /* Mark the symbol as undefined. plt.offset != -1 occurs
6773 only for the referenced symbol. */
6774 sym
->st_shndx
= SHN_UNDEF
;
6776 /* The run-time linker uses the st_value field of the symbol
6777 to reset the global offset table entry for this external
6778 to its stub address when unlinking a shared object. */
6779 sym
->st_value
= (s
->output_section
->vma
+ s
->output_offset
6783 BFD_ASSERT (h
->dynindx
!= -1
6784 || h
->forced_local
);
6786 sgot
= mips_elf_got_section (dynobj
, FALSE
);
6787 BFD_ASSERT (sgot
!= NULL
);
6788 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
6789 g
= mips_elf_section_data (sgot
)->u
.got_info
;
6790 BFD_ASSERT (g
!= NULL
);
6792 /* Run through the global symbol table, creating GOT entries for all
6793 the symbols that need them. */
6794 if (g
->global_gotsym
!= NULL
6795 && h
->dynindx
>= g
->global_gotsym
->dynindx
)
6800 value
= sym
->st_value
;
6801 offset
= mips_elf_global_got_index (dynobj
, output_bfd
, h
);
6802 MIPS_ELF_PUT_WORD (output_bfd
, value
, sgot
->contents
+ offset
);
6805 if (g
->next
&& h
->dynindx
!= -1)
6807 struct mips_got_entry e
, *p
;
6813 e
.abfd
= output_bfd
;
6815 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
6817 for (g
= g
->next
; g
->next
!= gg
; g
= g
->next
)
6820 && (p
= (struct mips_got_entry
*) htab_find (g
->got_entries
,
6825 || (elf_hash_table (info
)->dynamic_sections_created
6827 && p
->d
.h
->root
.def_dynamic
6828 && !p
->d
.h
->root
.def_regular
))
6830 /* Create an R_MIPS_REL32 relocation for this entry. Due to
6831 the various compatibility problems, it's easier to mock
6832 up an R_MIPS_32 or R_MIPS_64 relocation and leave
6833 mips_elf_create_dynamic_relocation to calculate the
6834 appropriate addend. */
6835 Elf_Internal_Rela rel
[3];
6837 memset (rel
, 0, sizeof (rel
));
6838 if (ABI_64_P (output_bfd
))
6839 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_64
);
6841 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_32
);
6842 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
6845 if (! (mips_elf_create_dynamic_relocation
6846 (output_bfd
, info
, rel
,
6847 e
.d
.h
, NULL
, sym
->st_value
, &entry
, sgot
)))
6851 entry
= sym
->st_value
;
6852 MIPS_ELF_PUT_WORD (output_bfd
, entry
, sgot
->contents
+ offset
);
6857 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
6858 name
= h
->root
.root
.string
;
6859 if (strcmp (name
, "_DYNAMIC") == 0
6860 || strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
6861 sym
->st_shndx
= SHN_ABS
;
6862 else if (strcmp (name
, "_DYNAMIC_LINK") == 0
6863 || strcmp (name
, "_DYNAMIC_LINKING") == 0)
6865 sym
->st_shndx
= SHN_ABS
;
6866 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6869 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (output_bfd
))
6871 sym
->st_shndx
= SHN_ABS
;
6872 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6873 sym
->st_value
= elf_gp (output_bfd
);
6875 else if (SGI_COMPAT (output_bfd
))
6877 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
6878 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
6880 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6881 sym
->st_other
= STO_PROTECTED
;
6883 sym
->st_shndx
= SHN_MIPS_DATA
;
6885 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
6887 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6888 sym
->st_other
= STO_PROTECTED
;
6889 sym
->st_value
= mips_elf_hash_table (info
)->procedure_count
;
6890 sym
->st_shndx
= SHN_ABS
;
6892 else if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
!= SHN_ABS
)
6894 if (h
->type
== STT_FUNC
)
6895 sym
->st_shndx
= SHN_MIPS_TEXT
;
6896 else if (h
->type
== STT_OBJECT
)
6897 sym
->st_shndx
= SHN_MIPS_DATA
;
6901 /* Handle the IRIX6-specific symbols. */
6902 if (IRIX_COMPAT (output_bfd
) == ict_irix6
)
6903 mips_elf_irix6_finish_dynamic_symbol (output_bfd
, name
, sym
);
6907 if (! mips_elf_hash_table (info
)->use_rld_obj_head
6908 && (strcmp (name
, "__rld_map") == 0
6909 || strcmp (name
, "__RLD_MAP") == 0))
6911 asection
*s
= bfd_get_section_by_name (dynobj
, ".rld_map");
6912 BFD_ASSERT (s
!= NULL
);
6913 sym
->st_value
= s
->output_section
->vma
+ s
->output_offset
;
6914 bfd_put_32 (output_bfd
, 0, s
->contents
);
6915 if (mips_elf_hash_table (info
)->rld_value
== 0)
6916 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
6918 else if (mips_elf_hash_table (info
)->use_rld_obj_head
6919 && strcmp (name
, "__rld_obj_head") == 0)
6921 /* IRIX6 does not use a .rld_map section. */
6922 if (IRIX_COMPAT (output_bfd
) == ict_irix5
6923 || IRIX_COMPAT (output_bfd
) == ict_none
)
6924 BFD_ASSERT (bfd_get_section_by_name (dynobj
, ".rld_map")
6926 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
6930 /* If this is a mips16 symbol, force the value to be even. */
6931 if (sym
->st_other
== STO_MIPS16
)
6932 sym
->st_value
&= ~1;
6937 /* Finish up the dynamic sections. */
6940 _bfd_mips_elf_finish_dynamic_sections (bfd
*output_bfd
,
6941 struct bfd_link_info
*info
)
6946 struct mips_got_info
*gg
, *g
;
6948 dynobj
= elf_hash_table (info
)->dynobj
;
6950 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
6952 sgot
= mips_elf_got_section (dynobj
, FALSE
);
6957 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
6958 gg
= mips_elf_section_data (sgot
)->u
.got_info
;
6959 BFD_ASSERT (gg
!= NULL
);
6960 g
= mips_elf_got_for_ibfd (gg
, output_bfd
);
6961 BFD_ASSERT (g
!= NULL
);
6964 if (elf_hash_table (info
)->dynamic_sections_created
)
6968 BFD_ASSERT (sdyn
!= NULL
);
6969 BFD_ASSERT (g
!= NULL
);
6971 for (b
= sdyn
->contents
;
6972 b
< sdyn
->contents
+ sdyn
->size
;
6973 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
6975 Elf_Internal_Dyn dyn
;
6979 bfd_boolean swap_out_p
;
6981 /* Read in the current dynamic entry. */
6982 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
6984 /* Assume that we're going to modify it and write it out. */
6990 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
6991 BFD_ASSERT (s
!= NULL
);
6992 dyn
.d_un
.d_val
= MIPS_ELF_REL_SIZE (dynobj
);
6996 /* Rewrite DT_STRSZ. */
6998 _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
7003 s
= bfd_get_section_by_name (output_bfd
, name
);
7004 BFD_ASSERT (s
!= NULL
);
7005 dyn
.d_un
.d_ptr
= s
->vma
;
7008 case DT_MIPS_RLD_VERSION
:
7009 dyn
.d_un
.d_val
= 1; /* XXX */
7013 dyn
.d_un
.d_val
= RHF_NOTPOT
; /* XXX */
7016 case DT_MIPS_TIME_STAMP
:
7017 time ((time_t *) &dyn
.d_un
.d_val
);
7020 case DT_MIPS_ICHECKSUM
:
7025 case DT_MIPS_IVERSION
:
7030 case DT_MIPS_BASE_ADDRESS
:
7031 s
= output_bfd
->sections
;
7032 BFD_ASSERT (s
!= NULL
);
7033 dyn
.d_un
.d_ptr
= s
->vma
& ~(bfd_vma
) 0xffff;
7036 case DT_MIPS_LOCAL_GOTNO
:
7037 dyn
.d_un
.d_val
= g
->local_gotno
;
7040 case DT_MIPS_UNREFEXTNO
:
7041 /* The index into the dynamic symbol table which is the
7042 entry of the first external symbol that is not
7043 referenced within the same object. */
7044 dyn
.d_un
.d_val
= bfd_count_sections (output_bfd
) + 1;
7047 case DT_MIPS_GOTSYM
:
7048 if (gg
->global_gotsym
)
7050 dyn
.d_un
.d_val
= gg
->global_gotsym
->dynindx
;
7053 /* In case if we don't have global got symbols we default
7054 to setting DT_MIPS_GOTSYM to the same value as
7055 DT_MIPS_SYMTABNO, so we just fall through. */
7057 case DT_MIPS_SYMTABNO
:
7059 elemsize
= MIPS_ELF_SYM_SIZE (output_bfd
);
7060 s
= bfd_get_section_by_name (output_bfd
, name
);
7061 BFD_ASSERT (s
!= NULL
);
7063 dyn
.d_un
.d_val
= s
->size
/ elemsize
;
7066 case DT_MIPS_HIPAGENO
:
7067 dyn
.d_un
.d_val
= g
->local_gotno
- MIPS_RESERVED_GOTNO
;
7070 case DT_MIPS_RLD_MAP
:
7071 dyn
.d_un
.d_ptr
= mips_elf_hash_table (info
)->rld_value
;
7074 case DT_MIPS_OPTIONS
:
7075 s
= (bfd_get_section_by_name
7076 (output_bfd
, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd
)));
7077 dyn
.d_un
.d_ptr
= s
->vma
;
7081 /* Reduce DT_RELSZ to account for any relocations we
7082 decided not to make. This is for the n64 irix rld,
7083 which doesn't seem to apply any relocations if there
7084 are trailing null entries. */
7085 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
7086 dyn
.d_un
.d_val
= (s
->reloc_count
7087 * (ABI_64_P (output_bfd
)
7088 ? sizeof (Elf64_Mips_External_Rel
)
7089 : sizeof (Elf32_External_Rel
)));
7098 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
7103 /* The first entry of the global offset table will be filled at
7104 runtime. The second entry will be used by some runtime loaders.
7105 This isn't the case of IRIX rld. */
7106 if (sgot
!= NULL
&& sgot
->size
> 0)
7108 MIPS_ELF_PUT_WORD (output_bfd
, 0, sgot
->contents
);
7109 MIPS_ELF_PUT_WORD (output_bfd
, 0x80000000,
7110 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
7114 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
7115 = MIPS_ELF_GOT_SIZE (output_bfd
);
7117 /* Generate dynamic relocations for the non-primary gots. */
7118 if (gg
!= NULL
&& gg
->next
)
7120 Elf_Internal_Rela rel
[3];
7123 memset (rel
, 0, sizeof (rel
));
7124 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_REL32
);
7126 for (g
= gg
->next
; g
->next
!= gg
; g
= g
->next
)
7128 bfd_vma index
= g
->next
->local_gotno
+ g
->next
->global_gotno
;
7130 MIPS_ELF_PUT_WORD (output_bfd
, 0, sgot
->contents
7131 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
7132 MIPS_ELF_PUT_WORD (output_bfd
, 0x80000000, sgot
->contents
7133 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
7138 while (index
< g
->assigned_gotno
)
7140 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
7141 = index
++ * MIPS_ELF_GOT_SIZE (output_bfd
);
7142 if (!(mips_elf_create_dynamic_relocation
7143 (output_bfd
, info
, rel
, NULL
,
7144 bfd_abs_section_ptr
,
7147 BFD_ASSERT (addend
== 0);
7154 Elf32_compact_rel cpt
;
7156 if (SGI_COMPAT (output_bfd
))
7158 /* Write .compact_rel section out. */
7159 s
= bfd_get_section_by_name (dynobj
, ".compact_rel");
7163 cpt
.num
= s
->reloc_count
;
7165 cpt
.offset
= (s
->output_section
->filepos
7166 + sizeof (Elf32_External_compact_rel
));
7169 bfd_elf32_swap_compact_rel_out (output_bfd
, &cpt
,
7170 ((Elf32_External_compact_rel
*)
7173 /* Clean up a dummy stub function entry in .text. */
7174 s
= bfd_get_section_by_name (dynobj
,
7175 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
7178 file_ptr dummy_offset
;
7180 BFD_ASSERT (s
->size
>= MIPS_FUNCTION_STUB_SIZE
);
7181 dummy_offset
= s
->size
- MIPS_FUNCTION_STUB_SIZE
;
7182 memset (s
->contents
+ dummy_offset
, 0,
7183 MIPS_FUNCTION_STUB_SIZE
);
7188 /* We need to sort the entries of the dynamic relocation section. */
7190 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
7193 && s
->size
> (bfd_vma
)2 * MIPS_ELF_REL_SIZE (output_bfd
))
7195 reldyn_sorting_bfd
= output_bfd
;
7197 if (ABI_64_P (output_bfd
))
7198 qsort ((Elf64_External_Rel
*) s
->contents
+ 1, s
->reloc_count
- 1,
7199 sizeof (Elf64_Mips_External_Rel
), sort_dynamic_relocs_64
);
7201 qsort ((Elf32_External_Rel
*) s
->contents
+ 1, s
->reloc_count
- 1,
7202 sizeof (Elf32_External_Rel
), sort_dynamic_relocs
);
7210 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
7213 mips_set_isa_flags (bfd
*abfd
)
7217 switch (bfd_get_mach (abfd
))
7220 case bfd_mach_mips3000
:
7221 val
= E_MIPS_ARCH_1
;
7224 case bfd_mach_mips3900
:
7225 val
= E_MIPS_ARCH_1
| E_MIPS_MACH_3900
;
7228 case bfd_mach_mips6000
:
7229 val
= E_MIPS_ARCH_2
;
7232 case bfd_mach_mips4000
:
7233 case bfd_mach_mips4300
:
7234 case bfd_mach_mips4400
:
7235 case bfd_mach_mips4600
:
7236 val
= E_MIPS_ARCH_3
;
7239 case bfd_mach_mips4010
:
7240 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4010
;
7243 case bfd_mach_mips4100
:
7244 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4100
;
7247 case bfd_mach_mips4111
:
7248 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4111
;
7251 case bfd_mach_mips4120
:
7252 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4120
;
7255 case bfd_mach_mips4650
:
7256 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4650
;
7259 case bfd_mach_mips5400
:
7260 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5400
;
7263 case bfd_mach_mips5500
:
7264 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5500
;
7267 case bfd_mach_mips9000
:
7268 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_9000
;
7271 case bfd_mach_mips5000
:
7272 case bfd_mach_mips7000
:
7273 case bfd_mach_mips8000
:
7274 case bfd_mach_mips10000
:
7275 case bfd_mach_mips12000
:
7276 val
= E_MIPS_ARCH_4
;
7279 case bfd_mach_mips5
:
7280 val
= E_MIPS_ARCH_5
;
7283 case bfd_mach_mips_sb1
:
7284 val
= E_MIPS_ARCH_64
| E_MIPS_MACH_SB1
;
7287 case bfd_mach_mipsisa32
:
7288 val
= E_MIPS_ARCH_32
;
7291 case bfd_mach_mipsisa64
:
7292 val
= E_MIPS_ARCH_64
;
7295 case bfd_mach_mipsisa32r2
:
7296 val
= E_MIPS_ARCH_32R2
;
7299 case bfd_mach_mipsisa64r2
:
7300 val
= E_MIPS_ARCH_64R2
;
7303 elf_elfheader (abfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
7304 elf_elfheader (abfd
)->e_flags
|= val
;
7309 /* The final processing done just before writing out a MIPS ELF object
7310 file. This gets the MIPS architecture right based on the machine
7311 number. This is used by both the 32-bit and the 64-bit ABI. */
7314 _bfd_mips_elf_final_write_processing (bfd
*abfd
,
7315 bfd_boolean linker ATTRIBUTE_UNUSED
)
7318 Elf_Internal_Shdr
**hdrpp
;
7322 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
7323 is nonzero. This is for compatibility with old objects, which used
7324 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
7325 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_MACH
) == 0)
7326 mips_set_isa_flags (abfd
);
7328 /* Set the sh_info field for .gptab sections and other appropriate
7329 info for each special section. */
7330 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
7331 i
< elf_numsections (abfd
);
7334 switch ((*hdrpp
)->sh_type
)
7337 case SHT_MIPS_LIBLIST
:
7338 sec
= bfd_get_section_by_name (abfd
, ".dynstr");
7340 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7343 case SHT_MIPS_GPTAB
:
7344 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7345 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7346 BFD_ASSERT (name
!= NULL
7347 && strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0);
7348 sec
= bfd_get_section_by_name (abfd
, name
+ sizeof ".gptab" - 1);
7349 BFD_ASSERT (sec
!= NULL
);
7350 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
7353 case SHT_MIPS_CONTENT
:
7354 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7355 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7356 BFD_ASSERT (name
!= NULL
7357 && strncmp (name
, ".MIPS.content",
7358 sizeof ".MIPS.content" - 1) == 0);
7359 sec
= bfd_get_section_by_name (abfd
,
7360 name
+ sizeof ".MIPS.content" - 1);
7361 BFD_ASSERT (sec
!= NULL
);
7362 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7365 case SHT_MIPS_SYMBOL_LIB
:
7366 sec
= bfd_get_section_by_name (abfd
, ".dynsym");
7368 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7369 sec
= bfd_get_section_by_name (abfd
, ".liblist");
7371 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
7374 case SHT_MIPS_EVENTS
:
7375 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7376 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7377 BFD_ASSERT (name
!= NULL
);
7378 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0)
7379 sec
= bfd_get_section_by_name (abfd
,
7380 name
+ sizeof ".MIPS.events" - 1);
7383 BFD_ASSERT (strncmp (name
, ".MIPS.post_rel",
7384 sizeof ".MIPS.post_rel" - 1) == 0);
7385 sec
= bfd_get_section_by_name (abfd
,
7387 + sizeof ".MIPS.post_rel" - 1));
7389 BFD_ASSERT (sec
!= NULL
);
7390 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7397 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
7401 _bfd_mips_elf_additional_program_headers (bfd
*abfd
)
7406 /* See if we need a PT_MIPS_REGINFO segment. */
7407 s
= bfd_get_section_by_name (abfd
, ".reginfo");
7408 if (s
&& (s
->flags
& SEC_LOAD
))
7411 /* See if we need a PT_MIPS_OPTIONS segment. */
7412 if (IRIX_COMPAT (abfd
) == ict_irix6
7413 && bfd_get_section_by_name (abfd
,
7414 MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)))
7417 /* See if we need a PT_MIPS_RTPROC segment. */
7418 if (IRIX_COMPAT (abfd
) == ict_irix5
7419 && bfd_get_section_by_name (abfd
, ".dynamic")
7420 && bfd_get_section_by_name (abfd
, ".mdebug"))
7426 /* Modify the segment map for an IRIX5 executable. */
7429 _bfd_mips_elf_modify_segment_map (bfd
*abfd
,
7430 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
7433 struct elf_segment_map
*m
, **pm
;
7436 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
7438 s
= bfd_get_section_by_name (abfd
, ".reginfo");
7439 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
7441 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
7442 if (m
->p_type
== PT_MIPS_REGINFO
)
7447 m
= bfd_zalloc (abfd
, amt
);
7451 m
->p_type
= PT_MIPS_REGINFO
;
7455 /* We want to put it after the PHDR and INTERP segments. */
7456 pm
= &elf_tdata (abfd
)->segment_map
;
7458 && ((*pm
)->p_type
== PT_PHDR
7459 || (*pm
)->p_type
== PT_INTERP
))
7467 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
7468 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
7469 PT_MIPS_OPTIONS segment immediately following the program header
7472 /* On non-IRIX6 new abi, we'll have already created a segment
7473 for this section, so don't create another. I'm not sure this
7474 is not also the case for IRIX 6, but I can't test it right
7476 && IRIX_COMPAT (abfd
) == ict_irix6
)
7478 for (s
= abfd
->sections
; s
; s
= s
->next
)
7479 if (elf_section_data (s
)->this_hdr
.sh_type
== SHT_MIPS_OPTIONS
)
7484 struct elf_segment_map
*options_segment
;
7486 pm
= &elf_tdata (abfd
)->segment_map
;
7488 && ((*pm
)->p_type
== PT_PHDR
7489 || (*pm
)->p_type
== PT_INTERP
))
7492 amt
= sizeof (struct elf_segment_map
);
7493 options_segment
= bfd_zalloc (abfd
, amt
);
7494 options_segment
->next
= *pm
;
7495 options_segment
->p_type
= PT_MIPS_OPTIONS
;
7496 options_segment
->p_flags
= PF_R
;
7497 options_segment
->p_flags_valid
= TRUE
;
7498 options_segment
->count
= 1;
7499 options_segment
->sections
[0] = s
;
7500 *pm
= options_segment
;
7505 if (IRIX_COMPAT (abfd
) == ict_irix5
)
7507 /* If there are .dynamic and .mdebug sections, we make a room
7508 for the RTPROC header. FIXME: Rewrite without section names. */
7509 if (bfd_get_section_by_name (abfd
, ".interp") == NULL
7510 && bfd_get_section_by_name (abfd
, ".dynamic") != NULL
7511 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
7513 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
7514 if (m
->p_type
== PT_MIPS_RTPROC
)
7519 m
= bfd_zalloc (abfd
, amt
);
7523 m
->p_type
= PT_MIPS_RTPROC
;
7525 s
= bfd_get_section_by_name (abfd
, ".rtproc");
7530 m
->p_flags_valid
= 1;
7538 /* We want to put it after the DYNAMIC segment. */
7539 pm
= &elf_tdata (abfd
)->segment_map
;
7540 while (*pm
!= NULL
&& (*pm
)->p_type
!= PT_DYNAMIC
)
7550 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
7551 .dynstr, .dynsym, and .hash sections, and everything in
7553 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
;
7555 if ((*pm
)->p_type
== PT_DYNAMIC
)
7558 if (m
!= NULL
&& IRIX_COMPAT (abfd
) == ict_none
)
7560 /* For a normal mips executable the permissions for the PT_DYNAMIC
7561 segment are read, write and execute. We do that here since
7562 the code in elf.c sets only the read permission. This matters
7563 sometimes for the dynamic linker. */
7564 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
7566 m
->p_flags
= PF_R
| PF_W
| PF_X
;
7567 m
->p_flags_valid
= 1;
7571 && m
->count
== 1 && strcmp (m
->sections
[0]->name
, ".dynamic") == 0)
7573 static const char *sec_names
[] =
7575 ".dynamic", ".dynstr", ".dynsym", ".hash"
7579 struct elf_segment_map
*n
;
7583 for (i
= 0; i
< sizeof sec_names
/ sizeof sec_names
[0]; i
++)
7585 s
= bfd_get_section_by_name (abfd
, sec_names
[i
]);
7586 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
7593 if (high
< s
->vma
+ sz
)
7599 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
7600 if ((s
->flags
& SEC_LOAD
) != 0
7602 && s
->vma
+ s
->size
<= high
)
7605 amt
= sizeof *n
+ (bfd_size_type
) (c
- 1) * sizeof (asection
*);
7606 n
= bfd_zalloc (abfd
, amt
);
7613 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
7615 if ((s
->flags
& SEC_LOAD
) != 0
7617 && s
->vma
+ s
->size
<= high
)
7631 /* Return the section that should be marked against GC for a given
7635 _bfd_mips_elf_gc_mark_hook (asection
*sec
,
7636 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
7637 Elf_Internal_Rela
*rel
,
7638 struct elf_link_hash_entry
*h
,
7639 Elf_Internal_Sym
*sym
)
7641 /* ??? Do mips16 stub sections need to be handled special? */
7645 switch (ELF_R_TYPE (sec
->owner
, rel
->r_info
))
7647 case R_MIPS_GNU_VTINHERIT
:
7648 case R_MIPS_GNU_VTENTRY
:
7652 switch (h
->root
.type
)
7654 case bfd_link_hash_defined
:
7655 case bfd_link_hash_defweak
:
7656 return h
->root
.u
.def
.section
;
7658 case bfd_link_hash_common
:
7659 return h
->root
.u
.c
.p
->section
;
7667 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
7672 /* Update the got entry reference counts for the section being removed. */
7675 _bfd_mips_elf_gc_sweep_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
7676 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
7677 asection
*sec ATTRIBUTE_UNUSED
,
7678 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
)
7681 Elf_Internal_Shdr
*symtab_hdr
;
7682 struct elf_link_hash_entry
**sym_hashes
;
7683 bfd_signed_vma
*local_got_refcounts
;
7684 const Elf_Internal_Rela
*rel
, *relend
;
7685 unsigned long r_symndx
;
7686 struct elf_link_hash_entry
*h
;
7688 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7689 sym_hashes
= elf_sym_hashes (abfd
);
7690 local_got_refcounts
= elf_local_got_refcounts (abfd
);
7692 relend
= relocs
+ sec
->reloc_count
;
7693 for (rel
= relocs
; rel
< relend
; rel
++)
7694 switch (ELF_R_TYPE (abfd
, rel
->r_info
))
7698 case R_MIPS_CALL_HI16
:
7699 case R_MIPS_CALL_LO16
:
7700 case R_MIPS_GOT_HI16
:
7701 case R_MIPS_GOT_LO16
:
7702 case R_MIPS_GOT_DISP
:
7703 case R_MIPS_GOT_PAGE
:
7704 case R_MIPS_GOT_OFST
:
7705 /* ??? It would seem that the existing MIPS code does no sort
7706 of reference counting or whatnot on its GOT and PLT entries,
7707 so it is not possible to garbage collect them at this time. */
7718 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
7719 hiding the old indirect symbol. Process additional relocation
7720 information. Also called for weakdefs, in which case we just let
7721 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
7724 _bfd_mips_elf_copy_indirect_symbol (const struct elf_backend_data
*bed
,
7725 struct elf_link_hash_entry
*dir
,
7726 struct elf_link_hash_entry
*ind
)
7728 struct mips_elf_link_hash_entry
*dirmips
, *indmips
;
7730 _bfd_elf_link_hash_copy_indirect (bed
, dir
, ind
);
7732 if (ind
->root
.type
!= bfd_link_hash_indirect
)
7735 dirmips
= (struct mips_elf_link_hash_entry
*) dir
;
7736 indmips
= (struct mips_elf_link_hash_entry
*) ind
;
7737 dirmips
->possibly_dynamic_relocs
+= indmips
->possibly_dynamic_relocs
;
7738 if (indmips
->readonly_reloc
)
7739 dirmips
->readonly_reloc
= TRUE
;
7740 if (indmips
->no_fn_stub
)
7741 dirmips
->no_fn_stub
= TRUE
;
7745 _bfd_mips_elf_hide_symbol (struct bfd_link_info
*info
,
7746 struct elf_link_hash_entry
*entry
,
7747 bfd_boolean force_local
)
7751 struct mips_got_info
*g
;
7752 struct mips_elf_link_hash_entry
*h
;
7754 h
= (struct mips_elf_link_hash_entry
*) entry
;
7755 if (h
->forced_local
)
7757 h
->forced_local
= force_local
;
7759 dynobj
= elf_hash_table (info
)->dynobj
;
7760 if (dynobj
!= NULL
&& force_local
)
7762 got
= mips_elf_got_section (dynobj
, FALSE
);
7763 g
= mips_elf_section_data (got
)->u
.got_info
;
7767 struct mips_got_entry e
;
7768 struct mips_got_info
*gg
= g
;
7770 /* Since we're turning what used to be a global symbol into a
7771 local one, bump up the number of local entries of each GOT
7772 that had an entry for it. This will automatically decrease
7773 the number of global entries, since global_gotno is actually
7774 the upper limit of global entries. */
7779 for (g
= g
->next
; g
!= gg
; g
= g
->next
)
7780 if (htab_find (g
->got_entries
, &e
))
7782 BFD_ASSERT (g
->global_gotno
> 0);
7787 /* If this was a global symbol forced into the primary GOT, we
7788 no longer need an entry for it. We can't release the entry
7789 at this point, but we must at least stop counting it as one
7790 of the symbols that required a forced got entry. */
7791 if (h
->root
.got
.offset
== 2)
7793 BFD_ASSERT (gg
->assigned_gotno
> 0);
7794 gg
->assigned_gotno
--;
7797 else if (g
->global_gotno
== 0 && g
->global_gotsym
== NULL
)
7798 /* If we haven't got through GOT allocation yet, just bump up the
7799 number of local entries, as this symbol won't be counted as
7802 else if (h
->root
.got
.offset
== 1)
7804 /* If we're past non-multi-GOT allocation and this symbol had
7805 been marked for a global got entry, give it a local entry
7807 BFD_ASSERT (g
->global_gotno
> 0);
7813 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
7819 _bfd_mips_elf_discard_info (bfd
*abfd
, struct elf_reloc_cookie
*cookie
,
7820 struct bfd_link_info
*info
)
7823 bfd_boolean ret
= FALSE
;
7824 unsigned char *tdata
;
7827 o
= bfd_get_section_by_name (abfd
, ".pdr");
7832 if (o
->size
% PDR_SIZE
!= 0)
7834 if (o
->output_section
!= NULL
7835 && bfd_is_abs_section (o
->output_section
))
7838 tdata
= bfd_zmalloc (o
->size
/ PDR_SIZE
);
7842 cookie
->rels
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
7850 cookie
->rel
= cookie
->rels
;
7851 cookie
->relend
= cookie
->rels
+ o
->reloc_count
;
7853 for (i
= 0, skip
= 0; i
< o
->size
/ PDR_SIZE
; i
++)
7855 if (bfd_elf_reloc_symbol_deleted_p (i
* PDR_SIZE
, cookie
))
7864 mips_elf_section_data (o
)->u
.tdata
= tdata
;
7865 o
->size
-= skip
* PDR_SIZE
;
7871 if (! info
->keep_memory
)
7872 free (cookie
->rels
);
7878 _bfd_mips_elf_ignore_discarded_relocs (asection
*sec
)
7880 if (strcmp (sec
->name
, ".pdr") == 0)
7886 _bfd_mips_elf_write_section (bfd
*output_bfd
, asection
*sec
,
7889 bfd_byte
*to
, *from
, *end
;
7892 if (strcmp (sec
->name
, ".pdr") != 0)
7895 if (mips_elf_section_data (sec
)->u
.tdata
== NULL
)
7899 end
= contents
+ sec
->size
;
7900 for (from
= contents
, i
= 0;
7902 from
+= PDR_SIZE
, i
++)
7904 if ((mips_elf_section_data (sec
)->u
.tdata
)[i
] == 1)
7907 memcpy (to
, from
, PDR_SIZE
);
7910 bfd_set_section_contents (output_bfd
, sec
->output_section
, contents
,
7911 sec
->output_offset
, sec
->size
);
7915 /* MIPS ELF uses a special find_nearest_line routine in order the
7916 handle the ECOFF debugging information. */
7918 struct mips_elf_find_line
7920 struct ecoff_debug_info d
;
7921 struct ecoff_find_line i
;
7925 _bfd_mips_elf_find_nearest_line (bfd
*abfd
, asection
*section
,
7926 asymbol
**symbols
, bfd_vma offset
,
7927 const char **filename_ptr
,
7928 const char **functionname_ptr
,
7929 unsigned int *line_ptr
)
7933 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
7934 filename_ptr
, functionname_ptr
,
7938 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
7939 filename_ptr
, functionname_ptr
,
7940 line_ptr
, ABI_64_P (abfd
) ? 8 : 0,
7941 &elf_tdata (abfd
)->dwarf2_find_line_info
))
7944 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
7948 struct mips_elf_find_line
*fi
;
7949 const struct ecoff_debug_swap
* const swap
=
7950 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
7952 /* If we are called during a link, mips_elf_final_link may have
7953 cleared the SEC_HAS_CONTENTS field. We force it back on here
7954 if appropriate (which it normally will be). */
7955 origflags
= msec
->flags
;
7956 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
7957 msec
->flags
|= SEC_HAS_CONTENTS
;
7959 fi
= elf_tdata (abfd
)->find_line_info
;
7962 bfd_size_type external_fdr_size
;
7965 struct fdr
*fdr_ptr
;
7966 bfd_size_type amt
= sizeof (struct mips_elf_find_line
);
7968 fi
= bfd_zalloc (abfd
, amt
);
7971 msec
->flags
= origflags
;
7975 if (! _bfd_mips_elf_read_ecoff_info (abfd
, msec
, &fi
->d
))
7977 msec
->flags
= origflags
;
7981 /* Swap in the FDR information. */
7982 amt
= fi
->d
.symbolic_header
.ifdMax
* sizeof (struct fdr
);
7983 fi
->d
.fdr
= bfd_alloc (abfd
, amt
);
7984 if (fi
->d
.fdr
== NULL
)
7986 msec
->flags
= origflags
;
7989 external_fdr_size
= swap
->external_fdr_size
;
7990 fdr_ptr
= fi
->d
.fdr
;
7991 fraw_src
= (char *) fi
->d
.external_fdr
;
7992 fraw_end
= (fraw_src
7993 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
7994 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
7995 (*swap
->swap_fdr_in
) (abfd
, fraw_src
, fdr_ptr
);
7997 elf_tdata (abfd
)->find_line_info
= fi
;
7999 /* Note that we don't bother to ever free this information.
8000 find_nearest_line is either called all the time, as in
8001 objdump -l, so the information should be saved, or it is
8002 rarely called, as in ld error messages, so the memory
8003 wasted is unimportant. Still, it would probably be a
8004 good idea for free_cached_info to throw it away. */
8007 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
8008 &fi
->i
, filename_ptr
, functionname_ptr
,
8011 msec
->flags
= origflags
;
8015 msec
->flags
= origflags
;
8018 /* Fall back on the generic ELF find_nearest_line routine. */
8020 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
8021 filename_ptr
, functionname_ptr
,
8025 /* When are writing out the .options or .MIPS.options section,
8026 remember the bytes we are writing out, so that we can install the
8027 GP value in the section_processing routine. */
8030 _bfd_mips_elf_set_section_contents (bfd
*abfd
, sec_ptr section
,
8031 const void *location
,
8032 file_ptr offset
, bfd_size_type count
)
8034 if (strcmp (section
->name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
8038 if (elf_section_data (section
) == NULL
)
8040 bfd_size_type amt
= sizeof (struct bfd_elf_section_data
);
8041 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
8042 if (elf_section_data (section
) == NULL
)
8045 c
= mips_elf_section_data (section
)->u
.tdata
;
8048 c
= bfd_zalloc (abfd
, section
->size
);
8051 mips_elf_section_data (section
)->u
.tdata
= c
;
8054 memcpy (c
+ offset
, location
, count
);
8057 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
,
8061 /* This is almost identical to bfd_generic_get_... except that some
8062 MIPS relocations need to be handled specially. Sigh. */
8065 _bfd_elf_mips_get_relocated_section_contents
8067 struct bfd_link_info
*link_info
,
8068 struct bfd_link_order
*link_order
,
8070 bfd_boolean relocatable
,
8073 /* Get enough memory to hold the stuff */
8074 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
8075 asection
*input_section
= link_order
->u
.indirect
.section
;
8078 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
8079 arelent
**reloc_vector
= NULL
;
8085 reloc_vector
= bfd_malloc (reloc_size
);
8086 if (reloc_vector
== NULL
&& reloc_size
!= 0)
8089 /* read in the section */
8090 sz
= input_section
->rawsize
? input_section
->rawsize
: input_section
->size
;
8091 if (!bfd_get_section_contents (input_bfd
, input_section
, data
, 0, sz
))
8094 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
8098 if (reloc_count
< 0)
8101 if (reloc_count
> 0)
8106 bfd_vma gp
= 0x12345678; /* initialize just to shut gcc up */
8109 struct bfd_hash_entry
*h
;
8110 struct bfd_link_hash_entry
*lh
;
8111 /* Skip all this stuff if we aren't mixing formats. */
8112 if (abfd
&& input_bfd
8113 && abfd
->xvec
== input_bfd
->xvec
)
8117 h
= bfd_hash_lookup (&link_info
->hash
->table
, "_gp", FALSE
, FALSE
);
8118 lh
= (struct bfd_link_hash_entry
*) h
;
8125 case bfd_link_hash_undefined
:
8126 case bfd_link_hash_undefweak
:
8127 case bfd_link_hash_common
:
8130 case bfd_link_hash_defined
:
8131 case bfd_link_hash_defweak
:
8133 gp
= lh
->u
.def
.value
;
8135 case bfd_link_hash_indirect
:
8136 case bfd_link_hash_warning
:
8138 /* @@FIXME ignoring warning for now */
8140 case bfd_link_hash_new
:
8149 for (parent
= reloc_vector
; *parent
!= NULL
; parent
++)
8151 char *error_message
= NULL
;
8152 bfd_reloc_status_type r
;
8154 /* Specific to MIPS: Deal with relocation types that require
8155 knowing the gp of the output bfd. */
8156 asymbol
*sym
= *(*parent
)->sym_ptr_ptr
;
8157 if (bfd_is_abs_section (sym
->section
) && abfd
)
8159 /* The special_function wouldn't get called anyway. */
8163 /* The gp isn't there; let the special function code
8164 fall over on its own. */
8166 else if ((*parent
)->howto
->special_function
8167 == _bfd_mips_elf32_gprel16_reloc
)
8169 /* bypass special_function call */
8170 r
= _bfd_mips_elf_gprel16_with_gp (input_bfd
, sym
, *parent
,
8171 input_section
, relocatable
,
8173 goto skip_bfd_perform_relocation
;
8175 /* end mips specific stuff */
8177 r
= bfd_perform_relocation (input_bfd
, *parent
, data
, input_section
,
8178 relocatable
? abfd
: NULL
,
8180 skip_bfd_perform_relocation
:
8184 asection
*os
= input_section
->output_section
;
8186 /* A partial link, so keep the relocs */
8187 os
->orelocation
[os
->reloc_count
] = *parent
;
8191 if (r
!= bfd_reloc_ok
)
8195 case bfd_reloc_undefined
:
8196 if (!((*link_info
->callbacks
->undefined_symbol
)
8197 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
8198 input_bfd
, input_section
, (*parent
)->address
,
8202 case bfd_reloc_dangerous
:
8203 BFD_ASSERT (error_message
!= NULL
);
8204 if (!((*link_info
->callbacks
->reloc_dangerous
)
8205 (link_info
, error_message
, input_bfd
, input_section
,
8206 (*parent
)->address
)))
8209 case bfd_reloc_overflow
:
8210 if (!((*link_info
->callbacks
->reloc_overflow
)
8212 bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
8213 (*parent
)->howto
->name
, (*parent
)->addend
,
8214 input_bfd
, input_section
, (*parent
)->address
)))
8217 case bfd_reloc_outofrange
:
8226 if (reloc_vector
!= NULL
)
8227 free (reloc_vector
);
8231 if (reloc_vector
!= NULL
)
8232 free (reloc_vector
);
8236 /* Create a MIPS ELF linker hash table. */
8238 struct bfd_link_hash_table
*
8239 _bfd_mips_elf_link_hash_table_create (bfd
*abfd
)
8241 struct mips_elf_link_hash_table
*ret
;
8242 bfd_size_type amt
= sizeof (struct mips_elf_link_hash_table
);
8244 ret
= bfd_malloc (amt
);
8248 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
8249 mips_elf_link_hash_newfunc
))
8256 /* We no longer use this. */
8257 for (i
= 0; i
< SIZEOF_MIPS_DYNSYM_SECNAMES
; i
++)
8258 ret
->dynsym_sec_strindex
[i
] = (bfd_size_type
) -1;
8260 ret
->procedure_count
= 0;
8261 ret
->compact_rel_size
= 0;
8262 ret
->use_rld_obj_head
= FALSE
;
8264 ret
->mips16_stubs_seen
= FALSE
;
8266 return &ret
->root
.root
;
8269 /* We need to use a special link routine to handle the .reginfo and
8270 the .mdebug sections. We need to merge all instances of these
8271 sections together, not write them all out sequentially. */
8274 _bfd_mips_elf_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
8278 struct bfd_link_order
*p
;
8279 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
8280 asection
*rtproc_sec
;
8281 Elf32_RegInfo reginfo
;
8282 struct ecoff_debug_info debug
;
8283 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8284 const struct ecoff_debug_swap
*swap
= bed
->elf_backend_ecoff_debug_swap
;
8285 HDRR
*symhdr
= &debug
.symbolic_header
;
8286 void *mdebug_handle
= NULL
;
8292 static const char * const secname
[] =
8294 ".text", ".init", ".fini", ".data",
8295 ".rodata", ".sdata", ".sbss", ".bss"
8297 static const int sc
[] =
8299 scText
, scInit
, scFini
, scData
,
8300 scRData
, scSData
, scSBss
, scBss
8303 /* We'd carefully arranged the dynamic symbol indices, and then the
8304 generic size_dynamic_sections renumbered them out from under us.
8305 Rather than trying somehow to prevent the renumbering, just do
8307 if (elf_hash_table (info
)->dynamic_sections_created
)
8311 struct mips_got_info
*g
;
8312 bfd_size_type dynsecsymcount
;
8314 /* When we resort, we must tell mips_elf_sort_hash_table what
8315 the lowest index it may use is. That's the number of section
8316 symbols we're going to add. The generic ELF linker only
8317 adds these symbols when building a shared object. Note that
8318 we count the sections after (possibly) removing the .options
8326 for (p
= abfd
->sections
; p
; p
= p
->next
)
8327 if ((p
->flags
& SEC_EXCLUDE
) == 0
8328 && (p
->flags
& SEC_ALLOC
) != 0
8329 && !(*bed
->elf_backend_omit_section_dynsym
) (abfd
, info
, p
))
8333 if (! mips_elf_sort_hash_table (info
, dynsecsymcount
+ 1))
8336 /* Make sure we didn't grow the global .got region. */
8337 dynobj
= elf_hash_table (info
)->dynobj
;
8338 got
= mips_elf_got_section (dynobj
, FALSE
);
8339 g
= mips_elf_section_data (got
)->u
.got_info
;
8341 if (g
->global_gotsym
!= NULL
)
8342 BFD_ASSERT ((elf_hash_table (info
)->dynsymcount
8343 - g
->global_gotsym
->dynindx
)
8344 <= g
->global_gotno
);
8348 /* We want to set the GP value for ld -r. */
8349 /* On IRIX5, we omit the .options section. On IRIX6, however, we
8350 include it, even though we don't process it quite right. (Some
8351 entries are supposed to be merged.) Empirically, we seem to be
8352 better off including it then not. */
8353 if (IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
8354 for (secpp
= &abfd
->sections
; *secpp
!= NULL
; secpp
= &(*secpp
)->next
)
8356 if (strcmp ((*secpp
)->name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
8358 for (p
= (*secpp
)->link_order_head
; p
!= NULL
; p
= p
->next
)
8359 if (p
->type
== bfd_indirect_link_order
)
8360 p
->u
.indirect
.section
->flags
&= ~SEC_HAS_CONTENTS
;
8361 (*secpp
)->link_order_head
= NULL
;
8362 bfd_section_list_remove (abfd
, secpp
);
8363 --abfd
->section_count
;
8369 /* We include .MIPS.options, even though we don't process it quite right.
8370 (Some entries are supposed to be merged.) At IRIX6 empirically we seem
8371 to be better off including it than not. */
8372 for (secpp
= &abfd
->sections
; *secpp
!= NULL
; secpp
= &(*secpp
)->next
)
8374 if (strcmp ((*secpp
)->name
, ".MIPS.options") == 0)
8376 for (p
= (*secpp
)->link_order_head
; p
!= NULL
; p
= p
->next
)
8377 if (p
->type
== bfd_indirect_link_order
)
8378 p
->u
.indirect
.section
->flags
&=~ SEC_HAS_CONTENTS
;
8379 (*secpp
)->link_order_head
= NULL
;
8380 bfd_section_list_remove (abfd
, secpp
);
8381 --abfd
->section_count
;
8388 /* Get a value for the GP register. */
8389 if (elf_gp (abfd
) == 0)
8391 struct bfd_link_hash_entry
*h
;
8393 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
8394 if (h
!= NULL
&& h
->type
== bfd_link_hash_defined
)
8395 elf_gp (abfd
) = (h
->u
.def
.value
8396 + h
->u
.def
.section
->output_section
->vma
8397 + h
->u
.def
.section
->output_offset
);
8398 else if (info
->relocatable
)
8400 bfd_vma lo
= MINUS_ONE
;
8402 /* Find the GP-relative section with the lowest offset. */
8403 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
8405 && (elf_section_data (o
)->this_hdr
.sh_flags
& SHF_MIPS_GPREL
))
8408 /* And calculate GP relative to that. */
8409 elf_gp (abfd
) = lo
+ ELF_MIPS_GP_OFFSET (abfd
);
8413 /* If the relocate_section function needs to do a reloc
8414 involving the GP value, it should make a reloc_dangerous
8415 callback to warn that GP is not defined. */
8419 /* Go through the sections and collect the .reginfo and .mdebug
8423 gptab_data_sec
= NULL
;
8424 gptab_bss_sec
= NULL
;
8425 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
8427 if (strcmp (o
->name
, ".reginfo") == 0)
8429 memset (®info
, 0, sizeof reginfo
);
8431 /* We have found the .reginfo section in the output file.
8432 Look through all the link_orders comprising it and merge
8433 the information together. */
8434 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8436 asection
*input_section
;
8438 Elf32_External_RegInfo ext
;
8441 if (p
->type
!= bfd_indirect_link_order
)
8443 if (p
->type
== bfd_data_link_order
)
8448 input_section
= p
->u
.indirect
.section
;
8449 input_bfd
= input_section
->owner
;
8451 if (! bfd_get_section_contents (input_bfd
, input_section
,
8452 &ext
, 0, sizeof ext
))
8455 bfd_mips_elf32_swap_reginfo_in (input_bfd
, &ext
, &sub
);
8457 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
8458 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
8459 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
8460 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
8461 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
8463 /* ri_gp_value is set by the function
8464 mips_elf32_section_processing when the section is
8465 finally written out. */
8467 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8468 elf_link_input_bfd ignores this section. */
8469 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8472 /* Size has been set in _bfd_mips_elf_always_size_sections. */
8473 BFD_ASSERT(o
->size
== sizeof (Elf32_External_RegInfo
));
8475 /* Skip this section later on (I don't think this currently
8476 matters, but someday it might). */
8477 o
->link_order_head
= NULL
;
8482 if (strcmp (o
->name
, ".mdebug") == 0)
8484 struct extsym_info einfo
;
8487 /* We have found the .mdebug section in the output file.
8488 Look through all the link_orders comprising it and merge
8489 the information together. */
8490 symhdr
->magic
= swap
->sym_magic
;
8491 /* FIXME: What should the version stamp be? */
8493 symhdr
->ilineMax
= 0;
8497 symhdr
->isymMax
= 0;
8498 symhdr
->ioptMax
= 0;
8499 symhdr
->iauxMax
= 0;
8501 symhdr
->issExtMax
= 0;
8504 symhdr
->iextMax
= 0;
8506 /* We accumulate the debugging information itself in the
8507 debug_info structure. */
8509 debug
.external_dnr
= NULL
;
8510 debug
.external_pdr
= NULL
;
8511 debug
.external_sym
= NULL
;
8512 debug
.external_opt
= NULL
;
8513 debug
.external_aux
= NULL
;
8515 debug
.ssext
= debug
.ssext_end
= NULL
;
8516 debug
.external_fdr
= NULL
;
8517 debug
.external_rfd
= NULL
;
8518 debug
.external_ext
= debug
.external_ext_end
= NULL
;
8520 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
8521 if (mdebug_handle
== NULL
)
8525 esym
.cobol_main
= 0;
8529 esym
.asym
.iss
= issNil
;
8530 esym
.asym
.st
= stLocal
;
8531 esym
.asym
.reserved
= 0;
8532 esym
.asym
.index
= indexNil
;
8534 for (i
= 0; i
< sizeof (secname
) / sizeof (secname
[0]); i
++)
8536 esym
.asym
.sc
= sc
[i
];
8537 s
= bfd_get_section_by_name (abfd
, secname
[i
]);
8540 esym
.asym
.value
= s
->vma
;
8541 last
= s
->vma
+ s
->size
;
8544 esym
.asym
.value
= last
;
8545 if (!bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
8550 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8552 asection
*input_section
;
8554 const struct ecoff_debug_swap
*input_swap
;
8555 struct ecoff_debug_info input_debug
;
8559 if (p
->type
!= bfd_indirect_link_order
)
8561 if (p
->type
== bfd_data_link_order
)
8566 input_section
= p
->u
.indirect
.section
;
8567 input_bfd
= input_section
->owner
;
8569 if (bfd_get_flavour (input_bfd
) != bfd_target_elf_flavour
8570 || (get_elf_backend_data (input_bfd
)
8571 ->elf_backend_ecoff_debug_swap
) == NULL
)
8573 /* I don't know what a non MIPS ELF bfd would be
8574 doing with a .mdebug section, but I don't really
8575 want to deal with it. */
8579 input_swap
= (get_elf_backend_data (input_bfd
)
8580 ->elf_backend_ecoff_debug_swap
);
8582 BFD_ASSERT (p
->size
== input_section
->size
);
8584 /* The ECOFF linking code expects that we have already
8585 read in the debugging information and set up an
8586 ecoff_debug_info structure, so we do that now. */
8587 if (! _bfd_mips_elf_read_ecoff_info (input_bfd
, input_section
,
8591 if (! (bfd_ecoff_debug_accumulate
8592 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
8593 &input_debug
, input_swap
, info
)))
8596 /* Loop through the external symbols. For each one with
8597 interesting information, try to find the symbol in
8598 the linker global hash table and save the information
8599 for the output external symbols. */
8600 eraw_src
= input_debug
.external_ext
;
8601 eraw_end
= (eraw_src
8602 + (input_debug
.symbolic_header
.iextMax
8603 * input_swap
->external_ext_size
));
8605 eraw_src
< eraw_end
;
8606 eraw_src
+= input_swap
->external_ext_size
)
8610 struct mips_elf_link_hash_entry
*h
;
8612 (*input_swap
->swap_ext_in
) (input_bfd
, eraw_src
, &ext
);
8613 if (ext
.asym
.sc
== scNil
8614 || ext
.asym
.sc
== scUndefined
8615 || ext
.asym
.sc
== scSUndefined
)
8618 name
= input_debug
.ssext
+ ext
.asym
.iss
;
8619 h
= mips_elf_link_hash_lookup (mips_elf_hash_table (info
),
8620 name
, FALSE
, FALSE
, TRUE
);
8621 if (h
== NULL
|| h
->esym
.ifd
!= -2)
8627 < input_debug
.symbolic_header
.ifdMax
);
8628 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
8634 /* Free up the information we just read. */
8635 free (input_debug
.line
);
8636 free (input_debug
.external_dnr
);
8637 free (input_debug
.external_pdr
);
8638 free (input_debug
.external_sym
);
8639 free (input_debug
.external_opt
);
8640 free (input_debug
.external_aux
);
8641 free (input_debug
.ss
);
8642 free (input_debug
.ssext
);
8643 free (input_debug
.external_fdr
);
8644 free (input_debug
.external_rfd
);
8645 free (input_debug
.external_ext
);
8647 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8648 elf_link_input_bfd ignores this section. */
8649 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8652 if (SGI_COMPAT (abfd
) && info
->shared
)
8654 /* Create .rtproc section. */
8655 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
8656 if (rtproc_sec
== NULL
)
8658 flagword flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
8659 | SEC_LINKER_CREATED
| SEC_READONLY
);
8661 rtproc_sec
= bfd_make_section (abfd
, ".rtproc");
8662 if (rtproc_sec
== NULL
8663 || ! bfd_set_section_flags (abfd
, rtproc_sec
, flags
)
8664 || ! bfd_set_section_alignment (abfd
, rtproc_sec
, 4))
8668 if (! mips_elf_create_procedure_table (mdebug_handle
, abfd
,
8674 /* Build the external symbol information. */
8677 einfo
.debug
= &debug
;
8679 einfo
.failed
= FALSE
;
8680 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
8681 mips_elf_output_extsym
, &einfo
);
8685 /* Set the size of the .mdebug section. */
8686 o
->size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
8688 /* Skip this section later on (I don't think this currently
8689 matters, but someday it might). */
8690 o
->link_order_head
= NULL
;
8695 if (strncmp (o
->name
, ".gptab.", sizeof ".gptab." - 1) == 0)
8697 const char *subname
;
8700 Elf32_External_gptab
*ext_tab
;
8703 /* The .gptab.sdata and .gptab.sbss sections hold
8704 information describing how the small data area would
8705 change depending upon the -G switch. These sections
8706 not used in executables files. */
8707 if (! info
->relocatable
)
8709 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8711 asection
*input_section
;
8713 if (p
->type
!= bfd_indirect_link_order
)
8715 if (p
->type
== bfd_data_link_order
)
8720 input_section
= p
->u
.indirect
.section
;
8722 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8723 elf_link_input_bfd ignores this section. */
8724 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8727 /* Skip this section later on (I don't think this
8728 currently matters, but someday it might). */
8729 o
->link_order_head
= NULL
;
8731 /* Really remove the section. */
8732 for (secpp
= &abfd
->sections
;
8734 secpp
= &(*secpp
)->next
)
8736 bfd_section_list_remove (abfd
, secpp
);
8737 --abfd
->section_count
;
8742 /* There is one gptab for initialized data, and one for
8743 uninitialized data. */
8744 if (strcmp (o
->name
, ".gptab.sdata") == 0)
8746 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
8750 (*_bfd_error_handler
)
8751 (_("%s: illegal section name `%s'"),
8752 bfd_get_filename (abfd
), o
->name
);
8753 bfd_set_error (bfd_error_nonrepresentable_section
);
8757 /* The linker script always combines .gptab.data and
8758 .gptab.sdata into .gptab.sdata, and likewise for
8759 .gptab.bss and .gptab.sbss. It is possible that there is
8760 no .sdata or .sbss section in the output file, in which
8761 case we must change the name of the output section. */
8762 subname
= o
->name
+ sizeof ".gptab" - 1;
8763 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
8765 if (o
== gptab_data_sec
)
8766 o
->name
= ".gptab.data";
8768 o
->name
= ".gptab.bss";
8769 subname
= o
->name
+ sizeof ".gptab" - 1;
8770 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
8773 /* Set up the first entry. */
8775 amt
= c
* sizeof (Elf32_gptab
);
8776 tab
= bfd_malloc (amt
);
8779 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
8780 tab
[0].gt_header
.gt_unused
= 0;
8782 /* Combine the input sections. */
8783 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8785 asection
*input_section
;
8789 bfd_size_type gpentry
;
8791 if (p
->type
!= bfd_indirect_link_order
)
8793 if (p
->type
== bfd_data_link_order
)
8798 input_section
= p
->u
.indirect
.section
;
8799 input_bfd
= input_section
->owner
;
8801 /* Combine the gptab entries for this input section one
8802 by one. We know that the input gptab entries are
8803 sorted by ascending -G value. */
8804 size
= input_section
->size
;
8806 for (gpentry
= sizeof (Elf32_External_gptab
);
8808 gpentry
+= sizeof (Elf32_External_gptab
))
8810 Elf32_External_gptab ext_gptab
;
8811 Elf32_gptab int_gptab
;
8817 if (! (bfd_get_section_contents
8818 (input_bfd
, input_section
, &ext_gptab
, gpentry
,
8819 sizeof (Elf32_External_gptab
))))
8825 bfd_mips_elf32_swap_gptab_in (input_bfd
, &ext_gptab
,
8827 val
= int_gptab
.gt_entry
.gt_g_value
;
8828 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
8831 for (look
= 1; look
< c
; look
++)
8833 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
8834 tab
[look
].gt_entry
.gt_bytes
+= add
;
8836 if (tab
[look
].gt_entry
.gt_g_value
== val
)
8842 Elf32_gptab
*new_tab
;
8845 /* We need a new table entry. */
8846 amt
= (bfd_size_type
) (c
+ 1) * sizeof (Elf32_gptab
);
8847 new_tab
= bfd_realloc (tab
, amt
);
8848 if (new_tab
== NULL
)
8854 tab
[c
].gt_entry
.gt_g_value
= val
;
8855 tab
[c
].gt_entry
.gt_bytes
= add
;
8857 /* Merge in the size for the next smallest -G
8858 value, since that will be implied by this new
8861 for (look
= 1; look
< c
; look
++)
8863 if (tab
[look
].gt_entry
.gt_g_value
< val
8865 || (tab
[look
].gt_entry
.gt_g_value
8866 > tab
[max
].gt_entry
.gt_g_value
)))
8870 tab
[c
].gt_entry
.gt_bytes
+=
8871 tab
[max
].gt_entry
.gt_bytes
;
8876 last
= int_gptab
.gt_entry
.gt_bytes
;
8879 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8880 elf_link_input_bfd ignores this section. */
8881 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8884 /* The table must be sorted by -G value. */
8886 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
8888 /* Swap out the table. */
8889 amt
= (bfd_size_type
) c
* sizeof (Elf32_External_gptab
);
8890 ext_tab
= bfd_alloc (abfd
, amt
);
8891 if (ext_tab
== NULL
)
8897 for (j
= 0; j
< c
; j
++)
8898 bfd_mips_elf32_swap_gptab_out (abfd
, tab
+ j
, ext_tab
+ j
);
8901 o
->size
= c
* sizeof (Elf32_External_gptab
);
8902 o
->contents
= (bfd_byte
*) ext_tab
;
8904 /* Skip this section later on (I don't think this currently
8905 matters, but someday it might). */
8906 o
->link_order_head
= NULL
;
8910 /* Invoke the regular ELF backend linker to do all the work. */
8911 if (!bfd_elf_final_link (abfd
, info
))
8914 /* Now write out the computed sections. */
8916 if (reginfo_sec
!= NULL
)
8918 Elf32_External_RegInfo ext
;
8920 bfd_mips_elf32_swap_reginfo_out (abfd
, ®info
, &ext
);
8921 if (! bfd_set_section_contents (abfd
, reginfo_sec
, &ext
, 0, sizeof ext
))
8925 if (mdebug_sec
!= NULL
)
8927 BFD_ASSERT (abfd
->output_has_begun
);
8928 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
8930 mdebug_sec
->filepos
))
8933 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
8936 if (gptab_data_sec
!= NULL
)
8938 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
8939 gptab_data_sec
->contents
,
8940 0, gptab_data_sec
->size
))
8944 if (gptab_bss_sec
!= NULL
)
8946 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
8947 gptab_bss_sec
->contents
,
8948 0, gptab_bss_sec
->size
))
8952 if (SGI_COMPAT (abfd
))
8954 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
8955 if (rtproc_sec
!= NULL
)
8957 if (! bfd_set_section_contents (abfd
, rtproc_sec
,
8958 rtproc_sec
->contents
,
8959 0, rtproc_sec
->size
))
8967 /* Structure for saying that BFD machine EXTENSION extends BASE. */
8969 struct mips_mach_extension
{
8970 unsigned long extension
, base
;
8974 /* An array describing how BFD machines relate to one another. The entries
8975 are ordered topologically with MIPS I extensions listed last. */
8977 static const struct mips_mach_extension mips_mach_extensions
[] = {
8978 /* MIPS64 extensions. */
8979 { bfd_mach_mipsisa64r2
, bfd_mach_mipsisa64
},
8980 { bfd_mach_mips_sb1
, bfd_mach_mipsisa64
},
8982 /* MIPS V extensions. */
8983 { bfd_mach_mipsisa64
, bfd_mach_mips5
},
8985 /* R10000 extensions. */
8986 { bfd_mach_mips12000
, bfd_mach_mips10000
},
8988 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
8989 vr5400 ISA, but doesn't include the multimedia stuff. It seems
8990 better to allow vr5400 and vr5500 code to be merged anyway, since
8991 many libraries will just use the core ISA. Perhaps we could add
8992 some sort of ASE flag if this ever proves a problem. */
8993 { bfd_mach_mips5500
, bfd_mach_mips5400
},
8994 { bfd_mach_mips5400
, bfd_mach_mips5000
},
8996 /* MIPS IV extensions. */
8997 { bfd_mach_mips5
, bfd_mach_mips8000
},
8998 { bfd_mach_mips10000
, bfd_mach_mips8000
},
8999 { bfd_mach_mips5000
, bfd_mach_mips8000
},
9000 { bfd_mach_mips7000
, bfd_mach_mips8000
},
9001 { bfd_mach_mips9000
, bfd_mach_mips8000
},
9003 /* VR4100 extensions. */
9004 { bfd_mach_mips4120
, bfd_mach_mips4100
},
9005 { bfd_mach_mips4111
, bfd_mach_mips4100
},
9007 /* MIPS III extensions. */
9008 { bfd_mach_mips8000
, bfd_mach_mips4000
},
9009 { bfd_mach_mips4650
, bfd_mach_mips4000
},
9010 { bfd_mach_mips4600
, bfd_mach_mips4000
},
9011 { bfd_mach_mips4400
, bfd_mach_mips4000
},
9012 { bfd_mach_mips4300
, bfd_mach_mips4000
},
9013 { bfd_mach_mips4100
, bfd_mach_mips4000
},
9014 { bfd_mach_mips4010
, bfd_mach_mips4000
},
9016 /* MIPS32 extensions. */
9017 { bfd_mach_mipsisa32r2
, bfd_mach_mipsisa32
},
9019 /* MIPS II extensions. */
9020 { bfd_mach_mips4000
, bfd_mach_mips6000
},
9021 { bfd_mach_mipsisa32
, bfd_mach_mips6000
},
9023 /* MIPS I extensions. */
9024 { bfd_mach_mips6000
, bfd_mach_mips3000
},
9025 { bfd_mach_mips3900
, bfd_mach_mips3000
}
9029 /* Return true if bfd machine EXTENSION is an extension of machine BASE. */
9032 mips_mach_extends_p (unsigned long base
, unsigned long extension
)
9036 for (i
= 0; extension
!= base
&& i
< ARRAY_SIZE (mips_mach_extensions
); i
++)
9037 if (extension
== mips_mach_extensions
[i
].extension
)
9038 extension
= mips_mach_extensions
[i
].base
;
9040 return extension
== base
;
9044 /* Return true if the given ELF header flags describe a 32-bit binary. */
9047 mips_32bit_flags_p (flagword flags
)
9049 return ((flags
& EF_MIPS_32BITMODE
) != 0
9050 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
9051 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
9052 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
9053 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
9054 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
9055 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
);
9059 /* Merge backend specific data from an object file to the output
9060 object file when linking. */
9063 _bfd_mips_elf_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
9068 bfd_boolean null_input_bfd
= TRUE
;
9071 /* Check if we have the same endianess */
9072 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
9074 (*_bfd_error_handler
)
9075 (_("%B: endianness incompatible with that of the selected emulation"),
9080 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
9081 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
9084 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
9086 (*_bfd_error_handler
)
9087 (_("%B: ABI is incompatible with that of the selected emulation"),
9092 new_flags
= elf_elfheader (ibfd
)->e_flags
;
9093 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_NOREORDER
;
9094 old_flags
= elf_elfheader (obfd
)->e_flags
;
9096 if (! elf_flags_init (obfd
))
9098 elf_flags_init (obfd
) = TRUE
;
9099 elf_elfheader (obfd
)->e_flags
= new_flags
;
9100 elf_elfheader (obfd
)->e_ident
[EI_CLASS
]
9101 = elf_elfheader (ibfd
)->e_ident
[EI_CLASS
];
9103 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
9104 && bfd_get_arch_info (obfd
)->the_default
)
9106 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
9107 bfd_get_mach (ibfd
)))
9114 /* Check flag compatibility. */
9116 new_flags
&= ~EF_MIPS_NOREORDER
;
9117 old_flags
&= ~EF_MIPS_NOREORDER
;
9119 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
9120 doesn't seem to matter. */
9121 new_flags
&= ~EF_MIPS_XGOT
;
9122 old_flags
&= ~EF_MIPS_XGOT
;
9124 /* MIPSpro generates ucode info in n64 objects. Again, we should
9125 just be able to ignore this. */
9126 new_flags
&= ~EF_MIPS_UCODE
;
9127 old_flags
&= ~EF_MIPS_UCODE
;
9129 if (new_flags
== old_flags
)
9132 /* Check to see if the input BFD actually contains any sections.
9133 If not, its flags may not have been initialised either, but it cannot
9134 actually cause any incompatibility. */
9135 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
9137 /* Ignore synthetic sections and empty .text, .data and .bss sections
9138 which are automatically generated by gas. */
9139 if (strcmp (sec
->name
, ".reginfo")
9140 && strcmp (sec
->name
, ".mdebug")
9142 || (strcmp (sec
->name
, ".text")
9143 && strcmp (sec
->name
, ".data")
9144 && strcmp (sec
->name
, ".bss"))))
9146 null_input_bfd
= FALSE
;
9155 if (((new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0)
9156 != ((old_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0))
9158 (*_bfd_error_handler
)
9159 (_("%B: warning: linking PIC files with non-PIC files"),
9164 if (new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
))
9165 elf_elfheader (obfd
)->e_flags
|= EF_MIPS_CPIC
;
9166 if (! (new_flags
& EF_MIPS_PIC
))
9167 elf_elfheader (obfd
)->e_flags
&= ~EF_MIPS_PIC
;
9169 new_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
9170 old_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
9172 /* Compare the ISAs. */
9173 if (mips_32bit_flags_p (old_flags
) != mips_32bit_flags_p (new_flags
))
9175 (*_bfd_error_handler
)
9176 (_("%B: linking 32-bit code with 64-bit code"),
9180 else if (!mips_mach_extends_p (bfd_get_mach (ibfd
), bfd_get_mach (obfd
)))
9182 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
9183 if (mips_mach_extends_p (bfd_get_mach (obfd
), bfd_get_mach (ibfd
)))
9185 /* Copy the architecture info from IBFD to OBFD. Also copy
9186 the 32-bit flag (if set) so that we continue to recognise
9187 OBFD as a 32-bit binary. */
9188 bfd_set_arch_info (obfd
, bfd_get_arch_info (ibfd
));
9189 elf_elfheader (obfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
9190 elf_elfheader (obfd
)->e_flags
9191 |= new_flags
& (EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9193 /* Copy across the ABI flags if OBFD doesn't use them
9194 and if that was what caused us to treat IBFD as 32-bit. */
9195 if ((old_flags
& EF_MIPS_ABI
) == 0
9196 && mips_32bit_flags_p (new_flags
)
9197 && !mips_32bit_flags_p (new_flags
& ~EF_MIPS_ABI
))
9198 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ABI
;
9202 /* The ISAs aren't compatible. */
9203 (*_bfd_error_handler
)
9204 (_("%B: linking %s module with previous %s modules"),
9206 bfd_printable_name (ibfd
),
9207 bfd_printable_name (obfd
));
9212 new_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9213 old_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9215 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
9216 does set EI_CLASS differently from any 32-bit ABI. */
9217 if ((new_flags
& EF_MIPS_ABI
) != (old_flags
& EF_MIPS_ABI
)
9218 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
9219 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
9221 /* Only error if both are set (to different values). */
9222 if (((new_flags
& EF_MIPS_ABI
) && (old_flags
& EF_MIPS_ABI
))
9223 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
9224 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
9226 (*_bfd_error_handler
)
9227 (_("%B: ABI mismatch: linking %s module with previous %s modules"),
9229 elf_mips_abi_name (ibfd
),
9230 elf_mips_abi_name (obfd
));
9233 new_flags
&= ~EF_MIPS_ABI
;
9234 old_flags
&= ~EF_MIPS_ABI
;
9237 /* For now, allow arbitrary mixing of ASEs (retain the union). */
9238 if ((new_flags
& EF_MIPS_ARCH_ASE
) != (old_flags
& EF_MIPS_ARCH_ASE
))
9240 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ARCH_ASE
;
9242 new_flags
&= ~ EF_MIPS_ARCH_ASE
;
9243 old_flags
&= ~ EF_MIPS_ARCH_ASE
;
9246 /* Warn about any other mismatches */
9247 if (new_flags
!= old_flags
)
9249 (*_bfd_error_handler
)
9250 (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
9251 ibfd
, (unsigned long) new_flags
,
9252 (unsigned long) old_flags
);
9258 bfd_set_error (bfd_error_bad_value
);
9265 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
9268 _bfd_mips_elf_set_private_flags (bfd
*abfd
, flagword flags
)
9270 BFD_ASSERT (!elf_flags_init (abfd
)
9271 || elf_elfheader (abfd
)->e_flags
== flags
);
9273 elf_elfheader (abfd
)->e_flags
= flags
;
9274 elf_flags_init (abfd
) = TRUE
;
9279 _bfd_mips_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
9283 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
9285 /* Print normal ELF private data. */
9286 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
9288 /* xgettext:c-format */
9289 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
9291 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
)
9292 fprintf (file
, _(" [abi=O32]"));
9293 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O64
)
9294 fprintf (file
, _(" [abi=O64]"));
9295 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
)
9296 fprintf (file
, _(" [abi=EABI32]"));
9297 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
9298 fprintf (file
, _(" [abi=EABI64]"));
9299 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
))
9300 fprintf (file
, _(" [abi unknown]"));
9301 else if (ABI_N32_P (abfd
))
9302 fprintf (file
, _(" [abi=N32]"));
9303 else if (ABI_64_P (abfd
))
9304 fprintf (file
, _(" [abi=64]"));
9306 fprintf (file
, _(" [no abi set]"));
9308 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
9309 fprintf (file
, _(" [mips1]"));
9310 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
9311 fprintf (file
, _(" [mips2]"));
9312 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
9313 fprintf (file
, _(" [mips3]"));
9314 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
9315 fprintf (file
, _(" [mips4]"));
9316 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_5
)
9317 fprintf (file
, _(" [mips5]"));
9318 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
)
9319 fprintf (file
, _(" [mips32]"));
9320 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64
)
9321 fprintf (file
, _(" [mips64]"));
9322 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
)
9323 fprintf (file
, _(" [mips32r2]"));
9324 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64R2
)
9325 fprintf (file
, _(" [mips64r2]"));
9327 fprintf (file
, _(" [unknown ISA]"));
9329 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
9330 fprintf (file
, _(" [mdmx]"));
9332 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_M16
)
9333 fprintf (file
, _(" [mips16]"));
9335 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_32BITMODE
)
9336 fprintf (file
, _(" [32bitmode]"));
9338 fprintf (file
, _(" [not 32bitmode]"));
9345 struct bfd_elf_special_section
const _bfd_mips_elf_special_sections
[]=
9347 { ".sdata", 6, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9348 { ".sbss", 5, -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9349 { ".lit4", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9350 { ".lit8", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9351 { ".ucode", 6, 0, SHT_MIPS_UCODE
, 0 },
9352 { ".mdebug", 7, 0, SHT_MIPS_DEBUG
, 0 },
9353 { NULL
, 0, 0, 0, 0 }