1 /* MIPS-specific support for ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2005, 2006, 2007 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
;
5225 switch (flags
& EF_MIPS_ARCH
)
5229 return bfd_mach_mips3000
;
5232 return bfd_mach_mips6000
;
5235 return bfd_mach_mips4000
;
5238 return bfd_mach_mips8000
;
5241 return bfd_mach_mips5
;
5243 case E_MIPS_ARCH_32
:
5244 return bfd_mach_mipsisa32
;
5246 case E_MIPS_ARCH_64
:
5247 return bfd_mach_mipsisa64
;
5249 case E_MIPS_ARCH_32R2
:
5250 return bfd_mach_mipsisa32r2
;
5252 case E_MIPS_ARCH_64R2
:
5253 return bfd_mach_mipsisa64r2
;
5260 /* Return printable name for ABI. */
5262 static INLINE
char *
5263 elf_mips_abi_name (bfd
*abfd
)
5267 flags
= elf_elfheader (abfd
)->e_flags
;
5268 switch (flags
& EF_MIPS_ABI
)
5271 if (ABI_N32_P (abfd
))
5273 else if (ABI_64_P (abfd
))
5277 case E_MIPS_ABI_O32
:
5279 case E_MIPS_ABI_O64
:
5281 case E_MIPS_ABI_EABI32
:
5283 case E_MIPS_ABI_EABI64
:
5286 return "unknown abi";
5290 /* MIPS ELF uses two common sections. One is the usual one, and the
5291 other is for small objects. All the small objects are kept
5292 together, and then referenced via the gp pointer, which yields
5293 faster assembler code. This is what we use for the small common
5294 section. This approach is copied from ecoff.c. */
5295 static asection mips_elf_scom_section
;
5296 static asymbol mips_elf_scom_symbol
;
5297 static asymbol
*mips_elf_scom_symbol_ptr
;
5299 /* MIPS ELF also uses an acommon section, which represents an
5300 allocated common symbol which may be overridden by a
5301 definition in a shared library. */
5302 static asection mips_elf_acom_section
;
5303 static asymbol mips_elf_acom_symbol
;
5304 static asymbol
*mips_elf_acom_symbol_ptr
;
5306 /* Handle the special MIPS section numbers that a symbol may use.
5307 This is used for both the 32-bit and the 64-bit ABI. */
5310 _bfd_mips_elf_symbol_processing (bfd
*abfd
, asymbol
*asym
)
5312 elf_symbol_type
*elfsym
;
5314 elfsym
= (elf_symbol_type
*) asym
;
5315 switch (elfsym
->internal_elf_sym
.st_shndx
)
5317 case SHN_MIPS_ACOMMON
:
5318 /* This section is used in a dynamically linked executable file.
5319 It is an allocated common section. The dynamic linker can
5320 either resolve these symbols to something in a shared
5321 library, or it can just leave them here. For our purposes,
5322 we can consider these symbols to be in a new section. */
5323 if (mips_elf_acom_section
.name
== NULL
)
5325 /* Initialize the acommon section. */
5326 mips_elf_acom_section
.name
= ".acommon";
5327 mips_elf_acom_section
.flags
= SEC_ALLOC
;
5328 mips_elf_acom_section
.output_section
= &mips_elf_acom_section
;
5329 mips_elf_acom_section
.symbol
= &mips_elf_acom_symbol
;
5330 mips_elf_acom_section
.symbol_ptr_ptr
= &mips_elf_acom_symbol_ptr
;
5331 mips_elf_acom_symbol
.name
= ".acommon";
5332 mips_elf_acom_symbol
.flags
= BSF_SECTION_SYM
;
5333 mips_elf_acom_symbol
.section
= &mips_elf_acom_section
;
5334 mips_elf_acom_symbol_ptr
= &mips_elf_acom_symbol
;
5336 asym
->section
= &mips_elf_acom_section
;
5340 /* Common symbols less than the GP size are automatically
5341 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
5342 if (asym
->value
> elf_gp_size (abfd
)
5343 || ELF_ST_TYPE (elfsym
->internal_elf_sym
.st_info
) == STT_TLS
5344 || IRIX_COMPAT (abfd
) == ict_irix6
)
5347 case SHN_MIPS_SCOMMON
:
5348 if (mips_elf_scom_section
.name
== NULL
)
5350 /* Initialize the small common section. */
5351 mips_elf_scom_section
.name
= ".scommon";
5352 mips_elf_scom_section
.flags
= SEC_IS_COMMON
;
5353 mips_elf_scom_section
.output_section
= &mips_elf_scom_section
;
5354 mips_elf_scom_section
.symbol
= &mips_elf_scom_symbol
;
5355 mips_elf_scom_section
.symbol_ptr_ptr
= &mips_elf_scom_symbol_ptr
;
5356 mips_elf_scom_symbol
.name
= ".scommon";
5357 mips_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
5358 mips_elf_scom_symbol
.section
= &mips_elf_scom_section
;
5359 mips_elf_scom_symbol_ptr
= &mips_elf_scom_symbol
;
5361 asym
->section
= &mips_elf_scom_section
;
5362 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
5365 case SHN_MIPS_SUNDEFINED
:
5366 asym
->section
= bfd_und_section_ptr
;
5371 asection
*section
= bfd_get_section_by_name (abfd
, ".text");
5373 BFD_ASSERT (SGI_COMPAT (abfd
));
5374 if (section
!= NULL
)
5376 asym
->section
= section
;
5377 /* MIPS_TEXT is a bit special, the address is not an offset
5378 to the base of the .text section. So substract the section
5379 base address to make it an offset. */
5380 asym
->value
-= section
->vma
;
5387 asection
*section
= bfd_get_section_by_name (abfd
, ".data");
5389 BFD_ASSERT (SGI_COMPAT (abfd
));
5390 if (section
!= NULL
)
5392 asym
->section
= section
;
5393 /* MIPS_DATA is a bit special, the address is not an offset
5394 to the base of the .data section. So substract the section
5395 base address to make it an offset. */
5396 asym
->value
-= section
->vma
;
5403 /* Implement elf_backend_eh_frame_address_size. This differs from
5404 the default in the way it handles EABI64.
5406 EABI64 was originally specified as an LP64 ABI, and that is what
5407 -mabi=eabi normally gives on a 64-bit target. However, gcc has
5408 historically accepted the combination of -mabi=eabi and -mlong32,
5409 and this ILP32 variation has become semi-official over time.
5410 Both forms use elf32 and have pointer-sized FDE addresses.
5412 If an EABI object was generated by GCC 4.0 or above, it will have
5413 an empty .gcc_compiled_longXX section, where XX is the size of longs
5414 in bits. Unfortunately, ILP32 objects generated by earlier compilers
5415 have no special marking to distinguish them from LP64 objects.
5417 We don't want users of the official LP64 ABI to be punished for the
5418 existence of the ILP32 variant, but at the same time, we don't want
5419 to mistakenly interpret pre-4.0 ILP32 objects as being LP64 objects.
5420 We therefore take the following approach:
5422 - If ABFD contains a .gcc_compiled_longXX section, use it to
5423 determine the pointer size.
5425 - Otherwise check the type of the first relocation. Assume that
5426 the LP64 ABI is being used if the relocation is of type R_MIPS_64.
5430 The second check is enough to detect LP64 objects generated by pre-4.0
5431 compilers because, in the kind of output generated by those compilers,
5432 the first relocation will be associated with either a CIE personality
5433 routine or an FDE start address. Furthermore, the compilers never
5434 used a special (non-pointer) encoding for this ABI.
5436 Checking the relocation type should also be safe because there is no
5437 reason to use R_MIPS_64 in an ILP32 object. Pre-4.0 compilers never
5441 _bfd_mips_elf_eh_frame_address_size (bfd
*abfd
, asection
*sec
)
5443 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
5445 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
5447 bfd_boolean long32_p
, long64_p
;
5449 long32_p
= bfd_get_section_by_name (abfd
, ".gcc_compiled_long32") != 0;
5450 long64_p
= bfd_get_section_by_name (abfd
, ".gcc_compiled_long64") != 0;
5451 if (long32_p
&& long64_p
)
5458 if (sec
->reloc_count
> 0
5459 && elf_section_data (sec
)->relocs
!= NULL
5460 && (ELF32_R_TYPE (elf_section_data (sec
)->relocs
[0].r_info
)
5469 /* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
5470 relocations against two unnamed section symbols to resolve to the
5471 same address. For example, if we have code like:
5473 lw $4,%got_disp(.data)($gp)
5474 lw $25,%got_disp(.text)($gp)
5477 then the linker will resolve both relocations to .data and the program
5478 will jump there rather than to .text.
5480 We can work around this problem by giving names to local section symbols.
5481 This is also what the MIPSpro tools do. */
5484 _bfd_mips_elf_name_local_section_symbols (bfd
*abfd
)
5486 return SGI_COMPAT (abfd
);
5489 /* Work over a section just before writing it out. This routine is
5490 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
5491 sections that need the SHF_MIPS_GPREL flag by name; there has to be
5495 _bfd_mips_elf_section_processing (bfd
*abfd
, Elf_Internal_Shdr
*hdr
)
5497 if (hdr
->sh_type
== SHT_MIPS_REGINFO
5498 && hdr
->sh_size
> 0)
5502 BFD_ASSERT (hdr
->sh_size
== sizeof (Elf32_External_RegInfo
));
5503 BFD_ASSERT (hdr
->contents
== NULL
);
5506 hdr
->sh_offset
+ sizeof (Elf32_External_RegInfo
) - 4,
5509 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
5510 if (bfd_bwrite (buf
, 4, abfd
) != 4)
5514 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
5515 && hdr
->bfd_section
!= NULL
5516 && mips_elf_section_data (hdr
->bfd_section
) != NULL
5517 && mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
!= NULL
)
5519 bfd_byte
*contents
, *l
, *lend
;
5521 /* We stored the section contents in the tdata field in the
5522 set_section_contents routine. We save the section contents
5523 so that we don't have to read them again.
5524 At this point we know that elf_gp is set, so we can look
5525 through the section contents to see if there is an
5526 ODK_REGINFO structure. */
5528 contents
= mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
;
5530 lend
= contents
+ hdr
->sh_size
;
5531 while (l
+ sizeof (Elf_External_Options
) <= lend
)
5533 Elf_Internal_Options intopt
;
5535 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
5537 if (intopt
.size
< sizeof (Elf_External_Options
))
5539 (*_bfd_error_handler
)
5540 (_("%B: Warning: bad `%s' option size %u smaller than its header"),
5541 abfd
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
), intopt
.size
);
5544 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
5551 + sizeof (Elf_External_Options
)
5552 + (sizeof (Elf64_External_RegInfo
) - 8)),
5555 H_PUT_64 (abfd
, elf_gp (abfd
), buf
);
5556 if (bfd_bwrite (buf
, 8, abfd
) != 8)
5559 else if (intopt
.kind
== ODK_REGINFO
)
5566 + sizeof (Elf_External_Options
)
5567 + (sizeof (Elf32_External_RegInfo
) - 4)),
5570 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
5571 if (bfd_bwrite (buf
, 4, abfd
) != 4)
5578 if (hdr
->bfd_section
!= NULL
)
5580 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
5582 if (strcmp (name
, ".sdata") == 0
5583 || strcmp (name
, ".lit8") == 0
5584 || strcmp (name
, ".lit4") == 0)
5586 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
5587 hdr
->sh_type
= SHT_PROGBITS
;
5589 else if (strcmp (name
, ".sbss") == 0)
5591 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
5592 hdr
->sh_type
= SHT_NOBITS
;
5594 else if (strcmp (name
, ".srdata") == 0)
5596 hdr
->sh_flags
|= SHF_ALLOC
| SHF_MIPS_GPREL
;
5597 hdr
->sh_type
= SHT_PROGBITS
;
5599 else if (strcmp (name
, ".compact_rel") == 0)
5602 hdr
->sh_type
= SHT_PROGBITS
;
5604 else if (strcmp (name
, ".rtproc") == 0)
5606 if (hdr
->sh_addralign
!= 0 && hdr
->sh_entsize
== 0)
5608 unsigned int adjust
;
5610 adjust
= hdr
->sh_size
% hdr
->sh_addralign
;
5612 hdr
->sh_size
+= hdr
->sh_addralign
- adjust
;
5620 /* Handle a MIPS specific section when reading an object file. This
5621 is called when elfcode.h finds a section with an unknown type.
5622 This routine supports both the 32-bit and 64-bit ELF ABI.
5624 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
5628 _bfd_mips_elf_section_from_shdr (bfd
*abfd
,
5629 Elf_Internal_Shdr
*hdr
,
5635 /* There ought to be a place to keep ELF backend specific flags, but
5636 at the moment there isn't one. We just keep track of the
5637 sections by their name, instead. Fortunately, the ABI gives
5638 suggested names for all the MIPS specific sections, so we will
5639 probably get away with this. */
5640 switch (hdr
->sh_type
)
5642 case SHT_MIPS_LIBLIST
:
5643 if (strcmp (name
, ".liblist") != 0)
5647 if (strcmp (name
, ".msym") != 0)
5650 case SHT_MIPS_CONFLICT
:
5651 if (strcmp (name
, ".conflict") != 0)
5654 case SHT_MIPS_GPTAB
:
5655 if (! CONST_STRNEQ (name
, ".gptab."))
5658 case SHT_MIPS_UCODE
:
5659 if (strcmp (name
, ".ucode") != 0)
5662 case SHT_MIPS_DEBUG
:
5663 if (strcmp (name
, ".mdebug") != 0)
5665 flags
= SEC_DEBUGGING
;
5667 case SHT_MIPS_REGINFO
:
5668 if (strcmp (name
, ".reginfo") != 0
5669 || hdr
->sh_size
!= sizeof (Elf32_External_RegInfo
))
5671 flags
= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_SIZE
);
5673 case SHT_MIPS_IFACE
:
5674 if (strcmp (name
, ".MIPS.interfaces") != 0)
5677 case SHT_MIPS_CONTENT
:
5678 if (! CONST_STRNEQ (name
, ".MIPS.content"))
5681 case SHT_MIPS_OPTIONS
:
5682 if (!MIPS_ELF_OPTIONS_SECTION_NAME_P (name
))
5685 case SHT_MIPS_DWARF
:
5686 if (! CONST_STRNEQ (name
, ".debug_"))
5689 case SHT_MIPS_SYMBOL_LIB
:
5690 if (strcmp (name
, ".MIPS.symlib") != 0)
5693 case SHT_MIPS_EVENTS
:
5694 if (! CONST_STRNEQ (name
, ".MIPS.events")
5695 && ! CONST_STRNEQ (name
, ".MIPS.post_rel"))
5702 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
5707 if (! bfd_set_section_flags (abfd
, hdr
->bfd_section
,
5708 (bfd_get_section_flags (abfd
,
5714 /* FIXME: We should record sh_info for a .gptab section. */
5716 /* For a .reginfo section, set the gp value in the tdata information
5717 from the contents of this section. We need the gp value while
5718 processing relocs, so we just get it now. The .reginfo section
5719 is not used in the 64-bit MIPS ELF ABI. */
5720 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
5722 Elf32_External_RegInfo ext
;
5725 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
,
5726 &ext
, 0, sizeof ext
))
5728 bfd_mips_elf32_swap_reginfo_in (abfd
, &ext
, &s
);
5729 elf_gp (abfd
) = s
.ri_gp_value
;
5732 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
5733 set the gp value based on what we find. We may see both
5734 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
5735 they should agree. */
5736 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
)
5738 bfd_byte
*contents
, *l
, *lend
;
5740 contents
= bfd_malloc (hdr
->sh_size
);
5741 if (contents
== NULL
)
5743 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
,
5750 lend
= contents
+ hdr
->sh_size
;
5751 while (l
+ sizeof (Elf_External_Options
) <= lend
)
5753 Elf_Internal_Options intopt
;
5755 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
5757 if (intopt
.size
< sizeof (Elf_External_Options
))
5759 (*_bfd_error_handler
)
5760 (_("%B: Warning: bad `%s' option size %u smaller than its header"),
5761 abfd
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
), intopt
.size
);
5764 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
5766 Elf64_Internal_RegInfo intreg
;
5768 bfd_mips_elf64_swap_reginfo_in
5770 ((Elf64_External_RegInfo
*)
5771 (l
+ sizeof (Elf_External_Options
))),
5773 elf_gp (abfd
) = intreg
.ri_gp_value
;
5775 else if (intopt
.kind
== ODK_REGINFO
)
5777 Elf32_RegInfo intreg
;
5779 bfd_mips_elf32_swap_reginfo_in
5781 ((Elf32_External_RegInfo
*)
5782 (l
+ sizeof (Elf_External_Options
))),
5784 elf_gp (abfd
) = intreg
.ri_gp_value
;
5794 /* Set the correct type for a MIPS ELF section. We do this by the
5795 section name, which is a hack, but ought to work. This routine is
5796 used by both the 32-bit and the 64-bit ABI. */
5799 _bfd_mips_elf_fake_sections (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*sec
)
5801 const char *name
= bfd_get_section_name (abfd
, sec
);
5803 if (strcmp (name
, ".liblist") == 0)
5805 hdr
->sh_type
= SHT_MIPS_LIBLIST
;
5806 hdr
->sh_info
= sec
->size
/ sizeof (Elf32_Lib
);
5807 /* The sh_link field is set in final_write_processing. */
5809 else if (strcmp (name
, ".conflict") == 0)
5810 hdr
->sh_type
= SHT_MIPS_CONFLICT
;
5811 else if (CONST_STRNEQ (name
, ".gptab."))
5813 hdr
->sh_type
= SHT_MIPS_GPTAB
;
5814 hdr
->sh_entsize
= sizeof (Elf32_External_gptab
);
5815 /* The sh_info field is set in final_write_processing. */
5817 else if (strcmp (name
, ".ucode") == 0)
5818 hdr
->sh_type
= SHT_MIPS_UCODE
;
5819 else if (strcmp (name
, ".mdebug") == 0)
5821 hdr
->sh_type
= SHT_MIPS_DEBUG
;
5822 /* In a shared object on IRIX 5.3, the .mdebug section has an
5823 entsize of 0. FIXME: Does this matter? */
5824 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
5825 hdr
->sh_entsize
= 0;
5827 hdr
->sh_entsize
= 1;
5829 else if (strcmp (name
, ".reginfo") == 0)
5831 hdr
->sh_type
= SHT_MIPS_REGINFO
;
5832 /* In a shared object on IRIX 5.3, the .reginfo section has an
5833 entsize of 0x18. FIXME: Does this matter? */
5834 if (SGI_COMPAT (abfd
))
5836 if ((abfd
->flags
& DYNAMIC
) != 0)
5837 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
5839 hdr
->sh_entsize
= 1;
5842 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
5844 else if (SGI_COMPAT (abfd
)
5845 && (strcmp (name
, ".hash") == 0
5846 || strcmp (name
, ".dynamic") == 0
5847 || strcmp (name
, ".dynstr") == 0))
5849 if (SGI_COMPAT (abfd
))
5850 hdr
->sh_entsize
= 0;
5852 /* This isn't how the IRIX6 linker behaves. */
5853 hdr
->sh_info
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
5856 else if (strcmp (name
, ".got") == 0
5857 || strcmp (name
, ".srdata") == 0
5858 || strcmp (name
, ".sdata") == 0
5859 || strcmp (name
, ".sbss") == 0
5860 || strcmp (name
, ".lit4") == 0
5861 || strcmp (name
, ".lit8") == 0)
5862 hdr
->sh_flags
|= SHF_MIPS_GPREL
;
5863 else if (strcmp (name
, ".MIPS.interfaces") == 0)
5865 hdr
->sh_type
= SHT_MIPS_IFACE
;
5866 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
5868 else if (CONST_STRNEQ (name
, ".MIPS.content"))
5870 hdr
->sh_type
= SHT_MIPS_CONTENT
;
5871 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
5872 /* The sh_info field is set in final_write_processing. */
5874 else if (MIPS_ELF_OPTIONS_SECTION_NAME_P (name
))
5876 hdr
->sh_type
= SHT_MIPS_OPTIONS
;
5877 hdr
->sh_entsize
= 1;
5878 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
5880 else if (CONST_STRNEQ (name
, ".debug_"))
5882 hdr
->sh_type
= SHT_MIPS_DWARF
;
5884 /* Irix facilities such as libexc expect a single .debug_frame
5885 per executable, the system ones have NOSTRIP set and the linker
5886 doesn't merge sections with different flags so ... */
5887 if (SGI_COMPAT (abfd
) && CONST_STRNEQ (name
, ".debug_frame"))
5888 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
5890 else if (strcmp (name
, ".MIPS.symlib") == 0)
5892 hdr
->sh_type
= SHT_MIPS_SYMBOL_LIB
;
5893 /* The sh_link and sh_info fields are set in
5894 final_write_processing. */
5896 else if (CONST_STRNEQ (name
, ".MIPS.events")
5897 || CONST_STRNEQ (name
, ".MIPS.post_rel"))
5899 hdr
->sh_type
= SHT_MIPS_EVENTS
;
5900 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
5901 /* The sh_link field is set in final_write_processing. */
5903 else if (strcmp (name
, ".msym") == 0)
5905 hdr
->sh_type
= SHT_MIPS_MSYM
;
5906 hdr
->sh_flags
|= SHF_ALLOC
;
5907 hdr
->sh_entsize
= 8;
5910 /* The generic elf_fake_sections will set up REL_HDR using the default
5911 kind of relocations. We used to set up a second header for the
5912 non-default kind of relocations here, but only NewABI would use
5913 these, and the IRIX ld doesn't like resulting empty RELA sections.
5914 Thus we create those header only on demand now. */
5919 /* Given a BFD section, try to locate the corresponding ELF section
5920 index. This is used by both the 32-bit and the 64-bit ABI.
5921 Actually, it's not clear to me that the 64-bit ABI supports these,
5922 but for non-PIC objects we will certainly want support for at least
5923 the .scommon section. */
5926 _bfd_mips_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
5927 asection
*sec
, int *retval
)
5929 if (strcmp (bfd_get_section_name (abfd
, sec
), ".scommon") == 0)
5931 *retval
= SHN_MIPS_SCOMMON
;
5934 if (strcmp (bfd_get_section_name (abfd
, sec
), ".acommon") == 0)
5936 *retval
= SHN_MIPS_ACOMMON
;
5942 /* Hook called by the linker routine which adds symbols from an object
5943 file. We must handle the special MIPS section numbers here. */
5946 _bfd_mips_elf_add_symbol_hook (bfd
*abfd
, struct bfd_link_info
*info
,
5947 Elf_Internal_Sym
*sym
, const char **namep
,
5948 flagword
*flagsp ATTRIBUTE_UNUSED
,
5949 asection
**secp
, bfd_vma
*valp
)
5951 if (SGI_COMPAT (abfd
)
5952 && (abfd
->flags
& DYNAMIC
) != 0
5953 && strcmp (*namep
, "_rld_new_interface") == 0)
5955 /* Skip IRIX5 rld entry name. */
5960 /* Shared objects may have a dynamic symbol '_gp_disp' defined as
5961 a SECTION *ABS*. This causes ld to think it can resolve _gp_disp
5962 by setting a DT_NEEDED for the shared object. Since _gp_disp is
5963 a magic symbol resolved by the linker, we ignore this bogus definition
5964 of _gp_disp. New ABI objects do not suffer from this problem so this
5965 is not done for them. */
5967 && (sym
->st_shndx
== SHN_ABS
)
5968 && (strcmp (*namep
, "_gp_disp") == 0))
5974 switch (sym
->st_shndx
)
5977 /* Common symbols less than the GP size are automatically
5978 treated as SHN_MIPS_SCOMMON symbols. */
5979 if (sym
->st_size
> elf_gp_size (abfd
)
5980 || ELF_ST_TYPE (sym
->st_info
) == STT_TLS
5981 || IRIX_COMPAT (abfd
) == ict_irix6
)
5984 case SHN_MIPS_SCOMMON
:
5985 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
5986 (*secp
)->flags
|= SEC_IS_COMMON
;
5987 *valp
= sym
->st_size
;
5991 /* This section is used in a shared object. */
5992 if (elf_tdata (abfd
)->elf_text_section
== NULL
)
5994 asymbol
*elf_text_symbol
;
5995 asection
*elf_text_section
;
5996 bfd_size_type amt
= sizeof (asection
);
5998 elf_text_section
= bfd_zalloc (abfd
, amt
);
5999 if (elf_text_section
== NULL
)
6002 amt
= sizeof (asymbol
);
6003 elf_text_symbol
= bfd_zalloc (abfd
, amt
);
6004 if (elf_text_symbol
== NULL
)
6007 /* Initialize the section. */
6009 elf_tdata (abfd
)->elf_text_section
= elf_text_section
;
6010 elf_tdata (abfd
)->elf_text_symbol
= elf_text_symbol
;
6012 elf_text_section
->symbol
= elf_text_symbol
;
6013 elf_text_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_text_symbol
;
6015 elf_text_section
->name
= ".text";
6016 elf_text_section
->flags
= SEC_NO_FLAGS
;
6017 elf_text_section
->output_section
= NULL
;
6018 elf_text_section
->owner
= abfd
;
6019 elf_text_symbol
->name
= ".text";
6020 elf_text_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
6021 elf_text_symbol
->section
= elf_text_section
;
6023 /* This code used to do *secp = bfd_und_section_ptr if
6024 info->shared. I don't know why, and that doesn't make sense,
6025 so I took it out. */
6026 *secp
= elf_tdata (abfd
)->elf_text_section
;
6029 case SHN_MIPS_ACOMMON
:
6030 /* Fall through. XXX Can we treat this as allocated data? */
6032 /* This section is used in a shared object. */
6033 if (elf_tdata (abfd
)->elf_data_section
== NULL
)
6035 asymbol
*elf_data_symbol
;
6036 asection
*elf_data_section
;
6037 bfd_size_type amt
= sizeof (asection
);
6039 elf_data_section
= bfd_zalloc (abfd
, amt
);
6040 if (elf_data_section
== NULL
)
6043 amt
= sizeof (asymbol
);
6044 elf_data_symbol
= bfd_zalloc (abfd
, amt
);
6045 if (elf_data_symbol
== NULL
)
6048 /* Initialize the section. */
6050 elf_tdata (abfd
)->elf_data_section
= elf_data_section
;
6051 elf_tdata (abfd
)->elf_data_symbol
= elf_data_symbol
;
6053 elf_data_section
->symbol
= elf_data_symbol
;
6054 elf_data_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_data_symbol
;
6056 elf_data_section
->name
= ".data";
6057 elf_data_section
->flags
= SEC_NO_FLAGS
;
6058 elf_data_section
->output_section
= NULL
;
6059 elf_data_section
->owner
= abfd
;
6060 elf_data_symbol
->name
= ".data";
6061 elf_data_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
6062 elf_data_symbol
->section
= elf_data_section
;
6064 /* This code used to do *secp = bfd_und_section_ptr if
6065 info->shared. I don't know why, and that doesn't make sense,
6066 so I took it out. */
6067 *secp
= elf_tdata (abfd
)->elf_data_section
;
6070 case SHN_MIPS_SUNDEFINED
:
6071 *secp
= bfd_und_section_ptr
;
6075 if (SGI_COMPAT (abfd
)
6077 && info
->hash
->creator
== abfd
->xvec
6078 && strcmp (*namep
, "__rld_obj_head") == 0)
6080 struct elf_link_hash_entry
*h
;
6081 struct bfd_link_hash_entry
*bh
;
6083 /* Mark __rld_obj_head as dynamic. */
6085 if (! (_bfd_generic_link_add_one_symbol
6086 (info
, abfd
, *namep
, BSF_GLOBAL
, *secp
, *valp
, NULL
, FALSE
,
6087 get_elf_backend_data (abfd
)->collect
, &bh
)))
6090 h
= (struct elf_link_hash_entry
*) bh
;
6093 h
->type
= STT_OBJECT
;
6095 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
6098 mips_elf_hash_table (info
)->use_rld_obj_head
= TRUE
;
6101 /* If this is a mips16 text symbol, add 1 to the value to make it
6102 odd. This will cause something like .word SYM to come up with
6103 the right value when it is loaded into the PC. */
6104 if (sym
->st_other
== STO_MIPS16
)
6110 /* This hook function is called before the linker writes out a global
6111 symbol. We mark symbols as small common if appropriate. This is
6112 also where we undo the increment of the value for a mips16 symbol. */
6115 _bfd_mips_elf_link_output_symbol_hook
6116 (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6117 const char *name ATTRIBUTE_UNUSED
, Elf_Internal_Sym
*sym
,
6118 asection
*input_sec
, struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
)
6120 /* If we see a common symbol, which implies a relocatable link, then
6121 if a symbol was small common in an input file, mark it as small
6122 common in the output file. */
6123 if (sym
->st_shndx
== SHN_COMMON
6124 && strcmp (input_sec
->name
, ".scommon") == 0)
6125 sym
->st_shndx
= SHN_MIPS_SCOMMON
;
6127 if (sym
->st_other
== STO_MIPS16
)
6128 sym
->st_value
&= ~1;
6133 /* Functions for the dynamic linker. */
6135 /* Create dynamic sections when linking against a dynamic object. */
6138 _bfd_mips_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
6140 struct elf_link_hash_entry
*h
;
6141 struct bfd_link_hash_entry
*bh
;
6143 register asection
*s
;
6144 const char * const *namep
;
6145 struct mips_elf_link_hash_table
*htab
;
6147 htab
= mips_elf_hash_table (info
);
6148 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
6149 | SEC_LINKER_CREATED
| SEC_READONLY
);
6151 /* The psABI requires a read-only .dynamic section, but the VxWorks
6153 if (!htab
->is_vxworks
)
6155 s
= bfd_get_section_by_name (abfd
, ".dynamic");
6158 if (! bfd_set_section_flags (abfd
, s
, flags
))
6163 /* We need to create .got section. */
6164 if (! mips_elf_create_got_section (abfd
, info
, FALSE
))
6167 if (! mips_elf_rel_dyn_section (info
, TRUE
))
6170 /* Create .stub section. */
6171 if (bfd_get_section_by_name (abfd
,
6172 MIPS_ELF_STUB_SECTION_NAME (abfd
)) == NULL
)
6174 s
= bfd_make_section_with_flags (abfd
,
6175 MIPS_ELF_STUB_SECTION_NAME (abfd
),
6178 || ! bfd_set_section_alignment (abfd
, s
,
6179 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
6183 if ((IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
6185 && bfd_get_section_by_name (abfd
, ".rld_map") == NULL
)
6187 s
= bfd_make_section_with_flags (abfd
, ".rld_map",
6188 flags
&~ (flagword
) SEC_READONLY
);
6190 || ! bfd_set_section_alignment (abfd
, s
,
6191 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
6195 /* On IRIX5, we adjust add some additional symbols and change the
6196 alignments of several sections. There is no ABI documentation
6197 indicating that this is necessary on IRIX6, nor any evidence that
6198 the linker takes such action. */
6199 if (IRIX_COMPAT (abfd
) == ict_irix5
)
6201 for (namep
= mips_elf_dynsym_rtproc_names
; *namep
!= NULL
; namep
++)
6204 if (! (_bfd_generic_link_add_one_symbol
6205 (info
, abfd
, *namep
, BSF_GLOBAL
, bfd_und_section_ptr
, 0,
6206 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
6209 h
= (struct elf_link_hash_entry
*) bh
;
6212 h
->type
= STT_SECTION
;
6214 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
6218 /* We need to create a .compact_rel section. */
6219 if (SGI_COMPAT (abfd
))
6221 if (!mips_elf_create_compact_rel_section (abfd
, info
))
6225 /* Change alignments of some sections. */
6226 s
= bfd_get_section_by_name (abfd
, ".hash");
6228 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
6229 s
= bfd_get_section_by_name (abfd
, ".dynsym");
6231 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
6232 s
= bfd_get_section_by_name (abfd
, ".dynstr");
6234 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
6235 s
= bfd_get_section_by_name (abfd
, ".reginfo");
6237 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
6238 s
= bfd_get_section_by_name (abfd
, ".dynamic");
6240 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
6247 name
= SGI_COMPAT (abfd
) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
6249 if (!(_bfd_generic_link_add_one_symbol
6250 (info
, abfd
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
, 0,
6251 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
6254 h
= (struct elf_link_hash_entry
*) bh
;
6257 h
->type
= STT_SECTION
;
6259 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
6262 if (! mips_elf_hash_table (info
)->use_rld_obj_head
)
6264 /* __rld_map is a four byte word located in the .data section
6265 and is filled in by the rtld to contain a pointer to
6266 the _r_debug structure. Its symbol value will be set in
6267 _bfd_mips_elf_finish_dynamic_symbol. */
6268 s
= bfd_get_section_by_name (abfd
, ".rld_map");
6269 BFD_ASSERT (s
!= NULL
);
6271 name
= SGI_COMPAT (abfd
) ? "__rld_map" : "__RLD_MAP";
6273 if (!(_bfd_generic_link_add_one_symbol
6274 (info
, abfd
, name
, BSF_GLOBAL
, s
, 0, NULL
, FALSE
,
6275 get_elf_backend_data (abfd
)->collect
, &bh
)))
6278 h
= (struct elf_link_hash_entry
*) bh
;
6281 h
->type
= STT_OBJECT
;
6283 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
6288 if (htab
->is_vxworks
)
6290 /* Create the .plt, .rela.plt, .dynbss and .rela.bss sections.
6291 Also create the _PROCEDURE_LINKAGE_TABLE symbol. */
6292 if (!_bfd_elf_create_dynamic_sections (abfd
, info
))
6295 /* Cache the sections created above. */
6296 htab
->sdynbss
= bfd_get_section_by_name (abfd
, ".dynbss");
6297 htab
->srelbss
= bfd_get_section_by_name (abfd
, ".rela.bss");
6298 htab
->srelplt
= bfd_get_section_by_name (abfd
, ".rela.plt");
6299 htab
->splt
= bfd_get_section_by_name (abfd
, ".plt");
6301 || (!htab
->srelbss
&& !info
->shared
)
6306 /* Do the usual VxWorks handling. */
6307 if (!elf_vxworks_create_dynamic_sections (abfd
, info
, &htab
->srelplt2
))
6310 /* Work out the PLT sizes. */
6313 htab
->plt_header_size
6314 = 4 * ARRAY_SIZE (mips_vxworks_shared_plt0_entry
);
6315 htab
->plt_entry_size
6316 = 4 * ARRAY_SIZE (mips_vxworks_shared_plt_entry
);
6320 htab
->plt_header_size
6321 = 4 * ARRAY_SIZE (mips_vxworks_exec_plt0_entry
);
6322 htab
->plt_entry_size
6323 = 4 * ARRAY_SIZE (mips_vxworks_exec_plt_entry
);
6330 /* Return true if relocation REL against section SEC is a REL rather than
6331 RELA relocation. RELOCS is the first relocation in the section and
6332 ABFD is the bfd that contains SEC. */
6335 mips_elf_rel_relocation_p (bfd
*abfd
, asection
*sec
,
6336 const Elf_Internal_Rela
*relocs
,
6337 const Elf_Internal_Rela
*rel
)
6339 Elf_Internal_Shdr
*rel_hdr
;
6340 const struct elf_backend_data
*bed
;
6342 /* To determine which flavor or relocation this is, we depend on the
6343 fact that the INPUT_SECTION's REL_HDR is read before its REL_HDR2. */
6344 rel_hdr
= &elf_section_data (sec
)->rel_hdr
;
6345 bed
= get_elf_backend_data (abfd
);
6346 if ((size_t) (rel
- relocs
)
6347 >= (NUM_SHDR_ENTRIES (rel_hdr
) * bed
->s
->int_rels_per_ext_rel
))
6348 rel_hdr
= elf_section_data (sec
)->rel_hdr2
;
6349 return rel_hdr
->sh_entsize
== MIPS_ELF_REL_SIZE (abfd
);
6352 /* Read the addend for REL relocation REL, which belongs to bfd ABFD.
6353 HOWTO is the relocation's howto and CONTENTS points to the contents
6354 of the section that REL is against. */
6357 mips_elf_read_rel_addend (bfd
*abfd
, const Elf_Internal_Rela
*rel
,
6358 reloc_howto_type
*howto
, bfd_byte
*contents
)
6361 unsigned int r_type
;
6364 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
6365 location
= contents
+ rel
->r_offset
;
6367 /* Get the addend, which is stored in the input file. */
6368 _bfd_mips16_elf_reloc_unshuffle (abfd
, r_type
, FALSE
, location
);
6369 addend
= mips_elf_obtain_contents (howto
, rel
, abfd
, contents
);
6370 _bfd_mips16_elf_reloc_shuffle (abfd
, r_type
, FALSE
, location
);
6372 return addend
& howto
->src_mask
;
6375 /* REL is a relocation in ABFD that needs a partnering LO16 relocation
6376 and *ADDEND is the addend for REL itself. Look for the LO16 relocation
6377 and update *ADDEND with the final addend. Return true on success
6378 or false if the LO16 could not be found. RELEND is the exclusive
6379 upper bound on the relocations for REL's section. */
6382 mips_elf_add_lo16_rel_addend (bfd
*abfd
,
6383 const Elf_Internal_Rela
*rel
,
6384 const Elf_Internal_Rela
*relend
,
6385 bfd_byte
*contents
, bfd_vma
*addend
)
6387 unsigned int r_type
, lo16_type
;
6388 const Elf_Internal_Rela
*lo16_relocation
;
6389 reloc_howto_type
*lo16_howto
;
6392 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
6393 if (r_type
== R_MIPS16_HI16
)
6394 lo16_type
= R_MIPS16_LO16
;
6396 lo16_type
= R_MIPS_LO16
;
6398 /* The combined value is the sum of the HI16 addend, left-shifted by
6399 sixteen bits, and the LO16 addend, sign extended. (Usually, the
6400 code does a `lui' of the HI16 value, and then an `addiu' of the
6403 Scan ahead to find a matching LO16 relocation.
6405 According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must
6406 be immediately following. However, for the IRIX6 ABI, the next
6407 relocation may be a composed relocation consisting of several
6408 relocations for the same address. In that case, the R_MIPS_LO16
6409 relocation may occur as one of these. We permit a similar
6410 extension in general, as that is useful for GCC.
6412 In some cases GCC dead code elimination removes the LO16 but keeps
6413 the corresponding HI16. This is strictly speaking a violation of
6414 the ABI but not immediately harmful. */
6415 lo16_relocation
= mips_elf_next_relocation (abfd
, lo16_type
, rel
, relend
);
6416 if (lo16_relocation
== NULL
)
6419 /* Obtain the addend kept there. */
6420 lo16_howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, lo16_type
, FALSE
);
6421 l
= mips_elf_read_rel_addend (abfd
, lo16_relocation
, lo16_howto
, contents
);
6423 l
<<= lo16_howto
->rightshift
;
6424 l
= _bfd_mips_elf_sign_extend (l
, 16);
6431 /* Try to read the contents of section SEC in bfd ABFD. Return true and
6432 store the contents in *CONTENTS on success. Assume that *CONTENTS
6433 already holds the contents if it is nonull on entry. */
6436 mips_elf_get_section_contents (bfd
*abfd
, asection
*sec
, bfd_byte
**contents
)
6441 /* Get cached copy if it exists. */
6442 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
6444 *contents
= elf_section_data (sec
)->this_hdr
.contents
;
6448 return bfd_malloc_and_get_section (abfd
, sec
, contents
);
6451 /* Look through the relocs for a section during the first phase, and
6452 allocate space in the global offset table. */
6455 _bfd_mips_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
6456 asection
*sec
, const Elf_Internal_Rela
*relocs
)
6460 Elf_Internal_Shdr
*symtab_hdr
;
6461 struct elf_link_hash_entry
**sym_hashes
;
6462 struct mips_got_info
*g
;
6464 const Elf_Internal_Rela
*rel
;
6465 const Elf_Internal_Rela
*rel_end
;
6468 const struct elf_backend_data
*bed
;
6469 struct mips_elf_link_hash_table
*htab
;
6472 reloc_howto_type
*howto
;
6474 if (info
->relocatable
)
6477 htab
= mips_elf_hash_table (info
);
6478 dynobj
= elf_hash_table (info
)->dynobj
;
6479 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
6480 sym_hashes
= elf_sym_hashes (abfd
);
6481 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
6483 /* Check for the mips16 stub sections. */
6485 name
= bfd_get_section_name (abfd
, sec
);
6486 if (FN_STUB_P (name
))
6488 unsigned long r_symndx
;
6490 /* Look at the relocation information to figure out which symbol
6493 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
6495 if (r_symndx
< extsymoff
6496 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
6500 /* This stub is for a local symbol. This stub will only be
6501 needed if there is some relocation in this BFD, other
6502 than a 16 bit function call, which refers to this symbol. */
6503 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
6505 Elf_Internal_Rela
*sec_relocs
;
6506 const Elf_Internal_Rela
*r
, *rend
;
6508 /* We can ignore stub sections when looking for relocs. */
6509 if ((o
->flags
& SEC_RELOC
) == 0
6510 || o
->reloc_count
== 0
6511 || mips16_stub_section_p (abfd
, o
))
6515 = _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
6517 if (sec_relocs
== NULL
)
6520 rend
= sec_relocs
+ o
->reloc_count
;
6521 for (r
= sec_relocs
; r
< rend
; r
++)
6522 if (ELF_R_SYM (abfd
, r
->r_info
) == r_symndx
6523 && ELF_R_TYPE (abfd
, r
->r_info
) != R_MIPS16_26
)
6526 if (elf_section_data (o
)->relocs
!= sec_relocs
)
6535 /* There is no non-call reloc for this stub, so we do
6536 not need it. Since this function is called before
6537 the linker maps input sections to output sections, we
6538 can easily discard it by setting the SEC_EXCLUDE
6540 sec
->flags
|= SEC_EXCLUDE
;
6544 /* Record this stub in an array of local symbol stubs for
6546 if (elf_tdata (abfd
)->local_stubs
== NULL
)
6548 unsigned long symcount
;
6552 if (elf_bad_symtab (abfd
))
6553 symcount
= NUM_SHDR_ENTRIES (symtab_hdr
);
6555 symcount
= symtab_hdr
->sh_info
;
6556 amt
= symcount
* sizeof (asection
*);
6557 n
= bfd_zalloc (abfd
, amt
);
6560 elf_tdata (abfd
)->local_stubs
= n
;
6563 sec
->flags
|= SEC_KEEP
;
6564 elf_tdata (abfd
)->local_stubs
[r_symndx
] = sec
;
6566 /* We don't need to set mips16_stubs_seen in this case.
6567 That flag is used to see whether we need to look through
6568 the global symbol table for stubs. We don't need to set
6569 it here, because we just have a local stub. */
6573 struct mips_elf_link_hash_entry
*h
;
6575 h
= ((struct mips_elf_link_hash_entry
*)
6576 sym_hashes
[r_symndx
- extsymoff
]);
6578 while (h
->root
.root
.type
== bfd_link_hash_indirect
6579 || h
->root
.root
.type
== bfd_link_hash_warning
)
6580 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
6582 /* H is the symbol this stub is for. */
6584 /* If we already have an appropriate stub for this function, we
6585 don't need another one, so we can discard this one. Since
6586 this function is called before the linker maps input sections
6587 to output sections, we can easily discard it by setting the
6588 SEC_EXCLUDE flag. */
6589 if (h
->fn_stub
!= NULL
)
6591 sec
->flags
|= SEC_EXCLUDE
;
6595 sec
->flags
|= SEC_KEEP
;
6597 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
6600 else if (CALL_STUB_P (name
) || CALL_FP_STUB_P (name
))
6602 unsigned long r_symndx
;
6603 struct mips_elf_link_hash_entry
*h
;
6606 /* Look at the relocation information to figure out which symbol
6609 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
6611 if (r_symndx
< extsymoff
6612 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
6616 /* This stub is for a local symbol. This stub will only be
6617 needed if there is some relocation (R_MIPS16_26) in this BFD
6618 that refers to this symbol. */
6619 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
6621 Elf_Internal_Rela
*sec_relocs
;
6622 const Elf_Internal_Rela
*r
, *rend
;
6624 /* We can ignore stub sections when looking for relocs. */
6625 if ((o
->flags
& SEC_RELOC
) == 0
6626 || o
->reloc_count
== 0
6627 || mips16_stub_section_p (abfd
, o
))
6631 = _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
6633 if (sec_relocs
== NULL
)
6636 rend
= sec_relocs
+ o
->reloc_count
;
6637 for (r
= sec_relocs
; r
< rend
; r
++)
6638 if (ELF_R_SYM (abfd
, r
->r_info
) == r_symndx
6639 && ELF_R_TYPE (abfd
, r
->r_info
) == R_MIPS16_26
)
6642 if (elf_section_data (o
)->relocs
!= sec_relocs
)
6651 /* There is no non-call reloc for this stub, so we do
6652 not need it. Since this function is called before
6653 the linker maps input sections to output sections, we
6654 can easily discard it by setting the SEC_EXCLUDE
6656 sec
->flags
|= SEC_EXCLUDE
;
6660 /* Record this stub in an array of local symbol call_stubs for
6662 if (elf_tdata (abfd
)->local_call_stubs
== NULL
)
6664 unsigned long symcount
;
6668 if (elf_bad_symtab (abfd
))
6669 symcount
= NUM_SHDR_ENTRIES (symtab_hdr
);
6671 symcount
= symtab_hdr
->sh_info
;
6672 amt
= symcount
* sizeof (asection
*);
6673 n
= bfd_zalloc (abfd
, amt
);
6676 elf_tdata (abfd
)->local_call_stubs
= n
;
6679 sec
->flags
|= SEC_KEEP
;
6680 elf_tdata (abfd
)->local_call_stubs
[r_symndx
] = sec
;
6682 /* We don't need to set mips16_stubs_seen in this case.
6683 That flag is used to see whether we need to look through
6684 the global symbol table for stubs. We don't need to set
6685 it here, because we just have a local stub. */
6689 h
= ((struct mips_elf_link_hash_entry
*)
6690 sym_hashes
[r_symndx
- extsymoff
]);
6692 /* H is the symbol this stub is for. */
6694 if (CALL_FP_STUB_P (name
))
6695 loc
= &h
->call_fp_stub
;
6697 loc
= &h
->call_stub
;
6699 /* If we already have an appropriate stub for this function, we
6700 don't need another one, so we can discard this one. Since
6701 this function is called before the linker maps input sections
6702 to output sections, we can easily discard it by setting the
6703 SEC_EXCLUDE flag. */
6706 sec
->flags
|= SEC_EXCLUDE
;
6710 sec
->flags
|= SEC_KEEP
;
6712 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
6723 sgot
= mips_elf_got_section (dynobj
, FALSE
);
6728 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
6729 g
= mips_elf_section_data (sgot
)->u
.got_info
;
6730 BFD_ASSERT (g
!= NULL
);
6735 bed
= get_elf_backend_data (abfd
);
6736 rel_end
= relocs
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
6738 for (rel
= relocs
; rel
< rel_end
; ++rel
)
6740 unsigned long r_symndx
;
6741 unsigned int r_type
;
6742 struct elf_link_hash_entry
*h
;
6744 r_symndx
= ELF_R_SYM (abfd
, rel
->r_info
);
6745 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
6747 if (r_symndx
< extsymoff
)
6749 else if (r_symndx
>= extsymoff
+ NUM_SHDR_ENTRIES (symtab_hdr
))
6751 (*_bfd_error_handler
)
6752 (_("%B: Malformed reloc detected for section %s"),
6754 bfd_set_error (bfd_error_bad_value
);
6759 h
= sym_hashes
[r_symndx
- extsymoff
];
6761 /* This may be an indirect symbol created because of a version. */
6764 while (h
->root
.type
== bfd_link_hash_indirect
)
6765 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
6769 /* Some relocs require a global offset table. */
6770 if (dynobj
== NULL
|| sgot
== NULL
)
6776 case R_MIPS_CALL_HI16
:
6777 case R_MIPS_CALL_LO16
:
6778 case R_MIPS_GOT_HI16
:
6779 case R_MIPS_GOT_LO16
:
6780 case R_MIPS_GOT_PAGE
:
6781 case R_MIPS_GOT_OFST
:
6782 case R_MIPS_GOT_DISP
:
6783 case R_MIPS_TLS_GOTTPREL
:
6785 case R_MIPS_TLS_LDM
:
6787 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
6788 if (! mips_elf_create_got_section (dynobj
, info
, FALSE
))
6790 g
= mips_elf_got_info (dynobj
, &sgot
);
6791 if (htab
->is_vxworks
&& !info
->shared
)
6793 (*_bfd_error_handler
)
6794 (_("%B: GOT reloc at 0x%lx not expected in executables"),
6795 abfd
, (unsigned long) rel
->r_offset
);
6796 bfd_set_error (bfd_error_bad_value
);
6804 /* In VxWorks executables, references to external symbols
6805 are handled using copy relocs or PLT stubs, so there's
6806 no need to add a dynamic relocation here. */
6808 && (info
->shared
|| (h
!= NULL
&& !htab
->is_vxworks
))
6809 && (sec
->flags
& SEC_ALLOC
) != 0)
6810 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
6820 ((struct mips_elf_link_hash_entry
*) h
)->is_relocation_target
= TRUE
;
6822 /* Relocations against the special VxWorks __GOTT_BASE__ and
6823 __GOTT_INDEX__ symbols must be left to the loader. Allocate
6824 room for them in .rela.dyn. */
6825 if (is_gott_symbol (info
, h
))
6829 sreloc
= mips_elf_rel_dyn_section (info
, TRUE
);
6833 mips_elf_allocate_dynamic_relocations (dynobj
, info
, 1);
6834 if (MIPS_ELF_READONLY_SECTION (sec
))
6835 /* We tell the dynamic linker that there are
6836 relocations against the text segment. */
6837 info
->flags
|= DF_TEXTREL
;
6840 else if (r_type
== R_MIPS_CALL_LO16
6841 || r_type
== R_MIPS_GOT_LO16
6842 || r_type
== R_MIPS_GOT_DISP
6843 || (r_type
== R_MIPS_GOT16
&& htab
->is_vxworks
))
6845 /* We may need a local GOT entry for this relocation. We
6846 don't count R_MIPS_GOT_PAGE because we can estimate the
6847 maximum number of pages needed by looking at the size of
6848 the segment. Similar comments apply to R_MIPS_GOT16 and
6849 R_MIPS_CALL16, except on VxWorks, where GOT relocations
6850 always evaluate to "G". We don't count R_MIPS_GOT_HI16, or
6851 R_MIPS_CALL_HI16 because these are always followed by an
6852 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
6853 if (! mips_elf_record_local_got_symbol (abfd
, r_symndx
,
6854 rel
->r_addend
, g
, 0))
6863 (*_bfd_error_handler
)
6864 (_("%B: CALL16 reloc at 0x%lx not against global symbol"),
6865 abfd
, (unsigned long) rel
->r_offset
);
6866 bfd_set_error (bfd_error_bad_value
);
6871 case R_MIPS_CALL_HI16
:
6872 case R_MIPS_CALL_LO16
:
6875 /* VxWorks call relocations point the function's .got.plt
6876 entry, which will be allocated by adjust_dynamic_symbol.
6877 Otherwise, this symbol requires a global GOT entry. */
6878 if ((!htab
->is_vxworks
|| h
->forced_local
)
6879 && !mips_elf_record_global_got_symbol (h
, abfd
, info
, g
, 0))
6882 /* We need a stub, not a plt entry for the undefined
6883 function. But we record it as if it needs plt. See
6884 _bfd_elf_adjust_dynamic_symbol. */
6890 case R_MIPS_GOT_PAGE
:
6891 /* If this is a global, overridable symbol, GOT_PAGE will
6892 decay to GOT_DISP, so we'll need a GOT entry for it. */
6895 struct mips_elf_link_hash_entry
*hmips
=
6896 (struct mips_elf_link_hash_entry
*) h
;
6898 while (hmips
->root
.root
.type
== bfd_link_hash_indirect
6899 || hmips
->root
.root
.type
== bfd_link_hash_warning
)
6900 hmips
= (struct mips_elf_link_hash_entry
*)
6901 hmips
->root
.root
.u
.i
.link
;
6903 if (hmips
->root
.def_regular
6904 && ! (info
->shared
&& ! info
->symbolic
6905 && ! hmips
->root
.forced_local
))
6911 case R_MIPS_GOT_HI16
:
6912 case R_MIPS_GOT_LO16
:
6915 /* This relocation needs a page entry in the GOT. */
6916 if (mips_elf_rel_relocation_p (abfd
, sec
, relocs
, rel
))
6918 if (!mips_elf_get_section_contents (abfd
, sec
, &contents
))
6920 howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, r_type
, FALSE
);
6921 addend
= mips_elf_read_rel_addend (abfd
, rel
,
6923 if (r_type
== R_MIPS_GOT16
)
6924 mips_elf_add_lo16_rel_addend (abfd
, rel
, rel_end
,
6927 addend
<<= howto
->rightshift
;
6930 addend
= rel
->r_addend
;
6931 if (!mips_elf_record_got_page_entry (abfd
, r_symndx
, addend
, g
))
6937 case R_MIPS_GOT_DISP
:
6938 if (h
&& ! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
, 0))
6942 case R_MIPS_TLS_GOTTPREL
:
6944 info
->flags
|= DF_STATIC_TLS
;
6947 case R_MIPS_TLS_LDM
:
6948 if (r_type
== R_MIPS_TLS_LDM
)
6956 /* This symbol requires a global offset table entry, or two
6957 for TLS GD relocations. */
6959 unsigned char flag
= (r_type
== R_MIPS_TLS_GD
6961 : r_type
== R_MIPS_TLS_LDM
6966 struct mips_elf_link_hash_entry
*hmips
=
6967 (struct mips_elf_link_hash_entry
*) h
;
6968 hmips
->tls_type
|= flag
;
6970 if (h
&& ! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
, flag
))
6975 BFD_ASSERT (flag
== GOT_TLS_LDM
|| r_symndx
!= 0);
6977 if (! mips_elf_record_local_got_symbol (abfd
, r_symndx
,
6978 rel
->r_addend
, g
, flag
))
6987 /* In VxWorks executables, references to external symbols
6988 are handled using copy relocs or PLT stubs, so there's
6989 no need to add a .rela.dyn entry for this relocation. */
6990 if ((info
->shared
|| (h
!= NULL
&& !htab
->is_vxworks
))
6991 && (sec
->flags
& SEC_ALLOC
) != 0)
6995 sreloc
= mips_elf_rel_dyn_section (info
, TRUE
);
7001 /* When creating a shared object, we must copy these
7002 reloc types into the output file as R_MIPS_REL32
7003 relocs. Make room for this reloc in .rel(a).dyn. */
7004 mips_elf_allocate_dynamic_relocations (dynobj
, info
, 1);
7005 if (MIPS_ELF_READONLY_SECTION (sec
))
7006 /* We tell the dynamic linker that there are
7007 relocations against the text segment. */
7008 info
->flags
|= DF_TEXTREL
;
7012 struct mips_elf_link_hash_entry
*hmips
;
7014 /* We only need to copy this reloc if the symbol is
7015 defined in a dynamic object. */
7016 hmips
= (struct mips_elf_link_hash_entry
*) h
;
7017 ++hmips
->possibly_dynamic_relocs
;
7018 if (MIPS_ELF_READONLY_SECTION (sec
))
7019 /* We need it to tell the dynamic linker if there
7020 are relocations against the text segment. */
7021 hmips
->readonly_reloc
= TRUE
;
7024 /* Even though we don't directly need a GOT entry for
7025 this symbol, a symbol must have a dynamic symbol
7026 table index greater that DT_MIPS_GOTSYM if there are
7027 dynamic relocations against it. This does not apply
7028 to VxWorks, which does not have the usual coupling
7029 between global GOT entries and .dynsym entries. */
7030 if (h
!= NULL
&& !htab
->is_vxworks
)
7033 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
7034 if (! mips_elf_create_got_section (dynobj
, info
, TRUE
))
7036 g
= mips_elf_got_info (dynobj
, &sgot
);
7037 if (! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
, 0))
7042 if (SGI_COMPAT (abfd
))
7043 mips_elf_hash_table (info
)->compact_rel_size
+=
7044 sizeof (Elf32_External_crinfo
);
7049 ((struct mips_elf_link_hash_entry
*) h
)->is_branch_target
= TRUE
;
7054 ((struct mips_elf_link_hash_entry
*) h
)->is_branch_target
= TRUE
;
7057 case R_MIPS_GPREL16
:
7058 case R_MIPS_LITERAL
:
7059 case R_MIPS_GPREL32
:
7060 if (SGI_COMPAT (abfd
))
7061 mips_elf_hash_table (info
)->compact_rel_size
+=
7062 sizeof (Elf32_External_crinfo
);
7065 /* This relocation describes the C++ object vtable hierarchy.
7066 Reconstruct it for later use during GC. */
7067 case R_MIPS_GNU_VTINHERIT
:
7068 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
7072 /* This relocation describes which C++ vtable entries are actually
7073 used. Record for later use during GC. */
7074 case R_MIPS_GNU_VTENTRY
:
7075 BFD_ASSERT (h
!= NULL
);
7077 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
7085 /* We must not create a stub for a symbol that has relocations
7086 related to taking the function's address. This doesn't apply to
7087 VxWorks, where CALL relocs refer to a .got.plt entry instead of
7088 a normal .got entry. */
7089 if (!htab
->is_vxworks
&& h
!= NULL
)
7093 ((struct mips_elf_link_hash_entry
*) h
)->no_fn_stub
= TRUE
;
7096 case R_MIPS_CALL_HI16
:
7097 case R_MIPS_CALL_LO16
:
7102 /* If this reloc is not a 16 bit call, and it has a global
7103 symbol, then we will need the fn_stub if there is one.
7104 References from a stub section do not count. */
7106 && r_type
!= R_MIPS16_26
7107 && !mips16_stub_section_p (abfd
, sec
))
7109 struct mips_elf_link_hash_entry
*mh
;
7111 mh
= (struct mips_elf_link_hash_entry
*) h
;
7112 mh
->need_fn_stub
= TRUE
;
7120 _bfd_mips_relax_section (bfd
*abfd
, asection
*sec
,
7121 struct bfd_link_info
*link_info
,
7124 Elf_Internal_Rela
*internal_relocs
;
7125 Elf_Internal_Rela
*irel
, *irelend
;
7126 Elf_Internal_Shdr
*symtab_hdr
;
7127 bfd_byte
*contents
= NULL
;
7129 bfd_boolean changed_contents
= FALSE
;
7130 bfd_vma sec_start
= sec
->output_section
->vma
+ sec
->output_offset
;
7131 Elf_Internal_Sym
*isymbuf
= NULL
;
7133 /* We are not currently changing any sizes, so only one pass. */
7136 if (link_info
->relocatable
)
7139 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
7140 link_info
->keep_memory
);
7141 if (internal_relocs
== NULL
)
7144 irelend
= internal_relocs
+ sec
->reloc_count
7145 * get_elf_backend_data (abfd
)->s
->int_rels_per_ext_rel
;
7146 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7147 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
7149 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
7152 bfd_signed_vma sym_offset
;
7153 unsigned int r_type
;
7154 unsigned long r_symndx
;
7156 unsigned long instruction
;
7158 /* Turn jalr into bgezal, and jr into beq, if they're marked
7159 with a JALR relocation, that indicate where they jump to.
7160 This saves some pipeline bubbles. */
7161 r_type
= ELF_R_TYPE (abfd
, irel
->r_info
);
7162 if (r_type
!= R_MIPS_JALR
)
7165 r_symndx
= ELF_R_SYM (abfd
, irel
->r_info
);
7166 /* Compute the address of the jump target. */
7167 if (r_symndx
>= extsymoff
)
7169 struct mips_elf_link_hash_entry
*h
7170 = ((struct mips_elf_link_hash_entry
*)
7171 elf_sym_hashes (abfd
) [r_symndx
- extsymoff
]);
7173 while (h
->root
.root
.type
== bfd_link_hash_indirect
7174 || h
->root
.root
.type
== bfd_link_hash_warning
)
7175 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
7177 /* If a symbol is undefined, or if it may be overridden,
7179 if (! ((h
->root
.root
.type
== bfd_link_hash_defined
7180 || h
->root
.root
.type
== bfd_link_hash_defweak
)
7181 && h
->root
.root
.u
.def
.section
)
7182 || (link_info
->shared
&& ! link_info
->symbolic
7183 && !h
->root
.forced_local
))
7186 sym_sec
= h
->root
.root
.u
.def
.section
;
7187 if (sym_sec
->output_section
)
7188 symval
= (h
->root
.root
.u
.def
.value
7189 + sym_sec
->output_section
->vma
7190 + sym_sec
->output_offset
);
7192 symval
= h
->root
.root
.u
.def
.value
;
7196 Elf_Internal_Sym
*isym
;
7198 /* Read this BFD's symbols if we haven't done so already. */
7199 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
7201 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
7202 if (isymbuf
== NULL
)
7203 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
7204 symtab_hdr
->sh_info
, 0,
7206 if (isymbuf
== NULL
)
7210 isym
= isymbuf
+ r_symndx
;
7211 if (isym
->st_shndx
== SHN_UNDEF
)
7213 else if (isym
->st_shndx
== SHN_ABS
)
7214 sym_sec
= bfd_abs_section_ptr
;
7215 else if (isym
->st_shndx
== SHN_COMMON
)
7216 sym_sec
= bfd_com_section_ptr
;
7219 = bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
7220 symval
= isym
->st_value
7221 + sym_sec
->output_section
->vma
7222 + sym_sec
->output_offset
;
7225 /* Compute branch offset, from delay slot of the jump to the
7227 sym_offset
= (symval
+ irel
->r_addend
)
7228 - (sec_start
+ irel
->r_offset
+ 4);
7230 /* Branch offset must be properly aligned. */
7231 if ((sym_offset
& 3) != 0)
7236 /* Check that it's in range. */
7237 if (sym_offset
< -0x8000 || sym_offset
>= 0x8000)
7240 /* Get the section contents if we haven't done so already. */
7241 if (!mips_elf_get_section_contents (abfd
, sec
, &contents
))
7244 instruction
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
7246 /* If it was jalr <reg>, turn it into bgezal $zero, <target>. */
7247 if ((instruction
& 0xfc1fffff) == 0x0000f809)
7248 instruction
= 0x04110000;
7249 /* If it was jr <reg>, turn it into b <target>. */
7250 else if ((instruction
& 0xfc1fffff) == 0x00000008)
7251 instruction
= 0x10000000;
7255 instruction
|= (sym_offset
& 0xffff);
7256 bfd_put_32 (abfd
, instruction
, contents
+ irel
->r_offset
);
7257 changed_contents
= TRUE
;
7260 if (contents
!= NULL
7261 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
7263 if (!changed_contents
&& !link_info
->keep_memory
)
7267 /* Cache the section contents for elf_link_input_bfd. */
7268 elf_section_data (sec
)->this_hdr
.contents
= contents
;
7274 if (contents
!= NULL
7275 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
7280 /* Adjust a symbol defined by a dynamic object and referenced by a
7281 regular object. The current definition is in some section of the
7282 dynamic object, but we're not including those sections. We have to
7283 change the definition to something the rest of the link can
7287 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
7288 struct elf_link_hash_entry
*h
)
7291 struct mips_elf_link_hash_entry
*hmips
;
7293 struct mips_elf_link_hash_table
*htab
;
7295 htab
= mips_elf_hash_table (info
);
7296 dynobj
= elf_hash_table (info
)->dynobj
;
7298 /* Make sure we know what is going on here. */
7299 BFD_ASSERT (dynobj
!= NULL
7301 || h
->u
.weakdef
!= NULL
7304 && !h
->def_regular
)));
7306 /* If this symbol is defined in a dynamic object, we need to copy
7307 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
7309 hmips
= (struct mips_elf_link_hash_entry
*) h
;
7310 if (! info
->relocatable
7311 && hmips
->possibly_dynamic_relocs
!= 0
7312 && (h
->root
.type
== bfd_link_hash_defweak
7313 || !h
->def_regular
))
7315 mips_elf_allocate_dynamic_relocations
7316 (dynobj
, info
, hmips
->possibly_dynamic_relocs
);
7317 if (hmips
->readonly_reloc
)
7318 /* We tell the dynamic linker that there are relocations
7319 against the text segment. */
7320 info
->flags
|= DF_TEXTREL
;
7323 /* For a function, create a stub, if allowed. */
7324 if (! hmips
->no_fn_stub
7327 if (! elf_hash_table (info
)->dynamic_sections_created
)
7330 /* If this symbol is not defined in a regular file, then set
7331 the symbol to the stub location. This is required to make
7332 function pointers compare as equal between the normal
7333 executable and the shared library. */
7334 if (!h
->def_regular
)
7336 /* We need .stub section. */
7337 s
= bfd_get_section_by_name (dynobj
,
7338 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
7339 BFD_ASSERT (s
!= NULL
);
7341 h
->root
.u
.def
.section
= s
;
7342 h
->root
.u
.def
.value
= s
->size
;
7344 /* XXX Write this stub address somewhere. */
7345 h
->plt
.offset
= s
->size
;
7347 /* Make room for this stub code. */
7348 s
->size
+= htab
->function_stub_size
;
7350 /* The last half word of the stub will be filled with the index
7351 of this symbol in .dynsym section. */
7355 else if ((h
->type
== STT_FUNC
)
7358 /* This will set the entry for this symbol in the GOT to 0, and
7359 the dynamic linker will take care of this. */
7360 h
->root
.u
.def
.value
= 0;
7364 /* If this is a weak symbol, and there is a real definition, the
7365 processor independent code will have arranged for us to see the
7366 real definition first, and we can just use the same value. */
7367 if (h
->u
.weakdef
!= NULL
)
7369 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
7370 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
7371 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
7372 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
7376 /* This is a reference to a symbol defined by a dynamic object which
7377 is not a function. */
7382 /* Likewise, for VxWorks. */
7385 _bfd_mips_vxworks_adjust_dynamic_symbol (struct bfd_link_info
*info
,
7386 struct elf_link_hash_entry
*h
)
7389 struct mips_elf_link_hash_entry
*hmips
;
7390 struct mips_elf_link_hash_table
*htab
;
7392 htab
= mips_elf_hash_table (info
);
7393 dynobj
= elf_hash_table (info
)->dynobj
;
7394 hmips
= (struct mips_elf_link_hash_entry
*) h
;
7396 /* Make sure we know what is going on here. */
7397 BFD_ASSERT (dynobj
!= NULL
7400 || h
->u
.weakdef
!= NULL
7403 && !h
->def_regular
)));
7405 /* If the symbol is defined by a dynamic object, we need a PLT stub if
7406 either (a) we want to branch to the symbol or (b) we're linking an
7407 executable that needs a canonical function address. In the latter
7408 case, the canonical address will be the address of the executable's
7410 if ((hmips
->is_branch_target
7412 && h
->type
== STT_FUNC
7413 && hmips
->is_relocation_target
))
7417 && !h
->forced_local
)
7420 /* Locally-binding symbols do not need a PLT stub; we can refer to
7421 the functions directly. */
7422 else if (h
->needs_plt
7423 && (SYMBOL_CALLS_LOCAL (info
, h
)
7424 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
7425 && h
->root
.type
== bfd_link_hash_undefweak
)))
7433 /* If this is the first symbol to need a PLT entry, allocate room
7434 for the header, and for the header's .rela.plt.unloaded entries. */
7435 if (htab
->splt
->size
== 0)
7437 htab
->splt
->size
+= htab
->plt_header_size
;
7439 htab
->srelplt2
->size
+= 2 * sizeof (Elf32_External_Rela
);
7442 /* Assign the next .plt entry to this symbol. */
7443 h
->plt
.offset
= htab
->splt
->size
;
7444 htab
->splt
->size
+= htab
->plt_entry_size
;
7446 /* If the output file has no definition of the symbol, set the
7447 symbol's value to the address of the stub. For executables,
7448 point at the PLT load stub rather than the lazy resolution stub;
7449 this stub will become the canonical function address. */
7450 if (!h
->def_regular
)
7452 h
->root
.u
.def
.section
= htab
->splt
;
7453 h
->root
.u
.def
.value
= h
->plt
.offset
;
7455 h
->root
.u
.def
.value
+= 8;
7458 /* Make room for the .got.plt entry and the R_JUMP_SLOT relocation. */
7459 htab
->sgotplt
->size
+= 4;
7460 htab
->srelplt
->size
+= sizeof (Elf32_External_Rela
);
7462 /* Make room for the .rela.plt.unloaded relocations. */
7464 htab
->srelplt2
->size
+= 3 * sizeof (Elf32_External_Rela
);
7469 /* If a function symbol is defined by a dynamic object, and we do not
7470 need a PLT stub for it, the symbol's value should be zero. */
7471 if (h
->type
== STT_FUNC
7476 h
->root
.u
.def
.value
= 0;
7480 /* If this is a weak symbol, and there is a real definition, the
7481 processor independent code will have arranged for us to see the
7482 real definition first, and we can just use the same value. */
7483 if (h
->u
.weakdef
!= NULL
)
7485 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
7486 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
7487 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
7488 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
7492 /* This is a reference to a symbol defined by a dynamic object which
7493 is not a function. */
7497 /* We must allocate the symbol in our .dynbss section, which will
7498 become part of the .bss section of the executable. There will be
7499 an entry for this symbol in the .dynsym section. The dynamic
7500 object will contain position independent code, so all references
7501 from the dynamic object to this symbol will go through the global
7502 offset table. The dynamic linker will use the .dynsym entry to
7503 determine the address it must put in the global offset table, so
7504 both the dynamic object and the regular object will refer to the
7505 same memory location for the variable. */
7507 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
7509 htab
->srelbss
->size
+= sizeof (Elf32_External_Rela
);
7513 return _bfd_elf_adjust_dynamic_copy (h
, htab
->sdynbss
);
7516 /* Return the number of dynamic section symbols required by OUTPUT_BFD.
7517 The number might be exact or a worst-case estimate, depending on how
7518 much information is available to elf_backend_omit_section_dynsym at
7519 the current linking stage. */
7521 static bfd_size_type
7522 count_section_dynsyms (bfd
*output_bfd
, struct bfd_link_info
*info
)
7524 bfd_size_type count
;
7527 if (info
->shared
|| elf_hash_table (info
)->is_relocatable_executable
)
7530 const struct elf_backend_data
*bed
;
7532 bed
= get_elf_backend_data (output_bfd
);
7533 for (p
= output_bfd
->sections
; p
; p
= p
->next
)
7534 if ((p
->flags
& SEC_EXCLUDE
) == 0
7535 && (p
->flags
& SEC_ALLOC
) != 0
7536 && !(*bed
->elf_backend_omit_section_dynsym
) (output_bfd
, info
, p
))
7542 /* This function is called after all the input files have been read,
7543 and the input sections have been assigned to output sections. We
7544 check for any mips16 stub sections that we can discard. */
7547 _bfd_mips_elf_always_size_sections (bfd
*output_bfd
,
7548 struct bfd_link_info
*info
)
7554 struct mips_got_info
*g
;
7556 bfd_size_type loadable_size
= 0;
7557 bfd_size_type page_gotno
;
7558 bfd_size_type dynsymcount
;
7560 struct mips_elf_count_tls_arg count_tls_arg
;
7561 struct mips_elf_link_hash_table
*htab
;
7563 htab
= mips_elf_hash_table (info
);
7565 /* The .reginfo section has a fixed size. */
7566 ri
= bfd_get_section_by_name (output_bfd
, ".reginfo");
7568 bfd_set_section_size (output_bfd
, ri
, sizeof (Elf32_External_RegInfo
));
7570 if (! (info
->relocatable
7571 || ! mips_elf_hash_table (info
)->mips16_stubs_seen
))
7572 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
7573 mips_elf_check_mips16_stubs
, NULL
);
7575 dynobj
= elf_hash_table (info
)->dynobj
;
7577 /* Relocatable links don't have it. */
7580 g
= mips_elf_got_info (dynobj
, &s
);
7584 /* Calculate the total loadable size of the output. That
7585 will give us the maximum number of GOT_PAGE entries
7587 for (sub
= info
->input_bfds
; sub
; sub
= sub
->link_next
)
7589 asection
*subsection
;
7591 for (subsection
= sub
->sections
;
7593 subsection
= subsection
->next
)
7595 if ((subsection
->flags
& SEC_ALLOC
) == 0)
7597 loadable_size
+= ((subsection
->size
+ 0xf)
7598 &~ (bfd_size_type
) 0xf);
7602 /* There has to be a global GOT entry for every symbol with
7603 a dynamic symbol table index of DT_MIPS_GOTSYM or
7604 higher. Therefore, it make sense to put those symbols
7605 that need GOT entries at the end of the symbol table. We
7607 if (! mips_elf_sort_hash_table (info
, 1))
7610 if (g
->global_gotsym
!= NULL
)
7611 i
= elf_hash_table (info
)->dynsymcount
- g
->global_gotsym
->dynindx
;
7613 /* If there are no global symbols, or none requiring
7614 relocations, then GLOBAL_GOTSYM will be NULL. */
7617 /* Get a worst-case estimate of the number of dynamic symbols needed.
7618 At this point, dynsymcount does not account for section symbols
7619 and count_section_dynsyms may overestimate the number that will
7621 dynsymcount
= (elf_hash_table (info
)->dynsymcount
7622 + count_section_dynsyms (output_bfd
, info
));
7624 /* Determine the size of one stub entry. */
7625 htab
->function_stub_size
= (dynsymcount
> 0x10000
7626 ? MIPS_FUNCTION_STUB_BIG_SIZE
7627 : MIPS_FUNCTION_STUB_NORMAL_SIZE
);
7629 /* In the worst case, we'll get one stub per dynamic symbol, plus
7630 one to account for the dummy entry at the end required by IRIX
7632 loadable_size
+= htab
->function_stub_size
* (i
+ 1);
7634 if (htab
->is_vxworks
)
7635 /* There's no need to allocate page entries for VxWorks; R_MIPS_GOT16
7636 relocations against local symbols evaluate to "G", and the EABI does
7637 not include R_MIPS_GOT_PAGE. */
7640 /* Assume there are two loadable segments consisting of contiguous
7641 sections. Is 5 enough? */
7642 page_gotno
= (loadable_size
>> 16) + 5;
7644 /* Choose the smaller of the two estimates; both are intended to be
7646 if (page_gotno
> g
->page_gotno
)
7647 page_gotno
= g
->page_gotno
;
7649 g
->local_gotno
+= page_gotno
;
7650 s
->size
+= g
->local_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
7652 g
->global_gotno
= i
;
7653 s
->size
+= i
* MIPS_ELF_GOT_SIZE (output_bfd
);
7655 /* We need to calculate tls_gotno for global symbols at this point
7656 instead of building it up earlier, to avoid doublecounting
7657 entries for one global symbol from multiple input files. */
7658 count_tls_arg
.info
= info
;
7659 count_tls_arg
.needed
= 0;
7660 elf_link_hash_traverse (elf_hash_table (info
),
7661 mips_elf_count_global_tls_entries
,
7663 g
->tls_gotno
+= count_tls_arg
.needed
;
7664 s
->size
+= g
->tls_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
7666 mips_elf_resolve_final_got_entries (g
);
7668 /* VxWorks does not support multiple GOTs. It initializes $gp to
7669 __GOTT_BASE__[__GOTT_INDEX__], the value of which is set by the
7671 if (!htab
->is_vxworks
&& s
->size
> MIPS_ELF_GOT_MAX_SIZE (info
))
7673 if (! mips_elf_multi_got (output_bfd
, info
, g
, s
, page_gotno
))
7678 /* Set up TLS entries for the first GOT. */
7679 g
->tls_assigned_gotno
= g
->global_gotno
+ g
->local_gotno
;
7680 htab_traverse (g
->got_entries
, mips_elf_initialize_tls_index
, g
);
7682 htab
->computed_got_sizes
= TRUE
;
7687 /* Set the sizes of the dynamic sections. */
7690 _bfd_mips_elf_size_dynamic_sections (bfd
*output_bfd
,
7691 struct bfd_link_info
*info
)
7694 asection
*s
, *sreldyn
;
7695 bfd_boolean reltext
;
7696 struct mips_elf_link_hash_table
*htab
;
7698 htab
= mips_elf_hash_table (info
);
7699 dynobj
= elf_hash_table (info
)->dynobj
;
7700 BFD_ASSERT (dynobj
!= NULL
);
7702 if (elf_hash_table (info
)->dynamic_sections_created
)
7704 /* Set the contents of the .interp section to the interpreter. */
7705 if (info
->executable
)
7707 s
= bfd_get_section_by_name (dynobj
, ".interp");
7708 BFD_ASSERT (s
!= NULL
);
7710 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd
)) + 1;
7712 = (bfd_byte
*) ELF_DYNAMIC_INTERPRETER (output_bfd
);
7716 /* The check_relocs and adjust_dynamic_symbol entry points have
7717 determined the sizes of the various dynamic sections. Allocate
7721 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
7725 /* It's OK to base decisions on the section name, because none
7726 of the dynobj section names depend upon the input files. */
7727 name
= bfd_get_section_name (dynobj
, s
);
7729 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
7732 if (CONST_STRNEQ (name
, ".rel"))
7736 const char *outname
;
7739 /* If this relocation section applies to a read only
7740 section, then we probably need a DT_TEXTREL entry.
7741 If the relocation section is .rel(a).dyn, we always
7742 assert a DT_TEXTREL entry rather than testing whether
7743 there exists a relocation to a read only section or
7745 outname
= bfd_get_section_name (output_bfd
,
7747 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
7749 && (target
->flags
& SEC_READONLY
) != 0
7750 && (target
->flags
& SEC_ALLOC
) != 0)
7751 || strcmp (outname
, MIPS_ELF_REL_DYN_NAME (info
)) == 0)
7754 /* We use the reloc_count field as a counter if we need
7755 to copy relocs into the output file. */
7756 if (strcmp (name
, MIPS_ELF_REL_DYN_NAME (info
)) != 0)
7759 /* If combreloc is enabled, elf_link_sort_relocs() will
7760 sort relocations, but in a different way than we do,
7761 and before we're done creating relocations. Also, it
7762 will move them around between input sections'
7763 relocation's contents, so our sorting would be
7764 broken, so don't let it run. */
7765 info
->combreloc
= 0;
7768 else if (htab
->is_vxworks
&& strcmp (name
, ".got") == 0)
7770 /* Executables do not need a GOT. */
7773 /* Allocate relocations for all but the reserved entries. */
7774 struct mips_got_info
*g
;
7777 g
= mips_elf_got_info (dynobj
, NULL
);
7778 count
= (g
->global_gotno
7780 - MIPS_RESERVED_GOTNO (info
));
7781 mips_elf_allocate_dynamic_relocations (dynobj
, info
, count
);
7784 else if (!htab
->is_vxworks
&& CONST_STRNEQ (name
, ".got"))
7786 /* _bfd_mips_elf_always_size_sections() has already done
7787 most of the work, but some symbols may have been mapped
7788 to versions that we must now resolve in the got_entries
7790 struct mips_got_info
*gg
= mips_elf_got_info (dynobj
, NULL
);
7791 struct mips_got_info
*g
= gg
;
7792 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
7793 unsigned int needed_relocs
= 0;
7797 set_got_offset_arg
.value
= MIPS_ELF_GOT_SIZE (output_bfd
);
7798 set_got_offset_arg
.info
= info
;
7800 /* NOTE 2005-02-03: How can this call, or the next, ever
7801 find any indirect entries to resolve? They were all
7802 resolved in mips_elf_multi_got. */
7803 mips_elf_resolve_final_got_entries (gg
);
7804 for (g
= gg
->next
; g
&& g
->next
!= gg
; g
= g
->next
)
7806 unsigned int save_assign
;
7808 mips_elf_resolve_final_got_entries (g
);
7810 /* Assign offsets to global GOT entries. */
7811 save_assign
= g
->assigned_gotno
;
7812 g
->assigned_gotno
= g
->local_gotno
;
7813 set_got_offset_arg
.g
= g
;
7814 set_got_offset_arg
.needed_relocs
= 0;
7815 htab_traverse (g
->got_entries
,
7816 mips_elf_set_global_got_offset
,
7817 &set_got_offset_arg
);
7818 needed_relocs
+= set_got_offset_arg
.needed_relocs
;
7819 BFD_ASSERT (g
->assigned_gotno
- g
->local_gotno
7820 <= g
->global_gotno
);
7822 g
->assigned_gotno
= save_assign
;
7825 needed_relocs
+= g
->local_gotno
- g
->assigned_gotno
;
7826 BFD_ASSERT (g
->assigned_gotno
== g
->next
->local_gotno
7827 + g
->next
->global_gotno
7828 + g
->next
->tls_gotno
7829 + MIPS_RESERVED_GOTNO (info
));
7835 struct mips_elf_count_tls_arg arg
;
7839 htab_traverse (gg
->got_entries
, mips_elf_count_local_tls_relocs
,
7841 elf_link_hash_traverse (elf_hash_table (info
),
7842 mips_elf_count_global_tls_relocs
,
7845 needed_relocs
+= arg
.needed
;
7849 mips_elf_allocate_dynamic_relocations (dynobj
, info
,
7852 else if (strcmp (name
, MIPS_ELF_STUB_SECTION_NAME (output_bfd
)) == 0)
7854 /* IRIX rld assumes that the function stub isn't at the end
7855 of .text section. So put a dummy. XXX */
7856 s
->size
+= htab
->function_stub_size
;
7858 else if (! info
->shared
7859 && ! mips_elf_hash_table (info
)->use_rld_obj_head
7860 && CONST_STRNEQ (name
, ".rld_map"))
7862 /* We add a room for __rld_map. It will be filled in by the
7863 rtld to contain a pointer to the _r_debug structure. */
7866 else if (SGI_COMPAT (output_bfd
)
7867 && CONST_STRNEQ (name
, ".compact_rel"))
7868 s
->size
+= mips_elf_hash_table (info
)->compact_rel_size
;
7869 else if (! CONST_STRNEQ (name
, ".init")
7870 && s
!= htab
->sgotplt
7873 /* It's not one of our sections, so don't allocate space. */
7879 s
->flags
|= SEC_EXCLUDE
;
7883 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
7886 /* Allocate memory for this section last, since we may increase its
7888 if (strcmp (name
, MIPS_ELF_REL_DYN_NAME (info
)) == 0)
7894 /* Allocate memory for the section contents. */
7895 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
7896 if (s
->contents
== NULL
)
7898 bfd_set_error (bfd_error_no_memory
);
7903 /* Allocate memory for the .rel(a).dyn section. */
7904 if (sreldyn
!= NULL
)
7906 sreldyn
->contents
= bfd_zalloc (dynobj
, sreldyn
->size
);
7907 if (sreldyn
->contents
== NULL
)
7909 bfd_set_error (bfd_error_no_memory
);
7914 if (elf_hash_table (info
)->dynamic_sections_created
)
7916 /* Add some entries to the .dynamic section. We fill in the
7917 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
7918 must add the entries now so that we get the correct size for
7919 the .dynamic section. */
7921 /* SGI object has the equivalence of DT_DEBUG in the
7922 DT_MIPS_RLD_MAP entry. This must come first because glibc
7923 only fills in DT_MIPS_RLD_MAP (not DT_DEBUG) and GDB only
7924 looks at the first one it sees. */
7926 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_MAP
, 0))
7929 /* The DT_DEBUG entry may be filled in by the dynamic linker and
7930 used by the debugger. */
7931 if (info
->executable
7932 && !SGI_COMPAT (output_bfd
)
7933 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
7936 if (reltext
&& (SGI_COMPAT (output_bfd
) || htab
->is_vxworks
))
7937 info
->flags
|= DF_TEXTREL
;
7939 if ((info
->flags
& DF_TEXTREL
) != 0)
7941 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_TEXTREL
, 0))
7944 /* Clear the DF_TEXTREL flag. It will be set again if we
7945 write out an actual text relocation; we may not, because
7946 at this point we do not know whether e.g. any .eh_frame
7947 absolute relocations have been converted to PC-relative. */
7948 info
->flags
&= ~DF_TEXTREL
;
7951 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTGOT
, 0))
7954 if (htab
->is_vxworks
)
7956 /* VxWorks uses .rela.dyn instead of .rel.dyn. It does not
7957 use any of the DT_MIPS_* tags. */
7958 if (mips_elf_rel_dyn_section (info
, FALSE
))
7960 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELA
, 0))
7963 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELASZ
, 0))
7966 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELAENT
, 0))
7969 if (htab
->splt
->size
> 0)
7971 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTREL
, 0))
7974 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_JMPREL
, 0))
7977 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTRELSZ
, 0))
7983 if (mips_elf_rel_dyn_section (info
, FALSE
))
7985 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_REL
, 0))
7988 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELSZ
, 0))
7991 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELENT
, 0))
7995 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_VERSION
, 0))
7998 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_FLAGS
, 0))
8001 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_BASE_ADDRESS
, 0))
8004 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LOCAL_GOTNO
, 0))
8007 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_SYMTABNO
, 0))
8010 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_UNREFEXTNO
, 0))
8013 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_GOTSYM
, 0))
8016 if (IRIX_COMPAT (dynobj
) == ict_irix5
8017 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_HIPAGENO
, 0))
8020 if (IRIX_COMPAT (dynobj
) == ict_irix6
8021 && (bfd_get_section_by_name
8022 (dynobj
, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj
)))
8023 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_OPTIONS
, 0))
8026 if (htab
->is_vxworks
8027 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
8034 /* REL is a relocation in INPUT_BFD that is being copied to OUTPUT_BFD.
8035 Adjust its R_ADDEND field so that it is correct for the output file.
8036 LOCAL_SYMS and LOCAL_SECTIONS are arrays of INPUT_BFD's local symbols
8037 and sections respectively; both use symbol indexes. */
8040 mips_elf_adjust_addend (bfd
*output_bfd
, struct bfd_link_info
*info
,
8041 bfd
*input_bfd
, Elf_Internal_Sym
*local_syms
,
8042 asection
**local_sections
, Elf_Internal_Rela
*rel
)
8044 unsigned int r_type
, r_symndx
;
8045 Elf_Internal_Sym
*sym
;
8048 if (mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
, FALSE
))
8050 r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
8051 if (r_type
== R_MIPS16_GPREL
8052 || r_type
== R_MIPS_GPREL16
8053 || r_type
== R_MIPS_GPREL32
8054 || r_type
== R_MIPS_LITERAL
)
8056 rel
->r_addend
+= _bfd_get_gp_value (input_bfd
);
8057 rel
->r_addend
-= _bfd_get_gp_value (output_bfd
);
8060 r_symndx
= ELF_R_SYM (output_bfd
, rel
->r_info
);
8061 sym
= local_syms
+ r_symndx
;
8063 /* Adjust REL's addend to account for section merging. */
8064 if (!info
->relocatable
)
8066 sec
= local_sections
[r_symndx
];
8067 _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
8070 /* This would normally be done by the rela_normal code in elflink.c. */
8071 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
8072 rel
->r_addend
+= local_sections
[r_symndx
]->output_offset
;
8076 /* Relocate a MIPS ELF section. */
8079 _bfd_mips_elf_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
8080 bfd
*input_bfd
, asection
*input_section
,
8081 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
8082 Elf_Internal_Sym
*local_syms
,
8083 asection
**local_sections
)
8085 Elf_Internal_Rela
*rel
;
8086 const Elf_Internal_Rela
*relend
;
8088 bfd_boolean use_saved_addend_p
= FALSE
;
8089 const struct elf_backend_data
*bed
;
8091 bed
= get_elf_backend_data (output_bfd
);
8092 relend
= relocs
+ input_section
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
8093 for (rel
= relocs
; rel
< relend
; ++rel
)
8097 reloc_howto_type
*howto
;
8098 bfd_boolean require_jalx
;
8099 /* TRUE if the relocation is a RELA relocation, rather than a
8101 bfd_boolean rela_relocation_p
= TRUE
;
8102 unsigned int r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
8104 unsigned long r_symndx
;
8106 Elf_Internal_Shdr
*symtab_hdr
;
8107 struct elf_link_hash_entry
*h
;
8109 /* Find the relocation howto for this relocation. */
8110 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, r_type
,
8111 NEWABI_P (input_bfd
)
8112 && (MIPS_RELOC_RELA_P
8113 (input_bfd
, input_section
,
8116 r_symndx
= ELF_R_SYM (input_bfd
, rel
->r_info
);
8117 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
8118 if (mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
, FALSE
))
8120 sec
= local_sections
[r_symndx
];
8125 unsigned long extsymoff
;
8128 if (!elf_bad_symtab (input_bfd
))
8129 extsymoff
= symtab_hdr
->sh_info
;
8130 h
= elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
];
8131 while (h
->root
.type
== bfd_link_hash_indirect
8132 || h
->root
.type
== bfd_link_hash_warning
)
8133 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
8136 if (h
->root
.type
== bfd_link_hash_defined
8137 || h
->root
.type
== bfd_link_hash_defweak
)
8138 sec
= h
->root
.u
.def
.section
;
8141 if (sec
!= NULL
&& elf_discarded_section (sec
))
8143 /* For relocs against symbols from removed linkonce sections,
8144 or sections discarded by a linker script, we just want the
8145 section contents zeroed. Avoid any special processing. */
8146 _bfd_clear_contents (howto
, input_bfd
, contents
+ rel
->r_offset
);
8152 if (r_type
== R_MIPS_64
&& ! NEWABI_P (input_bfd
))
8154 /* Some 32-bit code uses R_MIPS_64. In particular, people use
8155 64-bit code, but make sure all their addresses are in the
8156 lowermost or uppermost 32-bit section of the 64-bit address
8157 space. Thus, when they use an R_MIPS_64 they mean what is
8158 usually meant by R_MIPS_32, with the exception that the
8159 stored value is sign-extended to 64 bits. */
8160 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, R_MIPS_32
, FALSE
);
8162 /* On big-endian systems, we need to lie about the position
8164 if (bfd_big_endian (input_bfd
))
8168 if (!use_saved_addend_p
)
8170 /* If these relocations were originally of the REL variety,
8171 we must pull the addend out of the field that will be
8172 relocated. Otherwise, we simply use the contents of the
8174 if (mips_elf_rel_relocation_p (input_bfd
, input_section
,
8177 rela_relocation_p
= FALSE
;
8178 addend
= mips_elf_read_rel_addend (input_bfd
, rel
,
8180 if (r_type
== R_MIPS_HI16
8181 || r_type
== R_MIPS16_HI16
8182 || (r_type
== R_MIPS_GOT16
8183 && mips_elf_local_relocation_p (input_bfd
, rel
,
8184 local_sections
, FALSE
)))
8186 if (!mips_elf_add_lo16_rel_addend (input_bfd
, rel
, relend
,
8192 name
= h
->root
.root
.string
;
8194 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
8195 local_syms
+ r_symndx
,
8197 (*_bfd_error_handler
)
8198 (_("%B: Can't find matching LO16 reloc against `%s' for %s at 0x%lx in section `%A'"),
8199 input_bfd
, input_section
, name
, howto
->name
,
8204 addend
<<= howto
->rightshift
;
8207 addend
= rel
->r_addend
;
8208 mips_elf_adjust_addend (output_bfd
, info
, input_bfd
,
8209 local_syms
, local_sections
, rel
);
8212 if (info
->relocatable
)
8214 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
)
8215 && bfd_big_endian (input_bfd
))
8218 if (!rela_relocation_p
&& rel
->r_addend
)
8220 addend
+= rel
->r_addend
;
8221 if (r_type
== R_MIPS_HI16
8222 || r_type
== R_MIPS_GOT16
)
8223 addend
= mips_elf_high (addend
);
8224 else if (r_type
== R_MIPS_HIGHER
)
8225 addend
= mips_elf_higher (addend
);
8226 else if (r_type
== R_MIPS_HIGHEST
)
8227 addend
= mips_elf_highest (addend
);
8229 addend
>>= howto
->rightshift
;
8231 /* We use the source mask, rather than the destination
8232 mask because the place to which we are writing will be
8233 source of the addend in the final link. */
8234 addend
&= howto
->src_mask
;
8236 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
8237 /* See the comment above about using R_MIPS_64 in the 32-bit
8238 ABI. Here, we need to update the addend. It would be
8239 possible to get away with just using the R_MIPS_32 reloc
8240 but for endianness. */
8246 if (addend
& ((bfd_vma
) 1 << 31))
8248 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
8255 /* If we don't know that we have a 64-bit type,
8256 do two separate stores. */
8257 if (bfd_big_endian (input_bfd
))
8259 /* Store the sign-bits (which are most significant)
8261 low_bits
= sign_bits
;
8267 high_bits
= sign_bits
;
8269 bfd_put_32 (input_bfd
, low_bits
,
8270 contents
+ rel
->r_offset
);
8271 bfd_put_32 (input_bfd
, high_bits
,
8272 contents
+ rel
->r_offset
+ 4);
8276 if (! mips_elf_perform_relocation (info
, howto
, rel
, addend
,
8277 input_bfd
, input_section
,
8282 /* Go on to the next relocation. */
8286 /* In the N32 and 64-bit ABIs there may be multiple consecutive
8287 relocations for the same offset. In that case we are
8288 supposed to treat the output of each relocation as the addend
8290 if (rel
+ 1 < relend
8291 && rel
->r_offset
== rel
[1].r_offset
8292 && ELF_R_TYPE (input_bfd
, rel
[1].r_info
) != R_MIPS_NONE
)
8293 use_saved_addend_p
= TRUE
;
8295 use_saved_addend_p
= FALSE
;
8297 /* Figure out what value we are supposed to relocate. */
8298 switch (mips_elf_calculate_relocation (output_bfd
, input_bfd
,
8299 input_section
, info
, rel
,
8300 addend
, howto
, local_syms
,
8301 local_sections
, &value
,
8302 &name
, &require_jalx
,
8303 use_saved_addend_p
))
8305 case bfd_reloc_continue
:
8306 /* There's nothing to do. */
8309 case bfd_reloc_undefined
:
8310 /* mips_elf_calculate_relocation already called the
8311 undefined_symbol callback. There's no real point in
8312 trying to perform the relocation at this point, so we
8313 just skip ahead to the next relocation. */
8316 case bfd_reloc_notsupported
:
8317 msg
= _("internal error: unsupported relocation error");
8318 info
->callbacks
->warning
8319 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
8322 case bfd_reloc_overflow
:
8323 if (use_saved_addend_p
)
8324 /* Ignore overflow until we reach the last relocation for
8325 a given location. */
8329 struct mips_elf_link_hash_table
*htab
;
8331 htab
= mips_elf_hash_table (info
);
8332 BFD_ASSERT (name
!= NULL
);
8333 if (!htab
->small_data_overflow_reported
8334 && (howto
->type
== R_MIPS_GPREL16
8335 || howto
->type
== R_MIPS_LITERAL
))
8338 _("small-data section exceeds 64KB;"
8339 " lower small-data size limit (see option -G)");
8341 htab
->small_data_overflow_reported
= TRUE
;
8342 (*info
->callbacks
->einfo
) ("%P: %s\n", msg
);
8344 if (! ((*info
->callbacks
->reloc_overflow
)
8345 (info
, NULL
, name
, howto
->name
, (bfd_vma
) 0,
8346 input_bfd
, input_section
, rel
->r_offset
)))
8359 /* If we've got another relocation for the address, keep going
8360 until we reach the last one. */
8361 if (use_saved_addend_p
)
8367 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
8368 /* See the comment above about using R_MIPS_64 in the 32-bit
8369 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
8370 that calculated the right value. Now, however, we
8371 sign-extend the 32-bit result to 64-bits, and store it as a
8372 64-bit value. We are especially generous here in that we
8373 go to extreme lengths to support this usage on systems with
8374 only a 32-bit VMA. */
8380 if (value
& ((bfd_vma
) 1 << 31))
8382 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
8389 /* If we don't know that we have a 64-bit type,
8390 do two separate stores. */
8391 if (bfd_big_endian (input_bfd
))
8393 /* Undo what we did above. */
8395 /* Store the sign-bits (which are most significant)
8397 low_bits
= sign_bits
;
8403 high_bits
= sign_bits
;
8405 bfd_put_32 (input_bfd
, low_bits
,
8406 contents
+ rel
->r_offset
);
8407 bfd_put_32 (input_bfd
, high_bits
,
8408 contents
+ rel
->r_offset
+ 4);
8412 /* Actually perform the relocation. */
8413 if (! mips_elf_perform_relocation (info
, howto
, rel
, value
,
8414 input_bfd
, input_section
,
8415 contents
, require_jalx
))
8422 /* If NAME is one of the special IRIX6 symbols defined by the linker,
8423 adjust it appropriately now. */
8426 mips_elf_irix6_finish_dynamic_symbol (bfd
*abfd ATTRIBUTE_UNUSED
,
8427 const char *name
, Elf_Internal_Sym
*sym
)
8429 /* The linker script takes care of providing names and values for
8430 these, but we must place them into the right sections. */
8431 static const char* const text_section_symbols
[] = {
8434 "__dso_displacement",
8436 "__program_header_table",
8440 static const char* const data_section_symbols
[] = {
8448 const char* const *p
;
8451 for (i
= 0; i
< 2; ++i
)
8452 for (p
= (i
== 0) ? text_section_symbols
: data_section_symbols
;
8455 if (strcmp (*p
, name
) == 0)
8457 /* All of these symbols are given type STT_SECTION by the
8459 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8460 sym
->st_other
= STO_PROTECTED
;
8462 /* The IRIX linker puts these symbols in special sections. */
8464 sym
->st_shndx
= SHN_MIPS_TEXT
;
8466 sym
->st_shndx
= SHN_MIPS_DATA
;
8472 /* Finish up dynamic symbol handling. We set the contents of various
8473 dynamic sections here. */
8476 _bfd_mips_elf_finish_dynamic_symbol (bfd
*output_bfd
,
8477 struct bfd_link_info
*info
,
8478 struct elf_link_hash_entry
*h
,
8479 Elf_Internal_Sym
*sym
)
8483 struct mips_got_info
*g
, *gg
;
8486 struct mips_elf_link_hash_table
*htab
;
8488 htab
= mips_elf_hash_table (info
);
8489 dynobj
= elf_hash_table (info
)->dynobj
;
8491 if (h
->plt
.offset
!= MINUS_ONE
)
8494 bfd_byte stub
[MIPS_FUNCTION_STUB_BIG_SIZE
];
8496 /* This symbol has a stub. Set it up. */
8498 BFD_ASSERT (h
->dynindx
!= -1);
8500 s
= bfd_get_section_by_name (dynobj
,
8501 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
8502 BFD_ASSERT (s
!= NULL
);
8504 BFD_ASSERT ((htab
->function_stub_size
== MIPS_FUNCTION_STUB_BIG_SIZE
)
8505 || (h
->dynindx
<= 0xffff));
8507 /* Values up to 2^31 - 1 are allowed. Larger values would cause
8508 sign extension at runtime in the stub, resulting in a negative
8510 if (h
->dynindx
& ~0x7fffffff)
8513 /* Fill the stub. */
8515 bfd_put_32 (output_bfd
, STUB_LW (output_bfd
), stub
+ idx
);
8517 bfd_put_32 (output_bfd
, STUB_MOVE (output_bfd
), stub
+ idx
);
8519 if (htab
->function_stub_size
== MIPS_FUNCTION_STUB_BIG_SIZE
)
8521 bfd_put_32 (output_bfd
, STUB_LUI ((h
->dynindx
>> 16) & 0x7fff),
8525 bfd_put_32 (output_bfd
, STUB_JALR
, stub
+ idx
);
8528 /* If a large stub is not required and sign extension is not a
8529 problem, then use legacy code in the stub. */
8530 if (htab
->function_stub_size
== MIPS_FUNCTION_STUB_BIG_SIZE
)
8531 bfd_put_32 (output_bfd
, STUB_ORI (h
->dynindx
& 0xffff), stub
+ idx
);
8532 else if (h
->dynindx
& ~0x7fff)
8533 bfd_put_32 (output_bfd
, STUB_LI16U (h
->dynindx
& 0xffff), stub
+ idx
);
8535 bfd_put_32 (output_bfd
, STUB_LI16S (output_bfd
, h
->dynindx
),
8538 BFD_ASSERT (h
->plt
.offset
<= s
->size
);
8539 memcpy (s
->contents
+ h
->plt
.offset
, stub
, htab
->function_stub_size
);
8541 /* Mark the symbol as undefined. plt.offset != -1 occurs
8542 only for the referenced symbol. */
8543 sym
->st_shndx
= SHN_UNDEF
;
8545 /* The run-time linker uses the st_value field of the symbol
8546 to reset the global offset table entry for this external
8547 to its stub address when unlinking a shared object. */
8548 sym
->st_value
= (s
->output_section
->vma
+ s
->output_offset
8552 BFD_ASSERT (h
->dynindx
!= -1
8553 || h
->forced_local
);
8555 sgot
= mips_elf_got_section (dynobj
, FALSE
);
8556 BFD_ASSERT (sgot
!= NULL
);
8557 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
8558 g
= mips_elf_section_data (sgot
)->u
.got_info
;
8559 BFD_ASSERT (g
!= NULL
);
8561 /* Run through the global symbol table, creating GOT entries for all
8562 the symbols that need them. */
8563 if (g
->global_gotsym
!= NULL
8564 && h
->dynindx
>= g
->global_gotsym
->dynindx
)
8569 value
= sym
->st_value
;
8570 offset
= mips_elf_global_got_index (dynobj
, output_bfd
, h
, R_MIPS_GOT16
, info
);
8571 MIPS_ELF_PUT_WORD (output_bfd
, value
, sgot
->contents
+ offset
);
8574 if (g
->next
&& h
->dynindx
!= -1 && h
->type
!= STT_TLS
)
8576 struct mips_got_entry e
, *p
;
8582 e
.abfd
= output_bfd
;
8584 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
8587 for (g
= g
->next
; g
->next
!= gg
; g
= g
->next
)
8590 && (p
= (struct mips_got_entry
*) htab_find (g
->got_entries
,
8595 || (elf_hash_table (info
)->dynamic_sections_created
8597 && p
->d
.h
->root
.def_dynamic
8598 && !p
->d
.h
->root
.def_regular
))
8600 /* Create an R_MIPS_REL32 relocation for this entry. Due to
8601 the various compatibility problems, it's easier to mock
8602 up an R_MIPS_32 or R_MIPS_64 relocation and leave
8603 mips_elf_create_dynamic_relocation to calculate the
8604 appropriate addend. */
8605 Elf_Internal_Rela rel
[3];
8607 memset (rel
, 0, sizeof (rel
));
8608 if (ABI_64_P (output_bfd
))
8609 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_64
);
8611 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_32
);
8612 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
8615 if (! (mips_elf_create_dynamic_relocation
8616 (output_bfd
, info
, rel
,
8617 e
.d
.h
, NULL
, sym
->st_value
, &entry
, sgot
)))
8621 entry
= sym
->st_value
;
8622 MIPS_ELF_PUT_WORD (output_bfd
, entry
, sgot
->contents
+ offset
);
8627 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
8628 name
= h
->root
.root
.string
;
8629 if (strcmp (name
, "_DYNAMIC") == 0
8630 || h
== elf_hash_table (info
)->hgot
)
8631 sym
->st_shndx
= SHN_ABS
;
8632 else if (strcmp (name
, "_DYNAMIC_LINK") == 0
8633 || strcmp (name
, "_DYNAMIC_LINKING") == 0)
8635 sym
->st_shndx
= SHN_ABS
;
8636 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8639 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (output_bfd
))
8641 sym
->st_shndx
= SHN_ABS
;
8642 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8643 sym
->st_value
= elf_gp (output_bfd
);
8645 else if (SGI_COMPAT (output_bfd
))
8647 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
8648 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
8650 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8651 sym
->st_other
= STO_PROTECTED
;
8653 sym
->st_shndx
= SHN_MIPS_DATA
;
8655 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
8657 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8658 sym
->st_other
= STO_PROTECTED
;
8659 sym
->st_value
= mips_elf_hash_table (info
)->procedure_count
;
8660 sym
->st_shndx
= SHN_ABS
;
8662 else if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
!= SHN_ABS
)
8664 if (h
->type
== STT_FUNC
)
8665 sym
->st_shndx
= SHN_MIPS_TEXT
;
8666 else if (h
->type
== STT_OBJECT
)
8667 sym
->st_shndx
= SHN_MIPS_DATA
;
8671 /* Handle the IRIX6-specific symbols. */
8672 if (IRIX_COMPAT (output_bfd
) == ict_irix6
)
8673 mips_elf_irix6_finish_dynamic_symbol (output_bfd
, name
, sym
);
8677 if (! mips_elf_hash_table (info
)->use_rld_obj_head
8678 && (strcmp (name
, "__rld_map") == 0
8679 || strcmp (name
, "__RLD_MAP") == 0))
8681 asection
*s
= bfd_get_section_by_name (dynobj
, ".rld_map");
8682 BFD_ASSERT (s
!= NULL
);
8683 sym
->st_value
= s
->output_section
->vma
+ s
->output_offset
;
8684 bfd_put_32 (output_bfd
, 0, s
->contents
);
8685 if (mips_elf_hash_table (info
)->rld_value
== 0)
8686 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
8688 else if (mips_elf_hash_table (info
)->use_rld_obj_head
8689 && strcmp (name
, "__rld_obj_head") == 0)
8691 /* IRIX6 does not use a .rld_map section. */
8692 if (IRIX_COMPAT (output_bfd
) == ict_irix5
8693 || IRIX_COMPAT (output_bfd
) == ict_none
)
8694 BFD_ASSERT (bfd_get_section_by_name (dynobj
, ".rld_map")
8696 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
8700 /* If this is a mips16 symbol, force the value to be even. */
8701 if (sym
->st_other
== STO_MIPS16
)
8702 sym
->st_value
&= ~1;
8707 /* Likewise, for VxWorks. */
8710 _bfd_mips_vxworks_finish_dynamic_symbol (bfd
*output_bfd
,
8711 struct bfd_link_info
*info
,
8712 struct elf_link_hash_entry
*h
,
8713 Elf_Internal_Sym
*sym
)
8717 struct mips_got_info
*g
;
8718 struct mips_elf_link_hash_table
*htab
;
8720 htab
= mips_elf_hash_table (info
);
8721 dynobj
= elf_hash_table (info
)->dynobj
;
8723 if (h
->plt
.offset
!= (bfd_vma
) -1)
8726 bfd_vma plt_address
, plt_index
, got_address
, got_offset
, branch_offset
;
8727 Elf_Internal_Rela rel
;
8728 static const bfd_vma
*plt_entry
;
8730 BFD_ASSERT (h
->dynindx
!= -1);
8731 BFD_ASSERT (htab
->splt
!= NULL
);
8732 BFD_ASSERT (h
->plt
.offset
<= htab
->splt
->size
);
8734 /* Calculate the address of the .plt entry. */
8735 plt_address
= (htab
->splt
->output_section
->vma
8736 + htab
->splt
->output_offset
8739 /* Calculate the index of the entry. */
8740 plt_index
= ((h
->plt
.offset
- htab
->plt_header_size
)
8741 / htab
->plt_entry_size
);
8743 /* Calculate the address of the .got.plt entry. */
8744 got_address
= (htab
->sgotplt
->output_section
->vma
8745 + htab
->sgotplt
->output_offset
8748 /* Calculate the offset of the .got.plt entry from
8749 _GLOBAL_OFFSET_TABLE_. */
8750 got_offset
= mips_elf_gotplt_index (info
, h
);
8752 /* Calculate the offset for the branch at the start of the PLT
8753 entry. The branch jumps to the beginning of .plt. */
8754 branch_offset
= -(h
->plt
.offset
/ 4 + 1) & 0xffff;
8756 /* Fill in the initial value of the .got.plt entry. */
8757 bfd_put_32 (output_bfd
, plt_address
,
8758 htab
->sgotplt
->contents
+ plt_index
* 4);
8760 /* Find out where the .plt entry should go. */
8761 loc
= htab
->splt
->contents
+ h
->plt
.offset
;
8765 plt_entry
= mips_vxworks_shared_plt_entry
;
8766 bfd_put_32 (output_bfd
, plt_entry
[0] | branch_offset
, loc
);
8767 bfd_put_32 (output_bfd
, plt_entry
[1] | plt_index
, loc
+ 4);
8771 bfd_vma got_address_high
, got_address_low
;
8773 plt_entry
= mips_vxworks_exec_plt_entry
;
8774 got_address_high
= ((got_address
+ 0x8000) >> 16) & 0xffff;
8775 got_address_low
= got_address
& 0xffff;
8777 bfd_put_32 (output_bfd
, plt_entry
[0] | branch_offset
, loc
);
8778 bfd_put_32 (output_bfd
, plt_entry
[1] | plt_index
, loc
+ 4);
8779 bfd_put_32 (output_bfd
, plt_entry
[2] | got_address_high
, loc
+ 8);
8780 bfd_put_32 (output_bfd
, plt_entry
[3] | got_address_low
, loc
+ 12);
8781 bfd_put_32 (output_bfd
, plt_entry
[4], loc
+ 16);
8782 bfd_put_32 (output_bfd
, plt_entry
[5], loc
+ 20);
8783 bfd_put_32 (output_bfd
, plt_entry
[6], loc
+ 24);
8784 bfd_put_32 (output_bfd
, plt_entry
[7], loc
+ 28);
8786 loc
= (htab
->srelplt2
->contents
8787 + (plt_index
* 3 + 2) * sizeof (Elf32_External_Rela
));
8789 /* Emit a relocation for the .got.plt entry. */
8790 rel
.r_offset
= got_address
;
8791 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
, R_MIPS_32
);
8792 rel
.r_addend
= h
->plt
.offset
;
8793 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
8795 /* Emit a relocation for the lui of %hi(<.got.plt slot>). */
8796 loc
+= sizeof (Elf32_External_Rela
);
8797 rel
.r_offset
= plt_address
+ 8;
8798 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_HI16
);
8799 rel
.r_addend
= got_offset
;
8800 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
8802 /* Emit a relocation for the addiu of %lo(<.got.plt slot>). */
8803 loc
+= sizeof (Elf32_External_Rela
);
8805 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_LO16
);
8806 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
8809 /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry. */
8810 loc
= htab
->srelplt
->contents
+ plt_index
* sizeof (Elf32_External_Rela
);
8811 rel
.r_offset
= got_address
;
8812 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_JUMP_SLOT
);
8814 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
8816 if (!h
->def_regular
)
8817 sym
->st_shndx
= SHN_UNDEF
;
8820 BFD_ASSERT (h
->dynindx
!= -1 || h
->forced_local
);
8822 sgot
= mips_elf_got_section (dynobj
, FALSE
);
8823 BFD_ASSERT (sgot
!= NULL
);
8824 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
8825 g
= mips_elf_section_data (sgot
)->u
.got_info
;
8826 BFD_ASSERT (g
!= NULL
);
8828 /* See if this symbol has an entry in the GOT. */
8829 if (g
->global_gotsym
!= NULL
8830 && h
->dynindx
>= g
->global_gotsym
->dynindx
)
8833 Elf_Internal_Rela outrel
;
8837 /* Install the symbol value in the GOT. */
8838 offset
= mips_elf_global_got_index (dynobj
, output_bfd
, h
,
8839 R_MIPS_GOT16
, info
);
8840 MIPS_ELF_PUT_WORD (output_bfd
, sym
->st_value
, sgot
->contents
+ offset
);
8842 /* Add a dynamic relocation for it. */
8843 s
= mips_elf_rel_dyn_section (info
, FALSE
);
8844 loc
= s
->contents
+ (s
->reloc_count
++ * sizeof (Elf32_External_Rela
));
8845 outrel
.r_offset
= (sgot
->output_section
->vma
8846 + sgot
->output_offset
8848 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_32
);
8849 outrel
.r_addend
= 0;
8850 bfd_elf32_swap_reloca_out (dynobj
, &outrel
, loc
);
8853 /* Emit a copy reloc, if needed. */
8856 Elf_Internal_Rela rel
;
8858 BFD_ASSERT (h
->dynindx
!= -1);
8860 rel
.r_offset
= (h
->root
.u
.def
.section
->output_section
->vma
8861 + h
->root
.u
.def
.section
->output_offset
8862 + h
->root
.u
.def
.value
);
8863 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_COPY
);
8865 bfd_elf32_swap_reloca_out (output_bfd
, &rel
,
8866 htab
->srelbss
->contents
8867 + (htab
->srelbss
->reloc_count
8868 * sizeof (Elf32_External_Rela
)));
8869 ++htab
->srelbss
->reloc_count
;
8872 /* If this is a mips16 symbol, force the value to be even. */
8873 if (sym
->st_other
== STO_MIPS16
)
8874 sym
->st_value
&= ~1;
8879 /* Install the PLT header for a VxWorks executable and finalize the
8880 contents of .rela.plt.unloaded. */
8883 mips_vxworks_finish_exec_plt (bfd
*output_bfd
, struct bfd_link_info
*info
)
8885 Elf_Internal_Rela rela
;
8887 bfd_vma got_value
, got_value_high
, got_value_low
, plt_address
;
8888 static const bfd_vma
*plt_entry
;
8889 struct mips_elf_link_hash_table
*htab
;
8891 htab
= mips_elf_hash_table (info
);
8892 plt_entry
= mips_vxworks_exec_plt0_entry
;
8894 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */
8895 got_value
= (htab
->root
.hgot
->root
.u
.def
.section
->output_section
->vma
8896 + htab
->root
.hgot
->root
.u
.def
.section
->output_offset
8897 + htab
->root
.hgot
->root
.u
.def
.value
);
8899 got_value_high
= ((got_value
+ 0x8000) >> 16) & 0xffff;
8900 got_value_low
= got_value
& 0xffff;
8902 /* Calculate the address of the PLT header. */
8903 plt_address
= htab
->splt
->output_section
->vma
+ htab
->splt
->output_offset
;
8905 /* Install the PLT header. */
8906 loc
= htab
->splt
->contents
;
8907 bfd_put_32 (output_bfd
, plt_entry
[0] | got_value_high
, loc
);
8908 bfd_put_32 (output_bfd
, plt_entry
[1] | got_value_low
, loc
+ 4);
8909 bfd_put_32 (output_bfd
, plt_entry
[2], loc
+ 8);
8910 bfd_put_32 (output_bfd
, plt_entry
[3], loc
+ 12);
8911 bfd_put_32 (output_bfd
, plt_entry
[4], loc
+ 16);
8912 bfd_put_32 (output_bfd
, plt_entry
[5], loc
+ 20);
8914 /* Output the relocation for the lui of %hi(_GLOBAL_OFFSET_TABLE_). */
8915 loc
= htab
->srelplt2
->contents
;
8916 rela
.r_offset
= plt_address
;
8917 rela
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_HI16
);
8919 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
8920 loc
+= sizeof (Elf32_External_Rela
);
8922 /* Output the relocation for the following addiu of
8923 %lo(_GLOBAL_OFFSET_TABLE_). */
8925 rela
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_LO16
);
8926 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
8927 loc
+= sizeof (Elf32_External_Rela
);
8929 /* Fix up the remaining relocations. They may have the wrong
8930 symbol index for _G_O_T_ or _P_L_T_ depending on the order
8931 in which symbols were output. */
8932 while (loc
< htab
->srelplt2
->contents
+ htab
->srelplt2
->size
)
8934 Elf_Internal_Rela rel
;
8936 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &rel
);
8937 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
, R_MIPS_32
);
8938 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
8939 loc
+= sizeof (Elf32_External_Rela
);
8941 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &rel
);
8942 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_HI16
);
8943 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
8944 loc
+= sizeof (Elf32_External_Rela
);
8946 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &rel
);
8947 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_LO16
);
8948 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
8949 loc
+= sizeof (Elf32_External_Rela
);
8953 /* Install the PLT header for a VxWorks shared library. */
8956 mips_vxworks_finish_shared_plt (bfd
*output_bfd
, struct bfd_link_info
*info
)
8959 struct mips_elf_link_hash_table
*htab
;
8961 htab
= mips_elf_hash_table (info
);
8963 /* We just need to copy the entry byte-by-byte. */
8964 for (i
= 0; i
< ARRAY_SIZE (mips_vxworks_shared_plt0_entry
); i
++)
8965 bfd_put_32 (output_bfd
, mips_vxworks_shared_plt0_entry
[i
],
8966 htab
->splt
->contents
+ i
* 4);
8969 /* Finish up the dynamic sections. */
8972 _bfd_mips_elf_finish_dynamic_sections (bfd
*output_bfd
,
8973 struct bfd_link_info
*info
)
8978 struct mips_got_info
*gg
, *g
;
8979 struct mips_elf_link_hash_table
*htab
;
8981 htab
= mips_elf_hash_table (info
);
8982 dynobj
= elf_hash_table (info
)->dynobj
;
8984 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
8986 sgot
= mips_elf_got_section (dynobj
, FALSE
);
8991 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
8992 gg
= mips_elf_section_data (sgot
)->u
.got_info
;
8993 BFD_ASSERT (gg
!= NULL
);
8994 g
= mips_elf_got_for_ibfd (gg
, output_bfd
);
8995 BFD_ASSERT (g
!= NULL
);
8998 if (elf_hash_table (info
)->dynamic_sections_created
)
9001 int dyn_to_skip
= 0, dyn_skipped
= 0;
9003 BFD_ASSERT (sdyn
!= NULL
);
9004 BFD_ASSERT (g
!= NULL
);
9006 for (b
= sdyn
->contents
;
9007 b
< sdyn
->contents
+ sdyn
->size
;
9008 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
9010 Elf_Internal_Dyn dyn
;
9014 bfd_boolean swap_out_p
;
9016 /* Read in the current dynamic entry. */
9017 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
9019 /* Assume that we're going to modify it and write it out. */
9025 dyn
.d_un
.d_val
= MIPS_ELF_REL_SIZE (dynobj
);
9029 BFD_ASSERT (htab
->is_vxworks
);
9030 dyn
.d_un
.d_val
= MIPS_ELF_RELA_SIZE (dynobj
);
9034 /* Rewrite DT_STRSZ. */
9036 _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
9041 if (htab
->is_vxworks
)
9043 /* _GLOBAL_OFFSET_TABLE_ is defined to be the beginning
9044 of the ".got" section in DYNOBJ. */
9045 s
= bfd_get_section_by_name (dynobj
, name
);
9046 BFD_ASSERT (s
!= NULL
);
9047 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
9051 s
= bfd_get_section_by_name (output_bfd
, name
);
9052 BFD_ASSERT (s
!= NULL
);
9053 dyn
.d_un
.d_ptr
= s
->vma
;
9057 case DT_MIPS_RLD_VERSION
:
9058 dyn
.d_un
.d_val
= 1; /* XXX */
9062 dyn
.d_un
.d_val
= RHF_NOTPOT
; /* XXX */
9065 case DT_MIPS_TIME_STAMP
:
9073 case DT_MIPS_ICHECKSUM
:
9078 case DT_MIPS_IVERSION
:
9083 case DT_MIPS_BASE_ADDRESS
:
9084 s
= output_bfd
->sections
;
9085 BFD_ASSERT (s
!= NULL
);
9086 dyn
.d_un
.d_ptr
= s
->vma
& ~(bfd_vma
) 0xffff;
9089 case DT_MIPS_LOCAL_GOTNO
:
9090 dyn
.d_un
.d_val
= g
->local_gotno
;
9093 case DT_MIPS_UNREFEXTNO
:
9094 /* The index into the dynamic symbol table which is the
9095 entry of the first external symbol that is not
9096 referenced within the same object. */
9097 dyn
.d_un
.d_val
= bfd_count_sections (output_bfd
) + 1;
9100 case DT_MIPS_GOTSYM
:
9101 if (gg
->global_gotsym
)
9103 dyn
.d_un
.d_val
= gg
->global_gotsym
->dynindx
;
9106 /* In case if we don't have global got symbols we default
9107 to setting DT_MIPS_GOTSYM to the same value as
9108 DT_MIPS_SYMTABNO, so we just fall through. */
9110 case DT_MIPS_SYMTABNO
:
9112 elemsize
= MIPS_ELF_SYM_SIZE (output_bfd
);
9113 s
= bfd_get_section_by_name (output_bfd
, name
);
9114 BFD_ASSERT (s
!= NULL
);
9116 dyn
.d_un
.d_val
= s
->size
/ elemsize
;
9119 case DT_MIPS_HIPAGENO
:
9120 dyn
.d_un
.d_val
= g
->local_gotno
- MIPS_RESERVED_GOTNO (info
);
9123 case DT_MIPS_RLD_MAP
:
9124 dyn
.d_un
.d_ptr
= mips_elf_hash_table (info
)->rld_value
;
9127 case DT_MIPS_OPTIONS
:
9128 s
= (bfd_get_section_by_name
9129 (output_bfd
, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd
)));
9130 dyn
.d_un
.d_ptr
= s
->vma
;
9134 BFD_ASSERT (htab
->is_vxworks
);
9135 /* The count does not include the JUMP_SLOT relocations. */
9137 dyn
.d_un
.d_val
-= htab
->srelplt
->size
;
9141 BFD_ASSERT (htab
->is_vxworks
);
9142 dyn
.d_un
.d_val
= DT_RELA
;
9146 BFD_ASSERT (htab
->is_vxworks
);
9147 dyn
.d_un
.d_val
= htab
->srelplt
->size
;
9151 BFD_ASSERT (htab
->is_vxworks
);
9152 dyn
.d_un
.d_val
= (htab
->srelplt
->output_section
->vma
9153 + htab
->srelplt
->output_offset
);
9157 /* If we didn't need any text relocations after all, delete
9159 if (!(info
->flags
& DF_TEXTREL
))
9161 dyn_to_skip
= MIPS_ELF_DYN_SIZE (dynobj
);
9167 /* If we didn't need any text relocations after all, clear
9168 DF_TEXTREL from DT_FLAGS. */
9169 if (!(info
->flags
& DF_TEXTREL
))
9170 dyn
.d_un
.d_val
&= ~DF_TEXTREL
;
9177 if (htab
->is_vxworks
9178 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
9183 if (swap_out_p
|| dyn_skipped
)
9184 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
9185 (dynobj
, &dyn
, b
- dyn_skipped
);
9189 dyn_skipped
+= dyn_to_skip
;
9194 /* Wipe out any trailing entries if we shifted down a dynamic tag. */
9195 if (dyn_skipped
> 0)
9196 memset (b
- dyn_skipped
, 0, dyn_skipped
);
9199 if (sgot
!= NULL
&& sgot
->size
> 0
9200 && !bfd_is_abs_section (sgot
->output_section
))
9202 if (htab
->is_vxworks
)
9204 /* The first entry of the global offset table points to the
9205 ".dynamic" section. The second is initialized by the
9206 loader and contains the shared library identifier.
9207 The third is also initialized by the loader and points
9208 to the lazy resolution stub. */
9209 MIPS_ELF_PUT_WORD (output_bfd
,
9210 sdyn
->output_offset
+ sdyn
->output_section
->vma
,
9212 MIPS_ELF_PUT_WORD (output_bfd
, 0,
9213 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
9214 MIPS_ELF_PUT_WORD (output_bfd
, 0,
9216 + 2 * MIPS_ELF_GOT_SIZE (output_bfd
));
9220 /* The first entry of the global offset table will be filled at
9221 runtime. The second entry will be used by some runtime loaders.
9222 This isn't the case of IRIX rld. */
9223 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
9224 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0x80000000,
9225 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
9228 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
9229 = MIPS_ELF_GOT_SIZE (output_bfd
);
9232 /* Generate dynamic relocations for the non-primary gots. */
9233 if (gg
!= NULL
&& gg
->next
)
9235 Elf_Internal_Rela rel
[3];
9238 memset (rel
, 0, sizeof (rel
));
9239 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_REL32
);
9241 for (g
= gg
->next
; g
->next
!= gg
; g
= g
->next
)
9243 bfd_vma index
= g
->next
->local_gotno
+ g
->next
->global_gotno
9244 + g
->next
->tls_gotno
;
9246 MIPS_ELF_PUT_WORD (output_bfd
, 0, sgot
->contents
9247 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
9248 MIPS_ELF_PUT_WORD (output_bfd
, 0x80000000, sgot
->contents
9249 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
9254 while (index
< g
->assigned_gotno
)
9256 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
9257 = index
++ * MIPS_ELF_GOT_SIZE (output_bfd
);
9258 if (!(mips_elf_create_dynamic_relocation
9259 (output_bfd
, info
, rel
, NULL
,
9260 bfd_abs_section_ptr
,
9263 BFD_ASSERT (addend
== 0);
9268 /* The generation of dynamic relocations for the non-primary gots
9269 adds more dynamic relocations. We cannot count them until
9272 if (elf_hash_table (info
)->dynamic_sections_created
)
9275 bfd_boolean swap_out_p
;
9277 BFD_ASSERT (sdyn
!= NULL
);
9279 for (b
= sdyn
->contents
;
9280 b
< sdyn
->contents
+ sdyn
->size
;
9281 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
9283 Elf_Internal_Dyn dyn
;
9286 /* Read in the current dynamic entry. */
9287 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
9289 /* Assume that we're going to modify it and write it out. */
9295 /* Reduce DT_RELSZ to account for any relocations we
9296 decided not to make. This is for the n64 irix rld,
9297 which doesn't seem to apply any relocations if there
9298 are trailing null entries. */
9299 s
= mips_elf_rel_dyn_section (info
, FALSE
);
9300 dyn
.d_un
.d_val
= (s
->reloc_count
9301 * (ABI_64_P (output_bfd
)
9302 ? sizeof (Elf64_Mips_External_Rel
)
9303 : sizeof (Elf32_External_Rel
)));
9304 /* Adjust the section size too. Tools like the prelinker
9305 can reasonably expect the values to the same. */
9306 elf_section_data (s
->output_section
)->this_hdr
.sh_size
9316 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
9323 Elf32_compact_rel cpt
;
9325 if (SGI_COMPAT (output_bfd
))
9327 /* Write .compact_rel section out. */
9328 s
= bfd_get_section_by_name (dynobj
, ".compact_rel");
9332 cpt
.num
= s
->reloc_count
;
9334 cpt
.offset
= (s
->output_section
->filepos
9335 + sizeof (Elf32_External_compact_rel
));
9338 bfd_elf32_swap_compact_rel_out (output_bfd
, &cpt
,
9339 ((Elf32_External_compact_rel
*)
9342 /* Clean up a dummy stub function entry in .text. */
9343 s
= bfd_get_section_by_name (dynobj
,
9344 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
9347 file_ptr dummy_offset
;
9349 BFD_ASSERT (s
->size
>= htab
->function_stub_size
);
9350 dummy_offset
= s
->size
- htab
->function_stub_size
;
9351 memset (s
->contents
+ dummy_offset
, 0,
9352 htab
->function_stub_size
);
9357 /* The psABI says that the dynamic relocations must be sorted in
9358 increasing order of r_symndx. The VxWorks EABI doesn't require
9359 this, and because the code below handles REL rather than RELA
9360 relocations, using it for VxWorks would be outright harmful. */
9361 if (!htab
->is_vxworks
)
9363 s
= mips_elf_rel_dyn_section (info
, FALSE
);
9365 && s
->size
> (bfd_vma
)2 * MIPS_ELF_REL_SIZE (output_bfd
))
9367 reldyn_sorting_bfd
= output_bfd
;
9369 if (ABI_64_P (output_bfd
))
9370 qsort ((Elf64_External_Rel
*) s
->contents
+ 1,
9371 s
->reloc_count
- 1, sizeof (Elf64_Mips_External_Rel
),
9372 sort_dynamic_relocs_64
);
9374 qsort ((Elf32_External_Rel
*) s
->contents
+ 1,
9375 s
->reloc_count
- 1, sizeof (Elf32_External_Rel
),
9376 sort_dynamic_relocs
);
9381 if (htab
->is_vxworks
&& htab
->splt
->size
> 0)
9384 mips_vxworks_finish_shared_plt (output_bfd
, info
);
9386 mips_vxworks_finish_exec_plt (output_bfd
, info
);
9392 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
9395 mips_set_isa_flags (bfd
*abfd
)
9399 switch (bfd_get_mach (abfd
))
9402 case bfd_mach_mips3000
:
9403 val
= E_MIPS_ARCH_1
;
9406 case bfd_mach_mips3900
:
9407 val
= E_MIPS_ARCH_1
| E_MIPS_MACH_3900
;
9410 case bfd_mach_mips6000
:
9411 val
= E_MIPS_ARCH_2
;
9414 case bfd_mach_mips4000
:
9415 case bfd_mach_mips4300
:
9416 case bfd_mach_mips4400
:
9417 case bfd_mach_mips4600
:
9418 val
= E_MIPS_ARCH_3
;
9421 case bfd_mach_mips4010
:
9422 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4010
;
9425 case bfd_mach_mips4100
:
9426 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4100
;
9429 case bfd_mach_mips4111
:
9430 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4111
;
9433 case bfd_mach_mips4120
:
9434 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4120
;
9437 case bfd_mach_mips4650
:
9438 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4650
;
9441 case bfd_mach_mips5400
:
9442 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5400
;
9445 case bfd_mach_mips5500
:
9446 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5500
;
9449 case bfd_mach_mips9000
:
9450 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_9000
;
9453 case bfd_mach_mips5000
:
9454 case bfd_mach_mips7000
:
9455 case bfd_mach_mips8000
:
9456 case bfd_mach_mips10000
:
9457 case bfd_mach_mips12000
:
9458 val
= E_MIPS_ARCH_4
;
9461 case bfd_mach_mips5
:
9462 val
= E_MIPS_ARCH_5
;
9465 case bfd_mach_mips_sb1
:
9466 val
= E_MIPS_ARCH_64
| E_MIPS_MACH_SB1
;
9469 case bfd_mach_mipsisa32
:
9470 val
= E_MIPS_ARCH_32
;
9473 case bfd_mach_mipsisa64
:
9474 val
= E_MIPS_ARCH_64
;
9477 case bfd_mach_mipsisa32r2
:
9478 val
= E_MIPS_ARCH_32R2
;
9481 case bfd_mach_mipsisa64r2
:
9482 val
= E_MIPS_ARCH_64R2
;
9485 elf_elfheader (abfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
9486 elf_elfheader (abfd
)->e_flags
|= val
;
9491 /* The final processing done just before writing out a MIPS ELF object
9492 file. This gets the MIPS architecture right based on the machine
9493 number. This is used by both the 32-bit and the 64-bit ABI. */
9496 _bfd_mips_elf_final_write_processing (bfd
*abfd
,
9497 bfd_boolean linker ATTRIBUTE_UNUSED
)
9500 Elf_Internal_Shdr
**hdrpp
;
9504 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
9505 is nonzero. This is for compatibility with old objects, which used
9506 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
9507 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_MACH
) == 0)
9508 mips_set_isa_flags (abfd
);
9510 /* Set the sh_info field for .gptab sections and other appropriate
9511 info for each special section. */
9512 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
9513 i
< elf_numsections (abfd
);
9516 switch ((*hdrpp
)->sh_type
)
9519 case SHT_MIPS_LIBLIST
:
9520 sec
= bfd_get_section_by_name (abfd
, ".dynstr");
9522 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
9525 case SHT_MIPS_GPTAB
:
9526 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
9527 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
9528 BFD_ASSERT (name
!= NULL
9529 && CONST_STRNEQ (name
, ".gptab."));
9530 sec
= bfd_get_section_by_name (abfd
, name
+ sizeof ".gptab" - 1);
9531 BFD_ASSERT (sec
!= NULL
);
9532 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
9535 case SHT_MIPS_CONTENT
:
9536 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
9537 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
9538 BFD_ASSERT (name
!= NULL
9539 && CONST_STRNEQ (name
, ".MIPS.content"));
9540 sec
= bfd_get_section_by_name (abfd
,
9541 name
+ sizeof ".MIPS.content" - 1);
9542 BFD_ASSERT (sec
!= NULL
);
9543 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
9546 case SHT_MIPS_SYMBOL_LIB
:
9547 sec
= bfd_get_section_by_name (abfd
, ".dynsym");
9549 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
9550 sec
= bfd_get_section_by_name (abfd
, ".liblist");
9552 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
9555 case SHT_MIPS_EVENTS
:
9556 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
9557 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
9558 BFD_ASSERT (name
!= NULL
);
9559 if (CONST_STRNEQ (name
, ".MIPS.events"))
9560 sec
= bfd_get_section_by_name (abfd
,
9561 name
+ sizeof ".MIPS.events" - 1);
9564 BFD_ASSERT (CONST_STRNEQ (name
, ".MIPS.post_rel"));
9565 sec
= bfd_get_section_by_name (abfd
,
9567 + sizeof ".MIPS.post_rel" - 1));
9569 BFD_ASSERT (sec
!= NULL
);
9570 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
9577 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
9581 _bfd_mips_elf_additional_program_headers (bfd
*abfd
,
9582 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
9587 /* See if we need a PT_MIPS_REGINFO segment. */
9588 s
= bfd_get_section_by_name (abfd
, ".reginfo");
9589 if (s
&& (s
->flags
& SEC_LOAD
))
9592 /* See if we need a PT_MIPS_OPTIONS segment. */
9593 if (IRIX_COMPAT (abfd
) == ict_irix6
9594 && bfd_get_section_by_name (abfd
,
9595 MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)))
9598 /* See if we need a PT_MIPS_RTPROC segment. */
9599 if (IRIX_COMPAT (abfd
) == ict_irix5
9600 && bfd_get_section_by_name (abfd
, ".dynamic")
9601 && bfd_get_section_by_name (abfd
, ".mdebug"))
9604 /* Allocate a PT_NULL header in dynamic objects. See
9605 _bfd_mips_elf_modify_segment_map for details. */
9606 if (!SGI_COMPAT (abfd
)
9607 && bfd_get_section_by_name (abfd
, ".dynamic"))
9613 /* Modify the segment map for an IRIX5 executable. */
9616 _bfd_mips_elf_modify_segment_map (bfd
*abfd
,
9617 struct bfd_link_info
*info
)
9620 struct elf_segment_map
*m
, **pm
;
9623 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
9625 s
= bfd_get_section_by_name (abfd
, ".reginfo");
9626 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
9628 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
9629 if (m
->p_type
== PT_MIPS_REGINFO
)
9634 m
= bfd_zalloc (abfd
, amt
);
9638 m
->p_type
= PT_MIPS_REGINFO
;
9642 /* We want to put it after the PHDR and INTERP segments. */
9643 pm
= &elf_tdata (abfd
)->segment_map
;
9645 && ((*pm
)->p_type
== PT_PHDR
9646 || (*pm
)->p_type
== PT_INTERP
))
9654 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
9655 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
9656 PT_MIPS_OPTIONS segment immediately following the program header
9659 /* On non-IRIX6 new abi, we'll have already created a segment
9660 for this section, so don't create another. I'm not sure this
9661 is not also the case for IRIX 6, but I can't test it right
9663 && IRIX_COMPAT (abfd
) == ict_irix6
)
9665 for (s
= abfd
->sections
; s
; s
= s
->next
)
9666 if (elf_section_data (s
)->this_hdr
.sh_type
== SHT_MIPS_OPTIONS
)
9671 struct elf_segment_map
*options_segment
;
9673 pm
= &elf_tdata (abfd
)->segment_map
;
9675 && ((*pm
)->p_type
== PT_PHDR
9676 || (*pm
)->p_type
== PT_INTERP
))
9679 if (*pm
== NULL
|| (*pm
)->p_type
!= PT_MIPS_OPTIONS
)
9681 amt
= sizeof (struct elf_segment_map
);
9682 options_segment
= bfd_zalloc (abfd
, amt
);
9683 options_segment
->next
= *pm
;
9684 options_segment
->p_type
= PT_MIPS_OPTIONS
;
9685 options_segment
->p_flags
= PF_R
;
9686 options_segment
->p_flags_valid
= TRUE
;
9687 options_segment
->count
= 1;
9688 options_segment
->sections
[0] = s
;
9689 *pm
= options_segment
;
9695 if (IRIX_COMPAT (abfd
) == ict_irix5
)
9697 /* If there are .dynamic and .mdebug sections, we make a room
9698 for the RTPROC header. FIXME: Rewrite without section names. */
9699 if (bfd_get_section_by_name (abfd
, ".interp") == NULL
9700 && bfd_get_section_by_name (abfd
, ".dynamic") != NULL
9701 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
9703 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
9704 if (m
->p_type
== PT_MIPS_RTPROC
)
9709 m
= bfd_zalloc (abfd
, amt
);
9713 m
->p_type
= PT_MIPS_RTPROC
;
9715 s
= bfd_get_section_by_name (abfd
, ".rtproc");
9720 m
->p_flags_valid
= 1;
9728 /* We want to put it after the DYNAMIC segment. */
9729 pm
= &elf_tdata (abfd
)->segment_map
;
9730 while (*pm
!= NULL
&& (*pm
)->p_type
!= PT_DYNAMIC
)
9740 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
9741 .dynstr, .dynsym, and .hash sections, and everything in
9743 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
;
9745 if ((*pm
)->p_type
== PT_DYNAMIC
)
9748 if (m
!= NULL
&& IRIX_COMPAT (abfd
) == ict_none
)
9750 /* For a normal mips executable the permissions for the PT_DYNAMIC
9751 segment are read, write and execute. We do that here since
9752 the code in elf.c sets only the read permission. This matters
9753 sometimes for the dynamic linker. */
9754 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
9756 m
->p_flags
= PF_R
| PF_W
| PF_X
;
9757 m
->p_flags_valid
= 1;
9760 /* GNU/Linux binaries do not need the extended PT_DYNAMIC section.
9761 glibc's dynamic linker has traditionally derived the number of
9762 tags from the p_filesz field, and sometimes allocates stack
9763 arrays of that size. An overly-big PT_DYNAMIC segment can
9764 be actively harmful in such cases. Making PT_DYNAMIC contain
9765 other sections can also make life hard for the prelinker,
9766 which might move one of the other sections to a different
9768 if (SGI_COMPAT (abfd
)
9771 && strcmp (m
->sections
[0]->name
, ".dynamic") == 0)
9773 static const char *sec_names
[] =
9775 ".dynamic", ".dynstr", ".dynsym", ".hash"
9779 struct elf_segment_map
*n
;
9783 for (i
= 0; i
< sizeof sec_names
/ sizeof sec_names
[0]; i
++)
9785 s
= bfd_get_section_by_name (abfd
, sec_names
[i
]);
9786 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
9793 if (high
< s
->vma
+ sz
)
9799 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
9800 if ((s
->flags
& SEC_LOAD
) != 0
9802 && s
->vma
+ s
->size
<= high
)
9805 amt
= sizeof *n
+ (bfd_size_type
) (c
- 1) * sizeof (asection
*);
9806 n
= bfd_zalloc (abfd
, amt
);
9813 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
9815 if ((s
->flags
& SEC_LOAD
) != 0
9817 && s
->vma
+ s
->size
<= high
)
9828 /* Allocate a spare program header in dynamic objects so that tools
9829 like the prelinker can add an extra PT_LOAD entry.
9831 If the prelinker needs to make room for a new PT_LOAD entry, its
9832 standard procedure is to move the first (read-only) sections into
9833 the new (writable) segment. However, the MIPS ABI requires
9834 .dynamic to be in a read-only segment, and the section will often
9835 start within sizeof (ElfNN_Phdr) bytes of the last program header.
9837 Although the prelinker could in principle move .dynamic to a
9838 writable segment, it seems better to allocate a spare program
9839 header instead, and avoid the need to move any sections.
9840 There is a long tradition of allocating spare dynamic tags,
9841 so allocating a spare program header seems like a natural
9844 If INFO is NULL, we may be copying an already prelinked binary
9845 with objcopy or strip, so do not add this header. */
9847 && !SGI_COMPAT (abfd
)
9848 && bfd_get_section_by_name (abfd
, ".dynamic"))
9850 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
; pm
= &(*pm
)->next
)
9851 if ((*pm
)->p_type
== PT_NULL
)
9855 m
= bfd_zalloc (abfd
, sizeof (*m
));
9859 m
->p_type
= PT_NULL
;
9867 /* Return the section that should be marked against GC for a given
9871 _bfd_mips_elf_gc_mark_hook (asection
*sec
,
9872 struct bfd_link_info
*info
,
9873 Elf_Internal_Rela
*rel
,
9874 struct elf_link_hash_entry
*h
,
9875 Elf_Internal_Sym
*sym
)
9877 /* ??? Do mips16 stub sections need to be handled special? */
9880 switch (ELF_R_TYPE (sec
->owner
, rel
->r_info
))
9882 case R_MIPS_GNU_VTINHERIT
:
9883 case R_MIPS_GNU_VTENTRY
:
9887 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
9890 /* Update the got entry reference counts for the section being removed. */
9893 _bfd_mips_elf_gc_sweep_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
9894 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
9895 asection
*sec ATTRIBUTE_UNUSED
,
9896 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
)
9899 Elf_Internal_Shdr
*symtab_hdr
;
9900 struct elf_link_hash_entry
**sym_hashes
;
9901 bfd_signed_vma
*local_got_refcounts
;
9902 const Elf_Internal_Rela
*rel
, *relend
;
9903 unsigned long r_symndx
;
9904 struct elf_link_hash_entry
*h
;
9906 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
9907 sym_hashes
= elf_sym_hashes (abfd
);
9908 local_got_refcounts
= elf_local_got_refcounts (abfd
);
9910 relend
= relocs
+ sec
->reloc_count
;
9911 for (rel
= relocs
; rel
< relend
; rel
++)
9912 switch (ELF_R_TYPE (abfd
, rel
->r_info
))
9916 case R_MIPS_CALL_HI16
:
9917 case R_MIPS_CALL_LO16
:
9918 case R_MIPS_GOT_HI16
:
9919 case R_MIPS_GOT_LO16
:
9920 case R_MIPS_GOT_DISP
:
9921 case R_MIPS_GOT_PAGE
:
9922 case R_MIPS_GOT_OFST
:
9923 /* ??? It would seem that the existing MIPS code does no sort
9924 of reference counting or whatnot on its GOT and PLT entries,
9925 so it is not possible to garbage collect them at this time. */
9936 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
9937 hiding the old indirect symbol. Process additional relocation
9938 information. Also called for weakdefs, in which case we just let
9939 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
9942 _bfd_mips_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
9943 struct elf_link_hash_entry
*dir
,
9944 struct elf_link_hash_entry
*ind
)
9946 struct mips_elf_link_hash_entry
*dirmips
, *indmips
;
9948 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
9950 if (ind
->root
.type
!= bfd_link_hash_indirect
)
9953 dirmips
= (struct mips_elf_link_hash_entry
*) dir
;
9954 indmips
= (struct mips_elf_link_hash_entry
*) ind
;
9955 dirmips
->possibly_dynamic_relocs
+= indmips
->possibly_dynamic_relocs
;
9956 if (indmips
->readonly_reloc
)
9957 dirmips
->readonly_reloc
= TRUE
;
9958 if (indmips
->no_fn_stub
)
9959 dirmips
->no_fn_stub
= TRUE
;
9961 if (dirmips
->tls_type
== 0)
9962 dirmips
->tls_type
= indmips
->tls_type
;
9966 _bfd_mips_elf_hide_symbol (struct bfd_link_info
*info
,
9967 struct elf_link_hash_entry
*entry
,
9968 bfd_boolean force_local
)
9972 struct mips_got_info
*g
;
9973 struct mips_elf_link_hash_entry
*h
;
9974 struct mips_elf_link_hash_table
*htab
;
9976 h
= (struct mips_elf_link_hash_entry
*) entry
;
9977 if (h
->forced_local
)
9979 h
->forced_local
= force_local
;
9981 dynobj
= elf_hash_table (info
)->dynobj
;
9982 htab
= mips_elf_hash_table (info
);
9983 if (dynobj
!= NULL
&& force_local
&& h
->root
.type
!= STT_TLS
9984 && (got
= mips_elf_got_section (dynobj
, TRUE
)) != NULL
9985 && (g
= mips_elf_section_data (got
)->u
.got_info
) != NULL
)
9989 struct mips_got_entry e
;
9990 struct mips_got_info
*gg
= g
;
9992 /* Since we're turning what used to be a global symbol into a
9993 local one, bump up the number of local entries of each GOT
9994 that had an entry for it. This will automatically decrease
9995 the number of global entries, since global_gotno is actually
9996 the upper limit of global entries. */
10002 for (g
= g
->next
; g
!= gg
; g
= g
->next
)
10003 if (htab_find (g
->got_entries
, &e
))
10005 BFD_ASSERT (g
->global_gotno
> 0);
10010 /* If this was a global symbol forced into the primary GOT, we
10011 no longer need an entry for it. We can't release the entry
10012 at this point, but we must at least stop counting it as one
10013 of the symbols that required a forced got entry. */
10014 if (h
->root
.got
.offset
== 2)
10016 BFD_ASSERT (gg
->assigned_gotno
> 0);
10017 gg
->assigned_gotno
--;
10020 else if (h
->root
.got
.offset
== 1)
10022 /* check_relocs didn't know that this symbol would be
10023 forced-local, so add an extra local got entry. */
10025 if (htab
->computed_got_sizes
)
10027 /* We'll have treated this symbol as global rather
10029 BFD_ASSERT (g
->global_gotno
> 0);
10033 else if (htab
->is_vxworks
&& h
->root
.needs_plt
)
10035 /* check_relocs didn't know that this symbol would be
10036 forced-local, so add an extra local got entry. */
10038 if (htab
->computed_got_sizes
)
10039 /* The symbol is only used in call relocations, so we'll
10040 have assumed it only needs a .got.plt entry. Increase
10041 the size of .got accordingly. */
10042 got
->size
+= MIPS_ELF_GOT_SIZE (dynobj
);
10046 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
10049 #define PDR_SIZE 32
10052 _bfd_mips_elf_discard_info (bfd
*abfd
, struct elf_reloc_cookie
*cookie
,
10053 struct bfd_link_info
*info
)
10056 bfd_boolean ret
= FALSE
;
10057 unsigned char *tdata
;
10060 o
= bfd_get_section_by_name (abfd
, ".pdr");
10065 if (o
->size
% PDR_SIZE
!= 0)
10067 if (o
->output_section
!= NULL
10068 && bfd_is_abs_section (o
->output_section
))
10071 tdata
= bfd_zmalloc (o
->size
/ PDR_SIZE
);
10075 cookie
->rels
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
10076 info
->keep_memory
);
10083 cookie
->rel
= cookie
->rels
;
10084 cookie
->relend
= cookie
->rels
+ o
->reloc_count
;
10086 for (i
= 0, skip
= 0; i
< o
->size
/ PDR_SIZE
; i
++)
10088 if (bfd_elf_reloc_symbol_deleted_p (i
* PDR_SIZE
, cookie
))
10097 mips_elf_section_data (o
)->u
.tdata
= tdata
;
10098 o
->size
-= skip
* PDR_SIZE
;
10104 if (! info
->keep_memory
)
10105 free (cookie
->rels
);
10111 _bfd_mips_elf_ignore_discarded_relocs (asection
*sec
)
10113 if (strcmp (sec
->name
, ".pdr") == 0)
10119 _bfd_mips_elf_write_section (bfd
*output_bfd
,
10120 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
10121 asection
*sec
, bfd_byte
*contents
)
10123 bfd_byte
*to
, *from
, *end
;
10126 if (strcmp (sec
->name
, ".pdr") != 0)
10129 if (mips_elf_section_data (sec
)->u
.tdata
== NULL
)
10133 end
= contents
+ sec
->size
;
10134 for (from
= contents
, i
= 0;
10136 from
+= PDR_SIZE
, i
++)
10138 if ((mips_elf_section_data (sec
)->u
.tdata
)[i
] == 1)
10141 memcpy (to
, from
, PDR_SIZE
);
10144 bfd_set_section_contents (output_bfd
, sec
->output_section
, contents
,
10145 sec
->output_offset
, sec
->size
);
10149 /* MIPS ELF uses a special find_nearest_line routine in order the
10150 handle the ECOFF debugging information. */
10152 struct mips_elf_find_line
10154 struct ecoff_debug_info d
;
10155 struct ecoff_find_line i
;
10159 _bfd_mips_elf_find_nearest_line (bfd
*abfd
, asection
*section
,
10160 asymbol
**symbols
, bfd_vma offset
,
10161 const char **filename_ptr
,
10162 const char **functionname_ptr
,
10163 unsigned int *line_ptr
)
10167 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
10168 filename_ptr
, functionname_ptr
,
10172 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
10173 filename_ptr
, functionname_ptr
,
10174 line_ptr
, ABI_64_P (abfd
) ? 8 : 0,
10175 &elf_tdata (abfd
)->dwarf2_find_line_info
))
10178 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
10181 flagword origflags
;
10182 struct mips_elf_find_line
*fi
;
10183 const struct ecoff_debug_swap
* const swap
=
10184 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
10186 /* If we are called during a link, mips_elf_final_link may have
10187 cleared the SEC_HAS_CONTENTS field. We force it back on here
10188 if appropriate (which it normally will be). */
10189 origflags
= msec
->flags
;
10190 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
10191 msec
->flags
|= SEC_HAS_CONTENTS
;
10193 fi
= elf_tdata (abfd
)->find_line_info
;
10196 bfd_size_type external_fdr_size
;
10199 struct fdr
*fdr_ptr
;
10200 bfd_size_type amt
= sizeof (struct mips_elf_find_line
);
10202 fi
= bfd_zalloc (abfd
, amt
);
10205 msec
->flags
= origflags
;
10209 if (! _bfd_mips_elf_read_ecoff_info (abfd
, msec
, &fi
->d
))
10211 msec
->flags
= origflags
;
10215 /* Swap in the FDR information. */
10216 amt
= fi
->d
.symbolic_header
.ifdMax
* sizeof (struct fdr
);
10217 fi
->d
.fdr
= bfd_alloc (abfd
, amt
);
10218 if (fi
->d
.fdr
== NULL
)
10220 msec
->flags
= origflags
;
10223 external_fdr_size
= swap
->external_fdr_size
;
10224 fdr_ptr
= fi
->d
.fdr
;
10225 fraw_src
= (char *) fi
->d
.external_fdr
;
10226 fraw_end
= (fraw_src
10227 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
10228 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
10229 (*swap
->swap_fdr_in
) (abfd
, fraw_src
, fdr_ptr
);
10231 elf_tdata (abfd
)->find_line_info
= fi
;
10233 /* Note that we don't bother to ever free this information.
10234 find_nearest_line is either called all the time, as in
10235 objdump -l, so the information should be saved, or it is
10236 rarely called, as in ld error messages, so the memory
10237 wasted is unimportant. Still, it would probably be a
10238 good idea for free_cached_info to throw it away. */
10241 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
10242 &fi
->i
, filename_ptr
, functionname_ptr
,
10245 msec
->flags
= origflags
;
10249 msec
->flags
= origflags
;
10252 /* Fall back on the generic ELF find_nearest_line routine. */
10254 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
10255 filename_ptr
, functionname_ptr
,
10260 _bfd_mips_elf_find_inliner_info (bfd
*abfd
,
10261 const char **filename_ptr
,
10262 const char **functionname_ptr
,
10263 unsigned int *line_ptr
)
10266 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
10267 functionname_ptr
, line_ptr
,
10268 & elf_tdata (abfd
)->dwarf2_find_line_info
);
10273 /* When are writing out the .options or .MIPS.options section,
10274 remember the bytes we are writing out, so that we can install the
10275 GP value in the section_processing routine. */
10278 _bfd_mips_elf_set_section_contents (bfd
*abfd
, sec_ptr section
,
10279 const void *location
,
10280 file_ptr offset
, bfd_size_type count
)
10282 if (MIPS_ELF_OPTIONS_SECTION_NAME_P (section
->name
))
10286 if (elf_section_data (section
) == NULL
)
10288 bfd_size_type amt
= sizeof (struct bfd_elf_section_data
);
10289 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
10290 if (elf_section_data (section
) == NULL
)
10293 c
= mips_elf_section_data (section
)->u
.tdata
;
10296 c
= bfd_zalloc (abfd
, section
->size
);
10299 mips_elf_section_data (section
)->u
.tdata
= c
;
10302 memcpy (c
+ offset
, location
, count
);
10305 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
,
10309 /* This is almost identical to bfd_generic_get_... except that some
10310 MIPS relocations need to be handled specially. Sigh. */
10313 _bfd_elf_mips_get_relocated_section_contents
10315 struct bfd_link_info
*link_info
,
10316 struct bfd_link_order
*link_order
,
10318 bfd_boolean relocatable
,
10321 /* Get enough memory to hold the stuff */
10322 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
10323 asection
*input_section
= link_order
->u
.indirect
.section
;
10326 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
10327 arelent
**reloc_vector
= NULL
;
10330 if (reloc_size
< 0)
10333 reloc_vector
= bfd_malloc (reloc_size
);
10334 if (reloc_vector
== NULL
&& reloc_size
!= 0)
10337 /* read in the section */
10338 sz
= input_section
->rawsize
? input_section
->rawsize
: input_section
->size
;
10339 if (!bfd_get_section_contents (input_bfd
, input_section
, data
, 0, sz
))
10342 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
10346 if (reloc_count
< 0)
10349 if (reloc_count
> 0)
10354 bfd_vma gp
= 0x12345678; /* initialize just to shut gcc up */
10357 struct bfd_hash_entry
*h
;
10358 struct bfd_link_hash_entry
*lh
;
10359 /* Skip all this stuff if we aren't mixing formats. */
10360 if (abfd
&& input_bfd
10361 && abfd
->xvec
== input_bfd
->xvec
)
10365 h
= bfd_hash_lookup (&link_info
->hash
->table
, "_gp", FALSE
, FALSE
);
10366 lh
= (struct bfd_link_hash_entry
*) h
;
10373 case bfd_link_hash_undefined
:
10374 case bfd_link_hash_undefweak
:
10375 case bfd_link_hash_common
:
10378 case bfd_link_hash_defined
:
10379 case bfd_link_hash_defweak
:
10381 gp
= lh
->u
.def
.value
;
10383 case bfd_link_hash_indirect
:
10384 case bfd_link_hash_warning
:
10386 /* @@FIXME ignoring warning for now */
10388 case bfd_link_hash_new
:
10397 for (parent
= reloc_vector
; *parent
!= NULL
; parent
++)
10399 char *error_message
= NULL
;
10400 bfd_reloc_status_type r
;
10402 /* Specific to MIPS: Deal with relocation types that require
10403 knowing the gp of the output bfd. */
10404 asymbol
*sym
= *(*parent
)->sym_ptr_ptr
;
10406 /* If we've managed to find the gp and have a special
10407 function for the relocation then go ahead, else default
10408 to the generic handling. */
10410 && (*parent
)->howto
->special_function
10411 == _bfd_mips_elf32_gprel16_reloc
)
10412 r
= _bfd_mips_elf_gprel16_with_gp (input_bfd
, sym
, *parent
,
10413 input_section
, relocatable
,
10416 r
= bfd_perform_relocation (input_bfd
, *parent
, data
,
10418 relocatable
? abfd
: NULL
,
10423 asection
*os
= input_section
->output_section
;
10425 /* A partial link, so keep the relocs */
10426 os
->orelocation
[os
->reloc_count
] = *parent
;
10430 if (r
!= bfd_reloc_ok
)
10434 case bfd_reloc_undefined
:
10435 if (!((*link_info
->callbacks
->undefined_symbol
)
10436 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
10437 input_bfd
, input_section
, (*parent
)->address
, TRUE
)))
10440 case bfd_reloc_dangerous
:
10441 BFD_ASSERT (error_message
!= NULL
);
10442 if (!((*link_info
->callbacks
->reloc_dangerous
)
10443 (link_info
, error_message
, input_bfd
, input_section
,
10444 (*parent
)->address
)))
10447 case bfd_reloc_overflow
:
10448 if (!((*link_info
->callbacks
->reloc_overflow
)
10450 bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
10451 (*parent
)->howto
->name
, (*parent
)->addend
,
10452 input_bfd
, input_section
, (*parent
)->address
)))
10455 case bfd_reloc_outofrange
:
10464 if (reloc_vector
!= NULL
)
10465 free (reloc_vector
);
10469 if (reloc_vector
!= NULL
)
10470 free (reloc_vector
);
10474 /* Create a MIPS ELF linker hash table. */
10476 struct bfd_link_hash_table
*
10477 _bfd_mips_elf_link_hash_table_create (bfd
*abfd
)
10479 struct mips_elf_link_hash_table
*ret
;
10480 bfd_size_type amt
= sizeof (struct mips_elf_link_hash_table
);
10482 ret
= bfd_malloc (amt
);
10486 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
10487 mips_elf_link_hash_newfunc
,
10488 sizeof (struct mips_elf_link_hash_entry
)))
10495 /* We no longer use this. */
10496 for (i
= 0; i
< SIZEOF_MIPS_DYNSYM_SECNAMES
; i
++)
10497 ret
->dynsym_sec_strindex
[i
] = (bfd_size_type
) -1;
10499 ret
->procedure_count
= 0;
10500 ret
->compact_rel_size
= 0;
10501 ret
->use_rld_obj_head
= FALSE
;
10502 ret
->rld_value
= 0;
10503 ret
->mips16_stubs_seen
= FALSE
;
10504 ret
->computed_got_sizes
= FALSE
;
10505 ret
->is_vxworks
= FALSE
;
10506 ret
->small_data_overflow_reported
= FALSE
;
10507 ret
->srelbss
= NULL
;
10508 ret
->sdynbss
= NULL
;
10509 ret
->srelplt
= NULL
;
10510 ret
->srelplt2
= NULL
;
10511 ret
->sgotplt
= NULL
;
10513 ret
->plt_header_size
= 0;
10514 ret
->plt_entry_size
= 0;
10515 ret
->function_stub_size
= 0;
10517 return &ret
->root
.root
;
10520 /* Likewise, but indicate that the target is VxWorks. */
10522 struct bfd_link_hash_table
*
10523 _bfd_mips_vxworks_link_hash_table_create (bfd
*abfd
)
10525 struct bfd_link_hash_table
*ret
;
10527 ret
= _bfd_mips_elf_link_hash_table_create (abfd
);
10530 struct mips_elf_link_hash_table
*htab
;
10532 htab
= (struct mips_elf_link_hash_table
*) ret
;
10533 htab
->is_vxworks
= 1;
10538 /* We need to use a special link routine to handle the .reginfo and
10539 the .mdebug sections. We need to merge all instances of these
10540 sections together, not write them all out sequentially. */
10543 _bfd_mips_elf_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
10546 struct bfd_link_order
*p
;
10547 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
10548 asection
*rtproc_sec
;
10549 Elf32_RegInfo reginfo
;
10550 struct ecoff_debug_info debug
;
10551 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10552 const struct ecoff_debug_swap
*swap
= bed
->elf_backend_ecoff_debug_swap
;
10553 HDRR
*symhdr
= &debug
.symbolic_header
;
10554 void *mdebug_handle
= NULL
;
10559 struct mips_elf_link_hash_table
*htab
;
10561 static const char * const secname
[] =
10563 ".text", ".init", ".fini", ".data",
10564 ".rodata", ".sdata", ".sbss", ".bss"
10566 static const int sc
[] =
10568 scText
, scInit
, scFini
, scData
,
10569 scRData
, scSData
, scSBss
, scBss
10572 /* We'd carefully arranged the dynamic symbol indices, and then the
10573 generic size_dynamic_sections renumbered them out from under us.
10574 Rather than trying somehow to prevent the renumbering, just do
10576 htab
= mips_elf_hash_table (info
);
10577 if (elf_hash_table (info
)->dynamic_sections_created
)
10581 struct mips_got_info
*g
;
10582 bfd_size_type dynsecsymcount
;
10584 /* When we resort, we must tell mips_elf_sort_hash_table what
10585 the lowest index it may use is. That's the number of section
10586 symbols we're going to add. The generic ELF linker only
10587 adds these symbols when building a shared object. Note that
10588 we count the sections after (possibly) removing the .options
10591 dynsecsymcount
= count_section_dynsyms (abfd
, info
);
10592 if (! mips_elf_sort_hash_table (info
, dynsecsymcount
+ 1))
10595 /* Make sure we didn't grow the global .got region. */
10596 dynobj
= elf_hash_table (info
)->dynobj
;
10597 got
= mips_elf_got_section (dynobj
, FALSE
);
10598 g
= mips_elf_section_data (got
)->u
.got_info
;
10600 if (g
->global_gotsym
!= NULL
)
10601 BFD_ASSERT ((elf_hash_table (info
)->dynsymcount
10602 - g
->global_gotsym
->dynindx
)
10603 <= g
->global_gotno
);
10606 /* Get a value for the GP register. */
10607 if (elf_gp (abfd
) == 0)
10609 struct bfd_link_hash_entry
*h
;
10611 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
10612 if (h
!= NULL
&& h
->type
== bfd_link_hash_defined
)
10613 elf_gp (abfd
) = (h
->u
.def
.value
10614 + h
->u
.def
.section
->output_section
->vma
10615 + h
->u
.def
.section
->output_offset
);
10616 else if (htab
->is_vxworks
10617 && (h
= bfd_link_hash_lookup (info
->hash
,
10618 "_GLOBAL_OFFSET_TABLE_",
10619 FALSE
, FALSE
, TRUE
))
10620 && h
->type
== bfd_link_hash_defined
)
10621 elf_gp (abfd
) = (h
->u
.def
.section
->output_section
->vma
10622 + h
->u
.def
.section
->output_offset
10624 else if (info
->relocatable
)
10626 bfd_vma lo
= MINUS_ONE
;
10628 /* Find the GP-relative section with the lowest offset. */
10629 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
10631 && (elf_section_data (o
)->this_hdr
.sh_flags
& SHF_MIPS_GPREL
))
10634 /* And calculate GP relative to that. */
10635 elf_gp (abfd
) = lo
+ ELF_MIPS_GP_OFFSET (info
);
10639 /* If the relocate_section function needs to do a reloc
10640 involving the GP value, it should make a reloc_dangerous
10641 callback to warn that GP is not defined. */
10645 /* Go through the sections and collect the .reginfo and .mdebug
10647 reginfo_sec
= NULL
;
10649 gptab_data_sec
= NULL
;
10650 gptab_bss_sec
= NULL
;
10651 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
10653 if (strcmp (o
->name
, ".reginfo") == 0)
10655 memset (®info
, 0, sizeof reginfo
);
10657 /* We have found the .reginfo section in the output file.
10658 Look through all the link_orders comprising it and merge
10659 the information together. */
10660 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10662 asection
*input_section
;
10664 Elf32_External_RegInfo ext
;
10667 if (p
->type
!= bfd_indirect_link_order
)
10669 if (p
->type
== bfd_data_link_order
)
10674 input_section
= p
->u
.indirect
.section
;
10675 input_bfd
= input_section
->owner
;
10677 if (! bfd_get_section_contents (input_bfd
, input_section
,
10678 &ext
, 0, sizeof ext
))
10681 bfd_mips_elf32_swap_reginfo_in (input_bfd
, &ext
, &sub
);
10683 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
10684 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
10685 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
10686 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
10687 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
10689 /* ri_gp_value is set by the function
10690 mips_elf32_section_processing when the section is
10691 finally written out. */
10693 /* Hack: reset the SEC_HAS_CONTENTS flag so that
10694 elf_link_input_bfd ignores this section. */
10695 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
10698 /* Size has been set in _bfd_mips_elf_always_size_sections. */
10699 BFD_ASSERT(o
->size
== sizeof (Elf32_External_RegInfo
));
10701 /* Skip this section later on (I don't think this currently
10702 matters, but someday it might). */
10703 o
->map_head
.link_order
= NULL
;
10708 if (strcmp (o
->name
, ".mdebug") == 0)
10710 struct extsym_info einfo
;
10713 /* We have found the .mdebug section in the output file.
10714 Look through all the link_orders comprising it and merge
10715 the information together. */
10716 symhdr
->magic
= swap
->sym_magic
;
10717 /* FIXME: What should the version stamp be? */
10718 symhdr
->vstamp
= 0;
10719 symhdr
->ilineMax
= 0;
10720 symhdr
->cbLine
= 0;
10721 symhdr
->idnMax
= 0;
10722 symhdr
->ipdMax
= 0;
10723 symhdr
->isymMax
= 0;
10724 symhdr
->ioptMax
= 0;
10725 symhdr
->iauxMax
= 0;
10726 symhdr
->issMax
= 0;
10727 symhdr
->issExtMax
= 0;
10728 symhdr
->ifdMax
= 0;
10730 symhdr
->iextMax
= 0;
10732 /* We accumulate the debugging information itself in the
10733 debug_info structure. */
10735 debug
.external_dnr
= NULL
;
10736 debug
.external_pdr
= NULL
;
10737 debug
.external_sym
= NULL
;
10738 debug
.external_opt
= NULL
;
10739 debug
.external_aux
= NULL
;
10741 debug
.ssext
= debug
.ssext_end
= NULL
;
10742 debug
.external_fdr
= NULL
;
10743 debug
.external_rfd
= NULL
;
10744 debug
.external_ext
= debug
.external_ext_end
= NULL
;
10746 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
10747 if (mdebug_handle
== NULL
)
10751 esym
.cobol_main
= 0;
10755 esym
.asym
.iss
= issNil
;
10756 esym
.asym
.st
= stLocal
;
10757 esym
.asym
.reserved
= 0;
10758 esym
.asym
.index
= indexNil
;
10760 for (i
= 0; i
< sizeof (secname
) / sizeof (secname
[0]); i
++)
10762 esym
.asym
.sc
= sc
[i
];
10763 s
= bfd_get_section_by_name (abfd
, secname
[i
]);
10766 esym
.asym
.value
= s
->vma
;
10767 last
= s
->vma
+ s
->size
;
10770 esym
.asym
.value
= last
;
10771 if (!bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
10772 secname
[i
], &esym
))
10776 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10778 asection
*input_section
;
10780 const struct ecoff_debug_swap
*input_swap
;
10781 struct ecoff_debug_info input_debug
;
10785 if (p
->type
!= bfd_indirect_link_order
)
10787 if (p
->type
== bfd_data_link_order
)
10792 input_section
= p
->u
.indirect
.section
;
10793 input_bfd
= input_section
->owner
;
10795 if (bfd_get_flavour (input_bfd
) != bfd_target_elf_flavour
10796 || (get_elf_backend_data (input_bfd
)
10797 ->elf_backend_ecoff_debug_swap
) == NULL
)
10799 /* I don't know what a non MIPS ELF bfd would be
10800 doing with a .mdebug section, but I don't really
10801 want to deal with it. */
10805 input_swap
= (get_elf_backend_data (input_bfd
)
10806 ->elf_backend_ecoff_debug_swap
);
10808 BFD_ASSERT (p
->size
== input_section
->size
);
10810 /* The ECOFF linking code expects that we have already
10811 read in the debugging information and set up an
10812 ecoff_debug_info structure, so we do that now. */
10813 if (! _bfd_mips_elf_read_ecoff_info (input_bfd
, input_section
,
10817 if (! (bfd_ecoff_debug_accumulate
10818 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
10819 &input_debug
, input_swap
, info
)))
10822 /* Loop through the external symbols. For each one with
10823 interesting information, try to find the symbol in
10824 the linker global hash table and save the information
10825 for the output external symbols. */
10826 eraw_src
= input_debug
.external_ext
;
10827 eraw_end
= (eraw_src
10828 + (input_debug
.symbolic_header
.iextMax
10829 * input_swap
->external_ext_size
));
10831 eraw_src
< eraw_end
;
10832 eraw_src
+= input_swap
->external_ext_size
)
10836 struct mips_elf_link_hash_entry
*h
;
10838 (*input_swap
->swap_ext_in
) (input_bfd
, eraw_src
, &ext
);
10839 if (ext
.asym
.sc
== scNil
10840 || ext
.asym
.sc
== scUndefined
10841 || ext
.asym
.sc
== scSUndefined
)
10844 name
= input_debug
.ssext
+ ext
.asym
.iss
;
10845 h
= mips_elf_link_hash_lookup (mips_elf_hash_table (info
),
10846 name
, FALSE
, FALSE
, TRUE
);
10847 if (h
== NULL
|| h
->esym
.ifd
!= -2)
10852 BFD_ASSERT (ext
.ifd
10853 < input_debug
.symbolic_header
.ifdMax
);
10854 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
10860 /* Free up the information we just read. */
10861 free (input_debug
.line
);
10862 free (input_debug
.external_dnr
);
10863 free (input_debug
.external_pdr
);
10864 free (input_debug
.external_sym
);
10865 free (input_debug
.external_opt
);
10866 free (input_debug
.external_aux
);
10867 free (input_debug
.ss
);
10868 free (input_debug
.ssext
);
10869 free (input_debug
.external_fdr
);
10870 free (input_debug
.external_rfd
);
10871 free (input_debug
.external_ext
);
10873 /* Hack: reset the SEC_HAS_CONTENTS flag so that
10874 elf_link_input_bfd ignores this section. */
10875 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
10878 if (SGI_COMPAT (abfd
) && info
->shared
)
10880 /* Create .rtproc section. */
10881 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
10882 if (rtproc_sec
== NULL
)
10884 flagword flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
10885 | SEC_LINKER_CREATED
| SEC_READONLY
);
10887 rtproc_sec
= bfd_make_section_with_flags (abfd
,
10890 if (rtproc_sec
== NULL
10891 || ! bfd_set_section_alignment (abfd
, rtproc_sec
, 4))
10895 if (! mips_elf_create_procedure_table (mdebug_handle
, abfd
,
10901 /* Build the external symbol information. */
10904 einfo
.debug
= &debug
;
10906 einfo
.failed
= FALSE
;
10907 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
10908 mips_elf_output_extsym
, &einfo
);
10912 /* Set the size of the .mdebug section. */
10913 o
->size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
10915 /* Skip this section later on (I don't think this currently
10916 matters, but someday it might). */
10917 o
->map_head
.link_order
= NULL
;
10922 if (CONST_STRNEQ (o
->name
, ".gptab."))
10924 const char *subname
;
10927 Elf32_External_gptab
*ext_tab
;
10930 /* The .gptab.sdata and .gptab.sbss sections hold
10931 information describing how the small data area would
10932 change depending upon the -G switch. These sections
10933 not used in executables files. */
10934 if (! info
->relocatable
)
10936 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10938 asection
*input_section
;
10940 if (p
->type
!= bfd_indirect_link_order
)
10942 if (p
->type
== bfd_data_link_order
)
10947 input_section
= p
->u
.indirect
.section
;
10949 /* Hack: reset the SEC_HAS_CONTENTS flag so that
10950 elf_link_input_bfd ignores this section. */
10951 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
10954 /* Skip this section later on (I don't think this
10955 currently matters, but someday it might). */
10956 o
->map_head
.link_order
= NULL
;
10958 /* Really remove the section. */
10959 bfd_section_list_remove (abfd
, o
);
10960 --abfd
->section_count
;
10965 /* There is one gptab for initialized data, and one for
10966 uninitialized data. */
10967 if (strcmp (o
->name
, ".gptab.sdata") == 0)
10968 gptab_data_sec
= o
;
10969 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
10973 (*_bfd_error_handler
)
10974 (_("%s: illegal section name `%s'"),
10975 bfd_get_filename (abfd
), o
->name
);
10976 bfd_set_error (bfd_error_nonrepresentable_section
);
10980 /* The linker script always combines .gptab.data and
10981 .gptab.sdata into .gptab.sdata, and likewise for
10982 .gptab.bss and .gptab.sbss. It is possible that there is
10983 no .sdata or .sbss section in the output file, in which
10984 case we must change the name of the output section. */
10985 subname
= o
->name
+ sizeof ".gptab" - 1;
10986 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
10988 if (o
== gptab_data_sec
)
10989 o
->name
= ".gptab.data";
10991 o
->name
= ".gptab.bss";
10992 subname
= o
->name
+ sizeof ".gptab" - 1;
10993 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
10996 /* Set up the first entry. */
10998 amt
= c
* sizeof (Elf32_gptab
);
10999 tab
= bfd_malloc (amt
);
11002 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
11003 tab
[0].gt_header
.gt_unused
= 0;
11005 /* Combine the input sections. */
11006 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
11008 asection
*input_section
;
11010 bfd_size_type size
;
11011 unsigned long last
;
11012 bfd_size_type gpentry
;
11014 if (p
->type
!= bfd_indirect_link_order
)
11016 if (p
->type
== bfd_data_link_order
)
11021 input_section
= p
->u
.indirect
.section
;
11022 input_bfd
= input_section
->owner
;
11024 /* Combine the gptab entries for this input section one
11025 by one. We know that the input gptab entries are
11026 sorted by ascending -G value. */
11027 size
= input_section
->size
;
11029 for (gpentry
= sizeof (Elf32_External_gptab
);
11031 gpentry
+= sizeof (Elf32_External_gptab
))
11033 Elf32_External_gptab ext_gptab
;
11034 Elf32_gptab int_gptab
;
11040 if (! (bfd_get_section_contents
11041 (input_bfd
, input_section
, &ext_gptab
, gpentry
,
11042 sizeof (Elf32_External_gptab
))))
11048 bfd_mips_elf32_swap_gptab_in (input_bfd
, &ext_gptab
,
11050 val
= int_gptab
.gt_entry
.gt_g_value
;
11051 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
11054 for (look
= 1; look
< c
; look
++)
11056 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
11057 tab
[look
].gt_entry
.gt_bytes
+= add
;
11059 if (tab
[look
].gt_entry
.gt_g_value
== val
)
11065 Elf32_gptab
*new_tab
;
11068 /* We need a new table entry. */
11069 amt
= (bfd_size_type
) (c
+ 1) * sizeof (Elf32_gptab
);
11070 new_tab
= bfd_realloc (tab
, amt
);
11071 if (new_tab
== NULL
)
11077 tab
[c
].gt_entry
.gt_g_value
= val
;
11078 tab
[c
].gt_entry
.gt_bytes
= add
;
11080 /* Merge in the size for the next smallest -G
11081 value, since that will be implied by this new
11084 for (look
= 1; look
< c
; look
++)
11086 if (tab
[look
].gt_entry
.gt_g_value
< val
11088 || (tab
[look
].gt_entry
.gt_g_value
11089 > tab
[max
].gt_entry
.gt_g_value
)))
11093 tab
[c
].gt_entry
.gt_bytes
+=
11094 tab
[max
].gt_entry
.gt_bytes
;
11099 last
= int_gptab
.gt_entry
.gt_bytes
;
11102 /* Hack: reset the SEC_HAS_CONTENTS flag so that
11103 elf_link_input_bfd ignores this section. */
11104 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
11107 /* The table must be sorted by -G value. */
11109 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
11111 /* Swap out the table. */
11112 amt
= (bfd_size_type
) c
* sizeof (Elf32_External_gptab
);
11113 ext_tab
= bfd_alloc (abfd
, amt
);
11114 if (ext_tab
== NULL
)
11120 for (j
= 0; j
< c
; j
++)
11121 bfd_mips_elf32_swap_gptab_out (abfd
, tab
+ j
, ext_tab
+ j
);
11124 o
->size
= c
* sizeof (Elf32_External_gptab
);
11125 o
->contents
= (bfd_byte
*) ext_tab
;
11127 /* Skip this section later on (I don't think this currently
11128 matters, but someday it might). */
11129 o
->map_head
.link_order
= NULL
;
11133 /* Invoke the regular ELF backend linker to do all the work. */
11134 if (!bfd_elf_final_link (abfd
, info
))
11137 /* Now write out the computed sections. */
11139 if (reginfo_sec
!= NULL
)
11141 Elf32_External_RegInfo ext
;
11143 bfd_mips_elf32_swap_reginfo_out (abfd
, ®info
, &ext
);
11144 if (! bfd_set_section_contents (abfd
, reginfo_sec
, &ext
, 0, sizeof ext
))
11148 if (mdebug_sec
!= NULL
)
11150 BFD_ASSERT (abfd
->output_has_begun
);
11151 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
11153 mdebug_sec
->filepos
))
11156 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
11159 if (gptab_data_sec
!= NULL
)
11161 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
11162 gptab_data_sec
->contents
,
11163 0, gptab_data_sec
->size
))
11167 if (gptab_bss_sec
!= NULL
)
11169 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
11170 gptab_bss_sec
->contents
,
11171 0, gptab_bss_sec
->size
))
11175 if (SGI_COMPAT (abfd
))
11177 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
11178 if (rtproc_sec
!= NULL
)
11180 if (! bfd_set_section_contents (abfd
, rtproc_sec
,
11181 rtproc_sec
->contents
,
11182 0, rtproc_sec
->size
))
11190 /* Structure for saying that BFD machine EXTENSION extends BASE. */
11192 struct mips_mach_extension
{
11193 unsigned long extension
, base
;
11197 /* An array describing how BFD machines relate to one another. The entries
11198 are ordered topologically with MIPS I extensions listed last. */
11200 static const struct mips_mach_extension mips_mach_extensions
[] = {
11201 /* MIPS64 extensions. */
11202 { bfd_mach_mipsisa64r2
, bfd_mach_mipsisa64
},
11203 { bfd_mach_mips_sb1
, bfd_mach_mipsisa64
},
11205 /* MIPS V extensions. */
11206 { bfd_mach_mipsisa64
, bfd_mach_mips5
},
11208 /* R10000 extensions. */
11209 { bfd_mach_mips12000
, bfd_mach_mips10000
},
11211 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
11212 vr5400 ISA, but doesn't include the multimedia stuff. It seems
11213 better to allow vr5400 and vr5500 code to be merged anyway, since
11214 many libraries will just use the core ISA. Perhaps we could add
11215 some sort of ASE flag if this ever proves a problem. */
11216 { bfd_mach_mips5500
, bfd_mach_mips5400
},
11217 { bfd_mach_mips5400
, bfd_mach_mips5000
},
11219 /* MIPS IV extensions. */
11220 { bfd_mach_mips5
, bfd_mach_mips8000
},
11221 { bfd_mach_mips10000
, bfd_mach_mips8000
},
11222 { bfd_mach_mips5000
, bfd_mach_mips8000
},
11223 { bfd_mach_mips7000
, bfd_mach_mips8000
},
11224 { bfd_mach_mips9000
, bfd_mach_mips8000
},
11226 /* VR4100 extensions. */
11227 { bfd_mach_mips4120
, bfd_mach_mips4100
},
11228 { bfd_mach_mips4111
, bfd_mach_mips4100
},
11230 /* MIPS III extensions. */
11231 { bfd_mach_mips8000
, bfd_mach_mips4000
},
11232 { bfd_mach_mips4650
, bfd_mach_mips4000
},
11233 { bfd_mach_mips4600
, bfd_mach_mips4000
},
11234 { bfd_mach_mips4400
, bfd_mach_mips4000
},
11235 { bfd_mach_mips4300
, bfd_mach_mips4000
},
11236 { bfd_mach_mips4100
, bfd_mach_mips4000
},
11237 { bfd_mach_mips4010
, bfd_mach_mips4000
},
11239 /* MIPS32 extensions. */
11240 { bfd_mach_mipsisa32r2
, bfd_mach_mipsisa32
},
11242 /* MIPS II extensions. */
11243 { bfd_mach_mips4000
, bfd_mach_mips6000
},
11244 { bfd_mach_mipsisa32
, bfd_mach_mips6000
},
11246 /* MIPS I extensions. */
11247 { bfd_mach_mips6000
, bfd_mach_mips3000
},
11248 { bfd_mach_mips3900
, bfd_mach_mips3000
}
11252 /* Return true if bfd machine EXTENSION is an extension of machine BASE. */
11255 mips_mach_extends_p (unsigned long base
, unsigned long extension
)
11259 if (extension
== base
)
11262 if (base
== bfd_mach_mipsisa32
11263 && mips_mach_extends_p (bfd_mach_mipsisa64
, extension
))
11266 if (base
== bfd_mach_mipsisa32r2
11267 && mips_mach_extends_p (bfd_mach_mipsisa64r2
, extension
))
11270 for (i
= 0; i
< ARRAY_SIZE (mips_mach_extensions
); i
++)
11271 if (extension
== mips_mach_extensions
[i
].extension
)
11273 extension
= mips_mach_extensions
[i
].base
;
11274 if (extension
== base
)
11282 /* Return true if the given ELF header flags describe a 32-bit binary. */
11285 mips_32bit_flags_p (flagword flags
)
11287 return ((flags
& EF_MIPS_32BITMODE
) != 0
11288 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
11289 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
11290 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
11291 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
11292 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
11293 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
);
11297 /* Merge object attributes from IBFD into OBFD. Raise an error if
11298 there are conflicting attributes. */
11300 mips_elf_merge_obj_attributes (bfd
*ibfd
, bfd
*obfd
)
11302 obj_attribute
*in_attr
;
11303 obj_attribute
*out_attr
;
11305 if (!elf_known_obj_attributes_proc (obfd
)[0].i
)
11307 /* This is the first object. Copy the attributes. */
11308 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
11310 /* Use the Tag_null value to indicate the attributes have been
11312 elf_known_obj_attributes_proc (obfd
)[0].i
= 1;
11317 /* Check for conflicting Tag_GNU_MIPS_ABI_FP attributes and merge
11318 non-conflicting ones. */
11319 in_attr
= elf_known_obj_attributes (ibfd
)[OBJ_ATTR_GNU
];
11320 out_attr
= elf_known_obj_attributes (obfd
)[OBJ_ATTR_GNU
];
11321 if (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
!= out_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
11323 out_attr
[Tag_GNU_MIPS_ABI_FP
].type
= 1;
11324 if (out_attr
[Tag_GNU_MIPS_ABI_FP
].i
== 0)
11325 out_attr
[Tag_GNU_MIPS_ABI_FP
].i
= in_attr
[Tag_GNU_MIPS_ABI_FP
].i
;
11326 else if (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
== 0)
11328 else if (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
> 3)
11330 (_("Warning: %B uses unknown floating point ABI %d"), ibfd
,
11331 in_attr
[Tag_GNU_MIPS_ABI_FP
].i
);
11332 else if (out_attr
[Tag_GNU_MIPS_ABI_FP
].i
> 3)
11334 (_("Warning: %B uses unknown floating point ABI %d"), obfd
,
11335 out_attr
[Tag_GNU_MIPS_ABI_FP
].i
);
11337 switch (out_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
11340 switch (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
11344 (_("Warning: %B uses -msingle-float, %B uses -mdouble-float"),
11350 (_("Warning: %B uses hard float, %B uses soft float"),
11360 switch (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
11364 (_("Warning: %B uses -msingle-float, %B uses -mdouble-float"),
11370 (_("Warning: %B uses hard float, %B uses soft float"),
11380 switch (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
11385 (_("Warning: %B uses hard float, %B uses soft float"),
11399 /* Merge Tag_compatibility attributes and any common GNU ones. */
11400 _bfd_elf_merge_object_attributes (ibfd
, obfd
);
11405 /* Merge backend specific data from an object file to the output
11406 object file when linking. */
11409 _bfd_mips_elf_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
11411 flagword old_flags
;
11412 flagword new_flags
;
11414 bfd_boolean null_input_bfd
= TRUE
;
11417 /* Check if we have the same endianess */
11418 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
11420 (*_bfd_error_handler
)
11421 (_("%B: endianness incompatible with that of the selected emulation"),
11426 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
11427 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
11430 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
11432 (*_bfd_error_handler
)
11433 (_("%B: ABI is incompatible with that of the selected emulation"),
11438 if (!mips_elf_merge_obj_attributes (ibfd
, obfd
))
11441 new_flags
= elf_elfheader (ibfd
)->e_flags
;
11442 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_NOREORDER
;
11443 old_flags
= elf_elfheader (obfd
)->e_flags
;
11445 if (! elf_flags_init (obfd
))
11447 elf_flags_init (obfd
) = TRUE
;
11448 elf_elfheader (obfd
)->e_flags
= new_flags
;
11449 elf_elfheader (obfd
)->e_ident
[EI_CLASS
]
11450 = elf_elfheader (ibfd
)->e_ident
[EI_CLASS
];
11452 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
11453 && (bfd_get_arch_info (obfd
)->the_default
11454 || mips_mach_extends_p (bfd_get_mach (obfd
),
11455 bfd_get_mach (ibfd
))))
11457 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
11458 bfd_get_mach (ibfd
)))
11465 /* Check flag compatibility. */
11467 new_flags
&= ~EF_MIPS_NOREORDER
;
11468 old_flags
&= ~EF_MIPS_NOREORDER
;
11470 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
11471 doesn't seem to matter. */
11472 new_flags
&= ~EF_MIPS_XGOT
;
11473 old_flags
&= ~EF_MIPS_XGOT
;
11475 /* MIPSpro generates ucode info in n64 objects. Again, we should
11476 just be able to ignore this. */
11477 new_flags
&= ~EF_MIPS_UCODE
;
11478 old_flags
&= ~EF_MIPS_UCODE
;
11480 /* Don't care about the PIC flags from dynamic objects; they are
11482 if ((new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0
11483 && (ibfd
->flags
& DYNAMIC
) != 0)
11484 new_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
11486 if (new_flags
== old_flags
)
11489 /* Check to see if the input BFD actually contains any sections.
11490 If not, its flags may not have been initialised either, but it cannot
11491 actually cause any incompatibility. */
11492 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
11494 /* Ignore synthetic sections and empty .text, .data and .bss sections
11495 which are automatically generated by gas. */
11496 if (strcmp (sec
->name
, ".reginfo")
11497 && strcmp (sec
->name
, ".mdebug")
11499 || (strcmp (sec
->name
, ".text")
11500 && strcmp (sec
->name
, ".data")
11501 && strcmp (sec
->name
, ".bss"))))
11503 null_input_bfd
= FALSE
;
11507 if (null_input_bfd
)
11512 if (((new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0)
11513 != ((old_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0))
11515 (*_bfd_error_handler
)
11516 (_("%B: warning: linking PIC files with non-PIC files"),
11521 if (new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
))
11522 elf_elfheader (obfd
)->e_flags
|= EF_MIPS_CPIC
;
11523 if (! (new_flags
& EF_MIPS_PIC
))
11524 elf_elfheader (obfd
)->e_flags
&= ~EF_MIPS_PIC
;
11526 new_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
11527 old_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
11529 /* Compare the ISAs. */
11530 if (mips_32bit_flags_p (old_flags
) != mips_32bit_flags_p (new_flags
))
11532 (*_bfd_error_handler
)
11533 (_("%B: linking 32-bit code with 64-bit code"),
11537 else if (!mips_mach_extends_p (bfd_get_mach (ibfd
), bfd_get_mach (obfd
)))
11539 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
11540 if (mips_mach_extends_p (bfd_get_mach (obfd
), bfd_get_mach (ibfd
)))
11542 /* Copy the architecture info from IBFD to OBFD. Also copy
11543 the 32-bit flag (if set) so that we continue to recognise
11544 OBFD as a 32-bit binary. */
11545 bfd_set_arch_info (obfd
, bfd_get_arch_info (ibfd
));
11546 elf_elfheader (obfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
11547 elf_elfheader (obfd
)->e_flags
11548 |= new_flags
& (EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
11550 /* Copy across the ABI flags if OBFD doesn't use them
11551 and if that was what caused us to treat IBFD as 32-bit. */
11552 if ((old_flags
& EF_MIPS_ABI
) == 0
11553 && mips_32bit_flags_p (new_flags
)
11554 && !mips_32bit_flags_p (new_flags
& ~EF_MIPS_ABI
))
11555 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ABI
;
11559 /* The ISAs aren't compatible. */
11560 (*_bfd_error_handler
)
11561 (_("%B: linking %s module with previous %s modules"),
11563 bfd_printable_name (ibfd
),
11564 bfd_printable_name (obfd
));
11569 new_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
11570 old_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
11572 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
11573 does set EI_CLASS differently from any 32-bit ABI. */
11574 if ((new_flags
& EF_MIPS_ABI
) != (old_flags
& EF_MIPS_ABI
)
11575 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
11576 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
11578 /* Only error if both are set (to different values). */
11579 if (((new_flags
& EF_MIPS_ABI
) && (old_flags
& EF_MIPS_ABI
))
11580 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
11581 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
11583 (*_bfd_error_handler
)
11584 (_("%B: ABI mismatch: linking %s module with previous %s modules"),
11586 elf_mips_abi_name (ibfd
),
11587 elf_mips_abi_name (obfd
));
11590 new_flags
&= ~EF_MIPS_ABI
;
11591 old_flags
&= ~EF_MIPS_ABI
;
11594 /* For now, allow arbitrary mixing of ASEs (retain the union). */
11595 if ((new_flags
& EF_MIPS_ARCH_ASE
) != (old_flags
& EF_MIPS_ARCH_ASE
))
11597 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ARCH_ASE
;
11599 new_flags
&= ~ EF_MIPS_ARCH_ASE
;
11600 old_flags
&= ~ EF_MIPS_ARCH_ASE
;
11603 /* Warn about any other mismatches */
11604 if (new_flags
!= old_flags
)
11606 (*_bfd_error_handler
)
11607 (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
11608 ibfd
, (unsigned long) new_flags
,
11609 (unsigned long) old_flags
);
11615 bfd_set_error (bfd_error_bad_value
);
11622 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
11625 _bfd_mips_elf_set_private_flags (bfd
*abfd
, flagword flags
)
11627 BFD_ASSERT (!elf_flags_init (abfd
)
11628 || elf_elfheader (abfd
)->e_flags
== flags
);
11630 elf_elfheader (abfd
)->e_flags
= flags
;
11631 elf_flags_init (abfd
) = TRUE
;
11636 _bfd_mips_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
11640 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
11642 /* Print normal ELF private data. */
11643 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
11645 /* xgettext:c-format */
11646 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
11648 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
)
11649 fprintf (file
, _(" [abi=O32]"));
11650 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O64
)
11651 fprintf (file
, _(" [abi=O64]"));
11652 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
)
11653 fprintf (file
, _(" [abi=EABI32]"));
11654 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
11655 fprintf (file
, _(" [abi=EABI64]"));
11656 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
))
11657 fprintf (file
, _(" [abi unknown]"));
11658 else if (ABI_N32_P (abfd
))
11659 fprintf (file
, _(" [abi=N32]"));
11660 else if (ABI_64_P (abfd
))
11661 fprintf (file
, _(" [abi=64]"));
11663 fprintf (file
, _(" [no abi set]"));
11665 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
11666 fprintf (file
, " [mips1]");
11667 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
11668 fprintf (file
, " [mips2]");
11669 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
11670 fprintf (file
, " [mips3]");
11671 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
11672 fprintf (file
, " [mips4]");
11673 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_5
)
11674 fprintf (file
, " [mips5]");
11675 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
)
11676 fprintf (file
, " [mips32]");
11677 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64
)
11678 fprintf (file
, " [mips64]");
11679 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
)
11680 fprintf (file
, " [mips32r2]");
11681 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64R2
)
11682 fprintf (file
, " [mips64r2]");
11684 fprintf (file
, _(" [unknown ISA]"));
11686 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
11687 fprintf (file
, " [mdmx]");
11689 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_M16
)
11690 fprintf (file
, " [mips16]");
11692 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_32BITMODE
)
11693 fprintf (file
, " [32bitmode]");
11695 fprintf (file
, _(" [not 32bitmode]"));
11697 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_NOREORDER
)
11698 fprintf (file
, " [noreorder]");
11700 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_PIC
)
11701 fprintf (file
, " [PIC]");
11703 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_CPIC
)
11704 fprintf (file
, " [CPIC]");
11706 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_XGOT
)
11707 fprintf (file
, " [XGOT]");
11709 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_UCODE
)
11710 fprintf (file
, " [UCODE]");
11712 fputc ('\n', file
);
11717 const struct bfd_elf_special_section _bfd_mips_elf_special_sections
[] =
11719 { STRING_COMMA_LEN (".lit4"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
11720 { STRING_COMMA_LEN (".lit8"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
11721 { STRING_COMMA_LEN (".mdebug"), 0, SHT_MIPS_DEBUG
, 0 },
11722 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
11723 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
11724 { STRING_COMMA_LEN (".ucode"), 0, SHT_MIPS_UCODE
, 0 },
11725 { NULL
, 0, 0, 0, 0 }
11728 /* Merge non visibility st_other attributes. Ensure that the
11729 STO_OPTIONAL flag is copied into h->other, even if this is not a
11730 definiton of the symbol. */
11732 _bfd_mips_elf_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
11733 const Elf_Internal_Sym
*isym
,
11734 bfd_boolean definition
,
11735 bfd_boolean dynamic ATTRIBUTE_UNUSED
)
11737 if ((isym
->st_other
& ~ELF_ST_VISIBILITY (-1)) != 0)
11739 unsigned char other
;
11741 other
= (definition
? isym
->st_other
: h
->other
);
11742 other
&= ~ELF_ST_VISIBILITY (-1);
11743 h
->other
= other
| ELF_ST_VISIBILITY (h
->other
);
11747 && ELF_MIPS_IS_OPTIONAL (isym
->st_other
))
11748 h
->other
|= STO_OPTIONAL
;
11751 /* Decide whether an undefined symbol is special and can be ignored.
11752 This is the case for OPTIONAL symbols on IRIX. */
11754 _bfd_mips_elf_ignore_undef_symbol (struct elf_link_hash_entry
*h
)
11756 return ELF_MIPS_IS_OPTIONAL (h
->other
) ? TRUE
: FALSE
;
11760 _bfd_mips_elf_common_definition (Elf_Internal_Sym
*sym
)
11762 return (sym
->st_shndx
== SHN_COMMON
11763 || sym
->st_shndx
== SHN_MIPS_ACOMMON
11764 || sym
->st_shndx
== SHN_MIPS_SCOMMON
);