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_set_no_stub
PARAMS ((void **, void *));
475 static int mips_elf_resolve_final_got_entry
PARAMS ((void**, void *));
476 static void mips_elf_resolve_final_got_entries
477 PARAMS ((struct mips_got_info
*));
478 static bfd_vma mips_elf_adjust_gp
479 PARAMS ((bfd
*, struct mips_got_info
*, bfd
*));
480 static struct mips_got_info
*mips_elf_got_for_ibfd
481 PARAMS ((struct mips_got_info
*, bfd
*));
483 /* This will be used when we sort the dynamic relocation records. */
484 static bfd
*reldyn_sorting_bfd
;
486 /* Nonzero if ABFD is using the N32 ABI. */
488 #define ABI_N32_P(abfd) \
489 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
491 /* Nonzero if ABFD is using the N64 ABI. */
492 #define ABI_64_P(abfd) \
493 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
495 /* Nonzero if ABFD is using NewABI conventions. */
496 #define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
498 /* The IRIX compatibility level we are striving for. */
499 #define IRIX_COMPAT(abfd) \
500 (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
502 /* Whether we are trying to be compatible with IRIX at all. */
503 #define SGI_COMPAT(abfd) \
504 (IRIX_COMPAT (abfd) != ict_none)
506 /* The name of the options section. */
507 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
508 (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
510 /* The name of the stub section. */
511 #define MIPS_ELF_STUB_SECTION_NAME(abfd) \
512 (NEWABI_P (abfd) ? ".MIPS.stubs" : ".stub")
514 /* The size of an external REL relocation. */
515 #define MIPS_ELF_REL_SIZE(abfd) \
516 (get_elf_backend_data (abfd)->s->sizeof_rel)
518 /* The size of an external dynamic table entry. */
519 #define MIPS_ELF_DYN_SIZE(abfd) \
520 (get_elf_backend_data (abfd)->s->sizeof_dyn)
522 /* The size of a GOT entry. */
523 #define MIPS_ELF_GOT_SIZE(abfd) \
524 (get_elf_backend_data (abfd)->s->arch_size / 8)
526 /* The size of a symbol-table entry. */
527 #define MIPS_ELF_SYM_SIZE(abfd) \
528 (get_elf_backend_data (abfd)->s->sizeof_sym)
530 /* The default alignment for sections, as a power of two. */
531 #define MIPS_ELF_LOG_FILE_ALIGN(abfd) \
532 (get_elf_backend_data (abfd)->s->log_file_align)
534 /* Get word-sized data. */
535 #define MIPS_ELF_GET_WORD(abfd, ptr) \
536 (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
538 /* Put out word-sized data. */
539 #define MIPS_ELF_PUT_WORD(abfd, val, ptr) \
541 ? bfd_put_64 (abfd, val, ptr) \
542 : bfd_put_32 (abfd, val, ptr))
544 /* Add a dynamic symbol table-entry. */
546 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
547 (ABI_64_P (elf_hash_table (info)->dynobj) \
548 ? bfd_elf64_add_dynamic_entry (info, (bfd_vma) tag, (bfd_vma) val) \
549 : bfd_elf32_add_dynamic_entry (info, (bfd_vma) tag, (bfd_vma) val))
551 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
552 (ABI_64_P (elf_hash_table (info)->dynobj) \
553 ? (abort (), FALSE) \
554 : bfd_elf32_add_dynamic_entry (info, (bfd_vma) tag, (bfd_vma) val))
557 #define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela) \
558 (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela))
560 /* Determine whether the internal relocation of index REL_IDX is REL
561 (zero) or RELA (non-zero). The assumption is that, if there are
562 two relocation sections for this section, one of them is REL and
563 the other is RELA. If the index of the relocation we're testing is
564 in range for the first relocation section, check that the external
565 relocation size is that for RELA. It is also assumed that, if
566 rel_idx is not in range for the first section, and this first
567 section contains REL relocs, then the relocation is in the second
568 section, that is RELA. */
569 #define MIPS_RELOC_RELA_P(abfd, sec, rel_idx) \
570 ((NUM_SHDR_ENTRIES (&elf_section_data (sec)->rel_hdr) \
571 * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel \
572 > (bfd_vma)(rel_idx)) \
573 == (elf_section_data (sec)->rel_hdr.sh_entsize \
574 == (ABI_64_P (abfd) ? sizeof (Elf64_External_Rela) \
575 : sizeof (Elf32_External_Rela))))
577 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
578 from smaller values. Start with zero, widen, *then* decrement. */
579 #define MINUS_ONE (((bfd_vma)0) - 1)
581 /* The number of local .got entries we reserve. */
582 #define MIPS_RESERVED_GOTNO (2)
584 /* The offset of $gp from the beginning of the .got section. */
585 #define ELF_MIPS_GP_OFFSET(abfd) (0x7ff0)
587 /* The maximum size of the GOT for it to be addressable using 16-bit
589 #define MIPS_ELF_GOT_MAX_SIZE(abfd) (ELF_MIPS_GP_OFFSET(abfd) + 0x7fff)
591 /* Instructions which appear in a stub. */
592 #define STUB_LW(abfd) \
594 ? 0xdf998010 /* ld t9,0x8010(gp) */ \
595 : 0x8f998010)) /* lw t9,0x8010(gp) */
596 #define STUB_MOVE(abfd) \
598 ? 0x03e0782d /* daddu t7,ra */ \
599 : 0x03e07821)) /* addu t7,ra */
600 #define STUB_JALR 0x0320f809 /* jalr t9,ra */
601 #define STUB_LI16(abfd) \
603 ? 0x64180000 /* daddiu t8,zero,0 */ \
604 : 0x24180000)) /* addiu t8,zero,0 */
605 #define MIPS_FUNCTION_STUB_SIZE (16)
607 /* The name of the dynamic interpreter. This is put in the .interp
610 #define ELF_DYNAMIC_INTERPRETER(abfd) \
611 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
612 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
613 : "/usr/lib/libc.so.1")
616 #define MNAME(bfd,pre,pos) \
617 (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
618 #define ELF_R_SYM(bfd, i) \
619 (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
620 #define ELF_R_TYPE(bfd, i) \
621 (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
622 #define ELF_R_INFO(bfd, s, t) \
623 (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
625 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
626 #define ELF_R_SYM(bfd, i) \
628 #define ELF_R_TYPE(bfd, i) \
630 #define ELF_R_INFO(bfd, s, t) \
631 (ELF32_R_INFO (s, t))
634 /* The mips16 compiler uses a couple of special sections to handle
635 floating point arguments.
637 Section names that look like .mips16.fn.FNNAME contain stubs that
638 copy floating point arguments from the fp regs to the gp regs and
639 then jump to FNNAME. If any 32 bit function calls FNNAME, the
640 call should be redirected to the stub instead. If no 32 bit
641 function calls FNNAME, the stub should be discarded. We need to
642 consider any reference to the function, not just a call, because
643 if the address of the function is taken we will need the stub,
644 since the address might be passed to a 32 bit function.
646 Section names that look like .mips16.call.FNNAME contain stubs
647 that copy floating point arguments from the gp regs to the fp
648 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
649 then any 16 bit function that calls FNNAME should be redirected
650 to the stub instead. If FNNAME is not a 32 bit function, the
651 stub should be discarded.
653 .mips16.call.fp.FNNAME sections are similar, but contain stubs
654 which call FNNAME and then copy the return value from the fp regs
655 to the gp regs. These stubs store the return value in $18 while
656 calling FNNAME; any function which might call one of these stubs
657 must arrange to save $18 around the call. (This case is not
658 needed for 32 bit functions that call 16 bit functions, because
659 16 bit functions always return floating point values in both
662 Note that in all cases FNNAME might be defined statically.
663 Therefore, FNNAME is not used literally. Instead, the relocation
664 information will indicate which symbol the section is for.
666 We record any stubs that we find in the symbol table. */
668 #define FN_STUB ".mips16.fn."
669 #define CALL_STUB ".mips16.call."
670 #define CALL_FP_STUB ".mips16.call.fp."
672 /* Look up an entry in a MIPS ELF linker hash table. */
674 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
675 ((struct mips_elf_link_hash_entry *) \
676 elf_link_hash_lookup (&(table)->root, (string), (create), \
679 /* Traverse a MIPS ELF linker hash table. */
681 #define mips_elf_link_hash_traverse(table, func, info) \
682 (elf_link_hash_traverse \
684 (bfd_boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
687 /* Get the MIPS ELF linker hash table from a link_info structure. */
689 #define mips_elf_hash_table(p) \
690 ((struct mips_elf_link_hash_table *) ((p)->hash))
692 /* Create an entry in a MIPS ELF linker hash table. */
694 static struct bfd_hash_entry
*
695 mips_elf_link_hash_newfunc (entry
, table
, string
)
696 struct bfd_hash_entry
*entry
;
697 struct bfd_hash_table
*table
;
700 struct mips_elf_link_hash_entry
*ret
=
701 (struct mips_elf_link_hash_entry
*) entry
;
703 /* Allocate the structure if it has not already been allocated by a
705 if (ret
== (struct mips_elf_link_hash_entry
*) NULL
)
706 ret
= ((struct mips_elf_link_hash_entry
*)
707 bfd_hash_allocate (table
,
708 sizeof (struct mips_elf_link_hash_entry
)));
709 if (ret
== (struct mips_elf_link_hash_entry
*) NULL
)
710 return (struct bfd_hash_entry
*) ret
;
712 /* Call the allocation method of the superclass. */
713 ret
= ((struct mips_elf_link_hash_entry
*)
714 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
716 if (ret
!= (struct mips_elf_link_hash_entry
*) NULL
)
718 /* Set local fields. */
719 memset (&ret
->esym
, 0, sizeof (EXTR
));
720 /* We use -2 as a marker to indicate that the information has
721 not been set. -1 means there is no associated ifd. */
723 ret
->possibly_dynamic_relocs
= 0;
724 ret
->readonly_reloc
= FALSE
;
725 ret
->no_fn_stub
= FALSE
;
727 ret
->need_fn_stub
= FALSE
;
728 ret
->call_stub
= NULL
;
729 ret
->call_fp_stub
= NULL
;
730 ret
->forced_local
= FALSE
;
733 return (struct bfd_hash_entry
*) ret
;
737 _bfd_mips_elf_new_section_hook (abfd
, sec
)
741 struct _mips_elf_section_data
*sdata
;
742 bfd_size_type amt
= sizeof (*sdata
);
744 sdata
= (struct _mips_elf_section_data
*) bfd_zalloc (abfd
, amt
);
747 sec
->used_by_bfd
= (PTR
) sdata
;
749 return _bfd_elf_new_section_hook (abfd
, sec
);
752 /* Read ECOFF debugging information from a .mdebug section into a
753 ecoff_debug_info structure. */
756 _bfd_mips_elf_read_ecoff_info (abfd
, section
, debug
)
759 struct ecoff_debug_info
*debug
;
762 const struct ecoff_debug_swap
*swap
;
763 char *ext_hdr
= NULL
;
765 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
766 memset (debug
, 0, sizeof (*debug
));
768 ext_hdr
= (char *) bfd_malloc (swap
->external_hdr_size
);
769 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
772 if (! bfd_get_section_contents (abfd
, section
, ext_hdr
, (file_ptr
) 0,
773 swap
->external_hdr_size
))
776 symhdr
= &debug
->symbolic_header
;
777 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
779 /* The symbolic header contains absolute file offsets and sizes to
781 #define READ(ptr, offset, count, size, type) \
782 if (symhdr->count == 0) \
786 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
787 debug->ptr = (type) bfd_malloc (amt); \
788 if (debug->ptr == NULL) \
790 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
791 || bfd_bread (debug->ptr, amt, abfd) != amt) \
795 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
796 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, PTR
);
797 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, PTR
);
798 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, PTR
);
799 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, PTR
);
800 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
802 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
803 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
804 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, PTR
);
805 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, PTR
);
806 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, PTR
);
810 debug
->adjust
= NULL
;
817 if (debug
->line
!= NULL
)
819 if (debug
->external_dnr
!= NULL
)
820 free (debug
->external_dnr
);
821 if (debug
->external_pdr
!= NULL
)
822 free (debug
->external_pdr
);
823 if (debug
->external_sym
!= NULL
)
824 free (debug
->external_sym
);
825 if (debug
->external_opt
!= NULL
)
826 free (debug
->external_opt
);
827 if (debug
->external_aux
!= NULL
)
828 free (debug
->external_aux
);
829 if (debug
->ss
!= NULL
)
831 if (debug
->ssext
!= NULL
)
833 if (debug
->external_fdr
!= NULL
)
834 free (debug
->external_fdr
);
835 if (debug
->external_rfd
!= NULL
)
836 free (debug
->external_rfd
);
837 if (debug
->external_ext
!= NULL
)
838 free (debug
->external_ext
);
842 /* Swap RPDR (runtime procedure table entry) for output. */
845 ecoff_swap_rpdr_out (abfd
, in
, ex
)
850 H_PUT_S32 (abfd
, in
->adr
, ex
->p_adr
);
851 H_PUT_32 (abfd
, in
->regmask
, ex
->p_regmask
);
852 H_PUT_32 (abfd
, in
->regoffset
, ex
->p_regoffset
);
853 H_PUT_32 (abfd
, in
->fregmask
, ex
->p_fregmask
);
854 H_PUT_32 (abfd
, in
->fregoffset
, ex
->p_fregoffset
);
855 H_PUT_32 (abfd
, in
->frameoffset
, ex
->p_frameoffset
);
857 H_PUT_16 (abfd
, in
->framereg
, ex
->p_framereg
);
858 H_PUT_16 (abfd
, in
->pcreg
, ex
->p_pcreg
);
860 H_PUT_32 (abfd
, in
->irpss
, ex
->p_irpss
);
862 H_PUT_S32 (abfd
, in
->exception_info
, ex
->p_exception_info
);
866 /* Create a runtime procedure table from the .mdebug section. */
869 mips_elf_create_procedure_table (handle
, abfd
, info
, s
, debug
)
872 struct bfd_link_info
*info
;
874 struct ecoff_debug_info
*debug
;
876 const struct ecoff_debug_swap
*swap
;
877 HDRR
*hdr
= &debug
->symbolic_header
;
879 struct rpdr_ext
*erp
;
881 struct pdr_ext
*epdr
;
882 struct sym_ext
*esym
;
887 unsigned long sindex
;
891 const char *no_name_func
= _("static procedure (no name)");
899 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
901 sindex
= strlen (no_name_func
) + 1;
905 size
= swap
->external_pdr_size
;
907 epdr
= (struct pdr_ext
*) bfd_malloc (size
* count
);
911 if (! _bfd_ecoff_get_accumulated_pdr (handle
, (PTR
) epdr
))
914 size
= sizeof (RPDR
);
915 rp
= rpdr
= (RPDR
*) bfd_malloc (size
* count
);
919 size
= sizeof (char *);
920 sv
= (char **) bfd_malloc (size
* count
);
924 count
= hdr
->isymMax
;
925 size
= swap
->external_sym_size
;
926 esym
= (struct sym_ext
*) bfd_malloc (size
* count
);
930 if (! _bfd_ecoff_get_accumulated_sym (handle
, (PTR
) esym
))
934 ss
= (char *) bfd_malloc (count
);
937 if (! _bfd_ecoff_get_accumulated_ss (handle
, (PTR
) ss
))
941 for (i
= 0; i
< (unsigned long) count
; i
++, rp
++)
943 (*swap
->swap_pdr_in
) (abfd
, (PTR
) (epdr
+ i
), &pdr
);
944 (*swap
->swap_sym_in
) (abfd
, (PTR
) &esym
[pdr
.isym
], &sym
);
946 rp
->regmask
= pdr
.regmask
;
947 rp
->regoffset
= pdr
.regoffset
;
948 rp
->fregmask
= pdr
.fregmask
;
949 rp
->fregoffset
= pdr
.fregoffset
;
950 rp
->frameoffset
= pdr
.frameoffset
;
951 rp
->framereg
= pdr
.framereg
;
952 rp
->pcreg
= pdr
.pcreg
;
954 sv
[i
] = ss
+ sym
.iss
;
955 sindex
+= strlen (sv
[i
]) + 1;
959 size
= sizeof (struct rpdr_ext
) * (count
+ 2) + sindex
;
960 size
= BFD_ALIGN (size
, 16);
961 rtproc
= (PTR
) bfd_alloc (abfd
, size
);
964 mips_elf_hash_table (info
)->procedure_count
= 0;
968 mips_elf_hash_table (info
)->procedure_count
= count
+ 2;
970 erp
= (struct rpdr_ext
*) rtproc
;
971 memset (erp
, 0, sizeof (struct rpdr_ext
));
973 str
= (char *) rtproc
+ sizeof (struct rpdr_ext
) * (count
+ 2);
974 strcpy (str
, no_name_func
);
975 str
+= strlen (no_name_func
) + 1;
976 for (i
= 0; i
< count
; i
++)
978 ecoff_swap_rpdr_out (abfd
, rpdr
+ i
, erp
+ i
);
980 str
+= strlen (sv
[i
]) + 1;
982 H_PUT_S32 (abfd
, -1, (erp
+ count
)->p_adr
);
984 /* Set the size and contents of .rtproc section. */
986 s
->contents
= (bfd_byte
*) rtproc
;
988 /* Skip this section later on (I don't think this currently
989 matters, but someday it might). */
990 s
->link_order_head
= (struct bfd_link_order
*) NULL
;
1019 /* Check the mips16 stubs for a particular symbol, and see if we can
1023 mips_elf_check_mips16_stubs (h
, data
)
1024 struct mips_elf_link_hash_entry
*h
;
1025 PTR data ATTRIBUTE_UNUSED
;
1027 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1028 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1030 if (h
->fn_stub
!= NULL
1031 && ! h
->need_fn_stub
)
1033 /* We don't need the fn_stub; the only references to this symbol
1034 are 16 bit calls. Clobber the size to 0 to prevent it from
1035 being included in the link. */
1036 h
->fn_stub
->_raw_size
= 0;
1037 h
->fn_stub
->_cooked_size
= 0;
1038 h
->fn_stub
->flags
&= ~SEC_RELOC
;
1039 h
->fn_stub
->reloc_count
= 0;
1040 h
->fn_stub
->flags
|= SEC_EXCLUDE
;
1043 if (h
->call_stub
!= NULL
1044 && h
->root
.other
== STO_MIPS16
)
1046 /* We don't need the call_stub; this is a 16 bit function, so
1047 calls from other 16 bit functions are OK. Clobber the size
1048 to 0 to prevent it from being included in the link. */
1049 h
->call_stub
->_raw_size
= 0;
1050 h
->call_stub
->_cooked_size
= 0;
1051 h
->call_stub
->flags
&= ~SEC_RELOC
;
1052 h
->call_stub
->reloc_count
= 0;
1053 h
->call_stub
->flags
|= SEC_EXCLUDE
;
1056 if (h
->call_fp_stub
!= NULL
1057 && h
->root
.other
== STO_MIPS16
)
1059 /* We don't need the call_stub; this is a 16 bit function, so
1060 calls from other 16 bit functions are OK. Clobber the size
1061 to 0 to prevent it from being included in the link. */
1062 h
->call_fp_stub
->_raw_size
= 0;
1063 h
->call_fp_stub
->_cooked_size
= 0;
1064 h
->call_fp_stub
->flags
&= ~SEC_RELOC
;
1065 h
->call_fp_stub
->reloc_count
= 0;
1066 h
->call_fp_stub
->flags
|= SEC_EXCLUDE
;
1072 bfd_reloc_status_type
1073 _bfd_mips_elf_gprel16_with_gp (abfd
, symbol
, reloc_entry
, input_section
,
1074 relocatable
, data
, gp
)
1077 arelent
*reloc_entry
;
1078 asection
*input_section
;
1079 bfd_boolean relocatable
;
1084 unsigned long insn
= 0;
1087 if (bfd_is_com_section (symbol
->section
))
1090 relocation
= symbol
->value
;
1092 relocation
+= symbol
->section
->output_section
->vma
;
1093 relocation
+= symbol
->section
->output_offset
;
1095 if (reloc_entry
->address
> input_section
->_cooked_size
)
1096 return bfd_reloc_outofrange
;
1098 /* Set val to the offset into the section or symbol. */
1099 val
= reloc_entry
->addend
;
1101 if (reloc_entry
->howto
->partial_inplace
)
1103 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1104 val
+= insn
& 0xffff;
1107 _bfd_mips_elf_sign_extend(val
, 16);
1109 /* Adjust val for the final section location and GP value. If we
1110 are producing relocatable output, we don't want to do this for
1111 an external symbol. */
1113 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1114 val
+= relocation
- gp
;
1116 if (reloc_entry
->howto
->partial_inplace
)
1118 insn
= (insn
& ~0xffff) | (val
& 0xffff);
1119 bfd_put_32 (abfd
, (bfd_vma
) insn
,
1120 (bfd_byte
*) data
+ reloc_entry
->address
);
1123 reloc_entry
->addend
= val
;
1126 reloc_entry
->address
+= input_section
->output_offset
;
1127 else if (((val
& ~0xffff) != ~0xffff) && ((val
& ~0xffff) != 0))
1128 return bfd_reloc_overflow
;
1130 return bfd_reloc_ok
;
1133 /* Swap an entry in a .gptab section. Note that these routines rely
1134 on the equivalence of the two elements of the union. */
1137 bfd_mips_elf32_swap_gptab_in (abfd
, ex
, in
)
1139 const Elf32_External_gptab
*ex
;
1142 in
->gt_entry
.gt_g_value
= H_GET_32 (abfd
, ex
->gt_entry
.gt_g_value
);
1143 in
->gt_entry
.gt_bytes
= H_GET_32 (abfd
, ex
->gt_entry
.gt_bytes
);
1147 bfd_mips_elf32_swap_gptab_out (abfd
, in
, ex
)
1149 const Elf32_gptab
*in
;
1150 Elf32_External_gptab
*ex
;
1152 H_PUT_32 (abfd
, in
->gt_entry
.gt_g_value
, ex
->gt_entry
.gt_g_value
);
1153 H_PUT_32 (abfd
, in
->gt_entry
.gt_bytes
, ex
->gt_entry
.gt_bytes
);
1157 bfd_elf32_swap_compact_rel_out (abfd
, in
, ex
)
1159 const Elf32_compact_rel
*in
;
1160 Elf32_External_compact_rel
*ex
;
1162 H_PUT_32 (abfd
, in
->id1
, ex
->id1
);
1163 H_PUT_32 (abfd
, in
->num
, ex
->num
);
1164 H_PUT_32 (abfd
, in
->id2
, ex
->id2
);
1165 H_PUT_32 (abfd
, in
->offset
, ex
->offset
);
1166 H_PUT_32 (abfd
, in
->reserved0
, ex
->reserved0
);
1167 H_PUT_32 (abfd
, in
->reserved1
, ex
->reserved1
);
1171 bfd_elf32_swap_crinfo_out (abfd
, in
, ex
)
1173 const Elf32_crinfo
*in
;
1174 Elf32_External_crinfo
*ex
;
1178 l
= (((in
->ctype
& CRINFO_CTYPE
) << CRINFO_CTYPE_SH
)
1179 | ((in
->rtype
& CRINFO_RTYPE
) << CRINFO_RTYPE_SH
)
1180 | ((in
->dist2to
& CRINFO_DIST2TO
) << CRINFO_DIST2TO_SH
)
1181 | ((in
->relvaddr
& CRINFO_RELVADDR
) << CRINFO_RELVADDR_SH
));
1182 H_PUT_32 (abfd
, l
, ex
->info
);
1183 H_PUT_32 (abfd
, in
->konst
, ex
->konst
);
1184 H_PUT_32 (abfd
, in
->vaddr
, ex
->vaddr
);
1187 /* A .reginfo section holds a single Elf32_RegInfo structure. These
1188 routines swap this structure in and out. They are used outside of
1189 BFD, so they are globally visible. */
1192 bfd_mips_elf32_swap_reginfo_in (abfd
, ex
, in
)
1194 const Elf32_External_RegInfo
*ex
;
1197 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1198 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1199 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1200 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1201 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1202 in
->ri_gp_value
= H_GET_32 (abfd
, ex
->ri_gp_value
);
1206 bfd_mips_elf32_swap_reginfo_out (abfd
, in
, ex
)
1208 const Elf32_RegInfo
*in
;
1209 Elf32_External_RegInfo
*ex
;
1211 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1212 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1213 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1214 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1215 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1216 H_PUT_32 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1219 /* In the 64 bit ABI, the .MIPS.options section holds register
1220 information in an Elf64_Reginfo structure. These routines swap
1221 them in and out. They are globally visible because they are used
1222 outside of BFD. These routines are here so that gas can call them
1223 without worrying about whether the 64 bit ABI has been included. */
1226 bfd_mips_elf64_swap_reginfo_in (abfd
, ex
, in
)
1228 const Elf64_External_RegInfo
*ex
;
1229 Elf64_Internal_RegInfo
*in
;
1231 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1232 in
->ri_pad
= H_GET_32 (abfd
, ex
->ri_pad
);
1233 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1234 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1235 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1236 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1237 in
->ri_gp_value
= H_GET_64 (abfd
, ex
->ri_gp_value
);
1241 bfd_mips_elf64_swap_reginfo_out (abfd
, in
, ex
)
1243 const Elf64_Internal_RegInfo
*in
;
1244 Elf64_External_RegInfo
*ex
;
1246 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1247 H_PUT_32 (abfd
, in
->ri_pad
, ex
->ri_pad
);
1248 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1249 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1250 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1251 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1252 H_PUT_64 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1255 /* Swap in an options header. */
1258 bfd_mips_elf_swap_options_in (abfd
, ex
, in
)
1260 const Elf_External_Options
*ex
;
1261 Elf_Internal_Options
*in
;
1263 in
->kind
= H_GET_8 (abfd
, ex
->kind
);
1264 in
->size
= H_GET_8 (abfd
, ex
->size
);
1265 in
->section
= H_GET_16 (abfd
, ex
->section
);
1266 in
->info
= H_GET_32 (abfd
, ex
->info
);
1269 /* Swap out an options header. */
1272 bfd_mips_elf_swap_options_out (abfd
, in
, ex
)
1274 const Elf_Internal_Options
*in
;
1275 Elf_External_Options
*ex
;
1277 H_PUT_8 (abfd
, in
->kind
, ex
->kind
);
1278 H_PUT_8 (abfd
, in
->size
, ex
->size
);
1279 H_PUT_16 (abfd
, in
->section
, ex
->section
);
1280 H_PUT_32 (abfd
, in
->info
, ex
->info
);
1283 /* This function is called via qsort() to sort the dynamic relocation
1284 entries by increasing r_symndx value. */
1287 sort_dynamic_relocs (arg1
, arg2
)
1291 Elf_Internal_Rela int_reloc1
;
1292 Elf_Internal_Rela int_reloc2
;
1294 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg1
, &int_reloc1
);
1295 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg2
, &int_reloc2
);
1297 return ELF32_R_SYM (int_reloc1
.r_info
) - ELF32_R_SYM (int_reloc2
.r_info
);
1300 /* Like sort_dynamic_relocs, but used for elf64 relocations. */
1303 sort_dynamic_relocs_64 (arg1
, arg2
)
1307 Elf_Internal_Rela int_reloc1
[3];
1308 Elf_Internal_Rela int_reloc2
[3];
1310 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1311 (reldyn_sorting_bfd
, arg1
, int_reloc1
);
1312 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1313 (reldyn_sorting_bfd
, arg2
, int_reloc2
);
1315 return (ELF64_R_SYM (int_reloc1
[0].r_info
)
1316 - ELF64_R_SYM (int_reloc2
[0].r_info
));
1320 /* This routine is used to write out ECOFF debugging external symbol
1321 information. It is called via mips_elf_link_hash_traverse. The
1322 ECOFF external symbol information must match the ELF external
1323 symbol information. Unfortunately, at this point we don't know
1324 whether a symbol is required by reloc information, so the two
1325 tables may wind up being different. We must sort out the external
1326 symbol information before we can set the final size of the .mdebug
1327 section, and we must set the size of the .mdebug section before we
1328 can relocate any sections, and we can't know which symbols are
1329 required by relocation until we relocate the sections.
1330 Fortunately, it is relatively unlikely that any symbol will be
1331 stripped but required by a reloc. In particular, it can not happen
1332 when generating a final executable. */
1335 mips_elf_output_extsym (h
, data
)
1336 struct mips_elf_link_hash_entry
*h
;
1339 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
1341 asection
*sec
, *output_section
;
1343 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1344 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1346 if (h
->root
.indx
== -2)
1348 else if (((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1349 || (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
1350 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1351 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
1353 else if (einfo
->info
->strip
== strip_all
1354 || (einfo
->info
->strip
== strip_some
1355 && bfd_hash_lookup (einfo
->info
->keep_hash
,
1356 h
->root
.root
.root
.string
,
1357 FALSE
, FALSE
) == NULL
))
1365 if (h
->esym
.ifd
== -2)
1368 h
->esym
.cobol_main
= 0;
1369 h
->esym
.weakext
= 0;
1370 h
->esym
.reserved
= 0;
1371 h
->esym
.ifd
= ifdNil
;
1372 h
->esym
.asym
.value
= 0;
1373 h
->esym
.asym
.st
= stGlobal
;
1375 if (h
->root
.root
.type
== bfd_link_hash_undefined
1376 || h
->root
.root
.type
== bfd_link_hash_undefweak
)
1380 /* Use undefined class. Also, set class and type for some
1382 name
= h
->root
.root
.root
.string
;
1383 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
1384 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
1386 h
->esym
.asym
.sc
= scData
;
1387 h
->esym
.asym
.st
= stLabel
;
1388 h
->esym
.asym
.value
= 0;
1390 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
1392 h
->esym
.asym
.sc
= scAbs
;
1393 h
->esym
.asym
.st
= stLabel
;
1394 h
->esym
.asym
.value
=
1395 mips_elf_hash_table (einfo
->info
)->procedure_count
;
1397 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (einfo
->abfd
))
1399 h
->esym
.asym
.sc
= scAbs
;
1400 h
->esym
.asym
.st
= stLabel
;
1401 h
->esym
.asym
.value
= elf_gp (einfo
->abfd
);
1404 h
->esym
.asym
.sc
= scUndefined
;
1406 else if (h
->root
.root
.type
!= bfd_link_hash_defined
1407 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
1408 h
->esym
.asym
.sc
= scAbs
;
1413 sec
= h
->root
.root
.u
.def
.section
;
1414 output_section
= sec
->output_section
;
1416 /* When making a shared library and symbol h is the one from
1417 the another shared library, OUTPUT_SECTION may be null. */
1418 if (output_section
== NULL
)
1419 h
->esym
.asym
.sc
= scUndefined
;
1422 name
= bfd_section_name (output_section
->owner
, output_section
);
1424 if (strcmp (name
, ".text") == 0)
1425 h
->esym
.asym
.sc
= scText
;
1426 else if (strcmp (name
, ".data") == 0)
1427 h
->esym
.asym
.sc
= scData
;
1428 else if (strcmp (name
, ".sdata") == 0)
1429 h
->esym
.asym
.sc
= scSData
;
1430 else if (strcmp (name
, ".rodata") == 0
1431 || strcmp (name
, ".rdata") == 0)
1432 h
->esym
.asym
.sc
= scRData
;
1433 else if (strcmp (name
, ".bss") == 0)
1434 h
->esym
.asym
.sc
= scBss
;
1435 else if (strcmp (name
, ".sbss") == 0)
1436 h
->esym
.asym
.sc
= scSBss
;
1437 else if (strcmp (name
, ".init") == 0)
1438 h
->esym
.asym
.sc
= scInit
;
1439 else if (strcmp (name
, ".fini") == 0)
1440 h
->esym
.asym
.sc
= scFini
;
1442 h
->esym
.asym
.sc
= scAbs
;
1446 h
->esym
.asym
.reserved
= 0;
1447 h
->esym
.asym
.index
= indexNil
;
1450 if (h
->root
.root
.type
== bfd_link_hash_common
)
1451 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
1452 else if (h
->root
.root
.type
== bfd_link_hash_defined
1453 || h
->root
.root
.type
== bfd_link_hash_defweak
)
1455 if (h
->esym
.asym
.sc
== scCommon
)
1456 h
->esym
.asym
.sc
= scBss
;
1457 else if (h
->esym
.asym
.sc
== scSCommon
)
1458 h
->esym
.asym
.sc
= scSBss
;
1460 sec
= h
->root
.root
.u
.def
.section
;
1461 output_section
= sec
->output_section
;
1462 if (output_section
!= NULL
)
1463 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
1464 + sec
->output_offset
1465 + output_section
->vma
);
1467 h
->esym
.asym
.value
= 0;
1469 else if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
1471 struct mips_elf_link_hash_entry
*hd
= h
;
1472 bfd_boolean no_fn_stub
= h
->no_fn_stub
;
1474 while (hd
->root
.root
.type
== bfd_link_hash_indirect
)
1476 hd
= (struct mips_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
1477 no_fn_stub
= no_fn_stub
|| hd
->no_fn_stub
;
1482 /* Set type and value for a symbol with a function stub. */
1483 h
->esym
.asym
.st
= stProc
;
1484 sec
= hd
->root
.root
.u
.def
.section
;
1486 h
->esym
.asym
.value
= 0;
1489 output_section
= sec
->output_section
;
1490 if (output_section
!= NULL
)
1491 h
->esym
.asym
.value
= (hd
->root
.plt
.offset
1492 + sec
->output_offset
1493 + output_section
->vma
);
1495 h
->esym
.asym
.value
= 0;
1503 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
1504 h
->root
.root
.root
.string
,
1507 einfo
->failed
= TRUE
;
1514 /* A comparison routine used to sort .gptab entries. */
1517 gptab_compare (p1
, p2
)
1521 const Elf32_gptab
*a1
= (const Elf32_gptab
*) p1
;
1522 const Elf32_gptab
*a2
= (const Elf32_gptab
*) p2
;
1524 return a1
->gt_entry
.gt_g_value
- a2
->gt_entry
.gt_g_value
;
1527 /* Functions to manage the got entry hash table. */
1529 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
1532 static INLINE hashval_t
1533 mips_elf_hash_bfd_vma (addr
)
1537 return addr
+ (addr
>> 32);
1543 /* got_entries only match if they're identical, except for gotidx, so
1544 use all fields to compute the hash, and compare the appropriate
1548 mips_elf_got_entry_hash (entry_
)
1551 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
1553 return entry
->symndx
1554 + (! entry
->abfd
? mips_elf_hash_bfd_vma (entry
->d
.address
)
1556 + (entry
->symndx
>= 0 ? mips_elf_hash_bfd_vma (entry
->d
.addend
)
1557 : entry
->d
.h
->root
.root
.root
.hash
));
1561 mips_elf_got_entry_eq (entry1
, entry2
)
1565 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
1566 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
1568 return e1
->abfd
== e2
->abfd
&& e1
->symndx
== e2
->symndx
1569 && (! e1
->abfd
? e1
->d
.address
== e2
->d
.address
1570 : e1
->symndx
>= 0 ? e1
->d
.addend
== e2
->d
.addend
1571 : e1
->d
.h
== e2
->d
.h
);
1574 /* multi_got_entries are still a match in the case of global objects,
1575 even if the input bfd in which they're referenced differs, so the
1576 hash computation and compare functions are adjusted
1580 mips_elf_multi_got_entry_hash (entry_
)
1583 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
1585 return entry
->symndx
1587 ? mips_elf_hash_bfd_vma (entry
->d
.address
)
1588 : entry
->symndx
>= 0
1590 + mips_elf_hash_bfd_vma (entry
->d
.addend
))
1591 : entry
->d
.h
->root
.root
.root
.hash
);
1595 mips_elf_multi_got_entry_eq (entry1
, entry2
)
1599 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
1600 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
1602 return e1
->symndx
== e2
->symndx
1603 && (e1
->symndx
>= 0 ? e1
->abfd
== e2
->abfd
&& e1
->d
.addend
== e2
->d
.addend
1604 : e1
->abfd
== NULL
|| e2
->abfd
== NULL
1605 ? e1
->abfd
== e2
->abfd
&& e1
->d
.address
== e2
->d
.address
1606 : e1
->d
.h
== e2
->d
.h
);
1609 /* Returns the dynamic relocation section for DYNOBJ. */
1612 mips_elf_rel_dyn_section (dynobj
, create_p
)
1614 bfd_boolean create_p
;
1616 static const char dname
[] = ".rel.dyn";
1619 sreloc
= bfd_get_section_by_name (dynobj
, dname
);
1620 if (sreloc
== NULL
&& create_p
)
1622 sreloc
= bfd_make_section (dynobj
, dname
);
1624 || ! bfd_set_section_flags (dynobj
, sreloc
,
1629 | SEC_LINKER_CREATED
1631 || ! bfd_set_section_alignment (dynobj
, sreloc
,
1632 MIPS_ELF_LOG_FILE_ALIGN (dynobj
)))
1638 /* Returns the GOT section for ABFD. */
1641 mips_elf_got_section (abfd
, maybe_excluded
)
1643 bfd_boolean maybe_excluded
;
1645 asection
*sgot
= bfd_get_section_by_name (abfd
, ".got");
1647 || (! maybe_excluded
&& (sgot
->flags
& SEC_EXCLUDE
) != 0))
1652 /* Returns the GOT information associated with the link indicated by
1653 INFO. If SGOTP is non-NULL, it is filled in with the GOT
1656 static struct mips_got_info
*
1657 mips_elf_got_info (abfd
, sgotp
)
1662 struct mips_got_info
*g
;
1664 sgot
= mips_elf_got_section (abfd
, TRUE
);
1665 BFD_ASSERT (sgot
!= NULL
);
1666 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
1667 g
= mips_elf_section_data (sgot
)->u
.got_info
;
1668 BFD_ASSERT (g
!= NULL
);
1671 *sgotp
= (sgot
->flags
& SEC_EXCLUDE
) == 0 ? sgot
: NULL
;
1676 /* Obtain the lowest dynamic index of a symbol that was assigned a
1677 global GOT entry. */
1679 mips_elf_get_global_gotsym_index (abfd
)
1683 struct mips_got_info
*g
;
1688 sgot
= mips_elf_got_section (abfd
, TRUE
);
1689 if (sgot
== NULL
|| mips_elf_section_data (sgot
) == NULL
)
1692 g
= mips_elf_section_data (sgot
)->u
.got_info
;
1693 if (g
== NULL
|| g
->global_gotsym
== NULL
)
1696 return g
->global_gotsym
->dynindx
;
1699 /* Returns the GOT offset at which the indicated address can be found.
1700 If there is not yet a GOT entry for this value, create one. Returns
1701 -1 if no satisfactory GOT offset can be found. */
1704 mips_elf_local_got_index (abfd
, ibfd
, info
, value
)
1706 struct bfd_link_info
*info
;
1710 struct mips_got_info
*g
;
1711 struct mips_got_entry
*entry
;
1713 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1715 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
, value
);
1717 return entry
->gotidx
;
1722 /* Returns the GOT index for the global symbol indicated by H. */
1725 mips_elf_global_got_index (abfd
, ibfd
, h
)
1727 struct elf_link_hash_entry
*h
;
1731 struct mips_got_info
*g
, *gg
;
1732 long global_got_dynindx
= 0;
1734 gg
= g
= mips_elf_got_info (abfd
, &sgot
);
1735 if (g
->bfd2got
&& ibfd
)
1737 struct mips_got_entry e
, *p
;
1739 BFD_ASSERT (h
->dynindx
>= 0);
1741 g
= mips_elf_got_for_ibfd (g
, ibfd
);
1746 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
1748 p
= (struct mips_got_entry
*) htab_find (g
->got_entries
, &e
);
1750 BFD_ASSERT (p
->gotidx
> 0);
1755 if (gg
->global_gotsym
!= NULL
)
1756 global_got_dynindx
= gg
->global_gotsym
->dynindx
;
1758 /* Once we determine the global GOT entry with the lowest dynamic
1759 symbol table index, we must put all dynamic symbols with greater
1760 indices into the GOT. That makes it easy to calculate the GOT
1762 BFD_ASSERT (h
->dynindx
>= global_got_dynindx
);
1763 index
= ((h
->dynindx
- global_got_dynindx
+ g
->local_gotno
)
1764 * MIPS_ELF_GOT_SIZE (abfd
));
1765 BFD_ASSERT (index
< sgot
->_raw_size
);
1770 /* Find a GOT entry that is within 32KB of the VALUE. These entries
1771 are supposed to be placed at small offsets in the GOT, i.e.,
1772 within 32KB of GP. Return the index into the GOT for this page,
1773 and store the offset from this entry to the desired address in
1774 OFFSETP, if it is non-NULL. */
1777 mips_elf_got_page (abfd
, ibfd
, info
, value
, offsetp
)
1779 struct bfd_link_info
*info
;
1784 struct mips_got_info
*g
;
1786 struct mips_got_entry
*entry
;
1788 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1790 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
,
1792 & (~(bfd_vma
)0xffff));
1797 index
= entry
->gotidx
;
1800 *offsetp
= value
- entry
->d
.address
;
1805 /* Find a GOT entry whose higher-order 16 bits are the same as those
1806 for value. Return the index into the GOT for this entry. */
1809 mips_elf_got16_entry (abfd
, ibfd
, info
, value
, external
)
1811 struct bfd_link_info
*info
;
1813 bfd_boolean external
;
1816 struct mips_got_info
*g
;
1817 struct mips_got_entry
*entry
;
1821 /* Although the ABI says that it is "the high-order 16 bits" that we
1822 want, it is really the %high value. The complete value is
1823 calculated with a `addiu' of a LO16 relocation, just as with a
1825 value
= mips_elf_high (value
) << 16;
1828 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1830 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
, value
);
1832 return entry
->gotidx
;
1837 /* Returns the offset for the entry at the INDEXth position
1841 mips_elf_got_offset_from_index (dynobj
, output_bfd
, input_bfd
, index
)
1849 struct mips_got_info
*g
;
1851 g
= mips_elf_got_info (dynobj
, &sgot
);
1852 gp
= _bfd_get_gp_value (output_bfd
)
1853 + mips_elf_adjust_gp (output_bfd
, g
, input_bfd
);
1855 return sgot
->output_section
->vma
+ sgot
->output_offset
+ index
- gp
;
1858 /* Create a local GOT entry for VALUE. Return the index of the entry,
1859 or -1 if it could not be created. */
1861 static struct mips_got_entry
*
1862 mips_elf_create_local_got_entry (abfd
, ibfd
, gg
, sgot
, value
)
1864 struct mips_got_info
*gg
;
1868 struct mips_got_entry entry
, **loc
;
1869 struct mips_got_info
*g
;
1873 entry
.d
.address
= value
;
1875 g
= mips_elf_got_for_ibfd (gg
, ibfd
);
1878 g
= mips_elf_got_for_ibfd (gg
, abfd
);
1879 BFD_ASSERT (g
!= NULL
);
1882 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
1887 entry
.gotidx
= MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
++;
1889 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
1894 memcpy (*loc
, &entry
, sizeof entry
);
1896 if (g
->assigned_gotno
>= g
->local_gotno
)
1898 (*loc
)->gotidx
= -1;
1899 /* We didn't allocate enough space in the GOT. */
1900 (*_bfd_error_handler
)
1901 (_("not enough GOT space for local GOT entries"));
1902 bfd_set_error (bfd_error_bad_value
);
1906 MIPS_ELF_PUT_WORD (abfd
, value
,
1907 (sgot
->contents
+ entry
.gotidx
));
1912 /* Sort the dynamic symbol table so that symbols that need GOT entries
1913 appear towards the end. This reduces the amount of GOT space
1914 required. MAX_LOCAL is used to set the number of local symbols
1915 known to be in the dynamic symbol table. During
1916 _bfd_mips_elf_size_dynamic_sections, this value is 1. Afterward, the
1917 section symbols are added and the count is higher. */
1920 mips_elf_sort_hash_table (info
, max_local
)
1921 struct bfd_link_info
*info
;
1922 unsigned long max_local
;
1924 struct mips_elf_hash_sort_data hsd
;
1925 struct mips_got_info
*g
;
1928 dynobj
= elf_hash_table (info
)->dynobj
;
1930 g
= mips_elf_got_info (dynobj
, NULL
);
1933 hsd
.max_unref_got_dynindx
=
1934 hsd
.min_got_dynindx
= elf_hash_table (info
)->dynsymcount
1935 /* In the multi-got case, assigned_gotno of the master got_info
1936 indicate the number of entries that aren't referenced in the
1937 primary GOT, but that must have entries because there are
1938 dynamic relocations that reference it. Since they aren't
1939 referenced, we move them to the end of the GOT, so that they
1940 don't prevent other entries that are referenced from getting
1941 too large offsets. */
1942 - (g
->next
? g
->assigned_gotno
: 0);
1943 hsd
.max_non_got_dynindx
= max_local
;
1944 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table
*)
1945 elf_hash_table (info
)),
1946 mips_elf_sort_hash_table_f
,
1949 /* There should have been enough room in the symbol table to
1950 accommodate both the GOT and non-GOT symbols. */
1951 BFD_ASSERT (hsd
.max_non_got_dynindx
<= hsd
.min_got_dynindx
);
1952 BFD_ASSERT ((unsigned long)hsd
.max_unref_got_dynindx
1953 <= elf_hash_table (info
)->dynsymcount
);
1955 /* Now we know which dynamic symbol has the lowest dynamic symbol
1956 table index in the GOT. */
1957 g
->global_gotsym
= hsd
.low
;
1962 /* If H needs a GOT entry, assign it the highest available dynamic
1963 index. Otherwise, assign it the lowest available dynamic
1967 mips_elf_sort_hash_table_f (h
, data
)
1968 struct mips_elf_link_hash_entry
*h
;
1971 struct mips_elf_hash_sort_data
*hsd
1972 = (struct mips_elf_hash_sort_data
*) data
;
1974 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1975 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1977 /* Symbols without dynamic symbol table entries aren't interesting
1979 if (h
->root
.dynindx
== -1)
1982 /* Global symbols that need GOT entries that are not explicitly
1983 referenced are marked with got offset 2. Those that are
1984 referenced get a 1, and those that don't need GOT entries get
1986 if (h
->root
.got
.offset
== 2)
1988 if (hsd
->max_unref_got_dynindx
== hsd
->min_got_dynindx
)
1989 hsd
->low
= (struct elf_link_hash_entry
*) h
;
1990 h
->root
.dynindx
= hsd
->max_unref_got_dynindx
++;
1992 else if (h
->root
.got
.offset
!= 1)
1993 h
->root
.dynindx
= hsd
->max_non_got_dynindx
++;
1996 h
->root
.dynindx
= --hsd
->min_got_dynindx
;
1997 hsd
->low
= (struct elf_link_hash_entry
*) h
;
2003 /* If H is a symbol that needs a global GOT entry, but has a dynamic
2004 symbol table index lower than any we've seen to date, record it for
2008 mips_elf_record_global_got_symbol (h
, abfd
, info
, g
)
2009 struct elf_link_hash_entry
*h
;
2011 struct bfd_link_info
*info
;
2012 struct mips_got_info
*g
;
2014 struct mips_got_entry entry
, **loc
;
2016 /* A global symbol in the GOT must also be in the dynamic symbol
2018 if (h
->dynindx
== -1)
2020 switch (ELF_ST_VISIBILITY (h
->other
))
2024 _bfd_mips_elf_hide_symbol (info
, h
, TRUE
);
2027 if (!bfd_elf32_link_record_dynamic_symbol (info
, h
))
2033 entry
.d
.h
= (struct mips_elf_link_hash_entry
*) h
;
2035 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
2038 /* If we've already marked this entry as needing GOT space, we don't
2039 need to do it again. */
2043 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2049 memcpy (*loc
, &entry
, sizeof entry
);
2051 if (h
->got
.offset
!= MINUS_ONE
)
2054 /* By setting this to a value other than -1, we are indicating that
2055 there needs to be a GOT entry for H. Avoid using zero, as the
2056 generic ELF copy_indirect_symbol tests for <= 0. */
2062 /* Reserve space in G for a GOT entry containing the value of symbol
2063 SYMNDX in input bfd ABDF, plus ADDEND. */
2066 mips_elf_record_local_got_symbol (abfd
, symndx
, addend
, g
)
2070 struct mips_got_info
*g
;
2072 struct mips_got_entry entry
, **loc
;
2075 entry
.symndx
= symndx
;
2076 entry
.d
.addend
= addend
;
2077 loc
= (struct mips_got_entry
**)
2078 htab_find_slot (g
->got_entries
, &entry
, INSERT
);
2083 entry
.gotidx
= g
->local_gotno
++;
2085 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2090 memcpy (*loc
, &entry
, sizeof entry
);
2095 /* Compute the hash value of the bfd in a bfd2got hash entry. */
2098 mips_elf_bfd2got_entry_hash (entry_
)
2101 const struct mips_elf_bfd2got_hash
*entry
2102 = (struct mips_elf_bfd2got_hash
*)entry_
;
2104 return entry
->bfd
->id
;
2107 /* Check whether two hash entries have the same bfd. */
2110 mips_elf_bfd2got_entry_eq (entry1
, entry2
)
2114 const struct mips_elf_bfd2got_hash
*e1
2115 = (const struct mips_elf_bfd2got_hash
*)entry1
;
2116 const struct mips_elf_bfd2got_hash
*e2
2117 = (const struct mips_elf_bfd2got_hash
*)entry2
;
2119 return e1
->bfd
== e2
->bfd
;
2122 /* In a multi-got link, determine the GOT to be used for IBDF. G must
2123 be the master GOT data. */
2125 static struct mips_got_info
*
2126 mips_elf_got_for_ibfd (g
, ibfd
)
2127 struct mips_got_info
*g
;
2130 struct mips_elf_bfd2got_hash e
, *p
;
2136 p
= (struct mips_elf_bfd2got_hash
*) htab_find (g
->bfd2got
, &e
);
2137 return p
? p
->g
: NULL
;
2140 /* Create one separate got for each bfd that has entries in the global
2141 got, such that we can tell how many local and global entries each
2145 mips_elf_make_got_per_bfd (entryp
, p
)
2149 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2150 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
2151 htab_t bfd2got
= arg
->bfd2got
;
2152 struct mips_got_info
*g
;
2153 struct mips_elf_bfd2got_hash bfdgot_entry
, *bfdgot
;
2156 /* Find the got_info for this GOT entry's input bfd. Create one if
2158 bfdgot_entry
.bfd
= entry
->abfd
;
2159 bfdgotp
= htab_find_slot (bfd2got
, &bfdgot_entry
, INSERT
);
2160 bfdgot
= (struct mips_elf_bfd2got_hash
*)*bfdgotp
;
2166 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
2167 (arg
->obfd
, sizeof (struct mips_elf_bfd2got_hash
));
2177 bfdgot
->bfd
= entry
->abfd
;
2178 bfdgot
->g
= g
= (struct mips_got_info
*)
2179 bfd_alloc (arg
->obfd
, sizeof (struct mips_got_info
));
2186 g
->global_gotsym
= NULL
;
2187 g
->global_gotno
= 0;
2189 g
->assigned_gotno
= -1;
2190 g
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
2191 mips_elf_multi_got_entry_eq
,
2193 if (g
->got_entries
== NULL
)
2203 /* Insert the GOT entry in the bfd's got entry hash table. */
2204 entryp
= htab_find_slot (g
->got_entries
, entry
, INSERT
);
2205 if (*entryp
!= NULL
)
2210 if (entry
->symndx
>= 0 || entry
->d
.h
->forced_local
)
2218 /* Attempt to merge gots of different input bfds. Try to use as much
2219 as possible of the primary got, since it doesn't require explicit
2220 dynamic relocations, but don't use bfds that would reference global
2221 symbols out of the addressable range. Failing the primary got,
2222 attempt to merge with the current got, or finish the current got
2223 and then make make the new got current. */
2226 mips_elf_merge_gots (bfd2got_
, p
)
2230 struct mips_elf_bfd2got_hash
*bfd2got
2231 = (struct mips_elf_bfd2got_hash
*)*bfd2got_
;
2232 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
2233 unsigned int lcount
= bfd2got
->g
->local_gotno
;
2234 unsigned int gcount
= bfd2got
->g
->global_gotno
;
2235 unsigned int maxcnt
= arg
->max_count
;
2237 /* If we don't have a primary GOT and this is not too big, use it as
2238 a starting point for the primary GOT. */
2239 if (! arg
->primary
&& lcount
+ gcount
<= maxcnt
)
2241 arg
->primary
= bfd2got
->g
;
2242 arg
->primary_count
= lcount
+ gcount
;
2244 /* If it looks like we can merge this bfd's entries with those of
2245 the primary, merge them. The heuristics is conservative, but we
2246 don't have to squeeze it too hard. */
2247 else if (arg
->primary
2248 && (arg
->primary_count
+ lcount
+ gcount
) <= maxcnt
)
2250 struct mips_got_info
*g
= bfd2got
->g
;
2251 int old_lcount
= arg
->primary
->local_gotno
;
2252 int old_gcount
= arg
->primary
->global_gotno
;
2254 bfd2got
->g
= arg
->primary
;
2256 htab_traverse (g
->got_entries
,
2257 mips_elf_make_got_per_bfd
,
2259 if (arg
->obfd
== NULL
)
2262 htab_delete (g
->got_entries
);
2263 /* We don't have to worry about releasing memory of the actual
2264 got entries, since they're all in the master got_entries hash
2267 BFD_ASSERT (old_lcount
+ lcount
>= arg
->primary
->local_gotno
);
2268 BFD_ASSERT (old_gcount
+ gcount
>= arg
->primary
->global_gotno
);
2270 arg
->primary_count
= arg
->primary
->local_gotno
2271 + arg
->primary
->global_gotno
;
2273 /* If we can merge with the last-created got, do it. */
2274 else if (arg
->current
2275 && arg
->current_count
+ lcount
+ gcount
<= maxcnt
)
2277 struct mips_got_info
*g
= bfd2got
->g
;
2278 int old_lcount
= arg
->current
->local_gotno
;
2279 int old_gcount
= arg
->current
->global_gotno
;
2281 bfd2got
->g
= arg
->current
;
2283 htab_traverse (g
->got_entries
,
2284 mips_elf_make_got_per_bfd
,
2286 if (arg
->obfd
== NULL
)
2289 htab_delete (g
->got_entries
);
2291 BFD_ASSERT (old_lcount
+ lcount
>= arg
->current
->local_gotno
);
2292 BFD_ASSERT (old_gcount
+ gcount
>= arg
->current
->global_gotno
);
2294 arg
->current_count
= arg
->current
->local_gotno
2295 + arg
->current
->global_gotno
;
2297 /* Well, we couldn't merge, so create a new GOT. Don't check if it
2298 fits; if it turns out that it doesn't, we'll get relocation
2299 overflows anyway. */
2302 bfd2got
->g
->next
= arg
->current
;
2303 arg
->current
= bfd2got
->g
;
2305 arg
->current_count
= lcount
+ gcount
;
2311 /* If passed a NULL mips_got_info in the argument, set the marker used
2312 to tell whether a global symbol needs a got entry (in the primary
2313 got) to the given VALUE.
2315 If passed a pointer G to a mips_got_info in the argument (it must
2316 not be the primary GOT), compute the offset from the beginning of
2317 the (primary) GOT section to the entry in G corresponding to the
2318 global symbol. G's assigned_gotno must contain the index of the
2319 first available global GOT entry in G. VALUE must contain the size
2320 of a GOT entry in bytes. For each global GOT entry that requires a
2321 dynamic relocation, NEEDED_RELOCS is incremented, and the symbol is
2322 marked as not elligible for lazy resolution through a function
2325 mips_elf_set_global_got_offset (entryp
, p
)
2329 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2330 struct mips_elf_set_global_got_offset_arg
*arg
2331 = (struct mips_elf_set_global_got_offset_arg
*)p
;
2332 struct mips_got_info
*g
= arg
->g
;
2334 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1
2335 && entry
->d
.h
->root
.dynindx
!= -1)
2339 BFD_ASSERT (g
->global_gotsym
== NULL
);
2341 entry
->gotidx
= arg
->value
* (long) g
->assigned_gotno
++;
2342 if (arg
->info
->shared
2343 || (elf_hash_table (arg
->info
)->dynamic_sections_created
2344 && ((entry
->d
.h
->root
.elf_link_hash_flags
2345 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0)
2346 && ((entry
->d
.h
->root
.elf_link_hash_flags
2347 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
2348 ++arg
->needed_relocs
;
2351 entry
->d
.h
->root
.got
.offset
= arg
->value
;
2357 /* Mark any global symbols referenced in the GOT we are iterating over
2358 as inelligible for lazy resolution stubs. */
2360 mips_elf_set_no_stub (entryp
, p
)
2362 void *p ATTRIBUTE_UNUSED
;
2364 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2366 if (entry
->abfd
!= NULL
2367 && entry
->symndx
== -1
2368 && entry
->d
.h
->root
.dynindx
!= -1)
2369 entry
->d
.h
->no_fn_stub
= TRUE
;
2374 /* Follow indirect and warning hash entries so that each got entry
2375 points to the final symbol definition. P must point to a pointer
2376 to the hash table we're traversing. Since this traversal may
2377 modify the hash table, we set this pointer to NULL to indicate
2378 we've made a potentially-destructive change to the hash table, so
2379 the traversal must be restarted. */
2381 mips_elf_resolve_final_got_entry (entryp
, p
)
2385 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2386 htab_t got_entries
= *(htab_t
*)p
;
2388 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1)
2390 struct mips_elf_link_hash_entry
*h
= entry
->d
.h
;
2392 while (h
->root
.root
.type
== bfd_link_hash_indirect
2393 || h
->root
.root
.type
== bfd_link_hash_warning
)
2394 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2396 if (entry
->d
.h
== h
)
2401 /* If we can't find this entry with the new bfd hash, re-insert
2402 it, and get the traversal restarted. */
2403 if (! htab_find (got_entries
, entry
))
2405 htab_clear_slot (got_entries
, entryp
);
2406 entryp
= htab_find_slot (got_entries
, entry
, INSERT
);
2409 /* Abort the traversal, since the whole table may have
2410 moved, and leave it up to the parent to restart the
2412 *(htab_t
*)p
= NULL
;
2415 /* We might want to decrement the global_gotno count, but it's
2416 either too early or too late for that at this point. */
2422 /* Turn indirect got entries in a got_entries table into their final
2425 mips_elf_resolve_final_got_entries (g
)
2426 struct mips_got_info
*g
;
2432 got_entries
= g
->got_entries
;
2434 htab_traverse (got_entries
,
2435 mips_elf_resolve_final_got_entry
,
2438 while (got_entries
== NULL
);
2441 /* Return the offset of an input bfd IBFD's GOT from the beginning of
2444 mips_elf_adjust_gp (abfd
, g
, ibfd
)
2446 struct mips_got_info
*g
;
2449 if (g
->bfd2got
== NULL
)
2452 g
= mips_elf_got_for_ibfd (g
, ibfd
);
2456 BFD_ASSERT (g
->next
);
2460 return (g
->local_gotno
+ g
->global_gotno
) * MIPS_ELF_GOT_SIZE (abfd
);
2463 /* Turn a single GOT that is too big for 16-bit addressing into
2464 a sequence of GOTs, each one 16-bit addressable. */
2467 mips_elf_multi_got (abfd
, info
, g
, got
, pages
)
2469 struct bfd_link_info
*info
;
2470 struct mips_got_info
*g
;
2472 bfd_size_type pages
;
2474 struct mips_elf_got_per_bfd_arg got_per_bfd_arg
;
2475 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
2476 struct mips_got_info
*gg
;
2477 unsigned int assign
;
2479 g
->bfd2got
= htab_try_create (1, mips_elf_bfd2got_entry_hash
,
2480 mips_elf_bfd2got_entry_eq
,
2482 if (g
->bfd2got
== NULL
)
2485 got_per_bfd_arg
.bfd2got
= g
->bfd2got
;
2486 got_per_bfd_arg
.obfd
= abfd
;
2487 got_per_bfd_arg
.info
= info
;
2489 /* Count how many GOT entries each input bfd requires, creating a
2490 map from bfd to got info while at that. */
2491 mips_elf_resolve_final_got_entries (g
);
2492 htab_traverse (g
->got_entries
, mips_elf_make_got_per_bfd
, &got_per_bfd_arg
);
2493 if (got_per_bfd_arg
.obfd
== NULL
)
2496 got_per_bfd_arg
.current
= NULL
;
2497 got_per_bfd_arg
.primary
= NULL
;
2498 /* Taking out PAGES entries is a worst-case estimate. We could
2499 compute the maximum number of pages that each separate input bfd
2500 uses, but it's probably not worth it. */
2501 got_per_bfd_arg
.max_count
= ((MIPS_ELF_GOT_MAX_SIZE (abfd
)
2502 / MIPS_ELF_GOT_SIZE (abfd
))
2503 - MIPS_RESERVED_GOTNO
- pages
);
2505 /* Try to merge the GOTs of input bfds together, as long as they
2506 don't seem to exceed the maximum GOT size, choosing one of them
2507 to be the primary GOT. */
2508 htab_traverse (g
->bfd2got
, mips_elf_merge_gots
, &got_per_bfd_arg
);
2509 if (got_per_bfd_arg
.obfd
== NULL
)
2512 /* If we find any suitable primary GOT, create an empty one. */
2513 if (got_per_bfd_arg
.primary
== NULL
)
2515 g
->next
= (struct mips_got_info
*)
2516 bfd_alloc (abfd
, sizeof (struct mips_got_info
));
2517 if (g
->next
== NULL
)
2520 g
->next
->global_gotsym
= NULL
;
2521 g
->next
->global_gotno
= 0;
2522 g
->next
->local_gotno
= 0;
2523 g
->next
->assigned_gotno
= 0;
2524 g
->next
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
2525 mips_elf_multi_got_entry_eq
,
2527 if (g
->next
->got_entries
== NULL
)
2529 g
->next
->bfd2got
= NULL
;
2532 g
->next
= got_per_bfd_arg
.primary
;
2533 g
->next
->next
= got_per_bfd_arg
.current
;
2535 /* GG is now the master GOT, and G is the primary GOT. */
2539 /* Map the output bfd to the primary got. That's what we're going
2540 to use for bfds that use GOT16 or GOT_PAGE relocations that we
2541 didn't mark in check_relocs, and we want a quick way to find it.
2542 We can't just use gg->next because we're going to reverse the
2545 struct mips_elf_bfd2got_hash
*bfdgot
;
2548 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
2549 (abfd
, sizeof (struct mips_elf_bfd2got_hash
));
2556 bfdgotp
= htab_find_slot (gg
->bfd2got
, bfdgot
, INSERT
);
2558 BFD_ASSERT (*bfdgotp
== NULL
);
2562 /* The IRIX dynamic linker requires every symbol that is referenced
2563 in a dynamic relocation to be present in the primary GOT, so
2564 arrange for them to appear after those that are actually
2567 GNU/Linux could very well do without it, but it would slow down
2568 the dynamic linker, since it would have to resolve every dynamic
2569 symbol referenced in other GOTs more than once, without help from
2570 the cache. Also, knowing that every external symbol has a GOT
2571 helps speed up the resolution of local symbols too, so GNU/Linux
2572 follows IRIX's practice.
2574 The number 2 is used by mips_elf_sort_hash_table_f to count
2575 global GOT symbols that are unreferenced in the primary GOT, with
2576 an initial dynamic index computed from gg->assigned_gotno, where
2577 the number of unreferenced global entries in the primary GOT is
2581 gg
->assigned_gotno
= gg
->global_gotno
- g
->global_gotno
;
2582 g
->global_gotno
= gg
->global_gotno
;
2583 set_got_offset_arg
.value
= 2;
2587 /* This could be used for dynamic linkers that don't optimize
2588 symbol resolution while applying relocations so as to use
2589 primary GOT entries or assuming the symbol is locally-defined.
2590 With this code, we assign lower dynamic indices to global
2591 symbols that are not referenced in the primary GOT, so that
2592 their entries can be omitted. */
2593 gg
->assigned_gotno
= 0;
2594 set_got_offset_arg
.value
= -1;
2597 /* Reorder dynamic symbols as described above (which behavior
2598 depends on the setting of VALUE). */
2599 set_got_offset_arg
.g
= NULL
;
2600 htab_traverse (gg
->got_entries
, mips_elf_set_global_got_offset
,
2601 &set_got_offset_arg
);
2602 set_got_offset_arg
.value
= 1;
2603 htab_traverse (g
->got_entries
, mips_elf_set_global_got_offset
,
2604 &set_got_offset_arg
);
2605 if (! mips_elf_sort_hash_table (info
, 1))
2608 /* Now go through the GOTs assigning them offset ranges.
2609 [assigned_gotno, local_gotno[ will be set to the range of local
2610 entries in each GOT. We can then compute the end of a GOT by
2611 adding local_gotno to global_gotno. We reverse the list and make
2612 it circular since then we'll be able to quickly compute the
2613 beginning of a GOT, by computing the end of its predecessor. To
2614 avoid special cases for the primary GOT, while still preserving
2615 assertions that are valid for both single- and multi-got links,
2616 we arrange for the main got struct to have the right number of
2617 global entries, but set its local_gotno such that the initial
2618 offset of the primary GOT is zero. Remember that the primary GOT
2619 will become the last item in the circular linked list, so it
2620 points back to the master GOT. */
2621 gg
->local_gotno
= -g
->global_gotno
;
2622 gg
->global_gotno
= g
->global_gotno
;
2628 struct mips_got_info
*gn
;
2630 assign
+= MIPS_RESERVED_GOTNO
;
2631 g
->assigned_gotno
= assign
;
2632 g
->local_gotno
+= assign
+ pages
;
2633 assign
= g
->local_gotno
+ g
->global_gotno
;
2635 /* Take g out of the direct list, and push it onto the reversed
2636 list that gg points to. */
2642 /* Mark global symbols in every non-primary GOT as ineligible for
2645 htab_traverse (g
->got_entries
, mips_elf_set_no_stub
, NULL
);
2649 got
->_raw_size
= (gg
->next
->local_gotno
2650 + gg
->next
->global_gotno
) * MIPS_ELF_GOT_SIZE (abfd
);
2656 /* Returns the first relocation of type r_type found, beginning with
2657 RELOCATION. RELEND is one-past-the-end of the relocation table. */
2659 static const Elf_Internal_Rela
*
2660 mips_elf_next_relocation (abfd
, r_type
, relocation
, relend
)
2661 bfd
*abfd ATTRIBUTE_UNUSED
;
2662 unsigned int r_type
;
2663 const Elf_Internal_Rela
*relocation
;
2664 const Elf_Internal_Rela
*relend
;
2666 /* According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must be
2667 immediately following. However, for the IRIX6 ABI, the next
2668 relocation may be a composed relocation consisting of several
2669 relocations for the same address. In that case, the R_MIPS_LO16
2670 relocation may occur as one of these. We permit a similar
2671 extension in general, as that is useful for GCC. */
2672 while (relocation
< relend
)
2674 if (ELF_R_TYPE (abfd
, relocation
->r_info
) == r_type
)
2680 /* We didn't find it. */
2681 bfd_set_error (bfd_error_bad_value
);
2685 /* Return whether a relocation is against a local symbol. */
2688 mips_elf_local_relocation_p (input_bfd
, relocation
, local_sections
,
2691 const Elf_Internal_Rela
*relocation
;
2692 asection
**local_sections
;
2693 bfd_boolean check_forced
;
2695 unsigned long r_symndx
;
2696 Elf_Internal_Shdr
*symtab_hdr
;
2697 struct mips_elf_link_hash_entry
*h
;
2700 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
2701 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2702 extsymoff
= (elf_bad_symtab (input_bfd
)) ? 0 : symtab_hdr
->sh_info
;
2704 if (r_symndx
< extsymoff
)
2706 if (elf_bad_symtab (input_bfd
) && local_sections
[r_symndx
] != NULL
)
2711 /* Look up the hash table to check whether the symbol
2712 was forced local. */
2713 h
= (struct mips_elf_link_hash_entry
*)
2714 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
];
2715 /* Find the real hash-table entry for this symbol. */
2716 while (h
->root
.root
.type
== bfd_link_hash_indirect
2717 || h
->root
.root
.type
== bfd_link_hash_warning
)
2718 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2719 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0)
2726 /* Sign-extend VALUE, which has the indicated number of BITS. */
2729 _bfd_mips_elf_sign_extend (value
, bits
)
2733 if (value
& ((bfd_vma
) 1 << (bits
- 1)))
2734 /* VALUE is negative. */
2735 value
|= ((bfd_vma
) - 1) << bits
;
2740 /* Return non-zero if the indicated VALUE has overflowed the maximum
2741 range expressable by a signed number with the indicated number of
2745 mips_elf_overflow_p (value
, bits
)
2749 bfd_signed_vma svalue
= (bfd_signed_vma
) value
;
2751 if (svalue
> (1 << (bits
- 1)) - 1)
2752 /* The value is too big. */
2754 else if (svalue
< -(1 << (bits
- 1)))
2755 /* The value is too small. */
2762 /* Calculate the %high function. */
2765 mips_elf_high (value
)
2768 return ((value
+ (bfd_vma
) 0x8000) >> 16) & 0xffff;
2771 /* Calculate the %higher function. */
2774 mips_elf_higher (value
)
2775 bfd_vma value ATTRIBUTE_UNUSED
;
2778 return ((value
+ (bfd_vma
) 0x80008000) >> 32) & 0xffff;
2781 return (bfd_vma
) -1;
2785 /* Calculate the %highest function. */
2788 mips_elf_highest (value
)
2789 bfd_vma value ATTRIBUTE_UNUSED
;
2792 return ((value
+ (((bfd_vma
) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
2795 return (bfd_vma
) -1;
2799 /* Create the .compact_rel section. */
2802 mips_elf_create_compact_rel_section (abfd
, info
)
2804 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2807 register asection
*s
;
2809 if (bfd_get_section_by_name (abfd
, ".compact_rel") == NULL
)
2811 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
2814 s
= bfd_make_section (abfd
, ".compact_rel");
2816 || ! bfd_set_section_flags (abfd
, s
, flags
)
2817 || ! bfd_set_section_alignment (abfd
, s
,
2818 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
2821 s
->_raw_size
= sizeof (Elf32_External_compact_rel
);
2827 /* Create the .got section to hold the global offset table. */
2830 mips_elf_create_got_section (abfd
, info
, maybe_exclude
)
2832 struct bfd_link_info
*info
;
2833 bfd_boolean maybe_exclude
;
2836 register asection
*s
;
2837 struct elf_link_hash_entry
*h
;
2838 struct bfd_link_hash_entry
*bh
;
2839 struct mips_got_info
*g
;
2842 /* This function may be called more than once. */
2843 s
= mips_elf_got_section (abfd
, TRUE
);
2846 if (! maybe_exclude
)
2847 s
->flags
&= ~SEC_EXCLUDE
;
2851 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2852 | SEC_LINKER_CREATED
);
2855 flags
|= SEC_EXCLUDE
;
2857 /* We have to use an alignment of 2**4 here because this is hardcoded
2858 in the function stub generation and in the linker script. */
2859 s
= bfd_make_section (abfd
, ".got");
2861 || ! bfd_set_section_flags (abfd
, s
, flags
)
2862 || ! bfd_set_section_alignment (abfd
, s
, 4))
2865 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
2866 linker script because we don't want to define the symbol if we
2867 are not creating a global offset table. */
2869 if (! (_bfd_generic_link_add_one_symbol
2870 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
2871 (bfd_vma
) 0, (const char *) NULL
, FALSE
,
2872 get_elf_backend_data (abfd
)->collect
, &bh
)))
2875 h
= (struct elf_link_hash_entry
*) bh
;
2876 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
2877 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2878 h
->type
= STT_OBJECT
;
2881 && ! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2884 amt
= sizeof (struct mips_got_info
);
2885 g
= (struct mips_got_info
*) bfd_alloc (abfd
, amt
);
2888 g
->global_gotsym
= NULL
;
2889 g
->global_gotno
= 0;
2890 g
->local_gotno
= MIPS_RESERVED_GOTNO
;
2891 g
->assigned_gotno
= MIPS_RESERVED_GOTNO
;
2894 g
->got_entries
= htab_try_create (1, mips_elf_got_entry_hash
,
2895 mips_elf_got_entry_eq
,
2897 if (g
->got_entries
== NULL
)
2899 mips_elf_section_data (s
)->u
.got_info
= g
;
2900 mips_elf_section_data (s
)->elf
.this_hdr
.sh_flags
2901 |= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
2906 /* Calculate the value produced by the RELOCATION (which comes from
2907 the INPUT_BFD). The ADDEND is the addend to use for this
2908 RELOCATION; RELOCATION->R_ADDEND is ignored.
2910 The result of the relocation calculation is stored in VALUEP.
2911 REQUIRE_JALXP indicates whether or not the opcode used with this
2912 relocation must be JALX.
2914 This function returns bfd_reloc_continue if the caller need take no
2915 further action regarding this relocation, bfd_reloc_notsupported if
2916 something goes dramatically wrong, bfd_reloc_overflow if an
2917 overflow occurs, and bfd_reloc_ok to indicate success. */
2919 static bfd_reloc_status_type
2920 mips_elf_calculate_relocation (abfd
, input_bfd
, input_section
, info
,
2921 relocation
, addend
, howto
, local_syms
,
2922 local_sections
, valuep
, namep
,
2923 require_jalxp
, save_addend
)
2926 asection
*input_section
;
2927 struct bfd_link_info
*info
;
2928 const Elf_Internal_Rela
*relocation
;
2930 reloc_howto_type
*howto
;
2931 Elf_Internal_Sym
*local_syms
;
2932 asection
**local_sections
;
2935 bfd_boolean
*require_jalxp
;
2936 bfd_boolean save_addend
;
2938 /* The eventual value we will return. */
2940 /* The address of the symbol against which the relocation is
2943 /* The final GP value to be used for the relocatable, executable, or
2944 shared object file being produced. */
2945 bfd_vma gp
= MINUS_ONE
;
2946 /* The place (section offset or address) of the storage unit being
2949 /* The value of GP used to create the relocatable object. */
2950 bfd_vma gp0
= MINUS_ONE
;
2951 /* The offset into the global offset table at which the address of
2952 the relocation entry symbol, adjusted by the addend, resides
2953 during execution. */
2954 bfd_vma g
= MINUS_ONE
;
2955 /* The section in which the symbol referenced by the relocation is
2957 asection
*sec
= NULL
;
2958 struct mips_elf_link_hash_entry
*h
= NULL
;
2959 /* TRUE if the symbol referred to by this relocation is a local
2961 bfd_boolean local_p
, was_local_p
;
2962 /* TRUE if the symbol referred to by this relocation is "_gp_disp". */
2963 bfd_boolean gp_disp_p
= FALSE
;
2964 Elf_Internal_Shdr
*symtab_hdr
;
2966 unsigned long r_symndx
;
2968 /* TRUE if overflow occurred during the calculation of the
2969 relocation value. */
2970 bfd_boolean overflowed_p
;
2971 /* TRUE if this relocation refers to a MIPS16 function. */
2972 bfd_boolean target_is_16_bit_code_p
= FALSE
;
2974 /* Parse the relocation. */
2975 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
2976 r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
2977 p
= (input_section
->output_section
->vma
2978 + input_section
->output_offset
2979 + relocation
->r_offset
);
2981 /* Assume that there will be no overflow. */
2982 overflowed_p
= FALSE
;
2984 /* Figure out whether or not the symbol is local, and get the offset
2985 used in the array of hash table entries. */
2986 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2987 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
2988 local_sections
, FALSE
);
2989 was_local_p
= local_p
;
2990 if (! elf_bad_symtab (input_bfd
))
2991 extsymoff
= symtab_hdr
->sh_info
;
2994 /* The symbol table does not follow the rule that local symbols
2995 must come before globals. */
2999 /* Figure out the value of the symbol. */
3002 Elf_Internal_Sym
*sym
;
3004 sym
= local_syms
+ r_symndx
;
3005 sec
= local_sections
[r_symndx
];
3007 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3008 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
3009 || (sec
->flags
& SEC_MERGE
))
3010 symbol
+= sym
->st_value
;
3011 if ((sec
->flags
& SEC_MERGE
)
3012 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3014 addend
= _bfd_elf_rel_local_sym (abfd
, sym
, &sec
, addend
);
3016 addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
3019 /* MIPS16 text labels should be treated as odd. */
3020 if (sym
->st_other
== STO_MIPS16
)
3023 /* Record the name of this symbol, for our caller. */
3024 *namep
= bfd_elf_string_from_elf_section (input_bfd
,
3025 symtab_hdr
->sh_link
,
3028 *namep
= bfd_section_name (input_bfd
, sec
);
3030 target_is_16_bit_code_p
= (sym
->st_other
== STO_MIPS16
);
3034 /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ? */
3036 /* For global symbols we look up the symbol in the hash-table. */
3037 h
= ((struct mips_elf_link_hash_entry
*)
3038 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
]);
3039 /* Find the real hash-table entry for this symbol. */
3040 while (h
->root
.root
.type
== bfd_link_hash_indirect
3041 || h
->root
.root
.type
== bfd_link_hash_warning
)
3042 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3044 /* Record the name of this symbol, for our caller. */
3045 *namep
= h
->root
.root
.root
.string
;
3047 /* See if this is the special _gp_disp symbol. Note that such a
3048 symbol must always be a global symbol. */
3049 if (strcmp (*namep
, "_gp_disp") == 0
3050 && ! NEWABI_P (input_bfd
))
3052 /* Relocations against _gp_disp are permitted only with
3053 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
3054 if (r_type
!= R_MIPS_HI16
&& r_type
!= R_MIPS_LO16
)
3055 return bfd_reloc_notsupported
;
3059 /* If this symbol is defined, calculate its address. Note that
3060 _gp_disp is a magic symbol, always implicitly defined by the
3061 linker, so it's inappropriate to check to see whether or not
3063 else if ((h
->root
.root
.type
== bfd_link_hash_defined
3064 || h
->root
.root
.type
== bfd_link_hash_defweak
)
3065 && h
->root
.root
.u
.def
.section
)
3067 sec
= h
->root
.root
.u
.def
.section
;
3068 if (sec
->output_section
)
3069 symbol
= (h
->root
.root
.u
.def
.value
3070 + sec
->output_section
->vma
3071 + sec
->output_offset
);
3073 symbol
= h
->root
.root
.u
.def
.value
;
3075 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
3076 /* We allow relocations against undefined weak symbols, giving
3077 it the value zero, so that you can undefined weak functions
3078 and check to see if they exist by looking at their
3081 else if (info
->shared
3082 && info
->unresolved_syms_in_objects
== RM_IGNORE
3083 && ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
3085 else if (strcmp (*namep
, "_DYNAMIC_LINK") == 0 ||
3086 strcmp (*namep
, "_DYNAMIC_LINKING") == 0)
3088 /* If this is a dynamic link, we should have created a
3089 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
3090 in in _bfd_mips_elf_create_dynamic_sections.
3091 Otherwise, we should define the symbol with a value of 0.
3092 FIXME: It should probably get into the symbol table
3094 BFD_ASSERT (! info
->shared
);
3095 BFD_ASSERT (bfd_get_section_by_name (abfd
, ".dynamic") == NULL
);
3100 if (! ((*info
->callbacks
->undefined_symbol
)
3101 (info
, h
->root
.root
.root
.string
, input_bfd
,
3102 input_section
, relocation
->r_offset
,
3103 ((info
->shared
&& info
->unresolved_syms_in_shared_libs
== RM_GENERATE_ERROR
)
3104 || (!info
->shared
&& info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
)
3105 || ELF_ST_VISIBILITY (h
->root
.other
)))))
3106 return bfd_reloc_undefined
;
3110 target_is_16_bit_code_p
= (h
->root
.other
== STO_MIPS16
);
3113 /* If this is a 32- or 64-bit call to a 16-bit function with a stub, we
3114 need to redirect the call to the stub, unless we're already *in*
3116 if (r_type
!= R_MIPS16_26
&& !info
->relocatable
3117 && ((h
!= NULL
&& h
->fn_stub
!= NULL
)
3118 || (local_p
&& elf_tdata (input_bfd
)->local_stubs
!= NULL
3119 && elf_tdata (input_bfd
)->local_stubs
[r_symndx
] != NULL
))
3120 && !mips_elf_stub_section_p (input_bfd
, input_section
))
3122 /* This is a 32- or 64-bit call to a 16-bit function. We should
3123 have already noticed that we were going to need the
3126 sec
= elf_tdata (input_bfd
)->local_stubs
[r_symndx
];
3129 BFD_ASSERT (h
->need_fn_stub
);
3133 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3135 /* If this is a 16-bit call to a 32- or 64-bit function with a stub, we
3136 need to redirect the call to the stub. */
3137 else if (r_type
== R_MIPS16_26
&& !info
->relocatable
3139 && (h
->call_stub
!= NULL
|| h
->call_fp_stub
!= NULL
)
3140 && !target_is_16_bit_code_p
)
3142 /* If both call_stub and call_fp_stub are defined, we can figure
3143 out which one to use by seeing which one appears in the input
3145 if (h
->call_stub
!= NULL
&& h
->call_fp_stub
!= NULL
)
3150 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
3152 if (strncmp (bfd_get_section_name (input_bfd
, o
),
3153 CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
3155 sec
= h
->call_fp_stub
;
3162 else if (h
->call_stub
!= NULL
)
3165 sec
= h
->call_fp_stub
;
3167 BFD_ASSERT (sec
->_raw_size
> 0);
3168 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3171 /* Calls from 16-bit code to 32-bit code and vice versa require the
3172 special jalx instruction. */
3173 *require_jalxp
= (!info
->relocatable
3174 && (((r_type
== R_MIPS16_26
) && !target_is_16_bit_code_p
)
3175 || ((r_type
== R_MIPS_26
) && target_is_16_bit_code_p
)));
3177 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
3178 local_sections
, TRUE
);
3180 /* If we haven't already determined the GOT offset, or the GP value,
3181 and we're going to need it, get it now. */
3184 case R_MIPS_GOT_PAGE
:
3185 case R_MIPS_GOT_OFST
:
3186 /* If this symbol got a global GOT entry, we have to decay
3187 GOT_PAGE/GOT_OFST to GOT_DISP/addend. */
3188 local_p
= local_p
|| ! h
3190 < mips_elf_get_global_gotsym_index (elf_hash_table (info
)
3192 if (local_p
|| r_type
== R_MIPS_GOT_OFST
)
3198 case R_MIPS_GOT_DISP
:
3199 case R_MIPS_GOT_HI16
:
3200 case R_MIPS_CALL_HI16
:
3201 case R_MIPS_GOT_LO16
:
3202 case R_MIPS_CALL_LO16
:
3203 /* Find the index into the GOT where this value is located. */
3206 /* GOT_PAGE may take a non-zero addend, that is ignored in a
3207 GOT_PAGE relocation that decays to GOT_DISP because the
3208 symbol turns out to be global. The addend is then added
3210 BFD_ASSERT (addend
== 0 || r_type
== R_MIPS_GOT_PAGE
);
3211 g
= mips_elf_global_got_index (elf_hash_table (info
)->dynobj
,
3213 (struct elf_link_hash_entry
*) h
);
3214 if (! elf_hash_table(info
)->dynamic_sections_created
3216 && (info
->symbolic
|| h
->root
.dynindx
== -1)
3217 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
3219 /* This is a static link or a -Bsymbolic link. The
3220 symbol is defined locally, or was forced to be local.
3221 We must initialize this entry in the GOT. */
3222 bfd
*tmpbfd
= elf_hash_table (info
)->dynobj
;
3223 asection
*sgot
= mips_elf_got_section (tmpbfd
, FALSE
);
3224 MIPS_ELF_PUT_WORD (tmpbfd
, symbol
, sgot
->contents
+ g
);
3227 else if (r_type
== R_MIPS_GOT16
|| r_type
== R_MIPS_CALL16
)
3228 /* There's no need to create a local GOT entry here; the
3229 calculation for a local GOT16 entry does not involve G. */
3233 g
= mips_elf_local_got_index (abfd
, input_bfd
,
3234 info
, symbol
+ addend
);
3236 return bfd_reloc_outofrange
;
3239 /* Convert GOT indices to actual offsets. */
3240 g
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3241 abfd
, input_bfd
, g
);
3246 case R_MIPS16_GPREL
:
3247 case R_MIPS_GPREL16
:
3248 case R_MIPS_GPREL32
:
3249 case R_MIPS_LITERAL
:
3250 gp0
= _bfd_get_gp_value (input_bfd
);
3251 gp
= _bfd_get_gp_value (abfd
);
3252 if (elf_hash_table (info
)->dynobj
)
3253 gp
+= mips_elf_adjust_gp (abfd
,
3255 (elf_hash_table (info
)->dynobj
, NULL
),
3263 /* Figure out what kind of relocation is being performed. */
3267 return bfd_reloc_continue
;
3270 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 16);
3271 overflowed_p
= mips_elf_overflow_p (value
, 16);
3278 || (elf_hash_table (info
)->dynamic_sections_created
3280 && ((h
->root
.elf_link_hash_flags
3281 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0)
3282 && ((h
->root
.elf_link_hash_flags
3283 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
3285 && (input_section
->flags
& SEC_ALLOC
) != 0)
3287 /* If we're creating a shared library, or this relocation is
3288 against a symbol in a shared library, then we can't know
3289 where the symbol will end up. So, we create a relocation
3290 record in the output, and leave the job up to the dynamic
3293 if (!mips_elf_create_dynamic_relocation (abfd
,
3301 return bfd_reloc_undefined
;
3305 if (r_type
!= R_MIPS_REL32
)
3306 value
= symbol
+ addend
;
3310 value
&= howto
->dst_mask
;
3315 case R_MIPS_GNU_REL_LO16
:
3316 value
= symbol
+ addend
- p
;
3317 value
&= howto
->dst_mask
;
3320 case R_MIPS_GNU_REL16_S2
:
3321 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
<< 2, 18) - p
;
3322 overflowed_p
= mips_elf_overflow_p (value
, 18);
3323 value
= (value
>> 2) & howto
->dst_mask
;
3326 case R_MIPS_GNU_REL_HI16
:
3327 /* Instead of subtracting 'p' here, we should be subtracting the
3328 equivalent value for the LO part of the reloc, since the value
3329 here is relative to that address. Because that's not easy to do,
3330 we adjust 'addend' in _bfd_mips_elf_relocate_section(). See also
3331 the comment there for more information. */
3332 value
= mips_elf_high (addend
+ symbol
- p
);
3333 value
&= howto
->dst_mask
;
3337 /* The calculation for R_MIPS16_26 is just the same as for an
3338 R_MIPS_26. It's only the storage of the relocated field into
3339 the output file that's different. That's handled in
3340 mips_elf_perform_relocation. So, we just fall through to the
3341 R_MIPS_26 case here. */
3344 value
= (((addend
<< 2) | ((p
+ 4) & 0xf0000000)) + symbol
) >> 2;
3346 value
= (_bfd_mips_elf_sign_extend (addend
<< 2, 28) + symbol
) >> 2;
3347 value
&= howto
->dst_mask
;
3353 value
= mips_elf_high (addend
+ symbol
);
3354 value
&= howto
->dst_mask
;
3358 value
= mips_elf_high (addend
+ gp
- p
);
3359 overflowed_p
= mips_elf_overflow_p (value
, 16);
3365 value
= (symbol
+ addend
) & howto
->dst_mask
;
3368 value
= addend
+ gp
- p
+ 4;
3369 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
3370 for overflow. But, on, say, IRIX5, relocations against
3371 _gp_disp are normally generated from the .cpload
3372 pseudo-op. It generates code that normally looks like
3375 lui $gp,%hi(_gp_disp)
3376 addiu $gp,$gp,%lo(_gp_disp)
3379 Here $t9 holds the address of the function being called,
3380 as required by the MIPS ELF ABI. The R_MIPS_LO16
3381 relocation can easily overflow in this situation, but the
3382 R_MIPS_HI16 relocation will handle the overflow.
3383 Therefore, we consider this a bug in the MIPS ABI, and do
3384 not check for overflow here. */
3388 case R_MIPS_LITERAL
:
3389 /* Because we don't merge literal sections, we can handle this
3390 just like R_MIPS_GPREL16. In the long run, we should merge
3391 shared literals, and then we will need to additional work
3396 case R_MIPS16_GPREL
:
3397 /* The R_MIPS16_GPREL performs the same calculation as
3398 R_MIPS_GPREL16, but stores the relocated bits in a different
3399 order. We don't need to do anything special here; the
3400 differences are handled in mips_elf_perform_relocation. */
3401 case R_MIPS_GPREL16
:
3402 /* Only sign-extend the addend if it was extracted from the
3403 instruction. If the addend was separate, leave it alone,
3404 otherwise we may lose significant bits. */
3405 if (howto
->partial_inplace
)
3406 addend
= _bfd_mips_elf_sign_extend (addend
, 16);
3407 value
= symbol
+ addend
- gp
;
3408 /* If the symbol was local, any earlier relocatable links will
3409 have adjusted its addend with the gp offset, so compensate
3410 for that now. Don't do it for symbols forced local in this
3411 link, though, since they won't have had the gp offset applied
3415 overflowed_p
= mips_elf_overflow_p (value
, 16);
3424 /* The special case is when the symbol is forced to be local. We
3425 need the full address in the GOT since no R_MIPS_LO16 relocation
3427 forced
= ! mips_elf_local_relocation_p (input_bfd
, relocation
,
3428 local_sections
, FALSE
);
3429 value
= mips_elf_got16_entry (abfd
, input_bfd
, info
,
3430 symbol
+ addend
, forced
);
3431 if (value
== MINUS_ONE
)
3432 return bfd_reloc_outofrange
;
3434 = mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3435 abfd
, input_bfd
, value
);
3436 overflowed_p
= mips_elf_overflow_p (value
, 16);
3442 case R_MIPS_GOT_DISP
:
3445 overflowed_p
= mips_elf_overflow_p (value
, 16);
3448 case R_MIPS_GPREL32
:
3449 value
= (addend
+ symbol
+ gp0
- gp
);
3451 value
&= howto
->dst_mask
;
3455 value
= _bfd_mips_elf_sign_extend (addend
, 16) + symbol
- p
;
3456 overflowed_p
= mips_elf_overflow_p (value
, 16);
3459 case R_MIPS_GOT_HI16
:
3460 case R_MIPS_CALL_HI16
:
3461 /* We're allowed to handle these two relocations identically.
3462 The dynamic linker is allowed to handle the CALL relocations
3463 differently by creating a lazy evaluation stub. */
3465 value
= mips_elf_high (value
);
3466 value
&= howto
->dst_mask
;
3469 case R_MIPS_GOT_LO16
:
3470 case R_MIPS_CALL_LO16
:
3471 value
= g
& howto
->dst_mask
;
3474 case R_MIPS_GOT_PAGE
:
3475 /* GOT_PAGE relocations that reference non-local symbols decay
3476 to GOT_DISP. The corresponding GOT_OFST relocation decays to
3480 value
= mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, NULL
);
3481 if (value
== MINUS_ONE
)
3482 return bfd_reloc_outofrange
;
3483 value
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3484 abfd
, input_bfd
, value
);
3485 overflowed_p
= mips_elf_overflow_p (value
, 16);
3488 case R_MIPS_GOT_OFST
:
3490 mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, &value
);
3493 overflowed_p
= mips_elf_overflow_p (value
, 16);
3497 value
= symbol
- addend
;
3498 value
&= howto
->dst_mask
;
3502 value
= mips_elf_higher (addend
+ symbol
);
3503 value
&= howto
->dst_mask
;
3506 case R_MIPS_HIGHEST
:
3507 value
= mips_elf_highest (addend
+ symbol
);
3508 value
&= howto
->dst_mask
;
3511 case R_MIPS_SCN_DISP
:
3512 value
= symbol
+ addend
- sec
->output_offset
;
3513 value
&= howto
->dst_mask
;
3518 /* Both of these may be ignored. R_MIPS_JALR is an optimization
3519 hint; we could improve performance by honoring that hint. */
3520 return bfd_reloc_continue
;
3522 case R_MIPS_GNU_VTINHERIT
:
3523 case R_MIPS_GNU_VTENTRY
:
3524 /* We don't do anything with these at present. */
3525 return bfd_reloc_continue
;
3528 /* An unrecognized relocation type. */
3529 return bfd_reloc_notsupported
;
3532 /* Store the VALUE for our caller. */
3534 return overflowed_p
? bfd_reloc_overflow
: bfd_reloc_ok
;
3537 /* Obtain the field relocated by RELOCATION. */
3540 mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
)
3541 reloc_howto_type
*howto
;
3542 const Elf_Internal_Rela
*relocation
;
3547 bfd_byte
*location
= contents
+ relocation
->r_offset
;
3549 /* Obtain the bytes. */
3550 x
= bfd_get ((8 * bfd_get_reloc_size (howto
)), input_bfd
, location
);
3552 if ((ELF_R_TYPE (input_bfd
, relocation
->r_info
) == R_MIPS16_26
3553 || ELF_R_TYPE (input_bfd
, relocation
->r_info
) == R_MIPS16_GPREL
)
3554 && bfd_little_endian (input_bfd
))
3555 /* The two 16-bit words will be reversed on a little-endian system.
3556 See mips_elf_perform_relocation for more details. */
3557 x
= (((x
& 0xffff) << 16) | ((x
& 0xffff0000) >> 16));
3562 /* It has been determined that the result of the RELOCATION is the
3563 VALUE. Use HOWTO to place VALUE into the output file at the
3564 appropriate position. The SECTION is the section to which the
3565 relocation applies. If REQUIRE_JALX is TRUE, then the opcode used
3566 for the relocation must be either JAL or JALX, and it is
3567 unconditionally converted to JALX.
3569 Returns FALSE if anything goes wrong. */
3572 mips_elf_perform_relocation (info
, howto
, relocation
, value
, input_bfd
,
3573 input_section
, contents
, require_jalx
)
3574 struct bfd_link_info
*info
;
3575 reloc_howto_type
*howto
;
3576 const Elf_Internal_Rela
*relocation
;
3579 asection
*input_section
;
3581 bfd_boolean require_jalx
;
3585 int r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
3587 /* Figure out where the relocation is occurring. */
3588 location
= contents
+ relocation
->r_offset
;
3590 /* Obtain the current value. */
3591 x
= mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
);
3593 /* Clear the field we are setting. */
3594 x
&= ~howto
->dst_mask
;
3596 /* If this is the R_MIPS16_26 relocation, we must store the
3597 value in a funny way. */
3598 if (r_type
== R_MIPS16_26
)
3600 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
3601 Most mips16 instructions are 16 bits, but these instructions
3604 The format of these instructions is:
3606 +--------------+--------------------------------+
3607 ! JALX ! X! Imm 20:16 ! Imm 25:21 !
3608 +--------------+--------------------------------+
3610 +-----------------------------------------------+
3612 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
3613 Note that the immediate value in the first word is swapped.
3615 When producing a relocatable object file, R_MIPS16_26 is
3616 handled mostly like R_MIPS_26. In particular, the addend is
3617 stored as a straight 26-bit value in a 32-bit instruction.
3618 (gas makes life simpler for itself by never adjusting a
3619 R_MIPS16_26 reloc to be against a section, so the addend is
3620 always zero). However, the 32 bit instruction is stored as 2
3621 16-bit values, rather than a single 32-bit value. In a
3622 big-endian file, the result is the same; in a little-endian
3623 file, the two 16-bit halves of the 32 bit value are swapped.
3624 This is so that a disassembler can recognize the jal
3627 When doing a final link, R_MIPS16_26 is treated as a 32 bit
3628 instruction stored as two 16-bit values. The addend A is the
3629 contents of the targ26 field. The calculation is the same as
3630 R_MIPS_26. When storing the calculated value, reorder the
3631 immediate value as shown above, and don't forget to store the
3632 value as two 16-bit values.
3634 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
3638 +--------+----------------------+
3642 +--------+----------------------+
3645 +----------+------+-------------+
3649 +----------+--------------------+
3650 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
3651 ((sub1 << 16) | sub2)).
3653 When producing a relocatable object file, the calculation is
3654 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
3655 When producing a fully linked file, the calculation is
3656 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
3657 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff) */
3659 if (!info
->relocatable
)
3660 /* Shuffle the bits according to the formula above. */
3661 value
= (((value
& 0x1f0000) << 5)
3662 | ((value
& 0x3e00000) >> 5)
3663 | (value
& 0xffff));
3665 else if (r_type
== R_MIPS16_GPREL
)
3667 /* R_MIPS16_GPREL is used for GP-relative addressing in mips16
3668 mode. A typical instruction will have a format like this:
3670 +--------------+--------------------------------+
3671 ! EXTEND ! Imm 10:5 ! Imm 15:11 !
3672 +--------------+--------------------------------+
3673 ! Major ! rx ! ry ! Imm 4:0 !
3674 +--------------+--------------------------------+
3676 EXTEND is the five bit value 11110. Major is the instruction
3679 This is handled exactly like R_MIPS_GPREL16, except that the
3680 addend is retrieved and stored as shown in this diagram; that
3681 is, the Imm fields above replace the V-rel16 field.
3683 All we need to do here is shuffle the bits appropriately. As
3684 above, the two 16-bit halves must be swapped on a
3685 little-endian system. */
3686 value
= (((value
& 0x7e0) << 16)
3687 | ((value
& 0xf800) << 5)
3691 /* Set the field. */
3692 x
|= (value
& howto
->dst_mask
);
3694 /* If required, turn JAL into JALX. */
3698 bfd_vma opcode
= x
>> 26;
3699 bfd_vma jalx_opcode
;
3701 /* Check to see if the opcode is already JAL or JALX. */
3702 if (r_type
== R_MIPS16_26
)
3704 ok
= ((opcode
== 0x6) || (opcode
== 0x7));
3709 ok
= ((opcode
== 0x3) || (opcode
== 0x1d));
3713 /* If the opcode is not JAL or JALX, there's a problem. */
3716 (*_bfd_error_handler
)
3717 (_("%s: %s+0x%lx: jump to stub routine which is not jal"),
3718 bfd_archive_filename (input_bfd
),
3719 input_section
->name
,
3720 (unsigned long) relocation
->r_offset
);
3721 bfd_set_error (bfd_error_bad_value
);
3725 /* Make this the JALX opcode. */
3726 x
= (x
& ~(0x3f << 26)) | (jalx_opcode
<< 26);
3729 /* Swap the high- and low-order 16 bits on little-endian systems
3730 when doing a MIPS16 relocation. */
3731 if ((r_type
== R_MIPS16_GPREL
|| r_type
== R_MIPS16_26
)
3732 && bfd_little_endian (input_bfd
))
3733 x
= (((x
& 0xffff) << 16) | ((x
& 0xffff0000) >> 16));
3735 /* Put the value into the output. */
3736 bfd_put (8 * bfd_get_reloc_size (howto
), input_bfd
, x
, location
);
3740 /* Returns TRUE if SECTION is a MIPS16 stub section. */
3743 mips_elf_stub_section_p (abfd
, section
)
3744 bfd
*abfd ATTRIBUTE_UNUSED
;
3747 const char *name
= bfd_get_section_name (abfd
, section
);
3749 return (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0
3750 || strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
3751 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0);
3754 /* Add room for N relocations to the .rel.dyn section in ABFD. */
3757 mips_elf_allocate_dynamic_relocations (abfd
, n
)
3763 s
= mips_elf_rel_dyn_section (abfd
, FALSE
);
3764 BFD_ASSERT (s
!= NULL
);
3766 if (s
->_raw_size
== 0)
3768 /* Make room for a null element. */
3769 s
->_raw_size
+= MIPS_ELF_REL_SIZE (abfd
);
3772 s
->_raw_size
+= n
* MIPS_ELF_REL_SIZE (abfd
);
3775 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
3776 is the original relocation, which is now being transformed into a
3777 dynamic relocation. The ADDENDP is adjusted if necessary; the
3778 caller should store the result in place of the original addend. */
3781 mips_elf_create_dynamic_relocation (output_bfd
, info
, rel
, h
, sec
,
3782 symbol
, addendp
, input_section
)
3784 struct bfd_link_info
*info
;
3785 const Elf_Internal_Rela
*rel
;
3786 struct mips_elf_link_hash_entry
*h
;
3790 asection
*input_section
;
3792 Elf_Internal_Rela outrel
[3];
3798 r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
3799 dynobj
= elf_hash_table (info
)->dynobj
;
3800 sreloc
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
3801 BFD_ASSERT (sreloc
!= NULL
);
3802 BFD_ASSERT (sreloc
->contents
!= NULL
);
3803 BFD_ASSERT (sreloc
->reloc_count
* MIPS_ELF_REL_SIZE (output_bfd
)
3804 < sreloc
->_raw_size
);
3807 outrel
[0].r_offset
=
3808 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[0].r_offset
);
3809 outrel
[1].r_offset
=
3810 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[1].r_offset
);
3811 outrel
[2].r_offset
=
3812 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[2].r_offset
);
3815 /* We begin by assuming that the offset for the dynamic relocation
3816 is the same as for the original relocation. We'll adjust this
3817 later to reflect the correct output offsets. */
3818 if (input_section
->sec_info_type
!= ELF_INFO_TYPE_STABS
)
3820 outrel
[1].r_offset
= rel
[1].r_offset
;
3821 outrel
[2].r_offset
= rel
[2].r_offset
;
3825 /* Except that in a stab section things are more complex.
3826 Because we compress stab information, the offset given in the
3827 relocation may not be the one we want; we must let the stabs
3828 machinery tell us the offset. */
3829 outrel
[1].r_offset
= outrel
[0].r_offset
;
3830 outrel
[2].r_offset
= outrel
[0].r_offset
;
3831 /* If we didn't need the relocation at all, this value will be
3833 if (outrel
[0].r_offset
== (bfd_vma
) -1)
3838 if (outrel
[0].r_offset
== (bfd_vma
) -1)
3839 /* The relocation field has been deleted. */
3841 else if (outrel
[0].r_offset
== (bfd_vma
) -2)
3843 /* The relocation field has been converted into a relative value of
3844 some sort. Functions like _bfd_elf_write_section_eh_frame expect
3845 the field to be fully relocated, so add in the symbol's value. */
3850 /* If we've decided to skip this relocation, just output an empty
3851 record. Note that R_MIPS_NONE == 0, so that this call to memset
3852 is a way of setting R_TYPE to R_MIPS_NONE. */
3854 memset (outrel
, 0, sizeof (Elf_Internal_Rela
) * 3);
3858 bfd_boolean defined_p
;
3860 /* We must now calculate the dynamic symbol table index to use
3861 in the relocation. */
3863 && (! info
->symbolic
|| (h
->root
.elf_link_hash_flags
3864 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
3865 /* h->root.dynindx may be -1 if this symbol was marked to
3867 && h
->root
.dynindx
!= -1)
3869 indx
= h
->root
.dynindx
;
3870 if (SGI_COMPAT (output_bfd
))
3871 defined_p
= ((h
->root
.elf_link_hash_flags
3872 & ELF_LINK_HASH_DEF_REGULAR
) != 0);
3874 /* ??? glibc's ld.so just adds the final GOT entry to the
3875 relocation field. It therefore treats relocs against
3876 defined symbols in the same way as relocs against
3877 undefined symbols. */
3882 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
3884 else if (sec
== NULL
|| sec
->owner
== NULL
)
3886 bfd_set_error (bfd_error_bad_value
);
3891 indx
= elf_section_data (sec
->output_section
)->dynindx
;
3896 /* Instead of generating a relocation using the section
3897 symbol, we may as well make it a fully relative
3898 relocation. We want to avoid generating relocations to
3899 local symbols because we used to generate them
3900 incorrectly, without adding the original symbol value,
3901 which is mandated by the ABI for section symbols. In
3902 order to give dynamic loaders and applications time to
3903 phase out the incorrect use, we refrain from emitting
3904 section-relative relocations. It's not like they're
3905 useful, after all. This should be a bit more efficient
3907 /* ??? Although this behavior is compatible with glibc's ld.so,
3908 the ABI says that relocations against STN_UNDEF should have
3909 a symbol value of 0. Irix rld honors this, so relocations
3910 against STN_UNDEF have no effect. */
3911 if (!SGI_COMPAT (output_bfd
))
3916 /* If the relocation was previously an absolute relocation and
3917 this symbol will not be referred to by the relocation, we must
3918 adjust it by the value we give it in the dynamic symbol table.
3919 Otherwise leave the job up to the dynamic linker. */
3920 if (defined_p
&& r_type
!= R_MIPS_REL32
)
3923 /* The relocation is always an REL32 relocation because we don't
3924 know where the shared library will wind up at load-time. */
3925 outrel
[0].r_info
= ELF_R_INFO (output_bfd
, (unsigned long) indx
,
3927 /* For strict adherence to the ABI specification, we should
3928 generate a R_MIPS_64 relocation record by itself before the
3929 _REL32/_64 record as well, such that the addend is read in as
3930 a 64-bit value (REL32 is a 32-bit relocation, after all).
3931 However, since none of the existing ELF64 MIPS dynamic
3932 loaders seems to care, we don't waste space with these
3933 artificial relocations. If this turns out to not be true,
3934 mips_elf_allocate_dynamic_relocation() should be tweaked so
3935 as to make room for a pair of dynamic relocations per
3936 invocation if ABI_64_P, and here we should generate an
3937 additional relocation record with R_MIPS_64 by itself for a
3938 NULL symbol before this relocation record. */
3939 outrel
[1].r_info
= ELF_R_INFO (output_bfd
, (unsigned long) 0,
3940 ABI_64_P (output_bfd
)
3943 outrel
[2].r_info
= ELF_R_INFO (output_bfd
, (unsigned long) 0,
3946 /* Adjust the output offset of the relocation to reference the
3947 correct location in the output file. */
3948 outrel
[0].r_offset
+= (input_section
->output_section
->vma
3949 + input_section
->output_offset
);
3950 outrel
[1].r_offset
+= (input_section
->output_section
->vma
3951 + input_section
->output_offset
);
3952 outrel
[2].r_offset
+= (input_section
->output_section
->vma
3953 + input_section
->output_offset
);
3956 /* Put the relocation back out. We have to use the special
3957 relocation outputter in the 64-bit case since the 64-bit
3958 relocation format is non-standard. */
3959 if (ABI_64_P (output_bfd
))
3961 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
3962 (output_bfd
, &outrel
[0],
3964 + sreloc
->reloc_count
* sizeof (Elf64_Mips_External_Rel
)));
3967 bfd_elf32_swap_reloc_out
3968 (output_bfd
, &outrel
[0],
3969 (sreloc
->contents
+ sreloc
->reloc_count
* sizeof (Elf32_External_Rel
)));
3971 /* We've now added another relocation. */
3972 ++sreloc
->reloc_count
;
3974 /* Make sure the output section is writable. The dynamic linker
3975 will be writing to it. */
3976 elf_section_data (input_section
->output_section
)->this_hdr
.sh_flags
3979 /* On IRIX5, make an entry of compact relocation info. */
3980 if (! skip
&& IRIX_COMPAT (output_bfd
) == ict_irix5
)
3982 asection
*scpt
= bfd_get_section_by_name (dynobj
, ".compact_rel");
3987 Elf32_crinfo cptrel
;
3989 mips_elf_set_cr_format (cptrel
, CRF_MIPS_LONG
);
3990 cptrel
.vaddr
= (rel
->r_offset
3991 + input_section
->output_section
->vma
3992 + input_section
->output_offset
);
3993 if (r_type
== R_MIPS_REL32
)
3994 mips_elf_set_cr_type (cptrel
, CRT_MIPS_REL32
);
3996 mips_elf_set_cr_type (cptrel
, CRT_MIPS_WORD
);
3997 mips_elf_set_cr_dist2to (cptrel
, 0);
3998 cptrel
.konst
= *addendp
;
4000 cr
= (scpt
->contents
4001 + sizeof (Elf32_External_compact_rel
));
4002 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
4003 ((Elf32_External_crinfo
*) cr
4004 + scpt
->reloc_count
));
4005 ++scpt
->reloc_count
;
4012 /* Return the MACH for a MIPS e_flags value. */
4015 _bfd_elf_mips_mach (flags
)
4018 switch (flags
& EF_MIPS_MACH
)
4020 case E_MIPS_MACH_3900
:
4021 return bfd_mach_mips3900
;
4023 case E_MIPS_MACH_4010
:
4024 return bfd_mach_mips4010
;
4026 case E_MIPS_MACH_4100
:
4027 return bfd_mach_mips4100
;
4029 case E_MIPS_MACH_4111
:
4030 return bfd_mach_mips4111
;
4032 case E_MIPS_MACH_4120
:
4033 return bfd_mach_mips4120
;
4035 case E_MIPS_MACH_4650
:
4036 return bfd_mach_mips4650
;
4038 case E_MIPS_MACH_5400
:
4039 return bfd_mach_mips5400
;
4041 case E_MIPS_MACH_5500
:
4042 return bfd_mach_mips5500
;
4044 case E_MIPS_MACH_SB1
:
4045 return bfd_mach_mips_sb1
;
4048 switch (flags
& EF_MIPS_ARCH
)
4052 return bfd_mach_mips3000
;
4056 return bfd_mach_mips6000
;
4060 return bfd_mach_mips4000
;
4064 return bfd_mach_mips8000
;
4068 return bfd_mach_mips5
;
4071 case E_MIPS_ARCH_32
:
4072 return bfd_mach_mipsisa32
;
4075 case E_MIPS_ARCH_64
:
4076 return bfd_mach_mipsisa64
;
4079 case E_MIPS_ARCH_32R2
:
4080 return bfd_mach_mipsisa32r2
;
4083 case E_MIPS_ARCH_64R2
:
4084 return bfd_mach_mipsisa64r2
;
4092 /* Return printable name for ABI. */
4094 static INLINE
char *
4095 elf_mips_abi_name (abfd
)
4100 flags
= elf_elfheader (abfd
)->e_flags
;
4101 switch (flags
& EF_MIPS_ABI
)
4104 if (ABI_N32_P (abfd
))
4106 else if (ABI_64_P (abfd
))
4110 case E_MIPS_ABI_O32
:
4112 case E_MIPS_ABI_O64
:
4114 case E_MIPS_ABI_EABI32
:
4116 case E_MIPS_ABI_EABI64
:
4119 return "unknown abi";
4123 /* MIPS ELF uses two common sections. One is the usual one, and the
4124 other is for small objects. All the small objects are kept
4125 together, and then referenced via the gp pointer, which yields
4126 faster assembler code. This is what we use for the small common
4127 section. This approach is copied from ecoff.c. */
4128 static asection mips_elf_scom_section
;
4129 static asymbol mips_elf_scom_symbol
;
4130 static asymbol
*mips_elf_scom_symbol_ptr
;
4132 /* MIPS ELF also uses an acommon section, which represents an
4133 allocated common symbol which may be overridden by a
4134 definition in a shared library. */
4135 static asection mips_elf_acom_section
;
4136 static asymbol mips_elf_acom_symbol
;
4137 static asymbol
*mips_elf_acom_symbol_ptr
;
4139 /* Handle the special MIPS section numbers that a symbol may use.
4140 This is used for both the 32-bit and the 64-bit ABI. */
4143 _bfd_mips_elf_symbol_processing (abfd
, asym
)
4147 elf_symbol_type
*elfsym
;
4149 elfsym
= (elf_symbol_type
*) asym
;
4150 switch (elfsym
->internal_elf_sym
.st_shndx
)
4152 case SHN_MIPS_ACOMMON
:
4153 /* This section is used in a dynamically linked executable file.
4154 It is an allocated common section. The dynamic linker can
4155 either resolve these symbols to something in a shared
4156 library, or it can just leave them here. For our purposes,
4157 we can consider these symbols to be in a new section. */
4158 if (mips_elf_acom_section
.name
== NULL
)
4160 /* Initialize the acommon section. */
4161 mips_elf_acom_section
.name
= ".acommon";
4162 mips_elf_acom_section
.flags
= SEC_ALLOC
;
4163 mips_elf_acom_section
.output_section
= &mips_elf_acom_section
;
4164 mips_elf_acom_section
.symbol
= &mips_elf_acom_symbol
;
4165 mips_elf_acom_section
.symbol_ptr_ptr
= &mips_elf_acom_symbol_ptr
;
4166 mips_elf_acom_symbol
.name
= ".acommon";
4167 mips_elf_acom_symbol
.flags
= BSF_SECTION_SYM
;
4168 mips_elf_acom_symbol
.section
= &mips_elf_acom_section
;
4169 mips_elf_acom_symbol_ptr
= &mips_elf_acom_symbol
;
4171 asym
->section
= &mips_elf_acom_section
;
4175 /* Common symbols less than the GP size are automatically
4176 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
4177 if (asym
->value
> elf_gp_size (abfd
)
4178 || IRIX_COMPAT (abfd
) == ict_irix6
)
4181 case SHN_MIPS_SCOMMON
:
4182 if (mips_elf_scom_section
.name
== NULL
)
4184 /* Initialize the small common section. */
4185 mips_elf_scom_section
.name
= ".scommon";
4186 mips_elf_scom_section
.flags
= SEC_IS_COMMON
;
4187 mips_elf_scom_section
.output_section
= &mips_elf_scom_section
;
4188 mips_elf_scom_section
.symbol
= &mips_elf_scom_symbol
;
4189 mips_elf_scom_section
.symbol_ptr_ptr
= &mips_elf_scom_symbol_ptr
;
4190 mips_elf_scom_symbol
.name
= ".scommon";
4191 mips_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
4192 mips_elf_scom_symbol
.section
= &mips_elf_scom_section
;
4193 mips_elf_scom_symbol_ptr
= &mips_elf_scom_symbol
;
4195 asym
->section
= &mips_elf_scom_section
;
4196 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
4199 case SHN_MIPS_SUNDEFINED
:
4200 asym
->section
= bfd_und_section_ptr
;
4203 #if 0 /* for SGI_COMPAT */
4205 asym
->section
= mips_elf_text_section_ptr
;
4209 asym
->section
= mips_elf_data_section_ptr
;
4215 /* Work over a section just before writing it out. This routine is
4216 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
4217 sections that need the SHF_MIPS_GPREL flag by name; there has to be
4221 _bfd_mips_elf_section_processing (abfd
, hdr
)
4223 Elf_Internal_Shdr
*hdr
;
4225 if (hdr
->sh_type
== SHT_MIPS_REGINFO
4226 && hdr
->sh_size
> 0)
4230 BFD_ASSERT (hdr
->sh_size
== sizeof (Elf32_External_RegInfo
));
4231 BFD_ASSERT (hdr
->contents
== NULL
);
4234 hdr
->sh_offset
+ sizeof (Elf32_External_RegInfo
) - 4,
4237 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
4238 if (bfd_bwrite (buf
, (bfd_size_type
) 4, abfd
) != 4)
4242 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
4243 && hdr
->bfd_section
!= NULL
4244 && mips_elf_section_data (hdr
->bfd_section
) != NULL
4245 && mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
!= NULL
)
4247 bfd_byte
*contents
, *l
, *lend
;
4249 /* We stored the section contents in the tdata field in the
4250 set_section_contents routine. We save the section contents
4251 so that we don't have to read them again.
4252 At this point we know that elf_gp is set, so we can look
4253 through the section contents to see if there is an
4254 ODK_REGINFO structure. */
4256 contents
= mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
;
4258 lend
= contents
+ hdr
->sh_size
;
4259 while (l
+ sizeof (Elf_External_Options
) <= lend
)
4261 Elf_Internal_Options intopt
;
4263 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
4265 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
4272 + sizeof (Elf_External_Options
)
4273 + (sizeof (Elf64_External_RegInfo
) - 8)),
4276 H_PUT_64 (abfd
, elf_gp (abfd
), buf
);
4277 if (bfd_bwrite (buf
, (bfd_size_type
) 8, abfd
) != 8)
4280 else if (intopt
.kind
== ODK_REGINFO
)
4287 + sizeof (Elf_External_Options
)
4288 + (sizeof (Elf32_External_RegInfo
) - 4)),
4291 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
4292 if (bfd_bwrite (buf
, (bfd_size_type
) 4, abfd
) != 4)
4299 if (hdr
->bfd_section
!= NULL
)
4301 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
4303 if (strcmp (name
, ".sdata") == 0
4304 || strcmp (name
, ".lit8") == 0
4305 || strcmp (name
, ".lit4") == 0)
4307 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
4308 hdr
->sh_type
= SHT_PROGBITS
;
4310 else if (strcmp (name
, ".sbss") == 0)
4312 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
4313 hdr
->sh_type
= SHT_NOBITS
;
4315 else if (strcmp (name
, ".srdata") == 0)
4317 hdr
->sh_flags
|= SHF_ALLOC
| SHF_MIPS_GPREL
;
4318 hdr
->sh_type
= SHT_PROGBITS
;
4320 else if (strcmp (name
, ".compact_rel") == 0)
4323 hdr
->sh_type
= SHT_PROGBITS
;
4325 else if (strcmp (name
, ".rtproc") == 0)
4327 if (hdr
->sh_addralign
!= 0 && hdr
->sh_entsize
== 0)
4329 unsigned int adjust
;
4331 adjust
= hdr
->sh_size
% hdr
->sh_addralign
;
4333 hdr
->sh_size
+= hdr
->sh_addralign
- adjust
;
4341 /* Handle a MIPS specific section when reading an object file. This
4342 is called when elfcode.h finds a section with an unknown type.
4343 This routine supports both the 32-bit and 64-bit ELF ABI.
4345 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
4349 _bfd_mips_elf_section_from_shdr (abfd
, hdr
, name
)
4351 Elf_Internal_Shdr
*hdr
;
4356 /* There ought to be a place to keep ELF backend specific flags, but
4357 at the moment there isn't one. We just keep track of the
4358 sections by their name, instead. Fortunately, the ABI gives
4359 suggested names for all the MIPS specific sections, so we will
4360 probably get away with this. */
4361 switch (hdr
->sh_type
)
4363 case SHT_MIPS_LIBLIST
:
4364 if (strcmp (name
, ".liblist") != 0)
4368 if (strcmp (name
, ".msym") != 0)
4371 case SHT_MIPS_CONFLICT
:
4372 if (strcmp (name
, ".conflict") != 0)
4375 case SHT_MIPS_GPTAB
:
4376 if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) != 0)
4379 case SHT_MIPS_UCODE
:
4380 if (strcmp (name
, ".ucode") != 0)
4383 case SHT_MIPS_DEBUG
:
4384 if (strcmp (name
, ".mdebug") != 0)
4386 flags
= SEC_DEBUGGING
;
4388 case SHT_MIPS_REGINFO
:
4389 if (strcmp (name
, ".reginfo") != 0
4390 || hdr
->sh_size
!= sizeof (Elf32_External_RegInfo
))
4392 flags
= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_SIZE
);
4394 case SHT_MIPS_IFACE
:
4395 if (strcmp (name
, ".MIPS.interfaces") != 0)
4398 case SHT_MIPS_CONTENT
:
4399 if (strncmp (name
, ".MIPS.content", sizeof ".MIPS.content" - 1) != 0)
4402 case SHT_MIPS_OPTIONS
:
4403 if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) != 0)
4406 case SHT_MIPS_DWARF
:
4407 if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) != 0)
4410 case SHT_MIPS_SYMBOL_LIB
:
4411 if (strcmp (name
, ".MIPS.symlib") != 0)
4414 case SHT_MIPS_EVENTS
:
4415 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) != 0
4416 && strncmp (name
, ".MIPS.post_rel",
4417 sizeof ".MIPS.post_rel" - 1) != 0)
4424 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
4429 if (! bfd_set_section_flags (abfd
, hdr
->bfd_section
,
4430 (bfd_get_section_flags (abfd
,
4436 /* FIXME: We should record sh_info for a .gptab section. */
4438 /* For a .reginfo section, set the gp value in the tdata information
4439 from the contents of this section. We need the gp value while
4440 processing relocs, so we just get it now. The .reginfo section
4441 is not used in the 64-bit MIPS ELF ABI. */
4442 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
4444 Elf32_External_RegInfo ext
;
4447 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, (PTR
) &ext
,
4449 (bfd_size_type
) sizeof ext
))
4451 bfd_mips_elf32_swap_reginfo_in (abfd
, &ext
, &s
);
4452 elf_gp (abfd
) = s
.ri_gp_value
;
4455 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
4456 set the gp value based on what we find. We may see both
4457 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
4458 they should agree. */
4459 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
)
4461 bfd_byte
*contents
, *l
, *lend
;
4463 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
4464 if (contents
== NULL
)
4466 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
,
4467 (file_ptr
) 0, hdr
->sh_size
))
4473 lend
= contents
+ hdr
->sh_size
;
4474 while (l
+ sizeof (Elf_External_Options
) <= lend
)
4476 Elf_Internal_Options intopt
;
4478 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
4480 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
4482 Elf64_Internal_RegInfo intreg
;
4484 bfd_mips_elf64_swap_reginfo_in
4486 ((Elf64_External_RegInfo
*)
4487 (l
+ sizeof (Elf_External_Options
))),
4489 elf_gp (abfd
) = intreg
.ri_gp_value
;
4491 else if (intopt
.kind
== ODK_REGINFO
)
4493 Elf32_RegInfo intreg
;
4495 bfd_mips_elf32_swap_reginfo_in
4497 ((Elf32_External_RegInfo
*)
4498 (l
+ sizeof (Elf_External_Options
))),
4500 elf_gp (abfd
) = intreg
.ri_gp_value
;
4510 /* Set the correct type for a MIPS ELF section. We do this by the
4511 section name, which is a hack, but ought to work. This routine is
4512 used by both the 32-bit and the 64-bit ABI. */
4515 _bfd_mips_elf_fake_sections (abfd
, hdr
, sec
)
4517 Elf_Internal_Shdr
*hdr
;
4520 register const char *name
;
4522 name
= bfd_get_section_name (abfd
, sec
);
4524 if (strcmp (name
, ".liblist") == 0)
4526 hdr
->sh_type
= SHT_MIPS_LIBLIST
;
4527 hdr
->sh_info
= sec
->_raw_size
/ sizeof (Elf32_Lib
);
4528 /* The sh_link field is set in final_write_processing. */
4530 else if (strcmp (name
, ".conflict") == 0)
4531 hdr
->sh_type
= SHT_MIPS_CONFLICT
;
4532 else if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0)
4534 hdr
->sh_type
= SHT_MIPS_GPTAB
;
4535 hdr
->sh_entsize
= sizeof (Elf32_External_gptab
);
4536 /* The sh_info field is set in final_write_processing. */
4538 else if (strcmp (name
, ".ucode") == 0)
4539 hdr
->sh_type
= SHT_MIPS_UCODE
;
4540 else if (strcmp (name
, ".mdebug") == 0)
4542 hdr
->sh_type
= SHT_MIPS_DEBUG
;
4543 /* In a shared object on IRIX 5.3, the .mdebug section has an
4544 entsize of 0. FIXME: Does this matter? */
4545 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
4546 hdr
->sh_entsize
= 0;
4548 hdr
->sh_entsize
= 1;
4550 else if (strcmp (name
, ".reginfo") == 0)
4552 hdr
->sh_type
= SHT_MIPS_REGINFO
;
4553 /* In a shared object on IRIX 5.3, the .reginfo section has an
4554 entsize of 0x18. FIXME: Does this matter? */
4555 if (SGI_COMPAT (abfd
))
4557 if ((abfd
->flags
& DYNAMIC
) != 0)
4558 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
4560 hdr
->sh_entsize
= 1;
4563 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
4565 else if (SGI_COMPAT (abfd
)
4566 && (strcmp (name
, ".hash") == 0
4567 || strcmp (name
, ".dynamic") == 0
4568 || strcmp (name
, ".dynstr") == 0))
4570 if (SGI_COMPAT (abfd
))
4571 hdr
->sh_entsize
= 0;
4573 /* This isn't how the IRIX6 linker behaves. */
4574 hdr
->sh_info
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
4577 else if (strcmp (name
, ".got") == 0
4578 || strcmp (name
, ".srdata") == 0
4579 || strcmp (name
, ".sdata") == 0
4580 || strcmp (name
, ".sbss") == 0
4581 || strcmp (name
, ".lit4") == 0
4582 || strcmp (name
, ".lit8") == 0)
4583 hdr
->sh_flags
|= SHF_MIPS_GPREL
;
4584 else if (strcmp (name
, ".MIPS.interfaces") == 0)
4586 hdr
->sh_type
= SHT_MIPS_IFACE
;
4587 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4589 else if (strncmp (name
, ".MIPS.content", strlen (".MIPS.content")) == 0)
4591 hdr
->sh_type
= SHT_MIPS_CONTENT
;
4592 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4593 /* The sh_info field is set in final_write_processing. */
4595 else if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
4597 hdr
->sh_type
= SHT_MIPS_OPTIONS
;
4598 hdr
->sh_entsize
= 1;
4599 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4601 else if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) == 0)
4602 hdr
->sh_type
= SHT_MIPS_DWARF
;
4603 else if (strcmp (name
, ".MIPS.symlib") == 0)
4605 hdr
->sh_type
= SHT_MIPS_SYMBOL_LIB
;
4606 /* The sh_link and sh_info fields are set in
4607 final_write_processing. */
4609 else if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0
4610 || strncmp (name
, ".MIPS.post_rel",
4611 sizeof ".MIPS.post_rel" - 1) == 0)
4613 hdr
->sh_type
= SHT_MIPS_EVENTS
;
4614 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4615 /* The sh_link field is set in final_write_processing. */
4617 else if (strcmp (name
, ".msym") == 0)
4619 hdr
->sh_type
= SHT_MIPS_MSYM
;
4620 hdr
->sh_flags
|= SHF_ALLOC
;
4621 hdr
->sh_entsize
= 8;
4624 /* The generic elf_fake_sections will set up REL_HDR using the default
4625 kind of relocations. We used to set up a second header for the
4626 non-default kind of relocations here, but only NewABI would use
4627 these, and the IRIX ld doesn't like resulting empty RELA sections.
4628 Thus we create those header only on demand now. */
4633 /* Given a BFD section, try to locate the corresponding ELF section
4634 index. This is used by both the 32-bit and the 64-bit ABI.
4635 Actually, it's not clear to me that the 64-bit ABI supports these,
4636 but for non-PIC objects we will certainly want support for at least
4637 the .scommon section. */
4640 _bfd_mips_elf_section_from_bfd_section (abfd
, sec
, retval
)
4641 bfd
*abfd ATTRIBUTE_UNUSED
;
4645 if (strcmp (bfd_get_section_name (abfd
, sec
), ".scommon") == 0)
4647 *retval
= SHN_MIPS_SCOMMON
;
4650 if (strcmp (bfd_get_section_name (abfd
, sec
), ".acommon") == 0)
4652 *retval
= SHN_MIPS_ACOMMON
;
4658 /* Hook called by the linker routine which adds symbols from an object
4659 file. We must handle the special MIPS section numbers here. */
4662 _bfd_mips_elf_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
, secp
, valp
)
4664 struct bfd_link_info
*info
;
4665 const Elf_Internal_Sym
*sym
;
4667 flagword
*flagsp ATTRIBUTE_UNUSED
;
4671 if (SGI_COMPAT (abfd
)
4672 && (abfd
->flags
& DYNAMIC
) != 0
4673 && strcmp (*namep
, "_rld_new_interface") == 0)
4675 /* Skip IRIX5 rld entry name. */
4680 switch (sym
->st_shndx
)
4683 /* Common symbols less than the GP size are automatically
4684 treated as SHN_MIPS_SCOMMON symbols. */
4685 if (sym
->st_size
> elf_gp_size (abfd
)
4686 || IRIX_COMPAT (abfd
) == ict_irix6
)
4689 case SHN_MIPS_SCOMMON
:
4690 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
4691 (*secp
)->flags
|= SEC_IS_COMMON
;
4692 *valp
= sym
->st_size
;
4696 /* This section is used in a shared object. */
4697 if (elf_tdata (abfd
)->elf_text_section
== NULL
)
4699 asymbol
*elf_text_symbol
;
4700 asection
*elf_text_section
;
4701 bfd_size_type amt
= sizeof (asection
);
4703 elf_text_section
= bfd_zalloc (abfd
, amt
);
4704 if (elf_text_section
== NULL
)
4707 amt
= sizeof (asymbol
);
4708 elf_text_symbol
= bfd_zalloc (abfd
, amt
);
4709 if (elf_text_symbol
== NULL
)
4712 /* Initialize the section. */
4714 elf_tdata (abfd
)->elf_text_section
= elf_text_section
;
4715 elf_tdata (abfd
)->elf_text_symbol
= elf_text_symbol
;
4717 elf_text_section
->symbol
= elf_text_symbol
;
4718 elf_text_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_text_symbol
;
4720 elf_text_section
->name
= ".text";
4721 elf_text_section
->flags
= SEC_NO_FLAGS
;
4722 elf_text_section
->output_section
= NULL
;
4723 elf_text_section
->owner
= abfd
;
4724 elf_text_symbol
->name
= ".text";
4725 elf_text_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
4726 elf_text_symbol
->section
= elf_text_section
;
4728 /* This code used to do *secp = bfd_und_section_ptr if
4729 info->shared. I don't know why, and that doesn't make sense,
4730 so I took it out. */
4731 *secp
= elf_tdata (abfd
)->elf_text_section
;
4734 case SHN_MIPS_ACOMMON
:
4735 /* Fall through. XXX Can we treat this as allocated data? */
4737 /* This section is used in a shared object. */
4738 if (elf_tdata (abfd
)->elf_data_section
== NULL
)
4740 asymbol
*elf_data_symbol
;
4741 asection
*elf_data_section
;
4742 bfd_size_type amt
= sizeof (asection
);
4744 elf_data_section
= bfd_zalloc (abfd
, amt
);
4745 if (elf_data_section
== NULL
)
4748 amt
= sizeof (asymbol
);
4749 elf_data_symbol
= bfd_zalloc (abfd
, amt
);
4750 if (elf_data_symbol
== NULL
)
4753 /* Initialize the section. */
4755 elf_tdata (abfd
)->elf_data_section
= elf_data_section
;
4756 elf_tdata (abfd
)->elf_data_symbol
= elf_data_symbol
;
4758 elf_data_section
->symbol
= elf_data_symbol
;
4759 elf_data_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_data_symbol
;
4761 elf_data_section
->name
= ".data";
4762 elf_data_section
->flags
= SEC_NO_FLAGS
;
4763 elf_data_section
->output_section
= NULL
;
4764 elf_data_section
->owner
= abfd
;
4765 elf_data_symbol
->name
= ".data";
4766 elf_data_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
4767 elf_data_symbol
->section
= elf_data_section
;
4769 /* This code used to do *secp = bfd_und_section_ptr if
4770 info->shared. I don't know why, and that doesn't make sense,
4771 so I took it out. */
4772 *secp
= elf_tdata (abfd
)->elf_data_section
;
4775 case SHN_MIPS_SUNDEFINED
:
4776 *secp
= bfd_und_section_ptr
;
4780 if (SGI_COMPAT (abfd
)
4782 && info
->hash
->creator
== abfd
->xvec
4783 && strcmp (*namep
, "__rld_obj_head") == 0)
4785 struct elf_link_hash_entry
*h
;
4786 struct bfd_link_hash_entry
*bh
;
4788 /* Mark __rld_obj_head as dynamic. */
4790 if (! (_bfd_generic_link_add_one_symbol
4791 (info
, abfd
, *namep
, BSF_GLOBAL
, *secp
,
4792 (bfd_vma
) *valp
, (const char *) NULL
, FALSE
,
4793 get_elf_backend_data (abfd
)->collect
, &bh
)))
4796 h
= (struct elf_link_hash_entry
*) bh
;
4797 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
4798 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4799 h
->type
= STT_OBJECT
;
4801 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
4804 mips_elf_hash_table (info
)->use_rld_obj_head
= TRUE
;
4807 /* If this is a mips16 text symbol, add 1 to the value to make it
4808 odd. This will cause something like .word SYM to come up with
4809 the right value when it is loaded into the PC. */
4810 if (sym
->st_other
== STO_MIPS16
)
4816 /* This hook function is called before the linker writes out a global
4817 symbol. We mark symbols as small common if appropriate. This is
4818 also where we undo the increment of the value for a mips16 symbol. */
4821 _bfd_mips_elf_link_output_symbol_hook (abfd
, info
, name
, sym
, input_sec
)
4822 bfd
*abfd ATTRIBUTE_UNUSED
;
4823 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
4824 const char *name ATTRIBUTE_UNUSED
;
4825 Elf_Internal_Sym
*sym
;
4826 asection
*input_sec
;
4828 /* If we see a common symbol, which implies a relocatable link, then
4829 if a symbol was small common in an input file, mark it as small
4830 common in the output file. */
4831 if (sym
->st_shndx
== SHN_COMMON
4832 && strcmp (input_sec
->name
, ".scommon") == 0)
4833 sym
->st_shndx
= SHN_MIPS_SCOMMON
;
4835 if (sym
->st_other
== STO_MIPS16
4836 && (sym
->st_value
& 1) != 0)
4842 /* Functions for the dynamic linker. */
4844 /* Create dynamic sections when linking against a dynamic object. */
4847 _bfd_mips_elf_create_dynamic_sections (abfd
, info
)
4849 struct bfd_link_info
*info
;
4851 struct elf_link_hash_entry
*h
;
4852 struct bfd_link_hash_entry
*bh
;
4854 register asection
*s
;
4855 const char * const *namep
;
4857 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
4858 | SEC_LINKER_CREATED
| SEC_READONLY
);
4860 /* Mips ABI requests the .dynamic section to be read only. */
4861 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4864 if (! bfd_set_section_flags (abfd
, s
, flags
))
4868 /* We need to create .got section. */
4869 if (! mips_elf_create_got_section (abfd
, info
, FALSE
))
4872 if (! mips_elf_rel_dyn_section (elf_hash_table (info
)->dynobj
, TRUE
))
4875 /* Create .stub section. */
4876 if (bfd_get_section_by_name (abfd
,
4877 MIPS_ELF_STUB_SECTION_NAME (abfd
)) == NULL
)
4879 s
= bfd_make_section (abfd
, MIPS_ELF_STUB_SECTION_NAME (abfd
));
4881 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_CODE
)
4882 || ! bfd_set_section_alignment (abfd
, s
,
4883 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
4887 if ((IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
4889 && bfd_get_section_by_name (abfd
, ".rld_map") == NULL
)
4891 s
= bfd_make_section (abfd
, ".rld_map");
4893 || ! bfd_set_section_flags (abfd
, s
, flags
&~ (flagword
) SEC_READONLY
)
4894 || ! bfd_set_section_alignment (abfd
, s
,
4895 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
4899 /* On IRIX5, we adjust add some additional symbols and change the
4900 alignments of several sections. There is no ABI documentation
4901 indicating that this is necessary on IRIX6, nor any evidence that
4902 the linker takes such action. */
4903 if (IRIX_COMPAT (abfd
) == ict_irix5
)
4905 for (namep
= mips_elf_dynsym_rtproc_names
; *namep
!= NULL
; namep
++)
4908 if (! (_bfd_generic_link_add_one_symbol
4909 (info
, abfd
, *namep
, BSF_GLOBAL
, bfd_und_section_ptr
,
4910 (bfd_vma
) 0, (const char *) NULL
, FALSE
,
4911 get_elf_backend_data (abfd
)->collect
, &bh
)))
4914 h
= (struct elf_link_hash_entry
*) bh
;
4915 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
4916 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4917 h
->type
= STT_SECTION
;
4919 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
4923 /* We need to create a .compact_rel section. */
4924 if (SGI_COMPAT (abfd
))
4926 if (!mips_elf_create_compact_rel_section (abfd
, info
))
4930 /* Change alignments of some sections. */
4931 s
= bfd_get_section_by_name (abfd
, ".hash");
4933 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4934 s
= bfd_get_section_by_name (abfd
, ".dynsym");
4936 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4937 s
= bfd_get_section_by_name (abfd
, ".dynstr");
4939 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4940 s
= bfd_get_section_by_name (abfd
, ".reginfo");
4942 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4943 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4945 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4952 name
= SGI_COMPAT (abfd
) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
4954 if (!(_bfd_generic_link_add_one_symbol
4955 (info
, abfd
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
,
4956 (bfd_vma
) 0, (const char *) NULL
, FALSE
,
4957 get_elf_backend_data (abfd
)->collect
, &bh
)))
4960 h
= (struct elf_link_hash_entry
*) bh
;
4961 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
4962 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4963 h
->type
= STT_SECTION
;
4965 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
4968 if (! mips_elf_hash_table (info
)->use_rld_obj_head
)
4970 /* __rld_map is a four byte word located in the .data section
4971 and is filled in by the rtld to contain a pointer to
4972 the _r_debug structure. Its symbol value will be set in
4973 _bfd_mips_elf_finish_dynamic_symbol. */
4974 s
= bfd_get_section_by_name (abfd
, ".rld_map");
4975 BFD_ASSERT (s
!= NULL
);
4977 name
= SGI_COMPAT (abfd
) ? "__rld_map" : "__RLD_MAP";
4979 if (!(_bfd_generic_link_add_one_symbol
4980 (info
, abfd
, name
, BSF_GLOBAL
, s
,
4981 (bfd_vma
) 0, (const char *) NULL
, FALSE
,
4982 get_elf_backend_data (abfd
)->collect
, &bh
)))
4985 h
= (struct elf_link_hash_entry
*) bh
;
4986 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
4987 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4988 h
->type
= STT_OBJECT
;
4990 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
4998 /* Look through the relocs for a section during the first phase, and
4999 allocate space in the global offset table. */
5002 _bfd_mips_elf_check_relocs (abfd
, info
, sec
, relocs
)
5004 struct bfd_link_info
*info
;
5006 const Elf_Internal_Rela
*relocs
;
5010 Elf_Internal_Shdr
*symtab_hdr
;
5011 struct elf_link_hash_entry
**sym_hashes
;
5012 struct mips_got_info
*g
;
5014 const Elf_Internal_Rela
*rel
;
5015 const Elf_Internal_Rela
*rel_end
;
5018 const struct elf_backend_data
*bed
;
5020 if (info
->relocatable
)
5023 dynobj
= elf_hash_table (info
)->dynobj
;
5024 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5025 sym_hashes
= elf_sym_hashes (abfd
);
5026 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
5028 /* Check for the mips16 stub sections. */
5030 name
= bfd_get_section_name (abfd
, sec
);
5031 if (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0)
5033 unsigned long r_symndx
;
5035 /* Look at the relocation information to figure out which symbol
5038 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
5040 if (r_symndx
< extsymoff
5041 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
5045 /* This stub is for a local symbol. This stub will only be
5046 needed if there is some relocation in this BFD, other
5047 than a 16 bit function call, which refers to this symbol. */
5048 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5050 Elf_Internal_Rela
*sec_relocs
;
5051 const Elf_Internal_Rela
*r
, *rend
;
5053 /* We can ignore stub sections when looking for relocs. */
5054 if ((o
->flags
& SEC_RELOC
) == 0
5055 || o
->reloc_count
== 0
5056 || strncmp (bfd_get_section_name (abfd
, o
), FN_STUB
,
5057 sizeof FN_STUB
- 1) == 0
5058 || strncmp (bfd_get_section_name (abfd
, o
), CALL_STUB
,
5059 sizeof CALL_STUB
- 1) == 0
5060 || strncmp (bfd_get_section_name (abfd
, o
), CALL_FP_STUB
,
5061 sizeof CALL_FP_STUB
- 1) == 0)
5065 = _bfd_elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
5066 (Elf_Internal_Rela
*) NULL
,
5068 if (sec_relocs
== NULL
)
5071 rend
= sec_relocs
+ o
->reloc_count
;
5072 for (r
= sec_relocs
; r
< rend
; r
++)
5073 if (ELF_R_SYM (abfd
, r
->r_info
) == r_symndx
5074 && ELF_R_TYPE (abfd
, r
->r_info
) != R_MIPS16_26
)
5077 if (elf_section_data (o
)->relocs
!= sec_relocs
)
5086 /* There is no non-call reloc for this stub, so we do
5087 not need it. Since this function is called before
5088 the linker maps input sections to output sections, we
5089 can easily discard it by setting the SEC_EXCLUDE
5091 sec
->flags
|= SEC_EXCLUDE
;
5095 /* Record this stub in an array of local symbol stubs for
5097 if (elf_tdata (abfd
)->local_stubs
== NULL
)
5099 unsigned long symcount
;
5103 if (elf_bad_symtab (abfd
))
5104 symcount
= NUM_SHDR_ENTRIES (symtab_hdr
);
5106 symcount
= symtab_hdr
->sh_info
;
5107 amt
= symcount
* sizeof (asection
*);
5108 n
= (asection
**) bfd_zalloc (abfd
, amt
);
5111 elf_tdata (abfd
)->local_stubs
= n
;
5114 elf_tdata (abfd
)->local_stubs
[r_symndx
] = sec
;
5116 /* We don't need to set mips16_stubs_seen in this case.
5117 That flag is used to see whether we need to look through
5118 the global symbol table for stubs. We don't need to set
5119 it here, because we just have a local stub. */
5123 struct mips_elf_link_hash_entry
*h
;
5125 h
= ((struct mips_elf_link_hash_entry
*)
5126 sym_hashes
[r_symndx
- extsymoff
]);
5128 /* H is the symbol this stub is for. */
5131 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
5134 else if (strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
5135 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
5137 unsigned long r_symndx
;
5138 struct mips_elf_link_hash_entry
*h
;
5141 /* Look at the relocation information to figure out which symbol
5144 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
5146 if (r_symndx
< extsymoff
5147 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
5149 /* This stub was actually built for a static symbol defined
5150 in the same file. We assume that all static symbols in
5151 mips16 code are themselves mips16, so we can simply
5152 discard this stub. Since this function is called before
5153 the linker maps input sections to output sections, we can
5154 easily discard it by setting the SEC_EXCLUDE flag. */
5155 sec
->flags
|= SEC_EXCLUDE
;
5159 h
= ((struct mips_elf_link_hash_entry
*)
5160 sym_hashes
[r_symndx
- extsymoff
]);
5162 /* H is the symbol this stub is for. */
5164 if (strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
5165 loc
= &h
->call_fp_stub
;
5167 loc
= &h
->call_stub
;
5169 /* If we already have an appropriate stub for this function, we
5170 don't need another one, so we can discard this one. Since
5171 this function is called before the linker maps input sections
5172 to output sections, we can easily discard it by setting the
5173 SEC_EXCLUDE flag. We can also discard this section if we
5174 happen to already know that this is a mips16 function; it is
5175 not necessary to check this here, as it is checked later, but
5176 it is slightly faster to check now. */
5177 if (*loc
!= NULL
|| h
->root
.other
== STO_MIPS16
)
5179 sec
->flags
|= SEC_EXCLUDE
;
5184 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
5194 sgot
= mips_elf_got_section (dynobj
, FALSE
);
5199 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
5200 g
= mips_elf_section_data (sgot
)->u
.got_info
;
5201 BFD_ASSERT (g
!= NULL
);
5206 bed
= get_elf_backend_data (abfd
);
5207 rel_end
= relocs
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
5208 for (rel
= relocs
; rel
< rel_end
; ++rel
)
5210 unsigned long r_symndx
;
5211 unsigned int r_type
;
5212 struct elf_link_hash_entry
*h
;
5214 r_symndx
= ELF_R_SYM (abfd
, rel
->r_info
);
5215 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
5217 if (r_symndx
< extsymoff
)
5219 else if (r_symndx
>= extsymoff
+ NUM_SHDR_ENTRIES (symtab_hdr
))
5221 (*_bfd_error_handler
)
5222 (_("%s: Malformed reloc detected for section %s"),
5223 bfd_archive_filename (abfd
), name
);
5224 bfd_set_error (bfd_error_bad_value
);
5229 h
= sym_hashes
[r_symndx
- extsymoff
];
5231 /* This may be an indirect symbol created because of a version. */
5234 while (h
->root
.type
== bfd_link_hash_indirect
)
5235 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5239 /* Some relocs require a global offset table. */
5240 if (dynobj
== NULL
|| sgot
== NULL
)
5246 case R_MIPS_CALL_HI16
:
5247 case R_MIPS_CALL_LO16
:
5248 case R_MIPS_GOT_HI16
:
5249 case R_MIPS_GOT_LO16
:
5250 case R_MIPS_GOT_PAGE
:
5251 case R_MIPS_GOT_OFST
:
5252 case R_MIPS_GOT_DISP
:
5254 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5255 if (! mips_elf_create_got_section (dynobj
, info
, FALSE
))
5257 g
= mips_elf_got_info (dynobj
, &sgot
);
5264 && (info
->shared
|| h
!= NULL
)
5265 && (sec
->flags
& SEC_ALLOC
) != 0)
5266 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5274 if (!h
&& (r_type
== R_MIPS_CALL_LO16
5275 || r_type
== R_MIPS_GOT_LO16
5276 || r_type
== R_MIPS_GOT_DISP
))
5278 /* We may need a local GOT entry for this relocation. We
5279 don't count R_MIPS_GOT_PAGE because we can estimate the
5280 maximum number of pages needed by looking at the size of
5281 the segment. Similar comments apply to R_MIPS_GOT16 and
5282 R_MIPS_CALL16. We don't count R_MIPS_GOT_HI16, or
5283 R_MIPS_CALL_HI16 because these are always followed by an
5284 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
5285 if (! mips_elf_record_local_got_symbol (abfd
, r_symndx
,
5295 (*_bfd_error_handler
)
5296 (_("%s: CALL16 reloc at 0x%lx not against global symbol"),
5297 bfd_archive_filename (abfd
), (unsigned long) rel
->r_offset
);
5298 bfd_set_error (bfd_error_bad_value
);
5303 case R_MIPS_CALL_HI16
:
5304 case R_MIPS_CALL_LO16
:
5307 /* This symbol requires a global offset table entry. */
5308 if (! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5311 /* We need a stub, not a plt entry for the undefined
5312 function. But we record it as if it needs plt. See
5313 elf_adjust_dynamic_symbol in elflink.h. */
5314 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
5319 case R_MIPS_GOT_PAGE
:
5320 /* If this is a global, overridable symbol, GOT_PAGE will
5321 decay to GOT_DISP, so we'll need a GOT entry for it. */
5326 struct mips_elf_link_hash_entry
*hmips
=
5327 (struct mips_elf_link_hash_entry
*) h
;
5329 while (hmips
->root
.root
.type
== bfd_link_hash_indirect
5330 || hmips
->root
.root
.type
== bfd_link_hash_warning
)
5331 hmips
= (struct mips_elf_link_hash_entry
*)
5332 hmips
->root
.root
.u
.i
.link
;
5334 if ((hmips
->root
.root
.type
== bfd_link_hash_defined
5335 || hmips
->root
.root
.type
== bfd_link_hash_defweak
)
5336 && hmips
->root
.root
.u
.def
.section
5337 && ! (info
->shared
&& ! info
->symbolic
5338 && ! (hmips
->root
.elf_link_hash_flags
5339 & ELF_LINK_FORCED_LOCAL
))
5340 /* If we've encountered any other relocation
5341 referencing the symbol, we'll have marked it as
5342 dynamic, and, even though we might be able to get
5343 rid of the GOT entry should we know for sure all
5344 previous relocations were GOT_PAGE ones, at this
5345 point we can't tell, so just keep using the
5346 symbol as dynamic. This is very important in the
5347 multi-got case, since we don't decide whether to
5348 decay GOT_PAGE to GOT_DISP on a per-GOT basis: if
5349 the symbol is dynamic, we'll need a GOT entry for
5350 every GOT in which the symbol is referenced with
5351 a GOT_PAGE relocation. */
5352 && hmips
->root
.dynindx
== -1)
5358 case R_MIPS_GOT_HI16
:
5359 case R_MIPS_GOT_LO16
:
5360 case R_MIPS_GOT_DISP
:
5361 /* This symbol requires a global offset table entry. */
5362 if (h
&& ! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5369 if ((info
->shared
|| h
!= NULL
)
5370 && (sec
->flags
& SEC_ALLOC
) != 0)
5374 sreloc
= mips_elf_rel_dyn_section (dynobj
, TRUE
);
5378 #define MIPS_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
5381 /* When creating a shared object, we must copy these
5382 reloc types into the output file as R_MIPS_REL32
5383 relocs. We make room for this reloc in the
5384 .rel.dyn reloc section. */
5385 mips_elf_allocate_dynamic_relocations (dynobj
, 1);
5386 if ((sec
->flags
& MIPS_READONLY_SECTION
)
5387 == MIPS_READONLY_SECTION
)
5388 /* We tell the dynamic linker that there are
5389 relocations against the text segment. */
5390 info
->flags
|= DF_TEXTREL
;
5394 struct mips_elf_link_hash_entry
*hmips
;
5396 /* We only need to copy this reloc if the symbol is
5397 defined in a dynamic object. */
5398 hmips
= (struct mips_elf_link_hash_entry
*) h
;
5399 ++hmips
->possibly_dynamic_relocs
;
5400 if ((sec
->flags
& MIPS_READONLY_SECTION
)
5401 == MIPS_READONLY_SECTION
)
5402 /* We need it to tell the dynamic linker if there
5403 are relocations against the text segment. */
5404 hmips
->readonly_reloc
= TRUE
;
5407 /* Even though we don't directly need a GOT entry for
5408 this symbol, a symbol must have a dynamic symbol
5409 table index greater that DT_MIPS_GOTSYM if there are
5410 dynamic relocations against it. */
5414 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5415 if (! mips_elf_create_got_section (dynobj
, info
, TRUE
))
5417 g
= mips_elf_got_info (dynobj
, &sgot
);
5418 if (! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5423 if (SGI_COMPAT (abfd
))
5424 mips_elf_hash_table (info
)->compact_rel_size
+=
5425 sizeof (Elf32_External_crinfo
);
5429 case R_MIPS_GPREL16
:
5430 case R_MIPS_LITERAL
:
5431 case R_MIPS_GPREL32
:
5432 if (SGI_COMPAT (abfd
))
5433 mips_elf_hash_table (info
)->compact_rel_size
+=
5434 sizeof (Elf32_External_crinfo
);
5437 /* This relocation describes the C++ object vtable hierarchy.
5438 Reconstruct it for later use during GC. */
5439 case R_MIPS_GNU_VTINHERIT
:
5440 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
5444 /* This relocation describes which C++ vtable entries are actually
5445 used. Record for later use during GC. */
5446 case R_MIPS_GNU_VTENTRY
:
5447 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
5455 /* We must not create a stub for a symbol that has relocations
5456 related to taking the function's address. */
5462 struct mips_elf_link_hash_entry
*mh
;
5464 mh
= (struct mips_elf_link_hash_entry
*) h
;
5465 mh
->no_fn_stub
= TRUE
;
5469 case R_MIPS_CALL_HI16
:
5470 case R_MIPS_CALL_LO16
:
5475 /* If this reloc is not a 16 bit call, and it has a global
5476 symbol, then we will need the fn_stub if there is one.
5477 References from a stub section do not count. */
5479 && r_type
!= R_MIPS16_26
5480 && strncmp (bfd_get_section_name (abfd
, sec
), FN_STUB
,
5481 sizeof FN_STUB
- 1) != 0
5482 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_STUB
,
5483 sizeof CALL_STUB
- 1) != 0
5484 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_FP_STUB
,
5485 sizeof CALL_FP_STUB
- 1) != 0)
5487 struct mips_elf_link_hash_entry
*mh
;
5489 mh
= (struct mips_elf_link_hash_entry
*) h
;
5490 mh
->need_fn_stub
= TRUE
;
5498 _bfd_mips_relax_section (abfd
, sec
, link_info
, again
)
5501 struct bfd_link_info
*link_info
;
5504 Elf_Internal_Rela
*internal_relocs
;
5505 Elf_Internal_Rela
*irel
, *irelend
;
5506 Elf_Internal_Shdr
*symtab_hdr
;
5507 bfd_byte
*contents
= NULL
;
5508 bfd_byte
*free_contents
= NULL
;
5510 bfd_boolean changed_contents
= FALSE
;
5511 bfd_vma sec_start
= sec
->output_section
->vma
+ sec
->output_offset
;
5512 Elf_Internal_Sym
*isymbuf
= NULL
;
5514 /* We are not currently changing any sizes, so only one pass. */
5517 if (link_info
->relocatable
)
5520 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, (PTR
) NULL
,
5521 (Elf_Internal_Rela
*) NULL
,
5522 link_info
->keep_memory
);
5523 if (internal_relocs
== NULL
)
5526 irelend
= internal_relocs
+ sec
->reloc_count
5527 * get_elf_backend_data (abfd
)->s
->int_rels_per_ext_rel
;
5528 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5529 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
5531 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
5534 bfd_signed_vma sym_offset
;
5535 unsigned int r_type
;
5536 unsigned long r_symndx
;
5538 unsigned long instruction
;
5540 /* Turn jalr into bgezal, and jr into beq, if they're marked
5541 with a JALR relocation, that indicate where they jump to.
5542 This saves some pipeline bubbles. */
5543 r_type
= ELF_R_TYPE (abfd
, irel
->r_info
);
5544 if (r_type
!= R_MIPS_JALR
)
5547 r_symndx
= ELF_R_SYM (abfd
, irel
->r_info
);
5548 /* Compute the address of the jump target. */
5549 if (r_symndx
>= extsymoff
)
5551 struct mips_elf_link_hash_entry
*h
5552 = ((struct mips_elf_link_hash_entry
*)
5553 elf_sym_hashes (abfd
) [r_symndx
- extsymoff
]);
5555 while (h
->root
.root
.type
== bfd_link_hash_indirect
5556 || h
->root
.root
.type
== bfd_link_hash_warning
)
5557 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
5559 /* If a symbol is undefined, or if it may be overridden,
5561 if (! ((h
->root
.root
.type
== bfd_link_hash_defined
5562 || h
->root
.root
.type
== bfd_link_hash_defweak
)
5563 && h
->root
.root
.u
.def
.section
)
5564 || (link_info
->shared
&& ! link_info
->symbolic
5565 && ! (h
->root
.elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
)))
5568 sym_sec
= h
->root
.root
.u
.def
.section
;
5569 if (sym_sec
->output_section
)
5570 symval
= (h
->root
.root
.u
.def
.value
5571 + sym_sec
->output_section
->vma
5572 + sym_sec
->output_offset
);
5574 symval
= h
->root
.root
.u
.def
.value
;
5578 Elf_Internal_Sym
*isym
;
5580 /* Read this BFD's symbols if we haven't done so already. */
5581 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
5583 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5584 if (isymbuf
== NULL
)
5585 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
5586 symtab_hdr
->sh_info
, 0,
5588 if (isymbuf
== NULL
)
5592 isym
= isymbuf
+ r_symndx
;
5593 if (isym
->st_shndx
== SHN_UNDEF
)
5595 else if (isym
->st_shndx
== SHN_ABS
)
5596 sym_sec
= bfd_abs_section_ptr
;
5597 else if (isym
->st_shndx
== SHN_COMMON
)
5598 sym_sec
= bfd_com_section_ptr
;
5601 = bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
5602 symval
= isym
->st_value
5603 + sym_sec
->output_section
->vma
5604 + sym_sec
->output_offset
;
5607 /* Compute branch offset, from delay slot of the jump to the
5609 sym_offset
= (symval
+ irel
->r_addend
)
5610 - (sec_start
+ irel
->r_offset
+ 4);
5612 /* Branch offset must be properly aligned. */
5613 if ((sym_offset
& 3) != 0)
5618 /* Check that it's in range. */
5619 if (sym_offset
< -0x8000 || sym_offset
>= 0x8000)
5622 /* Get the section contents if we haven't done so already. */
5623 if (contents
== NULL
)
5625 /* Get cached copy if it exists. */
5626 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
5627 contents
= elf_section_data (sec
)->this_hdr
.contents
;
5630 contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
5631 if (contents
== NULL
)
5634 free_contents
= contents
;
5635 if (! bfd_get_section_contents (abfd
, sec
, contents
,
5636 (file_ptr
) 0, sec
->_raw_size
))
5641 instruction
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
5643 /* If it was jalr <reg>, turn it into bgezal $zero, <target>. */
5644 if ((instruction
& 0xfc1fffff) == 0x0000f809)
5645 instruction
= 0x04110000;
5646 /* If it was jr <reg>, turn it into b <target>. */
5647 else if ((instruction
& 0xfc1fffff) == 0x00000008)
5648 instruction
= 0x10000000;
5652 instruction
|= (sym_offset
& 0xffff);
5653 bfd_put_32 (abfd
, instruction
, contents
+ irel
->r_offset
);
5654 changed_contents
= TRUE
;
5657 if (contents
!= NULL
5658 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
5660 if (!changed_contents
&& !link_info
->keep_memory
)
5664 /* Cache the section contents for elf_link_input_bfd. */
5665 elf_section_data (sec
)->this_hdr
.contents
= contents
;
5671 if (free_contents
!= NULL
)
5672 free (free_contents
);
5676 /* Adjust a symbol defined by a dynamic object and referenced by a
5677 regular object. The current definition is in some section of the
5678 dynamic object, but we're not including those sections. We have to
5679 change the definition to something the rest of the link can
5683 _bfd_mips_elf_adjust_dynamic_symbol (info
, h
)
5684 struct bfd_link_info
*info
;
5685 struct elf_link_hash_entry
*h
;
5688 struct mips_elf_link_hash_entry
*hmips
;
5691 dynobj
= elf_hash_table (info
)->dynobj
;
5693 /* Make sure we know what is going on here. */
5694 BFD_ASSERT (dynobj
!= NULL
5695 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
5696 || h
->weakdef
!= NULL
5697 || ((h
->elf_link_hash_flags
5698 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
5699 && (h
->elf_link_hash_flags
5700 & ELF_LINK_HASH_REF_REGULAR
) != 0
5701 && (h
->elf_link_hash_flags
5702 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
5704 /* If this symbol is defined in a dynamic object, we need to copy
5705 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
5707 hmips
= (struct mips_elf_link_hash_entry
*) h
;
5708 if (! info
->relocatable
5709 && hmips
->possibly_dynamic_relocs
!= 0
5710 && (h
->root
.type
== bfd_link_hash_defweak
5711 || (h
->elf_link_hash_flags
5712 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
5714 mips_elf_allocate_dynamic_relocations (dynobj
,
5715 hmips
->possibly_dynamic_relocs
);
5716 if (hmips
->readonly_reloc
)
5717 /* We tell the dynamic linker that there are relocations
5718 against the text segment. */
5719 info
->flags
|= DF_TEXTREL
;
5722 /* For a function, create a stub, if allowed. */
5723 if (! hmips
->no_fn_stub
5724 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
5726 if (! elf_hash_table (info
)->dynamic_sections_created
)
5729 /* If this symbol is not defined in a regular file, then set
5730 the symbol to the stub location. This is required to make
5731 function pointers compare as equal between the normal
5732 executable and the shared library. */
5733 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
5735 /* We need .stub section. */
5736 s
= bfd_get_section_by_name (dynobj
,
5737 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
5738 BFD_ASSERT (s
!= NULL
);
5740 h
->root
.u
.def
.section
= s
;
5741 h
->root
.u
.def
.value
= s
->_raw_size
;
5743 /* XXX Write this stub address somewhere. */
5744 h
->plt
.offset
= s
->_raw_size
;
5746 /* Make room for this stub code. */
5747 s
->_raw_size
+= MIPS_FUNCTION_STUB_SIZE
;
5749 /* The last half word of the stub will be filled with the index
5750 of this symbol in .dynsym section. */
5754 else if ((h
->type
== STT_FUNC
)
5755 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0)
5757 /* This will set the entry for this symbol in the GOT to 0, and
5758 the dynamic linker will take care of this. */
5759 h
->root
.u
.def
.value
= 0;
5763 /* If this is a weak symbol, and there is a real definition, the
5764 processor independent code will have arranged for us to see the
5765 real definition first, and we can just use the same value. */
5766 if (h
->weakdef
!= NULL
)
5768 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
5769 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
5770 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
5771 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
5775 /* This is a reference to a symbol defined by a dynamic object which
5776 is not a function. */
5781 /* This function is called after all the input files have been read,
5782 and the input sections have been assigned to output sections. We
5783 check for any mips16 stub sections that we can discard. */
5786 _bfd_mips_elf_always_size_sections (output_bfd
, info
)
5788 struct bfd_link_info
*info
;
5794 struct mips_got_info
*g
;
5796 bfd_size_type loadable_size
= 0;
5797 bfd_size_type local_gotno
;
5800 /* The .reginfo section has a fixed size. */
5801 ri
= bfd_get_section_by_name (output_bfd
, ".reginfo");
5803 bfd_set_section_size (output_bfd
, ri
,
5804 (bfd_size_type
) sizeof (Elf32_External_RegInfo
));
5806 if (! (info
->relocatable
5807 || ! mips_elf_hash_table (info
)->mips16_stubs_seen
))
5808 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
5809 mips_elf_check_mips16_stubs
,
5812 dynobj
= elf_hash_table (info
)->dynobj
;
5814 /* Relocatable links don't have it. */
5817 g
= mips_elf_got_info (dynobj
, &s
);
5821 /* Calculate the total loadable size of the output. That
5822 will give us the maximum number of GOT_PAGE entries
5824 for (sub
= info
->input_bfds
; sub
; sub
= sub
->link_next
)
5826 asection
*subsection
;
5828 for (subsection
= sub
->sections
;
5830 subsection
= subsection
->next
)
5832 if ((subsection
->flags
& SEC_ALLOC
) == 0)
5834 loadable_size
+= ((subsection
->_raw_size
+ 0xf)
5835 &~ (bfd_size_type
) 0xf);
5839 /* There has to be a global GOT entry for every symbol with
5840 a dynamic symbol table index of DT_MIPS_GOTSYM or
5841 higher. Therefore, it make sense to put those symbols
5842 that need GOT entries at the end of the symbol table. We
5844 if (! mips_elf_sort_hash_table (info
, 1))
5847 if (g
->global_gotsym
!= NULL
)
5848 i
= elf_hash_table (info
)->dynsymcount
- g
->global_gotsym
->dynindx
;
5850 /* If there are no global symbols, or none requiring
5851 relocations, then GLOBAL_GOTSYM will be NULL. */
5854 /* In the worst case, we'll get one stub per dynamic symbol, plus
5855 one to account for the dummy entry at the end required by IRIX
5857 loadable_size
+= MIPS_FUNCTION_STUB_SIZE
* (i
+ 1);
5859 /* Assume there are two loadable segments consisting of
5860 contiguous sections. Is 5 enough? */
5861 local_gotno
= (loadable_size
>> 16) + 5;
5863 g
->local_gotno
+= local_gotno
;
5864 s
->_raw_size
+= g
->local_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
5866 g
->global_gotno
= i
;
5867 s
->_raw_size
+= i
* MIPS_ELF_GOT_SIZE (output_bfd
);
5869 if (s
->_raw_size
> MIPS_ELF_GOT_MAX_SIZE (output_bfd
)
5870 && ! mips_elf_multi_got (output_bfd
, info
, g
, s
, local_gotno
))
5876 /* Set the sizes of the dynamic sections. */
5879 _bfd_mips_elf_size_dynamic_sections (output_bfd
, info
)
5881 struct bfd_link_info
*info
;
5885 bfd_boolean reltext
;
5887 dynobj
= elf_hash_table (info
)->dynobj
;
5888 BFD_ASSERT (dynobj
!= NULL
);
5890 if (elf_hash_table (info
)->dynamic_sections_created
)
5892 /* Set the contents of the .interp section to the interpreter. */
5893 if (info
->executable
)
5895 s
= bfd_get_section_by_name (dynobj
, ".interp");
5896 BFD_ASSERT (s
!= NULL
);
5898 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd
)) + 1;
5900 = (bfd_byte
*) ELF_DYNAMIC_INTERPRETER (output_bfd
);
5904 /* The check_relocs and adjust_dynamic_symbol entry points have
5905 determined the sizes of the various dynamic sections. Allocate
5908 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
5913 /* It's OK to base decisions on the section name, because none
5914 of the dynobj section names depend upon the input files. */
5915 name
= bfd_get_section_name (dynobj
, s
);
5917 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
5922 if (strncmp (name
, ".rel", 4) == 0)
5924 if (s
->_raw_size
== 0)
5926 /* We only strip the section if the output section name
5927 has the same name. Otherwise, there might be several
5928 input sections for this output section. FIXME: This
5929 code is probably not needed these days anyhow, since
5930 the linker now does not create empty output sections. */
5931 if (s
->output_section
!= NULL
5933 bfd_get_section_name (s
->output_section
->owner
,
5934 s
->output_section
)) == 0)
5939 const char *outname
;
5942 /* If this relocation section applies to a read only
5943 section, then we probably need a DT_TEXTREL entry.
5944 If the relocation section is .rel.dyn, we always
5945 assert a DT_TEXTREL entry rather than testing whether
5946 there exists a relocation to a read only section or
5948 outname
= bfd_get_section_name (output_bfd
,
5950 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
5952 && (target
->flags
& SEC_READONLY
) != 0
5953 && (target
->flags
& SEC_ALLOC
) != 0)
5954 || strcmp (outname
, ".rel.dyn") == 0)
5957 /* We use the reloc_count field as a counter if we need
5958 to copy relocs into the output file. */
5959 if (strcmp (name
, ".rel.dyn") != 0)
5962 /* If combreloc is enabled, elf_link_sort_relocs() will
5963 sort relocations, but in a different way than we do,
5964 and before we're done creating relocations. Also, it
5965 will move them around between input sections'
5966 relocation's contents, so our sorting would be
5967 broken, so don't let it run. */
5968 info
->combreloc
= 0;
5971 else if (strncmp (name
, ".got", 4) == 0)
5973 /* _bfd_mips_elf_always_size_sections() has already done
5974 most of the work, but some symbols may have been mapped
5975 to versions that we must now resolve in the got_entries
5977 struct mips_got_info
*gg
= mips_elf_got_info (dynobj
, NULL
);
5978 struct mips_got_info
*g
= gg
;
5979 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
5980 unsigned int needed_relocs
= 0;
5984 set_got_offset_arg
.value
= MIPS_ELF_GOT_SIZE (output_bfd
);
5985 set_got_offset_arg
.info
= info
;
5987 mips_elf_resolve_final_got_entries (gg
);
5988 for (g
= gg
->next
; g
&& g
->next
!= gg
; g
= g
->next
)
5990 unsigned int save_assign
;
5992 mips_elf_resolve_final_got_entries (g
);
5994 /* Assign offsets to global GOT entries. */
5995 save_assign
= g
->assigned_gotno
;
5996 g
->assigned_gotno
= g
->local_gotno
;
5997 set_got_offset_arg
.g
= g
;
5998 set_got_offset_arg
.needed_relocs
= 0;
5999 htab_traverse (g
->got_entries
,
6000 mips_elf_set_global_got_offset
,
6001 &set_got_offset_arg
);
6002 needed_relocs
+= set_got_offset_arg
.needed_relocs
;
6003 BFD_ASSERT (g
->assigned_gotno
- g
->local_gotno
6004 <= g
->global_gotno
);
6006 g
->assigned_gotno
= save_assign
;
6009 needed_relocs
+= g
->local_gotno
- g
->assigned_gotno
;
6010 BFD_ASSERT (g
->assigned_gotno
== g
->next
->local_gotno
6011 + g
->next
->global_gotno
6012 + MIPS_RESERVED_GOTNO
);
6017 mips_elf_allocate_dynamic_relocations (dynobj
, needed_relocs
);
6020 else if (strcmp (name
, MIPS_ELF_STUB_SECTION_NAME (output_bfd
)) == 0)
6022 /* IRIX rld assumes that the function stub isn't at the end
6023 of .text section. So put a dummy. XXX */
6024 s
->_raw_size
+= MIPS_FUNCTION_STUB_SIZE
;
6026 else if (! info
->shared
6027 && ! mips_elf_hash_table (info
)->use_rld_obj_head
6028 && strncmp (name
, ".rld_map", 8) == 0)
6030 /* We add a room for __rld_map. It will be filled in by the
6031 rtld to contain a pointer to the _r_debug structure. */
6034 else if (SGI_COMPAT (output_bfd
)
6035 && strncmp (name
, ".compact_rel", 12) == 0)
6036 s
->_raw_size
+= mips_elf_hash_table (info
)->compact_rel_size
;
6037 else if (strncmp (name
, ".init", 5) != 0)
6039 /* It's not one of our sections, so don't allocate space. */
6045 _bfd_strip_section_from_output (info
, s
);
6049 /* Allocate memory for the section contents. */
6050 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
6051 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
6053 bfd_set_error (bfd_error_no_memory
);
6058 if (elf_hash_table (info
)->dynamic_sections_created
)
6060 /* Add some entries to the .dynamic section. We fill in the
6061 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
6062 must add the entries now so that we get the correct size for
6063 the .dynamic section. The DT_DEBUG entry is filled in by the
6064 dynamic linker and used by the debugger. */
6067 /* SGI object has the equivalence of DT_DEBUG in the
6068 DT_MIPS_RLD_MAP entry. */
6069 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_MAP
, 0))
6071 if (!SGI_COMPAT (output_bfd
))
6073 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
6079 /* Shared libraries on traditional mips have DT_DEBUG. */
6080 if (!SGI_COMPAT (output_bfd
))
6082 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
6087 if (reltext
&& SGI_COMPAT (output_bfd
))
6088 info
->flags
|= DF_TEXTREL
;
6090 if ((info
->flags
& DF_TEXTREL
) != 0)
6092 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_TEXTREL
, 0))
6096 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTGOT
, 0))
6099 if (mips_elf_rel_dyn_section (dynobj
, FALSE
))
6101 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_REL
, 0))
6104 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELSZ
, 0))
6107 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELENT
, 0))
6111 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_VERSION
, 0))
6114 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_FLAGS
, 0))
6118 /* Time stamps in executable files are a bad idea. */
6119 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_TIME_STAMP
, 0))
6124 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_ICHECKSUM
, 0))
6129 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_IVERSION
, 0))
6133 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_BASE_ADDRESS
, 0))
6136 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LOCAL_GOTNO
, 0))
6139 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_SYMTABNO
, 0))
6142 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_UNREFEXTNO
, 0))
6145 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_GOTSYM
, 0))
6148 if (IRIX_COMPAT (dynobj
) == ict_irix5
6149 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_HIPAGENO
, 0))
6152 if (IRIX_COMPAT (dynobj
) == ict_irix6
6153 && (bfd_get_section_by_name
6154 (dynobj
, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj
)))
6155 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_OPTIONS
, 0))
6162 /* Relocate a MIPS ELF section. */
6165 _bfd_mips_elf_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
6166 contents
, relocs
, local_syms
, local_sections
)
6168 struct bfd_link_info
*info
;
6170 asection
*input_section
;
6172 Elf_Internal_Rela
*relocs
;
6173 Elf_Internal_Sym
*local_syms
;
6174 asection
**local_sections
;
6176 Elf_Internal_Rela
*rel
;
6177 const Elf_Internal_Rela
*relend
;
6179 bfd_boolean use_saved_addend_p
= FALSE
;
6180 const struct elf_backend_data
*bed
;
6182 bed
= get_elf_backend_data (output_bfd
);
6183 relend
= relocs
+ input_section
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
6184 for (rel
= relocs
; rel
< relend
; ++rel
)
6188 reloc_howto_type
*howto
;
6189 bfd_boolean require_jalx
;
6190 /* TRUE if the relocation is a RELA relocation, rather than a
6192 bfd_boolean rela_relocation_p
= TRUE
;
6193 unsigned int r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
6194 const char * msg
= (const char *) NULL
;
6196 /* Find the relocation howto for this relocation. */
6197 if (r_type
== R_MIPS_64
&& ! NEWABI_P (input_bfd
))
6199 /* Some 32-bit code uses R_MIPS_64. In particular, people use
6200 64-bit code, but make sure all their addresses are in the
6201 lowermost or uppermost 32-bit section of the 64-bit address
6202 space. Thus, when they use an R_MIPS_64 they mean what is
6203 usually meant by R_MIPS_32, with the exception that the
6204 stored value is sign-extended to 64 bits. */
6205 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, R_MIPS_32
, FALSE
);
6207 /* On big-endian systems, we need to lie about the position
6209 if (bfd_big_endian (input_bfd
))
6213 /* NewABI defaults to RELA relocations. */
6214 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, r_type
,
6215 NEWABI_P (input_bfd
)
6216 && (MIPS_RELOC_RELA_P
6217 (input_bfd
, input_section
,
6220 if (!use_saved_addend_p
)
6222 Elf_Internal_Shdr
*rel_hdr
;
6224 /* If these relocations were originally of the REL variety,
6225 we must pull the addend out of the field that will be
6226 relocated. Otherwise, we simply use the contents of the
6227 RELA relocation. To determine which flavor or relocation
6228 this is, we depend on the fact that the INPUT_SECTION's
6229 REL_HDR is read before its REL_HDR2. */
6230 rel_hdr
= &elf_section_data (input_section
)->rel_hdr
;
6231 if ((size_t) (rel
- relocs
)
6232 >= (NUM_SHDR_ENTRIES (rel_hdr
) * bed
->s
->int_rels_per_ext_rel
))
6233 rel_hdr
= elf_section_data (input_section
)->rel_hdr2
;
6234 if (rel_hdr
->sh_entsize
== MIPS_ELF_REL_SIZE (input_bfd
))
6236 /* Note that this is a REL relocation. */
6237 rela_relocation_p
= FALSE
;
6239 /* Get the addend, which is stored in the input file. */
6240 addend
= mips_elf_obtain_contents (howto
, rel
, input_bfd
,
6242 addend
&= howto
->src_mask
;
6243 addend
<<= howto
->rightshift
;
6245 /* For some kinds of relocations, the ADDEND is a
6246 combination of the addend stored in two different
6248 if (r_type
== R_MIPS_HI16
6249 || r_type
== R_MIPS_GNU_REL_HI16
6250 || (r_type
== R_MIPS_GOT16
6251 && mips_elf_local_relocation_p (input_bfd
, rel
,
6252 local_sections
, FALSE
)))
6255 const Elf_Internal_Rela
*lo16_relocation
;
6256 reloc_howto_type
*lo16_howto
;
6259 /* The combined value is the sum of the HI16 addend,
6260 left-shifted by sixteen bits, and the LO16
6261 addend, sign extended. (Usually, the code does
6262 a `lui' of the HI16 value, and then an `addiu' of
6265 Scan ahead to find a matching LO16 relocation. */
6266 if (r_type
== R_MIPS_GNU_REL_HI16
)
6267 lo
= R_MIPS_GNU_REL_LO16
;
6270 lo16_relocation
= mips_elf_next_relocation (input_bfd
, lo
,
6272 if (lo16_relocation
== NULL
)
6275 /* Obtain the addend kept there. */
6276 lo16_howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, lo
, FALSE
);
6277 l
= mips_elf_obtain_contents (lo16_howto
, lo16_relocation
,
6278 input_bfd
, contents
);
6279 l
&= lo16_howto
->src_mask
;
6280 l
<<= lo16_howto
->rightshift
;
6281 l
= _bfd_mips_elf_sign_extend (l
, 16);
6285 /* Compute the combined addend. */
6288 /* If PC-relative, subtract the difference between the
6289 address of the LO part of the reloc and the address of
6290 the HI part. The relocation is relative to the LO
6291 part, but mips_elf_calculate_relocation() doesn't
6292 know its address or the difference from the HI part, so
6293 we subtract that difference here. See also the
6294 comment in mips_elf_calculate_relocation(). */
6295 if (r_type
== R_MIPS_GNU_REL_HI16
)
6296 addend
-= (lo16_relocation
->r_offset
- rel
->r_offset
);
6298 else if (r_type
== R_MIPS16_GPREL
)
6300 /* The addend is scrambled in the object file. See
6301 mips_elf_perform_relocation for details on the
6303 addend
= (((addend
& 0x1f0000) >> 5)
6304 | ((addend
& 0x7e00000) >> 16)
6309 addend
= rel
->r_addend
;
6312 if (info
->relocatable
)
6314 Elf_Internal_Sym
*sym
;
6315 unsigned long r_symndx
;
6317 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
)
6318 && bfd_big_endian (input_bfd
))
6321 /* Since we're just relocating, all we need to do is copy
6322 the relocations back out to the object file, unless
6323 they're against a section symbol, in which case we need
6324 to adjust by the section offset, or unless they're GP
6325 relative in which case we need to adjust by the amount
6326 that we're adjusting GP in this relocatable object. */
6328 if (! mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
,
6330 /* There's nothing to do for non-local relocations. */
6333 if (r_type
== R_MIPS16_GPREL
6334 || r_type
== R_MIPS_GPREL16
6335 || r_type
== R_MIPS_GPREL32
6336 || r_type
== R_MIPS_LITERAL
)
6337 addend
-= (_bfd_get_gp_value (output_bfd
)
6338 - _bfd_get_gp_value (input_bfd
));
6340 r_symndx
= ELF_R_SYM (output_bfd
, rel
->r_info
);
6341 sym
= local_syms
+ r_symndx
;
6342 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6343 /* Adjust the addend appropriately. */
6344 addend
+= local_sections
[r_symndx
]->output_offset
;
6346 if (howto
->partial_inplace
)
6348 /* If the relocation is for a R_MIPS_HI16 or R_MIPS_GOT16,
6349 then we only want to write out the high-order 16 bits.
6350 The subsequent R_MIPS_LO16 will handle the low-order bits.
6352 if (r_type
== R_MIPS_HI16
|| r_type
== R_MIPS_GOT16
6353 || r_type
== R_MIPS_GNU_REL_HI16
)
6354 addend
= mips_elf_high (addend
);
6355 else if (r_type
== R_MIPS_HIGHER
)
6356 addend
= mips_elf_higher (addend
);
6357 else if (r_type
== R_MIPS_HIGHEST
)
6358 addend
= mips_elf_highest (addend
);
6361 if (rela_relocation_p
)
6362 /* If this is a RELA relocation, just update the addend.
6363 We have to cast away constness for REL. */
6364 rel
->r_addend
= addend
;
6367 /* Otherwise, we have to write the value back out. Note
6368 that we use the source mask, rather than the
6369 destination mask because the place to which we are
6370 writing will be source of the addend in the final
6372 addend
>>= howto
->rightshift
;
6373 addend
&= howto
->src_mask
;
6375 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
6376 /* See the comment above about using R_MIPS_64 in the 32-bit
6377 ABI. Here, we need to update the addend. It would be
6378 possible to get away with just using the R_MIPS_32 reloc
6379 but for endianness. */
6385 if (addend
& ((bfd_vma
) 1 << 31))
6387 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
6394 /* If we don't know that we have a 64-bit type,
6395 do two separate stores. */
6396 if (bfd_big_endian (input_bfd
))
6398 /* Store the sign-bits (which are most significant)
6400 low_bits
= sign_bits
;
6406 high_bits
= sign_bits
;
6408 bfd_put_32 (input_bfd
, low_bits
,
6409 contents
+ rel
->r_offset
);
6410 bfd_put_32 (input_bfd
, high_bits
,
6411 contents
+ rel
->r_offset
+ 4);
6415 if (! mips_elf_perform_relocation (info
, howto
, rel
, addend
,
6416 input_bfd
, input_section
,
6421 /* Go on to the next relocation. */
6425 /* In the N32 and 64-bit ABIs there may be multiple consecutive
6426 relocations for the same offset. In that case we are
6427 supposed to treat the output of each relocation as the addend
6429 if (rel
+ 1 < relend
6430 && rel
->r_offset
== rel
[1].r_offset
6431 && ELF_R_TYPE (input_bfd
, rel
[1].r_info
) != R_MIPS_NONE
)
6432 use_saved_addend_p
= TRUE
;
6434 use_saved_addend_p
= FALSE
;
6436 addend
>>= howto
->rightshift
;
6438 /* Figure out what value we are supposed to relocate. */
6439 switch (mips_elf_calculate_relocation (output_bfd
, input_bfd
,
6440 input_section
, info
, rel
,
6441 addend
, howto
, local_syms
,
6442 local_sections
, &value
,
6443 &name
, &require_jalx
,
6444 use_saved_addend_p
))
6446 case bfd_reloc_continue
:
6447 /* There's nothing to do. */
6450 case bfd_reloc_undefined
:
6451 /* mips_elf_calculate_relocation already called the
6452 undefined_symbol callback. There's no real point in
6453 trying to perform the relocation at this point, so we
6454 just skip ahead to the next relocation. */
6457 case bfd_reloc_notsupported
:
6458 msg
= _("internal error: unsupported relocation error");
6459 info
->callbacks
->warning
6460 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
6463 case bfd_reloc_overflow
:
6464 if (use_saved_addend_p
)
6465 /* Ignore overflow until we reach the last relocation for
6466 a given location. */
6470 BFD_ASSERT (name
!= NULL
);
6471 if (! ((*info
->callbacks
->reloc_overflow
)
6472 (info
, name
, howto
->name
, (bfd_vma
) 0,
6473 input_bfd
, input_section
, rel
->r_offset
)))
6486 /* If we've got another relocation for the address, keep going
6487 until we reach the last one. */
6488 if (use_saved_addend_p
)
6494 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
6495 /* See the comment above about using R_MIPS_64 in the 32-bit
6496 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
6497 that calculated the right value. Now, however, we
6498 sign-extend the 32-bit result to 64-bits, and store it as a
6499 64-bit value. We are especially generous here in that we
6500 go to extreme lengths to support this usage on systems with
6501 only a 32-bit VMA. */
6507 if (value
& ((bfd_vma
) 1 << 31))
6509 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
6516 /* If we don't know that we have a 64-bit type,
6517 do two separate stores. */
6518 if (bfd_big_endian (input_bfd
))
6520 /* Undo what we did above. */
6522 /* Store the sign-bits (which are most significant)
6524 low_bits
= sign_bits
;
6530 high_bits
= sign_bits
;
6532 bfd_put_32 (input_bfd
, low_bits
,
6533 contents
+ rel
->r_offset
);
6534 bfd_put_32 (input_bfd
, high_bits
,
6535 contents
+ rel
->r_offset
+ 4);
6539 /* Actually perform the relocation. */
6540 if (! mips_elf_perform_relocation (info
, howto
, rel
, value
,
6541 input_bfd
, input_section
,
6542 contents
, require_jalx
))
6549 /* If NAME is one of the special IRIX6 symbols defined by the linker,
6550 adjust it appropriately now. */
6553 mips_elf_irix6_finish_dynamic_symbol (abfd
, name
, sym
)
6554 bfd
*abfd ATTRIBUTE_UNUSED
;
6556 Elf_Internal_Sym
*sym
;
6558 /* The linker script takes care of providing names and values for
6559 these, but we must place them into the right sections. */
6560 static const char* const text_section_symbols
[] = {
6563 "__dso_displacement",
6565 "__program_header_table",
6569 static const char* const data_section_symbols
[] = {
6577 const char* const *p
;
6580 for (i
= 0; i
< 2; ++i
)
6581 for (p
= (i
== 0) ? text_section_symbols
: data_section_symbols
;
6584 if (strcmp (*p
, name
) == 0)
6586 /* All of these symbols are given type STT_SECTION by the
6588 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6589 sym
->st_other
= STO_PROTECTED
;
6591 /* The IRIX linker puts these symbols in special sections. */
6593 sym
->st_shndx
= SHN_MIPS_TEXT
;
6595 sym
->st_shndx
= SHN_MIPS_DATA
;
6601 /* Finish up dynamic symbol handling. We set the contents of various
6602 dynamic sections here. */
6605 _bfd_mips_elf_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
6607 struct bfd_link_info
*info
;
6608 struct elf_link_hash_entry
*h
;
6609 Elf_Internal_Sym
*sym
;
6614 struct mips_got_info
*g
, *gg
;
6617 dynobj
= elf_hash_table (info
)->dynobj
;
6618 gval
= sym
->st_value
;
6620 if (h
->plt
.offset
!= (bfd_vma
) -1)
6623 bfd_byte stub
[MIPS_FUNCTION_STUB_SIZE
];
6625 /* This symbol has a stub. Set it up. */
6627 BFD_ASSERT (h
->dynindx
!= -1);
6629 s
= bfd_get_section_by_name (dynobj
,
6630 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
6631 BFD_ASSERT (s
!= NULL
);
6633 /* FIXME: Can h->dynindex be more than 64K? */
6634 if (h
->dynindx
& 0xffff0000)
6637 /* Fill the stub. */
6638 bfd_put_32 (output_bfd
, STUB_LW (output_bfd
), stub
);
6639 bfd_put_32 (output_bfd
, STUB_MOVE (output_bfd
), stub
+ 4);
6640 bfd_put_32 (output_bfd
, STUB_JALR
, stub
+ 8);
6641 bfd_put_32 (output_bfd
, STUB_LI16 (output_bfd
) + h
->dynindx
, stub
+ 12);
6643 BFD_ASSERT (h
->plt
.offset
<= s
->_raw_size
);
6644 memcpy (s
->contents
+ h
->plt
.offset
, stub
, MIPS_FUNCTION_STUB_SIZE
);
6646 /* Mark the symbol as undefined. plt.offset != -1 occurs
6647 only for the referenced symbol. */
6648 sym
->st_shndx
= SHN_UNDEF
;
6650 /* The run-time linker uses the st_value field of the symbol
6651 to reset the global offset table entry for this external
6652 to its stub address when unlinking a shared object. */
6653 gval
= s
->output_section
->vma
+ s
->output_offset
+ h
->plt
.offset
;
6654 sym
->st_value
= gval
;
6657 BFD_ASSERT (h
->dynindx
!= -1
6658 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0);
6660 sgot
= mips_elf_got_section (dynobj
, FALSE
);
6661 BFD_ASSERT (sgot
!= NULL
);
6662 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
6663 g
= mips_elf_section_data (sgot
)->u
.got_info
;
6664 BFD_ASSERT (g
!= NULL
);
6666 /* Run through the global symbol table, creating GOT entries for all
6667 the symbols that need them. */
6668 if (g
->global_gotsym
!= NULL
6669 && h
->dynindx
>= g
->global_gotsym
->dynindx
)
6674 value
= sym
->st_value
;
6675 offset
= mips_elf_global_got_index (dynobj
, output_bfd
, h
);
6676 MIPS_ELF_PUT_WORD (output_bfd
, value
, sgot
->contents
+ offset
);
6679 if (g
->next
&& h
->dynindx
!= -1)
6681 struct mips_got_entry e
, *p
;
6687 e
.abfd
= output_bfd
;
6689 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
6691 for (g
= g
->next
; g
->next
!= gg
; g
= g
->next
)
6694 && (p
= (struct mips_got_entry
*) htab_find (g
->got_entries
,
6699 || (elf_hash_table (info
)->dynamic_sections_created
6701 && ((p
->d
.h
->root
.elf_link_hash_flags
6702 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0)
6703 && ((p
->d
.h
->root
.elf_link_hash_flags
6704 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
6706 /* Create an R_MIPS_REL32 relocation for this entry. Due to
6707 the various compatibility problems, it's easier to mock
6708 up an R_MIPS_32 or R_MIPS_64 relocation and leave
6709 mips_elf_create_dynamic_relocation to calculate the
6710 appropriate addend. */
6711 Elf_Internal_Rela rel
[3];
6713 memset (rel
, 0, sizeof (rel
));
6714 if (ABI_64_P (output_bfd
))
6715 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_64
);
6717 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_32
);
6718 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
6721 if (! (mips_elf_create_dynamic_relocation
6722 (output_bfd
, info
, rel
,
6723 e
.d
.h
, NULL
, sym
->st_value
, &entry
, sgot
)))
6727 entry
= sym
->st_value
;
6728 MIPS_ELF_PUT_WORD (output_bfd
, entry
, sgot
->contents
+ offset
);
6733 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
6734 name
= h
->root
.root
.string
;
6735 if (strcmp (name
, "_DYNAMIC") == 0
6736 || strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
6737 sym
->st_shndx
= SHN_ABS
;
6738 else if (strcmp (name
, "_DYNAMIC_LINK") == 0
6739 || strcmp (name
, "_DYNAMIC_LINKING") == 0)
6741 sym
->st_shndx
= SHN_ABS
;
6742 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6745 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (output_bfd
))
6747 sym
->st_shndx
= SHN_ABS
;
6748 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6749 sym
->st_value
= elf_gp (output_bfd
);
6751 else if (SGI_COMPAT (output_bfd
))
6753 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
6754 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
6756 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6757 sym
->st_other
= STO_PROTECTED
;
6759 sym
->st_shndx
= SHN_MIPS_DATA
;
6761 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
6763 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6764 sym
->st_other
= STO_PROTECTED
;
6765 sym
->st_value
= mips_elf_hash_table (info
)->procedure_count
;
6766 sym
->st_shndx
= SHN_ABS
;
6768 else if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
!= SHN_ABS
)
6770 if (h
->type
== STT_FUNC
)
6771 sym
->st_shndx
= SHN_MIPS_TEXT
;
6772 else if (h
->type
== STT_OBJECT
)
6773 sym
->st_shndx
= SHN_MIPS_DATA
;
6777 /* Handle the IRIX6-specific symbols. */
6778 if (IRIX_COMPAT (output_bfd
) == ict_irix6
)
6779 mips_elf_irix6_finish_dynamic_symbol (output_bfd
, name
, sym
);
6783 if (! mips_elf_hash_table (info
)->use_rld_obj_head
6784 && (strcmp (name
, "__rld_map") == 0
6785 || strcmp (name
, "__RLD_MAP") == 0))
6787 asection
*s
= bfd_get_section_by_name (dynobj
, ".rld_map");
6788 BFD_ASSERT (s
!= NULL
);
6789 sym
->st_value
= s
->output_section
->vma
+ s
->output_offset
;
6790 bfd_put_32 (output_bfd
, (bfd_vma
) 0, s
->contents
);
6791 if (mips_elf_hash_table (info
)->rld_value
== 0)
6792 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
6794 else if (mips_elf_hash_table (info
)->use_rld_obj_head
6795 && strcmp (name
, "__rld_obj_head") == 0)
6797 /* IRIX6 does not use a .rld_map section. */
6798 if (IRIX_COMPAT (output_bfd
) == ict_irix5
6799 || IRIX_COMPAT (output_bfd
) == ict_none
)
6800 BFD_ASSERT (bfd_get_section_by_name (dynobj
, ".rld_map")
6802 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
6806 /* If this is a mips16 symbol, force the value to be even. */
6807 if (sym
->st_other
== STO_MIPS16
6808 && (sym
->st_value
& 1) != 0)
6814 /* Finish up the dynamic sections. */
6817 _bfd_mips_elf_finish_dynamic_sections (output_bfd
, info
)
6819 struct bfd_link_info
*info
;
6824 struct mips_got_info
*gg
, *g
;
6826 dynobj
= elf_hash_table (info
)->dynobj
;
6828 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
6830 sgot
= mips_elf_got_section (dynobj
, FALSE
);
6835 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
6836 gg
= mips_elf_section_data (sgot
)->u
.got_info
;
6837 BFD_ASSERT (gg
!= NULL
);
6838 g
= mips_elf_got_for_ibfd (gg
, output_bfd
);
6839 BFD_ASSERT (g
!= NULL
);
6842 if (elf_hash_table (info
)->dynamic_sections_created
)
6846 BFD_ASSERT (sdyn
!= NULL
);
6847 BFD_ASSERT (g
!= NULL
);
6849 for (b
= sdyn
->contents
;
6850 b
< sdyn
->contents
+ sdyn
->_raw_size
;
6851 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
6853 Elf_Internal_Dyn dyn
;
6857 bfd_boolean swap_out_p
;
6859 /* Read in the current dynamic entry. */
6860 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
6862 /* Assume that we're going to modify it and write it out. */
6868 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
6869 BFD_ASSERT (s
!= NULL
);
6870 dyn
.d_un
.d_val
= MIPS_ELF_REL_SIZE (dynobj
);
6874 /* Rewrite DT_STRSZ. */
6876 _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
6881 s
= bfd_get_section_by_name (output_bfd
, name
);
6882 BFD_ASSERT (s
!= NULL
);
6883 dyn
.d_un
.d_ptr
= s
->vma
;
6886 case DT_MIPS_RLD_VERSION
:
6887 dyn
.d_un
.d_val
= 1; /* XXX */
6891 dyn
.d_un
.d_val
= RHF_NOTPOT
; /* XXX */
6894 case DT_MIPS_TIME_STAMP
:
6895 time ((time_t *) &dyn
.d_un
.d_val
);
6898 case DT_MIPS_ICHECKSUM
:
6903 case DT_MIPS_IVERSION
:
6908 case DT_MIPS_BASE_ADDRESS
:
6909 s
= output_bfd
->sections
;
6910 BFD_ASSERT (s
!= NULL
);
6911 dyn
.d_un
.d_ptr
= s
->vma
& ~(bfd_vma
) 0xffff;
6914 case DT_MIPS_LOCAL_GOTNO
:
6915 dyn
.d_un
.d_val
= g
->local_gotno
;
6918 case DT_MIPS_UNREFEXTNO
:
6919 /* The index into the dynamic symbol table which is the
6920 entry of the first external symbol that is not
6921 referenced within the same object. */
6922 dyn
.d_un
.d_val
= bfd_count_sections (output_bfd
) + 1;
6925 case DT_MIPS_GOTSYM
:
6926 if (gg
->global_gotsym
)
6928 dyn
.d_un
.d_val
= gg
->global_gotsym
->dynindx
;
6931 /* In case if we don't have global got symbols we default
6932 to setting DT_MIPS_GOTSYM to the same value as
6933 DT_MIPS_SYMTABNO, so we just fall through. */
6935 case DT_MIPS_SYMTABNO
:
6937 elemsize
= MIPS_ELF_SYM_SIZE (output_bfd
);
6938 s
= bfd_get_section_by_name (output_bfd
, name
);
6939 BFD_ASSERT (s
!= NULL
);
6941 if (s
->_cooked_size
!= 0)
6942 dyn
.d_un
.d_val
= s
->_cooked_size
/ elemsize
;
6944 dyn
.d_un
.d_val
= s
->_raw_size
/ elemsize
;
6947 case DT_MIPS_HIPAGENO
:
6948 dyn
.d_un
.d_val
= g
->local_gotno
- MIPS_RESERVED_GOTNO
;
6951 case DT_MIPS_RLD_MAP
:
6952 dyn
.d_un
.d_ptr
= mips_elf_hash_table (info
)->rld_value
;
6955 case DT_MIPS_OPTIONS
:
6956 s
= (bfd_get_section_by_name
6957 (output_bfd
, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd
)));
6958 dyn
.d_un
.d_ptr
= s
->vma
;
6962 /* Reduce DT_RELSZ to account for any relocations we
6963 decided not to make. This is for the n64 irix rld,
6964 which doesn't seem to apply any relocations if there
6965 are trailing null entries. */
6966 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
6967 dyn
.d_un
.d_val
= (s
->reloc_count
6968 * (ABI_64_P (output_bfd
)
6969 ? sizeof (Elf64_Mips_External_Rel
)
6970 : sizeof (Elf32_External_Rel
)));
6979 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
6984 /* The first entry of the global offset table will be filled at
6985 runtime. The second entry will be used by some runtime loaders.
6986 This isn't the case of IRIX rld. */
6987 if (sgot
!= NULL
&& sgot
->_raw_size
> 0)
6989 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
6990 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0x80000000,
6991 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
6995 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
6996 = MIPS_ELF_GOT_SIZE (output_bfd
);
6998 /* Generate dynamic relocations for the non-primary gots. */
6999 if (gg
!= NULL
&& gg
->next
)
7001 Elf_Internal_Rela rel
[3];
7004 memset (rel
, 0, sizeof (rel
));
7005 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_REL32
);
7007 for (g
= gg
->next
; g
->next
!= gg
; g
= g
->next
)
7009 bfd_vma index
= g
->next
->local_gotno
+ g
->next
->global_gotno
;
7011 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0, sgot
->contents
7012 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
7013 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0x80000000, sgot
->contents
7014 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
7019 while (index
< g
->assigned_gotno
)
7021 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
7022 = index
++ * MIPS_ELF_GOT_SIZE (output_bfd
);
7023 if (!(mips_elf_create_dynamic_relocation
7024 (output_bfd
, info
, rel
, NULL
,
7025 bfd_abs_section_ptr
,
7028 BFD_ASSERT (addend
== 0);
7035 Elf32_compact_rel cpt
;
7037 if (SGI_COMPAT (output_bfd
))
7039 /* Write .compact_rel section out. */
7040 s
= bfd_get_section_by_name (dynobj
, ".compact_rel");
7044 cpt
.num
= s
->reloc_count
;
7046 cpt
.offset
= (s
->output_section
->filepos
7047 + sizeof (Elf32_External_compact_rel
));
7050 bfd_elf32_swap_compact_rel_out (output_bfd
, &cpt
,
7051 ((Elf32_External_compact_rel
*)
7054 /* Clean up a dummy stub function entry in .text. */
7055 s
= bfd_get_section_by_name (dynobj
,
7056 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
7059 file_ptr dummy_offset
;
7061 BFD_ASSERT (s
->_raw_size
>= MIPS_FUNCTION_STUB_SIZE
);
7062 dummy_offset
= s
->_raw_size
- MIPS_FUNCTION_STUB_SIZE
;
7063 memset (s
->contents
+ dummy_offset
, 0,
7064 MIPS_FUNCTION_STUB_SIZE
);
7069 /* We need to sort the entries of the dynamic relocation section. */
7071 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
7074 && s
->_raw_size
> (bfd_vma
)2 * MIPS_ELF_REL_SIZE (output_bfd
))
7076 reldyn_sorting_bfd
= output_bfd
;
7078 if (ABI_64_P (output_bfd
))
7079 qsort ((Elf64_External_Rel
*) s
->contents
+ 1,
7080 (size_t) s
->reloc_count
- 1,
7081 sizeof (Elf64_Mips_External_Rel
), sort_dynamic_relocs_64
);
7083 qsort ((Elf32_External_Rel
*) s
->contents
+ 1,
7084 (size_t) s
->reloc_count
- 1,
7085 sizeof (Elf32_External_Rel
), sort_dynamic_relocs
);
7093 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
7096 mips_set_isa_flags (abfd
)
7101 switch (bfd_get_mach (abfd
))
7104 case bfd_mach_mips3000
:
7105 val
= E_MIPS_ARCH_1
;
7108 case bfd_mach_mips3900
:
7109 val
= E_MIPS_ARCH_1
| E_MIPS_MACH_3900
;
7112 case bfd_mach_mips6000
:
7113 val
= E_MIPS_ARCH_2
;
7116 case bfd_mach_mips4000
:
7117 case bfd_mach_mips4300
:
7118 case bfd_mach_mips4400
:
7119 case bfd_mach_mips4600
:
7120 val
= E_MIPS_ARCH_3
;
7123 case bfd_mach_mips4010
:
7124 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4010
;
7127 case bfd_mach_mips4100
:
7128 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4100
;
7131 case bfd_mach_mips4111
:
7132 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4111
;
7135 case bfd_mach_mips4120
:
7136 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4120
;
7139 case bfd_mach_mips4650
:
7140 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4650
;
7143 case bfd_mach_mips5400
:
7144 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5400
;
7147 case bfd_mach_mips5500
:
7148 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5500
;
7151 case bfd_mach_mips5000
:
7152 case bfd_mach_mips7000
:
7153 case bfd_mach_mips8000
:
7154 case bfd_mach_mips10000
:
7155 case bfd_mach_mips12000
:
7156 val
= E_MIPS_ARCH_4
;
7159 case bfd_mach_mips5
:
7160 val
= E_MIPS_ARCH_5
;
7163 case bfd_mach_mips_sb1
:
7164 val
= E_MIPS_ARCH_64
| E_MIPS_MACH_SB1
;
7167 case bfd_mach_mipsisa32
:
7168 val
= E_MIPS_ARCH_32
;
7171 case bfd_mach_mipsisa64
:
7172 val
= E_MIPS_ARCH_64
;
7175 case bfd_mach_mipsisa32r2
:
7176 val
= E_MIPS_ARCH_32R2
;
7179 case bfd_mach_mipsisa64r2
:
7180 val
= E_MIPS_ARCH_64R2
;
7183 elf_elfheader (abfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
7184 elf_elfheader (abfd
)->e_flags
|= val
;
7189 /* The final processing done just before writing out a MIPS ELF object
7190 file. This gets the MIPS architecture right based on the machine
7191 number. This is used by both the 32-bit and the 64-bit ABI. */
7194 _bfd_mips_elf_final_write_processing (abfd
, linker
)
7196 bfd_boolean linker ATTRIBUTE_UNUSED
;
7199 Elf_Internal_Shdr
**hdrpp
;
7203 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
7204 is nonzero. This is for compatibility with old objects, which used
7205 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
7206 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_MACH
) == 0)
7207 mips_set_isa_flags (abfd
);
7209 /* Set the sh_info field for .gptab sections and other appropriate
7210 info for each special section. */
7211 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
7212 i
< elf_numsections (abfd
);
7215 switch ((*hdrpp
)->sh_type
)
7218 case SHT_MIPS_LIBLIST
:
7219 sec
= bfd_get_section_by_name (abfd
, ".dynstr");
7221 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7224 case SHT_MIPS_GPTAB
:
7225 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7226 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7227 BFD_ASSERT (name
!= NULL
7228 && strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0);
7229 sec
= bfd_get_section_by_name (abfd
, name
+ sizeof ".gptab" - 1);
7230 BFD_ASSERT (sec
!= NULL
);
7231 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
7234 case SHT_MIPS_CONTENT
:
7235 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7236 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7237 BFD_ASSERT (name
!= NULL
7238 && strncmp (name
, ".MIPS.content",
7239 sizeof ".MIPS.content" - 1) == 0);
7240 sec
= bfd_get_section_by_name (abfd
,
7241 name
+ sizeof ".MIPS.content" - 1);
7242 BFD_ASSERT (sec
!= NULL
);
7243 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7246 case SHT_MIPS_SYMBOL_LIB
:
7247 sec
= bfd_get_section_by_name (abfd
, ".dynsym");
7249 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7250 sec
= bfd_get_section_by_name (abfd
, ".liblist");
7252 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
7255 case SHT_MIPS_EVENTS
:
7256 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7257 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7258 BFD_ASSERT (name
!= NULL
);
7259 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0)
7260 sec
= bfd_get_section_by_name (abfd
,
7261 name
+ sizeof ".MIPS.events" - 1);
7264 BFD_ASSERT (strncmp (name
, ".MIPS.post_rel",
7265 sizeof ".MIPS.post_rel" - 1) == 0);
7266 sec
= bfd_get_section_by_name (abfd
,
7268 + sizeof ".MIPS.post_rel" - 1));
7270 BFD_ASSERT (sec
!= NULL
);
7271 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7278 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
7282 _bfd_mips_elf_additional_program_headers (abfd
)
7288 /* See if we need a PT_MIPS_REGINFO segment. */
7289 s
= bfd_get_section_by_name (abfd
, ".reginfo");
7290 if (s
&& (s
->flags
& SEC_LOAD
))
7293 /* See if we need a PT_MIPS_OPTIONS segment. */
7294 if (IRIX_COMPAT (abfd
) == ict_irix6
7295 && bfd_get_section_by_name (abfd
,
7296 MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)))
7299 /* See if we need a PT_MIPS_RTPROC segment. */
7300 if (IRIX_COMPAT (abfd
) == ict_irix5
7301 && bfd_get_section_by_name (abfd
, ".dynamic")
7302 && bfd_get_section_by_name (abfd
, ".mdebug"))
7308 /* Modify the segment map for an IRIX5 executable. */
7311 _bfd_mips_elf_modify_segment_map (abfd
)
7315 struct elf_segment_map
*m
, **pm
;
7318 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
7320 s
= bfd_get_section_by_name (abfd
, ".reginfo");
7321 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
7323 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
7324 if (m
->p_type
== PT_MIPS_REGINFO
)
7329 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
7333 m
->p_type
= PT_MIPS_REGINFO
;
7337 /* We want to put it after the PHDR and INTERP segments. */
7338 pm
= &elf_tdata (abfd
)->segment_map
;
7340 && ((*pm
)->p_type
== PT_PHDR
7341 || (*pm
)->p_type
== PT_INTERP
))
7349 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
7350 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
7351 PT_MIPS_OPTIONS segment immediately following the program header
7354 /* On non-IRIX6 new abi, we'll have already created a segment
7355 for this section, so don't create another. I'm not sure this
7356 is not also the case for IRIX 6, but I can't test it right
7358 && IRIX_COMPAT (abfd
) == ict_irix6
)
7360 for (s
= abfd
->sections
; s
; s
= s
->next
)
7361 if (elf_section_data (s
)->this_hdr
.sh_type
== SHT_MIPS_OPTIONS
)
7366 struct elf_segment_map
*options_segment
;
7368 pm
= &elf_tdata (abfd
)->segment_map
;
7370 && ((*pm
)->p_type
== PT_PHDR
7371 || (*pm
)->p_type
== PT_INTERP
))
7374 amt
= sizeof (struct elf_segment_map
);
7375 options_segment
= bfd_zalloc (abfd
, amt
);
7376 options_segment
->next
= *pm
;
7377 options_segment
->p_type
= PT_MIPS_OPTIONS
;
7378 options_segment
->p_flags
= PF_R
;
7379 options_segment
->p_flags_valid
= TRUE
;
7380 options_segment
->count
= 1;
7381 options_segment
->sections
[0] = s
;
7382 *pm
= options_segment
;
7387 if (IRIX_COMPAT (abfd
) == ict_irix5
)
7389 /* If there are .dynamic and .mdebug sections, we make a room
7390 for the RTPROC header. FIXME: Rewrite without section names. */
7391 if (bfd_get_section_by_name (abfd
, ".interp") == NULL
7392 && bfd_get_section_by_name (abfd
, ".dynamic") != NULL
7393 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
7395 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
7396 if (m
->p_type
== PT_MIPS_RTPROC
)
7401 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
7405 m
->p_type
= PT_MIPS_RTPROC
;
7407 s
= bfd_get_section_by_name (abfd
, ".rtproc");
7412 m
->p_flags_valid
= 1;
7420 /* We want to put it after the DYNAMIC segment. */
7421 pm
= &elf_tdata (abfd
)->segment_map
;
7422 while (*pm
!= NULL
&& (*pm
)->p_type
!= PT_DYNAMIC
)
7432 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
7433 .dynstr, .dynsym, and .hash sections, and everything in
7435 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
;
7437 if ((*pm
)->p_type
== PT_DYNAMIC
)
7440 if (m
!= NULL
&& IRIX_COMPAT (abfd
) == ict_none
)
7442 /* For a normal mips executable the permissions for the PT_DYNAMIC
7443 segment are read, write and execute. We do that here since
7444 the code in elf.c sets only the read permission. This matters
7445 sometimes for the dynamic linker. */
7446 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
7448 m
->p_flags
= PF_R
| PF_W
| PF_X
;
7449 m
->p_flags_valid
= 1;
7453 && m
->count
== 1 && strcmp (m
->sections
[0]->name
, ".dynamic") == 0)
7455 static const char *sec_names
[] =
7457 ".dynamic", ".dynstr", ".dynsym", ".hash"
7461 struct elf_segment_map
*n
;
7465 for (i
= 0; i
< sizeof sec_names
/ sizeof sec_names
[0]; i
++)
7467 s
= bfd_get_section_by_name (abfd
, sec_names
[i
]);
7468 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
7474 sz
= s
->_cooked_size
;
7477 if (high
< s
->vma
+ sz
)
7483 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
7484 if ((s
->flags
& SEC_LOAD
) != 0
7487 + (s
->_cooked_size
!=
7488 0 ? s
->_cooked_size
: s
->_raw_size
)) <= high
))
7491 amt
= sizeof *n
+ (bfd_size_type
) (c
- 1) * sizeof (asection
*);
7492 n
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
7499 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
7501 if ((s
->flags
& SEC_LOAD
) != 0
7504 + (s
->_cooked_size
!= 0 ?
7505 s
->_cooked_size
: s
->_raw_size
)) <= high
))
7519 /* Return the section that should be marked against GC for a given
7523 _bfd_mips_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
)
7525 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
7526 Elf_Internal_Rela
*rel
;
7527 struct elf_link_hash_entry
*h
;
7528 Elf_Internal_Sym
*sym
;
7530 /* ??? Do mips16 stub sections need to be handled special? */
7534 switch (ELF_R_TYPE (sec
->owner
, rel
->r_info
))
7536 case R_MIPS_GNU_VTINHERIT
:
7537 case R_MIPS_GNU_VTENTRY
:
7541 switch (h
->root
.type
)
7543 case bfd_link_hash_defined
:
7544 case bfd_link_hash_defweak
:
7545 return h
->root
.u
.def
.section
;
7547 case bfd_link_hash_common
:
7548 return h
->root
.u
.c
.p
->section
;
7556 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
7561 /* Update the got entry reference counts for the section being removed. */
7564 _bfd_mips_elf_gc_sweep_hook (abfd
, info
, sec
, relocs
)
7565 bfd
*abfd ATTRIBUTE_UNUSED
;
7566 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
7567 asection
*sec ATTRIBUTE_UNUSED
;
7568 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
;
7571 Elf_Internal_Shdr
*symtab_hdr
;
7572 struct elf_link_hash_entry
**sym_hashes
;
7573 bfd_signed_vma
*local_got_refcounts
;
7574 const Elf_Internal_Rela
*rel
, *relend
;
7575 unsigned long r_symndx
;
7576 struct elf_link_hash_entry
*h
;
7578 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7579 sym_hashes
= elf_sym_hashes (abfd
);
7580 local_got_refcounts
= elf_local_got_refcounts (abfd
);
7582 relend
= relocs
+ sec
->reloc_count
;
7583 for (rel
= relocs
; rel
< relend
; rel
++)
7584 switch (ELF_R_TYPE (abfd
, rel
->r_info
))
7588 case R_MIPS_CALL_HI16
:
7589 case R_MIPS_CALL_LO16
:
7590 case R_MIPS_GOT_HI16
:
7591 case R_MIPS_GOT_LO16
:
7592 case R_MIPS_GOT_DISP
:
7593 case R_MIPS_GOT_PAGE
:
7594 case R_MIPS_GOT_OFST
:
7595 /* ??? It would seem that the existing MIPS code does no sort
7596 of reference counting or whatnot on its GOT and PLT entries,
7597 so it is not possible to garbage collect them at this time. */
7608 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
7609 hiding the old indirect symbol. Process additional relocation
7610 information. Also called for weakdefs, in which case we just let
7611 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
7614 _bfd_mips_elf_copy_indirect_symbol (bed
, dir
, ind
)
7615 const struct elf_backend_data
*bed
;
7616 struct elf_link_hash_entry
*dir
, *ind
;
7618 struct mips_elf_link_hash_entry
*dirmips
, *indmips
;
7620 _bfd_elf_link_hash_copy_indirect (bed
, dir
, ind
);
7622 if (ind
->root
.type
!= bfd_link_hash_indirect
)
7625 dirmips
= (struct mips_elf_link_hash_entry
*) dir
;
7626 indmips
= (struct mips_elf_link_hash_entry
*) ind
;
7627 dirmips
->possibly_dynamic_relocs
+= indmips
->possibly_dynamic_relocs
;
7628 if (indmips
->readonly_reloc
)
7629 dirmips
->readonly_reloc
= TRUE
;
7630 if (indmips
->no_fn_stub
)
7631 dirmips
->no_fn_stub
= TRUE
;
7635 _bfd_mips_elf_hide_symbol (info
, entry
, force_local
)
7636 struct bfd_link_info
*info
;
7637 struct elf_link_hash_entry
*entry
;
7638 bfd_boolean force_local
;
7642 struct mips_got_info
*g
;
7643 struct mips_elf_link_hash_entry
*h
;
7645 h
= (struct mips_elf_link_hash_entry
*) entry
;
7646 if (h
->forced_local
)
7648 h
->forced_local
= force_local
;
7650 dynobj
= elf_hash_table (info
)->dynobj
;
7651 if (dynobj
!= NULL
&& force_local
)
7653 got
= mips_elf_got_section (dynobj
, FALSE
);
7654 g
= mips_elf_section_data (got
)->u
.got_info
;
7658 struct mips_got_entry e
;
7659 struct mips_got_info
*gg
= g
;
7661 /* Since we're turning what used to be a global symbol into a
7662 local one, bump up the number of local entries of each GOT
7663 that had an entry for it. This will automatically decrease
7664 the number of global entries, since global_gotno is actually
7665 the upper limit of global entries. */
7670 for (g
= g
->next
; g
!= gg
; g
= g
->next
)
7671 if (htab_find (g
->got_entries
, &e
))
7673 BFD_ASSERT (g
->global_gotno
> 0);
7678 /* If this was a global symbol forced into the primary GOT, we
7679 no longer need an entry for it. We can't release the entry
7680 at this point, but we must at least stop counting it as one
7681 of the symbols that required a forced got entry. */
7682 if (h
->root
.got
.offset
== 2)
7684 BFD_ASSERT (gg
->assigned_gotno
> 0);
7685 gg
->assigned_gotno
--;
7688 else if (g
->global_gotno
== 0 && g
->global_gotsym
== NULL
)
7689 /* If we haven't got through GOT allocation yet, just bump up the
7690 number of local entries, as this symbol won't be counted as
7693 else if (h
->root
.got
.offset
== 1)
7695 /* If we're past non-multi-GOT allocation and this symbol had
7696 been marked for a global got entry, give it a local entry
7698 BFD_ASSERT (g
->global_gotno
> 0);
7704 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
7710 _bfd_mips_elf_discard_info (abfd
, cookie
, info
)
7712 struct elf_reloc_cookie
*cookie
;
7713 struct bfd_link_info
*info
;
7716 bfd_boolean ret
= FALSE
;
7717 unsigned char *tdata
;
7720 o
= bfd_get_section_by_name (abfd
, ".pdr");
7723 if (o
->_raw_size
== 0)
7725 if (o
->_raw_size
% PDR_SIZE
!= 0)
7727 if (o
->output_section
!= NULL
7728 && bfd_is_abs_section (o
->output_section
))
7731 tdata
= bfd_zmalloc (o
->_raw_size
/ PDR_SIZE
);
7735 cookie
->rels
= _bfd_elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
7736 (Elf_Internal_Rela
*) NULL
,
7744 cookie
->rel
= cookie
->rels
;
7745 cookie
->relend
= cookie
->rels
+ o
->reloc_count
;
7747 for (i
= 0, skip
= 0; i
< o
->_raw_size
/ PDR_SIZE
; i
++)
7749 if (MNAME(abfd
,_bfd_elf
,reloc_symbol_deleted_p
) (i
* PDR_SIZE
, cookie
))
7758 mips_elf_section_data (o
)->u
.tdata
= tdata
;
7759 o
->_cooked_size
= o
->_raw_size
- skip
* PDR_SIZE
;
7765 if (! info
->keep_memory
)
7766 free (cookie
->rels
);
7772 _bfd_mips_elf_ignore_discarded_relocs (sec
)
7775 if (strcmp (sec
->name
, ".pdr") == 0)
7781 _bfd_mips_elf_write_section (output_bfd
, sec
, contents
)
7786 bfd_byte
*to
, *from
, *end
;
7789 if (strcmp (sec
->name
, ".pdr") != 0)
7792 if (mips_elf_section_data (sec
)->u
.tdata
== NULL
)
7796 end
= contents
+ sec
->_raw_size
;
7797 for (from
= contents
, i
= 0;
7799 from
+= PDR_SIZE
, i
++)
7801 if ((mips_elf_section_data (sec
)->u
.tdata
)[i
] == 1)
7804 memcpy (to
, from
, PDR_SIZE
);
7807 bfd_set_section_contents (output_bfd
, sec
->output_section
, contents
,
7808 (file_ptr
) sec
->output_offset
,
7813 /* MIPS ELF uses a special find_nearest_line routine in order the
7814 handle the ECOFF debugging information. */
7816 struct mips_elf_find_line
7818 struct ecoff_debug_info d
;
7819 struct ecoff_find_line i
;
7823 _bfd_mips_elf_find_nearest_line (abfd
, section
, symbols
, offset
, filename_ptr
,
7824 functionname_ptr
, line_ptr
)
7829 const char **filename_ptr
;
7830 const char **functionname_ptr
;
7831 unsigned int *line_ptr
;
7835 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
7836 filename_ptr
, functionname_ptr
,
7840 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
7841 filename_ptr
, functionname_ptr
,
7843 (unsigned) (ABI_64_P (abfd
) ? 8 : 0),
7844 &elf_tdata (abfd
)->dwarf2_find_line_info
))
7847 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
7851 struct mips_elf_find_line
*fi
;
7852 const struct ecoff_debug_swap
* const swap
=
7853 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
7855 /* If we are called during a link, mips_elf_final_link may have
7856 cleared the SEC_HAS_CONTENTS field. We force it back on here
7857 if appropriate (which it normally will be). */
7858 origflags
= msec
->flags
;
7859 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
7860 msec
->flags
|= SEC_HAS_CONTENTS
;
7862 fi
= elf_tdata (abfd
)->find_line_info
;
7865 bfd_size_type external_fdr_size
;
7868 struct fdr
*fdr_ptr
;
7869 bfd_size_type amt
= sizeof (struct mips_elf_find_line
);
7871 fi
= (struct mips_elf_find_line
*) bfd_zalloc (abfd
, amt
);
7874 msec
->flags
= origflags
;
7878 if (! _bfd_mips_elf_read_ecoff_info (abfd
, msec
, &fi
->d
))
7880 msec
->flags
= origflags
;
7884 /* Swap in the FDR information. */
7885 amt
= fi
->d
.symbolic_header
.ifdMax
* sizeof (struct fdr
);
7886 fi
->d
.fdr
= (struct fdr
*) bfd_alloc (abfd
, amt
);
7887 if (fi
->d
.fdr
== NULL
)
7889 msec
->flags
= origflags
;
7892 external_fdr_size
= swap
->external_fdr_size
;
7893 fdr_ptr
= fi
->d
.fdr
;
7894 fraw_src
= (char *) fi
->d
.external_fdr
;
7895 fraw_end
= (fraw_src
7896 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
7897 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
7898 (*swap
->swap_fdr_in
) (abfd
, (PTR
) fraw_src
, fdr_ptr
);
7900 elf_tdata (abfd
)->find_line_info
= fi
;
7902 /* Note that we don't bother to ever free this information.
7903 find_nearest_line is either called all the time, as in
7904 objdump -l, so the information should be saved, or it is
7905 rarely called, as in ld error messages, so the memory
7906 wasted is unimportant. Still, it would probably be a
7907 good idea for free_cached_info to throw it away. */
7910 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
7911 &fi
->i
, filename_ptr
, functionname_ptr
,
7914 msec
->flags
= origflags
;
7918 msec
->flags
= origflags
;
7921 /* Fall back on the generic ELF find_nearest_line routine. */
7923 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
7924 filename_ptr
, functionname_ptr
,
7928 /* When are writing out the .options or .MIPS.options section,
7929 remember the bytes we are writing out, so that we can install the
7930 GP value in the section_processing routine. */
7933 _bfd_mips_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
7938 bfd_size_type count
;
7940 if (strcmp (section
->name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
7944 if (elf_section_data (section
) == NULL
)
7946 bfd_size_type amt
= sizeof (struct bfd_elf_section_data
);
7947 section
->used_by_bfd
= (PTR
) bfd_zalloc (abfd
, amt
);
7948 if (elf_section_data (section
) == NULL
)
7951 c
= mips_elf_section_data (section
)->u
.tdata
;
7956 if (section
->_cooked_size
!= 0)
7957 size
= section
->_cooked_size
;
7959 size
= section
->_raw_size
;
7960 c
= (bfd_byte
*) bfd_zalloc (abfd
, size
);
7963 mips_elf_section_data (section
)->u
.tdata
= c
;
7966 memcpy (c
+ offset
, location
, (size_t) count
);
7969 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
,
7973 /* This is almost identical to bfd_generic_get_... except that some
7974 MIPS relocations need to be handled specially. Sigh. */
7977 _bfd_elf_mips_get_relocated_section_contents (abfd
, link_info
, link_order
,
7978 data
, relocatable
, symbols
)
7980 struct bfd_link_info
*link_info
;
7981 struct bfd_link_order
*link_order
;
7983 bfd_boolean relocatable
;
7986 /* Get enough memory to hold the stuff */
7987 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
7988 asection
*input_section
= link_order
->u
.indirect
.section
;
7990 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
7991 arelent
**reloc_vector
= NULL
;
7997 reloc_vector
= (arelent
**) bfd_malloc ((bfd_size_type
) reloc_size
);
7998 if (reloc_vector
== NULL
&& reloc_size
!= 0)
8001 /* read in the section */
8002 if (!bfd_get_section_contents (input_bfd
,
8006 input_section
->_raw_size
))
8009 /* We're not relaxing the section, so just copy the size info */
8010 input_section
->_cooked_size
= input_section
->_raw_size
;
8011 input_section
->reloc_done
= TRUE
;
8013 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
8017 if (reloc_count
< 0)
8020 if (reloc_count
> 0)
8025 bfd_vma gp
= 0x12345678; /* initialize just to shut gcc up */
8028 struct bfd_hash_entry
*h
;
8029 struct bfd_link_hash_entry
*lh
;
8030 /* Skip all this stuff if we aren't mixing formats. */
8031 if (abfd
&& input_bfd
8032 && abfd
->xvec
== input_bfd
->xvec
)
8036 h
= bfd_hash_lookup (&link_info
->hash
->table
, "_gp", FALSE
, FALSE
);
8037 lh
= (struct bfd_link_hash_entry
*) h
;
8044 case bfd_link_hash_undefined
:
8045 case bfd_link_hash_undefweak
:
8046 case bfd_link_hash_common
:
8049 case bfd_link_hash_defined
:
8050 case bfd_link_hash_defweak
:
8052 gp
= lh
->u
.def
.value
;
8054 case bfd_link_hash_indirect
:
8055 case bfd_link_hash_warning
:
8057 /* @@FIXME ignoring warning for now */
8059 case bfd_link_hash_new
:
8068 for (parent
= reloc_vector
; *parent
!= (arelent
*) NULL
;
8071 char *error_message
= (char *) NULL
;
8072 bfd_reloc_status_type r
;
8074 /* Specific to MIPS: Deal with relocation types that require
8075 knowing the gp of the output bfd. */
8076 asymbol
*sym
= *(*parent
)->sym_ptr_ptr
;
8077 if (bfd_is_abs_section (sym
->section
) && abfd
)
8079 /* The special_function wouldn't get called anyway. */
8083 /* The gp isn't there; let the special function code
8084 fall over on its own. */
8086 else if ((*parent
)->howto
->special_function
8087 == _bfd_mips_elf32_gprel16_reloc
)
8089 /* bypass special_function call */
8090 r
= _bfd_mips_elf_gprel16_with_gp (input_bfd
, sym
, *parent
,
8091 input_section
, relocatable
,
8093 goto skip_bfd_perform_relocation
;
8095 /* end mips specific stuff */
8097 r
= bfd_perform_relocation (input_bfd
,
8101 relocatable
? abfd
: (bfd
*) NULL
,
8103 skip_bfd_perform_relocation
:
8107 asection
*os
= input_section
->output_section
;
8109 /* A partial link, so keep the relocs */
8110 os
->orelocation
[os
->reloc_count
] = *parent
;
8114 if (r
!= bfd_reloc_ok
)
8118 case bfd_reloc_undefined
:
8119 if (!((*link_info
->callbacks
->undefined_symbol
)
8120 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
8121 input_bfd
, input_section
, (*parent
)->address
,
8125 case bfd_reloc_dangerous
:
8126 BFD_ASSERT (error_message
!= (char *) NULL
);
8127 if (!((*link_info
->callbacks
->reloc_dangerous
)
8128 (link_info
, error_message
, input_bfd
, input_section
,
8129 (*parent
)->address
)))
8132 case bfd_reloc_overflow
:
8133 if (!((*link_info
->callbacks
->reloc_overflow
)
8134 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
8135 (*parent
)->howto
->name
, (*parent
)->addend
,
8136 input_bfd
, input_section
, (*parent
)->address
)))
8139 case bfd_reloc_outofrange
:
8148 if (reloc_vector
!= NULL
)
8149 free (reloc_vector
);
8153 if (reloc_vector
!= NULL
)
8154 free (reloc_vector
);
8158 /* Create a MIPS ELF linker hash table. */
8160 struct bfd_link_hash_table
*
8161 _bfd_mips_elf_link_hash_table_create (abfd
)
8164 struct mips_elf_link_hash_table
*ret
;
8165 bfd_size_type amt
= sizeof (struct mips_elf_link_hash_table
);
8167 ret
= (struct mips_elf_link_hash_table
*) bfd_malloc (amt
);
8168 if (ret
== (struct mips_elf_link_hash_table
*) NULL
)
8171 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
8172 mips_elf_link_hash_newfunc
))
8179 /* We no longer use this. */
8180 for (i
= 0; i
< SIZEOF_MIPS_DYNSYM_SECNAMES
; i
++)
8181 ret
->dynsym_sec_strindex
[i
] = (bfd_size_type
) -1;
8183 ret
->procedure_count
= 0;
8184 ret
->compact_rel_size
= 0;
8185 ret
->use_rld_obj_head
= FALSE
;
8187 ret
->mips16_stubs_seen
= FALSE
;
8189 return &ret
->root
.root
;
8192 /* We need to use a special link routine to handle the .reginfo and
8193 the .mdebug sections. We need to merge all instances of these
8194 sections together, not write them all out sequentially. */
8197 _bfd_mips_elf_final_link (abfd
, info
)
8199 struct bfd_link_info
*info
;
8203 struct bfd_link_order
*p
;
8204 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
8205 asection
*rtproc_sec
;
8206 Elf32_RegInfo reginfo
;
8207 struct ecoff_debug_info debug
;
8208 const struct ecoff_debug_swap
*swap
8209 = get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
8210 HDRR
*symhdr
= &debug
.symbolic_header
;
8211 PTR mdebug_handle
= NULL
;
8217 static const char * const secname
[] =
8219 ".text", ".init", ".fini", ".data",
8220 ".rodata", ".sdata", ".sbss", ".bss"
8222 static const int sc
[] =
8224 scText
, scInit
, scFini
, scData
,
8225 scRData
, scSData
, scSBss
, scBss
8228 /* We'd carefully arranged the dynamic symbol indices, and then the
8229 generic size_dynamic_sections renumbered them out from under us.
8230 Rather than trying somehow to prevent the renumbering, just do
8232 if (elf_hash_table (info
)->dynamic_sections_created
)
8236 struct mips_got_info
*g
;
8238 /* When we resort, we must tell mips_elf_sort_hash_table what
8239 the lowest index it may use is. That's the number of section
8240 symbols we're going to add. The generic ELF linker only
8241 adds these symbols when building a shared object. Note that
8242 we count the sections after (possibly) removing the .options
8244 if (! mips_elf_sort_hash_table (info
, (info
->shared
8245 ? bfd_count_sections (abfd
) + 1
8249 /* Make sure we didn't grow the global .got region. */
8250 dynobj
= elf_hash_table (info
)->dynobj
;
8251 got
= mips_elf_got_section (dynobj
, FALSE
);
8252 g
= mips_elf_section_data (got
)->u
.got_info
;
8254 if (g
->global_gotsym
!= NULL
)
8255 BFD_ASSERT ((elf_hash_table (info
)->dynsymcount
8256 - g
->global_gotsym
->dynindx
)
8257 <= g
->global_gotno
);
8261 /* We want to set the GP value for ld -r. */
8262 /* On IRIX5, we omit the .options section. On IRIX6, however, we
8263 include it, even though we don't process it quite right. (Some
8264 entries are supposed to be merged.) Empirically, we seem to be
8265 better off including it then not. */
8266 if (IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
8267 for (secpp
= &abfd
->sections
; *secpp
!= NULL
; secpp
= &(*secpp
)->next
)
8269 if (strcmp ((*secpp
)->name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
8271 for (p
= (*secpp
)->link_order_head
; p
!= NULL
; p
= p
->next
)
8272 if (p
->type
== bfd_indirect_link_order
)
8273 p
->u
.indirect
.section
->flags
&= ~SEC_HAS_CONTENTS
;
8274 (*secpp
)->link_order_head
= NULL
;
8275 bfd_section_list_remove (abfd
, secpp
);
8276 --abfd
->section_count
;
8282 /* We include .MIPS.options, even though we don't process it quite right.
8283 (Some entries are supposed to be merged.) At IRIX6 empirically we seem
8284 to be better off including it than not. */
8285 for (secpp
= &abfd
->sections
; *secpp
!= NULL
; secpp
= &(*secpp
)->next
)
8287 if (strcmp ((*secpp
)->name
, ".MIPS.options") == 0)
8289 for (p
= (*secpp
)->link_order_head
; p
!= NULL
; p
= p
->next
)
8290 if (p
->type
== bfd_indirect_link_order
)
8291 p
->u
.indirect
.section
->flags
&=~ SEC_HAS_CONTENTS
;
8292 (*secpp
)->link_order_head
= NULL
;
8293 bfd_section_list_remove (abfd
, secpp
);
8294 --abfd
->section_count
;
8301 /* Get a value for the GP register. */
8302 if (elf_gp (abfd
) == 0)
8304 struct bfd_link_hash_entry
*h
;
8306 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
8307 if (h
!= (struct bfd_link_hash_entry
*) NULL
8308 && h
->type
== bfd_link_hash_defined
)
8309 elf_gp (abfd
) = (h
->u
.def
.value
8310 + h
->u
.def
.section
->output_section
->vma
8311 + h
->u
.def
.section
->output_offset
);
8312 else if (info
->relocatable
)
8314 bfd_vma lo
= MINUS_ONE
;
8316 /* Find the GP-relative section with the lowest offset. */
8317 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
8319 && (elf_section_data (o
)->this_hdr
.sh_flags
& SHF_MIPS_GPREL
))
8322 /* And calculate GP relative to that. */
8323 elf_gp (abfd
) = lo
+ ELF_MIPS_GP_OFFSET (abfd
);
8327 /* If the relocate_section function needs to do a reloc
8328 involving the GP value, it should make a reloc_dangerous
8329 callback to warn that GP is not defined. */
8333 /* Go through the sections and collect the .reginfo and .mdebug
8337 gptab_data_sec
= NULL
;
8338 gptab_bss_sec
= NULL
;
8339 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
8341 if (strcmp (o
->name
, ".reginfo") == 0)
8343 memset (®info
, 0, sizeof reginfo
);
8345 /* We have found the .reginfo section in the output file.
8346 Look through all the link_orders comprising it and merge
8347 the information together. */
8348 for (p
= o
->link_order_head
;
8349 p
!= (struct bfd_link_order
*) NULL
;
8352 asection
*input_section
;
8354 Elf32_External_RegInfo ext
;
8357 if (p
->type
!= bfd_indirect_link_order
)
8359 if (p
->type
== bfd_data_link_order
)
8364 input_section
= p
->u
.indirect
.section
;
8365 input_bfd
= input_section
->owner
;
8367 /* The linker emulation code has probably clobbered the
8368 size to be zero bytes. */
8369 if (input_section
->_raw_size
== 0)
8370 input_section
->_raw_size
= sizeof (Elf32_External_RegInfo
);
8372 if (! bfd_get_section_contents (input_bfd
, input_section
,
8375 (bfd_size_type
) sizeof ext
))
8378 bfd_mips_elf32_swap_reginfo_in (input_bfd
, &ext
, &sub
);
8380 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
8381 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
8382 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
8383 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
8384 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
8386 /* ri_gp_value is set by the function
8387 mips_elf32_section_processing when the section is
8388 finally written out. */
8390 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8391 elf_link_input_bfd ignores this section. */
8392 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8395 /* Size has been set in _bfd_mips_elf_always_size_sections. */
8396 BFD_ASSERT(o
->_raw_size
== sizeof (Elf32_External_RegInfo
));
8398 /* Skip this section later on (I don't think this currently
8399 matters, but someday it might). */
8400 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
8405 if (strcmp (o
->name
, ".mdebug") == 0)
8407 struct extsym_info einfo
;
8410 /* We have found the .mdebug section in the output file.
8411 Look through all the link_orders comprising it and merge
8412 the information together. */
8413 symhdr
->magic
= swap
->sym_magic
;
8414 /* FIXME: What should the version stamp be? */
8416 symhdr
->ilineMax
= 0;
8420 symhdr
->isymMax
= 0;
8421 symhdr
->ioptMax
= 0;
8422 symhdr
->iauxMax
= 0;
8424 symhdr
->issExtMax
= 0;
8427 symhdr
->iextMax
= 0;
8429 /* We accumulate the debugging information itself in the
8430 debug_info structure. */
8432 debug
.external_dnr
= NULL
;
8433 debug
.external_pdr
= NULL
;
8434 debug
.external_sym
= NULL
;
8435 debug
.external_opt
= NULL
;
8436 debug
.external_aux
= NULL
;
8438 debug
.ssext
= debug
.ssext_end
= NULL
;
8439 debug
.external_fdr
= NULL
;
8440 debug
.external_rfd
= NULL
;
8441 debug
.external_ext
= debug
.external_ext_end
= NULL
;
8443 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
8444 if (mdebug_handle
== (PTR
) NULL
)
8448 esym
.cobol_main
= 0;
8452 esym
.asym
.iss
= issNil
;
8453 esym
.asym
.st
= stLocal
;
8454 esym
.asym
.reserved
= 0;
8455 esym
.asym
.index
= indexNil
;
8457 for (i
= 0; i
< sizeof (secname
) / sizeof (secname
[0]); i
++)
8459 esym
.asym
.sc
= sc
[i
];
8460 s
= bfd_get_section_by_name (abfd
, secname
[i
]);
8463 esym
.asym
.value
= s
->vma
;
8464 last
= s
->vma
+ s
->_raw_size
;
8467 esym
.asym
.value
= last
;
8468 if (!bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
8473 for (p
= o
->link_order_head
;
8474 p
!= (struct bfd_link_order
*) NULL
;
8477 asection
*input_section
;
8479 const struct ecoff_debug_swap
*input_swap
;
8480 struct ecoff_debug_info input_debug
;
8484 if (p
->type
!= bfd_indirect_link_order
)
8486 if (p
->type
== bfd_data_link_order
)
8491 input_section
= p
->u
.indirect
.section
;
8492 input_bfd
= input_section
->owner
;
8494 if (bfd_get_flavour (input_bfd
) != bfd_target_elf_flavour
8495 || (get_elf_backend_data (input_bfd
)
8496 ->elf_backend_ecoff_debug_swap
) == NULL
)
8498 /* I don't know what a non MIPS ELF bfd would be
8499 doing with a .mdebug section, but I don't really
8500 want to deal with it. */
8504 input_swap
= (get_elf_backend_data (input_bfd
)
8505 ->elf_backend_ecoff_debug_swap
);
8507 BFD_ASSERT (p
->size
== input_section
->_raw_size
);
8509 /* The ECOFF linking code expects that we have already
8510 read in the debugging information and set up an
8511 ecoff_debug_info structure, so we do that now. */
8512 if (! _bfd_mips_elf_read_ecoff_info (input_bfd
, input_section
,
8516 if (! (bfd_ecoff_debug_accumulate
8517 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
8518 &input_debug
, input_swap
, info
)))
8521 /* Loop through the external symbols. For each one with
8522 interesting information, try to find the symbol in
8523 the linker global hash table and save the information
8524 for the output external symbols. */
8525 eraw_src
= input_debug
.external_ext
;
8526 eraw_end
= (eraw_src
8527 + (input_debug
.symbolic_header
.iextMax
8528 * input_swap
->external_ext_size
));
8530 eraw_src
< eraw_end
;
8531 eraw_src
+= input_swap
->external_ext_size
)
8535 struct mips_elf_link_hash_entry
*h
;
8537 (*input_swap
->swap_ext_in
) (input_bfd
, (PTR
) eraw_src
, &ext
);
8538 if (ext
.asym
.sc
== scNil
8539 || ext
.asym
.sc
== scUndefined
8540 || ext
.asym
.sc
== scSUndefined
)
8543 name
= input_debug
.ssext
+ ext
.asym
.iss
;
8544 h
= mips_elf_link_hash_lookup (mips_elf_hash_table (info
),
8545 name
, FALSE
, FALSE
, TRUE
);
8546 if (h
== NULL
|| h
->esym
.ifd
!= -2)
8552 < input_debug
.symbolic_header
.ifdMax
);
8553 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
8559 /* Free up the information we just read. */
8560 free (input_debug
.line
);
8561 free (input_debug
.external_dnr
);
8562 free (input_debug
.external_pdr
);
8563 free (input_debug
.external_sym
);
8564 free (input_debug
.external_opt
);
8565 free (input_debug
.external_aux
);
8566 free (input_debug
.ss
);
8567 free (input_debug
.ssext
);
8568 free (input_debug
.external_fdr
);
8569 free (input_debug
.external_rfd
);
8570 free (input_debug
.external_ext
);
8572 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8573 elf_link_input_bfd ignores this section. */
8574 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8577 if (SGI_COMPAT (abfd
) && info
->shared
)
8579 /* Create .rtproc section. */
8580 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
8581 if (rtproc_sec
== NULL
)
8583 flagword flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
8584 | SEC_LINKER_CREATED
| SEC_READONLY
);
8586 rtproc_sec
= bfd_make_section (abfd
, ".rtproc");
8587 if (rtproc_sec
== NULL
8588 || ! bfd_set_section_flags (abfd
, rtproc_sec
, flags
)
8589 || ! bfd_set_section_alignment (abfd
, rtproc_sec
, 4))
8593 if (! mips_elf_create_procedure_table (mdebug_handle
, abfd
,
8599 /* Build the external symbol information. */
8602 einfo
.debug
= &debug
;
8604 einfo
.failed
= FALSE
;
8605 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
8606 mips_elf_output_extsym
,
8611 /* Set the size of the .mdebug section. */
8612 o
->_raw_size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
8614 /* Skip this section later on (I don't think this currently
8615 matters, but someday it might). */
8616 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
8621 if (strncmp (o
->name
, ".gptab.", sizeof ".gptab." - 1) == 0)
8623 const char *subname
;
8626 Elf32_External_gptab
*ext_tab
;
8629 /* The .gptab.sdata and .gptab.sbss sections hold
8630 information describing how the small data area would
8631 change depending upon the -G switch. These sections
8632 not used in executables files. */
8633 if (! info
->relocatable
)
8635 for (p
= o
->link_order_head
;
8636 p
!= (struct bfd_link_order
*) NULL
;
8639 asection
*input_section
;
8641 if (p
->type
!= bfd_indirect_link_order
)
8643 if (p
->type
== bfd_data_link_order
)
8648 input_section
= p
->u
.indirect
.section
;
8650 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8651 elf_link_input_bfd ignores this section. */
8652 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8655 /* Skip this section later on (I don't think this
8656 currently matters, but someday it might). */
8657 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
8659 /* Really remove the section. */
8660 for (secpp
= &abfd
->sections
;
8662 secpp
= &(*secpp
)->next
)
8664 bfd_section_list_remove (abfd
, secpp
);
8665 --abfd
->section_count
;
8670 /* There is one gptab for initialized data, and one for
8671 uninitialized data. */
8672 if (strcmp (o
->name
, ".gptab.sdata") == 0)
8674 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
8678 (*_bfd_error_handler
)
8679 (_("%s: illegal section name `%s'"),
8680 bfd_get_filename (abfd
), o
->name
);
8681 bfd_set_error (bfd_error_nonrepresentable_section
);
8685 /* The linker script always combines .gptab.data and
8686 .gptab.sdata into .gptab.sdata, and likewise for
8687 .gptab.bss and .gptab.sbss. It is possible that there is
8688 no .sdata or .sbss section in the output file, in which
8689 case we must change the name of the output section. */
8690 subname
= o
->name
+ sizeof ".gptab" - 1;
8691 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
8693 if (o
== gptab_data_sec
)
8694 o
->name
= ".gptab.data";
8696 o
->name
= ".gptab.bss";
8697 subname
= o
->name
+ sizeof ".gptab" - 1;
8698 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
8701 /* Set up the first entry. */
8703 amt
= c
* sizeof (Elf32_gptab
);
8704 tab
= (Elf32_gptab
*) bfd_malloc (amt
);
8707 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
8708 tab
[0].gt_header
.gt_unused
= 0;
8710 /* Combine the input sections. */
8711 for (p
= o
->link_order_head
;
8712 p
!= (struct bfd_link_order
*) NULL
;
8715 asection
*input_section
;
8719 bfd_size_type gpentry
;
8721 if (p
->type
!= bfd_indirect_link_order
)
8723 if (p
->type
== bfd_data_link_order
)
8728 input_section
= p
->u
.indirect
.section
;
8729 input_bfd
= input_section
->owner
;
8731 /* Combine the gptab entries for this input section one
8732 by one. We know that the input gptab entries are
8733 sorted by ascending -G value. */
8734 size
= bfd_section_size (input_bfd
, input_section
);
8736 for (gpentry
= sizeof (Elf32_External_gptab
);
8738 gpentry
+= sizeof (Elf32_External_gptab
))
8740 Elf32_External_gptab ext_gptab
;
8741 Elf32_gptab int_gptab
;
8747 if (! (bfd_get_section_contents
8748 (input_bfd
, input_section
, (PTR
) &ext_gptab
,
8750 (bfd_size_type
) sizeof (Elf32_External_gptab
))))
8756 bfd_mips_elf32_swap_gptab_in (input_bfd
, &ext_gptab
,
8758 val
= int_gptab
.gt_entry
.gt_g_value
;
8759 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
8762 for (look
= 1; look
< c
; look
++)
8764 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
8765 tab
[look
].gt_entry
.gt_bytes
+= add
;
8767 if (tab
[look
].gt_entry
.gt_g_value
== val
)
8773 Elf32_gptab
*new_tab
;
8776 /* We need a new table entry. */
8777 amt
= (bfd_size_type
) (c
+ 1) * sizeof (Elf32_gptab
);
8778 new_tab
= (Elf32_gptab
*) bfd_realloc ((PTR
) tab
, amt
);
8779 if (new_tab
== NULL
)
8785 tab
[c
].gt_entry
.gt_g_value
= val
;
8786 tab
[c
].gt_entry
.gt_bytes
= add
;
8788 /* Merge in the size for the next smallest -G
8789 value, since that will be implied by this new
8792 for (look
= 1; look
< c
; look
++)
8794 if (tab
[look
].gt_entry
.gt_g_value
< val
8796 || (tab
[look
].gt_entry
.gt_g_value
8797 > tab
[max
].gt_entry
.gt_g_value
)))
8801 tab
[c
].gt_entry
.gt_bytes
+=
8802 tab
[max
].gt_entry
.gt_bytes
;
8807 last
= int_gptab
.gt_entry
.gt_bytes
;
8810 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8811 elf_link_input_bfd ignores this section. */
8812 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8815 /* The table must be sorted by -G value. */
8817 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
8819 /* Swap out the table. */
8820 amt
= (bfd_size_type
) c
* sizeof (Elf32_External_gptab
);
8821 ext_tab
= (Elf32_External_gptab
*) bfd_alloc (abfd
, amt
);
8822 if (ext_tab
== NULL
)
8828 for (j
= 0; j
< c
; j
++)
8829 bfd_mips_elf32_swap_gptab_out (abfd
, tab
+ j
, ext_tab
+ j
);
8832 o
->_raw_size
= c
* sizeof (Elf32_External_gptab
);
8833 o
->contents
= (bfd_byte
*) ext_tab
;
8835 /* Skip this section later on (I don't think this currently
8836 matters, but someday it might). */
8837 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
8841 /* Invoke the regular ELF backend linker to do all the work. */
8842 if (!MNAME(abfd
,bfd_elf
,bfd_final_link
) (abfd
, info
))
8845 /* Now write out the computed sections. */
8847 if (reginfo_sec
!= (asection
*) NULL
)
8849 Elf32_External_RegInfo ext
;
8851 bfd_mips_elf32_swap_reginfo_out (abfd
, ®info
, &ext
);
8852 if (! bfd_set_section_contents (abfd
, reginfo_sec
, (PTR
) &ext
,
8854 (bfd_size_type
) sizeof ext
))
8858 if (mdebug_sec
!= (asection
*) NULL
)
8860 BFD_ASSERT (abfd
->output_has_begun
);
8861 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
8863 mdebug_sec
->filepos
))
8866 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
8869 if (gptab_data_sec
!= (asection
*) NULL
)
8871 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
8872 gptab_data_sec
->contents
,
8874 gptab_data_sec
->_raw_size
))
8878 if (gptab_bss_sec
!= (asection
*) NULL
)
8880 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
8881 gptab_bss_sec
->contents
,
8883 gptab_bss_sec
->_raw_size
))
8887 if (SGI_COMPAT (abfd
))
8889 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
8890 if (rtproc_sec
!= NULL
)
8892 if (! bfd_set_section_contents (abfd
, rtproc_sec
,
8893 rtproc_sec
->contents
,
8895 rtproc_sec
->_raw_size
))
8903 /* Structure for saying that BFD machine EXTENSION extends BASE. */
8905 struct mips_mach_extension
{
8906 unsigned long extension
, base
;
8910 /* An array describing how BFD machines relate to one another. The entries
8911 are ordered topologically with MIPS I extensions listed last. */
8913 static const struct mips_mach_extension mips_mach_extensions
[] = {
8914 /* MIPS64 extensions. */
8915 { bfd_mach_mipsisa64r2
, bfd_mach_mipsisa64
},
8916 { bfd_mach_mips_sb1
, bfd_mach_mipsisa64
},
8918 /* MIPS V extensions. */
8919 { bfd_mach_mipsisa64
, bfd_mach_mips5
},
8921 /* R10000 extensions. */
8922 { bfd_mach_mips12000
, bfd_mach_mips10000
},
8924 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
8925 vr5400 ISA, but doesn't include the multimedia stuff. It seems
8926 better to allow vr5400 and vr5500 code to be merged anyway, since
8927 many libraries will just use the core ISA. Perhaps we could add
8928 some sort of ASE flag if this ever proves a problem. */
8929 { bfd_mach_mips5500
, bfd_mach_mips5400
},
8930 { bfd_mach_mips5400
, bfd_mach_mips5000
},
8932 /* MIPS IV extensions. */
8933 { bfd_mach_mips5
, bfd_mach_mips8000
},
8934 { bfd_mach_mips10000
, bfd_mach_mips8000
},
8935 { bfd_mach_mips5000
, bfd_mach_mips8000
},
8936 { bfd_mach_mips7000
, bfd_mach_mips8000
},
8938 /* VR4100 extensions. */
8939 { bfd_mach_mips4120
, bfd_mach_mips4100
},
8940 { bfd_mach_mips4111
, bfd_mach_mips4100
},
8942 /* MIPS III extensions. */
8943 { bfd_mach_mips8000
, bfd_mach_mips4000
},
8944 { bfd_mach_mips4650
, bfd_mach_mips4000
},
8945 { bfd_mach_mips4600
, bfd_mach_mips4000
},
8946 { bfd_mach_mips4400
, bfd_mach_mips4000
},
8947 { bfd_mach_mips4300
, bfd_mach_mips4000
},
8948 { bfd_mach_mips4100
, bfd_mach_mips4000
},
8949 { bfd_mach_mips4010
, bfd_mach_mips4000
},
8951 /* MIPS32 extensions. */
8952 { bfd_mach_mipsisa32r2
, bfd_mach_mipsisa32
},
8954 /* MIPS II extensions. */
8955 { bfd_mach_mips4000
, bfd_mach_mips6000
},
8956 { bfd_mach_mipsisa32
, bfd_mach_mips6000
},
8958 /* MIPS I extensions. */
8959 { bfd_mach_mips6000
, bfd_mach_mips3000
},
8960 { bfd_mach_mips3900
, bfd_mach_mips3000
}
8964 /* Return true if bfd machine EXTENSION is an extension of machine BASE. */
8967 mips_mach_extends_p (base
, extension
)
8968 unsigned long base
, extension
;
8972 for (i
= 0; extension
!= base
&& i
< ARRAY_SIZE (mips_mach_extensions
); i
++)
8973 if (extension
== mips_mach_extensions
[i
].extension
)
8974 extension
= mips_mach_extensions
[i
].base
;
8976 return extension
== base
;
8980 /* Return true if the given ELF header flags describe a 32-bit binary. */
8983 mips_32bit_flags_p (flags
)
8986 return ((flags
& EF_MIPS_32BITMODE
) != 0
8987 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
8988 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
8989 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
8990 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
8991 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
8992 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
);
8996 /* Merge backend specific data from an object file to the output
8997 object file when linking. */
9000 _bfd_mips_elf_merge_private_bfd_data (ibfd
, obfd
)
9007 bfd_boolean null_input_bfd
= TRUE
;
9010 /* Check if we have the same endianess */
9011 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
9013 (*_bfd_error_handler
)
9014 (_("%s: endianness incompatible with that of the selected emulation"),
9015 bfd_archive_filename (ibfd
));
9019 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
9020 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
9023 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
9025 (*_bfd_error_handler
)
9026 (_("%s: ABI is incompatible with that of the selected emulation"),
9027 bfd_archive_filename (ibfd
));
9031 new_flags
= elf_elfheader (ibfd
)->e_flags
;
9032 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_NOREORDER
;
9033 old_flags
= elf_elfheader (obfd
)->e_flags
;
9035 if (! elf_flags_init (obfd
))
9037 elf_flags_init (obfd
) = TRUE
;
9038 elf_elfheader (obfd
)->e_flags
= new_flags
;
9039 elf_elfheader (obfd
)->e_ident
[EI_CLASS
]
9040 = elf_elfheader (ibfd
)->e_ident
[EI_CLASS
];
9042 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
9043 && bfd_get_arch_info (obfd
)->the_default
)
9045 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
9046 bfd_get_mach (ibfd
)))
9053 /* Check flag compatibility. */
9055 new_flags
&= ~EF_MIPS_NOREORDER
;
9056 old_flags
&= ~EF_MIPS_NOREORDER
;
9058 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
9059 doesn't seem to matter. */
9060 new_flags
&= ~EF_MIPS_XGOT
;
9061 old_flags
&= ~EF_MIPS_XGOT
;
9063 /* MIPSpro generates ucode info in n64 objects. Again, we should
9064 just be able to ignore this. */
9065 new_flags
&= ~EF_MIPS_UCODE
;
9066 old_flags
&= ~EF_MIPS_UCODE
;
9068 if (new_flags
== old_flags
)
9071 /* Check to see if the input BFD actually contains any sections.
9072 If not, its flags may not have been initialised either, but it cannot
9073 actually cause any incompatibility. */
9074 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
9076 /* Ignore synthetic sections and empty .text, .data and .bss sections
9077 which are automatically generated by gas. */
9078 if (strcmp (sec
->name
, ".reginfo")
9079 && strcmp (sec
->name
, ".mdebug")
9080 && ((!strcmp (sec
->name
, ".text")
9081 || !strcmp (sec
->name
, ".data")
9082 || !strcmp (sec
->name
, ".bss"))
9083 && sec
->_raw_size
!= 0))
9085 null_input_bfd
= FALSE
;
9094 if (((new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0)
9095 != ((old_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0))
9097 (*_bfd_error_handler
)
9098 (_("%s: warning: linking PIC files with non-PIC files"),
9099 bfd_archive_filename (ibfd
));
9103 if (new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
))
9104 elf_elfheader (obfd
)->e_flags
|= EF_MIPS_CPIC
;
9105 if (! (new_flags
& EF_MIPS_PIC
))
9106 elf_elfheader (obfd
)->e_flags
&= ~EF_MIPS_PIC
;
9108 new_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
9109 old_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
9111 /* Compare the ISAs. */
9112 if (mips_32bit_flags_p (old_flags
) != mips_32bit_flags_p (new_flags
))
9114 (*_bfd_error_handler
)
9115 (_("%s: linking 32-bit code with 64-bit code"),
9116 bfd_archive_filename (ibfd
));
9119 else if (!mips_mach_extends_p (bfd_get_mach (ibfd
), bfd_get_mach (obfd
)))
9121 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
9122 if (mips_mach_extends_p (bfd_get_mach (obfd
), bfd_get_mach (ibfd
)))
9124 /* Copy the architecture info from IBFD to OBFD. Also copy
9125 the 32-bit flag (if set) so that we continue to recognise
9126 OBFD as a 32-bit binary. */
9127 bfd_set_arch_info (obfd
, bfd_get_arch_info (ibfd
));
9128 elf_elfheader (obfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
9129 elf_elfheader (obfd
)->e_flags
9130 |= new_flags
& (EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9132 /* Copy across the ABI flags if OBFD doesn't use them
9133 and if that was what caused us to treat IBFD as 32-bit. */
9134 if ((old_flags
& EF_MIPS_ABI
) == 0
9135 && mips_32bit_flags_p (new_flags
)
9136 && !mips_32bit_flags_p (new_flags
& ~EF_MIPS_ABI
))
9137 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ABI
;
9141 /* The ISAs aren't compatible. */
9142 (*_bfd_error_handler
)
9143 (_("%s: linking %s module with previous %s modules"),
9144 bfd_archive_filename (ibfd
),
9145 bfd_printable_name (ibfd
),
9146 bfd_printable_name (obfd
));
9151 new_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9152 old_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9154 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
9155 does set EI_CLASS differently from any 32-bit ABI. */
9156 if ((new_flags
& EF_MIPS_ABI
) != (old_flags
& EF_MIPS_ABI
)
9157 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
9158 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
9160 /* Only error if both are set (to different values). */
9161 if (((new_flags
& EF_MIPS_ABI
) && (old_flags
& EF_MIPS_ABI
))
9162 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
9163 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
9165 (*_bfd_error_handler
)
9166 (_("%s: ABI mismatch: linking %s module with previous %s modules"),
9167 bfd_archive_filename (ibfd
),
9168 elf_mips_abi_name (ibfd
),
9169 elf_mips_abi_name (obfd
));
9172 new_flags
&= ~EF_MIPS_ABI
;
9173 old_flags
&= ~EF_MIPS_ABI
;
9176 /* For now, allow arbitrary mixing of ASEs (retain the union). */
9177 if ((new_flags
& EF_MIPS_ARCH_ASE
) != (old_flags
& EF_MIPS_ARCH_ASE
))
9179 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ARCH_ASE
;
9181 new_flags
&= ~ EF_MIPS_ARCH_ASE
;
9182 old_flags
&= ~ EF_MIPS_ARCH_ASE
;
9185 /* Warn about any other mismatches */
9186 if (new_flags
!= old_flags
)
9188 (*_bfd_error_handler
)
9189 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
9190 bfd_archive_filename (ibfd
), (unsigned long) new_flags
,
9191 (unsigned long) old_flags
);
9197 bfd_set_error (bfd_error_bad_value
);
9204 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
9207 _bfd_mips_elf_set_private_flags (abfd
, flags
)
9211 BFD_ASSERT (!elf_flags_init (abfd
)
9212 || elf_elfheader (abfd
)->e_flags
== flags
);
9214 elf_elfheader (abfd
)->e_flags
= flags
;
9215 elf_flags_init (abfd
) = TRUE
;
9220 _bfd_mips_elf_print_private_bfd_data (abfd
, ptr
)
9224 FILE *file
= (FILE *) ptr
;
9226 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
9228 /* Print normal ELF private data. */
9229 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
9231 /* xgettext:c-format */
9232 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
9234 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
)
9235 fprintf (file
, _(" [abi=O32]"));
9236 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O64
)
9237 fprintf (file
, _(" [abi=O64]"));
9238 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
)
9239 fprintf (file
, _(" [abi=EABI32]"));
9240 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
9241 fprintf (file
, _(" [abi=EABI64]"));
9242 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
))
9243 fprintf (file
, _(" [abi unknown]"));
9244 else if (ABI_N32_P (abfd
))
9245 fprintf (file
, _(" [abi=N32]"));
9246 else if (ABI_64_P (abfd
))
9247 fprintf (file
, _(" [abi=64]"));
9249 fprintf (file
, _(" [no abi set]"));
9251 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
9252 fprintf (file
, _(" [mips1]"));
9253 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
9254 fprintf (file
, _(" [mips2]"));
9255 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
9256 fprintf (file
, _(" [mips3]"));
9257 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
9258 fprintf (file
, _(" [mips4]"));
9259 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_5
)
9260 fprintf (file
, _(" [mips5]"));
9261 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
)
9262 fprintf (file
, _(" [mips32]"));
9263 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64
)
9264 fprintf (file
, _(" [mips64]"));
9265 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
)
9266 fprintf (file
, _(" [mips32r2]"));
9267 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64R2
)
9268 fprintf (file
, _(" [mips64r2]"));
9270 fprintf (file
, _(" [unknown ISA]"));
9272 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
9273 fprintf (file
, _(" [mdmx]"));
9275 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_M16
)
9276 fprintf (file
, _(" [mips16]"));
9278 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_32BITMODE
)
9279 fprintf (file
, _(" [32bitmode]"));
9281 fprintf (file
, _(" [not 32bitmode]"));
9288 struct bfd_elf_special_section
const _bfd_mips_elf_special_sections
[]=
9290 { ".sdata", 6, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9291 { ".sbss", 5, -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9292 { ".lit4", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9293 { ".lit8", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9294 { ".ucode", 6, 0, SHT_MIPS_UCODE
, 0 },
9295 { ".mdebug", 7, 0, SHT_MIPS_DEBUG
, 0 },
9296 { NULL
, 0, 0, 0, 0 }