1 /* MIPS-specific support for ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003 Free Software Foundation, Inc.
5 Most of the information added by Ian Lance Taylor, Cygnus Support,
7 N32/64 ABI support added by Mark Mitchell, CodeSourcery, LLC.
8 <mark@codesourcery.com>
9 Traditional MIPS targets support added by Koundinya.K, Dansk Data
10 Elektronik & Operations Research Group. <kk@ddeorg.soft.net>
12 This file is part of BFD, the Binary File Descriptor library.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 2 of the License, or
17 (at your option) any later version.
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 /* This file handles functionality common to the different MIPS ABI's. */
33 #include "libiberty.h"
35 #include "elfxx-mips.h"
38 /* Get the ECOFF swapping routines. */
40 #include "coff/symconst.h"
41 #include "coff/ecoff.h"
42 #include "coff/mips.h"
46 /* This structure is used to hold .got entries while estimating got
50 /* The input bfd in which the symbol is defined. */
52 /* The index of the symbol, as stored in the relocation r_info, if
53 we have a local symbol; -1 otherwise. */
57 /* If abfd == NULL, an address that must be stored in the got. */
59 /* If abfd != NULL && symndx != -1, the addend of the relocation
60 that should be added to the symbol value. */
62 /* If abfd != NULL && symndx == -1, the hash table entry
63 corresponding to a global symbol in the got (or, local, if
65 struct mips_elf_link_hash_entry
*h
;
67 /* The offset from the beginning of the .got section to the entry
68 corresponding to this symbol+addend. If it's a global symbol
69 whose offset is yet to be decided, it's going to be -1. */
73 /* This structure is used to hold .got information when linking. */
77 /* The global symbol in the GOT with the lowest index in the dynamic
79 struct elf_link_hash_entry
*global_gotsym
;
80 /* The number of global .got entries. */
81 unsigned int global_gotno
;
82 /* The number of local .got entries. */
83 unsigned int local_gotno
;
84 /* The number of local .got entries we have used. */
85 unsigned int assigned_gotno
;
86 /* A hash table holding members of the got. */
87 struct htab
*got_entries
;
88 /* A hash table mapping input bfds to other mips_got_info. NULL
89 unless multi-got was necessary. */
91 /* In multi-got links, a pointer to the next got (err, rather, most
92 of the time, it points to the previous got). */
93 struct mips_got_info
*next
;
96 /* Map an input bfd to a got in a multi-got link. */
98 struct mips_elf_bfd2got_hash
{
100 struct mips_got_info
*g
;
103 /* Structure passed when traversing the bfd2got hash table, used to
104 create and merge bfd's gots. */
106 struct mips_elf_got_per_bfd_arg
108 /* A hashtable that maps bfds to gots. */
110 /* The output bfd. */
112 /* The link information. */
113 struct bfd_link_info
*info
;
114 /* A pointer to the primary got, i.e., the one that's going to get
115 the implicit relocations from DT_MIPS_LOCAL_GOTNO and
117 struct mips_got_info
*primary
;
118 /* A non-primary got we're trying to merge with other input bfd's
120 struct mips_got_info
*current
;
121 /* The maximum number of got entries that can be addressed with a
123 unsigned int max_count
;
124 /* The number of local and global entries in the primary got. */
125 unsigned int primary_count
;
126 /* The number of local and global entries in the current got. */
127 unsigned int current_count
;
130 /* Another structure used to pass arguments for got entries traversal. */
132 struct mips_elf_set_global_got_offset_arg
134 struct mips_got_info
*g
;
136 unsigned int needed_relocs
;
137 struct bfd_link_info
*info
;
140 struct _mips_elf_section_data
142 struct bfd_elf_section_data elf
;
145 struct mips_got_info
*got_info
;
150 #define mips_elf_section_data(sec) \
151 ((struct _mips_elf_section_data *) elf_section_data (sec))
153 /* This structure is passed to mips_elf_sort_hash_table_f when sorting
154 the dynamic symbols. */
156 struct mips_elf_hash_sort_data
158 /* The symbol in the global GOT with the lowest dynamic symbol table
160 struct elf_link_hash_entry
*low
;
161 /* The least dynamic symbol table index corresponding to a symbol
163 long min_got_dynindx
;
164 /* The greatest dynamic symbol table index corresponding to a symbol
165 with a GOT entry that is not referenced (e.g., a dynamic symbol
166 with dynamic relocations pointing to it from non-primary GOTs). */
167 long max_unref_got_dynindx
;
168 /* The greatest dynamic symbol table index not corresponding to a
169 symbol without a GOT entry. */
170 long max_non_got_dynindx
;
173 /* The MIPS ELF linker needs additional information for each symbol in
174 the global hash table. */
176 struct mips_elf_link_hash_entry
178 struct elf_link_hash_entry root
;
180 /* External symbol information. */
183 /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
185 unsigned int possibly_dynamic_relocs
;
187 /* If the R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 reloc is against
188 a readonly section. */
189 bfd_boolean readonly_reloc
;
191 /* We must not create a stub for a symbol that has relocations
192 related to taking the function's address, i.e. any but
193 R_MIPS_CALL*16 ones -- see "MIPS ABI Supplement, 3rd Edition",
195 bfd_boolean no_fn_stub
;
197 /* If there is a stub that 32 bit functions should use to call this
198 16 bit function, this points to the section containing the stub. */
201 /* Whether we need the fn_stub; this is set if this symbol appears
202 in any relocs other than a 16 bit call. */
203 bfd_boolean need_fn_stub
;
205 /* If there is a stub that 16 bit functions should use to call this
206 32 bit function, this points to the section containing the stub. */
209 /* This is like the call_stub field, but it is used if the function
210 being called returns a floating point value. */
211 asection
*call_fp_stub
;
213 /* Are we forced local? .*/
214 bfd_boolean forced_local
;
217 /* MIPS ELF linker hash table. */
219 struct mips_elf_link_hash_table
221 struct elf_link_hash_table root
;
223 /* We no longer use this. */
224 /* String section indices for the dynamic section symbols. */
225 bfd_size_type dynsym_sec_strindex
[SIZEOF_MIPS_DYNSYM_SECNAMES
];
227 /* The number of .rtproc entries. */
228 bfd_size_type procedure_count
;
229 /* The size of the .compact_rel section (if SGI_COMPAT). */
230 bfd_size_type compact_rel_size
;
231 /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic
232 entry is set to the address of __rld_obj_head as in IRIX5. */
233 bfd_boolean use_rld_obj_head
;
234 /* This is the value of the __rld_map or __rld_obj_head symbol. */
236 /* This is set if we see any mips16 stub sections. */
237 bfd_boolean mips16_stubs_seen
;
240 /* Structure used to pass information to mips_elf_output_extsym. */
245 struct bfd_link_info
*info
;
246 struct ecoff_debug_info
*debug
;
247 const struct ecoff_debug_swap
*swap
;
251 /* The names of the runtime procedure table symbols used on IRIX5. */
253 static const char * const mips_elf_dynsym_rtproc_names
[] =
256 "_procedure_string_table",
257 "_procedure_table_size",
261 /* These structures are used to generate the .compact_rel section on
266 unsigned long id1
; /* Always one? */
267 unsigned long num
; /* Number of compact relocation entries. */
268 unsigned long id2
; /* Always two? */
269 unsigned long offset
; /* The file offset of the first relocation. */
270 unsigned long reserved0
; /* Zero? */
271 unsigned long reserved1
; /* Zero? */
280 bfd_byte reserved0
[4];
281 bfd_byte reserved1
[4];
282 } Elf32_External_compact_rel
;
286 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
287 unsigned int rtype
: 4; /* Relocation types. See below. */
288 unsigned int dist2to
: 8;
289 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
290 unsigned long konst
; /* KONST field. See below. */
291 unsigned long vaddr
; /* VADDR to be relocated. */
296 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
297 unsigned int rtype
: 4; /* Relocation types. See below. */
298 unsigned int dist2to
: 8;
299 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
300 unsigned long konst
; /* KONST field. See below. */
308 } Elf32_External_crinfo
;
314 } Elf32_External_crinfo2
;
316 /* These are the constants used to swap the bitfields in a crinfo. */
318 #define CRINFO_CTYPE (0x1)
319 #define CRINFO_CTYPE_SH (31)
320 #define CRINFO_RTYPE (0xf)
321 #define CRINFO_RTYPE_SH (27)
322 #define CRINFO_DIST2TO (0xff)
323 #define CRINFO_DIST2TO_SH (19)
324 #define CRINFO_RELVADDR (0x7ffff)
325 #define CRINFO_RELVADDR_SH (0)
327 /* A compact relocation info has long (3 words) or short (2 words)
328 formats. A short format doesn't have VADDR field and relvaddr
329 fields contains ((VADDR - vaddr of the previous entry) >> 2). */
330 #define CRF_MIPS_LONG 1
331 #define CRF_MIPS_SHORT 0
333 /* There are 4 types of compact relocation at least. The value KONST
334 has different meaning for each type:
337 CT_MIPS_REL32 Address in data
338 CT_MIPS_WORD Address in word (XXX)
339 CT_MIPS_GPHI_LO GP - vaddr
340 CT_MIPS_JMPAD Address to jump
343 #define CRT_MIPS_REL32 0xa
344 #define CRT_MIPS_WORD 0xb
345 #define CRT_MIPS_GPHI_LO 0xc
346 #define CRT_MIPS_JMPAD 0xd
348 #define mips_elf_set_cr_format(x,format) ((x).ctype = (format))
349 #define mips_elf_set_cr_type(x,type) ((x).rtype = (type))
350 #define mips_elf_set_cr_dist2to(x,v) ((x).dist2to = (v))
351 #define mips_elf_set_cr_relvaddr(x,d) ((x).relvaddr = (d)<<2)
353 /* The structure of the runtime procedure descriptor created by the
354 loader for use by the static exception system. */
356 typedef struct runtime_pdr
{
357 bfd_vma adr
; /* Memory address of start of procedure. */
358 long regmask
; /* Save register mask. */
359 long regoffset
; /* Save register offset. */
360 long fregmask
; /* Save floating point register mask. */
361 long fregoffset
; /* Save floating point register offset. */
362 long frameoffset
; /* Frame size. */
363 short framereg
; /* Frame pointer register. */
364 short pcreg
; /* Offset or reg of return pc. */
365 long irpss
; /* Index into the runtime string table. */
367 struct exception_info
*exception_info
;/* Pointer to exception array. */
369 #define cbRPDR sizeof (RPDR)
370 #define rpdNil ((pRPDR) 0)
372 static struct bfd_hash_entry
*mips_elf_link_hash_newfunc
373 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
374 static void ecoff_swap_rpdr_out
375 PARAMS ((bfd
*, const RPDR
*, struct rpdr_ext
*));
376 static bfd_boolean mips_elf_create_procedure_table
377 PARAMS ((PTR
, bfd
*, struct bfd_link_info
*, asection
*,
378 struct ecoff_debug_info
*));
379 static bfd_boolean mips_elf_check_mips16_stubs
380 PARAMS ((struct mips_elf_link_hash_entry
*, PTR
));
381 static void bfd_mips_elf32_swap_gptab_in
382 PARAMS ((bfd
*, const Elf32_External_gptab
*, Elf32_gptab
*));
383 static void bfd_mips_elf32_swap_gptab_out
384 PARAMS ((bfd
*, const Elf32_gptab
*, Elf32_External_gptab
*));
385 static void bfd_elf32_swap_compact_rel_out
386 PARAMS ((bfd
*, const Elf32_compact_rel
*, Elf32_External_compact_rel
*));
387 static void bfd_elf32_swap_crinfo_out
388 PARAMS ((bfd
*, const Elf32_crinfo
*, Elf32_External_crinfo
*));
389 static int sort_dynamic_relocs
390 PARAMS ((const void *, const void *));
391 static int sort_dynamic_relocs_64
392 PARAMS ((const void *, const void *));
393 static bfd_boolean mips_elf_output_extsym
394 PARAMS ((struct mips_elf_link_hash_entry
*, PTR
));
395 static int gptab_compare
PARAMS ((const void *, const void *));
396 static asection
* mips_elf_rel_dyn_section
PARAMS ((bfd
*, bfd_boolean
));
397 static asection
* mips_elf_got_section
PARAMS ((bfd
*, bfd_boolean
));
398 static struct mips_got_info
*mips_elf_got_info
399 PARAMS ((bfd
*, asection
**));
400 static long mips_elf_get_global_gotsym_index
PARAMS ((bfd
*abfd
));
401 static bfd_vma mips_elf_local_got_index
402 PARAMS ((bfd
*, bfd
*, struct bfd_link_info
*, bfd_vma
));
403 static bfd_vma mips_elf_global_got_index
404 PARAMS ((bfd
*, bfd
*, struct elf_link_hash_entry
*));
405 static bfd_vma mips_elf_got_page
406 PARAMS ((bfd
*, bfd
*, struct bfd_link_info
*, bfd_vma
, bfd_vma
*));
407 static bfd_vma mips_elf_got16_entry
408 PARAMS ((bfd
*, bfd
*, struct bfd_link_info
*, bfd_vma
, bfd_boolean
));
409 static bfd_vma mips_elf_got_offset_from_index
410 PARAMS ((bfd
*, bfd
*, bfd
*, bfd_vma
));
411 static struct mips_got_entry
*mips_elf_create_local_got_entry
412 PARAMS ((bfd
*, bfd
*, struct mips_got_info
*, asection
*, bfd_vma
));
413 static bfd_boolean mips_elf_sort_hash_table
414 PARAMS ((struct bfd_link_info
*, unsigned long));
415 static bfd_boolean mips_elf_sort_hash_table_f
416 PARAMS ((struct mips_elf_link_hash_entry
*, PTR
));
417 static bfd_boolean mips_elf_record_local_got_symbol
418 PARAMS ((bfd
*, long, bfd_vma
, struct mips_got_info
*));
419 static bfd_boolean mips_elf_record_global_got_symbol
420 PARAMS ((struct elf_link_hash_entry
*, bfd
*, struct bfd_link_info
*,
421 struct mips_got_info
*));
422 static const Elf_Internal_Rela
*mips_elf_next_relocation
423 PARAMS ((bfd
*, unsigned int, const Elf_Internal_Rela
*,
424 const Elf_Internal_Rela
*));
425 static bfd_boolean mips_elf_local_relocation_p
426 PARAMS ((bfd
*, const Elf_Internal_Rela
*, asection
**, bfd_boolean
));
427 static bfd_boolean mips_elf_overflow_p
PARAMS ((bfd_vma
, int));
428 static bfd_vma mips_elf_high
PARAMS ((bfd_vma
));
429 static bfd_vma mips_elf_higher
PARAMS ((bfd_vma
));
430 static bfd_vma mips_elf_highest
PARAMS ((bfd_vma
));
431 static bfd_boolean mips_elf_create_compact_rel_section
432 PARAMS ((bfd
*, struct bfd_link_info
*));
433 static bfd_boolean mips_elf_create_got_section
434 PARAMS ((bfd
*, struct bfd_link_info
*, bfd_boolean
));
435 static bfd_reloc_status_type mips_elf_calculate_relocation
436 PARAMS ((bfd
*, bfd
*, asection
*, struct bfd_link_info
*,
437 const Elf_Internal_Rela
*, bfd_vma
, reloc_howto_type
*,
438 Elf_Internal_Sym
*, asection
**, bfd_vma
*, const char **,
439 bfd_boolean
*, bfd_boolean
));
440 static bfd_vma mips_elf_obtain_contents
441 PARAMS ((reloc_howto_type
*, const Elf_Internal_Rela
*, bfd
*, bfd_byte
*));
442 static bfd_boolean mips_elf_perform_relocation
443 PARAMS ((struct bfd_link_info
*, reloc_howto_type
*,
444 const Elf_Internal_Rela
*, bfd_vma
, bfd
*, asection
*, bfd_byte
*,
446 static bfd_boolean mips_elf_stub_section_p
447 PARAMS ((bfd
*, asection
*));
448 static void mips_elf_allocate_dynamic_relocations
449 PARAMS ((bfd
*, unsigned int));
450 static bfd_boolean mips_elf_create_dynamic_relocation
451 PARAMS ((bfd
*, struct bfd_link_info
*, const Elf_Internal_Rela
*,
452 struct mips_elf_link_hash_entry
*, asection
*,
453 bfd_vma
, bfd_vma
*, asection
*));
454 static void mips_set_isa_flags
PARAMS ((bfd
*));
455 static INLINE
char* elf_mips_abi_name
PARAMS ((bfd
*));
456 static void mips_elf_irix6_finish_dynamic_symbol
457 PARAMS ((bfd
*, const char *, Elf_Internal_Sym
*));
458 static bfd_boolean mips_mach_extends_p
PARAMS ((unsigned long, unsigned long));
459 static bfd_boolean mips_32bit_flags_p
PARAMS ((flagword
));
460 static INLINE hashval_t mips_elf_hash_bfd_vma
PARAMS ((bfd_vma
));
461 static hashval_t mips_elf_got_entry_hash
PARAMS ((const PTR
));
462 static int mips_elf_got_entry_eq
PARAMS ((const PTR
, const PTR
));
464 static bfd_boolean mips_elf_multi_got
465 PARAMS ((bfd
*, struct bfd_link_info
*, struct mips_got_info
*,
466 asection
*, bfd_size_type
));
467 static hashval_t mips_elf_multi_got_entry_hash
PARAMS ((const PTR
));
468 static int mips_elf_multi_got_entry_eq
PARAMS ((const PTR
, const PTR
));
469 static hashval_t mips_elf_bfd2got_entry_hash
PARAMS ((const PTR
));
470 static int mips_elf_bfd2got_entry_eq
PARAMS ((const PTR
, const PTR
));
471 static int mips_elf_make_got_per_bfd
PARAMS ((void **, void *));
472 static int mips_elf_merge_gots
PARAMS ((void **, void *));
473 static int mips_elf_set_global_got_offset
PARAMS ((void**, void *));
474 static int mips_elf_resolve_final_got_entry
PARAMS ((void**, void *));
475 static void mips_elf_resolve_final_got_entries
476 PARAMS ((struct mips_got_info
*));
477 static bfd_vma mips_elf_adjust_gp
478 PARAMS ((bfd
*, struct mips_got_info
*, bfd
*));
479 static struct mips_got_info
*mips_elf_got_for_ibfd
480 PARAMS ((struct mips_got_info
*, bfd
*));
482 /* This will be used when we sort the dynamic relocation records. */
483 static bfd
*reldyn_sorting_bfd
;
485 /* Nonzero if ABFD is using the N32 ABI. */
487 #define ABI_N32_P(abfd) \
488 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
490 /* Nonzero if ABFD is using the N64 ABI. */
491 #define ABI_64_P(abfd) \
492 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
494 /* Nonzero if ABFD is using NewABI conventions. */
495 #define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
497 /* The IRIX compatibility level we are striving for. */
498 #define IRIX_COMPAT(abfd) \
499 (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
501 /* Whether we are trying to be compatible with IRIX at all. */
502 #define SGI_COMPAT(abfd) \
503 (IRIX_COMPAT (abfd) != ict_none)
505 /* The name of the options section. */
506 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
507 (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
509 /* The name of the stub section. */
510 #define MIPS_ELF_STUB_SECTION_NAME(abfd) \
511 (NEWABI_P (abfd) ? ".MIPS.stubs" : ".stub")
513 /* The size of an external REL relocation. */
514 #define MIPS_ELF_REL_SIZE(abfd) \
515 (get_elf_backend_data (abfd)->s->sizeof_rel)
517 /* The size of an external dynamic table entry. */
518 #define MIPS_ELF_DYN_SIZE(abfd) \
519 (get_elf_backend_data (abfd)->s->sizeof_dyn)
521 /* The size of a GOT entry. */
522 #define MIPS_ELF_GOT_SIZE(abfd) \
523 (get_elf_backend_data (abfd)->s->arch_size / 8)
525 /* The size of a symbol-table entry. */
526 #define MIPS_ELF_SYM_SIZE(abfd) \
527 (get_elf_backend_data (abfd)->s->sizeof_sym)
529 /* The default alignment for sections, as a power of two. */
530 #define MIPS_ELF_LOG_FILE_ALIGN(abfd) \
531 (get_elf_backend_data (abfd)->s->log_file_align)
533 /* Get word-sized data. */
534 #define MIPS_ELF_GET_WORD(abfd, ptr) \
535 (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
537 /* Put out word-sized data. */
538 #define MIPS_ELF_PUT_WORD(abfd, val, ptr) \
540 ? bfd_put_64 (abfd, val, ptr) \
541 : bfd_put_32 (abfd, val, ptr))
543 /* Add a dynamic symbol table-entry. */
545 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
546 (ABI_64_P (elf_hash_table (info)->dynobj) \
547 ? bfd_elf64_add_dynamic_entry (info, (bfd_vma) tag, (bfd_vma) val) \
548 : bfd_elf32_add_dynamic_entry (info, (bfd_vma) tag, (bfd_vma) val))
550 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
551 (ABI_64_P (elf_hash_table (info)->dynobj) \
552 ? (abort (), FALSE) \
553 : bfd_elf32_add_dynamic_entry (info, (bfd_vma) tag, (bfd_vma) val))
556 #define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela) \
557 (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela))
559 /* Determine whether the internal relocation of index REL_IDX is REL
560 (zero) or RELA (non-zero). The assumption is that, if there are
561 two relocation sections for this section, one of them is REL and
562 the other is RELA. If the index of the relocation we're testing is
563 in range for the first relocation section, check that the external
564 relocation size is that for RELA. It is also assumed that, if
565 rel_idx is not in range for the first section, and this first
566 section contains REL relocs, then the relocation is in the second
567 section, that is RELA. */
568 #define MIPS_RELOC_RELA_P(abfd, sec, rel_idx) \
569 ((NUM_SHDR_ENTRIES (&elf_section_data (sec)->rel_hdr) \
570 * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel \
571 > (bfd_vma)(rel_idx)) \
572 == (elf_section_data (sec)->rel_hdr.sh_entsize \
573 == (ABI_64_P (abfd) ? sizeof (Elf64_External_Rela) \
574 : sizeof (Elf32_External_Rela))))
576 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
577 from smaller values. Start with zero, widen, *then* decrement. */
578 #define MINUS_ONE (((bfd_vma)0) - 1)
580 /* The number of local .got entries we reserve. */
581 #define MIPS_RESERVED_GOTNO (2)
583 /* The offset of $gp from the beginning of the .got section. */
584 #define ELF_MIPS_GP_OFFSET(abfd) (0x7ff0)
586 /* The maximum size of the GOT for it to be addressable using 16-bit
588 #define MIPS_ELF_GOT_MAX_SIZE(abfd) (ELF_MIPS_GP_OFFSET(abfd) + 0x7fff)
590 /* Instructions which appear in a stub. */
591 #define STUB_LW(abfd) \
593 ? 0xdf998010 /* ld t9,0x8010(gp) */ \
594 : 0x8f998010)) /* lw t9,0x8010(gp) */
595 #define STUB_MOVE(abfd) \
597 ? 0x03e0782d /* daddu t7,ra */ \
598 : 0x03e07821)) /* addu t7,ra */
599 #define STUB_JALR 0x0320f809 /* jalr t9,ra */
600 #define STUB_LI16(abfd) \
602 ? 0x64180000 /* daddiu t8,zero,0 */ \
603 : 0x24180000)) /* addiu t8,zero,0 */
604 #define MIPS_FUNCTION_STUB_SIZE (16)
606 /* The name of the dynamic interpreter. This is put in the .interp
609 #define ELF_DYNAMIC_INTERPRETER(abfd) \
610 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
611 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
612 : "/usr/lib/libc.so.1")
615 #define MNAME(bfd,pre,pos) \
616 (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
617 #define ELF_R_SYM(bfd, i) \
618 (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
619 #define ELF_R_TYPE(bfd, i) \
620 (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
621 #define ELF_R_INFO(bfd, s, t) \
622 (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
624 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
625 #define ELF_R_SYM(bfd, i) \
627 #define ELF_R_TYPE(bfd, i) \
629 #define ELF_R_INFO(bfd, s, t) \
630 (ELF32_R_INFO (s, t))
633 /* The mips16 compiler uses a couple of special sections to handle
634 floating point arguments.
636 Section names that look like .mips16.fn.FNNAME contain stubs that
637 copy floating point arguments from the fp regs to the gp regs and
638 then jump to FNNAME. If any 32 bit function calls FNNAME, the
639 call should be redirected to the stub instead. If no 32 bit
640 function calls FNNAME, the stub should be discarded. We need to
641 consider any reference to the function, not just a call, because
642 if the address of the function is taken we will need the stub,
643 since the address might be passed to a 32 bit function.
645 Section names that look like .mips16.call.FNNAME contain stubs
646 that copy floating point arguments from the gp regs to the fp
647 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
648 then any 16 bit function that calls FNNAME should be redirected
649 to the stub instead. If FNNAME is not a 32 bit function, the
650 stub should be discarded.
652 .mips16.call.fp.FNNAME sections are similar, but contain stubs
653 which call FNNAME and then copy the return value from the fp regs
654 to the gp regs. These stubs store the return value in $18 while
655 calling FNNAME; any function which might call one of these stubs
656 must arrange to save $18 around the call. (This case is not
657 needed for 32 bit functions that call 16 bit functions, because
658 16 bit functions always return floating point values in both
661 Note that in all cases FNNAME might be defined statically.
662 Therefore, FNNAME is not used literally. Instead, the relocation
663 information will indicate which symbol the section is for.
665 We record any stubs that we find in the symbol table. */
667 #define FN_STUB ".mips16.fn."
668 #define CALL_STUB ".mips16.call."
669 #define CALL_FP_STUB ".mips16.call.fp."
671 /* Look up an entry in a MIPS ELF linker hash table. */
673 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
674 ((struct mips_elf_link_hash_entry *) \
675 elf_link_hash_lookup (&(table)->root, (string), (create), \
678 /* Traverse a MIPS ELF linker hash table. */
680 #define mips_elf_link_hash_traverse(table, func, info) \
681 (elf_link_hash_traverse \
683 (bfd_boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
686 /* Get the MIPS ELF linker hash table from a link_info structure. */
688 #define mips_elf_hash_table(p) \
689 ((struct mips_elf_link_hash_table *) ((p)->hash))
691 /* Create an entry in a MIPS ELF linker hash table. */
693 static struct bfd_hash_entry
*
694 mips_elf_link_hash_newfunc (entry
, table
, string
)
695 struct bfd_hash_entry
*entry
;
696 struct bfd_hash_table
*table
;
699 struct mips_elf_link_hash_entry
*ret
=
700 (struct mips_elf_link_hash_entry
*) entry
;
702 /* Allocate the structure if it has not already been allocated by a
704 if (ret
== (struct mips_elf_link_hash_entry
*) NULL
)
705 ret
= ((struct mips_elf_link_hash_entry
*)
706 bfd_hash_allocate (table
,
707 sizeof (struct mips_elf_link_hash_entry
)));
708 if (ret
== (struct mips_elf_link_hash_entry
*) NULL
)
709 return (struct bfd_hash_entry
*) ret
;
711 /* Call the allocation method of the superclass. */
712 ret
= ((struct mips_elf_link_hash_entry
*)
713 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
715 if (ret
!= (struct mips_elf_link_hash_entry
*) NULL
)
717 /* Set local fields. */
718 memset (&ret
->esym
, 0, sizeof (EXTR
));
719 /* We use -2 as a marker to indicate that the information has
720 not been set. -1 means there is no associated ifd. */
722 ret
->possibly_dynamic_relocs
= 0;
723 ret
->readonly_reloc
= FALSE
;
724 ret
->no_fn_stub
= FALSE
;
726 ret
->need_fn_stub
= FALSE
;
727 ret
->call_stub
= NULL
;
728 ret
->call_fp_stub
= NULL
;
729 ret
->forced_local
= FALSE
;
732 return (struct bfd_hash_entry
*) ret
;
736 _bfd_mips_elf_new_section_hook (abfd
, sec
)
740 struct _mips_elf_section_data
*sdata
;
741 bfd_size_type amt
= sizeof (*sdata
);
743 sdata
= (struct _mips_elf_section_data
*) bfd_zalloc (abfd
, amt
);
746 sec
->used_by_bfd
= (PTR
) sdata
;
748 return _bfd_elf_new_section_hook (abfd
, sec
);
751 /* Read ECOFF debugging information from a .mdebug section into a
752 ecoff_debug_info structure. */
755 _bfd_mips_elf_read_ecoff_info (abfd
, section
, debug
)
758 struct ecoff_debug_info
*debug
;
761 const struct ecoff_debug_swap
*swap
;
762 char *ext_hdr
= NULL
;
764 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
765 memset (debug
, 0, sizeof (*debug
));
767 ext_hdr
= (char *) bfd_malloc (swap
->external_hdr_size
);
768 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
771 if (! bfd_get_section_contents (abfd
, section
, ext_hdr
, (file_ptr
) 0,
772 swap
->external_hdr_size
))
775 symhdr
= &debug
->symbolic_header
;
776 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
778 /* The symbolic header contains absolute file offsets and sizes to
780 #define READ(ptr, offset, count, size, type) \
781 if (symhdr->count == 0) \
785 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
786 debug->ptr = (type) bfd_malloc (amt); \
787 if (debug->ptr == NULL) \
789 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
790 || bfd_bread (debug->ptr, amt, abfd) != amt) \
794 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
795 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, PTR
);
796 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, PTR
);
797 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, PTR
);
798 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, PTR
);
799 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
801 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
802 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
803 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, PTR
);
804 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, PTR
);
805 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, PTR
);
809 debug
->adjust
= NULL
;
816 if (debug
->line
!= NULL
)
818 if (debug
->external_dnr
!= NULL
)
819 free (debug
->external_dnr
);
820 if (debug
->external_pdr
!= NULL
)
821 free (debug
->external_pdr
);
822 if (debug
->external_sym
!= NULL
)
823 free (debug
->external_sym
);
824 if (debug
->external_opt
!= NULL
)
825 free (debug
->external_opt
);
826 if (debug
->external_aux
!= NULL
)
827 free (debug
->external_aux
);
828 if (debug
->ss
!= NULL
)
830 if (debug
->ssext
!= NULL
)
832 if (debug
->external_fdr
!= NULL
)
833 free (debug
->external_fdr
);
834 if (debug
->external_rfd
!= NULL
)
835 free (debug
->external_rfd
);
836 if (debug
->external_ext
!= NULL
)
837 free (debug
->external_ext
);
841 /* Swap RPDR (runtime procedure table entry) for output. */
844 ecoff_swap_rpdr_out (abfd
, in
, ex
)
849 H_PUT_S32 (abfd
, in
->adr
, ex
->p_adr
);
850 H_PUT_32 (abfd
, in
->regmask
, ex
->p_regmask
);
851 H_PUT_32 (abfd
, in
->regoffset
, ex
->p_regoffset
);
852 H_PUT_32 (abfd
, in
->fregmask
, ex
->p_fregmask
);
853 H_PUT_32 (abfd
, in
->fregoffset
, ex
->p_fregoffset
);
854 H_PUT_32 (abfd
, in
->frameoffset
, ex
->p_frameoffset
);
856 H_PUT_16 (abfd
, in
->framereg
, ex
->p_framereg
);
857 H_PUT_16 (abfd
, in
->pcreg
, ex
->p_pcreg
);
859 H_PUT_32 (abfd
, in
->irpss
, ex
->p_irpss
);
861 H_PUT_S32 (abfd
, in
->exception_info
, ex
->p_exception_info
);
865 /* Create a runtime procedure table from the .mdebug section. */
868 mips_elf_create_procedure_table (handle
, abfd
, info
, s
, debug
)
871 struct bfd_link_info
*info
;
873 struct ecoff_debug_info
*debug
;
875 const struct ecoff_debug_swap
*swap
;
876 HDRR
*hdr
= &debug
->symbolic_header
;
878 struct rpdr_ext
*erp
;
880 struct pdr_ext
*epdr
;
881 struct sym_ext
*esym
;
886 unsigned long sindex
;
890 const char *no_name_func
= _("static procedure (no name)");
898 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
900 sindex
= strlen (no_name_func
) + 1;
904 size
= swap
->external_pdr_size
;
906 epdr
= (struct pdr_ext
*) bfd_malloc (size
* count
);
910 if (! _bfd_ecoff_get_accumulated_pdr (handle
, (PTR
) epdr
))
913 size
= sizeof (RPDR
);
914 rp
= rpdr
= (RPDR
*) bfd_malloc (size
* count
);
918 size
= sizeof (char *);
919 sv
= (char **) bfd_malloc (size
* count
);
923 count
= hdr
->isymMax
;
924 size
= swap
->external_sym_size
;
925 esym
= (struct sym_ext
*) bfd_malloc (size
* count
);
929 if (! _bfd_ecoff_get_accumulated_sym (handle
, (PTR
) esym
))
933 ss
= (char *) bfd_malloc (count
);
936 if (! _bfd_ecoff_get_accumulated_ss (handle
, (PTR
) ss
))
940 for (i
= 0; i
< (unsigned long) count
; i
++, rp
++)
942 (*swap
->swap_pdr_in
) (abfd
, (PTR
) (epdr
+ i
), &pdr
);
943 (*swap
->swap_sym_in
) (abfd
, (PTR
) &esym
[pdr
.isym
], &sym
);
945 rp
->regmask
= pdr
.regmask
;
946 rp
->regoffset
= pdr
.regoffset
;
947 rp
->fregmask
= pdr
.fregmask
;
948 rp
->fregoffset
= pdr
.fregoffset
;
949 rp
->frameoffset
= pdr
.frameoffset
;
950 rp
->framereg
= pdr
.framereg
;
951 rp
->pcreg
= pdr
.pcreg
;
953 sv
[i
] = ss
+ sym
.iss
;
954 sindex
+= strlen (sv
[i
]) + 1;
958 size
= sizeof (struct rpdr_ext
) * (count
+ 2) + sindex
;
959 size
= BFD_ALIGN (size
, 16);
960 rtproc
= (PTR
) bfd_alloc (abfd
, size
);
963 mips_elf_hash_table (info
)->procedure_count
= 0;
967 mips_elf_hash_table (info
)->procedure_count
= count
+ 2;
969 erp
= (struct rpdr_ext
*) rtproc
;
970 memset (erp
, 0, sizeof (struct rpdr_ext
));
972 str
= (char *) rtproc
+ sizeof (struct rpdr_ext
) * (count
+ 2);
973 strcpy (str
, no_name_func
);
974 str
+= strlen (no_name_func
) + 1;
975 for (i
= 0; i
< count
; i
++)
977 ecoff_swap_rpdr_out (abfd
, rpdr
+ i
, erp
+ i
);
979 str
+= strlen (sv
[i
]) + 1;
981 H_PUT_S32 (abfd
, -1, (erp
+ count
)->p_adr
);
983 /* Set the size and contents of .rtproc section. */
985 s
->contents
= (bfd_byte
*) rtproc
;
987 /* Skip this section later on (I don't think this currently
988 matters, but someday it might). */
989 s
->link_order_head
= (struct bfd_link_order
*) NULL
;
1018 /* Check the mips16 stubs for a particular symbol, and see if we can
1022 mips_elf_check_mips16_stubs (h
, data
)
1023 struct mips_elf_link_hash_entry
*h
;
1024 PTR data ATTRIBUTE_UNUSED
;
1026 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1027 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1029 if (h
->fn_stub
!= NULL
1030 && ! h
->need_fn_stub
)
1032 /* We don't need the fn_stub; the only references to this symbol
1033 are 16 bit calls. Clobber the size to 0 to prevent it from
1034 being included in the link. */
1035 h
->fn_stub
->_raw_size
= 0;
1036 h
->fn_stub
->_cooked_size
= 0;
1037 h
->fn_stub
->flags
&= ~SEC_RELOC
;
1038 h
->fn_stub
->reloc_count
= 0;
1039 h
->fn_stub
->flags
|= SEC_EXCLUDE
;
1042 if (h
->call_stub
!= NULL
1043 && h
->root
.other
== STO_MIPS16
)
1045 /* We don't need the call_stub; this is a 16 bit function, so
1046 calls from other 16 bit functions are OK. Clobber the size
1047 to 0 to prevent it from being included in the link. */
1048 h
->call_stub
->_raw_size
= 0;
1049 h
->call_stub
->_cooked_size
= 0;
1050 h
->call_stub
->flags
&= ~SEC_RELOC
;
1051 h
->call_stub
->reloc_count
= 0;
1052 h
->call_stub
->flags
|= SEC_EXCLUDE
;
1055 if (h
->call_fp_stub
!= NULL
1056 && h
->root
.other
== STO_MIPS16
)
1058 /* We don't need the call_stub; this is a 16 bit function, so
1059 calls from other 16 bit functions are OK. Clobber the size
1060 to 0 to prevent it from being included in the link. */
1061 h
->call_fp_stub
->_raw_size
= 0;
1062 h
->call_fp_stub
->_cooked_size
= 0;
1063 h
->call_fp_stub
->flags
&= ~SEC_RELOC
;
1064 h
->call_fp_stub
->reloc_count
= 0;
1065 h
->call_fp_stub
->flags
|= SEC_EXCLUDE
;
1071 bfd_reloc_status_type
1072 _bfd_mips_elf_gprel16_with_gp (abfd
, symbol
, reloc_entry
, input_section
,
1073 relocatable
, data
, gp
)
1076 arelent
*reloc_entry
;
1077 asection
*input_section
;
1078 bfd_boolean relocatable
;
1083 unsigned long insn
= 0;
1086 if (bfd_is_com_section (symbol
->section
))
1089 relocation
= symbol
->value
;
1091 relocation
+= symbol
->section
->output_section
->vma
;
1092 relocation
+= symbol
->section
->output_offset
;
1094 if (reloc_entry
->address
> input_section
->_cooked_size
)
1095 return bfd_reloc_outofrange
;
1097 /* Set val to the offset into the section or symbol. */
1098 val
= reloc_entry
->addend
;
1100 if (reloc_entry
->howto
->partial_inplace
)
1102 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1103 val
+= insn
& 0xffff;
1106 _bfd_mips_elf_sign_extend(val
, 16);
1108 /* Adjust val for the final section location and GP value. If we
1109 are producing relocatable output, we don't want to do this for
1110 an external symbol. */
1112 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1113 val
+= relocation
- gp
;
1115 if (reloc_entry
->howto
->partial_inplace
)
1117 insn
= (insn
& ~0xffff) | (val
& 0xffff);
1118 bfd_put_32 (abfd
, (bfd_vma
) insn
,
1119 (bfd_byte
*) data
+ reloc_entry
->address
);
1122 reloc_entry
->addend
= val
;
1125 reloc_entry
->address
+= input_section
->output_offset
;
1126 else if (((val
& ~0xffff) != ~0xffff) && ((val
& ~0xffff) != 0))
1127 return bfd_reloc_overflow
;
1129 return bfd_reloc_ok
;
1132 /* Swap an entry in a .gptab section. Note that these routines rely
1133 on the equivalence of the two elements of the union. */
1136 bfd_mips_elf32_swap_gptab_in (abfd
, ex
, in
)
1138 const Elf32_External_gptab
*ex
;
1141 in
->gt_entry
.gt_g_value
= H_GET_32 (abfd
, ex
->gt_entry
.gt_g_value
);
1142 in
->gt_entry
.gt_bytes
= H_GET_32 (abfd
, ex
->gt_entry
.gt_bytes
);
1146 bfd_mips_elf32_swap_gptab_out (abfd
, in
, ex
)
1148 const Elf32_gptab
*in
;
1149 Elf32_External_gptab
*ex
;
1151 H_PUT_32 (abfd
, in
->gt_entry
.gt_g_value
, ex
->gt_entry
.gt_g_value
);
1152 H_PUT_32 (abfd
, in
->gt_entry
.gt_bytes
, ex
->gt_entry
.gt_bytes
);
1156 bfd_elf32_swap_compact_rel_out (abfd
, in
, ex
)
1158 const Elf32_compact_rel
*in
;
1159 Elf32_External_compact_rel
*ex
;
1161 H_PUT_32 (abfd
, in
->id1
, ex
->id1
);
1162 H_PUT_32 (abfd
, in
->num
, ex
->num
);
1163 H_PUT_32 (abfd
, in
->id2
, ex
->id2
);
1164 H_PUT_32 (abfd
, in
->offset
, ex
->offset
);
1165 H_PUT_32 (abfd
, in
->reserved0
, ex
->reserved0
);
1166 H_PUT_32 (abfd
, in
->reserved1
, ex
->reserved1
);
1170 bfd_elf32_swap_crinfo_out (abfd
, in
, ex
)
1172 const Elf32_crinfo
*in
;
1173 Elf32_External_crinfo
*ex
;
1177 l
= (((in
->ctype
& CRINFO_CTYPE
) << CRINFO_CTYPE_SH
)
1178 | ((in
->rtype
& CRINFO_RTYPE
) << CRINFO_RTYPE_SH
)
1179 | ((in
->dist2to
& CRINFO_DIST2TO
) << CRINFO_DIST2TO_SH
)
1180 | ((in
->relvaddr
& CRINFO_RELVADDR
) << CRINFO_RELVADDR_SH
));
1181 H_PUT_32 (abfd
, l
, ex
->info
);
1182 H_PUT_32 (abfd
, in
->konst
, ex
->konst
);
1183 H_PUT_32 (abfd
, in
->vaddr
, ex
->vaddr
);
1186 /* A .reginfo section holds a single Elf32_RegInfo structure. These
1187 routines swap this structure in and out. They are used outside of
1188 BFD, so they are globally visible. */
1191 bfd_mips_elf32_swap_reginfo_in (abfd
, ex
, in
)
1193 const Elf32_External_RegInfo
*ex
;
1196 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1197 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1198 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1199 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1200 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1201 in
->ri_gp_value
= H_GET_32 (abfd
, ex
->ri_gp_value
);
1205 bfd_mips_elf32_swap_reginfo_out (abfd
, in
, ex
)
1207 const Elf32_RegInfo
*in
;
1208 Elf32_External_RegInfo
*ex
;
1210 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1211 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1212 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1213 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1214 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1215 H_PUT_32 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1218 /* In the 64 bit ABI, the .MIPS.options section holds register
1219 information in an Elf64_Reginfo structure. These routines swap
1220 them in and out. They are globally visible because they are used
1221 outside of BFD. These routines are here so that gas can call them
1222 without worrying about whether the 64 bit ABI has been included. */
1225 bfd_mips_elf64_swap_reginfo_in (abfd
, ex
, in
)
1227 const Elf64_External_RegInfo
*ex
;
1228 Elf64_Internal_RegInfo
*in
;
1230 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1231 in
->ri_pad
= H_GET_32 (abfd
, ex
->ri_pad
);
1232 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1233 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1234 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1235 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1236 in
->ri_gp_value
= H_GET_64 (abfd
, ex
->ri_gp_value
);
1240 bfd_mips_elf64_swap_reginfo_out (abfd
, in
, ex
)
1242 const Elf64_Internal_RegInfo
*in
;
1243 Elf64_External_RegInfo
*ex
;
1245 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1246 H_PUT_32 (abfd
, in
->ri_pad
, ex
->ri_pad
);
1247 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1248 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1249 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1250 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1251 H_PUT_64 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1254 /* Swap in an options header. */
1257 bfd_mips_elf_swap_options_in (abfd
, ex
, in
)
1259 const Elf_External_Options
*ex
;
1260 Elf_Internal_Options
*in
;
1262 in
->kind
= H_GET_8 (abfd
, ex
->kind
);
1263 in
->size
= H_GET_8 (abfd
, ex
->size
);
1264 in
->section
= H_GET_16 (abfd
, ex
->section
);
1265 in
->info
= H_GET_32 (abfd
, ex
->info
);
1268 /* Swap out an options header. */
1271 bfd_mips_elf_swap_options_out (abfd
, in
, ex
)
1273 const Elf_Internal_Options
*in
;
1274 Elf_External_Options
*ex
;
1276 H_PUT_8 (abfd
, in
->kind
, ex
->kind
);
1277 H_PUT_8 (abfd
, in
->size
, ex
->size
);
1278 H_PUT_16 (abfd
, in
->section
, ex
->section
);
1279 H_PUT_32 (abfd
, in
->info
, ex
->info
);
1282 /* This function is called via qsort() to sort the dynamic relocation
1283 entries by increasing r_symndx value. */
1286 sort_dynamic_relocs (arg1
, arg2
)
1290 Elf_Internal_Rela int_reloc1
;
1291 Elf_Internal_Rela int_reloc2
;
1293 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg1
, &int_reloc1
);
1294 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg2
, &int_reloc2
);
1296 return ELF32_R_SYM (int_reloc1
.r_info
) - ELF32_R_SYM (int_reloc2
.r_info
);
1299 /* Like sort_dynamic_relocs, but used for elf64 relocations. */
1302 sort_dynamic_relocs_64 (arg1
, arg2
)
1306 Elf_Internal_Rela int_reloc1
[3];
1307 Elf_Internal_Rela int_reloc2
[3];
1309 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1310 (reldyn_sorting_bfd
, arg1
, int_reloc1
);
1311 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1312 (reldyn_sorting_bfd
, arg2
, int_reloc2
);
1314 return (ELF64_R_SYM (int_reloc1
[0].r_info
)
1315 - ELF64_R_SYM (int_reloc2
[0].r_info
));
1319 /* This routine is used to write out ECOFF debugging external symbol
1320 information. It is called via mips_elf_link_hash_traverse. The
1321 ECOFF external symbol information must match the ELF external
1322 symbol information. Unfortunately, at this point we don't know
1323 whether a symbol is required by reloc information, so the two
1324 tables may wind up being different. We must sort out the external
1325 symbol information before we can set the final size of the .mdebug
1326 section, and we must set the size of the .mdebug section before we
1327 can relocate any sections, and we can't know which symbols are
1328 required by relocation until we relocate the sections.
1329 Fortunately, it is relatively unlikely that any symbol will be
1330 stripped but required by a reloc. In particular, it can not happen
1331 when generating a final executable. */
1334 mips_elf_output_extsym (h
, data
)
1335 struct mips_elf_link_hash_entry
*h
;
1338 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
1340 asection
*sec
, *output_section
;
1342 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1343 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1345 if (h
->root
.indx
== -2)
1347 else if (((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1348 || (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
1349 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1350 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
1352 else if (einfo
->info
->strip
== strip_all
1353 || (einfo
->info
->strip
== strip_some
1354 && bfd_hash_lookup (einfo
->info
->keep_hash
,
1355 h
->root
.root
.root
.string
,
1356 FALSE
, FALSE
) == NULL
))
1364 if (h
->esym
.ifd
== -2)
1367 h
->esym
.cobol_main
= 0;
1368 h
->esym
.weakext
= 0;
1369 h
->esym
.reserved
= 0;
1370 h
->esym
.ifd
= ifdNil
;
1371 h
->esym
.asym
.value
= 0;
1372 h
->esym
.asym
.st
= stGlobal
;
1374 if (h
->root
.root
.type
== bfd_link_hash_undefined
1375 || h
->root
.root
.type
== bfd_link_hash_undefweak
)
1379 /* Use undefined class. Also, set class and type for some
1381 name
= h
->root
.root
.root
.string
;
1382 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
1383 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
1385 h
->esym
.asym
.sc
= scData
;
1386 h
->esym
.asym
.st
= stLabel
;
1387 h
->esym
.asym
.value
= 0;
1389 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
1391 h
->esym
.asym
.sc
= scAbs
;
1392 h
->esym
.asym
.st
= stLabel
;
1393 h
->esym
.asym
.value
=
1394 mips_elf_hash_table (einfo
->info
)->procedure_count
;
1396 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (einfo
->abfd
))
1398 h
->esym
.asym
.sc
= scAbs
;
1399 h
->esym
.asym
.st
= stLabel
;
1400 h
->esym
.asym
.value
= elf_gp (einfo
->abfd
);
1403 h
->esym
.asym
.sc
= scUndefined
;
1405 else if (h
->root
.root
.type
!= bfd_link_hash_defined
1406 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
1407 h
->esym
.asym
.sc
= scAbs
;
1412 sec
= h
->root
.root
.u
.def
.section
;
1413 output_section
= sec
->output_section
;
1415 /* When making a shared library and symbol h is the one from
1416 the another shared library, OUTPUT_SECTION may be null. */
1417 if (output_section
== NULL
)
1418 h
->esym
.asym
.sc
= scUndefined
;
1421 name
= bfd_section_name (output_section
->owner
, output_section
);
1423 if (strcmp (name
, ".text") == 0)
1424 h
->esym
.asym
.sc
= scText
;
1425 else if (strcmp (name
, ".data") == 0)
1426 h
->esym
.asym
.sc
= scData
;
1427 else if (strcmp (name
, ".sdata") == 0)
1428 h
->esym
.asym
.sc
= scSData
;
1429 else if (strcmp (name
, ".rodata") == 0
1430 || strcmp (name
, ".rdata") == 0)
1431 h
->esym
.asym
.sc
= scRData
;
1432 else if (strcmp (name
, ".bss") == 0)
1433 h
->esym
.asym
.sc
= scBss
;
1434 else if (strcmp (name
, ".sbss") == 0)
1435 h
->esym
.asym
.sc
= scSBss
;
1436 else if (strcmp (name
, ".init") == 0)
1437 h
->esym
.asym
.sc
= scInit
;
1438 else if (strcmp (name
, ".fini") == 0)
1439 h
->esym
.asym
.sc
= scFini
;
1441 h
->esym
.asym
.sc
= scAbs
;
1445 h
->esym
.asym
.reserved
= 0;
1446 h
->esym
.asym
.index
= indexNil
;
1449 if (h
->root
.root
.type
== bfd_link_hash_common
)
1450 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
1451 else if (h
->root
.root
.type
== bfd_link_hash_defined
1452 || h
->root
.root
.type
== bfd_link_hash_defweak
)
1454 if (h
->esym
.asym
.sc
== scCommon
)
1455 h
->esym
.asym
.sc
= scBss
;
1456 else if (h
->esym
.asym
.sc
== scSCommon
)
1457 h
->esym
.asym
.sc
= scSBss
;
1459 sec
= h
->root
.root
.u
.def
.section
;
1460 output_section
= sec
->output_section
;
1461 if (output_section
!= NULL
)
1462 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
1463 + sec
->output_offset
1464 + output_section
->vma
);
1466 h
->esym
.asym
.value
= 0;
1468 else if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
1470 struct mips_elf_link_hash_entry
*hd
= h
;
1471 bfd_boolean no_fn_stub
= h
->no_fn_stub
;
1473 while (hd
->root
.root
.type
== bfd_link_hash_indirect
)
1475 hd
= (struct mips_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
1476 no_fn_stub
= no_fn_stub
|| hd
->no_fn_stub
;
1481 /* Set type and value for a symbol with a function stub. */
1482 h
->esym
.asym
.st
= stProc
;
1483 sec
= hd
->root
.root
.u
.def
.section
;
1485 h
->esym
.asym
.value
= 0;
1488 output_section
= sec
->output_section
;
1489 if (output_section
!= NULL
)
1490 h
->esym
.asym
.value
= (hd
->root
.plt
.offset
1491 + sec
->output_offset
1492 + output_section
->vma
);
1494 h
->esym
.asym
.value
= 0;
1502 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
1503 h
->root
.root
.root
.string
,
1506 einfo
->failed
= TRUE
;
1513 /* A comparison routine used to sort .gptab entries. */
1516 gptab_compare (p1
, p2
)
1520 const Elf32_gptab
*a1
= (const Elf32_gptab
*) p1
;
1521 const Elf32_gptab
*a2
= (const Elf32_gptab
*) p2
;
1523 return a1
->gt_entry
.gt_g_value
- a2
->gt_entry
.gt_g_value
;
1526 /* Functions to manage the got entry hash table. */
1528 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
1531 static INLINE hashval_t
1532 mips_elf_hash_bfd_vma (addr
)
1536 return addr
+ (addr
>> 32);
1542 /* got_entries only match if they're identical, except for gotidx, so
1543 use all fields to compute the hash, and compare the appropriate
1547 mips_elf_got_entry_hash (entry_
)
1550 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
1552 return entry
->symndx
1553 + (! entry
->abfd
? mips_elf_hash_bfd_vma (entry
->d
.address
)
1555 + (entry
->symndx
>= 0 ? mips_elf_hash_bfd_vma (entry
->d
.addend
)
1556 : entry
->d
.h
->root
.root
.root
.hash
));
1560 mips_elf_got_entry_eq (entry1
, entry2
)
1564 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
1565 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
1567 return e1
->abfd
== e2
->abfd
&& e1
->symndx
== e2
->symndx
1568 && (! e1
->abfd
? e1
->d
.address
== e2
->d
.address
1569 : e1
->symndx
>= 0 ? e1
->d
.addend
== e2
->d
.addend
1570 : e1
->d
.h
== e2
->d
.h
);
1573 /* multi_got_entries are still a match in the case of global objects,
1574 even if the input bfd in which they're referenced differs, so the
1575 hash computation and compare functions are adjusted
1579 mips_elf_multi_got_entry_hash (entry_
)
1582 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
1584 return entry
->symndx
1586 ? mips_elf_hash_bfd_vma (entry
->d
.address
)
1587 : entry
->symndx
>= 0
1589 + mips_elf_hash_bfd_vma (entry
->d
.addend
))
1590 : entry
->d
.h
->root
.root
.root
.hash
);
1594 mips_elf_multi_got_entry_eq (entry1
, entry2
)
1598 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
1599 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
1601 return e1
->symndx
== e2
->symndx
1602 && (e1
->symndx
>= 0 ? e1
->abfd
== e2
->abfd
&& e1
->d
.addend
== e2
->d
.addend
1603 : e1
->abfd
== NULL
|| e2
->abfd
== NULL
1604 ? e1
->abfd
== e2
->abfd
&& e1
->d
.address
== e2
->d
.address
1605 : e1
->d
.h
== e2
->d
.h
);
1608 /* Returns the dynamic relocation section for DYNOBJ. */
1611 mips_elf_rel_dyn_section (dynobj
, create_p
)
1613 bfd_boolean create_p
;
1615 static const char dname
[] = ".rel.dyn";
1618 sreloc
= bfd_get_section_by_name (dynobj
, dname
);
1619 if (sreloc
== NULL
&& create_p
)
1621 sreloc
= bfd_make_section (dynobj
, dname
);
1623 || ! bfd_set_section_flags (dynobj
, sreloc
,
1628 | SEC_LINKER_CREATED
1630 || ! bfd_set_section_alignment (dynobj
, sreloc
,
1631 MIPS_ELF_LOG_FILE_ALIGN (dynobj
)))
1637 /* Returns the GOT section for ABFD. */
1640 mips_elf_got_section (abfd
, maybe_excluded
)
1642 bfd_boolean maybe_excluded
;
1644 asection
*sgot
= bfd_get_section_by_name (abfd
, ".got");
1646 || (! maybe_excluded
&& (sgot
->flags
& SEC_EXCLUDE
) != 0))
1651 /* Returns the GOT information associated with the link indicated by
1652 INFO. If SGOTP is non-NULL, it is filled in with the GOT
1655 static struct mips_got_info
*
1656 mips_elf_got_info (abfd
, sgotp
)
1661 struct mips_got_info
*g
;
1663 sgot
= mips_elf_got_section (abfd
, TRUE
);
1664 BFD_ASSERT (sgot
!= NULL
);
1665 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
1666 g
= mips_elf_section_data (sgot
)->u
.got_info
;
1667 BFD_ASSERT (g
!= NULL
);
1670 *sgotp
= (sgot
->flags
& SEC_EXCLUDE
) == 0 ? sgot
: NULL
;
1675 /* Obtain the lowest dynamic index of a symbol that was assigned a
1676 global GOT entry. */
1678 mips_elf_get_global_gotsym_index (abfd
)
1682 struct mips_got_info
*g
;
1687 sgot
= mips_elf_got_section (abfd
, TRUE
);
1688 if (sgot
== NULL
|| mips_elf_section_data (sgot
) == NULL
)
1691 g
= mips_elf_section_data (sgot
)->u
.got_info
;
1692 if (g
== NULL
|| g
->global_gotsym
== NULL
)
1695 return g
->global_gotsym
->dynindx
;
1698 /* Returns the GOT offset at which the indicated address can be found.
1699 If there is not yet a GOT entry for this value, create one. Returns
1700 -1 if no satisfactory GOT offset can be found. */
1703 mips_elf_local_got_index (abfd
, ibfd
, info
, value
)
1705 struct bfd_link_info
*info
;
1709 struct mips_got_info
*g
;
1710 struct mips_got_entry
*entry
;
1712 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1714 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
, value
);
1716 return entry
->gotidx
;
1721 /* Returns the GOT index for the global symbol indicated by H. */
1724 mips_elf_global_got_index (abfd
, ibfd
, h
)
1726 struct elf_link_hash_entry
*h
;
1730 struct mips_got_info
*g
, *gg
;
1731 long global_got_dynindx
= 0;
1733 gg
= g
= mips_elf_got_info (abfd
, &sgot
);
1734 if (g
->bfd2got
&& ibfd
)
1736 struct mips_got_entry e
, *p
;
1738 BFD_ASSERT (h
->dynindx
>= 0);
1740 g
= mips_elf_got_for_ibfd (g
, ibfd
);
1745 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
1747 p
= (struct mips_got_entry
*) htab_find (g
->got_entries
, &e
);
1749 BFD_ASSERT (p
->gotidx
> 0);
1754 if (gg
->global_gotsym
!= NULL
)
1755 global_got_dynindx
= gg
->global_gotsym
->dynindx
;
1757 /* Once we determine the global GOT entry with the lowest dynamic
1758 symbol table index, we must put all dynamic symbols with greater
1759 indices into the GOT. That makes it easy to calculate the GOT
1761 BFD_ASSERT (h
->dynindx
>= global_got_dynindx
);
1762 index
= ((h
->dynindx
- global_got_dynindx
+ g
->local_gotno
)
1763 * MIPS_ELF_GOT_SIZE (abfd
));
1764 BFD_ASSERT (index
< sgot
->_raw_size
);
1769 /* Find a GOT entry that is within 32KB of the VALUE. These entries
1770 are supposed to be placed at small offsets in the GOT, i.e.,
1771 within 32KB of GP. Return the index into the GOT for this page,
1772 and store the offset from this entry to the desired address in
1773 OFFSETP, if it is non-NULL. */
1776 mips_elf_got_page (abfd
, ibfd
, info
, value
, offsetp
)
1778 struct bfd_link_info
*info
;
1783 struct mips_got_info
*g
;
1785 struct mips_got_entry
*entry
;
1787 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1789 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
,
1791 & (~(bfd_vma
)0xffff));
1796 index
= entry
->gotidx
;
1799 *offsetp
= value
- entry
->d
.address
;
1804 /* Find a GOT entry whose higher-order 16 bits are the same as those
1805 for value. Return the index into the GOT for this entry. */
1808 mips_elf_got16_entry (abfd
, ibfd
, info
, value
, external
)
1810 struct bfd_link_info
*info
;
1812 bfd_boolean external
;
1815 struct mips_got_info
*g
;
1816 struct mips_got_entry
*entry
;
1820 /* Although the ABI says that it is "the high-order 16 bits" that we
1821 want, it is really the %high value. The complete value is
1822 calculated with a `addiu' of a LO16 relocation, just as with a
1824 value
= mips_elf_high (value
) << 16;
1827 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1829 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
, value
);
1831 return entry
->gotidx
;
1836 /* Returns the offset for the entry at the INDEXth position
1840 mips_elf_got_offset_from_index (dynobj
, output_bfd
, input_bfd
, index
)
1848 struct mips_got_info
*g
;
1850 g
= mips_elf_got_info (dynobj
, &sgot
);
1851 gp
= _bfd_get_gp_value (output_bfd
)
1852 + mips_elf_adjust_gp (output_bfd
, g
, input_bfd
);
1854 return sgot
->output_section
->vma
+ sgot
->output_offset
+ index
- gp
;
1857 /* Create a local GOT entry for VALUE. Return the index of the entry,
1858 or -1 if it could not be created. */
1860 static struct mips_got_entry
*
1861 mips_elf_create_local_got_entry (abfd
, ibfd
, gg
, sgot
, value
)
1863 struct mips_got_info
*gg
;
1867 struct mips_got_entry entry
, **loc
;
1868 struct mips_got_info
*g
;
1872 entry
.d
.address
= value
;
1874 g
= mips_elf_got_for_ibfd (gg
, ibfd
);
1877 g
= mips_elf_got_for_ibfd (gg
, abfd
);
1878 BFD_ASSERT (g
!= NULL
);
1881 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
1886 entry
.gotidx
= MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
++;
1888 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
1893 memcpy (*loc
, &entry
, sizeof entry
);
1895 if (g
->assigned_gotno
>= g
->local_gotno
)
1897 (*loc
)->gotidx
= -1;
1898 /* We didn't allocate enough space in the GOT. */
1899 (*_bfd_error_handler
)
1900 (_("not enough GOT space for local GOT entries"));
1901 bfd_set_error (bfd_error_bad_value
);
1905 MIPS_ELF_PUT_WORD (abfd
, value
,
1906 (sgot
->contents
+ entry
.gotidx
));
1911 /* Sort the dynamic symbol table so that symbols that need GOT entries
1912 appear towards the end. This reduces the amount of GOT space
1913 required. MAX_LOCAL is used to set the number of local symbols
1914 known to be in the dynamic symbol table. During
1915 _bfd_mips_elf_size_dynamic_sections, this value is 1. Afterward, the
1916 section symbols are added and the count is higher. */
1919 mips_elf_sort_hash_table (info
, max_local
)
1920 struct bfd_link_info
*info
;
1921 unsigned long max_local
;
1923 struct mips_elf_hash_sort_data hsd
;
1924 struct mips_got_info
*g
;
1927 dynobj
= elf_hash_table (info
)->dynobj
;
1929 g
= mips_elf_got_info (dynobj
, NULL
);
1932 hsd
.max_unref_got_dynindx
=
1933 hsd
.min_got_dynindx
= elf_hash_table (info
)->dynsymcount
1934 /* In the multi-got case, assigned_gotno of the master got_info
1935 indicate the number of entries that aren't referenced in the
1936 primary GOT, but that must have entries because there are
1937 dynamic relocations that reference it. Since they aren't
1938 referenced, we move them to the end of the GOT, so that they
1939 don't prevent other entries that are referenced from getting
1940 too large offsets. */
1941 - (g
->next
? g
->assigned_gotno
: 0);
1942 hsd
.max_non_got_dynindx
= max_local
;
1943 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table
*)
1944 elf_hash_table (info
)),
1945 mips_elf_sort_hash_table_f
,
1948 /* There should have been enough room in the symbol table to
1949 accommodate both the GOT and non-GOT symbols. */
1950 BFD_ASSERT (hsd
.max_non_got_dynindx
<= hsd
.min_got_dynindx
);
1951 BFD_ASSERT ((unsigned long)hsd
.max_unref_got_dynindx
1952 <= elf_hash_table (info
)->dynsymcount
);
1954 /* Now we know which dynamic symbol has the lowest dynamic symbol
1955 table index in the GOT. */
1956 g
->global_gotsym
= hsd
.low
;
1961 /* If H needs a GOT entry, assign it the highest available dynamic
1962 index. Otherwise, assign it the lowest available dynamic
1966 mips_elf_sort_hash_table_f (h
, data
)
1967 struct mips_elf_link_hash_entry
*h
;
1970 struct mips_elf_hash_sort_data
*hsd
1971 = (struct mips_elf_hash_sort_data
*) data
;
1973 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1974 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1976 /* Symbols without dynamic symbol table entries aren't interesting
1978 if (h
->root
.dynindx
== -1)
1981 /* Global symbols that need GOT entries that are not explicitly
1982 referenced are marked with got offset 2. Those that are
1983 referenced get a 1, and those that don't need GOT entries get
1985 if (h
->root
.got
.offset
== 2)
1987 if (hsd
->max_unref_got_dynindx
== hsd
->min_got_dynindx
)
1988 hsd
->low
= (struct elf_link_hash_entry
*) h
;
1989 h
->root
.dynindx
= hsd
->max_unref_got_dynindx
++;
1991 else if (h
->root
.got
.offset
!= 1)
1992 h
->root
.dynindx
= hsd
->max_non_got_dynindx
++;
1995 h
->root
.dynindx
= --hsd
->min_got_dynindx
;
1996 hsd
->low
= (struct elf_link_hash_entry
*) h
;
2002 /* If H is a symbol that needs a global GOT entry, but has a dynamic
2003 symbol table index lower than any we've seen to date, record it for
2007 mips_elf_record_global_got_symbol (h
, abfd
, info
, g
)
2008 struct elf_link_hash_entry
*h
;
2010 struct bfd_link_info
*info
;
2011 struct mips_got_info
*g
;
2013 struct mips_got_entry entry
, **loc
;
2015 /* A global symbol in the GOT must also be in the dynamic symbol
2017 if (h
->dynindx
== -1)
2019 switch (ELF_ST_VISIBILITY (h
->other
))
2023 _bfd_mips_elf_hide_symbol (info
, h
, TRUE
);
2026 if (!bfd_elf32_link_record_dynamic_symbol (info
, h
))
2032 entry
.d
.h
= (struct mips_elf_link_hash_entry
*) h
;
2034 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
2037 /* If we've already marked this entry as needing GOT space, we don't
2038 need to do it again. */
2042 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2048 memcpy (*loc
, &entry
, sizeof entry
);
2050 if (h
->got
.offset
!= MINUS_ONE
)
2053 /* By setting this to a value other than -1, we are indicating that
2054 there needs to be a GOT entry for H. Avoid using zero, as the
2055 generic ELF copy_indirect_symbol tests for <= 0. */
2061 /* Reserve space in G for a GOT entry containing the value of symbol
2062 SYMNDX in input bfd ABDF, plus ADDEND. */
2065 mips_elf_record_local_got_symbol (abfd
, symndx
, addend
, g
)
2069 struct mips_got_info
*g
;
2071 struct mips_got_entry entry
, **loc
;
2074 entry
.symndx
= symndx
;
2075 entry
.d
.addend
= addend
;
2076 loc
= (struct mips_got_entry
**)
2077 htab_find_slot (g
->got_entries
, &entry
, INSERT
);
2082 entry
.gotidx
= g
->local_gotno
++;
2084 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2089 memcpy (*loc
, &entry
, sizeof entry
);
2094 /* Compute the hash value of the bfd in a bfd2got hash entry. */
2097 mips_elf_bfd2got_entry_hash (entry_
)
2100 const struct mips_elf_bfd2got_hash
*entry
2101 = (struct mips_elf_bfd2got_hash
*)entry_
;
2103 return entry
->bfd
->id
;
2106 /* Check whether two hash entries have the same bfd. */
2109 mips_elf_bfd2got_entry_eq (entry1
, entry2
)
2113 const struct mips_elf_bfd2got_hash
*e1
2114 = (const struct mips_elf_bfd2got_hash
*)entry1
;
2115 const struct mips_elf_bfd2got_hash
*e2
2116 = (const struct mips_elf_bfd2got_hash
*)entry2
;
2118 return e1
->bfd
== e2
->bfd
;
2121 /* In a multi-got link, determine the GOT to be used for IBDF. G must
2122 be the master GOT data. */
2124 static struct mips_got_info
*
2125 mips_elf_got_for_ibfd (g
, ibfd
)
2126 struct mips_got_info
*g
;
2129 struct mips_elf_bfd2got_hash e
, *p
;
2135 p
= (struct mips_elf_bfd2got_hash
*) htab_find (g
->bfd2got
, &e
);
2136 return p
? p
->g
: NULL
;
2139 /* Create one separate got for each bfd that has entries in the global
2140 got, such that we can tell how many local and global entries each
2144 mips_elf_make_got_per_bfd (entryp
, p
)
2148 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2149 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
2150 htab_t bfd2got
= arg
->bfd2got
;
2151 struct mips_got_info
*g
;
2152 struct mips_elf_bfd2got_hash bfdgot_entry
, *bfdgot
;
2155 /* Find the got_info for this GOT entry's input bfd. Create one if
2157 bfdgot_entry
.bfd
= entry
->abfd
;
2158 bfdgotp
= htab_find_slot (bfd2got
, &bfdgot_entry
, INSERT
);
2159 bfdgot
= (struct mips_elf_bfd2got_hash
*)*bfdgotp
;
2165 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
2166 (arg
->obfd
, sizeof (struct mips_elf_bfd2got_hash
));
2176 bfdgot
->bfd
= entry
->abfd
;
2177 bfdgot
->g
= g
= (struct mips_got_info
*)
2178 bfd_alloc (arg
->obfd
, sizeof (struct mips_got_info
));
2185 g
->global_gotsym
= NULL
;
2186 g
->global_gotno
= 0;
2188 g
->assigned_gotno
= -1;
2189 g
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
2190 mips_elf_multi_got_entry_eq
,
2192 if (g
->got_entries
== NULL
)
2202 /* Insert the GOT entry in the bfd's got entry hash table. */
2203 entryp
= htab_find_slot (g
->got_entries
, entry
, INSERT
);
2204 if (*entryp
!= NULL
)
2209 if (entry
->symndx
>= 0 || entry
->d
.h
->forced_local
)
2217 /* Attempt to merge gots of different input bfds. Try to use as much
2218 as possible of the primary got, since it doesn't require explicit
2219 dynamic relocations, but don't use bfds that would reference global
2220 symbols out of the addressable range. Failing the primary got,
2221 attempt to merge with the current got, or finish the current got
2222 and then make make the new got current. */
2225 mips_elf_merge_gots (bfd2got_
, p
)
2229 struct mips_elf_bfd2got_hash
*bfd2got
2230 = (struct mips_elf_bfd2got_hash
*)*bfd2got_
;
2231 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
2232 unsigned int lcount
= bfd2got
->g
->local_gotno
;
2233 unsigned int gcount
= bfd2got
->g
->global_gotno
;
2234 unsigned int maxcnt
= arg
->max_count
;
2236 /* If we don't have a primary GOT and this is not too big, use it as
2237 a starting point for the primary GOT. */
2238 if (! arg
->primary
&& lcount
+ gcount
<= maxcnt
)
2240 arg
->primary
= bfd2got
->g
;
2241 arg
->primary_count
= lcount
+ gcount
;
2243 /* If it looks like we can merge this bfd's entries with those of
2244 the primary, merge them. The heuristics is conservative, but we
2245 don't have to squeeze it too hard. */
2246 else if (arg
->primary
2247 && (arg
->primary_count
+ lcount
+ gcount
) <= maxcnt
)
2249 struct mips_got_info
*g
= bfd2got
->g
;
2250 int old_lcount
= arg
->primary
->local_gotno
;
2251 int old_gcount
= arg
->primary
->global_gotno
;
2253 bfd2got
->g
= arg
->primary
;
2255 htab_traverse (g
->got_entries
,
2256 mips_elf_make_got_per_bfd
,
2258 if (arg
->obfd
== NULL
)
2261 htab_delete (g
->got_entries
);
2262 /* We don't have to worry about releasing memory of the actual
2263 got entries, since they're all in the master got_entries hash
2266 BFD_ASSERT (old_lcount
+ lcount
== arg
->primary
->local_gotno
);
2267 BFD_ASSERT (old_gcount
+ gcount
>= arg
->primary
->global_gotno
);
2269 arg
->primary_count
= arg
->primary
->local_gotno
2270 + arg
->primary
->global_gotno
;
2272 /* If we can merge with the last-created got, do it. */
2273 else if (arg
->current
2274 && arg
->current_count
+ lcount
+ gcount
<= maxcnt
)
2276 struct mips_got_info
*g
= bfd2got
->g
;
2277 int old_lcount
= arg
->current
->local_gotno
;
2278 int old_gcount
= arg
->current
->global_gotno
;
2280 bfd2got
->g
= arg
->current
;
2282 htab_traverse (g
->got_entries
,
2283 mips_elf_make_got_per_bfd
,
2285 if (arg
->obfd
== NULL
)
2288 htab_delete (g
->got_entries
);
2290 BFD_ASSERT (old_lcount
+ lcount
== arg
->current
->local_gotno
);
2291 BFD_ASSERT (old_gcount
+ gcount
>= arg
->current
->global_gotno
);
2293 arg
->current_count
= arg
->current
->local_gotno
2294 + arg
->current
->global_gotno
;
2296 /* Well, we couldn't merge, so create a new GOT. Don't check if it
2297 fits; if it turns out that it doesn't, we'll get relocation
2298 overflows anyway. */
2301 bfd2got
->g
->next
= arg
->current
;
2302 arg
->current
= bfd2got
->g
;
2304 arg
->current_count
= lcount
+ gcount
;
2310 /* If passed a NULL mips_got_info in the argument, set the marker used
2311 to tell whether a global symbol needs a got entry (in the primary
2312 got) to the given VALUE.
2314 If passed a pointer G to a mips_got_info in the argument (it must
2315 not be the primary GOT), compute the offset from the beginning of
2316 the (primary) GOT section to the entry in G corresponding to the
2317 global symbol. G's assigned_gotno must contain the index of the
2318 first available global GOT entry in G. VALUE must contain the size
2319 of a GOT entry in bytes. For each global GOT entry that requires a
2320 dynamic relocation, NEEDED_RELOCS is incremented, and the symbol is
2321 marked as not elligible for lazy resolution through a function
2324 mips_elf_set_global_got_offset (entryp
, p
)
2328 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2329 struct mips_elf_set_global_got_offset_arg
*arg
2330 = (struct mips_elf_set_global_got_offset_arg
*)p
;
2331 struct mips_got_info
*g
= arg
->g
;
2333 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1
2334 && entry
->d
.h
->root
.dynindx
!= -1)
2338 BFD_ASSERT (g
->global_gotsym
== NULL
);
2340 entry
->gotidx
= arg
->value
* (long) g
->assigned_gotno
++;
2341 /* We can't do lazy update of GOT entries for
2342 non-primary GOTs since the PLT entries don't use the
2343 right offsets, so punt at it for now. */
2344 entry
->d
.h
->no_fn_stub
= TRUE
;
2345 if (arg
->info
->shared
2346 || (elf_hash_table (arg
->info
)->dynamic_sections_created
2347 && ((entry
->d
.h
->root
.elf_link_hash_flags
2348 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0)
2349 && ((entry
->d
.h
->root
.elf_link_hash_flags
2350 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
2351 ++arg
->needed_relocs
;
2354 entry
->d
.h
->root
.got
.offset
= arg
->value
;
2360 /* Follow indirect and warning hash entries so that each got entry
2361 points to the final symbol definition. P must point to a pointer
2362 to the hash table we're traversing. Since this traversal may
2363 modify the hash table, we set this pointer to NULL to indicate
2364 we've made a potentially-destructive change to the hash table, so
2365 the traversal must be restarted. */
2367 mips_elf_resolve_final_got_entry (entryp
, p
)
2371 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2372 htab_t got_entries
= *(htab_t
*)p
;
2374 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1)
2376 struct mips_elf_link_hash_entry
*h
= entry
->d
.h
;
2378 while (h
->root
.root
.type
== bfd_link_hash_indirect
2379 || h
->root
.root
.type
== bfd_link_hash_warning
)
2380 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2382 if (entry
->d
.h
== h
)
2387 /* If we can't find this entry with the new bfd hash, re-insert
2388 it, and get the traversal restarted. */
2389 if (! htab_find (got_entries
, entry
))
2391 htab_clear_slot (got_entries
, entryp
);
2392 entryp
= htab_find_slot (got_entries
, entry
, INSERT
);
2395 /* Abort the traversal, since the whole table may have
2396 moved, and leave it up to the parent to restart the
2398 *(htab_t
*)p
= NULL
;
2401 /* We might want to decrement the global_gotno count, but it's
2402 either too early or too late for that at this point. */
2408 /* Turn indirect got entries in a got_entries table into their final
2411 mips_elf_resolve_final_got_entries (g
)
2412 struct mips_got_info
*g
;
2418 got_entries
= g
->got_entries
;
2420 htab_traverse (got_entries
,
2421 mips_elf_resolve_final_got_entry
,
2424 while (got_entries
== NULL
);
2427 /* Return the offset of an input bfd IBFD's GOT from the beginning of
2430 mips_elf_adjust_gp (abfd
, g
, ibfd
)
2432 struct mips_got_info
*g
;
2435 if (g
->bfd2got
== NULL
)
2438 g
= mips_elf_got_for_ibfd (g
, ibfd
);
2442 BFD_ASSERT (g
->next
);
2446 return (g
->local_gotno
+ g
->global_gotno
) * MIPS_ELF_GOT_SIZE (abfd
);
2449 /* Turn a single GOT that is too big for 16-bit addressing into
2450 a sequence of GOTs, each one 16-bit addressable. */
2453 mips_elf_multi_got (abfd
, info
, g
, got
, pages
)
2455 struct bfd_link_info
*info
;
2456 struct mips_got_info
*g
;
2458 bfd_size_type pages
;
2460 struct mips_elf_got_per_bfd_arg got_per_bfd_arg
;
2461 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
2462 struct mips_got_info
*gg
;
2463 unsigned int assign
;
2465 g
->bfd2got
= htab_try_create (1, mips_elf_bfd2got_entry_hash
,
2466 mips_elf_bfd2got_entry_eq
,
2468 if (g
->bfd2got
== NULL
)
2471 got_per_bfd_arg
.bfd2got
= g
->bfd2got
;
2472 got_per_bfd_arg
.obfd
= abfd
;
2473 got_per_bfd_arg
.info
= info
;
2475 /* Count how many GOT entries each input bfd requires, creating a
2476 map from bfd to got info while at that. */
2477 mips_elf_resolve_final_got_entries (g
);
2478 htab_traverse (g
->got_entries
, mips_elf_make_got_per_bfd
, &got_per_bfd_arg
);
2479 if (got_per_bfd_arg
.obfd
== NULL
)
2482 got_per_bfd_arg
.current
= NULL
;
2483 got_per_bfd_arg
.primary
= NULL
;
2484 /* Taking out PAGES entries is a worst-case estimate. We could
2485 compute the maximum number of pages that each separate input bfd
2486 uses, but it's probably not worth it. */
2487 got_per_bfd_arg
.max_count
= ((MIPS_ELF_GOT_MAX_SIZE (abfd
)
2488 / MIPS_ELF_GOT_SIZE (abfd
))
2489 - MIPS_RESERVED_GOTNO
- pages
);
2491 /* Try to merge the GOTs of input bfds together, as long as they
2492 don't seem to exceed the maximum GOT size, choosing one of them
2493 to be the primary GOT. */
2494 htab_traverse (g
->bfd2got
, mips_elf_merge_gots
, &got_per_bfd_arg
);
2495 if (got_per_bfd_arg
.obfd
== NULL
)
2498 /* If we find any suitable primary GOT, create an empty one. */
2499 if (got_per_bfd_arg
.primary
== NULL
)
2501 g
->next
= (struct mips_got_info
*)
2502 bfd_alloc (abfd
, sizeof (struct mips_got_info
));
2503 if (g
->next
== NULL
)
2506 g
->next
->global_gotsym
= NULL
;
2507 g
->next
->global_gotno
= 0;
2508 g
->next
->local_gotno
= 0;
2509 g
->next
->assigned_gotno
= 0;
2510 g
->next
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
2511 mips_elf_multi_got_entry_eq
,
2513 if (g
->next
->got_entries
== NULL
)
2515 g
->next
->bfd2got
= NULL
;
2518 g
->next
= got_per_bfd_arg
.primary
;
2519 g
->next
->next
= got_per_bfd_arg
.current
;
2521 /* GG is now the master GOT, and G is the primary GOT. */
2525 /* Map the output bfd to the primary got. That's what we're going
2526 to use for bfds that use GOT16 or GOT_PAGE relocations that we
2527 didn't mark in check_relocs, and we want a quick way to find it.
2528 We can't just use gg->next because we're going to reverse the
2531 struct mips_elf_bfd2got_hash
*bfdgot
;
2534 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
2535 (abfd
, sizeof (struct mips_elf_bfd2got_hash
));
2542 bfdgotp
= htab_find_slot (gg
->bfd2got
, bfdgot
, INSERT
);
2544 BFD_ASSERT (*bfdgotp
== NULL
);
2548 /* The IRIX dynamic linker requires every symbol that is referenced
2549 in a dynamic relocation to be present in the primary GOT, so
2550 arrange for them to appear after those that are actually
2553 GNU/Linux could very well do without it, but it would slow down
2554 the dynamic linker, since it would have to resolve every dynamic
2555 symbol referenced in other GOTs more than once, without help from
2556 the cache. Also, knowing that every external symbol has a GOT
2557 helps speed up the resolution of local symbols too, so GNU/Linux
2558 follows IRIX's practice.
2560 The number 2 is used by mips_elf_sort_hash_table_f to count
2561 global GOT symbols that are unreferenced in the primary GOT, with
2562 an initial dynamic index computed from gg->assigned_gotno, where
2563 the number of unreferenced global entries in the primary GOT is
2567 gg
->assigned_gotno
= gg
->global_gotno
- g
->global_gotno
;
2568 g
->global_gotno
= gg
->global_gotno
;
2569 set_got_offset_arg
.value
= 2;
2573 /* This could be used for dynamic linkers that don't optimize
2574 symbol resolution while applying relocations so as to use
2575 primary GOT entries or assuming the symbol is locally-defined.
2576 With this code, we assign lower dynamic indices to global
2577 symbols that are not referenced in the primary GOT, so that
2578 their entries can be omitted. */
2579 gg
->assigned_gotno
= 0;
2580 set_got_offset_arg
.value
= -1;
2583 /* Reorder dynamic symbols as described above (which behavior
2584 depends on the setting of VALUE). */
2585 set_got_offset_arg
.g
= NULL
;
2586 htab_traverse (gg
->got_entries
, mips_elf_set_global_got_offset
,
2587 &set_got_offset_arg
);
2588 set_got_offset_arg
.value
= 1;
2589 htab_traverse (g
->got_entries
, mips_elf_set_global_got_offset
,
2590 &set_got_offset_arg
);
2591 if (! mips_elf_sort_hash_table (info
, 1))
2594 /* Now go through the GOTs assigning them offset ranges.
2595 [assigned_gotno, local_gotno[ will be set to the range of local
2596 entries in each GOT. We can then compute the end of a GOT by
2597 adding local_gotno to global_gotno. We reverse the list and make
2598 it circular since then we'll be able to quickly compute the
2599 beginning of a GOT, by computing the end of its predecessor. To
2600 avoid special cases for the primary GOT, while still preserving
2601 assertions that are valid for both single- and multi-got links,
2602 we arrange for the main got struct to have the right number of
2603 global entries, but set its local_gotno such that the initial
2604 offset of the primary GOT is zero. Remember that the primary GOT
2605 will become the last item in the circular linked list, so it
2606 points back to the master GOT. */
2607 gg
->local_gotno
= -g
->global_gotno
;
2608 gg
->global_gotno
= g
->global_gotno
;
2614 struct mips_got_info
*gn
;
2616 assign
+= MIPS_RESERVED_GOTNO
;
2617 g
->assigned_gotno
= assign
;
2618 g
->local_gotno
+= assign
+ pages
;
2619 assign
= g
->local_gotno
+ g
->global_gotno
;
2621 /* Take g out of the direct list, and push it onto the reversed
2622 list that gg points to. */
2630 got
->_raw_size
= (gg
->next
->local_gotno
2631 + gg
->next
->global_gotno
) * MIPS_ELF_GOT_SIZE (abfd
);
2637 /* Returns the first relocation of type r_type found, beginning with
2638 RELOCATION. RELEND is one-past-the-end of the relocation table. */
2640 static const Elf_Internal_Rela
*
2641 mips_elf_next_relocation (abfd
, r_type
, relocation
, relend
)
2642 bfd
*abfd ATTRIBUTE_UNUSED
;
2643 unsigned int r_type
;
2644 const Elf_Internal_Rela
*relocation
;
2645 const Elf_Internal_Rela
*relend
;
2647 /* According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must be
2648 immediately following. However, for the IRIX6 ABI, the next
2649 relocation may be a composed relocation consisting of several
2650 relocations for the same address. In that case, the R_MIPS_LO16
2651 relocation may occur as one of these. We permit a similar
2652 extension in general, as that is useful for GCC. */
2653 while (relocation
< relend
)
2655 if (ELF_R_TYPE (abfd
, relocation
->r_info
) == r_type
)
2661 /* We didn't find it. */
2662 bfd_set_error (bfd_error_bad_value
);
2666 /* Return whether a relocation is against a local symbol. */
2669 mips_elf_local_relocation_p (input_bfd
, relocation
, local_sections
,
2672 const Elf_Internal_Rela
*relocation
;
2673 asection
**local_sections
;
2674 bfd_boolean check_forced
;
2676 unsigned long r_symndx
;
2677 Elf_Internal_Shdr
*symtab_hdr
;
2678 struct mips_elf_link_hash_entry
*h
;
2681 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
2682 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2683 extsymoff
= (elf_bad_symtab (input_bfd
)) ? 0 : symtab_hdr
->sh_info
;
2685 if (r_symndx
< extsymoff
)
2687 if (elf_bad_symtab (input_bfd
) && local_sections
[r_symndx
] != NULL
)
2692 /* Look up the hash table to check whether the symbol
2693 was forced local. */
2694 h
= (struct mips_elf_link_hash_entry
*)
2695 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
];
2696 /* Find the real hash-table entry for this symbol. */
2697 while (h
->root
.root
.type
== bfd_link_hash_indirect
2698 || h
->root
.root
.type
== bfd_link_hash_warning
)
2699 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2700 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0)
2707 /* Sign-extend VALUE, which has the indicated number of BITS. */
2710 _bfd_mips_elf_sign_extend (value
, bits
)
2714 if (value
& ((bfd_vma
) 1 << (bits
- 1)))
2715 /* VALUE is negative. */
2716 value
|= ((bfd_vma
) - 1) << bits
;
2721 /* Return non-zero if the indicated VALUE has overflowed the maximum
2722 range expressable by a signed number with the indicated number of
2726 mips_elf_overflow_p (value
, bits
)
2730 bfd_signed_vma svalue
= (bfd_signed_vma
) value
;
2732 if (svalue
> (1 << (bits
- 1)) - 1)
2733 /* The value is too big. */
2735 else if (svalue
< -(1 << (bits
- 1)))
2736 /* The value is too small. */
2743 /* Calculate the %high function. */
2746 mips_elf_high (value
)
2749 return ((value
+ (bfd_vma
) 0x8000) >> 16) & 0xffff;
2752 /* Calculate the %higher function. */
2755 mips_elf_higher (value
)
2756 bfd_vma value ATTRIBUTE_UNUSED
;
2759 return ((value
+ (bfd_vma
) 0x80008000) >> 32) & 0xffff;
2762 return (bfd_vma
) -1;
2766 /* Calculate the %highest function. */
2769 mips_elf_highest (value
)
2770 bfd_vma value ATTRIBUTE_UNUSED
;
2773 return ((value
+ (((bfd_vma
) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
2776 return (bfd_vma
) -1;
2780 /* Create the .compact_rel section. */
2783 mips_elf_create_compact_rel_section (abfd
, info
)
2785 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2788 register asection
*s
;
2790 if (bfd_get_section_by_name (abfd
, ".compact_rel") == NULL
)
2792 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
2795 s
= bfd_make_section (abfd
, ".compact_rel");
2797 || ! bfd_set_section_flags (abfd
, s
, flags
)
2798 || ! bfd_set_section_alignment (abfd
, s
,
2799 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
2802 s
->_raw_size
= sizeof (Elf32_External_compact_rel
);
2808 /* Create the .got section to hold the global offset table. */
2811 mips_elf_create_got_section (abfd
, info
, maybe_exclude
)
2813 struct bfd_link_info
*info
;
2814 bfd_boolean maybe_exclude
;
2817 register asection
*s
;
2818 struct elf_link_hash_entry
*h
;
2819 struct bfd_link_hash_entry
*bh
;
2820 struct mips_got_info
*g
;
2823 /* This function may be called more than once. */
2824 s
= mips_elf_got_section (abfd
, TRUE
);
2827 if (! maybe_exclude
)
2828 s
->flags
&= ~SEC_EXCLUDE
;
2832 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2833 | SEC_LINKER_CREATED
);
2836 flags
|= SEC_EXCLUDE
;
2838 /* We have to use an alignment of 2**4 here because this is hardcoded
2839 in the function stub generation and in the linker script. */
2840 s
= bfd_make_section (abfd
, ".got");
2842 || ! bfd_set_section_flags (abfd
, s
, flags
)
2843 || ! bfd_set_section_alignment (abfd
, s
, 4))
2846 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
2847 linker script because we don't want to define the symbol if we
2848 are not creating a global offset table. */
2850 if (! (_bfd_generic_link_add_one_symbol
2851 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
2852 (bfd_vma
) 0, (const char *) NULL
, FALSE
,
2853 get_elf_backend_data (abfd
)->collect
, &bh
)))
2856 h
= (struct elf_link_hash_entry
*) bh
;
2857 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
2858 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2859 h
->type
= STT_OBJECT
;
2862 && ! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2865 amt
= sizeof (struct mips_got_info
);
2866 g
= (struct mips_got_info
*) bfd_alloc (abfd
, amt
);
2869 g
->global_gotsym
= NULL
;
2870 g
->local_gotno
= MIPS_RESERVED_GOTNO
;
2871 g
->assigned_gotno
= MIPS_RESERVED_GOTNO
;
2874 g
->got_entries
= htab_try_create (1, mips_elf_got_entry_hash
,
2875 mips_elf_got_entry_eq
,
2877 if (g
->got_entries
== NULL
)
2879 mips_elf_section_data (s
)->u
.got_info
= g
;
2880 mips_elf_section_data (s
)->elf
.this_hdr
.sh_flags
2881 |= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
2886 /* Calculate the value produced by the RELOCATION (which comes from
2887 the INPUT_BFD). The ADDEND is the addend to use for this
2888 RELOCATION; RELOCATION->R_ADDEND is ignored.
2890 The result of the relocation calculation is stored in VALUEP.
2891 REQUIRE_JALXP indicates whether or not the opcode used with this
2892 relocation must be JALX.
2894 This function returns bfd_reloc_continue if the caller need take no
2895 further action regarding this relocation, bfd_reloc_notsupported if
2896 something goes dramatically wrong, bfd_reloc_overflow if an
2897 overflow occurs, and bfd_reloc_ok to indicate success. */
2899 static bfd_reloc_status_type
2900 mips_elf_calculate_relocation (abfd
, input_bfd
, input_section
, info
,
2901 relocation
, addend
, howto
, local_syms
,
2902 local_sections
, valuep
, namep
,
2903 require_jalxp
, save_addend
)
2906 asection
*input_section
;
2907 struct bfd_link_info
*info
;
2908 const Elf_Internal_Rela
*relocation
;
2910 reloc_howto_type
*howto
;
2911 Elf_Internal_Sym
*local_syms
;
2912 asection
**local_sections
;
2915 bfd_boolean
*require_jalxp
;
2916 bfd_boolean save_addend
;
2918 /* The eventual value we will return. */
2920 /* The address of the symbol against which the relocation is
2923 /* The final GP value to be used for the relocatable, executable, or
2924 shared object file being produced. */
2925 bfd_vma gp
= MINUS_ONE
;
2926 /* The place (section offset or address) of the storage unit being
2929 /* The value of GP used to create the relocatable object. */
2930 bfd_vma gp0
= MINUS_ONE
;
2931 /* The offset into the global offset table at which the address of
2932 the relocation entry symbol, adjusted by the addend, resides
2933 during execution. */
2934 bfd_vma g
= MINUS_ONE
;
2935 /* The section in which the symbol referenced by the relocation is
2937 asection
*sec
= NULL
;
2938 struct mips_elf_link_hash_entry
*h
= NULL
;
2939 /* TRUE if the symbol referred to by this relocation is a local
2941 bfd_boolean local_p
, was_local_p
;
2942 /* TRUE if the symbol referred to by this relocation is "_gp_disp". */
2943 bfd_boolean gp_disp_p
= FALSE
;
2944 Elf_Internal_Shdr
*symtab_hdr
;
2946 unsigned long r_symndx
;
2948 /* TRUE if overflow occurred during the calculation of the
2949 relocation value. */
2950 bfd_boolean overflowed_p
;
2951 /* TRUE if this relocation refers to a MIPS16 function. */
2952 bfd_boolean target_is_16_bit_code_p
= FALSE
;
2954 /* Parse the relocation. */
2955 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
2956 r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
2957 p
= (input_section
->output_section
->vma
2958 + input_section
->output_offset
2959 + relocation
->r_offset
);
2961 /* Assume that there will be no overflow. */
2962 overflowed_p
= FALSE
;
2964 /* Figure out whether or not the symbol is local, and get the offset
2965 used in the array of hash table entries. */
2966 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2967 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
2968 local_sections
, FALSE
);
2969 was_local_p
= local_p
;
2970 if (! elf_bad_symtab (input_bfd
))
2971 extsymoff
= symtab_hdr
->sh_info
;
2974 /* The symbol table does not follow the rule that local symbols
2975 must come before globals. */
2979 /* Figure out the value of the symbol. */
2982 Elf_Internal_Sym
*sym
;
2984 sym
= local_syms
+ r_symndx
;
2985 sec
= local_sections
[r_symndx
];
2987 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
2988 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
2989 || (sec
->flags
& SEC_MERGE
))
2990 symbol
+= sym
->st_value
;
2991 if ((sec
->flags
& SEC_MERGE
)
2992 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2994 addend
= _bfd_elf_rel_local_sym (abfd
, sym
, &sec
, addend
);
2996 addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
2999 /* MIPS16 text labels should be treated as odd. */
3000 if (sym
->st_other
== STO_MIPS16
)
3003 /* Record the name of this symbol, for our caller. */
3004 *namep
= bfd_elf_string_from_elf_section (input_bfd
,
3005 symtab_hdr
->sh_link
,
3008 *namep
= bfd_section_name (input_bfd
, sec
);
3010 target_is_16_bit_code_p
= (sym
->st_other
== STO_MIPS16
);
3014 /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ? */
3016 /* For global symbols we look up the symbol in the hash-table. */
3017 h
= ((struct mips_elf_link_hash_entry
*)
3018 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
]);
3019 /* Find the real hash-table entry for this symbol. */
3020 while (h
->root
.root
.type
== bfd_link_hash_indirect
3021 || h
->root
.root
.type
== bfd_link_hash_warning
)
3022 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3024 /* Record the name of this symbol, for our caller. */
3025 *namep
= h
->root
.root
.root
.string
;
3027 /* See if this is the special _gp_disp symbol. Note that such a
3028 symbol must always be a global symbol. */
3029 if (strcmp (*namep
, "_gp_disp") == 0
3030 && ! NEWABI_P (input_bfd
))
3032 /* Relocations against _gp_disp are permitted only with
3033 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
3034 if (r_type
!= R_MIPS_HI16
&& r_type
!= R_MIPS_LO16
)
3035 return bfd_reloc_notsupported
;
3039 /* If this symbol is defined, calculate its address. Note that
3040 _gp_disp is a magic symbol, always implicitly defined by the
3041 linker, so it's inappropriate to check to see whether or not
3043 else if ((h
->root
.root
.type
== bfd_link_hash_defined
3044 || h
->root
.root
.type
== bfd_link_hash_defweak
)
3045 && h
->root
.root
.u
.def
.section
)
3047 sec
= h
->root
.root
.u
.def
.section
;
3048 if (sec
->output_section
)
3049 symbol
= (h
->root
.root
.u
.def
.value
3050 + sec
->output_section
->vma
3051 + sec
->output_offset
);
3053 symbol
= h
->root
.root
.u
.def
.value
;
3055 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
3056 /* We allow relocations against undefined weak symbols, giving
3057 it the value zero, so that you can undefined weak functions
3058 and check to see if they exist by looking at their
3061 else if (info
->shared
3062 && info
->unresolved_syms_in_objects
== RM_IGNORE
3063 && ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
3065 else if (strcmp (*namep
, "_DYNAMIC_LINK") == 0 ||
3066 strcmp (*namep
, "_DYNAMIC_LINKING") == 0)
3068 /* If this is a dynamic link, we should have created a
3069 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
3070 in in _bfd_mips_elf_create_dynamic_sections.
3071 Otherwise, we should define the symbol with a value of 0.
3072 FIXME: It should probably get into the symbol table
3074 BFD_ASSERT (! info
->shared
);
3075 BFD_ASSERT (bfd_get_section_by_name (abfd
, ".dynamic") == NULL
);
3080 if (! ((*info
->callbacks
->undefined_symbol
)
3081 (info
, h
->root
.root
.root
.string
, input_bfd
,
3082 input_section
, relocation
->r_offset
,
3083 ((info
->shared
&& info
->unresolved_syms_in_shared_libs
== RM_GENERATE_ERROR
)
3084 || (!info
->shared
&& info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
)
3085 || ELF_ST_VISIBILITY (h
->root
.other
)))))
3086 return bfd_reloc_undefined
;
3090 target_is_16_bit_code_p
= (h
->root
.other
== STO_MIPS16
);
3093 /* If this is a 32- or 64-bit call to a 16-bit function with a stub, we
3094 need to redirect the call to the stub, unless we're already *in*
3096 if (r_type
!= R_MIPS16_26
&& !info
->relocatable
3097 && ((h
!= NULL
&& h
->fn_stub
!= NULL
)
3098 || (local_p
&& elf_tdata (input_bfd
)->local_stubs
!= NULL
3099 && elf_tdata (input_bfd
)->local_stubs
[r_symndx
] != NULL
))
3100 && !mips_elf_stub_section_p (input_bfd
, input_section
))
3102 /* This is a 32- or 64-bit call to a 16-bit function. We should
3103 have already noticed that we were going to need the
3106 sec
= elf_tdata (input_bfd
)->local_stubs
[r_symndx
];
3109 BFD_ASSERT (h
->need_fn_stub
);
3113 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3115 /* If this is a 16-bit call to a 32- or 64-bit function with a stub, we
3116 need to redirect the call to the stub. */
3117 else if (r_type
== R_MIPS16_26
&& !info
->relocatable
3119 && (h
->call_stub
!= NULL
|| h
->call_fp_stub
!= NULL
)
3120 && !target_is_16_bit_code_p
)
3122 /* If both call_stub and call_fp_stub are defined, we can figure
3123 out which one to use by seeing which one appears in the input
3125 if (h
->call_stub
!= NULL
&& h
->call_fp_stub
!= NULL
)
3130 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
3132 if (strncmp (bfd_get_section_name (input_bfd
, o
),
3133 CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
3135 sec
= h
->call_fp_stub
;
3142 else if (h
->call_stub
!= NULL
)
3145 sec
= h
->call_fp_stub
;
3147 BFD_ASSERT (sec
->_raw_size
> 0);
3148 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3151 /* Calls from 16-bit code to 32-bit code and vice versa require the
3152 special jalx instruction. */
3153 *require_jalxp
= (!info
->relocatable
3154 && (((r_type
== R_MIPS16_26
) && !target_is_16_bit_code_p
)
3155 || ((r_type
== R_MIPS_26
) && target_is_16_bit_code_p
)));
3157 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
3158 local_sections
, TRUE
);
3160 /* If we haven't already determined the GOT offset, or the GP value,
3161 and we're going to need it, get it now. */
3164 case R_MIPS_GOT_PAGE
:
3165 case R_MIPS_GOT_OFST
:
3166 /* If this symbol got a global GOT entry, we have to decay
3167 GOT_PAGE/GOT_OFST to GOT_DISP/addend. */
3168 local_p
= local_p
|| ! h
3170 < mips_elf_get_global_gotsym_index (elf_hash_table (info
)
3172 if (local_p
|| r_type
== R_MIPS_GOT_OFST
)
3178 case R_MIPS_GOT_DISP
:
3179 case R_MIPS_GOT_HI16
:
3180 case R_MIPS_CALL_HI16
:
3181 case R_MIPS_GOT_LO16
:
3182 case R_MIPS_CALL_LO16
:
3183 /* Find the index into the GOT where this value is located. */
3186 /* GOT_PAGE may take a non-zero addend, that is ignored in a
3187 GOT_PAGE relocation that decays to GOT_DISP because the
3188 symbol turns out to be global. The addend is then added
3190 BFD_ASSERT (addend
== 0 || r_type
== R_MIPS_GOT_PAGE
);
3191 g
= mips_elf_global_got_index (elf_hash_table (info
)->dynobj
,
3193 (struct elf_link_hash_entry
*) h
);
3194 if (! elf_hash_table(info
)->dynamic_sections_created
3196 && (info
->symbolic
|| h
->root
.dynindx
== -1)
3197 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
3199 /* This is a static link or a -Bsymbolic link. The
3200 symbol is defined locally, or was forced to be local.
3201 We must initialize this entry in the GOT. */
3202 bfd
*tmpbfd
= elf_hash_table (info
)->dynobj
;
3203 asection
*sgot
= mips_elf_got_section (tmpbfd
, FALSE
);
3204 MIPS_ELF_PUT_WORD (tmpbfd
, symbol
, sgot
->contents
+ g
);
3207 else if (r_type
== R_MIPS_GOT16
|| r_type
== R_MIPS_CALL16
)
3208 /* There's no need to create a local GOT entry here; the
3209 calculation for a local GOT16 entry does not involve G. */
3213 g
= mips_elf_local_got_index (abfd
, input_bfd
,
3214 info
, symbol
+ addend
);
3216 return bfd_reloc_outofrange
;
3219 /* Convert GOT indices to actual offsets. */
3220 g
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3221 abfd
, input_bfd
, g
);
3226 case R_MIPS16_GPREL
:
3227 case R_MIPS_GPREL16
:
3228 case R_MIPS_GPREL32
:
3229 case R_MIPS_LITERAL
:
3230 gp0
= _bfd_get_gp_value (input_bfd
);
3231 gp
= _bfd_get_gp_value (abfd
);
3232 if (elf_hash_table (info
)->dynobj
)
3233 gp
+= mips_elf_adjust_gp (abfd
,
3235 (elf_hash_table (info
)->dynobj
, NULL
),
3243 /* Figure out what kind of relocation is being performed. */
3247 return bfd_reloc_continue
;
3250 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 16);
3251 overflowed_p
= mips_elf_overflow_p (value
, 16);
3258 || (elf_hash_table (info
)->dynamic_sections_created
3260 && ((h
->root
.elf_link_hash_flags
3261 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0)
3262 && ((h
->root
.elf_link_hash_flags
3263 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
3265 && (input_section
->flags
& SEC_ALLOC
) != 0)
3267 /* If we're creating a shared library, or this relocation is
3268 against a symbol in a shared library, then we can't know
3269 where the symbol will end up. So, we create a relocation
3270 record in the output, and leave the job up to the dynamic
3273 if (!mips_elf_create_dynamic_relocation (abfd
,
3281 return bfd_reloc_undefined
;
3285 if (r_type
!= R_MIPS_REL32
)
3286 value
= symbol
+ addend
;
3290 value
&= howto
->dst_mask
;
3295 case R_MIPS_GNU_REL_LO16
:
3296 value
= symbol
+ addend
- p
;
3297 value
&= howto
->dst_mask
;
3300 case R_MIPS_GNU_REL16_S2
:
3301 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
<< 2, 18) - p
;
3302 overflowed_p
= mips_elf_overflow_p (value
, 18);
3303 value
= (value
>> 2) & howto
->dst_mask
;
3306 case R_MIPS_GNU_REL_HI16
:
3307 /* Instead of subtracting 'p' here, we should be subtracting the
3308 equivalent value for the LO part of the reloc, since the value
3309 here is relative to that address. Because that's not easy to do,
3310 we adjust 'addend' in _bfd_mips_elf_relocate_section(). See also
3311 the comment there for more information. */
3312 value
= mips_elf_high (addend
+ symbol
- p
);
3313 value
&= howto
->dst_mask
;
3317 /* The calculation for R_MIPS16_26 is just the same as for an
3318 R_MIPS_26. It's only the storage of the relocated field into
3319 the output file that's different. That's handled in
3320 mips_elf_perform_relocation. So, we just fall through to the
3321 R_MIPS_26 case here. */
3324 value
= (((addend
<< 2) | ((p
+ 4) & 0xf0000000)) + symbol
) >> 2;
3326 value
= (_bfd_mips_elf_sign_extend (addend
<< 2, 28) + symbol
) >> 2;
3327 value
&= howto
->dst_mask
;
3333 value
= mips_elf_high (addend
+ symbol
);
3334 value
&= howto
->dst_mask
;
3338 value
= mips_elf_high (addend
+ gp
- p
);
3339 overflowed_p
= mips_elf_overflow_p (value
, 16);
3345 value
= (symbol
+ addend
) & howto
->dst_mask
;
3348 value
= addend
+ gp
- p
+ 4;
3349 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
3350 for overflow. But, on, say, IRIX5, relocations against
3351 _gp_disp are normally generated from the .cpload
3352 pseudo-op. It generates code that normally looks like
3355 lui $gp,%hi(_gp_disp)
3356 addiu $gp,$gp,%lo(_gp_disp)
3359 Here $t9 holds the address of the function being called,
3360 as required by the MIPS ELF ABI. The R_MIPS_LO16
3361 relocation can easily overflow in this situation, but the
3362 R_MIPS_HI16 relocation will handle the overflow.
3363 Therefore, we consider this a bug in the MIPS ABI, and do
3364 not check for overflow here. */
3368 case R_MIPS_LITERAL
:
3369 /* Because we don't merge literal sections, we can handle this
3370 just like R_MIPS_GPREL16. In the long run, we should merge
3371 shared literals, and then we will need to additional work
3376 case R_MIPS16_GPREL
:
3377 /* The R_MIPS16_GPREL performs the same calculation as
3378 R_MIPS_GPREL16, but stores the relocated bits in a different
3379 order. We don't need to do anything special here; the
3380 differences are handled in mips_elf_perform_relocation. */
3381 case R_MIPS_GPREL16
:
3382 /* Only sign-extend the addend if it was extracted from the
3383 instruction. If the addend was separate, leave it alone,
3384 otherwise we may lose significant bits. */
3385 if (howto
->partial_inplace
)
3386 addend
= _bfd_mips_elf_sign_extend (addend
, 16);
3387 value
= symbol
+ addend
- gp
;
3388 /* If the symbol was local, any earlier relocatable links will
3389 have adjusted its addend with the gp offset, so compensate
3390 for that now. Don't do it for symbols forced local in this
3391 link, though, since they won't have had the gp offset applied
3395 overflowed_p
= mips_elf_overflow_p (value
, 16);
3404 /* The special case is when the symbol is forced to be local. We
3405 need the full address in the GOT since no R_MIPS_LO16 relocation
3407 forced
= ! mips_elf_local_relocation_p (input_bfd
, relocation
,
3408 local_sections
, FALSE
);
3409 value
= mips_elf_got16_entry (abfd
, input_bfd
, info
,
3410 symbol
+ addend
, forced
);
3411 if (value
== MINUS_ONE
)
3412 return bfd_reloc_outofrange
;
3414 = mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3415 abfd
, input_bfd
, value
);
3416 overflowed_p
= mips_elf_overflow_p (value
, 16);
3422 case R_MIPS_GOT_DISP
:
3425 overflowed_p
= mips_elf_overflow_p (value
, 16);
3428 case R_MIPS_GPREL32
:
3429 value
= (addend
+ symbol
+ gp0
- gp
);
3431 value
&= howto
->dst_mask
;
3435 value
= _bfd_mips_elf_sign_extend (addend
, 16) + symbol
- p
;
3436 overflowed_p
= mips_elf_overflow_p (value
, 16);
3439 case R_MIPS_GOT_HI16
:
3440 case R_MIPS_CALL_HI16
:
3441 /* We're allowed to handle these two relocations identically.
3442 The dynamic linker is allowed to handle the CALL relocations
3443 differently by creating a lazy evaluation stub. */
3445 value
= mips_elf_high (value
);
3446 value
&= howto
->dst_mask
;
3449 case R_MIPS_GOT_LO16
:
3450 case R_MIPS_CALL_LO16
:
3451 value
= g
& howto
->dst_mask
;
3454 case R_MIPS_GOT_PAGE
:
3455 /* GOT_PAGE relocations that reference non-local symbols decay
3456 to GOT_DISP. The corresponding GOT_OFST relocation decays to
3460 value
= mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, NULL
);
3461 if (value
== MINUS_ONE
)
3462 return bfd_reloc_outofrange
;
3463 value
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3464 abfd
, input_bfd
, value
);
3465 overflowed_p
= mips_elf_overflow_p (value
, 16);
3468 case R_MIPS_GOT_OFST
:
3470 mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, &value
);
3473 overflowed_p
= mips_elf_overflow_p (value
, 16);
3477 value
= symbol
- addend
;
3478 value
&= howto
->dst_mask
;
3482 value
= mips_elf_higher (addend
+ symbol
);
3483 value
&= howto
->dst_mask
;
3486 case R_MIPS_HIGHEST
:
3487 value
= mips_elf_highest (addend
+ symbol
);
3488 value
&= howto
->dst_mask
;
3491 case R_MIPS_SCN_DISP
:
3492 value
= symbol
+ addend
- sec
->output_offset
;
3493 value
&= howto
->dst_mask
;
3498 /* Both of these may be ignored. R_MIPS_JALR is an optimization
3499 hint; we could improve performance by honoring that hint. */
3500 return bfd_reloc_continue
;
3502 case R_MIPS_GNU_VTINHERIT
:
3503 case R_MIPS_GNU_VTENTRY
:
3504 /* We don't do anything with these at present. */
3505 return bfd_reloc_continue
;
3508 /* An unrecognized relocation type. */
3509 return bfd_reloc_notsupported
;
3512 /* Store the VALUE for our caller. */
3514 return overflowed_p
? bfd_reloc_overflow
: bfd_reloc_ok
;
3517 /* Obtain the field relocated by RELOCATION. */
3520 mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
)
3521 reloc_howto_type
*howto
;
3522 const Elf_Internal_Rela
*relocation
;
3527 bfd_byte
*location
= contents
+ relocation
->r_offset
;
3529 /* Obtain the bytes. */
3530 x
= bfd_get ((8 * bfd_get_reloc_size (howto
)), input_bfd
, location
);
3532 if ((ELF_R_TYPE (input_bfd
, relocation
->r_info
) == R_MIPS16_26
3533 || ELF_R_TYPE (input_bfd
, relocation
->r_info
) == R_MIPS16_GPREL
)
3534 && bfd_little_endian (input_bfd
))
3535 /* The two 16-bit words will be reversed on a little-endian system.
3536 See mips_elf_perform_relocation for more details. */
3537 x
= (((x
& 0xffff) << 16) | ((x
& 0xffff0000) >> 16));
3542 /* It has been determined that the result of the RELOCATION is the
3543 VALUE. Use HOWTO to place VALUE into the output file at the
3544 appropriate position. The SECTION is the section to which the
3545 relocation applies. If REQUIRE_JALX is TRUE, then the opcode used
3546 for the relocation must be either JAL or JALX, and it is
3547 unconditionally converted to JALX.
3549 Returns FALSE if anything goes wrong. */
3552 mips_elf_perform_relocation (info
, howto
, relocation
, value
, input_bfd
,
3553 input_section
, contents
, require_jalx
)
3554 struct bfd_link_info
*info
;
3555 reloc_howto_type
*howto
;
3556 const Elf_Internal_Rela
*relocation
;
3559 asection
*input_section
;
3561 bfd_boolean require_jalx
;
3565 int r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
3567 /* Figure out where the relocation is occurring. */
3568 location
= contents
+ relocation
->r_offset
;
3570 /* Obtain the current value. */
3571 x
= mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
);
3573 /* Clear the field we are setting. */
3574 x
&= ~howto
->dst_mask
;
3576 /* If this is the R_MIPS16_26 relocation, we must store the
3577 value in a funny way. */
3578 if (r_type
== R_MIPS16_26
)
3580 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
3581 Most mips16 instructions are 16 bits, but these instructions
3584 The format of these instructions is:
3586 +--------------+--------------------------------+
3587 ! JALX ! X! Imm 20:16 ! Imm 25:21 !
3588 +--------------+--------------------------------+
3590 +-----------------------------------------------+
3592 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
3593 Note that the immediate value in the first word is swapped.
3595 When producing a relocatable object file, R_MIPS16_26 is
3596 handled mostly like R_MIPS_26. In particular, the addend is
3597 stored as a straight 26-bit value in a 32-bit instruction.
3598 (gas makes life simpler for itself by never adjusting a
3599 R_MIPS16_26 reloc to be against a section, so the addend is
3600 always zero). However, the 32 bit instruction is stored as 2
3601 16-bit values, rather than a single 32-bit value. In a
3602 big-endian file, the result is the same; in a little-endian
3603 file, the two 16-bit halves of the 32 bit value are swapped.
3604 This is so that a disassembler can recognize the jal
3607 When doing a final link, R_MIPS16_26 is treated as a 32 bit
3608 instruction stored as two 16-bit values. The addend A is the
3609 contents of the targ26 field. The calculation is the same as
3610 R_MIPS_26. When storing the calculated value, reorder the
3611 immediate value as shown above, and don't forget to store the
3612 value as two 16-bit values.
3614 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
3618 +--------+----------------------+
3622 +--------+----------------------+
3625 +----------+------+-------------+
3629 +----------+--------------------+
3630 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
3631 ((sub1 << 16) | sub2)).
3633 When producing a relocatable object file, the calculation is
3634 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
3635 When producing a fully linked file, the calculation is
3636 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
3637 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff) */
3639 if (!info
->relocatable
)
3640 /* Shuffle the bits according to the formula above. */
3641 value
= (((value
& 0x1f0000) << 5)
3642 | ((value
& 0x3e00000) >> 5)
3643 | (value
& 0xffff));
3645 else if (r_type
== R_MIPS16_GPREL
)
3647 /* R_MIPS16_GPREL is used for GP-relative addressing in mips16
3648 mode. A typical instruction will have a format like this:
3650 +--------------+--------------------------------+
3651 ! EXTEND ! Imm 10:5 ! Imm 15:11 !
3652 +--------------+--------------------------------+
3653 ! Major ! rx ! ry ! Imm 4:0 !
3654 +--------------+--------------------------------+
3656 EXTEND is the five bit value 11110. Major is the instruction
3659 This is handled exactly like R_MIPS_GPREL16, except that the
3660 addend is retrieved and stored as shown in this diagram; that
3661 is, the Imm fields above replace the V-rel16 field.
3663 All we need to do here is shuffle the bits appropriately. As
3664 above, the two 16-bit halves must be swapped on a
3665 little-endian system. */
3666 value
= (((value
& 0x7e0) << 16)
3667 | ((value
& 0xf800) << 5)
3671 /* Set the field. */
3672 x
|= (value
& howto
->dst_mask
);
3674 /* If required, turn JAL into JALX. */
3678 bfd_vma opcode
= x
>> 26;
3679 bfd_vma jalx_opcode
;
3681 /* Check to see if the opcode is already JAL or JALX. */
3682 if (r_type
== R_MIPS16_26
)
3684 ok
= ((opcode
== 0x6) || (opcode
== 0x7));
3689 ok
= ((opcode
== 0x3) || (opcode
== 0x1d));
3693 /* If the opcode is not JAL or JALX, there's a problem. */
3696 (*_bfd_error_handler
)
3697 (_("%s: %s+0x%lx: jump to stub routine which is not jal"),
3698 bfd_archive_filename (input_bfd
),
3699 input_section
->name
,
3700 (unsigned long) relocation
->r_offset
);
3701 bfd_set_error (bfd_error_bad_value
);
3705 /* Make this the JALX opcode. */
3706 x
= (x
& ~(0x3f << 26)) | (jalx_opcode
<< 26);
3709 /* Swap the high- and low-order 16 bits on little-endian systems
3710 when doing a MIPS16 relocation. */
3711 if ((r_type
== R_MIPS16_GPREL
|| r_type
== R_MIPS16_26
)
3712 && bfd_little_endian (input_bfd
))
3713 x
= (((x
& 0xffff) << 16) | ((x
& 0xffff0000) >> 16));
3715 /* Put the value into the output. */
3716 bfd_put (8 * bfd_get_reloc_size (howto
), input_bfd
, x
, location
);
3720 /* Returns TRUE if SECTION is a MIPS16 stub section. */
3723 mips_elf_stub_section_p (abfd
, section
)
3724 bfd
*abfd ATTRIBUTE_UNUSED
;
3727 const char *name
= bfd_get_section_name (abfd
, section
);
3729 return (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0
3730 || strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
3731 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0);
3734 /* Add room for N relocations to the .rel.dyn section in ABFD. */
3737 mips_elf_allocate_dynamic_relocations (abfd
, n
)
3743 s
= mips_elf_rel_dyn_section (abfd
, FALSE
);
3744 BFD_ASSERT (s
!= NULL
);
3746 if (s
->_raw_size
== 0)
3748 /* Make room for a null element. */
3749 s
->_raw_size
+= MIPS_ELF_REL_SIZE (abfd
);
3752 s
->_raw_size
+= n
* MIPS_ELF_REL_SIZE (abfd
);
3755 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
3756 is the original relocation, which is now being transformed into a
3757 dynamic relocation. The ADDENDP is adjusted if necessary; the
3758 caller should store the result in place of the original addend. */
3761 mips_elf_create_dynamic_relocation (output_bfd
, info
, rel
, h
, sec
,
3762 symbol
, addendp
, input_section
)
3764 struct bfd_link_info
*info
;
3765 const Elf_Internal_Rela
*rel
;
3766 struct mips_elf_link_hash_entry
*h
;
3770 asection
*input_section
;
3772 Elf_Internal_Rela outrel
[3];
3778 r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
3779 dynobj
= elf_hash_table (info
)->dynobj
;
3780 sreloc
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
3781 BFD_ASSERT (sreloc
!= NULL
);
3782 BFD_ASSERT (sreloc
->contents
!= NULL
);
3783 BFD_ASSERT (sreloc
->reloc_count
* MIPS_ELF_REL_SIZE (output_bfd
)
3784 < sreloc
->_raw_size
);
3787 outrel
[0].r_offset
=
3788 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[0].r_offset
);
3789 outrel
[1].r_offset
=
3790 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[1].r_offset
);
3791 outrel
[2].r_offset
=
3792 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[2].r_offset
);
3795 /* We begin by assuming that the offset for the dynamic relocation
3796 is the same as for the original relocation. We'll adjust this
3797 later to reflect the correct output offsets. */
3798 if (input_section
->sec_info_type
!= ELF_INFO_TYPE_STABS
)
3800 outrel
[1].r_offset
= rel
[1].r_offset
;
3801 outrel
[2].r_offset
= rel
[2].r_offset
;
3805 /* Except that in a stab section things are more complex.
3806 Because we compress stab information, the offset given in the
3807 relocation may not be the one we want; we must let the stabs
3808 machinery tell us the offset. */
3809 outrel
[1].r_offset
= outrel
[0].r_offset
;
3810 outrel
[2].r_offset
= outrel
[0].r_offset
;
3811 /* If we didn't need the relocation at all, this value will be
3813 if (outrel
[0].r_offset
== (bfd_vma
) -1)
3818 if (outrel
[0].r_offset
== (bfd_vma
) -1)
3819 /* The relocation field has been deleted. */
3821 else if (outrel
[0].r_offset
== (bfd_vma
) -2)
3823 /* The relocation field has been converted into a relative value of
3824 some sort. Functions like _bfd_elf_write_section_eh_frame expect
3825 the field to be fully relocated, so add in the symbol's value. */
3830 /* If we've decided to skip this relocation, just output an empty
3831 record. Note that R_MIPS_NONE == 0, so that this call to memset
3832 is a way of setting R_TYPE to R_MIPS_NONE. */
3834 memset (outrel
, 0, sizeof (Elf_Internal_Rela
) * 3);
3838 bfd_boolean defined_p
;
3840 /* We must now calculate the dynamic symbol table index to use
3841 in the relocation. */
3843 && (! info
->symbolic
|| (h
->root
.elf_link_hash_flags
3844 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
3845 /* h->root.dynindx may be -1 if this symbol was marked to
3847 && h
->root
.dynindx
!= -1)
3849 indx
= h
->root
.dynindx
;
3850 if (SGI_COMPAT (output_bfd
))
3851 defined_p
= ((h
->root
.elf_link_hash_flags
3852 & ELF_LINK_HASH_DEF_REGULAR
) != 0);
3854 /* ??? glibc's ld.so just adds the final GOT entry to the
3855 relocation field. It therefore treats relocs against
3856 defined symbols in the same way as relocs against
3857 undefined symbols. */
3862 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
3864 else if (sec
== NULL
|| sec
->owner
== NULL
)
3866 bfd_set_error (bfd_error_bad_value
);
3871 indx
= elf_section_data (sec
->output_section
)->dynindx
;
3876 /* Instead of generating a relocation using the section
3877 symbol, we may as well make it a fully relative
3878 relocation. We want to avoid generating relocations to
3879 local symbols because we used to generate them
3880 incorrectly, without adding the original symbol value,
3881 which is mandated by the ABI for section symbols. In
3882 order to give dynamic loaders and applications time to
3883 phase out the incorrect use, we refrain from emitting
3884 section-relative relocations. It's not like they're
3885 useful, after all. This should be a bit more efficient
3887 /* ??? Although this behavior is compatible with glibc's ld.so,
3888 the ABI says that relocations against STN_UNDEF should have
3889 a symbol value of 0. Irix rld honors this, so relocations
3890 against STN_UNDEF have no effect. */
3891 if (!SGI_COMPAT (output_bfd
))
3896 /* If the relocation was previously an absolute relocation and
3897 this symbol will not be referred to by the relocation, we must
3898 adjust it by the value we give it in the dynamic symbol table.
3899 Otherwise leave the job up to the dynamic linker. */
3900 if (defined_p
&& r_type
!= R_MIPS_REL32
)
3903 /* The relocation is always an REL32 relocation because we don't
3904 know where the shared library will wind up at load-time. */
3905 outrel
[0].r_info
= ELF_R_INFO (output_bfd
, (unsigned long) indx
,
3907 /* For strict adherence to the ABI specification, we should
3908 generate a R_MIPS_64 relocation record by itself before the
3909 _REL32/_64 record as well, such that the addend is read in as
3910 a 64-bit value (REL32 is a 32-bit relocation, after all).
3911 However, since none of the existing ELF64 MIPS dynamic
3912 loaders seems to care, we don't waste space with these
3913 artificial relocations. If this turns out to not be true,
3914 mips_elf_allocate_dynamic_relocation() should be tweaked so
3915 as to make room for a pair of dynamic relocations per
3916 invocation if ABI_64_P, and here we should generate an
3917 additional relocation record with R_MIPS_64 by itself for a
3918 NULL symbol before this relocation record. */
3919 outrel
[1].r_info
= ELF_R_INFO (output_bfd
, (unsigned long) 0,
3920 ABI_64_P (output_bfd
)
3923 outrel
[2].r_info
= ELF_R_INFO (output_bfd
, (unsigned long) 0,
3926 /* Adjust the output offset of the relocation to reference the
3927 correct location in the output file. */
3928 outrel
[0].r_offset
+= (input_section
->output_section
->vma
3929 + input_section
->output_offset
);
3930 outrel
[1].r_offset
+= (input_section
->output_section
->vma
3931 + input_section
->output_offset
);
3932 outrel
[2].r_offset
+= (input_section
->output_section
->vma
3933 + input_section
->output_offset
);
3936 /* Put the relocation back out. We have to use the special
3937 relocation outputter in the 64-bit case since the 64-bit
3938 relocation format is non-standard. */
3939 if (ABI_64_P (output_bfd
))
3941 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
3942 (output_bfd
, &outrel
[0],
3944 + sreloc
->reloc_count
* sizeof (Elf64_Mips_External_Rel
)));
3947 bfd_elf32_swap_reloc_out
3948 (output_bfd
, &outrel
[0],
3949 (sreloc
->contents
+ sreloc
->reloc_count
* sizeof (Elf32_External_Rel
)));
3951 /* We've now added another relocation. */
3952 ++sreloc
->reloc_count
;
3954 /* Make sure the output section is writable. The dynamic linker
3955 will be writing to it. */
3956 elf_section_data (input_section
->output_section
)->this_hdr
.sh_flags
3959 /* On IRIX5, make an entry of compact relocation info. */
3960 if (! skip
&& IRIX_COMPAT (output_bfd
) == ict_irix5
)
3962 asection
*scpt
= bfd_get_section_by_name (dynobj
, ".compact_rel");
3967 Elf32_crinfo cptrel
;
3969 mips_elf_set_cr_format (cptrel
, CRF_MIPS_LONG
);
3970 cptrel
.vaddr
= (rel
->r_offset
3971 + input_section
->output_section
->vma
3972 + input_section
->output_offset
);
3973 if (r_type
== R_MIPS_REL32
)
3974 mips_elf_set_cr_type (cptrel
, CRT_MIPS_REL32
);
3976 mips_elf_set_cr_type (cptrel
, CRT_MIPS_WORD
);
3977 mips_elf_set_cr_dist2to (cptrel
, 0);
3978 cptrel
.konst
= *addendp
;
3980 cr
= (scpt
->contents
3981 + sizeof (Elf32_External_compact_rel
));
3982 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
3983 ((Elf32_External_crinfo
*) cr
3984 + scpt
->reloc_count
));
3985 ++scpt
->reloc_count
;
3992 /* Return the MACH for a MIPS e_flags value. */
3995 _bfd_elf_mips_mach (flags
)
3998 switch (flags
& EF_MIPS_MACH
)
4000 case E_MIPS_MACH_3900
:
4001 return bfd_mach_mips3900
;
4003 case E_MIPS_MACH_4010
:
4004 return bfd_mach_mips4010
;
4006 case E_MIPS_MACH_4100
:
4007 return bfd_mach_mips4100
;
4009 case E_MIPS_MACH_4111
:
4010 return bfd_mach_mips4111
;
4012 case E_MIPS_MACH_4120
:
4013 return bfd_mach_mips4120
;
4015 case E_MIPS_MACH_4650
:
4016 return bfd_mach_mips4650
;
4018 case E_MIPS_MACH_5400
:
4019 return bfd_mach_mips5400
;
4021 case E_MIPS_MACH_5500
:
4022 return bfd_mach_mips5500
;
4024 case E_MIPS_MACH_SB1
:
4025 return bfd_mach_mips_sb1
;
4028 switch (flags
& EF_MIPS_ARCH
)
4032 return bfd_mach_mips3000
;
4036 return bfd_mach_mips6000
;
4040 return bfd_mach_mips4000
;
4044 return bfd_mach_mips8000
;
4048 return bfd_mach_mips5
;
4051 case E_MIPS_ARCH_32
:
4052 return bfd_mach_mipsisa32
;
4055 case E_MIPS_ARCH_64
:
4056 return bfd_mach_mipsisa64
;
4059 case E_MIPS_ARCH_32R2
:
4060 return bfd_mach_mipsisa32r2
;
4063 case E_MIPS_ARCH_64R2
:
4064 return bfd_mach_mipsisa64r2
;
4072 /* Return printable name for ABI. */
4074 static INLINE
char *
4075 elf_mips_abi_name (abfd
)
4080 flags
= elf_elfheader (abfd
)->e_flags
;
4081 switch (flags
& EF_MIPS_ABI
)
4084 if (ABI_N32_P (abfd
))
4086 else if (ABI_64_P (abfd
))
4090 case E_MIPS_ABI_O32
:
4092 case E_MIPS_ABI_O64
:
4094 case E_MIPS_ABI_EABI32
:
4096 case E_MIPS_ABI_EABI64
:
4099 return "unknown abi";
4103 /* MIPS ELF uses two common sections. One is the usual one, and the
4104 other is for small objects. All the small objects are kept
4105 together, and then referenced via the gp pointer, which yields
4106 faster assembler code. This is what we use for the small common
4107 section. This approach is copied from ecoff.c. */
4108 static asection mips_elf_scom_section
;
4109 static asymbol mips_elf_scom_symbol
;
4110 static asymbol
*mips_elf_scom_symbol_ptr
;
4112 /* MIPS ELF also uses an acommon section, which represents an
4113 allocated common symbol which may be overridden by a
4114 definition in a shared library. */
4115 static asection mips_elf_acom_section
;
4116 static asymbol mips_elf_acom_symbol
;
4117 static asymbol
*mips_elf_acom_symbol_ptr
;
4119 /* Handle the special MIPS section numbers that a symbol may use.
4120 This is used for both the 32-bit and the 64-bit ABI. */
4123 _bfd_mips_elf_symbol_processing (abfd
, asym
)
4127 elf_symbol_type
*elfsym
;
4129 elfsym
= (elf_symbol_type
*) asym
;
4130 switch (elfsym
->internal_elf_sym
.st_shndx
)
4132 case SHN_MIPS_ACOMMON
:
4133 /* This section is used in a dynamically linked executable file.
4134 It is an allocated common section. The dynamic linker can
4135 either resolve these symbols to something in a shared
4136 library, or it can just leave them here. For our purposes,
4137 we can consider these symbols to be in a new section. */
4138 if (mips_elf_acom_section
.name
== NULL
)
4140 /* Initialize the acommon section. */
4141 mips_elf_acom_section
.name
= ".acommon";
4142 mips_elf_acom_section
.flags
= SEC_ALLOC
;
4143 mips_elf_acom_section
.output_section
= &mips_elf_acom_section
;
4144 mips_elf_acom_section
.symbol
= &mips_elf_acom_symbol
;
4145 mips_elf_acom_section
.symbol_ptr_ptr
= &mips_elf_acom_symbol_ptr
;
4146 mips_elf_acom_symbol
.name
= ".acommon";
4147 mips_elf_acom_symbol
.flags
= BSF_SECTION_SYM
;
4148 mips_elf_acom_symbol
.section
= &mips_elf_acom_section
;
4149 mips_elf_acom_symbol_ptr
= &mips_elf_acom_symbol
;
4151 asym
->section
= &mips_elf_acom_section
;
4155 /* Common symbols less than the GP size are automatically
4156 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
4157 if (asym
->value
> elf_gp_size (abfd
)
4158 || IRIX_COMPAT (abfd
) == ict_irix6
)
4161 case SHN_MIPS_SCOMMON
:
4162 if (mips_elf_scom_section
.name
== NULL
)
4164 /* Initialize the small common section. */
4165 mips_elf_scom_section
.name
= ".scommon";
4166 mips_elf_scom_section
.flags
= SEC_IS_COMMON
;
4167 mips_elf_scom_section
.output_section
= &mips_elf_scom_section
;
4168 mips_elf_scom_section
.symbol
= &mips_elf_scom_symbol
;
4169 mips_elf_scom_section
.symbol_ptr_ptr
= &mips_elf_scom_symbol_ptr
;
4170 mips_elf_scom_symbol
.name
= ".scommon";
4171 mips_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
4172 mips_elf_scom_symbol
.section
= &mips_elf_scom_section
;
4173 mips_elf_scom_symbol_ptr
= &mips_elf_scom_symbol
;
4175 asym
->section
= &mips_elf_scom_section
;
4176 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
4179 case SHN_MIPS_SUNDEFINED
:
4180 asym
->section
= bfd_und_section_ptr
;
4183 #if 0 /* for SGI_COMPAT */
4185 asym
->section
= mips_elf_text_section_ptr
;
4189 asym
->section
= mips_elf_data_section_ptr
;
4195 /* Work over a section just before writing it out. This routine is
4196 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
4197 sections that need the SHF_MIPS_GPREL flag by name; there has to be
4201 _bfd_mips_elf_section_processing (abfd
, hdr
)
4203 Elf_Internal_Shdr
*hdr
;
4205 if (hdr
->sh_type
== SHT_MIPS_REGINFO
4206 && hdr
->sh_size
> 0)
4210 BFD_ASSERT (hdr
->sh_size
== sizeof (Elf32_External_RegInfo
));
4211 BFD_ASSERT (hdr
->contents
== NULL
);
4214 hdr
->sh_offset
+ sizeof (Elf32_External_RegInfo
) - 4,
4217 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
4218 if (bfd_bwrite (buf
, (bfd_size_type
) 4, abfd
) != 4)
4222 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
4223 && hdr
->bfd_section
!= NULL
4224 && mips_elf_section_data (hdr
->bfd_section
) != NULL
4225 && mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
!= NULL
)
4227 bfd_byte
*contents
, *l
, *lend
;
4229 /* We stored the section contents in the tdata field in the
4230 set_section_contents routine. We save the section contents
4231 so that we don't have to read them again.
4232 At this point we know that elf_gp is set, so we can look
4233 through the section contents to see if there is an
4234 ODK_REGINFO structure. */
4236 contents
= mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
;
4238 lend
= contents
+ hdr
->sh_size
;
4239 while (l
+ sizeof (Elf_External_Options
) <= lend
)
4241 Elf_Internal_Options intopt
;
4243 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
4245 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
4252 + sizeof (Elf_External_Options
)
4253 + (sizeof (Elf64_External_RegInfo
) - 8)),
4256 H_PUT_64 (abfd
, elf_gp (abfd
), buf
);
4257 if (bfd_bwrite (buf
, (bfd_size_type
) 8, abfd
) != 8)
4260 else if (intopt
.kind
== ODK_REGINFO
)
4267 + sizeof (Elf_External_Options
)
4268 + (sizeof (Elf32_External_RegInfo
) - 4)),
4271 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
4272 if (bfd_bwrite (buf
, (bfd_size_type
) 4, abfd
) != 4)
4279 if (hdr
->bfd_section
!= NULL
)
4281 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
4283 if (strcmp (name
, ".sdata") == 0
4284 || strcmp (name
, ".lit8") == 0
4285 || strcmp (name
, ".lit4") == 0)
4287 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
4288 hdr
->sh_type
= SHT_PROGBITS
;
4290 else if (strcmp (name
, ".sbss") == 0)
4292 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
4293 hdr
->sh_type
= SHT_NOBITS
;
4295 else if (strcmp (name
, ".srdata") == 0)
4297 hdr
->sh_flags
|= SHF_ALLOC
| SHF_MIPS_GPREL
;
4298 hdr
->sh_type
= SHT_PROGBITS
;
4300 else if (strcmp (name
, ".compact_rel") == 0)
4303 hdr
->sh_type
= SHT_PROGBITS
;
4305 else if (strcmp (name
, ".rtproc") == 0)
4307 if (hdr
->sh_addralign
!= 0 && hdr
->sh_entsize
== 0)
4309 unsigned int adjust
;
4311 adjust
= hdr
->sh_size
% hdr
->sh_addralign
;
4313 hdr
->sh_size
+= hdr
->sh_addralign
- adjust
;
4321 /* Handle a MIPS specific section when reading an object file. This
4322 is called when elfcode.h finds a section with an unknown type.
4323 This routine supports both the 32-bit and 64-bit ELF ABI.
4325 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
4329 _bfd_mips_elf_section_from_shdr (abfd
, hdr
, name
)
4331 Elf_Internal_Shdr
*hdr
;
4336 /* There ought to be a place to keep ELF backend specific flags, but
4337 at the moment there isn't one. We just keep track of the
4338 sections by their name, instead. Fortunately, the ABI gives
4339 suggested names for all the MIPS specific sections, so we will
4340 probably get away with this. */
4341 switch (hdr
->sh_type
)
4343 case SHT_MIPS_LIBLIST
:
4344 if (strcmp (name
, ".liblist") != 0)
4348 if (strcmp (name
, ".msym") != 0)
4351 case SHT_MIPS_CONFLICT
:
4352 if (strcmp (name
, ".conflict") != 0)
4355 case SHT_MIPS_GPTAB
:
4356 if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) != 0)
4359 case SHT_MIPS_UCODE
:
4360 if (strcmp (name
, ".ucode") != 0)
4363 case SHT_MIPS_DEBUG
:
4364 if (strcmp (name
, ".mdebug") != 0)
4366 flags
= SEC_DEBUGGING
;
4368 case SHT_MIPS_REGINFO
:
4369 if (strcmp (name
, ".reginfo") != 0
4370 || hdr
->sh_size
!= sizeof (Elf32_External_RegInfo
))
4372 flags
= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_SIZE
);
4374 case SHT_MIPS_IFACE
:
4375 if (strcmp (name
, ".MIPS.interfaces") != 0)
4378 case SHT_MIPS_CONTENT
:
4379 if (strncmp (name
, ".MIPS.content", sizeof ".MIPS.content" - 1) != 0)
4382 case SHT_MIPS_OPTIONS
:
4383 if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) != 0)
4386 case SHT_MIPS_DWARF
:
4387 if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) != 0)
4390 case SHT_MIPS_SYMBOL_LIB
:
4391 if (strcmp (name
, ".MIPS.symlib") != 0)
4394 case SHT_MIPS_EVENTS
:
4395 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) != 0
4396 && strncmp (name
, ".MIPS.post_rel",
4397 sizeof ".MIPS.post_rel" - 1) != 0)
4404 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
4409 if (! bfd_set_section_flags (abfd
, hdr
->bfd_section
,
4410 (bfd_get_section_flags (abfd
,
4416 /* FIXME: We should record sh_info for a .gptab section. */
4418 /* For a .reginfo section, set the gp value in the tdata information
4419 from the contents of this section. We need the gp value while
4420 processing relocs, so we just get it now. The .reginfo section
4421 is not used in the 64-bit MIPS ELF ABI. */
4422 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
4424 Elf32_External_RegInfo ext
;
4427 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, (PTR
) &ext
,
4429 (bfd_size_type
) sizeof ext
))
4431 bfd_mips_elf32_swap_reginfo_in (abfd
, &ext
, &s
);
4432 elf_gp (abfd
) = s
.ri_gp_value
;
4435 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
4436 set the gp value based on what we find. We may see both
4437 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
4438 they should agree. */
4439 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
)
4441 bfd_byte
*contents
, *l
, *lend
;
4443 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
4444 if (contents
== NULL
)
4446 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
,
4447 (file_ptr
) 0, hdr
->sh_size
))
4453 lend
= contents
+ hdr
->sh_size
;
4454 while (l
+ sizeof (Elf_External_Options
) <= lend
)
4456 Elf_Internal_Options intopt
;
4458 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
4460 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
4462 Elf64_Internal_RegInfo intreg
;
4464 bfd_mips_elf64_swap_reginfo_in
4466 ((Elf64_External_RegInfo
*)
4467 (l
+ sizeof (Elf_External_Options
))),
4469 elf_gp (abfd
) = intreg
.ri_gp_value
;
4471 else if (intopt
.kind
== ODK_REGINFO
)
4473 Elf32_RegInfo intreg
;
4475 bfd_mips_elf32_swap_reginfo_in
4477 ((Elf32_External_RegInfo
*)
4478 (l
+ sizeof (Elf_External_Options
))),
4480 elf_gp (abfd
) = intreg
.ri_gp_value
;
4490 /* Set the correct type for a MIPS ELF section. We do this by the
4491 section name, which is a hack, but ought to work. This routine is
4492 used by both the 32-bit and the 64-bit ABI. */
4495 _bfd_mips_elf_fake_sections (abfd
, hdr
, sec
)
4497 Elf_Internal_Shdr
*hdr
;
4500 register const char *name
;
4502 name
= bfd_get_section_name (abfd
, sec
);
4504 if (strcmp (name
, ".liblist") == 0)
4506 hdr
->sh_type
= SHT_MIPS_LIBLIST
;
4507 hdr
->sh_info
= sec
->_raw_size
/ sizeof (Elf32_Lib
);
4508 /* The sh_link field is set in final_write_processing. */
4510 else if (strcmp (name
, ".conflict") == 0)
4511 hdr
->sh_type
= SHT_MIPS_CONFLICT
;
4512 else if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0)
4514 hdr
->sh_type
= SHT_MIPS_GPTAB
;
4515 hdr
->sh_entsize
= sizeof (Elf32_External_gptab
);
4516 /* The sh_info field is set in final_write_processing. */
4518 else if (strcmp (name
, ".ucode") == 0)
4519 hdr
->sh_type
= SHT_MIPS_UCODE
;
4520 else if (strcmp (name
, ".mdebug") == 0)
4522 hdr
->sh_type
= SHT_MIPS_DEBUG
;
4523 /* In a shared object on IRIX 5.3, the .mdebug section has an
4524 entsize of 0. FIXME: Does this matter? */
4525 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
4526 hdr
->sh_entsize
= 0;
4528 hdr
->sh_entsize
= 1;
4530 else if (strcmp (name
, ".reginfo") == 0)
4532 hdr
->sh_type
= SHT_MIPS_REGINFO
;
4533 /* In a shared object on IRIX 5.3, the .reginfo section has an
4534 entsize of 0x18. FIXME: Does this matter? */
4535 if (SGI_COMPAT (abfd
))
4537 if ((abfd
->flags
& DYNAMIC
) != 0)
4538 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
4540 hdr
->sh_entsize
= 1;
4543 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
4545 else if (SGI_COMPAT (abfd
)
4546 && (strcmp (name
, ".hash") == 0
4547 || strcmp (name
, ".dynamic") == 0
4548 || strcmp (name
, ".dynstr") == 0))
4550 if (SGI_COMPAT (abfd
))
4551 hdr
->sh_entsize
= 0;
4553 /* This isn't how the IRIX6 linker behaves. */
4554 hdr
->sh_info
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
4557 else if (strcmp (name
, ".got") == 0
4558 || strcmp (name
, ".srdata") == 0
4559 || strcmp (name
, ".sdata") == 0
4560 || strcmp (name
, ".sbss") == 0
4561 || strcmp (name
, ".lit4") == 0
4562 || strcmp (name
, ".lit8") == 0)
4563 hdr
->sh_flags
|= SHF_MIPS_GPREL
;
4564 else if (strcmp (name
, ".MIPS.interfaces") == 0)
4566 hdr
->sh_type
= SHT_MIPS_IFACE
;
4567 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4569 else if (strncmp (name
, ".MIPS.content", strlen (".MIPS.content")) == 0)
4571 hdr
->sh_type
= SHT_MIPS_CONTENT
;
4572 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4573 /* The sh_info field is set in final_write_processing. */
4575 else if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
4577 hdr
->sh_type
= SHT_MIPS_OPTIONS
;
4578 hdr
->sh_entsize
= 1;
4579 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4581 else if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) == 0)
4582 hdr
->sh_type
= SHT_MIPS_DWARF
;
4583 else if (strcmp (name
, ".MIPS.symlib") == 0)
4585 hdr
->sh_type
= SHT_MIPS_SYMBOL_LIB
;
4586 /* The sh_link and sh_info fields are set in
4587 final_write_processing. */
4589 else if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0
4590 || strncmp (name
, ".MIPS.post_rel",
4591 sizeof ".MIPS.post_rel" - 1) == 0)
4593 hdr
->sh_type
= SHT_MIPS_EVENTS
;
4594 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4595 /* The sh_link field is set in final_write_processing. */
4597 else if (strcmp (name
, ".msym") == 0)
4599 hdr
->sh_type
= SHT_MIPS_MSYM
;
4600 hdr
->sh_flags
|= SHF_ALLOC
;
4601 hdr
->sh_entsize
= 8;
4604 /* The generic elf_fake_sections will set up REL_HDR using the default
4605 kind of relocations. We used to set up a second header for the
4606 non-default kind of relocations here, but only NewABI would use
4607 these, and the IRIX ld doesn't like resulting empty RELA sections.
4608 Thus we create those header only on demand now. */
4613 /* Given a BFD section, try to locate the corresponding ELF section
4614 index. This is used by both the 32-bit and the 64-bit ABI.
4615 Actually, it's not clear to me that the 64-bit ABI supports these,
4616 but for non-PIC objects we will certainly want support for at least
4617 the .scommon section. */
4620 _bfd_mips_elf_section_from_bfd_section (abfd
, sec
, retval
)
4621 bfd
*abfd ATTRIBUTE_UNUSED
;
4625 if (strcmp (bfd_get_section_name (abfd
, sec
), ".scommon") == 0)
4627 *retval
= SHN_MIPS_SCOMMON
;
4630 if (strcmp (bfd_get_section_name (abfd
, sec
), ".acommon") == 0)
4632 *retval
= SHN_MIPS_ACOMMON
;
4638 /* Hook called by the linker routine which adds symbols from an object
4639 file. We must handle the special MIPS section numbers here. */
4642 _bfd_mips_elf_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
, secp
, valp
)
4644 struct bfd_link_info
*info
;
4645 const Elf_Internal_Sym
*sym
;
4647 flagword
*flagsp ATTRIBUTE_UNUSED
;
4651 if (SGI_COMPAT (abfd
)
4652 && (abfd
->flags
& DYNAMIC
) != 0
4653 && strcmp (*namep
, "_rld_new_interface") == 0)
4655 /* Skip IRIX5 rld entry name. */
4660 switch (sym
->st_shndx
)
4663 /* Common symbols less than the GP size are automatically
4664 treated as SHN_MIPS_SCOMMON symbols. */
4665 if (sym
->st_size
> elf_gp_size (abfd
)
4666 || IRIX_COMPAT (abfd
) == ict_irix6
)
4669 case SHN_MIPS_SCOMMON
:
4670 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
4671 (*secp
)->flags
|= SEC_IS_COMMON
;
4672 *valp
= sym
->st_size
;
4676 /* This section is used in a shared object. */
4677 if (elf_tdata (abfd
)->elf_text_section
== NULL
)
4679 asymbol
*elf_text_symbol
;
4680 asection
*elf_text_section
;
4681 bfd_size_type amt
= sizeof (asection
);
4683 elf_text_section
= bfd_zalloc (abfd
, amt
);
4684 if (elf_text_section
== NULL
)
4687 amt
= sizeof (asymbol
);
4688 elf_text_symbol
= bfd_zalloc (abfd
, amt
);
4689 if (elf_text_symbol
== NULL
)
4692 /* Initialize the section. */
4694 elf_tdata (abfd
)->elf_text_section
= elf_text_section
;
4695 elf_tdata (abfd
)->elf_text_symbol
= elf_text_symbol
;
4697 elf_text_section
->symbol
= elf_text_symbol
;
4698 elf_text_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_text_symbol
;
4700 elf_text_section
->name
= ".text";
4701 elf_text_section
->flags
= SEC_NO_FLAGS
;
4702 elf_text_section
->output_section
= NULL
;
4703 elf_text_section
->owner
= abfd
;
4704 elf_text_symbol
->name
= ".text";
4705 elf_text_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
4706 elf_text_symbol
->section
= elf_text_section
;
4708 /* This code used to do *secp = bfd_und_section_ptr if
4709 info->shared. I don't know why, and that doesn't make sense,
4710 so I took it out. */
4711 *secp
= elf_tdata (abfd
)->elf_text_section
;
4714 case SHN_MIPS_ACOMMON
:
4715 /* Fall through. XXX Can we treat this as allocated data? */
4717 /* This section is used in a shared object. */
4718 if (elf_tdata (abfd
)->elf_data_section
== NULL
)
4720 asymbol
*elf_data_symbol
;
4721 asection
*elf_data_section
;
4722 bfd_size_type amt
= sizeof (asection
);
4724 elf_data_section
= bfd_zalloc (abfd
, amt
);
4725 if (elf_data_section
== NULL
)
4728 amt
= sizeof (asymbol
);
4729 elf_data_symbol
= bfd_zalloc (abfd
, amt
);
4730 if (elf_data_symbol
== NULL
)
4733 /* Initialize the section. */
4735 elf_tdata (abfd
)->elf_data_section
= elf_data_section
;
4736 elf_tdata (abfd
)->elf_data_symbol
= elf_data_symbol
;
4738 elf_data_section
->symbol
= elf_data_symbol
;
4739 elf_data_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_data_symbol
;
4741 elf_data_section
->name
= ".data";
4742 elf_data_section
->flags
= SEC_NO_FLAGS
;
4743 elf_data_section
->output_section
= NULL
;
4744 elf_data_section
->owner
= abfd
;
4745 elf_data_symbol
->name
= ".data";
4746 elf_data_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
4747 elf_data_symbol
->section
= elf_data_section
;
4749 /* This code used to do *secp = bfd_und_section_ptr if
4750 info->shared. I don't know why, and that doesn't make sense,
4751 so I took it out. */
4752 *secp
= elf_tdata (abfd
)->elf_data_section
;
4755 case SHN_MIPS_SUNDEFINED
:
4756 *secp
= bfd_und_section_ptr
;
4760 if (SGI_COMPAT (abfd
)
4762 && info
->hash
->creator
== abfd
->xvec
4763 && strcmp (*namep
, "__rld_obj_head") == 0)
4765 struct elf_link_hash_entry
*h
;
4766 struct bfd_link_hash_entry
*bh
;
4768 /* Mark __rld_obj_head as dynamic. */
4770 if (! (_bfd_generic_link_add_one_symbol
4771 (info
, abfd
, *namep
, BSF_GLOBAL
, *secp
,
4772 (bfd_vma
) *valp
, (const char *) NULL
, FALSE
,
4773 get_elf_backend_data (abfd
)->collect
, &bh
)))
4776 h
= (struct elf_link_hash_entry
*) bh
;
4777 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
4778 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4779 h
->type
= STT_OBJECT
;
4781 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
4784 mips_elf_hash_table (info
)->use_rld_obj_head
= TRUE
;
4787 /* If this is a mips16 text symbol, add 1 to the value to make it
4788 odd. This will cause something like .word SYM to come up with
4789 the right value when it is loaded into the PC. */
4790 if (sym
->st_other
== STO_MIPS16
)
4796 /* This hook function is called before the linker writes out a global
4797 symbol. We mark symbols as small common if appropriate. This is
4798 also where we undo the increment of the value for a mips16 symbol. */
4801 _bfd_mips_elf_link_output_symbol_hook (abfd
, info
, name
, sym
, input_sec
)
4802 bfd
*abfd ATTRIBUTE_UNUSED
;
4803 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
4804 const char *name ATTRIBUTE_UNUSED
;
4805 Elf_Internal_Sym
*sym
;
4806 asection
*input_sec
;
4808 /* If we see a common symbol, which implies a relocatable link, then
4809 if a symbol was small common in an input file, mark it as small
4810 common in the output file. */
4811 if (sym
->st_shndx
== SHN_COMMON
4812 && strcmp (input_sec
->name
, ".scommon") == 0)
4813 sym
->st_shndx
= SHN_MIPS_SCOMMON
;
4815 if (sym
->st_other
== STO_MIPS16
4816 && (sym
->st_value
& 1) != 0)
4822 /* Functions for the dynamic linker. */
4824 /* Create dynamic sections when linking against a dynamic object. */
4827 _bfd_mips_elf_create_dynamic_sections (abfd
, info
)
4829 struct bfd_link_info
*info
;
4831 struct elf_link_hash_entry
*h
;
4832 struct bfd_link_hash_entry
*bh
;
4834 register asection
*s
;
4835 const char * const *namep
;
4837 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
4838 | SEC_LINKER_CREATED
| SEC_READONLY
);
4840 /* Mips ABI requests the .dynamic section to be read only. */
4841 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4844 if (! bfd_set_section_flags (abfd
, s
, flags
))
4848 /* We need to create .got section. */
4849 if (! mips_elf_create_got_section (abfd
, info
, FALSE
))
4852 if (! mips_elf_rel_dyn_section (elf_hash_table (info
)->dynobj
, TRUE
))
4855 /* Create .stub section. */
4856 if (bfd_get_section_by_name (abfd
,
4857 MIPS_ELF_STUB_SECTION_NAME (abfd
)) == NULL
)
4859 s
= bfd_make_section (abfd
, MIPS_ELF_STUB_SECTION_NAME (abfd
));
4861 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_CODE
)
4862 || ! bfd_set_section_alignment (abfd
, s
,
4863 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
4867 if ((IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
4869 && bfd_get_section_by_name (abfd
, ".rld_map") == NULL
)
4871 s
= bfd_make_section (abfd
, ".rld_map");
4873 || ! bfd_set_section_flags (abfd
, s
, flags
&~ (flagword
) SEC_READONLY
)
4874 || ! bfd_set_section_alignment (abfd
, s
,
4875 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
4879 /* On IRIX5, we adjust add some additional symbols and change the
4880 alignments of several sections. There is no ABI documentation
4881 indicating that this is necessary on IRIX6, nor any evidence that
4882 the linker takes such action. */
4883 if (IRIX_COMPAT (abfd
) == ict_irix5
)
4885 for (namep
= mips_elf_dynsym_rtproc_names
; *namep
!= NULL
; namep
++)
4888 if (! (_bfd_generic_link_add_one_symbol
4889 (info
, abfd
, *namep
, BSF_GLOBAL
, bfd_und_section_ptr
,
4890 (bfd_vma
) 0, (const char *) NULL
, FALSE
,
4891 get_elf_backend_data (abfd
)->collect
, &bh
)))
4894 h
= (struct elf_link_hash_entry
*) bh
;
4895 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
4896 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4897 h
->type
= STT_SECTION
;
4899 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
4903 /* We need to create a .compact_rel section. */
4904 if (SGI_COMPAT (abfd
))
4906 if (!mips_elf_create_compact_rel_section (abfd
, info
))
4910 /* Change alignments of some sections. */
4911 s
= bfd_get_section_by_name (abfd
, ".hash");
4913 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4914 s
= bfd_get_section_by_name (abfd
, ".dynsym");
4916 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4917 s
= bfd_get_section_by_name (abfd
, ".dynstr");
4919 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4920 s
= bfd_get_section_by_name (abfd
, ".reginfo");
4922 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4923 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4925 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4932 name
= SGI_COMPAT (abfd
) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
4934 if (!(_bfd_generic_link_add_one_symbol
4935 (info
, abfd
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
,
4936 (bfd_vma
) 0, (const char *) NULL
, FALSE
,
4937 get_elf_backend_data (abfd
)->collect
, &bh
)))
4940 h
= (struct elf_link_hash_entry
*) bh
;
4941 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
4942 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4943 h
->type
= STT_SECTION
;
4945 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
4948 if (! mips_elf_hash_table (info
)->use_rld_obj_head
)
4950 /* __rld_map is a four byte word located in the .data section
4951 and is filled in by the rtld to contain a pointer to
4952 the _r_debug structure. Its symbol value will be set in
4953 _bfd_mips_elf_finish_dynamic_symbol. */
4954 s
= bfd_get_section_by_name (abfd
, ".rld_map");
4955 BFD_ASSERT (s
!= NULL
);
4957 name
= SGI_COMPAT (abfd
) ? "__rld_map" : "__RLD_MAP";
4959 if (!(_bfd_generic_link_add_one_symbol
4960 (info
, abfd
, name
, BSF_GLOBAL
, s
,
4961 (bfd_vma
) 0, (const char *) NULL
, FALSE
,
4962 get_elf_backend_data (abfd
)->collect
, &bh
)))
4965 h
= (struct elf_link_hash_entry
*) bh
;
4966 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
4967 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4968 h
->type
= STT_OBJECT
;
4970 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
4978 /* Look through the relocs for a section during the first phase, and
4979 allocate space in the global offset table. */
4982 _bfd_mips_elf_check_relocs (abfd
, info
, sec
, relocs
)
4984 struct bfd_link_info
*info
;
4986 const Elf_Internal_Rela
*relocs
;
4990 Elf_Internal_Shdr
*symtab_hdr
;
4991 struct elf_link_hash_entry
**sym_hashes
;
4992 struct mips_got_info
*g
;
4994 const Elf_Internal_Rela
*rel
;
4995 const Elf_Internal_Rela
*rel_end
;
4998 const struct elf_backend_data
*bed
;
5000 if (info
->relocatable
)
5003 dynobj
= elf_hash_table (info
)->dynobj
;
5004 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5005 sym_hashes
= elf_sym_hashes (abfd
);
5006 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
5008 /* Check for the mips16 stub sections. */
5010 name
= bfd_get_section_name (abfd
, sec
);
5011 if (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0)
5013 unsigned long r_symndx
;
5015 /* Look at the relocation information to figure out which symbol
5018 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
5020 if (r_symndx
< extsymoff
5021 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
5025 /* This stub is for a local symbol. This stub will only be
5026 needed if there is some relocation in this BFD, other
5027 than a 16 bit function call, which refers to this symbol. */
5028 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5030 Elf_Internal_Rela
*sec_relocs
;
5031 const Elf_Internal_Rela
*r
, *rend
;
5033 /* We can ignore stub sections when looking for relocs. */
5034 if ((o
->flags
& SEC_RELOC
) == 0
5035 || o
->reloc_count
== 0
5036 || strncmp (bfd_get_section_name (abfd
, o
), FN_STUB
,
5037 sizeof FN_STUB
- 1) == 0
5038 || strncmp (bfd_get_section_name (abfd
, o
), CALL_STUB
,
5039 sizeof CALL_STUB
- 1) == 0
5040 || strncmp (bfd_get_section_name (abfd
, o
), CALL_FP_STUB
,
5041 sizeof CALL_FP_STUB
- 1) == 0)
5045 = _bfd_elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
5046 (Elf_Internal_Rela
*) NULL
,
5048 if (sec_relocs
== NULL
)
5051 rend
= sec_relocs
+ o
->reloc_count
;
5052 for (r
= sec_relocs
; r
< rend
; r
++)
5053 if (ELF_R_SYM (abfd
, r
->r_info
) == r_symndx
5054 && ELF_R_TYPE (abfd
, r
->r_info
) != R_MIPS16_26
)
5057 if (elf_section_data (o
)->relocs
!= sec_relocs
)
5066 /* There is no non-call reloc for this stub, so we do
5067 not need it. Since this function is called before
5068 the linker maps input sections to output sections, we
5069 can easily discard it by setting the SEC_EXCLUDE
5071 sec
->flags
|= SEC_EXCLUDE
;
5075 /* Record this stub in an array of local symbol stubs for
5077 if (elf_tdata (abfd
)->local_stubs
== NULL
)
5079 unsigned long symcount
;
5083 if (elf_bad_symtab (abfd
))
5084 symcount
= NUM_SHDR_ENTRIES (symtab_hdr
);
5086 symcount
= symtab_hdr
->sh_info
;
5087 amt
= symcount
* sizeof (asection
*);
5088 n
= (asection
**) bfd_zalloc (abfd
, amt
);
5091 elf_tdata (abfd
)->local_stubs
= n
;
5094 elf_tdata (abfd
)->local_stubs
[r_symndx
] = sec
;
5096 /* We don't need to set mips16_stubs_seen in this case.
5097 That flag is used to see whether we need to look through
5098 the global symbol table for stubs. We don't need to set
5099 it here, because we just have a local stub. */
5103 struct mips_elf_link_hash_entry
*h
;
5105 h
= ((struct mips_elf_link_hash_entry
*)
5106 sym_hashes
[r_symndx
- extsymoff
]);
5108 /* H is the symbol this stub is for. */
5111 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
5114 else if (strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
5115 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
5117 unsigned long r_symndx
;
5118 struct mips_elf_link_hash_entry
*h
;
5121 /* Look at the relocation information to figure out which symbol
5124 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
5126 if (r_symndx
< extsymoff
5127 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
5129 /* This stub was actually built for a static symbol defined
5130 in the same file. We assume that all static symbols in
5131 mips16 code are themselves mips16, so we can simply
5132 discard this stub. Since this function is called before
5133 the linker maps input sections to output sections, we can
5134 easily discard it by setting the SEC_EXCLUDE flag. */
5135 sec
->flags
|= SEC_EXCLUDE
;
5139 h
= ((struct mips_elf_link_hash_entry
*)
5140 sym_hashes
[r_symndx
- extsymoff
]);
5142 /* H is the symbol this stub is for. */
5144 if (strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
5145 loc
= &h
->call_fp_stub
;
5147 loc
= &h
->call_stub
;
5149 /* If we already have an appropriate stub for this function, we
5150 don't need another one, so we can discard this one. Since
5151 this function is called before the linker maps input sections
5152 to output sections, we can easily discard it by setting the
5153 SEC_EXCLUDE flag. We can also discard this section if we
5154 happen to already know that this is a mips16 function; it is
5155 not necessary to check this here, as it is checked later, but
5156 it is slightly faster to check now. */
5157 if (*loc
!= NULL
|| h
->root
.other
== STO_MIPS16
)
5159 sec
->flags
|= SEC_EXCLUDE
;
5164 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
5174 sgot
= mips_elf_got_section (dynobj
, FALSE
);
5179 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
5180 g
= mips_elf_section_data (sgot
)->u
.got_info
;
5181 BFD_ASSERT (g
!= NULL
);
5186 bed
= get_elf_backend_data (abfd
);
5187 rel_end
= relocs
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
5188 for (rel
= relocs
; rel
< rel_end
; ++rel
)
5190 unsigned long r_symndx
;
5191 unsigned int r_type
;
5192 struct elf_link_hash_entry
*h
;
5194 r_symndx
= ELF_R_SYM (abfd
, rel
->r_info
);
5195 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
5197 if (r_symndx
< extsymoff
)
5199 else if (r_symndx
>= extsymoff
+ NUM_SHDR_ENTRIES (symtab_hdr
))
5201 (*_bfd_error_handler
)
5202 (_("%s: Malformed reloc detected for section %s"),
5203 bfd_archive_filename (abfd
), name
);
5204 bfd_set_error (bfd_error_bad_value
);
5209 h
= sym_hashes
[r_symndx
- extsymoff
];
5211 /* This may be an indirect symbol created because of a version. */
5214 while (h
->root
.type
== bfd_link_hash_indirect
)
5215 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5219 /* Some relocs require a global offset table. */
5220 if (dynobj
== NULL
|| sgot
== NULL
)
5226 case R_MIPS_CALL_HI16
:
5227 case R_MIPS_CALL_LO16
:
5228 case R_MIPS_GOT_HI16
:
5229 case R_MIPS_GOT_LO16
:
5230 case R_MIPS_GOT_PAGE
:
5231 case R_MIPS_GOT_OFST
:
5232 case R_MIPS_GOT_DISP
:
5234 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5235 if (! mips_elf_create_got_section (dynobj
, info
, FALSE
))
5237 g
= mips_elf_got_info (dynobj
, &sgot
);
5244 && (info
->shared
|| h
!= NULL
)
5245 && (sec
->flags
& SEC_ALLOC
) != 0)
5246 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5254 if (!h
&& (r_type
== R_MIPS_CALL_LO16
5255 || r_type
== R_MIPS_GOT_LO16
5256 || r_type
== R_MIPS_GOT_DISP
))
5258 /* We may need a local GOT entry for this relocation. We
5259 don't count R_MIPS_GOT_PAGE because we can estimate the
5260 maximum number of pages needed by looking at the size of
5261 the segment. Similar comments apply to R_MIPS_GOT16 and
5262 R_MIPS_CALL16. We don't count R_MIPS_GOT_HI16, or
5263 R_MIPS_CALL_HI16 because these are always followed by an
5264 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
5265 if (! mips_elf_record_local_got_symbol (abfd
, r_symndx
,
5275 (*_bfd_error_handler
)
5276 (_("%s: CALL16 reloc at 0x%lx not against global symbol"),
5277 bfd_archive_filename (abfd
), (unsigned long) rel
->r_offset
);
5278 bfd_set_error (bfd_error_bad_value
);
5283 case R_MIPS_CALL_HI16
:
5284 case R_MIPS_CALL_LO16
:
5287 /* This symbol requires a global offset table entry. */
5288 if (! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5291 /* We need a stub, not a plt entry for the undefined
5292 function. But we record it as if it needs plt. See
5293 elf_adjust_dynamic_symbol in elflink.h. */
5294 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
5299 case R_MIPS_GOT_PAGE
:
5300 /* If this is a global, overridable symbol, GOT_PAGE will
5301 decay to GOT_DISP, so we'll need a GOT entry for it. */
5306 struct mips_elf_link_hash_entry
*hmips
=
5307 (struct mips_elf_link_hash_entry
*) h
;
5309 while (hmips
->root
.root
.type
== bfd_link_hash_indirect
5310 || hmips
->root
.root
.type
== bfd_link_hash_warning
)
5311 hmips
= (struct mips_elf_link_hash_entry
*)
5312 hmips
->root
.root
.u
.i
.link
;
5314 if ((hmips
->root
.root
.type
== bfd_link_hash_defined
5315 || hmips
->root
.root
.type
== bfd_link_hash_defweak
)
5316 && hmips
->root
.root
.u
.def
.section
5317 && ! (info
->shared
&& ! info
->symbolic
5318 && ! (hmips
->root
.elf_link_hash_flags
5319 & ELF_LINK_FORCED_LOCAL
))
5320 /* If we've encountered any other relocation
5321 referencing the symbol, we'll have marked it as
5322 dynamic, and, even though we might be able to get
5323 rid of the GOT entry should we know for sure all
5324 previous relocations were GOT_PAGE ones, at this
5325 point we can't tell, so just keep using the
5326 symbol as dynamic. This is very important in the
5327 multi-got case, since we don't decide whether to
5328 decay GOT_PAGE to GOT_DISP on a per-GOT basis: if
5329 the symbol is dynamic, we'll need a GOT entry for
5330 every GOT in which the symbol is referenced with
5331 a GOT_PAGE relocation. */
5332 && hmips
->root
.dynindx
== -1)
5338 case R_MIPS_GOT_HI16
:
5339 case R_MIPS_GOT_LO16
:
5340 case R_MIPS_GOT_DISP
:
5341 /* This symbol requires a global offset table entry. */
5342 if (h
&& ! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5349 if ((info
->shared
|| h
!= NULL
)
5350 && (sec
->flags
& SEC_ALLOC
) != 0)
5354 sreloc
= mips_elf_rel_dyn_section (dynobj
, TRUE
);
5358 #define MIPS_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
5361 /* When creating a shared object, we must copy these
5362 reloc types into the output file as R_MIPS_REL32
5363 relocs. We make room for this reloc in the
5364 .rel.dyn reloc section. */
5365 mips_elf_allocate_dynamic_relocations (dynobj
, 1);
5366 if ((sec
->flags
& MIPS_READONLY_SECTION
)
5367 == MIPS_READONLY_SECTION
)
5368 /* We tell the dynamic linker that there are
5369 relocations against the text segment. */
5370 info
->flags
|= DF_TEXTREL
;
5374 struct mips_elf_link_hash_entry
*hmips
;
5376 /* We only need to copy this reloc if the symbol is
5377 defined in a dynamic object. */
5378 hmips
= (struct mips_elf_link_hash_entry
*) h
;
5379 ++hmips
->possibly_dynamic_relocs
;
5380 if ((sec
->flags
& MIPS_READONLY_SECTION
)
5381 == MIPS_READONLY_SECTION
)
5382 /* We need it to tell the dynamic linker if there
5383 are relocations against the text segment. */
5384 hmips
->readonly_reloc
= TRUE
;
5387 /* Even though we don't directly need a GOT entry for
5388 this symbol, a symbol must have a dynamic symbol
5389 table index greater that DT_MIPS_GOTSYM if there are
5390 dynamic relocations against it. */
5394 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5395 if (! mips_elf_create_got_section (dynobj
, info
, TRUE
))
5397 g
= mips_elf_got_info (dynobj
, &sgot
);
5398 if (! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5403 if (SGI_COMPAT (abfd
))
5404 mips_elf_hash_table (info
)->compact_rel_size
+=
5405 sizeof (Elf32_External_crinfo
);
5409 case R_MIPS_GPREL16
:
5410 case R_MIPS_LITERAL
:
5411 case R_MIPS_GPREL32
:
5412 if (SGI_COMPAT (abfd
))
5413 mips_elf_hash_table (info
)->compact_rel_size
+=
5414 sizeof (Elf32_External_crinfo
);
5417 /* This relocation describes the C++ object vtable hierarchy.
5418 Reconstruct it for later use during GC. */
5419 case R_MIPS_GNU_VTINHERIT
:
5420 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
5424 /* This relocation describes which C++ vtable entries are actually
5425 used. Record for later use during GC. */
5426 case R_MIPS_GNU_VTENTRY
:
5427 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
5435 /* We must not create a stub for a symbol that has relocations
5436 related to taking the function's address. */
5442 struct mips_elf_link_hash_entry
*mh
;
5444 mh
= (struct mips_elf_link_hash_entry
*) h
;
5445 mh
->no_fn_stub
= TRUE
;
5449 case R_MIPS_CALL_HI16
:
5450 case R_MIPS_CALL_LO16
:
5455 /* If this reloc is not a 16 bit call, and it has a global
5456 symbol, then we will need the fn_stub if there is one.
5457 References from a stub section do not count. */
5459 && r_type
!= R_MIPS16_26
5460 && strncmp (bfd_get_section_name (abfd
, sec
), FN_STUB
,
5461 sizeof FN_STUB
- 1) != 0
5462 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_STUB
,
5463 sizeof CALL_STUB
- 1) != 0
5464 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_FP_STUB
,
5465 sizeof CALL_FP_STUB
- 1) != 0)
5467 struct mips_elf_link_hash_entry
*mh
;
5469 mh
= (struct mips_elf_link_hash_entry
*) h
;
5470 mh
->need_fn_stub
= TRUE
;
5478 _bfd_mips_relax_section (abfd
, sec
, link_info
, again
)
5481 struct bfd_link_info
*link_info
;
5484 Elf_Internal_Rela
*internal_relocs
;
5485 Elf_Internal_Rela
*irel
, *irelend
;
5486 Elf_Internal_Shdr
*symtab_hdr
;
5487 bfd_byte
*contents
= NULL
;
5488 bfd_byte
*free_contents
= NULL
;
5490 bfd_boolean changed_contents
= FALSE
;
5491 bfd_vma sec_start
= sec
->output_section
->vma
+ sec
->output_offset
;
5492 Elf_Internal_Sym
*isymbuf
= NULL
;
5494 /* We are not currently changing any sizes, so only one pass. */
5497 if (link_info
->relocatable
)
5500 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, (PTR
) NULL
,
5501 (Elf_Internal_Rela
*) NULL
,
5502 link_info
->keep_memory
);
5503 if (internal_relocs
== NULL
)
5506 irelend
= internal_relocs
+ sec
->reloc_count
5507 * get_elf_backend_data (abfd
)->s
->int_rels_per_ext_rel
;
5508 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5509 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
5511 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
5514 bfd_signed_vma sym_offset
;
5515 unsigned int r_type
;
5516 unsigned long r_symndx
;
5518 unsigned long instruction
;
5520 /* Turn jalr into bgezal, and jr into beq, if they're marked
5521 with a JALR relocation, that indicate where they jump to.
5522 This saves some pipeline bubbles. */
5523 r_type
= ELF_R_TYPE (abfd
, irel
->r_info
);
5524 if (r_type
!= R_MIPS_JALR
)
5527 r_symndx
= ELF_R_SYM (abfd
, irel
->r_info
);
5528 /* Compute the address of the jump target. */
5529 if (r_symndx
>= extsymoff
)
5531 struct mips_elf_link_hash_entry
*h
5532 = ((struct mips_elf_link_hash_entry
*)
5533 elf_sym_hashes (abfd
) [r_symndx
- extsymoff
]);
5535 while (h
->root
.root
.type
== bfd_link_hash_indirect
5536 || h
->root
.root
.type
== bfd_link_hash_warning
)
5537 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
5539 /* If a symbol is undefined, or if it may be overridden,
5541 if (! ((h
->root
.root
.type
== bfd_link_hash_defined
5542 || h
->root
.root
.type
== bfd_link_hash_defweak
)
5543 && h
->root
.root
.u
.def
.section
)
5544 || (link_info
->shared
&& ! link_info
->symbolic
5545 && ! (h
->root
.elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
)))
5548 sym_sec
= h
->root
.root
.u
.def
.section
;
5549 if (sym_sec
->output_section
)
5550 symval
= (h
->root
.root
.u
.def
.value
5551 + sym_sec
->output_section
->vma
5552 + sym_sec
->output_offset
);
5554 symval
= h
->root
.root
.u
.def
.value
;
5558 Elf_Internal_Sym
*isym
;
5560 /* Read this BFD's symbols if we haven't done so already. */
5561 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
5563 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5564 if (isymbuf
== NULL
)
5565 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
5566 symtab_hdr
->sh_info
, 0,
5568 if (isymbuf
== NULL
)
5572 isym
= isymbuf
+ r_symndx
;
5573 if (isym
->st_shndx
== SHN_UNDEF
)
5575 else if (isym
->st_shndx
== SHN_ABS
)
5576 sym_sec
= bfd_abs_section_ptr
;
5577 else if (isym
->st_shndx
== SHN_COMMON
)
5578 sym_sec
= bfd_com_section_ptr
;
5581 = bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
5582 symval
= isym
->st_value
5583 + sym_sec
->output_section
->vma
5584 + sym_sec
->output_offset
;
5587 /* Compute branch offset, from delay slot of the jump to the
5589 sym_offset
= (symval
+ irel
->r_addend
)
5590 - (sec_start
+ irel
->r_offset
+ 4);
5592 /* Branch offset must be properly aligned. */
5593 if ((sym_offset
& 3) != 0)
5598 /* Check that it's in range. */
5599 if (sym_offset
< -0x8000 || sym_offset
>= 0x8000)
5602 /* Get the section contents if we haven't done so already. */
5603 if (contents
== NULL
)
5605 /* Get cached copy if it exists. */
5606 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
5607 contents
= elf_section_data (sec
)->this_hdr
.contents
;
5610 contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
5611 if (contents
== NULL
)
5614 free_contents
= contents
;
5615 if (! bfd_get_section_contents (abfd
, sec
, contents
,
5616 (file_ptr
) 0, sec
->_raw_size
))
5621 instruction
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
5623 /* If it was jalr <reg>, turn it into bgezal $zero, <target>. */
5624 if ((instruction
& 0xfc1fffff) == 0x0000f809)
5625 instruction
= 0x04110000;
5626 /* If it was jr <reg>, turn it into b <target>. */
5627 else if ((instruction
& 0xfc1fffff) == 0x00000008)
5628 instruction
= 0x10000000;
5632 instruction
|= (sym_offset
& 0xffff);
5633 bfd_put_32 (abfd
, instruction
, contents
+ irel
->r_offset
);
5634 changed_contents
= TRUE
;
5637 if (contents
!= NULL
5638 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
5640 if (!changed_contents
&& !link_info
->keep_memory
)
5644 /* Cache the section contents for elf_link_input_bfd. */
5645 elf_section_data (sec
)->this_hdr
.contents
= contents
;
5651 if (free_contents
!= NULL
)
5652 free (free_contents
);
5656 /* Adjust a symbol defined by a dynamic object and referenced by a
5657 regular object. The current definition is in some section of the
5658 dynamic object, but we're not including those sections. We have to
5659 change the definition to something the rest of the link can
5663 _bfd_mips_elf_adjust_dynamic_symbol (info
, h
)
5664 struct bfd_link_info
*info
;
5665 struct elf_link_hash_entry
*h
;
5668 struct mips_elf_link_hash_entry
*hmips
;
5671 dynobj
= elf_hash_table (info
)->dynobj
;
5673 /* Make sure we know what is going on here. */
5674 BFD_ASSERT (dynobj
!= NULL
5675 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
5676 || h
->weakdef
!= NULL
5677 || ((h
->elf_link_hash_flags
5678 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
5679 && (h
->elf_link_hash_flags
5680 & ELF_LINK_HASH_REF_REGULAR
) != 0
5681 && (h
->elf_link_hash_flags
5682 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
5684 /* If this symbol is defined in a dynamic object, we need to copy
5685 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
5687 hmips
= (struct mips_elf_link_hash_entry
*) h
;
5688 if (! info
->relocatable
5689 && hmips
->possibly_dynamic_relocs
!= 0
5690 && (h
->root
.type
== bfd_link_hash_defweak
5691 || (h
->elf_link_hash_flags
5692 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
5694 mips_elf_allocate_dynamic_relocations (dynobj
,
5695 hmips
->possibly_dynamic_relocs
);
5696 if (hmips
->readonly_reloc
)
5697 /* We tell the dynamic linker that there are relocations
5698 against the text segment. */
5699 info
->flags
|= DF_TEXTREL
;
5702 /* For a function, create a stub, if allowed. */
5703 if (! hmips
->no_fn_stub
5704 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
5706 if (! elf_hash_table (info
)->dynamic_sections_created
)
5709 /* If this symbol is not defined in a regular file, then set
5710 the symbol to the stub location. This is required to make
5711 function pointers compare as equal between the normal
5712 executable and the shared library. */
5713 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
5715 /* We need .stub section. */
5716 s
= bfd_get_section_by_name (dynobj
,
5717 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
5718 BFD_ASSERT (s
!= NULL
);
5720 h
->root
.u
.def
.section
= s
;
5721 h
->root
.u
.def
.value
= s
->_raw_size
;
5723 /* XXX Write this stub address somewhere. */
5724 h
->plt
.offset
= s
->_raw_size
;
5726 /* Make room for this stub code. */
5727 s
->_raw_size
+= MIPS_FUNCTION_STUB_SIZE
;
5729 /* The last half word of the stub will be filled with the index
5730 of this symbol in .dynsym section. */
5734 else if ((h
->type
== STT_FUNC
)
5735 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0)
5737 /* This will set the entry for this symbol in the GOT to 0, and
5738 the dynamic linker will take care of this. */
5739 h
->root
.u
.def
.value
= 0;
5743 /* If this is a weak symbol, and there is a real definition, the
5744 processor independent code will have arranged for us to see the
5745 real definition first, and we can just use the same value. */
5746 if (h
->weakdef
!= NULL
)
5748 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
5749 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
5750 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
5751 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
5755 /* This is a reference to a symbol defined by a dynamic object which
5756 is not a function. */
5761 /* This function is called after all the input files have been read,
5762 and the input sections have been assigned to output sections. We
5763 check for any mips16 stub sections that we can discard. */
5766 _bfd_mips_elf_always_size_sections (output_bfd
, info
)
5768 struct bfd_link_info
*info
;
5774 struct mips_got_info
*g
;
5776 bfd_size_type loadable_size
= 0;
5777 bfd_size_type local_gotno
;
5780 /* The .reginfo section has a fixed size. */
5781 ri
= bfd_get_section_by_name (output_bfd
, ".reginfo");
5783 bfd_set_section_size (output_bfd
, ri
,
5784 (bfd_size_type
) sizeof (Elf32_External_RegInfo
));
5786 if (! (info
->relocatable
5787 || ! mips_elf_hash_table (info
)->mips16_stubs_seen
))
5788 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
5789 mips_elf_check_mips16_stubs
,
5792 dynobj
= elf_hash_table (info
)->dynobj
;
5794 /* Relocatable links don't have it. */
5797 g
= mips_elf_got_info (dynobj
, &s
);
5801 /* Calculate the total loadable size of the output. That
5802 will give us the maximum number of GOT_PAGE entries
5804 for (sub
= info
->input_bfds
; sub
; sub
= sub
->link_next
)
5806 asection
*subsection
;
5808 for (subsection
= sub
->sections
;
5810 subsection
= subsection
->next
)
5812 if ((subsection
->flags
& SEC_ALLOC
) == 0)
5814 loadable_size
+= ((subsection
->_raw_size
+ 0xf)
5815 &~ (bfd_size_type
) 0xf);
5819 /* There has to be a global GOT entry for every symbol with
5820 a dynamic symbol table index of DT_MIPS_GOTSYM or
5821 higher. Therefore, it make sense to put those symbols
5822 that need GOT entries at the end of the symbol table. We
5824 if (! mips_elf_sort_hash_table (info
, 1))
5827 if (g
->global_gotsym
!= NULL
)
5828 i
= elf_hash_table (info
)->dynsymcount
- g
->global_gotsym
->dynindx
;
5830 /* If there are no global symbols, or none requiring
5831 relocations, then GLOBAL_GOTSYM will be NULL. */
5834 /* In the worst case, we'll get one stub per dynamic symbol, plus
5835 one to account for the dummy entry at the end required by IRIX
5837 loadable_size
+= MIPS_FUNCTION_STUB_SIZE
* (i
+ 1);
5839 /* Assume there are two loadable segments consisting of
5840 contiguous sections. Is 5 enough? */
5841 local_gotno
= (loadable_size
>> 16) + 5;
5843 g
->local_gotno
+= local_gotno
;
5844 s
->_raw_size
+= g
->local_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
5846 g
->global_gotno
= i
;
5847 s
->_raw_size
+= i
* MIPS_ELF_GOT_SIZE (output_bfd
);
5849 if (s
->_raw_size
> MIPS_ELF_GOT_MAX_SIZE (output_bfd
)
5850 && ! mips_elf_multi_got (output_bfd
, info
, g
, s
, local_gotno
))
5856 /* Set the sizes of the dynamic sections. */
5859 _bfd_mips_elf_size_dynamic_sections (output_bfd
, info
)
5861 struct bfd_link_info
*info
;
5865 bfd_boolean reltext
;
5867 dynobj
= elf_hash_table (info
)->dynobj
;
5868 BFD_ASSERT (dynobj
!= NULL
);
5870 if (elf_hash_table (info
)->dynamic_sections_created
)
5872 /* Set the contents of the .interp section to the interpreter. */
5875 s
= bfd_get_section_by_name (dynobj
, ".interp");
5876 BFD_ASSERT (s
!= NULL
);
5878 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd
)) + 1;
5880 = (bfd_byte
*) ELF_DYNAMIC_INTERPRETER (output_bfd
);
5884 /* The check_relocs and adjust_dynamic_symbol entry points have
5885 determined the sizes of the various dynamic sections. Allocate
5888 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
5893 /* It's OK to base decisions on the section name, because none
5894 of the dynobj section names depend upon the input files. */
5895 name
= bfd_get_section_name (dynobj
, s
);
5897 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
5902 if (strncmp (name
, ".rel", 4) == 0)
5904 if (s
->_raw_size
== 0)
5906 /* We only strip the section if the output section name
5907 has the same name. Otherwise, there might be several
5908 input sections for this output section. FIXME: This
5909 code is probably not needed these days anyhow, since
5910 the linker now does not create empty output sections. */
5911 if (s
->output_section
!= NULL
5913 bfd_get_section_name (s
->output_section
->owner
,
5914 s
->output_section
)) == 0)
5919 const char *outname
;
5922 /* If this relocation section applies to a read only
5923 section, then we probably need a DT_TEXTREL entry.
5924 If the relocation section is .rel.dyn, we always
5925 assert a DT_TEXTREL entry rather than testing whether
5926 there exists a relocation to a read only section or
5928 outname
= bfd_get_section_name (output_bfd
,
5930 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
5932 && (target
->flags
& SEC_READONLY
) != 0
5933 && (target
->flags
& SEC_ALLOC
) != 0)
5934 || strcmp (outname
, ".rel.dyn") == 0)
5937 /* We use the reloc_count field as a counter if we need
5938 to copy relocs into the output file. */
5939 if (strcmp (name
, ".rel.dyn") != 0)
5942 /* If combreloc is enabled, elf_link_sort_relocs() will
5943 sort relocations, but in a different way than we do,
5944 and before we're done creating relocations. Also, it
5945 will move them around between input sections'
5946 relocation's contents, so our sorting would be
5947 broken, so don't let it run. */
5948 info
->combreloc
= 0;
5951 else if (strncmp (name
, ".got", 4) == 0)
5953 /* _bfd_mips_elf_always_size_sections() has already done
5954 most of the work, but some symbols may have been mapped
5955 to versions that we must now resolve in the got_entries
5957 struct mips_got_info
*gg
= mips_elf_got_info (dynobj
, NULL
);
5958 struct mips_got_info
*g
= gg
;
5959 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
5960 unsigned int needed_relocs
= 0;
5964 set_got_offset_arg
.value
= MIPS_ELF_GOT_SIZE (output_bfd
);
5965 set_got_offset_arg
.info
= info
;
5967 mips_elf_resolve_final_got_entries (gg
);
5968 for (g
= gg
->next
; g
&& g
->next
!= gg
; g
= g
->next
)
5970 unsigned int save_assign
;
5972 mips_elf_resolve_final_got_entries (g
);
5974 /* Assign offsets to global GOT entries. */
5975 save_assign
= g
->assigned_gotno
;
5976 g
->assigned_gotno
= g
->local_gotno
;
5977 set_got_offset_arg
.g
= g
;
5978 set_got_offset_arg
.needed_relocs
= 0;
5979 htab_traverse (g
->got_entries
,
5980 mips_elf_set_global_got_offset
,
5981 &set_got_offset_arg
);
5982 needed_relocs
+= set_got_offset_arg
.needed_relocs
;
5983 BFD_ASSERT (g
->assigned_gotno
- g
->local_gotno
5984 <= g
->global_gotno
);
5986 g
->assigned_gotno
= save_assign
;
5989 needed_relocs
+= g
->local_gotno
- g
->assigned_gotno
;
5990 BFD_ASSERT (g
->assigned_gotno
== g
->next
->local_gotno
5991 + g
->next
->global_gotno
5992 + MIPS_RESERVED_GOTNO
);
5997 mips_elf_allocate_dynamic_relocations (dynobj
, needed_relocs
);
6000 else if (strcmp (name
, MIPS_ELF_STUB_SECTION_NAME (output_bfd
)) == 0)
6002 /* IRIX rld assumes that the function stub isn't at the end
6003 of .text section. So put a dummy. XXX */
6004 s
->_raw_size
+= MIPS_FUNCTION_STUB_SIZE
;
6006 else if (! info
->shared
6007 && ! mips_elf_hash_table (info
)->use_rld_obj_head
6008 && strncmp (name
, ".rld_map", 8) == 0)
6010 /* We add a room for __rld_map. It will be filled in by the
6011 rtld to contain a pointer to the _r_debug structure. */
6014 else if (SGI_COMPAT (output_bfd
)
6015 && strncmp (name
, ".compact_rel", 12) == 0)
6016 s
->_raw_size
+= mips_elf_hash_table (info
)->compact_rel_size
;
6017 else if (strncmp (name
, ".init", 5) != 0)
6019 /* It's not one of our sections, so don't allocate space. */
6025 _bfd_strip_section_from_output (info
, s
);
6029 /* Allocate memory for the section contents. */
6030 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
6031 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
6033 bfd_set_error (bfd_error_no_memory
);
6038 if (elf_hash_table (info
)->dynamic_sections_created
)
6040 /* Add some entries to the .dynamic section. We fill in the
6041 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
6042 must add the entries now so that we get the correct size for
6043 the .dynamic section. The DT_DEBUG entry is filled in by the
6044 dynamic linker and used by the debugger. */
6047 /* SGI object has the equivalence of DT_DEBUG in the
6048 DT_MIPS_RLD_MAP entry. */
6049 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_MAP
, 0))
6051 if (!SGI_COMPAT (output_bfd
))
6053 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
6059 /* Shared libraries on traditional mips have DT_DEBUG. */
6060 if (!SGI_COMPAT (output_bfd
))
6062 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
6067 if (reltext
&& SGI_COMPAT (output_bfd
))
6068 info
->flags
|= DF_TEXTREL
;
6070 if ((info
->flags
& DF_TEXTREL
) != 0)
6072 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_TEXTREL
, 0))
6076 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTGOT
, 0))
6079 if (mips_elf_rel_dyn_section (dynobj
, FALSE
))
6081 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_REL
, 0))
6084 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELSZ
, 0))
6087 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELENT
, 0))
6091 if (SGI_COMPAT (output_bfd
))
6093 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_CONFLICTNO
, 0))
6097 if (SGI_COMPAT (output_bfd
))
6099 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LIBLISTNO
, 0))
6103 if (bfd_get_section_by_name (dynobj
, ".conflict") != NULL
)
6105 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_CONFLICT
, 0))
6108 s
= bfd_get_section_by_name (dynobj
, ".liblist");
6109 BFD_ASSERT (s
!= NULL
);
6111 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LIBLIST
, 0))
6115 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_VERSION
, 0))
6118 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_FLAGS
, 0))
6122 /* Time stamps in executable files are a bad idea. */
6123 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_TIME_STAMP
, 0))
6128 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_ICHECKSUM
, 0))
6133 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_IVERSION
, 0))
6137 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_BASE_ADDRESS
, 0))
6140 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LOCAL_GOTNO
, 0))
6143 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_SYMTABNO
, 0))
6146 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_UNREFEXTNO
, 0))
6149 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_GOTSYM
, 0))
6152 if (IRIX_COMPAT (dynobj
) == ict_irix5
6153 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_HIPAGENO
, 0))
6156 if (IRIX_COMPAT (dynobj
) == ict_irix6
6157 && (bfd_get_section_by_name
6158 (dynobj
, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj
)))
6159 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_OPTIONS
, 0))
6166 /* Relocate a MIPS ELF section. */
6169 _bfd_mips_elf_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
6170 contents
, relocs
, local_syms
, local_sections
)
6172 struct bfd_link_info
*info
;
6174 asection
*input_section
;
6176 Elf_Internal_Rela
*relocs
;
6177 Elf_Internal_Sym
*local_syms
;
6178 asection
**local_sections
;
6180 Elf_Internal_Rela
*rel
;
6181 const Elf_Internal_Rela
*relend
;
6183 bfd_boolean use_saved_addend_p
= FALSE
;
6184 const struct elf_backend_data
*bed
;
6186 bed
= get_elf_backend_data (output_bfd
);
6187 relend
= relocs
+ input_section
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
6188 for (rel
= relocs
; rel
< relend
; ++rel
)
6192 reloc_howto_type
*howto
;
6193 bfd_boolean require_jalx
;
6194 /* TRUE if the relocation is a RELA relocation, rather than a
6196 bfd_boolean rela_relocation_p
= TRUE
;
6197 unsigned int r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
6198 const char * msg
= (const char *) NULL
;
6200 /* Find the relocation howto for this relocation. */
6201 if (r_type
== R_MIPS_64
&& ! NEWABI_P (input_bfd
))
6203 /* Some 32-bit code uses R_MIPS_64. In particular, people use
6204 64-bit code, but make sure all their addresses are in the
6205 lowermost or uppermost 32-bit section of the 64-bit address
6206 space. Thus, when they use an R_MIPS_64 they mean what is
6207 usually meant by R_MIPS_32, with the exception that the
6208 stored value is sign-extended to 64 bits. */
6209 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, R_MIPS_32
, FALSE
);
6211 /* On big-endian systems, we need to lie about the position
6213 if (bfd_big_endian (input_bfd
))
6217 /* NewABI defaults to RELA relocations. */
6218 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, r_type
,
6219 NEWABI_P (input_bfd
)
6220 && (MIPS_RELOC_RELA_P
6221 (input_bfd
, input_section
,
6224 if (!use_saved_addend_p
)
6226 Elf_Internal_Shdr
*rel_hdr
;
6228 /* If these relocations were originally of the REL variety,
6229 we must pull the addend out of the field that will be
6230 relocated. Otherwise, we simply use the contents of the
6231 RELA relocation. To determine which flavor or relocation
6232 this is, we depend on the fact that the INPUT_SECTION's
6233 REL_HDR is read before its REL_HDR2. */
6234 rel_hdr
= &elf_section_data (input_section
)->rel_hdr
;
6235 if ((size_t) (rel
- relocs
)
6236 >= (NUM_SHDR_ENTRIES (rel_hdr
) * bed
->s
->int_rels_per_ext_rel
))
6237 rel_hdr
= elf_section_data (input_section
)->rel_hdr2
;
6238 if (rel_hdr
->sh_entsize
== MIPS_ELF_REL_SIZE (input_bfd
))
6240 /* Note that this is a REL relocation. */
6241 rela_relocation_p
= FALSE
;
6243 /* Get the addend, which is stored in the input file. */
6244 addend
= mips_elf_obtain_contents (howto
, rel
, input_bfd
,
6246 addend
&= howto
->src_mask
;
6247 addend
<<= howto
->rightshift
;
6249 /* For some kinds of relocations, the ADDEND is a
6250 combination of the addend stored in two different
6252 if (r_type
== R_MIPS_HI16
6253 || r_type
== R_MIPS_GNU_REL_HI16
6254 || (r_type
== R_MIPS_GOT16
6255 && mips_elf_local_relocation_p (input_bfd
, rel
,
6256 local_sections
, FALSE
)))
6259 const Elf_Internal_Rela
*lo16_relocation
;
6260 reloc_howto_type
*lo16_howto
;
6263 /* The combined value is the sum of the HI16 addend,
6264 left-shifted by sixteen bits, and the LO16
6265 addend, sign extended. (Usually, the code does
6266 a `lui' of the HI16 value, and then an `addiu' of
6269 Scan ahead to find a matching LO16 relocation. */
6270 if (r_type
== R_MIPS_GNU_REL_HI16
)
6271 lo
= R_MIPS_GNU_REL_LO16
;
6274 lo16_relocation
= mips_elf_next_relocation (input_bfd
, lo
,
6276 if (lo16_relocation
== NULL
)
6279 /* Obtain the addend kept there. */
6280 lo16_howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, lo
, FALSE
);
6281 l
= mips_elf_obtain_contents (lo16_howto
, lo16_relocation
,
6282 input_bfd
, contents
);
6283 l
&= lo16_howto
->src_mask
;
6284 l
<<= lo16_howto
->rightshift
;
6285 l
= _bfd_mips_elf_sign_extend (l
, 16);
6289 /* Compute the combined addend. */
6292 /* If PC-relative, subtract the difference between the
6293 address of the LO part of the reloc and the address of
6294 the HI part. The relocation is relative to the LO
6295 part, but mips_elf_calculate_relocation() doesn't
6296 know its address or the difference from the HI part, so
6297 we subtract that difference here. See also the
6298 comment in mips_elf_calculate_relocation(). */
6299 if (r_type
== R_MIPS_GNU_REL_HI16
)
6300 addend
-= (lo16_relocation
->r_offset
- rel
->r_offset
);
6302 else if (r_type
== R_MIPS16_GPREL
)
6304 /* The addend is scrambled in the object file. See
6305 mips_elf_perform_relocation for details on the
6307 addend
= (((addend
& 0x1f0000) >> 5)
6308 | ((addend
& 0x7e00000) >> 16)
6313 addend
= rel
->r_addend
;
6316 if (info
->relocatable
)
6318 Elf_Internal_Sym
*sym
;
6319 unsigned long r_symndx
;
6321 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
)
6322 && bfd_big_endian (input_bfd
))
6325 /* Since we're just relocating, all we need to do is copy
6326 the relocations back out to the object file, unless
6327 they're against a section symbol, in which case we need
6328 to adjust by the section offset, or unless they're GP
6329 relative in which case we need to adjust by the amount
6330 that we're adjusting GP in this relocatable object. */
6332 if (! mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
,
6334 /* There's nothing to do for non-local relocations. */
6337 if (r_type
== R_MIPS16_GPREL
6338 || r_type
== R_MIPS_GPREL16
6339 || r_type
== R_MIPS_GPREL32
6340 || r_type
== R_MIPS_LITERAL
)
6341 addend
-= (_bfd_get_gp_value (output_bfd
)
6342 - _bfd_get_gp_value (input_bfd
));
6344 r_symndx
= ELF_R_SYM (output_bfd
, rel
->r_info
);
6345 sym
= local_syms
+ r_symndx
;
6346 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6347 /* Adjust the addend appropriately. */
6348 addend
+= local_sections
[r_symndx
]->output_offset
;
6350 if (howto
->partial_inplace
)
6352 /* If the relocation is for a R_MIPS_HI16 or R_MIPS_GOT16,
6353 then we only want to write out the high-order 16 bits.
6354 The subsequent R_MIPS_LO16 will handle the low-order bits.
6356 if (r_type
== R_MIPS_HI16
|| r_type
== R_MIPS_GOT16
6357 || r_type
== R_MIPS_GNU_REL_HI16
)
6358 addend
= mips_elf_high (addend
);
6359 else if (r_type
== R_MIPS_HIGHER
)
6360 addend
= mips_elf_higher (addend
);
6361 else if (r_type
== R_MIPS_HIGHEST
)
6362 addend
= mips_elf_highest (addend
);
6365 if (rela_relocation_p
)
6366 /* If this is a RELA relocation, just update the addend.
6367 We have to cast away constness for REL. */
6368 rel
->r_addend
= addend
;
6371 /* Otherwise, we have to write the value back out. Note
6372 that we use the source mask, rather than the
6373 destination mask because the place to which we are
6374 writing will be source of the addend in the final
6376 addend
>>= howto
->rightshift
;
6377 addend
&= howto
->src_mask
;
6379 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
6380 /* See the comment above about using R_MIPS_64 in the 32-bit
6381 ABI. Here, we need to update the addend. It would be
6382 possible to get away with just using the R_MIPS_32 reloc
6383 but for endianness. */
6389 if (addend
& ((bfd_vma
) 1 << 31))
6391 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
6398 /* If we don't know that we have a 64-bit type,
6399 do two separate stores. */
6400 if (bfd_big_endian (input_bfd
))
6402 /* Store the sign-bits (which are most significant)
6404 low_bits
= sign_bits
;
6410 high_bits
= sign_bits
;
6412 bfd_put_32 (input_bfd
, low_bits
,
6413 contents
+ rel
->r_offset
);
6414 bfd_put_32 (input_bfd
, high_bits
,
6415 contents
+ rel
->r_offset
+ 4);
6419 if (! mips_elf_perform_relocation (info
, howto
, rel
, addend
,
6420 input_bfd
, input_section
,
6425 /* Go on to the next relocation. */
6429 /* In the N32 and 64-bit ABIs there may be multiple consecutive
6430 relocations for the same offset. In that case we are
6431 supposed to treat the output of each relocation as the addend
6433 if (rel
+ 1 < relend
6434 && rel
->r_offset
== rel
[1].r_offset
6435 && ELF_R_TYPE (input_bfd
, rel
[1].r_info
) != R_MIPS_NONE
)
6436 use_saved_addend_p
= TRUE
;
6438 use_saved_addend_p
= FALSE
;
6440 addend
>>= howto
->rightshift
;
6442 /* Figure out what value we are supposed to relocate. */
6443 switch (mips_elf_calculate_relocation (output_bfd
, input_bfd
,
6444 input_section
, info
, rel
,
6445 addend
, howto
, local_syms
,
6446 local_sections
, &value
,
6447 &name
, &require_jalx
,
6448 use_saved_addend_p
))
6450 case bfd_reloc_continue
:
6451 /* There's nothing to do. */
6454 case bfd_reloc_undefined
:
6455 /* mips_elf_calculate_relocation already called the
6456 undefined_symbol callback. There's no real point in
6457 trying to perform the relocation at this point, so we
6458 just skip ahead to the next relocation. */
6461 case bfd_reloc_notsupported
:
6462 msg
= _("internal error: unsupported relocation error");
6463 info
->callbacks
->warning
6464 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
6467 case bfd_reloc_overflow
:
6468 if (use_saved_addend_p
)
6469 /* Ignore overflow until we reach the last relocation for
6470 a given location. */
6474 BFD_ASSERT (name
!= NULL
);
6475 if (! ((*info
->callbacks
->reloc_overflow
)
6476 (info
, name
, howto
->name
, (bfd_vma
) 0,
6477 input_bfd
, input_section
, rel
->r_offset
)))
6490 /* If we've got another relocation for the address, keep going
6491 until we reach the last one. */
6492 if (use_saved_addend_p
)
6498 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
6499 /* See the comment above about using R_MIPS_64 in the 32-bit
6500 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
6501 that calculated the right value. Now, however, we
6502 sign-extend the 32-bit result to 64-bits, and store it as a
6503 64-bit value. We are especially generous here in that we
6504 go to extreme lengths to support this usage on systems with
6505 only a 32-bit VMA. */
6511 if (value
& ((bfd_vma
) 1 << 31))
6513 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
6520 /* If we don't know that we have a 64-bit type,
6521 do two separate stores. */
6522 if (bfd_big_endian (input_bfd
))
6524 /* Undo what we did above. */
6526 /* Store the sign-bits (which are most significant)
6528 low_bits
= sign_bits
;
6534 high_bits
= sign_bits
;
6536 bfd_put_32 (input_bfd
, low_bits
,
6537 contents
+ rel
->r_offset
);
6538 bfd_put_32 (input_bfd
, high_bits
,
6539 contents
+ rel
->r_offset
+ 4);
6543 /* Actually perform the relocation. */
6544 if (! mips_elf_perform_relocation (info
, howto
, rel
, value
,
6545 input_bfd
, input_section
,
6546 contents
, require_jalx
))
6553 /* If NAME is one of the special IRIX6 symbols defined by the linker,
6554 adjust it appropriately now. */
6557 mips_elf_irix6_finish_dynamic_symbol (abfd
, name
, sym
)
6558 bfd
*abfd ATTRIBUTE_UNUSED
;
6560 Elf_Internal_Sym
*sym
;
6562 /* The linker script takes care of providing names and values for
6563 these, but we must place them into the right sections. */
6564 static const char* const text_section_symbols
[] = {
6567 "__dso_displacement",
6569 "__program_header_table",
6573 static const char* const data_section_symbols
[] = {
6581 const char* const *p
;
6584 for (i
= 0; i
< 2; ++i
)
6585 for (p
= (i
== 0) ? text_section_symbols
: data_section_symbols
;
6588 if (strcmp (*p
, name
) == 0)
6590 /* All of these symbols are given type STT_SECTION by the
6592 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6593 sym
->st_other
= STO_PROTECTED
;
6595 /* The IRIX linker puts these symbols in special sections. */
6597 sym
->st_shndx
= SHN_MIPS_TEXT
;
6599 sym
->st_shndx
= SHN_MIPS_DATA
;
6605 /* Finish up dynamic symbol handling. We set the contents of various
6606 dynamic sections here. */
6609 _bfd_mips_elf_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
6611 struct bfd_link_info
*info
;
6612 struct elf_link_hash_entry
*h
;
6613 Elf_Internal_Sym
*sym
;
6618 struct mips_got_info
*g
, *gg
;
6621 dynobj
= elf_hash_table (info
)->dynobj
;
6622 gval
= sym
->st_value
;
6624 if (h
->plt
.offset
!= (bfd_vma
) -1)
6627 bfd_byte stub
[MIPS_FUNCTION_STUB_SIZE
];
6629 /* This symbol has a stub. Set it up. */
6631 BFD_ASSERT (h
->dynindx
!= -1);
6633 s
= bfd_get_section_by_name (dynobj
,
6634 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
6635 BFD_ASSERT (s
!= NULL
);
6637 /* FIXME: Can h->dynindex be more than 64K? */
6638 if (h
->dynindx
& 0xffff0000)
6641 /* Fill the stub. */
6642 bfd_put_32 (output_bfd
, STUB_LW (output_bfd
), stub
);
6643 bfd_put_32 (output_bfd
, STUB_MOVE (output_bfd
), stub
+ 4);
6644 bfd_put_32 (output_bfd
, STUB_JALR
, stub
+ 8);
6645 bfd_put_32 (output_bfd
, STUB_LI16 (output_bfd
) + h
->dynindx
, stub
+ 12);
6647 BFD_ASSERT (h
->plt
.offset
<= s
->_raw_size
);
6648 memcpy (s
->contents
+ h
->plt
.offset
, stub
, MIPS_FUNCTION_STUB_SIZE
);
6650 /* Mark the symbol as undefined. plt.offset != -1 occurs
6651 only for the referenced symbol. */
6652 sym
->st_shndx
= SHN_UNDEF
;
6654 /* The run-time linker uses the st_value field of the symbol
6655 to reset the global offset table entry for this external
6656 to its stub address when unlinking a shared object. */
6657 gval
= s
->output_section
->vma
+ s
->output_offset
+ h
->plt
.offset
;
6658 sym
->st_value
= gval
;
6661 BFD_ASSERT (h
->dynindx
!= -1
6662 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0);
6664 sgot
= mips_elf_got_section (dynobj
, FALSE
);
6665 BFD_ASSERT (sgot
!= NULL
);
6666 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
6667 g
= mips_elf_section_data (sgot
)->u
.got_info
;
6668 BFD_ASSERT (g
!= NULL
);
6670 /* Run through the global symbol table, creating GOT entries for all
6671 the symbols that need them. */
6672 if (g
->global_gotsym
!= NULL
6673 && h
->dynindx
>= g
->global_gotsym
->dynindx
)
6678 value
= sym
->st_value
;
6679 offset
= mips_elf_global_got_index (dynobj
, output_bfd
, h
);
6680 MIPS_ELF_PUT_WORD (output_bfd
, value
, sgot
->contents
+ offset
);
6683 if (g
->next
&& h
->dynindx
!= -1)
6685 struct mips_got_entry e
, *p
;
6688 Elf_Internal_Rela rel
[3];
6693 e
.abfd
= output_bfd
;
6695 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
6698 || h
->root
.type
== bfd_link_hash_undefined
6699 || h
->root
.type
== bfd_link_hash_undefweak
)
6701 else if (sym
->st_value
)
6702 value
= sym
->st_value
;
6704 value
= h
->root
.u
.def
.value
;
6706 memset (rel
, 0, sizeof (rel
));
6707 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_REL32
);
6709 for (g
= g
->next
; g
->next
!= gg
; g
= g
->next
)
6712 && (p
= (struct mips_got_entry
*) htab_find (g
->got_entries
,
6716 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
6718 MIPS_ELF_PUT_WORD (output_bfd
, value
, sgot
->contents
+ offset
);
6721 || (elf_hash_table (info
)->dynamic_sections_created
6723 && ((p
->d
.h
->root
.elf_link_hash_flags
6724 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0)
6725 && ((p
->d
.h
->root
.elf_link_hash_flags
6726 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
6727 && ! (mips_elf_create_dynamic_relocation
6728 (output_bfd
, info
, rel
,
6729 e
.d
.h
, NULL
, value
, &addend
, sgot
)))
6731 BFD_ASSERT (addend
== 0);
6736 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
6737 name
= h
->root
.root
.string
;
6738 if (strcmp (name
, "_DYNAMIC") == 0
6739 || strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
6740 sym
->st_shndx
= SHN_ABS
;
6741 else if (strcmp (name
, "_DYNAMIC_LINK") == 0
6742 || strcmp (name
, "_DYNAMIC_LINKING") == 0)
6744 sym
->st_shndx
= SHN_ABS
;
6745 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6748 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (output_bfd
))
6750 sym
->st_shndx
= SHN_ABS
;
6751 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6752 sym
->st_value
= elf_gp (output_bfd
);
6754 else if (SGI_COMPAT (output_bfd
))
6756 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
6757 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
6759 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6760 sym
->st_other
= STO_PROTECTED
;
6762 sym
->st_shndx
= SHN_MIPS_DATA
;
6764 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
6766 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6767 sym
->st_other
= STO_PROTECTED
;
6768 sym
->st_value
= mips_elf_hash_table (info
)->procedure_count
;
6769 sym
->st_shndx
= SHN_ABS
;
6771 else if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
!= SHN_ABS
)
6773 if (h
->type
== STT_FUNC
)
6774 sym
->st_shndx
= SHN_MIPS_TEXT
;
6775 else if (h
->type
== STT_OBJECT
)
6776 sym
->st_shndx
= SHN_MIPS_DATA
;
6780 /* Handle the IRIX6-specific symbols. */
6781 if (IRIX_COMPAT (output_bfd
) == ict_irix6
)
6782 mips_elf_irix6_finish_dynamic_symbol (output_bfd
, name
, sym
);
6786 if (! mips_elf_hash_table (info
)->use_rld_obj_head
6787 && (strcmp (name
, "__rld_map") == 0
6788 || strcmp (name
, "__RLD_MAP") == 0))
6790 asection
*s
= bfd_get_section_by_name (dynobj
, ".rld_map");
6791 BFD_ASSERT (s
!= NULL
);
6792 sym
->st_value
= s
->output_section
->vma
+ s
->output_offset
;
6793 bfd_put_32 (output_bfd
, (bfd_vma
) 0, s
->contents
);
6794 if (mips_elf_hash_table (info
)->rld_value
== 0)
6795 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
6797 else if (mips_elf_hash_table (info
)->use_rld_obj_head
6798 && strcmp (name
, "__rld_obj_head") == 0)
6800 /* IRIX6 does not use a .rld_map section. */
6801 if (IRIX_COMPAT (output_bfd
) == ict_irix5
6802 || IRIX_COMPAT (output_bfd
) == ict_none
)
6803 BFD_ASSERT (bfd_get_section_by_name (dynobj
, ".rld_map")
6805 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
6809 /* If this is a mips16 symbol, force the value to be even. */
6810 if (sym
->st_other
== STO_MIPS16
6811 && (sym
->st_value
& 1) != 0)
6817 /* Finish up the dynamic sections. */
6820 _bfd_mips_elf_finish_dynamic_sections (output_bfd
, info
)
6822 struct bfd_link_info
*info
;
6827 struct mips_got_info
*gg
, *g
;
6829 dynobj
= elf_hash_table (info
)->dynobj
;
6831 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
6833 sgot
= mips_elf_got_section (dynobj
, FALSE
);
6838 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
6839 gg
= mips_elf_section_data (sgot
)->u
.got_info
;
6840 BFD_ASSERT (gg
!= NULL
);
6841 g
= mips_elf_got_for_ibfd (gg
, output_bfd
);
6842 BFD_ASSERT (g
!= NULL
);
6845 if (elf_hash_table (info
)->dynamic_sections_created
)
6849 BFD_ASSERT (sdyn
!= NULL
);
6850 BFD_ASSERT (g
!= NULL
);
6852 for (b
= sdyn
->contents
;
6853 b
< sdyn
->contents
+ sdyn
->_raw_size
;
6854 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
6856 Elf_Internal_Dyn dyn
;
6860 bfd_boolean swap_out_p
;
6862 /* Read in the current dynamic entry. */
6863 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
6865 /* Assume that we're going to modify it and write it out. */
6871 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
6872 BFD_ASSERT (s
!= NULL
);
6873 dyn
.d_un
.d_val
= MIPS_ELF_REL_SIZE (dynobj
);
6877 /* Rewrite DT_STRSZ. */
6879 _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
6885 case DT_MIPS_CONFLICT
:
6888 case DT_MIPS_LIBLIST
:
6891 s
= bfd_get_section_by_name (output_bfd
, name
);
6892 BFD_ASSERT (s
!= NULL
);
6893 dyn
.d_un
.d_ptr
= s
->vma
;
6896 case DT_MIPS_RLD_VERSION
:
6897 dyn
.d_un
.d_val
= 1; /* XXX */
6901 dyn
.d_un
.d_val
= RHF_NOTPOT
; /* XXX */
6904 case DT_MIPS_CONFLICTNO
:
6906 elemsize
= sizeof (Elf32_Conflict
);
6909 case DT_MIPS_LIBLISTNO
:
6911 elemsize
= sizeof (Elf32_Lib
);
6913 s
= bfd_get_section_by_name (output_bfd
, name
);
6916 if (s
->_cooked_size
!= 0)
6917 dyn
.d_un
.d_val
= s
->_cooked_size
/ elemsize
;
6919 dyn
.d_un
.d_val
= s
->_raw_size
/ elemsize
;
6925 case DT_MIPS_TIME_STAMP
:
6926 time ((time_t *) &dyn
.d_un
.d_val
);
6929 case DT_MIPS_ICHECKSUM
:
6934 case DT_MIPS_IVERSION
:
6939 case DT_MIPS_BASE_ADDRESS
:
6940 s
= output_bfd
->sections
;
6941 BFD_ASSERT (s
!= NULL
);
6942 dyn
.d_un
.d_ptr
= s
->vma
& ~(bfd_vma
) 0xffff;
6945 case DT_MIPS_LOCAL_GOTNO
:
6946 dyn
.d_un
.d_val
= g
->local_gotno
;
6949 case DT_MIPS_UNREFEXTNO
:
6950 /* The index into the dynamic symbol table which is the
6951 entry of the first external symbol that is not
6952 referenced within the same object. */
6953 dyn
.d_un
.d_val
= bfd_count_sections (output_bfd
) + 1;
6956 case DT_MIPS_GOTSYM
:
6957 if (gg
->global_gotsym
)
6959 dyn
.d_un
.d_val
= gg
->global_gotsym
->dynindx
;
6962 /* In case if we don't have global got symbols we default
6963 to setting DT_MIPS_GOTSYM to the same value as
6964 DT_MIPS_SYMTABNO, so we just fall through. */
6966 case DT_MIPS_SYMTABNO
:
6968 elemsize
= MIPS_ELF_SYM_SIZE (output_bfd
);
6969 s
= bfd_get_section_by_name (output_bfd
, name
);
6970 BFD_ASSERT (s
!= NULL
);
6972 if (s
->_cooked_size
!= 0)
6973 dyn
.d_un
.d_val
= s
->_cooked_size
/ elemsize
;
6975 dyn
.d_un
.d_val
= s
->_raw_size
/ elemsize
;
6978 case DT_MIPS_HIPAGENO
:
6979 dyn
.d_un
.d_val
= g
->local_gotno
- MIPS_RESERVED_GOTNO
;
6982 case DT_MIPS_RLD_MAP
:
6983 dyn
.d_un
.d_ptr
= mips_elf_hash_table (info
)->rld_value
;
6986 case DT_MIPS_OPTIONS
:
6987 s
= (bfd_get_section_by_name
6988 (output_bfd
, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd
)));
6989 dyn
.d_un
.d_ptr
= s
->vma
;
6993 s
= (bfd_get_section_by_name (output_bfd
, ".msym"));
6994 dyn
.d_un
.d_ptr
= s
->vma
;
7003 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
7008 /* The first entry of the global offset table will be filled at
7009 runtime. The second entry will be used by some runtime loaders.
7010 This isn't the case of IRIX rld. */
7011 if (sgot
!= NULL
&& sgot
->_raw_size
> 0)
7013 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
7014 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0x80000000,
7015 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
7019 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
7020 = MIPS_ELF_GOT_SIZE (output_bfd
);
7022 /* Generate dynamic relocations for the non-primary gots. */
7023 if (gg
!= NULL
&& gg
->next
)
7025 Elf_Internal_Rela rel
[3];
7028 memset (rel
, 0, sizeof (rel
));
7029 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_REL32
);
7031 for (g
= gg
->next
; g
->next
!= gg
; g
= g
->next
)
7033 bfd_vma index
= g
->next
->local_gotno
+ g
->next
->global_gotno
;
7035 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0, sgot
->contents
7036 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
7037 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0x80000000, sgot
->contents
7038 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
7043 while (index
< g
->assigned_gotno
)
7045 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
7046 = index
++ * MIPS_ELF_GOT_SIZE (output_bfd
);
7047 if (!(mips_elf_create_dynamic_relocation
7048 (output_bfd
, info
, rel
, NULL
,
7049 bfd_abs_section_ptr
,
7052 BFD_ASSERT (addend
== 0);
7059 Elf32_compact_rel cpt
;
7061 if (SGI_COMPAT (output_bfd
))
7063 /* Write .compact_rel section out. */
7064 s
= bfd_get_section_by_name (dynobj
, ".compact_rel");
7068 cpt
.num
= s
->reloc_count
;
7070 cpt
.offset
= (s
->output_section
->filepos
7071 + sizeof (Elf32_External_compact_rel
));
7074 bfd_elf32_swap_compact_rel_out (output_bfd
, &cpt
,
7075 ((Elf32_External_compact_rel
*)
7078 /* Clean up a dummy stub function entry in .text. */
7079 s
= bfd_get_section_by_name (dynobj
,
7080 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
7083 file_ptr dummy_offset
;
7085 BFD_ASSERT (s
->_raw_size
>= MIPS_FUNCTION_STUB_SIZE
);
7086 dummy_offset
= s
->_raw_size
- MIPS_FUNCTION_STUB_SIZE
;
7087 memset (s
->contents
+ dummy_offset
, 0,
7088 MIPS_FUNCTION_STUB_SIZE
);
7093 /* We need to sort the entries of the dynamic relocation section. */
7095 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
7098 && s
->_raw_size
> (bfd_vma
)2 * MIPS_ELF_REL_SIZE (output_bfd
))
7100 reldyn_sorting_bfd
= output_bfd
;
7102 if (ABI_64_P (output_bfd
))
7103 qsort ((Elf64_External_Rel
*) s
->contents
+ 1,
7104 (size_t) s
->reloc_count
- 1,
7105 sizeof (Elf64_Mips_External_Rel
), sort_dynamic_relocs_64
);
7107 qsort ((Elf32_External_Rel
*) s
->contents
+ 1,
7108 (size_t) s
->reloc_count
- 1,
7109 sizeof (Elf32_External_Rel
), sort_dynamic_relocs
);
7117 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
7120 mips_set_isa_flags (abfd
)
7125 switch (bfd_get_mach (abfd
))
7128 case bfd_mach_mips3000
:
7129 val
= E_MIPS_ARCH_1
;
7132 case bfd_mach_mips3900
:
7133 val
= E_MIPS_ARCH_1
| E_MIPS_MACH_3900
;
7136 case bfd_mach_mips6000
:
7137 val
= E_MIPS_ARCH_2
;
7140 case bfd_mach_mips4000
:
7141 case bfd_mach_mips4300
:
7142 case bfd_mach_mips4400
:
7143 case bfd_mach_mips4600
:
7144 val
= E_MIPS_ARCH_3
;
7147 case bfd_mach_mips4010
:
7148 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4010
;
7151 case bfd_mach_mips4100
:
7152 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4100
;
7155 case bfd_mach_mips4111
:
7156 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4111
;
7159 case bfd_mach_mips4120
:
7160 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4120
;
7163 case bfd_mach_mips4650
:
7164 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4650
;
7167 case bfd_mach_mips5400
:
7168 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5400
;
7171 case bfd_mach_mips5500
:
7172 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5500
;
7175 case bfd_mach_mips5000
:
7176 case bfd_mach_mips7000
:
7177 case bfd_mach_mips8000
:
7178 case bfd_mach_mips10000
:
7179 case bfd_mach_mips12000
:
7180 val
= E_MIPS_ARCH_4
;
7183 case bfd_mach_mips5
:
7184 val
= E_MIPS_ARCH_5
;
7187 case bfd_mach_mips_sb1
:
7188 val
= E_MIPS_ARCH_64
| E_MIPS_MACH_SB1
;
7191 case bfd_mach_mipsisa32
:
7192 val
= E_MIPS_ARCH_32
;
7195 case bfd_mach_mipsisa64
:
7196 val
= E_MIPS_ARCH_64
;
7199 case bfd_mach_mipsisa32r2
:
7200 val
= E_MIPS_ARCH_32R2
;
7203 case bfd_mach_mipsisa64r2
:
7204 val
= E_MIPS_ARCH_64R2
;
7207 elf_elfheader (abfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
7208 elf_elfheader (abfd
)->e_flags
|= val
;
7213 /* The final processing done just before writing out a MIPS ELF object
7214 file. This gets the MIPS architecture right based on the machine
7215 number. This is used by both the 32-bit and the 64-bit ABI. */
7218 _bfd_mips_elf_final_write_processing (abfd
, linker
)
7220 bfd_boolean linker ATTRIBUTE_UNUSED
;
7223 Elf_Internal_Shdr
**hdrpp
;
7227 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
7228 is nonzero. This is for compatibility with old objects, which used
7229 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
7230 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_MACH
) == 0)
7231 mips_set_isa_flags (abfd
);
7233 /* Set the sh_info field for .gptab sections and other appropriate
7234 info for each special section. */
7235 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
7236 i
< elf_numsections (abfd
);
7239 switch ((*hdrpp
)->sh_type
)
7242 case SHT_MIPS_LIBLIST
:
7243 sec
= bfd_get_section_by_name (abfd
, ".dynstr");
7245 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7248 case SHT_MIPS_GPTAB
:
7249 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7250 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7251 BFD_ASSERT (name
!= NULL
7252 && strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0);
7253 sec
= bfd_get_section_by_name (abfd
, name
+ sizeof ".gptab" - 1);
7254 BFD_ASSERT (sec
!= NULL
);
7255 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
7258 case SHT_MIPS_CONTENT
:
7259 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7260 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7261 BFD_ASSERT (name
!= NULL
7262 && strncmp (name
, ".MIPS.content",
7263 sizeof ".MIPS.content" - 1) == 0);
7264 sec
= bfd_get_section_by_name (abfd
,
7265 name
+ sizeof ".MIPS.content" - 1);
7266 BFD_ASSERT (sec
!= NULL
);
7267 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7270 case SHT_MIPS_SYMBOL_LIB
:
7271 sec
= bfd_get_section_by_name (abfd
, ".dynsym");
7273 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7274 sec
= bfd_get_section_by_name (abfd
, ".liblist");
7276 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
7279 case SHT_MIPS_EVENTS
:
7280 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7281 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7282 BFD_ASSERT (name
!= NULL
);
7283 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0)
7284 sec
= bfd_get_section_by_name (abfd
,
7285 name
+ sizeof ".MIPS.events" - 1);
7288 BFD_ASSERT (strncmp (name
, ".MIPS.post_rel",
7289 sizeof ".MIPS.post_rel" - 1) == 0);
7290 sec
= bfd_get_section_by_name (abfd
,
7292 + sizeof ".MIPS.post_rel" - 1));
7294 BFD_ASSERT (sec
!= NULL
);
7295 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7302 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
7306 _bfd_mips_elf_additional_program_headers (abfd
)
7312 /* See if we need a PT_MIPS_REGINFO segment. */
7313 s
= bfd_get_section_by_name (abfd
, ".reginfo");
7314 if (s
&& (s
->flags
& SEC_LOAD
))
7317 /* See if we need a PT_MIPS_OPTIONS segment. */
7318 if (IRIX_COMPAT (abfd
) == ict_irix6
7319 && bfd_get_section_by_name (abfd
,
7320 MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)))
7323 /* See if we need a PT_MIPS_RTPROC segment. */
7324 if (IRIX_COMPAT (abfd
) == ict_irix5
7325 && bfd_get_section_by_name (abfd
, ".dynamic")
7326 && bfd_get_section_by_name (abfd
, ".mdebug"))
7332 /* Modify the segment map for an IRIX5 executable. */
7335 _bfd_mips_elf_modify_segment_map (abfd
)
7339 struct elf_segment_map
*m
, **pm
;
7342 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
7344 s
= bfd_get_section_by_name (abfd
, ".reginfo");
7345 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
7347 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
7348 if (m
->p_type
== PT_MIPS_REGINFO
)
7353 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
7357 m
->p_type
= PT_MIPS_REGINFO
;
7361 /* We want to put it after the PHDR and INTERP segments. */
7362 pm
= &elf_tdata (abfd
)->segment_map
;
7364 && ((*pm
)->p_type
== PT_PHDR
7365 || (*pm
)->p_type
== PT_INTERP
))
7373 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
7374 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
7375 PT_OPTIONS segment immediately following the program header
7378 /* On non-IRIX6 new abi, we'll have already created a segment
7379 for this section, so don't create another. I'm not sure this
7380 is not also the case for IRIX 6, but I can't test it right
7382 && IRIX_COMPAT (abfd
) == ict_irix6
)
7384 for (s
= abfd
->sections
; s
; s
= s
->next
)
7385 if (elf_section_data (s
)->this_hdr
.sh_type
== SHT_MIPS_OPTIONS
)
7390 struct elf_segment_map
*options_segment
;
7392 /* Usually, there's a program header table. But, sometimes
7393 there's not (like when running the `ld' testsuite). So,
7394 if there's no program header table, we just put the
7395 options segment at the end. */
7396 for (pm
= &elf_tdata (abfd
)->segment_map
;
7399 if ((*pm
)->p_type
== PT_PHDR
)
7402 amt
= sizeof (struct elf_segment_map
);
7403 options_segment
= bfd_zalloc (abfd
, amt
);
7404 options_segment
->next
= *pm
;
7405 options_segment
->p_type
= PT_MIPS_OPTIONS
;
7406 options_segment
->p_flags
= PF_R
;
7407 options_segment
->p_flags_valid
= TRUE
;
7408 options_segment
->count
= 1;
7409 options_segment
->sections
[0] = s
;
7410 *pm
= options_segment
;
7415 if (IRIX_COMPAT (abfd
) == ict_irix5
)
7417 /* If there are .dynamic and .mdebug sections, we make a room
7418 for the RTPROC header. FIXME: Rewrite without section names. */
7419 if (bfd_get_section_by_name (abfd
, ".interp") == NULL
7420 && bfd_get_section_by_name (abfd
, ".dynamic") != NULL
7421 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
7423 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
7424 if (m
->p_type
== PT_MIPS_RTPROC
)
7429 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
7433 m
->p_type
= PT_MIPS_RTPROC
;
7435 s
= bfd_get_section_by_name (abfd
, ".rtproc");
7440 m
->p_flags_valid
= 1;
7448 /* We want to put it after the DYNAMIC segment. */
7449 pm
= &elf_tdata (abfd
)->segment_map
;
7450 while (*pm
!= NULL
&& (*pm
)->p_type
!= PT_DYNAMIC
)
7460 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
7461 .dynstr, .dynsym, and .hash sections, and everything in
7463 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
;
7465 if ((*pm
)->p_type
== PT_DYNAMIC
)
7468 if (m
!= NULL
&& IRIX_COMPAT (abfd
) == ict_none
)
7470 /* For a normal mips executable the permissions for the PT_DYNAMIC
7471 segment are read, write and execute. We do that here since
7472 the code in elf.c sets only the read permission. This matters
7473 sometimes for the dynamic linker. */
7474 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
7476 m
->p_flags
= PF_R
| PF_W
| PF_X
;
7477 m
->p_flags_valid
= 1;
7481 && m
->count
== 1 && strcmp (m
->sections
[0]->name
, ".dynamic") == 0)
7483 static const char *sec_names
[] =
7485 ".dynamic", ".dynstr", ".dynsym", ".hash"
7489 struct elf_segment_map
*n
;
7493 for (i
= 0; i
< sizeof sec_names
/ sizeof sec_names
[0]; i
++)
7495 s
= bfd_get_section_by_name (abfd
, sec_names
[i
]);
7496 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
7502 sz
= s
->_cooked_size
;
7505 if (high
< s
->vma
+ sz
)
7511 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
7512 if ((s
->flags
& SEC_LOAD
) != 0
7515 + (s
->_cooked_size
!=
7516 0 ? s
->_cooked_size
: s
->_raw_size
)) <= high
))
7519 amt
= sizeof *n
+ (bfd_size_type
) (c
- 1) * sizeof (asection
*);
7520 n
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
7527 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
7529 if ((s
->flags
& SEC_LOAD
) != 0
7532 + (s
->_cooked_size
!= 0 ?
7533 s
->_cooked_size
: s
->_raw_size
)) <= high
))
7547 /* Return the section that should be marked against GC for a given
7551 _bfd_mips_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
)
7553 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
7554 Elf_Internal_Rela
*rel
;
7555 struct elf_link_hash_entry
*h
;
7556 Elf_Internal_Sym
*sym
;
7558 /* ??? Do mips16 stub sections need to be handled special? */
7562 switch (ELF_R_TYPE (sec
->owner
, rel
->r_info
))
7564 case R_MIPS_GNU_VTINHERIT
:
7565 case R_MIPS_GNU_VTENTRY
:
7569 switch (h
->root
.type
)
7571 case bfd_link_hash_defined
:
7572 case bfd_link_hash_defweak
:
7573 return h
->root
.u
.def
.section
;
7575 case bfd_link_hash_common
:
7576 return h
->root
.u
.c
.p
->section
;
7584 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
7589 /* Update the got entry reference counts for the section being removed. */
7592 _bfd_mips_elf_gc_sweep_hook (abfd
, info
, sec
, relocs
)
7593 bfd
*abfd ATTRIBUTE_UNUSED
;
7594 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
7595 asection
*sec ATTRIBUTE_UNUSED
;
7596 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
;
7599 Elf_Internal_Shdr
*symtab_hdr
;
7600 struct elf_link_hash_entry
**sym_hashes
;
7601 bfd_signed_vma
*local_got_refcounts
;
7602 const Elf_Internal_Rela
*rel
, *relend
;
7603 unsigned long r_symndx
;
7604 struct elf_link_hash_entry
*h
;
7606 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7607 sym_hashes
= elf_sym_hashes (abfd
);
7608 local_got_refcounts
= elf_local_got_refcounts (abfd
);
7610 relend
= relocs
+ sec
->reloc_count
;
7611 for (rel
= relocs
; rel
< relend
; rel
++)
7612 switch (ELF_R_TYPE (abfd
, rel
->r_info
))
7616 case R_MIPS_CALL_HI16
:
7617 case R_MIPS_CALL_LO16
:
7618 case R_MIPS_GOT_HI16
:
7619 case R_MIPS_GOT_LO16
:
7620 case R_MIPS_GOT_DISP
:
7621 case R_MIPS_GOT_PAGE
:
7622 case R_MIPS_GOT_OFST
:
7623 /* ??? It would seem that the existing MIPS code does no sort
7624 of reference counting or whatnot on its GOT and PLT entries,
7625 so it is not possible to garbage collect them at this time. */
7636 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
7637 hiding the old indirect symbol. Process additional relocation
7638 information. Also called for weakdefs, in which case we just let
7639 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
7642 _bfd_mips_elf_copy_indirect_symbol (bed
, dir
, ind
)
7643 const struct elf_backend_data
*bed
;
7644 struct elf_link_hash_entry
*dir
, *ind
;
7646 struct mips_elf_link_hash_entry
*dirmips
, *indmips
;
7648 _bfd_elf_link_hash_copy_indirect (bed
, dir
, ind
);
7650 if (ind
->root
.type
!= bfd_link_hash_indirect
)
7653 dirmips
= (struct mips_elf_link_hash_entry
*) dir
;
7654 indmips
= (struct mips_elf_link_hash_entry
*) ind
;
7655 dirmips
->possibly_dynamic_relocs
+= indmips
->possibly_dynamic_relocs
;
7656 if (indmips
->readonly_reloc
)
7657 dirmips
->readonly_reloc
= TRUE
;
7658 if (indmips
->no_fn_stub
)
7659 dirmips
->no_fn_stub
= TRUE
;
7663 _bfd_mips_elf_hide_symbol (info
, entry
, force_local
)
7664 struct bfd_link_info
*info
;
7665 struct elf_link_hash_entry
*entry
;
7666 bfd_boolean force_local
;
7670 struct mips_got_info
*g
;
7671 struct mips_elf_link_hash_entry
*h
;
7673 h
= (struct mips_elf_link_hash_entry
*) entry
;
7674 if (h
->forced_local
)
7676 h
->forced_local
= force_local
;
7678 dynobj
= elf_hash_table (info
)->dynobj
;
7679 if (dynobj
!= NULL
&& force_local
)
7681 got
= mips_elf_got_section (dynobj
, FALSE
);
7682 g
= mips_elf_section_data (got
)->u
.got_info
;
7686 struct mips_got_entry e
;
7687 struct mips_got_info
*gg
= g
;
7689 /* Since we're turning what used to be a global symbol into a
7690 local one, bump up the number of local entries of each GOT
7691 that had an entry for it. This will automatically decrease
7692 the number of global entries, since global_gotno is actually
7693 the upper limit of global entries. */
7698 for (g
= g
->next
; g
!= gg
; g
= g
->next
)
7699 if (htab_find (g
->got_entries
, &e
))
7701 BFD_ASSERT (g
->global_gotno
> 0);
7706 /* If this was a global symbol forced into the primary GOT, we
7707 no longer need an entry for it. We can't release the entry
7708 at this point, but we must at least stop counting it as one
7709 of the symbols that required a forced got entry. */
7710 if (h
->root
.got
.offset
== 2)
7712 BFD_ASSERT (gg
->assigned_gotno
> 0);
7713 gg
->assigned_gotno
--;
7716 else if (g
->global_gotno
== 0 && g
->global_gotsym
== NULL
)
7717 /* If we haven't got through GOT allocation yet, just bump up the
7718 number of local entries, as this symbol won't be counted as
7721 else if (h
->root
.got
.offset
== 1)
7723 /* If we're past non-multi-GOT allocation and this symbol had
7724 been marked for a global got entry, give it a local entry
7726 BFD_ASSERT (g
->global_gotno
> 0);
7732 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
7738 _bfd_mips_elf_discard_info (abfd
, cookie
, info
)
7740 struct elf_reloc_cookie
*cookie
;
7741 struct bfd_link_info
*info
;
7744 bfd_boolean ret
= FALSE
;
7745 unsigned char *tdata
;
7748 o
= bfd_get_section_by_name (abfd
, ".pdr");
7751 if (o
->_raw_size
== 0)
7753 if (o
->_raw_size
% PDR_SIZE
!= 0)
7755 if (o
->output_section
!= NULL
7756 && bfd_is_abs_section (o
->output_section
))
7759 tdata
= bfd_zmalloc (o
->_raw_size
/ PDR_SIZE
);
7763 cookie
->rels
= _bfd_elf_link_read_relocs (abfd
, o
, (PTR
) NULL
,
7764 (Elf_Internal_Rela
*) NULL
,
7772 cookie
->rel
= cookie
->rels
;
7773 cookie
->relend
= cookie
->rels
+ o
->reloc_count
;
7775 for (i
= 0, skip
= 0; i
< o
->_raw_size
/ PDR_SIZE
; i
++)
7777 if (MNAME(abfd
,_bfd_elf
,reloc_symbol_deleted_p
) (i
* PDR_SIZE
, cookie
))
7786 mips_elf_section_data (o
)->u
.tdata
= tdata
;
7787 o
->_cooked_size
= o
->_raw_size
- skip
* PDR_SIZE
;
7793 if (! info
->keep_memory
)
7794 free (cookie
->rels
);
7800 _bfd_mips_elf_ignore_discarded_relocs (sec
)
7803 if (strcmp (sec
->name
, ".pdr") == 0)
7809 _bfd_mips_elf_write_section (output_bfd
, sec
, contents
)
7814 bfd_byte
*to
, *from
, *end
;
7817 if (strcmp (sec
->name
, ".pdr") != 0)
7820 if (mips_elf_section_data (sec
)->u
.tdata
== NULL
)
7824 end
= contents
+ sec
->_raw_size
;
7825 for (from
= contents
, i
= 0;
7827 from
+= PDR_SIZE
, i
++)
7829 if ((mips_elf_section_data (sec
)->u
.tdata
)[i
] == 1)
7832 memcpy (to
, from
, PDR_SIZE
);
7835 bfd_set_section_contents (output_bfd
, sec
->output_section
, contents
,
7836 (file_ptr
) sec
->output_offset
,
7841 /* MIPS ELF uses a special find_nearest_line routine in order the
7842 handle the ECOFF debugging information. */
7844 struct mips_elf_find_line
7846 struct ecoff_debug_info d
;
7847 struct ecoff_find_line i
;
7851 _bfd_mips_elf_find_nearest_line (abfd
, section
, symbols
, offset
, filename_ptr
,
7852 functionname_ptr
, line_ptr
)
7857 const char **filename_ptr
;
7858 const char **functionname_ptr
;
7859 unsigned int *line_ptr
;
7863 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
7864 filename_ptr
, functionname_ptr
,
7868 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
7869 filename_ptr
, functionname_ptr
,
7871 (unsigned) (ABI_64_P (abfd
) ? 8 : 0),
7872 &elf_tdata (abfd
)->dwarf2_find_line_info
))
7875 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
7879 struct mips_elf_find_line
*fi
;
7880 const struct ecoff_debug_swap
* const swap
=
7881 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
7883 /* If we are called during a link, mips_elf_final_link may have
7884 cleared the SEC_HAS_CONTENTS field. We force it back on here
7885 if appropriate (which it normally will be). */
7886 origflags
= msec
->flags
;
7887 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
7888 msec
->flags
|= SEC_HAS_CONTENTS
;
7890 fi
= elf_tdata (abfd
)->find_line_info
;
7893 bfd_size_type external_fdr_size
;
7896 struct fdr
*fdr_ptr
;
7897 bfd_size_type amt
= sizeof (struct mips_elf_find_line
);
7899 fi
= (struct mips_elf_find_line
*) bfd_zalloc (abfd
, amt
);
7902 msec
->flags
= origflags
;
7906 if (! _bfd_mips_elf_read_ecoff_info (abfd
, msec
, &fi
->d
))
7908 msec
->flags
= origflags
;
7912 /* Swap in the FDR information. */
7913 amt
= fi
->d
.symbolic_header
.ifdMax
* sizeof (struct fdr
);
7914 fi
->d
.fdr
= (struct fdr
*) bfd_alloc (abfd
, amt
);
7915 if (fi
->d
.fdr
== NULL
)
7917 msec
->flags
= origflags
;
7920 external_fdr_size
= swap
->external_fdr_size
;
7921 fdr_ptr
= fi
->d
.fdr
;
7922 fraw_src
= (char *) fi
->d
.external_fdr
;
7923 fraw_end
= (fraw_src
7924 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
7925 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
7926 (*swap
->swap_fdr_in
) (abfd
, (PTR
) fraw_src
, fdr_ptr
);
7928 elf_tdata (abfd
)->find_line_info
= fi
;
7930 /* Note that we don't bother to ever free this information.
7931 find_nearest_line is either called all the time, as in
7932 objdump -l, so the information should be saved, or it is
7933 rarely called, as in ld error messages, so the memory
7934 wasted is unimportant. Still, it would probably be a
7935 good idea for free_cached_info to throw it away. */
7938 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
7939 &fi
->i
, filename_ptr
, functionname_ptr
,
7942 msec
->flags
= origflags
;
7946 msec
->flags
= origflags
;
7949 /* Fall back on the generic ELF find_nearest_line routine. */
7951 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
7952 filename_ptr
, functionname_ptr
,
7956 /* When are writing out the .options or .MIPS.options section,
7957 remember the bytes we are writing out, so that we can install the
7958 GP value in the section_processing routine. */
7961 _bfd_mips_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
7966 bfd_size_type count
;
7968 if (strcmp (section
->name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
7972 if (elf_section_data (section
) == NULL
)
7974 bfd_size_type amt
= sizeof (struct bfd_elf_section_data
);
7975 section
->used_by_bfd
= (PTR
) bfd_zalloc (abfd
, amt
);
7976 if (elf_section_data (section
) == NULL
)
7979 c
= mips_elf_section_data (section
)->u
.tdata
;
7984 if (section
->_cooked_size
!= 0)
7985 size
= section
->_cooked_size
;
7987 size
= section
->_raw_size
;
7988 c
= (bfd_byte
*) bfd_zalloc (abfd
, size
);
7991 mips_elf_section_data (section
)->u
.tdata
= c
;
7994 memcpy (c
+ offset
, location
, (size_t) count
);
7997 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
,
8001 /* This is almost identical to bfd_generic_get_... except that some
8002 MIPS relocations need to be handled specially. Sigh. */
8005 _bfd_elf_mips_get_relocated_section_contents (abfd
, link_info
, link_order
,
8006 data
, relocatable
, symbols
)
8008 struct bfd_link_info
*link_info
;
8009 struct bfd_link_order
*link_order
;
8011 bfd_boolean relocatable
;
8014 /* Get enough memory to hold the stuff */
8015 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
8016 asection
*input_section
= link_order
->u
.indirect
.section
;
8018 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
8019 arelent
**reloc_vector
= NULL
;
8025 reloc_vector
= (arelent
**) bfd_malloc ((bfd_size_type
) reloc_size
);
8026 if (reloc_vector
== NULL
&& reloc_size
!= 0)
8029 /* read in the section */
8030 if (!bfd_get_section_contents (input_bfd
,
8034 input_section
->_raw_size
))
8037 /* We're not relaxing the section, so just copy the size info */
8038 input_section
->_cooked_size
= input_section
->_raw_size
;
8039 input_section
->reloc_done
= TRUE
;
8041 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
8045 if (reloc_count
< 0)
8048 if (reloc_count
> 0)
8053 bfd_vma gp
= 0x12345678; /* initialize just to shut gcc up */
8056 struct bfd_hash_entry
*h
;
8057 struct bfd_link_hash_entry
*lh
;
8058 /* Skip all this stuff if we aren't mixing formats. */
8059 if (abfd
&& input_bfd
8060 && abfd
->xvec
== input_bfd
->xvec
)
8064 h
= bfd_hash_lookup (&link_info
->hash
->table
, "_gp", FALSE
, FALSE
);
8065 lh
= (struct bfd_link_hash_entry
*) h
;
8072 case bfd_link_hash_undefined
:
8073 case bfd_link_hash_undefweak
:
8074 case bfd_link_hash_common
:
8077 case bfd_link_hash_defined
:
8078 case bfd_link_hash_defweak
:
8080 gp
= lh
->u
.def
.value
;
8082 case bfd_link_hash_indirect
:
8083 case bfd_link_hash_warning
:
8085 /* @@FIXME ignoring warning for now */
8087 case bfd_link_hash_new
:
8096 for (parent
= reloc_vector
; *parent
!= (arelent
*) NULL
;
8099 char *error_message
= (char *) NULL
;
8100 bfd_reloc_status_type r
;
8102 /* Specific to MIPS: Deal with relocation types that require
8103 knowing the gp of the output bfd. */
8104 asymbol
*sym
= *(*parent
)->sym_ptr_ptr
;
8105 if (bfd_is_abs_section (sym
->section
) && abfd
)
8107 /* The special_function wouldn't get called anyway. */
8111 /* The gp isn't there; let the special function code
8112 fall over on its own. */
8114 else if ((*parent
)->howto
->special_function
8115 == _bfd_mips_elf32_gprel16_reloc
)
8117 /* bypass special_function call */
8118 r
= _bfd_mips_elf_gprel16_with_gp (input_bfd
, sym
, *parent
,
8119 input_section
, relocatable
,
8121 goto skip_bfd_perform_relocation
;
8123 /* end mips specific stuff */
8125 r
= bfd_perform_relocation (input_bfd
,
8129 relocatable
? abfd
: (bfd
*) NULL
,
8131 skip_bfd_perform_relocation
:
8135 asection
*os
= input_section
->output_section
;
8137 /* A partial link, so keep the relocs */
8138 os
->orelocation
[os
->reloc_count
] = *parent
;
8142 if (r
!= bfd_reloc_ok
)
8146 case bfd_reloc_undefined
:
8147 if (!((*link_info
->callbacks
->undefined_symbol
)
8148 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
8149 input_bfd
, input_section
, (*parent
)->address
,
8153 case bfd_reloc_dangerous
:
8154 BFD_ASSERT (error_message
!= (char *) NULL
);
8155 if (!((*link_info
->callbacks
->reloc_dangerous
)
8156 (link_info
, error_message
, input_bfd
, input_section
,
8157 (*parent
)->address
)))
8160 case bfd_reloc_overflow
:
8161 if (!((*link_info
->callbacks
->reloc_overflow
)
8162 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
8163 (*parent
)->howto
->name
, (*parent
)->addend
,
8164 input_bfd
, input_section
, (*parent
)->address
)))
8167 case bfd_reloc_outofrange
:
8176 if (reloc_vector
!= NULL
)
8177 free (reloc_vector
);
8181 if (reloc_vector
!= NULL
)
8182 free (reloc_vector
);
8186 /* Create a MIPS ELF linker hash table. */
8188 struct bfd_link_hash_table
*
8189 _bfd_mips_elf_link_hash_table_create (abfd
)
8192 struct mips_elf_link_hash_table
*ret
;
8193 bfd_size_type amt
= sizeof (struct mips_elf_link_hash_table
);
8195 ret
= (struct mips_elf_link_hash_table
*) bfd_malloc (amt
);
8196 if (ret
== (struct mips_elf_link_hash_table
*) NULL
)
8199 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
8200 mips_elf_link_hash_newfunc
))
8207 /* We no longer use this. */
8208 for (i
= 0; i
< SIZEOF_MIPS_DYNSYM_SECNAMES
; i
++)
8209 ret
->dynsym_sec_strindex
[i
] = (bfd_size_type
) -1;
8211 ret
->procedure_count
= 0;
8212 ret
->compact_rel_size
= 0;
8213 ret
->use_rld_obj_head
= FALSE
;
8215 ret
->mips16_stubs_seen
= FALSE
;
8217 return &ret
->root
.root
;
8220 /* We need to use a special link routine to handle the .reginfo and
8221 the .mdebug sections. We need to merge all instances of these
8222 sections together, not write them all out sequentially. */
8225 _bfd_mips_elf_final_link (abfd
, info
)
8227 struct bfd_link_info
*info
;
8231 struct bfd_link_order
*p
;
8232 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
8233 asection
*rtproc_sec
;
8234 Elf32_RegInfo reginfo
;
8235 struct ecoff_debug_info debug
;
8236 const struct ecoff_debug_swap
*swap
8237 = get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
8238 HDRR
*symhdr
= &debug
.symbolic_header
;
8239 PTR mdebug_handle
= NULL
;
8245 static const char * const secname
[] =
8247 ".text", ".init", ".fini", ".data",
8248 ".rodata", ".sdata", ".sbss", ".bss"
8250 static const int sc
[] =
8252 scText
, scInit
, scFini
, scData
,
8253 scRData
, scSData
, scSBss
, scBss
8256 /* We'd carefully arranged the dynamic symbol indices, and then the
8257 generic size_dynamic_sections renumbered them out from under us.
8258 Rather than trying somehow to prevent the renumbering, just do
8260 if (elf_hash_table (info
)->dynamic_sections_created
)
8264 struct mips_got_info
*g
;
8266 /* When we resort, we must tell mips_elf_sort_hash_table what
8267 the lowest index it may use is. That's the number of section
8268 symbols we're going to add. The generic ELF linker only
8269 adds these symbols when building a shared object. Note that
8270 we count the sections after (possibly) removing the .options
8272 if (! mips_elf_sort_hash_table (info
, (info
->shared
8273 ? bfd_count_sections (abfd
) + 1
8277 /* Make sure we didn't grow the global .got region. */
8278 dynobj
= elf_hash_table (info
)->dynobj
;
8279 got
= mips_elf_got_section (dynobj
, FALSE
);
8280 g
= mips_elf_section_data (got
)->u
.got_info
;
8282 if (g
->global_gotsym
!= NULL
)
8283 BFD_ASSERT ((elf_hash_table (info
)->dynsymcount
8284 - g
->global_gotsym
->dynindx
)
8285 <= g
->global_gotno
);
8289 /* We want to set the GP value for ld -r. */
8290 /* On IRIX5, we omit the .options section. On IRIX6, however, we
8291 include it, even though we don't process it quite right. (Some
8292 entries are supposed to be merged.) Empirically, we seem to be
8293 better off including it then not. */
8294 if (IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
8295 for (secpp
= &abfd
->sections
; *secpp
!= NULL
; secpp
= &(*secpp
)->next
)
8297 if (strcmp ((*secpp
)->name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
8299 for (p
= (*secpp
)->link_order_head
; p
!= NULL
; p
= p
->next
)
8300 if (p
->type
== bfd_indirect_link_order
)
8301 p
->u
.indirect
.section
->flags
&= ~SEC_HAS_CONTENTS
;
8302 (*secpp
)->link_order_head
= NULL
;
8303 bfd_section_list_remove (abfd
, secpp
);
8304 --abfd
->section_count
;
8310 /* We include .MIPS.options, even though we don't process it quite right.
8311 (Some entries are supposed to be merged.) At IRIX6 empirically we seem
8312 to be better off including it than not. */
8313 for (secpp
= &abfd
->sections
; *secpp
!= NULL
; secpp
= &(*secpp
)->next
)
8315 if (strcmp ((*secpp
)->name
, ".MIPS.options") == 0)
8317 for (p
= (*secpp
)->link_order_head
; p
!= NULL
; p
= p
->next
)
8318 if (p
->type
== bfd_indirect_link_order
)
8319 p
->u
.indirect
.section
->flags
&=~ SEC_HAS_CONTENTS
;
8320 (*secpp
)->link_order_head
= NULL
;
8321 bfd_section_list_remove (abfd
, secpp
);
8322 --abfd
->section_count
;
8329 /* Get a value for the GP register. */
8330 if (elf_gp (abfd
) == 0)
8332 struct bfd_link_hash_entry
*h
;
8334 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
8335 if (h
!= (struct bfd_link_hash_entry
*) NULL
8336 && h
->type
== bfd_link_hash_defined
)
8337 elf_gp (abfd
) = (h
->u
.def
.value
8338 + h
->u
.def
.section
->output_section
->vma
8339 + h
->u
.def
.section
->output_offset
);
8340 else if (info
->relocatable
)
8342 bfd_vma lo
= MINUS_ONE
;
8344 /* Find the GP-relative section with the lowest offset. */
8345 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
8347 && (elf_section_data (o
)->this_hdr
.sh_flags
& SHF_MIPS_GPREL
))
8350 /* And calculate GP relative to that. */
8351 elf_gp (abfd
) = lo
+ ELF_MIPS_GP_OFFSET (abfd
);
8355 /* If the relocate_section function needs to do a reloc
8356 involving the GP value, it should make a reloc_dangerous
8357 callback to warn that GP is not defined. */
8361 /* Go through the sections and collect the .reginfo and .mdebug
8365 gptab_data_sec
= NULL
;
8366 gptab_bss_sec
= NULL
;
8367 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
8369 if (strcmp (o
->name
, ".reginfo") == 0)
8371 memset (®info
, 0, sizeof reginfo
);
8373 /* We have found the .reginfo section in the output file.
8374 Look through all the link_orders comprising it and merge
8375 the information together. */
8376 for (p
= o
->link_order_head
;
8377 p
!= (struct bfd_link_order
*) NULL
;
8380 asection
*input_section
;
8382 Elf32_External_RegInfo ext
;
8385 if (p
->type
!= bfd_indirect_link_order
)
8387 if (p
->type
== bfd_data_link_order
)
8392 input_section
= p
->u
.indirect
.section
;
8393 input_bfd
= input_section
->owner
;
8395 /* The linker emulation code has probably clobbered the
8396 size to be zero bytes. */
8397 if (input_section
->_raw_size
== 0)
8398 input_section
->_raw_size
= sizeof (Elf32_External_RegInfo
);
8400 if (! bfd_get_section_contents (input_bfd
, input_section
,
8403 (bfd_size_type
) sizeof ext
))
8406 bfd_mips_elf32_swap_reginfo_in (input_bfd
, &ext
, &sub
);
8408 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
8409 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
8410 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
8411 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
8412 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
8414 /* ri_gp_value is set by the function
8415 mips_elf32_section_processing when the section is
8416 finally written out. */
8418 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8419 elf_link_input_bfd ignores this section. */
8420 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8423 /* Size has been set in _bfd_mips_elf_always_size_sections. */
8424 BFD_ASSERT(o
->_raw_size
== sizeof (Elf32_External_RegInfo
));
8426 /* Skip this section later on (I don't think this currently
8427 matters, but someday it might). */
8428 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
8433 if (strcmp (o
->name
, ".mdebug") == 0)
8435 struct extsym_info einfo
;
8438 /* We have found the .mdebug section in the output file.
8439 Look through all the link_orders comprising it and merge
8440 the information together. */
8441 symhdr
->magic
= swap
->sym_magic
;
8442 /* FIXME: What should the version stamp be? */
8444 symhdr
->ilineMax
= 0;
8448 symhdr
->isymMax
= 0;
8449 symhdr
->ioptMax
= 0;
8450 symhdr
->iauxMax
= 0;
8452 symhdr
->issExtMax
= 0;
8455 symhdr
->iextMax
= 0;
8457 /* We accumulate the debugging information itself in the
8458 debug_info structure. */
8460 debug
.external_dnr
= NULL
;
8461 debug
.external_pdr
= NULL
;
8462 debug
.external_sym
= NULL
;
8463 debug
.external_opt
= NULL
;
8464 debug
.external_aux
= NULL
;
8466 debug
.ssext
= debug
.ssext_end
= NULL
;
8467 debug
.external_fdr
= NULL
;
8468 debug
.external_rfd
= NULL
;
8469 debug
.external_ext
= debug
.external_ext_end
= NULL
;
8471 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
8472 if (mdebug_handle
== (PTR
) NULL
)
8476 esym
.cobol_main
= 0;
8480 esym
.asym
.iss
= issNil
;
8481 esym
.asym
.st
= stLocal
;
8482 esym
.asym
.reserved
= 0;
8483 esym
.asym
.index
= indexNil
;
8485 for (i
= 0; i
< sizeof (secname
) / sizeof (secname
[0]); i
++)
8487 esym
.asym
.sc
= sc
[i
];
8488 s
= bfd_get_section_by_name (abfd
, secname
[i
]);
8491 esym
.asym
.value
= s
->vma
;
8492 last
= s
->vma
+ s
->_raw_size
;
8495 esym
.asym
.value
= last
;
8496 if (!bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
8501 for (p
= o
->link_order_head
;
8502 p
!= (struct bfd_link_order
*) NULL
;
8505 asection
*input_section
;
8507 const struct ecoff_debug_swap
*input_swap
;
8508 struct ecoff_debug_info input_debug
;
8512 if (p
->type
!= bfd_indirect_link_order
)
8514 if (p
->type
== bfd_data_link_order
)
8519 input_section
= p
->u
.indirect
.section
;
8520 input_bfd
= input_section
->owner
;
8522 if (bfd_get_flavour (input_bfd
) != bfd_target_elf_flavour
8523 || (get_elf_backend_data (input_bfd
)
8524 ->elf_backend_ecoff_debug_swap
) == NULL
)
8526 /* I don't know what a non MIPS ELF bfd would be
8527 doing with a .mdebug section, but I don't really
8528 want to deal with it. */
8532 input_swap
= (get_elf_backend_data (input_bfd
)
8533 ->elf_backend_ecoff_debug_swap
);
8535 BFD_ASSERT (p
->size
== input_section
->_raw_size
);
8537 /* The ECOFF linking code expects that we have already
8538 read in the debugging information and set up an
8539 ecoff_debug_info structure, so we do that now. */
8540 if (! _bfd_mips_elf_read_ecoff_info (input_bfd
, input_section
,
8544 if (! (bfd_ecoff_debug_accumulate
8545 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
8546 &input_debug
, input_swap
, info
)))
8549 /* Loop through the external symbols. For each one with
8550 interesting information, try to find the symbol in
8551 the linker global hash table and save the information
8552 for the output external symbols. */
8553 eraw_src
= input_debug
.external_ext
;
8554 eraw_end
= (eraw_src
8555 + (input_debug
.symbolic_header
.iextMax
8556 * input_swap
->external_ext_size
));
8558 eraw_src
< eraw_end
;
8559 eraw_src
+= input_swap
->external_ext_size
)
8563 struct mips_elf_link_hash_entry
*h
;
8565 (*input_swap
->swap_ext_in
) (input_bfd
, (PTR
) eraw_src
, &ext
);
8566 if (ext
.asym
.sc
== scNil
8567 || ext
.asym
.sc
== scUndefined
8568 || ext
.asym
.sc
== scSUndefined
)
8571 name
= input_debug
.ssext
+ ext
.asym
.iss
;
8572 h
= mips_elf_link_hash_lookup (mips_elf_hash_table (info
),
8573 name
, FALSE
, FALSE
, TRUE
);
8574 if (h
== NULL
|| h
->esym
.ifd
!= -2)
8580 < input_debug
.symbolic_header
.ifdMax
);
8581 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
8587 /* Free up the information we just read. */
8588 free (input_debug
.line
);
8589 free (input_debug
.external_dnr
);
8590 free (input_debug
.external_pdr
);
8591 free (input_debug
.external_sym
);
8592 free (input_debug
.external_opt
);
8593 free (input_debug
.external_aux
);
8594 free (input_debug
.ss
);
8595 free (input_debug
.ssext
);
8596 free (input_debug
.external_fdr
);
8597 free (input_debug
.external_rfd
);
8598 free (input_debug
.external_ext
);
8600 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8601 elf_link_input_bfd ignores this section. */
8602 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8605 if (SGI_COMPAT (abfd
) && info
->shared
)
8607 /* Create .rtproc section. */
8608 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
8609 if (rtproc_sec
== NULL
)
8611 flagword flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
8612 | SEC_LINKER_CREATED
| SEC_READONLY
);
8614 rtproc_sec
= bfd_make_section (abfd
, ".rtproc");
8615 if (rtproc_sec
== NULL
8616 || ! bfd_set_section_flags (abfd
, rtproc_sec
, flags
)
8617 || ! bfd_set_section_alignment (abfd
, rtproc_sec
, 4))
8621 if (! mips_elf_create_procedure_table (mdebug_handle
, abfd
,
8627 /* Build the external symbol information. */
8630 einfo
.debug
= &debug
;
8632 einfo
.failed
= FALSE
;
8633 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
8634 mips_elf_output_extsym
,
8639 /* Set the size of the .mdebug section. */
8640 o
->_raw_size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
8642 /* Skip this section later on (I don't think this currently
8643 matters, but someday it might). */
8644 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
8649 if (strncmp (o
->name
, ".gptab.", sizeof ".gptab." - 1) == 0)
8651 const char *subname
;
8654 Elf32_External_gptab
*ext_tab
;
8657 /* The .gptab.sdata and .gptab.sbss sections hold
8658 information describing how the small data area would
8659 change depending upon the -G switch. These sections
8660 not used in executables files. */
8661 if (! info
->relocatable
)
8663 for (p
= o
->link_order_head
;
8664 p
!= (struct bfd_link_order
*) NULL
;
8667 asection
*input_section
;
8669 if (p
->type
!= bfd_indirect_link_order
)
8671 if (p
->type
== bfd_data_link_order
)
8676 input_section
= p
->u
.indirect
.section
;
8678 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8679 elf_link_input_bfd ignores this section. */
8680 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8683 /* Skip this section later on (I don't think this
8684 currently matters, but someday it might). */
8685 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
8687 /* Really remove the section. */
8688 for (secpp
= &abfd
->sections
;
8690 secpp
= &(*secpp
)->next
)
8692 bfd_section_list_remove (abfd
, secpp
);
8693 --abfd
->section_count
;
8698 /* There is one gptab for initialized data, and one for
8699 uninitialized data. */
8700 if (strcmp (o
->name
, ".gptab.sdata") == 0)
8702 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
8706 (*_bfd_error_handler
)
8707 (_("%s: illegal section name `%s'"),
8708 bfd_get_filename (abfd
), o
->name
);
8709 bfd_set_error (bfd_error_nonrepresentable_section
);
8713 /* The linker script always combines .gptab.data and
8714 .gptab.sdata into .gptab.sdata, and likewise for
8715 .gptab.bss and .gptab.sbss. It is possible that there is
8716 no .sdata or .sbss section in the output file, in which
8717 case we must change the name of the output section. */
8718 subname
= o
->name
+ sizeof ".gptab" - 1;
8719 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
8721 if (o
== gptab_data_sec
)
8722 o
->name
= ".gptab.data";
8724 o
->name
= ".gptab.bss";
8725 subname
= o
->name
+ sizeof ".gptab" - 1;
8726 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
8729 /* Set up the first entry. */
8731 amt
= c
* sizeof (Elf32_gptab
);
8732 tab
= (Elf32_gptab
*) bfd_malloc (amt
);
8735 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
8736 tab
[0].gt_header
.gt_unused
= 0;
8738 /* Combine the input sections. */
8739 for (p
= o
->link_order_head
;
8740 p
!= (struct bfd_link_order
*) NULL
;
8743 asection
*input_section
;
8747 bfd_size_type gpentry
;
8749 if (p
->type
!= bfd_indirect_link_order
)
8751 if (p
->type
== bfd_data_link_order
)
8756 input_section
= p
->u
.indirect
.section
;
8757 input_bfd
= input_section
->owner
;
8759 /* Combine the gptab entries for this input section one
8760 by one. We know that the input gptab entries are
8761 sorted by ascending -G value. */
8762 size
= bfd_section_size (input_bfd
, input_section
);
8764 for (gpentry
= sizeof (Elf32_External_gptab
);
8766 gpentry
+= sizeof (Elf32_External_gptab
))
8768 Elf32_External_gptab ext_gptab
;
8769 Elf32_gptab int_gptab
;
8775 if (! (bfd_get_section_contents
8776 (input_bfd
, input_section
, (PTR
) &ext_gptab
,
8778 (bfd_size_type
) sizeof (Elf32_External_gptab
))))
8784 bfd_mips_elf32_swap_gptab_in (input_bfd
, &ext_gptab
,
8786 val
= int_gptab
.gt_entry
.gt_g_value
;
8787 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
8790 for (look
= 1; look
< c
; look
++)
8792 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
8793 tab
[look
].gt_entry
.gt_bytes
+= add
;
8795 if (tab
[look
].gt_entry
.gt_g_value
== val
)
8801 Elf32_gptab
*new_tab
;
8804 /* We need a new table entry. */
8805 amt
= (bfd_size_type
) (c
+ 1) * sizeof (Elf32_gptab
);
8806 new_tab
= (Elf32_gptab
*) bfd_realloc ((PTR
) tab
, amt
);
8807 if (new_tab
== NULL
)
8813 tab
[c
].gt_entry
.gt_g_value
= val
;
8814 tab
[c
].gt_entry
.gt_bytes
= add
;
8816 /* Merge in the size for the next smallest -G
8817 value, since that will be implied by this new
8820 for (look
= 1; look
< c
; look
++)
8822 if (tab
[look
].gt_entry
.gt_g_value
< val
8824 || (tab
[look
].gt_entry
.gt_g_value
8825 > tab
[max
].gt_entry
.gt_g_value
)))
8829 tab
[c
].gt_entry
.gt_bytes
+=
8830 tab
[max
].gt_entry
.gt_bytes
;
8835 last
= int_gptab
.gt_entry
.gt_bytes
;
8838 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8839 elf_link_input_bfd ignores this section. */
8840 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8843 /* The table must be sorted by -G value. */
8845 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
8847 /* Swap out the table. */
8848 amt
= (bfd_size_type
) c
* sizeof (Elf32_External_gptab
);
8849 ext_tab
= (Elf32_External_gptab
*) bfd_alloc (abfd
, amt
);
8850 if (ext_tab
== NULL
)
8856 for (j
= 0; j
< c
; j
++)
8857 bfd_mips_elf32_swap_gptab_out (abfd
, tab
+ j
, ext_tab
+ j
);
8860 o
->_raw_size
= c
* sizeof (Elf32_External_gptab
);
8861 o
->contents
= (bfd_byte
*) ext_tab
;
8863 /* Skip this section later on (I don't think this currently
8864 matters, but someday it might). */
8865 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
8869 /* Invoke the regular ELF backend linker to do all the work. */
8870 if (!MNAME(abfd
,bfd_elf
,bfd_final_link
) (abfd
, info
))
8873 /* Now write out the computed sections. */
8875 if (reginfo_sec
!= (asection
*) NULL
)
8877 Elf32_External_RegInfo ext
;
8879 bfd_mips_elf32_swap_reginfo_out (abfd
, ®info
, &ext
);
8880 if (! bfd_set_section_contents (abfd
, reginfo_sec
, (PTR
) &ext
,
8882 (bfd_size_type
) sizeof ext
))
8886 if (mdebug_sec
!= (asection
*) NULL
)
8888 BFD_ASSERT (abfd
->output_has_begun
);
8889 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
8891 mdebug_sec
->filepos
))
8894 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
8897 if (gptab_data_sec
!= (asection
*) NULL
)
8899 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
8900 gptab_data_sec
->contents
,
8902 gptab_data_sec
->_raw_size
))
8906 if (gptab_bss_sec
!= (asection
*) NULL
)
8908 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
8909 gptab_bss_sec
->contents
,
8911 gptab_bss_sec
->_raw_size
))
8915 if (SGI_COMPAT (abfd
))
8917 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
8918 if (rtproc_sec
!= NULL
)
8920 if (! bfd_set_section_contents (abfd
, rtproc_sec
,
8921 rtproc_sec
->contents
,
8923 rtproc_sec
->_raw_size
))
8931 /* Structure for saying that BFD machine EXTENSION extends BASE. */
8933 struct mips_mach_extension
{
8934 unsigned long extension
, base
;
8938 /* An array describing how BFD machines relate to one another. The entries
8939 are ordered topologically with MIPS I extensions listed last. */
8941 static const struct mips_mach_extension mips_mach_extensions
[] = {
8942 /* MIPS64 extensions. */
8943 { bfd_mach_mipsisa64r2
, bfd_mach_mipsisa64
},
8944 { bfd_mach_mips_sb1
, bfd_mach_mipsisa64
},
8946 /* MIPS V extensions. */
8947 { bfd_mach_mipsisa64
, bfd_mach_mips5
},
8949 /* R10000 extensions. */
8950 { bfd_mach_mips12000
, bfd_mach_mips10000
},
8952 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
8953 vr5400 ISA, but doesn't include the multimedia stuff. It seems
8954 better to allow vr5400 and vr5500 code to be merged anyway, since
8955 many libraries will just use the core ISA. Perhaps we could add
8956 some sort of ASE flag if this ever proves a problem. */
8957 { bfd_mach_mips5500
, bfd_mach_mips5400
},
8958 { bfd_mach_mips5400
, bfd_mach_mips5000
},
8960 /* MIPS IV extensions. */
8961 { bfd_mach_mips5
, bfd_mach_mips8000
},
8962 { bfd_mach_mips10000
, bfd_mach_mips8000
},
8963 { bfd_mach_mips5000
, bfd_mach_mips8000
},
8964 { bfd_mach_mips7000
, bfd_mach_mips8000
},
8966 /* VR4100 extensions. */
8967 { bfd_mach_mips4120
, bfd_mach_mips4100
},
8968 { bfd_mach_mips4111
, bfd_mach_mips4100
},
8970 /* MIPS III extensions. */
8971 { bfd_mach_mips8000
, bfd_mach_mips4000
},
8972 { bfd_mach_mips4650
, bfd_mach_mips4000
},
8973 { bfd_mach_mips4600
, bfd_mach_mips4000
},
8974 { bfd_mach_mips4400
, bfd_mach_mips4000
},
8975 { bfd_mach_mips4300
, bfd_mach_mips4000
},
8976 { bfd_mach_mips4100
, bfd_mach_mips4000
},
8977 { bfd_mach_mips4010
, bfd_mach_mips4000
},
8979 /* MIPS32 extensions. */
8980 { bfd_mach_mipsisa32r2
, bfd_mach_mipsisa32
},
8982 /* MIPS II extensions. */
8983 { bfd_mach_mips4000
, bfd_mach_mips6000
},
8984 { bfd_mach_mipsisa32
, bfd_mach_mips6000
},
8986 /* MIPS I extensions. */
8987 { bfd_mach_mips6000
, bfd_mach_mips3000
},
8988 { bfd_mach_mips3900
, bfd_mach_mips3000
}
8992 /* Return true if bfd machine EXTENSION is an extension of machine BASE. */
8995 mips_mach_extends_p (base
, extension
)
8996 unsigned long base
, extension
;
9000 for (i
= 0; extension
!= base
&& i
< ARRAY_SIZE (mips_mach_extensions
); i
++)
9001 if (extension
== mips_mach_extensions
[i
].extension
)
9002 extension
= mips_mach_extensions
[i
].base
;
9004 return extension
== base
;
9008 /* Return true if the given ELF header flags describe a 32-bit binary. */
9011 mips_32bit_flags_p (flags
)
9014 return ((flags
& EF_MIPS_32BITMODE
) != 0
9015 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
9016 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
9017 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
9018 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
9019 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
9020 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
);
9024 /* Merge backend specific data from an object file to the output
9025 object file when linking. */
9028 _bfd_mips_elf_merge_private_bfd_data (ibfd
, obfd
)
9035 bfd_boolean null_input_bfd
= TRUE
;
9038 /* Check if we have the same endianess */
9039 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
9041 (*_bfd_error_handler
)
9042 (_("%s: endianness incompatible with that of the selected emulation"),
9043 bfd_archive_filename (ibfd
));
9047 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
9048 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
9051 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
9053 (*_bfd_error_handler
)
9054 (_("%s: ABI is incompatible with that of the selected emulation"),
9055 bfd_archive_filename (ibfd
));
9059 new_flags
= elf_elfheader (ibfd
)->e_flags
;
9060 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_NOREORDER
;
9061 old_flags
= elf_elfheader (obfd
)->e_flags
;
9063 if (! elf_flags_init (obfd
))
9065 elf_flags_init (obfd
) = TRUE
;
9066 elf_elfheader (obfd
)->e_flags
= new_flags
;
9067 elf_elfheader (obfd
)->e_ident
[EI_CLASS
]
9068 = elf_elfheader (ibfd
)->e_ident
[EI_CLASS
];
9070 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
9071 && bfd_get_arch_info (obfd
)->the_default
)
9073 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
9074 bfd_get_mach (ibfd
)))
9081 /* Check flag compatibility. */
9083 new_flags
&= ~EF_MIPS_NOREORDER
;
9084 old_flags
&= ~EF_MIPS_NOREORDER
;
9086 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
9087 doesn't seem to matter. */
9088 new_flags
&= ~EF_MIPS_XGOT
;
9089 old_flags
&= ~EF_MIPS_XGOT
;
9091 if (new_flags
== old_flags
)
9094 /* Check to see if the input BFD actually contains any sections.
9095 If not, its flags may not have been initialised either, but it cannot
9096 actually cause any incompatibility. */
9097 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
9099 /* Ignore synthetic sections and empty .text, .data and .bss sections
9100 which are automatically generated by gas. */
9101 if (strcmp (sec
->name
, ".reginfo")
9102 && strcmp (sec
->name
, ".mdebug")
9103 && ((!strcmp (sec
->name
, ".text")
9104 || !strcmp (sec
->name
, ".data")
9105 || !strcmp (sec
->name
, ".bss"))
9106 && sec
->_raw_size
!= 0))
9108 null_input_bfd
= FALSE
;
9117 if (((new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0)
9118 != ((old_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0))
9120 (*_bfd_error_handler
)
9121 (_("%s: warning: linking PIC files with non-PIC files"),
9122 bfd_archive_filename (ibfd
));
9126 if (new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
))
9127 elf_elfheader (obfd
)->e_flags
|= EF_MIPS_CPIC
;
9128 if (! (new_flags
& EF_MIPS_PIC
))
9129 elf_elfheader (obfd
)->e_flags
&= ~EF_MIPS_PIC
;
9131 new_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
9132 old_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
9134 /* Compare the ISAs. */
9135 if (mips_32bit_flags_p (old_flags
) != mips_32bit_flags_p (new_flags
))
9137 (*_bfd_error_handler
)
9138 (_("%s: linking 32-bit code with 64-bit code"),
9139 bfd_archive_filename (ibfd
));
9142 else if (!mips_mach_extends_p (bfd_get_mach (ibfd
), bfd_get_mach (obfd
)))
9144 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
9145 if (mips_mach_extends_p (bfd_get_mach (obfd
), bfd_get_mach (ibfd
)))
9147 /* Copy the architecture info from IBFD to OBFD. Also copy
9148 the 32-bit flag (if set) so that we continue to recognise
9149 OBFD as a 32-bit binary. */
9150 bfd_set_arch_info (obfd
, bfd_get_arch_info (ibfd
));
9151 elf_elfheader (obfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
9152 elf_elfheader (obfd
)->e_flags
9153 |= new_flags
& (EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9155 /* Copy across the ABI flags if OBFD doesn't use them
9156 and if that was what caused us to treat IBFD as 32-bit. */
9157 if ((old_flags
& EF_MIPS_ABI
) == 0
9158 && mips_32bit_flags_p (new_flags
)
9159 && !mips_32bit_flags_p (new_flags
& ~EF_MIPS_ABI
))
9160 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ABI
;
9164 /* The ISAs aren't compatible. */
9165 (*_bfd_error_handler
)
9166 (_("%s: linking %s module with previous %s modules"),
9167 bfd_archive_filename (ibfd
),
9168 bfd_printable_name (ibfd
),
9169 bfd_printable_name (obfd
));
9174 new_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9175 old_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9177 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
9178 does set EI_CLASS differently from any 32-bit ABI. */
9179 if ((new_flags
& EF_MIPS_ABI
) != (old_flags
& EF_MIPS_ABI
)
9180 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
9181 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
9183 /* Only error if both are set (to different values). */
9184 if (((new_flags
& EF_MIPS_ABI
) && (old_flags
& EF_MIPS_ABI
))
9185 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
9186 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
9188 (*_bfd_error_handler
)
9189 (_("%s: ABI mismatch: linking %s module with previous %s modules"),
9190 bfd_archive_filename (ibfd
),
9191 elf_mips_abi_name (ibfd
),
9192 elf_mips_abi_name (obfd
));
9195 new_flags
&= ~EF_MIPS_ABI
;
9196 old_flags
&= ~EF_MIPS_ABI
;
9199 /* For now, allow arbitrary mixing of ASEs (retain the union). */
9200 if ((new_flags
& EF_MIPS_ARCH_ASE
) != (old_flags
& EF_MIPS_ARCH_ASE
))
9202 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ARCH_ASE
;
9204 new_flags
&= ~ EF_MIPS_ARCH_ASE
;
9205 old_flags
&= ~ EF_MIPS_ARCH_ASE
;
9208 /* Warn about any other mismatches */
9209 if (new_flags
!= old_flags
)
9211 (*_bfd_error_handler
)
9212 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
9213 bfd_archive_filename (ibfd
), (unsigned long) new_flags
,
9214 (unsigned long) old_flags
);
9220 bfd_set_error (bfd_error_bad_value
);
9227 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
9230 _bfd_mips_elf_set_private_flags (abfd
, flags
)
9234 BFD_ASSERT (!elf_flags_init (abfd
)
9235 || elf_elfheader (abfd
)->e_flags
== flags
);
9237 elf_elfheader (abfd
)->e_flags
= flags
;
9238 elf_flags_init (abfd
) = TRUE
;
9243 _bfd_mips_elf_print_private_bfd_data (abfd
, ptr
)
9247 FILE *file
= (FILE *) ptr
;
9249 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
9251 /* Print normal ELF private data. */
9252 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
9254 /* xgettext:c-format */
9255 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
9257 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
)
9258 fprintf (file
, _(" [abi=O32]"));
9259 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O64
)
9260 fprintf (file
, _(" [abi=O64]"));
9261 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
)
9262 fprintf (file
, _(" [abi=EABI32]"));
9263 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
9264 fprintf (file
, _(" [abi=EABI64]"));
9265 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
))
9266 fprintf (file
, _(" [abi unknown]"));
9267 else if (ABI_N32_P (abfd
))
9268 fprintf (file
, _(" [abi=N32]"));
9269 else if (ABI_64_P (abfd
))
9270 fprintf (file
, _(" [abi=64]"));
9272 fprintf (file
, _(" [no abi set]"));
9274 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
9275 fprintf (file
, _(" [mips1]"));
9276 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
9277 fprintf (file
, _(" [mips2]"));
9278 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
9279 fprintf (file
, _(" [mips3]"));
9280 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
9281 fprintf (file
, _(" [mips4]"));
9282 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_5
)
9283 fprintf (file
, _(" [mips5]"));
9284 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
)
9285 fprintf (file
, _(" [mips32]"));
9286 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64
)
9287 fprintf (file
, _(" [mips64]"));
9288 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
)
9289 fprintf (file
, _(" [mips32r2]"));
9290 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64R2
)
9291 fprintf (file
, _(" [mips64r2]"));
9293 fprintf (file
, _(" [unknown ISA]"));
9295 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
9296 fprintf (file
, _(" [mdmx]"));
9298 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_M16
)
9299 fprintf (file
, _(" [mips16]"));
9301 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_32BITMODE
)
9302 fprintf (file
, _(" [32bitmode]"));
9304 fprintf (file
, _(" [not 32bitmode]"));
9311 struct bfd_elf_special_section
const _bfd_mips_elf_special_sections
[]=
9313 { ".sdata", 6, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9314 { ".sbss", 5, -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9315 { ".lit4", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9316 { ".lit8", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9317 { ".ucode", 6, 0, SHT_MIPS_UCODE
, 0 },
9318 { ".mdebug", 7, 0, SHT_MIPS_DEBUG
, 0 },
9319 { NULL
, 0, 0, 0, 0 }