1 /* MIPS-specific support for ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003 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 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
374 static void ecoff_swap_rpdr_out
375 PARAMS ((bfd
*, const RPDR
*, struct rpdr_ext
*));
376 static bfd_boolean mips_elf_create_procedure_table
377 PARAMS ((PTR
, bfd
*, struct bfd_link_info
*, asection
*,
378 struct ecoff_debug_info
*));
379 static bfd_boolean mips_elf_check_mips16_stubs
380 PARAMS ((struct mips_elf_link_hash_entry
*, PTR
));
381 static void bfd_mips_elf32_swap_gptab_in
382 PARAMS ((bfd
*, const Elf32_External_gptab
*, Elf32_gptab
*));
383 static void bfd_mips_elf32_swap_gptab_out
384 PARAMS ((bfd
*, const Elf32_gptab
*, Elf32_External_gptab
*));
385 static void bfd_elf32_swap_compact_rel_out
386 PARAMS ((bfd
*, const Elf32_compact_rel
*, Elf32_External_compact_rel
*));
387 static void bfd_elf32_swap_crinfo_out
388 PARAMS ((bfd
*, const Elf32_crinfo
*, Elf32_External_crinfo
*));
389 static int sort_dynamic_relocs
390 PARAMS ((const void *, const void *));
391 static int sort_dynamic_relocs_64
392 PARAMS ((const void *, const void *));
393 static bfd_boolean mips_elf_output_extsym
394 PARAMS ((struct mips_elf_link_hash_entry
*, PTR
));
395 static int gptab_compare
PARAMS ((const void *, const void *));
396 static asection
* mips_elf_rel_dyn_section
PARAMS ((bfd
*, bfd_boolean
));
397 static asection
* mips_elf_got_section
PARAMS ((bfd
*, bfd_boolean
));
398 static struct mips_got_info
*mips_elf_got_info
399 PARAMS ((bfd
*, asection
**));
400 static long mips_elf_get_global_gotsym_index
PARAMS ((bfd
*abfd
));
401 static bfd_vma mips_elf_local_got_index
402 PARAMS ((bfd
*, bfd
*, struct bfd_link_info
*, bfd_vma
));
403 static bfd_vma mips_elf_global_got_index
404 PARAMS ((bfd
*, bfd
*, struct elf_link_hash_entry
*));
405 static bfd_vma mips_elf_got_page
406 PARAMS ((bfd
*, bfd
*, struct bfd_link_info
*, bfd_vma
, bfd_vma
*));
407 static bfd_vma mips_elf_got16_entry
408 PARAMS ((bfd
*, bfd
*, struct bfd_link_info
*, bfd_vma
, bfd_boolean
));
409 static bfd_vma mips_elf_got_offset_from_index
410 PARAMS ((bfd
*, bfd
*, bfd
*, bfd_vma
));
411 static struct mips_got_entry
*mips_elf_create_local_got_entry
412 PARAMS ((bfd
*, bfd
*, struct mips_got_info
*, asection
*, bfd_vma
));
413 static bfd_boolean mips_elf_sort_hash_table
414 PARAMS ((struct bfd_link_info
*, unsigned long));
415 static bfd_boolean mips_elf_sort_hash_table_f
416 PARAMS ((struct mips_elf_link_hash_entry
*, PTR
));
417 static bfd_boolean mips_elf_record_local_got_symbol
418 PARAMS ((bfd
*, long, bfd_vma
, struct mips_got_info
*));
419 static bfd_boolean mips_elf_record_global_got_symbol
420 PARAMS ((struct elf_link_hash_entry
*, bfd
*, struct bfd_link_info
*,
421 struct mips_got_info
*));
422 static const Elf_Internal_Rela
*mips_elf_next_relocation
423 PARAMS ((bfd
*, unsigned int, const Elf_Internal_Rela
*,
424 const Elf_Internal_Rela
*));
425 static bfd_boolean mips_elf_local_relocation_p
426 PARAMS ((bfd
*, const Elf_Internal_Rela
*, asection
**, bfd_boolean
));
427 static bfd_boolean mips_elf_overflow_p
PARAMS ((bfd_vma
, int));
428 static bfd_vma mips_elf_high
PARAMS ((bfd_vma
));
429 static bfd_vma mips_elf_higher
PARAMS ((bfd_vma
));
430 static bfd_vma mips_elf_highest
PARAMS ((bfd_vma
));
431 static bfd_boolean mips_elf_create_compact_rel_section
432 PARAMS ((bfd
*, struct bfd_link_info
*));
433 static bfd_boolean mips_elf_create_got_section
434 PARAMS ((bfd
*, struct bfd_link_info
*, bfd_boolean
));
435 static bfd_reloc_status_type mips_elf_calculate_relocation
436 PARAMS ((bfd
*, bfd
*, asection
*, struct bfd_link_info
*,
437 const Elf_Internal_Rela
*, bfd_vma
, reloc_howto_type
*,
438 Elf_Internal_Sym
*, asection
**, bfd_vma
*, const char **,
439 bfd_boolean
*, bfd_boolean
));
440 static bfd_vma mips_elf_obtain_contents
441 PARAMS ((reloc_howto_type
*, const Elf_Internal_Rela
*, bfd
*, bfd_byte
*));
442 static bfd_boolean mips_elf_perform_relocation
443 PARAMS ((struct bfd_link_info
*, reloc_howto_type
*,
444 const Elf_Internal_Rela
*, bfd_vma
, bfd
*, asection
*, bfd_byte
*,
446 static bfd_boolean mips_elf_stub_section_p
447 PARAMS ((bfd
*, asection
*));
448 static void mips_elf_allocate_dynamic_relocations
449 PARAMS ((bfd
*, unsigned int));
450 static bfd_boolean mips_elf_create_dynamic_relocation
451 PARAMS ((bfd
*, struct bfd_link_info
*, const Elf_Internal_Rela
*,
452 struct mips_elf_link_hash_entry
*, asection
*,
453 bfd_vma
, bfd_vma
*, asection
*));
454 static void mips_set_isa_flags
PARAMS ((bfd
*));
455 static INLINE
char* elf_mips_abi_name
PARAMS ((bfd
*));
456 static void mips_elf_irix6_finish_dynamic_symbol
457 PARAMS ((bfd
*, const char *, Elf_Internal_Sym
*));
458 static bfd_boolean mips_mach_extends_p
PARAMS ((unsigned long, unsigned long));
459 static bfd_boolean mips_32bit_flags_p
PARAMS ((flagword
));
460 static INLINE hashval_t mips_elf_hash_bfd_vma
PARAMS ((bfd_vma
));
461 static hashval_t mips_elf_got_entry_hash
PARAMS ((const PTR
));
462 static int mips_elf_got_entry_eq
PARAMS ((const PTR
, const PTR
));
464 static bfd_boolean mips_elf_multi_got
465 PARAMS ((bfd
*, struct bfd_link_info
*, struct mips_got_info
*,
466 asection
*, bfd_size_type
));
467 static hashval_t mips_elf_multi_got_entry_hash
PARAMS ((const PTR
));
468 static int mips_elf_multi_got_entry_eq
PARAMS ((const PTR
, const PTR
));
469 static hashval_t mips_elf_bfd2got_entry_hash
PARAMS ((const PTR
));
470 static int mips_elf_bfd2got_entry_eq
PARAMS ((const PTR
, const PTR
));
471 static int mips_elf_make_got_per_bfd
PARAMS ((void **, void *));
472 static int mips_elf_merge_gots
PARAMS ((void **, void *));
473 static int mips_elf_set_global_got_offset
PARAMS ((void**, void *));
474 static int mips_elf_resolve_final_got_entry
PARAMS ((void**, void *));
475 static void mips_elf_resolve_final_got_entries
476 PARAMS ((struct mips_got_info
*));
477 static bfd_vma mips_elf_adjust_gp
478 PARAMS ((bfd
*, struct mips_got_info
*, bfd
*));
479 static struct mips_got_info
*mips_elf_got_for_ibfd
480 PARAMS ((struct mips_got_info
*, bfd
*));
482 /* This will be used when we sort the dynamic relocation records. */
483 static bfd
*reldyn_sorting_bfd
;
485 /* Nonzero if ABFD is using the N32 ABI. */
487 #define ABI_N32_P(abfd) \
488 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
490 /* Nonzero if ABFD is using the N64 ABI. */
491 #define ABI_64_P(abfd) \
492 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
494 /* Nonzero if ABFD is using NewABI conventions. */
495 #define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
497 /* The IRIX compatibility level we are striving for. */
498 #define IRIX_COMPAT(abfd) \
499 (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
501 /* Whether we are trying to be compatible with IRIX at all. */
502 #define SGI_COMPAT(abfd) \
503 (IRIX_COMPAT (abfd) != ict_none)
505 /* The name of the options section. */
506 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
507 (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
509 /* The name of the stub section. */
510 #define MIPS_ELF_STUB_SECTION_NAME(abfd) \
511 (NEWABI_P (abfd) ? ".MIPS.stubs" : ".stub")
513 /* The size of an external REL relocation. */
514 #define MIPS_ELF_REL_SIZE(abfd) \
515 (get_elf_backend_data (abfd)->s->sizeof_rel)
517 /* The size of an external dynamic table entry. */
518 #define MIPS_ELF_DYN_SIZE(abfd) \
519 (get_elf_backend_data (abfd)->s->sizeof_dyn)
521 /* The size of a GOT entry. */
522 #define MIPS_ELF_GOT_SIZE(abfd) \
523 (get_elf_backend_data (abfd)->s->arch_size / 8)
525 /* The size of a symbol-table entry. */
526 #define MIPS_ELF_SYM_SIZE(abfd) \
527 (get_elf_backend_data (abfd)->s->sizeof_sym)
529 /* The default alignment for sections, as a power of two. */
530 #define MIPS_ELF_LOG_FILE_ALIGN(abfd) \
531 (get_elf_backend_data (abfd)->s->log_file_align)
533 /* Get word-sized data. */
534 #define MIPS_ELF_GET_WORD(abfd, ptr) \
535 (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
537 /* Put out word-sized data. */
538 #define MIPS_ELF_PUT_WORD(abfd, val, ptr) \
540 ? bfd_put_64 (abfd, val, ptr) \
541 : bfd_put_32 (abfd, val, ptr))
543 /* Add a dynamic symbol table-entry. */
545 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
546 (ABI_64_P (elf_hash_table (info)->dynobj) \
547 ? bfd_elf64_add_dynamic_entry (info, (bfd_vma) tag, (bfd_vma) val) \
548 : bfd_elf32_add_dynamic_entry (info, (bfd_vma) tag, (bfd_vma) val))
550 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
551 (ABI_64_P (elf_hash_table (info)->dynobj) \
552 ? (abort (), FALSE) \
553 : bfd_elf32_add_dynamic_entry (info, (bfd_vma) tag, (bfd_vma) val))
556 #define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela) \
557 (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela))
559 /* Determine whether the internal relocation of index REL_IDX is REL
560 (zero) or RELA (non-zero). The assumption is that, if there are
561 two relocation sections for this section, one of them is REL and
562 the other is RELA. If the index of the relocation we're testing is
563 in range for the first relocation section, check that the external
564 relocation size is that for RELA. It is also assumed that, if
565 rel_idx is not in range for the first section, and this first
566 section contains REL relocs, then the relocation is in the second
567 section, that is RELA. */
568 #define MIPS_RELOC_RELA_P(abfd, sec, rel_idx) \
569 ((NUM_SHDR_ENTRIES (&elf_section_data (sec)->rel_hdr) \
570 * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel \
571 > (bfd_vma)(rel_idx)) \
572 == (elf_section_data (sec)->rel_hdr.sh_entsize \
573 == (ABI_64_P (abfd) ? sizeof (Elf64_External_Rela) \
574 : sizeof (Elf32_External_Rela))))
576 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
577 from smaller values. Start with zero, widen, *then* decrement. */
578 #define MINUS_ONE (((bfd_vma)0) - 1)
580 /* The number of local .got entries we reserve. */
581 #define MIPS_RESERVED_GOTNO (2)
583 /* The offset of $gp from the beginning of the .got section. */
584 #define ELF_MIPS_GP_OFFSET(abfd) (0x7ff0)
586 /* The maximum size of the GOT for it to be addressable using 16-bit
588 #define MIPS_ELF_GOT_MAX_SIZE(abfd) (ELF_MIPS_GP_OFFSET(abfd) + 0x7fff)
590 /* Instructions which appear in a stub. */
591 #define STUB_LW(abfd) \
593 ? 0xdf998010 /* ld t9,0x8010(gp) */ \
594 : 0x8f998010)) /* lw t9,0x8010(gp) */
595 #define STUB_MOVE(abfd) \
597 ? 0x03e0782d /* daddu t7,ra */ \
598 : 0x03e07821)) /* addu t7,ra */
599 #define STUB_JALR 0x0320f809 /* jalr t9,ra */
600 #define STUB_LI16(abfd) \
602 ? 0x64180000 /* daddiu t8,zero,0 */ \
603 : 0x24180000)) /* addiu t8,zero,0 */
604 #define MIPS_FUNCTION_STUB_SIZE (16)
606 /* The name of the dynamic interpreter. This is put in the .interp
609 #define ELF_DYNAMIC_INTERPRETER(abfd) \
610 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
611 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
612 : "/usr/lib/libc.so.1")
615 #define MNAME(bfd,pre,pos) \
616 (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
617 #define ELF_R_SYM(bfd, i) \
618 (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
619 #define ELF_R_TYPE(bfd, i) \
620 (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
621 #define ELF_R_INFO(bfd, s, t) \
622 (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
624 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
625 #define ELF_R_SYM(bfd, i) \
627 #define ELF_R_TYPE(bfd, i) \
629 #define ELF_R_INFO(bfd, s, t) \
630 (ELF32_R_INFO (s, t))
633 /* The mips16 compiler uses a couple of special sections to handle
634 floating point arguments.
636 Section names that look like .mips16.fn.FNNAME contain stubs that
637 copy floating point arguments from the fp regs to the gp regs and
638 then jump to FNNAME. If any 32 bit function calls FNNAME, the
639 call should be redirected to the stub instead. If no 32 bit
640 function calls FNNAME, the stub should be discarded. We need to
641 consider any reference to the function, not just a call, because
642 if the address of the function is taken we will need the stub,
643 since the address might be passed to a 32 bit function.
645 Section names that look like .mips16.call.FNNAME contain stubs
646 that copy floating point arguments from the gp regs to the fp
647 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
648 then any 16 bit function that calls FNNAME should be redirected
649 to the stub instead. If FNNAME is not a 32 bit function, the
650 stub should be discarded.
652 .mips16.call.fp.FNNAME sections are similar, but contain stubs
653 which call FNNAME and then copy the return value from the fp regs
654 to the gp regs. These stubs store the return value in $18 while
655 calling FNNAME; any function which might call one of these stubs
656 must arrange to save $18 around the call. (This case is not
657 needed for 32 bit functions that call 16 bit functions, because
658 16 bit functions always return floating point values in both
661 Note that in all cases FNNAME might be defined statically.
662 Therefore, FNNAME is not used literally. Instead, the relocation
663 information will indicate which symbol the section is for.
665 We record any stubs that we find in the symbol table. */
667 #define FN_STUB ".mips16.fn."
668 #define CALL_STUB ".mips16.call."
669 #define CALL_FP_STUB ".mips16.call.fp."
671 /* Look up an entry in a MIPS ELF linker hash table. */
673 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
674 ((struct mips_elf_link_hash_entry *) \
675 elf_link_hash_lookup (&(table)->root, (string), (create), \
678 /* Traverse a MIPS ELF linker hash table. */
680 #define mips_elf_link_hash_traverse(table, func, info) \
681 (elf_link_hash_traverse \
683 (bfd_boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
686 /* Get the MIPS ELF linker hash table from a link_info structure. */
688 #define mips_elf_hash_table(p) \
689 ((struct mips_elf_link_hash_table *) ((p)->hash))
691 /* Create an entry in a MIPS ELF linker hash table. */
693 static struct bfd_hash_entry
*
694 mips_elf_link_hash_newfunc (entry
, table
, string
)
695 struct bfd_hash_entry
*entry
;
696 struct bfd_hash_table
*table
;
699 struct mips_elf_link_hash_entry
*ret
=
700 (struct mips_elf_link_hash_entry
*) entry
;
702 /* Allocate the structure if it has not already been allocated by a
704 if (ret
== (struct mips_elf_link_hash_entry
*) NULL
)
705 ret
= ((struct mips_elf_link_hash_entry
*)
706 bfd_hash_allocate (table
,
707 sizeof (struct mips_elf_link_hash_entry
)));
708 if (ret
== (struct mips_elf_link_hash_entry
*) NULL
)
709 return (struct bfd_hash_entry
*) ret
;
711 /* Call the allocation method of the superclass. */
712 ret
= ((struct mips_elf_link_hash_entry
*)
713 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
715 if (ret
!= (struct mips_elf_link_hash_entry
*) NULL
)
717 /* Set local fields. */
718 memset (&ret
->esym
, 0, sizeof (EXTR
));
719 /* We use -2 as a marker to indicate that the information has
720 not been set. -1 means there is no associated ifd. */
722 ret
->possibly_dynamic_relocs
= 0;
723 ret
->readonly_reloc
= FALSE
;
724 ret
->no_fn_stub
= FALSE
;
726 ret
->need_fn_stub
= FALSE
;
727 ret
->call_stub
= NULL
;
728 ret
->call_fp_stub
= NULL
;
729 ret
->forced_local
= FALSE
;
732 return (struct bfd_hash_entry
*) ret
;
736 _bfd_mips_elf_new_section_hook (abfd
, sec
)
740 struct _mips_elf_section_data
*sdata
;
741 bfd_size_type amt
= sizeof (*sdata
);
743 sdata
= (struct _mips_elf_section_data
*) bfd_zalloc (abfd
, amt
);
746 sec
->used_by_bfd
= (PTR
) sdata
;
748 return _bfd_elf_new_section_hook (abfd
, sec
);
751 /* Read ECOFF debugging information from a .mdebug section into a
752 ecoff_debug_info structure. */
755 _bfd_mips_elf_read_ecoff_info (abfd
, section
, debug
)
758 struct ecoff_debug_info
*debug
;
761 const struct ecoff_debug_swap
*swap
;
762 char *ext_hdr
= NULL
;
764 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
765 memset (debug
, 0, sizeof (*debug
));
767 ext_hdr
= (char *) bfd_malloc (swap
->external_hdr_size
);
768 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
771 if (! bfd_get_section_contents (abfd
, section
, ext_hdr
, (file_ptr
) 0,
772 swap
->external_hdr_size
))
775 symhdr
= &debug
->symbolic_header
;
776 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
778 /* The symbolic header contains absolute file offsets and sizes to
780 #define READ(ptr, offset, count, size, type) \
781 if (symhdr->count == 0) \
785 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
786 debug->ptr = (type) bfd_malloc (amt); \
787 if (debug->ptr == NULL) \
789 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
790 || bfd_bread (debug->ptr, amt, abfd) != amt) \
794 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
795 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, PTR
);
796 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, PTR
);
797 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, PTR
);
798 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, PTR
);
799 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
801 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
802 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
803 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, PTR
);
804 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, PTR
);
805 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, PTR
);
809 debug
->adjust
= NULL
;
816 if (debug
->line
!= NULL
)
818 if (debug
->external_dnr
!= NULL
)
819 free (debug
->external_dnr
);
820 if (debug
->external_pdr
!= NULL
)
821 free (debug
->external_pdr
);
822 if (debug
->external_sym
!= NULL
)
823 free (debug
->external_sym
);
824 if (debug
->external_opt
!= NULL
)
825 free (debug
->external_opt
);
826 if (debug
->external_aux
!= NULL
)
827 free (debug
->external_aux
);
828 if (debug
->ss
!= NULL
)
830 if (debug
->ssext
!= NULL
)
832 if (debug
->external_fdr
!= NULL
)
833 free (debug
->external_fdr
);
834 if (debug
->external_rfd
!= NULL
)
835 free (debug
->external_rfd
);
836 if (debug
->external_ext
!= NULL
)
837 free (debug
->external_ext
);
841 /* Swap RPDR (runtime procedure table entry) for output. */
844 ecoff_swap_rpdr_out (abfd
, in
, ex
)
849 H_PUT_S32 (abfd
, in
->adr
, ex
->p_adr
);
850 H_PUT_32 (abfd
, in
->regmask
, ex
->p_regmask
);
851 H_PUT_32 (abfd
, in
->regoffset
, ex
->p_regoffset
);
852 H_PUT_32 (abfd
, in
->fregmask
, ex
->p_fregmask
);
853 H_PUT_32 (abfd
, in
->fregoffset
, ex
->p_fregoffset
);
854 H_PUT_32 (abfd
, in
->frameoffset
, ex
->p_frameoffset
);
856 H_PUT_16 (abfd
, in
->framereg
, ex
->p_framereg
);
857 H_PUT_16 (abfd
, in
->pcreg
, ex
->p_pcreg
);
859 H_PUT_32 (abfd
, in
->irpss
, ex
->p_irpss
);
861 H_PUT_S32 (abfd
, in
->exception_info
, ex
->p_exception_info
);
865 /* Create a runtime procedure table from the .mdebug section. */
868 mips_elf_create_procedure_table (handle
, abfd
, info
, s
, debug
)
871 struct bfd_link_info
*info
;
873 struct ecoff_debug_info
*debug
;
875 const struct ecoff_debug_swap
*swap
;
876 HDRR
*hdr
= &debug
->symbolic_header
;
878 struct rpdr_ext
*erp
;
880 struct pdr_ext
*epdr
;
881 struct sym_ext
*esym
;
886 unsigned long sindex
;
890 const char *no_name_func
= _("static procedure (no name)");
898 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
900 sindex
= strlen (no_name_func
) + 1;
904 size
= swap
->external_pdr_size
;
906 epdr
= (struct pdr_ext
*) bfd_malloc (size
* count
);
910 if (! _bfd_ecoff_get_accumulated_pdr (handle
, (PTR
) epdr
))
913 size
= sizeof (RPDR
);
914 rp
= rpdr
= (RPDR
*) bfd_malloc (size
* count
);
918 size
= sizeof (char *);
919 sv
= (char **) bfd_malloc (size
* count
);
923 count
= hdr
->isymMax
;
924 size
= swap
->external_sym_size
;
925 esym
= (struct sym_ext
*) bfd_malloc (size
* count
);
929 if (! _bfd_ecoff_get_accumulated_sym (handle
, (PTR
) esym
))
933 ss
= (char *) bfd_malloc (count
);
936 if (! _bfd_ecoff_get_accumulated_ss (handle
, (PTR
) ss
))
940 for (i
= 0; i
< (unsigned long) count
; i
++, rp
++)
942 (*swap
->swap_pdr_in
) (abfd
, (PTR
) (epdr
+ i
), &pdr
);
943 (*swap
->swap_sym_in
) (abfd
, (PTR
) &esym
[pdr
.isym
], &sym
);
945 rp
->regmask
= pdr
.regmask
;
946 rp
->regoffset
= pdr
.regoffset
;
947 rp
->fregmask
= pdr
.fregmask
;
948 rp
->fregoffset
= pdr
.fregoffset
;
949 rp
->frameoffset
= pdr
.frameoffset
;
950 rp
->framereg
= pdr
.framereg
;
951 rp
->pcreg
= pdr
.pcreg
;
953 sv
[i
] = ss
+ sym
.iss
;
954 sindex
+= strlen (sv
[i
]) + 1;
958 size
= sizeof (struct rpdr_ext
) * (count
+ 2) + sindex
;
959 size
= BFD_ALIGN (size
, 16);
960 rtproc
= (PTR
) bfd_alloc (abfd
, size
);
963 mips_elf_hash_table (info
)->procedure_count
= 0;
967 mips_elf_hash_table (info
)->procedure_count
= count
+ 2;
969 erp
= (struct rpdr_ext
*) rtproc
;
970 memset (erp
, 0, sizeof (struct rpdr_ext
));
972 str
= (char *) rtproc
+ sizeof (struct rpdr_ext
) * (count
+ 2);
973 strcpy (str
, no_name_func
);
974 str
+= strlen (no_name_func
) + 1;
975 for (i
= 0; i
< count
; i
++)
977 ecoff_swap_rpdr_out (abfd
, rpdr
+ i
, erp
+ i
);
979 str
+= strlen (sv
[i
]) + 1;
981 H_PUT_S32 (abfd
, -1, (erp
+ count
)->p_adr
);
983 /* Set the size and contents of .rtproc section. */
985 s
->contents
= (bfd_byte
*) rtproc
;
987 /* Skip this section later on (I don't think this currently
988 matters, but someday it might). */
989 s
->link_order_head
= (struct bfd_link_order
*) NULL
;
1018 /* Check the mips16 stubs for a particular symbol, and see if we can
1022 mips_elf_check_mips16_stubs (h
, data
)
1023 struct mips_elf_link_hash_entry
*h
;
1024 PTR data ATTRIBUTE_UNUSED
;
1026 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1027 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1029 if (h
->fn_stub
!= NULL
1030 && ! h
->need_fn_stub
)
1032 /* We don't need the fn_stub; the only references to this symbol
1033 are 16 bit calls. Clobber the size to 0 to prevent it from
1034 being included in the link. */
1035 h
->fn_stub
->_raw_size
= 0;
1036 h
->fn_stub
->_cooked_size
= 0;
1037 h
->fn_stub
->flags
&= ~SEC_RELOC
;
1038 h
->fn_stub
->reloc_count
= 0;
1039 h
->fn_stub
->flags
|= SEC_EXCLUDE
;
1042 if (h
->call_stub
!= NULL
1043 && h
->root
.other
== STO_MIPS16
)
1045 /* We don't need the call_stub; this is a 16 bit function, so
1046 calls from other 16 bit functions are OK. Clobber the size
1047 to 0 to prevent it from being included in the link. */
1048 h
->call_stub
->_raw_size
= 0;
1049 h
->call_stub
->_cooked_size
= 0;
1050 h
->call_stub
->flags
&= ~SEC_RELOC
;
1051 h
->call_stub
->reloc_count
= 0;
1052 h
->call_stub
->flags
|= SEC_EXCLUDE
;
1055 if (h
->call_fp_stub
!= NULL
1056 && h
->root
.other
== STO_MIPS16
)
1058 /* We don't need the call_stub; this is a 16 bit function, so
1059 calls from other 16 bit functions are OK. Clobber the size
1060 to 0 to prevent it from being included in the link. */
1061 h
->call_fp_stub
->_raw_size
= 0;
1062 h
->call_fp_stub
->_cooked_size
= 0;
1063 h
->call_fp_stub
->flags
&= ~SEC_RELOC
;
1064 h
->call_fp_stub
->reloc_count
= 0;
1065 h
->call_fp_stub
->flags
|= SEC_EXCLUDE
;
1071 bfd_reloc_status_type
1072 _bfd_mips_elf_gprel16_with_gp (abfd
, symbol
, reloc_entry
, input_section
,
1073 relocatable
, data
, gp
)
1076 arelent
*reloc_entry
;
1077 asection
*input_section
;
1078 bfd_boolean relocatable
;
1083 unsigned long insn
= 0;
1086 if (bfd_is_com_section (symbol
->section
))
1089 relocation
= symbol
->value
;
1091 relocation
+= symbol
->section
->output_section
->vma
;
1092 relocation
+= symbol
->section
->output_offset
;
1094 if (reloc_entry
->address
> input_section
->_cooked_size
)
1095 return bfd_reloc_outofrange
;
1097 /* Set val to the offset into the section or symbol. */
1098 val
= reloc_entry
->addend
;
1100 if (reloc_entry
->howto
->partial_inplace
)
1102 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1103 val
+= insn
& 0xffff;
1106 _bfd_mips_elf_sign_extend(val
, 16);
1108 /* Adjust val for the final section location and GP value. If we
1109 are producing relocatable output, we don't want to do this for
1110 an external symbol. */
1112 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1113 val
+= relocation
- gp
;
1115 if (reloc_entry
->howto
->partial_inplace
)
1117 insn
= (insn
& ~0xffff) | (val
& 0xffff);
1118 bfd_put_32 (abfd
, (bfd_vma
) insn
,
1119 (bfd_byte
*) data
+ reloc_entry
->address
);
1122 reloc_entry
->addend
= val
;
1125 reloc_entry
->address
+= input_section
->output_offset
;
1126 else if (((val
& ~0xffff) != ~0xffff) && ((val
& ~0xffff) != 0))
1127 return bfd_reloc_overflow
;
1129 return bfd_reloc_ok
;
1132 /* Swap an entry in a .gptab section. Note that these routines rely
1133 on the equivalence of the two elements of the union. */
1136 bfd_mips_elf32_swap_gptab_in (abfd
, ex
, in
)
1138 const Elf32_External_gptab
*ex
;
1141 in
->gt_entry
.gt_g_value
= H_GET_32 (abfd
, ex
->gt_entry
.gt_g_value
);
1142 in
->gt_entry
.gt_bytes
= H_GET_32 (abfd
, ex
->gt_entry
.gt_bytes
);
1146 bfd_mips_elf32_swap_gptab_out (abfd
, in
, ex
)
1148 const Elf32_gptab
*in
;
1149 Elf32_External_gptab
*ex
;
1151 H_PUT_32 (abfd
, in
->gt_entry
.gt_g_value
, ex
->gt_entry
.gt_g_value
);
1152 H_PUT_32 (abfd
, in
->gt_entry
.gt_bytes
, ex
->gt_entry
.gt_bytes
);
1156 bfd_elf32_swap_compact_rel_out (abfd
, in
, ex
)
1158 const Elf32_compact_rel
*in
;
1159 Elf32_External_compact_rel
*ex
;
1161 H_PUT_32 (abfd
, in
->id1
, ex
->id1
);
1162 H_PUT_32 (abfd
, in
->num
, ex
->num
);
1163 H_PUT_32 (abfd
, in
->id2
, ex
->id2
);
1164 H_PUT_32 (abfd
, in
->offset
, ex
->offset
);
1165 H_PUT_32 (abfd
, in
->reserved0
, ex
->reserved0
);
1166 H_PUT_32 (abfd
, in
->reserved1
, ex
->reserved1
);
1170 bfd_elf32_swap_crinfo_out (abfd
, in
, ex
)
1172 const Elf32_crinfo
*in
;
1173 Elf32_External_crinfo
*ex
;
1177 l
= (((in
->ctype
& CRINFO_CTYPE
) << CRINFO_CTYPE_SH
)
1178 | ((in
->rtype
& CRINFO_RTYPE
) << CRINFO_RTYPE_SH
)
1179 | ((in
->dist2to
& CRINFO_DIST2TO
) << CRINFO_DIST2TO_SH
)
1180 | ((in
->relvaddr
& CRINFO_RELVADDR
) << CRINFO_RELVADDR_SH
));
1181 H_PUT_32 (abfd
, l
, ex
->info
);
1182 H_PUT_32 (abfd
, in
->konst
, ex
->konst
);
1183 H_PUT_32 (abfd
, in
->vaddr
, ex
->vaddr
);
1186 /* A .reginfo section holds a single Elf32_RegInfo structure. These
1187 routines swap this structure in and out. They are used outside of
1188 BFD, so they are globally visible. */
1191 bfd_mips_elf32_swap_reginfo_in (abfd
, ex
, in
)
1193 const Elf32_External_RegInfo
*ex
;
1196 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1197 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1198 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1199 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1200 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1201 in
->ri_gp_value
= H_GET_32 (abfd
, ex
->ri_gp_value
);
1205 bfd_mips_elf32_swap_reginfo_out (abfd
, in
, ex
)
1207 const Elf32_RegInfo
*in
;
1208 Elf32_External_RegInfo
*ex
;
1210 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1211 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1212 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1213 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1214 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1215 H_PUT_32 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1218 /* In the 64 bit ABI, the .MIPS.options section holds register
1219 information in an Elf64_Reginfo structure. These routines swap
1220 them in and out. They are globally visible because they are used
1221 outside of BFD. These routines are here so that gas can call them
1222 without worrying about whether the 64 bit ABI has been included. */
1225 bfd_mips_elf64_swap_reginfo_in (abfd
, ex
, in
)
1227 const Elf64_External_RegInfo
*ex
;
1228 Elf64_Internal_RegInfo
*in
;
1230 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1231 in
->ri_pad
= H_GET_32 (abfd
, ex
->ri_pad
);
1232 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1233 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1234 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1235 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1236 in
->ri_gp_value
= H_GET_64 (abfd
, ex
->ri_gp_value
);
1240 bfd_mips_elf64_swap_reginfo_out (abfd
, in
, ex
)
1242 const Elf64_Internal_RegInfo
*in
;
1243 Elf64_External_RegInfo
*ex
;
1245 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1246 H_PUT_32 (abfd
, in
->ri_pad
, ex
->ri_pad
);
1247 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1248 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1249 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1250 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1251 H_PUT_64 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1254 /* Swap in an options header. */
1257 bfd_mips_elf_swap_options_in (abfd
, ex
, in
)
1259 const Elf_External_Options
*ex
;
1260 Elf_Internal_Options
*in
;
1262 in
->kind
= H_GET_8 (abfd
, ex
->kind
);
1263 in
->size
= H_GET_8 (abfd
, ex
->size
);
1264 in
->section
= H_GET_16 (abfd
, ex
->section
);
1265 in
->info
= H_GET_32 (abfd
, ex
->info
);
1268 /* Swap out an options header. */
1271 bfd_mips_elf_swap_options_out (abfd
, in
, ex
)
1273 const Elf_Internal_Options
*in
;
1274 Elf_External_Options
*ex
;
1276 H_PUT_8 (abfd
, in
->kind
, ex
->kind
);
1277 H_PUT_8 (abfd
, in
->size
, ex
->size
);
1278 H_PUT_16 (abfd
, in
->section
, ex
->section
);
1279 H_PUT_32 (abfd
, in
->info
, ex
->info
);
1282 /* This function is called via qsort() to sort the dynamic relocation
1283 entries by increasing r_symndx value. */
1286 sort_dynamic_relocs (arg1
, arg2
)
1290 Elf_Internal_Rela int_reloc1
;
1291 Elf_Internal_Rela int_reloc2
;
1293 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg1
, &int_reloc1
);
1294 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg2
, &int_reloc2
);
1296 return ELF32_R_SYM (int_reloc1
.r_info
) - ELF32_R_SYM (int_reloc2
.r_info
);
1299 /* Like sort_dynamic_relocs, but used for elf64 relocations. */
1302 sort_dynamic_relocs_64 (arg1
, arg2
)
1306 Elf_Internal_Rela int_reloc1
[3];
1307 Elf_Internal_Rela int_reloc2
[3];
1309 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1310 (reldyn_sorting_bfd
, arg1
, int_reloc1
);
1311 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1312 (reldyn_sorting_bfd
, arg2
, int_reloc2
);
1314 return (ELF64_R_SYM (int_reloc1
[0].r_info
)
1315 - ELF64_R_SYM (int_reloc2
[0].r_info
));
1319 /* This routine is used to write out ECOFF debugging external symbol
1320 information. It is called via mips_elf_link_hash_traverse. The
1321 ECOFF external symbol information must match the ELF external
1322 symbol information. Unfortunately, at this point we don't know
1323 whether a symbol is required by reloc information, so the two
1324 tables may wind up being different. We must sort out the external
1325 symbol information before we can set the final size of the .mdebug
1326 section, and we must set the size of the .mdebug section before we
1327 can relocate any sections, and we can't know which symbols are
1328 required by relocation until we relocate the sections.
1329 Fortunately, it is relatively unlikely that any symbol will be
1330 stripped but required by a reloc. In particular, it can not happen
1331 when generating a final executable. */
1334 mips_elf_output_extsym (h
, data
)
1335 struct mips_elf_link_hash_entry
*h
;
1338 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
1340 asection
*sec
, *output_section
;
1342 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1343 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1345 if (h
->root
.indx
== -2)
1347 else if (((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1348 || (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
1349 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1350 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
1352 else if (einfo
->info
->strip
== strip_all
1353 || (einfo
->info
->strip
== strip_some
1354 && bfd_hash_lookup (einfo
->info
->keep_hash
,
1355 h
->root
.root
.root
.string
,
1356 FALSE
, FALSE
) == NULL
))
1364 if (h
->esym
.ifd
== -2)
1367 h
->esym
.cobol_main
= 0;
1368 h
->esym
.weakext
= 0;
1369 h
->esym
.reserved
= 0;
1370 h
->esym
.ifd
= ifdNil
;
1371 h
->esym
.asym
.value
= 0;
1372 h
->esym
.asym
.st
= stGlobal
;
1374 if (h
->root
.root
.type
== bfd_link_hash_undefined
1375 || h
->root
.root
.type
== bfd_link_hash_undefweak
)
1379 /* Use undefined class. Also, set class and type for some
1381 name
= h
->root
.root
.root
.string
;
1382 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
1383 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
1385 h
->esym
.asym
.sc
= scData
;
1386 h
->esym
.asym
.st
= stLabel
;
1387 h
->esym
.asym
.value
= 0;
1389 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
1391 h
->esym
.asym
.sc
= scAbs
;
1392 h
->esym
.asym
.st
= stLabel
;
1393 h
->esym
.asym
.value
=
1394 mips_elf_hash_table (einfo
->info
)->procedure_count
;
1396 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (einfo
->abfd
))
1398 h
->esym
.asym
.sc
= scAbs
;
1399 h
->esym
.asym
.st
= stLabel
;
1400 h
->esym
.asym
.value
= elf_gp (einfo
->abfd
);
1403 h
->esym
.asym
.sc
= scUndefined
;
1405 else if (h
->root
.root
.type
!= bfd_link_hash_defined
1406 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
1407 h
->esym
.asym
.sc
= scAbs
;
1412 sec
= h
->root
.root
.u
.def
.section
;
1413 output_section
= sec
->output_section
;
1415 /* When making a shared library and symbol h is the one from
1416 the another shared library, OUTPUT_SECTION may be null. */
1417 if (output_section
== NULL
)
1418 h
->esym
.asym
.sc
= scUndefined
;
1421 name
= bfd_section_name (output_section
->owner
, output_section
);
1423 if (strcmp (name
, ".text") == 0)
1424 h
->esym
.asym
.sc
= scText
;
1425 else if (strcmp (name
, ".data") == 0)
1426 h
->esym
.asym
.sc
= scData
;
1427 else if (strcmp (name
, ".sdata") == 0)
1428 h
->esym
.asym
.sc
= scSData
;
1429 else if (strcmp (name
, ".rodata") == 0
1430 || strcmp (name
, ".rdata") == 0)
1431 h
->esym
.asym
.sc
= scRData
;
1432 else if (strcmp (name
, ".bss") == 0)
1433 h
->esym
.asym
.sc
= scBss
;
1434 else if (strcmp (name
, ".sbss") == 0)
1435 h
->esym
.asym
.sc
= scSBss
;
1436 else if (strcmp (name
, ".init") == 0)
1437 h
->esym
.asym
.sc
= scInit
;
1438 else if (strcmp (name
, ".fini") == 0)
1439 h
->esym
.asym
.sc
= scFini
;
1441 h
->esym
.asym
.sc
= scAbs
;
1445 h
->esym
.asym
.reserved
= 0;
1446 h
->esym
.asym
.index
= indexNil
;
1449 if (h
->root
.root
.type
== bfd_link_hash_common
)
1450 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
1451 else if (h
->root
.root
.type
== bfd_link_hash_defined
1452 || h
->root
.root
.type
== bfd_link_hash_defweak
)
1454 if (h
->esym
.asym
.sc
== scCommon
)
1455 h
->esym
.asym
.sc
= scBss
;
1456 else if (h
->esym
.asym
.sc
== scSCommon
)
1457 h
->esym
.asym
.sc
= scSBss
;
1459 sec
= h
->root
.root
.u
.def
.section
;
1460 output_section
= sec
->output_section
;
1461 if (output_section
!= NULL
)
1462 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
1463 + sec
->output_offset
1464 + output_section
->vma
);
1466 h
->esym
.asym
.value
= 0;
1468 else if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
1470 struct mips_elf_link_hash_entry
*hd
= h
;
1471 bfd_boolean no_fn_stub
= h
->no_fn_stub
;
1473 while (hd
->root
.root
.type
== bfd_link_hash_indirect
)
1475 hd
= (struct mips_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
1476 no_fn_stub
= no_fn_stub
|| hd
->no_fn_stub
;
1481 /* Set type and value for a symbol with a function stub. */
1482 h
->esym
.asym
.st
= stProc
;
1483 sec
= hd
->root
.root
.u
.def
.section
;
1485 h
->esym
.asym
.value
= 0;
1488 output_section
= sec
->output_section
;
1489 if (output_section
!= NULL
)
1490 h
->esym
.asym
.value
= (hd
->root
.plt
.offset
1491 + sec
->output_offset
1492 + output_section
->vma
);
1494 h
->esym
.asym
.value
= 0;
1502 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
1503 h
->root
.root
.root
.string
,
1506 einfo
->failed
= TRUE
;
1513 /* A comparison routine used to sort .gptab entries. */
1516 gptab_compare (p1
, p2
)
1520 const Elf32_gptab
*a1
= (const Elf32_gptab
*) p1
;
1521 const Elf32_gptab
*a2
= (const Elf32_gptab
*) p2
;
1523 return a1
->gt_entry
.gt_g_value
- a2
->gt_entry
.gt_g_value
;
1526 /* Functions to manage the got entry hash table. */
1528 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
1531 static INLINE hashval_t
1532 mips_elf_hash_bfd_vma (addr
)
1536 return addr
+ (addr
>> 32);
1542 /* got_entries only match if they're identical, except for gotidx, so
1543 use all fields to compute the hash, and compare the appropriate
1547 mips_elf_got_entry_hash (entry_
)
1550 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
1552 return entry
->symndx
1553 + (! entry
->abfd
? mips_elf_hash_bfd_vma (entry
->d
.address
)
1555 + (entry
->symndx
>= 0 ? mips_elf_hash_bfd_vma (entry
->d
.addend
)
1556 : entry
->d
.h
->root
.root
.root
.hash
));
1560 mips_elf_got_entry_eq (entry1
, entry2
)
1564 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
1565 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
1567 return e1
->abfd
== e2
->abfd
&& e1
->symndx
== e2
->symndx
1568 && (! e1
->abfd
? e1
->d
.address
== e2
->d
.address
1569 : e1
->symndx
>= 0 ? e1
->d
.addend
== e2
->d
.addend
1570 : e1
->d
.h
== e2
->d
.h
);
1573 /* multi_got_entries are still a match in the case of global objects,
1574 even if the input bfd in which they're referenced differs, so the
1575 hash computation and compare functions are adjusted
1579 mips_elf_multi_got_entry_hash (entry_
)
1582 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
1584 return entry
->symndx
1586 ? mips_elf_hash_bfd_vma (entry
->d
.address
)
1587 : entry
->symndx
>= 0
1589 + mips_elf_hash_bfd_vma (entry
->d
.addend
))
1590 : entry
->d
.h
->root
.root
.root
.hash
);
1594 mips_elf_multi_got_entry_eq (entry1
, entry2
)
1598 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
1599 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
1601 return e1
->symndx
== e2
->symndx
1602 && (e1
->symndx
>= 0 ? e1
->abfd
== e2
->abfd
&& e1
->d
.addend
== e2
->d
.addend
1603 : e1
->abfd
== NULL
|| e2
->abfd
== NULL
1604 ? e1
->abfd
== e2
->abfd
&& e1
->d
.address
== e2
->d
.address
1605 : e1
->d
.h
== e2
->d
.h
);
1608 /* Returns the dynamic relocation section for DYNOBJ. */
1611 mips_elf_rel_dyn_section (dynobj
, create_p
)
1613 bfd_boolean create_p
;
1615 static const char dname
[] = ".rel.dyn";
1618 sreloc
= bfd_get_section_by_name (dynobj
, dname
);
1619 if (sreloc
== NULL
&& create_p
)
1621 sreloc
= bfd_make_section (dynobj
, dname
);
1623 || ! bfd_set_section_flags (dynobj
, sreloc
,
1628 | SEC_LINKER_CREATED
1630 || ! bfd_set_section_alignment (dynobj
, sreloc
,
1631 MIPS_ELF_LOG_FILE_ALIGN (dynobj
)))
1637 /* Returns the GOT section for ABFD. */
1640 mips_elf_got_section (abfd
, maybe_excluded
)
1642 bfd_boolean maybe_excluded
;
1644 asection
*sgot
= bfd_get_section_by_name (abfd
, ".got");
1646 || (! maybe_excluded
&& (sgot
->flags
& SEC_EXCLUDE
) != 0))
1651 /* Returns the GOT information associated with the link indicated by
1652 INFO. If SGOTP is non-NULL, it is filled in with the GOT
1655 static struct mips_got_info
*
1656 mips_elf_got_info (abfd
, sgotp
)
1661 struct mips_got_info
*g
;
1663 sgot
= mips_elf_got_section (abfd
, TRUE
);
1664 BFD_ASSERT (sgot
!= NULL
);
1665 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
1666 g
= mips_elf_section_data (sgot
)->u
.got_info
;
1667 BFD_ASSERT (g
!= NULL
);
1670 *sgotp
= (sgot
->flags
& SEC_EXCLUDE
) == 0 ? sgot
: NULL
;
1675 /* Obtain the lowest dynamic index of a symbol that was assigned a
1676 global GOT entry. */
1678 mips_elf_get_global_gotsym_index (abfd
)
1682 struct mips_got_info
*g
;
1687 sgot
= mips_elf_got_section (abfd
, TRUE
);
1688 if (sgot
== NULL
|| mips_elf_section_data (sgot
) == NULL
)
1691 g
= mips_elf_section_data (sgot
)->u
.got_info
;
1692 if (g
== NULL
|| g
->global_gotsym
== NULL
)
1695 return g
->global_gotsym
->dynindx
;
1698 /* Returns the GOT offset at which the indicated address can be found.
1699 If there is not yet a GOT entry for this value, create one. Returns
1700 -1 if no satisfactory GOT offset can be found. */
1703 mips_elf_local_got_index (abfd
, ibfd
, info
, value
)
1705 struct bfd_link_info
*info
;
1709 struct mips_got_info
*g
;
1710 struct mips_got_entry
*entry
;
1712 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1714 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
, value
);
1716 return entry
->gotidx
;
1721 /* Returns the GOT index for the global symbol indicated by H. */
1724 mips_elf_global_got_index (abfd
, ibfd
, h
)
1726 struct elf_link_hash_entry
*h
;
1730 struct mips_got_info
*g
, *gg
;
1731 long global_got_dynindx
= 0;
1733 gg
= g
= mips_elf_got_info (abfd
, &sgot
);
1734 if (g
->bfd2got
&& ibfd
)
1736 struct mips_got_entry e
, *p
;
1738 BFD_ASSERT (h
->dynindx
>= 0);
1740 g
= mips_elf_got_for_ibfd (g
, ibfd
);
1745 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
1747 p
= (struct mips_got_entry
*) htab_find (g
->got_entries
, &e
);
1749 BFD_ASSERT (p
->gotidx
> 0);
1754 if (gg
->global_gotsym
!= NULL
)
1755 global_got_dynindx
= gg
->global_gotsym
->dynindx
;
1757 /* Once we determine the global GOT entry with the lowest dynamic
1758 symbol table index, we must put all dynamic symbols with greater
1759 indices into the GOT. That makes it easy to calculate the GOT
1761 BFD_ASSERT (h
->dynindx
>= global_got_dynindx
);
1762 index
= ((h
->dynindx
- global_got_dynindx
+ g
->local_gotno
)
1763 * MIPS_ELF_GOT_SIZE (abfd
));
1764 BFD_ASSERT (index
< sgot
->_raw_size
);
1769 /* Find a GOT entry that is within 32KB of the VALUE. These entries
1770 are supposed to be placed at small offsets in the GOT, i.e.,
1771 within 32KB of GP. Return the index into the GOT for this page,
1772 and store the offset from this entry to the desired address in
1773 OFFSETP, if it is non-NULL. */
1776 mips_elf_got_page (abfd
, ibfd
, info
, value
, offsetp
)
1778 struct bfd_link_info
*info
;
1783 struct mips_got_info
*g
;
1785 struct mips_got_entry
*entry
;
1787 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1789 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
,
1791 & (~(bfd_vma
)0xffff));
1796 index
= entry
->gotidx
;
1799 *offsetp
= value
- entry
->d
.address
;
1804 /* Find a GOT entry whose higher-order 16 bits are the same as those
1805 for value. Return the index into the GOT for this entry. */
1808 mips_elf_got16_entry (abfd
, ibfd
, info
, value
, external
)
1810 struct bfd_link_info
*info
;
1812 bfd_boolean external
;
1815 struct mips_got_info
*g
;
1816 struct mips_got_entry
*entry
;
1820 /* Although the ABI says that it is "the high-order 16 bits" that we
1821 want, it is really the %high value. The complete value is
1822 calculated with a `addiu' of a LO16 relocation, just as with a
1824 value
= mips_elf_high (value
) << 16;
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 offset for the entry at the INDEXth position
1840 mips_elf_got_offset_from_index (dynobj
, output_bfd
, input_bfd
, index
)
1848 struct mips_got_info
*g
;
1850 g
= mips_elf_got_info (dynobj
, &sgot
);
1851 gp
= _bfd_get_gp_value (output_bfd
)
1852 + mips_elf_adjust_gp (output_bfd
, g
, input_bfd
);
1854 return sgot
->output_section
->vma
+ sgot
->output_offset
+ index
- gp
;
1857 /* Create a local GOT entry for VALUE. Return the index of the entry,
1858 or -1 if it could not be created. */
1860 static struct mips_got_entry
*
1861 mips_elf_create_local_got_entry (abfd
, ibfd
, gg
, sgot
, value
)
1863 struct mips_got_info
*gg
;
1867 struct mips_got_entry entry
, **loc
;
1868 struct mips_got_info
*g
;
1872 entry
.d
.address
= value
;
1874 g
= mips_elf_got_for_ibfd (gg
, ibfd
);
1877 g
= mips_elf_got_for_ibfd (gg
, abfd
);
1878 BFD_ASSERT (g
!= NULL
);
1881 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
1886 entry
.gotidx
= MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
++;
1888 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
1893 memcpy (*loc
, &entry
, sizeof entry
);
1895 if (g
->assigned_gotno
>= g
->local_gotno
)
1897 (*loc
)->gotidx
= -1;
1898 /* We didn't allocate enough space in the GOT. */
1899 (*_bfd_error_handler
)
1900 (_("not enough GOT space for local GOT entries"));
1901 bfd_set_error (bfd_error_bad_value
);
1905 MIPS_ELF_PUT_WORD (abfd
, value
,
1906 (sgot
->contents
+ entry
.gotidx
));
1911 /* Sort the dynamic symbol table so that symbols that need GOT entries
1912 appear towards the end. This reduces the amount of GOT space
1913 required. MAX_LOCAL is used to set the number of local symbols
1914 known to be in the dynamic symbol table. During
1915 _bfd_mips_elf_size_dynamic_sections, this value is 1. Afterward, the
1916 section symbols are added and the count is higher. */
1919 mips_elf_sort_hash_table (info
, max_local
)
1920 struct bfd_link_info
*info
;
1921 unsigned long max_local
;
1923 struct mips_elf_hash_sort_data hsd
;
1924 struct mips_got_info
*g
;
1927 dynobj
= elf_hash_table (info
)->dynobj
;
1929 g
= mips_elf_got_info (dynobj
, NULL
);
1932 hsd
.max_unref_got_dynindx
=
1933 hsd
.min_got_dynindx
= elf_hash_table (info
)->dynsymcount
1934 /* In the multi-got case, assigned_gotno of the master got_info
1935 indicate the number of entries that aren't referenced in the
1936 primary GOT, but that must have entries because there are
1937 dynamic relocations that reference it. Since they aren't
1938 referenced, we move them to the end of the GOT, so that they
1939 don't prevent other entries that are referenced from getting
1940 too large offsets. */
1941 - (g
->next
? g
->assigned_gotno
: 0);
1942 hsd
.max_non_got_dynindx
= max_local
;
1943 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table
*)
1944 elf_hash_table (info
)),
1945 mips_elf_sort_hash_table_f
,
1948 /* There should have been enough room in the symbol table to
1949 accommodate both the GOT and non-GOT symbols. */
1950 BFD_ASSERT (hsd
.max_non_got_dynindx
<= hsd
.min_got_dynindx
);
1951 BFD_ASSERT ((unsigned long)hsd
.max_unref_got_dynindx
1952 <= elf_hash_table (info
)->dynsymcount
);
1954 /* Now we know which dynamic symbol has the lowest dynamic symbol
1955 table index in the GOT. */
1956 g
->global_gotsym
= hsd
.low
;
1961 /* If H needs a GOT entry, assign it the highest available dynamic
1962 index. Otherwise, assign it the lowest available dynamic
1966 mips_elf_sort_hash_table_f (h
, data
)
1967 struct mips_elf_link_hash_entry
*h
;
1970 struct mips_elf_hash_sort_data
*hsd
1971 = (struct mips_elf_hash_sort_data
*) data
;
1973 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1974 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1976 /* Symbols without dynamic symbol table entries aren't interesting
1978 if (h
->root
.dynindx
== -1)
1981 /* Global symbols that need GOT entries that are not explicitly
1982 referenced are marked with got offset 2. Those that are
1983 referenced get a 1, and those that don't need GOT entries get
1985 if (h
->root
.got
.offset
== 2)
1987 if (hsd
->max_unref_got_dynindx
== hsd
->min_got_dynindx
)
1988 hsd
->low
= (struct elf_link_hash_entry
*) h
;
1989 h
->root
.dynindx
= hsd
->max_unref_got_dynindx
++;
1991 else if (h
->root
.got
.offset
!= 1)
1992 h
->root
.dynindx
= hsd
->max_non_got_dynindx
++;
1995 h
->root
.dynindx
= --hsd
->min_got_dynindx
;
1996 hsd
->low
= (struct elf_link_hash_entry
*) h
;
2002 /* If H is a symbol that needs a global GOT entry, but has a dynamic
2003 symbol table index lower than any we've seen to date, record it for
2007 mips_elf_record_global_got_symbol (h
, abfd
, info
, g
)
2008 struct elf_link_hash_entry
*h
;
2010 struct bfd_link_info
*info
;
2011 struct mips_got_info
*g
;
2013 struct mips_got_entry entry
, **loc
;
2015 /* A global symbol in the GOT must also be in the dynamic symbol
2017 if (h
->dynindx
== -1)
2019 switch (ELF_ST_VISIBILITY (h
->other
))
2023 _bfd_mips_elf_hide_symbol (info
, h
, TRUE
);
2026 if (!bfd_elf32_link_record_dynamic_symbol (info
, h
))
2032 entry
.d
.h
= (struct mips_elf_link_hash_entry
*) h
;
2034 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
2037 /* If we've already marked this entry as needing GOT space, we don't
2038 need to do it again. */
2042 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2048 memcpy (*loc
, &entry
, sizeof entry
);
2050 if (h
->got
.offset
!= MINUS_ONE
)
2053 /* By setting this to a value other than -1, we are indicating that
2054 there needs to be a GOT entry for H. Avoid using zero, as the
2055 generic ELF copy_indirect_symbol tests for <= 0. */
2061 /* Reserve space in G for a GOT entry containing the value of symbol
2062 SYMNDX in input bfd ABDF, plus ADDEND. */
2065 mips_elf_record_local_got_symbol (abfd
, symndx
, addend
, g
)
2069 struct mips_got_info
*g
;
2071 struct mips_got_entry entry
, **loc
;
2074 entry
.symndx
= symndx
;
2075 entry
.d
.addend
= addend
;
2076 loc
= (struct mips_got_entry
**)
2077 htab_find_slot (g
->got_entries
, &entry
, INSERT
);
2082 entry
.gotidx
= g
->local_gotno
++;
2084 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2089 memcpy (*loc
, &entry
, sizeof entry
);
2094 /* Compute the hash value of the bfd in a bfd2got hash entry. */
2097 mips_elf_bfd2got_entry_hash (entry_
)
2100 const struct mips_elf_bfd2got_hash
*entry
2101 = (struct mips_elf_bfd2got_hash
*)entry_
;
2103 return entry
->bfd
->id
;
2106 /* Check whether two hash entries have the same bfd. */
2109 mips_elf_bfd2got_entry_eq (entry1
, entry2
)
2113 const struct mips_elf_bfd2got_hash
*e1
2114 = (const struct mips_elf_bfd2got_hash
*)entry1
;
2115 const struct mips_elf_bfd2got_hash
*e2
2116 = (const struct mips_elf_bfd2got_hash
*)entry2
;
2118 return e1
->bfd
== e2
->bfd
;
2121 /* In a multi-got link, determine the GOT to be used for IBDF. G must
2122 be the master GOT data. */
2124 static struct mips_got_info
*
2125 mips_elf_got_for_ibfd (g
, ibfd
)
2126 struct mips_got_info
*g
;
2129 struct mips_elf_bfd2got_hash e
, *p
;
2135 p
= (struct mips_elf_bfd2got_hash
*) htab_find (g
->bfd2got
, &e
);
2136 return p
? p
->g
: NULL
;
2139 /* Create one separate got for each bfd that has entries in the global
2140 got, such that we can tell how many local and global entries each
2144 mips_elf_make_got_per_bfd (entryp
, p
)
2148 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2149 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
2150 htab_t bfd2got
= arg
->bfd2got
;
2151 struct mips_got_info
*g
;
2152 struct mips_elf_bfd2got_hash bfdgot_entry
, *bfdgot
;
2155 /* Find the got_info for this GOT entry's input bfd. Create one if
2157 bfdgot_entry
.bfd
= entry
->abfd
;
2158 bfdgotp
= htab_find_slot (bfd2got
, &bfdgot_entry
, INSERT
);
2159 bfdgot
= (struct mips_elf_bfd2got_hash
*)*bfdgotp
;
2165 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
2166 (arg
->obfd
, sizeof (struct mips_elf_bfd2got_hash
));
2176 bfdgot
->bfd
= entry
->abfd
;
2177 bfdgot
->g
= g
= (struct mips_got_info
*)
2178 bfd_alloc (arg
->obfd
, sizeof (struct mips_got_info
));
2185 g
->global_gotsym
= NULL
;
2186 g
->global_gotno
= 0;
2188 g
->assigned_gotno
= -1;
2189 g
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
2190 mips_elf_multi_got_entry_eq
,
2192 if (g
->got_entries
== NULL
)
2202 /* Insert the GOT entry in the bfd's got entry hash table. */
2203 entryp
= htab_find_slot (g
->got_entries
, entry
, INSERT
);
2204 if (*entryp
!= NULL
)
2209 if (entry
->symndx
>= 0 || entry
->d
.h
->forced_local
)
2217 /* Attempt to merge gots of different input bfds. Try to use as much
2218 as possible of the primary got, since it doesn't require explicit
2219 dynamic relocations, but don't use bfds that would reference global
2220 symbols out of the addressable range. Failing the primary got,
2221 attempt to merge with the current got, or finish the current got
2222 and then make make the new got current. */
2225 mips_elf_merge_gots (bfd2got_
, p
)
2229 struct mips_elf_bfd2got_hash
*bfd2got
2230 = (struct mips_elf_bfd2got_hash
*)*bfd2got_
;
2231 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
2232 unsigned int lcount
= bfd2got
->g
->local_gotno
;
2233 unsigned int gcount
= bfd2got
->g
->global_gotno
;
2234 unsigned int maxcnt
= arg
->max_count
;
2236 /* If we don't have a primary GOT and this is not too big, use it as
2237 a starting point for the primary GOT. */
2238 if (! arg
->primary
&& lcount
+ gcount
<= maxcnt
)
2240 arg
->primary
= bfd2got
->g
;
2241 arg
->primary_count
= lcount
+ gcount
;
2243 /* If it looks like we can merge this bfd's entries with those of
2244 the primary, merge them. The heuristics is conservative, but we
2245 don't have to squeeze it too hard. */
2246 else if (arg
->primary
2247 && (arg
->primary_count
+ lcount
+ gcount
) <= maxcnt
)
2249 struct mips_got_info
*g
= bfd2got
->g
;
2250 int old_lcount
= arg
->primary
->local_gotno
;
2251 int old_gcount
= arg
->primary
->global_gotno
;
2253 bfd2got
->g
= arg
->primary
;
2255 htab_traverse (g
->got_entries
,
2256 mips_elf_make_got_per_bfd
,
2258 if (arg
->obfd
== NULL
)
2261 htab_delete (g
->got_entries
);
2262 /* We don't have to worry about releasing memory of the actual
2263 got entries, since they're all in the master got_entries hash
2266 BFD_ASSERT (old_lcount
+ lcount
== arg
->primary
->local_gotno
);
2267 BFD_ASSERT (old_gcount
+ gcount
>= arg
->primary
->global_gotno
);
2269 arg
->primary_count
= arg
->primary
->local_gotno
2270 + arg
->primary
->global_gotno
;
2272 /* If we can merge with the last-created got, do it. */
2273 else if (arg
->current
2274 && arg
->current_count
+ lcount
+ gcount
<= maxcnt
)
2276 struct mips_got_info
*g
= bfd2got
->g
;
2277 int old_lcount
= arg
->current
->local_gotno
;
2278 int old_gcount
= arg
->current
->global_gotno
;
2280 bfd2got
->g
= arg
->current
;
2282 htab_traverse (g
->got_entries
,
2283 mips_elf_make_got_per_bfd
,
2285 if (arg
->obfd
== NULL
)
2288 htab_delete (g
->got_entries
);
2290 BFD_ASSERT (old_lcount
+ lcount
== arg
->current
->local_gotno
);
2291 BFD_ASSERT (old_gcount
+ gcount
>= arg
->current
->global_gotno
);
2293 arg
->current_count
= arg
->current
->local_gotno
2294 + arg
->current
->global_gotno
;
2296 /* Well, we couldn't merge, so create a new GOT. Don't check if it
2297 fits; if it turns out that it doesn't, we'll get relocation
2298 overflows anyway. */
2301 bfd2got
->g
->next
= arg
->current
;
2302 arg
->current
= bfd2got
->g
;
2304 arg
->current_count
= lcount
+ gcount
;
2310 /* If passed a NULL mips_got_info in the argument, set the marker used
2311 to tell whether a global symbol needs a got entry (in the primary
2312 got) to the given VALUE.
2314 If passed a pointer G to a mips_got_info in the argument (it must
2315 not be the primary GOT), compute the offset from the beginning of
2316 the (primary) GOT section to the entry in G corresponding to the
2317 global symbol. G's assigned_gotno must contain the index of the
2318 first available global GOT entry in G. VALUE must contain the size
2319 of a GOT entry in bytes. For each global GOT entry that requires a
2320 dynamic relocation, NEEDED_RELOCS is incremented, and the symbol is
2321 marked as not elligible for lazy resolution through a function
2324 mips_elf_set_global_got_offset (entryp
, p
)
2328 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2329 struct mips_elf_set_global_got_offset_arg
*arg
2330 = (struct mips_elf_set_global_got_offset_arg
*)p
;
2331 struct mips_got_info
*g
= arg
->g
;
2333 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1
2334 && entry
->d
.h
->root
.dynindx
!= -1)
2338 BFD_ASSERT (g
->global_gotsym
== NULL
);
2340 entry
->gotidx
= arg
->value
* (long) g
->assigned_gotno
++;
2341 /* We can't do lazy update of GOT entries for
2342 non-primary GOTs since the PLT entries don't use the
2343 right offsets, so punt at it for now. */
2344 entry
->d
.h
->no_fn_stub
= TRUE
;
2345 if (arg
->info
->shared
2346 || (elf_hash_table (arg
->info
)->dynamic_sections_created
2347 && ((entry
->d
.h
->root
.elf_link_hash_flags
2348 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0)
2349 && ((entry
->d
.h
->root
.elf_link_hash_flags
2350 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
2351 ++arg
->needed_relocs
;
2354 entry
->d
.h
->root
.got
.offset
= arg
->value
;
2360 /* Follow indirect and warning hash entries so that each got entry
2361 points to the final symbol definition. P must point to a pointer
2362 to the hash table we're traversing. Since this traversal may
2363 modify the hash table, we set this pointer to NULL to indicate
2364 we've made a potentially-destructive change to the hash table, so
2365 the traversal must be restarted. */
2367 mips_elf_resolve_final_got_entry (entryp
, p
)
2371 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2372 htab_t got_entries
= *(htab_t
*)p
;
2374 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1)
2376 struct mips_elf_link_hash_entry
*h
= entry
->d
.h
;
2378 while (h
->root
.root
.type
== bfd_link_hash_indirect
2379 || h
->root
.root
.type
== bfd_link_hash_warning
)
2380 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2382 if (entry
->d
.h
== h
)
2387 /* If we can't find this entry with the new bfd hash, re-insert
2388 it, and get the traversal restarted. */
2389 if (! htab_find (got_entries
, entry
))
2391 htab_clear_slot (got_entries
, entryp
);
2392 entryp
= htab_find_slot (got_entries
, entry
, INSERT
);
2395 /* Abort the traversal, since the whole table may have
2396 moved, and leave it up to the parent to restart the
2398 *(htab_t
*)p
= NULL
;
2401 /* We might want to decrement the global_gotno count, but it's
2402 either too early or too late for that at this point. */
2408 /* Turn indirect got entries in a got_entries table into their final
2411 mips_elf_resolve_final_got_entries (g
)
2412 struct mips_got_info
*g
;
2418 got_entries
= g
->got_entries
;
2420 htab_traverse (got_entries
,
2421 mips_elf_resolve_final_got_entry
,
2424 while (got_entries
== NULL
);
2427 /* Return the offset of an input bfd IBFD's GOT from the beginning of
2430 mips_elf_adjust_gp (abfd
, g
, ibfd
)
2432 struct mips_got_info
*g
;
2435 if (g
->bfd2got
== NULL
)
2438 g
= mips_elf_got_for_ibfd (g
, ibfd
);
2442 BFD_ASSERT (g
->next
);
2446 return (g
->local_gotno
+ g
->global_gotno
) * MIPS_ELF_GOT_SIZE (abfd
);
2449 /* Turn a single GOT that is too big for 16-bit addressing into
2450 a sequence of GOTs, each one 16-bit addressable. */
2453 mips_elf_multi_got (abfd
, info
, g
, got
, pages
)
2455 struct bfd_link_info
*info
;
2456 struct mips_got_info
*g
;
2458 bfd_size_type pages
;
2460 struct mips_elf_got_per_bfd_arg got_per_bfd_arg
;
2461 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
2462 struct mips_got_info
*gg
;
2463 unsigned int assign
;
2465 g
->bfd2got
= htab_try_create (1, mips_elf_bfd2got_entry_hash
,
2466 mips_elf_bfd2got_entry_eq
,
2468 if (g
->bfd2got
== NULL
)
2471 got_per_bfd_arg
.bfd2got
= g
->bfd2got
;
2472 got_per_bfd_arg
.obfd
= abfd
;
2473 got_per_bfd_arg
.info
= info
;
2475 /* Count how many GOT entries each input bfd requires, creating a
2476 map from bfd to got info while at that. */
2477 mips_elf_resolve_final_got_entries (g
);
2478 htab_traverse (g
->got_entries
, mips_elf_make_got_per_bfd
, &got_per_bfd_arg
);
2479 if (got_per_bfd_arg
.obfd
== NULL
)
2482 got_per_bfd_arg
.current
= NULL
;
2483 got_per_bfd_arg
.primary
= NULL
;
2484 /* Taking out PAGES entries is a worst-case estimate. We could
2485 compute the maximum number of pages that each separate input bfd
2486 uses, but it's probably not worth it. */
2487 got_per_bfd_arg
.max_count
= ((MIPS_ELF_GOT_MAX_SIZE (abfd
)
2488 / MIPS_ELF_GOT_SIZE (abfd
))
2489 - MIPS_RESERVED_GOTNO
- pages
);
2491 /* Try to merge the GOTs of input bfds together, as long as they
2492 don't seem to exceed the maximum GOT size, choosing one of them
2493 to be the primary GOT. */
2494 htab_traverse (g
->bfd2got
, mips_elf_merge_gots
, &got_per_bfd_arg
);
2495 if (got_per_bfd_arg
.obfd
== NULL
)
2498 /* If we find any suitable primary GOT, create an empty one. */
2499 if (got_per_bfd_arg
.primary
== NULL
)
2501 g
->next
= (struct mips_got_info
*)
2502 bfd_alloc (abfd
, sizeof (struct mips_got_info
));
2503 if (g
->next
== NULL
)
2506 g
->next
->global_gotsym
= NULL
;
2507 g
->next
->global_gotno
= 0;
2508 g
->next
->local_gotno
= 0;
2509 g
->next
->assigned_gotno
= 0;
2510 g
->next
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
2511 mips_elf_multi_got_entry_eq
,
2513 if (g
->next
->got_entries
== NULL
)
2515 g
->next
->bfd2got
= NULL
;
2518 g
->next
= got_per_bfd_arg
.primary
;
2519 g
->next
->next
= got_per_bfd_arg
.current
;
2521 /* GG is now the master GOT, and G is the primary GOT. */
2525 /* Map the output bfd to the primary got. That's what we're going
2526 to use for bfds that use GOT16 or GOT_PAGE relocations that we
2527 didn't mark in check_relocs, and we want a quick way to find it.
2528 We can't just use gg->next because we're going to reverse the
2531 struct mips_elf_bfd2got_hash
*bfdgot
;
2534 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
2535 (abfd
, sizeof (struct mips_elf_bfd2got_hash
));
2542 bfdgotp
= htab_find_slot (gg
->bfd2got
, bfdgot
, INSERT
);
2544 BFD_ASSERT (*bfdgotp
== NULL
);
2548 /* The IRIX dynamic linker requires every symbol that is referenced
2549 in a dynamic relocation to be present in the primary GOT, so
2550 arrange for them to appear after those that are actually
2553 GNU/Linux could very well do without it, but it would slow down
2554 the dynamic linker, since it would have to resolve every dynamic
2555 symbol referenced in other GOTs more than once, without help from
2556 the cache. Also, knowing that every external symbol has a GOT
2557 helps speed up the resolution of local symbols too, so GNU/Linux
2558 follows IRIX's practice.
2560 The number 2 is used by mips_elf_sort_hash_table_f to count
2561 global GOT symbols that are unreferenced in the primary GOT, with
2562 an initial dynamic index computed from gg->assigned_gotno, where
2563 the number of unreferenced global entries in the primary GOT is
2567 gg
->assigned_gotno
= gg
->global_gotno
- g
->global_gotno
;
2568 g
->global_gotno
= gg
->global_gotno
;
2569 set_got_offset_arg
.value
= 2;
2573 /* This could be used for dynamic linkers that don't optimize
2574 symbol resolution while applying relocations so as to use
2575 primary GOT entries or assuming the symbol is locally-defined.
2576 With this code, we assign lower dynamic indices to global
2577 symbols that are not referenced in the primary GOT, so that
2578 their entries can be omitted. */
2579 gg
->assigned_gotno
= 0;
2580 set_got_offset_arg
.value
= -1;
2583 /* Reorder dynamic symbols as described above (which behavior
2584 depends on the setting of VALUE). */
2585 set_got_offset_arg
.g
= NULL
;
2586 htab_traverse (gg
->got_entries
, mips_elf_set_global_got_offset
,
2587 &set_got_offset_arg
);
2588 set_got_offset_arg
.value
= 1;
2589 htab_traverse (g
->got_entries
, mips_elf_set_global_got_offset
,
2590 &set_got_offset_arg
);
2591 if (! mips_elf_sort_hash_table (info
, 1))
2594 /* Now go through the GOTs assigning them offset ranges.
2595 [assigned_gotno, local_gotno[ will be set to the range of local
2596 entries in each GOT. We can then compute the end of a GOT by
2597 adding local_gotno to global_gotno. We reverse the list and make
2598 it circular since then we'll be able to quickly compute the
2599 beginning of a GOT, by computing the end of its predecessor. To
2600 avoid special cases for the primary GOT, while still preserving
2601 assertions that are valid for both single- and multi-got links,
2602 we arrange for the main got struct to have the right number of
2603 global entries, but set its local_gotno such that the initial
2604 offset of the primary GOT is zero. Remember that the primary GOT
2605 will become the last item in the circular linked list, so it
2606 points back to the master GOT. */
2607 gg
->local_gotno
= -g
->global_gotno
;
2608 gg
->global_gotno
= g
->global_gotno
;
2614 struct mips_got_info
*gn
;
2616 assign
+= MIPS_RESERVED_GOTNO
;
2617 g
->assigned_gotno
= assign
;
2618 g
->local_gotno
+= assign
+ pages
;
2619 assign
= g
->local_gotno
+ g
->global_gotno
;
2621 /* Take g out of the direct list, and push it onto the reversed
2622 list that gg points to. */
2630 got
->_raw_size
= (gg
->next
->local_gotno
2631 + gg
->next
->global_gotno
) * MIPS_ELF_GOT_SIZE (abfd
);
2637 /* Returns the first relocation of type r_type found, beginning with
2638 RELOCATION. RELEND is one-past-the-end of the relocation table. */
2640 static const Elf_Internal_Rela
*
2641 mips_elf_next_relocation (abfd
, r_type
, relocation
, relend
)
2642 bfd
*abfd ATTRIBUTE_UNUSED
;
2643 unsigned int r_type
;
2644 const Elf_Internal_Rela
*relocation
;
2645 const Elf_Internal_Rela
*relend
;
2647 /* According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must be
2648 immediately following. However, for the IRIX6 ABI, the next
2649 relocation may be a composed relocation consisting of several
2650 relocations for the same address. In that case, the R_MIPS_LO16
2651 relocation may occur as one of these. We permit a similar
2652 extension in general, as that is useful for GCC. */
2653 while (relocation
< relend
)
2655 if (ELF_R_TYPE (abfd
, relocation
->r_info
) == r_type
)
2661 /* We didn't find it. */
2662 bfd_set_error (bfd_error_bad_value
);
2666 /* Return whether a relocation is against a local symbol. */
2669 mips_elf_local_relocation_p (input_bfd
, relocation
, local_sections
,
2672 const Elf_Internal_Rela
*relocation
;
2673 asection
**local_sections
;
2674 bfd_boolean check_forced
;
2676 unsigned long r_symndx
;
2677 Elf_Internal_Shdr
*symtab_hdr
;
2678 struct mips_elf_link_hash_entry
*h
;
2681 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
2682 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2683 extsymoff
= (elf_bad_symtab (input_bfd
)) ? 0 : symtab_hdr
->sh_info
;
2685 if (r_symndx
< extsymoff
)
2687 if (elf_bad_symtab (input_bfd
) && local_sections
[r_symndx
] != NULL
)
2692 /* Look up the hash table to check whether the symbol
2693 was forced local. */
2694 h
= (struct mips_elf_link_hash_entry
*)
2695 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
];
2696 /* Find the real hash-table entry for this symbol. */
2697 while (h
->root
.root
.type
== bfd_link_hash_indirect
2698 || h
->root
.root
.type
== bfd_link_hash_warning
)
2699 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2700 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0)
2707 /* Sign-extend VALUE, which has the indicated number of BITS. */
2710 _bfd_mips_elf_sign_extend (value
, bits
)
2714 if (value
& ((bfd_vma
) 1 << (bits
- 1)))
2715 /* VALUE is negative. */
2716 value
|= ((bfd_vma
) - 1) << bits
;
2721 /* Return non-zero if the indicated VALUE has overflowed the maximum
2722 range expressable by a signed number with the indicated number of
2726 mips_elf_overflow_p (value
, bits
)
2730 bfd_signed_vma svalue
= (bfd_signed_vma
) value
;
2732 if (svalue
> (1 << (bits
- 1)) - 1)
2733 /* The value is too big. */
2735 else if (svalue
< -(1 << (bits
- 1)))
2736 /* The value is too small. */
2743 /* Calculate the %high function. */
2746 mips_elf_high (value
)
2749 return ((value
+ (bfd_vma
) 0x8000) >> 16) & 0xffff;
2752 /* Calculate the %higher function. */
2755 mips_elf_higher (value
)
2756 bfd_vma value ATTRIBUTE_UNUSED
;
2759 return ((value
+ (bfd_vma
) 0x80008000) >> 32) & 0xffff;
2762 return (bfd_vma
) -1;
2766 /* Calculate the %highest function. */
2769 mips_elf_highest (value
)
2770 bfd_vma value ATTRIBUTE_UNUSED
;
2773 return ((value
+ (((bfd_vma
) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
2776 return (bfd_vma
) -1;
2780 /* Create the .compact_rel section. */
2783 mips_elf_create_compact_rel_section (abfd
, info
)
2785 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2788 register asection
*s
;
2790 if (bfd_get_section_by_name (abfd
, ".compact_rel") == NULL
)
2792 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
2795 s
= bfd_make_section (abfd
, ".compact_rel");
2797 || ! bfd_set_section_flags (abfd
, s
, flags
)
2798 || ! bfd_set_section_alignment (abfd
, s
,
2799 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
2802 s
->_raw_size
= sizeof (Elf32_External_compact_rel
);
2808 /* Create the .got section to hold the global offset table. */
2811 mips_elf_create_got_section (abfd
, info
, maybe_exclude
)
2813 struct bfd_link_info
*info
;
2814 bfd_boolean maybe_exclude
;
2817 register asection
*s
;
2818 struct elf_link_hash_entry
*h
;
2819 struct bfd_link_hash_entry
*bh
;
2820 struct mips_got_info
*g
;
2823 /* This function may be called more than once. */
2824 s
= mips_elf_got_section (abfd
, TRUE
);
2827 if (! maybe_exclude
)
2828 s
->flags
&= ~SEC_EXCLUDE
;
2832 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2833 | SEC_LINKER_CREATED
);
2836 flags
|= SEC_EXCLUDE
;
2838 /* We have to use an alignment of 2**4 here because this is hardcoded
2839 in the function stub generation and in the linker script. */
2840 s
= bfd_make_section (abfd
, ".got");
2842 || ! bfd_set_section_flags (abfd
, s
, flags
)
2843 || ! bfd_set_section_alignment (abfd
, s
, 4))
2846 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
2847 linker script because we don't want to define the symbol if we
2848 are not creating a global offset table. */
2850 if (! (_bfd_generic_link_add_one_symbol
2851 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
2852 (bfd_vma
) 0, (const char *) NULL
, FALSE
,
2853 get_elf_backend_data (abfd
)->collect
, &bh
)))
2856 h
= (struct elf_link_hash_entry
*) bh
;
2857 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
2858 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2859 h
->type
= STT_OBJECT
;
2862 && ! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2865 amt
= sizeof (struct mips_got_info
);
2866 g
= (struct mips_got_info
*) bfd_alloc (abfd
, amt
);
2869 g
->global_gotsym
= NULL
;
2870 g
->global_gotno
= 0;
2871 g
->local_gotno
= MIPS_RESERVED_GOTNO
;
2872 g
->assigned_gotno
= MIPS_RESERVED_GOTNO
;
2875 g
->got_entries
= htab_try_create (1, mips_elf_got_entry_hash
,
2876 mips_elf_got_entry_eq
,
2878 if (g
->got_entries
== NULL
)
2880 mips_elf_section_data (s
)->u
.got_info
= g
;
2881 mips_elf_section_data (s
)->elf
.this_hdr
.sh_flags
2882 |= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
2887 /* Calculate the value produced by the RELOCATION (which comes from
2888 the INPUT_BFD). The ADDEND is the addend to use for this
2889 RELOCATION; RELOCATION->R_ADDEND is ignored.
2891 The result of the relocation calculation is stored in VALUEP.
2892 REQUIRE_JALXP indicates whether or not the opcode used with this
2893 relocation must be JALX.
2895 This function returns bfd_reloc_continue if the caller need take no
2896 further action regarding this relocation, bfd_reloc_notsupported if
2897 something goes dramatically wrong, bfd_reloc_overflow if an
2898 overflow occurs, and bfd_reloc_ok to indicate success. */
2900 static bfd_reloc_status_type
2901 mips_elf_calculate_relocation (abfd
, input_bfd
, input_section
, info
,
2902 relocation
, addend
, howto
, local_syms
,
2903 local_sections
, valuep
, namep
,
2904 require_jalxp
, save_addend
)
2907 asection
*input_section
;
2908 struct bfd_link_info
*info
;
2909 const Elf_Internal_Rela
*relocation
;
2911 reloc_howto_type
*howto
;
2912 Elf_Internal_Sym
*local_syms
;
2913 asection
**local_sections
;
2916 bfd_boolean
*require_jalxp
;
2917 bfd_boolean save_addend
;
2919 /* The eventual value we will return. */
2921 /* The address of the symbol against which the relocation is
2924 /* The final GP value to be used for the relocatable, executable, or
2925 shared object file being produced. */
2926 bfd_vma gp
= MINUS_ONE
;
2927 /* The place (section offset or address) of the storage unit being
2930 /* The value of GP used to create the relocatable object. */
2931 bfd_vma gp0
= MINUS_ONE
;
2932 /* The offset into the global offset table at which the address of
2933 the relocation entry symbol, adjusted by the addend, resides
2934 during execution. */
2935 bfd_vma g
= MINUS_ONE
;
2936 /* The section in which the symbol referenced by the relocation is
2938 asection
*sec
= NULL
;
2939 struct mips_elf_link_hash_entry
*h
= NULL
;
2940 /* TRUE if the symbol referred to by this relocation is a local
2942 bfd_boolean local_p
, was_local_p
;
2943 /* TRUE if the symbol referred to by this relocation is "_gp_disp". */
2944 bfd_boolean gp_disp_p
= FALSE
;
2945 Elf_Internal_Shdr
*symtab_hdr
;
2947 unsigned long r_symndx
;
2949 /* TRUE if overflow occurred during the calculation of the
2950 relocation value. */
2951 bfd_boolean overflowed_p
;
2952 /* TRUE if this relocation refers to a MIPS16 function. */
2953 bfd_boolean target_is_16_bit_code_p
= FALSE
;
2955 /* Parse the relocation. */
2956 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
2957 r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
2958 p
= (input_section
->output_section
->vma
2959 + input_section
->output_offset
2960 + relocation
->r_offset
);
2962 /* Assume that there will be no overflow. */
2963 overflowed_p
= FALSE
;
2965 /* Figure out whether or not the symbol is local, and get the offset
2966 used in the array of hash table entries. */
2967 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2968 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
2969 local_sections
, FALSE
);
2970 was_local_p
= local_p
;
2971 if (! elf_bad_symtab (input_bfd
))
2972 extsymoff
= symtab_hdr
->sh_info
;
2975 /* The symbol table does not follow the rule that local symbols
2976 must come before globals. */
2980 /* Figure out the value of the symbol. */
2983 Elf_Internal_Sym
*sym
;
2985 sym
= local_syms
+ r_symndx
;
2986 sec
= local_sections
[r_symndx
];
2988 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
2989 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
2990 || (sec
->flags
& SEC_MERGE
))
2991 symbol
+= sym
->st_value
;
2992 if ((sec
->flags
& SEC_MERGE
)
2993 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2995 addend
= _bfd_elf_rel_local_sym (abfd
, sym
, &sec
, addend
);
2997 addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
3000 /* MIPS16 text labels should be treated as odd. */
3001 if (sym
->st_other
== STO_MIPS16
)
3004 /* Record the name of this symbol, for our caller. */
3005 *namep
= bfd_elf_string_from_elf_section (input_bfd
,
3006 symtab_hdr
->sh_link
,
3009 *namep
= bfd_section_name (input_bfd
, sec
);
3011 target_is_16_bit_code_p
= (sym
->st_other
== STO_MIPS16
);
3015 /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ? */
3017 /* For global symbols we look up the symbol in the hash-table. */
3018 h
= ((struct mips_elf_link_hash_entry
*)
3019 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
]);
3020 /* Find the real hash-table entry for this symbol. */
3021 while (h
->root
.root
.type
== bfd_link_hash_indirect
3022 || h
->root
.root
.type
== bfd_link_hash_warning
)
3023 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3025 /* Record the name of this symbol, for our caller. */
3026 *namep
= h
->root
.root
.root
.string
;
3028 /* See if this is the special _gp_disp symbol. Note that such a
3029 symbol must always be a global symbol. */
3030 if (strcmp (*namep
, "_gp_disp") == 0
3031 && ! NEWABI_P (input_bfd
))
3033 /* Relocations against _gp_disp are permitted only with
3034 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
3035 if (r_type
!= R_MIPS_HI16
&& r_type
!= R_MIPS_LO16
)
3036 return bfd_reloc_notsupported
;
3040 /* If this symbol is defined, calculate its address. Note that
3041 _gp_disp is a magic symbol, always implicitly defined by the
3042 linker, so it's inappropriate to check to see whether or not
3044 else if ((h
->root
.root
.type
== bfd_link_hash_defined
3045 || h
->root
.root
.type
== bfd_link_hash_defweak
)
3046 && h
->root
.root
.u
.def
.section
)
3048 sec
= h
->root
.root
.u
.def
.section
;
3049 if (sec
->output_section
)
3050 symbol
= (h
->root
.root
.u
.def
.value
3051 + sec
->output_section
->vma
3052 + sec
->output_offset
);
3054 symbol
= h
->root
.root
.u
.def
.value
;
3056 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
3057 /* We allow relocations against undefined weak symbols, giving
3058 it the value zero, so that you can undefined weak functions
3059 and check to see if they exist by looking at their
3062 else if (info
->shared
3063 && info
->unresolved_syms_in_objects
== RM_IGNORE
3064 && ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
3066 else if (strcmp (*namep
, "_DYNAMIC_LINK") == 0 ||
3067 strcmp (*namep
, "_DYNAMIC_LINKING") == 0)
3069 /* If this is a dynamic link, we should have created a
3070 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
3071 in in _bfd_mips_elf_create_dynamic_sections.
3072 Otherwise, we should define the symbol with a value of 0.
3073 FIXME: It should probably get into the symbol table
3075 BFD_ASSERT (! info
->shared
);
3076 BFD_ASSERT (bfd_get_section_by_name (abfd
, ".dynamic") == NULL
);
3081 if (! ((*info
->callbacks
->undefined_symbol
)
3082 (info
, h
->root
.root
.root
.string
, input_bfd
,
3083 input_section
, relocation
->r_offset
,
3084 ((info
->shared
&& info
->unresolved_syms_in_shared_libs
== RM_GENERATE_ERROR
)
3085 || (!info
->shared
&& info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
)
3086 || ELF_ST_VISIBILITY (h
->root
.other
)))))
3087 return bfd_reloc_undefined
;
3091 target_is_16_bit_code_p
= (h
->root
.other
== STO_MIPS16
);
3094 /* If this is a 32- or 64-bit call to a 16-bit function with a stub, we
3095 need to redirect the call to the stub, unless we're already *in*
3097 if (r_type
!= R_MIPS16_26
&& !info
->relocatable
3098 && ((h
!= NULL
&& h
->fn_stub
!= NULL
)
3099 || (local_p
&& elf_tdata (input_bfd
)->local_stubs
!= NULL
3100 && elf_tdata (input_bfd
)->local_stubs
[r_symndx
] != NULL
))
3101 && !mips_elf_stub_section_p (input_bfd
, input_section
))
3103 /* This is a 32- or 64-bit call to a 16-bit function. We should
3104 have already noticed that we were going to need the
3107 sec
= elf_tdata (input_bfd
)->local_stubs
[r_symndx
];
3110 BFD_ASSERT (h
->need_fn_stub
);
3114 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3116 /* If this is a 16-bit call to a 32- or 64-bit function with a stub, we
3117 need to redirect the call to the stub. */
3118 else if (r_type
== R_MIPS16_26
&& !info
->relocatable
3120 && (h
->call_stub
!= NULL
|| h
->call_fp_stub
!= NULL
)
3121 && !target_is_16_bit_code_p
)
3123 /* If both call_stub and call_fp_stub are defined, we can figure
3124 out which one to use by seeing which one appears in the input
3126 if (h
->call_stub
!= NULL
&& h
->call_fp_stub
!= NULL
)
3131 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
3133 if (strncmp (bfd_get_section_name (input_bfd
, o
),
3134 CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
3136 sec
= h
->call_fp_stub
;
3143 else if (h
->call_stub
!= NULL
)
3146 sec
= h
->call_fp_stub
;
3148 BFD_ASSERT (sec
->_raw_size
> 0);
3149 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3152 /* Calls from 16-bit code to 32-bit code and vice versa require the
3153 special jalx instruction. */
3154 *require_jalxp
= (!info
->relocatable
3155 && (((r_type
== R_MIPS16_26
) && !target_is_16_bit_code_p
)
3156 || ((r_type
== R_MIPS_26
) && target_is_16_bit_code_p
)));
3158 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
3159 local_sections
, TRUE
);
3161 /* If we haven't already determined the GOT offset, or the GP value,
3162 and we're going to need it, get it now. */
3165 case R_MIPS_GOT_PAGE
:
3166 case R_MIPS_GOT_OFST
:
3167 /* If this symbol got a global GOT entry, we have to decay
3168 GOT_PAGE/GOT_OFST to GOT_DISP/addend. */
3169 local_p
= local_p
|| ! h
3171 < mips_elf_get_global_gotsym_index (elf_hash_table (info
)
3173 if (local_p
|| r_type
== R_MIPS_GOT_OFST
)
3179 case R_MIPS_GOT_DISP
:
3180 case R_MIPS_GOT_HI16
:
3181 case R_MIPS_CALL_HI16
:
3182 case R_MIPS_GOT_LO16
:
3183 case R_MIPS_CALL_LO16
:
3184 /* Find the index into the GOT where this value is located. */
3187 /* GOT_PAGE may take a non-zero addend, that is ignored in a
3188 GOT_PAGE relocation that decays to GOT_DISP because the
3189 symbol turns out to be global. The addend is then added
3191 BFD_ASSERT (addend
== 0 || r_type
== R_MIPS_GOT_PAGE
);
3192 g
= mips_elf_global_got_index (elf_hash_table (info
)->dynobj
,
3194 (struct elf_link_hash_entry
*) h
);
3195 if (! elf_hash_table(info
)->dynamic_sections_created
3197 && (info
->symbolic
|| h
->root
.dynindx
== -1)
3198 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
3200 /* This is a static link or a -Bsymbolic link. The
3201 symbol is defined locally, or was forced to be local.
3202 We must initialize this entry in the GOT. */
3203 bfd
*tmpbfd
= elf_hash_table (info
)->dynobj
;
3204 asection
*sgot
= mips_elf_got_section (tmpbfd
, FALSE
);
3205 MIPS_ELF_PUT_WORD (tmpbfd
, symbol
, sgot
->contents
+ g
);
3208 else if (r_type
== R_MIPS_GOT16
|| r_type
== R_MIPS_CALL16
)
3209 /* There's no need to create a local GOT entry here; the
3210 calculation for a local GOT16 entry does not involve G. */
3214 g
= mips_elf_local_got_index (abfd
, input_bfd
,
3215 info
, symbol
+ addend
);
3217 return bfd_reloc_outofrange
;
3220 /* Convert GOT indices to actual offsets. */
3221 g
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3222 abfd
, input_bfd
, g
);
3227 case R_MIPS16_GPREL
:
3228 case R_MIPS_GPREL16
:
3229 case R_MIPS_GPREL32
:
3230 case R_MIPS_LITERAL
:
3231 gp0
= _bfd_get_gp_value (input_bfd
);
3232 gp
= _bfd_get_gp_value (abfd
);
3233 if (elf_hash_table (info
)->dynobj
)
3234 gp
+= mips_elf_adjust_gp (abfd
,
3236 (elf_hash_table (info
)->dynobj
, NULL
),
3244 /* Figure out what kind of relocation is being performed. */
3248 return bfd_reloc_continue
;
3251 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 16);
3252 overflowed_p
= mips_elf_overflow_p (value
, 16);
3259 || (elf_hash_table (info
)->dynamic_sections_created
3261 && ((h
->root
.elf_link_hash_flags
3262 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0)
3263 && ((h
->root
.elf_link_hash_flags
3264 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
3266 && (input_section
->flags
& SEC_ALLOC
) != 0)
3268 /* If we're creating a shared library, or this relocation is
3269 against a symbol in a shared library, then we can't know
3270 where the symbol will end up. So, we create a relocation
3271 record in the output, and leave the job up to the dynamic
3274 if (!mips_elf_create_dynamic_relocation (abfd
,
3282 return bfd_reloc_undefined
;
3286 if (r_type
!= R_MIPS_REL32
)
3287 value
= symbol
+ addend
;
3291 value
&= howto
->dst_mask
;
3296 case R_MIPS_GNU_REL_LO16
:
3297 value
= symbol
+ addend
- p
;
3298 value
&= howto
->dst_mask
;
3301 case R_MIPS_GNU_REL16_S2
:
3302 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
<< 2, 18) - p
;
3303 overflowed_p
= mips_elf_overflow_p (value
, 18);
3304 value
= (value
>> 2) & howto
->dst_mask
;
3307 case R_MIPS_GNU_REL_HI16
:
3308 /* Instead of subtracting 'p' here, we should be subtracting the
3309 equivalent value for the LO part of the reloc, since the value
3310 here is relative to that address. Because that's not easy to do,
3311 we adjust 'addend' in _bfd_mips_elf_relocate_section(). See also
3312 the comment there for more information. */
3313 value
= mips_elf_high (addend
+ symbol
- p
);
3314 value
&= howto
->dst_mask
;
3318 /* The calculation for R_MIPS16_26 is just the same as for an
3319 R_MIPS_26. It's only the storage of the relocated field into
3320 the output file that's different. That's handled in
3321 mips_elf_perform_relocation. So, we just fall through to the
3322 R_MIPS_26 case here. */
3325 value
= (((addend
<< 2) | ((p
+ 4) & 0xf0000000)) + symbol
) >> 2;
3327 value
= (_bfd_mips_elf_sign_extend (addend
<< 2, 28) + symbol
) >> 2;
3328 value
&= howto
->dst_mask
;
3334 value
= mips_elf_high (addend
+ symbol
);
3335 value
&= howto
->dst_mask
;
3339 value
= mips_elf_high (addend
+ gp
- p
);
3340 overflowed_p
= mips_elf_overflow_p (value
, 16);
3346 value
= (symbol
+ addend
) & howto
->dst_mask
;
3349 value
= addend
+ gp
- p
+ 4;
3350 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
3351 for overflow. But, on, say, IRIX5, relocations against
3352 _gp_disp are normally generated from the .cpload
3353 pseudo-op. It generates code that normally looks like
3356 lui $gp,%hi(_gp_disp)
3357 addiu $gp,$gp,%lo(_gp_disp)
3360 Here $t9 holds the address of the function being called,
3361 as required by the MIPS ELF ABI. The R_MIPS_LO16
3362 relocation can easily overflow in this situation, but the
3363 R_MIPS_HI16 relocation will handle the overflow.
3364 Therefore, we consider this a bug in the MIPS ABI, and do
3365 not check for overflow here. */
3369 case R_MIPS_LITERAL
:
3370 /* Because we don't merge literal sections, we can handle this
3371 just like R_MIPS_GPREL16. In the long run, we should merge
3372 shared literals, and then we will need to additional work
3377 case R_MIPS16_GPREL
:
3378 /* The R_MIPS16_GPREL performs the same calculation as
3379 R_MIPS_GPREL16, but stores the relocated bits in a different
3380 order. We don't need to do anything special here; the
3381 differences are handled in mips_elf_perform_relocation. */
3382 case R_MIPS_GPREL16
:
3383 /* Only sign-extend the addend if it was extracted from the
3384 instruction. If the addend was separate, leave it alone,
3385 otherwise we may lose significant bits. */
3386 if (howto
->partial_inplace
)
3387 addend
= _bfd_mips_elf_sign_extend (addend
, 16);
3388 value
= symbol
+ addend
- gp
;
3389 /* If the symbol was local, any earlier relocatable links will
3390 have adjusted its addend with the gp offset, so compensate
3391 for that now. Don't do it for symbols forced local in this
3392 link, though, since they won't have had the gp offset applied
3396 overflowed_p
= mips_elf_overflow_p (value
, 16);
3405 /* The special case is when the symbol is forced to be local. We
3406 need the full address in the GOT since no R_MIPS_LO16 relocation
3408 forced
= ! mips_elf_local_relocation_p (input_bfd
, relocation
,
3409 local_sections
, FALSE
);
3410 value
= mips_elf_got16_entry (abfd
, input_bfd
, info
,
3411 symbol
+ addend
, forced
);
3412 if (value
== MINUS_ONE
)
3413 return bfd_reloc_outofrange
;
3415 = mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3416 abfd
, input_bfd
, value
);
3417 overflowed_p
= mips_elf_overflow_p (value
, 16);
3423 case R_MIPS_GOT_DISP
:
3426 overflowed_p
= mips_elf_overflow_p (value
, 16);
3429 case R_MIPS_GPREL32
:
3430 value
= (addend
+ symbol
+ gp0
- gp
);
3432 value
&= howto
->dst_mask
;
3436 value
= _bfd_mips_elf_sign_extend (addend
, 16) + symbol
- p
;
3437 overflowed_p
= mips_elf_overflow_p (value
, 16);
3440 case R_MIPS_GOT_HI16
:
3441 case R_MIPS_CALL_HI16
:
3442 /* We're allowed to handle these two relocations identically.
3443 The dynamic linker is allowed to handle the CALL relocations
3444 differently by creating a lazy evaluation stub. */
3446 value
= mips_elf_high (value
);
3447 value
&= howto
->dst_mask
;
3450 case R_MIPS_GOT_LO16
:
3451 case R_MIPS_CALL_LO16
:
3452 value
= g
& howto
->dst_mask
;
3455 case R_MIPS_GOT_PAGE
:
3456 /* GOT_PAGE relocations that reference non-local symbols decay
3457 to GOT_DISP. The corresponding GOT_OFST relocation decays to
3461 value
= mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, NULL
);
3462 if (value
== MINUS_ONE
)
3463 return bfd_reloc_outofrange
;
3464 value
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3465 abfd
, input_bfd
, value
);
3466 overflowed_p
= mips_elf_overflow_p (value
, 16);
3469 case R_MIPS_GOT_OFST
:
3471 mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, &value
);
3474 overflowed_p
= mips_elf_overflow_p (value
, 16);
3478 value
= symbol
- addend
;
3479 value
&= howto
->dst_mask
;
3483 value
= mips_elf_higher (addend
+ symbol
);
3484 value
&= howto
->dst_mask
;
3487 case R_MIPS_HIGHEST
:
3488 value
= mips_elf_highest (addend
+ symbol
);
3489 value
&= howto
->dst_mask
;
3492 case R_MIPS_SCN_DISP
:
3493 value
= symbol
+ addend
- sec
->output_offset
;
3494 value
&= howto
->dst_mask
;
3499 /* Both of these may be ignored. R_MIPS_JALR is an optimization
3500 hint; we could improve performance by honoring that hint. */
3501 return bfd_reloc_continue
;
3503 case R_MIPS_GNU_VTINHERIT
:
3504 case R_MIPS_GNU_VTENTRY
:
3505 /* We don't do anything with these at present. */
3506 return bfd_reloc_continue
;
3509 /* An unrecognized relocation type. */
3510 return bfd_reloc_notsupported
;
3513 /* Store the VALUE for our caller. */
3515 return overflowed_p
? bfd_reloc_overflow
: bfd_reloc_ok
;
3518 /* Obtain the field relocated by RELOCATION. */
3521 mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
)
3522 reloc_howto_type
*howto
;
3523 const Elf_Internal_Rela
*relocation
;
3528 bfd_byte
*location
= contents
+ relocation
->r_offset
;
3530 /* Obtain the bytes. */
3531 x
= bfd_get ((8 * bfd_get_reloc_size (howto
)), input_bfd
, location
);
3533 if ((ELF_R_TYPE (input_bfd
, relocation
->r_info
) == R_MIPS16_26
3534 || ELF_R_TYPE (input_bfd
, relocation
->r_info
) == R_MIPS16_GPREL
)
3535 && bfd_little_endian (input_bfd
))
3536 /* The two 16-bit words will be reversed on a little-endian system.
3537 See mips_elf_perform_relocation for more details. */
3538 x
= (((x
& 0xffff) << 16) | ((x
& 0xffff0000) >> 16));
3543 /* It has been determined that the result of the RELOCATION is the
3544 VALUE. Use HOWTO to place VALUE into the output file at the
3545 appropriate position. The SECTION is the section to which the
3546 relocation applies. If REQUIRE_JALX is TRUE, then the opcode used
3547 for the relocation must be either JAL or JALX, and it is
3548 unconditionally converted to JALX.
3550 Returns FALSE if anything goes wrong. */
3553 mips_elf_perform_relocation (info
, howto
, relocation
, value
, input_bfd
,
3554 input_section
, contents
, require_jalx
)
3555 struct bfd_link_info
*info
;
3556 reloc_howto_type
*howto
;
3557 const Elf_Internal_Rela
*relocation
;
3560 asection
*input_section
;
3562 bfd_boolean require_jalx
;
3566 int r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
3568 /* Figure out where the relocation is occurring. */
3569 location
= contents
+ relocation
->r_offset
;
3571 /* Obtain the current value. */
3572 x
= mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
);
3574 /* Clear the field we are setting. */
3575 x
&= ~howto
->dst_mask
;
3577 /* If this is the R_MIPS16_26 relocation, we must store the
3578 value in a funny way. */
3579 if (r_type
== R_MIPS16_26
)
3581 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
3582 Most mips16 instructions are 16 bits, but these instructions
3585 The format of these instructions is:
3587 +--------------+--------------------------------+
3588 ! JALX ! X! Imm 20:16 ! Imm 25:21 !
3589 +--------------+--------------------------------+
3591 +-----------------------------------------------+
3593 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
3594 Note that the immediate value in the first word is swapped.
3596 When producing a relocatable object file, R_MIPS16_26 is
3597 handled mostly like R_MIPS_26. In particular, the addend is
3598 stored as a straight 26-bit value in a 32-bit instruction.
3599 (gas makes life simpler for itself by never adjusting a
3600 R_MIPS16_26 reloc to be against a section, so the addend is
3601 always zero). However, the 32 bit instruction is stored as 2
3602 16-bit values, rather than a single 32-bit value. In a
3603 big-endian file, the result is the same; in a little-endian
3604 file, the two 16-bit halves of the 32 bit value are swapped.
3605 This is so that a disassembler can recognize the jal
3608 When doing a final link, R_MIPS16_26 is treated as a 32 bit
3609 instruction stored as two 16-bit values. The addend A is the
3610 contents of the targ26 field. The calculation is the same as
3611 R_MIPS_26. When storing the calculated value, reorder the
3612 immediate value as shown above, and don't forget to store the
3613 value as two 16-bit values.
3615 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
3619 +--------+----------------------+
3623 +--------+----------------------+
3626 +----------+------+-------------+
3630 +----------+--------------------+
3631 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
3632 ((sub1 << 16) | sub2)).
3634 When producing a relocatable object file, the calculation is
3635 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
3636 When producing a fully linked file, the calculation is
3637 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
3638 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff) */
3640 if (!info
->relocatable
)
3641 /* Shuffle the bits according to the formula above. */
3642 value
= (((value
& 0x1f0000) << 5)
3643 | ((value
& 0x3e00000) >> 5)
3644 | (value
& 0xffff));
3646 else if (r_type
== R_MIPS16_GPREL
)
3648 /* R_MIPS16_GPREL is used for GP-relative addressing in mips16
3649 mode. A typical instruction will have a format like this:
3651 +--------------+--------------------------------+
3652 ! EXTEND ! Imm 10:5 ! Imm 15:11 !
3653 +--------------+--------------------------------+
3654 ! Major ! rx ! ry ! Imm 4:0 !
3655 +--------------+--------------------------------+
3657 EXTEND is the five bit value 11110. Major is the instruction
3660 This is handled exactly like R_MIPS_GPREL16, except that the
3661 addend is retrieved and stored as shown in this diagram; that
3662 is, the Imm fields above replace the V-rel16 field.
3664 All we need to do here is shuffle the bits appropriately. As
3665 above, the two 16-bit halves must be swapped on a
3666 little-endian system. */
3667 value
= (((value
& 0x7e0) << 16)
3668 | ((value
& 0xf800) << 5)
3672 /* Set the field. */
3673 x
|= (value
& howto
->dst_mask
);
3675 /* If required, turn JAL into JALX. */
3679 bfd_vma opcode
= x
>> 26;
3680 bfd_vma jalx_opcode
;
3682 /* Check to see if the opcode is already JAL or JALX. */
3683 if (r_type
== R_MIPS16_26
)
3685 ok
= ((opcode
== 0x6) || (opcode
== 0x7));
3690 ok
= ((opcode
== 0x3) || (opcode
== 0x1d));
3694 /* If the opcode is not JAL or JALX, there's a problem. */
3697 (*_bfd_error_handler
)
3698 (_("%s: %s+0x%lx: jump to stub routine which is not jal"),
3699 bfd_archive_filename (input_bfd
),
3700 input_section
->name
,
3701 (unsigned long) relocation
->r_offset
);
3702 bfd_set_error (bfd_error_bad_value
);
3706 /* Make this the JALX opcode. */
3707 x
= (x
& ~(0x3f << 26)) | (jalx_opcode
<< 26);
3710 /* Swap the high- and low-order 16 bits on little-endian systems
3711 when doing a MIPS16 relocation. */
3712 if ((r_type
== R_MIPS16_GPREL
|| r_type
== R_MIPS16_26
)
3713 && bfd_little_endian (input_bfd
))
3714 x
= (((x
& 0xffff) << 16) | ((x
& 0xffff0000) >> 16));
3716 /* Put the value into the output. */
3717 bfd_put (8 * bfd_get_reloc_size (howto
), input_bfd
, x
, location
);
3721 /* Returns TRUE if SECTION is a MIPS16 stub section. */
3724 mips_elf_stub_section_p (abfd
, section
)
3725 bfd
*abfd ATTRIBUTE_UNUSED
;
3728 const char *name
= bfd_get_section_name (abfd
, section
);
3730 return (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0
3731 || strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
3732 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0);
3735 /* Add room for N relocations to the .rel.dyn section in ABFD. */
3738 mips_elf_allocate_dynamic_relocations (abfd
, n
)
3744 s
= mips_elf_rel_dyn_section (abfd
, FALSE
);
3745 BFD_ASSERT (s
!= NULL
);
3747 if (s
->_raw_size
== 0)
3749 /* Make room for a null element. */
3750 s
->_raw_size
+= MIPS_ELF_REL_SIZE (abfd
);
3753 s
->_raw_size
+= n
* MIPS_ELF_REL_SIZE (abfd
);
3756 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
3757 is the original relocation, which is now being transformed into a
3758 dynamic relocation. The ADDENDP is adjusted if necessary; the
3759 caller should store the result in place of the original addend. */
3762 mips_elf_create_dynamic_relocation (output_bfd
, info
, rel
, h
, sec
,
3763 symbol
, addendp
, input_section
)
3765 struct bfd_link_info
*info
;
3766 const Elf_Internal_Rela
*rel
;
3767 struct mips_elf_link_hash_entry
*h
;
3771 asection
*input_section
;
3773 Elf_Internal_Rela outrel
[3];
3779 r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
3780 dynobj
= elf_hash_table (info
)->dynobj
;
3781 sreloc
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
3782 BFD_ASSERT (sreloc
!= NULL
);
3783 BFD_ASSERT (sreloc
->contents
!= NULL
);
3784 BFD_ASSERT (sreloc
->reloc_count
* MIPS_ELF_REL_SIZE (output_bfd
)
3785 < sreloc
->_raw_size
);
3788 outrel
[0].r_offset
=
3789 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[0].r_offset
);
3790 outrel
[1].r_offset
=
3791 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[1].r_offset
);
3792 outrel
[2].r_offset
=
3793 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[2].r_offset
);
3796 /* We begin by assuming that the offset for the dynamic relocation
3797 is the same as for the original relocation. We'll adjust this
3798 later to reflect the correct output offsets. */
3799 if (input_section
->sec_info_type
!= ELF_INFO_TYPE_STABS
)
3801 outrel
[1].r_offset
= rel
[1].r_offset
;
3802 outrel
[2].r_offset
= rel
[2].r_offset
;
3806 /* Except that in a stab section things are more complex.
3807 Because we compress stab information, the offset given in the
3808 relocation may not be the one we want; we must let the stabs
3809 machinery tell us the offset. */
3810 outrel
[1].r_offset
= outrel
[0].r_offset
;
3811 outrel
[2].r_offset
= outrel
[0].r_offset
;
3812 /* If we didn't need the relocation at all, this value will be
3814 if (outrel
[0].r_offset
== (bfd_vma
) -1)
3819 if (outrel
[0].r_offset
== (bfd_vma
) -1)
3820 /* The relocation field has been deleted. */
3822 else if (outrel
[0].r_offset
== (bfd_vma
) -2)
3824 /* The relocation field has been converted into a relative value of
3825 some sort. Functions like _bfd_elf_write_section_eh_frame expect
3826 the field to be fully relocated, so add in the symbol's value. */
3831 /* If we've decided to skip this relocation, just output an empty
3832 record. Note that R_MIPS_NONE == 0, so that this call to memset
3833 is a way of setting R_TYPE to R_MIPS_NONE. */
3835 memset (outrel
, 0, sizeof (Elf_Internal_Rela
) * 3);
3839 bfd_boolean defined_p
;
3841 /* We must now calculate the dynamic symbol table index to use
3842 in the relocation. */
3844 && (! info
->symbolic
|| (h
->root
.elf_link_hash_flags
3845 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
3846 /* h->root.dynindx may be -1 if this symbol was marked to
3848 && h
->root
.dynindx
!= -1)
3850 indx
= h
->root
.dynindx
;
3851 if (SGI_COMPAT (output_bfd
))
3852 defined_p
= ((h
->root
.elf_link_hash_flags
3853 & ELF_LINK_HASH_DEF_REGULAR
) != 0);
3855 /* ??? glibc's ld.so just adds the final GOT entry to the
3856 relocation field. It therefore treats relocs against
3857 defined symbols in the same way as relocs against
3858 undefined symbols. */
3863 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
3865 else if (sec
== NULL
|| sec
->owner
== NULL
)
3867 bfd_set_error (bfd_error_bad_value
);
3872 indx
= elf_section_data (sec
->output_section
)->dynindx
;
3877 /* Instead of generating a relocation using the section
3878 symbol, we may as well make it a fully relative
3879 relocation. We want to avoid generating relocations to
3880 local symbols because we used to generate them
3881 incorrectly, without adding the original symbol value,
3882 which is mandated by the ABI for section symbols. In
3883 order to give dynamic loaders and applications time to
3884 phase out the incorrect use, we refrain from emitting
3885 section-relative relocations. It's not like they're
3886 useful, after all. This should be a bit more efficient
3888 /* ??? Although this behavior is compatible with glibc's ld.so,
3889 the ABI says that relocations against STN_UNDEF should have
3890 a symbol value of 0. Irix rld honors this, so relocations
3891 against STN_UNDEF have no effect. */
3892 if (!SGI_COMPAT (output_bfd
))
3897 /* If the relocation was previously an absolute relocation and
3898 this symbol will not be referred to by the relocation, we must
3899 adjust it by the value we give it in the dynamic symbol table.
3900 Otherwise leave the job up to the dynamic linker. */
3901 if (defined_p
&& r_type
!= R_MIPS_REL32
)
3904 /* The relocation is always an REL32 relocation because we don't
3905 know where the shared library will wind up at load-time. */
3906 outrel
[0].r_info
= ELF_R_INFO (output_bfd
, (unsigned long) indx
,
3908 /* For strict adherence to the ABI specification, we should
3909 generate a R_MIPS_64 relocation record by itself before the
3910 _REL32/_64 record as well, such that the addend is read in as
3911 a 64-bit value (REL32 is a 32-bit relocation, after all).
3912 However, since none of the existing ELF64 MIPS dynamic
3913 loaders seems to care, we don't waste space with these
3914 artificial relocations. If this turns out to not be true,
3915 mips_elf_allocate_dynamic_relocation() should be tweaked so
3916 as to make room for a pair of dynamic relocations per
3917 invocation if ABI_64_P, and here we should generate an
3918 additional relocation record with R_MIPS_64 by itself for a
3919 NULL symbol before this relocation record. */
3920 outrel
[1].r_info
= ELF_R_INFO (output_bfd
, (unsigned long) 0,
3921 ABI_64_P (output_bfd
)
3924 outrel
[2].r_info
= ELF_R_INFO (output_bfd
, (unsigned long) 0,
3927 /* Adjust the output offset of the relocation to reference the
3928 correct location in the output file. */
3929 outrel
[0].r_offset
+= (input_section
->output_section
->vma
3930 + input_section
->output_offset
);
3931 outrel
[1].r_offset
+= (input_section
->output_section
->vma
3932 + input_section
->output_offset
);
3933 outrel
[2].r_offset
+= (input_section
->output_section
->vma
3934 + input_section
->output_offset
);
3937 /* Put the relocation back out. We have to use the special
3938 relocation outputter in the 64-bit case since the 64-bit
3939 relocation format is non-standard. */
3940 if (ABI_64_P (output_bfd
))
3942 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
3943 (output_bfd
, &outrel
[0],
3945 + sreloc
->reloc_count
* sizeof (Elf64_Mips_External_Rel
)));
3948 bfd_elf32_swap_reloc_out
3949 (output_bfd
, &outrel
[0],
3950 (sreloc
->contents
+ sreloc
->reloc_count
* sizeof (Elf32_External_Rel
)));
3952 /* We've now added another relocation. */
3953 ++sreloc
->reloc_count
;
3955 /* Make sure the output section is writable. The dynamic linker
3956 will be writing to it. */
3957 elf_section_data (input_section
->output_section
)->this_hdr
.sh_flags
3960 /* On IRIX5, make an entry of compact relocation info. */
3961 if (! skip
&& IRIX_COMPAT (output_bfd
) == ict_irix5
)
3963 asection
*scpt
= bfd_get_section_by_name (dynobj
, ".compact_rel");
3968 Elf32_crinfo cptrel
;
3970 mips_elf_set_cr_format (cptrel
, CRF_MIPS_LONG
);
3971 cptrel
.vaddr
= (rel
->r_offset
3972 + input_section
->output_section
->vma
3973 + input_section
->output_offset
);
3974 if (r_type
== R_MIPS_REL32
)
3975 mips_elf_set_cr_type (cptrel
, CRT_MIPS_REL32
);
3977 mips_elf_set_cr_type (cptrel
, CRT_MIPS_WORD
);
3978 mips_elf_set_cr_dist2to (cptrel
, 0);
3979 cptrel
.konst
= *addendp
;
3981 cr
= (scpt
->contents
3982 + sizeof (Elf32_External_compact_rel
));
3983 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
3984 ((Elf32_External_crinfo
*) cr
3985 + scpt
->reloc_count
));
3986 ++scpt
->reloc_count
;
3993 /* Return the MACH for a MIPS e_flags value. */
3996 _bfd_elf_mips_mach (flags
)
3999 switch (flags
& EF_MIPS_MACH
)
4001 case E_MIPS_MACH_3900
:
4002 return bfd_mach_mips3900
;
4004 case E_MIPS_MACH_4010
:
4005 return bfd_mach_mips4010
;
4007 case E_MIPS_MACH_4100
:
4008 return bfd_mach_mips4100
;
4010 case E_MIPS_MACH_4111
:
4011 return bfd_mach_mips4111
;
4013 case E_MIPS_MACH_4120
:
4014 return bfd_mach_mips4120
;
4016 case E_MIPS_MACH_4650
:
4017 return bfd_mach_mips4650
;
4019 case E_MIPS_MACH_5400
:
4020 return bfd_mach_mips5400
;
4022 case E_MIPS_MACH_5500
:
4023 return bfd_mach_mips5500
;
4025 case E_MIPS_MACH_SB1
:
4026 return bfd_mach_mips_sb1
;
4029 switch (flags
& EF_MIPS_ARCH
)
4033 return bfd_mach_mips3000
;
4037 return bfd_mach_mips6000
;
4041 return bfd_mach_mips4000
;
4045 return bfd_mach_mips8000
;
4049 return bfd_mach_mips5
;
4052 case E_MIPS_ARCH_32
:
4053 return bfd_mach_mipsisa32
;
4056 case E_MIPS_ARCH_64
:
4057 return bfd_mach_mipsisa64
;
4060 case E_MIPS_ARCH_32R2
:
4061 return bfd_mach_mipsisa32r2
;
4064 case E_MIPS_ARCH_64R2
:
4065 return bfd_mach_mipsisa64r2
;
4073 /* Return printable name for ABI. */
4075 static INLINE
char *
4076 elf_mips_abi_name (abfd
)
4081 flags
= elf_elfheader (abfd
)->e_flags
;
4082 switch (flags
& EF_MIPS_ABI
)
4085 if (ABI_N32_P (abfd
))
4087 else if (ABI_64_P (abfd
))
4091 case E_MIPS_ABI_O32
:
4093 case E_MIPS_ABI_O64
:
4095 case E_MIPS_ABI_EABI32
:
4097 case E_MIPS_ABI_EABI64
:
4100 return "unknown abi";
4104 /* MIPS ELF uses two common sections. One is the usual one, and the
4105 other is for small objects. All the small objects are kept
4106 together, and then referenced via the gp pointer, which yields
4107 faster assembler code. This is what we use for the small common
4108 section. This approach is copied from ecoff.c. */
4109 static asection mips_elf_scom_section
;
4110 static asymbol mips_elf_scom_symbol
;
4111 static asymbol
*mips_elf_scom_symbol_ptr
;
4113 /* MIPS ELF also uses an acommon section, which represents an
4114 allocated common symbol which may be overridden by a
4115 definition in a shared library. */
4116 static asection mips_elf_acom_section
;
4117 static asymbol mips_elf_acom_symbol
;
4118 static asymbol
*mips_elf_acom_symbol_ptr
;
4120 /* Handle the special MIPS section numbers that a symbol may use.
4121 This is used for both the 32-bit and the 64-bit ABI. */
4124 _bfd_mips_elf_symbol_processing (abfd
, asym
)
4128 elf_symbol_type
*elfsym
;
4130 elfsym
= (elf_symbol_type
*) asym
;
4131 switch (elfsym
->internal_elf_sym
.st_shndx
)
4133 case SHN_MIPS_ACOMMON
:
4134 /* This section is used in a dynamically linked executable file.
4135 It is an allocated common section. The dynamic linker can
4136 either resolve these symbols to something in a shared
4137 library, or it can just leave them here. For our purposes,
4138 we can consider these symbols to be in a new section. */
4139 if (mips_elf_acom_section
.name
== NULL
)
4141 /* Initialize the acommon section. */
4142 mips_elf_acom_section
.name
= ".acommon";
4143 mips_elf_acom_section
.flags
= SEC_ALLOC
;
4144 mips_elf_acom_section
.output_section
= &mips_elf_acom_section
;
4145 mips_elf_acom_section
.symbol
= &mips_elf_acom_symbol
;
4146 mips_elf_acom_section
.symbol_ptr_ptr
= &mips_elf_acom_symbol_ptr
;
4147 mips_elf_acom_symbol
.name
= ".acommon";
4148 mips_elf_acom_symbol
.flags
= BSF_SECTION_SYM
;
4149 mips_elf_acom_symbol
.section
= &mips_elf_acom_section
;
4150 mips_elf_acom_symbol_ptr
= &mips_elf_acom_symbol
;
4152 asym
->section
= &mips_elf_acom_section
;
4156 /* Common symbols less than the GP size are automatically
4157 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
4158 if (asym
->value
> elf_gp_size (abfd
)
4159 || IRIX_COMPAT (abfd
) == ict_irix6
)
4162 case SHN_MIPS_SCOMMON
:
4163 if (mips_elf_scom_section
.name
== NULL
)
4165 /* Initialize the small common section. */
4166 mips_elf_scom_section
.name
= ".scommon";
4167 mips_elf_scom_section
.flags
= SEC_IS_COMMON
;
4168 mips_elf_scom_section
.output_section
= &mips_elf_scom_section
;
4169 mips_elf_scom_section
.symbol
= &mips_elf_scom_symbol
;
4170 mips_elf_scom_section
.symbol_ptr_ptr
= &mips_elf_scom_symbol_ptr
;
4171 mips_elf_scom_symbol
.name
= ".scommon";
4172 mips_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
4173 mips_elf_scom_symbol
.section
= &mips_elf_scom_section
;
4174 mips_elf_scom_symbol_ptr
= &mips_elf_scom_symbol
;
4176 asym
->section
= &mips_elf_scom_section
;
4177 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
4180 case SHN_MIPS_SUNDEFINED
:
4181 asym
->section
= bfd_und_section_ptr
;
4184 #if 0 /* for SGI_COMPAT */
4186 asym
->section
= mips_elf_text_section_ptr
;
4190 asym
->section
= mips_elf_data_section_ptr
;
4196 /* Work over a section just before writing it out. This routine is
4197 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
4198 sections that need the SHF_MIPS_GPREL flag by name; there has to be
4202 _bfd_mips_elf_section_processing (abfd
, hdr
)
4204 Elf_Internal_Shdr
*hdr
;
4206 if (hdr
->sh_type
== SHT_MIPS_REGINFO
4207 && hdr
->sh_size
> 0)
4211 BFD_ASSERT (hdr
->sh_size
== sizeof (Elf32_External_RegInfo
));
4212 BFD_ASSERT (hdr
->contents
== NULL
);
4215 hdr
->sh_offset
+ sizeof (Elf32_External_RegInfo
) - 4,
4218 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
4219 if (bfd_bwrite (buf
, (bfd_size_type
) 4, abfd
) != 4)
4223 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
4224 && hdr
->bfd_section
!= NULL
4225 && mips_elf_section_data (hdr
->bfd_section
) != NULL
4226 && mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
!= NULL
)
4228 bfd_byte
*contents
, *l
, *lend
;
4230 /* We stored the section contents in the tdata field in the
4231 set_section_contents routine. We save the section contents
4232 so that we don't have to read them again.
4233 At this point we know that elf_gp is set, so we can look
4234 through the section contents to see if there is an
4235 ODK_REGINFO structure. */
4237 contents
= mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
;
4239 lend
= contents
+ hdr
->sh_size
;
4240 while (l
+ sizeof (Elf_External_Options
) <= lend
)
4242 Elf_Internal_Options intopt
;
4244 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
4246 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
4253 + sizeof (Elf_External_Options
)
4254 + (sizeof (Elf64_External_RegInfo
) - 8)),
4257 H_PUT_64 (abfd
, elf_gp (abfd
), buf
);
4258 if (bfd_bwrite (buf
, (bfd_size_type
) 8, abfd
) != 8)
4261 else if (intopt
.kind
== ODK_REGINFO
)
4268 + sizeof (Elf_External_Options
)
4269 + (sizeof (Elf32_External_RegInfo
) - 4)),
4272 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
4273 if (bfd_bwrite (buf
, (bfd_size_type
) 4, abfd
) != 4)
4280 if (hdr
->bfd_section
!= NULL
)
4282 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
4284 if (strcmp (name
, ".sdata") == 0
4285 || strcmp (name
, ".lit8") == 0
4286 || strcmp (name
, ".lit4") == 0)
4288 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
4289 hdr
->sh_type
= SHT_PROGBITS
;
4291 else if (strcmp (name
, ".sbss") == 0)
4293 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
4294 hdr
->sh_type
= SHT_NOBITS
;
4296 else if (strcmp (name
, ".srdata") == 0)
4298 hdr
->sh_flags
|= SHF_ALLOC
| SHF_MIPS_GPREL
;
4299 hdr
->sh_type
= SHT_PROGBITS
;
4301 else if (strcmp (name
, ".compact_rel") == 0)
4304 hdr
->sh_type
= SHT_PROGBITS
;
4306 else if (strcmp (name
, ".rtproc") == 0)
4308 if (hdr
->sh_addralign
!= 0 && hdr
->sh_entsize
== 0)
4310 unsigned int adjust
;
4312 adjust
= hdr
->sh_size
% hdr
->sh_addralign
;
4314 hdr
->sh_size
+= hdr
->sh_addralign
- adjust
;
4322 /* Handle a MIPS specific section when reading an object file. This
4323 is called when elfcode.h finds a section with an unknown type.
4324 This routine supports both the 32-bit and 64-bit ELF ABI.
4326 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
4330 _bfd_mips_elf_section_from_shdr (abfd
, hdr
, name
)
4332 Elf_Internal_Shdr
*hdr
;
4337 /* There ought to be a place to keep ELF backend specific flags, but
4338 at the moment there isn't one. We just keep track of the
4339 sections by their name, instead. Fortunately, the ABI gives
4340 suggested names for all the MIPS specific sections, so we will
4341 probably get away with this. */
4342 switch (hdr
->sh_type
)
4344 case SHT_MIPS_LIBLIST
:
4345 if (strcmp (name
, ".liblist") != 0)
4349 if (strcmp (name
, ".msym") != 0)
4352 case SHT_MIPS_CONFLICT
:
4353 if (strcmp (name
, ".conflict") != 0)
4356 case SHT_MIPS_GPTAB
:
4357 if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) != 0)
4360 case SHT_MIPS_UCODE
:
4361 if (strcmp (name
, ".ucode") != 0)
4364 case SHT_MIPS_DEBUG
:
4365 if (strcmp (name
, ".mdebug") != 0)
4367 flags
= SEC_DEBUGGING
;
4369 case SHT_MIPS_REGINFO
:
4370 if (strcmp (name
, ".reginfo") != 0
4371 || hdr
->sh_size
!= sizeof (Elf32_External_RegInfo
))
4373 flags
= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_SIZE
);
4375 case SHT_MIPS_IFACE
:
4376 if (strcmp (name
, ".MIPS.interfaces") != 0)
4379 case SHT_MIPS_CONTENT
:
4380 if (strncmp (name
, ".MIPS.content", sizeof ".MIPS.content" - 1) != 0)
4383 case SHT_MIPS_OPTIONS
:
4384 if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) != 0)
4387 case SHT_MIPS_DWARF
:
4388 if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) != 0)
4391 case SHT_MIPS_SYMBOL_LIB
:
4392 if (strcmp (name
, ".MIPS.symlib") != 0)
4395 case SHT_MIPS_EVENTS
:
4396 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) != 0
4397 && strncmp (name
, ".MIPS.post_rel",
4398 sizeof ".MIPS.post_rel" - 1) != 0)
4405 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
4410 if (! bfd_set_section_flags (abfd
, hdr
->bfd_section
,
4411 (bfd_get_section_flags (abfd
,
4417 /* FIXME: We should record sh_info for a .gptab section. */
4419 /* For a .reginfo section, set the gp value in the tdata information
4420 from the contents of this section. We need the gp value while
4421 processing relocs, so we just get it now. The .reginfo section
4422 is not used in the 64-bit MIPS ELF ABI. */
4423 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
4425 Elf32_External_RegInfo ext
;
4428 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, (PTR
) &ext
,
4430 (bfd_size_type
) sizeof ext
))
4432 bfd_mips_elf32_swap_reginfo_in (abfd
, &ext
, &s
);
4433 elf_gp (abfd
) = s
.ri_gp_value
;
4436 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
4437 set the gp value based on what we find. We may see both
4438 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
4439 they should agree. */
4440 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
)
4442 bfd_byte
*contents
, *l
, *lend
;
4444 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
4445 if (contents
== NULL
)
4447 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
,
4448 (file_ptr
) 0, hdr
->sh_size
))
4454 lend
= contents
+ hdr
->sh_size
;
4455 while (l
+ sizeof (Elf_External_Options
) <= lend
)
4457 Elf_Internal_Options intopt
;
4459 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
4461 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
4463 Elf64_Internal_RegInfo intreg
;
4465 bfd_mips_elf64_swap_reginfo_in
4467 ((Elf64_External_RegInfo
*)
4468 (l
+ sizeof (Elf_External_Options
))),
4470 elf_gp (abfd
) = intreg
.ri_gp_value
;
4472 else if (intopt
.kind
== ODK_REGINFO
)
4474 Elf32_RegInfo intreg
;
4476 bfd_mips_elf32_swap_reginfo_in
4478 ((Elf32_External_RegInfo
*)
4479 (l
+ sizeof (Elf_External_Options
))),
4481 elf_gp (abfd
) = intreg
.ri_gp_value
;
4491 /* Set the correct type for a MIPS ELF section. We do this by the
4492 section name, which is a hack, but ought to work. This routine is
4493 used by both the 32-bit and the 64-bit ABI. */
4496 _bfd_mips_elf_fake_sections (abfd
, hdr
, sec
)
4498 Elf_Internal_Shdr
*hdr
;
4501 register const char *name
;
4503 name
= bfd_get_section_name (abfd
, sec
);
4505 if (strcmp (name
, ".liblist") == 0)
4507 hdr
->sh_type
= SHT_MIPS_LIBLIST
;
4508 hdr
->sh_info
= sec
->_raw_size
/ sizeof (Elf32_Lib
);
4509 /* The sh_link field is set in final_write_processing. */
4511 else if (strcmp (name
, ".conflict") == 0)
4512 hdr
->sh_type
= SHT_MIPS_CONFLICT
;
4513 else if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0)
4515 hdr
->sh_type
= SHT_MIPS_GPTAB
;
4516 hdr
->sh_entsize
= sizeof (Elf32_External_gptab
);
4517 /* The sh_info field is set in final_write_processing. */
4519 else if (strcmp (name
, ".ucode") == 0)
4520 hdr
->sh_type
= SHT_MIPS_UCODE
;
4521 else if (strcmp (name
, ".mdebug") == 0)
4523 hdr
->sh_type
= SHT_MIPS_DEBUG
;
4524 /* In a shared object on IRIX 5.3, the .mdebug section has an
4525 entsize of 0. FIXME: Does this matter? */
4526 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
4527 hdr
->sh_entsize
= 0;
4529 hdr
->sh_entsize
= 1;
4531 else if (strcmp (name
, ".reginfo") == 0)
4533 hdr
->sh_type
= SHT_MIPS_REGINFO
;
4534 /* In a shared object on IRIX 5.3, the .reginfo section has an
4535 entsize of 0x18. FIXME: Does this matter? */
4536 if (SGI_COMPAT (abfd
))
4538 if ((abfd
->flags
& DYNAMIC
) != 0)
4539 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
4541 hdr
->sh_entsize
= 1;
4544 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
4546 else if (SGI_COMPAT (abfd
)
4547 && (strcmp (name
, ".hash") == 0
4548 || strcmp (name
, ".dynamic") == 0
4549 || strcmp (name
, ".dynstr") == 0))
4551 if (SGI_COMPAT (abfd
))
4552 hdr
->sh_entsize
= 0;
4554 /* This isn't how the IRIX6 linker behaves. */
4555 hdr
->sh_info
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
4558 else if (strcmp (name
, ".got") == 0
4559 || strcmp (name
, ".srdata") == 0
4560 || strcmp (name
, ".sdata") == 0
4561 || strcmp (name
, ".sbss") == 0
4562 || strcmp (name
, ".lit4") == 0
4563 || strcmp (name
, ".lit8") == 0)
4564 hdr
->sh_flags
|= SHF_MIPS_GPREL
;
4565 else if (strcmp (name
, ".MIPS.interfaces") == 0)
4567 hdr
->sh_type
= SHT_MIPS_IFACE
;
4568 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4570 else if (strncmp (name
, ".MIPS.content", strlen (".MIPS.content")) == 0)
4572 hdr
->sh_type
= SHT_MIPS_CONTENT
;
4573 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4574 /* The sh_info field is set in final_write_processing. */
4576 else if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
4578 hdr
->sh_type
= SHT_MIPS_OPTIONS
;
4579 hdr
->sh_entsize
= 1;
4580 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4582 else if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) == 0)
4583 hdr
->sh_type
= SHT_MIPS_DWARF
;
4584 else if (strcmp (name
, ".MIPS.symlib") == 0)
4586 hdr
->sh_type
= SHT_MIPS_SYMBOL_LIB
;
4587 /* The sh_link and sh_info fields are set in
4588 final_write_processing. */
4590 else if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0
4591 || strncmp (name
, ".MIPS.post_rel",
4592 sizeof ".MIPS.post_rel" - 1) == 0)
4594 hdr
->sh_type
= SHT_MIPS_EVENTS
;
4595 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4596 /* The sh_link field is set in final_write_processing. */
4598 else if (strcmp (name
, ".msym") == 0)
4600 hdr
->sh_type
= SHT_MIPS_MSYM
;
4601 hdr
->sh_flags
|= SHF_ALLOC
;
4602 hdr
->sh_entsize
= 8;
4605 /* The generic elf_fake_sections will set up REL_HDR using the default
4606 kind of relocations. We used to set up a second header for the
4607 non-default kind of relocations here, but only NewABI would use
4608 these, and the IRIX ld doesn't like resulting empty RELA sections.
4609 Thus we create those header only on demand now. */
4614 /* Given a BFD section, try to locate the corresponding ELF section
4615 index. This is used by both the 32-bit and the 64-bit ABI.
4616 Actually, it's not clear to me that the 64-bit ABI supports these,
4617 but for non-PIC objects we will certainly want support for at least
4618 the .scommon section. */
4621 _bfd_mips_elf_section_from_bfd_section (abfd
, sec
, retval
)
4622 bfd
*abfd ATTRIBUTE_UNUSED
;
4626 if (strcmp (bfd_get_section_name (abfd
, sec
), ".scommon") == 0)
4628 *retval
= SHN_MIPS_SCOMMON
;
4631 if (strcmp (bfd_get_section_name (abfd
, sec
), ".acommon") == 0)
4633 *retval
= SHN_MIPS_ACOMMON
;
4639 /* Hook called by the linker routine which adds symbols from an object
4640 file. We must handle the special MIPS section numbers here. */
4643 _bfd_mips_elf_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
, secp
, valp
)
4645 struct bfd_link_info
*info
;
4646 const Elf_Internal_Sym
*sym
;
4648 flagword
*flagsp ATTRIBUTE_UNUSED
;
4652 if (SGI_COMPAT (abfd
)
4653 && (abfd
->flags
& DYNAMIC
) != 0
4654 && strcmp (*namep
, "_rld_new_interface") == 0)
4656 /* Skip IRIX5 rld entry name. */
4661 switch (sym
->st_shndx
)
4664 /* Common symbols less than the GP size are automatically
4665 treated as SHN_MIPS_SCOMMON symbols. */
4666 if (sym
->st_size
> elf_gp_size (abfd
)
4667 || IRIX_COMPAT (abfd
) == ict_irix6
)
4670 case SHN_MIPS_SCOMMON
:
4671 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
4672 (*secp
)->flags
|= SEC_IS_COMMON
;
4673 *valp
= sym
->st_size
;
4677 /* This section is used in a shared object. */
4678 if (elf_tdata (abfd
)->elf_text_section
== NULL
)
4680 asymbol
*elf_text_symbol
;
4681 asection
*elf_text_section
;
4682 bfd_size_type amt
= sizeof (asection
);
4684 elf_text_section
= bfd_zalloc (abfd
, amt
);
4685 if (elf_text_section
== NULL
)
4688 amt
= sizeof (asymbol
);
4689 elf_text_symbol
= bfd_zalloc (abfd
, amt
);
4690 if (elf_text_symbol
== NULL
)
4693 /* Initialize the section. */
4695 elf_tdata (abfd
)->elf_text_section
= elf_text_section
;
4696 elf_tdata (abfd
)->elf_text_symbol
= elf_text_symbol
;
4698 elf_text_section
->symbol
= elf_text_symbol
;
4699 elf_text_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_text_symbol
;
4701 elf_text_section
->name
= ".text";
4702 elf_text_section
->flags
= SEC_NO_FLAGS
;
4703 elf_text_section
->output_section
= NULL
;
4704 elf_text_section
->owner
= abfd
;
4705 elf_text_symbol
->name
= ".text";
4706 elf_text_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
4707 elf_text_symbol
->section
= elf_text_section
;
4709 /* This code used to do *secp = bfd_und_section_ptr if
4710 info->shared. I don't know why, and that doesn't make sense,
4711 so I took it out. */
4712 *secp
= elf_tdata (abfd
)->elf_text_section
;
4715 case SHN_MIPS_ACOMMON
:
4716 /* Fall through. XXX Can we treat this as allocated data? */
4718 /* This section is used in a shared object. */
4719 if (elf_tdata (abfd
)->elf_data_section
== NULL
)
4721 asymbol
*elf_data_symbol
;
4722 asection
*elf_data_section
;
4723 bfd_size_type amt
= sizeof (asection
);
4725 elf_data_section
= bfd_zalloc (abfd
, amt
);
4726 if (elf_data_section
== NULL
)
4729 amt
= sizeof (asymbol
);
4730 elf_data_symbol
= bfd_zalloc (abfd
, amt
);
4731 if (elf_data_symbol
== NULL
)
4734 /* Initialize the section. */
4736 elf_tdata (abfd
)->elf_data_section
= elf_data_section
;
4737 elf_tdata (abfd
)->elf_data_symbol
= elf_data_symbol
;
4739 elf_data_section
->symbol
= elf_data_symbol
;
4740 elf_data_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_data_symbol
;
4742 elf_data_section
->name
= ".data";
4743 elf_data_section
->flags
= SEC_NO_FLAGS
;
4744 elf_data_section
->output_section
= NULL
;
4745 elf_data_section
->owner
= abfd
;
4746 elf_data_symbol
->name
= ".data";
4747 elf_data_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
4748 elf_data_symbol
->section
= elf_data_section
;
4750 /* This code used to do *secp = bfd_und_section_ptr if
4751 info->shared. I don't know why, and that doesn't make sense,
4752 so I took it out. */
4753 *secp
= elf_tdata (abfd
)->elf_data_section
;
4756 case SHN_MIPS_SUNDEFINED
:
4757 *secp
= bfd_und_section_ptr
;
4761 if (SGI_COMPAT (abfd
)
4763 && info
->hash
->creator
== abfd
->xvec
4764 && strcmp (*namep
, "__rld_obj_head") == 0)
4766 struct elf_link_hash_entry
*h
;
4767 struct bfd_link_hash_entry
*bh
;
4769 /* Mark __rld_obj_head as dynamic. */
4771 if (! (_bfd_generic_link_add_one_symbol
4772 (info
, abfd
, *namep
, BSF_GLOBAL
, *secp
,
4773 (bfd_vma
) *valp
, (const char *) NULL
, FALSE
,
4774 get_elf_backend_data (abfd
)->collect
, &bh
)))
4777 h
= (struct elf_link_hash_entry
*) bh
;
4778 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
4779 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4780 h
->type
= STT_OBJECT
;
4782 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
4785 mips_elf_hash_table (info
)->use_rld_obj_head
= TRUE
;
4788 /* If this is a mips16 text symbol, add 1 to the value to make it
4789 odd. This will cause something like .word SYM to come up with
4790 the right value when it is loaded into the PC. */
4791 if (sym
->st_other
== STO_MIPS16
)
4797 /* This hook function is called before the linker writes out a global
4798 symbol. We mark symbols as small common if appropriate. This is
4799 also where we undo the increment of the value for a mips16 symbol. */
4802 _bfd_mips_elf_link_output_symbol_hook (abfd
, info
, name
, sym
, input_sec
)
4803 bfd
*abfd ATTRIBUTE_UNUSED
;
4804 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
4805 const char *name ATTRIBUTE_UNUSED
;
4806 Elf_Internal_Sym
*sym
;
4807 asection
*input_sec
;
4809 /* If we see a common symbol, which implies a relocatable link, then
4810 if a symbol was small common in an input file, mark it as small
4811 common in the output file. */
4812 if (sym
->st_shndx
== SHN_COMMON
4813 && strcmp (input_sec
->name
, ".scommon") == 0)
4814 sym
->st_shndx
= SHN_MIPS_SCOMMON
;
4816 if (sym
->st_other
== STO_MIPS16
4817 && (sym
->st_value
& 1) != 0)
4823 /* Functions for the dynamic linker. */
4825 /* Create dynamic sections when linking against a dynamic object. */
4828 _bfd_mips_elf_create_dynamic_sections (abfd
, info
)
4830 struct bfd_link_info
*info
;
4832 struct elf_link_hash_entry
*h
;
4833 struct bfd_link_hash_entry
*bh
;
4835 register asection
*s
;
4836 const char * const *namep
;
4838 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
4839 | SEC_LINKER_CREATED
| SEC_READONLY
);
4841 /* Mips ABI requests the .dynamic section to be read only. */
4842 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4845 if (! bfd_set_section_flags (abfd
, s
, flags
))
4849 /* We need to create .got section. */
4850 if (! mips_elf_create_got_section (abfd
, info
, FALSE
))
4853 if (! mips_elf_rel_dyn_section (elf_hash_table (info
)->dynobj
, TRUE
))
4856 /* Create .stub section. */
4857 if (bfd_get_section_by_name (abfd
,
4858 MIPS_ELF_STUB_SECTION_NAME (abfd
)) == NULL
)
4860 s
= bfd_make_section (abfd
, MIPS_ELF_STUB_SECTION_NAME (abfd
));
4862 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_CODE
)
4863 || ! bfd_set_section_alignment (abfd
, s
,
4864 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
4868 if ((IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
4870 && bfd_get_section_by_name (abfd
, ".rld_map") == NULL
)
4872 s
= bfd_make_section (abfd
, ".rld_map");
4874 || ! bfd_set_section_flags (abfd
, s
, flags
&~ (flagword
) SEC_READONLY
)
4875 || ! bfd_set_section_alignment (abfd
, s
,
4876 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
4880 /* On IRIX5, we adjust add some additional symbols and change the
4881 alignments of several sections. There is no ABI documentation
4882 indicating that this is necessary on IRIX6, nor any evidence that
4883 the linker takes such action. */
4884 if (IRIX_COMPAT (abfd
) == ict_irix5
)
4886 for (namep
= mips_elf_dynsym_rtproc_names
; *namep
!= NULL
; namep
++)
4889 if (! (_bfd_generic_link_add_one_symbol
4890 (info
, abfd
, *namep
, BSF_GLOBAL
, bfd_und_section_ptr
,
4891 (bfd_vma
) 0, (const char *) NULL
, FALSE
,
4892 get_elf_backend_data (abfd
)->collect
, &bh
)))
4895 h
= (struct elf_link_hash_entry
*) bh
;
4896 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
4897 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4898 h
->type
= STT_SECTION
;
4900 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
4904 /* We need to create a .compact_rel section. */
4905 if (SGI_COMPAT (abfd
))
4907 if (!mips_elf_create_compact_rel_section (abfd
, info
))
4911 /* Change alignments of some sections. */
4912 s
= bfd_get_section_by_name (abfd
, ".hash");
4914 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4915 s
= bfd_get_section_by_name (abfd
, ".dynsym");
4917 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4918 s
= bfd_get_section_by_name (abfd
, ".dynstr");
4920 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4921 s
= bfd_get_section_by_name (abfd
, ".reginfo");
4923 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4924 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4926 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4933 name
= SGI_COMPAT (abfd
) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
4935 if (!(_bfd_generic_link_add_one_symbol
4936 (info
, abfd
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
,
4937 (bfd_vma
) 0, (const char *) NULL
, FALSE
,
4938 get_elf_backend_data (abfd
)->collect
, &bh
)))
4941 h
= (struct elf_link_hash_entry
*) bh
;
4942 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
4943 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4944 h
->type
= STT_SECTION
;
4946 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
4949 if (! mips_elf_hash_table (info
)->use_rld_obj_head
)
4951 /* __rld_map is a four byte word located in the .data section
4952 and is filled in by the rtld to contain a pointer to
4953 the _r_debug structure. Its symbol value will be set in
4954 _bfd_mips_elf_finish_dynamic_symbol. */
4955 s
= bfd_get_section_by_name (abfd
, ".rld_map");
4956 BFD_ASSERT (s
!= NULL
);
4958 name
= SGI_COMPAT (abfd
) ? "__rld_map" : "__RLD_MAP";
4960 if (!(_bfd_generic_link_add_one_symbol
4961 (info
, abfd
, name
, BSF_GLOBAL
, s
,
4962 (bfd_vma
) 0, (const char *) NULL
, FALSE
,
4963 get_elf_backend_data (abfd
)->collect
, &bh
)))
4966 h
= (struct elf_link_hash_entry
*) bh
;
4967 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
4968 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4969 h
->type
= STT_OBJECT
;
4971 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
4979 /* Look through the relocs for a section during the first phase, and
4980 allocate space in the global offset table. */
4983 _bfd_mips_elf_check_relocs (abfd
, info
, sec
, relocs
)
4985 struct bfd_link_info
*info
;
4987 const Elf_Internal_Rela
*relocs
;
4991 Elf_Internal_Shdr
*symtab_hdr
;
4992 struct elf_link_hash_entry
**sym_hashes
;
4993 struct mips_got_info
*g
;
4995 const Elf_Internal_Rela
*rel
;
4996 const Elf_Internal_Rela
*rel_end
;
4999 const struct elf_backend_data
*bed
;
5001 if (info
->relocatable
)
5004 dynobj
= elf_hash_table (info
)->dynobj
;
5005 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5006 sym_hashes
= elf_sym_hashes (abfd
);
5007 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
5009 /* Check for the mips16 stub sections. */
5011 name
= bfd_get_section_name (abfd
, sec
);
5012 if (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0)
5014 unsigned long r_symndx
;
5016 /* Look at the relocation information to figure out which symbol
5019 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
5021 if (r_symndx
< extsymoff
5022 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
5026 /* This stub is for a local symbol. This stub will only be
5027 needed if there is some relocation in this BFD, other
5028 than a 16 bit function call, which refers to this symbol. */
5029 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5031 Elf_Internal_Rela
*sec_relocs
;
5032 const Elf_Internal_Rela
*r
, *rend
;
5034 /* We can ignore stub sections when looking for relocs. */
5035 if ((o
->flags
& SEC_RELOC
) == 0
5036 || o
->reloc_count
== 0
5037 || strncmp (bfd_get_section_name (abfd
, o
), FN_STUB
,
5038 sizeof FN_STUB
- 1) == 0
5039 || strncmp (bfd_get_section_name (abfd
, o
), CALL_STUB
,
5040 sizeof CALL_STUB
- 1) == 0
5041 || strncmp (bfd_get_section_name (abfd
, o
), CALL_FP_STUB
,
5042 sizeof CALL_FP_STUB
- 1) == 0)
5046 = _bfd_elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
5047 (Elf_Internal_Rela
*) NULL
,
5049 if (sec_relocs
== NULL
)
5052 rend
= sec_relocs
+ o
->reloc_count
;
5053 for (r
= sec_relocs
; r
< rend
; r
++)
5054 if (ELF_R_SYM (abfd
, r
->r_info
) == r_symndx
5055 && ELF_R_TYPE (abfd
, r
->r_info
) != R_MIPS16_26
)
5058 if (elf_section_data (o
)->relocs
!= sec_relocs
)
5067 /* There is no non-call reloc for this stub, so we do
5068 not need it. Since this function is called before
5069 the linker maps input sections to output sections, we
5070 can easily discard it by setting the SEC_EXCLUDE
5072 sec
->flags
|= SEC_EXCLUDE
;
5076 /* Record this stub in an array of local symbol stubs for
5078 if (elf_tdata (abfd
)->local_stubs
== NULL
)
5080 unsigned long symcount
;
5084 if (elf_bad_symtab (abfd
))
5085 symcount
= NUM_SHDR_ENTRIES (symtab_hdr
);
5087 symcount
= symtab_hdr
->sh_info
;
5088 amt
= symcount
* sizeof (asection
*);
5089 n
= (asection
**) bfd_zalloc (abfd
, amt
);
5092 elf_tdata (abfd
)->local_stubs
= n
;
5095 elf_tdata (abfd
)->local_stubs
[r_symndx
] = sec
;
5097 /* We don't need to set mips16_stubs_seen in this case.
5098 That flag is used to see whether we need to look through
5099 the global symbol table for stubs. We don't need to set
5100 it here, because we just have a local stub. */
5104 struct mips_elf_link_hash_entry
*h
;
5106 h
= ((struct mips_elf_link_hash_entry
*)
5107 sym_hashes
[r_symndx
- extsymoff
]);
5109 /* H is the symbol this stub is for. */
5112 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
5115 else if (strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
5116 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
5118 unsigned long r_symndx
;
5119 struct mips_elf_link_hash_entry
*h
;
5122 /* Look at the relocation information to figure out which symbol
5125 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
5127 if (r_symndx
< extsymoff
5128 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
5130 /* This stub was actually built for a static symbol defined
5131 in the same file. We assume that all static symbols in
5132 mips16 code are themselves mips16, so we can simply
5133 discard this stub. Since this function is called before
5134 the linker maps input sections to output sections, we can
5135 easily discard it by setting the SEC_EXCLUDE flag. */
5136 sec
->flags
|= SEC_EXCLUDE
;
5140 h
= ((struct mips_elf_link_hash_entry
*)
5141 sym_hashes
[r_symndx
- extsymoff
]);
5143 /* H is the symbol this stub is for. */
5145 if (strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
5146 loc
= &h
->call_fp_stub
;
5148 loc
= &h
->call_stub
;
5150 /* If we already have an appropriate stub for this function, we
5151 don't need another one, so we can discard this one. Since
5152 this function is called before the linker maps input sections
5153 to output sections, we can easily discard it by setting the
5154 SEC_EXCLUDE flag. We can also discard this section if we
5155 happen to already know that this is a mips16 function; it is
5156 not necessary to check this here, as it is checked later, but
5157 it is slightly faster to check now. */
5158 if (*loc
!= NULL
|| h
->root
.other
== STO_MIPS16
)
5160 sec
->flags
|= SEC_EXCLUDE
;
5165 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
5175 sgot
= mips_elf_got_section (dynobj
, FALSE
);
5180 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
5181 g
= mips_elf_section_data (sgot
)->u
.got_info
;
5182 BFD_ASSERT (g
!= NULL
);
5187 bed
= get_elf_backend_data (abfd
);
5188 rel_end
= relocs
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
5189 for (rel
= relocs
; rel
< rel_end
; ++rel
)
5191 unsigned long r_symndx
;
5192 unsigned int r_type
;
5193 struct elf_link_hash_entry
*h
;
5195 r_symndx
= ELF_R_SYM (abfd
, rel
->r_info
);
5196 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
5198 if (r_symndx
< extsymoff
)
5200 else if (r_symndx
>= extsymoff
+ NUM_SHDR_ENTRIES (symtab_hdr
))
5202 (*_bfd_error_handler
)
5203 (_("%s: Malformed reloc detected for section %s"),
5204 bfd_archive_filename (abfd
), name
);
5205 bfd_set_error (bfd_error_bad_value
);
5210 h
= sym_hashes
[r_symndx
- extsymoff
];
5212 /* This may be an indirect symbol created because of a version. */
5215 while (h
->root
.type
== bfd_link_hash_indirect
)
5216 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5220 /* Some relocs require a global offset table. */
5221 if (dynobj
== NULL
|| sgot
== NULL
)
5227 case R_MIPS_CALL_HI16
:
5228 case R_MIPS_CALL_LO16
:
5229 case R_MIPS_GOT_HI16
:
5230 case R_MIPS_GOT_LO16
:
5231 case R_MIPS_GOT_PAGE
:
5232 case R_MIPS_GOT_OFST
:
5233 case R_MIPS_GOT_DISP
:
5235 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5236 if (! mips_elf_create_got_section (dynobj
, info
, FALSE
))
5238 g
= mips_elf_got_info (dynobj
, &sgot
);
5245 && (info
->shared
|| h
!= NULL
)
5246 && (sec
->flags
& SEC_ALLOC
) != 0)
5247 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5255 if (!h
&& (r_type
== R_MIPS_CALL_LO16
5256 || r_type
== R_MIPS_GOT_LO16
5257 || r_type
== R_MIPS_GOT_DISP
))
5259 /* We may need a local GOT entry for this relocation. We
5260 don't count R_MIPS_GOT_PAGE because we can estimate the
5261 maximum number of pages needed by looking at the size of
5262 the segment. Similar comments apply to R_MIPS_GOT16 and
5263 R_MIPS_CALL16. We don't count R_MIPS_GOT_HI16, or
5264 R_MIPS_CALL_HI16 because these are always followed by an
5265 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
5266 if (! mips_elf_record_local_got_symbol (abfd
, r_symndx
,
5276 (*_bfd_error_handler
)
5277 (_("%s: CALL16 reloc at 0x%lx not against global symbol"),
5278 bfd_archive_filename (abfd
), (unsigned long) rel
->r_offset
);
5279 bfd_set_error (bfd_error_bad_value
);
5284 case R_MIPS_CALL_HI16
:
5285 case R_MIPS_CALL_LO16
:
5288 /* This symbol requires a global offset table entry. */
5289 if (! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5292 /* We need a stub, not a plt entry for the undefined
5293 function. But we record it as if it needs plt. See
5294 elf_adjust_dynamic_symbol in elflink.h. */
5295 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
5300 case R_MIPS_GOT_PAGE
:
5301 /* If this is a global, overridable symbol, GOT_PAGE will
5302 decay to GOT_DISP, so we'll need a GOT entry for it. */
5307 struct mips_elf_link_hash_entry
*hmips
=
5308 (struct mips_elf_link_hash_entry
*) h
;
5310 while (hmips
->root
.root
.type
== bfd_link_hash_indirect
5311 || hmips
->root
.root
.type
== bfd_link_hash_warning
)
5312 hmips
= (struct mips_elf_link_hash_entry
*)
5313 hmips
->root
.root
.u
.i
.link
;
5315 if ((hmips
->root
.root
.type
== bfd_link_hash_defined
5316 || hmips
->root
.root
.type
== bfd_link_hash_defweak
)
5317 && hmips
->root
.root
.u
.def
.section
5318 && ! (info
->shared
&& ! info
->symbolic
5319 && ! (hmips
->root
.elf_link_hash_flags
5320 & ELF_LINK_FORCED_LOCAL
))
5321 /* If we've encountered any other relocation
5322 referencing the symbol, we'll have marked it as
5323 dynamic, and, even though we might be able to get
5324 rid of the GOT entry should we know for sure all
5325 previous relocations were GOT_PAGE ones, at this
5326 point we can't tell, so just keep using the
5327 symbol as dynamic. This is very important in the
5328 multi-got case, since we don't decide whether to
5329 decay GOT_PAGE to GOT_DISP on a per-GOT basis: if
5330 the symbol is dynamic, we'll need a GOT entry for
5331 every GOT in which the symbol is referenced with
5332 a GOT_PAGE relocation. */
5333 && hmips
->root
.dynindx
== -1)
5339 case R_MIPS_GOT_HI16
:
5340 case R_MIPS_GOT_LO16
:
5341 case R_MIPS_GOT_DISP
:
5342 /* This symbol requires a global offset table entry. */
5343 if (h
&& ! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5350 if ((info
->shared
|| h
!= NULL
)
5351 && (sec
->flags
& SEC_ALLOC
) != 0)
5355 sreloc
= mips_elf_rel_dyn_section (dynobj
, TRUE
);
5359 #define MIPS_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
5362 /* When creating a shared object, we must copy these
5363 reloc types into the output file as R_MIPS_REL32
5364 relocs. We make room for this reloc in the
5365 .rel.dyn reloc section. */
5366 mips_elf_allocate_dynamic_relocations (dynobj
, 1);
5367 if ((sec
->flags
& MIPS_READONLY_SECTION
)
5368 == MIPS_READONLY_SECTION
)
5369 /* We tell the dynamic linker that there are
5370 relocations against the text segment. */
5371 info
->flags
|= DF_TEXTREL
;
5375 struct mips_elf_link_hash_entry
*hmips
;
5377 /* We only need to copy this reloc if the symbol is
5378 defined in a dynamic object. */
5379 hmips
= (struct mips_elf_link_hash_entry
*) h
;
5380 ++hmips
->possibly_dynamic_relocs
;
5381 if ((sec
->flags
& MIPS_READONLY_SECTION
)
5382 == MIPS_READONLY_SECTION
)
5383 /* We need it to tell the dynamic linker if there
5384 are relocations against the text segment. */
5385 hmips
->readonly_reloc
= TRUE
;
5388 /* Even though we don't directly need a GOT entry for
5389 this symbol, a symbol must have a dynamic symbol
5390 table index greater that DT_MIPS_GOTSYM if there are
5391 dynamic relocations against it. */
5395 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5396 if (! mips_elf_create_got_section (dynobj
, info
, TRUE
))
5398 g
= mips_elf_got_info (dynobj
, &sgot
);
5399 if (! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5404 if (SGI_COMPAT (abfd
))
5405 mips_elf_hash_table (info
)->compact_rel_size
+=
5406 sizeof (Elf32_External_crinfo
);
5410 case R_MIPS_GPREL16
:
5411 case R_MIPS_LITERAL
:
5412 case R_MIPS_GPREL32
:
5413 if (SGI_COMPAT (abfd
))
5414 mips_elf_hash_table (info
)->compact_rel_size
+=
5415 sizeof (Elf32_External_crinfo
);
5418 /* This relocation describes the C++ object vtable hierarchy.
5419 Reconstruct it for later use during GC. */
5420 case R_MIPS_GNU_VTINHERIT
:
5421 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
5425 /* This relocation describes which C++ vtable entries are actually
5426 used. Record for later use during GC. */
5427 case R_MIPS_GNU_VTENTRY
:
5428 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
5436 /* We must not create a stub for a symbol that has relocations
5437 related to taking the function's address. */
5443 struct mips_elf_link_hash_entry
*mh
;
5445 mh
= (struct mips_elf_link_hash_entry
*) h
;
5446 mh
->no_fn_stub
= TRUE
;
5450 case R_MIPS_CALL_HI16
:
5451 case R_MIPS_CALL_LO16
:
5456 /* If this reloc is not a 16 bit call, and it has a global
5457 symbol, then we will need the fn_stub if there is one.
5458 References from a stub section do not count. */
5460 && r_type
!= R_MIPS16_26
5461 && strncmp (bfd_get_section_name (abfd
, sec
), FN_STUB
,
5462 sizeof FN_STUB
- 1) != 0
5463 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_STUB
,
5464 sizeof CALL_STUB
- 1) != 0
5465 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_FP_STUB
,
5466 sizeof CALL_FP_STUB
- 1) != 0)
5468 struct mips_elf_link_hash_entry
*mh
;
5470 mh
= (struct mips_elf_link_hash_entry
*) h
;
5471 mh
->need_fn_stub
= TRUE
;
5479 _bfd_mips_relax_section (abfd
, sec
, link_info
, again
)
5482 struct bfd_link_info
*link_info
;
5485 Elf_Internal_Rela
*internal_relocs
;
5486 Elf_Internal_Rela
*irel
, *irelend
;
5487 Elf_Internal_Shdr
*symtab_hdr
;
5488 bfd_byte
*contents
= NULL
;
5489 bfd_byte
*free_contents
= NULL
;
5491 bfd_boolean changed_contents
= FALSE
;
5492 bfd_vma sec_start
= sec
->output_section
->vma
+ sec
->output_offset
;
5493 Elf_Internal_Sym
*isymbuf
= NULL
;
5495 /* We are not currently changing any sizes, so only one pass. */
5498 if (link_info
->relocatable
)
5501 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, (PTR
) NULL
,
5502 (Elf_Internal_Rela
*) NULL
,
5503 link_info
->keep_memory
);
5504 if (internal_relocs
== NULL
)
5507 irelend
= internal_relocs
+ sec
->reloc_count
5508 * get_elf_backend_data (abfd
)->s
->int_rels_per_ext_rel
;
5509 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5510 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
5512 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
5515 bfd_signed_vma sym_offset
;
5516 unsigned int r_type
;
5517 unsigned long r_symndx
;
5519 unsigned long instruction
;
5521 /* Turn jalr into bgezal, and jr into beq, if they're marked
5522 with a JALR relocation, that indicate where they jump to.
5523 This saves some pipeline bubbles. */
5524 r_type
= ELF_R_TYPE (abfd
, irel
->r_info
);
5525 if (r_type
!= R_MIPS_JALR
)
5528 r_symndx
= ELF_R_SYM (abfd
, irel
->r_info
);
5529 /* Compute the address of the jump target. */
5530 if (r_symndx
>= extsymoff
)
5532 struct mips_elf_link_hash_entry
*h
5533 = ((struct mips_elf_link_hash_entry
*)
5534 elf_sym_hashes (abfd
) [r_symndx
- extsymoff
]);
5536 while (h
->root
.root
.type
== bfd_link_hash_indirect
5537 || h
->root
.root
.type
== bfd_link_hash_warning
)
5538 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
5540 /* If a symbol is undefined, or if it may be overridden,
5542 if (! ((h
->root
.root
.type
== bfd_link_hash_defined
5543 || h
->root
.root
.type
== bfd_link_hash_defweak
)
5544 && h
->root
.root
.u
.def
.section
)
5545 || (link_info
->shared
&& ! link_info
->symbolic
5546 && ! (h
->root
.elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
)))
5549 sym_sec
= h
->root
.root
.u
.def
.section
;
5550 if (sym_sec
->output_section
)
5551 symval
= (h
->root
.root
.u
.def
.value
5552 + sym_sec
->output_section
->vma
5553 + sym_sec
->output_offset
);
5555 symval
= h
->root
.root
.u
.def
.value
;
5559 Elf_Internal_Sym
*isym
;
5561 /* Read this BFD's symbols if we haven't done so already. */
5562 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
5564 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5565 if (isymbuf
== NULL
)
5566 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
5567 symtab_hdr
->sh_info
, 0,
5569 if (isymbuf
== NULL
)
5573 isym
= isymbuf
+ r_symndx
;
5574 if (isym
->st_shndx
== SHN_UNDEF
)
5576 else if (isym
->st_shndx
== SHN_ABS
)
5577 sym_sec
= bfd_abs_section_ptr
;
5578 else if (isym
->st_shndx
== SHN_COMMON
)
5579 sym_sec
= bfd_com_section_ptr
;
5582 = bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
5583 symval
= isym
->st_value
5584 + sym_sec
->output_section
->vma
5585 + sym_sec
->output_offset
;
5588 /* Compute branch offset, from delay slot of the jump to the
5590 sym_offset
= (symval
+ irel
->r_addend
)
5591 - (sec_start
+ irel
->r_offset
+ 4);
5593 /* Branch offset must be properly aligned. */
5594 if ((sym_offset
& 3) != 0)
5599 /* Check that it's in range. */
5600 if (sym_offset
< -0x8000 || sym_offset
>= 0x8000)
5603 /* Get the section contents if we haven't done so already. */
5604 if (contents
== NULL
)
5606 /* Get cached copy if it exists. */
5607 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
5608 contents
= elf_section_data (sec
)->this_hdr
.contents
;
5611 contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
5612 if (contents
== NULL
)
5615 free_contents
= contents
;
5616 if (! bfd_get_section_contents (abfd
, sec
, contents
,
5617 (file_ptr
) 0, sec
->_raw_size
))
5622 instruction
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
5624 /* If it was jalr <reg>, turn it into bgezal $zero, <target>. */
5625 if ((instruction
& 0xfc1fffff) == 0x0000f809)
5626 instruction
= 0x04110000;
5627 /* If it was jr <reg>, turn it into b <target>. */
5628 else if ((instruction
& 0xfc1fffff) == 0x00000008)
5629 instruction
= 0x10000000;
5633 instruction
|= (sym_offset
& 0xffff);
5634 bfd_put_32 (abfd
, instruction
, contents
+ irel
->r_offset
);
5635 changed_contents
= TRUE
;
5638 if (contents
!= NULL
5639 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
5641 if (!changed_contents
&& !link_info
->keep_memory
)
5645 /* Cache the section contents for elf_link_input_bfd. */
5646 elf_section_data (sec
)->this_hdr
.contents
= contents
;
5652 if (free_contents
!= NULL
)
5653 free (free_contents
);
5657 /* Adjust a symbol defined by a dynamic object and referenced by a
5658 regular object. The current definition is in some section of the
5659 dynamic object, but we're not including those sections. We have to
5660 change the definition to something the rest of the link can
5664 _bfd_mips_elf_adjust_dynamic_symbol (info
, h
)
5665 struct bfd_link_info
*info
;
5666 struct elf_link_hash_entry
*h
;
5669 struct mips_elf_link_hash_entry
*hmips
;
5672 dynobj
= elf_hash_table (info
)->dynobj
;
5674 /* Make sure we know what is going on here. */
5675 BFD_ASSERT (dynobj
!= NULL
5676 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
5677 || h
->weakdef
!= NULL
5678 || ((h
->elf_link_hash_flags
5679 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
5680 && (h
->elf_link_hash_flags
5681 & ELF_LINK_HASH_REF_REGULAR
) != 0
5682 && (h
->elf_link_hash_flags
5683 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
5685 /* If this symbol is defined in a dynamic object, we need to copy
5686 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
5688 hmips
= (struct mips_elf_link_hash_entry
*) h
;
5689 if (! info
->relocatable
5690 && hmips
->possibly_dynamic_relocs
!= 0
5691 && (h
->root
.type
== bfd_link_hash_defweak
5692 || (h
->elf_link_hash_flags
5693 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
5695 mips_elf_allocate_dynamic_relocations (dynobj
,
5696 hmips
->possibly_dynamic_relocs
);
5697 if (hmips
->readonly_reloc
)
5698 /* We tell the dynamic linker that there are relocations
5699 against the text segment. */
5700 info
->flags
|= DF_TEXTREL
;
5703 /* For a function, create a stub, if allowed. */
5704 if (! hmips
->no_fn_stub
5705 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
5707 if (! elf_hash_table (info
)->dynamic_sections_created
)
5710 /* If this symbol is not defined in a regular file, then set
5711 the symbol to the stub location. This is required to make
5712 function pointers compare as equal between the normal
5713 executable and the shared library. */
5714 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
5716 /* We need .stub section. */
5717 s
= bfd_get_section_by_name (dynobj
,
5718 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
5719 BFD_ASSERT (s
!= NULL
);
5721 h
->root
.u
.def
.section
= s
;
5722 h
->root
.u
.def
.value
= s
->_raw_size
;
5724 /* XXX Write this stub address somewhere. */
5725 h
->plt
.offset
= s
->_raw_size
;
5727 /* Make room for this stub code. */
5728 s
->_raw_size
+= MIPS_FUNCTION_STUB_SIZE
;
5730 /* The last half word of the stub will be filled with the index
5731 of this symbol in .dynsym section. */
5735 else if ((h
->type
== STT_FUNC
)
5736 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0)
5738 /* This will set the entry for this symbol in the GOT to 0, and
5739 the dynamic linker will take care of this. */
5740 h
->root
.u
.def
.value
= 0;
5744 /* If this is a weak symbol, and there is a real definition, the
5745 processor independent code will have arranged for us to see the
5746 real definition first, and we can just use the same value. */
5747 if (h
->weakdef
!= NULL
)
5749 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
5750 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
5751 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
5752 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
5756 /* This is a reference to a symbol defined by a dynamic object which
5757 is not a function. */
5762 /* This function is called after all the input files have been read,
5763 and the input sections have been assigned to output sections. We
5764 check for any mips16 stub sections that we can discard. */
5767 _bfd_mips_elf_always_size_sections (output_bfd
, info
)
5769 struct bfd_link_info
*info
;
5775 struct mips_got_info
*g
;
5777 bfd_size_type loadable_size
= 0;
5778 bfd_size_type local_gotno
;
5781 /* The .reginfo section has a fixed size. */
5782 ri
= bfd_get_section_by_name (output_bfd
, ".reginfo");
5784 bfd_set_section_size (output_bfd
, ri
,
5785 (bfd_size_type
) sizeof (Elf32_External_RegInfo
));
5787 if (! (info
->relocatable
5788 || ! mips_elf_hash_table (info
)->mips16_stubs_seen
))
5789 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
5790 mips_elf_check_mips16_stubs
,
5793 dynobj
= elf_hash_table (info
)->dynobj
;
5795 /* Relocatable links don't have it. */
5798 g
= mips_elf_got_info (dynobj
, &s
);
5802 /* Calculate the total loadable size of the output. That
5803 will give us the maximum number of GOT_PAGE entries
5805 for (sub
= info
->input_bfds
; sub
; sub
= sub
->link_next
)
5807 asection
*subsection
;
5809 for (subsection
= sub
->sections
;
5811 subsection
= subsection
->next
)
5813 if ((subsection
->flags
& SEC_ALLOC
) == 0)
5815 loadable_size
+= ((subsection
->_raw_size
+ 0xf)
5816 &~ (bfd_size_type
) 0xf);
5820 /* There has to be a global GOT entry for every symbol with
5821 a dynamic symbol table index of DT_MIPS_GOTSYM or
5822 higher. Therefore, it make sense to put those symbols
5823 that need GOT entries at the end of the symbol table. We
5825 if (! mips_elf_sort_hash_table (info
, 1))
5828 if (g
->global_gotsym
!= NULL
)
5829 i
= elf_hash_table (info
)->dynsymcount
- g
->global_gotsym
->dynindx
;
5831 /* If there are no global symbols, or none requiring
5832 relocations, then GLOBAL_GOTSYM will be NULL. */
5835 /* In the worst case, we'll get one stub per dynamic symbol, plus
5836 one to account for the dummy entry at the end required by IRIX
5838 loadable_size
+= MIPS_FUNCTION_STUB_SIZE
* (i
+ 1);
5840 /* Assume there are two loadable segments consisting of
5841 contiguous sections. Is 5 enough? */
5842 local_gotno
= (loadable_size
>> 16) + 5;
5844 g
->local_gotno
+= local_gotno
;
5845 s
->_raw_size
+= g
->local_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
5847 g
->global_gotno
= i
;
5848 s
->_raw_size
+= i
* MIPS_ELF_GOT_SIZE (output_bfd
);
5850 if (s
->_raw_size
> MIPS_ELF_GOT_MAX_SIZE (output_bfd
)
5851 && ! mips_elf_multi_got (output_bfd
, info
, g
, s
, local_gotno
))
5857 /* Set the sizes of the dynamic sections. */
5860 _bfd_mips_elf_size_dynamic_sections (output_bfd
, info
)
5862 struct bfd_link_info
*info
;
5866 bfd_boolean reltext
;
5868 dynobj
= elf_hash_table (info
)->dynobj
;
5869 BFD_ASSERT (dynobj
!= NULL
);
5871 if (elf_hash_table (info
)->dynamic_sections_created
)
5873 /* Set the contents of the .interp section to the interpreter. */
5876 s
= bfd_get_section_by_name (dynobj
, ".interp");
5877 BFD_ASSERT (s
!= NULL
);
5879 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd
)) + 1;
5881 = (bfd_byte
*) ELF_DYNAMIC_INTERPRETER (output_bfd
);
5885 /* The check_relocs and adjust_dynamic_symbol entry points have
5886 determined the sizes of the various dynamic sections. Allocate
5889 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
5894 /* It's OK to base decisions on the section name, because none
5895 of the dynobj section names depend upon the input files. */
5896 name
= bfd_get_section_name (dynobj
, s
);
5898 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
5903 if (strncmp (name
, ".rel", 4) == 0)
5905 if (s
->_raw_size
== 0)
5907 /* We only strip the section if the output section name
5908 has the same name. Otherwise, there might be several
5909 input sections for this output section. FIXME: This
5910 code is probably not needed these days anyhow, since
5911 the linker now does not create empty output sections. */
5912 if (s
->output_section
!= NULL
5914 bfd_get_section_name (s
->output_section
->owner
,
5915 s
->output_section
)) == 0)
5920 const char *outname
;
5923 /* If this relocation section applies to a read only
5924 section, then we probably need a DT_TEXTREL entry.
5925 If the relocation section is .rel.dyn, we always
5926 assert a DT_TEXTREL entry rather than testing whether
5927 there exists a relocation to a read only section or
5929 outname
= bfd_get_section_name (output_bfd
,
5931 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
5933 && (target
->flags
& SEC_READONLY
) != 0
5934 && (target
->flags
& SEC_ALLOC
) != 0)
5935 || strcmp (outname
, ".rel.dyn") == 0)
5938 /* We use the reloc_count field as a counter if we need
5939 to copy relocs into the output file. */
5940 if (strcmp (name
, ".rel.dyn") != 0)
5943 /* If combreloc is enabled, elf_link_sort_relocs() will
5944 sort relocations, but in a different way than we do,
5945 and before we're done creating relocations. Also, it
5946 will move them around between input sections'
5947 relocation's contents, so our sorting would be
5948 broken, so don't let it run. */
5949 info
->combreloc
= 0;
5952 else if (strncmp (name
, ".got", 4) == 0)
5954 /* _bfd_mips_elf_always_size_sections() has already done
5955 most of the work, but some symbols may have been mapped
5956 to versions that we must now resolve in the got_entries
5958 struct mips_got_info
*gg
= mips_elf_got_info (dynobj
, NULL
);
5959 struct mips_got_info
*g
= gg
;
5960 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
5961 unsigned int needed_relocs
= 0;
5965 set_got_offset_arg
.value
= MIPS_ELF_GOT_SIZE (output_bfd
);
5966 set_got_offset_arg
.info
= info
;
5968 mips_elf_resolve_final_got_entries (gg
);
5969 for (g
= gg
->next
; g
&& g
->next
!= gg
; g
= g
->next
)
5971 unsigned int save_assign
;
5973 mips_elf_resolve_final_got_entries (g
);
5975 /* Assign offsets to global GOT entries. */
5976 save_assign
= g
->assigned_gotno
;
5977 g
->assigned_gotno
= g
->local_gotno
;
5978 set_got_offset_arg
.g
= g
;
5979 set_got_offset_arg
.needed_relocs
= 0;
5980 htab_traverse (g
->got_entries
,
5981 mips_elf_set_global_got_offset
,
5982 &set_got_offset_arg
);
5983 needed_relocs
+= set_got_offset_arg
.needed_relocs
;
5984 BFD_ASSERT (g
->assigned_gotno
- g
->local_gotno
5985 <= g
->global_gotno
);
5987 g
->assigned_gotno
= save_assign
;
5990 needed_relocs
+= g
->local_gotno
- g
->assigned_gotno
;
5991 BFD_ASSERT (g
->assigned_gotno
== g
->next
->local_gotno
5992 + g
->next
->global_gotno
5993 + MIPS_RESERVED_GOTNO
);
5998 mips_elf_allocate_dynamic_relocations (dynobj
, needed_relocs
);
6001 else if (strcmp (name
, MIPS_ELF_STUB_SECTION_NAME (output_bfd
)) == 0)
6003 /* IRIX rld assumes that the function stub isn't at the end
6004 of .text section. So put a dummy. XXX */
6005 s
->_raw_size
+= MIPS_FUNCTION_STUB_SIZE
;
6007 else if (! info
->shared
6008 && ! mips_elf_hash_table (info
)->use_rld_obj_head
6009 && strncmp (name
, ".rld_map", 8) == 0)
6011 /* We add a room for __rld_map. It will be filled in by the
6012 rtld to contain a pointer to the _r_debug structure. */
6015 else if (SGI_COMPAT (output_bfd
)
6016 && strncmp (name
, ".compact_rel", 12) == 0)
6017 s
->_raw_size
+= mips_elf_hash_table (info
)->compact_rel_size
;
6018 else if (strncmp (name
, ".init", 5) != 0)
6020 /* It's not one of our sections, so don't allocate space. */
6026 _bfd_strip_section_from_output (info
, s
);
6030 /* Allocate memory for the section contents. */
6031 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
6032 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
6034 bfd_set_error (bfd_error_no_memory
);
6039 if (elf_hash_table (info
)->dynamic_sections_created
)
6041 /* Add some entries to the .dynamic section. We fill in the
6042 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
6043 must add the entries now so that we get the correct size for
6044 the .dynamic section. The DT_DEBUG entry is filled in by the
6045 dynamic linker and used by the debugger. */
6048 /* SGI object has the equivalence of DT_DEBUG in the
6049 DT_MIPS_RLD_MAP entry. */
6050 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_MAP
, 0))
6052 if (!SGI_COMPAT (output_bfd
))
6054 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
6060 /* Shared libraries on traditional mips have DT_DEBUG. */
6061 if (!SGI_COMPAT (output_bfd
))
6063 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
6068 if (reltext
&& SGI_COMPAT (output_bfd
))
6069 info
->flags
|= DF_TEXTREL
;
6071 if ((info
->flags
& DF_TEXTREL
) != 0)
6073 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_TEXTREL
, 0))
6077 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTGOT
, 0))
6080 if (mips_elf_rel_dyn_section (dynobj
, FALSE
))
6082 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_REL
, 0))
6085 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELSZ
, 0))
6088 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELENT
, 0))
6092 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_VERSION
, 0))
6095 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_FLAGS
, 0))
6099 /* Time stamps in executable files are a bad idea. */
6100 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_TIME_STAMP
, 0))
6105 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_ICHECKSUM
, 0))
6110 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_IVERSION
, 0))
6114 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_BASE_ADDRESS
, 0))
6117 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LOCAL_GOTNO
, 0))
6120 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_SYMTABNO
, 0))
6123 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_UNREFEXTNO
, 0))
6126 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_GOTSYM
, 0))
6129 if (IRIX_COMPAT (dynobj
) == ict_irix5
6130 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_HIPAGENO
, 0))
6133 if (IRIX_COMPAT (dynobj
) == ict_irix6
6134 && (bfd_get_section_by_name
6135 (dynobj
, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj
)))
6136 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_OPTIONS
, 0))
6143 /* Relocate a MIPS ELF section. */
6146 _bfd_mips_elf_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
6147 contents
, relocs
, local_syms
, local_sections
)
6149 struct bfd_link_info
*info
;
6151 asection
*input_section
;
6153 Elf_Internal_Rela
*relocs
;
6154 Elf_Internal_Sym
*local_syms
;
6155 asection
**local_sections
;
6157 Elf_Internal_Rela
*rel
;
6158 const Elf_Internal_Rela
*relend
;
6160 bfd_boolean use_saved_addend_p
= FALSE
;
6161 const struct elf_backend_data
*bed
;
6163 bed
= get_elf_backend_data (output_bfd
);
6164 relend
= relocs
+ input_section
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
6165 for (rel
= relocs
; rel
< relend
; ++rel
)
6169 reloc_howto_type
*howto
;
6170 bfd_boolean require_jalx
;
6171 /* TRUE if the relocation is a RELA relocation, rather than a
6173 bfd_boolean rela_relocation_p
= TRUE
;
6174 unsigned int r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
6175 const char * msg
= (const char *) NULL
;
6177 /* Find the relocation howto for this relocation. */
6178 if (r_type
== R_MIPS_64
&& ! NEWABI_P (input_bfd
))
6180 /* Some 32-bit code uses R_MIPS_64. In particular, people use
6181 64-bit code, but make sure all their addresses are in the
6182 lowermost or uppermost 32-bit section of the 64-bit address
6183 space. Thus, when they use an R_MIPS_64 they mean what is
6184 usually meant by R_MIPS_32, with the exception that the
6185 stored value is sign-extended to 64 bits. */
6186 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, R_MIPS_32
, FALSE
);
6188 /* On big-endian systems, we need to lie about the position
6190 if (bfd_big_endian (input_bfd
))
6194 /* NewABI defaults to RELA relocations. */
6195 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, r_type
,
6196 NEWABI_P (input_bfd
)
6197 && (MIPS_RELOC_RELA_P
6198 (input_bfd
, input_section
,
6201 if (!use_saved_addend_p
)
6203 Elf_Internal_Shdr
*rel_hdr
;
6205 /* If these relocations were originally of the REL variety,
6206 we must pull the addend out of the field that will be
6207 relocated. Otherwise, we simply use the contents of the
6208 RELA relocation. To determine which flavor or relocation
6209 this is, we depend on the fact that the INPUT_SECTION's
6210 REL_HDR is read before its REL_HDR2. */
6211 rel_hdr
= &elf_section_data (input_section
)->rel_hdr
;
6212 if ((size_t) (rel
- relocs
)
6213 >= (NUM_SHDR_ENTRIES (rel_hdr
) * bed
->s
->int_rels_per_ext_rel
))
6214 rel_hdr
= elf_section_data (input_section
)->rel_hdr2
;
6215 if (rel_hdr
->sh_entsize
== MIPS_ELF_REL_SIZE (input_bfd
))
6217 /* Note that this is a REL relocation. */
6218 rela_relocation_p
= FALSE
;
6220 /* Get the addend, which is stored in the input file. */
6221 addend
= mips_elf_obtain_contents (howto
, rel
, input_bfd
,
6223 addend
&= howto
->src_mask
;
6224 addend
<<= howto
->rightshift
;
6226 /* For some kinds of relocations, the ADDEND is a
6227 combination of the addend stored in two different
6229 if (r_type
== R_MIPS_HI16
6230 || r_type
== R_MIPS_GNU_REL_HI16
6231 || (r_type
== R_MIPS_GOT16
6232 && mips_elf_local_relocation_p (input_bfd
, rel
,
6233 local_sections
, FALSE
)))
6236 const Elf_Internal_Rela
*lo16_relocation
;
6237 reloc_howto_type
*lo16_howto
;
6240 /* The combined value is the sum of the HI16 addend,
6241 left-shifted by sixteen bits, and the LO16
6242 addend, sign extended. (Usually, the code does
6243 a `lui' of the HI16 value, and then an `addiu' of
6246 Scan ahead to find a matching LO16 relocation. */
6247 if (r_type
== R_MIPS_GNU_REL_HI16
)
6248 lo
= R_MIPS_GNU_REL_LO16
;
6251 lo16_relocation
= mips_elf_next_relocation (input_bfd
, lo
,
6253 if (lo16_relocation
== NULL
)
6256 /* Obtain the addend kept there. */
6257 lo16_howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, lo
, FALSE
);
6258 l
= mips_elf_obtain_contents (lo16_howto
, lo16_relocation
,
6259 input_bfd
, contents
);
6260 l
&= lo16_howto
->src_mask
;
6261 l
<<= lo16_howto
->rightshift
;
6262 l
= _bfd_mips_elf_sign_extend (l
, 16);
6266 /* Compute the combined addend. */
6269 /* If PC-relative, subtract the difference between the
6270 address of the LO part of the reloc and the address of
6271 the HI part. The relocation is relative to the LO
6272 part, but mips_elf_calculate_relocation() doesn't
6273 know its address or the difference from the HI part, so
6274 we subtract that difference here. See also the
6275 comment in mips_elf_calculate_relocation(). */
6276 if (r_type
== R_MIPS_GNU_REL_HI16
)
6277 addend
-= (lo16_relocation
->r_offset
- rel
->r_offset
);
6279 else if (r_type
== R_MIPS16_GPREL
)
6281 /* The addend is scrambled in the object file. See
6282 mips_elf_perform_relocation for details on the
6284 addend
= (((addend
& 0x1f0000) >> 5)
6285 | ((addend
& 0x7e00000) >> 16)
6290 addend
= rel
->r_addend
;
6293 if (info
->relocatable
)
6295 Elf_Internal_Sym
*sym
;
6296 unsigned long r_symndx
;
6298 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
)
6299 && bfd_big_endian (input_bfd
))
6302 /* Since we're just relocating, all we need to do is copy
6303 the relocations back out to the object file, unless
6304 they're against a section symbol, in which case we need
6305 to adjust by the section offset, or unless they're GP
6306 relative in which case we need to adjust by the amount
6307 that we're adjusting GP in this relocatable object. */
6309 if (! mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
,
6311 /* There's nothing to do for non-local relocations. */
6314 if (r_type
== R_MIPS16_GPREL
6315 || r_type
== R_MIPS_GPREL16
6316 || r_type
== R_MIPS_GPREL32
6317 || r_type
== R_MIPS_LITERAL
)
6318 addend
-= (_bfd_get_gp_value (output_bfd
)
6319 - _bfd_get_gp_value (input_bfd
));
6321 r_symndx
= ELF_R_SYM (output_bfd
, rel
->r_info
);
6322 sym
= local_syms
+ r_symndx
;
6323 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6324 /* Adjust the addend appropriately. */
6325 addend
+= local_sections
[r_symndx
]->output_offset
;
6327 if (howto
->partial_inplace
)
6329 /* If the relocation is for a R_MIPS_HI16 or R_MIPS_GOT16,
6330 then we only want to write out the high-order 16 bits.
6331 The subsequent R_MIPS_LO16 will handle the low-order bits.
6333 if (r_type
== R_MIPS_HI16
|| r_type
== R_MIPS_GOT16
6334 || r_type
== R_MIPS_GNU_REL_HI16
)
6335 addend
= mips_elf_high (addend
);
6336 else if (r_type
== R_MIPS_HIGHER
)
6337 addend
= mips_elf_higher (addend
);
6338 else if (r_type
== R_MIPS_HIGHEST
)
6339 addend
= mips_elf_highest (addend
);
6342 if (rela_relocation_p
)
6343 /* If this is a RELA relocation, just update the addend.
6344 We have to cast away constness for REL. */
6345 rel
->r_addend
= addend
;
6348 /* Otherwise, we have to write the value back out. Note
6349 that we use the source mask, rather than the
6350 destination mask because the place to which we are
6351 writing will be source of the addend in the final
6353 addend
>>= howto
->rightshift
;
6354 addend
&= howto
->src_mask
;
6356 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
6357 /* See the comment above about using R_MIPS_64 in the 32-bit
6358 ABI. Here, we need to update the addend. It would be
6359 possible to get away with just using the R_MIPS_32 reloc
6360 but for endianness. */
6366 if (addend
& ((bfd_vma
) 1 << 31))
6368 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
6375 /* If we don't know that we have a 64-bit type,
6376 do two separate stores. */
6377 if (bfd_big_endian (input_bfd
))
6379 /* Store the sign-bits (which are most significant)
6381 low_bits
= sign_bits
;
6387 high_bits
= sign_bits
;
6389 bfd_put_32 (input_bfd
, low_bits
,
6390 contents
+ rel
->r_offset
);
6391 bfd_put_32 (input_bfd
, high_bits
,
6392 contents
+ rel
->r_offset
+ 4);
6396 if (! mips_elf_perform_relocation (info
, howto
, rel
, addend
,
6397 input_bfd
, input_section
,
6402 /* Go on to the next relocation. */
6406 /* In the N32 and 64-bit ABIs there may be multiple consecutive
6407 relocations for the same offset. In that case we are
6408 supposed to treat the output of each relocation as the addend
6410 if (rel
+ 1 < relend
6411 && rel
->r_offset
== rel
[1].r_offset
6412 && ELF_R_TYPE (input_bfd
, rel
[1].r_info
) != R_MIPS_NONE
)
6413 use_saved_addend_p
= TRUE
;
6415 use_saved_addend_p
= FALSE
;
6417 addend
>>= howto
->rightshift
;
6419 /* Figure out what value we are supposed to relocate. */
6420 switch (mips_elf_calculate_relocation (output_bfd
, input_bfd
,
6421 input_section
, info
, rel
,
6422 addend
, howto
, local_syms
,
6423 local_sections
, &value
,
6424 &name
, &require_jalx
,
6425 use_saved_addend_p
))
6427 case bfd_reloc_continue
:
6428 /* There's nothing to do. */
6431 case bfd_reloc_undefined
:
6432 /* mips_elf_calculate_relocation already called the
6433 undefined_symbol callback. There's no real point in
6434 trying to perform the relocation at this point, so we
6435 just skip ahead to the next relocation. */
6438 case bfd_reloc_notsupported
:
6439 msg
= _("internal error: unsupported relocation error");
6440 info
->callbacks
->warning
6441 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
6444 case bfd_reloc_overflow
:
6445 if (use_saved_addend_p
)
6446 /* Ignore overflow until we reach the last relocation for
6447 a given location. */
6451 BFD_ASSERT (name
!= NULL
);
6452 if (! ((*info
->callbacks
->reloc_overflow
)
6453 (info
, name
, howto
->name
, (bfd_vma
) 0,
6454 input_bfd
, input_section
, rel
->r_offset
)))
6467 /* If we've got another relocation for the address, keep going
6468 until we reach the last one. */
6469 if (use_saved_addend_p
)
6475 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
6476 /* See the comment above about using R_MIPS_64 in the 32-bit
6477 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
6478 that calculated the right value. Now, however, we
6479 sign-extend the 32-bit result to 64-bits, and store it as a
6480 64-bit value. We are especially generous here in that we
6481 go to extreme lengths to support this usage on systems with
6482 only a 32-bit VMA. */
6488 if (value
& ((bfd_vma
) 1 << 31))
6490 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
6497 /* If we don't know that we have a 64-bit type,
6498 do two separate stores. */
6499 if (bfd_big_endian (input_bfd
))
6501 /* Undo what we did above. */
6503 /* Store the sign-bits (which are most significant)
6505 low_bits
= sign_bits
;
6511 high_bits
= sign_bits
;
6513 bfd_put_32 (input_bfd
, low_bits
,
6514 contents
+ rel
->r_offset
);
6515 bfd_put_32 (input_bfd
, high_bits
,
6516 contents
+ rel
->r_offset
+ 4);
6520 /* Actually perform the relocation. */
6521 if (! mips_elf_perform_relocation (info
, howto
, rel
, value
,
6522 input_bfd
, input_section
,
6523 contents
, require_jalx
))
6530 /* If NAME is one of the special IRIX6 symbols defined by the linker,
6531 adjust it appropriately now. */
6534 mips_elf_irix6_finish_dynamic_symbol (abfd
, name
, sym
)
6535 bfd
*abfd ATTRIBUTE_UNUSED
;
6537 Elf_Internal_Sym
*sym
;
6539 /* The linker script takes care of providing names and values for
6540 these, but we must place them into the right sections. */
6541 static const char* const text_section_symbols
[] = {
6544 "__dso_displacement",
6546 "__program_header_table",
6550 static const char* const data_section_symbols
[] = {
6558 const char* const *p
;
6561 for (i
= 0; i
< 2; ++i
)
6562 for (p
= (i
== 0) ? text_section_symbols
: data_section_symbols
;
6565 if (strcmp (*p
, name
) == 0)
6567 /* All of these symbols are given type STT_SECTION by the
6569 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6570 sym
->st_other
= STO_PROTECTED
;
6572 /* The IRIX linker puts these symbols in special sections. */
6574 sym
->st_shndx
= SHN_MIPS_TEXT
;
6576 sym
->st_shndx
= SHN_MIPS_DATA
;
6582 /* Finish up dynamic symbol handling. We set the contents of various
6583 dynamic sections here. */
6586 _bfd_mips_elf_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
6588 struct bfd_link_info
*info
;
6589 struct elf_link_hash_entry
*h
;
6590 Elf_Internal_Sym
*sym
;
6595 struct mips_got_info
*g
, *gg
;
6598 dynobj
= elf_hash_table (info
)->dynobj
;
6599 gval
= sym
->st_value
;
6601 if (h
->plt
.offset
!= (bfd_vma
) -1)
6604 bfd_byte stub
[MIPS_FUNCTION_STUB_SIZE
];
6606 /* This symbol has a stub. Set it up. */
6608 BFD_ASSERT (h
->dynindx
!= -1);
6610 s
= bfd_get_section_by_name (dynobj
,
6611 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
6612 BFD_ASSERT (s
!= NULL
);
6614 /* FIXME: Can h->dynindex be more than 64K? */
6615 if (h
->dynindx
& 0xffff0000)
6618 /* Fill the stub. */
6619 bfd_put_32 (output_bfd
, STUB_LW (output_bfd
), stub
);
6620 bfd_put_32 (output_bfd
, STUB_MOVE (output_bfd
), stub
+ 4);
6621 bfd_put_32 (output_bfd
, STUB_JALR
, stub
+ 8);
6622 bfd_put_32 (output_bfd
, STUB_LI16 (output_bfd
) + h
->dynindx
, stub
+ 12);
6624 BFD_ASSERT (h
->plt
.offset
<= s
->_raw_size
);
6625 memcpy (s
->contents
+ h
->plt
.offset
, stub
, MIPS_FUNCTION_STUB_SIZE
);
6627 /* Mark the symbol as undefined. plt.offset != -1 occurs
6628 only for the referenced symbol. */
6629 sym
->st_shndx
= SHN_UNDEF
;
6631 /* The run-time linker uses the st_value field of the symbol
6632 to reset the global offset table entry for this external
6633 to its stub address when unlinking a shared object. */
6634 gval
= s
->output_section
->vma
+ s
->output_offset
+ h
->plt
.offset
;
6635 sym
->st_value
= gval
;
6638 BFD_ASSERT (h
->dynindx
!= -1
6639 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0);
6641 sgot
= mips_elf_got_section (dynobj
, FALSE
);
6642 BFD_ASSERT (sgot
!= NULL
);
6643 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
6644 g
= mips_elf_section_data (sgot
)->u
.got_info
;
6645 BFD_ASSERT (g
!= NULL
);
6647 /* Run through the global symbol table, creating GOT entries for all
6648 the symbols that need them. */
6649 if (g
->global_gotsym
!= NULL
6650 && h
->dynindx
>= g
->global_gotsym
->dynindx
)
6655 value
= sym
->st_value
;
6656 offset
= mips_elf_global_got_index (dynobj
, output_bfd
, h
);
6657 MIPS_ELF_PUT_WORD (output_bfd
, value
, sgot
->contents
+ offset
);
6660 if (g
->next
&& h
->dynindx
!= -1)
6662 struct mips_got_entry e
, *p
;
6665 Elf_Internal_Rela rel
[3];
6670 e
.abfd
= output_bfd
;
6672 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
6675 || h
->root
.type
== bfd_link_hash_undefined
6676 || h
->root
.type
== bfd_link_hash_undefweak
)
6678 else if (sym
->st_value
)
6679 value
= sym
->st_value
;
6681 value
= h
->root
.u
.def
.value
;
6683 memset (rel
, 0, sizeof (rel
));
6684 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_REL32
);
6686 for (g
= g
->next
; g
->next
!= gg
; g
= g
->next
)
6689 && (p
= (struct mips_got_entry
*) htab_find (g
->got_entries
,
6693 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
6695 MIPS_ELF_PUT_WORD (output_bfd
, value
, sgot
->contents
+ offset
);
6698 || (elf_hash_table (info
)->dynamic_sections_created
6700 && ((p
->d
.h
->root
.elf_link_hash_flags
6701 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0)
6702 && ((p
->d
.h
->root
.elf_link_hash_flags
6703 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
6704 && ! (mips_elf_create_dynamic_relocation
6705 (output_bfd
, info
, rel
,
6706 e
.d
.h
, NULL
, value
, &addend
, sgot
)))
6708 BFD_ASSERT (addend
== 0);
6713 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
6714 name
= h
->root
.root
.string
;
6715 if (strcmp (name
, "_DYNAMIC") == 0
6716 || strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
6717 sym
->st_shndx
= SHN_ABS
;
6718 else if (strcmp (name
, "_DYNAMIC_LINK") == 0
6719 || strcmp (name
, "_DYNAMIC_LINKING") == 0)
6721 sym
->st_shndx
= SHN_ABS
;
6722 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6725 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (output_bfd
))
6727 sym
->st_shndx
= SHN_ABS
;
6728 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6729 sym
->st_value
= elf_gp (output_bfd
);
6731 else if (SGI_COMPAT (output_bfd
))
6733 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
6734 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
6736 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6737 sym
->st_other
= STO_PROTECTED
;
6739 sym
->st_shndx
= SHN_MIPS_DATA
;
6741 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
6743 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6744 sym
->st_other
= STO_PROTECTED
;
6745 sym
->st_value
= mips_elf_hash_table (info
)->procedure_count
;
6746 sym
->st_shndx
= SHN_ABS
;
6748 else if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
!= SHN_ABS
)
6750 if (h
->type
== STT_FUNC
)
6751 sym
->st_shndx
= SHN_MIPS_TEXT
;
6752 else if (h
->type
== STT_OBJECT
)
6753 sym
->st_shndx
= SHN_MIPS_DATA
;
6757 /* Handle the IRIX6-specific symbols. */
6758 if (IRIX_COMPAT (output_bfd
) == ict_irix6
)
6759 mips_elf_irix6_finish_dynamic_symbol (output_bfd
, name
, sym
);
6763 if (! mips_elf_hash_table (info
)->use_rld_obj_head
6764 && (strcmp (name
, "__rld_map") == 0
6765 || strcmp (name
, "__RLD_MAP") == 0))
6767 asection
*s
= bfd_get_section_by_name (dynobj
, ".rld_map");
6768 BFD_ASSERT (s
!= NULL
);
6769 sym
->st_value
= s
->output_section
->vma
+ s
->output_offset
;
6770 bfd_put_32 (output_bfd
, (bfd_vma
) 0, s
->contents
);
6771 if (mips_elf_hash_table (info
)->rld_value
== 0)
6772 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
6774 else if (mips_elf_hash_table (info
)->use_rld_obj_head
6775 && strcmp (name
, "__rld_obj_head") == 0)
6777 /* IRIX6 does not use a .rld_map section. */
6778 if (IRIX_COMPAT (output_bfd
) == ict_irix5
6779 || IRIX_COMPAT (output_bfd
) == ict_none
)
6780 BFD_ASSERT (bfd_get_section_by_name (dynobj
, ".rld_map")
6782 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
6786 /* If this is a mips16 symbol, force the value to be even. */
6787 if (sym
->st_other
== STO_MIPS16
6788 && (sym
->st_value
& 1) != 0)
6794 /* Finish up the dynamic sections. */
6797 _bfd_mips_elf_finish_dynamic_sections (output_bfd
, info
)
6799 struct bfd_link_info
*info
;
6804 struct mips_got_info
*gg
, *g
;
6806 dynobj
= elf_hash_table (info
)->dynobj
;
6808 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
6810 sgot
= mips_elf_got_section (dynobj
, FALSE
);
6815 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
6816 gg
= mips_elf_section_data (sgot
)->u
.got_info
;
6817 BFD_ASSERT (gg
!= NULL
);
6818 g
= mips_elf_got_for_ibfd (gg
, output_bfd
);
6819 BFD_ASSERT (g
!= NULL
);
6822 if (elf_hash_table (info
)->dynamic_sections_created
)
6826 BFD_ASSERT (sdyn
!= NULL
);
6827 BFD_ASSERT (g
!= NULL
);
6829 for (b
= sdyn
->contents
;
6830 b
< sdyn
->contents
+ sdyn
->_raw_size
;
6831 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
6833 Elf_Internal_Dyn dyn
;
6837 bfd_boolean swap_out_p
;
6839 /* Read in the current dynamic entry. */
6840 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
6842 /* Assume that we're going to modify it and write it out. */
6848 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
6849 BFD_ASSERT (s
!= NULL
);
6850 dyn
.d_un
.d_val
= MIPS_ELF_REL_SIZE (dynobj
);
6854 /* Rewrite DT_STRSZ. */
6856 _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
6861 s
= bfd_get_section_by_name (output_bfd
, name
);
6862 BFD_ASSERT (s
!= NULL
);
6863 dyn
.d_un
.d_ptr
= s
->vma
;
6866 case DT_MIPS_RLD_VERSION
:
6867 dyn
.d_un
.d_val
= 1; /* XXX */
6871 dyn
.d_un
.d_val
= RHF_NOTPOT
; /* XXX */
6874 case DT_MIPS_TIME_STAMP
:
6875 time ((time_t *) &dyn
.d_un
.d_val
);
6878 case DT_MIPS_ICHECKSUM
:
6883 case DT_MIPS_IVERSION
:
6888 case DT_MIPS_BASE_ADDRESS
:
6889 s
= output_bfd
->sections
;
6890 BFD_ASSERT (s
!= NULL
);
6891 dyn
.d_un
.d_ptr
= s
->vma
& ~(bfd_vma
) 0xffff;
6894 case DT_MIPS_LOCAL_GOTNO
:
6895 dyn
.d_un
.d_val
= g
->local_gotno
;
6898 case DT_MIPS_UNREFEXTNO
:
6899 /* The index into the dynamic symbol table which is the
6900 entry of the first external symbol that is not
6901 referenced within the same object. */
6902 dyn
.d_un
.d_val
= bfd_count_sections (output_bfd
) + 1;
6905 case DT_MIPS_GOTSYM
:
6906 if (gg
->global_gotsym
)
6908 dyn
.d_un
.d_val
= gg
->global_gotsym
->dynindx
;
6911 /* In case if we don't have global got symbols we default
6912 to setting DT_MIPS_GOTSYM to the same value as
6913 DT_MIPS_SYMTABNO, so we just fall through. */
6915 case DT_MIPS_SYMTABNO
:
6917 elemsize
= MIPS_ELF_SYM_SIZE (output_bfd
);
6918 s
= bfd_get_section_by_name (output_bfd
, name
);
6919 BFD_ASSERT (s
!= NULL
);
6921 if (s
->_cooked_size
!= 0)
6922 dyn
.d_un
.d_val
= s
->_cooked_size
/ elemsize
;
6924 dyn
.d_un
.d_val
= s
->_raw_size
/ elemsize
;
6927 case DT_MIPS_HIPAGENO
:
6928 dyn
.d_un
.d_val
= g
->local_gotno
- MIPS_RESERVED_GOTNO
;
6931 case DT_MIPS_RLD_MAP
:
6932 dyn
.d_un
.d_ptr
= mips_elf_hash_table (info
)->rld_value
;
6935 case DT_MIPS_OPTIONS
:
6936 s
= (bfd_get_section_by_name
6937 (output_bfd
, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd
)));
6938 dyn
.d_un
.d_ptr
= s
->vma
;
6942 /* Reduce DT_RELSZ to account for any relocations we
6943 decided not to make. This is for the n64 irix rld,
6944 which doesn't seem to apply any relocations if there
6945 are trailing null entries. */
6946 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
6947 dyn
.d_un
.d_val
= (s
->reloc_count
6948 * (ABI_64_P (output_bfd
)
6949 ? sizeof (Elf64_Mips_External_Rel
)
6950 : sizeof (Elf32_External_Rel
)));
6959 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
6964 /* The first entry of the global offset table will be filled at
6965 runtime. The second entry will be used by some runtime loaders.
6966 This isn't the case of IRIX rld. */
6967 if (sgot
!= NULL
&& sgot
->_raw_size
> 0)
6969 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
6970 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0x80000000,
6971 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
6975 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
6976 = MIPS_ELF_GOT_SIZE (output_bfd
);
6978 /* Generate dynamic relocations for the non-primary gots. */
6979 if (gg
!= NULL
&& gg
->next
)
6981 Elf_Internal_Rela rel
[3];
6984 memset (rel
, 0, sizeof (rel
));
6985 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_REL32
);
6987 for (g
= gg
->next
; g
->next
!= gg
; g
= g
->next
)
6989 bfd_vma index
= g
->next
->local_gotno
+ g
->next
->global_gotno
;
6991 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0, sgot
->contents
6992 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
6993 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0x80000000, sgot
->contents
6994 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
6999 while (index
< g
->assigned_gotno
)
7001 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
7002 = index
++ * MIPS_ELF_GOT_SIZE (output_bfd
);
7003 if (!(mips_elf_create_dynamic_relocation
7004 (output_bfd
, info
, rel
, NULL
,
7005 bfd_abs_section_ptr
,
7008 BFD_ASSERT (addend
== 0);
7015 Elf32_compact_rel cpt
;
7017 if (SGI_COMPAT (output_bfd
))
7019 /* Write .compact_rel section out. */
7020 s
= bfd_get_section_by_name (dynobj
, ".compact_rel");
7024 cpt
.num
= s
->reloc_count
;
7026 cpt
.offset
= (s
->output_section
->filepos
7027 + sizeof (Elf32_External_compact_rel
));
7030 bfd_elf32_swap_compact_rel_out (output_bfd
, &cpt
,
7031 ((Elf32_External_compact_rel
*)
7034 /* Clean up a dummy stub function entry in .text. */
7035 s
= bfd_get_section_by_name (dynobj
,
7036 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
7039 file_ptr dummy_offset
;
7041 BFD_ASSERT (s
->_raw_size
>= MIPS_FUNCTION_STUB_SIZE
);
7042 dummy_offset
= s
->_raw_size
- MIPS_FUNCTION_STUB_SIZE
;
7043 memset (s
->contents
+ dummy_offset
, 0,
7044 MIPS_FUNCTION_STUB_SIZE
);
7049 /* We need to sort the entries of the dynamic relocation section. */
7051 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
7054 && s
->_raw_size
> (bfd_vma
)2 * MIPS_ELF_REL_SIZE (output_bfd
))
7056 reldyn_sorting_bfd
= output_bfd
;
7058 if (ABI_64_P (output_bfd
))
7059 qsort ((Elf64_External_Rel
*) s
->contents
+ 1,
7060 (size_t) s
->reloc_count
- 1,
7061 sizeof (Elf64_Mips_External_Rel
), sort_dynamic_relocs_64
);
7063 qsort ((Elf32_External_Rel
*) s
->contents
+ 1,
7064 (size_t) s
->reloc_count
- 1,
7065 sizeof (Elf32_External_Rel
), sort_dynamic_relocs
);
7073 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
7076 mips_set_isa_flags (abfd
)
7081 switch (bfd_get_mach (abfd
))
7084 case bfd_mach_mips3000
:
7085 val
= E_MIPS_ARCH_1
;
7088 case bfd_mach_mips3900
:
7089 val
= E_MIPS_ARCH_1
| E_MIPS_MACH_3900
;
7092 case bfd_mach_mips6000
:
7093 val
= E_MIPS_ARCH_2
;
7096 case bfd_mach_mips4000
:
7097 case bfd_mach_mips4300
:
7098 case bfd_mach_mips4400
:
7099 case bfd_mach_mips4600
:
7100 val
= E_MIPS_ARCH_3
;
7103 case bfd_mach_mips4010
:
7104 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4010
;
7107 case bfd_mach_mips4100
:
7108 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4100
;
7111 case bfd_mach_mips4111
:
7112 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4111
;
7115 case bfd_mach_mips4120
:
7116 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4120
;
7119 case bfd_mach_mips4650
:
7120 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4650
;
7123 case bfd_mach_mips5400
:
7124 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5400
;
7127 case bfd_mach_mips5500
:
7128 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5500
;
7131 case bfd_mach_mips5000
:
7132 case bfd_mach_mips7000
:
7133 case bfd_mach_mips8000
:
7134 case bfd_mach_mips10000
:
7135 case bfd_mach_mips12000
:
7136 val
= E_MIPS_ARCH_4
;
7139 case bfd_mach_mips5
:
7140 val
= E_MIPS_ARCH_5
;
7143 case bfd_mach_mips_sb1
:
7144 val
= E_MIPS_ARCH_64
| E_MIPS_MACH_SB1
;
7147 case bfd_mach_mipsisa32
:
7148 val
= E_MIPS_ARCH_32
;
7151 case bfd_mach_mipsisa64
:
7152 val
= E_MIPS_ARCH_64
;
7155 case bfd_mach_mipsisa32r2
:
7156 val
= E_MIPS_ARCH_32R2
;
7159 case bfd_mach_mipsisa64r2
:
7160 val
= E_MIPS_ARCH_64R2
;
7163 elf_elfheader (abfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
7164 elf_elfheader (abfd
)->e_flags
|= val
;
7169 /* The final processing done just before writing out a MIPS ELF object
7170 file. This gets the MIPS architecture right based on the machine
7171 number. This is used by both the 32-bit and the 64-bit ABI. */
7174 _bfd_mips_elf_final_write_processing (abfd
, linker
)
7176 bfd_boolean linker ATTRIBUTE_UNUSED
;
7179 Elf_Internal_Shdr
**hdrpp
;
7183 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
7184 is nonzero. This is for compatibility with old objects, which used
7185 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
7186 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_MACH
) == 0)
7187 mips_set_isa_flags (abfd
);
7189 /* Set the sh_info field for .gptab sections and other appropriate
7190 info for each special section. */
7191 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
7192 i
< elf_numsections (abfd
);
7195 switch ((*hdrpp
)->sh_type
)
7198 case SHT_MIPS_LIBLIST
:
7199 sec
= bfd_get_section_by_name (abfd
, ".dynstr");
7201 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7204 case SHT_MIPS_GPTAB
:
7205 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7206 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7207 BFD_ASSERT (name
!= NULL
7208 && strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0);
7209 sec
= bfd_get_section_by_name (abfd
, name
+ sizeof ".gptab" - 1);
7210 BFD_ASSERT (sec
!= NULL
);
7211 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
7214 case SHT_MIPS_CONTENT
:
7215 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7216 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7217 BFD_ASSERT (name
!= NULL
7218 && strncmp (name
, ".MIPS.content",
7219 sizeof ".MIPS.content" - 1) == 0);
7220 sec
= bfd_get_section_by_name (abfd
,
7221 name
+ sizeof ".MIPS.content" - 1);
7222 BFD_ASSERT (sec
!= NULL
);
7223 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7226 case SHT_MIPS_SYMBOL_LIB
:
7227 sec
= bfd_get_section_by_name (abfd
, ".dynsym");
7229 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7230 sec
= bfd_get_section_by_name (abfd
, ".liblist");
7232 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
7235 case SHT_MIPS_EVENTS
:
7236 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7237 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7238 BFD_ASSERT (name
!= NULL
);
7239 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0)
7240 sec
= bfd_get_section_by_name (abfd
,
7241 name
+ sizeof ".MIPS.events" - 1);
7244 BFD_ASSERT (strncmp (name
, ".MIPS.post_rel",
7245 sizeof ".MIPS.post_rel" - 1) == 0);
7246 sec
= bfd_get_section_by_name (abfd
,
7248 + sizeof ".MIPS.post_rel" - 1));
7250 BFD_ASSERT (sec
!= NULL
);
7251 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7258 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
7262 _bfd_mips_elf_additional_program_headers (abfd
)
7268 /* See if we need a PT_MIPS_REGINFO segment. */
7269 s
= bfd_get_section_by_name (abfd
, ".reginfo");
7270 if (s
&& (s
->flags
& SEC_LOAD
))
7273 /* See if we need a PT_MIPS_OPTIONS segment. */
7274 if (IRIX_COMPAT (abfd
) == ict_irix6
7275 && bfd_get_section_by_name (abfd
,
7276 MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)))
7279 /* See if we need a PT_MIPS_RTPROC segment. */
7280 if (IRIX_COMPAT (abfd
) == ict_irix5
7281 && bfd_get_section_by_name (abfd
, ".dynamic")
7282 && bfd_get_section_by_name (abfd
, ".mdebug"))
7288 /* Modify the segment map for an IRIX5 executable. */
7291 _bfd_mips_elf_modify_segment_map (abfd
)
7295 struct elf_segment_map
*m
, **pm
;
7298 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
7300 s
= bfd_get_section_by_name (abfd
, ".reginfo");
7301 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
7303 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
7304 if (m
->p_type
== PT_MIPS_REGINFO
)
7309 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
7313 m
->p_type
= PT_MIPS_REGINFO
;
7317 /* We want to put it after the PHDR and INTERP segments. */
7318 pm
= &elf_tdata (abfd
)->segment_map
;
7320 && ((*pm
)->p_type
== PT_PHDR
7321 || (*pm
)->p_type
== PT_INTERP
))
7329 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
7330 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
7331 PT_MIPS_OPTIONS segment immediately following the program header
7334 /* On non-IRIX6 new abi, we'll have already created a segment
7335 for this section, so don't create another. I'm not sure this
7336 is not also the case for IRIX 6, but I can't test it right
7338 && IRIX_COMPAT (abfd
) == ict_irix6
)
7340 for (s
= abfd
->sections
; s
; s
= s
->next
)
7341 if (elf_section_data (s
)->this_hdr
.sh_type
== SHT_MIPS_OPTIONS
)
7346 struct elf_segment_map
*options_segment
;
7348 pm
= &elf_tdata (abfd
)->segment_map
;
7350 && ((*pm
)->p_type
== PT_PHDR
7351 || (*pm
)->p_type
== PT_INTERP
))
7354 amt
= sizeof (struct elf_segment_map
);
7355 options_segment
= bfd_zalloc (abfd
, amt
);
7356 options_segment
->next
= *pm
;
7357 options_segment
->p_type
= PT_MIPS_OPTIONS
;
7358 options_segment
->p_flags
= PF_R
;
7359 options_segment
->p_flags_valid
= TRUE
;
7360 options_segment
->count
= 1;
7361 options_segment
->sections
[0] = s
;
7362 *pm
= options_segment
;
7367 if (IRIX_COMPAT (abfd
) == ict_irix5
)
7369 /* If there are .dynamic and .mdebug sections, we make a room
7370 for the RTPROC header. FIXME: Rewrite without section names. */
7371 if (bfd_get_section_by_name (abfd
, ".interp") == NULL
7372 && bfd_get_section_by_name (abfd
, ".dynamic") != NULL
7373 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
7375 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
7376 if (m
->p_type
== PT_MIPS_RTPROC
)
7381 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
7385 m
->p_type
= PT_MIPS_RTPROC
;
7387 s
= bfd_get_section_by_name (abfd
, ".rtproc");
7392 m
->p_flags_valid
= 1;
7400 /* We want to put it after the DYNAMIC segment. */
7401 pm
= &elf_tdata (abfd
)->segment_map
;
7402 while (*pm
!= NULL
&& (*pm
)->p_type
!= PT_DYNAMIC
)
7412 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
7413 .dynstr, .dynsym, and .hash sections, and everything in
7415 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
;
7417 if ((*pm
)->p_type
== PT_DYNAMIC
)
7420 if (m
!= NULL
&& IRIX_COMPAT (abfd
) == ict_none
)
7422 /* For a normal mips executable the permissions for the PT_DYNAMIC
7423 segment are read, write and execute. We do that here since
7424 the code in elf.c sets only the read permission. This matters
7425 sometimes for the dynamic linker. */
7426 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
7428 m
->p_flags
= PF_R
| PF_W
| PF_X
;
7429 m
->p_flags_valid
= 1;
7433 && m
->count
== 1 && strcmp (m
->sections
[0]->name
, ".dynamic") == 0)
7435 static const char *sec_names
[] =
7437 ".dynamic", ".dynstr", ".dynsym", ".hash"
7441 struct elf_segment_map
*n
;
7445 for (i
= 0; i
< sizeof sec_names
/ sizeof sec_names
[0]; i
++)
7447 s
= bfd_get_section_by_name (abfd
, sec_names
[i
]);
7448 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
7454 sz
= s
->_cooked_size
;
7457 if (high
< s
->vma
+ sz
)
7463 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
7464 if ((s
->flags
& SEC_LOAD
) != 0
7467 + (s
->_cooked_size
!=
7468 0 ? s
->_cooked_size
: s
->_raw_size
)) <= high
))
7471 amt
= sizeof *n
+ (bfd_size_type
) (c
- 1) * sizeof (asection
*);
7472 n
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
7479 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
7481 if ((s
->flags
& SEC_LOAD
) != 0
7484 + (s
->_cooked_size
!= 0 ?
7485 s
->_cooked_size
: s
->_raw_size
)) <= high
))
7499 /* Return the section that should be marked against GC for a given
7503 _bfd_mips_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
)
7505 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
7506 Elf_Internal_Rela
*rel
;
7507 struct elf_link_hash_entry
*h
;
7508 Elf_Internal_Sym
*sym
;
7510 /* ??? Do mips16 stub sections need to be handled special? */
7514 switch (ELF_R_TYPE (sec
->owner
, rel
->r_info
))
7516 case R_MIPS_GNU_VTINHERIT
:
7517 case R_MIPS_GNU_VTENTRY
:
7521 switch (h
->root
.type
)
7523 case bfd_link_hash_defined
:
7524 case bfd_link_hash_defweak
:
7525 return h
->root
.u
.def
.section
;
7527 case bfd_link_hash_common
:
7528 return h
->root
.u
.c
.p
->section
;
7536 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
7541 /* Update the got entry reference counts for the section being removed. */
7544 _bfd_mips_elf_gc_sweep_hook (abfd
, info
, sec
, relocs
)
7545 bfd
*abfd ATTRIBUTE_UNUSED
;
7546 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
7547 asection
*sec ATTRIBUTE_UNUSED
;
7548 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
;
7551 Elf_Internal_Shdr
*symtab_hdr
;
7552 struct elf_link_hash_entry
**sym_hashes
;
7553 bfd_signed_vma
*local_got_refcounts
;
7554 const Elf_Internal_Rela
*rel
, *relend
;
7555 unsigned long r_symndx
;
7556 struct elf_link_hash_entry
*h
;
7558 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7559 sym_hashes
= elf_sym_hashes (abfd
);
7560 local_got_refcounts
= elf_local_got_refcounts (abfd
);
7562 relend
= relocs
+ sec
->reloc_count
;
7563 for (rel
= relocs
; rel
< relend
; rel
++)
7564 switch (ELF_R_TYPE (abfd
, rel
->r_info
))
7568 case R_MIPS_CALL_HI16
:
7569 case R_MIPS_CALL_LO16
:
7570 case R_MIPS_GOT_HI16
:
7571 case R_MIPS_GOT_LO16
:
7572 case R_MIPS_GOT_DISP
:
7573 case R_MIPS_GOT_PAGE
:
7574 case R_MIPS_GOT_OFST
:
7575 /* ??? It would seem that the existing MIPS code does no sort
7576 of reference counting or whatnot on its GOT and PLT entries,
7577 so it is not possible to garbage collect them at this time. */
7588 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
7589 hiding the old indirect symbol. Process additional relocation
7590 information. Also called for weakdefs, in which case we just let
7591 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
7594 _bfd_mips_elf_copy_indirect_symbol (bed
, dir
, ind
)
7595 const struct elf_backend_data
*bed
;
7596 struct elf_link_hash_entry
*dir
, *ind
;
7598 struct mips_elf_link_hash_entry
*dirmips
, *indmips
;
7600 _bfd_elf_link_hash_copy_indirect (bed
, dir
, ind
);
7602 if (ind
->root
.type
!= bfd_link_hash_indirect
)
7605 dirmips
= (struct mips_elf_link_hash_entry
*) dir
;
7606 indmips
= (struct mips_elf_link_hash_entry
*) ind
;
7607 dirmips
->possibly_dynamic_relocs
+= indmips
->possibly_dynamic_relocs
;
7608 if (indmips
->readonly_reloc
)
7609 dirmips
->readonly_reloc
= TRUE
;
7610 if (indmips
->no_fn_stub
)
7611 dirmips
->no_fn_stub
= TRUE
;
7615 _bfd_mips_elf_hide_symbol (info
, entry
, force_local
)
7616 struct bfd_link_info
*info
;
7617 struct elf_link_hash_entry
*entry
;
7618 bfd_boolean force_local
;
7622 struct mips_got_info
*g
;
7623 struct mips_elf_link_hash_entry
*h
;
7625 h
= (struct mips_elf_link_hash_entry
*) entry
;
7626 if (h
->forced_local
)
7628 h
->forced_local
= force_local
;
7630 dynobj
= elf_hash_table (info
)->dynobj
;
7631 if (dynobj
!= NULL
&& force_local
)
7633 got
= mips_elf_got_section (dynobj
, FALSE
);
7634 g
= mips_elf_section_data (got
)->u
.got_info
;
7638 struct mips_got_entry e
;
7639 struct mips_got_info
*gg
= g
;
7641 /* Since we're turning what used to be a global symbol into a
7642 local one, bump up the number of local entries of each GOT
7643 that had an entry for it. This will automatically decrease
7644 the number of global entries, since global_gotno is actually
7645 the upper limit of global entries. */
7650 for (g
= g
->next
; g
!= gg
; g
= g
->next
)
7651 if (htab_find (g
->got_entries
, &e
))
7653 BFD_ASSERT (g
->global_gotno
> 0);
7658 /* If this was a global symbol forced into the primary GOT, we
7659 no longer need an entry for it. We can't release the entry
7660 at this point, but we must at least stop counting it as one
7661 of the symbols that required a forced got entry. */
7662 if (h
->root
.got
.offset
== 2)
7664 BFD_ASSERT (gg
->assigned_gotno
> 0);
7665 gg
->assigned_gotno
--;
7668 else if (g
->global_gotno
== 0 && g
->global_gotsym
== NULL
)
7669 /* If we haven't got through GOT allocation yet, just bump up the
7670 number of local entries, as this symbol won't be counted as
7673 else if (h
->root
.got
.offset
== 1)
7675 /* If we're past non-multi-GOT allocation and this symbol had
7676 been marked for a global got entry, give it a local entry
7678 BFD_ASSERT (g
->global_gotno
> 0);
7684 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
7690 _bfd_mips_elf_discard_info (abfd
, cookie
, info
)
7692 struct elf_reloc_cookie
*cookie
;
7693 struct bfd_link_info
*info
;
7696 bfd_boolean ret
= FALSE
;
7697 unsigned char *tdata
;
7700 o
= bfd_get_section_by_name (abfd
, ".pdr");
7703 if (o
->_raw_size
== 0)
7705 if (o
->_raw_size
% PDR_SIZE
!= 0)
7707 if (o
->output_section
!= NULL
7708 && bfd_is_abs_section (o
->output_section
))
7711 tdata
= bfd_zmalloc (o
->_raw_size
/ PDR_SIZE
);
7715 cookie
->rels
= _bfd_elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
7716 (Elf_Internal_Rela
*) NULL
,
7724 cookie
->rel
= cookie
->rels
;
7725 cookie
->relend
= cookie
->rels
+ o
->reloc_count
;
7727 for (i
= 0, skip
= 0; i
< o
->_raw_size
/ PDR_SIZE
; i
++)
7729 if (MNAME(abfd
,_bfd_elf
,reloc_symbol_deleted_p
) (i
* PDR_SIZE
, cookie
))
7738 mips_elf_section_data (o
)->u
.tdata
= tdata
;
7739 o
->_cooked_size
= o
->_raw_size
- skip
* PDR_SIZE
;
7745 if (! info
->keep_memory
)
7746 free (cookie
->rels
);
7752 _bfd_mips_elf_ignore_discarded_relocs (sec
)
7755 if (strcmp (sec
->name
, ".pdr") == 0)
7761 _bfd_mips_elf_write_section (output_bfd
, sec
, contents
)
7766 bfd_byte
*to
, *from
, *end
;
7769 if (strcmp (sec
->name
, ".pdr") != 0)
7772 if (mips_elf_section_data (sec
)->u
.tdata
== NULL
)
7776 end
= contents
+ sec
->_raw_size
;
7777 for (from
= contents
, i
= 0;
7779 from
+= PDR_SIZE
, i
++)
7781 if ((mips_elf_section_data (sec
)->u
.tdata
)[i
] == 1)
7784 memcpy (to
, from
, PDR_SIZE
);
7787 bfd_set_section_contents (output_bfd
, sec
->output_section
, contents
,
7788 (file_ptr
) sec
->output_offset
,
7793 /* MIPS ELF uses a special find_nearest_line routine in order the
7794 handle the ECOFF debugging information. */
7796 struct mips_elf_find_line
7798 struct ecoff_debug_info d
;
7799 struct ecoff_find_line i
;
7803 _bfd_mips_elf_find_nearest_line (abfd
, section
, symbols
, offset
, filename_ptr
,
7804 functionname_ptr
, line_ptr
)
7809 const char **filename_ptr
;
7810 const char **functionname_ptr
;
7811 unsigned int *line_ptr
;
7815 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
7816 filename_ptr
, functionname_ptr
,
7820 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
7821 filename_ptr
, functionname_ptr
,
7823 (unsigned) (ABI_64_P (abfd
) ? 8 : 0),
7824 &elf_tdata (abfd
)->dwarf2_find_line_info
))
7827 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
7831 struct mips_elf_find_line
*fi
;
7832 const struct ecoff_debug_swap
* const swap
=
7833 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
7835 /* If we are called during a link, mips_elf_final_link may have
7836 cleared the SEC_HAS_CONTENTS field. We force it back on here
7837 if appropriate (which it normally will be). */
7838 origflags
= msec
->flags
;
7839 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
7840 msec
->flags
|= SEC_HAS_CONTENTS
;
7842 fi
= elf_tdata (abfd
)->find_line_info
;
7845 bfd_size_type external_fdr_size
;
7848 struct fdr
*fdr_ptr
;
7849 bfd_size_type amt
= sizeof (struct mips_elf_find_line
);
7851 fi
= (struct mips_elf_find_line
*) bfd_zalloc (abfd
, amt
);
7854 msec
->flags
= origflags
;
7858 if (! _bfd_mips_elf_read_ecoff_info (abfd
, msec
, &fi
->d
))
7860 msec
->flags
= origflags
;
7864 /* Swap in the FDR information. */
7865 amt
= fi
->d
.symbolic_header
.ifdMax
* sizeof (struct fdr
);
7866 fi
->d
.fdr
= (struct fdr
*) bfd_alloc (abfd
, amt
);
7867 if (fi
->d
.fdr
== NULL
)
7869 msec
->flags
= origflags
;
7872 external_fdr_size
= swap
->external_fdr_size
;
7873 fdr_ptr
= fi
->d
.fdr
;
7874 fraw_src
= (char *) fi
->d
.external_fdr
;
7875 fraw_end
= (fraw_src
7876 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
7877 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
7878 (*swap
->swap_fdr_in
) (abfd
, (PTR
) fraw_src
, fdr_ptr
);
7880 elf_tdata (abfd
)->find_line_info
= fi
;
7882 /* Note that we don't bother to ever free this information.
7883 find_nearest_line is either called all the time, as in
7884 objdump -l, so the information should be saved, or it is
7885 rarely called, as in ld error messages, so the memory
7886 wasted is unimportant. Still, it would probably be a
7887 good idea for free_cached_info to throw it away. */
7890 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
7891 &fi
->i
, filename_ptr
, functionname_ptr
,
7894 msec
->flags
= origflags
;
7898 msec
->flags
= origflags
;
7901 /* Fall back on the generic ELF find_nearest_line routine. */
7903 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
7904 filename_ptr
, functionname_ptr
,
7908 /* When are writing out the .options or .MIPS.options section,
7909 remember the bytes we are writing out, so that we can install the
7910 GP value in the section_processing routine. */
7913 _bfd_mips_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
7918 bfd_size_type count
;
7920 if (strcmp (section
->name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
7924 if (elf_section_data (section
) == NULL
)
7926 bfd_size_type amt
= sizeof (struct bfd_elf_section_data
);
7927 section
->used_by_bfd
= (PTR
) bfd_zalloc (abfd
, amt
);
7928 if (elf_section_data (section
) == NULL
)
7931 c
= mips_elf_section_data (section
)->u
.tdata
;
7936 if (section
->_cooked_size
!= 0)
7937 size
= section
->_cooked_size
;
7939 size
= section
->_raw_size
;
7940 c
= (bfd_byte
*) bfd_zalloc (abfd
, size
);
7943 mips_elf_section_data (section
)->u
.tdata
= c
;
7946 memcpy (c
+ offset
, location
, (size_t) count
);
7949 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
,
7953 /* This is almost identical to bfd_generic_get_... except that some
7954 MIPS relocations need to be handled specially. Sigh. */
7957 _bfd_elf_mips_get_relocated_section_contents (abfd
, link_info
, link_order
,
7958 data
, relocatable
, symbols
)
7960 struct bfd_link_info
*link_info
;
7961 struct bfd_link_order
*link_order
;
7963 bfd_boolean relocatable
;
7966 /* Get enough memory to hold the stuff */
7967 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
7968 asection
*input_section
= link_order
->u
.indirect
.section
;
7970 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
7971 arelent
**reloc_vector
= NULL
;
7977 reloc_vector
= (arelent
**) bfd_malloc ((bfd_size_type
) reloc_size
);
7978 if (reloc_vector
== NULL
&& reloc_size
!= 0)
7981 /* read in the section */
7982 if (!bfd_get_section_contents (input_bfd
,
7986 input_section
->_raw_size
))
7989 /* We're not relaxing the section, so just copy the size info */
7990 input_section
->_cooked_size
= input_section
->_raw_size
;
7991 input_section
->reloc_done
= TRUE
;
7993 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
7997 if (reloc_count
< 0)
8000 if (reloc_count
> 0)
8005 bfd_vma gp
= 0x12345678; /* initialize just to shut gcc up */
8008 struct bfd_hash_entry
*h
;
8009 struct bfd_link_hash_entry
*lh
;
8010 /* Skip all this stuff if we aren't mixing formats. */
8011 if (abfd
&& input_bfd
8012 && abfd
->xvec
== input_bfd
->xvec
)
8016 h
= bfd_hash_lookup (&link_info
->hash
->table
, "_gp", FALSE
, FALSE
);
8017 lh
= (struct bfd_link_hash_entry
*) h
;
8024 case bfd_link_hash_undefined
:
8025 case bfd_link_hash_undefweak
:
8026 case bfd_link_hash_common
:
8029 case bfd_link_hash_defined
:
8030 case bfd_link_hash_defweak
:
8032 gp
= lh
->u
.def
.value
;
8034 case bfd_link_hash_indirect
:
8035 case bfd_link_hash_warning
:
8037 /* @@FIXME ignoring warning for now */
8039 case bfd_link_hash_new
:
8048 for (parent
= reloc_vector
; *parent
!= (arelent
*) NULL
;
8051 char *error_message
= (char *) NULL
;
8052 bfd_reloc_status_type r
;
8054 /* Specific to MIPS: Deal with relocation types that require
8055 knowing the gp of the output bfd. */
8056 asymbol
*sym
= *(*parent
)->sym_ptr_ptr
;
8057 if (bfd_is_abs_section (sym
->section
) && abfd
)
8059 /* The special_function wouldn't get called anyway. */
8063 /* The gp isn't there; let the special function code
8064 fall over on its own. */
8066 else if ((*parent
)->howto
->special_function
8067 == _bfd_mips_elf32_gprel16_reloc
)
8069 /* bypass special_function call */
8070 r
= _bfd_mips_elf_gprel16_with_gp (input_bfd
, sym
, *parent
,
8071 input_section
, relocatable
,
8073 goto skip_bfd_perform_relocation
;
8075 /* end mips specific stuff */
8077 r
= bfd_perform_relocation (input_bfd
,
8081 relocatable
? abfd
: (bfd
*) NULL
,
8083 skip_bfd_perform_relocation
:
8087 asection
*os
= input_section
->output_section
;
8089 /* A partial link, so keep the relocs */
8090 os
->orelocation
[os
->reloc_count
] = *parent
;
8094 if (r
!= bfd_reloc_ok
)
8098 case bfd_reloc_undefined
:
8099 if (!((*link_info
->callbacks
->undefined_symbol
)
8100 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
8101 input_bfd
, input_section
, (*parent
)->address
,
8105 case bfd_reloc_dangerous
:
8106 BFD_ASSERT (error_message
!= (char *) NULL
);
8107 if (!((*link_info
->callbacks
->reloc_dangerous
)
8108 (link_info
, error_message
, input_bfd
, input_section
,
8109 (*parent
)->address
)))
8112 case bfd_reloc_overflow
:
8113 if (!((*link_info
->callbacks
->reloc_overflow
)
8114 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
8115 (*parent
)->howto
->name
, (*parent
)->addend
,
8116 input_bfd
, input_section
, (*parent
)->address
)))
8119 case bfd_reloc_outofrange
:
8128 if (reloc_vector
!= NULL
)
8129 free (reloc_vector
);
8133 if (reloc_vector
!= NULL
)
8134 free (reloc_vector
);
8138 /* Create a MIPS ELF linker hash table. */
8140 struct bfd_link_hash_table
*
8141 _bfd_mips_elf_link_hash_table_create (abfd
)
8144 struct mips_elf_link_hash_table
*ret
;
8145 bfd_size_type amt
= sizeof (struct mips_elf_link_hash_table
);
8147 ret
= (struct mips_elf_link_hash_table
*) bfd_malloc (amt
);
8148 if (ret
== (struct mips_elf_link_hash_table
*) NULL
)
8151 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
8152 mips_elf_link_hash_newfunc
))
8159 /* We no longer use this. */
8160 for (i
= 0; i
< SIZEOF_MIPS_DYNSYM_SECNAMES
; i
++)
8161 ret
->dynsym_sec_strindex
[i
] = (bfd_size_type
) -1;
8163 ret
->procedure_count
= 0;
8164 ret
->compact_rel_size
= 0;
8165 ret
->use_rld_obj_head
= FALSE
;
8167 ret
->mips16_stubs_seen
= FALSE
;
8169 return &ret
->root
.root
;
8172 /* We need to use a special link routine to handle the .reginfo and
8173 the .mdebug sections. We need to merge all instances of these
8174 sections together, not write them all out sequentially. */
8177 _bfd_mips_elf_final_link (abfd
, info
)
8179 struct bfd_link_info
*info
;
8183 struct bfd_link_order
*p
;
8184 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
8185 asection
*rtproc_sec
;
8186 Elf32_RegInfo reginfo
;
8187 struct ecoff_debug_info debug
;
8188 const struct ecoff_debug_swap
*swap
8189 = get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
8190 HDRR
*symhdr
= &debug
.symbolic_header
;
8191 PTR mdebug_handle
= NULL
;
8197 static const char * const secname
[] =
8199 ".text", ".init", ".fini", ".data",
8200 ".rodata", ".sdata", ".sbss", ".bss"
8202 static const int sc
[] =
8204 scText
, scInit
, scFini
, scData
,
8205 scRData
, scSData
, scSBss
, scBss
8208 /* We'd carefully arranged the dynamic symbol indices, and then the
8209 generic size_dynamic_sections renumbered them out from under us.
8210 Rather than trying somehow to prevent the renumbering, just do
8212 if (elf_hash_table (info
)->dynamic_sections_created
)
8216 struct mips_got_info
*g
;
8218 /* When we resort, we must tell mips_elf_sort_hash_table what
8219 the lowest index it may use is. That's the number of section
8220 symbols we're going to add. The generic ELF linker only
8221 adds these symbols when building a shared object. Note that
8222 we count the sections after (possibly) removing the .options
8224 if (! mips_elf_sort_hash_table (info
, (info
->shared
8225 ? bfd_count_sections (abfd
) + 1
8229 /* Make sure we didn't grow the global .got region. */
8230 dynobj
= elf_hash_table (info
)->dynobj
;
8231 got
= mips_elf_got_section (dynobj
, FALSE
);
8232 g
= mips_elf_section_data (got
)->u
.got_info
;
8234 if (g
->global_gotsym
!= NULL
)
8235 BFD_ASSERT ((elf_hash_table (info
)->dynsymcount
8236 - g
->global_gotsym
->dynindx
)
8237 <= g
->global_gotno
);
8241 /* We want to set the GP value for ld -r. */
8242 /* On IRIX5, we omit the .options section. On IRIX6, however, we
8243 include it, even though we don't process it quite right. (Some
8244 entries are supposed to be merged.) Empirically, we seem to be
8245 better off including it then not. */
8246 if (IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
8247 for (secpp
= &abfd
->sections
; *secpp
!= NULL
; secpp
= &(*secpp
)->next
)
8249 if (strcmp ((*secpp
)->name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
8251 for (p
= (*secpp
)->link_order_head
; p
!= NULL
; p
= p
->next
)
8252 if (p
->type
== bfd_indirect_link_order
)
8253 p
->u
.indirect
.section
->flags
&= ~SEC_HAS_CONTENTS
;
8254 (*secpp
)->link_order_head
= NULL
;
8255 bfd_section_list_remove (abfd
, secpp
);
8256 --abfd
->section_count
;
8262 /* We include .MIPS.options, even though we don't process it quite right.
8263 (Some entries are supposed to be merged.) At IRIX6 empirically we seem
8264 to be better off including it than not. */
8265 for (secpp
= &abfd
->sections
; *secpp
!= NULL
; secpp
= &(*secpp
)->next
)
8267 if (strcmp ((*secpp
)->name
, ".MIPS.options") == 0)
8269 for (p
= (*secpp
)->link_order_head
; p
!= NULL
; p
= p
->next
)
8270 if (p
->type
== bfd_indirect_link_order
)
8271 p
->u
.indirect
.section
->flags
&=~ SEC_HAS_CONTENTS
;
8272 (*secpp
)->link_order_head
= NULL
;
8273 bfd_section_list_remove (abfd
, secpp
);
8274 --abfd
->section_count
;
8281 /* Get a value for the GP register. */
8282 if (elf_gp (abfd
) == 0)
8284 struct bfd_link_hash_entry
*h
;
8286 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
8287 if (h
!= (struct bfd_link_hash_entry
*) NULL
8288 && h
->type
== bfd_link_hash_defined
)
8289 elf_gp (abfd
) = (h
->u
.def
.value
8290 + h
->u
.def
.section
->output_section
->vma
8291 + h
->u
.def
.section
->output_offset
);
8292 else if (info
->relocatable
)
8294 bfd_vma lo
= MINUS_ONE
;
8296 /* Find the GP-relative section with the lowest offset. */
8297 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
8299 && (elf_section_data (o
)->this_hdr
.sh_flags
& SHF_MIPS_GPREL
))
8302 /* And calculate GP relative to that. */
8303 elf_gp (abfd
) = lo
+ ELF_MIPS_GP_OFFSET (abfd
);
8307 /* If the relocate_section function needs to do a reloc
8308 involving the GP value, it should make a reloc_dangerous
8309 callback to warn that GP is not defined. */
8313 /* Go through the sections and collect the .reginfo and .mdebug
8317 gptab_data_sec
= NULL
;
8318 gptab_bss_sec
= NULL
;
8319 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
8321 if (strcmp (o
->name
, ".reginfo") == 0)
8323 memset (®info
, 0, sizeof reginfo
);
8325 /* We have found the .reginfo section in the output file.
8326 Look through all the link_orders comprising it and merge
8327 the information together. */
8328 for (p
= o
->link_order_head
;
8329 p
!= (struct bfd_link_order
*) NULL
;
8332 asection
*input_section
;
8334 Elf32_External_RegInfo ext
;
8337 if (p
->type
!= bfd_indirect_link_order
)
8339 if (p
->type
== bfd_data_link_order
)
8344 input_section
= p
->u
.indirect
.section
;
8345 input_bfd
= input_section
->owner
;
8347 /* The linker emulation code has probably clobbered the
8348 size to be zero bytes. */
8349 if (input_section
->_raw_size
== 0)
8350 input_section
->_raw_size
= sizeof (Elf32_External_RegInfo
);
8352 if (! bfd_get_section_contents (input_bfd
, input_section
,
8355 (bfd_size_type
) sizeof ext
))
8358 bfd_mips_elf32_swap_reginfo_in (input_bfd
, &ext
, &sub
);
8360 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
8361 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
8362 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
8363 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
8364 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
8366 /* ri_gp_value is set by the function
8367 mips_elf32_section_processing when the section is
8368 finally written out. */
8370 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8371 elf_link_input_bfd ignores this section. */
8372 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8375 /* Size has been set in _bfd_mips_elf_always_size_sections. */
8376 BFD_ASSERT(o
->_raw_size
== sizeof (Elf32_External_RegInfo
));
8378 /* Skip this section later on (I don't think this currently
8379 matters, but someday it might). */
8380 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
8385 if (strcmp (o
->name
, ".mdebug") == 0)
8387 struct extsym_info einfo
;
8390 /* We have found the .mdebug section in the output file.
8391 Look through all the link_orders comprising it and merge
8392 the information together. */
8393 symhdr
->magic
= swap
->sym_magic
;
8394 /* FIXME: What should the version stamp be? */
8396 symhdr
->ilineMax
= 0;
8400 symhdr
->isymMax
= 0;
8401 symhdr
->ioptMax
= 0;
8402 symhdr
->iauxMax
= 0;
8404 symhdr
->issExtMax
= 0;
8407 symhdr
->iextMax
= 0;
8409 /* We accumulate the debugging information itself in the
8410 debug_info structure. */
8412 debug
.external_dnr
= NULL
;
8413 debug
.external_pdr
= NULL
;
8414 debug
.external_sym
= NULL
;
8415 debug
.external_opt
= NULL
;
8416 debug
.external_aux
= NULL
;
8418 debug
.ssext
= debug
.ssext_end
= NULL
;
8419 debug
.external_fdr
= NULL
;
8420 debug
.external_rfd
= NULL
;
8421 debug
.external_ext
= debug
.external_ext_end
= NULL
;
8423 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
8424 if (mdebug_handle
== (PTR
) NULL
)
8428 esym
.cobol_main
= 0;
8432 esym
.asym
.iss
= issNil
;
8433 esym
.asym
.st
= stLocal
;
8434 esym
.asym
.reserved
= 0;
8435 esym
.asym
.index
= indexNil
;
8437 for (i
= 0; i
< sizeof (secname
) / sizeof (secname
[0]); i
++)
8439 esym
.asym
.sc
= sc
[i
];
8440 s
= bfd_get_section_by_name (abfd
, secname
[i
]);
8443 esym
.asym
.value
= s
->vma
;
8444 last
= s
->vma
+ s
->_raw_size
;
8447 esym
.asym
.value
= last
;
8448 if (!bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
8453 for (p
= o
->link_order_head
;
8454 p
!= (struct bfd_link_order
*) NULL
;
8457 asection
*input_section
;
8459 const struct ecoff_debug_swap
*input_swap
;
8460 struct ecoff_debug_info input_debug
;
8464 if (p
->type
!= bfd_indirect_link_order
)
8466 if (p
->type
== bfd_data_link_order
)
8471 input_section
= p
->u
.indirect
.section
;
8472 input_bfd
= input_section
->owner
;
8474 if (bfd_get_flavour (input_bfd
) != bfd_target_elf_flavour
8475 || (get_elf_backend_data (input_bfd
)
8476 ->elf_backend_ecoff_debug_swap
) == NULL
)
8478 /* I don't know what a non MIPS ELF bfd would be
8479 doing with a .mdebug section, but I don't really
8480 want to deal with it. */
8484 input_swap
= (get_elf_backend_data (input_bfd
)
8485 ->elf_backend_ecoff_debug_swap
);
8487 BFD_ASSERT (p
->size
== input_section
->_raw_size
);
8489 /* The ECOFF linking code expects that we have already
8490 read in the debugging information and set up an
8491 ecoff_debug_info structure, so we do that now. */
8492 if (! _bfd_mips_elf_read_ecoff_info (input_bfd
, input_section
,
8496 if (! (bfd_ecoff_debug_accumulate
8497 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
8498 &input_debug
, input_swap
, info
)))
8501 /* Loop through the external symbols. For each one with
8502 interesting information, try to find the symbol in
8503 the linker global hash table and save the information
8504 for the output external symbols. */
8505 eraw_src
= input_debug
.external_ext
;
8506 eraw_end
= (eraw_src
8507 + (input_debug
.symbolic_header
.iextMax
8508 * input_swap
->external_ext_size
));
8510 eraw_src
< eraw_end
;
8511 eraw_src
+= input_swap
->external_ext_size
)
8515 struct mips_elf_link_hash_entry
*h
;
8517 (*input_swap
->swap_ext_in
) (input_bfd
, (PTR
) eraw_src
, &ext
);
8518 if (ext
.asym
.sc
== scNil
8519 || ext
.asym
.sc
== scUndefined
8520 || ext
.asym
.sc
== scSUndefined
)
8523 name
= input_debug
.ssext
+ ext
.asym
.iss
;
8524 h
= mips_elf_link_hash_lookup (mips_elf_hash_table (info
),
8525 name
, FALSE
, FALSE
, TRUE
);
8526 if (h
== NULL
|| h
->esym
.ifd
!= -2)
8532 < input_debug
.symbolic_header
.ifdMax
);
8533 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
8539 /* Free up the information we just read. */
8540 free (input_debug
.line
);
8541 free (input_debug
.external_dnr
);
8542 free (input_debug
.external_pdr
);
8543 free (input_debug
.external_sym
);
8544 free (input_debug
.external_opt
);
8545 free (input_debug
.external_aux
);
8546 free (input_debug
.ss
);
8547 free (input_debug
.ssext
);
8548 free (input_debug
.external_fdr
);
8549 free (input_debug
.external_rfd
);
8550 free (input_debug
.external_ext
);
8552 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8553 elf_link_input_bfd ignores this section. */
8554 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8557 if (SGI_COMPAT (abfd
) && info
->shared
)
8559 /* Create .rtproc section. */
8560 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
8561 if (rtproc_sec
== NULL
)
8563 flagword flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
8564 | SEC_LINKER_CREATED
| SEC_READONLY
);
8566 rtproc_sec
= bfd_make_section (abfd
, ".rtproc");
8567 if (rtproc_sec
== NULL
8568 || ! bfd_set_section_flags (abfd
, rtproc_sec
, flags
)
8569 || ! bfd_set_section_alignment (abfd
, rtproc_sec
, 4))
8573 if (! mips_elf_create_procedure_table (mdebug_handle
, abfd
,
8579 /* Build the external symbol information. */
8582 einfo
.debug
= &debug
;
8584 einfo
.failed
= FALSE
;
8585 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
8586 mips_elf_output_extsym
,
8591 /* Set the size of the .mdebug section. */
8592 o
->_raw_size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
8594 /* Skip this section later on (I don't think this currently
8595 matters, but someday it might). */
8596 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
8601 if (strncmp (o
->name
, ".gptab.", sizeof ".gptab." - 1) == 0)
8603 const char *subname
;
8606 Elf32_External_gptab
*ext_tab
;
8609 /* The .gptab.sdata and .gptab.sbss sections hold
8610 information describing how the small data area would
8611 change depending upon the -G switch. These sections
8612 not used in executables files. */
8613 if (! info
->relocatable
)
8615 for (p
= o
->link_order_head
;
8616 p
!= (struct bfd_link_order
*) NULL
;
8619 asection
*input_section
;
8621 if (p
->type
!= bfd_indirect_link_order
)
8623 if (p
->type
== bfd_data_link_order
)
8628 input_section
= p
->u
.indirect
.section
;
8630 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8631 elf_link_input_bfd ignores this section. */
8632 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8635 /* Skip this section later on (I don't think this
8636 currently matters, but someday it might). */
8637 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
8639 /* Really remove the section. */
8640 for (secpp
= &abfd
->sections
;
8642 secpp
= &(*secpp
)->next
)
8644 bfd_section_list_remove (abfd
, secpp
);
8645 --abfd
->section_count
;
8650 /* There is one gptab for initialized data, and one for
8651 uninitialized data. */
8652 if (strcmp (o
->name
, ".gptab.sdata") == 0)
8654 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
8658 (*_bfd_error_handler
)
8659 (_("%s: illegal section name `%s'"),
8660 bfd_get_filename (abfd
), o
->name
);
8661 bfd_set_error (bfd_error_nonrepresentable_section
);
8665 /* The linker script always combines .gptab.data and
8666 .gptab.sdata into .gptab.sdata, and likewise for
8667 .gptab.bss and .gptab.sbss. It is possible that there is
8668 no .sdata or .sbss section in the output file, in which
8669 case we must change the name of the output section. */
8670 subname
= o
->name
+ sizeof ".gptab" - 1;
8671 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
8673 if (o
== gptab_data_sec
)
8674 o
->name
= ".gptab.data";
8676 o
->name
= ".gptab.bss";
8677 subname
= o
->name
+ sizeof ".gptab" - 1;
8678 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
8681 /* Set up the first entry. */
8683 amt
= c
* sizeof (Elf32_gptab
);
8684 tab
= (Elf32_gptab
*) bfd_malloc (amt
);
8687 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
8688 tab
[0].gt_header
.gt_unused
= 0;
8690 /* Combine the input sections. */
8691 for (p
= o
->link_order_head
;
8692 p
!= (struct bfd_link_order
*) NULL
;
8695 asection
*input_section
;
8699 bfd_size_type gpentry
;
8701 if (p
->type
!= bfd_indirect_link_order
)
8703 if (p
->type
== bfd_data_link_order
)
8708 input_section
= p
->u
.indirect
.section
;
8709 input_bfd
= input_section
->owner
;
8711 /* Combine the gptab entries for this input section one
8712 by one. We know that the input gptab entries are
8713 sorted by ascending -G value. */
8714 size
= bfd_section_size (input_bfd
, input_section
);
8716 for (gpentry
= sizeof (Elf32_External_gptab
);
8718 gpentry
+= sizeof (Elf32_External_gptab
))
8720 Elf32_External_gptab ext_gptab
;
8721 Elf32_gptab int_gptab
;
8727 if (! (bfd_get_section_contents
8728 (input_bfd
, input_section
, (PTR
) &ext_gptab
,
8730 (bfd_size_type
) sizeof (Elf32_External_gptab
))))
8736 bfd_mips_elf32_swap_gptab_in (input_bfd
, &ext_gptab
,
8738 val
= int_gptab
.gt_entry
.gt_g_value
;
8739 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
8742 for (look
= 1; look
< c
; look
++)
8744 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
8745 tab
[look
].gt_entry
.gt_bytes
+= add
;
8747 if (tab
[look
].gt_entry
.gt_g_value
== val
)
8753 Elf32_gptab
*new_tab
;
8756 /* We need a new table entry. */
8757 amt
= (bfd_size_type
) (c
+ 1) * sizeof (Elf32_gptab
);
8758 new_tab
= (Elf32_gptab
*) bfd_realloc ((PTR
) tab
, amt
);
8759 if (new_tab
== NULL
)
8765 tab
[c
].gt_entry
.gt_g_value
= val
;
8766 tab
[c
].gt_entry
.gt_bytes
= add
;
8768 /* Merge in the size for the next smallest -G
8769 value, since that will be implied by this new
8772 for (look
= 1; look
< c
; look
++)
8774 if (tab
[look
].gt_entry
.gt_g_value
< val
8776 || (tab
[look
].gt_entry
.gt_g_value
8777 > tab
[max
].gt_entry
.gt_g_value
)))
8781 tab
[c
].gt_entry
.gt_bytes
+=
8782 tab
[max
].gt_entry
.gt_bytes
;
8787 last
= int_gptab
.gt_entry
.gt_bytes
;
8790 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8791 elf_link_input_bfd ignores this section. */
8792 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8795 /* The table must be sorted by -G value. */
8797 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
8799 /* Swap out the table. */
8800 amt
= (bfd_size_type
) c
* sizeof (Elf32_External_gptab
);
8801 ext_tab
= (Elf32_External_gptab
*) bfd_alloc (abfd
, amt
);
8802 if (ext_tab
== NULL
)
8808 for (j
= 0; j
< c
; j
++)
8809 bfd_mips_elf32_swap_gptab_out (abfd
, tab
+ j
, ext_tab
+ j
);
8812 o
->_raw_size
= c
* sizeof (Elf32_External_gptab
);
8813 o
->contents
= (bfd_byte
*) ext_tab
;
8815 /* Skip this section later on (I don't think this currently
8816 matters, but someday it might). */
8817 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
8821 /* Invoke the regular ELF backend linker to do all the work. */
8822 if (!MNAME(abfd
,bfd_elf
,bfd_final_link
) (abfd
, info
))
8825 /* Now write out the computed sections. */
8827 if (reginfo_sec
!= (asection
*) NULL
)
8829 Elf32_External_RegInfo ext
;
8831 bfd_mips_elf32_swap_reginfo_out (abfd
, ®info
, &ext
);
8832 if (! bfd_set_section_contents (abfd
, reginfo_sec
, (PTR
) &ext
,
8834 (bfd_size_type
) sizeof ext
))
8838 if (mdebug_sec
!= (asection
*) NULL
)
8840 BFD_ASSERT (abfd
->output_has_begun
);
8841 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
8843 mdebug_sec
->filepos
))
8846 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
8849 if (gptab_data_sec
!= (asection
*) NULL
)
8851 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
8852 gptab_data_sec
->contents
,
8854 gptab_data_sec
->_raw_size
))
8858 if (gptab_bss_sec
!= (asection
*) NULL
)
8860 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
8861 gptab_bss_sec
->contents
,
8863 gptab_bss_sec
->_raw_size
))
8867 if (SGI_COMPAT (abfd
))
8869 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
8870 if (rtproc_sec
!= NULL
)
8872 if (! bfd_set_section_contents (abfd
, rtproc_sec
,
8873 rtproc_sec
->contents
,
8875 rtproc_sec
->_raw_size
))
8883 /* Structure for saying that BFD machine EXTENSION extends BASE. */
8885 struct mips_mach_extension
{
8886 unsigned long extension
, base
;
8890 /* An array describing how BFD machines relate to one another. The entries
8891 are ordered topologically with MIPS I extensions listed last. */
8893 static const struct mips_mach_extension mips_mach_extensions
[] = {
8894 /* MIPS64 extensions. */
8895 { bfd_mach_mipsisa64r2
, bfd_mach_mipsisa64
},
8896 { bfd_mach_mips_sb1
, bfd_mach_mipsisa64
},
8898 /* MIPS V extensions. */
8899 { bfd_mach_mipsisa64
, bfd_mach_mips5
},
8901 /* R10000 extensions. */
8902 { bfd_mach_mips12000
, bfd_mach_mips10000
},
8904 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
8905 vr5400 ISA, but doesn't include the multimedia stuff. It seems
8906 better to allow vr5400 and vr5500 code to be merged anyway, since
8907 many libraries will just use the core ISA. Perhaps we could add
8908 some sort of ASE flag if this ever proves a problem. */
8909 { bfd_mach_mips5500
, bfd_mach_mips5400
},
8910 { bfd_mach_mips5400
, bfd_mach_mips5000
},
8912 /* MIPS IV extensions. */
8913 { bfd_mach_mips5
, bfd_mach_mips8000
},
8914 { bfd_mach_mips10000
, bfd_mach_mips8000
},
8915 { bfd_mach_mips5000
, bfd_mach_mips8000
},
8916 { bfd_mach_mips7000
, bfd_mach_mips8000
},
8918 /* VR4100 extensions. */
8919 { bfd_mach_mips4120
, bfd_mach_mips4100
},
8920 { bfd_mach_mips4111
, bfd_mach_mips4100
},
8922 /* MIPS III extensions. */
8923 { bfd_mach_mips8000
, bfd_mach_mips4000
},
8924 { bfd_mach_mips4650
, bfd_mach_mips4000
},
8925 { bfd_mach_mips4600
, bfd_mach_mips4000
},
8926 { bfd_mach_mips4400
, bfd_mach_mips4000
},
8927 { bfd_mach_mips4300
, bfd_mach_mips4000
},
8928 { bfd_mach_mips4100
, bfd_mach_mips4000
},
8929 { bfd_mach_mips4010
, bfd_mach_mips4000
},
8931 /* MIPS32 extensions. */
8932 { bfd_mach_mipsisa32r2
, bfd_mach_mipsisa32
},
8934 /* MIPS II extensions. */
8935 { bfd_mach_mips4000
, bfd_mach_mips6000
},
8936 { bfd_mach_mipsisa32
, bfd_mach_mips6000
},
8938 /* MIPS I extensions. */
8939 { bfd_mach_mips6000
, bfd_mach_mips3000
},
8940 { bfd_mach_mips3900
, bfd_mach_mips3000
}
8944 /* Return true if bfd machine EXTENSION is an extension of machine BASE. */
8947 mips_mach_extends_p (base
, extension
)
8948 unsigned long base
, extension
;
8952 for (i
= 0; extension
!= base
&& i
< ARRAY_SIZE (mips_mach_extensions
); i
++)
8953 if (extension
== mips_mach_extensions
[i
].extension
)
8954 extension
= mips_mach_extensions
[i
].base
;
8956 return extension
== base
;
8960 /* Return true if the given ELF header flags describe a 32-bit binary. */
8963 mips_32bit_flags_p (flags
)
8966 return ((flags
& EF_MIPS_32BITMODE
) != 0
8967 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
8968 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
8969 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
8970 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
8971 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
8972 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
);
8976 /* Merge backend specific data from an object file to the output
8977 object file when linking. */
8980 _bfd_mips_elf_merge_private_bfd_data (ibfd
, obfd
)
8987 bfd_boolean null_input_bfd
= TRUE
;
8990 /* Check if we have the same endianess */
8991 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
8993 (*_bfd_error_handler
)
8994 (_("%s: endianness incompatible with that of the selected emulation"),
8995 bfd_archive_filename (ibfd
));
8999 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
9000 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
9003 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
9005 (*_bfd_error_handler
)
9006 (_("%s: ABI is incompatible with that of the selected emulation"),
9007 bfd_archive_filename (ibfd
));
9011 new_flags
= elf_elfheader (ibfd
)->e_flags
;
9012 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_NOREORDER
;
9013 old_flags
= elf_elfheader (obfd
)->e_flags
;
9015 if (! elf_flags_init (obfd
))
9017 elf_flags_init (obfd
) = TRUE
;
9018 elf_elfheader (obfd
)->e_flags
= new_flags
;
9019 elf_elfheader (obfd
)->e_ident
[EI_CLASS
]
9020 = elf_elfheader (ibfd
)->e_ident
[EI_CLASS
];
9022 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
9023 && bfd_get_arch_info (obfd
)->the_default
)
9025 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
9026 bfd_get_mach (ibfd
)))
9033 /* Check flag compatibility. */
9035 new_flags
&= ~EF_MIPS_NOREORDER
;
9036 old_flags
&= ~EF_MIPS_NOREORDER
;
9038 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
9039 doesn't seem to matter. */
9040 new_flags
&= ~EF_MIPS_XGOT
;
9041 old_flags
&= ~EF_MIPS_XGOT
;
9043 /* MIPSpro generates ucode info in n64 objects. Again, we should
9044 just be able to ignore this. */
9045 new_flags
&= ~EF_MIPS_UCODE
;
9046 old_flags
&= ~EF_MIPS_UCODE
;
9048 if (new_flags
== old_flags
)
9051 /* Check to see if the input BFD actually contains any sections.
9052 If not, its flags may not have been initialised either, but it cannot
9053 actually cause any incompatibility. */
9054 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
9056 /* Ignore synthetic sections and empty .text, .data and .bss sections
9057 which are automatically generated by gas. */
9058 if (strcmp (sec
->name
, ".reginfo")
9059 && strcmp (sec
->name
, ".mdebug")
9060 && ((!strcmp (sec
->name
, ".text")
9061 || !strcmp (sec
->name
, ".data")
9062 || !strcmp (sec
->name
, ".bss"))
9063 && sec
->_raw_size
!= 0))
9065 null_input_bfd
= FALSE
;
9074 if (((new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0)
9075 != ((old_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0))
9077 (*_bfd_error_handler
)
9078 (_("%s: warning: linking PIC files with non-PIC files"),
9079 bfd_archive_filename (ibfd
));
9083 if (new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
))
9084 elf_elfheader (obfd
)->e_flags
|= EF_MIPS_CPIC
;
9085 if (! (new_flags
& EF_MIPS_PIC
))
9086 elf_elfheader (obfd
)->e_flags
&= ~EF_MIPS_PIC
;
9088 new_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
9089 old_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
9091 /* Compare the ISAs. */
9092 if (mips_32bit_flags_p (old_flags
) != mips_32bit_flags_p (new_flags
))
9094 (*_bfd_error_handler
)
9095 (_("%s: linking 32-bit code with 64-bit code"),
9096 bfd_archive_filename (ibfd
));
9099 else if (!mips_mach_extends_p (bfd_get_mach (ibfd
), bfd_get_mach (obfd
)))
9101 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
9102 if (mips_mach_extends_p (bfd_get_mach (obfd
), bfd_get_mach (ibfd
)))
9104 /* Copy the architecture info from IBFD to OBFD. Also copy
9105 the 32-bit flag (if set) so that we continue to recognise
9106 OBFD as a 32-bit binary. */
9107 bfd_set_arch_info (obfd
, bfd_get_arch_info (ibfd
));
9108 elf_elfheader (obfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
9109 elf_elfheader (obfd
)->e_flags
9110 |= new_flags
& (EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9112 /* Copy across the ABI flags if OBFD doesn't use them
9113 and if that was what caused us to treat IBFD as 32-bit. */
9114 if ((old_flags
& EF_MIPS_ABI
) == 0
9115 && mips_32bit_flags_p (new_flags
)
9116 && !mips_32bit_flags_p (new_flags
& ~EF_MIPS_ABI
))
9117 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ABI
;
9121 /* The ISAs aren't compatible. */
9122 (*_bfd_error_handler
)
9123 (_("%s: linking %s module with previous %s modules"),
9124 bfd_archive_filename (ibfd
),
9125 bfd_printable_name (ibfd
),
9126 bfd_printable_name (obfd
));
9131 new_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9132 old_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9134 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
9135 does set EI_CLASS differently from any 32-bit ABI. */
9136 if ((new_flags
& EF_MIPS_ABI
) != (old_flags
& EF_MIPS_ABI
)
9137 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
9138 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
9140 /* Only error if both are set (to different values). */
9141 if (((new_flags
& EF_MIPS_ABI
) && (old_flags
& EF_MIPS_ABI
))
9142 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
9143 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
9145 (*_bfd_error_handler
)
9146 (_("%s: ABI mismatch: linking %s module with previous %s modules"),
9147 bfd_archive_filename (ibfd
),
9148 elf_mips_abi_name (ibfd
),
9149 elf_mips_abi_name (obfd
));
9152 new_flags
&= ~EF_MIPS_ABI
;
9153 old_flags
&= ~EF_MIPS_ABI
;
9156 /* For now, allow arbitrary mixing of ASEs (retain the union). */
9157 if ((new_flags
& EF_MIPS_ARCH_ASE
) != (old_flags
& EF_MIPS_ARCH_ASE
))
9159 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ARCH_ASE
;
9161 new_flags
&= ~ EF_MIPS_ARCH_ASE
;
9162 old_flags
&= ~ EF_MIPS_ARCH_ASE
;
9165 /* Warn about any other mismatches */
9166 if (new_flags
!= old_flags
)
9168 (*_bfd_error_handler
)
9169 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
9170 bfd_archive_filename (ibfd
), (unsigned long) new_flags
,
9171 (unsigned long) old_flags
);
9177 bfd_set_error (bfd_error_bad_value
);
9184 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
9187 _bfd_mips_elf_set_private_flags (abfd
, flags
)
9191 BFD_ASSERT (!elf_flags_init (abfd
)
9192 || elf_elfheader (abfd
)->e_flags
== flags
);
9194 elf_elfheader (abfd
)->e_flags
= flags
;
9195 elf_flags_init (abfd
) = TRUE
;
9200 _bfd_mips_elf_print_private_bfd_data (abfd
, ptr
)
9204 FILE *file
= (FILE *) ptr
;
9206 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
9208 /* Print normal ELF private data. */
9209 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
9211 /* xgettext:c-format */
9212 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
9214 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
)
9215 fprintf (file
, _(" [abi=O32]"));
9216 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O64
)
9217 fprintf (file
, _(" [abi=O64]"));
9218 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
)
9219 fprintf (file
, _(" [abi=EABI32]"));
9220 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
9221 fprintf (file
, _(" [abi=EABI64]"));
9222 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
))
9223 fprintf (file
, _(" [abi unknown]"));
9224 else if (ABI_N32_P (abfd
))
9225 fprintf (file
, _(" [abi=N32]"));
9226 else if (ABI_64_P (abfd
))
9227 fprintf (file
, _(" [abi=64]"));
9229 fprintf (file
, _(" [no abi set]"));
9231 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
9232 fprintf (file
, _(" [mips1]"));
9233 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
9234 fprintf (file
, _(" [mips2]"));
9235 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
9236 fprintf (file
, _(" [mips3]"));
9237 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
9238 fprintf (file
, _(" [mips4]"));
9239 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_5
)
9240 fprintf (file
, _(" [mips5]"));
9241 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
)
9242 fprintf (file
, _(" [mips32]"));
9243 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64
)
9244 fprintf (file
, _(" [mips64]"));
9245 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
)
9246 fprintf (file
, _(" [mips32r2]"));
9247 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64R2
)
9248 fprintf (file
, _(" [mips64r2]"));
9250 fprintf (file
, _(" [unknown ISA]"));
9252 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
9253 fprintf (file
, _(" [mdmx]"));
9255 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_M16
)
9256 fprintf (file
, _(" [mips16]"));
9258 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_32BITMODE
)
9259 fprintf (file
, _(" [32bitmode]"));
9261 fprintf (file
, _(" [not 32bitmode]"));
9268 struct bfd_elf_special_section
const _bfd_mips_elf_special_sections
[]=
9270 { ".sdata", 6, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9271 { ".sbss", 5, -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9272 { ".lit4", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9273 { ".lit8", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9274 { ".ucode", 6, 0, SHT_MIPS_UCODE
, 0 },
9275 { ".mdebug", 7, 0, SHT_MIPS_DEBUG
, 0 },
9276 { NULL
, 0, 0, 0, 0 }