1 /* MIPS-specific support for ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
5 Most of the information added by Ian Lance Taylor, Cygnus Support,
7 N32/64 ABI support added by Mark Mitchell, CodeSourcery, LLC.
8 <mark@codesourcery.com>
9 Traditional MIPS targets support added by Koundinya.K, Dansk Data
10 Elektronik & Operations Research Group. <kk@ddeorg.soft.net>
12 This file is part of BFD, the Binary File Descriptor library.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 3 of the License, or
17 (at your option) any later version.
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
27 MA 02110-1301, USA. */
30 /* This file handles functionality common to the different MIPS ABI's. */
35 #include "libiberty.h"
37 #include "elfxx-mips.h"
39 #include "elf-vxworks.h"
41 /* Get the ECOFF swapping routines. */
43 #include "coff/symconst.h"
44 #include "coff/ecoff.h"
45 #include "coff/mips.h"
49 /* This structure is used to hold information about one GOT entry.
50 There are three types of entry:
52 (1) absolute addresses
54 (2) SYMBOL + OFFSET addresses, where SYMBOL is local to an input bfd
55 (abfd != NULL, symndx >= 0)
56 (3) global and forced-local symbols
57 (abfd != NULL, symndx == -1)
59 Type (3) entries are treated differently for different types of GOT.
60 In the "master" GOT -- i.e. the one that describes every GOT
61 reference needed in the link -- the mips_got_entry is keyed on both
62 the symbol and the input bfd that references it. If it turns out
63 that we need multiple GOTs, we can then use this information to
64 create separate GOTs for each input bfd.
66 However, we want each of these separate GOTs to have at most one
67 entry for a given symbol, so their type (3) entries are keyed only
68 on the symbol. The input bfd given by the "abfd" field is somewhat
69 arbitrary in this case.
71 This means that when there are multiple GOTs, each GOT has a unique
72 mips_got_entry for every symbol within it. We can therefore use the
73 mips_got_entry fields (tls_type and gotidx) to track the symbol's
76 However, if it turns out that we need only a single GOT, we continue
77 to use the master GOT to describe it. There may therefore be several
78 mips_got_entries for the same symbol, each with a different input bfd.
79 We want to make sure that each symbol gets a unique GOT entry, so when
80 there's a single GOT, we use the symbol's hash entry, not the
81 mips_got_entry fields, to track a symbol's GOT index. */
84 /* The input bfd in which the symbol is defined. */
86 /* The index of the symbol, as stored in the relocation r_info, if
87 we have a local symbol; -1 otherwise. */
91 /* If abfd == NULL, an address that must be stored in the got. */
93 /* If abfd != NULL && symndx != -1, the addend of the relocation
94 that should be added to the symbol value. */
96 /* If abfd != NULL && symndx == -1, the hash table entry
97 corresponding to a global symbol in the got (or, local, if
99 struct mips_elf_link_hash_entry
*h
;
102 /* The TLS types included in this GOT entry (specifically, GD and
103 IE). The GD and IE flags can be added as we encounter new
104 relocations. LDM can also be set; it will always be alone, not
105 combined with any GD or IE flags. An LDM GOT entry will be
106 a local symbol entry with r_symndx == 0. */
107 unsigned char tls_type
;
109 /* The offset from the beginning of the .got section to the entry
110 corresponding to this symbol+addend. If it's a global symbol
111 whose offset is yet to be decided, it's going to be -1. */
115 /* This structure describes a range of addends: [MIN_ADDEND, MAX_ADDEND].
116 The structures form a non-overlapping list that is sorted by increasing
118 struct mips_got_page_range
120 struct mips_got_page_range
*next
;
121 bfd_signed_vma min_addend
;
122 bfd_signed_vma max_addend
;
125 /* This structure describes the range of addends that are applied to page
126 relocations against a given symbol. */
127 struct mips_got_page_entry
129 /* The input bfd in which the symbol is defined. */
131 /* The index of the symbol, as stored in the relocation r_info. */
133 /* The ranges for this page entry. */
134 struct mips_got_page_range
*ranges
;
135 /* The maximum number of page entries needed for RANGES. */
139 /* This structure is used to hold .got information when linking. */
143 /* The global symbol in the GOT with the lowest index in the dynamic
145 struct elf_link_hash_entry
*global_gotsym
;
146 /* The number of global .got entries. */
147 unsigned int global_gotno
;
148 /* The number of .got slots used for TLS. */
149 unsigned int tls_gotno
;
150 /* The first unused TLS .got entry. Used only during
151 mips_elf_initialize_tls_index. */
152 unsigned int tls_assigned_gotno
;
153 /* The number of local .got entries, eventually including page entries. */
154 unsigned int local_gotno
;
155 /* The maximum number of page entries needed. */
156 unsigned int page_gotno
;
157 /* The number of local .got entries we have used. */
158 unsigned int assigned_gotno
;
159 /* A hash table holding members of the got. */
160 struct htab
*got_entries
;
161 /* A hash table of mips_got_page_entry structures. */
162 struct htab
*got_page_entries
;
163 /* A hash table mapping input bfds to other mips_got_info. NULL
164 unless multi-got was necessary. */
165 struct htab
*bfd2got
;
166 /* In multi-got links, a pointer to the next got (err, rather, most
167 of the time, it points to the previous got). */
168 struct mips_got_info
*next
;
169 /* This is the GOT index of the TLS LDM entry for the GOT, MINUS_ONE
170 for none, or MINUS_TWO for not yet assigned. This is needed
171 because a single-GOT link may have multiple hash table entries
172 for the LDM. It does not get initialized in multi-GOT mode. */
173 bfd_vma tls_ldm_offset
;
176 /* Map an input bfd to a got in a multi-got link. */
178 struct mips_elf_bfd2got_hash
{
180 struct mips_got_info
*g
;
183 /* Structure passed when traversing the bfd2got hash table, used to
184 create and merge bfd's gots. */
186 struct mips_elf_got_per_bfd_arg
188 /* A hashtable that maps bfds to gots. */
190 /* The output bfd. */
192 /* The link information. */
193 struct bfd_link_info
*info
;
194 /* A pointer to the primary got, i.e., the one that's going to get
195 the implicit relocations from DT_MIPS_LOCAL_GOTNO and
197 struct mips_got_info
*primary
;
198 /* A non-primary got we're trying to merge with other input bfd's
200 struct mips_got_info
*current
;
201 /* The maximum number of got entries that can be addressed with a
203 unsigned int max_count
;
204 /* The maximum number of page entries needed by each got. */
205 unsigned int max_pages
;
206 /* The total number of global entries which will live in the
207 primary got and be automatically relocated. This includes
208 those not referenced by the primary GOT but included in
210 unsigned int global_count
;
213 /* Another structure used to pass arguments for got entries traversal. */
215 struct mips_elf_set_global_got_offset_arg
217 struct mips_got_info
*g
;
219 unsigned int needed_relocs
;
220 struct bfd_link_info
*info
;
223 /* A structure used to count TLS relocations or GOT entries, for GOT
224 entry or ELF symbol table traversal. */
226 struct mips_elf_count_tls_arg
228 struct bfd_link_info
*info
;
232 struct _mips_elf_section_data
234 struct bfd_elf_section_data elf
;
241 #define mips_elf_section_data(sec) \
242 ((struct _mips_elf_section_data *) elf_section_data (sec))
244 /* This structure is passed to mips_elf_sort_hash_table_f when sorting
245 the dynamic symbols. */
247 struct mips_elf_hash_sort_data
249 /* The symbol in the global GOT with the lowest dynamic symbol table
251 struct elf_link_hash_entry
*low
;
252 /* The least dynamic symbol table index corresponding to a non-TLS
253 symbol with a GOT entry. */
254 long min_got_dynindx
;
255 /* The greatest dynamic symbol table index corresponding to a symbol
256 with a GOT entry that is not referenced (e.g., a dynamic symbol
257 with dynamic relocations pointing to it from non-primary GOTs). */
258 long max_unref_got_dynindx
;
259 /* The greatest dynamic symbol table index not corresponding to a
260 symbol without a GOT entry. */
261 long max_non_got_dynindx
;
264 /* The MIPS ELF linker needs additional information for each symbol in
265 the global hash table. */
267 struct mips_elf_link_hash_entry
269 struct elf_link_hash_entry root
;
271 /* External symbol information. */
274 /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
276 unsigned int possibly_dynamic_relocs
;
278 /* If there is a stub that 32 bit functions should use to call this
279 16 bit function, this points to the section containing the stub. */
282 /* If there is a stub that 16 bit functions should use to call this
283 32 bit function, this points to the section containing the stub. */
286 /* This is like the call_stub field, but it is used if the function
287 being called returns a floating point value. */
288 asection
*call_fp_stub
;
292 #define GOT_TLS_LDM 2
294 #define GOT_TLS_OFFSET_DONE 0x40
295 #define GOT_TLS_DONE 0x80
296 unsigned char tls_type
;
298 /* This is only used in single-GOT mode; in multi-GOT mode there
299 is one mips_got_entry per GOT entry, so the offset is stored
300 there. In single-GOT mode there may be many mips_got_entry
301 structures all referring to the same GOT slot. It might be
302 possible to use root.got.offset instead, but that field is
303 overloaded already. */
304 bfd_vma tls_got_offset
;
306 /* True if one of the relocations described by possibly_dynamic_relocs
307 is against a readonly section. */
308 unsigned int readonly_reloc
: 1;
310 /* True if we must not create a .MIPS.stubs entry for this symbol.
311 This is set, for example, if there are relocations related to
312 taking the function's address, i.e. any but R_MIPS_CALL*16 ones.
313 See "MIPS ABI Supplement, 3rd Edition", p. 4-20. */
314 unsigned int no_fn_stub
: 1;
316 /* Whether we need the fn_stub; this is true if this symbol appears
317 in any relocs other than a 16 bit call. */
318 unsigned int need_fn_stub
: 1;
320 /* Are we forced local? This will only be set if we have converted
321 the initial global GOT entry to a local GOT entry. */
322 unsigned int forced_local
: 1;
324 /* Are we referenced by some kind of relocation? */
325 unsigned int is_relocation_target
: 1;
327 /* Are we referenced by branch relocations? */
328 unsigned int is_branch_target
: 1;
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
368 /* The master GOT information. */
369 struct mips_got_info
*got_info
;
370 /* The size of the PLT header in bytes (VxWorks only). */
371 bfd_vma plt_header_size
;
372 /* The size of a PLT entry in bytes (VxWorks only). */
373 bfd_vma plt_entry_size
;
374 /* The size of a function stub entry in bytes. */
375 bfd_vma function_stub_size
;
378 #define TLS_RELOC_P(r_type) \
379 (r_type == R_MIPS_TLS_DTPMOD32 \
380 || r_type == R_MIPS_TLS_DTPMOD64 \
381 || r_type == R_MIPS_TLS_DTPREL32 \
382 || r_type == R_MIPS_TLS_DTPREL64 \
383 || r_type == R_MIPS_TLS_GD \
384 || r_type == R_MIPS_TLS_LDM \
385 || r_type == R_MIPS_TLS_DTPREL_HI16 \
386 || r_type == R_MIPS_TLS_DTPREL_LO16 \
387 || r_type == R_MIPS_TLS_GOTTPREL \
388 || r_type == R_MIPS_TLS_TPREL32 \
389 || r_type == R_MIPS_TLS_TPREL64 \
390 || r_type == R_MIPS_TLS_TPREL_HI16 \
391 || r_type == R_MIPS_TLS_TPREL_LO16)
393 /* Structure used to pass information to mips_elf_output_extsym. */
398 struct bfd_link_info
*info
;
399 struct ecoff_debug_info
*debug
;
400 const struct ecoff_debug_swap
*swap
;
404 /* The names of the runtime procedure table symbols used on IRIX5. */
406 static const char * const mips_elf_dynsym_rtproc_names
[] =
409 "_procedure_string_table",
410 "_procedure_table_size",
414 /* These structures are used to generate the .compact_rel section on
419 unsigned long id1
; /* Always one? */
420 unsigned long num
; /* Number of compact relocation entries. */
421 unsigned long id2
; /* Always two? */
422 unsigned long offset
; /* The file offset of the first relocation. */
423 unsigned long reserved0
; /* Zero? */
424 unsigned long reserved1
; /* Zero? */
433 bfd_byte reserved0
[4];
434 bfd_byte reserved1
[4];
435 } Elf32_External_compact_rel
;
439 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
440 unsigned int rtype
: 4; /* Relocation types. See below. */
441 unsigned int dist2to
: 8;
442 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
443 unsigned long konst
; /* KONST field. See below. */
444 unsigned long vaddr
; /* VADDR to be relocated. */
449 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
450 unsigned int rtype
: 4; /* Relocation types. See below. */
451 unsigned int dist2to
: 8;
452 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
453 unsigned long konst
; /* KONST field. See below. */
461 } Elf32_External_crinfo
;
467 } Elf32_External_crinfo2
;
469 /* These are the constants used to swap the bitfields in a crinfo. */
471 #define CRINFO_CTYPE (0x1)
472 #define CRINFO_CTYPE_SH (31)
473 #define CRINFO_RTYPE (0xf)
474 #define CRINFO_RTYPE_SH (27)
475 #define CRINFO_DIST2TO (0xff)
476 #define CRINFO_DIST2TO_SH (19)
477 #define CRINFO_RELVADDR (0x7ffff)
478 #define CRINFO_RELVADDR_SH (0)
480 /* A compact relocation info has long (3 words) or short (2 words)
481 formats. A short format doesn't have VADDR field and relvaddr
482 fields contains ((VADDR - vaddr of the previous entry) >> 2). */
483 #define CRF_MIPS_LONG 1
484 #define CRF_MIPS_SHORT 0
486 /* There are 4 types of compact relocation at least. The value KONST
487 has different meaning for each type:
490 CT_MIPS_REL32 Address in data
491 CT_MIPS_WORD Address in word (XXX)
492 CT_MIPS_GPHI_LO GP - vaddr
493 CT_MIPS_JMPAD Address to jump
496 #define CRT_MIPS_REL32 0xa
497 #define CRT_MIPS_WORD 0xb
498 #define CRT_MIPS_GPHI_LO 0xc
499 #define CRT_MIPS_JMPAD 0xd
501 #define mips_elf_set_cr_format(x,format) ((x).ctype = (format))
502 #define mips_elf_set_cr_type(x,type) ((x).rtype = (type))
503 #define mips_elf_set_cr_dist2to(x,v) ((x).dist2to = (v))
504 #define mips_elf_set_cr_relvaddr(x,d) ((x).relvaddr = (d)<<2)
506 /* The structure of the runtime procedure descriptor created by the
507 loader for use by the static exception system. */
509 typedef struct runtime_pdr
{
510 bfd_vma adr
; /* Memory address of start of procedure. */
511 long regmask
; /* Save register mask. */
512 long regoffset
; /* Save register offset. */
513 long fregmask
; /* Save floating point register mask. */
514 long fregoffset
; /* Save floating point register offset. */
515 long frameoffset
; /* Frame size. */
516 short framereg
; /* Frame pointer register. */
517 short pcreg
; /* Offset or reg of return pc. */
518 long irpss
; /* Index into the runtime string table. */
520 struct exception_info
*exception_info
;/* Pointer to exception array. */
522 #define cbRPDR sizeof (RPDR)
523 #define rpdNil ((pRPDR) 0)
525 static struct mips_got_entry
*mips_elf_create_local_got_entry
526 (bfd
*, struct bfd_link_info
*, bfd
*, bfd_vma
, unsigned long,
527 struct mips_elf_link_hash_entry
*, int);
528 static bfd_boolean mips_elf_sort_hash_table_f
529 (struct mips_elf_link_hash_entry
*, void *);
530 static bfd_vma mips_elf_high
532 static bfd_boolean mips_elf_create_dynamic_relocation
533 (bfd
*, struct bfd_link_info
*, const Elf_Internal_Rela
*,
534 struct mips_elf_link_hash_entry
*, asection
*, bfd_vma
,
535 bfd_vma
*, asection
*);
536 static hashval_t mips_elf_got_entry_hash
538 static bfd_vma mips_elf_adjust_gp
539 (bfd
*, struct mips_got_info
*, bfd
*);
540 static struct mips_got_info
*mips_elf_got_for_ibfd
541 (struct mips_got_info
*, bfd
*);
543 /* This will be used when we sort the dynamic relocation records. */
544 static bfd
*reldyn_sorting_bfd
;
546 /* Nonzero if ABFD is using the N32 ABI. */
547 #define ABI_N32_P(abfd) \
548 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
550 /* Nonzero if ABFD is using the N64 ABI. */
551 #define ABI_64_P(abfd) \
552 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
554 /* Nonzero if ABFD is using NewABI conventions. */
555 #define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
557 /* The IRIX compatibility level we are striving for. */
558 #define IRIX_COMPAT(abfd) \
559 (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
561 /* Whether we are trying to be compatible with IRIX at all. */
562 #define SGI_COMPAT(abfd) \
563 (IRIX_COMPAT (abfd) != ict_none)
565 /* The name of the options section. */
566 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
567 (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
569 /* True if NAME is the recognized name of any SHT_MIPS_OPTIONS section.
570 Some IRIX system files do not use MIPS_ELF_OPTIONS_SECTION_NAME. */
571 #define MIPS_ELF_OPTIONS_SECTION_NAME_P(NAME) \
572 (strcmp (NAME, ".MIPS.options") == 0 || strcmp (NAME, ".options") == 0)
574 /* Whether the section is readonly. */
575 #define MIPS_ELF_READONLY_SECTION(sec) \
576 ((sec->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY)) \
577 == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
579 /* The name of the stub section. */
580 #define MIPS_ELF_STUB_SECTION_NAME(abfd) ".MIPS.stubs"
582 /* The size of an external REL relocation. */
583 #define MIPS_ELF_REL_SIZE(abfd) \
584 (get_elf_backend_data (abfd)->s->sizeof_rel)
586 /* The size of an external RELA relocation. */
587 #define MIPS_ELF_RELA_SIZE(abfd) \
588 (get_elf_backend_data (abfd)->s->sizeof_rela)
590 /* The size of an external dynamic table entry. */
591 #define MIPS_ELF_DYN_SIZE(abfd) \
592 (get_elf_backend_data (abfd)->s->sizeof_dyn)
594 /* The size of a GOT entry. */
595 #define MIPS_ELF_GOT_SIZE(abfd) \
596 (get_elf_backend_data (abfd)->s->arch_size / 8)
598 /* The size of a symbol-table entry. */
599 #define MIPS_ELF_SYM_SIZE(abfd) \
600 (get_elf_backend_data (abfd)->s->sizeof_sym)
602 /* The default alignment for sections, as a power of two. */
603 #define MIPS_ELF_LOG_FILE_ALIGN(abfd) \
604 (get_elf_backend_data (abfd)->s->log_file_align)
606 /* Get word-sized data. */
607 #define MIPS_ELF_GET_WORD(abfd, ptr) \
608 (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
610 /* Put out word-sized data. */
611 #define MIPS_ELF_PUT_WORD(abfd, val, ptr) \
613 ? bfd_put_64 (abfd, val, ptr) \
614 : bfd_put_32 (abfd, val, ptr))
616 /* Add a dynamic symbol table-entry. */
617 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
618 _bfd_elf_add_dynamic_entry (info, tag, val)
620 #define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela) \
621 (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela))
623 /* Determine whether the internal relocation of index REL_IDX is REL
624 (zero) or RELA (non-zero). The assumption is that, if there are
625 two relocation sections for this section, one of them is REL and
626 the other is RELA. If the index of the relocation we're testing is
627 in range for the first relocation section, check that the external
628 relocation size is that for RELA. It is also assumed that, if
629 rel_idx is not in range for the first section, and this first
630 section contains REL relocs, then the relocation is in the second
631 section, that is RELA. */
632 #define MIPS_RELOC_RELA_P(abfd, sec, rel_idx) \
633 ((NUM_SHDR_ENTRIES (&elf_section_data (sec)->rel_hdr) \
634 * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel \
635 > (bfd_vma)(rel_idx)) \
636 == (elf_section_data (sec)->rel_hdr.sh_entsize \
637 == (ABI_64_P (abfd) ? sizeof (Elf64_External_Rela) \
638 : sizeof (Elf32_External_Rela))))
640 /* The name of the dynamic relocation section. */
641 #define MIPS_ELF_REL_DYN_NAME(INFO) \
642 (mips_elf_hash_table (INFO)->is_vxworks ? ".rela.dyn" : ".rel.dyn")
644 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
645 from smaller values. Start with zero, widen, *then* decrement. */
646 #define MINUS_ONE (((bfd_vma)0) - 1)
647 #define MINUS_TWO (((bfd_vma)0) - 2)
649 /* The number of local .got entries we reserve. */
650 #define MIPS_RESERVED_GOTNO(INFO) \
651 (mips_elf_hash_table (INFO)->is_vxworks ? 3 : 2)
653 /* The value to write into got[1] for SVR4 targets, to identify it is
654 a GNU object. The dynamic linker can then use got[1] to store the
656 #define MIPS_ELF_GNU_GOT1_MASK(abfd) \
657 ((bfd_vma) 1 << (ABI_64_P (abfd) ? 63 : 31))
659 /* The offset of $gp from the beginning of the .got section. */
660 #define ELF_MIPS_GP_OFFSET(INFO) \
661 (mips_elf_hash_table (INFO)->is_vxworks ? 0x0 : 0x7ff0)
663 /* The maximum size of the GOT for it to be addressable using 16-bit
665 #define MIPS_ELF_GOT_MAX_SIZE(INFO) (ELF_MIPS_GP_OFFSET (INFO) + 0x7fff)
667 /* Instructions which appear in a stub. */
668 #define STUB_LW(abfd) \
670 ? 0xdf998010 /* ld t9,0x8010(gp) */ \
671 : 0x8f998010)) /* lw t9,0x8010(gp) */
672 #define STUB_MOVE(abfd) \
674 ? 0x03e0782d /* daddu t7,ra */ \
675 : 0x03e07821)) /* addu t7,ra */
676 #define STUB_LUI(VAL) (0x3c180000 + (VAL)) /* lui t8,VAL */
677 #define STUB_JALR 0x0320f809 /* jalr t9,ra */
678 #define STUB_ORI(VAL) (0x37180000 + (VAL)) /* ori t8,t8,VAL */
679 #define STUB_LI16U(VAL) (0x34180000 + (VAL)) /* ori t8,zero,VAL unsigned */
680 #define STUB_LI16S(abfd, VAL) \
682 ? (0x64180000 + (VAL)) /* daddiu t8,zero,VAL sign extended */ \
683 : (0x24180000 + (VAL)))) /* addiu t8,zero,VAL sign extended */
685 #define MIPS_FUNCTION_STUB_NORMAL_SIZE 16
686 #define MIPS_FUNCTION_STUB_BIG_SIZE 20
688 /* The name of the dynamic interpreter. This is put in the .interp
691 #define ELF_DYNAMIC_INTERPRETER(abfd) \
692 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
693 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
694 : "/usr/lib/libc.so.1")
697 #define MNAME(bfd,pre,pos) \
698 (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
699 #define ELF_R_SYM(bfd, i) \
700 (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
701 #define ELF_R_TYPE(bfd, i) \
702 (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
703 #define ELF_R_INFO(bfd, s, t) \
704 (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
706 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
707 #define ELF_R_SYM(bfd, i) \
709 #define ELF_R_TYPE(bfd, i) \
711 #define ELF_R_INFO(bfd, s, t) \
712 (ELF32_R_INFO (s, t))
715 /* The mips16 compiler uses a couple of special sections to handle
716 floating point arguments.
718 Section names that look like .mips16.fn.FNNAME contain stubs that
719 copy floating point arguments from the fp regs to the gp regs and
720 then jump to FNNAME. If any 32 bit function calls FNNAME, the
721 call should be redirected to the stub instead. If no 32 bit
722 function calls FNNAME, the stub should be discarded. We need to
723 consider any reference to the function, not just a call, because
724 if the address of the function is taken we will need the stub,
725 since the address might be passed to a 32 bit function.
727 Section names that look like .mips16.call.FNNAME contain stubs
728 that copy floating point arguments from the gp regs to the fp
729 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
730 then any 16 bit function that calls FNNAME should be redirected
731 to the stub instead. If FNNAME is not a 32 bit function, the
732 stub should be discarded.
734 .mips16.call.fp.FNNAME sections are similar, but contain stubs
735 which call FNNAME and then copy the return value from the fp regs
736 to the gp regs. These stubs store the return value in $18 while
737 calling FNNAME; any function which might call one of these stubs
738 must arrange to save $18 around the call. (This case is not
739 needed for 32 bit functions that call 16 bit functions, because
740 16 bit functions always return floating point values in both
743 Note that in all cases FNNAME might be defined statically.
744 Therefore, FNNAME is not used literally. Instead, the relocation
745 information will indicate which symbol the section is for.
747 We record any stubs that we find in the symbol table. */
749 #define FN_STUB ".mips16.fn."
750 #define CALL_STUB ".mips16.call."
751 #define CALL_FP_STUB ".mips16.call.fp."
753 #define FN_STUB_P(name) CONST_STRNEQ (name, FN_STUB)
754 #define CALL_STUB_P(name) CONST_STRNEQ (name, CALL_STUB)
755 #define CALL_FP_STUB_P(name) CONST_STRNEQ (name, CALL_FP_STUB)
757 /* The format of the first PLT entry in a VxWorks executable. */
758 static const bfd_vma mips_vxworks_exec_plt0_entry
[] = {
759 0x3c190000, /* lui t9, %hi(_GLOBAL_OFFSET_TABLE_) */
760 0x27390000, /* addiu t9, t9, %lo(_GLOBAL_OFFSET_TABLE_) */
761 0x8f390008, /* lw t9, 8(t9) */
762 0x00000000, /* nop */
763 0x03200008, /* jr t9 */
767 /* The format of subsequent PLT entries. */
768 static const bfd_vma mips_vxworks_exec_plt_entry
[] = {
769 0x10000000, /* b .PLT_resolver */
770 0x24180000, /* li t8, <pltindex> */
771 0x3c190000, /* lui t9, %hi(<.got.plt slot>) */
772 0x27390000, /* addiu t9, t9, %lo(<.got.plt slot>) */
773 0x8f390000, /* lw t9, 0(t9) */
774 0x00000000, /* nop */
775 0x03200008, /* jr t9 */
779 /* The format of the first PLT entry in a VxWorks shared object. */
780 static const bfd_vma mips_vxworks_shared_plt0_entry
[] = {
781 0x8f990008, /* lw t9, 8(gp) */
782 0x00000000, /* nop */
783 0x03200008, /* jr t9 */
784 0x00000000, /* nop */
785 0x00000000, /* nop */
789 /* The format of subsequent PLT entries. */
790 static const bfd_vma mips_vxworks_shared_plt_entry
[] = {
791 0x10000000, /* b .PLT_resolver */
792 0x24180000 /* li t8, <pltindex> */
795 /* Look up an entry in a MIPS ELF linker hash table. */
797 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
798 ((struct mips_elf_link_hash_entry *) \
799 elf_link_hash_lookup (&(table)->root, (string), (create), \
802 /* Traverse a MIPS ELF linker hash table. */
804 #define mips_elf_link_hash_traverse(table, func, info) \
805 (elf_link_hash_traverse \
807 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
810 /* Get the MIPS ELF linker hash table from a link_info structure. */
812 #define mips_elf_hash_table(p) \
813 ((struct mips_elf_link_hash_table *) ((p)->hash))
815 /* Find the base offsets for thread-local storage in this object,
816 for GD/LD and IE/LE respectively. */
818 #define TP_OFFSET 0x7000
819 #define DTP_OFFSET 0x8000
822 dtprel_base (struct bfd_link_info
*info
)
824 /* If tls_sec is NULL, we should have signalled an error already. */
825 if (elf_hash_table (info
)->tls_sec
== NULL
)
827 return elf_hash_table (info
)->tls_sec
->vma
+ DTP_OFFSET
;
831 tprel_base (struct bfd_link_info
*info
)
833 /* If tls_sec is NULL, we should have signalled an error already. */
834 if (elf_hash_table (info
)->tls_sec
== NULL
)
836 return elf_hash_table (info
)->tls_sec
->vma
+ TP_OFFSET
;
839 /* Create an entry in a MIPS ELF linker hash table. */
841 static struct bfd_hash_entry
*
842 mips_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
843 struct bfd_hash_table
*table
, const char *string
)
845 struct mips_elf_link_hash_entry
*ret
=
846 (struct mips_elf_link_hash_entry
*) entry
;
848 /* Allocate the structure if it has not already been allocated by a
851 ret
= bfd_hash_allocate (table
, sizeof (struct mips_elf_link_hash_entry
));
853 return (struct bfd_hash_entry
*) ret
;
855 /* Call the allocation method of the superclass. */
856 ret
= ((struct mips_elf_link_hash_entry
*)
857 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
861 /* Set local fields. */
862 memset (&ret
->esym
, 0, sizeof (EXTR
));
863 /* We use -2 as a marker to indicate that the information has
864 not been set. -1 means there is no associated ifd. */
866 ret
->possibly_dynamic_relocs
= 0;
868 ret
->call_stub
= NULL
;
869 ret
->call_fp_stub
= NULL
;
870 ret
->tls_type
= GOT_NORMAL
;
871 ret
->readonly_reloc
= FALSE
;
872 ret
->no_fn_stub
= FALSE
;
873 ret
->need_fn_stub
= FALSE
;
874 ret
->forced_local
= FALSE
;
875 ret
->is_relocation_target
= FALSE
;
876 ret
->is_branch_target
= FALSE
;
879 return (struct bfd_hash_entry
*) ret
;
883 _bfd_mips_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
885 if (!sec
->used_by_bfd
)
887 struct _mips_elf_section_data
*sdata
;
888 bfd_size_type amt
= sizeof (*sdata
);
890 sdata
= bfd_zalloc (abfd
, amt
);
893 sec
->used_by_bfd
= sdata
;
896 return _bfd_elf_new_section_hook (abfd
, sec
);
899 /* Read ECOFF debugging information from a .mdebug section into a
900 ecoff_debug_info structure. */
903 _bfd_mips_elf_read_ecoff_info (bfd
*abfd
, asection
*section
,
904 struct ecoff_debug_info
*debug
)
907 const struct ecoff_debug_swap
*swap
;
910 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
911 memset (debug
, 0, sizeof (*debug
));
913 ext_hdr
= bfd_malloc (swap
->external_hdr_size
);
914 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
917 if (! bfd_get_section_contents (abfd
, section
, ext_hdr
, 0,
918 swap
->external_hdr_size
))
921 symhdr
= &debug
->symbolic_header
;
922 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
924 /* The symbolic header contains absolute file offsets and sizes to
926 #define READ(ptr, offset, count, size, type) \
927 if (symhdr->count == 0) \
931 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
932 debug->ptr = bfd_malloc (amt); \
933 if (debug->ptr == NULL) \
935 if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0 \
936 || bfd_bread (debug->ptr, amt, abfd) != amt) \
940 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
941 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, void *);
942 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, void *);
943 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, void *);
944 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, void *);
945 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
947 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
948 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
949 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, void *);
950 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, void *);
951 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, void *);
961 if (debug
->line
!= NULL
)
963 if (debug
->external_dnr
!= NULL
)
964 free (debug
->external_dnr
);
965 if (debug
->external_pdr
!= NULL
)
966 free (debug
->external_pdr
);
967 if (debug
->external_sym
!= NULL
)
968 free (debug
->external_sym
);
969 if (debug
->external_opt
!= NULL
)
970 free (debug
->external_opt
);
971 if (debug
->external_aux
!= NULL
)
972 free (debug
->external_aux
);
973 if (debug
->ss
!= NULL
)
975 if (debug
->ssext
!= NULL
)
977 if (debug
->external_fdr
!= NULL
)
978 free (debug
->external_fdr
);
979 if (debug
->external_rfd
!= NULL
)
980 free (debug
->external_rfd
);
981 if (debug
->external_ext
!= NULL
)
982 free (debug
->external_ext
);
986 /* Swap RPDR (runtime procedure table entry) for output. */
989 ecoff_swap_rpdr_out (bfd
*abfd
, const RPDR
*in
, struct rpdr_ext
*ex
)
991 H_PUT_S32 (abfd
, in
->adr
, ex
->p_adr
);
992 H_PUT_32 (abfd
, in
->regmask
, ex
->p_regmask
);
993 H_PUT_32 (abfd
, in
->regoffset
, ex
->p_regoffset
);
994 H_PUT_32 (abfd
, in
->fregmask
, ex
->p_fregmask
);
995 H_PUT_32 (abfd
, in
->fregoffset
, ex
->p_fregoffset
);
996 H_PUT_32 (abfd
, in
->frameoffset
, ex
->p_frameoffset
);
998 H_PUT_16 (abfd
, in
->framereg
, ex
->p_framereg
);
999 H_PUT_16 (abfd
, in
->pcreg
, ex
->p_pcreg
);
1001 H_PUT_32 (abfd
, in
->irpss
, ex
->p_irpss
);
1004 /* Create a runtime procedure table from the .mdebug section. */
1007 mips_elf_create_procedure_table (void *handle
, bfd
*abfd
,
1008 struct bfd_link_info
*info
, asection
*s
,
1009 struct ecoff_debug_info
*debug
)
1011 const struct ecoff_debug_swap
*swap
;
1012 HDRR
*hdr
= &debug
->symbolic_header
;
1014 struct rpdr_ext
*erp
;
1016 struct pdr_ext
*epdr
;
1017 struct sym_ext
*esym
;
1021 bfd_size_type count
;
1022 unsigned long sindex
;
1026 const char *no_name_func
= _("static procedure (no name)");
1034 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
1036 sindex
= strlen (no_name_func
) + 1;
1037 count
= hdr
->ipdMax
;
1040 size
= swap
->external_pdr_size
;
1042 epdr
= bfd_malloc (size
* count
);
1046 if (! _bfd_ecoff_get_accumulated_pdr (handle
, (bfd_byte
*) epdr
))
1049 size
= sizeof (RPDR
);
1050 rp
= rpdr
= bfd_malloc (size
* count
);
1054 size
= sizeof (char *);
1055 sv
= bfd_malloc (size
* count
);
1059 count
= hdr
->isymMax
;
1060 size
= swap
->external_sym_size
;
1061 esym
= bfd_malloc (size
* count
);
1065 if (! _bfd_ecoff_get_accumulated_sym (handle
, (bfd_byte
*) esym
))
1068 count
= hdr
->issMax
;
1069 ss
= bfd_malloc (count
);
1072 if (! _bfd_ecoff_get_accumulated_ss (handle
, (bfd_byte
*) ss
))
1075 count
= hdr
->ipdMax
;
1076 for (i
= 0; i
< (unsigned long) count
; i
++, rp
++)
1078 (*swap
->swap_pdr_in
) (abfd
, epdr
+ i
, &pdr
);
1079 (*swap
->swap_sym_in
) (abfd
, &esym
[pdr
.isym
], &sym
);
1080 rp
->adr
= sym
.value
;
1081 rp
->regmask
= pdr
.regmask
;
1082 rp
->regoffset
= pdr
.regoffset
;
1083 rp
->fregmask
= pdr
.fregmask
;
1084 rp
->fregoffset
= pdr
.fregoffset
;
1085 rp
->frameoffset
= pdr
.frameoffset
;
1086 rp
->framereg
= pdr
.framereg
;
1087 rp
->pcreg
= pdr
.pcreg
;
1089 sv
[i
] = ss
+ sym
.iss
;
1090 sindex
+= strlen (sv
[i
]) + 1;
1094 size
= sizeof (struct rpdr_ext
) * (count
+ 2) + sindex
;
1095 size
= BFD_ALIGN (size
, 16);
1096 rtproc
= bfd_alloc (abfd
, size
);
1099 mips_elf_hash_table (info
)->procedure_count
= 0;
1103 mips_elf_hash_table (info
)->procedure_count
= count
+ 2;
1106 memset (erp
, 0, sizeof (struct rpdr_ext
));
1108 str
= (char *) rtproc
+ sizeof (struct rpdr_ext
) * (count
+ 2);
1109 strcpy (str
, no_name_func
);
1110 str
+= strlen (no_name_func
) + 1;
1111 for (i
= 0; i
< count
; i
++)
1113 ecoff_swap_rpdr_out (abfd
, rpdr
+ i
, erp
+ i
);
1114 strcpy (str
, sv
[i
]);
1115 str
+= strlen (sv
[i
]) + 1;
1117 H_PUT_S32 (abfd
, -1, (erp
+ count
)->p_adr
);
1119 /* Set the size and contents of .rtproc section. */
1121 s
->contents
= rtproc
;
1123 /* Skip this section later on (I don't think this currently
1124 matters, but someday it might). */
1125 s
->map_head
.link_order
= NULL
;
1154 /* We're about to redefine H. Create a symbol to represent H's
1155 current value and size, to help make the disassembly easier
1159 mips_elf_create_shadow_symbol (struct bfd_link_info
*info
,
1160 struct mips_elf_link_hash_entry
*h
,
1163 struct bfd_link_hash_entry
*bh
;
1164 struct elf_link_hash_entry
*elfh
;
1169 /* Read the symbol's value. */
1170 BFD_ASSERT (h
->root
.root
.type
== bfd_link_hash_defined
1171 || h
->root
.root
.type
== bfd_link_hash_defweak
);
1172 s
= h
->root
.root
.u
.def
.section
;
1173 value
= h
->root
.root
.u
.def
.value
;
1175 /* Create a new symbol. */
1176 name
= ACONCAT ((prefix
, h
->root
.root
.root
.string
, NULL
));
1178 if (!_bfd_generic_link_add_one_symbol (info
, s
->owner
, name
,
1179 BSF_LOCAL
, s
, value
, NULL
,
1183 /* Make it local and copy the other attributes from H. */
1184 elfh
= (struct elf_link_hash_entry
*) bh
;
1185 elfh
->type
= ELF_ST_INFO (STB_LOCAL
, ELF_ST_TYPE (h
->root
.type
));
1186 elfh
->other
= h
->root
.other
;
1187 elfh
->size
= h
->root
.size
;
1188 elfh
->forced_local
= 1;
1192 /* Return TRUE if relocations in SECTION can refer directly to a MIPS16
1193 function rather than to a hard-float stub. */
1196 section_allows_mips16_refs_p (asection
*section
)
1200 name
= bfd_get_section_name (section
->owner
, section
);
1201 return (FN_STUB_P (name
)
1202 || CALL_STUB_P (name
)
1203 || CALL_FP_STUB_P (name
)
1204 || strcmp (name
, ".pdr") == 0);
1207 /* [RELOCS, RELEND) are the relocations against SEC, which is a MIPS16
1208 stub section of some kind. Return the R_SYMNDX of the target
1209 function, or 0 if we can't decide which function that is. */
1211 static unsigned long
1212 mips16_stub_symndx (asection
*sec
, const Elf_Internal_Rela
*relocs
,
1213 const Elf_Internal_Rela
*relend
)
1215 const Elf_Internal_Rela
*rel
;
1217 /* Trust the first R_MIPS_NONE relocation, if any. */
1218 for (rel
= relocs
; rel
< relend
; rel
++)
1219 if (ELF_R_TYPE (sec
->owner
, rel
->r_info
) == R_MIPS_NONE
)
1220 return ELF_R_SYM (sec
->owner
, rel
->r_info
);
1222 /* Otherwise trust the first relocation, whatever its kind. This is
1223 the traditional behavior. */
1224 if (relocs
< relend
)
1225 return ELF_R_SYM (sec
->owner
, relocs
->r_info
);
1230 /* Check the mips16 stubs for a particular symbol, and see if we can
1234 mips_elf_check_mips16_stubs (struct mips_elf_link_hash_entry
*h
, void *data
)
1236 struct bfd_link_info
*info
;
1238 info
= (struct bfd_link_info
*) data
;
1239 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1240 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1242 /* Dynamic symbols must use the standard call interface, in case other
1243 objects try to call them. */
1244 if (h
->fn_stub
!= NULL
1245 && h
->root
.dynindx
!= -1)
1247 mips_elf_create_shadow_symbol (info
, h
, ".mips16.");
1248 h
->need_fn_stub
= TRUE
;
1251 if (h
->fn_stub
!= NULL
1252 && ! h
->need_fn_stub
)
1254 /* We don't need the fn_stub; the only references to this symbol
1255 are 16 bit calls. Clobber the size to 0 to prevent it from
1256 being included in the link. */
1257 h
->fn_stub
->size
= 0;
1258 h
->fn_stub
->flags
&= ~SEC_RELOC
;
1259 h
->fn_stub
->reloc_count
= 0;
1260 h
->fn_stub
->flags
|= SEC_EXCLUDE
;
1263 if (h
->call_stub
!= NULL
1264 && ELF_ST_IS_MIPS16 (h
->root
.other
))
1266 /* We don't need the call_stub; this is a 16 bit function, so
1267 calls from other 16 bit functions are OK. Clobber the size
1268 to 0 to prevent it from being included in the link. */
1269 h
->call_stub
->size
= 0;
1270 h
->call_stub
->flags
&= ~SEC_RELOC
;
1271 h
->call_stub
->reloc_count
= 0;
1272 h
->call_stub
->flags
|= SEC_EXCLUDE
;
1275 if (h
->call_fp_stub
!= NULL
1276 && ELF_ST_IS_MIPS16 (h
->root
.other
))
1278 /* We don't need the call_stub; this is a 16 bit function, so
1279 calls from other 16 bit functions are OK. Clobber the size
1280 to 0 to prevent it from being included in the link. */
1281 h
->call_fp_stub
->size
= 0;
1282 h
->call_fp_stub
->flags
&= ~SEC_RELOC
;
1283 h
->call_fp_stub
->reloc_count
= 0;
1284 h
->call_fp_stub
->flags
|= SEC_EXCLUDE
;
1290 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
1291 Most mips16 instructions are 16 bits, but these instructions
1294 The format of these instructions is:
1296 +--------------+--------------------------------+
1297 | JALX | X| Imm 20:16 | Imm 25:21 |
1298 +--------------+--------------------------------+
1300 +-----------------------------------------------+
1302 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
1303 Note that the immediate value in the first word is swapped.
1305 When producing a relocatable object file, R_MIPS16_26 is
1306 handled mostly like R_MIPS_26. In particular, the addend is
1307 stored as a straight 26-bit value in a 32-bit instruction.
1308 (gas makes life simpler for itself by never adjusting a
1309 R_MIPS16_26 reloc to be against a section, so the addend is
1310 always zero). However, the 32 bit instruction is stored as 2
1311 16-bit values, rather than a single 32-bit value. In a
1312 big-endian file, the result is the same; in a little-endian
1313 file, the two 16-bit halves of the 32 bit value are swapped.
1314 This is so that a disassembler can recognize the jal
1317 When doing a final link, R_MIPS16_26 is treated as a 32 bit
1318 instruction stored as two 16-bit values. The addend A is the
1319 contents of the targ26 field. The calculation is the same as
1320 R_MIPS_26. When storing the calculated value, reorder the
1321 immediate value as shown above, and don't forget to store the
1322 value as two 16-bit values.
1324 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
1328 +--------+----------------------+
1332 +--------+----------------------+
1335 +----------+------+-------------+
1339 +----------+--------------------+
1340 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
1341 ((sub1 << 16) | sub2)).
1343 When producing a relocatable object file, the calculation is
1344 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1345 When producing a fully linked file, the calculation is
1346 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1347 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)
1349 The table below lists the other MIPS16 instruction relocations.
1350 Each one is calculated in the same way as the non-MIPS16 relocation
1351 given on the right, but using the extended MIPS16 layout of 16-bit
1354 R_MIPS16_GPREL R_MIPS_GPREL16
1355 R_MIPS16_GOT16 R_MIPS_GOT16
1356 R_MIPS16_CALL16 R_MIPS_CALL16
1357 R_MIPS16_HI16 R_MIPS_HI16
1358 R_MIPS16_LO16 R_MIPS_LO16
1360 A typical instruction will have a format like this:
1362 +--------------+--------------------------------+
1363 | EXTEND | Imm 10:5 | Imm 15:11 |
1364 +--------------+--------------------------------+
1365 | Major | rx | ry | Imm 4:0 |
1366 +--------------+--------------------------------+
1368 EXTEND is the five bit value 11110. Major is the instruction
1371 All we need to do here is shuffle the bits appropriately.
1372 As above, the two 16-bit halves must be swapped on a
1373 little-endian system. */
1375 static inline bfd_boolean
1376 mips16_reloc_p (int r_type
)
1381 case R_MIPS16_GPREL
:
1382 case R_MIPS16_GOT16
:
1383 case R_MIPS16_CALL16
:
1393 static inline bfd_boolean
1394 got16_reloc_p (int r_type
)
1396 return r_type
== R_MIPS_GOT16
|| r_type
== R_MIPS16_GOT16
;
1399 static inline bfd_boolean
1400 call16_reloc_p (int r_type
)
1402 return r_type
== R_MIPS_CALL16
|| r_type
== R_MIPS16_CALL16
;
1405 static inline bfd_boolean
1406 hi16_reloc_p (int r_type
)
1408 return r_type
== R_MIPS_HI16
|| r_type
== R_MIPS16_HI16
;
1411 static inline bfd_boolean
1412 lo16_reloc_p (int r_type
)
1414 return r_type
== R_MIPS_LO16
|| r_type
== R_MIPS16_LO16
;
1417 static inline bfd_boolean
1418 mips16_call_reloc_p (int r_type
)
1420 return r_type
== R_MIPS16_26
|| r_type
== R_MIPS16_CALL16
;
1424 _bfd_mips16_elf_reloc_unshuffle (bfd
*abfd
, int r_type
,
1425 bfd_boolean jal_shuffle
, bfd_byte
*data
)
1427 bfd_vma extend
, insn
, val
;
1429 if (!mips16_reloc_p (r_type
))
1432 /* Pick up the mips16 extend instruction and the real instruction. */
1433 extend
= bfd_get_16 (abfd
, data
);
1434 insn
= bfd_get_16 (abfd
, data
+ 2);
1435 if (r_type
== R_MIPS16_26
)
1438 val
= ((extend
& 0xfc00) << 16) | ((extend
& 0x3e0) << 11)
1439 | ((extend
& 0x1f) << 21) | insn
;
1441 val
= extend
<< 16 | insn
;
1444 val
= ((extend
& 0xf800) << 16) | ((insn
& 0xffe0) << 11)
1445 | ((extend
& 0x1f) << 11) | (extend
& 0x7e0) | (insn
& 0x1f);
1446 bfd_put_32 (abfd
, val
, data
);
1450 _bfd_mips16_elf_reloc_shuffle (bfd
*abfd
, int r_type
,
1451 bfd_boolean jal_shuffle
, bfd_byte
*data
)
1453 bfd_vma extend
, insn
, val
;
1455 if (!mips16_reloc_p (r_type
))
1458 val
= bfd_get_32 (abfd
, data
);
1459 if (r_type
== R_MIPS16_26
)
1463 insn
= val
& 0xffff;
1464 extend
= ((val
>> 16) & 0xfc00) | ((val
>> 11) & 0x3e0)
1465 | ((val
>> 21) & 0x1f);
1469 insn
= val
& 0xffff;
1475 insn
= ((val
>> 11) & 0xffe0) | (val
& 0x1f);
1476 extend
= ((val
>> 16) & 0xf800) | ((val
>> 11) & 0x1f) | (val
& 0x7e0);
1478 bfd_put_16 (abfd
, insn
, data
+ 2);
1479 bfd_put_16 (abfd
, extend
, data
);
1482 bfd_reloc_status_type
1483 _bfd_mips_elf_gprel16_with_gp (bfd
*abfd
, asymbol
*symbol
,
1484 arelent
*reloc_entry
, asection
*input_section
,
1485 bfd_boolean relocatable
, void *data
, bfd_vma gp
)
1489 bfd_reloc_status_type status
;
1491 if (bfd_is_com_section (symbol
->section
))
1494 relocation
= symbol
->value
;
1496 relocation
+= symbol
->section
->output_section
->vma
;
1497 relocation
+= symbol
->section
->output_offset
;
1499 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1500 return bfd_reloc_outofrange
;
1502 /* Set val to the offset into the section or symbol. */
1503 val
= reloc_entry
->addend
;
1505 _bfd_mips_elf_sign_extend (val
, 16);
1507 /* Adjust val for the final section location and GP value. If we
1508 are producing relocatable output, we don't want to do this for
1509 an external symbol. */
1511 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1512 val
+= relocation
- gp
;
1514 if (reloc_entry
->howto
->partial_inplace
)
1516 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
1518 + reloc_entry
->address
);
1519 if (status
!= bfd_reloc_ok
)
1523 reloc_entry
->addend
= val
;
1526 reloc_entry
->address
+= input_section
->output_offset
;
1528 return bfd_reloc_ok
;
1531 /* Used to store a REL high-part relocation such as R_MIPS_HI16 or
1532 R_MIPS_GOT16. REL is the relocation, INPUT_SECTION is the section
1533 that contains the relocation field and DATA points to the start of
1538 struct mips_hi16
*next
;
1540 asection
*input_section
;
1544 /* FIXME: This should not be a static variable. */
1546 static struct mips_hi16
*mips_hi16_list
;
1548 /* A howto special_function for REL *HI16 relocations. We can only
1549 calculate the correct value once we've seen the partnering
1550 *LO16 relocation, so just save the information for later.
1552 The ABI requires that the *LO16 immediately follow the *HI16.
1553 However, as a GNU extension, we permit an arbitrary number of
1554 *HI16s to be associated with a single *LO16. This significantly
1555 simplies the relocation handling in gcc. */
1557 bfd_reloc_status_type
1558 _bfd_mips_elf_hi16_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
1559 asymbol
*symbol ATTRIBUTE_UNUSED
, void *data
,
1560 asection
*input_section
, bfd
*output_bfd
,
1561 char **error_message ATTRIBUTE_UNUSED
)
1563 struct mips_hi16
*n
;
1565 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1566 return bfd_reloc_outofrange
;
1568 n
= bfd_malloc (sizeof *n
);
1570 return bfd_reloc_outofrange
;
1572 n
->next
= mips_hi16_list
;
1574 n
->input_section
= input_section
;
1575 n
->rel
= *reloc_entry
;
1578 if (output_bfd
!= NULL
)
1579 reloc_entry
->address
+= input_section
->output_offset
;
1581 return bfd_reloc_ok
;
1584 /* A howto special_function for REL R_MIPS*_GOT16 relocations. This is just
1585 like any other 16-bit relocation when applied to global symbols, but is
1586 treated in the same as R_MIPS_HI16 when applied to local symbols. */
1588 bfd_reloc_status_type
1589 _bfd_mips_elf_got16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1590 void *data
, asection
*input_section
,
1591 bfd
*output_bfd
, char **error_message
)
1593 if ((symbol
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
1594 || bfd_is_und_section (bfd_get_section (symbol
))
1595 || bfd_is_com_section (bfd_get_section (symbol
)))
1596 /* The relocation is against a global symbol. */
1597 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1598 input_section
, output_bfd
,
1601 return _bfd_mips_elf_hi16_reloc (abfd
, reloc_entry
, symbol
, data
,
1602 input_section
, output_bfd
, error_message
);
1605 /* A howto special_function for REL *LO16 relocations. The *LO16 itself
1606 is a straightforward 16 bit inplace relocation, but we must deal with
1607 any partnering high-part relocations as well. */
1609 bfd_reloc_status_type
1610 _bfd_mips_elf_lo16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1611 void *data
, asection
*input_section
,
1612 bfd
*output_bfd
, char **error_message
)
1615 bfd_byte
*location
= (bfd_byte
*) data
+ reloc_entry
->address
;
1617 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1618 return bfd_reloc_outofrange
;
1620 _bfd_mips16_elf_reloc_unshuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1622 vallo
= bfd_get_32 (abfd
, location
);
1623 _bfd_mips16_elf_reloc_shuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1626 while (mips_hi16_list
!= NULL
)
1628 bfd_reloc_status_type ret
;
1629 struct mips_hi16
*hi
;
1631 hi
= mips_hi16_list
;
1633 /* R_MIPS*_GOT16 relocations are something of a special case. We
1634 want to install the addend in the same way as for a R_MIPS*_HI16
1635 relocation (with a rightshift of 16). However, since GOT16
1636 relocations can also be used with global symbols, their howto
1637 has a rightshift of 0. */
1638 if (hi
->rel
.howto
->type
== R_MIPS_GOT16
)
1639 hi
->rel
.howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, R_MIPS_HI16
, FALSE
);
1640 else if (hi
->rel
.howto
->type
== R_MIPS16_GOT16
)
1641 hi
->rel
.howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, R_MIPS16_HI16
, FALSE
);
1643 /* VALLO is a signed 16-bit number. Bias it by 0x8000 so that any
1644 carry or borrow will induce a change of +1 or -1 in the high part. */
1645 hi
->rel
.addend
+= (vallo
+ 0x8000) & 0xffff;
1647 ret
= _bfd_mips_elf_generic_reloc (abfd
, &hi
->rel
, symbol
, hi
->data
,
1648 hi
->input_section
, output_bfd
,
1650 if (ret
!= bfd_reloc_ok
)
1653 mips_hi16_list
= hi
->next
;
1657 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1658 input_section
, output_bfd
,
1662 /* A generic howto special_function. This calculates and installs the
1663 relocation itself, thus avoiding the oft-discussed problems in
1664 bfd_perform_relocation and bfd_install_relocation. */
1666 bfd_reloc_status_type
1667 _bfd_mips_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
1668 asymbol
*symbol
, void *data ATTRIBUTE_UNUSED
,
1669 asection
*input_section
, bfd
*output_bfd
,
1670 char **error_message ATTRIBUTE_UNUSED
)
1673 bfd_reloc_status_type status
;
1674 bfd_boolean relocatable
;
1676 relocatable
= (output_bfd
!= NULL
);
1678 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1679 return bfd_reloc_outofrange
;
1681 /* Build up the field adjustment in VAL. */
1683 if (!relocatable
|| (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1685 /* Either we're calculating the final field value or we have a
1686 relocation against a section symbol. Add in the section's
1687 offset or address. */
1688 val
+= symbol
->section
->output_section
->vma
;
1689 val
+= symbol
->section
->output_offset
;
1694 /* We're calculating the final field value. Add in the symbol's value
1695 and, if pc-relative, subtract the address of the field itself. */
1696 val
+= symbol
->value
;
1697 if (reloc_entry
->howto
->pc_relative
)
1699 val
-= input_section
->output_section
->vma
;
1700 val
-= input_section
->output_offset
;
1701 val
-= reloc_entry
->address
;
1705 /* VAL is now the final adjustment. If we're keeping this relocation
1706 in the output file, and if the relocation uses a separate addend,
1707 we just need to add VAL to that addend. Otherwise we need to add
1708 VAL to the relocation field itself. */
1709 if (relocatable
&& !reloc_entry
->howto
->partial_inplace
)
1710 reloc_entry
->addend
+= val
;
1713 bfd_byte
*location
= (bfd_byte
*) data
+ reloc_entry
->address
;
1715 /* Add in the separate addend, if any. */
1716 val
+= reloc_entry
->addend
;
1718 /* Add VAL to the relocation field. */
1719 _bfd_mips16_elf_reloc_unshuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1721 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
1723 _bfd_mips16_elf_reloc_shuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1726 if (status
!= bfd_reloc_ok
)
1731 reloc_entry
->address
+= input_section
->output_offset
;
1733 return bfd_reloc_ok
;
1736 /* Swap an entry in a .gptab section. Note that these routines rely
1737 on the equivalence of the two elements of the union. */
1740 bfd_mips_elf32_swap_gptab_in (bfd
*abfd
, const Elf32_External_gptab
*ex
,
1743 in
->gt_entry
.gt_g_value
= H_GET_32 (abfd
, ex
->gt_entry
.gt_g_value
);
1744 in
->gt_entry
.gt_bytes
= H_GET_32 (abfd
, ex
->gt_entry
.gt_bytes
);
1748 bfd_mips_elf32_swap_gptab_out (bfd
*abfd
, const Elf32_gptab
*in
,
1749 Elf32_External_gptab
*ex
)
1751 H_PUT_32 (abfd
, in
->gt_entry
.gt_g_value
, ex
->gt_entry
.gt_g_value
);
1752 H_PUT_32 (abfd
, in
->gt_entry
.gt_bytes
, ex
->gt_entry
.gt_bytes
);
1756 bfd_elf32_swap_compact_rel_out (bfd
*abfd
, const Elf32_compact_rel
*in
,
1757 Elf32_External_compact_rel
*ex
)
1759 H_PUT_32 (abfd
, in
->id1
, ex
->id1
);
1760 H_PUT_32 (abfd
, in
->num
, ex
->num
);
1761 H_PUT_32 (abfd
, in
->id2
, ex
->id2
);
1762 H_PUT_32 (abfd
, in
->offset
, ex
->offset
);
1763 H_PUT_32 (abfd
, in
->reserved0
, ex
->reserved0
);
1764 H_PUT_32 (abfd
, in
->reserved1
, ex
->reserved1
);
1768 bfd_elf32_swap_crinfo_out (bfd
*abfd
, const Elf32_crinfo
*in
,
1769 Elf32_External_crinfo
*ex
)
1773 l
= (((in
->ctype
& CRINFO_CTYPE
) << CRINFO_CTYPE_SH
)
1774 | ((in
->rtype
& CRINFO_RTYPE
) << CRINFO_RTYPE_SH
)
1775 | ((in
->dist2to
& CRINFO_DIST2TO
) << CRINFO_DIST2TO_SH
)
1776 | ((in
->relvaddr
& CRINFO_RELVADDR
) << CRINFO_RELVADDR_SH
));
1777 H_PUT_32 (abfd
, l
, ex
->info
);
1778 H_PUT_32 (abfd
, in
->konst
, ex
->konst
);
1779 H_PUT_32 (abfd
, in
->vaddr
, ex
->vaddr
);
1782 /* A .reginfo section holds a single Elf32_RegInfo structure. These
1783 routines swap this structure in and out. They are used outside of
1784 BFD, so they are globally visible. */
1787 bfd_mips_elf32_swap_reginfo_in (bfd
*abfd
, const Elf32_External_RegInfo
*ex
,
1790 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1791 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1792 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1793 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1794 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1795 in
->ri_gp_value
= H_GET_32 (abfd
, ex
->ri_gp_value
);
1799 bfd_mips_elf32_swap_reginfo_out (bfd
*abfd
, const Elf32_RegInfo
*in
,
1800 Elf32_External_RegInfo
*ex
)
1802 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1803 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1804 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1805 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1806 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1807 H_PUT_32 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1810 /* In the 64 bit ABI, the .MIPS.options section holds register
1811 information in an Elf64_Reginfo structure. These routines swap
1812 them in and out. They are globally visible because they are used
1813 outside of BFD. These routines are here so that gas can call them
1814 without worrying about whether the 64 bit ABI has been included. */
1817 bfd_mips_elf64_swap_reginfo_in (bfd
*abfd
, const Elf64_External_RegInfo
*ex
,
1818 Elf64_Internal_RegInfo
*in
)
1820 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1821 in
->ri_pad
= H_GET_32 (abfd
, ex
->ri_pad
);
1822 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1823 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1824 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1825 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1826 in
->ri_gp_value
= H_GET_64 (abfd
, ex
->ri_gp_value
);
1830 bfd_mips_elf64_swap_reginfo_out (bfd
*abfd
, const Elf64_Internal_RegInfo
*in
,
1831 Elf64_External_RegInfo
*ex
)
1833 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1834 H_PUT_32 (abfd
, in
->ri_pad
, ex
->ri_pad
);
1835 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1836 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1837 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1838 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1839 H_PUT_64 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1842 /* Swap in an options header. */
1845 bfd_mips_elf_swap_options_in (bfd
*abfd
, const Elf_External_Options
*ex
,
1846 Elf_Internal_Options
*in
)
1848 in
->kind
= H_GET_8 (abfd
, ex
->kind
);
1849 in
->size
= H_GET_8 (abfd
, ex
->size
);
1850 in
->section
= H_GET_16 (abfd
, ex
->section
);
1851 in
->info
= H_GET_32 (abfd
, ex
->info
);
1854 /* Swap out an options header. */
1857 bfd_mips_elf_swap_options_out (bfd
*abfd
, const Elf_Internal_Options
*in
,
1858 Elf_External_Options
*ex
)
1860 H_PUT_8 (abfd
, in
->kind
, ex
->kind
);
1861 H_PUT_8 (abfd
, in
->size
, ex
->size
);
1862 H_PUT_16 (abfd
, in
->section
, ex
->section
);
1863 H_PUT_32 (abfd
, in
->info
, ex
->info
);
1866 /* This function is called via qsort() to sort the dynamic relocation
1867 entries by increasing r_symndx value. */
1870 sort_dynamic_relocs (const void *arg1
, const void *arg2
)
1872 Elf_Internal_Rela int_reloc1
;
1873 Elf_Internal_Rela int_reloc2
;
1876 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg1
, &int_reloc1
);
1877 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg2
, &int_reloc2
);
1879 diff
= ELF32_R_SYM (int_reloc1
.r_info
) - ELF32_R_SYM (int_reloc2
.r_info
);
1883 if (int_reloc1
.r_offset
< int_reloc2
.r_offset
)
1885 if (int_reloc1
.r_offset
> int_reloc2
.r_offset
)
1890 /* Like sort_dynamic_relocs, but used for elf64 relocations. */
1893 sort_dynamic_relocs_64 (const void *arg1 ATTRIBUTE_UNUSED
,
1894 const void *arg2 ATTRIBUTE_UNUSED
)
1897 Elf_Internal_Rela int_reloc1
[3];
1898 Elf_Internal_Rela int_reloc2
[3];
1900 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1901 (reldyn_sorting_bfd
, arg1
, int_reloc1
);
1902 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1903 (reldyn_sorting_bfd
, arg2
, int_reloc2
);
1905 if (ELF64_R_SYM (int_reloc1
[0].r_info
) < ELF64_R_SYM (int_reloc2
[0].r_info
))
1907 if (ELF64_R_SYM (int_reloc1
[0].r_info
) > ELF64_R_SYM (int_reloc2
[0].r_info
))
1910 if (int_reloc1
[0].r_offset
< int_reloc2
[0].r_offset
)
1912 if (int_reloc1
[0].r_offset
> int_reloc2
[0].r_offset
)
1921 /* This routine is used to write out ECOFF debugging external symbol
1922 information. It is called via mips_elf_link_hash_traverse. The
1923 ECOFF external symbol information must match the ELF external
1924 symbol information. Unfortunately, at this point we don't know
1925 whether a symbol is required by reloc information, so the two
1926 tables may wind up being different. We must sort out the external
1927 symbol information before we can set the final size of the .mdebug
1928 section, and we must set the size of the .mdebug section before we
1929 can relocate any sections, and we can't know which symbols are
1930 required by relocation until we relocate the sections.
1931 Fortunately, it is relatively unlikely that any symbol will be
1932 stripped but required by a reloc. In particular, it can not happen
1933 when generating a final executable. */
1936 mips_elf_output_extsym (struct mips_elf_link_hash_entry
*h
, void *data
)
1938 struct extsym_info
*einfo
= data
;
1940 asection
*sec
, *output_section
;
1942 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1943 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1945 if (h
->root
.indx
== -2)
1947 else if ((h
->root
.def_dynamic
1948 || h
->root
.ref_dynamic
1949 || h
->root
.type
== bfd_link_hash_new
)
1950 && !h
->root
.def_regular
1951 && !h
->root
.ref_regular
)
1953 else if (einfo
->info
->strip
== strip_all
1954 || (einfo
->info
->strip
== strip_some
1955 && bfd_hash_lookup (einfo
->info
->keep_hash
,
1956 h
->root
.root
.root
.string
,
1957 FALSE
, FALSE
) == NULL
))
1965 if (h
->esym
.ifd
== -2)
1968 h
->esym
.cobol_main
= 0;
1969 h
->esym
.weakext
= 0;
1970 h
->esym
.reserved
= 0;
1971 h
->esym
.ifd
= ifdNil
;
1972 h
->esym
.asym
.value
= 0;
1973 h
->esym
.asym
.st
= stGlobal
;
1975 if (h
->root
.root
.type
== bfd_link_hash_undefined
1976 || h
->root
.root
.type
== bfd_link_hash_undefweak
)
1980 /* Use undefined class. Also, set class and type for some
1982 name
= h
->root
.root
.root
.string
;
1983 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
1984 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
1986 h
->esym
.asym
.sc
= scData
;
1987 h
->esym
.asym
.st
= stLabel
;
1988 h
->esym
.asym
.value
= 0;
1990 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
1992 h
->esym
.asym
.sc
= scAbs
;
1993 h
->esym
.asym
.st
= stLabel
;
1994 h
->esym
.asym
.value
=
1995 mips_elf_hash_table (einfo
->info
)->procedure_count
;
1997 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (einfo
->abfd
))
1999 h
->esym
.asym
.sc
= scAbs
;
2000 h
->esym
.asym
.st
= stLabel
;
2001 h
->esym
.asym
.value
= elf_gp (einfo
->abfd
);
2004 h
->esym
.asym
.sc
= scUndefined
;
2006 else if (h
->root
.root
.type
!= bfd_link_hash_defined
2007 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
2008 h
->esym
.asym
.sc
= scAbs
;
2013 sec
= h
->root
.root
.u
.def
.section
;
2014 output_section
= sec
->output_section
;
2016 /* When making a shared library and symbol h is the one from
2017 the another shared library, OUTPUT_SECTION may be null. */
2018 if (output_section
== NULL
)
2019 h
->esym
.asym
.sc
= scUndefined
;
2022 name
= bfd_section_name (output_section
->owner
, output_section
);
2024 if (strcmp (name
, ".text") == 0)
2025 h
->esym
.asym
.sc
= scText
;
2026 else if (strcmp (name
, ".data") == 0)
2027 h
->esym
.asym
.sc
= scData
;
2028 else if (strcmp (name
, ".sdata") == 0)
2029 h
->esym
.asym
.sc
= scSData
;
2030 else if (strcmp (name
, ".rodata") == 0
2031 || strcmp (name
, ".rdata") == 0)
2032 h
->esym
.asym
.sc
= scRData
;
2033 else if (strcmp (name
, ".bss") == 0)
2034 h
->esym
.asym
.sc
= scBss
;
2035 else if (strcmp (name
, ".sbss") == 0)
2036 h
->esym
.asym
.sc
= scSBss
;
2037 else if (strcmp (name
, ".init") == 0)
2038 h
->esym
.asym
.sc
= scInit
;
2039 else if (strcmp (name
, ".fini") == 0)
2040 h
->esym
.asym
.sc
= scFini
;
2042 h
->esym
.asym
.sc
= scAbs
;
2046 h
->esym
.asym
.reserved
= 0;
2047 h
->esym
.asym
.index
= indexNil
;
2050 if (h
->root
.root
.type
== bfd_link_hash_common
)
2051 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
2052 else if (h
->root
.root
.type
== bfd_link_hash_defined
2053 || h
->root
.root
.type
== bfd_link_hash_defweak
)
2055 if (h
->esym
.asym
.sc
== scCommon
)
2056 h
->esym
.asym
.sc
= scBss
;
2057 else if (h
->esym
.asym
.sc
== scSCommon
)
2058 h
->esym
.asym
.sc
= scSBss
;
2060 sec
= h
->root
.root
.u
.def
.section
;
2061 output_section
= sec
->output_section
;
2062 if (output_section
!= NULL
)
2063 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
2064 + sec
->output_offset
2065 + output_section
->vma
);
2067 h
->esym
.asym
.value
= 0;
2069 else if (h
->root
.needs_plt
)
2071 struct mips_elf_link_hash_entry
*hd
= h
;
2072 bfd_boolean no_fn_stub
= h
->no_fn_stub
;
2074 while (hd
->root
.root
.type
== bfd_link_hash_indirect
)
2076 hd
= (struct mips_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
2077 no_fn_stub
= no_fn_stub
|| hd
->no_fn_stub
;
2082 /* Set type and value for a symbol with a function stub. */
2083 h
->esym
.asym
.st
= stProc
;
2084 sec
= hd
->root
.root
.u
.def
.section
;
2086 h
->esym
.asym
.value
= 0;
2089 output_section
= sec
->output_section
;
2090 if (output_section
!= NULL
)
2091 h
->esym
.asym
.value
= (hd
->root
.plt
.offset
2092 + sec
->output_offset
2093 + output_section
->vma
);
2095 h
->esym
.asym
.value
= 0;
2100 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
2101 h
->root
.root
.root
.string
,
2104 einfo
->failed
= TRUE
;
2111 /* A comparison routine used to sort .gptab entries. */
2114 gptab_compare (const void *p1
, const void *p2
)
2116 const Elf32_gptab
*a1
= p1
;
2117 const Elf32_gptab
*a2
= p2
;
2119 return a1
->gt_entry
.gt_g_value
- a2
->gt_entry
.gt_g_value
;
2122 /* Functions to manage the got entry hash table. */
2124 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
2127 static INLINE hashval_t
2128 mips_elf_hash_bfd_vma (bfd_vma addr
)
2131 return addr
+ (addr
>> 32);
2137 /* got_entries only match if they're identical, except for gotidx, so
2138 use all fields to compute the hash, and compare the appropriate
2142 mips_elf_got_entry_hash (const void *entry_
)
2144 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
2146 return entry
->symndx
2147 + ((entry
->tls_type
& GOT_TLS_LDM
) << 17)
2148 + (! entry
->abfd
? mips_elf_hash_bfd_vma (entry
->d
.address
)
2150 + (entry
->symndx
>= 0 ? mips_elf_hash_bfd_vma (entry
->d
.addend
)
2151 : entry
->d
.h
->root
.root
.root
.hash
));
2155 mips_elf_got_entry_eq (const void *entry1
, const void *entry2
)
2157 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
2158 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
2160 /* An LDM entry can only match another LDM entry. */
2161 if ((e1
->tls_type
^ e2
->tls_type
) & GOT_TLS_LDM
)
2164 return e1
->abfd
== e2
->abfd
&& e1
->symndx
== e2
->symndx
2165 && (! e1
->abfd
? e1
->d
.address
== e2
->d
.address
2166 : e1
->symndx
>= 0 ? e1
->d
.addend
== e2
->d
.addend
2167 : e1
->d
.h
== e2
->d
.h
);
2170 /* multi_got_entries are still a match in the case of global objects,
2171 even if the input bfd in which they're referenced differs, so the
2172 hash computation and compare functions are adjusted
2176 mips_elf_multi_got_entry_hash (const void *entry_
)
2178 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
2180 return entry
->symndx
2182 ? mips_elf_hash_bfd_vma (entry
->d
.address
)
2183 : entry
->symndx
>= 0
2184 ? ((entry
->tls_type
& GOT_TLS_LDM
)
2185 ? (GOT_TLS_LDM
<< 17)
2187 + mips_elf_hash_bfd_vma (entry
->d
.addend
)))
2188 : entry
->d
.h
->root
.root
.root
.hash
);
2192 mips_elf_multi_got_entry_eq (const void *entry1
, const void *entry2
)
2194 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
2195 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
2197 /* Any two LDM entries match. */
2198 if (e1
->tls_type
& e2
->tls_type
& GOT_TLS_LDM
)
2201 /* Nothing else matches an LDM entry. */
2202 if ((e1
->tls_type
^ e2
->tls_type
) & GOT_TLS_LDM
)
2205 return e1
->symndx
== e2
->symndx
2206 && (e1
->symndx
>= 0 ? e1
->abfd
== e2
->abfd
&& e1
->d
.addend
== e2
->d
.addend
2207 : e1
->abfd
== NULL
|| e2
->abfd
== NULL
2208 ? e1
->abfd
== e2
->abfd
&& e1
->d
.address
== e2
->d
.address
2209 : e1
->d
.h
== e2
->d
.h
);
2213 mips_got_page_entry_hash (const void *entry_
)
2215 const struct mips_got_page_entry
*entry
;
2217 entry
= (const struct mips_got_page_entry
*) entry_
;
2218 return entry
->abfd
->id
+ entry
->symndx
;
2222 mips_got_page_entry_eq (const void *entry1_
, const void *entry2_
)
2224 const struct mips_got_page_entry
*entry1
, *entry2
;
2226 entry1
= (const struct mips_got_page_entry
*) entry1_
;
2227 entry2
= (const struct mips_got_page_entry
*) entry2_
;
2228 return entry1
->abfd
== entry2
->abfd
&& entry1
->symndx
== entry2
->symndx
;
2231 /* Return the dynamic relocation section. If it doesn't exist, try to
2232 create a new it if CREATE_P, otherwise return NULL. Also return NULL
2233 if creation fails. */
2236 mips_elf_rel_dyn_section (struct bfd_link_info
*info
, bfd_boolean create_p
)
2242 dname
= MIPS_ELF_REL_DYN_NAME (info
);
2243 dynobj
= elf_hash_table (info
)->dynobj
;
2244 sreloc
= bfd_get_section_by_name (dynobj
, dname
);
2245 if (sreloc
== NULL
&& create_p
)
2247 sreloc
= bfd_make_section_with_flags (dynobj
, dname
,
2252 | SEC_LINKER_CREATED
2255 || ! bfd_set_section_alignment (dynobj
, sreloc
,
2256 MIPS_ELF_LOG_FILE_ALIGN (dynobj
)))
2262 /* Returns the GOT section, if it hasn't been excluded. */
2265 mips_elf_got_section (struct bfd_link_info
*info
)
2267 struct mips_elf_link_hash_table
*htab
;
2269 htab
= mips_elf_hash_table (info
);
2270 if (htab
->sgot
== NULL
|| (htab
->sgot
->flags
& SEC_EXCLUDE
) != 0)
2275 /* Count the number of relocations needed for a TLS GOT entry, with
2276 access types from TLS_TYPE, and symbol H (or a local symbol if H
2280 mips_tls_got_relocs (struct bfd_link_info
*info
, unsigned char tls_type
,
2281 struct elf_link_hash_entry
*h
)
2285 bfd_boolean need_relocs
= FALSE
;
2286 bfd_boolean dyn
= elf_hash_table (info
)->dynamic_sections_created
;
2288 if (h
&& WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
2289 && (!info
->shared
|| !SYMBOL_REFERENCES_LOCAL (info
, h
)))
2292 if ((info
->shared
|| indx
!= 0)
2294 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2295 || h
->root
.type
!= bfd_link_hash_undefweak
))
2301 if (tls_type
& GOT_TLS_GD
)
2308 if (tls_type
& GOT_TLS_IE
)
2311 if ((tls_type
& GOT_TLS_LDM
) && info
->shared
)
2317 /* Count the number of TLS relocations required for the GOT entry in
2318 ARG1, if it describes a local symbol. */
2321 mips_elf_count_local_tls_relocs (void **arg1
, void *arg2
)
2323 struct mips_got_entry
*entry
= * (struct mips_got_entry
**) arg1
;
2324 struct mips_elf_count_tls_arg
*arg
= arg2
;
2326 if (entry
->abfd
!= NULL
&& entry
->symndx
!= -1)
2327 arg
->needed
+= mips_tls_got_relocs (arg
->info
, entry
->tls_type
, NULL
);
2332 /* Count the number of TLS GOT entries required for the global (or
2333 forced-local) symbol in ARG1. */
2336 mips_elf_count_global_tls_entries (void *arg1
, void *arg2
)
2338 struct mips_elf_link_hash_entry
*hm
2339 = (struct mips_elf_link_hash_entry
*) arg1
;
2340 struct mips_elf_count_tls_arg
*arg
= arg2
;
2342 if (hm
->tls_type
& GOT_TLS_GD
)
2344 if (hm
->tls_type
& GOT_TLS_IE
)
2350 /* Count the number of TLS relocations required for the global (or
2351 forced-local) symbol in ARG1. */
2354 mips_elf_count_global_tls_relocs (void *arg1
, void *arg2
)
2356 struct mips_elf_link_hash_entry
*hm
2357 = (struct mips_elf_link_hash_entry
*) arg1
;
2358 struct mips_elf_count_tls_arg
*arg
= arg2
;
2360 arg
->needed
+= mips_tls_got_relocs (arg
->info
, hm
->tls_type
, &hm
->root
);
2365 /* Output a simple dynamic relocation into SRELOC. */
2368 mips_elf_output_dynamic_relocation (bfd
*output_bfd
,
2374 Elf_Internal_Rela rel
[3];
2376 memset (rel
, 0, sizeof (rel
));
2378 rel
[0].r_info
= ELF_R_INFO (output_bfd
, indx
, r_type
);
2379 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
2381 if (ABI_64_P (output_bfd
))
2383 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
2384 (output_bfd
, &rel
[0],
2386 + sreloc
->reloc_count
* sizeof (Elf64_Mips_External_Rel
)));
2389 bfd_elf32_swap_reloc_out
2390 (output_bfd
, &rel
[0],
2392 + sreloc
->reloc_count
* sizeof (Elf32_External_Rel
)));
2393 ++sreloc
->reloc_count
;
2396 /* Initialize a set of TLS GOT entries for one symbol. */
2399 mips_elf_initialize_tls_slots (bfd
*abfd
, bfd_vma got_offset
,
2400 unsigned char *tls_type_p
,
2401 struct bfd_link_info
*info
,
2402 struct mips_elf_link_hash_entry
*h
,
2406 asection
*sreloc
, *sgot
;
2407 bfd_vma offset
, offset2
;
2408 bfd_boolean need_relocs
= FALSE
;
2410 sgot
= mips_elf_got_section (info
);
2415 bfd_boolean dyn
= elf_hash_table (info
)->dynamic_sections_created
;
2417 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, &h
->root
)
2418 && (!info
->shared
|| !SYMBOL_REFERENCES_LOCAL (info
, &h
->root
)))
2419 indx
= h
->root
.dynindx
;
2422 if (*tls_type_p
& GOT_TLS_DONE
)
2425 if ((info
->shared
|| indx
!= 0)
2427 || ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
2428 || h
->root
.type
!= bfd_link_hash_undefweak
))
2431 /* MINUS_ONE means the symbol is not defined in this object. It may not
2432 be defined at all; assume that the value doesn't matter in that
2433 case. Otherwise complain if we would use the value. */
2434 BFD_ASSERT (value
!= MINUS_ONE
|| (indx
!= 0 && need_relocs
)
2435 || h
->root
.root
.type
== bfd_link_hash_undefweak
);
2437 /* Emit necessary relocations. */
2438 sreloc
= mips_elf_rel_dyn_section (info
, FALSE
);
2440 /* General Dynamic. */
2441 if (*tls_type_p
& GOT_TLS_GD
)
2443 offset
= got_offset
;
2444 offset2
= offset
+ MIPS_ELF_GOT_SIZE (abfd
);
2448 mips_elf_output_dynamic_relocation
2449 (abfd
, sreloc
, indx
,
2450 ABI_64_P (abfd
) ? R_MIPS_TLS_DTPMOD64
: R_MIPS_TLS_DTPMOD32
,
2451 sgot
->output_offset
+ sgot
->output_section
->vma
+ offset
);
2454 mips_elf_output_dynamic_relocation
2455 (abfd
, sreloc
, indx
,
2456 ABI_64_P (abfd
) ? R_MIPS_TLS_DTPREL64
: R_MIPS_TLS_DTPREL32
,
2457 sgot
->output_offset
+ sgot
->output_section
->vma
+ offset2
);
2459 MIPS_ELF_PUT_WORD (abfd
, value
- dtprel_base (info
),
2460 sgot
->contents
+ offset2
);
2464 MIPS_ELF_PUT_WORD (abfd
, 1,
2465 sgot
->contents
+ offset
);
2466 MIPS_ELF_PUT_WORD (abfd
, value
- dtprel_base (info
),
2467 sgot
->contents
+ offset2
);
2470 got_offset
+= 2 * MIPS_ELF_GOT_SIZE (abfd
);
2473 /* Initial Exec model. */
2474 if (*tls_type_p
& GOT_TLS_IE
)
2476 offset
= got_offset
;
2481 MIPS_ELF_PUT_WORD (abfd
, value
- elf_hash_table (info
)->tls_sec
->vma
,
2482 sgot
->contents
+ offset
);
2484 MIPS_ELF_PUT_WORD (abfd
, 0,
2485 sgot
->contents
+ offset
);
2487 mips_elf_output_dynamic_relocation
2488 (abfd
, sreloc
, indx
,
2489 ABI_64_P (abfd
) ? R_MIPS_TLS_TPREL64
: R_MIPS_TLS_TPREL32
,
2490 sgot
->output_offset
+ sgot
->output_section
->vma
+ offset
);
2493 MIPS_ELF_PUT_WORD (abfd
, value
- tprel_base (info
),
2494 sgot
->contents
+ offset
);
2497 if (*tls_type_p
& GOT_TLS_LDM
)
2499 /* The initial offset is zero, and the LD offsets will include the
2500 bias by DTP_OFFSET. */
2501 MIPS_ELF_PUT_WORD (abfd
, 0,
2502 sgot
->contents
+ got_offset
2503 + MIPS_ELF_GOT_SIZE (abfd
));
2506 MIPS_ELF_PUT_WORD (abfd
, 1,
2507 sgot
->contents
+ got_offset
);
2509 mips_elf_output_dynamic_relocation
2510 (abfd
, sreloc
, indx
,
2511 ABI_64_P (abfd
) ? R_MIPS_TLS_DTPMOD64
: R_MIPS_TLS_DTPMOD32
,
2512 sgot
->output_offset
+ sgot
->output_section
->vma
+ got_offset
);
2515 *tls_type_p
|= GOT_TLS_DONE
;
2518 /* Return the GOT index to use for a relocation of type R_TYPE against
2519 a symbol accessed using TLS_TYPE models. The GOT entries for this
2520 symbol in this GOT start at GOT_INDEX. This function initializes the
2521 GOT entries and corresponding relocations. */
2524 mips_tls_got_index (bfd
*abfd
, bfd_vma got_index
, unsigned char *tls_type
,
2525 int r_type
, struct bfd_link_info
*info
,
2526 struct mips_elf_link_hash_entry
*h
, bfd_vma symbol
)
2528 BFD_ASSERT (r_type
== R_MIPS_TLS_GOTTPREL
|| r_type
== R_MIPS_TLS_GD
2529 || r_type
== R_MIPS_TLS_LDM
);
2531 mips_elf_initialize_tls_slots (abfd
, got_index
, tls_type
, info
, h
, symbol
);
2533 if (r_type
== R_MIPS_TLS_GOTTPREL
)
2535 BFD_ASSERT (*tls_type
& GOT_TLS_IE
);
2536 if (*tls_type
& GOT_TLS_GD
)
2537 return got_index
+ 2 * MIPS_ELF_GOT_SIZE (abfd
);
2542 if (r_type
== R_MIPS_TLS_GD
)
2544 BFD_ASSERT (*tls_type
& GOT_TLS_GD
);
2548 if (r_type
== R_MIPS_TLS_LDM
)
2550 BFD_ASSERT (*tls_type
& GOT_TLS_LDM
);
2557 /* Return the offset from _GLOBAL_OFFSET_TABLE_ of the .got.plt entry
2558 for global symbol H. .got.plt comes before the GOT, so the offset
2559 will be negative. */
2562 mips_elf_gotplt_index (struct bfd_link_info
*info
,
2563 struct elf_link_hash_entry
*h
)
2565 bfd_vma plt_index
, got_address
, got_value
;
2566 struct mips_elf_link_hash_table
*htab
;
2568 htab
= mips_elf_hash_table (info
);
2569 BFD_ASSERT (h
->plt
.offset
!= (bfd_vma
) -1);
2571 /* Calculate the index of the symbol's PLT entry. */
2572 plt_index
= (h
->plt
.offset
- htab
->plt_header_size
) / htab
->plt_entry_size
;
2574 /* Calculate the address of the associated .got.plt entry. */
2575 got_address
= (htab
->sgotplt
->output_section
->vma
2576 + htab
->sgotplt
->output_offset
2579 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */
2580 got_value
= (htab
->root
.hgot
->root
.u
.def
.section
->output_section
->vma
2581 + htab
->root
.hgot
->root
.u
.def
.section
->output_offset
2582 + htab
->root
.hgot
->root
.u
.def
.value
);
2584 return got_address
- got_value
;
2587 /* Return the GOT offset for address VALUE. If there is not yet a GOT
2588 entry for this value, create one. If R_SYMNDX refers to a TLS symbol,
2589 create a TLS GOT entry instead. Return -1 if no satisfactory GOT
2590 offset can be found. */
2593 mips_elf_local_got_index (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
2594 bfd_vma value
, unsigned long r_symndx
,
2595 struct mips_elf_link_hash_entry
*h
, int r_type
)
2597 struct mips_elf_link_hash_table
*htab
;
2598 struct mips_got_entry
*entry
;
2600 htab
= mips_elf_hash_table (info
);
2601 entry
= mips_elf_create_local_got_entry (abfd
, info
, ibfd
, value
,
2602 r_symndx
, h
, r_type
);
2606 if (TLS_RELOC_P (r_type
))
2608 if (entry
->symndx
== -1 && htab
->got_info
->next
== NULL
)
2609 /* A type (3) entry in the single-GOT case. We use the symbol's
2610 hash table entry to track the index. */
2611 return mips_tls_got_index (abfd
, h
->tls_got_offset
, &h
->tls_type
,
2612 r_type
, info
, h
, value
);
2614 return mips_tls_got_index (abfd
, entry
->gotidx
, &entry
->tls_type
,
2615 r_type
, info
, h
, value
);
2618 return entry
->gotidx
;
2621 /* Returns the GOT index for the global symbol indicated by H. */
2624 mips_elf_global_got_index (bfd
*abfd
, bfd
*ibfd
, struct elf_link_hash_entry
*h
,
2625 int r_type
, struct bfd_link_info
*info
)
2627 struct mips_elf_link_hash_table
*htab
;
2629 struct mips_got_info
*g
, *gg
;
2630 long global_got_dynindx
= 0;
2632 htab
= mips_elf_hash_table (info
);
2633 gg
= g
= htab
->got_info
;
2634 if (g
->bfd2got
&& ibfd
)
2636 struct mips_got_entry e
, *p
;
2638 BFD_ASSERT (h
->dynindx
>= 0);
2640 g
= mips_elf_got_for_ibfd (g
, ibfd
);
2641 if (g
->next
!= gg
|| TLS_RELOC_P (r_type
))
2645 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
2648 p
= htab_find (g
->got_entries
, &e
);
2650 BFD_ASSERT (p
->gotidx
> 0);
2652 if (TLS_RELOC_P (r_type
))
2654 bfd_vma value
= MINUS_ONE
;
2655 if ((h
->root
.type
== bfd_link_hash_defined
2656 || h
->root
.type
== bfd_link_hash_defweak
)
2657 && h
->root
.u
.def
.section
->output_section
)
2658 value
= (h
->root
.u
.def
.value
2659 + h
->root
.u
.def
.section
->output_offset
2660 + h
->root
.u
.def
.section
->output_section
->vma
);
2662 return mips_tls_got_index (abfd
, p
->gotidx
, &p
->tls_type
, r_type
,
2663 info
, e
.d
.h
, value
);
2670 if (gg
->global_gotsym
!= NULL
)
2671 global_got_dynindx
= gg
->global_gotsym
->dynindx
;
2673 if (TLS_RELOC_P (r_type
))
2675 struct mips_elf_link_hash_entry
*hm
2676 = (struct mips_elf_link_hash_entry
*) h
;
2677 bfd_vma value
= MINUS_ONE
;
2679 if ((h
->root
.type
== bfd_link_hash_defined
2680 || h
->root
.type
== bfd_link_hash_defweak
)
2681 && h
->root
.u
.def
.section
->output_section
)
2682 value
= (h
->root
.u
.def
.value
2683 + h
->root
.u
.def
.section
->output_offset
2684 + h
->root
.u
.def
.section
->output_section
->vma
);
2686 index
= mips_tls_got_index (abfd
, hm
->tls_got_offset
, &hm
->tls_type
,
2687 r_type
, info
, hm
, value
);
2691 /* Once we determine the global GOT entry with the lowest dynamic
2692 symbol table index, we must put all dynamic symbols with greater
2693 indices into the GOT. That makes it easy to calculate the GOT
2695 BFD_ASSERT (h
->dynindx
>= global_got_dynindx
);
2696 index
= ((h
->dynindx
- global_got_dynindx
+ g
->local_gotno
)
2697 * MIPS_ELF_GOT_SIZE (abfd
));
2699 BFD_ASSERT (index
< htab
->sgot
->size
);
2704 /* Find a GOT page entry that points to within 32KB of VALUE. These
2705 entries are supposed to be placed at small offsets in the GOT, i.e.,
2706 within 32KB of GP. Return the index of the GOT entry, or -1 if no
2707 entry could be created. If OFFSETP is nonnull, use it to return the
2708 offset of the GOT entry from VALUE. */
2711 mips_elf_got_page (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
2712 bfd_vma value
, bfd_vma
*offsetp
)
2714 bfd_vma page
, index
;
2715 struct mips_got_entry
*entry
;
2717 page
= (value
+ 0x8000) & ~(bfd_vma
) 0xffff;
2718 entry
= mips_elf_create_local_got_entry (abfd
, info
, ibfd
, page
, 0,
2719 NULL
, R_MIPS_GOT_PAGE
);
2724 index
= entry
->gotidx
;
2727 *offsetp
= value
- entry
->d
.address
;
2732 /* Find a local GOT entry for an R_MIPS*_GOT16 relocation against VALUE.
2733 EXTERNAL is true if the relocation was against a global symbol
2734 that has been forced local. */
2737 mips_elf_got16_entry (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
2738 bfd_vma value
, bfd_boolean external
)
2740 struct mips_got_entry
*entry
;
2742 /* GOT16 relocations against local symbols are followed by a LO16
2743 relocation; those against global symbols are not. Thus if the
2744 symbol was originally local, the GOT16 relocation should load the
2745 equivalent of %hi(VALUE), otherwise it should load VALUE itself. */
2747 value
= mips_elf_high (value
) << 16;
2749 /* It doesn't matter whether the original relocation was R_MIPS_GOT16,
2750 R_MIPS16_GOT16, R_MIPS_CALL16, etc. The format of the entry is the
2751 same in all cases. */
2752 entry
= mips_elf_create_local_got_entry (abfd
, info
, ibfd
, value
, 0,
2753 NULL
, R_MIPS_GOT16
);
2755 return entry
->gotidx
;
2760 /* Returns the offset for the entry at the INDEXth position
2764 mips_elf_got_offset_from_index (struct bfd_link_info
*info
, bfd
*output_bfd
,
2765 bfd
*input_bfd
, bfd_vma index
)
2767 struct mips_elf_link_hash_table
*htab
;
2771 htab
= mips_elf_hash_table (info
);
2773 gp
= _bfd_get_gp_value (output_bfd
)
2774 + mips_elf_adjust_gp (output_bfd
, htab
->got_info
, input_bfd
);
2776 return sgot
->output_section
->vma
+ sgot
->output_offset
+ index
- gp
;
2779 /* Create and return a local GOT entry for VALUE, which was calculated
2780 from a symbol belonging to INPUT_SECTON. Return NULL if it could not
2781 be created. If R_SYMNDX refers to a TLS symbol, create a TLS entry
2784 static struct mips_got_entry
*
2785 mips_elf_create_local_got_entry (bfd
*abfd
, struct bfd_link_info
*info
,
2786 bfd
*ibfd
, bfd_vma value
,
2787 unsigned long r_symndx
,
2788 struct mips_elf_link_hash_entry
*h
,
2791 struct mips_got_entry entry
, **loc
;
2792 struct mips_got_info
*g
;
2793 struct mips_elf_link_hash_table
*htab
;
2795 htab
= mips_elf_hash_table (info
);
2799 entry
.d
.address
= value
;
2802 g
= mips_elf_got_for_ibfd (htab
->got_info
, ibfd
);
2805 g
= mips_elf_got_for_ibfd (htab
->got_info
, abfd
);
2806 BFD_ASSERT (g
!= NULL
);
2809 /* We might have a symbol, H, if it has been forced local. Use the
2810 global entry then. It doesn't matter whether an entry is local
2811 or global for TLS, since the dynamic linker does not
2812 automatically relocate TLS GOT entries. */
2813 BFD_ASSERT (h
== NULL
|| h
->root
.forced_local
);
2814 if (TLS_RELOC_P (r_type
))
2816 struct mips_got_entry
*p
;
2819 if (r_type
== R_MIPS_TLS_LDM
)
2821 entry
.tls_type
= GOT_TLS_LDM
;
2827 entry
.symndx
= r_symndx
;
2833 p
= (struct mips_got_entry
*)
2834 htab_find (g
->got_entries
, &entry
);
2840 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
2845 entry
.gotidx
= MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
++;
2848 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2853 memcpy (*loc
, &entry
, sizeof entry
);
2855 if (g
->assigned_gotno
> g
->local_gotno
)
2857 (*loc
)->gotidx
= -1;
2858 /* We didn't allocate enough space in the GOT. */
2859 (*_bfd_error_handler
)
2860 (_("not enough GOT space for local GOT entries"));
2861 bfd_set_error (bfd_error_bad_value
);
2865 MIPS_ELF_PUT_WORD (abfd
, value
,
2866 (htab
->sgot
->contents
+ entry
.gotidx
));
2868 /* These GOT entries need a dynamic relocation on VxWorks. */
2869 if (htab
->is_vxworks
)
2871 Elf_Internal_Rela outrel
;
2874 bfd_vma got_address
;
2876 s
= mips_elf_rel_dyn_section (info
, FALSE
);
2877 got_address
= (htab
->sgot
->output_section
->vma
2878 + htab
->sgot
->output_offset
2881 loc
= s
->contents
+ (s
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2882 outrel
.r_offset
= got_address
;
2883 outrel
.r_info
= ELF32_R_INFO (STN_UNDEF
, R_MIPS_32
);
2884 outrel
.r_addend
= value
;
2885 bfd_elf32_swap_reloca_out (abfd
, &outrel
, loc
);
2891 /* Sort the dynamic symbol table so that symbols that need GOT entries
2892 appear towards the end. This reduces the amount of GOT space
2893 required. MAX_LOCAL is used to set the number of local symbols
2894 known to be in the dynamic symbol table. During
2895 _bfd_mips_elf_size_dynamic_sections, this value is 1. Afterward, the
2896 section symbols are added and the count is higher. */
2899 mips_elf_sort_hash_table (struct bfd_link_info
*info
, unsigned long max_local
)
2901 struct mips_elf_link_hash_table
*htab
;
2902 struct mips_elf_hash_sort_data hsd
;
2903 struct mips_got_info
*g
;
2905 htab
= mips_elf_hash_table (info
);
2909 hsd
.max_unref_got_dynindx
=
2910 hsd
.min_got_dynindx
= elf_hash_table (info
)->dynsymcount
2911 /* In the multi-got case, assigned_gotno of the master got_info
2912 indicate the number of entries that aren't referenced in the
2913 primary GOT, but that must have entries because there are
2914 dynamic relocations that reference it. Since they aren't
2915 referenced, we move them to the end of the GOT, so that they
2916 don't prevent other entries that are referenced from getting
2917 too large offsets. */
2918 - (g
->next
? g
->assigned_gotno
: 0);
2919 hsd
.max_non_got_dynindx
= max_local
;
2920 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table
*)
2921 elf_hash_table (info
)),
2922 mips_elf_sort_hash_table_f
,
2925 /* There should have been enough room in the symbol table to
2926 accommodate both the GOT and non-GOT symbols. */
2927 BFD_ASSERT (hsd
.max_non_got_dynindx
<= hsd
.min_got_dynindx
);
2928 BFD_ASSERT ((unsigned long)hsd
.max_unref_got_dynindx
2929 <= elf_hash_table (info
)->dynsymcount
);
2931 /* Now we know which dynamic symbol has the lowest dynamic symbol
2932 table index in the GOT. */
2933 g
->global_gotsym
= hsd
.low
;
2938 /* If H needs a GOT entry, assign it the highest available dynamic
2939 index. Otherwise, assign it the lowest available dynamic
2943 mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry
*h
, void *data
)
2945 struct mips_elf_hash_sort_data
*hsd
= data
;
2947 if (h
->root
.root
.type
== bfd_link_hash_warning
)
2948 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2950 /* Symbols without dynamic symbol table entries aren't interesting
2952 if (h
->root
.dynindx
== -1)
2955 /* Global symbols that need GOT entries that are not explicitly
2956 referenced are marked with got offset 2. Those that are
2957 referenced get a 1, and those that don't need GOT entries get
2958 -1. Forced local symbols may also be marked with got offset 1,
2959 but are never given global GOT entries. */
2960 if (h
->root
.got
.offset
== 2)
2962 BFD_ASSERT (h
->tls_type
== GOT_NORMAL
);
2964 if (hsd
->max_unref_got_dynindx
== hsd
->min_got_dynindx
)
2965 hsd
->low
= (struct elf_link_hash_entry
*) h
;
2966 h
->root
.dynindx
= hsd
->max_unref_got_dynindx
++;
2968 else if (h
->root
.got
.offset
!= 1 || h
->forced_local
)
2969 h
->root
.dynindx
= hsd
->max_non_got_dynindx
++;
2972 BFD_ASSERT (h
->tls_type
== GOT_NORMAL
);
2974 h
->root
.dynindx
= --hsd
->min_got_dynindx
;
2975 hsd
->low
= (struct elf_link_hash_entry
*) h
;
2981 /* If H is a symbol that needs a global GOT entry, but has a dynamic
2982 symbol table index lower than any we've seen to date, record it for
2986 mips_elf_record_global_got_symbol (struct elf_link_hash_entry
*h
,
2987 bfd
*abfd
, struct bfd_link_info
*info
,
2988 unsigned char tls_flag
)
2990 struct mips_elf_link_hash_table
*htab
;
2991 struct mips_got_entry entry
, **loc
;
2992 struct mips_got_info
*g
;
2994 htab
= mips_elf_hash_table (info
);
2996 /* A global symbol in the GOT must also be in the dynamic symbol
2998 if (h
->dynindx
== -1)
3000 switch (ELF_ST_VISIBILITY (h
->other
))
3004 _bfd_mips_elf_hide_symbol (info
, h
, TRUE
);
3007 if (!bfd_elf_link_record_dynamic_symbol (info
, h
))
3011 /* Make sure we have a GOT to put this entry into. */
3013 BFD_ASSERT (g
!= NULL
);
3017 entry
.d
.h
= (struct mips_elf_link_hash_entry
*) h
;
3020 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
3023 /* If we've already marked this entry as needing GOT space, we don't
3024 need to do it again. */
3027 (*loc
)->tls_type
|= tls_flag
;
3031 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
3037 entry
.tls_type
= tls_flag
;
3039 memcpy (*loc
, &entry
, sizeof entry
);
3041 if (h
->got
.offset
!= MINUS_ONE
)
3046 /* By setting this to a value other than -1, we are indicating that
3047 there needs to be a GOT entry for H. Avoid using zero, as the
3048 generic ELF copy_indirect_symbol tests for <= 0. */
3050 if (h
->forced_local
)
3057 /* Reserve space in G for a GOT entry containing the value of symbol
3058 SYMNDX in input bfd ABDF, plus ADDEND. */
3061 mips_elf_record_local_got_symbol (bfd
*abfd
, long symndx
, bfd_vma addend
,
3062 struct bfd_link_info
*info
,
3063 unsigned char tls_flag
)
3065 struct mips_elf_link_hash_table
*htab
;
3066 struct mips_got_info
*g
;
3067 struct mips_got_entry entry
, **loc
;
3069 htab
= mips_elf_hash_table (info
);
3071 BFD_ASSERT (g
!= NULL
);
3074 entry
.symndx
= symndx
;
3075 entry
.d
.addend
= addend
;
3076 entry
.tls_type
= tls_flag
;
3077 loc
= (struct mips_got_entry
**)
3078 htab_find_slot (g
->got_entries
, &entry
, INSERT
);
3082 if (tls_flag
== GOT_TLS_GD
&& !((*loc
)->tls_type
& GOT_TLS_GD
))
3085 (*loc
)->tls_type
|= tls_flag
;
3087 else if (tls_flag
== GOT_TLS_IE
&& !((*loc
)->tls_type
& GOT_TLS_IE
))
3090 (*loc
)->tls_type
|= tls_flag
;
3098 entry
.tls_type
= tls_flag
;
3099 if (tls_flag
== GOT_TLS_IE
)
3101 else if (tls_flag
== GOT_TLS_GD
)
3103 else if (g
->tls_ldm_offset
== MINUS_ONE
)
3105 g
->tls_ldm_offset
= MINUS_TWO
;
3111 entry
.gotidx
= g
->local_gotno
++;
3115 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
3120 memcpy (*loc
, &entry
, sizeof entry
);
3125 /* Return the maximum number of GOT page entries required for RANGE. */
3128 mips_elf_pages_for_range (const struct mips_got_page_range
*range
)
3130 return (range
->max_addend
- range
->min_addend
+ 0x1ffff) >> 16;
3133 /* Record that ABFD has a page relocation against symbol SYMNDX and
3134 that ADDEND is the addend for that relocation.
3136 This function creates an upper bound on the number of GOT slots
3137 required; no attempt is made to combine references to non-overridable
3138 global symbols across multiple input files. */
3141 mips_elf_record_got_page_entry (struct bfd_link_info
*info
, bfd
*abfd
,
3142 long symndx
, bfd_signed_vma addend
)
3144 struct mips_elf_link_hash_table
*htab
;
3145 struct mips_got_info
*g
;
3146 struct mips_got_page_entry lookup
, *entry
;
3147 struct mips_got_page_range
**range_ptr
, *range
;
3148 bfd_vma old_pages
, new_pages
;
3151 htab
= mips_elf_hash_table (info
);
3153 BFD_ASSERT (g
!= NULL
);
3155 /* Find the mips_got_page_entry hash table entry for this symbol. */
3157 lookup
.symndx
= symndx
;
3158 loc
= htab_find_slot (g
->got_page_entries
, &lookup
, INSERT
);
3162 /* Create a mips_got_page_entry if this is the first time we've
3164 entry
= (struct mips_got_page_entry
*) *loc
;
3167 entry
= bfd_alloc (abfd
, sizeof (*entry
));
3172 entry
->symndx
= symndx
;
3173 entry
->ranges
= NULL
;
3174 entry
->num_pages
= 0;
3178 /* Skip over ranges whose maximum extent cannot share a page entry
3180 range_ptr
= &entry
->ranges
;
3181 while (*range_ptr
&& addend
> (*range_ptr
)->max_addend
+ 0xffff)
3182 range_ptr
= &(*range_ptr
)->next
;
3184 /* If we scanned to the end of the list, or found a range whose
3185 minimum extent cannot share a page entry with ADDEND, create
3186 a new singleton range. */
3188 if (!range
|| addend
< range
->min_addend
- 0xffff)
3190 range
= bfd_alloc (abfd
, sizeof (*range
));
3194 range
->next
= *range_ptr
;
3195 range
->min_addend
= addend
;
3196 range
->max_addend
= addend
;
3204 /* Remember how many pages the old range contributed. */
3205 old_pages
= mips_elf_pages_for_range (range
);
3207 /* Update the ranges. */
3208 if (addend
< range
->min_addend
)
3209 range
->min_addend
= addend
;
3210 else if (addend
> range
->max_addend
)
3212 if (range
->next
&& addend
>= range
->next
->min_addend
- 0xffff)
3214 old_pages
+= mips_elf_pages_for_range (range
->next
);
3215 range
->max_addend
= range
->next
->max_addend
;
3216 range
->next
= range
->next
->next
;
3219 range
->max_addend
= addend
;
3222 /* Record any change in the total estimate. */
3223 new_pages
= mips_elf_pages_for_range (range
);
3224 if (old_pages
!= new_pages
)
3226 entry
->num_pages
+= new_pages
- old_pages
;
3227 g
->page_gotno
+= new_pages
- old_pages
;
3233 /* Compute the hash value of the bfd in a bfd2got hash entry. */
3236 mips_elf_bfd2got_entry_hash (const void *entry_
)
3238 const struct mips_elf_bfd2got_hash
*entry
3239 = (struct mips_elf_bfd2got_hash
*)entry_
;
3241 return entry
->bfd
->id
;
3244 /* Check whether two hash entries have the same bfd. */
3247 mips_elf_bfd2got_entry_eq (const void *entry1
, const void *entry2
)
3249 const struct mips_elf_bfd2got_hash
*e1
3250 = (const struct mips_elf_bfd2got_hash
*)entry1
;
3251 const struct mips_elf_bfd2got_hash
*e2
3252 = (const struct mips_elf_bfd2got_hash
*)entry2
;
3254 return e1
->bfd
== e2
->bfd
;
3257 /* In a multi-got link, determine the GOT to be used for IBFD. G must
3258 be the master GOT data. */
3260 static struct mips_got_info
*
3261 mips_elf_got_for_ibfd (struct mips_got_info
*g
, bfd
*ibfd
)
3263 struct mips_elf_bfd2got_hash e
, *p
;
3269 p
= htab_find (g
->bfd2got
, &e
);
3270 return p
? p
->g
: NULL
;
3273 /* Use BFD2GOT to find ABFD's got entry, creating one if none exists.
3274 Return NULL if an error occured. */
3276 static struct mips_got_info
*
3277 mips_elf_get_got_for_bfd (struct htab
*bfd2got
, bfd
*output_bfd
,
3280 struct mips_elf_bfd2got_hash bfdgot_entry
, *bfdgot
;
3281 struct mips_got_info
*g
;
3284 bfdgot_entry
.bfd
= input_bfd
;
3285 bfdgotp
= htab_find_slot (bfd2got
, &bfdgot_entry
, INSERT
);
3286 bfdgot
= (struct mips_elf_bfd2got_hash
*) *bfdgotp
;
3290 bfdgot
= ((struct mips_elf_bfd2got_hash
*)
3291 bfd_alloc (output_bfd
, sizeof (struct mips_elf_bfd2got_hash
)));
3297 g
= ((struct mips_got_info
*)
3298 bfd_alloc (output_bfd
, sizeof (struct mips_got_info
)));
3302 bfdgot
->bfd
= input_bfd
;
3305 g
->global_gotsym
= NULL
;
3306 g
->global_gotno
= 0;
3309 g
->assigned_gotno
= -1;
3311 g
->tls_assigned_gotno
= 0;
3312 g
->tls_ldm_offset
= MINUS_ONE
;
3313 g
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
3314 mips_elf_multi_got_entry_eq
, NULL
);
3315 if (g
->got_entries
== NULL
)
3318 g
->got_page_entries
= htab_try_create (1, mips_got_page_entry_hash
,
3319 mips_got_page_entry_eq
, NULL
);
3320 if (g
->got_page_entries
== NULL
)
3330 /* A htab_traverse callback for the entries in the master got.
3331 Create one separate got for each bfd that has entries in the global
3332 got, such that we can tell how many local and global entries each
3336 mips_elf_make_got_per_bfd (void **entryp
, void *p
)
3338 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
3339 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
3340 struct mips_got_info
*g
;
3342 g
= mips_elf_get_got_for_bfd (arg
->bfd2got
, arg
->obfd
, entry
->abfd
);
3349 /* Insert the GOT entry in the bfd's got entry hash table. */
3350 entryp
= htab_find_slot (g
->got_entries
, entry
, INSERT
);
3351 if (*entryp
!= NULL
)
3356 if (entry
->tls_type
)
3358 if (entry
->tls_type
& (GOT_TLS_GD
| GOT_TLS_LDM
))
3360 if (entry
->tls_type
& GOT_TLS_IE
)
3363 else if (entry
->symndx
>= 0 || entry
->d
.h
->forced_local
)
3371 /* A htab_traverse callback for the page entries in the master got.
3372 Associate each page entry with the bfd's got. */
3375 mips_elf_make_got_pages_per_bfd (void **entryp
, void *p
)
3377 struct mips_got_page_entry
*entry
= (struct mips_got_page_entry
*) *entryp
;
3378 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*) p
;
3379 struct mips_got_info
*g
;
3381 g
= mips_elf_get_got_for_bfd (arg
->bfd2got
, arg
->obfd
, entry
->abfd
);
3388 /* Insert the GOT entry in the bfd's got entry hash table. */
3389 entryp
= htab_find_slot (g
->got_page_entries
, entry
, INSERT
);
3390 if (*entryp
!= NULL
)
3394 g
->page_gotno
+= entry
->num_pages
;
3398 /* Consider merging the got described by BFD2GOT with TO, using the
3399 information given by ARG. Return -1 if this would lead to overflow,
3400 1 if they were merged successfully, and 0 if a merge failed due to
3401 lack of memory. (These values are chosen so that nonnegative return
3402 values can be returned by a htab_traverse callback.) */
3405 mips_elf_merge_got_with (struct mips_elf_bfd2got_hash
*bfd2got
,
3406 struct mips_got_info
*to
,
3407 struct mips_elf_got_per_bfd_arg
*arg
)
3409 struct mips_got_info
*from
= bfd2got
->g
;
3410 unsigned int estimate
;
3412 /* Work out how many page entries we would need for the combined GOT. */
3413 estimate
= arg
->max_pages
;
3414 if (estimate
>= from
->page_gotno
+ to
->page_gotno
)
3415 estimate
= from
->page_gotno
+ to
->page_gotno
;
3417 /* And conservatively estimate how many local, global and TLS entries
3419 estimate
+= (from
->local_gotno
3420 + from
->global_gotno
3426 /* Bail out if the combined GOT might be too big. */
3427 if (estimate
> arg
->max_count
)
3430 /* Commit to the merge. Record that TO is now the bfd for this got. */
3433 /* Transfer the bfd's got information from FROM to TO. */
3434 htab_traverse (from
->got_entries
, mips_elf_make_got_per_bfd
, arg
);
3435 if (arg
->obfd
== NULL
)
3438 htab_traverse (from
->got_page_entries
, mips_elf_make_got_pages_per_bfd
, arg
);
3439 if (arg
->obfd
== NULL
)
3442 /* We don't have to worry about releasing memory of the actual
3443 got entries, since they're all in the master got_entries hash
3445 htab_delete (from
->got_entries
);
3446 htab_delete (from
->got_page_entries
);
3450 /* Attempt to merge gots of different input bfds. Try to use as much
3451 as possible of the primary got, since it doesn't require explicit
3452 dynamic relocations, but don't use bfds that would reference global
3453 symbols out of the addressable range. Failing the primary got,
3454 attempt to merge with the current got, or finish the current got
3455 and then make make the new got current. */
3458 mips_elf_merge_gots (void **bfd2got_
, void *p
)
3460 struct mips_elf_bfd2got_hash
*bfd2got
3461 = (struct mips_elf_bfd2got_hash
*)*bfd2got_
;
3462 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
3463 struct mips_got_info
*g
;
3464 unsigned int estimate
;
3469 /* Work out the number of page, local and TLS entries. */
3470 estimate
= arg
->max_pages
;
3471 if (estimate
> g
->page_gotno
)
3472 estimate
= g
->page_gotno
;
3473 estimate
+= g
->local_gotno
+ g
->tls_gotno
;
3475 /* We place TLS GOT entries after both locals and globals. The globals
3476 for the primary GOT may overflow the normal GOT size limit, so be
3477 sure not to merge a GOT which requires TLS with the primary GOT in that
3478 case. This doesn't affect non-primary GOTs. */
3479 estimate
+= (g
->tls_gotno
> 0 ? arg
->global_count
: g
->global_gotno
);
3481 if (estimate
<= arg
->max_count
)
3483 /* If we don't have a primary GOT, use it as
3484 a starting point for the primary GOT. */
3487 arg
->primary
= bfd2got
->g
;
3491 /* Try merging with the primary GOT. */
3492 result
= mips_elf_merge_got_with (bfd2got
, arg
->primary
, arg
);
3497 /* If we can merge with the last-created got, do it. */
3500 result
= mips_elf_merge_got_with (bfd2got
, arg
->current
, arg
);
3505 /* Well, we couldn't merge, so create a new GOT. Don't check if it
3506 fits; if it turns out that it doesn't, we'll get relocation
3507 overflows anyway. */
3508 g
->next
= arg
->current
;
3514 /* Set the TLS GOT index for the GOT entry in ENTRYP. ENTRYP's NEXT field
3515 is null iff there is just a single GOT. */
3518 mips_elf_initialize_tls_index (void **entryp
, void *p
)
3520 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
3521 struct mips_got_info
*g
= p
;
3523 unsigned char tls_type
;
3525 /* We're only interested in TLS symbols. */
3526 if (entry
->tls_type
== 0)
3529 next_index
= MIPS_ELF_GOT_SIZE (entry
->abfd
) * (long) g
->tls_assigned_gotno
;
3531 if (entry
->symndx
== -1 && g
->next
== NULL
)
3533 /* A type (3) got entry in the single-GOT case. We use the symbol's
3534 hash table entry to track its index. */
3535 if (entry
->d
.h
->tls_type
& GOT_TLS_OFFSET_DONE
)
3537 entry
->d
.h
->tls_type
|= GOT_TLS_OFFSET_DONE
;
3538 entry
->d
.h
->tls_got_offset
= next_index
;
3539 tls_type
= entry
->d
.h
->tls_type
;
3543 if (entry
->tls_type
& GOT_TLS_LDM
)
3545 /* There are separate mips_got_entry objects for each input bfd
3546 that requires an LDM entry. Make sure that all LDM entries in
3547 a GOT resolve to the same index. */
3548 if (g
->tls_ldm_offset
!= MINUS_TWO
&& g
->tls_ldm_offset
!= MINUS_ONE
)
3550 entry
->gotidx
= g
->tls_ldm_offset
;
3553 g
->tls_ldm_offset
= next_index
;
3555 entry
->gotidx
= next_index
;
3556 tls_type
= entry
->tls_type
;
3559 /* Account for the entries we've just allocated. */
3560 if (tls_type
& (GOT_TLS_GD
| GOT_TLS_LDM
))
3561 g
->tls_assigned_gotno
+= 2;
3562 if (tls_type
& GOT_TLS_IE
)
3563 g
->tls_assigned_gotno
+= 1;
3568 /* If passed a NULL mips_got_info in the argument, set the marker used
3569 to tell whether a global symbol needs a got entry (in the primary
3570 got) to the given VALUE.
3572 If passed a pointer G to a mips_got_info in the argument (it must
3573 not be the primary GOT), compute the offset from the beginning of
3574 the (primary) GOT section to the entry in G corresponding to the
3575 global symbol. G's assigned_gotno must contain the index of the
3576 first available global GOT entry in G. VALUE must contain the size
3577 of a GOT entry in bytes. For each global GOT entry that requires a
3578 dynamic relocation, NEEDED_RELOCS is incremented, and the symbol is
3579 marked as not eligible for lazy resolution through a function
3582 mips_elf_set_global_got_offset (void **entryp
, void *p
)
3584 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
3585 struct mips_elf_set_global_got_offset_arg
*arg
3586 = (struct mips_elf_set_global_got_offset_arg
*)p
;
3587 struct mips_got_info
*g
= arg
->g
;
3589 if (g
&& entry
->tls_type
!= GOT_NORMAL
)
3590 arg
->needed_relocs
+=
3591 mips_tls_got_relocs (arg
->info
, entry
->tls_type
,
3592 entry
->symndx
== -1 ? &entry
->d
.h
->root
: NULL
);
3594 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1
3595 && entry
->d
.h
->root
.dynindx
!= -1
3596 && !entry
->d
.h
->forced_local
3597 && entry
->d
.h
->tls_type
== GOT_NORMAL
)
3601 BFD_ASSERT (g
->global_gotsym
== NULL
);
3603 entry
->gotidx
= arg
->value
* (long) g
->assigned_gotno
++;
3604 if (arg
->info
->shared
3605 || (elf_hash_table (arg
->info
)->dynamic_sections_created
3606 && entry
->d
.h
->root
.def_dynamic
3607 && !entry
->d
.h
->root
.def_regular
))
3608 ++arg
->needed_relocs
;
3611 entry
->d
.h
->root
.got
.offset
= arg
->value
;
3617 /* Mark any global symbols referenced in the GOT we are iterating over
3618 as inelligible for lazy resolution stubs. */
3620 mips_elf_set_no_stub (void **entryp
, void *p ATTRIBUTE_UNUSED
)
3622 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
3624 if (entry
->abfd
!= NULL
3625 && entry
->symndx
== -1
3626 && entry
->d
.h
->root
.dynindx
!= -1)
3627 entry
->d
.h
->no_fn_stub
= TRUE
;
3632 /* Follow indirect and warning hash entries so that each got entry
3633 points to the final symbol definition. P must point to a pointer
3634 to the hash table we're traversing. Since this traversal may
3635 modify the hash table, we set this pointer to NULL to indicate
3636 we've made a potentially-destructive change to the hash table, so
3637 the traversal must be restarted. */
3639 mips_elf_resolve_final_got_entry (void **entryp
, void *p
)
3641 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
3642 htab_t got_entries
= *(htab_t
*)p
;
3644 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1)
3646 struct mips_elf_link_hash_entry
*h
= entry
->d
.h
;
3648 while (h
->root
.root
.type
== bfd_link_hash_indirect
3649 || h
->root
.root
.type
== bfd_link_hash_warning
)
3650 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3652 if (entry
->d
.h
== h
)
3657 /* If we can't find this entry with the new bfd hash, re-insert
3658 it, and get the traversal restarted. */
3659 if (! htab_find (got_entries
, entry
))
3661 htab_clear_slot (got_entries
, entryp
);
3662 entryp
= htab_find_slot (got_entries
, entry
, INSERT
);
3665 /* Abort the traversal, since the whole table may have
3666 moved, and leave it up to the parent to restart the
3668 *(htab_t
*)p
= NULL
;
3671 /* We might want to decrement the global_gotno count, but it's
3672 either too early or too late for that at this point. */
3678 /* Turn indirect got entries in a got_entries table into their final
3681 mips_elf_resolve_final_got_entries (struct mips_got_info
*g
)
3687 got_entries
= g
->got_entries
;
3689 htab_traverse (got_entries
,
3690 mips_elf_resolve_final_got_entry
,
3693 while (got_entries
== NULL
);
3696 /* Return the offset of an input bfd IBFD's GOT from the beginning of
3699 mips_elf_adjust_gp (bfd
*abfd
, struct mips_got_info
*g
, bfd
*ibfd
)
3701 if (g
->bfd2got
== NULL
)
3704 g
= mips_elf_got_for_ibfd (g
, ibfd
);
3708 BFD_ASSERT (g
->next
);
3712 return (g
->local_gotno
+ g
->global_gotno
+ g
->tls_gotno
)
3713 * MIPS_ELF_GOT_SIZE (abfd
);
3716 /* Turn a single GOT that is too big for 16-bit addressing into
3717 a sequence of GOTs, each one 16-bit addressable. */
3720 mips_elf_multi_got (bfd
*abfd
, struct bfd_link_info
*info
,
3721 asection
*got
, bfd_size_type pages
)
3723 struct mips_elf_link_hash_table
*htab
;
3724 struct mips_elf_got_per_bfd_arg got_per_bfd_arg
;
3725 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
3726 struct mips_got_info
*g
, *gg
;
3727 unsigned int assign
;
3729 htab
= mips_elf_hash_table (info
);
3731 g
->bfd2got
= htab_try_create (1, mips_elf_bfd2got_entry_hash
,
3732 mips_elf_bfd2got_entry_eq
, NULL
);
3733 if (g
->bfd2got
== NULL
)
3736 got_per_bfd_arg
.bfd2got
= g
->bfd2got
;
3737 got_per_bfd_arg
.obfd
= abfd
;
3738 got_per_bfd_arg
.info
= info
;
3740 /* Count how many GOT entries each input bfd requires, creating a
3741 map from bfd to got info while at that. */
3742 htab_traverse (g
->got_entries
, mips_elf_make_got_per_bfd
, &got_per_bfd_arg
);
3743 if (got_per_bfd_arg
.obfd
== NULL
)
3746 /* Also count how many page entries each input bfd requires. */
3747 htab_traverse (g
->got_page_entries
, mips_elf_make_got_pages_per_bfd
,
3749 if (got_per_bfd_arg
.obfd
== NULL
)
3752 got_per_bfd_arg
.current
= NULL
;
3753 got_per_bfd_arg
.primary
= NULL
;
3754 got_per_bfd_arg
.max_count
= ((MIPS_ELF_GOT_MAX_SIZE (info
)
3755 / MIPS_ELF_GOT_SIZE (abfd
))
3756 - MIPS_RESERVED_GOTNO (info
));
3757 got_per_bfd_arg
.max_pages
= pages
;
3758 /* The number of globals that will be included in the primary GOT.
3759 See the calls to mips_elf_set_global_got_offset below for more
3761 got_per_bfd_arg
.global_count
= g
->global_gotno
;
3763 /* Try to merge the GOTs of input bfds together, as long as they
3764 don't seem to exceed the maximum GOT size, choosing one of them
3765 to be the primary GOT. */
3766 htab_traverse (g
->bfd2got
, mips_elf_merge_gots
, &got_per_bfd_arg
);
3767 if (got_per_bfd_arg
.obfd
== NULL
)
3770 /* If we do not find any suitable primary GOT, create an empty one. */
3771 if (got_per_bfd_arg
.primary
== NULL
)
3773 g
->next
= (struct mips_got_info
*)
3774 bfd_alloc (abfd
, sizeof (struct mips_got_info
));
3775 if (g
->next
== NULL
)
3778 g
->next
->global_gotsym
= NULL
;
3779 g
->next
->global_gotno
= 0;
3780 g
->next
->local_gotno
= 0;
3781 g
->next
->page_gotno
= 0;
3782 g
->next
->tls_gotno
= 0;
3783 g
->next
->assigned_gotno
= 0;
3784 g
->next
->tls_assigned_gotno
= 0;
3785 g
->next
->tls_ldm_offset
= MINUS_ONE
;
3786 g
->next
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
3787 mips_elf_multi_got_entry_eq
,
3789 if (g
->next
->got_entries
== NULL
)
3791 g
->next
->got_page_entries
= htab_try_create (1, mips_got_page_entry_hash
,
3792 mips_got_page_entry_eq
,
3794 if (g
->next
->got_page_entries
== NULL
)
3796 g
->next
->bfd2got
= NULL
;
3799 g
->next
= got_per_bfd_arg
.primary
;
3800 g
->next
->next
= got_per_bfd_arg
.current
;
3802 /* GG is now the master GOT, and G is the primary GOT. */
3806 /* Map the output bfd to the primary got. That's what we're going
3807 to use for bfds that use GOT16 or GOT_PAGE relocations that we
3808 didn't mark in check_relocs, and we want a quick way to find it.
3809 We can't just use gg->next because we're going to reverse the
3812 struct mips_elf_bfd2got_hash
*bfdgot
;
3815 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
3816 (abfd
, sizeof (struct mips_elf_bfd2got_hash
));
3823 bfdgotp
= htab_find_slot (gg
->bfd2got
, bfdgot
, INSERT
);
3825 BFD_ASSERT (*bfdgotp
== NULL
);
3829 /* The IRIX dynamic linker requires every symbol that is referenced
3830 in a dynamic relocation to be present in the primary GOT, so
3831 arrange for them to appear after those that are actually
3834 GNU/Linux could very well do without it, but it would slow down
3835 the dynamic linker, since it would have to resolve every dynamic
3836 symbol referenced in other GOTs more than once, without help from
3837 the cache. Also, knowing that every external symbol has a GOT
3838 helps speed up the resolution of local symbols too, so GNU/Linux
3839 follows IRIX's practice.
3841 The number 2 is used by mips_elf_sort_hash_table_f to count
3842 global GOT symbols that are unreferenced in the primary GOT, with
3843 an initial dynamic index computed from gg->assigned_gotno, where
3844 the number of unreferenced global entries in the primary GOT is
3848 gg
->assigned_gotno
= gg
->global_gotno
- g
->global_gotno
;
3849 g
->global_gotno
= gg
->global_gotno
;
3850 set_got_offset_arg
.value
= 2;
3854 /* This could be used for dynamic linkers that don't optimize
3855 symbol resolution while applying relocations so as to use
3856 primary GOT entries or assuming the symbol is locally-defined.
3857 With this code, we assign lower dynamic indices to global
3858 symbols that are not referenced in the primary GOT, so that
3859 their entries can be omitted. */
3860 gg
->assigned_gotno
= 0;
3861 set_got_offset_arg
.value
= -1;
3864 /* Reorder dynamic symbols as described above (which behavior
3865 depends on the setting of VALUE). */
3866 set_got_offset_arg
.g
= NULL
;
3867 htab_traverse (gg
->got_entries
, mips_elf_set_global_got_offset
,
3868 &set_got_offset_arg
);
3869 set_got_offset_arg
.value
= 1;
3870 htab_traverse (g
->got_entries
, mips_elf_set_global_got_offset
,
3871 &set_got_offset_arg
);
3872 if (! mips_elf_sort_hash_table (info
, 1))
3875 /* Now go through the GOTs assigning them offset ranges.
3876 [assigned_gotno, local_gotno[ will be set to the range of local
3877 entries in each GOT. We can then compute the end of a GOT by
3878 adding local_gotno to global_gotno. We reverse the list and make
3879 it circular since then we'll be able to quickly compute the
3880 beginning of a GOT, by computing the end of its predecessor. To
3881 avoid special cases for the primary GOT, while still preserving
3882 assertions that are valid for both single- and multi-got links,
3883 we arrange for the main got struct to have the right number of
3884 global entries, but set its local_gotno such that the initial
3885 offset of the primary GOT is zero. Remember that the primary GOT
3886 will become the last item in the circular linked list, so it
3887 points back to the master GOT. */
3888 gg
->local_gotno
= -g
->global_gotno
;
3889 gg
->global_gotno
= g
->global_gotno
;
3896 struct mips_got_info
*gn
;
3898 assign
+= MIPS_RESERVED_GOTNO (info
);
3899 g
->assigned_gotno
= assign
;
3900 g
->local_gotno
+= assign
;
3901 g
->local_gotno
+= (pages
< g
->page_gotno
? pages
: g
->page_gotno
);
3902 assign
= g
->local_gotno
+ g
->global_gotno
+ g
->tls_gotno
;
3904 /* Take g out of the direct list, and push it onto the reversed
3905 list that gg points to. g->next is guaranteed to be nonnull after
3906 this operation, as required by mips_elf_initialize_tls_index. */
3911 /* Set up any TLS entries. We always place the TLS entries after
3912 all non-TLS entries. */
3913 g
->tls_assigned_gotno
= g
->local_gotno
+ g
->global_gotno
;
3914 htab_traverse (g
->got_entries
, mips_elf_initialize_tls_index
, g
);
3916 /* Move onto the next GOT. It will be a secondary GOT if nonull. */
3919 /* Mark global symbols in every non-primary GOT as ineligible for
3922 htab_traverse (g
->got_entries
, mips_elf_set_no_stub
, NULL
);
3926 got
->size
= (gg
->next
->local_gotno
3927 + gg
->next
->global_gotno
3928 + gg
->next
->tls_gotno
) * MIPS_ELF_GOT_SIZE (abfd
);
3934 /* Returns the first relocation of type r_type found, beginning with
3935 RELOCATION. RELEND is one-past-the-end of the relocation table. */
3937 static const Elf_Internal_Rela
*
3938 mips_elf_next_relocation (bfd
*abfd ATTRIBUTE_UNUSED
, unsigned int r_type
,
3939 const Elf_Internal_Rela
*relocation
,
3940 const Elf_Internal_Rela
*relend
)
3942 unsigned long r_symndx
= ELF_R_SYM (abfd
, relocation
->r_info
);
3944 while (relocation
< relend
)
3946 if (ELF_R_TYPE (abfd
, relocation
->r_info
) == r_type
3947 && ELF_R_SYM (abfd
, relocation
->r_info
) == r_symndx
)
3953 /* We didn't find it. */
3957 /* Return whether a relocation is against a local symbol. */
3960 mips_elf_local_relocation_p (bfd
*input_bfd
,
3961 const Elf_Internal_Rela
*relocation
,
3962 asection
**local_sections
,
3963 bfd_boolean check_forced
)
3965 unsigned long r_symndx
;
3966 Elf_Internal_Shdr
*symtab_hdr
;
3967 struct mips_elf_link_hash_entry
*h
;
3970 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
3971 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3972 extsymoff
= (elf_bad_symtab (input_bfd
)) ? 0 : symtab_hdr
->sh_info
;
3974 if (r_symndx
< extsymoff
)
3976 if (elf_bad_symtab (input_bfd
) && local_sections
[r_symndx
] != NULL
)
3981 /* Look up the hash table to check whether the symbol
3982 was forced local. */
3983 h
= (struct mips_elf_link_hash_entry
*)
3984 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
];
3985 /* Find the real hash-table entry for this symbol. */
3986 while (h
->root
.root
.type
== bfd_link_hash_indirect
3987 || h
->root
.root
.type
== bfd_link_hash_warning
)
3988 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3989 if (h
->root
.forced_local
)
3996 /* Sign-extend VALUE, which has the indicated number of BITS. */
3999 _bfd_mips_elf_sign_extend (bfd_vma value
, int bits
)
4001 if (value
& ((bfd_vma
) 1 << (bits
- 1)))
4002 /* VALUE is negative. */
4003 value
|= ((bfd_vma
) - 1) << bits
;
4008 /* Return non-zero if the indicated VALUE has overflowed the maximum
4009 range expressible by a signed number with the indicated number of
4013 mips_elf_overflow_p (bfd_vma value
, int bits
)
4015 bfd_signed_vma svalue
= (bfd_signed_vma
) value
;
4017 if (svalue
> (1 << (bits
- 1)) - 1)
4018 /* The value is too big. */
4020 else if (svalue
< -(1 << (bits
- 1)))
4021 /* The value is too small. */
4028 /* Calculate the %high function. */
4031 mips_elf_high (bfd_vma value
)
4033 return ((value
+ (bfd_vma
) 0x8000) >> 16) & 0xffff;
4036 /* Calculate the %higher function. */
4039 mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED
)
4042 return ((value
+ (bfd_vma
) 0x80008000) >> 32) & 0xffff;
4049 /* Calculate the %highest function. */
4052 mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED
)
4055 return ((value
+ (((bfd_vma
) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
4062 /* Create the .compact_rel section. */
4065 mips_elf_create_compact_rel_section
4066 (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
4069 register asection
*s
;
4071 if (bfd_get_section_by_name (abfd
, ".compact_rel") == NULL
)
4073 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
4076 s
= bfd_make_section_with_flags (abfd
, ".compact_rel", flags
);
4078 || ! bfd_set_section_alignment (abfd
, s
,
4079 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
4082 s
->size
= sizeof (Elf32_External_compact_rel
);
4088 /* Create the .got section to hold the global offset table. */
4091 mips_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
,
4092 bfd_boolean maybe_exclude
)
4095 register asection
*s
;
4096 struct elf_link_hash_entry
*h
;
4097 struct bfd_link_hash_entry
*bh
;
4098 struct mips_got_info
*g
;
4100 struct mips_elf_link_hash_table
*htab
;
4102 htab
= mips_elf_hash_table (info
);
4104 /* This function may be called more than once. */
4108 if (! maybe_exclude
)
4109 s
->flags
&= ~SEC_EXCLUDE
;
4113 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
4114 | SEC_LINKER_CREATED
);
4117 flags
|= SEC_EXCLUDE
;
4119 /* We have to use an alignment of 2**4 here because this is hardcoded
4120 in the function stub generation and in the linker script. */
4121 s
= bfd_make_section_with_flags (abfd
, ".got", flags
);
4123 || ! bfd_set_section_alignment (abfd
, s
, 4))
4127 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
4128 linker script because we don't want to define the symbol if we
4129 are not creating a global offset table. */
4131 if (! (_bfd_generic_link_add_one_symbol
4132 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
4133 0, NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
4136 h
= (struct elf_link_hash_entry
*) bh
;
4139 h
->type
= STT_OBJECT
;
4140 elf_hash_table (info
)->hgot
= h
;
4143 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
4146 amt
= sizeof (struct mips_got_info
);
4147 g
= bfd_alloc (abfd
, amt
);
4150 g
->global_gotsym
= NULL
;
4151 g
->global_gotno
= 0;
4153 g
->local_gotno
= MIPS_RESERVED_GOTNO (info
);
4155 g
->assigned_gotno
= MIPS_RESERVED_GOTNO (info
);
4158 g
->tls_ldm_offset
= MINUS_ONE
;
4159 g
->got_entries
= htab_try_create (1, mips_elf_got_entry_hash
,
4160 mips_elf_got_entry_eq
, NULL
);
4161 if (g
->got_entries
== NULL
)
4163 g
->got_page_entries
= htab_try_create (1, mips_got_page_entry_hash
,
4164 mips_got_page_entry_eq
, NULL
);
4165 if (g
->got_page_entries
== NULL
)
4168 mips_elf_section_data (s
)->elf
.this_hdr
.sh_flags
4169 |= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
4171 /* VxWorks also needs a .got.plt section. */
4172 if (htab
->is_vxworks
)
4174 s
= bfd_make_section_with_flags (abfd
, ".got.plt",
4175 SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
4176 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
4177 if (s
== NULL
|| !bfd_set_section_alignment (abfd
, s
, 4))
4185 /* Return true if H refers to the special VxWorks __GOTT_BASE__ or
4186 __GOTT_INDEX__ symbols. These symbols are only special for
4187 shared objects; they are not used in executables. */
4190 is_gott_symbol (struct bfd_link_info
*info
, struct elf_link_hash_entry
*h
)
4192 return (mips_elf_hash_table (info
)->is_vxworks
4194 && (strcmp (h
->root
.root
.string
, "__GOTT_BASE__") == 0
4195 || strcmp (h
->root
.root
.string
, "__GOTT_INDEX__") == 0));
4198 /* Calculate the value produced by the RELOCATION (which comes from
4199 the INPUT_BFD). The ADDEND is the addend to use for this
4200 RELOCATION; RELOCATION->R_ADDEND is ignored.
4202 The result of the relocation calculation is stored in VALUEP.
4203 REQUIRE_JALXP indicates whether or not the opcode used with this
4204 relocation must be JALX.
4206 This function returns bfd_reloc_continue if the caller need take no
4207 further action regarding this relocation, bfd_reloc_notsupported if
4208 something goes dramatically wrong, bfd_reloc_overflow if an
4209 overflow occurs, and bfd_reloc_ok to indicate success. */
4211 static bfd_reloc_status_type
4212 mips_elf_calculate_relocation (bfd
*abfd
, bfd
*input_bfd
,
4213 asection
*input_section
,
4214 struct bfd_link_info
*info
,
4215 const Elf_Internal_Rela
*relocation
,
4216 bfd_vma addend
, reloc_howto_type
*howto
,
4217 Elf_Internal_Sym
*local_syms
,
4218 asection
**local_sections
, bfd_vma
*valuep
,
4219 const char **namep
, bfd_boolean
*require_jalxp
,
4220 bfd_boolean save_addend
)
4222 /* The eventual value we will return. */
4224 /* The address of the symbol against which the relocation is
4227 /* The final GP value to be used for the relocatable, executable, or
4228 shared object file being produced. */
4230 /* The place (section offset or address) of the storage unit being
4233 /* The value of GP used to create the relocatable object. */
4235 /* The offset into the global offset table at which the address of
4236 the relocation entry symbol, adjusted by the addend, resides
4237 during execution. */
4238 bfd_vma g
= MINUS_ONE
;
4239 /* The section in which the symbol referenced by the relocation is
4241 asection
*sec
= NULL
;
4242 struct mips_elf_link_hash_entry
*h
= NULL
;
4243 /* TRUE if the symbol referred to by this relocation is a local
4245 bfd_boolean local_p
, was_local_p
;
4246 /* TRUE if the symbol referred to by this relocation is "_gp_disp". */
4247 bfd_boolean gp_disp_p
= FALSE
;
4248 /* TRUE if the symbol referred to by this relocation is
4249 "__gnu_local_gp". */
4250 bfd_boolean gnu_local_gp_p
= FALSE
;
4251 Elf_Internal_Shdr
*symtab_hdr
;
4253 unsigned long r_symndx
;
4255 /* TRUE if overflow occurred during the calculation of the
4256 relocation value. */
4257 bfd_boolean overflowed_p
;
4258 /* TRUE if this relocation refers to a MIPS16 function. */
4259 bfd_boolean target_is_16_bit_code_p
= FALSE
;
4260 struct mips_elf_link_hash_table
*htab
;
4263 dynobj
= elf_hash_table (info
)->dynobj
;
4264 htab
= mips_elf_hash_table (info
);
4266 /* Parse the relocation. */
4267 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
4268 r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
4269 p
= (input_section
->output_section
->vma
4270 + input_section
->output_offset
4271 + relocation
->r_offset
);
4273 /* Assume that there will be no overflow. */
4274 overflowed_p
= FALSE
;
4276 /* Figure out whether or not the symbol is local, and get the offset
4277 used in the array of hash table entries. */
4278 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
4279 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
4280 local_sections
, FALSE
);
4281 was_local_p
= local_p
;
4282 if (! elf_bad_symtab (input_bfd
))
4283 extsymoff
= symtab_hdr
->sh_info
;
4286 /* The symbol table does not follow the rule that local symbols
4287 must come before globals. */
4291 /* Figure out the value of the symbol. */
4294 Elf_Internal_Sym
*sym
;
4296 sym
= local_syms
+ r_symndx
;
4297 sec
= local_sections
[r_symndx
];
4299 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
4300 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
4301 || (sec
->flags
& SEC_MERGE
))
4302 symbol
+= sym
->st_value
;
4303 if ((sec
->flags
& SEC_MERGE
)
4304 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4306 addend
= _bfd_elf_rel_local_sym (abfd
, sym
, &sec
, addend
);
4308 addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
4311 /* MIPS16 text labels should be treated as odd. */
4312 if (ELF_ST_IS_MIPS16 (sym
->st_other
))
4315 /* Record the name of this symbol, for our caller. */
4316 *namep
= bfd_elf_string_from_elf_section (input_bfd
,
4317 symtab_hdr
->sh_link
,
4320 *namep
= bfd_section_name (input_bfd
, sec
);
4322 target_is_16_bit_code_p
= ELF_ST_IS_MIPS16 (sym
->st_other
);
4326 /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ? */
4328 /* For global symbols we look up the symbol in the hash-table. */
4329 h
= ((struct mips_elf_link_hash_entry
*)
4330 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
]);
4331 /* Find the real hash-table entry for this symbol. */
4332 while (h
->root
.root
.type
== bfd_link_hash_indirect
4333 || h
->root
.root
.type
== bfd_link_hash_warning
)
4334 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
4336 /* Record the name of this symbol, for our caller. */
4337 *namep
= h
->root
.root
.root
.string
;
4339 /* See if this is the special _gp_disp symbol. Note that such a
4340 symbol must always be a global symbol. */
4341 if (strcmp (*namep
, "_gp_disp") == 0
4342 && ! NEWABI_P (input_bfd
))
4344 /* Relocations against _gp_disp are permitted only with
4345 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
4346 if (!hi16_reloc_p (r_type
) && !lo16_reloc_p (r_type
))
4347 return bfd_reloc_notsupported
;
4351 /* See if this is the special _gp symbol. Note that such a
4352 symbol must always be a global symbol. */
4353 else if (strcmp (*namep
, "__gnu_local_gp") == 0)
4354 gnu_local_gp_p
= TRUE
;
4357 /* If this symbol is defined, calculate its address. Note that
4358 _gp_disp is a magic symbol, always implicitly defined by the
4359 linker, so it's inappropriate to check to see whether or not
4361 else if ((h
->root
.root
.type
== bfd_link_hash_defined
4362 || h
->root
.root
.type
== bfd_link_hash_defweak
)
4363 && h
->root
.root
.u
.def
.section
)
4365 sec
= h
->root
.root
.u
.def
.section
;
4366 if (sec
->output_section
)
4367 symbol
= (h
->root
.root
.u
.def
.value
4368 + sec
->output_section
->vma
4369 + sec
->output_offset
);
4371 symbol
= h
->root
.root
.u
.def
.value
;
4373 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
4374 /* We allow relocations against undefined weak symbols, giving
4375 it the value zero, so that you can undefined weak functions
4376 and check to see if they exist by looking at their
4379 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
4380 && ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
4382 else if (strcmp (*namep
, SGI_COMPAT (input_bfd
)
4383 ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING") == 0)
4385 /* If this is a dynamic link, we should have created a
4386 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
4387 in in _bfd_mips_elf_create_dynamic_sections.
4388 Otherwise, we should define the symbol with a value of 0.
4389 FIXME: It should probably get into the symbol table
4391 BFD_ASSERT (! info
->shared
);
4392 BFD_ASSERT (bfd_get_section_by_name (abfd
, ".dynamic") == NULL
);
4395 else if (ELF_MIPS_IS_OPTIONAL (h
->root
.other
))
4397 /* This is an optional symbol - an Irix specific extension to the
4398 ELF spec. Ignore it for now.
4399 XXX - FIXME - there is more to the spec for OPTIONAL symbols
4400 than simply ignoring them, but we do not handle this for now.
4401 For information see the "64-bit ELF Object File Specification"
4402 which is available from here:
4403 http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf */
4408 if (! ((*info
->callbacks
->undefined_symbol
)
4409 (info
, h
->root
.root
.root
.string
, input_bfd
,
4410 input_section
, relocation
->r_offset
,
4411 (info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
)
4412 || ELF_ST_VISIBILITY (h
->root
.other
))))
4413 return bfd_reloc_undefined
;
4417 target_is_16_bit_code_p
= ELF_ST_IS_MIPS16 (h
->root
.other
);
4420 /* If this is a reference to a 16-bit function with a stub, we need
4421 to redirect the relocation to the stub unless:
4423 (a) the relocation is for a MIPS16 JAL;
4425 (b) the relocation is for a MIPS16 PIC call, and there are no
4426 non-MIPS16 uses of the GOT slot; or
4428 (c) the section allows direct references to MIPS16 functions. */
4429 if (r_type
!= R_MIPS16_26
4430 && !info
->relocatable
4432 && h
->fn_stub
!= NULL
4433 && (r_type
!= R_MIPS16_CALL16
|| h
->need_fn_stub
))
4435 && elf_tdata (input_bfd
)->local_stubs
!= NULL
4436 && elf_tdata (input_bfd
)->local_stubs
[r_symndx
] != NULL
))
4437 && !section_allows_mips16_refs_p (input_section
))
4439 /* This is a 32- or 64-bit call to a 16-bit function. We should
4440 have already noticed that we were going to need the
4443 sec
= elf_tdata (input_bfd
)->local_stubs
[r_symndx
];
4446 BFD_ASSERT (h
->need_fn_stub
);
4450 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
4451 /* The target is 16-bit, but the stub isn't. */
4452 target_is_16_bit_code_p
= FALSE
;
4454 /* If this is a 16-bit call to a 32- or 64-bit function with a stub, we
4455 need to redirect the call to the stub. Note that we specifically
4456 exclude R_MIPS16_CALL16 from this behavior; indirect calls should
4457 use an indirect stub instead. */
4458 else if (r_type
== R_MIPS16_26
&& !info
->relocatable
4459 && ((h
!= NULL
&& (h
->call_stub
!= NULL
|| h
->call_fp_stub
!= NULL
))
4461 && elf_tdata (input_bfd
)->local_call_stubs
!= NULL
4462 && elf_tdata (input_bfd
)->local_call_stubs
[r_symndx
] != NULL
))
4463 && !target_is_16_bit_code_p
)
4466 sec
= elf_tdata (input_bfd
)->local_call_stubs
[r_symndx
];
4469 /* If both call_stub and call_fp_stub are defined, we can figure
4470 out which one to use by checking which one appears in the input
4472 if (h
->call_stub
!= NULL
&& h
->call_fp_stub
!= NULL
)
4477 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
4479 if (CALL_FP_STUB_P (bfd_get_section_name (input_bfd
, o
)))
4481 sec
= h
->call_fp_stub
;
4488 else if (h
->call_stub
!= NULL
)
4491 sec
= h
->call_fp_stub
;
4494 BFD_ASSERT (sec
->size
> 0);
4495 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
4498 /* Calls from 16-bit code to 32-bit code and vice versa require the
4499 special jalx instruction. */
4500 *require_jalxp
= (!info
->relocatable
4501 && (((r_type
== R_MIPS16_26
) && !target_is_16_bit_code_p
)
4502 || ((r_type
== R_MIPS_26
) && target_is_16_bit_code_p
)));
4504 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
4505 local_sections
, TRUE
);
4507 gp0
= _bfd_get_gp_value (input_bfd
);
4508 gp
= _bfd_get_gp_value (abfd
);
4510 gp
+= mips_elf_adjust_gp (abfd
, htab
->got_info
, input_bfd
);
4515 /* If we haven't already determined the GOT offset, oand we're going
4516 to need it, get it now. */
4519 case R_MIPS_GOT_PAGE
:
4520 case R_MIPS_GOT_OFST
:
4521 /* We need to decay to GOT_DISP/addend if the symbol doesn't
4523 local_p
= local_p
|| _bfd_elf_symbol_refs_local_p (&h
->root
, info
, 1);
4524 if (local_p
|| r_type
== R_MIPS_GOT_OFST
)
4528 case R_MIPS16_CALL16
:
4529 case R_MIPS16_GOT16
:
4532 case R_MIPS_GOT_DISP
:
4533 case R_MIPS_GOT_HI16
:
4534 case R_MIPS_CALL_HI16
:
4535 case R_MIPS_GOT_LO16
:
4536 case R_MIPS_CALL_LO16
:
4538 case R_MIPS_TLS_GOTTPREL
:
4539 case R_MIPS_TLS_LDM
:
4540 /* Find the index into the GOT where this value is located. */
4541 if (r_type
== R_MIPS_TLS_LDM
)
4543 g
= mips_elf_local_got_index (abfd
, input_bfd
, info
,
4544 0, 0, NULL
, r_type
);
4546 return bfd_reloc_outofrange
;
4550 /* On VxWorks, CALL relocations should refer to the .got.plt
4551 entry, which is initialized to point at the PLT stub. */
4552 if (htab
->is_vxworks
4553 && (r_type
== R_MIPS_CALL_HI16
4554 || r_type
== R_MIPS_CALL_LO16
4555 || call16_reloc_p (r_type
)))
4557 BFD_ASSERT (addend
== 0);
4558 BFD_ASSERT (h
->root
.needs_plt
);
4559 g
= mips_elf_gotplt_index (info
, &h
->root
);
4563 /* GOT_PAGE may take a non-zero addend, that is ignored in a
4564 GOT_PAGE relocation that decays to GOT_DISP because the
4565 symbol turns out to be global. The addend is then added
4567 BFD_ASSERT (addend
== 0 || r_type
== R_MIPS_GOT_PAGE
);
4568 g
= mips_elf_global_got_index (dynobj
, input_bfd
,
4569 &h
->root
, r_type
, info
);
4570 if (h
->tls_type
== GOT_NORMAL
4571 && (! elf_hash_table(info
)->dynamic_sections_created
4573 && (info
->symbolic
|| h
->root
.forced_local
)
4574 && h
->root
.def_regular
)))
4575 /* This is a static link or a -Bsymbolic link. The
4576 symbol is defined locally, or was forced to be local.
4577 We must initialize this entry in the GOT. */
4578 MIPS_ELF_PUT_WORD (dynobj
, symbol
, htab
->sgot
->contents
+ g
);
4581 else if (!htab
->is_vxworks
4582 && (call16_reloc_p (r_type
) || got16_reloc_p (r_type
)))
4583 /* The calculation below does not involve "g". */
4587 g
= mips_elf_local_got_index (abfd
, input_bfd
, info
,
4588 symbol
+ addend
, r_symndx
, h
, r_type
);
4590 return bfd_reloc_outofrange
;
4593 /* Convert GOT indices to actual offsets. */
4594 g
= mips_elf_got_offset_from_index (info
, abfd
, input_bfd
, g
);
4598 /* Relocations against the VxWorks __GOTT_BASE__ and __GOTT_INDEX__
4599 symbols are resolved by the loader. Add them to .rela.dyn. */
4600 if (h
!= NULL
&& is_gott_symbol (info
, &h
->root
))
4602 Elf_Internal_Rela outrel
;
4606 s
= mips_elf_rel_dyn_section (info
, FALSE
);
4607 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4609 outrel
.r_offset
= (input_section
->output_section
->vma
4610 + input_section
->output_offset
4611 + relocation
->r_offset
);
4612 outrel
.r_info
= ELF32_R_INFO (h
->root
.dynindx
, r_type
);
4613 outrel
.r_addend
= addend
;
4614 bfd_elf32_swap_reloca_out (abfd
, &outrel
, loc
);
4616 /* If we've written this relocation for a readonly section,
4617 we need to set DF_TEXTREL again, so that we do not delete the
4619 if (MIPS_ELF_READONLY_SECTION (input_section
))
4620 info
->flags
|= DF_TEXTREL
;
4623 return bfd_reloc_ok
;
4626 /* Figure out what kind of relocation is being performed. */
4630 return bfd_reloc_continue
;
4633 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 16);
4634 overflowed_p
= mips_elf_overflow_p (value
, 16);
4641 || (!htab
->is_vxworks
4642 && htab
->root
.dynamic_sections_created
4644 && h
->root
.def_dynamic
4645 && !h
->root
.def_regular
))
4648 || h
->root
.root
.type
!= bfd_link_hash_undefweak
4649 || ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
4650 && (input_section
->flags
& SEC_ALLOC
) != 0)
4652 /* If we're creating a shared library, or this relocation is
4653 against a symbol in a shared library, then we can't know
4654 where the symbol will end up. So, we create a relocation
4655 record in the output, and leave the job up to the dynamic
4658 In VxWorks executables, references to external symbols
4659 are handled using copy relocs or PLT stubs, so there's
4660 no need to add a dynamic relocation here. */
4662 if (!mips_elf_create_dynamic_relocation (abfd
,
4670 return bfd_reloc_undefined
;
4674 if (r_type
!= R_MIPS_REL32
)
4675 value
= symbol
+ addend
;
4679 value
&= howto
->dst_mask
;
4683 value
= symbol
+ addend
- p
;
4684 value
&= howto
->dst_mask
;
4688 /* The calculation for R_MIPS16_26 is just the same as for an
4689 R_MIPS_26. It's only the storage of the relocated field into
4690 the output file that's different. That's handled in
4691 mips_elf_perform_relocation. So, we just fall through to the
4692 R_MIPS_26 case here. */
4695 value
= ((addend
| ((p
+ 4) & 0xf0000000)) + symbol
) >> 2;
4698 value
= (_bfd_mips_elf_sign_extend (addend
, 28) + symbol
) >> 2;
4699 if (h
->root
.root
.type
!= bfd_link_hash_undefweak
)
4700 overflowed_p
= (value
>> 26) != ((p
+ 4) >> 28);
4702 value
&= howto
->dst_mask
;
4705 case R_MIPS_TLS_DTPREL_HI16
:
4706 value
= (mips_elf_high (addend
+ symbol
- dtprel_base (info
))
4710 case R_MIPS_TLS_DTPREL_LO16
:
4711 case R_MIPS_TLS_DTPREL32
:
4712 case R_MIPS_TLS_DTPREL64
:
4713 value
= (symbol
+ addend
- dtprel_base (info
)) & howto
->dst_mask
;
4716 case R_MIPS_TLS_TPREL_HI16
:
4717 value
= (mips_elf_high (addend
+ symbol
- tprel_base (info
))
4721 case R_MIPS_TLS_TPREL_LO16
:
4722 value
= (symbol
+ addend
- tprel_base (info
)) & howto
->dst_mask
;
4729 value
= mips_elf_high (addend
+ symbol
);
4730 value
&= howto
->dst_mask
;
4734 /* For MIPS16 ABI code we generate this sequence
4735 0: li $v0,%hi(_gp_disp)
4736 4: addiupc $v1,%lo(_gp_disp)
4740 So the offsets of hi and lo relocs are the same, but the
4741 $pc is four higher than $t9 would be, so reduce
4742 both reloc addends by 4. */
4743 if (r_type
== R_MIPS16_HI16
)
4744 value
= mips_elf_high (addend
+ gp
- p
- 4);
4746 value
= mips_elf_high (addend
+ gp
- p
);
4747 overflowed_p
= mips_elf_overflow_p (value
, 16);
4754 value
= (symbol
+ addend
) & howto
->dst_mask
;
4757 /* See the comment for R_MIPS16_HI16 above for the reason
4758 for this conditional. */
4759 if (r_type
== R_MIPS16_LO16
)
4760 value
= addend
+ gp
- p
;
4762 value
= addend
+ gp
- p
+ 4;
4763 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
4764 for overflow. But, on, say, IRIX5, relocations against
4765 _gp_disp are normally generated from the .cpload
4766 pseudo-op. It generates code that normally looks like
4769 lui $gp,%hi(_gp_disp)
4770 addiu $gp,$gp,%lo(_gp_disp)
4773 Here $t9 holds the address of the function being called,
4774 as required by the MIPS ELF ABI. The R_MIPS_LO16
4775 relocation can easily overflow in this situation, but the
4776 R_MIPS_HI16 relocation will handle the overflow.
4777 Therefore, we consider this a bug in the MIPS ABI, and do
4778 not check for overflow here. */
4782 case R_MIPS_LITERAL
:
4783 /* Because we don't merge literal sections, we can handle this
4784 just like R_MIPS_GPREL16. In the long run, we should merge
4785 shared literals, and then we will need to additional work
4790 case R_MIPS16_GPREL
:
4791 /* The R_MIPS16_GPREL performs the same calculation as
4792 R_MIPS_GPREL16, but stores the relocated bits in a different
4793 order. We don't need to do anything special here; the
4794 differences are handled in mips_elf_perform_relocation. */
4795 case R_MIPS_GPREL16
:
4796 /* Only sign-extend the addend if it was extracted from the
4797 instruction. If the addend was separate, leave it alone,
4798 otherwise we may lose significant bits. */
4799 if (howto
->partial_inplace
)
4800 addend
= _bfd_mips_elf_sign_extend (addend
, 16);
4801 value
= symbol
+ addend
- gp
;
4802 /* If the symbol was local, any earlier relocatable links will
4803 have adjusted its addend with the gp offset, so compensate
4804 for that now. Don't do it for symbols forced local in this
4805 link, though, since they won't have had the gp offset applied
4809 overflowed_p
= mips_elf_overflow_p (value
, 16);
4812 case R_MIPS16_GOT16
:
4813 case R_MIPS16_CALL16
:
4816 /* VxWorks does not have separate local and global semantics for
4817 R_MIPS*_GOT16; every relocation evaluates to "G". */
4818 if (!htab
->is_vxworks
&& local_p
)
4822 forced
= ! mips_elf_local_relocation_p (input_bfd
, relocation
,
4823 local_sections
, FALSE
);
4824 value
= mips_elf_got16_entry (abfd
, input_bfd
, info
,
4825 symbol
+ addend
, forced
);
4826 if (value
== MINUS_ONE
)
4827 return bfd_reloc_outofrange
;
4829 = mips_elf_got_offset_from_index (info
, abfd
, input_bfd
, value
);
4830 overflowed_p
= mips_elf_overflow_p (value
, 16);
4837 case R_MIPS_TLS_GOTTPREL
:
4838 case R_MIPS_TLS_LDM
:
4839 case R_MIPS_GOT_DISP
:
4842 overflowed_p
= mips_elf_overflow_p (value
, 16);
4845 case R_MIPS_GPREL32
:
4846 value
= (addend
+ symbol
+ gp0
- gp
);
4848 value
&= howto
->dst_mask
;
4852 case R_MIPS_GNU_REL16_S2
:
4853 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 18) - p
;
4854 overflowed_p
= mips_elf_overflow_p (value
, 18);
4855 value
>>= howto
->rightshift
;
4856 value
&= howto
->dst_mask
;
4859 case R_MIPS_GOT_HI16
:
4860 case R_MIPS_CALL_HI16
:
4861 /* We're allowed to handle these two relocations identically.
4862 The dynamic linker is allowed to handle the CALL relocations
4863 differently by creating a lazy evaluation stub. */
4865 value
= mips_elf_high (value
);
4866 value
&= howto
->dst_mask
;
4869 case R_MIPS_GOT_LO16
:
4870 case R_MIPS_CALL_LO16
:
4871 value
= g
& howto
->dst_mask
;
4874 case R_MIPS_GOT_PAGE
:
4875 /* GOT_PAGE relocations that reference non-local symbols decay
4876 to GOT_DISP. The corresponding GOT_OFST relocation decays to
4880 value
= mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, NULL
);
4881 if (value
== MINUS_ONE
)
4882 return bfd_reloc_outofrange
;
4883 value
= mips_elf_got_offset_from_index (info
, abfd
, input_bfd
, value
);
4884 overflowed_p
= mips_elf_overflow_p (value
, 16);
4887 case R_MIPS_GOT_OFST
:
4889 mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, &value
);
4892 overflowed_p
= mips_elf_overflow_p (value
, 16);
4896 value
= symbol
- addend
;
4897 value
&= howto
->dst_mask
;
4901 value
= mips_elf_higher (addend
+ symbol
);
4902 value
&= howto
->dst_mask
;
4905 case R_MIPS_HIGHEST
:
4906 value
= mips_elf_highest (addend
+ symbol
);
4907 value
&= howto
->dst_mask
;
4910 case R_MIPS_SCN_DISP
:
4911 value
= symbol
+ addend
- sec
->output_offset
;
4912 value
&= howto
->dst_mask
;
4916 /* This relocation is only a hint. In some cases, we optimize
4917 it into a bal instruction. But we don't try to optimize
4918 branches to the PLT; that will wind up wasting time. */
4919 if (h
!= NULL
&& h
->root
.plt
.offset
!= (bfd_vma
) -1)
4920 return bfd_reloc_continue
;
4921 value
= symbol
+ addend
;
4925 case R_MIPS_GNU_VTINHERIT
:
4926 case R_MIPS_GNU_VTENTRY
:
4927 /* We don't do anything with these at present. */
4928 return bfd_reloc_continue
;
4931 /* An unrecognized relocation type. */
4932 return bfd_reloc_notsupported
;
4935 /* Store the VALUE for our caller. */
4937 return overflowed_p
? bfd_reloc_overflow
: bfd_reloc_ok
;
4940 /* Obtain the field relocated by RELOCATION. */
4943 mips_elf_obtain_contents (reloc_howto_type
*howto
,
4944 const Elf_Internal_Rela
*relocation
,
4945 bfd
*input_bfd
, bfd_byte
*contents
)
4948 bfd_byte
*location
= contents
+ relocation
->r_offset
;
4950 /* Obtain the bytes. */
4951 x
= bfd_get ((8 * bfd_get_reloc_size (howto
)), input_bfd
, location
);
4956 /* It has been determined that the result of the RELOCATION is the
4957 VALUE. Use HOWTO to place VALUE into the output file at the
4958 appropriate position. The SECTION is the section to which the
4959 relocation applies. If REQUIRE_JALX is TRUE, then the opcode used
4960 for the relocation must be either JAL or JALX, and it is
4961 unconditionally converted to JALX.
4963 Returns FALSE if anything goes wrong. */
4966 mips_elf_perform_relocation (struct bfd_link_info
*info
,
4967 reloc_howto_type
*howto
,
4968 const Elf_Internal_Rela
*relocation
,
4969 bfd_vma value
, bfd
*input_bfd
,
4970 asection
*input_section
, bfd_byte
*contents
,
4971 bfd_boolean require_jalx
)
4975 int r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
4977 /* Figure out where the relocation is occurring. */
4978 location
= contents
+ relocation
->r_offset
;
4980 _bfd_mips16_elf_reloc_unshuffle (input_bfd
, r_type
, FALSE
, location
);
4982 /* Obtain the current value. */
4983 x
= mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
);
4985 /* Clear the field we are setting. */
4986 x
&= ~howto
->dst_mask
;
4988 /* Set the field. */
4989 x
|= (value
& howto
->dst_mask
);
4991 /* If required, turn JAL into JALX. */
4995 bfd_vma opcode
= x
>> 26;
4996 bfd_vma jalx_opcode
;
4998 /* Check to see if the opcode is already JAL or JALX. */
4999 if (r_type
== R_MIPS16_26
)
5001 ok
= ((opcode
== 0x6) || (opcode
== 0x7));
5006 ok
= ((opcode
== 0x3) || (opcode
== 0x1d));
5010 /* If the opcode is not JAL or JALX, there's a problem. */
5013 (*_bfd_error_handler
)
5014 (_("%B: %A+0x%lx: jump to stub routine which is not jal"),
5017 (unsigned long) relocation
->r_offset
);
5018 bfd_set_error (bfd_error_bad_value
);
5022 /* Make this the JALX opcode. */
5023 x
= (x
& ~(0x3f << 26)) | (jalx_opcode
<< 26);
5026 /* On the RM9000, bal is faster than jal, because bal uses branch
5027 prediction hardware. If we are linking for the RM9000, and we
5028 see jal, and bal fits, use it instead. Note that this
5029 transformation should be safe for all architectures. */
5030 if (bfd_get_mach (input_bfd
) == bfd_mach_mips9000
5031 && !info
->relocatable
5033 && ((r_type
== R_MIPS_26
&& (x
>> 26) == 0x3) /* jal addr */
5034 || (r_type
== R_MIPS_JALR
&& x
== 0x0320f809))) /* jalr t9 */
5040 addr
= (input_section
->output_section
->vma
5041 + input_section
->output_offset
5042 + relocation
->r_offset
5044 if (r_type
== R_MIPS_26
)
5045 dest
= (value
<< 2) | ((addr
>> 28) << 28);
5049 if (off
<= 0x1ffff && off
>= -0x20000)
5050 x
= 0x04110000 | (((bfd_vma
) off
>> 2) & 0xffff); /* bal addr */
5053 /* Put the value into the output. */
5054 bfd_put (8 * bfd_get_reloc_size (howto
), input_bfd
, x
, location
);
5056 _bfd_mips16_elf_reloc_shuffle(input_bfd
, r_type
, !info
->relocatable
,
5062 /* Add room for N relocations to the .rel(a).dyn section in ABFD. */
5065 mips_elf_allocate_dynamic_relocations (bfd
*abfd
, struct bfd_link_info
*info
,
5069 struct mips_elf_link_hash_table
*htab
;
5071 htab
= mips_elf_hash_table (info
);
5072 s
= mips_elf_rel_dyn_section (info
, FALSE
);
5073 BFD_ASSERT (s
!= NULL
);
5075 if (htab
->is_vxworks
)
5076 s
->size
+= n
* MIPS_ELF_RELA_SIZE (abfd
);
5081 /* Make room for a null element. */
5082 s
->size
+= MIPS_ELF_REL_SIZE (abfd
);
5085 s
->size
+= n
* MIPS_ELF_REL_SIZE (abfd
);
5089 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
5090 is the original relocation, which is now being transformed into a
5091 dynamic relocation. The ADDENDP is adjusted if necessary; the
5092 caller should store the result in place of the original addend. */
5095 mips_elf_create_dynamic_relocation (bfd
*output_bfd
,
5096 struct bfd_link_info
*info
,
5097 const Elf_Internal_Rela
*rel
,
5098 struct mips_elf_link_hash_entry
*h
,
5099 asection
*sec
, bfd_vma symbol
,
5100 bfd_vma
*addendp
, asection
*input_section
)
5102 Elf_Internal_Rela outrel
[3];
5107 bfd_boolean defined_p
;
5108 struct mips_elf_link_hash_table
*htab
;
5110 htab
= mips_elf_hash_table (info
);
5111 r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
5112 dynobj
= elf_hash_table (info
)->dynobj
;
5113 sreloc
= mips_elf_rel_dyn_section (info
, FALSE
);
5114 BFD_ASSERT (sreloc
!= NULL
);
5115 BFD_ASSERT (sreloc
->contents
!= NULL
);
5116 BFD_ASSERT (sreloc
->reloc_count
* MIPS_ELF_REL_SIZE (output_bfd
)
5119 outrel
[0].r_offset
=
5120 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[0].r_offset
);
5121 if (ABI_64_P (output_bfd
))
5123 outrel
[1].r_offset
=
5124 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[1].r_offset
);
5125 outrel
[2].r_offset
=
5126 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[2].r_offset
);
5129 if (outrel
[0].r_offset
== MINUS_ONE
)
5130 /* The relocation field has been deleted. */
5133 if (outrel
[0].r_offset
== MINUS_TWO
)
5135 /* The relocation field has been converted into a relative value of
5136 some sort. Functions like _bfd_elf_write_section_eh_frame expect
5137 the field to be fully relocated, so add in the symbol's value. */
5142 /* We must now calculate the dynamic symbol table index to use
5143 in the relocation. */
5145 && (!h
->root
.def_regular
5146 || (info
->shared
&& !info
->symbolic
&& !h
->root
.forced_local
)))
5148 indx
= h
->root
.dynindx
;
5149 if (SGI_COMPAT (output_bfd
))
5150 defined_p
= h
->root
.def_regular
;
5152 /* ??? glibc's ld.so just adds the final GOT entry to the
5153 relocation field. It therefore treats relocs against
5154 defined symbols in the same way as relocs against
5155 undefined symbols. */
5160 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
5162 else if (sec
== NULL
|| sec
->owner
== NULL
)
5164 bfd_set_error (bfd_error_bad_value
);
5169 indx
= elf_section_data (sec
->output_section
)->dynindx
;
5172 asection
*osec
= htab
->root
.text_index_section
;
5173 indx
= elf_section_data (osec
)->dynindx
;
5179 /* Instead of generating a relocation using the section
5180 symbol, we may as well make it a fully relative
5181 relocation. We want to avoid generating relocations to
5182 local symbols because we used to generate them
5183 incorrectly, without adding the original symbol value,
5184 which is mandated by the ABI for section symbols. In
5185 order to give dynamic loaders and applications time to
5186 phase out the incorrect use, we refrain from emitting
5187 section-relative relocations. It's not like they're
5188 useful, after all. This should be a bit more efficient
5190 /* ??? Although this behavior is compatible with glibc's ld.so,
5191 the ABI says that relocations against STN_UNDEF should have
5192 a symbol value of 0. Irix rld honors this, so relocations
5193 against STN_UNDEF have no effect. */
5194 if (!SGI_COMPAT (output_bfd
))
5199 /* If the relocation was previously an absolute relocation and
5200 this symbol will not be referred to by the relocation, we must
5201 adjust it by the value we give it in the dynamic symbol table.
5202 Otherwise leave the job up to the dynamic linker. */
5203 if (defined_p
&& r_type
!= R_MIPS_REL32
)
5206 if (htab
->is_vxworks
)
5207 /* VxWorks uses non-relative relocations for this. */
5208 outrel
[0].r_info
= ELF32_R_INFO (indx
, R_MIPS_32
);
5210 /* The relocation is always an REL32 relocation because we don't
5211 know where the shared library will wind up at load-time. */
5212 outrel
[0].r_info
= ELF_R_INFO (output_bfd
, (unsigned long) indx
,
5215 /* For strict adherence to the ABI specification, we should
5216 generate a R_MIPS_64 relocation record by itself before the
5217 _REL32/_64 record as well, such that the addend is read in as
5218 a 64-bit value (REL32 is a 32-bit relocation, after all).
5219 However, since none of the existing ELF64 MIPS dynamic
5220 loaders seems to care, we don't waste space with these
5221 artificial relocations. If this turns out to not be true,
5222 mips_elf_allocate_dynamic_relocation() should be tweaked so
5223 as to make room for a pair of dynamic relocations per
5224 invocation if ABI_64_P, and here we should generate an
5225 additional relocation record with R_MIPS_64 by itself for a
5226 NULL symbol before this relocation record. */
5227 outrel
[1].r_info
= ELF_R_INFO (output_bfd
, 0,
5228 ABI_64_P (output_bfd
)
5231 outrel
[2].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_NONE
);
5233 /* Adjust the output offset of the relocation to reference the
5234 correct location in the output file. */
5235 outrel
[0].r_offset
+= (input_section
->output_section
->vma
5236 + input_section
->output_offset
);
5237 outrel
[1].r_offset
+= (input_section
->output_section
->vma
5238 + input_section
->output_offset
);
5239 outrel
[2].r_offset
+= (input_section
->output_section
->vma
5240 + input_section
->output_offset
);
5242 /* Put the relocation back out. We have to use the special
5243 relocation outputter in the 64-bit case since the 64-bit
5244 relocation format is non-standard. */
5245 if (ABI_64_P (output_bfd
))
5247 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
5248 (output_bfd
, &outrel
[0],
5250 + sreloc
->reloc_count
* sizeof (Elf64_Mips_External_Rel
)));
5252 else if (htab
->is_vxworks
)
5254 /* VxWorks uses RELA rather than REL dynamic relocations. */
5255 outrel
[0].r_addend
= *addendp
;
5256 bfd_elf32_swap_reloca_out
5257 (output_bfd
, &outrel
[0],
5259 + sreloc
->reloc_count
* sizeof (Elf32_External_Rela
)));
5262 bfd_elf32_swap_reloc_out
5263 (output_bfd
, &outrel
[0],
5264 (sreloc
->contents
+ sreloc
->reloc_count
* sizeof (Elf32_External_Rel
)));
5266 /* We've now added another relocation. */
5267 ++sreloc
->reloc_count
;
5269 /* Make sure the output section is writable. The dynamic linker
5270 will be writing to it. */
5271 elf_section_data (input_section
->output_section
)->this_hdr
.sh_flags
5274 /* On IRIX5, make an entry of compact relocation info. */
5275 if (IRIX_COMPAT (output_bfd
) == ict_irix5
)
5277 asection
*scpt
= bfd_get_section_by_name (dynobj
, ".compact_rel");
5282 Elf32_crinfo cptrel
;
5284 mips_elf_set_cr_format (cptrel
, CRF_MIPS_LONG
);
5285 cptrel
.vaddr
= (rel
->r_offset
5286 + input_section
->output_section
->vma
5287 + input_section
->output_offset
);
5288 if (r_type
== R_MIPS_REL32
)
5289 mips_elf_set_cr_type (cptrel
, CRT_MIPS_REL32
);
5291 mips_elf_set_cr_type (cptrel
, CRT_MIPS_WORD
);
5292 mips_elf_set_cr_dist2to (cptrel
, 0);
5293 cptrel
.konst
= *addendp
;
5295 cr
= (scpt
->contents
5296 + sizeof (Elf32_External_compact_rel
));
5297 mips_elf_set_cr_relvaddr (cptrel
, 0);
5298 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
5299 ((Elf32_External_crinfo
*) cr
5300 + scpt
->reloc_count
));
5301 ++scpt
->reloc_count
;
5305 /* If we've written this relocation for a readonly section,
5306 we need to set DF_TEXTREL again, so that we do not delete the
5308 if (MIPS_ELF_READONLY_SECTION (input_section
))
5309 info
->flags
|= DF_TEXTREL
;
5314 /* Return the MACH for a MIPS e_flags value. */
5317 _bfd_elf_mips_mach (flagword flags
)
5319 switch (flags
& EF_MIPS_MACH
)
5321 case E_MIPS_MACH_3900
:
5322 return bfd_mach_mips3900
;
5324 case E_MIPS_MACH_4010
:
5325 return bfd_mach_mips4010
;
5327 case E_MIPS_MACH_4100
:
5328 return bfd_mach_mips4100
;
5330 case E_MIPS_MACH_4111
:
5331 return bfd_mach_mips4111
;
5333 case E_MIPS_MACH_4120
:
5334 return bfd_mach_mips4120
;
5336 case E_MIPS_MACH_4650
:
5337 return bfd_mach_mips4650
;
5339 case E_MIPS_MACH_5400
:
5340 return bfd_mach_mips5400
;
5342 case E_MIPS_MACH_5500
:
5343 return bfd_mach_mips5500
;
5345 case E_MIPS_MACH_9000
:
5346 return bfd_mach_mips9000
;
5348 case E_MIPS_MACH_SB1
:
5349 return bfd_mach_mips_sb1
;
5351 case E_MIPS_MACH_LS2E
:
5352 return bfd_mach_mips_loongson_2e
;
5354 case E_MIPS_MACH_LS2F
:
5355 return bfd_mach_mips_loongson_2f
;
5357 case E_MIPS_MACH_OCTEON
:
5358 return bfd_mach_mips_octeon
;
5361 switch (flags
& EF_MIPS_ARCH
)
5365 return bfd_mach_mips3000
;
5368 return bfd_mach_mips6000
;
5371 return bfd_mach_mips4000
;
5374 return bfd_mach_mips8000
;
5377 return bfd_mach_mips5
;
5379 case E_MIPS_ARCH_32
:
5380 return bfd_mach_mipsisa32
;
5382 case E_MIPS_ARCH_64
:
5383 return bfd_mach_mipsisa64
;
5385 case E_MIPS_ARCH_32R2
:
5386 return bfd_mach_mipsisa32r2
;
5388 case E_MIPS_ARCH_64R2
:
5389 return bfd_mach_mipsisa64r2
;
5396 /* Return printable name for ABI. */
5398 static INLINE
char *
5399 elf_mips_abi_name (bfd
*abfd
)
5403 flags
= elf_elfheader (abfd
)->e_flags
;
5404 switch (flags
& EF_MIPS_ABI
)
5407 if (ABI_N32_P (abfd
))
5409 else if (ABI_64_P (abfd
))
5413 case E_MIPS_ABI_O32
:
5415 case E_MIPS_ABI_O64
:
5417 case E_MIPS_ABI_EABI32
:
5419 case E_MIPS_ABI_EABI64
:
5422 return "unknown abi";
5426 /* MIPS ELF uses two common sections. One is the usual one, and the
5427 other is for small objects. All the small objects are kept
5428 together, and then referenced via the gp pointer, which yields
5429 faster assembler code. This is what we use for the small common
5430 section. This approach is copied from ecoff.c. */
5431 static asection mips_elf_scom_section
;
5432 static asymbol mips_elf_scom_symbol
;
5433 static asymbol
*mips_elf_scom_symbol_ptr
;
5435 /* MIPS ELF also uses an acommon section, which represents an
5436 allocated common symbol which may be overridden by a
5437 definition in a shared library. */
5438 static asection mips_elf_acom_section
;
5439 static asymbol mips_elf_acom_symbol
;
5440 static asymbol
*mips_elf_acom_symbol_ptr
;
5442 /* This is used for both the 32-bit and the 64-bit ABI. */
5445 _bfd_mips_elf_symbol_processing (bfd
*abfd
, asymbol
*asym
)
5447 elf_symbol_type
*elfsym
;
5449 /* Handle the special MIPS section numbers that a symbol may use. */
5450 elfsym
= (elf_symbol_type
*) asym
;
5451 switch (elfsym
->internal_elf_sym
.st_shndx
)
5453 case SHN_MIPS_ACOMMON
:
5454 /* This section is used in a dynamically linked executable file.
5455 It is an allocated common section. The dynamic linker can
5456 either resolve these symbols to something in a shared
5457 library, or it can just leave them here. For our purposes,
5458 we can consider these symbols to be in a new section. */
5459 if (mips_elf_acom_section
.name
== NULL
)
5461 /* Initialize the acommon section. */
5462 mips_elf_acom_section
.name
= ".acommon";
5463 mips_elf_acom_section
.flags
= SEC_ALLOC
;
5464 mips_elf_acom_section
.output_section
= &mips_elf_acom_section
;
5465 mips_elf_acom_section
.symbol
= &mips_elf_acom_symbol
;
5466 mips_elf_acom_section
.symbol_ptr_ptr
= &mips_elf_acom_symbol_ptr
;
5467 mips_elf_acom_symbol
.name
= ".acommon";
5468 mips_elf_acom_symbol
.flags
= BSF_SECTION_SYM
;
5469 mips_elf_acom_symbol
.section
= &mips_elf_acom_section
;
5470 mips_elf_acom_symbol_ptr
= &mips_elf_acom_symbol
;
5472 asym
->section
= &mips_elf_acom_section
;
5476 /* Common symbols less than the GP size are automatically
5477 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
5478 if (asym
->value
> elf_gp_size (abfd
)
5479 || ELF_ST_TYPE (elfsym
->internal_elf_sym
.st_info
) == STT_TLS
5480 || IRIX_COMPAT (abfd
) == ict_irix6
)
5483 case SHN_MIPS_SCOMMON
:
5484 if (mips_elf_scom_section
.name
== NULL
)
5486 /* Initialize the small common section. */
5487 mips_elf_scom_section
.name
= ".scommon";
5488 mips_elf_scom_section
.flags
= SEC_IS_COMMON
;
5489 mips_elf_scom_section
.output_section
= &mips_elf_scom_section
;
5490 mips_elf_scom_section
.symbol
= &mips_elf_scom_symbol
;
5491 mips_elf_scom_section
.symbol_ptr_ptr
= &mips_elf_scom_symbol_ptr
;
5492 mips_elf_scom_symbol
.name
= ".scommon";
5493 mips_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
5494 mips_elf_scom_symbol
.section
= &mips_elf_scom_section
;
5495 mips_elf_scom_symbol_ptr
= &mips_elf_scom_symbol
;
5497 asym
->section
= &mips_elf_scom_section
;
5498 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
5501 case SHN_MIPS_SUNDEFINED
:
5502 asym
->section
= bfd_und_section_ptr
;
5507 asection
*section
= bfd_get_section_by_name (abfd
, ".text");
5509 BFD_ASSERT (SGI_COMPAT (abfd
));
5510 if (section
!= NULL
)
5512 asym
->section
= section
;
5513 /* MIPS_TEXT is a bit special, the address is not an offset
5514 to the base of the .text section. So substract the section
5515 base address to make it an offset. */
5516 asym
->value
-= section
->vma
;
5523 asection
*section
= bfd_get_section_by_name (abfd
, ".data");
5525 BFD_ASSERT (SGI_COMPAT (abfd
));
5526 if (section
!= NULL
)
5528 asym
->section
= section
;
5529 /* MIPS_DATA is a bit special, the address is not an offset
5530 to the base of the .data section. So substract the section
5531 base address to make it an offset. */
5532 asym
->value
-= section
->vma
;
5538 /* If this is an odd-valued function symbol, assume it's a MIPS16 one. */
5539 if (ELF_ST_TYPE (elfsym
->internal_elf_sym
.st_info
) == STT_FUNC
5540 && (asym
->value
& 1) != 0)
5543 elfsym
->internal_elf_sym
.st_other
5544 = ELF_ST_SET_MIPS16 (elfsym
->internal_elf_sym
.st_other
);
5548 /* Implement elf_backend_eh_frame_address_size. This differs from
5549 the default in the way it handles EABI64.
5551 EABI64 was originally specified as an LP64 ABI, and that is what
5552 -mabi=eabi normally gives on a 64-bit target. However, gcc has
5553 historically accepted the combination of -mabi=eabi and -mlong32,
5554 and this ILP32 variation has become semi-official over time.
5555 Both forms use elf32 and have pointer-sized FDE addresses.
5557 If an EABI object was generated by GCC 4.0 or above, it will have
5558 an empty .gcc_compiled_longXX section, where XX is the size of longs
5559 in bits. Unfortunately, ILP32 objects generated by earlier compilers
5560 have no special marking to distinguish them from LP64 objects.
5562 We don't want users of the official LP64 ABI to be punished for the
5563 existence of the ILP32 variant, but at the same time, we don't want
5564 to mistakenly interpret pre-4.0 ILP32 objects as being LP64 objects.
5565 We therefore take the following approach:
5567 - If ABFD contains a .gcc_compiled_longXX section, use it to
5568 determine the pointer size.
5570 - Otherwise check the type of the first relocation. Assume that
5571 the LP64 ABI is being used if the relocation is of type R_MIPS_64.
5575 The second check is enough to detect LP64 objects generated by pre-4.0
5576 compilers because, in the kind of output generated by those compilers,
5577 the first relocation will be associated with either a CIE personality
5578 routine or an FDE start address. Furthermore, the compilers never
5579 used a special (non-pointer) encoding for this ABI.
5581 Checking the relocation type should also be safe because there is no
5582 reason to use R_MIPS_64 in an ILP32 object. Pre-4.0 compilers never
5586 _bfd_mips_elf_eh_frame_address_size (bfd
*abfd
, asection
*sec
)
5588 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
5590 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
5592 bfd_boolean long32_p
, long64_p
;
5594 long32_p
= bfd_get_section_by_name (abfd
, ".gcc_compiled_long32") != 0;
5595 long64_p
= bfd_get_section_by_name (abfd
, ".gcc_compiled_long64") != 0;
5596 if (long32_p
&& long64_p
)
5603 if (sec
->reloc_count
> 0
5604 && elf_section_data (sec
)->relocs
!= NULL
5605 && (ELF32_R_TYPE (elf_section_data (sec
)->relocs
[0].r_info
)
5614 /* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
5615 relocations against two unnamed section symbols to resolve to the
5616 same address. For example, if we have code like:
5618 lw $4,%got_disp(.data)($gp)
5619 lw $25,%got_disp(.text)($gp)
5622 then the linker will resolve both relocations to .data and the program
5623 will jump there rather than to .text.
5625 We can work around this problem by giving names to local section symbols.
5626 This is also what the MIPSpro tools do. */
5629 _bfd_mips_elf_name_local_section_symbols (bfd
*abfd
)
5631 return SGI_COMPAT (abfd
);
5634 /* Work over a section just before writing it out. This routine is
5635 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
5636 sections that need the SHF_MIPS_GPREL flag by name; there has to be
5640 _bfd_mips_elf_section_processing (bfd
*abfd
, Elf_Internal_Shdr
*hdr
)
5642 if (hdr
->sh_type
== SHT_MIPS_REGINFO
5643 && hdr
->sh_size
> 0)
5647 BFD_ASSERT (hdr
->sh_size
== sizeof (Elf32_External_RegInfo
));
5648 BFD_ASSERT (hdr
->contents
== NULL
);
5651 hdr
->sh_offset
+ sizeof (Elf32_External_RegInfo
) - 4,
5654 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
5655 if (bfd_bwrite (buf
, 4, abfd
) != 4)
5659 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
5660 && hdr
->bfd_section
!= NULL
5661 && mips_elf_section_data (hdr
->bfd_section
) != NULL
5662 && mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
!= NULL
)
5664 bfd_byte
*contents
, *l
, *lend
;
5666 /* We stored the section contents in the tdata field in the
5667 set_section_contents routine. We save the section contents
5668 so that we don't have to read them again.
5669 At this point we know that elf_gp is set, so we can look
5670 through the section contents to see if there is an
5671 ODK_REGINFO structure. */
5673 contents
= mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
;
5675 lend
= contents
+ hdr
->sh_size
;
5676 while (l
+ sizeof (Elf_External_Options
) <= lend
)
5678 Elf_Internal_Options intopt
;
5680 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
5682 if (intopt
.size
< sizeof (Elf_External_Options
))
5684 (*_bfd_error_handler
)
5685 (_("%B: Warning: bad `%s' option size %u smaller than its header"),
5686 abfd
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
), intopt
.size
);
5689 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
5696 + sizeof (Elf_External_Options
)
5697 + (sizeof (Elf64_External_RegInfo
) - 8)),
5700 H_PUT_64 (abfd
, elf_gp (abfd
), buf
);
5701 if (bfd_bwrite (buf
, 8, abfd
) != 8)
5704 else if (intopt
.kind
== ODK_REGINFO
)
5711 + sizeof (Elf_External_Options
)
5712 + (sizeof (Elf32_External_RegInfo
) - 4)),
5715 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
5716 if (bfd_bwrite (buf
, 4, abfd
) != 4)
5723 if (hdr
->bfd_section
!= NULL
)
5725 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
5727 if (strcmp (name
, ".sdata") == 0
5728 || strcmp (name
, ".lit8") == 0
5729 || strcmp (name
, ".lit4") == 0)
5731 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
5732 hdr
->sh_type
= SHT_PROGBITS
;
5734 else if (strcmp (name
, ".sbss") == 0)
5736 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
5737 hdr
->sh_type
= SHT_NOBITS
;
5739 else if (strcmp (name
, ".srdata") == 0)
5741 hdr
->sh_flags
|= SHF_ALLOC
| SHF_MIPS_GPREL
;
5742 hdr
->sh_type
= SHT_PROGBITS
;
5744 else if (strcmp (name
, ".compact_rel") == 0)
5747 hdr
->sh_type
= SHT_PROGBITS
;
5749 else if (strcmp (name
, ".rtproc") == 0)
5751 if (hdr
->sh_addralign
!= 0 && hdr
->sh_entsize
== 0)
5753 unsigned int adjust
;
5755 adjust
= hdr
->sh_size
% hdr
->sh_addralign
;
5757 hdr
->sh_size
+= hdr
->sh_addralign
- adjust
;
5765 /* Handle a MIPS specific section when reading an object file. This
5766 is called when elfcode.h finds a section with an unknown type.
5767 This routine supports both the 32-bit and 64-bit ELF ABI.
5769 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
5773 _bfd_mips_elf_section_from_shdr (bfd
*abfd
,
5774 Elf_Internal_Shdr
*hdr
,
5780 /* There ought to be a place to keep ELF backend specific flags, but
5781 at the moment there isn't one. We just keep track of the
5782 sections by their name, instead. Fortunately, the ABI gives
5783 suggested names for all the MIPS specific sections, so we will
5784 probably get away with this. */
5785 switch (hdr
->sh_type
)
5787 case SHT_MIPS_LIBLIST
:
5788 if (strcmp (name
, ".liblist") != 0)
5792 if (strcmp (name
, ".msym") != 0)
5795 case SHT_MIPS_CONFLICT
:
5796 if (strcmp (name
, ".conflict") != 0)
5799 case SHT_MIPS_GPTAB
:
5800 if (! CONST_STRNEQ (name
, ".gptab."))
5803 case SHT_MIPS_UCODE
:
5804 if (strcmp (name
, ".ucode") != 0)
5807 case SHT_MIPS_DEBUG
:
5808 if (strcmp (name
, ".mdebug") != 0)
5810 flags
= SEC_DEBUGGING
;
5812 case SHT_MIPS_REGINFO
:
5813 if (strcmp (name
, ".reginfo") != 0
5814 || hdr
->sh_size
!= sizeof (Elf32_External_RegInfo
))
5816 flags
= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_SIZE
);
5818 case SHT_MIPS_IFACE
:
5819 if (strcmp (name
, ".MIPS.interfaces") != 0)
5822 case SHT_MIPS_CONTENT
:
5823 if (! CONST_STRNEQ (name
, ".MIPS.content"))
5826 case SHT_MIPS_OPTIONS
:
5827 if (!MIPS_ELF_OPTIONS_SECTION_NAME_P (name
))
5830 case SHT_MIPS_DWARF
:
5831 if (! CONST_STRNEQ (name
, ".debug_")
5832 && ! CONST_STRNEQ (name
, ".zdebug_"))
5835 case SHT_MIPS_SYMBOL_LIB
:
5836 if (strcmp (name
, ".MIPS.symlib") != 0)
5839 case SHT_MIPS_EVENTS
:
5840 if (! CONST_STRNEQ (name
, ".MIPS.events")
5841 && ! CONST_STRNEQ (name
, ".MIPS.post_rel"))
5848 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
5853 if (! bfd_set_section_flags (abfd
, hdr
->bfd_section
,
5854 (bfd_get_section_flags (abfd
,
5860 /* FIXME: We should record sh_info for a .gptab section. */
5862 /* For a .reginfo section, set the gp value in the tdata information
5863 from the contents of this section. We need the gp value while
5864 processing relocs, so we just get it now. The .reginfo section
5865 is not used in the 64-bit MIPS ELF ABI. */
5866 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
5868 Elf32_External_RegInfo ext
;
5871 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
,
5872 &ext
, 0, sizeof ext
))
5874 bfd_mips_elf32_swap_reginfo_in (abfd
, &ext
, &s
);
5875 elf_gp (abfd
) = s
.ri_gp_value
;
5878 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
5879 set the gp value based on what we find. We may see both
5880 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
5881 they should agree. */
5882 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
)
5884 bfd_byte
*contents
, *l
, *lend
;
5886 contents
= bfd_malloc (hdr
->sh_size
);
5887 if (contents
== NULL
)
5889 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
,
5896 lend
= contents
+ hdr
->sh_size
;
5897 while (l
+ sizeof (Elf_External_Options
) <= lend
)
5899 Elf_Internal_Options intopt
;
5901 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
5903 if (intopt
.size
< sizeof (Elf_External_Options
))
5905 (*_bfd_error_handler
)
5906 (_("%B: Warning: bad `%s' option size %u smaller than its header"),
5907 abfd
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
), intopt
.size
);
5910 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
5912 Elf64_Internal_RegInfo intreg
;
5914 bfd_mips_elf64_swap_reginfo_in
5916 ((Elf64_External_RegInfo
*)
5917 (l
+ sizeof (Elf_External_Options
))),
5919 elf_gp (abfd
) = intreg
.ri_gp_value
;
5921 else if (intopt
.kind
== ODK_REGINFO
)
5923 Elf32_RegInfo intreg
;
5925 bfd_mips_elf32_swap_reginfo_in
5927 ((Elf32_External_RegInfo
*)
5928 (l
+ sizeof (Elf_External_Options
))),
5930 elf_gp (abfd
) = intreg
.ri_gp_value
;
5940 /* Set the correct type for a MIPS ELF section. We do this by the
5941 section name, which is a hack, but ought to work. This routine is
5942 used by both the 32-bit and the 64-bit ABI. */
5945 _bfd_mips_elf_fake_sections (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*sec
)
5947 const char *name
= bfd_get_section_name (abfd
, sec
);
5949 if (strcmp (name
, ".liblist") == 0)
5951 hdr
->sh_type
= SHT_MIPS_LIBLIST
;
5952 hdr
->sh_info
= sec
->size
/ sizeof (Elf32_Lib
);
5953 /* The sh_link field is set in final_write_processing. */
5955 else if (strcmp (name
, ".conflict") == 0)
5956 hdr
->sh_type
= SHT_MIPS_CONFLICT
;
5957 else if (CONST_STRNEQ (name
, ".gptab."))
5959 hdr
->sh_type
= SHT_MIPS_GPTAB
;
5960 hdr
->sh_entsize
= sizeof (Elf32_External_gptab
);
5961 /* The sh_info field is set in final_write_processing. */
5963 else if (strcmp (name
, ".ucode") == 0)
5964 hdr
->sh_type
= SHT_MIPS_UCODE
;
5965 else if (strcmp (name
, ".mdebug") == 0)
5967 hdr
->sh_type
= SHT_MIPS_DEBUG
;
5968 /* In a shared object on IRIX 5.3, the .mdebug section has an
5969 entsize of 0. FIXME: Does this matter? */
5970 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
5971 hdr
->sh_entsize
= 0;
5973 hdr
->sh_entsize
= 1;
5975 else if (strcmp (name
, ".reginfo") == 0)
5977 hdr
->sh_type
= SHT_MIPS_REGINFO
;
5978 /* In a shared object on IRIX 5.3, the .reginfo section has an
5979 entsize of 0x18. FIXME: Does this matter? */
5980 if (SGI_COMPAT (abfd
))
5982 if ((abfd
->flags
& DYNAMIC
) != 0)
5983 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
5985 hdr
->sh_entsize
= 1;
5988 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
5990 else if (SGI_COMPAT (abfd
)
5991 && (strcmp (name
, ".hash") == 0
5992 || strcmp (name
, ".dynamic") == 0
5993 || strcmp (name
, ".dynstr") == 0))
5995 if (SGI_COMPAT (abfd
))
5996 hdr
->sh_entsize
= 0;
5998 /* This isn't how the IRIX6 linker behaves. */
5999 hdr
->sh_info
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
6002 else if (strcmp (name
, ".got") == 0
6003 || strcmp (name
, ".srdata") == 0
6004 || strcmp (name
, ".sdata") == 0
6005 || strcmp (name
, ".sbss") == 0
6006 || strcmp (name
, ".lit4") == 0
6007 || strcmp (name
, ".lit8") == 0)
6008 hdr
->sh_flags
|= SHF_MIPS_GPREL
;
6009 else if (strcmp (name
, ".MIPS.interfaces") == 0)
6011 hdr
->sh_type
= SHT_MIPS_IFACE
;
6012 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
6014 else if (CONST_STRNEQ (name
, ".MIPS.content"))
6016 hdr
->sh_type
= SHT_MIPS_CONTENT
;
6017 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
6018 /* The sh_info field is set in final_write_processing. */
6020 else if (MIPS_ELF_OPTIONS_SECTION_NAME_P (name
))
6022 hdr
->sh_type
= SHT_MIPS_OPTIONS
;
6023 hdr
->sh_entsize
= 1;
6024 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
6026 else if (CONST_STRNEQ (name
, ".debug_")
6027 || CONST_STRNEQ (name
, ".zdebug_"))
6029 hdr
->sh_type
= SHT_MIPS_DWARF
;
6031 /* Irix facilities such as libexc expect a single .debug_frame
6032 per executable, the system ones have NOSTRIP set and the linker
6033 doesn't merge sections with different flags so ... */
6034 if (SGI_COMPAT (abfd
) && CONST_STRNEQ (name
, ".debug_frame"))
6035 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
6037 else if (strcmp (name
, ".MIPS.symlib") == 0)
6039 hdr
->sh_type
= SHT_MIPS_SYMBOL_LIB
;
6040 /* The sh_link and sh_info fields are set in
6041 final_write_processing. */
6043 else if (CONST_STRNEQ (name
, ".MIPS.events")
6044 || CONST_STRNEQ (name
, ".MIPS.post_rel"))
6046 hdr
->sh_type
= SHT_MIPS_EVENTS
;
6047 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
6048 /* The sh_link field is set in final_write_processing. */
6050 else if (strcmp (name
, ".msym") == 0)
6052 hdr
->sh_type
= SHT_MIPS_MSYM
;
6053 hdr
->sh_flags
|= SHF_ALLOC
;
6054 hdr
->sh_entsize
= 8;
6057 /* The generic elf_fake_sections will set up REL_HDR using the default
6058 kind of relocations. We used to set up a second header for the
6059 non-default kind of relocations here, but only NewABI would use
6060 these, and the IRIX ld doesn't like resulting empty RELA sections.
6061 Thus we create those header only on demand now. */
6066 /* Given a BFD section, try to locate the corresponding ELF section
6067 index. This is used by both the 32-bit and the 64-bit ABI.
6068 Actually, it's not clear to me that the 64-bit ABI supports these,
6069 but for non-PIC objects we will certainly want support for at least
6070 the .scommon section. */
6073 _bfd_mips_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
6074 asection
*sec
, int *retval
)
6076 if (strcmp (bfd_get_section_name (abfd
, sec
), ".scommon") == 0)
6078 *retval
= SHN_MIPS_SCOMMON
;
6081 if (strcmp (bfd_get_section_name (abfd
, sec
), ".acommon") == 0)
6083 *retval
= SHN_MIPS_ACOMMON
;
6089 /* Hook called by the linker routine which adds symbols from an object
6090 file. We must handle the special MIPS section numbers here. */
6093 _bfd_mips_elf_add_symbol_hook (bfd
*abfd
, struct bfd_link_info
*info
,
6094 Elf_Internal_Sym
*sym
, const char **namep
,
6095 flagword
*flagsp ATTRIBUTE_UNUSED
,
6096 asection
**secp
, bfd_vma
*valp
)
6098 if (SGI_COMPAT (abfd
)
6099 && (abfd
->flags
& DYNAMIC
) != 0
6100 && strcmp (*namep
, "_rld_new_interface") == 0)
6102 /* Skip IRIX5 rld entry name. */
6107 /* Shared objects may have a dynamic symbol '_gp_disp' defined as
6108 a SECTION *ABS*. This causes ld to think it can resolve _gp_disp
6109 by setting a DT_NEEDED for the shared object. Since _gp_disp is
6110 a magic symbol resolved by the linker, we ignore this bogus definition
6111 of _gp_disp. New ABI objects do not suffer from this problem so this
6112 is not done for them. */
6114 && (sym
->st_shndx
== SHN_ABS
)
6115 && (strcmp (*namep
, "_gp_disp") == 0))
6121 switch (sym
->st_shndx
)
6124 /* Common symbols less than the GP size are automatically
6125 treated as SHN_MIPS_SCOMMON symbols. */
6126 if (sym
->st_size
> elf_gp_size (abfd
)
6127 || ELF_ST_TYPE (sym
->st_info
) == STT_TLS
6128 || IRIX_COMPAT (abfd
) == ict_irix6
)
6131 case SHN_MIPS_SCOMMON
:
6132 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
6133 (*secp
)->flags
|= SEC_IS_COMMON
;
6134 *valp
= sym
->st_size
;
6138 /* This section is used in a shared object. */
6139 if (elf_tdata (abfd
)->elf_text_section
== NULL
)
6141 asymbol
*elf_text_symbol
;
6142 asection
*elf_text_section
;
6143 bfd_size_type amt
= sizeof (asection
);
6145 elf_text_section
= bfd_zalloc (abfd
, amt
);
6146 if (elf_text_section
== NULL
)
6149 amt
= sizeof (asymbol
);
6150 elf_text_symbol
= bfd_zalloc (abfd
, amt
);
6151 if (elf_text_symbol
== NULL
)
6154 /* Initialize the section. */
6156 elf_tdata (abfd
)->elf_text_section
= elf_text_section
;
6157 elf_tdata (abfd
)->elf_text_symbol
= elf_text_symbol
;
6159 elf_text_section
->symbol
= elf_text_symbol
;
6160 elf_text_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_text_symbol
;
6162 elf_text_section
->name
= ".text";
6163 elf_text_section
->flags
= SEC_NO_FLAGS
;
6164 elf_text_section
->output_section
= NULL
;
6165 elf_text_section
->owner
= abfd
;
6166 elf_text_symbol
->name
= ".text";
6167 elf_text_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
6168 elf_text_symbol
->section
= elf_text_section
;
6170 /* This code used to do *secp = bfd_und_section_ptr if
6171 info->shared. I don't know why, and that doesn't make sense,
6172 so I took it out. */
6173 *secp
= elf_tdata (abfd
)->elf_text_section
;
6176 case SHN_MIPS_ACOMMON
:
6177 /* Fall through. XXX Can we treat this as allocated data? */
6179 /* This section is used in a shared object. */
6180 if (elf_tdata (abfd
)->elf_data_section
== NULL
)
6182 asymbol
*elf_data_symbol
;
6183 asection
*elf_data_section
;
6184 bfd_size_type amt
= sizeof (asection
);
6186 elf_data_section
= bfd_zalloc (abfd
, amt
);
6187 if (elf_data_section
== NULL
)
6190 amt
= sizeof (asymbol
);
6191 elf_data_symbol
= bfd_zalloc (abfd
, amt
);
6192 if (elf_data_symbol
== NULL
)
6195 /* Initialize the section. */
6197 elf_tdata (abfd
)->elf_data_section
= elf_data_section
;
6198 elf_tdata (abfd
)->elf_data_symbol
= elf_data_symbol
;
6200 elf_data_section
->symbol
= elf_data_symbol
;
6201 elf_data_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_data_symbol
;
6203 elf_data_section
->name
= ".data";
6204 elf_data_section
->flags
= SEC_NO_FLAGS
;
6205 elf_data_section
->output_section
= NULL
;
6206 elf_data_section
->owner
= abfd
;
6207 elf_data_symbol
->name
= ".data";
6208 elf_data_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
6209 elf_data_symbol
->section
= elf_data_section
;
6211 /* This code used to do *secp = bfd_und_section_ptr if
6212 info->shared. I don't know why, and that doesn't make sense,
6213 so I took it out. */
6214 *secp
= elf_tdata (abfd
)->elf_data_section
;
6217 case SHN_MIPS_SUNDEFINED
:
6218 *secp
= bfd_und_section_ptr
;
6222 if (SGI_COMPAT (abfd
)
6224 && info
->output_bfd
->xvec
== abfd
->xvec
6225 && strcmp (*namep
, "__rld_obj_head") == 0)
6227 struct elf_link_hash_entry
*h
;
6228 struct bfd_link_hash_entry
*bh
;
6230 /* Mark __rld_obj_head as dynamic. */
6232 if (! (_bfd_generic_link_add_one_symbol
6233 (info
, abfd
, *namep
, BSF_GLOBAL
, *secp
, *valp
, NULL
, FALSE
,
6234 get_elf_backend_data (abfd
)->collect
, &bh
)))
6237 h
= (struct elf_link_hash_entry
*) bh
;
6240 h
->type
= STT_OBJECT
;
6242 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
6245 mips_elf_hash_table (info
)->use_rld_obj_head
= TRUE
;
6248 /* If this is a mips16 text symbol, add 1 to the value to make it
6249 odd. This will cause something like .word SYM to come up with
6250 the right value when it is loaded into the PC. */
6251 if (ELF_ST_IS_MIPS16 (sym
->st_other
))
6257 /* This hook function is called before the linker writes out a global
6258 symbol. We mark symbols as small common if appropriate. This is
6259 also where we undo the increment of the value for a mips16 symbol. */
6262 _bfd_mips_elf_link_output_symbol_hook
6263 (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6264 const char *name ATTRIBUTE_UNUSED
, Elf_Internal_Sym
*sym
,
6265 asection
*input_sec
, struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
)
6267 /* If we see a common symbol, which implies a relocatable link, then
6268 if a symbol was small common in an input file, mark it as small
6269 common in the output file. */
6270 if (sym
->st_shndx
== SHN_COMMON
6271 && strcmp (input_sec
->name
, ".scommon") == 0)
6272 sym
->st_shndx
= SHN_MIPS_SCOMMON
;
6274 if (ELF_ST_IS_MIPS16 (sym
->st_other
))
6275 sym
->st_value
&= ~1;
6280 /* Functions for the dynamic linker. */
6282 /* Create dynamic sections when linking against a dynamic object. */
6285 _bfd_mips_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
6287 struct elf_link_hash_entry
*h
;
6288 struct bfd_link_hash_entry
*bh
;
6290 register asection
*s
;
6291 const char * const *namep
;
6292 struct mips_elf_link_hash_table
*htab
;
6294 htab
= mips_elf_hash_table (info
);
6295 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
6296 | SEC_LINKER_CREATED
| SEC_READONLY
);
6298 /* The psABI requires a read-only .dynamic section, but the VxWorks
6300 if (!htab
->is_vxworks
)
6302 s
= bfd_get_section_by_name (abfd
, ".dynamic");
6305 if (! bfd_set_section_flags (abfd
, s
, flags
))
6310 /* We need to create .got section. */
6311 if (! mips_elf_create_got_section (abfd
, info
, FALSE
))
6314 if (! mips_elf_rel_dyn_section (info
, TRUE
))
6317 /* Create .stub section. */
6318 s
= bfd_make_section_with_flags (abfd
,
6319 MIPS_ELF_STUB_SECTION_NAME (abfd
),
6322 || ! bfd_set_section_alignment (abfd
, s
,
6323 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
6327 if ((IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
6329 && bfd_get_section_by_name (abfd
, ".rld_map") == NULL
)
6331 s
= bfd_make_section_with_flags (abfd
, ".rld_map",
6332 flags
&~ (flagword
) SEC_READONLY
);
6334 || ! bfd_set_section_alignment (abfd
, s
,
6335 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
6339 /* On IRIX5, we adjust add some additional symbols and change the
6340 alignments of several sections. There is no ABI documentation
6341 indicating that this is necessary on IRIX6, nor any evidence that
6342 the linker takes such action. */
6343 if (IRIX_COMPAT (abfd
) == ict_irix5
)
6345 for (namep
= mips_elf_dynsym_rtproc_names
; *namep
!= NULL
; namep
++)
6348 if (! (_bfd_generic_link_add_one_symbol
6349 (info
, abfd
, *namep
, BSF_GLOBAL
, bfd_und_section_ptr
, 0,
6350 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
6353 h
= (struct elf_link_hash_entry
*) bh
;
6356 h
->type
= STT_SECTION
;
6358 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
6362 /* We need to create a .compact_rel section. */
6363 if (SGI_COMPAT (abfd
))
6365 if (!mips_elf_create_compact_rel_section (abfd
, info
))
6369 /* Change alignments of some sections. */
6370 s
= bfd_get_section_by_name (abfd
, ".hash");
6372 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
6373 s
= bfd_get_section_by_name (abfd
, ".dynsym");
6375 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
6376 s
= bfd_get_section_by_name (abfd
, ".dynstr");
6378 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
6379 s
= bfd_get_section_by_name (abfd
, ".reginfo");
6381 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
6382 s
= bfd_get_section_by_name (abfd
, ".dynamic");
6384 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
6391 name
= SGI_COMPAT (abfd
) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
6393 if (!(_bfd_generic_link_add_one_symbol
6394 (info
, abfd
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
, 0,
6395 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
6398 h
= (struct elf_link_hash_entry
*) bh
;
6401 h
->type
= STT_SECTION
;
6403 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
6406 if (! mips_elf_hash_table (info
)->use_rld_obj_head
)
6408 /* __rld_map is a four byte word located in the .data section
6409 and is filled in by the rtld to contain a pointer to
6410 the _r_debug structure. Its symbol value will be set in
6411 _bfd_mips_elf_finish_dynamic_symbol. */
6412 s
= bfd_get_section_by_name (abfd
, ".rld_map");
6413 BFD_ASSERT (s
!= NULL
);
6415 name
= SGI_COMPAT (abfd
) ? "__rld_map" : "__RLD_MAP";
6417 if (!(_bfd_generic_link_add_one_symbol
6418 (info
, abfd
, name
, BSF_GLOBAL
, s
, 0, NULL
, FALSE
,
6419 get_elf_backend_data (abfd
)->collect
, &bh
)))
6422 h
= (struct elf_link_hash_entry
*) bh
;
6425 h
->type
= STT_OBJECT
;
6427 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
6432 if (htab
->is_vxworks
)
6434 /* Create the .plt, .rela.plt, .dynbss and .rela.bss sections.
6435 Also create the _PROCEDURE_LINKAGE_TABLE symbol. */
6436 if (!_bfd_elf_create_dynamic_sections (abfd
, info
))
6439 /* Cache the sections created above. */
6440 htab
->sdynbss
= bfd_get_section_by_name (abfd
, ".dynbss");
6441 htab
->srelbss
= bfd_get_section_by_name (abfd
, ".rela.bss");
6442 htab
->srelplt
= bfd_get_section_by_name (abfd
, ".rela.plt");
6443 htab
->splt
= bfd_get_section_by_name (abfd
, ".plt");
6445 || (!htab
->srelbss
&& !info
->shared
)
6450 /* Do the usual VxWorks handling. */
6451 if (!elf_vxworks_create_dynamic_sections (abfd
, info
, &htab
->srelplt2
))
6454 /* Work out the PLT sizes. */
6457 htab
->plt_header_size
6458 = 4 * ARRAY_SIZE (mips_vxworks_shared_plt0_entry
);
6459 htab
->plt_entry_size
6460 = 4 * ARRAY_SIZE (mips_vxworks_shared_plt_entry
);
6464 htab
->plt_header_size
6465 = 4 * ARRAY_SIZE (mips_vxworks_exec_plt0_entry
);
6466 htab
->plt_entry_size
6467 = 4 * ARRAY_SIZE (mips_vxworks_exec_plt_entry
);
6474 /* Return true if relocation REL against section SEC is a REL rather than
6475 RELA relocation. RELOCS is the first relocation in the section and
6476 ABFD is the bfd that contains SEC. */
6479 mips_elf_rel_relocation_p (bfd
*abfd
, asection
*sec
,
6480 const Elf_Internal_Rela
*relocs
,
6481 const Elf_Internal_Rela
*rel
)
6483 Elf_Internal_Shdr
*rel_hdr
;
6484 const struct elf_backend_data
*bed
;
6486 /* To determine which flavor or relocation this is, we depend on the
6487 fact that the INPUT_SECTION's REL_HDR is read before its REL_HDR2. */
6488 rel_hdr
= &elf_section_data (sec
)->rel_hdr
;
6489 bed
= get_elf_backend_data (abfd
);
6490 if ((size_t) (rel
- relocs
)
6491 >= (NUM_SHDR_ENTRIES (rel_hdr
) * bed
->s
->int_rels_per_ext_rel
))
6492 rel_hdr
= elf_section_data (sec
)->rel_hdr2
;
6493 return rel_hdr
->sh_entsize
== MIPS_ELF_REL_SIZE (abfd
);
6496 /* Read the addend for REL relocation REL, which belongs to bfd ABFD.
6497 HOWTO is the relocation's howto and CONTENTS points to the contents
6498 of the section that REL is against. */
6501 mips_elf_read_rel_addend (bfd
*abfd
, const Elf_Internal_Rela
*rel
,
6502 reloc_howto_type
*howto
, bfd_byte
*contents
)
6505 unsigned int r_type
;
6508 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
6509 location
= contents
+ rel
->r_offset
;
6511 /* Get the addend, which is stored in the input file. */
6512 _bfd_mips16_elf_reloc_unshuffle (abfd
, r_type
, FALSE
, location
);
6513 addend
= mips_elf_obtain_contents (howto
, rel
, abfd
, contents
);
6514 _bfd_mips16_elf_reloc_shuffle (abfd
, r_type
, FALSE
, location
);
6516 return addend
& howto
->src_mask
;
6519 /* REL is a relocation in ABFD that needs a partnering LO16 relocation
6520 and *ADDEND is the addend for REL itself. Look for the LO16 relocation
6521 and update *ADDEND with the final addend. Return true on success
6522 or false if the LO16 could not be found. RELEND is the exclusive
6523 upper bound on the relocations for REL's section. */
6526 mips_elf_add_lo16_rel_addend (bfd
*abfd
,
6527 const Elf_Internal_Rela
*rel
,
6528 const Elf_Internal_Rela
*relend
,
6529 bfd_byte
*contents
, bfd_vma
*addend
)
6531 unsigned int r_type
, lo16_type
;
6532 const Elf_Internal_Rela
*lo16_relocation
;
6533 reloc_howto_type
*lo16_howto
;
6536 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
6537 if (mips16_reloc_p (r_type
))
6538 lo16_type
= R_MIPS16_LO16
;
6540 lo16_type
= R_MIPS_LO16
;
6542 /* The combined value is the sum of the HI16 addend, left-shifted by
6543 sixteen bits, and the LO16 addend, sign extended. (Usually, the
6544 code does a `lui' of the HI16 value, and then an `addiu' of the
6547 Scan ahead to find a matching LO16 relocation.
6549 According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must
6550 be immediately following. However, for the IRIX6 ABI, the next
6551 relocation may be a composed relocation consisting of several
6552 relocations for the same address. In that case, the R_MIPS_LO16
6553 relocation may occur as one of these. We permit a similar
6554 extension in general, as that is useful for GCC.
6556 In some cases GCC dead code elimination removes the LO16 but keeps
6557 the corresponding HI16. This is strictly speaking a violation of
6558 the ABI but not immediately harmful. */
6559 lo16_relocation
= mips_elf_next_relocation (abfd
, lo16_type
, rel
, relend
);
6560 if (lo16_relocation
== NULL
)
6563 /* Obtain the addend kept there. */
6564 lo16_howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, lo16_type
, FALSE
);
6565 l
= mips_elf_read_rel_addend (abfd
, lo16_relocation
, lo16_howto
, contents
);
6567 l
<<= lo16_howto
->rightshift
;
6568 l
= _bfd_mips_elf_sign_extend (l
, 16);
6575 /* Try to read the contents of section SEC in bfd ABFD. Return true and
6576 store the contents in *CONTENTS on success. Assume that *CONTENTS
6577 already holds the contents if it is nonull on entry. */
6580 mips_elf_get_section_contents (bfd
*abfd
, asection
*sec
, bfd_byte
**contents
)
6585 /* Get cached copy if it exists. */
6586 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
6588 *contents
= elf_section_data (sec
)->this_hdr
.contents
;
6592 return bfd_malloc_and_get_section (abfd
, sec
, contents
);
6595 /* Look through the relocs for a section during the first phase, and
6596 allocate space in the global offset table. */
6599 _bfd_mips_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
6600 asection
*sec
, const Elf_Internal_Rela
*relocs
)
6604 Elf_Internal_Shdr
*symtab_hdr
;
6605 struct elf_link_hash_entry
**sym_hashes
;
6607 const Elf_Internal_Rela
*rel
;
6608 const Elf_Internal_Rela
*rel_end
;
6610 const struct elf_backend_data
*bed
;
6611 struct mips_elf_link_hash_table
*htab
;
6614 reloc_howto_type
*howto
;
6616 if (info
->relocatable
)
6619 htab
= mips_elf_hash_table (info
);
6620 dynobj
= elf_hash_table (info
)->dynobj
;
6621 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
6622 sym_hashes
= elf_sym_hashes (abfd
);
6623 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
6625 bed
= get_elf_backend_data (abfd
);
6626 rel_end
= relocs
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
6628 /* Check for the mips16 stub sections. */
6630 name
= bfd_get_section_name (abfd
, sec
);
6631 if (FN_STUB_P (name
))
6633 unsigned long r_symndx
;
6635 /* Look at the relocation information to figure out which symbol
6638 r_symndx
= mips16_stub_symndx (sec
, relocs
, rel_end
);
6641 (*_bfd_error_handler
)
6642 (_("%B: Warning: cannot determine the target function for"
6643 " stub section `%s'"),
6645 bfd_set_error (bfd_error_bad_value
);
6649 if (r_symndx
< extsymoff
6650 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
6654 /* This stub is for a local symbol. This stub will only be
6655 needed if there is some relocation in this BFD, other
6656 than a 16 bit function call, which refers to this symbol. */
6657 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
6659 Elf_Internal_Rela
*sec_relocs
;
6660 const Elf_Internal_Rela
*r
, *rend
;
6662 /* We can ignore stub sections when looking for relocs. */
6663 if ((o
->flags
& SEC_RELOC
) == 0
6664 || o
->reloc_count
== 0
6665 || section_allows_mips16_refs_p (o
))
6669 = _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
6671 if (sec_relocs
== NULL
)
6674 rend
= sec_relocs
+ o
->reloc_count
;
6675 for (r
= sec_relocs
; r
< rend
; r
++)
6676 if (ELF_R_SYM (abfd
, r
->r_info
) == r_symndx
6677 && !mips16_call_reloc_p (ELF_R_TYPE (abfd
, r
->r_info
)))
6680 if (elf_section_data (o
)->relocs
!= sec_relocs
)
6689 /* There is no non-call reloc for this stub, so we do
6690 not need it. Since this function is called before
6691 the linker maps input sections to output sections, we
6692 can easily discard it by setting the SEC_EXCLUDE
6694 sec
->flags
|= SEC_EXCLUDE
;
6698 /* Record this stub in an array of local symbol stubs for
6700 if (elf_tdata (abfd
)->local_stubs
== NULL
)
6702 unsigned long symcount
;
6706 if (elf_bad_symtab (abfd
))
6707 symcount
= NUM_SHDR_ENTRIES (symtab_hdr
);
6709 symcount
= symtab_hdr
->sh_info
;
6710 amt
= symcount
* sizeof (asection
*);
6711 n
= bfd_zalloc (abfd
, amt
);
6714 elf_tdata (abfd
)->local_stubs
= n
;
6717 sec
->flags
|= SEC_KEEP
;
6718 elf_tdata (abfd
)->local_stubs
[r_symndx
] = sec
;
6720 /* We don't need to set mips16_stubs_seen in this case.
6721 That flag is used to see whether we need to look through
6722 the global symbol table for stubs. We don't need to set
6723 it here, because we just have a local stub. */
6727 struct mips_elf_link_hash_entry
*h
;
6729 h
= ((struct mips_elf_link_hash_entry
*)
6730 sym_hashes
[r_symndx
- extsymoff
]);
6732 while (h
->root
.root
.type
== bfd_link_hash_indirect
6733 || h
->root
.root
.type
== bfd_link_hash_warning
)
6734 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
6736 /* H is the symbol this stub is for. */
6738 /* If we already have an appropriate stub for this function, we
6739 don't need another one, so we can discard this one. Since
6740 this function is called before the linker maps input sections
6741 to output sections, we can easily discard it by setting the
6742 SEC_EXCLUDE flag. */
6743 if (h
->fn_stub
!= NULL
)
6745 sec
->flags
|= SEC_EXCLUDE
;
6749 sec
->flags
|= SEC_KEEP
;
6751 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
6754 else if (CALL_STUB_P (name
) || CALL_FP_STUB_P (name
))
6756 unsigned long r_symndx
;
6757 struct mips_elf_link_hash_entry
*h
;
6760 /* Look at the relocation information to figure out which symbol
6763 r_symndx
= mips16_stub_symndx (sec
, relocs
, rel_end
);
6766 (*_bfd_error_handler
)
6767 (_("%B: Warning: cannot determine the target function for"
6768 " stub section `%s'"),
6770 bfd_set_error (bfd_error_bad_value
);
6774 if (r_symndx
< extsymoff
6775 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
6779 /* This stub is for a local symbol. This stub will only be
6780 needed if there is some relocation (R_MIPS16_26) in this BFD
6781 that refers to this symbol. */
6782 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
6784 Elf_Internal_Rela
*sec_relocs
;
6785 const Elf_Internal_Rela
*r
, *rend
;
6787 /* We can ignore stub sections when looking for relocs. */
6788 if ((o
->flags
& SEC_RELOC
) == 0
6789 || o
->reloc_count
== 0
6790 || section_allows_mips16_refs_p (o
))
6794 = _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
6796 if (sec_relocs
== NULL
)
6799 rend
= sec_relocs
+ o
->reloc_count
;
6800 for (r
= sec_relocs
; r
< rend
; r
++)
6801 if (ELF_R_SYM (abfd
, r
->r_info
) == r_symndx
6802 && ELF_R_TYPE (abfd
, r
->r_info
) == R_MIPS16_26
)
6805 if (elf_section_data (o
)->relocs
!= sec_relocs
)
6814 /* There is no non-call reloc for this stub, so we do
6815 not need it. Since this function is called before
6816 the linker maps input sections to output sections, we
6817 can easily discard it by setting the SEC_EXCLUDE
6819 sec
->flags
|= SEC_EXCLUDE
;
6823 /* Record this stub in an array of local symbol call_stubs for
6825 if (elf_tdata (abfd
)->local_call_stubs
== NULL
)
6827 unsigned long symcount
;
6831 if (elf_bad_symtab (abfd
))
6832 symcount
= NUM_SHDR_ENTRIES (symtab_hdr
);
6834 symcount
= symtab_hdr
->sh_info
;
6835 amt
= symcount
* sizeof (asection
*);
6836 n
= bfd_zalloc (abfd
, amt
);
6839 elf_tdata (abfd
)->local_call_stubs
= n
;
6842 sec
->flags
|= SEC_KEEP
;
6843 elf_tdata (abfd
)->local_call_stubs
[r_symndx
] = sec
;
6845 /* We don't need to set mips16_stubs_seen in this case.
6846 That flag is used to see whether we need to look through
6847 the global symbol table for stubs. We don't need to set
6848 it here, because we just have a local stub. */
6852 h
= ((struct mips_elf_link_hash_entry
*)
6853 sym_hashes
[r_symndx
- extsymoff
]);
6855 /* H is the symbol this stub is for. */
6857 if (CALL_FP_STUB_P (name
))
6858 loc
= &h
->call_fp_stub
;
6860 loc
= &h
->call_stub
;
6862 /* If we already have an appropriate stub for this function, we
6863 don't need another one, so we can discard this one. Since
6864 this function is called before the linker maps input sections
6865 to output sections, we can easily discard it by setting the
6866 SEC_EXCLUDE flag. */
6869 sec
->flags
|= SEC_EXCLUDE
;
6873 sec
->flags
|= SEC_KEEP
;
6875 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
6881 for (rel
= relocs
; rel
< rel_end
; ++rel
)
6883 unsigned long r_symndx
;
6884 unsigned int r_type
;
6885 struct elf_link_hash_entry
*h
;
6887 r_symndx
= ELF_R_SYM (abfd
, rel
->r_info
);
6888 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
6890 if (r_symndx
< extsymoff
)
6892 else if (r_symndx
>= extsymoff
+ NUM_SHDR_ENTRIES (symtab_hdr
))
6894 (*_bfd_error_handler
)
6895 (_("%B: Malformed reloc detected for section %s"),
6897 bfd_set_error (bfd_error_bad_value
);
6902 h
= sym_hashes
[r_symndx
- extsymoff
];
6904 /* This may be an indirect symbol created because of a version. */
6907 while (h
->root
.type
== bfd_link_hash_indirect
)
6908 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
6912 /* Some relocs require a global offset table. */
6913 if (dynobj
== NULL
|| htab
->sgot
== NULL
)
6917 case R_MIPS16_GOT16
:
6918 case R_MIPS16_CALL16
:
6921 case R_MIPS_CALL_HI16
:
6922 case R_MIPS_CALL_LO16
:
6923 case R_MIPS_GOT_HI16
:
6924 case R_MIPS_GOT_LO16
:
6925 case R_MIPS_GOT_PAGE
:
6926 case R_MIPS_GOT_OFST
:
6927 case R_MIPS_GOT_DISP
:
6928 case R_MIPS_TLS_GOTTPREL
:
6930 case R_MIPS_TLS_LDM
:
6932 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
6933 if (! mips_elf_create_got_section (dynobj
, info
, FALSE
))
6935 if (htab
->is_vxworks
&& !info
->shared
)
6937 (*_bfd_error_handler
)
6938 (_("%B: GOT reloc at 0x%lx not expected in executables"),
6939 abfd
, (unsigned long) rel
->r_offset
);
6940 bfd_set_error (bfd_error_bad_value
);
6948 /* In VxWorks executables, references to external symbols
6949 are handled using copy relocs or PLT stubs, so there's
6950 no need to add a dynamic relocation here. */
6952 && (info
->shared
|| (h
!= NULL
&& !htab
->is_vxworks
))
6953 && (sec
->flags
& SEC_ALLOC
) != 0)
6954 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
6964 ((struct mips_elf_link_hash_entry
*) h
)->is_relocation_target
= TRUE
;
6966 /* Relocations against the special VxWorks __GOTT_BASE__ and
6967 __GOTT_INDEX__ symbols must be left to the loader. Allocate
6968 room for them in .rela.dyn. */
6969 if (is_gott_symbol (info
, h
))
6973 sreloc
= mips_elf_rel_dyn_section (info
, TRUE
);
6977 mips_elf_allocate_dynamic_relocations (dynobj
, info
, 1);
6978 if (MIPS_ELF_READONLY_SECTION (sec
))
6979 /* We tell the dynamic linker that there are
6980 relocations against the text segment. */
6981 info
->flags
|= DF_TEXTREL
;
6984 else if (r_type
== R_MIPS_CALL_LO16
6985 || r_type
== R_MIPS_GOT_LO16
6986 || r_type
== R_MIPS_GOT_DISP
6987 || (got16_reloc_p (r_type
) && htab
->is_vxworks
))
6989 /* We may need a local GOT entry for this relocation. We
6990 don't count R_MIPS_GOT_PAGE because we can estimate the
6991 maximum number of pages needed by looking at the size of
6992 the segment. Similar comments apply to R_MIPS*_GOT16 and
6993 R_MIPS*_CALL16, except on VxWorks, where GOT relocations
6994 always evaluate to "G". We don't count R_MIPS_GOT_HI16, or
6995 R_MIPS_CALL_HI16 because these are always followed by an
6996 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
6997 if (!mips_elf_record_local_got_symbol (abfd
, r_symndx
,
6998 rel
->r_addend
, info
, 0))
7005 case R_MIPS16_CALL16
:
7008 (*_bfd_error_handler
)
7009 (_("%B: CALL16 reloc at 0x%lx not against global symbol"),
7010 abfd
, (unsigned long) rel
->r_offset
);
7011 bfd_set_error (bfd_error_bad_value
);
7016 case R_MIPS_CALL_HI16
:
7017 case R_MIPS_CALL_LO16
:
7020 /* VxWorks call relocations point the function's .got.plt
7021 entry, which will be allocated by adjust_dynamic_symbol.
7022 Otherwise, this symbol requires a global GOT entry. */
7023 if ((!htab
->is_vxworks
|| h
->forced_local
)
7024 && !mips_elf_record_global_got_symbol (h
, abfd
, info
, 0))
7027 /* We need a stub, not a plt entry for the undefined
7028 function. But we record it as if it needs plt. See
7029 _bfd_elf_adjust_dynamic_symbol. */
7035 case R_MIPS_GOT_PAGE
:
7036 /* If this is a global, overridable symbol, GOT_PAGE will
7037 decay to GOT_DISP, so we'll need a GOT entry for it. */
7040 struct mips_elf_link_hash_entry
*hmips
=
7041 (struct mips_elf_link_hash_entry
*) h
;
7043 while (hmips
->root
.root
.type
== bfd_link_hash_indirect
7044 || hmips
->root
.root
.type
== bfd_link_hash_warning
)
7045 hmips
= (struct mips_elf_link_hash_entry
*)
7046 hmips
->root
.root
.u
.i
.link
;
7048 /* This symbol is definitely not overridable. */
7049 if (hmips
->root
.def_regular
7050 && ! (info
->shared
&& ! info
->symbolic
7051 && ! hmips
->root
.forced_local
))
7056 case R_MIPS16_GOT16
:
7058 case R_MIPS_GOT_HI16
:
7059 case R_MIPS_GOT_LO16
:
7060 if (!h
|| r_type
== R_MIPS_GOT_PAGE
)
7062 /* This relocation needs (or may need, if h != NULL) a
7063 page entry in the GOT. For R_MIPS_GOT_PAGE we do not
7064 know for sure until we know whether the symbol is
7066 if (mips_elf_rel_relocation_p (abfd
, sec
, relocs
, rel
))
7068 if (!mips_elf_get_section_contents (abfd
, sec
, &contents
))
7070 howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, r_type
, FALSE
);
7071 addend
= mips_elf_read_rel_addend (abfd
, rel
,
7073 if (r_type
== R_MIPS_GOT16
)
7074 mips_elf_add_lo16_rel_addend (abfd
, rel
, rel_end
,
7077 addend
<<= howto
->rightshift
;
7080 addend
= rel
->r_addend
;
7081 if (!mips_elf_record_got_page_entry (info
, abfd
, r_symndx
,
7088 case R_MIPS_GOT_DISP
:
7089 if (h
&& !mips_elf_record_global_got_symbol (h
, abfd
, info
, 0))
7093 case R_MIPS_TLS_GOTTPREL
:
7095 info
->flags
|= DF_STATIC_TLS
;
7098 case R_MIPS_TLS_LDM
:
7099 if (r_type
== R_MIPS_TLS_LDM
)
7107 /* This symbol requires a global offset table entry, or two
7108 for TLS GD relocations. */
7110 unsigned char flag
= (r_type
== R_MIPS_TLS_GD
7112 : r_type
== R_MIPS_TLS_LDM
7117 struct mips_elf_link_hash_entry
*hmips
=
7118 (struct mips_elf_link_hash_entry
*) h
;
7119 hmips
->tls_type
|= flag
;
7121 if (h
&& !mips_elf_record_global_got_symbol (h
, abfd
,
7127 BFD_ASSERT (flag
== GOT_TLS_LDM
|| r_symndx
!= 0);
7129 if (!mips_elf_record_local_got_symbol (abfd
, r_symndx
,
7140 /* In VxWorks executables, references to external symbols
7141 are handled using copy relocs or PLT stubs, so there's
7142 no need to add a .rela.dyn entry for this relocation. */
7143 if ((info
->shared
|| (h
!= NULL
&& !htab
->is_vxworks
))
7144 && !(h
&& strcmp (h
->root
.root
.string
, "__gnu_local_gp") == 0)
7145 && (sec
->flags
& SEC_ALLOC
) != 0)
7149 sreloc
= mips_elf_rel_dyn_section (info
, TRUE
);
7153 if (info
->shared
&& h
== NULL
)
7155 /* When creating a shared object, we must copy these
7156 reloc types into the output file as R_MIPS_REL32
7157 relocs. Make room for this reloc in .rel(a).dyn. */
7158 mips_elf_allocate_dynamic_relocations (dynobj
, info
, 1);
7159 if (MIPS_ELF_READONLY_SECTION (sec
))
7160 /* We tell the dynamic linker that there are
7161 relocations against the text segment. */
7162 info
->flags
|= DF_TEXTREL
;
7166 struct mips_elf_link_hash_entry
*hmips
;
7168 /* For a shared object, we must copy this relocation
7169 unless the symbol turns out to be undefined and
7170 weak with non-default visibility, in which case
7171 it will be left as zero.
7173 We could elide R_MIPS_REL32 for locally binding symbols
7174 in shared libraries, but do not yet do so.
7176 For an executable, we only need to copy this
7177 reloc if the symbol is defined in a dynamic
7179 hmips
= (struct mips_elf_link_hash_entry
*) h
;
7180 ++hmips
->possibly_dynamic_relocs
;
7181 if (MIPS_ELF_READONLY_SECTION (sec
))
7182 /* We need it to tell the dynamic linker if there
7183 are relocations against the text segment. */
7184 hmips
->readonly_reloc
= TRUE
;
7187 /* Even though we don't directly need a GOT entry for
7188 this symbol, a symbol must have a dynamic symbol
7189 table index greater that DT_MIPS_GOTSYM if there are
7190 dynamic relocations against it. This does not apply
7191 to VxWorks, which does not have the usual coupling
7192 between global GOT entries and .dynsym entries. */
7193 if (h
!= NULL
&& !htab
->is_vxworks
)
7196 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
7197 if (! mips_elf_create_got_section (dynobj
, info
, TRUE
))
7199 if (!mips_elf_record_global_got_symbol (h
, abfd
, info
, 0))
7204 if (SGI_COMPAT (abfd
))
7205 mips_elf_hash_table (info
)->compact_rel_size
+=
7206 sizeof (Elf32_External_crinfo
);
7211 ((struct mips_elf_link_hash_entry
*) h
)->is_branch_target
= TRUE
;
7216 ((struct mips_elf_link_hash_entry
*) h
)->is_branch_target
= TRUE
;
7219 case R_MIPS_GPREL16
:
7220 case R_MIPS_LITERAL
:
7221 case R_MIPS_GPREL32
:
7222 if (SGI_COMPAT (abfd
))
7223 mips_elf_hash_table (info
)->compact_rel_size
+=
7224 sizeof (Elf32_External_crinfo
);
7227 /* This relocation describes the C++ object vtable hierarchy.
7228 Reconstruct it for later use during GC. */
7229 case R_MIPS_GNU_VTINHERIT
:
7230 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
7234 /* This relocation describes which C++ vtable entries are actually
7235 used. Record for later use during GC. */
7236 case R_MIPS_GNU_VTENTRY
:
7237 BFD_ASSERT (h
!= NULL
);
7239 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
7247 /* We must not create a stub for a symbol that has relocations
7248 related to taking the function's address. This doesn't apply to
7249 VxWorks, where CALL relocs refer to a .got.plt entry instead of
7250 a normal .got entry. */
7251 if (!htab
->is_vxworks
&& h
!= NULL
)
7255 ((struct mips_elf_link_hash_entry
*) h
)->no_fn_stub
= TRUE
;
7257 case R_MIPS16_CALL16
:
7259 case R_MIPS_CALL_HI16
:
7260 case R_MIPS_CALL_LO16
:
7265 /* See if this reloc would need to refer to a MIPS16 hard-float stub,
7266 if there is one. We only need to handle global symbols here;
7267 we decide whether to keep or delete stubs for local symbols
7268 when processing the stub's relocations. */
7270 && !mips16_call_reloc_p (r_type
)
7271 && !section_allows_mips16_refs_p (sec
))
7273 struct mips_elf_link_hash_entry
*mh
;
7275 mh
= (struct mips_elf_link_hash_entry
*) h
;
7276 mh
->need_fn_stub
= TRUE
;
7284 _bfd_mips_relax_section (bfd
*abfd
, asection
*sec
,
7285 struct bfd_link_info
*link_info
,
7288 Elf_Internal_Rela
*internal_relocs
;
7289 Elf_Internal_Rela
*irel
, *irelend
;
7290 Elf_Internal_Shdr
*symtab_hdr
;
7291 bfd_byte
*contents
= NULL
;
7293 bfd_boolean changed_contents
= FALSE
;
7294 bfd_vma sec_start
= sec
->output_section
->vma
+ sec
->output_offset
;
7295 Elf_Internal_Sym
*isymbuf
= NULL
;
7297 /* We are not currently changing any sizes, so only one pass. */
7300 if (link_info
->relocatable
)
7303 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
7304 link_info
->keep_memory
);
7305 if (internal_relocs
== NULL
)
7308 irelend
= internal_relocs
+ sec
->reloc_count
7309 * get_elf_backend_data (abfd
)->s
->int_rels_per_ext_rel
;
7310 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7311 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
7313 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
7316 bfd_signed_vma sym_offset
;
7317 unsigned int r_type
;
7318 unsigned long r_symndx
;
7320 unsigned long instruction
;
7322 /* Turn jalr into bgezal, and jr into beq, if they're marked
7323 with a JALR relocation, that indicate where they jump to.
7324 This saves some pipeline bubbles. */
7325 r_type
= ELF_R_TYPE (abfd
, irel
->r_info
);
7326 if (r_type
!= R_MIPS_JALR
)
7329 r_symndx
= ELF_R_SYM (abfd
, irel
->r_info
);
7330 /* Compute the address of the jump target. */
7331 if (r_symndx
>= extsymoff
)
7333 struct mips_elf_link_hash_entry
*h
7334 = ((struct mips_elf_link_hash_entry
*)
7335 elf_sym_hashes (abfd
) [r_symndx
- extsymoff
]);
7337 while (h
->root
.root
.type
== bfd_link_hash_indirect
7338 || h
->root
.root
.type
== bfd_link_hash_warning
)
7339 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
7341 /* If a symbol is undefined, or if it may be overridden,
7343 if (! ((h
->root
.root
.type
== bfd_link_hash_defined
7344 || h
->root
.root
.type
== bfd_link_hash_defweak
)
7345 && h
->root
.root
.u
.def
.section
)
7346 || (link_info
->shared
&& ! link_info
->symbolic
7347 && !h
->root
.forced_local
))
7350 sym_sec
= h
->root
.root
.u
.def
.section
;
7351 if (sym_sec
->output_section
)
7352 symval
= (h
->root
.root
.u
.def
.value
7353 + sym_sec
->output_section
->vma
7354 + sym_sec
->output_offset
);
7356 symval
= h
->root
.root
.u
.def
.value
;
7360 Elf_Internal_Sym
*isym
;
7362 /* Read this BFD's symbols if we haven't done so already. */
7363 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
7365 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
7366 if (isymbuf
== NULL
)
7367 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
7368 symtab_hdr
->sh_info
, 0,
7370 if (isymbuf
== NULL
)
7374 isym
= isymbuf
+ r_symndx
;
7375 if (isym
->st_shndx
== SHN_UNDEF
)
7377 else if (isym
->st_shndx
== SHN_ABS
)
7378 sym_sec
= bfd_abs_section_ptr
;
7379 else if (isym
->st_shndx
== SHN_COMMON
)
7380 sym_sec
= bfd_com_section_ptr
;
7383 = bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
7384 symval
= isym
->st_value
7385 + sym_sec
->output_section
->vma
7386 + sym_sec
->output_offset
;
7389 /* Compute branch offset, from delay slot of the jump to the
7391 sym_offset
= (symval
+ irel
->r_addend
)
7392 - (sec_start
+ irel
->r_offset
+ 4);
7394 /* Branch offset must be properly aligned. */
7395 if ((sym_offset
& 3) != 0)
7400 /* Check that it's in range. */
7401 if (sym_offset
< -0x8000 || sym_offset
>= 0x8000)
7404 /* Get the section contents if we haven't done so already. */
7405 if (!mips_elf_get_section_contents (abfd
, sec
, &contents
))
7408 instruction
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
7410 /* If it was jalr <reg>, turn it into bgezal $zero, <target>. */
7411 if ((instruction
& 0xfc1fffff) == 0x0000f809)
7412 instruction
= 0x04110000;
7413 /* If it was jr <reg>, turn it into b <target>. */
7414 else if ((instruction
& 0xfc1fffff) == 0x00000008)
7415 instruction
= 0x10000000;
7419 instruction
|= (sym_offset
& 0xffff);
7420 bfd_put_32 (abfd
, instruction
, contents
+ irel
->r_offset
);
7421 changed_contents
= TRUE
;
7424 if (contents
!= NULL
7425 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
7427 if (!changed_contents
&& !link_info
->keep_memory
)
7431 /* Cache the section contents for elf_link_input_bfd. */
7432 elf_section_data (sec
)->this_hdr
.contents
= contents
;
7438 if (contents
!= NULL
7439 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
7444 /* Allocate space for global sym dynamic relocs. */
7447 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
7449 struct bfd_link_info
*info
= inf
;
7451 struct mips_elf_link_hash_entry
*hmips
;
7452 struct mips_elf_link_hash_table
*htab
;
7454 htab
= mips_elf_hash_table (info
);
7455 dynobj
= elf_hash_table (info
)->dynobj
;
7456 hmips
= (struct mips_elf_link_hash_entry
*) h
;
7458 /* VxWorks executables are handled elsewhere; we only need to
7459 allocate relocations in shared objects. */
7460 if (htab
->is_vxworks
&& !info
->shared
)
7463 /* If this symbol is defined in a dynamic object, or we are creating
7464 a shared library, we will need to copy any R_MIPS_32 or
7465 R_MIPS_REL32 relocs against it into the output file. */
7466 if (! info
->relocatable
7467 && hmips
->possibly_dynamic_relocs
!= 0
7468 && (h
->root
.type
== bfd_link_hash_defweak
7472 bfd_boolean do_copy
= TRUE
;
7474 if (h
->root
.type
== bfd_link_hash_undefweak
)
7476 /* Do not copy relocations for undefined weak symbols with
7477 non-default visibility. */
7478 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
7481 /* Make sure undefined weak symbols are output as a dynamic
7483 else if (h
->dynindx
== -1 && !h
->forced_local
)
7485 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
7492 mips_elf_allocate_dynamic_relocations
7493 (dynobj
, info
, hmips
->possibly_dynamic_relocs
);
7494 if (hmips
->readonly_reloc
)
7495 /* We tell the dynamic linker that there are relocations
7496 against the text segment. */
7497 info
->flags
|= DF_TEXTREL
;
7504 /* Adjust a symbol defined by a dynamic object and referenced by a
7505 regular object. The current definition is in some section of the
7506 dynamic object, but we're not including those sections. We have to
7507 change the definition to something the rest of the link can
7511 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
7512 struct elf_link_hash_entry
*h
)
7515 struct mips_elf_link_hash_entry
*hmips
;
7516 struct mips_elf_link_hash_table
*htab
;
7518 htab
= mips_elf_hash_table (info
);
7519 dynobj
= elf_hash_table (info
)->dynobj
;
7521 /* Make sure we know what is going on here. */
7522 BFD_ASSERT (dynobj
!= NULL
7524 || h
->u
.weakdef
!= NULL
7527 && !h
->def_regular
)));
7529 hmips
= (struct mips_elf_link_hash_entry
*) h
;
7531 /* For a function, create a stub, if allowed. */
7532 if (! hmips
->no_fn_stub
7535 if (! elf_hash_table (info
)->dynamic_sections_created
)
7538 /* If this symbol is not defined in a regular file, then set
7539 the symbol to the stub location. This is required to make
7540 function pointers compare as equal between the normal
7541 executable and the shared library. */
7542 if (!h
->def_regular
)
7544 /* We need .stub section. */
7545 h
->root
.u
.def
.section
= htab
->sstubs
;
7546 h
->root
.u
.def
.value
= htab
->sstubs
->size
;
7548 /* XXX Write this stub address somewhere. */
7549 h
->plt
.offset
= htab
->sstubs
->size
;
7551 /* Make room for this stub code. */
7552 htab
->sstubs
->size
+= htab
->function_stub_size
;
7554 /* The last half word of the stub will be filled with the index
7555 of this symbol in .dynsym section. */
7559 else if ((h
->type
== STT_FUNC
)
7562 /* This will set the entry for this symbol in the GOT to 0, and
7563 the dynamic linker will take care of this. */
7564 h
->root
.u
.def
.value
= 0;
7568 /* If this is a weak symbol, and there is a real definition, the
7569 processor independent code will have arranged for us to see the
7570 real definition first, and we can just use the same value. */
7571 if (h
->u
.weakdef
!= NULL
)
7573 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
7574 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
7575 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
7576 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
7580 /* This is a reference to a symbol defined by a dynamic object which
7581 is not a function. */
7586 /* Likewise, for VxWorks. */
7589 _bfd_mips_vxworks_adjust_dynamic_symbol (struct bfd_link_info
*info
,
7590 struct elf_link_hash_entry
*h
)
7593 struct mips_elf_link_hash_entry
*hmips
;
7594 struct mips_elf_link_hash_table
*htab
;
7596 htab
= mips_elf_hash_table (info
);
7597 dynobj
= elf_hash_table (info
)->dynobj
;
7598 hmips
= (struct mips_elf_link_hash_entry
*) h
;
7600 /* Make sure we know what is going on here. */
7601 BFD_ASSERT (dynobj
!= NULL
7604 || h
->u
.weakdef
!= NULL
7607 && !h
->def_regular
)));
7609 /* If the symbol is defined by a dynamic object, we need a PLT stub if
7610 either (a) we want to branch to the symbol or (b) we're linking an
7611 executable that needs a canonical function address. In the latter
7612 case, the canonical address will be the address of the executable's
7614 if ((hmips
->is_branch_target
7616 && h
->type
== STT_FUNC
7617 && hmips
->is_relocation_target
))
7621 && !h
->forced_local
)
7624 /* Locally-binding symbols do not need a PLT stub; we can refer to
7625 the functions directly. */
7626 else if (h
->needs_plt
7627 && (SYMBOL_CALLS_LOCAL (info
, h
)
7628 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
7629 && h
->root
.type
== bfd_link_hash_undefweak
)))
7637 /* If this is the first symbol to need a PLT entry, allocate room
7638 for the header, and for the header's .rela.plt.unloaded entries. */
7639 if (htab
->splt
->size
== 0)
7641 htab
->splt
->size
+= htab
->plt_header_size
;
7643 htab
->srelplt2
->size
+= 2 * sizeof (Elf32_External_Rela
);
7646 /* Assign the next .plt entry to this symbol. */
7647 h
->plt
.offset
= htab
->splt
->size
;
7648 htab
->splt
->size
+= htab
->plt_entry_size
;
7650 /* If the output file has no definition of the symbol, set the
7651 symbol's value to the address of the stub. Point at the PLT
7652 load stub rather than the lazy resolution stub; this stub
7653 will become the canonical function address. */
7654 if (!info
->shared
&& !h
->def_regular
)
7656 h
->root
.u
.def
.section
= htab
->splt
;
7657 h
->root
.u
.def
.value
= h
->plt
.offset
;
7658 h
->root
.u
.def
.value
+= 8;
7661 /* Make room for the .got.plt entry and the R_JUMP_SLOT relocation. */
7662 htab
->sgotplt
->size
+= 4;
7663 htab
->srelplt
->size
+= sizeof (Elf32_External_Rela
);
7665 /* Make room for the .rela.plt.unloaded relocations. */
7667 htab
->srelplt2
->size
+= 3 * sizeof (Elf32_External_Rela
);
7672 /* If a function symbol is defined by a dynamic object, and we do not
7673 need a PLT stub for it, the symbol's value should be zero. */
7674 if (h
->type
== STT_FUNC
7679 h
->root
.u
.def
.value
= 0;
7683 /* If this is a weak symbol, and there is a real definition, the
7684 processor independent code will have arranged for us to see the
7685 real definition first, and we can just use the same value. */
7686 if (h
->u
.weakdef
!= NULL
)
7688 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
7689 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
7690 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
7691 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
7695 /* This is a reference to a symbol defined by a dynamic object which
7696 is not a function. */
7700 /* We must allocate the symbol in our .dynbss section, which will
7701 become part of the .bss section of the executable. There will be
7702 an entry for this symbol in the .dynsym section. The dynamic
7703 object will contain position independent code, so all references
7704 from the dynamic object to this symbol will go through the global
7705 offset table. The dynamic linker will use the .dynsym entry to
7706 determine the address it must put in the global offset table, so
7707 both the dynamic object and the regular object will refer to the
7708 same memory location for the variable. */
7710 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
7712 htab
->srelbss
->size
+= sizeof (Elf32_External_Rela
);
7716 return _bfd_elf_adjust_dynamic_copy (h
, htab
->sdynbss
);
7719 /* Return the number of dynamic section symbols required by OUTPUT_BFD.
7720 The number might be exact or a worst-case estimate, depending on how
7721 much information is available to elf_backend_omit_section_dynsym at
7722 the current linking stage. */
7724 static bfd_size_type
7725 count_section_dynsyms (bfd
*output_bfd
, struct bfd_link_info
*info
)
7727 bfd_size_type count
;
7730 if (info
->shared
|| elf_hash_table (info
)->is_relocatable_executable
)
7733 const struct elf_backend_data
*bed
;
7735 bed
= get_elf_backend_data (output_bfd
);
7736 for (p
= output_bfd
->sections
; p
; p
= p
->next
)
7737 if ((p
->flags
& SEC_EXCLUDE
) == 0
7738 && (p
->flags
& SEC_ALLOC
) != 0
7739 && !(*bed
->elf_backend_omit_section_dynsym
) (output_bfd
, info
, p
))
7745 /* This function is called after all the input files have been read,
7746 and the input sections have been assigned to output sections. We
7747 check for any mips16 stub sections that we can discard. */
7750 _bfd_mips_elf_always_size_sections (bfd
*output_bfd
,
7751 struct bfd_link_info
*info
)
7756 struct mips_got_info
*g
;
7758 bfd_size_type loadable_size
= 0;
7759 bfd_size_type page_gotno
;
7760 bfd_size_type dynsymcount
;
7762 struct mips_elf_count_tls_arg count_tls_arg
;
7763 struct mips_elf_link_hash_table
*htab
;
7765 htab
= mips_elf_hash_table (info
);
7767 /* The .reginfo section has a fixed size. */
7768 ri
= bfd_get_section_by_name (output_bfd
, ".reginfo");
7770 bfd_set_section_size (output_bfd
, ri
, sizeof (Elf32_External_RegInfo
));
7772 if (! (info
->relocatable
7773 || ! mips_elf_hash_table (info
)->mips16_stubs_seen
))
7774 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
7775 mips_elf_check_mips16_stubs
, info
);
7783 /* Calculate the total loadable size of the output. That
7784 will give us the maximum number of GOT_PAGE entries
7786 for (sub
= info
->input_bfds
; sub
; sub
= sub
->link_next
)
7788 asection
*subsection
;
7790 for (subsection
= sub
->sections
;
7792 subsection
= subsection
->next
)
7794 if ((subsection
->flags
& SEC_ALLOC
) == 0)
7796 loadable_size
+= ((subsection
->size
+ 0xf)
7797 &~ (bfd_size_type
) 0xf);
7801 /* There has to be a global GOT entry for every symbol with
7802 a dynamic symbol table index of DT_MIPS_GOTSYM or
7803 higher. Therefore, it make sense to put those symbols
7804 that need GOT entries at the end of the symbol table. We
7806 if (! mips_elf_sort_hash_table (info
, 1))
7809 if (g
->global_gotsym
!= NULL
)
7810 i
= elf_hash_table (info
)->dynsymcount
- g
->global_gotsym
->dynindx
;
7812 /* If there are no global symbols, or none requiring
7813 relocations, then GLOBAL_GOTSYM will be NULL. */
7816 /* Get a worst-case estimate of the number of dynamic symbols needed.
7817 At this point, dynsymcount does not account for section symbols
7818 and count_section_dynsyms may overestimate the number that will
7820 dynsymcount
= (elf_hash_table (info
)->dynsymcount
7821 + count_section_dynsyms (output_bfd
, info
));
7823 /* Determine the size of one stub entry. */
7824 htab
->function_stub_size
= (dynsymcount
> 0x10000
7825 ? MIPS_FUNCTION_STUB_BIG_SIZE
7826 : MIPS_FUNCTION_STUB_NORMAL_SIZE
);
7828 /* In the worst case, we'll get one stub per dynamic symbol, plus
7829 one to account for the dummy entry at the end required by IRIX
7831 loadable_size
+= htab
->function_stub_size
* (i
+ 1);
7833 if (htab
->is_vxworks
)
7834 /* There's no need to allocate page entries for VxWorks; R_MIPS*_GOT16
7835 relocations against local symbols evaluate to "G", and the EABI does
7836 not include R_MIPS_GOT_PAGE. */
7839 /* Assume there are two loadable segments consisting of contiguous
7840 sections. Is 5 enough? */
7841 page_gotno
= (loadable_size
>> 16) + 5;
7843 /* Choose the smaller of the two estimates; both are intended to be
7845 if (page_gotno
> g
->page_gotno
)
7846 page_gotno
= g
->page_gotno
;
7848 g
->local_gotno
+= page_gotno
;
7849 s
->size
+= g
->local_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
7851 g
->global_gotno
= i
;
7852 s
->size
+= i
* MIPS_ELF_GOT_SIZE (output_bfd
);
7854 /* We need to calculate tls_gotno for global symbols at this point
7855 instead of building it up earlier, to avoid doublecounting
7856 entries for one global symbol from multiple input files. */
7857 count_tls_arg
.info
= info
;
7858 count_tls_arg
.needed
= 0;
7859 elf_link_hash_traverse (elf_hash_table (info
),
7860 mips_elf_count_global_tls_entries
,
7862 g
->tls_gotno
+= count_tls_arg
.needed
;
7863 s
->size
+= g
->tls_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
7865 mips_elf_resolve_final_got_entries (g
);
7867 /* VxWorks does not support multiple GOTs. It initializes $gp to
7868 __GOTT_BASE__[__GOTT_INDEX__], the value of which is set by the
7870 if (!htab
->is_vxworks
&& s
->size
> MIPS_ELF_GOT_MAX_SIZE (info
))
7872 if (!mips_elf_multi_got (output_bfd
, info
, s
, page_gotno
))
7877 /* Set up TLS entries for the first GOT. */
7878 g
->tls_assigned_gotno
= g
->global_gotno
+ g
->local_gotno
;
7879 htab_traverse (g
->got_entries
, mips_elf_initialize_tls_index
, g
);
7881 htab
->computed_got_sizes
= TRUE
;
7886 /* Set the sizes of the dynamic sections. */
7889 _bfd_mips_elf_size_dynamic_sections (bfd
*output_bfd
,
7890 struct bfd_link_info
*info
)
7893 asection
*s
, *sreldyn
;
7894 bfd_boolean reltext
;
7895 struct mips_elf_link_hash_table
*htab
;
7897 htab
= mips_elf_hash_table (info
);
7898 dynobj
= elf_hash_table (info
)->dynobj
;
7899 BFD_ASSERT (dynobj
!= NULL
);
7901 if (elf_hash_table (info
)->dynamic_sections_created
)
7903 /* Set the contents of the .interp section to the interpreter. */
7904 if (info
->executable
)
7906 s
= bfd_get_section_by_name (dynobj
, ".interp");
7907 BFD_ASSERT (s
!= NULL
);
7909 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd
)) + 1;
7911 = (bfd_byte
*) ELF_DYNAMIC_INTERPRETER (output_bfd
);
7915 /* IRIX rld assumes that the function stub isn't at the end
7916 of the .text section, so add a dummy entry to the end. */
7917 if (htab
->sstubs
&& htab
->sstubs
->size
> 0)
7918 htab
->sstubs
->size
+= htab
->function_stub_size
;
7920 /* Allocate space for global sym dynamic relocs. */
7921 elf_link_hash_traverse (&htab
->root
, allocate_dynrelocs
, (PTR
) info
);
7923 /* The check_relocs and adjust_dynamic_symbol entry points have
7924 determined the sizes of the various dynamic sections. Allocate
7928 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
7932 /* It's OK to base decisions on the section name, because none
7933 of the dynobj section names depend upon the input files. */
7934 name
= bfd_get_section_name (dynobj
, s
);
7936 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
7939 if (CONST_STRNEQ (name
, ".rel"))
7943 const char *outname
;
7946 /* If this relocation section applies to a read only
7947 section, then we probably need a DT_TEXTREL entry.
7948 If the relocation section is .rel(a).dyn, we always
7949 assert a DT_TEXTREL entry rather than testing whether
7950 there exists a relocation to a read only section or
7952 outname
= bfd_get_section_name (output_bfd
,
7954 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
7956 && (target
->flags
& SEC_READONLY
) != 0
7957 && (target
->flags
& SEC_ALLOC
) != 0)
7958 || strcmp (outname
, MIPS_ELF_REL_DYN_NAME (info
)) == 0)
7961 /* We use the reloc_count field as a counter if we need
7962 to copy relocs into the output file. */
7963 if (strcmp (name
, MIPS_ELF_REL_DYN_NAME (info
)) != 0)
7966 /* If combreloc is enabled, elf_link_sort_relocs() will
7967 sort relocations, but in a different way than we do,
7968 and before we're done creating relocations. Also, it
7969 will move them around between input sections'
7970 relocation's contents, so our sorting would be
7971 broken, so don't let it run. */
7972 info
->combreloc
= 0;
7975 else if (htab
->is_vxworks
&& strcmp (name
, ".got") == 0)
7977 /* Executables do not need a GOT. */
7980 /* Allocate relocations for all but the reserved entries. */
7983 count
= (htab
->got_info
->global_gotno
7984 + htab
->got_info
->local_gotno
7985 - MIPS_RESERVED_GOTNO (info
));
7986 mips_elf_allocate_dynamic_relocations (dynobj
, info
, count
);
7989 else if (!htab
->is_vxworks
&& CONST_STRNEQ (name
, ".got"))
7991 /* _bfd_mips_elf_always_size_sections() has already done
7992 most of the work, but some symbols may have been mapped
7993 to versions that we must now resolve in the got_entries
7995 struct mips_got_info
*gg
= htab
->got_info
;
7996 struct mips_got_info
*g
= gg
;
7997 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
7998 unsigned int needed_relocs
= 0;
8002 set_got_offset_arg
.value
= MIPS_ELF_GOT_SIZE (output_bfd
);
8003 set_got_offset_arg
.info
= info
;
8005 /* NOTE 2005-02-03: How can this call, or the next, ever
8006 find any indirect entries to resolve? They were all
8007 resolved in mips_elf_multi_got. */
8008 mips_elf_resolve_final_got_entries (gg
);
8009 for (g
= gg
->next
; g
&& g
->next
!= gg
; g
= g
->next
)
8011 unsigned int save_assign
;
8013 mips_elf_resolve_final_got_entries (g
);
8015 /* Assign offsets to global GOT entries. */
8016 save_assign
= g
->assigned_gotno
;
8017 g
->assigned_gotno
= g
->local_gotno
;
8018 set_got_offset_arg
.g
= g
;
8019 set_got_offset_arg
.needed_relocs
= 0;
8020 htab_traverse (g
->got_entries
,
8021 mips_elf_set_global_got_offset
,
8022 &set_got_offset_arg
);
8023 needed_relocs
+= set_got_offset_arg
.needed_relocs
;
8024 BFD_ASSERT (g
->assigned_gotno
- g
->local_gotno
8025 <= g
->global_gotno
);
8027 g
->assigned_gotno
= save_assign
;
8030 needed_relocs
+= g
->local_gotno
- g
->assigned_gotno
;
8031 BFD_ASSERT (g
->assigned_gotno
== g
->next
->local_gotno
8032 + g
->next
->global_gotno
8033 + g
->next
->tls_gotno
8034 + MIPS_RESERVED_GOTNO (info
));
8040 struct mips_elf_count_tls_arg arg
;
8044 htab_traverse (gg
->got_entries
, mips_elf_count_local_tls_relocs
,
8046 elf_link_hash_traverse (elf_hash_table (info
),
8047 mips_elf_count_global_tls_relocs
,
8050 needed_relocs
+= arg
.needed
;
8054 mips_elf_allocate_dynamic_relocations (dynobj
, info
,
8057 else if (! info
->shared
8058 && ! mips_elf_hash_table (info
)->use_rld_obj_head
8059 && CONST_STRNEQ (name
, ".rld_map"))
8061 /* We add a room for __rld_map. It will be filled in by the
8062 rtld to contain a pointer to the _r_debug structure. */
8065 else if (SGI_COMPAT (output_bfd
)
8066 && CONST_STRNEQ (name
, ".compact_rel"))
8067 s
->size
+= mips_elf_hash_table (info
)->compact_rel_size
;
8068 else if (! CONST_STRNEQ (name
, ".init")
8069 && s
!= htab
->sgotplt
8071 && s
!= htab
->sstubs
)
8073 /* It's not one of our sections, so don't allocate space. */
8079 s
->flags
|= SEC_EXCLUDE
;
8083 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
8086 /* Allocate memory for this section last, since we may increase its
8088 if (strcmp (name
, MIPS_ELF_REL_DYN_NAME (info
)) == 0)
8094 /* Allocate memory for the section contents. */
8095 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
8096 if (s
->contents
== NULL
)
8098 bfd_set_error (bfd_error_no_memory
);
8103 /* Allocate memory for the .rel(a).dyn section. */
8104 if (sreldyn
!= NULL
)
8106 sreldyn
->contents
= bfd_zalloc (dynobj
, sreldyn
->size
);
8107 if (sreldyn
->contents
== NULL
)
8109 bfd_set_error (bfd_error_no_memory
);
8114 if (elf_hash_table (info
)->dynamic_sections_created
)
8116 /* Add some entries to the .dynamic section. We fill in the
8117 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
8118 must add the entries now so that we get the correct size for
8119 the .dynamic section. */
8121 /* SGI object has the equivalence of DT_DEBUG in the
8122 DT_MIPS_RLD_MAP entry. This must come first because glibc
8123 only fills in DT_MIPS_RLD_MAP (not DT_DEBUG) and GDB only
8124 looks at the first one it sees. */
8126 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_MAP
, 0))
8129 /* The DT_DEBUG entry may be filled in by the dynamic linker and
8130 used by the debugger. */
8131 if (info
->executable
8132 && !SGI_COMPAT (output_bfd
)
8133 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
8136 if (reltext
&& (SGI_COMPAT (output_bfd
) || htab
->is_vxworks
))
8137 info
->flags
|= DF_TEXTREL
;
8139 if ((info
->flags
& DF_TEXTREL
) != 0)
8141 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_TEXTREL
, 0))
8144 /* Clear the DF_TEXTREL flag. It will be set again if we
8145 write out an actual text relocation; we may not, because
8146 at this point we do not know whether e.g. any .eh_frame
8147 absolute relocations have been converted to PC-relative. */
8148 info
->flags
&= ~DF_TEXTREL
;
8151 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTGOT
, 0))
8154 if (htab
->is_vxworks
)
8156 /* VxWorks uses .rela.dyn instead of .rel.dyn. It does not
8157 use any of the DT_MIPS_* tags. */
8158 if (mips_elf_rel_dyn_section (info
, FALSE
))
8160 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELA
, 0))
8163 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELASZ
, 0))
8166 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELAENT
, 0))
8169 if (htab
->splt
->size
> 0)
8171 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTREL
, 0))
8174 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_JMPREL
, 0))
8177 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTRELSZ
, 0))
8183 if (mips_elf_rel_dyn_section (info
, FALSE
))
8185 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_REL
, 0))
8188 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELSZ
, 0))
8191 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELENT
, 0))
8195 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_VERSION
, 0))
8198 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_FLAGS
, 0))
8201 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_BASE_ADDRESS
, 0))
8204 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LOCAL_GOTNO
, 0))
8207 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_SYMTABNO
, 0))
8210 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_UNREFEXTNO
, 0))
8213 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_GOTSYM
, 0))
8216 if (IRIX_COMPAT (dynobj
) == ict_irix5
8217 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_HIPAGENO
, 0))
8220 if (IRIX_COMPAT (dynobj
) == ict_irix6
8221 && (bfd_get_section_by_name
8222 (dynobj
, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj
)))
8223 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_OPTIONS
, 0))
8226 if (htab
->is_vxworks
8227 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
8234 /* REL is a relocation in INPUT_BFD that is being copied to OUTPUT_BFD.
8235 Adjust its R_ADDEND field so that it is correct for the output file.
8236 LOCAL_SYMS and LOCAL_SECTIONS are arrays of INPUT_BFD's local symbols
8237 and sections respectively; both use symbol indexes. */
8240 mips_elf_adjust_addend (bfd
*output_bfd
, struct bfd_link_info
*info
,
8241 bfd
*input_bfd
, Elf_Internal_Sym
*local_syms
,
8242 asection
**local_sections
, Elf_Internal_Rela
*rel
)
8244 unsigned int r_type
, r_symndx
;
8245 Elf_Internal_Sym
*sym
;
8248 if (mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
, FALSE
))
8250 r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
8251 if (r_type
== R_MIPS16_GPREL
8252 || r_type
== R_MIPS_GPREL16
8253 || r_type
== R_MIPS_GPREL32
8254 || r_type
== R_MIPS_LITERAL
)
8256 rel
->r_addend
+= _bfd_get_gp_value (input_bfd
);
8257 rel
->r_addend
-= _bfd_get_gp_value (output_bfd
);
8260 r_symndx
= ELF_R_SYM (output_bfd
, rel
->r_info
);
8261 sym
= local_syms
+ r_symndx
;
8263 /* Adjust REL's addend to account for section merging. */
8264 if (!info
->relocatable
)
8266 sec
= local_sections
[r_symndx
];
8267 _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
8270 /* This would normally be done by the rela_normal code in elflink.c. */
8271 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
8272 rel
->r_addend
+= local_sections
[r_symndx
]->output_offset
;
8276 /* Relocate a MIPS ELF section. */
8279 _bfd_mips_elf_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
8280 bfd
*input_bfd
, asection
*input_section
,
8281 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
8282 Elf_Internal_Sym
*local_syms
,
8283 asection
**local_sections
)
8285 Elf_Internal_Rela
*rel
;
8286 const Elf_Internal_Rela
*relend
;
8288 bfd_boolean use_saved_addend_p
= FALSE
;
8289 const struct elf_backend_data
*bed
;
8291 bed
= get_elf_backend_data (output_bfd
);
8292 relend
= relocs
+ input_section
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
8293 for (rel
= relocs
; rel
< relend
; ++rel
)
8297 reloc_howto_type
*howto
;
8298 bfd_boolean require_jalx
;
8299 /* TRUE if the relocation is a RELA relocation, rather than a
8301 bfd_boolean rela_relocation_p
= TRUE
;
8302 unsigned int r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
8304 unsigned long r_symndx
;
8306 Elf_Internal_Shdr
*symtab_hdr
;
8307 struct elf_link_hash_entry
*h
;
8309 /* Find the relocation howto for this relocation. */
8310 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, r_type
,
8311 NEWABI_P (input_bfd
)
8312 && (MIPS_RELOC_RELA_P
8313 (input_bfd
, input_section
,
8316 r_symndx
= ELF_R_SYM (input_bfd
, rel
->r_info
);
8317 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
8318 if (mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
, FALSE
))
8320 sec
= local_sections
[r_symndx
];
8325 unsigned long extsymoff
;
8328 if (!elf_bad_symtab (input_bfd
))
8329 extsymoff
= symtab_hdr
->sh_info
;
8330 h
= elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
];
8331 while (h
->root
.type
== bfd_link_hash_indirect
8332 || h
->root
.type
== bfd_link_hash_warning
)
8333 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
8336 if (h
->root
.type
== bfd_link_hash_defined
8337 || h
->root
.type
== bfd_link_hash_defweak
)
8338 sec
= h
->root
.u
.def
.section
;
8341 if (sec
!= NULL
&& elf_discarded_section (sec
))
8343 /* For relocs against symbols from removed linkonce sections,
8344 or sections discarded by a linker script, we just want the
8345 section contents zeroed. Avoid any special processing. */
8346 _bfd_clear_contents (howto
, input_bfd
, contents
+ rel
->r_offset
);
8352 if (r_type
== R_MIPS_64
&& ! NEWABI_P (input_bfd
))
8354 /* Some 32-bit code uses R_MIPS_64. In particular, people use
8355 64-bit code, but make sure all their addresses are in the
8356 lowermost or uppermost 32-bit section of the 64-bit address
8357 space. Thus, when they use an R_MIPS_64 they mean what is
8358 usually meant by R_MIPS_32, with the exception that the
8359 stored value is sign-extended to 64 bits. */
8360 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, R_MIPS_32
, FALSE
);
8362 /* On big-endian systems, we need to lie about the position
8364 if (bfd_big_endian (input_bfd
))
8368 if (!use_saved_addend_p
)
8370 /* If these relocations were originally of the REL variety,
8371 we must pull the addend out of the field that will be
8372 relocated. Otherwise, we simply use the contents of the
8374 if (mips_elf_rel_relocation_p (input_bfd
, input_section
,
8377 rela_relocation_p
= FALSE
;
8378 addend
= mips_elf_read_rel_addend (input_bfd
, rel
,
8380 if (hi16_reloc_p (r_type
)
8381 || (got16_reloc_p (r_type
)
8382 && mips_elf_local_relocation_p (input_bfd
, rel
,
8383 local_sections
, FALSE
)))
8385 if (!mips_elf_add_lo16_rel_addend (input_bfd
, rel
, relend
,
8391 name
= h
->root
.root
.string
;
8393 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
8394 local_syms
+ r_symndx
,
8396 (*_bfd_error_handler
)
8397 (_("%B: Can't find matching LO16 reloc against `%s' for %s at 0x%lx in section `%A'"),
8398 input_bfd
, input_section
, name
, howto
->name
,
8403 addend
<<= howto
->rightshift
;
8406 addend
= rel
->r_addend
;
8407 mips_elf_adjust_addend (output_bfd
, info
, input_bfd
,
8408 local_syms
, local_sections
, rel
);
8411 if (info
->relocatable
)
8413 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
)
8414 && bfd_big_endian (input_bfd
))
8417 if (!rela_relocation_p
&& rel
->r_addend
)
8419 addend
+= rel
->r_addend
;
8420 if (hi16_reloc_p (r_type
) || got16_reloc_p (r_type
))
8421 addend
= mips_elf_high (addend
);
8422 else if (r_type
== R_MIPS_HIGHER
)
8423 addend
= mips_elf_higher (addend
);
8424 else if (r_type
== R_MIPS_HIGHEST
)
8425 addend
= mips_elf_highest (addend
);
8427 addend
>>= howto
->rightshift
;
8429 /* We use the source mask, rather than the destination
8430 mask because the place to which we are writing will be
8431 source of the addend in the final link. */
8432 addend
&= howto
->src_mask
;
8434 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
8435 /* See the comment above about using R_MIPS_64 in the 32-bit
8436 ABI. Here, we need to update the addend. It would be
8437 possible to get away with just using the R_MIPS_32 reloc
8438 but for endianness. */
8444 if (addend
& ((bfd_vma
) 1 << 31))
8446 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
8453 /* If we don't know that we have a 64-bit type,
8454 do two separate stores. */
8455 if (bfd_big_endian (input_bfd
))
8457 /* Store the sign-bits (which are most significant)
8459 low_bits
= sign_bits
;
8465 high_bits
= sign_bits
;
8467 bfd_put_32 (input_bfd
, low_bits
,
8468 contents
+ rel
->r_offset
);
8469 bfd_put_32 (input_bfd
, high_bits
,
8470 contents
+ rel
->r_offset
+ 4);
8474 if (! mips_elf_perform_relocation (info
, howto
, rel
, addend
,
8475 input_bfd
, input_section
,
8480 /* Go on to the next relocation. */
8484 /* In the N32 and 64-bit ABIs there may be multiple consecutive
8485 relocations for the same offset. In that case we are
8486 supposed to treat the output of each relocation as the addend
8488 if (rel
+ 1 < relend
8489 && rel
->r_offset
== rel
[1].r_offset
8490 && ELF_R_TYPE (input_bfd
, rel
[1].r_info
) != R_MIPS_NONE
)
8491 use_saved_addend_p
= TRUE
;
8493 use_saved_addend_p
= FALSE
;
8495 /* Figure out what value we are supposed to relocate. */
8496 switch (mips_elf_calculate_relocation (output_bfd
, input_bfd
,
8497 input_section
, info
, rel
,
8498 addend
, howto
, local_syms
,
8499 local_sections
, &value
,
8500 &name
, &require_jalx
,
8501 use_saved_addend_p
))
8503 case bfd_reloc_continue
:
8504 /* There's nothing to do. */
8507 case bfd_reloc_undefined
:
8508 /* mips_elf_calculate_relocation already called the
8509 undefined_symbol callback. There's no real point in
8510 trying to perform the relocation at this point, so we
8511 just skip ahead to the next relocation. */
8514 case bfd_reloc_notsupported
:
8515 msg
= _("internal error: unsupported relocation error");
8516 info
->callbacks
->warning
8517 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
8520 case bfd_reloc_overflow
:
8521 if (use_saved_addend_p
)
8522 /* Ignore overflow until we reach the last relocation for
8523 a given location. */
8527 struct mips_elf_link_hash_table
*htab
;
8529 htab
= mips_elf_hash_table (info
);
8530 BFD_ASSERT (name
!= NULL
);
8531 if (!htab
->small_data_overflow_reported
8532 && (howto
->type
== R_MIPS_GPREL16
8533 || howto
->type
== R_MIPS_LITERAL
))
8536 _("small-data section exceeds 64KB;"
8537 " lower small-data size limit (see option -G)");
8539 htab
->small_data_overflow_reported
= TRUE
;
8540 (*info
->callbacks
->einfo
) ("%P: %s\n", msg
);
8542 if (! ((*info
->callbacks
->reloc_overflow
)
8543 (info
, NULL
, name
, howto
->name
, (bfd_vma
) 0,
8544 input_bfd
, input_section
, rel
->r_offset
)))
8557 /* If we've got another relocation for the address, keep going
8558 until we reach the last one. */
8559 if (use_saved_addend_p
)
8565 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
8566 /* See the comment above about using R_MIPS_64 in the 32-bit
8567 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
8568 that calculated the right value. Now, however, we
8569 sign-extend the 32-bit result to 64-bits, and store it as a
8570 64-bit value. We are especially generous here in that we
8571 go to extreme lengths to support this usage on systems with
8572 only a 32-bit VMA. */
8578 if (value
& ((bfd_vma
) 1 << 31))
8580 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
8587 /* If we don't know that we have a 64-bit type,
8588 do two separate stores. */
8589 if (bfd_big_endian (input_bfd
))
8591 /* Undo what we did above. */
8593 /* Store the sign-bits (which are most significant)
8595 low_bits
= sign_bits
;
8601 high_bits
= sign_bits
;
8603 bfd_put_32 (input_bfd
, low_bits
,
8604 contents
+ rel
->r_offset
);
8605 bfd_put_32 (input_bfd
, high_bits
,
8606 contents
+ rel
->r_offset
+ 4);
8610 /* Actually perform the relocation. */
8611 if (! mips_elf_perform_relocation (info
, howto
, rel
, value
,
8612 input_bfd
, input_section
,
8613 contents
, require_jalx
))
8620 /* If NAME is one of the special IRIX6 symbols defined by the linker,
8621 adjust it appropriately now. */
8624 mips_elf_irix6_finish_dynamic_symbol (bfd
*abfd ATTRIBUTE_UNUSED
,
8625 const char *name
, Elf_Internal_Sym
*sym
)
8627 /* The linker script takes care of providing names and values for
8628 these, but we must place them into the right sections. */
8629 static const char* const text_section_symbols
[] = {
8632 "__dso_displacement",
8634 "__program_header_table",
8638 static const char* const data_section_symbols
[] = {
8646 const char* const *p
;
8649 for (i
= 0; i
< 2; ++i
)
8650 for (p
= (i
== 0) ? text_section_symbols
: data_section_symbols
;
8653 if (strcmp (*p
, name
) == 0)
8655 /* All of these symbols are given type STT_SECTION by the
8657 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8658 sym
->st_other
= STO_PROTECTED
;
8660 /* The IRIX linker puts these symbols in special sections. */
8662 sym
->st_shndx
= SHN_MIPS_TEXT
;
8664 sym
->st_shndx
= SHN_MIPS_DATA
;
8670 /* Finish up dynamic symbol handling. We set the contents of various
8671 dynamic sections here. */
8674 _bfd_mips_elf_finish_dynamic_symbol (bfd
*output_bfd
,
8675 struct bfd_link_info
*info
,
8676 struct elf_link_hash_entry
*h
,
8677 Elf_Internal_Sym
*sym
)
8681 struct mips_got_info
*g
, *gg
;
8684 struct mips_elf_link_hash_table
*htab
;
8685 struct mips_elf_link_hash_entry
*hmips
;
8687 htab
= mips_elf_hash_table (info
);
8688 dynobj
= elf_hash_table (info
)->dynobj
;
8689 hmips
= (struct mips_elf_link_hash_entry
*) h
;
8691 if (h
->plt
.offset
!= MINUS_ONE
)
8693 bfd_byte stub
[MIPS_FUNCTION_STUB_BIG_SIZE
];
8695 /* This symbol has a stub. Set it up. */
8697 BFD_ASSERT (h
->dynindx
!= -1);
8699 BFD_ASSERT ((htab
->function_stub_size
== MIPS_FUNCTION_STUB_BIG_SIZE
)
8700 || (h
->dynindx
<= 0xffff));
8702 /* Values up to 2^31 - 1 are allowed. Larger values would cause
8703 sign extension at runtime in the stub, resulting in a negative
8705 if (h
->dynindx
& ~0x7fffffff)
8708 /* Fill the stub. */
8710 bfd_put_32 (output_bfd
, STUB_LW (output_bfd
), stub
+ idx
);
8712 bfd_put_32 (output_bfd
, STUB_MOVE (output_bfd
), stub
+ idx
);
8714 if (htab
->function_stub_size
== MIPS_FUNCTION_STUB_BIG_SIZE
)
8716 bfd_put_32 (output_bfd
, STUB_LUI ((h
->dynindx
>> 16) & 0x7fff),
8720 bfd_put_32 (output_bfd
, STUB_JALR
, stub
+ idx
);
8723 /* If a large stub is not required and sign extension is not a
8724 problem, then use legacy code in the stub. */
8725 if (htab
->function_stub_size
== MIPS_FUNCTION_STUB_BIG_SIZE
)
8726 bfd_put_32 (output_bfd
, STUB_ORI (h
->dynindx
& 0xffff), stub
+ idx
);
8727 else if (h
->dynindx
& ~0x7fff)
8728 bfd_put_32 (output_bfd
, STUB_LI16U (h
->dynindx
& 0xffff), stub
+ idx
);
8730 bfd_put_32 (output_bfd
, STUB_LI16S (output_bfd
, h
->dynindx
),
8733 BFD_ASSERT (h
->plt
.offset
<= htab
->sstubs
->size
);
8734 memcpy (htab
->sstubs
->contents
+ h
->plt
.offset
,
8735 stub
, htab
->function_stub_size
);
8737 /* Mark the symbol as undefined. plt.offset != -1 occurs
8738 only for the referenced symbol. */
8739 sym
->st_shndx
= SHN_UNDEF
;
8741 /* The run-time linker uses the st_value field of the symbol
8742 to reset the global offset table entry for this external
8743 to its stub address when unlinking a shared object. */
8744 sym
->st_value
= (htab
->sstubs
->output_section
->vma
8745 + htab
->sstubs
->output_offset
8749 /* If we have a MIPS16 function with a stub, the dynamic symbol must
8750 refer to the stub, since only the stub uses the standard calling
8752 if (h
->dynindx
!= -1 && hmips
->fn_stub
!= NULL
)
8754 BFD_ASSERT (hmips
->need_fn_stub
);
8755 sym
->st_value
= (hmips
->fn_stub
->output_section
->vma
8756 + hmips
->fn_stub
->output_offset
);
8757 sym
->st_size
= hmips
->fn_stub
->size
;
8758 sym
->st_other
= ELF_ST_VISIBILITY (sym
->st_other
);
8761 BFD_ASSERT (h
->dynindx
!= -1
8762 || h
->forced_local
);
8764 sgot
= mips_elf_got_section (info
);
8765 BFD_ASSERT (sgot
!= NULL
);
8767 BFD_ASSERT (g
!= NULL
);
8769 /* Run through the global symbol table, creating GOT entries for all
8770 the symbols that need them. */
8771 if (g
->global_gotsym
!= NULL
8772 && h
->dynindx
>= g
->global_gotsym
->dynindx
)
8777 value
= sym
->st_value
;
8778 offset
= mips_elf_global_got_index (dynobj
, output_bfd
, h
,
8779 R_MIPS_GOT16
, info
);
8780 MIPS_ELF_PUT_WORD (output_bfd
, value
, sgot
->contents
+ offset
);
8783 if (g
->next
&& h
->dynindx
!= -1 && h
->type
!= STT_TLS
)
8785 struct mips_got_entry e
, *p
;
8791 e
.abfd
= output_bfd
;
8796 for (g
= g
->next
; g
->next
!= gg
; g
= g
->next
)
8799 && (p
= (struct mips_got_entry
*) htab_find (g
->got_entries
,
8804 || (elf_hash_table (info
)->dynamic_sections_created
8806 && p
->d
.h
->root
.def_dynamic
8807 && !p
->d
.h
->root
.def_regular
))
8809 /* Create an R_MIPS_REL32 relocation for this entry. Due to
8810 the various compatibility problems, it's easier to mock
8811 up an R_MIPS_32 or R_MIPS_64 relocation and leave
8812 mips_elf_create_dynamic_relocation to calculate the
8813 appropriate addend. */
8814 Elf_Internal_Rela rel
[3];
8816 memset (rel
, 0, sizeof (rel
));
8817 if (ABI_64_P (output_bfd
))
8818 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_64
);
8820 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_32
);
8821 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
8824 if (! (mips_elf_create_dynamic_relocation
8825 (output_bfd
, info
, rel
,
8826 e
.d
.h
, NULL
, sym
->st_value
, &entry
, sgot
)))
8830 entry
= sym
->st_value
;
8831 MIPS_ELF_PUT_WORD (output_bfd
, entry
, sgot
->contents
+ offset
);
8836 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
8837 name
= h
->root
.root
.string
;
8838 if (strcmp (name
, "_DYNAMIC") == 0
8839 || h
== elf_hash_table (info
)->hgot
)
8840 sym
->st_shndx
= SHN_ABS
;
8841 else if (strcmp (name
, "_DYNAMIC_LINK") == 0
8842 || strcmp (name
, "_DYNAMIC_LINKING") == 0)
8844 sym
->st_shndx
= SHN_ABS
;
8845 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8848 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (output_bfd
))
8850 sym
->st_shndx
= SHN_ABS
;
8851 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8852 sym
->st_value
= elf_gp (output_bfd
);
8854 else if (SGI_COMPAT (output_bfd
))
8856 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
8857 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
8859 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8860 sym
->st_other
= STO_PROTECTED
;
8862 sym
->st_shndx
= SHN_MIPS_DATA
;
8864 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
8866 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8867 sym
->st_other
= STO_PROTECTED
;
8868 sym
->st_value
= mips_elf_hash_table (info
)->procedure_count
;
8869 sym
->st_shndx
= SHN_ABS
;
8871 else if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
!= SHN_ABS
)
8873 if (h
->type
== STT_FUNC
)
8874 sym
->st_shndx
= SHN_MIPS_TEXT
;
8875 else if (h
->type
== STT_OBJECT
)
8876 sym
->st_shndx
= SHN_MIPS_DATA
;
8880 /* Handle the IRIX6-specific symbols. */
8881 if (IRIX_COMPAT (output_bfd
) == ict_irix6
)
8882 mips_elf_irix6_finish_dynamic_symbol (output_bfd
, name
, sym
);
8886 if (! mips_elf_hash_table (info
)->use_rld_obj_head
8887 && (strcmp (name
, "__rld_map") == 0
8888 || strcmp (name
, "__RLD_MAP") == 0))
8890 asection
*s
= bfd_get_section_by_name (dynobj
, ".rld_map");
8891 BFD_ASSERT (s
!= NULL
);
8892 sym
->st_value
= s
->output_section
->vma
+ s
->output_offset
;
8893 bfd_put_32 (output_bfd
, 0, s
->contents
);
8894 if (mips_elf_hash_table (info
)->rld_value
== 0)
8895 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
8897 else if (mips_elf_hash_table (info
)->use_rld_obj_head
8898 && strcmp (name
, "__rld_obj_head") == 0)
8900 /* IRIX6 does not use a .rld_map section. */
8901 if (IRIX_COMPAT (output_bfd
) == ict_irix5
8902 || IRIX_COMPAT (output_bfd
) == ict_none
)
8903 BFD_ASSERT (bfd_get_section_by_name (dynobj
, ".rld_map")
8905 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
8909 /* Keep dynamic MIPS16 symbols odd. This allows the dynamic linker to
8910 treat MIPS16 symbols like any other. */
8911 if (ELF_ST_IS_MIPS16 (sym
->st_other
))
8913 BFD_ASSERT (sym
->st_value
& 1);
8914 sym
->st_other
-= STO_MIPS16
;
8920 /* Likewise, for VxWorks. */
8923 _bfd_mips_vxworks_finish_dynamic_symbol (bfd
*output_bfd
,
8924 struct bfd_link_info
*info
,
8925 struct elf_link_hash_entry
*h
,
8926 Elf_Internal_Sym
*sym
)
8930 struct mips_got_info
*g
;
8931 struct mips_elf_link_hash_table
*htab
;
8933 htab
= mips_elf_hash_table (info
);
8934 dynobj
= elf_hash_table (info
)->dynobj
;
8936 if (h
->plt
.offset
!= (bfd_vma
) -1)
8939 bfd_vma plt_address
, plt_index
, got_address
, got_offset
, branch_offset
;
8940 Elf_Internal_Rela rel
;
8941 static const bfd_vma
*plt_entry
;
8943 BFD_ASSERT (h
->dynindx
!= -1);
8944 BFD_ASSERT (htab
->splt
!= NULL
);
8945 BFD_ASSERT (h
->plt
.offset
<= htab
->splt
->size
);
8947 /* Calculate the address of the .plt entry. */
8948 plt_address
= (htab
->splt
->output_section
->vma
8949 + htab
->splt
->output_offset
8952 /* Calculate the index of the entry. */
8953 plt_index
= ((h
->plt
.offset
- htab
->plt_header_size
)
8954 / htab
->plt_entry_size
);
8956 /* Calculate the address of the .got.plt entry. */
8957 got_address
= (htab
->sgotplt
->output_section
->vma
8958 + htab
->sgotplt
->output_offset
8961 /* Calculate the offset of the .got.plt entry from
8962 _GLOBAL_OFFSET_TABLE_. */
8963 got_offset
= mips_elf_gotplt_index (info
, h
);
8965 /* Calculate the offset for the branch at the start of the PLT
8966 entry. The branch jumps to the beginning of .plt. */
8967 branch_offset
= -(h
->plt
.offset
/ 4 + 1) & 0xffff;
8969 /* Fill in the initial value of the .got.plt entry. */
8970 bfd_put_32 (output_bfd
, plt_address
,
8971 htab
->sgotplt
->contents
+ plt_index
* 4);
8973 /* Find out where the .plt entry should go. */
8974 loc
= htab
->splt
->contents
+ h
->plt
.offset
;
8978 plt_entry
= mips_vxworks_shared_plt_entry
;
8979 bfd_put_32 (output_bfd
, plt_entry
[0] | branch_offset
, loc
);
8980 bfd_put_32 (output_bfd
, plt_entry
[1] | plt_index
, loc
+ 4);
8984 bfd_vma got_address_high
, got_address_low
;
8986 plt_entry
= mips_vxworks_exec_plt_entry
;
8987 got_address_high
= ((got_address
+ 0x8000) >> 16) & 0xffff;
8988 got_address_low
= got_address
& 0xffff;
8990 bfd_put_32 (output_bfd
, plt_entry
[0] | branch_offset
, loc
);
8991 bfd_put_32 (output_bfd
, plt_entry
[1] | plt_index
, loc
+ 4);
8992 bfd_put_32 (output_bfd
, plt_entry
[2] | got_address_high
, loc
+ 8);
8993 bfd_put_32 (output_bfd
, plt_entry
[3] | got_address_low
, loc
+ 12);
8994 bfd_put_32 (output_bfd
, plt_entry
[4], loc
+ 16);
8995 bfd_put_32 (output_bfd
, plt_entry
[5], loc
+ 20);
8996 bfd_put_32 (output_bfd
, plt_entry
[6], loc
+ 24);
8997 bfd_put_32 (output_bfd
, plt_entry
[7], loc
+ 28);
8999 loc
= (htab
->srelplt2
->contents
9000 + (plt_index
* 3 + 2) * sizeof (Elf32_External_Rela
));
9002 /* Emit a relocation for the .got.plt entry. */
9003 rel
.r_offset
= got_address
;
9004 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
, R_MIPS_32
);
9005 rel
.r_addend
= h
->plt
.offset
;
9006 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
9008 /* Emit a relocation for the lui of %hi(<.got.plt slot>). */
9009 loc
+= sizeof (Elf32_External_Rela
);
9010 rel
.r_offset
= plt_address
+ 8;
9011 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_HI16
);
9012 rel
.r_addend
= got_offset
;
9013 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
9015 /* Emit a relocation for the addiu of %lo(<.got.plt slot>). */
9016 loc
+= sizeof (Elf32_External_Rela
);
9018 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_LO16
);
9019 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
9022 /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry. */
9023 loc
= htab
->srelplt
->contents
+ plt_index
* sizeof (Elf32_External_Rela
);
9024 rel
.r_offset
= got_address
;
9025 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_JUMP_SLOT
);
9027 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
9029 if (!h
->def_regular
)
9030 sym
->st_shndx
= SHN_UNDEF
;
9033 BFD_ASSERT (h
->dynindx
!= -1 || h
->forced_local
);
9035 sgot
= mips_elf_got_section (info
);
9036 BFD_ASSERT (sgot
!= NULL
);
9038 BFD_ASSERT (g
!= NULL
);
9040 /* See if this symbol has an entry in the GOT. */
9041 if (g
->global_gotsym
!= NULL
9042 && h
->dynindx
>= g
->global_gotsym
->dynindx
)
9045 Elf_Internal_Rela outrel
;
9049 /* Install the symbol value in the GOT. */
9050 offset
= mips_elf_global_got_index (dynobj
, output_bfd
, h
,
9051 R_MIPS_GOT16
, info
);
9052 MIPS_ELF_PUT_WORD (output_bfd
, sym
->st_value
, sgot
->contents
+ offset
);
9054 /* Add a dynamic relocation for it. */
9055 s
= mips_elf_rel_dyn_section (info
, FALSE
);
9056 loc
= s
->contents
+ (s
->reloc_count
++ * sizeof (Elf32_External_Rela
));
9057 outrel
.r_offset
= (sgot
->output_section
->vma
9058 + sgot
->output_offset
9060 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_32
);
9061 outrel
.r_addend
= 0;
9062 bfd_elf32_swap_reloca_out (dynobj
, &outrel
, loc
);
9065 /* Emit a copy reloc, if needed. */
9068 Elf_Internal_Rela rel
;
9070 BFD_ASSERT (h
->dynindx
!= -1);
9072 rel
.r_offset
= (h
->root
.u
.def
.section
->output_section
->vma
9073 + h
->root
.u
.def
.section
->output_offset
9074 + h
->root
.u
.def
.value
);
9075 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_COPY
);
9077 bfd_elf32_swap_reloca_out (output_bfd
, &rel
,
9078 htab
->srelbss
->contents
9079 + (htab
->srelbss
->reloc_count
9080 * sizeof (Elf32_External_Rela
)));
9081 ++htab
->srelbss
->reloc_count
;
9084 /* If this is a mips16 symbol, force the value to be even. */
9085 if (ELF_ST_IS_MIPS16 (sym
->st_other
))
9086 sym
->st_value
&= ~1;
9091 /* Install the PLT header for a VxWorks executable and finalize the
9092 contents of .rela.plt.unloaded. */
9095 mips_vxworks_finish_exec_plt (bfd
*output_bfd
, struct bfd_link_info
*info
)
9097 Elf_Internal_Rela rela
;
9099 bfd_vma got_value
, got_value_high
, got_value_low
, plt_address
;
9100 static const bfd_vma
*plt_entry
;
9101 struct mips_elf_link_hash_table
*htab
;
9103 htab
= mips_elf_hash_table (info
);
9104 plt_entry
= mips_vxworks_exec_plt0_entry
;
9106 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */
9107 got_value
= (htab
->root
.hgot
->root
.u
.def
.section
->output_section
->vma
9108 + htab
->root
.hgot
->root
.u
.def
.section
->output_offset
9109 + htab
->root
.hgot
->root
.u
.def
.value
);
9111 got_value_high
= ((got_value
+ 0x8000) >> 16) & 0xffff;
9112 got_value_low
= got_value
& 0xffff;
9114 /* Calculate the address of the PLT header. */
9115 plt_address
= htab
->splt
->output_section
->vma
+ htab
->splt
->output_offset
;
9117 /* Install the PLT header. */
9118 loc
= htab
->splt
->contents
;
9119 bfd_put_32 (output_bfd
, plt_entry
[0] | got_value_high
, loc
);
9120 bfd_put_32 (output_bfd
, plt_entry
[1] | got_value_low
, loc
+ 4);
9121 bfd_put_32 (output_bfd
, plt_entry
[2], loc
+ 8);
9122 bfd_put_32 (output_bfd
, plt_entry
[3], loc
+ 12);
9123 bfd_put_32 (output_bfd
, plt_entry
[4], loc
+ 16);
9124 bfd_put_32 (output_bfd
, plt_entry
[5], loc
+ 20);
9126 /* Output the relocation for the lui of %hi(_GLOBAL_OFFSET_TABLE_). */
9127 loc
= htab
->srelplt2
->contents
;
9128 rela
.r_offset
= plt_address
;
9129 rela
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_HI16
);
9131 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
9132 loc
+= sizeof (Elf32_External_Rela
);
9134 /* Output the relocation for the following addiu of
9135 %lo(_GLOBAL_OFFSET_TABLE_). */
9137 rela
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_LO16
);
9138 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
9139 loc
+= sizeof (Elf32_External_Rela
);
9141 /* Fix up the remaining relocations. They may have the wrong
9142 symbol index for _G_O_T_ or _P_L_T_ depending on the order
9143 in which symbols were output. */
9144 while (loc
< htab
->srelplt2
->contents
+ htab
->srelplt2
->size
)
9146 Elf_Internal_Rela rel
;
9148 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &rel
);
9149 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
, R_MIPS_32
);
9150 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
9151 loc
+= sizeof (Elf32_External_Rela
);
9153 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &rel
);
9154 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_HI16
);
9155 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
9156 loc
+= sizeof (Elf32_External_Rela
);
9158 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &rel
);
9159 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_LO16
);
9160 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
9161 loc
+= sizeof (Elf32_External_Rela
);
9165 /* Install the PLT header for a VxWorks shared library. */
9168 mips_vxworks_finish_shared_plt (bfd
*output_bfd
, struct bfd_link_info
*info
)
9171 struct mips_elf_link_hash_table
*htab
;
9173 htab
= mips_elf_hash_table (info
);
9175 /* We just need to copy the entry byte-by-byte. */
9176 for (i
= 0; i
< ARRAY_SIZE (mips_vxworks_shared_plt0_entry
); i
++)
9177 bfd_put_32 (output_bfd
, mips_vxworks_shared_plt0_entry
[i
],
9178 htab
->splt
->contents
+ i
* 4);
9181 /* Finish up the dynamic sections. */
9184 _bfd_mips_elf_finish_dynamic_sections (bfd
*output_bfd
,
9185 struct bfd_link_info
*info
)
9190 struct mips_got_info
*gg
, *g
;
9191 struct mips_elf_link_hash_table
*htab
;
9193 htab
= mips_elf_hash_table (info
);
9194 dynobj
= elf_hash_table (info
)->dynobj
;
9196 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
9198 sgot
= mips_elf_got_section (info
);
9203 gg
= htab
->got_info
;
9204 g
= mips_elf_got_for_ibfd (gg
, output_bfd
);
9205 BFD_ASSERT (g
!= NULL
);
9208 if (elf_hash_table (info
)->dynamic_sections_created
)
9211 int dyn_to_skip
= 0, dyn_skipped
= 0;
9213 BFD_ASSERT (sdyn
!= NULL
);
9214 BFD_ASSERT (g
!= NULL
);
9216 for (b
= sdyn
->contents
;
9217 b
< sdyn
->contents
+ sdyn
->size
;
9218 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
9220 Elf_Internal_Dyn dyn
;
9224 bfd_boolean swap_out_p
;
9226 /* Read in the current dynamic entry. */
9227 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
9229 /* Assume that we're going to modify it and write it out. */
9235 dyn
.d_un
.d_val
= MIPS_ELF_REL_SIZE (dynobj
);
9239 BFD_ASSERT (htab
->is_vxworks
);
9240 dyn
.d_un
.d_val
= MIPS_ELF_RELA_SIZE (dynobj
);
9244 /* Rewrite DT_STRSZ. */
9246 _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
9251 if (htab
->is_vxworks
)
9253 /* _GLOBAL_OFFSET_TABLE_ is defined to be the beginning
9254 of the ".got" section in DYNOBJ. */
9255 s
= bfd_get_section_by_name (dynobj
, name
);
9256 BFD_ASSERT (s
!= NULL
);
9257 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
9261 s
= bfd_get_section_by_name (output_bfd
, name
);
9262 BFD_ASSERT (s
!= NULL
);
9263 dyn
.d_un
.d_ptr
= s
->vma
;
9267 case DT_MIPS_RLD_VERSION
:
9268 dyn
.d_un
.d_val
= 1; /* XXX */
9272 dyn
.d_un
.d_val
= RHF_NOTPOT
; /* XXX */
9275 case DT_MIPS_TIME_STAMP
:
9283 case DT_MIPS_ICHECKSUM
:
9288 case DT_MIPS_IVERSION
:
9293 case DT_MIPS_BASE_ADDRESS
:
9294 s
= output_bfd
->sections
;
9295 BFD_ASSERT (s
!= NULL
);
9296 dyn
.d_un
.d_ptr
= s
->vma
& ~(bfd_vma
) 0xffff;
9299 case DT_MIPS_LOCAL_GOTNO
:
9300 dyn
.d_un
.d_val
= g
->local_gotno
;
9303 case DT_MIPS_UNREFEXTNO
:
9304 /* The index into the dynamic symbol table which is the
9305 entry of the first external symbol that is not
9306 referenced within the same object. */
9307 dyn
.d_un
.d_val
= bfd_count_sections (output_bfd
) + 1;
9310 case DT_MIPS_GOTSYM
:
9311 if (gg
->global_gotsym
)
9313 dyn
.d_un
.d_val
= gg
->global_gotsym
->dynindx
;
9316 /* In case if we don't have global got symbols we default
9317 to setting DT_MIPS_GOTSYM to the same value as
9318 DT_MIPS_SYMTABNO, so we just fall through. */
9320 case DT_MIPS_SYMTABNO
:
9322 elemsize
= MIPS_ELF_SYM_SIZE (output_bfd
);
9323 s
= bfd_get_section_by_name (output_bfd
, name
);
9324 BFD_ASSERT (s
!= NULL
);
9326 dyn
.d_un
.d_val
= s
->size
/ elemsize
;
9329 case DT_MIPS_HIPAGENO
:
9330 dyn
.d_un
.d_val
= g
->local_gotno
- MIPS_RESERVED_GOTNO (info
);
9333 case DT_MIPS_RLD_MAP
:
9334 dyn
.d_un
.d_ptr
= mips_elf_hash_table (info
)->rld_value
;
9337 case DT_MIPS_OPTIONS
:
9338 s
= (bfd_get_section_by_name
9339 (output_bfd
, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd
)));
9340 dyn
.d_un
.d_ptr
= s
->vma
;
9344 BFD_ASSERT (htab
->is_vxworks
);
9345 /* The count does not include the JUMP_SLOT relocations. */
9347 dyn
.d_un
.d_val
-= htab
->srelplt
->size
;
9351 BFD_ASSERT (htab
->is_vxworks
);
9352 dyn
.d_un
.d_val
= DT_RELA
;
9356 BFD_ASSERT (htab
->is_vxworks
);
9357 dyn
.d_un
.d_val
= htab
->srelplt
->size
;
9361 BFD_ASSERT (htab
->is_vxworks
);
9362 dyn
.d_un
.d_val
= (htab
->srelplt
->output_section
->vma
9363 + htab
->srelplt
->output_offset
);
9367 /* If we didn't need any text relocations after all, delete
9369 if (!(info
->flags
& DF_TEXTREL
))
9371 dyn_to_skip
= MIPS_ELF_DYN_SIZE (dynobj
);
9377 /* If we didn't need any text relocations after all, clear
9378 DF_TEXTREL from DT_FLAGS. */
9379 if (!(info
->flags
& DF_TEXTREL
))
9380 dyn
.d_un
.d_val
&= ~DF_TEXTREL
;
9387 if (htab
->is_vxworks
9388 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
9393 if (swap_out_p
|| dyn_skipped
)
9394 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
9395 (dynobj
, &dyn
, b
- dyn_skipped
);
9399 dyn_skipped
+= dyn_to_skip
;
9404 /* Wipe out any trailing entries if we shifted down a dynamic tag. */
9405 if (dyn_skipped
> 0)
9406 memset (b
- dyn_skipped
, 0, dyn_skipped
);
9409 if (sgot
!= NULL
&& sgot
->size
> 0
9410 && !bfd_is_abs_section (sgot
->output_section
))
9412 if (htab
->is_vxworks
)
9414 /* The first entry of the global offset table points to the
9415 ".dynamic" section. The second is initialized by the
9416 loader and contains the shared library identifier.
9417 The third is also initialized by the loader and points
9418 to the lazy resolution stub. */
9419 MIPS_ELF_PUT_WORD (output_bfd
,
9420 sdyn
->output_offset
+ sdyn
->output_section
->vma
,
9422 MIPS_ELF_PUT_WORD (output_bfd
, 0,
9423 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
9424 MIPS_ELF_PUT_WORD (output_bfd
, 0,
9426 + 2 * MIPS_ELF_GOT_SIZE (output_bfd
));
9430 /* The first entry of the global offset table will be filled at
9431 runtime. The second entry will be used by some runtime loaders.
9432 This isn't the case of IRIX rld. */
9433 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
9434 MIPS_ELF_PUT_WORD (output_bfd
, MIPS_ELF_GNU_GOT1_MASK (output_bfd
),
9435 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
9438 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
9439 = MIPS_ELF_GOT_SIZE (output_bfd
);
9442 /* Generate dynamic relocations for the non-primary gots. */
9443 if (gg
!= NULL
&& gg
->next
)
9445 Elf_Internal_Rela rel
[3];
9448 memset (rel
, 0, sizeof (rel
));
9449 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_REL32
);
9451 for (g
= gg
->next
; g
->next
!= gg
; g
= g
->next
)
9453 bfd_vma index
= g
->next
->local_gotno
+ g
->next
->global_gotno
9454 + g
->next
->tls_gotno
;
9456 MIPS_ELF_PUT_WORD (output_bfd
, 0, sgot
->contents
9457 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
9458 MIPS_ELF_PUT_WORD (output_bfd
, MIPS_ELF_GNU_GOT1_MASK (output_bfd
),
9460 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
9465 while (index
< g
->assigned_gotno
)
9467 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
9468 = index
++ * MIPS_ELF_GOT_SIZE (output_bfd
);
9469 if (!(mips_elf_create_dynamic_relocation
9470 (output_bfd
, info
, rel
, NULL
,
9471 bfd_abs_section_ptr
,
9474 BFD_ASSERT (addend
== 0);
9479 /* The generation of dynamic relocations for the non-primary gots
9480 adds more dynamic relocations. We cannot count them until
9483 if (elf_hash_table (info
)->dynamic_sections_created
)
9486 bfd_boolean swap_out_p
;
9488 BFD_ASSERT (sdyn
!= NULL
);
9490 for (b
= sdyn
->contents
;
9491 b
< sdyn
->contents
+ sdyn
->size
;
9492 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
9494 Elf_Internal_Dyn dyn
;
9497 /* Read in the current dynamic entry. */
9498 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
9500 /* Assume that we're going to modify it and write it out. */
9506 /* Reduce DT_RELSZ to account for any relocations we
9507 decided not to make. This is for the n64 irix rld,
9508 which doesn't seem to apply any relocations if there
9509 are trailing null entries. */
9510 s
= mips_elf_rel_dyn_section (info
, FALSE
);
9511 dyn
.d_un
.d_val
= (s
->reloc_count
9512 * (ABI_64_P (output_bfd
)
9513 ? sizeof (Elf64_Mips_External_Rel
)
9514 : sizeof (Elf32_External_Rel
)));
9515 /* Adjust the section size too. Tools like the prelinker
9516 can reasonably expect the values to the same. */
9517 elf_section_data (s
->output_section
)->this_hdr
.sh_size
9527 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
9534 Elf32_compact_rel cpt
;
9536 if (SGI_COMPAT (output_bfd
))
9538 /* Write .compact_rel section out. */
9539 s
= bfd_get_section_by_name (dynobj
, ".compact_rel");
9543 cpt
.num
= s
->reloc_count
;
9545 cpt
.offset
= (s
->output_section
->filepos
9546 + sizeof (Elf32_External_compact_rel
));
9549 bfd_elf32_swap_compact_rel_out (output_bfd
, &cpt
,
9550 ((Elf32_External_compact_rel
*)
9553 /* Clean up a dummy stub function entry in .text. */
9554 if (htab
->sstubs
!= NULL
)
9556 file_ptr dummy_offset
;
9558 BFD_ASSERT (htab
->sstubs
->size
>= htab
->function_stub_size
);
9559 dummy_offset
= htab
->sstubs
->size
- htab
->function_stub_size
;
9560 memset (htab
->sstubs
->contents
+ dummy_offset
, 0,
9561 htab
->function_stub_size
);
9566 /* The psABI says that the dynamic relocations must be sorted in
9567 increasing order of r_symndx. The VxWorks EABI doesn't require
9568 this, and because the code below handles REL rather than RELA
9569 relocations, using it for VxWorks would be outright harmful. */
9570 if (!htab
->is_vxworks
)
9572 s
= mips_elf_rel_dyn_section (info
, FALSE
);
9574 && s
->size
> (bfd_vma
)2 * MIPS_ELF_REL_SIZE (output_bfd
))
9576 reldyn_sorting_bfd
= output_bfd
;
9578 if (ABI_64_P (output_bfd
))
9579 qsort ((Elf64_External_Rel
*) s
->contents
+ 1,
9580 s
->reloc_count
- 1, sizeof (Elf64_Mips_External_Rel
),
9581 sort_dynamic_relocs_64
);
9583 qsort ((Elf32_External_Rel
*) s
->contents
+ 1,
9584 s
->reloc_count
- 1, sizeof (Elf32_External_Rel
),
9585 sort_dynamic_relocs
);
9590 if (htab
->is_vxworks
&& htab
->splt
->size
> 0)
9593 mips_vxworks_finish_shared_plt (output_bfd
, info
);
9595 mips_vxworks_finish_exec_plt (output_bfd
, info
);
9601 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
9604 mips_set_isa_flags (bfd
*abfd
)
9608 switch (bfd_get_mach (abfd
))
9611 case bfd_mach_mips3000
:
9612 val
= E_MIPS_ARCH_1
;
9615 case bfd_mach_mips3900
:
9616 val
= E_MIPS_ARCH_1
| E_MIPS_MACH_3900
;
9619 case bfd_mach_mips6000
:
9620 val
= E_MIPS_ARCH_2
;
9623 case bfd_mach_mips4000
:
9624 case bfd_mach_mips4300
:
9625 case bfd_mach_mips4400
:
9626 case bfd_mach_mips4600
:
9627 val
= E_MIPS_ARCH_3
;
9630 case bfd_mach_mips4010
:
9631 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4010
;
9634 case bfd_mach_mips4100
:
9635 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4100
;
9638 case bfd_mach_mips4111
:
9639 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4111
;
9642 case bfd_mach_mips4120
:
9643 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4120
;
9646 case bfd_mach_mips4650
:
9647 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4650
;
9650 case bfd_mach_mips5400
:
9651 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5400
;
9654 case bfd_mach_mips5500
:
9655 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5500
;
9658 case bfd_mach_mips9000
:
9659 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_9000
;
9662 case bfd_mach_mips5000
:
9663 case bfd_mach_mips7000
:
9664 case bfd_mach_mips8000
:
9665 case bfd_mach_mips10000
:
9666 case bfd_mach_mips12000
:
9667 val
= E_MIPS_ARCH_4
;
9670 case bfd_mach_mips5
:
9671 val
= E_MIPS_ARCH_5
;
9674 case bfd_mach_mips_loongson_2e
:
9675 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_LS2E
;
9678 case bfd_mach_mips_loongson_2f
:
9679 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_LS2F
;
9682 case bfd_mach_mips_sb1
:
9683 val
= E_MIPS_ARCH_64
| E_MIPS_MACH_SB1
;
9686 case bfd_mach_mips_octeon
:
9687 val
= E_MIPS_ARCH_64R2
| E_MIPS_MACH_OCTEON
;
9690 case bfd_mach_mipsisa32
:
9691 val
= E_MIPS_ARCH_32
;
9694 case bfd_mach_mipsisa64
:
9695 val
= E_MIPS_ARCH_64
;
9698 case bfd_mach_mipsisa32r2
:
9699 val
= E_MIPS_ARCH_32R2
;
9702 case bfd_mach_mipsisa64r2
:
9703 val
= E_MIPS_ARCH_64R2
;
9706 elf_elfheader (abfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
9707 elf_elfheader (abfd
)->e_flags
|= val
;
9712 /* The final processing done just before writing out a MIPS ELF object
9713 file. This gets the MIPS architecture right based on the machine
9714 number. This is used by both the 32-bit and the 64-bit ABI. */
9717 _bfd_mips_elf_final_write_processing (bfd
*abfd
,
9718 bfd_boolean linker ATTRIBUTE_UNUSED
)
9721 Elf_Internal_Shdr
**hdrpp
;
9725 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
9726 is nonzero. This is for compatibility with old objects, which used
9727 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
9728 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_MACH
) == 0)
9729 mips_set_isa_flags (abfd
);
9731 /* Set the sh_info field for .gptab sections and other appropriate
9732 info for each special section. */
9733 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
9734 i
< elf_numsections (abfd
);
9737 switch ((*hdrpp
)->sh_type
)
9740 case SHT_MIPS_LIBLIST
:
9741 sec
= bfd_get_section_by_name (abfd
, ".dynstr");
9743 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
9746 case SHT_MIPS_GPTAB
:
9747 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
9748 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
9749 BFD_ASSERT (name
!= NULL
9750 && CONST_STRNEQ (name
, ".gptab."));
9751 sec
= bfd_get_section_by_name (abfd
, name
+ sizeof ".gptab" - 1);
9752 BFD_ASSERT (sec
!= NULL
);
9753 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
9756 case SHT_MIPS_CONTENT
:
9757 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
9758 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
9759 BFD_ASSERT (name
!= NULL
9760 && CONST_STRNEQ (name
, ".MIPS.content"));
9761 sec
= bfd_get_section_by_name (abfd
,
9762 name
+ sizeof ".MIPS.content" - 1);
9763 BFD_ASSERT (sec
!= NULL
);
9764 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
9767 case SHT_MIPS_SYMBOL_LIB
:
9768 sec
= bfd_get_section_by_name (abfd
, ".dynsym");
9770 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
9771 sec
= bfd_get_section_by_name (abfd
, ".liblist");
9773 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
9776 case SHT_MIPS_EVENTS
:
9777 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
9778 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
9779 BFD_ASSERT (name
!= NULL
);
9780 if (CONST_STRNEQ (name
, ".MIPS.events"))
9781 sec
= bfd_get_section_by_name (abfd
,
9782 name
+ sizeof ".MIPS.events" - 1);
9785 BFD_ASSERT (CONST_STRNEQ (name
, ".MIPS.post_rel"));
9786 sec
= bfd_get_section_by_name (abfd
,
9788 + sizeof ".MIPS.post_rel" - 1));
9790 BFD_ASSERT (sec
!= NULL
);
9791 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
9798 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
9802 _bfd_mips_elf_additional_program_headers (bfd
*abfd
,
9803 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
9808 /* See if we need a PT_MIPS_REGINFO segment. */
9809 s
= bfd_get_section_by_name (abfd
, ".reginfo");
9810 if (s
&& (s
->flags
& SEC_LOAD
))
9813 /* See if we need a PT_MIPS_OPTIONS segment. */
9814 if (IRIX_COMPAT (abfd
) == ict_irix6
9815 && bfd_get_section_by_name (abfd
,
9816 MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)))
9819 /* See if we need a PT_MIPS_RTPROC segment. */
9820 if (IRIX_COMPAT (abfd
) == ict_irix5
9821 && bfd_get_section_by_name (abfd
, ".dynamic")
9822 && bfd_get_section_by_name (abfd
, ".mdebug"))
9825 /* Allocate a PT_NULL header in dynamic objects. See
9826 _bfd_mips_elf_modify_segment_map for details. */
9827 if (!SGI_COMPAT (abfd
)
9828 && bfd_get_section_by_name (abfd
, ".dynamic"))
9834 /* Modify the segment map for an IRIX5 executable. */
9837 _bfd_mips_elf_modify_segment_map (bfd
*abfd
,
9838 struct bfd_link_info
*info
)
9841 struct elf_segment_map
*m
, **pm
;
9844 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
9846 s
= bfd_get_section_by_name (abfd
, ".reginfo");
9847 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
9849 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
9850 if (m
->p_type
== PT_MIPS_REGINFO
)
9855 m
= bfd_zalloc (abfd
, amt
);
9859 m
->p_type
= PT_MIPS_REGINFO
;
9863 /* We want to put it after the PHDR and INTERP segments. */
9864 pm
= &elf_tdata (abfd
)->segment_map
;
9866 && ((*pm
)->p_type
== PT_PHDR
9867 || (*pm
)->p_type
== PT_INTERP
))
9875 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
9876 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
9877 PT_MIPS_OPTIONS segment immediately following the program header
9880 /* On non-IRIX6 new abi, we'll have already created a segment
9881 for this section, so don't create another. I'm not sure this
9882 is not also the case for IRIX 6, but I can't test it right
9884 && IRIX_COMPAT (abfd
) == ict_irix6
)
9886 for (s
= abfd
->sections
; s
; s
= s
->next
)
9887 if (elf_section_data (s
)->this_hdr
.sh_type
== SHT_MIPS_OPTIONS
)
9892 struct elf_segment_map
*options_segment
;
9894 pm
= &elf_tdata (abfd
)->segment_map
;
9896 && ((*pm
)->p_type
== PT_PHDR
9897 || (*pm
)->p_type
== PT_INTERP
))
9900 if (*pm
== NULL
|| (*pm
)->p_type
!= PT_MIPS_OPTIONS
)
9902 amt
= sizeof (struct elf_segment_map
);
9903 options_segment
= bfd_zalloc (abfd
, amt
);
9904 options_segment
->next
= *pm
;
9905 options_segment
->p_type
= PT_MIPS_OPTIONS
;
9906 options_segment
->p_flags
= PF_R
;
9907 options_segment
->p_flags_valid
= TRUE
;
9908 options_segment
->count
= 1;
9909 options_segment
->sections
[0] = s
;
9910 *pm
= options_segment
;
9916 if (IRIX_COMPAT (abfd
) == ict_irix5
)
9918 /* If there are .dynamic and .mdebug sections, we make a room
9919 for the RTPROC header. FIXME: Rewrite without section names. */
9920 if (bfd_get_section_by_name (abfd
, ".interp") == NULL
9921 && bfd_get_section_by_name (abfd
, ".dynamic") != NULL
9922 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
9924 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
9925 if (m
->p_type
== PT_MIPS_RTPROC
)
9930 m
= bfd_zalloc (abfd
, amt
);
9934 m
->p_type
= PT_MIPS_RTPROC
;
9936 s
= bfd_get_section_by_name (abfd
, ".rtproc");
9941 m
->p_flags_valid
= 1;
9949 /* We want to put it after the DYNAMIC segment. */
9950 pm
= &elf_tdata (abfd
)->segment_map
;
9951 while (*pm
!= NULL
&& (*pm
)->p_type
!= PT_DYNAMIC
)
9961 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
9962 .dynstr, .dynsym, and .hash sections, and everything in
9964 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
;
9966 if ((*pm
)->p_type
== PT_DYNAMIC
)
9969 if (m
!= NULL
&& IRIX_COMPAT (abfd
) == ict_none
)
9971 /* For a normal mips executable the permissions for the PT_DYNAMIC
9972 segment are read, write and execute. We do that here since
9973 the code in elf.c sets only the read permission. This matters
9974 sometimes for the dynamic linker. */
9975 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
9977 m
->p_flags
= PF_R
| PF_W
| PF_X
;
9978 m
->p_flags_valid
= 1;
9981 /* GNU/Linux binaries do not need the extended PT_DYNAMIC section.
9982 glibc's dynamic linker has traditionally derived the number of
9983 tags from the p_filesz field, and sometimes allocates stack
9984 arrays of that size. An overly-big PT_DYNAMIC segment can
9985 be actively harmful in such cases. Making PT_DYNAMIC contain
9986 other sections can also make life hard for the prelinker,
9987 which might move one of the other sections to a different
9989 if (SGI_COMPAT (abfd
)
9992 && strcmp (m
->sections
[0]->name
, ".dynamic") == 0)
9994 static const char *sec_names
[] =
9996 ".dynamic", ".dynstr", ".dynsym", ".hash"
10000 struct elf_segment_map
*n
;
10002 low
= ~(bfd_vma
) 0;
10004 for (i
= 0; i
< sizeof sec_names
/ sizeof sec_names
[0]; i
++)
10006 s
= bfd_get_section_by_name (abfd
, sec_names
[i
]);
10007 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
10014 if (high
< s
->vma
+ sz
)
10015 high
= s
->vma
+ sz
;
10020 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
10021 if ((s
->flags
& SEC_LOAD
) != 0
10023 && s
->vma
+ s
->size
<= high
)
10026 amt
= sizeof *n
+ (bfd_size_type
) (c
- 1) * sizeof (asection
*);
10027 n
= bfd_zalloc (abfd
, amt
);
10034 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
10036 if ((s
->flags
& SEC_LOAD
) != 0
10038 && s
->vma
+ s
->size
<= high
)
10040 n
->sections
[i
] = s
;
10049 /* Allocate a spare program header in dynamic objects so that tools
10050 like the prelinker can add an extra PT_LOAD entry.
10052 If the prelinker needs to make room for a new PT_LOAD entry, its
10053 standard procedure is to move the first (read-only) sections into
10054 the new (writable) segment. However, the MIPS ABI requires
10055 .dynamic to be in a read-only segment, and the section will often
10056 start within sizeof (ElfNN_Phdr) bytes of the last program header.
10058 Although the prelinker could in principle move .dynamic to a
10059 writable segment, it seems better to allocate a spare program
10060 header instead, and avoid the need to move any sections.
10061 There is a long tradition of allocating spare dynamic tags,
10062 so allocating a spare program header seems like a natural
10065 If INFO is NULL, we may be copying an already prelinked binary
10066 with objcopy or strip, so do not add this header. */
10068 && !SGI_COMPAT (abfd
)
10069 && bfd_get_section_by_name (abfd
, ".dynamic"))
10071 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
; pm
= &(*pm
)->next
)
10072 if ((*pm
)->p_type
== PT_NULL
)
10076 m
= bfd_zalloc (abfd
, sizeof (*m
));
10080 m
->p_type
= PT_NULL
;
10088 /* Return the section that should be marked against GC for a given
10092 _bfd_mips_elf_gc_mark_hook (asection
*sec
,
10093 struct bfd_link_info
*info
,
10094 Elf_Internal_Rela
*rel
,
10095 struct elf_link_hash_entry
*h
,
10096 Elf_Internal_Sym
*sym
)
10098 /* ??? Do mips16 stub sections need to be handled special? */
10101 switch (ELF_R_TYPE (sec
->owner
, rel
->r_info
))
10103 case R_MIPS_GNU_VTINHERIT
:
10104 case R_MIPS_GNU_VTENTRY
:
10108 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
10111 /* Update the got entry reference counts for the section being removed. */
10114 _bfd_mips_elf_gc_sweep_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
10115 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
10116 asection
*sec ATTRIBUTE_UNUSED
,
10117 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
)
10120 Elf_Internal_Shdr
*symtab_hdr
;
10121 struct elf_link_hash_entry
**sym_hashes
;
10122 bfd_signed_vma
*local_got_refcounts
;
10123 const Elf_Internal_Rela
*rel
, *relend
;
10124 unsigned long r_symndx
;
10125 struct elf_link_hash_entry
*h
;
10127 if (info
->relocatable
)
10130 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10131 sym_hashes
= elf_sym_hashes (abfd
);
10132 local_got_refcounts
= elf_local_got_refcounts (abfd
);
10134 relend
= relocs
+ sec
->reloc_count
;
10135 for (rel
= relocs
; rel
< relend
; rel
++)
10136 switch (ELF_R_TYPE (abfd
, rel
->r_info
))
10138 case R_MIPS16_GOT16
:
10139 case R_MIPS16_CALL16
:
10141 case R_MIPS_CALL16
:
10142 case R_MIPS_CALL_HI16
:
10143 case R_MIPS_CALL_LO16
:
10144 case R_MIPS_GOT_HI16
:
10145 case R_MIPS_GOT_LO16
:
10146 case R_MIPS_GOT_DISP
:
10147 case R_MIPS_GOT_PAGE
:
10148 case R_MIPS_GOT_OFST
:
10149 /* ??? It would seem that the existing MIPS code does no sort
10150 of reference counting or whatnot on its GOT and PLT entries,
10151 so it is not possible to garbage collect them at this time. */
10162 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
10163 hiding the old indirect symbol. Process additional relocation
10164 information. Also called for weakdefs, in which case we just let
10165 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
10168 _bfd_mips_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
10169 struct elf_link_hash_entry
*dir
,
10170 struct elf_link_hash_entry
*ind
)
10172 struct mips_elf_link_hash_entry
*dirmips
, *indmips
;
10174 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
10176 if (ind
->root
.type
!= bfd_link_hash_indirect
)
10179 dirmips
= (struct mips_elf_link_hash_entry
*) dir
;
10180 indmips
= (struct mips_elf_link_hash_entry
*) ind
;
10181 dirmips
->possibly_dynamic_relocs
+= indmips
->possibly_dynamic_relocs
;
10182 if (indmips
->readonly_reloc
)
10183 dirmips
->readonly_reloc
= TRUE
;
10184 if (indmips
->no_fn_stub
)
10185 dirmips
->no_fn_stub
= TRUE
;
10187 if (dirmips
->tls_type
== 0)
10188 dirmips
->tls_type
= indmips
->tls_type
;
10192 _bfd_mips_elf_hide_symbol (struct bfd_link_info
*info
,
10193 struct elf_link_hash_entry
*entry
,
10194 bfd_boolean force_local
)
10197 struct mips_got_info
*g
;
10198 struct mips_elf_link_hash_entry
*h
;
10199 struct mips_elf_link_hash_table
*htab
;
10201 h
= (struct mips_elf_link_hash_entry
*) entry
;
10202 if (h
->forced_local
)
10204 h
->forced_local
= force_local
;
10206 dynobj
= elf_hash_table (info
)->dynobj
;
10207 htab
= mips_elf_hash_table (info
);
10210 && h
->root
.type
!= STT_TLS
10211 && htab
->got_info
!= NULL
)
10213 g
= htab
->got_info
;
10216 struct mips_got_entry e
;
10217 struct mips_got_info
*gg
= g
;
10219 /* Since we're turning what used to be a global symbol into a
10220 local one, bump up the number of local entries of each GOT
10221 that had an entry for it. This will automatically decrease
10222 the number of global entries, since global_gotno is actually
10223 the upper limit of global entries. */
10229 for (g
= g
->next
; g
!= gg
; g
= g
->next
)
10230 if (htab_find (g
->got_entries
, &e
))
10232 BFD_ASSERT (g
->global_gotno
> 0);
10237 /* If this was a global symbol forced into the primary GOT, we
10238 no longer need an entry for it. We can't release the entry
10239 at this point, but we must at least stop counting it as one
10240 of the symbols that required a forced got entry. */
10241 if (h
->root
.got
.offset
== 2)
10243 BFD_ASSERT (gg
->assigned_gotno
> 0);
10244 gg
->assigned_gotno
--;
10247 else if (h
->root
.got
.offset
== 1)
10249 /* check_relocs didn't know that this symbol would be
10250 forced-local, so add an extra local got entry. */
10252 if (htab
->computed_got_sizes
)
10254 /* We'll have treated this symbol as global rather
10256 BFD_ASSERT (g
->global_gotno
> 0);
10260 else if (htab
->is_vxworks
&& h
->root
.needs_plt
)
10262 /* check_relocs didn't know that this symbol would be
10263 forced-local, so add an extra local got entry. */
10265 if (htab
->computed_got_sizes
)
10266 /* The symbol is only used in call relocations, so we'll
10267 have assumed it only needs a .got.plt entry. Increase
10268 the size of .got accordingly. */
10269 htab
->sgot
->size
+= MIPS_ELF_GOT_SIZE (dynobj
);
10273 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
10276 #define PDR_SIZE 32
10279 _bfd_mips_elf_discard_info (bfd
*abfd
, struct elf_reloc_cookie
*cookie
,
10280 struct bfd_link_info
*info
)
10283 bfd_boolean ret
= FALSE
;
10284 unsigned char *tdata
;
10287 o
= bfd_get_section_by_name (abfd
, ".pdr");
10292 if (o
->size
% PDR_SIZE
!= 0)
10294 if (o
->output_section
!= NULL
10295 && bfd_is_abs_section (o
->output_section
))
10298 tdata
= bfd_zmalloc (o
->size
/ PDR_SIZE
);
10302 cookie
->rels
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
10303 info
->keep_memory
);
10310 cookie
->rel
= cookie
->rels
;
10311 cookie
->relend
= cookie
->rels
+ o
->reloc_count
;
10313 for (i
= 0, skip
= 0; i
< o
->size
/ PDR_SIZE
; i
++)
10315 if (bfd_elf_reloc_symbol_deleted_p (i
* PDR_SIZE
, cookie
))
10324 mips_elf_section_data (o
)->u
.tdata
= tdata
;
10325 o
->size
-= skip
* PDR_SIZE
;
10331 if (! info
->keep_memory
)
10332 free (cookie
->rels
);
10338 _bfd_mips_elf_ignore_discarded_relocs (asection
*sec
)
10340 if (strcmp (sec
->name
, ".pdr") == 0)
10346 _bfd_mips_elf_write_section (bfd
*output_bfd
,
10347 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
10348 asection
*sec
, bfd_byte
*contents
)
10350 bfd_byte
*to
, *from
, *end
;
10353 if (strcmp (sec
->name
, ".pdr") != 0)
10356 if (mips_elf_section_data (sec
)->u
.tdata
== NULL
)
10360 end
= contents
+ sec
->size
;
10361 for (from
= contents
, i
= 0;
10363 from
+= PDR_SIZE
, i
++)
10365 if ((mips_elf_section_data (sec
)->u
.tdata
)[i
] == 1)
10368 memcpy (to
, from
, PDR_SIZE
);
10371 bfd_set_section_contents (output_bfd
, sec
->output_section
, contents
,
10372 sec
->output_offset
, sec
->size
);
10376 /* MIPS ELF uses a special find_nearest_line routine in order the
10377 handle the ECOFF debugging information. */
10379 struct mips_elf_find_line
10381 struct ecoff_debug_info d
;
10382 struct ecoff_find_line i
;
10386 _bfd_mips_elf_find_nearest_line (bfd
*abfd
, asection
*section
,
10387 asymbol
**symbols
, bfd_vma offset
,
10388 const char **filename_ptr
,
10389 const char **functionname_ptr
,
10390 unsigned int *line_ptr
)
10394 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
10395 filename_ptr
, functionname_ptr
,
10399 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
10400 filename_ptr
, functionname_ptr
,
10401 line_ptr
, ABI_64_P (abfd
) ? 8 : 0,
10402 &elf_tdata (abfd
)->dwarf2_find_line_info
))
10405 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
10408 flagword origflags
;
10409 struct mips_elf_find_line
*fi
;
10410 const struct ecoff_debug_swap
* const swap
=
10411 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
10413 /* If we are called during a link, mips_elf_final_link may have
10414 cleared the SEC_HAS_CONTENTS field. We force it back on here
10415 if appropriate (which it normally will be). */
10416 origflags
= msec
->flags
;
10417 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
10418 msec
->flags
|= SEC_HAS_CONTENTS
;
10420 fi
= elf_tdata (abfd
)->find_line_info
;
10423 bfd_size_type external_fdr_size
;
10426 struct fdr
*fdr_ptr
;
10427 bfd_size_type amt
= sizeof (struct mips_elf_find_line
);
10429 fi
= bfd_zalloc (abfd
, amt
);
10432 msec
->flags
= origflags
;
10436 if (! _bfd_mips_elf_read_ecoff_info (abfd
, msec
, &fi
->d
))
10438 msec
->flags
= origflags
;
10442 /* Swap in the FDR information. */
10443 amt
= fi
->d
.symbolic_header
.ifdMax
* sizeof (struct fdr
);
10444 fi
->d
.fdr
= bfd_alloc (abfd
, amt
);
10445 if (fi
->d
.fdr
== NULL
)
10447 msec
->flags
= origflags
;
10450 external_fdr_size
= swap
->external_fdr_size
;
10451 fdr_ptr
= fi
->d
.fdr
;
10452 fraw_src
= (char *) fi
->d
.external_fdr
;
10453 fraw_end
= (fraw_src
10454 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
10455 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
10456 (*swap
->swap_fdr_in
) (abfd
, fraw_src
, fdr_ptr
);
10458 elf_tdata (abfd
)->find_line_info
= fi
;
10460 /* Note that we don't bother to ever free this information.
10461 find_nearest_line is either called all the time, as in
10462 objdump -l, so the information should be saved, or it is
10463 rarely called, as in ld error messages, so the memory
10464 wasted is unimportant. Still, it would probably be a
10465 good idea for free_cached_info to throw it away. */
10468 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
10469 &fi
->i
, filename_ptr
, functionname_ptr
,
10472 msec
->flags
= origflags
;
10476 msec
->flags
= origflags
;
10479 /* Fall back on the generic ELF find_nearest_line routine. */
10481 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
10482 filename_ptr
, functionname_ptr
,
10487 _bfd_mips_elf_find_inliner_info (bfd
*abfd
,
10488 const char **filename_ptr
,
10489 const char **functionname_ptr
,
10490 unsigned int *line_ptr
)
10493 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
10494 functionname_ptr
, line_ptr
,
10495 & elf_tdata (abfd
)->dwarf2_find_line_info
);
10500 /* When are writing out the .options or .MIPS.options section,
10501 remember the bytes we are writing out, so that we can install the
10502 GP value in the section_processing routine. */
10505 _bfd_mips_elf_set_section_contents (bfd
*abfd
, sec_ptr section
,
10506 const void *location
,
10507 file_ptr offset
, bfd_size_type count
)
10509 if (MIPS_ELF_OPTIONS_SECTION_NAME_P (section
->name
))
10513 if (elf_section_data (section
) == NULL
)
10515 bfd_size_type amt
= sizeof (struct bfd_elf_section_data
);
10516 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
10517 if (elf_section_data (section
) == NULL
)
10520 c
= mips_elf_section_data (section
)->u
.tdata
;
10523 c
= bfd_zalloc (abfd
, section
->size
);
10526 mips_elf_section_data (section
)->u
.tdata
= c
;
10529 memcpy (c
+ offset
, location
, count
);
10532 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
,
10536 /* This is almost identical to bfd_generic_get_... except that some
10537 MIPS relocations need to be handled specially. Sigh. */
10540 _bfd_elf_mips_get_relocated_section_contents
10542 struct bfd_link_info
*link_info
,
10543 struct bfd_link_order
*link_order
,
10545 bfd_boolean relocatable
,
10548 /* Get enough memory to hold the stuff */
10549 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
10550 asection
*input_section
= link_order
->u
.indirect
.section
;
10553 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
10554 arelent
**reloc_vector
= NULL
;
10557 if (reloc_size
< 0)
10560 reloc_vector
= bfd_malloc (reloc_size
);
10561 if (reloc_vector
== NULL
&& reloc_size
!= 0)
10564 /* read in the section */
10565 sz
= input_section
->rawsize
? input_section
->rawsize
: input_section
->size
;
10566 if (!bfd_get_section_contents (input_bfd
, input_section
, data
, 0, sz
))
10569 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
10573 if (reloc_count
< 0)
10576 if (reloc_count
> 0)
10581 bfd_vma gp
= 0x12345678; /* initialize just to shut gcc up */
10584 struct bfd_hash_entry
*h
;
10585 struct bfd_link_hash_entry
*lh
;
10586 /* Skip all this stuff if we aren't mixing formats. */
10587 if (abfd
&& input_bfd
10588 && abfd
->xvec
== input_bfd
->xvec
)
10592 h
= bfd_hash_lookup (&link_info
->hash
->table
, "_gp", FALSE
, FALSE
);
10593 lh
= (struct bfd_link_hash_entry
*) h
;
10600 case bfd_link_hash_undefined
:
10601 case bfd_link_hash_undefweak
:
10602 case bfd_link_hash_common
:
10605 case bfd_link_hash_defined
:
10606 case bfd_link_hash_defweak
:
10608 gp
= lh
->u
.def
.value
;
10610 case bfd_link_hash_indirect
:
10611 case bfd_link_hash_warning
:
10613 /* @@FIXME ignoring warning for now */
10615 case bfd_link_hash_new
:
10624 for (parent
= reloc_vector
; *parent
!= NULL
; parent
++)
10626 char *error_message
= NULL
;
10627 bfd_reloc_status_type r
;
10629 /* Specific to MIPS: Deal with relocation types that require
10630 knowing the gp of the output bfd. */
10631 asymbol
*sym
= *(*parent
)->sym_ptr_ptr
;
10633 /* If we've managed to find the gp and have a special
10634 function for the relocation then go ahead, else default
10635 to the generic handling. */
10637 && (*parent
)->howto
->special_function
10638 == _bfd_mips_elf32_gprel16_reloc
)
10639 r
= _bfd_mips_elf_gprel16_with_gp (input_bfd
, sym
, *parent
,
10640 input_section
, relocatable
,
10643 r
= bfd_perform_relocation (input_bfd
, *parent
, data
,
10645 relocatable
? abfd
: NULL
,
10650 asection
*os
= input_section
->output_section
;
10652 /* A partial link, so keep the relocs */
10653 os
->orelocation
[os
->reloc_count
] = *parent
;
10657 if (r
!= bfd_reloc_ok
)
10661 case bfd_reloc_undefined
:
10662 if (!((*link_info
->callbacks
->undefined_symbol
)
10663 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
10664 input_bfd
, input_section
, (*parent
)->address
, TRUE
)))
10667 case bfd_reloc_dangerous
:
10668 BFD_ASSERT (error_message
!= NULL
);
10669 if (!((*link_info
->callbacks
->reloc_dangerous
)
10670 (link_info
, error_message
, input_bfd
, input_section
,
10671 (*parent
)->address
)))
10674 case bfd_reloc_overflow
:
10675 if (!((*link_info
->callbacks
->reloc_overflow
)
10677 bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
10678 (*parent
)->howto
->name
, (*parent
)->addend
,
10679 input_bfd
, input_section
, (*parent
)->address
)))
10682 case bfd_reloc_outofrange
:
10691 if (reloc_vector
!= NULL
)
10692 free (reloc_vector
);
10696 if (reloc_vector
!= NULL
)
10697 free (reloc_vector
);
10701 /* Create a MIPS ELF linker hash table. */
10703 struct bfd_link_hash_table
*
10704 _bfd_mips_elf_link_hash_table_create (bfd
*abfd
)
10706 struct mips_elf_link_hash_table
*ret
;
10707 bfd_size_type amt
= sizeof (struct mips_elf_link_hash_table
);
10709 ret
= bfd_malloc (amt
);
10713 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
10714 mips_elf_link_hash_newfunc
,
10715 sizeof (struct mips_elf_link_hash_entry
)))
10722 /* We no longer use this. */
10723 for (i
= 0; i
< SIZEOF_MIPS_DYNSYM_SECNAMES
; i
++)
10724 ret
->dynsym_sec_strindex
[i
] = (bfd_size_type
) -1;
10726 ret
->procedure_count
= 0;
10727 ret
->compact_rel_size
= 0;
10728 ret
->use_rld_obj_head
= FALSE
;
10729 ret
->rld_value
= 0;
10730 ret
->mips16_stubs_seen
= FALSE
;
10731 ret
->computed_got_sizes
= FALSE
;
10732 ret
->is_vxworks
= FALSE
;
10733 ret
->small_data_overflow_reported
= FALSE
;
10734 ret
->srelbss
= NULL
;
10735 ret
->sdynbss
= NULL
;
10736 ret
->srelplt
= NULL
;
10737 ret
->srelplt2
= NULL
;
10738 ret
->sgotplt
= NULL
;
10740 ret
->sstubs
= NULL
;
10742 ret
->got_info
= NULL
;
10743 ret
->plt_header_size
= 0;
10744 ret
->plt_entry_size
= 0;
10745 ret
->function_stub_size
= 0;
10747 return &ret
->root
.root
;
10750 /* Likewise, but indicate that the target is VxWorks. */
10752 struct bfd_link_hash_table
*
10753 _bfd_mips_vxworks_link_hash_table_create (bfd
*abfd
)
10755 struct bfd_link_hash_table
*ret
;
10757 ret
= _bfd_mips_elf_link_hash_table_create (abfd
);
10760 struct mips_elf_link_hash_table
*htab
;
10762 htab
= (struct mips_elf_link_hash_table
*) ret
;
10763 htab
->is_vxworks
= 1;
10768 /* We need to use a special link routine to handle the .reginfo and
10769 the .mdebug sections. We need to merge all instances of these
10770 sections together, not write them all out sequentially. */
10773 _bfd_mips_elf_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
10776 struct bfd_link_order
*p
;
10777 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
10778 asection
*rtproc_sec
;
10779 Elf32_RegInfo reginfo
;
10780 struct ecoff_debug_info debug
;
10781 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10782 const struct ecoff_debug_swap
*swap
= bed
->elf_backend_ecoff_debug_swap
;
10783 HDRR
*symhdr
= &debug
.symbolic_header
;
10784 void *mdebug_handle
= NULL
;
10789 struct mips_elf_link_hash_table
*htab
;
10791 static const char * const secname
[] =
10793 ".text", ".init", ".fini", ".data",
10794 ".rodata", ".sdata", ".sbss", ".bss"
10796 static const int sc
[] =
10798 scText
, scInit
, scFini
, scData
,
10799 scRData
, scSData
, scSBss
, scBss
10802 /* We'd carefully arranged the dynamic symbol indices, and then the
10803 generic size_dynamic_sections renumbered them out from under us.
10804 Rather than trying somehow to prevent the renumbering, just do
10806 htab
= mips_elf_hash_table (info
);
10807 if (elf_hash_table (info
)->dynamic_sections_created
)
10809 struct mips_got_info
*g
;
10810 bfd_size_type dynsecsymcount
;
10812 /* When we resort, we must tell mips_elf_sort_hash_table what
10813 the lowest index it may use is. That's the number of section
10814 symbols we're going to add. The generic ELF linker only
10815 adds these symbols when building a shared object. Note that
10816 we count the sections after (possibly) removing the .options
10819 dynsecsymcount
= count_section_dynsyms (abfd
, info
);
10820 if (! mips_elf_sort_hash_table (info
, dynsecsymcount
+ 1))
10823 /* Make sure we didn't grow the global .got region. */
10824 g
= htab
->got_info
;
10825 if (g
->global_gotsym
!= NULL
)
10826 BFD_ASSERT ((elf_hash_table (info
)->dynsymcount
10827 - g
->global_gotsym
->dynindx
)
10828 <= g
->global_gotno
);
10831 /* Get a value for the GP register. */
10832 if (elf_gp (abfd
) == 0)
10834 struct bfd_link_hash_entry
*h
;
10836 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
10837 if (h
!= NULL
&& h
->type
== bfd_link_hash_defined
)
10838 elf_gp (abfd
) = (h
->u
.def
.value
10839 + h
->u
.def
.section
->output_section
->vma
10840 + h
->u
.def
.section
->output_offset
);
10841 else if (htab
->is_vxworks
10842 && (h
= bfd_link_hash_lookup (info
->hash
,
10843 "_GLOBAL_OFFSET_TABLE_",
10844 FALSE
, FALSE
, TRUE
))
10845 && h
->type
== bfd_link_hash_defined
)
10846 elf_gp (abfd
) = (h
->u
.def
.section
->output_section
->vma
10847 + h
->u
.def
.section
->output_offset
10849 else if (info
->relocatable
)
10851 bfd_vma lo
= MINUS_ONE
;
10853 /* Find the GP-relative section with the lowest offset. */
10854 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
10856 && (elf_section_data (o
)->this_hdr
.sh_flags
& SHF_MIPS_GPREL
))
10859 /* And calculate GP relative to that. */
10860 elf_gp (abfd
) = lo
+ ELF_MIPS_GP_OFFSET (info
);
10864 /* If the relocate_section function needs to do a reloc
10865 involving the GP value, it should make a reloc_dangerous
10866 callback to warn that GP is not defined. */
10870 /* Go through the sections and collect the .reginfo and .mdebug
10872 reginfo_sec
= NULL
;
10874 gptab_data_sec
= NULL
;
10875 gptab_bss_sec
= NULL
;
10876 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
10878 if (strcmp (o
->name
, ".reginfo") == 0)
10880 memset (®info
, 0, sizeof reginfo
);
10882 /* We have found the .reginfo section in the output file.
10883 Look through all the link_orders comprising it and merge
10884 the information together. */
10885 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10887 asection
*input_section
;
10889 Elf32_External_RegInfo ext
;
10892 if (p
->type
!= bfd_indirect_link_order
)
10894 if (p
->type
== bfd_data_link_order
)
10899 input_section
= p
->u
.indirect
.section
;
10900 input_bfd
= input_section
->owner
;
10902 if (! bfd_get_section_contents (input_bfd
, input_section
,
10903 &ext
, 0, sizeof ext
))
10906 bfd_mips_elf32_swap_reginfo_in (input_bfd
, &ext
, &sub
);
10908 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
10909 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
10910 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
10911 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
10912 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
10914 /* ri_gp_value is set by the function
10915 mips_elf32_section_processing when the section is
10916 finally written out. */
10918 /* Hack: reset the SEC_HAS_CONTENTS flag so that
10919 elf_link_input_bfd ignores this section. */
10920 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
10923 /* Size has been set in _bfd_mips_elf_always_size_sections. */
10924 BFD_ASSERT(o
->size
== sizeof (Elf32_External_RegInfo
));
10926 /* Skip this section later on (I don't think this currently
10927 matters, but someday it might). */
10928 o
->map_head
.link_order
= NULL
;
10933 if (strcmp (o
->name
, ".mdebug") == 0)
10935 struct extsym_info einfo
;
10938 /* We have found the .mdebug section in the output file.
10939 Look through all the link_orders comprising it and merge
10940 the information together. */
10941 symhdr
->magic
= swap
->sym_magic
;
10942 /* FIXME: What should the version stamp be? */
10943 symhdr
->vstamp
= 0;
10944 symhdr
->ilineMax
= 0;
10945 symhdr
->cbLine
= 0;
10946 symhdr
->idnMax
= 0;
10947 symhdr
->ipdMax
= 0;
10948 symhdr
->isymMax
= 0;
10949 symhdr
->ioptMax
= 0;
10950 symhdr
->iauxMax
= 0;
10951 symhdr
->issMax
= 0;
10952 symhdr
->issExtMax
= 0;
10953 symhdr
->ifdMax
= 0;
10955 symhdr
->iextMax
= 0;
10957 /* We accumulate the debugging information itself in the
10958 debug_info structure. */
10960 debug
.external_dnr
= NULL
;
10961 debug
.external_pdr
= NULL
;
10962 debug
.external_sym
= NULL
;
10963 debug
.external_opt
= NULL
;
10964 debug
.external_aux
= NULL
;
10966 debug
.ssext
= debug
.ssext_end
= NULL
;
10967 debug
.external_fdr
= NULL
;
10968 debug
.external_rfd
= NULL
;
10969 debug
.external_ext
= debug
.external_ext_end
= NULL
;
10971 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
10972 if (mdebug_handle
== NULL
)
10976 esym
.cobol_main
= 0;
10980 esym
.asym
.iss
= issNil
;
10981 esym
.asym
.st
= stLocal
;
10982 esym
.asym
.reserved
= 0;
10983 esym
.asym
.index
= indexNil
;
10985 for (i
= 0; i
< sizeof (secname
) / sizeof (secname
[0]); i
++)
10987 esym
.asym
.sc
= sc
[i
];
10988 s
= bfd_get_section_by_name (abfd
, secname
[i
]);
10991 esym
.asym
.value
= s
->vma
;
10992 last
= s
->vma
+ s
->size
;
10995 esym
.asym
.value
= last
;
10996 if (!bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
10997 secname
[i
], &esym
))
11001 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
11003 asection
*input_section
;
11005 const struct ecoff_debug_swap
*input_swap
;
11006 struct ecoff_debug_info input_debug
;
11010 if (p
->type
!= bfd_indirect_link_order
)
11012 if (p
->type
== bfd_data_link_order
)
11017 input_section
= p
->u
.indirect
.section
;
11018 input_bfd
= input_section
->owner
;
11020 if (bfd_get_flavour (input_bfd
) != bfd_target_elf_flavour
11021 || (get_elf_backend_data (input_bfd
)
11022 ->elf_backend_ecoff_debug_swap
) == NULL
)
11024 /* I don't know what a non MIPS ELF bfd would be
11025 doing with a .mdebug section, but I don't really
11026 want to deal with it. */
11030 input_swap
= (get_elf_backend_data (input_bfd
)
11031 ->elf_backend_ecoff_debug_swap
);
11033 BFD_ASSERT (p
->size
== input_section
->size
);
11035 /* The ECOFF linking code expects that we have already
11036 read in the debugging information and set up an
11037 ecoff_debug_info structure, so we do that now. */
11038 if (! _bfd_mips_elf_read_ecoff_info (input_bfd
, input_section
,
11042 if (! (bfd_ecoff_debug_accumulate
11043 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
11044 &input_debug
, input_swap
, info
)))
11047 /* Loop through the external symbols. For each one with
11048 interesting information, try to find the symbol in
11049 the linker global hash table and save the information
11050 for the output external symbols. */
11051 eraw_src
= input_debug
.external_ext
;
11052 eraw_end
= (eraw_src
11053 + (input_debug
.symbolic_header
.iextMax
11054 * input_swap
->external_ext_size
));
11056 eraw_src
< eraw_end
;
11057 eraw_src
+= input_swap
->external_ext_size
)
11061 struct mips_elf_link_hash_entry
*h
;
11063 (*input_swap
->swap_ext_in
) (input_bfd
, eraw_src
, &ext
);
11064 if (ext
.asym
.sc
== scNil
11065 || ext
.asym
.sc
== scUndefined
11066 || ext
.asym
.sc
== scSUndefined
)
11069 name
= input_debug
.ssext
+ ext
.asym
.iss
;
11070 h
= mips_elf_link_hash_lookup (mips_elf_hash_table (info
),
11071 name
, FALSE
, FALSE
, TRUE
);
11072 if (h
== NULL
|| h
->esym
.ifd
!= -2)
11077 BFD_ASSERT (ext
.ifd
11078 < input_debug
.symbolic_header
.ifdMax
);
11079 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
11085 /* Free up the information we just read. */
11086 free (input_debug
.line
);
11087 free (input_debug
.external_dnr
);
11088 free (input_debug
.external_pdr
);
11089 free (input_debug
.external_sym
);
11090 free (input_debug
.external_opt
);
11091 free (input_debug
.external_aux
);
11092 free (input_debug
.ss
);
11093 free (input_debug
.ssext
);
11094 free (input_debug
.external_fdr
);
11095 free (input_debug
.external_rfd
);
11096 free (input_debug
.external_ext
);
11098 /* Hack: reset the SEC_HAS_CONTENTS flag so that
11099 elf_link_input_bfd ignores this section. */
11100 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
11103 if (SGI_COMPAT (abfd
) && info
->shared
)
11105 /* Create .rtproc section. */
11106 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
11107 if (rtproc_sec
== NULL
)
11109 flagword flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
11110 | SEC_LINKER_CREATED
| SEC_READONLY
);
11112 rtproc_sec
= bfd_make_section_with_flags (abfd
,
11115 if (rtproc_sec
== NULL
11116 || ! bfd_set_section_alignment (abfd
, rtproc_sec
, 4))
11120 if (! mips_elf_create_procedure_table (mdebug_handle
, abfd
,
11126 /* Build the external symbol information. */
11129 einfo
.debug
= &debug
;
11131 einfo
.failed
= FALSE
;
11132 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
11133 mips_elf_output_extsym
, &einfo
);
11137 /* Set the size of the .mdebug section. */
11138 o
->size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
11140 /* Skip this section later on (I don't think this currently
11141 matters, but someday it might). */
11142 o
->map_head
.link_order
= NULL
;
11147 if (CONST_STRNEQ (o
->name
, ".gptab."))
11149 const char *subname
;
11152 Elf32_External_gptab
*ext_tab
;
11155 /* The .gptab.sdata and .gptab.sbss sections hold
11156 information describing how the small data area would
11157 change depending upon the -G switch. These sections
11158 not used in executables files. */
11159 if (! info
->relocatable
)
11161 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
11163 asection
*input_section
;
11165 if (p
->type
!= bfd_indirect_link_order
)
11167 if (p
->type
== bfd_data_link_order
)
11172 input_section
= p
->u
.indirect
.section
;
11174 /* Hack: reset the SEC_HAS_CONTENTS flag so that
11175 elf_link_input_bfd ignores this section. */
11176 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
11179 /* Skip this section later on (I don't think this
11180 currently matters, but someday it might). */
11181 o
->map_head
.link_order
= NULL
;
11183 /* Really remove the section. */
11184 bfd_section_list_remove (abfd
, o
);
11185 --abfd
->section_count
;
11190 /* There is one gptab for initialized data, and one for
11191 uninitialized data. */
11192 if (strcmp (o
->name
, ".gptab.sdata") == 0)
11193 gptab_data_sec
= o
;
11194 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
11198 (*_bfd_error_handler
)
11199 (_("%s: illegal section name `%s'"),
11200 bfd_get_filename (abfd
), o
->name
);
11201 bfd_set_error (bfd_error_nonrepresentable_section
);
11205 /* The linker script always combines .gptab.data and
11206 .gptab.sdata into .gptab.sdata, and likewise for
11207 .gptab.bss and .gptab.sbss. It is possible that there is
11208 no .sdata or .sbss section in the output file, in which
11209 case we must change the name of the output section. */
11210 subname
= o
->name
+ sizeof ".gptab" - 1;
11211 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
11213 if (o
== gptab_data_sec
)
11214 o
->name
= ".gptab.data";
11216 o
->name
= ".gptab.bss";
11217 subname
= o
->name
+ sizeof ".gptab" - 1;
11218 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
11221 /* Set up the first entry. */
11223 amt
= c
* sizeof (Elf32_gptab
);
11224 tab
= bfd_malloc (amt
);
11227 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
11228 tab
[0].gt_header
.gt_unused
= 0;
11230 /* Combine the input sections. */
11231 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
11233 asection
*input_section
;
11235 bfd_size_type size
;
11236 unsigned long last
;
11237 bfd_size_type gpentry
;
11239 if (p
->type
!= bfd_indirect_link_order
)
11241 if (p
->type
== bfd_data_link_order
)
11246 input_section
= p
->u
.indirect
.section
;
11247 input_bfd
= input_section
->owner
;
11249 /* Combine the gptab entries for this input section one
11250 by one. We know that the input gptab entries are
11251 sorted by ascending -G value. */
11252 size
= input_section
->size
;
11254 for (gpentry
= sizeof (Elf32_External_gptab
);
11256 gpentry
+= sizeof (Elf32_External_gptab
))
11258 Elf32_External_gptab ext_gptab
;
11259 Elf32_gptab int_gptab
;
11265 if (! (bfd_get_section_contents
11266 (input_bfd
, input_section
, &ext_gptab
, gpentry
,
11267 sizeof (Elf32_External_gptab
))))
11273 bfd_mips_elf32_swap_gptab_in (input_bfd
, &ext_gptab
,
11275 val
= int_gptab
.gt_entry
.gt_g_value
;
11276 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
11279 for (look
= 1; look
< c
; look
++)
11281 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
11282 tab
[look
].gt_entry
.gt_bytes
+= add
;
11284 if (tab
[look
].gt_entry
.gt_g_value
== val
)
11290 Elf32_gptab
*new_tab
;
11293 /* We need a new table entry. */
11294 amt
= (bfd_size_type
) (c
+ 1) * sizeof (Elf32_gptab
);
11295 new_tab
= bfd_realloc (tab
, amt
);
11296 if (new_tab
== NULL
)
11302 tab
[c
].gt_entry
.gt_g_value
= val
;
11303 tab
[c
].gt_entry
.gt_bytes
= add
;
11305 /* Merge in the size for the next smallest -G
11306 value, since that will be implied by this new
11309 for (look
= 1; look
< c
; look
++)
11311 if (tab
[look
].gt_entry
.gt_g_value
< val
11313 || (tab
[look
].gt_entry
.gt_g_value
11314 > tab
[max
].gt_entry
.gt_g_value
)))
11318 tab
[c
].gt_entry
.gt_bytes
+=
11319 tab
[max
].gt_entry
.gt_bytes
;
11324 last
= int_gptab
.gt_entry
.gt_bytes
;
11327 /* Hack: reset the SEC_HAS_CONTENTS flag so that
11328 elf_link_input_bfd ignores this section. */
11329 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
11332 /* The table must be sorted by -G value. */
11334 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
11336 /* Swap out the table. */
11337 amt
= (bfd_size_type
) c
* sizeof (Elf32_External_gptab
);
11338 ext_tab
= bfd_alloc (abfd
, amt
);
11339 if (ext_tab
== NULL
)
11345 for (j
= 0; j
< c
; j
++)
11346 bfd_mips_elf32_swap_gptab_out (abfd
, tab
+ j
, ext_tab
+ j
);
11349 o
->size
= c
* sizeof (Elf32_External_gptab
);
11350 o
->contents
= (bfd_byte
*) ext_tab
;
11352 /* Skip this section later on (I don't think this currently
11353 matters, but someday it might). */
11354 o
->map_head
.link_order
= NULL
;
11358 /* Invoke the regular ELF backend linker to do all the work. */
11359 if (!bfd_elf_final_link (abfd
, info
))
11362 /* Now write out the computed sections. */
11364 if (reginfo_sec
!= NULL
)
11366 Elf32_External_RegInfo ext
;
11368 bfd_mips_elf32_swap_reginfo_out (abfd
, ®info
, &ext
);
11369 if (! bfd_set_section_contents (abfd
, reginfo_sec
, &ext
, 0, sizeof ext
))
11373 if (mdebug_sec
!= NULL
)
11375 BFD_ASSERT (abfd
->output_has_begun
);
11376 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
11378 mdebug_sec
->filepos
))
11381 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
11384 if (gptab_data_sec
!= NULL
)
11386 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
11387 gptab_data_sec
->contents
,
11388 0, gptab_data_sec
->size
))
11392 if (gptab_bss_sec
!= NULL
)
11394 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
11395 gptab_bss_sec
->contents
,
11396 0, gptab_bss_sec
->size
))
11400 if (SGI_COMPAT (abfd
))
11402 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
11403 if (rtproc_sec
!= NULL
)
11405 if (! bfd_set_section_contents (abfd
, rtproc_sec
,
11406 rtproc_sec
->contents
,
11407 0, rtproc_sec
->size
))
11415 /* Structure for saying that BFD machine EXTENSION extends BASE. */
11417 struct mips_mach_extension
{
11418 unsigned long extension
, base
;
11422 /* An array describing how BFD machines relate to one another. The entries
11423 are ordered topologically with MIPS I extensions listed last. */
11425 static const struct mips_mach_extension mips_mach_extensions
[] = {
11426 /* MIPS64r2 extensions. */
11427 { bfd_mach_mips_octeon
, bfd_mach_mipsisa64r2
},
11429 /* MIPS64 extensions. */
11430 { bfd_mach_mipsisa64r2
, bfd_mach_mipsisa64
},
11431 { bfd_mach_mips_sb1
, bfd_mach_mipsisa64
},
11433 /* MIPS V extensions. */
11434 { bfd_mach_mipsisa64
, bfd_mach_mips5
},
11436 /* R10000 extensions. */
11437 { bfd_mach_mips12000
, bfd_mach_mips10000
},
11439 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
11440 vr5400 ISA, but doesn't include the multimedia stuff. It seems
11441 better to allow vr5400 and vr5500 code to be merged anyway, since
11442 many libraries will just use the core ISA. Perhaps we could add
11443 some sort of ASE flag if this ever proves a problem. */
11444 { bfd_mach_mips5500
, bfd_mach_mips5400
},
11445 { bfd_mach_mips5400
, bfd_mach_mips5000
},
11447 /* MIPS IV extensions. */
11448 { bfd_mach_mips5
, bfd_mach_mips8000
},
11449 { bfd_mach_mips10000
, bfd_mach_mips8000
},
11450 { bfd_mach_mips5000
, bfd_mach_mips8000
},
11451 { bfd_mach_mips7000
, bfd_mach_mips8000
},
11452 { bfd_mach_mips9000
, bfd_mach_mips8000
},
11454 /* VR4100 extensions. */
11455 { bfd_mach_mips4120
, bfd_mach_mips4100
},
11456 { bfd_mach_mips4111
, bfd_mach_mips4100
},
11458 /* MIPS III extensions. */
11459 { bfd_mach_mips_loongson_2e
, bfd_mach_mips4000
},
11460 { bfd_mach_mips_loongson_2f
, bfd_mach_mips4000
},
11461 { bfd_mach_mips8000
, bfd_mach_mips4000
},
11462 { bfd_mach_mips4650
, bfd_mach_mips4000
},
11463 { bfd_mach_mips4600
, bfd_mach_mips4000
},
11464 { bfd_mach_mips4400
, bfd_mach_mips4000
},
11465 { bfd_mach_mips4300
, bfd_mach_mips4000
},
11466 { bfd_mach_mips4100
, bfd_mach_mips4000
},
11467 { bfd_mach_mips4010
, bfd_mach_mips4000
},
11469 /* MIPS32 extensions. */
11470 { bfd_mach_mipsisa32r2
, bfd_mach_mipsisa32
},
11472 /* MIPS II extensions. */
11473 { bfd_mach_mips4000
, bfd_mach_mips6000
},
11474 { bfd_mach_mipsisa32
, bfd_mach_mips6000
},
11476 /* MIPS I extensions. */
11477 { bfd_mach_mips6000
, bfd_mach_mips3000
},
11478 { bfd_mach_mips3900
, bfd_mach_mips3000
}
11482 /* Return true if bfd machine EXTENSION is an extension of machine BASE. */
11485 mips_mach_extends_p (unsigned long base
, unsigned long extension
)
11489 if (extension
== base
)
11492 if (base
== bfd_mach_mipsisa32
11493 && mips_mach_extends_p (bfd_mach_mipsisa64
, extension
))
11496 if (base
== bfd_mach_mipsisa32r2
11497 && mips_mach_extends_p (bfd_mach_mipsisa64r2
, extension
))
11500 for (i
= 0; i
< ARRAY_SIZE (mips_mach_extensions
); i
++)
11501 if (extension
== mips_mach_extensions
[i
].extension
)
11503 extension
= mips_mach_extensions
[i
].base
;
11504 if (extension
== base
)
11512 /* Return true if the given ELF header flags describe a 32-bit binary. */
11515 mips_32bit_flags_p (flagword flags
)
11517 return ((flags
& EF_MIPS_32BITMODE
) != 0
11518 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
11519 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
11520 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
11521 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
11522 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
11523 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
);
11527 /* Merge object attributes from IBFD into OBFD. Raise an error if
11528 there are conflicting attributes. */
11530 mips_elf_merge_obj_attributes (bfd
*ibfd
, bfd
*obfd
)
11532 obj_attribute
*in_attr
;
11533 obj_attribute
*out_attr
;
11535 if (!elf_known_obj_attributes_proc (obfd
)[0].i
)
11537 /* This is the first object. Copy the attributes. */
11538 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
11540 /* Use the Tag_null value to indicate the attributes have been
11542 elf_known_obj_attributes_proc (obfd
)[0].i
= 1;
11547 /* Check for conflicting Tag_GNU_MIPS_ABI_FP attributes and merge
11548 non-conflicting ones. */
11549 in_attr
= elf_known_obj_attributes (ibfd
)[OBJ_ATTR_GNU
];
11550 out_attr
= elf_known_obj_attributes (obfd
)[OBJ_ATTR_GNU
];
11551 if (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
!= out_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
11553 out_attr
[Tag_GNU_MIPS_ABI_FP
].type
= 1;
11554 if (out_attr
[Tag_GNU_MIPS_ABI_FP
].i
== 0)
11555 out_attr
[Tag_GNU_MIPS_ABI_FP
].i
= in_attr
[Tag_GNU_MIPS_ABI_FP
].i
;
11556 else if (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
== 0)
11558 else if (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
> 4)
11560 (_("Warning: %B uses unknown floating point ABI %d"), ibfd
,
11561 in_attr
[Tag_GNU_MIPS_ABI_FP
].i
);
11562 else if (out_attr
[Tag_GNU_MIPS_ABI_FP
].i
> 4)
11564 (_("Warning: %B uses unknown floating point ABI %d"), obfd
,
11565 out_attr
[Tag_GNU_MIPS_ABI_FP
].i
);
11567 switch (out_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
11570 switch (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
11574 (_("Warning: %B uses -msingle-float, %B uses -mdouble-float"),
11580 (_("Warning: %B uses hard float, %B uses soft float"),
11586 (_("Warning: %B uses -msingle-float, %B uses -mips32r2 -mfp64"),
11596 switch (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
11600 (_("Warning: %B uses -msingle-float, %B uses -mdouble-float"),
11606 (_("Warning: %B uses hard float, %B uses soft float"),
11612 (_("Warning: %B uses -mdouble-float, %B uses -mips32r2 -mfp64"),
11622 switch (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
11628 (_("Warning: %B uses hard float, %B uses soft float"),
11638 switch (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
11642 (_("Warning: %B uses -msingle-float, %B uses -mips32r2 -mfp64"),
11648 (_("Warning: %B uses -mdouble-float, %B uses -mips32r2 -mfp64"),
11654 (_("Warning: %B uses hard float, %B uses soft float"),
11668 /* Merge Tag_compatibility attributes and any common GNU ones. */
11669 _bfd_elf_merge_object_attributes (ibfd
, obfd
);
11674 /* Merge backend specific data from an object file to the output
11675 object file when linking. */
11678 _bfd_mips_elf_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
11680 flagword old_flags
;
11681 flagword new_flags
;
11683 bfd_boolean null_input_bfd
= TRUE
;
11686 /* Check if we have the same endianess */
11687 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
11689 (*_bfd_error_handler
)
11690 (_("%B: endianness incompatible with that of the selected emulation"),
11695 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
11696 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
11699 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
11701 (*_bfd_error_handler
)
11702 (_("%B: ABI is incompatible with that of the selected emulation"),
11707 if (!mips_elf_merge_obj_attributes (ibfd
, obfd
))
11710 new_flags
= elf_elfheader (ibfd
)->e_flags
;
11711 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_NOREORDER
;
11712 old_flags
= elf_elfheader (obfd
)->e_flags
;
11714 if (! elf_flags_init (obfd
))
11716 elf_flags_init (obfd
) = TRUE
;
11717 elf_elfheader (obfd
)->e_flags
= new_flags
;
11718 elf_elfheader (obfd
)->e_ident
[EI_CLASS
]
11719 = elf_elfheader (ibfd
)->e_ident
[EI_CLASS
];
11721 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
11722 && (bfd_get_arch_info (obfd
)->the_default
11723 || mips_mach_extends_p (bfd_get_mach (obfd
),
11724 bfd_get_mach (ibfd
))))
11726 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
11727 bfd_get_mach (ibfd
)))
11734 /* Check flag compatibility. */
11736 new_flags
&= ~EF_MIPS_NOREORDER
;
11737 old_flags
&= ~EF_MIPS_NOREORDER
;
11739 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
11740 doesn't seem to matter. */
11741 new_flags
&= ~EF_MIPS_XGOT
;
11742 old_flags
&= ~EF_MIPS_XGOT
;
11744 /* MIPSpro generates ucode info in n64 objects. Again, we should
11745 just be able to ignore this. */
11746 new_flags
&= ~EF_MIPS_UCODE
;
11747 old_flags
&= ~EF_MIPS_UCODE
;
11749 /* Don't care about the PIC flags from dynamic objects; they are
11751 if ((new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0
11752 && (ibfd
->flags
& DYNAMIC
) != 0)
11753 new_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
11755 if (new_flags
== old_flags
)
11758 /* Check to see if the input BFD actually contains any sections.
11759 If not, its flags may not have been initialised either, but it cannot
11760 actually cause any incompatibility. */
11761 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
11763 /* Ignore synthetic sections and empty .text, .data and .bss sections
11764 which are automatically generated by gas. */
11765 if (strcmp (sec
->name
, ".reginfo")
11766 && strcmp (sec
->name
, ".mdebug")
11768 || (strcmp (sec
->name
, ".text")
11769 && strcmp (sec
->name
, ".data")
11770 && strcmp (sec
->name
, ".bss"))))
11772 null_input_bfd
= FALSE
;
11776 if (null_input_bfd
)
11781 if (((new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0)
11782 != ((old_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0))
11784 (*_bfd_error_handler
)
11785 (_("%B: warning: linking PIC files with non-PIC files"),
11790 if (new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
))
11791 elf_elfheader (obfd
)->e_flags
|= EF_MIPS_CPIC
;
11792 if (! (new_flags
& EF_MIPS_PIC
))
11793 elf_elfheader (obfd
)->e_flags
&= ~EF_MIPS_PIC
;
11795 new_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
11796 old_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
11798 /* Compare the ISAs. */
11799 if (mips_32bit_flags_p (old_flags
) != mips_32bit_flags_p (new_flags
))
11801 (*_bfd_error_handler
)
11802 (_("%B: linking 32-bit code with 64-bit code"),
11806 else if (!mips_mach_extends_p (bfd_get_mach (ibfd
), bfd_get_mach (obfd
)))
11808 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
11809 if (mips_mach_extends_p (bfd_get_mach (obfd
), bfd_get_mach (ibfd
)))
11811 /* Copy the architecture info from IBFD to OBFD. Also copy
11812 the 32-bit flag (if set) so that we continue to recognise
11813 OBFD as a 32-bit binary. */
11814 bfd_set_arch_info (obfd
, bfd_get_arch_info (ibfd
));
11815 elf_elfheader (obfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
11816 elf_elfheader (obfd
)->e_flags
11817 |= new_flags
& (EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
11819 /* Copy across the ABI flags if OBFD doesn't use them
11820 and if that was what caused us to treat IBFD as 32-bit. */
11821 if ((old_flags
& EF_MIPS_ABI
) == 0
11822 && mips_32bit_flags_p (new_flags
)
11823 && !mips_32bit_flags_p (new_flags
& ~EF_MIPS_ABI
))
11824 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ABI
;
11828 /* The ISAs aren't compatible. */
11829 (*_bfd_error_handler
)
11830 (_("%B: linking %s module with previous %s modules"),
11832 bfd_printable_name (ibfd
),
11833 bfd_printable_name (obfd
));
11838 new_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
11839 old_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
11841 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
11842 does set EI_CLASS differently from any 32-bit ABI. */
11843 if ((new_flags
& EF_MIPS_ABI
) != (old_flags
& EF_MIPS_ABI
)
11844 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
11845 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
11847 /* Only error if both are set (to different values). */
11848 if (((new_flags
& EF_MIPS_ABI
) && (old_flags
& EF_MIPS_ABI
))
11849 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
11850 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
11852 (*_bfd_error_handler
)
11853 (_("%B: ABI mismatch: linking %s module with previous %s modules"),
11855 elf_mips_abi_name (ibfd
),
11856 elf_mips_abi_name (obfd
));
11859 new_flags
&= ~EF_MIPS_ABI
;
11860 old_flags
&= ~EF_MIPS_ABI
;
11863 /* For now, allow arbitrary mixing of ASEs (retain the union). */
11864 if ((new_flags
& EF_MIPS_ARCH_ASE
) != (old_flags
& EF_MIPS_ARCH_ASE
))
11866 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ARCH_ASE
;
11868 new_flags
&= ~ EF_MIPS_ARCH_ASE
;
11869 old_flags
&= ~ EF_MIPS_ARCH_ASE
;
11872 /* Warn about any other mismatches */
11873 if (new_flags
!= old_flags
)
11875 (*_bfd_error_handler
)
11876 (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
11877 ibfd
, (unsigned long) new_flags
,
11878 (unsigned long) old_flags
);
11884 bfd_set_error (bfd_error_bad_value
);
11891 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
11894 _bfd_mips_elf_set_private_flags (bfd
*abfd
, flagword flags
)
11896 BFD_ASSERT (!elf_flags_init (abfd
)
11897 || elf_elfheader (abfd
)->e_flags
== flags
);
11899 elf_elfheader (abfd
)->e_flags
= flags
;
11900 elf_flags_init (abfd
) = TRUE
;
11905 _bfd_mips_elf_get_target_dtag (bfd_vma dtag
)
11909 default: return "";
11910 case DT_MIPS_RLD_VERSION
:
11911 return "MIPS_RLD_VERSION";
11912 case DT_MIPS_TIME_STAMP
:
11913 return "MIPS_TIME_STAMP";
11914 case DT_MIPS_ICHECKSUM
:
11915 return "MIPS_ICHECKSUM";
11916 case DT_MIPS_IVERSION
:
11917 return "MIPS_IVERSION";
11918 case DT_MIPS_FLAGS
:
11919 return "MIPS_FLAGS";
11920 case DT_MIPS_BASE_ADDRESS
:
11921 return "MIPS_BASE_ADDRESS";
11923 return "MIPS_MSYM";
11924 case DT_MIPS_CONFLICT
:
11925 return "MIPS_CONFLICT";
11926 case DT_MIPS_LIBLIST
:
11927 return "MIPS_LIBLIST";
11928 case DT_MIPS_LOCAL_GOTNO
:
11929 return "MIPS_LOCAL_GOTNO";
11930 case DT_MIPS_CONFLICTNO
:
11931 return "MIPS_CONFLICTNO";
11932 case DT_MIPS_LIBLISTNO
:
11933 return "MIPS_LIBLISTNO";
11934 case DT_MIPS_SYMTABNO
:
11935 return "MIPS_SYMTABNO";
11936 case DT_MIPS_UNREFEXTNO
:
11937 return "MIPS_UNREFEXTNO";
11938 case DT_MIPS_GOTSYM
:
11939 return "MIPS_GOTSYM";
11940 case DT_MIPS_HIPAGENO
:
11941 return "MIPS_HIPAGENO";
11942 case DT_MIPS_RLD_MAP
:
11943 return "MIPS_RLD_MAP";
11944 case DT_MIPS_DELTA_CLASS
:
11945 return "MIPS_DELTA_CLASS";
11946 case DT_MIPS_DELTA_CLASS_NO
:
11947 return "MIPS_DELTA_CLASS_NO";
11948 case DT_MIPS_DELTA_INSTANCE
:
11949 return "MIPS_DELTA_INSTANCE";
11950 case DT_MIPS_DELTA_INSTANCE_NO
:
11951 return "MIPS_DELTA_INSTANCE_NO";
11952 case DT_MIPS_DELTA_RELOC
:
11953 return "MIPS_DELTA_RELOC";
11954 case DT_MIPS_DELTA_RELOC_NO
:
11955 return "MIPS_DELTA_RELOC_NO";
11956 case DT_MIPS_DELTA_SYM
:
11957 return "MIPS_DELTA_SYM";
11958 case DT_MIPS_DELTA_SYM_NO
:
11959 return "MIPS_DELTA_SYM_NO";
11960 case DT_MIPS_DELTA_CLASSSYM
:
11961 return "MIPS_DELTA_CLASSSYM";
11962 case DT_MIPS_DELTA_CLASSSYM_NO
:
11963 return "MIPS_DELTA_CLASSSYM_NO";
11964 case DT_MIPS_CXX_FLAGS
:
11965 return "MIPS_CXX_FLAGS";
11966 case DT_MIPS_PIXIE_INIT
:
11967 return "MIPS_PIXIE_INIT";
11968 case DT_MIPS_SYMBOL_LIB
:
11969 return "MIPS_SYMBOL_LIB";
11970 case DT_MIPS_LOCALPAGE_GOTIDX
:
11971 return "MIPS_LOCALPAGE_GOTIDX";
11972 case DT_MIPS_LOCAL_GOTIDX
:
11973 return "MIPS_LOCAL_GOTIDX";
11974 case DT_MIPS_HIDDEN_GOTIDX
:
11975 return "MIPS_HIDDEN_GOTIDX";
11976 case DT_MIPS_PROTECTED_GOTIDX
:
11977 return "MIPS_PROTECTED_GOT_IDX";
11978 case DT_MIPS_OPTIONS
:
11979 return "MIPS_OPTIONS";
11980 case DT_MIPS_INTERFACE
:
11981 return "MIPS_INTERFACE";
11982 case DT_MIPS_DYNSTR_ALIGN
:
11983 return "DT_MIPS_DYNSTR_ALIGN";
11984 case DT_MIPS_INTERFACE_SIZE
:
11985 return "DT_MIPS_INTERFACE_SIZE";
11986 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
:
11987 return "DT_MIPS_RLD_TEXT_RESOLVE_ADDR";
11988 case DT_MIPS_PERF_SUFFIX
:
11989 return "DT_MIPS_PERF_SUFFIX";
11990 case DT_MIPS_COMPACT_SIZE
:
11991 return "DT_MIPS_COMPACT_SIZE";
11992 case DT_MIPS_GP_VALUE
:
11993 return "DT_MIPS_GP_VALUE";
11994 case DT_MIPS_AUX_DYNAMIC
:
11995 return "DT_MIPS_AUX_DYNAMIC";
12000 _bfd_mips_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
12004 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
12006 /* Print normal ELF private data. */
12007 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
12009 /* xgettext:c-format */
12010 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
12012 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
)
12013 fprintf (file
, _(" [abi=O32]"));
12014 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O64
)
12015 fprintf (file
, _(" [abi=O64]"));
12016 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
)
12017 fprintf (file
, _(" [abi=EABI32]"));
12018 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
12019 fprintf (file
, _(" [abi=EABI64]"));
12020 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
))
12021 fprintf (file
, _(" [abi unknown]"));
12022 else if (ABI_N32_P (abfd
))
12023 fprintf (file
, _(" [abi=N32]"));
12024 else if (ABI_64_P (abfd
))
12025 fprintf (file
, _(" [abi=64]"));
12027 fprintf (file
, _(" [no abi set]"));
12029 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
12030 fprintf (file
, " [mips1]");
12031 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
12032 fprintf (file
, " [mips2]");
12033 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
12034 fprintf (file
, " [mips3]");
12035 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
12036 fprintf (file
, " [mips4]");
12037 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_5
)
12038 fprintf (file
, " [mips5]");
12039 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
)
12040 fprintf (file
, " [mips32]");
12041 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64
)
12042 fprintf (file
, " [mips64]");
12043 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
)
12044 fprintf (file
, " [mips32r2]");
12045 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64R2
)
12046 fprintf (file
, " [mips64r2]");
12048 fprintf (file
, _(" [unknown ISA]"));
12050 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
12051 fprintf (file
, " [mdmx]");
12053 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_M16
)
12054 fprintf (file
, " [mips16]");
12056 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_32BITMODE
)
12057 fprintf (file
, " [32bitmode]");
12059 fprintf (file
, _(" [not 32bitmode]"));
12061 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_NOREORDER
)
12062 fprintf (file
, " [noreorder]");
12064 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_PIC
)
12065 fprintf (file
, " [PIC]");
12067 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_CPIC
)
12068 fprintf (file
, " [CPIC]");
12070 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_XGOT
)
12071 fprintf (file
, " [XGOT]");
12073 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_UCODE
)
12074 fprintf (file
, " [UCODE]");
12076 fputc ('\n', file
);
12081 const struct bfd_elf_special_section _bfd_mips_elf_special_sections
[] =
12083 { STRING_COMMA_LEN (".lit4"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
12084 { STRING_COMMA_LEN (".lit8"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
12085 { STRING_COMMA_LEN (".mdebug"), 0, SHT_MIPS_DEBUG
, 0 },
12086 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
12087 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
12088 { STRING_COMMA_LEN (".ucode"), 0, SHT_MIPS_UCODE
, 0 },
12089 { NULL
, 0, 0, 0, 0 }
12092 /* Merge non visibility st_other attributes. Ensure that the
12093 STO_OPTIONAL flag is copied into h->other, even if this is not a
12094 definiton of the symbol. */
12096 _bfd_mips_elf_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
12097 const Elf_Internal_Sym
*isym
,
12098 bfd_boolean definition
,
12099 bfd_boolean dynamic ATTRIBUTE_UNUSED
)
12101 if ((isym
->st_other
& ~ELF_ST_VISIBILITY (-1)) != 0)
12103 unsigned char other
;
12105 other
= (definition
? isym
->st_other
: h
->other
);
12106 other
&= ~ELF_ST_VISIBILITY (-1);
12107 h
->other
= other
| ELF_ST_VISIBILITY (h
->other
);
12111 && ELF_MIPS_IS_OPTIONAL (isym
->st_other
))
12112 h
->other
|= STO_OPTIONAL
;
12115 /* Decide whether an undefined symbol is special and can be ignored.
12116 This is the case for OPTIONAL symbols on IRIX. */
12118 _bfd_mips_elf_ignore_undef_symbol (struct elf_link_hash_entry
*h
)
12120 return ELF_MIPS_IS_OPTIONAL (h
->other
) ? TRUE
: FALSE
;
12124 _bfd_mips_elf_common_definition (Elf_Internal_Sym
*sym
)
12126 return (sym
->st_shndx
== SHN_COMMON
12127 || sym
->st_shndx
== SHN_MIPS_ACOMMON
12128 || sym
->st_shndx
== SHN_MIPS_SCOMMON
);