1 /* MIPS-specific support for ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004 Free Software Foundation, Inc.
5 Most of the information added by Ian Lance Taylor, Cygnus Support,
7 N32/64 ABI support added by Mark Mitchell, CodeSourcery, LLC.
8 <mark@codesourcery.com>
9 Traditional MIPS targets support added by Koundinya.K, Dansk Data
10 Elektronik & Operations Research Group. <kk@ddeorg.soft.net>
12 This file is part of BFD, the Binary File Descriptor library.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 2 of the License, or
17 (at your option) any later version.
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 /* This file handles functionality common to the different MIPS ABI's. */
33 #include "libiberty.h"
35 #include "elfxx-mips.h"
38 /* Get the ECOFF swapping routines. */
40 #include "coff/symconst.h"
41 #include "coff/ecoff.h"
42 #include "coff/mips.h"
46 /* This structure is used to hold .got entries while estimating got
50 /* The input bfd in which the symbol is defined. */
52 /* The index of the symbol, as stored in the relocation r_info, if
53 we have a local symbol; -1 otherwise. */
57 /* If abfd == NULL, an address that must be stored in the got. */
59 /* If abfd != NULL && symndx != -1, the addend of the relocation
60 that should be added to the symbol value. */
62 /* If abfd != NULL && symndx == -1, the hash table entry
63 corresponding to a global symbol in the got (or, local, if
65 struct mips_elf_link_hash_entry
*h
;
67 /* The offset from the beginning of the .got section to the entry
68 corresponding to this symbol+addend. If it's a global symbol
69 whose offset is yet to be decided, it's going to be -1. */
73 /* This structure is used to hold .got information when linking. */
77 /* The global symbol in the GOT with the lowest index in the dynamic
79 struct elf_link_hash_entry
*global_gotsym
;
80 /* The number of global .got entries. */
81 unsigned int global_gotno
;
82 /* The number of local .got entries. */
83 unsigned int local_gotno
;
84 /* The number of local .got entries we have used. */
85 unsigned int assigned_gotno
;
86 /* A hash table holding members of the got. */
87 struct htab
*got_entries
;
88 /* A hash table mapping input bfds to other mips_got_info. NULL
89 unless multi-got was necessary. */
91 /* In multi-got links, a pointer to the next got (err, rather, most
92 of the time, it points to the previous got). */
93 struct mips_got_info
*next
;
96 /* Map an input bfd to a got in a multi-got link. */
98 struct mips_elf_bfd2got_hash
{
100 struct mips_got_info
*g
;
103 /* Structure passed when traversing the bfd2got hash table, used to
104 create and merge bfd's gots. */
106 struct mips_elf_got_per_bfd_arg
108 /* A hashtable that maps bfds to gots. */
110 /* The output bfd. */
112 /* The link information. */
113 struct bfd_link_info
*info
;
114 /* A pointer to the primary got, i.e., the one that's going to get
115 the implicit relocations from DT_MIPS_LOCAL_GOTNO and
117 struct mips_got_info
*primary
;
118 /* A non-primary got we're trying to merge with other input bfd's
120 struct mips_got_info
*current
;
121 /* The maximum number of got entries that can be addressed with a
123 unsigned int max_count
;
124 /* The number of local and global entries in the primary got. */
125 unsigned int primary_count
;
126 /* The number of local and global entries in the current got. */
127 unsigned int current_count
;
130 /* Another structure used to pass arguments for got entries traversal. */
132 struct mips_elf_set_global_got_offset_arg
134 struct mips_got_info
*g
;
136 unsigned int needed_relocs
;
137 struct bfd_link_info
*info
;
140 struct _mips_elf_section_data
142 struct bfd_elf_section_data elf
;
145 struct mips_got_info
*got_info
;
150 #define mips_elf_section_data(sec) \
151 ((struct _mips_elf_section_data *) elf_section_data (sec))
153 /* This structure is passed to mips_elf_sort_hash_table_f when sorting
154 the dynamic symbols. */
156 struct mips_elf_hash_sort_data
158 /* The symbol in the global GOT with the lowest dynamic symbol table
160 struct elf_link_hash_entry
*low
;
161 /* The least dynamic symbol table index corresponding to a symbol
163 long min_got_dynindx
;
164 /* The greatest dynamic symbol table index corresponding to a symbol
165 with a GOT entry that is not referenced (e.g., a dynamic symbol
166 with dynamic relocations pointing to it from non-primary GOTs). */
167 long max_unref_got_dynindx
;
168 /* The greatest dynamic symbol table index not corresponding to a
169 symbol without a GOT entry. */
170 long max_non_got_dynindx
;
173 /* The MIPS ELF linker needs additional information for each symbol in
174 the global hash table. */
176 struct mips_elf_link_hash_entry
178 struct elf_link_hash_entry root
;
180 /* External symbol information. */
183 /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
185 unsigned int possibly_dynamic_relocs
;
187 /* If the R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 reloc is against
188 a readonly section. */
189 bfd_boolean readonly_reloc
;
191 /* We must not create a stub for a symbol that has relocations
192 related to taking the function's address, i.e. any but
193 R_MIPS_CALL*16 ones -- see "MIPS ABI Supplement, 3rd Edition",
195 bfd_boolean no_fn_stub
;
197 /* If there is a stub that 32 bit functions should use to call this
198 16 bit function, this points to the section containing the stub. */
201 /* Whether we need the fn_stub; this is set if this symbol appears
202 in any relocs other than a 16 bit call. */
203 bfd_boolean need_fn_stub
;
205 /* If there is a stub that 16 bit functions should use to call this
206 32 bit function, this points to the section containing the stub. */
209 /* This is like the call_stub field, but it is used if the function
210 being called returns a floating point value. */
211 asection
*call_fp_stub
;
213 /* Are we forced local? .*/
214 bfd_boolean forced_local
;
217 /* MIPS ELF linker hash table. */
219 struct mips_elf_link_hash_table
221 struct elf_link_hash_table root
;
223 /* We no longer use this. */
224 /* String section indices for the dynamic section symbols. */
225 bfd_size_type dynsym_sec_strindex
[SIZEOF_MIPS_DYNSYM_SECNAMES
];
227 /* The number of .rtproc entries. */
228 bfd_size_type procedure_count
;
229 /* The size of the .compact_rel section (if SGI_COMPAT). */
230 bfd_size_type compact_rel_size
;
231 /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic
232 entry is set to the address of __rld_obj_head as in IRIX5. */
233 bfd_boolean use_rld_obj_head
;
234 /* This is the value of the __rld_map or __rld_obj_head symbol. */
236 /* This is set if we see any mips16 stub sections. */
237 bfd_boolean mips16_stubs_seen
;
240 /* Structure used to pass information to mips_elf_output_extsym. */
245 struct bfd_link_info
*info
;
246 struct ecoff_debug_info
*debug
;
247 const struct ecoff_debug_swap
*swap
;
251 /* The names of the runtime procedure table symbols used on IRIX5. */
253 static const char * const mips_elf_dynsym_rtproc_names
[] =
256 "_procedure_string_table",
257 "_procedure_table_size",
261 /* These structures are used to generate the .compact_rel section on
266 unsigned long id1
; /* Always one? */
267 unsigned long num
; /* Number of compact relocation entries. */
268 unsigned long id2
; /* Always two? */
269 unsigned long offset
; /* The file offset of the first relocation. */
270 unsigned long reserved0
; /* Zero? */
271 unsigned long reserved1
; /* Zero? */
280 bfd_byte reserved0
[4];
281 bfd_byte reserved1
[4];
282 } Elf32_External_compact_rel
;
286 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
287 unsigned int rtype
: 4; /* Relocation types. See below. */
288 unsigned int dist2to
: 8;
289 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
290 unsigned long konst
; /* KONST field. See below. */
291 unsigned long vaddr
; /* VADDR to be relocated. */
296 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
297 unsigned int rtype
: 4; /* Relocation types. See below. */
298 unsigned int dist2to
: 8;
299 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
300 unsigned long konst
; /* KONST field. See below. */
308 } Elf32_External_crinfo
;
314 } Elf32_External_crinfo2
;
316 /* These are the constants used to swap the bitfields in a crinfo. */
318 #define CRINFO_CTYPE (0x1)
319 #define CRINFO_CTYPE_SH (31)
320 #define CRINFO_RTYPE (0xf)
321 #define CRINFO_RTYPE_SH (27)
322 #define CRINFO_DIST2TO (0xff)
323 #define CRINFO_DIST2TO_SH (19)
324 #define CRINFO_RELVADDR (0x7ffff)
325 #define CRINFO_RELVADDR_SH (0)
327 /* A compact relocation info has long (3 words) or short (2 words)
328 formats. A short format doesn't have VADDR field and relvaddr
329 fields contains ((VADDR - vaddr of the previous entry) >> 2). */
330 #define CRF_MIPS_LONG 1
331 #define CRF_MIPS_SHORT 0
333 /* There are 4 types of compact relocation at least. The value KONST
334 has different meaning for each type:
337 CT_MIPS_REL32 Address in data
338 CT_MIPS_WORD Address in word (XXX)
339 CT_MIPS_GPHI_LO GP - vaddr
340 CT_MIPS_JMPAD Address to jump
343 #define CRT_MIPS_REL32 0xa
344 #define CRT_MIPS_WORD 0xb
345 #define CRT_MIPS_GPHI_LO 0xc
346 #define CRT_MIPS_JMPAD 0xd
348 #define mips_elf_set_cr_format(x,format) ((x).ctype = (format))
349 #define mips_elf_set_cr_type(x,type) ((x).rtype = (type))
350 #define mips_elf_set_cr_dist2to(x,v) ((x).dist2to = (v))
351 #define mips_elf_set_cr_relvaddr(x,d) ((x).relvaddr = (d)<<2)
353 /* The structure of the runtime procedure descriptor created by the
354 loader for use by the static exception system. */
356 typedef struct runtime_pdr
{
357 bfd_vma adr
; /* Memory address of start of procedure. */
358 long regmask
; /* Save register mask. */
359 long regoffset
; /* Save register offset. */
360 long fregmask
; /* Save floating point register mask. */
361 long fregoffset
; /* Save floating point register offset. */
362 long frameoffset
; /* Frame size. */
363 short framereg
; /* Frame pointer register. */
364 short pcreg
; /* Offset or reg of return pc. */
365 long irpss
; /* Index into the runtime string table. */
367 struct exception_info
*exception_info
;/* Pointer to exception array. */
369 #define cbRPDR sizeof (RPDR)
370 #define rpdNil ((pRPDR) 0)
372 static struct bfd_hash_entry
*mips_elf_link_hash_newfunc
373 (struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *);
374 static void ecoff_swap_rpdr_out
375 (bfd
*, const RPDR
*, struct rpdr_ext
*);
376 static bfd_boolean mips_elf_create_procedure_table
377 (void *, bfd
*, struct bfd_link_info
*, asection
*,
378 struct ecoff_debug_info
*);
379 static bfd_boolean mips_elf_check_mips16_stubs
380 (struct mips_elf_link_hash_entry
*, void *);
381 static void bfd_mips_elf32_swap_gptab_in
382 (bfd
*, const Elf32_External_gptab
*, Elf32_gptab
*);
383 static void bfd_mips_elf32_swap_gptab_out
384 (bfd
*, const Elf32_gptab
*, Elf32_External_gptab
*);
385 static void bfd_elf32_swap_compact_rel_out
386 (bfd
*, const Elf32_compact_rel
*, Elf32_External_compact_rel
*);
387 static void bfd_elf32_swap_crinfo_out
388 (bfd
*, const Elf32_crinfo
*, Elf32_External_crinfo
*);
389 static int sort_dynamic_relocs
390 (const void *, const void *);
391 static int sort_dynamic_relocs_64
392 (const void *, const void *);
393 static bfd_boolean mips_elf_output_extsym
394 (struct mips_elf_link_hash_entry
*, void *);
395 static int gptab_compare
396 (const void *, const void *);
397 static asection
*mips_elf_rel_dyn_section
398 (bfd
*, bfd_boolean
);
399 static asection
*mips_elf_got_section
400 (bfd
*, bfd_boolean
);
401 static struct mips_got_info
*mips_elf_got_info
402 (bfd
*, asection
**);
403 static long mips_elf_get_global_gotsym_index
405 static bfd_vma mips_elf_local_got_index
406 (bfd
*, bfd
*, struct bfd_link_info
*, bfd_vma
);
407 static bfd_vma mips_elf_global_got_index
408 (bfd
*, bfd
*, struct elf_link_hash_entry
*);
409 static bfd_vma mips_elf_got_page
410 (bfd
*, bfd
*, struct bfd_link_info
*, bfd_vma
, bfd_vma
*);
411 static bfd_vma mips_elf_got16_entry
412 (bfd
*, bfd
*, struct bfd_link_info
*, bfd_vma
, bfd_boolean
);
413 static bfd_vma mips_elf_got_offset_from_index
414 (bfd
*, bfd
*, bfd
*, bfd_vma
);
415 static struct mips_got_entry
*mips_elf_create_local_got_entry
416 (bfd
*, bfd
*, struct mips_got_info
*, asection
*, bfd_vma
);
417 static bfd_boolean mips_elf_sort_hash_table
418 (struct bfd_link_info
*, unsigned long);
419 static bfd_boolean mips_elf_sort_hash_table_f
420 (struct mips_elf_link_hash_entry
*, void *);
421 static bfd_boolean mips_elf_record_local_got_symbol
422 (bfd
*, long, bfd_vma
, struct mips_got_info
*);
423 static bfd_boolean mips_elf_record_global_got_symbol
424 (struct elf_link_hash_entry
*, bfd
*, struct bfd_link_info
*,
425 struct mips_got_info
*);
426 static const Elf_Internal_Rela
*mips_elf_next_relocation
427 (bfd
*, unsigned int, const Elf_Internal_Rela
*, const Elf_Internal_Rela
*);
428 static bfd_boolean mips_elf_local_relocation_p
429 (bfd
*, const Elf_Internal_Rela
*, asection
**, bfd_boolean
);
430 static bfd_boolean mips_elf_overflow_p
432 static bfd_vma mips_elf_high
434 static bfd_vma mips_elf_higher
436 static bfd_vma mips_elf_highest
438 static bfd_boolean mips_elf_create_compact_rel_section
439 (bfd
*, struct bfd_link_info
*);
440 static bfd_boolean mips_elf_create_got_section
441 (bfd
*, struct bfd_link_info
*, bfd_boolean
);
442 static bfd_reloc_status_type mips_elf_calculate_relocation
443 (bfd
*, bfd
*, asection
*, struct bfd_link_info
*,
444 const Elf_Internal_Rela
*, bfd_vma
, reloc_howto_type
*,
445 Elf_Internal_Sym
*, asection
**, bfd_vma
*, const char **,
446 bfd_boolean
*, bfd_boolean
);
447 static bfd_vma mips_elf_obtain_contents
448 (reloc_howto_type
*, const Elf_Internal_Rela
*, bfd
*, bfd_byte
*);
449 static bfd_boolean mips_elf_perform_relocation
450 (struct bfd_link_info
*, reloc_howto_type
*, const Elf_Internal_Rela
*,
451 bfd_vma
, bfd
*, asection
*, bfd_byte
*, bfd_boolean
);
452 static bfd_boolean mips_elf_stub_section_p
454 static void mips_elf_allocate_dynamic_relocations
455 (bfd
*, unsigned int);
456 static bfd_boolean mips_elf_create_dynamic_relocation
457 (bfd
*, struct bfd_link_info
*, const Elf_Internal_Rela
*,
458 struct mips_elf_link_hash_entry
*, asection
*, bfd_vma
,
459 bfd_vma
*, asection
*);
460 static void mips_set_isa_flags
462 static INLINE
char *elf_mips_abi_name
464 static void mips_elf_irix6_finish_dynamic_symbol
465 (bfd
*, const char *, Elf_Internal_Sym
*);
466 static bfd_boolean mips_mach_extends_p
467 (unsigned long, unsigned long);
468 static bfd_boolean mips_32bit_flags_p
470 static INLINE hashval_t mips_elf_hash_bfd_vma
472 static hashval_t mips_elf_got_entry_hash
474 static int mips_elf_got_entry_eq
475 (const void *, const void *);
477 static bfd_boolean mips_elf_multi_got
478 (bfd
*, struct bfd_link_info
*, struct mips_got_info
*,
479 asection
*, bfd_size_type
);
480 static hashval_t mips_elf_multi_got_entry_hash
482 static int mips_elf_multi_got_entry_eq
483 (const void *, const void *);
484 static hashval_t mips_elf_bfd2got_entry_hash
486 static int mips_elf_bfd2got_entry_eq
487 (const void *, const void *);
488 static int mips_elf_make_got_per_bfd
490 static int mips_elf_merge_gots
492 static int mips_elf_set_global_got_offset
494 static int mips_elf_set_no_stub
496 static int mips_elf_resolve_final_got_entry
498 static void mips_elf_resolve_final_got_entries
499 (struct mips_got_info
*);
500 static bfd_vma mips_elf_adjust_gp
501 (bfd
*, struct mips_got_info
*, bfd
*);
502 static struct mips_got_info
*mips_elf_got_for_ibfd
503 (struct mips_got_info
*, bfd
*);
505 /* This will be used when we sort the dynamic relocation records. */
506 static bfd
*reldyn_sorting_bfd
;
508 /* Nonzero if ABFD is using the N32 ABI. */
510 #define ABI_N32_P(abfd) \
511 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
513 /* Nonzero if ABFD is using the N64 ABI. */
514 #define ABI_64_P(abfd) \
515 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
517 /* Nonzero if ABFD is using NewABI conventions. */
518 #define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
520 /* The IRIX compatibility level we are striving for. */
521 #define IRIX_COMPAT(abfd) \
522 (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
524 /* Whether we are trying to be compatible with IRIX at all. */
525 #define SGI_COMPAT(abfd) \
526 (IRIX_COMPAT (abfd) != ict_none)
528 /* The name of the options section. */
529 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
530 (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
532 /* The name of the stub section. */
533 #define MIPS_ELF_STUB_SECTION_NAME(abfd) \
534 (NEWABI_P (abfd) ? ".MIPS.stubs" : ".stub")
536 /* The size of an external REL relocation. */
537 #define MIPS_ELF_REL_SIZE(abfd) \
538 (get_elf_backend_data (abfd)->s->sizeof_rel)
540 /* The size of an external dynamic table entry. */
541 #define MIPS_ELF_DYN_SIZE(abfd) \
542 (get_elf_backend_data (abfd)->s->sizeof_dyn)
544 /* The size of a GOT entry. */
545 #define MIPS_ELF_GOT_SIZE(abfd) \
546 (get_elf_backend_data (abfd)->s->arch_size / 8)
548 /* The size of a symbol-table entry. */
549 #define MIPS_ELF_SYM_SIZE(abfd) \
550 (get_elf_backend_data (abfd)->s->sizeof_sym)
552 /* The default alignment for sections, as a power of two. */
553 #define MIPS_ELF_LOG_FILE_ALIGN(abfd) \
554 (get_elf_backend_data (abfd)->s->log_file_align)
556 /* Get word-sized data. */
557 #define MIPS_ELF_GET_WORD(abfd, ptr) \
558 (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
560 /* Put out word-sized data. */
561 #define MIPS_ELF_PUT_WORD(abfd, val, ptr) \
563 ? bfd_put_64 (abfd, val, ptr) \
564 : bfd_put_32 (abfd, val, ptr))
566 /* Add a dynamic symbol table-entry. */
568 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
569 (ABI_64_P (elf_hash_table (info)->dynobj) \
570 ? bfd_elf64_add_dynamic_entry (info, tag, val) \
571 : bfd_elf32_add_dynamic_entry (info, tag, val))
573 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
574 (ABI_64_P (elf_hash_table (info)->dynobj) \
575 ? (abort (), FALSE) \
576 : bfd_elf32_add_dynamic_entry (info, tag, val))
579 #define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela) \
580 (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela))
582 /* Determine whether the internal relocation of index REL_IDX is REL
583 (zero) or RELA (non-zero). The assumption is that, if there are
584 two relocation sections for this section, one of them is REL and
585 the other is RELA. If the index of the relocation we're testing is
586 in range for the first relocation section, check that the external
587 relocation size is that for RELA. It is also assumed that, if
588 rel_idx is not in range for the first section, and this first
589 section contains REL relocs, then the relocation is in the second
590 section, that is RELA. */
591 #define MIPS_RELOC_RELA_P(abfd, sec, rel_idx) \
592 ((NUM_SHDR_ENTRIES (&elf_section_data (sec)->rel_hdr) \
593 * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel \
594 > (bfd_vma)(rel_idx)) \
595 == (elf_section_data (sec)->rel_hdr.sh_entsize \
596 == (ABI_64_P (abfd) ? sizeof (Elf64_External_Rela) \
597 : sizeof (Elf32_External_Rela))))
599 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
600 from smaller values. Start with zero, widen, *then* decrement. */
601 #define MINUS_ONE (((bfd_vma)0) - 1)
603 /* The number of local .got entries we reserve. */
604 #define MIPS_RESERVED_GOTNO (2)
606 /* The offset of $gp from the beginning of the .got section. */
607 #define ELF_MIPS_GP_OFFSET(abfd) (0x7ff0)
609 /* The maximum size of the GOT for it to be addressable using 16-bit
611 #define MIPS_ELF_GOT_MAX_SIZE(abfd) (ELF_MIPS_GP_OFFSET(abfd) + 0x7fff)
613 /* Instructions which appear in a stub. */
614 #define STUB_LW(abfd) \
616 ? 0xdf998010 /* ld t9,0x8010(gp) */ \
617 : 0x8f998010)) /* lw t9,0x8010(gp) */
618 #define STUB_MOVE(abfd) \
620 ? 0x03e0782d /* daddu t7,ra */ \
621 : 0x03e07821)) /* addu t7,ra */
622 #define STUB_JALR 0x0320f809 /* jalr t9,ra */
623 #define STUB_LI16(abfd) \
625 ? 0x64180000 /* daddiu t8,zero,0 */ \
626 : 0x24180000)) /* addiu t8,zero,0 */
627 #define MIPS_FUNCTION_STUB_SIZE (16)
629 /* The name of the dynamic interpreter. This is put in the .interp
632 #define ELF_DYNAMIC_INTERPRETER(abfd) \
633 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
634 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
635 : "/usr/lib/libc.so.1")
638 #define MNAME(bfd,pre,pos) \
639 (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
640 #define ELF_R_SYM(bfd, i) \
641 (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
642 #define ELF_R_TYPE(bfd, i) \
643 (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
644 #define ELF_R_INFO(bfd, s, t) \
645 (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
647 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
648 #define ELF_R_SYM(bfd, i) \
650 #define ELF_R_TYPE(bfd, i) \
652 #define ELF_R_INFO(bfd, s, t) \
653 (ELF32_R_INFO (s, t))
656 /* The mips16 compiler uses a couple of special sections to handle
657 floating point arguments.
659 Section names that look like .mips16.fn.FNNAME contain stubs that
660 copy floating point arguments from the fp regs to the gp regs and
661 then jump to FNNAME. If any 32 bit function calls FNNAME, the
662 call should be redirected to the stub instead. If no 32 bit
663 function calls FNNAME, the stub should be discarded. We need to
664 consider any reference to the function, not just a call, because
665 if the address of the function is taken we will need the stub,
666 since the address might be passed to a 32 bit function.
668 Section names that look like .mips16.call.FNNAME contain stubs
669 that copy floating point arguments from the gp regs to the fp
670 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
671 then any 16 bit function that calls FNNAME should be redirected
672 to the stub instead. If FNNAME is not a 32 bit function, the
673 stub should be discarded.
675 .mips16.call.fp.FNNAME sections are similar, but contain stubs
676 which call FNNAME and then copy the return value from the fp regs
677 to the gp regs. These stubs store the return value in $18 while
678 calling FNNAME; any function which might call one of these stubs
679 must arrange to save $18 around the call. (This case is not
680 needed for 32 bit functions that call 16 bit functions, because
681 16 bit functions always return floating point values in both
684 Note that in all cases FNNAME might be defined statically.
685 Therefore, FNNAME is not used literally. Instead, the relocation
686 information will indicate which symbol the section is for.
688 We record any stubs that we find in the symbol table. */
690 #define FN_STUB ".mips16.fn."
691 #define CALL_STUB ".mips16.call."
692 #define CALL_FP_STUB ".mips16.call.fp."
694 /* Look up an entry in a MIPS ELF linker hash table. */
696 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
697 ((struct mips_elf_link_hash_entry *) \
698 elf_link_hash_lookup (&(table)->root, (string), (create), \
701 /* Traverse a MIPS ELF linker hash table. */
703 #define mips_elf_link_hash_traverse(table, func, info) \
704 (elf_link_hash_traverse \
706 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
709 /* Get the MIPS ELF linker hash table from a link_info structure. */
711 #define mips_elf_hash_table(p) \
712 ((struct mips_elf_link_hash_table *) ((p)->hash))
714 /* Create an entry in a MIPS ELF linker hash table. */
716 static struct bfd_hash_entry
*
717 mips_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
718 struct bfd_hash_table
*table
, const char *string
)
720 struct mips_elf_link_hash_entry
*ret
=
721 (struct mips_elf_link_hash_entry
*) entry
;
723 /* Allocate the structure if it has not already been allocated by a
726 ret
= bfd_hash_allocate (table
, sizeof (struct mips_elf_link_hash_entry
));
728 return (struct bfd_hash_entry
*) ret
;
730 /* Call the allocation method of the superclass. */
731 ret
= ((struct mips_elf_link_hash_entry
*)
732 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
736 /* Set local fields. */
737 memset (&ret
->esym
, 0, sizeof (EXTR
));
738 /* We use -2 as a marker to indicate that the information has
739 not been set. -1 means there is no associated ifd. */
741 ret
->possibly_dynamic_relocs
= 0;
742 ret
->readonly_reloc
= FALSE
;
743 ret
->no_fn_stub
= FALSE
;
745 ret
->need_fn_stub
= FALSE
;
746 ret
->call_stub
= NULL
;
747 ret
->call_fp_stub
= NULL
;
748 ret
->forced_local
= FALSE
;
751 return (struct bfd_hash_entry
*) ret
;
755 _bfd_mips_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
757 struct _mips_elf_section_data
*sdata
;
758 bfd_size_type amt
= sizeof (*sdata
);
760 sdata
= bfd_zalloc (abfd
, amt
);
763 sec
->used_by_bfd
= sdata
;
765 return _bfd_elf_new_section_hook (abfd
, sec
);
768 /* Read ECOFF debugging information from a .mdebug section into a
769 ecoff_debug_info structure. */
772 _bfd_mips_elf_read_ecoff_info (bfd
*abfd
, asection
*section
,
773 struct ecoff_debug_info
*debug
)
776 const struct ecoff_debug_swap
*swap
;
779 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
780 memset (debug
, 0, sizeof (*debug
));
782 ext_hdr
= bfd_malloc (swap
->external_hdr_size
);
783 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
786 if (! bfd_get_section_contents (abfd
, section
, ext_hdr
, 0,
787 swap
->external_hdr_size
))
790 symhdr
= &debug
->symbolic_header
;
791 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
793 /* The symbolic header contains absolute file offsets and sizes to
795 #define READ(ptr, offset, count, size, type) \
796 if (symhdr->count == 0) \
800 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
801 debug->ptr = bfd_malloc (amt); \
802 if (debug->ptr == NULL) \
804 if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0 \
805 || bfd_bread (debug->ptr, amt, abfd) != amt) \
809 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
810 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, void *);
811 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, void *);
812 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, void *);
813 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, void *);
814 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
816 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
817 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
818 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, void *);
819 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, void *);
820 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, void *);
824 debug
->adjust
= NULL
;
831 if (debug
->line
!= NULL
)
833 if (debug
->external_dnr
!= NULL
)
834 free (debug
->external_dnr
);
835 if (debug
->external_pdr
!= NULL
)
836 free (debug
->external_pdr
);
837 if (debug
->external_sym
!= NULL
)
838 free (debug
->external_sym
);
839 if (debug
->external_opt
!= NULL
)
840 free (debug
->external_opt
);
841 if (debug
->external_aux
!= NULL
)
842 free (debug
->external_aux
);
843 if (debug
->ss
!= NULL
)
845 if (debug
->ssext
!= NULL
)
847 if (debug
->external_fdr
!= NULL
)
848 free (debug
->external_fdr
);
849 if (debug
->external_rfd
!= NULL
)
850 free (debug
->external_rfd
);
851 if (debug
->external_ext
!= NULL
)
852 free (debug
->external_ext
);
856 /* Swap RPDR (runtime procedure table entry) for output. */
859 ecoff_swap_rpdr_out (bfd
*abfd
, const RPDR
*in
, struct rpdr_ext
*ex
)
861 H_PUT_S32 (abfd
, in
->adr
, ex
->p_adr
);
862 H_PUT_32 (abfd
, in
->regmask
, ex
->p_regmask
);
863 H_PUT_32 (abfd
, in
->regoffset
, ex
->p_regoffset
);
864 H_PUT_32 (abfd
, in
->fregmask
, ex
->p_fregmask
);
865 H_PUT_32 (abfd
, in
->fregoffset
, ex
->p_fregoffset
);
866 H_PUT_32 (abfd
, in
->frameoffset
, ex
->p_frameoffset
);
868 H_PUT_16 (abfd
, in
->framereg
, ex
->p_framereg
);
869 H_PUT_16 (abfd
, in
->pcreg
, ex
->p_pcreg
);
871 H_PUT_32 (abfd
, in
->irpss
, ex
->p_irpss
);
873 H_PUT_S32 (abfd
, in
->exception_info
, ex
->p_exception_info
);
877 /* Create a runtime procedure table from the .mdebug section. */
880 mips_elf_create_procedure_table (void *handle
, bfd
*abfd
,
881 struct bfd_link_info
*info
, asection
*s
,
882 struct ecoff_debug_info
*debug
)
884 const struct ecoff_debug_swap
*swap
;
885 HDRR
*hdr
= &debug
->symbolic_header
;
887 struct rpdr_ext
*erp
;
889 struct pdr_ext
*epdr
;
890 struct sym_ext
*esym
;
895 unsigned long sindex
;
899 const char *no_name_func
= _("static procedure (no name)");
907 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
909 sindex
= strlen (no_name_func
) + 1;
913 size
= swap
->external_pdr_size
;
915 epdr
= bfd_malloc (size
* count
);
919 if (! _bfd_ecoff_get_accumulated_pdr (handle
, (bfd_byte
*) epdr
))
922 size
= sizeof (RPDR
);
923 rp
= rpdr
= bfd_malloc (size
* count
);
927 size
= sizeof (char *);
928 sv
= bfd_malloc (size
* count
);
932 count
= hdr
->isymMax
;
933 size
= swap
->external_sym_size
;
934 esym
= bfd_malloc (size
* count
);
938 if (! _bfd_ecoff_get_accumulated_sym (handle
, (bfd_byte
*) esym
))
942 ss
= bfd_malloc (count
);
945 if (! _bfd_ecoff_get_accumulated_ss (handle
, ss
))
949 for (i
= 0; i
< (unsigned long) count
; i
++, rp
++)
951 (*swap
->swap_pdr_in
) (abfd
, epdr
+ i
, &pdr
);
952 (*swap
->swap_sym_in
) (abfd
, &esym
[pdr
.isym
], &sym
);
954 rp
->regmask
= pdr
.regmask
;
955 rp
->regoffset
= pdr
.regoffset
;
956 rp
->fregmask
= pdr
.fregmask
;
957 rp
->fregoffset
= pdr
.fregoffset
;
958 rp
->frameoffset
= pdr
.frameoffset
;
959 rp
->framereg
= pdr
.framereg
;
960 rp
->pcreg
= pdr
.pcreg
;
962 sv
[i
] = ss
+ sym
.iss
;
963 sindex
+= strlen (sv
[i
]) + 1;
967 size
= sizeof (struct rpdr_ext
) * (count
+ 2) + sindex
;
968 size
= BFD_ALIGN (size
, 16);
969 rtproc
= bfd_alloc (abfd
, size
);
972 mips_elf_hash_table (info
)->procedure_count
= 0;
976 mips_elf_hash_table (info
)->procedure_count
= count
+ 2;
979 memset (erp
, 0, sizeof (struct rpdr_ext
));
981 str
= (char *) rtproc
+ sizeof (struct rpdr_ext
) * (count
+ 2);
982 strcpy (str
, no_name_func
);
983 str
+= strlen (no_name_func
) + 1;
984 for (i
= 0; i
< count
; i
++)
986 ecoff_swap_rpdr_out (abfd
, rpdr
+ i
, erp
+ i
);
988 str
+= strlen (sv
[i
]) + 1;
990 H_PUT_S32 (abfd
, -1, (erp
+ count
)->p_adr
);
992 /* Set the size and contents of .rtproc section. */
994 s
->contents
= rtproc
;
996 /* Skip this section later on (I don't think this currently
997 matters, but someday it might). */
998 s
->link_order_head
= NULL
;
1027 /* Check the mips16 stubs for a particular symbol, and see if we can
1031 mips_elf_check_mips16_stubs (struct mips_elf_link_hash_entry
*h
,
1032 void *data ATTRIBUTE_UNUSED
)
1034 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1035 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1037 if (h
->fn_stub
!= NULL
1038 && ! h
->need_fn_stub
)
1040 /* We don't need the fn_stub; the only references to this symbol
1041 are 16 bit calls. Clobber the size to 0 to prevent it from
1042 being included in the link. */
1043 h
->fn_stub
->_raw_size
= 0;
1044 h
->fn_stub
->_cooked_size
= 0;
1045 h
->fn_stub
->flags
&= ~SEC_RELOC
;
1046 h
->fn_stub
->reloc_count
= 0;
1047 h
->fn_stub
->flags
|= SEC_EXCLUDE
;
1050 if (h
->call_stub
!= NULL
1051 && h
->root
.other
== STO_MIPS16
)
1053 /* We don't need the call_stub; this is a 16 bit function, so
1054 calls from other 16 bit functions are OK. Clobber the size
1055 to 0 to prevent it from being included in the link. */
1056 h
->call_stub
->_raw_size
= 0;
1057 h
->call_stub
->_cooked_size
= 0;
1058 h
->call_stub
->flags
&= ~SEC_RELOC
;
1059 h
->call_stub
->reloc_count
= 0;
1060 h
->call_stub
->flags
|= SEC_EXCLUDE
;
1063 if (h
->call_fp_stub
!= NULL
1064 && h
->root
.other
== STO_MIPS16
)
1066 /* We don't need the call_stub; this is a 16 bit function, so
1067 calls from other 16 bit functions are OK. Clobber the size
1068 to 0 to prevent it from being included in the link. */
1069 h
->call_fp_stub
->_raw_size
= 0;
1070 h
->call_fp_stub
->_cooked_size
= 0;
1071 h
->call_fp_stub
->flags
&= ~SEC_RELOC
;
1072 h
->call_fp_stub
->reloc_count
= 0;
1073 h
->call_fp_stub
->flags
|= SEC_EXCLUDE
;
1079 bfd_reloc_status_type
1080 _bfd_mips_elf_gprel16_with_gp (bfd
*abfd
, asymbol
*symbol
,
1081 arelent
*reloc_entry
, asection
*input_section
,
1082 bfd_boolean relocatable
, void *data
, bfd_vma gp
)
1086 bfd_reloc_status_type status
;
1088 if (bfd_is_com_section (symbol
->section
))
1091 relocation
= symbol
->value
;
1093 relocation
+= symbol
->section
->output_section
->vma
;
1094 relocation
+= symbol
->section
->output_offset
;
1096 if (reloc_entry
->address
> input_section
->_cooked_size
)
1097 return bfd_reloc_outofrange
;
1099 /* Set val to the offset into the section or symbol. */
1100 val
= reloc_entry
->addend
;
1102 _bfd_mips_elf_sign_extend (val
, 16);
1104 /* Adjust val for the final section location and GP value. If we
1105 are producing relocatable output, we don't want to do this for
1106 an external symbol. */
1108 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1109 val
+= relocation
- gp
;
1111 if (reloc_entry
->howto
->partial_inplace
)
1113 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
1115 + reloc_entry
->address
);
1116 if (status
!= bfd_reloc_ok
)
1120 reloc_entry
->addend
= val
;
1123 reloc_entry
->address
+= input_section
->output_offset
;
1125 return bfd_reloc_ok
;
1128 /* Used to store a REL high-part relocation such as R_MIPS_HI16 or
1129 R_MIPS_GOT16. REL is the relocation, INPUT_SECTION is the section
1130 that contains the relocation field and DATA points to the start of
1135 struct mips_hi16
*next
;
1137 asection
*input_section
;
1141 /* FIXME: This should not be a static variable. */
1143 static struct mips_hi16
*mips_hi16_list
;
1145 /* A howto special_function for REL *HI16 relocations. We can only
1146 calculate the correct value once we've seen the partnering
1147 *LO16 relocation, so just save the information for later.
1149 The ABI requires that the *LO16 immediately follow the *HI16.
1150 However, as a GNU extension, we permit an arbitrary number of
1151 *HI16s to be associated with a single *LO16. This significantly
1152 simplies the relocation handling in gcc. */
1154 bfd_reloc_status_type
1155 _bfd_mips_elf_hi16_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
1156 asymbol
*symbol ATTRIBUTE_UNUSED
, void *data
,
1157 asection
*input_section
, bfd
*output_bfd
,
1158 char **error_message ATTRIBUTE_UNUSED
)
1160 struct mips_hi16
*n
;
1162 if (reloc_entry
->address
> input_section
->_cooked_size
)
1163 return bfd_reloc_outofrange
;
1165 n
= bfd_malloc (sizeof *n
);
1167 return bfd_reloc_outofrange
;
1169 n
->next
= mips_hi16_list
;
1171 n
->input_section
= input_section
;
1172 n
->rel
= *reloc_entry
;
1175 if (output_bfd
!= NULL
)
1176 reloc_entry
->address
+= input_section
->output_offset
;
1178 return bfd_reloc_ok
;
1181 /* A howto special_function for REL R_MIPS_GOT16 relocations. This is just
1182 like any other 16-bit relocation when applied to global symbols, but is
1183 treated in the same as R_MIPS_HI16 when applied to local symbols. */
1185 bfd_reloc_status_type
1186 _bfd_mips_elf_got16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1187 void *data
, asection
*input_section
,
1188 bfd
*output_bfd
, char **error_message
)
1190 if ((symbol
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
1191 || bfd_is_und_section (bfd_get_section (symbol
))
1192 || bfd_is_com_section (bfd_get_section (symbol
)))
1193 /* The relocation is against a global symbol. */
1194 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1195 input_section
, output_bfd
,
1198 return _bfd_mips_elf_hi16_reloc (abfd
, reloc_entry
, symbol
, data
,
1199 input_section
, output_bfd
, error_message
);
1202 /* A howto special_function for REL *LO16 relocations. The *LO16 itself
1203 is a straightforward 16 bit inplace relocation, but we must deal with
1204 any partnering high-part relocations as well. */
1206 bfd_reloc_status_type
1207 _bfd_mips_elf_lo16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1208 void *data
, asection
*input_section
,
1209 bfd
*output_bfd
, char **error_message
)
1213 if (reloc_entry
->address
> input_section
->_cooked_size
)
1214 return bfd_reloc_outofrange
;
1216 vallo
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1217 while (mips_hi16_list
!= NULL
)
1219 bfd_reloc_status_type ret
;
1220 struct mips_hi16
*hi
;
1222 hi
= mips_hi16_list
;
1224 /* R_MIPS_GOT16 relocations are something of a special case. We
1225 want to install the addend in the same way as for a R_MIPS_HI16
1226 relocation (with a rightshift of 16). However, since GOT16
1227 relocations can also be used with global symbols, their howto
1228 has a rightshift of 0. */
1229 if (hi
->rel
.howto
->type
== R_MIPS_GOT16
)
1230 hi
->rel
.howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, R_MIPS_HI16
, FALSE
);
1232 /* VALLO is a signed 16-bit number. Bias it by 0x8000 so that any
1233 carry or borrow will induce a change of +1 or -1 in the high part. */
1234 hi
->rel
.addend
+= (vallo
+ 0x8000) & 0xffff;
1236 /* R_MIPS_GNU_REL_HI16 relocations are relative to the address of the
1237 lo16 relocation, not their own address. If we're calculating the
1238 final value, and hence subtracting the "PC", subtract the offset
1239 of the lo16 relocation from here. */
1240 if (output_bfd
== NULL
&& hi
->rel
.howto
->type
== R_MIPS_GNU_REL_HI16
)
1241 hi
->rel
.addend
-= reloc_entry
->address
- hi
->rel
.address
;
1243 ret
= _bfd_mips_elf_generic_reloc (abfd
, &hi
->rel
, symbol
, hi
->data
,
1244 hi
->input_section
, output_bfd
,
1246 if (ret
!= bfd_reloc_ok
)
1249 mips_hi16_list
= hi
->next
;
1253 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1254 input_section
, output_bfd
,
1258 /* A generic howto special_function. This calculates and installs the
1259 relocation itself, thus avoiding the oft-discussed problems in
1260 bfd_perform_relocation and bfd_install_relocation. */
1262 bfd_reloc_status_type
1263 _bfd_mips_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
1264 asymbol
*symbol
, void *data ATTRIBUTE_UNUSED
,
1265 asection
*input_section
, bfd
*output_bfd
,
1266 char **error_message ATTRIBUTE_UNUSED
)
1269 bfd_reloc_status_type status
;
1270 bfd_boolean relocatable
;
1272 relocatable
= (output_bfd
!= NULL
);
1274 if (reloc_entry
->address
> input_section
->_cooked_size
)
1275 return bfd_reloc_outofrange
;
1277 /* Build up the field adjustment in VAL. */
1279 if (!relocatable
|| (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1281 /* Either we're calculating the final field value or we have a
1282 relocation against a section symbol. Add in the section's
1283 offset or address. */
1284 val
+= symbol
->section
->output_section
->vma
;
1285 val
+= symbol
->section
->output_offset
;
1290 /* We're calculating the final field value. Add in the symbol's value
1291 and, if pc-relative, subtract the address of the field itself. */
1292 val
+= symbol
->value
;
1293 if (reloc_entry
->howto
->pc_relative
)
1295 val
-= input_section
->output_section
->vma
;
1296 val
-= input_section
->output_offset
;
1297 val
-= reloc_entry
->address
;
1301 /* VAL is now the final adjustment. If we're keeping this relocation
1302 in the output file, and if the relocation uses a separate addend,
1303 we just need to add VAL to that addend. Otherwise we need to add
1304 VAL to the relocation field itself. */
1305 if (relocatable
&& !reloc_entry
->howto
->partial_inplace
)
1306 reloc_entry
->addend
+= val
;
1309 /* Add in the separate addend, if any. */
1310 val
+= reloc_entry
->addend
;
1312 /* Add VAL to the relocation field. */
1313 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
1315 + reloc_entry
->address
);
1316 if (status
!= bfd_reloc_ok
)
1321 reloc_entry
->address
+= input_section
->output_offset
;
1323 return bfd_reloc_ok
;
1326 /* Swap an entry in a .gptab section. Note that these routines rely
1327 on the equivalence of the two elements of the union. */
1330 bfd_mips_elf32_swap_gptab_in (bfd
*abfd
, const Elf32_External_gptab
*ex
,
1333 in
->gt_entry
.gt_g_value
= H_GET_32 (abfd
, ex
->gt_entry
.gt_g_value
);
1334 in
->gt_entry
.gt_bytes
= H_GET_32 (abfd
, ex
->gt_entry
.gt_bytes
);
1338 bfd_mips_elf32_swap_gptab_out (bfd
*abfd
, const Elf32_gptab
*in
,
1339 Elf32_External_gptab
*ex
)
1341 H_PUT_32 (abfd
, in
->gt_entry
.gt_g_value
, ex
->gt_entry
.gt_g_value
);
1342 H_PUT_32 (abfd
, in
->gt_entry
.gt_bytes
, ex
->gt_entry
.gt_bytes
);
1346 bfd_elf32_swap_compact_rel_out (bfd
*abfd
, const Elf32_compact_rel
*in
,
1347 Elf32_External_compact_rel
*ex
)
1349 H_PUT_32 (abfd
, in
->id1
, ex
->id1
);
1350 H_PUT_32 (abfd
, in
->num
, ex
->num
);
1351 H_PUT_32 (abfd
, in
->id2
, ex
->id2
);
1352 H_PUT_32 (abfd
, in
->offset
, ex
->offset
);
1353 H_PUT_32 (abfd
, in
->reserved0
, ex
->reserved0
);
1354 H_PUT_32 (abfd
, in
->reserved1
, ex
->reserved1
);
1358 bfd_elf32_swap_crinfo_out (bfd
*abfd
, const Elf32_crinfo
*in
,
1359 Elf32_External_crinfo
*ex
)
1363 l
= (((in
->ctype
& CRINFO_CTYPE
) << CRINFO_CTYPE_SH
)
1364 | ((in
->rtype
& CRINFO_RTYPE
) << CRINFO_RTYPE_SH
)
1365 | ((in
->dist2to
& CRINFO_DIST2TO
) << CRINFO_DIST2TO_SH
)
1366 | ((in
->relvaddr
& CRINFO_RELVADDR
) << CRINFO_RELVADDR_SH
));
1367 H_PUT_32 (abfd
, l
, ex
->info
);
1368 H_PUT_32 (abfd
, in
->konst
, ex
->konst
);
1369 H_PUT_32 (abfd
, in
->vaddr
, ex
->vaddr
);
1372 /* A .reginfo section holds a single Elf32_RegInfo structure. These
1373 routines swap this structure in and out. They are used outside of
1374 BFD, so they are globally visible. */
1377 bfd_mips_elf32_swap_reginfo_in (bfd
*abfd
, const Elf32_External_RegInfo
*ex
,
1380 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1381 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1382 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1383 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1384 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1385 in
->ri_gp_value
= H_GET_32 (abfd
, ex
->ri_gp_value
);
1389 bfd_mips_elf32_swap_reginfo_out (bfd
*abfd
, const Elf32_RegInfo
*in
,
1390 Elf32_External_RegInfo
*ex
)
1392 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1393 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1394 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1395 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1396 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1397 H_PUT_32 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1400 /* In the 64 bit ABI, the .MIPS.options section holds register
1401 information in an Elf64_Reginfo structure. These routines swap
1402 them in and out. They are globally visible because they are used
1403 outside of BFD. These routines are here so that gas can call them
1404 without worrying about whether the 64 bit ABI has been included. */
1407 bfd_mips_elf64_swap_reginfo_in (bfd
*abfd
, const Elf64_External_RegInfo
*ex
,
1408 Elf64_Internal_RegInfo
*in
)
1410 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1411 in
->ri_pad
= H_GET_32 (abfd
, ex
->ri_pad
);
1412 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1413 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1414 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1415 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1416 in
->ri_gp_value
= H_GET_64 (abfd
, ex
->ri_gp_value
);
1420 bfd_mips_elf64_swap_reginfo_out (bfd
*abfd
, const Elf64_Internal_RegInfo
*in
,
1421 Elf64_External_RegInfo
*ex
)
1423 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1424 H_PUT_32 (abfd
, in
->ri_pad
, ex
->ri_pad
);
1425 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1426 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1427 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1428 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1429 H_PUT_64 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1432 /* Swap in an options header. */
1435 bfd_mips_elf_swap_options_in (bfd
*abfd
, const Elf_External_Options
*ex
,
1436 Elf_Internal_Options
*in
)
1438 in
->kind
= H_GET_8 (abfd
, ex
->kind
);
1439 in
->size
= H_GET_8 (abfd
, ex
->size
);
1440 in
->section
= H_GET_16 (abfd
, ex
->section
);
1441 in
->info
= H_GET_32 (abfd
, ex
->info
);
1444 /* Swap out an options header. */
1447 bfd_mips_elf_swap_options_out (bfd
*abfd
, const Elf_Internal_Options
*in
,
1448 Elf_External_Options
*ex
)
1450 H_PUT_8 (abfd
, in
->kind
, ex
->kind
);
1451 H_PUT_8 (abfd
, in
->size
, ex
->size
);
1452 H_PUT_16 (abfd
, in
->section
, ex
->section
);
1453 H_PUT_32 (abfd
, in
->info
, ex
->info
);
1456 /* This function is called via qsort() to sort the dynamic relocation
1457 entries by increasing r_symndx value. */
1460 sort_dynamic_relocs (const void *arg1
, const void *arg2
)
1462 Elf_Internal_Rela int_reloc1
;
1463 Elf_Internal_Rela int_reloc2
;
1465 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg1
, &int_reloc1
);
1466 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg2
, &int_reloc2
);
1468 return ELF32_R_SYM (int_reloc1
.r_info
) - ELF32_R_SYM (int_reloc2
.r_info
);
1471 /* Like sort_dynamic_relocs, but used for elf64 relocations. */
1474 sort_dynamic_relocs_64 (const void *arg1
, const void *arg2
)
1476 Elf_Internal_Rela int_reloc1
[3];
1477 Elf_Internal_Rela int_reloc2
[3];
1479 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1480 (reldyn_sorting_bfd
, arg1
, int_reloc1
);
1481 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1482 (reldyn_sorting_bfd
, arg2
, int_reloc2
);
1484 return (ELF64_R_SYM (int_reloc1
[0].r_info
)
1485 - ELF64_R_SYM (int_reloc2
[0].r_info
));
1489 /* This routine is used to write out ECOFF debugging external symbol
1490 information. It is called via mips_elf_link_hash_traverse. The
1491 ECOFF external symbol information must match the ELF external
1492 symbol information. Unfortunately, at this point we don't know
1493 whether a symbol is required by reloc information, so the two
1494 tables may wind up being different. We must sort out the external
1495 symbol information before we can set the final size of the .mdebug
1496 section, and we must set the size of the .mdebug section before we
1497 can relocate any sections, and we can't know which symbols are
1498 required by relocation until we relocate the sections.
1499 Fortunately, it is relatively unlikely that any symbol will be
1500 stripped but required by a reloc. In particular, it can not happen
1501 when generating a final executable. */
1504 mips_elf_output_extsym (struct mips_elf_link_hash_entry
*h
, void *data
)
1506 struct extsym_info
*einfo
= data
;
1508 asection
*sec
, *output_section
;
1510 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1511 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1513 if (h
->root
.indx
== -2)
1515 else if (((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1516 || (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
1517 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1518 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
1520 else if (einfo
->info
->strip
== strip_all
1521 || (einfo
->info
->strip
== strip_some
1522 && bfd_hash_lookup (einfo
->info
->keep_hash
,
1523 h
->root
.root
.root
.string
,
1524 FALSE
, FALSE
) == NULL
))
1532 if (h
->esym
.ifd
== -2)
1535 h
->esym
.cobol_main
= 0;
1536 h
->esym
.weakext
= 0;
1537 h
->esym
.reserved
= 0;
1538 h
->esym
.ifd
= ifdNil
;
1539 h
->esym
.asym
.value
= 0;
1540 h
->esym
.asym
.st
= stGlobal
;
1542 if (h
->root
.root
.type
== bfd_link_hash_undefined
1543 || h
->root
.root
.type
== bfd_link_hash_undefweak
)
1547 /* Use undefined class. Also, set class and type for some
1549 name
= h
->root
.root
.root
.string
;
1550 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
1551 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
1553 h
->esym
.asym
.sc
= scData
;
1554 h
->esym
.asym
.st
= stLabel
;
1555 h
->esym
.asym
.value
= 0;
1557 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
1559 h
->esym
.asym
.sc
= scAbs
;
1560 h
->esym
.asym
.st
= stLabel
;
1561 h
->esym
.asym
.value
=
1562 mips_elf_hash_table (einfo
->info
)->procedure_count
;
1564 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (einfo
->abfd
))
1566 h
->esym
.asym
.sc
= scAbs
;
1567 h
->esym
.asym
.st
= stLabel
;
1568 h
->esym
.asym
.value
= elf_gp (einfo
->abfd
);
1571 h
->esym
.asym
.sc
= scUndefined
;
1573 else if (h
->root
.root
.type
!= bfd_link_hash_defined
1574 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
1575 h
->esym
.asym
.sc
= scAbs
;
1580 sec
= h
->root
.root
.u
.def
.section
;
1581 output_section
= sec
->output_section
;
1583 /* When making a shared library and symbol h is the one from
1584 the another shared library, OUTPUT_SECTION may be null. */
1585 if (output_section
== NULL
)
1586 h
->esym
.asym
.sc
= scUndefined
;
1589 name
= bfd_section_name (output_section
->owner
, output_section
);
1591 if (strcmp (name
, ".text") == 0)
1592 h
->esym
.asym
.sc
= scText
;
1593 else if (strcmp (name
, ".data") == 0)
1594 h
->esym
.asym
.sc
= scData
;
1595 else if (strcmp (name
, ".sdata") == 0)
1596 h
->esym
.asym
.sc
= scSData
;
1597 else if (strcmp (name
, ".rodata") == 0
1598 || strcmp (name
, ".rdata") == 0)
1599 h
->esym
.asym
.sc
= scRData
;
1600 else if (strcmp (name
, ".bss") == 0)
1601 h
->esym
.asym
.sc
= scBss
;
1602 else if (strcmp (name
, ".sbss") == 0)
1603 h
->esym
.asym
.sc
= scSBss
;
1604 else if (strcmp (name
, ".init") == 0)
1605 h
->esym
.asym
.sc
= scInit
;
1606 else if (strcmp (name
, ".fini") == 0)
1607 h
->esym
.asym
.sc
= scFini
;
1609 h
->esym
.asym
.sc
= scAbs
;
1613 h
->esym
.asym
.reserved
= 0;
1614 h
->esym
.asym
.index
= indexNil
;
1617 if (h
->root
.root
.type
== bfd_link_hash_common
)
1618 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
1619 else if (h
->root
.root
.type
== bfd_link_hash_defined
1620 || h
->root
.root
.type
== bfd_link_hash_defweak
)
1622 if (h
->esym
.asym
.sc
== scCommon
)
1623 h
->esym
.asym
.sc
= scBss
;
1624 else if (h
->esym
.asym
.sc
== scSCommon
)
1625 h
->esym
.asym
.sc
= scSBss
;
1627 sec
= h
->root
.root
.u
.def
.section
;
1628 output_section
= sec
->output_section
;
1629 if (output_section
!= NULL
)
1630 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
1631 + sec
->output_offset
1632 + output_section
->vma
);
1634 h
->esym
.asym
.value
= 0;
1636 else if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
1638 struct mips_elf_link_hash_entry
*hd
= h
;
1639 bfd_boolean no_fn_stub
= h
->no_fn_stub
;
1641 while (hd
->root
.root
.type
== bfd_link_hash_indirect
)
1643 hd
= (struct mips_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
1644 no_fn_stub
= no_fn_stub
|| hd
->no_fn_stub
;
1649 /* Set type and value for a symbol with a function stub. */
1650 h
->esym
.asym
.st
= stProc
;
1651 sec
= hd
->root
.root
.u
.def
.section
;
1653 h
->esym
.asym
.value
= 0;
1656 output_section
= sec
->output_section
;
1657 if (output_section
!= NULL
)
1658 h
->esym
.asym
.value
= (hd
->root
.plt
.offset
1659 + sec
->output_offset
1660 + output_section
->vma
);
1662 h
->esym
.asym
.value
= 0;
1670 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
1671 h
->root
.root
.root
.string
,
1674 einfo
->failed
= TRUE
;
1681 /* A comparison routine used to sort .gptab entries. */
1684 gptab_compare (const void *p1
, const void *p2
)
1686 const Elf32_gptab
*a1
= p1
;
1687 const Elf32_gptab
*a2
= p2
;
1689 return a1
->gt_entry
.gt_g_value
- a2
->gt_entry
.gt_g_value
;
1692 /* Functions to manage the got entry hash table. */
1694 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
1697 static INLINE hashval_t
1698 mips_elf_hash_bfd_vma (bfd_vma addr
)
1701 return addr
+ (addr
>> 32);
1707 /* got_entries only match if they're identical, except for gotidx, so
1708 use all fields to compute the hash, and compare the appropriate
1712 mips_elf_got_entry_hash (const void *entry_
)
1714 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
1716 return entry
->symndx
1717 + (! entry
->abfd
? mips_elf_hash_bfd_vma (entry
->d
.address
)
1719 + (entry
->symndx
>= 0 ? mips_elf_hash_bfd_vma (entry
->d
.addend
)
1720 : entry
->d
.h
->root
.root
.root
.hash
));
1724 mips_elf_got_entry_eq (const void *entry1
, const void *entry2
)
1726 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
1727 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
1729 return e1
->abfd
== e2
->abfd
&& e1
->symndx
== e2
->symndx
1730 && (! e1
->abfd
? e1
->d
.address
== e2
->d
.address
1731 : e1
->symndx
>= 0 ? e1
->d
.addend
== e2
->d
.addend
1732 : e1
->d
.h
== e2
->d
.h
);
1735 /* multi_got_entries are still a match in the case of global objects,
1736 even if the input bfd in which they're referenced differs, so the
1737 hash computation and compare functions are adjusted
1741 mips_elf_multi_got_entry_hash (const void *entry_
)
1743 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
1745 return entry
->symndx
1747 ? mips_elf_hash_bfd_vma (entry
->d
.address
)
1748 : entry
->symndx
>= 0
1750 + mips_elf_hash_bfd_vma (entry
->d
.addend
))
1751 : entry
->d
.h
->root
.root
.root
.hash
);
1755 mips_elf_multi_got_entry_eq (const void *entry1
, const void *entry2
)
1757 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
1758 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
1760 return e1
->symndx
== e2
->symndx
1761 && (e1
->symndx
>= 0 ? e1
->abfd
== e2
->abfd
&& e1
->d
.addend
== e2
->d
.addend
1762 : e1
->abfd
== NULL
|| e2
->abfd
== NULL
1763 ? e1
->abfd
== e2
->abfd
&& e1
->d
.address
== e2
->d
.address
1764 : e1
->d
.h
== e2
->d
.h
);
1767 /* Returns the dynamic relocation section for DYNOBJ. */
1770 mips_elf_rel_dyn_section (bfd
*dynobj
, bfd_boolean create_p
)
1772 static const char dname
[] = ".rel.dyn";
1775 sreloc
= bfd_get_section_by_name (dynobj
, dname
);
1776 if (sreloc
== NULL
&& create_p
)
1778 sreloc
= bfd_make_section (dynobj
, dname
);
1780 || ! bfd_set_section_flags (dynobj
, sreloc
,
1785 | SEC_LINKER_CREATED
1787 || ! bfd_set_section_alignment (dynobj
, sreloc
,
1788 MIPS_ELF_LOG_FILE_ALIGN (dynobj
)))
1794 /* Returns the GOT section for ABFD. */
1797 mips_elf_got_section (bfd
*abfd
, bfd_boolean maybe_excluded
)
1799 asection
*sgot
= bfd_get_section_by_name (abfd
, ".got");
1801 || (! maybe_excluded
&& (sgot
->flags
& SEC_EXCLUDE
) != 0))
1806 /* Returns the GOT information associated with the link indicated by
1807 INFO. If SGOTP is non-NULL, it is filled in with the GOT
1810 static struct mips_got_info
*
1811 mips_elf_got_info (bfd
*abfd
, asection
**sgotp
)
1814 struct mips_got_info
*g
;
1816 sgot
= mips_elf_got_section (abfd
, TRUE
);
1817 BFD_ASSERT (sgot
!= NULL
);
1818 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
1819 g
= mips_elf_section_data (sgot
)->u
.got_info
;
1820 BFD_ASSERT (g
!= NULL
);
1823 *sgotp
= (sgot
->flags
& SEC_EXCLUDE
) == 0 ? sgot
: NULL
;
1828 /* Obtain the lowest dynamic index of a symbol that was assigned a
1829 global GOT entry. */
1831 mips_elf_get_global_gotsym_index (bfd
*abfd
)
1834 struct mips_got_info
*g
;
1839 sgot
= mips_elf_got_section (abfd
, TRUE
);
1840 if (sgot
== NULL
|| mips_elf_section_data (sgot
) == NULL
)
1843 g
= mips_elf_section_data (sgot
)->u
.got_info
;
1844 if (g
== NULL
|| g
->global_gotsym
== NULL
)
1847 return g
->global_gotsym
->dynindx
;
1850 /* Returns the GOT offset at which the indicated address can be found.
1851 If there is not yet a GOT entry for this value, create one. Returns
1852 -1 if no satisfactory GOT offset can be found. */
1855 mips_elf_local_got_index (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
1859 struct mips_got_info
*g
;
1860 struct mips_got_entry
*entry
;
1862 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1864 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
, value
);
1866 return entry
->gotidx
;
1871 /* Returns the GOT index for the global symbol indicated by H. */
1874 mips_elf_global_got_index (bfd
*abfd
, bfd
*ibfd
, struct elf_link_hash_entry
*h
)
1878 struct mips_got_info
*g
, *gg
;
1879 long global_got_dynindx
= 0;
1881 gg
= g
= mips_elf_got_info (abfd
, &sgot
);
1882 if (g
->bfd2got
&& ibfd
)
1884 struct mips_got_entry e
, *p
;
1886 BFD_ASSERT (h
->dynindx
>= 0);
1888 g
= mips_elf_got_for_ibfd (g
, ibfd
);
1893 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
1895 p
= htab_find (g
->got_entries
, &e
);
1897 BFD_ASSERT (p
->gotidx
> 0);
1902 if (gg
->global_gotsym
!= NULL
)
1903 global_got_dynindx
= gg
->global_gotsym
->dynindx
;
1905 /* Once we determine the global GOT entry with the lowest dynamic
1906 symbol table index, we must put all dynamic symbols with greater
1907 indices into the GOT. That makes it easy to calculate the GOT
1909 BFD_ASSERT (h
->dynindx
>= global_got_dynindx
);
1910 index
= ((h
->dynindx
- global_got_dynindx
+ g
->local_gotno
)
1911 * MIPS_ELF_GOT_SIZE (abfd
));
1912 BFD_ASSERT (index
< sgot
->_raw_size
);
1917 /* Find a GOT entry that is within 32KB of the VALUE. These entries
1918 are supposed to be placed at small offsets in the GOT, i.e.,
1919 within 32KB of GP. Return the index into the GOT for this page,
1920 and store the offset from this entry to the desired address in
1921 OFFSETP, if it is non-NULL. */
1924 mips_elf_got_page (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
1925 bfd_vma value
, bfd_vma
*offsetp
)
1928 struct mips_got_info
*g
;
1930 struct mips_got_entry
*entry
;
1932 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1934 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
,
1936 & (~(bfd_vma
)0xffff));
1941 index
= entry
->gotidx
;
1944 *offsetp
= value
- entry
->d
.address
;
1949 /* Find a GOT entry whose higher-order 16 bits are the same as those
1950 for value. Return the index into the GOT for this entry. */
1953 mips_elf_got16_entry (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
1954 bfd_vma value
, bfd_boolean external
)
1957 struct mips_got_info
*g
;
1958 struct mips_got_entry
*entry
;
1962 /* Although the ABI says that it is "the high-order 16 bits" that we
1963 want, it is really the %high value. The complete value is
1964 calculated with a `addiu' of a LO16 relocation, just as with a
1966 value
= mips_elf_high (value
) << 16;
1969 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1971 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
, value
);
1973 return entry
->gotidx
;
1978 /* Returns the offset for the entry at the INDEXth position
1982 mips_elf_got_offset_from_index (bfd
*dynobj
, bfd
*output_bfd
,
1983 bfd
*input_bfd
, bfd_vma index
)
1987 struct mips_got_info
*g
;
1989 g
= mips_elf_got_info (dynobj
, &sgot
);
1990 gp
= _bfd_get_gp_value (output_bfd
)
1991 + mips_elf_adjust_gp (output_bfd
, g
, input_bfd
);
1993 return sgot
->output_section
->vma
+ sgot
->output_offset
+ index
- gp
;
1996 /* Create a local GOT entry for VALUE. Return the index of the entry,
1997 or -1 if it could not be created. */
1999 static struct mips_got_entry
*
2000 mips_elf_create_local_got_entry (bfd
*abfd
, bfd
*ibfd
,
2001 struct mips_got_info
*gg
,
2002 asection
*sgot
, bfd_vma value
)
2004 struct mips_got_entry entry
, **loc
;
2005 struct mips_got_info
*g
;
2009 entry
.d
.address
= value
;
2011 g
= mips_elf_got_for_ibfd (gg
, ibfd
);
2014 g
= mips_elf_got_for_ibfd (gg
, abfd
);
2015 BFD_ASSERT (g
!= NULL
);
2018 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
2023 entry
.gotidx
= MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
++;
2025 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2030 memcpy (*loc
, &entry
, sizeof entry
);
2032 if (g
->assigned_gotno
>= g
->local_gotno
)
2034 (*loc
)->gotidx
= -1;
2035 /* We didn't allocate enough space in the GOT. */
2036 (*_bfd_error_handler
)
2037 (_("not enough GOT space for local GOT entries"));
2038 bfd_set_error (bfd_error_bad_value
);
2042 MIPS_ELF_PUT_WORD (abfd
, value
,
2043 (sgot
->contents
+ entry
.gotidx
));
2048 /* Sort the dynamic symbol table so that symbols that need GOT entries
2049 appear towards the end. This reduces the amount of GOT space
2050 required. MAX_LOCAL is used to set the number of local symbols
2051 known to be in the dynamic symbol table. During
2052 _bfd_mips_elf_size_dynamic_sections, this value is 1. Afterward, the
2053 section symbols are added and the count is higher. */
2056 mips_elf_sort_hash_table (struct bfd_link_info
*info
, unsigned long max_local
)
2058 struct mips_elf_hash_sort_data hsd
;
2059 struct mips_got_info
*g
;
2062 dynobj
= elf_hash_table (info
)->dynobj
;
2064 g
= mips_elf_got_info (dynobj
, NULL
);
2067 hsd
.max_unref_got_dynindx
=
2068 hsd
.min_got_dynindx
= elf_hash_table (info
)->dynsymcount
2069 /* In the multi-got case, assigned_gotno of the master got_info
2070 indicate the number of entries that aren't referenced in the
2071 primary GOT, but that must have entries because there are
2072 dynamic relocations that reference it. Since they aren't
2073 referenced, we move them to the end of the GOT, so that they
2074 don't prevent other entries that are referenced from getting
2075 too large offsets. */
2076 - (g
->next
? g
->assigned_gotno
: 0);
2077 hsd
.max_non_got_dynindx
= max_local
;
2078 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table
*)
2079 elf_hash_table (info
)),
2080 mips_elf_sort_hash_table_f
,
2083 /* There should have been enough room in the symbol table to
2084 accommodate both the GOT and non-GOT symbols. */
2085 BFD_ASSERT (hsd
.max_non_got_dynindx
<= hsd
.min_got_dynindx
);
2086 BFD_ASSERT ((unsigned long)hsd
.max_unref_got_dynindx
2087 <= elf_hash_table (info
)->dynsymcount
);
2089 /* Now we know which dynamic symbol has the lowest dynamic symbol
2090 table index in the GOT. */
2091 g
->global_gotsym
= hsd
.low
;
2096 /* If H needs a GOT entry, assign it the highest available dynamic
2097 index. Otherwise, assign it the lowest available dynamic
2101 mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry
*h
, void *data
)
2103 struct mips_elf_hash_sort_data
*hsd
= data
;
2105 if (h
->root
.root
.type
== bfd_link_hash_warning
)
2106 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2108 /* Symbols without dynamic symbol table entries aren't interesting
2110 if (h
->root
.dynindx
== -1)
2113 /* Global symbols that need GOT entries that are not explicitly
2114 referenced are marked with got offset 2. Those that are
2115 referenced get a 1, and those that don't need GOT entries get
2117 if (h
->root
.got
.offset
== 2)
2119 if (hsd
->max_unref_got_dynindx
== hsd
->min_got_dynindx
)
2120 hsd
->low
= (struct elf_link_hash_entry
*) h
;
2121 h
->root
.dynindx
= hsd
->max_unref_got_dynindx
++;
2123 else if (h
->root
.got
.offset
!= 1)
2124 h
->root
.dynindx
= hsd
->max_non_got_dynindx
++;
2127 h
->root
.dynindx
= --hsd
->min_got_dynindx
;
2128 hsd
->low
= (struct elf_link_hash_entry
*) h
;
2134 /* If H is a symbol that needs a global GOT entry, but has a dynamic
2135 symbol table index lower than any we've seen to date, record it for
2139 mips_elf_record_global_got_symbol (struct elf_link_hash_entry
*h
,
2140 bfd
*abfd
, struct bfd_link_info
*info
,
2141 struct mips_got_info
*g
)
2143 struct mips_got_entry entry
, **loc
;
2145 /* A global symbol in the GOT must also be in the dynamic symbol
2147 if (h
->dynindx
== -1)
2149 switch (ELF_ST_VISIBILITY (h
->other
))
2153 _bfd_mips_elf_hide_symbol (info
, h
, TRUE
);
2156 if (!bfd_elf32_link_record_dynamic_symbol (info
, h
))
2162 entry
.d
.h
= (struct mips_elf_link_hash_entry
*) h
;
2164 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
2167 /* If we've already marked this entry as needing GOT space, we don't
2168 need to do it again. */
2172 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2178 memcpy (*loc
, &entry
, sizeof entry
);
2180 if (h
->got
.offset
!= MINUS_ONE
)
2183 /* By setting this to a value other than -1, we are indicating that
2184 there needs to be a GOT entry for H. Avoid using zero, as the
2185 generic ELF copy_indirect_symbol tests for <= 0. */
2191 /* Reserve space in G for a GOT entry containing the value of symbol
2192 SYMNDX in input bfd ABDF, plus ADDEND. */
2195 mips_elf_record_local_got_symbol (bfd
*abfd
, long symndx
, bfd_vma addend
,
2196 struct mips_got_info
*g
)
2198 struct mips_got_entry entry
, **loc
;
2201 entry
.symndx
= symndx
;
2202 entry
.d
.addend
= addend
;
2203 loc
= (struct mips_got_entry
**)
2204 htab_find_slot (g
->got_entries
, &entry
, INSERT
);
2209 entry
.gotidx
= g
->local_gotno
++;
2211 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2216 memcpy (*loc
, &entry
, sizeof entry
);
2221 /* Compute the hash value of the bfd in a bfd2got hash entry. */
2224 mips_elf_bfd2got_entry_hash (const void *entry_
)
2226 const struct mips_elf_bfd2got_hash
*entry
2227 = (struct mips_elf_bfd2got_hash
*)entry_
;
2229 return entry
->bfd
->id
;
2232 /* Check whether two hash entries have the same bfd. */
2235 mips_elf_bfd2got_entry_eq (const void *entry1
, const void *entry2
)
2237 const struct mips_elf_bfd2got_hash
*e1
2238 = (const struct mips_elf_bfd2got_hash
*)entry1
;
2239 const struct mips_elf_bfd2got_hash
*e2
2240 = (const struct mips_elf_bfd2got_hash
*)entry2
;
2242 return e1
->bfd
== e2
->bfd
;
2245 /* In a multi-got link, determine the GOT to be used for IBDF. G must
2246 be the master GOT data. */
2248 static struct mips_got_info
*
2249 mips_elf_got_for_ibfd (struct mips_got_info
*g
, bfd
*ibfd
)
2251 struct mips_elf_bfd2got_hash e
, *p
;
2257 p
= htab_find (g
->bfd2got
, &e
);
2258 return p
? p
->g
: NULL
;
2261 /* Create one separate got for each bfd that has entries in the global
2262 got, such that we can tell how many local and global entries each
2266 mips_elf_make_got_per_bfd (void **entryp
, void *p
)
2268 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2269 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
2270 htab_t bfd2got
= arg
->bfd2got
;
2271 struct mips_got_info
*g
;
2272 struct mips_elf_bfd2got_hash bfdgot_entry
, *bfdgot
;
2275 /* Find the got_info for this GOT entry's input bfd. Create one if
2277 bfdgot_entry
.bfd
= entry
->abfd
;
2278 bfdgotp
= htab_find_slot (bfd2got
, &bfdgot_entry
, INSERT
);
2279 bfdgot
= (struct mips_elf_bfd2got_hash
*)*bfdgotp
;
2285 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
2286 (arg
->obfd
, sizeof (struct mips_elf_bfd2got_hash
));
2296 bfdgot
->bfd
= entry
->abfd
;
2297 bfdgot
->g
= g
= (struct mips_got_info
*)
2298 bfd_alloc (arg
->obfd
, sizeof (struct mips_got_info
));
2305 g
->global_gotsym
= NULL
;
2306 g
->global_gotno
= 0;
2308 g
->assigned_gotno
= -1;
2309 g
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
2310 mips_elf_multi_got_entry_eq
, NULL
);
2311 if (g
->got_entries
== NULL
)
2321 /* Insert the GOT entry in the bfd's got entry hash table. */
2322 entryp
= htab_find_slot (g
->got_entries
, entry
, INSERT
);
2323 if (*entryp
!= NULL
)
2328 if (entry
->symndx
>= 0 || entry
->d
.h
->forced_local
)
2336 /* Attempt to merge gots of different input bfds. Try to use as much
2337 as possible of the primary got, since it doesn't require explicit
2338 dynamic relocations, but don't use bfds that would reference global
2339 symbols out of the addressable range. Failing the primary got,
2340 attempt to merge with the current got, or finish the current got
2341 and then make make the new got current. */
2344 mips_elf_merge_gots (void **bfd2got_
, void *p
)
2346 struct mips_elf_bfd2got_hash
*bfd2got
2347 = (struct mips_elf_bfd2got_hash
*)*bfd2got_
;
2348 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
2349 unsigned int lcount
= bfd2got
->g
->local_gotno
;
2350 unsigned int gcount
= bfd2got
->g
->global_gotno
;
2351 unsigned int maxcnt
= arg
->max_count
;
2353 /* If we don't have a primary GOT and this is not too big, use it as
2354 a starting point for the primary GOT. */
2355 if (! arg
->primary
&& lcount
+ gcount
<= maxcnt
)
2357 arg
->primary
= bfd2got
->g
;
2358 arg
->primary_count
= lcount
+ gcount
;
2360 /* If it looks like we can merge this bfd's entries with those of
2361 the primary, merge them. The heuristics is conservative, but we
2362 don't have to squeeze it too hard. */
2363 else if (arg
->primary
2364 && (arg
->primary_count
+ lcount
+ gcount
) <= maxcnt
)
2366 struct mips_got_info
*g
= bfd2got
->g
;
2367 int old_lcount
= arg
->primary
->local_gotno
;
2368 int old_gcount
= arg
->primary
->global_gotno
;
2370 bfd2got
->g
= arg
->primary
;
2372 htab_traverse (g
->got_entries
,
2373 mips_elf_make_got_per_bfd
,
2375 if (arg
->obfd
== NULL
)
2378 htab_delete (g
->got_entries
);
2379 /* We don't have to worry about releasing memory of the actual
2380 got entries, since they're all in the master got_entries hash
2383 BFD_ASSERT (old_lcount
+ lcount
>= arg
->primary
->local_gotno
);
2384 BFD_ASSERT (old_gcount
+ gcount
>= arg
->primary
->global_gotno
);
2386 arg
->primary_count
= arg
->primary
->local_gotno
2387 + arg
->primary
->global_gotno
;
2389 /* If we can merge with the last-created got, do it. */
2390 else if (arg
->current
2391 && arg
->current_count
+ lcount
+ gcount
<= maxcnt
)
2393 struct mips_got_info
*g
= bfd2got
->g
;
2394 int old_lcount
= arg
->current
->local_gotno
;
2395 int old_gcount
= arg
->current
->global_gotno
;
2397 bfd2got
->g
= arg
->current
;
2399 htab_traverse (g
->got_entries
,
2400 mips_elf_make_got_per_bfd
,
2402 if (arg
->obfd
== NULL
)
2405 htab_delete (g
->got_entries
);
2407 BFD_ASSERT (old_lcount
+ lcount
>= arg
->current
->local_gotno
);
2408 BFD_ASSERT (old_gcount
+ gcount
>= arg
->current
->global_gotno
);
2410 arg
->current_count
= arg
->current
->local_gotno
2411 + arg
->current
->global_gotno
;
2413 /* Well, we couldn't merge, so create a new GOT. Don't check if it
2414 fits; if it turns out that it doesn't, we'll get relocation
2415 overflows anyway. */
2418 bfd2got
->g
->next
= arg
->current
;
2419 arg
->current
= bfd2got
->g
;
2421 arg
->current_count
= lcount
+ gcount
;
2427 /* If passed a NULL mips_got_info in the argument, set the marker used
2428 to tell whether a global symbol needs a got entry (in the primary
2429 got) to the given VALUE.
2431 If passed a pointer G to a mips_got_info in the argument (it must
2432 not be the primary GOT), compute the offset from the beginning of
2433 the (primary) GOT section to the entry in G corresponding to the
2434 global symbol. G's assigned_gotno must contain the index of the
2435 first available global GOT entry in G. VALUE must contain the size
2436 of a GOT entry in bytes. For each global GOT entry that requires a
2437 dynamic relocation, NEEDED_RELOCS is incremented, and the symbol is
2438 marked as not eligible for lazy resolution through a function
2441 mips_elf_set_global_got_offset (void **entryp
, void *p
)
2443 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2444 struct mips_elf_set_global_got_offset_arg
*arg
2445 = (struct mips_elf_set_global_got_offset_arg
*)p
;
2446 struct mips_got_info
*g
= arg
->g
;
2448 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1
2449 && entry
->d
.h
->root
.dynindx
!= -1)
2453 BFD_ASSERT (g
->global_gotsym
== NULL
);
2455 entry
->gotidx
= arg
->value
* (long) g
->assigned_gotno
++;
2456 if (arg
->info
->shared
2457 || (elf_hash_table (arg
->info
)->dynamic_sections_created
2458 && ((entry
->d
.h
->root
.elf_link_hash_flags
2459 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0)
2460 && ((entry
->d
.h
->root
.elf_link_hash_flags
2461 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
2462 ++arg
->needed_relocs
;
2465 entry
->d
.h
->root
.got
.offset
= arg
->value
;
2471 /* Mark any global symbols referenced in the GOT we are iterating over
2472 as inelligible for lazy resolution stubs. */
2474 mips_elf_set_no_stub (void **entryp
, void *p ATTRIBUTE_UNUSED
)
2476 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2478 if (entry
->abfd
!= NULL
2479 && entry
->symndx
== -1
2480 && entry
->d
.h
->root
.dynindx
!= -1)
2481 entry
->d
.h
->no_fn_stub
= TRUE
;
2486 /* Follow indirect and warning hash entries so that each got entry
2487 points to the final symbol definition. P must point to a pointer
2488 to the hash table we're traversing. Since this traversal may
2489 modify the hash table, we set this pointer to NULL to indicate
2490 we've made a potentially-destructive change to the hash table, so
2491 the traversal must be restarted. */
2493 mips_elf_resolve_final_got_entry (void **entryp
, void *p
)
2495 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2496 htab_t got_entries
= *(htab_t
*)p
;
2498 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1)
2500 struct mips_elf_link_hash_entry
*h
= entry
->d
.h
;
2502 while (h
->root
.root
.type
== bfd_link_hash_indirect
2503 || h
->root
.root
.type
== bfd_link_hash_warning
)
2504 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2506 if (entry
->d
.h
== h
)
2511 /* If we can't find this entry with the new bfd hash, re-insert
2512 it, and get the traversal restarted. */
2513 if (! htab_find (got_entries
, entry
))
2515 htab_clear_slot (got_entries
, entryp
);
2516 entryp
= htab_find_slot (got_entries
, entry
, INSERT
);
2519 /* Abort the traversal, since the whole table may have
2520 moved, and leave it up to the parent to restart the
2522 *(htab_t
*)p
= NULL
;
2525 /* We might want to decrement the global_gotno count, but it's
2526 either too early or too late for that at this point. */
2532 /* Turn indirect got entries in a got_entries table into their final
2535 mips_elf_resolve_final_got_entries (struct mips_got_info
*g
)
2541 got_entries
= g
->got_entries
;
2543 htab_traverse (got_entries
,
2544 mips_elf_resolve_final_got_entry
,
2547 while (got_entries
== NULL
);
2550 /* Return the offset of an input bfd IBFD's GOT from the beginning of
2553 mips_elf_adjust_gp (bfd
*abfd
, struct mips_got_info
*g
, bfd
*ibfd
)
2555 if (g
->bfd2got
== NULL
)
2558 g
= mips_elf_got_for_ibfd (g
, ibfd
);
2562 BFD_ASSERT (g
->next
);
2566 return (g
->local_gotno
+ g
->global_gotno
) * MIPS_ELF_GOT_SIZE (abfd
);
2569 /* Turn a single GOT that is too big for 16-bit addressing into
2570 a sequence of GOTs, each one 16-bit addressable. */
2573 mips_elf_multi_got (bfd
*abfd
, struct bfd_link_info
*info
,
2574 struct mips_got_info
*g
, asection
*got
,
2575 bfd_size_type pages
)
2577 struct mips_elf_got_per_bfd_arg got_per_bfd_arg
;
2578 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
2579 struct mips_got_info
*gg
;
2580 unsigned int assign
;
2582 g
->bfd2got
= htab_try_create (1, mips_elf_bfd2got_entry_hash
,
2583 mips_elf_bfd2got_entry_eq
, NULL
);
2584 if (g
->bfd2got
== NULL
)
2587 got_per_bfd_arg
.bfd2got
= g
->bfd2got
;
2588 got_per_bfd_arg
.obfd
= abfd
;
2589 got_per_bfd_arg
.info
= info
;
2591 /* Count how many GOT entries each input bfd requires, creating a
2592 map from bfd to got info while at that. */
2593 mips_elf_resolve_final_got_entries (g
);
2594 htab_traverse (g
->got_entries
, mips_elf_make_got_per_bfd
, &got_per_bfd_arg
);
2595 if (got_per_bfd_arg
.obfd
== NULL
)
2598 got_per_bfd_arg
.current
= NULL
;
2599 got_per_bfd_arg
.primary
= NULL
;
2600 /* Taking out PAGES entries is a worst-case estimate. We could
2601 compute the maximum number of pages that each separate input bfd
2602 uses, but it's probably not worth it. */
2603 got_per_bfd_arg
.max_count
= ((MIPS_ELF_GOT_MAX_SIZE (abfd
)
2604 / MIPS_ELF_GOT_SIZE (abfd
))
2605 - MIPS_RESERVED_GOTNO
- pages
);
2607 /* Try to merge the GOTs of input bfds together, as long as they
2608 don't seem to exceed the maximum GOT size, choosing one of them
2609 to be the primary GOT. */
2610 htab_traverse (g
->bfd2got
, mips_elf_merge_gots
, &got_per_bfd_arg
);
2611 if (got_per_bfd_arg
.obfd
== NULL
)
2614 /* If we find any suitable primary GOT, create an empty one. */
2615 if (got_per_bfd_arg
.primary
== NULL
)
2617 g
->next
= (struct mips_got_info
*)
2618 bfd_alloc (abfd
, sizeof (struct mips_got_info
));
2619 if (g
->next
== NULL
)
2622 g
->next
->global_gotsym
= NULL
;
2623 g
->next
->global_gotno
= 0;
2624 g
->next
->local_gotno
= 0;
2625 g
->next
->assigned_gotno
= 0;
2626 g
->next
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
2627 mips_elf_multi_got_entry_eq
,
2629 if (g
->next
->got_entries
== NULL
)
2631 g
->next
->bfd2got
= NULL
;
2634 g
->next
= got_per_bfd_arg
.primary
;
2635 g
->next
->next
= got_per_bfd_arg
.current
;
2637 /* GG is now the master GOT, and G is the primary GOT. */
2641 /* Map the output bfd to the primary got. That's what we're going
2642 to use for bfds that use GOT16 or GOT_PAGE relocations that we
2643 didn't mark in check_relocs, and we want a quick way to find it.
2644 We can't just use gg->next because we're going to reverse the
2647 struct mips_elf_bfd2got_hash
*bfdgot
;
2650 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
2651 (abfd
, sizeof (struct mips_elf_bfd2got_hash
));
2658 bfdgotp
= htab_find_slot (gg
->bfd2got
, bfdgot
, INSERT
);
2660 BFD_ASSERT (*bfdgotp
== NULL
);
2664 /* The IRIX dynamic linker requires every symbol that is referenced
2665 in a dynamic relocation to be present in the primary GOT, so
2666 arrange for them to appear after those that are actually
2669 GNU/Linux could very well do without it, but it would slow down
2670 the dynamic linker, since it would have to resolve every dynamic
2671 symbol referenced in other GOTs more than once, without help from
2672 the cache. Also, knowing that every external symbol has a GOT
2673 helps speed up the resolution of local symbols too, so GNU/Linux
2674 follows IRIX's practice.
2676 The number 2 is used by mips_elf_sort_hash_table_f to count
2677 global GOT symbols that are unreferenced in the primary GOT, with
2678 an initial dynamic index computed from gg->assigned_gotno, where
2679 the number of unreferenced global entries in the primary GOT is
2683 gg
->assigned_gotno
= gg
->global_gotno
- g
->global_gotno
;
2684 g
->global_gotno
= gg
->global_gotno
;
2685 set_got_offset_arg
.value
= 2;
2689 /* This could be used for dynamic linkers that don't optimize
2690 symbol resolution while applying relocations so as to use
2691 primary GOT entries or assuming the symbol is locally-defined.
2692 With this code, we assign lower dynamic indices to global
2693 symbols that are not referenced in the primary GOT, so that
2694 their entries can be omitted. */
2695 gg
->assigned_gotno
= 0;
2696 set_got_offset_arg
.value
= -1;
2699 /* Reorder dynamic symbols as described above (which behavior
2700 depends on the setting of VALUE). */
2701 set_got_offset_arg
.g
= NULL
;
2702 htab_traverse (gg
->got_entries
, mips_elf_set_global_got_offset
,
2703 &set_got_offset_arg
);
2704 set_got_offset_arg
.value
= 1;
2705 htab_traverse (g
->got_entries
, mips_elf_set_global_got_offset
,
2706 &set_got_offset_arg
);
2707 if (! mips_elf_sort_hash_table (info
, 1))
2710 /* Now go through the GOTs assigning them offset ranges.
2711 [assigned_gotno, local_gotno[ will be set to the range of local
2712 entries in each GOT. We can then compute the end of a GOT by
2713 adding local_gotno to global_gotno. We reverse the list and make
2714 it circular since then we'll be able to quickly compute the
2715 beginning of a GOT, by computing the end of its predecessor. To
2716 avoid special cases for the primary GOT, while still preserving
2717 assertions that are valid for both single- and multi-got links,
2718 we arrange for the main got struct to have the right number of
2719 global entries, but set its local_gotno such that the initial
2720 offset of the primary GOT is zero. Remember that the primary GOT
2721 will become the last item in the circular linked list, so it
2722 points back to the master GOT. */
2723 gg
->local_gotno
= -g
->global_gotno
;
2724 gg
->global_gotno
= g
->global_gotno
;
2730 struct mips_got_info
*gn
;
2732 assign
+= MIPS_RESERVED_GOTNO
;
2733 g
->assigned_gotno
= assign
;
2734 g
->local_gotno
+= assign
+ pages
;
2735 assign
= g
->local_gotno
+ g
->global_gotno
;
2737 /* Take g out of the direct list, and push it onto the reversed
2738 list that gg points to. */
2744 /* Mark global symbols in every non-primary GOT as ineligible for
2747 htab_traverse (g
->got_entries
, mips_elf_set_no_stub
, NULL
);
2751 got
->_raw_size
= (gg
->next
->local_gotno
2752 + gg
->next
->global_gotno
) * MIPS_ELF_GOT_SIZE (abfd
);
2758 /* Returns the first relocation of type r_type found, beginning with
2759 RELOCATION. RELEND is one-past-the-end of the relocation table. */
2761 static const Elf_Internal_Rela
*
2762 mips_elf_next_relocation (bfd
*abfd ATTRIBUTE_UNUSED
, unsigned int r_type
,
2763 const Elf_Internal_Rela
*relocation
,
2764 const Elf_Internal_Rela
*relend
)
2766 /* According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must be
2767 immediately following. However, for the IRIX6 ABI, the next
2768 relocation may be a composed relocation consisting of several
2769 relocations for the same address. In that case, the R_MIPS_LO16
2770 relocation may occur as one of these. We permit a similar
2771 extension in general, as that is useful for GCC. */
2772 while (relocation
< relend
)
2774 if (ELF_R_TYPE (abfd
, relocation
->r_info
) == r_type
)
2780 /* We didn't find it. */
2781 bfd_set_error (bfd_error_bad_value
);
2785 /* Return whether a relocation is against a local symbol. */
2788 mips_elf_local_relocation_p (bfd
*input_bfd
,
2789 const Elf_Internal_Rela
*relocation
,
2790 asection
**local_sections
,
2791 bfd_boolean check_forced
)
2793 unsigned long r_symndx
;
2794 Elf_Internal_Shdr
*symtab_hdr
;
2795 struct mips_elf_link_hash_entry
*h
;
2798 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
2799 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2800 extsymoff
= (elf_bad_symtab (input_bfd
)) ? 0 : symtab_hdr
->sh_info
;
2802 if (r_symndx
< extsymoff
)
2804 if (elf_bad_symtab (input_bfd
) && local_sections
[r_symndx
] != NULL
)
2809 /* Look up the hash table to check whether the symbol
2810 was forced local. */
2811 h
= (struct mips_elf_link_hash_entry
*)
2812 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
];
2813 /* Find the real hash-table entry for this symbol. */
2814 while (h
->root
.root
.type
== bfd_link_hash_indirect
2815 || h
->root
.root
.type
== bfd_link_hash_warning
)
2816 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2817 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0)
2824 /* Sign-extend VALUE, which has the indicated number of BITS. */
2827 _bfd_mips_elf_sign_extend (bfd_vma value
, int bits
)
2829 if (value
& ((bfd_vma
) 1 << (bits
- 1)))
2830 /* VALUE is negative. */
2831 value
|= ((bfd_vma
) - 1) << bits
;
2836 /* Return non-zero if the indicated VALUE has overflowed the maximum
2837 range expressible by a signed number with the indicated number of
2841 mips_elf_overflow_p (bfd_vma value
, int bits
)
2843 bfd_signed_vma svalue
= (bfd_signed_vma
) value
;
2845 if (svalue
> (1 << (bits
- 1)) - 1)
2846 /* The value is too big. */
2848 else if (svalue
< -(1 << (bits
- 1)))
2849 /* The value is too small. */
2856 /* Calculate the %high function. */
2859 mips_elf_high (bfd_vma value
)
2861 return ((value
+ (bfd_vma
) 0x8000) >> 16) & 0xffff;
2864 /* Calculate the %higher function. */
2867 mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED
)
2870 return ((value
+ (bfd_vma
) 0x80008000) >> 32) & 0xffff;
2873 return (bfd_vma
) -1;
2877 /* Calculate the %highest function. */
2880 mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED
)
2883 return ((value
+ (((bfd_vma
) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
2886 return (bfd_vma
) -1;
2890 /* Create the .compact_rel section. */
2893 mips_elf_create_compact_rel_section
2894 (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2897 register asection
*s
;
2899 if (bfd_get_section_by_name (abfd
, ".compact_rel") == NULL
)
2901 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
2904 s
= bfd_make_section (abfd
, ".compact_rel");
2906 || ! bfd_set_section_flags (abfd
, s
, flags
)
2907 || ! bfd_set_section_alignment (abfd
, s
,
2908 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
2911 s
->_raw_size
= sizeof (Elf32_External_compact_rel
);
2917 /* Create the .got section to hold the global offset table. */
2920 mips_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
,
2921 bfd_boolean maybe_exclude
)
2924 register asection
*s
;
2925 struct elf_link_hash_entry
*h
;
2926 struct bfd_link_hash_entry
*bh
;
2927 struct mips_got_info
*g
;
2930 /* This function may be called more than once. */
2931 s
= mips_elf_got_section (abfd
, TRUE
);
2934 if (! maybe_exclude
)
2935 s
->flags
&= ~SEC_EXCLUDE
;
2939 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2940 | SEC_LINKER_CREATED
);
2943 flags
|= SEC_EXCLUDE
;
2945 /* We have to use an alignment of 2**4 here because this is hardcoded
2946 in the function stub generation and in the linker script. */
2947 s
= bfd_make_section (abfd
, ".got");
2949 || ! bfd_set_section_flags (abfd
, s
, flags
)
2950 || ! bfd_set_section_alignment (abfd
, s
, 4))
2953 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
2954 linker script because we don't want to define the symbol if we
2955 are not creating a global offset table. */
2957 if (! (_bfd_generic_link_add_one_symbol
2958 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
2959 0, NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
2962 h
= (struct elf_link_hash_entry
*) bh
;
2963 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
2964 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2965 h
->type
= STT_OBJECT
;
2968 && ! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2971 amt
= sizeof (struct mips_got_info
);
2972 g
= bfd_alloc (abfd
, amt
);
2975 g
->global_gotsym
= NULL
;
2976 g
->global_gotno
= 0;
2977 g
->local_gotno
= MIPS_RESERVED_GOTNO
;
2978 g
->assigned_gotno
= MIPS_RESERVED_GOTNO
;
2981 g
->got_entries
= htab_try_create (1, mips_elf_got_entry_hash
,
2982 mips_elf_got_entry_eq
, NULL
);
2983 if (g
->got_entries
== NULL
)
2985 mips_elf_section_data (s
)->u
.got_info
= g
;
2986 mips_elf_section_data (s
)->elf
.this_hdr
.sh_flags
2987 |= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
2992 /* Calculate the value produced by the RELOCATION (which comes from
2993 the INPUT_BFD). The ADDEND is the addend to use for this
2994 RELOCATION; RELOCATION->R_ADDEND is ignored.
2996 The result of the relocation calculation is stored in VALUEP.
2997 REQUIRE_JALXP indicates whether or not the opcode used with this
2998 relocation must be JALX.
3000 This function returns bfd_reloc_continue if the caller need take no
3001 further action regarding this relocation, bfd_reloc_notsupported if
3002 something goes dramatically wrong, bfd_reloc_overflow if an
3003 overflow occurs, and bfd_reloc_ok to indicate success. */
3005 static bfd_reloc_status_type
3006 mips_elf_calculate_relocation (bfd
*abfd
, bfd
*input_bfd
,
3007 asection
*input_section
,
3008 struct bfd_link_info
*info
,
3009 const Elf_Internal_Rela
*relocation
,
3010 bfd_vma addend
, reloc_howto_type
*howto
,
3011 Elf_Internal_Sym
*local_syms
,
3012 asection
**local_sections
, bfd_vma
*valuep
,
3013 const char **namep
, bfd_boolean
*require_jalxp
,
3014 bfd_boolean save_addend
)
3016 /* The eventual value we will return. */
3018 /* The address of the symbol against which the relocation is
3021 /* The final GP value to be used for the relocatable, executable, or
3022 shared object file being produced. */
3023 bfd_vma gp
= MINUS_ONE
;
3024 /* The place (section offset or address) of the storage unit being
3027 /* The value of GP used to create the relocatable object. */
3028 bfd_vma gp0
= MINUS_ONE
;
3029 /* The offset into the global offset table at which the address of
3030 the relocation entry symbol, adjusted by the addend, resides
3031 during execution. */
3032 bfd_vma g
= MINUS_ONE
;
3033 /* The section in which the symbol referenced by the relocation is
3035 asection
*sec
= NULL
;
3036 struct mips_elf_link_hash_entry
*h
= NULL
;
3037 /* TRUE if the symbol referred to by this relocation is a local
3039 bfd_boolean local_p
, was_local_p
;
3040 /* TRUE if the symbol referred to by this relocation is "_gp_disp". */
3041 bfd_boolean gp_disp_p
= FALSE
;
3042 Elf_Internal_Shdr
*symtab_hdr
;
3044 unsigned long r_symndx
;
3046 /* TRUE if overflow occurred during the calculation of the
3047 relocation value. */
3048 bfd_boolean overflowed_p
;
3049 /* TRUE if this relocation refers to a MIPS16 function. */
3050 bfd_boolean target_is_16_bit_code_p
= FALSE
;
3052 /* Parse the relocation. */
3053 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
3054 r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
3055 p
= (input_section
->output_section
->vma
3056 + input_section
->output_offset
3057 + relocation
->r_offset
);
3059 /* Assume that there will be no overflow. */
3060 overflowed_p
= FALSE
;
3062 /* Figure out whether or not the symbol is local, and get the offset
3063 used in the array of hash table entries. */
3064 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3065 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
3066 local_sections
, FALSE
);
3067 was_local_p
= local_p
;
3068 if (! elf_bad_symtab (input_bfd
))
3069 extsymoff
= symtab_hdr
->sh_info
;
3072 /* The symbol table does not follow the rule that local symbols
3073 must come before globals. */
3077 /* Figure out the value of the symbol. */
3080 Elf_Internal_Sym
*sym
;
3082 sym
= local_syms
+ r_symndx
;
3083 sec
= local_sections
[r_symndx
];
3085 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3086 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
3087 || (sec
->flags
& SEC_MERGE
))
3088 symbol
+= sym
->st_value
;
3089 if ((sec
->flags
& SEC_MERGE
)
3090 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3092 addend
= _bfd_elf_rel_local_sym (abfd
, sym
, &sec
, addend
);
3094 addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
3097 /* MIPS16 text labels should be treated as odd. */
3098 if (sym
->st_other
== STO_MIPS16
)
3101 /* Record the name of this symbol, for our caller. */
3102 *namep
= bfd_elf_string_from_elf_section (input_bfd
,
3103 symtab_hdr
->sh_link
,
3106 *namep
= bfd_section_name (input_bfd
, sec
);
3108 target_is_16_bit_code_p
= (sym
->st_other
== STO_MIPS16
);
3112 /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ? */
3114 /* For global symbols we look up the symbol in the hash-table. */
3115 h
= ((struct mips_elf_link_hash_entry
*)
3116 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
]);
3117 /* Find the real hash-table entry for this symbol. */
3118 while (h
->root
.root
.type
== bfd_link_hash_indirect
3119 || h
->root
.root
.type
== bfd_link_hash_warning
)
3120 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3122 /* Record the name of this symbol, for our caller. */
3123 *namep
= h
->root
.root
.root
.string
;
3125 /* See if this is the special _gp_disp symbol. Note that such a
3126 symbol must always be a global symbol. */
3127 if (strcmp (*namep
, "_gp_disp") == 0
3128 && ! NEWABI_P (input_bfd
))
3130 /* Relocations against _gp_disp are permitted only with
3131 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
3132 if (r_type
!= R_MIPS_HI16
&& r_type
!= R_MIPS_LO16
)
3133 return bfd_reloc_notsupported
;
3137 /* If this symbol is defined, calculate its address. Note that
3138 _gp_disp is a magic symbol, always implicitly defined by the
3139 linker, so it's inappropriate to check to see whether or not
3141 else if ((h
->root
.root
.type
== bfd_link_hash_defined
3142 || h
->root
.root
.type
== bfd_link_hash_defweak
)
3143 && h
->root
.root
.u
.def
.section
)
3145 sec
= h
->root
.root
.u
.def
.section
;
3146 if (sec
->output_section
)
3147 symbol
= (h
->root
.root
.u
.def
.value
3148 + sec
->output_section
->vma
3149 + sec
->output_offset
);
3151 symbol
= h
->root
.root
.u
.def
.value
;
3153 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
3154 /* We allow relocations against undefined weak symbols, giving
3155 it the value zero, so that you can undefined weak functions
3156 and check to see if they exist by looking at their
3159 else if (info
->shared
3160 && info
->unresolved_syms_in_objects
== RM_IGNORE
3161 && ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
3163 else if (strcmp (*namep
, "_DYNAMIC_LINK") == 0 ||
3164 strcmp (*namep
, "_DYNAMIC_LINKING") == 0)
3166 /* If this is a dynamic link, we should have created a
3167 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
3168 in in _bfd_mips_elf_create_dynamic_sections.
3169 Otherwise, we should define the symbol with a value of 0.
3170 FIXME: It should probably get into the symbol table
3172 BFD_ASSERT (! info
->shared
);
3173 BFD_ASSERT (bfd_get_section_by_name (abfd
, ".dynamic") == NULL
);
3178 if (! ((*info
->callbacks
->undefined_symbol
)
3179 (info
, h
->root
.root
.root
.string
, input_bfd
,
3180 input_section
, relocation
->r_offset
,
3181 ((info
->shared
&& info
->unresolved_syms_in_shared_libs
== RM_GENERATE_ERROR
)
3182 || (!info
->shared
&& info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
)
3183 || ELF_ST_VISIBILITY (h
->root
.other
)))))
3184 return bfd_reloc_undefined
;
3188 target_is_16_bit_code_p
= (h
->root
.other
== STO_MIPS16
);
3191 /* If this is a 32- or 64-bit call to a 16-bit function with a stub, we
3192 need to redirect the call to the stub, unless we're already *in*
3194 if (r_type
!= R_MIPS16_26
&& !info
->relocatable
3195 && ((h
!= NULL
&& h
->fn_stub
!= NULL
)
3196 || (local_p
&& elf_tdata (input_bfd
)->local_stubs
!= NULL
3197 && elf_tdata (input_bfd
)->local_stubs
[r_symndx
] != NULL
))
3198 && !mips_elf_stub_section_p (input_bfd
, input_section
))
3200 /* This is a 32- or 64-bit call to a 16-bit function. We should
3201 have already noticed that we were going to need the
3204 sec
= elf_tdata (input_bfd
)->local_stubs
[r_symndx
];
3207 BFD_ASSERT (h
->need_fn_stub
);
3211 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3213 /* If this is a 16-bit call to a 32- or 64-bit function with a stub, we
3214 need to redirect the call to the stub. */
3215 else if (r_type
== R_MIPS16_26
&& !info
->relocatable
3217 && (h
->call_stub
!= NULL
|| h
->call_fp_stub
!= NULL
)
3218 && !target_is_16_bit_code_p
)
3220 /* If both call_stub and call_fp_stub are defined, we can figure
3221 out which one to use by seeing which one appears in the input
3223 if (h
->call_stub
!= NULL
&& h
->call_fp_stub
!= NULL
)
3228 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
3230 if (strncmp (bfd_get_section_name (input_bfd
, o
),
3231 CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
3233 sec
= h
->call_fp_stub
;
3240 else if (h
->call_stub
!= NULL
)
3243 sec
= h
->call_fp_stub
;
3245 BFD_ASSERT (sec
->_raw_size
> 0);
3246 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3249 /* Calls from 16-bit code to 32-bit code and vice versa require the
3250 special jalx instruction. */
3251 *require_jalxp
= (!info
->relocatable
3252 && (((r_type
== R_MIPS16_26
) && !target_is_16_bit_code_p
)
3253 || ((r_type
== R_MIPS_26
) && target_is_16_bit_code_p
)));
3255 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
3256 local_sections
, TRUE
);
3258 /* If we haven't already determined the GOT offset, or the GP value,
3259 and we're going to need it, get it now. */
3262 case R_MIPS_GOT_PAGE
:
3263 case R_MIPS_GOT_OFST
:
3264 /* We need to decay to GOT_DISP/addend if the symbol doesn't
3266 local_p
= local_p
|| _bfd_elf_symbol_refs_local_p (&h
->root
, info
, 1);
3267 if (local_p
|| r_type
== R_MIPS_GOT_OFST
)
3273 case R_MIPS_GOT_DISP
:
3274 case R_MIPS_GOT_HI16
:
3275 case R_MIPS_CALL_HI16
:
3276 case R_MIPS_GOT_LO16
:
3277 case R_MIPS_CALL_LO16
:
3278 /* Find the index into the GOT where this value is located. */
3281 /* GOT_PAGE may take a non-zero addend, that is ignored in a
3282 GOT_PAGE relocation that decays to GOT_DISP because the
3283 symbol turns out to be global. The addend is then added
3285 BFD_ASSERT (addend
== 0 || r_type
== R_MIPS_GOT_PAGE
);
3286 g
= mips_elf_global_got_index (elf_hash_table (info
)->dynobj
,
3288 (struct elf_link_hash_entry
*) h
);
3289 if (! elf_hash_table(info
)->dynamic_sections_created
3291 && (info
->symbolic
|| h
->root
.dynindx
== -1)
3292 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
3294 /* This is a static link or a -Bsymbolic link. The
3295 symbol is defined locally, or was forced to be local.
3296 We must initialize this entry in the GOT. */
3297 bfd
*tmpbfd
= elf_hash_table (info
)->dynobj
;
3298 asection
*sgot
= mips_elf_got_section (tmpbfd
, FALSE
);
3299 MIPS_ELF_PUT_WORD (tmpbfd
, symbol
, sgot
->contents
+ g
);
3302 else if (r_type
== R_MIPS_GOT16
|| r_type
== R_MIPS_CALL16
)
3303 /* There's no need to create a local GOT entry here; the
3304 calculation for a local GOT16 entry does not involve G. */
3308 g
= mips_elf_local_got_index (abfd
, input_bfd
,
3309 info
, symbol
+ addend
);
3311 return bfd_reloc_outofrange
;
3314 /* Convert GOT indices to actual offsets. */
3315 g
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3316 abfd
, input_bfd
, g
);
3321 case R_MIPS16_GPREL
:
3322 case R_MIPS_GPREL16
:
3323 case R_MIPS_GPREL32
:
3324 case R_MIPS_LITERAL
:
3325 gp0
= _bfd_get_gp_value (input_bfd
);
3326 gp
= _bfd_get_gp_value (abfd
);
3327 if (elf_hash_table (info
)->dynobj
)
3328 gp
+= mips_elf_adjust_gp (abfd
,
3330 (elf_hash_table (info
)->dynobj
, NULL
),
3338 /* Figure out what kind of relocation is being performed. */
3342 return bfd_reloc_continue
;
3345 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 16);
3346 overflowed_p
= mips_elf_overflow_p (value
, 16);
3353 || (elf_hash_table (info
)->dynamic_sections_created
3355 && ((h
->root
.elf_link_hash_flags
3356 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0)
3357 && ((h
->root
.elf_link_hash_flags
3358 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
3360 && (input_section
->flags
& SEC_ALLOC
) != 0)
3362 /* If we're creating a shared library, or this relocation is
3363 against a symbol in a shared library, then we can't know
3364 where the symbol will end up. So, we create a relocation
3365 record in the output, and leave the job up to the dynamic
3368 if (!mips_elf_create_dynamic_relocation (abfd
,
3376 return bfd_reloc_undefined
;
3380 if (r_type
!= R_MIPS_REL32
)
3381 value
= symbol
+ addend
;
3385 value
&= howto
->dst_mask
;
3390 case R_MIPS_GNU_REL_LO16
:
3391 value
= symbol
+ addend
- p
;
3392 value
&= howto
->dst_mask
;
3395 case R_MIPS_GNU_REL16_S2
:
3396 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 18) - p
;
3397 overflowed_p
= mips_elf_overflow_p (value
, 18);
3398 value
= (value
>> 2) & howto
->dst_mask
;
3401 case R_MIPS_GNU_REL_HI16
:
3402 /* Instead of subtracting 'p' here, we should be subtracting the
3403 equivalent value for the LO part of the reloc, since the value
3404 here is relative to that address. Because that's not easy to do,
3405 we adjust 'addend' in _bfd_mips_elf_relocate_section(). See also
3406 the comment there for more information. */
3407 value
= mips_elf_high (addend
+ symbol
- p
);
3408 value
&= howto
->dst_mask
;
3412 /* The calculation for R_MIPS16_26 is just the same as for an
3413 R_MIPS_26. It's only the storage of the relocated field into
3414 the output file that's different. That's handled in
3415 mips_elf_perform_relocation. So, we just fall through to the
3416 R_MIPS_26 case here. */
3419 value
= ((addend
| ((p
+ 4) & 0xf0000000)) + symbol
) >> 2;
3421 value
= (_bfd_mips_elf_sign_extend (addend
, 28) + symbol
) >> 2;
3422 value
&= howto
->dst_mask
;
3428 value
= mips_elf_high (addend
+ symbol
);
3429 value
&= howto
->dst_mask
;
3433 value
= mips_elf_high (addend
+ gp
- p
);
3434 overflowed_p
= mips_elf_overflow_p (value
, 16);
3440 value
= (symbol
+ addend
) & howto
->dst_mask
;
3443 value
= addend
+ gp
- p
+ 4;
3444 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
3445 for overflow. But, on, say, IRIX5, relocations against
3446 _gp_disp are normally generated from the .cpload
3447 pseudo-op. It generates code that normally looks like
3450 lui $gp,%hi(_gp_disp)
3451 addiu $gp,$gp,%lo(_gp_disp)
3454 Here $t9 holds the address of the function being called,
3455 as required by the MIPS ELF ABI. The R_MIPS_LO16
3456 relocation can easily overflow in this situation, but the
3457 R_MIPS_HI16 relocation will handle the overflow.
3458 Therefore, we consider this a bug in the MIPS ABI, and do
3459 not check for overflow here. */
3463 case R_MIPS_LITERAL
:
3464 /* Because we don't merge literal sections, we can handle this
3465 just like R_MIPS_GPREL16. In the long run, we should merge
3466 shared literals, and then we will need to additional work
3471 case R_MIPS16_GPREL
:
3472 /* The R_MIPS16_GPREL performs the same calculation as
3473 R_MIPS_GPREL16, but stores the relocated bits in a different
3474 order. We don't need to do anything special here; the
3475 differences are handled in mips_elf_perform_relocation. */
3476 case R_MIPS_GPREL16
:
3477 /* Only sign-extend the addend if it was extracted from the
3478 instruction. If the addend was separate, leave it alone,
3479 otherwise we may lose significant bits. */
3480 if (howto
->partial_inplace
)
3481 addend
= _bfd_mips_elf_sign_extend (addend
, 16);
3482 value
= symbol
+ addend
- gp
;
3483 /* If the symbol was local, any earlier relocatable links will
3484 have adjusted its addend with the gp offset, so compensate
3485 for that now. Don't do it for symbols forced local in this
3486 link, though, since they won't have had the gp offset applied
3490 overflowed_p
= mips_elf_overflow_p (value
, 16);
3499 /* The special case is when the symbol is forced to be local. We
3500 need the full address in the GOT since no R_MIPS_LO16 relocation
3502 forced
= ! mips_elf_local_relocation_p (input_bfd
, relocation
,
3503 local_sections
, FALSE
);
3504 value
= mips_elf_got16_entry (abfd
, input_bfd
, info
,
3505 symbol
+ addend
, forced
);
3506 if (value
== MINUS_ONE
)
3507 return bfd_reloc_outofrange
;
3509 = mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3510 abfd
, input_bfd
, value
);
3511 overflowed_p
= mips_elf_overflow_p (value
, 16);
3517 case R_MIPS_GOT_DISP
:
3520 overflowed_p
= mips_elf_overflow_p (value
, 16);
3523 case R_MIPS_GPREL32
:
3524 value
= (addend
+ symbol
+ gp0
- gp
);
3526 value
&= howto
->dst_mask
;
3530 value
= _bfd_mips_elf_sign_extend (addend
, 16) + symbol
- p
;
3531 overflowed_p
= mips_elf_overflow_p (value
, 16);
3534 case R_MIPS_GOT_HI16
:
3535 case R_MIPS_CALL_HI16
:
3536 /* We're allowed to handle these two relocations identically.
3537 The dynamic linker is allowed to handle the CALL relocations
3538 differently by creating a lazy evaluation stub. */
3540 value
= mips_elf_high (value
);
3541 value
&= howto
->dst_mask
;
3544 case R_MIPS_GOT_LO16
:
3545 case R_MIPS_CALL_LO16
:
3546 value
= g
& howto
->dst_mask
;
3549 case R_MIPS_GOT_PAGE
:
3550 /* GOT_PAGE relocations that reference non-local symbols decay
3551 to GOT_DISP. The corresponding GOT_OFST relocation decays to
3555 value
= mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, NULL
);
3556 if (value
== MINUS_ONE
)
3557 return bfd_reloc_outofrange
;
3558 value
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3559 abfd
, input_bfd
, value
);
3560 overflowed_p
= mips_elf_overflow_p (value
, 16);
3563 case R_MIPS_GOT_OFST
:
3565 mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, &value
);
3568 overflowed_p
= mips_elf_overflow_p (value
, 16);
3572 value
= symbol
- addend
;
3573 value
&= howto
->dst_mask
;
3577 value
= mips_elf_higher (addend
+ symbol
);
3578 value
&= howto
->dst_mask
;
3581 case R_MIPS_HIGHEST
:
3582 value
= mips_elf_highest (addend
+ symbol
);
3583 value
&= howto
->dst_mask
;
3586 case R_MIPS_SCN_DISP
:
3587 value
= symbol
+ addend
- sec
->output_offset
;
3588 value
&= howto
->dst_mask
;
3593 /* Both of these may be ignored. R_MIPS_JALR is an optimization
3594 hint; we could improve performance by honoring that hint. */
3595 return bfd_reloc_continue
;
3597 case R_MIPS_GNU_VTINHERIT
:
3598 case R_MIPS_GNU_VTENTRY
:
3599 /* We don't do anything with these at present. */
3600 return bfd_reloc_continue
;
3603 /* An unrecognized relocation type. */
3604 return bfd_reloc_notsupported
;
3607 /* Store the VALUE for our caller. */
3609 return overflowed_p
? bfd_reloc_overflow
: bfd_reloc_ok
;
3612 /* Obtain the field relocated by RELOCATION. */
3615 mips_elf_obtain_contents (reloc_howto_type
*howto
,
3616 const Elf_Internal_Rela
*relocation
,
3617 bfd
*input_bfd
, bfd_byte
*contents
)
3620 bfd_byte
*location
= contents
+ relocation
->r_offset
;
3622 /* Obtain the bytes. */
3623 x
= bfd_get ((8 * bfd_get_reloc_size (howto
)), input_bfd
, location
);
3625 if ((ELF_R_TYPE (input_bfd
, relocation
->r_info
) == R_MIPS16_26
3626 || ELF_R_TYPE (input_bfd
, relocation
->r_info
) == R_MIPS16_GPREL
)
3627 && bfd_little_endian (input_bfd
))
3628 /* The two 16-bit words will be reversed on a little-endian system.
3629 See mips_elf_perform_relocation for more details. */
3630 x
= (((x
& 0xffff) << 16) | ((x
& 0xffff0000) >> 16));
3635 /* It has been determined that the result of the RELOCATION is the
3636 VALUE. Use HOWTO to place VALUE into the output file at the
3637 appropriate position. The SECTION is the section to which the
3638 relocation applies. If REQUIRE_JALX is TRUE, then the opcode used
3639 for the relocation must be either JAL or JALX, and it is
3640 unconditionally converted to JALX.
3642 Returns FALSE if anything goes wrong. */
3645 mips_elf_perform_relocation (struct bfd_link_info
*info
,
3646 reloc_howto_type
*howto
,
3647 const Elf_Internal_Rela
*relocation
,
3648 bfd_vma value
, bfd
*input_bfd
,
3649 asection
*input_section
, bfd_byte
*contents
,
3650 bfd_boolean require_jalx
)
3654 int r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
3656 /* Figure out where the relocation is occurring. */
3657 location
= contents
+ relocation
->r_offset
;
3659 /* Obtain the current value. */
3660 x
= mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
);
3662 /* Clear the field we are setting. */
3663 x
&= ~howto
->dst_mask
;
3665 /* If this is the R_MIPS16_26 relocation, we must store the
3666 value in a funny way. */
3667 if (r_type
== R_MIPS16_26
)
3669 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
3670 Most mips16 instructions are 16 bits, but these instructions
3673 The format of these instructions is:
3675 +--------------+--------------------------------+
3676 ! JALX ! X! Imm 20:16 ! Imm 25:21 !
3677 +--------------+--------------------------------+
3679 +-----------------------------------------------+
3681 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
3682 Note that the immediate value in the first word is swapped.
3684 When producing a relocatable object file, R_MIPS16_26 is
3685 handled mostly like R_MIPS_26. In particular, the addend is
3686 stored as a straight 26-bit value in a 32-bit instruction.
3687 (gas makes life simpler for itself by never adjusting a
3688 R_MIPS16_26 reloc to be against a section, so the addend is
3689 always zero). However, the 32 bit instruction is stored as 2
3690 16-bit values, rather than a single 32-bit value. In a
3691 big-endian file, the result is the same; in a little-endian
3692 file, the two 16-bit halves of the 32 bit value are swapped.
3693 This is so that a disassembler can recognize the jal
3696 When doing a final link, R_MIPS16_26 is treated as a 32 bit
3697 instruction stored as two 16-bit values. The addend A is the
3698 contents of the targ26 field. The calculation is the same as
3699 R_MIPS_26. When storing the calculated value, reorder the
3700 immediate value as shown above, and don't forget to store the
3701 value as two 16-bit values.
3703 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
3707 +--------+----------------------+
3711 +--------+----------------------+
3714 +----------+------+-------------+
3718 +----------+--------------------+
3719 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
3720 ((sub1 << 16) | sub2)).
3722 When producing a relocatable object file, the calculation is
3723 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
3724 When producing a fully linked file, the calculation is
3725 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
3726 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff) */
3728 if (!info
->relocatable
)
3729 /* Shuffle the bits according to the formula above. */
3730 value
= (((value
& 0x1f0000) << 5)
3731 | ((value
& 0x3e00000) >> 5)
3732 | (value
& 0xffff));
3734 else if (r_type
== R_MIPS16_GPREL
)
3736 /* R_MIPS16_GPREL is used for GP-relative addressing in mips16
3737 mode. A typical instruction will have a format like this:
3739 +--------------+--------------------------------+
3740 ! EXTEND ! Imm 10:5 ! Imm 15:11 !
3741 +--------------+--------------------------------+
3742 ! Major ! rx ! ry ! Imm 4:0 !
3743 +--------------+--------------------------------+
3745 EXTEND is the five bit value 11110. Major is the instruction
3748 This is handled exactly like R_MIPS_GPREL16, except that the
3749 addend is retrieved and stored as shown in this diagram; that
3750 is, the Imm fields above replace the V-rel16 field.
3752 All we need to do here is shuffle the bits appropriately. As
3753 above, the two 16-bit halves must be swapped on a
3754 little-endian system. */
3755 value
= (((value
& 0x7e0) << 16)
3756 | ((value
& 0xf800) << 5)
3760 /* Set the field. */
3761 x
|= (value
& howto
->dst_mask
);
3763 /* If required, turn JAL into JALX. */
3767 bfd_vma opcode
= x
>> 26;
3768 bfd_vma jalx_opcode
;
3770 /* Check to see if the opcode is already JAL or JALX. */
3771 if (r_type
== R_MIPS16_26
)
3773 ok
= ((opcode
== 0x6) || (opcode
== 0x7));
3778 ok
= ((opcode
== 0x3) || (opcode
== 0x1d));
3782 /* If the opcode is not JAL or JALX, there's a problem. */
3785 (*_bfd_error_handler
)
3786 (_("%s: %s+0x%lx: jump to stub routine which is not jal"),
3787 bfd_archive_filename (input_bfd
),
3788 input_section
->name
,
3789 (unsigned long) relocation
->r_offset
);
3790 bfd_set_error (bfd_error_bad_value
);
3794 /* Make this the JALX opcode. */
3795 x
= (x
& ~(0x3f << 26)) | (jalx_opcode
<< 26);
3798 /* Swap the high- and low-order 16 bits on little-endian systems
3799 when doing a MIPS16 relocation. */
3800 if ((r_type
== R_MIPS16_GPREL
|| r_type
== R_MIPS16_26
)
3801 && bfd_little_endian (input_bfd
))
3802 x
= (((x
& 0xffff) << 16) | ((x
& 0xffff0000) >> 16));
3804 /* Put the value into the output. */
3805 bfd_put (8 * bfd_get_reloc_size (howto
), input_bfd
, x
, location
);
3809 /* Returns TRUE if SECTION is a MIPS16 stub section. */
3812 mips_elf_stub_section_p (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*section
)
3814 const char *name
= bfd_get_section_name (abfd
, section
);
3816 return (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0
3817 || strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
3818 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0);
3821 /* Add room for N relocations to the .rel.dyn section in ABFD. */
3824 mips_elf_allocate_dynamic_relocations (bfd
*abfd
, unsigned int n
)
3828 s
= mips_elf_rel_dyn_section (abfd
, FALSE
);
3829 BFD_ASSERT (s
!= NULL
);
3831 if (s
->_raw_size
== 0)
3833 /* Make room for a null element. */
3834 s
->_raw_size
+= MIPS_ELF_REL_SIZE (abfd
);
3837 s
->_raw_size
+= n
* MIPS_ELF_REL_SIZE (abfd
);
3840 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
3841 is the original relocation, which is now being transformed into a
3842 dynamic relocation. The ADDENDP is adjusted if necessary; the
3843 caller should store the result in place of the original addend. */
3846 mips_elf_create_dynamic_relocation (bfd
*output_bfd
,
3847 struct bfd_link_info
*info
,
3848 const Elf_Internal_Rela
*rel
,
3849 struct mips_elf_link_hash_entry
*h
,
3850 asection
*sec
, bfd_vma symbol
,
3851 bfd_vma
*addendp
, asection
*input_section
)
3853 Elf_Internal_Rela outrel
[3];
3859 r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
3860 dynobj
= elf_hash_table (info
)->dynobj
;
3861 sreloc
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
3862 BFD_ASSERT (sreloc
!= NULL
);
3863 BFD_ASSERT (sreloc
->contents
!= NULL
);
3864 BFD_ASSERT (sreloc
->reloc_count
* MIPS_ELF_REL_SIZE (output_bfd
)
3865 < sreloc
->_raw_size
);
3868 outrel
[0].r_offset
=
3869 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[0].r_offset
);
3870 outrel
[1].r_offset
=
3871 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[1].r_offset
);
3872 outrel
[2].r_offset
=
3873 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[2].r_offset
);
3876 /* We begin by assuming that the offset for the dynamic relocation
3877 is the same as for the original relocation. We'll adjust this
3878 later to reflect the correct output offsets. */
3879 if (input_section
->sec_info_type
!= ELF_INFO_TYPE_STABS
)
3881 outrel
[1].r_offset
= rel
[1].r_offset
;
3882 outrel
[2].r_offset
= rel
[2].r_offset
;
3886 /* Except that in a stab section things are more complex.
3887 Because we compress stab information, the offset given in the
3888 relocation may not be the one we want; we must let the stabs
3889 machinery tell us the offset. */
3890 outrel
[1].r_offset
= outrel
[0].r_offset
;
3891 outrel
[2].r_offset
= outrel
[0].r_offset
;
3892 /* If we didn't need the relocation at all, this value will be
3894 if (outrel
[0].r_offset
== (bfd_vma
) -1)
3899 if (outrel
[0].r_offset
== (bfd_vma
) -1)
3900 /* The relocation field has been deleted. */
3902 else if (outrel
[0].r_offset
== (bfd_vma
) -2)
3904 /* The relocation field has been converted into a relative value of
3905 some sort. Functions like _bfd_elf_write_section_eh_frame expect
3906 the field to be fully relocated, so add in the symbol's value. */
3911 /* If we've decided to skip this relocation, just output an empty
3912 record. Note that R_MIPS_NONE == 0, so that this call to memset
3913 is a way of setting R_TYPE to R_MIPS_NONE. */
3915 memset (outrel
, 0, sizeof (Elf_Internal_Rela
) * 3);
3919 bfd_boolean defined_p
;
3921 /* We must now calculate the dynamic symbol table index to use
3922 in the relocation. */
3924 && (! info
->symbolic
|| (h
->root
.elf_link_hash_flags
3925 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
3926 /* h->root.dynindx may be -1 if this symbol was marked to
3928 && h
->root
.dynindx
!= -1)
3930 indx
= h
->root
.dynindx
;
3931 if (SGI_COMPAT (output_bfd
))
3932 defined_p
= ((h
->root
.elf_link_hash_flags
3933 & ELF_LINK_HASH_DEF_REGULAR
) != 0);
3935 /* ??? glibc's ld.so just adds the final GOT entry to the
3936 relocation field. It therefore treats relocs against
3937 defined symbols in the same way as relocs against
3938 undefined symbols. */
3943 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
3945 else if (sec
== NULL
|| sec
->owner
== NULL
)
3947 bfd_set_error (bfd_error_bad_value
);
3952 indx
= elf_section_data (sec
->output_section
)->dynindx
;
3957 /* Instead of generating a relocation using the section
3958 symbol, we may as well make it a fully relative
3959 relocation. We want to avoid generating relocations to
3960 local symbols because we used to generate them
3961 incorrectly, without adding the original symbol value,
3962 which is mandated by the ABI for section symbols. In
3963 order to give dynamic loaders and applications time to
3964 phase out the incorrect use, we refrain from emitting
3965 section-relative relocations. It's not like they're
3966 useful, after all. This should be a bit more efficient
3968 /* ??? Although this behavior is compatible with glibc's ld.so,
3969 the ABI says that relocations against STN_UNDEF should have
3970 a symbol value of 0. Irix rld honors this, so relocations
3971 against STN_UNDEF have no effect. */
3972 if (!SGI_COMPAT (output_bfd
))
3977 /* If the relocation was previously an absolute relocation and
3978 this symbol will not be referred to by the relocation, we must
3979 adjust it by the value we give it in the dynamic symbol table.
3980 Otherwise leave the job up to the dynamic linker. */
3981 if (defined_p
&& r_type
!= R_MIPS_REL32
)
3984 /* The relocation is always an REL32 relocation because we don't
3985 know where the shared library will wind up at load-time. */
3986 outrel
[0].r_info
= ELF_R_INFO (output_bfd
, (unsigned long) indx
,
3988 /* For strict adherence to the ABI specification, we should
3989 generate a R_MIPS_64 relocation record by itself before the
3990 _REL32/_64 record as well, such that the addend is read in as
3991 a 64-bit value (REL32 is a 32-bit relocation, after all).
3992 However, since none of the existing ELF64 MIPS dynamic
3993 loaders seems to care, we don't waste space with these
3994 artificial relocations. If this turns out to not be true,
3995 mips_elf_allocate_dynamic_relocation() should be tweaked so
3996 as to make room for a pair of dynamic relocations per
3997 invocation if ABI_64_P, and here we should generate an
3998 additional relocation record with R_MIPS_64 by itself for a
3999 NULL symbol before this relocation record. */
4000 outrel
[1].r_info
= ELF_R_INFO (output_bfd
, 0,
4001 ABI_64_P (output_bfd
)
4004 outrel
[2].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_NONE
);
4006 /* Adjust the output offset of the relocation to reference the
4007 correct location in the output file. */
4008 outrel
[0].r_offset
+= (input_section
->output_section
->vma
4009 + input_section
->output_offset
);
4010 outrel
[1].r_offset
+= (input_section
->output_section
->vma
4011 + input_section
->output_offset
);
4012 outrel
[2].r_offset
+= (input_section
->output_section
->vma
4013 + input_section
->output_offset
);
4016 /* Put the relocation back out. We have to use the special
4017 relocation outputter in the 64-bit case since the 64-bit
4018 relocation format is non-standard. */
4019 if (ABI_64_P (output_bfd
))
4021 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
4022 (output_bfd
, &outrel
[0],
4024 + sreloc
->reloc_count
* sizeof (Elf64_Mips_External_Rel
)));
4027 bfd_elf32_swap_reloc_out
4028 (output_bfd
, &outrel
[0],
4029 (sreloc
->contents
+ sreloc
->reloc_count
* sizeof (Elf32_External_Rel
)));
4031 /* We've now added another relocation. */
4032 ++sreloc
->reloc_count
;
4034 /* Make sure the output section is writable. The dynamic linker
4035 will be writing to it. */
4036 elf_section_data (input_section
->output_section
)->this_hdr
.sh_flags
4039 /* On IRIX5, make an entry of compact relocation info. */
4040 if (! skip
&& IRIX_COMPAT (output_bfd
) == ict_irix5
)
4042 asection
*scpt
= bfd_get_section_by_name (dynobj
, ".compact_rel");
4047 Elf32_crinfo cptrel
;
4049 mips_elf_set_cr_format (cptrel
, CRF_MIPS_LONG
);
4050 cptrel
.vaddr
= (rel
->r_offset
4051 + input_section
->output_section
->vma
4052 + input_section
->output_offset
);
4053 if (r_type
== R_MIPS_REL32
)
4054 mips_elf_set_cr_type (cptrel
, CRT_MIPS_REL32
);
4056 mips_elf_set_cr_type (cptrel
, CRT_MIPS_WORD
);
4057 mips_elf_set_cr_dist2to (cptrel
, 0);
4058 cptrel
.konst
= *addendp
;
4060 cr
= (scpt
->contents
4061 + sizeof (Elf32_External_compact_rel
));
4062 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
4063 ((Elf32_External_crinfo
*) cr
4064 + scpt
->reloc_count
));
4065 ++scpt
->reloc_count
;
4072 /* Return the MACH for a MIPS e_flags value. */
4075 _bfd_elf_mips_mach (flagword flags
)
4077 switch (flags
& EF_MIPS_MACH
)
4079 case E_MIPS_MACH_3900
:
4080 return bfd_mach_mips3900
;
4082 case E_MIPS_MACH_4010
:
4083 return bfd_mach_mips4010
;
4085 case E_MIPS_MACH_4100
:
4086 return bfd_mach_mips4100
;
4088 case E_MIPS_MACH_4111
:
4089 return bfd_mach_mips4111
;
4091 case E_MIPS_MACH_4120
:
4092 return bfd_mach_mips4120
;
4094 case E_MIPS_MACH_4650
:
4095 return bfd_mach_mips4650
;
4097 case E_MIPS_MACH_5400
:
4098 return bfd_mach_mips5400
;
4100 case E_MIPS_MACH_5500
:
4101 return bfd_mach_mips5500
;
4103 case E_MIPS_MACH_SB1
:
4104 return bfd_mach_mips_sb1
;
4107 switch (flags
& EF_MIPS_ARCH
)
4111 return bfd_mach_mips3000
;
4115 return bfd_mach_mips6000
;
4119 return bfd_mach_mips4000
;
4123 return bfd_mach_mips8000
;
4127 return bfd_mach_mips5
;
4130 case E_MIPS_ARCH_32
:
4131 return bfd_mach_mipsisa32
;
4134 case E_MIPS_ARCH_64
:
4135 return bfd_mach_mipsisa64
;
4138 case E_MIPS_ARCH_32R2
:
4139 return bfd_mach_mipsisa32r2
;
4142 case E_MIPS_ARCH_64R2
:
4143 return bfd_mach_mipsisa64r2
;
4151 /* Return printable name for ABI. */
4153 static INLINE
char *
4154 elf_mips_abi_name (bfd
*abfd
)
4158 flags
= elf_elfheader (abfd
)->e_flags
;
4159 switch (flags
& EF_MIPS_ABI
)
4162 if (ABI_N32_P (abfd
))
4164 else if (ABI_64_P (abfd
))
4168 case E_MIPS_ABI_O32
:
4170 case E_MIPS_ABI_O64
:
4172 case E_MIPS_ABI_EABI32
:
4174 case E_MIPS_ABI_EABI64
:
4177 return "unknown abi";
4181 /* MIPS ELF uses two common sections. One is the usual one, and the
4182 other is for small objects. All the small objects are kept
4183 together, and then referenced via the gp pointer, which yields
4184 faster assembler code. This is what we use for the small common
4185 section. This approach is copied from ecoff.c. */
4186 static asection mips_elf_scom_section
;
4187 static asymbol mips_elf_scom_symbol
;
4188 static asymbol
*mips_elf_scom_symbol_ptr
;
4190 /* MIPS ELF also uses an acommon section, which represents an
4191 allocated common symbol which may be overridden by a
4192 definition in a shared library. */
4193 static asection mips_elf_acom_section
;
4194 static asymbol mips_elf_acom_symbol
;
4195 static asymbol
*mips_elf_acom_symbol_ptr
;
4197 /* Handle the special MIPS section numbers that a symbol may use.
4198 This is used for both the 32-bit and the 64-bit ABI. */
4201 _bfd_mips_elf_symbol_processing (bfd
*abfd
, asymbol
*asym
)
4203 elf_symbol_type
*elfsym
;
4205 elfsym
= (elf_symbol_type
*) asym
;
4206 switch (elfsym
->internal_elf_sym
.st_shndx
)
4208 case SHN_MIPS_ACOMMON
:
4209 /* This section is used in a dynamically linked executable file.
4210 It is an allocated common section. The dynamic linker can
4211 either resolve these symbols to something in a shared
4212 library, or it can just leave them here. For our purposes,
4213 we can consider these symbols to be in a new section. */
4214 if (mips_elf_acom_section
.name
== NULL
)
4216 /* Initialize the acommon section. */
4217 mips_elf_acom_section
.name
= ".acommon";
4218 mips_elf_acom_section
.flags
= SEC_ALLOC
;
4219 mips_elf_acom_section
.output_section
= &mips_elf_acom_section
;
4220 mips_elf_acom_section
.symbol
= &mips_elf_acom_symbol
;
4221 mips_elf_acom_section
.symbol_ptr_ptr
= &mips_elf_acom_symbol_ptr
;
4222 mips_elf_acom_symbol
.name
= ".acommon";
4223 mips_elf_acom_symbol
.flags
= BSF_SECTION_SYM
;
4224 mips_elf_acom_symbol
.section
= &mips_elf_acom_section
;
4225 mips_elf_acom_symbol_ptr
= &mips_elf_acom_symbol
;
4227 asym
->section
= &mips_elf_acom_section
;
4231 /* Common symbols less than the GP size are automatically
4232 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
4233 if (asym
->value
> elf_gp_size (abfd
)
4234 || IRIX_COMPAT (abfd
) == ict_irix6
)
4237 case SHN_MIPS_SCOMMON
:
4238 if (mips_elf_scom_section
.name
== NULL
)
4240 /* Initialize the small common section. */
4241 mips_elf_scom_section
.name
= ".scommon";
4242 mips_elf_scom_section
.flags
= SEC_IS_COMMON
;
4243 mips_elf_scom_section
.output_section
= &mips_elf_scom_section
;
4244 mips_elf_scom_section
.symbol
= &mips_elf_scom_symbol
;
4245 mips_elf_scom_section
.symbol_ptr_ptr
= &mips_elf_scom_symbol_ptr
;
4246 mips_elf_scom_symbol
.name
= ".scommon";
4247 mips_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
4248 mips_elf_scom_symbol
.section
= &mips_elf_scom_section
;
4249 mips_elf_scom_symbol_ptr
= &mips_elf_scom_symbol
;
4251 asym
->section
= &mips_elf_scom_section
;
4252 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
4255 case SHN_MIPS_SUNDEFINED
:
4256 asym
->section
= bfd_und_section_ptr
;
4259 #if 0 /* for SGI_COMPAT */
4261 asym
->section
= mips_elf_text_section_ptr
;
4265 asym
->section
= mips_elf_data_section_ptr
;
4271 /* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
4272 relocations against two unnamed section symbols to resolve to the
4273 same address. For example, if we have code like:
4275 lw $4,%got_disp(.data)($gp)
4276 lw $25,%got_disp(.text)($gp)
4279 then the linker will resolve both relocations to .data and the program
4280 will jump there rather than to .text.
4282 We can work around this problem by giving names to local section symbols.
4283 This is also what the MIPSpro tools do. */
4286 _bfd_mips_elf_name_local_section_symbols (bfd
*abfd
)
4288 return SGI_COMPAT (abfd
);
4291 /* Work over a section just before writing it out. This routine is
4292 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
4293 sections that need the SHF_MIPS_GPREL flag by name; there has to be
4297 _bfd_mips_elf_section_processing (bfd
*abfd
, Elf_Internal_Shdr
*hdr
)
4299 if (hdr
->sh_type
== SHT_MIPS_REGINFO
4300 && hdr
->sh_size
> 0)
4304 BFD_ASSERT (hdr
->sh_size
== sizeof (Elf32_External_RegInfo
));
4305 BFD_ASSERT (hdr
->contents
== NULL
);
4308 hdr
->sh_offset
+ sizeof (Elf32_External_RegInfo
) - 4,
4311 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
4312 if (bfd_bwrite (buf
, 4, abfd
) != 4)
4316 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
4317 && hdr
->bfd_section
!= NULL
4318 && mips_elf_section_data (hdr
->bfd_section
) != NULL
4319 && mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
!= NULL
)
4321 bfd_byte
*contents
, *l
, *lend
;
4323 /* We stored the section contents in the tdata field in the
4324 set_section_contents routine. We save the section contents
4325 so that we don't have to read them again.
4326 At this point we know that elf_gp is set, so we can look
4327 through the section contents to see if there is an
4328 ODK_REGINFO structure. */
4330 contents
= mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
;
4332 lend
= contents
+ hdr
->sh_size
;
4333 while (l
+ sizeof (Elf_External_Options
) <= lend
)
4335 Elf_Internal_Options intopt
;
4337 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
4339 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
4346 + sizeof (Elf_External_Options
)
4347 + (sizeof (Elf64_External_RegInfo
) - 8)),
4350 H_PUT_64 (abfd
, elf_gp (abfd
), buf
);
4351 if (bfd_bwrite (buf
, 8, abfd
) != 8)
4354 else if (intopt
.kind
== ODK_REGINFO
)
4361 + sizeof (Elf_External_Options
)
4362 + (sizeof (Elf32_External_RegInfo
) - 4)),
4365 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
4366 if (bfd_bwrite (buf
, 4, abfd
) != 4)
4373 if (hdr
->bfd_section
!= NULL
)
4375 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
4377 if (strcmp (name
, ".sdata") == 0
4378 || strcmp (name
, ".lit8") == 0
4379 || strcmp (name
, ".lit4") == 0)
4381 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
4382 hdr
->sh_type
= SHT_PROGBITS
;
4384 else if (strcmp (name
, ".sbss") == 0)
4386 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
4387 hdr
->sh_type
= SHT_NOBITS
;
4389 else if (strcmp (name
, ".srdata") == 0)
4391 hdr
->sh_flags
|= SHF_ALLOC
| SHF_MIPS_GPREL
;
4392 hdr
->sh_type
= SHT_PROGBITS
;
4394 else if (strcmp (name
, ".compact_rel") == 0)
4397 hdr
->sh_type
= SHT_PROGBITS
;
4399 else if (strcmp (name
, ".rtproc") == 0)
4401 if (hdr
->sh_addralign
!= 0 && hdr
->sh_entsize
== 0)
4403 unsigned int adjust
;
4405 adjust
= hdr
->sh_size
% hdr
->sh_addralign
;
4407 hdr
->sh_size
+= hdr
->sh_addralign
- adjust
;
4415 /* Handle a MIPS specific section when reading an object file. This
4416 is called when elfcode.h finds a section with an unknown type.
4417 This routine supports both the 32-bit and 64-bit ELF ABI.
4419 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
4423 _bfd_mips_elf_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
4428 /* There ought to be a place to keep ELF backend specific flags, but
4429 at the moment there isn't one. We just keep track of the
4430 sections by their name, instead. Fortunately, the ABI gives
4431 suggested names for all the MIPS specific sections, so we will
4432 probably get away with this. */
4433 switch (hdr
->sh_type
)
4435 case SHT_MIPS_LIBLIST
:
4436 if (strcmp (name
, ".liblist") != 0)
4440 if (strcmp (name
, ".msym") != 0)
4443 case SHT_MIPS_CONFLICT
:
4444 if (strcmp (name
, ".conflict") != 0)
4447 case SHT_MIPS_GPTAB
:
4448 if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) != 0)
4451 case SHT_MIPS_UCODE
:
4452 if (strcmp (name
, ".ucode") != 0)
4455 case SHT_MIPS_DEBUG
:
4456 if (strcmp (name
, ".mdebug") != 0)
4458 flags
= SEC_DEBUGGING
;
4460 case SHT_MIPS_REGINFO
:
4461 if (strcmp (name
, ".reginfo") != 0
4462 || hdr
->sh_size
!= sizeof (Elf32_External_RegInfo
))
4464 flags
= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_SIZE
);
4466 case SHT_MIPS_IFACE
:
4467 if (strcmp (name
, ".MIPS.interfaces") != 0)
4470 case SHT_MIPS_CONTENT
:
4471 if (strncmp (name
, ".MIPS.content", sizeof ".MIPS.content" - 1) != 0)
4474 case SHT_MIPS_OPTIONS
:
4475 if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) != 0)
4478 case SHT_MIPS_DWARF
:
4479 if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) != 0)
4482 case SHT_MIPS_SYMBOL_LIB
:
4483 if (strcmp (name
, ".MIPS.symlib") != 0)
4486 case SHT_MIPS_EVENTS
:
4487 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) != 0
4488 && strncmp (name
, ".MIPS.post_rel",
4489 sizeof ".MIPS.post_rel" - 1) != 0)
4496 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
4501 if (! bfd_set_section_flags (abfd
, hdr
->bfd_section
,
4502 (bfd_get_section_flags (abfd
,
4508 /* FIXME: We should record sh_info for a .gptab section. */
4510 /* For a .reginfo section, set the gp value in the tdata information
4511 from the contents of this section. We need the gp value while
4512 processing relocs, so we just get it now. The .reginfo section
4513 is not used in the 64-bit MIPS ELF ABI. */
4514 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
4516 Elf32_External_RegInfo ext
;
4519 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
,
4520 &ext
, 0, sizeof ext
))
4522 bfd_mips_elf32_swap_reginfo_in (abfd
, &ext
, &s
);
4523 elf_gp (abfd
) = s
.ri_gp_value
;
4526 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
4527 set the gp value based on what we find. We may see both
4528 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
4529 they should agree. */
4530 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
)
4532 bfd_byte
*contents
, *l
, *lend
;
4534 contents
= bfd_malloc (hdr
->sh_size
);
4535 if (contents
== NULL
)
4537 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
,
4544 lend
= contents
+ hdr
->sh_size
;
4545 while (l
+ sizeof (Elf_External_Options
) <= lend
)
4547 Elf_Internal_Options intopt
;
4549 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
4551 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
4553 Elf64_Internal_RegInfo intreg
;
4555 bfd_mips_elf64_swap_reginfo_in
4557 ((Elf64_External_RegInfo
*)
4558 (l
+ sizeof (Elf_External_Options
))),
4560 elf_gp (abfd
) = intreg
.ri_gp_value
;
4562 else if (intopt
.kind
== ODK_REGINFO
)
4564 Elf32_RegInfo intreg
;
4566 bfd_mips_elf32_swap_reginfo_in
4568 ((Elf32_External_RegInfo
*)
4569 (l
+ sizeof (Elf_External_Options
))),
4571 elf_gp (abfd
) = intreg
.ri_gp_value
;
4581 /* Set the correct type for a MIPS ELF section. We do this by the
4582 section name, which is a hack, but ought to work. This routine is
4583 used by both the 32-bit and the 64-bit ABI. */
4586 _bfd_mips_elf_fake_sections (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*sec
)
4588 register const char *name
;
4590 name
= bfd_get_section_name (abfd
, sec
);
4592 if (strcmp (name
, ".liblist") == 0)
4594 hdr
->sh_type
= SHT_MIPS_LIBLIST
;
4595 hdr
->sh_info
= sec
->_raw_size
/ sizeof (Elf32_Lib
);
4596 /* The sh_link field is set in final_write_processing. */
4598 else if (strcmp (name
, ".conflict") == 0)
4599 hdr
->sh_type
= SHT_MIPS_CONFLICT
;
4600 else if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0)
4602 hdr
->sh_type
= SHT_MIPS_GPTAB
;
4603 hdr
->sh_entsize
= sizeof (Elf32_External_gptab
);
4604 /* The sh_info field is set in final_write_processing. */
4606 else if (strcmp (name
, ".ucode") == 0)
4607 hdr
->sh_type
= SHT_MIPS_UCODE
;
4608 else if (strcmp (name
, ".mdebug") == 0)
4610 hdr
->sh_type
= SHT_MIPS_DEBUG
;
4611 /* In a shared object on IRIX 5.3, the .mdebug section has an
4612 entsize of 0. FIXME: Does this matter? */
4613 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
4614 hdr
->sh_entsize
= 0;
4616 hdr
->sh_entsize
= 1;
4618 else if (strcmp (name
, ".reginfo") == 0)
4620 hdr
->sh_type
= SHT_MIPS_REGINFO
;
4621 /* In a shared object on IRIX 5.3, the .reginfo section has an
4622 entsize of 0x18. FIXME: Does this matter? */
4623 if (SGI_COMPAT (abfd
))
4625 if ((abfd
->flags
& DYNAMIC
) != 0)
4626 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
4628 hdr
->sh_entsize
= 1;
4631 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
4633 else if (SGI_COMPAT (abfd
)
4634 && (strcmp (name
, ".hash") == 0
4635 || strcmp (name
, ".dynamic") == 0
4636 || strcmp (name
, ".dynstr") == 0))
4638 if (SGI_COMPAT (abfd
))
4639 hdr
->sh_entsize
= 0;
4641 /* This isn't how the IRIX6 linker behaves. */
4642 hdr
->sh_info
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
4645 else if (strcmp (name
, ".got") == 0
4646 || strcmp (name
, ".srdata") == 0
4647 || strcmp (name
, ".sdata") == 0
4648 || strcmp (name
, ".sbss") == 0
4649 || strcmp (name
, ".lit4") == 0
4650 || strcmp (name
, ".lit8") == 0)
4651 hdr
->sh_flags
|= SHF_MIPS_GPREL
;
4652 else if (strcmp (name
, ".MIPS.interfaces") == 0)
4654 hdr
->sh_type
= SHT_MIPS_IFACE
;
4655 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4657 else if (strncmp (name
, ".MIPS.content", strlen (".MIPS.content")) == 0)
4659 hdr
->sh_type
= SHT_MIPS_CONTENT
;
4660 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4661 /* The sh_info field is set in final_write_processing. */
4663 else if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
4665 hdr
->sh_type
= SHT_MIPS_OPTIONS
;
4666 hdr
->sh_entsize
= 1;
4667 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4669 else if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) == 0)
4670 hdr
->sh_type
= SHT_MIPS_DWARF
;
4671 else if (strcmp (name
, ".MIPS.symlib") == 0)
4673 hdr
->sh_type
= SHT_MIPS_SYMBOL_LIB
;
4674 /* The sh_link and sh_info fields are set in
4675 final_write_processing. */
4677 else if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0
4678 || strncmp (name
, ".MIPS.post_rel",
4679 sizeof ".MIPS.post_rel" - 1) == 0)
4681 hdr
->sh_type
= SHT_MIPS_EVENTS
;
4682 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4683 /* The sh_link field is set in final_write_processing. */
4685 else if (strcmp (name
, ".msym") == 0)
4687 hdr
->sh_type
= SHT_MIPS_MSYM
;
4688 hdr
->sh_flags
|= SHF_ALLOC
;
4689 hdr
->sh_entsize
= 8;
4692 /* The generic elf_fake_sections will set up REL_HDR using the default
4693 kind of relocations. We used to set up a second header for the
4694 non-default kind of relocations here, but only NewABI would use
4695 these, and the IRIX ld doesn't like resulting empty RELA sections.
4696 Thus we create those header only on demand now. */
4701 /* Given a BFD section, try to locate the corresponding ELF section
4702 index. This is used by both the 32-bit and the 64-bit ABI.
4703 Actually, it's not clear to me that the 64-bit ABI supports these,
4704 but for non-PIC objects we will certainly want support for at least
4705 the .scommon section. */
4708 _bfd_mips_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
4709 asection
*sec
, int *retval
)
4711 if (strcmp (bfd_get_section_name (abfd
, sec
), ".scommon") == 0)
4713 *retval
= SHN_MIPS_SCOMMON
;
4716 if (strcmp (bfd_get_section_name (abfd
, sec
), ".acommon") == 0)
4718 *retval
= SHN_MIPS_ACOMMON
;
4724 /* Hook called by the linker routine which adds symbols from an object
4725 file. We must handle the special MIPS section numbers here. */
4728 _bfd_mips_elf_add_symbol_hook (bfd
*abfd
, struct bfd_link_info
*info
,
4729 const Elf_Internal_Sym
*sym
, const char **namep
,
4730 flagword
*flagsp ATTRIBUTE_UNUSED
,
4731 asection
**secp
, bfd_vma
*valp
)
4733 if (SGI_COMPAT (abfd
)
4734 && (abfd
->flags
& DYNAMIC
) != 0
4735 && strcmp (*namep
, "_rld_new_interface") == 0)
4737 /* Skip IRIX5 rld entry name. */
4742 switch (sym
->st_shndx
)
4745 /* Common symbols less than the GP size are automatically
4746 treated as SHN_MIPS_SCOMMON symbols. */
4747 if (sym
->st_size
> elf_gp_size (abfd
)
4748 || IRIX_COMPAT (abfd
) == ict_irix6
)
4751 case SHN_MIPS_SCOMMON
:
4752 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
4753 (*secp
)->flags
|= SEC_IS_COMMON
;
4754 *valp
= sym
->st_size
;
4758 /* This section is used in a shared object. */
4759 if (elf_tdata (abfd
)->elf_text_section
== NULL
)
4761 asymbol
*elf_text_symbol
;
4762 asection
*elf_text_section
;
4763 bfd_size_type amt
= sizeof (asection
);
4765 elf_text_section
= bfd_zalloc (abfd
, amt
);
4766 if (elf_text_section
== NULL
)
4769 amt
= sizeof (asymbol
);
4770 elf_text_symbol
= bfd_zalloc (abfd
, amt
);
4771 if (elf_text_symbol
== NULL
)
4774 /* Initialize the section. */
4776 elf_tdata (abfd
)->elf_text_section
= elf_text_section
;
4777 elf_tdata (abfd
)->elf_text_symbol
= elf_text_symbol
;
4779 elf_text_section
->symbol
= elf_text_symbol
;
4780 elf_text_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_text_symbol
;
4782 elf_text_section
->name
= ".text";
4783 elf_text_section
->flags
= SEC_NO_FLAGS
;
4784 elf_text_section
->output_section
= NULL
;
4785 elf_text_section
->owner
= abfd
;
4786 elf_text_symbol
->name
= ".text";
4787 elf_text_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
4788 elf_text_symbol
->section
= elf_text_section
;
4790 /* This code used to do *secp = bfd_und_section_ptr if
4791 info->shared. I don't know why, and that doesn't make sense,
4792 so I took it out. */
4793 *secp
= elf_tdata (abfd
)->elf_text_section
;
4796 case SHN_MIPS_ACOMMON
:
4797 /* Fall through. XXX Can we treat this as allocated data? */
4799 /* This section is used in a shared object. */
4800 if (elf_tdata (abfd
)->elf_data_section
== NULL
)
4802 asymbol
*elf_data_symbol
;
4803 asection
*elf_data_section
;
4804 bfd_size_type amt
= sizeof (asection
);
4806 elf_data_section
= bfd_zalloc (abfd
, amt
);
4807 if (elf_data_section
== NULL
)
4810 amt
= sizeof (asymbol
);
4811 elf_data_symbol
= bfd_zalloc (abfd
, amt
);
4812 if (elf_data_symbol
== NULL
)
4815 /* Initialize the section. */
4817 elf_tdata (abfd
)->elf_data_section
= elf_data_section
;
4818 elf_tdata (abfd
)->elf_data_symbol
= elf_data_symbol
;
4820 elf_data_section
->symbol
= elf_data_symbol
;
4821 elf_data_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_data_symbol
;
4823 elf_data_section
->name
= ".data";
4824 elf_data_section
->flags
= SEC_NO_FLAGS
;
4825 elf_data_section
->output_section
= NULL
;
4826 elf_data_section
->owner
= abfd
;
4827 elf_data_symbol
->name
= ".data";
4828 elf_data_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
4829 elf_data_symbol
->section
= elf_data_section
;
4831 /* This code used to do *secp = bfd_und_section_ptr if
4832 info->shared. I don't know why, and that doesn't make sense,
4833 so I took it out. */
4834 *secp
= elf_tdata (abfd
)->elf_data_section
;
4837 case SHN_MIPS_SUNDEFINED
:
4838 *secp
= bfd_und_section_ptr
;
4842 if (SGI_COMPAT (abfd
)
4844 && info
->hash
->creator
== abfd
->xvec
4845 && strcmp (*namep
, "__rld_obj_head") == 0)
4847 struct elf_link_hash_entry
*h
;
4848 struct bfd_link_hash_entry
*bh
;
4850 /* Mark __rld_obj_head as dynamic. */
4852 if (! (_bfd_generic_link_add_one_symbol
4853 (info
, abfd
, *namep
, BSF_GLOBAL
, *secp
, *valp
, NULL
, FALSE
,
4854 get_elf_backend_data (abfd
)->collect
, &bh
)))
4857 h
= (struct elf_link_hash_entry
*) bh
;
4858 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
4859 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4860 h
->type
= STT_OBJECT
;
4862 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
4865 mips_elf_hash_table (info
)->use_rld_obj_head
= TRUE
;
4868 /* If this is a mips16 text symbol, add 1 to the value to make it
4869 odd. This will cause something like .word SYM to come up with
4870 the right value when it is loaded into the PC. */
4871 if (sym
->st_other
== STO_MIPS16
)
4877 /* This hook function is called before the linker writes out a global
4878 symbol. We mark symbols as small common if appropriate. This is
4879 also where we undo the increment of the value for a mips16 symbol. */
4882 _bfd_mips_elf_link_output_symbol_hook
4883 (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4884 const char *name ATTRIBUTE_UNUSED
, Elf_Internal_Sym
*sym
,
4885 asection
*input_sec
, struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
)
4887 /* If we see a common symbol, which implies a relocatable link, then
4888 if a symbol was small common in an input file, mark it as small
4889 common in the output file. */
4890 if (sym
->st_shndx
== SHN_COMMON
4891 && strcmp (input_sec
->name
, ".scommon") == 0)
4892 sym
->st_shndx
= SHN_MIPS_SCOMMON
;
4894 if (sym
->st_other
== STO_MIPS16
)
4895 sym
->st_value
&= ~1;
4900 /* Functions for the dynamic linker. */
4902 /* Create dynamic sections when linking against a dynamic object. */
4905 _bfd_mips_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
4907 struct elf_link_hash_entry
*h
;
4908 struct bfd_link_hash_entry
*bh
;
4910 register asection
*s
;
4911 const char * const *namep
;
4913 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
4914 | SEC_LINKER_CREATED
| SEC_READONLY
);
4916 /* Mips ABI requests the .dynamic section to be read only. */
4917 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4920 if (! bfd_set_section_flags (abfd
, s
, flags
))
4924 /* We need to create .got section. */
4925 if (! mips_elf_create_got_section (abfd
, info
, FALSE
))
4928 if (! mips_elf_rel_dyn_section (elf_hash_table (info
)->dynobj
, TRUE
))
4931 /* Create .stub section. */
4932 if (bfd_get_section_by_name (abfd
,
4933 MIPS_ELF_STUB_SECTION_NAME (abfd
)) == NULL
)
4935 s
= bfd_make_section (abfd
, MIPS_ELF_STUB_SECTION_NAME (abfd
));
4937 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_CODE
)
4938 || ! bfd_set_section_alignment (abfd
, s
,
4939 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
4943 if ((IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
4945 && bfd_get_section_by_name (abfd
, ".rld_map") == NULL
)
4947 s
= bfd_make_section (abfd
, ".rld_map");
4949 || ! bfd_set_section_flags (abfd
, s
, flags
&~ (flagword
) SEC_READONLY
)
4950 || ! bfd_set_section_alignment (abfd
, s
,
4951 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
4955 /* On IRIX5, we adjust add some additional symbols and change the
4956 alignments of several sections. There is no ABI documentation
4957 indicating that this is necessary on IRIX6, nor any evidence that
4958 the linker takes such action. */
4959 if (IRIX_COMPAT (abfd
) == ict_irix5
)
4961 for (namep
= mips_elf_dynsym_rtproc_names
; *namep
!= NULL
; namep
++)
4964 if (! (_bfd_generic_link_add_one_symbol
4965 (info
, abfd
, *namep
, BSF_GLOBAL
, bfd_und_section_ptr
, 0,
4966 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
4969 h
= (struct elf_link_hash_entry
*) bh
;
4970 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
4971 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4972 h
->type
= STT_SECTION
;
4974 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
4978 /* We need to create a .compact_rel section. */
4979 if (SGI_COMPAT (abfd
))
4981 if (!mips_elf_create_compact_rel_section (abfd
, info
))
4985 /* Change alignments of some sections. */
4986 s
= bfd_get_section_by_name (abfd
, ".hash");
4988 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4989 s
= bfd_get_section_by_name (abfd
, ".dynsym");
4991 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4992 s
= bfd_get_section_by_name (abfd
, ".dynstr");
4994 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4995 s
= bfd_get_section_by_name (abfd
, ".reginfo");
4997 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4998 s
= bfd_get_section_by_name (abfd
, ".dynamic");
5000 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
5007 name
= SGI_COMPAT (abfd
) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
5009 if (!(_bfd_generic_link_add_one_symbol
5010 (info
, abfd
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
, 0,
5011 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
5014 h
= (struct elf_link_hash_entry
*) bh
;
5015 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
5016 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
5017 h
->type
= STT_SECTION
;
5019 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
5022 if (! mips_elf_hash_table (info
)->use_rld_obj_head
)
5024 /* __rld_map is a four byte word located in the .data section
5025 and is filled in by the rtld to contain a pointer to
5026 the _r_debug structure. Its symbol value will be set in
5027 _bfd_mips_elf_finish_dynamic_symbol. */
5028 s
= bfd_get_section_by_name (abfd
, ".rld_map");
5029 BFD_ASSERT (s
!= NULL
);
5031 name
= SGI_COMPAT (abfd
) ? "__rld_map" : "__RLD_MAP";
5033 if (!(_bfd_generic_link_add_one_symbol
5034 (info
, abfd
, name
, BSF_GLOBAL
, s
, 0, NULL
, FALSE
,
5035 get_elf_backend_data (abfd
)->collect
, &bh
)))
5038 h
= (struct elf_link_hash_entry
*) bh
;
5039 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
5040 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
5041 h
->type
= STT_OBJECT
;
5043 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
5051 /* Look through the relocs for a section during the first phase, and
5052 allocate space in the global offset table. */
5055 _bfd_mips_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
5056 asection
*sec
, const Elf_Internal_Rela
*relocs
)
5060 Elf_Internal_Shdr
*symtab_hdr
;
5061 struct elf_link_hash_entry
**sym_hashes
;
5062 struct mips_got_info
*g
;
5064 const Elf_Internal_Rela
*rel
;
5065 const Elf_Internal_Rela
*rel_end
;
5068 const struct elf_backend_data
*bed
;
5070 if (info
->relocatable
)
5073 dynobj
= elf_hash_table (info
)->dynobj
;
5074 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5075 sym_hashes
= elf_sym_hashes (abfd
);
5076 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
5078 /* Check for the mips16 stub sections. */
5080 name
= bfd_get_section_name (abfd
, sec
);
5081 if (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0)
5083 unsigned long r_symndx
;
5085 /* Look at the relocation information to figure out which symbol
5088 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
5090 if (r_symndx
< extsymoff
5091 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
5095 /* This stub is for a local symbol. This stub will only be
5096 needed if there is some relocation in this BFD, other
5097 than a 16 bit function call, which refers to this symbol. */
5098 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5100 Elf_Internal_Rela
*sec_relocs
;
5101 const Elf_Internal_Rela
*r
, *rend
;
5103 /* We can ignore stub sections when looking for relocs. */
5104 if ((o
->flags
& SEC_RELOC
) == 0
5105 || o
->reloc_count
== 0
5106 || strncmp (bfd_get_section_name (abfd
, o
), FN_STUB
,
5107 sizeof FN_STUB
- 1) == 0
5108 || strncmp (bfd_get_section_name (abfd
, o
), CALL_STUB
,
5109 sizeof CALL_STUB
- 1) == 0
5110 || strncmp (bfd_get_section_name (abfd
, o
), CALL_FP_STUB
,
5111 sizeof CALL_FP_STUB
- 1) == 0)
5115 = _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
5117 if (sec_relocs
== NULL
)
5120 rend
= sec_relocs
+ o
->reloc_count
;
5121 for (r
= sec_relocs
; r
< rend
; r
++)
5122 if (ELF_R_SYM (abfd
, r
->r_info
) == r_symndx
5123 && ELF_R_TYPE (abfd
, r
->r_info
) != R_MIPS16_26
)
5126 if (elf_section_data (o
)->relocs
!= sec_relocs
)
5135 /* There is no non-call reloc for this stub, so we do
5136 not need it. Since this function is called before
5137 the linker maps input sections to output sections, we
5138 can easily discard it by setting the SEC_EXCLUDE
5140 sec
->flags
|= SEC_EXCLUDE
;
5144 /* Record this stub in an array of local symbol stubs for
5146 if (elf_tdata (abfd
)->local_stubs
== NULL
)
5148 unsigned long symcount
;
5152 if (elf_bad_symtab (abfd
))
5153 symcount
= NUM_SHDR_ENTRIES (symtab_hdr
);
5155 symcount
= symtab_hdr
->sh_info
;
5156 amt
= symcount
* sizeof (asection
*);
5157 n
= bfd_zalloc (abfd
, amt
);
5160 elf_tdata (abfd
)->local_stubs
= n
;
5163 elf_tdata (abfd
)->local_stubs
[r_symndx
] = sec
;
5165 /* We don't need to set mips16_stubs_seen in this case.
5166 That flag is used to see whether we need to look through
5167 the global symbol table for stubs. We don't need to set
5168 it here, because we just have a local stub. */
5172 struct mips_elf_link_hash_entry
*h
;
5174 h
= ((struct mips_elf_link_hash_entry
*)
5175 sym_hashes
[r_symndx
- extsymoff
]);
5177 /* H is the symbol this stub is for. */
5180 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
5183 else if (strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
5184 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
5186 unsigned long r_symndx
;
5187 struct mips_elf_link_hash_entry
*h
;
5190 /* Look at the relocation information to figure out which symbol
5193 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
5195 if (r_symndx
< extsymoff
5196 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
5198 /* This stub was actually built for a static symbol defined
5199 in the same file. We assume that all static symbols in
5200 mips16 code are themselves mips16, so we can simply
5201 discard this stub. Since this function is called before
5202 the linker maps input sections to output sections, we can
5203 easily discard it by setting the SEC_EXCLUDE flag. */
5204 sec
->flags
|= SEC_EXCLUDE
;
5208 h
= ((struct mips_elf_link_hash_entry
*)
5209 sym_hashes
[r_symndx
- extsymoff
]);
5211 /* H is the symbol this stub is for. */
5213 if (strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
5214 loc
= &h
->call_fp_stub
;
5216 loc
= &h
->call_stub
;
5218 /* If we already have an appropriate stub for this function, we
5219 don't need another one, so we can discard this one. Since
5220 this function is called before the linker maps input sections
5221 to output sections, we can easily discard it by setting the
5222 SEC_EXCLUDE flag. We can also discard this section if we
5223 happen to already know that this is a mips16 function; it is
5224 not necessary to check this here, as it is checked later, but
5225 it is slightly faster to check now. */
5226 if (*loc
!= NULL
|| h
->root
.other
== STO_MIPS16
)
5228 sec
->flags
|= SEC_EXCLUDE
;
5233 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
5243 sgot
= mips_elf_got_section (dynobj
, FALSE
);
5248 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
5249 g
= mips_elf_section_data (sgot
)->u
.got_info
;
5250 BFD_ASSERT (g
!= NULL
);
5255 bed
= get_elf_backend_data (abfd
);
5256 rel_end
= relocs
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
5257 for (rel
= relocs
; rel
< rel_end
; ++rel
)
5259 unsigned long r_symndx
;
5260 unsigned int r_type
;
5261 struct elf_link_hash_entry
*h
;
5263 r_symndx
= ELF_R_SYM (abfd
, rel
->r_info
);
5264 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
5266 if (r_symndx
< extsymoff
)
5268 else if (r_symndx
>= extsymoff
+ NUM_SHDR_ENTRIES (symtab_hdr
))
5270 (*_bfd_error_handler
)
5271 (_("%s: Malformed reloc detected for section %s"),
5272 bfd_archive_filename (abfd
), name
);
5273 bfd_set_error (bfd_error_bad_value
);
5278 h
= sym_hashes
[r_symndx
- extsymoff
];
5280 /* This may be an indirect symbol created because of a version. */
5283 while (h
->root
.type
== bfd_link_hash_indirect
)
5284 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5288 /* Some relocs require a global offset table. */
5289 if (dynobj
== NULL
|| sgot
== NULL
)
5295 case R_MIPS_CALL_HI16
:
5296 case R_MIPS_CALL_LO16
:
5297 case R_MIPS_GOT_HI16
:
5298 case R_MIPS_GOT_LO16
:
5299 case R_MIPS_GOT_PAGE
:
5300 case R_MIPS_GOT_OFST
:
5301 case R_MIPS_GOT_DISP
:
5303 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5304 if (! mips_elf_create_got_section (dynobj
, info
, FALSE
))
5306 g
= mips_elf_got_info (dynobj
, &sgot
);
5313 && (info
->shared
|| h
!= NULL
)
5314 && (sec
->flags
& SEC_ALLOC
) != 0)
5315 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5323 if (!h
&& (r_type
== R_MIPS_CALL_LO16
5324 || r_type
== R_MIPS_GOT_LO16
5325 || r_type
== R_MIPS_GOT_DISP
))
5327 /* We may need a local GOT entry for this relocation. We
5328 don't count R_MIPS_GOT_PAGE because we can estimate the
5329 maximum number of pages needed by looking at the size of
5330 the segment. Similar comments apply to R_MIPS_GOT16 and
5331 R_MIPS_CALL16. We don't count R_MIPS_GOT_HI16, or
5332 R_MIPS_CALL_HI16 because these are always followed by an
5333 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
5334 if (! mips_elf_record_local_got_symbol (abfd
, r_symndx
,
5344 (*_bfd_error_handler
)
5345 (_("%s: CALL16 reloc at 0x%lx not against global symbol"),
5346 bfd_archive_filename (abfd
), (unsigned long) rel
->r_offset
);
5347 bfd_set_error (bfd_error_bad_value
);
5352 case R_MIPS_CALL_HI16
:
5353 case R_MIPS_CALL_LO16
:
5356 /* This symbol requires a global offset table entry. */
5357 if (! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5360 /* We need a stub, not a plt entry for the undefined
5361 function. But we record it as if it needs plt. See
5362 elf_adjust_dynamic_symbol in elflink.h. */
5363 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
5368 case R_MIPS_GOT_PAGE
:
5369 /* If this is a global, overridable symbol, GOT_PAGE will
5370 decay to GOT_DISP, so we'll need a GOT entry for it. */
5375 struct mips_elf_link_hash_entry
*hmips
=
5376 (struct mips_elf_link_hash_entry
*) h
;
5378 while (hmips
->root
.root
.type
== bfd_link_hash_indirect
5379 || hmips
->root
.root
.type
== bfd_link_hash_warning
)
5380 hmips
= (struct mips_elf_link_hash_entry
*)
5381 hmips
->root
.root
.u
.i
.link
;
5383 if ((hmips
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)
5384 && ! (info
->shared
&& ! info
->symbolic
5385 && ! (hmips
->root
.elf_link_hash_flags
5386 & ELF_LINK_FORCED_LOCAL
)))
5392 case R_MIPS_GOT_HI16
:
5393 case R_MIPS_GOT_LO16
:
5394 case R_MIPS_GOT_DISP
:
5395 /* This symbol requires a global offset table entry. */
5396 if (h
&& ! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5403 if ((info
->shared
|| h
!= NULL
)
5404 && (sec
->flags
& SEC_ALLOC
) != 0)
5408 sreloc
= mips_elf_rel_dyn_section (dynobj
, TRUE
);
5412 #define MIPS_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
5415 /* When creating a shared object, we must copy these
5416 reloc types into the output file as R_MIPS_REL32
5417 relocs. We make room for this reloc in the
5418 .rel.dyn reloc section. */
5419 mips_elf_allocate_dynamic_relocations (dynobj
, 1);
5420 if ((sec
->flags
& MIPS_READONLY_SECTION
)
5421 == MIPS_READONLY_SECTION
)
5422 /* We tell the dynamic linker that there are
5423 relocations against the text segment. */
5424 info
->flags
|= DF_TEXTREL
;
5428 struct mips_elf_link_hash_entry
*hmips
;
5430 /* We only need to copy this reloc if the symbol is
5431 defined in a dynamic object. */
5432 hmips
= (struct mips_elf_link_hash_entry
*) h
;
5433 ++hmips
->possibly_dynamic_relocs
;
5434 if ((sec
->flags
& MIPS_READONLY_SECTION
)
5435 == MIPS_READONLY_SECTION
)
5436 /* We need it to tell the dynamic linker if there
5437 are relocations against the text segment. */
5438 hmips
->readonly_reloc
= TRUE
;
5441 /* Even though we don't directly need a GOT entry for
5442 this symbol, a symbol must have a dynamic symbol
5443 table index greater that DT_MIPS_GOTSYM if there are
5444 dynamic relocations against it. */
5448 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5449 if (! mips_elf_create_got_section (dynobj
, info
, TRUE
))
5451 g
= mips_elf_got_info (dynobj
, &sgot
);
5452 if (! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5457 if (SGI_COMPAT (abfd
))
5458 mips_elf_hash_table (info
)->compact_rel_size
+=
5459 sizeof (Elf32_External_crinfo
);
5463 case R_MIPS_GPREL16
:
5464 case R_MIPS_LITERAL
:
5465 case R_MIPS_GPREL32
:
5466 if (SGI_COMPAT (abfd
))
5467 mips_elf_hash_table (info
)->compact_rel_size
+=
5468 sizeof (Elf32_External_crinfo
);
5471 /* This relocation describes the C++ object vtable hierarchy.
5472 Reconstruct it for later use during GC. */
5473 case R_MIPS_GNU_VTINHERIT
:
5474 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
5478 /* This relocation describes which C++ vtable entries are actually
5479 used. Record for later use during GC. */
5480 case R_MIPS_GNU_VTENTRY
:
5481 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
5489 /* We must not create a stub for a symbol that has relocations
5490 related to taking the function's address. */
5496 struct mips_elf_link_hash_entry
*mh
;
5498 mh
= (struct mips_elf_link_hash_entry
*) h
;
5499 mh
->no_fn_stub
= TRUE
;
5503 case R_MIPS_CALL_HI16
:
5504 case R_MIPS_CALL_LO16
:
5509 /* If this reloc is not a 16 bit call, and it has a global
5510 symbol, then we will need the fn_stub if there is one.
5511 References from a stub section do not count. */
5513 && r_type
!= R_MIPS16_26
5514 && strncmp (bfd_get_section_name (abfd
, sec
), FN_STUB
,
5515 sizeof FN_STUB
- 1) != 0
5516 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_STUB
,
5517 sizeof CALL_STUB
- 1) != 0
5518 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_FP_STUB
,
5519 sizeof CALL_FP_STUB
- 1) != 0)
5521 struct mips_elf_link_hash_entry
*mh
;
5523 mh
= (struct mips_elf_link_hash_entry
*) h
;
5524 mh
->need_fn_stub
= TRUE
;
5532 _bfd_mips_relax_section (bfd
*abfd
, asection
*sec
,
5533 struct bfd_link_info
*link_info
,
5536 Elf_Internal_Rela
*internal_relocs
;
5537 Elf_Internal_Rela
*irel
, *irelend
;
5538 Elf_Internal_Shdr
*symtab_hdr
;
5539 bfd_byte
*contents
= NULL
;
5540 bfd_byte
*free_contents
= NULL
;
5542 bfd_boolean changed_contents
= FALSE
;
5543 bfd_vma sec_start
= sec
->output_section
->vma
+ sec
->output_offset
;
5544 Elf_Internal_Sym
*isymbuf
= NULL
;
5546 /* We are not currently changing any sizes, so only one pass. */
5549 if (link_info
->relocatable
)
5552 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
5553 link_info
->keep_memory
);
5554 if (internal_relocs
== NULL
)
5557 irelend
= internal_relocs
+ sec
->reloc_count
5558 * get_elf_backend_data (abfd
)->s
->int_rels_per_ext_rel
;
5559 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5560 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
5562 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
5565 bfd_signed_vma sym_offset
;
5566 unsigned int r_type
;
5567 unsigned long r_symndx
;
5569 unsigned long instruction
;
5571 /* Turn jalr into bgezal, and jr into beq, if they're marked
5572 with a JALR relocation, that indicate where they jump to.
5573 This saves some pipeline bubbles. */
5574 r_type
= ELF_R_TYPE (abfd
, irel
->r_info
);
5575 if (r_type
!= R_MIPS_JALR
)
5578 r_symndx
= ELF_R_SYM (abfd
, irel
->r_info
);
5579 /* Compute the address of the jump target. */
5580 if (r_symndx
>= extsymoff
)
5582 struct mips_elf_link_hash_entry
*h
5583 = ((struct mips_elf_link_hash_entry
*)
5584 elf_sym_hashes (abfd
) [r_symndx
- extsymoff
]);
5586 while (h
->root
.root
.type
== bfd_link_hash_indirect
5587 || h
->root
.root
.type
== bfd_link_hash_warning
)
5588 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
5590 /* If a symbol is undefined, or if it may be overridden,
5592 if (! ((h
->root
.root
.type
== bfd_link_hash_defined
5593 || h
->root
.root
.type
== bfd_link_hash_defweak
)
5594 && h
->root
.root
.u
.def
.section
)
5595 || (link_info
->shared
&& ! link_info
->symbolic
5596 && ! (h
->root
.elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
)))
5599 sym_sec
= h
->root
.root
.u
.def
.section
;
5600 if (sym_sec
->output_section
)
5601 symval
= (h
->root
.root
.u
.def
.value
5602 + sym_sec
->output_section
->vma
5603 + sym_sec
->output_offset
);
5605 symval
= h
->root
.root
.u
.def
.value
;
5609 Elf_Internal_Sym
*isym
;
5611 /* Read this BFD's symbols if we haven't done so already. */
5612 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
5614 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5615 if (isymbuf
== NULL
)
5616 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
5617 symtab_hdr
->sh_info
, 0,
5619 if (isymbuf
== NULL
)
5623 isym
= isymbuf
+ r_symndx
;
5624 if (isym
->st_shndx
== SHN_UNDEF
)
5626 else if (isym
->st_shndx
== SHN_ABS
)
5627 sym_sec
= bfd_abs_section_ptr
;
5628 else if (isym
->st_shndx
== SHN_COMMON
)
5629 sym_sec
= bfd_com_section_ptr
;
5632 = bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
5633 symval
= isym
->st_value
5634 + sym_sec
->output_section
->vma
5635 + sym_sec
->output_offset
;
5638 /* Compute branch offset, from delay slot of the jump to the
5640 sym_offset
= (symval
+ irel
->r_addend
)
5641 - (sec_start
+ irel
->r_offset
+ 4);
5643 /* Branch offset must be properly aligned. */
5644 if ((sym_offset
& 3) != 0)
5649 /* Check that it's in range. */
5650 if (sym_offset
< -0x8000 || sym_offset
>= 0x8000)
5653 /* Get the section contents if we haven't done so already. */
5654 if (contents
== NULL
)
5656 /* Get cached copy if it exists. */
5657 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
5658 contents
= elf_section_data (sec
)->this_hdr
.contents
;
5661 contents
= bfd_malloc (sec
->_raw_size
);
5662 if (contents
== NULL
)
5665 free_contents
= contents
;
5666 if (! bfd_get_section_contents (abfd
, sec
, contents
,
5672 instruction
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
5674 /* If it was jalr <reg>, turn it into bgezal $zero, <target>. */
5675 if ((instruction
& 0xfc1fffff) == 0x0000f809)
5676 instruction
= 0x04110000;
5677 /* If it was jr <reg>, turn it into b <target>. */
5678 else if ((instruction
& 0xfc1fffff) == 0x00000008)
5679 instruction
= 0x10000000;
5683 instruction
|= (sym_offset
& 0xffff);
5684 bfd_put_32 (abfd
, instruction
, contents
+ irel
->r_offset
);
5685 changed_contents
= TRUE
;
5688 if (contents
!= NULL
5689 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
5691 if (!changed_contents
&& !link_info
->keep_memory
)
5695 /* Cache the section contents for elf_link_input_bfd. */
5696 elf_section_data (sec
)->this_hdr
.contents
= contents
;
5702 if (free_contents
!= NULL
)
5703 free (free_contents
);
5707 /* Adjust a symbol defined by a dynamic object and referenced by a
5708 regular object. The current definition is in some section of the
5709 dynamic object, but we're not including those sections. We have to
5710 change the definition to something the rest of the link can
5714 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
5715 struct elf_link_hash_entry
*h
)
5718 struct mips_elf_link_hash_entry
*hmips
;
5721 dynobj
= elf_hash_table (info
)->dynobj
;
5723 /* Make sure we know what is going on here. */
5724 BFD_ASSERT (dynobj
!= NULL
5725 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
5726 || h
->weakdef
!= NULL
5727 || ((h
->elf_link_hash_flags
5728 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
5729 && (h
->elf_link_hash_flags
5730 & ELF_LINK_HASH_REF_REGULAR
) != 0
5731 && (h
->elf_link_hash_flags
5732 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
5734 /* If this symbol is defined in a dynamic object, we need to copy
5735 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
5737 hmips
= (struct mips_elf_link_hash_entry
*) h
;
5738 if (! info
->relocatable
5739 && hmips
->possibly_dynamic_relocs
!= 0
5740 && (h
->root
.type
== bfd_link_hash_defweak
5741 || (h
->elf_link_hash_flags
5742 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
5744 mips_elf_allocate_dynamic_relocations (dynobj
,
5745 hmips
->possibly_dynamic_relocs
);
5746 if (hmips
->readonly_reloc
)
5747 /* We tell the dynamic linker that there are relocations
5748 against the text segment. */
5749 info
->flags
|= DF_TEXTREL
;
5752 /* For a function, create a stub, if allowed. */
5753 if (! hmips
->no_fn_stub
5754 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
5756 if (! elf_hash_table (info
)->dynamic_sections_created
)
5759 /* If this symbol is not defined in a regular file, then set
5760 the symbol to the stub location. This is required to make
5761 function pointers compare as equal between the normal
5762 executable and the shared library. */
5763 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
5765 /* We need .stub section. */
5766 s
= bfd_get_section_by_name (dynobj
,
5767 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
5768 BFD_ASSERT (s
!= NULL
);
5770 h
->root
.u
.def
.section
= s
;
5771 h
->root
.u
.def
.value
= s
->_raw_size
;
5773 /* XXX Write this stub address somewhere. */
5774 h
->plt
.offset
= s
->_raw_size
;
5776 /* Make room for this stub code. */
5777 s
->_raw_size
+= MIPS_FUNCTION_STUB_SIZE
;
5779 /* The last half word of the stub will be filled with the index
5780 of this symbol in .dynsym section. */
5784 else if ((h
->type
== STT_FUNC
)
5785 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0)
5787 /* This will set the entry for this symbol in the GOT to 0, and
5788 the dynamic linker will take care of this. */
5789 h
->root
.u
.def
.value
= 0;
5793 /* If this is a weak symbol, and there is a real definition, the
5794 processor independent code will have arranged for us to see the
5795 real definition first, and we can just use the same value. */
5796 if (h
->weakdef
!= NULL
)
5798 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
5799 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
5800 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
5801 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
5805 /* This is a reference to a symbol defined by a dynamic object which
5806 is not a function. */
5811 /* This function is called after all the input files have been read,
5812 and the input sections have been assigned to output sections. We
5813 check for any mips16 stub sections that we can discard. */
5816 _bfd_mips_elf_always_size_sections (bfd
*output_bfd
,
5817 struct bfd_link_info
*info
)
5823 struct mips_got_info
*g
;
5825 bfd_size_type loadable_size
= 0;
5826 bfd_size_type local_gotno
;
5829 /* The .reginfo section has a fixed size. */
5830 ri
= bfd_get_section_by_name (output_bfd
, ".reginfo");
5832 bfd_set_section_size (output_bfd
, ri
, sizeof (Elf32_External_RegInfo
));
5834 if (! (info
->relocatable
5835 || ! mips_elf_hash_table (info
)->mips16_stubs_seen
))
5836 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
5837 mips_elf_check_mips16_stubs
, NULL
);
5839 dynobj
= elf_hash_table (info
)->dynobj
;
5841 /* Relocatable links don't have it. */
5844 g
= mips_elf_got_info (dynobj
, &s
);
5848 /* Calculate the total loadable size of the output. That
5849 will give us the maximum number of GOT_PAGE entries
5851 for (sub
= info
->input_bfds
; sub
; sub
= sub
->link_next
)
5853 asection
*subsection
;
5855 for (subsection
= sub
->sections
;
5857 subsection
= subsection
->next
)
5859 if ((subsection
->flags
& SEC_ALLOC
) == 0)
5861 loadable_size
+= ((subsection
->_raw_size
+ 0xf)
5862 &~ (bfd_size_type
) 0xf);
5866 /* There has to be a global GOT entry for every symbol with
5867 a dynamic symbol table index of DT_MIPS_GOTSYM or
5868 higher. Therefore, it make sense to put those symbols
5869 that need GOT entries at the end of the symbol table. We
5871 if (! mips_elf_sort_hash_table (info
, 1))
5874 if (g
->global_gotsym
!= NULL
)
5875 i
= elf_hash_table (info
)->dynsymcount
- g
->global_gotsym
->dynindx
;
5877 /* If there are no global symbols, or none requiring
5878 relocations, then GLOBAL_GOTSYM will be NULL. */
5881 /* In the worst case, we'll get one stub per dynamic symbol, plus
5882 one to account for the dummy entry at the end required by IRIX
5884 loadable_size
+= MIPS_FUNCTION_STUB_SIZE
* (i
+ 1);
5886 /* Assume there are two loadable segments consisting of
5887 contiguous sections. Is 5 enough? */
5888 local_gotno
= (loadable_size
>> 16) + 5;
5890 g
->local_gotno
+= local_gotno
;
5891 s
->_raw_size
+= g
->local_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
5893 g
->global_gotno
= i
;
5894 s
->_raw_size
+= i
* MIPS_ELF_GOT_SIZE (output_bfd
);
5896 if (s
->_raw_size
> MIPS_ELF_GOT_MAX_SIZE (output_bfd
)
5897 && ! mips_elf_multi_got (output_bfd
, info
, g
, s
, local_gotno
))
5903 /* Set the sizes of the dynamic sections. */
5906 _bfd_mips_elf_size_dynamic_sections (bfd
*output_bfd
,
5907 struct bfd_link_info
*info
)
5911 bfd_boolean reltext
;
5913 dynobj
= elf_hash_table (info
)->dynobj
;
5914 BFD_ASSERT (dynobj
!= NULL
);
5916 if (elf_hash_table (info
)->dynamic_sections_created
)
5918 /* Set the contents of the .interp section to the interpreter. */
5919 if (info
->executable
)
5921 s
= bfd_get_section_by_name (dynobj
, ".interp");
5922 BFD_ASSERT (s
!= NULL
);
5924 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd
)) + 1;
5926 = (bfd_byte
*) ELF_DYNAMIC_INTERPRETER (output_bfd
);
5930 /* The check_relocs and adjust_dynamic_symbol entry points have
5931 determined the sizes of the various dynamic sections. Allocate
5934 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
5939 /* It's OK to base decisions on the section name, because none
5940 of the dynobj section names depend upon the input files. */
5941 name
= bfd_get_section_name (dynobj
, s
);
5943 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
5948 if (strncmp (name
, ".rel", 4) == 0)
5950 if (s
->_raw_size
== 0)
5952 /* We only strip the section if the output section name
5953 has the same name. Otherwise, there might be several
5954 input sections for this output section. FIXME: This
5955 code is probably not needed these days anyhow, since
5956 the linker now does not create empty output sections. */
5957 if (s
->output_section
!= NULL
5959 bfd_get_section_name (s
->output_section
->owner
,
5960 s
->output_section
)) == 0)
5965 const char *outname
;
5968 /* If this relocation section applies to a read only
5969 section, then we probably need a DT_TEXTREL entry.
5970 If the relocation section is .rel.dyn, we always
5971 assert a DT_TEXTREL entry rather than testing whether
5972 there exists a relocation to a read only section or
5974 outname
= bfd_get_section_name (output_bfd
,
5976 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
5978 && (target
->flags
& SEC_READONLY
) != 0
5979 && (target
->flags
& SEC_ALLOC
) != 0)
5980 || strcmp (outname
, ".rel.dyn") == 0)
5983 /* We use the reloc_count field as a counter if we need
5984 to copy relocs into the output file. */
5985 if (strcmp (name
, ".rel.dyn") != 0)
5988 /* If combreloc is enabled, elf_link_sort_relocs() will
5989 sort relocations, but in a different way than we do,
5990 and before we're done creating relocations. Also, it
5991 will move them around between input sections'
5992 relocation's contents, so our sorting would be
5993 broken, so don't let it run. */
5994 info
->combreloc
= 0;
5997 else if (strncmp (name
, ".got", 4) == 0)
5999 /* _bfd_mips_elf_always_size_sections() has already done
6000 most of the work, but some symbols may have been mapped
6001 to versions that we must now resolve in the got_entries
6003 struct mips_got_info
*gg
= mips_elf_got_info (dynobj
, NULL
);
6004 struct mips_got_info
*g
= gg
;
6005 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
6006 unsigned int needed_relocs
= 0;
6010 set_got_offset_arg
.value
= MIPS_ELF_GOT_SIZE (output_bfd
);
6011 set_got_offset_arg
.info
= info
;
6013 mips_elf_resolve_final_got_entries (gg
);
6014 for (g
= gg
->next
; g
&& g
->next
!= gg
; g
= g
->next
)
6016 unsigned int save_assign
;
6018 mips_elf_resolve_final_got_entries (g
);
6020 /* Assign offsets to global GOT entries. */
6021 save_assign
= g
->assigned_gotno
;
6022 g
->assigned_gotno
= g
->local_gotno
;
6023 set_got_offset_arg
.g
= g
;
6024 set_got_offset_arg
.needed_relocs
= 0;
6025 htab_traverse (g
->got_entries
,
6026 mips_elf_set_global_got_offset
,
6027 &set_got_offset_arg
);
6028 needed_relocs
+= set_got_offset_arg
.needed_relocs
;
6029 BFD_ASSERT (g
->assigned_gotno
- g
->local_gotno
6030 <= g
->global_gotno
);
6032 g
->assigned_gotno
= save_assign
;
6035 needed_relocs
+= g
->local_gotno
- g
->assigned_gotno
;
6036 BFD_ASSERT (g
->assigned_gotno
== g
->next
->local_gotno
6037 + g
->next
->global_gotno
6038 + MIPS_RESERVED_GOTNO
);
6043 mips_elf_allocate_dynamic_relocations (dynobj
, needed_relocs
);
6046 else if (strcmp (name
, MIPS_ELF_STUB_SECTION_NAME (output_bfd
)) == 0)
6048 /* IRIX rld assumes that the function stub isn't at the end
6049 of .text section. So put a dummy. XXX */
6050 s
->_raw_size
+= MIPS_FUNCTION_STUB_SIZE
;
6052 else if (! info
->shared
6053 && ! mips_elf_hash_table (info
)->use_rld_obj_head
6054 && strncmp (name
, ".rld_map", 8) == 0)
6056 /* We add a room for __rld_map. It will be filled in by the
6057 rtld to contain a pointer to the _r_debug structure. */
6060 else if (SGI_COMPAT (output_bfd
)
6061 && strncmp (name
, ".compact_rel", 12) == 0)
6062 s
->_raw_size
+= mips_elf_hash_table (info
)->compact_rel_size
;
6063 else if (strncmp (name
, ".init", 5) != 0)
6065 /* It's not one of our sections, so don't allocate space. */
6071 _bfd_strip_section_from_output (info
, s
);
6075 /* Allocate memory for the section contents. */
6076 s
->contents
= bfd_zalloc (dynobj
, s
->_raw_size
);
6077 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
6079 bfd_set_error (bfd_error_no_memory
);
6084 if (elf_hash_table (info
)->dynamic_sections_created
)
6086 /* Add some entries to the .dynamic section. We fill in the
6087 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
6088 must add the entries now so that we get the correct size for
6089 the .dynamic section. The DT_DEBUG entry is filled in by the
6090 dynamic linker and used by the debugger. */
6093 /* SGI object has the equivalence of DT_DEBUG in the
6094 DT_MIPS_RLD_MAP entry. */
6095 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_MAP
, 0))
6097 if (!SGI_COMPAT (output_bfd
))
6099 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
6105 /* Shared libraries on traditional mips have DT_DEBUG. */
6106 if (!SGI_COMPAT (output_bfd
))
6108 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
6113 if (reltext
&& SGI_COMPAT (output_bfd
))
6114 info
->flags
|= DF_TEXTREL
;
6116 if ((info
->flags
& DF_TEXTREL
) != 0)
6118 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_TEXTREL
, 0))
6122 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTGOT
, 0))
6125 if (mips_elf_rel_dyn_section (dynobj
, FALSE
))
6127 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_REL
, 0))
6130 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELSZ
, 0))
6133 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELENT
, 0))
6137 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_VERSION
, 0))
6140 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_FLAGS
, 0))
6144 /* Time stamps in executable files are a bad idea. */
6145 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_TIME_STAMP
, 0))
6150 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_ICHECKSUM
, 0))
6155 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_IVERSION
, 0))
6159 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_BASE_ADDRESS
, 0))
6162 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LOCAL_GOTNO
, 0))
6165 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_SYMTABNO
, 0))
6168 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_UNREFEXTNO
, 0))
6171 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_GOTSYM
, 0))
6174 if (IRIX_COMPAT (dynobj
) == ict_irix5
6175 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_HIPAGENO
, 0))
6178 if (IRIX_COMPAT (dynobj
) == ict_irix6
6179 && (bfd_get_section_by_name
6180 (dynobj
, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj
)))
6181 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_OPTIONS
, 0))
6188 /* Relocate a MIPS ELF section. */
6191 _bfd_mips_elf_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
6192 bfd
*input_bfd
, asection
*input_section
,
6193 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
6194 Elf_Internal_Sym
*local_syms
,
6195 asection
**local_sections
)
6197 Elf_Internal_Rela
*rel
;
6198 const Elf_Internal_Rela
*relend
;
6200 bfd_boolean use_saved_addend_p
= FALSE
;
6201 const struct elf_backend_data
*bed
;
6203 bed
= get_elf_backend_data (output_bfd
);
6204 relend
= relocs
+ input_section
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
6205 for (rel
= relocs
; rel
< relend
; ++rel
)
6209 reloc_howto_type
*howto
;
6210 bfd_boolean require_jalx
;
6211 /* TRUE if the relocation is a RELA relocation, rather than a
6213 bfd_boolean rela_relocation_p
= TRUE
;
6214 unsigned int r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
6217 /* Find the relocation howto for this relocation. */
6218 if (r_type
== R_MIPS_64
&& ! NEWABI_P (input_bfd
))
6220 /* Some 32-bit code uses R_MIPS_64. In particular, people use
6221 64-bit code, but make sure all their addresses are in the
6222 lowermost or uppermost 32-bit section of the 64-bit address
6223 space. Thus, when they use an R_MIPS_64 they mean what is
6224 usually meant by R_MIPS_32, with the exception that the
6225 stored value is sign-extended to 64 bits. */
6226 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, R_MIPS_32
, FALSE
);
6228 /* On big-endian systems, we need to lie about the position
6230 if (bfd_big_endian (input_bfd
))
6234 /* NewABI defaults to RELA relocations. */
6235 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, r_type
,
6236 NEWABI_P (input_bfd
)
6237 && (MIPS_RELOC_RELA_P
6238 (input_bfd
, input_section
,
6241 if (!use_saved_addend_p
)
6243 Elf_Internal_Shdr
*rel_hdr
;
6245 /* If these relocations were originally of the REL variety,
6246 we must pull the addend out of the field that will be
6247 relocated. Otherwise, we simply use the contents of the
6248 RELA relocation. To determine which flavor or relocation
6249 this is, we depend on the fact that the INPUT_SECTION's
6250 REL_HDR is read before its REL_HDR2. */
6251 rel_hdr
= &elf_section_data (input_section
)->rel_hdr
;
6252 if ((size_t) (rel
- relocs
)
6253 >= (NUM_SHDR_ENTRIES (rel_hdr
) * bed
->s
->int_rels_per_ext_rel
))
6254 rel_hdr
= elf_section_data (input_section
)->rel_hdr2
;
6255 if (rel_hdr
->sh_entsize
== MIPS_ELF_REL_SIZE (input_bfd
))
6257 /* Note that this is a REL relocation. */
6258 rela_relocation_p
= FALSE
;
6260 /* Get the addend, which is stored in the input file. */
6261 addend
= mips_elf_obtain_contents (howto
, rel
, input_bfd
,
6263 addend
&= howto
->src_mask
;
6265 /* For some kinds of relocations, the ADDEND is a
6266 combination of the addend stored in two different
6268 if (r_type
== R_MIPS_HI16
6269 || r_type
== R_MIPS_GNU_REL_HI16
6270 || (r_type
== R_MIPS_GOT16
6271 && mips_elf_local_relocation_p (input_bfd
, rel
,
6272 local_sections
, FALSE
)))
6275 const Elf_Internal_Rela
*lo16_relocation
;
6276 reloc_howto_type
*lo16_howto
;
6279 /* The combined value is the sum of the HI16 addend,
6280 left-shifted by sixteen bits, and the LO16
6281 addend, sign extended. (Usually, the code does
6282 a `lui' of the HI16 value, and then an `addiu' of
6285 Scan ahead to find a matching LO16 relocation. */
6286 if (r_type
== R_MIPS_GNU_REL_HI16
)
6287 lo
= R_MIPS_GNU_REL_LO16
;
6290 lo16_relocation
= mips_elf_next_relocation (input_bfd
, lo
,
6292 if (lo16_relocation
== NULL
)
6295 /* Obtain the addend kept there. */
6296 lo16_howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, lo
, FALSE
);
6297 l
= mips_elf_obtain_contents (lo16_howto
, lo16_relocation
,
6298 input_bfd
, contents
);
6299 l
&= lo16_howto
->src_mask
;
6300 l
<<= lo16_howto
->rightshift
;
6301 l
= _bfd_mips_elf_sign_extend (l
, 16);
6305 /* Compute the combined addend. */
6308 /* If PC-relative, subtract the difference between the
6309 address of the LO part of the reloc and the address of
6310 the HI part. The relocation is relative to the LO
6311 part, but mips_elf_calculate_relocation() doesn't
6312 know its address or the difference from the HI part, so
6313 we subtract that difference here. See also the
6314 comment in mips_elf_calculate_relocation(). */
6315 if (r_type
== R_MIPS_GNU_REL_HI16
)
6316 addend
-= (lo16_relocation
->r_offset
- rel
->r_offset
);
6318 else if (r_type
== R_MIPS16_GPREL
)
6320 /* The addend is scrambled in the object file. See
6321 mips_elf_perform_relocation for details on the
6323 addend
= (((addend
& 0x1f0000) >> 5)
6324 | ((addend
& 0x7e00000) >> 16)
6328 addend
<<= howto
->rightshift
;
6331 addend
= rel
->r_addend
;
6334 if (info
->relocatable
)
6336 Elf_Internal_Sym
*sym
;
6337 unsigned long r_symndx
;
6339 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
)
6340 && bfd_big_endian (input_bfd
))
6343 /* Since we're just relocating, all we need to do is copy
6344 the relocations back out to the object file, unless
6345 they're against a section symbol, in which case we need
6346 to adjust by the section offset, or unless they're GP
6347 relative in which case we need to adjust by the amount
6348 that we're adjusting GP in this relocatable object. */
6350 if (! mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
,
6352 /* There's nothing to do for non-local relocations. */
6355 if (r_type
== R_MIPS16_GPREL
6356 || r_type
== R_MIPS_GPREL16
6357 || r_type
== R_MIPS_GPREL32
6358 || r_type
== R_MIPS_LITERAL
)
6359 addend
-= (_bfd_get_gp_value (output_bfd
)
6360 - _bfd_get_gp_value (input_bfd
));
6362 r_symndx
= ELF_R_SYM (output_bfd
, rel
->r_info
);
6363 sym
= local_syms
+ r_symndx
;
6364 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6365 /* Adjust the addend appropriately. */
6366 addend
+= local_sections
[r_symndx
]->output_offset
;
6368 if (rela_relocation_p
)
6369 /* If this is a RELA relocation, just update the addend. */
6370 rel
->r_addend
= addend
;
6373 if (r_type
== R_MIPS_HI16
6374 || r_type
== R_MIPS_GOT16
6375 || r_type
== R_MIPS_GNU_REL_HI16
)
6376 addend
= mips_elf_high (addend
);
6377 else if (r_type
== R_MIPS_HIGHER
)
6378 addend
= mips_elf_higher (addend
);
6379 else if (r_type
== R_MIPS_HIGHEST
)
6380 addend
= mips_elf_highest (addend
);
6382 addend
>>= howto
->rightshift
;
6384 /* We use the source mask, rather than the destination
6385 mask because the place to which we are writing will be
6386 source of the addend in the final link. */
6387 addend
&= howto
->src_mask
;
6389 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
6390 /* See the comment above about using R_MIPS_64 in the 32-bit
6391 ABI. Here, we need to update the addend. It would be
6392 possible to get away with just using the R_MIPS_32 reloc
6393 but for endianness. */
6399 if (addend
& ((bfd_vma
) 1 << 31))
6401 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
6408 /* If we don't know that we have a 64-bit type,
6409 do two separate stores. */
6410 if (bfd_big_endian (input_bfd
))
6412 /* Store the sign-bits (which are most significant)
6414 low_bits
= sign_bits
;
6420 high_bits
= sign_bits
;
6422 bfd_put_32 (input_bfd
, low_bits
,
6423 contents
+ rel
->r_offset
);
6424 bfd_put_32 (input_bfd
, high_bits
,
6425 contents
+ rel
->r_offset
+ 4);
6429 if (! mips_elf_perform_relocation (info
, howto
, rel
, addend
,
6430 input_bfd
, input_section
,
6435 /* Go on to the next relocation. */
6439 /* In the N32 and 64-bit ABIs there may be multiple consecutive
6440 relocations for the same offset. In that case we are
6441 supposed to treat the output of each relocation as the addend
6443 if (rel
+ 1 < relend
6444 && rel
->r_offset
== rel
[1].r_offset
6445 && ELF_R_TYPE (input_bfd
, rel
[1].r_info
) != R_MIPS_NONE
)
6446 use_saved_addend_p
= TRUE
;
6448 use_saved_addend_p
= FALSE
;
6450 /* Figure out what value we are supposed to relocate. */
6451 switch (mips_elf_calculate_relocation (output_bfd
, input_bfd
,
6452 input_section
, info
, rel
,
6453 addend
, howto
, local_syms
,
6454 local_sections
, &value
,
6455 &name
, &require_jalx
,
6456 use_saved_addend_p
))
6458 case bfd_reloc_continue
:
6459 /* There's nothing to do. */
6462 case bfd_reloc_undefined
:
6463 /* mips_elf_calculate_relocation already called the
6464 undefined_symbol callback. There's no real point in
6465 trying to perform the relocation at this point, so we
6466 just skip ahead to the next relocation. */
6469 case bfd_reloc_notsupported
:
6470 msg
= _("internal error: unsupported relocation error");
6471 info
->callbacks
->warning
6472 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
6475 case bfd_reloc_overflow
:
6476 if (use_saved_addend_p
)
6477 /* Ignore overflow until we reach the last relocation for
6478 a given location. */
6482 BFD_ASSERT (name
!= NULL
);
6483 if (! ((*info
->callbacks
->reloc_overflow
)
6484 (info
, name
, howto
->name
, 0,
6485 input_bfd
, input_section
, rel
->r_offset
)))
6498 /* If we've got another relocation for the address, keep going
6499 until we reach the last one. */
6500 if (use_saved_addend_p
)
6506 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
6507 /* See the comment above about using R_MIPS_64 in the 32-bit
6508 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
6509 that calculated the right value. Now, however, we
6510 sign-extend the 32-bit result to 64-bits, and store it as a
6511 64-bit value. We are especially generous here in that we
6512 go to extreme lengths to support this usage on systems with
6513 only a 32-bit VMA. */
6519 if (value
& ((bfd_vma
) 1 << 31))
6521 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
6528 /* If we don't know that we have a 64-bit type,
6529 do two separate stores. */
6530 if (bfd_big_endian (input_bfd
))
6532 /* Undo what we did above. */
6534 /* Store the sign-bits (which are most significant)
6536 low_bits
= sign_bits
;
6542 high_bits
= sign_bits
;
6544 bfd_put_32 (input_bfd
, low_bits
,
6545 contents
+ rel
->r_offset
);
6546 bfd_put_32 (input_bfd
, high_bits
,
6547 contents
+ rel
->r_offset
+ 4);
6551 /* Actually perform the relocation. */
6552 if (! mips_elf_perform_relocation (info
, howto
, rel
, value
,
6553 input_bfd
, input_section
,
6554 contents
, require_jalx
))
6561 /* If NAME is one of the special IRIX6 symbols defined by the linker,
6562 adjust it appropriately now. */
6565 mips_elf_irix6_finish_dynamic_symbol (bfd
*abfd ATTRIBUTE_UNUSED
,
6566 const char *name
, Elf_Internal_Sym
*sym
)
6568 /* The linker script takes care of providing names and values for
6569 these, but we must place them into the right sections. */
6570 static const char* const text_section_symbols
[] = {
6573 "__dso_displacement",
6575 "__program_header_table",
6579 static const char* const data_section_symbols
[] = {
6587 const char* const *p
;
6590 for (i
= 0; i
< 2; ++i
)
6591 for (p
= (i
== 0) ? text_section_symbols
: data_section_symbols
;
6594 if (strcmp (*p
, name
) == 0)
6596 /* All of these symbols are given type STT_SECTION by the
6598 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6599 sym
->st_other
= STO_PROTECTED
;
6601 /* The IRIX linker puts these symbols in special sections. */
6603 sym
->st_shndx
= SHN_MIPS_TEXT
;
6605 sym
->st_shndx
= SHN_MIPS_DATA
;
6611 /* Finish up dynamic symbol handling. We set the contents of various
6612 dynamic sections here. */
6615 _bfd_mips_elf_finish_dynamic_symbol (bfd
*output_bfd
,
6616 struct bfd_link_info
*info
,
6617 struct elf_link_hash_entry
*h
,
6618 Elf_Internal_Sym
*sym
)
6623 struct mips_got_info
*g
, *gg
;
6626 dynobj
= elf_hash_table (info
)->dynobj
;
6627 gval
= sym
->st_value
;
6629 if (h
->plt
.offset
!= (bfd_vma
) -1)
6632 bfd_byte stub
[MIPS_FUNCTION_STUB_SIZE
];
6634 /* This symbol has a stub. Set it up. */
6636 BFD_ASSERT (h
->dynindx
!= -1);
6638 s
= bfd_get_section_by_name (dynobj
,
6639 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
6640 BFD_ASSERT (s
!= NULL
);
6642 /* FIXME: Can h->dynindex be more than 64K? */
6643 if (h
->dynindx
& 0xffff0000)
6646 /* Fill the stub. */
6647 bfd_put_32 (output_bfd
, STUB_LW (output_bfd
), stub
);
6648 bfd_put_32 (output_bfd
, STUB_MOVE (output_bfd
), stub
+ 4);
6649 bfd_put_32 (output_bfd
, STUB_JALR
, stub
+ 8);
6650 bfd_put_32 (output_bfd
, STUB_LI16 (output_bfd
) + h
->dynindx
, stub
+ 12);
6652 BFD_ASSERT (h
->plt
.offset
<= s
->_raw_size
);
6653 memcpy (s
->contents
+ h
->plt
.offset
, stub
, MIPS_FUNCTION_STUB_SIZE
);
6655 /* Mark the symbol as undefined. plt.offset != -1 occurs
6656 only for the referenced symbol. */
6657 sym
->st_shndx
= SHN_UNDEF
;
6659 /* The run-time linker uses the st_value field of the symbol
6660 to reset the global offset table entry for this external
6661 to its stub address when unlinking a shared object. */
6662 gval
= s
->output_section
->vma
+ s
->output_offset
+ h
->plt
.offset
;
6663 sym
->st_value
= gval
;
6666 BFD_ASSERT (h
->dynindx
!= -1
6667 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0);
6669 sgot
= mips_elf_got_section (dynobj
, FALSE
);
6670 BFD_ASSERT (sgot
!= NULL
);
6671 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
6672 g
= mips_elf_section_data (sgot
)->u
.got_info
;
6673 BFD_ASSERT (g
!= NULL
);
6675 /* Run through the global symbol table, creating GOT entries for all
6676 the symbols that need them. */
6677 if (g
->global_gotsym
!= NULL
6678 && h
->dynindx
>= g
->global_gotsym
->dynindx
)
6683 value
= sym
->st_value
;
6684 offset
= mips_elf_global_got_index (dynobj
, output_bfd
, h
);
6685 MIPS_ELF_PUT_WORD (output_bfd
, value
, sgot
->contents
+ offset
);
6688 if (g
->next
&& h
->dynindx
!= -1)
6690 struct mips_got_entry e
, *p
;
6696 e
.abfd
= output_bfd
;
6698 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
6700 for (g
= g
->next
; g
->next
!= gg
; g
= g
->next
)
6703 && (p
= (struct mips_got_entry
*) htab_find (g
->got_entries
,
6708 || (elf_hash_table (info
)->dynamic_sections_created
6710 && ((p
->d
.h
->root
.elf_link_hash_flags
6711 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0)
6712 && ((p
->d
.h
->root
.elf_link_hash_flags
6713 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
6715 /* Create an R_MIPS_REL32 relocation for this entry. Due to
6716 the various compatibility problems, it's easier to mock
6717 up an R_MIPS_32 or R_MIPS_64 relocation and leave
6718 mips_elf_create_dynamic_relocation to calculate the
6719 appropriate addend. */
6720 Elf_Internal_Rela rel
[3];
6722 memset (rel
, 0, sizeof (rel
));
6723 if (ABI_64_P (output_bfd
))
6724 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_64
);
6726 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_32
);
6727 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
6730 if (! (mips_elf_create_dynamic_relocation
6731 (output_bfd
, info
, rel
,
6732 e
.d
.h
, NULL
, sym
->st_value
, &entry
, sgot
)))
6736 entry
= sym
->st_value
;
6737 MIPS_ELF_PUT_WORD (output_bfd
, entry
, sgot
->contents
+ offset
);
6742 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
6743 name
= h
->root
.root
.string
;
6744 if (strcmp (name
, "_DYNAMIC") == 0
6745 || strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
6746 sym
->st_shndx
= SHN_ABS
;
6747 else if (strcmp (name
, "_DYNAMIC_LINK") == 0
6748 || strcmp (name
, "_DYNAMIC_LINKING") == 0)
6750 sym
->st_shndx
= SHN_ABS
;
6751 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6754 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (output_bfd
))
6756 sym
->st_shndx
= SHN_ABS
;
6757 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6758 sym
->st_value
= elf_gp (output_bfd
);
6760 else if (SGI_COMPAT (output_bfd
))
6762 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
6763 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
6765 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6766 sym
->st_other
= STO_PROTECTED
;
6768 sym
->st_shndx
= SHN_MIPS_DATA
;
6770 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
6772 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6773 sym
->st_other
= STO_PROTECTED
;
6774 sym
->st_value
= mips_elf_hash_table (info
)->procedure_count
;
6775 sym
->st_shndx
= SHN_ABS
;
6777 else if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
!= SHN_ABS
)
6779 if (h
->type
== STT_FUNC
)
6780 sym
->st_shndx
= SHN_MIPS_TEXT
;
6781 else if (h
->type
== STT_OBJECT
)
6782 sym
->st_shndx
= SHN_MIPS_DATA
;
6786 /* Handle the IRIX6-specific symbols. */
6787 if (IRIX_COMPAT (output_bfd
) == ict_irix6
)
6788 mips_elf_irix6_finish_dynamic_symbol (output_bfd
, name
, sym
);
6792 if (! mips_elf_hash_table (info
)->use_rld_obj_head
6793 && (strcmp (name
, "__rld_map") == 0
6794 || strcmp (name
, "__RLD_MAP") == 0))
6796 asection
*s
= bfd_get_section_by_name (dynobj
, ".rld_map");
6797 BFD_ASSERT (s
!= NULL
);
6798 sym
->st_value
= s
->output_section
->vma
+ s
->output_offset
;
6799 bfd_put_32 (output_bfd
, 0, s
->contents
);
6800 if (mips_elf_hash_table (info
)->rld_value
== 0)
6801 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
6803 else if (mips_elf_hash_table (info
)->use_rld_obj_head
6804 && strcmp (name
, "__rld_obj_head") == 0)
6806 /* IRIX6 does not use a .rld_map section. */
6807 if (IRIX_COMPAT (output_bfd
) == ict_irix5
6808 || IRIX_COMPAT (output_bfd
) == ict_none
)
6809 BFD_ASSERT (bfd_get_section_by_name (dynobj
, ".rld_map")
6811 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
6815 /* If this is a mips16 symbol, force the value to be even. */
6816 if (sym
->st_other
== STO_MIPS16
)
6817 sym
->st_value
&= ~1;
6822 /* Finish up the dynamic sections. */
6825 _bfd_mips_elf_finish_dynamic_sections (bfd
*output_bfd
,
6826 struct bfd_link_info
*info
)
6831 struct mips_got_info
*gg
, *g
;
6833 dynobj
= elf_hash_table (info
)->dynobj
;
6835 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
6837 sgot
= mips_elf_got_section (dynobj
, FALSE
);
6842 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
6843 gg
= mips_elf_section_data (sgot
)->u
.got_info
;
6844 BFD_ASSERT (gg
!= NULL
);
6845 g
= mips_elf_got_for_ibfd (gg
, output_bfd
);
6846 BFD_ASSERT (g
!= NULL
);
6849 if (elf_hash_table (info
)->dynamic_sections_created
)
6853 BFD_ASSERT (sdyn
!= NULL
);
6854 BFD_ASSERT (g
!= NULL
);
6856 for (b
= sdyn
->contents
;
6857 b
< sdyn
->contents
+ sdyn
->_raw_size
;
6858 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
6860 Elf_Internal_Dyn dyn
;
6864 bfd_boolean swap_out_p
;
6866 /* Read in the current dynamic entry. */
6867 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
6869 /* Assume that we're going to modify it and write it out. */
6875 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
6876 BFD_ASSERT (s
!= NULL
);
6877 dyn
.d_un
.d_val
= MIPS_ELF_REL_SIZE (dynobj
);
6881 /* Rewrite DT_STRSZ. */
6883 _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
6888 s
= bfd_get_section_by_name (output_bfd
, name
);
6889 BFD_ASSERT (s
!= NULL
);
6890 dyn
.d_un
.d_ptr
= s
->vma
;
6893 case DT_MIPS_RLD_VERSION
:
6894 dyn
.d_un
.d_val
= 1; /* XXX */
6898 dyn
.d_un
.d_val
= RHF_NOTPOT
; /* XXX */
6901 case DT_MIPS_TIME_STAMP
:
6902 time ((time_t *) &dyn
.d_un
.d_val
);
6905 case DT_MIPS_ICHECKSUM
:
6910 case DT_MIPS_IVERSION
:
6915 case DT_MIPS_BASE_ADDRESS
:
6916 s
= output_bfd
->sections
;
6917 BFD_ASSERT (s
!= NULL
);
6918 dyn
.d_un
.d_ptr
= s
->vma
& ~(bfd_vma
) 0xffff;
6921 case DT_MIPS_LOCAL_GOTNO
:
6922 dyn
.d_un
.d_val
= g
->local_gotno
;
6925 case DT_MIPS_UNREFEXTNO
:
6926 /* The index into the dynamic symbol table which is the
6927 entry of the first external symbol that is not
6928 referenced within the same object. */
6929 dyn
.d_un
.d_val
= bfd_count_sections (output_bfd
) + 1;
6932 case DT_MIPS_GOTSYM
:
6933 if (gg
->global_gotsym
)
6935 dyn
.d_un
.d_val
= gg
->global_gotsym
->dynindx
;
6938 /* In case if we don't have global got symbols we default
6939 to setting DT_MIPS_GOTSYM to the same value as
6940 DT_MIPS_SYMTABNO, so we just fall through. */
6942 case DT_MIPS_SYMTABNO
:
6944 elemsize
= MIPS_ELF_SYM_SIZE (output_bfd
);
6945 s
= bfd_get_section_by_name (output_bfd
, name
);
6946 BFD_ASSERT (s
!= NULL
);
6948 if (s
->_cooked_size
!= 0)
6949 dyn
.d_un
.d_val
= s
->_cooked_size
/ elemsize
;
6951 dyn
.d_un
.d_val
= s
->_raw_size
/ elemsize
;
6954 case DT_MIPS_HIPAGENO
:
6955 dyn
.d_un
.d_val
= g
->local_gotno
- MIPS_RESERVED_GOTNO
;
6958 case DT_MIPS_RLD_MAP
:
6959 dyn
.d_un
.d_ptr
= mips_elf_hash_table (info
)->rld_value
;
6962 case DT_MIPS_OPTIONS
:
6963 s
= (bfd_get_section_by_name
6964 (output_bfd
, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd
)));
6965 dyn
.d_un
.d_ptr
= s
->vma
;
6969 /* Reduce DT_RELSZ to account for any relocations we
6970 decided not to make. This is for the n64 irix rld,
6971 which doesn't seem to apply any relocations if there
6972 are trailing null entries. */
6973 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
6974 dyn
.d_un
.d_val
= (s
->reloc_count
6975 * (ABI_64_P (output_bfd
)
6976 ? sizeof (Elf64_Mips_External_Rel
)
6977 : sizeof (Elf32_External_Rel
)));
6986 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
6991 /* The first entry of the global offset table will be filled at
6992 runtime. The second entry will be used by some runtime loaders.
6993 This isn't the case of IRIX rld. */
6994 if (sgot
!= NULL
&& sgot
->_raw_size
> 0)
6996 MIPS_ELF_PUT_WORD (output_bfd
, 0, sgot
->contents
);
6997 MIPS_ELF_PUT_WORD (output_bfd
, 0x80000000,
6998 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
7002 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
7003 = MIPS_ELF_GOT_SIZE (output_bfd
);
7005 /* Generate dynamic relocations for the non-primary gots. */
7006 if (gg
!= NULL
&& gg
->next
)
7008 Elf_Internal_Rela rel
[3];
7011 memset (rel
, 0, sizeof (rel
));
7012 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_REL32
);
7014 for (g
= gg
->next
; g
->next
!= gg
; g
= g
->next
)
7016 bfd_vma index
= g
->next
->local_gotno
+ g
->next
->global_gotno
;
7018 MIPS_ELF_PUT_WORD (output_bfd
, 0, sgot
->contents
7019 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
7020 MIPS_ELF_PUT_WORD (output_bfd
, 0x80000000, sgot
->contents
7021 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
7026 while (index
< g
->assigned_gotno
)
7028 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
7029 = index
++ * MIPS_ELF_GOT_SIZE (output_bfd
);
7030 if (!(mips_elf_create_dynamic_relocation
7031 (output_bfd
, info
, rel
, NULL
,
7032 bfd_abs_section_ptr
,
7035 BFD_ASSERT (addend
== 0);
7042 Elf32_compact_rel cpt
;
7044 if (SGI_COMPAT (output_bfd
))
7046 /* Write .compact_rel section out. */
7047 s
= bfd_get_section_by_name (dynobj
, ".compact_rel");
7051 cpt
.num
= s
->reloc_count
;
7053 cpt
.offset
= (s
->output_section
->filepos
7054 + sizeof (Elf32_External_compact_rel
));
7057 bfd_elf32_swap_compact_rel_out (output_bfd
, &cpt
,
7058 ((Elf32_External_compact_rel
*)
7061 /* Clean up a dummy stub function entry in .text. */
7062 s
= bfd_get_section_by_name (dynobj
,
7063 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
7066 file_ptr dummy_offset
;
7068 BFD_ASSERT (s
->_raw_size
>= MIPS_FUNCTION_STUB_SIZE
);
7069 dummy_offset
= s
->_raw_size
- MIPS_FUNCTION_STUB_SIZE
;
7070 memset (s
->contents
+ dummy_offset
, 0,
7071 MIPS_FUNCTION_STUB_SIZE
);
7076 /* We need to sort the entries of the dynamic relocation section. */
7078 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
7081 && s
->_raw_size
> (bfd_vma
)2 * MIPS_ELF_REL_SIZE (output_bfd
))
7083 reldyn_sorting_bfd
= output_bfd
;
7085 if (ABI_64_P (output_bfd
))
7086 qsort ((Elf64_External_Rel
*) s
->contents
+ 1, s
->reloc_count
- 1,
7087 sizeof (Elf64_Mips_External_Rel
), sort_dynamic_relocs_64
);
7089 qsort ((Elf32_External_Rel
*) s
->contents
+ 1, s
->reloc_count
- 1,
7090 sizeof (Elf32_External_Rel
), sort_dynamic_relocs
);
7098 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
7101 mips_set_isa_flags (bfd
*abfd
)
7105 switch (bfd_get_mach (abfd
))
7108 case bfd_mach_mips3000
:
7109 val
= E_MIPS_ARCH_1
;
7112 case bfd_mach_mips3900
:
7113 val
= E_MIPS_ARCH_1
| E_MIPS_MACH_3900
;
7116 case bfd_mach_mips6000
:
7117 val
= E_MIPS_ARCH_2
;
7120 case bfd_mach_mips4000
:
7121 case bfd_mach_mips4300
:
7122 case bfd_mach_mips4400
:
7123 case bfd_mach_mips4600
:
7124 val
= E_MIPS_ARCH_3
;
7127 case bfd_mach_mips4010
:
7128 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4010
;
7131 case bfd_mach_mips4100
:
7132 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4100
;
7135 case bfd_mach_mips4111
:
7136 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4111
;
7139 case bfd_mach_mips4120
:
7140 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4120
;
7143 case bfd_mach_mips4650
:
7144 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4650
;
7147 case bfd_mach_mips5400
:
7148 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5400
;
7151 case bfd_mach_mips5500
:
7152 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5500
;
7155 case bfd_mach_mips5000
:
7156 case bfd_mach_mips7000
:
7157 case bfd_mach_mips8000
:
7158 case bfd_mach_mips10000
:
7159 case bfd_mach_mips12000
:
7160 val
= E_MIPS_ARCH_4
;
7163 case bfd_mach_mips5
:
7164 val
= E_MIPS_ARCH_5
;
7167 case bfd_mach_mips_sb1
:
7168 val
= E_MIPS_ARCH_64
| E_MIPS_MACH_SB1
;
7171 case bfd_mach_mipsisa32
:
7172 val
= E_MIPS_ARCH_32
;
7175 case bfd_mach_mipsisa64
:
7176 val
= E_MIPS_ARCH_64
;
7179 case bfd_mach_mipsisa32r2
:
7180 val
= E_MIPS_ARCH_32R2
;
7183 case bfd_mach_mipsisa64r2
:
7184 val
= E_MIPS_ARCH_64R2
;
7187 elf_elfheader (abfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
7188 elf_elfheader (abfd
)->e_flags
|= val
;
7193 /* The final processing done just before writing out a MIPS ELF object
7194 file. This gets the MIPS architecture right based on the machine
7195 number. This is used by both the 32-bit and the 64-bit ABI. */
7198 _bfd_mips_elf_final_write_processing (bfd
*abfd
,
7199 bfd_boolean linker ATTRIBUTE_UNUSED
)
7202 Elf_Internal_Shdr
**hdrpp
;
7206 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
7207 is nonzero. This is for compatibility with old objects, which used
7208 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
7209 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_MACH
) == 0)
7210 mips_set_isa_flags (abfd
);
7212 /* Set the sh_info field for .gptab sections and other appropriate
7213 info for each special section. */
7214 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
7215 i
< elf_numsections (abfd
);
7218 switch ((*hdrpp
)->sh_type
)
7221 case SHT_MIPS_LIBLIST
:
7222 sec
= bfd_get_section_by_name (abfd
, ".dynstr");
7224 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7227 case SHT_MIPS_GPTAB
:
7228 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7229 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7230 BFD_ASSERT (name
!= NULL
7231 && strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0);
7232 sec
= bfd_get_section_by_name (abfd
, name
+ sizeof ".gptab" - 1);
7233 BFD_ASSERT (sec
!= NULL
);
7234 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
7237 case SHT_MIPS_CONTENT
:
7238 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7239 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7240 BFD_ASSERT (name
!= NULL
7241 && strncmp (name
, ".MIPS.content",
7242 sizeof ".MIPS.content" - 1) == 0);
7243 sec
= bfd_get_section_by_name (abfd
,
7244 name
+ sizeof ".MIPS.content" - 1);
7245 BFD_ASSERT (sec
!= NULL
);
7246 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7249 case SHT_MIPS_SYMBOL_LIB
:
7250 sec
= bfd_get_section_by_name (abfd
, ".dynsym");
7252 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7253 sec
= bfd_get_section_by_name (abfd
, ".liblist");
7255 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
7258 case SHT_MIPS_EVENTS
:
7259 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7260 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7261 BFD_ASSERT (name
!= NULL
);
7262 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0)
7263 sec
= bfd_get_section_by_name (abfd
,
7264 name
+ sizeof ".MIPS.events" - 1);
7267 BFD_ASSERT (strncmp (name
, ".MIPS.post_rel",
7268 sizeof ".MIPS.post_rel" - 1) == 0);
7269 sec
= bfd_get_section_by_name (abfd
,
7271 + sizeof ".MIPS.post_rel" - 1));
7273 BFD_ASSERT (sec
!= NULL
);
7274 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7281 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
7285 _bfd_mips_elf_additional_program_headers (bfd
*abfd
)
7290 /* See if we need a PT_MIPS_REGINFO segment. */
7291 s
= bfd_get_section_by_name (abfd
, ".reginfo");
7292 if (s
&& (s
->flags
& SEC_LOAD
))
7295 /* See if we need a PT_MIPS_OPTIONS segment. */
7296 if (IRIX_COMPAT (abfd
) == ict_irix6
7297 && bfd_get_section_by_name (abfd
,
7298 MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)))
7301 /* See if we need a PT_MIPS_RTPROC segment. */
7302 if (IRIX_COMPAT (abfd
) == ict_irix5
7303 && bfd_get_section_by_name (abfd
, ".dynamic")
7304 && bfd_get_section_by_name (abfd
, ".mdebug"))
7310 /* Modify the segment map for an IRIX5 executable. */
7313 _bfd_mips_elf_modify_segment_map (bfd
*abfd
,
7314 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
7317 struct elf_segment_map
*m
, **pm
;
7320 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
7322 s
= bfd_get_section_by_name (abfd
, ".reginfo");
7323 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
7325 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
7326 if (m
->p_type
== PT_MIPS_REGINFO
)
7331 m
= bfd_zalloc (abfd
, amt
);
7335 m
->p_type
= PT_MIPS_REGINFO
;
7339 /* We want to put it after the PHDR and INTERP segments. */
7340 pm
= &elf_tdata (abfd
)->segment_map
;
7342 && ((*pm
)->p_type
== PT_PHDR
7343 || (*pm
)->p_type
== PT_INTERP
))
7351 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
7352 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
7353 PT_MIPS_OPTIONS segment immediately following the program header
7356 /* On non-IRIX6 new abi, we'll have already created a segment
7357 for this section, so don't create another. I'm not sure this
7358 is not also the case for IRIX 6, but I can't test it right
7360 && IRIX_COMPAT (abfd
) == ict_irix6
)
7362 for (s
= abfd
->sections
; s
; s
= s
->next
)
7363 if (elf_section_data (s
)->this_hdr
.sh_type
== SHT_MIPS_OPTIONS
)
7368 struct elf_segment_map
*options_segment
;
7370 pm
= &elf_tdata (abfd
)->segment_map
;
7372 && ((*pm
)->p_type
== PT_PHDR
7373 || (*pm
)->p_type
== PT_INTERP
))
7376 amt
= sizeof (struct elf_segment_map
);
7377 options_segment
= bfd_zalloc (abfd
, amt
);
7378 options_segment
->next
= *pm
;
7379 options_segment
->p_type
= PT_MIPS_OPTIONS
;
7380 options_segment
->p_flags
= PF_R
;
7381 options_segment
->p_flags_valid
= TRUE
;
7382 options_segment
->count
= 1;
7383 options_segment
->sections
[0] = s
;
7384 *pm
= options_segment
;
7389 if (IRIX_COMPAT (abfd
) == ict_irix5
)
7391 /* If there are .dynamic and .mdebug sections, we make a room
7392 for the RTPROC header. FIXME: Rewrite without section names. */
7393 if (bfd_get_section_by_name (abfd
, ".interp") == NULL
7394 && bfd_get_section_by_name (abfd
, ".dynamic") != NULL
7395 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
7397 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
7398 if (m
->p_type
== PT_MIPS_RTPROC
)
7403 m
= bfd_zalloc (abfd
, amt
);
7407 m
->p_type
= PT_MIPS_RTPROC
;
7409 s
= bfd_get_section_by_name (abfd
, ".rtproc");
7414 m
->p_flags_valid
= 1;
7422 /* We want to put it after the DYNAMIC segment. */
7423 pm
= &elf_tdata (abfd
)->segment_map
;
7424 while (*pm
!= NULL
&& (*pm
)->p_type
!= PT_DYNAMIC
)
7434 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
7435 .dynstr, .dynsym, and .hash sections, and everything in
7437 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
;
7439 if ((*pm
)->p_type
== PT_DYNAMIC
)
7442 if (m
!= NULL
&& IRIX_COMPAT (abfd
) == ict_none
)
7444 /* For a normal mips executable the permissions for the PT_DYNAMIC
7445 segment are read, write and execute. We do that here since
7446 the code in elf.c sets only the read permission. This matters
7447 sometimes for the dynamic linker. */
7448 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
7450 m
->p_flags
= PF_R
| PF_W
| PF_X
;
7451 m
->p_flags_valid
= 1;
7455 && m
->count
== 1 && strcmp (m
->sections
[0]->name
, ".dynamic") == 0)
7457 static const char *sec_names
[] =
7459 ".dynamic", ".dynstr", ".dynsym", ".hash"
7463 struct elf_segment_map
*n
;
7467 for (i
= 0; i
< sizeof sec_names
/ sizeof sec_names
[0]; i
++)
7469 s
= bfd_get_section_by_name (abfd
, sec_names
[i
]);
7470 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
7476 sz
= s
->_cooked_size
;
7479 if (high
< s
->vma
+ sz
)
7485 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
7486 if ((s
->flags
& SEC_LOAD
) != 0
7489 + (s
->_cooked_size
!=
7490 0 ? s
->_cooked_size
: s
->_raw_size
)) <= high
))
7493 amt
= sizeof *n
+ (bfd_size_type
) (c
- 1) * sizeof (asection
*);
7494 n
= bfd_zalloc (abfd
, amt
);
7501 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
7503 if ((s
->flags
& SEC_LOAD
) != 0
7506 + (s
->_cooked_size
!= 0 ?
7507 s
->_cooked_size
: s
->_raw_size
)) <= high
))
7521 /* Return the section that should be marked against GC for a given
7525 _bfd_mips_elf_gc_mark_hook (asection
*sec
,
7526 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
7527 Elf_Internal_Rela
*rel
,
7528 struct elf_link_hash_entry
*h
,
7529 Elf_Internal_Sym
*sym
)
7531 /* ??? Do mips16 stub sections need to be handled special? */
7535 switch (ELF_R_TYPE (sec
->owner
, rel
->r_info
))
7537 case R_MIPS_GNU_VTINHERIT
:
7538 case R_MIPS_GNU_VTENTRY
:
7542 switch (h
->root
.type
)
7544 case bfd_link_hash_defined
:
7545 case bfd_link_hash_defweak
:
7546 return h
->root
.u
.def
.section
;
7548 case bfd_link_hash_common
:
7549 return h
->root
.u
.c
.p
->section
;
7557 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
7562 /* Update the got entry reference counts for the section being removed. */
7565 _bfd_mips_elf_gc_sweep_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
7566 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
7567 asection
*sec ATTRIBUTE_UNUSED
,
7568 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
)
7571 Elf_Internal_Shdr
*symtab_hdr
;
7572 struct elf_link_hash_entry
**sym_hashes
;
7573 bfd_signed_vma
*local_got_refcounts
;
7574 const Elf_Internal_Rela
*rel
, *relend
;
7575 unsigned long r_symndx
;
7576 struct elf_link_hash_entry
*h
;
7578 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7579 sym_hashes
= elf_sym_hashes (abfd
);
7580 local_got_refcounts
= elf_local_got_refcounts (abfd
);
7582 relend
= relocs
+ sec
->reloc_count
;
7583 for (rel
= relocs
; rel
< relend
; rel
++)
7584 switch (ELF_R_TYPE (abfd
, rel
->r_info
))
7588 case R_MIPS_CALL_HI16
:
7589 case R_MIPS_CALL_LO16
:
7590 case R_MIPS_GOT_HI16
:
7591 case R_MIPS_GOT_LO16
:
7592 case R_MIPS_GOT_DISP
:
7593 case R_MIPS_GOT_PAGE
:
7594 case R_MIPS_GOT_OFST
:
7595 /* ??? It would seem that the existing MIPS code does no sort
7596 of reference counting or whatnot on its GOT and PLT entries,
7597 so it is not possible to garbage collect them at this time. */
7608 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
7609 hiding the old indirect symbol. Process additional relocation
7610 information. Also called for weakdefs, in which case we just let
7611 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
7614 _bfd_mips_elf_copy_indirect_symbol (const struct elf_backend_data
*bed
,
7615 struct elf_link_hash_entry
*dir
,
7616 struct elf_link_hash_entry
*ind
)
7618 struct mips_elf_link_hash_entry
*dirmips
, *indmips
;
7620 _bfd_elf_link_hash_copy_indirect (bed
, dir
, ind
);
7622 if (ind
->root
.type
!= bfd_link_hash_indirect
)
7625 dirmips
= (struct mips_elf_link_hash_entry
*) dir
;
7626 indmips
= (struct mips_elf_link_hash_entry
*) ind
;
7627 dirmips
->possibly_dynamic_relocs
+= indmips
->possibly_dynamic_relocs
;
7628 if (indmips
->readonly_reloc
)
7629 dirmips
->readonly_reloc
= TRUE
;
7630 if (indmips
->no_fn_stub
)
7631 dirmips
->no_fn_stub
= TRUE
;
7635 _bfd_mips_elf_hide_symbol (struct bfd_link_info
*info
,
7636 struct elf_link_hash_entry
*entry
,
7637 bfd_boolean force_local
)
7641 struct mips_got_info
*g
;
7642 struct mips_elf_link_hash_entry
*h
;
7644 h
= (struct mips_elf_link_hash_entry
*) entry
;
7645 if (h
->forced_local
)
7647 h
->forced_local
= force_local
;
7649 dynobj
= elf_hash_table (info
)->dynobj
;
7650 if (dynobj
!= NULL
&& force_local
)
7652 got
= mips_elf_got_section (dynobj
, FALSE
);
7653 g
= mips_elf_section_data (got
)->u
.got_info
;
7657 struct mips_got_entry e
;
7658 struct mips_got_info
*gg
= g
;
7660 /* Since we're turning what used to be a global symbol into a
7661 local one, bump up the number of local entries of each GOT
7662 that had an entry for it. This will automatically decrease
7663 the number of global entries, since global_gotno is actually
7664 the upper limit of global entries. */
7669 for (g
= g
->next
; g
!= gg
; g
= g
->next
)
7670 if (htab_find (g
->got_entries
, &e
))
7672 BFD_ASSERT (g
->global_gotno
> 0);
7677 /* If this was a global symbol forced into the primary GOT, we
7678 no longer need an entry for it. We can't release the entry
7679 at this point, but we must at least stop counting it as one
7680 of the symbols that required a forced got entry. */
7681 if (h
->root
.got
.offset
== 2)
7683 BFD_ASSERT (gg
->assigned_gotno
> 0);
7684 gg
->assigned_gotno
--;
7687 else if (g
->global_gotno
== 0 && g
->global_gotsym
== NULL
)
7688 /* If we haven't got through GOT allocation yet, just bump up the
7689 number of local entries, as this symbol won't be counted as
7692 else if (h
->root
.got
.offset
== 1)
7694 /* If we're past non-multi-GOT allocation and this symbol had
7695 been marked for a global got entry, give it a local entry
7697 BFD_ASSERT (g
->global_gotno
> 0);
7703 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
7709 _bfd_mips_elf_discard_info (bfd
*abfd
, struct elf_reloc_cookie
*cookie
,
7710 struct bfd_link_info
*info
)
7713 bfd_boolean ret
= FALSE
;
7714 unsigned char *tdata
;
7717 o
= bfd_get_section_by_name (abfd
, ".pdr");
7720 if (o
->_raw_size
== 0)
7722 if (o
->_raw_size
% PDR_SIZE
!= 0)
7724 if (o
->output_section
!= NULL
7725 && bfd_is_abs_section (o
->output_section
))
7728 tdata
= bfd_zmalloc (o
->_raw_size
/ PDR_SIZE
);
7732 cookie
->rels
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
7740 cookie
->rel
= cookie
->rels
;
7741 cookie
->relend
= cookie
->rels
+ o
->reloc_count
;
7743 for (i
= 0, skip
= 0; i
< o
->_raw_size
/ PDR_SIZE
; i
++)
7745 if (MNAME(abfd
,_bfd_elf
,reloc_symbol_deleted_p
) (i
* PDR_SIZE
, cookie
))
7754 mips_elf_section_data (o
)->u
.tdata
= tdata
;
7755 o
->_cooked_size
= o
->_raw_size
- skip
* PDR_SIZE
;
7761 if (! info
->keep_memory
)
7762 free (cookie
->rels
);
7768 _bfd_mips_elf_ignore_discarded_relocs (asection
*sec
)
7770 if (strcmp (sec
->name
, ".pdr") == 0)
7776 _bfd_mips_elf_write_section (bfd
*output_bfd
, asection
*sec
,
7779 bfd_byte
*to
, *from
, *end
;
7782 if (strcmp (sec
->name
, ".pdr") != 0)
7785 if (mips_elf_section_data (sec
)->u
.tdata
== NULL
)
7789 end
= contents
+ sec
->_raw_size
;
7790 for (from
= contents
, i
= 0;
7792 from
+= PDR_SIZE
, i
++)
7794 if ((mips_elf_section_data (sec
)->u
.tdata
)[i
] == 1)
7797 memcpy (to
, from
, PDR_SIZE
);
7800 bfd_set_section_contents (output_bfd
, sec
->output_section
, contents
,
7801 sec
->output_offset
, sec
->_cooked_size
);
7805 /* MIPS ELF uses a special find_nearest_line routine in order the
7806 handle the ECOFF debugging information. */
7808 struct mips_elf_find_line
7810 struct ecoff_debug_info d
;
7811 struct ecoff_find_line i
;
7815 _bfd_mips_elf_find_nearest_line (bfd
*abfd
, asection
*section
,
7816 asymbol
**symbols
, bfd_vma offset
,
7817 const char **filename_ptr
,
7818 const char **functionname_ptr
,
7819 unsigned int *line_ptr
)
7823 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
7824 filename_ptr
, functionname_ptr
,
7828 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
7829 filename_ptr
, functionname_ptr
,
7830 line_ptr
, ABI_64_P (abfd
) ? 8 : 0,
7831 &elf_tdata (abfd
)->dwarf2_find_line_info
))
7834 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
7838 struct mips_elf_find_line
*fi
;
7839 const struct ecoff_debug_swap
* const swap
=
7840 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
7842 /* If we are called during a link, mips_elf_final_link may have
7843 cleared the SEC_HAS_CONTENTS field. We force it back on here
7844 if appropriate (which it normally will be). */
7845 origflags
= msec
->flags
;
7846 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
7847 msec
->flags
|= SEC_HAS_CONTENTS
;
7849 fi
= elf_tdata (abfd
)->find_line_info
;
7852 bfd_size_type external_fdr_size
;
7855 struct fdr
*fdr_ptr
;
7856 bfd_size_type amt
= sizeof (struct mips_elf_find_line
);
7858 fi
= bfd_zalloc (abfd
, amt
);
7861 msec
->flags
= origflags
;
7865 if (! _bfd_mips_elf_read_ecoff_info (abfd
, msec
, &fi
->d
))
7867 msec
->flags
= origflags
;
7871 /* Swap in the FDR information. */
7872 amt
= fi
->d
.symbolic_header
.ifdMax
* sizeof (struct fdr
);
7873 fi
->d
.fdr
= bfd_alloc (abfd
, amt
);
7874 if (fi
->d
.fdr
== NULL
)
7876 msec
->flags
= origflags
;
7879 external_fdr_size
= swap
->external_fdr_size
;
7880 fdr_ptr
= fi
->d
.fdr
;
7881 fraw_src
= (char *) fi
->d
.external_fdr
;
7882 fraw_end
= (fraw_src
7883 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
7884 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
7885 (*swap
->swap_fdr_in
) (abfd
, fraw_src
, fdr_ptr
);
7887 elf_tdata (abfd
)->find_line_info
= fi
;
7889 /* Note that we don't bother to ever free this information.
7890 find_nearest_line is either called all the time, as in
7891 objdump -l, so the information should be saved, or it is
7892 rarely called, as in ld error messages, so the memory
7893 wasted is unimportant. Still, it would probably be a
7894 good idea for free_cached_info to throw it away. */
7897 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
7898 &fi
->i
, filename_ptr
, functionname_ptr
,
7901 msec
->flags
= origflags
;
7905 msec
->flags
= origflags
;
7908 /* Fall back on the generic ELF find_nearest_line routine. */
7910 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
7911 filename_ptr
, functionname_ptr
,
7915 /* When are writing out the .options or .MIPS.options section,
7916 remember the bytes we are writing out, so that we can install the
7917 GP value in the section_processing routine. */
7920 _bfd_mips_elf_set_section_contents (bfd
*abfd
, sec_ptr section
,
7921 const void *location
,
7922 file_ptr offset
, bfd_size_type count
)
7924 if (strcmp (section
->name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
7928 if (elf_section_data (section
) == NULL
)
7930 bfd_size_type amt
= sizeof (struct bfd_elf_section_data
);
7931 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
7932 if (elf_section_data (section
) == NULL
)
7935 c
= mips_elf_section_data (section
)->u
.tdata
;
7940 if (section
->_cooked_size
!= 0)
7941 size
= section
->_cooked_size
;
7943 size
= section
->_raw_size
;
7944 c
= bfd_zalloc (abfd
, size
);
7947 mips_elf_section_data (section
)->u
.tdata
= c
;
7950 memcpy (c
+ offset
, location
, count
);
7953 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
,
7957 /* This is almost identical to bfd_generic_get_... except that some
7958 MIPS relocations need to be handled specially. Sigh. */
7961 _bfd_elf_mips_get_relocated_section_contents
7963 struct bfd_link_info
*link_info
,
7964 struct bfd_link_order
*link_order
,
7966 bfd_boolean relocatable
,
7969 /* Get enough memory to hold the stuff */
7970 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
7971 asection
*input_section
= link_order
->u
.indirect
.section
;
7973 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
7974 arelent
**reloc_vector
= NULL
;
7980 reloc_vector
= bfd_malloc (reloc_size
);
7981 if (reloc_vector
== NULL
&& reloc_size
!= 0)
7984 /* read in the section */
7985 if (!bfd_get_section_contents (input_bfd
, input_section
, data
, 0,
7986 input_section
->_raw_size
))
7989 /* We're not relaxing the section, so just copy the size info */
7990 input_section
->_cooked_size
= input_section
->_raw_size
;
7991 input_section
->reloc_done
= TRUE
;
7993 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
7997 if (reloc_count
< 0)
8000 if (reloc_count
> 0)
8005 bfd_vma gp
= 0x12345678; /* initialize just to shut gcc up */
8008 struct bfd_hash_entry
*h
;
8009 struct bfd_link_hash_entry
*lh
;
8010 /* Skip all this stuff if we aren't mixing formats. */
8011 if (abfd
&& input_bfd
8012 && abfd
->xvec
== input_bfd
->xvec
)
8016 h
= bfd_hash_lookup (&link_info
->hash
->table
, "_gp", FALSE
, FALSE
);
8017 lh
= (struct bfd_link_hash_entry
*) h
;
8024 case bfd_link_hash_undefined
:
8025 case bfd_link_hash_undefweak
:
8026 case bfd_link_hash_common
:
8029 case bfd_link_hash_defined
:
8030 case bfd_link_hash_defweak
:
8032 gp
= lh
->u
.def
.value
;
8034 case bfd_link_hash_indirect
:
8035 case bfd_link_hash_warning
:
8037 /* @@FIXME ignoring warning for now */
8039 case bfd_link_hash_new
:
8048 for (parent
= reloc_vector
; *parent
!= NULL
; parent
++)
8050 char *error_message
= NULL
;
8051 bfd_reloc_status_type r
;
8053 /* Specific to MIPS: Deal with relocation types that require
8054 knowing the gp of the output bfd. */
8055 asymbol
*sym
= *(*parent
)->sym_ptr_ptr
;
8056 if (bfd_is_abs_section (sym
->section
) && abfd
)
8058 /* The special_function wouldn't get called anyway. */
8062 /* The gp isn't there; let the special function code
8063 fall over on its own. */
8065 else if ((*parent
)->howto
->special_function
8066 == _bfd_mips_elf32_gprel16_reloc
)
8068 /* bypass special_function call */
8069 r
= _bfd_mips_elf_gprel16_with_gp (input_bfd
, sym
, *parent
,
8070 input_section
, relocatable
,
8072 goto skip_bfd_perform_relocation
;
8074 /* end mips specific stuff */
8076 r
= bfd_perform_relocation (input_bfd
, *parent
, data
, input_section
,
8077 relocatable
? abfd
: NULL
,
8079 skip_bfd_perform_relocation
:
8083 asection
*os
= input_section
->output_section
;
8085 /* A partial link, so keep the relocs */
8086 os
->orelocation
[os
->reloc_count
] = *parent
;
8090 if (r
!= bfd_reloc_ok
)
8094 case bfd_reloc_undefined
:
8095 if (!((*link_info
->callbacks
->undefined_symbol
)
8096 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
8097 input_bfd
, input_section
, (*parent
)->address
,
8101 case bfd_reloc_dangerous
:
8102 BFD_ASSERT (error_message
!= NULL
);
8103 if (!((*link_info
->callbacks
->reloc_dangerous
)
8104 (link_info
, error_message
, input_bfd
, input_section
,
8105 (*parent
)->address
)))
8108 case bfd_reloc_overflow
:
8109 if (!((*link_info
->callbacks
->reloc_overflow
)
8110 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
8111 (*parent
)->howto
->name
, (*parent
)->addend
,
8112 input_bfd
, input_section
, (*parent
)->address
)))
8115 case bfd_reloc_outofrange
:
8124 if (reloc_vector
!= NULL
)
8125 free (reloc_vector
);
8129 if (reloc_vector
!= NULL
)
8130 free (reloc_vector
);
8134 /* Create a MIPS ELF linker hash table. */
8136 struct bfd_link_hash_table
*
8137 _bfd_mips_elf_link_hash_table_create (bfd
*abfd
)
8139 struct mips_elf_link_hash_table
*ret
;
8140 bfd_size_type amt
= sizeof (struct mips_elf_link_hash_table
);
8142 ret
= bfd_malloc (amt
);
8146 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
8147 mips_elf_link_hash_newfunc
))
8154 /* We no longer use this. */
8155 for (i
= 0; i
< SIZEOF_MIPS_DYNSYM_SECNAMES
; i
++)
8156 ret
->dynsym_sec_strindex
[i
] = (bfd_size_type
) -1;
8158 ret
->procedure_count
= 0;
8159 ret
->compact_rel_size
= 0;
8160 ret
->use_rld_obj_head
= FALSE
;
8162 ret
->mips16_stubs_seen
= FALSE
;
8164 return &ret
->root
.root
;
8167 /* We need to use a special link routine to handle the .reginfo and
8168 the .mdebug sections. We need to merge all instances of these
8169 sections together, not write them all out sequentially. */
8172 _bfd_mips_elf_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
8176 struct bfd_link_order
*p
;
8177 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
8178 asection
*rtproc_sec
;
8179 Elf32_RegInfo reginfo
;
8180 struct ecoff_debug_info debug
;
8181 const struct ecoff_debug_swap
*swap
8182 = get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
8183 HDRR
*symhdr
= &debug
.symbolic_header
;
8184 void *mdebug_handle
= NULL
;
8190 static const char * const secname
[] =
8192 ".text", ".init", ".fini", ".data",
8193 ".rodata", ".sdata", ".sbss", ".bss"
8195 static const int sc
[] =
8197 scText
, scInit
, scFini
, scData
,
8198 scRData
, scSData
, scSBss
, scBss
8201 /* We'd carefully arranged the dynamic symbol indices, and then the
8202 generic size_dynamic_sections renumbered them out from under us.
8203 Rather than trying somehow to prevent the renumbering, just do
8205 if (elf_hash_table (info
)->dynamic_sections_created
)
8209 struct mips_got_info
*g
;
8211 /* When we resort, we must tell mips_elf_sort_hash_table what
8212 the lowest index it may use is. That's the number of section
8213 symbols we're going to add. The generic ELF linker only
8214 adds these symbols when building a shared object. Note that
8215 we count the sections after (possibly) removing the .options
8217 if (! mips_elf_sort_hash_table (info
, (info
->shared
8218 ? bfd_count_sections (abfd
) + 1
8222 /* Make sure we didn't grow the global .got region. */
8223 dynobj
= elf_hash_table (info
)->dynobj
;
8224 got
= mips_elf_got_section (dynobj
, FALSE
);
8225 g
= mips_elf_section_data (got
)->u
.got_info
;
8227 if (g
->global_gotsym
!= NULL
)
8228 BFD_ASSERT ((elf_hash_table (info
)->dynsymcount
8229 - g
->global_gotsym
->dynindx
)
8230 <= g
->global_gotno
);
8234 /* We want to set the GP value for ld -r. */
8235 /* On IRIX5, we omit the .options section. On IRIX6, however, we
8236 include it, even though we don't process it quite right. (Some
8237 entries are supposed to be merged.) Empirically, we seem to be
8238 better off including it then not. */
8239 if (IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
8240 for (secpp
= &abfd
->sections
; *secpp
!= NULL
; secpp
= &(*secpp
)->next
)
8242 if (strcmp ((*secpp
)->name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
8244 for (p
= (*secpp
)->link_order_head
; p
!= NULL
; p
= p
->next
)
8245 if (p
->type
== bfd_indirect_link_order
)
8246 p
->u
.indirect
.section
->flags
&= ~SEC_HAS_CONTENTS
;
8247 (*secpp
)->link_order_head
= NULL
;
8248 bfd_section_list_remove (abfd
, secpp
);
8249 --abfd
->section_count
;
8255 /* We include .MIPS.options, even though we don't process it quite right.
8256 (Some entries are supposed to be merged.) At IRIX6 empirically we seem
8257 to be better off including it than not. */
8258 for (secpp
= &abfd
->sections
; *secpp
!= NULL
; secpp
= &(*secpp
)->next
)
8260 if (strcmp ((*secpp
)->name
, ".MIPS.options") == 0)
8262 for (p
= (*secpp
)->link_order_head
; p
!= NULL
; p
= p
->next
)
8263 if (p
->type
== bfd_indirect_link_order
)
8264 p
->u
.indirect
.section
->flags
&=~ SEC_HAS_CONTENTS
;
8265 (*secpp
)->link_order_head
= NULL
;
8266 bfd_section_list_remove (abfd
, secpp
);
8267 --abfd
->section_count
;
8274 /* Get a value for the GP register. */
8275 if (elf_gp (abfd
) == 0)
8277 struct bfd_link_hash_entry
*h
;
8279 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
8280 if (h
!= NULL
&& h
->type
== bfd_link_hash_defined
)
8281 elf_gp (abfd
) = (h
->u
.def
.value
8282 + h
->u
.def
.section
->output_section
->vma
8283 + h
->u
.def
.section
->output_offset
);
8284 else if (info
->relocatable
)
8286 bfd_vma lo
= MINUS_ONE
;
8288 /* Find the GP-relative section with the lowest offset. */
8289 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
8291 && (elf_section_data (o
)->this_hdr
.sh_flags
& SHF_MIPS_GPREL
))
8294 /* And calculate GP relative to that. */
8295 elf_gp (abfd
) = lo
+ ELF_MIPS_GP_OFFSET (abfd
);
8299 /* If the relocate_section function needs to do a reloc
8300 involving the GP value, it should make a reloc_dangerous
8301 callback to warn that GP is not defined. */
8305 /* Go through the sections and collect the .reginfo and .mdebug
8309 gptab_data_sec
= NULL
;
8310 gptab_bss_sec
= NULL
;
8311 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
8313 if (strcmp (o
->name
, ".reginfo") == 0)
8315 memset (®info
, 0, sizeof reginfo
);
8317 /* We have found the .reginfo section in the output file.
8318 Look through all the link_orders comprising it and merge
8319 the information together. */
8320 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8322 asection
*input_section
;
8324 Elf32_External_RegInfo ext
;
8327 if (p
->type
!= bfd_indirect_link_order
)
8329 if (p
->type
== bfd_data_link_order
)
8334 input_section
= p
->u
.indirect
.section
;
8335 input_bfd
= input_section
->owner
;
8337 /* The linker emulation code has probably clobbered the
8338 size to be zero bytes. */
8339 if (input_section
->_raw_size
== 0)
8340 input_section
->_raw_size
= sizeof (Elf32_External_RegInfo
);
8342 if (! bfd_get_section_contents (input_bfd
, input_section
,
8343 &ext
, 0, sizeof ext
))
8346 bfd_mips_elf32_swap_reginfo_in (input_bfd
, &ext
, &sub
);
8348 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
8349 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
8350 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
8351 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
8352 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
8354 /* ri_gp_value is set by the function
8355 mips_elf32_section_processing when the section is
8356 finally written out. */
8358 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8359 elf_link_input_bfd ignores this section. */
8360 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8363 /* Size has been set in _bfd_mips_elf_always_size_sections. */
8364 BFD_ASSERT(o
->_raw_size
== sizeof (Elf32_External_RegInfo
));
8366 /* Skip this section later on (I don't think this currently
8367 matters, but someday it might). */
8368 o
->link_order_head
= NULL
;
8373 if (strcmp (o
->name
, ".mdebug") == 0)
8375 struct extsym_info einfo
;
8378 /* We have found the .mdebug section in the output file.
8379 Look through all the link_orders comprising it and merge
8380 the information together. */
8381 symhdr
->magic
= swap
->sym_magic
;
8382 /* FIXME: What should the version stamp be? */
8384 symhdr
->ilineMax
= 0;
8388 symhdr
->isymMax
= 0;
8389 symhdr
->ioptMax
= 0;
8390 symhdr
->iauxMax
= 0;
8392 symhdr
->issExtMax
= 0;
8395 symhdr
->iextMax
= 0;
8397 /* We accumulate the debugging information itself in the
8398 debug_info structure. */
8400 debug
.external_dnr
= NULL
;
8401 debug
.external_pdr
= NULL
;
8402 debug
.external_sym
= NULL
;
8403 debug
.external_opt
= NULL
;
8404 debug
.external_aux
= NULL
;
8406 debug
.ssext
= debug
.ssext_end
= NULL
;
8407 debug
.external_fdr
= NULL
;
8408 debug
.external_rfd
= NULL
;
8409 debug
.external_ext
= debug
.external_ext_end
= NULL
;
8411 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
8412 if (mdebug_handle
== NULL
)
8416 esym
.cobol_main
= 0;
8420 esym
.asym
.iss
= issNil
;
8421 esym
.asym
.st
= stLocal
;
8422 esym
.asym
.reserved
= 0;
8423 esym
.asym
.index
= indexNil
;
8425 for (i
= 0; i
< sizeof (secname
) / sizeof (secname
[0]); i
++)
8427 esym
.asym
.sc
= sc
[i
];
8428 s
= bfd_get_section_by_name (abfd
, secname
[i
]);
8431 esym
.asym
.value
= s
->vma
;
8432 last
= s
->vma
+ s
->_raw_size
;
8435 esym
.asym
.value
= last
;
8436 if (!bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
8441 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8443 asection
*input_section
;
8445 const struct ecoff_debug_swap
*input_swap
;
8446 struct ecoff_debug_info input_debug
;
8450 if (p
->type
!= bfd_indirect_link_order
)
8452 if (p
->type
== bfd_data_link_order
)
8457 input_section
= p
->u
.indirect
.section
;
8458 input_bfd
= input_section
->owner
;
8460 if (bfd_get_flavour (input_bfd
) != bfd_target_elf_flavour
8461 || (get_elf_backend_data (input_bfd
)
8462 ->elf_backend_ecoff_debug_swap
) == NULL
)
8464 /* I don't know what a non MIPS ELF bfd would be
8465 doing with a .mdebug section, but I don't really
8466 want to deal with it. */
8470 input_swap
= (get_elf_backend_data (input_bfd
)
8471 ->elf_backend_ecoff_debug_swap
);
8473 BFD_ASSERT (p
->size
== input_section
->_raw_size
);
8475 /* The ECOFF linking code expects that we have already
8476 read in the debugging information and set up an
8477 ecoff_debug_info structure, so we do that now. */
8478 if (! _bfd_mips_elf_read_ecoff_info (input_bfd
, input_section
,
8482 if (! (bfd_ecoff_debug_accumulate
8483 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
8484 &input_debug
, input_swap
, info
)))
8487 /* Loop through the external symbols. For each one with
8488 interesting information, try to find the symbol in
8489 the linker global hash table and save the information
8490 for the output external symbols. */
8491 eraw_src
= input_debug
.external_ext
;
8492 eraw_end
= (eraw_src
8493 + (input_debug
.symbolic_header
.iextMax
8494 * input_swap
->external_ext_size
));
8496 eraw_src
< eraw_end
;
8497 eraw_src
+= input_swap
->external_ext_size
)
8501 struct mips_elf_link_hash_entry
*h
;
8503 (*input_swap
->swap_ext_in
) (input_bfd
, eraw_src
, &ext
);
8504 if (ext
.asym
.sc
== scNil
8505 || ext
.asym
.sc
== scUndefined
8506 || ext
.asym
.sc
== scSUndefined
)
8509 name
= input_debug
.ssext
+ ext
.asym
.iss
;
8510 h
= mips_elf_link_hash_lookup (mips_elf_hash_table (info
),
8511 name
, FALSE
, FALSE
, TRUE
);
8512 if (h
== NULL
|| h
->esym
.ifd
!= -2)
8518 < input_debug
.symbolic_header
.ifdMax
);
8519 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
8525 /* Free up the information we just read. */
8526 free (input_debug
.line
);
8527 free (input_debug
.external_dnr
);
8528 free (input_debug
.external_pdr
);
8529 free (input_debug
.external_sym
);
8530 free (input_debug
.external_opt
);
8531 free (input_debug
.external_aux
);
8532 free (input_debug
.ss
);
8533 free (input_debug
.ssext
);
8534 free (input_debug
.external_fdr
);
8535 free (input_debug
.external_rfd
);
8536 free (input_debug
.external_ext
);
8538 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8539 elf_link_input_bfd ignores this section. */
8540 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8543 if (SGI_COMPAT (abfd
) && info
->shared
)
8545 /* Create .rtproc section. */
8546 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
8547 if (rtproc_sec
== NULL
)
8549 flagword flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
8550 | SEC_LINKER_CREATED
| SEC_READONLY
);
8552 rtproc_sec
= bfd_make_section (abfd
, ".rtproc");
8553 if (rtproc_sec
== NULL
8554 || ! bfd_set_section_flags (abfd
, rtproc_sec
, flags
)
8555 || ! bfd_set_section_alignment (abfd
, rtproc_sec
, 4))
8559 if (! mips_elf_create_procedure_table (mdebug_handle
, abfd
,
8565 /* Build the external symbol information. */
8568 einfo
.debug
= &debug
;
8570 einfo
.failed
= FALSE
;
8571 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
8572 mips_elf_output_extsym
, &einfo
);
8576 /* Set the size of the .mdebug section. */
8577 o
->_raw_size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
8579 /* Skip this section later on (I don't think this currently
8580 matters, but someday it might). */
8581 o
->link_order_head
= NULL
;
8586 if (strncmp (o
->name
, ".gptab.", sizeof ".gptab." - 1) == 0)
8588 const char *subname
;
8591 Elf32_External_gptab
*ext_tab
;
8594 /* The .gptab.sdata and .gptab.sbss sections hold
8595 information describing how the small data area would
8596 change depending upon the -G switch. These sections
8597 not used in executables files. */
8598 if (! info
->relocatable
)
8600 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8602 asection
*input_section
;
8604 if (p
->type
!= bfd_indirect_link_order
)
8606 if (p
->type
== bfd_data_link_order
)
8611 input_section
= p
->u
.indirect
.section
;
8613 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8614 elf_link_input_bfd ignores this section. */
8615 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8618 /* Skip this section later on (I don't think this
8619 currently matters, but someday it might). */
8620 o
->link_order_head
= NULL
;
8622 /* Really remove the section. */
8623 for (secpp
= &abfd
->sections
;
8625 secpp
= &(*secpp
)->next
)
8627 bfd_section_list_remove (abfd
, secpp
);
8628 --abfd
->section_count
;
8633 /* There is one gptab for initialized data, and one for
8634 uninitialized data. */
8635 if (strcmp (o
->name
, ".gptab.sdata") == 0)
8637 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
8641 (*_bfd_error_handler
)
8642 (_("%s: illegal section name `%s'"),
8643 bfd_get_filename (abfd
), o
->name
);
8644 bfd_set_error (bfd_error_nonrepresentable_section
);
8648 /* The linker script always combines .gptab.data and
8649 .gptab.sdata into .gptab.sdata, and likewise for
8650 .gptab.bss and .gptab.sbss. It is possible that there is
8651 no .sdata or .sbss section in the output file, in which
8652 case we must change the name of the output section. */
8653 subname
= o
->name
+ sizeof ".gptab" - 1;
8654 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
8656 if (o
== gptab_data_sec
)
8657 o
->name
= ".gptab.data";
8659 o
->name
= ".gptab.bss";
8660 subname
= o
->name
+ sizeof ".gptab" - 1;
8661 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
8664 /* Set up the first entry. */
8666 amt
= c
* sizeof (Elf32_gptab
);
8667 tab
= bfd_malloc (amt
);
8670 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
8671 tab
[0].gt_header
.gt_unused
= 0;
8673 /* Combine the input sections. */
8674 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8676 asection
*input_section
;
8680 bfd_size_type gpentry
;
8682 if (p
->type
!= bfd_indirect_link_order
)
8684 if (p
->type
== bfd_data_link_order
)
8689 input_section
= p
->u
.indirect
.section
;
8690 input_bfd
= input_section
->owner
;
8692 /* Combine the gptab entries for this input section one
8693 by one. We know that the input gptab entries are
8694 sorted by ascending -G value. */
8695 size
= bfd_section_size (input_bfd
, input_section
);
8697 for (gpentry
= sizeof (Elf32_External_gptab
);
8699 gpentry
+= sizeof (Elf32_External_gptab
))
8701 Elf32_External_gptab ext_gptab
;
8702 Elf32_gptab int_gptab
;
8708 if (! (bfd_get_section_contents
8709 (input_bfd
, input_section
, &ext_gptab
, gpentry
,
8710 sizeof (Elf32_External_gptab
))))
8716 bfd_mips_elf32_swap_gptab_in (input_bfd
, &ext_gptab
,
8718 val
= int_gptab
.gt_entry
.gt_g_value
;
8719 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
8722 for (look
= 1; look
< c
; look
++)
8724 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
8725 tab
[look
].gt_entry
.gt_bytes
+= add
;
8727 if (tab
[look
].gt_entry
.gt_g_value
== val
)
8733 Elf32_gptab
*new_tab
;
8736 /* We need a new table entry. */
8737 amt
= (bfd_size_type
) (c
+ 1) * sizeof (Elf32_gptab
);
8738 new_tab
= bfd_realloc (tab
, amt
);
8739 if (new_tab
== NULL
)
8745 tab
[c
].gt_entry
.gt_g_value
= val
;
8746 tab
[c
].gt_entry
.gt_bytes
= add
;
8748 /* Merge in the size for the next smallest -G
8749 value, since that will be implied by this new
8752 for (look
= 1; look
< c
; look
++)
8754 if (tab
[look
].gt_entry
.gt_g_value
< val
8756 || (tab
[look
].gt_entry
.gt_g_value
8757 > tab
[max
].gt_entry
.gt_g_value
)))
8761 tab
[c
].gt_entry
.gt_bytes
+=
8762 tab
[max
].gt_entry
.gt_bytes
;
8767 last
= int_gptab
.gt_entry
.gt_bytes
;
8770 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8771 elf_link_input_bfd ignores this section. */
8772 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8775 /* The table must be sorted by -G value. */
8777 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
8779 /* Swap out the table. */
8780 amt
= (bfd_size_type
) c
* sizeof (Elf32_External_gptab
);
8781 ext_tab
= bfd_alloc (abfd
, amt
);
8782 if (ext_tab
== NULL
)
8788 for (j
= 0; j
< c
; j
++)
8789 bfd_mips_elf32_swap_gptab_out (abfd
, tab
+ j
, ext_tab
+ j
);
8792 o
->_raw_size
= c
* sizeof (Elf32_External_gptab
);
8793 o
->contents
= (bfd_byte
*) ext_tab
;
8795 /* Skip this section later on (I don't think this currently
8796 matters, but someday it might). */
8797 o
->link_order_head
= NULL
;
8801 /* Invoke the regular ELF backend linker to do all the work. */
8802 if (!MNAME(abfd
,bfd_elf
,bfd_final_link
) (abfd
, info
))
8805 /* Now write out the computed sections. */
8807 if (reginfo_sec
!= NULL
)
8809 Elf32_External_RegInfo ext
;
8811 bfd_mips_elf32_swap_reginfo_out (abfd
, ®info
, &ext
);
8812 if (! bfd_set_section_contents (abfd
, reginfo_sec
, &ext
, 0, sizeof ext
))
8816 if (mdebug_sec
!= NULL
)
8818 BFD_ASSERT (abfd
->output_has_begun
);
8819 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
8821 mdebug_sec
->filepos
))
8824 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
8827 if (gptab_data_sec
!= NULL
)
8829 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
8830 gptab_data_sec
->contents
,
8831 0, gptab_data_sec
->_raw_size
))
8835 if (gptab_bss_sec
!= NULL
)
8837 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
8838 gptab_bss_sec
->contents
,
8839 0, gptab_bss_sec
->_raw_size
))
8843 if (SGI_COMPAT (abfd
))
8845 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
8846 if (rtproc_sec
!= NULL
)
8848 if (! bfd_set_section_contents (abfd
, rtproc_sec
,
8849 rtproc_sec
->contents
,
8850 0, rtproc_sec
->_raw_size
))
8858 /* Structure for saying that BFD machine EXTENSION extends BASE. */
8860 struct mips_mach_extension
{
8861 unsigned long extension
, base
;
8865 /* An array describing how BFD machines relate to one another. The entries
8866 are ordered topologically with MIPS I extensions listed last. */
8868 static const struct mips_mach_extension mips_mach_extensions
[] = {
8869 /* MIPS64 extensions. */
8870 { bfd_mach_mipsisa64r2
, bfd_mach_mipsisa64
},
8871 { bfd_mach_mips_sb1
, bfd_mach_mipsisa64
},
8873 /* MIPS V extensions. */
8874 { bfd_mach_mipsisa64
, bfd_mach_mips5
},
8876 /* R10000 extensions. */
8877 { bfd_mach_mips12000
, bfd_mach_mips10000
},
8879 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
8880 vr5400 ISA, but doesn't include the multimedia stuff. It seems
8881 better to allow vr5400 and vr5500 code to be merged anyway, since
8882 many libraries will just use the core ISA. Perhaps we could add
8883 some sort of ASE flag if this ever proves a problem. */
8884 { bfd_mach_mips5500
, bfd_mach_mips5400
},
8885 { bfd_mach_mips5400
, bfd_mach_mips5000
},
8887 /* MIPS IV extensions. */
8888 { bfd_mach_mips5
, bfd_mach_mips8000
},
8889 { bfd_mach_mips10000
, bfd_mach_mips8000
},
8890 { bfd_mach_mips5000
, bfd_mach_mips8000
},
8891 { bfd_mach_mips7000
, bfd_mach_mips8000
},
8893 /* VR4100 extensions. */
8894 { bfd_mach_mips4120
, bfd_mach_mips4100
},
8895 { bfd_mach_mips4111
, bfd_mach_mips4100
},
8897 /* MIPS III extensions. */
8898 { bfd_mach_mips8000
, bfd_mach_mips4000
},
8899 { bfd_mach_mips4650
, bfd_mach_mips4000
},
8900 { bfd_mach_mips4600
, bfd_mach_mips4000
},
8901 { bfd_mach_mips4400
, bfd_mach_mips4000
},
8902 { bfd_mach_mips4300
, bfd_mach_mips4000
},
8903 { bfd_mach_mips4100
, bfd_mach_mips4000
},
8904 { bfd_mach_mips4010
, bfd_mach_mips4000
},
8906 /* MIPS32 extensions. */
8907 { bfd_mach_mipsisa32r2
, bfd_mach_mipsisa32
},
8909 /* MIPS II extensions. */
8910 { bfd_mach_mips4000
, bfd_mach_mips6000
},
8911 { bfd_mach_mipsisa32
, bfd_mach_mips6000
},
8913 /* MIPS I extensions. */
8914 { bfd_mach_mips6000
, bfd_mach_mips3000
},
8915 { bfd_mach_mips3900
, bfd_mach_mips3000
}
8919 /* Return true if bfd machine EXTENSION is an extension of machine BASE. */
8922 mips_mach_extends_p (unsigned long base
, unsigned long extension
)
8926 for (i
= 0; extension
!= base
&& i
< ARRAY_SIZE (mips_mach_extensions
); i
++)
8927 if (extension
== mips_mach_extensions
[i
].extension
)
8928 extension
= mips_mach_extensions
[i
].base
;
8930 return extension
== base
;
8934 /* Return true if the given ELF header flags describe a 32-bit binary. */
8937 mips_32bit_flags_p (flagword flags
)
8939 return ((flags
& EF_MIPS_32BITMODE
) != 0
8940 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
8941 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
8942 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
8943 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
8944 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
8945 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
);
8949 /* Merge backend specific data from an object file to the output
8950 object file when linking. */
8953 _bfd_mips_elf_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
8958 bfd_boolean null_input_bfd
= TRUE
;
8961 /* Check if we have the same endianess */
8962 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
8964 (*_bfd_error_handler
)
8965 (_("%s: endianness incompatible with that of the selected emulation"),
8966 bfd_archive_filename (ibfd
));
8970 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
8971 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
8974 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
8976 (*_bfd_error_handler
)
8977 (_("%s: ABI is incompatible with that of the selected emulation"),
8978 bfd_archive_filename (ibfd
));
8982 new_flags
= elf_elfheader (ibfd
)->e_flags
;
8983 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_NOREORDER
;
8984 old_flags
= elf_elfheader (obfd
)->e_flags
;
8986 if (! elf_flags_init (obfd
))
8988 elf_flags_init (obfd
) = TRUE
;
8989 elf_elfheader (obfd
)->e_flags
= new_flags
;
8990 elf_elfheader (obfd
)->e_ident
[EI_CLASS
]
8991 = elf_elfheader (ibfd
)->e_ident
[EI_CLASS
];
8993 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
8994 && bfd_get_arch_info (obfd
)->the_default
)
8996 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
8997 bfd_get_mach (ibfd
)))
9004 /* Check flag compatibility. */
9006 new_flags
&= ~EF_MIPS_NOREORDER
;
9007 old_flags
&= ~EF_MIPS_NOREORDER
;
9009 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
9010 doesn't seem to matter. */
9011 new_flags
&= ~EF_MIPS_XGOT
;
9012 old_flags
&= ~EF_MIPS_XGOT
;
9014 /* MIPSpro generates ucode info in n64 objects. Again, we should
9015 just be able to ignore this. */
9016 new_flags
&= ~EF_MIPS_UCODE
;
9017 old_flags
&= ~EF_MIPS_UCODE
;
9019 if (new_flags
== old_flags
)
9022 /* Check to see if the input BFD actually contains any sections.
9023 If not, its flags may not have been initialised either, but it cannot
9024 actually cause any incompatibility. */
9025 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
9027 /* Ignore synthetic sections and empty .text, .data and .bss sections
9028 which are automatically generated by gas. */
9029 if (strcmp (sec
->name
, ".reginfo")
9030 && strcmp (sec
->name
, ".mdebug")
9031 && (sec
->_raw_size
!= 0
9032 || (strcmp (sec
->name
, ".text")
9033 && strcmp (sec
->name
, ".data")
9034 && strcmp (sec
->name
, ".bss"))))
9036 null_input_bfd
= FALSE
;
9045 if (((new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0)
9046 != ((old_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0))
9048 (*_bfd_error_handler
)
9049 (_("%s: warning: linking PIC files with non-PIC files"),
9050 bfd_archive_filename (ibfd
));
9054 if (new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
))
9055 elf_elfheader (obfd
)->e_flags
|= EF_MIPS_CPIC
;
9056 if (! (new_flags
& EF_MIPS_PIC
))
9057 elf_elfheader (obfd
)->e_flags
&= ~EF_MIPS_PIC
;
9059 new_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
9060 old_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
9062 /* Compare the ISAs. */
9063 if (mips_32bit_flags_p (old_flags
) != mips_32bit_flags_p (new_flags
))
9065 (*_bfd_error_handler
)
9066 (_("%s: linking 32-bit code with 64-bit code"),
9067 bfd_archive_filename (ibfd
));
9070 else if (!mips_mach_extends_p (bfd_get_mach (ibfd
), bfd_get_mach (obfd
)))
9072 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
9073 if (mips_mach_extends_p (bfd_get_mach (obfd
), bfd_get_mach (ibfd
)))
9075 /* Copy the architecture info from IBFD to OBFD. Also copy
9076 the 32-bit flag (if set) so that we continue to recognise
9077 OBFD as a 32-bit binary. */
9078 bfd_set_arch_info (obfd
, bfd_get_arch_info (ibfd
));
9079 elf_elfheader (obfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
9080 elf_elfheader (obfd
)->e_flags
9081 |= new_flags
& (EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9083 /* Copy across the ABI flags if OBFD doesn't use them
9084 and if that was what caused us to treat IBFD as 32-bit. */
9085 if ((old_flags
& EF_MIPS_ABI
) == 0
9086 && mips_32bit_flags_p (new_flags
)
9087 && !mips_32bit_flags_p (new_flags
& ~EF_MIPS_ABI
))
9088 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ABI
;
9092 /* The ISAs aren't compatible. */
9093 (*_bfd_error_handler
)
9094 (_("%s: linking %s module with previous %s modules"),
9095 bfd_archive_filename (ibfd
),
9096 bfd_printable_name (ibfd
),
9097 bfd_printable_name (obfd
));
9102 new_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9103 old_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9105 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
9106 does set EI_CLASS differently from any 32-bit ABI. */
9107 if ((new_flags
& EF_MIPS_ABI
) != (old_flags
& EF_MIPS_ABI
)
9108 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
9109 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
9111 /* Only error if both are set (to different values). */
9112 if (((new_flags
& EF_MIPS_ABI
) && (old_flags
& EF_MIPS_ABI
))
9113 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
9114 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
9116 (*_bfd_error_handler
)
9117 (_("%s: ABI mismatch: linking %s module with previous %s modules"),
9118 bfd_archive_filename (ibfd
),
9119 elf_mips_abi_name (ibfd
),
9120 elf_mips_abi_name (obfd
));
9123 new_flags
&= ~EF_MIPS_ABI
;
9124 old_flags
&= ~EF_MIPS_ABI
;
9127 /* For now, allow arbitrary mixing of ASEs (retain the union). */
9128 if ((new_flags
& EF_MIPS_ARCH_ASE
) != (old_flags
& EF_MIPS_ARCH_ASE
))
9130 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ARCH_ASE
;
9132 new_flags
&= ~ EF_MIPS_ARCH_ASE
;
9133 old_flags
&= ~ EF_MIPS_ARCH_ASE
;
9136 /* Warn about any other mismatches */
9137 if (new_flags
!= old_flags
)
9139 (*_bfd_error_handler
)
9140 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
9141 bfd_archive_filename (ibfd
), (unsigned long) new_flags
,
9142 (unsigned long) old_flags
);
9148 bfd_set_error (bfd_error_bad_value
);
9155 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
9158 _bfd_mips_elf_set_private_flags (bfd
*abfd
, flagword flags
)
9160 BFD_ASSERT (!elf_flags_init (abfd
)
9161 || elf_elfheader (abfd
)->e_flags
== flags
);
9163 elf_elfheader (abfd
)->e_flags
= flags
;
9164 elf_flags_init (abfd
) = TRUE
;
9169 _bfd_mips_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
9173 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
9175 /* Print normal ELF private data. */
9176 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
9178 /* xgettext:c-format */
9179 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
9181 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
)
9182 fprintf (file
, _(" [abi=O32]"));
9183 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O64
)
9184 fprintf (file
, _(" [abi=O64]"));
9185 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
)
9186 fprintf (file
, _(" [abi=EABI32]"));
9187 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
9188 fprintf (file
, _(" [abi=EABI64]"));
9189 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
))
9190 fprintf (file
, _(" [abi unknown]"));
9191 else if (ABI_N32_P (abfd
))
9192 fprintf (file
, _(" [abi=N32]"));
9193 else if (ABI_64_P (abfd
))
9194 fprintf (file
, _(" [abi=64]"));
9196 fprintf (file
, _(" [no abi set]"));
9198 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
9199 fprintf (file
, _(" [mips1]"));
9200 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
9201 fprintf (file
, _(" [mips2]"));
9202 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
9203 fprintf (file
, _(" [mips3]"));
9204 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
9205 fprintf (file
, _(" [mips4]"));
9206 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_5
)
9207 fprintf (file
, _(" [mips5]"));
9208 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
)
9209 fprintf (file
, _(" [mips32]"));
9210 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64
)
9211 fprintf (file
, _(" [mips64]"));
9212 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
)
9213 fprintf (file
, _(" [mips32r2]"));
9214 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64R2
)
9215 fprintf (file
, _(" [mips64r2]"));
9217 fprintf (file
, _(" [unknown ISA]"));
9219 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
9220 fprintf (file
, _(" [mdmx]"));
9222 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_M16
)
9223 fprintf (file
, _(" [mips16]"));
9225 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_32BITMODE
)
9226 fprintf (file
, _(" [32bitmode]"));
9228 fprintf (file
, _(" [not 32bitmode]"));
9235 struct bfd_elf_special_section
const _bfd_mips_elf_special_sections
[]=
9237 { ".sdata", 6, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9238 { ".sbss", 5, -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9239 { ".lit4", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9240 { ".lit8", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9241 { ".ucode", 6, 0, SHT_MIPS_UCODE
, 0 },
9242 { ".mdebug", 7, 0, SHT_MIPS_DEBUG
, 0 },
9243 { NULL
, 0, 0, 0, 0 }