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 offset of $gp from the beginning of the .got section. */
652 #define ELF_MIPS_GP_OFFSET(INFO) \
653 (mips_elf_hash_table (INFO)->is_vxworks ? 0x0 : 0x7ff0)
655 /* The maximum size of the GOT for it to be addressable using 16-bit
657 #define MIPS_ELF_GOT_MAX_SIZE(INFO) (ELF_MIPS_GP_OFFSET (INFO) + 0x7fff)
659 /* Instructions which appear in a stub. */
660 #define STUB_LW(abfd) \
662 ? 0xdf998010 /* ld t9,0x8010(gp) */ \
663 : 0x8f998010)) /* lw t9,0x8010(gp) */
664 #define STUB_MOVE(abfd) \
666 ? 0x03e0782d /* daddu t7,ra */ \
667 : 0x03e07821)) /* addu t7,ra */
668 #define STUB_LUI(VAL) (0x3c180000 + (VAL)) /* lui t8,VAL */
669 #define STUB_JALR 0x0320f809 /* jalr t9,ra */
670 #define STUB_ORI(VAL) (0x37180000 + (VAL)) /* ori t8,t8,VAL */
671 #define STUB_LI16U(VAL) (0x34180000 + (VAL)) /* ori t8,zero,VAL unsigned */
672 #define STUB_LI16S(abfd, VAL) \
674 ? (0x64180000 + (VAL)) /* daddiu t8,zero,VAL sign extended */ \
675 : (0x24180000 + (VAL)))) /* addiu t8,zero,VAL sign extended */
677 #define MIPS_FUNCTION_STUB_NORMAL_SIZE 16
678 #define MIPS_FUNCTION_STUB_BIG_SIZE 20
680 /* The name of the dynamic interpreter. This is put in the .interp
683 #define ELF_DYNAMIC_INTERPRETER(abfd) \
684 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
685 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
686 : "/usr/lib/libc.so.1")
689 #define MNAME(bfd,pre,pos) \
690 (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
691 #define ELF_R_SYM(bfd, i) \
692 (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
693 #define ELF_R_TYPE(bfd, i) \
694 (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
695 #define ELF_R_INFO(bfd, s, t) \
696 (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
698 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
699 #define ELF_R_SYM(bfd, i) \
701 #define ELF_R_TYPE(bfd, i) \
703 #define ELF_R_INFO(bfd, s, t) \
704 (ELF32_R_INFO (s, t))
707 /* The mips16 compiler uses a couple of special sections to handle
708 floating point arguments.
710 Section names that look like .mips16.fn.FNNAME contain stubs that
711 copy floating point arguments from the fp regs to the gp regs and
712 then jump to FNNAME. If any 32 bit function calls FNNAME, the
713 call should be redirected to the stub instead. If no 32 bit
714 function calls FNNAME, the stub should be discarded. We need to
715 consider any reference to the function, not just a call, because
716 if the address of the function is taken we will need the stub,
717 since the address might be passed to a 32 bit function.
719 Section names that look like .mips16.call.FNNAME contain stubs
720 that copy floating point arguments from the gp regs to the fp
721 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
722 then any 16 bit function that calls FNNAME should be redirected
723 to the stub instead. If FNNAME is not a 32 bit function, the
724 stub should be discarded.
726 .mips16.call.fp.FNNAME sections are similar, but contain stubs
727 which call FNNAME and then copy the return value from the fp regs
728 to the gp regs. These stubs store the return value in $18 while
729 calling FNNAME; any function which might call one of these stubs
730 must arrange to save $18 around the call. (This case is not
731 needed for 32 bit functions that call 16 bit functions, because
732 16 bit functions always return floating point values in both
735 Note that in all cases FNNAME might be defined statically.
736 Therefore, FNNAME is not used literally. Instead, the relocation
737 information will indicate which symbol the section is for.
739 We record any stubs that we find in the symbol table. */
741 #define FN_STUB ".mips16.fn."
742 #define CALL_STUB ".mips16.call."
743 #define CALL_FP_STUB ".mips16.call.fp."
745 #define FN_STUB_P(name) CONST_STRNEQ (name, FN_STUB)
746 #define CALL_STUB_P(name) CONST_STRNEQ (name, CALL_STUB)
747 #define CALL_FP_STUB_P(name) CONST_STRNEQ (name, CALL_FP_STUB)
749 /* The format of the first PLT entry in a VxWorks executable. */
750 static const bfd_vma mips_vxworks_exec_plt0_entry[] = {
751 0x3c190000, /* lui t9, %hi(_GLOBAL_OFFSET_TABLE_) */
752 0x27390000, /* addiu t9, t9, %lo(_GLOBAL_OFFSET_TABLE_) */
753 0x8f390008, /* lw t9, 8(t9) */
754 0x00000000, /* nop */
755 0x03200008, /* jr t9 */
759 /* The format of subsequent PLT entries. */
760 static const bfd_vma mips_vxworks_exec_plt_entry[] = {
761 0x10000000, /* b .PLT_resolver */
762 0x24180000, /* li t8, <pltindex> */
763 0x3c190000, /* lui t9, %hi(<.got.plt slot>) */
764 0x27390000, /* addiu t9, t9, %lo(<.got.plt slot>) */
765 0x8f390000, /* lw t9, 0(t9) */
766 0x00000000, /* nop */
767 0x03200008, /* jr t9 */
771 /* The format of the first PLT entry in a VxWorks shared object. */
772 static const bfd_vma mips_vxworks_shared_plt0_entry[] = {
773 0x8f990008, /* lw t9, 8(gp) */
774 0x00000000, /* nop */
775 0x03200008, /* jr t9 */
776 0x00000000, /* nop */
777 0x00000000, /* nop */
781 /* The format of subsequent PLT entries. */
782 static const bfd_vma mips_vxworks_shared_plt_entry[] = {
783 0x10000000, /* b .PLT_resolver */
784 0x24180000 /* li t8, <pltindex> */
787 /* Look up an entry in a MIPS ELF linker hash table. */
789 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
790 ((struct mips_elf_link_hash_entry *) \
791 elf_link_hash_lookup (&(table)->root, (string), (create), \
794 /* Traverse a MIPS ELF linker hash table. */
796 #define mips_elf_link_hash_traverse(table, func, info) \
797 (elf_link_hash_traverse \
799 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
802 /* Get the MIPS ELF linker hash table from a link_info structure. */
804 #define mips_elf_hash_table(p) \
805 ((struct mips_elf_link_hash_table *) ((p)->hash))
807 /* Find the base offsets for thread-local storage in this object,
808 for GD/LD and IE/LE respectively. */
810 #define TP_OFFSET 0x7000
811 #define DTP_OFFSET 0x8000
814 dtprel_base (struct bfd_link_info *info)
816 /* If tls_sec is NULL, we should have signalled an error already. */
817 if (elf_hash_table (info)->tls_sec == NULL)
819 return elf_hash_table (info)->tls_sec->vma + DTP_OFFSET;
823 tprel_base (struct bfd_link_info *info)
825 /* If tls_sec is NULL, we should have signalled an error already. */
826 if (elf_hash_table (info)->tls_sec == NULL)
828 return elf_hash_table (info)->tls_sec->vma + TP_OFFSET;
831 /* Create an entry in a MIPS ELF linker hash table. */
833 static struct bfd_hash_entry *
834 mips_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
835 struct bfd_hash_table *table, const char *string)
837 struct mips_elf_link_hash_entry *ret =
838 (struct mips_elf_link_hash_entry *) entry;
840 /* Allocate the structure if it has not already been allocated by a
843 ret = bfd_hash_allocate (table, sizeof (struct mips_elf_link_hash_entry));
845 return (struct bfd_hash_entry *) ret;
847 /* Call the allocation method of the superclass. */
848 ret = ((struct mips_elf_link_hash_entry *)
849 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
853 /* Set local fields. */
854 memset (&ret->esym, 0, sizeof (EXTR));
855 /* We use -2 as a marker to indicate that the information has
856 not been set. -1 means there is no associated ifd. */
858 ret->possibly_dynamic_relocs = 0;
859 ret->readonly_reloc = FALSE;
860 ret->no_fn_stub = FALSE;
862 ret->need_fn_stub = FALSE;
863 ret->call_stub = NULL;
864 ret->call_fp_stub = NULL;
865 ret->forced_local = FALSE;
866 ret->is_branch_target = FALSE;
867 ret->is_relocation_target = FALSE;
868 ret->tls_type = GOT_NORMAL;
871 return (struct bfd_hash_entry *) ret;
875 _bfd_mips_elf_new_section_hook (bfd *abfd, asection *sec)
877 if (!sec->used_by_bfd)
879 struct _mips_elf_section_data *sdata;
880 bfd_size_type amt = sizeof (*sdata);
882 sdata = bfd_zalloc (abfd, amt);
885 sec->used_by_bfd = sdata;
888 return _bfd_elf_new_section_hook (abfd, sec);
891 /* Read ECOFF debugging information from a .mdebug section into a
892 ecoff_debug_info structure. */
895 _bfd_mips_elf_read_ecoff_info (bfd *abfd, asection *section,
896 struct ecoff_debug_info *debug)
899 const struct ecoff_debug_swap *swap;
902 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
903 memset (debug, 0, sizeof (*debug));
905 ext_hdr = bfd_malloc (swap->external_hdr_size);
906 if (ext_hdr == NULL && swap->external_hdr_size != 0)
909 if (! bfd_get_section_contents (abfd, section, ext_hdr, 0,
910 swap->external_hdr_size))
913 symhdr = &debug->symbolic_header;
914 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
916 /* The symbolic header contains absolute file offsets and sizes to
918 #define READ(ptr, offset, count, size, type) \
919 if (symhdr->count == 0) \
923 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
924 debug->ptr = bfd_malloc (amt); \
925 if (debug->ptr == NULL) \
927 if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0 \
928 || bfd_bread (debug->ptr, amt, abfd) != amt) \
932 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
933 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *);
934 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *);
935 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *);
936 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *);
937 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
939 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
940 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
941 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *);
942 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *);
943 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, void *);
953 if (debug->line != NULL)
955 if (debug->external_dnr != NULL)
956 free (debug->external_dnr);
957 if (debug->external_pdr != NULL)
958 free (debug->external_pdr);
959 if (debug->external_sym != NULL)
960 free (debug->external_sym);
961 if (debug->external_opt != NULL)
962 free (debug->external_opt);
963 if (debug->external_aux != NULL)
964 free (debug->external_aux);
965 if (debug->ss != NULL)
967 if (debug->ssext != NULL)
969 if (debug->external_fdr != NULL)
970 free (debug->external_fdr);
971 if (debug->external_rfd != NULL)
972 free (debug->external_rfd);
973 if (debug->external_ext != NULL)
974 free (debug->external_ext);
978 /* Swap RPDR (runtime procedure table entry) for output. */
981 ecoff_swap_rpdr_out (bfd *abfd, const RPDR *in, struct rpdr_ext *ex)
983 H_PUT_S32 (abfd, in->adr, ex->p_adr);
984 H_PUT_32 (abfd, in->regmask, ex->p_regmask);
985 H_PUT_32 (abfd, in->regoffset, ex->p_regoffset);
986 H_PUT_32 (abfd, in->fregmask, ex->p_fregmask);
987 H_PUT_32 (abfd, in->fregoffset, ex->p_fregoffset);
988 H_PUT_32 (abfd, in->frameoffset, ex->p_frameoffset);
990 H_PUT_16 (abfd, in->framereg, ex->p_framereg);
991 H_PUT_16 (abfd, in->pcreg, ex->p_pcreg);
993 H_PUT_32 (abfd, in->irpss, ex->p_irpss);
996 /* Create a runtime procedure table from the .mdebug section. */
999 mips_elf_create_procedure_table (void *handle, bfd *abfd,
1000 struct bfd_link_info *info, asection *s,
1001 struct ecoff_debug_info *debug)
1003 const struct ecoff_debug_swap *swap;
1004 HDRR *hdr = &debug->symbolic_header;
1006 struct rpdr_ext *erp;
1008 struct pdr_ext *epdr;
1009 struct sym_ext *esym;
1013 bfd_size_type count;
1014 unsigned long sindex;
1018 const char *no_name_func = _("static procedure (no name)");
1026 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1028 sindex = strlen (no_name_func) + 1;
1029 count = hdr->ipdMax;
1032 size = swap->external_pdr_size;
1034 epdr = bfd_malloc (size * count);
1038 if (! _bfd_ecoff_get_accumulated_pdr (handle, (bfd_byte *) epdr))
1041 size = sizeof (RPDR);
1042 rp = rpdr = bfd_malloc (size * count);
1046 size = sizeof (char *);
1047 sv = bfd_malloc (size * count);
1051 count = hdr->isymMax;
1052 size = swap->external_sym_size;
1053 esym = bfd_malloc (size * count);
1057 if (! _bfd_ecoff_get_accumulated_sym (handle, (bfd_byte *) esym))
1060 count = hdr->issMax;
1061 ss = bfd_malloc (count);
1064 if (! _bfd_ecoff_get_accumulated_ss (handle, (bfd_byte *) ss))
1067 count = hdr->ipdMax;
1068 for (i = 0; i < (unsigned long) count; i++, rp++)
1070 (*swap->swap_pdr_in) (abfd, epdr + i, &pdr);
1071 (*swap->swap_sym_in) (abfd, &esym[pdr.isym], &sym);
1072 rp->adr = sym.value;
1073 rp->regmask = pdr.regmask;
1074 rp->regoffset = pdr.regoffset;
1075 rp->fregmask = pdr.fregmask;
1076 rp->fregoffset = pdr.fregoffset;
1077 rp->frameoffset = pdr.frameoffset;
1078 rp->framereg = pdr.framereg;
1079 rp->pcreg = pdr.pcreg;
1081 sv[i] = ss + sym.iss;
1082 sindex += strlen (sv[i]) + 1;
1086 size = sizeof (struct rpdr_ext) * (count + 2) + sindex;
1087 size = BFD_ALIGN (size, 16);
1088 rtproc = bfd_alloc (abfd, size);
1091 mips_elf_hash_table (info)->procedure_count = 0;
1095 mips_elf_hash_table (info)->procedure_count = count + 2;
1098 memset (erp, 0, sizeof (struct rpdr_ext));
1100 str = (char *) rtproc + sizeof (struct rpdr_ext) * (count + 2);
1101 strcpy (str, no_name_func);
1102 str += strlen (no_name_func) + 1;
1103 for (i = 0; i < count; i++)
1105 ecoff_swap_rpdr_out (abfd, rpdr + i, erp + i);
1106 strcpy (str, sv[i]);
1107 str += strlen (sv[i]) + 1;
1109 H_PUT_S32 (abfd, -1, (erp + count)->p_adr);
1111 /* Set the size and contents of .rtproc section. */
1113 s->contents = rtproc;
1115 /* Skip this section later on (I don't think this currently
1116 matters, but someday it might). */
1117 s->map_head.link_order = NULL;
1146 /* Check the mips16 stubs for a particular symbol, and see if we can
1150 mips_elf_check_mips16_stubs (struct mips_elf_link_hash_entry *h,
1151 void *data ATTRIBUTE_UNUSED)
1153 if (h->root.root.type == bfd_link_hash_warning)
1154 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
1156 if (h->fn_stub != NULL
1157 && ! h->need_fn_stub)
1159 /* We don't need the fn_stub; the only references to this symbol
1160 are 16 bit calls. Clobber the size to 0 to prevent it from
1161 being included in the link. */
1162 h->fn_stub->size = 0;
1163 h->fn_stub->flags &= ~SEC_RELOC;
1164 h->fn_stub->reloc_count = 0;
1165 h->fn_stub->flags |= SEC_EXCLUDE;
1168 if (h->call_stub != NULL
1169 && h->root.other == STO_MIPS16)
1171 /* We don't need the call_stub; this is a 16 bit function, so
1172 calls from other 16 bit functions are OK. Clobber the size
1173 to 0 to prevent it from being included in the link. */
1174 h->call_stub->size = 0;
1175 h->call_stub->flags &= ~SEC_RELOC;
1176 h->call_stub->reloc_count = 0;
1177 h->call_stub->flags |= SEC_EXCLUDE;
1180 if (h->call_fp_stub != NULL
1181 && h->root.other == STO_MIPS16)
1183 /* We don't need the call_stub; this is a 16 bit function, so
1184 calls from other 16 bit functions are OK. Clobber the size
1185 to 0 to prevent it from being included in the link. */
1186 h->call_fp_stub->size = 0;
1187 h->call_fp_stub->flags &= ~SEC_RELOC;
1188 h->call_fp_stub->reloc_count = 0;
1189 h->call_fp_stub->flags |= SEC_EXCLUDE;
1195 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
1196 Most mips16 instructions are 16 bits, but these instructions
1199 The format of these instructions is:
1201 +--------------+--------------------------------+
1202 | JALX | X| Imm 20:16 | Imm 25:21 |
1203 +--------------+--------------------------------+
1205 +-----------------------------------------------+
1207 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
1208 Note that the immediate value in the first word is swapped.
1210 When producing a relocatable object file, R_MIPS16_26 is
1211 handled mostly like R_MIPS_26. In particular, the addend is
1212 stored as a straight 26-bit value in a 32-bit instruction.
1213 (gas makes life simpler for itself by never adjusting a
1214 R_MIPS16_26 reloc to be against a section, so the addend is
1215 always zero). However, the 32 bit instruction is stored as 2
1216 16-bit values, rather than a single 32-bit value. In a
1217 big-endian file, the result is the same; in a little-endian
1218 file, the two 16-bit halves of the 32 bit value are swapped.
1219 This is so that a disassembler can recognize the jal
1222 When doing a final link, R_MIPS16_26 is treated as a 32 bit
1223 instruction stored as two 16-bit values. The addend A is the
1224 contents of the targ26 field. The calculation is the same as
1225 R_MIPS_26. When storing the calculated value, reorder the
1226 immediate value as shown above, and don't forget to store the
1227 value as two 16-bit values.
1229 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
1233 +--------+----------------------+
1237 +--------+----------------------+
1240 +----------+------+-------------+
1244 +----------+--------------------+
1245 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
1246 ((sub1 << 16) | sub2)).
1248 When producing a relocatable object file, the calculation is
1249 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1250 When producing a fully linked file, the calculation is
1251 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1252 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)
1254 R_MIPS16_GPREL is used for GP-relative addressing in mips16
1255 mode. A typical instruction will have a format like this:
1257 +--------------+--------------------------------+
1258 | EXTEND | Imm 10:5 | Imm 15:11 |
1259 +--------------+--------------------------------+
1260 | Major | rx | ry | Imm 4:0 |
1261 +--------------+--------------------------------+
1263 EXTEND is the five bit value 11110. Major is the instruction
1266 This is handled exactly like R_MIPS_GPREL16, except that the
1267 addend is retrieved and stored as shown in this diagram; that
1268 is, the Imm fields above replace the V-rel16 field.
1270 All we need to do here is shuffle the bits appropriately. As
1271 above, the two 16-bit halves must be swapped on a
1272 little-endian system.
1274 R_MIPS16_HI16 and R_MIPS16_LO16 are used in mips16 mode to
1275 access data when neither GP-relative nor PC-relative addressing
1276 can be used. They are handled like R_MIPS_HI16 and R_MIPS_LO16,
1277 except that the addend is retrieved and stored as shown above
1281 _bfd_mips16_elf_reloc_unshuffle (bfd *abfd, int r_type,
1282 bfd_boolean jal_shuffle, bfd_byte *data)
1284 bfd_vma extend, insn, val;
1286 if (r_type != R_MIPS16_26 && r_type != R_MIPS16_GPREL
1287 && r_type != R_MIPS16_HI16 && r_type != R_MIPS16_LO16)
1290 /* Pick up the mips16 extend instruction and the real instruction. */
1291 extend = bfd_get_16 (abfd, data);
1292 insn = bfd_get_16 (abfd, data + 2);
1293 if (r_type == R_MIPS16_26)
1296 val = ((extend & 0xfc00) << 16) | ((extend & 0x3e0) << 11)
1297 | ((extend & 0x1f) << 21) | insn;
1299 val = extend << 16 | insn;
1302 val = ((extend & 0xf800) << 16) | ((insn & 0xffe0) << 11)
1303 | ((extend & 0x1f) << 11) | (extend & 0x7e0) | (insn & 0x1f);
1304 bfd_put_32 (abfd, val, data);
1308 _bfd_mips16_elf_reloc_shuffle (bfd *abfd, int r_type,
1309 bfd_boolean jal_shuffle, bfd_byte *data)
1311 bfd_vma extend, insn, val;
1313 if (r_type != R_MIPS16_26 && r_type != R_MIPS16_GPREL
1314 && r_type != R_MIPS16_HI16 && r_type != R_MIPS16_LO16)
1317 val = bfd_get_32 (abfd, data);
1318 if (r_type == R_MIPS16_26)
1322 insn = val & 0xffff;
1323 extend = ((val >> 16) & 0xfc00) | ((val >> 11) & 0x3e0)
1324 | ((val >> 21) & 0x1f);
1328 insn = val & 0xffff;
1334 insn = ((val >> 11) & 0xffe0) | (val & 0x1f);
1335 extend = ((val >> 16) & 0xf800) | ((val >> 11) & 0x1f) | (val & 0x7e0);
1337 bfd_put_16 (abfd, insn, data + 2);
1338 bfd_put_16 (abfd, extend, data);
1341 bfd_reloc_status_type
1342 _bfd_mips_elf_gprel16_with_gp (bfd *abfd, asymbol *symbol,
1343 arelent *reloc_entry, asection *input_section,
1344 bfd_boolean relocatable, void *data, bfd_vma gp)
1348 bfd_reloc_status_type status;
1350 if (bfd_is_com_section (symbol->section))
1353 relocation = symbol->value;
1355 relocation += symbol->section->output_section->vma;
1356 relocation += symbol->section->output_offset;
1358 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
1359 return bfd_reloc_outofrange;
1361 /* Set val to the offset into the section or symbol. */
1362 val = reloc_entry->addend;
1364 _bfd_mips_elf_sign_extend (val, 16);
1366 /* Adjust val for the final section location and GP value. If we
1367 are producing relocatable output, we don't want to do this for
1368 an external symbol. */
1370 || (symbol->flags & BSF_SECTION_SYM) != 0)
1371 val += relocation - gp;
1373 if (reloc_entry->howto->partial_inplace)
1375 status = _bfd_relocate_contents (reloc_entry->howto, abfd, val,
1377 + reloc_entry->address);
1378 if (status != bfd_reloc_ok)
1382 reloc_entry->addend = val;
1385 reloc_entry->address += input_section->output_offset;
1387 return bfd_reloc_ok;
1390 /* Used to store a REL high-part relocation such as R_MIPS_HI16 or
1391 R_MIPS_GOT16. REL is the relocation, INPUT_SECTION is the section
1392 that contains the relocation field and DATA points to the start of
1397 struct mips_hi16 *next;
1399 asection *input_section;
1403 /* FIXME: This should not be a static variable. */
1405 static struct mips_hi16 *mips_hi16_list;
1407 /* A howto special_function for REL *HI16 relocations. We can only
1408 calculate the correct value once we've seen the partnering
1409 *LO16 relocation, so just save the information for later.
1411 The ABI requires that the *LO16 immediately follow the *HI16.
1412 However, as a GNU extension, we permit an arbitrary number of
1413 *HI16s to be associated with a single *LO16. This significantly
1414 simplies the relocation handling in gcc. */
1416 bfd_reloc_status_type
1417 _bfd_mips_elf_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
1418 asymbol *symbol ATTRIBUTE_UNUSED, void *data,
1419 asection *input_section, bfd *output_bfd,
1420 char **error_message ATTRIBUTE_UNUSED)
1422 struct mips_hi16 *n;
1424 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
1425 return bfd_reloc_outofrange;
1427 n = bfd_malloc (sizeof *n);
1429 return bfd_reloc_outofrange;
1431 n->next = mips_hi16_list;
1433 n->input_section = input_section;
1434 n->rel = *reloc_entry;
1437 if (output_bfd != NULL)
1438 reloc_entry->address += input_section->output_offset;
1440 return bfd_reloc_ok;
1443 /* A howto special_function for REL R_MIPS_GOT16 relocations. This is just
1444 like any other 16-bit relocation when applied to global symbols, but is
1445 treated in the same as R_MIPS_HI16 when applied to local symbols. */
1447 bfd_reloc_status_type
1448 _bfd_mips_elf_got16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1449 void *data, asection *input_section,
1450 bfd *output_bfd, char **error_message)
1452 if ((symbol->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
1453 || bfd_is_und_section (bfd_get_section (symbol))
1454 || bfd_is_com_section (bfd_get_section (symbol)))
1455 /* The relocation is against a global symbol. */
1456 return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1457 input_section, output_bfd,
1460 return _bfd_mips_elf_hi16_reloc (abfd, reloc_entry, symbol, data,
1461 input_section, output_bfd, error_message);
1464 /* A howto special_function for REL *LO16 relocations. The *LO16 itself
1465 is a straightforward 16 bit inplace relocation, but we must deal with
1466 any partnering high-part relocations as well. */
1468 bfd_reloc_status_type
1469 _bfd_mips_elf_lo16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1470 void *data, asection *input_section,
1471 bfd *output_bfd, char **error_message)
1474 bfd_byte *location = (bfd_byte *) data + reloc_entry->address;
1476 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
1477 return bfd_reloc_outofrange;
1479 _bfd_mips16_elf_reloc_unshuffle (abfd, reloc_entry->howto->type, FALSE,
1481 vallo = bfd_get_32 (abfd, location);
1482 _bfd_mips16_elf_reloc_shuffle (abfd, reloc_entry->howto->type, FALSE,
1485 while (mips_hi16_list != NULL)
1487 bfd_reloc_status_type ret;
1488 struct mips_hi16 *hi;
1490 hi = mips_hi16_list;
1492 /* R_MIPS_GOT16 relocations are something of a special case. We
1493 want to install the addend in the same way as for a R_MIPS_HI16
1494 relocation (with a rightshift of 16). However, since GOT16
1495 relocations can also be used with global symbols, their howto
1496 has a rightshift of 0. */
1497 if (hi->rel.howto->type == R_MIPS_GOT16)
1498 hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MIPS_HI16, FALSE);
1500 /* VALLO is a signed 16-bit number. Bias it by 0x8000 so that any
1501 carry or borrow will induce a change of +1 or -1 in the high part. */
1502 hi->rel.addend += (vallo + 0x8000) & 0xffff;
1504 ret = _bfd_mips_elf_generic_reloc (abfd, &hi->rel, symbol, hi->data,
1505 hi->input_section, output_bfd,
1507 if (ret != bfd_reloc_ok)
1510 mips_hi16_list = hi->next;
1514 return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1515 input_section, output_bfd,
1519 /* A generic howto special_function. This calculates and installs the
1520 relocation itself, thus avoiding the oft-discussed problems in
1521 bfd_perform_relocation and bfd_install_relocation. */
1523 bfd_reloc_status_type
1524 _bfd_mips_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
1525 asymbol *symbol, void *data ATTRIBUTE_UNUSED,
1526 asection *input_section, bfd *output_bfd,
1527 char **error_message ATTRIBUTE_UNUSED)
1530 bfd_reloc_status_type status;
1531 bfd_boolean relocatable;
1533 relocatable = (output_bfd != NULL);
1535 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
1536 return bfd_reloc_outofrange;
1538 /* Build up the field adjustment in VAL. */
1540 if (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0)
1542 /* Either we're calculating the final field value or we have a
1543 relocation against a section symbol. Add in the section's
1544 offset or address. */
1545 val += symbol->section->output_section->vma;
1546 val += symbol->section->output_offset;
1551 /* We're calculating the final field value. Add in the symbol's value
1552 and, if pc-relative, subtract the address of the field itself. */
1553 val += symbol->value;
1554 if (reloc_entry->howto->pc_relative)
1556 val -= input_section->output_section->vma;
1557 val -= input_section->output_offset;
1558 val -= reloc_entry->address;
1562 /* VAL is now the final adjustment. If we're keeping this relocation
1563 in the output file, and if the relocation uses a separate addend,
1564 we just need to add VAL to that addend. Otherwise we need to add
1565 VAL to the relocation field itself. */
1566 if (relocatable && !reloc_entry->howto->partial_inplace)
1567 reloc_entry->addend += val;
1570 bfd_byte *location = (bfd_byte *) data + reloc_entry->address;
1572 /* Add in the separate addend, if any. */
1573 val += reloc_entry->addend;
1575 /* Add VAL to the relocation field. */
1576 _bfd_mips16_elf_reloc_unshuffle (abfd, reloc_entry->howto->type, FALSE,
1578 status = _bfd_relocate_contents (reloc_entry->howto, abfd, val,
1580 _bfd_mips16_elf_reloc_shuffle (abfd, reloc_entry->howto->type, FALSE,
1583 if (status != bfd_reloc_ok)
1588 reloc_entry->address += input_section->output_offset;
1590 return bfd_reloc_ok;
1593 /* Swap an entry in a .gptab section. Note that these routines rely
1594 on the equivalence of the two elements of the union. */
1597 bfd_mips_elf32_swap_gptab_in (bfd *abfd, const Elf32_External_gptab *ex,
1600 in->gt_entry.gt_g_value = H_GET_32 (abfd, ex->gt_entry.gt_g_value);
1601 in->gt_entry.gt_bytes = H_GET_32 (abfd, ex->gt_entry.gt_bytes);
1605 bfd_mips_elf32_swap_gptab_out (bfd *abfd, const Elf32_gptab *in,
1606 Elf32_External_gptab *ex)
1608 H_PUT_32 (abfd, in->gt_entry.gt_g_value, ex->gt_entry.gt_g_value);
1609 H_PUT_32 (abfd, in->gt_entry.gt_bytes, ex->gt_entry.gt_bytes);
1613 bfd_elf32_swap_compact_rel_out (bfd *abfd, const Elf32_compact_rel *in,
1614 Elf32_External_compact_rel *ex)
1616 H_PUT_32 (abfd, in->id1, ex->id1);
1617 H_PUT_32 (abfd, in->num, ex->num);
1618 H_PUT_32 (abfd, in->id2, ex->id2);
1619 H_PUT_32 (abfd, in->offset, ex->offset);
1620 H_PUT_32 (abfd, in->reserved0, ex->reserved0);
1621 H_PUT_32 (abfd, in->reserved1, ex->reserved1);
1625 bfd_elf32_swap_crinfo_out (bfd *abfd, const Elf32_crinfo *in,
1626 Elf32_External_crinfo *ex)
1630 l = (((in->ctype & CRINFO_CTYPE) << CRINFO_CTYPE_SH)
1631 | ((in->rtype & CRINFO_RTYPE) << CRINFO_RTYPE_SH)
1632 | ((in->dist2to & CRINFO_DIST2TO) << CRINFO_DIST2TO_SH)
1633 | ((in->relvaddr & CRINFO_RELVADDR) << CRINFO_RELVADDR_SH));
1634 H_PUT_32 (abfd, l, ex->info);
1635 H_PUT_32 (abfd, in->konst, ex->konst);
1636 H_PUT_32 (abfd, in->vaddr, ex->vaddr);
1639 /* A .reginfo section holds a single Elf32_RegInfo structure. These
1640 routines swap this structure in and out. They are used outside of
1641 BFD, so they are globally visible. */
1644 bfd_mips_elf32_swap_reginfo_in (bfd *abfd, const Elf32_External_RegInfo *ex,
1647 in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask);
1648 in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]);
1649 in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]);
1650 in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]);
1651 in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]);
1652 in->ri_gp_value = H_GET_32 (abfd, ex->ri_gp_value);
1656 bfd_mips_elf32_swap_reginfo_out (bfd *abfd, const Elf32_RegInfo *in,
1657 Elf32_External_RegInfo *ex)
1659 H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask);
1660 H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]);
1661 H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]);
1662 H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]);
1663 H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]);
1664 H_PUT_32 (abfd, in->ri_gp_value, ex->ri_gp_value);
1667 /* In the 64 bit ABI, the .MIPS.options section holds register
1668 information in an Elf64_Reginfo structure. These routines swap
1669 them in and out. They are globally visible because they are used
1670 outside of BFD. These routines are here so that gas can call them
1671 without worrying about whether the 64 bit ABI has been included. */
1674 bfd_mips_elf64_swap_reginfo_in (bfd *abfd, const Elf64_External_RegInfo *ex,
1675 Elf64_Internal_RegInfo *in)
1677 in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask);
1678 in->ri_pad = H_GET_32 (abfd, ex->ri_pad);
1679 in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]);
1680 in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]);
1681 in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]);
1682 in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]);
1683 in->ri_gp_value = H_GET_64 (abfd, ex->ri_gp_value);
1687 bfd_mips_elf64_swap_reginfo_out (bfd *abfd, const Elf64_Internal_RegInfo *in,
1688 Elf64_External_RegInfo *ex)
1690 H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask);
1691 H_PUT_32 (abfd, in->ri_pad, ex->ri_pad);
1692 H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]);
1693 H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]);
1694 H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]);
1695 H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]);
1696 H_PUT_64 (abfd, in->ri_gp_value, ex->ri_gp_value);
1699 /* Swap in an options header. */
1702 bfd_mips_elf_swap_options_in (bfd *abfd, const Elf_External_Options *ex,
1703 Elf_Internal_Options *in)
1705 in->kind = H_GET_8 (abfd, ex->kind);
1706 in->size = H_GET_8 (abfd, ex->size);
1707 in->section = H_GET_16 (abfd, ex->section);
1708 in->info = H_GET_32 (abfd, ex->info);
1711 /* Swap out an options header. */
1714 bfd_mips_elf_swap_options_out (bfd *abfd, const Elf_Internal_Options *in,
1715 Elf_External_Options *ex)
1717 H_PUT_8 (abfd, in->kind, ex->kind);
1718 H_PUT_8 (abfd, in->size, ex->size);
1719 H_PUT_16 (abfd, in->section, ex->section);
1720 H_PUT_32 (abfd, in->info, ex->info);
1723 /* This function is called via qsort() to sort the dynamic relocation
1724 entries by increasing r_symndx value. */
1727 sort_dynamic_relocs (const void *arg1, const void *arg2)
1729 Elf_Internal_Rela int_reloc1;
1730 Elf_Internal_Rela int_reloc2;
1733 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg1, &int_reloc1);
1734 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg2, &int_reloc2);
1736 diff = ELF32_R_SYM (int_reloc1.r_info) - ELF32_R_SYM (int_reloc2.r_info);
1740 if (int_reloc1.r_offset < int_reloc2.r_offset)
1742 if (int_reloc1.r_offset > int_reloc2.r_offset)
1747 /* Like sort_dynamic_relocs, but used for elf64 relocations. */
1750 sort_dynamic_relocs_64 (const void *arg1 ATTRIBUTE_UNUSED,
1751 const void *arg2 ATTRIBUTE_UNUSED)
1754 Elf_Internal_Rela int_reloc1[3];
1755 Elf_Internal_Rela int_reloc2[3];
1757 (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in)
1758 (reldyn_sorting_bfd, arg1, int_reloc1);
1759 (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in)
1760 (reldyn_sorting_bfd, arg2, int_reloc2);
1762 if (ELF64_R_SYM (int_reloc1[0].r_info) < ELF64_R_SYM (int_reloc2[0].r_info))
1764 if (ELF64_R_SYM (int_reloc1[0].r_info) > ELF64_R_SYM (int_reloc2[0].r_info))
1767 if (int_reloc1[0].r_offset < int_reloc2[0].r_offset)
1769 if (int_reloc1[0].r_offset > int_reloc2[0].r_offset)
1778 /* This routine is used to write out ECOFF debugging external symbol
1779 information. It is called via mips_elf_link_hash_traverse. The
1780 ECOFF external symbol information must match the ELF external
1781 symbol information. Unfortunately, at this point we don't know
1782 whether a symbol is required by reloc information, so the two
1783 tables may wind up being different. We must sort out the external
1784 symbol information before we can set the final size of the .mdebug
1785 section, and we must set the size of the .mdebug section before we
1786 can relocate any sections, and we can't know which symbols are
1787 required by relocation until we relocate the sections.
1788 Fortunately, it is relatively unlikely that any symbol will be
1789 stripped but required by a reloc. In particular, it can not happen
1790 when generating a final executable. */
1793 mips_elf_output_extsym (struct mips_elf_link_hash_entry *h, void *data)
1795 struct extsym_info *einfo = data;
1797 asection *sec, *output_section;
1799 if (h->root.root.type == bfd_link_hash_warning)
1800 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
1802 if (h->root.indx == -2)
1804 else if ((h->root.def_dynamic
1805 || h->root.ref_dynamic
1806 || h->root.type == bfd_link_hash_new)
1807 && !h->root.def_regular
1808 && !h->root.ref_regular)
1810 else if (einfo->info->strip == strip_all
1811 || (einfo->info->strip == strip_some
1812 && bfd_hash_lookup (einfo->info->keep_hash,
1813 h->root.root.root.string,
1814 FALSE, FALSE) == NULL))
1822 if (h->esym.ifd == -2)
1825 h->esym.cobol_main = 0;
1826 h->esym.weakext = 0;
1827 h->esym.reserved = 0;
1828 h->esym.ifd = ifdNil;
1829 h->esym.asym.value = 0;
1830 h->esym.asym.st = stGlobal;
1832 if (h->root.root.type == bfd_link_hash_undefined
1833 || h->root.root.type == bfd_link_hash_undefweak)
1837 /* Use undefined class. Also, set class and type for some
1839 name = h->root.root.root.string;
1840 if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
1841 || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
1843 h->esym.asym.sc = scData;
1844 h->esym.asym.st = stLabel;
1845 h->esym.asym.value = 0;
1847 else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
1849 h->esym.asym.sc = scAbs;
1850 h->esym.asym.st = stLabel;
1851 h->esym.asym.value =
1852 mips_elf_hash_table (einfo->info)->procedure_count;
1854 else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (einfo->abfd))
1856 h->esym.asym.sc = scAbs;
1857 h->esym.asym.st = stLabel;
1858 h->esym.asym.value = elf_gp (einfo->abfd);
1861 h->esym.asym.sc = scUndefined;
1863 else if (h->root.root.type != bfd_link_hash_defined
1864 && h->root.root.type != bfd_link_hash_defweak)
1865 h->esym.asym.sc = scAbs;
1870 sec = h->root.root.u.def.section;
1871 output_section = sec->output_section;
1873 /* When making a shared library and symbol h is the one from
1874 the another shared library, OUTPUT_SECTION may be null. */
1875 if (output_section == NULL)
1876 h->esym.asym.sc = scUndefined;
1879 name = bfd_section_name (output_section->owner, output_section);
1881 if (strcmp (name, ".text") == 0)
1882 h->esym.asym.sc = scText;
1883 else if (strcmp (name, ".data") == 0)
1884 h->esym.asym.sc = scData;
1885 else if (strcmp (name, ".sdata") == 0)
1886 h->esym.asym.sc = scSData;
1887 else if (strcmp (name, ".rodata") == 0
1888 || strcmp (name, ".rdata") == 0)
1889 h->esym.asym.sc = scRData;
1890 else if (strcmp (name, ".bss") == 0)
1891 h->esym.asym.sc = scBss;
1892 else if (strcmp (name, ".sbss") == 0)
1893 h->esym.asym.sc = scSBss;
1894 else if (strcmp (name, ".init") == 0)
1895 h->esym.asym.sc = scInit;
1896 else if (strcmp (name, ".fini") == 0)
1897 h->esym.asym.sc = scFini;
1899 h->esym.asym.sc = scAbs;
1903 h->esym.asym.reserved = 0;
1904 h->esym.asym.index = indexNil;
1907 if (h->root.root.type == bfd_link_hash_common)
1908 h->esym.asym.value = h->root.root.u.c.size;
1909 else if (h->root.root.type == bfd_link_hash_defined
1910 || h->root.root.type == bfd_link_hash_defweak)
1912 if (h->esym.asym.sc == scCommon)
1913 h->esym.asym.sc = scBss;
1914 else if (h->esym.asym.sc == scSCommon)
1915 h->esym.asym.sc = scSBss;
1917 sec = h->root.root.u.def.section;
1918 output_section = sec->output_section;
1919 if (output_section != NULL)
1920 h->esym.asym.value = (h->root.root.u.def.value
1921 + sec->output_offset
1922 + output_section->vma);
1924 h->esym.asym.value = 0;
1926 else if (h->root.needs_plt)
1928 struct mips_elf_link_hash_entry *hd = h;
1929 bfd_boolean no_fn_stub = h->no_fn_stub;
1931 while (hd->root.root.type == bfd_link_hash_indirect)
1933 hd = (struct mips_elf_link_hash_entry *)h->root.root.u.i.link;
1934 no_fn_stub = no_fn_stub || hd->no_fn_stub;
1939 /* Set type and value for a symbol with a function stub. */
1940 h->esym.asym.st = stProc;
1941 sec = hd->root.root.u.def.section;
1943 h->esym.asym.value = 0;
1946 output_section = sec->output_section;
1947 if (output_section != NULL)
1948 h->esym.asym.value = (hd->root.plt.offset
1949 + sec->output_offset
1950 + output_section->vma);
1952 h->esym.asym.value = 0;
1957 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
1958 h->root.root.root.string,
1961 einfo->failed = TRUE;
1968 /* A comparison routine used to sort .gptab entries. */
1971 gptab_compare (const void *p1, const void *p2)
1973 const Elf32_gptab *a1 = p1;
1974 const Elf32_gptab *a2 = p2;
1976 return a1->gt_entry.gt_g_value - a2->gt_entry.gt_g_value;
1979 /* Functions to manage the got entry hash table. */
1981 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
1984 static INLINE hashval_t
1985 mips_elf_hash_bfd_vma (bfd_vma addr)
1988 return addr + (addr >> 32);
1994 /* got_entries only match if they're identical, except for gotidx, so
1995 use all fields to compute the hash, and compare the appropriate
1999 mips_elf_got_entry_hash (const void *entry_)
2001 const struct mips_got_entry *entry = (struct mips_got_entry *)entry_;
2003 return entry->symndx
2004 + ((entry->tls_type & GOT_TLS_LDM) << 17)
2005 + (! entry->abfd ? mips_elf_hash_bfd_vma (entry->d.address)
2007 + (entry->symndx >= 0 ? mips_elf_hash_bfd_vma (entry->d.addend)
2008 : entry->d.h->root.root.root.hash));
2012 mips_elf_got_entry_eq (const void *entry1, const void *entry2)
2014 const struct mips_got_entry *e1 = (struct mips_got_entry *)entry1;
2015 const struct mips_got_entry *e2 = (struct mips_got_entry *)entry2;
2017 /* An LDM entry can only match another LDM entry. */
2018 if ((e1->tls_type ^ e2->tls_type) & GOT_TLS_LDM)
2021 return e1->abfd == e2->abfd && e1->symndx == e2->symndx
2022 && (! e1->abfd ? e1->d.address == e2->d.address
2023 : e1->symndx >= 0 ? e1->d.addend == e2->d.addend
2024 : e1->d.h == e2->d.h);
2027 /* multi_got_entries are still a match in the case of global objects,
2028 even if the input bfd in which they're referenced differs, so the
2029 hash computation and compare functions are adjusted
2033 mips_elf_multi_got_entry_hash (const void *entry_)
2035 const struct mips_got_entry *entry = (struct mips_got_entry *)entry_;
2037 return entry->symndx
2039 ? mips_elf_hash_bfd_vma (entry->d.address)
2040 : entry->symndx >= 0
2041 ? ((entry->tls_type & GOT_TLS_LDM)
2042 ? (GOT_TLS_LDM << 17)
2044 + mips_elf_hash_bfd_vma (entry->d.addend)))
2045 : entry->d.h->root.root.root.hash);
2049 mips_elf_multi_got_entry_eq (const void *entry1, const void *entry2)
2051 const struct mips_got_entry *e1 = (struct mips_got_entry *)entry1;
2052 const struct mips_got_entry *e2 = (struct mips_got_entry *)entry2;
2054 /* Any two LDM entries match. */
2055 if (e1->tls_type & e2->tls_type & GOT_TLS_LDM)
2058 /* Nothing else matches an LDM entry. */
2059 if ((e1->tls_type ^ e2->tls_type) & GOT_TLS_LDM)
2062 return e1->symndx == e2->symndx
2063 && (e1->symndx >= 0 ? e1->abfd == e2->abfd && e1->d.addend == e2->d.addend
2064 : e1->abfd == NULL || e2->abfd == NULL
2065 ? e1->abfd == e2->abfd && e1->d.address == e2->d.address
2066 : e1->d.h == e2->d.h);
2070 mips_got_page_entry_hash (const void *entry_)
2072 const struct mips_got_page_entry *entry;
2074 entry = (const struct mips_got_page_entry *) entry_;
2075 return entry->abfd->id + entry->symndx;
2079 mips_got_page_entry_eq (const void *entry1_, const void *entry2_)
2081 const struct mips_got_page_entry *entry1, *entry2;
2083 entry1 = (const struct mips_got_page_entry *) entry1_;
2084 entry2 = (const struct mips_got_page_entry *) entry2_;
2085 return entry1->abfd == entry2->abfd && entry1->symndx == entry2->symndx;
2088 /* Return the dynamic relocation section. If it doesn't exist, try to
2089 create a new it if CREATE_P, otherwise return NULL. Also return NULL
2090 if creation fails. */
2093 mips_elf_rel_dyn_section (struct bfd_link_info *info, bfd_boolean create_p)
2099 dname = MIPS_ELF_REL_DYN_NAME (info);
2100 dynobj = elf_hash_table (info)->dynobj;
2101 sreloc = bfd_get_section_by_name (dynobj, dname);
2102 if (sreloc == NULL && create_p)
2104 sreloc = bfd_make_section_with_flags (dynobj, dname,
2109 | SEC_LINKER_CREATED
2112 || ! bfd_set_section_alignment (dynobj, sreloc,
2113 MIPS_ELF_LOG_FILE_ALIGN (dynobj)))
2119 /* Returns the GOT section for ABFD. */
2122 mips_elf_got_section (bfd *abfd, bfd_boolean maybe_excluded)
2124 asection *sgot = bfd_get_section_by_name (abfd, ".got");
2126 || (! maybe_excluded && (sgot->flags & SEC_EXCLUDE) != 0))
2131 /* Returns the GOT information associated with the link indicated by
2132 INFO. If SGOTP is non-NULL, it is filled in with the GOT
2135 static struct mips_got_info *
2136 mips_elf_got_info (bfd *abfd, asection **sgotp)
2139 struct mips_got_info *g;
2141 sgot = mips_elf_got_section (abfd, TRUE);
2142 BFD_ASSERT (sgot != NULL);
2143 BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
2144 g = mips_elf_section_data (sgot)->u.got_info;
2145 BFD_ASSERT (g != NULL);
2148 *sgotp = (sgot->flags & SEC_EXCLUDE) == 0 ? sgot : NULL;
2153 /* Count the number of relocations needed for a TLS GOT entry, with
2154 access types from TLS_TYPE, and symbol H (or a local symbol if H
2158 mips_tls_got_relocs (struct bfd_link_info *info, unsigned char tls_type,
2159 struct elf_link_hash_entry *h)
2163 bfd_boolean need_relocs = FALSE;
2164 bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created;
2166 if (h && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2167 && (!info->shared || !SYMBOL_REFERENCES_LOCAL (info, h)))
2170 if ((info->shared || indx != 0)
2172 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2173 || h->root.type != bfd_link_hash_undefweak))
2179 if (tls_type & GOT_TLS_GD)
2186 if (tls_type & GOT_TLS_IE)
2189 if ((tls_type & GOT_TLS_LDM) && info->shared)
2195 /* Count the number of TLS relocations required for the GOT entry in
2196 ARG1, if it describes a local symbol. */
2199 mips_elf_count_local_tls_relocs (void **arg1, void *arg2)
2201 struct mips_got_entry *entry = * (struct mips_got_entry **) arg1;
2202 struct mips_elf_count_tls_arg *arg = arg2;
2204 if (entry->abfd != NULL && entry->symndx != -1)
2205 arg->needed += mips_tls_got_relocs (arg->info, entry->tls_type, NULL);
2210 /* Count the number of TLS GOT entries required for the global (or
2211 forced-local) symbol in ARG1. */
2214 mips_elf_count_global_tls_entries (void *arg1, void *arg2)
2216 struct mips_elf_link_hash_entry *hm
2217 = (struct mips_elf_link_hash_entry *) arg1;
2218 struct mips_elf_count_tls_arg *arg = arg2;
2220 if (hm->tls_type & GOT_TLS_GD)
2222 if (hm->tls_type & GOT_TLS_IE)
2228 /* Count the number of TLS relocations required for the global (or
2229 forced-local) symbol in ARG1. */
2232 mips_elf_count_global_tls_relocs (void *arg1, void *arg2)
2234 struct mips_elf_link_hash_entry *hm
2235 = (struct mips_elf_link_hash_entry *) arg1;
2236 struct mips_elf_count_tls_arg *arg = arg2;
2238 arg->needed += mips_tls_got_relocs (arg->info, hm->tls_type, &hm->root);
2243 /* Output a simple dynamic relocation into SRELOC. */
2246 mips_elf_output_dynamic_relocation (bfd *output_bfd,
2252 Elf_Internal_Rela rel[3];
2254 memset (rel, 0, sizeof (rel));
2256 rel[0].r_info = ELF_R_INFO (output_bfd, indx, r_type);
2257 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
2259 if (ABI_64_P (output_bfd))
2261 (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
2262 (output_bfd, &rel[0],
2264 + sreloc->reloc_count * sizeof (Elf64_Mips_External_Rel)));
2267 bfd_elf32_swap_reloc_out
2268 (output_bfd, &rel[0],
2270 + sreloc->reloc_count * sizeof (Elf32_External_Rel)));
2271 ++sreloc->reloc_count;
2274 /* Initialize a set of TLS GOT entries for one symbol. */
2277 mips_elf_initialize_tls_slots (bfd *abfd, bfd_vma got_offset,
2278 unsigned char *tls_type_p,
2279 struct bfd_link_info *info,
2280 struct mips_elf_link_hash_entry *h,
2284 asection *sreloc, *sgot;
2285 bfd_vma offset, offset2;
2287 bfd_boolean need_relocs = FALSE;
2289 dynobj = elf_hash_table (info)->dynobj;
2290 sgot = mips_elf_got_section (dynobj, FALSE);
2295 bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created;
2297 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, &h->root)
2298 && (!info->shared || !SYMBOL_REFERENCES_LOCAL (info, &h->root)))
2299 indx = h->root.dynindx;
2302 if (*tls_type_p & GOT_TLS_DONE)
2305 if ((info->shared || indx != 0)
2307 || ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT
2308 || h->root.type != bfd_link_hash_undefweak))
2311 /* MINUS_ONE means the symbol is not defined in this object. It may not
2312 be defined at all; assume that the value doesn't matter in that
2313 case. Otherwise complain if we would use the value. */
2314 BFD_ASSERT (value != MINUS_ONE || (indx != 0 && need_relocs)
2315 || h->root.root.type == bfd_link_hash_undefweak);
2317 /* Emit necessary relocations. */
2318 sreloc = mips_elf_rel_dyn_section (info, FALSE);
2320 /* General Dynamic. */
2321 if (*tls_type_p & GOT_TLS_GD)
2323 offset = got_offset;
2324 offset2 = offset + MIPS_ELF_GOT_SIZE (abfd);
2328 mips_elf_output_dynamic_relocation
2329 (abfd, sreloc, indx,
2330 ABI_64_P (abfd) ? R_MIPS_TLS_DTPMOD64 : R_MIPS_TLS_DTPMOD32,
2331 sgot->output_offset + sgot->output_section->vma + offset);
2334 mips_elf_output_dynamic_relocation
2335 (abfd, sreloc, indx,
2336 ABI_64_P (abfd) ? R_MIPS_TLS_DTPREL64 : R_MIPS_TLS_DTPREL32,
2337 sgot->output_offset + sgot->output_section->vma + offset2);
2339 MIPS_ELF_PUT_WORD (abfd, value - dtprel_base (info),
2340 sgot->contents + offset2);
2344 MIPS_ELF_PUT_WORD (abfd, 1,
2345 sgot->contents + offset);
2346 MIPS_ELF_PUT_WORD (abfd, value - dtprel_base (info),
2347 sgot->contents + offset2);
2350 got_offset += 2 * MIPS_ELF_GOT_SIZE (abfd);
2353 /* Initial Exec model. */
2354 if (*tls_type_p & GOT_TLS_IE)
2356 offset = got_offset;
2361 MIPS_ELF_PUT_WORD (abfd, value - elf_hash_table (info)->tls_sec->vma,
2362 sgot->contents + offset);
2364 MIPS_ELF_PUT_WORD (abfd, 0,
2365 sgot->contents + offset);
2367 mips_elf_output_dynamic_relocation
2368 (abfd, sreloc, indx,
2369 ABI_64_P (abfd) ? R_MIPS_TLS_TPREL64 : R_MIPS_TLS_TPREL32,
2370 sgot->output_offset + sgot->output_section->vma + offset);
2373 MIPS_ELF_PUT_WORD (abfd, value - tprel_base (info),
2374 sgot->contents + offset);
2377 if (*tls_type_p & GOT_TLS_LDM)
2379 /* The initial offset is zero, and the LD offsets will include the
2380 bias by DTP_OFFSET. */
2381 MIPS_ELF_PUT_WORD (abfd, 0,
2382 sgot->contents + got_offset
2383 + MIPS_ELF_GOT_SIZE (abfd));
2386 MIPS_ELF_PUT_WORD (abfd, 1,
2387 sgot->contents + got_offset);
2389 mips_elf_output_dynamic_relocation
2390 (abfd, sreloc, indx,
2391 ABI_64_P (abfd) ? R_MIPS_TLS_DTPMOD64 : R_MIPS_TLS_DTPMOD32,
2392 sgot->output_offset + sgot->output_section->vma + got_offset);
2395 *tls_type_p |= GOT_TLS_DONE;
2398 /* Return the GOT index to use for a relocation of type R_TYPE against
2399 a symbol accessed using TLS_TYPE models. The GOT entries for this
2400 symbol in this GOT start at GOT_INDEX. This function initializes the
2401 GOT entries and corresponding relocations. */
2404 mips_tls_got_index (bfd *abfd, bfd_vma got_index, unsigned char *tls_type,
2405 int r_type, struct bfd_link_info *info,
2406 struct mips_elf_link_hash_entry *h, bfd_vma symbol)
2408 BFD_ASSERT (r_type == R_MIPS_TLS_GOTTPREL || r_type == R_MIPS_TLS_GD
2409 || r_type == R_MIPS_TLS_LDM);
2411 mips_elf_initialize_tls_slots (abfd, got_index, tls_type, info, h, symbol);
2413 if (r_type == R_MIPS_TLS_GOTTPREL)
2415 BFD_ASSERT (*tls_type & GOT_TLS_IE);
2416 if (*tls_type & GOT_TLS_GD)
2417 return got_index + 2 * MIPS_ELF_GOT_SIZE (abfd);
2422 if (r_type == R_MIPS_TLS_GD)
2424 BFD_ASSERT (*tls_type & GOT_TLS_GD);
2428 if (r_type == R_MIPS_TLS_LDM)
2430 BFD_ASSERT (*tls_type & GOT_TLS_LDM);
2437 /* Return the offset from _GLOBAL_OFFSET_TABLE_ of the .got.plt entry
2438 for global symbol H. .got.plt comes before the GOT, so the offset
2439 will be negative. */
2442 mips_elf_gotplt_index (struct bfd_link_info *info,
2443 struct elf_link_hash_entry *h)
2445 bfd_vma plt_index, got_address, got_value;
2446 struct mips_elf_link_hash_table *htab;
2448 htab = mips_elf_hash_table (info);
2449 BFD_ASSERT (h->plt.offset != (bfd_vma) -1);
2451 /* Calculate the index of the symbol's PLT entry. */
2452 plt_index = (h->plt.offset - htab->plt_header_size) / htab->plt_entry_size;
2454 /* Calculate the address of the associated .got.plt entry. */
2455 got_address = (htab->sgotplt->output_section->vma
2456 + htab->sgotplt->output_offset
2459 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */
2460 got_value = (htab->root.hgot->root.u.def.section->output_section->vma
2461 + htab->root.hgot->root.u.def.section->output_offset
2462 + htab->root.hgot->root.u.def.value);
2464 return got_address - got_value;
2467 /* Return the GOT offset for address VALUE. If there is not yet a GOT
2468 entry for this value, create one. If R_SYMNDX refers to a TLS symbol,
2469 create a TLS GOT entry instead. Return -1 if no satisfactory GOT
2470 offset can be found. */
2473 mips_elf_local_got_index (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
2474 bfd_vma value, unsigned long r_symndx,
2475 struct mips_elf_link_hash_entry *h, int r_type)
2478 struct mips_got_info *g;
2479 struct mips_got_entry *entry;
2481 g = mips_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
2483 entry = mips_elf_create_local_got_entry (abfd, info, ibfd, g, sgot,
2484 value, r_symndx, h, r_type);
2488 if (TLS_RELOC_P (r_type))
2490 if (entry->symndx == -1 && g->next == NULL)
2491 /* A type (3) entry in the single-GOT case. We use the symbol's
2492 hash table entry to track the index. */
2493 return mips_tls_got_index (abfd, h->tls_got_offset, &h->tls_type,
2494 r_type, info, h, value);
2496 return mips_tls_got_index (abfd, entry->gotidx, &entry->tls_type,
2497 r_type, info, h, value);
2500 return entry->gotidx;
2503 /* Returns the GOT index for the global symbol indicated by H. */
2506 mips_elf_global_got_index (bfd *abfd, bfd *ibfd, struct elf_link_hash_entry *h,
2507 int r_type, struct bfd_link_info *info)
2511 struct mips_got_info *g, *gg;
2512 long global_got_dynindx = 0;
2514 gg = g = mips_elf_got_info (abfd, &sgot);
2515 if (g->bfd2got && ibfd)
2517 struct mips_got_entry e, *p;
2519 BFD_ASSERT (h->dynindx >= 0);
2521 g = mips_elf_got_for_ibfd (g, ibfd);
2522 if (g->next != gg || TLS_RELOC_P (r_type))
2526 e.d.h = (struct mips_elf_link_hash_entry *)h;
2529 p = htab_find (g->got_entries, &e);
2531 BFD_ASSERT (p->gotidx > 0);
2533 if (TLS_RELOC_P (r_type))
2535 bfd_vma value = MINUS_ONE;
2536 if ((h->root.type == bfd_link_hash_defined
2537 || h->root.type == bfd_link_hash_defweak)
2538 && h->root.u.def.section->output_section)
2539 value = (h->root.u.def.value
2540 + h->root.u.def.section->output_offset
2541 + h->root.u.def.section->output_section->vma);
2543 return mips_tls_got_index (abfd, p->gotidx, &p->tls_type, r_type,
2544 info, e.d.h, value);
2551 if (gg->global_gotsym != NULL)
2552 global_got_dynindx = gg->global_gotsym->dynindx;
2554 if (TLS_RELOC_P (r_type))
2556 struct mips_elf_link_hash_entry *hm
2557 = (struct mips_elf_link_hash_entry *) h;
2558 bfd_vma value = MINUS_ONE;
2560 if ((h->root.type == bfd_link_hash_defined
2561 || h->root.type == bfd_link_hash_defweak)
2562 && h->root.u.def.section->output_section)
2563 value = (h->root.u.def.value
2564 + h->root.u.def.section->output_offset
2565 + h->root.u.def.section->output_section->vma);
2567 index = mips_tls_got_index (abfd, hm->tls_got_offset, &hm->tls_type,
2568 r_type, info, hm, value);
2572 /* Once we determine the global GOT entry with the lowest dynamic
2573 symbol table index, we must put all dynamic symbols with greater
2574 indices into the GOT. That makes it easy to calculate the GOT
2576 BFD_ASSERT (h->dynindx >= global_got_dynindx);
2577 index = ((h->dynindx - global_got_dynindx + g->local_gotno)
2578 * MIPS_ELF_GOT_SIZE (abfd));
2580 BFD_ASSERT (index < sgot->size);
2585 /* Find a GOT page entry that points to within 32KB of VALUE. These
2586 entries are supposed to be placed at small offsets in the GOT, i.e.,
2587 within 32KB of GP. Return the index of the GOT entry, or -1 if no
2588 entry could be created. If OFFSETP is nonnull, use it to return the
2589 offset of the GOT entry from VALUE. */
2592 mips_elf_got_page (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
2593 bfd_vma value, bfd_vma *offsetp)
2596 struct mips_got_info *g;
2597 bfd_vma page, index;
2598 struct mips_got_entry *entry;
2600 g = mips_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
2602 page = (value + 0x8000) & ~(bfd_vma) 0xffff;
2603 entry = mips_elf_create_local_got_entry (abfd, info, ibfd, g, sgot,
2604 page, 0, NULL, R_MIPS_GOT_PAGE);
2609 index = entry->gotidx;
2612 *offsetp = value - entry->d.address;
2617 /* Find a local GOT entry for an R_MIPS_GOT16 relocation against VALUE.
2618 EXTERNAL is true if the relocation was against a global symbol
2619 that has been forced local. */
2622 mips_elf_got16_entry (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
2623 bfd_vma value, bfd_boolean external)
2626 struct mips_got_info *g;
2627 struct mips_got_entry *entry;
2629 /* GOT16 relocations against local symbols are followed by a LO16
2630 relocation; those against global symbols are not. Thus if the
2631 symbol was originally local, the GOT16 relocation should load the
2632 equivalent of %hi(VALUE), otherwise it should load VALUE itself. */
2634 value = mips_elf_high (value) << 16;
2636 g = mips_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
2638 entry = mips_elf_create_local_got_entry (abfd, info, ibfd, g, sgot,
2639 value, 0, NULL, R_MIPS_GOT16);
2641 return entry->gotidx;
2646 /* Returns the offset for the entry at the INDEXth position
2650 mips_elf_got_offset_from_index (bfd *dynobj, bfd *output_bfd,
2651 bfd *input_bfd, bfd_vma index)
2655 struct mips_got_info *g;
2657 g = mips_elf_got_info (dynobj, &sgot);
2658 gp = _bfd_get_gp_value (output_bfd)
2659 + mips_elf_adjust_gp (output_bfd, g, input_bfd);
2661 return sgot->output_section->vma + sgot->output_offset + index - gp;
2664 /* Create and return a local GOT entry for VALUE, which was calculated
2665 from a symbol belonging to INPUT_SECTON. Return NULL if it could not
2666 be created. If R_SYMNDX refers to a TLS symbol, create a TLS entry
2669 static struct mips_got_entry *
2670 mips_elf_create_local_got_entry (bfd *abfd, struct bfd_link_info *info,
2671 bfd *ibfd, struct mips_got_info *gg,
2672 asection *sgot, bfd_vma value,
2673 unsigned long r_symndx,
2674 struct mips_elf_link_hash_entry *h,
2677 struct mips_got_entry entry, **loc;
2678 struct mips_got_info *g;
2679 struct mips_elf_link_hash_table *htab;
2681 htab = mips_elf_hash_table (info);
2685 entry.d.address = value;
2688 g = mips_elf_got_for_ibfd (gg, ibfd);
2691 g = mips_elf_got_for_ibfd (gg, abfd);
2692 BFD_ASSERT (g != NULL);
2695 /* We might have a symbol, H, if it has been forced local. Use the
2696 global entry then. It doesn't matter whether an entry is local
2697 or global for TLS, since the dynamic linker does not
2698 automatically relocate TLS GOT entries. */
2699 BFD_ASSERT (h == NULL || h->root.forced_local);
2700 if (TLS_RELOC_P (r_type))
2702 struct mips_got_entry *p;
2705 if (r_type == R_MIPS_TLS_LDM)
2707 entry.tls_type = GOT_TLS_LDM;
2713 entry.symndx = r_symndx;
2719 p = (struct mips_got_entry *)
2720 htab_find (g->got_entries, &entry);
2726 loc = (struct mips_got_entry **) htab_find_slot (g->got_entries, &entry,
2731 entry.gotidx = MIPS_ELF_GOT_SIZE (abfd) * g->assigned_gotno++;
2734 *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry);
2739 memcpy (*loc, &entry, sizeof entry);
2741 if (g->assigned_gotno > g->local_gotno)
2743 (*loc)->gotidx = -1;
2744 /* We didn't allocate enough space in the GOT. */
2745 (*_bfd_error_handler)
2746 (_("not enough GOT space for local GOT entries"));
2747 bfd_set_error (bfd_error_bad_value);
2751 MIPS_ELF_PUT_WORD (abfd, value,
2752 (sgot->contents + entry.gotidx));
2754 /* These GOT entries need a dynamic relocation on VxWorks. */
2755 if (htab->is_vxworks)
2757 Elf_Internal_Rela outrel;
2760 bfd_vma got_address;
2762 s = mips_elf_rel_dyn_section (info, FALSE);
2763 got_address = (sgot->output_section->vma
2764 + sgot->output_offset
2767 loc = s->contents + (s->reloc_count++ * sizeof (Elf32_External_Rela));
2768 outrel.r_offset = got_address;
2769 outrel.r_info = ELF32_R_INFO (STN_UNDEF, R_MIPS_32);
2770 outrel.r_addend = value;
2771 bfd_elf32_swap_reloca_out (abfd, &outrel, loc);
2777 /* Sort the dynamic symbol table so that symbols that need GOT entries
2778 appear towards the end. This reduces the amount of GOT space
2779 required. MAX_LOCAL is used to set the number of local symbols
2780 known to be in the dynamic symbol table. During
2781 _bfd_mips_elf_size_dynamic_sections, this value is 1. Afterward, the
2782 section symbols are added and the count is higher. */
2785 mips_elf_sort_hash_table (struct bfd_link_info *info, unsigned long max_local)
2787 struct mips_elf_hash_sort_data hsd;
2788 struct mips_got_info *g;
2791 dynobj = elf_hash_table (info)->dynobj;
2793 g = mips_elf_got_info (dynobj, NULL);
2796 hsd.max_unref_got_dynindx =
2797 hsd.min_got_dynindx = elf_hash_table (info)->dynsymcount
2798 /* In the multi-got case, assigned_gotno of the master got_info
2799 indicate the number of entries that aren't referenced in the
2800 primary GOT, but that must have entries because there are
2801 dynamic relocations that reference it. Since they aren't
2802 referenced, we move them to the end of the GOT, so that they
2803 don't prevent other entries that are referenced from getting
2804 too large offsets. */
2805 - (g->next ? g->assigned_gotno : 0);
2806 hsd.max_non_got_dynindx = max_local;
2807 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table *)
2808 elf_hash_table (info)),
2809 mips_elf_sort_hash_table_f,
2812 /* There should have been enough room in the symbol table to
2813 accommodate both the GOT and non-GOT symbols. */
2814 BFD_ASSERT (hsd.max_non_got_dynindx <= hsd.min_got_dynindx);
2815 BFD_ASSERT ((unsigned long)hsd.max_unref_got_dynindx
2816 <= elf_hash_table (info)->dynsymcount);
2818 /* Now we know which dynamic symbol has the lowest dynamic symbol
2819 table index in the GOT. */
2820 g->global_gotsym = hsd.low;
2825 /* If H needs a GOT entry, assign it the highest available dynamic
2826 index. Otherwise, assign it the lowest available dynamic
2830 mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry *h, void *data)
2832 struct mips_elf_hash_sort_data *hsd = data;
2834 if (h->root.root.type == bfd_link_hash_warning)
2835 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
2837 /* Symbols without dynamic symbol table entries aren't interesting
2839 if (h->root.dynindx == -1)
2842 /* Global symbols that need GOT entries that are not explicitly
2843 referenced are marked with got offset 2. Those that are
2844 referenced get a 1, and those that don't need GOT entries get
2845 -1. Forced local symbols may also be marked with got offset 1,
2846 but are never given global GOT entries. */
2847 if (h->root.got.offset == 2)
2849 BFD_ASSERT (h->tls_type == GOT_NORMAL);
2851 if (hsd->max_unref_got_dynindx == hsd->min_got_dynindx)
2852 hsd->low = (struct elf_link_hash_entry *) h;
2853 h->root.dynindx = hsd->max_unref_got_dynindx++;
2855 else if (h->root.got.offset != 1 || h->forced_local)
2856 h->root.dynindx = hsd->max_non_got_dynindx++;
2859 BFD_ASSERT (h->tls_type == GOT_NORMAL);
2861 h->root.dynindx = --hsd->min_got_dynindx;
2862 hsd->low = (struct elf_link_hash_entry *) h;
2868 /* If H is a symbol that needs a global GOT entry, but has a dynamic
2869 symbol table index lower than any we've seen to date, record it for
2873 mips_elf_record_global_got_symbol (struct elf_link_hash_entry *h,
2874 bfd *abfd, struct bfd_link_info *info,
2875 struct mips_got_info *g,
2876 unsigned char tls_flag)
2878 struct mips_got_entry entry, **loc;
2880 /* A global symbol in the GOT must also be in the dynamic symbol
2882 if (h->dynindx == -1)
2884 switch (ELF_ST_VISIBILITY (h->other))
2888 _bfd_mips_elf_hide_symbol (info, h, TRUE);
2891 if (!bfd_elf_link_record_dynamic_symbol (info, h))
2895 /* Make sure we have a GOT to put this entry into. */
2896 BFD_ASSERT (g != NULL);
2900 entry.d.h = (struct mips_elf_link_hash_entry *) h;
2903 loc = (struct mips_got_entry **) htab_find_slot (g->got_entries, &entry,
2906 /* If we've already marked this entry as needing GOT space, we don't
2907 need to do it again. */
2910 (*loc)->tls_type |= tls_flag;
2914 *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry);
2920 entry.tls_type = tls_flag;
2922 memcpy (*loc, &entry, sizeof entry);
2924 if (h->got.offset != MINUS_ONE)
2929 /* By setting this to a value other than -1, we are indicating that
2930 there needs to be a GOT entry for H. Avoid using zero, as the
2931 generic ELF copy_indirect_symbol tests for <= 0. */
2933 if (h->forced_local)
2940 /* Reserve space in G for a GOT entry containing the value of symbol
2941 SYMNDX in input bfd ABDF, plus ADDEND. */
2944 mips_elf_record_local_got_symbol (bfd *abfd, long symndx, bfd_vma addend,
2945 struct mips_got_info *g,
2946 unsigned char tls_flag)
2948 struct mips_got_entry entry, **loc;
2951 entry.symndx = symndx;
2952 entry.d.addend = addend;
2953 entry.tls_type = tls_flag;
2954 loc = (struct mips_got_entry **)
2955 htab_find_slot (g->got_entries, &entry, INSERT);
2959 if (tls_flag == GOT_TLS_GD && !((*loc)->tls_type & GOT_TLS_GD))
2962 (*loc)->tls_type |= tls_flag;
2964 else if (tls_flag == GOT_TLS_IE && !((*loc)->tls_type & GOT_TLS_IE))
2967 (*loc)->tls_type |= tls_flag;
2975 entry.tls_type = tls_flag;
2976 if (tls_flag == GOT_TLS_IE)
2978 else if (tls_flag == GOT_TLS_GD)
2980 else if (g->tls_ldm_offset == MINUS_ONE)
2982 g->tls_ldm_offset = MINUS_TWO;
2988 entry.gotidx = g->local_gotno++;
2992 *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry);
2997 memcpy (*loc, &entry, sizeof entry);
3002 /* Return the maximum number of GOT page entries required for RANGE. */
3005 mips_elf_pages_for_range (const struct mips_got_page_range *range)
3007 return (range->max_addend - range->min_addend + 0x1ffff) >> 16;
3010 /* Record that ABFD has a page relocation against symbol SYMNDX and that
3011 ADDEND is the addend for that relocation. G is the GOT information. */
3014 mips_elf_record_got_page_entry (bfd *abfd, long symndx, bfd_signed_vma addend,
3015 struct mips_got_info *g)
3017 struct mips_got_page_entry lookup, *entry;
3018 struct mips_got_page_range **range_ptr, *range;
3019 bfd_vma old_pages, new_pages;
3022 /* Find the mips_got_page_entry hash table entry for this symbol. */
3024 lookup.symndx = symndx;
3025 loc = htab_find_slot (g->got_page_entries, &lookup, INSERT);
3029 /* Create a mips_got_page_entry if this is the first time we've
3031 entry = (struct mips_got_page_entry *) *loc;
3034 entry = bfd_alloc (abfd, sizeof (*entry));
3039 entry->symndx = symndx;
3040 entry->ranges = NULL;
3041 entry->num_pages = 0;
3045 /* Skip over ranges whose maximum extent cannot share a page entry
3047 range_ptr = &entry->ranges;
3048 while (*range_ptr && addend > (*range_ptr)->max_addend + 0xffff)
3049 range_ptr = &(*range_ptr)->next;
3051 /* If we scanned to the end of the list, or found a range whose
3052 minimum extent cannot share a page entry with ADDEND, create
3053 a new singleton range. */
3055 if (!range || addend < range->min_addend - 0xffff)
3057 range = bfd_alloc (abfd, sizeof (*range));
3061 range->next = *range_ptr;
3062 range->min_addend = addend;
3063 range->max_addend = addend;
3071 /* Remember how many pages the old range contributed. */
3072 old_pages = mips_elf_pages_for_range (range);
3074 /* Update the ranges. */
3075 if (addend < range->min_addend)
3076 range->min_addend = addend;
3077 else if (addend > range->max_addend)
3079 if (range->next && addend >= range->next->min_addend - 0xffff)
3081 old_pages += mips_elf_pages_for_range (range->next);
3082 range->max_addend = range->next->max_addend;
3083 range->next = range->next->next;
3086 range->max_addend = addend;
3089 /* Record any change in the total estimate. */
3090 new_pages = mips_elf_pages_for_range (range);
3091 if (old_pages != new_pages)
3093 entry->num_pages += new_pages - old_pages;
3094 g->page_gotno += new_pages - old_pages;
3100 /* Compute the hash value of the bfd in a bfd2got hash entry. */
3103 mips_elf_bfd2got_entry_hash (const void *entry_)
3105 const struct mips_elf_bfd2got_hash *entry
3106 = (struct mips_elf_bfd2got_hash *)entry_;
3108 return entry->bfd->id;
3111 /* Check whether two hash entries have the same bfd. */
3114 mips_elf_bfd2got_entry_eq (const void *entry1, const void *entry2)
3116 const struct mips_elf_bfd2got_hash *e1
3117 = (const struct mips_elf_bfd2got_hash *)entry1;
3118 const struct mips_elf_bfd2got_hash *e2
3119 = (const struct mips_elf_bfd2got_hash *)entry2;
3121 return e1->bfd == e2->bfd;
3124 /* In a multi-got link, determine the GOT to be used for IBFD. G must
3125 be the master GOT data. */
3127 static struct mips_got_info *
3128 mips_elf_got_for_ibfd (struct mips_got_info *g, bfd *ibfd)
3130 struct mips_elf_bfd2got_hash e, *p;
3136 p = htab_find (g->bfd2got, &e);
3137 return p ? p->g : NULL;
3140 /* Use BFD2GOT to find ABFD's got entry, creating one if none exists.
3141 Return NULL if an error occured. */
3143 static struct mips_got_info *
3144 mips_elf_get_got_for_bfd (struct htab *bfd2got, bfd *output_bfd,
3147 struct mips_elf_bfd2got_hash bfdgot_entry, *bfdgot;
3148 struct mips_got_info *g;
3151 bfdgot_entry.bfd = input_bfd;
3152 bfdgotp = htab_find_slot (bfd2got, &bfdgot_entry, INSERT);
3153 bfdgot = (struct mips_elf_bfd2got_hash *) *bfdgotp;
3157 bfdgot = ((struct mips_elf_bfd2got_hash *)
3158 bfd_alloc (output_bfd, sizeof (struct mips_elf_bfd2got_hash)));
3164 g = ((struct mips_got_info *)
3165 bfd_alloc (output_bfd, sizeof (struct mips_got_info)));
3169 bfdgot->bfd = input_bfd;
3172 g->global_gotsym = NULL;
3173 g->global_gotno = 0;
3176 g->assigned_gotno = -1;
3178 g->tls_assigned_gotno = 0;
3179 g->tls_ldm_offset = MINUS_ONE;
3180 g->got_entries = htab_try_create (1, mips_elf_multi_got_entry_hash,
3181 mips_elf_multi_got_entry_eq, NULL);
3182 if (g->got_entries == NULL)
3185 g->got_page_entries = htab_try_create (1, mips_got_page_entry_hash,
3186 mips_got_page_entry_eq, NULL);
3187 if (g->got_page_entries == NULL)
3197 /* A htab_traverse callback for the entries in the master got.
3198 Create one separate got for each bfd that has entries in the global
3199 got, such that we can tell how many local and global entries each
3203 mips_elf_make_got_per_bfd (void **entryp, void *p)
3205 struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
3206 struct mips_elf_got_per_bfd_arg *arg = (struct mips_elf_got_per_bfd_arg *)p;
3207 struct mips_got_info *g;
3209 g = mips_elf_get_got_for_bfd (arg->bfd2got, arg->obfd, entry->abfd);
3216 /* Insert the GOT entry in the bfd's got entry hash table. */
3217 entryp = htab_find_slot (g->got_entries, entry, INSERT);
3218 if (*entryp != NULL)
3223 if (entry->tls_type)
3225 if (entry->tls_type & (GOT_TLS_GD | GOT_TLS_LDM))
3227 if (entry->tls_type & GOT_TLS_IE)
3230 else if (entry->symndx >= 0 || entry->d.h->forced_local)
3238 /* A htab_traverse callback for the page entries in the master got.
3239 Associate each page entry with the bfd's got. */
3242 mips_elf_make_got_pages_per_bfd (void **entryp, void *p)
3244 struct mips_got_page_entry *entry = (struct mips_got_page_entry *) *entryp;
3245 struct mips_elf_got_per_bfd_arg *arg = (struct mips_elf_got_per_bfd_arg *) p;
3246 struct mips_got_info *g;
3248 g = mips_elf_get_got_for_bfd (arg->bfd2got, arg->obfd, entry->abfd);
3255 /* Insert the GOT entry in the bfd's got entry hash table. */
3256 entryp = htab_find_slot (g->got_page_entries, entry, INSERT);
3257 if (*entryp != NULL)
3261 g->page_gotno += entry->num_pages;
3265 /* Consider merging the got described by BFD2GOT with TO, using the
3266 information given by ARG. Return -1 if this would lead to overflow,
3267 1 if they were merged successfully, and 0 if a merge failed due to
3268 lack of memory. (These values are chosen so that nonnegative return
3269 values can be returned by a htab_traverse callback.) */
3272 mips_elf_merge_got_with (struct mips_elf_bfd2got_hash *bfd2got,
3273 struct mips_got_info *to,
3274 struct mips_elf_got_per_bfd_arg *arg)
3276 struct mips_got_info *from = bfd2got->g;
3277 unsigned int estimate;
3279 /* Work out how many page entries we would need for the combined GOT. */
3280 estimate = arg->max_pages;
3281 if (estimate >= from->page_gotno + to->page_gotno)
3282 estimate = from->page_gotno + to->page_gotno;
3284 /* And conservatively estimate how many local, global and TLS entries
3286 estimate += (from->local_gotno
3287 + from->global_gotno
3293 /* Bail out if the combined GOT might be too big. */
3294 if (estimate > arg->max_count)
3297 /* Commit to the merge. Record that TO is now the bfd for this got. */
3300 /* Transfer the bfd's got information from FROM to TO. */
3301 htab_traverse (from->got_entries, mips_elf_make_got_per_bfd, arg);
3302 if (arg->obfd == NULL)
3305 htab_traverse (from->got_page_entries, mips_elf_make_got_pages_per_bfd, arg);
3306 if (arg->obfd == NULL)
3309 /* We don't have to worry about releasing memory of the actual
3310 got entries, since they're all in the master got_entries hash
3312 htab_delete (from->got_entries);
3313 htab_delete (from->got_page_entries);
3317 /* Attempt to merge gots of different input bfds. Try to use as much
3318 as possible of the primary got, since it doesn't require explicit
3319 dynamic relocations, but don't use bfds that would reference global
3320 symbols out of the addressable range. Failing the primary got,
3321 attempt to merge with the current got, or finish the current got
3322 and then make make the new got current. */
3325 mips_elf_merge_gots (void **bfd2got_, void *p)
3327 struct mips_elf_bfd2got_hash *bfd2got
3328 = (struct mips_elf_bfd2got_hash *)*bfd2got_;
3329 struct mips_elf_got_per_bfd_arg *arg = (struct mips_elf_got_per_bfd_arg *)p;
3330 struct mips_got_info *g;
3331 unsigned int estimate;
3336 /* Work out the number of page, local and TLS entries. */
3337 estimate = arg->max_pages;
3338 if (estimate > g->page_gotno)
3339 estimate = g->page_gotno;
3340 estimate += g->local_gotno + g->tls_gotno;
3342 /* We place TLS GOT entries after both locals and globals. The globals
3343 for the primary GOT may overflow the normal GOT size limit, so be
3344 sure not to merge a GOT which requires TLS with the primary GOT in that
3345 case. This doesn't affect non-primary GOTs. */
3346 estimate += (g->tls_gotno > 0 ? arg->global_count : g->global_gotno);
3348 if (estimate <= arg->max_count)
3350 /* If we don't have a primary GOT, use it as
3351 a starting point for the primary GOT. */
3354 arg->primary = bfd2got->g;
3358 /* Try merging with the primary GOT. */
3359 result = mips_elf_merge_got_with (bfd2got, arg->primary, arg);
3364 /* If we can merge with the last-created got, do it. */
3367 result = mips_elf_merge_got_with (bfd2got, arg->current, arg);
3372 /* Well, we couldn't merge, so create a new GOT. Don't check if it
3373 fits; if it turns out that it doesn't, we'll get relocation
3374 overflows anyway. */
3375 g->next = arg->current;
3381 /* Set the TLS GOT index for the GOT entry in ENTRYP. ENTRYP's NEXT field
3382 is null iff there is just a single GOT. */
3385 mips_elf_initialize_tls_index (void **entryp, void *p)
3387 struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
3388 struct mips_got_info *g = p;
3390 unsigned char tls_type;
3392 /* We're only interested in TLS symbols. */
3393 if (entry->tls_type == 0)
3396 next_index = MIPS_ELF_GOT_SIZE (entry->abfd) * (long) g->tls_assigned_gotno;
3398 if (entry->symndx == -1 && g->next == NULL)
3400 /* A type (3) got entry in the single-GOT case. We use the symbol's
3401 hash table entry to track its index. */
3402 if (entry->d.h->tls_type & GOT_TLS_OFFSET_DONE)
3404 entry->d.h->tls_type |= GOT_TLS_OFFSET_DONE;
3405 entry->d.h->tls_got_offset = next_index;
3406 tls_type = entry->d.h->tls_type;
3410 if (entry->tls_type & GOT_TLS_LDM)
3412 /* There are separate mips_got_entry objects for each input bfd
3413 that requires an LDM entry. Make sure that all LDM entries in
3414 a GOT resolve to the same index. */
3415 if (g->tls_ldm_offset != MINUS_TWO && g->tls_ldm_offset != MINUS_ONE)
3417 entry->gotidx = g->tls_ldm_offset;
3420 g->tls_ldm_offset = next_index;
3422 entry->gotidx = next_index;
3423 tls_type = entry->tls_type;
3426 /* Account for the entries we've just allocated. */
3427 if (tls_type & (GOT_TLS_GD | GOT_TLS_LDM))
3428 g->tls_assigned_gotno += 2;
3429 if (tls_type & GOT_TLS_IE)
3430 g->tls_assigned_gotno += 1;
3435 /* If passed a NULL mips_got_info in the argument, set the marker used
3436 to tell whether a global symbol needs a got entry (in the primary
3437 got) to the given VALUE.
3439 If passed a pointer G to a mips_got_info in the argument (it must
3440 not be the primary GOT), compute the offset from the beginning of
3441 the (primary) GOT section to the entry in G corresponding to the
3442 global symbol. G's assigned_gotno must contain the index of the
3443 first available global GOT entry in G. VALUE must contain the size
3444 of a GOT entry in bytes. For each global GOT entry that requires a
3445 dynamic relocation, NEEDED_RELOCS is incremented, and the symbol is
3446 marked as not eligible for lazy resolution through a function
3449 mips_elf_set_global_got_offset (void **entryp, void *p)
3451 struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
3452 struct mips_elf_set_global_got_offset_arg *arg
3453 = (struct mips_elf_set_global_got_offset_arg *)p;
3454 struct mips_got_info *g = arg->g;
3456 if (g && entry->tls_type != GOT_NORMAL)
3457 arg->needed_relocs +=
3458 mips_tls_got_relocs (arg->info, entry->tls_type,
3459 entry->symndx == -1 ? &entry->d.h->root : NULL);
3461 if (entry->abfd != NULL && entry->symndx == -1
3462 && entry->d.h->root.dynindx != -1
3463 && !entry->d.h->forced_local
3464 && entry->d.h->tls_type == GOT_NORMAL)
3468 BFD_ASSERT (g->global_gotsym == NULL);
3470 entry->gotidx = arg->value * (long) g->assigned_gotno++;
3471 if (arg->info->shared
3472 || (elf_hash_table (arg->info)->dynamic_sections_created
3473 && entry->d.h->root.def_dynamic
3474 && !entry->d.h->root.def_regular))
3475 ++arg->needed_relocs;
3478 entry->d.h->root.got.offset = arg->value;
3484 /* Mark any global symbols referenced in the GOT we are iterating over
3485 as inelligible for lazy resolution stubs. */
3487 mips_elf_set_no_stub (void **entryp, void *p ATTRIBUTE_UNUSED)
3489 struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
3491 if (entry->abfd != NULL
3492 && entry->symndx == -1
3493 && entry->d.h->root.dynindx != -1)
3494 entry->d.h->no_fn_stub = TRUE;
3499 /* Follow indirect and warning hash entries so that each got entry
3500 points to the final symbol definition. P must point to a pointer
3501 to the hash table we're traversing. Since this traversal may
3502 modify the hash table, we set this pointer to NULL to indicate
3503 we've made a potentially-destructive change to the hash table, so
3504 the traversal must be restarted. */
3506 mips_elf_resolve_final_got_entry (void **entryp, void *p)
3508 struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
3509 htab_t got_entries = *(htab_t *)p;
3511 if (entry->abfd != NULL && entry->symndx == -1)
3513 struct mips_elf_link_hash_entry *h = entry->d.h;
3515 while (h->root.root.type == bfd_link_hash_indirect
3516 || h->root.root.type == bfd_link_hash_warning)
3517 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
3519 if (entry->d.h == h)
3524 /* If we can't find this entry with the new bfd hash, re-insert
3525 it, and get the traversal restarted. */
3526 if (! htab_find (got_entries, entry))
3528 htab_clear_slot (got_entries, entryp);
3529 entryp = htab_find_slot (got_entries, entry, INSERT);
3532 /* Abort the traversal, since the whole table may have
3533 moved, and leave it up to the parent to restart the
3535 *(htab_t *)p = NULL;
3538 /* We might want to decrement the global_gotno count, but it's
3539 either too early or too late for that at this point. */
3545 /* Turn indirect got entries in a got_entries table into their final
3548 mips_elf_resolve_final_got_entries (struct mips_got_info *g)
3554 got_entries = g->got_entries;
3556 htab_traverse (got_entries,
3557 mips_elf_resolve_final_got_entry,
3560 while (got_entries == NULL);
3563 /* Return the offset of an input bfd IBFD's GOT from the beginning of
3566 mips_elf_adjust_gp (bfd *abfd, struct mips_got_info *g, bfd *ibfd)
3568 if (g->bfd2got == NULL)
3571 g = mips_elf_got_for_ibfd (g, ibfd);
3575 BFD_ASSERT (g->next);
3579 return (g->local_gotno + g->global_gotno + g->tls_gotno)
3580 * MIPS_ELF_GOT_SIZE (abfd);
3583 /* Turn a single GOT that is too big for 16-bit addressing into
3584 a sequence of GOTs, each one 16-bit addressable. */
3587 mips_elf_multi_got (bfd *abfd, struct bfd_link_info *info,
3588 struct mips_got_info *g, asection *got,
3589 bfd_size_type pages)
3591 struct mips_elf_got_per_bfd_arg got_per_bfd_arg;
3592 struct mips_elf_set_global_got_offset_arg set_got_offset_arg;
3593 struct mips_got_info *gg;
3594 unsigned int assign;
3596 g->bfd2got = htab_try_create (1, mips_elf_bfd2got_entry_hash,
3597 mips_elf_bfd2got_entry_eq, NULL);
3598 if (g->bfd2got == NULL)
3601 got_per_bfd_arg.bfd2got = g->bfd2got;
3602 got_per_bfd_arg.obfd = abfd;
3603 got_per_bfd_arg.info = info;
3605 /* Count how many GOT entries each input bfd requires, creating a
3606 map from bfd to got info while at that. */
3607 htab_traverse (g->got_entries, mips_elf_make_got_per_bfd, &got_per_bfd_arg);
3608 if (got_per_bfd_arg.obfd == NULL)
3611 /* Also count how many page entries each input bfd requires. */
3612 htab_traverse (g->got_page_entries, mips_elf_make_got_pages_per_bfd,
3614 if (got_per_bfd_arg.obfd == NULL)
3617 got_per_bfd_arg.current = NULL;
3618 got_per_bfd_arg.primary = NULL;
3619 got_per_bfd_arg.max_count = ((MIPS_ELF_GOT_MAX_SIZE (info)
3620 / MIPS_ELF_GOT_SIZE (abfd))
3621 - MIPS_RESERVED_GOTNO (info));
3622 got_per_bfd_arg.max_pages = pages;
3623 /* The number of globals that will be included in the primary GOT.
3624 See the calls to mips_elf_set_global_got_offset below for more
3626 got_per_bfd_arg.global_count = g->global_gotno;
3628 /* Try to merge the GOTs of input bfds together, as long as they
3629 don't seem to exceed the maximum GOT size, choosing one of them
3630 to be the primary GOT. */
3631 htab_traverse (g->bfd2got, mips_elf_merge_gots, &got_per_bfd_arg);
3632 if (got_per_bfd_arg.obfd == NULL)
3635 /* If we do not find any suitable primary GOT, create an empty one. */
3636 if (got_per_bfd_arg.primary == NULL)
3638 g->next = (struct mips_got_info *)
3639 bfd_alloc (abfd, sizeof (struct mips_got_info));
3640 if (g->next == NULL)
3643 g->next->global_gotsym = NULL;
3644 g->next->global_gotno = 0;
3645 g->next->local_gotno = 0;
3646 g->next->page_gotno = 0;
3647 g->next->tls_gotno = 0;
3648 g->next->assigned_gotno = 0;
3649 g->next->tls_assigned_gotno = 0;
3650 g->next->tls_ldm_offset = MINUS_ONE;
3651 g->next->got_entries = htab_try_create (1, mips_elf_multi_got_entry_hash,
3652 mips_elf_multi_got_entry_eq,
3654 if (g->next->got_entries == NULL)
3656 g->next->got_page_entries = htab_try_create (1, mips_got_page_entry_hash,
3657 mips_got_page_entry_eq,
3659 if (g->next->got_page_entries == NULL)
3661 g->next->bfd2got = NULL;
3664 g->next = got_per_bfd_arg.primary;
3665 g->next->next = got_per_bfd_arg.current;
3667 /* GG is now the master GOT, and G is the primary GOT. */
3671 /* Map the output bfd to the primary got. That's what we're going
3672 to use for bfds that use GOT16 or GOT_PAGE relocations that we
3673 didn't mark in check_relocs, and we want a quick way to find it.
3674 We can't just use gg->next because we're going to reverse the
3677 struct mips_elf_bfd2got_hash *bfdgot;
3680 bfdgot = (struct mips_elf_bfd2got_hash *)bfd_alloc
3681 (abfd, sizeof (struct mips_elf_bfd2got_hash));
3688 bfdgotp = htab_find_slot (gg->bfd2got, bfdgot, INSERT);
3690 BFD_ASSERT (*bfdgotp == NULL);
3694 /* The IRIX dynamic linker requires every symbol that is referenced
3695 in a dynamic relocation to be present in the primary GOT, so
3696 arrange for them to appear after those that are actually
3699 GNU/Linux could very well do without it, but it would slow down
3700 the dynamic linker, since it would have to resolve every dynamic
3701 symbol referenced in other GOTs more than once, without help from
3702 the cache. Also, knowing that every external symbol has a GOT
3703 helps speed up the resolution of local symbols too, so GNU/Linux
3704 follows IRIX's practice.
3706 The number 2 is used by mips_elf_sort_hash_table_f to count
3707 global GOT symbols that are unreferenced in the primary GOT, with
3708 an initial dynamic index computed from gg->assigned_gotno, where
3709 the number of unreferenced global entries in the primary GOT is
3713 gg->assigned_gotno = gg->global_gotno - g->global_gotno;
3714 g->global_gotno = gg->global_gotno;
3715 set_got_offset_arg.value = 2;
3719 /* This could be used for dynamic linkers that don't optimize
3720 symbol resolution while applying relocations so as to use
3721 primary GOT entries or assuming the symbol is locally-defined.
3722 With this code, we assign lower dynamic indices to global
3723 symbols that are not referenced in the primary GOT, so that
3724 their entries can be omitted. */
3725 gg->assigned_gotno = 0;
3726 set_got_offset_arg.value = -1;
3729 /* Reorder dynamic symbols as described above (which behavior
3730 depends on the setting of VALUE). */
3731 set_got_offset_arg.g = NULL;
3732 htab_traverse (gg->got_entries, mips_elf_set_global_got_offset,
3733 &set_got_offset_arg);
3734 set_got_offset_arg.value = 1;
3735 htab_traverse (g->got_entries, mips_elf_set_global_got_offset,
3736 &set_got_offset_arg);
3737 if (! mips_elf_sort_hash_table (info, 1))
3740 /* Now go through the GOTs assigning them offset ranges.
3741 [assigned_gotno, local_gotno[ will be set to the range of local
3742 entries in each GOT. We can then compute the end of a GOT by
3743 adding local_gotno to global_gotno. We reverse the list and make
3744 it circular since then we'll be able to quickly compute the
3745 beginning of a GOT, by computing the end of its predecessor. To
3746 avoid special cases for the primary GOT, while still preserving
3747 assertions that are valid for both single- and multi-got links,
3748 we arrange for the main got struct to have the right number of
3749 global entries, but set its local_gotno such that the initial
3750 offset of the primary GOT is zero. Remember that the primary GOT
3751 will become the last item in the circular linked list, so it
3752 points back to the master GOT. */
3753 gg->local_gotno = -g->global_gotno;
3754 gg->global_gotno = g->global_gotno;
3761 struct mips_got_info *gn;
3763 assign += MIPS_RESERVED_GOTNO (info);
3764 g->assigned_gotno = assign;
3765 g->local_gotno += assign;
3766 g->local_gotno += (pages < g->page_gotno ? pages : g->page_gotno);
3767 assign = g->local_gotno + g->global_gotno + g->tls_gotno;
3769 /* Take g out of the direct list, and push it onto the reversed
3770 list that gg points to. g->next is guaranteed to be nonnull after
3771 this operation, as required by mips_elf_initialize_tls_index. */
3776 /* Set up any TLS entries. We always place the TLS entries after
3777 all non-TLS entries. */
3778 g->tls_assigned_gotno = g->local_gotno + g->global_gotno;
3779 htab_traverse (g->got_entries, mips_elf_initialize_tls_index, g);
3781 /* Move onto the next GOT. It will be a secondary GOT if nonull. */
3784 /* Mark global symbols in every non-primary GOT as ineligible for
3787 htab_traverse (g->got_entries, mips_elf_set_no_stub, NULL);
3791 got->size = (gg->next->local_gotno
3792 + gg->next->global_gotno
3793 + gg->next->tls_gotno) * MIPS_ELF_GOT_SIZE (abfd);
3799 /* Returns the first relocation of type r_type found, beginning with
3800 RELOCATION. RELEND is one-past-the-end of the relocation table. */
3802 static const Elf_Internal_Rela *
3803 mips_elf_next_relocation (bfd *abfd ATTRIBUTE_UNUSED, unsigned int r_type,
3804 const Elf_Internal_Rela *relocation,
3805 const Elf_Internal_Rela *relend)
3807 unsigned long r_symndx = ELF_R_SYM (abfd, relocation->r_info);
3809 while (relocation < relend)
3811 if (ELF_R_TYPE (abfd, relocation->r_info) == r_type
3812 && ELF_R_SYM (abfd, relocation->r_info) == r_symndx)
3818 /* We didn't find it. */
3822 /* Return whether a relocation is against a local symbol. */
3825 mips_elf_local_relocation_p (bfd *input_bfd,
3826 const Elf_Internal_Rela *relocation,
3827 asection **local_sections,
3828 bfd_boolean check_forced)
3830 unsigned long r_symndx;
3831 Elf_Internal_Shdr *symtab_hdr;
3832 struct mips_elf_link_hash_entry *h;
3835 r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
3836 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3837 extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
3839 if (r_symndx < extsymoff)
3841 if (elf_bad_symtab (input_bfd) && local_sections[r_symndx] != NULL)
3846 /* Look up the hash table to check whether the symbol
3847 was forced local. */
3848 h = (struct mips_elf_link_hash_entry *)
3849 elf_sym_hashes (input_bfd) [r_symndx - extsymoff];
3850 /* Find the real hash-table entry for this symbol. */
3851 while (h->root.root.type == bfd_link_hash_indirect
3852 || h->root.root.type == bfd_link_hash_warning)
3853 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
3854 if (h->root.forced_local)
3861 /* Sign-extend VALUE, which has the indicated number of BITS. */
3864 _bfd_mips_elf_sign_extend (bfd_vma value, int bits)
3866 if (value & ((bfd_vma) 1 << (bits - 1)))
3867 /* VALUE is negative. */
3868 value |= ((bfd_vma) - 1) << bits;
3873 /* Return non-zero if the indicated VALUE has overflowed the maximum
3874 range expressible by a signed number with the indicated number of
3878 mips_elf_overflow_p (bfd_vma value, int bits)
3880 bfd_signed_vma svalue = (bfd_signed_vma) value;
3882 if (svalue > (1 << (bits - 1)) - 1)
3883 /* The value is too big. */
3885 else if (svalue < -(1 << (bits - 1)))
3886 /* The value is too small. */
3893 /* Calculate the %high function. */
3896 mips_elf_high (bfd_vma value)
3898 return ((value + (bfd_vma) 0x8000) >> 16) & 0xffff;
3901 /* Calculate the %higher function. */
3904 mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED)
3907 return ((value + (bfd_vma) 0x80008000) >> 32) & 0xffff;
3914 /* Calculate the %highest function. */
3917 mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED)
3920 return ((value + (((bfd_vma) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
3927 /* Create the .compact_rel section. */
3930 mips_elf_create_compact_rel_section
3931 (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
3934 register asection *s;
3936 if (bfd_get_section_by_name (abfd, ".compact_rel") == NULL)
3938 flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED
3941 s = bfd_make_section_with_flags (abfd, ".compact_rel", flags);
3943 || ! bfd_set_section_alignment (abfd, s,
3944 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
3947 s->size = sizeof (Elf32_External_compact_rel);
3953 /* Create the .got section to hold the global offset table. */
3956 mips_elf_create_got_section (bfd *abfd, struct bfd_link_info *info,
3957 bfd_boolean maybe_exclude)
3960 register asection *s;
3961 struct elf_link_hash_entry *h;
3962 struct bfd_link_hash_entry *bh;
3963 struct mips_got_info *g;
3965 struct mips_elf_link_hash_table *htab;
3967 htab = mips_elf_hash_table (info);
3969 /* This function may be called more than once. */
3970 s = mips_elf_got_section (abfd, TRUE);
3973 if (! maybe_exclude)
3974 s->flags &= ~SEC_EXCLUDE;
3978 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3979 | SEC_LINKER_CREATED);
3982 flags |= SEC_EXCLUDE;
3984 /* We have to use an alignment of 2**4 here because this is hardcoded
3985 in the function stub generation and in the linker script. */
3986 s = bfd_make_section_with_flags (abfd, ".got", flags);
3988 || ! bfd_set_section_alignment (abfd, s, 4))
3991 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
3992 linker script because we don't want to define the symbol if we
3993 are not creating a global offset table. */
3995 if (! (_bfd_generic_link_add_one_symbol
3996 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
3997 0, NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
4000 h = (struct elf_link_hash_entry *) bh;
4003 h->type = STT_OBJECT;
4004 elf_hash_table (info)->hgot = h;
4007 && ! bfd_elf_link_record_dynamic_symbol (info, h))
4010 amt = sizeof (struct mips_got_info);
4011 g = bfd_alloc (abfd, amt);
4014 g->global_gotsym = NULL;
4015 g->global_gotno = 0;
4017 g->local_gotno = MIPS_RESERVED_GOTNO (info);
4019 g->assigned_gotno = MIPS_RESERVED_GOTNO (info);
4022 g->tls_ldm_offset = MINUS_ONE;
4023 g->got_entries = htab_try_create (1, mips_elf_got_entry_hash,
4024 mips_elf_got_entry_eq, NULL);
4025 if (g->got_entries == NULL)
4027 g->got_page_entries = htab_try_create (1, mips_got_page_entry_hash,
4028 mips_got_page_entry_eq, NULL);
4029 if (g->got_page_entries == NULL)
4031 mips_elf_section_data (s)->u.got_info = g;
4032 mips_elf_section_data (s)->elf.this_hdr.sh_flags
4033 |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
4035 /* VxWorks also needs a .got.plt section. */
4036 if (htab->is_vxworks)
4038 s = bfd_make_section_with_flags (abfd, ".got.plt",
4039 SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
4040 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4041 if (s == NULL || !bfd_set_section_alignment (abfd, s, 4))
4049 /* Return true if H refers to the special VxWorks __GOTT_BASE__ or
4050 __GOTT_INDEX__ symbols. These symbols are only special for
4051 shared objects; they are not used in executables. */
4054 is_gott_symbol (struct bfd_link_info *info, struct elf_link_hash_entry *h)
4056 return (mips_elf_hash_table (info)->is_vxworks
4058 && (strcmp (h->root.root.string, "__GOTT_BASE__") == 0
4059 || strcmp (h->root.root.string, "__GOTT_INDEX__") == 0));
4062 /* Calculate the value produced by the RELOCATION (which comes from
4063 the INPUT_BFD). The ADDEND is the addend to use for this
4064 RELOCATION; RELOCATION->R_ADDEND is ignored.
4066 The result of the relocation calculation is stored in VALUEP.
4067 REQUIRE_JALXP indicates whether or not the opcode used with this
4068 relocation must be JALX.
4070 This function returns bfd_reloc_continue if the caller need take no
4071 further action regarding this relocation, bfd_reloc_notsupported if
4072 something goes dramatically wrong, bfd_reloc_overflow if an
4073 overflow occurs, and bfd_reloc_ok to indicate success. */
4075 static bfd_reloc_status_type
4076 mips_elf_calculate_relocation (bfd *abfd, bfd *input_bfd,
4077 asection *input_section,
4078 struct bfd_link_info *info,
4079 const Elf_Internal_Rela *relocation,
4080 bfd_vma addend, reloc_howto_type *howto,
4081 Elf_Internal_Sym *local_syms,
4082 asection **local_sections, bfd_vma *valuep,
4083 const char **namep, bfd_boolean *require_jalxp,
4084 bfd_boolean save_addend)
4086 /* The eventual value we will return. */
4088 /* The address of the symbol against which the relocation is
4091 /* The final GP value to be used for the relocatable, executable, or
4092 shared object file being produced. */
4093 bfd_vma gp = MINUS_ONE;
4094 /* The place (section offset or address) of the storage unit being
4097 /* The value of GP used to create the relocatable object. */
4098 bfd_vma gp0 = MINUS_ONE;
4099 /* The offset into the global offset table at which the address of
4100 the relocation entry symbol, adjusted by the addend, resides
4101 during execution. */
4102 bfd_vma g = MINUS_ONE;
4103 /* The section in which the symbol referenced by the relocation is
4105 asection *sec = NULL;
4106 struct mips_elf_link_hash_entry *h = NULL;
4107 /* TRUE if the symbol referred to by this relocation is a local
4109 bfd_boolean local_p, was_local_p;
4110 /* TRUE if the symbol referred to by this relocation is "_gp_disp". */
4111 bfd_boolean gp_disp_p = FALSE;
4112 /* TRUE if the symbol referred to by this relocation is
4113 "__gnu_local_gp". */
4114 bfd_boolean gnu_local_gp_p = FALSE;
4115 Elf_Internal_Shdr *symtab_hdr;
4117 unsigned long r_symndx;
4119 /* TRUE if overflow occurred during the calculation of the
4120 relocation value. */
4121 bfd_boolean overflowed_p;
4122 /* TRUE if this relocation refers to a MIPS16 function. */
4123 bfd_boolean target_is_16_bit_code_p = FALSE;
4124 struct mips_elf_link_hash_table *htab;
4127 dynobj = elf_hash_table (info)->dynobj;
4128 htab = mips_elf_hash_table (info);
4130 /* Parse the relocation. */
4131 r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
4132 r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
4133 p = (input_section->output_section->vma
4134 + input_section->output_offset
4135 + relocation->r_offset);
4137 /* Assume that there will be no overflow. */
4138 overflowed_p = FALSE;
4140 /* Figure out whether or not the symbol is local, and get the offset
4141 used in the array of hash table entries. */
4142 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4143 local_p = mips_elf_local_relocation_p (input_bfd, relocation,
4144 local_sections, FALSE);
4145 was_local_p = local_p;
4146 if (! elf_bad_symtab (input_bfd))
4147 extsymoff = symtab_hdr->sh_info;
4150 /* The symbol table does not follow the rule that local symbols
4151 must come before globals. */
4155 /* Figure out the value of the symbol. */
4158 Elf_Internal_Sym *sym;
4160 sym = local_syms + r_symndx;
4161 sec = local_sections[r_symndx];
4163 symbol = sec->output_section->vma + sec->output_offset;
4164 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION
4165 || (sec->flags & SEC_MERGE))
4166 symbol += sym->st_value;
4167 if ((sec->flags & SEC_MERGE)
4168 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4170 addend = _bfd_elf_rel_local_sym (abfd, sym, &sec, addend);
4172 addend += sec->output_section->vma + sec->output_offset;
4175 /* MIPS16 text labels should be treated as odd. */
4176 if (sym->st_other == STO_MIPS16)
4179 /* Record the name of this symbol, for our caller. */
4180 *namep = bfd_elf_string_from_elf_section (input_bfd,
4181 symtab_hdr->sh_link,
4184 *namep = bfd_section_name (input_bfd, sec);
4186 target_is_16_bit_code_p = (sym->st_other == STO_MIPS16);
4190 /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ? */
4192 /* For global symbols we look up the symbol in the hash-table. */
4193 h = ((struct mips_elf_link_hash_entry *)
4194 elf_sym_hashes (input_bfd) [r_symndx - extsymoff]);
4195 /* Find the real hash-table entry for this symbol. */
4196 while (h->root.root.type == bfd_link_hash_indirect
4197 || h->root.root.type == bfd_link_hash_warning)
4198 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
4200 /* Record the name of this symbol, for our caller. */
4201 *namep = h->root.root.root.string;
4203 /* See if this is the special _gp_disp symbol. Note that such a
4204 symbol must always be a global symbol. */
4205 if (strcmp (*namep, "_gp_disp") == 0
4206 && ! NEWABI_P (input_bfd))
4208 /* Relocations against _gp_disp are permitted only with
4209 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
4210 if (r_type != R_MIPS_HI16 && r_type != R_MIPS_LO16
4211 && r_type != R_MIPS16_HI16 && r_type != R_MIPS16_LO16)
4212 return bfd_reloc_notsupported;
4216 /* See if this is the special _gp symbol. Note that such a
4217 symbol must always be a global symbol. */
4218 else if (strcmp (*namep, "__gnu_local_gp") == 0)
4219 gnu_local_gp_p = TRUE;
4222 /* If this symbol is defined, calculate its address. Note that
4223 _gp_disp is a magic symbol, always implicitly defined by the
4224 linker, so it's inappropriate to check to see whether or not
4226 else if ((h->root.root.type == bfd_link_hash_defined
4227 || h->root.root.type == bfd_link_hash_defweak)
4228 && h->root.root.u.def.section)
4230 sec = h->root.root.u.def.section;
4231 if (sec->output_section)
4232 symbol = (h->root.root.u.def.value
4233 + sec->output_section->vma
4234 + sec->output_offset);
4236 symbol = h->root.root.u.def.value;
4238 else if (h->root.root.type == bfd_link_hash_undefweak)
4239 /* We allow relocations against undefined weak symbols, giving
4240 it the value zero, so that you can undefined weak functions
4241 and check to see if they exist by looking at their
4244 else if (info->unresolved_syms_in_objects == RM_IGNORE
4245 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
4247 else if (strcmp (*namep, SGI_COMPAT (input_bfd)
4248 ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING") == 0)
4250 /* If this is a dynamic link, we should have created a
4251 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
4252 in in _bfd_mips_elf_create_dynamic_sections.
4253 Otherwise, we should define the symbol with a value of 0.
4254 FIXME: It should probably get into the symbol table
4256 BFD_ASSERT (! info->shared);
4257 BFD_ASSERT (bfd_get_section_by_name (abfd, ".dynamic") == NULL);
4260 else if (ELF_MIPS_IS_OPTIONAL (h->root.other))
4262 /* This is an optional symbol - an Irix specific extension to the
4263 ELF spec. Ignore it for now.
4264 XXX - FIXME - there is more to the spec for OPTIONAL symbols
4265 than simply ignoring them, but we do not handle this for now.
4266 For information see the "64-bit ELF Object File Specification"
4267 which is available from here:
4268 http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf */
4273 if (! ((*info->callbacks->undefined_symbol)
4274 (info, h->root.root.root.string, input_bfd,
4275 input_section, relocation->r_offset,
4276 (info->unresolved_syms_in_objects == RM_GENERATE_ERROR)
4277 || ELF_ST_VISIBILITY (h->root.other))))
4278 return bfd_reloc_undefined;
4282 target_is_16_bit_code_p = (h->root.other == STO_MIPS16);
4285 /* If this is a 32- or 64-bit call to a 16-bit function with a stub, we
4286 need to redirect the call to the stub, unless we're already *in*
4288 if (r_type != R_MIPS16_26 && !info->relocatable
4289 && ((h != NULL && h->fn_stub != NULL)
4291 && elf_tdata (input_bfd)->local_stubs != NULL
4292 && elf_tdata (input_bfd)->local_stubs[r_symndx] != NULL))
4293 && !mips16_stub_section_p (input_bfd, input_section))
4295 /* This is a 32- or 64-bit call to a 16-bit function. We should
4296 have already noticed that we were going to need the
4299 sec = elf_tdata (input_bfd)->local_stubs[r_symndx];
4302 BFD_ASSERT (h->need_fn_stub);
4306 symbol = sec->output_section->vma + sec->output_offset;
4307 /* The target is 16-bit, but the stub isn't. */
4308 target_is_16_bit_code_p = FALSE;
4310 /* If this is a 16-bit call to a 32- or 64-bit function with a stub, we
4311 need to redirect the call to the stub. */
4312 else if (r_type == R_MIPS16_26 && !info->relocatable
4313 && ((h != NULL && (h->call_stub != NULL || h->call_fp_stub != NULL))
4315 && elf_tdata (input_bfd)->local_call_stubs != NULL
4316 && elf_tdata (input_bfd)->local_call_stubs[r_symndx] != NULL))
4317 && !target_is_16_bit_code_p)
4320 sec = elf_tdata (input_bfd)->local_call_stubs[r_symndx];
4323 /* If both call_stub and call_fp_stub are defined, we can figure
4324 out which one to use by checking which one appears in the input
4326 if (h->call_stub != NULL && h->call_fp_stub != NULL)
4331 for (o = input_bfd->sections; o != NULL; o = o->next)
4333 if (CALL_FP_STUB_P (bfd_get_section_name (input_bfd, o)))
4335 sec = h->call_fp_stub;
4342 else if (h->call_stub != NULL)
4345 sec = h->call_fp_stub;
4348 BFD_ASSERT (sec->size > 0);
4349 symbol = sec->output_section->vma + sec->output_offset;
4352 /* Calls from 16-bit code to 32-bit code and vice versa require the
4353 special jalx instruction. */
4354 *require_jalxp = (!info->relocatable
4355 && (((r_type == R_MIPS16_26) && !target_is_16_bit_code_p)
4356 || ((r_type == R_MIPS_26) && target_is_16_bit_code_p)));
4358 local_p = mips_elf_local_relocation_p (input_bfd, relocation,
4359 local_sections, TRUE);
4361 /* If we haven't already determined the GOT offset, or the GP value,
4362 and we're going to need it, get it now. */
4365 case R_MIPS_GOT_PAGE:
4366 case R_MIPS_GOT_OFST:
4367 /* We need to decay to GOT_DISP/addend if the symbol doesn't
4369 local_p = local_p || _bfd_elf_symbol_refs_local_p (&h->root, info, 1);
4370 if (local_p || r_type == R_MIPS_GOT_OFST)
4376 case R_MIPS_GOT_DISP:
4377 case R_MIPS_GOT_HI16:
4378 case R_MIPS_CALL_HI16:
4379 case R_MIPS_GOT_LO16:
4380 case R_MIPS_CALL_LO16:
4382 case R_MIPS_TLS_GOTTPREL:
4383 case R_MIPS_TLS_LDM:
4384 /* Find the index into the GOT where this value is located. */
4385 if (r_type == R_MIPS_TLS_LDM)
4387 g = mips_elf_local_got_index (abfd, input_bfd, info,
4388 0, 0, NULL, r_type);
4390 return bfd_reloc_outofrange;
4394 /* On VxWorks, CALL relocations should refer to the .got.plt
4395 entry, which is initialized to point at the PLT stub. */
4396 if (htab->is_vxworks
4397 && (r_type == R_MIPS_CALL_HI16
4398 || r_type == R_MIPS_CALL_LO16
4399 || r_type == R_MIPS_CALL16))
4401 BFD_ASSERT (addend == 0);
4402 BFD_ASSERT (h->root.needs_plt);
4403 g = mips_elf_gotplt_index (info, &h->root);
4407 /* GOT_PAGE may take a non-zero addend, that is ignored in a
4408 GOT_PAGE relocation that decays to GOT_DISP because the
4409 symbol turns out to be global. The addend is then added
4411 BFD_ASSERT (addend == 0 || r_type == R_MIPS_GOT_PAGE);
4412 g = mips_elf_global_got_index (dynobj, input_bfd,
4413 &h->root, r_type, info);
4414 if (h->tls_type == GOT_NORMAL
4415 && (! elf_hash_table(info)->dynamic_sections_created
4417 && (info->symbolic || h->root.forced_local)
4418 && h->root.def_regular)))
4420 /* This is a static link or a -Bsymbolic link. The
4421 symbol is defined locally, or was forced to be local.
4422 We must initialize this entry in the GOT. */
4423 asection *sgot = mips_elf_got_section (dynobj, FALSE);
4424 MIPS_ELF_PUT_WORD (dynobj, symbol, sgot->contents + g);
4428 else if (!htab->is_vxworks
4429 && (r_type == R_MIPS_CALL16 || (r_type == R_MIPS_GOT16)))
4430 /* The calculation below does not involve "g". */
4434 g = mips_elf_local_got_index (abfd, input_bfd, info,
4435 symbol + addend, r_symndx, h, r_type);
4437 return bfd_reloc_outofrange;
4440 /* Convert GOT indices to actual offsets. */
4441 g = mips_elf_got_offset_from_index (dynobj, abfd, input_bfd, g);
4446 case R_MIPS_GPREL16:
4447 case R_MIPS_GPREL32:
4448 case R_MIPS_LITERAL:
4451 case R_MIPS16_GPREL:
4452 gp0 = _bfd_get_gp_value (input_bfd);
4453 gp = _bfd_get_gp_value (abfd);
4455 gp += mips_elf_adjust_gp (abfd, mips_elf_got_info (dynobj, NULL),
4466 /* Relocations against the VxWorks __GOTT_BASE__ and __GOTT_INDEX__
4467 symbols are resolved by the loader. Add them to .rela.dyn. */
4468 if (h != NULL && is_gott_symbol (info, &h->root))
4470 Elf_Internal_Rela outrel;
4474 s = mips_elf_rel_dyn_section (info, FALSE);
4475 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
4477 outrel.r_offset = (input_section->output_section->vma
4478 + input_section->output_offset
4479 + relocation->r_offset);
4480 outrel.r_info = ELF32_R_INFO (h->root.dynindx, r_type);
4481 outrel.r_addend = addend;
4482 bfd_elf32_swap_reloca_out (abfd, &outrel, loc);
4484 /* If we've written this relocation for a readonly section,
4485 we need to set DF_TEXTREL again, so that we do not delete the
4487 if (MIPS_ELF_READONLY_SECTION (input_section))
4488 info->flags |= DF_TEXTREL;
4491 return bfd_reloc_ok;
4494 /* Figure out what kind of relocation is being performed. */
4498 return bfd_reloc_continue;
4501 value = symbol + _bfd_mips_elf_sign_extend (addend, 16);
4502 overflowed_p = mips_elf_overflow_p (value, 16);
4509 || (!htab->is_vxworks
4510 && htab->root.dynamic_sections_created
4512 && h->root.def_dynamic
4513 && !h->root.def_regular))
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_"))
5698 case SHT_MIPS_SYMBOL_LIB:
5699 if (strcmp (name, ".MIPS.symlib") != 0)
5702 case SHT_MIPS_EVENTS:
5703 if (! CONST_STRNEQ (name, ".MIPS.events")
5704 && ! CONST_STRNEQ (name, ".MIPS.post_rel"))
5711 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
5716 if (! bfd_set_section_flags (abfd, hdr->bfd_section,
5717 (bfd_get_section_flags (abfd,
5723 /* FIXME: We should record sh_info for a .gptab section. */
5725 /* For a .reginfo section, set the gp value in the tdata information
5726 from the contents of this section. We need the gp value while
5727 processing relocs, so we just get it now. The .reginfo section
5728 is not used in the 64-bit MIPS ELF ABI. */
5729 if (hdr->sh_type == SHT_MIPS_REGINFO)
5731 Elf32_External_RegInfo ext;
5734 if (! bfd_get_section_contents (abfd, hdr->bfd_section,
5735 &ext, 0, sizeof ext))
5737 bfd_mips_elf32_swap_reginfo_in (abfd, &ext, &s);
5738 elf_gp (abfd) = s.ri_gp_value;
5741 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
5742 set the gp value based on what we find. We may see both
5743 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
5744 they should agree. */
5745 if (hdr->sh_type == SHT_MIPS_OPTIONS)
5747 bfd_byte *contents, *l, *lend;
5749 contents = bfd_malloc (hdr->sh_size);
5750 if (contents == NULL)
5752 if (! bfd_get_section_contents (abfd, hdr->bfd_section, contents,
5759 lend = contents + hdr->sh_size;
5760 while (l + sizeof (Elf_External_Options) <= lend)
5762 Elf_Internal_Options intopt;
5764 bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
5766 if (intopt.size < sizeof (Elf_External_Options))
5768 (*_bfd_error_handler)
5769 (_("%B: Warning: bad `%s' option size %u smaller than its header"),
5770 abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size);
5773 if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
5775 Elf64_Internal_RegInfo intreg;
5777 bfd_mips_elf64_swap_reginfo_in
5779 ((Elf64_External_RegInfo *)
5780 (l + sizeof (Elf_External_Options))),
5782 elf_gp (abfd) = intreg.ri_gp_value;
5784 else if (intopt.kind == ODK_REGINFO)
5786 Elf32_RegInfo intreg;
5788 bfd_mips_elf32_swap_reginfo_in
5790 ((Elf32_External_RegInfo *)
5791 (l + sizeof (Elf_External_Options))),
5793 elf_gp (abfd) = intreg.ri_gp_value;
5803 /* Set the correct type for a MIPS ELF section. We do this by the
5804 section name, which is a hack, but ought to work. This routine is
5805 used by both the 32-bit and the 64-bit ABI. */
5808 _bfd_mips_elf_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec)
5810 const char *name = bfd_get_section_name (abfd, sec);
5812 if (strcmp (name, ".liblist") == 0)
5814 hdr->sh_type = SHT_MIPS_LIBLIST;
5815 hdr->sh_info = sec->size / sizeof (Elf32_Lib);
5816 /* The sh_link field is set in final_write_processing. */
5818 else if (strcmp (name, ".conflict") == 0)
5819 hdr->sh_type = SHT_MIPS_CONFLICT;
5820 else if (CONST_STRNEQ (name, ".gptab."))
5822 hdr->sh_type = SHT_MIPS_GPTAB;
5823 hdr->sh_entsize = sizeof (Elf32_External_gptab);
5824 /* The sh_info field is set in final_write_processing. */
5826 else if (strcmp (name, ".ucode") == 0)
5827 hdr->sh_type = SHT_MIPS_UCODE;
5828 else if (strcmp (name, ".mdebug") == 0)
5830 hdr->sh_type = SHT_MIPS_DEBUG;
5831 /* In a shared object on IRIX 5.3, the .mdebug section has an
5832 entsize of 0. FIXME: Does this matter? */
5833 if (SGI_COMPAT (abfd) && (abfd->flags & DYNAMIC) != 0)
5834 hdr->sh_entsize = 0;
5836 hdr->sh_entsize = 1;
5838 else if (strcmp (name, ".reginfo") == 0)
5840 hdr->sh_type = SHT_MIPS_REGINFO;
5841 /* In a shared object on IRIX 5.3, the .reginfo section has an
5842 entsize of 0x18. FIXME: Does this matter? */
5843 if (SGI_COMPAT (abfd))
5845 if ((abfd->flags & DYNAMIC) != 0)
5846 hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
5848 hdr->sh_entsize = 1;
5851 hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
5853 else if (SGI_COMPAT (abfd)
5854 && (strcmp (name, ".hash") == 0
5855 || strcmp (name, ".dynamic") == 0
5856 || strcmp (name, ".dynstr") == 0))
5858 if (SGI_COMPAT (abfd))
5859 hdr->sh_entsize = 0;
5861 /* This isn't how the IRIX6 linker behaves. */
5862 hdr->sh_info = SIZEOF_MIPS_DYNSYM_SECNAMES;
5865 else if (strcmp (name, ".got") == 0
5866 || strcmp (name, ".srdata") == 0
5867 || strcmp (name, ".sdata") == 0
5868 || strcmp (name, ".sbss") == 0
5869 || strcmp (name, ".lit4") == 0
5870 || strcmp (name, ".lit8") == 0)
5871 hdr->sh_flags |= SHF_MIPS_GPREL;
5872 else if (strcmp (name, ".MIPS.interfaces") == 0)
5874 hdr->sh_type = SHT_MIPS_IFACE;
5875 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
5877 else if (CONST_STRNEQ (name, ".MIPS.content"))
5879 hdr->sh_type = SHT_MIPS_CONTENT;
5880 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
5881 /* The sh_info field is set in final_write_processing. */
5883 else if (MIPS_ELF_OPTIONS_SECTION_NAME_P (name))
5885 hdr->sh_type = SHT_MIPS_OPTIONS;
5886 hdr->sh_entsize = 1;
5887 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
5889 else if (CONST_STRNEQ (name, ".debug_"))
5891 hdr->sh_type = SHT_MIPS_DWARF;
5893 /* Irix facilities such as libexc expect a single .debug_frame
5894 per executable, the system ones have NOSTRIP set and the linker
5895 doesn't merge sections with different flags so ... */
5896 if (SGI_COMPAT (abfd) && CONST_STRNEQ (name, ".debug_frame"))
5897 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
5899 else if (strcmp (name, ".MIPS.symlib") == 0)
5901 hdr->sh_type = SHT_MIPS_SYMBOL_LIB;
5902 /* The sh_link and sh_info fields are set in
5903 final_write_processing. */
5905 else if (CONST_STRNEQ (name, ".MIPS.events")
5906 || CONST_STRNEQ (name, ".MIPS.post_rel"))
5908 hdr->sh_type = SHT_MIPS_EVENTS;
5909 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
5910 /* The sh_link field is set in final_write_processing. */
5912 else if (strcmp (name, ".msym") == 0)
5914 hdr->sh_type = SHT_MIPS_MSYM;
5915 hdr->sh_flags |= SHF_ALLOC;
5916 hdr->sh_entsize = 8;
5919 /* The generic elf_fake_sections will set up REL_HDR using the default
5920 kind of relocations. We used to set up a second header for the
5921 non-default kind of relocations here, but only NewABI would use
5922 these, and the IRIX ld doesn't like resulting empty RELA sections.
5923 Thus we create those header only on demand now. */
5928 /* Given a BFD section, try to locate the corresponding ELF section
5929 index. This is used by both the 32-bit and the 64-bit ABI.
5930 Actually, it's not clear to me that the 64-bit ABI supports these,
5931 but for non-PIC objects we will certainly want support for at least
5932 the .scommon section. */
5935 _bfd_mips_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
5936 asection *sec, int *retval)
5938 if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
5940 *retval = SHN_MIPS_SCOMMON;
5943 if (strcmp (bfd_get_section_name (abfd, sec), ".acommon") == 0)
5945 *retval = SHN_MIPS_ACOMMON;
5951 /* Hook called by the linker routine which adds symbols from an object
5952 file. We must handle the special MIPS section numbers here. */
5955 _bfd_mips_elf_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
5956 Elf_Internal_Sym *sym, const char **namep,
5957 flagword *flagsp ATTRIBUTE_UNUSED,
5958 asection **secp, bfd_vma *valp)
5960 if (SGI_COMPAT (abfd)
5961 && (abfd->flags & DYNAMIC) != 0
5962 && strcmp (*namep, "_rld_new_interface") == 0)
5964 /* Skip IRIX5 rld entry name. */
5969 /* Shared objects may have a dynamic symbol '_gp_disp' defined as
5970 a SECTION *ABS*. This causes ld to think it can resolve _gp_disp
5971 by setting a DT_NEEDED for the shared object. Since _gp_disp is
5972 a magic symbol resolved by the linker, we ignore this bogus definition
5973 of _gp_disp. New ABI objects do not suffer from this problem so this
5974 is not done for them. */
5976 && (sym->st_shndx == SHN_ABS)
5977 && (strcmp (*namep, "_gp_disp") == 0))
5983 switch (sym->st_shndx)
5986 /* Common symbols less than the GP size are automatically
5987 treated as SHN_MIPS_SCOMMON symbols. */
5988 if (sym->st_size > elf_gp_size (abfd)
5989 || ELF_ST_TYPE (sym->st_info) == STT_TLS
5990 || IRIX_COMPAT (abfd) == ict_irix6)
5993 case SHN_MIPS_SCOMMON:
5994 *secp = bfd_make_section_old_way (abfd, ".scommon");
5995 (*secp)->flags |= SEC_IS_COMMON;
5996 *valp = sym->st_size;
6000 /* This section is used in a shared object. */
6001 if (elf_tdata (abfd)->elf_text_section == NULL)
6003 asymbol *elf_text_symbol;
6004 asection *elf_text_section;
6005 bfd_size_type amt = sizeof (asection);
6007 elf_text_section = bfd_zalloc (abfd, amt);
6008 if (elf_text_section == NULL)
6011 amt = sizeof (asymbol);
6012 elf_text_symbol = bfd_zalloc (abfd, amt);
6013 if (elf_text_symbol == NULL)
6016 /* Initialize the section. */
6018 elf_tdata (abfd)->elf_text_section = elf_text_section;
6019 elf_tdata (abfd)->elf_text_symbol = elf_text_symbol;
6021 elf_text_section->symbol = elf_text_symbol;
6022 elf_text_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_text_symbol;
6024 elf_text_section->name = ".text";
6025 elf_text_section->flags = SEC_NO_FLAGS;
6026 elf_text_section->output_section = NULL;
6027 elf_text_section->owner = abfd;
6028 elf_text_symbol->name = ".text";
6029 elf_text_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
6030 elf_text_symbol->section = elf_text_section;
6032 /* This code used to do *secp = bfd_und_section_ptr if
6033 info->shared. I don't know why, and that doesn't make sense,
6034 so I took it out. */
6035 *secp = elf_tdata (abfd)->elf_text_section;
6038 case SHN_MIPS_ACOMMON:
6039 /* Fall through. XXX Can we treat this as allocated data? */
6041 /* This section is used in a shared object. */
6042 if (elf_tdata (abfd)->elf_data_section == NULL)
6044 asymbol *elf_data_symbol;
6045 asection *elf_data_section;
6046 bfd_size_type amt = sizeof (asection);
6048 elf_data_section = bfd_zalloc (abfd, amt);
6049 if (elf_data_section == NULL)
6052 amt = sizeof (asymbol);
6053 elf_data_symbol = bfd_zalloc (abfd, amt);
6054 if (elf_data_symbol == NULL)
6057 /* Initialize the section. */
6059 elf_tdata (abfd)->elf_data_section = elf_data_section;
6060 elf_tdata (abfd)->elf_data_symbol = elf_data_symbol;
6062 elf_data_section->symbol = elf_data_symbol;
6063 elf_data_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_data_symbol;
6065 elf_data_section->name = ".data";
6066 elf_data_section->flags = SEC_NO_FLAGS;
6067 elf_data_section->output_section = NULL;
6068 elf_data_section->owner = abfd;
6069 elf_data_symbol->name = ".data";
6070 elf_data_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
6071 elf_data_symbol->section = elf_data_section;
6073 /* This code used to do *secp = bfd_und_section_ptr if
6074 info->shared. I don't know why, and that doesn't make sense,
6075 so I took it out. */
6076 *secp = elf_tdata (abfd)->elf_data_section;
6079 case SHN_MIPS_SUNDEFINED:
6080 *secp = bfd_und_section_ptr;
6084 if (SGI_COMPAT (abfd)
6086 && info->hash->creator == abfd->xvec
6087 && strcmp (*namep, "__rld_obj_head") == 0)
6089 struct elf_link_hash_entry *h;
6090 struct bfd_link_hash_entry *bh;
6092 /* Mark __rld_obj_head as dynamic. */
6094 if (! (_bfd_generic_link_add_one_symbol
6095 (info, abfd, *namep, BSF_GLOBAL, *secp, *valp, NULL, FALSE,
6096 get_elf_backend_data (abfd)->collect, &bh)))
6099 h = (struct elf_link_hash_entry *) bh;
6102 h->type = STT_OBJECT;
6104 if (! bfd_elf_link_record_dynamic_symbol (info, h))
6107 mips_elf_hash_table (info)->use_rld_obj_head = TRUE;
6110 /* If this is a mips16 text symbol, add 1 to the value to make it
6111 odd. This will cause something like .word SYM to come up with
6112 the right value when it is loaded into the PC. */
6113 if (sym->st_other == STO_MIPS16)
6119 /* This hook function is called before the linker writes out a global
6120 symbol. We mark symbols as small common if appropriate. This is
6121 also where we undo the increment of the value for a mips16 symbol. */
6124 _bfd_mips_elf_link_output_symbol_hook
6125 (struct bfd_link_info *info ATTRIBUTE_UNUSED,
6126 const char *name ATTRIBUTE_UNUSED, Elf_Internal_Sym *sym,
6127 asection *input_sec, struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
6129 /* If we see a common symbol, which implies a relocatable link, then
6130 if a symbol was small common in an input file, mark it as small
6131 common in the output file. */
6132 if (sym->st_shndx == SHN_COMMON
6133 && strcmp (input_sec->name, ".scommon") == 0)
6134 sym->st_shndx = SHN_MIPS_SCOMMON;
6136 if (sym->st_other == STO_MIPS16)
6137 sym->st_value &= ~1;
6142 /* Functions for the dynamic linker. */
6144 /* Create dynamic sections when linking against a dynamic object. */
6147 _bfd_mips_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
6149 struct elf_link_hash_entry *h;
6150 struct bfd_link_hash_entry *bh;
6152 register asection *s;
6153 const char * const *namep;
6154 struct mips_elf_link_hash_table *htab;
6156 htab = mips_elf_hash_table (info);
6157 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
6158 | SEC_LINKER_CREATED | SEC_READONLY);
6160 /* The psABI requires a read-only .dynamic section, but the VxWorks
6162 if (!htab->is_vxworks)
6164 s = bfd_get_section_by_name (abfd, ".dynamic");
6167 if (! bfd_set_section_flags (abfd, s, flags))
6172 /* We need to create .got section. */
6173 if (! mips_elf_create_got_section (abfd, info, FALSE))
6176 if (! mips_elf_rel_dyn_section (info, TRUE))
6179 /* Create .stub section. */
6180 if (bfd_get_section_by_name (abfd,
6181 MIPS_ELF_STUB_SECTION_NAME (abfd)) == NULL)
6183 s = bfd_make_section_with_flags (abfd,
6184 MIPS_ELF_STUB_SECTION_NAME (abfd),
6187 || ! bfd_set_section_alignment (abfd, s,
6188 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
6192 if ((IRIX_COMPAT (abfd) == ict_irix5 || IRIX_COMPAT (abfd) == ict_none)
6194 && bfd_get_section_by_name (abfd, ".rld_map") == NULL)
6196 s = bfd_make_section_with_flags (abfd, ".rld_map",
6197 flags &~ (flagword) SEC_READONLY);
6199 || ! bfd_set_section_alignment (abfd, s,
6200 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
6204 /* On IRIX5, we adjust add some additional symbols and change the
6205 alignments of several sections. There is no ABI documentation
6206 indicating that this is necessary on IRIX6, nor any evidence that
6207 the linker takes such action. */
6208 if (IRIX_COMPAT (abfd) == ict_irix5)
6210 for (namep = mips_elf_dynsym_rtproc_names; *namep != NULL; namep++)
6213 if (! (_bfd_generic_link_add_one_symbol
6214 (info, abfd, *namep, BSF_GLOBAL, bfd_und_section_ptr, 0,
6215 NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
6218 h = (struct elf_link_hash_entry *) bh;
6221 h->type = STT_SECTION;
6223 if (! bfd_elf_link_record_dynamic_symbol (info, h))
6227 /* We need to create a .compact_rel section. */
6228 if (SGI_COMPAT (abfd))
6230 if (!mips_elf_create_compact_rel_section (abfd, info))
6234 /* Change alignments of some sections. */
6235 s = bfd_get_section_by_name (abfd, ".hash");
6237 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
6238 s = bfd_get_section_by_name (abfd, ".dynsym");
6240 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
6241 s = bfd_get_section_by_name (abfd, ".dynstr");
6243 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
6244 s = bfd_get_section_by_name (abfd, ".reginfo");
6246 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
6247 s = bfd_get_section_by_name (abfd, ".dynamic");
6249 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
6256 name = SGI_COMPAT (abfd) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
6258 if (!(_bfd_generic_link_add_one_symbol
6259 (info, abfd, name, BSF_GLOBAL, bfd_abs_section_ptr, 0,
6260 NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
6263 h = (struct elf_link_hash_entry *) bh;
6266 h->type = STT_SECTION;
6268 if (! bfd_elf_link_record_dynamic_symbol (info, h))
6271 if (! mips_elf_hash_table (info)->use_rld_obj_head)
6273 /* __rld_map is a four byte word located in the .data section
6274 and is filled in by the rtld to contain a pointer to
6275 the _r_debug structure. Its symbol value will be set in
6276 _bfd_mips_elf_finish_dynamic_symbol. */
6277 s = bfd_get_section_by_name (abfd, ".rld_map");
6278 BFD_ASSERT (s != NULL);
6280 name = SGI_COMPAT (abfd) ? "__rld_map" : "__RLD_MAP";
6282 if (!(_bfd_generic_link_add_one_symbol
6283 (info, abfd, name, BSF_GLOBAL, s, 0, NULL, FALSE,
6284 get_elf_backend_data (abfd)->collect, &bh)))
6287 h = (struct elf_link_hash_entry *) bh;
6290 h->type = STT_OBJECT;
6292 if (! bfd_elf_link_record_dynamic_symbol (info, h))
6297 if (htab->is_vxworks)
6299 /* Create the .plt, .rela.plt, .dynbss and .rela.bss sections.
6300 Also create the _PROCEDURE_LINKAGE_TABLE symbol. */
6301 if (!_bfd_elf_create_dynamic_sections (abfd, info))
6304 /* Cache the sections created above. */
6305 htab->sdynbss = bfd_get_section_by_name (abfd, ".dynbss");
6306 htab->srelbss = bfd_get_section_by_name (abfd, ".rela.bss");
6307 htab->srelplt = bfd_get_section_by_name (abfd, ".rela.plt");
6308 htab->splt = bfd_get_section_by_name (abfd, ".plt");
6310 || (!htab->srelbss && !info->shared)
6315 /* Do the usual VxWorks handling. */
6316 if (!elf_vxworks_create_dynamic_sections (abfd, info, &htab->srelplt2))
6319 /* Work out the PLT sizes. */
6322 htab->plt_header_size
6323 = 4 * ARRAY_SIZE (mips_vxworks_shared_plt0_entry);
6324 htab->plt_entry_size
6325 = 4 * ARRAY_SIZE (mips_vxworks_shared_plt_entry);
6329 htab->plt_header_size
6330 = 4 * ARRAY_SIZE (mips_vxworks_exec_plt0_entry);
6331 htab->plt_entry_size
6332 = 4 * ARRAY_SIZE (mips_vxworks_exec_plt_entry);
6339 /* Return true if relocation REL against section SEC is a REL rather than
6340 RELA relocation. RELOCS is the first relocation in the section and
6341 ABFD is the bfd that contains SEC. */
6344 mips_elf_rel_relocation_p (bfd *abfd, asection *sec,
6345 const Elf_Internal_Rela *relocs,
6346 const Elf_Internal_Rela *rel)
6348 Elf_Internal_Shdr *rel_hdr;
6349 const struct elf_backend_data *bed;
6351 /* To determine which flavor or relocation this is, we depend on the
6352 fact that the INPUT_SECTION's REL_HDR is read before its REL_HDR2. */
6353 rel_hdr = &elf_section_data (sec)->rel_hdr;
6354 bed = get_elf_backend_data (abfd);
6355 if ((size_t) (rel - relocs)
6356 >= (NUM_SHDR_ENTRIES (rel_hdr) * bed->s->int_rels_per_ext_rel))
6357 rel_hdr = elf_section_data (sec)->rel_hdr2;
6358 return rel_hdr->sh_entsize == MIPS_ELF_REL_SIZE (abfd);
6361 /* Read the addend for REL relocation REL, which belongs to bfd ABFD.
6362 HOWTO is the relocation's howto and CONTENTS points to the contents
6363 of the section that REL is against. */
6366 mips_elf_read_rel_addend (bfd *abfd, const Elf_Internal_Rela *rel,
6367 reloc_howto_type *howto, bfd_byte *contents)
6370 unsigned int r_type;
6373 r_type = ELF_R_TYPE (abfd, rel->r_info);
6374 location = contents + rel->r_offset;
6376 /* Get the addend, which is stored in the input file. */
6377 _bfd_mips16_elf_reloc_unshuffle (abfd, r_type, FALSE, location);
6378 addend = mips_elf_obtain_contents (howto, rel, abfd, contents);
6379 _bfd_mips16_elf_reloc_shuffle (abfd, r_type, FALSE, location);
6381 return addend & howto->src_mask;
6384 /* REL is a relocation in ABFD that needs a partnering LO16 relocation
6385 and *ADDEND is the addend for REL itself. Look for the LO16 relocation
6386 and update *ADDEND with the final addend. Return true on success
6387 or false if the LO16 could not be found. RELEND is the exclusive
6388 upper bound on the relocations for REL's section. */
6391 mips_elf_add_lo16_rel_addend (bfd *abfd,
6392 const Elf_Internal_Rela *rel,
6393 const Elf_Internal_Rela *relend,
6394 bfd_byte *contents, bfd_vma *addend)
6396 unsigned int r_type, lo16_type;
6397 const Elf_Internal_Rela *lo16_relocation;
6398 reloc_howto_type *lo16_howto;
6401 r_type = ELF_R_TYPE (abfd, rel->r_info);
6402 if (r_type == R_MIPS16_HI16)
6403 lo16_type = R_MIPS16_LO16;
6405 lo16_type = R_MIPS_LO16;
6407 /* The combined value is the sum of the HI16 addend, left-shifted by
6408 sixteen bits, and the LO16 addend, sign extended. (Usually, the
6409 code does a `lui' of the HI16 value, and then an `addiu' of the
6412 Scan ahead to find a matching LO16 relocation.
6414 According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must
6415 be immediately following. However, for the IRIX6 ABI, the next
6416 relocation may be a composed relocation consisting of several
6417 relocations for the same address. In that case, the R_MIPS_LO16
6418 relocation may occur as one of these. We permit a similar
6419 extension in general, as that is useful for GCC.
6421 In some cases GCC dead code elimination removes the LO16 but keeps
6422 the corresponding HI16. This is strictly speaking a violation of
6423 the ABI but not immediately harmful. */
6424 lo16_relocation = mips_elf_next_relocation (abfd, lo16_type, rel, relend);
6425 if (lo16_relocation == NULL)
6428 /* Obtain the addend kept there. */
6429 lo16_howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, lo16_type, FALSE);
6430 l = mips_elf_read_rel_addend (abfd, lo16_relocation, lo16_howto, contents);
6432 l <<= lo16_howto->rightshift;
6433 l = _bfd_mips_elf_sign_extend (l, 16);
6440 /* Try to read the contents of section SEC in bfd ABFD. Return true and
6441 store the contents in *CONTENTS on success. Assume that *CONTENTS
6442 already holds the contents if it is nonull on entry. */
6445 mips_elf_get_section_contents (bfd *abfd, asection *sec, bfd_byte **contents)
6450 /* Get cached copy if it exists. */
6451 if (elf_section_data (sec)->this_hdr.contents != NULL)
6453 *contents = elf_section_data (sec)->this_hdr.contents;
6457 return bfd_malloc_and_get_section (abfd, sec, contents);
6460 /* Look through the relocs for a section during the first phase, and
6461 allocate space in the global offset table. */
6464 _bfd_mips_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
6465 asection *sec, const Elf_Internal_Rela *relocs)
6469 Elf_Internal_Shdr *symtab_hdr;
6470 struct elf_link_hash_entry **sym_hashes;
6471 struct mips_got_info *g;
6473 const Elf_Internal_Rela *rel;
6474 const Elf_Internal_Rela *rel_end;
6477 const struct elf_backend_data *bed;
6478 struct mips_elf_link_hash_table *htab;
6481 reloc_howto_type *howto;
6483 if (info->relocatable)
6486 htab = mips_elf_hash_table (info);
6487 dynobj = elf_hash_table (info)->dynobj;
6488 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6489 sym_hashes = elf_sym_hashes (abfd);
6490 extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
6492 /* Check for the mips16 stub sections. */
6494 name = bfd_get_section_name (abfd, sec);
6495 if (FN_STUB_P (name))
6497 unsigned long r_symndx;
6499 /* Look at the relocation information to figure out which symbol
6502 r_symndx = ELF_R_SYM (abfd, relocs->r_info);
6504 if (r_symndx < extsymoff
6505 || sym_hashes[r_symndx - extsymoff] == NULL)
6509 /* This stub is for a local symbol. This stub will only be
6510 needed if there is some relocation in this BFD, other
6511 than a 16 bit function call, which refers to this symbol. */
6512 for (o = abfd->sections; o != NULL; o = o->next)
6514 Elf_Internal_Rela *sec_relocs;
6515 const Elf_Internal_Rela *r, *rend;
6517 /* We can ignore stub sections when looking for relocs. */
6518 if ((o->flags & SEC_RELOC) == 0
6519 || o->reloc_count == 0
6520 || mips16_stub_section_p (abfd, o))
6524 = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
6526 if (sec_relocs == NULL)
6529 rend = sec_relocs + o->reloc_count;
6530 for (r = sec_relocs; r < rend; r++)
6531 if (ELF_R_SYM (abfd, r->r_info) == r_symndx
6532 && ELF_R_TYPE (abfd, r->r_info) != R_MIPS16_26)
6535 if (elf_section_data (o)->relocs != sec_relocs)
6544 /* There is no non-call reloc for this stub, so we do
6545 not need it. Since this function is called before
6546 the linker maps input sections to output sections, we
6547 can easily discard it by setting the SEC_EXCLUDE
6549 sec->flags |= SEC_EXCLUDE;
6553 /* Record this stub in an array of local symbol stubs for
6555 if (elf_tdata (abfd)->local_stubs == NULL)
6557 unsigned long symcount;
6561 if (elf_bad_symtab (abfd))
6562 symcount = NUM_SHDR_ENTRIES (symtab_hdr);
6564 symcount = symtab_hdr->sh_info;
6565 amt = symcount * sizeof (asection *);
6566 n = bfd_zalloc (abfd, amt);
6569 elf_tdata (abfd)->local_stubs = n;
6572 sec->flags |= SEC_KEEP;
6573 elf_tdata (abfd)->local_stubs[r_symndx] = sec;
6575 /* We don't need to set mips16_stubs_seen in this case.
6576 That flag is used to see whether we need to look through
6577 the global symbol table for stubs. We don't need to set
6578 it here, because we just have a local stub. */
6582 struct mips_elf_link_hash_entry *h;
6584 h = ((struct mips_elf_link_hash_entry *)
6585 sym_hashes[r_symndx - extsymoff]);
6587 while (h->root.root.type == bfd_link_hash_indirect
6588 || h->root.root.type == bfd_link_hash_warning)
6589 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
6591 /* H is the symbol this stub is for. */
6593 /* If we already have an appropriate stub for this function, we
6594 don't need another one, so we can discard this one. Since
6595 this function is called before the linker maps input sections
6596 to output sections, we can easily discard it by setting the
6597 SEC_EXCLUDE flag. */
6598 if (h->fn_stub != NULL)
6600 sec->flags |= SEC_EXCLUDE;
6604 sec->flags |= SEC_KEEP;
6606 mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
6609 else if (CALL_STUB_P (name) || CALL_FP_STUB_P (name))
6611 unsigned long r_symndx;
6612 struct mips_elf_link_hash_entry *h;
6615 /* Look at the relocation information to figure out which symbol
6618 r_symndx = ELF_R_SYM (abfd, relocs->r_info);
6620 if (r_symndx < extsymoff
6621 || sym_hashes[r_symndx - extsymoff] == NULL)
6625 /* This stub is for a local symbol. This stub will only be
6626 needed if there is some relocation (R_MIPS16_26) in this BFD
6627 that refers to this symbol. */
6628 for (o = abfd->sections; o != NULL; o = o->next)
6630 Elf_Internal_Rela *sec_relocs;
6631 const Elf_Internal_Rela *r, *rend;
6633 /* We can ignore stub sections when looking for relocs. */
6634 if ((o->flags & SEC_RELOC) == 0
6635 || o->reloc_count == 0
6636 || mips16_stub_section_p (abfd, o))
6640 = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
6642 if (sec_relocs == NULL)
6645 rend = sec_relocs + o->reloc_count;
6646 for (r = sec_relocs; r < rend; r++)
6647 if (ELF_R_SYM (abfd, r->r_info) == r_symndx
6648 && ELF_R_TYPE (abfd, r->r_info) == R_MIPS16_26)
6651 if (elf_section_data (o)->relocs != sec_relocs)
6660 /* There is no non-call reloc for this stub, so we do
6661 not need it. Since this function is called before
6662 the linker maps input sections to output sections, we
6663 can easily discard it by setting the SEC_EXCLUDE
6665 sec->flags |= SEC_EXCLUDE;
6669 /* Record this stub in an array of local symbol call_stubs for
6671 if (elf_tdata (abfd)->local_call_stubs == NULL)
6673 unsigned long symcount;
6677 if (elf_bad_symtab (abfd))
6678 symcount = NUM_SHDR_ENTRIES (symtab_hdr);
6680 symcount = symtab_hdr->sh_info;
6681 amt = symcount * sizeof (asection *);
6682 n = bfd_zalloc (abfd, amt);
6685 elf_tdata (abfd)->local_call_stubs = n;
6688 sec->flags |= SEC_KEEP;
6689 elf_tdata (abfd)->local_call_stubs[r_symndx] = sec;
6691 /* We don't need to set mips16_stubs_seen in this case.
6692 That flag is used to see whether we need to look through
6693 the global symbol table for stubs. We don't need to set
6694 it here, because we just have a local stub. */
6698 h = ((struct mips_elf_link_hash_entry *)
6699 sym_hashes[r_symndx - extsymoff]);
6701 /* H is the symbol this stub is for. */
6703 if (CALL_FP_STUB_P (name))
6704 loc = &h->call_fp_stub;
6706 loc = &h->call_stub;
6708 /* If we already have an appropriate stub for this function, we
6709 don't need another one, so we can discard this one. Since
6710 this function is called before the linker maps input sections
6711 to output sections, we can easily discard it by setting the
6712 SEC_EXCLUDE flag. */
6715 sec->flags |= SEC_EXCLUDE;
6719 sec->flags |= SEC_KEEP;
6721 mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
6732 sgot = mips_elf_got_section (dynobj, FALSE);
6737 BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
6738 g = mips_elf_section_data (sgot)->u.got_info;
6739 BFD_ASSERT (g != NULL);
6744 bed = get_elf_backend_data (abfd);
6745 rel_end = relocs + sec->reloc_count * bed->s->int_rels_per_ext_rel;
6747 for (rel = relocs; rel < rel_end; ++rel)
6749 unsigned long r_symndx;
6750 unsigned int r_type;
6751 struct elf_link_hash_entry *h;
6753 r_symndx = ELF_R_SYM (abfd, rel->r_info);
6754 r_type = ELF_R_TYPE (abfd, rel->r_info);
6756 if (r_symndx < extsymoff)
6758 else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
6760 (*_bfd_error_handler)
6761 (_("%B: Malformed reloc detected for section %s"),
6763 bfd_set_error (bfd_error_bad_value);
6768 h = sym_hashes[r_symndx - extsymoff];
6770 /* This may be an indirect symbol created because of a version. */
6773 while (h->root.type == bfd_link_hash_indirect)
6774 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6778 /* Some relocs require a global offset table. */
6779 if (dynobj == NULL || sgot == NULL)
6785 case R_MIPS_CALL_HI16:
6786 case R_MIPS_CALL_LO16:
6787 case R_MIPS_GOT_HI16:
6788 case R_MIPS_GOT_LO16:
6789 case R_MIPS_GOT_PAGE:
6790 case R_MIPS_GOT_OFST:
6791 case R_MIPS_GOT_DISP:
6792 case R_MIPS_TLS_GOTTPREL:
6794 case R_MIPS_TLS_LDM:
6796 elf_hash_table (info)->dynobj = dynobj = abfd;
6797 if (! mips_elf_create_got_section (dynobj, info, FALSE))
6799 g = mips_elf_got_info (dynobj, &sgot);
6800 if (htab->is_vxworks && !info->shared)
6802 (*_bfd_error_handler)
6803 (_("%B: GOT reloc at 0x%lx not expected in executables"),
6804 abfd, (unsigned long) rel->r_offset);
6805 bfd_set_error (bfd_error_bad_value);
6813 /* In VxWorks executables, references to external symbols
6814 are handled using copy relocs or PLT stubs, so there's
6815 no need to add a dynamic relocation here. */
6817 && (info->shared || (h != NULL && !htab->is_vxworks))
6818 && (sec->flags & SEC_ALLOC) != 0)
6819 elf_hash_table (info)->dynobj = dynobj = abfd;
6829 ((struct mips_elf_link_hash_entry *) h)->is_relocation_target = TRUE;
6831 /* Relocations against the special VxWorks __GOTT_BASE__ and
6832 __GOTT_INDEX__ symbols must be left to the loader. Allocate
6833 room for them in .rela.dyn. */
6834 if (is_gott_symbol (info, h))
6838 sreloc = mips_elf_rel_dyn_section (info, TRUE);
6842 mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
6843 if (MIPS_ELF_READONLY_SECTION (sec))
6844 /* We tell the dynamic linker that there are
6845 relocations against the text segment. */
6846 info->flags |= DF_TEXTREL;
6849 else if (r_type == R_MIPS_CALL_LO16
6850 || r_type == R_MIPS_GOT_LO16
6851 || r_type == R_MIPS_GOT_DISP
6852 || (r_type == R_MIPS_GOT16 && htab->is_vxworks))
6854 /* We may need a local GOT entry for this relocation. We
6855 don't count R_MIPS_GOT_PAGE because we can estimate the
6856 maximum number of pages needed by looking at the size of
6857 the segment. Similar comments apply to R_MIPS_GOT16 and
6858 R_MIPS_CALL16, except on VxWorks, where GOT relocations
6859 always evaluate to "G". We don't count R_MIPS_GOT_HI16, or
6860 R_MIPS_CALL_HI16 because these are always followed by an
6861 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
6862 if (! mips_elf_record_local_got_symbol (abfd, r_symndx,
6863 rel->r_addend, g, 0))
6872 (*_bfd_error_handler)
6873 (_("%B: CALL16 reloc at 0x%lx not against global symbol"),
6874 abfd, (unsigned long) rel->r_offset);
6875 bfd_set_error (bfd_error_bad_value);
6880 case R_MIPS_CALL_HI16:
6881 case R_MIPS_CALL_LO16:
6884 /* VxWorks call relocations point the function's .got.plt
6885 entry, which will be allocated by adjust_dynamic_symbol.
6886 Otherwise, this symbol requires a global GOT entry. */
6887 if ((!htab->is_vxworks || h->forced_local)
6888 && !mips_elf_record_global_got_symbol (h, abfd, info, g, 0))
6891 /* We need a stub, not a plt entry for the undefined
6892 function. But we record it as if it needs plt. See
6893 _bfd_elf_adjust_dynamic_symbol. */
6899 case R_MIPS_GOT_PAGE:
6900 /* If this is a global, overridable symbol, GOT_PAGE will
6901 decay to GOT_DISP, so we'll need a GOT entry for it. */
6904 struct mips_elf_link_hash_entry *hmips =
6905 (struct mips_elf_link_hash_entry *) h;
6907 while (hmips->root.root.type == bfd_link_hash_indirect
6908 || hmips->root.root.type == bfd_link_hash_warning)
6909 hmips = (struct mips_elf_link_hash_entry *)
6910 hmips->root.root.u.i.link;
6912 if (hmips->root.def_regular
6913 && ! (info->shared && ! info->symbolic
6914 && ! hmips->root.forced_local))
6920 case R_MIPS_GOT_HI16:
6921 case R_MIPS_GOT_LO16:
6924 /* This relocation needs a page entry in the GOT. */
6925 if (mips_elf_rel_relocation_p (abfd, sec, relocs, rel))
6927 if (!mips_elf_get_section_contents (abfd, sec, &contents))
6929 howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, r_type, FALSE);
6930 addend = mips_elf_read_rel_addend (abfd, rel,
6932 if (r_type == R_MIPS_GOT16)
6933 mips_elf_add_lo16_rel_addend (abfd, rel, rel_end,
6936 addend <<= howto->rightshift;
6939 addend = rel->r_addend;
6940 if (!mips_elf_record_got_page_entry (abfd, r_symndx, addend, g))
6946 case R_MIPS_GOT_DISP:
6947 if (h && ! mips_elf_record_global_got_symbol (h, abfd, info, g, 0))
6951 case R_MIPS_TLS_GOTTPREL:
6953 info->flags |= DF_STATIC_TLS;
6956 case R_MIPS_TLS_LDM:
6957 if (r_type == R_MIPS_TLS_LDM)
6965 /* This symbol requires a global offset table entry, or two
6966 for TLS GD relocations. */
6968 unsigned char flag = (r_type == R_MIPS_TLS_GD
6970 : r_type == R_MIPS_TLS_LDM
6975 struct mips_elf_link_hash_entry *hmips =
6976 (struct mips_elf_link_hash_entry *) h;
6977 hmips->tls_type |= flag;
6979 if (h && ! mips_elf_record_global_got_symbol (h, abfd, info, g, flag))
6984 BFD_ASSERT (flag == GOT_TLS_LDM || r_symndx != 0);
6986 if (! mips_elf_record_local_got_symbol (abfd, r_symndx,
6987 rel->r_addend, g, flag))
6996 /* In VxWorks executables, references to external symbols
6997 are handled using copy relocs or PLT stubs, so there's
6998 no need to add a .rela.dyn entry for this relocation. */
6999 if ((info->shared || (h != NULL && !htab->is_vxworks))
7000 && (sec->flags & SEC_ALLOC) != 0)
7004 sreloc = mips_elf_rel_dyn_section (info, TRUE);
7010 /* When creating a shared object, we must copy these
7011 reloc types into the output file as R_MIPS_REL32
7012 relocs. Make room for this reloc in .rel(a).dyn. */
7013 mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
7014 if (MIPS_ELF_READONLY_SECTION (sec))
7015 /* We tell the dynamic linker that there are
7016 relocations against the text segment. */
7017 info->flags |= DF_TEXTREL;
7021 struct mips_elf_link_hash_entry *hmips;
7023 /* We only need to copy this reloc if the symbol is
7024 defined in a dynamic object. */
7025 hmips = (struct mips_elf_link_hash_entry *) h;
7026 ++hmips->possibly_dynamic_relocs;
7027 if (MIPS_ELF_READONLY_SECTION (sec))
7028 /* We need it to tell the dynamic linker if there
7029 are relocations against the text segment. */
7030 hmips->readonly_reloc = TRUE;
7033 /* Even though we don't directly need a GOT entry for
7034 this symbol, a symbol must have a dynamic symbol
7035 table index greater that DT_MIPS_GOTSYM if there are
7036 dynamic relocations against it. This does not apply
7037 to VxWorks, which does not have the usual coupling
7038 between global GOT entries and .dynsym entries. */
7039 if (h != NULL && !htab->is_vxworks)
7042 elf_hash_table (info)->dynobj = dynobj = abfd;
7043 if (! mips_elf_create_got_section (dynobj, info, TRUE))
7045 g = mips_elf_got_info (dynobj, &sgot);
7046 if (! mips_elf_record_global_got_symbol (h, abfd, info, g, 0))
7051 if (SGI_COMPAT (abfd))
7052 mips_elf_hash_table (info)->compact_rel_size +=
7053 sizeof (Elf32_External_crinfo);
7058 ((struct mips_elf_link_hash_entry *) h)->is_branch_target = TRUE;
7063 ((struct mips_elf_link_hash_entry *) h)->is_branch_target = TRUE;
7066 case R_MIPS_GPREL16:
7067 case R_MIPS_LITERAL:
7068 case R_MIPS_GPREL32:
7069 if (SGI_COMPAT (abfd))
7070 mips_elf_hash_table (info)->compact_rel_size +=
7071 sizeof (Elf32_External_crinfo);
7074 /* This relocation describes the C++ object vtable hierarchy.
7075 Reconstruct it for later use during GC. */
7076 case R_MIPS_GNU_VTINHERIT:
7077 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
7081 /* This relocation describes which C++ vtable entries are actually
7082 used. Record for later use during GC. */
7083 case R_MIPS_GNU_VTENTRY:
7084 BFD_ASSERT (h != NULL);
7086 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
7094 /* We must not create a stub for a symbol that has relocations
7095 related to taking the function's address. This doesn't apply to
7096 VxWorks, where CALL relocs refer to a .got.plt entry instead of
7097 a normal .got entry. */
7098 if (!htab->is_vxworks && h != NULL)
7102 ((struct mips_elf_link_hash_entry *) h)->no_fn_stub = TRUE;
7105 case R_MIPS_CALL_HI16:
7106 case R_MIPS_CALL_LO16:
7111 /* If this reloc is not a 16 bit call, and it has a global
7112 symbol, then we will need the fn_stub if there is one.
7113 References from a stub section do not count. */
7115 && r_type != R_MIPS16_26
7116 && !mips16_stub_section_p (abfd, sec))
7118 struct mips_elf_link_hash_entry *mh;
7120 mh = (struct mips_elf_link_hash_entry *) h;
7121 mh->need_fn_stub = TRUE;
7129 _bfd_mips_relax_section (bfd *abfd, asection *sec,
7130 struct bfd_link_info *link_info,
7133 Elf_Internal_Rela *internal_relocs;
7134 Elf_Internal_Rela *irel, *irelend;
7135 Elf_Internal_Shdr *symtab_hdr;
7136 bfd_byte *contents = NULL;
7138 bfd_boolean changed_contents = FALSE;
7139 bfd_vma sec_start = sec->output_section->vma + sec->output_offset;
7140 Elf_Internal_Sym *isymbuf = NULL;
7142 /* We are not currently changing any sizes, so only one pass. */
7145 if (link_info->relocatable)
7148 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
7149 link_info->keep_memory);
7150 if (internal_relocs == NULL)
7153 irelend = internal_relocs + sec->reloc_count
7154 * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel;
7155 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7156 extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
7158 for (irel = internal_relocs; irel < irelend; irel++)
7161 bfd_signed_vma sym_offset;
7162 unsigned int r_type;
7163 unsigned long r_symndx;
7165 unsigned long instruction;
7167 /* Turn jalr into bgezal, and jr into beq, if they're marked
7168 with a JALR relocation, that indicate where they jump to.
7169 This saves some pipeline bubbles. */
7170 r_type = ELF_R_TYPE (abfd, irel->r_info);
7171 if (r_type != R_MIPS_JALR)
7174 r_symndx = ELF_R_SYM (abfd, irel->r_info);
7175 /* Compute the address of the jump target. */
7176 if (r_symndx >= extsymoff)
7178 struct mips_elf_link_hash_entry *h
7179 = ((struct mips_elf_link_hash_entry *)
7180 elf_sym_hashes (abfd) [r_symndx - extsymoff]);
7182 while (h->root.root.type == bfd_link_hash_indirect
7183 || h->root.root.type == bfd_link_hash_warning)
7184 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
7186 /* If a symbol is undefined, or if it may be overridden,
7188 if (! ((h->root.root.type == bfd_link_hash_defined
7189 || h->root.root.type == bfd_link_hash_defweak)
7190 && h->root.root.u.def.section)
7191 || (link_info->shared && ! link_info->symbolic
7192 && !h->root.forced_local))
7195 sym_sec = h->root.root.u.def.section;
7196 if (sym_sec->output_section)
7197 symval = (h->root.root.u.def.value
7198 + sym_sec->output_section->vma
7199 + sym_sec->output_offset);
7201 symval = h->root.root.u.def.value;
7205 Elf_Internal_Sym *isym;
7207 /* Read this BFD's symbols if we haven't done so already. */
7208 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
7210 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
7211 if (isymbuf == NULL)
7212 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
7213 symtab_hdr->sh_info, 0,
7215 if (isymbuf == NULL)
7219 isym = isymbuf + r_symndx;
7220 if (isym->st_shndx == SHN_UNDEF)
7222 else if (isym->st_shndx == SHN_ABS)
7223 sym_sec = bfd_abs_section_ptr;
7224 else if (isym->st_shndx == SHN_COMMON)
7225 sym_sec = bfd_com_section_ptr;
7228 = bfd_section_from_elf_index (abfd, isym->st_shndx);
7229 symval = isym->st_value
7230 + sym_sec->output_section->vma
7231 + sym_sec->output_offset;
7234 /* Compute branch offset, from delay slot of the jump to the
7236 sym_offset = (symval + irel->r_addend)
7237 - (sec_start + irel->r_offset + 4);
7239 /* Branch offset must be properly aligned. */
7240 if ((sym_offset & 3) != 0)
7245 /* Check that it's in range. */
7246 if (sym_offset < -0x8000 || sym_offset >= 0x8000)
7249 /* Get the section contents if we haven't done so already. */
7250 if (!mips_elf_get_section_contents (abfd, sec, &contents))
7253 instruction = bfd_get_32 (abfd, contents + irel->r_offset);
7255 /* If it was jalr <reg>, turn it into bgezal $zero, <target>. */
7256 if ((instruction & 0xfc1fffff) == 0x0000f809)
7257 instruction = 0x04110000;
7258 /* If it was jr <reg>, turn it into b <target>. */
7259 else if ((instruction & 0xfc1fffff) == 0x00000008)
7260 instruction = 0x10000000;
7264 instruction |= (sym_offset & 0xffff);
7265 bfd_put_32 (abfd, instruction, contents + irel->r_offset);
7266 changed_contents = TRUE;
7269 if (contents != NULL
7270 && elf_section_data (sec)->this_hdr.contents != contents)
7272 if (!changed_contents && !link_info->keep_memory)
7276 /* Cache the section contents for elf_link_input_bfd. */
7277 elf_section_data (sec)->this_hdr.contents = contents;
7283 if (contents != NULL
7284 && elf_section_data (sec)->this_hdr.contents != contents)
7289 /* Adjust a symbol defined by a dynamic object and referenced by a
7290 regular object. The current definition is in some section of the
7291 dynamic object, but we're not including those sections. We have to
7292 change the definition to something the rest of the link can
7296 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7297 struct elf_link_hash_entry *h)
7300 struct mips_elf_link_hash_entry *hmips;
7302 struct mips_elf_link_hash_table *htab;
7304 htab = mips_elf_hash_table (info);
7305 dynobj = elf_hash_table (info)->dynobj;
7307 /* Make sure we know what is going on here. */
7308 BFD_ASSERT (dynobj != NULL
7310 || h->u.weakdef != NULL
7313 && !h->def_regular)));
7315 /* If this symbol is defined in a dynamic object, we need to copy
7316 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
7318 hmips = (struct mips_elf_link_hash_entry *) h;
7319 if (! info->relocatable
7320 && hmips->possibly_dynamic_relocs != 0
7321 && (h->root.type == bfd_link_hash_defweak
7322 || !h->def_regular))
7324 mips_elf_allocate_dynamic_relocations
7325 (dynobj, info, hmips->possibly_dynamic_relocs);
7326 if (hmips->readonly_reloc)
7327 /* We tell the dynamic linker that there are relocations
7328 against the text segment. */
7329 info->flags |= DF_TEXTREL;
7332 /* For a function, create a stub, if allowed. */
7333 if (! hmips->no_fn_stub
7336 if (! elf_hash_table (info)->dynamic_sections_created)
7339 /* If this symbol is not defined in a regular file, then set
7340 the symbol to the stub location. This is required to make
7341 function pointers compare as equal between the normal
7342 executable and the shared library. */
7343 if (!h->def_regular)
7345 /* We need .stub section. */
7346 s = bfd_get_section_by_name (dynobj,
7347 MIPS_ELF_STUB_SECTION_NAME (dynobj));
7348 BFD_ASSERT (s != NULL);
7350 h->root.u.def.section = s;
7351 h->root.u.def.value = s->size;
7353 /* XXX Write this stub address somewhere. */
7354 h->plt.offset = s->size;
7356 /* Make room for this stub code. */
7357 s->size += htab->function_stub_size;
7359 /* The last half word of the stub will be filled with the index
7360 of this symbol in .dynsym section. */
7364 else if ((h->type == STT_FUNC)
7367 /* This will set the entry for this symbol in the GOT to 0, and
7368 the dynamic linker will take care of this. */
7369 h->root.u.def.value = 0;
7373 /* If this is a weak symbol, and there is a real definition, the
7374 processor independent code will have arranged for us to see the
7375 real definition first, and we can just use the same value. */
7376 if (h->u.weakdef != NULL)
7378 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7379 || h->u.weakdef->root.type == bfd_link_hash_defweak);
7380 h->root.u.def.section = h->u.weakdef->root.u.def.section;
7381 h->root.u.def.value = h->u.weakdef->root.u.def.value;
7385 /* This is a reference to a symbol defined by a dynamic object which
7386 is not a function. */
7391 /* Likewise, for VxWorks. */
7394 _bfd_mips_vxworks_adjust_dynamic_symbol (struct bfd_link_info *info,
7395 struct elf_link_hash_entry *h)
7398 struct mips_elf_link_hash_entry *hmips;
7399 struct mips_elf_link_hash_table *htab;
7401 htab = mips_elf_hash_table (info);
7402 dynobj = elf_hash_table (info)->dynobj;
7403 hmips = (struct mips_elf_link_hash_entry *) h;
7405 /* Make sure we know what is going on here. */
7406 BFD_ASSERT (dynobj != NULL
7409 || h->u.weakdef != NULL
7412 && !h->def_regular)));
7414 /* If the symbol is defined by a dynamic object, we need a PLT stub if
7415 either (a) we want to branch to the symbol or (b) we're linking an
7416 executable that needs a canonical function address. In the latter
7417 case, the canonical address will be the address of the executable's
7419 if ((hmips->is_branch_target
7421 && h->type == STT_FUNC
7422 && hmips->is_relocation_target))
7426 && !h->forced_local)
7429 /* Locally-binding symbols do not need a PLT stub; we can refer to
7430 the functions directly. */
7431 else if (h->needs_plt
7432 && (SYMBOL_CALLS_LOCAL (info, h)
7433 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7434 && h->root.type == bfd_link_hash_undefweak)))
7442 /* If this is the first symbol to need a PLT entry, allocate room
7443 for the header, and for the header's .rela.plt.unloaded entries. */
7444 if (htab->splt->size == 0)
7446 htab->splt->size += htab->plt_header_size;
7448 htab->srelplt2->size += 2 * sizeof (Elf32_External_Rela);
7451 /* Assign the next .plt entry to this symbol. */
7452 h->plt.offset = htab->splt->size;
7453 htab->splt->size += htab->plt_entry_size;
7455 /* If the output file has no definition of the symbol, set the
7456 symbol's value to the address of the stub. For executables,
7457 point at the PLT load stub rather than the lazy resolution stub;
7458 this stub will become the canonical function address. */
7459 if (!h->def_regular)
7461 h->root.u.def.section = htab->splt;
7462 h->root.u.def.value = h->plt.offset;
7464 h->root.u.def.value += 8;
7467 /* Make room for the .got.plt entry and the R_JUMP_SLOT relocation. */
7468 htab->sgotplt->size += 4;
7469 htab->srelplt->size += sizeof (Elf32_External_Rela);
7471 /* Make room for the .rela.plt.unloaded relocations. */
7473 htab->srelplt2->size += 3 * sizeof (Elf32_External_Rela);
7478 /* If a function symbol is defined by a dynamic object, and we do not
7479 need a PLT stub for it, the symbol's value should be zero. */
7480 if (h->type == STT_FUNC
7485 h->root.u.def.value = 0;
7489 /* If this is a weak symbol, and there is a real definition, the
7490 processor independent code will have arranged for us to see the
7491 real definition first, and we can just use the same value. */
7492 if (h->u.weakdef != NULL)
7494 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7495 || h->u.weakdef->root.type == bfd_link_hash_defweak);
7496 h->root.u.def.section = h->u.weakdef->root.u.def.section;
7497 h->root.u.def.value = h->u.weakdef->root.u.def.value;
7501 /* This is a reference to a symbol defined by a dynamic object which
7502 is not a function. */
7506 /* We must allocate the symbol in our .dynbss section, which will
7507 become part of the .bss section of the executable. There will be
7508 an entry for this symbol in the .dynsym section. The dynamic
7509 object will contain position independent code, so all references
7510 from the dynamic object to this symbol will go through the global
7511 offset table. The dynamic linker will use the .dynsym entry to
7512 determine the address it must put in the global offset table, so
7513 both the dynamic object and the regular object will refer to the
7514 same memory location for the variable. */
7516 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
7518 htab->srelbss->size += sizeof (Elf32_External_Rela);
7522 return _bfd_elf_adjust_dynamic_copy (h, htab->sdynbss);
7525 /* Return the number of dynamic section symbols required by OUTPUT_BFD.
7526 The number might be exact or a worst-case estimate, depending on how
7527 much information is available to elf_backend_omit_section_dynsym at
7528 the current linking stage. */
7530 static bfd_size_type
7531 count_section_dynsyms (bfd *output_bfd, struct bfd_link_info *info)
7533 bfd_size_type count;
7536 if (info->shared || elf_hash_table (info)->is_relocatable_executable)
7539 const struct elf_backend_data *bed;
7541 bed = get_elf_backend_data (output_bfd);
7542 for (p = output_bfd->sections; p ; p = p->next)
7543 if ((p->flags & SEC_EXCLUDE) == 0
7544 && (p->flags & SEC_ALLOC) != 0
7545 && !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p))
7551 /* This function is called after all the input files have been read,
7552 and the input sections have been assigned to output sections. We
7553 check for any mips16 stub sections that we can discard. */
7556 _bfd_mips_elf_always_size_sections (bfd *output_bfd,
7557 struct bfd_link_info *info)
7563 struct mips_got_info *g;
7565 bfd_size_type loadable_size = 0;
7566 bfd_size_type page_gotno;
7567 bfd_size_type dynsymcount;
7569 struct mips_elf_count_tls_arg count_tls_arg;
7570 struct mips_elf_link_hash_table *htab;
7572 htab = mips_elf_hash_table (info);
7574 /* The .reginfo section has a fixed size. */
7575 ri = bfd_get_section_by_name (output_bfd, ".reginfo");
7577 bfd_set_section_size (output_bfd, ri, sizeof (Elf32_External_RegInfo));
7579 if (! (info->relocatable
7580 || ! mips_elf_hash_table (info)->mips16_stubs_seen))
7581 mips_elf_link_hash_traverse (mips_elf_hash_table (info),
7582 mips_elf_check_mips16_stubs, NULL);
7584 dynobj = elf_hash_table (info)->dynobj;
7586 /* Relocatable links don't have it. */
7589 g = mips_elf_got_info (dynobj, &s);
7593 /* Calculate the total loadable size of the output. That
7594 will give us the maximum number of GOT_PAGE entries
7596 for (sub = info->input_bfds; sub; sub = sub->link_next)
7598 asection *subsection;
7600 for (subsection = sub->sections;
7602 subsection = subsection->next)
7604 if ((subsection->flags & SEC_ALLOC) == 0)
7606 loadable_size += ((subsection->size + 0xf)
7607 &~ (bfd_size_type) 0xf);
7611 /* There has to be a global GOT entry for every symbol with
7612 a dynamic symbol table index of DT_MIPS_GOTSYM or
7613 higher. Therefore, it make sense to put those symbols
7614 that need GOT entries at the end of the symbol table. We
7616 if (! mips_elf_sort_hash_table (info, 1))
7619 if (g->global_gotsym != NULL)
7620 i = elf_hash_table (info)->dynsymcount - g->global_gotsym->dynindx;
7622 /* If there are no global symbols, or none requiring
7623 relocations, then GLOBAL_GOTSYM will be NULL. */
7626 /* Get a worst-case estimate of the number of dynamic symbols needed.
7627 At this point, dynsymcount does not account for section symbols
7628 and count_section_dynsyms may overestimate the number that will
7630 dynsymcount = (elf_hash_table (info)->dynsymcount
7631 + count_section_dynsyms (output_bfd, info));
7633 /* Determine the size of one stub entry. */
7634 htab->function_stub_size = (dynsymcount > 0x10000
7635 ? MIPS_FUNCTION_STUB_BIG_SIZE
7636 : MIPS_FUNCTION_STUB_NORMAL_SIZE);
7638 /* In the worst case, we'll get one stub per dynamic symbol, plus
7639 one to account for the dummy entry at the end required by IRIX
7641 loadable_size += htab->function_stub_size * (i + 1);
7643 if (htab->is_vxworks)
7644 /* There's no need to allocate page entries for VxWorks; R_MIPS_GOT16
7645 relocations against local symbols evaluate to "G", and the EABI does
7646 not include R_MIPS_GOT_PAGE. */
7649 /* Assume there are two loadable segments consisting of contiguous
7650 sections. Is 5 enough? */
7651 page_gotno = (loadable_size >> 16) + 5;
7653 /* Choose the smaller of the two estimates; both are intended to be
7655 if (page_gotno > g->page_gotno)
7656 page_gotno = g->page_gotno;
7658 g->local_gotno += page_gotno;
7659 s->size += g->local_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
7661 g->global_gotno = i;
7662 s->size += i * MIPS_ELF_GOT_SIZE (output_bfd);
7664 /* We need to calculate tls_gotno for global symbols at this point
7665 instead of building it up earlier, to avoid doublecounting
7666 entries for one global symbol from multiple input files. */
7667 count_tls_arg.info = info;
7668 count_tls_arg.needed = 0;
7669 elf_link_hash_traverse (elf_hash_table (info),
7670 mips_elf_count_global_tls_entries,
7672 g->tls_gotno += count_tls_arg.needed;
7673 s->size += g->tls_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
7675 mips_elf_resolve_final_got_entries (g);
7677 /* VxWorks does not support multiple GOTs. It initializes $gp to
7678 __GOTT_BASE__[__GOTT_INDEX__], the value of which is set by the
7680 if (!htab->is_vxworks && s->size > MIPS_ELF_GOT_MAX_SIZE (info))
7682 if (! mips_elf_multi_got (output_bfd, info, g, s, page_gotno))
7687 /* Set up TLS entries for the first GOT. */
7688 g->tls_assigned_gotno = g->global_gotno + g->local_gotno;
7689 htab_traverse (g->got_entries, mips_elf_initialize_tls_index, g);
7691 htab->computed_got_sizes = TRUE;
7696 /* Set the sizes of the dynamic sections. */
7699 _bfd_mips_elf_size_dynamic_sections (bfd *output_bfd,
7700 struct bfd_link_info *info)
7703 asection *s, *sreldyn;
7704 bfd_boolean reltext;
7705 struct mips_elf_link_hash_table *htab;
7707 htab = mips_elf_hash_table (info);
7708 dynobj = elf_hash_table (info)->dynobj;
7709 BFD_ASSERT (dynobj != NULL);
7711 if (elf_hash_table (info)->dynamic_sections_created)
7713 /* Set the contents of the .interp section to the interpreter. */
7714 if (info->executable)
7716 s = bfd_get_section_by_name (dynobj, ".interp");
7717 BFD_ASSERT (s != NULL);
7719 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd)) + 1;
7721 = (bfd_byte *) ELF_DYNAMIC_INTERPRETER (output_bfd);
7725 /* The check_relocs and adjust_dynamic_symbol entry points have
7726 determined the sizes of the various dynamic sections. Allocate
7730 for (s = dynobj->sections; s != NULL; s = s->next)
7734 /* It's OK to base decisions on the section name, because none
7735 of the dynobj section names depend upon the input files. */
7736 name = bfd_get_section_name (dynobj, s);
7738 if ((s->flags & SEC_LINKER_CREATED) == 0)
7741 if (CONST_STRNEQ (name, ".rel"))
7745 const char *outname;
7748 /* If this relocation section applies to a read only
7749 section, then we probably need a DT_TEXTREL entry.
7750 If the relocation section is .rel(a).dyn, we always
7751 assert a DT_TEXTREL entry rather than testing whether
7752 there exists a relocation to a read only section or
7754 outname = bfd_get_section_name (output_bfd,
7756 target = bfd_get_section_by_name (output_bfd, outname + 4);
7758 && (target->flags & SEC_READONLY) != 0
7759 && (target->flags & SEC_ALLOC) != 0)
7760 || strcmp (outname, MIPS_ELF_REL_DYN_NAME (info)) == 0)
7763 /* We use the reloc_count field as a counter if we need
7764 to copy relocs into the output file. */
7765 if (strcmp (name, MIPS_ELF_REL_DYN_NAME (info)) != 0)
7768 /* If combreloc is enabled, elf_link_sort_relocs() will
7769 sort relocations, but in a different way than we do,
7770 and before we're done creating relocations. Also, it
7771 will move them around between input sections'
7772 relocation's contents, so our sorting would be
7773 broken, so don't let it run. */
7774 info->combreloc = 0;
7777 else if (htab->is_vxworks && strcmp (name, ".got") == 0)
7779 /* Executables do not need a GOT. */
7782 /* Allocate relocations for all but the reserved entries. */
7783 struct mips_got_info *g;
7786 g = mips_elf_got_info (dynobj, NULL);
7787 count = (g->global_gotno
7789 - MIPS_RESERVED_GOTNO (info));
7790 mips_elf_allocate_dynamic_relocations (dynobj, info, count);
7793 else if (!htab->is_vxworks && CONST_STRNEQ (name, ".got"))
7795 /* _bfd_mips_elf_always_size_sections() has already done
7796 most of the work, but some symbols may have been mapped
7797 to versions that we must now resolve in the got_entries
7799 struct mips_got_info *gg = mips_elf_got_info (dynobj, NULL);
7800 struct mips_got_info *g = gg;
7801 struct mips_elf_set_global_got_offset_arg set_got_offset_arg;
7802 unsigned int needed_relocs = 0;
7806 set_got_offset_arg.value = MIPS_ELF_GOT_SIZE (output_bfd);
7807 set_got_offset_arg.info = info;
7809 /* NOTE 2005-02-03: How can this call, or the next, ever
7810 find any indirect entries to resolve? They were all
7811 resolved in mips_elf_multi_got. */
7812 mips_elf_resolve_final_got_entries (gg);
7813 for (g = gg->next; g && g->next != gg; g = g->next)
7815 unsigned int save_assign;
7817 mips_elf_resolve_final_got_entries (g);
7819 /* Assign offsets to global GOT entries. */
7820 save_assign = g->assigned_gotno;
7821 g->assigned_gotno = g->local_gotno;
7822 set_got_offset_arg.g = g;
7823 set_got_offset_arg.needed_relocs = 0;
7824 htab_traverse (g->got_entries,
7825 mips_elf_set_global_got_offset,
7826 &set_got_offset_arg);
7827 needed_relocs += set_got_offset_arg.needed_relocs;
7828 BFD_ASSERT (g->assigned_gotno - g->local_gotno
7829 <= g->global_gotno);
7831 g->assigned_gotno = save_assign;
7834 needed_relocs += g->local_gotno - g->assigned_gotno;
7835 BFD_ASSERT (g->assigned_gotno == g->next->local_gotno
7836 + g->next->global_gotno
7837 + g->next->tls_gotno
7838 + MIPS_RESERVED_GOTNO (info));
7844 struct mips_elf_count_tls_arg arg;
7848 htab_traverse (gg->got_entries, mips_elf_count_local_tls_relocs,
7850 elf_link_hash_traverse (elf_hash_table (info),
7851 mips_elf_count_global_tls_relocs,
7854 needed_relocs += arg.needed;
7858 mips_elf_allocate_dynamic_relocations (dynobj, info,
7861 else if (strcmp (name, MIPS_ELF_STUB_SECTION_NAME (output_bfd)) == 0)
7863 /* IRIX rld assumes that the function stub isn't at the end
7864 of .text section. So put a dummy. XXX */
7865 s->size += htab->function_stub_size;
7867 else if (! info->shared
7868 && ! mips_elf_hash_table (info)->use_rld_obj_head
7869 && CONST_STRNEQ (name, ".rld_map"))
7871 /* We add a room for __rld_map. It will be filled in by the
7872 rtld to contain a pointer to the _r_debug structure. */
7875 else if (SGI_COMPAT (output_bfd)
7876 && CONST_STRNEQ (name, ".compact_rel"))
7877 s->size += mips_elf_hash_table (info)->compact_rel_size;
7878 else if (! CONST_STRNEQ (name, ".init")
7879 && s != htab->sgotplt
7882 /* It's not one of our sections, so don't allocate space. */
7888 s->flags |= SEC_EXCLUDE;
7892 if ((s->flags & SEC_HAS_CONTENTS) == 0)
7895 /* Allocate memory for this section last, since we may increase its
7897 if (strcmp (name, MIPS_ELF_REL_DYN_NAME (info)) == 0)
7903 /* Allocate memory for the section contents. */
7904 s->contents = bfd_zalloc (dynobj, s->size);
7905 if (s->contents == NULL)
7907 bfd_set_error (bfd_error_no_memory);
7912 /* Allocate memory for the .rel(a).dyn section. */
7913 if (sreldyn != NULL)
7915 sreldyn->contents = bfd_zalloc (dynobj, sreldyn->size);
7916 if (sreldyn->contents == NULL)
7918 bfd_set_error (bfd_error_no_memory);
7923 if (elf_hash_table (info)->dynamic_sections_created)
7925 /* Add some entries to the .dynamic section. We fill in the
7926 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
7927 must add the entries now so that we get the correct size for
7928 the .dynamic section. */
7930 /* SGI object has the equivalence of DT_DEBUG in the
7931 DT_MIPS_RLD_MAP entry. This must come first because glibc
7932 only fills in DT_MIPS_RLD_MAP (not DT_DEBUG) and GDB only
7933 looks at the first one it sees. */
7935 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP, 0))
7938 /* The DT_DEBUG entry may be filled in by the dynamic linker and
7939 used by the debugger. */
7940 if (info->executable
7941 && !SGI_COMPAT (output_bfd)
7942 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
7945 if (reltext && (SGI_COMPAT (output_bfd) || htab->is_vxworks))
7946 info->flags |= DF_TEXTREL;
7948 if ((info->flags & DF_TEXTREL) != 0)
7950 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0))
7953 /* Clear the DF_TEXTREL flag. It will be set again if we
7954 write out an actual text relocation; we may not, because
7955 at this point we do not know whether e.g. any .eh_frame
7956 absolute relocations have been converted to PC-relative. */
7957 info->flags &= ~DF_TEXTREL;
7960 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0))
7963 if (htab->is_vxworks)
7965 /* VxWorks uses .rela.dyn instead of .rel.dyn. It does not
7966 use any of the DT_MIPS_* tags. */
7967 if (mips_elf_rel_dyn_section (info, FALSE))
7969 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELA, 0))
7972 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELASZ, 0))
7975 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELAENT, 0))
7978 if (htab->splt->size > 0)
7980 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTREL, 0))
7983 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_JMPREL, 0))
7986 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTRELSZ, 0))
7992 if (mips_elf_rel_dyn_section (info, FALSE))
7994 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0))
7997 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0))
8000 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0))
8004 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_VERSION, 0))
8007 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_FLAGS, 0))
8010 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_BASE_ADDRESS, 0))
8013 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LOCAL_GOTNO, 0))
8016 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_SYMTABNO, 0))
8019 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_UNREFEXTNO, 0))
8022 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_GOTSYM, 0))
8025 if (IRIX_COMPAT (dynobj) == ict_irix5
8026 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_HIPAGENO, 0))
8029 if (IRIX_COMPAT (dynobj) == ict_irix6
8030 && (bfd_get_section_by_name
8031 (dynobj, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj)))
8032 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_OPTIONS, 0))
8035 if (htab->is_vxworks
8036 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
8043 /* REL is a relocation in INPUT_BFD that is being copied to OUTPUT_BFD.
8044 Adjust its R_ADDEND field so that it is correct for the output file.
8045 LOCAL_SYMS and LOCAL_SECTIONS are arrays of INPUT_BFD's local symbols
8046 and sections respectively; both use symbol indexes. */
8049 mips_elf_adjust_addend (bfd *output_bfd, struct bfd_link_info *info,
8050 bfd *input_bfd, Elf_Internal_Sym *local_syms,
8051 asection **local_sections, Elf_Internal_Rela *rel)
8053 unsigned int r_type, r_symndx;
8054 Elf_Internal_Sym *sym;
8057 if (mips_elf_local_relocation_p (input_bfd, rel, local_sections, FALSE))
8059 r_type = ELF_R_TYPE (output_bfd, rel->r_info);
8060 if (r_type == R_MIPS16_GPREL
8061 || r_type == R_MIPS_GPREL16
8062 || r_type == R_MIPS_GPREL32
8063 || r_type == R_MIPS_LITERAL)
8065 rel->r_addend += _bfd_get_gp_value (input_bfd);
8066 rel->r_addend -= _bfd_get_gp_value (output_bfd);
8069 r_symndx = ELF_R_SYM (output_bfd, rel->r_info);
8070 sym = local_syms + r_symndx;
8072 /* Adjust REL's addend to account for section merging. */
8073 if (!info->relocatable)
8075 sec = local_sections[r_symndx];
8076 _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
8079 /* This would normally be done by the rela_normal code in elflink.c. */
8080 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
8081 rel->r_addend += local_sections[r_symndx]->output_offset;
8085 /* Relocate a MIPS ELF section. */
8088 _bfd_mips_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
8089 bfd *input_bfd, asection *input_section,
8090 bfd_byte *contents, Elf_Internal_Rela *relocs,
8091 Elf_Internal_Sym *local_syms,
8092 asection **local_sections)
8094 Elf_Internal_Rela *rel;
8095 const Elf_Internal_Rela *relend;
8097 bfd_boolean use_saved_addend_p = FALSE;
8098 const struct elf_backend_data *bed;
8100 bed = get_elf_backend_data (output_bfd);
8101 relend = relocs + input_section->reloc_count * bed->s->int_rels_per_ext_rel;
8102 for (rel = relocs; rel < relend; ++rel)
8106 reloc_howto_type *howto;
8107 bfd_boolean require_jalx;
8108 /* TRUE if the relocation is a RELA relocation, rather than a
8110 bfd_boolean rela_relocation_p = TRUE;
8111 unsigned int r_type = ELF_R_TYPE (output_bfd, rel->r_info);
8113 unsigned long r_symndx;
8115 Elf_Internal_Shdr *symtab_hdr;
8116 struct elf_link_hash_entry *h;
8118 /* Find the relocation howto for this relocation. */
8119 howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type,
8120 NEWABI_P (input_bfd)
8121 && (MIPS_RELOC_RELA_P
8122 (input_bfd, input_section,
8125 r_symndx = ELF_R_SYM (input_bfd, rel->r_info);
8126 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
8127 if (mips_elf_local_relocation_p (input_bfd, rel, local_sections, FALSE))
8129 sec = local_sections[r_symndx];
8134 unsigned long extsymoff;
8137 if (!elf_bad_symtab (input_bfd))
8138 extsymoff = symtab_hdr->sh_info;
8139 h = elf_sym_hashes (input_bfd) [r_symndx - extsymoff];
8140 while (h->root.type == bfd_link_hash_indirect
8141 || h->root.type == bfd_link_hash_warning)
8142 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8145 if (h->root.type == bfd_link_hash_defined
8146 || h->root.type == bfd_link_hash_defweak)
8147 sec = h->root.u.def.section;
8150 if (sec != NULL && elf_discarded_section (sec))
8152 /* For relocs against symbols from removed linkonce sections,
8153 or sections discarded by a linker script, we just want the
8154 section contents zeroed. Avoid any special processing. */
8155 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
8161 if (r_type == R_MIPS_64 && ! NEWABI_P (input_bfd))
8163 /* Some 32-bit code uses R_MIPS_64. In particular, people use
8164 64-bit code, but make sure all their addresses are in the
8165 lowermost or uppermost 32-bit section of the 64-bit address
8166 space. Thus, when they use an R_MIPS_64 they mean what is
8167 usually meant by R_MIPS_32, with the exception that the
8168 stored value is sign-extended to 64 bits. */
8169 howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, R_MIPS_32, FALSE);
8171 /* On big-endian systems, we need to lie about the position
8173 if (bfd_big_endian (input_bfd))
8177 if (!use_saved_addend_p)
8179 /* If these relocations were originally of the REL variety,
8180 we must pull the addend out of the field that will be
8181 relocated. Otherwise, we simply use the contents of the
8183 if (mips_elf_rel_relocation_p (input_bfd, input_section,
8186 rela_relocation_p = FALSE;
8187 addend = mips_elf_read_rel_addend (input_bfd, rel,
8189 if (r_type == R_MIPS_HI16
8190 || r_type == R_MIPS16_HI16
8191 || (r_type == R_MIPS_GOT16
8192 && mips_elf_local_relocation_p (input_bfd, rel,
8193 local_sections, FALSE)))
8195 if (!mips_elf_add_lo16_rel_addend (input_bfd, rel, relend,
8201 name = h->root.root.string;
8203 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
8204 local_syms + r_symndx,
8206 (*_bfd_error_handler)
8207 (_("%B: Can't find matching LO16 reloc against `%s' for %s at 0x%lx in section `%A'"),
8208 input_bfd, input_section, name, howto->name,
8213 addend <<= howto->rightshift;
8216 addend = rel->r_addend;
8217 mips_elf_adjust_addend (output_bfd, info, input_bfd,
8218 local_syms, local_sections, rel);
8221 if (info->relocatable)
8223 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd)
8224 && bfd_big_endian (input_bfd))
8227 if (!rela_relocation_p && rel->r_addend)
8229 addend += rel->r_addend;
8230 if (r_type == R_MIPS_HI16
8231 || r_type == R_MIPS_GOT16)
8232 addend = mips_elf_high (addend);
8233 else if (r_type == R_MIPS_HIGHER)
8234 addend = mips_elf_higher (addend);
8235 else if (r_type == R_MIPS_HIGHEST)
8236 addend = mips_elf_highest (addend);
8238 addend >>= howto->rightshift;
8240 /* We use the source mask, rather than the destination
8241 mask because the place to which we are writing will be
8242 source of the addend in the final link. */
8243 addend &= howto->src_mask;
8245 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
8246 /* See the comment above about using R_MIPS_64 in the 32-bit
8247 ABI. Here, we need to update the addend. It would be
8248 possible to get away with just using the R_MIPS_32 reloc
8249 but for endianness. */
8255 if (addend & ((bfd_vma) 1 << 31))
8257 sign_bits = ((bfd_vma) 1 << 32) - 1;
8264 /* If we don't know that we have a 64-bit type,
8265 do two separate stores. */
8266 if (bfd_big_endian (input_bfd))
8268 /* Store the sign-bits (which are most significant)
8270 low_bits = sign_bits;
8276 high_bits = sign_bits;
8278 bfd_put_32 (input_bfd, low_bits,
8279 contents + rel->r_offset);
8280 bfd_put_32 (input_bfd, high_bits,
8281 contents + rel->r_offset + 4);
8285 if (! mips_elf_perform_relocation (info, howto, rel, addend,
8286 input_bfd, input_section,
8291 /* Go on to the next relocation. */
8295 /* In the N32 and 64-bit ABIs there may be multiple consecutive
8296 relocations for the same offset. In that case we are
8297 supposed to treat the output of each relocation as the addend
8299 if (rel + 1 < relend
8300 && rel->r_offset == rel[1].r_offset
8301 && ELF_R_TYPE (input_bfd, rel[1].r_info) != R_MIPS_NONE)
8302 use_saved_addend_p = TRUE;
8304 use_saved_addend_p = FALSE;
8306 /* Figure out what value we are supposed to relocate. */
8307 switch (mips_elf_calculate_relocation (output_bfd, input_bfd,
8308 input_section, info, rel,
8309 addend, howto, local_syms,
8310 local_sections, &value,
8311 &name, &require_jalx,
8312 use_saved_addend_p))
8314 case bfd_reloc_continue:
8315 /* There's nothing to do. */
8318 case bfd_reloc_undefined:
8319 /* mips_elf_calculate_relocation already called the
8320 undefined_symbol callback. There's no real point in
8321 trying to perform the relocation at this point, so we
8322 just skip ahead to the next relocation. */
8325 case bfd_reloc_notsupported:
8326 msg = _("internal error: unsupported relocation error");
8327 info->callbacks->warning
8328 (info, msg, name, input_bfd, input_section, rel->r_offset);
8331 case bfd_reloc_overflow:
8332 if (use_saved_addend_p)
8333 /* Ignore overflow until we reach the last relocation for
8334 a given location. */
8338 struct mips_elf_link_hash_table *htab;
8340 htab = mips_elf_hash_table (info);
8341 BFD_ASSERT (name != NULL);
8342 if (!htab->small_data_overflow_reported
8343 && (howto->type == R_MIPS_GPREL16
8344 || howto->type == R_MIPS_LITERAL))
8347 _("small-data section exceeds 64KB;"
8348 " lower small-data size limit (see option -G)");
8350 htab->small_data_overflow_reported = TRUE;
8351 (*info->callbacks->einfo) ("%P: %s\n", msg);
8353 if (! ((*info->callbacks->reloc_overflow)
8354 (info, NULL, name, howto->name, (bfd_vma) 0,
8355 input_bfd, input_section, rel->r_offset)))
8368 /* If we've got another relocation for the address, keep going
8369 until we reach the last one. */
8370 if (use_saved_addend_p)
8376 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
8377 /* See the comment above about using R_MIPS_64 in the 32-bit
8378 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
8379 that calculated the right value. Now, however, we
8380 sign-extend the 32-bit result to 64-bits, and store it as a
8381 64-bit value. We are especially generous here in that we
8382 go to extreme lengths to support this usage on systems with
8383 only a 32-bit VMA. */
8389 if (value & ((bfd_vma) 1 << 31))
8391 sign_bits = ((bfd_vma) 1 << 32) - 1;
8398 /* If we don't know that we have a 64-bit type,
8399 do two separate stores. */
8400 if (bfd_big_endian (input_bfd))
8402 /* Undo what we did above. */
8404 /* Store the sign-bits (which are most significant)
8406 low_bits = sign_bits;
8412 high_bits = sign_bits;
8414 bfd_put_32 (input_bfd, low_bits,
8415 contents + rel->r_offset);
8416 bfd_put_32 (input_bfd, high_bits,
8417 contents + rel->r_offset + 4);
8421 /* Actually perform the relocation. */
8422 if (! mips_elf_perform_relocation (info, howto, rel, value,
8423 input_bfd, input_section,
8424 contents, require_jalx))
8431 /* If NAME is one of the special IRIX6 symbols defined by the linker,
8432 adjust it appropriately now. */
8435 mips_elf_irix6_finish_dynamic_symbol (bfd *abfd ATTRIBUTE_UNUSED,
8436 const char *name, Elf_Internal_Sym *sym)
8438 /* The linker script takes care of providing names and values for
8439 these, but we must place them into the right sections. */
8440 static const char* const text_section_symbols[] = {
8443 "__dso_displacement",
8445 "__program_header_table",
8449 static const char* const data_section_symbols[] = {
8457 const char* const *p;
8460 for (i = 0; i < 2; ++i)
8461 for (p = (i == 0) ? text_section_symbols : data_section_symbols;
8464 if (strcmp (*p, name) == 0)
8466 /* All of these symbols are given type STT_SECTION by the
8468 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8469 sym->st_other = STO_PROTECTED;
8471 /* The IRIX linker puts these symbols in special sections. */
8473 sym->st_shndx = SHN_MIPS_TEXT;
8475 sym->st_shndx = SHN_MIPS_DATA;
8481 /* Finish up dynamic symbol handling. We set the contents of various
8482 dynamic sections here. */
8485 _bfd_mips_elf_finish_dynamic_symbol (bfd *output_bfd,
8486 struct bfd_link_info *info,
8487 struct elf_link_hash_entry *h,
8488 Elf_Internal_Sym *sym)
8492 struct mips_got_info *g, *gg;
8495 struct mips_elf_link_hash_table *htab;
8497 htab = mips_elf_hash_table (info);
8498 dynobj = elf_hash_table (info)->dynobj;
8500 if (h->plt.offset != MINUS_ONE)
8503 bfd_byte stub[MIPS_FUNCTION_STUB_BIG_SIZE];
8505 /* This symbol has a stub. Set it up. */
8507 BFD_ASSERT (h->dynindx != -1);
8509 s = bfd_get_section_by_name (dynobj,
8510 MIPS_ELF_STUB_SECTION_NAME (dynobj));
8511 BFD_ASSERT (s != NULL);
8513 BFD_ASSERT ((htab->function_stub_size == MIPS_FUNCTION_STUB_BIG_SIZE)
8514 || (h->dynindx <= 0xffff));
8516 /* Values up to 2^31 - 1 are allowed. Larger values would cause
8517 sign extension at runtime in the stub, resulting in a negative
8519 if (h->dynindx & ~0x7fffffff)
8522 /* Fill the stub. */
8524 bfd_put_32 (output_bfd, STUB_LW (output_bfd), stub + idx);
8526 bfd_put_32 (output_bfd, STUB_MOVE (output_bfd), stub + idx);
8528 if (htab->function_stub_size == MIPS_FUNCTION_STUB_BIG_SIZE)
8530 bfd_put_32 (output_bfd, STUB_LUI ((h->dynindx >> 16) & 0x7fff),
8534 bfd_put_32 (output_bfd, STUB_JALR, stub + idx);
8537 /* If a large stub is not required and sign extension is not a
8538 problem, then use legacy code in the stub. */
8539 if (htab->function_stub_size == MIPS_FUNCTION_STUB_BIG_SIZE)
8540 bfd_put_32 (output_bfd, STUB_ORI (h->dynindx & 0xffff), stub + idx);
8541 else if (h->dynindx & ~0x7fff)
8542 bfd_put_32 (output_bfd, STUB_LI16U (h->dynindx & 0xffff), stub + idx);
8544 bfd_put_32 (output_bfd, STUB_LI16S (output_bfd, h->dynindx),
8547 BFD_ASSERT (h->plt.offset <= s->size);
8548 memcpy (s->contents + h->plt.offset, stub, htab->function_stub_size);
8550 /* Mark the symbol as undefined. plt.offset != -1 occurs
8551 only for the referenced symbol. */
8552 sym->st_shndx = SHN_UNDEF;
8554 /* The run-time linker uses the st_value field of the symbol
8555 to reset the global offset table entry for this external
8556 to its stub address when unlinking a shared object. */
8557 sym->st_value = (s->output_section->vma + s->output_offset
8561 BFD_ASSERT (h->dynindx != -1
8562 || h->forced_local);
8564 sgot = mips_elf_got_section (dynobj, FALSE);
8565 BFD_ASSERT (sgot != NULL);
8566 BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
8567 g = mips_elf_section_data (sgot)->u.got_info;
8568 BFD_ASSERT (g != NULL);
8570 /* Run through the global symbol table, creating GOT entries for all
8571 the symbols that need them. */
8572 if (g->global_gotsym != NULL
8573 && h->dynindx >= g->global_gotsym->dynindx)
8578 value = sym->st_value;
8579 offset = mips_elf_global_got_index (dynobj, output_bfd, h, R_MIPS_GOT16, info);
8580 MIPS_ELF_PUT_WORD (output_bfd, value, sgot->contents + offset);
8583 if (g->next && h->dynindx != -1 && h->type != STT_TLS)
8585 struct mips_got_entry e, *p;
8591 e.abfd = output_bfd;
8593 e.d.h = (struct mips_elf_link_hash_entry *)h;
8596 for (g = g->next; g->next != gg; g = g->next)
8599 && (p = (struct mips_got_entry *) htab_find (g->got_entries,
8604 || (elf_hash_table (info)->dynamic_sections_created
8606 && p->d.h->root.def_dynamic
8607 && !p->d.h->root.def_regular))
8609 /* Create an R_MIPS_REL32 relocation for this entry. Due to
8610 the various compatibility problems, it's easier to mock
8611 up an R_MIPS_32 or R_MIPS_64 relocation and leave
8612 mips_elf_create_dynamic_relocation to calculate the
8613 appropriate addend. */
8614 Elf_Internal_Rela rel[3];
8616 memset (rel, 0, sizeof (rel));
8617 if (ABI_64_P (output_bfd))
8618 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_64);
8620 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_32);
8621 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
8624 if (! (mips_elf_create_dynamic_relocation
8625 (output_bfd, info, rel,
8626 e.d.h, NULL, sym->st_value, &entry, sgot)))
8630 entry = sym->st_value;
8631 MIPS_ELF_PUT_WORD (output_bfd, entry, sgot->contents + offset);
8636 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
8637 name = h->root.root.string;
8638 if (strcmp (name, "_DYNAMIC") == 0
8639 || h == elf_hash_table (info)->hgot)
8640 sym->st_shndx = SHN_ABS;
8641 else if (strcmp (name, "_DYNAMIC_LINK") == 0
8642 || strcmp (name, "_DYNAMIC_LINKING") == 0)
8644 sym->st_shndx = SHN_ABS;
8645 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8648 else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (output_bfd))
8650 sym->st_shndx = SHN_ABS;
8651 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8652 sym->st_value = elf_gp (output_bfd);
8654 else if (SGI_COMPAT (output_bfd))
8656 if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
8657 || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
8659 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8660 sym->st_other = STO_PROTECTED;
8662 sym->st_shndx = SHN_MIPS_DATA;
8664 else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
8666 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8667 sym->st_other = STO_PROTECTED;
8668 sym->st_value = mips_elf_hash_table (info)->procedure_count;
8669 sym->st_shndx = SHN_ABS;
8671 else if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS)
8673 if (h->type == STT_FUNC)
8674 sym->st_shndx = SHN_MIPS_TEXT;
8675 else if (h->type == STT_OBJECT)
8676 sym->st_shndx = SHN_MIPS_DATA;
8680 /* Handle the IRIX6-specific symbols. */
8681 if (IRIX_COMPAT (output_bfd) == ict_irix6)
8682 mips_elf_irix6_finish_dynamic_symbol (output_bfd, name, sym);
8686 if (! mips_elf_hash_table (info)->use_rld_obj_head
8687 && (strcmp (name, "__rld_map") == 0
8688 || strcmp (name, "__RLD_MAP") == 0))
8690 asection *s = bfd_get_section_by_name (dynobj, ".rld_map");
8691 BFD_ASSERT (s != NULL);
8692 sym->st_value = s->output_section->vma + s->output_offset;
8693 bfd_put_32 (output_bfd, 0, s->contents);
8694 if (mips_elf_hash_table (info)->rld_value == 0)
8695 mips_elf_hash_table (info)->rld_value = sym->st_value;
8697 else if (mips_elf_hash_table (info)->use_rld_obj_head
8698 && strcmp (name, "__rld_obj_head") == 0)
8700 /* IRIX6 does not use a .rld_map section. */
8701 if (IRIX_COMPAT (output_bfd) == ict_irix5
8702 || IRIX_COMPAT (output_bfd) == ict_none)
8703 BFD_ASSERT (bfd_get_section_by_name (dynobj, ".rld_map")
8705 mips_elf_hash_table (info)->rld_value = sym->st_value;
8709 /* If this is a mips16 symbol, force the value to be even. */
8710 if (sym->st_other == STO_MIPS16)
8711 sym->st_value &= ~1;
8716 /* Likewise, for VxWorks. */
8719 _bfd_mips_vxworks_finish_dynamic_symbol (bfd *output_bfd,
8720 struct bfd_link_info *info,
8721 struct elf_link_hash_entry *h,
8722 Elf_Internal_Sym *sym)
8726 struct mips_got_info *g;
8727 struct mips_elf_link_hash_table *htab;
8729 htab = mips_elf_hash_table (info);
8730 dynobj = elf_hash_table (info)->dynobj;
8732 if (h->plt.offset != (bfd_vma) -1)
8735 bfd_vma plt_address, plt_index, got_address, got_offset, branch_offset;
8736 Elf_Internal_Rela rel;
8737 static const bfd_vma *plt_entry;
8739 BFD_ASSERT (h->dynindx != -1);
8740 BFD_ASSERT (htab->splt != NULL);
8741 BFD_ASSERT (h->plt.offset <= htab->splt->size);
8743 /* Calculate the address of the .plt entry. */
8744 plt_address = (htab->splt->output_section->vma
8745 + htab->splt->output_offset
8748 /* Calculate the index of the entry. */
8749 plt_index = ((h->plt.offset - htab->plt_header_size)
8750 / htab->plt_entry_size);
8752 /* Calculate the address of the .got.plt entry. */
8753 got_address = (htab->sgotplt->output_section->vma
8754 + htab->sgotplt->output_offset
8757 /* Calculate the offset of the .got.plt entry from
8758 _GLOBAL_OFFSET_TABLE_. */
8759 got_offset = mips_elf_gotplt_index (info, h);
8761 /* Calculate the offset for the branch at the start of the PLT
8762 entry. The branch jumps to the beginning of .plt. */
8763 branch_offset = -(h->plt.offset / 4 + 1) & 0xffff;
8765 /* Fill in the initial value of the .got.plt entry. */
8766 bfd_put_32 (output_bfd, plt_address,
8767 htab->sgotplt->contents + plt_index * 4);
8769 /* Find out where the .plt entry should go. */
8770 loc = htab->splt->contents + h->plt.offset;
8774 plt_entry = mips_vxworks_shared_plt_entry;
8775 bfd_put_32 (output_bfd, plt_entry[0] | branch_offset, loc);
8776 bfd_put_32 (output_bfd, plt_entry[1] | plt_index, loc + 4);
8780 bfd_vma got_address_high, got_address_low;
8782 plt_entry = mips_vxworks_exec_plt_entry;
8783 got_address_high = ((got_address + 0x8000) >> 16) & 0xffff;
8784 got_address_low = got_address & 0xffff;
8786 bfd_put_32 (output_bfd, plt_entry[0] | branch_offset, loc);
8787 bfd_put_32 (output_bfd, plt_entry[1] | plt_index, loc + 4);
8788 bfd_put_32 (output_bfd, plt_entry[2] | got_address_high, loc + 8);
8789 bfd_put_32 (output_bfd, plt_entry[3] | got_address_low, loc + 12);
8790 bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
8791 bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
8792 bfd_put_32 (output_bfd, plt_entry[6], loc + 24);
8793 bfd_put_32 (output_bfd, plt_entry[7], loc + 28);
8795 loc = (htab->srelplt2->contents
8796 + (plt_index * 3 + 2) * sizeof (Elf32_External_Rela));
8798 /* Emit a relocation for the .got.plt entry. */
8799 rel.r_offset = got_address;
8800 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_MIPS_32);
8801 rel.r_addend = h->plt.offset;
8802 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
8804 /* Emit a relocation for the lui of %hi(<.got.plt slot>). */
8805 loc += sizeof (Elf32_External_Rela);
8806 rel.r_offset = plt_address + 8;
8807 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
8808 rel.r_addend = got_offset;
8809 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
8811 /* Emit a relocation for the addiu of %lo(<.got.plt slot>). */
8812 loc += sizeof (Elf32_External_Rela);
8814 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
8815 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
8818 /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry. */
8819 loc = htab->srelplt->contents + plt_index * sizeof (Elf32_External_Rela);
8820 rel.r_offset = got_address;
8821 rel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_JUMP_SLOT);
8823 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
8825 if (!h->def_regular)
8826 sym->st_shndx = SHN_UNDEF;
8829 BFD_ASSERT (h->dynindx != -1 || h->forced_local);
8831 sgot = mips_elf_got_section (dynobj, FALSE);
8832 BFD_ASSERT (sgot != NULL);
8833 BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
8834 g = mips_elf_section_data (sgot)->u.got_info;
8835 BFD_ASSERT (g != NULL);
8837 /* See if this symbol has an entry in the GOT. */
8838 if (g->global_gotsym != NULL
8839 && h->dynindx >= g->global_gotsym->dynindx)
8842 Elf_Internal_Rela outrel;
8846 /* Install the symbol value in the GOT. */
8847 offset = mips_elf_global_got_index (dynobj, output_bfd, h,
8848 R_MIPS_GOT16, info);
8849 MIPS_ELF_PUT_WORD (output_bfd, sym->st_value, sgot->contents + offset);
8851 /* Add a dynamic relocation for it. */
8852 s = mips_elf_rel_dyn_section (info, FALSE);
8853 loc = s->contents + (s->reloc_count++ * sizeof (Elf32_External_Rela));
8854 outrel.r_offset = (sgot->output_section->vma
8855 + sgot->output_offset
8857 outrel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_32);
8858 outrel.r_addend = 0;
8859 bfd_elf32_swap_reloca_out (dynobj, &outrel, loc);
8862 /* Emit a copy reloc, if needed. */
8865 Elf_Internal_Rela rel;
8867 BFD_ASSERT (h->dynindx != -1);
8869 rel.r_offset = (h->root.u.def.section->output_section->vma
8870 + h->root.u.def.section->output_offset
8871 + h->root.u.def.value);
8872 rel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_COPY);
8874 bfd_elf32_swap_reloca_out (output_bfd, &rel,
8875 htab->srelbss->contents
8876 + (htab->srelbss->reloc_count
8877 * sizeof (Elf32_External_Rela)));
8878 ++htab->srelbss->reloc_count;
8881 /* If this is a mips16 symbol, force the value to be even. */
8882 if (sym->st_other == STO_MIPS16)
8883 sym->st_value &= ~1;
8888 /* Install the PLT header for a VxWorks executable and finalize the
8889 contents of .rela.plt.unloaded. */
8892 mips_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
8894 Elf_Internal_Rela rela;
8896 bfd_vma got_value, got_value_high, got_value_low, plt_address;
8897 static const bfd_vma *plt_entry;
8898 struct mips_elf_link_hash_table *htab;
8900 htab = mips_elf_hash_table (info);
8901 plt_entry = mips_vxworks_exec_plt0_entry;
8903 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */
8904 got_value = (htab->root.hgot->root.u.def.section->output_section->vma
8905 + htab->root.hgot->root.u.def.section->output_offset
8906 + htab->root.hgot->root.u.def.value);
8908 got_value_high = ((got_value + 0x8000) >> 16) & 0xffff;
8909 got_value_low = got_value & 0xffff;
8911 /* Calculate the address of the PLT header. */
8912 plt_address = htab->splt->output_section->vma + htab->splt->output_offset;
8914 /* Install the PLT header. */
8915 loc = htab->splt->contents;
8916 bfd_put_32 (output_bfd, plt_entry[0] | got_value_high, loc);
8917 bfd_put_32 (output_bfd, plt_entry[1] | got_value_low, loc + 4);
8918 bfd_put_32 (output_bfd, plt_entry[2], loc + 8);
8919 bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
8920 bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
8921 bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
8923 /* Output the relocation for the lui of %hi(_GLOBAL_OFFSET_TABLE_). */
8924 loc = htab->srelplt2->contents;
8925 rela.r_offset = plt_address;
8926 rela.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
8928 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
8929 loc += sizeof (Elf32_External_Rela);
8931 /* Output the relocation for the following addiu of
8932 %lo(_GLOBAL_OFFSET_TABLE_). */
8934 rela.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
8935 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
8936 loc += sizeof (Elf32_External_Rela);
8938 /* Fix up the remaining relocations. They may have the wrong
8939 symbol index for _G_O_T_ or _P_L_T_ depending on the order
8940 in which symbols were output. */
8941 while (loc < htab->srelplt2->contents + htab->srelplt2->size)
8943 Elf_Internal_Rela rel;
8945 bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
8946 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_MIPS_32);
8947 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
8948 loc += sizeof (Elf32_External_Rela);
8950 bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
8951 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
8952 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
8953 loc += sizeof (Elf32_External_Rela);
8955 bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
8956 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
8957 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
8958 loc += sizeof (Elf32_External_Rela);
8962 /* Install the PLT header for a VxWorks shared library. */
8965 mips_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
8968 struct mips_elf_link_hash_table *htab;
8970 htab = mips_elf_hash_table (info);
8972 /* We just need to copy the entry byte-by-byte. */
8973 for (i = 0; i < ARRAY_SIZE (mips_vxworks_shared_plt0_entry); i++)
8974 bfd_put_32 (output_bfd, mips_vxworks_shared_plt0_entry[i],
8975 htab->splt->contents + i * 4);
8978 /* Finish up the dynamic sections. */
8981 _bfd_mips_elf_finish_dynamic_sections (bfd *output_bfd,
8982 struct bfd_link_info *info)
8987 struct mips_got_info *gg, *g;
8988 struct mips_elf_link_hash_table *htab;
8990 htab = mips_elf_hash_table (info);
8991 dynobj = elf_hash_table (info)->dynobj;
8993 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
8995 sgot = mips_elf_got_section (dynobj, FALSE);
9000 BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
9001 gg = mips_elf_section_data (sgot)->u.got_info;
9002 BFD_ASSERT (gg != NULL);
9003 g = mips_elf_got_for_ibfd (gg, output_bfd);
9004 BFD_ASSERT (g != NULL);
9007 if (elf_hash_table (info)->dynamic_sections_created)
9010 int dyn_to_skip = 0, dyn_skipped = 0;
9012 BFD_ASSERT (sdyn != NULL);
9013 BFD_ASSERT (g != NULL);
9015 for (b = sdyn->contents;
9016 b < sdyn->contents + sdyn->size;
9017 b += MIPS_ELF_DYN_SIZE (dynobj))
9019 Elf_Internal_Dyn dyn;
9023 bfd_boolean swap_out_p;
9025 /* Read in the current dynamic entry. */
9026 (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
9028 /* Assume that we're going to modify it and write it out. */
9034 dyn.d_un.d_val = MIPS_ELF_REL_SIZE (dynobj);
9038 BFD_ASSERT (htab->is_vxworks);
9039 dyn.d_un.d_val = MIPS_ELF_RELA_SIZE (dynobj);
9043 /* Rewrite DT_STRSZ. */
9045 _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
9050 if (htab->is_vxworks)
9052 /* _GLOBAL_OFFSET_TABLE_ is defined to be the beginning
9053 of the ".got" section in DYNOBJ. */
9054 s = bfd_get_section_by_name (dynobj, name);
9055 BFD_ASSERT (s != NULL);
9056 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
9060 s = bfd_get_section_by_name (output_bfd, name);
9061 BFD_ASSERT (s != NULL);
9062 dyn.d_un.d_ptr = s->vma;
9066 case DT_MIPS_RLD_VERSION:
9067 dyn.d_un.d_val = 1; /* XXX */
9071 dyn.d_un.d_val = RHF_NOTPOT; /* XXX */
9074 case DT_MIPS_TIME_STAMP:
9082 case DT_MIPS_ICHECKSUM:
9087 case DT_MIPS_IVERSION:
9092 case DT_MIPS_BASE_ADDRESS:
9093 s = output_bfd->sections;
9094 BFD_ASSERT (s != NULL);
9095 dyn.d_un.d_ptr = s->vma & ~(bfd_vma) 0xffff;
9098 case DT_MIPS_LOCAL_GOTNO:
9099 dyn.d_un.d_val = g->local_gotno;
9102 case DT_MIPS_UNREFEXTNO:
9103 /* The index into the dynamic symbol table which is the
9104 entry of the first external symbol that is not
9105 referenced within the same object. */
9106 dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
9109 case DT_MIPS_GOTSYM:
9110 if (gg->global_gotsym)
9112 dyn.d_un.d_val = gg->global_gotsym->dynindx;
9115 /* In case if we don't have global got symbols we default
9116 to setting DT_MIPS_GOTSYM to the same value as
9117 DT_MIPS_SYMTABNO, so we just fall through. */
9119 case DT_MIPS_SYMTABNO:
9121 elemsize = MIPS_ELF_SYM_SIZE (output_bfd);
9122 s = bfd_get_section_by_name (output_bfd, name);
9123 BFD_ASSERT (s != NULL);
9125 dyn.d_un.d_val = s->size / elemsize;
9128 case DT_MIPS_HIPAGENO:
9129 dyn.d_un.d_val = g->local_gotno - MIPS_RESERVED_GOTNO (info);
9132 case DT_MIPS_RLD_MAP:
9133 dyn.d_un.d_ptr = mips_elf_hash_table (info)->rld_value;
9136 case DT_MIPS_OPTIONS:
9137 s = (bfd_get_section_by_name
9138 (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd)));
9139 dyn.d_un.d_ptr = s->vma;
9143 BFD_ASSERT (htab->is_vxworks);
9144 /* The count does not include the JUMP_SLOT relocations. */
9146 dyn.d_un.d_val -= htab->srelplt->size;
9150 BFD_ASSERT (htab->is_vxworks);
9151 dyn.d_un.d_val = DT_RELA;
9155 BFD_ASSERT (htab->is_vxworks);
9156 dyn.d_un.d_val = htab->srelplt->size;
9160 BFD_ASSERT (htab->is_vxworks);
9161 dyn.d_un.d_val = (htab->srelplt->output_section->vma
9162 + htab->srelplt->output_offset);
9166 /* If we didn't need any text relocations after all, delete
9168 if (!(info->flags & DF_TEXTREL))
9170 dyn_to_skip = MIPS_ELF_DYN_SIZE (dynobj);
9176 /* If we didn't need any text relocations after all, clear
9177 DF_TEXTREL from DT_FLAGS. */
9178 if (!(info->flags & DF_TEXTREL))
9179 dyn.d_un.d_val &= ~DF_TEXTREL;
9186 if (htab->is_vxworks
9187 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
9192 if (swap_out_p || dyn_skipped)
9193 (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
9194 (dynobj, &dyn, b - dyn_skipped);
9198 dyn_skipped += dyn_to_skip;
9203 /* Wipe out any trailing entries if we shifted down a dynamic tag. */
9204 if (dyn_skipped > 0)
9205 memset (b - dyn_skipped, 0, dyn_skipped);
9208 if (sgot != NULL && sgot->size > 0
9209 && !bfd_is_abs_section (sgot->output_section))
9211 if (htab->is_vxworks)
9213 /* The first entry of the global offset table points to the
9214 ".dynamic" section. The second is initialized by the
9215 loader and contains the shared library identifier.
9216 The third is also initialized by the loader and points
9217 to the lazy resolution stub. */
9218 MIPS_ELF_PUT_WORD (output_bfd,
9219 sdyn->output_offset + sdyn->output_section->vma,
9221 MIPS_ELF_PUT_WORD (output_bfd, 0,
9222 sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
9223 MIPS_ELF_PUT_WORD (output_bfd, 0,
9225 + 2 * MIPS_ELF_GOT_SIZE (output_bfd));
9229 /* The first entry of the global offset table will be filled at
9230 runtime. The second entry will be used by some runtime loaders.
9231 This isn't the case of IRIX rld. */
9232 MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0, sgot->contents);
9233 MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0x80000000,
9234 sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
9237 elf_section_data (sgot->output_section)->this_hdr.sh_entsize
9238 = MIPS_ELF_GOT_SIZE (output_bfd);
9241 /* Generate dynamic relocations for the non-primary gots. */
9242 if (gg != NULL && gg->next)
9244 Elf_Internal_Rela rel[3];
9247 memset (rel, 0, sizeof (rel));
9248 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_REL32);
9250 for (g = gg->next; g->next != gg; g = g->next)
9252 bfd_vma index = g->next->local_gotno + g->next->global_gotno
9253 + g->next->tls_gotno;
9255 MIPS_ELF_PUT_WORD (output_bfd, 0, sgot->contents
9256 + index++ * MIPS_ELF_GOT_SIZE (output_bfd));
9257 MIPS_ELF_PUT_WORD (output_bfd, 0x80000000, sgot->contents
9258 + index++ * MIPS_ELF_GOT_SIZE (output_bfd));
9263 while (index < g->assigned_gotno)
9265 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset
9266 = index++ * MIPS_ELF_GOT_SIZE (output_bfd);
9267 if (!(mips_elf_create_dynamic_relocation
9268 (output_bfd, info, rel, NULL,
9269 bfd_abs_section_ptr,
9272 BFD_ASSERT (addend == 0);
9277 /* The generation of dynamic relocations for the non-primary gots
9278 adds more dynamic relocations. We cannot count them until
9281 if (elf_hash_table (info)->dynamic_sections_created)
9284 bfd_boolean swap_out_p;
9286 BFD_ASSERT (sdyn != NULL);
9288 for (b = sdyn->contents;
9289 b < sdyn->contents + sdyn->size;
9290 b += MIPS_ELF_DYN_SIZE (dynobj))
9292 Elf_Internal_Dyn dyn;
9295 /* Read in the current dynamic entry. */
9296 (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
9298 /* Assume that we're going to modify it and write it out. */
9304 /* Reduce DT_RELSZ to account for any relocations we
9305 decided not to make. This is for the n64 irix rld,
9306 which doesn't seem to apply any relocations if there
9307 are trailing null entries. */
9308 s = mips_elf_rel_dyn_section (info, FALSE);
9309 dyn.d_un.d_val = (s->reloc_count
9310 * (ABI_64_P (output_bfd)
9311 ? sizeof (Elf64_Mips_External_Rel)
9312 : sizeof (Elf32_External_Rel)));
9313 /* Adjust the section size too. Tools like the prelinker
9314 can reasonably expect the values to the same. */
9315 elf_section_data (s->output_section)->this_hdr.sh_size
9325 (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
9332 Elf32_compact_rel cpt;
9334 if (SGI_COMPAT (output_bfd))
9336 /* Write .compact_rel section out. */
9337 s = bfd_get_section_by_name (dynobj, ".compact_rel");
9341 cpt.num = s->reloc_count;
9343 cpt.offset = (s->output_section->filepos
9344 + sizeof (Elf32_External_compact_rel));
9347 bfd_elf32_swap_compact_rel_out (output_bfd, &cpt,
9348 ((Elf32_External_compact_rel *)
9351 /* Clean up a dummy stub function entry in .text. */
9352 s = bfd_get_section_by_name (dynobj,
9353 MIPS_ELF_STUB_SECTION_NAME (dynobj));
9356 file_ptr dummy_offset;
9358 BFD_ASSERT (s->size >= htab->function_stub_size);
9359 dummy_offset = s->size - htab->function_stub_size;
9360 memset (s->contents + dummy_offset, 0,
9361 htab->function_stub_size);
9366 /* The psABI says that the dynamic relocations must be sorted in
9367 increasing order of r_symndx. The VxWorks EABI doesn't require
9368 this, and because the code below handles REL rather than RELA
9369 relocations, using it for VxWorks would be outright harmful. */
9370 if (!htab->is_vxworks)
9372 s = mips_elf_rel_dyn_section (info, FALSE);
9374 && s->size > (bfd_vma)2 * MIPS_ELF_REL_SIZE (output_bfd))
9376 reldyn_sorting_bfd = output_bfd;
9378 if (ABI_64_P (output_bfd))
9379 qsort ((Elf64_External_Rel *) s->contents + 1,
9380 s->reloc_count - 1, sizeof (Elf64_Mips_External_Rel),
9381 sort_dynamic_relocs_64);
9383 qsort ((Elf32_External_Rel *) s->contents + 1,
9384 s->reloc_count - 1, sizeof (Elf32_External_Rel),
9385 sort_dynamic_relocs);
9390 if (htab->is_vxworks && htab->splt->size > 0)
9393 mips_vxworks_finish_shared_plt (output_bfd, info);
9395 mips_vxworks_finish_exec_plt (output_bfd, info);
9401 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
9404 mips_set_isa_flags (bfd *abfd)
9408 switch (bfd_get_mach (abfd))
9411 case bfd_mach_mips3000:
9412 val = E_MIPS_ARCH_1;
9415 case bfd_mach_mips3900:
9416 val = E_MIPS_ARCH_1 | E_MIPS_MACH_3900;
9419 case bfd_mach_mips6000:
9420 val = E_MIPS_ARCH_2;
9423 case bfd_mach_mips4000:
9424 case bfd_mach_mips4300:
9425 case bfd_mach_mips4400:
9426 case bfd_mach_mips4600:
9427 val = E_MIPS_ARCH_3;
9430 case bfd_mach_mips4010:
9431 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4010;
9434 case bfd_mach_mips4100:
9435 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4100;
9438 case bfd_mach_mips4111:
9439 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4111;
9442 case bfd_mach_mips4120:
9443 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4120;
9446 case bfd_mach_mips4650:
9447 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4650;
9450 case bfd_mach_mips5400:
9451 val = E_MIPS_ARCH_4 | E_MIPS_MACH_5400;
9454 case bfd_mach_mips5500:
9455 val = E_MIPS_ARCH_4 | E_MIPS_MACH_5500;
9458 case bfd_mach_mips9000:
9459 val = E_MIPS_ARCH_4 | E_MIPS_MACH_9000;
9462 case bfd_mach_mips5000:
9463 case bfd_mach_mips7000:
9464 case bfd_mach_mips8000:
9465 case bfd_mach_mips10000:
9466 case bfd_mach_mips12000:
9467 val = E_MIPS_ARCH_4;
9470 case bfd_mach_mips5:
9471 val = E_MIPS_ARCH_5;
9474 case bfd_mach_mips_loongson_2e:
9475 val = E_MIPS_ARCH_3 | E_MIPS_MACH_LS2E;
9478 case bfd_mach_mips_loongson_2f:
9479 val = E_MIPS_ARCH_3 | E_MIPS_MACH_LS2F;
9482 case bfd_mach_mips_sb1:
9483 val = E_MIPS_ARCH_64 | E_MIPS_MACH_SB1;
9486 case bfd_mach_mips_octeon:
9487 val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_OCTEON;
9490 case bfd_mach_mipsisa32:
9491 val = E_MIPS_ARCH_32;
9494 case bfd_mach_mipsisa64:
9495 val = E_MIPS_ARCH_64;
9498 case bfd_mach_mipsisa32r2:
9499 val = E_MIPS_ARCH_32R2;
9502 case bfd_mach_mipsisa64r2:
9503 val = E_MIPS_ARCH_64R2;
9506 elf_elfheader (abfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
9507 elf_elfheader (abfd)->e_flags |= val;
9512 /* The final processing done just before writing out a MIPS ELF object
9513 file. This gets the MIPS architecture right based on the machine
9514 number. This is used by both the 32-bit and the 64-bit ABI. */
9517 _bfd_mips_elf_final_write_processing (bfd *abfd,
9518 bfd_boolean linker ATTRIBUTE_UNUSED)
9521 Elf_Internal_Shdr **hdrpp;
9525 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
9526 is nonzero. This is for compatibility with old objects, which used
9527 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
9528 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == 0)
9529 mips_set_isa_flags (abfd);
9531 /* Set the sh_info field for .gptab sections and other appropriate
9532 info for each special section. */
9533 for (i = 1, hdrpp = elf_elfsections (abfd) + 1;
9534 i < elf_numsections (abfd);
9537 switch ((*hdrpp)->sh_type)
9540 case SHT_MIPS_LIBLIST:
9541 sec = bfd_get_section_by_name (abfd, ".dynstr");
9543 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
9546 case SHT_MIPS_GPTAB:
9547 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
9548 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
9549 BFD_ASSERT (name != NULL
9550 && CONST_STRNEQ (name, ".gptab."));
9551 sec = bfd_get_section_by_name (abfd, name + sizeof ".gptab" - 1);
9552 BFD_ASSERT (sec != NULL);
9553 (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
9556 case SHT_MIPS_CONTENT:
9557 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
9558 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
9559 BFD_ASSERT (name != NULL
9560 && CONST_STRNEQ (name, ".MIPS.content"));
9561 sec = bfd_get_section_by_name (abfd,
9562 name + sizeof ".MIPS.content" - 1);
9563 BFD_ASSERT (sec != NULL);
9564 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
9567 case SHT_MIPS_SYMBOL_LIB:
9568 sec = bfd_get_section_by_name (abfd, ".dynsym");
9570 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
9571 sec = bfd_get_section_by_name (abfd, ".liblist");
9573 (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
9576 case SHT_MIPS_EVENTS:
9577 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
9578 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
9579 BFD_ASSERT (name != NULL);
9580 if (CONST_STRNEQ (name, ".MIPS.events"))
9581 sec = bfd_get_section_by_name (abfd,
9582 name + sizeof ".MIPS.events" - 1);
9585 BFD_ASSERT (CONST_STRNEQ (name, ".MIPS.post_rel"));
9586 sec = bfd_get_section_by_name (abfd,
9588 + sizeof ".MIPS.post_rel" - 1));
9590 BFD_ASSERT (sec != NULL);
9591 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
9598 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
9602 _bfd_mips_elf_additional_program_headers (bfd *abfd,
9603 struct bfd_link_info *info ATTRIBUTE_UNUSED)
9608 /* See if we need a PT_MIPS_REGINFO segment. */
9609 s = bfd_get_section_by_name (abfd, ".reginfo");
9610 if (s && (s->flags & SEC_LOAD))
9613 /* See if we need a PT_MIPS_OPTIONS segment. */
9614 if (IRIX_COMPAT (abfd) == ict_irix6
9615 && bfd_get_section_by_name (abfd,
9616 MIPS_ELF_OPTIONS_SECTION_NAME (abfd)))
9619 /* See if we need a PT_MIPS_RTPROC segment. */
9620 if (IRIX_COMPAT (abfd) == ict_irix5
9621 && bfd_get_section_by_name (abfd, ".dynamic")
9622 && bfd_get_section_by_name (abfd, ".mdebug"))
9625 /* Allocate a PT_NULL header in dynamic objects. See
9626 _bfd_mips_elf_modify_segment_map for details. */
9627 if (!SGI_COMPAT (abfd)
9628 && bfd_get_section_by_name (abfd, ".dynamic"))
9634 /* Modify the segment map for an IRIX5 executable. */
9637 _bfd_mips_elf_modify_segment_map (bfd *abfd,
9638 struct bfd_link_info *info)
9641 struct elf_segment_map *m, **pm;
9644 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
9646 s = bfd_get_section_by_name (abfd, ".reginfo");
9647 if (s != NULL && (s->flags & SEC_LOAD) != 0)
9649 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
9650 if (m->p_type == PT_MIPS_REGINFO)
9655 m = bfd_zalloc (abfd, amt);
9659 m->p_type = PT_MIPS_REGINFO;
9663 /* We want to put it after the PHDR and INTERP segments. */
9664 pm = &elf_tdata (abfd)->segment_map;
9666 && ((*pm)->p_type == PT_PHDR
9667 || (*pm)->p_type == PT_INTERP))
9675 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
9676 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
9677 PT_MIPS_OPTIONS segment immediately following the program header
9680 /* On non-IRIX6 new abi, we'll have already created a segment
9681 for this section, so don't create another. I'm not sure this
9682 is not also the case for IRIX 6, but I can't test it right
9684 && IRIX_COMPAT (abfd) == ict_irix6)
9686 for (s = abfd->sections; s; s = s->next)
9687 if (elf_section_data (s)->this_hdr.sh_type == SHT_MIPS_OPTIONS)
9692 struct elf_segment_map *options_segment;
9694 pm = &elf_tdata (abfd)->segment_map;
9696 && ((*pm)->p_type == PT_PHDR
9697 || (*pm)->p_type == PT_INTERP))
9700 if (*pm == NULL || (*pm)->p_type != PT_MIPS_OPTIONS)
9702 amt = sizeof (struct elf_segment_map);
9703 options_segment = bfd_zalloc (abfd, amt);
9704 options_segment->next = *pm;
9705 options_segment->p_type = PT_MIPS_OPTIONS;
9706 options_segment->p_flags = PF_R;
9707 options_segment->p_flags_valid = TRUE;
9708 options_segment->count = 1;
9709 options_segment->sections[0] = s;
9710 *pm = options_segment;
9716 if (IRIX_COMPAT (abfd) == ict_irix5)
9718 /* If there are .dynamic and .mdebug sections, we make a room
9719 for the RTPROC header. FIXME: Rewrite without section names. */
9720 if (bfd_get_section_by_name (abfd, ".interp") == NULL
9721 && bfd_get_section_by_name (abfd, ".dynamic") != NULL
9722 && bfd_get_section_by_name (abfd, ".mdebug") != NULL)
9724 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
9725 if (m->p_type == PT_MIPS_RTPROC)
9730 m = bfd_zalloc (abfd, amt);
9734 m->p_type = PT_MIPS_RTPROC;
9736 s = bfd_get_section_by_name (abfd, ".rtproc");
9741 m->p_flags_valid = 1;
9749 /* We want to put it after the DYNAMIC segment. */
9750 pm = &elf_tdata (abfd)->segment_map;
9751 while (*pm != NULL && (*pm)->p_type != PT_DYNAMIC)
9761 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
9762 .dynstr, .dynsym, and .hash sections, and everything in
9764 for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL;
9766 if ((*pm)->p_type == PT_DYNAMIC)
9769 if (m != NULL && IRIX_COMPAT (abfd) == ict_none)
9771 /* For a normal mips executable the permissions for the PT_DYNAMIC
9772 segment are read, write and execute. We do that here since
9773 the code in elf.c sets only the read permission. This matters
9774 sometimes for the dynamic linker. */
9775 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
9777 m->p_flags = PF_R | PF_W | PF_X;
9778 m->p_flags_valid = 1;
9781 /* GNU/Linux binaries do not need the extended PT_DYNAMIC section.
9782 glibc's dynamic linker has traditionally derived the number of
9783 tags from the p_filesz field, and sometimes allocates stack
9784 arrays of that size. An overly-big PT_DYNAMIC segment can
9785 be actively harmful in such cases. Making PT_DYNAMIC contain
9786 other sections can also make life hard for the prelinker,
9787 which might move one of the other sections to a different
9789 if (SGI_COMPAT (abfd)
9792 && strcmp (m->sections[0]->name, ".dynamic") == 0)
9794 static const char *sec_names[] =
9796 ".dynamic", ".dynstr", ".dynsym", ".hash"
9800 struct elf_segment_map *n;
9804 for (i = 0; i < sizeof sec_names / sizeof sec_names[0]; i++)
9806 s = bfd_get_section_by_name (abfd, sec_names[i]);
9807 if (s != NULL && (s->flags & SEC_LOAD) != 0)
9814 if (high < s->vma + sz)
9820 for (s = abfd->sections; s != NULL; s = s->next)
9821 if ((s->flags & SEC_LOAD) != 0
9823 && s->vma + s->size <= high)
9826 amt = sizeof *n + (bfd_size_type) (c - 1) * sizeof (asection *);
9827 n = bfd_zalloc (abfd, amt);
9834 for (s = abfd->sections; s != NULL; s = s->next)
9836 if ((s->flags & SEC_LOAD) != 0
9838 && s->vma + s->size <= high)
9849 /* Allocate a spare program header in dynamic objects so that tools
9850 like the prelinker can add an extra PT_LOAD entry.
9852 If the prelinker needs to make room for a new PT_LOAD entry, its
9853 standard procedure is to move the first (read-only) sections into
9854 the new (writable) segment. However, the MIPS ABI requires
9855 .dynamic to be in a read-only segment, and the section will often
9856 start within sizeof (ElfNN_Phdr) bytes of the last program header.
9858 Although the prelinker could in principle move .dynamic to a
9859 writable segment, it seems better to allocate a spare program
9860 header instead, and avoid the need to move any sections.
9861 There is a long tradition of allocating spare dynamic tags,
9862 so allocating a spare program header seems like a natural
9865 If INFO is NULL, we may be copying an already prelinked binary
9866 with objcopy or strip, so do not add this header. */
9868 && !SGI_COMPAT (abfd)
9869 && bfd_get_section_by_name (abfd, ".dynamic"))
9871 for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL; pm = &(*pm)->next)
9872 if ((*pm)->p_type == PT_NULL)
9876 m = bfd_zalloc (abfd, sizeof (*m));
9880 m->p_type = PT_NULL;
9888 /* Return the section that should be marked against GC for a given
9892 _bfd_mips_elf_gc_mark_hook (asection *sec,
9893 struct bfd_link_info *info,
9894 Elf_Internal_Rela *rel,
9895 struct elf_link_hash_entry *h,
9896 Elf_Internal_Sym *sym)
9898 /* ??? Do mips16 stub sections need to be handled special? */
9901 switch (ELF_R_TYPE (sec->owner, rel->r_info))
9903 case R_MIPS_GNU_VTINHERIT:
9904 case R_MIPS_GNU_VTENTRY:
9908 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
9911 /* Update the got entry reference counts for the section being removed. */
9914 _bfd_mips_elf_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
9915 struct bfd_link_info *info ATTRIBUTE_UNUSED,
9916 asection *sec ATTRIBUTE_UNUSED,
9917 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
9920 Elf_Internal_Shdr *symtab_hdr;
9921 struct elf_link_hash_entry **sym_hashes;
9922 bfd_signed_vma *local_got_refcounts;
9923 const Elf_Internal_Rela *rel, *relend;
9924 unsigned long r_symndx;
9925 struct elf_link_hash_entry *h;
9927 if (info->relocatable)
9930 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9931 sym_hashes = elf_sym_hashes (abfd);
9932 local_got_refcounts = elf_local_got_refcounts (abfd);
9934 relend = relocs + sec->reloc_count;
9935 for (rel = relocs; rel < relend; rel++)
9936 switch (ELF_R_TYPE (abfd, rel->r_info))
9940 case R_MIPS_CALL_HI16:
9941 case R_MIPS_CALL_LO16:
9942 case R_MIPS_GOT_HI16:
9943 case R_MIPS_GOT_LO16:
9944 case R_MIPS_GOT_DISP:
9945 case R_MIPS_GOT_PAGE:
9946 case R_MIPS_GOT_OFST:
9947 /* ??? It would seem that the existing MIPS code does no sort
9948 of reference counting or whatnot on its GOT and PLT entries,
9949 so it is not possible to garbage collect them at this time. */
9960 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
9961 hiding the old indirect symbol. Process additional relocation
9962 information. Also called for weakdefs, in which case we just let
9963 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
9966 _bfd_mips_elf_copy_indirect_symbol (struct bfd_link_info *info,
9967 struct elf_link_hash_entry *dir,
9968 struct elf_link_hash_entry *ind)
9970 struct mips_elf_link_hash_entry *dirmips, *indmips;
9972 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
9974 if (ind->root.type != bfd_link_hash_indirect)
9977 dirmips = (struct mips_elf_link_hash_entry *) dir;
9978 indmips = (struct mips_elf_link_hash_entry *) ind;
9979 dirmips->possibly_dynamic_relocs += indmips->possibly_dynamic_relocs;
9980 if (indmips->readonly_reloc)
9981 dirmips->readonly_reloc = TRUE;
9982 if (indmips->no_fn_stub)
9983 dirmips->no_fn_stub = TRUE;
9985 if (dirmips->tls_type == 0)
9986 dirmips->tls_type = indmips->tls_type;
9990 _bfd_mips_elf_hide_symbol (struct bfd_link_info *info,
9991 struct elf_link_hash_entry *entry,
9992 bfd_boolean force_local)
9996 struct mips_got_info *g;
9997 struct mips_elf_link_hash_entry *h;
9998 struct mips_elf_link_hash_table *htab;
10000 h = (struct mips_elf_link_hash_entry *) entry;
10001 if (h->forced_local)
10003 h->forced_local = force_local;
10005 dynobj = elf_hash_table (info)->dynobj;
10006 htab = mips_elf_hash_table (info);
10007 if (dynobj != NULL && force_local && h->root.type != STT_TLS
10008 && (got = mips_elf_got_section (dynobj, TRUE)) != NULL
10009 && (g = mips_elf_section_data (got)->u.got_info) != NULL)
10013 struct mips_got_entry e;
10014 struct mips_got_info *gg = g;
10016 /* Since we're turning what used to be a global symbol into a
10017 local one, bump up the number of local entries of each GOT
10018 that had an entry for it. This will automatically decrease
10019 the number of global entries, since global_gotno is actually
10020 the upper limit of global entries. */
10026 for (g = g->next; g != gg; g = g->next)
10027 if (htab_find (g->got_entries, &e))
10029 BFD_ASSERT (g->global_gotno > 0);
10034 /* If this was a global symbol forced into the primary GOT, we
10035 no longer need an entry for it. We can't release the entry
10036 at this point, but we must at least stop counting it as one
10037 of the symbols that required a forced got entry. */
10038 if (h->root.got.offset == 2)
10040 BFD_ASSERT (gg->assigned_gotno > 0);
10041 gg->assigned_gotno--;
10044 else if (h->root.got.offset == 1)
10046 /* check_relocs didn't know that this symbol would be
10047 forced-local, so add an extra local got entry. */
10049 if (htab->computed_got_sizes)
10051 /* We'll have treated this symbol as global rather
10053 BFD_ASSERT (g->global_gotno > 0);
10057 else if (htab->is_vxworks && h->root.needs_plt)
10059 /* check_relocs didn't know that this symbol would be
10060 forced-local, so add an extra local got entry. */
10062 if (htab->computed_got_sizes)
10063 /* The symbol is only used in call relocations, so we'll
10064 have assumed it only needs a .got.plt entry. Increase
10065 the size of .got accordingly. */
10066 got->size += MIPS_ELF_GOT_SIZE (dynobj);
10070 _bfd_elf_link_hash_hide_symbol (info, &h->root, force_local);
10073 #define PDR_SIZE 32
10076 _bfd_mips_elf_discard_info (bfd *abfd, struct elf_reloc_cookie *cookie,
10077 struct bfd_link_info *info)
10080 bfd_boolean ret = FALSE;
10081 unsigned char *tdata;
10084 o = bfd_get_section_by_name (abfd, ".pdr");
10089 if (o->size % PDR_SIZE != 0)
10091 if (o->output_section != NULL
10092 && bfd_is_abs_section (o->output_section))
10095 tdata = bfd_zmalloc (o->size / PDR_SIZE);
10099 cookie->rels = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
10100 info->keep_memory);
10107 cookie->rel = cookie->rels;
10108 cookie->relend = cookie->rels + o->reloc_count;
10110 for (i = 0, skip = 0; i < o->size / PDR_SIZE; i ++)
10112 if (bfd_elf_reloc_symbol_deleted_p (i * PDR_SIZE, cookie))
10121 mips_elf_section_data (o)->u.tdata = tdata;
10122 o->size -= skip * PDR_SIZE;
10128 if (! info->keep_memory)
10129 free (cookie->rels);
10135 _bfd_mips_elf_ignore_discarded_relocs (asection *sec)
10137 if (strcmp (sec->name, ".pdr") == 0)
10143 _bfd_mips_elf_write_section (bfd *output_bfd,
10144 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
10145 asection *sec, bfd_byte *contents)
10147 bfd_byte *to, *from, *end;
10150 if (strcmp (sec->name, ".pdr") != 0)
10153 if (mips_elf_section_data (sec)->u.tdata == NULL)
10157 end = contents + sec->size;
10158 for (from = contents, i = 0;
10160 from += PDR_SIZE, i++)
10162 if ((mips_elf_section_data (sec)->u.tdata)[i] == 1)
10165 memcpy (to, from, PDR_SIZE);
10168 bfd_set_section_contents (output_bfd, sec->output_section, contents,
10169 sec->output_offset, sec->size);
10173 /* MIPS ELF uses a special find_nearest_line routine in order the
10174 handle the ECOFF debugging information. */
10176 struct mips_elf_find_line
10178 struct ecoff_debug_info d;
10179 struct ecoff_find_line i;
10183 _bfd_mips_elf_find_nearest_line (bfd *abfd, asection *section,
10184 asymbol **symbols, bfd_vma offset,
10185 const char **filename_ptr,
10186 const char **functionname_ptr,
10187 unsigned int *line_ptr)
10191 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
10192 filename_ptr, functionname_ptr,
10196 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
10197 filename_ptr, functionname_ptr,
10198 line_ptr, ABI_64_P (abfd) ? 8 : 0,
10199 &elf_tdata (abfd)->dwarf2_find_line_info))
10202 msec = bfd_get_section_by_name (abfd, ".mdebug");
10205 flagword origflags;
10206 struct mips_elf_find_line *fi;
10207 const struct ecoff_debug_swap * const swap =
10208 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
10210 /* If we are called during a link, mips_elf_final_link may have
10211 cleared the SEC_HAS_CONTENTS field. We force it back on here
10212 if appropriate (which it normally will be). */
10213 origflags = msec->flags;
10214 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
10215 msec->flags |= SEC_HAS_CONTENTS;
10217 fi = elf_tdata (abfd)->find_line_info;
10220 bfd_size_type external_fdr_size;
10223 struct fdr *fdr_ptr;
10224 bfd_size_type amt = sizeof (struct mips_elf_find_line);
10226 fi = bfd_zalloc (abfd, amt);
10229 msec->flags = origflags;
10233 if (! _bfd_mips_elf_read_ecoff_info (abfd, msec, &fi->d))
10235 msec->flags = origflags;
10239 /* Swap in the FDR information. */
10240 amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
10241 fi->d.fdr = bfd_alloc (abfd, amt);
10242 if (fi->d.fdr == NULL)
10244 msec->flags = origflags;
10247 external_fdr_size = swap->external_fdr_size;
10248 fdr_ptr = fi->d.fdr;
10249 fraw_src = (char *) fi->d.external_fdr;
10250 fraw_end = (fraw_src
10251 + fi->d.symbolic_header.ifdMax * external_fdr_size);
10252 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
10253 (*swap->swap_fdr_in) (abfd, fraw_src, fdr_ptr);
10255 elf_tdata (abfd)->find_line_info = fi;
10257 /* Note that we don't bother to ever free this information.
10258 find_nearest_line is either called all the time, as in
10259 objdump -l, so the information should be saved, or it is
10260 rarely called, as in ld error messages, so the memory
10261 wasted is unimportant. Still, it would probably be a
10262 good idea for free_cached_info to throw it away. */
10265 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
10266 &fi->i, filename_ptr, functionname_ptr,
10269 msec->flags = origflags;
10273 msec->flags = origflags;
10276 /* Fall back on the generic ELF find_nearest_line routine. */
10278 return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
10279 filename_ptr, functionname_ptr,
10284 _bfd_mips_elf_find_inliner_info (bfd *abfd,
10285 const char **filename_ptr,
10286 const char **functionname_ptr,
10287 unsigned int *line_ptr)
10290 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
10291 functionname_ptr, line_ptr,
10292 & elf_tdata (abfd)->dwarf2_find_line_info);
10297 /* When are writing out the .options or .MIPS.options section,
10298 remember the bytes we are writing out, so that we can install the
10299 GP value in the section_processing routine. */
10302 _bfd_mips_elf_set_section_contents (bfd *abfd, sec_ptr section,
10303 const void *location,
10304 file_ptr offset, bfd_size_type count)
10306 if (MIPS_ELF_OPTIONS_SECTION_NAME_P (section->name))
10310 if (elf_section_data (section) == NULL)
10312 bfd_size_type amt = sizeof (struct bfd_elf_section_data);
10313 section->used_by_bfd = bfd_zalloc (abfd, amt);
10314 if (elf_section_data (section) == NULL)
10317 c = mips_elf_section_data (section)->u.tdata;
10320 c = bfd_zalloc (abfd, section->size);
10323 mips_elf_section_data (section)->u.tdata = c;
10326 memcpy (c + offset, location, count);
10329 return _bfd_elf_set_section_contents (abfd, section, location, offset,
10333 /* This is almost identical to bfd_generic_get_... except that some
10334 MIPS relocations need to be handled specially. Sigh. */
10337 _bfd_elf_mips_get_relocated_section_contents
10339 struct bfd_link_info *link_info,
10340 struct bfd_link_order *link_order,
10342 bfd_boolean relocatable,
10345 /* Get enough memory to hold the stuff */
10346 bfd *input_bfd = link_order->u.indirect.section->owner;
10347 asection *input_section = link_order->u.indirect.section;
10350 long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
10351 arelent **reloc_vector = NULL;
10354 if (reloc_size < 0)
10357 reloc_vector = bfd_malloc (reloc_size);
10358 if (reloc_vector == NULL && reloc_size != 0)
10361 /* read in the section */
10362 sz = input_section->rawsize ? input_section->rawsize : input_section->size;
10363 if (!bfd_get_section_contents (input_bfd, input_section, data, 0, sz))
10366 reloc_count = bfd_canonicalize_reloc (input_bfd,
10370 if (reloc_count < 0)
10373 if (reloc_count > 0)
10378 bfd_vma gp = 0x12345678; /* initialize just to shut gcc up */
10381 struct bfd_hash_entry *h;
10382 struct bfd_link_hash_entry *lh;
10383 /* Skip all this stuff if we aren't mixing formats. */
10384 if (abfd && input_bfd
10385 && abfd->xvec == input_bfd->xvec)
10389 h = bfd_hash_lookup (&link_info->hash->table, "_gp", FALSE, FALSE);
10390 lh = (struct bfd_link_hash_entry *) h;
10397 case bfd_link_hash_undefined:
10398 case bfd_link_hash_undefweak:
10399 case bfd_link_hash_common:
10402 case bfd_link_hash_defined:
10403 case bfd_link_hash_defweak:
10405 gp = lh->u.def.value;
10407 case bfd_link_hash_indirect:
10408 case bfd_link_hash_warning:
10410 /* @@FIXME ignoring warning for now */
10412 case bfd_link_hash_new:
10421 for (parent = reloc_vector; *parent != NULL; parent++)
10423 char *error_message = NULL;
10424 bfd_reloc_status_type r;
10426 /* Specific to MIPS: Deal with relocation types that require
10427 knowing the gp of the output bfd. */
10428 asymbol *sym = *(*parent)->sym_ptr_ptr;
10430 /* If we've managed to find the gp and have a special
10431 function for the relocation then go ahead, else default
10432 to the generic handling. */
10434 && (*parent)->howto->special_function
10435 == _bfd_mips_elf32_gprel16_reloc)
10436 r = _bfd_mips_elf_gprel16_with_gp (input_bfd, sym, *parent,
10437 input_section, relocatable,
10440 r = bfd_perform_relocation (input_bfd, *parent, data,
10442 relocatable ? abfd : NULL,
10447 asection *os = input_section->output_section;
10449 /* A partial link, so keep the relocs */
10450 os->orelocation[os->reloc_count] = *parent;
10454 if (r != bfd_reloc_ok)
10458 case bfd_reloc_undefined:
10459 if (!((*link_info->callbacks->undefined_symbol)
10460 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
10461 input_bfd, input_section, (*parent)->address, TRUE)))
10464 case bfd_reloc_dangerous:
10465 BFD_ASSERT (error_message != NULL);
10466 if (!((*link_info->callbacks->reloc_dangerous)
10467 (link_info, error_message, input_bfd, input_section,
10468 (*parent)->address)))
10471 case bfd_reloc_overflow:
10472 if (!((*link_info->callbacks->reloc_overflow)
10474 bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
10475 (*parent)->howto->name, (*parent)->addend,
10476 input_bfd, input_section, (*parent)->address)))
10479 case bfd_reloc_outofrange:
10488 if (reloc_vector != NULL)
10489 free (reloc_vector);
10493 if (reloc_vector != NULL)
10494 free (reloc_vector);
10498 /* Create a MIPS ELF linker hash table. */
10500 struct bfd_link_hash_table *
10501 _bfd_mips_elf_link_hash_table_create (bfd *abfd)
10503 struct mips_elf_link_hash_table *ret;
10504 bfd_size_type amt = sizeof (struct mips_elf_link_hash_table);
10506 ret = bfd_malloc (amt);
10510 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
10511 mips_elf_link_hash_newfunc,
10512 sizeof (struct mips_elf_link_hash_entry)))
10519 /* We no longer use this. */
10520 for (i = 0; i < SIZEOF_MIPS_DYNSYM_SECNAMES; i++)
10521 ret->dynsym_sec_strindex[i] = (bfd_size_type) -1;
10523 ret->procedure_count = 0;
10524 ret->compact_rel_size = 0;
10525 ret->use_rld_obj_head = FALSE;
10526 ret->rld_value = 0;
10527 ret->mips16_stubs_seen = FALSE;
10528 ret->computed_got_sizes = FALSE;
10529 ret->is_vxworks = FALSE;
10530 ret->small_data_overflow_reported = FALSE;
10531 ret->srelbss = NULL;
10532 ret->sdynbss = NULL;
10533 ret->srelplt = NULL;
10534 ret->srelplt2 = NULL;
10535 ret->sgotplt = NULL;
10537 ret->plt_header_size = 0;
10538 ret->plt_entry_size = 0;
10539 ret->function_stub_size = 0;
10541 return &ret->root.root;
10544 /* Likewise, but indicate that the target is VxWorks. */
10546 struct bfd_link_hash_table *
10547 _bfd_mips_vxworks_link_hash_table_create (bfd *abfd)
10549 struct bfd_link_hash_table *ret;
10551 ret = _bfd_mips_elf_link_hash_table_create (abfd);
10554 struct mips_elf_link_hash_table *htab;
10556 htab = (struct mips_elf_link_hash_table *) ret;
10557 htab->is_vxworks = 1;
10562 /* We need to use a special link routine to handle the .reginfo and
10563 the .mdebug sections. We need to merge all instances of these
10564 sections together, not write them all out sequentially. */
10567 _bfd_mips_elf_final_link (bfd *abfd, struct bfd_link_info *info)
10570 struct bfd_link_order *p;
10571 asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
10572 asection *rtproc_sec;
10573 Elf32_RegInfo reginfo;
10574 struct ecoff_debug_info debug;
10575 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10576 const struct ecoff_debug_swap *swap = bed->elf_backend_ecoff_debug_swap;
10577 HDRR *symhdr = &debug.symbolic_header;
10578 void *mdebug_handle = NULL;
10583 struct mips_elf_link_hash_table *htab;
10585 static const char * const secname[] =
10587 ".text", ".init", ".fini", ".data",
10588 ".rodata", ".sdata", ".sbss", ".bss"
10590 static const int sc[] =
10592 scText, scInit, scFini, scData,
10593 scRData, scSData, scSBss, scBss
10596 /* We'd carefully arranged the dynamic symbol indices, and then the
10597 generic size_dynamic_sections renumbered them out from under us.
10598 Rather than trying somehow to prevent the renumbering, just do
10600 htab = mips_elf_hash_table (info);
10601 if (elf_hash_table (info)->dynamic_sections_created)
10605 struct mips_got_info *g;
10606 bfd_size_type dynsecsymcount;
10608 /* When we resort, we must tell mips_elf_sort_hash_table what
10609 the lowest index it may use is. That's the number of section
10610 symbols we're going to add. The generic ELF linker only
10611 adds these symbols when building a shared object. Note that
10612 we count the sections after (possibly) removing the .options
10615 dynsecsymcount = count_section_dynsyms (abfd, info);
10616 if (! mips_elf_sort_hash_table (info, dynsecsymcount + 1))
10619 /* Make sure we didn't grow the global .got region. */
10620 dynobj = elf_hash_table (info)->dynobj;
10621 got = mips_elf_got_section (dynobj, FALSE);
10622 g = mips_elf_section_data (got)->u.got_info;
10624 if (g->global_gotsym != NULL)
10625 BFD_ASSERT ((elf_hash_table (info)->dynsymcount
10626 - g->global_gotsym->dynindx)
10627 <= g->global_gotno);
10630 /* Get a value for the GP register. */
10631 if (elf_gp (abfd) == 0)
10633 struct bfd_link_hash_entry *h;
10635 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
10636 if (h != NULL && h->type == bfd_link_hash_defined)
10637 elf_gp (abfd) = (h->u.def.value
10638 + h->u.def.section->output_section->vma
10639 + h->u.def.section->output_offset);
10640 else if (htab->is_vxworks
10641 && (h = bfd_link_hash_lookup (info->hash,
10642 "_GLOBAL_OFFSET_TABLE_",
10643 FALSE, FALSE, TRUE))
10644 && h->type == bfd_link_hash_defined)
10645 elf_gp (abfd) = (h->u.def.section->output_section->vma
10646 + h->u.def.section->output_offset
10648 else if (info->relocatable)
10650 bfd_vma lo = MINUS_ONE;
10652 /* Find the GP-relative section with the lowest offset. */
10653 for (o = abfd->sections; o != NULL; o = o->next)
10655 && (elf_section_data (o)->this_hdr.sh_flags & SHF_MIPS_GPREL))
10658 /* And calculate GP relative to that. */
10659 elf_gp (abfd) = lo + ELF_MIPS_GP_OFFSET (info);
10663 /* If the relocate_section function needs to do a reloc
10664 involving the GP value, it should make a reloc_dangerous
10665 callback to warn that GP is not defined. */
10669 /* Go through the sections and collect the .reginfo and .mdebug
10671 reginfo_sec = NULL;
10673 gptab_data_sec = NULL;
10674 gptab_bss_sec = NULL;
10675 for (o = abfd->sections; o != NULL; o = o->next)
10677 if (strcmp (o->name, ".reginfo") == 0)
10679 memset (®info, 0, sizeof reginfo);
10681 /* We have found the .reginfo section in the output file.
10682 Look through all the link_orders comprising it and merge
10683 the information together. */
10684 for (p = o->map_head.link_order; p != NULL; p = p->next)
10686 asection *input_section;
10688 Elf32_External_RegInfo ext;
10691 if (p->type != bfd_indirect_link_order)
10693 if (p->type == bfd_data_link_order)
10698 input_section = p->u.indirect.section;
10699 input_bfd = input_section->owner;
10701 if (! bfd_get_section_contents (input_bfd, input_section,
10702 &ext, 0, sizeof ext))
10705 bfd_mips_elf32_swap_reginfo_in (input_bfd, &ext, &sub);
10707 reginfo.ri_gprmask |= sub.ri_gprmask;
10708 reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
10709 reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
10710 reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
10711 reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
10713 /* ri_gp_value is set by the function
10714 mips_elf32_section_processing when the section is
10715 finally written out. */
10717 /* Hack: reset the SEC_HAS_CONTENTS flag so that
10718 elf_link_input_bfd ignores this section. */
10719 input_section->flags &= ~SEC_HAS_CONTENTS;
10722 /* Size has been set in _bfd_mips_elf_always_size_sections. */
10723 BFD_ASSERT(o->size == sizeof (Elf32_External_RegInfo));
10725 /* Skip this section later on (I don't think this currently
10726 matters, but someday it might). */
10727 o->map_head.link_order = NULL;
10732 if (strcmp (o->name, ".mdebug") == 0)
10734 struct extsym_info einfo;
10737 /* We have found the .mdebug section in the output file.
10738 Look through all the link_orders comprising it and merge
10739 the information together. */
10740 symhdr->magic = swap->sym_magic;
10741 /* FIXME: What should the version stamp be? */
10742 symhdr->vstamp = 0;
10743 symhdr->ilineMax = 0;
10744 symhdr->cbLine = 0;
10745 symhdr->idnMax = 0;
10746 symhdr->ipdMax = 0;
10747 symhdr->isymMax = 0;
10748 symhdr->ioptMax = 0;
10749 symhdr->iauxMax = 0;
10750 symhdr->issMax = 0;
10751 symhdr->issExtMax = 0;
10752 symhdr->ifdMax = 0;
10754 symhdr->iextMax = 0;
10756 /* We accumulate the debugging information itself in the
10757 debug_info structure. */
10759 debug.external_dnr = NULL;
10760 debug.external_pdr = NULL;
10761 debug.external_sym = NULL;
10762 debug.external_opt = NULL;
10763 debug.external_aux = NULL;
10765 debug.ssext = debug.ssext_end = NULL;
10766 debug.external_fdr = NULL;
10767 debug.external_rfd = NULL;
10768 debug.external_ext = debug.external_ext_end = NULL;
10770 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
10771 if (mdebug_handle == NULL)
10775 esym.cobol_main = 0;
10779 esym.asym.iss = issNil;
10780 esym.asym.st = stLocal;
10781 esym.asym.reserved = 0;
10782 esym.asym.index = indexNil;
10784 for (i = 0; i < sizeof (secname) / sizeof (secname[0]); i++)
10786 esym.asym.sc = sc[i];
10787 s = bfd_get_section_by_name (abfd, secname[i]);
10790 esym.asym.value = s->vma;
10791 last = s->vma + s->size;
10794 esym.asym.value = last;
10795 if (!bfd_ecoff_debug_one_external (abfd, &debug, swap,
10796 secname[i], &esym))
10800 for (p = o->map_head.link_order; p != NULL; p = p->next)
10802 asection *input_section;
10804 const struct ecoff_debug_swap *input_swap;
10805 struct ecoff_debug_info input_debug;
10809 if (p->type != bfd_indirect_link_order)
10811 if (p->type == bfd_data_link_order)
10816 input_section = p->u.indirect.section;
10817 input_bfd = input_section->owner;
10819 if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
10820 || (get_elf_backend_data (input_bfd)
10821 ->elf_backend_ecoff_debug_swap) == NULL)
10823 /* I don't know what a non MIPS ELF bfd would be
10824 doing with a .mdebug section, but I don't really
10825 want to deal with it. */
10829 input_swap = (get_elf_backend_data (input_bfd)
10830 ->elf_backend_ecoff_debug_swap);
10832 BFD_ASSERT (p->size == input_section->size);
10834 /* The ECOFF linking code expects that we have already
10835 read in the debugging information and set up an
10836 ecoff_debug_info structure, so we do that now. */
10837 if (! _bfd_mips_elf_read_ecoff_info (input_bfd, input_section,
10841 if (! (bfd_ecoff_debug_accumulate
10842 (mdebug_handle, abfd, &debug, swap, input_bfd,
10843 &input_debug, input_swap, info)))
10846 /* Loop through the external symbols. For each one with
10847 interesting information, try to find the symbol in
10848 the linker global hash table and save the information
10849 for the output external symbols. */
10850 eraw_src = input_debug.external_ext;
10851 eraw_end = (eraw_src
10852 + (input_debug.symbolic_header.iextMax
10853 * input_swap->external_ext_size));
10855 eraw_src < eraw_end;
10856 eraw_src += input_swap->external_ext_size)
10860 struct mips_elf_link_hash_entry *h;
10862 (*input_swap->swap_ext_in) (input_bfd, eraw_src, &ext);
10863 if (ext.asym.sc == scNil
10864 || ext.asym.sc == scUndefined
10865 || ext.asym.sc == scSUndefined)
10868 name = input_debug.ssext + ext.asym.iss;
10869 h = mips_elf_link_hash_lookup (mips_elf_hash_table (info),
10870 name, FALSE, FALSE, TRUE);
10871 if (h == NULL || h->esym.ifd != -2)
10876 BFD_ASSERT (ext.ifd
10877 < input_debug.symbolic_header.ifdMax);
10878 ext.ifd = input_debug.ifdmap[ext.ifd];
10884 /* Free up the information we just read. */
10885 free (input_debug.line);
10886 free (input_debug.external_dnr);
10887 free (input_debug.external_pdr);
10888 free (input_debug.external_sym);
10889 free (input_debug.external_opt);
10890 free (input_debug.external_aux);
10891 free (input_debug.ss);
10892 free (input_debug.ssext);
10893 free (input_debug.external_fdr);
10894 free (input_debug.external_rfd);
10895 free (input_debug.external_ext);
10897 /* Hack: reset the SEC_HAS_CONTENTS flag so that
10898 elf_link_input_bfd ignores this section. */
10899 input_section->flags &= ~SEC_HAS_CONTENTS;
10902 if (SGI_COMPAT (abfd) && info->shared)
10904 /* Create .rtproc section. */
10905 rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
10906 if (rtproc_sec == NULL)
10908 flagword flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
10909 | SEC_LINKER_CREATED | SEC_READONLY);
10911 rtproc_sec = bfd_make_section_with_flags (abfd,
10914 if (rtproc_sec == NULL
10915 || ! bfd_set_section_alignment (abfd, rtproc_sec, 4))
10919 if (! mips_elf_create_procedure_table (mdebug_handle, abfd,
10925 /* Build the external symbol information. */
10928 einfo.debug = &debug;
10930 einfo.failed = FALSE;
10931 mips_elf_link_hash_traverse (mips_elf_hash_table (info),
10932 mips_elf_output_extsym, &einfo);
10936 /* Set the size of the .mdebug section. */
10937 o->size = bfd_ecoff_debug_size (abfd, &debug, swap);
10939 /* Skip this section later on (I don't think this currently
10940 matters, but someday it might). */
10941 o->map_head.link_order = NULL;
10946 if (CONST_STRNEQ (o->name, ".gptab."))
10948 const char *subname;
10951 Elf32_External_gptab *ext_tab;
10954 /* The .gptab.sdata and .gptab.sbss sections hold
10955 information describing how the small data area would
10956 change depending upon the -G switch. These sections
10957 not used in executables files. */
10958 if (! info->relocatable)
10960 for (p = o->map_head.link_order; p != NULL; p = p->next)
10962 asection *input_section;
10964 if (p->type != bfd_indirect_link_order)
10966 if (p->type == bfd_data_link_order)
10971 input_section = p->u.indirect.section;
10973 /* Hack: reset the SEC_HAS_CONTENTS flag so that
10974 elf_link_input_bfd ignores this section. */
10975 input_section->flags &= ~SEC_HAS_CONTENTS;
10978 /* Skip this section later on (I don't think this
10979 currently matters, but someday it might). */
10980 o->map_head.link_order = NULL;
10982 /* Really remove the section. */
10983 bfd_section_list_remove (abfd, o);
10984 --abfd->section_count;
10989 /* There is one gptab for initialized data, and one for
10990 uninitialized data. */
10991 if (strcmp (o->name, ".gptab.sdata") == 0)
10992 gptab_data_sec = o;
10993 else if (strcmp (o->name, ".gptab.sbss") == 0)
10997 (*_bfd_error_handler)
10998 (_("%s: illegal section name `%s'"),
10999 bfd_get_filename (abfd), o->name);
11000 bfd_set_error (bfd_error_nonrepresentable_section);
11004 /* The linker script always combines .gptab.data and
11005 .gptab.sdata into .gptab.sdata, and likewise for
11006 .gptab.bss and .gptab.sbss. It is possible that there is
11007 no .sdata or .sbss section in the output file, in which
11008 case we must change the name of the output section. */
11009 subname = o->name + sizeof ".gptab" - 1;
11010 if (bfd_get_section_by_name (abfd, subname) == NULL)
11012 if (o == gptab_data_sec)
11013 o->name = ".gptab.data";
11015 o->name = ".gptab.bss";
11016 subname = o->name + sizeof ".gptab" - 1;
11017 BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
11020 /* Set up the first entry. */
11022 amt = c * sizeof (Elf32_gptab);
11023 tab = bfd_malloc (amt);
11026 tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
11027 tab[0].gt_header.gt_unused = 0;
11029 /* Combine the input sections. */
11030 for (p = o->map_head.link_order; p != NULL; p = p->next)
11032 asection *input_section;
11034 bfd_size_type size;
11035 unsigned long last;
11036 bfd_size_type gpentry;
11038 if (p->type != bfd_indirect_link_order)
11040 if (p->type == bfd_data_link_order)
11045 input_section = p->u.indirect.section;
11046 input_bfd = input_section->owner;
11048 /* Combine the gptab entries for this input section one
11049 by one. We know that the input gptab entries are
11050 sorted by ascending -G value. */
11051 size = input_section->size;
11053 for (gpentry = sizeof (Elf32_External_gptab);
11055 gpentry += sizeof (Elf32_External_gptab))
11057 Elf32_External_gptab ext_gptab;
11058 Elf32_gptab int_gptab;
11064 if (! (bfd_get_section_contents
11065 (input_bfd, input_section, &ext_gptab, gpentry,
11066 sizeof (Elf32_External_gptab))))
11072 bfd_mips_elf32_swap_gptab_in (input_bfd, &ext_gptab,
11074 val = int_gptab.gt_entry.gt_g_value;
11075 add = int_gptab.gt_entry.gt_bytes - last;
11078 for (look = 1; look < c; look++)
11080 if (tab[look].gt_entry.gt_g_value >= val)
11081 tab[look].gt_entry.gt_bytes += add;
11083 if (tab[look].gt_entry.gt_g_value == val)
11089 Elf32_gptab *new_tab;
11092 /* We need a new table entry. */
11093 amt = (bfd_size_type) (c + 1) * sizeof (Elf32_gptab);
11094 new_tab = bfd_realloc (tab, amt);
11095 if (new_tab == NULL)
11101 tab[c].gt_entry.gt_g_value = val;
11102 tab[c].gt_entry.gt_bytes = add;
11104 /* Merge in the size for the next smallest -G
11105 value, since that will be implied by this new
11108 for (look = 1; look < c; look++)
11110 if (tab[look].gt_entry.gt_g_value < val
11112 || (tab[look].gt_entry.gt_g_value
11113 > tab[max].gt_entry.gt_g_value)))
11117 tab[c].gt_entry.gt_bytes +=
11118 tab[max].gt_entry.gt_bytes;
11123 last = int_gptab.gt_entry.gt_bytes;
11126 /* Hack: reset the SEC_HAS_CONTENTS flag so that
11127 elf_link_input_bfd ignores this section. */
11128 input_section->flags &= ~SEC_HAS_CONTENTS;
11131 /* The table must be sorted by -G value. */
11133 qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
11135 /* Swap out the table. */
11136 amt = (bfd_size_type) c * sizeof (Elf32_External_gptab);
11137 ext_tab = bfd_alloc (abfd, amt);
11138 if (ext_tab == NULL)
11144 for (j = 0; j < c; j++)
11145 bfd_mips_elf32_swap_gptab_out (abfd, tab + j, ext_tab + j);
11148 o->size = c * sizeof (Elf32_External_gptab);
11149 o->contents = (bfd_byte *) ext_tab;
11151 /* Skip this section later on (I don't think this currently
11152 matters, but someday it might). */
11153 o->map_head.link_order = NULL;
11157 /* Invoke the regular ELF backend linker to do all the work. */
11158 if (!bfd_elf_final_link (abfd, info))
11161 /* Now write out the computed sections. */
11163 if (reginfo_sec != NULL)
11165 Elf32_External_RegInfo ext;
11167 bfd_mips_elf32_swap_reginfo_out (abfd, ®info, &ext);
11168 if (! bfd_set_section_contents (abfd, reginfo_sec, &ext, 0, sizeof ext))
11172 if (mdebug_sec != NULL)
11174 BFD_ASSERT (abfd->output_has_begun);
11175 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
11177 mdebug_sec->filepos))
11180 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
11183 if (gptab_data_sec != NULL)
11185 if (! bfd_set_section_contents (abfd, gptab_data_sec,
11186 gptab_data_sec->contents,
11187 0, gptab_data_sec->size))
11191 if (gptab_bss_sec != NULL)
11193 if (! bfd_set_section_contents (abfd, gptab_bss_sec,
11194 gptab_bss_sec->contents,
11195 0, gptab_bss_sec->size))
11199 if (SGI_COMPAT (abfd))
11201 rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
11202 if (rtproc_sec != NULL)
11204 if (! bfd_set_section_contents (abfd, rtproc_sec,
11205 rtproc_sec->contents,
11206 0, rtproc_sec->size))
11214 /* Structure for saying that BFD machine EXTENSION extends BASE. */
11216 struct mips_mach_extension {
11217 unsigned long extension, base;
11221 /* An array describing how BFD machines relate to one another. The entries
11222 are ordered topologically with MIPS I extensions listed last. */
11224 static const struct mips_mach_extension mips_mach_extensions[] = {
11225 /* MIPS64r2 extensions. */
11226 { bfd_mach_mips_octeon, bfd_mach_mipsisa64r2 },
11228 /* MIPS64 extensions. */
11229 { bfd_mach_mipsisa64r2, bfd_mach_mipsisa64 },
11230 { bfd_mach_mips_sb1, bfd_mach_mipsisa64 },
11232 /* MIPS V extensions. */
11233 { bfd_mach_mipsisa64, bfd_mach_mips5 },
11235 /* R10000 extensions. */
11236 { bfd_mach_mips12000, bfd_mach_mips10000 },
11238 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
11239 vr5400 ISA, but doesn't include the multimedia stuff. It seems
11240 better to allow vr5400 and vr5500 code to be merged anyway, since
11241 many libraries will just use the core ISA. Perhaps we could add
11242 some sort of ASE flag if this ever proves a problem. */
11243 { bfd_mach_mips5500, bfd_mach_mips5400 },
11244 { bfd_mach_mips5400, bfd_mach_mips5000 },
11246 /* MIPS IV extensions. */
11247 { bfd_mach_mips5, bfd_mach_mips8000 },
11248 { bfd_mach_mips10000, bfd_mach_mips8000 },
11249 { bfd_mach_mips5000, bfd_mach_mips8000 },
11250 { bfd_mach_mips7000, bfd_mach_mips8000 },
11251 { bfd_mach_mips9000, bfd_mach_mips8000 },
11253 /* VR4100 extensions. */
11254 { bfd_mach_mips4120, bfd_mach_mips4100 },
11255 { bfd_mach_mips4111, bfd_mach_mips4100 },
11257 /* MIPS III extensions. */
11258 { bfd_mach_mips_loongson_2e, bfd_mach_mips4000 },
11259 { bfd_mach_mips_loongson_2f, bfd_mach_mips4000 },
11260 { bfd_mach_mips8000, bfd_mach_mips4000 },
11261 { bfd_mach_mips4650, bfd_mach_mips4000 },
11262 { bfd_mach_mips4600, bfd_mach_mips4000 },
11263 { bfd_mach_mips4400, bfd_mach_mips4000 },
11264 { bfd_mach_mips4300, bfd_mach_mips4000 },
11265 { bfd_mach_mips4100, bfd_mach_mips4000 },
11266 { bfd_mach_mips4010, bfd_mach_mips4000 },
11268 /* MIPS32 extensions. */
11269 { bfd_mach_mipsisa32r2, bfd_mach_mipsisa32 },
11271 /* MIPS II extensions. */
11272 { bfd_mach_mips4000, bfd_mach_mips6000 },
11273 { bfd_mach_mipsisa32, bfd_mach_mips6000 },
11275 /* MIPS I extensions. */
11276 { bfd_mach_mips6000, bfd_mach_mips3000 },
11277 { bfd_mach_mips3900, bfd_mach_mips3000 }
11281 /* Return true if bfd machine EXTENSION is an extension of machine BASE. */
11284 mips_mach_extends_p (unsigned long base, unsigned long extension)
11288 if (extension == base)
11291 if (base == bfd_mach_mipsisa32
11292 && mips_mach_extends_p (bfd_mach_mipsisa64, extension))
11295 if (base == bfd_mach_mipsisa32r2
11296 && mips_mach_extends_p (bfd_mach_mipsisa64r2, extension))
11299 for (i = 0; i < ARRAY_SIZE (mips_mach_extensions); i++)
11300 if (extension == mips_mach_extensions[i].extension)
11302 extension = mips_mach_extensions[i].base;
11303 if (extension == base)
11311 /* Return true if the given ELF header flags describe a 32-bit binary. */
11314 mips_32bit_flags_p (flagword flags)
11316 return ((flags & EF_MIPS_32BITMODE) != 0
11317 || (flags & EF_MIPS_ABI) == E_MIPS_ABI_O32
11318 || (flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32
11319 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1
11320 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2
11321 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32
11322 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2);
11326 /* Merge object attributes from IBFD into OBFD. Raise an error if
11327 there are conflicting attributes. */
11329 mips_elf_merge_obj_attributes (bfd *ibfd, bfd *obfd)
11331 obj_attribute *in_attr;
11332 obj_attribute *out_attr;
11334 if (!elf_known_obj_attributes_proc (obfd)[0].i)
11336 /* This is the first object. Copy the attributes. */
11337 _bfd_elf_copy_obj_attributes (ibfd, obfd);
11339 /* Use the Tag_null value to indicate the attributes have been
11341 elf_known_obj_attributes_proc (obfd)[0].i = 1;
11346 /* Check for conflicting Tag_GNU_MIPS_ABI_FP attributes and merge
11347 non-conflicting ones. */
11348 in_attr = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
11349 out_attr = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
11350 if (in_attr[Tag_GNU_MIPS_ABI_FP].i != out_attr[Tag_GNU_MIPS_ABI_FP].i)
11352 out_attr[Tag_GNU_MIPS_ABI_FP].type = 1;
11353 if (out_attr[Tag_GNU_MIPS_ABI_FP].i == 0)
11354 out_attr[Tag_GNU_MIPS_ABI_FP].i = in_attr[Tag_GNU_MIPS_ABI_FP].i;
11355 else if (in_attr[Tag_GNU_MIPS_ABI_FP].i == 0)
11357 else if (in_attr[Tag_GNU_MIPS_ABI_FP].i > 4)
11359 (_("Warning: %B uses unknown floating point ABI %d"), ibfd,
11360 in_attr[Tag_GNU_MIPS_ABI_FP].i);
11361 else if (out_attr[Tag_GNU_MIPS_ABI_FP].i > 4)
11363 (_("Warning: %B uses unknown floating point ABI %d"), obfd,
11364 out_attr[Tag_GNU_MIPS_ABI_FP].i);
11366 switch (out_attr[Tag_GNU_MIPS_ABI_FP].i)
11369 switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
11373 (_("Warning: %B uses -msingle-float, %B uses -mdouble-float"),
11379 (_("Warning: %B uses hard float, %B uses soft float"),
11385 (_("Warning: %B uses -msingle-float, %B uses -mips32r2 -mfp64"),
11395 switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
11399 (_("Warning: %B uses -msingle-float, %B uses -mdouble-float"),
11405 (_("Warning: %B uses hard float, %B uses soft float"),
11411 (_("Warning: %B uses -mdouble-float, %B uses -mips32r2 -mfp64"),
11421 switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
11427 (_("Warning: %B uses hard float, %B uses soft float"),
11437 switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
11441 (_("Warning: %B uses -msingle-float, %B uses -mips32r2 -mfp64"),
11447 (_("Warning: %B uses -mdouble-float, %B uses -mips32r2 -mfp64"),
11453 (_("Warning: %B uses hard float, %B uses soft float"),
11467 /* Merge Tag_compatibility attributes and any common GNU ones. */
11468 _bfd_elf_merge_object_attributes (ibfd, obfd);
11473 /* Merge backend specific data from an object file to the output
11474 object file when linking. */
11477 _bfd_mips_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
11479 flagword old_flags;
11480 flagword new_flags;
11482 bfd_boolean null_input_bfd = TRUE;
11485 /* Check if we have the same endianess */
11486 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
11488 (*_bfd_error_handler)
11489 (_("%B: endianness incompatible with that of the selected emulation"),
11494 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
11495 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
11498 if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
11500 (*_bfd_error_handler)
11501 (_("%B: ABI is incompatible with that of the selected emulation"),
11506 if (!mips_elf_merge_obj_attributes (ibfd, obfd))
11509 new_flags = elf_elfheader (ibfd)->e_flags;
11510 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_NOREORDER;
11511 old_flags = elf_elfheader (obfd)->e_flags;
11513 if (! elf_flags_init (obfd))
11515 elf_flags_init (obfd) = TRUE;
11516 elf_elfheader (obfd)->e_flags = new_flags;
11517 elf_elfheader (obfd)->e_ident[EI_CLASS]
11518 = elf_elfheader (ibfd)->e_ident[EI_CLASS];
11520 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
11521 && (bfd_get_arch_info (obfd)->the_default
11522 || mips_mach_extends_p (bfd_get_mach (obfd),
11523 bfd_get_mach (ibfd))))
11525 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
11526 bfd_get_mach (ibfd)))
11533 /* Check flag compatibility. */
11535 new_flags &= ~EF_MIPS_NOREORDER;
11536 old_flags &= ~EF_MIPS_NOREORDER;
11538 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
11539 doesn't seem to matter. */
11540 new_flags &= ~EF_MIPS_XGOT;
11541 old_flags &= ~EF_MIPS_XGOT;
11543 /* MIPSpro generates ucode info in n64 objects. Again, we should
11544 just be able to ignore this. */
11545 new_flags &= ~EF_MIPS_UCODE;
11546 old_flags &= ~EF_MIPS_UCODE;
11548 /* Don't care about the PIC flags from dynamic objects; they are
11550 if ((new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0
11551 && (ibfd->flags & DYNAMIC) != 0)
11552 new_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
11554 if (new_flags == old_flags)
11557 /* Check to see if the input BFD actually contains any sections.
11558 If not, its flags may not have been initialised either, but it cannot
11559 actually cause any incompatibility. */
11560 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
11562 /* Ignore synthetic sections and empty .text, .data and .bss sections
11563 which are automatically generated by gas. */
11564 if (strcmp (sec->name, ".reginfo")
11565 && strcmp (sec->name, ".mdebug")
11567 || (strcmp (sec->name, ".text")
11568 && strcmp (sec->name, ".data")
11569 && strcmp (sec->name, ".bss"))))
11571 null_input_bfd = FALSE;
11575 if (null_input_bfd)
11580 if (((new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0)
11581 != ((old_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0))
11583 (*_bfd_error_handler)
11584 (_("%B: warning: linking PIC files with non-PIC files"),
11589 if (new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC))
11590 elf_elfheader (obfd)->e_flags |= EF_MIPS_CPIC;
11591 if (! (new_flags & EF_MIPS_PIC))
11592 elf_elfheader (obfd)->e_flags &= ~EF_MIPS_PIC;
11594 new_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
11595 old_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
11597 /* Compare the ISAs. */
11598 if (mips_32bit_flags_p (old_flags) != mips_32bit_flags_p (new_flags))
11600 (*_bfd_error_handler)
11601 (_("%B: linking 32-bit code with 64-bit code"),
11605 else if (!mips_mach_extends_p (bfd_get_mach (ibfd), bfd_get_mach (obfd)))
11607 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
11608 if (mips_mach_extends_p (bfd_get_mach (obfd), bfd_get_mach (ibfd)))
11610 /* Copy the architecture info from IBFD to OBFD. Also copy
11611 the 32-bit flag (if set) so that we continue to recognise
11612 OBFD as a 32-bit binary. */
11613 bfd_set_arch_info (obfd, bfd_get_arch_info (ibfd));
11614 elf_elfheader (obfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
11615 elf_elfheader (obfd)->e_flags
11616 |= new_flags & (EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
11618 /* Copy across the ABI flags if OBFD doesn't use them
11619 and if that was what caused us to treat IBFD as 32-bit. */
11620 if ((old_flags & EF_MIPS_ABI) == 0
11621 && mips_32bit_flags_p (new_flags)
11622 && !mips_32bit_flags_p (new_flags & ~EF_MIPS_ABI))
11623 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ABI;
11627 /* The ISAs aren't compatible. */
11628 (*_bfd_error_handler)
11629 (_("%B: linking %s module with previous %s modules"),
11631 bfd_printable_name (ibfd),
11632 bfd_printable_name (obfd));
11637 new_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
11638 old_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
11640 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
11641 does set EI_CLASS differently from any 32-bit ABI. */
11642 if ((new_flags & EF_MIPS_ABI) != (old_flags & EF_MIPS_ABI)
11643 || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
11644 != elf_elfheader (obfd)->e_ident[EI_CLASS]))
11646 /* Only error if both are set (to different values). */
11647 if (((new_flags & EF_MIPS_ABI) && (old_flags & EF_MIPS_ABI))
11648 || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
11649 != elf_elfheader (obfd)->e_ident[EI_CLASS]))
11651 (*_bfd_error_handler)
11652 (_("%B: ABI mismatch: linking %s module with previous %s modules"),
11654 elf_mips_abi_name (ibfd),
11655 elf_mips_abi_name (obfd));
11658 new_flags &= ~EF_MIPS_ABI;
11659 old_flags &= ~EF_MIPS_ABI;
11662 /* For now, allow arbitrary mixing of ASEs (retain the union). */
11663 if ((new_flags & EF_MIPS_ARCH_ASE) != (old_flags & EF_MIPS_ARCH_ASE))
11665 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ARCH_ASE;
11667 new_flags &= ~ EF_MIPS_ARCH_ASE;
11668 old_flags &= ~ EF_MIPS_ARCH_ASE;
11671 /* Warn about any other mismatches */
11672 if (new_flags != old_flags)
11674 (*_bfd_error_handler)
11675 (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
11676 ibfd, (unsigned long) new_flags,
11677 (unsigned long) old_flags);
11683 bfd_set_error (bfd_error_bad_value);
11690 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
11693 _bfd_mips_elf_set_private_flags (bfd *abfd, flagword flags)
11695 BFD_ASSERT (!elf_flags_init (abfd)
11696 || elf_elfheader (abfd)->e_flags == flags);
11698 elf_elfheader (abfd)->e_flags = flags;
11699 elf_flags_init (abfd) = TRUE;
11704 _bfd_mips_elf_print_private_bfd_data (bfd *abfd, void *ptr)
11708 BFD_ASSERT (abfd != NULL && ptr != NULL);
11710 /* Print normal ELF private data. */
11711 _bfd_elf_print_private_bfd_data (abfd, ptr);
11713 /* xgettext:c-format */
11714 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
11716 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32)
11717 fprintf (file, _(" [abi=O32]"));
11718 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O64)
11719 fprintf (file, _(" [abi=O64]"));
11720 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32)
11721 fprintf (file, _(" [abi=EABI32]"));
11722 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
11723 fprintf (file, _(" [abi=EABI64]"));
11724 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI))
11725 fprintf (file, _(" [abi unknown]"));
11726 else if (ABI_N32_P (abfd))
11727 fprintf (file, _(" [abi=N32]"));
11728 else if (ABI_64_P (abfd))
11729 fprintf (file, _(" [abi=64]"));
11731 fprintf (file, _(" [no abi set]"));
11733 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
11734 fprintf (file, " [mips1]");
11735 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
11736 fprintf (file, " [mips2]");
11737 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
11738 fprintf (file, " [mips3]");
11739 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
11740 fprintf (file, " [mips4]");
11741 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5)
11742 fprintf (file, " [mips5]");
11743 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32)
11744 fprintf (file, " [mips32]");
11745 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64)
11746 fprintf (file, " [mips64]");
11747 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2)
11748 fprintf (file, " [mips32r2]");
11749 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R2)
11750 fprintf (file, " [mips64r2]");
11752 fprintf (file, _(" [unknown ISA]"));
11754 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MDMX)
11755 fprintf (file, " [mdmx]");
11757 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_M16)
11758 fprintf (file, " [mips16]");
11760 if (elf_elfheader (abfd)->e_flags & EF_MIPS_32BITMODE)
11761 fprintf (file, " [32bitmode]");
11763 fprintf (file, _(" [not 32bitmode]"));
11765 if (elf_elfheader (abfd)->e_flags & EF_MIPS_NOREORDER)
11766 fprintf (file, " [noreorder]");
11768 if (elf_elfheader (abfd)->e_flags & EF_MIPS_PIC)
11769 fprintf (file, " [PIC]");
11771 if (elf_elfheader (abfd)->e_flags & EF_MIPS_CPIC)
11772 fprintf (file, " [CPIC]");
11774 if (elf_elfheader (abfd)->e_flags & EF_MIPS_XGOT)
11775 fprintf (file, " [XGOT]");
11777 if (elf_elfheader (abfd)->e_flags & EF_MIPS_UCODE)
11778 fprintf (file, " [UCODE]");
11780 fputc ('\n', file);
11785 const struct bfd_elf_special_section _bfd_mips_elf_special_sections[] =
11787 { STRING_COMMA_LEN (".lit4"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
11788 { STRING_COMMA_LEN (".lit8"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
11789 { STRING_COMMA_LEN (".mdebug"), 0, SHT_MIPS_DEBUG, 0 },
11790 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
11791 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
11792 { STRING_COMMA_LEN (".ucode"), 0, SHT_MIPS_UCODE, 0 },
11793 { NULL, 0, 0, 0, 0 }
11796 /* Merge non visibility st_other attributes. Ensure that the
11797 STO_OPTIONAL flag is copied into h->other, even if this is not a
11798 definiton of the symbol. */
11800 _bfd_mips_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
11801 const Elf_Internal_Sym *isym,
11802 bfd_boolean definition,
11803 bfd_boolean dynamic ATTRIBUTE_UNUSED)
11805 if ((isym->st_other & ~ELF_ST_VISIBILITY (-1)) != 0)
11807 unsigned char other;
11809 other = (definition ? isym->st_other : h->other);
11810 other &= ~ELF_ST_VISIBILITY (-1);
11811 h->other = other | ELF_ST_VISIBILITY (h->other);
11815 && ELF_MIPS_IS_OPTIONAL (isym->st_other))
11816 h->other |= STO_OPTIONAL;
11819 /* Decide whether an undefined symbol is special and can be ignored.
11820 This is the case for OPTIONAL symbols on IRIX. */
11822 _bfd_mips_elf_ignore_undef_symbol (struct elf_link_hash_entry *h)
11824 return ELF_MIPS_IS_OPTIONAL (h->other) ? TRUE : FALSE;
11828 _bfd_mips_elf_common_definition (Elf_Internal_Sym *sym)
11830 return (sym->st_shndx == SHN_COMMON
11831 || sym->st_shndx == SHN_MIPS_ACOMMON
11832 || sym->st_shndx == SHN_MIPS_SCOMMON);