1 /* MIPS-specific support for ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004 Free Software Foundation, Inc.
5 Most of the information added by Ian Lance Taylor, Cygnus Support,
7 N32/64 ABI support added by Mark Mitchell, CodeSourcery, LLC.
8 <mark@codesourcery.com>
9 Traditional MIPS targets support added by Koundinya.K, Dansk Data
10 Elektronik & Operations Research Group. <kk@ddeorg.soft.net>
12 This file is part of BFD, the Binary File Descriptor library.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 2 of the License, or
17 (at your option) any later version.
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 /* This file handles functionality common to the different MIPS ABI's. */
33 #include "libiberty.h"
35 #include "elfxx-mips.h"
38 /* Get the ECOFF swapping routines. */
40 #include "coff/symconst.h"
41 #include "coff/ecoff.h"
42 #include "coff/mips.h"
46 /* This structure is used to hold .got entries while estimating got
50 /* The input bfd in which the symbol is defined. */
52 /* The index of the symbol, as stored in the relocation r_info, if
53 we have a local symbol; -1 otherwise. */
57 /* If abfd == NULL, an address that must be stored in the got. */
59 /* If abfd != NULL && symndx != -1, the addend of the relocation
60 that should be added to the symbol value. */
62 /* If abfd != NULL && symndx == -1, the hash table entry
63 corresponding to a global symbol in the got (or, local, if
65 struct mips_elf_link_hash_entry
*h
;
67 /* The offset from the beginning of the .got section to the entry
68 corresponding to this symbol+addend. If it's a global symbol
69 whose offset is yet to be decided, it's going to be -1. */
73 /* This structure is used to hold .got information when linking. */
77 /* The global symbol in the GOT with the lowest index in the dynamic
79 struct elf_link_hash_entry
*global_gotsym
;
80 /* The number of global .got entries. */
81 unsigned int global_gotno
;
82 /* The number of local .got entries. */
83 unsigned int local_gotno
;
84 /* The number of local .got entries we have used. */
85 unsigned int assigned_gotno
;
86 /* A hash table holding members of the got. */
87 struct htab
*got_entries
;
88 /* A hash table mapping input bfds to other mips_got_info. NULL
89 unless multi-got was necessary. */
91 /* In multi-got links, a pointer to the next got (err, rather, most
92 of the time, it points to the previous got). */
93 struct mips_got_info
*next
;
96 /* Map an input bfd to a got in a multi-got link. */
98 struct mips_elf_bfd2got_hash
{
100 struct mips_got_info
*g
;
103 /* Structure passed when traversing the bfd2got hash table, used to
104 create and merge bfd's gots. */
106 struct mips_elf_got_per_bfd_arg
108 /* A hashtable that maps bfds to gots. */
110 /* The output bfd. */
112 /* The link information. */
113 struct bfd_link_info
*info
;
114 /* A pointer to the primary got, i.e., the one that's going to get
115 the implicit relocations from DT_MIPS_LOCAL_GOTNO and
117 struct mips_got_info
*primary
;
118 /* A non-primary got we're trying to merge with other input bfd's
120 struct mips_got_info
*current
;
121 /* The maximum number of got entries that can be addressed with a
123 unsigned int max_count
;
124 /* The number of local and global entries in the primary got. */
125 unsigned int primary_count
;
126 /* The number of local and global entries in the current got. */
127 unsigned int current_count
;
130 /* Another structure used to pass arguments for got entries traversal. */
132 struct mips_elf_set_global_got_offset_arg
134 struct mips_got_info
*g
;
136 unsigned int needed_relocs
;
137 struct bfd_link_info
*info
;
140 struct _mips_elf_section_data
142 struct bfd_elf_section_data elf
;
145 struct mips_got_info
*got_info
;
150 #define mips_elf_section_data(sec) \
151 ((struct _mips_elf_section_data *) elf_section_data (sec))
153 /* This structure is passed to mips_elf_sort_hash_table_f when sorting
154 the dynamic symbols. */
156 struct mips_elf_hash_sort_data
158 /* The symbol in the global GOT with the lowest dynamic symbol table
160 struct elf_link_hash_entry
*low
;
161 /* The least dynamic symbol table index corresponding to a symbol
163 long min_got_dynindx
;
164 /* The greatest dynamic symbol table index corresponding to a symbol
165 with a GOT entry that is not referenced (e.g., a dynamic symbol
166 with dynamic relocations pointing to it from non-primary GOTs). */
167 long max_unref_got_dynindx
;
168 /* The greatest dynamic symbol table index not corresponding to a
169 symbol without a GOT entry. */
170 long max_non_got_dynindx
;
173 /* The MIPS ELF linker needs additional information for each symbol in
174 the global hash table. */
176 struct mips_elf_link_hash_entry
178 struct elf_link_hash_entry root
;
180 /* External symbol information. */
183 /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
185 unsigned int possibly_dynamic_relocs
;
187 /* If the R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 reloc is against
188 a readonly section. */
189 bfd_boolean readonly_reloc
;
191 /* We must not create a stub for a symbol that has relocations
192 related to taking the function's address, i.e. any but
193 R_MIPS_CALL*16 ones -- see "MIPS ABI Supplement, 3rd Edition",
195 bfd_boolean no_fn_stub
;
197 /* If there is a stub that 32 bit functions should use to call this
198 16 bit function, this points to the section containing the stub. */
201 /* Whether we need the fn_stub; this is set if this symbol appears
202 in any relocs other than a 16 bit call. */
203 bfd_boolean need_fn_stub
;
205 /* If there is a stub that 16 bit functions should use to call this
206 32 bit function, this points to the section containing the stub. */
209 /* This is like the call_stub field, but it is used if the function
210 being called returns a floating point value. */
211 asection
*call_fp_stub
;
213 /* Are we forced local? .*/
214 bfd_boolean forced_local
;
217 /* MIPS ELF linker hash table. */
219 struct mips_elf_link_hash_table
221 struct elf_link_hash_table root
;
223 /* We no longer use this. */
224 /* String section indices for the dynamic section symbols. */
225 bfd_size_type dynsym_sec_strindex
[SIZEOF_MIPS_DYNSYM_SECNAMES
];
227 /* The number of .rtproc entries. */
228 bfd_size_type procedure_count
;
229 /* The size of the .compact_rel section (if SGI_COMPAT). */
230 bfd_size_type compact_rel_size
;
231 /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic
232 entry is set to the address of __rld_obj_head as in IRIX5. */
233 bfd_boolean use_rld_obj_head
;
234 /* This is the value of the __rld_map or __rld_obj_head symbol. */
236 /* This is set if we see any mips16 stub sections. */
237 bfd_boolean mips16_stubs_seen
;
240 /* Structure used to pass information to mips_elf_output_extsym. */
245 struct bfd_link_info
*info
;
246 struct ecoff_debug_info
*debug
;
247 const struct ecoff_debug_swap
*swap
;
251 /* The names of the runtime procedure table symbols used on IRIX5. */
253 static const char * const mips_elf_dynsym_rtproc_names
[] =
256 "_procedure_string_table",
257 "_procedure_table_size",
261 /* These structures are used to generate the .compact_rel section on
266 unsigned long id1
; /* Always one? */
267 unsigned long num
; /* Number of compact relocation entries. */
268 unsigned long id2
; /* Always two? */
269 unsigned long offset
; /* The file offset of the first relocation. */
270 unsigned long reserved0
; /* Zero? */
271 unsigned long reserved1
; /* Zero? */
280 bfd_byte reserved0
[4];
281 bfd_byte reserved1
[4];
282 } Elf32_External_compact_rel
;
286 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
287 unsigned int rtype
: 4; /* Relocation types. See below. */
288 unsigned int dist2to
: 8;
289 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
290 unsigned long konst
; /* KONST field. See below. */
291 unsigned long vaddr
; /* VADDR to be relocated. */
296 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
297 unsigned int rtype
: 4; /* Relocation types. See below. */
298 unsigned int dist2to
: 8;
299 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
300 unsigned long konst
; /* KONST field. See below. */
308 } Elf32_External_crinfo
;
314 } Elf32_External_crinfo2
;
316 /* These are the constants used to swap the bitfields in a crinfo. */
318 #define CRINFO_CTYPE (0x1)
319 #define CRINFO_CTYPE_SH (31)
320 #define CRINFO_RTYPE (0xf)
321 #define CRINFO_RTYPE_SH (27)
322 #define CRINFO_DIST2TO (0xff)
323 #define CRINFO_DIST2TO_SH (19)
324 #define CRINFO_RELVADDR (0x7ffff)
325 #define CRINFO_RELVADDR_SH (0)
327 /* A compact relocation info has long (3 words) or short (2 words)
328 formats. A short format doesn't have VADDR field and relvaddr
329 fields contains ((VADDR - vaddr of the previous entry) >> 2). */
330 #define CRF_MIPS_LONG 1
331 #define CRF_MIPS_SHORT 0
333 /* There are 4 types of compact relocation at least. The value KONST
334 has different meaning for each type:
337 CT_MIPS_REL32 Address in data
338 CT_MIPS_WORD Address in word (XXX)
339 CT_MIPS_GPHI_LO GP - vaddr
340 CT_MIPS_JMPAD Address to jump
343 #define CRT_MIPS_REL32 0xa
344 #define CRT_MIPS_WORD 0xb
345 #define CRT_MIPS_GPHI_LO 0xc
346 #define CRT_MIPS_JMPAD 0xd
348 #define mips_elf_set_cr_format(x,format) ((x).ctype = (format))
349 #define mips_elf_set_cr_type(x,type) ((x).rtype = (type))
350 #define mips_elf_set_cr_dist2to(x,v) ((x).dist2to = (v))
351 #define mips_elf_set_cr_relvaddr(x,d) ((x).relvaddr = (d)<<2)
353 /* The structure of the runtime procedure descriptor created by the
354 loader for use by the static exception system. */
356 typedef struct runtime_pdr
{
357 bfd_vma adr
; /* Memory address of start of procedure. */
358 long regmask
; /* Save register mask. */
359 long regoffset
; /* Save register offset. */
360 long fregmask
; /* Save floating point register mask. */
361 long fregoffset
; /* Save floating point register offset. */
362 long frameoffset
; /* Frame size. */
363 short framereg
; /* Frame pointer register. */
364 short pcreg
; /* Offset or reg of return pc. */
365 long irpss
; /* Index into the runtime string table. */
367 struct exception_info
*exception_info
;/* Pointer to exception array. */
369 #define cbRPDR sizeof (RPDR)
370 #define rpdNil ((pRPDR) 0)
372 static struct bfd_hash_entry
*mips_elf_link_hash_newfunc
373 (struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *);
374 static void ecoff_swap_rpdr_out
375 (bfd
*, const RPDR
*, struct rpdr_ext
*);
376 static bfd_boolean mips_elf_create_procedure_table
377 (void *, bfd
*, struct bfd_link_info
*, asection
*,
378 struct ecoff_debug_info
*);
379 static bfd_boolean mips_elf_check_mips16_stubs
380 (struct mips_elf_link_hash_entry
*, void *);
381 static void bfd_mips_elf32_swap_gptab_in
382 (bfd
*, const Elf32_External_gptab
*, Elf32_gptab
*);
383 static void bfd_mips_elf32_swap_gptab_out
384 (bfd
*, const Elf32_gptab
*, Elf32_External_gptab
*);
385 static void bfd_elf32_swap_compact_rel_out
386 (bfd
*, const Elf32_compact_rel
*, Elf32_External_compact_rel
*);
387 static void bfd_elf32_swap_crinfo_out
388 (bfd
*, const Elf32_crinfo
*, Elf32_External_crinfo
*);
389 static int sort_dynamic_relocs
390 (const void *, const void *);
391 static int sort_dynamic_relocs_64
392 (const void *, const void *);
393 static bfd_boolean mips_elf_output_extsym
394 (struct mips_elf_link_hash_entry
*, void *);
395 static int gptab_compare
396 (const void *, const void *);
397 static asection
*mips_elf_rel_dyn_section
398 (bfd
*, bfd_boolean
);
399 static asection
*mips_elf_got_section
400 (bfd
*, bfd_boolean
);
401 static struct mips_got_info
*mips_elf_got_info
402 (bfd
*, asection
**);
403 static bfd_vma mips_elf_local_got_index
404 (bfd
*, bfd
*, struct bfd_link_info
*, bfd_vma
);
405 static bfd_vma mips_elf_global_got_index
406 (bfd
*, bfd
*, struct elf_link_hash_entry
*);
407 static bfd_vma mips_elf_got_page
408 (bfd
*, bfd
*, struct bfd_link_info
*, bfd_vma
, bfd_vma
*);
409 static bfd_vma mips_elf_got16_entry
410 (bfd
*, bfd
*, struct bfd_link_info
*, bfd_vma
, bfd_boolean
);
411 static bfd_vma mips_elf_got_offset_from_index
412 (bfd
*, bfd
*, bfd
*, bfd_vma
);
413 static struct mips_got_entry
*mips_elf_create_local_got_entry
414 (bfd
*, bfd
*, struct mips_got_info
*, asection
*, bfd_vma
);
415 static bfd_boolean mips_elf_sort_hash_table
416 (struct bfd_link_info
*, unsigned long);
417 static bfd_boolean mips_elf_sort_hash_table_f
418 (struct mips_elf_link_hash_entry
*, void *);
419 static bfd_boolean mips_elf_record_local_got_symbol
420 (bfd
*, long, bfd_vma
, struct mips_got_info
*);
421 static bfd_boolean mips_elf_record_global_got_symbol
422 (struct elf_link_hash_entry
*, bfd
*, struct bfd_link_info
*,
423 struct mips_got_info
*);
424 static const Elf_Internal_Rela
*mips_elf_next_relocation
425 (bfd
*, unsigned int, const Elf_Internal_Rela
*, const Elf_Internal_Rela
*);
426 static bfd_boolean mips_elf_local_relocation_p
427 (bfd
*, const Elf_Internal_Rela
*, asection
**, bfd_boolean
);
428 static bfd_boolean mips_elf_overflow_p
430 static bfd_vma mips_elf_high
432 static bfd_vma mips_elf_higher
434 static bfd_vma mips_elf_highest
436 static bfd_boolean mips_elf_create_compact_rel_section
437 (bfd
*, struct bfd_link_info
*);
438 static bfd_boolean mips_elf_create_got_section
439 (bfd
*, struct bfd_link_info
*, bfd_boolean
);
440 static bfd_reloc_status_type mips_elf_calculate_relocation
441 (bfd
*, bfd
*, asection
*, struct bfd_link_info
*,
442 const Elf_Internal_Rela
*, bfd_vma
, reloc_howto_type
*,
443 Elf_Internal_Sym
*, asection
**, bfd_vma
*, const char **,
444 bfd_boolean
*, bfd_boolean
);
445 static bfd_vma mips_elf_obtain_contents
446 (reloc_howto_type
*, const Elf_Internal_Rela
*, bfd
*, bfd_byte
*);
447 static bfd_boolean mips_elf_perform_relocation
448 (struct bfd_link_info
*, reloc_howto_type
*, const Elf_Internal_Rela
*,
449 bfd_vma
, bfd
*, asection
*, bfd_byte
*, bfd_boolean
);
450 static bfd_boolean mips_elf_stub_section_p
452 static void mips_elf_allocate_dynamic_relocations
453 (bfd
*, unsigned int);
454 static bfd_boolean mips_elf_create_dynamic_relocation
455 (bfd
*, struct bfd_link_info
*, const Elf_Internal_Rela
*,
456 struct mips_elf_link_hash_entry
*, asection
*, bfd_vma
,
457 bfd_vma
*, asection
*);
458 static void mips_set_isa_flags
460 static INLINE
char *elf_mips_abi_name
462 static void mips_elf_irix6_finish_dynamic_symbol
463 (bfd
*, const char *, Elf_Internal_Sym
*);
464 static bfd_boolean mips_mach_extends_p
465 (unsigned long, unsigned long);
466 static bfd_boolean mips_32bit_flags_p
468 static INLINE hashval_t mips_elf_hash_bfd_vma
470 static hashval_t mips_elf_got_entry_hash
472 static int mips_elf_got_entry_eq
473 (const void *, const void *);
475 static bfd_boolean mips_elf_multi_got
476 (bfd
*, struct bfd_link_info
*, struct mips_got_info
*,
477 asection
*, bfd_size_type
);
478 static hashval_t mips_elf_multi_got_entry_hash
480 static int mips_elf_multi_got_entry_eq
481 (const void *, const void *);
482 static hashval_t mips_elf_bfd2got_entry_hash
484 static int mips_elf_bfd2got_entry_eq
485 (const void *, const void *);
486 static int mips_elf_make_got_per_bfd
488 static int mips_elf_merge_gots
490 static int mips_elf_set_global_got_offset
492 static int mips_elf_set_no_stub
494 static int mips_elf_resolve_final_got_entry
496 static void mips_elf_resolve_final_got_entries
497 (struct mips_got_info
*);
498 static bfd_vma mips_elf_adjust_gp
499 (bfd
*, struct mips_got_info
*, bfd
*);
500 static struct mips_got_info
*mips_elf_got_for_ibfd
501 (struct mips_got_info
*, bfd
*);
503 /* This will be used when we sort the dynamic relocation records. */
504 static bfd
*reldyn_sorting_bfd
;
506 /* Nonzero if ABFD is using the N32 ABI. */
508 #define ABI_N32_P(abfd) \
509 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
511 /* Nonzero if ABFD is using the N64 ABI. */
512 #define ABI_64_P(abfd) \
513 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
515 /* Nonzero if ABFD is using NewABI conventions. */
516 #define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
518 /* The IRIX compatibility level we are striving for. */
519 #define IRIX_COMPAT(abfd) \
520 (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
522 /* Whether we are trying to be compatible with IRIX at all. */
523 #define SGI_COMPAT(abfd) \
524 (IRIX_COMPAT (abfd) != ict_none)
526 /* The name of the options section. */
527 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
528 (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
530 /* The name of the stub section. */
531 #define MIPS_ELF_STUB_SECTION_NAME(abfd) ".MIPS.stubs"
533 /* The size of an external REL relocation. */
534 #define MIPS_ELF_REL_SIZE(abfd) \
535 (get_elf_backend_data (abfd)->s->sizeof_rel)
537 /* The size of an external dynamic table entry. */
538 #define MIPS_ELF_DYN_SIZE(abfd) \
539 (get_elf_backend_data (abfd)->s->sizeof_dyn)
541 /* The size of a GOT entry. */
542 #define MIPS_ELF_GOT_SIZE(abfd) \
543 (get_elf_backend_data (abfd)->s->arch_size / 8)
545 /* The size of a symbol-table entry. */
546 #define MIPS_ELF_SYM_SIZE(abfd) \
547 (get_elf_backend_data (abfd)->s->sizeof_sym)
549 /* The default alignment for sections, as a power of two. */
550 #define MIPS_ELF_LOG_FILE_ALIGN(abfd) \
551 (get_elf_backend_data (abfd)->s->log_file_align)
553 /* Get word-sized data. */
554 #define MIPS_ELF_GET_WORD(abfd, ptr) \
555 (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
557 /* Put out word-sized data. */
558 #define MIPS_ELF_PUT_WORD(abfd, val, ptr) \
560 ? bfd_put_64 (abfd, val, ptr) \
561 : bfd_put_32 (abfd, val, ptr))
563 /* Add a dynamic symbol table-entry. */
564 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
565 _bfd_elf_add_dynamic_entry (info, tag, val)
567 #define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela) \
568 (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela))
570 /* Determine whether the internal relocation of index REL_IDX is REL
571 (zero) or RELA (non-zero). The assumption is that, if there are
572 two relocation sections for this section, one of them is REL and
573 the other is RELA. If the index of the relocation we're testing is
574 in range for the first relocation section, check that the external
575 relocation size is that for RELA. It is also assumed that, if
576 rel_idx is not in range for the first section, and this first
577 section contains REL relocs, then the relocation is in the second
578 section, that is RELA. */
579 #define MIPS_RELOC_RELA_P(abfd, sec, rel_idx) \
580 ((NUM_SHDR_ENTRIES (&elf_section_data (sec)->rel_hdr) \
581 * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel \
582 > (bfd_vma)(rel_idx)) \
583 == (elf_section_data (sec)->rel_hdr.sh_entsize \
584 == (ABI_64_P (abfd) ? sizeof (Elf64_External_Rela) \
585 : sizeof (Elf32_External_Rela))))
587 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
588 from smaller values. Start with zero, widen, *then* decrement. */
589 #define MINUS_ONE (((bfd_vma)0) - 1)
591 /* The number of local .got entries we reserve. */
592 #define MIPS_RESERVED_GOTNO (2)
594 /* The offset of $gp from the beginning of the .got section. */
595 #define ELF_MIPS_GP_OFFSET(abfd) (0x7ff0)
597 /* The maximum size of the GOT for it to be addressable using 16-bit
599 #define MIPS_ELF_GOT_MAX_SIZE(abfd) (ELF_MIPS_GP_OFFSET(abfd) + 0x7fff)
601 /* Instructions which appear in a stub. */
602 #define STUB_LW(abfd) \
604 ? 0xdf998010 /* ld t9,0x8010(gp) */ \
605 : 0x8f998010)) /* lw t9,0x8010(gp) */
606 #define STUB_MOVE(abfd) \
608 ? 0x03e0782d /* daddu t7,ra */ \
609 : 0x03e07821)) /* addu t7,ra */
610 #define STUB_JALR 0x0320f809 /* jalr t9,ra */
611 #define STUB_LI16(abfd) \
613 ? 0x64180000 /* daddiu t8,zero,0 */ \
614 : 0x24180000)) /* addiu t8,zero,0 */
615 #define MIPS_FUNCTION_STUB_SIZE (16)
617 /* The name of the dynamic interpreter. This is put in the .interp
620 #define ELF_DYNAMIC_INTERPRETER(abfd) \
621 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
622 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
623 : "/usr/lib/libc.so.1")
626 #define MNAME(bfd,pre,pos) \
627 (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
628 #define ELF_R_SYM(bfd, i) \
629 (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
630 #define ELF_R_TYPE(bfd, i) \
631 (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
632 #define ELF_R_INFO(bfd, s, t) \
633 (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
635 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
636 #define ELF_R_SYM(bfd, i) \
638 #define ELF_R_TYPE(bfd, i) \
640 #define ELF_R_INFO(bfd, s, t) \
641 (ELF32_R_INFO (s, t))
644 /* The mips16 compiler uses a couple of special sections to handle
645 floating point arguments.
647 Section names that look like .mips16.fn.FNNAME contain stubs that
648 copy floating point arguments from the fp regs to the gp regs and
649 then jump to FNNAME. If any 32 bit function calls FNNAME, the
650 call should be redirected to the stub instead. If no 32 bit
651 function calls FNNAME, the stub should be discarded. We need to
652 consider any reference to the function, not just a call, because
653 if the address of the function is taken we will need the stub,
654 since the address might be passed to a 32 bit function.
656 Section names that look like .mips16.call.FNNAME contain stubs
657 that copy floating point arguments from the gp regs to the fp
658 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
659 then any 16 bit function that calls FNNAME should be redirected
660 to the stub instead. If FNNAME is not a 32 bit function, the
661 stub should be discarded.
663 .mips16.call.fp.FNNAME sections are similar, but contain stubs
664 which call FNNAME and then copy the return value from the fp regs
665 to the gp regs. These stubs store the return value in $18 while
666 calling FNNAME; any function which might call one of these stubs
667 must arrange to save $18 around the call. (This case is not
668 needed for 32 bit functions that call 16 bit functions, because
669 16 bit functions always return floating point values in both
672 Note that in all cases FNNAME might be defined statically.
673 Therefore, FNNAME is not used literally. Instead, the relocation
674 information will indicate which symbol the section is for.
676 We record any stubs that we find in the symbol table. */
678 #define FN_STUB ".mips16.fn."
679 #define CALL_STUB ".mips16.call."
680 #define CALL_FP_STUB ".mips16.call.fp."
682 /* Look up an entry in a MIPS ELF linker hash table. */
684 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
685 ((struct mips_elf_link_hash_entry *) \
686 elf_link_hash_lookup (&(table)->root, (string), (create), \
689 /* Traverse a MIPS ELF linker hash table. */
691 #define mips_elf_link_hash_traverse(table, func, info) \
692 (elf_link_hash_traverse \
694 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
697 /* Get the MIPS ELF linker hash table from a link_info structure. */
699 #define mips_elf_hash_table(p) \
700 ((struct mips_elf_link_hash_table *) ((p)->hash))
702 /* Create an entry in a MIPS ELF linker hash table. */
704 static struct bfd_hash_entry
*
705 mips_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
706 struct bfd_hash_table
*table
, const char *string
)
708 struct mips_elf_link_hash_entry
*ret
=
709 (struct mips_elf_link_hash_entry
*) entry
;
711 /* Allocate the structure if it has not already been allocated by a
714 ret
= bfd_hash_allocate (table
, sizeof (struct mips_elf_link_hash_entry
));
716 return (struct bfd_hash_entry
*) ret
;
718 /* Call the allocation method of the superclass. */
719 ret
= ((struct mips_elf_link_hash_entry
*)
720 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
724 /* Set local fields. */
725 memset (&ret
->esym
, 0, sizeof (EXTR
));
726 /* We use -2 as a marker to indicate that the information has
727 not been set. -1 means there is no associated ifd. */
729 ret
->possibly_dynamic_relocs
= 0;
730 ret
->readonly_reloc
= FALSE
;
731 ret
->no_fn_stub
= FALSE
;
733 ret
->need_fn_stub
= FALSE
;
734 ret
->call_stub
= NULL
;
735 ret
->call_fp_stub
= NULL
;
736 ret
->forced_local
= FALSE
;
739 return (struct bfd_hash_entry
*) ret
;
743 _bfd_mips_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
745 struct _mips_elf_section_data
*sdata
;
746 bfd_size_type amt
= sizeof (*sdata
);
748 sdata
= bfd_zalloc (abfd
, amt
);
751 sec
->used_by_bfd
= sdata
;
753 return _bfd_elf_new_section_hook (abfd
, sec
);
756 /* Read ECOFF debugging information from a .mdebug section into a
757 ecoff_debug_info structure. */
760 _bfd_mips_elf_read_ecoff_info (bfd
*abfd
, asection
*section
,
761 struct ecoff_debug_info
*debug
)
764 const struct ecoff_debug_swap
*swap
;
767 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
768 memset (debug
, 0, sizeof (*debug
));
770 ext_hdr
= bfd_malloc (swap
->external_hdr_size
);
771 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
774 if (! bfd_get_section_contents (abfd
, section
, ext_hdr
, 0,
775 swap
->external_hdr_size
))
778 symhdr
= &debug
->symbolic_header
;
779 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
781 /* The symbolic header contains absolute file offsets and sizes to
783 #define READ(ptr, offset, count, size, type) \
784 if (symhdr->count == 0) \
788 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
789 debug->ptr = bfd_malloc (amt); \
790 if (debug->ptr == NULL) \
792 if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0 \
793 || bfd_bread (debug->ptr, amt, abfd) != amt) \
797 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
798 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, void *);
799 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, void *);
800 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, void *);
801 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, void *);
802 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
804 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
805 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
806 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, void *);
807 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, void *);
808 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, void *);
818 if (debug
->line
!= NULL
)
820 if (debug
->external_dnr
!= NULL
)
821 free (debug
->external_dnr
);
822 if (debug
->external_pdr
!= NULL
)
823 free (debug
->external_pdr
);
824 if (debug
->external_sym
!= NULL
)
825 free (debug
->external_sym
);
826 if (debug
->external_opt
!= NULL
)
827 free (debug
->external_opt
);
828 if (debug
->external_aux
!= NULL
)
829 free (debug
->external_aux
);
830 if (debug
->ss
!= NULL
)
832 if (debug
->ssext
!= NULL
)
834 if (debug
->external_fdr
!= NULL
)
835 free (debug
->external_fdr
);
836 if (debug
->external_rfd
!= NULL
)
837 free (debug
->external_rfd
);
838 if (debug
->external_ext
!= NULL
)
839 free (debug
->external_ext
);
843 /* Swap RPDR (runtime procedure table entry) for output. */
846 ecoff_swap_rpdr_out (bfd
*abfd
, const RPDR
*in
, struct rpdr_ext
*ex
)
848 H_PUT_S32 (abfd
, in
->adr
, ex
->p_adr
);
849 H_PUT_32 (abfd
, in
->regmask
, ex
->p_regmask
);
850 H_PUT_32 (abfd
, in
->regoffset
, ex
->p_regoffset
);
851 H_PUT_32 (abfd
, in
->fregmask
, ex
->p_fregmask
);
852 H_PUT_32 (abfd
, in
->fregoffset
, ex
->p_fregoffset
);
853 H_PUT_32 (abfd
, in
->frameoffset
, ex
->p_frameoffset
);
855 H_PUT_16 (abfd
, in
->framereg
, ex
->p_framereg
);
856 H_PUT_16 (abfd
, in
->pcreg
, ex
->p_pcreg
);
858 H_PUT_32 (abfd
, in
->irpss
, ex
->p_irpss
);
860 H_PUT_S32 (abfd
, in
->exception_info
, ex
->p_exception_info
);
864 /* Create a runtime procedure table from the .mdebug section. */
867 mips_elf_create_procedure_table (void *handle
, bfd
*abfd
,
868 struct bfd_link_info
*info
, asection
*s
,
869 struct ecoff_debug_info
*debug
)
871 const struct ecoff_debug_swap
*swap
;
872 HDRR
*hdr
= &debug
->symbolic_header
;
874 struct rpdr_ext
*erp
;
876 struct pdr_ext
*epdr
;
877 struct sym_ext
*esym
;
882 unsigned long sindex
;
886 const char *no_name_func
= _("static procedure (no name)");
894 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
896 sindex
= strlen (no_name_func
) + 1;
900 size
= swap
->external_pdr_size
;
902 epdr
= bfd_malloc (size
* count
);
906 if (! _bfd_ecoff_get_accumulated_pdr (handle
, (bfd_byte
*) epdr
))
909 size
= sizeof (RPDR
);
910 rp
= rpdr
= bfd_malloc (size
* count
);
914 size
= sizeof (char *);
915 sv
= bfd_malloc (size
* count
);
919 count
= hdr
->isymMax
;
920 size
= swap
->external_sym_size
;
921 esym
= bfd_malloc (size
* count
);
925 if (! _bfd_ecoff_get_accumulated_sym (handle
, (bfd_byte
*) esym
))
929 ss
= bfd_malloc (count
);
932 if (! _bfd_ecoff_get_accumulated_ss (handle
, ss
))
936 for (i
= 0; i
< (unsigned long) count
; i
++, rp
++)
938 (*swap
->swap_pdr_in
) (abfd
, epdr
+ i
, &pdr
);
939 (*swap
->swap_sym_in
) (abfd
, &esym
[pdr
.isym
], &sym
);
941 rp
->regmask
= pdr
.regmask
;
942 rp
->regoffset
= pdr
.regoffset
;
943 rp
->fregmask
= pdr
.fregmask
;
944 rp
->fregoffset
= pdr
.fregoffset
;
945 rp
->frameoffset
= pdr
.frameoffset
;
946 rp
->framereg
= pdr
.framereg
;
947 rp
->pcreg
= pdr
.pcreg
;
949 sv
[i
] = ss
+ sym
.iss
;
950 sindex
+= strlen (sv
[i
]) + 1;
954 size
= sizeof (struct rpdr_ext
) * (count
+ 2) + sindex
;
955 size
= BFD_ALIGN (size
, 16);
956 rtproc
= bfd_alloc (abfd
, size
);
959 mips_elf_hash_table (info
)->procedure_count
= 0;
963 mips_elf_hash_table (info
)->procedure_count
= count
+ 2;
966 memset (erp
, 0, sizeof (struct rpdr_ext
));
968 str
= (char *) rtproc
+ sizeof (struct rpdr_ext
) * (count
+ 2);
969 strcpy (str
, no_name_func
);
970 str
+= strlen (no_name_func
) + 1;
971 for (i
= 0; i
< count
; i
++)
973 ecoff_swap_rpdr_out (abfd
, rpdr
+ i
, erp
+ i
);
975 str
+= strlen (sv
[i
]) + 1;
977 H_PUT_S32 (abfd
, -1, (erp
+ count
)->p_adr
);
979 /* Set the size and contents of .rtproc section. */
981 s
->contents
= rtproc
;
983 /* Skip this section later on (I don't think this currently
984 matters, but someday it might). */
985 s
->link_order_head
= NULL
;
1014 /* Check the mips16 stubs for a particular symbol, and see if we can
1018 mips_elf_check_mips16_stubs (struct mips_elf_link_hash_entry
*h
,
1019 void *data ATTRIBUTE_UNUSED
)
1021 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1022 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1024 if (h
->fn_stub
!= NULL
1025 && ! h
->need_fn_stub
)
1027 /* We don't need the fn_stub; the only references to this symbol
1028 are 16 bit calls. Clobber the size to 0 to prevent it from
1029 being included in the link. */
1030 h
->fn_stub
->_raw_size
= 0;
1031 h
->fn_stub
->_cooked_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
->_raw_size
= 0;
1044 h
->call_stub
->_cooked_size
= 0;
1045 h
->call_stub
->flags
&= ~SEC_RELOC
;
1046 h
->call_stub
->reloc_count
= 0;
1047 h
->call_stub
->flags
|= SEC_EXCLUDE
;
1050 if (h
->call_fp_stub
!= NULL
1051 && h
->root
.other
== STO_MIPS16
)
1053 /* We don't need the call_stub; this is a 16 bit function, so
1054 calls from other 16 bit functions are OK. Clobber the size
1055 to 0 to prevent it from being included in the link. */
1056 h
->call_fp_stub
->_raw_size
= 0;
1057 h
->call_fp_stub
->_cooked_size
= 0;
1058 h
->call_fp_stub
->flags
&= ~SEC_RELOC
;
1059 h
->call_fp_stub
->reloc_count
= 0;
1060 h
->call_fp_stub
->flags
|= SEC_EXCLUDE
;
1066 bfd_reloc_status_type
1067 _bfd_mips_elf_gprel16_with_gp (bfd
*abfd
, asymbol
*symbol
,
1068 arelent
*reloc_entry
, asection
*input_section
,
1069 bfd_boolean relocatable
, void *data
, bfd_vma gp
)
1073 bfd_reloc_status_type status
;
1075 if (bfd_is_com_section (symbol
->section
))
1078 relocation
= symbol
->value
;
1080 relocation
+= symbol
->section
->output_section
->vma
;
1081 relocation
+= symbol
->section
->output_offset
;
1083 if (reloc_entry
->address
> input_section
->_cooked_size
)
1084 return bfd_reloc_outofrange
;
1086 /* Set val to the offset into the section or symbol. */
1087 val
= reloc_entry
->addend
;
1089 _bfd_mips_elf_sign_extend (val
, 16);
1091 /* Adjust val for the final section location and GP value. If we
1092 are producing relocatable output, we don't want to do this for
1093 an external symbol. */
1095 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1096 val
+= relocation
- gp
;
1098 if (reloc_entry
->howto
->partial_inplace
)
1100 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
1102 + reloc_entry
->address
);
1103 if (status
!= bfd_reloc_ok
)
1107 reloc_entry
->addend
= val
;
1110 reloc_entry
->address
+= input_section
->output_offset
;
1112 return bfd_reloc_ok
;
1115 /* Used to store a REL high-part relocation such as R_MIPS_HI16 or
1116 R_MIPS_GOT16. REL is the relocation, INPUT_SECTION is the section
1117 that contains the relocation field and DATA points to the start of
1122 struct mips_hi16
*next
;
1124 asection
*input_section
;
1128 /* FIXME: This should not be a static variable. */
1130 static struct mips_hi16
*mips_hi16_list
;
1132 /* A howto special_function for REL *HI16 relocations. We can only
1133 calculate the correct value once we've seen the partnering
1134 *LO16 relocation, so just save the information for later.
1136 The ABI requires that the *LO16 immediately follow the *HI16.
1137 However, as a GNU extension, we permit an arbitrary number of
1138 *HI16s to be associated with a single *LO16. This significantly
1139 simplies the relocation handling in gcc. */
1141 bfd_reloc_status_type
1142 _bfd_mips_elf_hi16_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
1143 asymbol
*symbol ATTRIBUTE_UNUSED
, void *data
,
1144 asection
*input_section
, bfd
*output_bfd
,
1145 char **error_message ATTRIBUTE_UNUSED
)
1147 struct mips_hi16
*n
;
1149 if (reloc_entry
->address
> input_section
->_cooked_size
)
1150 return bfd_reloc_outofrange
;
1152 n
= bfd_malloc (sizeof *n
);
1154 return bfd_reloc_outofrange
;
1156 n
->next
= mips_hi16_list
;
1158 n
->input_section
= input_section
;
1159 n
->rel
= *reloc_entry
;
1162 if (output_bfd
!= NULL
)
1163 reloc_entry
->address
+= input_section
->output_offset
;
1165 return bfd_reloc_ok
;
1168 /* A howto special_function for REL R_MIPS_GOT16 relocations. This is just
1169 like any other 16-bit relocation when applied to global symbols, but is
1170 treated in the same as R_MIPS_HI16 when applied to local symbols. */
1172 bfd_reloc_status_type
1173 _bfd_mips_elf_got16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1174 void *data
, asection
*input_section
,
1175 bfd
*output_bfd
, char **error_message
)
1177 if ((symbol
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
1178 || bfd_is_und_section (bfd_get_section (symbol
))
1179 || bfd_is_com_section (bfd_get_section (symbol
)))
1180 /* The relocation is against a global symbol. */
1181 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1182 input_section
, output_bfd
,
1185 return _bfd_mips_elf_hi16_reloc (abfd
, reloc_entry
, symbol
, data
,
1186 input_section
, output_bfd
, error_message
);
1189 /* A howto special_function for REL *LO16 relocations. The *LO16 itself
1190 is a straightforward 16 bit inplace relocation, but we must deal with
1191 any partnering high-part relocations as well. */
1193 bfd_reloc_status_type
1194 _bfd_mips_elf_lo16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1195 void *data
, asection
*input_section
,
1196 bfd
*output_bfd
, char **error_message
)
1200 if (reloc_entry
->address
> input_section
->_cooked_size
)
1201 return bfd_reloc_outofrange
;
1203 vallo
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1204 while (mips_hi16_list
!= NULL
)
1206 bfd_reloc_status_type ret
;
1207 struct mips_hi16
*hi
;
1209 hi
= mips_hi16_list
;
1211 /* R_MIPS_GOT16 relocations are something of a special case. We
1212 want to install the addend in the same way as for a R_MIPS_HI16
1213 relocation (with a rightshift of 16). However, since GOT16
1214 relocations can also be used with global symbols, their howto
1215 has a rightshift of 0. */
1216 if (hi
->rel
.howto
->type
== R_MIPS_GOT16
)
1217 hi
->rel
.howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, R_MIPS_HI16
, FALSE
);
1219 /* VALLO is a signed 16-bit number. Bias it by 0x8000 so that any
1220 carry or borrow will induce a change of +1 or -1 in the high part. */
1221 hi
->rel
.addend
+= (vallo
+ 0x8000) & 0xffff;
1223 /* R_MIPS_GNU_REL_HI16 relocations are relative to the address of the
1224 lo16 relocation, not their own address. If we're calculating the
1225 final value, and hence subtracting the "PC", subtract the offset
1226 of the lo16 relocation from here. */
1227 if (output_bfd
== NULL
&& hi
->rel
.howto
->type
== R_MIPS_GNU_REL_HI16
)
1228 hi
->rel
.addend
-= reloc_entry
->address
- hi
->rel
.address
;
1230 ret
= _bfd_mips_elf_generic_reloc (abfd
, &hi
->rel
, symbol
, hi
->data
,
1231 hi
->input_section
, output_bfd
,
1233 if (ret
!= bfd_reloc_ok
)
1236 mips_hi16_list
= hi
->next
;
1240 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1241 input_section
, output_bfd
,
1245 /* A generic howto special_function. This calculates and installs the
1246 relocation itself, thus avoiding the oft-discussed problems in
1247 bfd_perform_relocation and bfd_install_relocation. */
1249 bfd_reloc_status_type
1250 _bfd_mips_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
1251 asymbol
*symbol
, void *data ATTRIBUTE_UNUSED
,
1252 asection
*input_section
, bfd
*output_bfd
,
1253 char **error_message ATTRIBUTE_UNUSED
)
1256 bfd_reloc_status_type status
;
1257 bfd_boolean relocatable
;
1259 relocatable
= (output_bfd
!= NULL
);
1261 if (reloc_entry
->address
> input_section
->_cooked_size
)
1262 return bfd_reloc_outofrange
;
1264 /* Build up the field adjustment in VAL. */
1266 if (!relocatable
|| (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1268 /* Either we're calculating the final field value or we have a
1269 relocation against a section symbol. Add in the section's
1270 offset or address. */
1271 val
+= symbol
->section
->output_section
->vma
;
1272 val
+= symbol
->section
->output_offset
;
1277 /* We're calculating the final field value. Add in the symbol's value
1278 and, if pc-relative, subtract the address of the field itself. */
1279 val
+= symbol
->value
;
1280 if (reloc_entry
->howto
->pc_relative
)
1282 val
-= input_section
->output_section
->vma
;
1283 val
-= input_section
->output_offset
;
1284 val
-= reloc_entry
->address
;
1288 /* VAL is now the final adjustment. If we're keeping this relocation
1289 in the output file, and if the relocation uses a separate addend,
1290 we just need to add VAL to that addend. Otherwise we need to add
1291 VAL to the relocation field itself. */
1292 if (relocatable
&& !reloc_entry
->howto
->partial_inplace
)
1293 reloc_entry
->addend
+= val
;
1296 /* Add in the separate addend, if any. */
1297 val
+= reloc_entry
->addend
;
1299 /* Add VAL to the relocation field. */
1300 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
1302 + reloc_entry
->address
);
1303 if (status
!= bfd_reloc_ok
)
1308 reloc_entry
->address
+= input_section
->output_offset
;
1310 return bfd_reloc_ok
;
1313 /* Swap an entry in a .gptab section. Note that these routines rely
1314 on the equivalence of the two elements of the union. */
1317 bfd_mips_elf32_swap_gptab_in (bfd
*abfd
, const Elf32_External_gptab
*ex
,
1320 in
->gt_entry
.gt_g_value
= H_GET_32 (abfd
, ex
->gt_entry
.gt_g_value
);
1321 in
->gt_entry
.gt_bytes
= H_GET_32 (abfd
, ex
->gt_entry
.gt_bytes
);
1325 bfd_mips_elf32_swap_gptab_out (bfd
*abfd
, const Elf32_gptab
*in
,
1326 Elf32_External_gptab
*ex
)
1328 H_PUT_32 (abfd
, in
->gt_entry
.gt_g_value
, ex
->gt_entry
.gt_g_value
);
1329 H_PUT_32 (abfd
, in
->gt_entry
.gt_bytes
, ex
->gt_entry
.gt_bytes
);
1333 bfd_elf32_swap_compact_rel_out (bfd
*abfd
, const Elf32_compact_rel
*in
,
1334 Elf32_External_compact_rel
*ex
)
1336 H_PUT_32 (abfd
, in
->id1
, ex
->id1
);
1337 H_PUT_32 (abfd
, in
->num
, ex
->num
);
1338 H_PUT_32 (abfd
, in
->id2
, ex
->id2
);
1339 H_PUT_32 (abfd
, in
->offset
, ex
->offset
);
1340 H_PUT_32 (abfd
, in
->reserved0
, ex
->reserved0
);
1341 H_PUT_32 (abfd
, in
->reserved1
, ex
->reserved1
);
1345 bfd_elf32_swap_crinfo_out (bfd
*abfd
, const Elf32_crinfo
*in
,
1346 Elf32_External_crinfo
*ex
)
1350 l
= (((in
->ctype
& CRINFO_CTYPE
) << CRINFO_CTYPE_SH
)
1351 | ((in
->rtype
& CRINFO_RTYPE
) << CRINFO_RTYPE_SH
)
1352 | ((in
->dist2to
& CRINFO_DIST2TO
) << CRINFO_DIST2TO_SH
)
1353 | ((in
->relvaddr
& CRINFO_RELVADDR
) << CRINFO_RELVADDR_SH
));
1354 H_PUT_32 (abfd
, l
, ex
->info
);
1355 H_PUT_32 (abfd
, in
->konst
, ex
->konst
);
1356 H_PUT_32 (abfd
, in
->vaddr
, ex
->vaddr
);
1359 /* A .reginfo section holds a single Elf32_RegInfo structure. These
1360 routines swap this structure in and out. They are used outside of
1361 BFD, so they are globally visible. */
1364 bfd_mips_elf32_swap_reginfo_in (bfd
*abfd
, const Elf32_External_RegInfo
*ex
,
1367 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1368 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1369 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1370 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1371 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1372 in
->ri_gp_value
= H_GET_32 (abfd
, ex
->ri_gp_value
);
1376 bfd_mips_elf32_swap_reginfo_out (bfd
*abfd
, const Elf32_RegInfo
*in
,
1377 Elf32_External_RegInfo
*ex
)
1379 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1380 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1381 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1382 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1383 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1384 H_PUT_32 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1387 /* In the 64 bit ABI, the .MIPS.options section holds register
1388 information in an Elf64_Reginfo structure. These routines swap
1389 them in and out. They are globally visible because they are used
1390 outside of BFD. These routines are here so that gas can call them
1391 without worrying about whether the 64 bit ABI has been included. */
1394 bfd_mips_elf64_swap_reginfo_in (bfd
*abfd
, const Elf64_External_RegInfo
*ex
,
1395 Elf64_Internal_RegInfo
*in
)
1397 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1398 in
->ri_pad
= H_GET_32 (abfd
, ex
->ri_pad
);
1399 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1400 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1401 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1402 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1403 in
->ri_gp_value
= H_GET_64 (abfd
, ex
->ri_gp_value
);
1407 bfd_mips_elf64_swap_reginfo_out (bfd
*abfd
, const Elf64_Internal_RegInfo
*in
,
1408 Elf64_External_RegInfo
*ex
)
1410 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1411 H_PUT_32 (abfd
, in
->ri_pad
, ex
->ri_pad
);
1412 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1413 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1414 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1415 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1416 H_PUT_64 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1419 /* Swap in an options header. */
1422 bfd_mips_elf_swap_options_in (bfd
*abfd
, const Elf_External_Options
*ex
,
1423 Elf_Internal_Options
*in
)
1425 in
->kind
= H_GET_8 (abfd
, ex
->kind
);
1426 in
->size
= H_GET_8 (abfd
, ex
->size
);
1427 in
->section
= H_GET_16 (abfd
, ex
->section
);
1428 in
->info
= H_GET_32 (abfd
, ex
->info
);
1431 /* Swap out an options header. */
1434 bfd_mips_elf_swap_options_out (bfd
*abfd
, const Elf_Internal_Options
*in
,
1435 Elf_External_Options
*ex
)
1437 H_PUT_8 (abfd
, in
->kind
, ex
->kind
);
1438 H_PUT_8 (abfd
, in
->size
, ex
->size
);
1439 H_PUT_16 (abfd
, in
->section
, ex
->section
);
1440 H_PUT_32 (abfd
, in
->info
, ex
->info
);
1443 /* This function is called via qsort() to sort the dynamic relocation
1444 entries by increasing r_symndx value. */
1447 sort_dynamic_relocs (const void *arg1
, const void *arg2
)
1449 Elf_Internal_Rela int_reloc1
;
1450 Elf_Internal_Rela int_reloc2
;
1452 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg1
, &int_reloc1
);
1453 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg2
, &int_reloc2
);
1455 return ELF32_R_SYM (int_reloc1
.r_info
) - ELF32_R_SYM (int_reloc2
.r_info
);
1458 /* Like sort_dynamic_relocs, but used for elf64 relocations. */
1461 sort_dynamic_relocs_64 (const void *arg1
, const void *arg2
)
1463 Elf_Internal_Rela int_reloc1
[3];
1464 Elf_Internal_Rela int_reloc2
[3];
1466 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1467 (reldyn_sorting_bfd
, arg1
, int_reloc1
);
1468 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1469 (reldyn_sorting_bfd
, arg2
, int_reloc2
);
1471 return (ELF64_R_SYM (int_reloc1
[0].r_info
)
1472 - ELF64_R_SYM (int_reloc2
[0].r_info
));
1476 /* This routine is used to write out ECOFF debugging external symbol
1477 information. It is called via mips_elf_link_hash_traverse. The
1478 ECOFF external symbol information must match the ELF external
1479 symbol information. Unfortunately, at this point we don't know
1480 whether a symbol is required by reloc information, so the two
1481 tables may wind up being different. We must sort out the external
1482 symbol information before we can set the final size of the .mdebug
1483 section, and we must set the size of the .mdebug section before we
1484 can relocate any sections, and we can't know which symbols are
1485 required by relocation until we relocate the sections.
1486 Fortunately, it is relatively unlikely that any symbol will be
1487 stripped but required by a reloc. In particular, it can not happen
1488 when generating a final executable. */
1491 mips_elf_output_extsym (struct mips_elf_link_hash_entry
*h
, void *data
)
1493 struct extsym_info
*einfo
= data
;
1495 asection
*sec
, *output_section
;
1497 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1498 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1500 if (h
->root
.indx
== -2)
1502 else if (((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1503 || (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
1504 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1505 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
1507 else if (einfo
->info
->strip
== strip_all
1508 || (einfo
->info
->strip
== strip_some
1509 && bfd_hash_lookup (einfo
->info
->keep_hash
,
1510 h
->root
.root
.root
.string
,
1511 FALSE
, FALSE
) == NULL
))
1519 if (h
->esym
.ifd
== -2)
1522 h
->esym
.cobol_main
= 0;
1523 h
->esym
.weakext
= 0;
1524 h
->esym
.reserved
= 0;
1525 h
->esym
.ifd
= ifdNil
;
1526 h
->esym
.asym
.value
= 0;
1527 h
->esym
.asym
.st
= stGlobal
;
1529 if (h
->root
.root
.type
== bfd_link_hash_undefined
1530 || h
->root
.root
.type
== bfd_link_hash_undefweak
)
1534 /* Use undefined class. Also, set class and type for some
1536 name
= h
->root
.root
.root
.string
;
1537 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
1538 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
1540 h
->esym
.asym
.sc
= scData
;
1541 h
->esym
.asym
.st
= stLabel
;
1542 h
->esym
.asym
.value
= 0;
1544 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
1546 h
->esym
.asym
.sc
= scAbs
;
1547 h
->esym
.asym
.st
= stLabel
;
1548 h
->esym
.asym
.value
=
1549 mips_elf_hash_table (einfo
->info
)->procedure_count
;
1551 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (einfo
->abfd
))
1553 h
->esym
.asym
.sc
= scAbs
;
1554 h
->esym
.asym
.st
= stLabel
;
1555 h
->esym
.asym
.value
= elf_gp (einfo
->abfd
);
1558 h
->esym
.asym
.sc
= scUndefined
;
1560 else if (h
->root
.root
.type
!= bfd_link_hash_defined
1561 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
1562 h
->esym
.asym
.sc
= scAbs
;
1567 sec
= h
->root
.root
.u
.def
.section
;
1568 output_section
= sec
->output_section
;
1570 /* When making a shared library and symbol h is the one from
1571 the another shared library, OUTPUT_SECTION may be null. */
1572 if (output_section
== NULL
)
1573 h
->esym
.asym
.sc
= scUndefined
;
1576 name
= bfd_section_name (output_section
->owner
, output_section
);
1578 if (strcmp (name
, ".text") == 0)
1579 h
->esym
.asym
.sc
= scText
;
1580 else if (strcmp (name
, ".data") == 0)
1581 h
->esym
.asym
.sc
= scData
;
1582 else if (strcmp (name
, ".sdata") == 0)
1583 h
->esym
.asym
.sc
= scSData
;
1584 else if (strcmp (name
, ".rodata") == 0
1585 || strcmp (name
, ".rdata") == 0)
1586 h
->esym
.asym
.sc
= scRData
;
1587 else if (strcmp (name
, ".bss") == 0)
1588 h
->esym
.asym
.sc
= scBss
;
1589 else if (strcmp (name
, ".sbss") == 0)
1590 h
->esym
.asym
.sc
= scSBss
;
1591 else if (strcmp (name
, ".init") == 0)
1592 h
->esym
.asym
.sc
= scInit
;
1593 else if (strcmp (name
, ".fini") == 0)
1594 h
->esym
.asym
.sc
= scFini
;
1596 h
->esym
.asym
.sc
= scAbs
;
1600 h
->esym
.asym
.reserved
= 0;
1601 h
->esym
.asym
.index
= indexNil
;
1604 if (h
->root
.root
.type
== bfd_link_hash_common
)
1605 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
1606 else if (h
->root
.root
.type
== bfd_link_hash_defined
1607 || h
->root
.root
.type
== bfd_link_hash_defweak
)
1609 if (h
->esym
.asym
.sc
== scCommon
)
1610 h
->esym
.asym
.sc
= scBss
;
1611 else if (h
->esym
.asym
.sc
== scSCommon
)
1612 h
->esym
.asym
.sc
= scSBss
;
1614 sec
= h
->root
.root
.u
.def
.section
;
1615 output_section
= sec
->output_section
;
1616 if (output_section
!= NULL
)
1617 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
1618 + sec
->output_offset
1619 + output_section
->vma
);
1621 h
->esym
.asym
.value
= 0;
1623 else if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
1625 struct mips_elf_link_hash_entry
*hd
= h
;
1626 bfd_boolean no_fn_stub
= h
->no_fn_stub
;
1628 while (hd
->root
.root
.type
== bfd_link_hash_indirect
)
1630 hd
= (struct mips_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
1631 no_fn_stub
= no_fn_stub
|| hd
->no_fn_stub
;
1636 /* Set type and value for a symbol with a function stub. */
1637 h
->esym
.asym
.st
= stProc
;
1638 sec
= hd
->root
.root
.u
.def
.section
;
1640 h
->esym
.asym
.value
= 0;
1643 output_section
= sec
->output_section
;
1644 if (output_section
!= NULL
)
1645 h
->esym
.asym
.value
= (hd
->root
.plt
.offset
1646 + sec
->output_offset
1647 + output_section
->vma
);
1649 h
->esym
.asym
.value
= 0;
1657 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
1658 h
->root
.root
.root
.string
,
1661 einfo
->failed
= TRUE
;
1668 /* A comparison routine used to sort .gptab entries. */
1671 gptab_compare (const void *p1
, const void *p2
)
1673 const Elf32_gptab
*a1
= p1
;
1674 const Elf32_gptab
*a2
= p2
;
1676 return a1
->gt_entry
.gt_g_value
- a2
->gt_entry
.gt_g_value
;
1679 /* Functions to manage the got entry hash table. */
1681 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
1684 static INLINE hashval_t
1685 mips_elf_hash_bfd_vma (bfd_vma addr
)
1688 return addr
+ (addr
>> 32);
1694 /* got_entries only match if they're identical, except for gotidx, so
1695 use all fields to compute the hash, and compare the appropriate
1699 mips_elf_got_entry_hash (const void *entry_
)
1701 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
1703 return entry
->symndx
1704 + (! entry
->abfd
? mips_elf_hash_bfd_vma (entry
->d
.address
)
1706 + (entry
->symndx
>= 0 ? mips_elf_hash_bfd_vma (entry
->d
.addend
)
1707 : entry
->d
.h
->root
.root
.root
.hash
));
1711 mips_elf_got_entry_eq (const void *entry1
, const void *entry2
)
1713 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
1714 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
1716 return e1
->abfd
== e2
->abfd
&& e1
->symndx
== e2
->symndx
1717 && (! e1
->abfd
? e1
->d
.address
== e2
->d
.address
1718 : e1
->symndx
>= 0 ? e1
->d
.addend
== e2
->d
.addend
1719 : e1
->d
.h
== e2
->d
.h
);
1722 /* multi_got_entries are still a match in the case of global objects,
1723 even if the input bfd in which they're referenced differs, so the
1724 hash computation and compare functions are adjusted
1728 mips_elf_multi_got_entry_hash (const void *entry_
)
1730 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
1732 return entry
->symndx
1734 ? mips_elf_hash_bfd_vma (entry
->d
.address
)
1735 : entry
->symndx
>= 0
1737 + mips_elf_hash_bfd_vma (entry
->d
.addend
))
1738 : entry
->d
.h
->root
.root
.root
.hash
);
1742 mips_elf_multi_got_entry_eq (const void *entry1
, const void *entry2
)
1744 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
1745 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
1747 return e1
->symndx
== e2
->symndx
1748 && (e1
->symndx
>= 0 ? e1
->abfd
== e2
->abfd
&& e1
->d
.addend
== e2
->d
.addend
1749 : e1
->abfd
== NULL
|| e2
->abfd
== NULL
1750 ? e1
->abfd
== e2
->abfd
&& e1
->d
.address
== e2
->d
.address
1751 : e1
->d
.h
== e2
->d
.h
);
1754 /* Returns the dynamic relocation section for DYNOBJ. */
1757 mips_elf_rel_dyn_section (bfd
*dynobj
, bfd_boolean create_p
)
1759 static const char dname
[] = ".rel.dyn";
1762 sreloc
= bfd_get_section_by_name (dynobj
, dname
);
1763 if (sreloc
== NULL
&& create_p
)
1765 sreloc
= bfd_make_section (dynobj
, dname
);
1767 || ! bfd_set_section_flags (dynobj
, sreloc
,
1772 | SEC_LINKER_CREATED
1774 || ! bfd_set_section_alignment (dynobj
, sreloc
,
1775 MIPS_ELF_LOG_FILE_ALIGN (dynobj
)))
1781 /* Returns the GOT section for ABFD. */
1784 mips_elf_got_section (bfd
*abfd
, bfd_boolean maybe_excluded
)
1786 asection
*sgot
= bfd_get_section_by_name (abfd
, ".got");
1788 || (! maybe_excluded
&& (sgot
->flags
& SEC_EXCLUDE
) != 0))
1793 /* Returns the GOT information associated with the link indicated by
1794 INFO. If SGOTP is non-NULL, it is filled in with the GOT
1797 static struct mips_got_info
*
1798 mips_elf_got_info (bfd
*abfd
, asection
**sgotp
)
1801 struct mips_got_info
*g
;
1803 sgot
= mips_elf_got_section (abfd
, TRUE
);
1804 BFD_ASSERT (sgot
!= NULL
);
1805 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
1806 g
= mips_elf_section_data (sgot
)->u
.got_info
;
1807 BFD_ASSERT (g
!= NULL
);
1810 *sgotp
= (sgot
->flags
& SEC_EXCLUDE
) == 0 ? sgot
: NULL
;
1815 /* Returns the GOT offset at which the indicated address can be found.
1816 If there is not yet a GOT entry for this value, create one. Returns
1817 -1 if no satisfactory GOT offset can be found. */
1820 mips_elf_local_got_index (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
1824 struct mips_got_info
*g
;
1825 struct mips_got_entry
*entry
;
1827 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1829 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
, value
);
1831 return entry
->gotidx
;
1836 /* Returns the GOT index for the global symbol indicated by H. */
1839 mips_elf_global_got_index (bfd
*abfd
, bfd
*ibfd
, struct elf_link_hash_entry
*h
)
1843 struct mips_got_info
*g
, *gg
;
1844 long global_got_dynindx
= 0;
1846 gg
= g
= mips_elf_got_info (abfd
, &sgot
);
1847 if (g
->bfd2got
&& ibfd
)
1849 struct mips_got_entry e
, *p
;
1851 BFD_ASSERT (h
->dynindx
>= 0);
1853 g
= mips_elf_got_for_ibfd (g
, ibfd
);
1858 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
1860 p
= htab_find (g
->got_entries
, &e
);
1862 BFD_ASSERT (p
->gotidx
> 0);
1867 if (gg
->global_gotsym
!= NULL
)
1868 global_got_dynindx
= gg
->global_gotsym
->dynindx
;
1870 /* Once we determine the global GOT entry with the lowest dynamic
1871 symbol table index, we must put all dynamic symbols with greater
1872 indices into the GOT. That makes it easy to calculate the GOT
1874 BFD_ASSERT (h
->dynindx
>= global_got_dynindx
);
1875 index
= ((h
->dynindx
- global_got_dynindx
+ g
->local_gotno
)
1876 * MIPS_ELF_GOT_SIZE (abfd
));
1877 BFD_ASSERT (index
< sgot
->_raw_size
);
1882 /* Find a GOT entry that is within 32KB of the VALUE. These entries
1883 are supposed to be placed at small offsets in the GOT, i.e.,
1884 within 32KB of GP. Return the index into the GOT for this page,
1885 and store the offset from this entry to the desired address in
1886 OFFSETP, if it is non-NULL. */
1889 mips_elf_got_page (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
1890 bfd_vma value
, bfd_vma
*offsetp
)
1893 struct mips_got_info
*g
;
1895 struct mips_got_entry
*entry
;
1897 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1899 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
,
1901 & (~(bfd_vma
)0xffff));
1906 index
= entry
->gotidx
;
1909 *offsetp
= value
- entry
->d
.address
;
1914 /* Find a GOT entry whose higher-order 16 bits are the same as those
1915 for value. Return the index into the GOT for this entry. */
1918 mips_elf_got16_entry (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
1919 bfd_vma value
, bfd_boolean external
)
1922 struct mips_got_info
*g
;
1923 struct mips_got_entry
*entry
;
1927 /* Although the ABI says that it is "the high-order 16 bits" that we
1928 want, it is really the %high value. The complete value is
1929 calculated with a `addiu' of a LO16 relocation, just as with a
1931 value
= mips_elf_high (value
) << 16;
1934 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1936 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
, value
);
1938 return entry
->gotidx
;
1943 /* Returns the offset for the entry at the INDEXth position
1947 mips_elf_got_offset_from_index (bfd
*dynobj
, bfd
*output_bfd
,
1948 bfd
*input_bfd
, bfd_vma index
)
1952 struct mips_got_info
*g
;
1954 g
= mips_elf_got_info (dynobj
, &sgot
);
1955 gp
= _bfd_get_gp_value (output_bfd
)
1956 + mips_elf_adjust_gp (output_bfd
, g
, input_bfd
);
1958 return sgot
->output_section
->vma
+ sgot
->output_offset
+ index
- gp
;
1961 /* Create a local GOT entry for VALUE. Return the index of the entry,
1962 or -1 if it could not be created. */
1964 static struct mips_got_entry
*
1965 mips_elf_create_local_got_entry (bfd
*abfd
, bfd
*ibfd
,
1966 struct mips_got_info
*gg
,
1967 asection
*sgot
, bfd_vma value
)
1969 struct mips_got_entry entry
, **loc
;
1970 struct mips_got_info
*g
;
1974 entry
.d
.address
= value
;
1976 g
= mips_elf_got_for_ibfd (gg
, ibfd
);
1979 g
= mips_elf_got_for_ibfd (gg
, abfd
);
1980 BFD_ASSERT (g
!= NULL
);
1983 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
1988 entry
.gotidx
= MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
++;
1990 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
1995 memcpy (*loc
, &entry
, sizeof entry
);
1997 if (g
->assigned_gotno
>= g
->local_gotno
)
1999 (*loc
)->gotidx
= -1;
2000 /* We didn't allocate enough space in the GOT. */
2001 (*_bfd_error_handler
)
2002 (_("not enough GOT space for local GOT entries"));
2003 bfd_set_error (bfd_error_bad_value
);
2007 MIPS_ELF_PUT_WORD (abfd
, value
,
2008 (sgot
->contents
+ entry
.gotidx
));
2013 /* Sort the dynamic symbol table so that symbols that need GOT entries
2014 appear towards the end. This reduces the amount of GOT space
2015 required. MAX_LOCAL is used to set the number of local symbols
2016 known to be in the dynamic symbol table. During
2017 _bfd_mips_elf_size_dynamic_sections, this value is 1. Afterward, the
2018 section symbols are added and the count is higher. */
2021 mips_elf_sort_hash_table (struct bfd_link_info
*info
, unsigned long max_local
)
2023 struct mips_elf_hash_sort_data hsd
;
2024 struct mips_got_info
*g
;
2027 dynobj
= elf_hash_table (info
)->dynobj
;
2029 g
= mips_elf_got_info (dynobj
, NULL
);
2032 hsd
.max_unref_got_dynindx
=
2033 hsd
.min_got_dynindx
= elf_hash_table (info
)->dynsymcount
2034 /* In the multi-got case, assigned_gotno of the master got_info
2035 indicate the number of entries that aren't referenced in the
2036 primary GOT, but that must have entries because there are
2037 dynamic relocations that reference it. Since they aren't
2038 referenced, we move them to the end of the GOT, so that they
2039 don't prevent other entries that are referenced from getting
2040 too large offsets. */
2041 - (g
->next
? g
->assigned_gotno
: 0);
2042 hsd
.max_non_got_dynindx
= max_local
;
2043 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table
*)
2044 elf_hash_table (info
)),
2045 mips_elf_sort_hash_table_f
,
2048 /* There should have been enough room in the symbol table to
2049 accommodate both the GOT and non-GOT symbols. */
2050 BFD_ASSERT (hsd
.max_non_got_dynindx
<= hsd
.min_got_dynindx
);
2051 BFD_ASSERT ((unsigned long)hsd
.max_unref_got_dynindx
2052 <= elf_hash_table (info
)->dynsymcount
);
2054 /* Now we know which dynamic symbol has the lowest dynamic symbol
2055 table index in the GOT. */
2056 g
->global_gotsym
= hsd
.low
;
2061 /* If H needs a GOT entry, assign it the highest available dynamic
2062 index. Otherwise, assign it the lowest available dynamic
2066 mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry
*h
, void *data
)
2068 struct mips_elf_hash_sort_data
*hsd
= data
;
2070 if (h
->root
.root
.type
== bfd_link_hash_warning
)
2071 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2073 /* Symbols without dynamic symbol table entries aren't interesting
2075 if (h
->root
.dynindx
== -1)
2078 /* Global symbols that need GOT entries that are not explicitly
2079 referenced are marked with got offset 2. Those that are
2080 referenced get a 1, and those that don't need GOT entries get
2082 if (h
->root
.got
.offset
== 2)
2084 if (hsd
->max_unref_got_dynindx
== hsd
->min_got_dynindx
)
2085 hsd
->low
= (struct elf_link_hash_entry
*) h
;
2086 h
->root
.dynindx
= hsd
->max_unref_got_dynindx
++;
2088 else if (h
->root
.got
.offset
!= 1)
2089 h
->root
.dynindx
= hsd
->max_non_got_dynindx
++;
2092 h
->root
.dynindx
= --hsd
->min_got_dynindx
;
2093 hsd
->low
= (struct elf_link_hash_entry
*) h
;
2099 /* If H is a symbol that needs a global GOT entry, but has a dynamic
2100 symbol table index lower than any we've seen to date, record it for
2104 mips_elf_record_global_got_symbol (struct elf_link_hash_entry
*h
,
2105 bfd
*abfd
, struct bfd_link_info
*info
,
2106 struct mips_got_info
*g
)
2108 struct mips_got_entry entry
, **loc
;
2110 /* A global symbol in the GOT must also be in the dynamic symbol
2112 if (h
->dynindx
== -1)
2114 switch (ELF_ST_VISIBILITY (h
->other
))
2118 _bfd_mips_elf_hide_symbol (info
, h
, TRUE
);
2121 if (!bfd_elf_link_record_dynamic_symbol (info
, h
))
2127 entry
.d
.h
= (struct mips_elf_link_hash_entry
*) h
;
2129 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
2132 /* If we've already marked this entry as needing GOT space, we don't
2133 need to do it again. */
2137 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2143 memcpy (*loc
, &entry
, sizeof entry
);
2145 if (h
->got
.offset
!= MINUS_ONE
)
2148 /* By setting this to a value other than -1, we are indicating that
2149 there needs to be a GOT entry for H. Avoid using zero, as the
2150 generic ELF copy_indirect_symbol tests for <= 0. */
2156 /* Reserve space in G for a GOT entry containing the value of symbol
2157 SYMNDX in input bfd ABDF, plus ADDEND. */
2160 mips_elf_record_local_got_symbol (bfd
*abfd
, long symndx
, bfd_vma addend
,
2161 struct mips_got_info
*g
)
2163 struct mips_got_entry entry
, **loc
;
2166 entry
.symndx
= symndx
;
2167 entry
.d
.addend
= addend
;
2168 loc
= (struct mips_got_entry
**)
2169 htab_find_slot (g
->got_entries
, &entry
, INSERT
);
2174 entry
.gotidx
= g
->local_gotno
++;
2176 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2181 memcpy (*loc
, &entry
, sizeof entry
);
2186 /* Compute the hash value of the bfd in a bfd2got hash entry. */
2189 mips_elf_bfd2got_entry_hash (const void *entry_
)
2191 const struct mips_elf_bfd2got_hash
*entry
2192 = (struct mips_elf_bfd2got_hash
*)entry_
;
2194 return entry
->bfd
->id
;
2197 /* Check whether two hash entries have the same bfd. */
2200 mips_elf_bfd2got_entry_eq (const void *entry1
, const void *entry2
)
2202 const struct mips_elf_bfd2got_hash
*e1
2203 = (const struct mips_elf_bfd2got_hash
*)entry1
;
2204 const struct mips_elf_bfd2got_hash
*e2
2205 = (const struct mips_elf_bfd2got_hash
*)entry2
;
2207 return e1
->bfd
== e2
->bfd
;
2210 /* In a multi-got link, determine the GOT to be used for IBDF. G must
2211 be the master GOT data. */
2213 static struct mips_got_info
*
2214 mips_elf_got_for_ibfd (struct mips_got_info
*g
, bfd
*ibfd
)
2216 struct mips_elf_bfd2got_hash e
, *p
;
2222 p
= htab_find (g
->bfd2got
, &e
);
2223 return p
? p
->g
: NULL
;
2226 /* Create one separate got for each bfd that has entries in the global
2227 got, such that we can tell how many local and global entries each
2231 mips_elf_make_got_per_bfd (void **entryp
, void *p
)
2233 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2234 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
2235 htab_t bfd2got
= arg
->bfd2got
;
2236 struct mips_got_info
*g
;
2237 struct mips_elf_bfd2got_hash bfdgot_entry
, *bfdgot
;
2240 /* Find the got_info for this GOT entry's input bfd. Create one if
2242 bfdgot_entry
.bfd
= entry
->abfd
;
2243 bfdgotp
= htab_find_slot (bfd2got
, &bfdgot_entry
, INSERT
);
2244 bfdgot
= (struct mips_elf_bfd2got_hash
*)*bfdgotp
;
2250 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
2251 (arg
->obfd
, sizeof (struct mips_elf_bfd2got_hash
));
2261 bfdgot
->bfd
= entry
->abfd
;
2262 bfdgot
->g
= g
= (struct mips_got_info
*)
2263 bfd_alloc (arg
->obfd
, sizeof (struct mips_got_info
));
2270 g
->global_gotsym
= NULL
;
2271 g
->global_gotno
= 0;
2273 g
->assigned_gotno
= -1;
2274 g
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
2275 mips_elf_multi_got_entry_eq
, NULL
);
2276 if (g
->got_entries
== NULL
)
2286 /* Insert the GOT entry in the bfd's got entry hash table. */
2287 entryp
= htab_find_slot (g
->got_entries
, entry
, INSERT
);
2288 if (*entryp
!= NULL
)
2293 if (entry
->symndx
>= 0 || entry
->d
.h
->forced_local
)
2301 /* Attempt to merge gots of different input bfds. Try to use as much
2302 as possible of the primary got, since it doesn't require explicit
2303 dynamic relocations, but don't use bfds that would reference global
2304 symbols out of the addressable range. Failing the primary got,
2305 attempt to merge with the current got, or finish the current got
2306 and then make make the new got current. */
2309 mips_elf_merge_gots (void **bfd2got_
, void *p
)
2311 struct mips_elf_bfd2got_hash
*bfd2got
2312 = (struct mips_elf_bfd2got_hash
*)*bfd2got_
;
2313 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
2314 unsigned int lcount
= bfd2got
->g
->local_gotno
;
2315 unsigned int gcount
= bfd2got
->g
->global_gotno
;
2316 unsigned int maxcnt
= arg
->max_count
;
2318 /* If we don't have a primary GOT and this is not too big, use it as
2319 a starting point for the primary GOT. */
2320 if (! arg
->primary
&& lcount
+ gcount
<= maxcnt
)
2322 arg
->primary
= bfd2got
->g
;
2323 arg
->primary_count
= lcount
+ gcount
;
2325 /* If it looks like we can merge this bfd's entries with those of
2326 the primary, merge them. The heuristics is conservative, but we
2327 don't have to squeeze it too hard. */
2328 else if (arg
->primary
2329 && (arg
->primary_count
+ lcount
+ gcount
) <= maxcnt
)
2331 struct mips_got_info
*g
= bfd2got
->g
;
2332 int old_lcount
= arg
->primary
->local_gotno
;
2333 int old_gcount
= arg
->primary
->global_gotno
;
2335 bfd2got
->g
= arg
->primary
;
2337 htab_traverse (g
->got_entries
,
2338 mips_elf_make_got_per_bfd
,
2340 if (arg
->obfd
== NULL
)
2343 htab_delete (g
->got_entries
);
2344 /* We don't have to worry about releasing memory of the actual
2345 got entries, since they're all in the master got_entries hash
2348 BFD_ASSERT (old_lcount
+ lcount
>= arg
->primary
->local_gotno
);
2349 BFD_ASSERT (old_gcount
+ gcount
>= arg
->primary
->global_gotno
);
2351 arg
->primary_count
= arg
->primary
->local_gotno
2352 + arg
->primary
->global_gotno
;
2354 /* If we can merge with the last-created got, do it. */
2355 else if (arg
->current
2356 && arg
->current_count
+ lcount
+ gcount
<= maxcnt
)
2358 struct mips_got_info
*g
= bfd2got
->g
;
2359 int old_lcount
= arg
->current
->local_gotno
;
2360 int old_gcount
= arg
->current
->global_gotno
;
2362 bfd2got
->g
= arg
->current
;
2364 htab_traverse (g
->got_entries
,
2365 mips_elf_make_got_per_bfd
,
2367 if (arg
->obfd
== NULL
)
2370 htab_delete (g
->got_entries
);
2372 BFD_ASSERT (old_lcount
+ lcount
>= arg
->current
->local_gotno
);
2373 BFD_ASSERT (old_gcount
+ gcount
>= arg
->current
->global_gotno
);
2375 arg
->current_count
= arg
->current
->local_gotno
2376 + arg
->current
->global_gotno
;
2378 /* Well, we couldn't merge, so create a new GOT. Don't check if it
2379 fits; if it turns out that it doesn't, we'll get relocation
2380 overflows anyway. */
2383 bfd2got
->g
->next
= arg
->current
;
2384 arg
->current
= bfd2got
->g
;
2386 arg
->current_count
= lcount
+ gcount
;
2392 /* If passed a NULL mips_got_info in the argument, set the marker used
2393 to tell whether a global symbol needs a got entry (in the primary
2394 got) to the given VALUE.
2396 If passed a pointer G to a mips_got_info in the argument (it must
2397 not be the primary GOT), compute the offset from the beginning of
2398 the (primary) GOT section to the entry in G corresponding to the
2399 global symbol. G's assigned_gotno must contain the index of the
2400 first available global GOT entry in G. VALUE must contain the size
2401 of a GOT entry in bytes. For each global GOT entry that requires a
2402 dynamic relocation, NEEDED_RELOCS is incremented, and the symbol is
2403 marked as not eligible for lazy resolution through a function
2406 mips_elf_set_global_got_offset (void **entryp
, void *p
)
2408 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2409 struct mips_elf_set_global_got_offset_arg
*arg
2410 = (struct mips_elf_set_global_got_offset_arg
*)p
;
2411 struct mips_got_info
*g
= arg
->g
;
2413 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1
2414 && entry
->d
.h
->root
.dynindx
!= -1)
2418 BFD_ASSERT (g
->global_gotsym
== NULL
);
2420 entry
->gotidx
= arg
->value
* (long) g
->assigned_gotno
++;
2421 if (arg
->info
->shared
2422 || (elf_hash_table (arg
->info
)->dynamic_sections_created
2423 && ((entry
->d
.h
->root
.elf_link_hash_flags
2424 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0)
2425 && ((entry
->d
.h
->root
.elf_link_hash_flags
2426 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
2427 ++arg
->needed_relocs
;
2430 entry
->d
.h
->root
.got
.offset
= arg
->value
;
2436 /* Mark any global symbols referenced in the GOT we are iterating over
2437 as inelligible for lazy resolution stubs. */
2439 mips_elf_set_no_stub (void **entryp
, void *p ATTRIBUTE_UNUSED
)
2441 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2443 if (entry
->abfd
!= NULL
2444 && entry
->symndx
== -1
2445 && entry
->d
.h
->root
.dynindx
!= -1)
2446 entry
->d
.h
->no_fn_stub
= TRUE
;
2451 /* Follow indirect and warning hash entries so that each got entry
2452 points to the final symbol definition. P must point to a pointer
2453 to the hash table we're traversing. Since this traversal may
2454 modify the hash table, we set this pointer to NULL to indicate
2455 we've made a potentially-destructive change to the hash table, so
2456 the traversal must be restarted. */
2458 mips_elf_resolve_final_got_entry (void **entryp
, void *p
)
2460 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2461 htab_t got_entries
= *(htab_t
*)p
;
2463 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1)
2465 struct mips_elf_link_hash_entry
*h
= entry
->d
.h
;
2467 while (h
->root
.root
.type
== bfd_link_hash_indirect
2468 || h
->root
.root
.type
== bfd_link_hash_warning
)
2469 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2471 if (entry
->d
.h
== h
)
2476 /* If we can't find this entry with the new bfd hash, re-insert
2477 it, and get the traversal restarted. */
2478 if (! htab_find (got_entries
, entry
))
2480 htab_clear_slot (got_entries
, entryp
);
2481 entryp
= htab_find_slot (got_entries
, entry
, INSERT
);
2484 /* Abort the traversal, since the whole table may have
2485 moved, and leave it up to the parent to restart the
2487 *(htab_t
*)p
= NULL
;
2490 /* We might want to decrement the global_gotno count, but it's
2491 either too early or too late for that at this point. */
2497 /* Turn indirect got entries in a got_entries table into their final
2500 mips_elf_resolve_final_got_entries (struct mips_got_info
*g
)
2506 got_entries
= g
->got_entries
;
2508 htab_traverse (got_entries
,
2509 mips_elf_resolve_final_got_entry
,
2512 while (got_entries
== NULL
);
2515 /* Return the offset of an input bfd IBFD's GOT from the beginning of
2518 mips_elf_adjust_gp (bfd
*abfd
, struct mips_got_info
*g
, bfd
*ibfd
)
2520 if (g
->bfd2got
== NULL
)
2523 g
= mips_elf_got_for_ibfd (g
, ibfd
);
2527 BFD_ASSERT (g
->next
);
2531 return (g
->local_gotno
+ g
->global_gotno
) * MIPS_ELF_GOT_SIZE (abfd
);
2534 /* Turn a single GOT that is too big for 16-bit addressing into
2535 a sequence of GOTs, each one 16-bit addressable. */
2538 mips_elf_multi_got (bfd
*abfd
, struct bfd_link_info
*info
,
2539 struct mips_got_info
*g
, asection
*got
,
2540 bfd_size_type pages
)
2542 struct mips_elf_got_per_bfd_arg got_per_bfd_arg
;
2543 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
2544 struct mips_got_info
*gg
;
2545 unsigned int assign
;
2547 g
->bfd2got
= htab_try_create (1, mips_elf_bfd2got_entry_hash
,
2548 mips_elf_bfd2got_entry_eq
, NULL
);
2549 if (g
->bfd2got
== NULL
)
2552 got_per_bfd_arg
.bfd2got
= g
->bfd2got
;
2553 got_per_bfd_arg
.obfd
= abfd
;
2554 got_per_bfd_arg
.info
= info
;
2556 /* Count how many GOT entries each input bfd requires, creating a
2557 map from bfd to got info while at that. */
2558 mips_elf_resolve_final_got_entries (g
);
2559 htab_traverse (g
->got_entries
, mips_elf_make_got_per_bfd
, &got_per_bfd_arg
);
2560 if (got_per_bfd_arg
.obfd
== NULL
)
2563 got_per_bfd_arg
.current
= NULL
;
2564 got_per_bfd_arg
.primary
= NULL
;
2565 /* Taking out PAGES entries is a worst-case estimate. We could
2566 compute the maximum number of pages that each separate input bfd
2567 uses, but it's probably not worth it. */
2568 got_per_bfd_arg
.max_count
= ((MIPS_ELF_GOT_MAX_SIZE (abfd
)
2569 / MIPS_ELF_GOT_SIZE (abfd
))
2570 - MIPS_RESERVED_GOTNO
- pages
);
2572 /* Try to merge the GOTs of input bfds together, as long as they
2573 don't seem to exceed the maximum GOT size, choosing one of them
2574 to be the primary GOT. */
2575 htab_traverse (g
->bfd2got
, mips_elf_merge_gots
, &got_per_bfd_arg
);
2576 if (got_per_bfd_arg
.obfd
== NULL
)
2579 /* If we find any suitable primary GOT, create an empty one. */
2580 if (got_per_bfd_arg
.primary
== NULL
)
2582 g
->next
= (struct mips_got_info
*)
2583 bfd_alloc (abfd
, sizeof (struct mips_got_info
));
2584 if (g
->next
== NULL
)
2587 g
->next
->global_gotsym
= NULL
;
2588 g
->next
->global_gotno
= 0;
2589 g
->next
->local_gotno
= 0;
2590 g
->next
->assigned_gotno
= 0;
2591 g
->next
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
2592 mips_elf_multi_got_entry_eq
,
2594 if (g
->next
->got_entries
== NULL
)
2596 g
->next
->bfd2got
= NULL
;
2599 g
->next
= got_per_bfd_arg
.primary
;
2600 g
->next
->next
= got_per_bfd_arg
.current
;
2602 /* GG is now the master GOT, and G is the primary GOT. */
2606 /* Map the output bfd to the primary got. That's what we're going
2607 to use for bfds that use GOT16 or GOT_PAGE relocations that we
2608 didn't mark in check_relocs, and we want a quick way to find it.
2609 We can't just use gg->next because we're going to reverse the
2612 struct mips_elf_bfd2got_hash
*bfdgot
;
2615 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
2616 (abfd
, sizeof (struct mips_elf_bfd2got_hash
));
2623 bfdgotp
= htab_find_slot (gg
->bfd2got
, bfdgot
, INSERT
);
2625 BFD_ASSERT (*bfdgotp
== NULL
);
2629 /* The IRIX dynamic linker requires every symbol that is referenced
2630 in a dynamic relocation to be present in the primary GOT, so
2631 arrange for them to appear after those that are actually
2634 GNU/Linux could very well do without it, but it would slow down
2635 the dynamic linker, since it would have to resolve every dynamic
2636 symbol referenced in other GOTs more than once, without help from
2637 the cache. Also, knowing that every external symbol has a GOT
2638 helps speed up the resolution of local symbols too, so GNU/Linux
2639 follows IRIX's practice.
2641 The number 2 is used by mips_elf_sort_hash_table_f to count
2642 global GOT symbols that are unreferenced in the primary GOT, with
2643 an initial dynamic index computed from gg->assigned_gotno, where
2644 the number of unreferenced global entries in the primary GOT is
2648 gg
->assigned_gotno
= gg
->global_gotno
- g
->global_gotno
;
2649 g
->global_gotno
= gg
->global_gotno
;
2650 set_got_offset_arg
.value
= 2;
2654 /* This could be used for dynamic linkers that don't optimize
2655 symbol resolution while applying relocations so as to use
2656 primary GOT entries or assuming the symbol is locally-defined.
2657 With this code, we assign lower dynamic indices to global
2658 symbols that are not referenced in the primary GOT, so that
2659 their entries can be omitted. */
2660 gg
->assigned_gotno
= 0;
2661 set_got_offset_arg
.value
= -1;
2664 /* Reorder dynamic symbols as described above (which behavior
2665 depends on the setting of VALUE). */
2666 set_got_offset_arg
.g
= NULL
;
2667 htab_traverse (gg
->got_entries
, mips_elf_set_global_got_offset
,
2668 &set_got_offset_arg
);
2669 set_got_offset_arg
.value
= 1;
2670 htab_traverse (g
->got_entries
, mips_elf_set_global_got_offset
,
2671 &set_got_offset_arg
);
2672 if (! mips_elf_sort_hash_table (info
, 1))
2675 /* Now go through the GOTs assigning them offset ranges.
2676 [assigned_gotno, local_gotno[ will be set to the range of local
2677 entries in each GOT. We can then compute the end of a GOT by
2678 adding local_gotno to global_gotno. We reverse the list and make
2679 it circular since then we'll be able to quickly compute the
2680 beginning of a GOT, by computing the end of its predecessor. To
2681 avoid special cases for the primary GOT, while still preserving
2682 assertions that are valid for both single- and multi-got links,
2683 we arrange for the main got struct to have the right number of
2684 global entries, but set its local_gotno such that the initial
2685 offset of the primary GOT is zero. Remember that the primary GOT
2686 will become the last item in the circular linked list, so it
2687 points back to the master GOT. */
2688 gg
->local_gotno
= -g
->global_gotno
;
2689 gg
->global_gotno
= g
->global_gotno
;
2695 struct mips_got_info
*gn
;
2697 assign
+= MIPS_RESERVED_GOTNO
;
2698 g
->assigned_gotno
= assign
;
2699 g
->local_gotno
+= assign
+ pages
;
2700 assign
= g
->local_gotno
+ g
->global_gotno
;
2702 /* Take g out of the direct list, and push it onto the reversed
2703 list that gg points to. */
2709 /* Mark global symbols in every non-primary GOT as ineligible for
2712 htab_traverse (g
->got_entries
, mips_elf_set_no_stub
, NULL
);
2716 got
->_raw_size
= (gg
->next
->local_gotno
2717 + gg
->next
->global_gotno
) * MIPS_ELF_GOT_SIZE (abfd
);
2723 /* Returns the first relocation of type r_type found, beginning with
2724 RELOCATION. RELEND is one-past-the-end of the relocation table. */
2726 static const Elf_Internal_Rela
*
2727 mips_elf_next_relocation (bfd
*abfd ATTRIBUTE_UNUSED
, unsigned int r_type
,
2728 const Elf_Internal_Rela
*relocation
,
2729 const Elf_Internal_Rela
*relend
)
2731 /* According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must be
2732 immediately following. However, for the IRIX6 ABI, the next
2733 relocation may be a composed relocation consisting of several
2734 relocations for the same address. In that case, the R_MIPS_LO16
2735 relocation may occur as one of these. We permit a similar
2736 extension in general, as that is useful for GCC. */
2737 while (relocation
< relend
)
2739 if (ELF_R_TYPE (abfd
, relocation
->r_info
) == r_type
)
2745 /* We didn't find it. */
2746 bfd_set_error (bfd_error_bad_value
);
2750 /* Return whether a relocation is against a local symbol. */
2753 mips_elf_local_relocation_p (bfd
*input_bfd
,
2754 const Elf_Internal_Rela
*relocation
,
2755 asection
**local_sections
,
2756 bfd_boolean check_forced
)
2758 unsigned long r_symndx
;
2759 Elf_Internal_Shdr
*symtab_hdr
;
2760 struct mips_elf_link_hash_entry
*h
;
2763 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
2764 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2765 extsymoff
= (elf_bad_symtab (input_bfd
)) ? 0 : symtab_hdr
->sh_info
;
2767 if (r_symndx
< extsymoff
)
2769 if (elf_bad_symtab (input_bfd
) && local_sections
[r_symndx
] != NULL
)
2774 /* Look up the hash table to check whether the symbol
2775 was forced local. */
2776 h
= (struct mips_elf_link_hash_entry
*)
2777 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
];
2778 /* Find the real hash-table entry for this symbol. */
2779 while (h
->root
.root
.type
== bfd_link_hash_indirect
2780 || h
->root
.root
.type
== bfd_link_hash_warning
)
2781 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2782 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0)
2789 /* Sign-extend VALUE, which has the indicated number of BITS. */
2792 _bfd_mips_elf_sign_extend (bfd_vma value
, int bits
)
2794 if (value
& ((bfd_vma
) 1 << (bits
- 1)))
2795 /* VALUE is negative. */
2796 value
|= ((bfd_vma
) - 1) << bits
;
2801 /* Return non-zero if the indicated VALUE has overflowed the maximum
2802 range expressible by a signed number with the indicated number of
2806 mips_elf_overflow_p (bfd_vma value
, int bits
)
2808 bfd_signed_vma svalue
= (bfd_signed_vma
) value
;
2810 if (svalue
> (1 << (bits
- 1)) - 1)
2811 /* The value is too big. */
2813 else if (svalue
< -(1 << (bits
- 1)))
2814 /* The value is too small. */
2821 /* Calculate the %high function. */
2824 mips_elf_high (bfd_vma value
)
2826 return ((value
+ (bfd_vma
) 0x8000) >> 16) & 0xffff;
2829 /* Calculate the %higher function. */
2832 mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED
)
2835 return ((value
+ (bfd_vma
) 0x80008000) >> 32) & 0xffff;
2838 return (bfd_vma
) -1;
2842 /* Calculate the %highest function. */
2845 mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED
)
2848 return ((value
+ (((bfd_vma
) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
2851 return (bfd_vma
) -1;
2855 /* Create the .compact_rel section. */
2858 mips_elf_create_compact_rel_section
2859 (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2862 register asection
*s
;
2864 if (bfd_get_section_by_name (abfd
, ".compact_rel") == NULL
)
2866 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
2869 s
= bfd_make_section (abfd
, ".compact_rel");
2871 || ! bfd_set_section_flags (abfd
, s
, flags
)
2872 || ! bfd_set_section_alignment (abfd
, s
,
2873 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
2876 s
->_raw_size
= sizeof (Elf32_External_compact_rel
);
2882 /* Create the .got section to hold the global offset table. */
2885 mips_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
,
2886 bfd_boolean maybe_exclude
)
2889 register asection
*s
;
2890 struct elf_link_hash_entry
*h
;
2891 struct bfd_link_hash_entry
*bh
;
2892 struct mips_got_info
*g
;
2895 /* This function may be called more than once. */
2896 s
= mips_elf_got_section (abfd
, TRUE
);
2899 if (! maybe_exclude
)
2900 s
->flags
&= ~SEC_EXCLUDE
;
2904 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2905 | SEC_LINKER_CREATED
);
2908 flags
|= SEC_EXCLUDE
;
2910 /* We have to use an alignment of 2**4 here because this is hardcoded
2911 in the function stub generation and in the linker script. */
2912 s
= bfd_make_section (abfd
, ".got");
2914 || ! bfd_set_section_flags (abfd
, s
, flags
)
2915 || ! bfd_set_section_alignment (abfd
, s
, 4))
2918 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
2919 linker script because we don't want to define the symbol if we
2920 are not creating a global offset table. */
2922 if (! (_bfd_generic_link_add_one_symbol
2923 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
2924 0, NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
2927 h
= (struct elf_link_hash_entry
*) bh
;
2928 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
2929 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2930 h
->type
= STT_OBJECT
;
2933 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2936 amt
= sizeof (struct mips_got_info
);
2937 g
= bfd_alloc (abfd
, amt
);
2940 g
->global_gotsym
= NULL
;
2941 g
->global_gotno
= 0;
2942 g
->local_gotno
= MIPS_RESERVED_GOTNO
;
2943 g
->assigned_gotno
= MIPS_RESERVED_GOTNO
;
2946 g
->got_entries
= htab_try_create (1, mips_elf_got_entry_hash
,
2947 mips_elf_got_entry_eq
, NULL
);
2948 if (g
->got_entries
== NULL
)
2950 mips_elf_section_data (s
)->u
.got_info
= g
;
2951 mips_elf_section_data (s
)->elf
.this_hdr
.sh_flags
2952 |= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
2957 /* Calculate the value produced by the RELOCATION (which comes from
2958 the INPUT_BFD). The ADDEND is the addend to use for this
2959 RELOCATION; RELOCATION->R_ADDEND is ignored.
2961 The result of the relocation calculation is stored in VALUEP.
2962 REQUIRE_JALXP indicates whether or not the opcode used with this
2963 relocation must be JALX.
2965 This function returns bfd_reloc_continue if the caller need take no
2966 further action regarding this relocation, bfd_reloc_notsupported if
2967 something goes dramatically wrong, bfd_reloc_overflow if an
2968 overflow occurs, and bfd_reloc_ok to indicate success. */
2970 static bfd_reloc_status_type
2971 mips_elf_calculate_relocation (bfd
*abfd
, bfd
*input_bfd
,
2972 asection
*input_section
,
2973 struct bfd_link_info
*info
,
2974 const Elf_Internal_Rela
*relocation
,
2975 bfd_vma addend
, reloc_howto_type
*howto
,
2976 Elf_Internal_Sym
*local_syms
,
2977 asection
**local_sections
, bfd_vma
*valuep
,
2978 const char **namep
, bfd_boolean
*require_jalxp
,
2979 bfd_boolean save_addend
)
2981 /* The eventual value we will return. */
2983 /* The address of the symbol against which the relocation is
2986 /* The final GP value to be used for the relocatable, executable, or
2987 shared object file being produced. */
2988 bfd_vma gp
= MINUS_ONE
;
2989 /* The place (section offset or address) of the storage unit being
2992 /* The value of GP used to create the relocatable object. */
2993 bfd_vma gp0
= MINUS_ONE
;
2994 /* The offset into the global offset table at which the address of
2995 the relocation entry symbol, adjusted by the addend, resides
2996 during execution. */
2997 bfd_vma g
= MINUS_ONE
;
2998 /* The section in which the symbol referenced by the relocation is
3000 asection
*sec
= NULL
;
3001 struct mips_elf_link_hash_entry
*h
= NULL
;
3002 /* TRUE if the symbol referred to by this relocation is a local
3004 bfd_boolean local_p
, was_local_p
;
3005 /* TRUE if the symbol referred to by this relocation is "_gp_disp". */
3006 bfd_boolean gp_disp_p
= FALSE
;
3007 Elf_Internal_Shdr
*symtab_hdr
;
3009 unsigned long r_symndx
;
3011 /* TRUE if overflow occurred during the calculation of the
3012 relocation value. */
3013 bfd_boolean overflowed_p
;
3014 /* TRUE if this relocation refers to a MIPS16 function. */
3015 bfd_boolean target_is_16_bit_code_p
= FALSE
;
3017 /* Parse the relocation. */
3018 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
3019 r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
3020 p
= (input_section
->output_section
->vma
3021 + input_section
->output_offset
3022 + relocation
->r_offset
);
3024 /* Assume that there will be no overflow. */
3025 overflowed_p
= FALSE
;
3027 /* Figure out whether or not the symbol is local, and get the offset
3028 used in the array of hash table entries. */
3029 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3030 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
3031 local_sections
, FALSE
);
3032 was_local_p
= local_p
;
3033 if (! elf_bad_symtab (input_bfd
))
3034 extsymoff
= symtab_hdr
->sh_info
;
3037 /* The symbol table does not follow the rule that local symbols
3038 must come before globals. */
3042 /* Figure out the value of the symbol. */
3045 Elf_Internal_Sym
*sym
;
3047 sym
= local_syms
+ r_symndx
;
3048 sec
= local_sections
[r_symndx
];
3050 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3051 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
3052 || (sec
->flags
& SEC_MERGE
))
3053 symbol
+= sym
->st_value
;
3054 if ((sec
->flags
& SEC_MERGE
)
3055 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3057 addend
= _bfd_elf_rel_local_sym (abfd
, sym
, &sec
, addend
);
3059 addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
3062 /* MIPS16 text labels should be treated as odd. */
3063 if (sym
->st_other
== STO_MIPS16
)
3066 /* Record the name of this symbol, for our caller. */
3067 *namep
= bfd_elf_string_from_elf_section (input_bfd
,
3068 symtab_hdr
->sh_link
,
3071 *namep
= bfd_section_name (input_bfd
, sec
);
3073 target_is_16_bit_code_p
= (sym
->st_other
== STO_MIPS16
);
3077 /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ? */
3079 /* For global symbols we look up the symbol in the hash-table. */
3080 h
= ((struct mips_elf_link_hash_entry
*)
3081 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
]);
3082 /* Find the real hash-table entry for this symbol. */
3083 while (h
->root
.root
.type
== bfd_link_hash_indirect
3084 || h
->root
.root
.type
== bfd_link_hash_warning
)
3085 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3087 /* Record the name of this symbol, for our caller. */
3088 *namep
= h
->root
.root
.root
.string
;
3090 /* See if this is the special _gp_disp symbol. Note that such a
3091 symbol must always be a global symbol. */
3092 if (strcmp (*namep
, "_gp_disp") == 0
3093 && ! NEWABI_P (input_bfd
))
3095 /* Relocations against _gp_disp are permitted only with
3096 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
3097 if (r_type
!= R_MIPS_HI16
&& r_type
!= R_MIPS_LO16
)
3098 return bfd_reloc_notsupported
;
3102 /* If this symbol is defined, calculate its address. Note that
3103 _gp_disp is a magic symbol, always implicitly defined by the
3104 linker, so it's inappropriate to check to see whether or not
3106 else if ((h
->root
.root
.type
== bfd_link_hash_defined
3107 || h
->root
.root
.type
== bfd_link_hash_defweak
)
3108 && h
->root
.root
.u
.def
.section
)
3110 sec
= h
->root
.root
.u
.def
.section
;
3111 if (sec
->output_section
)
3112 symbol
= (h
->root
.root
.u
.def
.value
3113 + sec
->output_section
->vma
3114 + sec
->output_offset
);
3116 symbol
= h
->root
.root
.u
.def
.value
;
3118 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
3119 /* We allow relocations against undefined weak symbols, giving
3120 it the value zero, so that you can undefined weak functions
3121 and check to see if they exist by looking at their
3124 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
3125 && ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
3127 else if (strcmp (*namep
, "_DYNAMIC_LINK") == 0 ||
3128 strcmp (*namep
, "_DYNAMIC_LINKING") == 0)
3130 /* If this is a dynamic link, we should have created a
3131 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
3132 in in _bfd_mips_elf_create_dynamic_sections.
3133 Otherwise, we should define the symbol with a value of 0.
3134 FIXME: It should probably get into the symbol table
3136 BFD_ASSERT (! info
->shared
);
3137 BFD_ASSERT (bfd_get_section_by_name (abfd
, ".dynamic") == NULL
);
3142 if (! ((*info
->callbacks
->undefined_symbol
)
3143 (info
, h
->root
.root
.root
.string
, input_bfd
,
3144 input_section
, relocation
->r_offset
,
3145 (info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
)
3146 || ELF_ST_VISIBILITY (h
->root
.other
))))
3147 return bfd_reloc_undefined
;
3151 target_is_16_bit_code_p
= (h
->root
.other
== STO_MIPS16
);
3154 /* If this is a 32- or 64-bit call to a 16-bit function with a stub, we
3155 need to redirect the call to the stub, unless we're already *in*
3157 if (r_type
!= R_MIPS16_26
&& !info
->relocatable
3158 && ((h
!= NULL
&& h
->fn_stub
!= NULL
)
3159 || (local_p
&& elf_tdata (input_bfd
)->local_stubs
!= NULL
3160 && elf_tdata (input_bfd
)->local_stubs
[r_symndx
] != NULL
))
3161 && !mips_elf_stub_section_p (input_bfd
, input_section
))
3163 /* This is a 32- or 64-bit call to a 16-bit function. We should
3164 have already noticed that we were going to need the
3167 sec
= elf_tdata (input_bfd
)->local_stubs
[r_symndx
];
3170 BFD_ASSERT (h
->need_fn_stub
);
3174 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3176 /* If this is a 16-bit call to a 32- or 64-bit function with a stub, we
3177 need to redirect the call to the stub. */
3178 else if (r_type
== R_MIPS16_26
&& !info
->relocatable
3180 && (h
->call_stub
!= NULL
|| h
->call_fp_stub
!= NULL
)
3181 && !target_is_16_bit_code_p
)
3183 /* If both call_stub and call_fp_stub are defined, we can figure
3184 out which one to use by seeing which one appears in the input
3186 if (h
->call_stub
!= NULL
&& h
->call_fp_stub
!= NULL
)
3191 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
3193 if (strncmp (bfd_get_section_name (input_bfd
, o
),
3194 CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
3196 sec
= h
->call_fp_stub
;
3203 else if (h
->call_stub
!= NULL
)
3206 sec
= h
->call_fp_stub
;
3208 BFD_ASSERT (sec
->_raw_size
> 0);
3209 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3212 /* Calls from 16-bit code to 32-bit code and vice versa require the
3213 special jalx instruction. */
3214 *require_jalxp
= (!info
->relocatable
3215 && (((r_type
== R_MIPS16_26
) && !target_is_16_bit_code_p
)
3216 || ((r_type
== R_MIPS_26
) && target_is_16_bit_code_p
)));
3218 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
3219 local_sections
, TRUE
);
3221 /* If we haven't already determined the GOT offset, or the GP value,
3222 and we're going to need it, get it now. */
3225 case R_MIPS_GOT_PAGE
:
3226 case R_MIPS_GOT_OFST
:
3227 /* We need to decay to GOT_DISP/addend if the symbol doesn't
3229 local_p
= local_p
|| _bfd_elf_symbol_refs_local_p (&h
->root
, info
, 1);
3230 if (local_p
|| r_type
== R_MIPS_GOT_OFST
)
3236 case R_MIPS_GOT_DISP
:
3237 case R_MIPS_GOT_HI16
:
3238 case R_MIPS_CALL_HI16
:
3239 case R_MIPS_GOT_LO16
:
3240 case R_MIPS_CALL_LO16
:
3241 /* Find the index into the GOT where this value is located. */
3244 /* GOT_PAGE may take a non-zero addend, that is ignored in a
3245 GOT_PAGE relocation that decays to GOT_DISP because the
3246 symbol turns out to be global. The addend is then added
3248 BFD_ASSERT (addend
== 0 || r_type
== R_MIPS_GOT_PAGE
);
3249 g
= mips_elf_global_got_index (elf_hash_table (info
)->dynobj
,
3251 (struct elf_link_hash_entry
*) h
);
3252 if (! elf_hash_table(info
)->dynamic_sections_created
3254 && (info
->symbolic
|| h
->root
.dynindx
== -1)
3255 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
3257 /* This is a static link or a -Bsymbolic link. The
3258 symbol is defined locally, or was forced to be local.
3259 We must initialize this entry in the GOT. */
3260 bfd
*tmpbfd
= elf_hash_table (info
)->dynobj
;
3261 asection
*sgot
= mips_elf_got_section (tmpbfd
, FALSE
);
3262 MIPS_ELF_PUT_WORD (tmpbfd
, symbol
, sgot
->contents
+ g
);
3265 else if (r_type
== R_MIPS_GOT16
|| r_type
== R_MIPS_CALL16
)
3266 /* There's no need to create a local GOT entry here; the
3267 calculation for a local GOT16 entry does not involve G. */
3271 g
= mips_elf_local_got_index (abfd
, input_bfd
,
3272 info
, symbol
+ addend
);
3274 return bfd_reloc_outofrange
;
3277 /* Convert GOT indices to actual offsets. */
3278 g
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3279 abfd
, input_bfd
, g
);
3284 case R_MIPS16_GPREL
:
3285 case R_MIPS_GPREL16
:
3286 case R_MIPS_GPREL32
:
3287 case R_MIPS_LITERAL
:
3288 gp0
= _bfd_get_gp_value (input_bfd
);
3289 gp
= _bfd_get_gp_value (abfd
);
3290 if (elf_hash_table (info
)->dynobj
)
3291 gp
+= mips_elf_adjust_gp (abfd
,
3293 (elf_hash_table (info
)->dynobj
, NULL
),
3301 /* Figure out what kind of relocation is being performed. */
3305 return bfd_reloc_continue
;
3308 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 16);
3309 overflowed_p
= mips_elf_overflow_p (value
, 16);
3316 || (elf_hash_table (info
)->dynamic_sections_created
3318 && ((h
->root
.elf_link_hash_flags
3319 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0)
3320 && ((h
->root
.elf_link_hash_flags
3321 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
3323 && (input_section
->flags
& SEC_ALLOC
) != 0)
3325 /* If we're creating a shared library, or this relocation is
3326 against a symbol in a shared library, then we can't know
3327 where the symbol will end up. So, we create a relocation
3328 record in the output, and leave the job up to the dynamic
3331 if (!mips_elf_create_dynamic_relocation (abfd
,
3339 return bfd_reloc_undefined
;
3343 if (r_type
!= R_MIPS_REL32
)
3344 value
= symbol
+ addend
;
3348 value
&= howto
->dst_mask
;
3353 case R_MIPS_GNU_REL_LO16
:
3354 value
= symbol
+ addend
- p
;
3355 value
&= howto
->dst_mask
;
3358 case R_MIPS_GNU_REL16_S2
:
3359 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 18) - p
;
3360 overflowed_p
= mips_elf_overflow_p (value
, 18);
3361 value
= (value
>> 2) & howto
->dst_mask
;
3364 case R_MIPS_GNU_REL_HI16
:
3365 /* Instead of subtracting 'p' here, we should be subtracting the
3366 equivalent value for the LO part of the reloc, since the value
3367 here is relative to that address. Because that's not easy to do,
3368 we adjust 'addend' in _bfd_mips_elf_relocate_section(). See also
3369 the comment there for more information. */
3370 value
= mips_elf_high (addend
+ symbol
- p
);
3371 value
&= howto
->dst_mask
;
3375 /* The calculation for R_MIPS16_26 is just the same as for an
3376 R_MIPS_26. It's only the storage of the relocated field into
3377 the output file that's different. That's handled in
3378 mips_elf_perform_relocation. So, we just fall through to the
3379 R_MIPS_26 case here. */
3382 value
= ((addend
| ((p
+ 4) & 0xf0000000)) + symbol
) >> 2;
3384 value
= (_bfd_mips_elf_sign_extend (addend
, 28) + symbol
) >> 2;
3385 value
&= howto
->dst_mask
;
3391 value
= mips_elf_high (addend
+ symbol
);
3392 value
&= howto
->dst_mask
;
3396 value
= mips_elf_high (addend
+ gp
- p
);
3397 overflowed_p
= mips_elf_overflow_p (value
, 16);
3403 value
= (symbol
+ addend
) & howto
->dst_mask
;
3406 value
= addend
+ gp
- p
+ 4;
3407 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
3408 for overflow. But, on, say, IRIX5, relocations against
3409 _gp_disp are normally generated from the .cpload
3410 pseudo-op. It generates code that normally looks like
3413 lui $gp,%hi(_gp_disp)
3414 addiu $gp,$gp,%lo(_gp_disp)
3417 Here $t9 holds the address of the function being called,
3418 as required by the MIPS ELF ABI. The R_MIPS_LO16
3419 relocation can easily overflow in this situation, but the
3420 R_MIPS_HI16 relocation will handle the overflow.
3421 Therefore, we consider this a bug in the MIPS ABI, and do
3422 not check for overflow here. */
3426 case R_MIPS_LITERAL
:
3427 /* Because we don't merge literal sections, we can handle this
3428 just like R_MIPS_GPREL16. In the long run, we should merge
3429 shared literals, and then we will need to additional work
3434 case R_MIPS16_GPREL
:
3435 /* The R_MIPS16_GPREL performs the same calculation as
3436 R_MIPS_GPREL16, but stores the relocated bits in a different
3437 order. We don't need to do anything special here; the
3438 differences are handled in mips_elf_perform_relocation. */
3439 case R_MIPS_GPREL16
:
3440 /* Only sign-extend the addend if it was extracted from the
3441 instruction. If the addend was separate, leave it alone,
3442 otherwise we may lose significant bits. */
3443 if (howto
->partial_inplace
)
3444 addend
= _bfd_mips_elf_sign_extend (addend
, 16);
3445 value
= symbol
+ addend
- gp
;
3446 /* If the symbol was local, any earlier relocatable links will
3447 have adjusted its addend with the gp offset, so compensate
3448 for that now. Don't do it for symbols forced local in this
3449 link, though, since they won't have had the gp offset applied
3453 overflowed_p
= mips_elf_overflow_p (value
, 16);
3462 /* The special case is when the symbol is forced to be local. We
3463 need the full address in the GOT since no R_MIPS_LO16 relocation
3465 forced
= ! mips_elf_local_relocation_p (input_bfd
, relocation
,
3466 local_sections
, FALSE
);
3467 value
= mips_elf_got16_entry (abfd
, input_bfd
, info
,
3468 symbol
+ addend
, forced
);
3469 if (value
== MINUS_ONE
)
3470 return bfd_reloc_outofrange
;
3472 = mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3473 abfd
, input_bfd
, value
);
3474 overflowed_p
= mips_elf_overflow_p (value
, 16);
3480 case R_MIPS_GOT_DISP
:
3483 overflowed_p
= mips_elf_overflow_p (value
, 16);
3486 case R_MIPS_GPREL32
:
3487 value
= (addend
+ symbol
+ gp0
- gp
);
3489 value
&= howto
->dst_mask
;
3493 value
= _bfd_mips_elf_sign_extend (addend
, 16) + symbol
- p
;
3494 overflowed_p
= mips_elf_overflow_p (value
, 16);
3497 case R_MIPS_GOT_HI16
:
3498 case R_MIPS_CALL_HI16
:
3499 /* We're allowed to handle these two relocations identically.
3500 The dynamic linker is allowed to handle the CALL relocations
3501 differently by creating a lazy evaluation stub. */
3503 value
= mips_elf_high (value
);
3504 value
&= howto
->dst_mask
;
3507 case R_MIPS_GOT_LO16
:
3508 case R_MIPS_CALL_LO16
:
3509 value
= g
& howto
->dst_mask
;
3512 case R_MIPS_GOT_PAGE
:
3513 /* GOT_PAGE relocations that reference non-local symbols decay
3514 to GOT_DISP. The corresponding GOT_OFST relocation decays to
3518 value
= mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, NULL
);
3519 if (value
== MINUS_ONE
)
3520 return bfd_reloc_outofrange
;
3521 value
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3522 abfd
, input_bfd
, value
);
3523 overflowed_p
= mips_elf_overflow_p (value
, 16);
3526 case R_MIPS_GOT_OFST
:
3528 mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, &value
);
3531 overflowed_p
= mips_elf_overflow_p (value
, 16);
3535 value
= symbol
- addend
;
3536 value
&= howto
->dst_mask
;
3540 value
= mips_elf_higher (addend
+ symbol
);
3541 value
&= howto
->dst_mask
;
3544 case R_MIPS_HIGHEST
:
3545 value
= mips_elf_highest (addend
+ symbol
);
3546 value
&= howto
->dst_mask
;
3549 case R_MIPS_SCN_DISP
:
3550 value
= symbol
+ addend
- sec
->output_offset
;
3551 value
&= howto
->dst_mask
;
3556 /* Both of these may be ignored. R_MIPS_JALR is an optimization
3557 hint; we could improve performance by honoring that hint. */
3558 return bfd_reloc_continue
;
3560 case R_MIPS_GNU_VTINHERIT
:
3561 case R_MIPS_GNU_VTENTRY
:
3562 /* We don't do anything with these at present. */
3563 return bfd_reloc_continue
;
3566 /* An unrecognized relocation type. */
3567 return bfd_reloc_notsupported
;
3570 /* Store the VALUE for our caller. */
3572 return overflowed_p
? bfd_reloc_overflow
: bfd_reloc_ok
;
3575 /* Obtain the field relocated by RELOCATION. */
3578 mips_elf_obtain_contents (reloc_howto_type
*howto
,
3579 const Elf_Internal_Rela
*relocation
,
3580 bfd
*input_bfd
, bfd_byte
*contents
)
3583 bfd_byte
*location
= contents
+ relocation
->r_offset
;
3585 /* Obtain the bytes. */
3586 x
= bfd_get ((8 * bfd_get_reloc_size (howto
)), input_bfd
, location
);
3588 if ((ELF_R_TYPE (input_bfd
, relocation
->r_info
) == R_MIPS16_26
3589 || ELF_R_TYPE (input_bfd
, relocation
->r_info
) == R_MIPS16_GPREL
)
3590 && bfd_little_endian (input_bfd
))
3591 /* The two 16-bit words will be reversed on a little-endian system.
3592 See mips_elf_perform_relocation for more details. */
3593 x
= (((x
& 0xffff) << 16) | ((x
& 0xffff0000) >> 16));
3598 /* It has been determined that the result of the RELOCATION is the
3599 VALUE. Use HOWTO to place VALUE into the output file at the
3600 appropriate position. The SECTION is the section to which the
3601 relocation applies. If REQUIRE_JALX is TRUE, then the opcode used
3602 for the relocation must be either JAL or JALX, and it is
3603 unconditionally converted to JALX.
3605 Returns FALSE if anything goes wrong. */
3608 mips_elf_perform_relocation (struct bfd_link_info
*info
,
3609 reloc_howto_type
*howto
,
3610 const Elf_Internal_Rela
*relocation
,
3611 bfd_vma value
, bfd
*input_bfd
,
3612 asection
*input_section
, bfd_byte
*contents
,
3613 bfd_boolean require_jalx
)
3617 int r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
3619 /* Figure out where the relocation is occurring. */
3620 location
= contents
+ relocation
->r_offset
;
3622 /* Obtain the current value. */
3623 x
= mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
);
3625 /* Clear the field we are setting. */
3626 x
&= ~howto
->dst_mask
;
3628 /* If this is the R_MIPS16_26 relocation, we must store the
3629 value in a funny way. */
3630 if (r_type
== R_MIPS16_26
)
3632 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
3633 Most mips16 instructions are 16 bits, but these instructions
3636 The format of these instructions is:
3638 +--------------+--------------------------------+
3639 ! JALX ! X! Imm 20:16 ! Imm 25:21 !
3640 +--------------+--------------------------------+
3642 +-----------------------------------------------+
3644 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
3645 Note that the immediate value in the first word is swapped.
3647 When producing a relocatable object file, R_MIPS16_26 is
3648 handled mostly like R_MIPS_26. In particular, the addend is
3649 stored as a straight 26-bit value in a 32-bit instruction.
3650 (gas makes life simpler for itself by never adjusting a
3651 R_MIPS16_26 reloc to be against a section, so the addend is
3652 always zero). However, the 32 bit instruction is stored as 2
3653 16-bit values, rather than a single 32-bit value. In a
3654 big-endian file, the result is the same; in a little-endian
3655 file, the two 16-bit halves of the 32 bit value are swapped.
3656 This is so that a disassembler can recognize the jal
3659 When doing a final link, R_MIPS16_26 is treated as a 32 bit
3660 instruction stored as two 16-bit values. The addend A is the
3661 contents of the targ26 field. The calculation is the same as
3662 R_MIPS_26. When storing the calculated value, reorder the
3663 immediate value as shown above, and don't forget to store the
3664 value as two 16-bit values.
3666 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
3670 +--------+----------------------+
3674 +--------+----------------------+
3677 +----------+------+-------------+
3681 +----------+--------------------+
3682 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
3683 ((sub1 << 16) | sub2)).
3685 When producing a relocatable object file, the calculation is
3686 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
3687 When producing a fully linked file, the calculation is
3688 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
3689 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff) */
3691 if (!info
->relocatable
)
3692 /* Shuffle the bits according to the formula above. */
3693 value
= (((value
& 0x1f0000) << 5)
3694 | ((value
& 0x3e00000) >> 5)
3695 | (value
& 0xffff));
3697 else if (r_type
== R_MIPS16_GPREL
)
3699 /* R_MIPS16_GPREL is used for GP-relative addressing in mips16
3700 mode. A typical instruction will have a format like this:
3702 +--------------+--------------------------------+
3703 ! EXTEND ! Imm 10:5 ! Imm 15:11 !
3704 +--------------+--------------------------------+
3705 ! Major ! rx ! ry ! Imm 4:0 !
3706 +--------------+--------------------------------+
3708 EXTEND is the five bit value 11110. Major is the instruction
3711 This is handled exactly like R_MIPS_GPREL16, except that the
3712 addend is retrieved and stored as shown in this diagram; that
3713 is, the Imm fields above replace the V-rel16 field.
3715 All we need to do here is shuffle the bits appropriately. As
3716 above, the two 16-bit halves must be swapped on a
3717 little-endian system. */
3718 value
= (((value
& 0x7e0) << 16)
3719 | ((value
& 0xf800) << 5)
3723 /* Set the field. */
3724 x
|= (value
& howto
->dst_mask
);
3726 /* If required, turn JAL into JALX. */
3730 bfd_vma opcode
= x
>> 26;
3731 bfd_vma jalx_opcode
;
3733 /* Check to see if the opcode is already JAL or JALX. */
3734 if (r_type
== R_MIPS16_26
)
3736 ok
= ((opcode
== 0x6) || (opcode
== 0x7));
3741 ok
= ((opcode
== 0x3) || (opcode
== 0x1d));
3745 /* If the opcode is not JAL or JALX, there's a problem. */
3748 (*_bfd_error_handler
)
3749 (_("%s: %s+0x%lx: jump to stub routine which is not jal"),
3750 bfd_archive_filename (input_bfd
),
3751 input_section
->name
,
3752 (unsigned long) relocation
->r_offset
);
3753 bfd_set_error (bfd_error_bad_value
);
3757 /* Make this the JALX opcode. */
3758 x
= (x
& ~(0x3f << 26)) | (jalx_opcode
<< 26);
3761 /* Swap the high- and low-order 16 bits on little-endian systems
3762 when doing a MIPS16 relocation. */
3763 if ((r_type
== R_MIPS16_GPREL
|| r_type
== R_MIPS16_26
)
3764 && bfd_little_endian (input_bfd
))
3765 x
= (((x
& 0xffff) << 16) | ((x
& 0xffff0000) >> 16));
3767 /* Put the value into the output. */
3768 bfd_put (8 * bfd_get_reloc_size (howto
), input_bfd
, x
, location
);
3772 /* Returns TRUE if SECTION is a MIPS16 stub section. */
3775 mips_elf_stub_section_p (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*section
)
3777 const char *name
= bfd_get_section_name (abfd
, section
);
3779 return (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0
3780 || strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
3781 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0);
3784 /* Add room for N relocations to the .rel.dyn section in ABFD. */
3787 mips_elf_allocate_dynamic_relocations (bfd
*abfd
, unsigned int n
)
3791 s
= mips_elf_rel_dyn_section (abfd
, FALSE
);
3792 BFD_ASSERT (s
!= NULL
);
3794 if (s
->_raw_size
== 0)
3796 /* Make room for a null element. */
3797 s
->_raw_size
+= MIPS_ELF_REL_SIZE (abfd
);
3800 s
->_raw_size
+= n
* MIPS_ELF_REL_SIZE (abfd
);
3803 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
3804 is the original relocation, which is now being transformed into a
3805 dynamic relocation. The ADDENDP is adjusted if necessary; the
3806 caller should store the result in place of the original addend. */
3809 mips_elf_create_dynamic_relocation (bfd
*output_bfd
,
3810 struct bfd_link_info
*info
,
3811 const Elf_Internal_Rela
*rel
,
3812 struct mips_elf_link_hash_entry
*h
,
3813 asection
*sec
, bfd_vma symbol
,
3814 bfd_vma
*addendp
, asection
*input_section
)
3816 Elf_Internal_Rela outrel
[3];
3822 r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
3823 dynobj
= elf_hash_table (info
)->dynobj
;
3824 sreloc
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
3825 BFD_ASSERT (sreloc
!= NULL
);
3826 BFD_ASSERT (sreloc
->contents
!= NULL
);
3827 BFD_ASSERT (sreloc
->reloc_count
* MIPS_ELF_REL_SIZE (output_bfd
)
3828 < sreloc
->_raw_size
);
3831 outrel
[0].r_offset
=
3832 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[0].r_offset
);
3833 outrel
[1].r_offset
=
3834 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[1].r_offset
);
3835 outrel
[2].r_offset
=
3836 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[2].r_offset
);
3839 /* We begin by assuming that the offset for the dynamic relocation
3840 is the same as for the original relocation. We'll adjust this
3841 later to reflect the correct output offsets. */
3842 if (input_section
->sec_info_type
!= ELF_INFO_TYPE_STABS
)
3844 outrel
[1].r_offset
= rel
[1].r_offset
;
3845 outrel
[2].r_offset
= rel
[2].r_offset
;
3849 /* Except that in a stab section things are more complex.
3850 Because we compress stab information, the offset given in the
3851 relocation may not be the one we want; we must let the stabs
3852 machinery tell us the offset. */
3853 outrel
[1].r_offset
= outrel
[0].r_offset
;
3854 outrel
[2].r_offset
= outrel
[0].r_offset
;
3855 /* If we didn't need the relocation at all, this value will be
3857 if (outrel
[0].r_offset
== (bfd_vma
) -1)
3862 if (outrel
[0].r_offset
== (bfd_vma
) -1)
3863 /* The relocation field has been deleted. */
3865 else if (outrel
[0].r_offset
== (bfd_vma
) -2)
3867 /* The relocation field has been converted into a relative value of
3868 some sort. Functions like _bfd_elf_write_section_eh_frame expect
3869 the field to be fully relocated, so add in the symbol's value. */
3874 /* If we've decided to skip this relocation, just output an empty
3875 record. Note that R_MIPS_NONE == 0, so that this call to memset
3876 is a way of setting R_TYPE to R_MIPS_NONE. */
3878 memset (outrel
, 0, sizeof (Elf_Internal_Rela
) * 3);
3882 bfd_boolean defined_p
;
3884 /* We must now calculate the dynamic symbol table index to use
3885 in the relocation. */
3887 && (! info
->symbolic
|| (h
->root
.elf_link_hash_flags
3888 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
3889 /* h->root.dynindx may be -1 if this symbol was marked to
3891 && h
->root
.dynindx
!= -1)
3893 indx
= h
->root
.dynindx
;
3894 if (SGI_COMPAT (output_bfd
))
3895 defined_p
= ((h
->root
.elf_link_hash_flags
3896 & ELF_LINK_HASH_DEF_REGULAR
) != 0);
3898 /* ??? glibc's ld.so just adds the final GOT entry to the
3899 relocation field. It therefore treats relocs against
3900 defined symbols in the same way as relocs against
3901 undefined symbols. */
3906 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
3908 else if (sec
== NULL
|| sec
->owner
== NULL
)
3910 bfd_set_error (bfd_error_bad_value
);
3915 indx
= elf_section_data (sec
->output_section
)->dynindx
;
3920 /* Instead of generating a relocation using the section
3921 symbol, we may as well make it a fully relative
3922 relocation. We want to avoid generating relocations to
3923 local symbols because we used to generate them
3924 incorrectly, without adding the original symbol value,
3925 which is mandated by the ABI for section symbols. In
3926 order to give dynamic loaders and applications time to
3927 phase out the incorrect use, we refrain from emitting
3928 section-relative relocations. It's not like they're
3929 useful, after all. This should be a bit more efficient
3931 /* ??? Although this behavior is compatible with glibc's ld.so,
3932 the ABI says that relocations against STN_UNDEF should have
3933 a symbol value of 0. Irix rld honors this, so relocations
3934 against STN_UNDEF have no effect. */
3935 if (!SGI_COMPAT (output_bfd
))
3940 /* If the relocation was previously an absolute relocation and
3941 this symbol will not be referred to by the relocation, we must
3942 adjust it by the value we give it in the dynamic symbol table.
3943 Otherwise leave the job up to the dynamic linker. */
3944 if (defined_p
&& r_type
!= R_MIPS_REL32
)
3947 /* The relocation is always an REL32 relocation because we don't
3948 know where the shared library will wind up at load-time. */
3949 outrel
[0].r_info
= ELF_R_INFO (output_bfd
, (unsigned long) indx
,
3951 /* For strict adherence to the ABI specification, we should
3952 generate a R_MIPS_64 relocation record by itself before the
3953 _REL32/_64 record as well, such that the addend is read in as
3954 a 64-bit value (REL32 is a 32-bit relocation, after all).
3955 However, since none of the existing ELF64 MIPS dynamic
3956 loaders seems to care, we don't waste space with these
3957 artificial relocations. If this turns out to not be true,
3958 mips_elf_allocate_dynamic_relocation() should be tweaked so
3959 as to make room for a pair of dynamic relocations per
3960 invocation if ABI_64_P, and here we should generate an
3961 additional relocation record with R_MIPS_64 by itself for a
3962 NULL symbol before this relocation record. */
3963 outrel
[1].r_info
= ELF_R_INFO (output_bfd
, 0,
3964 ABI_64_P (output_bfd
)
3967 outrel
[2].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_NONE
);
3969 /* Adjust the output offset of the relocation to reference the
3970 correct location in the output file. */
3971 outrel
[0].r_offset
+= (input_section
->output_section
->vma
3972 + input_section
->output_offset
);
3973 outrel
[1].r_offset
+= (input_section
->output_section
->vma
3974 + input_section
->output_offset
);
3975 outrel
[2].r_offset
+= (input_section
->output_section
->vma
3976 + input_section
->output_offset
);
3979 /* Put the relocation back out. We have to use the special
3980 relocation outputter in the 64-bit case since the 64-bit
3981 relocation format is non-standard. */
3982 if (ABI_64_P (output_bfd
))
3984 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
3985 (output_bfd
, &outrel
[0],
3987 + sreloc
->reloc_count
* sizeof (Elf64_Mips_External_Rel
)));
3990 bfd_elf32_swap_reloc_out
3991 (output_bfd
, &outrel
[0],
3992 (sreloc
->contents
+ sreloc
->reloc_count
* sizeof (Elf32_External_Rel
)));
3994 /* We've now added another relocation. */
3995 ++sreloc
->reloc_count
;
3997 /* Make sure the output section is writable. The dynamic linker
3998 will be writing to it. */
3999 elf_section_data (input_section
->output_section
)->this_hdr
.sh_flags
4002 /* On IRIX5, make an entry of compact relocation info. */
4003 if (! skip
&& IRIX_COMPAT (output_bfd
) == ict_irix5
)
4005 asection
*scpt
= bfd_get_section_by_name (dynobj
, ".compact_rel");
4010 Elf32_crinfo cptrel
;
4012 mips_elf_set_cr_format (cptrel
, CRF_MIPS_LONG
);
4013 cptrel
.vaddr
= (rel
->r_offset
4014 + input_section
->output_section
->vma
4015 + input_section
->output_offset
);
4016 if (r_type
== R_MIPS_REL32
)
4017 mips_elf_set_cr_type (cptrel
, CRT_MIPS_REL32
);
4019 mips_elf_set_cr_type (cptrel
, CRT_MIPS_WORD
);
4020 mips_elf_set_cr_dist2to (cptrel
, 0);
4021 cptrel
.konst
= *addendp
;
4023 cr
= (scpt
->contents
4024 + sizeof (Elf32_External_compact_rel
));
4025 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
4026 ((Elf32_External_crinfo
*) cr
4027 + scpt
->reloc_count
));
4028 ++scpt
->reloc_count
;
4035 /* Return the MACH for a MIPS e_flags value. */
4038 _bfd_elf_mips_mach (flagword flags
)
4040 switch (flags
& EF_MIPS_MACH
)
4042 case E_MIPS_MACH_3900
:
4043 return bfd_mach_mips3900
;
4045 case E_MIPS_MACH_4010
:
4046 return bfd_mach_mips4010
;
4048 case E_MIPS_MACH_4100
:
4049 return bfd_mach_mips4100
;
4051 case E_MIPS_MACH_4111
:
4052 return bfd_mach_mips4111
;
4054 case E_MIPS_MACH_4120
:
4055 return bfd_mach_mips4120
;
4057 case E_MIPS_MACH_4650
:
4058 return bfd_mach_mips4650
;
4060 case E_MIPS_MACH_5400
:
4061 return bfd_mach_mips5400
;
4063 case E_MIPS_MACH_5500
:
4064 return bfd_mach_mips5500
;
4066 case E_MIPS_MACH_SB1
:
4067 return bfd_mach_mips_sb1
;
4070 switch (flags
& EF_MIPS_ARCH
)
4074 return bfd_mach_mips3000
;
4078 return bfd_mach_mips6000
;
4082 return bfd_mach_mips4000
;
4086 return bfd_mach_mips8000
;
4090 return bfd_mach_mips5
;
4093 case E_MIPS_ARCH_32
:
4094 return bfd_mach_mipsisa32
;
4097 case E_MIPS_ARCH_64
:
4098 return bfd_mach_mipsisa64
;
4101 case E_MIPS_ARCH_32R2
:
4102 return bfd_mach_mipsisa32r2
;
4105 case E_MIPS_ARCH_64R2
:
4106 return bfd_mach_mipsisa64r2
;
4114 /* Return printable name for ABI. */
4116 static INLINE
char *
4117 elf_mips_abi_name (bfd
*abfd
)
4121 flags
= elf_elfheader (abfd
)->e_flags
;
4122 switch (flags
& EF_MIPS_ABI
)
4125 if (ABI_N32_P (abfd
))
4127 else if (ABI_64_P (abfd
))
4131 case E_MIPS_ABI_O32
:
4133 case E_MIPS_ABI_O64
:
4135 case E_MIPS_ABI_EABI32
:
4137 case E_MIPS_ABI_EABI64
:
4140 return "unknown abi";
4144 /* MIPS ELF uses two common sections. One is the usual one, and the
4145 other is for small objects. All the small objects are kept
4146 together, and then referenced via the gp pointer, which yields
4147 faster assembler code. This is what we use for the small common
4148 section. This approach is copied from ecoff.c. */
4149 static asection mips_elf_scom_section
;
4150 static asymbol mips_elf_scom_symbol
;
4151 static asymbol
*mips_elf_scom_symbol_ptr
;
4153 /* MIPS ELF also uses an acommon section, which represents an
4154 allocated common symbol which may be overridden by a
4155 definition in a shared library. */
4156 static asection mips_elf_acom_section
;
4157 static asymbol mips_elf_acom_symbol
;
4158 static asymbol
*mips_elf_acom_symbol_ptr
;
4160 /* Handle the special MIPS section numbers that a symbol may use.
4161 This is used for both the 32-bit and the 64-bit ABI. */
4164 _bfd_mips_elf_symbol_processing (bfd
*abfd
, asymbol
*asym
)
4166 elf_symbol_type
*elfsym
;
4168 elfsym
= (elf_symbol_type
*) asym
;
4169 switch (elfsym
->internal_elf_sym
.st_shndx
)
4171 case SHN_MIPS_ACOMMON
:
4172 /* This section is used in a dynamically linked executable file.
4173 It is an allocated common section. The dynamic linker can
4174 either resolve these symbols to something in a shared
4175 library, or it can just leave them here. For our purposes,
4176 we can consider these symbols to be in a new section. */
4177 if (mips_elf_acom_section
.name
== NULL
)
4179 /* Initialize the acommon section. */
4180 mips_elf_acom_section
.name
= ".acommon";
4181 mips_elf_acom_section
.flags
= SEC_ALLOC
;
4182 mips_elf_acom_section
.output_section
= &mips_elf_acom_section
;
4183 mips_elf_acom_section
.symbol
= &mips_elf_acom_symbol
;
4184 mips_elf_acom_section
.symbol_ptr_ptr
= &mips_elf_acom_symbol_ptr
;
4185 mips_elf_acom_symbol
.name
= ".acommon";
4186 mips_elf_acom_symbol
.flags
= BSF_SECTION_SYM
;
4187 mips_elf_acom_symbol
.section
= &mips_elf_acom_section
;
4188 mips_elf_acom_symbol_ptr
= &mips_elf_acom_symbol
;
4190 asym
->section
= &mips_elf_acom_section
;
4194 /* Common symbols less than the GP size are automatically
4195 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
4196 if (asym
->value
> elf_gp_size (abfd
)
4197 || IRIX_COMPAT (abfd
) == ict_irix6
)
4200 case SHN_MIPS_SCOMMON
:
4201 if (mips_elf_scom_section
.name
== NULL
)
4203 /* Initialize the small common section. */
4204 mips_elf_scom_section
.name
= ".scommon";
4205 mips_elf_scom_section
.flags
= SEC_IS_COMMON
;
4206 mips_elf_scom_section
.output_section
= &mips_elf_scom_section
;
4207 mips_elf_scom_section
.symbol
= &mips_elf_scom_symbol
;
4208 mips_elf_scom_section
.symbol_ptr_ptr
= &mips_elf_scom_symbol_ptr
;
4209 mips_elf_scom_symbol
.name
= ".scommon";
4210 mips_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
4211 mips_elf_scom_symbol
.section
= &mips_elf_scom_section
;
4212 mips_elf_scom_symbol_ptr
= &mips_elf_scom_symbol
;
4214 asym
->section
= &mips_elf_scom_section
;
4215 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
4218 case SHN_MIPS_SUNDEFINED
:
4219 asym
->section
= bfd_und_section_ptr
;
4222 #if 0 /* for SGI_COMPAT */
4224 asym
->section
= mips_elf_text_section_ptr
;
4228 asym
->section
= mips_elf_data_section_ptr
;
4234 /* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
4235 relocations against two unnamed section symbols to resolve to the
4236 same address. For example, if we have code like:
4238 lw $4,%got_disp(.data)($gp)
4239 lw $25,%got_disp(.text)($gp)
4242 then the linker will resolve both relocations to .data and the program
4243 will jump there rather than to .text.
4245 We can work around this problem by giving names to local section symbols.
4246 This is also what the MIPSpro tools do. */
4249 _bfd_mips_elf_name_local_section_symbols (bfd
*abfd
)
4251 return SGI_COMPAT (abfd
);
4254 /* Work over a section just before writing it out. This routine is
4255 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
4256 sections that need the SHF_MIPS_GPREL flag by name; there has to be
4260 _bfd_mips_elf_section_processing (bfd
*abfd
, Elf_Internal_Shdr
*hdr
)
4262 if (hdr
->sh_type
== SHT_MIPS_REGINFO
4263 && hdr
->sh_size
> 0)
4267 BFD_ASSERT (hdr
->sh_size
== sizeof (Elf32_External_RegInfo
));
4268 BFD_ASSERT (hdr
->contents
== NULL
);
4271 hdr
->sh_offset
+ sizeof (Elf32_External_RegInfo
) - 4,
4274 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
4275 if (bfd_bwrite (buf
, 4, abfd
) != 4)
4279 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
4280 && hdr
->bfd_section
!= NULL
4281 && mips_elf_section_data (hdr
->bfd_section
) != NULL
4282 && mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
!= NULL
)
4284 bfd_byte
*contents
, *l
, *lend
;
4286 /* We stored the section contents in the tdata field in the
4287 set_section_contents routine. We save the section contents
4288 so that we don't have to read them again.
4289 At this point we know that elf_gp is set, so we can look
4290 through the section contents to see if there is an
4291 ODK_REGINFO structure. */
4293 contents
= mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
;
4295 lend
= contents
+ hdr
->sh_size
;
4296 while (l
+ sizeof (Elf_External_Options
) <= lend
)
4298 Elf_Internal_Options intopt
;
4300 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
4302 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
4309 + sizeof (Elf_External_Options
)
4310 + (sizeof (Elf64_External_RegInfo
) - 8)),
4313 H_PUT_64 (abfd
, elf_gp (abfd
), buf
);
4314 if (bfd_bwrite (buf
, 8, abfd
) != 8)
4317 else if (intopt
.kind
== ODK_REGINFO
)
4324 + sizeof (Elf_External_Options
)
4325 + (sizeof (Elf32_External_RegInfo
) - 4)),
4328 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
4329 if (bfd_bwrite (buf
, 4, abfd
) != 4)
4336 if (hdr
->bfd_section
!= NULL
)
4338 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
4340 if (strcmp (name
, ".sdata") == 0
4341 || strcmp (name
, ".lit8") == 0
4342 || strcmp (name
, ".lit4") == 0)
4344 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
4345 hdr
->sh_type
= SHT_PROGBITS
;
4347 else if (strcmp (name
, ".sbss") == 0)
4349 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
4350 hdr
->sh_type
= SHT_NOBITS
;
4352 else if (strcmp (name
, ".srdata") == 0)
4354 hdr
->sh_flags
|= SHF_ALLOC
| SHF_MIPS_GPREL
;
4355 hdr
->sh_type
= SHT_PROGBITS
;
4357 else if (strcmp (name
, ".compact_rel") == 0)
4360 hdr
->sh_type
= SHT_PROGBITS
;
4362 else if (strcmp (name
, ".rtproc") == 0)
4364 if (hdr
->sh_addralign
!= 0 && hdr
->sh_entsize
== 0)
4366 unsigned int adjust
;
4368 adjust
= hdr
->sh_size
% hdr
->sh_addralign
;
4370 hdr
->sh_size
+= hdr
->sh_addralign
- adjust
;
4378 /* Handle a MIPS specific section when reading an object file. This
4379 is called when elfcode.h finds a section with an unknown type.
4380 This routine supports both the 32-bit and 64-bit ELF ABI.
4382 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
4386 _bfd_mips_elf_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
4391 /* There ought to be a place to keep ELF backend specific flags, but
4392 at the moment there isn't one. We just keep track of the
4393 sections by their name, instead. Fortunately, the ABI gives
4394 suggested names for all the MIPS specific sections, so we will
4395 probably get away with this. */
4396 switch (hdr
->sh_type
)
4398 case SHT_MIPS_LIBLIST
:
4399 if (strcmp (name
, ".liblist") != 0)
4403 if (strcmp (name
, ".msym") != 0)
4406 case SHT_MIPS_CONFLICT
:
4407 if (strcmp (name
, ".conflict") != 0)
4410 case SHT_MIPS_GPTAB
:
4411 if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) != 0)
4414 case SHT_MIPS_UCODE
:
4415 if (strcmp (name
, ".ucode") != 0)
4418 case SHT_MIPS_DEBUG
:
4419 if (strcmp (name
, ".mdebug") != 0)
4421 flags
= SEC_DEBUGGING
;
4423 case SHT_MIPS_REGINFO
:
4424 if (strcmp (name
, ".reginfo") != 0
4425 || hdr
->sh_size
!= sizeof (Elf32_External_RegInfo
))
4427 flags
= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_SIZE
);
4429 case SHT_MIPS_IFACE
:
4430 if (strcmp (name
, ".MIPS.interfaces") != 0)
4433 case SHT_MIPS_CONTENT
:
4434 if (strncmp (name
, ".MIPS.content", sizeof ".MIPS.content" - 1) != 0)
4437 case SHT_MIPS_OPTIONS
:
4438 if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) != 0)
4441 case SHT_MIPS_DWARF
:
4442 if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) != 0)
4445 case SHT_MIPS_SYMBOL_LIB
:
4446 if (strcmp (name
, ".MIPS.symlib") != 0)
4449 case SHT_MIPS_EVENTS
:
4450 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) != 0
4451 && strncmp (name
, ".MIPS.post_rel",
4452 sizeof ".MIPS.post_rel" - 1) != 0)
4459 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
4464 if (! bfd_set_section_flags (abfd
, hdr
->bfd_section
,
4465 (bfd_get_section_flags (abfd
,
4471 /* FIXME: We should record sh_info for a .gptab section. */
4473 /* For a .reginfo section, set the gp value in the tdata information
4474 from the contents of this section. We need the gp value while
4475 processing relocs, so we just get it now. The .reginfo section
4476 is not used in the 64-bit MIPS ELF ABI. */
4477 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
4479 Elf32_External_RegInfo ext
;
4482 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
,
4483 &ext
, 0, sizeof ext
))
4485 bfd_mips_elf32_swap_reginfo_in (abfd
, &ext
, &s
);
4486 elf_gp (abfd
) = s
.ri_gp_value
;
4489 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
4490 set the gp value based on what we find. We may see both
4491 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
4492 they should agree. */
4493 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
)
4495 bfd_byte
*contents
, *l
, *lend
;
4497 contents
= bfd_malloc (hdr
->sh_size
);
4498 if (contents
== NULL
)
4500 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
,
4507 lend
= contents
+ hdr
->sh_size
;
4508 while (l
+ sizeof (Elf_External_Options
) <= lend
)
4510 Elf_Internal_Options intopt
;
4512 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
4514 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
4516 Elf64_Internal_RegInfo intreg
;
4518 bfd_mips_elf64_swap_reginfo_in
4520 ((Elf64_External_RegInfo
*)
4521 (l
+ sizeof (Elf_External_Options
))),
4523 elf_gp (abfd
) = intreg
.ri_gp_value
;
4525 else if (intopt
.kind
== ODK_REGINFO
)
4527 Elf32_RegInfo intreg
;
4529 bfd_mips_elf32_swap_reginfo_in
4531 ((Elf32_External_RegInfo
*)
4532 (l
+ sizeof (Elf_External_Options
))),
4534 elf_gp (abfd
) = intreg
.ri_gp_value
;
4544 /* Set the correct type for a MIPS ELF section. We do this by the
4545 section name, which is a hack, but ought to work. This routine is
4546 used by both the 32-bit and the 64-bit ABI. */
4549 _bfd_mips_elf_fake_sections (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*sec
)
4551 register const char *name
;
4553 name
= bfd_get_section_name (abfd
, sec
);
4555 if (strcmp (name
, ".liblist") == 0)
4557 hdr
->sh_type
= SHT_MIPS_LIBLIST
;
4558 hdr
->sh_info
= sec
->_raw_size
/ sizeof (Elf32_Lib
);
4559 /* The sh_link field is set in final_write_processing. */
4561 else if (strcmp (name
, ".conflict") == 0)
4562 hdr
->sh_type
= SHT_MIPS_CONFLICT
;
4563 else if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0)
4565 hdr
->sh_type
= SHT_MIPS_GPTAB
;
4566 hdr
->sh_entsize
= sizeof (Elf32_External_gptab
);
4567 /* The sh_info field is set in final_write_processing. */
4569 else if (strcmp (name
, ".ucode") == 0)
4570 hdr
->sh_type
= SHT_MIPS_UCODE
;
4571 else if (strcmp (name
, ".mdebug") == 0)
4573 hdr
->sh_type
= SHT_MIPS_DEBUG
;
4574 /* In a shared object on IRIX 5.3, the .mdebug section has an
4575 entsize of 0. FIXME: Does this matter? */
4576 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
4577 hdr
->sh_entsize
= 0;
4579 hdr
->sh_entsize
= 1;
4581 else if (strcmp (name
, ".reginfo") == 0)
4583 hdr
->sh_type
= SHT_MIPS_REGINFO
;
4584 /* In a shared object on IRIX 5.3, the .reginfo section has an
4585 entsize of 0x18. FIXME: Does this matter? */
4586 if (SGI_COMPAT (abfd
))
4588 if ((abfd
->flags
& DYNAMIC
) != 0)
4589 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
4591 hdr
->sh_entsize
= 1;
4594 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
4596 else if (SGI_COMPAT (abfd
)
4597 && (strcmp (name
, ".hash") == 0
4598 || strcmp (name
, ".dynamic") == 0
4599 || strcmp (name
, ".dynstr") == 0))
4601 if (SGI_COMPAT (abfd
))
4602 hdr
->sh_entsize
= 0;
4604 /* This isn't how the IRIX6 linker behaves. */
4605 hdr
->sh_info
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
4608 else if (strcmp (name
, ".got") == 0
4609 || strcmp (name
, ".srdata") == 0
4610 || strcmp (name
, ".sdata") == 0
4611 || strcmp (name
, ".sbss") == 0
4612 || strcmp (name
, ".lit4") == 0
4613 || strcmp (name
, ".lit8") == 0)
4614 hdr
->sh_flags
|= SHF_MIPS_GPREL
;
4615 else if (strcmp (name
, ".MIPS.interfaces") == 0)
4617 hdr
->sh_type
= SHT_MIPS_IFACE
;
4618 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4620 else if (strncmp (name
, ".MIPS.content", strlen (".MIPS.content")) == 0)
4622 hdr
->sh_type
= SHT_MIPS_CONTENT
;
4623 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4624 /* The sh_info field is set in final_write_processing. */
4626 else if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
4628 hdr
->sh_type
= SHT_MIPS_OPTIONS
;
4629 hdr
->sh_entsize
= 1;
4630 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4632 else if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) == 0)
4633 hdr
->sh_type
= SHT_MIPS_DWARF
;
4634 else if (strcmp (name
, ".MIPS.symlib") == 0)
4636 hdr
->sh_type
= SHT_MIPS_SYMBOL_LIB
;
4637 /* The sh_link and sh_info fields are set in
4638 final_write_processing. */
4640 else if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0
4641 || strncmp (name
, ".MIPS.post_rel",
4642 sizeof ".MIPS.post_rel" - 1) == 0)
4644 hdr
->sh_type
= SHT_MIPS_EVENTS
;
4645 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4646 /* The sh_link field is set in final_write_processing. */
4648 else if (strcmp (name
, ".msym") == 0)
4650 hdr
->sh_type
= SHT_MIPS_MSYM
;
4651 hdr
->sh_flags
|= SHF_ALLOC
;
4652 hdr
->sh_entsize
= 8;
4655 /* The generic elf_fake_sections will set up REL_HDR using the default
4656 kind of relocations. We used to set up a second header for the
4657 non-default kind of relocations here, but only NewABI would use
4658 these, and the IRIX ld doesn't like resulting empty RELA sections.
4659 Thus we create those header only on demand now. */
4664 /* Given a BFD section, try to locate the corresponding ELF section
4665 index. This is used by both the 32-bit and the 64-bit ABI.
4666 Actually, it's not clear to me that the 64-bit ABI supports these,
4667 but for non-PIC objects we will certainly want support for at least
4668 the .scommon section. */
4671 _bfd_mips_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
4672 asection
*sec
, int *retval
)
4674 if (strcmp (bfd_get_section_name (abfd
, sec
), ".scommon") == 0)
4676 *retval
= SHN_MIPS_SCOMMON
;
4679 if (strcmp (bfd_get_section_name (abfd
, sec
), ".acommon") == 0)
4681 *retval
= SHN_MIPS_ACOMMON
;
4687 /* Hook called by the linker routine which adds symbols from an object
4688 file. We must handle the special MIPS section numbers here. */
4691 _bfd_mips_elf_add_symbol_hook (bfd
*abfd
, struct bfd_link_info
*info
,
4692 Elf_Internal_Sym
*sym
, const char **namep
,
4693 flagword
*flagsp ATTRIBUTE_UNUSED
,
4694 asection
**secp
, bfd_vma
*valp
)
4696 if (SGI_COMPAT (abfd
)
4697 && (abfd
->flags
& DYNAMIC
) != 0
4698 && strcmp (*namep
, "_rld_new_interface") == 0)
4700 /* Skip IRIX5 rld entry name. */
4705 switch (sym
->st_shndx
)
4708 /* Common symbols less than the GP size are automatically
4709 treated as SHN_MIPS_SCOMMON symbols. */
4710 if (sym
->st_size
> elf_gp_size (abfd
)
4711 || IRIX_COMPAT (abfd
) == ict_irix6
)
4714 case SHN_MIPS_SCOMMON
:
4715 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
4716 (*secp
)->flags
|= SEC_IS_COMMON
;
4717 *valp
= sym
->st_size
;
4721 /* This section is used in a shared object. */
4722 if (elf_tdata (abfd
)->elf_text_section
== NULL
)
4724 asymbol
*elf_text_symbol
;
4725 asection
*elf_text_section
;
4726 bfd_size_type amt
= sizeof (asection
);
4728 elf_text_section
= bfd_zalloc (abfd
, amt
);
4729 if (elf_text_section
== NULL
)
4732 amt
= sizeof (asymbol
);
4733 elf_text_symbol
= bfd_zalloc (abfd
, amt
);
4734 if (elf_text_symbol
== NULL
)
4737 /* Initialize the section. */
4739 elf_tdata (abfd
)->elf_text_section
= elf_text_section
;
4740 elf_tdata (abfd
)->elf_text_symbol
= elf_text_symbol
;
4742 elf_text_section
->symbol
= elf_text_symbol
;
4743 elf_text_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_text_symbol
;
4745 elf_text_section
->name
= ".text";
4746 elf_text_section
->flags
= SEC_NO_FLAGS
;
4747 elf_text_section
->output_section
= NULL
;
4748 elf_text_section
->owner
= abfd
;
4749 elf_text_symbol
->name
= ".text";
4750 elf_text_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
4751 elf_text_symbol
->section
= elf_text_section
;
4753 /* This code used to do *secp = bfd_und_section_ptr if
4754 info->shared. I don't know why, and that doesn't make sense,
4755 so I took it out. */
4756 *secp
= elf_tdata (abfd
)->elf_text_section
;
4759 case SHN_MIPS_ACOMMON
:
4760 /* Fall through. XXX Can we treat this as allocated data? */
4762 /* This section is used in a shared object. */
4763 if (elf_tdata (abfd
)->elf_data_section
== NULL
)
4765 asymbol
*elf_data_symbol
;
4766 asection
*elf_data_section
;
4767 bfd_size_type amt
= sizeof (asection
);
4769 elf_data_section
= bfd_zalloc (abfd
, amt
);
4770 if (elf_data_section
== NULL
)
4773 amt
= sizeof (asymbol
);
4774 elf_data_symbol
= bfd_zalloc (abfd
, amt
);
4775 if (elf_data_symbol
== NULL
)
4778 /* Initialize the section. */
4780 elf_tdata (abfd
)->elf_data_section
= elf_data_section
;
4781 elf_tdata (abfd
)->elf_data_symbol
= elf_data_symbol
;
4783 elf_data_section
->symbol
= elf_data_symbol
;
4784 elf_data_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_data_symbol
;
4786 elf_data_section
->name
= ".data";
4787 elf_data_section
->flags
= SEC_NO_FLAGS
;
4788 elf_data_section
->output_section
= NULL
;
4789 elf_data_section
->owner
= abfd
;
4790 elf_data_symbol
->name
= ".data";
4791 elf_data_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
4792 elf_data_symbol
->section
= elf_data_section
;
4794 /* This code used to do *secp = bfd_und_section_ptr if
4795 info->shared. I don't know why, and that doesn't make sense,
4796 so I took it out. */
4797 *secp
= elf_tdata (abfd
)->elf_data_section
;
4800 case SHN_MIPS_SUNDEFINED
:
4801 *secp
= bfd_und_section_ptr
;
4805 if (SGI_COMPAT (abfd
)
4807 && info
->hash
->creator
== abfd
->xvec
4808 && strcmp (*namep
, "__rld_obj_head") == 0)
4810 struct elf_link_hash_entry
*h
;
4811 struct bfd_link_hash_entry
*bh
;
4813 /* Mark __rld_obj_head as dynamic. */
4815 if (! (_bfd_generic_link_add_one_symbol
4816 (info
, abfd
, *namep
, BSF_GLOBAL
, *secp
, *valp
, NULL
, FALSE
,
4817 get_elf_backend_data (abfd
)->collect
, &bh
)))
4820 h
= (struct elf_link_hash_entry
*) bh
;
4821 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
4822 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4823 h
->type
= STT_OBJECT
;
4825 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
4828 mips_elf_hash_table (info
)->use_rld_obj_head
= TRUE
;
4831 /* If this is a mips16 text symbol, add 1 to the value to make it
4832 odd. This will cause something like .word SYM to come up with
4833 the right value when it is loaded into the PC. */
4834 if (sym
->st_other
== STO_MIPS16
)
4840 /* This hook function is called before the linker writes out a global
4841 symbol. We mark symbols as small common if appropriate. This is
4842 also where we undo the increment of the value for a mips16 symbol. */
4845 _bfd_mips_elf_link_output_symbol_hook
4846 (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4847 const char *name ATTRIBUTE_UNUSED
, Elf_Internal_Sym
*sym
,
4848 asection
*input_sec
, struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
)
4850 /* If we see a common symbol, which implies a relocatable link, then
4851 if a symbol was small common in an input file, mark it as small
4852 common in the output file. */
4853 if (sym
->st_shndx
== SHN_COMMON
4854 && strcmp (input_sec
->name
, ".scommon") == 0)
4855 sym
->st_shndx
= SHN_MIPS_SCOMMON
;
4857 if (sym
->st_other
== STO_MIPS16
)
4858 sym
->st_value
&= ~1;
4863 /* Functions for the dynamic linker. */
4865 /* Create dynamic sections when linking against a dynamic object. */
4868 _bfd_mips_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
4870 struct elf_link_hash_entry
*h
;
4871 struct bfd_link_hash_entry
*bh
;
4873 register asection
*s
;
4874 const char * const *namep
;
4876 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
4877 | SEC_LINKER_CREATED
| SEC_READONLY
);
4879 /* Mips ABI requests the .dynamic section to be read only. */
4880 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4883 if (! bfd_set_section_flags (abfd
, s
, flags
))
4887 /* We need to create .got section. */
4888 if (! mips_elf_create_got_section (abfd
, info
, FALSE
))
4891 if (! mips_elf_rel_dyn_section (elf_hash_table (info
)->dynobj
, TRUE
))
4894 /* Create .stub section. */
4895 if (bfd_get_section_by_name (abfd
,
4896 MIPS_ELF_STUB_SECTION_NAME (abfd
)) == NULL
)
4898 s
= bfd_make_section (abfd
, MIPS_ELF_STUB_SECTION_NAME (abfd
));
4900 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_CODE
)
4901 || ! bfd_set_section_alignment (abfd
, s
,
4902 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
4906 if ((IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
4908 && bfd_get_section_by_name (abfd
, ".rld_map") == NULL
)
4910 s
= bfd_make_section (abfd
, ".rld_map");
4912 || ! bfd_set_section_flags (abfd
, s
, flags
&~ (flagword
) SEC_READONLY
)
4913 || ! bfd_set_section_alignment (abfd
, s
,
4914 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
4918 /* On IRIX5, we adjust add some additional symbols and change the
4919 alignments of several sections. There is no ABI documentation
4920 indicating that this is necessary on IRIX6, nor any evidence that
4921 the linker takes such action. */
4922 if (IRIX_COMPAT (abfd
) == ict_irix5
)
4924 for (namep
= mips_elf_dynsym_rtproc_names
; *namep
!= NULL
; namep
++)
4927 if (! (_bfd_generic_link_add_one_symbol
4928 (info
, abfd
, *namep
, BSF_GLOBAL
, bfd_und_section_ptr
, 0,
4929 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
4932 h
= (struct elf_link_hash_entry
*) bh
;
4933 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
4934 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4935 h
->type
= STT_SECTION
;
4937 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
4941 /* We need to create a .compact_rel section. */
4942 if (SGI_COMPAT (abfd
))
4944 if (!mips_elf_create_compact_rel_section (abfd
, info
))
4948 /* Change alignments of some sections. */
4949 s
= bfd_get_section_by_name (abfd
, ".hash");
4951 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4952 s
= bfd_get_section_by_name (abfd
, ".dynsym");
4954 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4955 s
= bfd_get_section_by_name (abfd
, ".dynstr");
4957 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4958 s
= bfd_get_section_by_name (abfd
, ".reginfo");
4960 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4961 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4963 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4970 name
= SGI_COMPAT (abfd
) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
4972 if (!(_bfd_generic_link_add_one_symbol
4973 (info
, abfd
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
, 0,
4974 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
4977 h
= (struct elf_link_hash_entry
*) bh
;
4978 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
4979 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4980 h
->type
= STT_SECTION
;
4982 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
4985 if (! mips_elf_hash_table (info
)->use_rld_obj_head
)
4987 /* __rld_map is a four byte word located in the .data section
4988 and is filled in by the rtld to contain a pointer to
4989 the _r_debug structure. Its symbol value will be set in
4990 _bfd_mips_elf_finish_dynamic_symbol. */
4991 s
= bfd_get_section_by_name (abfd
, ".rld_map");
4992 BFD_ASSERT (s
!= NULL
);
4994 name
= SGI_COMPAT (abfd
) ? "__rld_map" : "__RLD_MAP";
4996 if (!(_bfd_generic_link_add_one_symbol
4997 (info
, abfd
, name
, BSF_GLOBAL
, s
, 0, NULL
, FALSE
,
4998 get_elf_backend_data (abfd
)->collect
, &bh
)))
5001 h
= (struct elf_link_hash_entry
*) bh
;
5002 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
5003 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
5004 h
->type
= STT_OBJECT
;
5006 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
5014 /* Look through the relocs for a section during the first phase, and
5015 allocate space in the global offset table. */
5018 _bfd_mips_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
5019 asection
*sec
, const Elf_Internal_Rela
*relocs
)
5023 Elf_Internal_Shdr
*symtab_hdr
;
5024 struct elf_link_hash_entry
**sym_hashes
;
5025 struct mips_got_info
*g
;
5027 const Elf_Internal_Rela
*rel
;
5028 const Elf_Internal_Rela
*rel_end
;
5031 const struct elf_backend_data
*bed
;
5033 if (info
->relocatable
)
5036 dynobj
= elf_hash_table (info
)->dynobj
;
5037 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5038 sym_hashes
= elf_sym_hashes (abfd
);
5039 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
5041 /* Check for the mips16 stub sections. */
5043 name
= bfd_get_section_name (abfd
, sec
);
5044 if (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0)
5046 unsigned long r_symndx
;
5048 /* Look at the relocation information to figure out which symbol
5051 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
5053 if (r_symndx
< extsymoff
5054 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
5058 /* This stub is for a local symbol. This stub will only be
5059 needed if there is some relocation in this BFD, other
5060 than a 16 bit function call, which refers to this symbol. */
5061 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5063 Elf_Internal_Rela
*sec_relocs
;
5064 const Elf_Internal_Rela
*r
, *rend
;
5066 /* We can ignore stub sections when looking for relocs. */
5067 if ((o
->flags
& SEC_RELOC
) == 0
5068 || o
->reloc_count
== 0
5069 || strncmp (bfd_get_section_name (abfd
, o
), FN_STUB
,
5070 sizeof FN_STUB
- 1) == 0
5071 || strncmp (bfd_get_section_name (abfd
, o
), CALL_STUB
,
5072 sizeof CALL_STUB
- 1) == 0
5073 || strncmp (bfd_get_section_name (abfd
, o
), CALL_FP_STUB
,
5074 sizeof CALL_FP_STUB
- 1) == 0)
5078 = _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
5080 if (sec_relocs
== NULL
)
5083 rend
= sec_relocs
+ o
->reloc_count
;
5084 for (r
= sec_relocs
; r
< rend
; r
++)
5085 if (ELF_R_SYM (abfd
, r
->r_info
) == r_symndx
5086 && ELF_R_TYPE (abfd
, r
->r_info
) != R_MIPS16_26
)
5089 if (elf_section_data (o
)->relocs
!= sec_relocs
)
5098 /* There is no non-call reloc for this stub, so we do
5099 not need it. Since this function is called before
5100 the linker maps input sections to output sections, we
5101 can easily discard it by setting the SEC_EXCLUDE
5103 sec
->flags
|= SEC_EXCLUDE
;
5107 /* Record this stub in an array of local symbol stubs for
5109 if (elf_tdata (abfd
)->local_stubs
== NULL
)
5111 unsigned long symcount
;
5115 if (elf_bad_symtab (abfd
))
5116 symcount
= NUM_SHDR_ENTRIES (symtab_hdr
);
5118 symcount
= symtab_hdr
->sh_info
;
5119 amt
= symcount
* sizeof (asection
*);
5120 n
= bfd_zalloc (abfd
, amt
);
5123 elf_tdata (abfd
)->local_stubs
= n
;
5126 elf_tdata (abfd
)->local_stubs
[r_symndx
] = sec
;
5128 /* We don't need to set mips16_stubs_seen in this case.
5129 That flag is used to see whether we need to look through
5130 the global symbol table for stubs. We don't need to set
5131 it here, because we just have a local stub. */
5135 struct mips_elf_link_hash_entry
*h
;
5137 h
= ((struct mips_elf_link_hash_entry
*)
5138 sym_hashes
[r_symndx
- extsymoff
]);
5140 /* H is the symbol this stub is for. */
5143 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
5146 else if (strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
5147 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
5149 unsigned long r_symndx
;
5150 struct mips_elf_link_hash_entry
*h
;
5153 /* Look at the relocation information to figure out which symbol
5156 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
5158 if (r_symndx
< extsymoff
5159 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
5161 /* This stub was actually built for a static symbol defined
5162 in the same file. We assume that all static symbols in
5163 mips16 code are themselves mips16, so we can simply
5164 discard this stub. Since this function is called before
5165 the linker maps input sections to output sections, we can
5166 easily discard it by setting the SEC_EXCLUDE flag. */
5167 sec
->flags
|= SEC_EXCLUDE
;
5171 h
= ((struct mips_elf_link_hash_entry
*)
5172 sym_hashes
[r_symndx
- extsymoff
]);
5174 /* H is the symbol this stub is for. */
5176 if (strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
5177 loc
= &h
->call_fp_stub
;
5179 loc
= &h
->call_stub
;
5181 /* If we already have an appropriate stub for this function, we
5182 don't need another one, so we can discard this one. Since
5183 this function is called before the linker maps input sections
5184 to output sections, we can easily discard it by setting the
5185 SEC_EXCLUDE flag. We can also discard this section if we
5186 happen to already know that this is a mips16 function; it is
5187 not necessary to check this here, as it is checked later, but
5188 it is slightly faster to check now. */
5189 if (*loc
!= NULL
|| h
->root
.other
== STO_MIPS16
)
5191 sec
->flags
|= SEC_EXCLUDE
;
5196 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
5206 sgot
= mips_elf_got_section (dynobj
, FALSE
);
5211 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
5212 g
= mips_elf_section_data (sgot
)->u
.got_info
;
5213 BFD_ASSERT (g
!= NULL
);
5218 bed
= get_elf_backend_data (abfd
);
5219 rel_end
= relocs
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
5220 for (rel
= relocs
; rel
< rel_end
; ++rel
)
5222 unsigned long r_symndx
;
5223 unsigned int r_type
;
5224 struct elf_link_hash_entry
*h
;
5226 r_symndx
= ELF_R_SYM (abfd
, rel
->r_info
);
5227 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
5229 if (r_symndx
< extsymoff
)
5231 else if (r_symndx
>= extsymoff
+ NUM_SHDR_ENTRIES (symtab_hdr
))
5233 (*_bfd_error_handler
)
5234 (_("%s: Malformed reloc detected for section %s"),
5235 bfd_archive_filename (abfd
), name
);
5236 bfd_set_error (bfd_error_bad_value
);
5241 h
= sym_hashes
[r_symndx
- extsymoff
];
5243 /* This may be an indirect symbol created because of a version. */
5246 while (h
->root
.type
== bfd_link_hash_indirect
)
5247 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5251 /* Some relocs require a global offset table. */
5252 if (dynobj
== NULL
|| sgot
== NULL
)
5258 case R_MIPS_CALL_HI16
:
5259 case R_MIPS_CALL_LO16
:
5260 case R_MIPS_GOT_HI16
:
5261 case R_MIPS_GOT_LO16
:
5262 case R_MIPS_GOT_PAGE
:
5263 case R_MIPS_GOT_OFST
:
5264 case R_MIPS_GOT_DISP
:
5266 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5267 if (! mips_elf_create_got_section (dynobj
, info
, FALSE
))
5269 g
= mips_elf_got_info (dynobj
, &sgot
);
5276 && (info
->shared
|| h
!= NULL
)
5277 && (sec
->flags
& SEC_ALLOC
) != 0)
5278 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5286 if (!h
&& (r_type
== R_MIPS_CALL_LO16
5287 || r_type
== R_MIPS_GOT_LO16
5288 || r_type
== R_MIPS_GOT_DISP
))
5290 /* We may need a local GOT entry for this relocation. We
5291 don't count R_MIPS_GOT_PAGE because we can estimate the
5292 maximum number of pages needed by looking at the size of
5293 the segment. Similar comments apply to R_MIPS_GOT16 and
5294 R_MIPS_CALL16. We don't count R_MIPS_GOT_HI16, or
5295 R_MIPS_CALL_HI16 because these are always followed by an
5296 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
5297 if (! mips_elf_record_local_got_symbol (abfd
, r_symndx
,
5307 (*_bfd_error_handler
)
5308 (_("%s: CALL16 reloc at 0x%lx not against global symbol"),
5309 bfd_archive_filename (abfd
), (unsigned long) rel
->r_offset
);
5310 bfd_set_error (bfd_error_bad_value
);
5315 case R_MIPS_CALL_HI16
:
5316 case R_MIPS_CALL_LO16
:
5319 /* This symbol requires a global offset table entry. */
5320 if (! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5323 /* We need a stub, not a plt entry for the undefined
5324 function. But we record it as if it needs plt. See
5325 _bfd_elf_adjust_dynamic_symbol. */
5326 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
5331 case R_MIPS_GOT_PAGE
:
5332 /* If this is a global, overridable symbol, GOT_PAGE will
5333 decay to GOT_DISP, so we'll need a GOT entry for it. */
5338 struct mips_elf_link_hash_entry
*hmips
=
5339 (struct mips_elf_link_hash_entry
*) h
;
5341 while (hmips
->root
.root
.type
== bfd_link_hash_indirect
5342 || hmips
->root
.root
.type
== bfd_link_hash_warning
)
5343 hmips
= (struct mips_elf_link_hash_entry
*)
5344 hmips
->root
.root
.u
.i
.link
;
5346 if ((hmips
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)
5347 && ! (info
->shared
&& ! info
->symbolic
5348 && ! (hmips
->root
.elf_link_hash_flags
5349 & ELF_LINK_FORCED_LOCAL
)))
5355 case R_MIPS_GOT_HI16
:
5356 case R_MIPS_GOT_LO16
:
5357 case R_MIPS_GOT_DISP
:
5358 /* This symbol requires a global offset table entry. */
5359 if (h
&& ! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5366 if ((info
->shared
|| h
!= NULL
)
5367 && (sec
->flags
& SEC_ALLOC
) != 0)
5371 sreloc
= mips_elf_rel_dyn_section (dynobj
, TRUE
);
5375 #define MIPS_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
5378 /* When creating a shared object, we must copy these
5379 reloc types into the output file as R_MIPS_REL32
5380 relocs. We make room for this reloc in the
5381 .rel.dyn reloc section. */
5382 mips_elf_allocate_dynamic_relocations (dynobj
, 1);
5383 if ((sec
->flags
& MIPS_READONLY_SECTION
)
5384 == MIPS_READONLY_SECTION
)
5385 /* We tell the dynamic linker that there are
5386 relocations against the text segment. */
5387 info
->flags
|= DF_TEXTREL
;
5391 struct mips_elf_link_hash_entry
*hmips
;
5393 /* We only need to copy this reloc if the symbol is
5394 defined in a dynamic object. */
5395 hmips
= (struct mips_elf_link_hash_entry
*) h
;
5396 ++hmips
->possibly_dynamic_relocs
;
5397 if ((sec
->flags
& MIPS_READONLY_SECTION
)
5398 == MIPS_READONLY_SECTION
)
5399 /* We need it to tell the dynamic linker if there
5400 are relocations against the text segment. */
5401 hmips
->readonly_reloc
= TRUE
;
5404 /* Even though we don't directly need a GOT entry for
5405 this symbol, a symbol must have a dynamic symbol
5406 table index greater that DT_MIPS_GOTSYM if there are
5407 dynamic relocations against it. */
5411 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5412 if (! mips_elf_create_got_section (dynobj
, info
, TRUE
))
5414 g
= mips_elf_got_info (dynobj
, &sgot
);
5415 if (! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5420 if (SGI_COMPAT (abfd
))
5421 mips_elf_hash_table (info
)->compact_rel_size
+=
5422 sizeof (Elf32_External_crinfo
);
5426 case R_MIPS_GPREL16
:
5427 case R_MIPS_LITERAL
:
5428 case R_MIPS_GPREL32
:
5429 if (SGI_COMPAT (abfd
))
5430 mips_elf_hash_table (info
)->compact_rel_size
+=
5431 sizeof (Elf32_External_crinfo
);
5434 /* This relocation describes the C++ object vtable hierarchy.
5435 Reconstruct it for later use during GC. */
5436 case R_MIPS_GNU_VTINHERIT
:
5437 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
5441 /* This relocation describes which C++ vtable entries are actually
5442 used. Record for later use during GC. */
5443 case R_MIPS_GNU_VTENTRY
:
5444 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
5452 /* We must not create a stub for a symbol that has relocations
5453 related to taking the function's address. */
5459 struct mips_elf_link_hash_entry
*mh
;
5461 mh
= (struct mips_elf_link_hash_entry
*) h
;
5462 mh
->no_fn_stub
= TRUE
;
5466 case R_MIPS_CALL_HI16
:
5467 case R_MIPS_CALL_LO16
:
5472 /* If this reloc is not a 16 bit call, and it has a global
5473 symbol, then we will need the fn_stub if there is one.
5474 References from a stub section do not count. */
5476 && r_type
!= R_MIPS16_26
5477 && strncmp (bfd_get_section_name (abfd
, sec
), FN_STUB
,
5478 sizeof FN_STUB
- 1) != 0
5479 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_STUB
,
5480 sizeof CALL_STUB
- 1) != 0
5481 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_FP_STUB
,
5482 sizeof CALL_FP_STUB
- 1) != 0)
5484 struct mips_elf_link_hash_entry
*mh
;
5486 mh
= (struct mips_elf_link_hash_entry
*) h
;
5487 mh
->need_fn_stub
= TRUE
;
5495 _bfd_mips_relax_section (bfd
*abfd
, asection
*sec
,
5496 struct bfd_link_info
*link_info
,
5499 Elf_Internal_Rela
*internal_relocs
;
5500 Elf_Internal_Rela
*irel
, *irelend
;
5501 Elf_Internal_Shdr
*symtab_hdr
;
5502 bfd_byte
*contents
= NULL
;
5503 bfd_byte
*free_contents
= NULL
;
5505 bfd_boolean changed_contents
= FALSE
;
5506 bfd_vma sec_start
= sec
->output_section
->vma
+ sec
->output_offset
;
5507 Elf_Internal_Sym
*isymbuf
= NULL
;
5509 /* We are not currently changing any sizes, so only one pass. */
5512 if (link_info
->relocatable
)
5515 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
5516 link_info
->keep_memory
);
5517 if (internal_relocs
== NULL
)
5520 irelend
= internal_relocs
+ sec
->reloc_count
5521 * get_elf_backend_data (abfd
)->s
->int_rels_per_ext_rel
;
5522 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5523 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
5525 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
5528 bfd_signed_vma sym_offset
;
5529 unsigned int r_type
;
5530 unsigned long r_symndx
;
5532 unsigned long instruction
;
5534 /* Turn jalr into bgezal, and jr into beq, if they're marked
5535 with a JALR relocation, that indicate where they jump to.
5536 This saves some pipeline bubbles. */
5537 r_type
= ELF_R_TYPE (abfd
, irel
->r_info
);
5538 if (r_type
!= R_MIPS_JALR
)
5541 r_symndx
= ELF_R_SYM (abfd
, irel
->r_info
);
5542 /* Compute the address of the jump target. */
5543 if (r_symndx
>= extsymoff
)
5545 struct mips_elf_link_hash_entry
*h
5546 = ((struct mips_elf_link_hash_entry
*)
5547 elf_sym_hashes (abfd
) [r_symndx
- extsymoff
]);
5549 while (h
->root
.root
.type
== bfd_link_hash_indirect
5550 || h
->root
.root
.type
== bfd_link_hash_warning
)
5551 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
5553 /* If a symbol is undefined, or if it may be overridden,
5555 if (! ((h
->root
.root
.type
== bfd_link_hash_defined
5556 || h
->root
.root
.type
== bfd_link_hash_defweak
)
5557 && h
->root
.root
.u
.def
.section
)
5558 || (link_info
->shared
&& ! link_info
->symbolic
5559 && ! (h
->root
.elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
)))
5562 sym_sec
= h
->root
.root
.u
.def
.section
;
5563 if (sym_sec
->output_section
)
5564 symval
= (h
->root
.root
.u
.def
.value
5565 + sym_sec
->output_section
->vma
5566 + sym_sec
->output_offset
);
5568 symval
= h
->root
.root
.u
.def
.value
;
5572 Elf_Internal_Sym
*isym
;
5574 /* Read this BFD's symbols if we haven't done so already. */
5575 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
5577 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5578 if (isymbuf
== NULL
)
5579 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
5580 symtab_hdr
->sh_info
, 0,
5582 if (isymbuf
== NULL
)
5586 isym
= isymbuf
+ r_symndx
;
5587 if (isym
->st_shndx
== SHN_UNDEF
)
5589 else if (isym
->st_shndx
== SHN_ABS
)
5590 sym_sec
= bfd_abs_section_ptr
;
5591 else if (isym
->st_shndx
== SHN_COMMON
)
5592 sym_sec
= bfd_com_section_ptr
;
5595 = bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
5596 symval
= isym
->st_value
5597 + sym_sec
->output_section
->vma
5598 + sym_sec
->output_offset
;
5601 /* Compute branch offset, from delay slot of the jump to the
5603 sym_offset
= (symval
+ irel
->r_addend
)
5604 - (sec_start
+ irel
->r_offset
+ 4);
5606 /* Branch offset must be properly aligned. */
5607 if ((sym_offset
& 3) != 0)
5612 /* Check that it's in range. */
5613 if (sym_offset
< -0x8000 || sym_offset
>= 0x8000)
5616 /* Get the section contents if we haven't done so already. */
5617 if (contents
== NULL
)
5619 /* Get cached copy if it exists. */
5620 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
5621 contents
= elf_section_data (sec
)->this_hdr
.contents
;
5624 contents
= bfd_malloc (sec
->_raw_size
);
5625 if (contents
== NULL
)
5628 free_contents
= contents
;
5629 if (! bfd_get_section_contents (abfd
, sec
, contents
,
5635 instruction
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
5637 /* If it was jalr <reg>, turn it into bgezal $zero, <target>. */
5638 if ((instruction
& 0xfc1fffff) == 0x0000f809)
5639 instruction
= 0x04110000;
5640 /* If it was jr <reg>, turn it into b <target>. */
5641 else if ((instruction
& 0xfc1fffff) == 0x00000008)
5642 instruction
= 0x10000000;
5646 instruction
|= (sym_offset
& 0xffff);
5647 bfd_put_32 (abfd
, instruction
, contents
+ irel
->r_offset
);
5648 changed_contents
= TRUE
;
5651 if (contents
!= NULL
5652 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
5654 if (!changed_contents
&& !link_info
->keep_memory
)
5658 /* Cache the section contents for elf_link_input_bfd. */
5659 elf_section_data (sec
)->this_hdr
.contents
= contents
;
5665 if (free_contents
!= NULL
)
5666 free (free_contents
);
5670 /* Adjust a symbol defined by a dynamic object and referenced by a
5671 regular object. The current definition is in some section of the
5672 dynamic object, but we're not including those sections. We have to
5673 change the definition to something the rest of the link can
5677 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
5678 struct elf_link_hash_entry
*h
)
5681 struct mips_elf_link_hash_entry
*hmips
;
5684 dynobj
= elf_hash_table (info
)->dynobj
;
5686 /* Make sure we know what is going on here. */
5687 BFD_ASSERT (dynobj
!= NULL
5688 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
5689 || h
->weakdef
!= NULL
5690 || ((h
->elf_link_hash_flags
5691 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
5692 && (h
->elf_link_hash_flags
5693 & ELF_LINK_HASH_REF_REGULAR
) != 0
5694 && (h
->elf_link_hash_flags
5695 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
5697 /* If this symbol is defined in a dynamic object, we need to copy
5698 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
5700 hmips
= (struct mips_elf_link_hash_entry
*) h
;
5701 if (! info
->relocatable
5702 && hmips
->possibly_dynamic_relocs
!= 0
5703 && (h
->root
.type
== bfd_link_hash_defweak
5704 || (h
->elf_link_hash_flags
5705 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
5707 mips_elf_allocate_dynamic_relocations (dynobj
,
5708 hmips
->possibly_dynamic_relocs
);
5709 if (hmips
->readonly_reloc
)
5710 /* We tell the dynamic linker that there are relocations
5711 against the text segment. */
5712 info
->flags
|= DF_TEXTREL
;
5715 /* For a function, create a stub, if allowed. */
5716 if (! hmips
->no_fn_stub
5717 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
5719 if (! elf_hash_table (info
)->dynamic_sections_created
)
5722 /* If this symbol is not defined in a regular file, then set
5723 the symbol to the stub location. This is required to make
5724 function pointers compare as equal between the normal
5725 executable and the shared library. */
5726 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
5728 /* We need .stub section. */
5729 s
= bfd_get_section_by_name (dynobj
,
5730 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
5731 BFD_ASSERT (s
!= NULL
);
5733 h
->root
.u
.def
.section
= s
;
5734 h
->root
.u
.def
.value
= s
->_raw_size
;
5736 /* XXX Write this stub address somewhere. */
5737 h
->plt
.offset
= s
->_raw_size
;
5739 /* Make room for this stub code. */
5740 s
->_raw_size
+= MIPS_FUNCTION_STUB_SIZE
;
5742 /* The last half word of the stub will be filled with the index
5743 of this symbol in .dynsym section. */
5747 else if ((h
->type
== STT_FUNC
)
5748 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0)
5750 /* This will set the entry for this symbol in the GOT to 0, and
5751 the dynamic linker will take care of this. */
5752 h
->root
.u
.def
.value
= 0;
5756 /* If this is a weak symbol, and there is a real definition, the
5757 processor independent code will have arranged for us to see the
5758 real definition first, and we can just use the same value. */
5759 if (h
->weakdef
!= NULL
)
5761 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
5762 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
5763 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
5764 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
5768 /* This is a reference to a symbol defined by a dynamic object which
5769 is not a function. */
5774 /* This function is called after all the input files have been read,
5775 and the input sections have been assigned to output sections. We
5776 check for any mips16 stub sections that we can discard. */
5779 _bfd_mips_elf_always_size_sections (bfd
*output_bfd
,
5780 struct bfd_link_info
*info
)
5786 struct mips_got_info
*g
;
5788 bfd_size_type loadable_size
= 0;
5789 bfd_size_type local_gotno
;
5792 /* The .reginfo section has a fixed size. */
5793 ri
= bfd_get_section_by_name (output_bfd
, ".reginfo");
5795 bfd_set_section_size (output_bfd
, ri
, sizeof (Elf32_External_RegInfo
));
5797 if (! (info
->relocatable
5798 || ! mips_elf_hash_table (info
)->mips16_stubs_seen
))
5799 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
5800 mips_elf_check_mips16_stubs
, NULL
);
5802 dynobj
= elf_hash_table (info
)->dynobj
;
5804 /* Relocatable links don't have it. */
5807 g
= mips_elf_got_info (dynobj
, &s
);
5811 /* Calculate the total loadable size of the output. That
5812 will give us the maximum number of GOT_PAGE entries
5814 for (sub
= info
->input_bfds
; sub
; sub
= sub
->link_next
)
5816 asection
*subsection
;
5818 for (subsection
= sub
->sections
;
5820 subsection
= subsection
->next
)
5822 if ((subsection
->flags
& SEC_ALLOC
) == 0)
5824 loadable_size
+= ((subsection
->_raw_size
+ 0xf)
5825 &~ (bfd_size_type
) 0xf);
5829 /* There has to be a global GOT entry for every symbol with
5830 a dynamic symbol table index of DT_MIPS_GOTSYM or
5831 higher. Therefore, it make sense to put those symbols
5832 that need GOT entries at the end of the symbol table. We
5834 if (! mips_elf_sort_hash_table (info
, 1))
5837 if (g
->global_gotsym
!= NULL
)
5838 i
= elf_hash_table (info
)->dynsymcount
- g
->global_gotsym
->dynindx
;
5840 /* If there are no global symbols, or none requiring
5841 relocations, then GLOBAL_GOTSYM will be NULL. */
5844 /* In the worst case, we'll get one stub per dynamic symbol, plus
5845 one to account for the dummy entry at the end required by IRIX
5847 loadable_size
+= MIPS_FUNCTION_STUB_SIZE
* (i
+ 1);
5849 /* Assume there are two loadable segments consisting of
5850 contiguous sections. Is 5 enough? */
5851 local_gotno
= (loadable_size
>> 16) + 5;
5853 g
->local_gotno
+= local_gotno
;
5854 s
->_raw_size
+= g
->local_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
5856 g
->global_gotno
= i
;
5857 s
->_raw_size
+= i
* MIPS_ELF_GOT_SIZE (output_bfd
);
5859 if (s
->_raw_size
> MIPS_ELF_GOT_MAX_SIZE (output_bfd
)
5860 && ! mips_elf_multi_got (output_bfd
, info
, g
, s
, local_gotno
))
5866 /* Set the sizes of the dynamic sections. */
5869 _bfd_mips_elf_size_dynamic_sections (bfd
*output_bfd
,
5870 struct bfd_link_info
*info
)
5874 bfd_boolean reltext
;
5876 dynobj
= elf_hash_table (info
)->dynobj
;
5877 BFD_ASSERT (dynobj
!= NULL
);
5879 if (elf_hash_table (info
)->dynamic_sections_created
)
5881 /* Set the contents of the .interp section to the interpreter. */
5882 if (info
->executable
)
5884 s
= bfd_get_section_by_name (dynobj
, ".interp");
5885 BFD_ASSERT (s
!= NULL
);
5887 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd
)) + 1;
5889 = (bfd_byte
*) ELF_DYNAMIC_INTERPRETER (output_bfd
);
5893 /* The check_relocs and adjust_dynamic_symbol entry points have
5894 determined the sizes of the various dynamic sections. Allocate
5897 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
5902 /* It's OK to base decisions on the section name, because none
5903 of the dynobj section names depend upon the input files. */
5904 name
= bfd_get_section_name (dynobj
, s
);
5906 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
5911 if (strncmp (name
, ".rel", 4) == 0)
5913 if (s
->_raw_size
== 0)
5915 /* We only strip the section if the output section name
5916 has the same name. Otherwise, there might be several
5917 input sections for this output section. FIXME: This
5918 code is probably not needed these days anyhow, since
5919 the linker now does not create empty output sections. */
5920 if (s
->output_section
!= NULL
5922 bfd_get_section_name (s
->output_section
->owner
,
5923 s
->output_section
)) == 0)
5928 const char *outname
;
5931 /* If this relocation section applies to a read only
5932 section, then we probably need a DT_TEXTREL entry.
5933 If the relocation section is .rel.dyn, we always
5934 assert a DT_TEXTREL entry rather than testing whether
5935 there exists a relocation to a read only section or
5937 outname
= bfd_get_section_name (output_bfd
,
5939 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
5941 && (target
->flags
& SEC_READONLY
) != 0
5942 && (target
->flags
& SEC_ALLOC
) != 0)
5943 || strcmp (outname
, ".rel.dyn") == 0)
5946 /* We use the reloc_count field as a counter if we need
5947 to copy relocs into the output file. */
5948 if (strcmp (name
, ".rel.dyn") != 0)
5951 /* If combreloc is enabled, elf_link_sort_relocs() will
5952 sort relocations, but in a different way than we do,
5953 and before we're done creating relocations. Also, it
5954 will move them around between input sections'
5955 relocation's contents, so our sorting would be
5956 broken, so don't let it run. */
5957 info
->combreloc
= 0;
5960 else if (strncmp (name
, ".got", 4) == 0)
5962 /* _bfd_mips_elf_always_size_sections() has already done
5963 most of the work, but some symbols may have been mapped
5964 to versions that we must now resolve in the got_entries
5966 struct mips_got_info
*gg
= mips_elf_got_info (dynobj
, NULL
);
5967 struct mips_got_info
*g
= gg
;
5968 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
5969 unsigned int needed_relocs
= 0;
5973 set_got_offset_arg
.value
= MIPS_ELF_GOT_SIZE (output_bfd
);
5974 set_got_offset_arg
.info
= info
;
5976 mips_elf_resolve_final_got_entries (gg
);
5977 for (g
= gg
->next
; g
&& g
->next
!= gg
; g
= g
->next
)
5979 unsigned int save_assign
;
5981 mips_elf_resolve_final_got_entries (g
);
5983 /* Assign offsets to global GOT entries. */
5984 save_assign
= g
->assigned_gotno
;
5985 g
->assigned_gotno
= g
->local_gotno
;
5986 set_got_offset_arg
.g
= g
;
5987 set_got_offset_arg
.needed_relocs
= 0;
5988 htab_traverse (g
->got_entries
,
5989 mips_elf_set_global_got_offset
,
5990 &set_got_offset_arg
);
5991 needed_relocs
+= set_got_offset_arg
.needed_relocs
;
5992 BFD_ASSERT (g
->assigned_gotno
- g
->local_gotno
5993 <= g
->global_gotno
);
5995 g
->assigned_gotno
= save_assign
;
5998 needed_relocs
+= g
->local_gotno
- g
->assigned_gotno
;
5999 BFD_ASSERT (g
->assigned_gotno
== g
->next
->local_gotno
6000 + g
->next
->global_gotno
6001 + MIPS_RESERVED_GOTNO
);
6006 mips_elf_allocate_dynamic_relocations (dynobj
, needed_relocs
);
6009 else if (strcmp (name
, MIPS_ELF_STUB_SECTION_NAME (output_bfd
)) == 0)
6011 /* IRIX rld assumes that the function stub isn't at the end
6012 of .text section. So put a dummy. XXX */
6013 s
->_raw_size
+= MIPS_FUNCTION_STUB_SIZE
;
6015 else if (! info
->shared
6016 && ! mips_elf_hash_table (info
)->use_rld_obj_head
6017 && strncmp (name
, ".rld_map", 8) == 0)
6019 /* We add a room for __rld_map. It will be filled in by the
6020 rtld to contain a pointer to the _r_debug structure. */
6023 else if (SGI_COMPAT (output_bfd
)
6024 && strncmp (name
, ".compact_rel", 12) == 0)
6025 s
->_raw_size
+= mips_elf_hash_table (info
)->compact_rel_size
;
6026 else if (strncmp (name
, ".init", 5) != 0)
6028 /* It's not one of our sections, so don't allocate space. */
6034 _bfd_strip_section_from_output (info
, s
);
6038 /* Allocate memory for the section contents. */
6039 s
->contents
= bfd_zalloc (dynobj
, s
->_raw_size
);
6040 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
6042 bfd_set_error (bfd_error_no_memory
);
6047 if (elf_hash_table (info
)->dynamic_sections_created
)
6049 /* Add some entries to the .dynamic section. We fill in the
6050 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
6051 must add the entries now so that we get the correct size for
6052 the .dynamic section. The DT_DEBUG entry is filled in by the
6053 dynamic linker and used by the debugger. */
6056 /* SGI object has the equivalence of DT_DEBUG in the
6057 DT_MIPS_RLD_MAP entry. */
6058 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_MAP
, 0))
6060 if (!SGI_COMPAT (output_bfd
))
6062 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
6068 /* Shared libraries on traditional mips have DT_DEBUG. */
6069 if (!SGI_COMPAT (output_bfd
))
6071 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
6076 if (reltext
&& SGI_COMPAT (output_bfd
))
6077 info
->flags
|= DF_TEXTREL
;
6079 if ((info
->flags
& DF_TEXTREL
) != 0)
6081 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_TEXTREL
, 0))
6085 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTGOT
, 0))
6088 if (mips_elf_rel_dyn_section (dynobj
, FALSE
))
6090 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_REL
, 0))
6093 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELSZ
, 0))
6096 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELENT
, 0))
6100 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_VERSION
, 0))
6103 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_FLAGS
, 0))
6107 /* Time stamps in executable files are a bad idea. */
6108 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_TIME_STAMP
, 0))
6113 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_ICHECKSUM
, 0))
6118 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_IVERSION
, 0))
6122 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_BASE_ADDRESS
, 0))
6125 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LOCAL_GOTNO
, 0))
6128 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_SYMTABNO
, 0))
6131 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_UNREFEXTNO
, 0))
6134 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_GOTSYM
, 0))
6137 if (IRIX_COMPAT (dynobj
) == ict_irix5
6138 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_HIPAGENO
, 0))
6141 if (IRIX_COMPAT (dynobj
) == ict_irix6
6142 && (bfd_get_section_by_name
6143 (dynobj
, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj
)))
6144 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_OPTIONS
, 0))
6151 /* Relocate a MIPS ELF section. */
6154 _bfd_mips_elf_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
6155 bfd
*input_bfd
, asection
*input_section
,
6156 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
6157 Elf_Internal_Sym
*local_syms
,
6158 asection
**local_sections
)
6160 Elf_Internal_Rela
*rel
;
6161 const Elf_Internal_Rela
*relend
;
6163 bfd_boolean use_saved_addend_p
= FALSE
;
6164 const struct elf_backend_data
*bed
;
6166 bed
= get_elf_backend_data (output_bfd
);
6167 relend
= relocs
+ input_section
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
6168 for (rel
= relocs
; rel
< relend
; ++rel
)
6172 reloc_howto_type
*howto
;
6173 bfd_boolean require_jalx
;
6174 /* TRUE if the relocation is a RELA relocation, rather than a
6176 bfd_boolean rela_relocation_p
= TRUE
;
6177 unsigned int r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
6180 /* Find the relocation howto for this relocation. */
6181 if (r_type
== R_MIPS_64
&& ! NEWABI_P (input_bfd
))
6183 /* Some 32-bit code uses R_MIPS_64. In particular, people use
6184 64-bit code, but make sure all their addresses are in the
6185 lowermost or uppermost 32-bit section of the 64-bit address
6186 space. Thus, when they use an R_MIPS_64 they mean what is
6187 usually meant by R_MIPS_32, with the exception that the
6188 stored value is sign-extended to 64 bits. */
6189 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, R_MIPS_32
, FALSE
);
6191 /* On big-endian systems, we need to lie about the position
6193 if (bfd_big_endian (input_bfd
))
6197 /* NewABI defaults to RELA relocations. */
6198 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, r_type
,
6199 NEWABI_P (input_bfd
)
6200 && (MIPS_RELOC_RELA_P
6201 (input_bfd
, input_section
,
6204 if (!use_saved_addend_p
)
6206 Elf_Internal_Shdr
*rel_hdr
;
6208 /* If these relocations were originally of the REL variety,
6209 we must pull the addend out of the field that will be
6210 relocated. Otherwise, we simply use the contents of the
6211 RELA relocation. To determine which flavor or relocation
6212 this is, we depend on the fact that the INPUT_SECTION's
6213 REL_HDR is read before its REL_HDR2. */
6214 rel_hdr
= &elf_section_data (input_section
)->rel_hdr
;
6215 if ((size_t) (rel
- relocs
)
6216 >= (NUM_SHDR_ENTRIES (rel_hdr
) * bed
->s
->int_rels_per_ext_rel
))
6217 rel_hdr
= elf_section_data (input_section
)->rel_hdr2
;
6218 if (rel_hdr
->sh_entsize
== MIPS_ELF_REL_SIZE (input_bfd
))
6220 /* Note that this is a REL relocation. */
6221 rela_relocation_p
= FALSE
;
6223 /* Get the addend, which is stored in the input file. */
6224 addend
= mips_elf_obtain_contents (howto
, rel
, input_bfd
,
6226 addend
&= howto
->src_mask
;
6228 /* For some kinds of relocations, the ADDEND is a
6229 combination of the addend stored in two different
6231 if (r_type
== R_MIPS_HI16
6232 || r_type
== R_MIPS_GNU_REL_HI16
6233 || (r_type
== R_MIPS_GOT16
6234 && mips_elf_local_relocation_p (input_bfd
, rel
,
6235 local_sections
, FALSE
)))
6238 const Elf_Internal_Rela
*lo16_relocation
;
6239 reloc_howto_type
*lo16_howto
;
6242 /* The combined value is the sum of the HI16 addend,
6243 left-shifted by sixteen bits, and the LO16
6244 addend, sign extended. (Usually, the code does
6245 a `lui' of the HI16 value, and then an `addiu' of
6248 Scan ahead to find a matching LO16 relocation. */
6249 if (r_type
== R_MIPS_GNU_REL_HI16
)
6250 lo
= R_MIPS_GNU_REL_LO16
;
6253 lo16_relocation
= mips_elf_next_relocation (input_bfd
, lo
,
6255 if (lo16_relocation
== NULL
)
6258 /* Obtain the addend kept there. */
6259 lo16_howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, lo
, FALSE
);
6260 l
= mips_elf_obtain_contents (lo16_howto
, lo16_relocation
,
6261 input_bfd
, contents
);
6262 l
&= lo16_howto
->src_mask
;
6263 l
<<= lo16_howto
->rightshift
;
6264 l
= _bfd_mips_elf_sign_extend (l
, 16);
6268 /* Compute the combined addend. */
6271 /* If PC-relative, subtract the difference between the
6272 address of the LO part of the reloc and the address of
6273 the HI part. The relocation is relative to the LO
6274 part, but mips_elf_calculate_relocation() doesn't
6275 know its address or the difference from the HI part, so
6276 we subtract that difference here. See also the
6277 comment in mips_elf_calculate_relocation(). */
6278 if (r_type
== R_MIPS_GNU_REL_HI16
)
6279 addend
-= (lo16_relocation
->r_offset
- rel
->r_offset
);
6281 else if (r_type
== R_MIPS16_GPREL
)
6283 /* The addend is scrambled in the object file. See
6284 mips_elf_perform_relocation for details on the
6286 addend
= (((addend
& 0x1f0000) >> 5)
6287 | ((addend
& 0x7e00000) >> 16)
6291 addend
<<= howto
->rightshift
;
6294 addend
= rel
->r_addend
;
6297 if (info
->relocatable
)
6299 Elf_Internal_Sym
*sym
;
6300 unsigned long r_symndx
;
6302 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
)
6303 && bfd_big_endian (input_bfd
))
6306 /* Since we're just relocating, all we need to do is copy
6307 the relocations back out to the object file, unless
6308 they're against a section symbol, in which case we need
6309 to adjust by the section offset, or unless they're GP
6310 relative in which case we need to adjust by the amount
6311 that we're adjusting GP in this relocatable object. */
6313 if (! mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
,
6315 /* There's nothing to do for non-local relocations. */
6318 if (r_type
== R_MIPS16_GPREL
6319 || r_type
== R_MIPS_GPREL16
6320 || r_type
== R_MIPS_GPREL32
6321 || r_type
== R_MIPS_LITERAL
)
6322 addend
-= (_bfd_get_gp_value (output_bfd
)
6323 - _bfd_get_gp_value (input_bfd
));
6325 r_symndx
= ELF_R_SYM (output_bfd
, rel
->r_info
);
6326 sym
= local_syms
+ r_symndx
;
6327 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6328 /* Adjust the addend appropriately. */
6329 addend
+= local_sections
[r_symndx
]->output_offset
;
6331 if (rela_relocation_p
)
6332 /* If this is a RELA relocation, just update the addend. */
6333 rel
->r_addend
= addend
;
6336 if (r_type
== R_MIPS_HI16
6337 || r_type
== R_MIPS_GOT16
6338 || r_type
== R_MIPS_GNU_REL_HI16
)
6339 addend
= mips_elf_high (addend
);
6340 else if (r_type
== R_MIPS_HIGHER
)
6341 addend
= mips_elf_higher (addend
);
6342 else if (r_type
== R_MIPS_HIGHEST
)
6343 addend
= mips_elf_highest (addend
);
6345 addend
>>= howto
->rightshift
;
6347 /* We use the source mask, rather than the destination
6348 mask because the place to which we are writing will be
6349 source of the addend in the final link. */
6350 addend
&= howto
->src_mask
;
6352 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
6353 /* See the comment above about using R_MIPS_64 in the 32-bit
6354 ABI. Here, we need to update the addend. It would be
6355 possible to get away with just using the R_MIPS_32 reloc
6356 but for endianness. */
6362 if (addend
& ((bfd_vma
) 1 << 31))
6364 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
6371 /* If we don't know that we have a 64-bit type,
6372 do two separate stores. */
6373 if (bfd_big_endian (input_bfd
))
6375 /* Store the sign-bits (which are most significant)
6377 low_bits
= sign_bits
;
6383 high_bits
= sign_bits
;
6385 bfd_put_32 (input_bfd
, low_bits
,
6386 contents
+ rel
->r_offset
);
6387 bfd_put_32 (input_bfd
, high_bits
,
6388 contents
+ rel
->r_offset
+ 4);
6392 if (! mips_elf_perform_relocation (info
, howto
, rel
, addend
,
6393 input_bfd
, input_section
,
6398 /* Go on to the next relocation. */
6402 /* In the N32 and 64-bit ABIs there may be multiple consecutive
6403 relocations for the same offset. In that case we are
6404 supposed to treat the output of each relocation as the addend
6406 if (rel
+ 1 < relend
6407 && rel
->r_offset
== rel
[1].r_offset
6408 && ELF_R_TYPE (input_bfd
, rel
[1].r_info
) != R_MIPS_NONE
)
6409 use_saved_addend_p
= TRUE
;
6411 use_saved_addend_p
= FALSE
;
6413 /* Figure out what value we are supposed to relocate. */
6414 switch (mips_elf_calculate_relocation (output_bfd
, input_bfd
,
6415 input_section
, info
, rel
,
6416 addend
, howto
, local_syms
,
6417 local_sections
, &value
,
6418 &name
, &require_jalx
,
6419 use_saved_addend_p
))
6421 case bfd_reloc_continue
:
6422 /* There's nothing to do. */
6425 case bfd_reloc_undefined
:
6426 /* mips_elf_calculate_relocation already called the
6427 undefined_symbol callback. There's no real point in
6428 trying to perform the relocation at this point, so we
6429 just skip ahead to the next relocation. */
6432 case bfd_reloc_notsupported
:
6433 msg
= _("internal error: unsupported relocation error");
6434 info
->callbacks
->warning
6435 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
6438 case bfd_reloc_overflow
:
6439 if (use_saved_addend_p
)
6440 /* Ignore overflow until we reach the last relocation for
6441 a given location. */
6445 BFD_ASSERT (name
!= NULL
);
6446 if (! ((*info
->callbacks
->reloc_overflow
)
6447 (info
, name
, howto
->name
, 0,
6448 input_bfd
, input_section
, rel
->r_offset
)))
6461 /* If we've got another relocation for the address, keep going
6462 until we reach the last one. */
6463 if (use_saved_addend_p
)
6469 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
6470 /* See the comment above about using R_MIPS_64 in the 32-bit
6471 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
6472 that calculated the right value. Now, however, we
6473 sign-extend the 32-bit result to 64-bits, and store it as a
6474 64-bit value. We are especially generous here in that we
6475 go to extreme lengths to support this usage on systems with
6476 only a 32-bit VMA. */
6482 if (value
& ((bfd_vma
) 1 << 31))
6484 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
6491 /* If we don't know that we have a 64-bit type,
6492 do two separate stores. */
6493 if (bfd_big_endian (input_bfd
))
6495 /* Undo what we did above. */
6497 /* Store the sign-bits (which are most significant)
6499 low_bits
= sign_bits
;
6505 high_bits
= sign_bits
;
6507 bfd_put_32 (input_bfd
, low_bits
,
6508 contents
+ rel
->r_offset
);
6509 bfd_put_32 (input_bfd
, high_bits
,
6510 contents
+ rel
->r_offset
+ 4);
6514 /* Actually perform the relocation. */
6515 if (! mips_elf_perform_relocation (info
, howto
, rel
, value
,
6516 input_bfd
, input_section
,
6517 contents
, require_jalx
))
6524 /* If NAME is one of the special IRIX6 symbols defined by the linker,
6525 adjust it appropriately now. */
6528 mips_elf_irix6_finish_dynamic_symbol (bfd
*abfd ATTRIBUTE_UNUSED
,
6529 const char *name
, Elf_Internal_Sym
*sym
)
6531 /* The linker script takes care of providing names and values for
6532 these, but we must place them into the right sections. */
6533 static const char* const text_section_symbols
[] = {
6536 "__dso_displacement",
6538 "__program_header_table",
6542 static const char* const data_section_symbols
[] = {
6550 const char* const *p
;
6553 for (i
= 0; i
< 2; ++i
)
6554 for (p
= (i
== 0) ? text_section_symbols
: data_section_symbols
;
6557 if (strcmp (*p
, name
) == 0)
6559 /* All of these symbols are given type STT_SECTION by the
6561 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6562 sym
->st_other
= STO_PROTECTED
;
6564 /* The IRIX linker puts these symbols in special sections. */
6566 sym
->st_shndx
= SHN_MIPS_TEXT
;
6568 sym
->st_shndx
= SHN_MIPS_DATA
;
6574 /* Finish up dynamic symbol handling. We set the contents of various
6575 dynamic sections here. */
6578 _bfd_mips_elf_finish_dynamic_symbol (bfd
*output_bfd
,
6579 struct bfd_link_info
*info
,
6580 struct elf_link_hash_entry
*h
,
6581 Elf_Internal_Sym
*sym
)
6586 struct mips_got_info
*g
, *gg
;
6589 dynobj
= elf_hash_table (info
)->dynobj
;
6590 gval
= sym
->st_value
;
6592 if (h
->plt
.offset
!= (bfd_vma
) -1)
6595 bfd_byte stub
[MIPS_FUNCTION_STUB_SIZE
];
6597 /* This symbol has a stub. Set it up. */
6599 BFD_ASSERT (h
->dynindx
!= -1);
6601 s
= bfd_get_section_by_name (dynobj
,
6602 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
6603 BFD_ASSERT (s
!= NULL
);
6605 /* FIXME: Can h->dynindex be more than 64K? */
6606 if (h
->dynindx
& 0xffff0000)
6609 /* Fill the stub. */
6610 bfd_put_32 (output_bfd
, STUB_LW (output_bfd
), stub
);
6611 bfd_put_32 (output_bfd
, STUB_MOVE (output_bfd
), stub
+ 4);
6612 bfd_put_32 (output_bfd
, STUB_JALR
, stub
+ 8);
6613 bfd_put_32 (output_bfd
, STUB_LI16 (output_bfd
) + h
->dynindx
, stub
+ 12);
6615 BFD_ASSERT (h
->plt
.offset
<= s
->_raw_size
);
6616 memcpy (s
->contents
+ h
->plt
.offset
, stub
, MIPS_FUNCTION_STUB_SIZE
);
6618 /* Mark the symbol as undefined. plt.offset != -1 occurs
6619 only for the referenced symbol. */
6620 sym
->st_shndx
= SHN_UNDEF
;
6622 /* The run-time linker uses the st_value field of the symbol
6623 to reset the global offset table entry for this external
6624 to its stub address when unlinking a shared object. */
6625 gval
= s
->output_section
->vma
+ s
->output_offset
+ h
->plt
.offset
;
6626 sym
->st_value
= gval
;
6629 BFD_ASSERT (h
->dynindx
!= -1
6630 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0);
6632 sgot
= mips_elf_got_section (dynobj
, FALSE
);
6633 BFD_ASSERT (sgot
!= NULL
);
6634 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
6635 g
= mips_elf_section_data (sgot
)->u
.got_info
;
6636 BFD_ASSERT (g
!= NULL
);
6638 /* Run through the global symbol table, creating GOT entries for all
6639 the symbols that need them. */
6640 if (g
->global_gotsym
!= NULL
6641 && h
->dynindx
>= g
->global_gotsym
->dynindx
)
6646 value
= sym
->st_value
;
6647 offset
= mips_elf_global_got_index (dynobj
, output_bfd
, h
);
6648 MIPS_ELF_PUT_WORD (output_bfd
, value
, sgot
->contents
+ offset
);
6651 if (g
->next
&& h
->dynindx
!= -1)
6653 struct mips_got_entry e
, *p
;
6659 e
.abfd
= output_bfd
;
6661 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
6663 for (g
= g
->next
; g
->next
!= gg
; g
= g
->next
)
6666 && (p
= (struct mips_got_entry
*) htab_find (g
->got_entries
,
6671 || (elf_hash_table (info
)->dynamic_sections_created
6673 && ((p
->d
.h
->root
.elf_link_hash_flags
6674 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0)
6675 && ((p
->d
.h
->root
.elf_link_hash_flags
6676 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
6678 /* Create an R_MIPS_REL32 relocation for this entry. Due to
6679 the various compatibility problems, it's easier to mock
6680 up an R_MIPS_32 or R_MIPS_64 relocation and leave
6681 mips_elf_create_dynamic_relocation to calculate the
6682 appropriate addend. */
6683 Elf_Internal_Rela rel
[3];
6685 memset (rel
, 0, sizeof (rel
));
6686 if (ABI_64_P (output_bfd
))
6687 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_64
);
6689 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_32
);
6690 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
6693 if (! (mips_elf_create_dynamic_relocation
6694 (output_bfd
, info
, rel
,
6695 e
.d
.h
, NULL
, sym
->st_value
, &entry
, sgot
)))
6699 entry
= sym
->st_value
;
6700 MIPS_ELF_PUT_WORD (output_bfd
, entry
, sgot
->contents
+ offset
);
6705 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
6706 name
= h
->root
.root
.string
;
6707 if (strcmp (name
, "_DYNAMIC") == 0
6708 || strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
6709 sym
->st_shndx
= SHN_ABS
;
6710 else if (strcmp (name
, "_DYNAMIC_LINK") == 0
6711 || strcmp (name
, "_DYNAMIC_LINKING") == 0)
6713 sym
->st_shndx
= SHN_ABS
;
6714 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6717 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (output_bfd
))
6719 sym
->st_shndx
= SHN_ABS
;
6720 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6721 sym
->st_value
= elf_gp (output_bfd
);
6723 else if (SGI_COMPAT (output_bfd
))
6725 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
6726 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
6728 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6729 sym
->st_other
= STO_PROTECTED
;
6731 sym
->st_shndx
= SHN_MIPS_DATA
;
6733 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
6735 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6736 sym
->st_other
= STO_PROTECTED
;
6737 sym
->st_value
= mips_elf_hash_table (info
)->procedure_count
;
6738 sym
->st_shndx
= SHN_ABS
;
6740 else if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
!= SHN_ABS
)
6742 if (h
->type
== STT_FUNC
)
6743 sym
->st_shndx
= SHN_MIPS_TEXT
;
6744 else if (h
->type
== STT_OBJECT
)
6745 sym
->st_shndx
= SHN_MIPS_DATA
;
6749 /* Handle the IRIX6-specific symbols. */
6750 if (IRIX_COMPAT (output_bfd
) == ict_irix6
)
6751 mips_elf_irix6_finish_dynamic_symbol (output_bfd
, name
, sym
);
6755 if (! mips_elf_hash_table (info
)->use_rld_obj_head
6756 && (strcmp (name
, "__rld_map") == 0
6757 || strcmp (name
, "__RLD_MAP") == 0))
6759 asection
*s
= bfd_get_section_by_name (dynobj
, ".rld_map");
6760 BFD_ASSERT (s
!= NULL
);
6761 sym
->st_value
= s
->output_section
->vma
+ s
->output_offset
;
6762 bfd_put_32 (output_bfd
, 0, s
->contents
);
6763 if (mips_elf_hash_table (info
)->rld_value
== 0)
6764 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
6766 else if (mips_elf_hash_table (info
)->use_rld_obj_head
6767 && strcmp (name
, "__rld_obj_head") == 0)
6769 /* IRIX6 does not use a .rld_map section. */
6770 if (IRIX_COMPAT (output_bfd
) == ict_irix5
6771 || IRIX_COMPAT (output_bfd
) == ict_none
)
6772 BFD_ASSERT (bfd_get_section_by_name (dynobj
, ".rld_map")
6774 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
6778 /* If this is a mips16 symbol, force the value to be even. */
6779 if (sym
->st_other
== STO_MIPS16
)
6780 sym
->st_value
&= ~1;
6785 /* Finish up the dynamic sections. */
6788 _bfd_mips_elf_finish_dynamic_sections (bfd
*output_bfd
,
6789 struct bfd_link_info
*info
)
6794 struct mips_got_info
*gg
, *g
;
6796 dynobj
= elf_hash_table (info
)->dynobj
;
6798 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
6800 sgot
= mips_elf_got_section (dynobj
, FALSE
);
6805 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
6806 gg
= mips_elf_section_data (sgot
)->u
.got_info
;
6807 BFD_ASSERT (gg
!= NULL
);
6808 g
= mips_elf_got_for_ibfd (gg
, output_bfd
);
6809 BFD_ASSERT (g
!= NULL
);
6812 if (elf_hash_table (info
)->dynamic_sections_created
)
6816 BFD_ASSERT (sdyn
!= NULL
);
6817 BFD_ASSERT (g
!= NULL
);
6819 for (b
= sdyn
->contents
;
6820 b
< sdyn
->contents
+ sdyn
->_raw_size
;
6821 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
6823 Elf_Internal_Dyn dyn
;
6827 bfd_boolean swap_out_p
;
6829 /* Read in the current dynamic entry. */
6830 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
6832 /* Assume that we're going to modify it and write it out. */
6838 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
6839 BFD_ASSERT (s
!= NULL
);
6840 dyn
.d_un
.d_val
= MIPS_ELF_REL_SIZE (dynobj
);
6844 /* Rewrite DT_STRSZ. */
6846 _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
6851 s
= bfd_get_section_by_name (output_bfd
, name
);
6852 BFD_ASSERT (s
!= NULL
);
6853 dyn
.d_un
.d_ptr
= s
->vma
;
6856 case DT_MIPS_RLD_VERSION
:
6857 dyn
.d_un
.d_val
= 1; /* XXX */
6861 dyn
.d_un
.d_val
= RHF_NOTPOT
; /* XXX */
6864 case DT_MIPS_TIME_STAMP
:
6865 time ((time_t *) &dyn
.d_un
.d_val
);
6868 case DT_MIPS_ICHECKSUM
:
6873 case DT_MIPS_IVERSION
:
6878 case DT_MIPS_BASE_ADDRESS
:
6879 s
= output_bfd
->sections
;
6880 BFD_ASSERT (s
!= NULL
);
6881 dyn
.d_un
.d_ptr
= s
->vma
& ~(bfd_vma
) 0xffff;
6884 case DT_MIPS_LOCAL_GOTNO
:
6885 dyn
.d_un
.d_val
= g
->local_gotno
;
6888 case DT_MIPS_UNREFEXTNO
:
6889 /* The index into the dynamic symbol table which is the
6890 entry of the first external symbol that is not
6891 referenced within the same object. */
6892 dyn
.d_un
.d_val
= bfd_count_sections (output_bfd
) + 1;
6895 case DT_MIPS_GOTSYM
:
6896 if (gg
->global_gotsym
)
6898 dyn
.d_un
.d_val
= gg
->global_gotsym
->dynindx
;
6901 /* In case if we don't have global got symbols we default
6902 to setting DT_MIPS_GOTSYM to the same value as
6903 DT_MIPS_SYMTABNO, so we just fall through. */
6905 case DT_MIPS_SYMTABNO
:
6907 elemsize
= MIPS_ELF_SYM_SIZE (output_bfd
);
6908 s
= bfd_get_section_by_name (output_bfd
, name
);
6909 BFD_ASSERT (s
!= NULL
);
6911 if (s
->_cooked_size
!= 0)
6912 dyn
.d_un
.d_val
= s
->_cooked_size
/ elemsize
;
6914 dyn
.d_un
.d_val
= s
->_raw_size
/ elemsize
;
6917 case DT_MIPS_HIPAGENO
:
6918 dyn
.d_un
.d_val
= g
->local_gotno
- MIPS_RESERVED_GOTNO
;
6921 case DT_MIPS_RLD_MAP
:
6922 dyn
.d_un
.d_ptr
= mips_elf_hash_table (info
)->rld_value
;
6925 case DT_MIPS_OPTIONS
:
6926 s
= (bfd_get_section_by_name
6927 (output_bfd
, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd
)));
6928 dyn
.d_un
.d_ptr
= s
->vma
;
6932 /* Reduce DT_RELSZ to account for any relocations we
6933 decided not to make. This is for the n64 irix rld,
6934 which doesn't seem to apply any relocations if there
6935 are trailing null entries. */
6936 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
6937 dyn
.d_un
.d_val
= (s
->reloc_count
6938 * (ABI_64_P (output_bfd
)
6939 ? sizeof (Elf64_Mips_External_Rel
)
6940 : sizeof (Elf32_External_Rel
)));
6949 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
6954 /* The first entry of the global offset table will be filled at
6955 runtime. The second entry will be used by some runtime loaders.
6956 This isn't the case of IRIX rld. */
6957 if (sgot
!= NULL
&& sgot
->_raw_size
> 0)
6959 MIPS_ELF_PUT_WORD (output_bfd
, 0, sgot
->contents
);
6960 MIPS_ELF_PUT_WORD (output_bfd
, 0x80000000,
6961 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
6965 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
6966 = MIPS_ELF_GOT_SIZE (output_bfd
);
6968 /* Generate dynamic relocations for the non-primary gots. */
6969 if (gg
!= NULL
&& gg
->next
)
6971 Elf_Internal_Rela rel
[3];
6974 memset (rel
, 0, sizeof (rel
));
6975 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_REL32
);
6977 for (g
= gg
->next
; g
->next
!= gg
; g
= g
->next
)
6979 bfd_vma index
= g
->next
->local_gotno
+ g
->next
->global_gotno
;
6981 MIPS_ELF_PUT_WORD (output_bfd
, 0, sgot
->contents
6982 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
6983 MIPS_ELF_PUT_WORD (output_bfd
, 0x80000000, sgot
->contents
6984 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
6989 while (index
< g
->assigned_gotno
)
6991 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
6992 = index
++ * MIPS_ELF_GOT_SIZE (output_bfd
);
6993 if (!(mips_elf_create_dynamic_relocation
6994 (output_bfd
, info
, rel
, NULL
,
6995 bfd_abs_section_ptr
,
6998 BFD_ASSERT (addend
== 0);
7005 Elf32_compact_rel cpt
;
7007 if (SGI_COMPAT (output_bfd
))
7009 /* Write .compact_rel section out. */
7010 s
= bfd_get_section_by_name (dynobj
, ".compact_rel");
7014 cpt
.num
= s
->reloc_count
;
7016 cpt
.offset
= (s
->output_section
->filepos
7017 + sizeof (Elf32_External_compact_rel
));
7020 bfd_elf32_swap_compact_rel_out (output_bfd
, &cpt
,
7021 ((Elf32_External_compact_rel
*)
7024 /* Clean up a dummy stub function entry in .text. */
7025 s
= bfd_get_section_by_name (dynobj
,
7026 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
7029 file_ptr dummy_offset
;
7031 BFD_ASSERT (s
->_raw_size
>= MIPS_FUNCTION_STUB_SIZE
);
7032 dummy_offset
= s
->_raw_size
- MIPS_FUNCTION_STUB_SIZE
;
7033 memset (s
->contents
+ dummy_offset
, 0,
7034 MIPS_FUNCTION_STUB_SIZE
);
7039 /* We need to sort the entries of the dynamic relocation section. */
7041 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
7044 && s
->_raw_size
> (bfd_vma
)2 * MIPS_ELF_REL_SIZE (output_bfd
))
7046 reldyn_sorting_bfd
= output_bfd
;
7048 if (ABI_64_P (output_bfd
))
7049 qsort ((Elf64_External_Rel
*) s
->contents
+ 1, s
->reloc_count
- 1,
7050 sizeof (Elf64_Mips_External_Rel
), sort_dynamic_relocs_64
);
7052 qsort ((Elf32_External_Rel
*) s
->contents
+ 1, s
->reloc_count
- 1,
7053 sizeof (Elf32_External_Rel
), sort_dynamic_relocs
);
7061 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
7064 mips_set_isa_flags (bfd
*abfd
)
7068 switch (bfd_get_mach (abfd
))
7071 case bfd_mach_mips3000
:
7072 val
= E_MIPS_ARCH_1
;
7075 case bfd_mach_mips3900
:
7076 val
= E_MIPS_ARCH_1
| E_MIPS_MACH_3900
;
7079 case bfd_mach_mips6000
:
7080 val
= E_MIPS_ARCH_2
;
7083 case bfd_mach_mips4000
:
7084 case bfd_mach_mips4300
:
7085 case bfd_mach_mips4400
:
7086 case bfd_mach_mips4600
:
7087 val
= E_MIPS_ARCH_3
;
7090 case bfd_mach_mips4010
:
7091 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4010
;
7094 case bfd_mach_mips4100
:
7095 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4100
;
7098 case bfd_mach_mips4111
:
7099 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4111
;
7102 case bfd_mach_mips4120
:
7103 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4120
;
7106 case bfd_mach_mips4650
:
7107 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4650
;
7110 case bfd_mach_mips5400
:
7111 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5400
;
7114 case bfd_mach_mips5500
:
7115 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5500
;
7118 case bfd_mach_mips5000
:
7119 case bfd_mach_mips7000
:
7120 case bfd_mach_mips8000
:
7121 case bfd_mach_mips10000
:
7122 case bfd_mach_mips12000
:
7123 val
= E_MIPS_ARCH_4
;
7126 case bfd_mach_mips5
:
7127 val
= E_MIPS_ARCH_5
;
7130 case bfd_mach_mips_sb1
:
7131 val
= E_MIPS_ARCH_64
| E_MIPS_MACH_SB1
;
7134 case bfd_mach_mipsisa32
:
7135 val
= E_MIPS_ARCH_32
;
7138 case bfd_mach_mipsisa64
:
7139 val
= E_MIPS_ARCH_64
;
7142 case bfd_mach_mipsisa32r2
:
7143 val
= E_MIPS_ARCH_32R2
;
7146 case bfd_mach_mipsisa64r2
:
7147 val
= E_MIPS_ARCH_64R2
;
7150 elf_elfheader (abfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
7151 elf_elfheader (abfd
)->e_flags
|= val
;
7156 /* The final processing done just before writing out a MIPS ELF object
7157 file. This gets the MIPS architecture right based on the machine
7158 number. This is used by both the 32-bit and the 64-bit ABI. */
7161 _bfd_mips_elf_final_write_processing (bfd
*abfd
,
7162 bfd_boolean linker ATTRIBUTE_UNUSED
)
7165 Elf_Internal_Shdr
**hdrpp
;
7169 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
7170 is nonzero. This is for compatibility with old objects, which used
7171 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
7172 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_MACH
) == 0)
7173 mips_set_isa_flags (abfd
);
7175 /* Set the sh_info field for .gptab sections and other appropriate
7176 info for each special section. */
7177 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
7178 i
< elf_numsections (abfd
);
7181 switch ((*hdrpp
)->sh_type
)
7184 case SHT_MIPS_LIBLIST
:
7185 sec
= bfd_get_section_by_name (abfd
, ".dynstr");
7187 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7190 case SHT_MIPS_GPTAB
:
7191 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7192 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7193 BFD_ASSERT (name
!= NULL
7194 && strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0);
7195 sec
= bfd_get_section_by_name (abfd
, name
+ sizeof ".gptab" - 1);
7196 BFD_ASSERT (sec
!= NULL
);
7197 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
7200 case SHT_MIPS_CONTENT
:
7201 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7202 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7203 BFD_ASSERT (name
!= NULL
7204 && strncmp (name
, ".MIPS.content",
7205 sizeof ".MIPS.content" - 1) == 0);
7206 sec
= bfd_get_section_by_name (abfd
,
7207 name
+ sizeof ".MIPS.content" - 1);
7208 BFD_ASSERT (sec
!= NULL
);
7209 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7212 case SHT_MIPS_SYMBOL_LIB
:
7213 sec
= bfd_get_section_by_name (abfd
, ".dynsym");
7215 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7216 sec
= bfd_get_section_by_name (abfd
, ".liblist");
7218 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
7221 case SHT_MIPS_EVENTS
:
7222 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7223 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7224 BFD_ASSERT (name
!= NULL
);
7225 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0)
7226 sec
= bfd_get_section_by_name (abfd
,
7227 name
+ sizeof ".MIPS.events" - 1);
7230 BFD_ASSERT (strncmp (name
, ".MIPS.post_rel",
7231 sizeof ".MIPS.post_rel" - 1) == 0);
7232 sec
= bfd_get_section_by_name (abfd
,
7234 + sizeof ".MIPS.post_rel" - 1));
7236 BFD_ASSERT (sec
!= NULL
);
7237 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7244 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
7248 _bfd_mips_elf_additional_program_headers (bfd
*abfd
)
7253 /* See if we need a PT_MIPS_REGINFO segment. */
7254 s
= bfd_get_section_by_name (abfd
, ".reginfo");
7255 if (s
&& (s
->flags
& SEC_LOAD
))
7258 /* See if we need a PT_MIPS_OPTIONS segment. */
7259 if (IRIX_COMPAT (abfd
) == ict_irix6
7260 && bfd_get_section_by_name (abfd
,
7261 MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)))
7264 /* See if we need a PT_MIPS_RTPROC segment. */
7265 if (IRIX_COMPAT (abfd
) == ict_irix5
7266 && bfd_get_section_by_name (abfd
, ".dynamic")
7267 && bfd_get_section_by_name (abfd
, ".mdebug"))
7273 /* Modify the segment map for an IRIX5 executable. */
7276 _bfd_mips_elf_modify_segment_map (bfd
*abfd
,
7277 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
7280 struct elf_segment_map
*m
, **pm
;
7283 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
7285 s
= bfd_get_section_by_name (abfd
, ".reginfo");
7286 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
7288 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
7289 if (m
->p_type
== PT_MIPS_REGINFO
)
7294 m
= bfd_zalloc (abfd
, amt
);
7298 m
->p_type
= PT_MIPS_REGINFO
;
7302 /* We want to put it after the PHDR and INTERP segments. */
7303 pm
= &elf_tdata (abfd
)->segment_map
;
7305 && ((*pm
)->p_type
== PT_PHDR
7306 || (*pm
)->p_type
== PT_INTERP
))
7314 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
7315 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
7316 PT_MIPS_OPTIONS segment immediately following the program header
7319 /* On non-IRIX6 new abi, we'll have already created a segment
7320 for this section, so don't create another. I'm not sure this
7321 is not also the case for IRIX 6, but I can't test it right
7323 && IRIX_COMPAT (abfd
) == ict_irix6
)
7325 for (s
= abfd
->sections
; s
; s
= s
->next
)
7326 if (elf_section_data (s
)->this_hdr
.sh_type
== SHT_MIPS_OPTIONS
)
7331 struct elf_segment_map
*options_segment
;
7333 pm
= &elf_tdata (abfd
)->segment_map
;
7335 && ((*pm
)->p_type
== PT_PHDR
7336 || (*pm
)->p_type
== PT_INTERP
))
7339 amt
= sizeof (struct elf_segment_map
);
7340 options_segment
= bfd_zalloc (abfd
, amt
);
7341 options_segment
->next
= *pm
;
7342 options_segment
->p_type
= PT_MIPS_OPTIONS
;
7343 options_segment
->p_flags
= PF_R
;
7344 options_segment
->p_flags_valid
= TRUE
;
7345 options_segment
->count
= 1;
7346 options_segment
->sections
[0] = s
;
7347 *pm
= options_segment
;
7352 if (IRIX_COMPAT (abfd
) == ict_irix5
)
7354 /* If there are .dynamic and .mdebug sections, we make a room
7355 for the RTPROC header. FIXME: Rewrite without section names. */
7356 if (bfd_get_section_by_name (abfd
, ".interp") == NULL
7357 && bfd_get_section_by_name (abfd
, ".dynamic") != NULL
7358 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
7360 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
7361 if (m
->p_type
== PT_MIPS_RTPROC
)
7366 m
= bfd_zalloc (abfd
, amt
);
7370 m
->p_type
= PT_MIPS_RTPROC
;
7372 s
= bfd_get_section_by_name (abfd
, ".rtproc");
7377 m
->p_flags_valid
= 1;
7385 /* We want to put it after the DYNAMIC segment. */
7386 pm
= &elf_tdata (abfd
)->segment_map
;
7387 while (*pm
!= NULL
&& (*pm
)->p_type
!= PT_DYNAMIC
)
7397 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
7398 .dynstr, .dynsym, and .hash sections, and everything in
7400 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
;
7402 if ((*pm
)->p_type
== PT_DYNAMIC
)
7405 if (m
!= NULL
&& IRIX_COMPAT (abfd
) == ict_none
)
7407 /* For a normal mips executable the permissions for the PT_DYNAMIC
7408 segment are read, write and execute. We do that here since
7409 the code in elf.c sets only the read permission. This matters
7410 sometimes for the dynamic linker. */
7411 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
7413 m
->p_flags
= PF_R
| PF_W
| PF_X
;
7414 m
->p_flags_valid
= 1;
7418 && m
->count
== 1 && strcmp (m
->sections
[0]->name
, ".dynamic") == 0)
7420 static const char *sec_names
[] =
7422 ".dynamic", ".dynstr", ".dynsym", ".hash"
7426 struct elf_segment_map
*n
;
7430 for (i
= 0; i
< sizeof sec_names
/ sizeof sec_names
[0]; i
++)
7432 s
= bfd_get_section_by_name (abfd
, sec_names
[i
]);
7433 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
7439 sz
= s
->_cooked_size
;
7442 if (high
< s
->vma
+ sz
)
7448 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
7449 if ((s
->flags
& SEC_LOAD
) != 0
7452 + (s
->_cooked_size
!=
7453 0 ? s
->_cooked_size
: s
->_raw_size
)) <= high
))
7456 amt
= sizeof *n
+ (bfd_size_type
) (c
- 1) * sizeof (asection
*);
7457 n
= bfd_zalloc (abfd
, amt
);
7464 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
7466 if ((s
->flags
& SEC_LOAD
) != 0
7469 + (s
->_cooked_size
!= 0 ?
7470 s
->_cooked_size
: s
->_raw_size
)) <= high
))
7484 /* Return the section that should be marked against GC for a given
7488 _bfd_mips_elf_gc_mark_hook (asection
*sec
,
7489 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
7490 Elf_Internal_Rela
*rel
,
7491 struct elf_link_hash_entry
*h
,
7492 Elf_Internal_Sym
*sym
)
7494 /* ??? Do mips16 stub sections need to be handled special? */
7498 switch (ELF_R_TYPE (sec
->owner
, rel
->r_info
))
7500 case R_MIPS_GNU_VTINHERIT
:
7501 case R_MIPS_GNU_VTENTRY
:
7505 switch (h
->root
.type
)
7507 case bfd_link_hash_defined
:
7508 case bfd_link_hash_defweak
:
7509 return h
->root
.u
.def
.section
;
7511 case bfd_link_hash_common
:
7512 return h
->root
.u
.c
.p
->section
;
7520 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
7525 /* Update the got entry reference counts for the section being removed. */
7528 _bfd_mips_elf_gc_sweep_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
7529 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
7530 asection
*sec ATTRIBUTE_UNUSED
,
7531 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
)
7534 Elf_Internal_Shdr
*symtab_hdr
;
7535 struct elf_link_hash_entry
**sym_hashes
;
7536 bfd_signed_vma
*local_got_refcounts
;
7537 const Elf_Internal_Rela
*rel
, *relend
;
7538 unsigned long r_symndx
;
7539 struct elf_link_hash_entry
*h
;
7541 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7542 sym_hashes
= elf_sym_hashes (abfd
);
7543 local_got_refcounts
= elf_local_got_refcounts (abfd
);
7545 relend
= relocs
+ sec
->reloc_count
;
7546 for (rel
= relocs
; rel
< relend
; rel
++)
7547 switch (ELF_R_TYPE (abfd
, rel
->r_info
))
7551 case R_MIPS_CALL_HI16
:
7552 case R_MIPS_CALL_LO16
:
7553 case R_MIPS_GOT_HI16
:
7554 case R_MIPS_GOT_LO16
:
7555 case R_MIPS_GOT_DISP
:
7556 case R_MIPS_GOT_PAGE
:
7557 case R_MIPS_GOT_OFST
:
7558 /* ??? It would seem that the existing MIPS code does no sort
7559 of reference counting or whatnot on its GOT and PLT entries,
7560 so it is not possible to garbage collect them at this time. */
7571 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
7572 hiding the old indirect symbol. Process additional relocation
7573 information. Also called for weakdefs, in which case we just let
7574 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
7577 _bfd_mips_elf_copy_indirect_symbol (const struct elf_backend_data
*bed
,
7578 struct elf_link_hash_entry
*dir
,
7579 struct elf_link_hash_entry
*ind
)
7581 struct mips_elf_link_hash_entry
*dirmips
, *indmips
;
7583 _bfd_elf_link_hash_copy_indirect (bed
, dir
, ind
);
7585 if (ind
->root
.type
!= bfd_link_hash_indirect
)
7588 dirmips
= (struct mips_elf_link_hash_entry
*) dir
;
7589 indmips
= (struct mips_elf_link_hash_entry
*) ind
;
7590 dirmips
->possibly_dynamic_relocs
+= indmips
->possibly_dynamic_relocs
;
7591 if (indmips
->readonly_reloc
)
7592 dirmips
->readonly_reloc
= TRUE
;
7593 if (indmips
->no_fn_stub
)
7594 dirmips
->no_fn_stub
= TRUE
;
7598 _bfd_mips_elf_hide_symbol (struct bfd_link_info
*info
,
7599 struct elf_link_hash_entry
*entry
,
7600 bfd_boolean force_local
)
7604 struct mips_got_info
*g
;
7605 struct mips_elf_link_hash_entry
*h
;
7607 h
= (struct mips_elf_link_hash_entry
*) entry
;
7608 if (h
->forced_local
)
7610 h
->forced_local
= force_local
;
7612 dynobj
= elf_hash_table (info
)->dynobj
;
7613 if (dynobj
!= NULL
&& force_local
)
7615 got
= mips_elf_got_section (dynobj
, FALSE
);
7616 g
= mips_elf_section_data (got
)->u
.got_info
;
7620 struct mips_got_entry e
;
7621 struct mips_got_info
*gg
= g
;
7623 /* Since we're turning what used to be a global symbol into a
7624 local one, bump up the number of local entries of each GOT
7625 that had an entry for it. This will automatically decrease
7626 the number of global entries, since global_gotno is actually
7627 the upper limit of global entries. */
7632 for (g
= g
->next
; g
!= gg
; g
= g
->next
)
7633 if (htab_find (g
->got_entries
, &e
))
7635 BFD_ASSERT (g
->global_gotno
> 0);
7640 /* If this was a global symbol forced into the primary GOT, we
7641 no longer need an entry for it. We can't release the entry
7642 at this point, but we must at least stop counting it as one
7643 of the symbols that required a forced got entry. */
7644 if (h
->root
.got
.offset
== 2)
7646 BFD_ASSERT (gg
->assigned_gotno
> 0);
7647 gg
->assigned_gotno
--;
7650 else if (g
->global_gotno
== 0 && g
->global_gotsym
== NULL
)
7651 /* If we haven't got through GOT allocation yet, just bump up the
7652 number of local entries, as this symbol won't be counted as
7655 else if (h
->root
.got
.offset
== 1)
7657 /* If we're past non-multi-GOT allocation and this symbol had
7658 been marked for a global got entry, give it a local entry
7660 BFD_ASSERT (g
->global_gotno
> 0);
7666 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
7672 _bfd_mips_elf_discard_info (bfd
*abfd
, struct elf_reloc_cookie
*cookie
,
7673 struct bfd_link_info
*info
)
7676 bfd_boolean ret
= FALSE
;
7677 unsigned char *tdata
;
7680 o
= bfd_get_section_by_name (abfd
, ".pdr");
7683 if (o
->_raw_size
== 0)
7685 if (o
->_raw_size
% PDR_SIZE
!= 0)
7687 if (o
->output_section
!= NULL
7688 && bfd_is_abs_section (o
->output_section
))
7691 tdata
= bfd_zmalloc (o
->_raw_size
/ PDR_SIZE
);
7695 cookie
->rels
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
7703 cookie
->rel
= cookie
->rels
;
7704 cookie
->relend
= cookie
->rels
+ o
->reloc_count
;
7706 for (i
= 0, skip
= 0; i
< o
->_raw_size
/ PDR_SIZE
; i
++)
7708 if (bfd_elf_reloc_symbol_deleted_p (i
* PDR_SIZE
, cookie
))
7717 mips_elf_section_data (o
)->u
.tdata
= tdata
;
7718 o
->_cooked_size
= o
->_raw_size
- skip
* PDR_SIZE
;
7724 if (! info
->keep_memory
)
7725 free (cookie
->rels
);
7731 _bfd_mips_elf_ignore_discarded_relocs (asection
*sec
)
7733 if (strcmp (sec
->name
, ".pdr") == 0)
7739 _bfd_mips_elf_write_section (bfd
*output_bfd
, asection
*sec
,
7742 bfd_byte
*to
, *from
, *end
;
7745 if (strcmp (sec
->name
, ".pdr") != 0)
7748 if (mips_elf_section_data (sec
)->u
.tdata
== NULL
)
7752 end
= contents
+ sec
->_raw_size
;
7753 for (from
= contents
, i
= 0;
7755 from
+= PDR_SIZE
, i
++)
7757 if ((mips_elf_section_data (sec
)->u
.tdata
)[i
] == 1)
7760 memcpy (to
, from
, PDR_SIZE
);
7763 bfd_set_section_contents (output_bfd
, sec
->output_section
, contents
,
7764 sec
->output_offset
, sec
->_cooked_size
);
7768 /* MIPS ELF uses a special find_nearest_line routine in order the
7769 handle the ECOFF debugging information. */
7771 struct mips_elf_find_line
7773 struct ecoff_debug_info d
;
7774 struct ecoff_find_line i
;
7778 _bfd_mips_elf_find_nearest_line (bfd
*abfd
, asection
*section
,
7779 asymbol
**symbols
, bfd_vma offset
,
7780 const char **filename_ptr
,
7781 const char **functionname_ptr
,
7782 unsigned int *line_ptr
)
7786 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
7787 filename_ptr
, functionname_ptr
,
7791 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
7792 filename_ptr
, functionname_ptr
,
7793 line_ptr
, ABI_64_P (abfd
) ? 8 : 0,
7794 &elf_tdata (abfd
)->dwarf2_find_line_info
))
7797 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
7801 struct mips_elf_find_line
*fi
;
7802 const struct ecoff_debug_swap
* const swap
=
7803 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
7805 /* If we are called during a link, mips_elf_final_link may have
7806 cleared the SEC_HAS_CONTENTS field. We force it back on here
7807 if appropriate (which it normally will be). */
7808 origflags
= msec
->flags
;
7809 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
7810 msec
->flags
|= SEC_HAS_CONTENTS
;
7812 fi
= elf_tdata (abfd
)->find_line_info
;
7815 bfd_size_type external_fdr_size
;
7818 struct fdr
*fdr_ptr
;
7819 bfd_size_type amt
= sizeof (struct mips_elf_find_line
);
7821 fi
= bfd_zalloc (abfd
, amt
);
7824 msec
->flags
= origflags
;
7828 if (! _bfd_mips_elf_read_ecoff_info (abfd
, msec
, &fi
->d
))
7830 msec
->flags
= origflags
;
7834 /* Swap in the FDR information. */
7835 amt
= fi
->d
.symbolic_header
.ifdMax
* sizeof (struct fdr
);
7836 fi
->d
.fdr
= bfd_alloc (abfd
, amt
);
7837 if (fi
->d
.fdr
== NULL
)
7839 msec
->flags
= origflags
;
7842 external_fdr_size
= swap
->external_fdr_size
;
7843 fdr_ptr
= fi
->d
.fdr
;
7844 fraw_src
= (char *) fi
->d
.external_fdr
;
7845 fraw_end
= (fraw_src
7846 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
7847 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
7848 (*swap
->swap_fdr_in
) (abfd
, fraw_src
, fdr_ptr
);
7850 elf_tdata (abfd
)->find_line_info
= fi
;
7852 /* Note that we don't bother to ever free this information.
7853 find_nearest_line is either called all the time, as in
7854 objdump -l, so the information should be saved, or it is
7855 rarely called, as in ld error messages, so the memory
7856 wasted is unimportant. Still, it would probably be a
7857 good idea for free_cached_info to throw it away. */
7860 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
7861 &fi
->i
, filename_ptr
, functionname_ptr
,
7864 msec
->flags
= origflags
;
7868 msec
->flags
= origflags
;
7871 /* Fall back on the generic ELF find_nearest_line routine. */
7873 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
7874 filename_ptr
, functionname_ptr
,
7878 /* When are writing out the .options or .MIPS.options section,
7879 remember the bytes we are writing out, so that we can install the
7880 GP value in the section_processing routine. */
7883 _bfd_mips_elf_set_section_contents (bfd
*abfd
, sec_ptr section
,
7884 const void *location
,
7885 file_ptr offset
, bfd_size_type count
)
7887 if (strcmp (section
->name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
7891 if (elf_section_data (section
) == NULL
)
7893 bfd_size_type amt
= sizeof (struct bfd_elf_section_data
);
7894 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
7895 if (elf_section_data (section
) == NULL
)
7898 c
= mips_elf_section_data (section
)->u
.tdata
;
7903 if (section
->_cooked_size
!= 0)
7904 size
= section
->_cooked_size
;
7906 size
= section
->_raw_size
;
7907 c
= bfd_zalloc (abfd
, size
);
7910 mips_elf_section_data (section
)->u
.tdata
= c
;
7913 memcpy (c
+ offset
, location
, count
);
7916 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
,
7920 /* This is almost identical to bfd_generic_get_... except that some
7921 MIPS relocations need to be handled specially. Sigh. */
7924 _bfd_elf_mips_get_relocated_section_contents
7926 struct bfd_link_info
*link_info
,
7927 struct bfd_link_order
*link_order
,
7929 bfd_boolean relocatable
,
7932 /* Get enough memory to hold the stuff */
7933 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
7934 asection
*input_section
= link_order
->u
.indirect
.section
;
7936 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
7937 arelent
**reloc_vector
= NULL
;
7943 reloc_vector
= bfd_malloc (reloc_size
);
7944 if (reloc_vector
== NULL
&& reloc_size
!= 0)
7947 /* read in the section */
7948 if (!bfd_get_section_contents (input_bfd
, input_section
, data
, 0,
7949 input_section
->_raw_size
))
7952 /* We're not relaxing the section, so just copy the size info */
7953 input_section
->_cooked_size
= input_section
->_raw_size
;
7954 input_section
->reloc_done
= TRUE
;
7956 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
7960 if (reloc_count
< 0)
7963 if (reloc_count
> 0)
7968 bfd_vma gp
= 0x12345678; /* initialize just to shut gcc up */
7971 struct bfd_hash_entry
*h
;
7972 struct bfd_link_hash_entry
*lh
;
7973 /* Skip all this stuff if we aren't mixing formats. */
7974 if (abfd
&& input_bfd
7975 && abfd
->xvec
== input_bfd
->xvec
)
7979 h
= bfd_hash_lookup (&link_info
->hash
->table
, "_gp", FALSE
, FALSE
);
7980 lh
= (struct bfd_link_hash_entry
*) h
;
7987 case bfd_link_hash_undefined
:
7988 case bfd_link_hash_undefweak
:
7989 case bfd_link_hash_common
:
7992 case bfd_link_hash_defined
:
7993 case bfd_link_hash_defweak
:
7995 gp
= lh
->u
.def
.value
;
7997 case bfd_link_hash_indirect
:
7998 case bfd_link_hash_warning
:
8000 /* @@FIXME ignoring warning for now */
8002 case bfd_link_hash_new
:
8011 for (parent
= reloc_vector
; *parent
!= NULL
; parent
++)
8013 char *error_message
= NULL
;
8014 bfd_reloc_status_type r
;
8016 /* Specific to MIPS: Deal with relocation types that require
8017 knowing the gp of the output bfd. */
8018 asymbol
*sym
= *(*parent
)->sym_ptr_ptr
;
8019 if (bfd_is_abs_section (sym
->section
) && abfd
)
8021 /* The special_function wouldn't get called anyway. */
8025 /* The gp isn't there; let the special function code
8026 fall over on its own. */
8028 else if ((*parent
)->howto
->special_function
8029 == _bfd_mips_elf32_gprel16_reloc
)
8031 /* bypass special_function call */
8032 r
= _bfd_mips_elf_gprel16_with_gp (input_bfd
, sym
, *parent
,
8033 input_section
, relocatable
,
8035 goto skip_bfd_perform_relocation
;
8037 /* end mips specific stuff */
8039 r
= bfd_perform_relocation (input_bfd
, *parent
, data
, input_section
,
8040 relocatable
? abfd
: NULL
,
8042 skip_bfd_perform_relocation
:
8046 asection
*os
= input_section
->output_section
;
8048 /* A partial link, so keep the relocs */
8049 os
->orelocation
[os
->reloc_count
] = *parent
;
8053 if (r
!= bfd_reloc_ok
)
8057 case bfd_reloc_undefined
:
8058 if (!((*link_info
->callbacks
->undefined_symbol
)
8059 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
8060 input_bfd
, input_section
, (*parent
)->address
,
8064 case bfd_reloc_dangerous
:
8065 BFD_ASSERT (error_message
!= NULL
);
8066 if (!((*link_info
->callbacks
->reloc_dangerous
)
8067 (link_info
, error_message
, input_bfd
, input_section
,
8068 (*parent
)->address
)))
8071 case bfd_reloc_overflow
:
8072 if (!((*link_info
->callbacks
->reloc_overflow
)
8073 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
8074 (*parent
)->howto
->name
, (*parent
)->addend
,
8075 input_bfd
, input_section
, (*parent
)->address
)))
8078 case bfd_reloc_outofrange
:
8087 if (reloc_vector
!= NULL
)
8088 free (reloc_vector
);
8092 if (reloc_vector
!= NULL
)
8093 free (reloc_vector
);
8097 /* Create a MIPS ELF linker hash table. */
8099 struct bfd_link_hash_table
*
8100 _bfd_mips_elf_link_hash_table_create (bfd
*abfd
)
8102 struct mips_elf_link_hash_table
*ret
;
8103 bfd_size_type amt
= sizeof (struct mips_elf_link_hash_table
);
8105 ret
= bfd_malloc (amt
);
8109 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
8110 mips_elf_link_hash_newfunc
))
8117 /* We no longer use this. */
8118 for (i
= 0; i
< SIZEOF_MIPS_DYNSYM_SECNAMES
; i
++)
8119 ret
->dynsym_sec_strindex
[i
] = (bfd_size_type
) -1;
8121 ret
->procedure_count
= 0;
8122 ret
->compact_rel_size
= 0;
8123 ret
->use_rld_obj_head
= FALSE
;
8125 ret
->mips16_stubs_seen
= FALSE
;
8127 return &ret
->root
.root
;
8130 /* We need to use a special link routine to handle the .reginfo and
8131 the .mdebug sections. We need to merge all instances of these
8132 sections together, not write them all out sequentially. */
8135 _bfd_mips_elf_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
8139 struct bfd_link_order
*p
;
8140 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
8141 asection
*rtproc_sec
;
8142 Elf32_RegInfo reginfo
;
8143 struct ecoff_debug_info debug
;
8144 const struct ecoff_debug_swap
*swap
8145 = get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
8146 HDRR
*symhdr
= &debug
.symbolic_header
;
8147 void *mdebug_handle
= NULL
;
8153 static const char * const secname
[] =
8155 ".text", ".init", ".fini", ".data",
8156 ".rodata", ".sdata", ".sbss", ".bss"
8158 static const int sc
[] =
8160 scText
, scInit
, scFini
, scData
,
8161 scRData
, scSData
, scSBss
, scBss
8164 /* We'd carefully arranged the dynamic symbol indices, and then the
8165 generic size_dynamic_sections renumbered them out from under us.
8166 Rather than trying somehow to prevent the renumbering, just do
8168 if (elf_hash_table (info
)->dynamic_sections_created
)
8172 struct mips_got_info
*g
;
8174 /* When we resort, we must tell mips_elf_sort_hash_table what
8175 the lowest index it may use is. That's the number of section
8176 symbols we're going to add. The generic ELF linker only
8177 adds these symbols when building a shared object. Note that
8178 we count the sections after (possibly) removing the .options
8180 if (! mips_elf_sort_hash_table (info
, (info
->shared
8181 ? bfd_count_sections (abfd
) + 1
8185 /* Make sure we didn't grow the global .got region. */
8186 dynobj
= elf_hash_table (info
)->dynobj
;
8187 got
= mips_elf_got_section (dynobj
, FALSE
);
8188 g
= mips_elf_section_data (got
)->u
.got_info
;
8190 if (g
->global_gotsym
!= NULL
)
8191 BFD_ASSERT ((elf_hash_table (info
)->dynsymcount
8192 - g
->global_gotsym
->dynindx
)
8193 <= g
->global_gotno
);
8197 /* We want to set the GP value for ld -r. */
8198 /* On IRIX5, we omit the .options section. On IRIX6, however, we
8199 include it, even though we don't process it quite right. (Some
8200 entries are supposed to be merged.) Empirically, we seem to be
8201 better off including it then not. */
8202 if (IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
8203 for (secpp
= &abfd
->sections
; *secpp
!= NULL
; secpp
= &(*secpp
)->next
)
8205 if (strcmp ((*secpp
)->name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
8207 for (p
= (*secpp
)->link_order_head
; p
!= NULL
; p
= p
->next
)
8208 if (p
->type
== bfd_indirect_link_order
)
8209 p
->u
.indirect
.section
->flags
&= ~SEC_HAS_CONTENTS
;
8210 (*secpp
)->link_order_head
= NULL
;
8211 bfd_section_list_remove (abfd
, secpp
);
8212 --abfd
->section_count
;
8218 /* We include .MIPS.options, even though we don't process it quite right.
8219 (Some entries are supposed to be merged.) At IRIX6 empirically we seem
8220 to be better off including it than not. */
8221 for (secpp
= &abfd
->sections
; *secpp
!= NULL
; secpp
= &(*secpp
)->next
)
8223 if (strcmp ((*secpp
)->name
, ".MIPS.options") == 0)
8225 for (p
= (*secpp
)->link_order_head
; p
!= NULL
; p
= p
->next
)
8226 if (p
->type
== bfd_indirect_link_order
)
8227 p
->u
.indirect
.section
->flags
&=~ SEC_HAS_CONTENTS
;
8228 (*secpp
)->link_order_head
= NULL
;
8229 bfd_section_list_remove (abfd
, secpp
);
8230 --abfd
->section_count
;
8237 /* Get a value for the GP register. */
8238 if (elf_gp (abfd
) == 0)
8240 struct bfd_link_hash_entry
*h
;
8242 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
8243 if (h
!= NULL
&& h
->type
== bfd_link_hash_defined
)
8244 elf_gp (abfd
) = (h
->u
.def
.value
8245 + h
->u
.def
.section
->output_section
->vma
8246 + h
->u
.def
.section
->output_offset
);
8247 else if (info
->relocatable
)
8249 bfd_vma lo
= MINUS_ONE
;
8251 /* Find the GP-relative section with the lowest offset. */
8252 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
8254 && (elf_section_data (o
)->this_hdr
.sh_flags
& SHF_MIPS_GPREL
))
8257 /* And calculate GP relative to that. */
8258 elf_gp (abfd
) = lo
+ ELF_MIPS_GP_OFFSET (abfd
);
8262 /* If the relocate_section function needs to do a reloc
8263 involving the GP value, it should make a reloc_dangerous
8264 callback to warn that GP is not defined. */
8268 /* Go through the sections and collect the .reginfo and .mdebug
8272 gptab_data_sec
= NULL
;
8273 gptab_bss_sec
= NULL
;
8274 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
8276 if (strcmp (o
->name
, ".reginfo") == 0)
8278 memset (®info
, 0, sizeof reginfo
);
8280 /* We have found the .reginfo section in the output file.
8281 Look through all the link_orders comprising it and merge
8282 the information together. */
8283 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8285 asection
*input_section
;
8287 Elf32_External_RegInfo ext
;
8290 if (p
->type
!= bfd_indirect_link_order
)
8292 if (p
->type
== bfd_data_link_order
)
8297 input_section
= p
->u
.indirect
.section
;
8298 input_bfd
= input_section
->owner
;
8300 /* The linker emulation code has probably clobbered the
8301 size to be zero bytes. */
8302 if (input_section
->_raw_size
== 0)
8303 input_section
->_raw_size
= sizeof (Elf32_External_RegInfo
);
8305 if (! bfd_get_section_contents (input_bfd
, input_section
,
8306 &ext
, 0, sizeof ext
))
8309 bfd_mips_elf32_swap_reginfo_in (input_bfd
, &ext
, &sub
);
8311 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
8312 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
8313 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
8314 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
8315 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
8317 /* ri_gp_value is set by the function
8318 mips_elf32_section_processing when the section is
8319 finally written out. */
8321 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8322 elf_link_input_bfd ignores this section. */
8323 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8326 /* Size has been set in _bfd_mips_elf_always_size_sections. */
8327 BFD_ASSERT(o
->_raw_size
== sizeof (Elf32_External_RegInfo
));
8329 /* Skip this section later on (I don't think this currently
8330 matters, but someday it might). */
8331 o
->link_order_head
= NULL
;
8336 if (strcmp (o
->name
, ".mdebug") == 0)
8338 struct extsym_info einfo
;
8341 /* We have found the .mdebug section in the output file.
8342 Look through all the link_orders comprising it and merge
8343 the information together. */
8344 symhdr
->magic
= swap
->sym_magic
;
8345 /* FIXME: What should the version stamp be? */
8347 symhdr
->ilineMax
= 0;
8351 symhdr
->isymMax
= 0;
8352 symhdr
->ioptMax
= 0;
8353 symhdr
->iauxMax
= 0;
8355 symhdr
->issExtMax
= 0;
8358 symhdr
->iextMax
= 0;
8360 /* We accumulate the debugging information itself in the
8361 debug_info structure. */
8363 debug
.external_dnr
= NULL
;
8364 debug
.external_pdr
= NULL
;
8365 debug
.external_sym
= NULL
;
8366 debug
.external_opt
= NULL
;
8367 debug
.external_aux
= NULL
;
8369 debug
.ssext
= debug
.ssext_end
= NULL
;
8370 debug
.external_fdr
= NULL
;
8371 debug
.external_rfd
= NULL
;
8372 debug
.external_ext
= debug
.external_ext_end
= NULL
;
8374 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
8375 if (mdebug_handle
== NULL
)
8379 esym
.cobol_main
= 0;
8383 esym
.asym
.iss
= issNil
;
8384 esym
.asym
.st
= stLocal
;
8385 esym
.asym
.reserved
= 0;
8386 esym
.asym
.index
= indexNil
;
8388 for (i
= 0; i
< sizeof (secname
) / sizeof (secname
[0]); i
++)
8390 esym
.asym
.sc
= sc
[i
];
8391 s
= bfd_get_section_by_name (abfd
, secname
[i
]);
8394 esym
.asym
.value
= s
->vma
;
8395 last
= s
->vma
+ s
->_raw_size
;
8398 esym
.asym
.value
= last
;
8399 if (!bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
8404 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8406 asection
*input_section
;
8408 const struct ecoff_debug_swap
*input_swap
;
8409 struct ecoff_debug_info input_debug
;
8413 if (p
->type
!= bfd_indirect_link_order
)
8415 if (p
->type
== bfd_data_link_order
)
8420 input_section
= p
->u
.indirect
.section
;
8421 input_bfd
= input_section
->owner
;
8423 if (bfd_get_flavour (input_bfd
) != bfd_target_elf_flavour
8424 || (get_elf_backend_data (input_bfd
)
8425 ->elf_backend_ecoff_debug_swap
) == NULL
)
8427 /* I don't know what a non MIPS ELF bfd would be
8428 doing with a .mdebug section, but I don't really
8429 want to deal with it. */
8433 input_swap
= (get_elf_backend_data (input_bfd
)
8434 ->elf_backend_ecoff_debug_swap
);
8436 BFD_ASSERT (p
->size
== input_section
->_raw_size
);
8438 /* The ECOFF linking code expects that we have already
8439 read in the debugging information and set up an
8440 ecoff_debug_info structure, so we do that now. */
8441 if (! _bfd_mips_elf_read_ecoff_info (input_bfd
, input_section
,
8445 if (! (bfd_ecoff_debug_accumulate
8446 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
8447 &input_debug
, input_swap
, info
)))
8450 /* Loop through the external symbols. For each one with
8451 interesting information, try to find the symbol in
8452 the linker global hash table and save the information
8453 for the output external symbols. */
8454 eraw_src
= input_debug
.external_ext
;
8455 eraw_end
= (eraw_src
8456 + (input_debug
.symbolic_header
.iextMax
8457 * input_swap
->external_ext_size
));
8459 eraw_src
< eraw_end
;
8460 eraw_src
+= input_swap
->external_ext_size
)
8464 struct mips_elf_link_hash_entry
*h
;
8466 (*input_swap
->swap_ext_in
) (input_bfd
, eraw_src
, &ext
);
8467 if (ext
.asym
.sc
== scNil
8468 || ext
.asym
.sc
== scUndefined
8469 || ext
.asym
.sc
== scSUndefined
)
8472 name
= input_debug
.ssext
+ ext
.asym
.iss
;
8473 h
= mips_elf_link_hash_lookup (mips_elf_hash_table (info
),
8474 name
, FALSE
, FALSE
, TRUE
);
8475 if (h
== NULL
|| h
->esym
.ifd
!= -2)
8481 < input_debug
.symbolic_header
.ifdMax
);
8482 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
8488 /* Free up the information we just read. */
8489 free (input_debug
.line
);
8490 free (input_debug
.external_dnr
);
8491 free (input_debug
.external_pdr
);
8492 free (input_debug
.external_sym
);
8493 free (input_debug
.external_opt
);
8494 free (input_debug
.external_aux
);
8495 free (input_debug
.ss
);
8496 free (input_debug
.ssext
);
8497 free (input_debug
.external_fdr
);
8498 free (input_debug
.external_rfd
);
8499 free (input_debug
.external_ext
);
8501 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8502 elf_link_input_bfd ignores this section. */
8503 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8506 if (SGI_COMPAT (abfd
) && info
->shared
)
8508 /* Create .rtproc section. */
8509 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
8510 if (rtproc_sec
== NULL
)
8512 flagword flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
8513 | SEC_LINKER_CREATED
| SEC_READONLY
);
8515 rtproc_sec
= bfd_make_section (abfd
, ".rtproc");
8516 if (rtproc_sec
== NULL
8517 || ! bfd_set_section_flags (abfd
, rtproc_sec
, flags
)
8518 || ! bfd_set_section_alignment (abfd
, rtproc_sec
, 4))
8522 if (! mips_elf_create_procedure_table (mdebug_handle
, abfd
,
8528 /* Build the external symbol information. */
8531 einfo
.debug
= &debug
;
8533 einfo
.failed
= FALSE
;
8534 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
8535 mips_elf_output_extsym
, &einfo
);
8539 /* Set the size of the .mdebug section. */
8540 o
->_raw_size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
8542 /* Skip this section later on (I don't think this currently
8543 matters, but someday it might). */
8544 o
->link_order_head
= NULL
;
8549 if (strncmp (o
->name
, ".gptab.", sizeof ".gptab." - 1) == 0)
8551 const char *subname
;
8554 Elf32_External_gptab
*ext_tab
;
8557 /* The .gptab.sdata and .gptab.sbss sections hold
8558 information describing how the small data area would
8559 change depending upon the -G switch. These sections
8560 not used in executables files. */
8561 if (! info
->relocatable
)
8563 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8565 asection
*input_section
;
8567 if (p
->type
!= bfd_indirect_link_order
)
8569 if (p
->type
== bfd_data_link_order
)
8574 input_section
= p
->u
.indirect
.section
;
8576 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8577 elf_link_input_bfd ignores this section. */
8578 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8581 /* Skip this section later on (I don't think this
8582 currently matters, but someday it might). */
8583 o
->link_order_head
= NULL
;
8585 /* Really remove the section. */
8586 for (secpp
= &abfd
->sections
;
8588 secpp
= &(*secpp
)->next
)
8590 bfd_section_list_remove (abfd
, secpp
);
8591 --abfd
->section_count
;
8596 /* There is one gptab for initialized data, and one for
8597 uninitialized data. */
8598 if (strcmp (o
->name
, ".gptab.sdata") == 0)
8600 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
8604 (*_bfd_error_handler
)
8605 (_("%s: illegal section name `%s'"),
8606 bfd_get_filename (abfd
), o
->name
);
8607 bfd_set_error (bfd_error_nonrepresentable_section
);
8611 /* The linker script always combines .gptab.data and
8612 .gptab.sdata into .gptab.sdata, and likewise for
8613 .gptab.bss and .gptab.sbss. It is possible that there is
8614 no .sdata or .sbss section in the output file, in which
8615 case we must change the name of the output section. */
8616 subname
= o
->name
+ sizeof ".gptab" - 1;
8617 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
8619 if (o
== gptab_data_sec
)
8620 o
->name
= ".gptab.data";
8622 o
->name
= ".gptab.bss";
8623 subname
= o
->name
+ sizeof ".gptab" - 1;
8624 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
8627 /* Set up the first entry. */
8629 amt
= c
* sizeof (Elf32_gptab
);
8630 tab
= bfd_malloc (amt
);
8633 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
8634 tab
[0].gt_header
.gt_unused
= 0;
8636 /* Combine the input sections. */
8637 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8639 asection
*input_section
;
8643 bfd_size_type gpentry
;
8645 if (p
->type
!= bfd_indirect_link_order
)
8647 if (p
->type
== bfd_data_link_order
)
8652 input_section
= p
->u
.indirect
.section
;
8653 input_bfd
= input_section
->owner
;
8655 /* Combine the gptab entries for this input section one
8656 by one. We know that the input gptab entries are
8657 sorted by ascending -G value. */
8658 size
= bfd_section_size (input_bfd
, input_section
);
8660 for (gpentry
= sizeof (Elf32_External_gptab
);
8662 gpentry
+= sizeof (Elf32_External_gptab
))
8664 Elf32_External_gptab ext_gptab
;
8665 Elf32_gptab int_gptab
;
8671 if (! (bfd_get_section_contents
8672 (input_bfd
, input_section
, &ext_gptab
, gpentry
,
8673 sizeof (Elf32_External_gptab
))))
8679 bfd_mips_elf32_swap_gptab_in (input_bfd
, &ext_gptab
,
8681 val
= int_gptab
.gt_entry
.gt_g_value
;
8682 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
8685 for (look
= 1; look
< c
; look
++)
8687 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
8688 tab
[look
].gt_entry
.gt_bytes
+= add
;
8690 if (tab
[look
].gt_entry
.gt_g_value
== val
)
8696 Elf32_gptab
*new_tab
;
8699 /* We need a new table entry. */
8700 amt
= (bfd_size_type
) (c
+ 1) * sizeof (Elf32_gptab
);
8701 new_tab
= bfd_realloc (tab
, amt
);
8702 if (new_tab
== NULL
)
8708 tab
[c
].gt_entry
.gt_g_value
= val
;
8709 tab
[c
].gt_entry
.gt_bytes
= add
;
8711 /* Merge in the size for the next smallest -G
8712 value, since that will be implied by this new
8715 for (look
= 1; look
< c
; look
++)
8717 if (tab
[look
].gt_entry
.gt_g_value
< val
8719 || (tab
[look
].gt_entry
.gt_g_value
8720 > tab
[max
].gt_entry
.gt_g_value
)))
8724 tab
[c
].gt_entry
.gt_bytes
+=
8725 tab
[max
].gt_entry
.gt_bytes
;
8730 last
= int_gptab
.gt_entry
.gt_bytes
;
8733 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8734 elf_link_input_bfd ignores this section. */
8735 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8738 /* The table must be sorted by -G value. */
8740 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
8742 /* Swap out the table. */
8743 amt
= (bfd_size_type
) c
* sizeof (Elf32_External_gptab
);
8744 ext_tab
= bfd_alloc (abfd
, amt
);
8745 if (ext_tab
== NULL
)
8751 for (j
= 0; j
< c
; j
++)
8752 bfd_mips_elf32_swap_gptab_out (abfd
, tab
+ j
, ext_tab
+ j
);
8755 o
->_raw_size
= c
* sizeof (Elf32_External_gptab
);
8756 o
->contents
= (bfd_byte
*) ext_tab
;
8758 /* Skip this section later on (I don't think this currently
8759 matters, but someday it might). */
8760 o
->link_order_head
= NULL
;
8764 /* Invoke the regular ELF backend linker to do all the work. */
8765 if (!bfd_elf_final_link (abfd
, info
))
8768 /* Now write out the computed sections. */
8770 if (reginfo_sec
!= NULL
)
8772 Elf32_External_RegInfo ext
;
8774 bfd_mips_elf32_swap_reginfo_out (abfd
, ®info
, &ext
);
8775 if (! bfd_set_section_contents (abfd
, reginfo_sec
, &ext
, 0, sizeof ext
))
8779 if (mdebug_sec
!= NULL
)
8781 BFD_ASSERT (abfd
->output_has_begun
);
8782 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
8784 mdebug_sec
->filepos
))
8787 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
8790 if (gptab_data_sec
!= NULL
)
8792 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
8793 gptab_data_sec
->contents
,
8794 0, gptab_data_sec
->_raw_size
))
8798 if (gptab_bss_sec
!= NULL
)
8800 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
8801 gptab_bss_sec
->contents
,
8802 0, gptab_bss_sec
->_raw_size
))
8806 if (SGI_COMPAT (abfd
))
8808 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
8809 if (rtproc_sec
!= NULL
)
8811 if (! bfd_set_section_contents (abfd
, rtproc_sec
,
8812 rtproc_sec
->contents
,
8813 0, rtproc_sec
->_raw_size
))
8821 /* Structure for saying that BFD machine EXTENSION extends BASE. */
8823 struct mips_mach_extension
{
8824 unsigned long extension
, base
;
8828 /* An array describing how BFD machines relate to one another. The entries
8829 are ordered topologically with MIPS I extensions listed last. */
8831 static const struct mips_mach_extension mips_mach_extensions
[] = {
8832 /* MIPS64 extensions. */
8833 { bfd_mach_mipsisa64r2
, bfd_mach_mipsisa64
},
8834 { bfd_mach_mips_sb1
, bfd_mach_mipsisa64
},
8836 /* MIPS V extensions. */
8837 { bfd_mach_mipsisa64
, bfd_mach_mips5
},
8839 /* R10000 extensions. */
8840 { bfd_mach_mips12000
, bfd_mach_mips10000
},
8842 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
8843 vr5400 ISA, but doesn't include the multimedia stuff. It seems
8844 better to allow vr5400 and vr5500 code to be merged anyway, since
8845 many libraries will just use the core ISA. Perhaps we could add
8846 some sort of ASE flag if this ever proves a problem. */
8847 { bfd_mach_mips5500
, bfd_mach_mips5400
},
8848 { bfd_mach_mips5400
, bfd_mach_mips5000
},
8850 /* MIPS IV extensions. */
8851 { bfd_mach_mips5
, bfd_mach_mips8000
},
8852 { bfd_mach_mips10000
, bfd_mach_mips8000
},
8853 { bfd_mach_mips5000
, bfd_mach_mips8000
},
8854 { bfd_mach_mips7000
, bfd_mach_mips8000
},
8856 /* VR4100 extensions. */
8857 { bfd_mach_mips4120
, bfd_mach_mips4100
},
8858 { bfd_mach_mips4111
, bfd_mach_mips4100
},
8860 /* MIPS III extensions. */
8861 { bfd_mach_mips8000
, bfd_mach_mips4000
},
8862 { bfd_mach_mips4650
, bfd_mach_mips4000
},
8863 { bfd_mach_mips4600
, bfd_mach_mips4000
},
8864 { bfd_mach_mips4400
, bfd_mach_mips4000
},
8865 { bfd_mach_mips4300
, bfd_mach_mips4000
},
8866 { bfd_mach_mips4100
, bfd_mach_mips4000
},
8867 { bfd_mach_mips4010
, bfd_mach_mips4000
},
8869 /* MIPS32 extensions. */
8870 { bfd_mach_mipsisa32r2
, bfd_mach_mipsisa32
},
8872 /* MIPS II extensions. */
8873 { bfd_mach_mips4000
, bfd_mach_mips6000
},
8874 { bfd_mach_mipsisa32
, bfd_mach_mips6000
},
8876 /* MIPS I extensions. */
8877 { bfd_mach_mips6000
, bfd_mach_mips3000
},
8878 { bfd_mach_mips3900
, bfd_mach_mips3000
}
8882 /* Return true if bfd machine EXTENSION is an extension of machine BASE. */
8885 mips_mach_extends_p (unsigned long base
, unsigned long extension
)
8889 for (i
= 0; extension
!= base
&& i
< ARRAY_SIZE (mips_mach_extensions
); i
++)
8890 if (extension
== mips_mach_extensions
[i
].extension
)
8891 extension
= mips_mach_extensions
[i
].base
;
8893 return extension
== base
;
8897 /* Return true if the given ELF header flags describe a 32-bit binary. */
8900 mips_32bit_flags_p (flagword flags
)
8902 return ((flags
& EF_MIPS_32BITMODE
) != 0
8903 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
8904 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
8905 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
8906 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
8907 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
8908 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
);
8912 /* Merge backend specific data from an object file to the output
8913 object file when linking. */
8916 _bfd_mips_elf_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
8921 bfd_boolean null_input_bfd
= TRUE
;
8924 /* Check if we have the same endianess */
8925 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
8927 (*_bfd_error_handler
)
8928 (_("%s: endianness incompatible with that of the selected emulation"),
8929 bfd_archive_filename (ibfd
));
8933 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
8934 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
8937 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
8939 (*_bfd_error_handler
)
8940 (_("%s: ABI is incompatible with that of the selected emulation"),
8941 bfd_archive_filename (ibfd
));
8945 new_flags
= elf_elfheader (ibfd
)->e_flags
;
8946 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_NOREORDER
;
8947 old_flags
= elf_elfheader (obfd
)->e_flags
;
8949 if (! elf_flags_init (obfd
))
8951 elf_flags_init (obfd
) = TRUE
;
8952 elf_elfheader (obfd
)->e_flags
= new_flags
;
8953 elf_elfheader (obfd
)->e_ident
[EI_CLASS
]
8954 = elf_elfheader (ibfd
)->e_ident
[EI_CLASS
];
8956 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
8957 && bfd_get_arch_info (obfd
)->the_default
)
8959 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
8960 bfd_get_mach (ibfd
)))
8967 /* Check flag compatibility. */
8969 new_flags
&= ~EF_MIPS_NOREORDER
;
8970 old_flags
&= ~EF_MIPS_NOREORDER
;
8972 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
8973 doesn't seem to matter. */
8974 new_flags
&= ~EF_MIPS_XGOT
;
8975 old_flags
&= ~EF_MIPS_XGOT
;
8977 /* MIPSpro generates ucode info in n64 objects. Again, we should
8978 just be able to ignore this. */
8979 new_flags
&= ~EF_MIPS_UCODE
;
8980 old_flags
&= ~EF_MIPS_UCODE
;
8982 if (new_flags
== old_flags
)
8985 /* Check to see if the input BFD actually contains any sections.
8986 If not, its flags may not have been initialised either, but it cannot
8987 actually cause any incompatibility. */
8988 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
8990 /* Ignore synthetic sections and empty .text, .data and .bss sections
8991 which are automatically generated by gas. */
8992 if (strcmp (sec
->name
, ".reginfo")
8993 && strcmp (sec
->name
, ".mdebug")
8994 && (sec
->_raw_size
!= 0
8995 || (strcmp (sec
->name
, ".text")
8996 && strcmp (sec
->name
, ".data")
8997 && strcmp (sec
->name
, ".bss"))))
8999 null_input_bfd
= FALSE
;
9008 if (((new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0)
9009 != ((old_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0))
9011 (*_bfd_error_handler
)
9012 (_("%s: warning: linking PIC files with non-PIC files"),
9013 bfd_archive_filename (ibfd
));
9017 if (new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
))
9018 elf_elfheader (obfd
)->e_flags
|= EF_MIPS_CPIC
;
9019 if (! (new_flags
& EF_MIPS_PIC
))
9020 elf_elfheader (obfd
)->e_flags
&= ~EF_MIPS_PIC
;
9022 new_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
9023 old_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
9025 /* Compare the ISAs. */
9026 if (mips_32bit_flags_p (old_flags
) != mips_32bit_flags_p (new_flags
))
9028 (*_bfd_error_handler
)
9029 (_("%s: linking 32-bit code with 64-bit code"),
9030 bfd_archive_filename (ibfd
));
9033 else if (!mips_mach_extends_p (bfd_get_mach (ibfd
), bfd_get_mach (obfd
)))
9035 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
9036 if (mips_mach_extends_p (bfd_get_mach (obfd
), bfd_get_mach (ibfd
)))
9038 /* Copy the architecture info from IBFD to OBFD. Also copy
9039 the 32-bit flag (if set) so that we continue to recognise
9040 OBFD as a 32-bit binary. */
9041 bfd_set_arch_info (obfd
, bfd_get_arch_info (ibfd
));
9042 elf_elfheader (obfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
9043 elf_elfheader (obfd
)->e_flags
9044 |= new_flags
& (EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9046 /* Copy across the ABI flags if OBFD doesn't use them
9047 and if that was what caused us to treat IBFD as 32-bit. */
9048 if ((old_flags
& EF_MIPS_ABI
) == 0
9049 && mips_32bit_flags_p (new_flags
)
9050 && !mips_32bit_flags_p (new_flags
& ~EF_MIPS_ABI
))
9051 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ABI
;
9055 /* The ISAs aren't compatible. */
9056 (*_bfd_error_handler
)
9057 (_("%s: linking %s module with previous %s modules"),
9058 bfd_archive_filename (ibfd
),
9059 bfd_printable_name (ibfd
),
9060 bfd_printable_name (obfd
));
9065 new_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9066 old_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9068 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
9069 does set EI_CLASS differently from any 32-bit ABI. */
9070 if ((new_flags
& EF_MIPS_ABI
) != (old_flags
& EF_MIPS_ABI
)
9071 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
9072 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
9074 /* Only error if both are set (to different values). */
9075 if (((new_flags
& EF_MIPS_ABI
) && (old_flags
& EF_MIPS_ABI
))
9076 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
9077 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
9079 (*_bfd_error_handler
)
9080 (_("%s: ABI mismatch: linking %s module with previous %s modules"),
9081 bfd_archive_filename (ibfd
),
9082 elf_mips_abi_name (ibfd
),
9083 elf_mips_abi_name (obfd
));
9086 new_flags
&= ~EF_MIPS_ABI
;
9087 old_flags
&= ~EF_MIPS_ABI
;
9090 /* For now, allow arbitrary mixing of ASEs (retain the union). */
9091 if ((new_flags
& EF_MIPS_ARCH_ASE
) != (old_flags
& EF_MIPS_ARCH_ASE
))
9093 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ARCH_ASE
;
9095 new_flags
&= ~ EF_MIPS_ARCH_ASE
;
9096 old_flags
&= ~ EF_MIPS_ARCH_ASE
;
9099 /* Warn about any other mismatches */
9100 if (new_flags
!= old_flags
)
9102 (*_bfd_error_handler
)
9103 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
9104 bfd_archive_filename (ibfd
), (unsigned long) new_flags
,
9105 (unsigned long) old_flags
);
9111 bfd_set_error (bfd_error_bad_value
);
9118 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
9121 _bfd_mips_elf_set_private_flags (bfd
*abfd
, flagword flags
)
9123 BFD_ASSERT (!elf_flags_init (abfd
)
9124 || elf_elfheader (abfd
)->e_flags
== flags
);
9126 elf_elfheader (abfd
)->e_flags
= flags
;
9127 elf_flags_init (abfd
) = TRUE
;
9132 _bfd_mips_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
9136 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
9138 /* Print normal ELF private data. */
9139 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
9141 /* xgettext:c-format */
9142 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
9144 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
)
9145 fprintf (file
, _(" [abi=O32]"));
9146 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O64
)
9147 fprintf (file
, _(" [abi=O64]"));
9148 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
)
9149 fprintf (file
, _(" [abi=EABI32]"));
9150 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
9151 fprintf (file
, _(" [abi=EABI64]"));
9152 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
))
9153 fprintf (file
, _(" [abi unknown]"));
9154 else if (ABI_N32_P (abfd
))
9155 fprintf (file
, _(" [abi=N32]"));
9156 else if (ABI_64_P (abfd
))
9157 fprintf (file
, _(" [abi=64]"));
9159 fprintf (file
, _(" [no abi set]"));
9161 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
9162 fprintf (file
, _(" [mips1]"));
9163 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
9164 fprintf (file
, _(" [mips2]"));
9165 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
9166 fprintf (file
, _(" [mips3]"));
9167 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
9168 fprintf (file
, _(" [mips4]"));
9169 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_5
)
9170 fprintf (file
, _(" [mips5]"));
9171 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
)
9172 fprintf (file
, _(" [mips32]"));
9173 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64
)
9174 fprintf (file
, _(" [mips64]"));
9175 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
)
9176 fprintf (file
, _(" [mips32r2]"));
9177 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64R2
)
9178 fprintf (file
, _(" [mips64r2]"));
9180 fprintf (file
, _(" [unknown ISA]"));
9182 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
9183 fprintf (file
, _(" [mdmx]"));
9185 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_M16
)
9186 fprintf (file
, _(" [mips16]"));
9188 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_32BITMODE
)
9189 fprintf (file
, _(" [32bitmode]"));
9191 fprintf (file
, _(" [not 32bitmode]"));
9198 struct bfd_elf_special_section
const _bfd_mips_elf_special_sections
[]=
9200 { ".sdata", 6, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9201 { ".sbss", 5, -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9202 { ".lit4", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9203 { ".lit8", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9204 { ".ucode", 6, 0, SHT_MIPS_UCODE
, 0 },
9205 { ".mdebug", 7, 0, SHT_MIPS_DEBUG
, 0 },
9206 { NULL
, 0, 0, 0, 0 }