1 /* MIPS-specific support for ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2005, 2006, 2007, 2008 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 3 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., 51 Franklin Street - Fifth Floor, Boston,
27 MA 02110-1301, USA. */
30 /* This file handles functionality common to the different MIPS ABI's. */
35 #include "libiberty.h"
37 #include "elfxx-mips.h"
39 #include "elf-vxworks.h"
41 /* Get the ECOFF swapping routines. */
43 #include "coff/symconst.h"
44 #include "coff/ecoff.h"
45 #include "coff/mips.h"
49 /* This structure is used to hold information about one GOT entry.
50 There are three types of entry:
52 (1) absolute addresses
54 (2) SYMBOL + OFFSET addresses, where SYMBOL is local to an input bfd
55 (abfd != NULL, symndx >= 0)
56 (3) global and forced-local symbols
57 (abfd != NULL, symndx == -1)
59 Type (3) entries are treated differently for different types of GOT.
60 In the "master" GOT -- i.e. the one that describes every GOT
61 reference needed in the link -- the mips_got_entry is keyed on both
62 the symbol and the input bfd that references it. If it turns out
63 that we need multiple GOTs, we can then use this information to
64 create separate GOTs for each input bfd.
66 However, we want each of these separate GOTs to have at most one
67 entry for a given symbol, so their type (3) entries are keyed only
68 on the symbol. The input bfd given by the "abfd" field is somewhat
69 arbitrary in this case.
71 This means that when there are multiple GOTs, each GOT has a unique
72 mips_got_entry for every symbol within it. We can therefore use the
73 mips_got_entry fields (tls_type and gotidx) to track the symbol's
76 However, if it turns out that we need only a single GOT, we continue
77 to use the master GOT to describe it. There may therefore be several
78 mips_got_entries for the same symbol, each with a different input bfd.
79 We want to make sure that each symbol gets a unique GOT entry, so when
80 there's a single GOT, we use the symbol's hash entry, not the
81 mips_got_entry fields, to track a symbol's GOT index. */
84 /* The input bfd in which the symbol is defined. */
86 /* The index of the symbol, as stored in the relocation r_info, if
87 we have a local symbol; -1 otherwise. */
91 /* If abfd == NULL, an address that must be stored in the got. */
93 /* If abfd != NULL && symndx != -1, the addend of the relocation
94 that should be added to the symbol value. */
96 /* If abfd != NULL && symndx == -1, the hash table entry
97 corresponding to a global symbol in the got (or, local, if
99 struct mips_elf_link_hash_entry
*h
;
102 /* The TLS types included in this GOT entry (specifically, GD and
103 IE). The GD and IE flags can be added as we encounter new
104 relocations. LDM can also be set; it will always be alone, not
105 combined with any GD or IE flags. An LDM GOT entry will be
106 a local symbol entry with r_symndx == 0. */
107 unsigned char tls_type
;
109 /* The offset from the beginning of the .got section to the entry
110 corresponding to this symbol+addend. If it's a global symbol
111 whose offset is yet to be decided, it's going to be -1. */
115 /* This structure describes a range of addends: [MIN_ADDEND, MAX_ADDEND].
116 The structures form a non-overlapping list that is sorted by increasing
118 struct mips_got_page_range
120 struct mips_got_page_range
*next
;
121 bfd_signed_vma min_addend
;
122 bfd_signed_vma max_addend
;
125 /* This structure describes the range of addends that are applied to page
126 relocations against a given symbol. */
127 struct mips_got_page_entry
129 /* The input bfd in which the symbol is defined. */
131 /* The index of the symbol, as stored in the relocation r_info. */
133 /* The ranges for this page entry. */
134 struct mips_got_page_range
*ranges
;
135 /* The maximum number of page entries needed for RANGES. */
139 /* This structure is used to hold .got information when linking. */
143 /* The global symbol in the GOT with the lowest index in the dynamic
145 struct elf_link_hash_entry
*global_gotsym
;
146 /* The number of global .got entries. */
147 unsigned int global_gotno
;
148 /* The number of .got slots used for TLS. */
149 unsigned int tls_gotno
;
150 /* The first unused TLS .got entry. Used only during
151 mips_elf_initialize_tls_index. */
152 unsigned int tls_assigned_gotno
;
153 /* The number of local .got entries, eventually including page entries. */
154 unsigned int local_gotno
;
155 /* The maximum number of page entries needed. */
156 unsigned int page_gotno
;
157 /* The number of local .got entries we have used. */
158 unsigned int assigned_gotno
;
159 /* A hash table holding members of the got. */
160 struct htab
*got_entries
;
161 /* A hash table of mips_got_page_entry structures. */
162 struct htab
*got_page_entries
;
163 /* A hash table mapping input bfds to other mips_got_info. NULL
164 unless multi-got was necessary. */
165 struct htab
*bfd2got
;
166 /* In multi-got links, a pointer to the next got (err, rather, most
167 of the time, it points to the previous got). */
168 struct mips_got_info
*next
;
169 /* This is the GOT index of the TLS LDM entry for the GOT, MINUS_ONE
170 for none, or MINUS_TWO for not yet assigned. This is needed
171 because a single-GOT link may have multiple hash table entries
172 for the LDM. It does not get initialized in multi-GOT mode. */
173 bfd_vma tls_ldm_offset
;
176 /* Map an input bfd to a got in a multi-got link. */
178 struct mips_elf_bfd2got_hash
{
180 struct mips_got_info
*g
;
183 /* Structure passed when traversing the bfd2got hash table, used to
184 create and merge bfd's gots. */
186 struct mips_elf_got_per_bfd_arg
188 /* A hashtable that maps bfds to gots. */
190 /* The output bfd. */
192 /* The link information. */
193 struct bfd_link_info
*info
;
194 /* A pointer to the primary got, i.e., the one that's going to get
195 the implicit relocations from DT_MIPS_LOCAL_GOTNO and
197 struct mips_got_info
*primary
;
198 /* A non-primary got we're trying to merge with other input bfd's
200 struct mips_got_info
*current
;
201 /* The maximum number of got entries that can be addressed with a
203 unsigned int max_count
;
204 /* The maximum number of page entries needed by each got. */
205 unsigned int max_pages
;
206 /* The total number of global entries which will live in the
207 primary got and be automatically relocated. This includes
208 those not referenced by the primary GOT but included in
210 unsigned int global_count
;
213 /* Another structure used to pass arguments for got entries traversal. */
215 struct mips_elf_set_global_got_offset_arg
217 struct mips_got_info
*g
;
219 unsigned int needed_relocs
;
220 struct bfd_link_info
*info
;
223 /* A structure used to count TLS relocations or GOT entries, for GOT
224 entry or ELF symbol table traversal. */
226 struct mips_elf_count_tls_arg
228 struct bfd_link_info
*info
;
232 struct _mips_elf_section_data
234 struct bfd_elf_section_data elf
;
237 struct mips_got_info
*got_info
;
242 #define mips_elf_section_data(sec) \
243 ((struct _mips_elf_section_data *) elf_section_data (sec))
245 /* This structure is passed to mips_elf_sort_hash_table_f when sorting
246 the dynamic symbols. */
248 struct mips_elf_hash_sort_data
250 /* The symbol in the global GOT with the lowest dynamic symbol table
252 struct elf_link_hash_entry
*low
;
253 /* The least dynamic symbol table index corresponding to a non-TLS
254 symbol with a GOT entry. */
255 long min_got_dynindx
;
256 /* The greatest dynamic symbol table index corresponding to a symbol
257 with a GOT entry that is not referenced (e.g., a dynamic symbol
258 with dynamic relocations pointing to it from non-primary GOTs). */
259 long max_unref_got_dynindx
;
260 /* The greatest dynamic symbol table index not corresponding to a
261 symbol without a GOT entry. */
262 long max_non_got_dynindx
;
265 /* The MIPS ELF linker needs additional information for each symbol in
266 the global hash table. */
268 struct mips_elf_link_hash_entry
270 struct elf_link_hash_entry root
;
272 /* External symbol information. */
275 /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
277 unsigned int possibly_dynamic_relocs
;
279 /* If the R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 reloc is against
280 a readonly section. */
281 bfd_boolean readonly_reloc
;
283 /* We must not create a stub for a symbol that has relocations
284 related to taking the function's address, i.e. any but
285 R_MIPS_CALL*16 ones -- see "MIPS ABI Supplement, 3rd Edition",
287 bfd_boolean no_fn_stub
;
289 /* If there is a stub that 32 bit functions should use to call this
290 16 bit function, this points to the section containing the stub. */
293 /* Whether we need the fn_stub; this is set if this symbol appears
294 in any relocs other than a 16 bit call. */
295 bfd_boolean need_fn_stub
;
297 /* If there is a stub that 16 bit functions should use to call this
298 32 bit function, this points to the section containing the stub. */
301 /* This is like the call_stub field, but it is used if the function
302 being called returns a floating point value. */
303 asection
*call_fp_stub
;
305 /* Are we forced local? This will only be set if we have converted
306 the initial global GOT entry to a local GOT entry. */
307 bfd_boolean forced_local
;
309 /* Are we referenced by some kind of relocation? */
310 bfd_boolean is_relocation_target
;
312 /* Are we referenced by branch relocations? */
313 bfd_boolean is_branch_target
;
317 #define GOT_TLS_LDM 2
319 #define GOT_TLS_OFFSET_DONE 0x40
320 #define GOT_TLS_DONE 0x80
321 unsigned char tls_type
;
322 /* This is only used in single-GOT mode; in multi-GOT mode there
323 is one mips_got_entry per GOT entry, so the offset is stored
324 there. In single-GOT mode there may be many mips_got_entry
325 structures all referring to the same GOT slot. It might be
326 possible to use root.got.offset instead, but that field is
327 overloaded already. */
328 bfd_vma tls_got_offset
;
331 /* MIPS ELF linker hash table. */
333 struct mips_elf_link_hash_table
335 struct elf_link_hash_table root
;
337 /* We no longer use this. */
338 /* String section indices for the dynamic section symbols. */
339 bfd_size_type dynsym_sec_strindex
[SIZEOF_MIPS_DYNSYM_SECNAMES
];
341 /* The number of .rtproc entries. */
342 bfd_size_type procedure_count
;
343 /* The size of the .compact_rel section (if SGI_COMPAT). */
344 bfd_size_type compact_rel_size
;
345 /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic
346 entry is set to the address of __rld_obj_head as in IRIX5. */
347 bfd_boolean use_rld_obj_head
;
348 /* This is the value of the __rld_map or __rld_obj_head symbol. */
350 /* This is set if we see any mips16 stub sections. */
351 bfd_boolean mips16_stubs_seen
;
352 /* True if we've computed the size of the GOT. */
353 bfd_boolean computed_got_sizes
;
354 /* True if we're generating code for VxWorks. */
355 bfd_boolean is_vxworks
;
356 /* True if we already reported the small-data section overflow. */
357 bfd_boolean small_data_overflow_reported
;
358 /* Shortcuts to some dynamic sections, or NULL if they are not
366 /* The size of the PLT header in bytes (VxWorks only). */
367 bfd_vma plt_header_size
;
368 /* The size of a PLT entry in bytes (VxWorks only). */
369 bfd_vma plt_entry_size
;
370 /* The size of a function stub entry in bytes. */
371 bfd_vma function_stub_size
;
374 #define TLS_RELOC_P(r_type) \
375 (r_type == R_MIPS_TLS_DTPMOD32 \
376 || r_type == R_MIPS_TLS_DTPMOD64 \
377 || r_type == R_MIPS_TLS_DTPREL32 \
378 || r_type == R_MIPS_TLS_DTPREL64 \
379 || r_type == R_MIPS_TLS_GD \
380 || r_type == R_MIPS_TLS_LDM \
381 || r_type == R_MIPS_TLS_DTPREL_HI16 \
382 || r_type == R_MIPS_TLS_DTPREL_LO16 \
383 || r_type == R_MIPS_TLS_GOTTPREL \
384 || r_type == R_MIPS_TLS_TPREL32 \
385 || r_type == R_MIPS_TLS_TPREL64 \
386 || r_type == R_MIPS_TLS_TPREL_HI16 \
387 || r_type == R_MIPS_TLS_TPREL_LO16)
389 /* Structure used to pass information to mips_elf_output_extsym. */
394 struct bfd_link_info
*info
;
395 struct ecoff_debug_info
*debug
;
396 const struct ecoff_debug_swap
*swap
;
400 /* The names of the runtime procedure table symbols used on IRIX5. */
402 static const char * const mips_elf_dynsym_rtproc_names
[] =
405 "_procedure_string_table",
406 "_procedure_table_size",
410 /* These structures are used to generate the .compact_rel section on
415 unsigned long id1
; /* Always one? */
416 unsigned long num
; /* Number of compact relocation entries. */
417 unsigned long id2
; /* Always two? */
418 unsigned long offset
; /* The file offset of the first relocation. */
419 unsigned long reserved0
; /* Zero? */
420 unsigned long reserved1
; /* Zero? */
429 bfd_byte reserved0
[4];
430 bfd_byte reserved1
[4];
431 } Elf32_External_compact_rel
;
435 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
436 unsigned int rtype
: 4; /* Relocation types. See below. */
437 unsigned int dist2to
: 8;
438 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
439 unsigned long konst
; /* KONST field. See below. */
440 unsigned long vaddr
; /* VADDR to be relocated. */
445 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
446 unsigned int rtype
: 4; /* Relocation types. See below. */
447 unsigned int dist2to
: 8;
448 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
449 unsigned long konst
; /* KONST field. See below. */
457 } Elf32_External_crinfo
;
463 } Elf32_External_crinfo2
;
465 /* These are the constants used to swap the bitfields in a crinfo. */
467 #define CRINFO_CTYPE (0x1)
468 #define CRINFO_CTYPE_SH (31)
469 #define CRINFO_RTYPE (0xf)
470 #define CRINFO_RTYPE_SH (27)
471 #define CRINFO_DIST2TO (0xff)
472 #define CRINFO_DIST2TO_SH (19)
473 #define CRINFO_RELVADDR (0x7ffff)
474 #define CRINFO_RELVADDR_SH (0)
476 /* A compact relocation info has long (3 words) or short (2 words)
477 formats. A short format doesn't have VADDR field and relvaddr
478 fields contains ((VADDR - vaddr of the previous entry) >> 2). */
479 #define CRF_MIPS_LONG 1
480 #define CRF_MIPS_SHORT 0
482 /* There are 4 types of compact relocation at least. The value KONST
483 has different meaning for each type:
486 CT_MIPS_REL32 Address in data
487 CT_MIPS_WORD Address in word (XXX)
488 CT_MIPS_GPHI_LO GP - vaddr
489 CT_MIPS_JMPAD Address to jump
492 #define CRT_MIPS_REL32 0xa
493 #define CRT_MIPS_WORD 0xb
494 #define CRT_MIPS_GPHI_LO 0xc
495 #define CRT_MIPS_JMPAD 0xd
497 #define mips_elf_set_cr_format(x,format) ((x).ctype = (format))
498 #define mips_elf_set_cr_type(x,type) ((x).rtype = (type))
499 #define mips_elf_set_cr_dist2to(x,v) ((x).dist2to = (v))
500 #define mips_elf_set_cr_relvaddr(x,d) ((x).relvaddr = (d)<<2)
502 /* The structure of the runtime procedure descriptor created by the
503 loader for use by the static exception system. */
505 typedef struct runtime_pdr
{
506 bfd_vma adr
; /* Memory address of start of procedure. */
507 long regmask
; /* Save register mask. */
508 long regoffset
; /* Save register offset. */
509 long fregmask
; /* Save floating point register mask. */
510 long fregoffset
; /* Save floating point register offset. */
511 long frameoffset
; /* Frame size. */
512 short framereg
; /* Frame pointer register. */
513 short pcreg
; /* Offset or reg of return pc. */
514 long irpss
; /* Index into the runtime string table. */
516 struct exception_info
*exception_info
;/* Pointer to exception array. */
518 #define cbRPDR sizeof (RPDR)
519 #define rpdNil ((pRPDR) 0)
521 static struct mips_got_entry
*mips_elf_create_local_got_entry
522 (bfd
*, struct bfd_link_info
*, bfd
*, struct mips_got_info
*, asection
*,
523 bfd_vma
, unsigned long, struct mips_elf_link_hash_entry
*, int);
524 static bfd_boolean mips_elf_sort_hash_table_f
525 (struct mips_elf_link_hash_entry
*, void *);
526 static bfd_vma mips_elf_high
528 static bfd_boolean mips16_stub_section_p
530 static bfd_boolean mips_elf_create_dynamic_relocation
531 (bfd
*, struct bfd_link_info
*, const Elf_Internal_Rela
*,
532 struct mips_elf_link_hash_entry
*, asection
*, bfd_vma
,
533 bfd_vma
*, asection
*);
534 static hashval_t mips_elf_got_entry_hash
536 static bfd_vma mips_elf_adjust_gp
537 (bfd
*, struct mips_got_info
*, bfd
*);
538 static struct mips_got_info
*mips_elf_got_for_ibfd
539 (struct mips_got_info
*, bfd
*);
541 /* This will be used when we sort the dynamic relocation records. */
542 static bfd
*reldyn_sorting_bfd
;
544 /* Nonzero if ABFD is using the N32 ABI. */
545 #define ABI_N32_P(abfd) \
546 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
548 /* Nonzero if ABFD is using the N64 ABI. */
549 #define ABI_64_P(abfd) \
550 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
552 /* Nonzero if ABFD is using NewABI conventions. */
553 #define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
555 /* The IRIX compatibility level we are striving for. */
556 #define IRIX_COMPAT(abfd) \
557 (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
559 /* Whether we are trying to be compatible with IRIX at all. */
560 #define SGI_COMPAT(abfd) \
561 (IRIX_COMPAT (abfd) != ict_none)
563 /* The name of the options section. */
564 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
565 (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
567 /* True if NAME is the recognized name of any SHT_MIPS_OPTIONS section.
568 Some IRIX system files do not use MIPS_ELF_OPTIONS_SECTION_NAME. */
569 #define MIPS_ELF_OPTIONS_SECTION_NAME_P(NAME) \
570 (strcmp (NAME, ".MIPS.options") == 0 || strcmp (NAME, ".options") == 0)
572 /* Whether the section is readonly. */
573 #define MIPS_ELF_READONLY_SECTION(sec) \
574 ((sec->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY)) \
575 == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
577 /* The name of the stub section. */
578 #define MIPS_ELF_STUB_SECTION_NAME(abfd) ".MIPS.stubs"
580 /* The size of an external REL relocation. */
581 #define MIPS_ELF_REL_SIZE(abfd) \
582 (get_elf_backend_data (abfd)->s->sizeof_rel)
584 /* The size of an external RELA relocation. */
585 #define MIPS_ELF_RELA_SIZE(abfd) \
586 (get_elf_backend_data (abfd)->s->sizeof_rela)
588 /* The size of an external dynamic table entry. */
589 #define MIPS_ELF_DYN_SIZE(abfd) \
590 (get_elf_backend_data (abfd)->s->sizeof_dyn)
592 /* The size of a GOT entry. */
593 #define MIPS_ELF_GOT_SIZE(abfd) \
594 (get_elf_backend_data (abfd)->s->arch_size / 8)
596 /* The size of a symbol-table entry. */
597 #define MIPS_ELF_SYM_SIZE(abfd) \
598 (get_elf_backend_data (abfd)->s->sizeof_sym)
600 /* The default alignment for sections, as a power of two. */
601 #define MIPS_ELF_LOG_FILE_ALIGN(abfd) \
602 (get_elf_backend_data (abfd)->s->log_file_align)
604 /* Get word-sized data. */
605 #define MIPS_ELF_GET_WORD(abfd, ptr) \
606 (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
608 /* Put out word-sized data. */
609 #define MIPS_ELF_PUT_WORD(abfd, val, ptr) \
611 ? bfd_put_64 (abfd, val, ptr) \
612 : bfd_put_32 (abfd, val, ptr))
614 /* Add a dynamic symbol table-entry. */
615 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
616 _bfd_elf_add_dynamic_entry (info, tag, val)
618 #define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela) \
619 (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela))
621 /* Determine whether the internal relocation of index REL_IDX is REL
622 (zero) or RELA (non-zero). The assumption is that, if there are
623 two relocation sections for this section, one of them is REL and
624 the other is RELA. If the index of the relocation we're testing is
625 in range for the first relocation section, check that the external
626 relocation size is that for RELA. It is also assumed that, if
627 rel_idx is not in range for the first section, and this first
628 section contains REL relocs, then the relocation is in the second
629 section, that is RELA. */
630 #define MIPS_RELOC_RELA_P(abfd, sec, rel_idx) \
631 ((NUM_SHDR_ENTRIES (&elf_section_data (sec)->rel_hdr) \
632 * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel \
633 > (bfd_vma)(rel_idx)) \
634 == (elf_section_data (sec)->rel_hdr.sh_entsize \
635 == (ABI_64_P (abfd) ? sizeof (Elf64_External_Rela) \
636 : sizeof (Elf32_External_Rela))))
638 /* The name of the dynamic relocation section. */
639 #define MIPS_ELF_REL_DYN_NAME(INFO) \
640 (mips_elf_hash_table (INFO)->is_vxworks ? ".rela.dyn" : ".rel.dyn")
642 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
643 from smaller values. Start with zero, widen, *then* decrement. */
644 #define MINUS_ONE (((bfd_vma)0) - 1)
645 #define MINUS_TWO (((bfd_vma)0) - 2)
647 /* The number of local .got entries we reserve. */
648 #define MIPS_RESERVED_GOTNO(INFO) \
649 (mips_elf_hash_table (INFO)->is_vxworks ? 3 : 2)
651 /* The value to write into got[1] for SVR4 targets, to identify it is
652 a GNU object. The dynamic linker can then use got[1] to store the
654 #define MIPS_ELF_GNU_GOT1_MASK(abfd) \
655 ((bfd_vma) 1 << (ABI_64_P (abfd) ? 63 : 31))
657 /* The offset of $gp from the beginning of the .got section. */
658 #define ELF_MIPS_GP_OFFSET(INFO) \
659 (mips_elf_hash_table (INFO)->is_vxworks ? 0x0 : 0x7ff0)
661 /* The maximum size of the GOT for it to be addressable using 16-bit
663 #define MIPS_ELF_GOT_MAX_SIZE(INFO) (ELF_MIPS_GP_OFFSET (INFO) + 0x7fff)
665 /* Instructions which appear in a stub. */
666 #define STUB_LW(abfd) \
668 ? 0xdf998010 /* ld t9,0x8010(gp) */ \
669 : 0x8f998010)) /* lw t9,0x8010(gp) */
670 #define STUB_MOVE(abfd) \
672 ? 0x03e0782d /* daddu t7,ra */ \
673 : 0x03e07821)) /* addu t7,ra */
674 #define STUB_LUI(VAL) (0x3c180000 + (VAL)) /* lui t8,VAL */
675 #define STUB_JALR 0x0320f809 /* jalr t9,ra */
676 #define STUB_ORI(VAL) (0x37180000 + (VAL)) /* ori t8,t8,VAL */
677 #define STUB_LI16U(VAL) (0x34180000 + (VAL)) /* ori t8,zero,VAL unsigned */
678 #define STUB_LI16S(abfd, VAL) \
680 ? (0x64180000 + (VAL)) /* daddiu t8,zero,VAL sign extended */ \
681 : (0x24180000 + (VAL)))) /* addiu t8,zero,VAL sign extended */
683 #define MIPS_FUNCTION_STUB_NORMAL_SIZE 16
684 #define MIPS_FUNCTION_STUB_BIG_SIZE 20
686 /* The name of the dynamic interpreter. This is put in the .interp
689 #define ELF_DYNAMIC_INTERPRETER(abfd) \
690 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
691 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
692 : "/usr/lib/libc.so.1")
695 #define MNAME(bfd,pre,pos) \
696 (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
697 #define ELF_R_SYM(bfd, i) \
698 (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
699 #define ELF_R_TYPE(bfd, i) \
700 (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
701 #define ELF_R_INFO(bfd, s, t) \
702 (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
704 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
705 #define ELF_R_SYM(bfd, i) \
707 #define ELF_R_TYPE(bfd, i) \
709 #define ELF_R_INFO(bfd, s, t) \
710 (ELF32_R_INFO (s, t))
713 /* The mips16 compiler uses a couple of special sections to handle
714 floating point arguments.
716 Section names that look like .mips16.fn.FNNAME contain stubs that
717 copy floating point arguments from the fp regs to the gp regs and
718 then jump to FNNAME. If any 32 bit function calls FNNAME, the
719 call should be redirected to the stub instead. If no 32 bit
720 function calls FNNAME, the stub should be discarded. We need to
721 consider any reference to the function, not just a call, because
722 if the address of the function is taken we will need the stub,
723 since the address might be passed to a 32 bit function.
725 Section names that look like .mips16.call.FNNAME contain stubs
726 that copy floating point arguments from the gp regs to the fp
727 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
728 then any 16 bit function that calls FNNAME should be redirected
729 to the stub instead. If FNNAME is not a 32 bit function, the
730 stub should be discarded.
732 .mips16.call.fp.FNNAME sections are similar, but contain stubs
733 which call FNNAME and then copy the return value from the fp regs
734 to the gp regs. These stubs store the return value in $18 while
735 calling FNNAME; any function which might call one of these stubs
736 must arrange to save $18 around the call. (This case is not
737 needed for 32 bit functions that call 16 bit functions, because
738 16 bit functions always return floating point values in both
741 Note that in all cases FNNAME might be defined statically.
742 Therefore, FNNAME is not used literally. Instead, the relocation
743 information will indicate which symbol the section is for.
745 We record any stubs that we find in the symbol table. */
747 #define FN_STUB ".mips16.fn."
748 #define CALL_STUB ".mips16.call."
749 #define CALL_FP_STUB ".mips16.call.fp."
751 #define FN_STUB_P(name) CONST_STRNEQ (name, FN_STUB)
752 #define CALL_STUB_P(name) CONST_STRNEQ (name, CALL_STUB)
753 #define CALL_FP_STUB_P(name) CONST_STRNEQ (name, CALL_FP_STUB)
755 /* The format of the first PLT entry in a VxWorks executable. */
756 static const bfd_vma mips_vxworks_exec_plt0_entry
[] = {
757 0x3c190000, /* lui t9, %hi(_GLOBAL_OFFSET_TABLE_) */
758 0x27390000, /* addiu t9, t9, %lo(_GLOBAL_OFFSET_TABLE_) */
759 0x8f390008, /* lw t9, 8(t9) */
760 0x00000000, /* nop */
761 0x03200008, /* jr t9 */
765 /* The format of subsequent PLT entries. */
766 static const bfd_vma mips_vxworks_exec_plt_entry
[] = {
767 0x10000000, /* b .PLT_resolver */
768 0x24180000, /* li t8, <pltindex> */
769 0x3c190000, /* lui t9, %hi(<.got.plt slot>) */
770 0x27390000, /* addiu t9, t9, %lo(<.got.plt slot>) */
771 0x8f390000, /* lw t9, 0(t9) */
772 0x00000000, /* nop */
773 0x03200008, /* jr t9 */
777 /* The format of the first PLT entry in a VxWorks shared object. */
778 static const bfd_vma mips_vxworks_shared_plt0_entry
[] = {
779 0x8f990008, /* lw t9, 8(gp) */
780 0x00000000, /* nop */
781 0x03200008, /* jr t9 */
782 0x00000000, /* nop */
783 0x00000000, /* nop */
787 /* The format of subsequent PLT entries. */
788 static const bfd_vma mips_vxworks_shared_plt_entry
[] = {
789 0x10000000, /* b .PLT_resolver */
790 0x24180000 /* li t8, <pltindex> */
793 /* Look up an entry in a MIPS ELF linker hash table. */
795 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
796 ((struct mips_elf_link_hash_entry *) \
797 elf_link_hash_lookup (&(table)->root, (string), (create), \
800 /* Traverse a MIPS ELF linker hash table. */
802 #define mips_elf_link_hash_traverse(table, func, info) \
803 (elf_link_hash_traverse \
805 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
808 /* Get the MIPS ELF linker hash table from a link_info structure. */
810 #define mips_elf_hash_table(p) \
811 ((struct mips_elf_link_hash_table *) ((p)->hash))
813 /* Find the base offsets for thread-local storage in this object,
814 for GD/LD and IE/LE respectively. */
816 #define TP_OFFSET 0x7000
817 #define DTP_OFFSET 0x8000
820 dtprel_base (struct bfd_link_info
*info
)
822 /* If tls_sec is NULL, we should have signalled an error already. */
823 if (elf_hash_table (info
)->tls_sec
== NULL
)
825 return elf_hash_table (info
)->tls_sec
->vma
+ DTP_OFFSET
;
829 tprel_base (struct bfd_link_info
*info
)
831 /* If tls_sec is NULL, we should have signalled an error already. */
832 if (elf_hash_table (info
)->tls_sec
== NULL
)
834 return elf_hash_table (info
)->tls_sec
->vma
+ TP_OFFSET
;
837 /* Create an entry in a MIPS ELF linker hash table. */
839 static struct bfd_hash_entry
*
840 mips_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
841 struct bfd_hash_table
*table
, const char *string
)
843 struct mips_elf_link_hash_entry
*ret
=
844 (struct mips_elf_link_hash_entry
*) entry
;
846 /* Allocate the structure if it has not already been allocated by a
849 ret
= bfd_hash_allocate (table
, sizeof (struct mips_elf_link_hash_entry
));
851 return (struct bfd_hash_entry
*) ret
;
853 /* Call the allocation method of the superclass. */
854 ret
= ((struct mips_elf_link_hash_entry
*)
855 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
859 /* Set local fields. */
860 memset (&ret
->esym
, 0, sizeof (EXTR
));
861 /* We use -2 as a marker to indicate that the information has
862 not been set. -1 means there is no associated ifd. */
864 ret
->possibly_dynamic_relocs
= 0;
865 ret
->readonly_reloc
= FALSE
;
866 ret
->no_fn_stub
= FALSE
;
868 ret
->need_fn_stub
= FALSE
;
869 ret
->call_stub
= NULL
;
870 ret
->call_fp_stub
= NULL
;
871 ret
->forced_local
= FALSE
;
872 ret
->is_branch_target
= FALSE
;
873 ret
->is_relocation_target
= FALSE
;
874 ret
->tls_type
= GOT_NORMAL
;
877 return (struct bfd_hash_entry
*) ret
;
881 _bfd_mips_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
883 if (!sec
->used_by_bfd
)
885 struct _mips_elf_section_data
*sdata
;
886 bfd_size_type amt
= sizeof (*sdata
);
888 sdata
= bfd_zalloc (abfd
, amt
);
891 sec
->used_by_bfd
= sdata
;
894 return _bfd_elf_new_section_hook (abfd
, sec
);
897 /* Read ECOFF debugging information from a .mdebug section into a
898 ecoff_debug_info structure. */
901 _bfd_mips_elf_read_ecoff_info (bfd
*abfd
, asection
*section
,
902 struct ecoff_debug_info
*debug
)
905 const struct ecoff_debug_swap
*swap
;
908 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
909 memset (debug
, 0, sizeof (*debug
));
911 ext_hdr
= bfd_malloc (swap
->external_hdr_size
);
912 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
915 if (! bfd_get_section_contents (abfd
, section
, ext_hdr
, 0,
916 swap
->external_hdr_size
))
919 symhdr
= &debug
->symbolic_header
;
920 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
922 /* The symbolic header contains absolute file offsets and sizes to
924 #define READ(ptr, offset, count, size, type) \
925 if (symhdr->count == 0) \
929 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
930 debug->ptr = bfd_malloc (amt); \
931 if (debug->ptr == NULL) \
933 if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0 \
934 || bfd_bread (debug->ptr, amt, abfd) != amt) \
938 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
939 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, void *);
940 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, void *);
941 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, void *);
942 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, void *);
943 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
945 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
946 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
947 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, void *);
948 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, void *);
949 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, void *);
959 if (debug
->line
!= NULL
)
961 if (debug
->external_dnr
!= NULL
)
962 free (debug
->external_dnr
);
963 if (debug
->external_pdr
!= NULL
)
964 free (debug
->external_pdr
);
965 if (debug
->external_sym
!= NULL
)
966 free (debug
->external_sym
);
967 if (debug
->external_opt
!= NULL
)
968 free (debug
->external_opt
);
969 if (debug
->external_aux
!= NULL
)
970 free (debug
->external_aux
);
971 if (debug
->ss
!= NULL
)
973 if (debug
->ssext
!= NULL
)
975 if (debug
->external_fdr
!= NULL
)
976 free (debug
->external_fdr
);
977 if (debug
->external_rfd
!= NULL
)
978 free (debug
->external_rfd
);
979 if (debug
->external_ext
!= NULL
)
980 free (debug
->external_ext
);
984 /* Swap RPDR (runtime procedure table entry) for output. */
987 ecoff_swap_rpdr_out (bfd
*abfd
, const RPDR
*in
, struct rpdr_ext
*ex
)
989 H_PUT_S32 (abfd
, in
->adr
, ex
->p_adr
);
990 H_PUT_32 (abfd
, in
->regmask
, ex
->p_regmask
);
991 H_PUT_32 (abfd
, in
->regoffset
, ex
->p_regoffset
);
992 H_PUT_32 (abfd
, in
->fregmask
, ex
->p_fregmask
);
993 H_PUT_32 (abfd
, in
->fregoffset
, ex
->p_fregoffset
);
994 H_PUT_32 (abfd
, in
->frameoffset
, ex
->p_frameoffset
);
996 H_PUT_16 (abfd
, in
->framereg
, ex
->p_framereg
);
997 H_PUT_16 (abfd
, in
->pcreg
, ex
->p_pcreg
);
999 H_PUT_32 (abfd
, in
->irpss
, ex
->p_irpss
);
1002 /* Create a runtime procedure table from the .mdebug section. */
1005 mips_elf_create_procedure_table (void *handle
, bfd
*abfd
,
1006 struct bfd_link_info
*info
, asection
*s
,
1007 struct ecoff_debug_info
*debug
)
1009 const struct ecoff_debug_swap
*swap
;
1010 HDRR
*hdr
= &debug
->symbolic_header
;
1012 struct rpdr_ext
*erp
;
1014 struct pdr_ext
*epdr
;
1015 struct sym_ext
*esym
;
1019 bfd_size_type count
;
1020 unsigned long sindex
;
1024 const char *no_name_func
= _("static procedure (no name)");
1032 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
1034 sindex
= strlen (no_name_func
) + 1;
1035 count
= hdr
->ipdMax
;
1038 size
= swap
->external_pdr_size
;
1040 epdr
= bfd_malloc (size
* count
);
1044 if (! _bfd_ecoff_get_accumulated_pdr (handle
, (bfd_byte
*) epdr
))
1047 size
= sizeof (RPDR
);
1048 rp
= rpdr
= bfd_malloc (size
* count
);
1052 size
= sizeof (char *);
1053 sv
= bfd_malloc (size
* count
);
1057 count
= hdr
->isymMax
;
1058 size
= swap
->external_sym_size
;
1059 esym
= bfd_malloc (size
* count
);
1063 if (! _bfd_ecoff_get_accumulated_sym (handle
, (bfd_byte
*) esym
))
1066 count
= hdr
->issMax
;
1067 ss
= bfd_malloc (count
);
1070 if (! _bfd_ecoff_get_accumulated_ss (handle
, (bfd_byte
*) ss
))
1073 count
= hdr
->ipdMax
;
1074 for (i
= 0; i
< (unsigned long) count
; i
++, rp
++)
1076 (*swap
->swap_pdr_in
) (abfd
, epdr
+ i
, &pdr
);
1077 (*swap
->swap_sym_in
) (abfd
, &esym
[pdr
.isym
], &sym
);
1078 rp
->adr
= sym
.value
;
1079 rp
->regmask
= pdr
.regmask
;
1080 rp
->regoffset
= pdr
.regoffset
;
1081 rp
->fregmask
= pdr
.fregmask
;
1082 rp
->fregoffset
= pdr
.fregoffset
;
1083 rp
->frameoffset
= pdr
.frameoffset
;
1084 rp
->framereg
= pdr
.framereg
;
1085 rp
->pcreg
= pdr
.pcreg
;
1087 sv
[i
] = ss
+ sym
.iss
;
1088 sindex
+= strlen (sv
[i
]) + 1;
1092 size
= sizeof (struct rpdr_ext
) * (count
+ 2) + sindex
;
1093 size
= BFD_ALIGN (size
, 16);
1094 rtproc
= bfd_alloc (abfd
, size
);
1097 mips_elf_hash_table (info
)->procedure_count
= 0;
1101 mips_elf_hash_table (info
)->procedure_count
= count
+ 2;
1104 memset (erp
, 0, sizeof (struct rpdr_ext
));
1106 str
= (char *) rtproc
+ sizeof (struct rpdr_ext
) * (count
+ 2);
1107 strcpy (str
, no_name_func
);
1108 str
+= strlen (no_name_func
) + 1;
1109 for (i
= 0; i
< count
; i
++)
1111 ecoff_swap_rpdr_out (abfd
, rpdr
+ i
, erp
+ i
);
1112 strcpy (str
, sv
[i
]);
1113 str
+= strlen (sv
[i
]) + 1;
1115 H_PUT_S32 (abfd
, -1, (erp
+ count
)->p_adr
);
1117 /* Set the size and contents of .rtproc section. */
1119 s
->contents
= rtproc
;
1121 /* Skip this section later on (I don't think this currently
1122 matters, but someday it might). */
1123 s
->map_head
.link_order
= NULL
;
1152 /* Check the mips16 stubs for a particular symbol, and see if we can
1156 mips_elf_check_mips16_stubs (struct mips_elf_link_hash_entry
*h
,
1157 void *data ATTRIBUTE_UNUSED
)
1159 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1160 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1162 if (h
->fn_stub
!= NULL
1163 && ! h
->need_fn_stub
)
1165 /* We don't need the fn_stub; the only references to this symbol
1166 are 16 bit calls. Clobber the size to 0 to prevent it from
1167 being included in the link. */
1168 h
->fn_stub
->size
= 0;
1169 h
->fn_stub
->flags
&= ~SEC_RELOC
;
1170 h
->fn_stub
->reloc_count
= 0;
1171 h
->fn_stub
->flags
|= SEC_EXCLUDE
;
1174 if (h
->call_stub
!= NULL
1175 && ELF_ST_IS_MIPS16 (h
->root
.other
))
1177 /* We don't need the call_stub; this is a 16 bit function, so
1178 calls from other 16 bit functions are OK. Clobber the size
1179 to 0 to prevent it from being included in the link. */
1180 h
->call_stub
->size
= 0;
1181 h
->call_stub
->flags
&= ~SEC_RELOC
;
1182 h
->call_stub
->reloc_count
= 0;
1183 h
->call_stub
->flags
|= SEC_EXCLUDE
;
1186 if (h
->call_fp_stub
!= NULL
1187 && ELF_ST_IS_MIPS16 (h
->root
.other
))
1189 /* We don't need the call_stub; this is a 16 bit function, so
1190 calls from other 16 bit functions are OK. Clobber the size
1191 to 0 to prevent it from being included in the link. */
1192 h
->call_fp_stub
->size
= 0;
1193 h
->call_fp_stub
->flags
&= ~SEC_RELOC
;
1194 h
->call_fp_stub
->reloc_count
= 0;
1195 h
->call_fp_stub
->flags
|= SEC_EXCLUDE
;
1201 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
1202 Most mips16 instructions are 16 bits, but these instructions
1205 The format of these instructions is:
1207 +--------------+--------------------------------+
1208 | JALX | X| Imm 20:16 | Imm 25:21 |
1209 +--------------+--------------------------------+
1211 +-----------------------------------------------+
1213 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
1214 Note that the immediate value in the first word is swapped.
1216 When producing a relocatable object file, R_MIPS16_26 is
1217 handled mostly like R_MIPS_26. In particular, the addend is
1218 stored as a straight 26-bit value in a 32-bit instruction.
1219 (gas makes life simpler for itself by never adjusting a
1220 R_MIPS16_26 reloc to be against a section, so the addend is
1221 always zero). However, the 32 bit instruction is stored as 2
1222 16-bit values, rather than a single 32-bit value. In a
1223 big-endian file, the result is the same; in a little-endian
1224 file, the two 16-bit halves of the 32 bit value are swapped.
1225 This is so that a disassembler can recognize the jal
1228 When doing a final link, R_MIPS16_26 is treated as a 32 bit
1229 instruction stored as two 16-bit values. The addend A is the
1230 contents of the targ26 field. The calculation is the same as
1231 R_MIPS_26. When storing the calculated value, reorder the
1232 immediate value as shown above, and don't forget to store the
1233 value as two 16-bit values.
1235 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
1239 +--------+----------------------+
1243 +--------+----------------------+
1246 +----------+------+-------------+
1250 +----------+--------------------+
1251 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
1252 ((sub1 << 16) | sub2)).
1254 When producing a relocatable object file, the calculation is
1255 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1256 When producing a fully linked file, the calculation is
1257 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1258 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)
1260 R_MIPS16_GPREL is used for GP-relative addressing in mips16
1261 mode. A typical instruction will have a format like this:
1263 +--------------+--------------------------------+
1264 | EXTEND | Imm 10:5 | Imm 15:11 |
1265 +--------------+--------------------------------+
1266 | Major | rx | ry | Imm 4:0 |
1267 +--------------+--------------------------------+
1269 EXTEND is the five bit value 11110. Major is the instruction
1272 This is handled exactly like R_MIPS_GPREL16, except that the
1273 addend is retrieved and stored as shown in this diagram; that
1274 is, the Imm fields above replace the V-rel16 field.
1276 All we need to do here is shuffle the bits appropriately. As
1277 above, the two 16-bit halves must be swapped on a
1278 little-endian system.
1280 R_MIPS16_HI16 and R_MIPS16_LO16 are used in mips16 mode to
1281 access data when neither GP-relative nor PC-relative addressing
1282 can be used. They are handled like R_MIPS_HI16 and R_MIPS_LO16,
1283 except that the addend is retrieved and stored as shown above
1287 _bfd_mips16_elf_reloc_unshuffle (bfd
*abfd
, int r_type
,
1288 bfd_boolean jal_shuffle
, bfd_byte
*data
)
1290 bfd_vma extend
, insn
, val
;
1292 if (r_type
!= R_MIPS16_26
&& r_type
!= R_MIPS16_GPREL
1293 && r_type
!= R_MIPS16_HI16
&& r_type
!= R_MIPS16_LO16
)
1296 /* Pick up the mips16 extend instruction and the real instruction. */
1297 extend
= bfd_get_16 (abfd
, data
);
1298 insn
= bfd_get_16 (abfd
, data
+ 2);
1299 if (r_type
== R_MIPS16_26
)
1302 val
= ((extend
& 0xfc00) << 16) | ((extend
& 0x3e0) << 11)
1303 | ((extend
& 0x1f) << 21) | insn
;
1305 val
= extend
<< 16 | insn
;
1308 val
= ((extend
& 0xf800) << 16) | ((insn
& 0xffe0) << 11)
1309 | ((extend
& 0x1f) << 11) | (extend
& 0x7e0) | (insn
& 0x1f);
1310 bfd_put_32 (abfd
, val
, data
);
1314 _bfd_mips16_elf_reloc_shuffle (bfd
*abfd
, int r_type
,
1315 bfd_boolean jal_shuffle
, bfd_byte
*data
)
1317 bfd_vma extend
, insn
, val
;
1319 if (r_type
!= R_MIPS16_26
&& r_type
!= R_MIPS16_GPREL
1320 && r_type
!= R_MIPS16_HI16
&& r_type
!= R_MIPS16_LO16
)
1323 val
= bfd_get_32 (abfd
, data
);
1324 if (r_type
== R_MIPS16_26
)
1328 insn
= val
& 0xffff;
1329 extend
= ((val
>> 16) & 0xfc00) | ((val
>> 11) & 0x3e0)
1330 | ((val
>> 21) & 0x1f);
1334 insn
= val
& 0xffff;
1340 insn
= ((val
>> 11) & 0xffe0) | (val
& 0x1f);
1341 extend
= ((val
>> 16) & 0xf800) | ((val
>> 11) & 0x1f) | (val
& 0x7e0);
1343 bfd_put_16 (abfd
, insn
, data
+ 2);
1344 bfd_put_16 (abfd
, extend
, data
);
1347 bfd_reloc_status_type
1348 _bfd_mips_elf_gprel16_with_gp (bfd
*abfd
, asymbol
*symbol
,
1349 arelent
*reloc_entry
, asection
*input_section
,
1350 bfd_boolean relocatable
, void *data
, bfd_vma gp
)
1354 bfd_reloc_status_type status
;
1356 if (bfd_is_com_section (symbol
->section
))
1359 relocation
= symbol
->value
;
1361 relocation
+= symbol
->section
->output_section
->vma
;
1362 relocation
+= symbol
->section
->output_offset
;
1364 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1365 return bfd_reloc_outofrange
;
1367 /* Set val to the offset into the section or symbol. */
1368 val
= reloc_entry
->addend
;
1370 _bfd_mips_elf_sign_extend (val
, 16);
1372 /* Adjust val for the final section location and GP value. If we
1373 are producing relocatable output, we don't want to do this for
1374 an external symbol. */
1376 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1377 val
+= relocation
- gp
;
1379 if (reloc_entry
->howto
->partial_inplace
)
1381 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
1383 + reloc_entry
->address
);
1384 if (status
!= bfd_reloc_ok
)
1388 reloc_entry
->addend
= val
;
1391 reloc_entry
->address
+= input_section
->output_offset
;
1393 return bfd_reloc_ok
;
1396 /* Used to store a REL high-part relocation such as R_MIPS_HI16 or
1397 R_MIPS_GOT16. REL is the relocation, INPUT_SECTION is the section
1398 that contains the relocation field and DATA points to the start of
1403 struct mips_hi16
*next
;
1405 asection
*input_section
;
1409 /* FIXME: This should not be a static variable. */
1411 static struct mips_hi16
*mips_hi16_list
;
1413 /* A howto special_function for REL *HI16 relocations. We can only
1414 calculate the correct value once we've seen the partnering
1415 *LO16 relocation, so just save the information for later.
1417 The ABI requires that the *LO16 immediately follow the *HI16.
1418 However, as a GNU extension, we permit an arbitrary number of
1419 *HI16s to be associated with a single *LO16. This significantly
1420 simplies the relocation handling in gcc. */
1422 bfd_reloc_status_type
1423 _bfd_mips_elf_hi16_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
1424 asymbol
*symbol ATTRIBUTE_UNUSED
, void *data
,
1425 asection
*input_section
, bfd
*output_bfd
,
1426 char **error_message ATTRIBUTE_UNUSED
)
1428 struct mips_hi16
*n
;
1430 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1431 return bfd_reloc_outofrange
;
1433 n
= bfd_malloc (sizeof *n
);
1435 return bfd_reloc_outofrange
;
1437 n
->next
= mips_hi16_list
;
1439 n
->input_section
= input_section
;
1440 n
->rel
= *reloc_entry
;
1443 if (output_bfd
!= NULL
)
1444 reloc_entry
->address
+= input_section
->output_offset
;
1446 return bfd_reloc_ok
;
1449 /* A howto special_function for REL R_MIPS_GOT16 relocations. This is just
1450 like any other 16-bit relocation when applied to global symbols, but is
1451 treated in the same as R_MIPS_HI16 when applied to local symbols. */
1453 bfd_reloc_status_type
1454 _bfd_mips_elf_got16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1455 void *data
, asection
*input_section
,
1456 bfd
*output_bfd
, char **error_message
)
1458 if ((symbol
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
1459 || bfd_is_und_section (bfd_get_section (symbol
))
1460 || bfd_is_com_section (bfd_get_section (symbol
)))
1461 /* The relocation is against a global symbol. */
1462 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1463 input_section
, output_bfd
,
1466 return _bfd_mips_elf_hi16_reloc (abfd
, reloc_entry
, symbol
, data
,
1467 input_section
, output_bfd
, error_message
);
1470 /* A howto special_function for REL *LO16 relocations. The *LO16 itself
1471 is a straightforward 16 bit inplace relocation, but we must deal with
1472 any partnering high-part relocations as well. */
1474 bfd_reloc_status_type
1475 _bfd_mips_elf_lo16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1476 void *data
, asection
*input_section
,
1477 bfd
*output_bfd
, char **error_message
)
1480 bfd_byte
*location
= (bfd_byte
*) data
+ reloc_entry
->address
;
1482 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1483 return bfd_reloc_outofrange
;
1485 _bfd_mips16_elf_reloc_unshuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1487 vallo
= bfd_get_32 (abfd
, location
);
1488 _bfd_mips16_elf_reloc_shuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1491 while (mips_hi16_list
!= NULL
)
1493 bfd_reloc_status_type ret
;
1494 struct mips_hi16
*hi
;
1496 hi
= mips_hi16_list
;
1498 /* R_MIPS_GOT16 relocations are something of a special case. We
1499 want to install the addend in the same way as for a R_MIPS_HI16
1500 relocation (with a rightshift of 16). However, since GOT16
1501 relocations can also be used with global symbols, their howto
1502 has a rightshift of 0. */
1503 if (hi
->rel
.howto
->type
== R_MIPS_GOT16
)
1504 hi
->rel
.howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, R_MIPS_HI16
, FALSE
);
1506 /* VALLO is a signed 16-bit number. Bias it by 0x8000 so that any
1507 carry or borrow will induce a change of +1 or -1 in the high part. */
1508 hi
->rel
.addend
+= (vallo
+ 0x8000) & 0xffff;
1510 ret
= _bfd_mips_elf_generic_reloc (abfd
, &hi
->rel
, symbol
, hi
->data
,
1511 hi
->input_section
, output_bfd
,
1513 if (ret
!= bfd_reloc_ok
)
1516 mips_hi16_list
= hi
->next
;
1520 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1521 input_section
, output_bfd
,
1525 /* A generic howto special_function. This calculates and installs the
1526 relocation itself, thus avoiding the oft-discussed problems in
1527 bfd_perform_relocation and bfd_install_relocation. */
1529 bfd_reloc_status_type
1530 _bfd_mips_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
1531 asymbol
*symbol
, void *data ATTRIBUTE_UNUSED
,
1532 asection
*input_section
, bfd
*output_bfd
,
1533 char **error_message ATTRIBUTE_UNUSED
)
1536 bfd_reloc_status_type status
;
1537 bfd_boolean relocatable
;
1539 relocatable
= (output_bfd
!= NULL
);
1541 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1542 return bfd_reloc_outofrange
;
1544 /* Build up the field adjustment in VAL. */
1546 if (!relocatable
|| (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1548 /* Either we're calculating the final field value or we have a
1549 relocation against a section symbol. Add in the section's
1550 offset or address. */
1551 val
+= symbol
->section
->output_section
->vma
;
1552 val
+= symbol
->section
->output_offset
;
1557 /* We're calculating the final field value. Add in the symbol's value
1558 and, if pc-relative, subtract the address of the field itself. */
1559 val
+= symbol
->value
;
1560 if (reloc_entry
->howto
->pc_relative
)
1562 val
-= input_section
->output_section
->vma
;
1563 val
-= input_section
->output_offset
;
1564 val
-= reloc_entry
->address
;
1568 /* VAL is now the final adjustment. If we're keeping this relocation
1569 in the output file, and if the relocation uses a separate addend,
1570 we just need to add VAL to that addend. Otherwise we need to add
1571 VAL to the relocation field itself. */
1572 if (relocatable
&& !reloc_entry
->howto
->partial_inplace
)
1573 reloc_entry
->addend
+= val
;
1576 bfd_byte
*location
= (bfd_byte
*) data
+ reloc_entry
->address
;
1578 /* Add in the separate addend, if any. */
1579 val
+= reloc_entry
->addend
;
1581 /* Add VAL to the relocation field. */
1582 _bfd_mips16_elf_reloc_unshuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1584 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
1586 _bfd_mips16_elf_reloc_shuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1589 if (status
!= bfd_reloc_ok
)
1594 reloc_entry
->address
+= input_section
->output_offset
;
1596 return bfd_reloc_ok
;
1599 /* Swap an entry in a .gptab section. Note that these routines rely
1600 on the equivalence of the two elements of the union. */
1603 bfd_mips_elf32_swap_gptab_in (bfd
*abfd
, const Elf32_External_gptab
*ex
,
1606 in
->gt_entry
.gt_g_value
= H_GET_32 (abfd
, ex
->gt_entry
.gt_g_value
);
1607 in
->gt_entry
.gt_bytes
= H_GET_32 (abfd
, ex
->gt_entry
.gt_bytes
);
1611 bfd_mips_elf32_swap_gptab_out (bfd
*abfd
, const Elf32_gptab
*in
,
1612 Elf32_External_gptab
*ex
)
1614 H_PUT_32 (abfd
, in
->gt_entry
.gt_g_value
, ex
->gt_entry
.gt_g_value
);
1615 H_PUT_32 (abfd
, in
->gt_entry
.gt_bytes
, ex
->gt_entry
.gt_bytes
);
1619 bfd_elf32_swap_compact_rel_out (bfd
*abfd
, const Elf32_compact_rel
*in
,
1620 Elf32_External_compact_rel
*ex
)
1622 H_PUT_32 (abfd
, in
->id1
, ex
->id1
);
1623 H_PUT_32 (abfd
, in
->num
, ex
->num
);
1624 H_PUT_32 (abfd
, in
->id2
, ex
->id2
);
1625 H_PUT_32 (abfd
, in
->offset
, ex
->offset
);
1626 H_PUT_32 (abfd
, in
->reserved0
, ex
->reserved0
);
1627 H_PUT_32 (abfd
, in
->reserved1
, ex
->reserved1
);
1631 bfd_elf32_swap_crinfo_out (bfd
*abfd
, const Elf32_crinfo
*in
,
1632 Elf32_External_crinfo
*ex
)
1636 l
= (((in
->ctype
& CRINFO_CTYPE
) << CRINFO_CTYPE_SH
)
1637 | ((in
->rtype
& CRINFO_RTYPE
) << CRINFO_RTYPE_SH
)
1638 | ((in
->dist2to
& CRINFO_DIST2TO
) << CRINFO_DIST2TO_SH
)
1639 | ((in
->relvaddr
& CRINFO_RELVADDR
) << CRINFO_RELVADDR_SH
));
1640 H_PUT_32 (abfd
, l
, ex
->info
);
1641 H_PUT_32 (abfd
, in
->konst
, ex
->konst
);
1642 H_PUT_32 (abfd
, in
->vaddr
, ex
->vaddr
);
1645 /* A .reginfo section holds a single Elf32_RegInfo structure. These
1646 routines swap this structure in and out. They are used outside of
1647 BFD, so they are globally visible. */
1650 bfd_mips_elf32_swap_reginfo_in (bfd
*abfd
, const Elf32_External_RegInfo
*ex
,
1653 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1654 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1655 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1656 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1657 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1658 in
->ri_gp_value
= H_GET_32 (abfd
, ex
->ri_gp_value
);
1662 bfd_mips_elf32_swap_reginfo_out (bfd
*abfd
, const Elf32_RegInfo
*in
,
1663 Elf32_External_RegInfo
*ex
)
1665 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1666 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1667 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1668 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1669 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1670 H_PUT_32 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1673 /* In the 64 bit ABI, the .MIPS.options section holds register
1674 information in an Elf64_Reginfo structure. These routines swap
1675 them in and out. They are globally visible because they are used
1676 outside of BFD. These routines are here so that gas can call them
1677 without worrying about whether the 64 bit ABI has been included. */
1680 bfd_mips_elf64_swap_reginfo_in (bfd
*abfd
, const Elf64_External_RegInfo
*ex
,
1681 Elf64_Internal_RegInfo
*in
)
1683 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1684 in
->ri_pad
= H_GET_32 (abfd
, ex
->ri_pad
);
1685 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1686 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1687 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1688 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1689 in
->ri_gp_value
= H_GET_64 (abfd
, ex
->ri_gp_value
);
1693 bfd_mips_elf64_swap_reginfo_out (bfd
*abfd
, const Elf64_Internal_RegInfo
*in
,
1694 Elf64_External_RegInfo
*ex
)
1696 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1697 H_PUT_32 (abfd
, in
->ri_pad
, ex
->ri_pad
);
1698 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1699 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1700 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1701 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1702 H_PUT_64 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1705 /* Swap in an options header. */
1708 bfd_mips_elf_swap_options_in (bfd
*abfd
, const Elf_External_Options
*ex
,
1709 Elf_Internal_Options
*in
)
1711 in
->kind
= H_GET_8 (abfd
, ex
->kind
);
1712 in
->size
= H_GET_8 (abfd
, ex
->size
);
1713 in
->section
= H_GET_16 (abfd
, ex
->section
);
1714 in
->info
= H_GET_32 (abfd
, ex
->info
);
1717 /* Swap out an options header. */
1720 bfd_mips_elf_swap_options_out (bfd
*abfd
, const Elf_Internal_Options
*in
,
1721 Elf_External_Options
*ex
)
1723 H_PUT_8 (abfd
, in
->kind
, ex
->kind
);
1724 H_PUT_8 (abfd
, in
->size
, ex
->size
);
1725 H_PUT_16 (abfd
, in
->section
, ex
->section
);
1726 H_PUT_32 (abfd
, in
->info
, ex
->info
);
1729 /* This function is called via qsort() to sort the dynamic relocation
1730 entries by increasing r_symndx value. */
1733 sort_dynamic_relocs (const void *arg1
, const void *arg2
)
1735 Elf_Internal_Rela int_reloc1
;
1736 Elf_Internal_Rela int_reloc2
;
1739 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg1
, &int_reloc1
);
1740 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg2
, &int_reloc2
);
1742 diff
= ELF32_R_SYM (int_reloc1
.r_info
) - ELF32_R_SYM (int_reloc2
.r_info
);
1746 if (int_reloc1
.r_offset
< int_reloc2
.r_offset
)
1748 if (int_reloc1
.r_offset
> int_reloc2
.r_offset
)
1753 /* Like sort_dynamic_relocs, but used for elf64 relocations. */
1756 sort_dynamic_relocs_64 (const void *arg1 ATTRIBUTE_UNUSED
,
1757 const void *arg2 ATTRIBUTE_UNUSED
)
1760 Elf_Internal_Rela int_reloc1
[3];
1761 Elf_Internal_Rela int_reloc2
[3];
1763 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1764 (reldyn_sorting_bfd
, arg1
, int_reloc1
);
1765 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1766 (reldyn_sorting_bfd
, arg2
, int_reloc2
);
1768 if (ELF64_R_SYM (int_reloc1
[0].r_info
) < ELF64_R_SYM (int_reloc2
[0].r_info
))
1770 if (ELF64_R_SYM (int_reloc1
[0].r_info
) > ELF64_R_SYM (int_reloc2
[0].r_info
))
1773 if (int_reloc1
[0].r_offset
< int_reloc2
[0].r_offset
)
1775 if (int_reloc1
[0].r_offset
> int_reloc2
[0].r_offset
)
1784 /* This routine is used to write out ECOFF debugging external symbol
1785 information. It is called via mips_elf_link_hash_traverse. The
1786 ECOFF external symbol information must match the ELF external
1787 symbol information. Unfortunately, at this point we don't know
1788 whether a symbol is required by reloc information, so the two
1789 tables may wind up being different. We must sort out the external
1790 symbol information before we can set the final size of the .mdebug
1791 section, and we must set the size of the .mdebug section before we
1792 can relocate any sections, and we can't know which symbols are
1793 required by relocation until we relocate the sections.
1794 Fortunately, it is relatively unlikely that any symbol will be
1795 stripped but required by a reloc. In particular, it can not happen
1796 when generating a final executable. */
1799 mips_elf_output_extsym (struct mips_elf_link_hash_entry
*h
, void *data
)
1801 struct extsym_info
*einfo
= data
;
1803 asection
*sec
, *output_section
;
1805 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1806 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1808 if (h
->root
.indx
== -2)
1810 else if ((h
->root
.def_dynamic
1811 || h
->root
.ref_dynamic
1812 || h
->root
.type
== bfd_link_hash_new
)
1813 && !h
->root
.def_regular
1814 && !h
->root
.ref_regular
)
1816 else if (einfo
->info
->strip
== strip_all
1817 || (einfo
->info
->strip
== strip_some
1818 && bfd_hash_lookup (einfo
->info
->keep_hash
,
1819 h
->root
.root
.root
.string
,
1820 FALSE
, FALSE
) == NULL
))
1828 if (h
->esym
.ifd
== -2)
1831 h
->esym
.cobol_main
= 0;
1832 h
->esym
.weakext
= 0;
1833 h
->esym
.reserved
= 0;
1834 h
->esym
.ifd
= ifdNil
;
1835 h
->esym
.asym
.value
= 0;
1836 h
->esym
.asym
.st
= stGlobal
;
1838 if (h
->root
.root
.type
== bfd_link_hash_undefined
1839 || h
->root
.root
.type
== bfd_link_hash_undefweak
)
1843 /* Use undefined class. Also, set class and type for some
1845 name
= h
->root
.root
.root
.string
;
1846 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
1847 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
1849 h
->esym
.asym
.sc
= scData
;
1850 h
->esym
.asym
.st
= stLabel
;
1851 h
->esym
.asym
.value
= 0;
1853 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
1855 h
->esym
.asym
.sc
= scAbs
;
1856 h
->esym
.asym
.st
= stLabel
;
1857 h
->esym
.asym
.value
=
1858 mips_elf_hash_table (einfo
->info
)->procedure_count
;
1860 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (einfo
->abfd
))
1862 h
->esym
.asym
.sc
= scAbs
;
1863 h
->esym
.asym
.st
= stLabel
;
1864 h
->esym
.asym
.value
= elf_gp (einfo
->abfd
);
1867 h
->esym
.asym
.sc
= scUndefined
;
1869 else if (h
->root
.root
.type
!= bfd_link_hash_defined
1870 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
1871 h
->esym
.asym
.sc
= scAbs
;
1876 sec
= h
->root
.root
.u
.def
.section
;
1877 output_section
= sec
->output_section
;
1879 /* When making a shared library and symbol h is the one from
1880 the another shared library, OUTPUT_SECTION may be null. */
1881 if (output_section
== NULL
)
1882 h
->esym
.asym
.sc
= scUndefined
;
1885 name
= bfd_section_name (output_section
->owner
, output_section
);
1887 if (strcmp (name
, ".text") == 0)
1888 h
->esym
.asym
.sc
= scText
;
1889 else if (strcmp (name
, ".data") == 0)
1890 h
->esym
.asym
.sc
= scData
;
1891 else if (strcmp (name
, ".sdata") == 0)
1892 h
->esym
.asym
.sc
= scSData
;
1893 else if (strcmp (name
, ".rodata") == 0
1894 || strcmp (name
, ".rdata") == 0)
1895 h
->esym
.asym
.sc
= scRData
;
1896 else if (strcmp (name
, ".bss") == 0)
1897 h
->esym
.asym
.sc
= scBss
;
1898 else if (strcmp (name
, ".sbss") == 0)
1899 h
->esym
.asym
.sc
= scSBss
;
1900 else if (strcmp (name
, ".init") == 0)
1901 h
->esym
.asym
.sc
= scInit
;
1902 else if (strcmp (name
, ".fini") == 0)
1903 h
->esym
.asym
.sc
= scFini
;
1905 h
->esym
.asym
.sc
= scAbs
;
1909 h
->esym
.asym
.reserved
= 0;
1910 h
->esym
.asym
.index
= indexNil
;
1913 if (h
->root
.root
.type
== bfd_link_hash_common
)
1914 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
1915 else if (h
->root
.root
.type
== bfd_link_hash_defined
1916 || h
->root
.root
.type
== bfd_link_hash_defweak
)
1918 if (h
->esym
.asym
.sc
== scCommon
)
1919 h
->esym
.asym
.sc
= scBss
;
1920 else if (h
->esym
.asym
.sc
== scSCommon
)
1921 h
->esym
.asym
.sc
= scSBss
;
1923 sec
= h
->root
.root
.u
.def
.section
;
1924 output_section
= sec
->output_section
;
1925 if (output_section
!= NULL
)
1926 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
1927 + sec
->output_offset
1928 + output_section
->vma
);
1930 h
->esym
.asym
.value
= 0;
1932 else if (h
->root
.needs_plt
)
1934 struct mips_elf_link_hash_entry
*hd
= h
;
1935 bfd_boolean no_fn_stub
= h
->no_fn_stub
;
1937 while (hd
->root
.root
.type
== bfd_link_hash_indirect
)
1939 hd
= (struct mips_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
1940 no_fn_stub
= no_fn_stub
|| hd
->no_fn_stub
;
1945 /* Set type and value for a symbol with a function stub. */
1946 h
->esym
.asym
.st
= stProc
;
1947 sec
= hd
->root
.root
.u
.def
.section
;
1949 h
->esym
.asym
.value
= 0;
1952 output_section
= sec
->output_section
;
1953 if (output_section
!= NULL
)
1954 h
->esym
.asym
.value
= (hd
->root
.plt
.offset
1955 + sec
->output_offset
1956 + output_section
->vma
);
1958 h
->esym
.asym
.value
= 0;
1963 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
1964 h
->root
.root
.root
.string
,
1967 einfo
->failed
= TRUE
;
1974 /* A comparison routine used to sort .gptab entries. */
1977 gptab_compare (const void *p1
, const void *p2
)
1979 const Elf32_gptab
*a1
= p1
;
1980 const Elf32_gptab
*a2
= p2
;
1982 return a1
->gt_entry
.gt_g_value
- a2
->gt_entry
.gt_g_value
;
1985 /* Functions to manage the got entry hash table. */
1987 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
1990 static INLINE hashval_t
1991 mips_elf_hash_bfd_vma (bfd_vma addr
)
1994 return addr
+ (addr
>> 32);
2000 /* got_entries only match if they're identical, except for gotidx, so
2001 use all fields to compute the hash, and compare the appropriate
2005 mips_elf_got_entry_hash (const void *entry_
)
2007 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
2009 return entry
->symndx
2010 + ((entry
->tls_type
& GOT_TLS_LDM
) << 17)
2011 + (! entry
->abfd
? mips_elf_hash_bfd_vma (entry
->d
.address
)
2013 + (entry
->symndx
>= 0 ? mips_elf_hash_bfd_vma (entry
->d
.addend
)
2014 : entry
->d
.h
->root
.root
.root
.hash
));
2018 mips_elf_got_entry_eq (const void *entry1
, const void *entry2
)
2020 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
2021 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
2023 /* An LDM entry can only match another LDM entry. */
2024 if ((e1
->tls_type
^ e2
->tls_type
) & GOT_TLS_LDM
)
2027 return e1
->abfd
== e2
->abfd
&& e1
->symndx
== e2
->symndx
2028 && (! e1
->abfd
? e1
->d
.address
== e2
->d
.address
2029 : e1
->symndx
>= 0 ? e1
->d
.addend
== e2
->d
.addend
2030 : e1
->d
.h
== e2
->d
.h
);
2033 /* multi_got_entries are still a match in the case of global objects,
2034 even if the input bfd in which they're referenced differs, so the
2035 hash computation and compare functions are adjusted
2039 mips_elf_multi_got_entry_hash (const void *entry_
)
2041 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
2043 return entry
->symndx
2045 ? mips_elf_hash_bfd_vma (entry
->d
.address
)
2046 : entry
->symndx
>= 0
2047 ? ((entry
->tls_type
& GOT_TLS_LDM
)
2048 ? (GOT_TLS_LDM
<< 17)
2050 + mips_elf_hash_bfd_vma (entry
->d
.addend
)))
2051 : entry
->d
.h
->root
.root
.root
.hash
);
2055 mips_elf_multi_got_entry_eq (const void *entry1
, const void *entry2
)
2057 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
2058 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
2060 /* Any two LDM entries match. */
2061 if (e1
->tls_type
& e2
->tls_type
& GOT_TLS_LDM
)
2064 /* Nothing else matches an LDM entry. */
2065 if ((e1
->tls_type
^ e2
->tls_type
) & GOT_TLS_LDM
)
2068 return e1
->symndx
== e2
->symndx
2069 && (e1
->symndx
>= 0 ? e1
->abfd
== e2
->abfd
&& e1
->d
.addend
== e2
->d
.addend
2070 : e1
->abfd
== NULL
|| e2
->abfd
== NULL
2071 ? e1
->abfd
== e2
->abfd
&& e1
->d
.address
== e2
->d
.address
2072 : e1
->d
.h
== e2
->d
.h
);
2076 mips_got_page_entry_hash (const void *entry_
)
2078 const struct mips_got_page_entry
*entry
;
2080 entry
= (const struct mips_got_page_entry
*) entry_
;
2081 return entry
->abfd
->id
+ entry
->symndx
;
2085 mips_got_page_entry_eq (const void *entry1_
, const void *entry2_
)
2087 const struct mips_got_page_entry
*entry1
, *entry2
;
2089 entry1
= (const struct mips_got_page_entry
*) entry1_
;
2090 entry2
= (const struct mips_got_page_entry
*) entry2_
;
2091 return entry1
->abfd
== entry2
->abfd
&& entry1
->symndx
== entry2
->symndx
;
2094 /* Return the dynamic relocation section. If it doesn't exist, try to
2095 create a new it if CREATE_P, otherwise return NULL. Also return NULL
2096 if creation fails. */
2099 mips_elf_rel_dyn_section (struct bfd_link_info
*info
, bfd_boolean create_p
)
2105 dname
= MIPS_ELF_REL_DYN_NAME (info
);
2106 dynobj
= elf_hash_table (info
)->dynobj
;
2107 sreloc
= bfd_get_section_by_name (dynobj
, dname
);
2108 if (sreloc
== NULL
&& create_p
)
2110 sreloc
= bfd_make_section_with_flags (dynobj
, dname
,
2115 | SEC_LINKER_CREATED
2118 || ! bfd_set_section_alignment (dynobj
, sreloc
,
2119 MIPS_ELF_LOG_FILE_ALIGN (dynobj
)))
2125 /* Returns the GOT section for ABFD. */
2128 mips_elf_got_section (bfd
*abfd
, bfd_boolean maybe_excluded
)
2130 asection
*sgot
= bfd_get_section_by_name (abfd
, ".got");
2132 || (! maybe_excluded
&& (sgot
->flags
& SEC_EXCLUDE
) != 0))
2137 /* Returns the GOT information associated with the link indicated by
2138 INFO. If SGOTP is non-NULL, it is filled in with the GOT
2141 static struct mips_got_info
*
2142 mips_elf_got_info (bfd
*abfd
, asection
**sgotp
)
2145 struct mips_got_info
*g
;
2147 sgot
= mips_elf_got_section (abfd
, TRUE
);
2148 BFD_ASSERT (sgot
!= NULL
);
2149 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
2150 g
= mips_elf_section_data (sgot
)->u
.got_info
;
2151 BFD_ASSERT (g
!= NULL
);
2154 *sgotp
= (sgot
->flags
& SEC_EXCLUDE
) == 0 ? sgot
: NULL
;
2159 /* Count the number of relocations needed for a TLS GOT entry, with
2160 access types from TLS_TYPE, and symbol H (or a local symbol if H
2164 mips_tls_got_relocs (struct bfd_link_info
*info
, unsigned char tls_type
,
2165 struct elf_link_hash_entry
*h
)
2169 bfd_boolean need_relocs
= FALSE
;
2170 bfd_boolean dyn
= elf_hash_table (info
)->dynamic_sections_created
;
2172 if (h
&& WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
2173 && (!info
->shared
|| !SYMBOL_REFERENCES_LOCAL (info
, h
)))
2176 if ((info
->shared
|| indx
!= 0)
2178 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2179 || h
->root
.type
!= bfd_link_hash_undefweak
))
2185 if (tls_type
& GOT_TLS_GD
)
2192 if (tls_type
& GOT_TLS_IE
)
2195 if ((tls_type
& GOT_TLS_LDM
) && info
->shared
)
2201 /* Count the number of TLS relocations required for the GOT entry in
2202 ARG1, if it describes a local symbol. */
2205 mips_elf_count_local_tls_relocs (void **arg1
, void *arg2
)
2207 struct mips_got_entry
*entry
= * (struct mips_got_entry
**) arg1
;
2208 struct mips_elf_count_tls_arg
*arg
= arg2
;
2210 if (entry
->abfd
!= NULL
&& entry
->symndx
!= -1)
2211 arg
->needed
+= mips_tls_got_relocs (arg
->info
, entry
->tls_type
, NULL
);
2216 /* Count the number of TLS GOT entries required for the global (or
2217 forced-local) symbol in ARG1. */
2220 mips_elf_count_global_tls_entries (void *arg1
, void *arg2
)
2222 struct mips_elf_link_hash_entry
*hm
2223 = (struct mips_elf_link_hash_entry
*) arg1
;
2224 struct mips_elf_count_tls_arg
*arg
= arg2
;
2226 if (hm
->tls_type
& GOT_TLS_GD
)
2228 if (hm
->tls_type
& GOT_TLS_IE
)
2234 /* Count the number of TLS relocations required for the global (or
2235 forced-local) symbol in ARG1. */
2238 mips_elf_count_global_tls_relocs (void *arg1
, void *arg2
)
2240 struct mips_elf_link_hash_entry
*hm
2241 = (struct mips_elf_link_hash_entry
*) arg1
;
2242 struct mips_elf_count_tls_arg
*arg
= arg2
;
2244 arg
->needed
+= mips_tls_got_relocs (arg
->info
, hm
->tls_type
, &hm
->root
);
2249 /* Output a simple dynamic relocation into SRELOC. */
2252 mips_elf_output_dynamic_relocation (bfd
*output_bfd
,
2258 Elf_Internal_Rela rel
[3];
2260 memset (rel
, 0, sizeof (rel
));
2262 rel
[0].r_info
= ELF_R_INFO (output_bfd
, indx
, r_type
);
2263 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
2265 if (ABI_64_P (output_bfd
))
2267 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
2268 (output_bfd
, &rel
[0],
2270 + sreloc
->reloc_count
* sizeof (Elf64_Mips_External_Rel
)));
2273 bfd_elf32_swap_reloc_out
2274 (output_bfd
, &rel
[0],
2276 + sreloc
->reloc_count
* sizeof (Elf32_External_Rel
)));
2277 ++sreloc
->reloc_count
;
2280 /* Initialize a set of TLS GOT entries for one symbol. */
2283 mips_elf_initialize_tls_slots (bfd
*abfd
, bfd_vma got_offset
,
2284 unsigned char *tls_type_p
,
2285 struct bfd_link_info
*info
,
2286 struct mips_elf_link_hash_entry
*h
,
2290 asection
*sreloc
, *sgot
;
2291 bfd_vma offset
, offset2
;
2293 bfd_boolean need_relocs
= FALSE
;
2295 dynobj
= elf_hash_table (info
)->dynobj
;
2296 sgot
= mips_elf_got_section (dynobj
, FALSE
);
2301 bfd_boolean dyn
= elf_hash_table (info
)->dynamic_sections_created
;
2303 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, &h
->root
)
2304 && (!info
->shared
|| !SYMBOL_REFERENCES_LOCAL (info
, &h
->root
)))
2305 indx
= h
->root
.dynindx
;
2308 if (*tls_type_p
& GOT_TLS_DONE
)
2311 if ((info
->shared
|| indx
!= 0)
2313 || ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
2314 || h
->root
.type
!= bfd_link_hash_undefweak
))
2317 /* MINUS_ONE means the symbol is not defined in this object. It may not
2318 be defined at all; assume that the value doesn't matter in that
2319 case. Otherwise complain if we would use the value. */
2320 BFD_ASSERT (value
!= MINUS_ONE
|| (indx
!= 0 && need_relocs
)
2321 || h
->root
.root
.type
== bfd_link_hash_undefweak
);
2323 /* Emit necessary relocations. */
2324 sreloc
= mips_elf_rel_dyn_section (info
, FALSE
);
2326 /* General Dynamic. */
2327 if (*tls_type_p
& GOT_TLS_GD
)
2329 offset
= got_offset
;
2330 offset2
= offset
+ MIPS_ELF_GOT_SIZE (abfd
);
2334 mips_elf_output_dynamic_relocation
2335 (abfd
, sreloc
, indx
,
2336 ABI_64_P (abfd
) ? R_MIPS_TLS_DTPMOD64
: R_MIPS_TLS_DTPMOD32
,
2337 sgot
->output_offset
+ sgot
->output_section
->vma
+ offset
);
2340 mips_elf_output_dynamic_relocation
2341 (abfd
, sreloc
, indx
,
2342 ABI_64_P (abfd
) ? R_MIPS_TLS_DTPREL64
: R_MIPS_TLS_DTPREL32
,
2343 sgot
->output_offset
+ sgot
->output_section
->vma
+ offset2
);
2345 MIPS_ELF_PUT_WORD (abfd
, value
- dtprel_base (info
),
2346 sgot
->contents
+ offset2
);
2350 MIPS_ELF_PUT_WORD (abfd
, 1,
2351 sgot
->contents
+ offset
);
2352 MIPS_ELF_PUT_WORD (abfd
, value
- dtprel_base (info
),
2353 sgot
->contents
+ offset2
);
2356 got_offset
+= 2 * MIPS_ELF_GOT_SIZE (abfd
);
2359 /* Initial Exec model. */
2360 if (*tls_type_p
& GOT_TLS_IE
)
2362 offset
= got_offset
;
2367 MIPS_ELF_PUT_WORD (abfd
, value
- elf_hash_table (info
)->tls_sec
->vma
,
2368 sgot
->contents
+ offset
);
2370 MIPS_ELF_PUT_WORD (abfd
, 0,
2371 sgot
->contents
+ offset
);
2373 mips_elf_output_dynamic_relocation
2374 (abfd
, sreloc
, indx
,
2375 ABI_64_P (abfd
) ? R_MIPS_TLS_TPREL64
: R_MIPS_TLS_TPREL32
,
2376 sgot
->output_offset
+ sgot
->output_section
->vma
+ offset
);
2379 MIPS_ELF_PUT_WORD (abfd
, value
- tprel_base (info
),
2380 sgot
->contents
+ offset
);
2383 if (*tls_type_p
& GOT_TLS_LDM
)
2385 /* The initial offset is zero, and the LD offsets will include the
2386 bias by DTP_OFFSET. */
2387 MIPS_ELF_PUT_WORD (abfd
, 0,
2388 sgot
->contents
+ got_offset
2389 + MIPS_ELF_GOT_SIZE (abfd
));
2392 MIPS_ELF_PUT_WORD (abfd
, 1,
2393 sgot
->contents
+ got_offset
);
2395 mips_elf_output_dynamic_relocation
2396 (abfd
, sreloc
, indx
,
2397 ABI_64_P (abfd
) ? R_MIPS_TLS_DTPMOD64
: R_MIPS_TLS_DTPMOD32
,
2398 sgot
->output_offset
+ sgot
->output_section
->vma
+ got_offset
);
2401 *tls_type_p
|= GOT_TLS_DONE
;
2404 /* Return the GOT index to use for a relocation of type R_TYPE against
2405 a symbol accessed using TLS_TYPE models. The GOT entries for this
2406 symbol in this GOT start at GOT_INDEX. This function initializes the
2407 GOT entries and corresponding relocations. */
2410 mips_tls_got_index (bfd
*abfd
, bfd_vma got_index
, unsigned char *tls_type
,
2411 int r_type
, struct bfd_link_info
*info
,
2412 struct mips_elf_link_hash_entry
*h
, bfd_vma symbol
)
2414 BFD_ASSERT (r_type
== R_MIPS_TLS_GOTTPREL
|| r_type
== R_MIPS_TLS_GD
2415 || r_type
== R_MIPS_TLS_LDM
);
2417 mips_elf_initialize_tls_slots (abfd
, got_index
, tls_type
, info
, h
, symbol
);
2419 if (r_type
== R_MIPS_TLS_GOTTPREL
)
2421 BFD_ASSERT (*tls_type
& GOT_TLS_IE
);
2422 if (*tls_type
& GOT_TLS_GD
)
2423 return got_index
+ 2 * MIPS_ELF_GOT_SIZE (abfd
);
2428 if (r_type
== R_MIPS_TLS_GD
)
2430 BFD_ASSERT (*tls_type
& GOT_TLS_GD
);
2434 if (r_type
== R_MIPS_TLS_LDM
)
2436 BFD_ASSERT (*tls_type
& GOT_TLS_LDM
);
2443 /* Return the offset from _GLOBAL_OFFSET_TABLE_ of the .got.plt entry
2444 for global symbol H. .got.plt comes before the GOT, so the offset
2445 will be negative. */
2448 mips_elf_gotplt_index (struct bfd_link_info
*info
,
2449 struct elf_link_hash_entry
*h
)
2451 bfd_vma plt_index
, got_address
, got_value
;
2452 struct mips_elf_link_hash_table
*htab
;
2454 htab
= mips_elf_hash_table (info
);
2455 BFD_ASSERT (h
->plt
.offset
!= (bfd_vma
) -1);
2457 /* Calculate the index of the symbol's PLT entry. */
2458 plt_index
= (h
->plt
.offset
- htab
->plt_header_size
) / htab
->plt_entry_size
;
2460 /* Calculate the address of the associated .got.plt entry. */
2461 got_address
= (htab
->sgotplt
->output_section
->vma
2462 + htab
->sgotplt
->output_offset
2465 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */
2466 got_value
= (htab
->root
.hgot
->root
.u
.def
.section
->output_section
->vma
2467 + htab
->root
.hgot
->root
.u
.def
.section
->output_offset
2468 + htab
->root
.hgot
->root
.u
.def
.value
);
2470 return got_address
- got_value
;
2473 /* Return the GOT offset for address VALUE. If there is not yet a GOT
2474 entry for this value, create one. If R_SYMNDX refers to a TLS symbol,
2475 create a TLS GOT entry instead. Return -1 if no satisfactory GOT
2476 offset can be found. */
2479 mips_elf_local_got_index (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
2480 bfd_vma value
, unsigned long r_symndx
,
2481 struct mips_elf_link_hash_entry
*h
, int r_type
)
2484 struct mips_got_info
*g
;
2485 struct mips_got_entry
*entry
;
2487 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
2489 entry
= mips_elf_create_local_got_entry (abfd
, info
, ibfd
, g
, sgot
,
2490 value
, r_symndx
, h
, r_type
);
2494 if (TLS_RELOC_P (r_type
))
2496 if (entry
->symndx
== -1 && g
->next
== NULL
)
2497 /* A type (3) entry in the single-GOT case. We use the symbol's
2498 hash table entry to track the index. */
2499 return mips_tls_got_index (abfd
, h
->tls_got_offset
, &h
->tls_type
,
2500 r_type
, info
, h
, value
);
2502 return mips_tls_got_index (abfd
, entry
->gotidx
, &entry
->tls_type
,
2503 r_type
, info
, h
, value
);
2506 return entry
->gotidx
;
2509 /* Returns the GOT index for the global symbol indicated by H. */
2512 mips_elf_global_got_index (bfd
*abfd
, bfd
*ibfd
, struct elf_link_hash_entry
*h
,
2513 int r_type
, struct bfd_link_info
*info
)
2517 struct mips_got_info
*g
, *gg
;
2518 long global_got_dynindx
= 0;
2520 gg
= g
= mips_elf_got_info (abfd
, &sgot
);
2521 if (g
->bfd2got
&& ibfd
)
2523 struct mips_got_entry e
, *p
;
2525 BFD_ASSERT (h
->dynindx
>= 0);
2527 g
= mips_elf_got_for_ibfd (g
, ibfd
);
2528 if (g
->next
!= gg
|| TLS_RELOC_P (r_type
))
2532 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
2535 p
= htab_find (g
->got_entries
, &e
);
2537 BFD_ASSERT (p
->gotidx
> 0);
2539 if (TLS_RELOC_P (r_type
))
2541 bfd_vma value
= MINUS_ONE
;
2542 if ((h
->root
.type
== bfd_link_hash_defined
2543 || h
->root
.type
== bfd_link_hash_defweak
)
2544 && h
->root
.u
.def
.section
->output_section
)
2545 value
= (h
->root
.u
.def
.value
2546 + h
->root
.u
.def
.section
->output_offset
2547 + h
->root
.u
.def
.section
->output_section
->vma
);
2549 return mips_tls_got_index (abfd
, p
->gotidx
, &p
->tls_type
, r_type
,
2550 info
, e
.d
.h
, value
);
2557 if (gg
->global_gotsym
!= NULL
)
2558 global_got_dynindx
= gg
->global_gotsym
->dynindx
;
2560 if (TLS_RELOC_P (r_type
))
2562 struct mips_elf_link_hash_entry
*hm
2563 = (struct mips_elf_link_hash_entry
*) h
;
2564 bfd_vma value
= MINUS_ONE
;
2566 if ((h
->root
.type
== bfd_link_hash_defined
2567 || h
->root
.type
== bfd_link_hash_defweak
)
2568 && h
->root
.u
.def
.section
->output_section
)
2569 value
= (h
->root
.u
.def
.value
2570 + h
->root
.u
.def
.section
->output_offset
2571 + h
->root
.u
.def
.section
->output_section
->vma
);
2573 index
= mips_tls_got_index (abfd
, hm
->tls_got_offset
, &hm
->tls_type
,
2574 r_type
, info
, hm
, value
);
2578 /* Once we determine the global GOT entry with the lowest dynamic
2579 symbol table index, we must put all dynamic symbols with greater
2580 indices into the GOT. That makes it easy to calculate the GOT
2582 BFD_ASSERT (h
->dynindx
>= global_got_dynindx
);
2583 index
= ((h
->dynindx
- global_got_dynindx
+ g
->local_gotno
)
2584 * MIPS_ELF_GOT_SIZE (abfd
));
2586 BFD_ASSERT (index
< sgot
->size
);
2591 /* Find a GOT page entry that points to within 32KB of VALUE. These
2592 entries are supposed to be placed at small offsets in the GOT, i.e.,
2593 within 32KB of GP. Return the index of the GOT entry, or -1 if no
2594 entry could be created. If OFFSETP is nonnull, use it to return the
2595 offset of the GOT entry from VALUE. */
2598 mips_elf_got_page (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
2599 bfd_vma value
, bfd_vma
*offsetp
)
2602 struct mips_got_info
*g
;
2603 bfd_vma page
, index
;
2604 struct mips_got_entry
*entry
;
2606 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
2608 page
= (value
+ 0x8000) & ~(bfd_vma
) 0xffff;
2609 entry
= mips_elf_create_local_got_entry (abfd
, info
, ibfd
, g
, sgot
,
2610 page
, 0, NULL
, R_MIPS_GOT_PAGE
);
2615 index
= entry
->gotidx
;
2618 *offsetp
= value
- entry
->d
.address
;
2623 /* Find a local GOT entry for an R_MIPS_GOT16 relocation against VALUE.
2624 EXTERNAL is true if the relocation was against a global symbol
2625 that has been forced local. */
2628 mips_elf_got16_entry (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
2629 bfd_vma value
, bfd_boolean external
)
2632 struct mips_got_info
*g
;
2633 struct mips_got_entry
*entry
;
2635 /* GOT16 relocations against local symbols are followed by a LO16
2636 relocation; those against global symbols are not. Thus if the
2637 symbol was originally local, the GOT16 relocation should load the
2638 equivalent of %hi(VALUE), otherwise it should load VALUE itself. */
2640 value
= mips_elf_high (value
) << 16;
2642 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
2644 entry
= mips_elf_create_local_got_entry (abfd
, info
, ibfd
, g
, sgot
,
2645 value
, 0, NULL
, R_MIPS_GOT16
);
2647 return entry
->gotidx
;
2652 /* Returns the offset for the entry at the INDEXth position
2656 mips_elf_got_offset_from_index (bfd
*dynobj
, bfd
*output_bfd
,
2657 bfd
*input_bfd
, bfd_vma index
)
2661 struct mips_got_info
*g
;
2663 g
= mips_elf_got_info (dynobj
, &sgot
);
2664 gp
= _bfd_get_gp_value (output_bfd
)
2665 + mips_elf_adjust_gp (output_bfd
, g
, input_bfd
);
2667 return sgot
->output_section
->vma
+ sgot
->output_offset
+ index
- gp
;
2670 /* Create and return a local GOT entry for VALUE, which was calculated
2671 from a symbol belonging to INPUT_SECTON. Return NULL if it could not
2672 be created. If R_SYMNDX refers to a TLS symbol, create a TLS entry
2675 static struct mips_got_entry
*
2676 mips_elf_create_local_got_entry (bfd
*abfd
, struct bfd_link_info
*info
,
2677 bfd
*ibfd
, struct mips_got_info
*gg
,
2678 asection
*sgot
, bfd_vma value
,
2679 unsigned long r_symndx
,
2680 struct mips_elf_link_hash_entry
*h
,
2683 struct mips_got_entry entry
, **loc
;
2684 struct mips_got_info
*g
;
2685 struct mips_elf_link_hash_table
*htab
;
2687 htab
= mips_elf_hash_table (info
);
2691 entry
.d
.address
= value
;
2694 g
= mips_elf_got_for_ibfd (gg
, ibfd
);
2697 g
= mips_elf_got_for_ibfd (gg
, abfd
);
2698 BFD_ASSERT (g
!= NULL
);
2701 /* We might have a symbol, H, if it has been forced local. Use the
2702 global entry then. It doesn't matter whether an entry is local
2703 or global for TLS, since the dynamic linker does not
2704 automatically relocate TLS GOT entries. */
2705 BFD_ASSERT (h
== NULL
|| h
->root
.forced_local
);
2706 if (TLS_RELOC_P (r_type
))
2708 struct mips_got_entry
*p
;
2711 if (r_type
== R_MIPS_TLS_LDM
)
2713 entry
.tls_type
= GOT_TLS_LDM
;
2719 entry
.symndx
= r_symndx
;
2725 p
= (struct mips_got_entry
*)
2726 htab_find (g
->got_entries
, &entry
);
2732 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
2737 entry
.gotidx
= MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
++;
2740 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2745 memcpy (*loc
, &entry
, sizeof entry
);
2747 if (g
->assigned_gotno
> g
->local_gotno
)
2749 (*loc
)->gotidx
= -1;
2750 /* We didn't allocate enough space in the GOT. */
2751 (*_bfd_error_handler
)
2752 (_("not enough GOT space for local GOT entries"));
2753 bfd_set_error (bfd_error_bad_value
);
2757 MIPS_ELF_PUT_WORD (abfd
, value
,
2758 (sgot
->contents
+ entry
.gotidx
));
2760 /* These GOT entries need a dynamic relocation on VxWorks. */
2761 if (htab
->is_vxworks
)
2763 Elf_Internal_Rela outrel
;
2766 bfd_vma got_address
;
2768 s
= mips_elf_rel_dyn_section (info
, FALSE
);
2769 got_address
= (sgot
->output_section
->vma
2770 + sgot
->output_offset
2773 loc
= s
->contents
+ (s
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2774 outrel
.r_offset
= got_address
;
2775 outrel
.r_info
= ELF32_R_INFO (STN_UNDEF
, R_MIPS_32
);
2776 outrel
.r_addend
= value
;
2777 bfd_elf32_swap_reloca_out (abfd
, &outrel
, loc
);
2783 /* Sort the dynamic symbol table so that symbols that need GOT entries
2784 appear towards the end. This reduces the amount of GOT space
2785 required. MAX_LOCAL is used to set the number of local symbols
2786 known to be in the dynamic symbol table. During
2787 _bfd_mips_elf_size_dynamic_sections, this value is 1. Afterward, the
2788 section symbols are added and the count is higher. */
2791 mips_elf_sort_hash_table (struct bfd_link_info
*info
, unsigned long max_local
)
2793 struct mips_elf_hash_sort_data hsd
;
2794 struct mips_got_info
*g
;
2797 dynobj
= elf_hash_table (info
)->dynobj
;
2799 g
= mips_elf_got_info (dynobj
, NULL
);
2802 hsd
.max_unref_got_dynindx
=
2803 hsd
.min_got_dynindx
= elf_hash_table (info
)->dynsymcount
2804 /* In the multi-got case, assigned_gotno of the master got_info
2805 indicate the number of entries that aren't referenced in the
2806 primary GOT, but that must have entries because there are
2807 dynamic relocations that reference it. Since they aren't
2808 referenced, we move them to the end of the GOT, so that they
2809 don't prevent other entries that are referenced from getting
2810 too large offsets. */
2811 - (g
->next
? g
->assigned_gotno
: 0);
2812 hsd
.max_non_got_dynindx
= max_local
;
2813 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table
*)
2814 elf_hash_table (info
)),
2815 mips_elf_sort_hash_table_f
,
2818 /* There should have been enough room in the symbol table to
2819 accommodate both the GOT and non-GOT symbols. */
2820 BFD_ASSERT (hsd
.max_non_got_dynindx
<= hsd
.min_got_dynindx
);
2821 BFD_ASSERT ((unsigned long)hsd
.max_unref_got_dynindx
2822 <= elf_hash_table (info
)->dynsymcount
);
2824 /* Now we know which dynamic symbol has the lowest dynamic symbol
2825 table index in the GOT. */
2826 g
->global_gotsym
= hsd
.low
;
2831 /* If H needs a GOT entry, assign it the highest available dynamic
2832 index. Otherwise, assign it the lowest available dynamic
2836 mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry
*h
, void *data
)
2838 struct mips_elf_hash_sort_data
*hsd
= data
;
2840 if (h
->root
.root
.type
== bfd_link_hash_warning
)
2841 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2843 /* Symbols without dynamic symbol table entries aren't interesting
2845 if (h
->root
.dynindx
== -1)
2848 /* Global symbols that need GOT entries that are not explicitly
2849 referenced are marked with got offset 2. Those that are
2850 referenced get a 1, and those that don't need GOT entries get
2851 -1. Forced local symbols may also be marked with got offset 1,
2852 but are never given global GOT entries. */
2853 if (h
->root
.got
.offset
== 2)
2855 BFD_ASSERT (h
->tls_type
== GOT_NORMAL
);
2857 if (hsd
->max_unref_got_dynindx
== hsd
->min_got_dynindx
)
2858 hsd
->low
= (struct elf_link_hash_entry
*) h
;
2859 h
->root
.dynindx
= hsd
->max_unref_got_dynindx
++;
2861 else if (h
->root
.got
.offset
!= 1 || h
->forced_local
)
2862 h
->root
.dynindx
= hsd
->max_non_got_dynindx
++;
2865 BFD_ASSERT (h
->tls_type
== GOT_NORMAL
);
2867 h
->root
.dynindx
= --hsd
->min_got_dynindx
;
2868 hsd
->low
= (struct elf_link_hash_entry
*) h
;
2874 /* If H is a symbol that needs a global GOT entry, but has a dynamic
2875 symbol table index lower than any we've seen to date, record it for
2879 mips_elf_record_global_got_symbol (struct elf_link_hash_entry
*h
,
2880 bfd
*abfd
, struct bfd_link_info
*info
,
2881 struct mips_got_info
*g
,
2882 unsigned char tls_flag
)
2884 struct mips_got_entry entry
, **loc
;
2886 /* A global symbol in the GOT must also be in the dynamic symbol
2888 if (h
->dynindx
== -1)
2890 switch (ELF_ST_VISIBILITY (h
->other
))
2894 _bfd_mips_elf_hide_symbol (info
, h
, TRUE
);
2897 if (!bfd_elf_link_record_dynamic_symbol (info
, h
))
2901 /* Make sure we have a GOT to put this entry into. */
2902 BFD_ASSERT (g
!= NULL
);
2906 entry
.d
.h
= (struct mips_elf_link_hash_entry
*) h
;
2909 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
2912 /* If we've already marked this entry as needing GOT space, we don't
2913 need to do it again. */
2916 (*loc
)->tls_type
|= tls_flag
;
2920 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2926 entry
.tls_type
= tls_flag
;
2928 memcpy (*loc
, &entry
, sizeof entry
);
2930 if (h
->got
.offset
!= MINUS_ONE
)
2935 /* By setting this to a value other than -1, we are indicating that
2936 there needs to be a GOT entry for H. Avoid using zero, as the
2937 generic ELF copy_indirect_symbol tests for <= 0. */
2939 if (h
->forced_local
)
2946 /* Reserve space in G for a GOT entry containing the value of symbol
2947 SYMNDX in input bfd ABDF, plus ADDEND. */
2950 mips_elf_record_local_got_symbol (bfd
*abfd
, long symndx
, bfd_vma addend
,
2951 struct mips_got_info
*g
,
2952 unsigned char tls_flag
)
2954 struct mips_got_entry entry
, **loc
;
2957 entry
.symndx
= symndx
;
2958 entry
.d
.addend
= addend
;
2959 entry
.tls_type
= tls_flag
;
2960 loc
= (struct mips_got_entry
**)
2961 htab_find_slot (g
->got_entries
, &entry
, INSERT
);
2965 if (tls_flag
== GOT_TLS_GD
&& !((*loc
)->tls_type
& GOT_TLS_GD
))
2968 (*loc
)->tls_type
|= tls_flag
;
2970 else if (tls_flag
== GOT_TLS_IE
&& !((*loc
)->tls_type
& GOT_TLS_IE
))
2973 (*loc
)->tls_type
|= tls_flag
;
2981 entry
.tls_type
= tls_flag
;
2982 if (tls_flag
== GOT_TLS_IE
)
2984 else if (tls_flag
== GOT_TLS_GD
)
2986 else if (g
->tls_ldm_offset
== MINUS_ONE
)
2988 g
->tls_ldm_offset
= MINUS_TWO
;
2994 entry
.gotidx
= g
->local_gotno
++;
2998 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
3003 memcpy (*loc
, &entry
, sizeof entry
);
3008 /* Return the maximum number of GOT page entries required for RANGE. */
3011 mips_elf_pages_for_range (const struct mips_got_page_range
*range
)
3013 return (range
->max_addend
- range
->min_addend
+ 0x1ffff) >> 16;
3016 /* Record that ABFD has a page relocation against symbol SYMNDX and
3017 that ADDEND is the addend for that relocation. G is the GOT
3018 information. This function creates an upper bound on the number of
3019 GOT slots required; no attempt is made to combine references to
3020 non-overridable global symbols across multiple input files. */
3023 mips_elf_record_got_page_entry (bfd
*abfd
, long symndx
, bfd_signed_vma addend
,
3024 struct mips_got_info
*g
)
3026 struct mips_got_page_entry lookup
, *entry
;
3027 struct mips_got_page_range
**range_ptr
, *range
;
3028 bfd_vma old_pages
, new_pages
;
3031 /* Find the mips_got_page_entry hash table entry for this symbol. */
3033 lookup
.symndx
= symndx
;
3034 loc
= htab_find_slot (g
->got_page_entries
, &lookup
, INSERT
);
3038 /* Create a mips_got_page_entry if this is the first time we've
3040 entry
= (struct mips_got_page_entry
*) *loc
;
3043 entry
= bfd_alloc (abfd
, sizeof (*entry
));
3048 entry
->symndx
= symndx
;
3049 entry
->ranges
= NULL
;
3050 entry
->num_pages
= 0;
3054 /* Skip over ranges whose maximum extent cannot share a page entry
3056 range_ptr
= &entry
->ranges
;
3057 while (*range_ptr
&& addend
> (*range_ptr
)->max_addend
+ 0xffff)
3058 range_ptr
= &(*range_ptr
)->next
;
3060 /* If we scanned to the end of the list, or found a range whose
3061 minimum extent cannot share a page entry with ADDEND, create
3062 a new singleton range. */
3064 if (!range
|| addend
< range
->min_addend
- 0xffff)
3066 range
= bfd_alloc (abfd
, sizeof (*range
));
3070 range
->next
= *range_ptr
;
3071 range
->min_addend
= addend
;
3072 range
->max_addend
= addend
;
3080 /* Remember how many pages the old range contributed. */
3081 old_pages
= mips_elf_pages_for_range (range
);
3083 /* Update the ranges. */
3084 if (addend
< range
->min_addend
)
3085 range
->min_addend
= addend
;
3086 else if (addend
> range
->max_addend
)
3088 if (range
->next
&& addend
>= range
->next
->min_addend
- 0xffff)
3090 old_pages
+= mips_elf_pages_for_range (range
->next
);
3091 range
->max_addend
= range
->next
->max_addend
;
3092 range
->next
= range
->next
->next
;
3095 range
->max_addend
= addend
;
3098 /* Record any change in the total estimate. */
3099 new_pages
= mips_elf_pages_for_range (range
);
3100 if (old_pages
!= new_pages
)
3102 entry
->num_pages
+= new_pages
- old_pages
;
3103 g
->page_gotno
+= new_pages
- old_pages
;
3109 /* Compute the hash value of the bfd in a bfd2got hash entry. */
3112 mips_elf_bfd2got_entry_hash (const void *entry_
)
3114 const struct mips_elf_bfd2got_hash
*entry
3115 = (struct mips_elf_bfd2got_hash
*)entry_
;
3117 return entry
->bfd
->id
;
3120 /* Check whether two hash entries have the same bfd. */
3123 mips_elf_bfd2got_entry_eq (const void *entry1
, const void *entry2
)
3125 const struct mips_elf_bfd2got_hash
*e1
3126 = (const struct mips_elf_bfd2got_hash
*)entry1
;
3127 const struct mips_elf_bfd2got_hash
*e2
3128 = (const struct mips_elf_bfd2got_hash
*)entry2
;
3130 return e1
->bfd
== e2
->bfd
;
3133 /* In a multi-got link, determine the GOT to be used for IBFD. G must
3134 be the master GOT data. */
3136 static struct mips_got_info
*
3137 mips_elf_got_for_ibfd (struct mips_got_info
*g
, bfd
*ibfd
)
3139 struct mips_elf_bfd2got_hash e
, *p
;
3145 p
= htab_find (g
->bfd2got
, &e
);
3146 return p
? p
->g
: NULL
;
3149 /* Use BFD2GOT to find ABFD's got entry, creating one if none exists.
3150 Return NULL if an error occured. */
3152 static struct mips_got_info
*
3153 mips_elf_get_got_for_bfd (struct htab
*bfd2got
, bfd
*output_bfd
,
3156 struct mips_elf_bfd2got_hash bfdgot_entry
, *bfdgot
;
3157 struct mips_got_info
*g
;
3160 bfdgot_entry
.bfd
= input_bfd
;
3161 bfdgotp
= htab_find_slot (bfd2got
, &bfdgot_entry
, INSERT
);
3162 bfdgot
= (struct mips_elf_bfd2got_hash
*) *bfdgotp
;
3166 bfdgot
= ((struct mips_elf_bfd2got_hash
*)
3167 bfd_alloc (output_bfd
, sizeof (struct mips_elf_bfd2got_hash
)));
3173 g
= ((struct mips_got_info
*)
3174 bfd_alloc (output_bfd
, sizeof (struct mips_got_info
)));
3178 bfdgot
->bfd
= input_bfd
;
3181 g
->global_gotsym
= NULL
;
3182 g
->global_gotno
= 0;
3185 g
->assigned_gotno
= -1;
3187 g
->tls_assigned_gotno
= 0;
3188 g
->tls_ldm_offset
= MINUS_ONE
;
3189 g
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
3190 mips_elf_multi_got_entry_eq
, NULL
);
3191 if (g
->got_entries
== NULL
)
3194 g
->got_page_entries
= htab_try_create (1, mips_got_page_entry_hash
,
3195 mips_got_page_entry_eq
, NULL
);
3196 if (g
->got_page_entries
== NULL
)
3206 /* A htab_traverse callback for the entries in the master got.
3207 Create one separate got for each bfd that has entries in the global
3208 got, such that we can tell how many local and global entries each
3212 mips_elf_make_got_per_bfd (void **entryp
, void *p
)
3214 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
3215 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
3216 struct mips_got_info
*g
;
3218 g
= mips_elf_get_got_for_bfd (arg
->bfd2got
, arg
->obfd
, entry
->abfd
);
3225 /* Insert the GOT entry in the bfd's got entry hash table. */
3226 entryp
= htab_find_slot (g
->got_entries
, entry
, INSERT
);
3227 if (*entryp
!= NULL
)
3232 if (entry
->tls_type
)
3234 if (entry
->tls_type
& (GOT_TLS_GD
| GOT_TLS_LDM
))
3236 if (entry
->tls_type
& GOT_TLS_IE
)
3239 else if (entry
->symndx
>= 0 || entry
->d
.h
->forced_local
)
3247 /* A htab_traverse callback for the page entries in the master got.
3248 Associate each page entry with the bfd's got. */
3251 mips_elf_make_got_pages_per_bfd (void **entryp
, void *p
)
3253 struct mips_got_page_entry
*entry
= (struct mips_got_page_entry
*) *entryp
;
3254 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*) p
;
3255 struct mips_got_info
*g
;
3257 g
= mips_elf_get_got_for_bfd (arg
->bfd2got
, arg
->obfd
, entry
->abfd
);
3264 /* Insert the GOT entry in the bfd's got entry hash table. */
3265 entryp
= htab_find_slot (g
->got_page_entries
, entry
, INSERT
);
3266 if (*entryp
!= NULL
)
3270 g
->page_gotno
+= entry
->num_pages
;
3274 /* Consider merging the got described by BFD2GOT with TO, using the
3275 information given by ARG. Return -1 if this would lead to overflow,
3276 1 if they were merged successfully, and 0 if a merge failed due to
3277 lack of memory. (These values are chosen so that nonnegative return
3278 values can be returned by a htab_traverse callback.) */
3281 mips_elf_merge_got_with (struct mips_elf_bfd2got_hash
*bfd2got
,
3282 struct mips_got_info
*to
,
3283 struct mips_elf_got_per_bfd_arg
*arg
)
3285 struct mips_got_info
*from
= bfd2got
->g
;
3286 unsigned int estimate
;
3288 /* Work out how many page entries we would need for the combined GOT. */
3289 estimate
= arg
->max_pages
;
3290 if (estimate
>= from
->page_gotno
+ to
->page_gotno
)
3291 estimate
= from
->page_gotno
+ to
->page_gotno
;
3293 /* And conservatively estimate how many local, global and TLS entries
3295 estimate
+= (from
->local_gotno
3296 + from
->global_gotno
3302 /* Bail out if the combined GOT might be too big. */
3303 if (estimate
> arg
->max_count
)
3306 /* Commit to the merge. Record that TO is now the bfd for this got. */
3309 /* Transfer the bfd's got information from FROM to TO. */
3310 htab_traverse (from
->got_entries
, mips_elf_make_got_per_bfd
, arg
);
3311 if (arg
->obfd
== NULL
)
3314 htab_traverse (from
->got_page_entries
, mips_elf_make_got_pages_per_bfd
, arg
);
3315 if (arg
->obfd
== NULL
)
3318 /* We don't have to worry about releasing memory of the actual
3319 got entries, since they're all in the master got_entries hash
3321 htab_delete (from
->got_entries
);
3322 htab_delete (from
->got_page_entries
);
3326 /* Attempt to merge gots of different input bfds. Try to use as much
3327 as possible of the primary got, since it doesn't require explicit
3328 dynamic relocations, but don't use bfds that would reference global
3329 symbols out of the addressable range. Failing the primary got,
3330 attempt to merge with the current got, or finish the current got
3331 and then make make the new got current. */
3334 mips_elf_merge_gots (void **bfd2got_
, void *p
)
3336 struct mips_elf_bfd2got_hash
*bfd2got
3337 = (struct mips_elf_bfd2got_hash
*)*bfd2got_
;
3338 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
3339 struct mips_got_info
*g
;
3340 unsigned int estimate
;
3345 /* Work out the number of page, local and TLS entries. */
3346 estimate
= arg
->max_pages
;
3347 if (estimate
> g
->page_gotno
)
3348 estimate
= g
->page_gotno
;
3349 estimate
+= g
->local_gotno
+ g
->tls_gotno
;
3351 /* We place TLS GOT entries after both locals and globals. The globals
3352 for the primary GOT may overflow the normal GOT size limit, so be
3353 sure not to merge a GOT which requires TLS with the primary GOT in that
3354 case. This doesn't affect non-primary GOTs. */
3355 estimate
+= (g
->tls_gotno
> 0 ? arg
->global_count
: g
->global_gotno
);
3357 if (estimate
<= arg
->max_count
)
3359 /* If we don't have a primary GOT, use it as
3360 a starting point for the primary GOT. */
3363 arg
->primary
= bfd2got
->g
;
3367 /* Try merging with the primary GOT. */
3368 result
= mips_elf_merge_got_with (bfd2got
, arg
->primary
, arg
);
3373 /* If we can merge with the last-created got, do it. */
3376 result
= mips_elf_merge_got_with (bfd2got
, arg
->current
, arg
);
3381 /* Well, we couldn't merge, so create a new GOT. Don't check if it
3382 fits; if it turns out that it doesn't, we'll get relocation
3383 overflows anyway. */
3384 g
->next
= arg
->current
;
3390 /* Set the TLS GOT index for the GOT entry in ENTRYP. ENTRYP's NEXT field
3391 is null iff there is just a single GOT. */
3394 mips_elf_initialize_tls_index (void **entryp
, void *p
)
3396 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
3397 struct mips_got_info
*g
= p
;
3399 unsigned char tls_type
;
3401 /* We're only interested in TLS symbols. */
3402 if (entry
->tls_type
== 0)
3405 next_index
= MIPS_ELF_GOT_SIZE (entry
->abfd
) * (long) g
->tls_assigned_gotno
;
3407 if (entry
->symndx
== -1 && g
->next
== NULL
)
3409 /* A type (3) got entry in the single-GOT case. We use the symbol's
3410 hash table entry to track its index. */
3411 if (entry
->d
.h
->tls_type
& GOT_TLS_OFFSET_DONE
)
3413 entry
->d
.h
->tls_type
|= GOT_TLS_OFFSET_DONE
;
3414 entry
->d
.h
->tls_got_offset
= next_index
;
3415 tls_type
= entry
->d
.h
->tls_type
;
3419 if (entry
->tls_type
& GOT_TLS_LDM
)
3421 /* There are separate mips_got_entry objects for each input bfd
3422 that requires an LDM entry. Make sure that all LDM entries in
3423 a GOT resolve to the same index. */
3424 if (g
->tls_ldm_offset
!= MINUS_TWO
&& g
->tls_ldm_offset
!= MINUS_ONE
)
3426 entry
->gotidx
= g
->tls_ldm_offset
;
3429 g
->tls_ldm_offset
= next_index
;
3431 entry
->gotidx
= next_index
;
3432 tls_type
= entry
->tls_type
;
3435 /* Account for the entries we've just allocated. */
3436 if (tls_type
& (GOT_TLS_GD
| GOT_TLS_LDM
))
3437 g
->tls_assigned_gotno
+= 2;
3438 if (tls_type
& GOT_TLS_IE
)
3439 g
->tls_assigned_gotno
+= 1;
3444 /* If passed a NULL mips_got_info in the argument, set the marker used
3445 to tell whether a global symbol needs a got entry (in the primary
3446 got) to the given VALUE.
3448 If passed a pointer G to a mips_got_info in the argument (it must
3449 not be the primary GOT), compute the offset from the beginning of
3450 the (primary) GOT section to the entry in G corresponding to the
3451 global symbol. G's assigned_gotno must contain the index of the
3452 first available global GOT entry in G. VALUE must contain the size
3453 of a GOT entry in bytes. For each global GOT entry that requires a
3454 dynamic relocation, NEEDED_RELOCS is incremented, and the symbol is
3455 marked as not eligible for lazy resolution through a function
3458 mips_elf_set_global_got_offset (void **entryp
, void *p
)
3460 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
3461 struct mips_elf_set_global_got_offset_arg
*arg
3462 = (struct mips_elf_set_global_got_offset_arg
*)p
;
3463 struct mips_got_info
*g
= arg
->g
;
3465 if (g
&& entry
->tls_type
!= GOT_NORMAL
)
3466 arg
->needed_relocs
+=
3467 mips_tls_got_relocs (arg
->info
, entry
->tls_type
,
3468 entry
->symndx
== -1 ? &entry
->d
.h
->root
: NULL
);
3470 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1
3471 && entry
->d
.h
->root
.dynindx
!= -1
3472 && !entry
->d
.h
->forced_local
3473 && entry
->d
.h
->tls_type
== GOT_NORMAL
)
3477 BFD_ASSERT (g
->global_gotsym
== NULL
);
3479 entry
->gotidx
= arg
->value
* (long) g
->assigned_gotno
++;
3480 if (arg
->info
->shared
3481 || (elf_hash_table (arg
->info
)->dynamic_sections_created
3482 && entry
->d
.h
->root
.def_dynamic
3483 && !entry
->d
.h
->root
.def_regular
))
3484 ++arg
->needed_relocs
;
3487 entry
->d
.h
->root
.got
.offset
= arg
->value
;
3493 /* Mark any global symbols referenced in the GOT we are iterating over
3494 as inelligible for lazy resolution stubs. */
3496 mips_elf_set_no_stub (void **entryp
, void *p ATTRIBUTE_UNUSED
)
3498 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
3500 if (entry
->abfd
!= NULL
3501 && entry
->symndx
== -1
3502 && entry
->d
.h
->root
.dynindx
!= -1)
3503 entry
->d
.h
->no_fn_stub
= TRUE
;
3508 /* Follow indirect and warning hash entries so that each got entry
3509 points to the final symbol definition. P must point to a pointer
3510 to the hash table we're traversing. Since this traversal may
3511 modify the hash table, we set this pointer to NULL to indicate
3512 we've made a potentially-destructive change to the hash table, so
3513 the traversal must be restarted. */
3515 mips_elf_resolve_final_got_entry (void **entryp
, void *p
)
3517 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
3518 htab_t got_entries
= *(htab_t
*)p
;
3520 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1)
3522 struct mips_elf_link_hash_entry
*h
= entry
->d
.h
;
3524 while (h
->root
.root
.type
== bfd_link_hash_indirect
3525 || h
->root
.root
.type
== bfd_link_hash_warning
)
3526 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3528 if (entry
->d
.h
== h
)
3533 /* If we can't find this entry with the new bfd hash, re-insert
3534 it, and get the traversal restarted. */
3535 if (! htab_find (got_entries
, entry
))
3537 htab_clear_slot (got_entries
, entryp
);
3538 entryp
= htab_find_slot (got_entries
, entry
, INSERT
);
3541 /* Abort the traversal, since the whole table may have
3542 moved, and leave it up to the parent to restart the
3544 *(htab_t
*)p
= NULL
;
3547 /* We might want to decrement the global_gotno count, but it's
3548 either too early or too late for that at this point. */
3554 /* Turn indirect got entries in a got_entries table into their final
3557 mips_elf_resolve_final_got_entries (struct mips_got_info
*g
)
3563 got_entries
= g
->got_entries
;
3565 htab_traverse (got_entries
,
3566 mips_elf_resolve_final_got_entry
,
3569 while (got_entries
== NULL
);
3572 /* Return the offset of an input bfd IBFD's GOT from the beginning of
3575 mips_elf_adjust_gp (bfd
*abfd
, struct mips_got_info
*g
, bfd
*ibfd
)
3577 if (g
->bfd2got
== NULL
)
3580 g
= mips_elf_got_for_ibfd (g
, ibfd
);
3584 BFD_ASSERT (g
->next
);
3588 return (g
->local_gotno
+ g
->global_gotno
+ g
->tls_gotno
)
3589 * MIPS_ELF_GOT_SIZE (abfd
);
3592 /* Turn a single GOT that is too big for 16-bit addressing into
3593 a sequence of GOTs, each one 16-bit addressable. */
3596 mips_elf_multi_got (bfd
*abfd
, struct bfd_link_info
*info
,
3597 struct mips_got_info
*g
, asection
*got
,
3598 bfd_size_type pages
)
3600 struct mips_elf_got_per_bfd_arg got_per_bfd_arg
;
3601 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
3602 struct mips_got_info
*gg
;
3603 unsigned int assign
;
3605 g
->bfd2got
= htab_try_create (1, mips_elf_bfd2got_entry_hash
,
3606 mips_elf_bfd2got_entry_eq
, NULL
);
3607 if (g
->bfd2got
== NULL
)
3610 got_per_bfd_arg
.bfd2got
= g
->bfd2got
;
3611 got_per_bfd_arg
.obfd
= abfd
;
3612 got_per_bfd_arg
.info
= info
;
3614 /* Count how many GOT entries each input bfd requires, creating a
3615 map from bfd to got info while at that. */
3616 htab_traverse (g
->got_entries
, mips_elf_make_got_per_bfd
, &got_per_bfd_arg
);
3617 if (got_per_bfd_arg
.obfd
== NULL
)
3620 /* Also count how many page entries each input bfd requires. */
3621 htab_traverse (g
->got_page_entries
, mips_elf_make_got_pages_per_bfd
,
3623 if (got_per_bfd_arg
.obfd
== NULL
)
3626 got_per_bfd_arg
.current
= NULL
;
3627 got_per_bfd_arg
.primary
= NULL
;
3628 got_per_bfd_arg
.max_count
= ((MIPS_ELF_GOT_MAX_SIZE (info
)
3629 / MIPS_ELF_GOT_SIZE (abfd
))
3630 - MIPS_RESERVED_GOTNO (info
));
3631 got_per_bfd_arg
.max_pages
= pages
;
3632 /* The number of globals that will be included in the primary GOT.
3633 See the calls to mips_elf_set_global_got_offset below for more
3635 got_per_bfd_arg
.global_count
= g
->global_gotno
;
3637 /* Try to merge the GOTs of input bfds together, as long as they
3638 don't seem to exceed the maximum GOT size, choosing one of them
3639 to be the primary GOT. */
3640 htab_traverse (g
->bfd2got
, mips_elf_merge_gots
, &got_per_bfd_arg
);
3641 if (got_per_bfd_arg
.obfd
== NULL
)
3644 /* If we do not find any suitable primary GOT, create an empty one. */
3645 if (got_per_bfd_arg
.primary
== NULL
)
3647 g
->next
= (struct mips_got_info
*)
3648 bfd_alloc (abfd
, sizeof (struct mips_got_info
));
3649 if (g
->next
== NULL
)
3652 g
->next
->global_gotsym
= NULL
;
3653 g
->next
->global_gotno
= 0;
3654 g
->next
->local_gotno
= 0;
3655 g
->next
->page_gotno
= 0;
3656 g
->next
->tls_gotno
= 0;
3657 g
->next
->assigned_gotno
= 0;
3658 g
->next
->tls_assigned_gotno
= 0;
3659 g
->next
->tls_ldm_offset
= MINUS_ONE
;
3660 g
->next
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
3661 mips_elf_multi_got_entry_eq
,
3663 if (g
->next
->got_entries
== NULL
)
3665 g
->next
->got_page_entries
= htab_try_create (1, mips_got_page_entry_hash
,
3666 mips_got_page_entry_eq
,
3668 if (g
->next
->got_page_entries
== NULL
)
3670 g
->next
->bfd2got
= NULL
;
3673 g
->next
= got_per_bfd_arg
.primary
;
3674 g
->next
->next
= got_per_bfd_arg
.current
;
3676 /* GG is now the master GOT, and G is the primary GOT. */
3680 /* Map the output bfd to the primary got. That's what we're going
3681 to use for bfds that use GOT16 or GOT_PAGE relocations that we
3682 didn't mark in check_relocs, and we want a quick way to find it.
3683 We can't just use gg->next because we're going to reverse the
3686 struct mips_elf_bfd2got_hash
*bfdgot
;
3689 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
3690 (abfd
, sizeof (struct mips_elf_bfd2got_hash
));
3697 bfdgotp
= htab_find_slot (gg
->bfd2got
, bfdgot
, INSERT
);
3699 BFD_ASSERT (*bfdgotp
== NULL
);
3703 /* The IRIX dynamic linker requires every symbol that is referenced
3704 in a dynamic relocation to be present in the primary GOT, so
3705 arrange for them to appear after those that are actually
3708 GNU/Linux could very well do without it, but it would slow down
3709 the dynamic linker, since it would have to resolve every dynamic
3710 symbol referenced in other GOTs more than once, without help from
3711 the cache. Also, knowing that every external symbol has a GOT
3712 helps speed up the resolution of local symbols too, so GNU/Linux
3713 follows IRIX's practice.
3715 The number 2 is used by mips_elf_sort_hash_table_f to count
3716 global GOT symbols that are unreferenced in the primary GOT, with
3717 an initial dynamic index computed from gg->assigned_gotno, where
3718 the number of unreferenced global entries in the primary GOT is
3722 gg
->assigned_gotno
= gg
->global_gotno
- g
->global_gotno
;
3723 g
->global_gotno
= gg
->global_gotno
;
3724 set_got_offset_arg
.value
= 2;
3728 /* This could be used for dynamic linkers that don't optimize
3729 symbol resolution while applying relocations so as to use
3730 primary GOT entries or assuming the symbol is locally-defined.
3731 With this code, we assign lower dynamic indices to global
3732 symbols that are not referenced in the primary GOT, so that
3733 their entries can be omitted. */
3734 gg
->assigned_gotno
= 0;
3735 set_got_offset_arg
.value
= -1;
3738 /* Reorder dynamic symbols as described above (which behavior
3739 depends on the setting of VALUE). */
3740 set_got_offset_arg
.g
= NULL
;
3741 htab_traverse (gg
->got_entries
, mips_elf_set_global_got_offset
,
3742 &set_got_offset_arg
);
3743 set_got_offset_arg
.value
= 1;
3744 htab_traverse (g
->got_entries
, mips_elf_set_global_got_offset
,
3745 &set_got_offset_arg
);
3746 if (! mips_elf_sort_hash_table (info
, 1))
3749 /* Now go through the GOTs assigning them offset ranges.
3750 [assigned_gotno, local_gotno[ will be set to the range of local
3751 entries in each GOT. We can then compute the end of a GOT by
3752 adding local_gotno to global_gotno. We reverse the list and make
3753 it circular since then we'll be able to quickly compute the
3754 beginning of a GOT, by computing the end of its predecessor. To
3755 avoid special cases for the primary GOT, while still preserving
3756 assertions that are valid for both single- and multi-got links,
3757 we arrange for the main got struct to have the right number of
3758 global entries, but set its local_gotno such that the initial
3759 offset of the primary GOT is zero. Remember that the primary GOT
3760 will become the last item in the circular linked list, so it
3761 points back to the master GOT. */
3762 gg
->local_gotno
= -g
->global_gotno
;
3763 gg
->global_gotno
= g
->global_gotno
;
3770 struct mips_got_info
*gn
;
3772 assign
+= MIPS_RESERVED_GOTNO (info
);
3773 g
->assigned_gotno
= assign
;
3774 g
->local_gotno
+= assign
;
3775 g
->local_gotno
+= (pages
< g
->page_gotno
? pages
: g
->page_gotno
);
3776 assign
= g
->local_gotno
+ g
->global_gotno
+ g
->tls_gotno
;
3778 /* Take g out of the direct list, and push it onto the reversed
3779 list that gg points to. g->next is guaranteed to be nonnull after
3780 this operation, as required by mips_elf_initialize_tls_index. */
3785 /* Set up any TLS entries. We always place the TLS entries after
3786 all non-TLS entries. */
3787 g
->tls_assigned_gotno
= g
->local_gotno
+ g
->global_gotno
;
3788 htab_traverse (g
->got_entries
, mips_elf_initialize_tls_index
, g
);
3790 /* Move onto the next GOT. It will be a secondary GOT if nonull. */
3793 /* Mark global symbols in every non-primary GOT as ineligible for
3796 htab_traverse (g
->got_entries
, mips_elf_set_no_stub
, NULL
);
3800 got
->size
= (gg
->next
->local_gotno
3801 + gg
->next
->global_gotno
3802 + gg
->next
->tls_gotno
) * MIPS_ELF_GOT_SIZE (abfd
);
3808 /* Returns the first relocation of type r_type found, beginning with
3809 RELOCATION. RELEND is one-past-the-end of the relocation table. */
3811 static const Elf_Internal_Rela
*
3812 mips_elf_next_relocation (bfd
*abfd ATTRIBUTE_UNUSED
, unsigned int r_type
,
3813 const Elf_Internal_Rela
*relocation
,
3814 const Elf_Internal_Rela
*relend
)
3816 unsigned long r_symndx
= ELF_R_SYM (abfd
, relocation
->r_info
);
3818 while (relocation
< relend
)
3820 if (ELF_R_TYPE (abfd
, relocation
->r_info
) == r_type
3821 && ELF_R_SYM (abfd
, relocation
->r_info
) == r_symndx
)
3827 /* We didn't find it. */
3831 /* Return whether a relocation is against a local symbol. */
3834 mips_elf_local_relocation_p (bfd
*input_bfd
,
3835 const Elf_Internal_Rela
*relocation
,
3836 asection
**local_sections
,
3837 bfd_boolean check_forced
)
3839 unsigned long r_symndx
;
3840 Elf_Internal_Shdr
*symtab_hdr
;
3841 struct mips_elf_link_hash_entry
*h
;
3844 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
3845 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3846 extsymoff
= (elf_bad_symtab (input_bfd
)) ? 0 : symtab_hdr
->sh_info
;
3848 if (r_symndx
< extsymoff
)
3850 if (elf_bad_symtab (input_bfd
) && local_sections
[r_symndx
] != NULL
)
3855 /* Look up the hash table to check whether the symbol
3856 was forced local. */
3857 h
= (struct mips_elf_link_hash_entry
*)
3858 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
];
3859 /* Find the real hash-table entry for this symbol. */
3860 while (h
->root
.root
.type
== bfd_link_hash_indirect
3861 || h
->root
.root
.type
== bfd_link_hash_warning
)
3862 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3863 if (h
->root
.forced_local
)
3870 /* Sign-extend VALUE, which has the indicated number of BITS. */
3873 _bfd_mips_elf_sign_extend (bfd_vma value
, int bits
)
3875 if (value
& ((bfd_vma
) 1 << (bits
- 1)))
3876 /* VALUE is negative. */
3877 value
|= ((bfd_vma
) - 1) << bits
;
3882 /* Return non-zero if the indicated VALUE has overflowed the maximum
3883 range expressible by a signed number with the indicated number of
3887 mips_elf_overflow_p (bfd_vma value
, int bits
)
3889 bfd_signed_vma svalue
= (bfd_signed_vma
) value
;
3891 if (svalue
> (1 << (bits
- 1)) - 1)
3892 /* The value is too big. */
3894 else if (svalue
< -(1 << (bits
- 1)))
3895 /* The value is too small. */
3902 /* Calculate the %high function. */
3905 mips_elf_high (bfd_vma value
)
3907 return ((value
+ (bfd_vma
) 0x8000) >> 16) & 0xffff;
3910 /* Calculate the %higher function. */
3913 mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED
)
3916 return ((value
+ (bfd_vma
) 0x80008000) >> 32) & 0xffff;
3923 /* Calculate the %highest function. */
3926 mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED
)
3929 return ((value
+ (((bfd_vma
) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
3936 /* Create the .compact_rel section. */
3939 mips_elf_create_compact_rel_section
3940 (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3943 register asection
*s
;
3945 if (bfd_get_section_by_name (abfd
, ".compact_rel") == NULL
)
3947 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
3950 s
= bfd_make_section_with_flags (abfd
, ".compact_rel", flags
);
3952 || ! bfd_set_section_alignment (abfd
, s
,
3953 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
3956 s
->size
= sizeof (Elf32_External_compact_rel
);
3962 /* Create the .got section to hold the global offset table. */
3965 mips_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
,
3966 bfd_boolean maybe_exclude
)
3969 register asection
*s
;
3970 struct elf_link_hash_entry
*h
;
3971 struct bfd_link_hash_entry
*bh
;
3972 struct mips_got_info
*g
;
3974 struct mips_elf_link_hash_table
*htab
;
3976 htab
= mips_elf_hash_table (info
);
3978 /* This function may be called more than once. */
3979 s
= mips_elf_got_section (abfd
, TRUE
);
3982 if (! maybe_exclude
)
3983 s
->flags
&= ~SEC_EXCLUDE
;
3987 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3988 | SEC_LINKER_CREATED
);
3991 flags
|= SEC_EXCLUDE
;
3993 /* We have to use an alignment of 2**4 here because this is hardcoded
3994 in the function stub generation and in the linker script. */
3995 s
= bfd_make_section_with_flags (abfd
, ".got", flags
);
3997 || ! bfd_set_section_alignment (abfd
, s
, 4))
4000 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
4001 linker script because we don't want to define the symbol if we
4002 are not creating a global offset table. */
4004 if (! (_bfd_generic_link_add_one_symbol
4005 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
4006 0, NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
4009 h
= (struct elf_link_hash_entry
*) bh
;
4012 h
->type
= STT_OBJECT
;
4013 elf_hash_table (info
)->hgot
= h
;
4016 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
4019 amt
= sizeof (struct mips_got_info
);
4020 g
= bfd_alloc (abfd
, amt
);
4023 g
->global_gotsym
= NULL
;
4024 g
->global_gotno
= 0;
4026 g
->local_gotno
= MIPS_RESERVED_GOTNO (info
);
4028 g
->assigned_gotno
= MIPS_RESERVED_GOTNO (info
);
4031 g
->tls_ldm_offset
= MINUS_ONE
;
4032 g
->got_entries
= htab_try_create (1, mips_elf_got_entry_hash
,
4033 mips_elf_got_entry_eq
, NULL
);
4034 if (g
->got_entries
== NULL
)
4036 g
->got_page_entries
= htab_try_create (1, mips_got_page_entry_hash
,
4037 mips_got_page_entry_eq
, NULL
);
4038 if (g
->got_page_entries
== NULL
)
4040 mips_elf_section_data (s
)->u
.got_info
= g
;
4041 mips_elf_section_data (s
)->elf
.this_hdr
.sh_flags
4042 |= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
4044 /* VxWorks also needs a .got.plt section. */
4045 if (htab
->is_vxworks
)
4047 s
= bfd_make_section_with_flags (abfd
, ".got.plt",
4048 SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
4049 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
4050 if (s
== NULL
|| !bfd_set_section_alignment (abfd
, s
, 4))
4058 /* Return true if H refers to the special VxWorks __GOTT_BASE__ or
4059 __GOTT_INDEX__ symbols. These symbols are only special for
4060 shared objects; they are not used in executables. */
4063 is_gott_symbol (struct bfd_link_info
*info
, struct elf_link_hash_entry
*h
)
4065 return (mips_elf_hash_table (info
)->is_vxworks
4067 && (strcmp (h
->root
.root
.string
, "__GOTT_BASE__") == 0
4068 || strcmp (h
->root
.root
.string
, "__GOTT_INDEX__") == 0));
4071 /* Calculate the value produced by the RELOCATION (which comes from
4072 the INPUT_BFD). The ADDEND is the addend to use for this
4073 RELOCATION; RELOCATION->R_ADDEND is ignored.
4075 The result of the relocation calculation is stored in VALUEP.
4076 REQUIRE_JALXP indicates whether or not the opcode used with this
4077 relocation must be JALX.
4079 This function returns bfd_reloc_continue if the caller need take no
4080 further action regarding this relocation, bfd_reloc_notsupported if
4081 something goes dramatically wrong, bfd_reloc_overflow if an
4082 overflow occurs, and bfd_reloc_ok to indicate success. */
4084 static bfd_reloc_status_type
4085 mips_elf_calculate_relocation (bfd
*abfd
, bfd
*input_bfd
,
4086 asection
*input_section
,
4087 struct bfd_link_info
*info
,
4088 const Elf_Internal_Rela
*relocation
,
4089 bfd_vma addend
, reloc_howto_type
*howto
,
4090 Elf_Internal_Sym
*local_syms
,
4091 asection
**local_sections
, bfd_vma
*valuep
,
4092 const char **namep
, bfd_boolean
*require_jalxp
,
4093 bfd_boolean save_addend
)
4095 /* The eventual value we will return. */
4097 /* The address of the symbol against which the relocation is
4100 /* The final GP value to be used for the relocatable, executable, or
4101 shared object file being produced. */
4103 /* The place (section offset or address) of the storage unit being
4106 /* The value of GP used to create the relocatable object. */
4108 /* The offset into the global offset table at which the address of
4109 the relocation entry symbol, adjusted by the addend, resides
4110 during execution. */
4111 bfd_vma g
= MINUS_ONE
;
4112 /* The section in which the symbol referenced by the relocation is
4114 asection
*sec
= NULL
;
4115 struct mips_elf_link_hash_entry
*h
= NULL
;
4116 /* TRUE if the symbol referred to by this relocation is a local
4118 bfd_boolean local_p
, was_local_p
;
4119 /* TRUE if the symbol referred to by this relocation is "_gp_disp". */
4120 bfd_boolean gp_disp_p
= FALSE
;
4121 /* TRUE if the symbol referred to by this relocation is
4122 "__gnu_local_gp". */
4123 bfd_boolean gnu_local_gp_p
= FALSE
;
4124 Elf_Internal_Shdr
*symtab_hdr
;
4126 unsigned long r_symndx
;
4128 /* TRUE if overflow occurred during the calculation of the
4129 relocation value. */
4130 bfd_boolean overflowed_p
;
4131 /* TRUE if this relocation refers to a MIPS16 function. */
4132 bfd_boolean target_is_16_bit_code_p
= FALSE
;
4133 struct mips_elf_link_hash_table
*htab
;
4136 dynobj
= elf_hash_table (info
)->dynobj
;
4137 htab
= mips_elf_hash_table (info
);
4139 /* Parse the relocation. */
4140 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
4141 r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
4142 p
= (input_section
->output_section
->vma
4143 + input_section
->output_offset
4144 + relocation
->r_offset
);
4146 /* Assume that there will be no overflow. */
4147 overflowed_p
= FALSE
;
4149 /* Figure out whether or not the symbol is local, and get the offset
4150 used in the array of hash table entries. */
4151 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
4152 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
4153 local_sections
, FALSE
);
4154 was_local_p
= local_p
;
4155 if (! elf_bad_symtab (input_bfd
))
4156 extsymoff
= symtab_hdr
->sh_info
;
4159 /* The symbol table does not follow the rule that local symbols
4160 must come before globals. */
4164 /* Figure out the value of the symbol. */
4167 Elf_Internal_Sym
*sym
;
4169 sym
= local_syms
+ r_symndx
;
4170 sec
= local_sections
[r_symndx
];
4172 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
4173 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
4174 || (sec
->flags
& SEC_MERGE
))
4175 symbol
+= sym
->st_value
;
4176 if ((sec
->flags
& SEC_MERGE
)
4177 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4179 addend
= _bfd_elf_rel_local_sym (abfd
, sym
, &sec
, addend
);
4181 addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
4184 /* MIPS16 text labels should be treated as odd. */
4185 if (ELF_ST_IS_MIPS16 (sym
->st_other
))
4188 /* Record the name of this symbol, for our caller. */
4189 *namep
= bfd_elf_string_from_elf_section (input_bfd
,
4190 symtab_hdr
->sh_link
,
4193 *namep
= bfd_section_name (input_bfd
, sec
);
4195 target_is_16_bit_code_p
= ELF_ST_IS_MIPS16 (sym
->st_other
);
4199 /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ? */
4201 /* For global symbols we look up the symbol in the hash-table. */
4202 h
= ((struct mips_elf_link_hash_entry
*)
4203 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
]);
4204 /* Find the real hash-table entry for this symbol. */
4205 while (h
->root
.root
.type
== bfd_link_hash_indirect
4206 || h
->root
.root
.type
== bfd_link_hash_warning
)
4207 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
4209 /* Record the name of this symbol, for our caller. */
4210 *namep
= h
->root
.root
.root
.string
;
4212 /* See if this is the special _gp_disp symbol. Note that such a
4213 symbol must always be a global symbol. */
4214 if (strcmp (*namep
, "_gp_disp") == 0
4215 && ! NEWABI_P (input_bfd
))
4217 /* Relocations against _gp_disp are permitted only with
4218 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
4219 if (r_type
!= R_MIPS_HI16
&& r_type
!= R_MIPS_LO16
4220 && r_type
!= R_MIPS16_HI16
&& r_type
!= R_MIPS16_LO16
)
4221 return bfd_reloc_notsupported
;
4225 /* See if this is the special _gp symbol. Note that such a
4226 symbol must always be a global symbol. */
4227 else if (strcmp (*namep
, "__gnu_local_gp") == 0)
4228 gnu_local_gp_p
= TRUE
;
4231 /* If this symbol is defined, calculate its address. Note that
4232 _gp_disp is a magic symbol, always implicitly defined by the
4233 linker, so it's inappropriate to check to see whether or not
4235 else if ((h
->root
.root
.type
== bfd_link_hash_defined
4236 || h
->root
.root
.type
== bfd_link_hash_defweak
)
4237 && h
->root
.root
.u
.def
.section
)
4239 sec
= h
->root
.root
.u
.def
.section
;
4240 if (sec
->output_section
)
4241 symbol
= (h
->root
.root
.u
.def
.value
4242 + sec
->output_section
->vma
4243 + sec
->output_offset
);
4245 symbol
= h
->root
.root
.u
.def
.value
;
4247 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
4248 /* We allow relocations against undefined weak symbols, giving
4249 it the value zero, so that you can undefined weak functions
4250 and check to see if they exist by looking at their
4253 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
4254 && ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
4256 else if (strcmp (*namep
, SGI_COMPAT (input_bfd
)
4257 ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING") == 0)
4259 /* If this is a dynamic link, we should have created a
4260 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
4261 in in _bfd_mips_elf_create_dynamic_sections.
4262 Otherwise, we should define the symbol with a value of 0.
4263 FIXME: It should probably get into the symbol table
4265 BFD_ASSERT (! info
->shared
);
4266 BFD_ASSERT (bfd_get_section_by_name (abfd
, ".dynamic") == NULL
);
4269 else if (ELF_MIPS_IS_OPTIONAL (h
->root
.other
))
4271 /* This is an optional symbol - an Irix specific extension to the
4272 ELF spec. Ignore it for now.
4273 XXX - FIXME - there is more to the spec for OPTIONAL symbols
4274 than simply ignoring them, but we do not handle this for now.
4275 For information see the "64-bit ELF Object File Specification"
4276 which is available from here:
4277 http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf */
4282 if (! ((*info
->callbacks
->undefined_symbol
)
4283 (info
, h
->root
.root
.root
.string
, input_bfd
,
4284 input_section
, relocation
->r_offset
,
4285 (info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
)
4286 || ELF_ST_VISIBILITY (h
->root
.other
))))
4287 return bfd_reloc_undefined
;
4291 target_is_16_bit_code_p
= ELF_ST_IS_MIPS16 (h
->root
.other
);
4294 /* If this is a 32- or 64-bit call to a 16-bit function with a stub, we
4295 need to redirect the call to the stub, unless we're already *in*
4297 if (r_type
!= R_MIPS16_26
&& !info
->relocatable
4298 && ((h
!= NULL
&& h
->fn_stub
!= NULL
)
4300 && elf_tdata (input_bfd
)->local_stubs
!= NULL
4301 && elf_tdata (input_bfd
)->local_stubs
[r_symndx
] != NULL
))
4302 && !mips16_stub_section_p (input_bfd
, input_section
))
4304 /* This is a 32- or 64-bit call to a 16-bit function. We should
4305 have already noticed that we were going to need the
4308 sec
= elf_tdata (input_bfd
)->local_stubs
[r_symndx
];
4311 BFD_ASSERT (h
->need_fn_stub
);
4315 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
4316 /* The target is 16-bit, but the stub isn't. */
4317 target_is_16_bit_code_p
= FALSE
;
4319 /* If this is a 16-bit call to a 32- or 64-bit function with a stub, we
4320 need to redirect the call to the stub. */
4321 else if (r_type
== R_MIPS16_26
&& !info
->relocatable
4322 && ((h
!= NULL
&& (h
->call_stub
!= NULL
|| h
->call_fp_stub
!= NULL
))
4324 && elf_tdata (input_bfd
)->local_call_stubs
!= NULL
4325 && elf_tdata (input_bfd
)->local_call_stubs
[r_symndx
] != NULL
))
4326 && !target_is_16_bit_code_p
)
4329 sec
= elf_tdata (input_bfd
)->local_call_stubs
[r_symndx
];
4332 /* If both call_stub and call_fp_stub are defined, we can figure
4333 out which one to use by checking which one appears in the input
4335 if (h
->call_stub
!= NULL
&& h
->call_fp_stub
!= NULL
)
4340 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
4342 if (CALL_FP_STUB_P (bfd_get_section_name (input_bfd
, o
)))
4344 sec
= h
->call_fp_stub
;
4351 else if (h
->call_stub
!= NULL
)
4354 sec
= h
->call_fp_stub
;
4357 BFD_ASSERT (sec
->size
> 0);
4358 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
4361 /* Calls from 16-bit code to 32-bit code and vice versa require the
4362 special jalx instruction. */
4363 *require_jalxp
= (!info
->relocatable
4364 && (((r_type
== R_MIPS16_26
) && !target_is_16_bit_code_p
)
4365 || ((r_type
== R_MIPS_26
) && target_is_16_bit_code_p
)));
4367 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
4368 local_sections
, TRUE
);
4370 gp0
= _bfd_get_gp_value (input_bfd
);
4371 gp
= _bfd_get_gp_value (abfd
);
4373 gp
+= mips_elf_adjust_gp (abfd
, mips_elf_got_info (dynobj
, NULL
),
4379 /* If we haven't already determined the GOT offset, oand we're going
4380 to need it, get it now. */
4383 case R_MIPS_GOT_PAGE
:
4384 case R_MIPS_GOT_OFST
:
4385 /* We need to decay to GOT_DISP/addend if the symbol doesn't
4387 local_p
= local_p
|| _bfd_elf_symbol_refs_local_p (&h
->root
, info
, 1);
4388 if (local_p
|| r_type
== R_MIPS_GOT_OFST
)
4394 case R_MIPS_GOT_DISP
:
4395 case R_MIPS_GOT_HI16
:
4396 case R_MIPS_CALL_HI16
:
4397 case R_MIPS_GOT_LO16
:
4398 case R_MIPS_CALL_LO16
:
4400 case R_MIPS_TLS_GOTTPREL
:
4401 case R_MIPS_TLS_LDM
:
4402 /* Find the index into the GOT where this value is located. */
4403 if (r_type
== R_MIPS_TLS_LDM
)
4405 g
= mips_elf_local_got_index (abfd
, input_bfd
, info
,
4406 0, 0, NULL
, r_type
);
4408 return bfd_reloc_outofrange
;
4412 /* On VxWorks, CALL relocations should refer to the .got.plt
4413 entry, which is initialized to point at the PLT stub. */
4414 if (htab
->is_vxworks
4415 && (r_type
== R_MIPS_CALL_HI16
4416 || r_type
== R_MIPS_CALL_LO16
4417 || r_type
== R_MIPS_CALL16
))
4419 BFD_ASSERT (addend
== 0);
4420 BFD_ASSERT (h
->root
.needs_plt
);
4421 g
= mips_elf_gotplt_index (info
, &h
->root
);
4425 /* GOT_PAGE may take a non-zero addend, that is ignored in a
4426 GOT_PAGE relocation that decays to GOT_DISP because the
4427 symbol turns out to be global. The addend is then added
4429 BFD_ASSERT (addend
== 0 || r_type
== R_MIPS_GOT_PAGE
);
4430 g
= mips_elf_global_got_index (dynobj
, input_bfd
,
4431 &h
->root
, r_type
, info
);
4432 if (h
->tls_type
== GOT_NORMAL
4433 && (! elf_hash_table(info
)->dynamic_sections_created
4435 && (info
->symbolic
|| h
->root
.forced_local
)
4436 && h
->root
.def_regular
)))
4438 /* This is a static link or a -Bsymbolic link. The
4439 symbol is defined locally, or was forced to be local.
4440 We must initialize this entry in the GOT. */
4441 asection
*sgot
= mips_elf_got_section (dynobj
, FALSE
);
4442 MIPS_ELF_PUT_WORD (dynobj
, symbol
, sgot
->contents
+ g
);
4446 else if (!htab
->is_vxworks
4447 && (r_type
== R_MIPS_CALL16
|| (r_type
== R_MIPS_GOT16
)))
4448 /* The calculation below does not involve "g". */
4452 g
= mips_elf_local_got_index (abfd
, input_bfd
, info
,
4453 symbol
+ addend
, r_symndx
, h
, r_type
);
4455 return bfd_reloc_outofrange
;
4458 /* Convert GOT indices to actual offsets. */
4459 g
= mips_elf_got_offset_from_index (dynobj
, abfd
, input_bfd
, g
);
4463 /* Relocations against the VxWorks __GOTT_BASE__ and __GOTT_INDEX__
4464 symbols are resolved by the loader. Add them to .rela.dyn. */
4465 if (h
!= NULL
&& is_gott_symbol (info
, &h
->root
))
4467 Elf_Internal_Rela outrel
;
4471 s
= mips_elf_rel_dyn_section (info
, FALSE
);
4472 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4474 outrel
.r_offset
= (input_section
->output_section
->vma
4475 + input_section
->output_offset
4476 + relocation
->r_offset
);
4477 outrel
.r_info
= ELF32_R_INFO (h
->root
.dynindx
, r_type
);
4478 outrel
.r_addend
= addend
;
4479 bfd_elf32_swap_reloca_out (abfd
, &outrel
, loc
);
4481 /* If we've written this relocation for a readonly section,
4482 we need to set DF_TEXTREL again, so that we do not delete the
4484 if (MIPS_ELF_READONLY_SECTION (input_section
))
4485 info
->flags
|= DF_TEXTREL
;
4488 return bfd_reloc_ok
;
4491 /* Figure out what kind of relocation is being performed. */
4495 return bfd_reloc_continue
;
4498 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 16);
4499 overflowed_p
= mips_elf_overflow_p (value
, 16);
4506 || (!htab
->is_vxworks
4507 && htab
->root
.dynamic_sections_created
4509 && h
->root
.def_dynamic
4510 && !h
->root
.def_regular
))
4513 || h
->root
.root
.type
!= bfd_link_hash_undefweak
4514 || ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
4515 && (input_section
->flags
& SEC_ALLOC
) != 0)
4517 /* If we're creating a shared library, or this relocation is
4518 against a symbol in a shared library, then we can't know
4519 where the symbol will end up. So, we create a relocation
4520 record in the output, and leave the job up to the dynamic
4523 In VxWorks executables, references to external symbols
4524 are handled using copy relocs or PLT stubs, so there's
4525 no need to add a dynamic relocation here. */
4527 if (!mips_elf_create_dynamic_relocation (abfd
,
4535 return bfd_reloc_undefined
;
4539 if (r_type
!= R_MIPS_REL32
)
4540 value
= symbol
+ addend
;
4544 value
&= howto
->dst_mask
;
4548 value
= symbol
+ addend
- p
;
4549 value
&= howto
->dst_mask
;
4553 /* The calculation for R_MIPS16_26 is just the same as for an
4554 R_MIPS_26. It's only the storage of the relocated field into
4555 the output file that's different. That's handled in
4556 mips_elf_perform_relocation. So, we just fall through to the
4557 R_MIPS_26 case here. */
4560 value
= ((addend
| ((p
+ 4) & 0xf0000000)) + symbol
) >> 2;
4563 value
= (_bfd_mips_elf_sign_extend (addend
, 28) + symbol
) >> 2;
4564 if (h
->root
.root
.type
!= bfd_link_hash_undefweak
)
4565 overflowed_p
= (value
>> 26) != ((p
+ 4) >> 28);
4567 value
&= howto
->dst_mask
;
4570 case R_MIPS_TLS_DTPREL_HI16
:
4571 value
= (mips_elf_high (addend
+ symbol
- dtprel_base (info
))
4575 case R_MIPS_TLS_DTPREL_LO16
:
4576 case R_MIPS_TLS_DTPREL32
:
4577 case R_MIPS_TLS_DTPREL64
:
4578 value
= (symbol
+ addend
- dtprel_base (info
)) & howto
->dst_mask
;
4581 case R_MIPS_TLS_TPREL_HI16
:
4582 value
= (mips_elf_high (addend
+ symbol
- tprel_base (info
))
4586 case R_MIPS_TLS_TPREL_LO16
:
4587 value
= (symbol
+ addend
- tprel_base (info
)) & howto
->dst_mask
;
4594 value
= mips_elf_high (addend
+ symbol
);
4595 value
&= howto
->dst_mask
;
4599 /* For MIPS16 ABI code we generate this sequence
4600 0: li $v0,%hi(_gp_disp)
4601 4: addiupc $v1,%lo(_gp_disp)
4605 So the offsets of hi and lo relocs are the same, but the
4606 $pc is four higher than $t9 would be, so reduce
4607 both reloc addends by 4. */
4608 if (r_type
== R_MIPS16_HI16
)
4609 value
= mips_elf_high (addend
+ gp
- p
- 4);
4611 value
= mips_elf_high (addend
+ gp
- p
);
4612 overflowed_p
= mips_elf_overflow_p (value
, 16);
4619 value
= (symbol
+ addend
) & howto
->dst_mask
;
4622 /* See the comment for R_MIPS16_HI16 above for the reason
4623 for this conditional. */
4624 if (r_type
== R_MIPS16_LO16
)
4625 value
= addend
+ gp
- p
;
4627 value
= addend
+ gp
- p
+ 4;
4628 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
4629 for overflow. But, on, say, IRIX5, relocations against
4630 _gp_disp are normally generated from the .cpload
4631 pseudo-op. It generates code that normally looks like
4634 lui $gp,%hi(_gp_disp)
4635 addiu $gp,$gp,%lo(_gp_disp)
4638 Here $t9 holds the address of the function being called,
4639 as required by the MIPS ELF ABI. The R_MIPS_LO16
4640 relocation can easily overflow in this situation, but the
4641 R_MIPS_HI16 relocation will handle the overflow.
4642 Therefore, we consider this a bug in the MIPS ABI, and do
4643 not check for overflow here. */
4647 case R_MIPS_LITERAL
:
4648 /* Because we don't merge literal sections, we can handle this
4649 just like R_MIPS_GPREL16. In the long run, we should merge
4650 shared literals, and then we will need to additional work
4655 case R_MIPS16_GPREL
:
4656 /* The R_MIPS16_GPREL performs the same calculation as
4657 R_MIPS_GPREL16, but stores the relocated bits in a different
4658 order. We don't need to do anything special here; the
4659 differences are handled in mips_elf_perform_relocation. */
4660 case R_MIPS_GPREL16
:
4661 /* Only sign-extend the addend if it was extracted from the
4662 instruction. If the addend was separate, leave it alone,
4663 otherwise we may lose significant bits. */
4664 if (howto
->partial_inplace
)
4665 addend
= _bfd_mips_elf_sign_extend (addend
, 16);
4666 value
= symbol
+ addend
- gp
;
4667 /* If the symbol was local, any earlier relocatable links will
4668 have adjusted its addend with the gp offset, so compensate
4669 for that now. Don't do it for symbols forced local in this
4670 link, though, since they won't have had the gp offset applied
4674 overflowed_p
= mips_elf_overflow_p (value
, 16);
4679 /* VxWorks does not have separate local and global semantics for
4680 R_MIPS_GOT16; every relocation evaluates to "G". */
4681 if (!htab
->is_vxworks
&& local_p
)
4685 forced
= ! mips_elf_local_relocation_p (input_bfd
, relocation
,
4686 local_sections
, FALSE
);
4687 value
= mips_elf_got16_entry (abfd
, input_bfd
, info
,
4688 symbol
+ addend
, forced
);
4689 if (value
== MINUS_ONE
)
4690 return bfd_reloc_outofrange
;
4692 = mips_elf_got_offset_from_index (dynobj
, abfd
, input_bfd
, value
);
4693 overflowed_p
= mips_elf_overflow_p (value
, 16);
4700 case R_MIPS_TLS_GOTTPREL
:
4701 case R_MIPS_TLS_LDM
:
4702 case R_MIPS_GOT_DISP
:
4705 overflowed_p
= mips_elf_overflow_p (value
, 16);
4708 case R_MIPS_GPREL32
:
4709 value
= (addend
+ symbol
+ gp0
- gp
);
4711 value
&= howto
->dst_mask
;
4715 case R_MIPS_GNU_REL16_S2
:
4716 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 18) - p
;
4717 overflowed_p
= mips_elf_overflow_p (value
, 18);
4718 value
>>= howto
->rightshift
;
4719 value
&= howto
->dst_mask
;
4722 case R_MIPS_GOT_HI16
:
4723 case R_MIPS_CALL_HI16
:
4724 /* We're allowed to handle these two relocations identically.
4725 The dynamic linker is allowed to handle the CALL relocations
4726 differently by creating a lazy evaluation stub. */
4728 value
= mips_elf_high (value
);
4729 value
&= howto
->dst_mask
;
4732 case R_MIPS_GOT_LO16
:
4733 case R_MIPS_CALL_LO16
:
4734 value
= g
& howto
->dst_mask
;
4737 case R_MIPS_GOT_PAGE
:
4738 /* GOT_PAGE relocations that reference non-local symbols decay
4739 to GOT_DISP. The corresponding GOT_OFST relocation decays to
4743 value
= mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, NULL
);
4744 if (value
== MINUS_ONE
)
4745 return bfd_reloc_outofrange
;
4746 value
= mips_elf_got_offset_from_index (dynobj
, abfd
, input_bfd
, value
);
4747 overflowed_p
= mips_elf_overflow_p (value
, 16);
4750 case R_MIPS_GOT_OFST
:
4752 mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, &value
);
4755 overflowed_p
= mips_elf_overflow_p (value
, 16);
4759 value
= symbol
- addend
;
4760 value
&= howto
->dst_mask
;
4764 value
= mips_elf_higher (addend
+ symbol
);
4765 value
&= howto
->dst_mask
;
4768 case R_MIPS_HIGHEST
:
4769 value
= mips_elf_highest (addend
+ symbol
);
4770 value
&= howto
->dst_mask
;
4773 case R_MIPS_SCN_DISP
:
4774 value
= symbol
+ addend
- sec
->output_offset
;
4775 value
&= howto
->dst_mask
;
4779 /* This relocation is only a hint. In some cases, we optimize
4780 it into a bal instruction. But we don't try to optimize
4781 branches to the PLT; that will wind up wasting time. */
4782 if (h
!= NULL
&& h
->root
.plt
.offset
!= (bfd_vma
) -1)
4783 return bfd_reloc_continue
;
4784 value
= symbol
+ addend
;
4788 case R_MIPS_GNU_VTINHERIT
:
4789 case R_MIPS_GNU_VTENTRY
:
4790 /* We don't do anything with these at present. */
4791 return bfd_reloc_continue
;
4794 /* An unrecognized relocation type. */
4795 return bfd_reloc_notsupported
;
4798 /* Store the VALUE for our caller. */
4800 return overflowed_p
? bfd_reloc_overflow
: bfd_reloc_ok
;
4803 /* Obtain the field relocated by RELOCATION. */
4806 mips_elf_obtain_contents (reloc_howto_type
*howto
,
4807 const Elf_Internal_Rela
*relocation
,
4808 bfd
*input_bfd
, bfd_byte
*contents
)
4811 bfd_byte
*location
= contents
+ relocation
->r_offset
;
4813 /* Obtain the bytes. */
4814 x
= bfd_get ((8 * bfd_get_reloc_size (howto
)), input_bfd
, location
);
4819 /* It has been determined that the result of the RELOCATION is the
4820 VALUE. Use HOWTO to place VALUE into the output file at the
4821 appropriate position. The SECTION is the section to which the
4822 relocation applies. If REQUIRE_JALX is TRUE, then the opcode used
4823 for the relocation must be either JAL or JALX, and it is
4824 unconditionally converted to JALX.
4826 Returns FALSE if anything goes wrong. */
4829 mips_elf_perform_relocation (struct bfd_link_info
*info
,
4830 reloc_howto_type
*howto
,
4831 const Elf_Internal_Rela
*relocation
,
4832 bfd_vma value
, bfd
*input_bfd
,
4833 asection
*input_section
, bfd_byte
*contents
,
4834 bfd_boolean require_jalx
)
4838 int r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
4840 /* Figure out where the relocation is occurring. */
4841 location
= contents
+ relocation
->r_offset
;
4843 _bfd_mips16_elf_reloc_unshuffle (input_bfd
, r_type
, FALSE
, location
);
4845 /* Obtain the current value. */
4846 x
= mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
);
4848 /* Clear the field we are setting. */
4849 x
&= ~howto
->dst_mask
;
4851 /* Set the field. */
4852 x
|= (value
& howto
->dst_mask
);
4854 /* If required, turn JAL into JALX. */
4858 bfd_vma opcode
= x
>> 26;
4859 bfd_vma jalx_opcode
;
4861 /* Check to see if the opcode is already JAL or JALX. */
4862 if (r_type
== R_MIPS16_26
)
4864 ok
= ((opcode
== 0x6) || (opcode
== 0x7));
4869 ok
= ((opcode
== 0x3) || (opcode
== 0x1d));
4873 /* If the opcode is not JAL or JALX, there's a problem. */
4876 (*_bfd_error_handler
)
4877 (_("%B: %A+0x%lx: jump to stub routine which is not jal"),
4880 (unsigned long) relocation
->r_offset
);
4881 bfd_set_error (bfd_error_bad_value
);
4885 /* Make this the JALX opcode. */
4886 x
= (x
& ~(0x3f << 26)) | (jalx_opcode
<< 26);
4889 /* On the RM9000, bal is faster than jal, because bal uses branch
4890 prediction hardware. If we are linking for the RM9000, and we
4891 see jal, and bal fits, use it instead. Note that this
4892 transformation should be safe for all architectures. */
4893 if (bfd_get_mach (input_bfd
) == bfd_mach_mips9000
4894 && !info
->relocatable
4896 && ((r_type
== R_MIPS_26
&& (x
>> 26) == 0x3) /* jal addr */
4897 || (r_type
== R_MIPS_JALR
&& x
== 0x0320f809))) /* jalr t9 */
4903 addr
= (input_section
->output_section
->vma
4904 + input_section
->output_offset
4905 + relocation
->r_offset
4907 if (r_type
== R_MIPS_26
)
4908 dest
= (value
<< 2) | ((addr
>> 28) << 28);
4912 if (off
<= 0x1ffff && off
>= -0x20000)
4913 x
= 0x04110000 | (((bfd_vma
) off
>> 2) & 0xffff); /* bal addr */
4916 /* Put the value into the output. */
4917 bfd_put (8 * bfd_get_reloc_size (howto
), input_bfd
, x
, location
);
4919 _bfd_mips16_elf_reloc_shuffle(input_bfd
, r_type
, !info
->relocatable
,
4925 /* Returns TRUE if SECTION is a MIPS16 stub section. */
4928 mips16_stub_section_p (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*section
)
4930 const char *name
= bfd_get_section_name (abfd
, section
);
4932 return FN_STUB_P (name
) || CALL_STUB_P (name
) || CALL_FP_STUB_P (name
);
4935 /* Add room for N relocations to the .rel(a).dyn section in ABFD. */
4938 mips_elf_allocate_dynamic_relocations (bfd
*abfd
, struct bfd_link_info
*info
,
4942 struct mips_elf_link_hash_table
*htab
;
4944 htab
= mips_elf_hash_table (info
);
4945 s
= mips_elf_rel_dyn_section (info
, FALSE
);
4946 BFD_ASSERT (s
!= NULL
);
4948 if (htab
->is_vxworks
)
4949 s
->size
+= n
* MIPS_ELF_RELA_SIZE (abfd
);
4954 /* Make room for a null element. */
4955 s
->size
+= MIPS_ELF_REL_SIZE (abfd
);
4958 s
->size
+= n
* MIPS_ELF_REL_SIZE (abfd
);
4962 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
4963 is the original relocation, which is now being transformed into a
4964 dynamic relocation. The ADDENDP is adjusted if necessary; the
4965 caller should store the result in place of the original addend. */
4968 mips_elf_create_dynamic_relocation (bfd
*output_bfd
,
4969 struct bfd_link_info
*info
,
4970 const Elf_Internal_Rela
*rel
,
4971 struct mips_elf_link_hash_entry
*h
,
4972 asection
*sec
, bfd_vma symbol
,
4973 bfd_vma
*addendp
, asection
*input_section
)
4975 Elf_Internal_Rela outrel
[3];
4980 bfd_boolean defined_p
;
4981 struct mips_elf_link_hash_table
*htab
;
4983 htab
= mips_elf_hash_table (info
);
4984 r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
4985 dynobj
= elf_hash_table (info
)->dynobj
;
4986 sreloc
= mips_elf_rel_dyn_section (info
, FALSE
);
4987 BFD_ASSERT (sreloc
!= NULL
);
4988 BFD_ASSERT (sreloc
->contents
!= NULL
);
4989 BFD_ASSERT (sreloc
->reloc_count
* MIPS_ELF_REL_SIZE (output_bfd
)
4992 outrel
[0].r_offset
=
4993 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[0].r_offset
);
4994 if (ABI_64_P (output_bfd
))
4996 outrel
[1].r_offset
=
4997 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[1].r_offset
);
4998 outrel
[2].r_offset
=
4999 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[2].r_offset
);
5002 if (outrel
[0].r_offset
== MINUS_ONE
)
5003 /* The relocation field has been deleted. */
5006 if (outrel
[0].r_offset
== MINUS_TWO
)
5008 /* The relocation field has been converted into a relative value of
5009 some sort. Functions like _bfd_elf_write_section_eh_frame expect
5010 the field to be fully relocated, so add in the symbol's value. */
5015 /* We must now calculate the dynamic symbol table index to use
5016 in the relocation. */
5018 && (!h
->root
.def_regular
5019 || (info
->shared
&& !info
->symbolic
&& !h
->root
.forced_local
)))
5021 indx
= h
->root
.dynindx
;
5022 if (SGI_COMPAT (output_bfd
))
5023 defined_p
= h
->root
.def_regular
;
5025 /* ??? glibc's ld.so just adds the final GOT entry to the
5026 relocation field. It therefore treats relocs against
5027 defined symbols in the same way as relocs against
5028 undefined symbols. */
5033 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
5035 else if (sec
== NULL
|| sec
->owner
== NULL
)
5037 bfd_set_error (bfd_error_bad_value
);
5042 indx
= elf_section_data (sec
->output_section
)->dynindx
;
5045 asection
*osec
= htab
->root
.text_index_section
;
5046 indx
= elf_section_data (osec
)->dynindx
;
5052 /* Instead of generating a relocation using the section
5053 symbol, we may as well make it a fully relative
5054 relocation. We want to avoid generating relocations to
5055 local symbols because we used to generate them
5056 incorrectly, without adding the original symbol value,
5057 which is mandated by the ABI for section symbols. In
5058 order to give dynamic loaders and applications time to
5059 phase out the incorrect use, we refrain from emitting
5060 section-relative relocations. It's not like they're
5061 useful, after all. This should be a bit more efficient
5063 /* ??? Although this behavior is compatible with glibc's ld.so,
5064 the ABI says that relocations against STN_UNDEF should have
5065 a symbol value of 0. Irix rld honors this, so relocations
5066 against STN_UNDEF have no effect. */
5067 if (!SGI_COMPAT (output_bfd
))
5072 /* If the relocation was previously an absolute relocation and
5073 this symbol will not be referred to by the relocation, we must
5074 adjust it by the value we give it in the dynamic symbol table.
5075 Otherwise leave the job up to the dynamic linker. */
5076 if (defined_p
&& r_type
!= R_MIPS_REL32
)
5079 if (htab
->is_vxworks
)
5080 /* VxWorks uses non-relative relocations for this. */
5081 outrel
[0].r_info
= ELF32_R_INFO (indx
, R_MIPS_32
);
5083 /* The relocation is always an REL32 relocation because we don't
5084 know where the shared library will wind up at load-time. */
5085 outrel
[0].r_info
= ELF_R_INFO (output_bfd
, (unsigned long) indx
,
5088 /* For strict adherence to the ABI specification, we should
5089 generate a R_MIPS_64 relocation record by itself before the
5090 _REL32/_64 record as well, such that the addend is read in as
5091 a 64-bit value (REL32 is a 32-bit relocation, after all).
5092 However, since none of the existing ELF64 MIPS dynamic
5093 loaders seems to care, we don't waste space with these
5094 artificial relocations. If this turns out to not be true,
5095 mips_elf_allocate_dynamic_relocation() should be tweaked so
5096 as to make room for a pair of dynamic relocations per
5097 invocation if ABI_64_P, and here we should generate an
5098 additional relocation record with R_MIPS_64 by itself for a
5099 NULL symbol before this relocation record. */
5100 outrel
[1].r_info
= ELF_R_INFO (output_bfd
, 0,
5101 ABI_64_P (output_bfd
)
5104 outrel
[2].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_NONE
);
5106 /* Adjust the output offset of the relocation to reference the
5107 correct location in the output file. */
5108 outrel
[0].r_offset
+= (input_section
->output_section
->vma
5109 + input_section
->output_offset
);
5110 outrel
[1].r_offset
+= (input_section
->output_section
->vma
5111 + input_section
->output_offset
);
5112 outrel
[2].r_offset
+= (input_section
->output_section
->vma
5113 + input_section
->output_offset
);
5115 /* Put the relocation back out. We have to use the special
5116 relocation outputter in the 64-bit case since the 64-bit
5117 relocation format is non-standard. */
5118 if (ABI_64_P (output_bfd
))
5120 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
5121 (output_bfd
, &outrel
[0],
5123 + sreloc
->reloc_count
* sizeof (Elf64_Mips_External_Rel
)));
5125 else if (htab
->is_vxworks
)
5127 /* VxWorks uses RELA rather than REL dynamic relocations. */
5128 outrel
[0].r_addend
= *addendp
;
5129 bfd_elf32_swap_reloca_out
5130 (output_bfd
, &outrel
[0],
5132 + sreloc
->reloc_count
* sizeof (Elf32_External_Rela
)));
5135 bfd_elf32_swap_reloc_out
5136 (output_bfd
, &outrel
[0],
5137 (sreloc
->contents
+ sreloc
->reloc_count
* sizeof (Elf32_External_Rel
)));
5139 /* We've now added another relocation. */
5140 ++sreloc
->reloc_count
;
5142 /* Make sure the output section is writable. The dynamic linker
5143 will be writing to it. */
5144 elf_section_data (input_section
->output_section
)->this_hdr
.sh_flags
5147 /* On IRIX5, make an entry of compact relocation info. */
5148 if (IRIX_COMPAT (output_bfd
) == ict_irix5
)
5150 asection
*scpt
= bfd_get_section_by_name (dynobj
, ".compact_rel");
5155 Elf32_crinfo cptrel
;
5157 mips_elf_set_cr_format (cptrel
, CRF_MIPS_LONG
);
5158 cptrel
.vaddr
= (rel
->r_offset
5159 + input_section
->output_section
->vma
5160 + input_section
->output_offset
);
5161 if (r_type
== R_MIPS_REL32
)
5162 mips_elf_set_cr_type (cptrel
, CRT_MIPS_REL32
);
5164 mips_elf_set_cr_type (cptrel
, CRT_MIPS_WORD
);
5165 mips_elf_set_cr_dist2to (cptrel
, 0);
5166 cptrel
.konst
= *addendp
;
5168 cr
= (scpt
->contents
5169 + sizeof (Elf32_External_compact_rel
));
5170 mips_elf_set_cr_relvaddr (cptrel
, 0);
5171 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
5172 ((Elf32_External_crinfo
*) cr
5173 + scpt
->reloc_count
));
5174 ++scpt
->reloc_count
;
5178 /* If we've written this relocation for a readonly section,
5179 we need to set DF_TEXTREL again, so that we do not delete the
5181 if (MIPS_ELF_READONLY_SECTION (input_section
))
5182 info
->flags
|= DF_TEXTREL
;
5187 /* Return the MACH for a MIPS e_flags value. */
5190 _bfd_elf_mips_mach (flagword flags
)
5192 switch (flags
& EF_MIPS_MACH
)
5194 case E_MIPS_MACH_3900
:
5195 return bfd_mach_mips3900
;
5197 case E_MIPS_MACH_4010
:
5198 return bfd_mach_mips4010
;
5200 case E_MIPS_MACH_4100
:
5201 return bfd_mach_mips4100
;
5203 case E_MIPS_MACH_4111
:
5204 return bfd_mach_mips4111
;
5206 case E_MIPS_MACH_4120
:
5207 return bfd_mach_mips4120
;
5209 case E_MIPS_MACH_4650
:
5210 return bfd_mach_mips4650
;
5212 case E_MIPS_MACH_5400
:
5213 return bfd_mach_mips5400
;
5215 case E_MIPS_MACH_5500
:
5216 return bfd_mach_mips5500
;
5218 case E_MIPS_MACH_9000
:
5219 return bfd_mach_mips9000
;
5221 case E_MIPS_MACH_SB1
:
5222 return bfd_mach_mips_sb1
;
5224 case E_MIPS_MACH_LS2E
:
5225 return bfd_mach_mips_loongson_2e
;
5227 case E_MIPS_MACH_LS2F
:
5228 return bfd_mach_mips_loongson_2f
;
5230 case E_MIPS_MACH_OCTEON
:
5231 return bfd_mach_mips_octeon
;
5234 switch (flags
& EF_MIPS_ARCH
)
5238 return bfd_mach_mips3000
;
5241 return bfd_mach_mips6000
;
5244 return bfd_mach_mips4000
;
5247 return bfd_mach_mips8000
;
5250 return bfd_mach_mips5
;
5252 case E_MIPS_ARCH_32
:
5253 return bfd_mach_mipsisa32
;
5255 case E_MIPS_ARCH_64
:
5256 return bfd_mach_mipsisa64
;
5258 case E_MIPS_ARCH_32R2
:
5259 return bfd_mach_mipsisa32r2
;
5261 case E_MIPS_ARCH_64R2
:
5262 return bfd_mach_mipsisa64r2
;
5269 /* Return printable name for ABI. */
5271 static INLINE
char *
5272 elf_mips_abi_name (bfd
*abfd
)
5276 flags
= elf_elfheader (abfd
)->e_flags
;
5277 switch (flags
& EF_MIPS_ABI
)
5280 if (ABI_N32_P (abfd
))
5282 else if (ABI_64_P (abfd
))
5286 case E_MIPS_ABI_O32
:
5288 case E_MIPS_ABI_O64
:
5290 case E_MIPS_ABI_EABI32
:
5292 case E_MIPS_ABI_EABI64
:
5295 return "unknown abi";
5299 /* MIPS ELF uses two common sections. One is the usual one, and the
5300 other is for small objects. All the small objects are kept
5301 together, and then referenced via the gp pointer, which yields
5302 faster assembler code. This is what we use for the small common
5303 section. This approach is copied from ecoff.c. */
5304 static asection mips_elf_scom_section
;
5305 static asymbol mips_elf_scom_symbol
;
5306 static asymbol
*mips_elf_scom_symbol_ptr
;
5308 /* MIPS ELF also uses an acommon section, which represents an
5309 allocated common symbol which may be overridden by a
5310 definition in a shared library. */
5311 static asection mips_elf_acom_section
;
5312 static asymbol mips_elf_acom_symbol
;
5313 static asymbol
*mips_elf_acom_symbol_ptr
;
5315 /* Handle the special MIPS section numbers that a symbol may use.
5316 This is used for both the 32-bit and the 64-bit ABI. */
5319 _bfd_mips_elf_symbol_processing (bfd
*abfd
, asymbol
*asym
)
5321 elf_symbol_type
*elfsym
;
5323 elfsym
= (elf_symbol_type
*) asym
;
5324 switch (elfsym
->internal_elf_sym
.st_shndx
)
5326 case SHN_MIPS_ACOMMON
:
5327 /* This section is used in a dynamically linked executable file.
5328 It is an allocated common section. The dynamic linker can
5329 either resolve these symbols to something in a shared
5330 library, or it can just leave them here. For our purposes,
5331 we can consider these symbols to be in a new section. */
5332 if (mips_elf_acom_section
.name
== NULL
)
5334 /* Initialize the acommon section. */
5335 mips_elf_acom_section
.name
= ".acommon";
5336 mips_elf_acom_section
.flags
= SEC_ALLOC
;
5337 mips_elf_acom_section
.output_section
= &mips_elf_acom_section
;
5338 mips_elf_acom_section
.symbol
= &mips_elf_acom_symbol
;
5339 mips_elf_acom_section
.symbol_ptr_ptr
= &mips_elf_acom_symbol_ptr
;
5340 mips_elf_acom_symbol
.name
= ".acommon";
5341 mips_elf_acom_symbol
.flags
= BSF_SECTION_SYM
;
5342 mips_elf_acom_symbol
.section
= &mips_elf_acom_section
;
5343 mips_elf_acom_symbol_ptr
= &mips_elf_acom_symbol
;
5345 asym
->section
= &mips_elf_acom_section
;
5349 /* Common symbols less than the GP size are automatically
5350 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
5351 if (asym
->value
> elf_gp_size (abfd
)
5352 || ELF_ST_TYPE (elfsym
->internal_elf_sym
.st_info
) == STT_TLS
5353 || IRIX_COMPAT (abfd
) == ict_irix6
)
5356 case SHN_MIPS_SCOMMON
:
5357 if (mips_elf_scom_section
.name
== NULL
)
5359 /* Initialize the small common section. */
5360 mips_elf_scom_section
.name
= ".scommon";
5361 mips_elf_scom_section
.flags
= SEC_IS_COMMON
;
5362 mips_elf_scom_section
.output_section
= &mips_elf_scom_section
;
5363 mips_elf_scom_section
.symbol
= &mips_elf_scom_symbol
;
5364 mips_elf_scom_section
.symbol_ptr_ptr
= &mips_elf_scom_symbol_ptr
;
5365 mips_elf_scom_symbol
.name
= ".scommon";
5366 mips_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
5367 mips_elf_scom_symbol
.section
= &mips_elf_scom_section
;
5368 mips_elf_scom_symbol_ptr
= &mips_elf_scom_symbol
;
5370 asym
->section
= &mips_elf_scom_section
;
5371 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
5374 case SHN_MIPS_SUNDEFINED
:
5375 asym
->section
= bfd_und_section_ptr
;
5380 asection
*section
= bfd_get_section_by_name (abfd
, ".text");
5382 BFD_ASSERT (SGI_COMPAT (abfd
));
5383 if (section
!= NULL
)
5385 asym
->section
= section
;
5386 /* MIPS_TEXT is a bit special, the address is not an offset
5387 to the base of the .text section. So substract the section
5388 base address to make it an offset. */
5389 asym
->value
-= section
->vma
;
5396 asection
*section
= bfd_get_section_by_name (abfd
, ".data");
5398 BFD_ASSERT (SGI_COMPAT (abfd
));
5399 if (section
!= NULL
)
5401 asym
->section
= section
;
5402 /* MIPS_DATA is a bit special, the address is not an offset
5403 to the base of the .data section. So substract the section
5404 base address to make it an offset. */
5405 asym
->value
-= section
->vma
;
5412 /* Implement elf_backend_eh_frame_address_size. This differs from
5413 the default in the way it handles EABI64.
5415 EABI64 was originally specified as an LP64 ABI, and that is what
5416 -mabi=eabi normally gives on a 64-bit target. However, gcc has
5417 historically accepted the combination of -mabi=eabi and -mlong32,
5418 and this ILP32 variation has become semi-official over time.
5419 Both forms use elf32 and have pointer-sized FDE addresses.
5421 If an EABI object was generated by GCC 4.0 or above, it will have
5422 an empty .gcc_compiled_longXX section, where XX is the size of longs
5423 in bits. Unfortunately, ILP32 objects generated by earlier compilers
5424 have no special marking to distinguish them from LP64 objects.
5426 We don't want users of the official LP64 ABI to be punished for the
5427 existence of the ILP32 variant, but at the same time, we don't want
5428 to mistakenly interpret pre-4.0 ILP32 objects as being LP64 objects.
5429 We therefore take the following approach:
5431 - If ABFD contains a .gcc_compiled_longXX section, use it to
5432 determine the pointer size.
5434 - Otherwise check the type of the first relocation. Assume that
5435 the LP64 ABI is being used if the relocation is of type R_MIPS_64.
5439 The second check is enough to detect LP64 objects generated by pre-4.0
5440 compilers because, in the kind of output generated by those compilers,
5441 the first relocation will be associated with either a CIE personality
5442 routine or an FDE start address. Furthermore, the compilers never
5443 used a special (non-pointer) encoding for this ABI.
5445 Checking the relocation type should also be safe because there is no
5446 reason to use R_MIPS_64 in an ILP32 object. Pre-4.0 compilers never
5450 _bfd_mips_elf_eh_frame_address_size (bfd
*abfd
, asection
*sec
)
5452 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
5454 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
5456 bfd_boolean long32_p
, long64_p
;
5458 long32_p
= bfd_get_section_by_name (abfd
, ".gcc_compiled_long32") != 0;
5459 long64_p
= bfd_get_section_by_name (abfd
, ".gcc_compiled_long64") != 0;
5460 if (long32_p
&& long64_p
)
5467 if (sec
->reloc_count
> 0
5468 && elf_section_data (sec
)->relocs
!= NULL
5469 && (ELF32_R_TYPE (elf_section_data (sec
)->relocs
[0].r_info
)
5478 /* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
5479 relocations against two unnamed section symbols to resolve to the
5480 same address. For example, if we have code like:
5482 lw $4,%got_disp(.data)($gp)
5483 lw $25,%got_disp(.text)($gp)
5486 then the linker will resolve both relocations to .data and the program
5487 will jump there rather than to .text.
5489 We can work around this problem by giving names to local section symbols.
5490 This is also what the MIPSpro tools do. */
5493 _bfd_mips_elf_name_local_section_symbols (bfd
*abfd
)
5495 return SGI_COMPAT (abfd
);
5498 /* Work over a section just before writing it out. This routine is
5499 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
5500 sections that need the SHF_MIPS_GPREL flag by name; there has to be
5504 _bfd_mips_elf_section_processing (bfd
*abfd
, Elf_Internal_Shdr
*hdr
)
5506 if (hdr
->sh_type
== SHT_MIPS_REGINFO
5507 && hdr
->sh_size
> 0)
5511 BFD_ASSERT (hdr
->sh_size
== sizeof (Elf32_External_RegInfo
));
5512 BFD_ASSERT (hdr
->contents
== NULL
);
5515 hdr
->sh_offset
+ sizeof (Elf32_External_RegInfo
) - 4,
5518 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
5519 if (bfd_bwrite (buf
, 4, abfd
) != 4)
5523 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
5524 && hdr
->bfd_section
!= NULL
5525 && mips_elf_section_data (hdr
->bfd_section
) != NULL
5526 && mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
!= NULL
)
5528 bfd_byte
*contents
, *l
, *lend
;
5530 /* We stored the section contents in the tdata field in the
5531 set_section_contents routine. We save the section contents
5532 so that we don't have to read them again.
5533 At this point we know that elf_gp is set, so we can look
5534 through the section contents to see if there is an
5535 ODK_REGINFO structure. */
5537 contents
= mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
;
5539 lend
= contents
+ hdr
->sh_size
;
5540 while (l
+ sizeof (Elf_External_Options
) <= lend
)
5542 Elf_Internal_Options intopt
;
5544 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
5546 if (intopt
.size
< sizeof (Elf_External_Options
))
5548 (*_bfd_error_handler
)
5549 (_("%B: Warning: bad `%s' option size %u smaller than its header"),
5550 abfd
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
), intopt
.size
);
5553 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
5560 + sizeof (Elf_External_Options
)
5561 + (sizeof (Elf64_External_RegInfo
) - 8)),
5564 H_PUT_64 (abfd
, elf_gp (abfd
), buf
);
5565 if (bfd_bwrite (buf
, 8, abfd
) != 8)
5568 else if (intopt
.kind
== ODK_REGINFO
)
5575 + sizeof (Elf_External_Options
)
5576 + (sizeof (Elf32_External_RegInfo
) - 4)),
5579 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
5580 if (bfd_bwrite (buf
, 4, abfd
) != 4)
5587 if (hdr
->bfd_section
!= NULL
)
5589 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
5591 if (strcmp (name
, ".sdata") == 0
5592 || strcmp (name
, ".lit8") == 0
5593 || strcmp (name
, ".lit4") == 0)
5595 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
5596 hdr
->sh_type
= SHT_PROGBITS
;
5598 else if (strcmp (name
, ".sbss") == 0)
5600 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
5601 hdr
->sh_type
= SHT_NOBITS
;
5603 else if (strcmp (name
, ".srdata") == 0)
5605 hdr
->sh_flags
|= SHF_ALLOC
| SHF_MIPS_GPREL
;
5606 hdr
->sh_type
= SHT_PROGBITS
;
5608 else if (strcmp (name
, ".compact_rel") == 0)
5611 hdr
->sh_type
= SHT_PROGBITS
;
5613 else if (strcmp (name
, ".rtproc") == 0)
5615 if (hdr
->sh_addralign
!= 0 && hdr
->sh_entsize
== 0)
5617 unsigned int adjust
;
5619 adjust
= hdr
->sh_size
% hdr
->sh_addralign
;
5621 hdr
->sh_size
+= hdr
->sh_addralign
- adjust
;
5629 /* Handle a MIPS specific section when reading an object file. This
5630 is called when elfcode.h finds a section with an unknown type.
5631 This routine supports both the 32-bit and 64-bit ELF ABI.
5633 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
5637 _bfd_mips_elf_section_from_shdr (bfd
*abfd
,
5638 Elf_Internal_Shdr
*hdr
,
5644 /* There ought to be a place to keep ELF backend specific flags, but
5645 at the moment there isn't one. We just keep track of the
5646 sections by their name, instead. Fortunately, the ABI gives
5647 suggested names for all the MIPS specific sections, so we will
5648 probably get away with this. */
5649 switch (hdr
->sh_type
)
5651 case SHT_MIPS_LIBLIST
:
5652 if (strcmp (name
, ".liblist") != 0)
5656 if (strcmp (name
, ".msym") != 0)
5659 case SHT_MIPS_CONFLICT
:
5660 if (strcmp (name
, ".conflict") != 0)
5663 case SHT_MIPS_GPTAB
:
5664 if (! CONST_STRNEQ (name
, ".gptab."))
5667 case SHT_MIPS_UCODE
:
5668 if (strcmp (name
, ".ucode") != 0)
5671 case SHT_MIPS_DEBUG
:
5672 if (strcmp (name
, ".mdebug") != 0)
5674 flags
= SEC_DEBUGGING
;
5676 case SHT_MIPS_REGINFO
:
5677 if (strcmp (name
, ".reginfo") != 0
5678 || hdr
->sh_size
!= sizeof (Elf32_External_RegInfo
))
5680 flags
= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_SIZE
);
5682 case SHT_MIPS_IFACE
:
5683 if (strcmp (name
, ".MIPS.interfaces") != 0)
5686 case SHT_MIPS_CONTENT
:
5687 if (! CONST_STRNEQ (name
, ".MIPS.content"))
5690 case SHT_MIPS_OPTIONS
:
5691 if (!MIPS_ELF_OPTIONS_SECTION_NAME_P (name
))
5694 case SHT_MIPS_DWARF
:
5695 if (! CONST_STRNEQ (name
, ".debug_")
5696 && ! CONST_STRNEQ (name
, ".zdebug_"))
5699 case SHT_MIPS_SYMBOL_LIB
:
5700 if (strcmp (name
, ".MIPS.symlib") != 0)
5703 case SHT_MIPS_EVENTS
:
5704 if (! CONST_STRNEQ (name
, ".MIPS.events")
5705 && ! CONST_STRNEQ (name
, ".MIPS.post_rel"))
5712 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
5717 if (! bfd_set_section_flags (abfd
, hdr
->bfd_section
,
5718 (bfd_get_section_flags (abfd
,
5724 /* FIXME: We should record sh_info for a .gptab section. */
5726 /* For a .reginfo section, set the gp value in the tdata information
5727 from the contents of this section. We need the gp value while
5728 processing relocs, so we just get it now. The .reginfo section
5729 is not used in the 64-bit MIPS ELF ABI. */
5730 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
5732 Elf32_External_RegInfo ext
;
5735 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
,
5736 &ext
, 0, sizeof ext
))
5738 bfd_mips_elf32_swap_reginfo_in (abfd
, &ext
, &s
);
5739 elf_gp (abfd
) = s
.ri_gp_value
;
5742 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
5743 set the gp value based on what we find. We may see both
5744 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
5745 they should agree. */
5746 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
)
5748 bfd_byte
*contents
, *l
, *lend
;
5750 contents
= bfd_malloc (hdr
->sh_size
);
5751 if (contents
== NULL
)
5753 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
,
5760 lend
= contents
+ hdr
->sh_size
;
5761 while (l
+ sizeof (Elf_External_Options
) <= lend
)
5763 Elf_Internal_Options intopt
;
5765 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
5767 if (intopt
.size
< sizeof (Elf_External_Options
))
5769 (*_bfd_error_handler
)
5770 (_("%B: Warning: bad `%s' option size %u smaller than its header"),
5771 abfd
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
), intopt
.size
);
5774 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
5776 Elf64_Internal_RegInfo intreg
;
5778 bfd_mips_elf64_swap_reginfo_in
5780 ((Elf64_External_RegInfo
*)
5781 (l
+ sizeof (Elf_External_Options
))),
5783 elf_gp (abfd
) = intreg
.ri_gp_value
;
5785 else if (intopt
.kind
== ODK_REGINFO
)
5787 Elf32_RegInfo intreg
;
5789 bfd_mips_elf32_swap_reginfo_in
5791 ((Elf32_External_RegInfo
*)
5792 (l
+ sizeof (Elf_External_Options
))),
5794 elf_gp (abfd
) = intreg
.ri_gp_value
;
5804 /* Set the correct type for a MIPS ELF section. We do this by the
5805 section name, which is a hack, but ought to work. This routine is
5806 used by both the 32-bit and the 64-bit ABI. */
5809 _bfd_mips_elf_fake_sections (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*sec
)
5811 const char *name
= bfd_get_section_name (abfd
, sec
);
5813 if (strcmp (name
, ".liblist") == 0)
5815 hdr
->sh_type
= SHT_MIPS_LIBLIST
;
5816 hdr
->sh_info
= sec
->size
/ sizeof (Elf32_Lib
);
5817 /* The sh_link field is set in final_write_processing. */
5819 else if (strcmp (name
, ".conflict") == 0)
5820 hdr
->sh_type
= SHT_MIPS_CONFLICT
;
5821 else if (CONST_STRNEQ (name
, ".gptab."))
5823 hdr
->sh_type
= SHT_MIPS_GPTAB
;
5824 hdr
->sh_entsize
= sizeof (Elf32_External_gptab
);
5825 /* The sh_info field is set in final_write_processing. */
5827 else if (strcmp (name
, ".ucode") == 0)
5828 hdr
->sh_type
= SHT_MIPS_UCODE
;
5829 else if (strcmp (name
, ".mdebug") == 0)
5831 hdr
->sh_type
= SHT_MIPS_DEBUG
;
5832 /* In a shared object on IRIX 5.3, the .mdebug section has an
5833 entsize of 0. FIXME: Does this matter? */
5834 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
5835 hdr
->sh_entsize
= 0;
5837 hdr
->sh_entsize
= 1;
5839 else if (strcmp (name
, ".reginfo") == 0)
5841 hdr
->sh_type
= SHT_MIPS_REGINFO
;
5842 /* In a shared object on IRIX 5.3, the .reginfo section has an
5843 entsize of 0x18. FIXME: Does this matter? */
5844 if (SGI_COMPAT (abfd
))
5846 if ((abfd
->flags
& DYNAMIC
) != 0)
5847 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
5849 hdr
->sh_entsize
= 1;
5852 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
5854 else if (SGI_COMPAT (abfd
)
5855 && (strcmp (name
, ".hash") == 0
5856 || strcmp (name
, ".dynamic") == 0
5857 || strcmp (name
, ".dynstr") == 0))
5859 if (SGI_COMPAT (abfd
))
5860 hdr
->sh_entsize
= 0;
5862 /* This isn't how the IRIX6 linker behaves. */
5863 hdr
->sh_info
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
5866 else if (strcmp (name
, ".got") == 0
5867 || strcmp (name
, ".srdata") == 0
5868 || strcmp (name
, ".sdata") == 0
5869 || strcmp (name
, ".sbss") == 0
5870 || strcmp (name
, ".lit4") == 0
5871 || strcmp (name
, ".lit8") == 0)
5872 hdr
->sh_flags
|= SHF_MIPS_GPREL
;
5873 else if (strcmp (name
, ".MIPS.interfaces") == 0)
5875 hdr
->sh_type
= SHT_MIPS_IFACE
;
5876 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
5878 else if (CONST_STRNEQ (name
, ".MIPS.content"))
5880 hdr
->sh_type
= SHT_MIPS_CONTENT
;
5881 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
5882 /* The sh_info field is set in final_write_processing. */
5884 else if (MIPS_ELF_OPTIONS_SECTION_NAME_P (name
))
5886 hdr
->sh_type
= SHT_MIPS_OPTIONS
;
5887 hdr
->sh_entsize
= 1;
5888 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
5890 else if (CONST_STRNEQ (name
, ".debug_")
5891 || CONST_STRNEQ (name
, ".zdebug_"))
5893 hdr
->sh_type
= SHT_MIPS_DWARF
;
5895 /* Irix facilities such as libexc expect a single .debug_frame
5896 per executable, the system ones have NOSTRIP set and the linker
5897 doesn't merge sections with different flags so ... */
5898 if (SGI_COMPAT (abfd
) && CONST_STRNEQ (name
, ".debug_frame"))
5899 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
5901 else if (strcmp (name
, ".MIPS.symlib") == 0)
5903 hdr
->sh_type
= SHT_MIPS_SYMBOL_LIB
;
5904 /* The sh_link and sh_info fields are set in
5905 final_write_processing. */
5907 else if (CONST_STRNEQ (name
, ".MIPS.events")
5908 || CONST_STRNEQ (name
, ".MIPS.post_rel"))
5910 hdr
->sh_type
= SHT_MIPS_EVENTS
;
5911 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
5912 /* The sh_link field is set in final_write_processing. */
5914 else if (strcmp (name
, ".msym") == 0)
5916 hdr
->sh_type
= SHT_MIPS_MSYM
;
5917 hdr
->sh_flags
|= SHF_ALLOC
;
5918 hdr
->sh_entsize
= 8;
5921 /* The generic elf_fake_sections will set up REL_HDR using the default
5922 kind of relocations. We used to set up a second header for the
5923 non-default kind of relocations here, but only NewABI would use
5924 these, and the IRIX ld doesn't like resulting empty RELA sections.
5925 Thus we create those header only on demand now. */
5930 /* Given a BFD section, try to locate the corresponding ELF section
5931 index. This is used by both the 32-bit and the 64-bit ABI.
5932 Actually, it's not clear to me that the 64-bit ABI supports these,
5933 but for non-PIC objects we will certainly want support for at least
5934 the .scommon section. */
5937 _bfd_mips_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
5938 asection
*sec
, int *retval
)
5940 if (strcmp (bfd_get_section_name (abfd
, sec
), ".scommon") == 0)
5942 *retval
= SHN_MIPS_SCOMMON
;
5945 if (strcmp (bfd_get_section_name (abfd
, sec
), ".acommon") == 0)
5947 *retval
= SHN_MIPS_ACOMMON
;
5953 /* Hook called by the linker routine which adds symbols from an object
5954 file. We must handle the special MIPS section numbers here. */
5957 _bfd_mips_elf_add_symbol_hook (bfd
*abfd
, struct bfd_link_info
*info
,
5958 Elf_Internal_Sym
*sym
, const char **namep
,
5959 flagword
*flagsp ATTRIBUTE_UNUSED
,
5960 asection
**secp
, bfd_vma
*valp
)
5962 if (SGI_COMPAT (abfd
)
5963 && (abfd
->flags
& DYNAMIC
) != 0
5964 && strcmp (*namep
, "_rld_new_interface") == 0)
5966 /* Skip IRIX5 rld entry name. */
5971 /* Shared objects may have a dynamic symbol '_gp_disp' defined as
5972 a SECTION *ABS*. This causes ld to think it can resolve _gp_disp
5973 by setting a DT_NEEDED for the shared object. Since _gp_disp is
5974 a magic symbol resolved by the linker, we ignore this bogus definition
5975 of _gp_disp. New ABI objects do not suffer from this problem so this
5976 is not done for them. */
5978 && (sym
->st_shndx
== SHN_ABS
)
5979 && (strcmp (*namep
, "_gp_disp") == 0))
5985 switch (sym
->st_shndx
)
5988 /* Common symbols less than the GP size are automatically
5989 treated as SHN_MIPS_SCOMMON symbols. */
5990 if (sym
->st_size
> elf_gp_size (abfd
)
5991 || ELF_ST_TYPE (sym
->st_info
) == STT_TLS
5992 || IRIX_COMPAT (abfd
) == ict_irix6
)
5995 case SHN_MIPS_SCOMMON
:
5996 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
5997 (*secp
)->flags
|= SEC_IS_COMMON
;
5998 *valp
= sym
->st_size
;
6002 /* This section is used in a shared object. */
6003 if (elf_tdata (abfd
)->elf_text_section
== NULL
)
6005 asymbol
*elf_text_symbol
;
6006 asection
*elf_text_section
;
6007 bfd_size_type amt
= sizeof (asection
);
6009 elf_text_section
= bfd_zalloc (abfd
, amt
);
6010 if (elf_text_section
== NULL
)
6013 amt
= sizeof (asymbol
);
6014 elf_text_symbol
= bfd_zalloc (abfd
, amt
);
6015 if (elf_text_symbol
== NULL
)
6018 /* Initialize the section. */
6020 elf_tdata (abfd
)->elf_text_section
= elf_text_section
;
6021 elf_tdata (abfd
)->elf_text_symbol
= elf_text_symbol
;
6023 elf_text_section
->symbol
= elf_text_symbol
;
6024 elf_text_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_text_symbol
;
6026 elf_text_section
->name
= ".text";
6027 elf_text_section
->flags
= SEC_NO_FLAGS
;
6028 elf_text_section
->output_section
= NULL
;
6029 elf_text_section
->owner
= abfd
;
6030 elf_text_symbol
->name
= ".text";
6031 elf_text_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
6032 elf_text_symbol
->section
= elf_text_section
;
6034 /* This code used to do *secp = bfd_und_section_ptr if
6035 info->shared. I don't know why, and that doesn't make sense,
6036 so I took it out. */
6037 *secp
= elf_tdata (abfd
)->elf_text_section
;
6040 case SHN_MIPS_ACOMMON
:
6041 /* Fall through. XXX Can we treat this as allocated data? */
6043 /* This section is used in a shared object. */
6044 if (elf_tdata (abfd
)->elf_data_section
== NULL
)
6046 asymbol
*elf_data_symbol
;
6047 asection
*elf_data_section
;
6048 bfd_size_type amt
= sizeof (asection
);
6050 elf_data_section
= bfd_zalloc (abfd
, amt
);
6051 if (elf_data_section
== NULL
)
6054 amt
= sizeof (asymbol
);
6055 elf_data_symbol
= bfd_zalloc (abfd
, amt
);
6056 if (elf_data_symbol
== NULL
)
6059 /* Initialize the section. */
6061 elf_tdata (abfd
)->elf_data_section
= elf_data_section
;
6062 elf_tdata (abfd
)->elf_data_symbol
= elf_data_symbol
;
6064 elf_data_section
->symbol
= elf_data_symbol
;
6065 elf_data_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_data_symbol
;
6067 elf_data_section
->name
= ".data";
6068 elf_data_section
->flags
= SEC_NO_FLAGS
;
6069 elf_data_section
->output_section
= NULL
;
6070 elf_data_section
->owner
= abfd
;
6071 elf_data_symbol
->name
= ".data";
6072 elf_data_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
6073 elf_data_symbol
->section
= elf_data_section
;
6075 /* This code used to do *secp = bfd_und_section_ptr if
6076 info->shared. I don't know why, and that doesn't make sense,
6077 so I took it out. */
6078 *secp
= elf_tdata (abfd
)->elf_data_section
;
6081 case SHN_MIPS_SUNDEFINED
:
6082 *secp
= bfd_und_section_ptr
;
6086 if (SGI_COMPAT (abfd
)
6088 && info
->output_bfd
->xvec
== abfd
->xvec
6089 && strcmp (*namep
, "__rld_obj_head") == 0)
6091 struct elf_link_hash_entry
*h
;
6092 struct bfd_link_hash_entry
*bh
;
6094 /* Mark __rld_obj_head as dynamic. */
6096 if (! (_bfd_generic_link_add_one_symbol
6097 (info
, abfd
, *namep
, BSF_GLOBAL
, *secp
, *valp
, NULL
, FALSE
,
6098 get_elf_backend_data (abfd
)->collect
, &bh
)))
6101 h
= (struct elf_link_hash_entry
*) bh
;
6104 h
->type
= STT_OBJECT
;
6106 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
6109 mips_elf_hash_table (info
)->use_rld_obj_head
= TRUE
;
6112 /* If this is a mips16 text symbol, add 1 to the value to make it
6113 odd. This will cause something like .word SYM to come up with
6114 the right value when it is loaded into the PC. */
6115 if (ELF_ST_IS_MIPS16 (sym
->st_other
))
6121 /* This hook function is called before the linker writes out a global
6122 symbol. We mark symbols as small common if appropriate. This is
6123 also where we undo the increment of the value for a mips16 symbol. */
6126 _bfd_mips_elf_link_output_symbol_hook
6127 (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6128 const char *name ATTRIBUTE_UNUSED
, Elf_Internal_Sym
*sym
,
6129 asection
*input_sec
, struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
)
6131 /* If we see a common symbol, which implies a relocatable link, then
6132 if a symbol was small common in an input file, mark it as small
6133 common in the output file. */
6134 if (sym
->st_shndx
== SHN_COMMON
6135 && strcmp (input_sec
->name
, ".scommon") == 0)
6136 sym
->st_shndx
= SHN_MIPS_SCOMMON
;
6138 if (ELF_ST_IS_MIPS16 (sym
->st_other
))
6139 sym
->st_value
&= ~1;
6144 /* Functions for the dynamic linker. */
6146 /* Create dynamic sections when linking against a dynamic object. */
6149 _bfd_mips_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
6151 struct elf_link_hash_entry
*h
;
6152 struct bfd_link_hash_entry
*bh
;
6154 register asection
*s
;
6155 const char * const *namep
;
6156 struct mips_elf_link_hash_table
*htab
;
6158 htab
= mips_elf_hash_table (info
);
6159 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
6160 | SEC_LINKER_CREATED
| SEC_READONLY
);
6162 /* The psABI requires a read-only .dynamic section, but the VxWorks
6164 if (!htab
->is_vxworks
)
6166 s
= bfd_get_section_by_name (abfd
, ".dynamic");
6169 if (! bfd_set_section_flags (abfd
, s
, flags
))
6174 /* We need to create .got section. */
6175 if (! mips_elf_create_got_section (abfd
, info
, FALSE
))
6178 if (! mips_elf_rel_dyn_section (info
, TRUE
))
6181 /* Create .stub section. */
6182 if (bfd_get_section_by_name (abfd
,
6183 MIPS_ELF_STUB_SECTION_NAME (abfd
)) == NULL
)
6185 s
= bfd_make_section_with_flags (abfd
,
6186 MIPS_ELF_STUB_SECTION_NAME (abfd
),
6189 || ! bfd_set_section_alignment (abfd
, s
,
6190 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
6194 if ((IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
6196 && bfd_get_section_by_name (abfd
, ".rld_map") == NULL
)
6198 s
= bfd_make_section_with_flags (abfd
, ".rld_map",
6199 flags
&~ (flagword
) SEC_READONLY
);
6201 || ! bfd_set_section_alignment (abfd
, s
,
6202 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
6206 /* On IRIX5, we adjust add some additional symbols and change the
6207 alignments of several sections. There is no ABI documentation
6208 indicating that this is necessary on IRIX6, nor any evidence that
6209 the linker takes such action. */
6210 if (IRIX_COMPAT (abfd
) == ict_irix5
)
6212 for (namep
= mips_elf_dynsym_rtproc_names
; *namep
!= NULL
; namep
++)
6215 if (! (_bfd_generic_link_add_one_symbol
6216 (info
, abfd
, *namep
, BSF_GLOBAL
, bfd_und_section_ptr
, 0,
6217 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
6220 h
= (struct elf_link_hash_entry
*) bh
;
6223 h
->type
= STT_SECTION
;
6225 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
6229 /* We need to create a .compact_rel section. */
6230 if (SGI_COMPAT (abfd
))
6232 if (!mips_elf_create_compact_rel_section (abfd
, info
))
6236 /* Change alignments of some sections. */
6237 s
= bfd_get_section_by_name (abfd
, ".hash");
6239 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
6240 s
= bfd_get_section_by_name (abfd
, ".dynsym");
6242 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
6243 s
= bfd_get_section_by_name (abfd
, ".dynstr");
6245 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
6246 s
= bfd_get_section_by_name (abfd
, ".reginfo");
6248 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
6249 s
= bfd_get_section_by_name (abfd
, ".dynamic");
6251 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
6258 name
= SGI_COMPAT (abfd
) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
6260 if (!(_bfd_generic_link_add_one_symbol
6261 (info
, abfd
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
, 0,
6262 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
6265 h
= (struct elf_link_hash_entry
*) bh
;
6268 h
->type
= STT_SECTION
;
6270 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
6273 if (! mips_elf_hash_table (info
)->use_rld_obj_head
)
6275 /* __rld_map is a four byte word located in the .data section
6276 and is filled in by the rtld to contain a pointer to
6277 the _r_debug structure. Its symbol value will be set in
6278 _bfd_mips_elf_finish_dynamic_symbol. */
6279 s
= bfd_get_section_by_name (abfd
, ".rld_map");
6280 BFD_ASSERT (s
!= NULL
);
6282 name
= SGI_COMPAT (abfd
) ? "__rld_map" : "__RLD_MAP";
6284 if (!(_bfd_generic_link_add_one_symbol
6285 (info
, abfd
, name
, BSF_GLOBAL
, s
, 0, NULL
, FALSE
,
6286 get_elf_backend_data (abfd
)->collect
, &bh
)))
6289 h
= (struct elf_link_hash_entry
*) bh
;
6292 h
->type
= STT_OBJECT
;
6294 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
6299 if (htab
->is_vxworks
)
6301 /* Create the .plt, .rela.plt, .dynbss and .rela.bss sections.
6302 Also create the _PROCEDURE_LINKAGE_TABLE symbol. */
6303 if (!_bfd_elf_create_dynamic_sections (abfd
, info
))
6306 /* Cache the sections created above. */
6307 htab
->sdynbss
= bfd_get_section_by_name (abfd
, ".dynbss");
6308 htab
->srelbss
= bfd_get_section_by_name (abfd
, ".rela.bss");
6309 htab
->srelplt
= bfd_get_section_by_name (abfd
, ".rela.plt");
6310 htab
->splt
= bfd_get_section_by_name (abfd
, ".plt");
6312 || (!htab
->srelbss
&& !info
->shared
)
6317 /* Do the usual VxWorks handling. */
6318 if (!elf_vxworks_create_dynamic_sections (abfd
, info
, &htab
->srelplt2
))
6321 /* Work out the PLT sizes. */
6324 htab
->plt_header_size
6325 = 4 * ARRAY_SIZE (mips_vxworks_shared_plt0_entry
);
6326 htab
->plt_entry_size
6327 = 4 * ARRAY_SIZE (mips_vxworks_shared_plt_entry
);
6331 htab
->plt_header_size
6332 = 4 * ARRAY_SIZE (mips_vxworks_exec_plt0_entry
);
6333 htab
->plt_entry_size
6334 = 4 * ARRAY_SIZE (mips_vxworks_exec_plt_entry
);
6341 /* Return true if relocation REL against section SEC is a REL rather than
6342 RELA relocation. RELOCS is the first relocation in the section and
6343 ABFD is the bfd that contains SEC. */
6346 mips_elf_rel_relocation_p (bfd
*abfd
, asection
*sec
,
6347 const Elf_Internal_Rela
*relocs
,
6348 const Elf_Internal_Rela
*rel
)
6350 Elf_Internal_Shdr
*rel_hdr
;
6351 const struct elf_backend_data
*bed
;
6353 /* To determine which flavor or relocation this is, we depend on the
6354 fact that the INPUT_SECTION's REL_HDR is read before its REL_HDR2. */
6355 rel_hdr
= &elf_section_data (sec
)->rel_hdr
;
6356 bed
= get_elf_backend_data (abfd
);
6357 if ((size_t) (rel
- relocs
)
6358 >= (NUM_SHDR_ENTRIES (rel_hdr
) * bed
->s
->int_rels_per_ext_rel
))
6359 rel_hdr
= elf_section_data (sec
)->rel_hdr2
;
6360 return rel_hdr
->sh_entsize
== MIPS_ELF_REL_SIZE (abfd
);
6363 /* Read the addend for REL relocation REL, which belongs to bfd ABFD.
6364 HOWTO is the relocation's howto and CONTENTS points to the contents
6365 of the section that REL is against. */
6368 mips_elf_read_rel_addend (bfd
*abfd
, const Elf_Internal_Rela
*rel
,
6369 reloc_howto_type
*howto
, bfd_byte
*contents
)
6372 unsigned int r_type
;
6375 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
6376 location
= contents
+ rel
->r_offset
;
6378 /* Get the addend, which is stored in the input file. */
6379 _bfd_mips16_elf_reloc_unshuffle (abfd
, r_type
, FALSE
, location
);
6380 addend
= mips_elf_obtain_contents (howto
, rel
, abfd
, contents
);
6381 _bfd_mips16_elf_reloc_shuffle (abfd
, r_type
, FALSE
, location
);
6383 return addend
& howto
->src_mask
;
6386 /* REL is a relocation in ABFD that needs a partnering LO16 relocation
6387 and *ADDEND is the addend for REL itself. Look for the LO16 relocation
6388 and update *ADDEND with the final addend. Return true on success
6389 or false if the LO16 could not be found. RELEND is the exclusive
6390 upper bound on the relocations for REL's section. */
6393 mips_elf_add_lo16_rel_addend (bfd
*abfd
,
6394 const Elf_Internal_Rela
*rel
,
6395 const Elf_Internal_Rela
*relend
,
6396 bfd_byte
*contents
, bfd_vma
*addend
)
6398 unsigned int r_type
, lo16_type
;
6399 const Elf_Internal_Rela
*lo16_relocation
;
6400 reloc_howto_type
*lo16_howto
;
6403 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
6404 if (r_type
== R_MIPS16_HI16
)
6405 lo16_type
= R_MIPS16_LO16
;
6407 lo16_type
= R_MIPS_LO16
;
6409 /* The combined value is the sum of the HI16 addend, left-shifted by
6410 sixteen bits, and the LO16 addend, sign extended. (Usually, the
6411 code does a `lui' of the HI16 value, and then an `addiu' of the
6414 Scan ahead to find a matching LO16 relocation.
6416 According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must
6417 be immediately following. However, for the IRIX6 ABI, the next
6418 relocation may be a composed relocation consisting of several
6419 relocations for the same address. In that case, the R_MIPS_LO16
6420 relocation may occur as one of these. We permit a similar
6421 extension in general, as that is useful for GCC.
6423 In some cases GCC dead code elimination removes the LO16 but keeps
6424 the corresponding HI16. This is strictly speaking a violation of
6425 the ABI but not immediately harmful. */
6426 lo16_relocation
= mips_elf_next_relocation (abfd
, lo16_type
, rel
, relend
);
6427 if (lo16_relocation
== NULL
)
6430 /* Obtain the addend kept there. */
6431 lo16_howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, lo16_type
, FALSE
);
6432 l
= mips_elf_read_rel_addend (abfd
, lo16_relocation
, lo16_howto
, contents
);
6434 l
<<= lo16_howto
->rightshift
;
6435 l
= _bfd_mips_elf_sign_extend (l
, 16);
6442 /* Try to read the contents of section SEC in bfd ABFD. Return true and
6443 store the contents in *CONTENTS on success. Assume that *CONTENTS
6444 already holds the contents if it is nonull on entry. */
6447 mips_elf_get_section_contents (bfd
*abfd
, asection
*sec
, bfd_byte
**contents
)
6452 /* Get cached copy if it exists. */
6453 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
6455 *contents
= elf_section_data (sec
)->this_hdr
.contents
;
6459 return bfd_malloc_and_get_section (abfd
, sec
, contents
);
6462 /* Look through the relocs for a section during the first phase, and
6463 allocate space in the global offset table. */
6466 _bfd_mips_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
6467 asection
*sec
, const Elf_Internal_Rela
*relocs
)
6471 Elf_Internal_Shdr
*symtab_hdr
;
6472 struct elf_link_hash_entry
**sym_hashes
;
6473 struct mips_got_info
*g
;
6475 const Elf_Internal_Rela
*rel
;
6476 const Elf_Internal_Rela
*rel_end
;
6479 const struct elf_backend_data
*bed
;
6480 struct mips_elf_link_hash_table
*htab
;
6483 reloc_howto_type
*howto
;
6485 if (info
->relocatable
)
6488 htab
= mips_elf_hash_table (info
);
6489 dynobj
= elf_hash_table (info
)->dynobj
;
6490 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
6491 sym_hashes
= elf_sym_hashes (abfd
);
6492 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
6494 /* Check for the mips16 stub sections. */
6496 name
= bfd_get_section_name (abfd
, sec
);
6497 if (FN_STUB_P (name
))
6499 unsigned long r_symndx
;
6501 /* Look at the relocation information to figure out which symbol
6504 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
6506 if (r_symndx
< extsymoff
6507 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
6511 /* This stub is for a local symbol. This stub will only be
6512 needed if there is some relocation in this BFD, other
6513 than a 16 bit function call, which refers to this symbol. */
6514 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
6516 Elf_Internal_Rela
*sec_relocs
;
6517 const Elf_Internal_Rela
*r
, *rend
;
6519 /* We can ignore stub sections when looking for relocs. */
6520 if ((o
->flags
& SEC_RELOC
) == 0
6521 || o
->reloc_count
== 0
6522 || mips16_stub_section_p (abfd
, o
))
6526 = _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
6528 if (sec_relocs
== NULL
)
6531 rend
= sec_relocs
+ o
->reloc_count
;
6532 for (r
= sec_relocs
; r
< rend
; r
++)
6533 if (ELF_R_SYM (abfd
, r
->r_info
) == r_symndx
6534 && ELF_R_TYPE (abfd
, r
->r_info
) != R_MIPS16_26
)
6537 if (elf_section_data (o
)->relocs
!= sec_relocs
)
6546 /* There is no non-call reloc for this stub, so we do
6547 not need it. Since this function is called before
6548 the linker maps input sections to output sections, we
6549 can easily discard it by setting the SEC_EXCLUDE
6551 sec
->flags
|= SEC_EXCLUDE
;
6555 /* Record this stub in an array of local symbol stubs for
6557 if (elf_tdata (abfd
)->local_stubs
== NULL
)
6559 unsigned long symcount
;
6563 if (elf_bad_symtab (abfd
))
6564 symcount
= NUM_SHDR_ENTRIES (symtab_hdr
);
6566 symcount
= symtab_hdr
->sh_info
;
6567 amt
= symcount
* sizeof (asection
*);
6568 n
= bfd_zalloc (abfd
, amt
);
6571 elf_tdata (abfd
)->local_stubs
= n
;
6574 sec
->flags
|= SEC_KEEP
;
6575 elf_tdata (abfd
)->local_stubs
[r_symndx
] = sec
;
6577 /* We don't need to set mips16_stubs_seen in this case.
6578 That flag is used to see whether we need to look through
6579 the global symbol table for stubs. We don't need to set
6580 it here, because we just have a local stub. */
6584 struct mips_elf_link_hash_entry
*h
;
6586 h
= ((struct mips_elf_link_hash_entry
*)
6587 sym_hashes
[r_symndx
- extsymoff
]);
6589 while (h
->root
.root
.type
== bfd_link_hash_indirect
6590 || h
->root
.root
.type
== bfd_link_hash_warning
)
6591 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
6593 /* H is the symbol this stub is for. */
6595 /* If we already have an appropriate stub for this function, we
6596 don't need another one, so we can discard this one. Since
6597 this function is called before the linker maps input sections
6598 to output sections, we can easily discard it by setting the
6599 SEC_EXCLUDE flag. */
6600 if (h
->fn_stub
!= NULL
)
6602 sec
->flags
|= SEC_EXCLUDE
;
6606 sec
->flags
|= SEC_KEEP
;
6608 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
6611 else if (CALL_STUB_P (name
) || CALL_FP_STUB_P (name
))
6613 unsigned long r_symndx
;
6614 struct mips_elf_link_hash_entry
*h
;
6617 /* Look at the relocation information to figure out which symbol
6620 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
6622 if (r_symndx
< extsymoff
6623 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
6627 /* This stub is for a local symbol. This stub will only be
6628 needed if there is some relocation (R_MIPS16_26) in this BFD
6629 that refers to this symbol. */
6630 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
6632 Elf_Internal_Rela
*sec_relocs
;
6633 const Elf_Internal_Rela
*r
, *rend
;
6635 /* We can ignore stub sections when looking for relocs. */
6636 if ((o
->flags
& SEC_RELOC
) == 0
6637 || o
->reloc_count
== 0
6638 || mips16_stub_section_p (abfd
, o
))
6642 = _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
6644 if (sec_relocs
== NULL
)
6647 rend
= sec_relocs
+ o
->reloc_count
;
6648 for (r
= sec_relocs
; r
< rend
; r
++)
6649 if (ELF_R_SYM (abfd
, r
->r_info
) == r_symndx
6650 && ELF_R_TYPE (abfd
, r
->r_info
) == R_MIPS16_26
)
6653 if (elf_section_data (o
)->relocs
!= sec_relocs
)
6662 /* There is no non-call reloc for this stub, so we do
6663 not need it. Since this function is called before
6664 the linker maps input sections to output sections, we
6665 can easily discard it by setting the SEC_EXCLUDE
6667 sec
->flags
|= SEC_EXCLUDE
;
6671 /* Record this stub in an array of local symbol call_stubs for
6673 if (elf_tdata (abfd
)->local_call_stubs
== NULL
)
6675 unsigned long symcount
;
6679 if (elf_bad_symtab (abfd
))
6680 symcount
= NUM_SHDR_ENTRIES (symtab_hdr
);
6682 symcount
= symtab_hdr
->sh_info
;
6683 amt
= symcount
* sizeof (asection
*);
6684 n
= bfd_zalloc (abfd
, amt
);
6687 elf_tdata (abfd
)->local_call_stubs
= n
;
6690 sec
->flags
|= SEC_KEEP
;
6691 elf_tdata (abfd
)->local_call_stubs
[r_symndx
] = sec
;
6693 /* We don't need to set mips16_stubs_seen in this case.
6694 That flag is used to see whether we need to look through
6695 the global symbol table for stubs. We don't need to set
6696 it here, because we just have a local stub. */
6700 h
= ((struct mips_elf_link_hash_entry
*)
6701 sym_hashes
[r_symndx
- extsymoff
]);
6703 /* H is the symbol this stub is for. */
6705 if (CALL_FP_STUB_P (name
))
6706 loc
= &h
->call_fp_stub
;
6708 loc
= &h
->call_stub
;
6710 /* If we already have an appropriate stub for this function, we
6711 don't need another one, so we can discard this one. Since
6712 this function is called before the linker maps input sections
6713 to output sections, we can easily discard it by setting the
6714 SEC_EXCLUDE flag. */
6717 sec
->flags
|= SEC_EXCLUDE
;
6721 sec
->flags
|= SEC_KEEP
;
6723 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
6734 sgot
= mips_elf_got_section (dynobj
, FALSE
);
6739 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
6740 g
= mips_elf_section_data (sgot
)->u
.got_info
;
6741 BFD_ASSERT (g
!= NULL
);
6746 bed
= get_elf_backend_data (abfd
);
6747 rel_end
= relocs
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
6749 for (rel
= relocs
; rel
< rel_end
; ++rel
)
6751 unsigned long r_symndx
;
6752 unsigned int r_type
;
6753 struct elf_link_hash_entry
*h
;
6755 r_symndx
= ELF_R_SYM (abfd
, rel
->r_info
);
6756 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
6758 if (r_symndx
< extsymoff
)
6760 else if (r_symndx
>= extsymoff
+ NUM_SHDR_ENTRIES (symtab_hdr
))
6762 (*_bfd_error_handler
)
6763 (_("%B: Malformed reloc detected for section %s"),
6765 bfd_set_error (bfd_error_bad_value
);
6770 h
= sym_hashes
[r_symndx
- extsymoff
];
6772 /* This may be an indirect symbol created because of a version. */
6775 while (h
->root
.type
== bfd_link_hash_indirect
)
6776 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
6780 /* Some relocs require a global offset table. */
6781 if (dynobj
== NULL
|| sgot
== NULL
)
6787 case R_MIPS_CALL_HI16
:
6788 case R_MIPS_CALL_LO16
:
6789 case R_MIPS_GOT_HI16
:
6790 case R_MIPS_GOT_LO16
:
6791 case R_MIPS_GOT_PAGE
:
6792 case R_MIPS_GOT_OFST
:
6793 case R_MIPS_GOT_DISP
:
6794 case R_MIPS_TLS_GOTTPREL
:
6796 case R_MIPS_TLS_LDM
:
6798 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
6799 if (! mips_elf_create_got_section (dynobj
, info
, FALSE
))
6801 g
= mips_elf_got_info (dynobj
, &sgot
);
6802 if (htab
->is_vxworks
&& !info
->shared
)
6804 (*_bfd_error_handler
)
6805 (_("%B: GOT reloc at 0x%lx not expected in executables"),
6806 abfd
, (unsigned long) rel
->r_offset
);
6807 bfd_set_error (bfd_error_bad_value
);
6815 /* In VxWorks executables, references to external symbols
6816 are handled using copy relocs or PLT stubs, so there's
6817 no need to add a dynamic relocation here. */
6819 && (info
->shared
|| (h
!= NULL
&& !htab
->is_vxworks
))
6820 && (sec
->flags
& SEC_ALLOC
) != 0)
6821 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
6831 ((struct mips_elf_link_hash_entry
*) h
)->is_relocation_target
= TRUE
;
6833 /* Relocations against the special VxWorks __GOTT_BASE__ and
6834 __GOTT_INDEX__ symbols must be left to the loader. Allocate
6835 room for them in .rela.dyn. */
6836 if (is_gott_symbol (info
, h
))
6840 sreloc
= mips_elf_rel_dyn_section (info
, TRUE
);
6844 mips_elf_allocate_dynamic_relocations (dynobj
, info
, 1);
6845 if (MIPS_ELF_READONLY_SECTION (sec
))
6846 /* We tell the dynamic linker that there are
6847 relocations against the text segment. */
6848 info
->flags
|= DF_TEXTREL
;
6851 else if (r_type
== R_MIPS_CALL_LO16
6852 || r_type
== R_MIPS_GOT_LO16
6853 || r_type
== R_MIPS_GOT_DISP
6854 || (r_type
== R_MIPS_GOT16
&& htab
->is_vxworks
))
6856 /* We may need a local GOT entry for this relocation. We
6857 don't count R_MIPS_GOT_PAGE because we can estimate the
6858 maximum number of pages needed by looking at the size of
6859 the segment. Similar comments apply to R_MIPS_GOT16 and
6860 R_MIPS_CALL16, except on VxWorks, where GOT relocations
6861 always evaluate to "G". We don't count R_MIPS_GOT_HI16, or
6862 R_MIPS_CALL_HI16 because these are always followed by an
6863 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
6864 if (! mips_elf_record_local_got_symbol (abfd
, r_symndx
,
6865 rel
->r_addend
, g
, 0))
6874 (*_bfd_error_handler
)
6875 (_("%B: CALL16 reloc at 0x%lx not against global symbol"),
6876 abfd
, (unsigned long) rel
->r_offset
);
6877 bfd_set_error (bfd_error_bad_value
);
6882 case R_MIPS_CALL_HI16
:
6883 case R_MIPS_CALL_LO16
:
6886 /* VxWorks call relocations point the function's .got.plt
6887 entry, which will be allocated by adjust_dynamic_symbol.
6888 Otherwise, this symbol requires a global GOT entry. */
6889 if ((!htab
->is_vxworks
|| h
->forced_local
)
6890 && !mips_elf_record_global_got_symbol (h
, abfd
, info
, g
, 0))
6893 /* We need a stub, not a plt entry for the undefined
6894 function. But we record it as if it needs plt. See
6895 _bfd_elf_adjust_dynamic_symbol. */
6901 case R_MIPS_GOT_PAGE
:
6902 /* If this is a global, overridable symbol, GOT_PAGE will
6903 decay to GOT_DISP, so we'll need a GOT entry for it. */
6906 struct mips_elf_link_hash_entry
*hmips
=
6907 (struct mips_elf_link_hash_entry
*) h
;
6909 while (hmips
->root
.root
.type
== bfd_link_hash_indirect
6910 || hmips
->root
.root
.type
== bfd_link_hash_warning
)
6911 hmips
= (struct mips_elf_link_hash_entry
*)
6912 hmips
->root
.root
.u
.i
.link
;
6914 /* This symbol is definitely not overridable. */
6915 if (hmips
->root
.def_regular
6916 && ! (info
->shared
&& ! info
->symbolic
6917 && ! hmips
->root
.forced_local
))
6923 case R_MIPS_GOT_HI16
:
6924 case R_MIPS_GOT_LO16
:
6925 if (!h
|| r_type
== R_MIPS_GOT_PAGE
)
6927 /* This relocation needs (or may need, if h != NULL) a
6928 page entry in the GOT. For R_MIPS_GOT_PAGE we do not
6929 know for sure until we know whether the symbol is
6931 if (mips_elf_rel_relocation_p (abfd
, sec
, relocs
, rel
))
6933 if (!mips_elf_get_section_contents (abfd
, sec
, &contents
))
6935 howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, r_type
, FALSE
);
6936 addend
= mips_elf_read_rel_addend (abfd
, rel
,
6938 if (r_type
== R_MIPS_GOT16
)
6939 mips_elf_add_lo16_rel_addend (abfd
, rel
, rel_end
,
6942 addend
<<= howto
->rightshift
;
6945 addend
= rel
->r_addend
;
6946 if (!mips_elf_record_got_page_entry (abfd
, r_symndx
, addend
, g
))
6952 case R_MIPS_GOT_DISP
:
6953 if (h
&& ! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
, 0))
6957 case R_MIPS_TLS_GOTTPREL
:
6959 info
->flags
|= DF_STATIC_TLS
;
6962 case R_MIPS_TLS_LDM
:
6963 if (r_type
== R_MIPS_TLS_LDM
)
6971 /* This symbol requires a global offset table entry, or two
6972 for TLS GD relocations. */
6974 unsigned char flag
= (r_type
== R_MIPS_TLS_GD
6976 : r_type
== R_MIPS_TLS_LDM
6981 struct mips_elf_link_hash_entry
*hmips
=
6982 (struct mips_elf_link_hash_entry
*) h
;
6983 hmips
->tls_type
|= flag
;
6985 if (h
&& ! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
, flag
))
6990 BFD_ASSERT (flag
== GOT_TLS_LDM
|| r_symndx
!= 0);
6992 if (! mips_elf_record_local_got_symbol (abfd
, r_symndx
,
6993 rel
->r_addend
, g
, flag
))
7002 /* In VxWorks executables, references to external symbols
7003 are handled using copy relocs or PLT stubs, so there's
7004 no need to add a .rela.dyn entry for this relocation. */
7005 if ((info
->shared
|| (h
!= NULL
&& !htab
->is_vxworks
))
7006 && (sec
->flags
& SEC_ALLOC
) != 0)
7010 sreloc
= mips_elf_rel_dyn_section (info
, TRUE
);
7014 if (info
->shared
&& h
== NULL
)
7016 /* When creating a shared object, we must copy these
7017 reloc types into the output file as R_MIPS_REL32
7018 relocs. Make room for this reloc in .rel(a).dyn. */
7019 mips_elf_allocate_dynamic_relocations (dynobj
, info
, 1);
7020 if (MIPS_ELF_READONLY_SECTION (sec
))
7021 /* We tell the dynamic linker that there are
7022 relocations against the text segment. */
7023 info
->flags
|= DF_TEXTREL
;
7027 struct mips_elf_link_hash_entry
*hmips
;
7029 /* For a shared object, we must copy this relocation
7030 unless the symbol turns out to be undefined and
7031 weak with non-default visibility, in which case
7032 it will be left as zero.
7034 We could elide R_MIPS_REL32 for locally binding symbols
7035 in shared libraries, but do not yet do so.
7037 For an executable, we only need to copy this
7038 reloc if the symbol is defined in a dynamic
7040 hmips
= (struct mips_elf_link_hash_entry
*) h
;
7041 ++hmips
->possibly_dynamic_relocs
;
7042 if (MIPS_ELF_READONLY_SECTION (sec
))
7043 /* We need it to tell the dynamic linker if there
7044 are relocations against the text segment. */
7045 hmips
->readonly_reloc
= TRUE
;
7048 /* Even though we don't directly need a GOT entry for
7049 this symbol, a symbol must have a dynamic symbol
7050 table index greater that DT_MIPS_GOTSYM if there are
7051 dynamic relocations against it. This does not apply
7052 to VxWorks, which does not have the usual coupling
7053 between global GOT entries and .dynsym entries. */
7054 if (h
!= NULL
&& !htab
->is_vxworks
)
7057 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
7058 if (! mips_elf_create_got_section (dynobj
, info
, TRUE
))
7060 g
= mips_elf_got_info (dynobj
, &sgot
);
7061 if (! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
, 0))
7066 if (SGI_COMPAT (abfd
))
7067 mips_elf_hash_table (info
)->compact_rel_size
+=
7068 sizeof (Elf32_External_crinfo
);
7073 ((struct mips_elf_link_hash_entry
*) h
)->is_branch_target
= TRUE
;
7078 ((struct mips_elf_link_hash_entry
*) h
)->is_branch_target
= TRUE
;
7081 case R_MIPS_GPREL16
:
7082 case R_MIPS_LITERAL
:
7083 case R_MIPS_GPREL32
:
7084 if (SGI_COMPAT (abfd
))
7085 mips_elf_hash_table (info
)->compact_rel_size
+=
7086 sizeof (Elf32_External_crinfo
);
7089 /* This relocation describes the C++ object vtable hierarchy.
7090 Reconstruct it for later use during GC. */
7091 case R_MIPS_GNU_VTINHERIT
:
7092 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
7096 /* This relocation describes which C++ vtable entries are actually
7097 used. Record for later use during GC. */
7098 case R_MIPS_GNU_VTENTRY
:
7099 BFD_ASSERT (h
!= NULL
);
7101 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
7109 /* We must not create a stub for a symbol that has relocations
7110 related to taking the function's address. This doesn't apply to
7111 VxWorks, where CALL relocs refer to a .got.plt entry instead of
7112 a normal .got entry. */
7113 if (!htab
->is_vxworks
&& h
!= NULL
)
7117 ((struct mips_elf_link_hash_entry
*) h
)->no_fn_stub
= TRUE
;
7120 case R_MIPS_CALL_HI16
:
7121 case R_MIPS_CALL_LO16
:
7126 /* If this reloc is not a 16 bit call, and it has a global
7127 symbol, then we will need the fn_stub if there is one.
7128 References from a stub section do not count. */
7130 && r_type
!= R_MIPS16_26
7131 && !mips16_stub_section_p (abfd
, sec
))
7133 struct mips_elf_link_hash_entry
*mh
;
7135 mh
= (struct mips_elf_link_hash_entry
*) h
;
7136 mh
->need_fn_stub
= TRUE
;
7144 _bfd_mips_relax_section (bfd
*abfd
, asection
*sec
,
7145 struct bfd_link_info
*link_info
,
7148 Elf_Internal_Rela
*internal_relocs
;
7149 Elf_Internal_Rela
*irel
, *irelend
;
7150 Elf_Internal_Shdr
*symtab_hdr
;
7151 bfd_byte
*contents
= NULL
;
7153 bfd_boolean changed_contents
= FALSE
;
7154 bfd_vma sec_start
= sec
->output_section
->vma
+ sec
->output_offset
;
7155 Elf_Internal_Sym
*isymbuf
= NULL
;
7157 /* We are not currently changing any sizes, so only one pass. */
7160 if (link_info
->relocatable
)
7163 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
7164 link_info
->keep_memory
);
7165 if (internal_relocs
== NULL
)
7168 irelend
= internal_relocs
+ sec
->reloc_count
7169 * get_elf_backend_data (abfd
)->s
->int_rels_per_ext_rel
;
7170 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7171 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
7173 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
7176 bfd_signed_vma sym_offset
;
7177 unsigned int r_type
;
7178 unsigned long r_symndx
;
7180 unsigned long instruction
;
7182 /* Turn jalr into bgezal, and jr into beq, if they're marked
7183 with a JALR relocation, that indicate where they jump to.
7184 This saves some pipeline bubbles. */
7185 r_type
= ELF_R_TYPE (abfd
, irel
->r_info
);
7186 if (r_type
!= R_MIPS_JALR
)
7189 r_symndx
= ELF_R_SYM (abfd
, irel
->r_info
);
7190 /* Compute the address of the jump target. */
7191 if (r_symndx
>= extsymoff
)
7193 struct mips_elf_link_hash_entry
*h
7194 = ((struct mips_elf_link_hash_entry
*)
7195 elf_sym_hashes (abfd
) [r_symndx
- extsymoff
]);
7197 while (h
->root
.root
.type
== bfd_link_hash_indirect
7198 || h
->root
.root
.type
== bfd_link_hash_warning
)
7199 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
7201 /* If a symbol is undefined, or if it may be overridden,
7203 if (! ((h
->root
.root
.type
== bfd_link_hash_defined
7204 || h
->root
.root
.type
== bfd_link_hash_defweak
)
7205 && h
->root
.root
.u
.def
.section
)
7206 || (link_info
->shared
&& ! link_info
->symbolic
7207 && !h
->root
.forced_local
))
7210 sym_sec
= h
->root
.root
.u
.def
.section
;
7211 if (sym_sec
->output_section
)
7212 symval
= (h
->root
.root
.u
.def
.value
7213 + sym_sec
->output_section
->vma
7214 + sym_sec
->output_offset
);
7216 symval
= h
->root
.root
.u
.def
.value
;
7220 Elf_Internal_Sym
*isym
;
7222 /* Read this BFD's symbols if we haven't done so already. */
7223 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
7225 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
7226 if (isymbuf
== NULL
)
7227 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
7228 symtab_hdr
->sh_info
, 0,
7230 if (isymbuf
== NULL
)
7234 isym
= isymbuf
+ r_symndx
;
7235 if (isym
->st_shndx
== SHN_UNDEF
)
7237 else if (isym
->st_shndx
== SHN_ABS
)
7238 sym_sec
= bfd_abs_section_ptr
;
7239 else if (isym
->st_shndx
== SHN_COMMON
)
7240 sym_sec
= bfd_com_section_ptr
;
7243 = bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
7244 symval
= isym
->st_value
7245 + sym_sec
->output_section
->vma
7246 + sym_sec
->output_offset
;
7249 /* Compute branch offset, from delay slot of the jump to the
7251 sym_offset
= (symval
+ irel
->r_addend
)
7252 - (sec_start
+ irel
->r_offset
+ 4);
7254 /* Branch offset must be properly aligned. */
7255 if ((sym_offset
& 3) != 0)
7260 /* Check that it's in range. */
7261 if (sym_offset
< -0x8000 || sym_offset
>= 0x8000)
7264 /* Get the section contents if we haven't done so already. */
7265 if (!mips_elf_get_section_contents (abfd
, sec
, &contents
))
7268 instruction
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
7270 /* If it was jalr <reg>, turn it into bgezal $zero, <target>. */
7271 if ((instruction
& 0xfc1fffff) == 0x0000f809)
7272 instruction
= 0x04110000;
7273 /* If it was jr <reg>, turn it into b <target>. */
7274 else if ((instruction
& 0xfc1fffff) == 0x00000008)
7275 instruction
= 0x10000000;
7279 instruction
|= (sym_offset
& 0xffff);
7280 bfd_put_32 (abfd
, instruction
, contents
+ irel
->r_offset
);
7281 changed_contents
= TRUE
;
7284 if (contents
!= NULL
7285 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
7287 if (!changed_contents
&& !link_info
->keep_memory
)
7291 /* Cache the section contents for elf_link_input_bfd. */
7292 elf_section_data (sec
)->this_hdr
.contents
= contents
;
7298 if (contents
!= NULL
7299 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
7304 /* Allocate space for global sym dynamic relocs. */
7307 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
7309 struct bfd_link_info
*info
= inf
;
7311 struct mips_elf_link_hash_entry
*hmips
;
7312 struct mips_elf_link_hash_table
*htab
;
7314 htab
= mips_elf_hash_table (info
);
7315 dynobj
= elf_hash_table (info
)->dynobj
;
7316 hmips
= (struct mips_elf_link_hash_entry
*) h
;
7318 /* VxWorks executables are handled elsewhere; we only need to
7319 allocate relocations in shared objects. */
7320 if (htab
->is_vxworks
&& !info
->shared
)
7323 /* If this symbol is defined in a dynamic object, or we are creating
7324 a shared library, we will need to copy any R_MIPS_32 or
7325 R_MIPS_REL32 relocs against it into the output file. */
7326 if (! info
->relocatable
7327 && hmips
->possibly_dynamic_relocs
!= 0
7328 && (h
->root
.type
== bfd_link_hash_defweak
7332 bfd_boolean do_copy
= TRUE
;
7334 if (h
->root
.type
== bfd_link_hash_undefweak
)
7336 /* Do not copy relocations for undefined weak symbols with
7337 non-default visibility. */
7338 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
7341 /* Make sure undefined weak symbols are output as a dynamic
7343 else if (h
->dynindx
== -1 && !h
->forced_local
)
7345 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
7352 mips_elf_allocate_dynamic_relocations
7353 (dynobj
, info
, hmips
->possibly_dynamic_relocs
);
7354 if (hmips
->readonly_reloc
)
7355 /* We tell the dynamic linker that there are relocations
7356 against the text segment. */
7357 info
->flags
|= DF_TEXTREL
;
7364 /* Adjust a symbol defined by a dynamic object and referenced by a
7365 regular object. The current definition is in some section of the
7366 dynamic object, but we're not including those sections. We have to
7367 change the definition to something the rest of the link can
7371 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
7372 struct elf_link_hash_entry
*h
)
7375 struct mips_elf_link_hash_entry
*hmips
;
7377 struct mips_elf_link_hash_table
*htab
;
7379 htab
= mips_elf_hash_table (info
);
7380 dynobj
= elf_hash_table (info
)->dynobj
;
7382 /* Make sure we know what is going on here. */
7383 BFD_ASSERT (dynobj
!= NULL
7385 || h
->u
.weakdef
!= NULL
7388 && !h
->def_regular
)));
7390 hmips
= (struct mips_elf_link_hash_entry
*) h
;
7392 /* For a function, create a stub, if allowed. */
7393 if (! hmips
->no_fn_stub
7396 if (! elf_hash_table (info
)->dynamic_sections_created
)
7399 /* If this symbol is not defined in a regular file, then set
7400 the symbol to the stub location. This is required to make
7401 function pointers compare as equal between the normal
7402 executable and the shared library. */
7403 if (!h
->def_regular
)
7405 /* We need .stub section. */
7406 s
= bfd_get_section_by_name (dynobj
,
7407 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
7408 BFD_ASSERT (s
!= NULL
);
7410 h
->root
.u
.def
.section
= s
;
7411 h
->root
.u
.def
.value
= s
->size
;
7413 /* XXX Write this stub address somewhere. */
7414 h
->plt
.offset
= s
->size
;
7416 /* Make room for this stub code. */
7417 s
->size
+= htab
->function_stub_size
;
7419 /* The last half word of the stub will be filled with the index
7420 of this symbol in .dynsym section. */
7424 else if ((h
->type
== STT_FUNC
)
7427 /* This will set the entry for this symbol in the GOT to 0, and
7428 the dynamic linker will take care of this. */
7429 h
->root
.u
.def
.value
= 0;
7433 /* If this is a weak symbol, and there is a real definition, the
7434 processor independent code will have arranged for us to see the
7435 real definition first, and we can just use the same value. */
7436 if (h
->u
.weakdef
!= NULL
)
7438 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
7439 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
7440 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
7441 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
7445 /* This is a reference to a symbol defined by a dynamic object which
7446 is not a function. */
7451 /* Likewise, for VxWorks. */
7454 _bfd_mips_vxworks_adjust_dynamic_symbol (struct bfd_link_info
*info
,
7455 struct elf_link_hash_entry
*h
)
7458 struct mips_elf_link_hash_entry
*hmips
;
7459 struct mips_elf_link_hash_table
*htab
;
7461 htab
= mips_elf_hash_table (info
);
7462 dynobj
= elf_hash_table (info
)->dynobj
;
7463 hmips
= (struct mips_elf_link_hash_entry
*) h
;
7465 /* Make sure we know what is going on here. */
7466 BFD_ASSERT (dynobj
!= NULL
7469 || h
->u
.weakdef
!= NULL
7472 && !h
->def_regular
)));
7474 /* If the symbol is defined by a dynamic object, we need a PLT stub if
7475 either (a) we want to branch to the symbol or (b) we're linking an
7476 executable that needs a canonical function address. In the latter
7477 case, the canonical address will be the address of the executable's
7479 if ((hmips
->is_branch_target
7481 && h
->type
== STT_FUNC
7482 && hmips
->is_relocation_target
))
7486 && !h
->forced_local
)
7489 /* Locally-binding symbols do not need a PLT stub; we can refer to
7490 the functions directly. */
7491 else if (h
->needs_plt
7492 && (SYMBOL_CALLS_LOCAL (info
, h
)
7493 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
7494 && h
->root
.type
== bfd_link_hash_undefweak
)))
7502 /* If this is the first symbol to need a PLT entry, allocate room
7503 for the header, and for the header's .rela.plt.unloaded entries. */
7504 if (htab
->splt
->size
== 0)
7506 htab
->splt
->size
+= htab
->plt_header_size
;
7508 htab
->srelplt2
->size
+= 2 * sizeof (Elf32_External_Rela
);
7511 /* Assign the next .plt entry to this symbol. */
7512 h
->plt
.offset
= htab
->splt
->size
;
7513 htab
->splt
->size
+= htab
->plt_entry_size
;
7515 /* If the output file has no definition of the symbol, set the
7516 symbol's value to the address of the stub. Point at the PLT
7517 load stub rather than the lazy resolution stub; this stub
7518 will become the canonical function address. */
7519 if (!info
->shared
&& !h
->def_regular
)
7521 h
->root
.u
.def
.section
= htab
->splt
;
7522 h
->root
.u
.def
.value
= h
->plt
.offset
;
7523 h
->root
.u
.def
.value
+= 8;
7526 /* Make room for the .got.plt entry and the R_JUMP_SLOT relocation. */
7527 htab
->sgotplt
->size
+= 4;
7528 htab
->srelplt
->size
+= sizeof (Elf32_External_Rela
);
7530 /* Make room for the .rela.plt.unloaded relocations. */
7532 htab
->srelplt2
->size
+= 3 * sizeof (Elf32_External_Rela
);
7537 /* If a function symbol is defined by a dynamic object, and we do not
7538 need a PLT stub for it, the symbol's value should be zero. */
7539 if (h
->type
== STT_FUNC
7544 h
->root
.u
.def
.value
= 0;
7548 /* If this is a weak symbol, and there is a real definition, the
7549 processor independent code will have arranged for us to see the
7550 real definition first, and we can just use the same value. */
7551 if (h
->u
.weakdef
!= NULL
)
7553 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
7554 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
7555 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
7556 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
7560 /* This is a reference to a symbol defined by a dynamic object which
7561 is not a function. */
7565 /* We must allocate the symbol in our .dynbss section, which will
7566 become part of the .bss section of the executable. There will be
7567 an entry for this symbol in the .dynsym section. The dynamic
7568 object will contain position independent code, so all references
7569 from the dynamic object to this symbol will go through the global
7570 offset table. The dynamic linker will use the .dynsym entry to
7571 determine the address it must put in the global offset table, so
7572 both the dynamic object and the regular object will refer to the
7573 same memory location for the variable. */
7575 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
7577 htab
->srelbss
->size
+= sizeof (Elf32_External_Rela
);
7581 return _bfd_elf_adjust_dynamic_copy (h
, htab
->sdynbss
);
7584 /* Return the number of dynamic section symbols required by OUTPUT_BFD.
7585 The number might be exact or a worst-case estimate, depending on how
7586 much information is available to elf_backend_omit_section_dynsym at
7587 the current linking stage. */
7589 static bfd_size_type
7590 count_section_dynsyms (bfd
*output_bfd
, struct bfd_link_info
*info
)
7592 bfd_size_type count
;
7595 if (info
->shared
|| elf_hash_table (info
)->is_relocatable_executable
)
7598 const struct elf_backend_data
*bed
;
7600 bed
= get_elf_backend_data (output_bfd
);
7601 for (p
= output_bfd
->sections
; p
; p
= p
->next
)
7602 if ((p
->flags
& SEC_EXCLUDE
) == 0
7603 && (p
->flags
& SEC_ALLOC
) != 0
7604 && !(*bed
->elf_backend_omit_section_dynsym
) (output_bfd
, info
, p
))
7610 /* This function is called after all the input files have been read,
7611 and the input sections have been assigned to output sections. We
7612 check for any mips16 stub sections that we can discard. */
7615 _bfd_mips_elf_always_size_sections (bfd
*output_bfd
,
7616 struct bfd_link_info
*info
)
7622 struct mips_got_info
*g
;
7624 bfd_size_type loadable_size
= 0;
7625 bfd_size_type page_gotno
;
7626 bfd_size_type dynsymcount
;
7628 struct mips_elf_count_tls_arg count_tls_arg
;
7629 struct mips_elf_link_hash_table
*htab
;
7631 htab
= mips_elf_hash_table (info
);
7633 /* The .reginfo section has a fixed size. */
7634 ri
= bfd_get_section_by_name (output_bfd
, ".reginfo");
7636 bfd_set_section_size (output_bfd
, ri
, sizeof (Elf32_External_RegInfo
));
7638 if (! (info
->relocatable
7639 || ! mips_elf_hash_table (info
)->mips16_stubs_seen
))
7640 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
7641 mips_elf_check_mips16_stubs
, NULL
);
7643 dynobj
= elf_hash_table (info
)->dynobj
;
7645 /* Relocatable links don't have it. */
7648 g
= mips_elf_got_info (dynobj
, &s
);
7652 /* Calculate the total loadable size of the output. That
7653 will give us the maximum number of GOT_PAGE entries
7655 for (sub
= info
->input_bfds
; sub
; sub
= sub
->link_next
)
7657 asection
*subsection
;
7659 for (subsection
= sub
->sections
;
7661 subsection
= subsection
->next
)
7663 if ((subsection
->flags
& SEC_ALLOC
) == 0)
7665 loadable_size
+= ((subsection
->size
+ 0xf)
7666 &~ (bfd_size_type
) 0xf);
7670 /* There has to be a global GOT entry for every symbol with
7671 a dynamic symbol table index of DT_MIPS_GOTSYM or
7672 higher. Therefore, it make sense to put those symbols
7673 that need GOT entries at the end of the symbol table. We
7675 if (! mips_elf_sort_hash_table (info
, 1))
7678 if (g
->global_gotsym
!= NULL
)
7679 i
= elf_hash_table (info
)->dynsymcount
- g
->global_gotsym
->dynindx
;
7681 /* If there are no global symbols, or none requiring
7682 relocations, then GLOBAL_GOTSYM will be NULL. */
7685 /* Get a worst-case estimate of the number of dynamic symbols needed.
7686 At this point, dynsymcount does not account for section symbols
7687 and count_section_dynsyms may overestimate the number that will
7689 dynsymcount
= (elf_hash_table (info
)->dynsymcount
7690 + count_section_dynsyms (output_bfd
, info
));
7692 /* Determine the size of one stub entry. */
7693 htab
->function_stub_size
= (dynsymcount
> 0x10000
7694 ? MIPS_FUNCTION_STUB_BIG_SIZE
7695 : MIPS_FUNCTION_STUB_NORMAL_SIZE
);
7697 /* In the worst case, we'll get one stub per dynamic symbol, plus
7698 one to account for the dummy entry at the end required by IRIX
7700 loadable_size
+= htab
->function_stub_size
* (i
+ 1);
7702 if (htab
->is_vxworks
)
7703 /* There's no need to allocate page entries for VxWorks; R_MIPS_GOT16
7704 relocations against local symbols evaluate to "G", and the EABI does
7705 not include R_MIPS_GOT_PAGE. */
7708 /* Assume there are two loadable segments consisting of contiguous
7709 sections. Is 5 enough? */
7710 page_gotno
= (loadable_size
>> 16) + 5;
7712 /* Choose the smaller of the two estimates; both are intended to be
7714 if (page_gotno
> g
->page_gotno
)
7715 page_gotno
= g
->page_gotno
;
7717 g
->local_gotno
+= page_gotno
;
7718 s
->size
+= g
->local_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
7720 g
->global_gotno
= i
;
7721 s
->size
+= i
* MIPS_ELF_GOT_SIZE (output_bfd
);
7723 /* We need to calculate tls_gotno for global symbols at this point
7724 instead of building it up earlier, to avoid doublecounting
7725 entries for one global symbol from multiple input files. */
7726 count_tls_arg
.info
= info
;
7727 count_tls_arg
.needed
= 0;
7728 elf_link_hash_traverse (elf_hash_table (info
),
7729 mips_elf_count_global_tls_entries
,
7731 g
->tls_gotno
+= count_tls_arg
.needed
;
7732 s
->size
+= g
->tls_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
7734 mips_elf_resolve_final_got_entries (g
);
7736 /* VxWorks does not support multiple GOTs. It initializes $gp to
7737 __GOTT_BASE__[__GOTT_INDEX__], the value of which is set by the
7739 if (!htab
->is_vxworks
&& s
->size
> MIPS_ELF_GOT_MAX_SIZE (info
))
7741 if (! mips_elf_multi_got (output_bfd
, info
, g
, s
, page_gotno
))
7746 /* Set up TLS entries for the first GOT. */
7747 g
->tls_assigned_gotno
= g
->global_gotno
+ g
->local_gotno
;
7748 htab_traverse (g
->got_entries
, mips_elf_initialize_tls_index
, g
);
7750 htab
->computed_got_sizes
= TRUE
;
7755 /* Set the sizes of the dynamic sections. */
7758 _bfd_mips_elf_size_dynamic_sections (bfd
*output_bfd
,
7759 struct bfd_link_info
*info
)
7762 asection
*s
, *sreldyn
;
7763 bfd_boolean reltext
;
7764 struct mips_elf_link_hash_table
*htab
;
7766 htab
= mips_elf_hash_table (info
);
7767 dynobj
= elf_hash_table (info
)->dynobj
;
7768 BFD_ASSERT (dynobj
!= NULL
);
7770 if (elf_hash_table (info
)->dynamic_sections_created
)
7772 /* Set the contents of the .interp section to the interpreter. */
7773 if (info
->executable
)
7775 s
= bfd_get_section_by_name (dynobj
, ".interp");
7776 BFD_ASSERT (s
!= NULL
);
7778 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd
)) + 1;
7780 = (bfd_byte
*) ELF_DYNAMIC_INTERPRETER (output_bfd
);
7784 /* Allocate space for global sym dynamic relocs. */
7785 elf_link_hash_traverse (&htab
->root
, allocate_dynrelocs
, (PTR
) info
);
7787 /* The check_relocs and adjust_dynamic_symbol entry points have
7788 determined the sizes of the various dynamic sections. Allocate
7792 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
7796 /* It's OK to base decisions on the section name, because none
7797 of the dynobj section names depend upon the input files. */
7798 name
= bfd_get_section_name (dynobj
, s
);
7800 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
7803 if (CONST_STRNEQ (name
, ".rel"))
7807 const char *outname
;
7810 /* If this relocation section applies to a read only
7811 section, then we probably need a DT_TEXTREL entry.
7812 If the relocation section is .rel(a).dyn, we always
7813 assert a DT_TEXTREL entry rather than testing whether
7814 there exists a relocation to a read only section or
7816 outname
= bfd_get_section_name (output_bfd
,
7818 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
7820 && (target
->flags
& SEC_READONLY
) != 0
7821 && (target
->flags
& SEC_ALLOC
) != 0)
7822 || strcmp (outname
, MIPS_ELF_REL_DYN_NAME (info
)) == 0)
7825 /* We use the reloc_count field as a counter if we need
7826 to copy relocs into the output file. */
7827 if (strcmp (name
, MIPS_ELF_REL_DYN_NAME (info
)) != 0)
7830 /* If combreloc is enabled, elf_link_sort_relocs() will
7831 sort relocations, but in a different way than we do,
7832 and before we're done creating relocations. Also, it
7833 will move them around between input sections'
7834 relocation's contents, so our sorting would be
7835 broken, so don't let it run. */
7836 info
->combreloc
= 0;
7839 else if (htab
->is_vxworks
&& strcmp (name
, ".got") == 0)
7841 /* Executables do not need a GOT. */
7844 /* Allocate relocations for all but the reserved entries. */
7845 struct mips_got_info
*g
;
7848 g
= mips_elf_got_info (dynobj
, NULL
);
7849 count
= (g
->global_gotno
7851 - MIPS_RESERVED_GOTNO (info
));
7852 mips_elf_allocate_dynamic_relocations (dynobj
, info
, count
);
7855 else if (!htab
->is_vxworks
&& CONST_STRNEQ (name
, ".got"))
7857 /* _bfd_mips_elf_always_size_sections() has already done
7858 most of the work, but some symbols may have been mapped
7859 to versions that we must now resolve in the got_entries
7861 struct mips_got_info
*gg
= mips_elf_got_info (dynobj
, NULL
);
7862 struct mips_got_info
*g
= gg
;
7863 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
7864 unsigned int needed_relocs
= 0;
7868 set_got_offset_arg
.value
= MIPS_ELF_GOT_SIZE (output_bfd
);
7869 set_got_offset_arg
.info
= info
;
7871 /* NOTE 2005-02-03: How can this call, or the next, ever
7872 find any indirect entries to resolve? They were all
7873 resolved in mips_elf_multi_got. */
7874 mips_elf_resolve_final_got_entries (gg
);
7875 for (g
= gg
->next
; g
&& g
->next
!= gg
; g
= g
->next
)
7877 unsigned int save_assign
;
7879 mips_elf_resolve_final_got_entries (g
);
7881 /* Assign offsets to global GOT entries. */
7882 save_assign
= g
->assigned_gotno
;
7883 g
->assigned_gotno
= g
->local_gotno
;
7884 set_got_offset_arg
.g
= g
;
7885 set_got_offset_arg
.needed_relocs
= 0;
7886 htab_traverse (g
->got_entries
,
7887 mips_elf_set_global_got_offset
,
7888 &set_got_offset_arg
);
7889 needed_relocs
+= set_got_offset_arg
.needed_relocs
;
7890 BFD_ASSERT (g
->assigned_gotno
- g
->local_gotno
7891 <= g
->global_gotno
);
7893 g
->assigned_gotno
= save_assign
;
7896 needed_relocs
+= g
->local_gotno
- g
->assigned_gotno
;
7897 BFD_ASSERT (g
->assigned_gotno
== g
->next
->local_gotno
7898 + g
->next
->global_gotno
7899 + g
->next
->tls_gotno
7900 + MIPS_RESERVED_GOTNO (info
));
7906 struct mips_elf_count_tls_arg arg
;
7910 htab_traverse (gg
->got_entries
, mips_elf_count_local_tls_relocs
,
7912 elf_link_hash_traverse (elf_hash_table (info
),
7913 mips_elf_count_global_tls_relocs
,
7916 needed_relocs
+= arg
.needed
;
7920 mips_elf_allocate_dynamic_relocations (dynobj
, info
,
7923 else if (strcmp (name
, MIPS_ELF_STUB_SECTION_NAME (output_bfd
)) == 0)
7925 /* IRIX rld assumes that the function stub isn't at the end
7926 of .text section. So put a dummy. XXX */
7927 s
->size
+= htab
->function_stub_size
;
7929 else if (! info
->shared
7930 && ! mips_elf_hash_table (info
)->use_rld_obj_head
7931 && CONST_STRNEQ (name
, ".rld_map"))
7933 /* We add a room for __rld_map. It will be filled in by the
7934 rtld to contain a pointer to the _r_debug structure. */
7937 else if (SGI_COMPAT (output_bfd
)
7938 && CONST_STRNEQ (name
, ".compact_rel"))
7939 s
->size
+= mips_elf_hash_table (info
)->compact_rel_size
;
7940 else if (! CONST_STRNEQ (name
, ".init")
7941 && s
!= htab
->sgotplt
7944 /* It's not one of our sections, so don't allocate space. */
7950 s
->flags
|= SEC_EXCLUDE
;
7954 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
7957 /* Allocate memory for this section last, since we may increase its
7959 if (strcmp (name
, MIPS_ELF_REL_DYN_NAME (info
)) == 0)
7965 /* Allocate memory for the section contents. */
7966 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
7967 if (s
->contents
== NULL
)
7969 bfd_set_error (bfd_error_no_memory
);
7974 /* Allocate memory for the .rel(a).dyn section. */
7975 if (sreldyn
!= NULL
)
7977 sreldyn
->contents
= bfd_zalloc (dynobj
, sreldyn
->size
);
7978 if (sreldyn
->contents
== NULL
)
7980 bfd_set_error (bfd_error_no_memory
);
7985 if (elf_hash_table (info
)->dynamic_sections_created
)
7987 /* Add some entries to the .dynamic section. We fill in the
7988 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
7989 must add the entries now so that we get the correct size for
7990 the .dynamic section. */
7992 /* SGI object has the equivalence of DT_DEBUG in the
7993 DT_MIPS_RLD_MAP entry. This must come first because glibc
7994 only fills in DT_MIPS_RLD_MAP (not DT_DEBUG) and GDB only
7995 looks at the first one it sees. */
7997 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_MAP
, 0))
8000 /* The DT_DEBUG entry may be filled in by the dynamic linker and
8001 used by the debugger. */
8002 if (info
->executable
8003 && !SGI_COMPAT (output_bfd
)
8004 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
8007 if (reltext
&& (SGI_COMPAT (output_bfd
) || htab
->is_vxworks
))
8008 info
->flags
|= DF_TEXTREL
;
8010 if ((info
->flags
& DF_TEXTREL
) != 0)
8012 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_TEXTREL
, 0))
8015 /* Clear the DF_TEXTREL flag. It will be set again if we
8016 write out an actual text relocation; we may not, because
8017 at this point we do not know whether e.g. any .eh_frame
8018 absolute relocations have been converted to PC-relative. */
8019 info
->flags
&= ~DF_TEXTREL
;
8022 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTGOT
, 0))
8025 if (htab
->is_vxworks
)
8027 /* VxWorks uses .rela.dyn instead of .rel.dyn. It does not
8028 use any of the DT_MIPS_* tags. */
8029 if (mips_elf_rel_dyn_section (info
, FALSE
))
8031 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELA
, 0))
8034 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELASZ
, 0))
8037 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELAENT
, 0))
8040 if (htab
->splt
->size
> 0)
8042 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTREL
, 0))
8045 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_JMPREL
, 0))
8048 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTRELSZ
, 0))
8054 if (mips_elf_rel_dyn_section (info
, FALSE
))
8056 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_REL
, 0))
8059 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELSZ
, 0))
8062 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELENT
, 0))
8066 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_VERSION
, 0))
8069 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_FLAGS
, 0))
8072 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_BASE_ADDRESS
, 0))
8075 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LOCAL_GOTNO
, 0))
8078 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_SYMTABNO
, 0))
8081 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_UNREFEXTNO
, 0))
8084 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_GOTSYM
, 0))
8087 if (IRIX_COMPAT (dynobj
) == ict_irix5
8088 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_HIPAGENO
, 0))
8091 if (IRIX_COMPAT (dynobj
) == ict_irix6
8092 && (bfd_get_section_by_name
8093 (dynobj
, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj
)))
8094 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_OPTIONS
, 0))
8097 if (htab
->is_vxworks
8098 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
8105 /* REL is a relocation in INPUT_BFD that is being copied to OUTPUT_BFD.
8106 Adjust its R_ADDEND field so that it is correct for the output file.
8107 LOCAL_SYMS and LOCAL_SECTIONS are arrays of INPUT_BFD's local symbols
8108 and sections respectively; both use symbol indexes. */
8111 mips_elf_adjust_addend (bfd
*output_bfd
, struct bfd_link_info
*info
,
8112 bfd
*input_bfd
, Elf_Internal_Sym
*local_syms
,
8113 asection
**local_sections
, Elf_Internal_Rela
*rel
)
8115 unsigned int r_type
, r_symndx
;
8116 Elf_Internal_Sym
*sym
;
8119 if (mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
, FALSE
))
8121 r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
8122 if (r_type
== R_MIPS16_GPREL
8123 || r_type
== R_MIPS_GPREL16
8124 || r_type
== R_MIPS_GPREL32
8125 || r_type
== R_MIPS_LITERAL
)
8127 rel
->r_addend
+= _bfd_get_gp_value (input_bfd
);
8128 rel
->r_addend
-= _bfd_get_gp_value (output_bfd
);
8131 r_symndx
= ELF_R_SYM (output_bfd
, rel
->r_info
);
8132 sym
= local_syms
+ r_symndx
;
8134 /* Adjust REL's addend to account for section merging. */
8135 if (!info
->relocatable
)
8137 sec
= local_sections
[r_symndx
];
8138 _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
8141 /* This would normally be done by the rela_normal code in elflink.c. */
8142 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
8143 rel
->r_addend
+= local_sections
[r_symndx
]->output_offset
;
8147 /* Relocate a MIPS ELF section. */
8150 _bfd_mips_elf_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
8151 bfd
*input_bfd
, asection
*input_section
,
8152 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
8153 Elf_Internal_Sym
*local_syms
,
8154 asection
**local_sections
)
8156 Elf_Internal_Rela
*rel
;
8157 const Elf_Internal_Rela
*relend
;
8159 bfd_boolean use_saved_addend_p
= FALSE
;
8160 const struct elf_backend_data
*bed
;
8162 bed
= get_elf_backend_data (output_bfd
);
8163 relend
= relocs
+ input_section
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
8164 for (rel
= relocs
; rel
< relend
; ++rel
)
8168 reloc_howto_type
*howto
;
8169 bfd_boolean require_jalx
;
8170 /* TRUE if the relocation is a RELA relocation, rather than a
8172 bfd_boolean rela_relocation_p
= TRUE
;
8173 unsigned int r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
8175 unsigned long r_symndx
;
8177 Elf_Internal_Shdr
*symtab_hdr
;
8178 struct elf_link_hash_entry
*h
;
8180 /* Find the relocation howto for this relocation. */
8181 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, r_type
,
8182 NEWABI_P (input_bfd
)
8183 && (MIPS_RELOC_RELA_P
8184 (input_bfd
, input_section
,
8187 r_symndx
= ELF_R_SYM (input_bfd
, rel
->r_info
);
8188 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
8189 if (mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
, FALSE
))
8191 sec
= local_sections
[r_symndx
];
8196 unsigned long extsymoff
;
8199 if (!elf_bad_symtab (input_bfd
))
8200 extsymoff
= symtab_hdr
->sh_info
;
8201 h
= elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
];
8202 while (h
->root
.type
== bfd_link_hash_indirect
8203 || h
->root
.type
== bfd_link_hash_warning
)
8204 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
8207 if (h
->root
.type
== bfd_link_hash_defined
8208 || h
->root
.type
== bfd_link_hash_defweak
)
8209 sec
= h
->root
.u
.def
.section
;
8212 if (sec
!= NULL
&& elf_discarded_section (sec
))
8214 /* For relocs against symbols from removed linkonce sections,
8215 or sections discarded by a linker script, we just want the
8216 section contents zeroed. Avoid any special processing. */
8217 _bfd_clear_contents (howto
, input_bfd
, contents
+ rel
->r_offset
);
8223 if (r_type
== R_MIPS_64
&& ! NEWABI_P (input_bfd
))
8225 /* Some 32-bit code uses R_MIPS_64. In particular, people use
8226 64-bit code, but make sure all their addresses are in the
8227 lowermost or uppermost 32-bit section of the 64-bit address
8228 space. Thus, when they use an R_MIPS_64 they mean what is
8229 usually meant by R_MIPS_32, with the exception that the
8230 stored value is sign-extended to 64 bits. */
8231 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, R_MIPS_32
, FALSE
);
8233 /* On big-endian systems, we need to lie about the position
8235 if (bfd_big_endian (input_bfd
))
8239 if (!use_saved_addend_p
)
8241 /* If these relocations were originally of the REL variety,
8242 we must pull the addend out of the field that will be
8243 relocated. Otherwise, we simply use the contents of the
8245 if (mips_elf_rel_relocation_p (input_bfd
, input_section
,
8248 rela_relocation_p
= FALSE
;
8249 addend
= mips_elf_read_rel_addend (input_bfd
, rel
,
8251 if (r_type
== R_MIPS_HI16
8252 || r_type
== R_MIPS16_HI16
8253 || (r_type
== R_MIPS_GOT16
8254 && mips_elf_local_relocation_p (input_bfd
, rel
,
8255 local_sections
, FALSE
)))
8257 if (!mips_elf_add_lo16_rel_addend (input_bfd
, rel
, relend
,
8263 name
= h
->root
.root
.string
;
8265 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
8266 local_syms
+ r_symndx
,
8268 (*_bfd_error_handler
)
8269 (_("%B: Can't find matching LO16 reloc against `%s' for %s at 0x%lx in section `%A'"),
8270 input_bfd
, input_section
, name
, howto
->name
,
8275 addend
<<= howto
->rightshift
;
8278 addend
= rel
->r_addend
;
8279 mips_elf_adjust_addend (output_bfd
, info
, input_bfd
,
8280 local_syms
, local_sections
, rel
);
8283 if (info
->relocatable
)
8285 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
)
8286 && bfd_big_endian (input_bfd
))
8289 if (!rela_relocation_p
&& rel
->r_addend
)
8291 addend
+= rel
->r_addend
;
8292 if (r_type
== R_MIPS_HI16
8293 || r_type
== R_MIPS_GOT16
)
8294 addend
= mips_elf_high (addend
);
8295 else if (r_type
== R_MIPS_HIGHER
)
8296 addend
= mips_elf_higher (addend
);
8297 else if (r_type
== R_MIPS_HIGHEST
)
8298 addend
= mips_elf_highest (addend
);
8300 addend
>>= howto
->rightshift
;
8302 /* We use the source mask, rather than the destination
8303 mask because the place to which we are writing will be
8304 source of the addend in the final link. */
8305 addend
&= howto
->src_mask
;
8307 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
8308 /* See the comment above about using R_MIPS_64 in the 32-bit
8309 ABI. Here, we need to update the addend. It would be
8310 possible to get away with just using the R_MIPS_32 reloc
8311 but for endianness. */
8317 if (addend
& ((bfd_vma
) 1 << 31))
8319 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
8326 /* If we don't know that we have a 64-bit type,
8327 do two separate stores. */
8328 if (bfd_big_endian (input_bfd
))
8330 /* Store the sign-bits (which are most significant)
8332 low_bits
= sign_bits
;
8338 high_bits
= sign_bits
;
8340 bfd_put_32 (input_bfd
, low_bits
,
8341 contents
+ rel
->r_offset
);
8342 bfd_put_32 (input_bfd
, high_bits
,
8343 contents
+ rel
->r_offset
+ 4);
8347 if (! mips_elf_perform_relocation (info
, howto
, rel
, addend
,
8348 input_bfd
, input_section
,
8353 /* Go on to the next relocation. */
8357 /* In the N32 and 64-bit ABIs there may be multiple consecutive
8358 relocations for the same offset. In that case we are
8359 supposed to treat the output of each relocation as the addend
8361 if (rel
+ 1 < relend
8362 && rel
->r_offset
== rel
[1].r_offset
8363 && ELF_R_TYPE (input_bfd
, rel
[1].r_info
) != R_MIPS_NONE
)
8364 use_saved_addend_p
= TRUE
;
8366 use_saved_addend_p
= FALSE
;
8368 /* Figure out what value we are supposed to relocate. */
8369 switch (mips_elf_calculate_relocation (output_bfd
, input_bfd
,
8370 input_section
, info
, rel
,
8371 addend
, howto
, local_syms
,
8372 local_sections
, &value
,
8373 &name
, &require_jalx
,
8374 use_saved_addend_p
))
8376 case bfd_reloc_continue
:
8377 /* There's nothing to do. */
8380 case bfd_reloc_undefined
:
8381 /* mips_elf_calculate_relocation already called the
8382 undefined_symbol callback. There's no real point in
8383 trying to perform the relocation at this point, so we
8384 just skip ahead to the next relocation. */
8387 case bfd_reloc_notsupported
:
8388 msg
= _("internal error: unsupported relocation error");
8389 info
->callbacks
->warning
8390 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
8393 case bfd_reloc_overflow
:
8394 if (use_saved_addend_p
)
8395 /* Ignore overflow until we reach the last relocation for
8396 a given location. */
8400 struct mips_elf_link_hash_table
*htab
;
8402 htab
= mips_elf_hash_table (info
);
8403 BFD_ASSERT (name
!= NULL
);
8404 if (!htab
->small_data_overflow_reported
8405 && (howto
->type
== R_MIPS_GPREL16
8406 || howto
->type
== R_MIPS_LITERAL
))
8409 _("small-data section exceeds 64KB;"
8410 " lower small-data size limit (see option -G)");
8412 htab
->small_data_overflow_reported
= TRUE
;
8413 (*info
->callbacks
->einfo
) ("%P: %s\n", msg
);
8415 if (! ((*info
->callbacks
->reloc_overflow
)
8416 (info
, NULL
, name
, howto
->name
, (bfd_vma
) 0,
8417 input_bfd
, input_section
, rel
->r_offset
)))
8430 /* If we've got another relocation for the address, keep going
8431 until we reach the last one. */
8432 if (use_saved_addend_p
)
8438 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
8439 /* See the comment above about using R_MIPS_64 in the 32-bit
8440 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
8441 that calculated the right value. Now, however, we
8442 sign-extend the 32-bit result to 64-bits, and store it as a
8443 64-bit value. We are especially generous here in that we
8444 go to extreme lengths to support this usage on systems with
8445 only a 32-bit VMA. */
8451 if (value
& ((bfd_vma
) 1 << 31))
8453 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
8460 /* If we don't know that we have a 64-bit type,
8461 do two separate stores. */
8462 if (bfd_big_endian (input_bfd
))
8464 /* Undo what we did above. */
8466 /* Store the sign-bits (which are most significant)
8468 low_bits
= sign_bits
;
8474 high_bits
= sign_bits
;
8476 bfd_put_32 (input_bfd
, low_bits
,
8477 contents
+ rel
->r_offset
);
8478 bfd_put_32 (input_bfd
, high_bits
,
8479 contents
+ rel
->r_offset
+ 4);
8483 /* Actually perform the relocation. */
8484 if (! mips_elf_perform_relocation (info
, howto
, rel
, value
,
8485 input_bfd
, input_section
,
8486 contents
, require_jalx
))
8493 /* If NAME is one of the special IRIX6 symbols defined by the linker,
8494 adjust it appropriately now. */
8497 mips_elf_irix6_finish_dynamic_symbol (bfd
*abfd ATTRIBUTE_UNUSED
,
8498 const char *name
, Elf_Internal_Sym
*sym
)
8500 /* The linker script takes care of providing names and values for
8501 these, but we must place them into the right sections. */
8502 static const char* const text_section_symbols
[] = {
8505 "__dso_displacement",
8507 "__program_header_table",
8511 static const char* const data_section_symbols
[] = {
8519 const char* const *p
;
8522 for (i
= 0; i
< 2; ++i
)
8523 for (p
= (i
== 0) ? text_section_symbols
: data_section_symbols
;
8526 if (strcmp (*p
, name
) == 0)
8528 /* All of these symbols are given type STT_SECTION by the
8530 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8531 sym
->st_other
= STO_PROTECTED
;
8533 /* The IRIX linker puts these symbols in special sections. */
8535 sym
->st_shndx
= SHN_MIPS_TEXT
;
8537 sym
->st_shndx
= SHN_MIPS_DATA
;
8543 /* Finish up dynamic symbol handling. We set the contents of various
8544 dynamic sections here. */
8547 _bfd_mips_elf_finish_dynamic_symbol (bfd
*output_bfd
,
8548 struct bfd_link_info
*info
,
8549 struct elf_link_hash_entry
*h
,
8550 Elf_Internal_Sym
*sym
)
8554 struct mips_got_info
*g
, *gg
;
8557 struct mips_elf_link_hash_table
*htab
;
8559 htab
= mips_elf_hash_table (info
);
8560 dynobj
= elf_hash_table (info
)->dynobj
;
8562 if (h
->plt
.offset
!= MINUS_ONE
)
8565 bfd_byte stub
[MIPS_FUNCTION_STUB_BIG_SIZE
];
8567 /* This symbol has a stub. Set it up. */
8569 BFD_ASSERT (h
->dynindx
!= -1);
8571 s
= bfd_get_section_by_name (dynobj
,
8572 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
8573 BFD_ASSERT (s
!= NULL
);
8575 BFD_ASSERT ((htab
->function_stub_size
== MIPS_FUNCTION_STUB_BIG_SIZE
)
8576 || (h
->dynindx
<= 0xffff));
8578 /* Values up to 2^31 - 1 are allowed. Larger values would cause
8579 sign extension at runtime in the stub, resulting in a negative
8581 if (h
->dynindx
& ~0x7fffffff)
8584 /* Fill the stub. */
8586 bfd_put_32 (output_bfd
, STUB_LW (output_bfd
), stub
+ idx
);
8588 bfd_put_32 (output_bfd
, STUB_MOVE (output_bfd
), stub
+ idx
);
8590 if (htab
->function_stub_size
== MIPS_FUNCTION_STUB_BIG_SIZE
)
8592 bfd_put_32 (output_bfd
, STUB_LUI ((h
->dynindx
>> 16) & 0x7fff),
8596 bfd_put_32 (output_bfd
, STUB_JALR
, stub
+ idx
);
8599 /* If a large stub is not required and sign extension is not a
8600 problem, then use legacy code in the stub. */
8601 if (htab
->function_stub_size
== MIPS_FUNCTION_STUB_BIG_SIZE
)
8602 bfd_put_32 (output_bfd
, STUB_ORI (h
->dynindx
& 0xffff), stub
+ idx
);
8603 else if (h
->dynindx
& ~0x7fff)
8604 bfd_put_32 (output_bfd
, STUB_LI16U (h
->dynindx
& 0xffff), stub
+ idx
);
8606 bfd_put_32 (output_bfd
, STUB_LI16S (output_bfd
, h
->dynindx
),
8609 BFD_ASSERT (h
->plt
.offset
<= s
->size
);
8610 memcpy (s
->contents
+ h
->plt
.offset
, stub
, htab
->function_stub_size
);
8612 /* Mark the symbol as undefined. plt.offset != -1 occurs
8613 only for the referenced symbol. */
8614 sym
->st_shndx
= SHN_UNDEF
;
8616 /* The run-time linker uses the st_value field of the symbol
8617 to reset the global offset table entry for this external
8618 to its stub address when unlinking a shared object. */
8619 sym
->st_value
= (s
->output_section
->vma
+ s
->output_offset
8623 BFD_ASSERT (h
->dynindx
!= -1
8624 || h
->forced_local
);
8626 sgot
= mips_elf_got_section (dynobj
, FALSE
);
8627 BFD_ASSERT (sgot
!= NULL
);
8628 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
8629 g
= mips_elf_section_data (sgot
)->u
.got_info
;
8630 BFD_ASSERT (g
!= NULL
);
8632 /* Run through the global symbol table, creating GOT entries for all
8633 the symbols that need them. */
8634 if (g
->global_gotsym
!= NULL
8635 && h
->dynindx
>= g
->global_gotsym
->dynindx
)
8640 value
= sym
->st_value
;
8641 offset
= mips_elf_global_got_index (dynobj
, output_bfd
, h
, R_MIPS_GOT16
, info
);
8642 MIPS_ELF_PUT_WORD (output_bfd
, value
, sgot
->contents
+ offset
);
8645 if (g
->next
&& h
->dynindx
!= -1 && h
->type
!= STT_TLS
)
8647 struct mips_got_entry e
, *p
;
8653 e
.abfd
= output_bfd
;
8655 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
8658 for (g
= g
->next
; g
->next
!= gg
; g
= g
->next
)
8661 && (p
= (struct mips_got_entry
*) htab_find (g
->got_entries
,
8666 || (elf_hash_table (info
)->dynamic_sections_created
8668 && p
->d
.h
->root
.def_dynamic
8669 && !p
->d
.h
->root
.def_regular
))
8671 /* Create an R_MIPS_REL32 relocation for this entry. Due to
8672 the various compatibility problems, it's easier to mock
8673 up an R_MIPS_32 or R_MIPS_64 relocation and leave
8674 mips_elf_create_dynamic_relocation to calculate the
8675 appropriate addend. */
8676 Elf_Internal_Rela rel
[3];
8678 memset (rel
, 0, sizeof (rel
));
8679 if (ABI_64_P (output_bfd
))
8680 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_64
);
8682 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_32
);
8683 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
8686 if (! (mips_elf_create_dynamic_relocation
8687 (output_bfd
, info
, rel
,
8688 e
.d
.h
, NULL
, sym
->st_value
, &entry
, sgot
)))
8692 entry
= sym
->st_value
;
8693 MIPS_ELF_PUT_WORD (output_bfd
, entry
, sgot
->contents
+ offset
);
8698 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
8699 name
= h
->root
.root
.string
;
8700 if (strcmp (name
, "_DYNAMIC") == 0
8701 || h
== elf_hash_table (info
)->hgot
)
8702 sym
->st_shndx
= SHN_ABS
;
8703 else if (strcmp (name
, "_DYNAMIC_LINK") == 0
8704 || strcmp (name
, "_DYNAMIC_LINKING") == 0)
8706 sym
->st_shndx
= SHN_ABS
;
8707 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8710 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (output_bfd
))
8712 sym
->st_shndx
= SHN_ABS
;
8713 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8714 sym
->st_value
= elf_gp (output_bfd
);
8716 else if (SGI_COMPAT (output_bfd
))
8718 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
8719 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
8721 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8722 sym
->st_other
= STO_PROTECTED
;
8724 sym
->st_shndx
= SHN_MIPS_DATA
;
8726 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
8728 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8729 sym
->st_other
= STO_PROTECTED
;
8730 sym
->st_value
= mips_elf_hash_table (info
)->procedure_count
;
8731 sym
->st_shndx
= SHN_ABS
;
8733 else if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
!= SHN_ABS
)
8735 if (h
->type
== STT_FUNC
)
8736 sym
->st_shndx
= SHN_MIPS_TEXT
;
8737 else if (h
->type
== STT_OBJECT
)
8738 sym
->st_shndx
= SHN_MIPS_DATA
;
8742 /* Handle the IRIX6-specific symbols. */
8743 if (IRIX_COMPAT (output_bfd
) == ict_irix6
)
8744 mips_elf_irix6_finish_dynamic_symbol (output_bfd
, name
, sym
);
8748 if (! mips_elf_hash_table (info
)->use_rld_obj_head
8749 && (strcmp (name
, "__rld_map") == 0
8750 || strcmp (name
, "__RLD_MAP") == 0))
8752 asection
*s
= bfd_get_section_by_name (dynobj
, ".rld_map");
8753 BFD_ASSERT (s
!= NULL
);
8754 sym
->st_value
= s
->output_section
->vma
+ s
->output_offset
;
8755 bfd_put_32 (output_bfd
, 0, s
->contents
);
8756 if (mips_elf_hash_table (info
)->rld_value
== 0)
8757 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
8759 else if (mips_elf_hash_table (info
)->use_rld_obj_head
8760 && strcmp (name
, "__rld_obj_head") == 0)
8762 /* IRIX6 does not use a .rld_map section. */
8763 if (IRIX_COMPAT (output_bfd
) == ict_irix5
8764 || IRIX_COMPAT (output_bfd
) == ict_none
)
8765 BFD_ASSERT (bfd_get_section_by_name (dynobj
, ".rld_map")
8767 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
8771 /* If this is a mips16 symbol, force the value to be even. */
8772 if (ELF_ST_IS_MIPS16 (sym
->st_other
))
8773 sym
->st_value
&= ~1;
8778 /* Likewise, for VxWorks. */
8781 _bfd_mips_vxworks_finish_dynamic_symbol (bfd
*output_bfd
,
8782 struct bfd_link_info
*info
,
8783 struct elf_link_hash_entry
*h
,
8784 Elf_Internal_Sym
*sym
)
8788 struct mips_got_info
*g
;
8789 struct mips_elf_link_hash_table
*htab
;
8791 htab
= mips_elf_hash_table (info
);
8792 dynobj
= elf_hash_table (info
)->dynobj
;
8794 if (h
->plt
.offset
!= (bfd_vma
) -1)
8797 bfd_vma plt_address
, plt_index
, got_address
, got_offset
, branch_offset
;
8798 Elf_Internal_Rela rel
;
8799 static const bfd_vma
*plt_entry
;
8801 BFD_ASSERT (h
->dynindx
!= -1);
8802 BFD_ASSERT (htab
->splt
!= NULL
);
8803 BFD_ASSERT (h
->plt
.offset
<= htab
->splt
->size
);
8805 /* Calculate the address of the .plt entry. */
8806 plt_address
= (htab
->splt
->output_section
->vma
8807 + htab
->splt
->output_offset
8810 /* Calculate the index of the entry. */
8811 plt_index
= ((h
->plt
.offset
- htab
->plt_header_size
)
8812 / htab
->plt_entry_size
);
8814 /* Calculate the address of the .got.plt entry. */
8815 got_address
= (htab
->sgotplt
->output_section
->vma
8816 + htab
->sgotplt
->output_offset
8819 /* Calculate the offset of the .got.plt entry from
8820 _GLOBAL_OFFSET_TABLE_. */
8821 got_offset
= mips_elf_gotplt_index (info
, h
);
8823 /* Calculate the offset for the branch at the start of the PLT
8824 entry. The branch jumps to the beginning of .plt. */
8825 branch_offset
= -(h
->plt
.offset
/ 4 + 1) & 0xffff;
8827 /* Fill in the initial value of the .got.plt entry. */
8828 bfd_put_32 (output_bfd
, plt_address
,
8829 htab
->sgotplt
->contents
+ plt_index
* 4);
8831 /* Find out where the .plt entry should go. */
8832 loc
= htab
->splt
->contents
+ h
->plt
.offset
;
8836 plt_entry
= mips_vxworks_shared_plt_entry
;
8837 bfd_put_32 (output_bfd
, plt_entry
[0] | branch_offset
, loc
);
8838 bfd_put_32 (output_bfd
, plt_entry
[1] | plt_index
, loc
+ 4);
8842 bfd_vma got_address_high
, got_address_low
;
8844 plt_entry
= mips_vxworks_exec_plt_entry
;
8845 got_address_high
= ((got_address
+ 0x8000) >> 16) & 0xffff;
8846 got_address_low
= got_address
& 0xffff;
8848 bfd_put_32 (output_bfd
, plt_entry
[0] | branch_offset
, loc
);
8849 bfd_put_32 (output_bfd
, plt_entry
[1] | plt_index
, loc
+ 4);
8850 bfd_put_32 (output_bfd
, plt_entry
[2] | got_address_high
, loc
+ 8);
8851 bfd_put_32 (output_bfd
, plt_entry
[3] | got_address_low
, loc
+ 12);
8852 bfd_put_32 (output_bfd
, plt_entry
[4], loc
+ 16);
8853 bfd_put_32 (output_bfd
, plt_entry
[5], loc
+ 20);
8854 bfd_put_32 (output_bfd
, plt_entry
[6], loc
+ 24);
8855 bfd_put_32 (output_bfd
, plt_entry
[7], loc
+ 28);
8857 loc
= (htab
->srelplt2
->contents
8858 + (plt_index
* 3 + 2) * sizeof (Elf32_External_Rela
));
8860 /* Emit a relocation for the .got.plt entry. */
8861 rel
.r_offset
= got_address
;
8862 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
, R_MIPS_32
);
8863 rel
.r_addend
= h
->plt
.offset
;
8864 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
8866 /* Emit a relocation for the lui of %hi(<.got.plt slot>). */
8867 loc
+= sizeof (Elf32_External_Rela
);
8868 rel
.r_offset
= plt_address
+ 8;
8869 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_HI16
);
8870 rel
.r_addend
= got_offset
;
8871 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
8873 /* Emit a relocation for the addiu of %lo(<.got.plt slot>). */
8874 loc
+= sizeof (Elf32_External_Rela
);
8876 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_LO16
);
8877 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
8880 /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry. */
8881 loc
= htab
->srelplt
->contents
+ plt_index
* sizeof (Elf32_External_Rela
);
8882 rel
.r_offset
= got_address
;
8883 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_JUMP_SLOT
);
8885 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
8887 if (!h
->def_regular
)
8888 sym
->st_shndx
= SHN_UNDEF
;
8891 BFD_ASSERT (h
->dynindx
!= -1 || h
->forced_local
);
8893 sgot
= mips_elf_got_section (dynobj
, FALSE
);
8894 BFD_ASSERT (sgot
!= NULL
);
8895 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
8896 g
= mips_elf_section_data (sgot
)->u
.got_info
;
8897 BFD_ASSERT (g
!= NULL
);
8899 /* See if this symbol has an entry in the GOT. */
8900 if (g
->global_gotsym
!= NULL
8901 && h
->dynindx
>= g
->global_gotsym
->dynindx
)
8904 Elf_Internal_Rela outrel
;
8908 /* Install the symbol value in the GOT. */
8909 offset
= mips_elf_global_got_index (dynobj
, output_bfd
, h
,
8910 R_MIPS_GOT16
, info
);
8911 MIPS_ELF_PUT_WORD (output_bfd
, sym
->st_value
, sgot
->contents
+ offset
);
8913 /* Add a dynamic relocation for it. */
8914 s
= mips_elf_rel_dyn_section (info
, FALSE
);
8915 loc
= s
->contents
+ (s
->reloc_count
++ * sizeof (Elf32_External_Rela
));
8916 outrel
.r_offset
= (sgot
->output_section
->vma
8917 + sgot
->output_offset
8919 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_32
);
8920 outrel
.r_addend
= 0;
8921 bfd_elf32_swap_reloca_out (dynobj
, &outrel
, loc
);
8924 /* Emit a copy reloc, if needed. */
8927 Elf_Internal_Rela rel
;
8929 BFD_ASSERT (h
->dynindx
!= -1);
8931 rel
.r_offset
= (h
->root
.u
.def
.section
->output_section
->vma
8932 + h
->root
.u
.def
.section
->output_offset
8933 + h
->root
.u
.def
.value
);
8934 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_COPY
);
8936 bfd_elf32_swap_reloca_out (output_bfd
, &rel
,
8937 htab
->srelbss
->contents
8938 + (htab
->srelbss
->reloc_count
8939 * sizeof (Elf32_External_Rela
)));
8940 ++htab
->srelbss
->reloc_count
;
8943 /* If this is a mips16 symbol, force the value to be even. */
8944 if (ELF_ST_IS_MIPS16 (sym
->st_other
))
8945 sym
->st_value
&= ~1;
8950 /* Install the PLT header for a VxWorks executable and finalize the
8951 contents of .rela.plt.unloaded. */
8954 mips_vxworks_finish_exec_plt (bfd
*output_bfd
, struct bfd_link_info
*info
)
8956 Elf_Internal_Rela rela
;
8958 bfd_vma got_value
, got_value_high
, got_value_low
, plt_address
;
8959 static const bfd_vma
*plt_entry
;
8960 struct mips_elf_link_hash_table
*htab
;
8962 htab
= mips_elf_hash_table (info
);
8963 plt_entry
= mips_vxworks_exec_plt0_entry
;
8965 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */
8966 got_value
= (htab
->root
.hgot
->root
.u
.def
.section
->output_section
->vma
8967 + htab
->root
.hgot
->root
.u
.def
.section
->output_offset
8968 + htab
->root
.hgot
->root
.u
.def
.value
);
8970 got_value_high
= ((got_value
+ 0x8000) >> 16) & 0xffff;
8971 got_value_low
= got_value
& 0xffff;
8973 /* Calculate the address of the PLT header. */
8974 plt_address
= htab
->splt
->output_section
->vma
+ htab
->splt
->output_offset
;
8976 /* Install the PLT header. */
8977 loc
= htab
->splt
->contents
;
8978 bfd_put_32 (output_bfd
, plt_entry
[0] | got_value_high
, loc
);
8979 bfd_put_32 (output_bfd
, plt_entry
[1] | got_value_low
, loc
+ 4);
8980 bfd_put_32 (output_bfd
, plt_entry
[2], loc
+ 8);
8981 bfd_put_32 (output_bfd
, plt_entry
[3], loc
+ 12);
8982 bfd_put_32 (output_bfd
, plt_entry
[4], loc
+ 16);
8983 bfd_put_32 (output_bfd
, plt_entry
[5], loc
+ 20);
8985 /* Output the relocation for the lui of %hi(_GLOBAL_OFFSET_TABLE_). */
8986 loc
= htab
->srelplt2
->contents
;
8987 rela
.r_offset
= plt_address
;
8988 rela
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_HI16
);
8990 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
8991 loc
+= sizeof (Elf32_External_Rela
);
8993 /* Output the relocation for the following addiu of
8994 %lo(_GLOBAL_OFFSET_TABLE_). */
8996 rela
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_LO16
);
8997 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
8998 loc
+= sizeof (Elf32_External_Rela
);
9000 /* Fix up the remaining relocations. They may have the wrong
9001 symbol index for _G_O_T_ or _P_L_T_ depending on the order
9002 in which symbols were output. */
9003 while (loc
< htab
->srelplt2
->contents
+ htab
->srelplt2
->size
)
9005 Elf_Internal_Rela rel
;
9007 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &rel
);
9008 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
, R_MIPS_32
);
9009 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
9010 loc
+= sizeof (Elf32_External_Rela
);
9012 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &rel
);
9013 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_HI16
);
9014 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
9015 loc
+= sizeof (Elf32_External_Rela
);
9017 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &rel
);
9018 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_LO16
);
9019 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
9020 loc
+= sizeof (Elf32_External_Rela
);
9024 /* Install the PLT header for a VxWorks shared library. */
9027 mips_vxworks_finish_shared_plt (bfd
*output_bfd
, struct bfd_link_info
*info
)
9030 struct mips_elf_link_hash_table
*htab
;
9032 htab
= mips_elf_hash_table (info
);
9034 /* We just need to copy the entry byte-by-byte. */
9035 for (i
= 0; i
< ARRAY_SIZE (mips_vxworks_shared_plt0_entry
); i
++)
9036 bfd_put_32 (output_bfd
, mips_vxworks_shared_plt0_entry
[i
],
9037 htab
->splt
->contents
+ i
* 4);
9040 /* Finish up the dynamic sections. */
9043 _bfd_mips_elf_finish_dynamic_sections (bfd
*output_bfd
,
9044 struct bfd_link_info
*info
)
9049 struct mips_got_info
*gg
, *g
;
9050 struct mips_elf_link_hash_table
*htab
;
9052 htab
= mips_elf_hash_table (info
);
9053 dynobj
= elf_hash_table (info
)->dynobj
;
9055 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
9057 sgot
= mips_elf_got_section (dynobj
, FALSE
);
9062 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
9063 gg
= mips_elf_section_data (sgot
)->u
.got_info
;
9064 BFD_ASSERT (gg
!= NULL
);
9065 g
= mips_elf_got_for_ibfd (gg
, output_bfd
);
9066 BFD_ASSERT (g
!= NULL
);
9069 if (elf_hash_table (info
)->dynamic_sections_created
)
9072 int dyn_to_skip
= 0, dyn_skipped
= 0;
9074 BFD_ASSERT (sdyn
!= NULL
);
9075 BFD_ASSERT (g
!= NULL
);
9077 for (b
= sdyn
->contents
;
9078 b
< sdyn
->contents
+ sdyn
->size
;
9079 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
9081 Elf_Internal_Dyn dyn
;
9085 bfd_boolean swap_out_p
;
9087 /* Read in the current dynamic entry. */
9088 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
9090 /* Assume that we're going to modify it and write it out. */
9096 dyn
.d_un
.d_val
= MIPS_ELF_REL_SIZE (dynobj
);
9100 BFD_ASSERT (htab
->is_vxworks
);
9101 dyn
.d_un
.d_val
= MIPS_ELF_RELA_SIZE (dynobj
);
9105 /* Rewrite DT_STRSZ. */
9107 _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
9112 if (htab
->is_vxworks
)
9114 /* _GLOBAL_OFFSET_TABLE_ is defined to be the beginning
9115 of the ".got" section in DYNOBJ. */
9116 s
= bfd_get_section_by_name (dynobj
, name
);
9117 BFD_ASSERT (s
!= NULL
);
9118 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
9122 s
= bfd_get_section_by_name (output_bfd
, name
);
9123 BFD_ASSERT (s
!= NULL
);
9124 dyn
.d_un
.d_ptr
= s
->vma
;
9128 case DT_MIPS_RLD_VERSION
:
9129 dyn
.d_un
.d_val
= 1; /* XXX */
9133 dyn
.d_un
.d_val
= RHF_NOTPOT
; /* XXX */
9136 case DT_MIPS_TIME_STAMP
:
9144 case DT_MIPS_ICHECKSUM
:
9149 case DT_MIPS_IVERSION
:
9154 case DT_MIPS_BASE_ADDRESS
:
9155 s
= output_bfd
->sections
;
9156 BFD_ASSERT (s
!= NULL
);
9157 dyn
.d_un
.d_ptr
= s
->vma
& ~(bfd_vma
) 0xffff;
9160 case DT_MIPS_LOCAL_GOTNO
:
9161 dyn
.d_un
.d_val
= g
->local_gotno
;
9164 case DT_MIPS_UNREFEXTNO
:
9165 /* The index into the dynamic symbol table which is the
9166 entry of the first external symbol that is not
9167 referenced within the same object. */
9168 dyn
.d_un
.d_val
= bfd_count_sections (output_bfd
) + 1;
9171 case DT_MIPS_GOTSYM
:
9172 if (gg
->global_gotsym
)
9174 dyn
.d_un
.d_val
= gg
->global_gotsym
->dynindx
;
9177 /* In case if we don't have global got symbols we default
9178 to setting DT_MIPS_GOTSYM to the same value as
9179 DT_MIPS_SYMTABNO, so we just fall through. */
9181 case DT_MIPS_SYMTABNO
:
9183 elemsize
= MIPS_ELF_SYM_SIZE (output_bfd
);
9184 s
= bfd_get_section_by_name (output_bfd
, name
);
9185 BFD_ASSERT (s
!= NULL
);
9187 dyn
.d_un
.d_val
= s
->size
/ elemsize
;
9190 case DT_MIPS_HIPAGENO
:
9191 dyn
.d_un
.d_val
= g
->local_gotno
- MIPS_RESERVED_GOTNO (info
);
9194 case DT_MIPS_RLD_MAP
:
9195 dyn
.d_un
.d_ptr
= mips_elf_hash_table (info
)->rld_value
;
9198 case DT_MIPS_OPTIONS
:
9199 s
= (bfd_get_section_by_name
9200 (output_bfd
, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd
)));
9201 dyn
.d_un
.d_ptr
= s
->vma
;
9205 BFD_ASSERT (htab
->is_vxworks
);
9206 /* The count does not include the JUMP_SLOT relocations. */
9208 dyn
.d_un
.d_val
-= htab
->srelplt
->size
;
9212 BFD_ASSERT (htab
->is_vxworks
);
9213 dyn
.d_un
.d_val
= DT_RELA
;
9217 BFD_ASSERT (htab
->is_vxworks
);
9218 dyn
.d_un
.d_val
= htab
->srelplt
->size
;
9222 BFD_ASSERT (htab
->is_vxworks
);
9223 dyn
.d_un
.d_val
= (htab
->srelplt
->output_section
->vma
9224 + htab
->srelplt
->output_offset
);
9228 /* If we didn't need any text relocations after all, delete
9230 if (!(info
->flags
& DF_TEXTREL
))
9232 dyn_to_skip
= MIPS_ELF_DYN_SIZE (dynobj
);
9238 /* If we didn't need any text relocations after all, clear
9239 DF_TEXTREL from DT_FLAGS. */
9240 if (!(info
->flags
& DF_TEXTREL
))
9241 dyn
.d_un
.d_val
&= ~DF_TEXTREL
;
9248 if (htab
->is_vxworks
9249 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
9254 if (swap_out_p
|| dyn_skipped
)
9255 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
9256 (dynobj
, &dyn
, b
- dyn_skipped
);
9260 dyn_skipped
+= dyn_to_skip
;
9265 /* Wipe out any trailing entries if we shifted down a dynamic tag. */
9266 if (dyn_skipped
> 0)
9267 memset (b
- dyn_skipped
, 0, dyn_skipped
);
9270 if (sgot
!= NULL
&& sgot
->size
> 0
9271 && !bfd_is_abs_section (sgot
->output_section
))
9273 if (htab
->is_vxworks
)
9275 /* The first entry of the global offset table points to the
9276 ".dynamic" section. The second is initialized by the
9277 loader and contains the shared library identifier.
9278 The third is also initialized by the loader and points
9279 to the lazy resolution stub. */
9280 MIPS_ELF_PUT_WORD (output_bfd
,
9281 sdyn
->output_offset
+ sdyn
->output_section
->vma
,
9283 MIPS_ELF_PUT_WORD (output_bfd
, 0,
9284 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
9285 MIPS_ELF_PUT_WORD (output_bfd
, 0,
9287 + 2 * MIPS_ELF_GOT_SIZE (output_bfd
));
9291 /* The first entry of the global offset table will be filled at
9292 runtime. The second entry will be used by some runtime loaders.
9293 This isn't the case of IRIX rld. */
9294 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
9295 MIPS_ELF_PUT_WORD (output_bfd
, MIPS_ELF_GNU_GOT1_MASK (output_bfd
),
9296 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
9299 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
9300 = MIPS_ELF_GOT_SIZE (output_bfd
);
9303 /* Generate dynamic relocations for the non-primary gots. */
9304 if (gg
!= NULL
&& gg
->next
)
9306 Elf_Internal_Rela rel
[3];
9309 memset (rel
, 0, sizeof (rel
));
9310 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_REL32
);
9312 for (g
= gg
->next
; g
->next
!= gg
; g
= g
->next
)
9314 bfd_vma index
= g
->next
->local_gotno
+ g
->next
->global_gotno
9315 + g
->next
->tls_gotno
;
9317 MIPS_ELF_PUT_WORD (output_bfd
, 0, sgot
->contents
9318 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
9319 MIPS_ELF_PUT_WORD (output_bfd
, MIPS_ELF_GNU_GOT1_MASK (output_bfd
),
9321 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
9326 while (index
< g
->assigned_gotno
)
9328 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
9329 = index
++ * MIPS_ELF_GOT_SIZE (output_bfd
);
9330 if (!(mips_elf_create_dynamic_relocation
9331 (output_bfd
, info
, rel
, NULL
,
9332 bfd_abs_section_ptr
,
9335 BFD_ASSERT (addend
== 0);
9340 /* The generation of dynamic relocations for the non-primary gots
9341 adds more dynamic relocations. We cannot count them until
9344 if (elf_hash_table (info
)->dynamic_sections_created
)
9347 bfd_boolean swap_out_p
;
9349 BFD_ASSERT (sdyn
!= NULL
);
9351 for (b
= sdyn
->contents
;
9352 b
< sdyn
->contents
+ sdyn
->size
;
9353 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
9355 Elf_Internal_Dyn dyn
;
9358 /* Read in the current dynamic entry. */
9359 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
9361 /* Assume that we're going to modify it and write it out. */
9367 /* Reduce DT_RELSZ to account for any relocations we
9368 decided not to make. This is for the n64 irix rld,
9369 which doesn't seem to apply any relocations if there
9370 are trailing null entries. */
9371 s
= mips_elf_rel_dyn_section (info
, FALSE
);
9372 dyn
.d_un
.d_val
= (s
->reloc_count
9373 * (ABI_64_P (output_bfd
)
9374 ? sizeof (Elf64_Mips_External_Rel
)
9375 : sizeof (Elf32_External_Rel
)));
9376 /* Adjust the section size too. Tools like the prelinker
9377 can reasonably expect the values to the same. */
9378 elf_section_data (s
->output_section
)->this_hdr
.sh_size
9388 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
9395 Elf32_compact_rel cpt
;
9397 if (SGI_COMPAT (output_bfd
))
9399 /* Write .compact_rel section out. */
9400 s
= bfd_get_section_by_name (dynobj
, ".compact_rel");
9404 cpt
.num
= s
->reloc_count
;
9406 cpt
.offset
= (s
->output_section
->filepos
9407 + sizeof (Elf32_External_compact_rel
));
9410 bfd_elf32_swap_compact_rel_out (output_bfd
, &cpt
,
9411 ((Elf32_External_compact_rel
*)
9414 /* Clean up a dummy stub function entry in .text. */
9415 s
= bfd_get_section_by_name (dynobj
,
9416 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
9419 file_ptr dummy_offset
;
9421 BFD_ASSERT (s
->size
>= htab
->function_stub_size
);
9422 dummy_offset
= s
->size
- htab
->function_stub_size
;
9423 memset (s
->contents
+ dummy_offset
, 0,
9424 htab
->function_stub_size
);
9429 /* The psABI says that the dynamic relocations must be sorted in
9430 increasing order of r_symndx. The VxWorks EABI doesn't require
9431 this, and because the code below handles REL rather than RELA
9432 relocations, using it for VxWorks would be outright harmful. */
9433 if (!htab
->is_vxworks
)
9435 s
= mips_elf_rel_dyn_section (info
, FALSE
);
9437 && s
->size
> (bfd_vma
)2 * MIPS_ELF_REL_SIZE (output_bfd
))
9439 reldyn_sorting_bfd
= output_bfd
;
9441 if (ABI_64_P (output_bfd
))
9442 qsort ((Elf64_External_Rel
*) s
->contents
+ 1,
9443 s
->reloc_count
- 1, sizeof (Elf64_Mips_External_Rel
),
9444 sort_dynamic_relocs_64
);
9446 qsort ((Elf32_External_Rel
*) s
->contents
+ 1,
9447 s
->reloc_count
- 1, sizeof (Elf32_External_Rel
),
9448 sort_dynamic_relocs
);
9453 if (htab
->is_vxworks
&& htab
->splt
->size
> 0)
9456 mips_vxworks_finish_shared_plt (output_bfd
, info
);
9458 mips_vxworks_finish_exec_plt (output_bfd
, info
);
9464 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
9467 mips_set_isa_flags (bfd
*abfd
)
9471 switch (bfd_get_mach (abfd
))
9474 case bfd_mach_mips3000
:
9475 val
= E_MIPS_ARCH_1
;
9478 case bfd_mach_mips3900
:
9479 val
= E_MIPS_ARCH_1
| E_MIPS_MACH_3900
;
9482 case bfd_mach_mips6000
:
9483 val
= E_MIPS_ARCH_2
;
9486 case bfd_mach_mips4000
:
9487 case bfd_mach_mips4300
:
9488 case bfd_mach_mips4400
:
9489 case bfd_mach_mips4600
:
9490 val
= E_MIPS_ARCH_3
;
9493 case bfd_mach_mips4010
:
9494 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4010
;
9497 case bfd_mach_mips4100
:
9498 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4100
;
9501 case bfd_mach_mips4111
:
9502 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4111
;
9505 case bfd_mach_mips4120
:
9506 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4120
;
9509 case bfd_mach_mips4650
:
9510 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4650
;
9513 case bfd_mach_mips5400
:
9514 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5400
;
9517 case bfd_mach_mips5500
:
9518 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5500
;
9521 case bfd_mach_mips9000
:
9522 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_9000
;
9525 case bfd_mach_mips5000
:
9526 case bfd_mach_mips7000
:
9527 case bfd_mach_mips8000
:
9528 case bfd_mach_mips10000
:
9529 case bfd_mach_mips12000
:
9530 val
= E_MIPS_ARCH_4
;
9533 case bfd_mach_mips5
:
9534 val
= E_MIPS_ARCH_5
;
9537 case bfd_mach_mips_loongson_2e
:
9538 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_LS2E
;
9541 case bfd_mach_mips_loongson_2f
:
9542 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_LS2F
;
9545 case bfd_mach_mips_sb1
:
9546 val
= E_MIPS_ARCH_64
| E_MIPS_MACH_SB1
;
9549 case bfd_mach_mips_octeon
:
9550 val
= E_MIPS_ARCH_64R2
| E_MIPS_MACH_OCTEON
;
9553 case bfd_mach_mipsisa32
:
9554 val
= E_MIPS_ARCH_32
;
9557 case bfd_mach_mipsisa64
:
9558 val
= E_MIPS_ARCH_64
;
9561 case bfd_mach_mipsisa32r2
:
9562 val
= E_MIPS_ARCH_32R2
;
9565 case bfd_mach_mipsisa64r2
:
9566 val
= E_MIPS_ARCH_64R2
;
9569 elf_elfheader (abfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
9570 elf_elfheader (abfd
)->e_flags
|= val
;
9575 /* The final processing done just before writing out a MIPS ELF object
9576 file. This gets the MIPS architecture right based on the machine
9577 number. This is used by both the 32-bit and the 64-bit ABI. */
9580 _bfd_mips_elf_final_write_processing (bfd
*abfd
,
9581 bfd_boolean linker ATTRIBUTE_UNUSED
)
9584 Elf_Internal_Shdr
**hdrpp
;
9588 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
9589 is nonzero. This is for compatibility with old objects, which used
9590 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
9591 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_MACH
) == 0)
9592 mips_set_isa_flags (abfd
);
9594 /* Set the sh_info field for .gptab sections and other appropriate
9595 info for each special section. */
9596 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
9597 i
< elf_numsections (abfd
);
9600 switch ((*hdrpp
)->sh_type
)
9603 case SHT_MIPS_LIBLIST
:
9604 sec
= bfd_get_section_by_name (abfd
, ".dynstr");
9606 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
9609 case SHT_MIPS_GPTAB
:
9610 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
9611 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
9612 BFD_ASSERT (name
!= NULL
9613 && CONST_STRNEQ (name
, ".gptab."));
9614 sec
= bfd_get_section_by_name (abfd
, name
+ sizeof ".gptab" - 1);
9615 BFD_ASSERT (sec
!= NULL
);
9616 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
9619 case SHT_MIPS_CONTENT
:
9620 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
9621 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
9622 BFD_ASSERT (name
!= NULL
9623 && CONST_STRNEQ (name
, ".MIPS.content"));
9624 sec
= bfd_get_section_by_name (abfd
,
9625 name
+ sizeof ".MIPS.content" - 1);
9626 BFD_ASSERT (sec
!= NULL
);
9627 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
9630 case SHT_MIPS_SYMBOL_LIB
:
9631 sec
= bfd_get_section_by_name (abfd
, ".dynsym");
9633 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
9634 sec
= bfd_get_section_by_name (abfd
, ".liblist");
9636 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
9639 case SHT_MIPS_EVENTS
:
9640 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
9641 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
9642 BFD_ASSERT (name
!= NULL
);
9643 if (CONST_STRNEQ (name
, ".MIPS.events"))
9644 sec
= bfd_get_section_by_name (abfd
,
9645 name
+ sizeof ".MIPS.events" - 1);
9648 BFD_ASSERT (CONST_STRNEQ (name
, ".MIPS.post_rel"));
9649 sec
= bfd_get_section_by_name (abfd
,
9651 + sizeof ".MIPS.post_rel" - 1));
9653 BFD_ASSERT (sec
!= NULL
);
9654 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
9661 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
9665 _bfd_mips_elf_additional_program_headers (bfd
*abfd
,
9666 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
9671 /* See if we need a PT_MIPS_REGINFO segment. */
9672 s
= bfd_get_section_by_name (abfd
, ".reginfo");
9673 if (s
&& (s
->flags
& SEC_LOAD
))
9676 /* See if we need a PT_MIPS_OPTIONS segment. */
9677 if (IRIX_COMPAT (abfd
) == ict_irix6
9678 && bfd_get_section_by_name (abfd
,
9679 MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)))
9682 /* See if we need a PT_MIPS_RTPROC segment. */
9683 if (IRIX_COMPAT (abfd
) == ict_irix5
9684 && bfd_get_section_by_name (abfd
, ".dynamic")
9685 && bfd_get_section_by_name (abfd
, ".mdebug"))
9688 /* Allocate a PT_NULL header in dynamic objects. See
9689 _bfd_mips_elf_modify_segment_map for details. */
9690 if (!SGI_COMPAT (abfd
)
9691 && bfd_get_section_by_name (abfd
, ".dynamic"))
9697 /* Modify the segment map for an IRIX5 executable. */
9700 _bfd_mips_elf_modify_segment_map (bfd
*abfd
,
9701 struct bfd_link_info
*info
)
9704 struct elf_segment_map
*m
, **pm
;
9707 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
9709 s
= bfd_get_section_by_name (abfd
, ".reginfo");
9710 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
9712 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
9713 if (m
->p_type
== PT_MIPS_REGINFO
)
9718 m
= bfd_zalloc (abfd
, amt
);
9722 m
->p_type
= PT_MIPS_REGINFO
;
9726 /* We want to put it after the PHDR and INTERP segments. */
9727 pm
= &elf_tdata (abfd
)->segment_map
;
9729 && ((*pm
)->p_type
== PT_PHDR
9730 || (*pm
)->p_type
== PT_INTERP
))
9738 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
9739 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
9740 PT_MIPS_OPTIONS segment immediately following the program header
9743 /* On non-IRIX6 new abi, we'll have already created a segment
9744 for this section, so don't create another. I'm not sure this
9745 is not also the case for IRIX 6, but I can't test it right
9747 && IRIX_COMPAT (abfd
) == ict_irix6
)
9749 for (s
= abfd
->sections
; s
; s
= s
->next
)
9750 if (elf_section_data (s
)->this_hdr
.sh_type
== SHT_MIPS_OPTIONS
)
9755 struct elf_segment_map
*options_segment
;
9757 pm
= &elf_tdata (abfd
)->segment_map
;
9759 && ((*pm
)->p_type
== PT_PHDR
9760 || (*pm
)->p_type
== PT_INTERP
))
9763 if (*pm
== NULL
|| (*pm
)->p_type
!= PT_MIPS_OPTIONS
)
9765 amt
= sizeof (struct elf_segment_map
);
9766 options_segment
= bfd_zalloc (abfd
, amt
);
9767 options_segment
->next
= *pm
;
9768 options_segment
->p_type
= PT_MIPS_OPTIONS
;
9769 options_segment
->p_flags
= PF_R
;
9770 options_segment
->p_flags_valid
= TRUE
;
9771 options_segment
->count
= 1;
9772 options_segment
->sections
[0] = s
;
9773 *pm
= options_segment
;
9779 if (IRIX_COMPAT (abfd
) == ict_irix5
)
9781 /* If there are .dynamic and .mdebug sections, we make a room
9782 for the RTPROC header. FIXME: Rewrite without section names. */
9783 if (bfd_get_section_by_name (abfd
, ".interp") == NULL
9784 && bfd_get_section_by_name (abfd
, ".dynamic") != NULL
9785 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
9787 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
9788 if (m
->p_type
== PT_MIPS_RTPROC
)
9793 m
= bfd_zalloc (abfd
, amt
);
9797 m
->p_type
= PT_MIPS_RTPROC
;
9799 s
= bfd_get_section_by_name (abfd
, ".rtproc");
9804 m
->p_flags_valid
= 1;
9812 /* We want to put it after the DYNAMIC segment. */
9813 pm
= &elf_tdata (abfd
)->segment_map
;
9814 while (*pm
!= NULL
&& (*pm
)->p_type
!= PT_DYNAMIC
)
9824 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
9825 .dynstr, .dynsym, and .hash sections, and everything in
9827 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
;
9829 if ((*pm
)->p_type
== PT_DYNAMIC
)
9832 if (m
!= NULL
&& IRIX_COMPAT (abfd
) == ict_none
)
9834 /* For a normal mips executable the permissions for the PT_DYNAMIC
9835 segment are read, write and execute. We do that here since
9836 the code in elf.c sets only the read permission. This matters
9837 sometimes for the dynamic linker. */
9838 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
9840 m
->p_flags
= PF_R
| PF_W
| PF_X
;
9841 m
->p_flags_valid
= 1;
9844 /* GNU/Linux binaries do not need the extended PT_DYNAMIC section.
9845 glibc's dynamic linker has traditionally derived the number of
9846 tags from the p_filesz field, and sometimes allocates stack
9847 arrays of that size. An overly-big PT_DYNAMIC segment can
9848 be actively harmful in such cases. Making PT_DYNAMIC contain
9849 other sections can also make life hard for the prelinker,
9850 which might move one of the other sections to a different
9852 if (SGI_COMPAT (abfd
)
9855 && strcmp (m
->sections
[0]->name
, ".dynamic") == 0)
9857 static const char *sec_names
[] =
9859 ".dynamic", ".dynstr", ".dynsym", ".hash"
9863 struct elf_segment_map
*n
;
9867 for (i
= 0; i
< sizeof sec_names
/ sizeof sec_names
[0]; i
++)
9869 s
= bfd_get_section_by_name (abfd
, sec_names
[i
]);
9870 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
9877 if (high
< s
->vma
+ sz
)
9883 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
9884 if ((s
->flags
& SEC_LOAD
) != 0
9886 && s
->vma
+ s
->size
<= high
)
9889 amt
= sizeof *n
+ (bfd_size_type
) (c
- 1) * sizeof (asection
*);
9890 n
= bfd_zalloc (abfd
, amt
);
9897 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
9899 if ((s
->flags
& SEC_LOAD
) != 0
9901 && s
->vma
+ s
->size
<= high
)
9912 /* Allocate a spare program header in dynamic objects so that tools
9913 like the prelinker can add an extra PT_LOAD entry.
9915 If the prelinker needs to make room for a new PT_LOAD entry, its
9916 standard procedure is to move the first (read-only) sections into
9917 the new (writable) segment. However, the MIPS ABI requires
9918 .dynamic to be in a read-only segment, and the section will often
9919 start within sizeof (ElfNN_Phdr) bytes of the last program header.
9921 Although the prelinker could in principle move .dynamic to a
9922 writable segment, it seems better to allocate a spare program
9923 header instead, and avoid the need to move any sections.
9924 There is a long tradition of allocating spare dynamic tags,
9925 so allocating a spare program header seems like a natural
9928 If INFO is NULL, we may be copying an already prelinked binary
9929 with objcopy or strip, so do not add this header. */
9931 && !SGI_COMPAT (abfd
)
9932 && bfd_get_section_by_name (abfd
, ".dynamic"))
9934 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
; pm
= &(*pm
)->next
)
9935 if ((*pm
)->p_type
== PT_NULL
)
9939 m
= bfd_zalloc (abfd
, sizeof (*m
));
9943 m
->p_type
= PT_NULL
;
9951 /* Return the section that should be marked against GC for a given
9955 _bfd_mips_elf_gc_mark_hook (asection
*sec
,
9956 struct bfd_link_info
*info
,
9957 Elf_Internal_Rela
*rel
,
9958 struct elf_link_hash_entry
*h
,
9959 Elf_Internal_Sym
*sym
)
9961 /* ??? Do mips16 stub sections need to be handled special? */
9964 switch (ELF_R_TYPE (sec
->owner
, rel
->r_info
))
9966 case R_MIPS_GNU_VTINHERIT
:
9967 case R_MIPS_GNU_VTENTRY
:
9971 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
9974 /* Update the got entry reference counts for the section being removed. */
9977 _bfd_mips_elf_gc_sweep_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
9978 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
9979 asection
*sec ATTRIBUTE_UNUSED
,
9980 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
)
9983 Elf_Internal_Shdr
*symtab_hdr
;
9984 struct elf_link_hash_entry
**sym_hashes
;
9985 bfd_signed_vma
*local_got_refcounts
;
9986 const Elf_Internal_Rela
*rel
, *relend
;
9987 unsigned long r_symndx
;
9988 struct elf_link_hash_entry
*h
;
9990 if (info
->relocatable
)
9993 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
9994 sym_hashes
= elf_sym_hashes (abfd
);
9995 local_got_refcounts
= elf_local_got_refcounts (abfd
);
9997 relend
= relocs
+ sec
->reloc_count
;
9998 for (rel
= relocs
; rel
< relend
; rel
++)
9999 switch (ELF_R_TYPE (abfd
, rel
->r_info
))
10002 case R_MIPS_CALL16
:
10003 case R_MIPS_CALL_HI16
:
10004 case R_MIPS_CALL_LO16
:
10005 case R_MIPS_GOT_HI16
:
10006 case R_MIPS_GOT_LO16
:
10007 case R_MIPS_GOT_DISP
:
10008 case R_MIPS_GOT_PAGE
:
10009 case R_MIPS_GOT_OFST
:
10010 /* ??? It would seem that the existing MIPS code does no sort
10011 of reference counting or whatnot on its GOT and PLT entries,
10012 so it is not possible to garbage collect them at this time. */
10023 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
10024 hiding the old indirect symbol. Process additional relocation
10025 information. Also called for weakdefs, in which case we just let
10026 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
10029 _bfd_mips_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
10030 struct elf_link_hash_entry
*dir
,
10031 struct elf_link_hash_entry
*ind
)
10033 struct mips_elf_link_hash_entry
*dirmips
, *indmips
;
10035 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
10037 if (ind
->root
.type
!= bfd_link_hash_indirect
)
10040 dirmips
= (struct mips_elf_link_hash_entry
*) dir
;
10041 indmips
= (struct mips_elf_link_hash_entry
*) ind
;
10042 dirmips
->possibly_dynamic_relocs
+= indmips
->possibly_dynamic_relocs
;
10043 if (indmips
->readonly_reloc
)
10044 dirmips
->readonly_reloc
= TRUE
;
10045 if (indmips
->no_fn_stub
)
10046 dirmips
->no_fn_stub
= TRUE
;
10048 if (dirmips
->tls_type
== 0)
10049 dirmips
->tls_type
= indmips
->tls_type
;
10053 _bfd_mips_elf_hide_symbol (struct bfd_link_info
*info
,
10054 struct elf_link_hash_entry
*entry
,
10055 bfd_boolean force_local
)
10059 struct mips_got_info
*g
;
10060 struct mips_elf_link_hash_entry
*h
;
10061 struct mips_elf_link_hash_table
*htab
;
10063 h
= (struct mips_elf_link_hash_entry
*) entry
;
10064 if (h
->forced_local
)
10066 h
->forced_local
= force_local
;
10068 dynobj
= elf_hash_table (info
)->dynobj
;
10069 htab
= mips_elf_hash_table (info
);
10070 if (dynobj
!= NULL
&& force_local
&& h
->root
.type
!= STT_TLS
10071 && (got
= mips_elf_got_section (dynobj
, TRUE
)) != NULL
10072 && (g
= mips_elf_section_data (got
)->u
.got_info
) != NULL
)
10076 struct mips_got_entry e
;
10077 struct mips_got_info
*gg
= g
;
10079 /* Since we're turning what used to be a global symbol into a
10080 local one, bump up the number of local entries of each GOT
10081 that had an entry for it. This will automatically decrease
10082 the number of global entries, since global_gotno is actually
10083 the upper limit of global entries. */
10089 for (g
= g
->next
; g
!= gg
; g
= g
->next
)
10090 if (htab_find (g
->got_entries
, &e
))
10092 BFD_ASSERT (g
->global_gotno
> 0);
10097 /* If this was a global symbol forced into the primary GOT, we
10098 no longer need an entry for it. We can't release the entry
10099 at this point, but we must at least stop counting it as one
10100 of the symbols that required a forced got entry. */
10101 if (h
->root
.got
.offset
== 2)
10103 BFD_ASSERT (gg
->assigned_gotno
> 0);
10104 gg
->assigned_gotno
--;
10107 else if (h
->root
.got
.offset
== 1)
10109 /* check_relocs didn't know that this symbol would be
10110 forced-local, so add an extra local got entry. */
10112 if (htab
->computed_got_sizes
)
10114 /* We'll have treated this symbol as global rather
10116 BFD_ASSERT (g
->global_gotno
> 0);
10120 else if (htab
->is_vxworks
&& h
->root
.needs_plt
)
10122 /* check_relocs didn't know that this symbol would be
10123 forced-local, so add an extra local got entry. */
10125 if (htab
->computed_got_sizes
)
10126 /* The symbol is only used in call relocations, so we'll
10127 have assumed it only needs a .got.plt entry. Increase
10128 the size of .got accordingly. */
10129 got
->size
+= MIPS_ELF_GOT_SIZE (dynobj
);
10133 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
10136 #define PDR_SIZE 32
10139 _bfd_mips_elf_discard_info (bfd
*abfd
, struct elf_reloc_cookie
*cookie
,
10140 struct bfd_link_info
*info
)
10143 bfd_boolean ret
= FALSE
;
10144 unsigned char *tdata
;
10147 o
= bfd_get_section_by_name (abfd
, ".pdr");
10152 if (o
->size
% PDR_SIZE
!= 0)
10154 if (o
->output_section
!= NULL
10155 && bfd_is_abs_section (o
->output_section
))
10158 tdata
= bfd_zmalloc (o
->size
/ PDR_SIZE
);
10162 cookie
->rels
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
10163 info
->keep_memory
);
10170 cookie
->rel
= cookie
->rels
;
10171 cookie
->relend
= cookie
->rels
+ o
->reloc_count
;
10173 for (i
= 0, skip
= 0; i
< o
->size
/ PDR_SIZE
; i
++)
10175 if (bfd_elf_reloc_symbol_deleted_p (i
* PDR_SIZE
, cookie
))
10184 mips_elf_section_data (o
)->u
.tdata
= tdata
;
10185 o
->size
-= skip
* PDR_SIZE
;
10191 if (! info
->keep_memory
)
10192 free (cookie
->rels
);
10198 _bfd_mips_elf_ignore_discarded_relocs (asection
*sec
)
10200 if (strcmp (sec
->name
, ".pdr") == 0)
10206 _bfd_mips_elf_write_section (bfd
*output_bfd
,
10207 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
10208 asection
*sec
, bfd_byte
*contents
)
10210 bfd_byte
*to
, *from
, *end
;
10213 if (strcmp (sec
->name
, ".pdr") != 0)
10216 if (mips_elf_section_data (sec
)->u
.tdata
== NULL
)
10220 end
= contents
+ sec
->size
;
10221 for (from
= contents
, i
= 0;
10223 from
+= PDR_SIZE
, i
++)
10225 if ((mips_elf_section_data (sec
)->u
.tdata
)[i
] == 1)
10228 memcpy (to
, from
, PDR_SIZE
);
10231 bfd_set_section_contents (output_bfd
, sec
->output_section
, contents
,
10232 sec
->output_offset
, sec
->size
);
10236 /* MIPS ELF uses a special find_nearest_line routine in order the
10237 handle the ECOFF debugging information. */
10239 struct mips_elf_find_line
10241 struct ecoff_debug_info d
;
10242 struct ecoff_find_line i
;
10246 _bfd_mips_elf_find_nearest_line (bfd
*abfd
, asection
*section
,
10247 asymbol
**symbols
, bfd_vma offset
,
10248 const char **filename_ptr
,
10249 const char **functionname_ptr
,
10250 unsigned int *line_ptr
)
10254 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
10255 filename_ptr
, functionname_ptr
,
10259 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
10260 filename_ptr
, functionname_ptr
,
10261 line_ptr
, ABI_64_P (abfd
) ? 8 : 0,
10262 &elf_tdata (abfd
)->dwarf2_find_line_info
))
10265 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
10268 flagword origflags
;
10269 struct mips_elf_find_line
*fi
;
10270 const struct ecoff_debug_swap
* const swap
=
10271 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
10273 /* If we are called during a link, mips_elf_final_link may have
10274 cleared the SEC_HAS_CONTENTS field. We force it back on here
10275 if appropriate (which it normally will be). */
10276 origflags
= msec
->flags
;
10277 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
10278 msec
->flags
|= SEC_HAS_CONTENTS
;
10280 fi
= elf_tdata (abfd
)->find_line_info
;
10283 bfd_size_type external_fdr_size
;
10286 struct fdr
*fdr_ptr
;
10287 bfd_size_type amt
= sizeof (struct mips_elf_find_line
);
10289 fi
= bfd_zalloc (abfd
, amt
);
10292 msec
->flags
= origflags
;
10296 if (! _bfd_mips_elf_read_ecoff_info (abfd
, msec
, &fi
->d
))
10298 msec
->flags
= origflags
;
10302 /* Swap in the FDR information. */
10303 amt
= fi
->d
.symbolic_header
.ifdMax
* sizeof (struct fdr
);
10304 fi
->d
.fdr
= bfd_alloc (abfd
, amt
);
10305 if (fi
->d
.fdr
== NULL
)
10307 msec
->flags
= origflags
;
10310 external_fdr_size
= swap
->external_fdr_size
;
10311 fdr_ptr
= fi
->d
.fdr
;
10312 fraw_src
= (char *) fi
->d
.external_fdr
;
10313 fraw_end
= (fraw_src
10314 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
10315 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
10316 (*swap
->swap_fdr_in
) (abfd
, fraw_src
, fdr_ptr
);
10318 elf_tdata (abfd
)->find_line_info
= fi
;
10320 /* Note that we don't bother to ever free this information.
10321 find_nearest_line is either called all the time, as in
10322 objdump -l, so the information should be saved, or it is
10323 rarely called, as in ld error messages, so the memory
10324 wasted is unimportant. Still, it would probably be a
10325 good idea for free_cached_info to throw it away. */
10328 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
10329 &fi
->i
, filename_ptr
, functionname_ptr
,
10332 msec
->flags
= origflags
;
10336 msec
->flags
= origflags
;
10339 /* Fall back on the generic ELF find_nearest_line routine. */
10341 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
10342 filename_ptr
, functionname_ptr
,
10347 _bfd_mips_elf_find_inliner_info (bfd
*abfd
,
10348 const char **filename_ptr
,
10349 const char **functionname_ptr
,
10350 unsigned int *line_ptr
)
10353 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
10354 functionname_ptr
, line_ptr
,
10355 & elf_tdata (abfd
)->dwarf2_find_line_info
);
10360 /* When are writing out the .options or .MIPS.options section,
10361 remember the bytes we are writing out, so that we can install the
10362 GP value in the section_processing routine. */
10365 _bfd_mips_elf_set_section_contents (bfd
*abfd
, sec_ptr section
,
10366 const void *location
,
10367 file_ptr offset
, bfd_size_type count
)
10369 if (MIPS_ELF_OPTIONS_SECTION_NAME_P (section
->name
))
10373 if (elf_section_data (section
) == NULL
)
10375 bfd_size_type amt
= sizeof (struct bfd_elf_section_data
);
10376 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
10377 if (elf_section_data (section
) == NULL
)
10380 c
= mips_elf_section_data (section
)->u
.tdata
;
10383 c
= bfd_zalloc (abfd
, section
->size
);
10386 mips_elf_section_data (section
)->u
.tdata
= c
;
10389 memcpy (c
+ offset
, location
, count
);
10392 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
,
10396 /* This is almost identical to bfd_generic_get_... except that some
10397 MIPS relocations need to be handled specially. Sigh. */
10400 _bfd_elf_mips_get_relocated_section_contents
10402 struct bfd_link_info
*link_info
,
10403 struct bfd_link_order
*link_order
,
10405 bfd_boolean relocatable
,
10408 /* Get enough memory to hold the stuff */
10409 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
10410 asection
*input_section
= link_order
->u
.indirect
.section
;
10413 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
10414 arelent
**reloc_vector
= NULL
;
10417 if (reloc_size
< 0)
10420 reloc_vector
= bfd_malloc (reloc_size
);
10421 if (reloc_vector
== NULL
&& reloc_size
!= 0)
10424 /* read in the section */
10425 sz
= input_section
->rawsize
? input_section
->rawsize
: input_section
->size
;
10426 if (!bfd_get_section_contents (input_bfd
, input_section
, data
, 0, sz
))
10429 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
10433 if (reloc_count
< 0)
10436 if (reloc_count
> 0)
10441 bfd_vma gp
= 0x12345678; /* initialize just to shut gcc up */
10444 struct bfd_hash_entry
*h
;
10445 struct bfd_link_hash_entry
*lh
;
10446 /* Skip all this stuff if we aren't mixing formats. */
10447 if (abfd
&& input_bfd
10448 && abfd
->xvec
== input_bfd
->xvec
)
10452 h
= bfd_hash_lookup (&link_info
->hash
->table
, "_gp", FALSE
, FALSE
);
10453 lh
= (struct bfd_link_hash_entry
*) h
;
10460 case bfd_link_hash_undefined
:
10461 case bfd_link_hash_undefweak
:
10462 case bfd_link_hash_common
:
10465 case bfd_link_hash_defined
:
10466 case bfd_link_hash_defweak
:
10468 gp
= lh
->u
.def
.value
;
10470 case bfd_link_hash_indirect
:
10471 case bfd_link_hash_warning
:
10473 /* @@FIXME ignoring warning for now */
10475 case bfd_link_hash_new
:
10484 for (parent
= reloc_vector
; *parent
!= NULL
; parent
++)
10486 char *error_message
= NULL
;
10487 bfd_reloc_status_type r
;
10489 /* Specific to MIPS: Deal with relocation types that require
10490 knowing the gp of the output bfd. */
10491 asymbol
*sym
= *(*parent
)->sym_ptr_ptr
;
10493 /* If we've managed to find the gp and have a special
10494 function for the relocation then go ahead, else default
10495 to the generic handling. */
10497 && (*parent
)->howto
->special_function
10498 == _bfd_mips_elf32_gprel16_reloc
)
10499 r
= _bfd_mips_elf_gprel16_with_gp (input_bfd
, sym
, *parent
,
10500 input_section
, relocatable
,
10503 r
= bfd_perform_relocation (input_bfd
, *parent
, data
,
10505 relocatable
? abfd
: NULL
,
10510 asection
*os
= input_section
->output_section
;
10512 /* A partial link, so keep the relocs */
10513 os
->orelocation
[os
->reloc_count
] = *parent
;
10517 if (r
!= bfd_reloc_ok
)
10521 case bfd_reloc_undefined
:
10522 if (!((*link_info
->callbacks
->undefined_symbol
)
10523 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
10524 input_bfd
, input_section
, (*parent
)->address
, TRUE
)))
10527 case bfd_reloc_dangerous
:
10528 BFD_ASSERT (error_message
!= NULL
);
10529 if (!((*link_info
->callbacks
->reloc_dangerous
)
10530 (link_info
, error_message
, input_bfd
, input_section
,
10531 (*parent
)->address
)))
10534 case bfd_reloc_overflow
:
10535 if (!((*link_info
->callbacks
->reloc_overflow
)
10537 bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
10538 (*parent
)->howto
->name
, (*parent
)->addend
,
10539 input_bfd
, input_section
, (*parent
)->address
)))
10542 case bfd_reloc_outofrange
:
10551 if (reloc_vector
!= NULL
)
10552 free (reloc_vector
);
10556 if (reloc_vector
!= NULL
)
10557 free (reloc_vector
);
10561 /* Create a MIPS ELF linker hash table. */
10563 struct bfd_link_hash_table
*
10564 _bfd_mips_elf_link_hash_table_create (bfd
*abfd
)
10566 struct mips_elf_link_hash_table
*ret
;
10567 bfd_size_type amt
= sizeof (struct mips_elf_link_hash_table
);
10569 ret
= bfd_malloc (amt
);
10573 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
10574 mips_elf_link_hash_newfunc
,
10575 sizeof (struct mips_elf_link_hash_entry
)))
10582 /* We no longer use this. */
10583 for (i
= 0; i
< SIZEOF_MIPS_DYNSYM_SECNAMES
; i
++)
10584 ret
->dynsym_sec_strindex
[i
] = (bfd_size_type
) -1;
10586 ret
->procedure_count
= 0;
10587 ret
->compact_rel_size
= 0;
10588 ret
->use_rld_obj_head
= FALSE
;
10589 ret
->rld_value
= 0;
10590 ret
->mips16_stubs_seen
= FALSE
;
10591 ret
->computed_got_sizes
= FALSE
;
10592 ret
->is_vxworks
= FALSE
;
10593 ret
->small_data_overflow_reported
= FALSE
;
10594 ret
->srelbss
= NULL
;
10595 ret
->sdynbss
= NULL
;
10596 ret
->srelplt
= NULL
;
10597 ret
->srelplt2
= NULL
;
10598 ret
->sgotplt
= NULL
;
10600 ret
->plt_header_size
= 0;
10601 ret
->plt_entry_size
= 0;
10602 ret
->function_stub_size
= 0;
10604 return &ret
->root
.root
;
10607 /* Likewise, but indicate that the target is VxWorks. */
10609 struct bfd_link_hash_table
*
10610 _bfd_mips_vxworks_link_hash_table_create (bfd
*abfd
)
10612 struct bfd_link_hash_table
*ret
;
10614 ret
= _bfd_mips_elf_link_hash_table_create (abfd
);
10617 struct mips_elf_link_hash_table
*htab
;
10619 htab
= (struct mips_elf_link_hash_table
*) ret
;
10620 htab
->is_vxworks
= 1;
10625 /* We need to use a special link routine to handle the .reginfo and
10626 the .mdebug sections. We need to merge all instances of these
10627 sections together, not write them all out sequentially. */
10630 _bfd_mips_elf_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
10633 struct bfd_link_order
*p
;
10634 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
10635 asection
*rtproc_sec
;
10636 Elf32_RegInfo reginfo
;
10637 struct ecoff_debug_info debug
;
10638 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10639 const struct ecoff_debug_swap
*swap
= bed
->elf_backend_ecoff_debug_swap
;
10640 HDRR
*symhdr
= &debug
.symbolic_header
;
10641 void *mdebug_handle
= NULL
;
10646 struct mips_elf_link_hash_table
*htab
;
10648 static const char * const secname
[] =
10650 ".text", ".init", ".fini", ".data",
10651 ".rodata", ".sdata", ".sbss", ".bss"
10653 static const int sc
[] =
10655 scText
, scInit
, scFini
, scData
,
10656 scRData
, scSData
, scSBss
, scBss
10659 /* We'd carefully arranged the dynamic symbol indices, and then the
10660 generic size_dynamic_sections renumbered them out from under us.
10661 Rather than trying somehow to prevent the renumbering, just do
10663 htab
= mips_elf_hash_table (info
);
10664 if (elf_hash_table (info
)->dynamic_sections_created
)
10668 struct mips_got_info
*g
;
10669 bfd_size_type dynsecsymcount
;
10671 /* When we resort, we must tell mips_elf_sort_hash_table what
10672 the lowest index it may use is. That's the number of section
10673 symbols we're going to add. The generic ELF linker only
10674 adds these symbols when building a shared object. Note that
10675 we count the sections after (possibly) removing the .options
10678 dynsecsymcount
= count_section_dynsyms (abfd
, info
);
10679 if (! mips_elf_sort_hash_table (info
, dynsecsymcount
+ 1))
10682 /* Make sure we didn't grow the global .got region. */
10683 dynobj
= elf_hash_table (info
)->dynobj
;
10684 got
= mips_elf_got_section (dynobj
, FALSE
);
10685 g
= mips_elf_section_data (got
)->u
.got_info
;
10687 if (g
->global_gotsym
!= NULL
)
10688 BFD_ASSERT ((elf_hash_table (info
)->dynsymcount
10689 - g
->global_gotsym
->dynindx
)
10690 <= g
->global_gotno
);
10693 /* Get a value for the GP register. */
10694 if (elf_gp (abfd
) == 0)
10696 struct bfd_link_hash_entry
*h
;
10698 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
10699 if (h
!= NULL
&& h
->type
== bfd_link_hash_defined
)
10700 elf_gp (abfd
) = (h
->u
.def
.value
10701 + h
->u
.def
.section
->output_section
->vma
10702 + h
->u
.def
.section
->output_offset
);
10703 else if (htab
->is_vxworks
10704 && (h
= bfd_link_hash_lookup (info
->hash
,
10705 "_GLOBAL_OFFSET_TABLE_",
10706 FALSE
, FALSE
, TRUE
))
10707 && h
->type
== bfd_link_hash_defined
)
10708 elf_gp (abfd
) = (h
->u
.def
.section
->output_section
->vma
10709 + h
->u
.def
.section
->output_offset
10711 else if (info
->relocatable
)
10713 bfd_vma lo
= MINUS_ONE
;
10715 /* Find the GP-relative section with the lowest offset. */
10716 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
10718 && (elf_section_data (o
)->this_hdr
.sh_flags
& SHF_MIPS_GPREL
))
10721 /* And calculate GP relative to that. */
10722 elf_gp (abfd
) = lo
+ ELF_MIPS_GP_OFFSET (info
);
10726 /* If the relocate_section function needs to do a reloc
10727 involving the GP value, it should make a reloc_dangerous
10728 callback to warn that GP is not defined. */
10732 /* Go through the sections and collect the .reginfo and .mdebug
10734 reginfo_sec
= NULL
;
10736 gptab_data_sec
= NULL
;
10737 gptab_bss_sec
= NULL
;
10738 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
10740 if (strcmp (o
->name
, ".reginfo") == 0)
10742 memset (®info
, 0, sizeof reginfo
);
10744 /* We have found the .reginfo section in the output file.
10745 Look through all the link_orders comprising it and merge
10746 the information together. */
10747 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10749 asection
*input_section
;
10751 Elf32_External_RegInfo ext
;
10754 if (p
->type
!= bfd_indirect_link_order
)
10756 if (p
->type
== bfd_data_link_order
)
10761 input_section
= p
->u
.indirect
.section
;
10762 input_bfd
= input_section
->owner
;
10764 if (! bfd_get_section_contents (input_bfd
, input_section
,
10765 &ext
, 0, sizeof ext
))
10768 bfd_mips_elf32_swap_reginfo_in (input_bfd
, &ext
, &sub
);
10770 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
10771 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
10772 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
10773 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
10774 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
10776 /* ri_gp_value is set by the function
10777 mips_elf32_section_processing when the section is
10778 finally written out. */
10780 /* Hack: reset the SEC_HAS_CONTENTS flag so that
10781 elf_link_input_bfd ignores this section. */
10782 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
10785 /* Size has been set in _bfd_mips_elf_always_size_sections. */
10786 BFD_ASSERT(o
->size
== sizeof (Elf32_External_RegInfo
));
10788 /* Skip this section later on (I don't think this currently
10789 matters, but someday it might). */
10790 o
->map_head
.link_order
= NULL
;
10795 if (strcmp (o
->name
, ".mdebug") == 0)
10797 struct extsym_info einfo
;
10800 /* We have found the .mdebug section in the output file.
10801 Look through all the link_orders comprising it and merge
10802 the information together. */
10803 symhdr
->magic
= swap
->sym_magic
;
10804 /* FIXME: What should the version stamp be? */
10805 symhdr
->vstamp
= 0;
10806 symhdr
->ilineMax
= 0;
10807 symhdr
->cbLine
= 0;
10808 symhdr
->idnMax
= 0;
10809 symhdr
->ipdMax
= 0;
10810 symhdr
->isymMax
= 0;
10811 symhdr
->ioptMax
= 0;
10812 symhdr
->iauxMax
= 0;
10813 symhdr
->issMax
= 0;
10814 symhdr
->issExtMax
= 0;
10815 symhdr
->ifdMax
= 0;
10817 symhdr
->iextMax
= 0;
10819 /* We accumulate the debugging information itself in the
10820 debug_info structure. */
10822 debug
.external_dnr
= NULL
;
10823 debug
.external_pdr
= NULL
;
10824 debug
.external_sym
= NULL
;
10825 debug
.external_opt
= NULL
;
10826 debug
.external_aux
= NULL
;
10828 debug
.ssext
= debug
.ssext_end
= NULL
;
10829 debug
.external_fdr
= NULL
;
10830 debug
.external_rfd
= NULL
;
10831 debug
.external_ext
= debug
.external_ext_end
= NULL
;
10833 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
10834 if (mdebug_handle
== NULL
)
10838 esym
.cobol_main
= 0;
10842 esym
.asym
.iss
= issNil
;
10843 esym
.asym
.st
= stLocal
;
10844 esym
.asym
.reserved
= 0;
10845 esym
.asym
.index
= indexNil
;
10847 for (i
= 0; i
< sizeof (secname
) / sizeof (secname
[0]); i
++)
10849 esym
.asym
.sc
= sc
[i
];
10850 s
= bfd_get_section_by_name (abfd
, secname
[i
]);
10853 esym
.asym
.value
= s
->vma
;
10854 last
= s
->vma
+ s
->size
;
10857 esym
.asym
.value
= last
;
10858 if (!bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
10859 secname
[i
], &esym
))
10863 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10865 asection
*input_section
;
10867 const struct ecoff_debug_swap
*input_swap
;
10868 struct ecoff_debug_info input_debug
;
10872 if (p
->type
!= bfd_indirect_link_order
)
10874 if (p
->type
== bfd_data_link_order
)
10879 input_section
= p
->u
.indirect
.section
;
10880 input_bfd
= input_section
->owner
;
10882 if (bfd_get_flavour (input_bfd
) != bfd_target_elf_flavour
10883 || (get_elf_backend_data (input_bfd
)
10884 ->elf_backend_ecoff_debug_swap
) == NULL
)
10886 /* I don't know what a non MIPS ELF bfd would be
10887 doing with a .mdebug section, but I don't really
10888 want to deal with it. */
10892 input_swap
= (get_elf_backend_data (input_bfd
)
10893 ->elf_backend_ecoff_debug_swap
);
10895 BFD_ASSERT (p
->size
== input_section
->size
);
10897 /* The ECOFF linking code expects that we have already
10898 read in the debugging information and set up an
10899 ecoff_debug_info structure, so we do that now. */
10900 if (! _bfd_mips_elf_read_ecoff_info (input_bfd
, input_section
,
10904 if (! (bfd_ecoff_debug_accumulate
10905 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
10906 &input_debug
, input_swap
, info
)))
10909 /* Loop through the external symbols. For each one with
10910 interesting information, try to find the symbol in
10911 the linker global hash table and save the information
10912 for the output external symbols. */
10913 eraw_src
= input_debug
.external_ext
;
10914 eraw_end
= (eraw_src
10915 + (input_debug
.symbolic_header
.iextMax
10916 * input_swap
->external_ext_size
));
10918 eraw_src
< eraw_end
;
10919 eraw_src
+= input_swap
->external_ext_size
)
10923 struct mips_elf_link_hash_entry
*h
;
10925 (*input_swap
->swap_ext_in
) (input_bfd
, eraw_src
, &ext
);
10926 if (ext
.asym
.sc
== scNil
10927 || ext
.asym
.sc
== scUndefined
10928 || ext
.asym
.sc
== scSUndefined
)
10931 name
= input_debug
.ssext
+ ext
.asym
.iss
;
10932 h
= mips_elf_link_hash_lookup (mips_elf_hash_table (info
),
10933 name
, FALSE
, FALSE
, TRUE
);
10934 if (h
== NULL
|| h
->esym
.ifd
!= -2)
10939 BFD_ASSERT (ext
.ifd
10940 < input_debug
.symbolic_header
.ifdMax
);
10941 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
10947 /* Free up the information we just read. */
10948 free (input_debug
.line
);
10949 free (input_debug
.external_dnr
);
10950 free (input_debug
.external_pdr
);
10951 free (input_debug
.external_sym
);
10952 free (input_debug
.external_opt
);
10953 free (input_debug
.external_aux
);
10954 free (input_debug
.ss
);
10955 free (input_debug
.ssext
);
10956 free (input_debug
.external_fdr
);
10957 free (input_debug
.external_rfd
);
10958 free (input_debug
.external_ext
);
10960 /* Hack: reset the SEC_HAS_CONTENTS flag so that
10961 elf_link_input_bfd ignores this section. */
10962 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
10965 if (SGI_COMPAT (abfd
) && info
->shared
)
10967 /* Create .rtproc section. */
10968 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
10969 if (rtproc_sec
== NULL
)
10971 flagword flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
10972 | SEC_LINKER_CREATED
| SEC_READONLY
);
10974 rtproc_sec
= bfd_make_section_with_flags (abfd
,
10977 if (rtproc_sec
== NULL
10978 || ! bfd_set_section_alignment (abfd
, rtproc_sec
, 4))
10982 if (! mips_elf_create_procedure_table (mdebug_handle
, abfd
,
10988 /* Build the external symbol information. */
10991 einfo
.debug
= &debug
;
10993 einfo
.failed
= FALSE
;
10994 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
10995 mips_elf_output_extsym
, &einfo
);
10999 /* Set the size of the .mdebug section. */
11000 o
->size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
11002 /* Skip this section later on (I don't think this currently
11003 matters, but someday it might). */
11004 o
->map_head
.link_order
= NULL
;
11009 if (CONST_STRNEQ (o
->name
, ".gptab."))
11011 const char *subname
;
11014 Elf32_External_gptab
*ext_tab
;
11017 /* The .gptab.sdata and .gptab.sbss sections hold
11018 information describing how the small data area would
11019 change depending upon the -G switch. These sections
11020 not used in executables files. */
11021 if (! info
->relocatable
)
11023 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
11025 asection
*input_section
;
11027 if (p
->type
!= bfd_indirect_link_order
)
11029 if (p
->type
== bfd_data_link_order
)
11034 input_section
= p
->u
.indirect
.section
;
11036 /* Hack: reset the SEC_HAS_CONTENTS flag so that
11037 elf_link_input_bfd ignores this section. */
11038 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
11041 /* Skip this section later on (I don't think this
11042 currently matters, but someday it might). */
11043 o
->map_head
.link_order
= NULL
;
11045 /* Really remove the section. */
11046 bfd_section_list_remove (abfd
, o
);
11047 --abfd
->section_count
;
11052 /* There is one gptab for initialized data, and one for
11053 uninitialized data. */
11054 if (strcmp (o
->name
, ".gptab.sdata") == 0)
11055 gptab_data_sec
= o
;
11056 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
11060 (*_bfd_error_handler
)
11061 (_("%s: illegal section name `%s'"),
11062 bfd_get_filename (abfd
), o
->name
);
11063 bfd_set_error (bfd_error_nonrepresentable_section
);
11067 /* The linker script always combines .gptab.data and
11068 .gptab.sdata into .gptab.sdata, and likewise for
11069 .gptab.bss and .gptab.sbss. It is possible that there is
11070 no .sdata or .sbss section in the output file, in which
11071 case we must change the name of the output section. */
11072 subname
= o
->name
+ sizeof ".gptab" - 1;
11073 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
11075 if (o
== gptab_data_sec
)
11076 o
->name
= ".gptab.data";
11078 o
->name
= ".gptab.bss";
11079 subname
= o
->name
+ sizeof ".gptab" - 1;
11080 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
11083 /* Set up the first entry. */
11085 amt
= c
* sizeof (Elf32_gptab
);
11086 tab
= bfd_malloc (amt
);
11089 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
11090 tab
[0].gt_header
.gt_unused
= 0;
11092 /* Combine the input sections. */
11093 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
11095 asection
*input_section
;
11097 bfd_size_type size
;
11098 unsigned long last
;
11099 bfd_size_type gpentry
;
11101 if (p
->type
!= bfd_indirect_link_order
)
11103 if (p
->type
== bfd_data_link_order
)
11108 input_section
= p
->u
.indirect
.section
;
11109 input_bfd
= input_section
->owner
;
11111 /* Combine the gptab entries for this input section one
11112 by one. We know that the input gptab entries are
11113 sorted by ascending -G value. */
11114 size
= input_section
->size
;
11116 for (gpentry
= sizeof (Elf32_External_gptab
);
11118 gpentry
+= sizeof (Elf32_External_gptab
))
11120 Elf32_External_gptab ext_gptab
;
11121 Elf32_gptab int_gptab
;
11127 if (! (bfd_get_section_contents
11128 (input_bfd
, input_section
, &ext_gptab
, gpentry
,
11129 sizeof (Elf32_External_gptab
))))
11135 bfd_mips_elf32_swap_gptab_in (input_bfd
, &ext_gptab
,
11137 val
= int_gptab
.gt_entry
.gt_g_value
;
11138 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
11141 for (look
= 1; look
< c
; look
++)
11143 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
11144 tab
[look
].gt_entry
.gt_bytes
+= add
;
11146 if (tab
[look
].gt_entry
.gt_g_value
== val
)
11152 Elf32_gptab
*new_tab
;
11155 /* We need a new table entry. */
11156 amt
= (bfd_size_type
) (c
+ 1) * sizeof (Elf32_gptab
);
11157 new_tab
= bfd_realloc (tab
, amt
);
11158 if (new_tab
== NULL
)
11164 tab
[c
].gt_entry
.gt_g_value
= val
;
11165 tab
[c
].gt_entry
.gt_bytes
= add
;
11167 /* Merge in the size for the next smallest -G
11168 value, since that will be implied by this new
11171 for (look
= 1; look
< c
; look
++)
11173 if (tab
[look
].gt_entry
.gt_g_value
< val
11175 || (tab
[look
].gt_entry
.gt_g_value
11176 > tab
[max
].gt_entry
.gt_g_value
)))
11180 tab
[c
].gt_entry
.gt_bytes
+=
11181 tab
[max
].gt_entry
.gt_bytes
;
11186 last
= int_gptab
.gt_entry
.gt_bytes
;
11189 /* Hack: reset the SEC_HAS_CONTENTS flag so that
11190 elf_link_input_bfd ignores this section. */
11191 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
11194 /* The table must be sorted by -G value. */
11196 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
11198 /* Swap out the table. */
11199 amt
= (bfd_size_type
) c
* sizeof (Elf32_External_gptab
);
11200 ext_tab
= bfd_alloc (abfd
, amt
);
11201 if (ext_tab
== NULL
)
11207 for (j
= 0; j
< c
; j
++)
11208 bfd_mips_elf32_swap_gptab_out (abfd
, tab
+ j
, ext_tab
+ j
);
11211 o
->size
= c
* sizeof (Elf32_External_gptab
);
11212 o
->contents
= (bfd_byte
*) ext_tab
;
11214 /* Skip this section later on (I don't think this currently
11215 matters, but someday it might). */
11216 o
->map_head
.link_order
= NULL
;
11220 /* Invoke the regular ELF backend linker to do all the work. */
11221 if (!bfd_elf_final_link (abfd
, info
))
11224 /* Now write out the computed sections. */
11226 if (reginfo_sec
!= NULL
)
11228 Elf32_External_RegInfo ext
;
11230 bfd_mips_elf32_swap_reginfo_out (abfd
, ®info
, &ext
);
11231 if (! bfd_set_section_contents (abfd
, reginfo_sec
, &ext
, 0, sizeof ext
))
11235 if (mdebug_sec
!= NULL
)
11237 BFD_ASSERT (abfd
->output_has_begun
);
11238 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
11240 mdebug_sec
->filepos
))
11243 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
11246 if (gptab_data_sec
!= NULL
)
11248 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
11249 gptab_data_sec
->contents
,
11250 0, gptab_data_sec
->size
))
11254 if (gptab_bss_sec
!= NULL
)
11256 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
11257 gptab_bss_sec
->contents
,
11258 0, gptab_bss_sec
->size
))
11262 if (SGI_COMPAT (abfd
))
11264 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
11265 if (rtproc_sec
!= NULL
)
11267 if (! bfd_set_section_contents (abfd
, rtproc_sec
,
11268 rtproc_sec
->contents
,
11269 0, rtproc_sec
->size
))
11277 /* Structure for saying that BFD machine EXTENSION extends BASE. */
11279 struct mips_mach_extension
{
11280 unsigned long extension
, base
;
11284 /* An array describing how BFD machines relate to one another. The entries
11285 are ordered topologically with MIPS I extensions listed last. */
11287 static const struct mips_mach_extension mips_mach_extensions
[] = {
11288 /* MIPS64r2 extensions. */
11289 { bfd_mach_mips_octeon
, bfd_mach_mipsisa64r2
},
11291 /* MIPS64 extensions. */
11292 { bfd_mach_mipsisa64r2
, bfd_mach_mipsisa64
},
11293 { bfd_mach_mips_sb1
, bfd_mach_mipsisa64
},
11295 /* MIPS V extensions. */
11296 { bfd_mach_mipsisa64
, bfd_mach_mips5
},
11298 /* R10000 extensions. */
11299 { bfd_mach_mips12000
, bfd_mach_mips10000
},
11301 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
11302 vr5400 ISA, but doesn't include the multimedia stuff. It seems
11303 better to allow vr5400 and vr5500 code to be merged anyway, since
11304 many libraries will just use the core ISA. Perhaps we could add
11305 some sort of ASE flag if this ever proves a problem. */
11306 { bfd_mach_mips5500
, bfd_mach_mips5400
},
11307 { bfd_mach_mips5400
, bfd_mach_mips5000
},
11309 /* MIPS IV extensions. */
11310 { bfd_mach_mips5
, bfd_mach_mips8000
},
11311 { bfd_mach_mips10000
, bfd_mach_mips8000
},
11312 { bfd_mach_mips5000
, bfd_mach_mips8000
},
11313 { bfd_mach_mips7000
, bfd_mach_mips8000
},
11314 { bfd_mach_mips9000
, bfd_mach_mips8000
},
11316 /* VR4100 extensions. */
11317 { bfd_mach_mips4120
, bfd_mach_mips4100
},
11318 { bfd_mach_mips4111
, bfd_mach_mips4100
},
11320 /* MIPS III extensions. */
11321 { bfd_mach_mips_loongson_2e
, bfd_mach_mips4000
},
11322 { bfd_mach_mips_loongson_2f
, bfd_mach_mips4000
},
11323 { bfd_mach_mips8000
, bfd_mach_mips4000
},
11324 { bfd_mach_mips4650
, bfd_mach_mips4000
},
11325 { bfd_mach_mips4600
, bfd_mach_mips4000
},
11326 { bfd_mach_mips4400
, bfd_mach_mips4000
},
11327 { bfd_mach_mips4300
, bfd_mach_mips4000
},
11328 { bfd_mach_mips4100
, bfd_mach_mips4000
},
11329 { bfd_mach_mips4010
, bfd_mach_mips4000
},
11331 /* MIPS32 extensions. */
11332 { bfd_mach_mipsisa32r2
, bfd_mach_mipsisa32
},
11334 /* MIPS II extensions. */
11335 { bfd_mach_mips4000
, bfd_mach_mips6000
},
11336 { bfd_mach_mipsisa32
, bfd_mach_mips6000
},
11338 /* MIPS I extensions. */
11339 { bfd_mach_mips6000
, bfd_mach_mips3000
},
11340 { bfd_mach_mips3900
, bfd_mach_mips3000
}
11344 /* Return true if bfd machine EXTENSION is an extension of machine BASE. */
11347 mips_mach_extends_p (unsigned long base
, unsigned long extension
)
11351 if (extension
== base
)
11354 if (base
== bfd_mach_mipsisa32
11355 && mips_mach_extends_p (bfd_mach_mipsisa64
, extension
))
11358 if (base
== bfd_mach_mipsisa32r2
11359 && mips_mach_extends_p (bfd_mach_mipsisa64r2
, extension
))
11362 for (i
= 0; i
< ARRAY_SIZE (mips_mach_extensions
); i
++)
11363 if (extension
== mips_mach_extensions
[i
].extension
)
11365 extension
= mips_mach_extensions
[i
].base
;
11366 if (extension
== base
)
11374 /* Return true if the given ELF header flags describe a 32-bit binary. */
11377 mips_32bit_flags_p (flagword flags
)
11379 return ((flags
& EF_MIPS_32BITMODE
) != 0
11380 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
11381 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
11382 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
11383 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
11384 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
11385 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
);
11389 /* Merge object attributes from IBFD into OBFD. Raise an error if
11390 there are conflicting attributes. */
11392 mips_elf_merge_obj_attributes (bfd
*ibfd
, bfd
*obfd
)
11394 obj_attribute
*in_attr
;
11395 obj_attribute
*out_attr
;
11397 if (!elf_known_obj_attributes_proc (obfd
)[0].i
)
11399 /* This is the first object. Copy the attributes. */
11400 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
11402 /* Use the Tag_null value to indicate the attributes have been
11404 elf_known_obj_attributes_proc (obfd
)[0].i
= 1;
11409 /* Check for conflicting Tag_GNU_MIPS_ABI_FP attributes and merge
11410 non-conflicting ones. */
11411 in_attr
= elf_known_obj_attributes (ibfd
)[OBJ_ATTR_GNU
];
11412 out_attr
= elf_known_obj_attributes (obfd
)[OBJ_ATTR_GNU
];
11413 if (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
!= out_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
11415 out_attr
[Tag_GNU_MIPS_ABI_FP
].type
= 1;
11416 if (out_attr
[Tag_GNU_MIPS_ABI_FP
].i
== 0)
11417 out_attr
[Tag_GNU_MIPS_ABI_FP
].i
= in_attr
[Tag_GNU_MIPS_ABI_FP
].i
;
11418 else if (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
== 0)
11420 else if (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
> 4)
11422 (_("Warning: %B uses unknown floating point ABI %d"), ibfd
,
11423 in_attr
[Tag_GNU_MIPS_ABI_FP
].i
);
11424 else if (out_attr
[Tag_GNU_MIPS_ABI_FP
].i
> 4)
11426 (_("Warning: %B uses unknown floating point ABI %d"), obfd
,
11427 out_attr
[Tag_GNU_MIPS_ABI_FP
].i
);
11429 switch (out_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
11432 switch (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
11436 (_("Warning: %B uses -msingle-float, %B uses -mdouble-float"),
11442 (_("Warning: %B uses hard float, %B uses soft float"),
11448 (_("Warning: %B uses -msingle-float, %B uses -mips32r2 -mfp64"),
11458 switch (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
11462 (_("Warning: %B uses -msingle-float, %B uses -mdouble-float"),
11468 (_("Warning: %B uses hard float, %B uses soft float"),
11474 (_("Warning: %B uses -mdouble-float, %B uses -mips32r2 -mfp64"),
11484 switch (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
11490 (_("Warning: %B uses hard float, %B uses soft float"),
11500 switch (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
11504 (_("Warning: %B uses -msingle-float, %B uses -mips32r2 -mfp64"),
11510 (_("Warning: %B uses -mdouble-float, %B uses -mips32r2 -mfp64"),
11516 (_("Warning: %B uses hard float, %B uses soft float"),
11530 /* Merge Tag_compatibility attributes and any common GNU ones. */
11531 _bfd_elf_merge_object_attributes (ibfd
, obfd
);
11536 /* Merge backend specific data from an object file to the output
11537 object file when linking. */
11540 _bfd_mips_elf_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
11542 flagword old_flags
;
11543 flagword new_flags
;
11545 bfd_boolean null_input_bfd
= TRUE
;
11548 /* Check if we have the same endianess */
11549 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
11551 (*_bfd_error_handler
)
11552 (_("%B: endianness incompatible with that of the selected emulation"),
11557 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
11558 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
11561 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
11563 (*_bfd_error_handler
)
11564 (_("%B: ABI is incompatible with that of the selected emulation"),
11569 if (!mips_elf_merge_obj_attributes (ibfd
, obfd
))
11572 new_flags
= elf_elfheader (ibfd
)->e_flags
;
11573 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_NOREORDER
;
11574 old_flags
= elf_elfheader (obfd
)->e_flags
;
11576 if (! elf_flags_init (obfd
))
11578 elf_flags_init (obfd
) = TRUE
;
11579 elf_elfheader (obfd
)->e_flags
= new_flags
;
11580 elf_elfheader (obfd
)->e_ident
[EI_CLASS
]
11581 = elf_elfheader (ibfd
)->e_ident
[EI_CLASS
];
11583 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
11584 && (bfd_get_arch_info (obfd
)->the_default
11585 || mips_mach_extends_p (bfd_get_mach (obfd
),
11586 bfd_get_mach (ibfd
))))
11588 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
11589 bfd_get_mach (ibfd
)))
11596 /* Check flag compatibility. */
11598 new_flags
&= ~EF_MIPS_NOREORDER
;
11599 old_flags
&= ~EF_MIPS_NOREORDER
;
11601 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
11602 doesn't seem to matter. */
11603 new_flags
&= ~EF_MIPS_XGOT
;
11604 old_flags
&= ~EF_MIPS_XGOT
;
11606 /* MIPSpro generates ucode info in n64 objects. Again, we should
11607 just be able to ignore this. */
11608 new_flags
&= ~EF_MIPS_UCODE
;
11609 old_flags
&= ~EF_MIPS_UCODE
;
11611 /* Don't care about the PIC flags from dynamic objects; they are
11613 if ((new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0
11614 && (ibfd
->flags
& DYNAMIC
) != 0)
11615 new_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
11617 if (new_flags
== old_flags
)
11620 /* Check to see if the input BFD actually contains any sections.
11621 If not, its flags may not have been initialised either, but it cannot
11622 actually cause any incompatibility. */
11623 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
11625 /* Ignore synthetic sections and empty .text, .data and .bss sections
11626 which are automatically generated by gas. */
11627 if (strcmp (sec
->name
, ".reginfo")
11628 && strcmp (sec
->name
, ".mdebug")
11630 || (strcmp (sec
->name
, ".text")
11631 && strcmp (sec
->name
, ".data")
11632 && strcmp (sec
->name
, ".bss"))))
11634 null_input_bfd
= FALSE
;
11638 if (null_input_bfd
)
11643 if (((new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0)
11644 != ((old_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0))
11646 (*_bfd_error_handler
)
11647 (_("%B: warning: linking PIC files with non-PIC files"),
11652 if (new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
))
11653 elf_elfheader (obfd
)->e_flags
|= EF_MIPS_CPIC
;
11654 if (! (new_flags
& EF_MIPS_PIC
))
11655 elf_elfheader (obfd
)->e_flags
&= ~EF_MIPS_PIC
;
11657 new_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
11658 old_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
11660 /* Compare the ISAs. */
11661 if (mips_32bit_flags_p (old_flags
) != mips_32bit_flags_p (new_flags
))
11663 (*_bfd_error_handler
)
11664 (_("%B: linking 32-bit code with 64-bit code"),
11668 else if (!mips_mach_extends_p (bfd_get_mach (ibfd
), bfd_get_mach (obfd
)))
11670 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
11671 if (mips_mach_extends_p (bfd_get_mach (obfd
), bfd_get_mach (ibfd
)))
11673 /* Copy the architecture info from IBFD to OBFD. Also copy
11674 the 32-bit flag (if set) so that we continue to recognise
11675 OBFD as a 32-bit binary. */
11676 bfd_set_arch_info (obfd
, bfd_get_arch_info (ibfd
));
11677 elf_elfheader (obfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
11678 elf_elfheader (obfd
)->e_flags
11679 |= new_flags
& (EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
11681 /* Copy across the ABI flags if OBFD doesn't use them
11682 and if that was what caused us to treat IBFD as 32-bit. */
11683 if ((old_flags
& EF_MIPS_ABI
) == 0
11684 && mips_32bit_flags_p (new_flags
)
11685 && !mips_32bit_flags_p (new_flags
& ~EF_MIPS_ABI
))
11686 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ABI
;
11690 /* The ISAs aren't compatible. */
11691 (*_bfd_error_handler
)
11692 (_("%B: linking %s module with previous %s modules"),
11694 bfd_printable_name (ibfd
),
11695 bfd_printable_name (obfd
));
11700 new_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
11701 old_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
11703 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
11704 does set EI_CLASS differently from any 32-bit ABI. */
11705 if ((new_flags
& EF_MIPS_ABI
) != (old_flags
& EF_MIPS_ABI
)
11706 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
11707 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
11709 /* Only error if both are set (to different values). */
11710 if (((new_flags
& EF_MIPS_ABI
) && (old_flags
& EF_MIPS_ABI
))
11711 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
11712 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
11714 (*_bfd_error_handler
)
11715 (_("%B: ABI mismatch: linking %s module with previous %s modules"),
11717 elf_mips_abi_name (ibfd
),
11718 elf_mips_abi_name (obfd
));
11721 new_flags
&= ~EF_MIPS_ABI
;
11722 old_flags
&= ~EF_MIPS_ABI
;
11725 /* For now, allow arbitrary mixing of ASEs (retain the union). */
11726 if ((new_flags
& EF_MIPS_ARCH_ASE
) != (old_flags
& EF_MIPS_ARCH_ASE
))
11728 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ARCH_ASE
;
11730 new_flags
&= ~ EF_MIPS_ARCH_ASE
;
11731 old_flags
&= ~ EF_MIPS_ARCH_ASE
;
11734 /* Warn about any other mismatches */
11735 if (new_flags
!= old_flags
)
11737 (*_bfd_error_handler
)
11738 (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
11739 ibfd
, (unsigned long) new_flags
,
11740 (unsigned long) old_flags
);
11746 bfd_set_error (bfd_error_bad_value
);
11753 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
11756 _bfd_mips_elf_set_private_flags (bfd
*abfd
, flagword flags
)
11758 BFD_ASSERT (!elf_flags_init (abfd
)
11759 || elf_elfheader (abfd
)->e_flags
== flags
);
11761 elf_elfheader (abfd
)->e_flags
= flags
;
11762 elf_flags_init (abfd
) = TRUE
;
11767 _bfd_mips_elf_get_target_dtag (bfd_vma dtag
)
11771 default: return "";
11772 case DT_MIPS_RLD_VERSION
:
11773 return "MIPS_RLD_VERSION";
11774 case DT_MIPS_TIME_STAMP
:
11775 return "MIPS_TIME_STAMP";
11776 case DT_MIPS_ICHECKSUM
:
11777 return "MIPS_ICHECKSUM";
11778 case DT_MIPS_IVERSION
:
11779 return "MIPS_IVERSION";
11780 case DT_MIPS_FLAGS
:
11781 return "MIPS_FLAGS";
11782 case DT_MIPS_BASE_ADDRESS
:
11783 return "MIPS_BASE_ADDRESS";
11785 return "MIPS_MSYM";
11786 case DT_MIPS_CONFLICT
:
11787 return "MIPS_CONFLICT";
11788 case DT_MIPS_LIBLIST
:
11789 return "MIPS_LIBLIST";
11790 case DT_MIPS_LOCAL_GOTNO
:
11791 return "MIPS_LOCAL_GOTNO";
11792 case DT_MIPS_CONFLICTNO
:
11793 return "MIPS_CONFLICTNO";
11794 case DT_MIPS_LIBLISTNO
:
11795 return "MIPS_LIBLISTNO";
11796 case DT_MIPS_SYMTABNO
:
11797 return "MIPS_SYMTABNO";
11798 case DT_MIPS_UNREFEXTNO
:
11799 return "MIPS_UNREFEXTNO";
11800 case DT_MIPS_GOTSYM
:
11801 return "MIPS_GOTSYM";
11802 case DT_MIPS_HIPAGENO
:
11803 return "MIPS_HIPAGENO";
11804 case DT_MIPS_RLD_MAP
:
11805 return "MIPS_RLD_MAP";
11806 case DT_MIPS_DELTA_CLASS
:
11807 return "MIPS_DELTA_CLASS";
11808 case DT_MIPS_DELTA_CLASS_NO
:
11809 return "MIPS_DELTA_CLASS_NO";
11810 case DT_MIPS_DELTA_INSTANCE
:
11811 return "MIPS_DELTA_INSTANCE";
11812 case DT_MIPS_DELTA_INSTANCE_NO
:
11813 return "MIPS_DELTA_INSTANCE_NO";
11814 case DT_MIPS_DELTA_RELOC
:
11815 return "MIPS_DELTA_RELOC";
11816 case DT_MIPS_DELTA_RELOC_NO
:
11817 return "MIPS_DELTA_RELOC_NO";
11818 case DT_MIPS_DELTA_SYM
:
11819 return "MIPS_DELTA_SYM";
11820 case DT_MIPS_DELTA_SYM_NO
:
11821 return "MIPS_DELTA_SYM_NO";
11822 case DT_MIPS_DELTA_CLASSSYM
:
11823 return "MIPS_DELTA_CLASSSYM";
11824 case DT_MIPS_DELTA_CLASSSYM_NO
:
11825 return "MIPS_DELTA_CLASSSYM_NO";
11826 case DT_MIPS_CXX_FLAGS
:
11827 return "MIPS_CXX_FLAGS";
11828 case DT_MIPS_PIXIE_INIT
:
11829 return "MIPS_PIXIE_INIT";
11830 case DT_MIPS_SYMBOL_LIB
:
11831 return "MIPS_SYMBOL_LIB";
11832 case DT_MIPS_LOCALPAGE_GOTIDX
:
11833 return "MIPS_LOCALPAGE_GOTIDX";
11834 case DT_MIPS_LOCAL_GOTIDX
:
11835 return "MIPS_LOCAL_GOTIDX";
11836 case DT_MIPS_HIDDEN_GOTIDX
:
11837 return "MIPS_HIDDEN_GOTIDX";
11838 case DT_MIPS_PROTECTED_GOTIDX
:
11839 return "MIPS_PROTECTED_GOT_IDX";
11840 case DT_MIPS_OPTIONS
:
11841 return "MIPS_OPTIONS";
11842 case DT_MIPS_INTERFACE
:
11843 return "MIPS_INTERFACE";
11844 case DT_MIPS_DYNSTR_ALIGN
:
11845 return "DT_MIPS_DYNSTR_ALIGN";
11846 case DT_MIPS_INTERFACE_SIZE
:
11847 return "DT_MIPS_INTERFACE_SIZE";
11848 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
:
11849 return "DT_MIPS_RLD_TEXT_RESOLVE_ADDR";
11850 case DT_MIPS_PERF_SUFFIX
:
11851 return "DT_MIPS_PERF_SUFFIX";
11852 case DT_MIPS_COMPACT_SIZE
:
11853 return "DT_MIPS_COMPACT_SIZE";
11854 case DT_MIPS_GP_VALUE
:
11855 return "DT_MIPS_GP_VALUE";
11856 case DT_MIPS_AUX_DYNAMIC
:
11857 return "DT_MIPS_AUX_DYNAMIC";
11862 _bfd_mips_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
11866 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
11868 /* Print normal ELF private data. */
11869 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
11871 /* xgettext:c-format */
11872 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
11874 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
)
11875 fprintf (file
, _(" [abi=O32]"));
11876 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O64
)
11877 fprintf (file
, _(" [abi=O64]"));
11878 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
)
11879 fprintf (file
, _(" [abi=EABI32]"));
11880 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
11881 fprintf (file
, _(" [abi=EABI64]"));
11882 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
))
11883 fprintf (file
, _(" [abi unknown]"));
11884 else if (ABI_N32_P (abfd
))
11885 fprintf (file
, _(" [abi=N32]"));
11886 else if (ABI_64_P (abfd
))
11887 fprintf (file
, _(" [abi=64]"));
11889 fprintf (file
, _(" [no abi set]"));
11891 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
11892 fprintf (file
, " [mips1]");
11893 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
11894 fprintf (file
, " [mips2]");
11895 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
11896 fprintf (file
, " [mips3]");
11897 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
11898 fprintf (file
, " [mips4]");
11899 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_5
)
11900 fprintf (file
, " [mips5]");
11901 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
)
11902 fprintf (file
, " [mips32]");
11903 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64
)
11904 fprintf (file
, " [mips64]");
11905 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
)
11906 fprintf (file
, " [mips32r2]");
11907 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64R2
)
11908 fprintf (file
, " [mips64r2]");
11910 fprintf (file
, _(" [unknown ISA]"));
11912 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
11913 fprintf (file
, " [mdmx]");
11915 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_M16
)
11916 fprintf (file
, " [mips16]");
11918 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_32BITMODE
)
11919 fprintf (file
, " [32bitmode]");
11921 fprintf (file
, _(" [not 32bitmode]"));
11923 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_NOREORDER
)
11924 fprintf (file
, " [noreorder]");
11926 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_PIC
)
11927 fprintf (file
, " [PIC]");
11929 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_CPIC
)
11930 fprintf (file
, " [CPIC]");
11932 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_XGOT
)
11933 fprintf (file
, " [XGOT]");
11935 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_UCODE
)
11936 fprintf (file
, " [UCODE]");
11938 fputc ('\n', file
);
11943 const struct bfd_elf_special_section _bfd_mips_elf_special_sections
[] =
11945 { STRING_COMMA_LEN (".lit4"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
11946 { STRING_COMMA_LEN (".lit8"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
11947 { STRING_COMMA_LEN (".mdebug"), 0, SHT_MIPS_DEBUG
, 0 },
11948 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
11949 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
11950 { STRING_COMMA_LEN (".ucode"), 0, SHT_MIPS_UCODE
, 0 },
11951 { NULL
, 0, 0, 0, 0 }
11954 /* Merge non visibility st_other attributes. Ensure that the
11955 STO_OPTIONAL flag is copied into h->other, even if this is not a
11956 definiton of the symbol. */
11958 _bfd_mips_elf_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
11959 const Elf_Internal_Sym
*isym
,
11960 bfd_boolean definition
,
11961 bfd_boolean dynamic ATTRIBUTE_UNUSED
)
11963 if ((isym
->st_other
& ~ELF_ST_VISIBILITY (-1)) != 0)
11965 unsigned char other
;
11967 other
= (definition
? isym
->st_other
: h
->other
);
11968 other
&= ~ELF_ST_VISIBILITY (-1);
11969 h
->other
= other
| ELF_ST_VISIBILITY (h
->other
);
11973 && ELF_MIPS_IS_OPTIONAL (isym
->st_other
))
11974 h
->other
|= STO_OPTIONAL
;
11977 /* Decide whether an undefined symbol is special and can be ignored.
11978 This is the case for OPTIONAL symbols on IRIX. */
11980 _bfd_mips_elf_ignore_undef_symbol (struct elf_link_hash_entry
*h
)
11982 return ELF_MIPS_IS_OPTIONAL (h
->other
) ? TRUE
: FALSE
;
11986 _bfd_mips_elf_common_definition (Elf_Internal_Sym
*sym
)
11988 return (sym
->st_shndx
== SHN_COMMON
11989 || sym
->st_shndx
== SHN_MIPS_ACOMMON
11990 || sym
->st_shndx
== SHN_MIPS_SCOMMON
);