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. */
567 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
568 _bfd_elf_add_dynamic_entry (info, tag, val)
570 #define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela) \
571 (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela))
573 /* Determine whether the internal relocation of index REL_IDX is REL
574 (zero) or RELA (non-zero). The assumption is that, if there are
575 two relocation sections for this section, one of them is REL and
576 the other is RELA. If the index of the relocation we're testing is
577 in range for the first relocation section, check that the external
578 relocation size is that for RELA. It is also assumed that, if
579 rel_idx is not in range for the first section, and this first
580 section contains REL relocs, then the relocation is in the second
581 section, that is RELA. */
582 #define MIPS_RELOC_RELA_P(abfd, sec, rel_idx) \
583 ((NUM_SHDR_ENTRIES (&elf_section_data (sec)->rel_hdr) \
584 * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel \
585 > (bfd_vma)(rel_idx)) \
586 == (elf_section_data (sec)->rel_hdr.sh_entsize \
587 == (ABI_64_P (abfd) ? sizeof (Elf64_External_Rela) \
588 : sizeof (Elf32_External_Rela))))
590 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
591 from smaller values. Start with zero, widen, *then* decrement. */
592 #define MINUS_ONE (((bfd_vma)0) - 1)
594 /* The number of local .got entries we reserve. */
595 #define MIPS_RESERVED_GOTNO (2)
597 /* The offset of $gp from the beginning of the .got section. */
598 #define ELF_MIPS_GP_OFFSET(abfd) (0x7ff0)
600 /* The maximum size of the GOT for it to be addressable using 16-bit
602 #define MIPS_ELF_GOT_MAX_SIZE(abfd) (ELF_MIPS_GP_OFFSET(abfd) + 0x7fff)
604 /* Instructions which appear in a stub. */
605 #define STUB_LW(abfd) \
607 ? 0xdf998010 /* ld t9,0x8010(gp) */ \
608 : 0x8f998010)) /* lw t9,0x8010(gp) */
609 #define STUB_MOVE(abfd) \
611 ? 0x03e0782d /* daddu t7,ra */ \
612 : 0x03e07821)) /* addu t7,ra */
613 #define STUB_JALR 0x0320f809 /* jalr t9,ra */
614 #define STUB_LI16(abfd) \
616 ? 0x64180000 /* daddiu t8,zero,0 */ \
617 : 0x24180000)) /* addiu t8,zero,0 */
618 #define MIPS_FUNCTION_STUB_SIZE (16)
620 /* The name of the dynamic interpreter. This is put in the .interp
623 #define ELF_DYNAMIC_INTERPRETER(abfd) \
624 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
625 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
626 : "/usr/lib/libc.so.1")
629 #define MNAME(bfd,pre,pos) \
630 (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
631 #define ELF_R_SYM(bfd, i) \
632 (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
633 #define ELF_R_TYPE(bfd, i) \
634 (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
635 #define ELF_R_INFO(bfd, s, t) \
636 (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
638 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
639 #define ELF_R_SYM(bfd, i) \
641 #define ELF_R_TYPE(bfd, i) \
643 #define ELF_R_INFO(bfd, s, t) \
644 (ELF32_R_INFO (s, t))
647 /* The mips16 compiler uses a couple of special sections to handle
648 floating point arguments.
650 Section names that look like .mips16.fn.FNNAME contain stubs that
651 copy floating point arguments from the fp regs to the gp regs and
652 then jump to FNNAME. If any 32 bit function calls FNNAME, the
653 call should be redirected to the stub instead. If no 32 bit
654 function calls FNNAME, the stub should be discarded. We need to
655 consider any reference to the function, not just a call, because
656 if the address of the function is taken we will need the stub,
657 since the address might be passed to a 32 bit function.
659 Section names that look like .mips16.call.FNNAME contain stubs
660 that copy floating point arguments from the gp regs to the fp
661 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
662 then any 16 bit function that calls FNNAME should be redirected
663 to the stub instead. If FNNAME is not a 32 bit function, the
664 stub should be discarded.
666 .mips16.call.fp.FNNAME sections are similar, but contain stubs
667 which call FNNAME and then copy the return value from the fp regs
668 to the gp regs. These stubs store the return value in $18 while
669 calling FNNAME; any function which might call one of these stubs
670 must arrange to save $18 around the call. (This case is not
671 needed for 32 bit functions that call 16 bit functions, because
672 16 bit functions always return floating point values in both
675 Note that in all cases FNNAME might be defined statically.
676 Therefore, FNNAME is not used literally. Instead, the relocation
677 information will indicate which symbol the section is for.
679 We record any stubs that we find in the symbol table. */
681 #define FN_STUB ".mips16.fn."
682 #define CALL_STUB ".mips16.call."
683 #define CALL_FP_STUB ".mips16.call.fp."
685 /* Look up an entry in a MIPS ELF linker hash table. */
687 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
688 ((struct mips_elf_link_hash_entry *) \
689 elf_link_hash_lookup (&(table)->root, (string), (create), \
692 /* Traverse a MIPS ELF linker hash table. */
694 #define mips_elf_link_hash_traverse(table, func, info) \
695 (elf_link_hash_traverse \
697 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
700 /* Get the MIPS ELF linker hash table from a link_info structure. */
702 #define mips_elf_hash_table(p) \
703 ((struct mips_elf_link_hash_table *) ((p)->hash))
705 /* Create an entry in a MIPS ELF linker hash table. */
707 static struct bfd_hash_entry
*
708 mips_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
709 struct bfd_hash_table
*table
, const char *string
)
711 struct mips_elf_link_hash_entry
*ret
=
712 (struct mips_elf_link_hash_entry
*) entry
;
714 /* Allocate the structure if it has not already been allocated by a
717 ret
= bfd_hash_allocate (table
, sizeof (struct mips_elf_link_hash_entry
));
719 return (struct bfd_hash_entry
*) ret
;
721 /* Call the allocation method of the superclass. */
722 ret
= ((struct mips_elf_link_hash_entry
*)
723 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
727 /* Set local fields. */
728 memset (&ret
->esym
, 0, sizeof (EXTR
));
729 /* We use -2 as a marker to indicate that the information has
730 not been set. -1 means there is no associated ifd. */
732 ret
->possibly_dynamic_relocs
= 0;
733 ret
->readonly_reloc
= FALSE
;
734 ret
->no_fn_stub
= FALSE
;
736 ret
->need_fn_stub
= FALSE
;
737 ret
->call_stub
= NULL
;
738 ret
->call_fp_stub
= NULL
;
739 ret
->forced_local
= FALSE
;
742 return (struct bfd_hash_entry
*) ret
;
746 _bfd_mips_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
748 struct _mips_elf_section_data
*sdata
;
749 bfd_size_type amt
= sizeof (*sdata
);
751 sdata
= bfd_zalloc (abfd
, amt
);
754 sec
->used_by_bfd
= sdata
;
756 return _bfd_elf_new_section_hook (abfd
, sec
);
759 /* Read ECOFF debugging information from a .mdebug section into a
760 ecoff_debug_info structure. */
763 _bfd_mips_elf_read_ecoff_info (bfd
*abfd
, asection
*section
,
764 struct ecoff_debug_info
*debug
)
767 const struct ecoff_debug_swap
*swap
;
770 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
771 memset (debug
, 0, sizeof (*debug
));
773 ext_hdr
= bfd_malloc (swap
->external_hdr_size
);
774 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
777 if (! bfd_get_section_contents (abfd
, section
, ext_hdr
, 0,
778 swap
->external_hdr_size
))
781 symhdr
= &debug
->symbolic_header
;
782 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
784 /* The symbolic header contains absolute file offsets and sizes to
786 #define READ(ptr, offset, count, size, type) \
787 if (symhdr->count == 0) \
791 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
792 debug->ptr = bfd_malloc (amt); \
793 if (debug->ptr == NULL) \
795 if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0 \
796 || bfd_bread (debug->ptr, amt, abfd) != amt) \
800 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
801 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, void *);
802 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, void *);
803 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, void *);
804 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, void *);
805 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
807 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
808 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
809 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, void *);
810 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, void *);
811 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, void *);
815 debug
->adjust
= NULL
;
822 if (debug
->line
!= NULL
)
824 if (debug
->external_dnr
!= NULL
)
825 free (debug
->external_dnr
);
826 if (debug
->external_pdr
!= NULL
)
827 free (debug
->external_pdr
);
828 if (debug
->external_sym
!= NULL
)
829 free (debug
->external_sym
);
830 if (debug
->external_opt
!= NULL
)
831 free (debug
->external_opt
);
832 if (debug
->external_aux
!= NULL
)
833 free (debug
->external_aux
);
834 if (debug
->ss
!= NULL
)
836 if (debug
->ssext
!= NULL
)
838 if (debug
->external_fdr
!= NULL
)
839 free (debug
->external_fdr
);
840 if (debug
->external_rfd
!= NULL
)
841 free (debug
->external_rfd
);
842 if (debug
->external_ext
!= NULL
)
843 free (debug
->external_ext
);
847 /* Swap RPDR (runtime procedure table entry) for output. */
850 ecoff_swap_rpdr_out (bfd
*abfd
, const RPDR
*in
, struct rpdr_ext
*ex
)
852 H_PUT_S32 (abfd
, in
->adr
, ex
->p_adr
);
853 H_PUT_32 (abfd
, in
->regmask
, ex
->p_regmask
);
854 H_PUT_32 (abfd
, in
->regoffset
, ex
->p_regoffset
);
855 H_PUT_32 (abfd
, in
->fregmask
, ex
->p_fregmask
);
856 H_PUT_32 (abfd
, in
->fregoffset
, ex
->p_fregoffset
);
857 H_PUT_32 (abfd
, in
->frameoffset
, ex
->p_frameoffset
);
859 H_PUT_16 (abfd
, in
->framereg
, ex
->p_framereg
);
860 H_PUT_16 (abfd
, in
->pcreg
, ex
->p_pcreg
);
862 H_PUT_32 (abfd
, in
->irpss
, ex
->p_irpss
);
864 H_PUT_S32 (abfd
, in
->exception_info
, ex
->p_exception_info
);
868 /* Create a runtime procedure table from the .mdebug section. */
871 mips_elf_create_procedure_table (void *handle
, bfd
*abfd
,
872 struct bfd_link_info
*info
, asection
*s
,
873 struct ecoff_debug_info
*debug
)
875 const struct ecoff_debug_swap
*swap
;
876 HDRR
*hdr
= &debug
->symbolic_header
;
878 struct rpdr_ext
*erp
;
880 struct pdr_ext
*epdr
;
881 struct sym_ext
*esym
;
886 unsigned long sindex
;
890 const char *no_name_func
= _("static procedure (no name)");
898 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
900 sindex
= strlen (no_name_func
) + 1;
904 size
= swap
->external_pdr_size
;
906 epdr
= bfd_malloc (size
* count
);
910 if (! _bfd_ecoff_get_accumulated_pdr (handle
, (bfd_byte
*) epdr
))
913 size
= sizeof (RPDR
);
914 rp
= rpdr
= bfd_malloc (size
* count
);
918 size
= sizeof (char *);
919 sv
= bfd_malloc (size
* count
);
923 count
= hdr
->isymMax
;
924 size
= swap
->external_sym_size
;
925 esym
= bfd_malloc (size
* count
);
929 if (! _bfd_ecoff_get_accumulated_sym (handle
, (bfd_byte
*) esym
))
933 ss
= bfd_malloc (count
);
936 if (! _bfd_ecoff_get_accumulated_ss (handle
, ss
))
940 for (i
= 0; i
< (unsigned long) count
; i
++, rp
++)
942 (*swap
->swap_pdr_in
) (abfd
, epdr
+ i
, &pdr
);
943 (*swap
->swap_sym_in
) (abfd
, &esym
[pdr
.isym
], &sym
);
945 rp
->regmask
= pdr
.regmask
;
946 rp
->regoffset
= pdr
.regoffset
;
947 rp
->fregmask
= pdr
.fregmask
;
948 rp
->fregoffset
= pdr
.fregoffset
;
949 rp
->frameoffset
= pdr
.frameoffset
;
950 rp
->framereg
= pdr
.framereg
;
951 rp
->pcreg
= pdr
.pcreg
;
953 sv
[i
] = ss
+ sym
.iss
;
954 sindex
+= strlen (sv
[i
]) + 1;
958 size
= sizeof (struct rpdr_ext
) * (count
+ 2) + sindex
;
959 size
= BFD_ALIGN (size
, 16);
960 rtproc
= bfd_alloc (abfd
, size
);
963 mips_elf_hash_table (info
)->procedure_count
= 0;
967 mips_elf_hash_table (info
)->procedure_count
= count
+ 2;
970 memset (erp
, 0, sizeof (struct rpdr_ext
));
972 str
= (char *) rtproc
+ sizeof (struct rpdr_ext
) * (count
+ 2);
973 strcpy (str
, no_name_func
);
974 str
+= strlen (no_name_func
) + 1;
975 for (i
= 0; i
< count
; i
++)
977 ecoff_swap_rpdr_out (abfd
, rpdr
+ i
, erp
+ i
);
979 str
+= strlen (sv
[i
]) + 1;
981 H_PUT_S32 (abfd
, -1, (erp
+ count
)->p_adr
);
983 /* Set the size and contents of .rtproc section. */
985 s
->contents
= rtproc
;
987 /* Skip this section later on (I don't think this currently
988 matters, but someday it might). */
989 s
->link_order_head
= NULL
;
1018 /* Check the mips16 stubs for a particular symbol, and see if we can
1022 mips_elf_check_mips16_stubs (struct mips_elf_link_hash_entry
*h
,
1023 void *data ATTRIBUTE_UNUSED
)
1025 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1026 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1028 if (h
->fn_stub
!= NULL
1029 && ! h
->need_fn_stub
)
1031 /* We don't need the fn_stub; the only references to this symbol
1032 are 16 bit calls. Clobber the size to 0 to prevent it from
1033 being included in the link. */
1034 h
->fn_stub
->_raw_size
= 0;
1035 h
->fn_stub
->_cooked_size
= 0;
1036 h
->fn_stub
->flags
&= ~SEC_RELOC
;
1037 h
->fn_stub
->reloc_count
= 0;
1038 h
->fn_stub
->flags
|= SEC_EXCLUDE
;
1041 if (h
->call_stub
!= NULL
1042 && h
->root
.other
== STO_MIPS16
)
1044 /* We don't need the call_stub; this is a 16 bit function, so
1045 calls from other 16 bit functions are OK. Clobber the size
1046 to 0 to prevent it from being included in the link. */
1047 h
->call_stub
->_raw_size
= 0;
1048 h
->call_stub
->_cooked_size
= 0;
1049 h
->call_stub
->flags
&= ~SEC_RELOC
;
1050 h
->call_stub
->reloc_count
= 0;
1051 h
->call_stub
->flags
|= SEC_EXCLUDE
;
1054 if (h
->call_fp_stub
!= NULL
1055 && h
->root
.other
== STO_MIPS16
)
1057 /* We don't need the call_stub; this is a 16 bit function, so
1058 calls from other 16 bit functions are OK. Clobber the size
1059 to 0 to prevent it from being included in the link. */
1060 h
->call_fp_stub
->_raw_size
= 0;
1061 h
->call_fp_stub
->_cooked_size
= 0;
1062 h
->call_fp_stub
->flags
&= ~SEC_RELOC
;
1063 h
->call_fp_stub
->reloc_count
= 0;
1064 h
->call_fp_stub
->flags
|= SEC_EXCLUDE
;
1070 bfd_reloc_status_type
1071 _bfd_mips_elf_gprel16_with_gp (bfd
*abfd
, asymbol
*symbol
,
1072 arelent
*reloc_entry
, asection
*input_section
,
1073 bfd_boolean relocatable
, void *data
, bfd_vma gp
)
1077 bfd_reloc_status_type status
;
1079 if (bfd_is_com_section (symbol
->section
))
1082 relocation
= symbol
->value
;
1084 relocation
+= symbol
->section
->output_section
->vma
;
1085 relocation
+= symbol
->section
->output_offset
;
1087 if (reloc_entry
->address
> input_section
->_cooked_size
)
1088 return bfd_reloc_outofrange
;
1090 /* Set val to the offset into the section or symbol. */
1091 val
= reloc_entry
->addend
;
1093 _bfd_mips_elf_sign_extend (val
, 16);
1095 /* Adjust val for the final section location and GP value. If we
1096 are producing relocatable output, we don't want to do this for
1097 an external symbol. */
1099 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1100 val
+= relocation
- gp
;
1102 if (reloc_entry
->howto
->partial_inplace
)
1104 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
1106 + reloc_entry
->address
);
1107 if (status
!= bfd_reloc_ok
)
1111 reloc_entry
->addend
= val
;
1114 reloc_entry
->address
+= input_section
->output_offset
;
1116 return bfd_reloc_ok
;
1119 /* Used to store a REL high-part relocation such as R_MIPS_HI16 or
1120 R_MIPS_GOT16. REL is the relocation, INPUT_SECTION is the section
1121 that contains the relocation field and DATA points to the start of
1126 struct mips_hi16
*next
;
1128 asection
*input_section
;
1132 /* FIXME: This should not be a static variable. */
1134 static struct mips_hi16
*mips_hi16_list
;
1136 /* A howto special_function for REL *HI16 relocations. We can only
1137 calculate the correct value once we've seen the partnering
1138 *LO16 relocation, so just save the information for later.
1140 The ABI requires that the *LO16 immediately follow the *HI16.
1141 However, as a GNU extension, we permit an arbitrary number of
1142 *HI16s to be associated with a single *LO16. This significantly
1143 simplies the relocation handling in gcc. */
1145 bfd_reloc_status_type
1146 _bfd_mips_elf_hi16_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
1147 asymbol
*symbol ATTRIBUTE_UNUSED
, void *data
,
1148 asection
*input_section
, bfd
*output_bfd
,
1149 char **error_message ATTRIBUTE_UNUSED
)
1151 struct mips_hi16
*n
;
1153 if (reloc_entry
->address
> input_section
->_cooked_size
)
1154 return bfd_reloc_outofrange
;
1156 n
= bfd_malloc (sizeof *n
);
1158 return bfd_reloc_outofrange
;
1160 n
->next
= mips_hi16_list
;
1162 n
->input_section
= input_section
;
1163 n
->rel
= *reloc_entry
;
1166 if (output_bfd
!= NULL
)
1167 reloc_entry
->address
+= input_section
->output_offset
;
1169 return bfd_reloc_ok
;
1172 /* A howto special_function for REL R_MIPS_GOT16 relocations. This is just
1173 like any other 16-bit relocation when applied to global symbols, but is
1174 treated in the same as R_MIPS_HI16 when applied to local symbols. */
1176 bfd_reloc_status_type
1177 _bfd_mips_elf_got16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1178 void *data
, asection
*input_section
,
1179 bfd
*output_bfd
, char **error_message
)
1181 if ((symbol
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
1182 || bfd_is_und_section (bfd_get_section (symbol
))
1183 || bfd_is_com_section (bfd_get_section (symbol
)))
1184 /* The relocation is against a global symbol. */
1185 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1186 input_section
, output_bfd
,
1189 return _bfd_mips_elf_hi16_reloc (abfd
, reloc_entry
, symbol
, data
,
1190 input_section
, output_bfd
, error_message
);
1193 /* A howto special_function for REL *LO16 relocations. The *LO16 itself
1194 is a straightforward 16 bit inplace relocation, but we must deal with
1195 any partnering high-part relocations as well. */
1197 bfd_reloc_status_type
1198 _bfd_mips_elf_lo16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1199 void *data
, asection
*input_section
,
1200 bfd
*output_bfd
, char **error_message
)
1204 if (reloc_entry
->address
> input_section
->_cooked_size
)
1205 return bfd_reloc_outofrange
;
1207 vallo
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1208 while (mips_hi16_list
!= NULL
)
1210 bfd_reloc_status_type ret
;
1211 struct mips_hi16
*hi
;
1213 hi
= mips_hi16_list
;
1215 /* R_MIPS_GOT16 relocations are something of a special case. We
1216 want to install the addend in the same way as for a R_MIPS_HI16
1217 relocation (with a rightshift of 16). However, since GOT16
1218 relocations can also be used with global symbols, their howto
1219 has a rightshift of 0. */
1220 if (hi
->rel
.howto
->type
== R_MIPS_GOT16
)
1221 hi
->rel
.howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, R_MIPS_HI16
, FALSE
);
1223 /* VALLO is a signed 16-bit number. Bias it by 0x8000 so that any
1224 carry or borrow will induce a change of +1 or -1 in the high part. */
1225 hi
->rel
.addend
+= (vallo
+ 0x8000) & 0xffff;
1227 /* R_MIPS_GNU_REL_HI16 relocations are relative to the address of the
1228 lo16 relocation, not their own address. If we're calculating the
1229 final value, and hence subtracting the "PC", subtract the offset
1230 of the lo16 relocation from here. */
1231 if (output_bfd
== NULL
&& hi
->rel
.howto
->type
== R_MIPS_GNU_REL_HI16
)
1232 hi
->rel
.addend
-= reloc_entry
->address
- hi
->rel
.address
;
1234 ret
= _bfd_mips_elf_generic_reloc (abfd
, &hi
->rel
, symbol
, hi
->data
,
1235 hi
->input_section
, output_bfd
,
1237 if (ret
!= bfd_reloc_ok
)
1240 mips_hi16_list
= hi
->next
;
1244 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1245 input_section
, output_bfd
,
1249 /* A generic howto special_function. This calculates and installs the
1250 relocation itself, thus avoiding the oft-discussed problems in
1251 bfd_perform_relocation and bfd_install_relocation. */
1253 bfd_reloc_status_type
1254 _bfd_mips_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
1255 asymbol
*symbol
, void *data ATTRIBUTE_UNUSED
,
1256 asection
*input_section
, bfd
*output_bfd
,
1257 char **error_message ATTRIBUTE_UNUSED
)
1260 bfd_reloc_status_type status
;
1261 bfd_boolean relocatable
;
1263 relocatable
= (output_bfd
!= NULL
);
1265 if (reloc_entry
->address
> input_section
->_cooked_size
)
1266 return bfd_reloc_outofrange
;
1268 /* Build up the field adjustment in VAL. */
1270 if (!relocatable
|| (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1272 /* Either we're calculating the final field value or we have a
1273 relocation against a section symbol. Add in the section's
1274 offset or address. */
1275 val
+= symbol
->section
->output_section
->vma
;
1276 val
+= symbol
->section
->output_offset
;
1281 /* We're calculating the final field value. Add in the symbol's value
1282 and, if pc-relative, subtract the address of the field itself. */
1283 val
+= symbol
->value
;
1284 if (reloc_entry
->howto
->pc_relative
)
1286 val
-= input_section
->output_section
->vma
;
1287 val
-= input_section
->output_offset
;
1288 val
-= reloc_entry
->address
;
1292 /* VAL is now the final adjustment. If we're keeping this relocation
1293 in the output file, and if the relocation uses a separate addend,
1294 we just need to add VAL to that addend. Otherwise we need to add
1295 VAL to the relocation field itself. */
1296 if (relocatable
&& !reloc_entry
->howto
->partial_inplace
)
1297 reloc_entry
->addend
+= val
;
1300 /* Add in the separate addend, if any. */
1301 val
+= reloc_entry
->addend
;
1303 /* Add VAL to the relocation field. */
1304 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
1306 + reloc_entry
->address
);
1307 if (status
!= bfd_reloc_ok
)
1312 reloc_entry
->address
+= input_section
->output_offset
;
1314 return bfd_reloc_ok
;
1317 /* Swap an entry in a .gptab section. Note that these routines rely
1318 on the equivalence of the two elements of the union. */
1321 bfd_mips_elf32_swap_gptab_in (bfd
*abfd
, const Elf32_External_gptab
*ex
,
1324 in
->gt_entry
.gt_g_value
= H_GET_32 (abfd
, ex
->gt_entry
.gt_g_value
);
1325 in
->gt_entry
.gt_bytes
= H_GET_32 (abfd
, ex
->gt_entry
.gt_bytes
);
1329 bfd_mips_elf32_swap_gptab_out (bfd
*abfd
, const Elf32_gptab
*in
,
1330 Elf32_External_gptab
*ex
)
1332 H_PUT_32 (abfd
, in
->gt_entry
.gt_g_value
, ex
->gt_entry
.gt_g_value
);
1333 H_PUT_32 (abfd
, in
->gt_entry
.gt_bytes
, ex
->gt_entry
.gt_bytes
);
1337 bfd_elf32_swap_compact_rel_out (bfd
*abfd
, const Elf32_compact_rel
*in
,
1338 Elf32_External_compact_rel
*ex
)
1340 H_PUT_32 (abfd
, in
->id1
, ex
->id1
);
1341 H_PUT_32 (abfd
, in
->num
, ex
->num
);
1342 H_PUT_32 (abfd
, in
->id2
, ex
->id2
);
1343 H_PUT_32 (abfd
, in
->offset
, ex
->offset
);
1344 H_PUT_32 (abfd
, in
->reserved0
, ex
->reserved0
);
1345 H_PUT_32 (abfd
, in
->reserved1
, ex
->reserved1
);
1349 bfd_elf32_swap_crinfo_out (bfd
*abfd
, const Elf32_crinfo
*in
,
1350 Elf32_External_crinfo
*ex
)
1354 l
= (((in
->ctype
& CRINFO_CTYPE
) << CRINFO_CTYPE_SH
)
1355 | ((in
->rtype
& CRINFO_RTYPE
) << CRINFO_RTYPE_SH
)
1356 | ((in
->dist2to
& CRINFO_DIST2TO
) << CRINFO_DIST2TO_SH
)
1357 | ((in
->relvaddr
& CRINFO_RELVADDR
) << CRINFO_RELVADDR_SH
));
1358 H_PUT_32 (abfd
, l
, ex
->info
);
1359 H_PUT_32 (abfd
, in
->konst
, ex
->konst
);
1360 H_PUT_32 (abfd
, in
->vaddr
, ex
->vaddr
);
1363 /* A .reginfo section holds a single Elf32_RegInfo structure. These
1364 routines swap this structure in and out. They are used outside of
1365 BFD, so they are globally visible. */
1368 bfd_mips_elf32_swap_reginfo_in (bfd
*abfd
, const Elf32_External_RegInfo
*ex
,
1371 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1372 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1373 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1374 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1375 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1376 in
->ri_gp_value
= H_GET_32 (abfd
, ex
->ri_gp_value
);
1380 bfd_mips_elf32_swap_reginfo_out (bfd
*abfd
, const Elf32_RegInfo
*in
,
1381 Elf32_External_RegInfo
*ex
)
1383 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1384 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1385 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1386 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1387 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1388 H_PUT_32 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1391 /* In the 64 bit ABI, the .MIPS.options section holds register
1392 information in an Elf64_Reginfo structure. These routines swap
1393 them in and out. They are globally visible because they are used
1394 outside of BFD. These routines are here so that gas can call them
1395 without worrying about whether the 64 bit ABI has been included. */
1398 bfd_mips_elf64_swap_reginfo_in (bfd
*abfd
, const Elf64_External_RegInfo
*ex
,
1399 Elf64_Internal_RegInfo
*in
)
1401 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1402 in
->ri_pad
= H_GET_32 (abfd
, ex
->ri_pad
);
1403 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1404 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1405 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1406 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1407 in
->ri_gp_value
= H_GET_64 (abfd
, ex
->ri_gp_value
);
1411 bfd_mips_elf64_swap_reginfo_out (bfd
*abfd
, const Elf64_Internal_RegInfo
*in
,
1412 Elf64_External_RegInfo
*ex
)
1414 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1415 H_PUT_32 (abfd
, in
->ri_pad
, ex
->ri_pad
);
1416 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1417 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1418 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1419 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1420 H_PUT_64 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1423 /* Swap in an options header. */
1426 bfd_mips_elf_swap_options_in (bfd
*abfd
, const Elf_External_Options
*ex
,
1427 Elf_Internal_Options
*in
)
1429 in
->kind
= H_GET_8 (abfd
, ex
->kind
);
1430 in
->size
= H_GET_8 (abfd
, ex
->size
);
1431 in
->section
= H_GET_16 (abfd
, ex
->section
);
1432 in
->info
= H_GET_32 (abfd
, ex
->info
);
1435 /* Swap out an options header. */
1438 bfd_mips_elf_swap_options_out (bfd
*abfd
, const Elf_Internal_Options
*in
,
1439 Elf_External_Options
*ex
)
1441 H_PUT_8 (abfd
, in
->kind
, ex
->kind
);
1442 H_PUT_8 (abfd
, in
->size
, ex
->size
);
1443 H_PUT_16 (abfd
, in
->section
, ex
->section
);
1444 H_PUT_32 (abfd
, in
->info
, ex
->info
);
1447 /* This function is called via qsort() to sort the dynamic relocation
1448 entries by increasing r_symndx value. */
1451 sort_dynamic_relocs (const void *arg1
, const void *arg2
)
1453 Elf_Internal_Rela int_reloc1
;
1454 Elf_Internal_Rela int_reloc2
;
1456 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg1
, &int_reloc1
);
1457 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg2
, &int_reloc2
);
1459 return ELF32_R_SYM (int_reloc1
.r_info
) - ELF32_R_SYM (int_reloc2
.r_info
);
1462 /* Like sort_dynamic_relocs, but used for elf64 relocations. */
1465 sort_dynamic_relocs_64 (const void *arg1
, const void *arg2
)
1467 Elf_Internal_Rela int_reloc1
[3];
1468 Elf_Internal_Rela int_reloc2
[3];
1470 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1471 (reldyn_sorting_bfd
, arg1
, int_reloc1
);
1472 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1473 (reldyn_sorting_bfd
, arg2
, int_reloc2
);
1475 return (ELF64_R_SYM (int_reloc1
[0].r_info
)
1476 - ELF64_R_SYM (int_reloc2
[0].r_info
));
1480 /* This routine is used to write out ECOFF debugging external symbol
1481 information. It is called via mips_elf_link_hash_traverse. The
1482 ECOFF external symbol information must match the ELF external
1483 symbol information. Unfortunately, at this point we don't know
1484 whether a symbol is required by reloc information, so the two
1485 tables may wind up being different. We must sort out the external
1486 symbol information before we can set the final size of the .mdebug
1487 section, and we must set the size of the .mdebug section before we
1488 can relocate any sections, and we can't know which symbols are
1489 required by relocation until we relocate the sections.
1490 Fortunately, it is relatively unlikely that any symbol will be
1491 stripped but required by a reloc. In particular, it can not happen
1492 when generating a final executable. */
1495 mips_elf_output_extsym (struct mips_elf_link_hash_entry
*h
, void *data
)
1497 struct extsym_info
*einfo
= data
;
1499 asection
*sec
, *output_section
;
1501 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1502 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1504 if (h
->root
.indx
== -2)
1506 else if (((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1507 || (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
1508 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
1509 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
1511 else if (einfo
->info
->strip
== strip_all
1512 || (einfo
->info
->strip
== strip_some
1513 && bfd_hash_lookup (einfo
->info
->keep_hash
,
1514 h
->root
.root
.root
.string
,
1515 FALSE
, FALSE
) == NULL
))
1523 if (h
->esym
.ifd
== -2)
1526 h
->esym
.cobol_main
= 0;
1527 h
->esym
.weakext
= 0;
1528 h
->esym
.reserved
= 0;
1529 h
->esym
.ifd
= ifdNil
;
1530 h
->esym
.asym
.value
= 0;
1531 h
->esym
.asym
.st
= stGlobal
;
1533 if (h
->root
.root
.type
== bfd_link_hash_undefined
1534 || h
->root
.root
.type
== bfd_link_hash_undefweak
)
1538 /* Use undefined class. Also, set class and type for some
1540 name
= h
->root
.root
.root
.string
;
1541 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
1542 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
1544 h
->esym
.asym
.sc
= scData
;
1545 h
->esym
.asym
.st
= stLabel
;
1546 h
->esym
.asym
.value
= 0;
1548 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
1550 h
->esym
.asym
.sc
= scAbs
;
1551 h
->esym
.asym
.st
= stLabel
;
1552 h
->esym
.asym
.value
=
1553 mips_elf_hash_table (einfo
->info
)->procedure_count
;
1555 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (einfo
->abfd
))
1557 h
->esym
.asym
.sc
= scAbs
;
1558 h
->esym
.asym
.st
= stLabel
;
1559 h
->esym
.asym
.value
= elf_gp (einfo
->abfd
);
1562 h
->esym
.asym
.sc
= scUndefined
;
1564 else if (h
->root
.root
.type
!= bfd_link_hash_defined
1565 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
1566 h
->esym
.asym
.sc
= scAbs
;
1571 sec
= h
->root
.root
.u
.def
.section
;
1572 output_section
= sec
->output_section
;
1574 /* When making a shared library and symbol h is the one from
1575 the another shared library, OUTPUT_SECTION may be null. */
1576 if (output_section
== NULL
)
1577 h
->esym
.asym
.sc
= scUndefined
;
1580 name
= bfd_section_name (output_section
->owner
, output_section
);
1582 if (strcmp (name
, ".text") == 0)
1583 h
->esym
.asym
.sc
= scText
;
1584 else if (strcmp (name
, ".data") == 0)
1585 h
->esym
.asym
.sc
= scData
;
1586 else if (strcmp (name
, ".sdata") == 0)
1587 h
->esym
.asym
.sc
= scSData
;
1588 else if (strcmp (name
, ".rodata") == 0
1589 || strcmp (name
, ".rdata") == 0)
1590 h
->esym
.asym
.sc
= scRData
;
1591 else if (strcmp (name
, ".bss") == 0)
1592 h
->esym
.asym
.sc
= scBss
;
1593 else if (strcmp (name
, ".sbss") == 0)
1594 h
->esym
.asym
.sc
= scSBss
;
1595 else if (strcmp (name
, ".init") == 0)
1596 h
->esym
.asym
.sc
= scInit
;
1597 else if (strcmp (name
, ".fini") == 0)
1598 h
->esym
.asym
.sc
= scFini
;
1600 h
->esym
.asym
.sc
= scAbs
;
1604 h
->esym
.asym
.reserved
= 0;
1605 h
->esym
.asym
.index
= indexNil
;
1608 if (h
->root
.root
.type
== bfd_link_hash_common
)
1609 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
1610 else if (h
->root
.root
.type
== bfd_link_hash_defined
1611 || h
->root
.root
.type
== bfd_link_hash_defweak
)
1613 if (h
->esym
.asym
.sc
== scCommon
)
1614 h
->esym
.asym
.sc
= scBss
;
1615 else if (h
->esym
.asym
.sc
== scSCommon
)
1616 h
->esym
.asym
.sc
= scSBss
;
1618 sec
= h
->root
.root
.u
.def
.section
;
1619 output_section
= sec
->output_section
;
1620 if (output_section
!= NULL
)
1621 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
1622 + sec
->output_offset
1623 + output_section
->vma
);
1625 h
->esym
.asym
.value
= 0;
1627 else if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
1629 struct mips_elf_link_hash_entry
*hd
= h
;
1630 bfd_boolean no_fn_stub
= h
->no_fn_stub
;
1632 while (hd
->root
.root
.type
== bfd_link_hash_indirect
)
1634 hd
= (struct mips_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
1635 no_fn_stub
= no_fn_stub
|| hd
->no_fn_stub
;
1640 /* Set type and value for a symbol with a function stub. */
1641 h
->esym
.asym
.st
= stProc
;
1642 sec
= hd
->root
.root
.u
.def
.section
;
1644 h
->esym
.asym
.value
= 0;
1647 output_section
= sec
->output_section
;
1648 if (output_section
!= NULL
)
1649 h
->esym
.asym
.value
= (hd
->root
.plt
.offset
1650 + sec
->output_offset
1651 + output_section
->vma
);
1653 h
->esym
.asym
.value
= 0;
1661 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
1662 h
->root
.root
.root
.string
,
1665 einfo
->failed
= TRUE
;
1672 /* A comparison routine used to sort .gptab entries. */
1675 gptab_compare (const void *p1
, const void *p2
)
1677 const Elf32_gptab
*a1
= p1
;
1678 const Elf32_gptab
*a2
= p2
;
1680 return a1
->gt_entry
.gt_g_value
- a2
->gt_entry
.gt_g_value
;
1683 /* Functions to manage the got entry hash table. */
1685 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
1688 static INLINE hashval_t
1689 mips_elf_hash_bfd_vma (bfd_vma addr
)
1692 return addr
+ (addr
>> 32);
1698 /* got_entries only match if they're identical, except for gotidx, so
1699 use all fields to compute the hash, and compare the appropriate
1703 mips_elf_got_entry_hash (const void *entry_
)
1705 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
1707 return entry
->symndx
1708 + (! entry
->abfd
? mips_elf_hash_bfd_vma (entry
->d
.address
)
1710 + (entry
->symndx
>= 0 ? mips_elf_hash_bfd_vma (entry
->d
.addend
)
1711 : entry
->d
.h
->root
.root
.root
.hash
));
1715 mips_elf_got_entry_eq (const void *entry1
, const void *entry2
)
1717 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
1718 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
1720 return e1
->abfd
== e2
->abfd
&& e1
->symndx
== e2
->symndx
1721 && (! e1
->abfd
? e1
->d
.address
== e2
->d
.address
1722 : e1
->symndx
>= 0 ? e1
->d
.addend
== e2
->d
.addend
1723 : e1
->d
.h
== e2
->d
.h
);
1726 /* multi_got_entries are still a match in the case of global objects,
1727 even if the input bfd in which they're referenced differs, so the
1728 hash computation and compare functions are adjusted
1732 mips_elf_multi_got_entry_hash (const void *entry_
)
1734 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
1736 return entry
->symndx
1738 ? mips_elf_hash_bfd_vma (entry
->d
.address
)
1739 : entry
->symndx
>= 0
1741 + mips_elf_hash_bfd_vma (entry
->d
.addend
))
1742 : entry
->d
.h
->root
.root
.root
.hash
);
1746 mips_elf_multi_got_entry_eq (const void *entry1
, const void *entry2
)
1748 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
1749 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
1751 return e1
->symndx
== e2
->symndx
1752 && (e1
->symndx
>= 0 ? e1
->abfd
== e2
->abfd
&& e1
->d
.addend
== e2
->d
.addend
1753 : e1
->abfd
== NULL
|| e2
->abfd
== NULL
1754 ? e1
->abfd
== e2
->abfd
&& e1
->d
.address
== e2
->d
.address
1755 : e1
->d
.h
== e2
->d
.h
);
1758 /* Returns the dynamic relocation section for DYNOBJ. */
1761 mips_elf_rel_dyn_section (bfd
*dynobj
, bfd_boolean create_p
)
1763 static const char dname
[] = ".rel.dyn";
1766 sreloc
= bfd_get_section_by_name (dynobj
, dname
);
1767 if (sreloc
== NULL
&& create_p
)
1769 sreloc
= bfd_make_section (dynobj
, dname
);
1771 || ! bfd_set_section_flags (dynobj
, sreloc
,
1776 | SEC_LINKER_CREATED
1778 || ! bfd_set_section_alignment (dynobj
, sreloc
,
1779 MIPS_ELF_LOG_FILE_ALIGN (dynobj
)))
1785 /* Returns the GOT section for ABFD. */
1788 mips_elf_got_section (bfd
*abfd
, bfd_boolean maybe_excluded
)
1790 asection
*sgot
= bfd_get_section_by_name (abfd
, ".got");
1792 || (! maybe_excluded
&& (sgot
->flags
& SEC_EXCLUDE
) != 0))
1797 /* Returns the GOT information associated with the link indicated by
1798 INFO. If SGOTP is non-NULL, it is filled in with the GOT
1801 static struct mips_got_info
*
1802 mips_elf_got_info (bfd
*abfd
, asection
**sgotp
)
1805 struct mips_got_info
*g
;
1807 sgot
= mips_elf_got_section (abfd
, TRUE
);
1808 BFD_ASSERT (sgot
!= NULL
);
1809 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
1810 g
= mips_elf_section_data (sgot
)->u
.got_info
;
1811 BFD_ASSERT (g
!= NULL
);
1814 *sgotp
= (sgot
->flags
& SEC_EXCLUDE
) == 0 ? sgot
: NULL
;
1819 /* Obtain the lowest dynamic index of a symbol that was assigned a
1820 global GOT entry. */
1822 mips_elf_get_global_gotsym_index (bfd
*abfd
)
1825 struct mips_got_info
*g
;
1830 sgot
= mips_elf_got_section (abfd
, TRUE
);
1831 if (sgot
== NULL
|| mips_elf_section_data (sgot
) == NULL
)
1834 g
= mips_elf_section_data (sgot
)->u
.got_info
;
1835 if (g
== NULL
|| g
->global_gotsym
== NULL
)
1838 return g
->global_gotsym
->dynindx
;
1841 /* Returns the GOT offset at which the indicated address can be found.
1842 If there is not yet a GOT entry for this value, create one. Returns
1843 -1 if no satisfactory GOT offset can be found. */
1846 mips_elf_local_got_index (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
1850 struct mips_got_info
*g
;
1851 struct mips_got_entry
*entry
;
1853 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1855 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
, value
);
1857 return entry
->gotidx
;
1862 /* Returns the GOT index for the global symbol indicated by H. */
1865 mips_elf_global_got_index (bfd
*abfd
, bfd
*ibfd
, struct elf_link_hash_entry
*h
)
1869 struct mips_got_info
*g
, *gg
;
1870 long global_got_dynindx
= 0;
1872 gg
= g
= mips_elf_got_info (abfd
, &sgot
);
1873 if (g
->bfd2got
&& ibfd
)
1875 struct mips_got_entry e
, *p
;
1877 BFD_ASSERT (h
->dynindx
>= 0);
1879 g
= mips_elf_got_for_ibfd (g
, ibfd
);
1884 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
1886 p
= htab_find (g
->got_entries
, &e
);
1888 BFD_ASSERT (p
->gotidx
> 0);
1893 if (gg
->global_gotsym
!= NULL
)
1894 global_got_dynindx
= gg
->global_gotsym
->dynindx
;
1896 /* Once we determine the global GOT entry with the lowest dynamic
1897 symbol table index, we must put all dynamic symbols with greater
1898 indices into the GOT. That makes it easy to calculate the GOT
1900 BFD_ASSERT (h
->dynindx
>= global_got_dynindx
);
1901 index
= ((h
->dynindx
- global_got_dynindx
+ g
->local_gotno
)
1902 * MIPS_ELF_GOT_SIZE (abfd
));
1903 BFD_ASSERT (index
< sgot
->_raw_size
);
1908 /* Find a GOT entry that is within 32KB of the VALUE. These entries
1909 are supposed to be placed at small offsets in the GOT, i.e.,
1910 within 32KB of GP. Return the index into the GOT for this page,
1911 and store the offset from this entry to the desired address in
1912 OFFSETP, if it is non-NULL. */
1915 mips_elf_got_page (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
1916 bfd_vma value
, bfd_vma
*offsetp
)
1919 struct mips_got_info
*g
;
1921 struct mips_got_entry
*entry
;
1923 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1925 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
,
1927 & (~(bfd_vma
)0xffff));
1932 index
= entry
->gotidx
;
1935 *offsetp
= value
- entry
->d
.address
;
1940 /* Find a GOT entry whose higher-order 16 bits are the same as those
1941 for value. Return the index into the GOT for this entry. */
1944 mips_elf_got16_entry (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
1945 bfd_vma value
, bfd_boolean external
)
1948 struct mips_got_info
*g
;
1949 struct mips_got_entry
*entry
;
1953 /* Although the ABI says that it is "the high-order 16 bits" that we
1954 want, it is really the %high value. The complete value is
1955 calculated with a `addiu' of a LO16 relocation, just as with a
1957 value
= mips_elf_high (value
) << 16;
1960 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1962 entry
= mips_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
, value
);
1964 return entry
->gotidx
;
1969 /* Returns the offset for the entry at the INDEXth position
1973 mips_elf_got_offset_from_index (bfd
*dynobj
, bfd
*output_bfd
,
1974 bfd
*input_bfd
, bfd_vma index
)
1978 struct mips_got_info
*g
;
1980 g
= mips_elf_got_info (dynobj
, &sgot
);
1981 gp
= _bfd_get_gp_value (output_bfd
)
1982 + mips_elf_adjust_gp (output_bfd
, g
, input_bfd
);
1984 return sgot
->output_section
->vma
+ sgot
->output_offset
+ index
- gp
;
1987 /* Create a local GOT entry for VALUE. Return the index of the entry,
1988 or -1 if it could not be created. */
1990 static struct mips_got_entry
*
1991 mips_elf_create_local_got_entry (bfd
*abfd
, bfd
*ibfd
,
1992 struct mips_got_info
*gg
,
1993 asection
*sgot
, bfd_vma value
)
1995 struct mips_got_entry entry
, **loc
;
1996 struct mips_got_info
*g
;
2000 entry
.d
.address
= value
;
2002 g
= mips_elf_got_for_ibfd (gg
, ibfd
);
2005 g
= mips_elf_got_for_ibfd (gg
, abfd
);
2006 BFD_ASSERT (g
!= NULL
);
2009 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
2014 entry
.gotidx
= MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
++;
2016 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2021 memcpy (*loc
, &entry
, sizeof entry
);
2023 if (g
->assigned_gotno
>= g
->local_gotno
)
2025 (*loc
)->gotidx
= -1;
2026 /* We didn't allocate enough space in the GOT. */
2027 (*_bfd_error_handler
)
2028 (_("not enough GOT space for local GOT entries"));
2029 bfd_set_error (bfd_error_bad_value
);
2033 MIPS_ELF_PUT_WORD (abfd
, value
,
2034 (sgot
->contents
+ entry
.gotidx
));
2039 /* Sort the dynamic symbol table so that symbols that need GOT entries
2040 appear towards the end. This reduces the amount of GOT space
2041 required. MAX_LOCAL is used to set the number of local symbols
2042 known to be in the dynamic symbol table. During
2043 _bfd_mips_elf_size_dynamic_sections, this value is 1. Afterward, the
2044 section symbols are added and the count is higher. */
2047 mips_elf_sort_hash_table (struct bfd_link_info
*info
, unsigned long max_local
)
2049 struct mips_elf_hash_sort_data hsd
;
2050 struct mips_got_info
*g
;
2053 dynobj
= elf_hash_table (info
)->dynobj
;
2055 g
= mips_elf_got_info (dynobj
, NULL
);
2058 hsd
.max_unref_got_dynindx
=
2059 hsd
.min_got_dynindx
= elf_hash_table (info
)->dynsymcount
2060 /* In the multi-got case, assigned_gotno of the master got_info
2061 indicate the number of entries that aren't referenced in the
2062 primary GOT, but that must have entries because there are
2063 dynamic relocations that reference it. Since they aren't
2064 referenced, we move them to the end of the GOT, so that they
2065 don't prevent other entries that are referenced from getting
2066 too large offsets. */
2067 - (g
->next
? g
->assigned_gotno
: 0);
2068 hsd
.max_non_got_dynindx
= max_local
;
2069 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table
*)
2070 elf_hash_table (info
)),
2071 mips_elf_sort_hash_table_f
,
2074 /* There should have been enough room in the symbol table to
2075 accommodate both the GOT and non-GOT symbols. */
2076 BFD_ASSERT (hsd
.max_non_got_dynindx
<= hsd
.min_got_dynindx
);
2077 BFD_ASSERT ((unsigned long)hsd
.max_unref_got_dynindx
2078 <= elf_hash_table (info
)->dynsymcount
);
2080 /* Now we know which dynamic symbol has the lowest dynamic symbol
2081 table index in the GOT. */
2082 g
->global_gotsym
= hsd
.low
;
2087 /* If H needs a GOT entry, assign it the highest available dynamic
2088 index. Otherwise, assign it the lowest available dynamic
2092 mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry
*h
, void *data
)
2094 struct mips_elf_hash_sort_data
*hsd
= data
;
2096 if (h
->root
.root
.type
== bfd_link_hash_warning
)
2097 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2099 /* Symbols without dynamic symbol table entries aren't interesting
2101 if (h
->root
.dynindx
== -1)
2104 /* Global symbols that need GOT entries that are not explicitly
2105 referenced are marked with got offset 2. Those that are
2106 referenced get a 1, and those that don't need GOT entries get
2108 if (h
->root
.got
.offset
== 2)
2110 if (hsd
->max_unref_got_dynindx
== hsd
->min_got_dynindx
)
2111 hsd
->low
= (struct elf_link_hash_entry
*) h
;
2112 h
->root
.dynindx
= hsd
->max_unref_got_dynindx
++;
2114 else if (h
->root
.got
.offset
!= 1)
2115 h
->root
.dynindx
= hsd
->max_non_got_dynindx
++;
2118 h
->root
.dynindx
= --hsd
->min_got_dynindx
;
2119 hsd
->low
= (struct elf_link_hash_entry
*) h
;
2125 /* If H is a symbol that needs a global GOT entry, but has a dynamic
2126 symbol table index lower than any we've seen to date, record it for
2130 mips_elf_record_global_got_symbol (struct elf_link_hash_entry
*h
,
2131 bfd
*abfd
, struct bfd_link_info
*info
,
2132 struct mips_got_info
*g
)
2134 struct mips_got_entry entry
, **loc
;
2136 /* A global symbol in the GOT must also be in the dynamic symbol
2138 if (h
->dynindx
== -1)
2140 switch (ELF_ST_VISIBILITY (h
->other
))
2144 _bfd_mips_elf_hide_symbol (info
, h
, TRUE
);
2147 if (!bfd_elf32_link_record_dynamic_symbol (info
, h
))
2153 entry
.d
.h
= (struct mips_elf_link_hash_entry
*) h
;
2155 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
2158 /* If we've already marked this entry as needing GOT space, we don't
2159 need to do it again. */
2163 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2169 memcpy (*loc
, &entry
, sizeof entry
);
2171 if (h
->got
.offset
!= MINUS_ONE
)
2174 /* By setting this to a value other than -1, we are indicating that
2175 there needs to be a GOT entry for H. Avoid using zero, as the
2176 generic ELF copy_indirect_symbol tests for <= 0. */
2182 /* Reserve space in G for a GOT entry containing the value of symbol
2183 SYMNDX in input bfd ABDF, plus ADDEND. */
2186 mips_elf_record_local_got_symbol (bfd
*abfd
, long symndx
, bfd_vma addend
,
2187 struct mips_got_info
*g
)
2189 struct mips_got_entry entry
, **loc
;
2192 entry
.symndx
= symndx
;
2193 entry
.d
.addend
= addend
;
2194 loc
= (struct mips_got_entry
**)
2195 htab_find_slot (g
->got_entries
, &entry
, INSERT
);
2200 entry
.gotidx
= g
->local_gotno
++;
2202 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2207 memcpy (*loc
, &entry
, sizeof entry
);
2212 /* Compute the hash value of the bfd in a bfd2got hash entry. */
2215 mips_elf_bfd2got_entry_hash (const void *entry_
)
2217 const struct mips_elf_bfd2got_hash
*entry
2218 = (struct mips_elf_bfd2got_hash
*)entry_
;
2220 return entry
->bfd
->id
;
2223 /* Check whether two hash entries have the same bfd. */
2226 mips_elf_bfd2got_entry_eq (const void *entry1
, const void *entry2
)
2228 const struct mips_elf_bfd2got_hash
*e1
2229 = (const struct mips_elf_bfd2got_hash
*)entry1
;
2230 const struct mips_elf_bfd2got_hash
*e2
2231 = (const struct mips_elf_bfd2got_hash
*)entry2
;
2233 return e1
->bfd
== e2
->bfd
;
2236 /* In a multi-got link, determine the GOT to be used for IBDF. G must
2237 be the master GOT data. */
2239 static struct mips_got_info
*
2240 mips_elf_got_for_ibfd (struct mips_got_info
*g
, bfd
*ibfd
)
2242 struct mips_elf_bfd2got_hash e
, *p
;
2248 p
= htab_find (g
->bfd2got
, &e
);
2249 return p
? p
->g
: NULL
;
2252 /* Create one separate got for each bfd that has entries in the global
2253 got, such that we can tell how many local and global entries each
2257 mips_elf_make_got_per_bfd (void **entryp
, void *p
)
2259 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2260 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
2261 htab_t bfd2got
= arg
->bfd2got
;
2262 struct mips_got_info
*g
;
2263 struct mips_elf_bfd2got_hash bfdgot_entry
, *bfdgot
;
2266 /* Find the got_info for this GOT entry's input bfd. Create one if
2268 bfdgot_entry
.bfd
= entry
->abfd
;
2269 bfdgotp
= htab_find_slot (bfd2got
, &bfdgot_entry
, INSERT
);
2270 bfdgot
= (struct mips_elf_bfd2got_hash
*)*bfdgotp
;
2276 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
2277 (arg
->obfd
, sizeof (struct mips_elf_bfd2got_hash
));
2287 bfdgot
->bfd
= entry
->abfd
;
2288 bfdgot
->g
= g
= (struct mips_got_info
*)
2289 bfd_alloc (arg
->obfd
, sizeof (struct mips_got_info
));
2296 g
->global_gotsym
= NULL
;
2297 g
->global_gotno
= 0;
2299 g
->assigned_gotno
= -1;
2300 g
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
2301 mips_elf_multi_got_entry_eq
, NULL
);
2302 if (g
->got_entries
== NULL
)
2312 /* Insert the GOT entry in the bfd's got entry hash table. */
2313 entryp
= htab_find_slot (g
->got_entries
, entry
, INSERT
);
2314 if (*entryp
!= NULL
)
2319 if (entry
->symndx
>= 0 || entry
->d
.h
->forced_local
)
2327 /* Attempt to merge gots of different input bfds. Try to use as much
2328 as possible of the primary got, since it doesn't require explicit
2329 dynamic relocations, but don't use bfds that would reference global
2330 symbols out of the addressable range. Failing the primary got,
2331 attempt to merge with the current got, or finish the current got
2332 and then make make the new got current. */
2335 mips_elf_merge_gots (void **bfd2got_
, void *p
)
2337 struct mips_elf_bfd2got_hash
*bfd2got
2338 = (struct mips_elf_bfd2got_hash
*)*bfd2got_
;
2339 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
2340 unsigned int lcount
= bfd2got
->g
->local_gotno
;
2341 unsigned int gcount
= bfd2got
->g
->global_gotno
;
2342 unsigned int maxcnt
= arg
->max_count
;
2344 /* If we don't have a primary GOT and this is not too big, use it as
2345 a starting point for the primary GOT. */
2346 if (! arg
->primary
&& lcount
+ gcount
<= maxcnt
)
2348 arg
->primary
= bfd2got
->g
;
2349 arg
->primary_count
= lcount
+ gcount
;
2351 /* If it looks like we can merge this bfd's entries with those of
2352 the primary, merge them. The heuristics is conservative, but we
2353 don't have to squeeze it too hard. */
2354 else if (arg
->primary
2355 && (arg
->primary_count
+ lcount
+ gcount
) <= maxcnt
)
2357 struct mips_got_info
*g
= bfd2got
->g
;
2358 int old_lcount
= arg
->primary
->local_gotno
;
2359 int old_gcount
= arg
->primary
->global_gotno
;
2361 bfd2got
->g
= arg
->primary
;
2363 htab_traverse (g
->got_entries
,
2364 mips_elf_make_got_per_bfd
,
2366 if (arg
->obfd
== NULL
)
2369 htab_delete (g
->got_entries
);
2370 /* We don't have to worry about releasing memory of the actual
2371 got entries, since they're all in the master got_entries hash
2374 BFD_ASSERT (old_lcount
+ lcount
>= arg
->primary
->local_gotno
);
2375 BFD_ASSERT (old_gcount
+ gcount
>= arg
->primary
->global_gotno
);
2377 arg
->primary_count
= arg
->primary
->local_gotno
2378 + arg
->primary
->global_gotno
;
2380 /* If we can merge with the last-created got, do it. */
2381 else if (arg
->current
2382 && arg
->current_count
+ lcount
+ gcount
<= maxcnt
)
2384 struct mips_got_info
*g
= bfd2got
->g
;
2385 int old_lcount
= arg
->current
->local_gotno
;
2386 int old_gcount
= arg
->current
->global_gotno
;
2388 bfd2got
->g
= arg
->current
;
2390 htab_traverse (g
->got_entries
,
2391 mips_elf_make_got_per_bfd
,
2393 if (arg
->obfd
== NULL
)
2396 htab_delete (g
->got_entries
);
2398 BFD_ASSERT (old_lcount
+ lcount
>= arg
->current
->local_gotno
);
2399 BFD_ASSERT (old_gcount
+ gcount
>= arg
->current
->global_gotno
);
2401 arg
->current_count
= arg
->current
->local_gotno
2402 + arg
->current
->global_gotno
;
2404 /* Well, we couldn't merge, so create a new GOT. Don't check if it
2405 fits; if it turns out that it doesn't, we'll get relocation
2406 overflows anyway. */
2409 bfd2got
->g
->next
= arg
->current
;
2410 arg
->current
= bfd2got
->g
;
2412 arg
->current_count
= lcount
+ gcount
;
2418 /* If passed a NULL mips_got_info in the argument, set the marker used
2419 to tell whether a global symbol needs a got entry (in the primary
2420 got) to the given VALUE.
2422 If passed a pointer G to a mips_got_info in the argument (it must
2423 not be the primary GOT), compute the offset from the beginning of
2424 the (primary) GOT section to the entry in G corresponding to the
2425 global symbol. G's assigned_gotno must contain the index of the
2426 first available global GOT entry in G. VALUE must contain the size
2427 of a GOT entry in bytes. For each global GOT entry that requires a
2428 dynamic relocation, NEEDED_RELOCS is incremented, and the symbol is
2429 marked as not eligible for lazy resolution through a function
2432 mips_elf_set_global_got_offset (void **entryp
, void *p
)
2434 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2435 struct mips_elf_set_global_got_offset_arg
*arg
2436 = (struct mips_elf_set_global_got_offset_arg
*)p
;
2437 struct mips_got_info
*g
= arg
->g
;
2439 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1
2440 && entry
->d
.h
->root
.dynindx
!= -1)
2444 BFD_ASSERT (g
->global_gotsym
== NULL
);
2446 entry
->gotidx
= arg
->value
* (long) g
->assigned_gotno
++;
2447 if (arg
->info
->shared
2448 || (elf_hash_table (arg
->info
)->dynamic_sections_created
2449 && ((entry
->d
.h
->root
.elf_link_hash_flags
2450 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0)
2451 && ((entry
->d
.h
->root
.elf_link_hash_flags
2452 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
2453 ++arg
->needed_relocs
;
2456 entry
->d
.h
->root
.got
.offset
= arg
->value
;
2462 /* Mark any global symbols referenced in the GOT we are iterating over
2463 as inelligible for lazy resolution stubs. */
2465 mips_elf_set_no_stub (void **entryp
, void *p ATTRIBUTE_UNUSED
)
2467 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2469 if (entry
->abfd
!= NULL
2470 && entry
->symndx
== -1
2471 && entry
->d
.h
->root
.dynindx
!= -1)
2472 entry
->d
.h
->no_fn_stub
= TRUE
;
2477 /* Follow indirect and warning hash entries so that each got entry
2478 points to the final symbol definition. P must point to a pointer
2479 to the hash table we're traversing. Since this traversal may
2480 modify the hash table, we set this pointer to NULL to indicate
2481 we've made a potentially-destructive change to the hash table, so
2482 the traversal must be restarted. */
2484 mips_elf_resolve_final_got_entry (void **entryp
, void *p
)
2486 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2487 htab_t got_entries
= *(htab_t
*)p
;
2489 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1)
2491 struct mips_elf_link_hash_entry
*h
= entry
->d
.h
;
2493 while (h
->root
.root
.type
== bfd_link_hash_indirect
2494 || h
->root
.root
.type
== bfd_link_hash_warning
)
2495 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2497 if (entry
->d
.h
== h
)
2502 /* If we can't find this entry with the new bfd hash, re-insert
2503 it, and get the traversal restarted. */
2504 if (! htab_find (got_entries
, entry
))
2506 htab_clear_slot (got_entries
, entryp
);
2507 entryp
= htab_find_slot (got_entries
, entry
, INSERT
);
2510 /* Abort the traversal, since the whole table may have
2511 moved, and leave it up to the parent to restart the
2513 *(htab_t
*)p
= NULL
;
2516 /* We might want to decrement the global_gotno count, but it's
2517 either too early or too late for that at this point. */
2523 /* Turn indirect got entries in a got_entries table into their final
2526 mips_elf_resolve_final_got_entries (struct mips_got_info
*g
)
2532 got_entries
= g
->got_entries
;
2534 htab_traverse (got_entries
,
2535 mips_elf_resolve_final_got_entry
,
2538 while (got_entries
== NULL
);
2541 /* Return the offset of an input bfd IBFD's GOT from the beginning of
2544 mips_elf_adjust_gp (bfd
*abfd
, struct mips_got_info
*g
, bfd
*ibfd
)
2546 if (g
->bfd2got
== NULL
)
2549 g
= mips_elf_got_for_ibfd (g
, ibfd
);
2553 BFD_ASSERT (g
->next
);
2557 return (g
->local_gotno
+ g
->global_gotno
) * MIPS_ELF_GOT_SIZE (abfd
);
2560 /* Turn a single GOT that is too big for 16-bit addressing into
2561 a sequence of GOTs, each one 16-bit addressable. */
2564 mips_elf_multi_got (bfd
*abfd
, struct bfd_link_info
*info
,
2565 struct mips_got_info
*g
, asection
*got
,
2566 bfd_size_type pages
)
2568 struct mips_elf_got_per_bfd_arg got_per_bfd_arg
;
2569 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
2570 struct mips_got_info
*gg
;
2571 unsigned int assign
;
2573 g
->bfd2got
= htab_try_create (1, mips_elf_bfd2got_entry_hash
,
2574 mips_elf_bfd2got_entry_eq
, NULL
);
2575 if (g
->bfd2got
== NULL
)
2578 got_per_bfd_arg
.bfd2got
= g
->bfd2got
;
2579 got_per_bfd_arg
.obfd
= abfd
;
2580 got_per_bfd_arg
.info
= info
;
2582 /* Count how many GOT entries each input bfd requires, creating a
2583 map from bfd to got info while at that. */
2584 mips_elf_resolve_final_got_entries (g
);
2585 htab_traverse (g
->got_entries
, mips_elf_make_got_per_bfd
, &got_per_bfd_arg
);
2586 if (got_per_bfd_arg
.obfd
== NULL
)
2589 got_per_bfd_arg
.current
= NULL
;
2590 got_per_bfd_arg
.primary
= NULL
;
2591 /* Taking out PAGES entries is a worst-case estimate. We could
2592 compute the maximum number of pages that each separate input bfd
2593 uses, but it's probably not worth it. */
2594 got_per_bfd_arg
.max_count
= ((MIPS_ELF_GOT_MAX_SIZE (abfd
)
2595 / MIPS_ELF_GOT_SIZE (abfd
))
2596 - MIPS_RESERVED_GOTNO
- pages
);
2598 /* Try to merge the GOTs of input bfds together, as long as they
2599 don't seem to exceed the maximum GOT size, choosing one of them
2600 to be the primary GOT. */
2601 htab_traverse (g
->bfd2got
, mips_elf_merge_gots
, &got_per_bfd_arg
);
2602 if (got_per_bfd_arg
.obfd
== NULL
)
2605 /* If we find any suitable primary GOT, create an empty one. */
2606 if (got_per_bfd_arg
.primary
== NULL
)
2608 g
->next
= (struct mips_got_info
*)
2609 bfd_alloc (abfd
, sizeof (struct mips_got_info
));
2610 if (g
->next
== NULL
)
2613 g
->next
->global_gotsym
= NULL
;
2614 g
->next
->global_gotno
= 0;
2615 g
->next
->local_gotno
= 0;
2616 g
->next
->assigned_gotno
= 0;
2617 g
->next
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
2618 mips_elf_multi_got_entry_eq
,
2620 if (g
->next
->got_entries
== NULL
)
2622 g
->next
->bfd2got
= NULL
;
2625 g
->next
= got_per_bfd_arg
.primary
;
2626 g
->next
->next
= got_per_bfd_arg
.current
;
2628 /* GG is now the master GOT, and G is the primary GOT. */
2632 /* Map the output bfd to the primary got. That's what we're going
2633 to use for bfds that use GOT16 or GOT_PAGE relocations that we
2634 didn't mark in check_relocs, and we want a quick way to find it.
2635 We can't just use gg->next because we're going to reverse the
2638 struct mips_elf_bfd2got_hash
*bfdgot
;
2641 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
2642 (abfd
, sizeof (struct mips_elf_bfd2got_hash
));
2649 bfdgotp
= htab_find_slot (gg
->bfd2got
, bfdgot
, INSERT
);
2651 BFD_ASSERT (*bfdgotp
== NULL
);
2655 /* The IRIX dynamic linker requires every symbol that is referenced
2656 in a dynamic relocation to be present in the primary GOT, so
2657 arrange for them to appear after those that are actually
2660 GNU/Linux could very well do without it, but it would slow down
2661 the dynamic linker, since it would have to resolve every dynamic
2662 symbol referenced in other GOTs more than once, without help from
2663 the cache. Also, knowing that every external symbol has a GOT
2664 helps speed up the resolution of local symbols too, so GNU/Linux
2665 follows IRIX's practice.
2667 The number 2 is used by mips_elf_sort_hash_table_f to count
2668 global GOT symbols that are unreferenced in the primary GOT, with
2669 an initial dynamic index computed from gg->assigned_gotno, where
2670 the number of unreferenced global entries in the primary GOT is
2674 gg
->assigned_gotno
= gg
->global_gotno
- g
->global_gotno
;
2675 g
->global_gotno
= gg
->global_gotno
;
2676 set_got_offset_arg
.value
= 2;
2680 /* This could be used for dynamic linkers that don't optimize
2681 symbol resolution while applying relocations so as to use
2682 primary GOT entries or assuming the symbol is locally-defined.
2683 With this code, we assign lower dynamic indices to global
2684 symbols that are not referenced in the primary GOT, so that
2685 their entries can be omitted. */
2686 gg
->assigned_gotno
= 0;
2687 set_got_offset_arg
.value
= -1;
2690 /* Reorder dynamic symbols as described above (which behavior
2691 depends on the setting of VALUE). */
2692 set_got_offset_arg
.g
= NULL
;
2693 htab_traverse (gg
->got_entries
, mips_elf_set_global_got_offset
,
2694 &set_got_offset_arg
);
2695 set_got_offset_arg
.value
= 1;
2696 htab_traverse (g
->got_entries
, mips_elf_set_global_got_offset
,
2697 &set_got_offset_arg
);
2698 if (! mips_elf_sort_hash_table (info
, 1))
2701 /* Now go through the GOTs assigning them offset ranges.
2702 [assigned_gotno, local_gotno[ will be set to the range of local
2703 entries in each GOT. We can then compute the end of a GOT by
2704 adding local_gotno to global_gotno. We reverse the list and make
2705 it circular since then we'll be able to quickly compute the
2706 beginning of a GOT, by computing the end of its predecessor. To
2707 avoid special cases for the primary GOT, while still preserving
2708 assertions that are valid for both single- and multi-got links,
2709 we arrange for the main got struct to have the right number of
2710 global entries, but set its local_gotno such that the initial
2711 offset of the primary GOT is zero. Remember that the primary GOT
2712 will become the last item in the circular linked list, so it
2713 points back to the master GOT. */
2714 gg
->local_gotno
= -g
->global_gotno
;
2715 gg
->global_gotno
= g
->global_gotno
;
2721 struct mips_got_info
*gn
;
2723 assign
+= MIPS_RESERVED_GOTNO
;
2724 g
->assigned_gotno
= assign
;
2725 g
->local_gotno
+= assign
+ pages
;
2726 assign
= g
->local_gotno
+ g
->global_gotno
;
2728 /* Take g out of the direct list, and push it onto the reversed
2729 list that gg points to. */
2735 /* Mark global symbols in every non-primary GOT as ineligible for
2738 htab_traverse (g
->got_entries
, mips_elf_set_no_stub
, NULL
);
2742 got
->_raw_size
= (gg
->next
->local_gotno
2743 + gg
->next
->global_gotno
) * MIPS_ELF_GOT_SIZE (abfd
);
2749 /* Returns the first relocation of type r_type found, beginning with
2750 RELOCATION. RELEND is one-past-the-end of the relocation table. */
2752 static const Elf_Internal_Rela
*
2753 mips_elf_next_relocation (bfd
*abfd ATTRIBUTE_UNUSED
, unsigned int r_type
,
2754 const Elf_Internal_Rela
*relocation
,
2755 const Elf_Internal_Rela
*relend
)
2757 /* According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must be
2758 immediately following. However, for the IRIX6 ABI, the next
2759 relocation may be a composed relocation consisting of several
2760 relocations for the same address. In that case, the R_MIPS_LO16
2761 relocation may occur as one of these. We permit a similar
2762 extension in general, as that is useful for GCC. */
2763 while (relocation
< relend
)
2765 if (ELF_R_TYPE (abfd
, relocation
->r_info
) == r_type
)
2771 /* We didn't find it. */
2772 bfd_set_error (bfd_error_bad_value
);
2776 /* Return whether a relocation is against a local symbol. */
2779 mips_elf_local_relocation_p (bfd
*input_bfd
,
2780 const Elf_Internal_Rela
*relocation
,
2781 asection
**local_sections
,
2782 bfd_boolean check_forced
)
2784 unsigned long r_symndx
;
2785 Elf_Internal_Shdr
*symtab_hdr
;
2786 struct mips_elf_link_hash_entry
*h
;
2789 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
2790 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2791 extsymoff
= (elf_bad_symtab (input_bfd
)) ? 0 : symtab_hdr
->sh_info
;
2793 if (r_symndx
< extsymoff
)
2795 if (elf_bad_symtab (input_bfd
) && local_sections
[r_symndx
] != NULL
)
2800 /* Look up the hash table to check whether the symbol
2801 was forced local. */
2802 h
= (struct mips_elf_link_hash_entry
*)
2803 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
];
2804 /* Find the real hash-table entry for this symbol. */
2805 while (h
->root
.root
.type
== bfd_link_hash_indirect
2806 || h
->root
.root
.type
== bfd_link_hash_warning
)
2807 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2808 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0)
2815 /* Sign-extend VALUE, which has the indicated number of BITS. */
2818 _bfd_mips_elf_sign_extend (bfd_vma value
, int bits
)
2820 if (value
& ((bfd_vma
) 1 << (bits
- 1)))
2821 /* VALUE is negative. */
2822 value
|= ((bfd_vma
) - 1) << bits
;
2827 /* Return non-zero if the indicated VALUE has overflowed the maximum
2828 range expressible by a signed number with the indicated number of
2832 mips_elf_overflow_p (bfd_vma value
, int bits
)
2834 bfd_signed_vma svalue
= (bfd_signed_vma
) value
;
2836 if (svalue
> (1 << (bits
- 1)) - 1)
2837 /* The value is too big. */
2839 else if (svalue
< -(1 << (bits
- 1)))
2840 /* The value is too small. */
2847 /* Calculate the %high function. */
2850 mips_elf_high (bfd_vma value
)
2852 return ((value
+ (bfd_vma
) 0x8000) >> 16) & 0xffff;
2855 /* Calculate the %higher function. */
2858 mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED
)
2861 return ((value
+ (bfd_vma
) 0x80008000) >> 32) & 0xffff;
2864 return (bfd_vma
) -1;
2868 /* Calculate the %highest function. */
2871 mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED
)
2874 return ((value
+ (((bfd_vma
) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
2877 return (bfd_vma
) -1;
2881 /* Create the .compact_rel section. */
2884 mips_elf_create_compact_rel_section
2885 (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2888 register asection
*s
;
2890 if (bfd_get_section_by_name (abfd
, ".compact_rel") == NULL
)
2892 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
2895 s
= bfd_make_section (abfd
, ".compact_rel");
2897 || ! bfd_set_section_flags (abfd
, s
, flags
)
2898 || ! bfd_set_section_alignment (abfd
, s
,
2899 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
2902 s
->_raw_size
= sizeof (Elf32_External_compact_rel
);
2908 /* Create the .got section to hold the global offset table. */
2911 mips_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
,
2912 bfd_boolean maybe_exclude
)
2915 register asection
*s
;
2916 struct elf_link_hash_entry
*h
;
2917 struct bfd_link_hash_entry
*bh
;
2918 struct mips_got_info
*g
;
2921 /* This function may be called more than once. */
2922 s
= mips_elf_got_section (abfd
, TRUE
);
2925 if (! maybe_exclude
)
2926 s
->flags
&= ~SEC_EXCLUDE
;
2930 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2931 | SEC_LINKER_CREATED
);
2934 flags
|= SEC_EXCLUDE
;
2936 /* We have to use an alignment of 2**4 here because this is hardcoded
2937 in the function stub generation and in the linker script. */
2938 s
= bfd_make_section (abfd
, ".got");
2940 || ! bfd_set_section_flags (abfd
, s
, flags
)
2941 || ! bfd_set_section_alignment (abfd
, s
, 4))
2944 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
2945 linker script because we don't want to define the symbol if we
2946 are not creating a global offset table. */
2948 if (! (_bfd_generic_link_add_one_symbol
2949 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
2950 0, NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
2953 h
= (struct elf_link_hash_entry
*) bh
;
2954 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
2955 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2956 h
->type
= STT_OBJECT
;
2959 && ! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2962 amt
= sizeof (struct mips_got_info
);
2963 g
= bfd_alloc (abfd
, amt
);
2966 g
->global_gotsym
= NULL
;
2967 g
->global_gotno
= 0;
2968 g
->local_gotno
= MIPS_RESERVED_GOTNO
;
2969 g
->assigned_gotno
= MIPS_RESERVED_GOTNO
;
2972 g
->got_entries
= htab_try_create (1, mips_elf_got_entry_hash
,
2973 mips_elf_got_entry_eq
, NULL
);
2974 if (g
->got_entries
== NULL
)
2976 mips_elf_section_data (s
)->u
.got_info
= g
;
2977 mips_elf_section_data (s
)->elf
.this_hdr
.sh_flags
2978 |= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
2983 /* Calculate the value produced by the RELOCATION (which comes from
2984 the INPUT_BFD). The ADDEND is the addend to use for this
2985 RELOCATION; RELOCATION->R_ADDEND is ignored.
2987 The result of the relocation calculation is stored in VALUEP.
2988 REQUIRE_JALXP indicates whether or not the opcode used with this
2989 relocation must be JALX.
2991 This function returns bfd_reloc_continue if the caller need take no
2992 further action regarding this relocation, bfd_reloc_notsupported if
2993 something goes dramatically wrong, bfd_reloc_overflow if an
2994 overflow occurs, and bfd_reloc_ok to indicate success. */
2996 static bfd_reloc_status_type
2997 mips_elf_calculate_relocation (bfd
*abfd
, bfd
*input_bfd
,
2998 asection
*input_section
,
2999 struct bfd_link_info
*info
,
3000 const Elf_Internal_Rela
*relocation
,
3001 bfd_vma addend
, reloc_howto_type
*howto
,
3002 Elf_Internal_Sym
*local_syms
,
3003 asection
**local_sections
, bfd_vma
*valuep
,
3004 const char **namep
, bfd_boolean
*require_jalxp
,
3005 bfd_boolean save_addend
)
3007 /* The eventual value we will return. */
3009 /* The address of the symbol against which the relocation is
3012 /* The final GP value to be used for the relocatable, executable, or
3013 shared object file being produced. */
3014 bfd_vma gp
= MINUS_ONE
;
3015 /* The place (section offset or address) of the storage unit being
3018 /* The value of GP used to create the relocatable object. */
3019 bfd_vma gp0
= MINUS_ONE
;
3020 /* The offset into the global offset table at which the address of
3021 the relocation entry symbol, adjusted by the addend, resides
3022 during execution. */
3023 bfd_vma g
= MINUS_ONE
;
3024 /* The section in which the symbol referenced by the relocation is
3026 asection
*sec
= NULL
;
3027 struct mips_elf_link_hash_entry
*h
= NULL
;
3028 /* TRUE if the symbol referred to by this relocation is a local
3030 bfd_boolean local_p
, was_local_p
;
3031 /* TRUE if the symbol referred to by this relocation is "_gp_disp". */
3032 bfd_boolean gp_disp_p
= FALSE
;
3033 Elf_Internal_Shdr
*symtab_hdr
;
3035 unsigned long r_symndx
;
3037 /* TRUE if overflow occurred during the calculation of the
3038 relocation value. */
3039 bfd_boolean overflowed_p
;
3040 /* TRUE if this relocation refers to a MIPS16 function. */
3041 bfd_boolean target_is_16_bit_code_p
= FALSE
;
3043 /* Parse the relocation. */
3044 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
3045 r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
3046 p
= (input_section
->output_section
->vma
3047 + input_section
->output_offset
3048 + relocation
->r_offset
);
3050 /* Assume that there will be no overflow. */
3051 overflowed_p
= FALSE
;
3053 /* Figure out whether or not the symbol is local, and get the offset
3054 used in the array of hash table entries. */
3055 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3056 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
3057 local_sections
, FALSE
);
3058 was_local_p
= local_p
;
3059 if (! elf_bad_symtab (input_bfd
))
3060 extsymoff
= symtab_hdr
->sh_info
;
3063 /* The symbol table does not follow the rule that local symbols
3064 must come before globals. */
3068 /* Figure out the value of the symbol. */
3071 Elf_Internal_Sym
*sym
;
3073 sym
= local_syms
+ r_symndx
;
3074 sec
= local_sections
[r_symndx
];
3076 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3077 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
3078 || (sec
->flags
& SEC_MERGE
))
3079 symbol
+= sym
->st_value
;
3080 if ((sec
->flags
& SEC_MERGE
)
3081 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3083 addend
= _bfd_elf_rel_local_sym (abfd
, sym
, &sec
, addend
);
3085 addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
3088 /* MIPS16 text labels should be treated as odd. */
3089 if (sym
->st_other
== STO_MIPS16
)
3092 /* Record the name of this symbol, for our caller. */
3093 *namep
= bfd_elf_string_from_elf_section (input_bfd
,
3094 symtab_hdr
->sh_link
,
3097 *namep
= bfd_section_name (input_bfd
, sec
);
3099 target_is_16_bit_code_p
= (sym
->st_other
== STO_MIPS16
);
3103 /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ? */
3105 /* For global symbols we look up the symbol in the hash-table. */
3106 h
= ((struct mips_elf_link_hash_entry
*)
3107 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
]);
3108 /* Find the real hash-table entry for this symbol. */
3109 while (h
->root
.root
.type
== bfd_link_hash_indirect
3110 || h
->root
.root
.type
== bfd_link_hash_warning
)
3111 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3113 /* Record the name of this symbol, for our caller. */
3114 *namep
= h
->root
.root
.root
.string
;
3116 /* See if this is the special _gp_disp symbol. Note that such a
3117 symbol must always be a global symbol. */
3118 if (strcmp (*namep
, "_gp_disp") == 0
3119 && ! NEWABI_P (input_bfd
))
3121 /* Relocations against _gp_disp are permitted only with
3122 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
3123 if (r_type
!= R_MIPS_HI16
&& r_type
!= R_MIPS_LO16
)
3124 return bfd_reloc_notsupported
;
3128 /* If this symbol is defined, calculate its address. Note that
3129 _gp_disp is a magic symbol, always implicitly defined by the
3130 linker, so it's inappropriate to check to see whether or not
3132 else if ((h
->root
.root
.type
== bfd_link_hash_defined
3133 || h
->root
.root
.type
== bfd_link_hash_defweak
)
3134 && h
->root
.root
.u
.def
.section
)
3136 sec
= h
->root
.root
.u
.def
.section
;
3137 if (sec
->output_section
)
3138 symbol
= (h
->root
.root
.u
.def
.value
3139 + sec
->output_section
->vma
3140 + sec
->output_offset
);
3142 symbol
= h
->root
.root
.u
.def
.value
;
3144 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
3145 /* We allow relocations against undefined weak symbols, giving
3146 it the value zero, so that you can undefined weak functions
3147 and check to see if they exist by looking at their
3150 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
3151 && ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
3153 else if (strcmp (*namep
, "_DYNAMIC_LINK") == 0 ||
3154 strcmp (*namep
, "_DYNAMIC_LINKING") == 0)
3156 /* If this is a dynamic link, we should have created a
3157 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
3158 in in _bfd_mips_elf_create_dynamic_sections.
3159 Otherwise, we should define the symbol with a value of 0.
3160 FIXME: It should probably get into the symbol table
3162 BFD_ASSERT (! info
->shared
);
3163 BFD_ASSERT (bfd_get_section_by_name (abfd
, ".dynamic") == NULL
);
3168 if (! ((*info
->callbacks
->undefined_symbol
)
3169 (info
, h
->root
.root
.root
.string
, input_bfd
,
3170 input_section
, relocation
->r_offset
,
3171 (info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
)
3172 || ELF_ST_VISIBILITY (h
->root
.other
))))
3173 return bfd_reloc_undefined
;
3177 target_is_16_bit_code_p
= (h
->root
.other
== STO_MIPS16
);
3180 /* If this is a 32- or 64-bit call to a 16-bit function with a stub, we
3181 need to redirect the call to the stub, unless we're already *in*
3183 if (r_type
!= R_MIPS16_26
&& !info
->relocatable
3184 && ((h
!= NULL
&& h
->fn_stub
!= NULL
)
3185 || (local_p
&& elf_tdata (input_bfd
)->local_stubs
!= NULL
3186 && elf_tdata (input_bfd
)->local_stubs
[r_symndx
] != NULL
))
3187 && !mips_elf_stub_section_p (input_bfd
, input_section
))
3189 /* This is a 32- or 64-bit call to a 16-bit function. We should
3190 have already noticed that we were going to need the
3193 sec
= elf_tdata (input_bfd
)->local_stubs
[r_symndx
];
3196 BFD_ASSERT (h
->need_fn_stub
);
3200 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3202 /* If this is a 16-bit call to a 32- or 64-bit function with a stub, we
3203 need to redirect the call to the stub. */
3204 else if (r_type
== R_MIPS16_26
&& !info
->relocatable
3206 && (h
->call_stub
!= NULL
|| h
->call_fp_stub
!= NULL
)
3207 && !target_is_16_bit_code_p
)
3209 /* If both call_stub and call_fp_stub are defined, we can figure
3210 out which one to use by seeing which one appears in the input
3212 if (h
->call_stub
!= NULL
&& h
->call_fp_stub
!= NULL
)
3217 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
3219 if (strncmp (bfd_get_section_name (input_bfd
, o
),
3220 CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
3222 sec
= h
->call_fp_stub
;
3229 else if (h
->call_stub
!= NULL
)
3232 sec
= h
->call_fp_stub
;
3234 BFD_ASSERT (sec
->_raw_size
> 0);
3235 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3238 /* Calls from 16-bit code to 32-bit code and vice versa require the
3239 special jalx instruction. */
3240 *require_jalxp
= (!info
->relocatable
3241 && (((r_type
== R_MIPS16_26
) && !target_is_16_bit_code_p
)
3242 || ((r_type
== R_MIPS_26
) && target_is_16_bit_code_p
)));
3244 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
3245 local_sections
, TRUE
);
3247 /* If we haven't already determined the GOT offset, or the GP value,
3248 and we're going to need it, get it now. */
3251 case R_MIPS_GOT_PAGE
:
3252 case R_MIPS_GOT_OFST
:
3253 /* We need to decay to GOT_DISP/addend if the symbol doesn't
3255 local_p
= local_p
|| _bfd_elf_symbol_refs_local_p (&h
->root
, info
, 1);
3256 if (local_p
|| r_type
== R_MIPS_GOT_OFST
)
3262 case R_MIPS_GOT_DISP
:
3263 case R_MIPS_GOT_HI16
:
3264 case R_MIPS_CALL_HI16
:
3265 case R_MIPS_GOT_LO16
:
3266 case R_MIPS_CALL_LO16
:
3267 /* Find the index into the GOT where this value is located. */
3270 /* GOT_PAGE may take a non-zero addend, that is ignored in a
3271 GOT_PAGE relocation that decays to GOT_DISP because the
3272 symbol turns out to be global. The addend is then added
3274 BFD_ASSERT (addend
== 0 || r_type
== R_MIPS_GOT_PAGE
);
3275 g
= mips_elf_global_got_index (elf_hash_table (info
)->dynobj
,
3277 (struct elf_link_hash_entry
*) h
);
3278 if (! elf_hash_table(info
)->dynamic_sections_created
3280 && (info
->symbolic
|| h
->root
.dynindx
== -1)
3281 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
3283 /* This is a static link or a -Bsymbolic link. The
3284 symbol is defined locally, or was forced to be local.
3285 We must initialize this entry in the GOT. */
3286 bfd
*tmpbfd
= elf_hash_table (info
)->dynobj
;
3287 asection
*sgot
= mips_elf_got_section (tmpbfd
, FALSE
);
3288 MIPS_ELF_PUT_WORD (tmpbfd
, symbol
, sgot
->contents
+ g
);
3291 else if (r_type
== R_MIPS_GOT16
|| r_type
== R_MIPS_CALL16
)
3292 /* There's no need to create a local GOT entry here; the
3293 calculation for a local GOT16 entry does not involve G. */
3297 g
= mips_elf_local_got_index (abfd
, input_bfd
,
3298 info
, symbol
+ addend
);
3300 return bfd_reloc_outofrange
;
3303 /* Convert GOT indices to actual offsets. */
3304 g
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3305 abfd
, input_bfd
, g
);
3310 case R_MIPS16_GPREL
:
3311 case R_MIPS_GPREL16
:
3312 case R_MIPS_GPREL32
:
3313 case R_MIPS_LITERAL
:
3314 gp0
= _bfd_get_gp_value (input_bfd
);
3315 gp
= _bfd_get_gp_value (abfd
);
3316 if (elf_hash_table (info
)->dynobj
)
3317 gp
+= mips_elf_adjust_gp (abfd
,
3319 (elf_hash_table (info
)->dynobj
, NULL
),
3327 /* Figure out what kind of relocation is being performed. */
3331 return bfd_reloc_continue
;
3334 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 16);
3335 overflowed_p
= mips_elf_overflow_p (value
, 16);
3342 || (elf_hash_table (info
)->dynamic_sections_created
3344 && ((h
->root
.elf_link_hash_flags
3345 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0)
3346 && ((h
->root
.elf_link_hash_flags
3347 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
3349 && (input_section
->flags
& SEC_ALLOC
) != 0)
3351 /* If we're creating a shared library, or this relocation is
3352 against a symbol in a shared library, then we can't know
3353 where the symbol will end up. So, we create a relocation
3354 record in the output, and leave the job up to the dynamic
3357 if (!mips_elf_create_dynamic_relocation (abfd
,
3365 return bfd_reloc_undefined
;
3369 if (r_type
!= R_MIPS_REL32
)
3370 value
= symbol
+ addend
;
3374 value
&= howto
->dst_mask
;
3379 case R_MIPS_GNU_REL_LO16
:
3380 value
= symbol
+ addend
- p
;
3381 value
&= howto
->dst_mask
;
3384 case R_MIPS_GNU_REL16_S2
:
3385 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 18) - p
;
3386 overflowed_p
= mips_elf_overflow_p (value
, 18);
3387 value
= (value
>> 2) & howto
->dst_mask
;
3390 case R_MIPS_GNU_REL_HI16
:
3391 /* Instead of subtracting 'p' here, we should be subtracting the
3392 equivalent value for the LO part of the reloc, since the value
3393 here is relative to that address. Because that's not easy to do,
3394 we adjust 'addend' in _bfd_mips_elf_relocate_section(). See also
3395 the comment there for more information. */
3396 value
= mips_elf_high (addend
+ symbol
- p
);
3397 value
&= howto
->dst_mask
;
3401 /* The calculation for R_MIPS16_26 is just the same as for an
3402 R_MIPS_26. It's only the storage of the relocated field into
3403 the output file that's different. That's handled in
3404 mips_elf_perform_relocation. So, we just fall through to the
3405 R_MIPS_26 case here. */
3408 value
= ((addend
| ((p
+ 4) & 0xf0000000)) + symbol
) >> 2;
3410 value
= (_bfd_mips_elf_sign_extend (addend
, 28) + symbol
) >> 2;
3411 value
&= howto
->dst_mask
;
3417 value
= mips_elf_high (addend
+ symbol
);
3418 value
&= howto
->dst_mask
;
3422 value
= mips_elf_high (addend
+ gp
- p
);
3423 overflowed_p
= mips_elf_overflow_p (value
, 16);
3429 value
= (symbol
+ addend
) & howto
->dst_mask
;
3432 value
= addend
+ gp
- p
+ 4;
3433 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
3434 for overflow. But, on, say, IRIX5, relocations against
3435 _gp_disp are normally generated from the .cpload
3436 pseudo-op. It generates code that normally looks like
3439 lui $gp,%hi(_gp_disp)
3440 addiu $gp,$gp,%lo(_gp_disp)
3443 Here $t9 holds the address of the function being called,
3444 as required by the MIPS ELF ABI. The R_MIPS_LO16
3445 relocation can easily overflow in this situation, but the
3446 R_MIPS_HI16 relocation will handle the overflow.
3447 Therefore, we consider this a bug in the MIPS ABI, and do
3448 not check for overflow here. */
3452 case R_MIPS_LITERAL
:
3453 /* Because we don't merge literal sections, we can handle this
3454 just like R_MIPS_GPREL16. In the long run, we should merge
3455 shared literals, and then we will need to additional work
3460 case R_MIPS16_GPREL
:
3461 /* The R_MIPS16_GPREL performs the same calculation as
3462 R_MIPS_GPREL16, but stores the relocated bits in a different
3463 order. We don't need to do anything special here; the
3464 differences are handled in mips_elf_perform_relocation. */
3465 case R_MIPS_GPREL16
:
3466 /* Only sign-extend the addend if it was extracted from the
3467 instruction. If the addend was separate, leave it alone,
3468 otherwise we may lose significant bits. */
3469 if (howto
->partial_inplace
)
3470 addend
= _bfd_mips_elf_sign_extend (addend
, 16);
3471 value
= symbol
+ addend
- gp
;
3472 /* If the symbol was local, any earlier relocatable links will
3473 have adjusted its addend with the gp offset, so compensate
3474 for that now. Don't do it for symbols forced local in this
3475 link, though, since they won't have had the gp offset applied
3479 overflowed_p
= mips_elf_overflow_p (value
, 16);
3488 /* The special case is when the symbol is forced to be local. We
3489 need the full address in the GOT since no R_MIPS_LO16 relocation
3491 forced
= ! mips_elf_local_relocation_p (input_bfd
, relocation
,
3492 local_sections
, FALSE
);
3493 value
= mips_elf_got16_entry (abfd
, input_bfd
, info
,
3494 symbol
+ addend
, forced
);
3495 if (value
== MINUS_ONE
)
3496 return bfd_reloc_outofrange
;
3498 = mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3499 abfd
, input_bfd
, value
);
3500 overflowed_p
= mips_elf_overflow_p (value
, 16);
3506 case R_MIPS_GOT_DISP
:
3509 overflowed_p
= mips_elf_overflow_p (value
, 16);
3512 case R_MIPS_GPREL32
:
3513 value
= (addend
+ symbol
+ gp0
- gp
);
3515 value
&= howto
->dst_mask
;
3519 value
= _bfd_mips_elf_sign_extend (addend
, 16) + symbol
- p
;
3520 overflowed_p
= mips_elf_overflow_p (value
, 16);
3523 case R_MIPS_GOT_HI16
:
3524 case R_MIPS_CALL_HI16
:
3525 /* We're allowed to handle these two relocations identically.
3526 The dynamic linker is allowed to handle the CALL relocations
3527 differently by creating a lazy evaluation stub. */
3529 value
= mips_elf_high (value
);
3530 value
&= howto
->dst_mask
;
3533 case R_MIPS_GOT_LO16
:
3534 case R_MIPS_CALL_LO16
:
3535 value
= g
& howto
->dst_mask
;
3538 case R_MIPS_GOT_PAGE
:
3539 /* GOT_PAGE relocations that reference non-local symbols decay
3540 to GOT_DISP. The corresponding GOT_OFST relocation decays to
3544 value
= mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, NULL
);
3545 if (value
== MINUS_ONE
)
3546 return bfd_reloc_outofrange
;
3547 value
= mips_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
3548 abfd
, input_bfd
, value
);
3549 overflowed_p
= mips_elf_overflow_p (value
, 16);
3552 case R_MIPS_GOT_OFST
:
3554 mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, &value
);
3557 overflowed_p
= mips_elf_overflow_p (value
, 16);
3561 value
= symbol
- addend
;
3562 value
&= howto
->dst_mask
;
3566 value
= mips_elf_higher (addend
+ symbol
);
3567 value
&= howto
->dst_mask
;
3570 case R_MIPS_HIGHEST
:
3571 value
= mips_elf_highest (addend
+ symbol
);
3572 value
&= howto
->dst_mask
;
3575 case R_MIPS_SCN_DISP
:
3576 value
= symbol
+ addend
- sec
->output_offset
;
3577 value
&= howto
->dst_mask
;
3582 /* Both of these may be ignored. R_MIPS_JALR is an optimization
3583 hint; we could improve performance by honoring that hint. */
3584 return bfd_reloc_continue
;
3586 case R_MIPS_GNU_VTINHERIT
:
3587 case R_MIPS_GNU_VTENTRY
:
3588 /* We don't do anything with these at present. */
3589 return bfd_reloc_continue
;
3592 /* An unrecognized relocation type. */
3593 return bfd_reloc_notsupported
;
3596 /* Store the VALUE for our caller. */
3598 return overflowed_p
? bfd_reloc_overflow
: bfd_reloc_ok
;
3601 /* Obtain the field relocated by RELOCATION. */
3604 mips_elf_obtain_contents (reloc_howto_type
*howto
,
3605 const Elf_Internal_Rela
*relocation
,
3606 bfd
*input_bfd
, bfd_byte
*contents
)
3609 bfd_byte
*location
= contents
+ relocation
->r_offset
;
3611 /* Obtain the bytes. */
3612 x
= bfd_get ((8 * bfd_get_reloc_size (howto
)), input_bfd
, location
);
3614 if ((ELF_R_TYPE (input_bfd
, relocation
->r_info
) == R_MIPS16_26
3615 || ELF_R_TYPE (input_bfd
, relocation
->r_info
) == R_MIPS16_GPREL
)
3616 && bfd_little_endian (input_bfd
))
3617 /* The two 16-bit words will be reversed on a little-endian system.
3618 See mips_elf_perform_relocation for more details. */
3619 x
= (((x
& 0xffff) << 16) | ((x
& 0xffff0000) >> 16));
3624 /* It has been determined that the result of the RELOCATION is the
3625 VALUE. Use HOWTO to place VALUE into the output file at the
3626 appropriate position. The SECTION is the section to which the
3627 relocation applies. If REQUIRE_JALX is TRUE, then the opcode used
3628 for the relocation must be either JAL or JALX, and it is
3629 unconditionally converted to JALX.
3631 Returns FALSE if anything goes wrong. */
3634 mips_elf_perform_relocation (struct bfd_link_info
*info
,
3635 reloc_howto_type
*howto
,
3636 const Elf_Internal_Rela
*relocation
,
3637 bfd_vma value
, bfd
*input_bfd
,
3638 asection
*input_section
, bfd_byte
*contents
,
3639 bfd_boolean require_jalx
)
3643 int r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
3645 /* Figure out where the relocation is occurring. */
3646 location
= contents
+ relocation
->r_offset
;
3648 /* Obtain the current value. */
3649 x
= mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
);
3651 /* Clear the field we are setting. */
3652 x
&= ~howto
->dst_mask
;
3654 /* If this is the R_MIPS16_26 relocation, we must store the
3655 value in a funny way. */
3656 if (r_type
== R_MIPS16_26
)
3658 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
3659 Most mips16 instructions are 16 bits, but these instructions
3662 The format of these instructions is:
3664 +--------------+--------------------------------+
3665 ! JALX ! X! Imm 20:16 ! Imm 25:21 !
3666 +--------------+--------------------------------+
3668 +-----------------------------------------------+
3670 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
3671 Note that the immediate value in the first word is swapped.
3673 When producing a relocatable object file, R_MIPS16_26 is
3674 handled mostly like R_MIPS_26. In particular, the addend is
3675 stored as a straight 26-bit value in a 32-bit instruction.
3676 (gas makes life simpler for itself by never adjusting a
3677 R_MIPS16_26 reloc to be against a section, so the addend is
3678 always zero). However, the 32 bit instruction is stored as 2
3679 16-bit values, rather than a single 32-bit value. In a
3680 big-endian file, the result is the same; in a little-endian
3681 file, the two 16-bit halves of the 32 bit value are swapped.
3682 This is so that a disassembler can recognize the jal
3685 When doing a final link, R_MIPS16_26 is treated as a 32 bit
3686 instruction stored as two 16-bit values. The addend A is the
3687 contents of the targ26 field. The calculation is the same as
3688 R_MIPS_26. When storing the calculated value, reorder the
3689 immediate value as shown above, and don't forget to store the
3690 value as two 16-bit values.
3692 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
3696 +--------+----------------------+
3700 +--------+----------------------+
3703 +----------+------+-------------+
3707 +----------+--------------------+
3708 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
3709 ((sub1 << 16) | sub2)).
3711 When producing a relocatable object file, the calculation is
3712 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
3713 When producing a fully linked file, the calculation is
3714 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
3715 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff) */
3717 if (!info
->relocatable
)
3718 /* Shuffle the bits according to the formula above. */
3719 value
= (((value
& 0x1f0000) << 5)
3720 | ((value
& 0x3e00000) >> 5)
3721 | (value
& 0xffff));
3723 else if (r_type
== R_MIPS16_GPREL
)
3725 /* R_MIPS16_GPREL is used for GP-relative addressing in mips16
3726 mode. A typical instruction will have a format like this:
3728 +--------------+--------------------------------+
3729 ! EXTEND ! Imm 10:5 ! Imm 15:11 !
3730 +--------------+--------------------------------+
3731 ! Major ! rx ! ry ! Imm 4:0 !
3732 +--------------+--------------------------------+
3734 EXTEND is the five bit value 11110. Major is the instruction
3737 This is handled exactly like R_MIPS_GPREL16, except that the
3738 addend is retrieved and stored as shown in this diagram; that
3739 is, the Imm fields above replace the V-rel16 field.
3741 All we need to do here is shuffle the bits appropriately. As
3742 above, the two 16-bit halves must be swapped on a
3743 little-endian system. */
3744 value
= (((value
& 0x7e0) << 16)
3745 | ((value
& 0xf800) << 5)
3749 /* Set the field. */
3750 x
|= (value
& howto
->dst_mask
);
3752 /* If required, turn JAL into JALX. */
3756 bfd_vma opcode
= x
>> 26;
3757 bfd_vma jalx_opcode
;
3759 /* Check to see if the opcode is already JAL or JALX. */
3760 if (r_type
== R_MIPS16_26
)
3762 ok
= ((opcode
== 0x6) || (opcode
== 0x7));
3767 ok
= ((opcode
== 0x3) || (opcode
== 0x1d));
3771 /* If the opcode is not JAL or JALX, there's a problem. */
3774 (*_bfd_error_handler
)
3775 (_("%s: %s+0x%lx: jump to stub routine which is not jal"),
3776 bfd_archive_filename (input_bfd
),
3777 input_section
->name
,
3778 (unsigned long) relocation
->r_offset
);
3779 bfd_set_error (bfd_error_bad_value
);
3783 /* Make this the JALX opcode. */
3784 x
= (x
& ~(0x3f << 26)) | (jalx_opcode
<< 26);
3787 /* Swap the high- and low-order 16 bits on little-endian systems
3788 when doing a MIPS16 relocation. */
3789 if ((r_type
== R_MIPS16_GPREL
|| r_type
== R_MIPS16_26
)
3790 && bfd_little_endian (input_bfd
))
3791 x
= (((x
& 0xffff) << 16) | ((x
& 0xffff0000) >> 16));
3793 /* Put the value into the output. */
3794 bfd_put (8 * bfd_get_reloc_size (howto
), input_bfd
, x
, location
);
3798 /* Returns TRUE if SECTION is a MIPS16 stub section. */
3801 mips_elf_stub_section_p (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*section
)
3803 const char *name
= bfd_get_section_name (abfd
, section
);
3805 return (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0
3806 || strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
3807 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0);
3810 /* Add room for N relocations to the .rel.dyn section in ABFD. */
3813 mips_elf_allocate_dynamic_relocations (bfd
*abfd
, unsigned int n
)
3817 s
= mips_elf_rel_dyn_section (abfd
, FALSE
);
3818 BFD_ASSERT (s
!= NULL
);
3820 if (s
->_raw_size
== 0)
3822 /* Make room for a null element. */
3823 s
->_raw_size
+= MIPS_ELF_REL_SIZE (abfd
);
3826 s
->_raw_size
+= n
* MIPS_ELF_REL_SIZE (abfd
);
3829 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
3830 is the original relocation, which is now being transformed into a
3831 dynamic relocation. The ADDENDP is adjusted if necessary; the
3832 caller should store the result in place of the original addend. */
3835 mips_elf_create_dynamic_relocation (bfd
*output_bfd
,
3836 struct bfd_link_info
*info
,
3837 const Elf_Internal_Rela
*rel
,
3838 struct mips_elf_link_hash_entry
*h
,
3839 asection
*sec
, bfd_vma symbol
,
3840 bfd_vma
*addendp
, asection
*input_section
)
3842 Elf_Internal_Rela outrel
[3];
3848 r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
3849 dynobj
= elf_hash_table (info
)->dynobj
;
3850 sreloc
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
3851 BFD_ASSERT (sreloc
!= NULL
);
3852 BFD_ASSERT (sreloc
->contents
!= NULL
);
3853 BFD_ASSERT (sreloc
->reloc_count
* MIPS_ELF_REL_SIZE (output_bfd
)
3854 < sreloc
->_raw_size
);
3857 outrel
[0].r_offset
=
3858 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[0].r_offset
);
3859 outrel
[1].r_offset
=
3860 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[1].r_offset
);
3861 outrel
[2].r_offset
=
3862 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[2].r_offset
);
3865 /* We begin by assuming that the offset for the dynamic relocation
3866 is the same as for the original relocation. We'll adjust this
3867 later to reflect the correct output offsets. */
3868 if (input_section
->sec_info_type
!= ELF_INFO_TYPE_STABS
)
3870 outrel
[1].r_offset
= rel
[1].r_offset
;
3871 outrel
[2].r_offset
= rel
[2].r_offset
;
3875 /* Except that in a stab section things are more complex.
3876 Because we compress stab information, the offset given in the
3877 relocation may not be the one we want; we must let the stabs
3878 machinery tell us the offset. */
3879 outrel
[1].r_offset
= outrel
[0].r_offset
;
3880 outrel
[2].r_offset
= outrel
[0].r_offset
;
3881 /* If we didn't need the relocation at all, this value will be
3883 if (outrel
[0].r_offset
== (bfd_vma
) -1)
3888 if (outrel
[0].r_offset
== (bfd_vma
) -1)
3889 /* The relocation field has been deleted. */
3891 else if (outrel
[0].r_offset
== (bfd_vma
) -2)
3893 /* The relocation field has been converted into a relative value of
3894 some sort. Functions like _bfd_elf_write_section_eh_frame expect
3895 the field to be fully relocated, so add in the symbol's value. */
3900 /* If we've decided to skip this relocation, just output an empty
3901 record. Note that R_MIPS_NONE == 0, so that this call to memset
3902 is a way of setting R_TYPE to R_MIPS_NONE. */
3904 memset (outrel
, 0, sizeof (Elf_Internal_Rela
) * 3);
3908 bfd_boolean defined_p
;
3910 /* We must now calculate the dynamic symbol table index to use
3911 in the relocation. */
3913 && (! info
->symbolic
|| (h
->root
.elf_link_hash_flags
3914 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
3915 /* h->root.dynindx may be -1 if this symbol was marked to
3917 && h
->root
.dynindx
!= -1)
3919 indx
= h
->root
.dynindx
;
3920 if (SGI_COMPAT (output_bfd
))
3921 defined_p
= ((h
->root
.elf_link_hash_flags
3922 & ELF_LINK_HASH_DEF_REGULAR
) != 0);
3924 /* ??? glibc's ld.so just adds the final GOT entry to the
3925 relocation field. It therefore treats relocs against
3926 defined symbols in the same way as relocs against
3927 undefined symbols. */
3932 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
3934 else if (sec
== NULL
|| sec
->owner
== NULL
)
3936 bfd_set_error (bfd_error_bad_value
);
3941 indx
= elf_section_data (sec
->output_section
)->dynindx
;
3946 /* Instead of generating a relocation using the section
3947 symbol, we may as well make it a fully relative
3948 relocation. We want to avoid generating relocations to
3949 local symbols because we used to generate them
3950 incorrectly, without adding the original symbol value,
3951 which is mandated by the ABI for section symbols. In
3952 order to give dynamic loaders and applications time to
3953 phase out the incorrect use, we refrain from emitting
3954 section-relative relocations. It's not like they're
3955 useful, after all. This should be a bit more efficient
3957 /* ??? Although this behavior is compatible with glibc's ld.so,
3958 the ABI says that relocations against STN_UNDEF should have
3959 a symbol value of 0. Irix rld honors this, so relocations
3960 against STN_UNDEF have no effect. */
3961 if (!SGI_COMPAT (output_bfd
))
3966 /* If the relocation was previously an absolute relocation and
3967 this symbol will not be referred to by the relocation, we must
3968 adjust it by the value we give it in the dynamic symbol table.
3969 Otherwise leave the job up to the dynamic linker. */
3970 if (defined_p
&& r_type
!= R_MIPS_REL32
)
3973 /* The relocation is always an REL32 relocation because we don't
3974 know where the shared library will wind up at load-time. */
3975 outrel
[0].r_info
= ELF_R_INFO (output_bfd
, (unsigned long) indx
,
3977 /* For strict adherence to the ABI specification, we should
3978 generate a R_MIPS_64 relocation record by itself before the
3979 _REL32/_64 record as well, such that the addend is read in as
3980 a 64-bit value (REL32 is a 32-bit relocation, after all).
3981 However, since none of the existing ELF64 MIPS dynamic
3982 loaders seems to care, we don't waste space with these
3983 artificial relocations. If this turns out to not be true,
3984 mips_elf_allocate_dynamic_relocation() should be tweaked so
3985 as to make room for a pair of dynamic relocations per
3986 invocation if ABI_64_P, and here we should generate an
3987 additional relocation record with R_MIPS_64 by itself for a
3988 NULL symbol before this relocation record. */
3989 outrel
[1].r_info
= ELF_R_INFO (output_bfd
, 0,
3990 ABI_64_P (output_bfd
)
3993 outrel
[2].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_NONE
);
3995 /* Adjust the output offset of the relocation to reference the
3996 correct location in the output file. */
3997 outrel
[0].r_offset
+= (input_section
->output_section
->vma
3998 + input_section
->output_offset
);
3999 outrel
[1].r_offset
+= (input_section
->output_section
->vma
4000 + input_section
->output_offset
);
4001 outrel
[2].r_offset
+= (input_section
->output_section
->vma
4002 + input_section
->output_offset
);
4005 /* Put the relocation back out. We have to use the special
4006 relocation outputter in the 64-bit case since the 64-bit
4007 relocation format is non-standard. */
4008 if (ABI_64_P (output_bfd
))
4010 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
4011 (output_bfd
, &outrel
[0],
4013 + sreloc
->reloc_count
* sizeof (Elf64_Mips_External_Rel
)));
4016 bfd_elf32_swap_reloc_out
4017 (output_bfd
, &outrel
[0],
4018 (sreloc
->contents
+ sreloc
->reloc_count
* sizeof (Elf32_External_Rel
)));
4020 /* We've now added another relocation. */
4021 ++sreloc
->reloc_count
;
4023 /* Make sure the output section is writable. The dynamic linker
4024 will be writing to it. */
4025 elf_section_data (input_section
->output_section
)->this_hdr
.sh_flags
4028 /* On IRIX5, make an entry of compact relocation info. */
4029 if (! skip
&& IRIX_COMPAT (output_bfd
) == ict_irix5
)
4031 asection
*scpt
= bfd_get_section_by_name (dynobj
, ".compact_rel");
4036 Elf32_crinfo cptrel
;
4038 mips_elf_set_cr_format (cptrel
, CRF_MIPS_LONG
);
4039 cptrel
.vaddr
= (rel
->r_offset
4040 + input_section
->output_section
->vma
4041 + input_section
->output_offset
);
4042 if (r_type
== R_MIPS_REL32
)
4043 mips_elf_set_cr_type (cptrel
, CRT_MIPS_REL32
);
4045 mips_elf_set_cr_type (cptrel
, CRT_MIPS_WORD
);
4046 mips_elf_set_cr_dist2to (cptrel
, 0);
4047 cptrel
.konst
= *addendp
;
4049 cr
= (scpt
->contents
4050 + sizeof (Elf32_External_compact_rel
));
4051 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
4052 ((Elf32_External_crinfo
*) cr
4053 + scpt
->reloc_count
));
4054 ++scpt
->reloc_count
;
4061 /* Return the MACH for a MIPS e_flags value. */
4064 _bfd_elf_mips_mach (flagword flags
)
4066 switch (flags
& EF_MIPS_MACH
)
4068 case E_MIPS_MACH_3900
:
4069 return bfd_mach_mips3900
;
4071 case E_MIPS_MACH_4010
:
4072 return bfd_mach_mips4010
;
4074 case E_MIPS_MACH_4100
:
4075 return bfd_mach_mips4100
;
4077 case E_MIPS_MACH_4111
:
4078 return bfd_mach_mips4111
;
4080 case E_MIPS_MACH_4120
:
4081 return bfd_mach_mips4120
;
4083 case E_MIPS_MACH_4650
:
4084 return bfd_mach_mips4650
;
4086 case E_MIPS_MACH_5400
:
4087 return bfd_mach_mips5400
;
4089 case E_MIPS_MACH_5500
:
4090 return bfd_mach_mips5500
;
4092 case E_MIPS_MACH_SB1
:
4093 return bfd_mach_mips_sb1
;
4096 switch (flags
& EF_MIPS_ARCH
)
4100 return bfd_mach_mips3000
;
4104 return bfd_mach_mips6000
;
4108 return bfd_mach_mips4000
;
4112 return bfd_mach_mips8000
;
4116 return bfd_mach_mips5
;
4119 case E_MIPS_ARCH_32
:
4120 return bfd_mach_mipsisa32
;
4123 case E_MIPS_ARCH_64
:
4124 return bfd_mach_mipsisa64
;
4127 case E_MIPS_ARCH_32R2
:
4128 return bfd_mach_mipsisa32r2
;
4131 case E_MIPS_ARCH_64R2
:
4132 return bfd_mach_mipsisa64r2
;
4140 /* Return printable name for ABI. */
4142 static INLINE
char *
4143 elf_mips_abi_name (bfd
*abfd
)
4147 flags
= elf_elfheader (abfd
)->e_flags
;
4148 switch (flags
& EF_MIPS_ABI
)
4151 if (ABI_N32_P (abfd
))
4153 else if (ABI_64_P (abfd
))
4157 case E_MIPS_ABI_O32
:
4159 case E_MIPS_ABI_O64
:
4161 case E_MIPS_ABI_EABI32
:
4163 case E_MIPS_ABI_EABI64
:
4166 return "unknown abi";
4170 /* MIPS ELF uses two common sections. One is the usual one, and the
4171 other is for small objects. All the small objects are kept
4172 together, and then referenced via the gp pointer, which yields
4173 faster assembler code. This is what we use for the small common
4174 section. This approach is copied from ecoff.c. */
4175 static asection mips_elf_scom_section
;
4176 static asymbol mips_elf_scom_symbol
;
4177 static asymbol
*mips_elf_scom_symbol_ptr
;
4179 /* MIPS ELF also uses an acommon section, which represents an
4180 allocated common symbol which may be overridden by a
4181 definition in a shared library. */
4182 static asection mips_elf_acom_section
;
4183 static asymbol mips_elf_acom_symbol
;
4184 static asymbol
*mips_elf_acom_symbol_ptr
;
4186 /* Handle the special MIPS section numbers that a symbol may use.
4187 This is used for both the 32-bit and the 64-bit ABI. */
4190 _bfd_mips_elf_symbol_processing (bfd
*abfd
, asymbol
*asym
)
4192 elf_symbol_type
*elfsym
;
4194 elfsym
= (elf_symbol_type
*) asym
;
4195 switch (elfsym
->internal_elf_sym
.st_shndx
)
4197 case SHN_MIPS_ACOMMON
:
4198 /* This section is used in a dynamically linked executable file.
4199 It is an allocated common section. The dynamic linker can
4200 either resolve these symbols to something in a shared
4201 library, or it can just leave them here. For our purposes,
4202 we can consider these symbols to be in a new section. */
4203 if (mips_elf_acom_section
.name
== NULL
)
4205 /* Initialize the acommon section. */
4206 mips_elf_acom_section
.name
= ".acommon";
4207 mips_elf_acom_section
.flags
= SEC_ALLOC
;
4208 mips_elf_acom_section
.output_section
= &mips_elf_acom_section
;
4209 mips_elf_acom_section
.symbol
= &mips_elf_acom_symbol
;
4210 mips_elf_acom_section
.symbol_ptr_ptr
= &mips_elf_acom_symbol_ptr
;
4211 mips_elf_acom_symbol
.name
= ".acommon";
4212 mips_elf_acom_symbol
.flags
= BSF_SECTION_SYM
;
4213 mips_elf_acom_symbol
.section
= &mips_elf_acom_section
;
4214 mips_elf_acom_symbol_ptr
= &mips_elf_acom_symbol
;
4216 asym
->section
= &mips_elf_acom_section
;
4220 /* Common symbols less than the GP size are automatically
4221 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
4222 if (asym
->value
> elf_gp_size (abfd
)
4223 || IRIX_COMPAT (abfd
) == ict_irix6
)
4226 case SHN_MIPS_SCOMMON
:
4227 if (mips_elf_scom_section
.name
== NULL
)
4229 /* Initialize the small common section. */
4230 mips_elf_scom_section
.name
= ".scommon";
4231 mips_elf_scom_section
.flags
= SEC_IS_COMMON
;
4232 mips_elf_scom_section
.output_section
= &mips_elf_scom_section
;
4233 mips_elf_scom_section
.symbol
= &mips_elf_scom_symbol
;
4234 mips_elf_scom_section
.symbol_ptr_ptr
= &mips_elf_scom_symbol_ptr
;
4235 mips_elf_scom_symbol
.name
= ".scommon";
4236 mips_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
4237 mips_elf_scom_symbol
.section
= &mips_elf_scom_section
;
4238 mips_elf_scom_symbol_ptr
= &mips_elf_scom_symbol
;
4240 asym
->section
= &mips_elf_scom_section
;
4241 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
4244 case SHN_MIPS_SUNDEFINED
:
4245 asym
->section
= bfd_und_section_ptr
;
4248 #if 0 /* for SGI_COMPAT */
4250 asym
->section
= mips_elf_text_section_ptr
;
4254 asym
->section
= mips_elf_data_section_ptr
;
4260 /* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
4261 relocations against two unnamed section symbols to resolve to the
4262 same address. For example, if we have code like:
4264 lw $4,%got_disp(.data)($gp)
4265 lw $25,%got_disp(.text)($gp)
4268 then the linker will resolve both relocations to .data and the program
4269 will jump there rather than to .text.
4271 We can work around this problem by giving names to local section symbols.
4272 This is also what the MIPSpro tools do. */
4275 _bfd_mips_elf_name_local_section_symbols (bfd
*abfd
)
4277 return SGI_COMPAT (abfd
);
4280 /* Work over a section just before writing it out. This routine is
4281 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
4282 sections that need the SHF_MIPS_GPREL flag by name; there has to be
4286 _bfd_mips_elf_section_processing (bfd
*abfd
, Elf_Internal_Shdr
*hdr
)
4288 if (hdr
->sh_type
== SHT_MIPS_REGINFO
4289 && hdr
->sh_size
> 0)
4293 BFD_ASSERT (hdr
->sh_size
== sizeof (Elf32_External_RegInfo
));
4294 BFD_ASSERT (hdr
->contents
== NULL
);
4297 hdr
->sh_offset
+ sizeof (Elf32_External_RegInfo
) - 4,
4300 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
4301 if (bfd_bwrite (buf
, 4, abfd
) != 4)
4305 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
4306 && hdr
->bfd_section
!= NULL
4307 && mips_elf_section_data (hdr
->bfd_section
) != NULL
4308 && mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
!= NULL
)
4310 bfd_byte
*contents
, *l
, *lend
;
4312 /* We stored the section contents in the tdata field in the
4313 set_section_contents routine. We save the section contents
4314 so that we don't have to read them again.
4315 At this point we know that elf_gp is set, so we can look
4316 through the section contents to see if there is an
4317 ODK_REGINFO structure. */
4319 contents
= mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
;
4321 lend
= contents
+ hdr
->sh_size
;
4322 while (l
+ sizeof (Elf_External_Options
) <= lend
)
4324 Elf_Internal_Options intopt
;
4326 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
4328 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
4335 + sizeof (Elf_External_Options
)
4336 + (sizeof (Elf64_External_RegInfo
) - 8)),
4339 H_PUT_64 (abfd
, elf_gp (abfd
), buf
);
4340 if (bfd_bwrite (buf
, 8, abfd
) != 8)
4343 else if (intopt
.kind
== ODK_REGINFO
)
4350 + sizeof (Elf_External_Options
)
4351 + (sizeof (Elf32_External_RegInfo
) - 4)),
4354 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
4355 if (bfd_bwrite (buf
, 4, abfd
) != 4)
4362 if (hdr
->bfd_section
!= NULL
)
4364 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
4366 if (strcmp (name
, ".sdata") == 0
4367 || strcmp (name
, ".lit8") == 0
4368 || strcmp (name
, ".lit4") == 0)
4370 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
4371 hdr
->sh_type
= SHT_PROGBITS
;
4373 else if (strcmp (name
, ".sbss") == 0)
4375 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
4376 hdr
->sh_type
= SHT_NOBITS
;
4378 else if (strcmp (name
, ".srdata") == 0)
4380 hdr
->sh_flags
|= SHF_ALLOC
| SHF_MIPS_GPREL
;
4381 hdr
->sh_type
= SHT_PROGBITS
;
4383 else if (strcmp (name
, ".compact_rel") == 0)
4386 hdr
->sh_type
= SHT_PROGBITS
;
4388 else if (strcmp (name
, ".rtproc") == 0)
4390 if (hdr
->sh_addralign
!= 0 && hdr
->sh_entsize
== 0)
4392 unsigned int adjust
;
4394 adjust
= hdr
->sh_size
% hdr
->sh_addralign
;
4396 hdr
->sh_size
+= hdr
->sh_addralign
- adjust
;
4404 /* Handle a MIPS specific section when reading an object file. This
4405 is called when elfcode.h finds a section with an unknown type.
4406 This routine supports both the 32-bit and 64-bit ELF ABI.
4408 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
4412 _bfd_mips_elf_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
4417 /* There ought to be a place to keep ELF backend specific flags, but
4418 at the moment there isn't one. We just keep track of the
4419 sections by their name, instead. Fortunately, the ABI gives
4420 suggested names for all the MIPS specific sections, so we will
4421 probably get away with this. */
4422 switch (hdr
->sh_type
)
4424 case SHT_MIPS_LIBLIST
:
4425 if (strcmp (name
, ".liblist") != 0)
4429 if (strcmp (name
, ".msym") != 0)
4432 case SHT_MIPS_CONFLICT
:
4433 if (strcmp (name
, ".conflict") != 0)
4436 case SHT_MIPS_GPTAB
:
4437 if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) != 0)
4440 case SHT_MIPS_UCODE
:
4441 if (strcmp (name
, ".ucode") != 0)
4444 case SHT_MIPS_DEBUG
:
4445 if (strcmp (name
, ".mdebug") != 0)
4447 flags
= SEC_DEBUGGING
;
4449 case SHT_MIPS_REGINFO
:
4450 if (strcmp (name
, ".reginfo") != 0
4451 || hdr
->sh_size
!= sizeof (Elf32_External_RegInfo
))
4453 flags
= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_SIZE
);
4455 case SHT_MIPS_IFACE
:
4456 if (strcmp (name
, ".MIPS.interfaces") != 0)
4459 case SHT_MIPS_CONTENT
:
4460 if (strncmp (name
, ".MIPS.content", sizeof ".MIPS.content" - 1) != 0)
4463 case SHT_MIPS_OPTIONS
:
4464 if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) != 0)
4467 case SHT_MIPS_DWARF
:
4468 if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) != 0)
4471 case SHT_MIPS_SYMBOL_LIB
:
4472 if (strcmp (name
, ".MIPS.symlib") != 0)
4475 case SHT_MIPS_EVENTS
:
4476 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) != 0
4477 && strncmp (name
, ".MIPS.post_rel",
4478 sizeof ".MIPS.post_rel" - 1) != 0)
4485 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
4490 if (! bfd_set_section_flags (abfd
, hdr
->bfd_section
,
4491 (bfd_get_section_flags (abfd
,
4497 /* FIXME: We should record sh_info for a .gptab section. */
4499 /* For a .reginfo section, set the gp value in the tdata information
4500 from the contents of this section. We need the gp value while
4501 processing relocs, so we just get it now. The .reginfo section
4502 is not used in the 64-bit MIPS ELF ABI. */
4503 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
4505 Elf32_External_RegInfo ext
;
4508 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
,
4509 &ext
, 0, sizeof ext
))
4511 bfd_mips_elf32_swap_reginfo_in (abfd
, &ext
, &s
);
4512 elf_gp (abfd
) = s
.ri_gp_value
;
4515 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
4516 set the gp value based on what we find. We may see both
4517 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
4518 they should agree. */
4519 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
)
4521 bfd_byte
*contents
, *l
, *lend
;
4523 contents
= bfd_malloc (hdr
->sh_size
);
4524 if (contents
== NULL
)
4526 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
,
4533 lend
= contents
+ hdr
->sh_size
;
4534 while (l
+ sizeof (Elf_External_Options
) <= lend
)
4536 Elf_Internal_Options intopt
;
4538 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
4540 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
4542 Elf64_Internal_RegInfo intreg
;
4544 bfd_mips_elf64_swap_reginfo_in
4546 ((Elf64_External_RegInfo
*)
4547 (l
+ sizeof (Elf_External_Options
))),
4549 elf_gp (abfd
) = intreg
.ri_gp_value
;
4551 else if (intopt
.kind
== ODK_REGINFO
)
4553 Elf32_RegInfo intreg
;
4555 bfd_mips_elf32_swap_reginfo_in
4557 ((Elf32_External_RegInfo
*)
4558 (l
+ sizeof (Elf_External_Options
))),
4560 elf_gp (abfd
) = intreg
.ri_gp_value
;
4570 /* Set the correct type for a MIPS ELF section. We do this by the
4571 section name, which is a hack, but ought to work. This routine is
4572 used by both the 32-bit and the 64-bit ABI. */
4575 _bfd_mips_elf_fake_sections (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*sec
)
4577 register const char *name
;
4579 name
= bfd_get_section_name (abfd
, sec
);
4581 if (strcmp (name
, ".liblist") == 0)
4583 hdr
->sh_type
= SHT_MIPS_LIBLIST
;
4584 hdr
->sh_info
= sec
->_raw_size
/ sizeof (Elf32_Lib
);
4585 /* The sh_link field is set in final_write_processing. */
4587 else if (strcmp (name
, ".conflict") == 0)
4588 hdr
->sh_type
= SHT_MIPS_CONFLICT
;
4589 else if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0)
4591 hdr
->sh_type
= SHT_MIPS_GPTAB
;
4592 hdr
->sh_entsize
= sizeof (Elf32_External_gptab
);
4593 /* The sh_info field is set in final_write_processing. */
4595 else if (strcmp (name
, ".ucode") == 0)
4596 hdr
->sh_type
= SHT_MIPS_UCODE
;
4597 else if (strcmp (name
, ".mdebug") == 0)
4599 hdr
->sh_type
= SHT_MIPS_DEBUG
;
4600 /* In a shared object on IRIX 5.3, the .mdebug section has an
4601 entsize of 0. FIXME: Does this matter? */
4602 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
4603 hdr
->sh_entsize
= 0;
4605 hdr
->sh_entsize
= 1;
4607 else if (strcmp (name
, ".reginfo") == 0)
4609 hdr
->sh_type
= SHT_MIPS_REGINFO
;
4610 /* In a shared object on IRIX 5.3, the .reginfo section has an
4611 entsize of 0x18. FIXME: Does this matter? */
4612 if (SGI_COMPAT (abfd
))
4614 if ((abfd
->flags
& DYNAMIC
) != 0)
4615 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
4617 hdr
->sh_entsize
= 1;
4620 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
4622 else if (SGI_COMPAT (abfd
)
4623 && (strcmp (name
, ".hash") == 0
4624 || strcmp (name
, ".dynamic") == 0
4625 || strcmp (name
, ".dynstr") == 0))
4627 if (SGI_COMPAT (abfd
))
4628 hdr
->sh_entsize
= 0;
4630 /* This isn't how the IRIX6 linker behaves. */
4631 hdr
->sh_info
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
4634 else if (strcmp (name
, ".got") == 0
4635 || strcmp (name
, ".srdata") == 0
4636 || strcmp (name
, ".sdata") == 0
4637 || strcmp (name
, ".sbss") == 0
4638 || strcmp (name
, ".lit4") == 0
4639 || strcmp (name
, ".lit8") == 0)
4640 hdr
->sh_flags
|= SHF_MIPS_GPREL
;
4641 else if (strcmp (name
, ".MIPS.interfaces") == 0)
4643 hdr
->sh_type
= SHT_MIPS_IFACE
;
4644 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4646 else if (strncmp (name
, ".MIPS.content", strlen (".MIPS.content")) == 0)
4648 hdr
->sh_type
= SHT_MIPS_CONTENT
;
4649 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4650 /* The sh_info field is set in final_write_processing. */
4652 else if (strcmp (name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
4654 hdr
->sh_type
= SHT_MIPS_OPTIONS
;
4655 hdr
->sh_entsize
= 1;
4656 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4658 else if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) == 0)
4659 hdr
->sh_type
= SHT_MIPS_DWARF
;
4660 else if (strcmp (name
, ".MIPS.symlib") == 0)
4662 hdr
->sh_type
= SHT_MIPS_SYMBOL_LIB
;
4663 /* The sh_link and sh_info fields are set in
4664 final_write_processing. */
4666 else if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0
4667 || strncmp (name
, ".MIPS.post_rel",
4668 sizeof ".MIPS.post_rel" - 1) == 0)
4670 hdr
->sh_type
= SHT_MIPS_EVENTS
;
4671 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
4672 /* The sh_link field is set in final_write_processing. */
4674 else if (strcmp (name
, ".msym") == 0)
4676 hdr
->sh_type
= SHT_MIPS_MSYM
;
4677 hdr
->sh_flags
|= SHF_ALLOC
;
4678 hdr
->sh_entsize
= 8;
4681 /* The generic elf_fake_sections will set up REL_HDR using the default
4682 kind of relocations. We used to set up a second header for the
4683 non-default kind of relocations here, but only NewABI would use
4684 these, and the IRIX ld doesn't like resulting empty RELA sections.
4685 Thus we create those header only on demand now. */
4690 /* Given a BFD section, try to locate the corresponding ELF section
4691 index. This is used by both the 32-bit and the 64-bit ABI.
4692 Actually, it's not clear to me that the 64-bit ABI supports these,
4693 but for non-PIC objects we will certainly want support for at least
4694 the .scommon section. */
4697 _bfd_mips_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
4698 asection
*sec
, int *retval
)
4700 if (strcmp (bfd_get_section_name (abfd
, sec
), ".scommon") == 0)
4702 *retval
= SHN_MIPS_SCOMMON
;
4705 if (strcmp (bfd_get_section_name (abfd
, sec
), ".acommon") == 0)
4707 *retval
= SHN_MIPS_ACOMMON
;
4713 /* Hook called by the linker routine which adds symbols from an object
4714 file. We must handle the special MIPS section numbers here. */
4717 _bfd_mips_elf_add_symbol_hook (bfd
*abfd
, struct bfd_link_info
*info
,
4718 const Elf_Internal_Sym
*sym
, const char **namep
,
4719 flagword
*flagsp ATTRIBUTE_UNUSED
,
4720 asection
**secp
, bfd_vma
*valp
)
4722 if (SGI_COMPAT (abfd
)
4723 && (abfd
->flags
& DYNAMIC
) != 0
4724 && strcmp (*namep
, "_rld_new_interface") == 0)
4726 /* Skip IRIX5 rld entry name. */
4731 switch (sym
->st_shndx
)
4734 /* Common symbols less than the GP size are automatically
4735 treated as SHN_MIPS_SCOMMON symbols. */
4736 if (sym
->st_size
> elf_gp_size (abfd
)
4737 || IRIX_COMPAT (abfd
) == ict_irix6
)
4740 case SHN_MIPS_SCOMMON
:
4741 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
4742 (*secp
)->flags
|= SEC_IS_COMMON
;
4743 *valp
= sym
->st_size
;
4747 /* This section is used in a shared object. */
4748 if (elf_tdata (abfd
)->elf_text_section
== NULL
)
4750 asymbol
*elf_text_symbol
;
4751 asection
*elf_text_section
;
4752 bfd_size_type amt
= sizeof (asection
);
4754 elf_text_section
= bfd_zalloc (abfd
, amt
);
4755 if (elf_text_section
== NULL
)
4758 amt
= sizeof (asymbol
);
4759 elf_text_symbol
= bfd_zalloc (abfd
, amt
);
4760 if (elf_text_symbol
== NULL
)
4763 /* Initialize the section. */
4765 elf_tdata (abfd
)->elf_text_section
= elf_text_section
;
4766 elf_tdata (abfd
)->elf_text_symbol
= elf_text_symbol
;
4768 elf_text_section
->symbol
= elf_text_symbol
;
4769 elf_text_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_text_symbol
;
4771 elf_text_section
->name
= ".text";
4772 elf_text_section
->flags
= SEC_NO_FLAGS
;
4773 elf_text_section
->output_section
= NULL
;
4774 elf_text_section
->owner
= abfd
;
4775 elf_text_symbol
->name
= ".text";
4776 elf_text_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
4777 elf_text_symbol
->section
= elf_text_section
;
4779 /* This code used to do *secp = bfd_und_section_ptr if
4780 info->shared. I don't know why, and that doesn't make sense,
4781 so I took it out. */
4782 *secp
= elf_tdata (abfd
)->elf_text_section
;
4785 case SHN_MIPS_ACOMMON
:
4786 /* Fall through. XXX Can we treat this as allocated data? */
4788 /* This section is used in a shared object. */
4789 if (elf_tdata (abfd
)->elf_data_section
== NULL
)
4791 asymbol
*elf_data_symbol
;
4792 asection
*elf_data_section
;
4793 bfd_size_type amt
= sizeof (asection
);
4795 elf_data_section
= bfd_zalloc (abfd
, amt
);
4796 if (elf_data_section
== NULL
)
4799 amt
= sizeof (asymbol
);
4800 elf_data_symbol
= bfd_zalloc (abfd
, amt
);
4801 if (elf_data_symbol
== NULL
)
4804 /* Initialize the section. */
4806 elf_tdata (abfd
)->elf_data_section
= elf_data_section
;
4807 elf_tdata (abfd
)->elf_data_symbol
= elf_data_symbol
;
4809 elf_data_section
->symbol
= elf_data_symbol
;
4810 elf_data_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_data_symbol
;
4812 elf_data_section
->name
= ".data";
4813 elf_data_section
->flags
= SEC_NO_FLAGS
;
4814 elf_data_section
->output_section
= NULL
;
4815 elf_data_section
->owner
= abfd
;
4816 elf_data_symbol
->name
= ".data";
4817 elf_data_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
4818 elf_data_symbol
->section
= elf_data_section
;
4820 /* This code used to do *secp = bfd_und_section_ptr if
4821 info->shared. I don't know why, and that doesn't make sense,
4822 so I took it out. */
4823 *secp
= elf_tdata (abfd
)->elf_data_section
;
4826 case SHN_MIPS_SUNDEFINED
:
4827 *secp
= bfd_und_section_ptr
;
4831 if (SGI_COMPAT (abfd
)
4833 && info
->hash
->creator
== abfd
->xvec
4834 && strcmp (*namep
, "__rld_obj_head") == 0)
4836 struct elf_link_hash_entry
*h
;
4837 struct bfd_link_hash_entry
*bh
;
4839 /* Mark __rld_obj_head as dynamic. */
4841 if (! (_bfd_generic_link_add_one_symbol
4842 (info
, abfd
, *namep
, BSF_GLOBAL
, *secp
, *valp
, NULL
, FALSE
,
4843 get_elf_backend_data (abfd
)->collect
, &bh
)))
4846 h
= (struct elf_link_hash_entry
*) bh
;
4847 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
4848 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4849 h
->type
= STT_OBJECT
;
4851 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
4854 mips_elf_hash_table (info
)->use_rld_obj_head
= TRUE
;
4857 /* If this is a mips16 text symbol, add 1 to the value to make it
4858 odd. This will cause something like .word SYM to come up with
4859 the right value when it is loaded into the PC. */
4860 if (sym
->st_other
== STO_MIPS16
)
4866 /* This hook function is called before the linker writes out a global
4867 symbol. We mark symbols as small common if appropriate. This is
4868 also where we undo the increment of the value for a mips16 symbol. */
4871 _bfd_mips_elf_link_output_symbol_hook
4872 (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4873 const char *name ATTRIBUTE_UNUSED
, Elf_Internal_Sym
*sym
,
4874 asection
*input_sec
, struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
)
4876 /* If we see a common symbol, which implies a relocatable link, then
4877 if a symbol was small common in an input file, mark it as small
4878 common in the output file. */
4879 if (sym
->st_shndx
== SHN_COMMON
4880 && strcmp (input_sec
->name
, ".scommon") == 0)
4881 sym
->st_shndx
= SHN_MIPS_SCOMMON
;
4883 if (sym
->st_other
== STO_MIPS16
)
4884 sym
->st_value
&= ~1;
4889 /* Functions for the dynamic linker. */
4891 /* Create dynamic sections when linking against a dynamic object. */
4894 _bfd_mips_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
4896 struct elf_link_hash_entry
*h
;
4897 struct bfd_link_hash_entry
*bh
;
4899 register asection
*s
;
4900 const char * const *namep
;
4902 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
4903 | SEC_LINKER_CREATED
| SEC_READONLY
);
4905 /* Mips ABI requests the .dynamic section to be read only. */
4906 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4909 if (! bfd_set_section_flags (abfd
, s
, flags
))
4913 /* We need to create .got section. */
4914 if (! mips_elf_create_got_section (abfd
, info
, FALSE
))
4917 if (! mips_elf_rel_dyn_section (elf_hash_table (info
)->dynobj
, TRUE
))
4920 /* Create .stub section. */
4921 if (bfd_get_section_by_name (abfd
,
4922 MIPS_ELF_STUB_SECTION_NAME (abfd
)) == NULL
)
4924 s
= bfd_make_section (abfd
, MIPS_ELF_STUB_SECTION_NAME (abfd
));
4926 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_CODE
)
4927 || ! bfd_set_section_alignment (abfd
, s
,
4928 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
4932 if ((IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
4934 && bfd_get_section_by_name (abfd
, ".rld_map") == NULL
)
4936 s
= bfd_make_section (abfd
, ".rld_map");
4938 || ! bfd_set_section_flags (abfd
, s
, flags
&~ (flagword
) SEC_READONLY
)
4939 || ! bfd_set_section_alignment (abfd
, s
,
4940 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
4944 /* On IRIX5, we adjust add some additional symbols and change the
4945 alignments of several sections. There is no ABI documentation
4946 indicating that this is necessary on IRIX6, nor any evidence that
4947 the linker takes such action. */
4948 if (IRIX_COMPAT (abfd
) == ict_irix5
)
4950 for (namep
= mips_elf_dynsym_rtproc_names
; *namep
!= NULL
; namep
++)
4953 if (! (_bfd_generic_link_add_one_symbol
4954 (info
, abfd
, *namep
, BSF_GLOBAL
, bfd_und_section_ptr
, 0,
4955 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
4958 h
= (struct elf_link_hash_entry
*) bh
;
4959 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
4960 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
4961 h
->type
= STT_SECTION
;
4963 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
4967 /* We need to create a .compact_rel section. */
4968 if (SGI_COMPAT (abfd
))
4970 if (!mips_elf_create_compact_rel_section (abfd
, info
))
4974 /* Change alignments of some sections. */
4975 s
= bfd_get_section_by_name (abfd
, ".hash");
4977 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4978 s
= bfd_get_section_by_name (abfd
, ".dynsym");
4980 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4981 s
= bfd_get_section_by_name (abfd
, ".dynstr");
4983 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4984 s
= bfd_get_section_by_name (abfd
, ".reginfo");
4986 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4987 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4989 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
4996 name
= SGI_COMPAT (abfd
) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
4998 if (!(_bfd_generic_link_add_one_symbol
4999 (info
, abfd
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
, 0,
5000 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
5003 h
= (struct elf_link_hash_entry
*) bh
;
5004 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
5005 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
5006 h
->type
= STT_SECTION
;
5008 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
5011 if (! mips_elf_hash_table (info
)->use_rld_obj_head
)
5013 /* __rld_map is a four byte word located in the .data section
5014 and is filled in by the rtld to contain a pointer to
5015 the _r_debug structure. Its symbol value will be set in
5016 _bfd_mips_elf_finish_dynamic_symbol. */
5017 s
= bfd_get_section_by_name (abfd
, ".rld_map");
5018 BFD_ASSERT (s
!= NULL
);
5020 name
= SGI_COMPAT (abfd
) ? "__rld_map" : "__RLD_MAP";
5022 if (!(_bfd_generic_link_add_one_symbol
5023 (info
, abfd
, name
, BSF_GLOBAL
, s
, 0, NULL
, FALSE
,
5024 get_elf_backend_data (abfd
)->collect
, &bh
)))
5027 h
= (struct elf_link_hash_entry
*) bh
;
5028 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_ELF
;
5029 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
5030 h
->type
= STT_OBJECT
;
5032 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
5040 /* Look through the relocs for a section during the first phase, and
5041 allocate space in the global offset table. */
5044 _bfd_mips_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
5045 asection
*sec
, const Elf_Internal_Rela
*relocs
)
5049 Elf_Internal_Shdr
*symtab_hdr
;
5050 struct elf_link_hash_entry
**sym_hashes
;
5051 struct mips_got_info
*g
;
5053 const Elf_Internal_Rela
*rel
;
5054 const Elf_Internal_Rela
*rel_end
;
5057 const struct elf_backend_data
*bed
;
5059 if (info
->relocatable
)
5062 dynobj
= elf_hash_table (info
)->dynobj
;
5063 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5064 sym_hashes
= elf_sym_hashes (abfd
);
5065 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
5067 /* Check for the mips16 stub sections. */
5069 name
= bfd_get_section_name (abfd
, sec
);
5070 if (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0)
5072 unsigned long r_symndx
;
5074 /* Look at the relocation information to figure out which symbol
5077 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
5079 if (r_symndx
< extsymoff
5080 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
5084 /* This stub is for a local symbol. This stub will only be
5085 needed if there is some relocation in this BFD, other
5086 than a 16 bit function call, which refers to this symbol. */
5087 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5089 Elf_Internal_Rela
*sec_relocs
;
5090 const Elf_Internal_Rela
*r
, *rend
;
5092 /* We can ignore stub sections when looking for relocs. */
5093 if ((o
->flags
& SEC_RELOC
) == 0
5094 || o
->reloc_count
== 0
5095 || strncmp (bfd_get_section_name (abfd
, o
), FN_STUB
,
5096 sizeof FN_STUB
- 1) == 0
5097 || strncmp (bfd_get_section_name (abfd
, o
), CALL_STUB
,
5098 sizeof CALL_STUB
- 1) == 0
5099 || strncmp (bfd_get_section_name (abfd
, o
), CALL_FP_STUB
,
5100 sizeof CALL_FP_STUB
- 1) == 0)
5104 = _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
5106 if (sec_relocs
== NULL
)
5109 rend
= sec_relocs
+ o
->reloc_count
;
5110 for (r
= sec_relocs
; r
< rend
; r
++)
5111 if (ELF_R_SYM (abfd
, r
->r_info
) == r_symndx
5112 && ELF_R_TYPE (abfd
, r
->r_info
) != R_MIPS16_26
)
5115 if (elf_section_data (o
)->relocs
!= sec_relocs
)
5124 /* There is no non-call reloc for this stub, so we do
5125 not need it. Since this function is called before
5126 the linker maps input sections to output sections, we
5127 can easily discard it by setting the SEC_EXCLUDE
5129 sec
->flags
|= SEC_EXCLUDE
;
5133 /* Record this stub in an array of local symbol stubs for
5135 if (elf_tdata (abfd
)->local_stubs
== NULL
)
5137 unsigned long symcount
;
5141 if (elf_bad_symtab (abfd
))
5142 symcount
= NUM_SHDR_ENTRIES (symtab_hdr
);
5144 symcount
= symtab_hdr
->sh_info
;
5145 amt
= symcount
* sizeof (asection
*);
5146 n
= bfd_zalloc (abfd
, amt
);
5149 elf_tdata (abfd
)->local_stubs
= n
;
5152 elf_tdata (abfd
)->local_stubs
[r_symndx
] = sec
;
5154 /* We don't need to set mips16_stubs_seen in this case.
5155 That flag is used to see whether we need to look through
5156 the global symbol table for stubs. We don't need to set
5157 it here, because we just have a local stub. */
5161 struct mips_elf_link_hash_entry
*h
;
5163 h
= ((struct mips_elf_link_hash_entry
*)
5164 sym_hashes
[r_symndx
- extsymoff
]);
5166 /* H is the symbol this stub is for. */
5169 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
5172 else if (strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
5173 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
5175 unsigned long r_symndx
;
5176 struct mips_elf_link_hash_entry
*h
;
5179 /* Look at the relocation information to figure out which symbol
5182 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
5184 if (r_symndx
< extsymoff
5185 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
5187 /* This stub was actually built for a static symbol defined
5188 in the same file. We assume that all static symbols in
5189 mips16 code are themselves mips16, so we can simply
5190 discard this stub. Since this function is called before
5191 the linker maps input sections to output sections, we can
5192 easily discard it by setting the SEC_EXCLUDE flag. */
5193 sec
->flags
|= SEC_EXCLUDE
;
5197 h
= ((struct mips_elf_link_hash_entry
*)
5198 sym_hashes
[r_symndx
- extsymoff
]);
5200 /* H is the symbol this stub is for. */
5202 if (strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
5203 loc
= &h
->call_fp_stub
;
5205 loc
= &h
->call_stub
;
5207 /* If we already have an appropriate stub for this function, we
5208 don't need another one, so we can discard this one. Since
5209 this function is called before the linker maps input sections
5210 to output sections, we can easily discard it by setting the
5211 SEC_EXCLUDE flag. We can also discard this section if we
5212 happen to already know that this is a mips16 function; it is
5213 not necessary to check this here, as it is checked later, but
5214 it is slightly faster to check now. */
5215 if (*loc
!= NULL
|| h
->root
.other
== STO_MIPS16
)
5217 sec
->flags
|= SEC_EXCLUDE
;
5222 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
5232 sgot
= mips_elf_got_section (dynobj
, FALSE
);
5237 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
5238 g
= mips_elf_section_data (sgot
)->u
.got_info
;
5239 BFD_ASSERT (g
!= NULL
);
5244 bed
= get_elf_backend_data (abfd
);
5245 rel_end
= relocs
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
5246 for (rel
= relocs
; rel
< rel_end
; ++rel
)
5248 unsigned long r_symndx
;
5249 unsigned int r_type
;
5250 struct elf_link_hash_entry
*h
;
5252 r_symndx
= ELF_R_SYM (abfd
, rel
->r_info
);
5253 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
5255 if (r_symndx
< extsymoff
)
5257 else if (r_symndx
>= extsymoff
+ NUM_SHDR_ENTRIES (symtab_hdr
))
5259 (*_bfd_error_handler
)
5260 (_("%s: Malformed reloc detected for section %s"),
5261 bfd_archive_filename (abfd
), name
);
5262 bfd_set_error (bfd_error_bad_value
);
5267 h
= sym_hashes
[r_symndx
- extsymoff
];
5269 /* This may be an indirect symbol created because of a version. */
5272 while (h
->root
.type
== bfd_link_hash_indirect
)
5273 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5277 /* Some relocs require a global offset table. */
5278 if (dynobj
== NULL
|| sgot
== NULL
)
5284 case R_MIPS_CALL_HI16
:
5285 case R_MIPS_CALL_LO16
:
5286 case R_MIPS_GOT_HI16
:
5287 case R_MIPS_GOT_LO16
:
5288 case R_MIPS_GOT_PAGE
:
5289 case R_MIPS_GOT_OFST
:
5290 case R_MIPS_GOT_DISP
:
5292 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5293 if (! mips_elf_create_got_section (dynobj
, info
, FALSE
))
5295 g
= mips_elf_got_info (dynobj
, &sgot
);
5302 && (info
->shared
|| h
!= NULL
)
5303 && (sec
->flags
& SEC_ALLOC
) != 0)
5304 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5312 if (!h
&& (r_type
== R_MIPS_CALL_LO16
5313 || r_type
== R_MIPS_GOT_LO16
5314 || r_type
== R_MIPS_GOT_DISP
))
5316 /* We may need a local GOT entry for this relocation. We
5317 don't count R_MIPS_GOT_PAGE because we can estimate the
5318 maximum number of pages needed by looking at the size of
5319 the segment. Similar comments apply to R_MIPS_GOT16 and
5320 R_MIPS_CALL16. We don't count R_MIPS_GOT_HI16, or
5321 R_MIPS_CALL_HI16 because these are always followed by an
5322 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
5323 if (! mips_elf_record_local_got_symbol (abfd
, r_symndx
,
5333 (*_bfd_error_handler
)
5334 (_("%s: CALL16 reloc at 0x%lx not against global symbol"),
5335 bfd_archive_filename (abfd
), (unsigned long) rel
->r_offset
);
5336 bfd_set_error (bfd_error_bad_value
);
5341 case R_MIPS_CALL_HI16
:
5342 case R_MIPS_CALL_LO16
:
5345 /* This symbol requires a global offset table entry. */
5346 if (! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5349 /* We need a stub, not a plt entry for the undefined
5350 function. But we record it as if it needs plt. See
5351 elf_adjust_dynamic_symbol in elflink.h. */
5352 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
5357 case R_MIPS_GOT_PAGE
:
5358 /* If this is a global, overridable symbol, GOT_PAGE will
5359 decay to GOT_DISP, so we'll need a GOT entry for it. */
5364 struct mips_elf_link_hash_entry
*hmips
=
5365 (struct mips_elf_link_hash_entry
*) h
;
5367 while (hmips
->root
.root
.type
== bfd_link_hash_indirect
5368 || hmips
->root
.root
.type
== bfd_link_hash_warning
)
5369 hmips
= (struct mips_elf_link_hash_entry
*)
5370 hmips
->root
.root
.u
.i
.link
;
5372 if ((hmips
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)
5373 && ! (info
->shared
&& ! info
->symbolic
5374 && ! (hmips
->root
.elf_link_hash_flags
5375 & ELF_LINK_FORCED_LOCAL
)))
5381 case R_MIPS_GOT_HI16
:
5382 case R_MIPS_GOT_LO16
:
5383 case R_MIPS_GOT_DISP
:
5384 /* This symbol requires a global offset table entry. */
5385 if (h
&& ! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5392 if ((info
->shared
|| h
!= NULL
)
5393 && (sec
->flags
& SEC_ALLOC
) != 0)
5397 sreloc
= mips_elf_rel_dyn_section (dynobj
, TRUE
);
5401 #define MIPS_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
5404 /* When creating a shared object, we must copy these
5405 reloc types into the output file as R_MIPS_REL32
5406 relocs. We make room for this reloc in the
5407 .rel.dyn reloc section. */
5408 mips_elf_allocate_dynamic_relocations (dynobj
, 1);
5409 if ((sec
->flags
& MIPS_READONLY_SECTION
)
5410 == MIPS_READONLY_SECTION
)
5411 /* We tell the dynamic linker that there are
5412 relocations against the text segment. */
5413 info
->flags
|= DF_TEXTREL
;
5417 struct mips_elf_link_hash_entry
*hmips
;
5419 /* We only need to copy this reloc if the symbol is
5420 defined in a dynamic object. */
5421 hmips
= (struct mips_elf_link_hash_entry
*) h
;
5422 ++hmips
->possibly_dynamic_relocs
;
5423 if ((sec
->flags
& MIPS_READONLY_SECTION
)
5424 == MIPS_READONLY_SECTION
)
5425 /* We need it to tell the dynamic linker if there
5426 are relocations against the text segment. */
5427 hmips
->readonly_reloc
= TRUE
;
5430 /* Even though we don't directly need a GOT entry for
5431 this symbol, a symbol must have a dynamic symbol
5432 table index greater that DT_MIPS_GOTSYM if there are
5433 dynamic relocations against it. */
5437 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
5438 if (! mips_elf_create_got_section (dynobj
, info
, TRUE
))
5440 g
= mips_elf_got_info (dynobj
, &sgot
);
5441 if (! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
))
5446 if (SGI_COMPAT (abfd
))
5447 mips_elf_hash_table (info
)->compact_rel_size
+=
5448 sizeof (Elf32_External_crinfo
);
5452 case R_MIPS_GPREL16
:
5453 case R_MIPS_LITERAL
:
5454 case R_MIPS_GPREL32
:
5455 if (SGI_COMPAT (abfd
))
5456 mips_elf_hash_table (info
)->compact_rel_size
+=
5457 sizeof (Elf32_External_crinfo
);
5460 /* This relocation describes the C++ object vtable hierarchy.
5461 Reconstruct it for later use during GC. */
5462 case R_MIPS_GNU_VTINHERIT
:
5463 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
5467 /* This relocation describes which C++ vtable entries are actually
5468 used. Record for later use during GC. */
5469 case R_MIPS_GNU_VTENTRY
:
5470 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
5478 /* We must not create a stub for a symbol that has relocations
5479 related to taking the function's address. */
5485 struct mips_elf_link_hash_entry
*mh
;
5487 mh
= (struct mips_elf_link_hash_entry
*) h
;
5488 mh
->no_fn_stub
= TRUE
;
5492 case R_MIPS_CALL_HI16
:
5493 case R_MIPS_CALL_LO16
:
5498 /* If this reloc is not a 16 bit call, and it has a global
5499 symbol, then we will need the fn_stub if there is one.
5500 References from a stub section do not count. */
5502 && r_type
!= R_MIPS16_26
5503 && strncmp (bfd_get_section_name (abfd
, sec
), FN_STUB
,
5504 sizeof FN_STUB
- 1) != 0
5505 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_STUB
,
5506 sizeof CALL_STUB
- 1) != 0
5507 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_FP_STUB
,
5508 sizeof CALL_FP_STUB
- 1) != 0)
5510 struct mips_elf_link_hash_entry
*mh
;
5512 mh
= (struct mips_elf_link_hash_entry
*) h
;
5513 mh
->need_fn_stub
= TRUE
;
5521 _bfd_mips_relax_section (bfd
*abfd
, asection
*sec
,
5522 struct bfd_link_info
*link_info
,
5525 Elf_Internal_Rela
*internal_relocs
;
5526 Elf_Internal_Rela
*irel
, *irelend
;
5527 Elf_Internal_Shdr
*symtab_hdr
;
5528 bfd_byte
*contents
= NULL
;
5529 bfd_byte
*free_contents
= NULL
;
5531 bfd_boolean changed_contents
= FALSE
;
5532 bfd_vma sec_start
= sec
->output_section
->vma
+ sec
->output_offset
;
5533 Elf_Internal_Sym
*isymbuf
= NULL
;
5535 /* We are not currently changing any sizes, so only one pass. */
5538 if (link_info
->relocatable
)
5541 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
5542 link_info
->keep_memory
);
5543 if (internal_relocs
== NULL
)
5546 irelend
= internal_relocs
+ sec
->reloc_count
5547 * get_elf_backend_data (abfd
)->s
->int_rels_per_ext_rel
;
5548 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5549 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
5551 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
5554 bfd_signed_vma sym_offset
;
5555 unsigned int r_type
;
5556 unsigned long r_symndx
;
5558 unsigned long instruction
;
5560 /* Turn jalr into bgezal, and jr into beq, if they're marked
5561 with a JALR relocation, that indicate where they jump to.
5562 This saves some pipeline bubbles. */
5563 r_type
= ELF_R_TYPE (abfd
, irel
->r_info
);
5564 if (r_type
!= R_MIPS_JALR
)
5567 r_symndx
= ELF_R_SYM (abfd
, irel
->r_info
);
5568 /* Compute the address of the jump target. */
5569 if (r_symndx
>= extsymoff
)
5571 struct mips_elf_link_hash_entry
*h
5572 = ((struct mips_elf_link_hash_entry
*)
5573 elf_sym_hashes (abfd
) [r_symndx
- extsymoff
]);
5575 while (h
->root
.root
.type
== bfd_link_hash_indirect
5576 || h
->root
.root
.type
== bfd_link_hash_warning
)
5577 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
5579 /* If a symbol is undefined, or if it may be overridden,
5581 if (! ((h
->root
.root
.type
== bfd_link_hash_defined
5582 || h
->root
.root
.type
== bfd_link_hash_defweak
)
5583 && h
->root
.root
.u
.def
.section
)
5584 || (link_info
->shared
&& ! link_info
->symbolic
5585 && ! (h
->root
.elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
)))
5588 sym_sec
= h
->root
.root
.u
.def
.section
;
5589 if (sym_sec
->output_section
)
5590 symval
= (h
->root
.root
.u
.def
.value
5591 + sym_sec
->output_section
->vma
5592 + sym_sec
->output_offset
);
5594 symval
= h
->root
.root
.u
.def
.value
;
5598 Elf_Internal_Sym
*isym
;
5600 /* Read this BFD's symbols if we haven't done so already. */
5601 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
5603 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5604 if (isymbuf
== NULL
)
5605 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
5606 symtab_hdr
->sh_info
, 0,
5608 if (isymbuf
== NULL
)
5612 isym
= isymbuf
+ r_symndx
;
5613 if (isym
->st_shndx
== SHN_UNDEF
)
5615 else if (isym
->st_shndx
== SHN_ABS
)
5616 sym_sec
= bfd_abs_section_ptr
;
5617 else if (isym
->st_shndx
== SHN_COMMON
)
5618 sym_sec
= bfd_com_section_ptr
;
5621 = bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
5622 symval
= isym
->st_value
5623 + sym_sec
->output_section
->vma
5624 + sym_sec
->output_offset
;
5627 /* Compute branch offset, from delay slot of the jump to the
5629 sym_offset
= (symval
+ irel
->r_addend
)
5630 - (sec_start
+ irel
->r_offset
+ 4);
5632 /* Branch offset must be properly aligned. */
5633 if ((sym_offset
& 3) != 0)
5638 /* Check that it's in range. */
5639 if (sym_offset
< -0x8000 || sym_offset
>= 0x8000)
5642 /* Get the section contents if we haven't done so already. */
5643 if (contents
== NULL
)
5645 /* Get cached copy if it exists. */
5646 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
5647 contents
= elf_section_data (sec
)->this_hdr
.contents
;
5650 contents
= bfd_malloc (sec
->_raw_size
);
5651 if (contents
== NULL
)
5654 free_contents
= contents
;
5655 if (! bfd_get_section_contents (abfd
, sec
, contents
,
5661 instruction
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
5663 /* If it was jalr <reg>, turn it into bgezal $zero, <target>. */
5664 if ((instruction
& 0xfc1fffff) == 0x0000f809)
5665 instruction
= 0x04110000;
5666 /* If it was jr <reg>, turn it into b <target>. */
5667 else if ((instruction
& 0xfc1fffff) == 0x00000008)
5668 instruction
= 0x10000000;
5672 instruction
|= (sym_offset
& 0xffff);
5673 bfd_put_32 (abfd
, instruction
, contents
+ irel
->r_offset
);
5674 changed_contents
= TRUE
;
5677 if (contents
!= NULL
5678 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
5680 if (!changed_contents
&& !link_info
->keep_memory
)
5684 /* Cache the section contents for elf_link_input_bfd. */
5685 elf_section_data (sec
)->this_hdr
.contents
= contents
;
5691 if (free_contents
!= NULL
)
5692 free (free_contents
);
5696 /* Adjust a symbol defined by a dynamic object and referenced by a
5697 regular object. The current definition is in some section of the
5698 dynamic object, but we're not including those sections. We have to
5699 change the definition to something the rest of the link can
5703 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
5704 struct elf_link_hash_entry
*h
)
5707 struct mips_elf_link_hash_entry
*hmips
;
5710 dynobj
= elf_hash_table (info
)->dynobj
;
5712 /* Make sure we know what is going on here. */
5713 BFD_ASSERT (dynobj
!= NULL
5714 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
5715 || h
->weakdef
!= NULL
5716 || ((h
->elf_link_hash_flags
5717 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
5718 && (h
->elf_link_hash_flags
5719 & ELF_LINK_HASH_REF_REGULAR
) != 0
5720 && (h
->elf_link_hash_flags
5721 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
5723 /* If this symbol is defined in a dynamic object, we need to copy
5724 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
5726 hmips
= (struct mips_elf_link_hash_entry
*) h
;
5727 if (! info
->relocatable
5728 && hmips
->possibly_dynamic_relocs
!= 0
5729 && (h
->root
.type
== bfd_link_hash_defweak
5730 || (h
->elf_link_hash_flags
5731 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
5733 mips_elf_allocate_dynamic_relocations (dynobj
,
5734 hmips
->possibly_dynamic_relocs
);
5735 if (hmips
->readonly_reloc
)
5736 /* We tell the dynamic linker that there are relocations
5737 against the text segment. */
5738 info
->flags
|= DF_TEXTREL
;
5741 /* For a function, create a stub, if allowed. */
5742 if (! hmips
->no_fn_stub
5743 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
5745 if (! elf_hash_table (info
)->dynamic_sections_created
)
5748 /* If this symbol is not defined in a regular file, then set
5749 the symbol to the stub location. This is required to make
5750 function pointers compare as equal between the normal
5751 executable and the shared library. */
5752 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
5754 /* We need .stub section. */
5755 s
= bfd_get_section_by_name (dynobj
,
5756 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
5757 BFD_ASSERT (s
!= NULL
);
5759 h
->root
.u
.def
.section
= s
;
5760 h
->root
.u
.def
.value
= s
->_raw_size
;
5762 /* XXX Write this stub address somewhere. */
5763 h
->plt
.offset
= s
->_raw_size
;
5765 /* Make room for this stub code. */
5766 s
->_raw_size
+= MIPS_FUNCTION_STUB_SIZE
;
5768 /* The last half word of the stub will be filled with the index
5769 of this symbol in .dynsym section. */
5773 else if ((h
->type
== STT_FUNC
)
5774 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) == 0)
5776 /* This will set the entry for this symbol in the GOT to 0, and
5777 the dynamic linker will take care of this. */
5778 h
->root
.u
.def
.value
= 0;
5782 /* If this is a weak symbol, and there is a real definition, the
5783 processor independent code will have arranged for us to see the
5784 real definition first, and we can just use the same value. */
5785 if (h
->weakdef
!= NULL
)
5787 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
5788 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
5789 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
5790 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
5794 /* This is a reference to a symbol defined by a dynamic object which
5795 is not a function. */
5800 /* This function is called after all the input files have been read,
5801 and the input sections have been assigned to output sections. We
5802 check for any mips16 stub sections that we can discard. */
5805 _bfd_mips_elf_always_size_sections (bfd
*output_bfd
,
5806 struct bfd_link_info
*info
)
5812 struct mips_got_info
*g
;
5814 bfd_size_type loadable_size
= 0;
5815 bfd_size_type local_gotno
;
5818 /* The .reginfo section has a fixed size. */
5819 ri
= bfd_get_section_by_name (output_bfd
, ".reginfo");
5821 bfd_set_section_size (output_bfd
, ri
, sizeof (Elf32_External_RegInfo
));
5823 if (! (info
->relocatable
5824 || ! mips_elf_hash_table (info
)->mips16_stubs_seen
))
5825 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
5826 mips_elf_check_mips16_stubs
, NULL
);
5828 dynobj
= elf_hash_table (info
)->dynobj
;
5830 /* Relocatable links don't have it. */
5833 g
= mips_elf_got_info (dynobj
, &s
);
5837 /* Calculate the total loadable size of the output. That
5838 will give us the maximum number of GOT_PAGE entries
5840 for (sub
= info
->input_bfds
; sub
; sub
= sub
->link_next
)
5842 asection
*subsection
;
5844 for (subsection
= sub
->sections
;
5846 subsection
= subsection
->next
)
5848 if ((subsection
->flags
& SEC_ALLOC
) == 0)
5850 loadable_size
+= ((subsection
->_raw_size
+ 0xf)
5851 &~ (bfd_size_type
) 0xf);
5855 /* There has to be a global GOT entry for every symbol with
5856 a dynamic symbol table index of DT_MIPS_GOTSYM or
5857 higher. Therefore, it make sense to put those symbols
5858 that need GOT entries at the end of the symbol table. We
5860 if (! mips_elf_sort_hash_table (info
, 1))
5863 if (g
->global_gotsym
!= NULL
)
5864 i
= elf_hash_table (info
)->dynsymcount
- g
->global_gotsym
->dynindx
;
5866 /* If there are no global symbols, or none requiring
5867 relocations, then GLOBAL_GOTSYM will be NULL. */
5870 /* In the worst case, we'll get one stub per dynamic symbol, plus
5871 one to account for the dummy entry at the end required by IRIX
5873 loadable_size
+= MIPS_FUNCTION_STUB_SIZE
* (i
+ 1);
5875 /* Assume there are two loadable segments consisting of
5876 contiguous sections. Is 5 enough? */
5877 local_gotno
= (loadable_size
>> 16) + 5;
5879 g
->local_gotno
+= local_gotno
;
5880 s
->_raw_size
+= g
->local_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
5882 g
->global_gotno
= i
;
5883 s
->_raw_size
+= i
* MIPS_ELF_GOT_SIZE (output_bfd
);
5885 if (s
->_raw_size
> MIPS_ELF_GOT_MAX_SIZE (output_bfd
)
5886 && ! mips_elf_multi_got (output_bfd
, info
, g
, s
, local_gotno
))
5892 /* Set the sizes of the dynamic sections. */
5895 _bfd_mips_elf_size_dynamic_sections (bfd
*output_bfd
,
5896 struct bfd_link_info
*info
)
5900 bfd_boolean reltext
;
5902 dynobj
= elf_hash_table (info
)->dynobj
;
5903 BFD_ASSERT (dynobj
!= NULL
);
5905 if (elf_hash_table (info
)->dynamic_sections_created
)
5907 /* Set the contents of the .interp section to the interpreter. */
5908 if (info
->executable
)
5910 s
= bfd_get_section_by_name (dynobj
, ".interp");
5911 BFD_ASSERT (s
!= NULL
);
5913 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd
)) + 1;
5915 = (bfd_byte
*) ELF_DYNAMIC_INTERPRETER (output_bfd
);
5919 /* The check_relocs and adjust_dynamic_symbol entry points have
5920 determined the sizes of the various dynamic sections. Allocate
5923 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
5928 /* It's OK to base decisions on the section name, because none
5929 of the dynobj section names depend upon the input files. */
5930 name
= bfd_get_section_name (dynobj
, s
);
5932 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
5937 if (strncmp (name
, ".rel", 4) == 0)
5939 if (s
->_raw_size
== 0)
5941 /* We only strip the section if the output section name
5942 has the same name. Otherwise, there might be several
5943 input sections for this output section. FIXME: This
5944 code is probably not needed these days anyhow, since
5945 the linker now does not create empty output sections. */
5946 if (s
->output_section
!= NULL
5948 bfd_get_section_name (s
->output_section
->owner
,
5949 s
->output_section
)) == 0)
5954 const char *outname
;
5957 /* If this relocation section applies to a read only
5958 section, then we probably need a DT_TEXTREL entry.
5959 If the relocation section is .rel.dyn, we always
5960 assert a DT_TEXTREL entry rather than testing whether
5961 there exists a relocation to a read only section or
5963 outname
= bfd_get_section_name (output_bfd
,
5965 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
5967 && (target
->flags
& SEC_READONLY
) != 0
5968 && (target
->flags
& SEC_ALLOC
) != 0)
5969 || strcmp (outname
, ".rel.dyn") == 0)
5972 /* We use the reloc_count field as a counter if we need
5973 to copy relocs into the output file. */
5974 if (strcmp (name
, ".rel.dyn") != 0)
5977 /* If combreloc is enabled, elf_link_sort_relocs() will
5978 sort relocations, but in a different way than we do,
5979 and before we're done creating relocations. Also, it
5980 will move them around between input sections'
5981 relocation's contents, so our sorting would be
5982 broken, so don't let it run. */
5983 info
->combreloc
= 0;
5986 else if (strncmp (name
, ".got", 4) == 0)
5988 /* _bfd_mips_elf_always_size_sections() has already done
5989 most of the work, but some symbols may have been mapped
5990 to versions that we must now resolve in the got_entries
5992 struct mips_got_info
*gg
= mips_elf_got_info (dynobj
, NULL
);
5993 struct mips_got_info
*g
= gg
;
5994 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
5995 unsigned int needed_relocs
= 0;
5999 set_got_offset_arg
.value
= MIPS_ELF_GOT_SIZE (output_bfd
);
6000 set_got_offset_arg
.info
= info
;
6002 mips_elf_resolve_final_got_entries (gg
);
6003 for (g
= gg
->next
; g
&& g
->next
!= gg
; g
= g
->next
)
6005 unsigned int save_assign
;
6007 mips_elf_resolve_final_got_entries (g
);
6009 /* Assign offsets to global GOT entries. */
6010 save_assign
= g
->assigned_gotno
;
6011 g
->assigned_gotno
= g
->local_gotno
;
6012 set_got_offset_arg
.g
= g
;
6013 set_got_offset_arg
.needed_relocs
= 0;
6014 htab_traverse (g
->got_entries
,
6015 mips_elf_set_global_got_offset
,
6016 &set_got_offset_arg
);
6017 needed_relocs
+= set_got_offset_arg
.needed_relocs
;
6018 BFD_ASSERT (g
->assigned_gotno
- g
->local_gotno
6019 <= g
->global_gotno
);
6021 g
->assigned_gotno
= save_assign
;
6024 needed_relocs
+= g
->local_gotno
- g
->assigned_gotno
;
6025 BFD_ASSERT (g
->assigned_gotno
== g
->next
->local_gotno
6026 + g
->next
->global_gotno
6027 + MIPS_RESERVED_GOTNO
);
6032 mips_elf_allocate_dynamic_relocations (dynobj
, needed_relocs
);
6035 else if (strcmp (name
, MIPS_ELF_STUB_SECTION_NAME (output_bfd
)) == 0)
6037 /* IRIX rld assumes that the function stub isn't at the end
6038 of .text section. So put a dummy. XXX */
6039 s
->_raw_size
+= MIPS_FUNCTION_STUB_SIZE
;
6041 else if (! info
->shared
6042 && ! mips_elf_hash_table (info
)->use_rld_obj_head
6043 && strncmp (name
, ".rld_map", 8) == 0)
6045 /* We add a room for __rld_map. It will be filled in by the
6046 rtld to contain a pointer to the _r_debug structure. */
6049 else if (SGI_COMPAT (output_bfd
)
6050 && strncmp (name
, ".compact_rel", 12) == 0)
6051 s
->_raw_size
+= mips_elf_hash_table (info
)->compact_rel_size
;
6052 else if (strncmp (name
, ".init", 5) != 0)
6054 /* It's not one of our sections, so don't allocate space. */
6060 _bfd_strip_section_from_output (info
, s
);
6064 /* Allocate memory for the section contents. */
6065 s
->contents
= bfd_zalloc (dynobj
, s
->_raw_size
);
6066 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
6068 bfd_set_error (bfd_error_no_memory
);
6073 if (elf_hash_table (info
)->dynamic_sections_created
)
6075 /* Add some entries to the .dynamic section. We fill in the
6076 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
6077 must add the entries now so that we get the correct size for
6078 the .dynamic section. The DT_DEBUG entry is filled in by the
6079 dynamic linker and used by the debugger. */
6082 /* SGI object has the equivalence of DT_DEBUG in the
6083 DT_MIPS_RLD_MAP entry. */
6084 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_MAP
, 0))
6086 if (!SGI_COMPAT (output_bfd
))
6088 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
6094 /* Shared libraries on traditional mips have DT_DEBUG. */
6095 if (!SGI_COMPAT (output_bfd
))
6097 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
6102 if (reltext
&& SGI_COMPAT (output_bfd
))
6103 info
->flags
|= DF_TEXTREL
;
6105 if ((info
->flags
& DF_TEXTREL
) != 0)
6107 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_TEXTREL
, 0))
6111 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTGOT
, 0))
6114 if (mips_elf_rel_dyn_section (dynobj
, FALSE
))
6116 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_REL
, 0))
6119 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELSZ
, 0))
6122 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELENT
, 0))
6126 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_VERSION
, 0))
6129 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_FLAGS
, 0))
6133 /* Time stamps in executable files are a bad idea. */
6134 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_TIME_STAMP
, 0))
6139 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_ICHECKSUM
, 0))
6144 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_IVERSION
, 0))
6148 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_BASE_ADDRESS
, 0))
6151 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LOCAL_GOTNO
, 0))
6154 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_SYMTABNO
, 0))
6157 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_UNREFEXTNO
, 0))
6160 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_GOTSYM
, 0))
6163 if (IRIX_COMPAT (dynobj
) == ict_irix5
6164 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_HIPAGENO
, 0))
6167 if (IRIX_COMPAT (dynobj
) == ict_irix6
6168 && (bfd_get_section_by_name
6169 (dynobj
, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj
)))
6170 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_OPTIONS
, 0))
6177 /* Relocate a MIPS ELF section. */
6180 _bfd_mips_elf_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
6181 bfd
*input_bfd
, asection
*input_section
,
6182 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
6183 Elf_Internal_Sym
*local_syms
,
6184 asection
**local_sections
)
6186 Elf_Internal_Rela
*rel
;
6187 const Elf_Internal_Rela
*relend
;
6189 bfd_boolean use_saved_addend_p
= FALSE
;
6190 const struct elf_backend_data
*bed
;
6192 bed
= get_elf_backend_data (output_bfd
);
6193 relend
= relocs
+ input_section
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
6194 for (rel
= relocs
; rel
< relend
; ++rel
)
6198 reloc_howto_type
*howto
;
6199 bfd_boolean require_jalx
;
6200 /* TRUE if the relocation is a RELA relocation, rather than a
6202 bfd_boolean rela_relocation_p
= TRUE
;
6203 unsigned int r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
6206 /* Find the relocation howto for this relocation. */
6207 if (r_type
== R_MIPS_64
&& ! NEWABI_P (input_bfd
))
6209 /* Some 32-bit code uses R_MIPS_64. In particular, people use
6210 64-bit code, but make sure all their addresses are in the
6211 lowermost or uppermost 32-bit section of the 64-bit address
6212 space. Thus, when they use an R_MIPS_64 they mean what is
6213 usually meant by R_MIPS_32, with the exception that the
6214 stored value is sign-extended to 64 bits. */
6215 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, R_MIPS_32
, FALSE
);
6217 /* On big-endian systems, we need to lie about the position
6219 if (bfd_big_endian (input_bfd
))
6223 /* NewABI defaults to RELA relocations. */
6224 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, r_type
,
6225 NEWABI_P (input_bfd
)
6226 && (MIPS_RELOC_RELA_P
6227 (input_bfd
, input_section
,
6230 if (!use_saved_addend_p
)
6232 Elf_Internal_Shdr
*rel_hdr
;
6234 /* If these relocations were originally of the REL variety,
6235 we must pull the addend out of the field that will be
6236 relocated. Otherwise, we simply use the contents of the
6237 RELA relocation. To determine which flavor or relocation
6238 this is, we depend on the fact that the INPUT_SECTION's
6239 REL_HDR is read before its REL_HDR2. */
6240 rel_hdr
= &elf_section_data (input_section
)->rel_hdr
;
6241 if ((size_t) (rel
- relocs
)
6242 >= (NUM_SHDR_ENTRIES (rel_hdr
) * bed
->s
->int_rels_per_ext_rel
))
6243 rel_hdr
= elf_section_data (input_section
)->rel_hdr2
;
6244 if (rel_hdr
->sh_entsize
== MIPS_ELF_REL_SIZE (input_bfd
))
6246 /* Note that this is a REL relocation. */
6247 rela_relocation_p
= FALSE
;
6249 /* Get the addend, which is stored in the input file. */
6250 addend
= mips_elf_obtain_contents (howto
, rel
, input_bfd
,
6252 addend
&= howto
->src_mask
;
6254 /* For some kinds of relocations, the ADDEND is a
6255 combination of the addend stored in two different
6257 if (r_type
== R_MIPS_HI16
6258 || r_type
== R_MIPS_GNU_REL_HI16
6259 || (r_type
== R_MIPS_GOT16
6260 && mips_elf_local_relocation_p (input_bfd
, rel
,
6261 local_sections
, FALSE
)))
6264 const Elf_Internal_Rela
*lo16_relocation
;
6265 reloc_howto_type
*lo16_howto
;
6268 /* The combined value is the sum of the HI16 addend,
6269 left-shifted by sixteen bits, and the LO16
6270 addend, sign extended. (Usually, the code does
6271 a `lui' of the HI16 value, and then an `addiu' of
6274 Scan ahead to find a matching LO16 relocation. */
6275 if (r_type
== R_MIPS_GNU_REL_HI16
)
6276 lo
= R_MIPS_GNU_REL_LO16
;
6279 lo16_relocation
= mips_elf_next_relocation (input_bfd
, lo
,
6281 if (lo16_relocation
== NULL
)
6284 /* Obtain the addend kept there. */
6285 lo16_howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, lo
, FALSE
);
6286 l
= mips_elf_obtain_contents (lo16_howto
, lo16_relocation
,
6287 input_bfd
, contents
);
6288 l
&= lo16_howto
->src_mask
;
6289 l
<<= lo16_howto
->rightshift
;
6290 l
= _bfd_mips_elf_sign_extend (l
, 16);
6294 /* Compute the combined addend. */
6297 /* If PC-relative, subtract the difference between the
6298 address of the LO part of the reloc and the address of
6299 the HI part. The relocation is relative to the LO
6300 part, but mips_elf_calculate_relocation() doesn't
6301 know its address or the difference from the HI part, so
6302 we subtract that difference here. See also the
6303 comment in mips_elf_calculate_relocation(). */
6304 if (r_type
== R_MIPS_GNU_REL_HI16
)
6305 addend
-= (lo16_relocation
->r_offset
- rel
->r_offset
);
6307 else if (r_type
== R_MIPS16_GPREL
)
6309 /* The addend is scrambled in the object file. See
6310 mips_elf_perform_relocation for details on the
6312 addend
= (((addend
& 0x1f0000) >> 5)
6313 | ((addend
& 0x7e00000) >> 16)
6317 addend
<<= howto
->rightshift
;
6320 addend
= rel
->r_addend
;
6323 if (info
->relocatable
)
6325 Elf_Internal_Sym
*sym
;
6326 unsigned long r_symndx
;
6328 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
)
6329 && bfd_big_endian (input_bfd
))
6332 /* Since we're just relocating, all we need to do is copy
6333 the relocations back out to the object file, unless
6334 they're against a section symbol, in which case we need
6335 to adjust by the section offset, or unless they're GP
6336 relative in which case we need to adjust by the amount
6337 that we're adjusting GP in this relocatable object. */
6339 if (! mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
,
6341 /* There's nothing to do for non-local relocations. */
6344 if (r_type
== R_MIPS16_GPREL
6345 || r_type
== R_MIPS_GPREL16
6346 || r_type
== R_MIPS_GPREL32
6347 || r_type
== R_MIPS_LITERAL
)
6348 addend
-= (_bfd_get_gp_value (output_bfd
)
6349 - _bfd_get_gp_value (input_bfd
));
6351 r_symndx
= ELF_R_SYM (output_bfd
, rel
->r_info
);
6352 sym
= local_syms
+ r_symndx
;
6353 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6354 /* Adjust the addend appropriately. */
6355 addend
+= local_sections
[r_symndx
]->output_offset
;
6357 if (rela_relocation_p
)
6358 /* If this is a RELA relocation, just update the addend. */
6359 rel
->r_addend
= addend
;
6362 if (r_type
== R_MIPS_HI16
6363 || r_type
== R_MIPS_GOT16
6364 || r_type
== R_MIPS_GNU_REL_HI16
)
6365 addend
= mips_elf_high (addend
);
6366 else if (r_type
== R_MIPS_HIGHER
)
6367 addend
= mips_elf_higher (addend
);
6368 else if (r_type
== R_MIPS_HIGHEST
)
6369 addend
= mips_elf_highest (addend
);
6371 addend
>>= howto
->rightshift
;
6373 /* We use the source mask, rather than the destination
6374 mask because the place to which we are writing will be
6375 source of the addend in the final link. */
6376 addend
&= howto
->src_mask
;
6378 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
6379 /* See the comment above about using R_MIPS_64 in the 32-bit
6380 ABI. Here, we need to update the addend. It would be
6381 possible to get away with just using the R_MIPS_32 reloc
6382 but for endianness. */
6388 if (addend
& ((bfd_vma
) 1 << 31))
6390 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
6397 /* If we don't know that we have a 64-bit type,
6398 do two separate stores. */
6399 if (bfd_big_endian (input_bfd
))
6401 /* Store the sign-bits (which are most significant)
6403 low_bits
= sign_bits
;
6409 high_bits
= sign_bits
;
6411 bfd_put_32 (input_bfd
, low_bits
,
6412 contents
+ rel
->r_offset
);
6413 bfd_put_32 (input_bfd
, high_bits
,
6414 contents
+ rel
->r_offset
+ 4);
6418 if (! mips_elf_perform_relocation (info
, howto
, rel
, addend
,
6419 input_bfd
, input_section
,
6424 /* Go on to the next relocation. */
6428 /* In the N32 and 64-bit ABIs there may be multiple consecutive
6429 relocations for the same offset. In that case we are
6430 supposed to treat the output of each relocation as the addend
6432 if (rel
+ 1 < relend
6433 && rel
->r_offset
== rel
[1].r_offset
6434 && ELF_R_TYPE (input_bfd
, rel
[1].r_info
) != R_MIPS_NONE
)
6435 use_saved_addend_p
= TRUE
;
6437 use_saved_addend_p
= FALSE
;
6439 /* Figure out what value we are supposed to relocate. */
6440 switch (mips_elf_calculate_relocation (output_bfd
, input_bfd
,
6441 input_section
, info
, rel
,
6442 addend
, howto
, local_syms
,
6443 local_sections
, &value
,
6444 &name
, &require_jalx
,
6445 use_saved_addend_p
))
6447 case bfd_reloc_continue
:
6448 /* There's nothing to do. */
6451 case bfd_reloc_undefined
:
6452 /* mips_elf_calculate_relocation already called the
6453 undefined_symbol callback. There's no real point in
6454 trying to perform the relocation at this point, so we
6455 just skip ahead to the next relocation. */
6458 case bfd_reloc_notsupported
:
6459 msg
= _("internal error: unsupported relocation error");
6460 info
->callbacks
->warning
6461 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
6464 case bfd_reloc_overflow
:
6465 if (use_saved_addend_p
)
6466 /* Ignore overflow until we reach the last relocation for
6467 a given location. */
6471 BFD_ASSERT (name
!= NULL
);
6472 if (! ((*info
->callbacks
->reloc_overflow
)
6473 (info
, name
, howto
->name
, 0,
6474 input_bfd
, input_section
, rel
->r_offset
)))
6487 /* If we've got another relocation for the address, keep going
6488 until we reach the last one. */
6489 if (use_saved_addend_p
)
6495 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
6496 /* See the comment above about using R_MIPS_64 in the 32-bit
6497 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
6498 that calculated the right value. Now, however, we
6499 sign-extend the 32-bit result to 64-bits, and store it as a
6500 64-bit value. We are especially generous here in that we
6501 go to extreme lengths to support this usage on systems with
6502 only a 32-bit VMA. */
6508 if (value
& ((bfd_vma
) 1 << 31))
6510 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
6517 /* If we don't know that we have a 64-bit type,
6518 do two separate stores. */
6519 if (bfd_big_endian (input_bfd
))
6521 /* Undo what we did above. */
6523 /* Store the sign-bits (which are most significant)
6525 low_bits
= sign_bits
;
6531 high_bits
= sign_bits
;
6533 bfd_put_32 (input_bfd
, low_bits
,
6534 contents
+ rel
->r_offset
);
6535 bfd_put_32 (input_bfd
, high_bits
,
6536 contents
+ rel
->r_offset
+ 4);
6540 /* Actually perform the relocation. */
6541 if (! mips_elf_perform_relocation (info
, howto
, rel
, value
,
6542 input_bfd
, input_section
,
6543 contents
, require_jalx
))
6550 /* If NAME is one of the special IRIX6 symbols defined by the linker,
6551 adjust it appropriately now. */
6554 mips_elf_irix6_finish_dynamic_symbol (bfd
*abfd ATTRIBUTE_UNUSED
,
6555 const char *name
, Elf_Internal_Sym
*sym
)
6557 /* The linker script takes care of providing names and values for
6558 these, but we must place them into the right sections. */
6559 static const char* const text_section_symbols
[] = {
6562 "__dso_displacement",
6564 "__program_header_table",
6568 static const char* const data_section_symbols
[] = {
6576 const char* const *p
;
6579 for (i
= 0; i
< 2; ++i
)
6580 for (p
= (i
== 0) ? text_section_symbols
: data_section_symbols
;
6583 if (strcmp (*p
, name
) == 0)
6585 /* All of these symbols are given type STT_SECTION by the
6587 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6588 sym
->st_other
= STO_PROTECTED
;
6590 /* The IRIX linker puts these symbols in special sections. */
6592 sym
->st_shndx
= SHN_MIPS_TEXT
;
6594 sym
->st_shndx
= SHN_MIPS_DATA
;
6600 /* Finish up dynamic symbol handling. We set the contents of various
6601 dynamic sections here. */
6604 _bfd_mips_elf_finish_dynamic_symbol (bfd
*output_bfd
,
6605 struct bfd_link_info
*info
,
6606 struct elf_link_hash_entry
*h
,
6607 Elf_Internal_Sym
*sym
)
6612 struct mips_got_info
*g
, *gg
;
6615 dynobj
= elf_hash_table (info
)->dynobj
;
6616 gval
= sym
->st_value
;
6618 if (h
->plt
.offset
!= (bfd_vma
) -1)
6621 bfd_byte stub
[MIPS_FUNCTION_STUB_SIZE
];
6623 /* This symbol has a stub. Set it up. */
6625 BFD_ASSERT (h
->dynindx
!= -1);
6627 s
= bfd_get_section_by_name (dynobj
,
6628 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
6629 BFD_ASSERT (s
!= NULL
);
6631 /* FIXME: Can h->dynindex be more than 64K? */
6632 if (h
->dynindx
& 0xffff0000)
6635 /* Fill the stub. */
6636 bfd_put_32 (output_bfd
, STUB_LW (output_bfd
), stub
);
6637 bfd_put_32 (output_bfd
, STUB_MOVE (output_bfd
), stub
+ 4);
6638 bfd_put_32 (output_bfd
, STUB_JALR
, stub
+ 8);
6639 bfd_put_32 (output_bfd
, STUB_LI16 (output_bfd
) + h
->dynindx
, stub
+ 12);
6641 BFD_ASSERT (h
->plt
.offset
<= s
->_raw_size
);
6642 memcpy (s
->contents
+ h
->plt
.offset
, stub
, MIPS_FUNCTION_STUB_SIZE
);
6644 /* Mark the symbol as undefined. plt.offset != -1 occurs
6645 only for the referenced symbol. */
6646 sym
->st_shndx
= SHN_UNDEF
;
6648 /* The run-time linker uses the st_value field of the symbol
6649 to reset the global offset table entry for this external
6650 to its stub address when unlinking a shared object. */
6651 gval
= s
->output_section
->vma
+ s
->output_offset
+ h
->plt
.offset
;
6652 sym
->st_value
= gval
;
6655 BFD_ASSERT (h
->dynindx
!= -1
6656 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0);
6658 sgot
= mips_elf_got_section (dynobj
, FALSE
);
6659 BFD_ASSERT (sgot
!= NULL
);
6660 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
6661 g
= mips_elf_section_data (sgot
)->u
.got_info
;
6662 BFD_ASSERT (g
!= NULL
);
6664 /* Run through the global symbol table, creating GOT entries for all
6665 the symbols that need them. */
6666 if (g
->global_gotsym
!= NULL
6667 && h
->dynindx
>= g
->global_gotsym
->dynindx
)
6672 value
= sym
->st_value
;
6673 offset
= mips_elf_global_got_index (dynobj
, output_bfd
, h
);
6674 MIPS_ELF_PUT_WORD (output_bfd
, value
, sgot
->contents
+ offset
);
6677 if (g
->next
&& h
->dynindx
!= -1)
6679 struct mips_got_entry e
, *p
;
6685 e
.abfd
= output_bfd
;
6687 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
6689 for (g
= g
->next
; g
->next
!= gg
; g
= g
->next
)
6692 && (p
= (struct mips_got_entry
*) htab_find (g
->got_entries
,
6697 || (elf_hash_table (info
)->dynamic_sections_created
6699 && ((p
->d
.h
->root
.elf_link_hash_flags
6700 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0)
6701 && ((p
->d
.h
->root
.elf_link_hash_flags
6702 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
6704 /* Create an R_MIPS_REL32 relocation for this entry. Due to
6705 the various compatibility problems, it's easier to mock
6706 up an R_MIPS_32 or R_MIPS_64 relocation and leave
6707 mips_elf_create_dynamic_relocation to calculate the
6708 appropriate addend. */
6709 Elf_Internal_Rela rel
[3];
6711 memset (rel
, 0, sizeof (rel
));
6712 if (ABI_64_P (output_bfd
))
6713 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_64
);
6715 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_32
);
6716 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
6719 if (! (mips_elf_create_dynamic_relocation
6720 (output_bfd
, info
, rel
,
6721 e
.d
.h
, NULL
, sym
->st_value
, &entry
, sgot
)))
6725 entry
= sym
->st_value
;
6726 MIPS_ELF_PUT_WORD (output_bfd
, entry
, sgot
->contents
+ offset
);
6731 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
6732 name
= h
->root
.root
.string
;
6733 if (strcmp (name
, "_DYNAMIC") == 0
6734 || strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
6735 sym
->st_shndx
= SHN_ABS
;
6736 else if (strcmp (name
, "_DYNAMIC_LINK") == 0
6737 || strcmp (name
, "_DYNAMIC_LINKING") == 0)
6739 sym
->st_shndx
= SHN_ABS
;
6740 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6743 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (output_bfd
))
6745 sym
->st_shndx
= SHN_ABS
;
6746 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6747 sym
->st_value
= elf_gp (output_bfd
);
6749 else if (SGI_COMPAT (output_bfd
))
6751 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
6752 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
6754 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6755 sym
->st_other
= STO_PROTECTED
;
6757 sym
->st_shndx
= SHN_MIPS_DATA
;
6759 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
6761 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6762 sym
->st_other
= STO_PROTECTED
;
6763 sym
->st_value
= mips_elf_hash_table (info
)->procedure_count
;
6764 sym
->st_shndx
= SHN_ABS
;
6766 else if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
!= SHN_ABS
)
6768 if (h
->type
== STT_FUNC
)
6769 sym
->st_shndx
= SHN_MIPS_TEXT
;
6770 else if (h
->type
== STT_OBJECT
)
6771 sym
->st_shndx
= SHN_MIPS_DATA
;
6775 /* Handle the IRIX6-specific symbols. */
6776 if (IRIX_COMPAT (output_bfd
) == ict_irix6
)
6777 mips_elf_irix6_finish_dynamic_symbol (output_bfd
, name
, sym
);
6781 if (! mips_elf_hash_table (info
)->use_rld_obj_head
6782 && (strcmp (name
, "__rld_map") == 0
6783 || strcmp (name
, "__RLD_MAP") == 0))
6785 asection
*s
= bfd_get_section_by_name (dynobj
, ".rld_map");
6786 BFD_ASSERT (s
!= NULL
);
6787 sym
->st_value
= s
->output_section
->vma
+ s
->output_offset
;
6788 bfd_put_32 (output_bfd
, 0, s
->contents
);
6789 if (mips_elf_hash_table (info
)->rld_value
== 0)
6790 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
6792 else if (mips_elf_hash_table (info
)->use_rld_obj_head
6793 && strcmp (name
, "__rld_obj_head") == 0)
6795 /* IRIX6 does not use a .rld_map section. */
6796 if (IRIX_COMPAT (output_bfd
) == ict_irix5
6797 || IRIX_COMPAT (output_bfd
) == ict_none
)
6798 BFD_ASSERT (bfd_get_section_by_name (dynobj
, ".rld_map")
6800 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
6804 /* If this is a mips16 symbol, force the value to be even. */
6805 if (sym
->st_other
== STO_MIPS16
)
6806 sym
->st_value
&= ~1;
6811 /* Finish up the dynamic sections. */
6814 _bfd_mips_elf_finish_dynamic_sections (bfd
*output_bfd
,
6815 struct bfd_link_info
*info
)
6820 struct mips_got_info
*gg
, *g
;
6822 dynobj
= elf_hash_table (info
)->dynobj
;
6824 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
6826 sgot
= mips_elf_got_section (dynobj
, FALSE
);
6831 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
6832 gg
= mips_elf_section_data (sgot
)->u
.got_info
;
6833 BFD_ASSERT (gg
!= NULL
);
6834 g
= mips_elf_got_for_ibfd (gg
, output_bfd
);
6835 BFD_ASSERT (g
!= NULL
);
6838 if (elf_hash_table (info
)->dynamic_sections_created
)
6842 BFD_ASSERT (sdyn
!= NULL
);
6843 BFD_ASSERT (g
!= NULL
);
6845 for (b
= sdyn
->contents
;
6846 b
< sdyn
->contents
+ sdyn
->_raw_size
;
6847 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
6849 Elf_Internal_Dyn dyn
;
6853 bfd_boolean swap_out_p
;
6855 /* Read in the current dynamic entry. */
6856 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
6858 /* Assume that we're going to modify it and write it out. */
6864 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
6865 BFD_ASSERT (s
!= NULL
);
6866 dyn
.d_un
.d_val
= MIPS_ELF_REL_SIZE (dynobj
);
6870 /* Rewrite DT_STRSZ. */
6872 _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
6877 s
= bfd_get_section_by_name (output_bfd
, name
);
6878 BFD_ASSERT (s
!= NULL
);
6879 dyn
.d_un
.d_ptr
= s
->vma
;
6882 case DT_MIPS_RLD_VERSION
:
6883 dyn
.d_un
.d_val
= 1; /* XXX */
6887 dyn
.d_un
.d_val
= RHF_NOTPOT
; /* XXX */
6890 case DT_MIPS_TIME_STAMP
:
6891 time ((time_t *) &dyn
.d_un
.d_val
);
6894 case DT_MIPS_ICHECKSUM
:
6899 case DT_MIPS_IVERSION
:
6904 case DT_MIPS_BASE_ADDRESS
:
6905 s
= output_bfd
->sections
;
6906 BFD_ASSERT (s
!= NULL
);
6907 dyn
.d_un
.d_ptr
= s
->vma
& ~(bfd_vma
) 0xffff;
6910 case DT_MIPS_LOCAL_GOTNO
:
6911 dyn
.d_un
.d_val
= g
->local_gotno
;
6914 case DT_MIPS_UNREFEXTNO
:
6915 /* The index into the dynamic symbol table which is the
6916 entry of the first external symbol that is not
6917 referenced within the same object. */
6918 dyn
.d_un
.d_val
= bfd_count_sections (output_bfd
) + 1;
6921 case DT_MIPS_GOTSYM
:
6922 if (gg
->global_gotsym
)
6924 dyn
.d_un
.d_val
= gg
->global_gotsym
->dynindx
;
6927 /* In case if we don't have global got symbols we default
6928 to setting DT_MIPS_GOTSYM to the same value as
6929 DT_MIPS_SYMTABNO, so we just fall through. */
6931 case DT_MIPS_SYMTABNO
:
6933 elemsize
= MIPS_ELF_SYM_SIZE (output_bfd
);
6934 s
= bfd_get_section_by_name (output_bfd
, name
);
6935 BFD_ASSERT (s
!= NULL
);
6937 if (s
->_cooked_size
!= 0)
6938 dyn
.d_un
.d_val
= s
->_cooked_size
/ elemsize
;
6940 dyn
.d_un
.d_val
= s
->_raw_size
/ elemsize
;
6943 case DT_MIPS_HIPAGENO
:
6944 dyn
.d_un
.d_val
= g
->local_gotno
- MIPS_RESERVED_GOTNO
;
6947 case DT_MIPS_RLD_MAP
:
6948 dyn
.d_un
.d_ptr
= mips_elf_hash_table (info
)->rld_value
;
6951 case DT_MIPS_OPTIONS
:
6952 s
= (bfd_get_section_by_name
6953 (output_bfd
, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd
)));
6954 dyn
.d_un
.d_ptr
= s
->vma
;
6958 /* Reduce DT_RELSZ to account for any relocations we
6959 decided not to make. This is for the n64 irix rld,
6960 which doesn't seem to apply any relocations if there
6961 are trailing null entries. */
6962 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
6963 dyn
.d_un
.d_val
= (s
->reloc_count
6964 * (ABI_64_P (output_bfd
)
6965 ? sizeof (Elf64_Mips_External_Rel
)
6966 : sizeof (Elf32_External_Rel
)));
6975 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
6980 /* The first entry of the global offset table will be filled at
6981 runtime. The second entry will be used by some runtime loaders.
6982 This isn't the case of IRIX rld. */
6983 if (sgot
!= NULL
&& sgot
->_raw_size
> 0)
6985 MIPS_ELF_PUT_WORD (output_bfd
, 0, sgot
->contents
);
6986 MIPS_ELF_PUT_WORD (output_bfd
, 0x80000000,
6987 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
6991 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
6992 = MIPS_ELF_GOT_SIZE (output_bfd
);
6994 /* Generate dynamic relocations for the non-primary gots. */
6995 if (gg
!= NULL
&& gg
->next
)
6997 Elf_Internal_Rela rel
[3];
7000 memset (rel
, 0, sizeof (rel
));
7001 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_REL32
);
7003 for (g
= gg
->next
; g
->next
!= gg
; g
= g
->next
)
7005 bfd_vma index
= g
->next
->local_gotno
+ g
->next
->global_gotno
;
7007 MIPS_ELF_PUT_WORD (output_bfd
, 0, sgot
->contents
7008 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
7009 MIPS_ELF_PUT_WORD (output_bfd
, 0x80000000, sgot
->contents
7010 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
7015 while (index
< g
->assigned_gotno
)
7017 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
7018 = index
++ * MIPS_ELF_GOT_SIZE (output_bfd
);
7019 if (!(mips_elf_create_dynamic_relocation
7020 (output_bfd
, info
, rel
, NULL
,
7021 bfd_abs_section_ptr
,
7024 BFD_ASSERT (addend
== 0);
7031 Elf32_compact_rel cpt
;
7033 if (SGI_COMPAT (output_bfd
))
7035 /* Write .compact_rel section out. */
7036 s
= bfd_get_section_by_name (dynobj
, ".compact_rel");
7040 cpt
.num
= s
->reloc_count
;
7042 cpt
.offset
= (s
->output_section
->filepos
7043 + sizeof (Elf32_External_compact_rel
));
7046 bfd_elf32_swap_compact_rel_out (output_bfd
, &cpt
,
7047 ((Elf32_External_compact_rel
*)
7050 /* Clean up a dummy stub function entry in .text. */
7051 s
= bfd_get_section_by_name (dynobj
,
7052 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
7055 file_ptr dummy_offset
;
7057 BFD_ASSERT (s
->_raw_size
>= MIPS_FUNCTION_STUB_SIZE
);
7058 dummy_offset
= s
->_raw_size
- MIPS_FUNCTION_STUB_SIZE
;
7059 memset (s
->contents
+ dummy_offset
, 0,
7060 MIPS_FUNCTION_STUB_SIZE
);
7065 /* We need to sort the entries of the dynamic relocation section. */
7067 s
= mips_elf_rel_dyn_section (dynobj
, FALSE
);
7070 && s
->_raw_size
> (bfd_vma
)2 * MIPS_ELF_REL_SIZE (output_bfd
))
7072 reldyn_sorting_bfd
= output_bfd
;
7074 if (ABI_64_P (output_bfd
))
7075 qsort ((Elf64_External_Rel
*) s
->contents
+ 1, s
->reloc_count
- 1,
7076 sizeof (Elf64_Mips_External_Rel
), sort_dynamic_relocs_64
);
7078 qsort ((Elf32_External_Rel
*) s
->contents
+ 1, s
->reloc_count
- 1,
7079 sizeof (Elf32_External_Rel
), sort_dynamic_relocs
);
7087 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
7090 mips_set_isa_flags (bfd
*abfd
)
7094 switch (bfd_get_mach (abfd
))
7097 case bfd_mach_mips3000
:
7098 val
= E_MIPS_ARCH_1
;
7101 case bfd_mach_mips3900
:
7102 val
= E_MIPS_ARCH_1
| E_MIPS_MACH_3900
;
7105 case bfd_mach_mips6000
:
7106 val
= E_MIPS_ARCH_2
;
7109 case bfd_mach_mips4000
:
7110 case bfd_mach_mips4300
:
7111 case bfd_mach_mips4400
:
7112 case bfd_mach_mips4600
:
7113 val
= E_MIPS_ARCH_3
;
7116 case bfd_mach_mips4010
:
7117 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4010
;
7120 case bfd_mach_mips4100
:
7121 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4100
;
7124 case bfd_mach_mips4111
:
7125 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4111
;
7128 case bfd_mach_mips4120
:
7129 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4120
;
7132 case bfd_mach_mips4650
:
7133 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4650
;
7136 case bfd_mach_mips5400
:
7137 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5400
;
7140 case bfd_mach_mips5500
:
7141 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5500
;
7144 case bfd_mach_mips5000
:
7145 case bfd_mach_mips7000
:
7146 case bfd_mach_mips8000
:
7147 case bfd_mach_mips10000
:
7148 case bfd_mach_mips12000
:
7149 val
= E_MIPS_ARCH_4
;
7152 case bfd_mach_mips5
:
7153 val
= E_MIPS_ARCH_5
;
7156 case bfd_mach_mips_sb1
:
7157 val
= E_MIPS_ARCH_64
| E_MIPS_MACH_SB1
;
7160 case bfd_mach_mipsisa32
:
7161 val
= E_MIPS_ARCH_32
;
7164 case bfd_mach_mipsisa64
:
7165 val
= E_MIPS_ARCH_64
;
7168 case bfd_mach_mipsisa32r2
:
7169 val
= E_MIPS_ARCH_32R2
;
7172 case bfd_mach_mipsisa64r2
:
7173 val
= E_MIPS_ARCH_64R2
;
7176 elf_elfheader (abfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
7177 elf_elfheader (abfd
)->e_flags
|= val
;
7182 /* The final processing done just before writing out a MIPS ELF object
7183 file. This gets the MIPS architecture right based on the machine
7184 number. This is used by both the 32-bit and the 64-bit ABI. */
7187 _bfd_mips_elf_final_write_processing (bfd
*abfd
,
7188 bfd_boolean linker ATTRIBUTE_UNUSED
)
7191 Elf_Internal_Shdr
**hdrpp
;
7195 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
7196 is nonzero. This is for compatibility with old objects, which used
7197 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
7198 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_MACH
) == 0)
7199 mips_set_isa_flags (abfd
);
7201 /* Set the sh_info field for .gptab sections and other appropriate
7202 info for each special section. */
7203 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
7204 i
< elf_numsections (abfd
);
7207 switch ((*hdrpp
)->sh_type
)
7210 case SHT_MIPS_LIBLIST
:
7211 sec
= bfd_get_section_by_name (abfd
, ".dynstr");
7213 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7216 case SHT_MIPS_GPTAB
:
7217 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7218 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7219 BFD_ASSERT (name
!= NULL
7220 && strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0);
7221 sec
= bfd_get_section_by_name (abfd
, name
+ sizeof ".gptab" - 1);
7222 BFD_ASSERT (sec
!= NULL
);
7223 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
7226 case SHT_MIPS_CONTENT
:
7227 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7228 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7229 BFD_ASSERT (name
!= NULL
7230 && strncmp (name
, ".MIPS.content",
7231 sizeof ".MIPS.content" - 1) == 0);
7232 sec
= bfd_get_section_by_name (abfd
,
7233 name
+ sizeof ".MIPS.content" - 1);
7234 BFD_ASSERT (sec
!= NULL
);
7235 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7238 case SHT_MIPS_SYMBOL_LIB
:
7239 sec
= bfd_get_section_by_name (abfd
, ".dynsym");
7241 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7242 sec
= bfd_get_section_by_name (abfd
, ".liblist");
7244 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
7247 case SHT_MIPS_EVENTS
:
7248 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
7249 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
7250 BFD_ASSERT (name
!= NULL
);
7251 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0)
7252 sec
= bfd_get_section_by_name (abfd
,
7253 name
+ sizeof ".MIPS.events" - 1);
7256 BFD_ASSERT (strncmp (name
, ".MIPS.post_rel",
7257 sizeof ".MIPS.post_rel" - 1) == 0);
7258 sec
= bfd_get_section_by_name (abfd
,
7260 + sizeof ".MIPS.post_rel" - 1));
7262 BFD_ASSERT (sec
!= NULL
);
7263 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
7270 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
7274 _bfd_mips_elf_additional_program_headers (bfd
*abfd
)
7279 /* See if we need a PT_MIPS_REGINFO segment. */
7280 s
= bfd_get_section_by_name (abfd
, ".reginfo");
7281 if (s
&& (s
->flags
& SEC_LOAD
))
7284 /* See if we need a PT_MIPS_OPTIONS segment. */
7285 if (IRIX_COMPAT (abfd
) == ict_irix6
7286 && bfd_get_section_by_name (abfd
,
7287 MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)))
7290 /* See if we need a PT_MIPS_RTPROC segment. */
7291 if (IRIX_COMPAT (abfd
) == ict_irix5
7292 && bfd_get_section_by_name (abfd
, ".dynamic")
7293 && bfd_get_section_by_name (abfd
, ".mdebug"))
7299 /* Modify the segment map for an IRIX5 executable. */
7302 _bfd_mips_elf_modify_segment_map (bfd
*abfd
,
7303 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
7306 struct elf_segment_map
*m
, **pm
;
7309 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
7311 s
= bfd_get_section_by_name (abfd
, ".reginfo");
7312 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
7314 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
7315 if (m
->p_type
== PT_MIPS_REGINFO
)
7320 m
= bfd_zalloc (abfd
, amt
);
7324 m
->p_type
= PT_MIPS_REGINFO
;
7328 /* We want to put it after the PHDR and INTERP segments. */
7329 pm
= &elf_tdata (abfd
)->segment_map
;
7331 && ((*pm
)->p_type
== PT_PHDR
7332 || (*pm
)->p_type
== PT_INTERP
))
7340 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
7341 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
7342 PT_MIPS_OPTIONS segment immediately following the program header
7345 /* On non-IRIX6 new abi, we'll have already created a segment
7346 for this section, so don't create another. I'm not sure this
7347 is not also the case for IRIX 6, but I can't test it right
7349 && IRIX_COMPAT (abfd
) == ict_irix6
)
7351 for (s
= abfd
->sections
; s
; s
= s
->next
)
7352 if (elf_section_data (s
)->this_hdr
.sh_type
== SHT_MIPS_OPTIONS
)
7357 struct elf_segment_map
*options_segment
;
7359 pm
= &elf_tdata (abfd
)->segment_map
;
7361 && ((*pm
)->p_type
== PT_PHDR
7362 || (*pm
)->p_type
== PT_INTERP
))
7365 amt
= sizeof (struct elf_segment_map
);
7366 options_segment
= bfd_zalloc (abfd
, amt
);
7367 options_segment
->next
= *pm
;
7368 options_segment
->p_type
= PT_MIPS_OPTIONS
;
7369 options_segment
->p_flags
= PF_R
;
7370 options_segment
->p_flags_valid
= TRUE
;
7371 options_segment
->count
= 1;
7372 options_segment
->sections
[0] = s
;
7373 *pm
= options_segment
;
7378 if (IRIX_COMPAT (abfd
) == ict_irix5
)
7380 /* If there are .dynamic and .mdebug sections, we make a room
7381 for the RTPROC header. FIXME: Rewrite without section names. */
7382 if (bfd_get_section_by_name (abfd
, ".interp") == NULL
7383 && bfd_get_section_by_name (abfd
, ".dynamic") != NULL
7384 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
7386 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
7387 if (m
->p_type
== PT_MIPS_RTPROC
)
7392 m
= bfd_zalloc (abfd
, amt
);
7396 m
->p_type
= PT_MIPS_RTPROC
;
7398 s
= bfd_get_section_by_name (abfd
, ".rtproc");
7403 m
->p_flags_valid
= 1;
7411 /* We want to put it after the DYNAMIC segment. */
7412 pm
= &elf_tdata (abfd
)->segment_map
;
7413 while (*pm
!= NULL
&& (*pm
)->p_type
!= PT_DYNAMIC
)
7423 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
7424 .dynstr, .dynsym, and .hash sections, and everything in
7426 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
;
7428 if ((*pm
)->p_type
== PT_DYNAMIC
)
7431 if (m
!= NULL
&& IRIX_COMPAT (abfd
) == ict_none
)
7433 /* For a normal mips executable the permissions for the PT_DYNAMIC
7434 segment are read, write and execute. We do that here since
7435 the code in elf.c sets only the read permission. This matters
7436 sometimes for the dynamic linker. */
7437 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
7439 m
->p_flags
= PF_R
| PF_W
| PF_X
;
7440 m
->p_flags_valid
= 1;
7444 && m
->count
== 1 && strcmp (m
->sections
[0]->name
, ".dynamic") == 0)
7446 static const char *sec_names
[] =
7448 ".dynamic", ".dynstr", ".dynsym", ".hash"
7452 struct elf_segment_map
*n
;
7456 for (i
= 0; i
< sizeof sec_names
/ sizeof sec_names
[0]; i
++)
7458 s
= bfd_get_section_by_name (abfd
, sec_names
[i
]);
7459 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
7465 sz
= s
->_cooked_size
;
7468 if (high
< s
->vma
+ sz
)
7474 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
7475 if ((s
->flags
& SEC_LOAD
) != 0
7478 + (s
->_cooked_size
!=
7479 0 ? s
->_cooked_size
: s
->_raw_size
)) <= high
))
7482 amt
= sizeof *n
+ (bfd_size_type
) (c
- 1) * sizeof (asection
*);
7483 n
= bfd_zalloc (abfd
, amt
);
7490 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
7492 if ((s
->flags
& SEC_LOAD
) != 0
7495 + (s
->_cooked_size
!= 0 ?
7496 s
->_cooked_size
: s
->_raw_size
)) <= high
))
7510 /* Return the section that should be marked against GC for a given
7514 _bfd_mips_elf_gc_mark_hook (asection
*sec
,
7515 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
7516 Elf_Internal_Rela
*rel
,
7517 struct elf_link_hash_entry
*h
,
7518 Elf_Internal_Sym
*sym
)
7520 /* ??? Do mips16 stub sections need to be handled special? */
7524 switch (ELF_R_TYPE (sec
->owner
, rel
->r_info
))
7526 case R_MIPS_GNU_VTINHERIT
:
7527 case R_MIPS_GNU_VTENTRY
:
7531 switch (h
->root
.type
)
7533 case bfd_link_hash_defined
:
7534 case bfd_link_hash_defweak
:
7535 return h
->root
.u
.def
.section
;
7537 case bfd_link_hash_common
:
7538 return h
->root
.u
.c
.p
->section
;
7546 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
7551 /* Update the got entry reference counts for the section being removed. */
7554 _bfd_mips_elf_gc_sweep_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
7555 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
7556 asection
*sec ATTRIBUTE_UNUSED
,
7557 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
)
7560 Elf_Internal_Shdr
*symtab_hdr
;
7561 struct elf_link_hash_entry
**sym_hashes
;
7562 bfd_signed_vma
*local_got_refcounts
;
7563 const Elf_Internal_Rela
*rel
, *relend
;
7564 unsigned long r_symndx
;
7565 struct elf_link_hash_entry
*h
;
7567 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7568 sym_hashes
= elf_sym_hashes (abfd
);
7569 local_got_refcounts
= elf_local_got_refcounts (abfd
);
7571 relend
= relocs
+ sec
->reloc_count
;
7572 for (rel
= relocs
; rel
< relend
; rel
++)
7573 switch (ELF_R_TYPE (abfd
, rel
->r_info
))
7577 case R_MIPS_CALL_HI16
:
7578 case R_MIPS_CALL_LO16
:
7579 case R_MIPS_GOT_HI16
:
7580 case R_MIPS_GOT_LO16
:
7581 case R_MIPS_GOT_DISP
:
7582 case R_MIPS_GOT_PAGE
:
7583 case R_MIPS_GOT_OFST
:
7584 /* ??? It would seem that the existing MIPS code does no sort
7585 of reference counting or whatnot on its GOT and PLT entries,
7586 so it is not possible to garbage collect them at this time. */
7597 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
7598 hiding the old indirect symbol. Process additional relocation
7599 information. Also called for weakdefs, in which case we just let
7600 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
7603 _bfd_mips_elf_copy_indirect_symbol (const struct elf_backend_data
*bed
,
7604 struct elf_link_hash_entry
*dir
,
7605 struct elf_link_hash_entry
*ind
)
7607 struct mips_elf_link_hash_entry
*dirmips
, *indmips
;
7609 _bfd_elf_link_hash_copy_indirect (bed
, dir
, ind
);
7611 if (ind
->root
.type
!= bfd_link_hash_indirect
)
7614 dirmips
= (struct mips_elf_link_hash_entry
*) dir
;
7615 indmips
= (struct mips_elf_link_hash_entry
*) ind
;
7616 dirmips
->possibly_dynamic_relocs
+= indmips
->possibly_dynamic_relocs
;
7617 if (indmips
->readonly_reloc
)
7618 dirmips
->readonly_reloc
= TRUE
;
7619 if (indmips
->no_fn_stub
)
7620 dirmips
->no_fn_stub
= TRUE
;
7624 _bfd_mips_elf_hide_symbol (struct bfd_link_info
*info
,
7625 struct elf_link_hash_entry
*entry
,
7626 bfd_boolean force_local
)
7630 struct mips_got_info
*g
;
7631 struct mips_elf_link_hash_entry
*h
;
7633 h
= (struct mips_elf_link_hash_entry
*) entry
;
7634 if (h
->forced_local
)
7636 h
->forced_local
= force_local
;
7638 dynobj
= elf_hash_table (info
)->dynobj
;
7639 if (dynobj
!= NULL
&& force_local
)
7641 got
= mips_elf_got_section (dynobj
, FALSE
);
7642 g
= mips_elf_section_data (got
)->u
.got_info
;
7646 struct mips_got_entry e
;
7647 struct mips_got_info
*gg
= g
;
7649 /* Since we're turning what used to be a global symbol into a
7650 local one, bump up the number of local entries of each GOT
7651 that had an entry for it. This will automatically decrease
7652 the number of global entries, since global_gotno is actually
7653 the upper limit of global entries. */
7658 for (g
= g
->next
; g
!= gg
; g
= g
->next
)
7659 if (htab_find (g
->got_entries
, &e
))
7661 BFD_ASSERT (g
->global_gotno
> 0);
7666 /* If this was a global symbol forced into the primary GOT, we
7667 no longer need an entry for it. We can't release the entry
7668 at this point, but we must at least stop counting it as one
7669 of the symbols that required a forced got entry. */
7670 if (h
->root
.got
.offset
== 2)
7672 BFD_ASSERT (gg
->assigned_gotno
> 0);
7673 gg
->assigned_gotno
--;
7676 else if (g
->global_gotno
== 0 && g
->global_gotsym
== NULL
)
7677 /* If we haven't got through GOT allocation yet, just bump up the
7678 number of local entries, as this symbol won't be counted as
7681 else if (h
->root
.got
.offset
== 1)
7683 /* If we're past non-multi-GOT allocation and this symbol had
7684 been marked for a global got entry, give it a local entry
7686 BFD_ASSERT (g
->global_gotno
> 0);
7692 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
7698 _bfd_mips_elf_discard_info (bfd
*abfd
, struct elf_reloc_cookie
*cookie
,
7699 struct bfd_link_info
*info
)
7702 bfd_boolean ret
= FALSE
;
7703 unsigned char *tdata
;
7706 o
= bfd_get_section_by_name (abfd
, ".pdr");
7709 if (o
->_raw_size
== 0)
7711 if (o
->_raw_size
% PDR_SIZE
!= 0)
7713 if (o
->output_section
!= NULL
7714 && bfd_is_abs_section (o
->output_section
))
7717 tdata
= bfd_zmalloc (o
->_raw_size
/ PDR_SIZE
);
7721 cookie
->rels
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
7729 cookie
->rel
= cookie
->rels
;
7730 cookie
->relend
= cookie
->rels
+ o
->reloc_count
;
7732 for (i
= 0, skip
= 0; i
< o
->_raw_size
/ PDR_SIZE
; i
++)
7734 if (MNAME(abfd
,_bfd_elf
,reloc_symbol_deleted_p
) (i
* PDR_SIZE
, cookie
))
7743 mips_elf_section_data (o
)->u
.tdata
= tdata
;
7744 o
->_cooked_size
= o
->_raw_size
- skip
* PDR_SIZE
;
7750 if (! info
->keep_memory
)
7751 free (cookie
->rels
);
7757 _bfd_mips_elf_ignore_discarded_relocs (asection
*sec
)
7759 if (strcmp (sec
->name
, ".pdr") == 0)
7765 _bfd_mips_elf_write_section (bfd
*output_bfd
, asection
*sec
,
7768 bfd_byte
*to
, *from
, *end
;
7771 if (strcmp (sec
->name
, ".pdr") != 0)
7774 if (mips_elf_section_data (sec
)->u
.tdata
== NULL
)
7778 end
= contents
+ sec
->_raw_size
;
7779 for (from
= contents
, i
= 0;
7781 from
+= PDR_SIZE
, i
++)
7783 if ((mips_elf_section_data (sec
)->u
.tdata
)[i
] == 1)
7786 memcpy (to
, from
, PDR_SIZE
);
7789 bfd_set_section_contents (output_bfd
, sec
->output_section
, contents
,
7790 sec
->output_offset
, sec
->_cooked_size
);
7794 /* MIPS ELF uses a special find_nearest_line routine in order the
7795 handle the ECOFF debugging information. */
7797 struct mips_elf_find_line
7799 struct ecoff_debug_info d
;
7800 struct ecoff_find_line i
;
7804 _bfd_mips_elf_find_nearest_line (bfd
*abfd
, asection
*section
,
7805 asymbol
**symbols
, bfd_vma offset
,
7806 const char **filename_ptr
,
7807 const char **functionname_ptr
,
7808 unsigned int *line_ptr
)
7812 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
7813 filename_ptr
, functionname_ptr
,
7817 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
7818 filename_ptr
, functionname_ptr
,
7819 line_ptr
, ABI_64_P (abfd
) ? 8 : 0,
7820 &elf_tdata (abfd
)->dwarf2_find_line_info
))
7823 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
7827 struct mips_elf_find_line
*fi
;
7828 const struct ecoff_debug_swap
* const swap
=
7829 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
7831 /* If we are called during a link, mips_elf_final_link may have
7832 cleared the SEC_HAS_CONTENTS field. We force it back on here
7833 if appropriate (which it normally will be). */
7834 origflags
= msec
->flags
;
7835 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
7836 msec
->flags
|= SEC_HAS_CONTENTS
;
7838 fi
= elf_tdata (abfd
)->find_line_info
;
7841 bfd_size_type external_fdr_size
;
7844 struct fdr
*fdr_ptr
;
7845 bfd_size_type amt
= sizeof (struct mips_elf_find_line
);
7847 fi
= bfd_zalloc (abfd
, amt
);
7850 msec
->flags
= origflags
;
7854 if (! _bfd_mips_elf_read_ecoff_info (abfd
, msec
, &fi
->d
))
7856 msec
->flags
= origflags
;
7860 /* Swap in the FDR information. */
7861 amt
= fi
->d
.symbolic_header
.ifdMax
* sizeof (struct fdr
);
7862 fi
->d
.fdr
= bfd_alloc (abfd
, amt
);
7863 if (fi
->d
.fdr
== NULL
)
7865 msec
->flags
= origflags
;
7868 external_fdr_size
= swap
->external_fdr_size
;
7869 fdr_ptr
= fi
->d
.fdr
;
7870 fraw_src
= (char *) fi
->d
.external_fdr
;
7871 fraw_end
= (fraw_src
7872 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
7873 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
7874 (*swap
->swap_fdr_in
) (abfd
, fraw_src
, fdr_ptr
);
7876 elf_tdata (abfd
)->find_line_info
= fi
;
7878 /* Note that we don't bother to ever free this information.
7879 find_nearest_line is either called all the time, as in
7880 objdump -l, so the information should be saved, or it is
7881 rarely called, as in ld error messages, so the memory
7882 wasted is unimportant. Still, it would probably be a
7883 good idea for free_cached_info to throw it away. */
7886 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
7887 &fi
->i
, filename_ptr
, functionname_ptr
,
7890 msec
->flags
= origflags
;
7894 msec
->flags
= origflags
;
7897 /* Fall back on the generic ELF find_nearest_line routine. */
7899 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
7900 filename_ptr
, functionname_ptr
,
7904 /* When are writing out the .options or .MIPS.options section,
7905 remember the bytes we are writing out, so that we can install the
7906 GP value in the section_processing routine. */
7909 _bfd_mips_elf_set_section_contents (bfd
*abfd
, sec_ptr section
,
7910 const void *location
,
7911 file_ptr offset
, bfd_size_type count
)
7913 if (strcmp (section
->name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
7917 if (elf_section_data (section
) == NULL
)
7919 bfd_size_type amt
= sizeof (struct bfd_elf_section_data
);
7920 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
7921 if (elf_section_data (section
) == NULL
)
7924 c
= mips_elf_section_data (section
)->u
.tdata
;
7929 if (section
->_cooked_size
!= 0)
7930 size
= section
->_cooked_size
;
7932 size
= section
->_raw_size
;
7933 c
= bfd_zalloc (abfd
, size
);
7936 mips_elf_section_data (section
)->u
.tdata
= c
;
7939 memcpy (c
+ offset
, location
, count
);
7942 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
,
7946 /* This is almost identical to bfd_generic_get_... except that some
7947 MIPS relocations need to be handled specially. Sigh. */
7950 _bfd_elf_mips_get_relocated_section_contents
7952 struct bfd_link_info
*link_info
,
7953 struct bfd_link_order
*link_order
,
7955 bfd_boolean relocatable
,
7958 /* Get enough memory to hold the stuff */
7959 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
7960 asection
*input_section
= link_order
->u
.indirect
.section
;
7962 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
7963 arelent
**reloc_vector
= NULL
;
7969 reloc_vector
= bfd_malloc (reloc_size
);
7970 if (reloc_vector
== NULL
&& reloc_size
!= 0)
7973 /* read in the section */
7974 if (!bfd_get_section_contents (input_bfd
, input_section
, data
, 0,
7975 input_section
->_raw_size
))
7978 /* We're not relaxing the section, so just copy the size info */
7979 input_section
->_cooked_size
= input_section
->_raw_size
;
7980 input_section
->reloc_done
= TRUE
;
7982 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
7986 if (reloc_count
< 0)
7989 if (reloc_count
> 0)
7994 bfd_vma gp
= 0x12345678; /* initialize just to shut gcc up */
7997 struct bfd_hash_entry
*h
;
7998 struct bfd_link_hash_entry
*lh
;
7999 /* Skip all this stuff if we aren't mixing formats. */
8000 if (abfd
&& input_bfd
8001 && abfd
->xvec
== input_bfd
->xvec
)
8005 h
= bfd_hash_lookup (&link_info
->hash
->table
, "_gp", FALSE
, FALSE
);
8006 lh
= (struct bfd_link_hash_entry
*) h
;
8013 case bfd_link_hash_undefined
:
8014 case bfd_link_hash_undefweak
:
8015 case bfd_link_hash_common
:
8018 case bfd_link_hash_defined
:
8019 case bfd_link_hash_defweak
:
8021 gp
= lh
->u
.def
.value
;
8023 case bfd_link_hash_indirect
:
8024 case bfd_link_hash_warning
:
8026 /* @@FIXME ignoring warning for now */
8028 case bfd_link_hash_new
:
8037 for (parent
= reloc_vector
; *parent
!= NULL
; parent
++)
8039 char *error_message
= NULL
;
8040 bfd_reloc_status_type r
;
8042 /* Specific to MIPS: Deal with relocation types that require
8043 knowing the gp of the output bfd. */
8044 asymbol
*sym
= *(*parent
)->sym_ptr_ptr
;
8045 if (bfd_is_abs_section (sym
->section
) && abfd
)
8047 /* The special_function wouldn't get called anyway. */
8051 /* The gp isn't there; let the special function code
8052 fall over on its own. */
8054 else if ((*parent
)->howto
->special_function
8055 == _bfd_mips_elf32_gprel16_reloc
)
8057 /* bypass special_function call */
8058 r
= _bfd_mips_elf_gprel16_with_gp (input_bfd
, sym
, *parent
,
8059 input_section
, relocatable
,
8061 goto skip_bfd_perform_relocation
;
8063 /* end mips specific stuff */
8065 r
= bfd_perform_relocation (input_bfd
, *parent
, data
, input_section
,
8066 relocatable
? abfd
: NULL
,
8068 skip_bfd_perform_relocation
:
8072 asection
*os
= input_section
->output_section
;
8074 /* A partial link, so keep the relocs */
8075 os
->orelocation
[os
->reloc_count
] = *parent
;
8079 if (r
!= bfd_reloc_ok
)
8083 case bfd_reloc_undefined
:
8084 if (!((*link_info
->callbacks
->undefined_symbol
)
8085 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
8086 input_bfd
, input_section
, (*parent
)->address
,
8090 case bfd_reloc_dangerous
:
8091 BFD_ASSERT (error_message
!= NULL
);
8092 if (!((*link_info
->callbacks
->reloc_dangerous
)
8093 (link_info
, error_message
, input_bfd
, input_section
,
8094 (*parent
)->address
)))
8097 case bfd_reloc_overflow
:
8098 if (!((*link_info
->callbacks
->reloc_overflow
)
8099 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
8100 (*parent
)->howto
->name
, (*parent
)->addend
,
8101 input_bfd
, input_section
, (*parent
)->address
)))
8104 case bfd_reloc_outofrange
:
8113 if (reloc_vector
!= NULL
)
8114 free (reloc_vector
);
8118 if (reloc_vector
!= NULL
)
8119 free (reloc_vector
);
8123 /* Create a MIPS ELF linker hash table. */
8125 struct bfd_link_hash_table
*
8126 _bfd_mips_elf_link_hash_table_create (bfd
*abfd
)
8128 struct mips_elf_link_hash_table
*ret
;
8129 bfd_size_type amt
= sizeof (struct mips_elf_link_hash_table
);
8131 ret
= bfd_malloc (amt
);
8135 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
8136 mips_elf_link_hash_newfunc
))
8143 /* We no longer use this. */
8144 for (i
= 0; i
< SIZEOF_MIPS_DYNSYM_SECNAMES
; i
++)
8145 ret
->dynsym_sec_strindex
[i
] = (bfd_size_type
) -1;
8147 ret
->procedure_count
= 0;
8148 ret
->compact_rel_size
= 0;
8149 ret
->use_rld_obj_head
= FALSE
;
8151 ret
->mips16_stubs_seen
= FALSE
;
8153 return &ret
->root
.root
;
8156 /* We need to use a special link routine to handle the .reginfo and
8157 the .mdebug sections. We need to merge all instances of these
8158 sections together, not write them all out sequentially. */
8161 _bfd_mips_elf_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
8165 struct bfd_link_order
*p
;
8166 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
8167 asection
*rtproc_sec
;
8168 Elf32_RegInfo reginfo
;
8169 struct ecoff_debug_info debug
;
8170 const struct ecoff_debug_swap
*swap
8171 = get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
8172 HDRR
*symhdr
= &debug
.symbolic_header
;
8173 void *mdebug_handle
= NULL
;
8179 static const char * const secname
[] =
8181 ".text", ".init", ".fini", ".data",
8182 ".rodata", ".sdata", ".sbss", ".bss"
8184 static const int sc
[] =
8186 scText
, scInit
, scFini
, scData
,
8187 scRData
, scSData
, scSBss
, scBss
8190 /* We'd carefully arranged the dynamic symbol indices, and then the
8191 generic size_dynamic_sections renumbered them out from under us.
8192 Rather than trying somehow to prevent the renumbering, just do
8194 if (elf_hash_table (info
)->dynamic_sections_created
)
8198 struct mips_got_info
*g
;
8200 /* When we resort, we must tell mips_elf_sort_hash_table what
8201 the lowest index it may use is. That's the number of section
8202 symbols we're going to add. The generic ELF linker only
8203 adds these symbols when building a shared object. Note that
8204 we count the sections after (possibly) removing the .options
8206 if (! mips_elf_sort_hash_table (info
, (info
->shared
8207 ? bfd_count_sections (abfd
) + 1
8211 /* Make sure we didn't grow the global .got region. */
8212 dynobj
= elf_hash_table (info
)->dynobj
;
8213 got
= mips_elf_got_section (dynobj
, FALSE
);
8214 g
= mips_elf_section_data (got
)->u
.got_info
;
8216 if (g
->global_gotsym
!= NULL
)
8217 BFD_ASSERT ((elf_hash_table (info
)->dynsymcount
8218 - g
->global_gotsym
->dynindx
)
8219 <= g
->global_gotno
);
8223 /* We want to set the GP value for ld -r. */
8224 /* On IRIX5, we omit the .options section. On IRIX6, however, we
8225 include it, even though we don't process it quite right. (Some
8226 entries are supposed to be merged.) Empirically, we seem to be
8227 better off including it then not. */
8228 if (IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
8229 for (secpp
= &abfd
->sections
; *secpp
!= NULL
; secpp
= &(*secpp
)->next
)
8231 if (strcmp ((*secpp
)->name
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)) == 0)
8233 for (p
= (*secpp
)->link_order_head
; p
!= NULL
; p
= p
->next
)
8234 if (p
->type
== bfd_indirect_link_order
)
8235 p
->u
.indirect
.section
->flags
&= ~SEC_HAS_CONTENTS
;
8236 (*secpp
)->link_order_head
= NULL
;
8237 bfd_section_list_remove (abfd
, secpp
);
8238 --abfd
->section_count
;
8244 /* We include .MIPS.options, even though we don't process it quite right.
8245 (Some entries are supposed to be merged.) At IRIX6 empirically we seem
8246 to be better off including it than not. */
8247 for (secpp
= &abfd
->sections
; *secpp
!= NULL
; secpp
= &(*secpp
)->next
)
8249 if (strcmp ((*secpp
)->name
, ".MIPS.options") == 0)
8251 for (p
= (*secpp
)->link_order_head
; p
!= NULL
; p
= p
->next
)
8252 if (p
->type
== bfd_indirect_link_order
)
8253 p
->u
.indirect
.section
->flags
&=~ SEC_HAS_CONTENTS
;
8254 (*secpp
)->link_order_head
= NULL
;
8255 bfd_section_list_remove (abfd
, secpp
);
8256 --abfd
->section_count
;
8263 /* Get a value for the GP register. */
8264 if (elf_gp (abfd
) == 0)
8266 struct bfd_link_hash_entry
*h
;
8268 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
8269 if (h
!= NULL
&& h
->type
== bfd_link_hash_defined
)
8270 elf_gp (abfd
) = (h
->u
.def
.value
8271 + h
->u
.def
.section
->output_section
->vma
8272 + h
->u
.def
.section
->output_offset
);
8273 else if (info
->relocatable
)
8275 bfd_vma lo
= MINUS_ONE
;
8277 /* Find the GP-relative section with the lowest offset. */
8278 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
8280 && (elf_section_data (o
)->this_hdr
.sh_flags
& SHF_MIPS_GPREL
))
8283 /* And calculate GP relative to that. */
8284 elf_gp (abfd
) = lo
+ ELF_MIPS_GP_OFFSET (abfd
);
8288 /* If the relocate_section function needs to do a reloc
8289 involving the GP value, it should make a reloc_dangerous
8290 callback to warn that GP is not defined. */
8294 /* Go through the sections and collect the .reginfo and .mdebug
8298 gptab_data_sec
= NULL
;
8299 gptab_bss_sec
= NULL
;
8300 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
8302 if (strcmp (o
->name
, ".reginfo") == 0)
8304 memset (®info
, 0, sizeof reginfo
);
8306 /* We have found the .reginfo section in the output file.
8307 Look through all the link_orders comprising it and merge
8308 the information together. */
8309 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8311 asection
*input_section
;
8313 Elf32_External_RegInfo ext
;
8316 if (p
->type
!= bfd_indirect_link_order
)
8318 if (p
->type
== bfd_data_link_order
)
8323 input_section
= p
->u
.indirect
.section
;
8324 input_bfd
= input_section
->owner
;
8326 /* The linker emulation code has probably clobbered the
8327 size to be zero bytes. */
8328 if (input_section
->_raw_size
== 0)
8329 input_section
->_raw_size
= sizeof (Elf32_External_RegInfo
);
8331 if (! bfd_get_section_contents (input_bfd
, input_section
,
8332 &ext
, 0, sizeof ext
))
8335 bfd_mips_elf32_swap_reginfo_in (input_bfd
, &ext
, &sub
);
8337 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
8338 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
8339 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
8340 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
8341 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
8343 /* ri_gp_value is set by the function
8344 mips_elf32_section_processing when the section is
8345 finally written out. */
8347 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8348 elf_link_input_bfd ignores this section. */
8349 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8352 /* Size has been set in _bfd_mips_elf_always_size_sections. */
8353 BFD_ASSERT(o
->_raw_size
== sizeof (Elf32_External_RegInfo
));
8355 /* Skip this section later on (I don't think this currently
8356 matters, but someday it might). */
8357 o
->link_order_head
= NULL
;
8362 if (strcmp (o
->name
, ".mdebug") == 0)
8364 struct extsym_info einfo
;
8367 /* We have found the .mdebug section in the output file.
8368 Look through all the link_orders comprising it and merge
8369 the information together. */
8370 symhdr
->magic
= swap
->sym_magic
;
8371 /* FIXME: What should the version stamp be? */
8373 symhdr
->ilineMax
= 0;
8377 symhdr
->isymMax
= 0;
8378 symhdr
->ioptMax
= 0;
8379 symhdr
->iauxMax
= 0;
8381 symhdr
->issExtMax
= 0;
8384 symhdr
->iextMax
= 0;
8386 /* We accumulate the debugging information itself in the
8387 debug_info structure. */
8389 debug
.external_dnr
= NULL
;
8390 debug
.external_pdr
= NULL
;
8391 debug
.external_sym
= NULL
;
8392 debug
.external_opt
= NULL
;
8393 debug
.external_aux
= NULL
;
8395 debug
.ssext
= debug
.ssext_end
= NULL
;
8396 debug
.external_fdr
= NULL
;
8397 debug
.external_rfd
= NULL
;
8398 debug
.external_ext
= debug
.external_ext_end
= NULL
;
8400 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
8401 if (mdebug_handle
== NULL
)
8405 esym
.cobol_main
= 0;
8409 esym
.asym
.iss
= issNil
;
8410 esym
.asym
.st
= stLocal
;
8411 esym
.asym
.reserved
= 0;
8412 esym
.asym
.index
= indexNil
;
8414 for (i
= 0; i
< sizeof (secname
) / sizeof (secname
[0]); i
++)
8416 esym
.asym
.sc
= sc
[i
];
8417 s
= bfd_get_section_by_name (abfd
, secname
[i
]);
8420 esym
.asym
.value
= s
->vma
;
8421 last
= s
->vma
+ s
->_raw_size
;
8424 esym
.asym
.value
= last
;
8425 if (!bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
8430 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8432 asection
*input_section
;
8434 const struct ecoff_debug_swap
*input_swap
;
8435 struct ecoff_debug_info input_debug
;
8439 if (p
->type
!= bfd_indirect_link_order
)
8441 if (p
->type
== bfd_data_link_order
)
8446 input_section
= p
->u
.indirect
.section
;
8447 input_bfd
= input_section
->owner
;
8449 if (bfd_get_flavour (input_bfd
) != bfd_target_elf_flavour
8450 || (get_elf_backend_data (input_bfd
)
8451 ->elf_backend_ecoff_debug_swap
) == NULL
)
8453 /* I don't know what a non MIPS ELF bfd would be
8454 doing with a .mdebug section, but I don't really
8455 want to deal with it. */
8459 input_swap
= (get_elf_backend_data (input_bfd
)
8460 ->elf_backend_ecoff_debug_swap
);
8462 BFD_ASSERT (p
->size
== input_section
->_raw_size
);
8464 /* The ECOFF linking code expects that we have already
8465 read in the debugging information and set up an
8466 ecoff_debug_info structure, so we do that now. */
8467 if (! _bfd_mips_elf_read_ecoff_info (input_bfd
, input_section
,
8471 if (! (bfd_ecoff_debug_accumulate
8472 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
8473 &input_debug
, input_swap
, info
)))
8476 /* Loop through the external symbols. For each one with
8477 interesting information, try to find the symbol in
8478 the linker global hash table and save the information
8479 for the output external symbols. */
8480 eraw_src
= input_debug
.external_ext
;
8481 eraw_end
= (eraw_src
8482 + (input_debug
.symbolic_header
.iextMax
8483 * input_swap
->external_ext_size
));
8485 eraw_src
< eraw_end
;
8486 eraw_src
+= input_swap
->external_ext_size
)
8490 struct mips_elf_link_hash_entry
*h
;
8492 (*input_swap
->swap_ext_in
) (input_bfd
, eraw_src
, &ext
);
8493 if (ext
.asym
.sc
== scNil
8494 || ext
.asym
.sc
== scUndefined
8495 || ext
.asym
.sc
== scSUndefined
)
8498 name
= input_debug
.ssext
+ ext
.asym
.iss
;
8499 h
= mips_elf_link_hash_lookup (mips_elf_hash_table (info
),
8500 name
, FALSE
, FALSE
, TRUE
);
8501 if (h
== NULL
|| h
->esym
.ifd
!= -2)
8507 < input_debug
.symbolic_header
.ifdMax
);
8508 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
8514 /* Free up the information we just read. */
8515 free (input_debug
.line
);
8516 free (input_debug
.external_dnr
);
8517 free (input_debug
.external_pdr
);
8518 free (input_debug
.external_sym
);
8519 free (input_debug
.external_opt
);
8520 free (input_debug
.external_aux
);
8521 free (input_debug
.ss
);
8522 free (input_debug
.ssext
);
8523 free (input_debug
.external_fdr
);
8524 free (input_debug
.external_rfd
);
8525 free (input_debug
.external_ext
);
8527 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8528 elf_link_input_bfd ignores this section. */
8529 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8532 if (SGI_COMPAT (abfd
) && info
->shared
)
8534 /* Create .rtproc section. */
8535 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
8536 if (rtproc_sec
== NULL
)
8538 flagword flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
8539 | SEC_LINKER_CREATED
| SEC_READONLY
);
8541 rtproc_sec
= bfd_make_section (abfd
, ".rtproc");
8542 if (rtproc_sec
== NULL
8543 || ! bfd_set_section_flags (abfd
, rtproc_sec
, flags
)
8544 || ! bfd_set_section_alignment (abfd
, rtproc_sec
, 4))
8548 if (! mips_elf_create_procedure_table (mdebug_handle
, abfd
,
8554 /* Build the external symbol information. */
8557 einfo
.debug
= &debug
;
8559 einfo
.failed
= FALSE
;
8560 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
8561 mips_elf_output_extsym
, &einfo
);
8565 /* Set the size of the .mdebug section. */
8566 o
->_raw_size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
8568 /* Skip this section later on (I don't think this currently
8569 matters, but someday it might). */
8570 o
->link_order_head
= NULL
;
8575 if (strncmp (o
->name
, ".gptab.", sizeof ".gptab." - 1) == 0)
8577 const char *subname
;
8580 Elf32_External_gptab
*ext_tab
;
8583 /* The .gptab.sdata and .gptab.sbss sections hold
8584 information describing how the small data area would
8585 change depending upon the -G switch. These sections
8586 not used in executables files. */
8587 if (! info
->relocatable
)
8589 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8591 asection
*input_section
;
8593 if (p
->type
!= bfd_indirect_link_order
)
8595 if (p
->type
== bfd_data_link_order
)
8600 input_section
= p
->u
.indirect
.section
;
8602 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8603 elf_link_input_bfd ignores this section. */
8604 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8607 /* Skip this section later on (I don't think this
8608 currently matters, but someday it might). */
8609 o
->link_order_head
= NULL
;
8611 /* Really remove the section. */
8612 for (secpp
= &abfd
->sections
;
8614 secpp
= &(*secpp
)->next
)
8616 bfd_section_list_remove (abfd
, secpp
);
8617 --abfd
->section_count
;
8622 /* There is one gptab for initialized data, and one for
8623 uninitialized data. */
8624 if (strcmp (o
->name
, ".gptab.sdata") == 0)
8626 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
8630 (*_bfd_error_handler
)
8631 (_("%s: illegal section name `%s'"),
8632 bfd_get_filename (abfd
), o
->name
);
8633 bfd_set_error (bfd_error_nonrepresentable_section
);
8637 /* The linker script always combines .gptab.data and
8638 .gptab.sdata into .gptab.sdata, and likewise for
8639 .gptab.bss and .gptab.sbss. It is possible that there is
8640 no .sdata or .sbss section in the output file, in which
8641 case we must change the name of the output section. */
8642 subname
= o
->name
+ sizeof ".gptab" - 1;
8643 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
8645 if (o
== gptab_data_sec
)
8646 o
->name
= ".gptab.data";
8648 o
->name
= ".gptab.bss";
8649 subname
= o
->name
+ sizeof ".gptab" - 1;
8650 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
8653 /* Set up the first entry. */
8655 amt
= c
* sizeof (Elf32_gptab
);
8656 tab
= bfd_malloc (amt
);
8659 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
8660 tab
[0].gt_header
.gt_unused
= 0;
8662 /* Combine the input sections. */
8663 for (p
= o
->link_order_head
; p
!= NULL
; p
= p
->next
)
8665 asection
*input_section
;
8669 bfd_size_type gpentry
;
8671 if (p
->type
!= bfd_indirect_link_order
)
8673 if (p
->type
== bfd_data_link_order
)
8678 input_section
= p
->u
.indirect
.section
;
8679 input_bfd
= input_section
->owner
;
8681 /* Combine the gptab entries for this input section one
8682 by one. We know that the input gptab entries are
8683 sorted by ascending -G value. */
8684 size
= bfd_section_size (input_bfd
, input_section
);
8686 for (gpentry
= sizeof (Elf32_External_gptab
);
8688 gpentry
+= sizeof (Elf32_External_gptab
))
8690 Elf32_External_gptab ext_gptab
;
8691 Elf32_gptab int_gptab
;
8697 if (! (bfd_get_section_contents
8698 (input_bfd
, input_section
, &ext_gptab
, gpentry
,
8699 sizeof (Elf32_External_gptab
))))
8705 bfd_mips_elf32_swap_gptab_in (input_bfd
, &ext_gptab
,
8707 val
= int_gptab
.gt_entry
.gt_g_value
;
8708 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
8711 for (look
= 1; look
< c
; look
++)
8713 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
8714 tab
[look
].gt_entry
.gt_bytes
+= add
;
8716 if (tab
[look
].gt_entry
.gt_g_value
== val
)
8722 Elf32_gptab
*new_tab
;
8725 /* We need a new table entry. */
8726 amt
= (bfd_size_type
) (c
+ 1) * sizeof (Elf32_gptab
);
8727 new_tab
= bfd_realloc (tab
, amt
);
8728 if (new_tab
== NULL
)
8734 tab
[c
].gt_entry
.gt_g_value
= val
;
8735 tab
[c
].gt_entry
.gt_bytes
= add
;
8737 /* Merge in the size for the next smallest -G
8738 value, since that will be implied by this new
8741 for (look
= 1; look
< c
; look
++)
8743 if (tab
[look
].gt_entry
.gt_g_value
< val
8745 || (tab
[look
].gt_entry
.gt_g_value
8746 > tab
[max
].gt_entry
.gt_g_value
)))
8750 tab
[c
].gt_entry
.gt_bytes
+=
8751 tab
[max
].gt_entry
.gt_bytes
;
8756 last
= int_gptab
.gt_entry
.gt_bytes
;
8759 /* Hack: reset the SEC_HAS_CONTENTS flag so that
8760 elf_link_input_bfd ignores this section. */
8761 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
8764 /* The table must be sorted by -G value. */
8766 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
8768 /* Swap out the table. */
8769 amt
= (bfd_size_type
) c
* sizeof (Elf32_External_gptab
);
8770 ext_tab
= bfd_alloc (abfd
, amt
);
8771 if (ext_tab
== NULL
)
8777 for (j
= 0; j
< c
; j
++)
8778 bfd_mips_elf32_swap_gptab_out (abfd
, tab
+ j
, ext_tab
+ j
);
8781 o
->_raw_size
= c
* sizeof (Elf32_External_gptab
);
8782 o
->contents
= (bfd_byte
*) ext_tab
;
8784 /* Skip this section later on (I don't think this currently
8785 matters, but someday it might). */
8786 o
->link_order_head
= NULL
;
8790 /* Invoke the regular ELF backend linker to do all the work. */
8791 if (!MNAME(abfd
,bfd_elf
,bfd_final_link
) (abfd
, info
))
8794 /* Now write out the computed sections. */
8796 if (reginfo_sec
!= NULL
)
8798 Elf32_External_RegInfo ext
;
8800 bfd_mips_elf32_swap_reginfo_out (abfd
, ®info
, &ext
);
8801 if (! bfd_set_section_contents (abfd
, reginfo_sec
, &ext
, 0, sizeof ext
))
8805 if (mdebug_sec
!= NULL
)
8807 BFD_ASSERT (abfd
->output_has_begun
);
8808 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
8810 mdebug_sec
->filepos
))
8813 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
8816 if (gptab_data_sec
!= NULL
)
8818 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
8819 gptab_data_sec
->contents
,
8820 0, gptab_data_sec
->_raw_size
))
8824 if (gptab_bss_sec
!= NULL
)
8826 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
8827 gptab_bss_sec
->contents
,
8828 0, gptab_bss_sec
->_raw_size
))
8832 if (SGI_COMPAT (abfd
))
8834 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
8835 if (rtproc_sec
!= NULL
)
8837 if (! bfd_set_section_contents (abfd
, rtproc_sec
,
8838 rtproc_sec
->contents
,
8839 0, rtproc_sec
->_raw_size
))
8847 /* Structure for saying that BFD machine EXTENSION extends BASE. */
8849 struct mips_mach_extension
{
8850 unsigned long extension
, base
;
8854 /* An array describing how BFD machines relate to one another. The entries
8855 are ordered topologically with MIPS I extensions listed last. */
8857 static const struct mips_mach_extension mips_mach_extensions
[] = {
8858 /* MIPS64 extensions. */
8859 { bfd_mach_mipsisa64r2
, bfd_mach_mipsisa64
},
8860 { bfd_mach_mips_sb1
, bfd_mach_mipsisa64
},
8862 /* MIPS V extensions. */
8863 { bfd_mach_mipsisa64
, bfd_mach_mips5
},
8865 /* R10000 extensions. */
8866 { bfd_mach_mips12000
, bfd_mach_mips10000
},
8868 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
8869 vr5400 ISA, but doesn't include the multimedia stuff. It seems
8870 better to allow vr5400 and vr5500 code to be merged anyway, since
8871 many libraries will just use the core ISA. Perhaps we could add
8872 some sort of ASE flag if this ever proves a problem. */
8873 { bfd_mach_mips5500
, bfd_mach_mips5400
},
8874 { bfd_mach_mips5400
, bfd_mach_mips5000
},
8876 /* MIPS IV extensions. */
8877 { bfd_mach_mips5
, bfd_mach_mips8000
},
8878 { bfd_mach_mips10000
, bfd_mach_mips8000
},
8879 { bfd_mach_mips5000
, bfd_mach_mips8000
},
8880 { bfd_mach_mips7000
, bfd_mach_mips8000
},
8882 /* VR4100 extensions. */
8883 { bfd_mach_mips4120
, bfd_mach_mips4100
},
8884 { bfd_mach_mips4111
, bfd_mach_mips4100
},
8886 /* MIPS III extensions. */
8887 { bfd_mach_mips8000
, bfd_mach_mips4000
},
8888 { bfd_mach_mips4650
, bfd_mach_mips4000
},
8889 { bfd_mach_mips4600
, bfd_mach_mips4000
},
8890 { bfd_mach_mips4400
, bfd_mach_mips4000
},
8891 { bfd_mach_mips4300
, bfd_mach_mips4000
},
8892 { bfd_mach_mips4100
, bfd_mach_mips4000
},
8893 { bfd_mach_mips4010
, bfd_mach_mips4000
},
8895 /* MIPS32 extensions. */
8896 { bfd_mach_mipsisa32r2
, bfd_mach_mipsisa32
},
8898 /* MIPS II extensions. */
8899 { bfd_mach_mips4000
, bfd_mach_mips6000
},
8900 { bfd_mach_mipsisa32
, bfd_mach_mips6000
},
8902 /* MIPS I extensions. */
8903 { bfd_mach_mips6000
, bfd_mach_mips3000
},
8904 { bfd_mach_mips3900
, bfd_mach_mips3000
}
8908 /* Return true if bfd machine EXTENSION is an extension of machine BASE. */
8911 mips_mach_extends_p (unsigned long base
, unsigned long extension
)
8915 for (i
= 0; extension
!= base
&& i
< ARRAY_SIZE (mips_mach_extensions
); i
++)
8916 if (extension
== mips_mach_extensions
[i
].extension
)
8917 extension
= mips_mach_extensions
[i
].base
;
8919 return extension
== base
;
8923 /* Return true if the given ELF header flags describe a 32-bit binary. */
8926 mips_32bit_flags_p (flagword flags
)
8928 return ((flags
& EF_MIPS_32BITMODE
) != 0
8929 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
8930 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
8931 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
8932 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
8933 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
8934 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
);
8938 /* Merge backend specific data from an object file to the output
8939 object file when linking. */
8942 _bfd_mips_elf_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
8947 bfd_boolean null_input_bfd
= TRUE
;
8950 /* Check if we have the same endianess */
8951 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
8953 (*_bfd_error_handler
)
8954 (_("%s: endianness incompatible with that of the selected emulation"),
8955 bfd_archive_filename (ibfd
));
8959 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
8960 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
8963 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
8965 (*_bfd_error_handler
)
8966 (_("%s: ABI is incompatible with that of the selected emulation"),
8967 bfd_archive_filename (ibfd
));
8971 new_flags
= elf_elfheader (ibfd
)->e_flags
;
8972 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_NOREORDER
;
8973 old_flags
= elf_elfheader (obfd
)->e_flags
;
8975 if (! elf_flags_init (obfd
))
8977 elf_flags_init (obfd
) = TRUE
;
8978 elf_elfheader (obfd
)->e_flags
= new_flags
;
8979 elf_elfheader (obfd
)->e_ident
[EI_CLASS
]
8980 = elf_elfheader (ibfd
)->e_ident
[EI_CLASS
];
8982 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
8983 && bfd_get_arch_info (obfd
)->the_default
)
8985 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
8986 bfd_get_mach (ibfd
)))
8993 /* Check flag compatibility. */
8995 new_flags
&= ~EF_MIPS_NOREORDER
;
8996 old_flags
&= ~EF_MIPS_NOREORDER
;
8998 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
8999 doesn't seem to matter. */
9000 new_flags
&= ~EF_MIPS_XGOT
;
9001 old_flags
&= ~EF_MIPS_XGOT
;
9003 /* MIPSpro generates ucode info in n64 objects. Again, we should
9004 just be able to ignore this. */
9005 new_flags
&= ~EF_MIPS_UCODE
;
9006 old_flags
&= ~EF_MIPS_UCODE
;
9008 if (new_flags
== old_flags
)
9011 /* Check to see if the input BFD actually contains any sections.
9012 If not, its flags may not have been initialised either, but it cannot
9013 actually cause any incompatibility. */
9014 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
9016 /* Ignore synthetic sections and empty .text, .data and .bss sections
9017 which are automatically generated by gas. */
9018 if (strcmp (sec
->name
, ".reginfo")
9019 && strcmp (sec
->name
, ".mdebug")
9020 && (sec
->_raw_size
!= 0
9021 || (strcmp (sec
->name
, ".text")
9022 && strcmp (sec
->name
, ".data")
9023 && strcmp (sec
->name
, ".bss"))))
9025 null_input_bfd
= FALSE
;
9034 if (((new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0)
9035 != ((old_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0))
9037 (*_bfd_error_handler
)
9038 (_("%s: warning: linking PIC files with non-PIC files"),
9039 bfd_archive_filename (ibfd
));
9043 if (new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
))
9044 elf_elfheader (obfd
)->e_flags
|= EF_MIPS_CPIC
;
9045 if (! (new_flags
& EF_MIPS_PIC
))
9046 elf_elfheader (obfd
)->e_flags
&= ~EF_MIPS_PIC
;
9048 new_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
9049 old_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
9051 /* Compare the ISAs. */
9052 if (mips_32bit_flags_p (old_flags
) != mips_32bit_flags_p (new_flags
))
9054 (*_bfd_error_handler
)
9055 (_("%s: linking 32-bit code with 64-bit code"),
9056 bfd_archive_filename (ibfd
));
9059 else if (!mips_mach_extends_p (bfd_get_mach (ibfd
), bfd_get_mach (obfd
)))
9061 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
9062 if (mips_mach_extends_p (bfd_get_mach (obfd
), bfd_get_mach (ibfd
)))
9064 /* Copy the architecture info from IBFD to OBFD. Also copy
9065 the 32-bit flag (if set) so that we continue to recognise
9066 OBFD as a 32-bit binary. */
9067 bfd_set_arch_info (obfd
, bfd_get_arch_info (ibfd
));
9068 elf_elfheader (obfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
9069 elf_elfheader (obfd
)->e_flags
9070 |= new_flags
& (EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9072 /* Copy across the ABI flags if OBFD doesn't use them
9073 and if that was what caused us to treat IBFD as 32-bit. */
9074 if ((old_flags
& EF_MIPS_ABI
) == 0
9075 && mips_32bit_flags_p (new_flags
)
9076 && !mips_32bit_flags_p (new_flags
& ~EF_MIPS_ABI
))
9077 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ABI
;
9081 /* The ISAs aren't compatible. */
9082 (*_bfd_error_handler
)
9083 (_("%s: linking %s module with previous %s modules"),
9084 bfd_archive_filename (ibfd
),
9085 bfd_printable_name (ibfd
),
9086 bfd_printable_name (obfd
));
9091 new_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9092 old_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
9094 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
9095 does set EI_CLASS differently from any 32-bit ABI. */
9096 if ((new_flags
& EF_MIPS_ABI
) != (old_flags
& EF_MIPS_ABI
)
9097 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
9098 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
9100 /* Only error if both are set (to different values). */
9101 if (((new_flags
& EF_MIPS_ABI
) && (old_flags
& EF_MIPS_ABI
))
9102 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
9103 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
9105 (*_bfd_error_handler
)
9106 (_("%s: ABI mismatch: linking %s module with previous %s modules"),
9107 bfd_archive_filename (ibfd
),
9108 elf_mips_abi_name (ibfd
),
9109 elf_mips_abi_name (obfd
));
9112 new_flags
&= ~EF_MIPS_ABI
;
9113 old_flags
&= ~EF_MIPS_ABI
;
9116 /* For now, allow arbitrary mixing of ASEs (retain the union). */
9117 if ((new_flags
& EF_MIPS_ARCH_ASE
) != (old_flags
& EF_MIPS_ARCH_ASE
))
9119 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ARCH_ASE
;
9121 new_flags
&= ~ EF_MIPS_ARCH_ASE
;
9122 old_flags
&= ~ EF_MIPS_ARCH_ASE
;
9125 /* Warn about any other mismatches */
9126 if (new_flags
!= old_flags
)
9128 (*_bfd_error_handler
)
9129 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
9130 bfd_archive_filename (ibfd
), (unsigned long) new_flags
,
9131 (unsigned long) old_flags
);
9137 bfd_set_error (bfd_error_bad_value
);
9144 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
9147 _bfd_mips_elf_set_private_flags (bfd
*abfd
, flagword flags
)
9149 BFD_ASSERT (!elf_flags_init (abfd
)
9150 || elf_elfheader (abfd
)->e_flags
== flags
);
9152 elf_elfheader (abfd
)->e_flags
= flags
;
9153 elf_flags_init (abfd
) = TRUE
;
9158 _bfd_mips_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
9162 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
9164 /* Print normal ELF private data. */
9165 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
9167 /* xgettext:c-format */
9168 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
9170 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
)
9171 fprintf (file
, _(" [abi=O32]"));
9172 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O64
)
9173 fprintf (file
, _(" [abi=O64]"));
9174 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
)
9175 fprintf (file
, _(" [abi=EABI32]"));
9176 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
9177 fprintf (file
, _(" [abi=EABI64]"));
9178 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
))
9179 fprintf (file
, _(" [abi unknown]"));
9180 else if (ABI_N32_P (abfd
))
9181 fprintf (file
, _(" [abi=N32]"));
9182 else if (ABI_64_P (abfd
))
9183 fprintf (file
, _(" [abi=64]"));
9185 fprintf (file
, _(" [no abi set]"));
9187 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
9188 fprintf (file
, _(" [mips1]"));
9189 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
9190 fprintf (file
, _(" [mips2]"));
9191 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
9192 fprintf (file
, _(" [mips3]"));
9193 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
9194 fprintf (file
, _(" [mips4]"));
9195 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_5
)
9196 fprintf (file
, _(" [mips5]"));
9197 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
)
9198 fprintf (file
, _(" [mips32]"));
9199 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64
)
9200 fprintf (file
, _(" [mips64]"));
9201 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
)
9202 fprintf (file
, _(" [mips32r2]"));
9203 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64R2
)
9204 fprintf (file
, _(" [mips64r2]"));
9206 fprintf (file
, _(" [unknown ISA]"));
9208 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
9209 fprintf (file
, _(" [mdmx]"));
9211 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_M16
)
9212 fprintf (file
, _(" [mips16]"));
9214 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_32BITMODE
)
9215 fprintf (file
, _(" [32bitmode]"));
9217 fprintf (file
, _(" [not 32bitmode]"));
9224 struct bfd_elf_special_section
const _bfd_mips_elf_special_sections
[]=
9226 { ".sdata", 6, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9227 { ".sbss", 5, -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9228 { ".lit4", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9229 { ".lit8", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
9230 { ".ucode", 6, 0, SHT_MIPS_UCODE
, 0 },
9231 { ".mdebug", 7, 0, SHT_MIPS_DEBUG
, 0 },
9232 { NULL
, 0, 0, 0, 0 }