1 /* MIPS-specific support for ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
5 Most of the information added by Ian Lance Taylor, Cygnus Support,
7 N32/64 ABI support added by Mark Mitchell, CodeSourcery, LLC.
8 <mark@codesourcery.com>
9 Traditional MIPS targets support added by Koundinya.K, Dansk Data
10 Elektronik & Operations Research Group. <kk@ddeorg.soft.net>
12 This file is part of BFD, the Binary File Descriptor library.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 2 of the License, or
17 (at your option) any later version.
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
28 /* This file handles functionality common to the different MIPS ABI's. */
33 #include "libiberty.h"
35 #include "elfxx-mips.h"
37 #include "elf-vxworks.h"
39 /* Get the ECOFF swapping routines. */
41 #include "coff/symconst.h"
42 #include "coff/ecoff.h"
43 #include "coff/mips.h"
47 /* This structure is used to hold information about one GOT entry.
48 There are three types of entry:
50 (1) absolute addresses
52 (2) SYMBOL + OFFSET addresses, where SYMBOL is local to an input bfd
53 (abfd != NULL, symndx >= 0)
54 (3) global and forced-local symbols
55 (abfd != NULL, symndx == -1)
57 Type (3) entries are treated differently for different types of GOT.
58 In the "master" GOT -- i.e. the one that describes every GOT
59 reference needed in the link -- the mips_got_entry is keyed on both
60 the symbol and the input bfd that references it. If it turns out
61 that we need multiple GOTs, we can then use this information to
62 create separate GOTs for each input bfd.
64 However, we want each of these separate GOTs to have at most one
65 entry for a given symbol, so their type (3) entries are keyed only
66 on the symbol. The input bfd given by the "abfd" field is somewhat
67 arbitrary in this case.
69 This means that when there are multiple GOTs, each GOT has a unique
70 mips_got_entry for every symbol within it. We can therefore use the
71 mips_got_entry fields (tls_type and gotidx) to track the symbol's
74 However, if it turns out that we need only a single GOT, we continue
75 to use the master GOT to describe it. There may therefore be several
76 mips_got_entries for the same symbol, each with a different input bfd.
77 We want to make sure that each symbol gets a unique GOT entry, so when
78 there's a single GOT, we use the symbol's hash entry, not the
79 mips_got_entry fields, to track a symbol's GOT index. */
82 /* The input bfd in which the symbol is defined. */
84 /* The index of the symbol, as stored in the relocation r_info, if
85 we have a local symbol; -1 otherwise. */
89 /* If abfd == NULL, an address that must be stored in the got. */
91 /* If abfd != NULL && symndx != -1, the addend of the relocation
92 that should be added to the symbol value. */
94 /* If abfd != NULL && symndx == -1, the hash table entry
95 corresponding to a global symbol in the got (or, local, if
97 struct mips_elf_link_hash_entry
*h
;
100 /* The TLS types included in this GOT entry (specifically, GD and
101 IE). The GD and IE flags can be added as we encounter new
102 relocations. LDM can also be set; it will always be alone, not
103 combined with any GD or IE flags. An LDM GOT entry will be
104 a local symbol entry with r_symndx == 0. */
105 unsigned char tls_type
;
107 /* The offset from the beginning of the .got section to the entry
108 corresponding to this symbol+addend. If it's a global symbol
109 whose offset is yet to be decided, it's going to be -1. */
113 /* This structure is used to hold .got information when linking. */
117 /* The global symbol in the GOT with the lowest index in the dynamic
119 struct elf_link_hash_entry
*global_gotsym
;
120 /* The number of global .got entries. */
121 unsigned int global_gotno
;
122 /* The number of .got slots used for TLS. */
123 unsigned int tls_gotno
;
124 /* The first unused TLS .got entry. Used only during
125 mips_elf_initialize_tls_index. */
126 unsigned int tls_assigned_gotno
;
127 /* The number of local .got entries. */
128 unsigned int local_gotno
;
129 /* The number of local .got entries we have used. */
130 unsigned int assigned_gotno
;
131 /* A hash table holding members of the got. */
132 struct htab
*got_entries
;
133 /* A hash table mapping input bfds to other mips_got_info. NULL
134 unless multi-got was necessary. */
135 struct htab
*bfd2got
;
136 /* In multi-got links, a pointer to the next got (err, rather, most
137 of the time, it points to the previous got). */
138 struct mips_got_info
*next
;
139 /* This is the GOT index of the TLS LDM entry for the GOT, MINUS_ONE
140 for none, or MINUS_TWO for not yet assigned. This is needed
141 because a single-GOT link may have multiple hash table entries
142 for the LDM. It does not get initialized in multi-GOT mode. */
143 bfd_vma tls_ldm_offset
;
146 /* Map an input bfd to a got in a multi-got link. */
148 struct mips_elf_bfd2got_hash
{
150 struct mips_got_info
*g
;
153 /* Structure passed when traversing the bfd2got hash table, used to
154 create and merge bfd's gots. */
156 struct mips_elf_got_per_bfd_arg
158 /* A hashtable that maps bfds to gots. */
160 /* The output bfd. */
162 /* The link information. */
163 struct bfd_link_info
*info
;
164 /* A pointer to the primary got, i.e., the one that's going to get
165 the implicit relocations from DT_MIPS_LOCAL_GOTNO and
167 struct mips_got_info
*primary
;
168 /* A non-primary got we're trying to merge with other input bfd's
170 struct mips_got_info
*current
;
171 /* The maximum number of got entries that can be addressed with a
173 unsigned int max_count
;
174 /* The number of local and global entries in the primary got. */
175 unsigned int primary_count
;
176 /* The number of local and global entries in the current got. */
177 unsigned int current_count
;
178 /* The total number of global entries which will live in the
179 primary got and be automatically relocated. This includes
180 those not referenced by the primary GOT but included in
182 unsigned int global_count
;
185 /* Another structure used to pass arguments for got entries traversal. */
187 struct mips_elf_set_global_got_offset_arg
189 struct mips_got_info
*g
;
191 unsigned int needed_relocs
;
192 struct bfd_link_info
*info
;
195 /* A structure used to count TLS relocations or GOT entries, for GOT
196 entry or ELF symbol table traversal. */
198 struct mips_elf_count_tls_arg
200 struct bfd_link_info
*info
;
204 struct _mips_elf_section_data
206 struct bfd_elf_section_data elf
;
209 struct mips_got_info
*got_info
;
214 #define mips_elf_section_data(sec) \
215 ((struct _mips_elf_section_data *) elf_section_data (sec))
217 /* This structure is passed to mips_elf_sort_hash_table_f when sorting
218 the dynamic symbols. */
220 struct mips_elf_hash_sort_data
222 /* The symbol in the global GOT with the lowest dynamic symbol table
224 struct elf_link_hash_entry
*low
;
225 /* The least dynamic symbol table index corresponding to a non-TLS
226 symbol with a GOT entry. */
227 long min_got_dynindx
;
228 /* The greatest dynamic symbol table index corresponding to a symbol
229 with a GOT entry that is not referenced (e.g., a dynamic symbol
230 with dynamic relocations pointing to it from non-primary GOTs). */
231 long max_unref_got_dynindx
;
232 /* The greatest dynamic symbol table index not corresponding to a
233 symbol without a GOT entry. */
234 long max_non_got_dynindx
;
237 /* The MIPS ELF linker needs additional information for each symbol in
238 the global hash table. */
240 struct mips_elf_link_hash_entry
242 struct elf_link_hash_entry root
;
244 /* External symbol information. */
247 /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
249 unsigned int possibly_dynamic_relocs
;
251 /* If the R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 reloc is against
252 a readonly section. */
253 bfd_boolean readonly_reloc
;
255 /* We must not create a stub for a symbol that has relocations
256 related to taking the function's address, i.e. any but
257 R_MIPS_CALL*16 ones -- see "MIPS ABI Supplement, 3rd Edition",
259 bfd_boolean no_fn_stub
;
261 /* If there is a stub that 32 bit functions should use to call this
262 16 bit function, this points to the section containing the stub. */
265 /* Whether we need the fn_stub; this is set if this symbol appears
266 in any relocs other than a 16 bit call. */
267 bfd_boolean need_fn_stub
;
269 /* If there is a stub that 16 bit functions should use to call this
270 32 bit function, this points to the section containing the stub. */
273 /* This is like the call_stub field, but it is used if the function
274 being called returns a floating point value. */
275 asection
*call_fp_stub
;
277 /* Are we forced local? This will only be set if we have converted
278 the initial global GOT entry to a local GOT entry. */
279 bfd_boolean forced_local
;
281 /* Are we referenced by some kind of relocation? */
282 bfd_boolean is_relocation_target
;
284 /* Are we referenced by branch relocations? */
285 bfd_boolean is_branch_target
;
289 #define GOT_TLS_LDM 2
291 #define GOT_TLS_OFFSET_DONE 0x40
292 #define GOT_TLS_DONE 0x80
293 unsigned char tls_type
;
294 /* This is only used in single-GOT mode; in multi-GOT mode there
295 is one mips_got_entry per GOT entry, so the offset is stored
296 there. In single-GOT mode there may be many mips_got_entry
297 structures all referring to the same GOT slot. It might be
298 possible to use root.got.offset instead, but that field is
299 overloaded already. */
300 bfd_vma tls_got_offset
;
303 /* MIPS ELF linker hash table. */
305 struct mips_elf_link_hash_table
307 struct elf_link_hash_table root
;
309 /* We no longer use this. */
310 /* String section indices for the dynamic section symbols. */
311 bfd_size_type dynsym_sec_strindex
[SIZEOF_MIPS_DYNSYM_SECNAMES
];
313 /* The number of .rtproc entries. */
314 bfd_size_type procedure_count
;
315 /* The size of the .compact_rel section (if SGI_COMPAT). */
316 bfd_size_type compact_rel_size
;
317 /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic
318 entry is set to the address of __rld_obj_head as in IRIX5. */
319 bfd_boolean use_rld_obj_head
;
320 /* This is the value of the __rld_map or __rld_obj_head symbol. */
322 /* This is set if we see any mips16 stub sections. */
323 bfd_boolean mips16_stubs_seen
;
324 /* True if we're generating code for VxWorks. */
325 bfd_boolean is_vxworks
;
326 /* Shortcuts to some dynamic sections, or NULL if they are not
334 /* The size of the PLT header in bytes (VxWorks only). */
335 bfd_vma plt_header_size
;
336 /* The size of a PLT entry in bytes (VxWorks only). */
337 bfd_vma plt_entry_size
;
340 #define TLS_RELOC_P(r_type) \
341 (r_type == R_MIPS_TLS_DTPMOD32 \
342 || r_type == R_MIPS_TLS_DTPMOD64 \
343 || r_type == R_MIPS_TLS_DTPREL32 \
344 || r_type == R_MIPS_TLS_DTPREL64 \
345 || r_type == R_MIPS_TLS_GD \
346 || r_type == R_MIPS_TLS_LDM \
347 || r_type == R_MIPS_TLS_DTPREL_HI16 \
348 || r_type == R_MIPS_TLS_DTPREL_LO16 \
349 || r_type == R_MIPS_TLS_GOTTPREL \
350 || r_type == R_MIPS_TLS_TPREL32 \
351 || r_type == R_MIPS_TLS_TPREL64 \
352 || r_type == R_MIPS_TLS_TPREL_HI16 \
353 || r_type == R_MIPS_TLS_TPREL_LO16)
355 /* Structure used to pass information to mips_elf_output_extsym. */
360 struct bfd_link_info
*info
;
361 struct ecoff_debug_info
*debug
;
362 const struct ecoff_debug_swap
*swap
;
366 /* The names of the runtime procedure table symbols used on IRIX5. */
368 static const char * const mips_elf_dynsym_rtproc_names
[] =
371 "_procedure_string_table",
372 "_procedure_table_size",
376 /* These structures are used to generate the .compact_rel section on
381 unsigned long id1
; /* Always one? */
382 unsigned long num
; /* Number of compact relocation entries. */
383 unsigned long id2
; /* Always two? */
384 unsigned long offset
; /* The file offset of the first relocation. */
385 unsigned long reserved0
; /* Zero? */
386 unsigned long reserved1
; /* Zero? */
395 bfd_byte reserved0
[4];
396 bfd_byte reserved1
[4];
397 } Elf32_External_compact_rel
;
401 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
402 unsigned int rtype
: 4; /* Relocation types. See below. */
403 unsigned int dist2to
: 8;
404 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
405 unsigned long konst
; /* KONST field. See below. */
406 unsigned long vaddr
; /* VADDR to be relocated. */
411 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
412 unsigned int rtype
: 4; /* Relocation types. See below. */
413 unsigned int dist2to
: 8;
414 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
415 unsigned long konst
; /* KONST field. See below. */
423 } Elf32_External_crinfo
;
429 } Elf32_External_crinfo2
;
431 /* These are the constants used to swap the bitfields in a crinfo. */
433 #define CRINFO_CTYPE (0x1)
434 #define CRINFO_CTYPE_SH (31)
435 #define CRINFO_RTYPE (0xf)
436 #define CRINFO_RTYPE_SH (27)
437 #define CRINFO_DIST2TO (0xff)
438 #define CRINFO_DIST2TO_SH (19)
439 #define CRINFO_RELVADDR (0x7ffff)
440 #define CRINFO_RELVADDR_SH (0)
442 /* A compact relocation info has long (3 words) or short (2 words)
443 formats. A short format doesn't have VADDR field and relvaddr
444 fields contains ((VADDR - vaddr of the previous entry) >> 2). */
445 #define CRF_MIPS_LONG 1
446 #define CRF_MIPS_SHORT 0
448 /* There are 4 types of compact relocation at least. The value KONST
449 has different meaning for each type:
452 CT_MIPS_REL32 Address in data
453 CT_MIPS_WORD Address in word (XXX)
454 CT_MIPS_GPHI_LO GP - vaddr
455 CT_MIPS_JMPAD Address to jump
458 #define CRT_MIPS_REL32 0xa
459 #define CRT_MIPS_WORD 0xb
460 #define CRT_MIPS_GPHI_LO 0xc
461 #define CRT_MIPS_JMPAD 0xd
463 #define mips_elf_set_cr_format(x,format) ((x).ctype = (format))
464 #define mips_elf_set_cr_type(x,type) ((x).rtype = (type))
465 #define mips_elf_set_cr_dist2to(x,v) ((x).dist2to = (v))
466 #define mips_elf_set_cr_relvaddr(x,d) ((x).relvaddr = (d)<<2)
468 /* The structure of the runtime procedure descriptor created by the
469 loader for use by the static exception system. */
471 typedef struct runtime_pdr
{
472 bfd_vma adr
; /* Memory address of start of procedure. */
473 long regmask
; /* Save register mask. */
474 long regoffset
; /* Save register offset. */
475 long fregmask
; /* Save floating point register mask. */
476 long fregoffset
; /* Save floating point register offset. */
477 long frameoffset
; /* Frame size. */
478 short framereg
; /* Frame pointer register. */
479 short pcreg
; /* Offset or reg of return pc. */
480 long irpss
; /* Index into the runtime string table. */
482 struct exception_info
*exception_info
;/* Pointer to exception array. */
484 #define cbRPDR sizeof (RPDR)
485 #define rpdNil ((pRPDR) 0)
487 static struct mips_got_entry
*mips_elf_create_local_got_entry
488 (bfd
*, struct bfd_link_info
*, bfd
*, struct mips_got_info
*, asection
*,
489 asection
*, bfd_vma
, unsigned long, struct mips_elf_link_hash_entry
*, int);
490 static bfd_boolean mips_elf_sort_hash_table_f
491 (struct mips_elf_link_hash_entry
*, void *);
492 static bfd_vma mips_elf_high
494 static bfd_boolean mips_elf_stub_section_p
496 static bfd_boolean mips_elf_create_dynamic_relocation
497 (bfd
*, struct bfd_link_info
*, const Elf_Internal_Rela
*,
498 struct mips_elf_link_hash_entry
*, asection
*, bfd_vma
,
499 bfd_vma
*, asection
*);
500 static hashval_t mips_elf_got_entry_hash
502 static bfd_vma mips_elf_adjust_gp
503 (bfd
*, struct mips_got_info
*, bfd
*);
504 static struct mips_got_info
*mips_elf_got_for_ibfd
505 (struct mips_got_info
*, bfd
*);
507 /* This will be used when we sort the dynamic relocation records. */
508 static bfd
*reldyn_sorting_bfd
;
510 /* Nonzero if ABFD is using the N32 ABI. */
511 #define ABI_N32_P(abfd) \
512 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
514 /* Nonzero if ABFD is using the N64 ABI. */
515 #define ABI_64_P(abfd) \
516 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
518 /* Nonzero if ABFD is using NewABI conventions. */
519 #define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
521 /* The IRIX compatibility level we are striving for. */
522 #define IRIX_COMPAT(abfd) \
523 (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
525 /* Whether we are trying to be compatible with IRIX at all. */
526 #define SGI_COMPAT(abfd) \
527 (IRIX_COMPAT (abfd) != ict_none)
529 /* The name of the options section. */
530 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
531 (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
533 /* True if NAME is the recognized name of any SHT_MIPS_OPTIONS section.
534 Some IRIX system files do not use MIPS_ELF_OPTIONS_SECTION_NAME. */
535 #define MIPS_ELF_OPTIONS_SECTION_NAME_P(NAME) \
536 (strcmp (NAME, ".MIPS.options") == 0 || strcmp (NAME, ".options") == 0)
538 /* Whether the section is readonly. */
539 #define MIPS_ELF_READONLY_SECTION(sec) \
540 ((sec->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY)) \
541 == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
543 /* The name of the stub section. */
544 #define MIPS_ELF_STUB_SECTION_NAME(abfd) ".MIPS.stubs"
546 /* The size of an external REL relocation. */
547 #define MIPS_ELF_REL_SIZE(abfd) \
548 (get_elf_backend_data (abfd)->s->sizeof_rel)
550 /* The size of an external RELA relocation. */
551 #define MIPS_ELF_RELA_SIZE(abfd) \
552 (get_elf_backend_data (abfd)->s->sizeof_rela)
554 /* The size of an external dynamic table entry. */
555 #define MIPS_ELF_DYN_SIZE(abfd) \
556 (get_elf_backend_data (abfd)->s->sizeof_dyn)
558 /* The size of a GOT entry. */
559 #define MIPS_ELF_GOT_SIZE(abfd) \
560 (get_elf_backend_data (abfd)->s->arch_size / 8)
562 /* The size of a symbol-table entry. */
563 #define MIPS_ELF_SYM_SIZE(abfd) \
564 (get_elf_backend_data (abfd)->s->sizeof_sym)
566 /* The default alignment for sections, as a power of two. */
567 #define MIPS_ELF_LOG_FILE_ALIGN(abfd) \
568 (get_elf_backend_data (abfd)->s->log_file_align)
570 /* Get word-sized data. */
571 #define MIPS_ELF_GET_WORD(abfd, ptr) \
572 (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
574 /* Put out word-sized data. */
575 #define MIPS_ELF_PUT_WORD(abfd, val, ptr) \
577 ? bfd_put_64 (abfd, val, ptr) \
578 : bfd_put_32 (abfd, val, ptr))
580 /* Add a dynamic symbol table-entry. */
581 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
582 _bfd_elf_add_dynamic_entry (info, tag, val)
584 #define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela) \
585 (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela))
587 /* Determine whether the internal relocation of index REL_IDX is REL
588 (zero) or RELA (non-zero). The assumption is that, if there are
589 two relocation sections for this section, one of them is REL and
590 the other is RELA. If the index of the relocation we're testing is
591 in range for the first relocation section, check that the external
592 relocation size is that for RELA. It is also assumed that, if
593 rel_idx is not in range for the first section, and this first
594 section contains REL relocs, then the relocation is in the second
595 section, that is RELA. */
596 #define MIPS_RELOC_RELA_P(abfd, sec, rel_idx) \
597 ((NUM_SHDR_ENTRIES (&elf_section_data (sec)->rel_hdr) \
598 * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel \
599 > (bfd_vma)(rel_idx)) \
600 == (elf_section_data (sec)->rel_hdr.sh_entsize \
601 == (ABI_64_P (abfd) ? sizeof (Elf64_External_Rela) \
602 : sizeof (Elf32_External_Rela))))
604 /* The name of the dynamic relocation section. */
605 #define MIPS_ELF_REL_DYN_NAME(INFO) \
606 (mips_elf_hash_table (INFO)->is_vxworks ? ".rela.dyn" : ".rel.dyn")
608 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
609 from smaller values. Start with zero, widen, *then* decrement. */
610 #define MINUS_ONE (((bfd_vma)0) - 1)
611 #define MINUS_TWO (((bfd_vma)0) - 2)
613 /* The number of local .got entries we reserve. */
614 #define MIPS_RESERVED_GOTNO(INFO) \
615 (mips_elf_hash_table (INFO)->is_vxworks ? 3 : 2)
617 /* The offset of $gp from the beginning of the .got section. */
618 #define ELF_MIPS_GP_OFFSET(INFO) \
619 (mips_elf_hash_table (INFO)->is_vxworks ? 0x0 : 0x7ff0)
621 /* The maximum size of the GOT for it to be addressable using 16-bit
623 #define MIPS_ELF_GOT_MAX_SIZE(INFO) (ELF_MIPS_GP_OFFSET (INFO) + 0x7fff)
625 /* Instructions which appear in a stub. */
626 #define STUB_LW(abfd) \
628 ? 0xdf998010 /* ld t9,0x8010(gp) */ \
629 : 0x8f998010)) /* lw t9,0x8010(gp) */
630 #define STUB_MOVE(abfd) \
632 ? 0x03e0782d /* daddu t7,ra */ \
633 : 0x03e07821)) /* addu t7,ra */
634 #define STUB_LUI(VAL) (0x3c180000 + (VAL)) /* lui t8,VAL */
635 #define STUB_JALR 0x0320f809 /* jalr t9,ra */
636 #define STUB_LI16U(VAL) (0x34180000 + (VAL)) /* ori t8,zero,VAL unsigned*/
637 #define STUB_LI16S(abfd, VAL) \
639 ? (0x64180000 + (VAL)) /* daddiu t8,zero,VAL sign extended */ \
640 : (0x24180000 + (VAL)))) /* addiu t8,zero,VAL sign extended */
642 #define MIPS_FUNCTION_STUB_SIZE(INFO) \
643 (elf_hash_table (INFO)->dynsymcount > 65536 ? 20 : 16)
645 #define MIPS_FUNCTION_STUB_MAX_SIZE 20
647 /* The name of the dynamic interpreter. This is put in the .interp
650 #define ELF_DYNAMIC_INTERPRETER(abfd) \
651 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
652 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
653 : "/usr/lib/libc.so.1")
656 #define MNAME(bfd,pre,pos) \
657 (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
658 #define ELF_R_SYM(bfd, i) \
659 (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
660 #define ELF_R_TYPE(bfd, i) \
661 (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
662 #define ELF_R_INFO(bfd, s, t) \
663 (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
665 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
666 #define ELF_R_SYM(bfd, i) \
668 #define ELF_R_TYPE(bfd, i) \
670 #define ELF_R_INFO(bfd, s, t) \
671 (ELF32_R_INFO (s, t))
674 /* The mips16 compiler uses a couple of special sections to handle
675 floating point arguments.
677 Section names that look like .mips16.fn.FNNAME contain stubs that
678 copy floating point arguments from the fp regs to the gp regs and
679 then jump to FNNAME. If any 32 bit function calls FNNAME, the
680 call should be redirected to the stub instead. If no 32 bit
681 function calls FNNAME, the stub should be discarded. We need to
682 consider any reference to the function, not just a call, because
683 if the address of the function is taken we will need the stub,
684 since the address might be passed to a 32 bit function.
686 Section names that look like .mips16.call.FNNAME contain stubs
687 that copy floating point arguments from the gp regs to the fp
688 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
689 then any 16 bit function that calls FNNAME should be redirected
690 to the stub instead. If FNNAME is not a 32 bit function, the
691 stub should be discarded.
693 .mips16.call.fp.FNNAME sections are similar, but contain stubs
694 which call FNNAME and then copy the return value from the fp regs
695 to the gp regs. These stubs store the return value in $18 while
696 calling FNNAME; any function which might call one of these stubs
697 must arrange to save $18 around the call. (This case is not
698 needed for 32 bit functions that call 16 bit functions, because
699 16 bit functions always return floating point values in both
702 Note that in all cases FNNAME might be defined statically.
703 Therefore, FNNAME is not used literally. Instead, the relocation
704 information will indicate which symbol the section is for.
706 We record any stubs that we find in the symbol table. */
708 #define FN_STUB ".mips16.fn."
709 #define CALL_STUB ".mips16.call."
710 #define CALL_FP_STUB ".mips16.call.fp."
712 /* The format of the first PLT entry in a VxWorks executable. */
713 static const bfd_vma mips_vxworks_exec_plt0_entry
[] = {
714 0x3c190000, /* lui t9, %hi(_GLOBAL_OFFSET_TABLE_) */
715 0x27390000, /* addiu t9, t9, %lo(_GLOBAL_OFFSET_TABLE_) */
716 0x8f390008, /* lw t9, 8(t9) */
717 0x00000000, /* nop */
718 0x03200008, /* jr t9 */
722 /* The format of subsequent PLT entries. */
723 static const bfd_vma mips_vxworks_exec_plt_entry
[] = {
724 0x10000000, /* b .PLT_resolver */
725 0x24180000, /* li t8, <pltindex> */
726 0x3c190000, /* lui t9, %hi(<.got.plt slot>) */
727 0x27390000, /* addiu t9, t9, %lo(<.got.plt slot>) */
728 0x8f390000, /* lw t9, 0(t9) */
729 0x00000000, /* nop */
730 0x03200008, /* jr t9 */
734 /* The format of the first PLT entry in a VxWorks shared object. */
735 static const bfd_vma mips_vxworks_shared_plt0_entry
[] = {
736 0x8f990008, /* lw t9, 8(gp) */
737 0x00000000, /* nop */
738 0x03200008, /* jr t9 */
739 0x00000000, /* nop */
740 0x00000000, /* nop */
744 /* The format of subsequent PLT entries. */
745 static const bfd_vma mips_vxworks_shared_plt_entry
[] = {
746 0x10000000, /* b .PLT_resolver */
747 0x24180000 /* li t8, <pltindex> */
750 /* Look up an entry in a MIPS ELF linker hash table. */
752 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
753 ((struct mips_elf_link_hash_entry *) \
754 elf_link_hash_lookup (&(table)->root, (string), (create), \
757 /* Traverse a MIPS ELF linker hash table. */
759 #define mips_elf_link_hash_traverse(table, func, info) \
760 (elf_link_hash_traverse \
762 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
765 /* Get the MIPS ELF linker hash table from a link_info structure. */
767 #define mips_elf_hash_table(p) \
768 ((struct mips_elf_link_hash_table *) ((p)->hash))
770 /* Find the base offsets for thread-local storage in this object,
771 for GD/LD and IE/LE respectively. */
773 #define TP_OFFSET 0x7000
774 #define DTP_OFFSET 0x8000
777 dtprel_base (struct bfd_link_info
*info
)
779 /* If tls_sec is NULL, we should have signalled an error already. */
780 if (elf_hash_table (info
)->tls_sec
== NULL
)
782 return elf_hash_table (info
)->tls_sec
->vma
+ DTP_OFFSET
;
786 tprel_base (struct bfd_link_info
*info
)
788 /* If tls_sec is NULL, we should have signalled an error already. */
789 if (elf_hash_table (info
)->tls_sec
== NULL
)
791 return elf_hash_table (info
)->tls_sec
->vma
+ TP_OFFSET
;
794 /* Create an entry in a MIPS ELF linker hash table. */
796 static struct bfd_hash_entry
*
797 mips_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
798 struct bfd_hash_table
*table
, const char *string
)
800 struct mips_elf_link_hash_entry
*ret
=
801 (struct mips_elf_link_hash_entry
*) entry
;
803 /* Allocate the structure if it has not already been allocated by a
806 ret
= bfd_hash_allocate (table
, sizeof (struct mips_elf_link_hash_entry
));
808 return (struct bfd_hash_entry
*) ret
;
810 /* Call the allocation method of the superclass. */
811 ret
= ((struct mips_elf_link_hash_entry
*)
812 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
816 /* Set local fields. */
817 memset (&ret
->esym
, 0, sizeof (EXTR
));
818 /* We use -2 as a marker to indicate that the information has
819 not been set. -1 means there is no associated ifd. */
821 ret
->possibly_dynamic_relocs
= 0;
822 ret
->readonly_reloc
= FALSE
;
823 ret
->no_fn_stub
= FALSE
;
825 ret
->need_fn_stub
= FALSE
;
826 ret
->call_stub
= NULL
;
827 ret
->call_fp_stub
= NULL
;
828 ret
->forced_local
= FALSE
;
829 ret
->is_branch_target
= FALSE
;
830 ret
->is_relocation_target
= FALSE
;
831 ret
->tls_type
= GOT_NORMAL
;
834 return (struct bfd_hash_entry
*) ret
;
838 _bfd_mips_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
840 if (!sec
->used_by_bfd
)
842 struct _mips_elf_section_data
*sdata
;
843 bfd_size_type amt
= sizeof (*sdata
);
845 sdata
= bfd_zalloc (abfd
, amt
);
848 sec
->used_by_bfd
= sdata
;
851 return _bfd_elf_new_section_hook (abfd
, sec
);
854 /* Read ECOFF debugging information from a .mdebug section into a
855 ecoff_debug_info structure. */
858 _bfd_mips_elf_read_ecoff_info (bfd
*abfd
, asection
*section
,
859 struct ecoff_debug_info
*debug
)
862 const struct ecoff_debug_swap
*swap
;
865 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
866 memset (debug
, 0, sizeof (*debug
));
868 ext_hdr
= bfd_malloc (swap
->external_hdr_size
);
869 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
872 if (! bfd_get_section_contents (abfd
, section
, ext_hdr
, 0,
873 swap
->external_hdr_size
))
876 symhdr
= &debug
->symbolic_header
;
877 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
879 /* The symbolic header contains absolute file offsets and sizes to
881 #define READ(ptr, offset, count, size, type) \
882 if (symhdr->count == 0) \
886 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
887 debug->ptr = bfd_malloc (amt); \
888 if (debug->ptr == NULL) \
890 if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0 \
891 || bfd_bread (debug->ptr, amt, abfd) != amt) \
895 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
896 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, void *);
897 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, void *);
898 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, void *);
899 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, void *);
900 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
902 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
903 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
904 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, void *);
905 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, void *);
906 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, void *);
916 if (debug
->line
!= NULL
)
918 if (debug
->external_dnr
!= NULL
)
919 free (debug
->external_dnr
);
920 if (debug
->external_pdr
!= NULL
)
921 free (debug
->external_pdr
);
922 if (debug
->external_sym
!= NULL
)
923 free (debug
->external_sym
);
924 if (debug
->external_opt
!= NULL
)
925 free (debug
->external_opt
);
926 if (debug
->external_aux
!= NULL
)
927 free (debug
->external_aux
);
928 if (debug
->ss
!= NULL
)
930 if (debug
->ssext
!= NULL
)
932 if (debug
->external_fdr
!= NULL
)
933 free (debug
->external_fdr
);
934 if (debug
->external_rfd
!= NULL
)
935 free (debug
->external_rfd
);
936 if (debug
->external_ext
!= NULL
)
937 free (debug
->external_ext
);
941 /* Swap RPDR (runtime procedure table entry) for output. */
944 ecoff_swap_rpdr_out (bfd
*abfd
, const RPDR
*in
, struct rpdr_ext
*ex
)
946 H_PUT_S32 (abfd
, in
->adr
, ex
->p_adr
);
947 H_PUT_32 (abfd
, in
->regmask
, ex
->p_regmask
);
948 H_PUT_32 (abfd
, in
->regoffset
, ex
->p_regoffset
);
949 H_PUT_32 (abfd
, in
->fregmask
, ex
->p_fregmask
);
950 H_PUT_32 (abfd
, in
->fregoffset
, ex
->p_fregoffset
);
951 H_PUT_32 (abfd
, in
->frameoffset
, ex
->p_frameoffset
);
953 H_PUT_16 (abfd
, in
->framereg
, ex
->p_framereg
);
954 H_PUT_16 (abfd
, in
->pcreg
, ex
->p_pcreg
);
956 H_PUT_32 (abfd
, in
->irpss
, ex
->p_irpss
);
959 /* Create a runtime procedure table from the .mdebug section. */
962 mips_elf_create_procedure_table (void *handle
, bfd
*abfd
,
963 struct bfd_link_info
*info
, asection
*s
,
964 struct ecoff_debug_info
*debug
)
966 const struct ecoff_debug_swap
*swap
;
967 HDRR
*hdr
= &debug
->symbolic_header
;
969 struct rpdr_ext
*erp
;
971 struct pdr_ext
*epdr
;
972 struct sym_ext
*esym
;
977 unsigned long sindex
;
981 const char *no_name_func
= _("static procedure (no name)");
989 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
991 sindex
= strlen (no_name_func
) + 1;
995 size
= swap
->external_pdr_size
;
997 epdr
= bfd_malloc (size
* count
);
1001 if (! _bfd_ecoff_get_accumulated_pdr (handle
, (bfd_byte
*) epdr
))
1004 size
= sizeof (RPDR
);
1005 rp
= rpdr
= bfd_malloc (size
* count
);
1009 size
= sizeof (char *);
1010 sv
= bfd_malloc (size
* count
);
1014 count
= hdr
->isymMax
;
1015 size
= swap
->external_sym_size
;
1016 esym
= bfd_malloc (size
* count
);
1020 if (! _bfd_ecoff_get_accumulated_sym (handle
, (bfd_byte
*) esym
))
1023 count
= hdr
->issMax
;
1024 ss
= bfd_malloc (count
);
1027 if (! _bfd_ecoff_get_accumulated_ss (handle
, (bfd_byte
*) ss
))
1030 count
= hdr
->ipdMax
;
1031 for (i
= 0; i
< (unsigned long) count
; i
++, rp
++)
1033 (*swap
->swap_pdr_in
) (abfd
, epdr
+ i
, &pdr
);
1034 (*swap
->swap_sym_in
) (abfd
, &esym
[pdr
.isym
], &sym
);
1035 rp
->adr
= sym
.value
;
1036 rp
->regmask
= pdr
.regmask
;
1037 rp
->regoffset
= pdr
.regoffset
;
1038 rp
->fregmask
= pdr
.fregmask
;
1039 rp
->fregoffset
= pdr
.fregoffset
;
1040 rp
->frameoffset
= pdr
.frameoffset
;
1041 rp
->framereg
= pdr
.framereg
;
1042 rp
->pcreg
= pdr
.pcreg
;
1044 sv
[i
] = ss
+ sym
.iss
;
1045 sindex
+= strlen (sv
[i
]) + 1;
1049 size
= sizeof (struct rpdr_ext
) * (count
+ 2) + sindex
;
1050 size
= BFD_ALIGN (size
, 16);
1051 rtproc
= bfd_alloc (abfd
, size
);
1054 mips_elf_hash_table (info
)->procedure_count
= 0;
1058 mips_elf_hash_table (info
)->procedure_count
= count
+ 2;
1061 memset (erp
, 0, sizeof (struct rpdr_ext
));
1063 str
= (char *) rtproc
+ sizeof (struct rpdr_ext
) * (count
+ 2);
1064 strcpy (str
, no_name_func
);
1065 str
+= strlen (no_name_func
) + 1;
1066 for (i
= 0; i
< count
; i
++)
1068 ecoff_swap_rpdr_out (abfd
, rpdr
+ i
, erp
+ i
);
1069 strcpy (str
, sv
[i
]);
1070 str
+= strlen (sv
[i
]) + 1;
1072 H_PUT_S32 (abfd
, -1, (erp
+ count
)->p_adr
);
1074 /* Set the size and contents of .rtproc section. */
1076 s
->contents
= rtproc
;
1078 /* Skip this section later on (I don't think this currently
1079 matters, but someday it might). */
1080 s
->map_head
.link_order
= NULL
;
1109 /* Check the mips16 stubs for a particular symbol, and see if we can
1113 mips_elf_check_mips16_stubs (struct mips_elf_link_hash_entry
*h
,
1114 void *data ATTRIBUTE_UNUSED
)
1116 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1117 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1119 if (h
->fn_stub
!= NULL
1120 && ! h
->need_fn_stub
)
1122 /* We don't need the fn_stub; the only references to this symbol
1123 are 16 bit calls. Clobber the size to 0 to prevent it from
1124 being included in the link. */
1125 h
->fn_stub
->size
= 0;
1126 h
->fn_stub
->flags
&= ~SEC_RELOC
;
1127 h
->fn_stub
->reloc_count
= 0;
1128 h
->fn_stub
->flags
|= SEC_EXCLUDE
;
1131 if (h
->call_stub
!= NULL
1132 && h
->root
.other
== STO_MIPS16
)
1134 /* We don't need the call_stub; this is a 16 bit function, so
1135 calls from other 16 bit functions are OK. Clobber the size
1136 to 0 to prevent it from being included in the link. */
1137 h
->call_stub
->size
= 0;
1138 h
->call_stub
->flags
&= ~SEC_RELOC
;
1139 h
->call_stub
->reloc_count
= 0;
1140 h
->call_stub
->flags
|= SEC_EXCLUDE
;
1143 if (h
->call_fp_stub
!= NULL
1144 && h
->root
.other
== STO_MIPS16
)
1146 /* We don't need the call_stub; this is a 16 bit function, so
1147 calls from other 16 bit functions are OK. Clobber the size
1148 to 0 to prevent it from being included in the link. */
1149 h
->call_fp_stub
->size
= 0;
1150 h
->call_fp_stub
->flags
&= ~SEC_RELOC
;
1151 h
->call_fp_stub
->reloc_count
= 0;
1152 h
->call_fp_stub
->flags
|= SEC_EXCLUDE
;
1158 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
1159 Most mips16 instructions are 16 bits, but these instructions
1162 The format of these instructions is:
1164 +--------------+--------------------------------+
1165 | JALX | X| Imm 20:16 | Imm 25:21 |
1166 +--------------+--------------------------------+
1168 +-----------------------------------------------+
1170 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
1171 Note that the immediate value in the first word is swapped.
1173 When producing a relocatable object file, R_MIPS16_26 is
1174 handled mostly like R_MIPS_26. In particular, the addend is
1175 stored as a straight 26-bit value in a 32-bit instruction.
1176 (gas makes life simpler for itself by never adjusting a
1177 R_MIPS16_26 reloc to be against a section, so the addend is
1178 always zero). However, the 32 bit instruction is stored as 2
1179 16-bit values, rather than a single 32-bit value. In a
1180 big-endian file, the result is the same; in a little-endian
1181 file, the two 16-bit halves of the 32 bit value are swapped.
1182 This is so that a disassembler can recognize the jal
1185 When doing a final link, R_MIPS16_26 is treated as a 32 bit
1186 instruction stored as two 16-bit values. The addend A is the
1187 contents of the targ26 field. The calculation is the same as
1188 R_MIPS_26. When storing the calculated value, reorder the
1189 immediate value as shown above, and don't forget to store the
1190 value as two 16-bit values.
1192 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
1196 +--------+----------------------+
1200 +--------+----------------------+
1203 +----------+------+-------------+
1207 +----------+--------------------+
1208 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
1209 ((sub1 << 16) | sub2)).
1211 When producing a relocatable object file, the calculation is
1212 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1213 When producing a fully linked file, the calculation is
1214 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1215 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)
1217 R_MIPS16_GPREL is used for GP-relative addressing in mips16
1218 mode. A typical instruction will have a format like this:
1220 +--------------+--------------------------------+
1221 | EXTEND | Imm 10:5 | Imm 15:11 |
1222 +--------------+--------------------------------+
1223 | Major | rx | ry | Imm 4:0 |
1224 +--------------+--------------------------------+
1226 EXTEND is the five bit value 11110. Major is the instruction
1229 This is handled exactly like R_MIPS_GPREL16, except that the
1230 addend is retrieved and stored as shown in this diagram; that
1231 is, the Imm fields above replace the V-rel16 field.
1233 All we need to do here is shuffle the bits appropriately. As
1234 above, the two 16-bit halves must be swapped on a
1235 little-endian system.
1237 R_MIPS16_HI16 and R_MIPS16_LO16 are used in mips16 mode to
1238 access data when neither GP-relative nor PC-relative addressing
1239 can be used. They are handled like R_MIPS_HI16 and R_MIPS_LO16,
1240 except that the addend is retrieved and stored as shown above
1244 _bfd_mips16_elf_reloc_unshuffle (bfd
*abfd
, int r_type
,
1245 bfd_boolean jal_shuffle
, bfd_byte
*data
)
1247 bfd_vma extend
, insn
, val
;
1249 if (r_type
!= R_MIPS16_26
&& r_type
!= R_MIPS16_GPREL
1250 && r_type
!= R_MIPS16_HI16
&& r_type
!= R_MIPS16_LO16
)
1253 /* Pick up the mips16 extend instruction and the real instruction. */
1254 extend
= bfd_get_16 (abfd
, data
);
1255 insn
= bfd_get_16 (abfd
, data
+ 2);
1256 if (r_type
== R_MIPS16_26
)
1259 val
= ((extend
& 0xfc00) << 16) | ((extend
& 0x3e0) << 11)
1260 | ((extend
& 0x1f) << 21) | insn
;
1262 val
= extend
<< 16 | insn
;
1265 val
= ((extend
& 0xf800) << 16) | ((insn
& 0xffe0) << 11)
1266 | ((extend
& 0x1f) << 11) | (extend
& 0x7e0) | (insn
& 0x1f);
1267 bfd_put_32 (abfd
, val
, data
);
1271 _bfd_mips16_elf_reloc_shuffle (bfd
*abfd
, int r_type
,
1272 bfd_boolean jal_shuffle
, bfd_byte
*data
)
1274 bfd_vma extend
, insn
, val
;
1276 if (r_type
!= R_MIPS16_26
&& r_type
!= R_MIPS16_GPREL
1277 && r_type
!= R_MIPS16_HI16
&& r_type
!= R_MIPS16_LO16
)
1280 val
= bfd_get_32 (abfd
, data
);
1281 if (r_type
== R_MIPS16_26
)
1285 insn
= val
& 0xffff;
1286 extend
= ((val
>> 16) & 0xfc00) | ((val
>> 11) & 0x3e0)
1287 | ((val
>> 21) & 0x1f);
1291 insn
= val
& 0xffff;
1297 insn
= ((val
>> 11) & 0xffe0) | (val
& 0x1f);
1298 extend
= ((val
>> 16) & 0xf800) | ((val
>> 11) & 0x1f) | (val
& 0x7e0);
1300 bfd_put_16 (abfd
, insn
, data
+ 2);
1301 bfd_put_16 (abfd
, extend
, data
);
1304 bfd_reloc_status_type
1305 _bfd_mips_elf_gprel16_with_gp (bfd
*abfd
, asymbol
*symbol
,
1306 arelent
*reloc_entry
, asection
*input_section
,
1307 bfd_boolean relocatable
, void *data
, bfd_vma gp
)
1311 bfd_reloc_status_type status
;
1313 if (bfd_is_com_section (symbol
->section
))
1316 relocation
= symbol
->value
;
1318 relocation
+= symbol
->section
->output_section
->vma
;
1319 relocation
+= symbol
->section
->output_offset
;
1321 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1322 return bfd_reloc_outofrange
;
1324 /* Set val to the offset into the section or symbol. */
1325 val
= reloc_entry
->addend
;
1327 _bfd_mips_elf_sign_extend (val
, 16);
1329 /* Adjust val for the final section location and GP value. If we
1330 are producing relocatable output, we don't want to do this for
1331 an external symbol. */
1333 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1334 val
+= relocation
- gp
;
1336 if (reloc_entry
->howto
->partial_inplace
)
1338 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
1340 + reloc_entry
->address
);
1341 if (status
!= bfd_reloc_ok
)
1345 reloc_entry
->addend
= val
;
1348 reloc_entry
->address
+= input_section
->output_offset
;
1350 return bfd_reloc_ok
;
1353 /* Used to store a REL high-part relocation such as R_MIPS_HI16 or
1354 R_MIPS_GOT16. REL is the relocation, INPUT_SECTION is the section
1355 that contains the relocation field and DATA points to the start of
1360 struct mips_hi16
*next
;
1362 asection
*input_section
;
1366 /* FIXME: This should not be a static variable. */
1368 static struct mips_hi16
*mips_hi16_list
;
1370 /* A howto special_function for REL *HI16 relocations. We can only
1371 calculate the correct value once we've seen the partnering
1372 *LO16 relocation, so just save the information for later.
1374 The ABI requires that the *LO16 immediately follow the *HI16.
1375 However, as a GNU extension, we permit an arbitrary number of
1376 *HI16s to be associated with a single *LO16. This significantly
1377 simplies the relocation handling in gcc. */
1379 bfd_reloc_status_type
1380 _bfd_mips_elf_hi16_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
1381 asymbol
*symbol ATTRIBUTE_UNUSED
, void *data
,
1382 asection
*input_section
, bfd
*output_bfd
,
1383 char **error_message ATTRIBUTE_UNUSED
)
1385 struct mips_hi16
*n
;
1387 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1388 return bfd_reloc_outofrange
;
1390 n
= bfd_malloc (sizeof *n
);
1392 return bfd_reloc_outofrange
;
1394 n
->next
= mips_hi16_list
;
1396 n
->input_section
= input_section
;
1397 n
->rel
= *reloc_entry
;
1400 if (output_bfd
!= NULL
)
1401 reloc_entry
->address
+= input_section
->output_offset
;
1403 return bfd_reloc_ok
;
1406 /* A howto special_function for REL R_MIPS_GOT16 relocations. This is just
1407 like any other 16-bit relocation when applied to global symbols, but is
1408 treated in the same as R_MIPS_HI16 when applied to local symbols. */
1410 bfd_reloc_status_type
1411 _bfd_mips_elf_got16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1412 void *data
, asection
*input_section
,
1413 bfd
*output_bfd
, char **error_message
)
1415 if ((symbol
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
1416 || bfd_is_und_section (bfd_get_section (symbol
))
1417 || bfd_is_com_section (bfd_get_section (symbol
)))
1418 /* The relocation is against a global symbol. */
1419 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1420 input_section
, output_bfd
,
1423 return _bfd_mips_elf_hi16_reloc (abfd
, reloc_entry
, symbol
, data
,
1424 input_section
, output_bfd
, error_message
);
1427 /* A howto special_function for REL *LO16 relocations. The *LO16 itself
1428 is a straightforward 16 bit inplace relocation, but we must deal with
1429 any partnering high-part relocations as well. */
1431 bfd_reloc_status_type
1432 _bfd_mips_elf_lo16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1433 void *data
, asection
*input_section
,
1434 bfd
*output_bfd
, char **error_message
)
1437 bfd_byte
*location
= (bfd_byte
*) data
+ reloc_entry
->address
;
1439 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1440 return bfd_reloc_outofrange
;
1442 _bfd_mips16_elf_reloc_unshuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1444 vallo
= bfd_get_32 (abfd
, location
);
1445 _bfd_mips16_elf_reloc_shuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1448 while (mips_hi16_list
!= NULL
)
1450 bfd_reloc_status_type ret
;
1451 struct mips_hi16
*hi
;
1453 hi
= mips_hi16_list
;
1455 /* R_MIPS_GOT16 relocations are something of a special case. We
1456 want to install the addend in the same way as for a R_MIPS_HI16
1457 relocation (with a rightshift of 16). However, since GOT16
1458 relocations can also be used with global symbols, their howto
1459 has a rightshift of 0. */
1460 if (hi
->rel
.howto
->type
== R_MIPS_GOT16
)
1461 hi
->rel
.howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, R_MIPS_HI16
, FALSE
);
1463 /* VALLO is a signed 16-bit number. Bias it by 0x8000 so that any
1464 carry or borrow will induce a change of +1 or -1 in the high part. */
1465 hi
->rel
.addend
+= (vallo
+ 0x8000) & 0xffff;
1467 ret
= _bfd_mips_elf_generic_reloc (abfd
, &hi
->rel
, symbol
, hi
->data
,
1468 hi
->input_section
, output_bfd
,
1470 if (ret
!= bfd_reloc_ok
)
1473 mips_hi16_list
= hi
->next
;
1477 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1478 input_section
, output_bfd
,
1482 /* A generic howto special_function. This calculates and installs the
1483 relocation itself, thus avoiding the oft-discussed problems in
1484 bfd_perform_relocation and bfd_install_relocation. */
1486 bfd_reloc_status_type
1487 _bfd_mips_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
1488 asymbol
*symbol
, void *data ATTRIBUTE_UNUSED
,
1489 asection
*input_section
, bfd
*output_bfd
,
1490 char **error_message ATTRIBUTE_UNUSED
)
1493 bfd_reloc_status_type status
;
1494 bfd_boolean relocatable
;
1496 relocatable
= (output_bfd
!= NULL
);
1498 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1499 return bfd_reloc_outofrange
;
1501 /* Build up the field adjustment in VAL. */
1503 if (!relocatable
|| (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1505 /* Either we're calculating the final field value or we have a
1506 relocation against a section symbol. Add in the section's
1507 offset or address. */
1508 val
+= symbol
->section
->output_section
->vma
;
1509 val
+= symbol
->section
->output_offset
;
1514 /* We're calculating the final field value. Add in the symbol's value
1515 and, if pc-relative, subtract the address of the field itself. */
1516 val
+= symbol
->value
;
1517 if (reloc_entry
->howto
->pc_relative
)
1519 val
-= input_section
->output_section
->vma
;
1520 val
-= input_section
->output_offset
;
1521 val
-= reloc_entry
->address
;
1525 /* VAL is now the final adjustment. If we're keeping this relocation
1526 in the output file, and if the relocation uses a separate addend,
1527 we just need to add VAL to that addend. Otherwise we need to add
1528 VAL to the relocation field itself. */
1529 if (relocatable
&& !reloc_entry
->howto
->partial_inplace
)
1530 reloc_entry
->addend
+= val
;
1533 bfd_byte
*location
= (bfd_byte
*) data
+ reloc_entry
->address
;
1535 /* Add in the separate addend, if any. */
1536 val
+= reloc_entry
->addend
;
1538 /* Add VAL to the relocation field. */
1539 _bfd_mips16_elf_reloc_unshuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1541 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
1543 _bfd_mips16_elf_reloc_shuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
1546 if (status
!= bfd_reloc_ok
)
1551 reloc_entry
->address
+= input_section
->output_offset
;
1553 return bfd_reloc_ok
;
1556 /* Swap an entry in a .gptab section. Note that these routines rely
1557 on the equivalence of the two elements of the union. */
1560 bfd_mips_elf32_swap_gptab_in (bfd
*abfd
, const Elf32_External_gptab
*ex
,
1563 in
->gt_entry
.gt_g_value
= H_GET_32 (abfd
, ex
->gt_entry
.gt_g_value
);
1564 in
->gt_entry
.gt_bytes
= H_GET_32 (abfd
, ex
->gt_entry
.gt_bytes
);
1568 bfd_mips_elf32_swap_gptab_out (bfd
*abfd
, const Elf32_gptab
*in
,
1569 Elf32_External_gptab
*ex
)
1571 H_PUT_32 (abfd
, in
->gt_entry
.gt_g_value
, ex
->gt_entry
.gt_g_value
);
1572 H_PUT_32 (abfd
, in
->gt_entry
.gt_bytes
, ex
->gt_entry
.gt_bytes
);
1576 bfd_elf32_swap_compact_rel_out (bfd
*abfd
, const Elf32_compact_rel
*in
,
1577 Elf32_External_compact_rel
*ex
)
1579 H_PUT_32 (abfd
, in
->id1
, ex
->id1
);
1580 H_PUT_32 (abfd
, in
->num
, ex
->num
);
1581 H_PUT_32 (abfd
, in
->id2
, ex
->id2
);
1582 H_PUT_32 (abfd
, in
->offset
, ex
->offset
);
1583 H_PUT_32 (abfd
, in
->reserved0
, ex
->reserved0
);
1584 H_PUT_32 (abfd
, in
->reserved1
, ex
->reserved1
);
1588 bfd_elf32_swap_crinfo_out (bfd
*abfd
, const Elf32_crinfo
*in
,
1589 Elf32_External_crinfo
*ex
)
1593 l
= (((in
->ctype
& CRINFO_CTYPE
) << CRINFO_CTYPE_SH
)
1594 | ((in
->rtype
& CRINFO_RTYPE
) << CRINFO_RTYPE_SH
)
1595 | ((in
->dist2to
& CRINFO_DIST2TO
) << CRINFO_DIST2TO_SH
)
1596 | ((in
->relvaddr
& CRINFO_RELVADDR
) << CRINFO_RELVADDR_SH
));
1597 H_PUT_32 (abfd
, l
, ex
->info
);
1598 H_PUT_32 (abfd
, in
->konst
, ex
->konst
);
1599 H_PUT_32 (abfd
, in
->vaddr
, ex
->vaddr
);
1602 /* A .reginfo section holds a single Elf32_RegInfo structure. These
1603 routines swap this structure in and out. They are used outside of
1604 BFD, so they are globally visible. */
1607 bfd_mips_elf32_swap_reginfo_in (bfd
*abfd
, const Elf32_External_RegInfo
*ex
,
1610 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1611 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1612 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1613 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1614 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1615 in
->ri_gp_value
= H_GET_32 (abfd
, ex
->ri_gp_value
);
1619 bfd_mips_elf32_swap_reginfo_out (bfd
*abfd
, const Elf32_RegInfo
*in
,
1620 Elf32_External_RegInfo
*ex
)
1622 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1623 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1624 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1625 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1626 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1627 H_PUT_32 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1630 /* In the 64 bit ABI, the .MIPS.options section holds register
1631 information in an Elf64_Reginfo structure. These routines swap
1632 them in and out. They are globally visible because they are used
1633 outside of BFD. These routines are here so that gas can call them
1634 without worrying about whether the 64 bit ABI has been included. */
1637 bfd_mips_elf64_swap_reginfo_in (bfd
*abfd
, const Elf64_External_RegInfo
*ex
,
1638 Elf64_Internal_RegInfo
*in
)
1640 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
1641 in
->ri_pad
= H_GET_32 (abfd
, ex
->ri_pad
);
1642 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
1643 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
1644 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
1645 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
1646 in
->ri_gp_value
= H_GET_64 (abfd
, ex
->ri_gp_value
);
1650 bfd_mips_elf64_swap_reginfo_out (bfd
*abfd
, const Elf64_Internal_RegInfo
*in
,
1651 Elf64_External_RegInfo
*ex
)
1653 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
1654 H_PUT_32 (abfd
, in
->ri_pad
, ex
->ri_pad
);
1655 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
1656 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
1657 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
1658 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
1659 H_PUT_64 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
1662 /* Swap in an options header. */
1665 bfd_mips_elf_swap_options_in (bfd
*abfd
, const Elf_External_Options
*ex
,
1666 Elf_Internal_Options
*in
)
1668 in
->kind
= H_GET_8 (abfd
, ex
->kind
);
1669 in
->size
= H_GET_8 (abfd
, ex
->size
);
1670 in
->section
= H_GET_16 (abfd
, ex
->section
);
1671 in
->info
= H_GET_32 (abfd
, ex
->info
);
1674 /* Swap out an options header. */
1677 bfd_mips_elf_swap_options_out (bfd
*abfd
, const Elf_Internal_Options
*in
,
1678 Elf_External_Options
*ex
)
1680 H_PUT_8 (abfd
, in
->kind
, ex
->kind
);
1681 H_PUT_8 (abfd
, in
->size
, ex
->size
);
1682 H_PUT_16 (abfd
, in
->section
, ex
->section
);
1683 H_PUT_32 (abfd
, in
->info
, ex
->info
);
1686 /* This function is called via qsort() to sort the dynamic relocation
1687 entries by increasing r_symndx value. */
1690 sort_dynamic_relocs (const void *arg1
, const void *arg2
)
1692 Elf_Internal_Rela int_reloc1
;
1693 Elf_Internal_Rela int_reloc2
;
1695 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg1
, &int_reloc1
);
1696 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg2
, &int_reloc2
);
1698 return ELF32_R_SYM (int_reloc1
.r_info
) - ELF32_R_SYM (int_reloc2
.r_info
);
1701 /* Like sort_dynamic_relocs, but used for elf64 relocations. */
1704 sort_dynamic_relocs_64 (const void *arg1 ATTRIBUTE_UNUSED
,
1705 const void *arg2 ATTRIBUTE_UNUSED
)
1708 Elf_Internal_Rela int_reloc1
[3];
1709 Elf_Internal_Rela int_reloc2
[3];
1711 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1712 (reldyn_sorting_bfd
, arg1
, int_reloc1
);
1713 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
1714 (reldyn_sorting_bfd
, arg2
, int_reloc2
);
1716 return (ELF64_R_SYM (int_reloc1
[0].r_info
)
1717 - ELF64_R_SYM (int_reloc2
[0].r_info
));
1724 /* This routine is used to write out ECOFF debugging external symbol
1725 information. It is called via mips_elf_link_hash_traverse. The
1726 ECOFF external symbol information must match the ELF external
1727 symbol information. Unfortunately, at this point we don't know
1728 whether a symbol is required by reloc information, so the two
1729 tables may wind up being different. We must sort out the external
1730 symbol information before we can set the final size of the .mdebug
1731 section, and we must set the size of the .mdebug section before we
1732 can relocate any sections, and we can't know which symbols are
1733 required by relocation until we relocate the sections.
1734 Fortunately, it is relatively unlikely that any symbol will be
1735 stripped but required by a reloc. In particular, it can not happen
1736 when generating a final executable. */
1739 mips_elf_output_extsym (struct mips_elf_link_hash_entry
*h
, void *data
)
1741 struct extsym_info
*einfo
= data
;
1743 asection
*sec
, *output_section
;
1745 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1746 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1748 if (h
->root
.indx
== -2)
1750 else if ((h
->root
.def_dynamic
1751 || h
->root
.ref_dynamic
1752 || h
->root
.type
== bfd_link_hash_new
)
1753 && !h
->root
.def_regular
1754 && !h
->root
.ref_regular
)
1756 else if (einfo
->info
->strip
== strip_all
1757 || (einfo
->info
->strip
== strip_some
1758 && bfd_hash_lookup (einfo
->info
->keep_hash
,
1759 h
->root
.root
.root
.string
,
1760 FALSE
, FALSE
) == NULL
))
1768 if (h
->esym
.ifd
== -2)
1771 h
->esym
.cobol_main
= 0;
1772 h
->esym
.weakext
= 0;
1773 h
->esym
.reserved
= 0;
1774 h
->esym
.ifd
= ifdNil
;
1775 h
->esym
.asym
.value
= 0;
1776 h
->esym
.asym
.st
= stGlobal
;
1778 if (h
->root
.root
.type
== bfd_link_hash_undefined
1779 || h
->root
.root
.type
== bfd_link_hash_undefweak
)
1783 /* Use undefined class. Also, set class and type for some
1785 name
= h
->root
.root
.root
.string
;
1786 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
1787 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
1789 h
->esym
.asym
.sc
= scData
;
1790 h
->esym
.asym
.st
= stLabel
;
1791 h
->esym
.asym
.value
= 0;
1793 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
1795 h
->esym
.asym
.sc
= scAbs
;
1796 h
->esym
.asym
.st
= stLabel
;
1797 h
->esym
.asym
.value
=
1798 mips_elf_hash_table (einfo
->info
)->procedure_count
;
1800 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (einfo
->abfd
))
1802 h
->esym
.asym
.sc
= scAbs
;
1803 h
->esym
.asym
.st
= stLabel
;
1804 h
->esym
.asym
.value
= elf_gp (einfo
->abfd
);
1807 h
->esym
.asym
.sc
= scUndefined
;
1809 else if (h
->root
.root
.type
!= bfd_link_hash_defined
1810 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
1811 h
->esym
.asym
.sc
= scAbs
;
1816 sec
= h
->root
.root
.u
.def
.section
;
1817 output_section
= sec
->output_section
;
1819 /* When making a shared library and symbol h is the one from
1820 the another shared library, OUTPUT_SECTION may be null. */
1821 if (output_section
== NULL
)
1822 h
->esym
.asym
.sc
= scUndefined
;
1825 name
= bfd_section_name (output_section
->owner
, output_section
);
1827 if (strcmp (name
, ".text") == 0)
1828 h
->esym
.asym
.sc
= scText
;
1829 else if (strcmp (name
, ".data") == 0)
1830 h
->esym
.asym
.sc
= scData
;
1831 else if (strcmp (name
, ".sdata") == 0)
1832 h
->esym
.asym
.sc
= scSData
;
1833 else if (strcmp (name
, ".rodata") == 0
1834 || strcmp (name
, ".rdata") == 0)
1835 h
->esym
.asym
.sc
= scRData
;
1836 else if (strcmp (name
, ".bss") == 0)
1837 h
->esym
.asym
.sc
= scBss
;
1838 else if (strcmp (name
, ".sbss") == 0)
1839 h
->esym
.asym
.sc
= scSBss
;
1840 else if (strcmp (name
, ".init") == 0)
1841 h
->esym
.asym
.sc
= scInit
;
1842 else if (strcmp (name
, ".fini") == 0)
1843 h
->esym
.asym
.sc
= scFini
;
1845 h
->esym
.asym
.sc
= scAbs
;
1849 h
->esym
.asym
.reserved
= 0;
1850 h
->esym
.asym
.index
= indexNil
;
1853 if (h
->root
.root
.type
== bfd_link_hash_common
)
1854 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
1855 else if (h
->root
.root
.type
== bfd_link_hash_defined
1856 || h
->root
.root
.type
== bfd_link_hash_defweak
)
1858 if (h
->esym
.asym
.sc
== scCommon
)
1859 h
->esym
.asym
.sc
= scBss
;
1860 else if (h
->esym
.asym
.sc
== scSCommon
)
1861 h
->esym
.asym
.sc
= scSBss
;
1863 sec
= h
->root
.root
.u
.def
.section
;
1864 output_section
= sec
->output_section
;
1865 if (output_section
!= NULL
)
1866 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
1867 + sec
->output_offset
1868 + output_section
->vma
);
1870 h
->esym
.asym
.value
= 0;
1872 else if (h
->root
.needs_plt
)
1874 struct mips_elf_link_hash_entry
*hd
= h
;
1875 bfd_boolean no_fn_stub
= h
->no_fn_stub
;
1877 while (hd
->root
.root
.type
== bfd_link_hash_indirect
)
1879 hd
= (struct mips_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
1880 no_fn_stub
= no_fn_stub
|| hd
->no_fn_stub
;
1885 /* Set type and value for a symbol with a function stub. */
1886 h
->esym
.asym
.st
= stProc
;
1887 sec
= hd
->root
.root
.u
.def
.section
;
1889 h
->esym
.asym
.value
= 0;
1892 output_section
= sec
->output_section
;
1893 if (output_section
!= NULL
)
1894 h
->esym
.asym
.value
= (hd
->root
.plt
.offset
1895 + sec
->output_offset
1896 + output_section
->vma
);
1898 h
->esym
.asym
.value
= 0;
1903 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
1904 h
->root
.root
.root
.string
,
1907 einfo
->failed
= TRUE
;
1914 /* A comparison routine used to sort .gptab entries. */
1917 gptab_compare (const void *p1
, const void *p2
)
1919 const Elf32_gptab
*a1
= p1
;
1920 const Elf32_gptab
*a2
= p2
;
1922 return a1
->gt_entry
.gt_g_value
- a2
->gt_entry
.gt_g_value
;
1925 /* Functions to manage the got entry hash table. */
1927 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
1930 static INLINE hashval_t
1931 mips_elf_hash_bfd_vma (bfd_vma addr
)
1934 return addr
+ (addr
>> 32);
1940 /* got_entries only match if they're identical, except for gotidx, so
1941 use all fields to compute the hash, and compare the appropriate
1945 mips_elf_got_entry_hash (const void *entry_
)
1947 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
1949 return entry
->symndx
1950 + ((entry
->tls_type
& GOT_TLS_LDM
) << 17)
1951 + (! entry
->abfd
? mips_elf_hash_bfd_vma (entry
->d
.address
)
1953 + (entry
->symndx
>= 0 ? mips_elf_hash_bfd_vma (entry
->d
.addend
)
1954 : entry
->d
.h
->root
.root
.root
.hash
));
1958 mips_elf_got_entry_eq (const void *entry1
, const void *entry2
)
1960 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
1961 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
1963 /* An LDM entry can only match another LDM entry. */
1964 if ((e1
->tls_type
^ e2
->tls_type
) & GOT_TLS_LDM
)
1967 return e1
->abfd
== e2
->abfd
&& e1
->symndx
== e2
->symndx
1968 && (! e1
->abfd
? e1
->d
.address
== e2
->d
.address
1969 : e1
->symndx
>= 0 ? e1
->d
.addend
== e2
->d
.addend
1970 : e1
->d
.h
== e2
->d
.h
);
1973 /* multi_got_entries are still a match in the case of global objects,
1974 even if the input bfd in which they're referenced differs, so the
1975 hash computation and compare functions are adjusted
1979 mips_elf_multi_got_entry_hash (const void *entry_
)
1981 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
1983 return entry
->symndx
1985 ? mips_elf_hash_bfd_vma (entry
->d
.address
)
1986 : entry
->symndx
>= 0
1987 ? ((entry
->tls_type
& GOT_TLS_LDM
)
1988 ? (GOT_TLS_LDM
<< 17)
1990 + mips_elf_hash_bfd_vma (entry
->d
.addend
)))
1991 : entry
->d
.h
->root
.root
.root
.hash
);
1995 mips_elf_multi_got_entry_eq (const void *entry1
, const void *entry2
)
1997 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
1998 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
2000 /* Any two LDM entries match. */
2001 if (e1
->tls_type
& e2
->tls_type
& GOT_TLS_LDM
)
2004 /* Nothing else matches an LDM entry. */
2005 if ((e1
->tls_type
^ e2
->tls_type
) & GOT_TLS_LDM
)
2008 return e1
->symndx
== e2
->symndx
2009 && (e1
->symndx
>= 0 ? e1
->abfd
== e2
->abfd
&& e1
->d
.addend
== e2
->d
.addend
2010 : e1
->abfd
== NULL
|| e2
->abfd
== NULL
2011 ? e1
->abfd
== e2
->abfd
&& e1
->d
.address
== e2
->d
.address
2012 : e1
->d
.h
== e2
->d
.h
);
2015 /* Return the dynamic relocation section. If it doesn't exist, try to
2016 create a new it if CREATE_P, otherwise return NULL. Also return NULL
2017 if creation fails. */
2020 mips_elf_rel_dyn_section (struct bfd_link_info
*info
, bfd_boolean create_p
)
2026 dname
= MIPS_ELF_REL_DYN_NAME (info
);
2027 dynobj
= elf_hash_table (info
)->dynobj
;
2028 sreloc
= bfd_get_section_by_name (dynobj
, dname
);
2029 if (sreloc
== NULL
&& create_p
)
2031 sreloc
= bfd_make_section_with_flags (dynobj
, dname
,
2036 | SEC_LINKER_CREATED
2039 || ! bfd_set_section_alignment (dynobj
, sreloc
,
2040 MIPS_ELF_LOG_FILE_ALIGN (dynobj
)))
2046 /* Returns the GOT section for ABFD. */
2049 mips_elf_got_section (bfd
*abfd
, bfd_boolean maybe_excluded
)
2051 asection
*sgot
= bfd_get_section_by_name (abfd
, ".got");
2053 || (! maybe_excluded
&& (sgot
->flags
& SEC_EXCLUDE
) != 0))
2058 /* Returns the GOT information associated with the link indicated by
2059 INFO. If SGOTP is non-NULL, it is filled in with the GOT
2062 static struct mips_got_info
*
2063 mips_elf_got_info (bfd
*abfd
, asection
**sgotp
)
2066 struct mips_got_info
*g
;
2068 sgot
= mips_elf_got_section (abfd
, TRUE
);
2069 BFD_ASSERT (sgot
!= NULL
);
2070 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
2071 g
= mips_elf_section_data (sgot
)->u
.got_info
;
2072 BFD_ASSERT (g
!= NULL
);
2075 *sgotp
= (sgot
->flags
& SEC_EXCLUDE
) == 0 ? sgot
: NULL
;
2080 /* Count the number of relocations needed for a TLS GOT entry, with
2081 access types from TLS_TYPE, and symbol H (or a local symbol if H
2085 mips_tls_got_relocs (struct bfd_link_info
*info
, unsigned char tls_type
,
2086 struct elf_link_hash_entry
*h
)
2090 bfd_boolean need_relocs
= FALSE
;
2091 bfd_boolean dyn
= elf_hash_table (info
)->dynamic_sections_created
;
2093 if (h
&& WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
2094 && (!info
->shared
|| !SYMBOL_REFERENCES_LOCAL (info
, h
)))
2097 if ((info
->shared
|| indx
!= 0)
2099 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2100 || h
->root
.type
!= bfd_link_hash_undefweak
))
2106 if (tls_type
& GOT_TLS_GD
)
2113 if (tls_type
& GOT_TLS_IE
)
2116 if ((tls_type
& GOT_TLS_LDM
) && info
->shared
)
2122 /* Count the number of TLS relocations required for the GOT entry in
2123 ARG1, if it describes a local symbol. */
2126 mips_elf_count_local_tls_relocs (void **arg1
, void *arg2
)
2128 struct mips_got_entry
*entry
= * (struct mips_got_entry
**) arg1
;
2129 struct mips_elf_count_tls_arg
*arg
= arg2
;
2131 if (entry
->abfd
!= NULL
&& entry
->symndx
!= -1)
2132 arg
->needed
+= mips_tls_got_relocs (arg
->info
, entry
->tls_type
, NULL
);
2137 /* Count the number of TLS GOT entries required for the global (or
2138 forced-local) symbol in ARG1. */
2141 mips_elf_count_global_tls_entries (void *arg1
, void *arg2
)
2143 struct mips_elf_link_hash_entry
*hm
2144 = (struct mips_elf_link_hash_entry
*) arg1
;
2145 struct mips_elf_count_tls_arg
*arg
= arg2
;
2147 if (hm
->tls_type
& GOT_TLS_GD
)
2149 if (hm
->tls_type
& GOT_TLS_IE
)
2155 /* Count the number of TLS relocations required for the global (or
2156 forced-local) symbol in ARG1. */
2159 mips_elf_count_global_tls_relocs (void *arg1
, void *arg2
)
2161 struct mips_elf_link_hash_entry
*hm
2162 = (struct mips_elf_link_hash_entry
*) arg1
;
2163 struct mips_elf_count_tls_arg
*arg
= arg2
;
2165 arg
->needed
+= mips_tls_got_relocs (arg
->info
, hm
->tls_type
, &hm
->root
);
2170 /* Output a simple dynamic relocation into SRELOC. */
2173 mips_elf_output_dynamic_relocation (bfd
*output_bfd
,
2179 Elf_Internal_Rela rel
[3];
2181 memset (rel
, 0, sizeof (rel
));
2183 rel
[0].r_info
= ELF_R_INFO (output_bfd
, indx
, r_type
);
2184 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
2186 if (ABI_64_P (output_bfd
))
2188 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
2189 (output_bfd
, &rel
[0],
2191 + sreloc
->reloc_count
* sizeof (Elf64_Mips_External_Rel
)));
2194 bfd_elf32_swap_reloc_out
2195 (output_bfd
, &rel
[0],
2197 + sreloc
->reloc_count
* sizeof (Elf32_External_Rel
)));
2198 ++sreloc
->reloc_count
;
2201 /* Initialize a set of TLS GOT entries for one symbol. */
2204 mips_elf_initialize_tls_slots (bfd
*abfd
, bfd_vma got_offset
,
2205 unsigned char *tls_type_p
,
2206 struct bfd_link_info
*info
,
2207 struct mips_elf_link_hash_entry
*h
,
2211 asection
*sreloc
, *sgot
;
2212 bfd_vma offset
, offset2
;
2214 bfd_boolean need_relocs
= FALSE
;
2216 dynobj
= elf_hash_table (info
)->dynobj
;
2217 sgot
= mips_elf_got_section (dynobj
, FALSE
);
2222 bfd_boolean dyn
= elf_hash_table (info
)->dynamic_sections_created
;
2224 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, &h
->root
)
2225 && (!info
->shared
|| !SYMBOL_REFERENCES_LOCAL (info
, &h
->root
)))
2226 indx
= h
->root
.dynindx
;
2229 if (*tls_type_p
& GOT_TLS_DONE
)
2232 if ((info
->shared
|| indx
!= 0)
2234 || ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
2235 || h
->root
.type
!= bfd_link_hash_undefweak
))
2238 /* MINUS_ONE means the symbol is not defined in this object. It may not
2239 be defined at all; assume that the value doesn't matter in that
2240 case. Otherwise complain if we would use the value. */
2241 BFD_ASSERT (value
!= MINUS_ONE
|| (indx
!= 0 && need_relocs
)
2242 || h
->root
.root
.type
== bfd_link_hash_undefweak
);
2244 /* Emit necessary relocations. */
2245 sreloc
= mips_elf_rel_dyn_section (info
, FALSE
);
2247 /* General Dynamic. */
2248 if (*tls_type_p
& GOT_TLS_GD
)
2250 offset
= got_offset
;
2251 offset2
= offset
+ MIPS_ELF_GOT_SIZE (abfd
);
2255 mips_elf_output_dynamic_relocation
2256 (abfd
, sreloc
, indx
,
2257 ABI_64_P (abfd
) ? R_MIPS_TLS_DTPMOD64
: R_MIPS_TLS_DTPMOD32
,
2258 sgot
->output_offset
+ sgot
->output_section
->vma
+ offset
);
2261 mips_elf_output_dynamic_relocation
2262 (abfd
, sreloc
, indx
,
2263 ABI_64_P (abfd
) ? R_MIPS_TLS_DTPREL64
: R_MIPS_TLS_DTPREL32
,
2264 sgot
->output_offset
+ sgot
->output_section
->vma
+ offset2
);
2266 MIPS_ELF_PUT_WORD (abfd
, value
- dtprel_base (info
),
2267 sgot
->contents
+ offset2
);
2271 MIPS_ELF_PUT_WORD (abfd
, 1,
2272 sgot
->contents
+ offset
);
2273 MIPS_ELF_PUT_WORD (abfd
, value
- dtprel_base (info
),
2274 sgot
->contents
+ offset2
);
2277 got_offset
+= 2 * MIPS_ELF_GOT_SIZE (abfd
);
2280 /* Initial Exec model. */
2281 if (*tls_type_p
& GOT_TLS_IE
)
2283 offset
= got_offset
;
2288 MIPS_ELF_PUT_WORD (abfd
, value
- elf_hash_table (info
)->tls_sec
->vma
,
2289 sgot
->contents
+ offset
);
2291 MIPS_ELF_PUT_WORD (abfd
, 0,
2292 sgot
->contents
+ offset
);
2294 mips_elf_output_dynamic_relocation
2295 (abfd
, sreloc
, indx
,
2296 ABI_64_P (abfd
) ? R_MIPS_TLS_TPREL64
: R_MIPS_TLS_TPREL32
,
2297 sgot
->output_offset
+ sgot
->output_section
->vma
+ offset
);
2300 MIPS_ELF_PUT_WORD (abfd
, value
- tprel_base (info
),
2301 sgot
->contents
+ offset
);
2304 if (*tls_type_p
& GOT_TLS_LDM
)
2306 /* The initial offset is zero, and the LD offsets will include the
2307 bias by DTP_OFFSET. */
2308 MIPS_ELF_PUT_WORD (abfd
, 0,
2309 sgot
->contents
+ got_offset
2310 + MIPS_ELF_GOT_SIZE (abfd
));
2313 MIPS_ELF_PUT_WORD (abfd
, 1,
2314 sgot
->contents
+ got_offset
);
2316 mips_elf_output_dynamic_relocation
2317 (abfd
, sreloc
, indx
,
2318 ABI_64_P (abfd
) ? R_MIPS_TLS_DTPMOD64
: R_MIPS_TLS_DTPMOD32
,
2319 sgot
->output_offset
+ sgot
->output_section
->vma
+ got_offset
);
2322 *tls_type_p
|= GOT_TLS_DONE
;
2325 /* Return the GOT index to use for a relocation of type R_TYPE against
2326 a symbol accessed using TLS_TYPE models. The GOT entries for this
2327 symbol in this GOT start at GOT_INDEX. This function initializes the
2328 GOT entries and corresponding relocations. */
2331 mips_tls_got_index (bfd
*abfd
, bfd_vma got_index
, unsigned char *tls_type
,
2332 int r_type
, struct bfd_link_info
*info
,
2333 struct mips_elf_link_hash_entry
*h
, bfd_vma symbol
)
2335 BFD_ASSERT (r_type
== R_MIPS_TLS_GOTTPREL
|| r_type
== R_MIPS_TLS_GD
2336 || r_type
== R_MIPS_TLS_LDM
);
2338 mips_elf_initialize_tls_slots (abfd
, got_index
, tls_type
, info
, h
, symbol
);
2340 if (r_type
== R_MIPS_TLS_GOTTPREL
)
2342 BFD_ASSERT (*tls_type
& GOT_TLS_IE
);
2343 if (*tls_type
& GOT_TLS_GD
)
2344 return got_index
+ 2 * MIPS_ELF_GOT_SIZE (abfd
);
2349 if (r_type
== R_MIPS_TLS_GD
)
2351 BFD_ASSERT (*tls_type
& GOT_TLS_GD
);
2355 if (r_type
== R_MIPS_TLS_LDM
)
2357 BFD_ASSERT (*tls_type
& GOT_TLS_LDM
);
2364 /* Return the offset from _GLOBAL_OFFSET_TABLE_ of the .got.plt entry
2365 for global symbol H. .got.plt comes before the GOT, so the offset
2366 will be negative. */
2369 mips_elf_gotplt_index (struct bfd_link_info
*info
,
2370 struct elf_link_hash_entry
*h
)
2372 bfd_vma plt_index
, got_address
, got_value
;
2373 struct mips_elf_link_hash_table
*htab
;
2375 htab
= mips_elf_hash_table (info
);
2376 BFD_ASSERT (h
->plt
.offset
!= (bfd_vma
) -1);
2378 /* Calculate the index of the symbol's PLT entry. */
2379 plt_index
= (h
->plt
.offset
- htab
->plt_header_size
) / htab
->plt_entry_size
;
2381 /* Calculate the address of the associated .got.plt entry. */
2382 got_address
= (htab
->sgotplt
->output_section
->vma
2383 + htab
->sgotplt
->output_offset
2386 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */
2387 got_value
= (htab
->root
.hgot
->root
.u
.def
.section
->output_section
->vma
2388 + htab
->root
.hgot
->root
.u
.def
.section
->output_offset
2389 + htab
->root
.hgot
->root
.u
.def
.value
);
2391 return got_address
- got_value
;
2394 /* Return the GOT offset for address VALUE, which was derived from
2395 a symbol belonging to INPUT_SECTION. If there is not yet a GOT
2396 entry for this value, create one. If R_SYMNDX refers to a TLS symbol,
2397 create a TLS GOT entry instead. Return -1 if no satisfactory GOT
2398 offset can be found. */
2401 mips_elf_local_got_index (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
2402 asection
*input_section
, bfd_vma value
,
2403 unsigned long r_symndx
,
2404 struct mips_elf_link_hash_entry
*h
, int r_type
)
2407 struct mips_got_info
*g
;
2408 struct mips_got_entry
*entry
;
2410 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
2412 entry
= mips_elf_create_local_got_entry (abfd
, info
, ibfd
, g
, sgot
,
2413 input_section
, value
,
2414 r_symndx
, h
, r_type
);
2418 if (TLS_RELOC_P (r_type
))
2420 if (entry
->symndx
== -1 && g
->next
== NULL
)
2421 /* A type (3) entry in the single-GOT case. We use the symbol's
2422 hash table entry to track the index. */
2423 return mips_tls_got_index (abfd
, h
->tls_got_offset
, &h
->tls_type
,
2424 r_type
, info
, h
, value
);
2426 return mips_tls_got_index (abfd
, entry
->gotidx
, &entry
->tls_type
,
2427 r_type
, info
, h
, value
);
2430 return entry
->gotidx
;
2433 /* Returns the GOT index for the global symbol indicated by H. */
2436 mips_elf_global_got_index (bfd
*abfd
, bfd
*ibfd
, struct elf_link_hash_entry
*h
,
2437 int r_type
, struct bfd_link_info
*info
)
2441 struct mips_got_info
*g
, *gg
;
2442 long global_got_dynindx
= 0;
2444 gg
= g
= mips_elf_got_info (abfd
, &sgot
);
2445 if (g
->bfd2got
&& ibfd
)
2447 struct mips_got_entry e
, *p
;
2449 BFD_ASSERT (h
->dynindx
>= 0);
2451 g
= mips_elf_got_for_ibfd (g
, ibfd
);
2452 if (g
->next
!= gg
|| TLS_RELOC_P (r_type
))
2456 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
2459 p
= htab_find (g
->got_entries
, &e
);
2461 BFD_ASSERT (p
->gotidx
> 0);
2463 if (TLS_RELOC_P (r_type
))
2465 bfd_vma value
= MINUS_ONE
;
2466 if ((h
->root
.type
== bfd_link_hash_defined
2467 || h
->root
.type
== bfd_link_hash_defweak
)
2468 && h
->root
.u
.def
.section
->output_section
)
2469 value
= (h
->root
.u
.def
.value
2470 + h
->root
.u
.def
.section
->output_offset
2471 + h
->root
.u
.def
.section
->output_section
->vma
);
2473 return mips_tls_got_index (abfd
, p
->gotidx
, &p
->tls_type
, r_type
,
2474 info
, e
.d
.h
, value
);
2481 if (gg
->global_gotsym
!= NULL
)
2482 global_got_dynindx
= gg
->global_gotsym
->dynindx
;
2484 if (TLS_RELOC_P (r_type
))
2486 struct mips_elf_link_hash_entry
*hm
2487 = (struct mips_elf_link_hash_entry
*) h
;
2488 bfd_vma value
= MINUS_ONE
;
2490 if ((h
->root
.type
== bfd_link_hash_defined
2491 || h
->root
.type
== bfd_link_hash_defweak
)
2492 && h
->root
.u
.def
.section
->output_section
)
2493 value
= (h
->root
.u
.def
.value
2494 + h
->root
.u
.def
.section
->output_offset
2495 + h
->root
.u
.def
.section
->output_section
->vma
);
2497 index
= mips_tls_got_index (abfd
, hm
->tls_got_offset
, &hm
->tls_type
,
2498 r_type
, info
, hm
, value
);
2502 /* Once we determine the global GOT entry with the lowest dynamic
2503 symbol table index, we must put all dynamic symbols with greater
2504 indices into the GOT. That makes it easy to calculate the GOT
2506 BFD_ASSERT (h
->dynindx
>= global_got_dynindx
);
2507 index
= ((h
->dynindx
- global_got_dynindx
+ g
->local_gotno
)
2508 * MIPS_ELF_GOT_SIZE (abfd
));
2510 BFD_ASSERT (index
< sgot
->size
);
2515 /* Find a GOT page entry that points to within 32KB of VALUE, which was
2516 calculated from a symbol belonging to INPUT_SECTION. These entries
2517 are supposed to be placed at small offsets in the GOT, i.e., within
2518 32KB of GP. Return the index of the GOT entry, or -1 if no entry
2519 could be created. If OFFSETP is nonnull, use it to return the
2520 offset of the GOT entry from VALUE. */
2523 mips_elf_got_page (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
2524 asection
*input_section
, bfd_vma value
, bfd_vma
*offsetp
)
2527 struct mips_got_info
*g
;
2528 bfd_vma page
, index
;
2529 struct mips_got_entry
*entry
;
2531 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
2533 page
= (value
+ 0x8000) & ~(bfd_vma
) 0xffff;
2534 entry
= mips_elf_create_local_got_entry (abfd
, info
, ibfd
, g
, sgot
,
2535 input_section
, page
, 0,
2536 NULL
, R_MIPS_GOT_PAGE
);
2541 index
= entry
->gotidx
;
2544 *offsetp
= value
- entry
->d
.address
;
2549 /* Find a local GOT entry for an R_MIPS_GOT16 relocation against VALUE,
2550 which was calculated from a symbol belonging to INPUT_SECTION.
2551 EXTERNAL is true if the relocation was against a global symbol
2552 that has been forced local. */
2555 mips_elf_got16_entry (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
2556 asection
*input_section
, bfd_vma value
,
2557 bfd_boolean external
)
2560 struct mips_got_info
*g
;
2561 struct mips_got_entry
*entry
;
2563 /* GOT16 relocations against local symbols are followed by a LO16
2564 relocation; those against global symbols are not. Thus if the
2565 symbol was originally local, the GOT16 relocation should load the
2566 equivalent of %hi(VALUE), otherwise it should load VALUE itself. */
2568 value
= mips_elf_high (value
) << 16;
2570 g
= mips_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
2572 entry
= mips_elf_create_local_got_entry (abfd
, info
, ibfd
, g
, sgot
,
2573 input_section
, value
, 0,
2574 NULL
, R_MIPS_GOT16
);
2576 return entry
->gotidx
;
2581 /* Returns the offset for the entry at the INDEXth position
2585 mips_elf_got_offset_from_index (bfd
*dynobj
, bfd
*output_bfd
,
2586 bfd
*input_bfd
, bfd_vma index
)
2590 struct mips_got_info
*g
;
2592 g
= mips_elf_got_info (dynobj
, &sgot
);
2593 gp
= _bfd_get_gp_value (output_bfd
)
2594 + mips_elf_adjust_gp (output_bfd
, g
, input_bfd
);
2596 return sgot
->output_section
->vma
+ sgot
->output_offset
+ index
- gp
;
2599 /* Create and return a local GOT entry for VALUE, which was calculated
2600 from a symbol belonging to INPUT_SECTON. Return NULL if it could not
2601 be created. If R_SYMNDX refers to a TLS symbol, create a TLS entry
2604 static struct mips_got_entry
*
2605 mips_elf_create_local_got_entry (bfd
*abfd
, struct bfd_link_info
*info
,
2606 bfd
*ibfd
, struct mips_got_info
*gg
,
2607 asection
*sgot
, asection
*input_section
,
2608 bfd_vma value
, unsigned long r_symndx
,
2609 struct mips_elf_link_hash_entry
*h
,
2612 struct mips_got_entry entry
, **loc
;
2613 struct mips_got_info
*g
;
2614 struct mips_elf_link_hash_table
*htab
;
2616 htab
= mips_elf_hash_table (info
);
2620 entry
.d
.address
= value
;
2623 g
= mips_elf_got_for_ibfd (gg
, ibfd
);
2626 g
= mips_elf_got_for_ibfd (gg
, abfd
);
2627 BFD_ASSERT (g
!= NULL
);
2630 /* We might have a symbol, H, if it has been forced local. Use the
2631 global entry then. It doesn't matter whether an entry is local
2632 or global for TLS, since the dynamic linker does not
2633 automatically relocate TLS GOT entries. */
2634 BFD_ASSERT (h
== NULL
|| h
->root
.forced_local
);
2635 if (TLS_RELOC_P (r_type
))
2637 struct mips_got_entry
*p
;
2640 if (r_type
== R_MIPS_TLS_LDM
)
2642 entry
.tls_type
= GOT_TLS_LDM
;
2648 entry
.symndx
= r_symndx
;
2654 p
= (struct mips_got_entry
*)
2655 htab_find (g
->got_entries
, &entry
);
2661 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
2666 entry
.gotidx
= MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
++;
2669 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2674 memcpy (*loc
, &entry
, sizeof entry
);
2676 if (g
->assigned_gotno
>= g
->local_gotno
)
2678 (*loc
)->gotidx
= -1;
2679 /* We didn't allocate enough space in the GOT. */
2680 (*_bfd_error_handler
)
2681 (_("not enough GOT space for local GOT entries"));
2682 bfd_set_error (bfd_error_bad_value
);
2686 MIPS_ELF_PUT_WORD (abfd
, value
,
2687 (sgot
->contents
+ entry
.gotidx
));
2689 /* These GOT entries need a dynamic relocation on VxWorks. Because
2690 the offset between segments is not fixed, the relocation must be
2691 against a symbol in the same segment as the original symbol.
2692 The easiest way to do this is to take INPUT_SECTION's output
2693 section and emit a relocation against its section symbol. */
2694 if (htab
->is_vxworks
)
2696 Elf_Internal_Rela outrel
;
2697 asection
*s
, *output_section
;
2699 bfd_vma got_address
;
2702 s
= mips_elf_rel_dyn_section (info
, FALSE
);
2703 output_section
= input_section
->output_section
;
2704 dynindx
= elf_section_data (output_section
)->dynindx
;
2705 got_address
= (sgot
->output_section
->vma
2706 + sgot
->output_offset
2709 loc
= s
->contents
+ (s
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2710 outrel
.r_offset
= got_address
;
2711 outrel
.r_info
= ELF32_R_INFO (dynindx
, R_MIPS_32
);
2712 outrel
.r_addend
= value
- output_section
->vma
;
2713 bfd_elf32_swap_reloca_out (abfd
, &outrel
, loc
);
2719 /* Sort the dynamic symbol table so that symbols that need GOT entries
2720 appear towards the end. This reduces the amount of GOT space
2721 required. MAX_LOCAL is used to set the number of local symbols
2722 known to be in the dynamic symbol table. During
2723 _bfd_mips_elf_size_dynamic_sections, this value is 1. Afterward, the
2724 section symbols are added and the count is higher. */
2727 mips_elf_sort_hash_table (struct bfd_link_info
*info
, unsigned long max_local
)
2729 struct mips_elf_hash_sort_data hsd
;
2730 struct mips_got_info
*g
;
2733 dynobj
= elf_hash_table (info
)->dynobj
;
2735 g
= mips_elf_got_info (dynobj
, NULL
);
2738 hsd
.max_unref_got_dynindx
=
2739 hsd
.min_got_dynindx
= elf_hash_table (info
)->dynsymcount
2740 /* In the multi-got case, assigned_gotno of the master got_info
2741 indicate the number of entries that aren't referenced in the
2742 primary GOT, but that must have entries because there are
2743 dynamic relocations that reference it. Since they aren't
2744 referenced, we move them to the end of the GOT, so that they
2745 don't prevent other entries that are referenced from getting
2746 too large offsets. */
2747 - (g
->next
? g
->assigned_gotno
: 0);
2748 hsd
.max_non_got_dynindx
= max_local
;
2749 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table
*)
2750 elf_hash_table (info
)),
2751 mips_elf_sort_hash_table_f
,
2754 /* There should have been enough room in the symbol table to
2755 accommodate both the GOT and non-GOT symbols. */
2756 BFD_ASSERT (hsd
.max_non_got_dynindx
<= hsd
.min_got_dynindx
);
2757 BFD_ASSERT ((unsigned long)hsd
.max_unref_got_dynindx
2758 <= elf_hash_table (info
)->dynsymcount
);
2760 /* Now we know which dynamic symbol has the lowest dynamic symbol
2761 table index in the GOT. */
2762 g
->global_gotsym
= hsd
.low
;
2767 /* If H needs a GOT entry, assign it the highest available dynamic
2768 index. Otherwise, assign it the lowest available dynamic
2772 mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry
*h
, void *data
)
2774 struct mips_elf_hash_sort_data
*hsd
= data
;
2776 if (h
->root
.root
.type
== bfd_link_hash_warning
)
2777 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2779 /* Symbols without dynamic symbol table entries aren't interesting
2781 if (h
->root
.dynindx
== -1)
2784 /* Global symbols that need GOT entries that are not explicitly
2785 referenced are marked with got offset 2. Those that are
2786 referenced get a 1, and those that don't need GOT entries get
2788 if (h
->root
.got
.offset
== 2)
2790 BFD_ASSERT (h
->tls_type
== GOT_NORMAL
);
2792 if (hsd
->max_unref_got_dynindx
== hsd
->min_got_dynindx
)
2793 hsd
->low
= (struct elf_link_hash_entry
*) h
;
2794 h
->root
.dynindx
= hsd
->max_unref_got_dynindx
++;
2796 else if (h
->root
.got
.offset
!= 1)
2797 h
->root
.dynindx
= hsd
->max_non_got_dynindx
++;
2800 BFD_ASSERT (h
->tls_type
== GOT_NORMAL
);
2802 h
->root
.dynindx
= --hsd
->min_got_dynindx
;
2803 hsd
->low
= (struct elf_link_hash_entry
*) h
;
2809 /* If H is a symbol that needs a global GOT entry, but has a dynamic
2810 symbol table index lower than any we've seen to date, record it for
2814 mips_elf_record_global_got_symbol (struct elf_link_hash_entry
*h
,
2815 bfd
*abfd
, struct bfd_link_info
*info
,
2816 struct mips_got_info
*g
,
2817 unsigned char tls_flag
)
2819 struct mips_got_entry entry
, **loc
;
2821 /* A global symbol in the GOT must also be in the dynamic symbol
2823 if (h
->dynindx
== -1)
2825 switch (ELF_ST_VISIBILITY (h
->other
))
2829 _bfd_mips_elf_hide_symbol (info
, h
, TRUE
);
2832 if (!bfd_elf_link_record_dynamic_symbol (info
, h
))
2836 /* Make sure we have a GOT to put this entry into. */
2837 BFD_ASSERT (g
!= NULL
);
2841 entry
.d
.h
= (struct mips_elf_link_hash_entry
*) h
;
2844 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
2847 /* If we've already marked this entry as needing GOT space, we don't
2848 need to do it again. */
2851 (*loc
)->tls_type
|= tls_flag
;
2855 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2861 entry
.tls_type
= tls_flag
;
2863 memcpy (*loc
, &entry
, sizeof entry
);
2865 if (h
->got
.offset
!= MINUS_ONE
)
2868 /* By setting this to a value other than -1, we are indicating that
2869 there needs to be a GOT entry for H. Avoid using zero, as the
2870 generic ELF copy_indirect_symbol tests for <= 0. */
2877 /* Reserve space in G for a GOT entry containing the value of symbol
2878 SYMNDX in input bfd ABDF, plus ADDEND. */
2881 mips_elf_record_local_got_symbol (bfd
*abfd
, long symndx
, bfd_vma addend
,
2882 struct mips_got_info
*g
,
2883 unsigned char tls_flag
)
2885 struct mips_got_entry entry
, **loc
;
2888 entry
.symndx
= symndx
;
2889 entry
.d
.addend
= addend
;
2890 entry
.tls_type
= tls_flag
;
2891 loc
= (struct mips_got_entry
**)
2892 htab_find_slot (g
->got_entries
, &entry
, INSERT
);
2896 if (tls_flag
== GOT_TLS_GD
&& !((*loc
)->tls_type
& GOT_TLS_GD
))
2899 (*loc
)->tls_type
|= tls_flag
;
2901 else if (tls_flag
== GOT_TLS_IE
&& !((*loc
)->tls_type
& GOT_TLS_IE
))
2904 (*loc
)->tls_type
|= tls_flag
;
2912 entry
.tls_type
= tls_flag
;
2913 if (tls_flag
== GOT_TLS_IE
)
2915 else if (tls_flag
== GOT_TLS_GD
)
2917 else if (g
->tls_ldm_offset
== MINUS_ONE
)
2919 g
->tls_ldm_offset
= MINUS_TWO
;
2925 entry
.gotidx
= g
->local_gotno
++;
2929 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
2934 memcpy (*loc
, &entry
, sizeof entry
);
2939 /* Compute the hash value of the bfd in a bfd2got hash entry. */
2942 mips_elf_bfd2got_entry_hash (const void *entry_
)
2944 const struct mips_elf_bfd2got_hash
*entry
2945 = (struct mips_elf_bfd2got_hash
*)entry_
;
2947 return entry
->bfd
->id
;
2950 /* Check whether two hash entries have the same bfd. */
2953 mips_elf_bfd2got_entry_eq (const void *entry1
, const void *entry2
)
2955 const struct mips_elf_bfd2got_hash
*e1
2956 = (const struct mips_elf_bfd2got_hash
*)entry1
;
2957 const struct mips_elf_bfd2got_hash
*e2
2958 = (const struct mips_elf_bfd2got_hash
*)entry2
;
2960 return e1
->bfd
== e2
->bfd
;
2963 /* In a multi-got link, determine the GOT to be used for IBFD. G must
2964 be the master GOT data. */
2966 static struct mips_got_info
*
2967 mips_elf_got_for_ibfd (struct mips_got_info
*g
, bfd
*ibfd
)
2969 struct mips_elf_bfd2got_hash e
, *p
;
2975 p
= htab_find (g
->bfd2got
, &e
);
2976 return p
? p
->g
: NULL
;
2979 /* Create one separate got for each bfd that has entries in the global
2980 got, such that we can tell how many local and global entries each
2984 mips_elf_make_got_per_bfd (void **entryp
, void *p
)
2986 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
2987 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
2988 htab_t bfd2got
= arg
->bfd2got
;
2989 struct mips_got_info
*g
;
2990 struct mips_elf_bfd2got_hash bfdgot_entry
, *bfdgot
;
2993 /* Find the got_info for this GOT entry's input bfd. Create one if
2995 bfdgot_entry
.bfd
= entry
->abfd
;
2996 bfdgotp
= htab_find_slot (bfd2got
, &bfdgot_entry
, INSERT
);
2997 bfdgot
= (struct mips_elf_bfd2got_hash
*)*bfdgotp
;
3003 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
3004 (arg
->obfd
, sizeof (struct mips_elf_bfd2got_hash
));
3014 bfdgot
->bfd
= entry
->abfd
;
3015 bfdgot
->g
= g
= (struct mips_got_info
*)
3016 bfd_alloc (arg
->obfd
, sizeof (struct mips_got_info
));
3023 g
->global_gotsym
= NULL
;
3024 g
->global_gotno
= 0;
3026 g
->assigned_gotno
= -1;
3028 g
->tls_assigned_gotno
= 0;
3029 g
->tls_ldm_offset
= MINUS_ONE
;
3030 g
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
3031 mips_elf_multi_got_entry_eq
, NULL
);
3032 if (g
->got_entries
== NULL
)
3042 /* Insert the GOT entry in the bfd's got entry hash table. */
3043 entryp
= htab_find_slot (g
->got_entries
, entry
, INSERT
);
3044 if (*entryp
!= NULL
)
3049 if (entry
->tls_type
)
3051 if (entry
->tls_type
& (GOT_TLS_GD
| GOT_TLS_LDM
))
3053 if (entry
->tls_type
& GOT_TLS_IE
)
3056 else if (entry
->symndx
>= 0 || entry
->d
.h
->forced_local
)
3064 /* Attempt to merge gots of different input bfds. Try to use as much
3065 as possible of the primary got, since it doesn't require explicit
3066 dynamic relocations, but don't use bfds that would reference global
3067 symbols out of the addressable range. Failing the primary got,
3068 attempt to merge with the current got, or finish the current got
3069 and then make make the new got current. */
3072 mips_elf_merge_gots (void **bfd2got_
, void *p
)
3074 struct mips_elf_bfd2got_hash
*bfd2got
3075 = (struct mips_elf_bfd2got_hash
*)*bfd2got_
;
3076 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
3077 unsigned int lcount
= bfd2got
->g
->local_gotno
;
3078 unsigned int gcount
= bfd2got
->g
->global_gotno
;
3079 unsigned int tcount
= bfd2got
->g
->tls_gotno
;
3080 unsigned int maxcnt
= arg
->max_count
;
3081 bfd_boolean too_many_for_tls
= FALSE
;
3083 /* We place TLS GOT entries after both locals and globals. The globals
3084 for the primary GOT may overflow the normal GOT size limit, so be
3085 sure not to merge a GOT which requires TLS with the primary GOT in that
3086 case. This doesn't affect non-primary GOTs. */
3089 unsigned int primary_total
= lcount
+ tcount
+ arg
->global_count
;
3090 if (primary_total
* MIPS_ELF_GOT_SIZE (bfd2got
->bfd
)
3091 >= MIPS_ELF_GOT_MAX_SIZE (arg
->info
))
3092 too_many_for_tls
= TRUE
;
3095 /* If we don't have a primary GOT and this is not too big, use it as
3096 a starting point for the primary GOT. */
3097 if (! arg
->primary
&& lcount
+ gcount
+ tcount
<= maxcnt
3098 && ! too_many_for_tls
)
3100 arg
->primary
= bfd2got
->g
;
3101 arg
->primary_count
= lcount
+ gcount
;
3103 /* If it looks like we can merge this bfd's entries with those of
3104 the primary, merge them. The heuristics is conservative, but we
3105 don't have to squeeze it too hard. */
3106 else if (arg
->primary
&& ! too_many_for_tls
3107 && (arg
->primary_count
+ lcount
+ gcount
+ tcount
) <= maxcnt
)
3109 struct mips_got_info
*g
= bfd2got
->g
;
3110 int old_lcount
= arg
->primary
->local_gotno
;
3111 int old_gcount
= arg
->primary
->global_gotno
;
3112 int old_tcount
= arg
->primary
->tls_gotno
;
3114 bfd2got
->g
= arg
->primary
;
3116 htab_traverse (g
->got_entries
,
3117 mips_elf_make_got_per_bfd
,
3119 if (arg
->obfd
== NULL
)
3122 htab_delete (g
->got_entries
);
3123 /* We don't have to worry about releasing memory of the actual
3124 got entries, since they're all in the master got_entries hash
3127 BFD_ASSERT (old_lcount
+ lcount
>= arg
->primary
->local_gotno
);
3128 BFD_ASSERT (old_gcount
+ gcount
>= arg
->primary
->global_gotno
);
3129 BFD_ASSERT (old_tcount
+ tcount
>= arg
->primary
->tls_gotno
);
3131 arg
->primary_count
= arg
->primary
->local_gotno
3132 + arg
->primary
->global_gotno
+ arg
->primary
->tls_gotno
;
3134 /* If we can merge with the last-created got, do it. */
3135 else if (arg
->current
3136 && arg
->current_count
+ lcount
+ gcount
+ tcount
<= maxcnt
)
3138 struct mips_got_info
*g
= bfd2got
->g
;
3139 int old_lcount
= arg
->current
->local_gotno
;
3140 int old_gcount
= arg
->current
->global_gotno
;
3141 int old_tcount
= arg
->current
->tls_gotno
;
3143 bfd2got
->g
= arg
->current
;
3145 htab_traverse (g
->got_entries
,
3146 mips_elf_make_got_per_bfd
,
3148 if (arg
->obfd
== NULL
)
3151 htab_delete (g
->got_entries
);
3153 BFD_ASSERT (old_lcount
+ lcount
>= arg
->current
->local_gotno
);
3154 BFD_ASSERT (old_gcount
+ gcount
>= arg
->current
->global_gotno
);
3155 BFD_ASSERT (old_tcount
+ tcount
>= arg
->current
->tls_gotno
);
3157 arg
->current_count
= arg
->current
->local_gotno
3158 + arg
->current
->global_gotno
+ arg
->current
->tls_gotno
;
3160 /* Well, we couldn't merge, so create a new GOT. Don't check if it
3161 fits; if it turns out that it doesn't, we'll get relocation
3162 overflows anyway. */
3165 bfd2got
->g
->next
= arg
->current
;
3166 arg
->current
= bfd2got
->g
;
3168 arg
->current_count
= lcount
+ gcount
+ 2 * tcount
;
3174 /* Set the TLS GOT index for the GOT entry in ENTRYP. ENTRYP's NEXT field
3175 is null iff there is just a single GOT. */
3178 mips_elf_initialize_tls_index (void **entryp
, void *p
)
3180 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
3181 struct mips_got_info
*g
= p
;
3184 /* We're only interested in TLS symbols. */
3185 if (entry
->tls_type
== 0)
3188 next_index
= MIPS_ELF_GOT_SIZE (entry
->abfd
) * (long) g
->tls_assigned_gotno
;
3190 if (entry
->symndx
== -1 && g
->next
== NULL
)
3192 /* A type (3) got entry in the single-GOT case. We use the symbol's
3193 hash table entry to track its index. */
3194 if (entry
->d
.h
->tls_type
& GOT_TLS_OFFSET_DONE
)
3196 entry
->d
.h
->tls_type
|= GOT_TLS_OFFSET_DONE
;
3197 entry
->d
.h
->tls_got_offset
= next_index
;
3201 if (entry
->tls_type
& GOT_TLS_LDM
)
3203 /* There are separate mips_got_entry objects for each input bfd
3204 that requires an LDM entry. Make sure that all LDM entries in
3205 a GOT resolve to the same index. */
3206 if (g
->tls_ldm_offset
!= MINUS_TWO
&& g
->tls_ldm_offset
!= MINUS_ONE
)
3208 entry
->gotidx
= g
->tls_ldm_offset
;
3211 g
->tls_ldm_offset
= next_index
;
3213 entry
->gotidx
= next_index
;
3216 /* Account for the entries we've just allocated. */
3217 if (entry
->tls_type
& (GOT_TLS_GD
| GOT_TLS_LDM
))
3218 g
->tls_assigned_gotno
+= 2;
3219 if (entry
->tls_type
& GOT_TLS_IE
)
3220 g
->tls_assigned_gotno
+= 1;
3225 /* If passed a NULL mips_got_info in the argument, set the marker used
3226 to tell whether a global symbol needs a got entry (in the primary
3227 got) to the given VALUE.
3229 If passed a pointer G to a mips_got_info in the argument (it must
3230 not be the primary GOT), compute the offset from the beginning of
3231 the (primary) GOT section to the entry in G corresponding to the
3232 global symbol. G's assigned_gotno must contain the index of the
3233 first available global GOT entry in G. VALUE must contain the size
3234 of a GOT entry in bytes. For each global GOT entry that requires a
3235 dynamic relocation, NEEDED_RELOCS is incremented, and the symbol is
3236 marked as not eligible for lazy resolution through a function
3239 mips_elf_set_global_got_offset (void **entryp
, void *p
)
3241 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
3242 struct mips_elf_set_global_got_offset_arg
*arg
3243 = (struct mips_elf_set_global_got_offset_arg
*)p
;
3244 struct mips_got_info
*g
= arg
->g
;
3246 if (g
&& entry
->tls_type
!= GOT_NORMAL
)
3247 arg
->needed_relocs
+=
3248 mips_tls_got_relocs (arg
->info
, entry
->tls_type
,
3249 entry
->symndx
== -1 ? &entry
->d
.h
->root
: NULL
);
3251 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1
3252 && entry
->d
.h
->root
.dynindx
!= -1
3253 && entry
->d
.h
->tls_type
== GOT_NORMAL
)
3257 BFD_ASSERT (g
->global_gotsym
== NULL
);
3259 entry
->gotidx
= arg
->value
* (long) g
->assigned_gotno
++;
3260 if (arg
->info
->shared
3261 || (elf_hash_table (arg
->info
)->dynamic_sections_created
3262 && entry
->d
.h
->root
.def_dynamic
3263 && !entry
->d
.h
->root
.def_regular
))
3264 ++arg
->needed_relocs
;
3267 entry
->d
.h
->root
.got
.offset
= arg
->value
;
3273 /* Mark any global symbols referenced in the GOT we are iterating over
3274 as inelligible for lazy resolution stubs. */
3276 mips_elf_set_no_stub (void **entryp
, void *p ATTRIBUTE_UNUSED
)
3278 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
3280 if (entry
->abfd
!= NULL
3281 && entry
->symndx
== -1
3282 && entry
->d
.h
->root
.dynindx
!= -1)
3283 entry
->d
.h
->no_fn_stub
= TRUE
;
3288 /* Follow indirect and warning hash entries so that each got entry
3289 points to the final symbol definition. P must point to a pointer
3290 to the hash table we're traversing. Since this traversal may
3291 modify the hash table, we set this pointer to NULL to indicate
3292 we've made a potentially-destructive change to the hash table, so
3293 the traversal must be restarted. */
3295 mips_elf_resolve_final_got_entry (void **entryp
, void *p
)
3297 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
3298 htab_t got_entries
= *(htab_t
*)p
;
3300 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1)
3302 struct mips_elf_link_hash_entry
*h
= entry
->d
.h
;
3304 while (h
->root
.root
.type
== bfd_link_hash_indirect
3305 || h
->root
.root
.type
== bfd_link_hash_warning
)
3306 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3308 if (entry
->d
.h
== h
)
3313 /* If we can't find this entry with the new bfd hash, re-insert
3314 it, and get the traversal restarted. */
3315 if (! htab_find (got_entries
, entry
))
3317 htab_clear_slot (got_entries
, entryp
);
3318 entryp
= htab_find_slot (got_entries
, entry
, INSERT
);
3321 /* Abort the traversal, since the whole table may have
3322 moved, and leave it up to the parent to restart the
3324 *(htab_t
*)p
= NULL
;
3327 /* We might want to decrement the global_gotno count, but it's
3328 either too early or too late for that at this point. */
3334 /* Turn indirect got entries in a got_entries table into their final
3337 mips_elf_resolve_final_got_entries (struct mips_got_info
*g
)
3343 got_entries
= g
->got_entries
;
3345 htab_traverse (got_entries
,
3346 mips_elf_resolve_final_got_entry
,
3349 while (got_entries
== NULL
);
3352 /* Return the offset of an input bfd IBFD's GOT from the beginning of
3355 mips_elf_adjust_gp (bfd
*abfd
, struct mips_got_info
*g
, bfd
*ibfd
)
3357 if (g
->bfd2got
== NULL
)
3360 g
= mips_elf_got_for_ibfd (g
, ibfd
);
3364 BFD_ASSERT (g
->next
);
3368 return (g
->local_gotno
+ g
->global_gotno
+ g
->tls_gotno
)
3369 * MIPS_ELF_GOT_SIZE (abfd
);
3372 /* Turn a single GOT that is too big for 16-bit addressing into
3373 a sequence of GOTs, each one 16-bit addressable. */
3376 mips_elf_multi_got (bfd
*abfd
, struct bfd_link_info
*info
,
3377 struct mips_got_info
*g
, asection
*got
,
3378 bfd_size_type pages
)
3380 struct mips_elf_got_per_bfd_arg got_per_bfd_arg
;
3381 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
3382 struct mips_got_info
*gg
;
3383 unsigned int assign
;
3385 g
->bfd2got
= htab_try_create (1, mips_elf_bfd2got_entry_hash
,
3386 mips_elf_bfd2got_entry_eq
, NULL
);
3387 if (g
->bfd2got
== NULL
)
3390 got_per_bfd_arg
.bfd2got
= g
->bfd2got
;
3391 got_per_bfd_arg
.obfd
= abfd
;
3392 got_per_bfd_arg
.info
= info
;
3394 /* Count how many GOT entries each input bfd requires, creating a
3395 map from bfd to got info while at that. */
3396 htab_traverse (g
->got_entries
, mips_elf_make_got_per_bfd
, &got_per_bfd_arg
);
3397 if (got_per_bfd_arg
.obfd
== NULL
)
3400 got_per_bfd_arg
.current
= NULL
;
3401 got_per_bfd_arg
.primary
= NULL
;
3402 /* Taking out PAGES entries is a worst-case estimate. We could
3403 compute the maximum number of pages that each separate input bfd
3404 uses, but it's probably not worth it. */
3405 got_per_bfd_arg
.max_count
= ((MIPS_ELF_GOT_MAX_SIZE (info
)
3406 / MIPS_ELF_GOT_SIZE (abfd
))
3407 - MIPS_RESERVED_GOTNO (info
) - pages
);
3408 /* The number of globals that will be included in the primary GOT.
3409 See the calls to mips_elf_set_global_got_offset below for more
3411 got_per_bfd_arg
.global_count
= g
->global_gotno
;
3413 /* Try to merge the GOTs of input bfds together, as long as they
3414 don't seem to exceed the maximum GOT size, choosing one of them
3415 to be the primary GOT. */
3416 htab_traverse (g
->bfd2got
, mips_elf_merge_gots
, &got_per_bfd_arg
);
3417 if (got_per_bfd_arg
.obfd
== NULL
)
3420 /* If we do not find any suitable primary GOT, create an empty one. */
3421 if (got_per_bfd_arg
.primary
== NULL
)
3423 g
->next
= (struct mips_got_info
*)
3424 bfd_alloc (abfd
, sizeof (struct mips_got_info
));
3425 if (g
->next
== NULL
)
3428 g
->next
->global_gotsym
= NULL
;
3429 g
->next
->global_gotno
= 0;
3430 g
->next
->local_gotno
= 0;
3431 g
->next
->tls_gotno
= 0;
3432 g
->next
->assigned_gotno
= 0;
3433 g
->next
->tls_assigned_gotno
= 0;
3434 g
->next
->tls_ldm_offset
= MINUS_ONE
;
3435 g
->next
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
3436 mips_elf_multi_got_entry_eq
,
3438 if (g
->next
->got_entries
== NULL
)
3440 g
->next
->bfd2got
= NULL
;
3443 g
->next
= got_per_bfd_arg
.primary
;
3444 g
->next
->next
= got_per_bfd_arg
.current
;
3446 /* GG is now the master GOT, and G is the primary GOT. */
3450 /* Map the output bfd to the primary got. That's what we're going
3451 to use for bfds that use GOT16 or GOT_PAGE relocations that we
3452 didn't mark in check_relocs, and we want a quick way to find it.
3453 We can't just use gg->next because we're going to reverse the
3456 struct mips_elf_bfd2got_hash
*bfdgot
;
3459 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
3460 (abfd
, sizeof (struct mips_elf_bfd2got_hash
));
3467 bfdgotp
= htab_find_slot (gg
->bfd2got
, bfdgot
, INSERT
);
3469 BFD_ASSERT (*bfdgotp
== NULL
);
3473 /* The IRIX dynamic linker requires every symbol that is referenced
3474 in a dynamic relocation to be present in the primary GOT, so
3475 arrange for them to appear after those that are actually
3478 GNU/Linux could very well do without it, but it would slow down
3479 the dynamic linker, since it would have to resolve every dynamic
3480 symbol referenced in other GOTs more than once, without help from
3481 the cache. Also, knowing that every external symbol has a GOT
3482 helps speed up the resolution of local symbols too, so GNU/Linux
3483 follows IRIX's practice.
3485 The number 2 is used by mips_elf_sort_hash_table_f to count
3486 global GOT symbols that are unreferenced in the primary GOT, with
3487 an initial dynamic index computed from gg->assigned_gotno, where
3488 the number of unreferenced global entries in the primary GOT is
3492 gg
->assigned_gotno
= gg
->global_gotno
- g
->global_gotno
;
3493 g
->global_gotno
= gg
->global_gotno
;
3494 set_got_offset_arg
.value
= 2;
3498 /* This could be used for dynamic linkers that don't optimize
3499 symbol resolution while applying relocations so as to use
3500 primary GOT entries or assuming the symbol is locally-defined.
3501 With this code, we assign lower dynamic indices to global
3502 symbols that are not referenced in the primary GOT, so that
3503 their entries can be omitted. */
3504 gg
->assigned_gotno
= 0;
3505 set_got_offset_arg
.value
= -1;
3508 /* Reorder dynamic symbols as described above (which behavior
3509 depends on the setting of VALUE). */
3510 set_got_offset_arg
.g
= NULL
;
3511 htab_traverse (gg
->got_entries
, mips_elf_set_global_got_offset
,
3512 &set_got_offset_arg
);
3513 set_got_offset_arg
.value
= 1;
3514 htab_traverse (g
->got_entries
, mips_elf_set_global_got_offset
,
3515 &set_got_offset_arg
);
3516 if (! mips_elf_sort_hash_table (info
, 1))
3519 /* Now go through the GOTs assigning them offset ranges.
3520 [assigned_gotno, local_gotno[ will be set to the range of local
3521 entries in each GOT. We can then compute the end of a GOT by
3522 adding local_gotno to global_gotno. We reverse the list and make
3523 it circular since then we'll be able to quickly compute the
3524 beginning of a GOT, by computing the end of its predecessor. To
3525 avoid special cases for the primary GOT, while still preserving
3526 assertions that are valid for both single- and multi-got links,
3527 we arrange for the main got struct to have the right number of
3528 global entries, but set its local_gotno such that the initial
3529 offset of the primary GOT is zero. Remember that the primary GOT
3530 will become the last item in the circular linked list, so it
3531 points back to the master GOT. */
3532 gg
->local_gotno
= -g
->global_gotno
;
3533 gg
->global_gotno
= g
->global_gotno
;
3540 struct mips_got_info
*gn
;
3542 assign
+= MIPS_RESERVED_GOTNO (info
);
3543 g
->assigned_gotno
= assign
;
3544 g
->local_gotno
+= assign
+ pages
;
3545 assign
= g
->local_gotno
+ g
->global_gotno
+ g
->tls_gotno
;
3547 /* Take g out of the direct list, and push it onto the reversed
3548 list that gg points to. g->next is guaranteed to be nonnull after
3549 this operation, as required by mips_elf_initialize_tls_index. */
3554 /* Set up any TLS entries. We always place the TLS entries after
3555 all non-TLS entries. */
3556 g
->tls_assigned_gotno
= g
->local_gotno
+ g
->global_gotno
;
3557 htab_traverse (g
->got_entries
, mips_elf_initialize_tls_index
, g
);
3559 /* Move onto the next GOT. It will be a secondary GOT if nonull. */
3562 /* Mark global symbols in every non-primary GOT as ineligible for
3565 htab_traverse (g
->got_entries
, mips_elf_set_no_stub
, NULL
);
3569 got
->size
= (gg
->next
->local_gotno
3570 + gg
->next
->global_gotno
3571 + gg
->next
->tls_gotno
) * MIPS_ELF_GOT_SIZE (abfd
);
3577 /* Returns the first relocation of type r_type found, beginning with
3578 RELOCATION. RELEND is one-past-the-end of the relocation table. */
3580 static const Elf_Internal_Rela
*
3581 mips_elf_next_relocation (bfd
*abfd ATTRIBUTE_UNUSED
, unsigned int r_type
,
3582 const Elf_Internal_Rela
*relocation
,
3583 const Elf_Internal_Rela
*relend
)
3585 while (relocation
< relend
)
3587 if (ELF_R_TYPE (abfd
, relocation
->r_info
) == r_type
)
3593 /* We didn't find it. */
3594 bfd_set_error (bfd_error_bad_value
);
3598 /* Return whether a relocation is against a local symbol. */
3601 mips_elf_local_relocation_p (bfd
*input_bfd
,
3602 const Elf_Internal_Rela
*relocation
,
3603 asection
**local_sections
,
3604 bfd_boolean check_forced
)
3606 unsigned long r_symndx
;
3607 Elf_Internal_Shdr
*symtab_hdr
;
3608 struct mips_elf_link_hash_entry
*h
;
3611 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
3612 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3613 extsymoff
= (elf_bad_symtab (input_bfd
)) ? 0 : symtab_hdr
->sh_info
;
3615 if (r_symndx
< extsymoff
)
3617 if (elf_bad_symtab (input_bfd
) && local_sections
[r_symndx
] != NULL
)
3622 /* Look up the hash table to check whether the symbol
3623 was forced local. */
3624 h
= (struct mips_elf_link_hash_entry
*)
3625 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
];
3626 /* Find the real hash-table entry for this symbol. */
3627 while (h
->root
.root
.type
== bfd_link_hash_indirect
3628 || h
->root
.root
.type
== bfd_link_hash_warning
)
3629 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3630 if (h
->root
.forced_local
)
3637 /* Sign-extend VALUE, which has the indicated number of BITS. */
3640 _bfd_mips_elf_sign_extend (bfd_vma value
, int bits
)
3642 if (value
& ((bfd_vma
) 1 << (bits
- 1)))
3643 /* VALUE is negative. */
3644 value
|= ((bfd_vma
) - 1) << bits
;
3649 /* Return non-zero if the indicated VALUE has overflowed the maximum
3650 range expressible by a signed number with the indicated number of
3654 mips_elf_overflow_p (bfd_vma value
, int bits
)
3656 bfd_signed_vma svalue
= (bfd_signed_vma
) value
;
3658 if (svalue
> (1 << (bits
- 1)) - 1)
3659 /* The value is too big. */
3661 else if (svalue
< -(1 << (bits
- 1)))
3662 /* The value is too small. */
3669 /* Calculate the %high function. */
3672 mips_elf_high (bfd_vma value
)
3674 return ((value
+ (bfd_vma
) 0x8000) >> 16) & 0xffff;
3677 /* Calculate the %higher function. */
3680 mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED
)
3683 return ((value
+ (bfd_vma
) 0x80008000) >> 32) & 0xffff;
3690 /* Calculate the %highest function. */
3693 mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED
)
3696 return ((value
+ (((bfd_vma
) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
3703 /* Create the .compact_rel section. */
3706 mips_elf_create_compact_rel_section
3707 (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3710 register asection
*s
;
3712 if (bfd_get_section_by_name (abfd
, ".compact_rel") == NULL
)
3714 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
3717 s
= bfd_make_section_with_flags (abfd
, ".compact_rel", flags
);
3719 || ! bfd_set_section_alignment (abfd
, s
,
3720 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
3723 s
->size
= sizeof (Elf32_External_compact_rel
);
3729 /* Create the .got section to hold the global offset table. */
3732 mips_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
,
3733 bfd_boolean maybe_exclude
)
3736 register asection
*s
;
3737 struct elf_link_hash_entry
*h
;
3738 struct bfd_link_hash_entry
*bh
;
3739 struct mips_got_info
*g
;
3741 struct mips_elf_link_hash_table
*htab
;
3743 htab
= mips_elf_hash_table (info
);
3745 /* This function may be called more than once. */
3746 s
= mips_elf_got_section (abfd
, TRUE
);
3749 if (! maybe_exclude
)
3750 s
->flags
&= ~SEC_EXCLUDE
;
3754 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3755 | SEC_LINKER_CREATED
);
3758 flags
|= SEC_EXCLUDE
;
3760 /* We have to use an alignment of 2**4 here because this is hardcoded
3761 in the function stub generation and in the linker script. */
3762 s
= bfd_make_section_with_flags (abfd
, ".got", flags
);
3764 || ! bfd_set_section_alignment (abfd
, s
, 4))
3767 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
3768 linker script because we don't want to define the symbol if we
3769 are not creating a global offset table. */
3771 if (! (_bfd_generic_link_add_one_symbol
3772 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
3773 0, NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
3776 h
= (struct elf_link_hash_entry
*) bh
;
3779 h
->type
= STT_OBJECT
;
3780 elf_hash_table (info
)->hgot
= h
;
3783 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3786 amt
= sizeof (struct mips_got_info
);
3787 g
= bfd_alloc (abfd
, amt
);
3790 g
->global_gotsym
= NULL
;
3791 g
->global_gotno
= 0;
3793 g
->local_gotno
= MIPS_RESERVED_GOTNO (info
);
3794 g
->assigned_gotno
= MIPS_RESERVED_GOTNO (info
);
3797 g
->tls_ldm_offset
= MINUS_ONE
;
3798 g
->got_entries
= htab_try_create (1, mips_elf_got_entry_hash
,
3799 mips_elf_got_entry_eq
, NULL
);
3800 if (g
->got_entries
== NULL
)
3802 mips_elf_section_data (s
)->u
.got_info
= g
;
3803 mips_elf_section_data (s
)->elf
.this_hdr
.sh_flags
3804 |= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
3806 /* VxWorks also needs a .got.plt section. */
3807 if (htab
->is_vxworks
)
3809 s
= bfd_make_section_with_flags (abfd
, ".got.plt",
3810 SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
3811 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3812 if (s
== NULL
|| !bfd_set_section_alignment (abfd
, s
, 4))
3820 /* Return true if H refers to the special VxWorks __GOTT_BASE__ or
3821 __GOTT_INDEX__ symbols. These symbols are only special for
3822 shared objects; they are not used in executables. */
3825 is_gott_symbol (struct bfd_link_info
*info
, struct elf_link_hash_entry
*h
)
3827 return (mips_elf_hash_table (info
)->is_vxworks
3829 && (strcmp (h
->root
.root
.string
, "__GOTT_BASE__") == 0
3830 || strcmp (h
->root
.root
.string
, "__GOTT_INDEX__") == 0));
3833 /* Calculate the value produced by the RELOCATION (which comes from
3834 the INPUT_BFD). The ADDEND is the addend to use for this
3835 RELOCATION; RELOCATION->R_ADDEND is ignored.
3837 The result of the relocation calculation is stored in VALUEP.
3838 REQUIRE_JALXP indicates whether or not the opcode used with this
3839 relocation must be JALX.
3841 This function returns bfd_reloc_continue if the caller need take no
3842 further action regarding this relocation, bfd_reloc_notsupported if
3843 something goes dramatically wrong, bfd_reloc_overflow if an
3844 overflow occurs, and bfd_reloc_ok to indicate success. */
3846 static bfd_reloc_status_type
3847 mips_elf_calculate_relocation (bfd
*abfd
, bfd
*input_bfd
,
3848 asection
*input_section
,
3849 struct bfd_link_info
*info
,
3850 const Elf_Internal_Rela
*relocation
,
3851 bfd_vma addend
, reloc_howto_type
*howto
,
3852 Elf_Internal_Sym
*local_syms
,
3853 asection
**local_sections
, bfd_vma
*valuep
,
3854 const char **namep
, bfd_boolean
*require_jalxp
,
3855 bfd_boolean save_addend
)
3857 /* The eventual value we will return. */
3859 /* The address of the symbol against which the relocation is
3862 /* The final GP value to be used for the relocatable, executable, or
3863 shared object file being produced. */
3864 bfd_vma gp
= MINUS_ONE
;
3865 /* The place (section offset or address) of the storage unit being
3868 /* The value of GP used to create the relocatable object. */
3869 bfd_vma gp0
= MINUS_ONE
;
3870 /* The offset into the global offset table at which the address of
3871 the relocation entry symbol, adjusted by the addend, resides
3872 during execution. */
3873 bfd_vma g
= MINUS_ONE
;
3874 /* The section in which the symbol referenced by the relocation is
3876 asection
*sec
= NULL
;
3877 struct mips_elf_link_hash_entry
*h
= NULL
;
3878 /* TRUE if the symbol referred to by this relocation is a local
3880 bfd_boolean local_p
, was_local_p
;
3881 /* TRUE if the symbol referred to by this relocation is "_gp_disp". */
3882 bfd_boolean gp_disp_p
= FALSE
;
3883 /* TRUE if the symbol referred to by this relocation is
3884 "__gnu_local_gp". */
3885 bfd_boolean gnu_local_gp_p
= FALSE
;
3886 Elf_Internal_Shdr
*symtab_hdr
;
3888 unsigned long r_symndx
;
3890 /* TRUE if overflow occurred during the calculation of the
3891 relocation value. */
3892 bfd_boolean overflowed_p
;
3893 /* TRUE if this relocation refers to a MIPS16 function. */
3894 bfd_boolean target_is_16_bit_code_p
= FALSE
;
3895 struct mips_elf_link_hash_table
*htab
;
3898 dynobj
= elf_hash_table (info
)->dynobj
;
3899 htab
= mips_elf_hash_table (info
);
3901 /* Parse the relocation. */
3902 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
3903 r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
3904 p
= (input_section
->output_section
->vma
3905 + input_section
->output_offset
3906 + relocation
->r_offset
);
3908 /* Assume that there will be no overflow. */
3909 overflowed_p
= FALSE
;
3911 /* Figure out whether or not the symbol is local, and get the offset
3912 used in the array of hash table entries. */
3913 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3914 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
3915 local_sections
, FALSE
);
3916 was_local_p
= local_p
;
3917 if (! elf_bad_symtab (input_bfd
))
3918 extsymoff
= symtab_hdr
->sh_info
;
3921 /* The symbol table does not follow the rule that local symbols
3922 must come before globals. */
3926 /* Figure out the value of the symbol. */
3929 Elf_Internal_Sym
*sym
;
3931 sym
= local_syms
+ r_symndx
;
3932 sec
= local_sections
[r_symndx
];
3934 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
3935 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
3936 || (sec
->flags
& SEC_MERGE
))
3937 symbol
+= sym
->st_value
;
3938 if ((sec
->flags
& SEC_MERGE
)
3939 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3941 addend
= _bfd_elf_rel_local_sym (abfd
, sym
, &sec
, addend
);
3943 addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
3946 /* MIPS16 text labels should be treated as odd. */
3947 if (sym
->st_other
== STO_MIPS16
)
3950 /* Record the name of this symbol, for our caller. */
3951 *namep
= bfd_elf_string_from_elf_section (input_bfd
,
3952 symtab_hdr
->sh_link
,
3955 *namep
= bfd_section_name (input_bfd
, sec
);
3957 target_is_16_bit_code_p
= (sym
->st_other
== STO_MIPS16
);
3961 /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ? */
3963 /* For global symbols we look up the symbol in the hash-table. */
3964 h
= ((struct mips_elf_link_hash_entry
*)
3965 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
]);
3966 /* Find the real hash-table entry for this symbol. */
3967 while (h
->root
.root
.type
== bfd_link_hash_indirect
3968 || h
->root
.root
.type
== bfd_link_hash_warning
)
3969 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3971 /* Record the name of this symbol, for our caller. */
3972 *namep
= h
->root
.root
.root
.string
;
3974 /* See if this is the special _gp_disp symbol. Note that such a
3975 symbol must always be a global symbol. */
3976 if (strcmp (*namep
, "_gp_disp") == 0
3977 && ! NEWABI_P (input_bfd
))
3979 /* Relocations against _gp_disp are permitted only with
3980 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
3981 if (r_type
!= R_MIPS_HI16
&& r_type
!= R_MIPS_LO16
3982 && r_type
!= R_MIPS16_HI16
&& r_type
!= R_MIPS16_LO16
)
3983 return bfd_reloc_notsupported
;
3987 /* See if this is the special _gp symbol. Note that such a
3988 symbol must always be a global symbol. */
3989 else if (strcmp (*namep
, "__gnu_local_gp") == 0)
3990 gnu_local_gp_p
= TRUE
;
3993 /* If this symbol is defined, calculate its address. Note that
3994 _gp_disp is a magic symbol, always implicitly defined by the
3995 linker, so it's inappropriate to check to see whether or not
3997 else if ((h
->root
.root
.type
== bfd_link_hash_defined
3998 || h
->root
.root
.type
== bfd_link_hash_defweak
)
3999 && h
->root
.root
.u
.def
.section
)
4001 sec
= h
->root
.root
.u
.def
.section
;
4002 if (sec
->output_section
)
4003 symbol
= (h
->root
.root
.u
.def
.value
4004 + sec
->output_section
->vma
4005 + sec
->output_offset
);
4007 symbol
= h
->root
.root
.u
.def
.value
;
4009 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
4010 /* We allow relocations against undefined weak symbols, giving
4011 it the value zero, so that you can undefined weak functions
4012 and check to see if they exist by looking at their
4015 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
4016 && ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
4018 else if (strcmp (*namep
, SGI_COMPAT (input_bfd
)
4019 ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING") == 0)
4021 /* If this is a dynamic link, we should have created a
4022 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
4023 in in _bfd_mips_elf_create_dynamic_sections.
4024 Otherwise, we should define the symbol with a value of 0.
4025 FIXME: It should probably get into the symbol table
4027 BFD_ASSERT (! info
->shared
);
4028 BFD_ASSERT (bfd_get_section_by_name (abfd
, ".dynamic") == NULL
);
4031 else if (ELF_MIPS_IS_OPTIONAL (h
->root
.other
))
4033 /* This is an optional symbol - an Irix specific extension to the
4034 ELF spec. Ignore it for now.
4035 XXX - FIXME - there is more to the spec for OPTIONAL symbols
4036 than simply ignoring them, but we do not handle this for now.
4037 For information see the "64-bit ELF Object File Specification"
4038 which is available from here:
4039 http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf */
4044 if (! ((*info
->callbacks
->undefined_symbol
)
4045 (info
, h
->root
.root
.root
.string
, input_bfd
,
4046 input_section
, relocation
->r_offset
,
4047 (info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
)
4048 || ELF_ST_VISIBILITY (h
->root
.other
))))
4049 return bfd_reloc_undefined
;
4053 target_is_16_bit_code_p
= (h
->root
.other
== STO_MIPS16
);
4056 /* If this is a 32- or 64-bit call to a 16-bit function with a stub, we
4057 need to redirect the call to the stub, unless we're already *in*
4059 if (r_type
!= R_MIPS16_26
&& !info
->relocatable
4060 && ((h
!= NULL
&& h
->fn_stub
!= NULL
)
4061 || (local_p
&& elf_tdata (input_bfd
)->local_stubs
!= NULL
4062 && elf_tdata (input_bfd
)->local_stubs
[r_symndx
] != NULL
))
4063 && !mips_elf_stub_section_p (input_bfd
, input_section
))
4065 /* This is a 32- or 64-bit call to a 16-bit function. We should
4066 have already noticed that we were going to need the
4069 sec
= elf_tdata (input_bfd
)->local_stubs
[r_symndx
];
4072 BFD_ASSERT (h
->need_fn_stub
);
4076 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
4077 /* The target is 16-bit, but the stub isn't. */
4078 target_is_16_bit_code_p
= FALSE
;
4080 /* If this is a 16-bit call to a 32- or 64-bit function with a stub, we
4081 need to redirect the call to the stub. */
4082 else if (r_type
== R_MIPS16_26
&& !info
->relocatable
4084 && (h
->call_stub
!= NULL
|| h
->call_fp_stub
!= NULL
)
4085 && !target_is_16_bit_code_p
)
4087 /* If both call_stub and call_fp_stub are defined, we can figure
4088 out which one to use by seeing which one appears in the input
4090 if (h
->call_stub
!= NULL
&& h
->call_fp_stub
!= NULL
)
4095 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
4097 if (strncmp (bfd_get_section_name (input_bfd
, o
),
4098 CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
4100 sec
= h
->call_fp_stub
;
4107 else if (h
->call_stub
!= NULL
)
4110 sec
= h
->call_fp_stub
;
4112 BFD_ASSERT (sec
->size
> 0);
4113 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
4116 /* Calls from 16-bit code to 32-bit code and vice versa require the
4117 special jalx instruction. */
4118 *require_jalxp
= (!info
->relocatable
4119 && (((r_type
== R_MIPS16_26
) && !target_is_16_bit_code_p
)
4120 || ((r_type
== R_MIPS_26
) && target_is_16_bit_code_p
)));
4122 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
4123 local_sections
, TRUE
);
4125 /* If we haven't already determined the GOT offset, or the GP value,
4126 and we're going to need it, get it now. */
4129 case R_MIPS_GOT_PAGE
:
4130 case R_MIPS_GOT_OFST
:
4131 /* We need to decay to GOT_DISP/addend if the symbol doesn't
4133 local_p
= local_p
|| _bfd_elf_symbol_refs_local_p (&h
->root
, info
, 1);
4134 if (local_p
|| r_type
== R_MIPS_GOT_OFST
)
4140 case R_MIPS_GOT_DISP
:
4141 case R_MIPS_GOT_HI16
:
4142 case R_MIPS_CALL_HI16
:
4143 case R_MIPS_GOT_LO16
:
4144 case R_MIPS_CALL_LO16
:
4146 case R_MIPS_TLS_GOTTPREL
:
4147 case R_MIPS_TLS_LDM
:
4148 /* Find the index into the GOT where this value is located. */
4149 if (r_type
== R_MIPS_TLS_LDM
)
4151 g
= mips_elf_local_got_index (abfd
, input_bfd
, info
,
4152 sec
, 0, 0, NULL
, r_type
);
4154 return bfd_reloc_outofrange
;
4158 /* On VxWorks, CALL relocations should refer to the .got.plt
4159 entry, which is initialized to point at the PLT stub. */
4160 if (htab
->is_vxworks
4161 && (r_type
== R_MIPS_CALL_HI16
4162 || r_type
== R_MIPS_CALL_LO16
4163 || r_type
== R_MIPS_CALL16
))
4165 BFD_ASSERT (addend
== 0);
4166 BFD_ASSERT (h
->root
.needs_plt
);
4167 g
= mips_elf_gotplt_index (info
, &h
->root
);
4171 /* GOT_PAGE may take a non-zero addend, that is ignored in a
4172 GOT_PAGE relocation that decays to GOT_DISP because the
4173 symbol turns out to be global. The addend is then added
4175 BFD_ASSERT (addend
== 0 || r_type
== R_MIPS_GOT_PAGE
);
4176 g
= mips_elf_global_got_index (dynobj
, input_bfd
,
4177 &h
->root
, r_type
, info
);
4178 if (h
->tls_type
== GOT_NORMAL
4179 && (! elf_hash_table(info
)->dynamic_sections_created
4181 && (info
->symbolic
|| h
->root
.forced_local
)
4182 && h
->root
.def_regular
)))
4184 /* This is a static link or a -Bsymbolic link. The
4185 symbol is defined locally, or was forced to be local.
4186 We must initialize this entry in the GOT. */
4187 asection
*sgot
= mips_elf_got_section (dynobj
, FALSE
);
4188 MIPS_ELF_PUT_WORD (dynobj
, symbol
, sgot
->contents
+ g
);
4192 else if (!htab
->is_vxworks
4193 && (r_type
== R_MIPS_CALL16
|| (r_type
== R_MIPS_GOT16
)))
4194 /* The calculation below does not involve "g". */
4198 g
= mips_elf_local_got_index (abfd
, input_bfd
, info
, sec
,
4199 symbol
+ addend
, r_symndx
, h
, r_type
);
4201 return bfd_reloc_outofrange
;
4204 /* Convert GOT indices to actual offsets. */
4205 g
= mips_elf_got_offset_from_index (dynobj
, abfd
, input_bfd
, g
);
4210 case R_MIPS_GPREL16
:
4211 case R_MIPS_GPREL32
:
4212 case R_MIPS_LITERAL
:
4215 case R_MIPS16_GPREL
:
4216 gp0
= _bfd_get_gp_value (input_bfd
);
4217 gp
= _bfd_get_gp_value (abfd
);
4219 gp
+= mips_elf_adjust_gp (abfd
, mips_elf_got_info (dynobj
, NULL
),
4230 /* Relocations against the VxWorks __GOTT_BASE__ and __GOTT_INDEX__
4231 symbols are resolved by the loader. Add them to .rela.dyn. */
4232 if (h
!= NULL
&& is_gott_symbol (info
, &h
->root
))
4234 Elf_Internal_Rela outrel
;
4238 s
= mips_elf_rel_dyn_section (info
, FALSE
);
4239 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4241 outrel
.r_offset
= (input_section
->output_section
->vma
4242 + input_section
->output_offset
4243 + relocation
->r_offset
);
4244 outrel
.r_info
= ELF32_R_INFO (h
->root
.dynindx
, r_type
);
4245 outrel
.r_addend
= addend
;
4246 bfd_elf32_swap_reloca_out (abfd
, &outrel
, loc
);
4248 return bfd_reloc_ok
;
4251 /* Figure out what kind of relocation is being performed. */
4255 return bfd_reloc_continue
;
4258 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 16);
4259 overflowed_p
= mips_elf_overflow_p (value
, 16);
4266 || (!htab
->is_vxworks
4267 && htab
->root
.dynamic_sections_created
4269 && h
->root
.def_dynamic
4270 && !h
->root
.def_regular
))
4272 && (input_section
->flags
& SEC_ALLOC
) != 0)
4274 /* If we're creating a shared library, or this relocation is
4275 against a symbol in a shared library, then we can't know
4276 where the symbol will end up. So, we create a relocation
4277 record in the output, and leave the job up to the dynamic
4280 In VxWorks executables, references to external symbols
4281 are handled using copy relocs or PLT stubs, so there's
4282 no need to add a dynamic relocation here. */
4284 if (!mips_elf_create_dynamic_relocation (abfd
,
4292 return bfd_reloc_undefined
;
4296 if (r_type
!= R_MIPS_REL32
)
4297 value
= symbol
+ addend
;
4301 value
&= howto
->dst_mask
;
4305 value
= symbol
+ addend
- p
;
4306 value
&= howto
->dst_mask
;
4310 /* The calculation for R_MIPS16_26 is just the same as for an
4311 R_MIPS_26. It's only the storage of the relocated field into
4312 the output file that's different. That's handled in
4313 mips_elf_perform_relocation. So, we just fall through to the
4314 R_MIPS_26 case here. */
4317 value
= ((addend
| ((p
+ 4) & 0xf0000000)) + symbol
) >> 2;
4320 value
= (_bfd_mips_elf_sign_extend (addend
, 28) + symbol
) >> 2;
4321 if (h
->root
.root
.type
!= bfd_link_hash_undefweak
)
4322 overflowed_p
= (value
>> 26) != ((p
+ 4) >> 28);
4324 value
&= howto
->dst_mask
;
4327 case R_MIPS_TLS_DTPREL_HI16
:
4328 value
= (mips_elf_high (addend
+ symbol
- dtprel_base (info
))
4332 case R_MIPS_TLS_DTPREL_LO16
:
4333 value
= (symbol
+ addend
- dtprel_base (info
)) & howto
->dst_mask
;
4336 case R_MIPS_TLS_TPREL_HI16
:
4337 value
= (mips_elf_high (addend
+ symbol
- tprel_base (info
))
4341 case R_MIPS_TLS_TPREL_LO16
:
4342 value
= (symbol
+ addend
- tprel_base (info
)) & howto
->dst_mask
;
4349 value
= mips_elf_high (addend
+ symbol
);
4350 value
&= howto
->dst_mask
;
4354 /* For MIPS16 ABI code we generate this sequence
4355 0: li $v0,%hi(_gp_disp)
4356 4: addiupc $v1,%lo(_gp_disp)
4360 So the offsets of hi and lo relocs are the same, but the
4361 $pc is four higher than $t9 would be, so reduce
4362 both reloc addends by 4. */
4363 if (r_type
== R_MIPS16_HI16
)
4364 value
= mips_elf_high (addend
+ gp
- p
- 4);
4366 value
= mips_elf_high (addend
+ gp
- p
);
4367 overflowed_p
= mips_elf_overflow_p (value
, 16);
4374 value
= (symbol
+ addend
) & howto
->dst_mask
;
4377 /* See the comment for R_MIPS16_HI16 above for the reason
4378 for this conditional. */
4379 if (r_type
== R_MIPS16_LO16
)
4380 value
= addend
+ gp
- p
;
4382 value
= addend
+ gp
- p
+ 4;
4383 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
4384 for overflow. But, on, say, IRIX5, relocations against
4385 _gp_disp are normally generated from the .cpload
4386 pseudo-op. It generates code that normally looks like
4389 lui $gp,%hi(_gp_disp)
4390 addiu $gp,$gp,%lo(_gp_disp)
4393 Here $t9 holds the address of the function being called,
4394 as required by the MIPS ELF ABI. The R_MIPS_LO16
4395 relocation can easily overflow in this situation, but the
4396 R_MIPS_HI16 relocation will handle the overflow.
4397 Therefore, we consider this a bug in the MIPS ABI, and do
4398 not check for overflow here. */
4402 case R_MIPS_LITERAL
:
4403 /* Because we don't merge literal sections, we can handle this
4404 just like R_MIPS_GPREL16. In the long run, we should merge
4405 shared literals, and then we will need to additional work
4410 case R_MIPS16_GPREL
:
4411 /* The R_MIPS16_GPREL performs the same calculation as
4412 R_MIPS_GPREL16, but stores the relocated bits in a different
4413 order. We don't need to do anything special here; the
4414 differences are handled in mips_elf_perform_relocation. */
4415 case R_MIPS_GPREL16
:
4416 /* Only sign-extend the addend if it was extracted from the
4417 instruction. If the addend was separate, leave it alone,
4418 otherwise we may lose significant bits. */
4419 if (howto
->partial_inplace
)
4420 addend
= _bfd_mips_elf_sign_extend (addend
, 16);
4421 value
= symbol
+ addend
- gp
;
4422 /* If the symbol was local, any earlier relocatable links will
4423 have adjusted its addend with the gp offset, so compensate
4424 for that now. Don't do it for symbols forced local in this
4425 link, though, since they won't have had the gp offset applied
4429 overflowed_p
= mips_elf_overflow_p (value
, 16);
4434 /* VxWorks does not have separate local and global semantics for
4435 R_MIPS_GOT16; every relocation evaluates to "G". */
4436 if (!htab
->is_vxworks
&& local_p
)
4440 forced
= ! mips_elf_local_relocation_p (input_bfd
, relocation
,
4441 local_sections
, FALSE
);
4442 value
= mips_elf_got16_entry (abfd
, input_bfd
, info
, sec
,
4443 symbol
+ addend
, forced
);
4444 if (value
== MINUS_ONE
)
4445 return bfd_reloc_outofrange
;
4447 = mips_elf_got_offset_from_index (dynobj
, abfd
, input_bfd
, value
);
4448 overflowed_p
= mips_elf_overflow_p (value
, 16);
4455 case R_MIPS_TLS_GOTTPREL
:
4456 case R_MIPS_TLS_LDM
:
4457 case R_MIPS_GOT_DISP
:
4460 overflowed_p
= mips_elf_overflow_p (value
, 16);
4463 case R_MIPS_GPREL32
:
4464 value
= (addend
+ symbol
+ gp0
- gp
);
4466 value
&= howto
->dst_mask
;
4470 case R_MIPS_GNU_REL16_S2
:
4471 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 18) - p
;
4472 overflowed_p
= mips_elf_overflow_p (value
, 18);
4473 value
= (value
>> 2) & howto
->dst_mask
;
4476 case R_MIPS_GOT_HI16
:
4477 case R_MIPS_CALL_HI16
:
4478 /* We're allowed to handle these two relocations identically.
4479 The dynamic linker is allowed to handle the CALL relocations
4480 differently by creating a lazy evaluation stub. */
4482 value
= mips_elf_high (value
);
4483 value
&= howto
->dst_mask
;
4486 case R_MIPS_GOT_LO16
:
4487 case R_MIPS_CALL_LO16
:
4488 value
= g
& howto
->dst_mask
;
4491 case R_MIPS_GOT_PAGE
:
4492 /* GOT_PAGE relocations that reference non-local symbols decay
4493 to GOT_DISP. The corresponding GOT_OFST relocation decays to
4497 value
= mips_elf_got_page (abfd
, input_bfd
, info
, sec
,
4498 symbol
+ addend
, NULL
);
4499 if (value
== MINUS_ONE
)
4500 return bfd_reloc_outofrange
;
4501 value
= mips_elf_got_offset_from_index (dynobj
, abfd
, input_bfd
, value
);
4502 overflowed_p
= mips_elf_overflow_p (value
, 16);
4505 case R_MIPS_GOT_OFST
:
4507 mips_elf_got_page (abfd
, input_bfd
, info
, sec
,
4508 symbol
+ addend
, &value
);
4511 overflowed_p
= mips_elf_overflow_p (value
, 16);
4515 value
= symbol
- addend
;
4516 value
&= howto
->dst_mask
;
4520 value
= mips_elf_higher (addend
+ symbol
);
4521 value
&= howto
->dst_mask
;
4524 case R_MIPS_HIGHEST
:
4525 value
= mips_elf_highest (addend
+ symbol
);
4526 value
&= howto
->dst_mask
;
4529 case R_MIPS_SCN_DISP
:
4530 value
= symbol
+ addend
- sec
->output_offset
;
4531 value
&= howto
->dst_mask
;
4535 /* This relocation is only a hint. In some cases, we optimize
4536 it into a bal instruction. But we don't try to optimize
4537 branches to the PLT; that will wind up wasting time. */
4538 if (h
!= NULL
&& h
->root
.plt
.offset
!= (bfd_vma
) -1)
4539 return bfd_reloc_continue
;
4540 value
= symbol
+ addend
;
4544 case R_MIPS_GNU_VTINHERIT
:
4545 case R_MIPS_GNU_VTENTRY
:
4546 /* We don't do anything with these at present. */
4547 return bfd_reloc_continue
;
4550 /* An unrecognized relocation type. */
4551 return bfd_reloc_notsupported
;
4554 /* Store the VALUE for our caller. */
4556 return overflowed_p
? bfd_reloc_overflow
: bfd_reloc_ok
;
4559 /* Obtain the field relocated by RELOCATION. */
4562 mips_elf_obtain_contents (reloc_howto_type
*howto
,
4563 const Elf_Internal_Rela
*relocation
,
4564 bfd
*input_bfd
, bfd_byte
*contents
)
4567 bfd_byte
*location
= contents
+ relocation
->r_offset
;
4569 /* Obtain the bytes. */
4570 x
= bfd_get ((8 * bfd_get_reloc_size (howto
)), input_bfd
, location
);
4575 /* It has been determined that the result of the RELOCATION is the
4576 VALUE. Use HOWTO to place VALUE into the output file at the
4577 appropriate position. The SECTION is the section to which the
4578 relocation applies. If REQUIRE_JALX is TRUE, then the opcode used
4579 for the relocation must be either JAL or JALX, and it is
4580 unconditionally converted to JALX.
4582 Returns FALSE if anything goes wrong. */
4585 mips_elf_perform_relocation (struct bfd_link_info
*info
,
4586 reloc_howto_type
*howto
,
4587 const Elf_Internal_Rela
*relocation
,
4588 bfd_vma value
, bfd
*input_bfd
,
4589 asection
*input_section
, bfd_byte
*contents
,
4590 bfd_boolean require_jalx
)
4594 int r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
4596 /* Figure out where the relocation is occurring. */
4597 location
= contents
+ relocation
->r_offset
;
4599 _bfd_mips16_elf_reloc_unshuffle (input_bfd
, r_type
, FALSE
, location
);
4601 /* Obtain the current value. */
4602 x
= mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
);
4604 /* Clear the field we are setting. */
4605 x
&= ~howto
->dst_mask
;
4607 /* Set the field. */
4608 x
|= (value
& howto
->dst_mask
);
4610 /* If required, turn JAL into JALX. */
4614 bfd_vma opcode
= x
>> 26;
4615 bfd_vma jalx_opcode
;
4617 /* Check to see if the opcode is already JAL or JALX. */
4618 if (r_type
== R_MIPS16_26
)
4620 ok
= ((opcode
== 0x6) || (opcode
== 0x7));
4625 ok
= ((opcode
== 0x3) || (opcode
== 0x1d));
4629 /* If the opcode is not JAL or JALX, there's a problem. */
4632 (*_bfd_error_handler
)
4633 (_("%B: %A+0x%lx: jump to stub routine which is not jal"),
4636 (unsigned long) relocation
->r_offset
);
4637 bfd_set_error (bfd_error_bad_value
);
4641 /* Make this the JALX opcode. */
4642 x
= (x
& ~(0x3f << 26)) | (jalx_opcode
<< 26);
4645 /* On the RM9000, bal is faster than jal, because bal uses branch
4646 prediction hardware. If we are linking for the RM9000, and we
4647 see jal, and bal fits, use it instead. Note that this
4648 transformation should be safe for all architectures. */
4649 if (bfd_get_mach (input_bfd
) == bfd_mach_mips9000
4650 && !info
->relocatable
4652 && ((r_type
== R_MIPS_26
&& (x
>> 26) == 0x3) /* jal addr */
4653 || (r_type
== R_MIPS_JALR
&& x
== 0x0320f809))) /* jalr t9 */
4659 addr
= (input_section
->output_section
->vma
4660 + input_section
->output_offset
4661 + relocation
->r_offset
4663 if (r_type
== R_MIPS_26
)
4664 dest
= (value
<< 2) | ((addr
>> 28) << 28);
4668 if (off
<= 0x1ffff && off
>= -0x20000)
4669 x
= 0x04110000 | (((bfd_vma
) off
>> 2) & 0xffff); /* bal addr */
4672 /* Put the value into the output. */
4673 bfd_put (8 * bfd_get_reloc_size (howto
), input_bfd
, x
, location
);
4675 _bfd_mips16_elf_reloc_shuffle(input_bfd
, r_type
, !info
->relocatable
,
4681 /* Returns TRUE if SECTION is a MIPS16 stub section. */
4684 mips_elf_stub_section_p (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*section
)
4686 const char *name
= bfd_get_section_name (abfd
, section
);
4688 return (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0
4689 || strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
4690 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0);
4693 /* Add room for N relocations to the .rel(a).dyn section in ABFD. */
4696 mips_elf_allocate_dynamic_relocations (bfd
*abfd
, struct bfd_link_info
*info
,
4700 struct mips_elf_link_hash_table
*htab
;
4702 htab
= mips_elf_hash_table (info
);
4703 s
= mips_elf_rel_dyn_section (info
, FALSE
);
4704 BFD_ASSERT (s
!= NULL
);
4706 if (htab
->is_vxworks
)
4707 s
->size
+= n
* MIPS_ELF_RELA_SIZE (abfd
);
4712 /* Make room for a null element. */
4713 s
->size
+= MIPS_ELF_REL_SIZE (abfd
);
4716 s
->size
+= n
* MIPS_ELF_REL_SIZE (abfd
);
4720 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
4721 is the original relocation, which is now being transformed into a
4722 dynamic relocation. The ADDENDP is adjusted if necessary; the
4723 caller should store the result in place of the original addend. */
4726 mips_elf_create_dynamic_relocation (bfd
*output_bfd
,
4727 struct bfd_link_info
*info
,
4728 const Elf_Internal_Rela
*rel
,
4729 struct mips_elf_link_hash_entry
*h
,
4730 asection
*sec
, bfd_vma symbol
,
4731 bfd_vma
*addendp
, asection
*input_section
)
4733 Elf_Internal_Rela outrel
[3];
4738 bfd_boolean defined_p
;
4739 struct mips_elf_link_hash_table
*htab
;
4741 htab
= mips_elf_hash_table (info
);
4742 r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
4743 dynobj
= elf_hash_table (info
)->dynobj
;
4744 sreloc
= mips_elf_rel_dyn_section (info
, FALSE
);
4745 BFD_ASSERT (sreloc
!= NULL
);
4746 BFD_ASSERT (sreloc
->contents
!= NULL
);
4747 BFD_ASSERT (sreloc
->reloc_count
* MIPS_ELF_REL_SIZE (output_bfd
)
4750 outrel
[0].r_offset
=
4751 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[0].r_offset
);
4752 outrel
[1].r_offset
=
4753 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[1].r_offset
);
4754 outrel
[2].r_offset
=
4755 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[2].r_offset
);
4757 if (outrel
[0].r_offset
== MINUS_ONE
)
4758 /* The relocation field has been deleted. */
4761 if (outrel
[0].r_offset
== MINUS_TWO
)
4763 /* The relocation field has been converted into a relative value of
4764 some sort. Functions like _bfd_elf_write_section_eh_frame expect
4765 the field to be fully relocated, so add in the symbol's value. */
4770 /* We must now calculate the dynamic symbol table index to use
4771 in the relocation. */
4773 && (!h
->root
.def_regular
4774 || (info
->shared
&& !info
->symbolic
&& !h
->root
.forced_local
)))
4776 indx
= h
->root
.dynindx
;
4777 if (SGI_COMPAT (output_bfd
))
4778 defined_p
= h
->root
.def_regular
;
4780 /* ??? glibc's ld.so just adds the final GOT entry to the
4781 relocation field. It therefore treats relocs against
4782 defined symbols in the same way as relocs against
4783 undefined symbols. */
4788 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
4790 else if (sec
== NULL
|| sec
->owner
== NULL
)
4792 bfd_set_error (bfd_error_bad_value
);
4797 indx
= elf_section_data (sec
->output_section
)->dynindx
;
4802 /* Instead of generating a relocation using the section
4803 symbol, we may as well make it a fully relative
4804 relocation. We want to avoid generating relocations to
4805 local symbols because we used to generate them
4806 incorrectly, without adding the original symbol value,
4807 which is mandated by the ABI for section symbols. In
4808 order to give dynamic loaders and applications time to
4809 phase out the incorrect use, we refrain from emitting
4810 section-relative relocations. It's not like they're
4811 useful, after all. This should be a bit more efficient
4813 /* ??? Although this behavior is compatible with glibc's ld.so,
4814 the ABI says that relocations against STN_UNDEF should have
4815 a symbol value of 0. Irix rld honors this, so relocations
4816 against STN_UNDEF have no effect. */
4817 if (!SGI_COMPAT (output_bfd
))
4822 /* If the relocation was previously an absolute relocation and
4823 this symbol will not be referred to by the relocation, we must
4824 adjust it by the value we give it in the dynamic symbol table.
4825 Otherwise leave the job up to the dynamic linker. */
4826 if (defined_p
&& r_type
!= R_MIPS_REL32
)
4829 if (htab
->is_vxworks
)
4830 /* VxWorks uses non-relative relocations for this. */
4831 outrel
[0].r_info
= ELF32_R_INFO (indx
, R_MIPS_32
);
4833 /* The relocation is always an REL32 relocation because we don't
4834 know where the shared library will wind up at load-time. */
4835 outrel
[0].r_info
= ELF_R_INFO (output_bfd
, (unsigned long) indx
,
4838 /* For strict adherence to the ABI specification, we should
4839 generate a R_MIPS_64 relocation record by itself before the
4840 _REL32/_64 record as well, such that the addend is read in as
4841 a 64-bit value (REL32 is a 32-bit relocation, after all).
4842 However, since none of the existing ELF64 MIPS dynamic
4843 loaders seems to care, we don't waste space with these
4844 artificial relocations. If this turns out to not be true,
4845 mips_elf_allocate_dynamic_relocation() should be tweaked so
4846 as to make room for a pair of dynamic relocations per
4847 invocation if ABI_64_P, and here we should generate an
4848 additional relocation record with R_MIPS_64 by itself for a
4849 NULL symbol before this relocation record. */
4850 outrel
[1].r_info
= ELF_R_INFO (output_bfd
, 0,
4851 ABI_64_P (output_bfd
)
4854 outrel
[2].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_NONE
);
4856 /* Adjust the output offset of the relocation to reference the
4857 correct location in the output file. */
4858 outrel
[0].r_offset
+= (input_section
->output_section
->vma
4859 + input_section
->output_offset
);
4860 outrel
[1].r_offset
+= (input_section
->output_section
->vma
4861 + input_section
->output_offset
);
4862 outrel
[2].r_offset
+= (input_section
->output_section
->vma
4863 + input_section
->output_offset
);
4865 /* Put the relocation back out. We have to use the special
4866 relocation outputter in the 64-bit case since the 64-bit
4867 relocation format is non-standard. */
4868 if (ABI_64_P (output_bfd
))
4870 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
4871 (output_bfd
, &outrel
[0],
4873 + sreloc
->reloc_count
* sizeof (Elf64_Mips_External_Rel
)));
4875 else if (htab
->is_vxworks
)
4877 /* VxWorks uses RELA rather than REL dynamic relocations. */
4878 outrel
[0].r_addend
= *addendp
;
4879 bfd_elf32_swap_reloca_out
4880 (output_bfd
, &outrel
[0],
4882 + sreloc
->reloc_count
* sizeof (Elf32_External_Rela
)));
4885 bfd_elf32_swap_reloc_out
4886 (output_bfd
, &outrel
[0],
4887 (sreloc
->contents
+ sreloc
->reloc_count
* sizeof (Elf32_External_Rel
)));
4889 /* We've now added another relocation. */
4890 ++sreloc
->reloc_count
;
4892 /* Make sure the output section is writable. The dynamic linker
4893 will be writing to it. */
4894 elf_section_data (input_section
->output_section
)->this_hdr
.sh_flags
4897 /* On IRIX5, make an entry of compact relocation info. */
4898 if (IRIX_COMPAT (output_bfd
) == ict_irix5
)
4900 asection
*scpt
= bfd_get_section_by_name (dynobj
, ".compact_rel");
4905 Elf32_crinfo cptrel
;
4907 mips_elf_set_cr_format (cptrel
, CRF_MIPS_LONG
);
4908 cptrel
.vaddr
= (rel
->r_offset
4909 + input_section
->output_section
->vma
4910 + input_section
->output_offset
);
4911 if (r_type
== R_MIPS_REL32
)
4912 mips_elf_set_cr_type (cptrel
, CRT_MIPS_REL32
);
4914 mips_elf_set_cr_type (cptrel
, CRT_MIPS_WORD
);
4915 mips_elf_set_cr_dist2to (cptrel
, 0);
4916 cptrel
.konst
= *addendp
;
4918 cr
= (scpt
->contents
4919 + sizeof (Elf32_External_compact_rel
));
4920 mips_elf_set_cr_relvaddr (cptrel
, 0);
4921 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
4922 ((Elf32_External_crinfo
*) cr
4923 + scpt
->reloc_count
));
4924 ++scpt
->reloc_count
;
4928 /* If we've written this relocation for a readonly section,
4929 we need to set DF_TEXTREL again, so that we do not delete the
4931 if (MIPS_ELF_READONLY_SECTION (input_section
))
4932 info
->flags
|= DF_TEXTREL
;
4937 /* Return the MACH for a MIPS e_flags value. */
4940 _bfd_elf_mips_mach (flagword flags
)
4942 switch (flags
& EF_MIPS_MACH
)
4944 case E_MIPS_MACH_3900
:
4945 return bfd_mach_mips3900
;
4947 case E_MIPS_MACH_4010
:
4948 return bfd_mach_mips4010
;
4950 case E_MIPS_MACH_4100
:
4951 return bfd_mach_mips4100
;
4953 case E_MIPS_MACH_4111
:
4954 return bfd_mach_mips4111
;
4956 case E_MIPS_MACH_4120
:
4957 return bfd_mach_mips4120
;
4959 case E_MIPS_MACH_4650
:
4960 return bfd_mach_mips4650
;
4962 case E_MIPS_MACH_5400
:
4963 return bfd_mach_mips5400
;
4965 case E_MIPS_MACH_5500
:
4966 return bfd_mach_mips5500
;
4968 case E_MIPS_MACH_9000
:
4969 return bfd_mach_mips9000
;
4971 case E_MIPS_MACH_SB1
:
4972 return bfd_mach_mips_sb1
;
4975 switch (flags
& EF_MIPS_ARCH
)
4979 return bfd_mach_mips3000
;
4982 return bfd_mach_mips6000
;
4985 return bfd_mach_mips4000
;
4988 return bfd_mach_mips8000
;
4991 return bfd_mach_mips5
;
4993 case E_MIPS_ARCH_32
:
4994 return bfd_mach_mipsisa32
;
4996 case E_MIPS_ARCH_64
:
4997 return bfd_mach_mipsisa64
;
4999 case E_MIPS_ARCH_32R2
:
5000 return bfd_mach_mipsisa32r2
;
5002 case E_MIPS_ARCH_64R2
:
5003 return bfd_mach_mipsisa64r2
;
5010 /* Return printable name for ABI. */
5012 static INLINE
char *
5013 elf_mips_abi_name (bfd
*abfd
)
5017 flags
= elf_elfheader (abfd
)->e_flags
;
5018 switch (flags
& EF_MIPS_ABI
)
5021 if (ABI_N32_P (abfd
))
5023 else if (ABI_64_P (abfd
))
5027 case E_MIPS_ABI_O32
:
5029 case E_MIPS_ABI_O64
:
5031 case E_MIPS_ABI_EABI32
:
5033 case E_MIPS_ABI_EABI64
:
5036 return "unknown abi";
5040 /* MIPS ELF uses two common sections. One is the usual one, and the
5041 other is for small objects. All the small objects are kept
5042 together, and then referenced via the gp pointer, which yields
5043 faster assembler code. This is what we use for the small common
5044 section. This approach is copied from ecoff.c. */
5045 static asection mips_elf_scom_section
;
5046 static asymbol mips_elf_scom_symbol
;
5047 static asymbol
*mips_elf_scom_symbol_ptr
;
5049 /* MIPS ELF also uses an acommon section, which represents an
5050 allocated common symbol which may be overridden by a
5051 definition in a shared library. */
5052 static asection mips_elf_acom_section
;
5053 static asymbol mips_elf_acom_symbol
;
5054 static asymbol
*mips_elf_acom_symbol_ptr
;
5056 /* Handle the special MIPS section numbers that a symbol may use.
5057 This is used for both the 32-bit and the 64-bit ABI. */
5060 _bfd_mips_elf_symbol_processing (bfd
*abfd
, asymbol
*asym
)
5062 elf_symbol_type
*elfsym
;
5064 elfsym
= (elf_symbol_type
*) asym
;
5065 switch (elfsym
->internal_elf_sym
.st_shndx
)
5067 case SHN_MIPS_ACOMMON
:
5068 /* This section is used in a dynamically linked executable file.
5069 It is an allocated common section. The dynamic linker can
5070 either resolve these symbols to something in a shared
5071 library, or it can just leave them here. For our purposes,
5072 we can consider these symbols to be in a new section. */
5073 if (mips_elf_acom_section
.name
== NULL
)
5075 /* Initialize the acommon section. */
5076 mips_elf_acom_section
.name
= ".acommon";
5077 mips_elf_acom_section
.flags
= SEC_ALLOC
;
5078 mips_elf_acom_section
.output_section
= &mips_elf_acom_section
;
5079 mips_elf_acom_section
.symbol
= &mips_elf_acom_symbol
;
5080 mips_elf_acom_section
.symbol_ptr_ptr
= &mips_elf_acom_symbol_ptr
;
5081 mips_elf_acom_symbol
.name
= ".acommon";
5082 mips_elf_acom_symbol
.flags
= BSF_SECTION_SYM
;
5083 mips_elf_acom_symbol
.section
= &mips_elf_acom_section
;
5084 mips_elf_acom_symbol_ptr
= &mips_elf_acom_symbol
;
5086 asym
->section
= &mips_elf_acom_section
;
5090 /* Common symbols less than the GP size are automatically
5091 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
5092 if (asym
->value
> elf_gp_size (abfd
)
5093 || IRIX_COMPAT (abfd
) == ict_irix6
)
5096 case SHN_MIPS_SCOMMON
:
5097 if (mips_elf_scom_section
.name
== NULL
)
5099 /* Initialize the small common section. */
5100 mips_elf_scom_section
.name
= ".scommon";
5101 mips_elf_scom_section
.flags
= SEC_IS_COMMON
;
5102 mips_elf_scom_section
.output_section
= &mips_elf_scom_section
;
5103 mips_elf_scom_section
.symbol
= &mips_elf_scom_symbol
;
5104 mips_elf_scom_section
.symbol_ptr_ptr
= &mips_elf_scom_symbol_ptr
;
5105 mips_elf_scom_symbol
.name
= ".scommon";
5106 mips_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
5107 mips_elf_scom_symbol
.section
= &mips_elf_scom_section
;
5108 mips_elf_scom_symbol_ptr
= &mips_elf_scom_symbol
;
5110 asym
->section
= &mips_elf_scom_section
;
5111 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
5114 case SHN_MIPS_SUNDEFINED
:
5115 asym
->section
= bfd_und_section_ptr
;
5120 asection
*section
= bfd_get_section_by_name (abfd
, ".text");
5122 BFD_ASSERT (SGI_COMPAT (abfd
));
5123 if (section
!= NULL
)
5125 asym
->section
= section
;
5126 /* MIPS_TEXT is a bit special, the address is not an offset
5127 to the base of the .text section. So substract the section
5128 base address to make it an offset. */
5129 asym
->value
-= section
->vma
;
5136 asection
*section
= bfd_get_section_by_name (abfd
, ".data");
5138 BFD_ASSERT (SGI_COMPAT (abfd
));
5139 if (section
!= NULL
)
5141 asym
->section
= section
;
5142 /* MIPS_DATA is a bit special, the address is not an offset
5143 to the base of the .data section. So substract the section
5144 base address to make it an offset. */
5145 asym
->value
-= section
->vma
;
5152 /* Implement elf_backend_eh_frame_address_size. This differs from
5153 the default in the way it handles EABI64.
5155 EABI64 was originally specified as an LP64 ABI, and that is what
5156 -mabi=eabi normally gives on a 64-bit target. However, gcc has
5157 historically accepted the combination of -mabi=eabi and -mlong32,
5158 and this ILP32 variation has become semi-official over time.
5159 Both forms use elf32 and have pointer-sized FDE addresses.
5161 If an EABI object was generated by GCC 4.0 or above, it will have
5162 an empty .gcc_compiled_longXX section, where XX is the size of longs
5163 in bits. Unfortunately, ILP32 objects generated by earlier compilers
5164 have no special marking to distinguish them from LP64 objects.
5166 We don't want users of the official LP64 ABI to be punished for the
5167 existence of the ILP32 variant, but at the same time, we don't want
5168 to mistakenly interpret pre-4.0 ILP32 objects as being LP64 objects.
5169 We therefore take the following approach:
5171 - If ABFD contains a .gcc_compiled_longXX section, use it to
5172 determine the pointer size.
5174 - Otherwise check the type of the first relocation. Assume that
5175 the LP64 ABI is being used if the relocation is of type R_MIPS_64.
5179 The second check is enough to detect LP64 objects generated by pre-4.0
5180 compilers because, in the kind of output generated by those compilers,
5181 the first relocation will be associated with either a CIE personality
5182 routine or an FDE start address. Furthermore, the compilers never
5183 used a special (non-pointer) encoding for this ABI.
5185 Checking the relocation type should also be safe because there is no
5186 reason to use R_MIPS_64 in an ILP32 object. Pre-4.0 compilers never
5190 _bfd_mips_elf_eh_frame_address_size (bfd
*abfd
, asection
*sec
)
5192 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
5194 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
5196 bfd_boolean long32_p
, long64_p
;
5198 long32_p
= bfd_get_section_by_name (abfd
, ".gcc_compiled_long32") != 0;
5199 long64_p
= bfd_get_section_by_name (abfd
, ".gcc_compiled_long64") != 0;
5200 if (long32_p
&& long64_p
)
5207 if (sec
->reloc_count
> 0
5208 && elf_section_data (sec
)->relocs
!= NULL
5209 && (ELF32_R_TYPE (elf_section_data (sec
)->relocs
[0].r_info
)
5218 /* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
5219 relocations against two unnamed section symbols to resolve to the
5220 same address. For example, if we have code like:
5222 lw $4,%got_disp(.data)($gp)
5223 lw $25,%got_disp(.text)($gp)
5226 then the linker will resolve both relocations to .data and the program
5227 will jump there rather than to .text.
5229 We can work around this problem by giving names to local section symbols.
5230 This is also what the MIPSpro tools do. */
5233 _bfd_mips_elf_name_local_section_symbols (bfd
*abfd
)
5235 return SGI_COMPAT (abfd
);
5238 /* Work over a section just before writing it out. This routine is
5239 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
5240 sections that need the SHF_MIPS_GPREL flag by name; there has to be
5244 _bfd_mips_elf_section_processing (bfd
*abfd
, Elf_Internal_Shdr
*hdr
)
5246 if (hdr
->sh_type
== SHT_MIPS_REGINFO
5247 && hdr
->sh_size
> 0)
5251 BFD_ASSERT (hdr
->sh_size
== sizeof (Elf32_External_RegInfo
));
5252 BFD_ASSERT (hdr
->contents
== NULL
);
5255 hdr
->sh_offset
+ sizeof (Elf32_External_RegInfo
) - 4,
5258 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
5259 if (bfd_bwrite (buf
, 4, abfd
) != 4)
5263 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
5264 && hdr
->bfd_section
!= NULL
5265 && mips_elf_section_data (hdr
->bfd_section
) != NULL
5266 && mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
!= NULL
)
5268 bfd_byte
*contents
, *l
, *lend
;
5270 /* We stored the section contents in the tdata field in the
5271 set_section_contents routine. We save the section contents
5272 so that we don't have to read them again.
5273 At this point we know that elf_gp is set, so we can look
5274 through the section contents to see if there is an
5275 ODK_REGINFO structure. */
5277 contents
= mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
;
5279 lend
= contents
+ hdr
->sh_size
;
5280 while (l
+ sizeof (Elf_External_Options
) <= lend
)
5282 Elf_Internal_Options intopt
;
5284 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
5286 if (intopt
.size
< sizeof (Elf_External_Options
))
5288 (*_bfd_error_handler
)
5289 (_("%B: Warning: bad `%s' option size %u smaller than its header"),
5290 abfd
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
), intopt
.size
);
5293 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
5300 + sizeof (Elf_External_Options
)
5301 + (sizeof (Elf64_External_RegInfo
) - 8)),
5304 H_PUT_64 (abfd
, elf_gp (abfd
), buf
);
5305 if (bfd_bwrite (buf
, 8, abfd
) != 8)
5308 else if (intopt
.kind
== ODK_REGINFO
)
5315 + sizeof (Elf_External_Options
)
5316 + (sizeof (Elf32_External_RegInfo
) - 4)),
5319 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
5320 if (bfd_bwrite (buf
, 4, abfd
) != 4)
5327 if (hdr
->bfd_section
!= NULL
)
5329 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
5331 if (strcmp (name
, ".sdata") == 0
5332 || strcmp (name
, ".lit8") == 0
5333 || strcmp (name
, ".lit4") == 0)
5335 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
5336 hdr
->sh_type
= SHT_PROGBITS
;
5338 else if (strcmp (name
, ".sbss") == 0)
5340 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
5341 hdr
->sh_type
= SHT_NOBITS
;
5343 else if (strcmp (name
, ".srdata") == 0)
5345 hdr
->sh_flags
|= SHF_ALLOC
| SHF_MIPS_GPREL
;
5346 hdr
->sh_type
= SHT_PROGBITS
;
5348 else if (strcmp (name
, ".compact_rel") == 0)
5351 hdr
->sh_type
= SHT_PROGBITS
;
5353 else if (strcmp (name
, ".rtproc") == 0)
5355 if (hdr
->sh_addralign
!= 0 && hdr
->sh_entsize
== 0)
5357 unsigned int adjust
;
5359 adjust
= hdr
->sh_size
% hdr
->sh_addralign
;
5361 hdr
->sh_size
+= hdr
->sh_addralign
- adjust
;
5369 /* Handle a MIPS specific section when reading an object file. This
5370 is called when elfcode.h finds a section with an unknown type.
5371 This routine supports both the 32-bit and 64-bit ELF ABI.
5373 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
5377 _bfd_mips_elf_section_from_shdr (bfd
*abfd
,
5378 Elf_Internal_Shdr
*hdr
,
5384 /* There ought to be a place to keep ELF backend specific flags, but
5385 at the moment there isn't one. We just keep track of the
5386 sections by their name, instead. Fortunately, the ABI gives
5387 suggested names for all the MIPS specific sections, so we will
5388 probably get away with this. */
5389 switch (hdr
->sh_type
)
5391 case SHT_MIPS_LIBLIST
:
5392 if (strcmp (name
, ".liblist") != 0)
5396 if (strcmp (name
, ".msym") != 0)
5399 case SHT_MIPS_CONFLICT
:
5400 if (strcmp (name
, ".conflict") != 0)
5403 case SHT_MIPS_GPTAB
:
5404 if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) != 0)
5407 case SHT_MIPS_UCODE
:
5408 if (strcmp (name
, ".ucode") != 0)
5411 case SHT_MIPS_DEBUG
:
5412 if (strcmp (name
, ".mdebug") != 0)
5414 flags
= SEC_DEBUGGING
;
5416 case SHT_MIPS_REGINFO
:
5417 if (strcmp (name
, ".reginfo") != 0
5418 || hdr
->sh_size
!= sizeof (Elf32_External_RegInfo
))
5420 flags
= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_SIZE
);
5422 case SHT_MIPS_IFACE
:
5423 if (strcmp (name
, ".MIPS.interfaces") != 0)
5426 case SHT_MIPS_CONTENT
:
5427 if (strncmp (name
, ".MIPS.content", sizeof ".MIPS.content" - 1) != 0)
5430 case SHT_MIPS_OPTIONS
:
5431 if (!MIPS_ELF_OPTIONS_SECTION_NAME_P (name
))
5434 case SHT_MIPS_DWARF
:
5435 if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) != 0)
5438 case SHT_MIPS_SYMBOL_LIB
:
5439 if (strcmp (name
, ".MIPS.symlib") != 0)
5442 case SHT_MIPS_EVENTS
:
5443 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) != 0
5444 && strncmp (name
, ".MIPS.post_rel",
5445 sizeof ".MIPS.post_rel" - 1) != 0)
5452 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
5457 if (! bfd_set_section_flags (abfd
, hdr
->bfd_section
,
5458 (bfd_get_section_flags (abfd
,
5464 /* FIXME: We should record sh_info for a .gptab section. */
5466 /* For a .reginfo section, set the gp value in the tdata information
5467 from the contents of this section. We need the gp value while
5468 processing relocs, so we just get it now. The .reginfo section
5469 is not used in the 64-bit MIPS ELF ABI. */
5470 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
5472 Elf32_External_RegInfo ext
;
5475 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
,
5476 &ext
, 0, sizeof ext
))
5478 bfd_mips_elf32_swap_reginfo_in (abfd
, &ext
, &s
);
5479 elf_gp (abfd
) = s
.ri_gp_value
;
5482 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
5483 set the gp value based on what we find. We may see both
5484 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
5485 they should agree. */
5486 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
)
5488 bfd_byte
*contents
, *l
, *lend
;
5490 contents
= bfd_malloc (hdr
->sh_size
);
5491 if (contents
== NULL
)
5493 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
,
5500 lend
= contents
+ hdr
->sh_size
;
5501 while (l
+ sizeof (Elf_External_Options
) <= lend
)
5503 Elf_Internal_Options intopt
;
5505 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
5507 if (intopt
.size
< sizeof (Elf_External_Options
))
5509 (*_bfd_error_handler
)
5510 (_("%B: Warning: bad `%s' option size %u smaller than its header"),
5511 abfd
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
), intopt
.size
);
5514 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
5516 Elf64_Internal_RegInfo intreg
;
5518 bfd_mips_elf64_swap_reginfo_in
5520 ((Elf64_External_RegInfo
*)
5521 (l
+ sizeof (Elf_External_Options
))),
5523 elf_gp (abfd
) = intreg
.ri_gp_value
;
5525 else if (intopt
.kind
== ODK_REGINFO
)
5527 Elf32_RegInfo intreg
;
5529 bfd_mips_elf32_swap_reginfo_in
5531 ((Elf32_External_RegInfo
*)
5532 (l
+ sizeof (Elf_External_Options
))),
5534 elf_gp (abfd
) = intreg
.ri_gp_value
;
5544 /* Set the correct type for a MIPS ELF section. We do this by the
5545 section name, which is a hack, but ought to work. This routine is
5546 used by both the 32-bit and the 64-bit ABI. */
5549 _bfd_mips_elf_fake_sections (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*sec
)
5551 register const char *name
;
5552 unsigned int sh_type
;
5554 name
= bfd_get_section_name (abfd
, sec
);
5555 sh_type
= hdr
->sh_type
;
5557 if (strcmp (name
, ".liblist") == 0)
5559 hdr
->sh_type
= SHT_MIPS_LIBLIST
;
5560 hdr
->sh_info
= sec
->size
/ sizeof (Elf32_Lib
);
5561 /* The sh_link field is set in final_write_processing. */
5563 else if (strcmp (name
, ".conflict") == 0)
5564 hdr
->sh_type
= SHT_MIPS_CONFLICT
;
5565 else if (strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0)
5567 hdr
->sh_type
= SHT_MIPS_GPTAB
;
5568 hdr
->sh_entsize
= sizeof (Elf32_External_gptab
);
5569 /* The sh_info field is set in final_write_processing. */
5571 else if (strcmp (name
, ".ucode") == 0)
5572 hdr
->sh_type
= SHT_MIPS_UCODE
;
5573 else if (strcmp (name
, ".mdebug") == 0)
5575 hdr
->sh_type
= SHT_MIPS_DEBUG
;
5576 /* In a shared object on IRIX 5.3, the .mdebug section has an
5577 entsize of 0. FIXME: Does this matter? */
5578 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
5579 hdr
->sh_entsize
= 0;
5581 hdr
->sh_entsize
= 1;
5583 else if (strcmp (name
, ".reginfo") == 0)
5585 hdr
->sh_type
= SHT_MIPS_REGINFO
;
5586 /* In a shared object on IRIX 5.3, the .reginfo section has an
5587 entsize of 0x18. FIXME: Does this matter? */
5588 if (SGI_COMPAT (abfd
))
5590 if ((abfd
->flags
& DYNAMIC
) != 0)
5591 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
5593 hdr
->sh_entsize
= 1;
5596 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
5598 else if (SGI_COMPAT (abfd
)
5599 && (strcmp (name
, ".hash") == 0
5600 || strcmp (name
, ".dynamic") == 0
5601 || strcmp (name
, ".dynstr") == 0))
5603 if (SGI_COMPAT (abfd
))
5604 hdr
->sh_entsize
= 0;
5606 /* This isn't how the IRIX6 linker behaves. */
5607 hdr
->sh_info
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
5610 else if (strcmp (name
, ".got") == 0
5611 || strcmp (name
, ".srdata") == 0
5612 || strcmp (name
, ".sdata") == 0
5613 || strcmp (name
, ".sbss") == 0
5614 || strcmp (name
, ".lit4") == 0
5615 || strcmp (name
, ".lit8") == 0)
5616 hdr
->sh_flags
|= SHF_MIPS_GPREL
;
5617 else if (strcmp (name
, ".MIPS.interfaces") == 0)
5619 hdr
->sh_type
= SHT_MIPS_IFACE
;
5620 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
5622 else if (strncmp (name
, ".MIPS.content", strlen (".MIPS.content")) == 0)
5624 hdr
->sh_type
= SHT_MIPS_CONTENT
;
5625 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
5626 /* The sh_info field is set in final_write_processing. */
5628 else if (MIPS_ELF_OPTIONS_SECTION_NAME_P (name
))
5630 hdr
->sh_type
= SHT_MIPS_OPTIONS
;
5631 hdr
->sh_entsize
= 1;
5632 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
5634 else if (strncmp (name
, ".debug_", sizeof ".debug_" - 1) == 0)
5635 hdr
->sh_type
= SHT_MIPS_DWARF
;
5636 else if (strcmp (name
, ".MIPS.symlib") == 0)
5638 hdr
->sh_type
= SHT_MIPS_SYMBOL_LIB
;
5639 /* The sh_link and sh_info fields are set in
5640 final_write_processing. */
5642 else if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0
5643 || strncmp (name
, ".MIPS.post_rel",
5644 sizeof ".MIPS.post_rel" - 1) == 0)
5646 hdr
->sh_type
= SHT_MIPS_EVENTS
;
5647 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
5648 /* The sh_link field is set in final_write_processing. */
5650 else if (strcmp (name
, ".msym") == 0)
5652 hdr
->sh_type
= SHT_MIPS_MSYM
;
5653 hdr
->sh_flags
|= SHF_ALLOC
;
5654 hdr
->sh_entsize
= 8;
5657 /* In the unlikely event a special section is empty it has to lose its
5658 special meaning. This may happen e.g. when using `strip' with the
5659 "--only-keep-debug" option. */
5660 if (sec
->size
> 0 && !(sec
->flags
& SEC_HAS_CONTENTS
))
5661 hdr
->sh_type
= sh_type
;
5663 /* The generic elf_fake_sections will set up REL_HDR using the default
5664 kind of relocations. We used to set up a second header for the
5665 non-default kind of relocations here, but only NewABI would use
5666 these, and the IRIX ld doesn't like resulting empty RELA sections.
5667 Thus we create those header only on demand now. */
5672 /* Given a BFD section, try to locate the corresponding ELF section
5673 index. This is used by both the 32-bit and the 64-bit ABI.
5674 Actually, it's not clear to me that the 64-bit ABI supports these,
5675 but for non-PIC objects we will certainly want support for at least
5676 the .scommon section. */
5679 _bfd_mips_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
5680 asection
*sec
, int *retval
)
5682 if (strcmp (bfd_get_section_name (abfd
, sec
), ".scommon") == 0)
5684 *retval
= SHN_MIPS_SCOMMON
;
5687 if (strcmp (bfd_get_section_name (abfd
, sec
), ".acommon") == 0)
5689 *retval
= SHN_MIPS_ACOMMON
;
5695 /* Hook called by the linker routine which adds symbols from an object
5696 file. We must handle the special MIPS section numbers here. */
5699 _bfd_mips_elf_add_symbol_hook (bfd
*abfd
, struct bfd_link_info
*info
,
5700 Elf_Internal_Sym
*sym
, const char **namep
,
5701 flagword
*flagsp ATTRIBUTE_UNUSED
,
5702 asection
**secp
, bfd_vma
*valp
)
5704 if (SGI_COMPAT (abfd
)
5705 && (abfd
->flags
& DYNAMIC
) != 0
5706 && strcmp (*namep
, "_rld_new_interface") == 0)
5708 /* Skip IRIX5 rld entry name. */
5713 /* Shared objects may have a dynamic symbol '_gp_disp' defined as
5714 a SECTION *ABS*. This causes ld to think it can resolve _gp_disp
5715 by setting a DT_NEEDED for the shared object. Since _gp_disp is
5716 a magic symbol resolved by the linker, we ignore this bogus definition
5717 of _gp_disp. New ABI objects do not suffer from this problem so this
5718 is not done for them. */
5720 && (sym
->st_shndx
== SHN_ABS
)
5721 && (strcmp (*namep
, "_gp_disp") == 0))
5727 switch (sym
->st_shndx
)
5730 /* Common symbols less than the GP size are automatically
5731 treated as SHN_MIPS_SCOMMON symbols. */
5732 if (sym
->st_size
> elf_gp_size (abfd
)
5733 || IRIX_COMPAT (abfd
) == ict_irix6
)
5736 case SHN_MIPS_SCOMMON
:
5737 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
5738 (*secp
)->flags
|= SEC_IS_COMMON
;
5739 *valp
= sym
->st_size
;
5743 /* This section is used in a shared object. */
5744 if (elf_tdata (abfd
)->elf_text_section
== NULL
)
5746 asymbol
*elf_text_symbol
;
5747 asection
*elf_text_section
;
5748 bfd_size_type amt
= sizeof (asection
);
5750 elf_text_section
= bfd_zalloc (abfd
, amt
);
5751 if (elf_text_section
== NULL
)
5754 amt
= sizeof (asymbol
);
5755 elf_text_symbol
= bfd_zalloc (abfd
, amt
);
5756 if (elf_text_symbol
== NULL
)
5759 /* Initialize the section. */
5761 elf_tdata (abfd
)->elf_text_section
= elf_text_section
;
5762 elf_tdata (abfd
)->elf_text_symbol
= elf_text_symbol
;
5764 elf_text_section
->symbol
= elf_text_symbol
;
5765 elf_text_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_text_symbol
;
5767 elf_text_section
->name
= ".text";
5768 elf_text_section
->flags
= SEC_NO_FLAGS
;
5769 elf_text_section
->output_section
= NULL
;
5770 elf_text_section
->owner
= abfd
;
5771 elf_text_symbol
->name
= ".text";
5772 elf_text_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
5773 elf_text_symbol
->section
= elf_text_section
;
5775 /* This code used to do *secp = bfd_und_section_ptr if
5776 info->shared. I don't know why, and that doesn't make sense,
5777 so I took it out. */
5778 *secp
= elf_tdata (abfd
)->elf_text_section
;
5781 case SHN_MIPS_ACOMMON
:
5782 /* Fall through. XXX Can we treat this as allocated data? */
5784 /* This section is used in a shared object. */
5785 if (elf_tdata (abfd
)->elf_data_section
== NULL
)
5787 asymbol
*elf_data_symbol
;
5788 asection
*elf_data_section
;
5789 bfd_size_type amt
= sizeof (asection
);
5791 elf_data_section
= bfd_zalloc (abfd
, amt
);
5792 if (elf_data_section
== NULL
)
5795 amt
= sizeof (asymbol
);
5796 elf_data_symbol
= bfd_zalloc (abfd
, amt
);
5797 if (elf_data_symbol
== NULL
)
5800 /* Initialize the section. */
5802 elf_tdata (abfd
)->elf_data_section
= elf_data_section
;
5803 elf_tdata (abfd
)->elf_data_symbol
= elf_data_symbol
;
5805 elf_data_section
->symbol
= elf_data_symbol
;
5806 elf_data_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_data_symbol
;
5808 elf_data_section
->name
= ".data";
5809 elf_data_section
->flags
= SEC_NO_FLAGS
;
5810 elf_data_section
->output_section
= NULL
;
5811 elf_data_section
->owner
= abfd
;
5812 elf_data_symbol
->name
= ".data";
5813 elf_data_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
5814 elf_data_symbol
->section
= elf_data_section
;
5816 /* This code used to do *secp = bfd_und_section_ptr if
5817 info->shared. I don't know why, and that doesn't make sense,
5818 so I took it out. */
5819 *secp
= elf_tdata (abfd
)->elf_data_section
;
5822 case SHN_MIPS_SUNDEFINED
:
5823 *secp
= bfd_und_section_ptr
;
5827 if (SGI_COMPAT (abfd
)
5829 && info
->hash
->creator
== abfd
->xvec
5830 && strcmp (*namep
, "__rld_obj_head") == 0)
5832 struct elf_link_hash_entry
*h
;
5833 struct bfd_link_hash_entry
*bh
;
5835 /* Mark __rld_obj_head as dynamic. */
5837 if (! (_bfd_generic_link_add_one_symbol
5838 (info
, abfd
, *namep
, BSF_GLOBAL
, *secp
, *valp
, NULL
, FALSE
,
5839 get_elf_backend_data (abfd
)->collect
, &bh
)))
5842 h
= (struct elf_link_hash_entry
*) bh
;
5845 h
->type
= STT_OBJECT
;
5847 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
5850 mips_elf_hash_table (info
)->use_rld_obj_head
= TRUE
;
5853 /* If this is a mips16 text symbol, add 1 to the value to make it
5854 odd. This will cause something like .word SYM to come up with
5855 the right value when it is loaded into the PC. */
5856 if (sym
->st_other
== STO_MIPS16
)
5862 /* This hook function is called before the linker writes out a global
5863 symbol. We mark symbols as small common if appropriate. This is
5864 also where we undo the increment of the value for a mips16 symbol. */
5867 _bfd_mips_elf_link_output_symbol_hook
5868 (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5869 const char *name ATTRIBUTE_UNUSED
, Elf_Internal_Sym
*sym
,
5870 asection
*input_sec
, struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
)
5872 /* If we see a common symbol, which implies a relocatable link, then
5873 if a symbol was small common in an input file, mark it as small
5874 common in the output file. */
5875 if (sym
->st_shndx
== SHN_COMMON
5876 && strcmp (input_sec
->name
, ".scommon") == 0)
5877 sym
->st_shndx
= SHN_MIPS_SCOMMON
;
5879 if (sym
->st_other
== STO_MIPS16
)
5880 sym
->st_value
&= ~1;
5885 /* Functions for the dynamic linker. */
5887 /* Create dynamic sections when linking against a dynamic object. */
5890 _bfd_mips_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
5892 struct elf_link_hash_entry
*h
;
5893 struct bfd_link_hash_entry
*bh
;
5895 register asection
*s
;
5896 const char * const *namep
;
5897 struct mips_elf_link_hash_table
*htab
;
5899 htab
= mips_elf_hash_table (info
);
5900 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
5901 | SEC_LINKER_CREATED
| SEC_READONLY
);
5903 /* The psABI requires a read-only .dynamic section, but the VxWorks
5905 if (!htab
->is_vxworks
)
5907 s
= bfd_get_section_by_name (abfd
, ".dynamic");
5910 if (! bfd_set_section_flags (abfd
, s
, flags
))
5915 /* We need to create .got section. */
5916 if (! mips_elf_create_got_section (abfd
, info
, FALSE
))
5919 if (! mips_elf_rel_dyn_section (info
, TRUE
))
5922 /* Create .stub section. */
5923 if (bfd_get_section_by_name (abfd
,
5924 MIPS_ELF_STUB_SECTION_NAME (abfd
)) == NULL
)
5926 s
= bfd_make_section_with_flags (abfd
,
5927 MIPS_ELF_STUB_SECTION_NAME (abfd
),
5930 || ! bfd_set_section_alignment (abfd
, s
,
5931 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
5935 if ((IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
5937 && bfd_get_section_by_name (abfd
, ".rld_map") == NULL
)
5939 s
= bfd_make_section_with_flags (abfd
, ".rld_map",
5940 flags
&~ (flagword
) SEC_READONLY
);
5942 || ! bfd_set_section_alignment (abfd
, s
,
5943 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
5947 /* On IRIX5, we adjust add some additional symbols and change the
5948 alignments of several sections. There is no ABI documentation
5949 indicating that this is necessary on IRIX6, nor any evidence that
5950 the linker takes such action. */
5951 if (IRIX_COMPAT (abfd
) == ict_irix5
)
5953 for (namep
= mips_elf_dynsym_rtproc_names
; *namep
!= NULL
; namep
++)
5956 if (! (_bfd_generic_link_add_one_symbol
5957 (info
, abfd
, *namep
, BSF_GLOBAL
, bfd_und_section_ptr
, 0,
5958 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
5961 h
= (struct elf_link_hash_entry
*) bh
;
5964 h
->type
= STT_SECTION
;
5966 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
5970 /* We need to create a .compact_rel section. */
5971 if (SGI_COMPAT (abfd
))
5973 if (!mips_elf_create_compact_rel_section (abfd
, info
))
5977 /* Change alignments of some sections. */
5978 s
= bfd_get_section_by_name (abfd
, ".hash");
5980 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
5981 s
= bfd_get_section_by_name (abfd
, ".dynsym");
5983 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
5984 s
= bfd_get_section_by_name (abfd
, ".dynstr");
5986 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
5987 s
= bfd_get_section_by_name (abfd
, ".reginfo");
5989 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
5990 s
= bfd_get_section_by_name (abfd
, ".dynamic");
5992 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
5999 name
= SGI_COMPAT (abfd
) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
6001 if (!(_bfd_generic_link_add_one_symbol
6002 (info
, abfd
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
, 0,
6003 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
6006 h
= (struct elf_link_hash_entry
*) bh
;
6009 h
->type
= STT_SECTION
;
6011 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
6014 if (! mips_elf_hash_table (info
)->use_rld_obj_head
)
6016 /* __rld_map is a four byte word located in the .data section
6017 and is filled in by the rtld to contain a pointer to
6018 the _r_debug structure. Its symbol value will be set in
6019 _bfd_mips_elf_finish_dynamic_symbol. */
6020 s
= bfd_get_section_by_name (abfd
, ".rld_map");
6021 BFD_ASSERT (s
!= NULL
);
6023 name
= SGI_COMPAT (abfd
) ? "__rld_map" : "__RLD_MAP";
6025 if (!(_bfd_generic_link_add_one_symbol
6026 (info
, abfd
, name
, BSF_GLOBAL
, s
, 0, NULL
, FALSE
,
6027 get_elf_backend_data (abfd
)->collect
, &bh
)))
6030 h
= (struct elf_link_hash_entry
*) bh
;
6033 h
->type
= STT_OBJECT
;
6035 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
6040 if (htab
->is_vxworks
)
6042 /* Create the .plt, .rela.plt, .dynbss and .rela.bss sections.
6043 Also create the _PROCEDURE_LINKAGE_TABLE symbol. */
6044 if (!_bfd_elf_create_dynamic_sections (abfd
, info
))
6047 /* Cache the sections created above. */
6048 htab
->sdynbss
= bfd_get_section_by_name (abfd
, ".dynbss");
6049 htab
->srelbss
= bfd_get_section_by_name (abfd
, ".rela.bss");
6050 htab
->srelplt
= bfd_get_section_by_name (abfd
, ".rela.plt");
6051 htab
->splt
= bfd_get_section_by_name (abfd
, ".plt");
6053 || (!htab
->srelbss
&& !info
->shared
)
6058 /* Do the usual VxWorks handling. */
6059 if (!elf_vxworks_create_dynamic_sections (abfd
, info
, &htab
->srelplt2
))
6062 /* Work out the PLT sizes. */
6065 htab
->plt_header_size
6066 = 4 * ARRAY_SIZE (mips_vxworks_shared_plt0_entry
);
6067 htab
->plt_entry_size
6068 = 4 * ARRAY_SIZE (mips_vxworks_shared_plt_entry
);
6072 htab
->plt_header_size
6073 = 4 * ARRAY_SIZE (mips_vxworks_exec_plt0_entry
);
6074 htab
->plt_entry_size
6075 = 4 * ARRAY_SIZE (mips_vxworks_exec_plt_entry
);
6082 /* Look through the relocs for a section during the first phase, and
6083 allocate space in the global offset table. */
6086 _bfd_mips_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
6087 asection
*sec
, const Elf_Internal_Rela
*relocs
)
6091 Elf_Internal_Shdr
*symtab_hdr
;
6092 struct elf_link_hash_entry
**sym_hashes
;
6093 struct mips_got_info
*g
;
6095 const Elf_Internal_Rela
*rel
;
6096 const Elf_Internal_Rela
*rel_end
;
6099 const struct elf_backend_data
*bed
;
6100 struct mips_elf_link_hash_table
*htab
;
6102 if (info
->relocatable
)
6105 htab
= mips_elf_hash_table (info
);
6106 dynobj
= elf_hash_table (info
)->dynobj
;
6107 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
6108 sym_hashes
= elf_sym_hashes (abfd
);
6109 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
6111 /* Check for the mips16 stub sections. */
6113 name
= bfd_get_section_name (abfd
, sec
);
6114 if (strncmp (name
, FN_STUB
, sizeof FN_STUB
- 1) == 0)
6116 unsigned long r_symndx
;
6118 /* Look at the relocation information to figure out which symbol
6121 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
6123 if (r_symndx
< extsymoff
6124 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
6128 /* This stub is for a local symbol. This stub will only be
6129 needed if there is some relocation in this BFD, other
6130 than a 16 bit function call, which refers to this symbol. */
6131 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
6133 Elf_Internal_Rela
*sec_relocs
;
6134 const Elf_Internal_Rela
*r
, *rend
;
6136 /* We can ignore stub sections when looking for relocs. */
6137 if ((o
->flags
& SEC_RELOC
) == 0
6138 || o
->reloc_count
== 0
6139 || strncmp (bfd_get_section_name (abfd
, o
), FN_STUB
,
6140 sizeof FN_STUB
- 1) == 0
6141 || strncmp (bfd_get_section_name (abfd
, o
), CALL_STUB
,
6142 sizeof CALL_STUB
- 1) == 0
6143 || strncmp (bfd_get_section_name (abfd
, o
), CALL_FP_STUB
,
6144 sizeof CALL_FP_STUB
- 1) == 0)
6148 = _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
6150 if (sec_relocs
== NULL
)
6153 rend
= sec_relocs
+ o
->reloc_count
;
6154 for (r
= sec_relocs
; r
< rend
; r
++)
6155 if (ELF_R_SYM (abfd
, r
->r_info
) == r_symndx
6156 && ELF_R_TYPE (abfd
, r
->r_info
) != R_MIPS16_26
)
6159 if (elf_section_data (o
)->relocs
!= sec_relocs
)
6168 /* There is no non-call reloc for this stub, so we do
6169 not need it. Since this function is called before
6170 the linker maps input sections to output sections, we
6171 can easily discard it by setting the SEC_EXCLUDE
6173 sec
->flags
|= SEC_EXCLUDE
;
6177 /* Record this stub in an array of local symbol stubs for
6179 if (elf_tdata (abfd
)->local_stubs
== NULL
)
6181 unsigned long symcount
;
6185 if (elf_bad_symtab (abfd
))
6186 symcount
= NUM_SHDR_ENTRIES (symtab_hdr
);
6188 symcount
= symtab_hdr
->sh_info
;
6189 amt
= symcount
* sizeof (asection
*);
6190 n
= bfd_zalloc (abfd
, amt
);
6193 elf_tdata (abfd
)->local_stubs
= n
;
6196 elf_tdata (abfd
)->local_stubs
[r_symndx
] = sec
;
6198 /* We don't need to set mips16_stubs_seen in this case.
6199 That flag is used to see whether we need to look through
6200 the global symbol table for stubs. We don't need to set
6201 it here, because we just have a local stub. */
6205 struct mips_elf_link_hash_entry
*h
;
6207 h
= ((struct mips_elf_link_hash_entry
*)
6208 sym_hashes
[r_symndx
- extsymoff
]);
6210 while (h
->root
.root
.type
== bfd_link_hash_indirect
6211 || h
->root
.root
.type
== bfd_link_hash_warning
)
6212 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
6214 /* H is the symbol this stub is for. */
6217 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
6220 else if (strncmp (name
, CALL_STUB
, sizeof CALL_STUB
- 1) == 0
6221 || strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
6223 unsigned long r_symndx
;
6224 struct mips_elf_link_hash_entry
*h
;
6227 /* Look at the relocation information to figure out which symbol
6230 r_symndx
= ELF_R_SYM (abfd
, relocs
->r_info
);
6232 if (r_symndx
< extsymoff
6233 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
6235 /* This stub was actually built for a static symbol defined
6236 in the same file. We assume that all static symbols in
6237 mips16 code are themselves mips16, so we can simply
6238 discard this stub. Since this function is called before
6239 the linker maps input sections to output sections, we can
6240 easily discard it by setting the SEC_EXCLUDE flag. */
6241 sec
->flags
|= SEC_EXCLUDE
;
6245 h
= ((struct mips_elf_link_hash_entry
*)
6246 sym_hashes
[r_symndx
- extsymoff
]);
6248 /* H is the symbol this stub is for. */
6250 if (strncmp (name
, CALL_FP_STUB
, sizeof CALL_FP_STUB
- 1) == 0)
6251 loc
= &h
->call_fp_stub
;
6253 loc
= &h
->call_stub
;
6255 /* If we already have an appropriate stub for this function, we
6256 don't need another one, so we can discard this one. Since
6257 this function is called before the linker maps input sections
6258 to output sections, we can easily discard it by setting the
6259 SEC_EXCLUDE flag. We can also discard this section if we
6260 happen to already know that this is a mips16 function; it is
6261 not necessary to check this here, as it is checked later, but
6262 it is slightly faster to check now. */
6263 if (*loc
!= NULL
|| h
->root
.other
== STO_MIPS16
)
6265 sec
->flags
|= SEC_EXCLUDE
;
6270 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
6280 sgot
= mips_elf_got_section (dynobj
, FALSE
);
6285 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
6286 g
= mips_elf_section_data (sgot
)->u
.got_info
;
6287 BFD_ASSERT (g
!= NULL
);
6292 bed
= get_elf_backend_data (abfd
);
6293 rel_end
= relocs
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
6294 for (rel
= relocs
; rel
< rel_end
; ++rel
)
6296 unsigned long r_symndx
;
6297 unsigned int r_type
;
6298 struct elf_link_hash_entry
*h
;
6300 r_symndx
= ELF_R_SYM (abfd
, rel
->r_info
);
6301 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
6303 if (r_symndx
< extsymoff
)
6305 else if (r_symndx
>= extsymoff
+ NUM_SHDR_ENTRIES (symtab_hdr
))
6307 (*_bfd_error_handler
)
6308 (_("%B: Malformed reloc detected for section %s"),
6310 bfd_set_error (bfd_error_bad_value
);
6315 h
= sym_hashes
[r_symndx
- extsymoff
];
6317 /* This may be an indirect symbol created because of a version. */
6320 while (h
->root
.type
== bfd_link_hash_indirect
)
6321 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
6325 /* Some relocs require a global offset table. */
6326 if (dynobj
== NULL
|| sgot
== NULL
)
6332 case R_MIPS_CALL_HI16
:
6333 case R_MIPS_CALL_LO16
:
6334 case R_MIPS_GOT_HI16
:
6335 case R_MIPS_GOT_LO16
:
6336 case R_MIPS_GOT_PAGE
:
6337 case R_MIPS_GOT_OFST
:
6338 case R_MIPS_GOT_DISP
:
6339 case R_MIPS_TLS_GOTTPREL
:
6341 case R_MIPS_TLS_LDM
:
6343 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
6344 if (! mips_elf_create_got_section (dynobj
, info
, FALSE
))
6346 g
= mips_elf_got_info (dynobj
, &sgot
);
6347 if (htab
->is_vxworks
&& !info
->shared
)
6349 (*_bfd_error_handler
)
6350 (_("%B: GOT reloc at 0x%lx not expected in executables"),
6351 abfd
, (unsigned long) rel
->r_offset
);
6352 bfd_set_error (bfd_error_bad_value
);
6360 /* In VxWorks executables, references to external symbols
6361 are handled using copy relocs or PLT stubs, so there's
6362 no need to add a dynamic relocation here. */
6364 && (info
->shared
|| (h
!= NULL
&& !htab
->is_vxworks
))
6365 && (sec
->flags
& SEC_ALLOC
) != 0)
6366 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
6376 ((struct mips_elf_link_hash_entry
*) h
)->is_relocation_target
= TRUE
;
6378 /* Relocations against the special VxWorks __GOTT_BASE__ and
6379 __GOTT_INDEX__ symbols must be left to the loader. Allocate
6380 room for them in .rela.dyn. */
6381 if (is_gott_symbol (info
, h
))
6385 sreloc
= mips_elf_rel_dyn_section (info
, TRUE
);
6389 mips_elf_allocate_dynamic_relocations (dynobj
, info
, 1);
6392 else if (r_type
== R_MIPS_CALL_LO16
6393 || r_type
== R_MIPS_GOT_LO16
6394 || r_type
== R_MIPS_GOT_DISP
6395 || (r_type
== R_MIPS_GOT16
&& htab
->is_vxworks
))
6397 /* We may need a local GOT entry for this relocation. We
6398 don't count R_MIPS_GOT_PAGE because we can estimate the
6399 maximum number of pages needed by looking at the size of
6400 the segment. Similar comments apply to R_MIPS_GOT16 and
6401 R_MIPS_CALL16, except on VxWorks, where GOT relocations
6402 always evaluate to "G". We don't count R_MIPS_GOT_HI16, or
6403 R_MIPS_CALL_HI16 because these are always followed by an
6404 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
6405 if (! mips_elf_record_local_got_symbol (abfd
, r_symndx
,
6406 rel
->r_addend
, g
, 0))
6415 (*_bfd_error_handler
)
6416 (_("%B: CALL16 reloc at 0x%lx not against global symbol"),
6417 abfd
, (unsigned long) rel
->r_offset
);
6418 bfd_set_error (bfd_error_bad_value
);
6423 case R_MIPS_CALL_HI16
:
6424 case R_MIPS_CALL_LO16
:
6427 /* VxWorks call relocations point the function's .got.plt
6428 entry, which will be allocated by adjust_dynamic_symbol.
6429 Otherwise, this symbol requires a global GOT entry. */
6430 if (!htab
->is_vxworks
6431 && !mips_elf_record_global_got_symbol (h
, abfd
, info
, g
, 0))
6434 /* We need a stub, not a plt entry for the undefined
6435 function. But we record it as if it needs plt. See
6436 _bfd_elf_adjust_dynamic_symbol. */
6442 case R_MIPS_GOT_PAGE
:
6443 /* If this is a global, overridable symbol, GOT_PAGE will
6444 decay to GOT_DISP, so we'll need a GOT entry for it. */
6449 struct mips_elf_link_hash_entry
*hmips
=
6450 (struct mips_elf_link_hash_entry
*) h
;
6452 while (hmips
->root
.root
.type
== bfd_link_hash_indirect
6453 || hmips
->root
.root
.type
== bfd_link_hash_warning
)
6454 hmips
= (struct mips_elf_link_hash_entry
*)
6455 hmips
->root
.root
.u
.i
.link
;
6457 if (hmips
->root
.def_regular
6458 && ! (info
->shared
&& ! info
->symbolic
6459 && ! hmips
->root
.forced_local
))
6465 case R_MIPS_GOT_HI16
:
6466 case R_MIPS_GOT_LO16
:
6467 case R_MIPS_GOT_DISP
:
6468 if (h
&& ! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
, 0))
6472 case R_MIPS_TLS_GOTTPREL
:
6474 info
->flags
|= DF_STATIC_TLS
;
6477 case R_MIPS_TLS_LDM
:
6478 if (r_type
== R_MIPS_TLS_LDM
)
6486 /* This symbol requires a global offset table entry, or two
6487 for TLS GD relocations. */
6489 unsigned char flag
= (r_type
== R_MIPS_TLS_GD
6491 : r_type
== R_MIPS_TLS_LDM
6496 struct mips_elf_link_hash_entry
*hmips
=
6497 (struct mips_elf_link_hash_entry
*) h
;
6498 hmips
->tls_type
|= flag
;
6500 if (h
&& ! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
, flag
))
6505 BFD_ASSERT (flag
== GOT_TLS_LDM
|| r_symndx
!= 0);
6507 if (! mips_elf_record_local_got_symbol (abfd
, r_symndx
,
6508 rel
->r_addend
, g
, flag
))
6517 /* In VxWorks executables, references to external symbols
6518 are handled using copy relocs or PLT stubs, so there's
6519 no need to add a .rela.dyn entry for this relocation. */
6520 if ((info
->shared
|| (h
!= NULL
&& !htab
->is_vxworks
))
6521 && (sec
->flags
& SEC_ALLOC
) != 0)
6525 sreloc
= mips_elf_rel_dyn_section (info
, TRUE
);
6531 /* When creating a shared object, we must copy these
6532 reloc types into the output file as R_MIPS_REL32
6533 relocs. Make room for this reloc in .rel(a).dyn. */
6534 mips_elf_allocate_dynamic_relocations (dynobj
, info
, 1);
6535 if (MIPS_ELF_READONLY_SECTION (sec
))
6536 /* We tell the dynamic linker that there are
6537 relocations against the text segment. */
6538 info
->flags
|= DF_TEXTREL
;
6542 struct mips_elf_link_hash_entry
*hmips
;
6544 /* We only need to copy this reloc if the symbol is
6545 defined in a dynamic object. */
6546 hmips
= (struct mips_elf_link_hash_entry
*) h
;
6547 ++hmips
->possibly_dynamic_relocs
;
6548 if (MIPS_ELF_READONLY_SECTION (sec
))
6549 /* We need it to tell the dynamic linker if there
6550 are relocations against the text segment. */
6551 hmips
->readonly_reloc
= TRUE
;
6554 /* Even though we don't directly need a GOT entry for
6555 this symbol, a symbol must have a dynamic symbol
6556 table index greater that DT_MIPS_GOTSYM if there are
6557 dynamic relocations against it. This does not apply
6558 to VxWorks, which does not have the usual coupling
6559 between global GOT entries and .dynsym entries. */
6560 if (h
!= NULL
&& !htab
->is_vxworks
)
6563 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
6564 if (! mips_elf_create_got_section (dynobj
, info
, TRUE
))
6566 g
= mips_elf_got_info (dynobj
, &sgot
);
6567 if (! mips_elf_record_global_got_symbol (h
, abfd
, info
, g
, 0))
6572 if (SGI_COMPAT (abfd
))
6573 mips_elf_hash_table (info
)->compact_rel_size
+=
6574 sizeof (Elf32_External_crinfo
);
6579 ((struct mips_elf_link_hash_entry
*) h
)->is_branch_target
= TRUE
;
6584 ((struct mips_elf_link_hash_entry
*) h
)->is_branch_target
= TRUE
;
6587 case R_MIPS_GPREL16
:
6588 case R_MIPS_LITERAL
:
6589 case R_MIPS_GPREL32
:
6590 if (SGI_COMPAT (abfd
))
6591 mips_elf_hash_table (info
)->compact_rel_size
+=
6592 sizeof (Elf32_External_crinfo
);
6595 /* This relocation describes the C++ object vtable hierarchy.
6596 Reconstruct it for later use during GC. */
6597 case R_MIPS_GNU_VTINHERIT
:
6598 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
6602 /* This relocation describes which C++ vtable entries are actually
6603 used. Record for later use during GC. */
6604 case R_MIPS_GNU_VTENTRY
:
6605 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
6613 /* We must not create a stub for a symbol that has relocations
6614 related to taking the function's address. This doesn't apply to
6615 VxWorks, where CALL relocs refer to a .got.plt entry instead of
6616 a normal .got entry. */
6617 if (!htab
->is_vxworks
&& h
!= NULL
)
6621 ((struct mips_elf_link_hash_entry
*) h
)->no_fn_stub
= TRUE
;
6624 case R_MIPS_CALL_HI16
:
6625 case R_MIPS_CALL_LO16
:
6630 /* If this reloc is not a 16 bit call, and it has a global
6631 symbol, then we will need the fn_stub if there is one.
6632 References from a stub section do not count. */
6634 && r_type
!= R_MIPS16_26
6635 && strncmp (bfd_get_section_name (abfd
, sec
), FN_STUB
,
6636 sizeof FN_STUB
- 1) != 0
6637 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_STUB
,
6638 sizeof CALL_STUB
- 1) != 0
6639 && strncmp (bfd_get_section_name (abfd
, sec
), CALL_FP_STUB
,
6640 sizeof CALL_FP_STUB
- 1) != 0)
6642 struct mips_elf_link_hash_entry
*mh
;
6644 mh
= (struct mips_elf_link_hash_entry
*) h
;
6645 mh
->need_fn_stub
= TRUE
;
6653 _bfd_mips_relax_section (bfd
*abfd
, asection
*sec
,
6654 struct bfd_link_info
*link_info
,
6657 Elf_Internal_Rela
*internal_relocs
;
6658 Elf_Internal_Rela
*irel
, *irelend
;
6659 Elf_Internal_Shdr
*symtab_hdr
;
6660 bfd_byte
*contents
= NULL
;
6662 bfd_boolean changed_contents
= FALSE
;
6663 bfd_vma sec_start
= sec
->output_section
->vma
+ sec
->output_offset
;
6664 Elf_Internal_Sym
*isymbuf
= NULL
;
6666 /* We are not currently changing any sizes, so only one pass. */
6669 if (link_info
->relocatable
)
6672 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
6673 link_info
->keep_memory
);
6674 if (internal_relocs
== NULL
)
6677 irelend
= internal_relocs
+ sec
->reloc_count
6678 * get_elf_backend_data (abfd
)->s
->int_rels_per_ext_rel
;
6679 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
6680 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
6682 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
6685 bfd_signed_vma sym_offset
;
6686 unsigned int r_type
;
6687 unsigned long r_symndx
;
6689 unsigned long instruction
;
6691 /* Turn jalr into bgezal, and jr into beq, if they're marked
6692 with a JALR relocation, that indicate where they jump to.
6693 This saves some pipeline bubbles. */
6694 r_type
= ELF_R_TYPE (abfd
, irel
->r_info
);
6695 if (r_type
!= R_MIPS_JALR
)
6698 r_symndx
= ELF_R_SYM (abfd
, irel
->r_info
);
6699 /* Compute the address of the jump target. */
6700 if (r_symndx
>= extsymoff
)
6702 struct mips_elf_link_hash_entry
*h
6703 = ((struct mips_elf_link_hash_entry
*)
6704 elf_sym_hashes (abfd
) [r_symndx
- extsymoff
]);
6706 while (h
->root
.root
.type
== bfd_link_hash_indirect
6707 || h
->root
.root
.type
== bfd_link_hash_warning
)
6708 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
6710 /* If a symbol is undefined, or if it may be overridden,
6712 if (! ((h
->root
.root
.type
== bfd_link_hash_defined
6713 || h
->root
.root
.type
== bfd_link_hash_defweak
)
6714 && h
->root
.root
.u
.def
.section
)
6715 || (link_info
->shared
&& ! link_info
->symbolic
6716 && !h
->root
.forced_local
))
6719 sym_sec
= h
->root
.root
.u
.def
.section
;
6720 if (sym_sec
->output_section
)
6721 symval
= (h
->root
.root
.u
.def
.value
6722 + sym_sec
->output_section
->vma
6723 + sym_sec
->output_offset
);
6725 symval
= h
->root
.root
.u
.def
.value
;
6729 Elf_Internal_Sym
*isym
;
6731 /* Read this BFD's symbols if we haven't done so already. */
6732 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
6734 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
6735 if (isymbuf
== NULL
)
6736 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
6737 symtab_hdr
->sh_info
, 0,
6739 if (isymbuf
== NULL
)
6743 isym
= isymbuf
+ r_symndx
;
6744 if (isym
->st_shndx
== SHN_UNDEF
)
6746 else if (isym
->st_shndx
== SHN_ABS
)
6747 sym_sec
= bfd_abs_section_ptr
;
6748 else if (isym
->st_shndx
== SHN_COMMON
)
6749 sym_sec
= bfd_com_section_ptr
;
6752 = bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
6753 symval
= isym
->st_value
6754 + sym_sec
->output_section
->vma
6755 + sym_sec
->output_offset
;
6758 /* Compute branch offset, from delay slot of the jump to the
6760 sym_offset
= (symval
+ irel
->r_addend
)
6761 - (sec_start
+ irel
->r_offset
+ 4);
6763 /* Branch offset must be properly aligned. */
6764 if ((sym_offset
& 3) != 0)
6769 /* Check that it's in range. */
6770 if (sym_offset
< -0x8000 || sym_offset
>= 0x8000)
6773 /* Get the section contents if we haven't done so already. */
6774 if (contents
== NULL
)
6776 /* Get cached copy if it exists. */
6777 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
6778 contents
= elf_section_data (sec
)->this_hdr
.contents
;
6781 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
6786 instruction
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
6788 /* If it was jalr <reg>, turn it into bgezal $zero, <target>. */
6789 if ((instruction
& 0xfc1fffff) == 0x0000f809)
6790 instruction
= 0x04110000;
6791 /* If it was jr <reg>, turn it into b <target>. */
6792 else if ((instruction
& 0xfc1fffff) == 0x00000008)
6793 instruction
= 0x10000000;
6797 instruction
|= (sym_offset
& 0xffff);
6798 bfd_put_32 (abfd
, instruction
, contents
+ irel
->r_offset
);
6799 changed_contents
= TRUE
;
6802 if (contents
!= NULL
6803 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
6805 if (!changed_contents
&& !link_info
->keep_memory
)
6809 /* Cache the section contents for elf_link_input_bfd. */
6810 elf_section_data (sec
)->this_hdr
.contents
= contents
;
6816 if (contents
!= NULL
6817 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
6822 /* Adjust a symbol defined by a dynamic object and referenced by a
6823 regular object. The current definition is in some section of the
6824 dynamic object, but we're not including those sections. We have to
6825 change the definition to something the rest of the link can
6829 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
6830 struct elf_link_hash_entry
*h
)
6833 struct mips_elf_link_hash_entry
*hmips
;
6836 dynobj
= elf_hash_table (info
)->dynobj
;
6838 /* Make sure we know what is going on here. */
6839 BFD_ASSERT (dynobj
!= NULL
6841 || h
->u
.weakdef
!= NULL
6844 && !h
->def_regular
)));
6846 /* If this symbol is defined in a dynamic object, we need to copy
6847 any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
6849 hmips
= (struct mips_elf_link_hash_entry
*) h
;
6850 if (! info
->relocatable
6851 && hmips
->possibly_dynamic_relocs
!= 0
6852 && (h
->root
.type
== bfd_link_hash_defweak
6853 || !h
->def_regular
))
6855 mips_elf_allocate_dynamic_relocations
6856 (dynobj
, info
, hmips
->possibly_dynamic_relocs
);
6857 if (hmips
->readonly_reloc
)
6858 /* We tell the dynamic linker that there are relocations
6859 against the text segment. */
6860 info
->flags
|= DF_TEXTREL
;
6863 /* For a function, create a stub, if allowed. */
6864 if (! hmips
->no_fn_stub
6867 if (! elf_hash_table (info
)->dynamic_sections_created
)
6870 /* If this symbol is not defined in a regular file, then set
6871 the symbol to the stub location. This is required to make
6872 function pointers compare as equal between the normal
6873 executable and the shared library. */
6874 if (!h
->def_regular
)
6876 /* We need .stub section. */
6877 s
= bfd_get_section_by_name (dynobj
,
6878 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
6879 BFD_ASSERT (s
!= NULL
);
6881 h
->root
.u
.def
.section
= s
;
6882 h
->root
.u
.def
.value
= s
->size
;
6884 /* XXX Write this stub address somewhere. */
6885 h
->plt
.offset
= s
->size
;
6887 /* Make room for this stub code. */
6888 s
->size
+= MIPS_FUNCTION_STUB_SIZE (info
);
6890 /* The last half word of the stub will be filled with the index
6891 of this symbol in .dynsym section. */
6895 else if ((h
->type
== STT_FUNC
)
6898 /* This will set the entry for this symbol in the GOT to 0, and
6899 the dynamic linker will take care of this. */
6900 h
->root
.u
.def
.value
= 0;
6904 /* If this is a weak symbol, and there is a real definition, the
6905 processor independent code will have arranged for us to see the
6906 real definition first, and we can just use the same value. */
6907 if (h
->u
.weakdef
!= NULL
)
6909 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
6910 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
6911 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
6912 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
6916 /* This is a reference to a symbol defined by a dynamic object which
6917 is not a function. */
6922 /* Likewise, for VxWorks. */
6925 _bfd_mips_vxworks_adjust_dynamic_symbol (struct bfd_link_info
*info
,
6926 struct elf_link_hash_entry
*h
)
6929 struct mips_elf_link_hash_entry
*hmips
;
6930 struct mips_elf_link_hash_table
*htab
;
6931 unsigned int power_of_two
;
6933 htab
= mips_elf_hash_table (info
);
6934 dynobj
= elf_hash_table (info
)->dynobj
;
6935 hmips
= (struct mips_elf_link_hash_entry
*) h
;
6937 /* Make sure we know what is going on here. */
6938 BFD_ASSERT (dynobj
!= NULL
6941 || h
->u
.weakdef
!= NULL
6944 && !h
->def_regular
)));
6946 /* If the symbol is defined by a dynamic object, we need a PLT stub if
6947 either (a) we want to branch to the symbol or (b) we're linking an
6948 executable that needs a canonical function address. In the latter
6949 case, the canonical address will be the address of the executable's
6951 if ((hmips
->is_branch_target
6953 && h
->type
== STT_FUNC
6954 && hmips
->is_relocation_target
))
6958 && !h
->forced_local
)
6961 /* Locally-binding symbols do not need a PLT stub; we can refer to
6962 the functions directly. */
6963 else if (h
->needs_plt
6964 && (SYMBOL_CALLS_LOCAL (info
, h
)
6965 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
6966 && h
->root
.type
== bfd_link_hash_undefweak
)))
6974 /* If this is the first symbol to need a PLT entry, allocate room
6975 for the header, and for the header's .rela.plt.unloaded entries. */
6976 if (htab
->splt
->size
== 0)
6978 htab
->splt
->size
+= htab
->plt_header_size
;
6980 htab
->srelplt2
->size
+= 2 * sizeof (Elf32_External_Rela
);
6983 /* Assign the next .plt entry to this symbol. */
6984 h
->plt
.offset
= htab
->splt
->size
;
6985 htab
->splt
->size
+= htab
->plt_entry_size
;
6987 /* If the output file has no definition of the symbol, set the
6988 symbol's value to the address of the stub. For executables,
6989 point at the PLT load stub rather than the lazy resolution stub;
6990 this stub will become the canonical function address. */
6991 if (!h
->def_regular
)
6993 h
->root
.u
.def
.section
= htab
->splt
;
6994 h
->root
.u
.def
.value
= h
->plt
.offset
;
6996 h
->root
.u
.def
.value
+= 8;
6999 /* Make room for the .got.plt entry and the R_JUMP_SLOT relocation. */
7000 htab
->sgotplt
->size
+= 4;
7001 htab
->srelplt
->size
+= sizeof (Elf32_External_Rela
);
7003 /* Make room for the .rela.plt.unloaded relocations. */
7005 htab
->srelplt2
->size
+= 3 * sizeof (Elf32_External_Rela
);
7010 /* If a function symbol is defined by a dynamic object, and we do not
7011 need a PLT stub for it, the symbol's value should be zero. */
7012 if (h
->type
== STT_FUNC
7017 h
->root
.u
.def
.value
= 0;
7021 /* If this is a weak symbol, and there is a real definition, the
7022 processor independent code will have arranged for us to see the
7023 real definition first, and we can just use the same value. */
7024 if (h
->u
.weakdef
!= NULL
)
7026 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
7027 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
7028 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
7029 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
7033 /* This is a reference to a symbol defined by a dynamic object which
7034 is not a function. */
7038 /* We must allocate the symbol in our .dynbss section, which will
7039 become part of the .bss section of the executable. There will be
7040 an entry for this symbol in the .dynsym section. The dynamic
7041 object will contain position independent code, so all references
7042 from the dynamic object to this symbol will go through the global
7043 offset table. The dynamic linker will use the .dynsym entry to
7044 determine the address it must put in the global offset table, so
7045 both the dynamic object and the regular object will refer to the
7046 same memory location for the variable. */
7048 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
7050 htab
->srelbss
->size
+= sizeof (Elf32_External_Rela
);
7054 /* We need to figure out the alignment required for this symbol. */
7055 power_of_two
= bfd_log2 (h
->size
);
7056 if (power_of_two
> 4)
7059 /* Apply the required alignment. */
7060 htab
->sdynbss
->size
= BFD_ALIGN (htab
->sdynbss
->size
,
7061 (bfd_size_type
) 1 << power_of_two
);
7062 if (power_of_two
> bfd_get_section_alignment (dynobj
, htab
->sdynbss
)
7063 && !bfd_set_section_alignment (dynobj
, htab
->sdynbss
, power_of_two
))
7066 /* Define the symbol as being at this point in the section. */
7067 h
->root
.u
.def
.section
= htab
->sdynbss
;
7068 h
->root
.u
.def
.value
= htab
->sdynbss
->size
;
7070 /* Increment the section size to make room for the symbol. */
7071 htab
->sdynbss
->size
+= h
->size
;
7076 /* This function is called after all the input files have been read,
7077 and the input sections have been assigned to output sections. We
7078 check for any mips16 stub sections that we can discard. */
7081 _bfd_mips_elf_always_size_sections (bfd
*output_bfd
,
7082 struct bfd_link_info
*info
)
7088 struct mips_got_info
*g
;
7090 bfd_size_type loadable_size
= 0;
7091 bfd_size_type local_gotno
;
7093 struct mips_elf_count_tls_arg count_tls_arg
;
7094 struct mips_elf_link_hash_table
*htab
;
7096 htab
= mips_elf_hash_table (info
);
7098 /* The .reginfo section has a fixed size. */
7099 ri
= bfd_get_section_by_name (output_bfd
, ".reginfo");
7101 bfd_set_section_size (output_bfd
, ri
, sizeof (Elf32_External_RegInfo
));
7103 if (! (info
->relocatable
7104 || ! mips_elf_hash_table (info
)->mips16_stubs_seen
))
7105 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
7106 mips_elf_check_mips16_stubs
, NULL
);
7108 dynobj
= elf_hash_table (info
)->dynobj
;
7110 /* Relocatable links don't have it. */
7113 g
= mips_elf_got_info (dynobj
, &s
);
7117 /* Calculate the total loadable size of the output. That
7118 will give us the maximum number of GOT_PAGE entries
7120 for (sub
= info
->input_bfds
; sub
; sub
= sub
->link_next
)
7122 asection
*subsection
;
7124 for (subsection
= sub
->sections
;
7126 subsection
= subsection
->next
)
7128 if ((subsection
->flags
& SEC_ALLOC
) == 0)
7130 loadable_size
+= ((subsection
->size
+ 0xf)
7131 &~ (bfd_size_type
) 0xf);
7135 /* There has to be a global GOT entry for every symbol with
7136 a dynamic symbol table index of DT_MIPS_GOTSYM or
7137 higher. Therefore, it make sense to put those symbols
7138 that need GOT entries at the end of the symbol table. We
7140 if (! mips_elf_sort_hash_table (info
, 1))
7143 if (g
->global_gotsym
!= NULL
)
7144 i
= elf_hash_table (info
)->dynsymcount
- g
->global_gotsym
->dynindx
;
7146 /* If there are no global symbols, or none requiring
7147 relocations, then GLOBAL_GOTSYM will be NULL. */
7150 /* In the worst case, we'll get one stub per dynamic symbol, plus
7151 one to account for the dummy entry at the end required by IRIX
7153 loadable_size
+= MIPS_FUNCTION_STUB_SIZE (info
) * (i
+ 1);
7155 if (htab
->is_vxworks
)
7156 /* There's no need to allocate page entries for VxWorks; R_MIPS_GOT16
7157 relocations against local symbols evaluate to "G", and the EABI does
7158 not include R_MIPS_GOT_PAGE. */
7161 /* Assume there are two loadable segments consisting of contiguous
7162 sections. Is 5 enough? */
7163 local_gotno
= (loadable_size
>> 16) + 5;
7165 g
->local_gotno
+= local_gotno
;
7166 s
->size
+= g
->local_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
7168 g
->global_gotno
= i
;
7169 s
->size
+= i
* MIPS_ELF_GOT_SIZE (output_bfd
);
7171 /* We need to calculate tls_gotno for global symbols at this point
7172 instead of building it up earlier, to avoid doublecounting
7173 entries for one global symbol from multiple input files. */
7174 count_tls_arg
.info
= info
;
7175 count_tls_arg
.needed
= 0;
7176 elf_link_hash_traverse (elf_hash_table (info
),
7177 mips_elf_count_global_tls_entries
,
7179 g
->tls_gotno
+= count_tls_arg
.needed
;
7180 s
->size
+= g
->tls_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
7182 mips_elf_resolve_final_got_entries (g
);
7184 /* VxWorks does not support multiple GOTs. It initializes $gp to
7185 __GOTT_BASE__[__GOTT_INDEX__], the value of which is set by the
7187 if (!htab
->is_vxworks
&& s
->size
> MIPS_ELF_GOT_MAX_SIZE (info
))
7189 if (! mips_elf_multi_got (output_bfd
, info
, g
, s
, local_gotno
))
7194 /* Set up TLS entries for the first GOT. */
7195 g
->tls_assigned_gotno
= g
->global_gotno
+ g
->local_gotno
;
7196 htab_traverse (g
->got_entries
, mips_elf_initialize_tls_index
, g
);
7202 /* Set the sizes of the dynamic sections. */
7205 _bfd_mips_elf_size_dynamic_sections (bfd
*output_bfd
,
7206 struct bfd_link_info
*info
)
7209 asection
*s
, *sreldyn
;
7210 bfd_boolean reltext
;
7211 struct mips_elf_link_hash_table
*htab
;
7213 htab
= mips_elf_hash_table (info
);
7214 dynobj
= elf_hash_table (info
)->dynobj
;
7215 BFD_ASSERT (dynobj
!= NULL
);
7217 if (elf_hash_table (info
)->dynamic_sections_created
)
7219 /* Set the contents of the .interp section to the interpreter. */
7220 if (info
->executable
)
7222 s
= bfd_get_section_by_name (dynobj
, ".interp");
7223 BFD_ASSERT (s
!= NULL
);
7225 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd
)) + 1;
7227 = (bfd_byte
*) ELF_DYNAMIC_INTERPRETER (output_bfd
);
7231 /* The check_relocs and adjust_dynamic_symbol entry points have
7232 determined the sizes of the various dynamic sections. Allocate
7236 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
7240 /* It's OK to base decisions on the section name, because none
7241 of the dynobj section names depend upon the input files. */
7242 name
= bfd_get_section_name (dynobj
, s
);
7244 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
7247 if (strncmp (name
, ".rel", 4) == 0)
7251 const char *outname
;
7254 /* If this relocation section applies to a read only
7255 section, then we probably need a DT_TEXTREL entry.
7256 If the relocation section is .rel(a).dyn, we always
7257 assert a DT_TEXTREL entry rather than testing whether
7258 there exists a relocation to a read only section or
7260 outname
= bfd_get_section_name (output_bfd
,
7262 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
7264 && (target
->flags
& SEC_READONLY
) != 0
7265 && (target
->flags
& SEC_ALLOC
) != 0)
7266 || strcmp (outname
, MIPS_ELF_REL_DYN_NAME (info
)) == 0)
7269 /* We use the reloc_count field as a counter if we need
7270 to copy relocs into the output file. */
7271 if (strcmp (name
, MIPS_ELF_REL_DYN_NAME (info
)) != 0)
7274 /* If combreloc is enabled, elf_link_sort_relocs() will
7275 sort relocations, but in a different way than we do,
7276 and before we're done creating relocations. Also, it
7277 will move them around between input sections'
7278 relocation's contents, so our sorting would be
7279 broken, so don't let it run. */
7280 info
->combreloc
= 0;
7283 else if (htab
->is_vxworks
&& strcmp (name
, ".got") == 0)
7285 /* Executables do not need a GOT. */
7288 /* Allocate relocations for all but the reserved entries. */
7289 struct mips_got_info
*g
;
7292 g
= mips_elf_got_info (dynobj
, NULL
);
7293 count
= (g
->global_gotno
7295 - MIPS_RESERVED_GOTNO (info
));
7296 mips_elf_allocate_dynamic_relocations (dynobj
, info
, count
);
7299 else if (!htab
->is_vxworks
&& strncmp (name
, ".got", 4) == 0)
7301 /* _bfd_mips_elf_always_size_sections() has already done
7302 most of the work, but some symbols may have been mapped
7303 to versions that we must now resolve in the got_entries
7305 struct mips_got_info
*gg
= mips_elf_got_info (dynobj
, NULL
);
7306 struct mips_got_info
*g
= gg
;
7307 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
7308 unsigned int needed_relocs
= 0;
7312 set_got_offset_arg
.value
= MIPS_ELF_GOT_SIZE (output_bfd
);
7313 set_got_offset_arg
.info
= info
;
7315 /* NOTE 2005-02-03: How can this call, or the next, ever
7316 find any indirect entries to resolve? They were all
7317 resolved in mips_elf_multi_got. */
7318 mips_elf_resolve_final_got_entries (gg
);
7319 for (g
= gg
->next
; g
&& g
->next
!= gg
; g
= g
->next
)
7321 unsigned int save_assign
;
7323 mips_elf_resolve_final_got_entries (g
);
7325 /* Assign offsets to global GOT entries. */
7326 save_assign
= g
->assigned_gotno
;
7327 g
->assigned_gotno
= g
->local_gotno
;
7328 set_got_offset_arg
.g
= g
;
7329 set_got_offset_arg
.needed_relocs
= 0;
7330 htab_traverse (g
->got_entries
,
7331 mips_elf_set_global_got_offset
,
7332 &set_got_offset_arg
);
7333 needed_relocs
+= set_got_offset_arg
.needed_relocs
;
7334 BFD_ASSERT (g
->assigned_gotno
- g
->local_gotno
7335 <= g
->global_gotno
);
7337 g
->assigned_gotno
= save_assign
;
7340 needed_relocs
+= g
->local_gotno
- g
->assigned_gotno
;
7341 BFD_ASSERT (g
->assigned_gotno
== g
->next
->local_gotno
7342 + g
->next
->global_gotno
7343 + g
->next
->tls_gotno
7344 + MIPS_RESERVED_GOTNO (info
));
7350 struct mips_elf_count_tls_arg arg
;
7354 htab_traverse (gg
->got_entries
, mips_elf_count_local_tls_relocs
,
7356 elf_link_hash_traverse (elf_hash_table (info
),
7357 mips_elf_count_global_tls_relocs
,
7360 needed_relocs
+= arg
.needed
;
7364 mips_elf_allocate_dynamic_relocations (dynobj
, info
,
7367 else if (strcmp (name
, MIPS_ELF_STUB_SECTION_NAME (output_bfd
)) == 0)
7369 /* IRIX rld assumes that the function stub isn't at the end
7370 of .text section. So put a dummy. XXX */
7371 s
->size
+= MIPS_FUNCTION_STUB_SIZE (info
);
7373 else if (! info
->shared
7374 && ! mips_elf_hash_table (info
)->use_rld_obj_head
7375 && strncmp (name
, ".rld_map", 8) == 0)
7377 /* We add a room for __rld_map. It will be filled in by the
7378 rtld to contain a pointer to the _r_debug structure. */
7381 else if (SGI_COMPAT (output_bfd
)
7382 && strncmp (name
, ".compact_rel", 12) == 0)
7383 s
->size
+= mips_elf_hash_table (info
)->compact_rel_size
;
7384 else if (strncmp (name
, ".init", 5) != 0
7385 && s
!= htab
->sgotplt
7388 /* It's not one of our sections, so don't allocate space. */
7394 s
->flags
|= SEC_EXCLUDE
;
7398 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
7401 /* Allocate memory for this section last, since we may increase its
7403 if (strcmp (name
, MIPS_ELF_REL_DYN_NAME (info
)) == 0)
7409 /* Allocate memory for the section contents. */
7410 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
7411 if (s
->contents
== NULL
)
7413 bfd_set_error (bfd_error_no_memory
);
7418 /* Allocate memory for the .rel(a).dyn section. */
7419 if (sreldyn
!= NULL
)
7421 sreldyn
->contents
= bfd_zalloc (dynobj
, sreldyn
->size
);
7422 if (sreldyn
->contents
== NULL
)
7424 bfd_set_error (bfd_error_no_memory
);
7429 if (elf_hash_table (info
)->dynamic_sections_created
)
7431 /* Add some entries to the .dynamic section. We fill in the
7432 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
7433 must add the entries now so that we get the correct size for
7434 the .dynamic section. The DT_DEBUG entry is filled in by the
7435 dynamic linker and used by the debugger. */
7438 /* SGI object has the equivalence of DT_DEBUG in the
7439 DT_MIPS_RLD_MAP entry. */
7440 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_MAP
, 0))
7442 if (!SGI_COMPAT (output_bfd
))
7444 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
7450 /* Shared libraries on traditional mips have DT_DEBUG. */
7451 if (!SGI_COMPAT (output_bfd
))
7453 if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
7458 if (reltext
&& (SGI_COMPAT (output_bfd
) || htab
->is_vxworks
))
7459 info
->flags
|= DF_TEXTREL
;
7461 if ((info
->flags
& DF_TEXTREL
) != 0)
7463 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_TEXTREL
, 0))
7466 /* Clear the DF_TEXTREL flag. It will be set again if we
7467 write out an actual text relocation; we may not, because
7468 at this point we do not know whether e.g. any .eh_frame
7469 absolute relocations have been converted to PC-relative. */
7470 info
->flags
&= ~DF_TEXTREL
;
7473 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTGOT
, 0))
7476 if (htab
->is_vxworks
)
7478 /* VxWorks uses .rela.dyn instead of .rel.dyn. It does not
7479 use any of the DT_MIPS_* tags. */
7480 if (mips_elf_rel_dyn_section (info
, FALSE
))
7482 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELA
, 0))
7485 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELASZ
, 0))
7488 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELAENT
, 0))
7491 if (htab
->splt
->size
> 0)
7493 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTREL
, 0))
7496 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_JMPREL
, 0))
7499 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTRELSZ
, 0))
7505 if (mips_elf_rel_dyn_section (info
, FALSE
))
7507 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_REL
, 0))
7510 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELSZ
, 0))
7513 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELENT
, 0))
7517 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_VERSION
, 0))
7520 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_FLAGS
, 0))
7523 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_BASE_ADDRESS
, 0))
7526 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LOCAL_GOTNO
, 0))
7529 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_SYMTABNO
, 0))
7532 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_UNREFEXTNO
, 0))
7535 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_GOTSYM
, 0))
7538 if (IRIX_COMPAT (dynobj
) == ict_irix5
7539 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_HIPAGENO
, 0))
7542 if (IRIX_COMPAT (dynobj
) == ict_irix6
7543 && (bfd_get_section_by_name
7544 (dynobj
, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj
)))
7545 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_OPTIONS
, 0))
7553 /* REL is a relocation in INPUT_BFD that is being copied to OUTPUT_BFD.
7554 Adjust its R_ADDEND field so that it is correct for the output file.
7555 LOCAL_SYMS and LOCAL_SECTIONS are arrays of INPUT_BFD's local symbols
7556 and sections respectively; both use symbol indexes. */
7559 mips_elf_adjust_addend (bfd
*output_bfd
, struct bfd_link_info
*info
,
7560 bfd
*input_bfd
, Elf_Internal_Sym
*local_syms
,
7561 asection
**local_sections
, Elf_Internal_Rela
*rel
)
7563 unsigned int r_type
, r_symndx
;
7564 Elf_Internal_Sym
*sym
;
7567 if (mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
, FALSE
))
7569 r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
7570 if (r_type
== R_MIPS16_GPREL
7571 || r_type
== R_MIPS_GPREL16
7572 || r_type
== R_MIPS_GPREL32
7573 || r_type
== R_MIPS_LITERAL
)
7575 rel
->r_addend
+= _bfd_get_gp_value (input_bfd
);
7576 rel
->r_addend
-= _bfd_get_gp_value (output_bfd
);
7579 r_symndx
= ELF_R_SYM (output_bfd
, rel
->r_info
);
7580 sym
= local_syms
+ r_symndx
;
7582 /* Adjust REL's addend to account for section merging. */
7583 if (!info
->relocatable
)
7585 sec
= local_sections
[r_symndx
];
7586 _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
7589 /* This would normally be done by the rela_normal code in elflink.c. */
7590 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
7591 rel
->r_addend
+= local_sections
[r_symndx
]->output_offset
;
7595 /* Relocate a MIPS ELF section. */
7598 _bfd_mips_elf_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
7599 bfd
*input_bfd
, asection
*input_section
,
7600 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
7601 Elf_Internal_Sym
*local_syms
,
7602 asection
**local_sections
)
7604 Elf_Internal_Rela
*rel
;
7605 const Elf_Internal_Rela
*relend
;
7607 bfd_boolean use_saved_addend_p
= FALSE
;
7608 const struct elf_backend_data
*bed
;
7610 bed
= get_elf_backend_data (output_bfd
);
7611 relend
= relocs
+ input_section
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
7612 for (rel
= relocs
; rel
< relend
; ++rel
)
7616 reloc_howto_type
*howto
;
7617 bfd_boolean require_jalx
;
7618 /* TRUE if the relocation is a RELA relocation, rather than a
7620 bfd_boolean rela_relocation_p
= TRUE
;
7621 unsigned int r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
7624 /* Find the relocation howto for this relocation. */
7625 if (r_type
== R_MIPS_64
&& ! NEWABI_P (input_bfd
))
7627 /* Some 32-bit code uses R_MIPS_64. In particular, people use
7628 64-bit code, but make sure all their addresses are in the
7629 lowermost or uppermost 32-bit section of the 64-bit address
7630 space. Thus, when they use an R_MIPS_64 they mean what is
7631 usually meant by R_MIPS_32, with the exception that the
7632 stored value is sign-extended to 64 bits. */
7633 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, R_MIPS_32
, FALSE
);
7635 /* On big-endian systems, we need to lie about the position
7637 if (bfd_big_endian (input_bfd
))
7641 /* NewABI defaults to RELA relocations. */
7642 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, r_type
,
7643 NEWABI_P (input_bfd
)
7644 && (MIPS_RELOC_RELA_P
7645 (input_bfd
, input_section
,
7648 if (!use_saved_addend_p
)
7650 Elf_Internal_Shdr
*rel_hdr
;
7652 /* If these relocations were originally of the REL variety,
7653 we must pull the addend out of the field that will be
7654 relocated. Otherwise, we simply use the contents of the
7655 RELA relocation. To determine which flavor or relocation
7656 this is, we depend on the fact that the INPUT_SECTION's
7657 REL_HDR is read before its REL_HDR2. */
7658 rel_hdr
= &elf_section_data (input_section
)->rel_hdr
;
7659 if ((size_t) (rel
- relocs
)
7660 >= (NUM_SHDR_ENTRIES (rel_hdr
) * bed
->s
->int_rels_per_ext_rel
))
7661 rel_hdr
= elf_section_data (input_section
)->rel_hdr2
;
7662 if (rel_hdr
->sh_entsize
== MIPS_ELF_REL_SIZE (input_bfd
))
7664 bfd_byte
*location
= contents
+ rel
->r_offset
;
7666 /* Note that this is a REL relocation. */
7667 rela_relocation_p
= FALSE
;
7669 /* Get the addend, which is stored in the input file. */
7670 _bfd_mips16_elf_reloc_unshuffle (input_bfd
, r_type
, FALSE
,
7672 addend
= mips_elf_obtain_contents (howto
, rel
, input_bfd
,
7674 _bfd_mips16_elf_reloc_shuffle(input_bfd
, r_type
, FALSE
,
7677 addend
&= howto
->src_mask
;
7679 /* For some kinds of relocations, the ADDEND is a
7680 combination of the addend stored in two different
7682 if (r_type
== R_MIPS_HI16
|| r_type
== R_MIPS16_HI16
7683 || (r_type
== R_MIPS_GOT16
7684 && mips_elf_local_relocation_p (input_bfd
, rel
,
7685 local_sections
, FALSE
)))
7688 const Elf_Internal_Rela
*lo16_relocation
;
7689 reloc_howto_type
*lo16_howto
;
7690 bfd_byte
*lo16_location
;
7693 if (r_type
== R_MIPS16_HI16
)
7694 lo16_type
= R_MIPS16_LO16
;
7696 lo16_type
= R_MIPS_LO16
;
7698 /* The combined value is the sum of the HI16 addend,
7699 left-shifted by sixteen bits, and the LO16
7700 addend, sign extended. (Usually, the code does
7701 a `lui' of the HI16 value, and then an `addiu' of
7704 Scan ahead to find a matching LO16 relocation.
7706 According to the MIPS ELF ABI, the R_MIPS_LO16
7707 relocation must be immediately following.
7708 However, for the IRIX6 ABI, the next relocation
7709 may be a composed relocation consisting of
7710 several relocations for the same address. In
7711 that case, the R_MIPS_LO16 relocation may occur
7712 as one of these. We permit a similar extension
7713 in general, as that is useful for GCC. */
7714 lo16_relocation
= mips_elf_next_relocation (input_bfd
,
7717 if (lo16_relocation
== NULL
)
7720 lo16_location
= contents
+ lo16_relocation
->r_offset
;
7722 /* Obtain the addend kept there. */
7723 lo16_howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
,
7725 _bfd_mips16_elf_reloc_unshuffle (input_bfd
, lo16_type
, FALSE
,
7727 l
= mips_elf_obtain_contents (lo16_howto
, lo16_relocation
,
7728 input_bfd
, contents
);
7729 _bfd_mips16_elf_reloc_shuffle (input_bfd
, lo16_type
, FALSE
,
7731 l
&= lo16_howto
->src_mask
;
7732 l
<<= lo16_howto
->rightshift
;
7733 l
= _bfd_mips_elf_sign_extend (l
, 16);
7737 /* Compute the combined addend. */
7741 addend
<<= howto
->rightshift
;
7744 addend
= rel
->r_addend
;
7745 mips_elf_adjust_addend (output_bfd
, info
, input_bfd
,
7746 local_syms
, local_sections
, rel
);
7749 if (info
->relocatable
)
7751 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
)
7752 && bfd_big_endian (input_bfd
))
7755 if (!rela_relocation_p
&& rel
->r_addend
)
7757 addend
+= rel
->r_addend
;
7758 if (r_type
== R_MIPS_HI16
7759 || r_type
== R_MIPS_GOT16
)
7760 addend
= mips_elf_high (addend
);
7761 else if (r_type
== R_MIPS_HIGHER
)
7762 addend
= mips_elf_higher (addend
);
7763 else if (r_type
== R_MIPS_HIGHEST
)
7764 addend
= mips_elf_highest (addend
);
7766 addend
>>= howto
->rightshift
;
7768 /* We use the source mask, rather than the destination
7769 mask because the place to which we are writing will be
7770 source of the addend in the final link. */
7771 addend
&= howto
->src_mask
;
7773 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
7774 /* See the comment above about using R_MIPS_64 in the 32-bit
7775 ABI. Here, we need to update the addend. It would be
7776 possible to get away with just using the R_MIPS_32 reloc
7777 but for endianness. */
7783 if (addend
& ((bfd_vma
) 1 << 31))
7785 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
7792 /* If we don't know that we have a 64-bit type,
7793 do two separate stores. */
7794 if (bfd_big_endian (input_bfd
))
7796 /* Store the sign-bits (which are most significant)
7798 low_bits
= sign_bits
;
7804 high_bits
= sign_bits
;
7806 bfd_put_32 (input_bfd
, low_bits
,
7807 contents
+ rel
->r_offset
);
7808 bfd_put_32 (input_bfd
, high_bits
,
7809 contents
+ rel
->r_offset
+ 4);
7813 if (! mips_elf_perform_relocation (info
, howto
, rel
, addend
,
7814 input_bfd
, input_section
,
7819 /* Go on to the next relocation. */
7823 /* In the N32 and 64-bit ABIs there may be multiple consecutive
7824 relocations for the same offset. In that case we are
7825 supposed to treat the output of each relocation as the addend
7827 if (rel
+ 1 < relend
7828 && rel
->r_offset
== rel
[1].r_offset
7829 && ELF_R_TYPE (input_bfd
, rel
[1].r_info
) != R_MIPS_NONE
)
7830 use_saved_addend_p
= TRUE
;
7832 use_saved_addend_p
= FALSE
;
7834 /* Figure out what value we are supposed to relocate. */
7835 switch (mips_elf_calculate_relocation (output_bfd
, input_bfd
,
7836 input_section
, info
, rel
,
7837 addend
, howto
, local_syms
,
7838 local_sections
, &value
,
7839 &name
, &require_jalx
,
7840 use_saved_addend_p
))
7842 case bfd_reloc_continue
:
7843 /* There's nothing to do. */
7846 case bfd_reloc_undefined
:
7847 /* mips_elf_calculate_relocation already called the
7848 undefined_symbol callback. There's no real point in
7849 trying to perform the relocation at this point, so we
7850 just skip ahead to the next relocation. */
7853 case bfd_reloc_notsupported
:
7854 msg
= _("internal error: unsupported relocation error");
7855 info
->callbacks
->warning
7856 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
7859 case bfd_reloc_overflow
:
7860 if (use_saved_addend_p
)
7861 /* Ignore overflow until we reach the last relocation for
7862 a given location. */
7866 BFD_ASSERT (name
!= NULL
);
7867 if (! ((*info
->callbacks
->reloc_overflow
)
7868 (info
, NULL
, name
, howto
->name
, (bfd_vma
) 0,
7869 input_bfd
, input_section
, rel
->r_offset
)))
7882 /* If we've got another relocation for the address, keep going
7883 until we reach the last one. */
7884 if (use_saved_addend_p
)
7890 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
7891 /* See the comment above about using R_MIPS_64 in the 32-bit
7892 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
7893 that calculated the right value. Now, however, we
7894 sign-extend the 32-bit result to 64-bits, and store it as a
7895 64-bit value. We are especially generous here in that we
7896 go to extreme lengths to support this usage on systems with
7897 only a 32-bit VMA. */
7903 if (value
& ((bfd_vma
) 1 << 31))
7905 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
7912 /* If we don't know that we have a 64-bit type,
7913 do two separate stores. */
7914 if (bfd_big_endian (input_bfd
))
7916 /* Undo what we did above. */
7918 /* Store the sign-bits (which are most significant)
7920 low_bits
= sign_bits
;
7926 high_bits
= sign_bits
;
7928 bfd_put_32 (input_bfd
, low_bits
,
7929 contents
+ rel
->r_offset
);
7930 bfd_put_32 (input_bfd
, high_bits
,
7931 contents
+ rel
->r_offset
+ 4);
7935 /* Actually perform the relocation. */
7936 if (! mips_elf_perform_relocation (info
, howto
, rel
, value
,
7937 input_bfd
, input_section
,
7938 contents
, require_jalx
))
7945 /* If NAME is one of the special IRIX6 symbols defined by the linker,
7946 adjust it appropriately now. */
7949 mips_elf_irix6_finish_dynamic_symbol (bfd
*abfd ATTRIBUTE_UNUSED
,
7950 const char *name
, Elf_Internal_Sym
*sym
)
7952 /* The linker script takes care of providing names and values for
7953 these, but we must place them into the right sections. */
7954 static const char* const text_section_symbols
[] = {
7957 "__dso_displacement",
7959 "__program_header_table",
7963 static const char* const data_section_symbols
[] = {
7971 const char* const *p
;
7974 for (i
= 0; i
< 2; ++i
)
7975 for (p
= (i
== 0) ? text_section_symbols
: data_section_symbols
;
7978 if (strcmp (*p
, name
) == 0)
7980 /* All of these symbols are given type STT_SECTION by the
7982 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
7983 sym
->st_other
= STO_PROTECTED
;
7985 /* The IRIX linker puts these symbols in special sections. */
7987 sym
->st_shndx
= SHN_MIPS_TEXT
;
7989 sym
->st_shndx
= SHN_MIPS_DATA
;
7995 /* Finish up dynamic symbol handling. We set the contents of various
7996 dynamic sections here. */
7999 _bfd_mips_elf_finish_dynamic_symbol (bfd
*output_bfd
,
8000 struct bfd_link_info
*info
,
8001 struct elf_link_hash_entry
*h
,
8002 Elf_Internal_Sym
*sym
)
8006 struct mips_got_info
*g
, *gg
;
8010 dynobj
= elf_hash_table (info
)->dynobj
;
8012 if (h
->plt
.offset
!= MINUS_ONE
)
8015 bfd_byte stub
[MIPS_FUNCTION_STUB_MAX_SIZE
];
8017 /* This symbol has a stub. Set it up. */
8019 BFD_ASSERT (h
->dynindx
!= -1);
8021 s
= bfd_get_section_by_name (dynobj
,
8022 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
8023 BFD_ASSERT (s
!= NULL
);
8025 BFD_ASSERT ((MIPS_FUNCTION_STUB_SIZE (info
) == 20)
8026 || (h
->dynindx
<= 65536));
8028 /* Values up to 2^31 - 1 are allowed. Larger values would cause
8029 sign extension at runtime in the stub, resulting in a
8030 negative index value. */
8031 if (h
->dynindx
& 0x80000000)
8034 /* Fill the stub. */
8036 bfd_put_32 (output_bfd
, STUB_LW (output_bfd
), stub
+ idx
);
8038 bfd_put_32 (output_bfd
, STUB_MOVE (output_bfd
), stub
+ idx
);
8040 if (MIPS_FUNCTION_STUB_SIZE (info
) == 20)
8042 bfd_put_32 (output_bfd
, STUB_LUI ((h
->dynindx
>> 16 ) & 0xffff),
8046 bfd_put_32 (output_bfd
, STUB_JALR
, stub
+ idx
);
8049 /* If a large stub is not required and sign extension is not a
8050 problem, then use legacy code in the stub. */
8051 if ((MIPS_FUNCTION_STUB_SIZE (info
) == 20) || (h
->dynindx
& 0xffff8000))
8052 bfd_put_32 (output_bfd
, STUB_LI16U (h
->dynindx
& 0xffff), stub
+ idx
);
8054 bfd_put_32 (output_bfd
,
8055 STUB_LI16S (output_bfd
, h
->dynindx
& 0xffff), stub
+ idx
);
8057 BFD_ASSERT (h
->plt
.offset
<= s
->size
);
8058 memcpy (s
->contents
+ h
->plt
.offset
,
8059 stub
, MIPS_FUNCTION_STUB_SIZE (info
));
8061 /* Mark the symbol as undefined. plt.offset != -1 occurs
8062 only for the referenced symbol. */
8063 sym
->st_shndx
= SHN_UNDEF
;
8065 /* The run-time linker uses the st_value field of the symbol
8066 to reset the global offset table entry for this external
8067 to its stub address when unlinking a shared object. */
8068 sym
->st_value
= (s
->output_section
->vma
+ s
->output_offset
8072 BFD_ASSERT (h
->dynindx
!= -1
8073 || h
->forced_local
);
8075 sgot
= mips_elf_got_section (dynobj
, FALSE
);
8076 BFD_ASSERT (sgot
!= NULL
);
8077 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
8078 g
= mips_elf_section_data (sgot
)->u
.got_info
;
8079 BFD_ASSERT (g
!= NULL
);
8081 /* Run through the global symbol table, creating GOT entries for all
8082 the symbols that need them. */
8083 if (g
->global_gotsym
!= NULL
8084 && h
->dynindx
>= g
->global_gotsym
->dynindx
)
8089 value
= sym
->st_value
;
8090 offset
= mips_elf_global_got_index (dynobj
, output_bfd
, h
, R_MIPS_GOT16
, info
);
8091 MIPS_ELF_PUT_WORD (output_bfd
, value
, sgot
->contents
+ offset
);
8094 if (g
->next
&& h
->dynindx
!= -1 && h
->type
!= STT_TLS
)
8096 struct mips_got_entry e
, *p
;
8102 e
.abfd
= output_bfd
;
8104 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
8107 for (g
= g
->next
; g
->next
!= gg
; g
= g
->next
)
8110 && (p
= (struct mips_got_entry
*) htab_find (g
->got_entries
,
8115 || (elf_hash_table (info
)->dynamic_sections_created
8117 && p
->d
.h
->root
.def_dynamic
8118 && !p
->d
.h
->root
.def_regular
))
8120 /* Create an R_MIPS_REL32 relocation for this entry. Due to
8121 the various compatibility problems, it's easier to mock
8122 up an R_MIPS_32 or R_MIPS_64 relocation and leave
8123 mips_elf_create_dynamic_relocation to calculate the
8124 appropriate addend. */
8125 Elf_Internal_Rela rel
[3];
8127 memset (rel
, 0, sizeof (rel
));
8128 if (ABI_64_P (output_bfd
))
8129 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_64
);
8131 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_32
);
8132 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
8135 if (! (mips_elf_create_dynamic_relocation
8136 (output_bfd
, info
, rel
,
8137 e
.d
.h
, NULL
, sym
->st_value
, &entry
, sgot
)))
8141 entry
= sym
->st_value
;
8142 MIPS_ELF_PUT_WORD (output_bfd
, entry
, sgot
->contents
+ offset
);
8147 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
8148 name
= h
->root
.root
.string
;
8149 if (strcmp (name
, "_DYNAMIC") == 0
8150 || h
== elf_hash_table (info
)->hgot
)
8151 sym
->st_shndx
= SHN_ABS
;
8152 else if (strcmp (name
, "_DYNAMIC_LINK") == 0
8153 || strcmp (name
, "_DYNAMIC_LINKING") == 0)
8155 sym
->st_shndx
= SHN_ABS
;
8156 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8159 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (output_bfd
))
8161 sym
->st_shndx
= SHN_ABS
;
8162 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8163 sym
->st_value
= elf_gp (output_bfd
);
8165 else if (SGI_COMPAT (output_bfd
))
8167 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
8168 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
8170 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8171 sym
->st_other
= STO_PROTECTED
;
8173 sym
->st_shndx
= SHN_MIPS_DATA
;
8175 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
8177 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8178 sym
->st_other
= STO_PROTECTED
;
8179 sym
->st_value
= mips_elf_hash_table (info
)->procedure_count
;
8180 sym
->st_shndx
= SHN_ABS
;
8182 else if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
!= SHN_ABS
)
8184 if (h
->type
== STT_FUNC
)
8185 sym
->st_shndx
= SHN_MIPS_TEXT
;
8186 else if (h
->type
== STT_OBJECT
)
8187 sym
->st_shndx
= SHN_MIPS_DATA
;
8191 /* Handle the IRIX6-specific symbols. */
8192 if (IRIX_COMPAT (output_bfd
) == ict_irix6
)
8193 mips_elf_irix6_finish_dynamic_symbol (output_bfd
, name
, sym
);
8197 if (! mips_elf_hash_table (info
)->use_rld_obj_head
8198 && (strcmp (name
, "__rld_map") == 0
8199 || strcmp (name
, "__RLD_MAP") == 0))
8201 asection
*s
= bfd_get_section_by_name (dynobj
, ".rld_map");
8202 BFD_ASSERT (s
!= NULL
);
8203 sym
->st_value
= s
->output_section
->vma
+ s
->output_offset
;
8204 bfd_put_32 (output_bfd
, 0, s
->contents
);
8205 if (mips_elf_hash_table (info
)->rld_value
== 0)
8206 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
8208 else if (mips_elf_hash_table (info
)->use_rld_obj_head
8209 && strcmp (name
, "__rld_obj_head") == 0)
8211 /* IRIX6 does not use a .rld_map section. */
8212 if (IRIX_COMPAT (output_bfd
) == ict_irix5
8213 || IRIX_COMPAT (output_bfd
) == ict_none
)
8214 BFD_ASSERT (bfd_get_section_by_name (dynobj
, ".rld_map")
8216 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
8220 /* If this is a mips16 symbol, force the value to be even. */
8221 if (sym
->st_other
== STO_MIPS16
)
8222 sym
->st_value
&= ~1;
8227 /* Likewise, for VxWorks. */
8230 _bfd_mips_vxworks_finish_dynamic_symbol (bfd
*output_bfd
,
8231 struct bfd_link_info
*info
,
8232 struct elf_link_hash_entry
*h
,
8233 Elf_Internal_Sym
*sym
)
8237 struct mips_got_info
*g
;
8238 struct mips_elf_link_hash_table
*htab
;
8240 htab
= mips_elf_hash_table (info
);
8241 dynobj
= elf_hash_table (info
)->dynobj
;
8243 if (h
->plt
.offset
!= (bfd_vma
) -1)
8246 bfd_vma plt_address
, plt_index
, got_address
, got_offset
, branch_offset
;
8247 Elf_Internal_Rela rel
;
8248 static const bfd_vma
*plt_entry
;
8250 BFD_ASSERT (h
->dynindx
!= -1);
8251 BFD_ASSERT (htab
->splt
!= NULL
);
8252 BFD_ASSERT (h
->plt
.offset
<= htab
->splt
->size
);
8254 /* Calculate the address of the .plt entry. */
8255 plt_address
= (htab
->splt
->output_section
->vma
8256 + htab
->splt
->output_offset
8259 /* Calculate the index of the entry. */
8260 plt_index
= ((h
->plt
.offset
- htab
->plt_header_size
)
8261 / htab
->plt_entry_size
);
8263 /* Calculate the address of the .got.plt entry. */
8264 got_address
= (htab
->sgotplt
->output_section
->vma
8265 + htab
->sgotplt
->output_offset
8268 /* Calculate the offset of the .got.plt entry from
8269 _GLOBAL_OFFSET_TABLE_. */
8270 got_offset
= mips_elf_gotplt_index (info
, h
);
8272 /* Calculate the offset for the branch at the start of the PLT
8273 entry. The branch jumps to the beginning of .plt. */
8274 branch_offset
= -(h
->plt
.offset
/ 4 + 1) & 0xffff;
8276 /* Fill in the initial value of the .got.plt entry. */
8277 bfd_put_32 (output_bfd
, plt_address
,
8278 htab
->sgotplt
->contents
+ plt_index
* 4);
8280 /* Find out where the .plt entry should go. */
8281 loc
= htab
->splt
->contents
+ h
->plt
.offset
;
8285 plt_entry
= mips_vxworks_shared_plt_entry
;
8286 bfd_put_32 (output_bfd
, plt_entry
[0] | branch_offset
, loc
);
8287 bfd_put_32 (output_bfd
, plt_entry
[1] | plt_index
, loc
+ 4);
8291 bfd_vma got_address_high
, got_address_low
;
8293 plt_entry
= mips_vxworks_exec_plt_entry
;
8294 got_address_high
= ((got_address
+ 0x8000) >> 16) & 0xffff;
8295 got_address_low
= got_address
& 0xffff;
8297 bfd_put_32 (output_bfd
, plt_entry
[0] | branch_offset
, loc
);
8298 bfd_put_32 (output_bfd
, plt_entry
[1] | plt_index
, loc
+ 4);
8299 bfd_put_32 (output_bfd
, plt_entry
[2] | got_address_high
, loc
+ 8);
8300 bfd_put_32 (output_bfd
, plt_entry
[3] | got_address_low
, loc
+ 12);
8301 bfd_put_32 (output_bfd
, plt_entry
[4], loc
+ 16);
8302 bfd_put_32 (output_bfd
, plt_entry
[5], loc
+ 20);
8303 bfd_put_32 (output_bfd
, plt_entry
[6], loc
+ 24);
8304 bfd_put_32 (output_bfd
, plt_entry
[7], loc
+ 28);
8306 loc
= (htab
->srelplt2
->contents
8307 + (plt_index
* 3 + 2) * sizeof (Elf32_External_Rela
));
8309 /* Emit a relocation for the .got.plt entry. */
8310 rel
.r_offset
= got_address
;
8311 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
, R_MIPS_32
);
8312 rel
.r_addend
= h
->plt
.offset
;
8313 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
8315 /* Emit a relocation for the lui of %hi(<.got.plt slot>). */
8316 loc
+= sizeof (Elf32_External_Rela
);
8317 rel
.r_offset
= plt_address
+ 8;
8318 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_HI16
);
8319 rel
.r_addend
= got_offset
;
8320 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
8322 /* Emit a relocation for the addiu of %lo(<.got.plt slot>). */
8323 loc
+= sizeof (Elf32_External_Rela
);
8325 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_LO16
);
8326 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
8329 /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry. */
8330 loc
= htab
->srelplt
->contents
+ plt_index
* sizeof (Elf32_External_Rela
);
8331 rel
.r_offset
= got_address
;
8332 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_JUMP_SLOT
);
8334 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
8336 if (!h
->def_regular
)
8337 sym
->st_shndx
= SHN_UNDEF
;
8340 BFD_ASSERT (h
->dynindx
!= -1 || h
->forced_local
);
8342 sgot
= mips_elf_got_section (dynobj
, FALSE
);
8343 BFD_ASSERT (sgot
!= NULL
);
8344 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
8345 g
= mips_elf_section_data (sgot
)->u
.got_info
;
8346 BFD_ASSERT (g
!= NULL
);
8348 /* See if this symbol has an entry in the GOT. */
8349 if (g
->global_gotsym
!= NULL
8350 && h
->dynindx
>= g
->global_gotsym
->dynindx
)
8353 Elf_Internal_Rela outrel
;
8357 /* Install the symbol value in the GOT. */
8358 offset
= mips_elf_global_got_index (dynobj
, output_bfd
, h
,
8359 R_MIPS_GOT16
, info
);
8360 MIPS_ELF_PUT_WORD (output_bfd
, sym
->st_value
, sgot
->contents
+ offset
);
8362 /* Add a dynamic relocation for it. */
8363 s
= mips_elf_rel_dyn_section (info
, FALSE
);
8364 loc
= s
->contents
+ (s
->reloc_count
++ * sizeof (Elf32_External_Rela
));
8365 outrel
.r_offset
= (sgot
->output_section
->vma
8366 + sgot
->output_offset
8368 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_32
);
8369 outrel
.r_addend
= 0;
8370 bfd_elf32_swap_reloca_out (dynobj
, &outrel
, loc
);
8373 /* Emit a copy reloc, if needed. */
8376 Elf_Internal_Rela rel
;
8378 BFD_ASSERT (h
->dynindx
!= -1);
8380 rel
.r_offset
= (h
->root
.u
.def
.section
->output_section
->vma
8381 + h
->root
.u
.def
.section
->output_offset
8382 + h
->root
.u
.def
.value
);
8383 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_COPY
);
8385 bfd_elf32_swap_reloca_out (output_bfd
, &rel
,
8386 htab
->srelbss
->contents
8387 + (htab
->srelbss
->reloc_count
8388 * sizeof (Elf32_External_Rela
)));
8389 ++htab
->srelbss
->reloc_count
;
8392 /* If this is a mips16 symbol, force the value to be even. */
8393 if (sym
->st_other
== STO_MIPS16
)
8394 sym
->st_value
&= ~1;
8399 /* Install the PLT header for a VxWorks executable and finalize the
8400 contents of .rela.plt.unloaded. */
8403 mips_vxworks_finish_exec_plt (bfd
*output_bfd
, struct bfd_link_info
*info
)
8405 Elf_Internal_Rela rela
;
8407 bfd_vma got_value
, got_value_high
, got_value_low
, plt_address
;
8408 static const bfd_vma
*plt_entry
;
8409 struct mips_elf_link_hash_table
*htab
;
8411 htab
= mips_elf_hash_table (info
);
8412 plt_entry
= mips_vxworks_exec_plt0_entry
;
8414 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */
8415 got_value
= (htab
->root
.hgot
->root
.u
.def
.section
->output_section
->vma
8416 + htab
->root
.hgot
->root
.u
.def
.section
->output_offset
8417 + htab
->root
.hgot
->root
.u
.def
.value
);
8419 got_value_high
= ((got_value
+ 0x8000) >> 16) & 0xffff;
8420 got_value_low
= got_value
& 0xffff;
8422 /* Calculate the address of the PLT header. */
8423 plt_address
= htab
->splt
->output_section
->vma
+ htab
->splt
->output_offset
;
8425 /* Install the PLT header. */
8426 loc
= htab
->splt
->contents
;
8427 bfd_put_32 (output_bfd
, plt_entry
[0] | got_value_high
, loc
);
8428 bfd_put_32 (output_bfd
, plt_entry
[1] | got_value_low
, loc
+ 4);
8429 bfd_put_32 (output_bfd
, plt_entry
[2], loc
+ 8);
8430 bfd_put_32 (output_bfd
, plt_entry
[3], loc
+ 12);
8431 bfd_put_32 (output_bfd
, plt_entry
[4], loc
+ 16);
8432 bfd_put_32 (output_bfd
, plt_entry
[5], loc
+ 20);
8434 /* Output the relocation for the lui of %hi(_GLOBAL_OFFSET_TABLE_). */
8435 loc
= htab
->srelplt2
->contents
;
8436 rela
.r_offset
= plt_address
;
8437 rela
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_HI16
);
8439 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
8440 loc
+= sizeof (Elf32_External_Rela
);
8442 /* Output the relocation for the following addiu of
8443 %lo(_GLOBAL_OFFSET_TABLE_). */
8445 rela
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_LO16
);
8446 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
8447 loc
+= sizeof (Elf32_External_Rela
);
8449 /* Fix up the remaining relocations. They may have the wrong
8450 symbol index for _G_O_T_ or _P_L_T_ depending on the order
8451 in which symbols were output. */
8452 while (loc
< htab
->srelplt2
->contents
+ htab
->srelplt2
->size
)
8454 Elf_Internal_Rela rel
;
8456 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &rel
);
8457 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
, R_MIPS_32
);
8458 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
8459 loc
+= sizeof (Elf32_External_Rela
);
8461 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &rel
);
8462 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_HI16
);
8463 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
8464 loc
+= sizeof (Elf32_External_Rela
);
8466 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &rel
);
8467 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_LO16
);
8468 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
8469 loc
+= sizeof (Elf32_External_Rela
);
8473 /* Install the PLT header for a VxWorks shared library. */
8476 mips_vxworks_finish_shared_plt (bfd
*output_bfd
, struct bfd_link_info
*info
)
8479 struct mips_elf_link_hash_table
*htab
;
8481 htab
= mips_elf_hash_table (info
);
8483 /* We just need to copy the entry byte-by-byte. */
8484 for (i
= 0; i
< ARRAY_SIZE (mips_vxworks_shared_plt0_entry
); i
++)
8485 bfd_put_32 (output_bfd
, mips_vxworks_shared_plt0_entry
[i
],
8486 htab
->splt
->contents
+ i
* 4);
8489 /* Finish up the dynamic sections. */
8492 _bfd_mips_elf_finish_dynamic_sections (bfd
*output_bfd
,
8493 struct bfd_link_info
*info
)
8498 struct mips_got_info
*gg
, *g
;
8499 struct mips_elf_link_hash_table
*htab
;
8501 htab
= mips_elf_hash_table (info
);
8502 dynobj
= elf_hash_table (info
)->dynobj
;
8504 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
8506 sgot
= mips_elf_got_section (dynobj
, FALSE
);
8511 BFD_ASSERT (mips_elf_section_data (sgot
) != NULL
);
8512 gg
= mips_elf_section_data (sgot
)->u
.got_info
;
8513 BFD_ASSERT (gg
!= NULL
);
8514 g
= mips_elf_got_for_ibfd (gg
, output_bfd
);
8515 BFD_ASSERT (g
!= NULL
);
8518 if (elf_hash_table (info
)->dynamic_sections_created
)
8521 int dyn_to_skip
= 0, dyn_skipped
= 0;
8523 BFD_ASSERT (sdyn
!= NULL
);
8524 BFD_ASSERT (g
!= NULL
);
8526 for (b
= sdyn
->contents
;
8527 b
< sdyn
->contents
+ sdyn
->size
;
8528 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
8530 Elf_Internal_Dyn dyn
;
8534 bfd_boolean swap_out_p
;
8536 /* Read in the current dynamic entry. */
8537 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
8539 /* Assume that we're going to modify it and write it out. */
8545 dyn
.d_un
.d_val
= MIPS_ELF_REL_SIZE (dynobj
);
8549 BFD_ASSERT (htab
->is_vxworks
);
8550 dyn
.d_un
.d_val
= MIPS_ELF_RELA_SIZE (dynobj
);
8554 /* Rewrite DT_STRSZ. */
8556 _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
8561 if (htab
->is_vxworks
)
8563 /* _GLOBAL_OFFSET_TABLE_ is defined to be the beginning
8564 of the ".got" section in DYNOBJ. */
8565 s
= bfd_get_section_by_name (dynobj
, name
);
8566 BFD_ASSERT (s
!= NULL
);
8567 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
8571 s
= bfd_get_section_by_name (output_bfd
, name
);
8572 BFD_ASSERT (s
!= NULL
);
8573 dyn
.d_un
.d_ptr
= s
->vma
;
8577 case DT_MIPS_RLD_VERSION
:
8578 dyn
.d_un
.d_val
= 1; /* XXX */
8582 dyn
.d_un
.d_val
= RHF_NOTPOT
; /* XXX */
8585 case DT_MIPS_TIME_STAMP
:
8593 case DT_MIPS_ICHECKSUM
:
8598 case DT_MIPS_IVERSION
:
8603 case DT_MIPS_BASE_ADDRESS
:
8604 s
= output_bfd
->sections
;
8605 BFD_ASSERT (s
!= NULL
);
8606 dyn
.d_un
.d_ptr
= s
->vma
& ~(bfd_vma
) 0xffff;
8609 case DT_MIPS_LOCAL_GOTNO
:
8610 dyn
.d_un
.d_val
= g
->local_gotno
;
8613 case DT_MIPS_UNREFEXTNO
:
8614 /* The index into the dynamic symbol table which is the
8615 entry of the first external symbol that is not
8616 referenced within the same object. */
8617 dyn
.d_un
.d_val
= bfd_count_sections (output_bfd
) + 1;
8620 case DT_MIPS_GOTSYM
:
8621 if (gg
->global_gotsym
)
8623 dyn
.d_un
.d_val
= gg
->global_gotsym
->dynindx
;
8626 /* In case if we don't have global got symbols we default
8627 to setting DT_MIPS_GOTSYM to the same value as
8628 DT_MIPS_SYMTABNO, so we just fall through. */
8630 case DT_MIPS_SYMTABNO
:
8632 elemsize
= MIPS_ELF_SYM_SIZE (output_bfd
);
8633 s
= bfd_get_section_by_name (output_bfd
, name
);
8634 BFD_ASSERT (s
!= NULL
);
8636 dyn
.d_un
.d_val
= s
->size
/ elemsize
;
8639 case DT_MIPS_HIPAGENO
:
8640 dyn
.d_un
.d_val
= g
->local_gotno
- MIPS_RESERVED_GOTNO (info
);
8643 case DT_MIPS_RLD_MAP
:
8644 dyn
.d_un
.d_ptr
= mips_elf_hash_table (info
)->rld_value
;
8647 case DT_MIPS_OPTIONS
:
8648 s
= (bfd_get_section_by_name
8649 (output_bfd
, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd
)));
8650 dyn
.d_un
.d_ptr
= s
->vma
;
8654 BFD_ASSERT (htab
->is_vxworks
);
8655 /* The count does not include the JUMP_SLOT relocations. */
8657 dyn
.d_un
.d_val
-= htab
->srelplt
->size
;
8661 BFD_ASSERT (htab
->is_vxworks
);
8662 dyn
.d_un
.d_val
= DT_RELA
;
8666 BFD_ASSERT (htab
->is_vxworks
);
8667 dyn
.d_un
.d_val
= htab
->srelplt
->size
;
8671 BFD_ASSERT (htab
->is_vxworks
);
8672 dyn
.d_un
.d_val
= (htab
->srelplt
->output_section
->vma
8673 + htab
->srelplt
->output_offset
);
8677 /* If we didn't need any text relocations after all, delete
8679 if (!(info
->flags
& DF_TEXTREL
))
8681 dyn_to_skip
= MIPS_ELF_DYN_SIZE (dynobj
);
8687 /* If we didn't need any text relocations after all, clear
8688 DF_TEXTREL from DT_FLAGS. */
8689 if (!(info
->flags
& DF_TEXTREL
))
8690 dyn
.d_un
.d_val
&= ~DF_TEXTREL
;
8700 if (swap_out_p
|| dyn_skipped
)
8701 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
8702 (dynobj
, &dyn
, b
- dyn_skipped
);
8706 dyn_skipped
+= dyn_to_skip
;
8711 /* Wipe out any trailing entries if we shifted down a dynamic tag. */
8712 if (dyn_skipped
> 0)
8713 memset (b
- dyn_skipped
, 0, dyn_skipped
);
8716 if (sgot
!= NULL
&& sgot
->size
> 0)
8718 if (htab
->is_vxworks
)
8720 /* The first entry of the global offset table points to the
8721 ".dynamic" section. The second is initialized by the
8722 loader and contains the shared library identifier.
8723 The third is also initialized by the loader and points
8724 to the lazy resolution stub. */
8725 MIPS_ELF_PUT_WORD (output_bfd
,
8726 sdyn
->output_offset
+ sdyn
->output_section
->vma
,
8728 MIPS_ELF_PUT_WORD (output_bfd
, 0,
8729 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
8730 MIPS_ELF_PUT_WORD (output_bfd
, 0,
8732 + 2 * MIPS_ELF_GOT_SIZE (output_bfd
));
8736 /* The first entry of the global offset table will be filled at
8737 runtime. The second entry will be used by some runtime loaders.
8738 This isn't the case of IRIX rld. */
8739 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
8740 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0x80000000,
8741 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
8746 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
8747 = MIPS_ELF_GOT_SIZE (output_bfd
);
8749 /* Generate dynamic relocations for the non-primary gots. */
8750 if (gg
!= NULL
&& gg
->next
)
8752 Elf_Internal_Rela rel
[3];
8755 memset (rel
, 0, sizeof (rel
));
8756 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_REL32
);
8758 for (g
= gg
->next
; g
->next
!= gg
; g
= g
->next
)
8760 bfd_vma index
= g
->next
->local_gotno
+ g
->next
->global_gotno
8761 + g
->next
->tls_gotno
;
8763 MIPS_ELF_PUT_WORD (output_bfd
, 0, sgot
->contents
8764 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
8765 MIPS_ELF_PUT_WORD (output_bfd
, 0x80000000, sgot
->contents
8766 + index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
8771 while (index
< g
->assigned_gotno
)
8773 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
8774 = index
++ * MIPS_ELF_GOT_SIZE (output_bfd
);
8775 if (!(mips_elf_create_dynamic_relocation
8776 (output_bfd
, info
, rel
, NULL
,
8777 bfd_abs_section_ptr
,
8780 BFD_ASSERT (addend
== 0);
8785 /* The generation of dynamic relocations for the non-primary gots
8786 adds more dynamic relocations. We cannot count them until
8789 if (elf_hash_table (info
)->dynamic_sections_created
)
8792 bfd_boolean swap_out_p
;
8794 BFD_ASSERT (sdyn
!= NULL
);
8796 for (b
= sdyn
->contents
;
8797 b
< sdyn
->contents
+ sdyn
->size
;
8798 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
8800 Elf_Internal_Dyn dyn
;
8803 /* Read in the current dynamic entry. */
8804 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
8806 /* Assume that we're going to modify it and write it out. */
8812 /* Reduce DT_RELSZ to account for any relocations we
8813 decided not to make. This is for the n64 irix rld,
8814 which doesn't seem to apply any relocations if there
8815 are trailing null entries. */
8816 s
= mips_elf_rel_dyn_section (info
, FALSE
);
8817 dyn
.d_un
.d_val
= (s
->reloc_count
8818 * (ABI_64_P (output_bfd
)
8819 ? sizeof (Elf64_Mips_External_Rel
)
8820 : sizeof (Elf32_External_Rel
)));
8829 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
8836 Elf32_compact_rel cpt
;
8838 if (SGI_COMPAT (output_bfd
))
8840 /* Write .compact_rel section out. */
8841 s
= bfd_get_section_by_name (dynobj
, ".compact_rel");
8845 cpt
.num
= s
->reloc_count
;
8847 cpt
.offset
= (s
->output_section
->filepos
8848 + sizeof (Elf32_External_compact_rel
));
8851 bfd_elf32_swap_compact_rel_out (output_bfd
, &cpt
,
8852 ((Elf32_External_compact_rel
*)
8855 /* Clean up a dummy stub function entry in .text. */
8856 s
= bfd_get_section_by_name (dynobj
,
8857 MIPS_ELF_STUB_SECTION_NAME (dynobj
));
8860 file_ptr dummy_offset
;
8862 BFD_ASSERT (s
->size
>= MIPS_FUNCTION_STUB_SIZE (info
));
8863 dummy_offset
= s
->size
- MIPS_FUNCTION_STUB_SIZE (info
);
8864 memset (s
->contents
+ dummy_offset
, 0,
8865 MIPS_FUNCTION_STUB_SIZE (info
));
8870 /* The psABI says that the dynamic relocations must be sorted in
8871 increasing order of r_symndx. The VxWorks EABI doesn't require
8872 this, and because the code below handles REL rather than RELA
8873 relocations, using it for VxWorks would be outright harmful. */
8874 if (!htab
->is_vxworks
)
8876 s
= mips_elf_rel_dyn_section (info
, FALSE
);
8878 && s
->size
> (bfd_vma
)2 * MIPS_ELF_REL_SIZE (output_bfd
))
8880 reldyn_sorting_bfd
= output_bfd
;
8882 if (ABI_64_P (output_bfd
))
8883 qsort ((Elf64_External_Rel
*) s
->contents
+ 1,
8884 s
->reloc_count
- 1, sizeof (Elf64_Mips_External_Rel
),
8885 sort_dynamic_relocs_64
);
8887 qsort ((Elf32_External_Rel
*) s
->contents
+ 1,
8888 s
->reloc_count
- 1, sizeof (Elf32_External_Rel
),
8889 sort_dynamic_relocs
);
8894 if (htab
->is_vxworks
&& htab
->splt
->size
> 0)
8897 mips_vxworks_finish_shared_plt (output_bfd
, info
);
8899 mips_vxworks_finish_exec_plt (output_bfd
, info
);
8905 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
8908 mips_set_isa_flags (bfd
*abfd
)
8912 switch (bfd_get_mach (abfd
))
8915 case bfd_mach_mips3000
:
8916 val
= E_MIPS_ARCH_1
;
8919 case bfd_mach_mips3900
:
8920 val
= E_MIPS_ARCH_1
| E_MIPS_MACH_3900
;
8923 case bfd_mach_mips6000
:
8924 val
= E_MIPS_ARCH_2
;
8927 case bfd_mach_mips4000
:
8928 case bfd_mach_mips4300
:
8929 case bfd_mach_mips4400
:
8930 case bfd_mach_mips4600
:
8931 val
= E_MIPS_ARCH_3
;
8934 case bfd_mach_mips4010
:
8935 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4010
;
8938 case bfd_mach_mips4100
:
8939 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4100
;
8942 case bfd_mach_mips4111
:
8943 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4111
;
8946 case bfd_mach_mips4120
:
8947 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4120
;
8950 case bfd_mach_mips4650
:
8951 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4650
;
8954 case bfd_mach_mips5400
:
8955 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5400
;
8958 case bfd_mach_mips5500
:
8959 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5500
;
8962 case bfd_mach_mips9000
:
8963 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_9000
;
8966 case bfd_mach_mips5000
:
8967 case bfd_mach_mips7000
:
8968 case bfd_mach_mips8000
:
8969 case bfd_mach_mips10000
:
8970 case bfd_mach_mips12000
:
8971 val
= E_MIPS_ARCH_4
;
8974 case bfd_mach_mips5
:
8975 val
= E_MIPS_ARCH_5
;
8978 case bfd_mach_mips_sb1
:
8979 val
= E_MIPS_ARCH_64
| E_MIPS_MACH_SB1
;
8982 case bfd_mach_mipsisa32
:
8983 val
= E_MIPS_ARCH_32
;
8986 case bfd_mach_mipsisa64
:
8987 val
= E_MIPS_ARCH_64
;
8990 case bfd_mach_mipsisa32r2
:
8991 val
= E_MIPS_ARCH_32R2
;
8994 case bfd_mach_mipsisa64r2
:
8995 val
= E_MIPS_ARCH_64R2
;
8998 elf_elfheader (abfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
8999 elf_elfheader (abfd
)->e_flags
|= val
;
9004 /* The final processing done just before writing out a MIPS ELF object
9005 file. This gets the MIPS architecture right based on the machine
9006 number. This is used by both the 32-bit and the 64-bit ABI. */
9009 _bfd_mips_elf_final_write_processing (bfd
*abfd
,
9010 bfd_boolean linker ATTRIBUTE_UNUSED
)
9013 Elf_Internal_Shdr
**hdrpp
;
9017 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
9018 is nonzero. This is for compatibility with old objects, which used
9019 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
9020 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_MACH
) == 0)
9021 mips_set_isa_flags (abfd
);
9023 /* Set the sh_info field for .gptab sections and other appropriate
9024 info for each special section. */
9025 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
9026 i
< elf_numsections (abfd
);
9029 switch ((*hdrpp
)->sh_type
)
9032 case SHT_MIPS_LIBLIST
:
9033 sec
= bfd_get_section_by_name (abfd
, ".dynstr");
9035 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
9038 case SHT_MIPS_GPTAB
:
9039 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
9040 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
9041 BFD_ASSERT (name
!= NULL
9042 && strncmp (name
, ".gptab.", sizeof ".gptab." - 1) == 0);
9043 sec
= bfd_get_section_by_name (abfd
, name
+ sizeof ".gptab" - 1);
9044 BFD_ASSERT (sec
!= NULL
);
9045 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
9048 case SHT_MIPS_CONTENT
:
9049 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
9050 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
9051 BFD_ASSERT (name
!= NULL
9052 && strncmp (name
, ".MIPS.content",
9053 sizeof ".MIPS.content" - 1) == 0);
9054 sec
= bfd_get_section_by_name (abfd
,
9055 name
+ sizeof ".MIPS.content" - 1);
9056 BFD_ASSERT (sec
!= NULL
);
9057 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
9060 case SHT_MIPS_SYMBOL_LIB
:
9061 sec
= bfd_get_section_by_name (abfd
, ".dynsym");
9063 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
9064 sec
= bfd_get_section_by_name (abfd
, ".liblist");
9066 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
9069 case SHT_MIPS_EVENTS
:
9070 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
9071 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
9072 BFD_ASSERT (name
!= NULL
);
9073 if (strncmp (name
, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0)
9074 sec
= bfd_get_section_by_name (abfd
,
9075 name
+ sizeof ".MIPS.events" - 1);
9078 BFD_ASSERT (strncmp (name
, ".MIPS.post_rel",
9079 sizeof ".MIPS.post_rel" - 1) == 0);
9080 sec
= bfd_get_section_by_name (abfd
,
9082 + sizeof ".MIPS.post_rel" - 1));
9084 BFD_ASSERT (sec
!= NULL
);
9085 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
9092 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
9096 _bfd_mips_elf_additional_program_headers (bfd
*abfd
)
9101 /* See if we need a PT_MIPS_REGINFO segment. */
9102 s
= bfd_get_section_by_name (abfd
, ".reginfo");
9103 if (s
&& (s
->flags
& SEC_LOAD
))
9106 /* See if we need a PT_MIPS_OPTIONS segment. */
9107 if (IRIX_COMPAT (abfd
) == ict_irix6
9108 && bfd_get_section_by_name (abfd
,
9109 MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)))
9112 /* See if we need a PT_MIPS_RTPROC segment. */
9113 if (IRIX_COMPAT (abfd
) == ict_irix5
9114 && bfd_get_section_by_name (abfd
, ".dynamic")
9115 && bfd_get_section_by_name (abfd
, ".mdebug"))
9121 /* Modify the segment map for an IRIX5 executable. */
9124 _bfd_mips_elf_modify_segment_map (bfd
*abfd
,
9125 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
9128 struct elf_segment_map
*m
, **pm
;
9131 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
9133 s
= bfd_get_section_by_name (abfd
, ".reginfo");
9134 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
9136 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
9137 if (m
->p_type
== PT_MIPS_REGINFO
)
9142 m
= bfd_zalloc (abfd
, amt
);
9146 m
->p_type
= PT_MIPS_REGINFO
;
9150 /* We want to put it after the PHDR and INTERP segments. */
9151 pm
= &elf_tdata (abfd
)->segment_map
;
9153 && ((*pm
)->p_type
== PT_PHDR
9154 || (*pm
)->p_type
== PT_INTERP
))
9162 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
9163 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
9164 PT_MIPS_OPTIONS segment immediately following the program header
9167 /* On non-IRIX6 new abi, we'll have already created a segment
9168 for this section, so don't create another. I'm not sure this
9169 is not also the case for IRIX 6, but I can't test it right
9171 && IRIX_COMPAT (abfd
) == ict_irix6
)
9173 for (s
= abfd
->sections
; s
; s
= s
->next
)
9174 if (elf_section_data (s
)->this_hdr
.sh_type
== SHT_MIPS_OPTIONS
)
9179 struct elf_segment_map
*options_segment
;
9181 pm
= &elf_tdata (abfd
)->segment_map
;
9183 && ((*pm
)->p_type
== PT_PHDR
9184 || (*pm
)->p_type
== PT_INTERP
))
9187 amt
= sizeof (struct elf_segment_map
);
9188 options_segment
= bfd_zalloc (abfd
, amt
);
9189 options_segment
->next
= *pm
;
9190 options_segment
->p_type
= PT_MIPS_OPTIONS
;
9191 options_segment
->p_flags
= PF_R
;
9192 options_segment
->p_flags_valid
= TRUE
;
9193 options_segment
->count
= 1;
9194 options_segment
->sections
[0] = s
;
9195 *pm
= options_segment
;
9200 if (IRIX_COMPAT (abfd
) == ict_irix5
)
9202 /* If there are .dynamic and .mdebug sections, we make a room
9203 for the RTPROC header. FIXME: Rewrite without section names. */
9204 if (bfd_get_section_by_name (abfd
, ".interp") == NULL
9205 && bfd_get_section_by_name (abfd
, ".dynamic") != NULL
9206 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
9208 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
9209 if (m
->p_type
== PT_MIPS_RTPROC
)
9214 m
= bfd_zalloc (abfd
, amt
);
9218 m
->p_type
= PT_MIPS_RTPROC
;
9220 s
= bfd_get_section_by_name (abfd
, ".rtproc");
9225 m
->p_flags_valid
= 1;
9233 /* We want to put it after the DYNAMIC segment. */
9234 pm
= &elf_tdata (abfd
)->segment_map
;
9235 while (*pm
!= NULL
&& (*pm
)->p_type
!= PT_DYNAMIC
)
9245 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
9246 .dynstr, .dynsym, and .hash sections, and everything in
9248 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
;
9250 if ((*pm
)->p_type
== PT_DYNAMIC
)
9253 if (m
!= NULL
&& IRIX_COMPAT (abfd
) == ict_none
)
9255 /* For a normal mips executable the permissions for the PT_DYNAMIC
9256 segment are read, write and execute. We do that here since
9257 the code in elf.c sets only the read permission. This matters
9258 sometimes for the dynamic linker. */
9259 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
9261 m
->p_flags
= PF_R
| PF_W
| PF_X
;
9262 m
->p_flags_valid
= 1;
9266 && m
->count
== 1 && strcmp (m
->sections
[0]->name
, ".dynamic") == 0)
9268 static const char *sec_names
[] =
9270 ".dynamic", ".dynstr", ".dynsym", ".hash"
9274 struct elf_segment_map
*n
;
9278 for (i
= 0; i
< sizeof sec_names
/ sizeof sec_names
[0]; i
++)
9280 s
= bfd_get_section_by_name (abfd
, sec_names
[i
]);
9281 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
9288 if (high
< s
->vma
+ sz
)
9294 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
9295 if ((s
->flags
& SEC_LOAD
) != 0
9297 && s
->vma
+ s
->size
<= high
)
9300 amt
= sizeof *n
+ (bfd_size_type
) (c
- 1) * sizeof (asection
*);
9301 n
= bfd_zalloc (abfd
, amt
);
9308 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
9310 if ((s
->flags
& SEC_LOAD
) != 0
9312 && s
->vma
+ s
->size
<= high
)
9326 /* Return the section that should be marked against GC for a given
9330 _bfd_mips_elf_gc_mark_hook (asection
*sec
,
9331 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
9332 Elf_Internal_Rela
*rel
,
9333 struct elf_link_hash_entry
*h
,
9334 Elf_Internal_Sym
*sym
)
9336 /* ??? Do mips16 stub sections need to be handled special? */
9340 switch (ELF_R_TYPE (sec
->owner
, rel
->r_info
))
9342 case R_MIPS_GNU_VTINHERIT
:
9343 case R_MIPS_GNU_VTENTRY
:
9347 switch (h
->root
.type
)
9349 case bfd_link_hash_defined
:
9350 case bfd_link_hash_defweak
:
9351 return h
->root
.u
.def
.section
;
9353 case bfd_link_hash_common
:
9354 return h
->root
.u
.c
.p
->section
;
9362 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
9367 /* Update the got entry reference counts for the section being removed. */
9370 _bfd_mips_elf_gc_sweep_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
9371 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
9372 asection
*sec ATTRIBUTE_UNUSED
,
9373 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
)
9376 Elf_Internal_Shdr
*symtab_hdr
;
9377 struct elf_link_hash_entry
**sym_hashes
;
9378 bfd_signed_vma
*local_got_refcounts
;
9379 const Elf_Internal_Rela
*rel
, *relend
;
9380 unsigned long r_symndx
;
9381 struct elf_link_hash_entry
*h
;
9383 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
9384 sym_hashes
= elf_sym_hashes (abfd
);
9385 local_got_refcounts
= elf_local_got_refcounts (abfd
);
9387 relend
= relocs
+ sec
->reloc_count
;
9388 for (rel
= relocs
; rel
< relend
; rel
++)
9389 switch (ELF_R_TYPE (abfd
, rel
->r_info
))
9393 case R_MIPS_CALL_HI16
:
9394 case R_MIPS_CALL_LO16
:
9395 case R_MIPS_GOT_HI16
:
9396 case R_MIPS_GOT_LO16
:
9397 case R_MIPS_GOT_DISP
:
9398 case R_MIPS_GOT_PAGE
:
9399 case R_MIPS_GOT_OFST
:
9400 /* ??? It would seem that the existing MIPS code does no sort
9401 of reference counting or whatnot on its GOT and PLT entries,
9402 so it is not possible to garbage collect them at this time. */
9413 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
9414 hiding the old indirect symbol. Process additional relocation
9415 information. Also called for weakdefs, in which case we just let
9416 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
9419 _bfd_mips_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
9420 struct elf_link_hash_entry
*dir
,
9421 struct elf_link_hash_entry
*ind
)
9423 struct mips_elf_link_hash_entry
*dirmips
, *indmips
;
9425 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
9427 if (ind
->root
.type
!= bfd_link_hash_indirect
)
9430 dirmips
= (struct mips_elf_link_hash_entry
*) dir
;
9431 indmips
= (struct mips_elf_link_hash_entry
*) ind
;
9432 dirmips
->possibly_dynamic_relocs
+= indmips
->possibly_dynamic_relocs
;
9433 if (indmips
->readonly_reloc
)
9434 dirmips
->readonly_reloc
= TRUE
;
9435 if (indmips
->no_fn_stub
)
9436 dirmips
->no_fn_stub
= TRUE
;
9438 if (dirmips
->tls_type
== 0)
9439 dirmips
->tls_type
= indmips
->tls_type
;
9443 _bfd_mips_elf_hide_symbol (struct bfd_link_info
*info
,
9444 struct elf_link_hash_entry
*entry
,
9445 bfd_boolean force_local
)
9449 struct mips_got_info
*g
;
9450 struct mips_elf_link_hash_entry
*h
;
9452 h
= (struct mips_elf_link_hash_entry
*) entry
;
9453 if (h
->forced_local
)
9455 h
->forced_local
= force_local
;
9457 dynobj
= elf_hash_table (info
)->dynobj
;
9458 if (dynobj
!= NULL
&& force_local
&& h
->root
.type
!= STT_TLS
9459 && (got
= mips_elf_got_section (dynobj
, TRUE
)) != NULL
9460 && (g
= mips_elf_section_data (got
)->u
.got_info
) != NULL
)
9464 struct mips_got_entry e
;
9465 struct mips_got_info
*gg
= g
;
9467 /* Since we're turning what used to be a global symbol into a
9468 local one, bump up the number of local entries of each GOT
9469 that had an entry for it. This will automatically decrease
9470 the number of global entries, since global_gotno is actually
9471 the upper limit of global entries. */
9477 for (g
= g
->next
; g
!= gg
; g
= g
->next
)
9478 if (htab_find (g
->got_entries
, &e
))
9480 BFD_ASSERT (g
->global_gotno
> 0);
9485 /* If this was a global symbol forced into the primary GOT, we
9486 no longer need an entry for it. We can't release the entry
9487 at this point, but we must at least stop counting it as one
9488 of the symbols that required a forced got entry. */
9489 if (h
->root
.got
.offset
== 2)
9491 BFD_ASSERT (gg
->assigned_gotno
> 0);
9492 gg
->assigned_gotno
--;
9495 else if (g
->global_gotno
== 0 && g
->global_gotsym
== NULL
)
9496 /* If we haven't got through GOT allocation yet, just bump up the
9497 number of local entries, as this symbol won't be counted as
9500 else if (h
->root
.got
.offset
== 1)
9502 /* If we're past non-multi-GOT allocation and this symbol had
9503 been marked for a global got entry, give it a local entry
9505 BFD_ASSERT (g
->global_gotno
> 0);
9511 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
9517 _bfd_mips_elf_discard_info (bfd
*abfd
, struct elf_reloc_cookie
*cookie
,
9518 struct bfd_link_info
*info
)
9521 bfd_boolean ret
= FALSE
;
9522 unsigned char *tdata
;
9525 o
= bfd_get_section_by_name (abfd
, ".pdr");
9530 if (o
->size
% PDR_SIZE
!= 0)
9532 if (o
->output_section
!= NULL
9533 && bfd_is_abs_section (o
->output_section
))
9536 tdata
= bfd_zmalloc (o
->size
/ PDR_SIZE
);
9540 cookie
->rels
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
9548 cookie
->rel
= cookie
->rels
;
9549 cookie
->relend
= cookie
->rels
+ o
->reloc_count
;
9551 for (i
= 0, skip
= 0; i
< o
->size
/ PDR_SIZE
; i
++)
9553 if (bfd_elf_reloc_symbol_deleted_p (i
* PDR_SIZE
, cookie
))
9562 mips_elf_section_data (o
)->u
.tdata
= tdata
;
9563 o
->size
-= skip
* PDR_SIZE
;
9569 if (! info
->keep_memory
)
9570 free (cookie
->rels
);
9576 _bfd_mips_elf_ignore_discarded_relocs (asection
*sec
)
9578 if (strcmp (sec
->name
, ".pdr") == 0)
9584 _bfd_mips_elf_write_section (bfd
*output_bfd
, asection
*sec
,
9587 bfd_byte
*to
, *from
, *end
;
9590 if (strcmp (sec
->name
, ".pdr") != 0)
9593 if (mips_elf_section_data (sec
)->u
.tdata
== NULL
)
9597 end
= contents
+ sec
->size
;
9598 for (from
= contents
, i
= 0;
9600 from
+= PDR_SIZE
, i
++)
9602 if ((mips_elf_section_data (sec
)->u
.tdata
)[i
] == 1)
9605 memcpy (to
, from
, PDR_SIZE
);
9608 bfd_set_section_contents (output_bfd
, sec
->output_section
, contents
,
9609 sec
->output_offset
, sec
->size
);
9613 /* MIPS ELF uses a special find_nearest_line routine in order the
9614 handle the ECOFF debugging information. */
9616 struct mips_elf_find_line
9618 struct ecoff_debug_info d
;
9619 struct ecoff_find_line i
;
9623 _bfd_mips_elf_find_nearest_line (bfd
*abfd
, asection
*section
,
9624 asymbol
**symbols
, bfd_vma offset
,
9625 const char **filename_ptr
,
9626 const char **functionname_ptr
,
9627 unsigned int *line_ptr
)
9631 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
9632 filename_ptr
, functionname_ptr
,
9636 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
9637 filename_ptr
, functionname_ptr
,
9638 line_ptr
, ABI_64_P (abfd
) ? 8 : 0,
9639 &elf_tdata (abfd
)->dwarf2_find_line_info
))
9642 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
9646 struct mips_elf_find_line
*fi
;
9647 const struct ecoff_debug_swap
* const swap
=
9648 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
9650 /* If we are called during a link, mips_elf_final_link may have
9651 cleared the SEC_HAS_CONTENTS field. We force it back on here
9652 if appropriate (which it normally will be). */
9653 origflags
= msec
->flags
;
9654 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
9655 msec
->flags
|= SEC_HAS_CONTENTS
;
9657 fi
= elf_tdata (abfd
)->find_line_info
;
9660 bfd_size_type external_fdr_size
;
9663 struct fdr
*fdr_ptr
;
9664 bfd_size_type amt
= sizeof (struct mips_elf_find_line
);
9666 fi
= bfd_zalloc (abfd
, amt
);
9669 msec
->flags
= origflags
;
9673 if (! _bfd_mips_elf_read_ecoff_info (abfd
, msec
, &fi
->d
))
9675 msec
->flags
= origflags
;
9679 /* Swap in the FDR information. */
9680 amt
= fi
->d
.symbolic_header
.ifdMax
* sizeof (struct fdr
);
9681 fi
->d
.fdr
= bfd_alloc (abfd
, amt
);
9682 if (fi
->d
.fdr
== NULL
)
9684 msec
->flags
= origflags
;
9687 external_fdr_size
= swap
->external_fdr_size
;
9688 fdr_ptr
= fi
->d
.fdr
;
9689 fraw_src
= (char *) fi
->d
.external_fdr
;
9690 fraw_end
= (fraw_src
9691 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
9692 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
9693 (*swap
->swap_fdr_in
) (abfd
, fraw_src
, fdr_ptr
);
9695 elf_tdata (abfd
)->find_line_info
= fi
;
9697 /* Note that we don't bother to ever free this information.
9698 find_nearest_line is either called all the time, as in
9699 objdump -l, so the information should be saved, or it is
9700 rarely called, as in ld error messages, so the memory
9701 wasted is unimportant. Still, it would probably be a
9702 good idea for free_cached_info to throw it away. */
9705 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
9706 &fi
->i
, filename_ptr
, functionname_ptr
,
9709 msec
->flags
= origflags
;
9713 msec
->flags
= origflags
;
9716 /* Fall back on the generic ELF find_nearest_line routine. */
9718 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
9719 filename_ptr
, functionname_ptr
,
9724 _bfd_mips_elf_find_inliner_info (bfd
*abfd
,
9725 const char **filename_ptr
,
9726 const char **functionname_ptr
,
9727 unsigned int *line_ptr
)
9730 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
9731 functionname_ptr
, line_ptr
,
9732 & elf_tdata (abfd
)->dwarf2_find_line_info
);
9737 /* When are writing out the .options or .MIPS.options section,
9738 remember the bytes we are writing out, so that we can install the
9739 GP value in the section_processing routine. */
9742 _bfd_mips_elf_set_section_contents (bfd
*abfd
, sec_ptr section
,
9743 const void *location
,
9744 file_ptr offset
, bfd_size_type count
)
9746 if (MIPS_ELF_OPTIONS_SECTION_NAME_P (section
->name
))
9750 if (elf_section_data (section
) == NULL
)
9752 bfd_size_type amt
= sizeof (struct bfd_elf_section_data
);
9753 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
9754 if (elf_section_data (section
) == NULL
)
9757 c
= mips_elf_section_data (section
)->u
.tdata
;
9760 c
= bfd_zalloc (abfd
, section
->size
);
9763 mips_elf_section_data (section
)->u
.tdata
= c
;
9766 memcpy (c
+ offset
, location
, count
);
9769 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
,
9773 /* This is almost identical to bfd_generic_get_... except that some
9774 MIPS relocations need to be handled specially. Sigh. */
9777 _bfd_elf_mips_get_relocated_section_contents
9779 struct bfd_link_info
*link_info
,
9780 struct bfd_link_order
*link_order
,
9782 bfd_boolean relocatable
,
9785 /* Get enough memory to hold the stuff */
9786 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
9787 asection
*input_section
= link_order
->u
.indirect
.section
;
9790 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
9791 arelent
**reloc_vector
= NULL
;
9797 reloc_vector
= bfd_malloc (reloc_size
);
9798 if (reloc_vector
== NULL
&& reloc_size
!= 0)
9801 /* read in the section */
9802 sz
= input_section
->rawsize
? input_section
->rawsize
: input_section
->size
;
9803 if (!bfd_get_section_contents (input_bfd
, input_section
, data
, 0, sz
))
9806 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
9810 if (reloc_count
< 0)
9813 if (reloc_count
> 0)
9818 bfd_vma gp
= 0x12345678; /* initialize just to shut gcc up */
9821 struct bfd_hash_entry
*h
;
9822 struct bfd_link_hash_entry
*lh
;
9823 /* Skip all this stuff if we aren't mixing formats. */
9824 if (abfd
&& input_bfd
9825 && abfd
->xvec
== input_bfd
->xvec
)
9829 h
= bfd_hash_lookup (&link_info
->hash
->table
, "_gp", FALSE
, FALSE
);
9830 lh
= (struct bfd_link_hash_entry
*) h
;
9837 case bfd_link_hash_undefined
:
9838 case bfd_link_hash_undefweak
:
9839 case bfd_link_hash_common
:
9842 case bfd_link_hash_defined
:
9843 case bfd_link_hash_defweak
:
9845 gp
= lh
->u
.def
.value
;
9847 case bfd_link_hash_indirect
:
9848 case bfd_link_hash_warning
:
9850 /* @@FIXME ignoring warning for now */
9852 case bfd_link_hash_new
:
9861 for (parent
= reloc_vector
; *parent
!= NULL
; parent
++)
9863 char *error_message
= NULL
;
9864 bfd_reloc_status_type r
;
9866 /* Specific to MIPS: Deal with relocation types that require
9867 knowing the gp of the output bfd. */
9868 asymbol
*sym
= *(*parent
)->sym_ptr_ptr
;
9870 /* If we've managed to find the gp and have a special
9871 function for the relocation then go ahead, else default
9872 to the generic handling. */
9874 && (*parent
)->howto
->special_function
9875 == _bfd_mips_elf32_gprel16_reloc
)
9876 r
= _bfd_mips_elf_gprel16_with_gp (input_bfd
, sym
, *parent
,
9877 input_section
, relocatable
,
9880 r
= bfd_perform_relocation (input_bfd
, *parent
, data
,
9882 relocatable
? abfd
: NULL
,
9887 asection
*os
= input_section
->output_section
;
9889 /* A partial link, so keep the relocs */
9890 os
->orelocation
[os
->reloc_count
] = *parent
;
9894 if (r
!= bfd_reloc_ok
)
9898 case bfd_reloc_undefined
:
9899 if (!((*link_info
->callbacks
->undefined_symbol
)
9900 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
9901 input_bfd
, input_section
, (*parent
)->address
, TRUE
)))
9904 case bfd_reloc_dangerous
:
9905 BFD_ASSERT (error_message
!= NULL
);
9906 if (!((*link_info
->callbacks
->reloc_dangerous
)
9907 (link_info
, error_message
, input_bfd
, input_section
,
9908 (*parent
)->address
)))
9911 case bfd_reloc_overflow
:
9912 if (!((*link_info
->callbacks
->reloc_overflow
)
9914 bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
9915 (*parent
)->howto
->name
, (*parent
)->addend
,
9916 input_bfd
, input_section
, (*parent
)->address
)))
9919 case bfd_reloc_outofrange
:
9928 if (reloc_vector
!= NULL
)
9929 free (reloc_vector
);
9933 if (reloc_vector
!= NULL
)
9934 free (reloc_vector
);
9938 /* Create a MIPS ELF linker hash table. */
9940 struct bfd_link_hash_table
*
9941 _bfd_mips_elf_link_hash_table_create (bfd
*abfd
)
9943 struct mips_elf_link_hash_table
*ret
;
9944 bfd_size_type amt
= sizeof (struct mips_elf_link_hash_table
);
9946 ret
= bfd_malloc (amt
);
9950 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
9951 mips_elf_link_hash_newfunc
,
9952 sizeof (struct mips_elf_link_hash_entry
)))
9959 /* We no longer use this. */
9960 for (i
= 0; i
< SIZEOF_MIPS_DYNSYM_SECNAMES
; i
++)
9961 ret
->dynsym_sec_strindex
[i
] = (bfd_size_type
) -1;
9963 ret
->procedure_count
= 0;
9964 ret
->compact_rel_size
= 0;
9965 ret
->use_rld_obj_head
= FALSE
;
9967 ret
->mips16_stubs_seen
= FALSE
;
9968 ret
->is_vxworks
= FALSE
;
9969 ret
->srelbss
= NULL
;
9970 ret
->sdynbss
= NULL
;
9971 ret
->srelplt
= NULL
;
9972 ret
->srelplt2
= NULL
;
9973 ret
->sgotplt
= NULL
;
9975 ret
->plt_header_size
= 0;
9976 ret
->plt_entry_size
= 0;
9978 return &ret
->root
.root
;
9981 /* Likewise, but indicate that the target is VxWorks. */
9983 struct bfd_link_hash_table
*
9984 _bfd_mips_vxworks_link_hash_table_create (bfd
*abfd
)
9986 struct bfd_link_hash_table
*ret
;
9988 ret
= _bfd_mips_elf_link_hash_table_create (abfd
);
9991 struct mips_elf_link_hash_table
*htab
;
9993 htab
= (struct mips_elf_link_hash_table
*) ret
;
9994 htab
->is_vxworks
= 1;
9999 /* We need to use a special link routine to handle the .reginfo and
10000 the .mdebug sections. We need to merge all instances of these
10001 sections together, not write them all out sequentially. */
10004 _bfd_mips_elf_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
10007 struct bfd_link_order
*p
;
10008 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
10009 asection
*rtproc_sec
;
10010 Elf32_RegInfo reginfo
;
10011 struct ecoff_debug_info debug
;
10012 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10013 const struct ecoff_debug_swap
*swap
= bed
->elf_backend_ecoff_debug_swap
;
10014 HDRR
*symhdr
= &debug
.symbolic_header
;
10015 void *mdebug_handle
= NULL
;
10020 struct mips_elf_link_hash_table
*htab
;
10022 static const char * const secname
[] =
10024 ".text", ".init", ".fini", ".data",
10025 ".rodata", ".sdata", ".sbss", ".bss"
10027 static const int sc
[] =
10029 scText
, scInit
, scFini
, scData
,
10030 scRData
, scSData
, scSBss
, scBss
10033 /* We'd carefully arranged the dynamic symbol indices, and then the
10034 generic size_dynamic_sections renumbered them out from under us.
10035 Rather than trying somehow to prevent the renumbering, just do
10037 htab
= mips_elf_hash_table (info
);
10038 if (elf_hash_table (info
)->dynamic_sections_created
)
10042 struct mips_got_info
*g
;
10043 bfd_size_type dynsecsymcount
;
10045 /* When we resort, we must tell mips_elf_sort_hash_table what
10046 the lowest index it may use is. That's the number of section
10047 symbols we're going to add. The generic ELF linker only
10048 adds these symbols when building a shared object. Note that
10049 we count the sections after (possibly) removing the .options
10052 dynsecsymcount
= 0;
10057 for (p
= abfd
->sections
; p
; p
= p
->next
)
10058 if ((p
->flags
& SEC_EXCLUDE
) == 0
10059 && (p
->flags
& SEC_ALLOC
) != 0
10060 && !(*bed
->elf_backend_omit_section_dynsym
) (abfd
, info
, p
))
10064 if (! mips_elf_sort_hash_table (info
, dynsecsymcount
+ 1))
10067 /* Make sure we didn't grow the global .got region. */
10068 dynobj
= elf_hash_table (info
)->dynobj
;
10069 got
= mips_elf_got_section (dynobj
, FALSE
);
10070 g
= mips_elf_section_data (got
)->u
.got_info
;
10072 if (g
->global_gotsym
!= NULL
)
10073 BFD_ASSERT ((elf_hash_table (info
)->dynsymcount
10074 - g
->global_gotsym
->dynindx
)
10075 <= g
->global_gotno
);
10078 /* Get a value for the GP register. */
10079 if (elf_gp (abfd
) == 0)
10081 struct bfd_link_hash_entry
*h
;
10083 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
10084 if (h
!= NULL
&& h
->type
== bfd_link_hash_defined
)
10085 elf_gp (abfd
) = (h
->u
.def
.value
10086 + h
->u
.def
.section
->output_section
->vma
10087 + h
->u
.def
.section
->output_offset
);
10088 else if (htab
->is_vxworks
10089 && (h
= bfd_link_hash_lookup (info
->hash
,
10090 "_GLOBAL_OFFSET_TABLE_",
10091 FALSE
, FALSE
, TRUE
))
10092 && h
->type
== bfd_link_hash_defined
)
10093 elf_gp (abfd
) = (h
->u
.def
.section
->output_section
->vma
10094 + h
->u
.def
.section
->output_offset
10096 else if (info
->relocatable
)
10098 bfd_vma lo
= MINUS_ONE
;
10100 /* Find the GP-relative section with the lowest offset. */
10101 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
10103 && (elf_section_data (o
)->this_hdr
.sh_flags
& SHF_MIPS_GPREL
))
10106 /* And calculate GP relative to that. */
10107 elf_gp (abfd
) = lo
+ ELF_MIPS_GP_OFFSET (info
);
10111 /* If the relocate_section function needs to do a reloc
10112 involving the GP value, it should make a reloc_dangerous
10113 callback to warn that GP is not defined. */
10117 /* Go through the sections and collect the .reginfo and .mdebug
10119 reginfo_sec
= NULL
;
10121 gptab_data_sec
= NULL
;
10122 gptab_bss_sec
= NULL
;
10123 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
10125 if (strcmp (o
->name
, ".reginfo") == 0)
10127 memset (®info
, 0, sizeof reginfo
);
10129 /* We have found the .reginfo section in the output file.
10130 Look through all the link_orders comprising it and merge
10131 the information together. */
10132 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10134 asection
*input_section
;
10136 Elf32_External_RegInfo ext
;
10139 if (p
->type
!= bfd_indirect_link_order
)
10141 if (p
->type
== bfd_data_link_order
)
10146 input_section
= p
->u
.indirect
.section
;
10147 input_bfd
= input_section
->owner
;
10149 if (! bfd_get_section_contents (input_bfd
, input_section
,
10150 &ext
, 0, sizeof ext
))
10153 bfd_mips_elf32_swap_reginfo_in (input_bfd
, &ext
, &sub
);
10155 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
10156 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
10157 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
10158 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
10159 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
10161 /* ri_gp_value is set by the function
10162 mips_elf32_section_processing when the section is
10163 finally written out. */
10165 /* Hack: reset the SEC_HAS_CONTENTS flag so that
10166 elf_link_input_bfd ignores this section. */
10167 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
10170 /* Size has been set in _bfd_mips_elf_always_size_sections. */
10171 BFD_ASSERT(o
->size
== sizeof (Elf32_External_RegInfo
));
10173 /* Skip this section later on (I don't think this currently
10174 matters, but someday it might). */
10175 o
->map_head
.link_order
= NULL
;
10180 if (strcmp (o
->name
, ".mdebug") == 0)
10182 struct extsym_info einfo
;
10185 /* We have found the .mdebug section in the output file.
10186 Look through all the link_orders comprising it and merge
10187 the information together. */
10188 symhdr
->magic
= swap
->sym_magic
;
10189 /* FIXME: What should the version stamp be? */
10190 symhdr
->vstamp
= 0;
10191 symhdr
->ilineMax
= 0;
10192 symhdr
->cbLine
= 0;
10193 symhdr
->idnMax
= 0;
10194 symhdr
->ipdMax
= 0;
10195 symhdr
->isymMax
= 0;
10196 symhdr
->ioptMax
= 0;
10197 symhdr
->iauxMax
= 0;
10198 symhdr
->issMax
= 0;
10199 symhdr
->issExtMax
= 0;
10200 symhdr
->ifdMax
= 0;
10202 symhdr
->iextMax
= 0;
10204 /* We accumulate the debugging information itself in the
10205 debug_info structure. */
10207 debug
.external_dnr
= NULL
;
10208 debug
.external_pdr
= NULL
;
10209 debug
.external_sym
= NULL
;
10210 debug
.external_opt
= NULL
;
10211 debug
.external_aux
= NULL
;
10213 debug
.ssext
= debug
.ssext_end
= NULL
;
10214 debug
.external_fdr
= NULL
;
10215 debug
.external_rfd
= NULL
;
10216 debug
.external_ext
= debug
.external_ext_end
= NULL
;
10218 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
10219 if (mdebug_handle
== NULL
)
10223 esym
.cobol_main
= 0;
10227 esym
.asym
.iss
= issNil
;
10228 esym
.asym
.st
= stLocal
;
10229 esym
.asym
.reserved
= 0;
10230 esym
.asym
.index
= indexNil
;
10232 for (i
= 0; i
< sizeof (secname
) / sizeof (secname
[0]); i
++)
10234 esym
.asym
.sc
= sc
[i
];
10235 s
= bfd_get_section_by_name (abfd
, secname
[i
]);
10238 esym
.asym
.value
= s
->vma
;
10239 last
= s
->vma
+ s
->size
;
10242 esym
.asym
.value
= last
;
10243 if (!bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
10244 secname
[i
], &esym
))
10248 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10250 asection
*input_section
;
10252 const struct ecoff_debug_swap
*input_swap
;
10253 struct ecoff_debug_info input_debug
;
10257 if (p
->type
!= bfd_indirect_link_order
)
10259 if (p
->type
== bfd_data_link_order
)
10264 input_section
= p
->u
.indirect
.section
;
10265 input_bfd
= input_section
->owner
;
10267 if (bfd_get_flavour (input_bfd
) != bfd_target_elf_flavour
10268 || (get_elf_backend_data (input_bfd
)
10269 ->elf_backend_ecoff_debug_swap
) == NULL
)
10271 /* I don't know what a non MIPS ELF bfd would be
10272 doing with a .mdebug section, but I don't really
10273 want to deal with it. */
10277 input_swap
= (get_elf_backend_data (input_bfd
)
10278 ->elf_backend_ecoff_debug_swap
);
10280 BFD_ASSERT (p
->size
== input_section
->size
);
10282 /* The ECOFF linking code expects that we have already
10283 read in the debugging information and set up an
10284 ecoff_debug_info structure, so we do that now. */
10285 if (! _bfd_mips_elf_read_ecoff_info (input_bfd
, input_section
,
10289 if (! (bfd_ecoff_debug_accumulate
10290 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
10291 &input_debug
, input_swap
, info
)))
10294 /* Loop through the external symbols. For each one with
10295 interesting information, try to find the symbol in
10296 the linker global hash table and save the information
10297 for the output external symbols. */
10298 eraw_src
= input_debug
.external_ext
;
10299 eraw_end
= (eraw_src
10300 + (input_debug
.symbolic_header
.iextMax
10301 * input_swap
->external_ext_size
));
10303 eraw_src
< eraw_end
;
10304 eraw_src
+= input_swap
->external_ext_size
)
10308 struct mips_elf_link_hash_entry
*h
;
10310 (*input_swap
->swap_ext_in
) (input_bfd
, eraw_src
, &ext
);
10311 if (ext
.asym
.sc
== scNil
10312 || ext
.asym
.sc
== scUndefined
10313 || ext
.asym
.sc
== scSUndefined
)
10316 name
= input_debug
.ssext
+ ext
.asym
.iss
;
10317 h
= mips_elf_link_hash_lookup (mips_elf_hash_table (info
),
10318 name
, FALSE
, FALSE
, TRUE
);
10319 if (h
== NULL
|| h
->esym
.ifd
!= -2)
10324 BFD_ASSERT (ext
.ifd
10325 < input_debug
.symbolic_header
.ifdMax
);
10326 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
10332 /* Free up the information we just read. */
10333 free (input_debug
.line
);
10334 free (input_debug
.external_dnr
);
10335 free (input_debug
.external_pdr
);
10336 free (input_debug
.external_sym
);
10337 free (input_debug
.external_opt
);
10338 free (input_debug
.external_aux
);
10339 free (input_debug
.ss
);
10340 free (input_debug
.ssext
);
10341 free (input_debug
.external_fdr
);
10342 free (input_debug
.external_rfd
);
10343 free (input_debug
.external_ext
);
10345 /* Hack: reset the SEC_HAS_CONTENTS flag so that
10346 elf_link_input_bfd ignores this section. */
10347 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
10350 if (SGI_COMPAT (abfd
) && info
->shared
)
10352 /* Create .rtproc section. */
10353 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
10354 if (rtproc_sec
== NULL
)
10356 flagword flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
10357 | SEC_LINKER_CREATED
| SEC_READONLY
);
10359 rtproc_sec
= bfd_make_section_with_flags (abfd
,
10362 if (rtproc_sec
== NULL
10363 || ! bfd_set_section_alignment (abfd
, rtproc_sec
, 4))
10367 if (! mips_elf_create_procedure_table (mdebug_handle
, abfd
,
10373 /* Build the external symbol information. */
10376 einfo
.debug
= &debug
;
10378 einfo
.failed
= FALSE
;
10379 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
10380 mips_elf_output_extsym
, &einfo
);
10384 /* Set the size of the .mdebug section. */
10385 o
->size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
10387 /* Skip this section later on (I don't think this currently
10388 matters, but someday it might). */
10389 o
->map_head
.link_order
= NULL
;
10394 if (strncmp (o
->name
, ".gptab.", sizeof ".gptab." - 1) == 0)
10396 const char *subname
;
10399 Elf32_External_gptab
*ext_tab
;
10402 /* The .gptab.sdata and .gptab.sbss sections hold
10403 information describing how the small data area would
10404 change depending upon the -G switch. These sections
10405 not used in executables files. */
10406 if (! info
->relocatable
)
10408 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10410 asection
*input_section
;
10412 if (p
->type
!= bfd_indirect_link_order
)
10414 if (p
->type
== bfd_data_link_order
)
10419 input_section
= p
->u
.indirect
.section
;
10421 /* Hack: reset the SEC_HAS_CONTENTS flag so that
10422 elf_link_input_bfd ignores this section. */
10423 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
10426 /* Skip this section later on (I don't think this
10427 currently matters, but someday it might). */
10428 o
->map_head
.link_order
= NULL
;
10430 /* Really remove the section. */
10431 bfd_section_list_remove (abfd
, o
);
10432 --abfd
->section_count
;
10437 /* There is one gptab for initialized data, and one for
10438 uninitialized data. */
10439 if (strcmp (o
->name
, ".gptab.sdata") == 0)
10440 gptab_data_sec
= o
;
10441 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
10445 (*_bfd_error_handler
)
10446 (_("%s: illegal section name `%s'"),
10447 bfd_get_filename (abfd
), o
->name
);
10448 bfd_set_error (bfd_error_nonrepresentable_section
);
10452 /* The linker script always combines .gptab.data and
10453 .gptab.sdata into .gptab.sdata, and likewise for
10454 .gptab.bss and .gptab.sbss. It is possible that there is
10455 no .sdata or .sbss section in the output file, in which
10456 case we must change the name of the output section. */
10457 subname
= o
->name
+ sizeof ".gptab" - 1;
10458 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
10460 if (o
== gptab_data_sec
)
10461 o
->name
= ".gptab.data";
10463 o
->name
= ".gptab.bss";
10464 subname
= o
->name
+ sizeof ".gptab" - 1;
10465 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
10468 /* Set up the first entry. */
10470 amt
= c
* sizeof (Elf32_gptab
);
10471 tab
= bfd_malloc (amt
);
10474 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
10475 tab
[0].gt_header
.gt_unused
= 0;
10477 /* Combine the input sections. */
10478 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
10480 asection
*input_section
;
10482 bfd_size_type size
;
10483 unsigned long last
;
10484 bfd_size_type gpentry
;
10486 if (p
->type
!= bfd_indirect_link_order
)
10488 if (p
->type
== bfd_data_link_order
)
10493 input_section
= p
->u
.indirect
.section
;
10494 input_bfd
= input_section
->owner
;
10496 /* Combine the gptab entries for this input section one
10497 by one. We know that the input gptab entries are
10498 sorted by ascending -G value. */
10499 size
= input_section
->size
;
10501 for (gpentry
= sizeof (Elf32_External_gptab
);
10503 gpentry
+= sizeof (Elf32_External_gptab
))
10505 Elf32_External_gptab ext_gptab
;
10506 Elf32_gptab int_gptab
;
10512 if (! (bfd_get_section_contents
10513 (input_bfd
, input_section
, &ext_gptab
, gpentry
,
10514 sizeof (Elf32_External_gptab
))))
10520 bfd_mips_elf32_swap_gptab_in (input_bfd
, &ext_gptab
,
10522 val
= int_gptab
.gt_entry
.gt_g_value
;
10523 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
10526 for (look
= 1; look
< c
; look
++)
10528 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
10529 tab
[look
].gt_entry
.gt_bytes
+= add
;
10531 if (tab
[look
].gt_entry
.gt_g_value
== val
)
10537 Elf32_gptab
*new_tab
;
10540 /* We need a new table entry. */
10541 amt
= (bfd_size_type
) (c
+ 1) * sizeof (Elf32_gptab
);
10542 new_tab
= bfd_realloc (tab
, amt
);
10543 if (new_tab
== NULL
)
10549 tab
[c
].gt_entry
.gt_g_value
= val
;
10550 tab
[c
].gt_entry
.gt_bytes
= add
;
10552 /* Merge in the size for the next smallest -G
10553 value, since that will be implied by this new
10556 for (look
= 1; look
< c
; look
++)
10558 if (tab
[look
].gt_entry
.gt_g_value
< val
10560 || (tab
[look
].gt_entry
.gt_g_value
10561 > tab
[max
].gt_entry
.gt_g_value
)))
10565 tab
[c
].gt_entry
.gt_bytes
+=
10566 tab
[max
].gt_entry
.gt_bytes
;
10571 last
= int_gptab
.gt_entry
.gt_bytes
;
10574 /* Hack: reset the SEC_HAS_CONTENTS flag so that
10575 elf_link_input_bfd ignores this section. */
10576 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
10579 /* The table must be sorted by -G value. */
10581 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
10583 /* Swap out the table. */
10584 amt
= (bfd_size_type
) c
* sizeof (Elf32_External_gptab
);
10585 ext_tab
= bfd_alloc (abfd
, amt
);
10586 if (ext_tab
== NULL
)
10592 for (j
= 0; j
< c
; j
++)
10593 bfd_mips_elf32_swap_gptab_out (abfd
, tab
+ j
, ext_tab
+ j
);
10596 o
->size
= c
* sizeof (Elf32_External_gptab
);
10597 o
->contents
= (bfd_byte
*) ext_tab
;
10599 /* Skip this section later on (I don't think this currently
10600 matters, but someday it might). */
10601 o
->map_head
.link_order
= NULL
;
10605 /* Invoke the regular ELF backend linker to do all the work. */
10606 if (!bfd_elf_final_link (abfd
, info
))
10609 /* Now write out the computed sections. */
10611 if (reginfo_sec
!= NULL
)
10613 Elf32_External_RegInfo ext
;
10615 bfd_mips_elf32_swap_reginfo_out (abfd
, ®info
, &ext
);
10616 if (! bfd_set_section_contents (abfd
, reginfo_sec
, &ext
, 0, sizeof ext
))
10620 if (mdebug_sec
!= NULL
)
10622 BFD_ASSERT (abfd
->output_has_begun
);
10623 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
10625 mdebug_sec
->filepos
))
10628 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
10631 if (gptab_data_sec
!= NULL
)
10633 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
10634 gptab_data_sec
->contents
,
10635 0, gptab_data_sec
->size
))
10639 if (gptab_bss_sec
!= NULL
)
10641 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
10642 gptab_bss_sec
->contents
,
10643 0, gptab_bss_sec
->size
))
10647 if (SGI_COMPAT (abfd
))
10649 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
10650 if (rtproc_sec
!= NULL
)
10652 if (! bfd_set_section_contents (abfd
, rtproc_sec
,
10653 rtproc_sec
->contents
,
10654 0, rtproc_sec
->size
))
10662 /* Structure for saying that BFD machine EXTENSION extends BASE. */
10664 struct mips_mach_extension
{
10665 unsigned long extension
, base
;
10669 /* An array describing how BFD machines relate to one another. The entries
10670 are ordered topologically with MIPS I extensions listed last. */
10672 static const struct mips_mach_extension mips_mach_extensions
[] = {
10673 /* MIPS64 extensions. */
10674 { bfd_mach_mipsisa64r2
, bfd_mach_mipsisa64
},
10675 { bfd_mach_mips_sb1
, bfd_mach_mipsisa64
},
10677 /* MIPS V extensions. */
10678 { bfd_mach_mipsisa64
, bfd_mach_mips5
},
10680 /* R10000 extensions. */
10681 { bfd_mach_mips12000
, bfd_mach_mips10000
},
10683 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
10684 vr5400 ISA, but doesn't include the multimedia stuff. It seems
10685 better to allow vr5400 and vr5500 code to be merged anyway, since
10686 many libraries will just use the core ISA. Perhaps we could add
10687 some sort of ASE flag if this ever proves a problem. */
10688 { bfd_mach_mips5500
, bfd_mach_mips5400
},
10689 { bfd_mach_mips5400
, bfd_mach_mips5000
},
10691 /* MIPS IV extensions. */
10692 { bfd_mach_mips5
, bfd_mach_mips8000
},
10693 { bfd_mach_mips10000
, bfd_mach_mips8000
},
10694 { bfd_mach_mips5000
, bfd_mach_mips8000
},
10695 { bfd_mach_mips7000
, bfd_mach_mips8000
},
10696 { bfd_mach_mips9000
, bfd_mach_mips8000
},
10698 /* VR4100 extensions. */
10699 { bfd_mach_mips4120
, bfd_mach_mips4100
},
10700 { bfd_mach_mips4111
, bfd_mach_mips4100
},
10702 /* MIPS III extensions. */
10703 { bfd_mach_mips8000
, bfd_mach_mips4000
},
10704 { bfd_mach_mips4650
, bfd_mach_mips4000
},
10705 { bfd_mach_mips4600
, bfd_mach_mips4000
},
10706 { bfd_mach_mips4400
, bfd_mach_mips4000
},
10707 { bfd_mach_mips4300
, bfd_mach_mips4000
},
10708 { bfd_mach_mips4100
, bfd_mach_mips4000
},
10709 { bfd_mach_mips4010
, bfd_mach_mips4000
},
10711 /* MIPS32 extensions. */
10712 { bfd_mach_mipsisa32r2
, bfd_mach_mipsisa32
},
10714 /* MIPS II extensions. */
10715 { bfd_mach_mips4000
, bfd_mach_mips6000
},
10716 { bfd_mach_mipsisa32
, bfd_mach_mips6000
},
10718 /* MIPS I extensions. */
10719 { bfd_mach_mips6000
, bfd_mach_mips3000
},
10720 { bfd_mach_mips3900
, bfd_mach_mips3000
}
10724 /* Return true if bfd machine EXTENSION is an extension of machine BASE. */
10727 mips_mach_extends_p (unsigned long base
, unsigned long extension
)
10731 if (extension
== base
)
10734 if (base
== bfd_mach_mipsisa32
10735 && mips_mach_extends_p (bfd_mach_mipsisa64
, extension
))
10738 if (base
== bfd_mach_mipsisa32r2
10739 && mips_mach_extends_p (bfd_mach_mipsisa64r2
, extension
))
10742 for (i
= 0; i
< ARRAY_SIZE (mips_mach_extensions
); i
++)
10743 if (extension
== mips_mach_extensions
[i
].extension
)
10745 extension
= mips_mach_extensions
[i
].base
;
10746 if (extension
== base
)
10754 /* Return true if the given ELF header flags describe a 32-bit binary. */
10757 mips_32bit_flags_p (flagword flags
)
10759 return ((flags
& EF_MIPS_32BITMODE
) != 0
10760 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
10761 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
10762 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
10763 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
10764 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
10765 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
);
10769 /* Merge backend specific data from an object file to the output
10770 object file when linking. */
10773 _bfd_mips_elf_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
10775 flagword old_flags
;
10776 flagword new_flags
;
10778 bfd_boolean null_input_bfd
= TRUE
;
10781 /* Check if we have the same endianess */
10782 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
10784 (*_bfd_error_handler
)
10785 (_("%B: endianness incompatible with that of the selected emulation"),
10790 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
10791 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
10794 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
10796 (*_bfd_error_handler
)
10797 (_("%B: ABI is incompatible with that of the selected emulation"),
10802 new_flags
= elf_elfheader (ibfd
)->e_flags
;
10803 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_NOREORDER
;
10804 old_flags
= elf_elfheader (obfd
)->e_flags
;
10806 if (! elf_flags_init (obfd
))
10808 elf_flags_init (obfd
) = TRUE
;
10809 elf_elfheader (obfd
)->e_flags
= new_flags
;
10810 elf_elfheader (obfd
)->e_ident
[EI_CLASS
]
10811 = elf_elfheader (ibfd
)->e_ident
[EI_CLASS
];
10813 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
10814 && bfd_get_arch_info (obfd
)->the_default
)
10816 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
10817 bfd_get_mach (ibfd
)))
10824 /* Check flag compatibility. */
10826 new_flags
&= ~EF_MIPS_NOREORDER
;
10827 old_flags
&= ~EF_MIPS_NOREORDER
;
10829 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
10830 doesn't seem to matter. */
10831 new_flags
&= ~EF_MIPS_XGOT
;
10832 old_flags
&= ~EF_MIPS_XGOT
;
10834 /* MIPSpro generates ucode info in n64 objects. Again, we should
10835 just be able to ignore this. */
10836 new_flags
&= ~EF_MIPS_UCODE
;
10837 old_flags
&= ~EF_MIPS_UCODE
;
10839 /* Don't care about the PIC flags from dynamic objects; they are
10841 if ((new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0
10842 && (ibfd
->flags
& DYNAMIC
) != 0)
10843 new_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
10845 if (new_flags
== old_flags
)
10848 /* Check to see if the input BFD actually contains any sections.
10849 If not, its flags may not have been initialised either, but it cannot
10850 actually cause any incompatibility. */
10851 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
10853 /* Ignore synthetic sections and empty .text, .data and .bss sections
10854 which are automatically generated by gas. */
10855 if (strcmp (sec
->name
, ".reginfo")
10856 && strcmp (sec
->name
, ".mdebug")
10858 || (strcmp (sec
->name
, ".text")
10859 && strcmp (sec
->name
, ".data")
10860 && strcmp (sec
->name
, ".bss"))))
10862 null_input_bfd
= FALSE
;
10866 if (null_input_bfd
)
10871 if (((new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0)
10872 != ((old_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0))
10874 (*_bfd_error_handler
)
10875 (_("%B: warning: linking PIC files with non-PIC files"),
10880 if (new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
))
10881 elf_elfheader (obfd
)->e_flags
|= EF_MIPS_CPIC
;
10882 if (! (new_flags
& EF_MIPS_PIC
))
10883 elf_elfheader (obfd
)->e_flags
&= ~EF_MIPS_PIC
;
10885 new_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
10886 old_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
10888 /* Compare the ISAs. */
10889 if (mips_32bit_flags_p (old_flags
) != mips_32bit_flags_p (new_flags
))
10891 (*_bfd_error_handler
)
10892 (_("%B: linking 32-bit code with 64-bit code"),
10896 else if (!mips_mach_extends_p (bfd_get_mach (ibfd
), bfd_get_mach (obfd
)))
10898 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
10899 if (mips_mach_extends_p (bfd_get_mach (obfd
), bfd_get_mach (ibfd
)))
10901 /* Copy the architecture info from IBFD to OBFD. Also copy
10902 the 32-bit flag (if set) so that we continue to recognise
10903 OBFD as a 32-bit binary. */
10904 bfd_set_arch_info (obfd
, bfd_get_arch_info (ibfd
));
10905 elf_elfheader (obfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
10906 elf_elfheader (obfd
)->e_flags
10907 |= new_flags
& (EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
10909 /* Copy across the ABI flags if OBFD doesn't use them
10910 and if that was what caused us to treat IBFD as 32-bit. */
10911 if ((old_flags
& EF_MIPS_ABI
) == 0
10912 && mips_32bit_flags_p (new_flags
)
10913 && !mips_32bit_flags_p (new_flags
& ~EF_MIPS_ABI
))
10914 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ABI
;
10918 /* The ISAs aren't compatible. */
10919 (*_bfd_error_handler
)
10920 (_("%B: linking %s module with previous %s modules"),
10922 bfd_printable_name (ibfd
),
10923 bfd_printable_name (obfd
));
10928 new_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
10929 old_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
10931 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
10932 does set EI_CLASS differently from any 32-bit ABI. */
10933 if ((new_flags
& EF_MIPS_ABI
) != (old_flags
& EF_MIPS_ABI
)
10934 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
10935 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
10937 /* Only error if both are set (to different values). */
10938 if (((new_flags
& EF_MIPS_ABI
) && (old_flags
& EF_MIPS_ABI
))
10939 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
10940 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
10942 (*_bfd_error_handler
)
10943 (_("%B: ABI mismatch: linking %s module with previous %s modules"),
10945 elf_mips_abi_name (ibfd
),
10946 elf_mips_abi_name (obfd
));
10949 new_flags
&= ~EF_MIPS_ABI
;
10950 old_flags
&= ~EF_MIPS_ABI
;
10953 /* For now, allow arbitrary mixing of ASEs (retain the union). */
10954 if ((new_flags
& EF_MIPS_ARCH_ASE
) != (old_flags
& EF_MIPS_ARCH_ASE
))
10956 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ARCH_ASE
;
10958 new_flags
&= ~ EF_MIPS_ARCH_ASE
;
10959 old_flags
&= ~ EF_MIPS_ARCH_ASE
;
10962 /* Warn about any other mismatches */
10963 if (new_flags
!= old_flags
)
10965 (*_bfd_error_handler
)
10966 (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
10967 ibfd
, (unsigned long) new_flags
,
10968 (unsigned long) old_flags
);
10974 bfd_set_error (bfd_error_bad_value
);
10981 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
10984 _bfd_mips_elf_set_private_flags (bfd
*abfd
, flagword flags
)
10986 BFD_ASSERT (!elf_flags_init (abfd
)
10987 || elf_elfheader (abfd
)->e_flags
== flags
);
10989 elf_elfheader (abfd
)->e_flags
= flags
;
10990 elf_flags_init (abfd
) = TRUE
;
10995 _bfd_mips_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
10999 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
11001 /* Print normal ELF private data. */
11002 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
11004 /* xgettext:c-format */
11005 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
11007 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
)
11008 fprintf (file
, _(" [abi=O32]"));
11009 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O64
)
11010 fprintf (file
, _(" [abi=O64]"));
11011 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
)
11012 fprintf (file
, _(" [abi=EABI32]"));
11013 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
11014 fprintf (file
, _(" [abi=EABI64]"));
11015 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
))
11016 fprintf (file
, _(" [abi unknown]"));
11017 else if (ABI_N32_P (abfd
))
11018 fprintf (file
, _(" [abi=N32]"));
11019 else if (ABI_64_P (abfd
))
11020 fprintf (file
, _(" [abi=64]"));
11022 fprintf (file
, _(" [no abi set]"));
11024 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
11025 fprintf (file
, _(" [mips1]"));
11026 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
11027 fprintf (file
, _(" [mips2]"));
11028 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
11029 fprintf (file
, _(" [mips3]"));
11030 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
11031 fprintf (file
, _(" [mips4]"));
11032 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_5
)
11033 fprintf (file
, _(" [mips5]"));
11034 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
)
11035 fprintf (file
, _(" [mips32]"));
11036 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64
)
11037 fprintf (file
, _(" [mips64]"));
11038 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
)
11039 fprintf (file
, _(" [mips32r2]"));
11040 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64R2
)
11041 fprintf (file
, _(" [mips64r2]"));
11043 fprintf (file
, _(" [unknown ISA]"));
11045 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
11046 fprintf (file
, _(" [mdmx]"));
11048 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_M16
)
11049 fprintf (file
, _(" [mips16]"));
11051 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_32BITMODE
)
11052 fprintf (file
, _(" [32bitmode]"));
11054 fprintf (file
, _(" [not 32bitmode]"));
11056 fputc ('\n', file
);
11061 const struct bfd_elf_special_section _bfd_mips_elf_special_sections
[] =
11063 { ".lit4", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
11064 { ".lit8", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
11065 { ".mdebug", 7, 0, SHT_MIPS_DEBUG
, 0 },
11066 { ".sbss", 5, -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
11067 { ".sdata", 6, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
11068 { ".ucode", 6, 0, SHT_MIPS_UCODE
, 0 },
11069 { NULL
, 0, 0, 0, 0 }
11072 /* Ensure that the STO_OPTIONAL flag is copied into h->other,
11073 even if this is not a defintion of the symbol. */
11075 _bfd_mips_elf_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
11076 const Elf_Internal_Sym
*isym
,
11077 bfd_boolean definition
,
11078 bfd_boolean dynamic ATTRIBUTE_UNUSED
)
11081 && ELF_MIPS_IS_OPTIONAL (isym
->st_other
))
11082 h
->other
|= STO_OPTIONAL
;
11085 /* Decide whether an undefined symbol is special and can be ignored.
11086 This is the case for OPTIONAL symbols on IRIX. */
11088 _bfd_mips_elf_ignore_undef_symbol (struct elf_link_hash_entry
*h
)
11090 return ELF_MIPS_IS_OPTIONAL (h
->other
) ? TRUE
: FALSE
;