1 /* MIPS-specific support for ELF
2 Copyright (C) 1993-2015 Free Software Foundation, Inc.
4 Most of the information added by Ian Lance Taylor, Cygnus Support,
6 N32/64 ABI support added by Mark Mitchell, CodeSourcery, LLC.
7 <mark@codesourcery.com>
8 Traditional MIPS targets support added by Koundinya.K, Dansk Data
9 Elektronik & Operations Research Group. <kk@ddeorg.soft.net>
11 This file is part of BFD, the Binary File Descriptor library.
13 This program is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 3 of the License, or
16 (at your option) any later version.
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
26 MA 02110-1301, USA. */
29 /* This file handles functionality common to the different MIPS ABI's. */
34 #include "libiberty.h"
36 #include "elfxx-mips.h"
38 #include "elf-vxworks.h"
41 /* Get the ECOFF swapping routines. */
43 #include "coff/symconst.h"
44 #include "coff/ecoff.h"
45 #include "coff/mips.h"
49 /* Types of TLS GOT entry. */
50 enum mips_got_tls_type
{
57 /* This structure is used to hold information about one GOT entry.
58 There are four types of entry:
60 (1) an absolute address
61 requires: abfd == NULL
64 (2) a SYMBOL + OFFSET address, where SYMBOL is local to an input bfd
65 requires: abfd != NULL, symndx >= 0, tls_type != GOT_TLS_LDM
66 fields: abfd, symndx, d.addend, tls_type
68 (3) a SYMBOL address, where SYMBOL is not local to an input bfd
69 requires: abfd != NULL, symndx == -1
73 requires: abfd != NULL, symndx == 0, tls_type == GOT_TLS_LDM
74 fields: none; there's only one of these per GOT. */
77 /* One input bfd that needs the GOT entry. */
79 /* The index of the symbol, as stored in the relocation r_info, if
80 we have a local symbol; -1 otherwise. */
84 /* If abfd == NULL, an address that must be stored in the got. */
86 /* If abfd != NULL && symndx != -1, the addend of the relocation
87 that should be added to the symbol value. */
89 /* If abfd != NULL && symndx == -1, the hash table entry
90 corresponding to a symbol in the GOT. The symbol's entry
91 is in the local area if h->global_got_area is GGA_NONE,
92 otherwise it is in the global area. */
93 struct mips_elf_link_hash_entry
*h
;
96 /* The TLS type of this GOT entry. An LDM GOT entry will be a local
97 symbol entry with r_symndx == 0. */
98 unsigned char tls_type
;
100 /* True if we have filled in the GOT contents for a TLS entry,
101 and created the associated relocations. */
102 unsigned char tls_initialized
;
104 /* The offset from the beginning of the .got section to the entry
105 corresponding to this symbol+addend. If it's a global symbol
106 whose offset is yet to be decided, it's going to be -1. */
110 /* This structure represents a GOT page reference from an input bfd.
111 Each instance represents a symbol + ADDEND, where the representation
112 of the symbol depends on whether it is local to the input bfd.
113 If it is, then SYMNDX >= 0, and the symbol has index SYMNDX in U.ABFD.
114 Otherwise, SYMNDX < 0 and U.H points to the symbol's hash table entry.
116 Page references with SYMNDX >= 0 always become page references
117 in the output. Page references with SYMNDX < 0 only become page
118 references if the symbol binds locally; in other cases, the page
119 reference decays to a global GOT reference. */
120 struct mips_got_page_ref
125 struct mips_elf_link_hash_entry
*h
;
131 /* This structure describes a range of addends: [MIN_ADDEND, MAX_ADDEND].
132 The structures form a non-overlapping list that is sorted by increasing
134 struct mips_got_page_range
136 struct mips_got_page_range
*next
;
137 bfd_signed_vma min_addend
;
138 bfd_signed_vma max_addend
;
141 /* This structure describes the range of addends that are applied to page
142 relocations against a given section. */
143 struct mips_got_page_entry
145 /* The section that these entries are based on. */
147 /* The ranges for this page entry. */
148 struct mips_got_page_range
*ranges
;
149 /* The maximum number of page entries needed for RANGES. */
153 /* This structure is used to hold .got information when linking. */
157 /* The number of global .got entries. */
158 unsigned int global_gotno
;
159 /* The number of global .got entries that are in the GGA_RELOC_ONLY area. */
160 unsigned int reloc_only_gotno
;
161 /* The number of .got slots used for TLS. */
162 unsigned int tls_gotno
;
163 /* The first unused TLS .got entry. Used only during
164 mips_elf_initialize_tls_index. */
165 unsigned int tls_assigned_gotno
;
166 /* The number of local .got entries, eventually including page entries. */
167 unsigned int local_gotno
;
168 /* The maximum number of page entries needed. */
169 unsigned int page_gotno
;
170 /* The number of relocations needed for the GOT entries. */
172 /* The first unused local .got entry. */
173 unsigned int assigned_low_gotno
;
174 /* The last unused local .got entry. */
175 unsigned int assigned_high_gotno
;
176 /* A hash table holding members of the got. */
177 struct htab
*got_entries
;
178 /* A hash table holding mips_got_page_ref structures. */
179 struct htab
*got_page_refs
;
180 /* A hash table of mips_got_page_entry structures. */
181 struct htab
*got_page_entries
;
182 /* In multi-got links, a pointer to the next got (err, rather, most
183 of the time, it points to the previous got). */
184 struct mips_got_info
*next
;
187 /* Structure passed when merging bfds' gots. */
189 struct mips_elf_got_per_bfd_arg
191 /* The output bfd. */
193 /* The link information. */
194 struct bfd_link_info
*info
;
195 /* A pointer to the primary got, i.e., the one that's going to get
196 the implicit relocations from DT_MIPS_LOCAL_GOTNO and
198 struct mips_got_info
*primary
;
199 /* A non-primary got we're trying to merge with other input bfd's
201 struct mips_got_info
*current
;
202 /* The maximum number of got entries that can be addressed with a
204 unsigned int max_count
;
205 /* The maximum number of page entries needed by each got. */
206 unsigned int max_pages
;
207 /* The total number of global entries which will live in the
208 primary got and be automatically relocated. This includes
209 those not referenced by the primary GOT but included in
211 unsigned int global_count
;
214 /* A structure used to pass information to htab_traverse callbacks
215 when laying out the GOT. */
217 struct mips_elf_traverse_got_arg
219 struct bfd_link_info
*info
;
220 struct mips_got_info
*g
;
224 struct _mips_elf_section_data
226 struct bfd_elf_section_data elf
;
233 #define mips_elf_section_data(sec) \
234 ((struct _mips_elf_section_data *) elf_section_data (sec))
236 #define is_mips_elf(bfd) \
237 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
238 && elf_tdata (bfd) != NULL \
239 && elf_object_id (bfd) == MIPS_ELF_DATA)
241 /* The ABI says that every symbol used by dynamic relocations must have
242 a global GOT entry. Among other things, this provides the dynamic
243 linker with a free, directly-indexed cache. The GOT can therefore
244 contain symbols that are not referenced by GOT relocations themselves
245 (in other words, it may have symbols that are not referenced by things
246 like R_MIPS_GOT16 and R_MIPS_GOT_PAGE).
248 GOT relocations are less likely to overflow if we put the associated
249 GOT entries towards the beginning. We therefore divide the global
250 GOT entries into two areas: "normal" and "reloc-only". Entries in
251 the first area can be used for both dynamic relocations and GP-relative
252 accesses, while those in the "reloc-only" area are for dynamic
255 These GGA_* ("Global GOT Area") values are organised so that lower
256 values are more general than higher values. Also, non-GGA_NONE
257 values are ordered by the position of the area in the GOT. */
259 #define GGA_RELOC_ONLY 1
262 /* Information about a non-PIC interface to a PIC function. There are
263 two ways of creating these interfaces. The first is to add:
266 addiu $25,$25,%lo(func)
268 immediately before a PIC function "func". The second is to add:
272 addiu $25,$25,%lo(func)
274 to a separate trampoline section.
276 Stubs of the first kind go in a new section immediately before the
277 target function. Stubs of the second kind go in a single section
278 pointed to by the hash table's "strampoline" field. */
279 struct mips_elf_la25_stub
{
280 /* The generated section that contains this stub. */
281 asection
*stub_section
;
283 /* The offset of the stub from the start of STUB_SECTION. */
286 /* One symbol for the original function. Its location is available
287 in H->root.root.u.def. */
288 struct mips_elf_link_hash_entry
*h
;
291 /* Macros for populating a mips_elf_la25_stub. */
293 #define LA25_LUI(VAL) (0x3c190000 | (VAL)) /* lui t9,VAL */
294 #define LA25_J(VAL) (0x08000000 | (((VAL) >> 2) & 0x3ffffff)) /* j VAL */
295 #define LA25_ADDIU(VAL) (0x27390000 | (VAL)) /* addiu t9,t9,VAL */
296 #define LA25_LUI_MICROMIPS(VAL) \
297 (0x41b90000 | (VAL)) /* lui t9,VAL */
298 #define LA25_J_MICROMIPS(VAL) \
299 (0xd4000000 | (((VAL) >> 1) & 0x3ffffff)) /* j VAL */
300 #define LA25_ADDIU_MICROMIPS(VAL) \
301 (0x33390000 | (VAL)) /* addiu t9,t9,VAL */
303 /* This structure is passed to mips_elf_sort_hash_table_f when sorting
304 the dynamic symbols. */
306 struct mips_elf_hash_sort_data
308 /* The symbol in the global GOT with the lowest dynamic symbol table
310 struct elf_link_hash_entry
*low
;
311 /* The least dynamic symbol table index corresponding to a non-TLS
312 symbol with a GOT entry. */
313 long min_got_dynindx
;
314 /* The greatest dynamic symbol table index corresponding to a symbol
315 with a GOT entry that is not referenced (e.g., a dynamic symbol
316 with dynamic relocations pointing to it from non-primary GOTs). */
317 long max_unref_got_dynindx
;
318 /* The greatest dynamic symbol table index not corresponding to a
319 symbol without a GOT entry. */
320 long max_non_got_dynindx
;
323 /* We make up to two PLT entries if needed, one for standard MIPS code
324 and one for compressed code, either a MIPS16 or microMIPS one. We
325 keep a separate record of traditional lazy-binding stubs, for easier
330 /* Traditional SVR4 stub offset, or -1 if none. */
333 /* Standard PLT entry offset, or -1 if none. */
336 /* Compressed PLT entry offset, or -1 if none. */
339 /* The corresponding .got.plt index, or -1 if none. */
340 bfd_vma gotplt_index
;
342 /* Whether we need a standard PLT entry. */
343 unsigned int need_mips
: 1;
345 /* Whether we need a compressed PLT entry. */
346 unsigned int need_comp
: 1;
349 /* The MIPS ELF linker needs additional information for each symbol in
350 the global hash table. */
352 struct mips_elf_link_hash_entry
354 struct elf_link_hash_entry root
;
356 /* External symbol information. */
359 /* The la25 stub we have created for ths symbol, if any. */
360 struct mips_elf_la25_stub
*la25_stub
;
362 /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
364 unsigned int possibly_dynamic_relocs
;
366 /* If there is a stub that 32 bit functions should use to call this
367 16 bit function, this points to the section containing the stub. */
370 /* If there is a stub that 16 bit functions should use to call this
371 32 bit function, this points to the section containing the stub. */
374 /* This is like the call_stub field, but it is used if the function
375 being called returns a floating point value. */
376 asection
*call_fp_stub
;
378 /* The highest GGA_* value that satisfies all references to this symbol. */
379 unsigned int global_got_area
: 2;
381 /* True if all GOT relocations against this symbol are for calls. This is
382 a looser condition than no_fn_stub below, because there may be other
383 non-call non-GOT relocations against the symbol. */
384 unsigned int got_only_for_calls
: 1;
386 /* True if one of the relocations described by possibly_dynamic_relocs
387 is against a readonly section. */
388 unsigned int readonly_reloc
: 1;
390 /* True if there is a relocation against this symbol that must be
391 resolved by the static linker (in other words, if the relocation
392 cannot possibly be made dynamic). */
393 unsigned int has_static_relocs
: 1;
395 /* True if we must not create a .MIPS.stubs entry for this symbol.
396 This is set, for example, if there are relocations related to
397 taking the function's address, i.e. any but R_MIPS_CALL*16 ones.
398 See "MIPS ABI Supplement, 3rd Edition", p. 4-20. */
399 unsigned int no_fn_stub
: 1;
401 /* Whether we need the fn_stub; this is true if this symbol appears
402 in any relocs other than a 16 bit call. */
403 unsigned int need_fn_stub
: 1;
405 /* True if this symbol is referenced by branch relocations from
406 any non-PIC input file. This is used to determine whether an
407 la25 stub is required. */
408 unsigned int has_nonpic_branches
: 1;
410 /* Does this symbol need a traditional MIPS lazy-binding stub
411 (as opposed to a PLT entry)? */
412 unsigned int needs_lazy_stub
: 1;
414 /* Does this symbol resolve to a PLT entry? */
415 unsigned int use_plt_entry
: 1;
418 /* MIPS ELF linker hash table. */
420 struct mips_elf_link_hash_table
422 struct elf_link_hash_table root
;
424 /* The number of .rtproc entries. */
425 bfd_size_type procedure_count
;
427 /* The size of the .compact_rel section (if SGI_COMPAT). */
428 bfd_size_type compact_rel_size
;
430 /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic entry
431 is set to the address of __rld_obj_head as in IRIX5 and IRIX6. */
432 bfd_boolean use_rld_obj_head
;
434 /* The __rld_map or __rld_obj_head symbol. */
435 struct elf_link_hash_entry
*rld_symbol
;
437 /* This is set if we see any mips16 stub sections. */
438 bfd_boolean mips16_stubs_seen
;
440 /* True if we can generate copy relocs and PLTs. */
441 bfd_boolean use_plts_and_copy_relocs
;
443 /* True if we can only use 32-bit microMIPS instructions. */
446 /* True if we're generating code for VxWorks. */
447 bfd_boolean is_vxworks
;
449 /* True if we already reported the small-data section overflow. */
450 bfd_boolean small_data_overflow_reported
;
452 /* Shortcuts to some dynamic sections, or NULL if they are not
463 /* The master GOT information. */
464 struct mips_got_info
*got_info
;
466 /* The global symbol in the GOT with the lowest index in the dynamic
468 struct elf_link_hash_entry
*global_gotsym
;
470 /* The size of the PLT header in bytes. */
471 bfd_vma plt_header_size
;
473 /* The size of a standard PLT entry in bytes. */
474 bfd_vma plt_mips_entry_size
;
476 /* The size of a compressed PLT entry in bytes. */
477 bfd_vma plt_comp_entry_size
;
479 /* The offset of the next standard PLT entry to create. */
480 bfd_vma plt_mips_offset
;
482 /* The offset of the next compressed PLT entry to create. */
483 bfd_vma plt_comp_offset
;
485 /* The index of the next .got.plt entry to create. */
486 bfd_vma plt_got_index
;
488 /* The number of functions that need a lazy-binding stub. */
489 bfd_vma lazy_stub_count
;
491 /* The size of a function stub entry in bytes. */
492 bfd_vma function_stub_size
;
494 /* The number of reserved entries at the beginning of the GOT. */
495 unsigned int reserved_gotno
;
497 /* The section used for mips_elf_la25_stub trampolines.
498 See the comment above that structure for details. */
499 asection
*strampoline
;
501 /* A table of mips_elf_la25_stubs, indexed by (input_section, offset)
505 /* A function FN (NAME, IS, OS) that creates a new input section
506 called NAME and links it to output section OS. If IS is nonnull,
507 the new section should go immediately before it, otherwise it
508 should go at the (current) beginning of OS.
510 The function returns the new section on success, otherwise it
512 asection
*(*add_stub_section
) (const char *, asection
*, asection
*);
514 /* Small local sym cache. */
515 struct sym_cache sym_cache
;
517 /* Is the PLT header compressed? */
518 unsigned int plt_header_is_comp
: 1;
521 /* Get the MIPS ELF linker hash table from a link_info structure. */
523 #define mips_elf_hash_table(p) \
524 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
525 == MIPS_ELF_DATA ? ((struct mips_elf_link_hash_table *) ((p)->hash)) : NULL)
527 /* A structure used to communicate with htab_traverse callbacks. */
528 struct mips_htab_traverse_info
530 /* The usual link-wide information. */
531 struct bfd_link_info
*info
;
534 /* Starts off FALSE and is set to TRUE if the link should be aborted. */
538 /* MIPS ELF private object data. */
540 struct mips_elf_obj_tdata
542 /* Generic ELF private object data. */
543 struct elf_obj_tdata root
;
545 /* Input BFD providing Tag_GNU_MIPS_ABI_FP attribute for output. */
548 /* Input BFD providing Tag_GNU_MIPS_ABI_MSA attribute for output. */
551 /* The abiflags for this object. */
552 Elf_Internal_ABIFlags_v0 abiflags
;
553 bfd_boolean abiflags_valid
;
555 /* The GOT requirements of input bfds. */
556 struct mips_got_info
*got
;
558 /* Used by _bfd_mips_elf_find_nearest_line. The structure could be
559 included directly in this one, but there's no point to wasting
560 the memory just for the infrequently called find_nearest_line. */
561 struct mips_elf_find_line
*find_line_info
;
563 /* An array of stub sections indexed by symbol number. */
564 asection
**local_stubs
;
565 asection
**local_call_stubs
;
567 /* The Irix 5 support uses two virtual sections, which represent
568 text/data symbols defined in dynamic objects. */
569 asymbol
*elf_data_symbol
;
570 asymbol
*elf_text_symbol
;
571 asection
*elf_data_section
;
572 asection
*elf_text_section
;
575 /* Get MIPS ELF private object data from BFD's tdata. */
577 #define mips_elf_tdata(bfd) \
578 ((struct mips_elf_obj_tdata *) (bfd)->tdata.any)
580 #define TLS_RELOC_P(r_type) \
581 (r_type == R_MIPS_TLS_DTPMOD32 \
582 || r_type == R_MIPS_TLS_DTPMOD64 \
583 || r_type == R_MIPS_TLS_DTPREL32 \
584 || r_type == R_MIPS_TLS_DTPREL64 \
585 || r_type == R_MIPS_TLS_GD \
586 || r_type == R_MIPS_TLS_LDM \
587 || r_type == R_MIPS_TLS_DTPREL_HI16 \
588 || r_type == R_MIPS_TLS_DTPREL_LO16 \
589 || r_type == R_MIPS_TLS_GOTTPREL \
590 || r_type == R_MIPS_TLS_TPREL32 \
591 || r_type == R_MIPS_TLS_TPREL64 \
592 || r_type == R_MIPS_TLS_TPREL_HI16 \
593 || r_type == R_MIPS_TLS_TPREL_LO16 \
594 || r_type == R_MIPS16_TLS_GD \
595 || r_type == R_MIPS16_TLS_LDM \
596 || r_type == R_MIPS16_TLS_DTPREL_HI16 \
597 || r_type == R_MIPS16_TLS_DTPREL_LO16 \
598 || r_type == R_MIPS16_TLS_GOTTPREL \
599 || r_type == R_MIPS16_TLS_TPREL_HI16 \
600 || r_type == R_MIPS16_TLS_TPREL_LO16 \
601 || r_type == R_MICROMIPS_TLS_GD \
602 || r_type == R_MICROMIPS_TLS_LDM \
603 || r_type == R_MICROMIPS_TLS_DTPREL_HI16 \
604 || r_type == R_MICROMIPS_TLS_DTPREL_LO16 \
605 || r_type == R_MICROMIPS_TLS_GOTTPREL \
606 || r_type == R_MICROMIPS_TLS_TPREL_HI16 \
607 || r_type == R_MICROMIPS_TLS_TPREL_LO16)
609 /* Structure used to pass information to mips_elf_output_extsym. */
614 struct bfd_link_info
*info
;
615 struct ecoff_debug_info
*debug
;
616 const struct ecoff_debug_swap
*swap
;
620 /* The names of the runtime procedure table symbols used on IRIX5. */
622 static const char * const mips_elf_dynsym_rtproc_names
[] =
625 "_procedure_string_table",
626 "_procedure_table_size",
630 /* These structures are used to generate the .compact_rel section on
635 unsigned long id1
; /* Always one? */
636 unsigned long num
; /* Number of compact relocation entries. */
637 unsigned long id2
; /* Always two? */
638 unsigned long offset
; /* The file offset of the first relocation. */
639 unsigned long reserved0
; /* Zero? */
640 unsigned long reserved1
; /* Zero? */
649 bfd_byte reserved0
[4];
650 bfd_byte reserved1
[4];
651 } Elf32_External_compact_rel
;
655 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
656 unsigned int rtype
: 4; /* Relocation types. See below. */
657 unsigned int dist2to
: 8;
658 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
659 unsigned long konst
; /* KONST field. See below. */
660 unsigned long vaddr
; /* VADDR to be relocated. */
665 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
666 unsigned int rtype
: 4; /* Relocation types. See below. */
667 unsigned int dist2to
: 8;
668 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
669 unsigned long konst
; /* KONST field. See below. */
677 } Elf32_External_crinfo
;
683 } Elf32_External_crinfo2
;
685 /* These are the constants used to swap the bitfields in a crinfo. */
687 #define CRINFO_CTYPE (0x1)
688 #define CRINFO_CTYPE_SH (31)
689 #define CRINFO_RTYPE (0xf)
690 #define CRINFO_RTYPE_SH (27)
691 #define CRINFO_DIST2TO (0xff)
692 #define CRINFO_DIST2TO_SH (19)
693 #define CRINFO_RELVADDR (0x7ffff)
694 #define CRINFO_RELVADDR_SH (0)
696 /* A compact relocation info has long (3 words) or short (2 words)
697 formats. A short format doesn't have VADDR field and relvaddr
698 fields contains ((VADDR - vaddr of the previous entry) >> 2). */
699 #define CRF_MIPS_LONG 1
700 #define CRF_MIPS_SHORT 0
702 /* There are 4 types of compact relocation at least. The value KONST
703 has different meaning for each type:
706 CT_MIPS_REL32 Address in data
707 CT_MIPS_WORD Address in word (XXX)
708 CT_MIPS_GPHI_LO GP - vaddr
709 CT_MIPS_JMPAD Address to jump
712 #define CRT_MIPS_REL32 0xa
713 #define CRT_MIPS_WORD 0xb
714 #define CRT_MIPS_GPHI_LO 0xc
715 #define CRT_MIPS_JMPAD 0xd
717 #define mips_elf_set_cr_format(x,format) ((x).ctype = (format))
718 #define mips_elf_set_cr_type(x,type) ((x).rtype = (type))
719 #define mips_elf_set_cr_dist2to(x,v) ((x).dist2to = (v))
720 #define mips_elf_set_cr_relvaddr(x,d) ((x).relvaddr = (d)<<2)
722 /* The structure of the runtime procedure descriptor created by the
723 loader for use by the static exception system. */
725 typedef struct runtime_pdr
{
726 bfd_vma adr
; /* Memory address of start of procedure. */
727 long regmask
; /* Save register mask. */
728 long regoffset
; /* Save register offset. */
729 long fregmask
; /* Save floating point register mask. */
730 long fregoffset
; /* Save floating point register offset. */
731 long frameoffset
; /* Frame size. */
732 short framereg
; /* Frame pointer register. */
733 short pcreg
; /* Offset or reg of return pc. */
734 long irpss
; /* Index into the runtime string table. */
736 struct exception_info
*exception_info
;/* Pointer to exception array. */
738 #define cbRPDR sizeof (RPDR)
739 #define rpdNil ((pRPDR) 0)
741 static struct mips_got_entry
*mips_elf_create_local_got_entry
742 (bfd
*, struct bfd_link_info
*, bfd
*, bfd_vma
, unsigned long,
743 struct mips_elf_link_hash_entry
*, int);
744 static bfd_boolean mips_elf_sort_hash_table_f
745 (struct mips_elf_link_hash_entry
*, void *);
746 static bfd_vma mips_elf_high
748 static bfd_boolean mips_elf_create_dynamic_relocation
749 (bfd
*, struct bfd_link_info
*, const Elf_Internal_Rela
*,
750 struct mips_elf_link_hash_entry
*, asection
*, bfd_vma
,
751 bfd_vma
*, asection
*);
752 static bfd_vma mips_elf_adjust_gp
753 (bfd
*, struct mips_got_info
*, bfd
*);
755 /* This will be used when we sort the dynamic relocation records. */
756 static bfd
*reldyn_sorting_bfd
;
758 /* True if ABFD is for CPUs with load interlocking that include
759 non-MIPS1 CPUs and R3900. */
760 #define LOAD_INTERLOCKS_P(abfd) \
761 ( ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) != E_MIPS_ARCH_1) \
762 || ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == E_MIPS_MACH_3900))
764 /* True if ABFD is for CPUs that are faster if JAL is converted to BAL.
765 This should be safe for all architectures. We enable this predicate
766 for RM9000 for now. */
767 #define JAL_TO_BAL_P(abfd) \
768 ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == E_MIPS_MACH_9000)
770 /* True if ABFD is for CPUs that are faster if JALR is converted to BAL.
771 This should be safe for all architectures. We enable this predicate for
773 #define JALR_TO_BAL_P(abfd) 1
775 /* True if ABFD is for CPUs that are faster if JR is converted to B.
776 This should be safe for all architectures. We enable this predicate for
778 #define JR_TO_B_P(abfd) 1
780 /* True if ABFD is a PIC object. */
781 #define PIC_OBJECT_P(abfd) \
782 ((elf_elfheader (abfd)->e_flags & EF_MIPS_PIC) != 0)
784 /* Nonzero if ABFD is using the O32 ABI. */
785 #define ABI_O32_P(abfd) \
786 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32)
788 /* Nonzero if ABFD is using the N32 ABI. */
789 #define ABI_N32_P(abfd) \
790 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
792 /* Nonzero if ABFD is using the N64 ABI. */
793 #define ABI_64_P(abfd) \
794 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
796 /* Nonzero if ABFD is using NewABI conventions. */
797 #define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
799 /* Nonzero if ABFD has microMIPS code. */
800 #define MICROMIPS_P(abfd) \
801 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS) != 0)
803 /* Nonzero if ABFD is MIPS R6. */
804 #define MIPSR6_P(abfd) \
805 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R6 \
806 || (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R6)
808 /* The IRIX compatibility level we are striving for. */
809 #define IRIX_COMPAT(abfd) \
810 (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
812 /* Whether we are trying to be compatible with IRIX at all. */
813 #define SGI_COMPAT(abfd) \
814 (IRIX_COMPAT (abfd) != ict_none)
816 /* The name of the options section. */
817 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
818 (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
820 /* True if NAME is the recognized name of any SHT_MIPS_OPTIONS section.
821 Some IRIX system files do not use MIPS_ELF_OPTIONS_SECTION_NAME. */
822 #define MIPS_ELF_OPTIONS_SECTION_NAME_P(NAME) \
823 (strcmp (NAME, ".MIPS.options") == 0 || strcmp (NAME, ".options") == 0)
825 /* True if NAME is the recognized name of any SHT_MIPS_ABIFLAGS section. */
826 #define MIPS_ELF_ABIFLAGS_SECTION_NAME_P(NAME) \
827 (strcmp (NAME, ".MIPS.abiflags") == 0)
829 /* Whether the section is readonly. */
830 #define MIPS_ELF_READONLY_SECTION(sec) \
831 ((sec->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY)) \
832 == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
834 /* The name of the stub section. */
835 #define MIPS_ELF_STUB_SECTION_NAME(abfd) ".MIPS.stubs"
837 /* The size of an external REL relocation. */
838 #define MIPS_ELF_REL_SIZE(abfd) \
839 (get_elf_backend_data (abfd)->s->sizeof_rel)
841 /* The size of an external RELA relocation. */
842 #define MIPS_ELF_RELA_SIZE(abfd) \
843 (get_elf_backend_data (abfd)->s->sizeof_rela)
845 /* The size of an external dynamic table entry. */
846 #define MIPS_ELF_DYN_SIZE(abfd) \
847 (get_elf_backend_data (abfd)->s->sizeof_dyn)
849 /* The size of a GOT entry. */
850 #define MIPS_ELF_GOT_SIZE(abfd) \
851 (get_elf_backend_data (abfd)->s->arch_size / 8)
853 /* The size of the .rld_map section. */
854 #define MIPS_ELF_RLD_MAP_SIZE(abfd) \
855 (get_elf_backend_data (abfd)->s->arch_size / 8)
857 /* The size of a symbol-table entry. */
858 #define MIPS_ELF_SYM_SIZE(abfd) \
859 (get_elf_backend_data (abfd)->s->sizeof_sym)
861 /* The default alignment for sections, as a power of two. */
862 #define MIPS_ELF_LOG_FILE_ALIGN(abfd) \
863 (get_elf_backend_data (abfd)->s->log_file_align)
865 /* Get word-sized data. */
866 #define MIPS_ELF_GET_WORD(abfd, ptr) \
867 (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
869 /* Put out word-sized data. */
870 #define MIPS_ELF_PUT_WORD(abfd, val, ptr) \
872 ? bfd_put_64 (abfd, val, ptr) \
873 : bfd_put_32 (abfd, val, ptr))
875 /* The opcode for word-sized loads (LW or LD). */
876 #define MIPS_ELF_LOAD_WORD(abfd) \
877 (ABI_64_P (abfd) ? 0xdc000000 : 0x8c000000)
879 /* Add a dynamic symbol table-entry. */
880 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
881 _bfd_elf_add_dynamic_entry (info, tag, val)
883 #define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela) \
884 (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela))
886 /* The name of the dynamic relocation section. */
887 #define MIPS_ELF_REL_DYN_NAME(INFO) \
888 (mips_elf_hash_table (INFO)->is_vxworks ? ".rela.dyn" : ".rel.dyn")
890 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
891 from smaller values. Start with zero, widen, *then* decrement. */
892 #define MINUS_ONE (((bfd_vma)0) - 1)
893 #define MINUS_TWO (((bfd_vma)0) - 2)
895 /* The value to write into got[1] for SVR4 targets, to identify it is
896 a GNU object. The dynamic linker can then use got[1] to store the
898 #define MIPS_ELF_GNU_GOT1_MASK(abfd) \
899 ((bfd_vma) 1 << (ABI_64_P (abfd) ? 63 : 31))
901 /* The offset of $gp from the beginning of the .got section. */
902 #define ELF_MIPS_GP_OFFSET(INFO) \
903 (mips_elf_hash_table (INFO)->is_vxworks ? 0x0 : 0x7ff0)
905 /* The maximum size of the GOT for it to be addressable using 16-bit
907 #define MIPS_ELF_GOT_MAX_SIZE(INFO) (ELF_MIPS_GP_OFFSET (INFO) + 0x7fff)
909 /* Instructions which appear in a stub. */
910 #define STUB_LW(abfd) \
912 ? 0xdf998010 /* ld t9,0x8010(gp) */ \
913 : 0x8f998010)) /* lw t9,0x8010(gp) */
914 #define STUB_MOVE 0x03e07825 /* or t7,ra,zero */
915 #define STUB_LUI(VAL) (0x3c180000 + (VAL)) /* lui t8,VAL */
916 #define STUB_JALR 0x0320f809 /* jalr t9,ra */
917 #define STUB_ORI(VAL) (0x37180000 + (VAL)) /* ori t8,t8,VAL */
918 #define STUB_LI16U(VAL) (0x34180000 + (VAL)) /* ori t8,zero,VAL unsigned */
919 #define STUB_LI16S(abfd, VAL) \
921 ? (0x64180000 + (VAL)) /* daddiu t8,zero,VAL sign extended */ \
922 : (0x24180000 + (VAL)))) /* addiu t8,zero,VAL sign extended */
924 /* Likewise for the microMIPS ASE. */
925 #define STUB_LW_MICROMIPS(abfd) \
927 ? 0xdf3c8010 /* ld t9,0x8010(gp) */ \
928 : 0xff3c8010) /* lw t9,0x8010(gp) */
929 #define STUB_MOVE_MICROMIPS 0x0dff /* move t7,ra */
930 #define STUB_MOVE32_MICROMIPS 0x001f7a90 /* or t7,ra,zero */
931 #define STUB_LUI_MICROMIPS(VAL) \
932 (0x41b80000 + (VAL)) /* lui t8,VAL */
933 #define STUB_JALR_MICROMIPS 0x45d9 /* jalr t9 */
934 #define STUB_JALR32_MICROMIPS 0x03f90f3c /* jalr ra,t9 */
935 #define STUB_ORI_MICROMIPS(VAL) \
936 (0x53180000 + (VAL)) /* ori t8,t8,VAL */
937 #define STUB_LI16U_MICROMIPS(VAL) \
938 (0x53000000 + (VAL)) /* ori t8,zero,VAL unsigned */
939 #define STUB_LI16S_MICROMIPS(abfd, VAL) \
941 ? 0x5f000000 + (VAL) /* daddiu t8,zero,VAL sign extended */ \
942 : 0x33000000 + (VAL)) /* addiu t8,zero,VAL sign extended */
944 #define MIPS_FUNCTION_STUB_NORMAL_SIZE 16
945 #define MIPS_FUNCTION_STUB_BIG_SIZE 20
946 #define MICROMIPS_FUNCTION_STUB_NORMAL_SIZE 12
947 #define MICROMIPS_FUNCTION_STUB_BIG_SIZE 16
948 #define MICROMIPS_INSN32_FUNCTION_STUB_NORMAL_SIZE 16
949 #define MICROMIPS_INSN32_FUNCTION_STUB_BIG_SIZE 20
951 /* The name of the dynamic interpreter. This is put in the .interp
954 #define ELF_DYNAMIC_INTERPRETER(abfd) \
955 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
956 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
957 : "/usr/lib/libc.so.1")
960 #define MNAME(bfd,pre,pos) \
961 (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
962 #define ELF_R_SYM(bfd, i) \
963 (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
964 #define ELF_R_TYPE(bfd, i) \
965 (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
966 #define ELF_R_INFO(bfd, s, t) \
967 (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
969 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
970 #define ELF_R_SYM(bfd, i) \
972 #define ELF_R_TYPE(bfd, i) \
974 #define ELF_R_INFO(bfd, s, t) \
975 (ELF32_R_INFO (s, t))
978 /* The mips16 compiler uses a couple of special sections to handle
979 floating point arguments.
981 Section names that look like .mips16.fn.FNNAME contain stubs that
982 copy floating point arguments from the fp regs to the gp regs and
983 then jump to FNNAME. If any 32 bit function calls FNNAME, the
984 call should be redirected to the stub instead. If no 32 bit
985 function calls FNNAME, the stub should be discarded. We need to
986 consider any reference to the function, not just a call, because
987 if the address of the function is taken we will need the stub,
988 since the address might be passed to a 32 bit function.
990 Section names that look like .mips16.call.FNNAME contain stubs
991 that copy floating point arguments from the gp regs to the fp
992 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
993 then any 16 bit function that calls FNNAME should be redirected
994 to the stub instead. If FNNAME is not a 32 bit function, the
995 stub should be discarded.
997 .mips16.call.fp.FNNAME sections are similar, but contain stubs
998 which call FNNAME and then copy the return value from the fp regs
999 to the gp regs. These stubs store the return value in $18 while
1000 calling FNNAME; any function which might call one of these stubs
1001 must arrange to save $18 around the call. (This case is not
1002 needed for 32 bit functions that call 16 bit functions, because
1003 16 bit functions always return floating point values in both
1006 Note that in all cases FNNAME might be defined statically.
1007 Therefore, FNNAME is not used literally. Instead, the relocation
1008 information will indicate which symbol the section is for.
1010 We record any stubs that we find in the symbol table. */
1012 #define FN_STUB ".mips16.fn."
1013 #define CALL_STUB ".mips16.call."
1014 #define CALL_FP_STUB ".mips16.call.fp."
1016 #define FN_STUB_P(name) CONST_STRNEQ (name, FN_STUB)
1017 #define CALL_STUB_P(name) CONST_STRNEQ (name, CALL_STUB)
1018 #define CALL_FP_STUB_P(name) CONST_STRNEQ (name, CALL_FP_STUB)
1020 /* The format of the first PLT entry in an O32 executable. */
1021 static const bfd_vma mips_o32_exec_plt0_entry
[] =
1023 0x3c1c0000, /* lui $28, %hi(&GOTPLT[0]) */
1024 0x8f990000, /* lw $25, %lo(&GOTPLT[0])($28) */
1025 0x279c0000, /* addiu $28, $28, %lo(&GOTPLT[0]) */
1026 0x031cc023, /* subu $24, $24, $28 */
1027 0x03e07825, /* or t7, ra, zero */
1028 0x0018c082, /* srl $24, $24, 2 */
1029 0x0320f809, /* jalr $25 */
1030 0x2718fffe /* subu $24, $24, 2 */
1033 /* The format of the first PLT entry in an N32 executable. Different
1034 because gp ($28) is not available; we use t2 ($14) instead. */
1035 static const bfd_vma mips_n32_exec_plt0_entry
[] =
1037 0x3c0e0000, /* lui $14, %hi(&GOTPLT[0]) */
1038 0x8dd90000, /* lw $25, %lo(&GOTPLT[0])($14) */
1039 0x25ce0000, /* addiu $14, $14, %lo(&GOTPLT[0]) */
1040 0x030ec023, /* subu $24, $24, $14 */
1041 0x03e07825, /* or t7, ra, zero */
1042 0x0018c082, /* srl $24, $24, 2 */
1043 0x0320f809, /* jalr $25 */
1044 0x2718fffe /* subu $24, $24, 2 */
1047 /* The format of the first PLT entry in an N64 executable. Different
1048 from N32 because of the increased size of GOT entries. */
1049 static const bfd_vma mips_n64_exec_plt0_entry
[] =
1051 0x3c0e0000, /* lui $14, %hi(&GOTPLT[0]) */
1052 0xddd90000, /* ld $25, %lo(&GOTPLT[0])($14) */
1053 0x25ce0000, /* addiu $14, $14, %lo(&GOTPLT[0]) */
1054 0x030ec023, /* subu $24, $24, $14 */
1055 0x03e07825, /* or t7, ra, zero */
1056 0x0018c0c2, /* srl $24, $24, 3 */
1057 0x0320f809, /* jalr $25 */
1058 0x2718fffe /* subu $24, $24, 2 */
1061 /* The format of the microMIPS first PLT entry in an O32 executable.
1062 We rely on v0 ($2) rather than t8 ($24) to contain the address
1063 of the GOTPLT entry handled, so this stub may only be used when
1064 all the subsequent PLT entries are microMIPS code too.
1066 The trailing NOP is for alignment and correct disassembly only. */
1067 static const bfd_vma micromips_o32_exec_plt0_entry
[] =
1069 0x7980, 0x0000, /* addiupc $3, (&GOTPLT[0]) - . */
1070 0xff23, 0x0000, /* lw $25, 0($3) */
1071 0x0535, /* subu $2, $2, $3 */
1072 0x2525, /* srl $2, $2, 2 */
1073 0x3302, 0xfffe, /* subu $24, $2, 2 */
1074 0x0dff, /* move $15, $31 */
1075 0x45f9, /* jalrs $25 */
1076 0x0f83, /* move $28, $3 */
1080 /* The format of the microMIPS first PLT entry in an O32 executable
1081 in the insn32 mode. */
1082 static const bfd_vma micromips_insn32_o32_exec_plt0_entry
[] =
1084 0x41bc, 0x0000, /* lui $28, %hi(&GOTPLT[0]) */
1085 0xff3c, 0x0000, /* lw $25, %lo(&GOTPLT[0])($28) */
1086 0x339c, 0x0000, /* addiu $28, $28, %lo(&GOTPLT[0]) */
1087 0x0398, 0xc1d0, /* subu $24, $24, $28 */
1088 0x001f, 0x7a90, /* or $15, $31, zero */
1089 0x0318, 0x1040, /* srl $24, $24, 2 */
1090 0x03f9, 0x0f3c, /* jalr $25 */
1091 0x3318, 0xfffe /* subu $24, $24, 2 */
1094 /* The format of subsequent standard PLT entries. */
1095 static const bfd_vma mips_exec_plt_entry
[] =
1097 0x3c0f0000, /* lui $15, %hi(.got.plt entry) */
1098 0x01f90000, /* l[wd] $25, %lo(.got.plt entry)($15) */
1099 0x25f80000, /* addiu $24, $15, %lo(.got.plt entry) */
1100 0x03200008 /* jr $25 */
1103 /* In the following PLT entry the JR and ADDIU instructions will
1104 be swapped in _bfd_mips_elf_finish_dynamic_symbol because
1105 LOAD_INTERLOCKS_P will be true for MIPS R6. */
1106 static const bfd_vma mipsr6_exec_plt_entry
[] =
1108 0x3c0f0000, /* lui $15, %hi(.got.plt entry) */
1109 0x01f90000, /* l[wd] $25, %lo(.got.plt entry)($15) */
1110 0x25f80000, /* addiu $24, $15, %lo(.got.plt entry) */
1111 0x03200009 /* jr $25 */
1114 /* The format of subsequent MIPS16 o32 PLT entries. We use v0 ($2)
1115 and v1 ($3) as temporaries because t8 ($24) and t9 ($25) are not
1116 directly addressable. */
1117 static const bfd_vma mips16_o32_exec_plt_entry
[] =
1119 0xb203, /* lw $2, 12($pc) */
1120 0x9a60, /* lw $3, 0($2) */
1121 0x651a, /* move $24, $2 */
1123 0x653b, /* move $25, $3 */
1125 0x0000, 0x0000 /* .word (.got.plt entry) */
1128 /* The format of subsequent microMIPS o32 PLT entries. We use v0 ($2)
1129 as a temporary because t8 ($24) is not addressable with ADDIUPC. */
1130 static const bfd_vma micromips_o32_exec_plt_entry
[] =
1132 0x7900, 0x0000, /* addiupc $2, (.got.plt entry) - . */
1133 0xff22, 0x0000, /* lw $25, 0($2) */
1134 0x4599, /* jr $25 */
1135 0x0f02 /* move $24, $2 */
1138 /* The format of subsequent microMIPS o32 PLT entries in the insn32 mode. */
1139 static const bfd_vma micromips_insn32_o32_exec_plt_entry
[] =
1141 0x41af, 0x0000, /* lui $15, %hi(.got.plt entry) */
1142 0xff2f, 0x0000, /* lw $25, %lo(.got.plt entry)($15) */
1143 0x0019, 0x0f3c, /* jr $25 */
1144 0x330f, 0x0000 /* addiu $24, $15, %lo(.got.plt entry) */
1147 /* The format of the first PLT entry in a VxWorks executable. */
1148 static const bfd_vma mips_vxworks_exec_plt0_entry
[] =
1150 0x3c190000, /* lui t9, %hi(_GLOBAL_OFFSET_TABLE_) */
1151 0x27390000, /* addiu t9, t9, %lo(_GLOBAL_OFFSET_TABLE_) */
1152 0x8f390008, /* lw t9, 8(t9) */
1153 0x00000000, /* nop */
1154 0x03200008, /* jr t9 */
1155 0x00000000 /* nop */
1158 /* The format of subsequent PLT entries. */
1159 static const bfd_vma mips_vxworks_exec_plt_entry
[] =
1161 0x10000000, /* b .PLT_resolver */
1162 0x24180000, /* li t8, <pltindex> */
1163 0x3c190000, /* lui t9, %hi(<.got.plt slot>) */
1164 0x27390000, /* addiu t9, t9, %lo(<.got.plt slot>) */
1165 0x8f390000, /* lw t9, 0(t9) */
1166 0x00000000, /* nop */
1167 0x03200008, /* jr t9 */
1168 0x00000000 /* nop */
1171 /* The format of the first PLT entry in a VxWorks shared object. */
1172 static const bfd_vma mips_vxworks_shared_plt0_entry
[] =
1174 0x8f990008, /* lw t9, 8(gp) */
1175 0x00000000, /* nop */
1176 0x03200008, /* jr t9 */
1177 0x00000000, /* nop */
1178 0x00000000, /* nop */
1179 0x00000000 /* nop */
1182 /* The format of subsequent PLT entries. */
1183 static const bfd_vma mips_vxworks_shared_plt_entry
[] =
1185 0x10000000, /* b .PLT_resolver */
1186 0x24180000 /* li t8, <pltindex> */
1189 /* microMIPS 32-bit opcode helper installer. */
1192 bfd_put_micromips_32 (const bfd
*abfd
, bfd_vma opcode
, bfd_byte
*ptr
)
1194 bfd_put_16 (abfd
, (opcode
>> 16) & 0xffff, ptr
);
1195 bfd_put_16 (abfd
, opcode
& 0xffff, ptr
+ 2);
1198 /* microMIPS 32-bit opcode helper retriever. */
1201 bfd_get_micromips_32 (const bfd
*abfd
, const bfd_byte
*ptr
)
1203 return (bfd_get_16 (abfd
, ptr
) << 16) | bfd_get_16 (abfd
, ptr
+ 2);
1206 /* Look up an entry in a MIPS ELF linker hash table. */
1208 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
1209 ((struct mips_elf_link_hash_entry *) \
1210 elf_link_hash_lookup (&(table)->root, (string), (create), \
1213 /* Traverse a MIPS ELF linker hash table. */
1215 #define mips_elf_link_hash_traverse(table, func, info) \
1216 (elf_link_hash_traverse \
1218 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
1221 /* Find the base offsets for thread-local storage in this object,
1222 for GD/LD and IE/LE respectively. */
1224 #define TP_OFFSET 0x7000
1225 #define DTP_OFFSET 0x8000
1228 dtprel_base (struct bfd_link_info
*info
)
1230 /* If tls_sec is NULL, we should have signalled an error already. */
1231 if (elf_hash_table (info
)->tls_sec
== NULL
)
1233 return elf_hash_table (info
)->tls_sec
->vma
+ DTP_OFFSET
;
1237 tprel_base (struct bfd_link_info
*info
)
1239 /* If tls_sec is NULL, we should have signalled an error already. */
1240 if (elf_hash_table (info
)->tls_sec
== NULL
)
1242 return elf_hash_table (info
)->tls_sec
->vma
+ TP_OFFSET
;
1245 /* Create an entry in a MIPS ELF linker hash table. */
1247 static struct bfd_hash_entry
*
1248 mips_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
1249 struct bfd_hash_table
*table
, const char *string
)
1251 struct mips_elf_link_hash_entry
*ret
=
1252 (struct mips_elf_link_hash_entry
*) entry
;
1254 /* Allocate the structure if it has not already been allocated by a
1257 ret
= bfd_hash_allocate (table
, sizeof (struct mips_elf_link_hash_entry
));
1259 return (struct bfd_hash_entry
*) ret
;
1261 /* Call the allocation method of the superclass. */
1262 ret
= ((struct mips_elf_link_hash_entry
*)
1263 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
1267 /* Set local fields. */
1268 memset (&ret
->esym
, 0, sizeof (EXTR
));
1269 /* We use -2 as a marker to indicate that the information has
1270 not been set. -1 means there is no associated ifd. */
1273 ret
->possibly_dynamic_relocs
= 0;
1274 ret
->fn_stub
= NULL
;
1275 ret
->call_stub
= NULL
;
1276 ret
->call_fp_stub
= NULL
;
1277 ret
->global_got_area
= GGA_NONE
;
1278 ret
->got_only_for_calls
= TRUE
;
1279 ret
->readonly_reloc
= FALSE
;
1280 ret
->has_static_relocs
= FALSE
;
1281 ret
->no_fn_stub
= FALSE
;
1282 ret
->need_fn_stub
= FALSE
;
1283 ret
->has_nonpic_branches
= FALSE
;
1284 ret
->needs_lazy_stub
= FALSE
;
1285 ret
->use_plt_entry
= FALSE
;
1288 return (struct bfd_hash_entry
*) ret
;
1291 /* Allocate MIPS ELF private object data. */
1294 _bfd_mips_elf_mkobject (bfd
*abfd
)
1296 return bfd_elf_allocate_object (abfd
, sizeof (struct mips_elf_obj_tdata
),
1301 _bfd_mips_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
1303 if (!sec
->used_by_bfd
)
1305 struct _mips_elf_section_data
*sdata
;
1306 bfd_size_type amt
= sizeof (*sdata
);
1308 sdata
= bfd_zalloc (abfd
, amt
);
1311 sec
->used_by_bfd
= sdata
;
1314 return _bfd_elf_new_section_hook (abfd
, sec
);
1317 /* Read ECOFF debugging information from a .mdebug section into a
1318 ecoff_debug_info structure. */
1321 _bfd_mips_elf_read_ecoff_info (bfd
*abfd
, asection
*section
,
1322 struct ecoff_debug_info
*debug
)
1325 const struct ecoff_debug_swap
*swap
;
1328 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
1329 memset (debug
, 0, sizeof (*debug
));
1331 ext_hdr
= bfd_malloc (swap
->external_hdr_size
);
1332 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
1335 if (! bfd_get_section_contents (abfd
, section
, ext_hdr
, 0,
1336 swap
->external_hdr_size
))
1339 symhdr
= &debug
->symbolic_header
;
1340 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
1342 /* The symbolic header contains absolute file offsets and sizes to
1344 #define READ(ptr, offset, count, size, type) \
1345 if (symhdr->count == 0) \
1346 debug->ptr = NULL; \
1349 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
1350 debug->ptr = bfd_malloc (amt); \
1351 if (debug->ptr == NULL) \
1352 goto error_return; \
1353 if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0 \
1354 || bfd_bread (debug->ptr, amt, abfd) != amt) \
1355 goto error_return; \
1358 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
1359 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, void *);
1360 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, void *);
1361 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, void *);
1362 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, void *);
1363 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
1365 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
1366 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
1367 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, void *);
1368 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, void *);
1369 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, void *);
1377 if (ext_hdr
!= NULL
)
1379 if (debug
->line
!= NULL
)
1381 if (debug
->external_dnr
!= NULL
)
1382 free (debug
->external_dnr
);
1383 if (debug
->external_pdr
!= NULL
)
1384 free (debug
->external_pdr
);
1385 if (debug
->external_sym
!= NULL
)
1386 free (debug
->external_sym
);
1387 if (debug
->external_opt
!= NULL
)
1388 free (debug
->external_opt
);
1389 if (debug
->external_aux
!= NULL
)
1390 free (debug
->external_aux
);
1391 if (debug
->ss
!= NULL
)
1393 if (debug
->ssext
!= NULL
)
1394 free (debug
->ssext
);
1395 if (debug
->external_fdr
!= NULL
)
1396 free (debug
->external_fdr
);
1397 if (debug
->external_rfd
!= NULL
)
1398 free (debug
->external_rfd
);
1399 if (debug
->external_ext
!= NULL
)
1400 free (debug
->external_ext
);
1404 /* Swap RPDR (runtime procedure table entry) for output. */
1407 ecoff_swap_rpdr_out (bfd
*abfd
, const RPDR
*in
, struct rpdr_ext
*ex
)
1409 H_PUT_S32 (abfd
, in
->adr
, ex
->p_adr
);
1410 H_PUT_32 (abfd
, in
->regmask
, ex
->p_regmask
);
1411 H_PUT_32 (abfd
, in
->regoffset
, ex
->p_regoffset
);
1412 H_PUT_32 (abfd
, in
->fregmask
, ex
->p_fregmask
);
1413 H_PUT_32 (abfd
, in
->fregoffset
, ex
->p_fregoffset
);
1414 H_PUT_32 (abfd
, in
->frameoffset
, ex
->p_frameoffset
);
1416 H_PUT_16 (abfd
, in
->framereg
, ex
->p_framereg
);
1417 H_PUT_16 (abfd
, in
->pcreg
, ex
->p_pcreg
);
1419 H_PUT_32 (abfd
, in
->irpss
, ex
->p_irpss
);
1422 /* Create a runtime procedure table from the .mdebug section. */
1425 mips_elf_create_procedure_table (void *handle
, bfd
*abfd
,
1426 struct bfd_link_info
*info
, asection
*s
,
1427 struct ecoff_debug_info
*debug
)
1429 const struct ecoff_debug_swap
*swap
;
1430 HDRR
*hdr
= &debug
->symbolic_header
;
1432 struct rpdr_ext
*erp
;
1434 struct pdr_ext
*epdr
;
1435 struct sym_ext
*esym
;
1439 bfd_size_type count
;
1440 unsigned long sindex
;
1444 const char *no_name_func
= _("static procedure (no name)");
1452 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
1454 sindex
= strlen (no_name_func
) + 1;
1455 count
= hdr
->ipdMax
;
1458 size
= swap
->external_pdr_size
;
1460 epdr
= bfd_malloc (size
* count
);
1464 if (! _bfd_ecoff_get_accumulated_pdr (handle
, (bfd_byte
*) epdr
))
1467 size
= sizeof (RPDR
);
1468 rp
= rpdr
= bfd_malloc (size
* count
);
1472 size
= sizeof (char *);
1473 sv
= bfd_malloc (size
* count
);
1477 count
= hdr
->isymMax
;
1478 size
= swap
->external_sym_size
;
1479 esym
= bfd_malloc (size
* count
);
1483 if (! _bfd_ecoff_get_accumulated_sym (handle
, (bfd_byte
*) esym
))
1486 count
= hdr
->issMax
;
1487 ss
= bfd_malloc (count
);
1490 if (! _bfd_ecoff_get_accumulated_ss (handle
, (bfd_byte
*) ss
))
1493 count
= hdr
->ipdMax
;
1494 for (i
= 0; i
< (unsigned long) count
; i
++, rp
++)
1496 (*swap
->swap_pdr_in
) (abfd
, epdr
+ i
, &pdr
);
1497 (*swap
->swap_sym_in
) (abfd
, &esym
[pdr
.isym
], &sym
);
1498 rp
->adr
= sym
.value
;
1499 rp
->regmask
= pdr
.regmask
;
1500 rp
->regoffset
= pdr
.regoffset
;
1501 rp
->fregmask
= pdr
.fregmask
;
1502 rp
->fregoffset
= pdr
.fregoffset
;
1503 rp
->frameoffset
= pdr
.frameoffset
;
1504 rp
->framereg
= pdr
.framereg
;
1505 rp
->pcreg
= pdr
.pcreg
;
1507 sv
[i
] = ss
+ sym
.iss
;
1508 sindex
+= strlen (sv
[i
]) + 1;
1512 size
= sizeof (struct rpdr_ext
) * (count
+ 2) + sindex
;
1513 size
= BFD_ALIGN (size
, 16);
1514 rtproc
= bfd_alloc (abfd
, size
);
1517 mips_elf_hash_table (info
)->procedure_count
= 0;
1521 mips_elf_hash_table (info
)->procedure_count
= count
+ 2;
1524 memset (erp
, 0, sizeof (struct rpdr_ext
));
1526 str
= (char *) rtproc
+ sizeof (struct rpdr_ext
) * (count
+ 2);
1527 strcpy (str
, no_name_func
);
1528 str
+= strlen (no_name_func
) + 1;
1529 for (i
= 0; i
< count
; i
++)
1531 ecoff_swap_rpdr_out (abfd
, rpdr
+ i
, erp
+ i
);
1532 strcpy (str
, sv
[i
]);
1533 str
+= strlen (sv
[i
]) + 1;
1535 H_PUT_S32 (abfd
, -1, (erp
+ count
)->p_adr
);
1537 /* Set the size and contents of .rtproc section. */
1539 s
->contents
= rtproc
;
1541 /* Skip this section later on (I don't think this currently
1542 matters, but someday it might). */
1543 s
->map_head
.link_order
= NULL
;
1572 /* We're going to create a stub for H. Create a symbol for the stub's
1573 value and size, to help make the disassembly easier to read. */
1576 mips_elf_create_stub_symbol (struct bfd_link_info
*info
,
1577 struct mips_elf_link_hash_entry
*h
,
1578 const char *prefix
, asection
*s
, bfd_vma value
,
1581 struct bfd_link_hash_entry
*bh
;
1582 struct elf_link_hash_entry
*elfh
;
1585 if (ELF_ST_IS_MICROMIPS (h
->root
.other
))
1588 /* Create a new symbol. */
1589 name
= ACONCAT ((prefix
, h
->root
.root
.root
.string
, NULL
));
1591 if (!_bfd_generic_link_add_one_symbol (info
, s
->owner
, name
,
1592 BSF_LOCAL
, s
, value
, NULL
,
1596 /* Make it a local function. */
1597 elfh
= (struct elf_link_hash_entry
*) bh
;
1598 elfh
->type
= ELF_ST_INFO (STB_LOCAL
, STT_FUNC
);
1600 elfh
->forced_local
= 1;
1604 /* We're about to redefine H. Create a symbol to represent H's
1605 current value and size, to help make the disassembly easier
1609 mips_elf_create_shadow_symbol (struct bfd_link_info
*info
,
1610 struct mips_elf_link_hash_entry
*h
,
1613 struct bfd_link_hash_entry
*bh
;
1614 struct elf_link_hash_entry
*elfh
;
1619 /* Read the symbol's value. */
1620 BFD_ASSERT (h
->root
.root
.type
== bfd_link_hash_defined
1621 || h
->root
.root
.type
== bfd_link_hash_defweak
);
1622 s
= h
->root
.root
.u
.def
.section
;
1623 value
= h
->root
.root
.u
.def
.value
;
1625 /* Create a new symbol. */
1626 name
= ACONCAT ((prefix
, h
->root
.root
.root
.string
, NULL
));
1628 if (!_bfd_generic_link_add_one_symbol (info
, s
->owner
, name
,
1629 BSF_LOCAL
, s
, value
, NULL
,
1633 /* Make it local and copy the other attributes from H. */
1634 elfh
= (struct elf_link_hash_entry
*) bh
;
1635 elfh
->type
= ELF_ST_INFO (STB_LOCAL
, ELF_ST_TYPE (h
->root
.type
));
1636 elfh
->other
= h
->root
.other
;
1637 elfh
->size
= h
->root
.size
;
1638 elfh
->forced_local
= 1;
1642 /* Return TRUE if relocations in SECTION can refer directly to a MIPS16
1643 function rather than to a hard-float stub. */
1646 section_allows_mips16_refs_p (asection
*section
)
1650 name
= bfd_get_section_name (section
->owner
, section
);
1651 return (FN_STUB_P (name
)
1652 || CALL_STUB_P (name
)
1653 || CALL_FP_STUB_P (name
)
1654 || strcmp (name
, ".pdr") == 0);
1657 /* [RELOCS, RELEND) are the relocations against SEC, which is a MIPS16
1658 stub section of some kind. Return the R_SYMNDX of the target
1659 function, or 0 if we can't decide which function that is. */
1661 static unsigned long
1662 mips16_stub_symndx (const struct elf_backend_data
*bed
,
1663 asection
*sec ATTRIBUTE_UNUSED
,
1664 const Elf_Internal_Rela
*relocs
,
1665 const Elf_Internal_Rela
*relend
)
1667 int int_rels_per_ext_rel
= bed
->s
->int_rels_per_ext_rel
;
1668 const Elf_Internal_Rela
*rel
;
1670 /* Trust the first R_MIPS_NONE relocation, if any, but not a subsequent
1671 one in a compound relocation. */
1672 for (rel
= relocs
; rel
< relend
; rel
+= int_rels_per_ext_rel
)
1673 if (ELF_R_TYPE (sec
->owner
, rel
->r_info
) == R_MIPS_NONE
)
1674 return ELF_R_SYM (sec
->owner
, rel
->r_info
);
1676 /* Otherwise trust the first relocation, whatever its kind. This is
1677 the traditional behavior. */
1678 if (relocs
< relend
)
1679 return ELF_R_SYM (sec
->owner
, relocs
->r_info
);
1684 /* Check the mips16 stubs for a particular symbol, and see if we can
1688 mips_elf_check_mips16_stubs (struct bfd_link_info
*info
,
1689 struct mips_elf_link_hash_entry
*h
)
1691 /* Dynamic symbols must use the standard call interface, in case other
1692 objects try to call them. */
1693 if (h
->fn_stub
!= NULL
1694 && h
->root
.dynindx
!= -1)
1696 mips_elf_create_shadow_symbol (info
, h
, ".mips16.");
1697 h
->need_fn_stub
= TRUE
;
1700 if (h
->fn_stub
!= NULL
1701 && ! h
->need_fn_stub
)
1703 /* We don't need the fn_stub; the only references to this symbol
1704 are 16 bit calls. Clobber the size to 0 to prevent it from
1705 being included in the link. */
1706 h
->fn_stub
->size
= 0;
1707 h
->fn_stub
->flags
&= ~SEC_RELOC
;
1708 h
->fn_stub
->reloc_count
= 0;
1709 h
->fn_stub
->flags
|= SEC_EXCLUDE
;
1712 if (h
->call_stub
!= NULL
1713 && ELF_ST_IS_MIPS16 (h
->root
.other
))
1715 /* We don't need the call_stub; this is a 16 bit function, so
1716 calls from other 16 bit functions are OK. Clobber the size
1717 to 0 to prevent it from being included in the link. */
1718 h
->call_stub
->size
= 0;
1719 h
->call_stub
->flags
&= ~SEC_RELOC
;
1720 h
->call_stub
->reloc_count
= 0;
1721 h
->call_stub
->flags
|= SEC_EXCLUDE
;
1724 if (h
->call_fp_stub
!= NULL
1725 && ELF_ST_IS_MIPS16 (h
->root
.other
))
1727 /* We don't need the call_stub; this is a 16 bit function, so
1728 calls from other 16 bit functions are OK. Clobber the size
1729 to 0 to prevent it from being included in the link. */
1730 h
->call_fp_stub
->size
= 0;
1731 h
->call_fp_stub
->flags
&= ~SEC_RELOC
;
1732 h
->call_fp_stub
->reloc_count
= 0;
1733 h
->call_fp_stub
->flags
|= SEC_EXCLUDE
;
1737 /* Hashtable callbacks for mips_elf_la25_stubs. */
1740 mips_elf_la25_stub_hash (const void *entry_
)
1742 const struct mips_elf_la25_stub
*entry
;
1744 entry
= (struct mips_elf_la25_stub
*) entry_
;
1745 return entry
->h
->root
.root
.u
.def
.section
->id
1746 + entry
->h
->root
.root
.u
.def
.value
;
1750 mips_elf_la25_stub_eq (const void *entry1_
, const void *entry2_
)
1752 const struct mips_elf_la25_stub
*entry1
, *entry2
;
1754 entry1
= (struct mips_elf_la25_stub
*) entry1_
;
1755 entry2
= (struct mips_elf_la25_stub
*) entry2_
;
1756 return ((entry1
->h
->root
.root
.u
.def
.section
1757 == entry2
->h
->root
.root
.u
.def
.section
)
1758 && (entry1
->h
->root
.root
.u
.def
.value
1759 == entry2
->h
->root
.root
.u
.def
.value
));
1762 /* Called by the linker to set up the la25 stub-creation code. FN is
1763 the linker's implementation of add_stub_function. Return true on
1767 _bfd_mips_elf_init_stubs (struct bfd_link_info
*info
,
1768 asection
*(*fn
) (const char *, asection
*,
1771 struct mips_elf_link_hash_table
*htab
;
1773 htab
= mips_elf_hash_table (info
);
1777 htab
->add_stub_section
= fn
;
1778 htab
->la25_stubs
= htab_try_create (1, mips_elf_la25_stub_hash
,
1779 mips_elf_la25_stub_eq
, NULL
);
1780 if (htab
->la25_stubs
== NULL
)
1786 /* Return true if H is a locally-defined PIC function, in the sense
1787 that it or its fn_stub might need $25 to be valid on entry.
1788 Note that MIPS16 functions set up $gp using PC-relative instructions,
1789 so they themselves never need $25 to be valid. Only non-MIPS16
1790 entry points are of interest here. */
1793 mips_elf_local_pic_function_p (struct mips_elf_link_hash_entry
*h
)
1795 return ((h
->root
.root
.type
== bfd_link_hash_defined
1796 || h
->root
.root
.type
== bfd_link_hash_defweak
)
1797 && h
->root
.def_regular
1798 && !bfd_is_abs_section (h
->root
.root
.u
.def
.section
)
1799 && (!ELF_ST_IS_MIPS16 (h
->root
.other
)
1800 || (h
->fn_stub
&& h
->need_fn_stub
))
1801 && (PIC_OBJECT_P (h
->root
.root
.u
.def
.section
->owner
)
1802 || ELF_ST_IS_MIPS_PIC (h
->root
.other
)));
1805 /* Set *SEC to the input section that contains the target of STUB.
1806 Return the offset of the target from the start of that section. */
1809 mips_elf_get_la25_target (struct mips_elf_la25_stub
*stub
,
1812 if (ELF_ST_IS_MIPS16 (stub
->h
->root
.other
))
1814 BFD_ASSERT (stub
->h
->need_fn_stub
);
1815 *sec
= stub
->h
->fn_stub
;
1820 *sec
= stub
->h
->root
.root
.u
.def
.section
;
1821 return stub
->h
->root
.root
.u
.def
.value
;
1825 /* STUB describes an la25 stub that we have decided to implement
1826 by inserting an LUI/ADDIU pair before the target function.
1827 Create the section and redirect the function symbol to it. */
1830 mips_elf_add_la25_intro (struct mips_elf_la25_stub
*stub
,
1831 struct bfd_link_info
*info
)
1833 struct mips_elf_link_hash_table
*htab
;
1835 asection
*s
, *input_section
;
1838 htab
= mips_elf_hash_table (info
);
1842 /* Create a unique name for the new section. */
1843 name
= bfd_malloc (11 + sizeof (".text.stub."));
1846 sprintf (name
, ".text.stub.%d", (int) htab_elements (htab
->la25_stubs
));
1848 /* Create the section. */
1849 mips_elf_get_la25_target (stub
, &input_section
);
1850 s
= htab
->add_stub_section (name
, input_section
,
1851 input_section
->output_section
);
1855 /* Make sure that any padding goes before the stub. */
1856 align
= input_section
->alignment_power
;
1857 if (!bfd_set_section_alignment (s
->owner
, s
, align
))
1860 s
->size
= (1 << align
) - 8;
1862 /* Create a symbol for the stub. */
1863 mips_elf_create_stub_symbol (info
, stub
->h
, ".pic.", s
, s
->size
, 8);
1864 stub
->stub_section
= s
;
1865 stub
->offset
= s
->size
;
1867 /* Allocate room for it. */
1872 /* STUB describes an la25 stub that we have decided to implement
1873 with a separate trampoline. Allocate room for it and redirect
1874 the function symbol to it. */
1877 mips_elf_add_la25_trampoline (struct mips_elf_la25_stub
*stub
,
1878 struct bfd_link_info
*info
)
1880 struct mips_elf_link_hash_table
*htab
;
1883 htab
= mips_elf_hash_table (info
);
1887 /* Create a trampoline section, if we haven't already. */
1888 s
= htab
->strampoline
;
1891 asection
*input_section
= stub
->h
->root
.root
.u
.def
.section
;
1892 s
= htab
->add_stub_section (".text", NULL
,
1893 input_section
->output_section
);
1894 if (s
== NULL
|| !bfd_set_section_alignment (s
->owner
, s
, 4))
1896 htab
->strampoline
= s
;
1899 /* Create a symbol for the stub. */
1900 mips_elf_create_stub_symbol (info
, stub
->h
, ".pic.", s
, s
->size
, 16);
1901 stub
->stub_section
= s
;
1902 stub
->offset
= s
->size
;
1904 /* Allocate room for it. */
1909 /* H describes a symbol that needs an la25 stub. Make sure that an
1910 appropriate stub exists and point H at it. */
1913 mips_elf_add_la25_stub (struct bfd_link_info
*info
,
1914 struct mips_elf_link_hash_entry
*h
)
1916 struct mips_elf_link_hash_table
*htab
;
1917 struct mips_elf_la25_stub search
, *stub
;
1918 bfd_boolean use_trampoline_p
;
1923 /* Describe the stub we want. */
1924 search
.stub_section
= NULL
;
1928 /* See if we've already created an equivalent stub. */
1929 htab
= mips_elf_hash_table (info
);
1933 slot
= htab_find_slot (htab
->la25_stubs
, &search
, INSERT
);
1937 stub
= (struct mips_elf_la25_stub
*) *slot
;
1940 /* We can reuse the existing stub. */
1941 h
->la25_stub
= stub
;
1945 /* Create a permanent copy of ENTRY and add it to the hash table. */
1946 stub
= bfd_malloc (sizeof (search
));
1952 /* Prefer to use LUI/ADDIU stubs if the function is at the beginning
1953 of the section and if we would need no more than 2 nops. */
1954 value
= mips_elf_get_la25_target (stub
, &s
);
1955 use_trampoline_p
= (value
!= 0 || s
->alignment_power
> 4);
1957 h
->la25_stub
= stub
;
1958 return (use_trampoline_p
1959 ? mips_elf_add_la25_trampoline (stub
, info
)
1960 : mips_elf_add_la25_intro (stub
, info
));
1963 /* A mips_elf_link_hash_traverse callback that is called before sizing
1964 sections. DATA points to a mips_htab_traverse_info structure. */
1967 mips_elf_check_symbols (struct mips_elf_link_hash_entry
*h
, void *data
)
1969 struct mips_htab_traverse_info
*hti
;
1971 hti
= (struct mips_htab_traverse_info
*) data
;
1972 if (!bfd_link_relocatable (hti
->info
))
1973 mips_elf_check_mips16_stubs (hti
->info
, h
);
1975 if (mips_elf_local_pic_function_p (h
))
1977 /* PR 12845: If H is in a section that has been garbage
1978 collected it will have its output section set to *ABS*. */
1979 if (bfd_is_abs_section (h
->root
.root
.u
.def
.section
->output_section
))
1982 /* H is a function that might need $25 to be valid on entry.
1983 If we're creating a non-PIC relocatable object, mark H as
1984 being PIC. If we're creating a non-relocatable object with
1985 non-PIC branches and jumps to H, make sure that H has an la25
1987 if (bfd_link_relocatable (hti
->info
))
1989 if (!PIC_OBJECT_P (hti
->output_bfd
))
1990 h
->root
.other
= ELF_ST_SET_MIPS_PIC (h
->root
.other
);
1992 else if (h
->has_nonpic_branches
&& !mips_elf_add_la25_stub (hti
->info
, h
))
2001 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
2002 Most mips16 instructions are 16 bits, but these instructions
2005 The format of these instructions is:
2007 +--------------+--------------------------------+
2008 | JALX | X| Imm 20:16 | Imm 25:21 |
2009 +--------------+--------------------------------+
2011 +-----------------------------------------------+
2013 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
2014 Note that the immediate value in the first word is swapped.
2016 When producing a relocatable object file, R_MIPS16_26 is
2017 handled mostly like R_MIPS_26. In particular, the addend is
2018 stored as a straight 26-bit value in a 32-bit instruction.
2019 (gas makes life simpler for itself by never adjusting a
2020 R_MIPS16_26 reloc to be against a section, so the addend is
2021 always zero). However, the 32 bit instruction is stored as 2
2022 16-bit values, rather than a single 32-bit value. In a
2023 big-endian file, the result is the same; in a little-endian
2024 file, the two 16-bit halves of the 32 bit value are swapped.
2025 This is so that a disassembler can recognize the jal
2028 When doing a final link, R_MIPS16_26 is treated as a 32 bit
2029 instruction stored as two 16-bit values. The addend A is the
2030 contents of the targ26 field. The calculation is the same as
2031 R_MIPS_26. When storing the calculated value, reorder the
2032 immediate value as shown above, and don't forget to store the
2033 value as two 16-bit values.
2035 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
2039 +--------+----------------------+
2043 +--------+----------------------+
2046 +----------+------+-------------+
2050 +----------+--------------------+
2051 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
2052 ((sub1 << 16) | sub2)).
2054 When producing a relocatable object file, the calculation is
2055 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
2056 When producing a fully linked file, the calculation is
2057 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
2058 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)
2060 The table below lists the other MIPS16 instruction relocations.
2061 Each one is calculated in the same way as the non-MIPS16 relocation
2062 given on the right, but using the extended MIPS16 layout of 16-bit
2065 R_MIPS16_GPREL R_MIPS_GPREL16
2066 R_MIPS16_GOT16 R_MIPS_GOT16
2067 R_MIPS16_CALL16 R_MIPS_CALL16
2068 R_MIPS16_HI16 R_MIPS_HI16
2069 R_MIPS16_LO16 R_MIPS_LO16
2071 A typical instruction will have a format like this:
2073 +--------------+--------------------------------+
2074 | EXTEND | Imm 10:5 | Imm 15:11 |
2075 +--------------+--------------------------------+
2076 | Major | rx | ry | Imm 4:0 |
2077 +--------------+--------------------------------+
2079 EXTEND is the five bit value 11110. Major is the instruction
2082 All we need to do here is shuffle the bits appropriately.
2083 As above, the two 16-bit halves must be swapped on a
2084 little-endian system. */
2086 static inline bfd_boolean
2087 mips16_reloc_p (int r_type
)
2092 case R_MIPS16_GPREL
:
2093 case R_MIPS16_GOT16
:
2094 case R_MIPS16_CALL16
:
2097 case R_MIPS16_TLS_GD
:
2098 case R_MIPS16_TLS_LDM
:
2099 case R_MIPS16_TLS_DTPREL_HI16
:
2100 case R_MIPS16_TLS_DTPREL_LO16
:
2101 case R_MIPS16_TLS_GOTTPREL
:
2102 case R_MIPS16_TLS_TPREL_HI16
:
2103 case R_MIPS16_TLS_TPREL_LO16
:
2111 /* Check if a microMIPS reloc. */
2113 static inline bfd_boolean
2114 micromips_reloc_p (unsigned int r_type
)
2116 return r_type
>= R_MICROMIPS_min
&& r_type
< R_MICROMIPS_max
;
2119 /* Similar to MIPS16, the two 16-bit halves in microMIPS must be swapped
2120 on a little-endian system. This does not apply to R_MICROMIPS_PC7_S1
2121 and R_MICROMIPS_PC10_S1 relocs that apply to 16-bit instructions. */
2123 static inline bfd_boolean
2124 micromips_reloc_shuffle_p (unsigned int r_type
)
2126 return (micromips_reloc_p (r_type
)
2127 && r_type
!= R_MICROMIPS_PC7_S1
2128 && r_type
!= R_MICROMIPS_PC10_S1
);
2131 static inline bfd_boolean
2132 got16_reloc_p (int r_type
)
2134 return (r_type
== R_MIPS_GOT16
2135 || r_type
== R_MIPS16_GOT16
2136 || r_type
== R_MICROMIPS_GOT16
);
2139 static inline bfd_boolean
2140 call16_reloc_p (int r_type
)
2142 return (r_type
== R_MIPS_CALL16
2143 || r_type
== R_MIPS16_CALL16
2144 || r_type
== R_MICROMIPS_CALL16
);
2147 static inline bfd_boolean
2148 got_disp_reloc_p (unsigned int r_type
)
2150 return r_type
== R_MIPS_GOT_DISP
|| r_type
== R_MICROMIPS_GOT_DISP
;
2153 static inline bfd_boolean
2154 got_page_reloc_p (unsigned int r_type
)
2156 return r_type
== R_MIPS_GOT_PAGE
|| r_type
== R_MICROMIPS_GOT_PAGE
;
2159 static inline bfd_boolean
2160 got_lo16_reloc_p (unsigned int r_type
)
2162 return r_type
== R_MIPS_GOT_LO16
|| r_type
== R_MICROMIPS_GOT_LO16
;
2165 static inline bfd_boolean
2166 call_hi16_reloc_p (unsigned int r_type
)
2168 return r_type
== R_MIPS_CALL_HI16
|| r_type
== R_MICROMIPS_CALL_HI16
;
2171 static inline bfd_boolean
2172 call_lo16_reloc_p (unsigned int r_type
)
2174 return r_type
== R_MIPS_CALL_LO16
|| r_type
== R_MICROMIPS_CALL_LO16
;
2177 static inline bfd_boolean
2178 hi16_reloc_p (int r_type
)
2180 return (r_type
== R_MIPS_HI16
2181 || r_type
== R_MIPS16_HI16
2182 || r_type
== R_MICROMIPS_HI16
2183 || r_type
== R_MIPS_PCHI16
);
2186 static inline bfd_boolean
2187 lo16_reloc_p (int r_type
)
2189 return (r_type
== R_MIPS_LO16
2190 || r_type
== R_MIPS16_LO16
2191 || r_type
== R_MICROMIPS_LO16
2192 || r_type
== R_MIPS_PCLO16
);
2195 static inline bfd_boolean
2196 mips16_call_reloc_p (int r_type
)
2198 return r_type
== R_MIPS16_26
|| r_type
== R_MIPS16_CALL16
;
2201 static inline bfd_boolean
2202 jal_reloc_p (int r_type
)
2204 return (r_type
== R_MIPS_26
2205 || r_type
== R_MIPS16_26
2206 || r_type
== R_MICROMIPS_26_S1
);
2209 static inline bfd_boolean
2210 aligned_pcrel_reloc_p (int r_type
)
2212 return (r_type
== R_MIPS_PC18_S3
2213 || r_type
== R_MIPS_PC19_S2
);
2216 static inline bfd_boolean
2217 micromips_branch_reloc_p (int r_type
)
2219 return (r_type
== R_MICROMIPS_26_S1
2220 || r_type
== R_MICROMIPS_PC16_S1
2221 || r_type
== R_MICROMIPS_PC10_S1
2222 || r_type
== R_MICROMIPS_PC7_S1
);
2225 static inline bfd_boolean
2226 tls_gd_reloc_p (unsigned int r_type
)
2228 return (r_type
== R_MIPS_TLS_GD
2229 || r_type
== R_MIPS16_TLS_GD
2230 || r_type
== R_MICROMIPS_TLS_GD
);
2233 static inline bfd_boolean
2234 tls_ldm_reloc_p (unsigned int r_type
)
2236 return (r_type
== R_MIPS_TLS_LDM
2237 || r_type
== R_MIPS16_TLS_LDM
2238 || r_type
== R_MICROMIPS_TLS_LDM
);
2241 static inline bfd_boolean
2242 tls_gottprel_reloc_p (unsigned int r_type
)
2244 return (r_type
== R_MIPS_TLS_GOTTPREL
2245 || r_type
== R_MIPS16_TLS_GOTTPREL
2246 || r_type
== R_MICROMIPS_TLS_GOTTPREL
);
2250 _bfd_mips_elf_reloc_unshuffle (bfd
*abfd
, int r_type
,
2251 bfd_boolean jal_shuffle
, bfd_byte
*data
)
2253 bfd_vma first
, second
, val
;
2255 if (!mips16_reloc_p (r_type
) && !micromips_reloc_shuffle_p (r_type
))
2258 /* Pick up the first and second halfwords of the instruction. */
2259 first
= bfd_get_16 (abfd
, data
);
2260 second
= bfd_get_16 (abfd
, data
+ 2);
2261 if (micromips_reloc_p (r_type
) || (r_type
== R_MIPS16_26
&& !jal_shuffle
))
2262 val
= first
<< 16 | second
;
2263 else if (r_type
!= R_MIPS16_26
)
2264 val
= (((first
& 0xf800) << 16) | ((second
& 0xffe0) << 11)
2265 | ((first
& 0x1f) << 11) | (first
& 0x7e0) | (second
& 0x1f));
2267 val
= (((first
& 0xfc00) << 16) | ((first
& 0x3e0) << 11)
2268 | ((first
& 0x1f) << 21) | second
);
2269 bfd_put_32 (abfd
, val
, data
);
2273 _bfd_mips_elf_reloc_shuffle (bfd
*abfd
, int r_type
,
2274 bfd_boolean jal_shuffle
, bfd_byte
*data
)
2276 bfd_vma first
, second
, val
;
2278 if (!mips16_reloc_p (r_type
) && !micromips_reloc_shuffle_p (r_type
))
2281 val
= bfd_get_32 (abfd
, data
);
2282 if (micromips_reloc_p (r_type
) || (r_type
== R_MIPS16_26
&& !jal_shuffle
))
2284 second
= val
& 0xffff;
2287 else if (r_type
!= R_MIPS16_26
)
2289 second
= ((val
>> 11) & 0xffe0) | (val
& 0x1f);
2290 first
= ((val
>> 16) & 0xf800) | ((val
>> 11) & 0x1f) | (val
& 0x7e0);
2294 second
= val
& 0xffff;
2295 first
= ((val
>> 16) & 0xfc00) | ((val
>> 11) & 0x3e0)
2296 | ((val
>> 21) & 0x1f);
2298 bfd_put_16 (abfd
, second
, data
+ 2);
2299 bfd_put_16 (abfd
, first
, data
);
2302 bfd_reloc_status_type
2303 _bfd_mips_elf_gprel16_with_gp (bfd
*abfd
, asymbol
*symbol
,
2304 arelent
*reloc_entry
, asection
*input_section
,
2305 bfd_boolean relocatable
, void *data
, bfd_vma gp
)
2309 bfd_reloc_status_type status
;
2311 if (bfd_is_com_section (symbol
->section
))
2314 relocation
= symbol
->value
;
2316 relocation
+= symbol
->section
->output_section
->vma
;
2317 relocation
+= symbol
->section
->output_offset
;
2319 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
2320 return bfd_reloc_outofrange
;
2322 /* Set val to the offset into the section or symbol. */
2323 val
= reloc_entry
->addend
;
2325 _bfd_mips_elf_sign_extend (val
, 16);
2327 /* Adjust val for the final section location and GP value. If we
2328 are producing relocatable output, we don't want to do this for
2329 an external symbol. */
2331 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
2332 val
+= relocation
- gp
;
2334 if (reloc_entry
->howto
->partial_inplace
)
2336 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
2338 + reloc_entry
->address
);
2339 if (status
!= bfd_reloc_ok
)
2343 reloc_entry
->addend
= val
;
2346 reloc_entry
->address
+= input_section
->output_offset
;
2348 return bfd_reloc_ok
;
2351 /* Used to store a REL high-part relocation such as R_MIPS_HI16 or
2352 R_MIPS_GOT16. REL is the relocation, INPUT_SECTION is the section
2353 that contains the relocation field and DATA points to the start of
2358 struct mips_hi16
*next
;
2360 asection
*input_section
;
2364 /* FIXME: This should not be a static variable. */
2366 static struct mips_hi16
*mips_hi16_list
;
2368 /* A howto special_function for REL *HI16 relocations. We can only
2369 calculate the correct value once we've seen the partnering
2370 *LO16 relocation, so just save the information for later.
2372 The ABI requires that the *LO16 immediately follow the *HI16.
2373 However, as a GNU extension, we permit an arbitrary number of
2374 *HI16s to be associated with a single *LO16. This significantly
2375 simplies the relocation handling in gcc. */
2377 bfd_reloc_status_type
2378 _bfd_mips_elf_hi16_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
2379 asymbol
*symbol ATTRIBUTE_UNUSED
, void *data
,
2380 asection
*input_section
, bfd
*output_bfd
,
2381 char **error_message ATTRIBUTE_UNUSED
)
2383 struct mips_hi16
*n
;
2385 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
2386 return bfd_reloc_outofrange
;
2388 n
= bfd_malloc (sizeof *n
);
2390 return bfd_reloc_outofrange
;
2392 n
->next
= mips_hi16_list
;
2394 n
->input_section
= input_section
;
2395 n
->rel
= *reloc_entry
;
2398 if (output_bfd
!= NULL
)
2399 reloc_entry
->address
+= input_section
->output_offset
;
2401 return bfd_reloc_ok
;
2404 /* A howto special_function for REL R_MIPS*_GOT16 relocations. This is just
2405 like any other 16-bit relocation when applied to global symbols, but is
2406 treated in the same as R_MIPS_HI16 when applied to local symbols. */
2408 bfd_reloc_status_type
2409 _bfd_mips_elf_got16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
2410 void *data
, asection
*input_section
,
2411 bfd
*output_bfd
, char **error_message
)
2413 if ((symbol
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
2414 || bfd_is_und_section (bfd_get_section (symbol
))
2415 || bfd_is_com_section (bfd_get_section (symbol
)))
2416 /* The relocation is against a global symbol. */
2417 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
2418 input_section
, output_bfd
,
2421 return _bfd_mips_elf_hi16_reloc (abfd
, reloc_entry
, symbol
, data
,
2422 input_section
, output_bfd
, error_message
);
2425 /* A howto special_function for REL *LO16 relocations. The *LO16 itself
2426 is a straightforward 16 bit inplace relocation, but we must deal with
2427 any partnering high-part relocations as well. */
2429 bfd_reloc_status_type
2430 _bfd_mips_elf_lo16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
2431 void *data
, asection
*input_section
,
2432 bfd
*output_bfd
, char **error_message
)
2435 bfd_byte
*location
= (bfd_byte
*) data
+ reloc_entry
->address
;
2437 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
2438 return bfd_reloc_outofrange
;
2440 _bfd_mips_elf_reloc_unshuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
2442 vallo
= bfd_get_32 (abfd
, location
);
2443 _bfd_mips_elf_reloc_shuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
2446 while (mips_hi16_list
!= NULL
)
2448 bfd_reloc_status_type ret
;
2449 struct mips_hi16
*hi
;
2451 hi
= mips_hi16_list
;
2453 /* R_MIPS*_GOT16 relocations are something of a special case. We
2454 want to install the addend in the same way as for a R_MIPS*_HI16
2455 relocation (with a rightshift of 16). However, since GOT16
2456 relocations can also be used with global symbols, their howto
2457 has a rightshift of 0. */
2458 if (hi
->rel
.howto
->type
== R_MIPS_GOT16
)
2459 hi
->rel
.howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, R_MIPS_HI16
, FALSE
);
2460 else if (hi
->rel
.howto
->type
== R_MIPS16_GOT16
)
2461 hi
->rel
.howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, R_MIPS16_HI16
, FALSE
);
2462 else if (hi
->rel
.howto
->type
== R_MICROMIPS_GOT16
)
2463 hi
->rel
.howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, R_MICROMIPS_HI16
, FALSE
);
2465 /* VALLO is a signed 16-bit number. Bias it by 0x8000 so that any
2466 carry or borrow will induce a change of +1 or -1 in the high part. */
2467 hi
->rel
.addend
+= (vallo
+ 0x8000) & 0xffff;
2469 ret
= _bfd_mips_elf_generic_reloc (abfd
, &hi
->rel
, symbol
, hi
->data
,
2470 hi
->input_section
, output_bfd
,
2472 if (ret
!= bfd_reloc_ok
)
2475 mips_hi16_list
= hi
->next
;
2479 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
2480 input_section
, output_bfd
,
2484 /* A generic howto special_function. This calculates and installs the
2485 relocation itself, thus avoiding the oft-discussed problems in
2486 bfd_perform_relocation and bfd_install_relocation. */
2488 bfd_reloc_status_type
2489 _bfd_mips_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
2490 asymbol
*symbol
, void *data ATTRIBUTE_UNUSED
,
2491 asection
*input_section
, bfd
*output_bfd
,
2492 char **error_message ATTRIBUTE_UNUSED
)
2495 bfd_reloc_status_type status
;
2496 bfd_boolean relocatable
;
2498 relocatable
= (output_bfd
!= NULL
);
2500 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
2501 return bfd_reloc_outofrange
;
2503 /* Build up the field adjustment in VAL. */
2505 if (!relocatable
|| (symbol
->flags
& BSF_SECTION_SYM
) != 0)
2507 /* Either we're calculating the final field value or we have a
2508 relocation against a section symbol. Add in the section's
2509 offset or address. */
2510 val
+= symbol
->section
->output_section
->vma
;
2511 val
+= symbol
->section
->output_offset
;
2516 /* We're calculating the final field value. Add in the symbol's value
2517 and, if pc-relative, subtract the address of the field itself. */
2518 val
+= symbol
->value
;
2519 if (reloc_entry
->howto
->pc_relative
)
2521 val
-= input_section
->output_section
->vma
;
2522 val
-= input_section
->output_offset
;
2523 val
-= reloc_entry
->address
;
2527 /* VAL is now the final adjustment. If we're keeping this relocation
2528 in the output file, and if the relocation uses a separate addend,
2529 we just need to add VAL to that addend. Otherwise we need to add
2530 VAL to the relocation field itself. */
2531 if (relocatable
&& !reloc_entry
->howto
->partial_inplace
)
2532 reloc_entry
->addend
+= val
;
2535 bfd_byte
*location
= (bfd_byte
*) data
+ reloc_entry
->address
;
2537 /* Add in the separate addend, if any. */
2538 val
+= reloc_entry
->addend
;
2540 /* Add VAL to the relocation field. */
2541 _bfd_mips_elf_reloc_unshuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
2543 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
2545 _bfd_mips_elf_reloc_shuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
2548 if (status
!= bfd_reloc_ok
)
2553 reloc_entry
->address
+= input_section
->output_offset
;
2555 return bfd_reloc_ok
;
2558 /* Swap an entry in a .gptab section. Note that these routines rely
2559 on the equivalence of the two elements of the union. */
2562 bfd_mips_elf32_swap_gptab_in (bfd
*abfd
, const Elf32_External_gptab
*ex
,
2565 in
->gt_entry
.gt_g_value
= H_GET_32 (abfd
, ex
->gt_entry
.gt_g_value
);
2566 in
->gt_entry
.gt_bytes
= H_GET_32 (abfd
, ex
->gt_entry
.gt_bytes
);
2570 bfd_mips_elf32_swap_gptab_out (bfd
*abfd
, const Elf32_gptab
*in
,
2571 Elf32_External_gptab
*ex
)
2573 H_PUT_32 (abfd
, in
->gt_entry
.gt_g_value
, ex
->gt_entry
.gt_g_value
);
2574 H_PUT_32 (abfd
, in
->gt_entry
.gt_bytes
, ex
->gt_entry
.gt_bytes
);
2578 bfd_elf32_swap_compact_rel_out (bfd
*abfd
, const Elf32_compact_rel
*in
,
2579 Elf32_External_compact_rel
*ex
)
2581 H_PUT_32 (abfd
, in
->id1
, ex
->id1
);
2582 H_PUT_32 (abfd
, in
->num
, ex
->num
);
2583 H_PUT_32 (abfd
, in
->id2
, ex
->id2
);
2584 H_PUT_32 (abfd
, in
->offset
, ex
->offset
);
2585 H_PUT_32 (abfd
, in
->reserved0
, ex
->reserved0
);
2586 H_PUT_32 (abfd
, in
->reserved1
, ex
->reserved1
);
2590 bfd_elf32_swap_crinfo_out (bfd
*abfd
, const Elf32_crinfo
*in
,
2591 Elf32_External_crinfo
*ex
)
2595 l
= (((in
->ctype
& CRINFO_CTYPE
) << CRINFO_CTYPE_SH
)
2596 | ((in
->rtype
& CRINFO_RTYPE
) << CRINFO_RTYPE_SH
)
2597 | ((in
->dist2to
& CRINFO_DIST2TO
) << CRINFO_DIST2TO_SH
)
2598 | ((in
->relvaddr
& CRINFO_RELVADDR
) << CRINFO_RELVADDR_SH
));
2599 H_PUT_32 (abfd
, l
, ex
->info
);
2600 H_PUT_32 (abfd
, in
->konst
, ex
->konst
);
2601 H_PUT_32 (abfd
, in
->vaddr
, ex
->vaddr
);
2604 /* A .reginfo section holds a single Elf32_RegInfo structure. These
2605 routines swap this structure in and out. They are used outside of
2606 BFD, so they are globally visible. */
2609 bfd_mips_elf32_swap_reginfo_in (bfd
*abfd
, const Elf32_External_RegInfo
*ex
,
2612 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
2613 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
2614 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
2615 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
2616 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
2617 in
->ri_gp_value
= H_GET_32 (abfd
, ex
->ri_gp_value
);
2621 bfd_mips_elf32_swap_reginfo_out (bfd
*abfd
, const Elf32_RegInfo
*in
,
2622 Elf32_External_RegInfo
*ex
)
2624 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
2625 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
2626 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
2627 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
2628 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
2629 H_PUT_32 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
2632 /* In the 64 bit ABI, the .MIPS.options section holds register
2633 information in an Elf64_Reginfo structure. These routines swap
2634 them in and out. They are globally visible because they are used
2635 outside of BFD. These routines are here so that gas can call them
2636 without worrying about whether the 64 bit ABI has been included. */
2639 bfd_mips_elf64_swap_reginfo_in (bfd
*abfd
, const Elf64_External_RegInfo
*ex
,
2640 Elf64_Internal_RegInfo
*in
)
2642 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
2643 in
->ri_pad
= H_GET_32 (abfd
, ex
->ri_pad
);
2644 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
2645 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
2646 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
2647 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
2648 in
->ri_gp_value
= H_GET_64 (abfd
, ex
->ri_gp_value
);
2652 bfd_mips_elf64_swap_reginfo_out (bfd
*abfd
, const Elf64_Internal_RegInfo
*in
,
2653 Elf64_External_RegInfo
*ex
)
2655 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
2656 H_PUT_32 (abfd
, in
->ri_pad
, ex
->ri_pad
);
2657 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
2658 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
2659 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
2660 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
2661 H_PUT_64 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
2664 /* Swap in an options header. */
2667 bfd_mips_elf_swap_options_in (bfd
*abfd
, const Elf_External_Options
*ex
,
2668 Elf_Internal_Options
*in
)
2670 in
->kind
= H_GET_8 (abfd
, ex
->kind
);
2671 in
->size
= H_GET_8 (abfd
, ex
->size
);
2672 in
->section
= H_GET_16 (abfd
, ex
->section
);
2673 in
->info
= H_GET_32 (abfd
, ex
->info
);
2676 /* Swap out an options header. */
2679 bfd_mips_elf_swap_options_out (bfd
*abfd
, const Elf_Internal_Options
*in
,
2680 Elf_External_Options
*ex
)
2682 H_PUT_8 (abfd
, in
->kind
, ex
->kind
);
2683 H_PUT_8 (abfd
, in
->size
, ex
->size
);
2684 H_PUT_16 (abfd
, in
->section
, ex
->section
);
2685 H_PUT_32 (abfd
, in
->info
, ex
->info
);
2688 /* Swap in an abiflags structure. */
2691 bfd_mips_elf_swap_abiflags_v0_in (bfd
*abfd
,
2692 const Elf_External_ABIFlags_v0
*ex
,
2693 Elf_Internal_ABIFlags_v0
*in
)
2695 in
->version
= H_GET_16 (abfd
, ex
->version
);
2696 in
->isa_level
= H_GET_8 (abfd
, ex
->isa_level
);
2697 in
->isa_rev
= H_GET_8 (abfd
, ex
->isa_rev
);
2698 in
->gpr_size
= H_GET_8 (abfd
, ex
->gpr_size
);
2699 in
->cpr1_size
= H_GET_8 (abfd
, ex
->cpr1_size
);
2700 in
->cpr2_size
= H_GET_8 (abfd
, ex
->cpr2_size
);
2701 in
->fp_abi
= H_GET_8 (abfd
, ex
->fp_abi
);
2702 in
->isa_ext
= H_GET_32 (abfd
, ex
->isa_ext
);
2703 in
->ases
= H_GET_32 (abfd
, ex
->ases
);
2704 in
->flags1
= H_GET_32 (abfd
, ex
->flags1
);
2705 in
->flags2
= H_GET_32 (abfd
, ex
->flags2
);
2708 /* Swap out an abiflags structure. */
2711 bfd_mips_elf_swap_abiflags_v0_out (bfd
*abfd
,
2712 const Elf_Internal_ABIFlags_v0
*in
,
2713 Elf_External_ABIFlags_v0
*ex
)
2715 H_PUT_16 (abfd
, in
->version
, ex
->version
);
2716 H_PUT_8 (abfd
, in
->isa_level
, ex
->isa_level
);
2717 H_PUT_8 (abfd
, in
->isa_rev
, ex
->isa_rev
);
2718 H_PUT_8 (abfd
, in
->gpr_size
, ex
->gpr_size
);
2719 H_PUT_8 (abfd
, in
->cpr1_size
, ex
->cpr1_size
);
2720 H_PUT_8 (abfd
, in
->cpr2_size
, ex
->cpr2_size
);
2721 H_PUT_8 (abfd
, in
->fp_abi
, ex
->fp_abi
);
2722 H_PUT_32 (abfd
, in
->isa_ext
, ex
->isa_ext
);
2723 H_PUT_32 (abfd
, in
->ases
, ex
->ases
);
2724 H_PUT_32 (abfd
, in
->flags1
, ex
->flags1
);
2725 H_PUT_32 (abfd
, in
->flags2
, ex
->flags2
);
2728 /* This function is called via qsort() to sort the dynamic relocation
2729 entries by increasing r_symndx value. */
2732 sort_dynamic_relocs (const void *arg1
, const void *arg2
)
2734 Elf_Internal_Rela int_reloc1
;
2735 Elf_Internal_Rela int_reloc2
;
2738 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg1
, &int_reloc1
);
2739 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg2
, &int_reloc2
);
2741 diff
= ELF32_R_SYM (int_reloc1
.r_info
) - ELF32_R_SYM (int_reloc2
.r_info
);
2745 if (int_reloc1
.r_offset
< int_reloc2
.r_offset
)
2747 if (int_reloc1
.r_offset
> int_reloc2
.r_offset
)
2752 /* Like sort_dynamic_relocs, but used for elf64 relocations. */
2755 sort_dynamic_relocs_64 (const void *arg1 ATTRIBUTE_UNUSED
,
2756 const void *arg2 ATTRIBUTE_UNUSED
)
2759 Elf_Internal_Rela int_reloc1
[3];
2760 Elf_Internal_Rela int_reloc2
[3];
2762 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
2763 (reldyn_sorting_bfd
, arg1
, int_reloc1
);
2764 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
2765 (reldyn_sorting_bfd
, arg2
, int_reloc2
);
2767 if (ELF64_R_SYM (int_reloc1
[0].r_info
) < ELF64_R_SYM (int_reloc2
[0].r_info
))
2769 if (ELF64_R_SYM (int_reloc1
[0].r_info
) > ELF64_R_SYM (int_reloc2
[0].r_info
))
2772 if (int_reloc1
[0].r_offset
< int_reloc2
[0].r_offset
)
2774 if (int_reloc1
[0].r_offset
> int_reloc2
[0].r_offset
)
2783 /* This routine is used to write out ECOFF debugging external symbol
2784 information. It is called via mips_elf_link_hash_traverse. The
2785 ECOFF external symbol information must match the ELF external
2786 symbol information. Unfortunately, at this point we don't know
2787 whether a symbol is required by reloc information, so the two
2788 tables may wind up being different. We must sort out the external
2789 symbol information before we can set the final size of the .mdebug
2790 section, and we must set the size of the .mdebug section before we
2791 can relocate any sections, and we can't know which symbols are
2792 required by relocation until we relocate the sections.
2793 Fortunately, it is relatively unlikely that any symbol will be
2794 stripped but required by a reloc. In particular, it can not happen
2795 when generating a final executable. */
2798 mips_elf_output_extsym (struct mips_elf_link_hash_entry
*h
, void *data
)
2800 struct extsym_info
*einfo
= data
;
2802 asection
*sec
, *output_section
;
2804 if (h
->root
.indx
== -2)
2806 else if ((h
->root
.def_dynamic
2807 || h
->root
.ref_dynamic
2808 || h
->root
.type
== bfd_link_hash_new
)
2809 && !h
->root
.def_regular
2810 && !h
->root
.ref_regular
)
2812 else if (einfo
->info
->strip
== strip_all
2813 || (einfo
->info
->strip
== strip_some
2814 && bfd_hash_lookup (einfo
->info
->keep_hash
,
2815 h
->root
.root
.root
.string
,
2816 FALSE
, FALSE
) == NULL
))
2824 if (h
->esym
.ifd
== -2)
2827 h
->esym
.cobol_main
= 0;
2828 h
->esym
.weakext
= 0;
2829 h
->esym
.reserved
= 0;
2830 h
->esym
.ifd
= ifdNil
;
2831 h
->esym
.asym
.value
= 0;
2832 h
->esym
.asym
.st
= stGlobal
;
2834 if (h
->root
.root
.type
== bfd_link_hash_undefined
2835 || h
->root
.root
.type
== bfd_link_hash_undefweak
)
2839 /* Use undefined class. Also, set class and type for some
2841 name
= h
->root
.root
.root
.string
;
2842 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
2843 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
2845 h
->esym
.asym
.sc
= scData
;
2846 h
->esym
.asym
.st
= stLabel
;
2847 h
->esym
.asym
.value
= 0;
2849 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
2851 h
->esym
.asym
.sc
= scAbs
;
2852 h
->esym
.asym
.st
= stLabel
;
2853 h
->esym
.asym
.value
=
2854 mips_elf_hash_table (einfo
->info
)->procedure_count
;
2856 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (einfo
->abfd
))
2858 h
->esym
.asym
.sc
= scAbs
;
2859 h
->esym
.asym
.st
= stLabel
;
2860 h
->esym
.asym
.value
= elf_gp (einfo
->abfd
);
2863 h
->esym
.asym
.sc
= scUndefined
;
2865 else if (h
->root
.root
.type
!= bfd_link_hash_defined
2866 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
2867 h
->esym
.asym
.sc
= scAbs
;
2872 sec
= h
->root
.root
.u
.def
.section
;
2873 output_section
= sec
->output_section
;
2875 /* When making a shared library and symbol h is the one from
2876 the another shared library, OUTPUT_SECTION may be null. */
2877 if (output_section
== NULL
)
2878 h
->esym
.asym
.sc
= scUndefined
;
2881 name
= bfd_section_name (output_section
->owner
, output_section
);
2883 if (strcmp (name
, ".text") == 0)
2884 h
->esym
.asym
.sc
= scText
;
2885 else if (strcmp (name
, ".data") == 0)
2886 h
->esym
.asym
.sc
= scData
;
2887 else if (strcmp (name
, ".sdata") == 0)
2888 h
->esym
.asym
.sc
= scSData
;
2889 else if (strcmp (name
, ".rodata") == 0
2890 || strcmp (name
, ".rdata") == 0)
2891 h
->esym
.asym
.sc
= scRData
;
2892 else if (strcmp (name
, ".bss") == 0)
2893 h
->esym
.asym
.sc
= scBss
;
2894 else if (strcmp (name
, ".sbss") == 0)
2895 h
->esym
.asym
.sc
= scSBss
;
2896 else if (strcmp (name
, ".init") == 0)
2897 h
->esym
.asym
.sc
= scInit
;
2898 else if (strcmp (name
, ".fini") == 0)
2899 h
->esym
.asym
.sc
= scFini
;
2901 h
->esym
.asym
.sc
= scAbs
;
2905 h
->esym
.asym
.reserved
= 0;
2906 h
->esym
.asym
.index
= indexNil
;
2909 if (h
->root
.root
.type
== bfd_link_hash_common
)
2910 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
2911 else if (h
->root
.root
.type
== bfd_link_hash_defined
2912 || h
->root
.root
.type
== bfd_link_hash_defweak
)
2914 if (h
->esym
.asym
.sc
== scCommon
)
2915 h
->esym
.asym
.sc
= scBss
;
2916 else if (h
->esym
.asym
.sc
== scSCommon
)
2917 h
->esym
.asym
.sc
= scSBss
;
2919 sec
= h
->root
.root
.u
.def
.section
;
2920 output_section
= sec
->output_section
;
2921 if (output_section
!= NULL
)
2922 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
2923 + sec
->output_offset
2924 + output_section
->vma
);
2926 h
->esym
.asym
.value
= 0;
2930 struct mips_elf_link_hash_entry
*hd
= h
;
2932 while (hd
->root
.root
.type
== bfd_link_hash_indirect
)
2933 hd
= (struct mips_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
2935 if (hd
->needs_lazy_stub
)
2937 BFD_ASSERT (hd
->root
.plt
.plist
!= NULL
);
2938 BFD_ASSERT (hd
->root
.plt
.plist
->stub_offset
!= MINUS_ONE
);
2939 /* Set type and value for a symbol with a function stub. */
2940 h
->esym
.asym
.st
= stProc
;
2941 sec
= hd
->root
.root
.u
.def
.section
;
2943 h
->esym
.asym
.value
= 0;
2946 output_section
= sec
->output_section
;
2947 if (output_section
!= NULL
)
2948 h
->esym
.asym
.value
= (hd
->root
.plt
.plist
->stub_offset
2949 + sec
->output_offset
2950 + output_section
->vma
);
2952 h
->esym
.asym
.value
= 0;
2957 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
2958 h
->root
.root
.root
.string
,
2961 einfo
->failed
= TRUE
;
2968 /* A comparison routine used to sort .gptab entries. */
2971 gptab_compare (const void *p1
, const void *p2
)
2973 const Elf32_gptab
*a1
= p1
;
2974 const Elf32_gptab
*a2
= p2
;
2976 return a1
->gt_entry
.gt_g_value
- a2
->gt_entry
.gt_g_value
;
2979 /* Functions to manage the got entry hash table. */
2981 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
2984 static INLINE hashval_t
2985 mips_elf_hash_bfd_vma (bfd_vma addr
)
2988 return addr
+ (addr
>> 32);
2995 mips_elf_got_entry_hash (const void *entry_
)
2997 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
2999 return (entry
->symndx
3000 + ((entry
->tls_type
== GOT_TLS_LDM
) << 18)
3001 + (entry
->tls_type
== GOT_TLS_LDM
? 0
3002 : !entry
->abfd
? mips_elf_hash_bfd_vma (entry
->d
.address
)
3003 : entry
->symndx
>= 0 ? (entry
->abfd
->id
3004 + mips_elf_hash_bfd_vma (entry
->d
.addend
))
3005 : entry
->d
.h
->root
.root
.root
.hash
));
3009 mips_elf_got_entry_eq (const void *entry1
, const void *entry2
)
3011 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
3012 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
3014 return (e1
->symndx
== e2
->symndx
3015 && e1
->tls_type
== e2
->tls_type
3016 && (e1
->tls_type
== GOT_TLS_LDM
? TRUE
3017 : !e1
->abfd
? !e2
->abfd
&& e1
->d
.address
== e2
->d
.address
3018 : e1
->symndx
>= 0 ? (e1
->abfd
== e2
->abfd
3019 && e1
->d
.addend
== e2
->d
.addend
)
3020 : e2
->abfd
&& e1
->d
.h
== e2
->d
.h
));
3024 mips_got_page_ref_hash (const void *ref_
)
3026 const struct mips_got_page_ref
*ref
;
3028 ref
= (const struct mips_got_page_ref
*) ref_
;
3029 return ((ref
->symndx
>= 0
3030 ? (hashval_t
) (ref
->u
.abfd
->id
+ ref
->symndx
)
3031 : ref
->u
.h
->root
.root
.root
.hash
)
3032 + mips_elf_hash_bfd_vma (ref
->addend
));
3036 mips_got_page_ref_eq (const void *ref1_
, const void *ref2_
)
3038 const struct mips_got_page_ref
*ref1
, *ref2
;
3040 ref1
= (const struct mips_got_page_ref
*) ref1_
;
3041 ref2
= (const struct mips_got_page_ref
*) ref2_
;
3042 return (ref1
->symndx
== ref2
->symndx
3043 && (ref1
->symndx
< 0
3044 ? ref1
->u
.h
== ref2
->u
.h
3045 : ref1
->u
.abfd
== ref2
->u
.abfd
)
3046 && ref1
->addend
== ref2
->addend
);
3050 mips_got_page_entry_hash (const void *entry_
)
3052 const struct mips_got_page_entry
*entry
;
3054 entry
= (const struct mips_got_page_entry
*) entry_
;
3055 return entry
->sec
->id
;
3059 mips_got_page_entry_eq (const void *entry1_
, const void *entry2_
)
3061 const struct mips_got_page_entry
*entry1
, *entry2
;
3063 entry1
= (const struct mips_got_page_entry
*) entry1_
;
3064 entry2
= (const struct mips_got_page_entry
*) entry2_
;
3065 return entry1
->sec
== entry2
->sec
;
3068 /* Create and return a new mips_got_info structure. */
3070 static struct mips_got_info
*
3071 mips_elf_create_got_info (bfd
*abfd
)
3073 struct mips_got_info
*g
;
3075 g
= bfd_zalloc (abfd
, sizeof (struct mips_got_info
));
3079 g
->got_entries
= htab_try_create (1, mips_elf_got_entry_hash
,
3080 mips_elf_got_entry_eq
, NULL
);
3081 if (g
->got_entries
== NULL
)
3084 g
->got_page_refs
= htab_try_create (1, mips_got_page_ref_hash
,
3085 mips_got_page_ref_eq
, NULL
);
3086 if (g
->got_page_refs
== NULL
)
3092 /* Return the GOT info for input bfd ABFD, trying to create a new one if
3093 CREATE_P and if ABFD doesn't already have a GOT. */
3095 static struct mips_got_info
*
3096 mips_elf_bfd_got (bfd
*abfd
, bfd_boolean create_p
)
3098 struct mips_elf_obj_tdata
*tdata
;
3100 if (!is_mips_elf (abfd
))
3103 tdata
= mips_elf_tdata (abfd
);
3104 if (!tdata
->got
&& create_p
)
3105 tdata
->got
= mips_elf_create_got_info (abfd
);
3109 /* Record that ABFD should use output GOT G. */
3112 mips_elf_replace_bfd_got (bfd
*abfd
, struct mips_got_info
*g
)
3114 struct mips_elf_obj_tdata
*tdata
;
3116 BFD_ASSERT (is_mips_elf (abfd
));
3117 tdata
= mips_elf_tdata (abfd
);
3120 /* The GOT structure itself and the hash table entries are
3121 allocated to a bfd, but the hash tables aren't. */
3122 htab_delete (tdata
->got
->got_entries
);
3123 htab_delete (tdata
->got
->got_page_refs
);
3124 if (tdata
->got
->got_page_entries
)
3125 htab_delete (tdata
->got
->got_page_entries
);
3130 /* Return the dynamic relocation section. If it doesn't exist, try to
3131 create a new it if CREATE_P, otherwise return NULL. Also return NULL
3132 if creation fails. */
3135 mips_elf_rel_dyn_section (struct bfd_link_info
*info
, bfd_boolean create_p
)
3141 dname
= MIPS_ELF_REL_DYN_NAME (info
);
3142 dynobj
= elf_hash_table (info
)->dynobj
;
3143 sreloc
= bfd_get_linker_section (dynobj
, dname
);
3144 if (sreloc
== NULL
&& create_p
)
3146 sreloc
= bfd_make_section_anyway_with_flags (dynobj
, dname
,
3151 | SEC_LINKER_CREATED
3154 || ! bfd_set_section_alignment (dynobj
, sreloc
,
3155 MIPS_ELF_LOG_FILE_ALIGN (dynobj
)))
3161 /* Return the GOT_TLS_* type required by relocation type R_TYPE. */
3164 mips_elf_reloc_tls_type (unsigned int r_type
)
3166 if (tls_gd_reloc_p (r_type
))
3169 if (tls_ldm_reloc_p (r_type
))
3172 if (tls_gottprel_reloc_p (r_type
))
3175 return GOT_TLS_NONE
;
3178 /* Return the number of GOT slots needed for GOT TLS type TYPE. */
3181 mips_tls_got_entries (unsigned int type
)
3198 /* Count the number of relocations needed for a TLS GOT entry, with
3199 access types from TLS_TYPE, and symbol H (or a local symbol if H
3203 mips_tls_got_relocs (struct bfd_link_info
*info
, unsigned char tls_type
,
3204 struct elf_link_hash_entry
*h
)
3207 bfd_boolean need_relocs
= FALSE
;
3208 bfd_boolean dyn
= elf_hash_table (info
)->dynamic_sections_created
;
3210 if (h
&& WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
3211 && (!bfd_link_pic (info
) || !SYMBOL_REFERENCES_LOCAL (info
, h
)))
3214 if ((bfd_link_pic (info
) || indx
!= 0)
3216 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3217 || h
->root
.type
!= bfd_link_hash_undefweak
))
3226 return indx
!= 0 ? 2 : 1;
3232 return bfd_link_pic (info
) ? 1 : 0;
3239 /* Add the number of GOT entries and TLS relocations required by ENTRY
3243 mips_elf_count_got_entry (struct bfd_link_info
*info
,
3244 struct mips_got_info
*g
,
3245 struct mips_got_entry
*entry
)
3247 if (entry
->tls_type
)
3249 g
->tls_gotno
+= mips_tls_got_entries (entry
->tls_type
);
3250 g
->relocs
+= mips_tls_got_relocs (info
, entry
->tls_type
,
3252 ? &entry
->d
.h
->root
: NULL
);
3254 else if (entry
->symndx
>= 0 || entry
->d
.h
->global_got_area
== GGA_NONE
)
3255 g
->local_gotno
+= 1;
3257 g
->global_gotno
+= 1;
3260 /* Output a simple dynamic relocation into SRELOC. */
3263 mips_elf_output_dynamic_relocation (bfd
*output_bfd
,
3265 unsigned long reloc_index
,
3270 Elf_Internal_Rela rel
[3];
3272 memset (rel
, 0, sizeof (rel
));
3274 rel
[0].r_info
= ELF_R_INFO (output_bfd
, indx
, r_type
);
3275 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
3277 if (ABI_64_P (output_bfd
))
3279 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
3280 (output_bfd
, &rel
[0],
3282 + reloc_index
* sizeof (Elf64_Mips_External_Rel
)));
3285 bfd_elf32_swap_reloc_out
3286 (output_bfd
, &rel
[0],
3288 + reloc_index
* sizeof (Elf32_External_Rel
)));
3291 /* Initialize a set of TLS GOT entries for one symbol. */
3294 mips_elf_initialize_tls_slots (bfd
*abfd
, struct bfd_link_info
*info
,
3295 struct mips_got_entry
*entry
,
3296 struct mips_elf_link_hash_entry
*h
,
3299 struct mips_elf_link_hash_table
*htab
;
3301 asection
*sreloc
, *sgot
;
3302 bfd_vma got_offset
, got_offset2
;
3303 bfd_boolean need_relocs
= FALSE
;
3305 htab
= mips_elf_hash_table (info
);
3314 bfd_boolean dyn
= elf_hash_table (info
)->dynamic_sections_created
;
3316 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
),
3318 && (!bfd_link_pic (info
)
3319 || !SYMBOL_REFERENCES_LOCAL (info
, &h
->root
)))
3320 indx
= h
->root
.dynindx
;
3323 if (entry
->tls_initialized
)
3326 if ((bfd_link_pic (info
) || indx
!= 0)
3328 || ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
3329 || h
->root
.type
!= bfd_link_hash_undefweak
))
3332 /* MINUS_ONE means the symbol is not defined in this object. It may not
3333 be defined at all; assume that the value doesn't matter in that
3334 case. Otherwise complain if we would use the value. */
3335 BFD_ASSERT (value
!= MINUS_ONE
|| (indx
!= 0 && need_relocs
)
3336 || h
->root
.root
.type
== bfd_link_hash_undefweak
);
3338 /* Emit necessary relocations. */
3339 sreloc
= mips_elf_rel_dyn_section (info
, FALSE
);
3340 got_offset
= entry
->gotidx
;
3342 switch (entry
->tls_type
)
3345 /* General Dynamic. */
3346 got_offset2
= got_offset
+ MIPS_ELF_GOT_SIZE (abfd
);
3350 mips_elf_output_dynamic_relocation
3351 (abfd
, sreloc
, sreloc
->reloc_count
++, indx
,
3352 ABI_64_P (abfd
) ? R_MIPS_TLS_DTPMOD64
: R_MIPS_TLS_DTPMOD32
,
3353 sgot
->output_offset
+ sgot
->output_section
->vma
+ got_offset
);
3356 mips_elf_output_dynamic_relocation
3357 (abfd
, sreloc
, sreloc
->reloc_count
++, indx
,
3358 ABI_64_P (abfd
) ? R_MIPS_TLS_DTPREL64
: R_MIPS_TLS_DTPREL32
,
3359 sgot
->output_offset
+ sgot
->output_section
->vma
+ got_offset2
);
3361 MIPS_ELF_PUT_WORD (abfd
, value
- dtprel_base (info
),
3362 sgot
->contents
+ got_offset2
);
3366 MIPS_ELF_PUT_WORD (abfd
, 1,
3367 sgot
->contents
+ got_offset
);
3368 MIPS_ELF_PUT_WORD (abfd
, value
- dtprel_base (info
),
3369 sgot
->contents
+ got_offset2
);
3374 /* Initial Exec model. */
3378 MIPS_ELF_PUT_WORD (abfd
, value
- elf_hash_table (info
)->tls_sec
->vma
,
3379 sgot
->contents
+ got_offset
);
3381 MIPS_ELF_PUT_WORD (abfd
, 0,
3382 sgot
->contents
+ got_offset
);
3384 mips_elf_output_dynamic_relocation
3385 (abfd
, sreloc
, sreloc
->reloc_count
++, indx
,
3386 ABI_64_P (abfd
) ? R_MIPS_TLS_TPREL64
: R_MIPS_TLS_TPREL32
,
3387 sgot
->output_offset
+ sgot
->output_section
->vma
+ got_offset
);
3390 MIPS_ELF_PUT_WORD (abfd
, value
- tprel_base (info
),
3391 sgot
->contents
+ got_offset
);
3395 /* The initial offset is zero, and the LD offsets will include the
3396 bias by DTP_OFFSET. */
3397 MIPS_ELF_PUT_WORD (abfd
, 0,
3398 sgot
->contents
+ got_offset
3399 + MIPS_ELF_GOT_SIZE (abfd
));
3401 if (!bfd_link_pic (info
))
3402 MIPS_ELF_PUT_WORD (abfd
, 1,
3403 sgot
->contents
+ got_offset
);
3405 mips_elf_output_dynamic_relocation
3406 (abfd
, sreloc
, sreloc
->reloc_count
++, indx
,
3407 ABI_64_P (abfd
) ? R_MIPS_TLS_DTPMOD64
: R_MIPS_TLS_DTPMOD32
,
3408 sgot
->output_offset
+ sgot
->output_section
->vma
+ got_offset
);
3415 entry
->tls_initialized
= TRUE
;
3418 /* Return the offset from _GLOBAL_OFFSET_TABLE_ of the .got.plt entry
3419 for global symbol H. .got.plt comes before the GOT, so the offset
3420 will be negative. */
3423 mips_elf_gotplt_index (struct bfd_link_info
*info
,
3424 struct elf_link_hash_entry
*h
)
3426 bfd_vma got_address
, got_value
;
3427 struct mips_elf_link_hash_table
*htab
;
3429 htab
= mips_elf_hash_table (info
);
3430 BFD_ASSERT (htab
!= NULL
);
3432 BFD_ASSERT (h
->plt
.plist
!= NULL
);
3433 BFD_ASSERT (h
->plt
.plist
->gotplt_index
!= MINUS_ONE
);
3435 /* Calculate the address of the associated .got.plt entry. */
3436 got_address
= (htab
->sgotplt
->output_section
->vma
3437 + htab
->sgotplt
->output_offset
3438 + (h
->plt
.plist
->gotplt_index
3439 * MIPS_ELF_GOT_SIZE (info
->output_bfd
)));
3441 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */
3442 got_value
= (htab
->root
.hgot
->root
.u
.def
.section
->output_section
->vma
3443 + htab
->root
.hgot
->root
.u
.def
.section
->output_offset
3444 + htab
->root
.hgot
->root
.u
.def
.value
);
3446 return got_address
- got_value
;
3449 /* Return the GOT offset for address VALUE. If there is not yet a GOT
3450 entry for this value, create one. If R_SYMNDX refers to a TLS symbol,
3451 create a TLS GOT entry instead. Return -1 if no satisfactory GOT
3452 offset can be found. */
3455 mips_elf_local_got_index (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
3456 bfd_vma value
, unsigned long r_symndx
,
3457 struct mips_elf_link_hash_entry
*h
, int r_type
)
3459 struct mips_elf_link_hash_table
*htab
;
3460 struct mips_got_entry
*entry
;
3462 htab
= mips_elf_hash_table (info
);
3463 BFD_ASSERT (htab
!= NULL
);
3465 entry
= mips_elf_create_local_got_entry (abfd
, info
, ibfd
, value
,
3466 r_symndx
, h
, r_type
);
3470 if (entry
->tls_type
)
3471 mips_elf_initialize_tls_slots (abfd
, info
, entry
, h
, value
);
3472 return entry
->gotidx
;
3475 /* Return the GOT index of global symbol H in the primary GOT. */
3478 mips_elf_primary_global_got_index (bfd
*obfd
, struct bfd_link_info
*info
,
3479 struct elf_link_hash_entry
*h
)
3481 struct mips_elf_link_hash_table
*htab
;
3482 long global_got_dynindx
;
3483 struct mips_got_info
*g
;
3486 htab
= mips_elf_hash_table (info
);
3487 BFD_ASSERT (htab
!= NULL
);
3489 global_got_dynindx
= 0;
3490 if (htab
->global_gotsym
!= NULL
)
3491 global_got_dynindx
= htab
->global_gotsym
->dynindx
;
3493 /* Once we determine the global GOT entry with the lowest dynamic
3494 symbol table index, we must put all dynamic symbols with greater
3495 indices into the primary GOT. That makes it easy to calculate the
3497 BFD_ASSERT (h
->dynindx
>= global_got_dynindx
);
3498 g
= mips_elf_bfd_got (obfd
, FALSE
);
3499 got_index
= ((h
->dynindx
- global_got_dynindx
+ g
->local_gotno
)
3500 * MIPS_ELF_GOT_SIZE (obfd
));
3501 BFD_ASSERT (got_index
< htab
->sgot
->size
);
3506 /* Return the GOT index for the global symbol indicated by H, which is
3507 referenced by a relocation of type R_TYPE in IBFD. */
3510 mips_elf_global_got_index (bfd
*obfd
, struct bfd_link_info
*info
, bfd
*ibfd
,
3511 struct elf_link_hash_entry
*h
, int r_type
)
3513 struct mips_elf_link_hash_table
*htab
;
3514 struct mips_got_info
*g
;
3515 struct mips_got_entry lookup
, *entry
;
3518 htab
= mips_elf_hash_table (info
);
3519 BFD_ASSERT (htab
!= NULL
);
3521 g
= mips_elf_bfd_got (ibfd
, FALSE
);
3524 lookup
.tls_type
= mips_elf_reloc_tls_type (r_type
);
3525 if (!lookup
.tls_type
&& g
== mips_elf_bfd_got (obfd
, FALSE
))
3526 return mips_elf_primary_global_got_index (obfd
, info
, h
);
3530 lookup
.d
.h
= (struct mips_elf_link_hash_entry
*) h
;
3531 entry
= htab_find (g
->got_entries
, &lookup
);
3534 gotidx
= entry
->gotidx
;
3535 BFD_ASSERT (gotidx
> 0 && gotidx
< htab
->sgot
->size
);
3537 if (lookup
.tls_type
)
3539 bfd_vma value
= MINUS_ONE
;
3541 if ((h
->root
.type
== bfd_link_hash_defined
3542 || h
->root
.type
== bfd_link_hash_defweak
)
3543 && h
->root
.u
.def
.section
->output_section
)
3544 value
= (h
->root
.u
.def
.value
3545 + h
->root
.u
.def
.section
->output_offset
3546 + h
->root
.u
.def
.section
->output_section
->vma
);
3548 mips_elf_initialize_tls_slots (obfd
, info
, entry
, lookup
.d
.h
, value
);
3553 /* Find a GOT page entry that points to within 32KB of VALUE. These
3554 entries are supposed to be placed at small offsets in the GOT, i.e.,
3555 within 32KB of GP. Return the index of the GOT entry, or -1 if no
3556 entry could be created. If OFFSETP is nonnull, use it to return the
3557 offset of the GOT entry from VALUE. */
3560 mips_elf_got_page (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
3561 bfd_vma value
, bfd_vma
*offsetp
)
3563 bfd_vma page
, got_index
;
3564 struct mips_got_entry
*entry
;
3566 page
= (value
+ 0x8000) & ~(bfd_vma
) 0xffff;
3567 entry
= mips_elf_create_local_got_entry (abfd
, info
, ibfd
, page
, 0,
3568 NULL
, R_MIPS_GOT_PAGE
);
3573 got_index
= entry
->gotidx
;
3576 *offsetp
= value
- entry
->d
.address
;
3581 /* Find a local GOT entry for an R_MIPS*_GOT16 relocation against VALUE.
3582 EXTERNAL is true if the relocation was originally against a global
3583 symbol that binds locally. */
3586 mips_elf_got16_entry (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
3587 bfd_vma value
, bfd_boolean external
)
3589 struct mips_got_entry
*entry
;
3591 /* GOT16 relocations against local symbols are followed by a LO16
3592 relocation; those against global symbols are not. Thus if the
3593 symbol was originally local, the GOT16 relocation should load the
3594 equivalent of %hi(VALUE), otherwise it should load VALUE itself. */
3596 value
= mips_elf_high (value
) << 16;
3598 /* It doesn't matter whether the original relocation was R_MIPS_GOT16,
3599 R_MIPS16_GOT16, R_MIPS_CALL16, etc. The format of the entry is the
3600 same in all cases. */
3601 entry
= mips_elf_create_local_got_entry (abfd
, info
, ibfd
, value
, 0,
3602 NULL
, R_MIPS_GOT16
);
3604 return entry
->gotidx
;
3609 /* Returns the offset for the entry at the INDEXth position
3613 mips_elf_got_offset_from_index (struct bfd_link_info
*info
, bfd
*output_bfd
,
3614 bfd
*input_bfd
, bfd_vma got_index
)
3616 struct mips_elf_link_hash_table
*htab
;
3620 htab
= mips_elf_hash_table (info
);
3621 BFD_ASSERT (htab
!= NULL
);
3624 gp
= _bfd_get_gp_value (output_bfd
)
3625 + mips_elf_adjust_gp (output_bfd
, htab
->got_info
, input_bfd
);
3627 return sgot
->output_section
->vma
+ sgot
->output_offset
+ got_index
- gp
;
3630 /* Create and return a local GOT entry for VALUE, which was calculated
3631 from a symbol belonging to INPUT_SECTON. Return NULL if it could not
3632 be created. If R_SYMNDX refers to a TLS symbol, create a TLS entry
3635 static struct mips_got_entry
*
3636 mips_elf_create_local_got_entry (bfd
*abfd
, struct bfd_link_info
*info
,
3637 bfd
*ibfd
, bfd_vma value
,
3638 unsigned long r_symndx
,
3639 struct mips_elf_link_hash_entry
*h
,
3642 struct mips_got_entry lookup
, *entry
;
3644 struct mips_got_info
*g
;
3645 struct mips_elf_link_hash_table
*htab
;
3648 htab
= mips_elf_hash_table (info
);
3649 BFD_ASSERT (htab
!= NULL
);
3651 g
= mips_elf_bfd_got (ibfd
, FALSE
);
3654 g
= mips_elf_bfd_got (abfd
, FALSE
);
3655 BFD_ASSERT (g
!= NULL
);
3658 /* This function shouldn't be called for symbols that live in the global
3660 BFD_ASSERT (h
== NULL
|| h
->global_got_area
== GGA_NONE
);
3662 lookup
.tls_type
= mips_elf_reloc_tls_type (r_type
);
3663 if (lookup
.tls_type
)
3666 if (tls_ldm_reloc_p (r_type
))
3669 lookup
.d
.addend
= 0;
3673 lookup
.symndx
= r_symndx
;
3674 lookup
.d
.addend
= 0;
3682 entry
= (struct mips_got_entry
*) htab_find (g
->got_entries
, &lookup
);
3685 gotidx
= entry
->gotidx
;
3686 BFD_ASSERT (gotidx
> 0 && gotidx
< htab
->sgot
->size
);
3693 lookup
.d
.address
= value
;
3694 loc
= htab_find_slot (g
->got_entries
, &lookup
, INSERT
);
3698 entry
= (struct mips_got_entry
*) *loc
;
3702 if (g
->assigned_low_gotno
> g
->assigned_high_gotno
)
3704 /* We didn't allocate enough space in the GOT. */
3705 (*_bfd_error_handler
)
3706 (_("not enough GOT space for local GOT entries"));
3707 bfd_set_error (bfd_error_bad_value
);
3711 entry
= (struct mips_got_entry
*) bfd_alloc (abfd
, sizeof (*entry
));
3715 if (got16_reloc_p (r_type
)
3716 || call16_reloc_p (r_type
)
3717 || got_page_reloc_p (r_type
)
3718 || got_disp_reloc_p (r_type
))
3719 lookup
.gotidx
= MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_low_gotno
++;
3721 lookup
.gotidx
= MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_high_gotno
--;
3726 MIPS_ELF_PUT_WORD (abfd
, value
, htab
->sgot
->contents
+ entry
->gotidx
);
3728 /* These GOT entries need a dynamic relocation on VxWorks. */
3729 if (htab
->is_vxworks
)
3731 Elf_Internal_Rela outrel
;
3734 bfd_vma got_address
;
3736 s
= mips_elf_rel_dyn_section (info
, FALSE
);
3737 got_address
= (htab
->sgot
->output_section
->vma
3738 + htab
->sgot
->output_offset
3741 rloc
= s
->contents
+ (s
->reloc_count
++ * sizeof (Elf32_External_Rela
));
3742 outrel
.r_offset
= got_address
;
3743 outrel
.r_info
= ELF32_R_INFO (STN_UNDEF
, R_MIPS_32
);
3744 outrel
.r_addend
= value
;
3745 bfd_elf32_swap_reloca_out (abfd
, &outrel
, rloc
);
3751 /* Return the number of dynamic section symbols required by OUTPUT_BFD.
3752 The number might be exact or a worst-case estimate, depending on how
3753 much information is available to elf_backend_omit_section_dynsym at
3754 the current linking stage. */
3756 static bfd_size_type
3757 count_section_dynsyms (bfd
*output_bfd
, struct bfd_link_info
*info
)
3759 bfd_size_type count
;
3762 if (bfd_link_pic (info
)
3763 || elf_hash_table (info
)->is_relocatable_executable
)
3766 const struct elf_backend_data
*bed
;
3768 bed
= get_elf_backend_data (output_bfd
);
3769 for (p
= output_bfd
->sections
; p
; p
= p
->next
)
3770 if ((p
->flags
& SEC_EXCLUDE
) == 0
3771 && (p
->flags
& SEC_ALLOC
) != 0
3772 && !(*bed
->elf_backend_omit_section_dynsym
) (output_bfd
, info
, p
))
3778 /* Sort the dynamic symbol table so that symbols that need GOT entries
3779 appear towards the end. */
3782 mips_elf_sort_hash_table (bfd
*abfd
, struct bfd_link_info
*info
)
3784 struct mips_elf_link_hash_table
*htab
;
3785 struct mips_elf_hash_sort_data hsd
;
3786 struct mips_got_info
*g
;
3788 if (elf_hash_table (info
)->dynsymcount
== 0)
3791 htab
= mips_elf_hash_table (info
);
3792 BFD_ASSERT (htab
!= NULL
);
3799 hsd
.max_unref_got_dynindx
3800 = hsd
.min_got_dynindx
3801 = (elf_hash_table (info
)->dynsymcount
- g
->reloc_only_gotno
);
3802 hsd
.max_non_got_dynindx
= count_section_dynsyms (abfd
, info
) + 1;
3803 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table
*)
3804 elf_hash_table (info
)),
3805 mips_elf_sort_hash_table_f
,
3808 /* There should have been enough room in the symbol table to
3809 accommodate both the GOT and non-GOT symbols. */
3810 BFD_ASSERT (hsd
.max_non_got_dynindx
<= hsd
.min_got_dynindx
);
3811 BFD_ASSERT ((unsigned long) hsd
.max_unref_got_dynindx
3812 == elf_hash_table (info
)->dynsymcount
);
3813 BFD_ASSERT (elf_hash_table (info
)->dynsymcount
- hsd
.min_got_dynindx
3814 == g
->global_gotno
);
3816 /* Now we know which dynamic symbol has the lowest dynamic symbol
3817 table index in the GOT. */
3818 htab
->global_gotsym
= hsd
.low
;
3823 /* If H needs a GOT entry, assign it the highest available dynamic
3824 index. Otherwise, assign it the lowest available dynamic
3828 mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry
*h
, void *data
)
3830 struct mips_elf_hash_sort_data
*hsd
= data
;
3832 /* Symbols without dynamic symbol table entries aren't interesting
3834 if (h
->root
.dynindx
== -1)
3837 switch (h
->global_got_area
)
3840 h
->root
.dynindx
= hsd
->max_non_got_dynindx
++;
3844 h
->root
.dynindx
= --hsd
->min_got_dynindx
;
3845 hsd
->low
= (struct elf_link_hash_entry
*) h
;
3848 case GGA_RELOC_ONLY
:
3849 if (hsd
->max_unref_got_dynindx
== hsd
->min_got_dynindx
)
3850 hsd
->low
= (struct elf_link_hash_entry
*) h
;
3851 h
->root
.dynindx
= hsd
->max_unref_got_dynindx
++;
3858 /* Record that input bfd ABFD requires a GOT entry like *LOOKUP
3859 (which is owned by the caller and shouldn't be added to the
3860 hash table directly). */
3863 mips_elf_record_got_entry (struct bfd_link_info
*info
, bfd
*abfd
,
3864 struct mips_got_entry
*lookup
)
3866 struct mips_elf_link_hash_table
*htab
;
3867 struct mips_got_entry
*entry
;
3868 struct mips_got_info
*g
;
3869 void **loc
, **bfd_loc
;
3871 /* Make sure there's a slot for this entry in the master GOT. */
3872 htab
= mips_elf_hash_table (info
);
3874 loc
= htab_find_slot (g
->got_entries
, lookup
, INSERT
);
3878 /* Populate the entry if it isn't already. */
3879 entry
= (struct mips_got_entry
*) *loc
;
3882 entry
= (struct mips_got_entry
*) bfd_alloc (abfd
, sizeof (*entry
));
3886 lookup
->tls_initialized
= FALSE
;
3887 lookup
->gotidx
= -1;
3892 /* Reuse the same GOT entry for the BFD's GOT. */
3893 g
= mips_elf_bfd_got (abfd
, TRUE
);
3897 bfd_loc
= htab_find_slot (g
->got_entries
, lookup
, INSERT
);
3906 /* ABFD has a GOT relocation of type R_TYPE against H. Reserve a GOT
3907 entry for it. FOR_CALL is true if the caller is only interested in
3908 using the GOT entry for calls. */
3911 mips_elf_record_global_got_symbol (struct elf_link_hash_entry
*h
,
3912 bfd
*abfd
, struct bfd_link_info
*info
,
3913 bfd_boolean for_call
, int r_type
)
3915 struct mips_elf_link_hash_table
*htab
;
3916 struct mips_elf_link_hash_entry
*hmips
;
3917 struct mips_got_entry entry
;
3918 unsigned char tls_type
;
3920 htab
= mips_elf_hash_table (info
);
3921 BFD_ASSERT (htab
!= NULL
);
3923 hmips
= (struct mips_elf_link_hash_entry
*) h
;
3925 hmips
->got_only_for_calls
= FALSE
;
3927 /* A global symbol in the GOT must also be in the dynamic symbol
3929 if (h
->dynindx
== -1)
3931 switch (ELF_ST_VISIBILITY (h
->other
))
3935 _bfd_elf_link_hash_hide_symbol (info
, h
, TRUE
);
3938 if (!bfd_elf_link_record_dynamic_symbol (info
, h
))
3942 tls_type
= mips_elf_reloc_tls_type (r_type
);
3943 if (tls_type
== GOT_TLS_NONE
&& hmips
->global_got_area
> GGA_NORMAL
)
3944 hmips
->global_got_area
= GGA_NORMAL
;
3948 entry
.d
.h
= (struct mips_elf_link_hash_entry
*) h
;
3949 entry
.tls_type
= tls_type
;
3950 return mips_elf_record_got_entry (info
, abfd
, &entry
);
3953 /* ABFD has a GOT relocation of type R_TYPE against symbol SYMNDX + ADDEND,
3954 where SYMNDX is a local symbol. Reserve a GOT entry for it. */
3957 mips_elf_record_local_got_symbol (bfd
*abfd
, long symndx
, bfd_vma addend
,
3958 struct bfd_link_info
*info
, int r_type
)
3960 struct mips_elf_link_hash_table
*htab
;
3961 struct mips_got_info
*g
;
3962 struct mips_got_entry entry
;
3964 htab
= mips_elf_hash_table (info
);
3965 BFD_ASSERT (htab
!= NULL
);
3968 BFD_ASSERT (g
!= NULL
);
3971 entry
.symndx
= symndx
;
3972 entry
.d
.addend
= addend
;
3973 entry
.tls_type
= mips_elf_reloc_tls_type (r_type
);
3974 return mips_elf_record_got_entry (info
, abfd
, &entry
);
3977 /* Record that ABFD has a page relocation against SYMNDX + ADDEND.
3978 H is the symbol's hash table entry, or null if SYMNDX is local
3982 mips_elf_record_got_page_ref (struct bfd_link_info
*info
, bfd
*abfd
,
3983 long symndx
, struct elf_link_hash_entry
*h
,
3984 bfd_signed_vma addend
)
3986 struct mips_elf_link_hash_table
*htab
;
3987 struct mips_got_info
*g1
, *g2
;
3988 struct mips_got_page_ref lookup
, *entry
;
3989 void **loc
, **bfd_loc
;
3991 htab
= mips_elf_hash_table (info
);
3992 BFD_ASSERT (htab
!= NULL
);
3994 g1
= htab
->got_info
;
3995 BFD_ASSERT (g1
!= NULL
);
4000 lookup
.u
.h
= (struct mips_elf_link_hash_entry
*) h
;
4004 lookup
.symndx
= symndx
;
4005 lookup
.u
.abfd
= abfd
;
4007 lookup
.addend
= addend
;
4008 loc
= htab_find_slot (g1
->got_page_refs
, &lookup
, INSERT
);
4012 entry
= (struct mips_got_page_ref
*) *loc
;
4015 entry
= bfd_alloc (abfd
, sizeof (*entry
));
4023 /* Add the same entry to the BFD's GOT. */
4024 g2
= mips_elf_bfd_got (abfd
, TRUE
);
4028 bfd_loc
= htab_find_slot (g2
->got_page_refs
, &lookup
, INSERT
);
4038 /* Add room for N relocations to the .rel(a).dyn section in ABFD. */
4041 mips_elf_allocate_dynamic_relocations (bfd
*abfd
, struct bfd_link_info
*info
,
4045 struct mips_elf_link_hash_table
*htab
;
4047 htab
= mips_elf_hash_table (info
);
4048 BFD_ASSERT (htab
!= NULL
);
4050 s
= mips_elf_rel_dyn_section (info
, FALSE
);
4051 BFD_ASSERT (s
!= NULL
);
4053 if (htab
->is_vxworks
)
4054 s
->size
+= n
* MIPS_ELF_RELA_SIZE (abfd
);
4059 /* Make room for a null element. */
4060 s
->size
+= MIPS_ELF_REL_SIZE (abfd
);
4063 s
->size
+= n
* MIPS_ELF_REL_SIZE (abfd
);
4067 /* A htab_traverse callback for GOT entries, with DATA pointing to a
4068 mips_elf_traverse_got_arg structure. Count the number of GOT
4069 entries and TLS relocs. Set DATA->value to true if we need
4070 to resolve indirect or warning symbols and then recreate the GOT. */
4073 mips_elf_check_recreate_got (void **entryp
, void *data
)
4075 struct mips_got_entry
*entry
;
4076 struct mips_elf_traverse_got_arg
*arg
;
4078 entry
= (struct mips_got_entry
*) *entryp
;
4079 arg
= (struct mips_elf_traverse_got_arg
*) data
;
4080 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1)
4082 struct mips_elf_link_hash_entry
*h
;
4085 if (h
->root
.root
.type
== bfd_link_hash_indirect
4086 || h
->root
.root
.type
== bfd_link_hash_warning
)
4092 mips_elf_count_got_entry (arg
->info
, arg
->g
, entry
);
4096 /* A htab_traverse callback for GOT entries, with DATA pointing to a
4097 mips_elf_traverse_got_arg structure. Add all entries to DATA->g,
4098 converting entries for indirect and warning symbols into entries
4099 for the target symbol. Set DATA->g to null on error. */
4102 mips_elf_recreate_got (void **entryp
, void *data
)
4104 struct mips_got_entry new_entry
, *entry
;
4105 struct mips_elf_traverse_got_arg
*arg
;
4108 entry
= (struct mips_got_entry
*) *entryp
;
4109 arg
= (struct mips_elf_traverse_got_arg
*) data
;
4110 if (entry
->abfd
!= NULL
4111 && entry
->symndx
== -1
4112 && (entry
->d
.h
->root
.root
.type
== bfd_link_hash_indirect
4113 || entry
->d
.h
->root
.root
.type
== bfd_link_hash_warning
))
4115 struct mips_elf_link_hash_entry
*h
;
4122 BFD_ASSERT (h
->global_got_area
== GGA_NONE
);
4123 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
4125 while (h
->root
.root
.type
== bfd_link_hash_indirect
4126 || h
->root
.root
.type
== bfd_link_hash_warning
);
4129 slot
= htab_find_slot (arg
->g
->got_entries
, entry
, INSERT
);
4137 if (entry
== &new_entry
)
4139 entry
= bfd_alloc (entry
->abfd
, sizeof (*entry
));
4148 mips_elf_count_got_entry (arg
->info
, arg
->g
, entry
);
4153 /* Return the maximum number of GOT page entries required for RANGE. */
4156 mips_elf_pages_for_range (const struct mips_got_page_range
*range
)
4158 return (range
->max_addend
- range
->min_addend
+ 0x1ffff) >> 16;
4161 /* Record that G requires a page entry that can reach SEC + ADDEND. */
4164 mips_elf_record_got_page_entry (struct mips_elf_traverse_got_arg
*arg
,
4165 asection
*sec
, bfd_signed_vma addend
)
4167 struct mips_got_info
*g
= arg
->g
;
4168 struct mips_got_page_entry lookup
, *entry
;
4169 struct mips_got_page_range
**range_ptr
, *range
;
4170 bfd_vma old_pages
, new_pages
;
4173 /* Find the mips_got_page_entry hash table entry for this section. */
4175 loc
= htab_find_slot (g
->got_page_entries
, &lookup
, INSERT
);
4179 /* Create a mips_got_page_entry if this is the first time we've
4180 seen the section. */
4181 entry
= (struct mips_got_page_entry
*) *loc
;
4184 entry
= bfd_zalloc (arg
->info
->output_bfd
, sizeof (*entry
));
4192 /* Skip over ranges whose maximum extent cannot share a page entry
4194 range_ptr
= &entry
->ranges
;
4195 while (*range_ptr
&& addend
> (*range_ptr
)->max_addend
+ 0xffff)
4196 range_ptr
= &(*range_ptr
)->next
;
4198 /* If we scanned to the end of the list, or found a range whose
4199 minimum extent cannot share a page entry with ADDEND, create
4200 a new singleton range. */
4202 if (!range
|| addend
< range
->min_addend
- 0xffff)
4204 range
= bfd_zalloc (arg
->info
->output_bfd
, sizeof (*range
));
4208 range
->next
= *range_ptr
;
4209 range
->min_addend
= addend
;
4210 range
->max_addend
= addend
;
4218 /* Remember how many pages the old range contributed. */
4219 old_pages
= mips_elf_pages_for_range (range
);
4221 /* Update the ranges. */
4222 if (addend
< range
->min_addend
)
4223 range
->min_addend
= addend
;
4224 else if (addend
> range
->max_addend
)
4226 if (range
->next
&& addend
>= range
->next
->min_addend
- 0xffff)
4228 old_pages
+= mips_elf_pages_for_range (range
->next
);
4229 range
->max_addend
= range
->next
->max_addend
;
4230 range
->next
= range
->next
->next
;
4233 range
->max_addend
= addend
;
4236 /* Record any change in the total estimate. */
4237 new_pages
= mips_elf_pages_for_range (range
);
4238 if (old_pages
!= new_pages
)
4240 entry
->num_pages
+= new_pages
- old_pages
;
4241 g
->page_gotno
+= new_pages
- old_pages
;
4247 /* A htab_traverse callback for which *REFP points to a mips_got_page_ref
4248 and for which DATA points to a mips_elf_traverse_got_arg. Work out
4249 whether the page reference described by *REFP needs a GOT page entry,
4250 and record that entry in DATA->g if so. Set DATA->g to null on failure. */
4253 mips_elf_resolve_got_page_ref (void **refp
, void *data
)
4255 struct mips_got_page_ref
*ref
;
4256 struct mips_elf_traverse_got_arg
*arg
;
4257 struct mips_elf_link_hash_table
*htab
;
4261 ref
= (struct mips_got_page_ref
*) *refp
;
4262 arg
= (struct mips_elf_traverse_got_arg
*) data
;
4263 htab
= mips_elf_hash_table (arg
->info
);
4265 if (ref
->symndx
< 0)
4267 struct mips_elf_link_hash_entry
*h
;
4269 /* Global GOT_PAGEs decay to GOT_DISP and so don't need page entries. */
4271 if (!SYMBOL_REFERENCES_LOCAL (arg
->info
, &h
->root
))
4274 /* Ignore undefined symbols; we'll issue an error later if
4276 if (!((h
->root
.root
.type
== bfd_link_hash_defined
4277 || h
->root
.root
.type
== bfd_link_hash_defweak
)
4278 && h
->root
.root
.u
.def
.section
))
4281 sec
= h
->root
.root
.u
.def
.section
;
4282 addend
= h
->root
.root
.u
.def
.value
+ ref
->addend
;
4286 Elf_Internal_Sym
*isym
;
4288 /* Read in the symbol. */
4289 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
, ref
->u
.abfd
,
4297 /* Get the associated input section. */
4298 sec
= bfd_section_from_elf_index (ref
->u
.abfd
, isym
->st_shndx
);
4305 /* If this is a mergable section, work out the section and offset
4306 of the merged data. For section symbols, the addend specifies
4307 of the offset _of_ the first byte in the data, otherwise it
4308 specifies the offset _from_ the first byte. */
4309 if (sec
->flags
& SEC_MERGE
)
4313 secinfo
= elf_section_data (sec
)->sec_info
;
4314 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
4315 addend
= _bfd_merged_section_offset (ref
->u
.abfd
, &sec
, secinfo
,
4316 isym
->st_value
+ ref
->addend
);
4318 addend
= _bfd_merged_section_offset (ref
->u
.abfd
, &sec
, secinfo
,
4319 isym
->st_value
) + ref
->addend
;
4322 addend
= isym
->st_value
+ ref
->addend
;
4324 if (!mips_elf_record_got_page_entry (arg
, sec
, addend
))
4332 /* If any entries in G->got_entries are for indirect or warning symbols,
4333 replace them with entries for the target symbol. Convert g->got_page_refs
4334 into got_page_entry structures and estimate the number of page entries
4335 that they require. */
4338 mips_elf_resolve_final_got_entries (struct bfd_link_info
*info
,
4339 struct mips_got_info
*g
)
4341 struct mips_elf_traverse_got_arg tga
;
4342 struct mips_got_info oldg
;
4349 htab_traverse (g
->got_entries
, mips_elf_check_recreate_got
, &tga
);
4353 g
->got_entries
= htab_create (htab_size (oldg
.got_entries
),
4354 mips_elf_got_entry_hash
,
4355 mips_elf_got_entry_eq
, NULL
);
4356 if (!g
->got_entries
)
4359 htab_traverse (oldg
.got_entries
, mips_elf_recreate_got
, &tga
);
4363 htab_delete (oldg
.got_entries
);
4366 g
->got_page_entries
= htab_try_create (1, mips_got_page_entry_hash
,
4367 mips_got_page_entry_eq
, NULL
);
4368 if (g
->got_page_entries
== NULL
)
4373 htab_traverse (g
->got_page_refs
, mips_elf_resolve_got_page_ref
, &tga
);
4378 /* Return true if a GOT entry for H should live in the local rather than
4382 mips_use_local_got_p (struct bfd_link_info
*info
,
4383 struct mips_elf_link_hash_entry
*h
)
4385 /* Symbols that aren't in the dynamic symbol table must live in the
4386 local GOT. This includes symbols that are completely undefined
4387 and which therefore don't bind locally. We'll report undefined
4388 symbols later if appropriate. */
4389 if (h
->root
.dynindx
== -1)
4392 /* Symbols that bind locally can (and in the case of forced-local
4393 symbols, must) live in the local GOT. */
4394 if (h
->got_only_for_calls
4395 ? SYMBOL_CALLS_LOCAL (info
, &h
->root
)
4396 : SYMBOL_REFERENCES_LOCAL (info
, &h
->root
))
4399 /* If this is an executable that must provide a definition of the symbol,
4400 either though PLTs or copy relocations, then that address should go in
4401 the local rather than global GOT. */
4402 if (bfd_link_executable (info
) && h
->has_static_relocs
)
4408 /* A mips_elf_link_hash_traverse callback for which DATA points to the
4409 link_info structure. Decide whether the hash entry needs an entry in
4410 the global part of the primary GOT, setting global_got_area accordingly.
4411 Count the number of global symbols that are in the primary GOT only
4412 because they have relocations against them (reloc_only_gotno). */
4415 mips_elf_count_got_symbols (struct mips_elf_link_hash_entry
*h
, void *data
)
4417 struct bfd_link_info
*info
;
4418 struct mips_elf_link_hash_table
*htab
;
4419 struct mips_got_info
*g
;
4421 info
= (struct bfd_link_info
*) data
;
4422 htab
= mips_elf_hash_table (info
);
4424 if (h
->global_got_area
!= GGA_NONE
)
4426 /* Make a final decision about whether the symbol belongs in the
4427 local or global GOT. */
4428 if (mips_use_local_got_p (info
, h
))
4429 /* The symbol belongs in the local GOT. We no longer need this
4430 entry if it was only used for relocations; those relocations
4431 will be against the null or section symbol instead of H. */
4432 h
->global_got_area
= GGA_NONE
;
4433 else if (htab
->is_vxworks
4434 && h
->got_only_for_calls
4435 && h
->root
.plt
.plist
->mips_offset
!= MINUS_ONE
)
4436 /* On VxWorks, calls can refer directly to the .got.plt entry;
4437 they don't need entries in the regular GOT. .got.plt entries
4438 will be allocated by _bfd_mips_elf_adjust_dynamic_symbol. */
4439 h
->global_got_area
= GGA_NONE
;
4440 else if (h
->global_got_area
== GGA_RELOC_ONLY
)
4442 g
->reloc_only_gotno
++;
4449 /* A htab_traverse callback for GOT entries. Add each one to the GOT
4450 given in mips_elf_traverse_got_arg DATA. Clear DATA->G on error. */
4453 mips_elf_add_got_entry (void **entryp
, void *data
)
4455 struct mips_got_entry
*entry
;
4456 struct mips_elf_traverse_got_arg
*arg
;
4459 entry
= (struct mips_got_entry
*) *entryp
;
4460 arg
= (struct mips_elf_traverse_got_arg
*) data
;
4461 slot
= htab_find_slot (arg
->g
->got_entries
, entry
, INSERT
);
4470 mips_elf_count_got_entry (arg
->info
, arg
->g
, entry
);
4475 /* A htab_traverse callback for GOT page entries. Add each one to the GOT
4476 given in mips_elf_traverse_got_arg DATA. Clear DATA->G on error. */
4479 mips_elf_add_got_page_entry (void **entryp
, void *data
)
4481 struct mips_got_page_entry
*entry
;
4482 struct mips_elf_traverse_got_arg
*arg
;
4485 entry
= (struct mips_got_page_entry
*) *entryp
;
4486 arg
= (struct mips_elf_traverse_got_arg
*) data
;
4487 slot
= htab_find_slot (arg
->g
->got_page_entries
, entry
, INSERT
);
4496 arg
->g
->page_gotno
+= entry
->num_pages
;
4501 /* Consider merging FROM, which is ABFD's GOT, into TO. Return -1 if
4502 this would lead to overflow, 1 if they were merged successfully,
4503 and 0 if a merge failed due to lack of memory. (These values are chosen
4504 so that nonnegative return values can be returned by a htab_traverse
4508 mips_elf_merge_got_with (bfd
*abfd
, struct mips_got_info
*from
,
4509 struct mips_got_info
*to
,
4510 struct mips_elf_got_per_bfd_arg
*arg
)
4512 struct mips_elf_traverse_got_arg tga
;
4513 unsigned int estimate
;
4515 /* Work out how many page entries we would need for the combined GOT. */
4516 estimate
= arg
->max_pages
;
4517 if (estimate
>= from
->page_gotno
+ to
->page_gotno
)
4518 estimate
= from
->page_gotno
+ to
->page_gotno
;
4520 /* And conservatively estimate how many local and TLS entries
4522 estimate
+= from
->local_gotno
+ to
->local_gotno
;
4523 estimate
+= from
->tls_gotno
+ to
->tls_gotno
;
4525 /* If we're merging with the primary got, any TLS relocations will
4526 come after the full set of global entries. Otherwise estimate those
4527 conservatively as well. */
4528 if (to
== arg
->primary
&& from
->tls_gotno
+ to
->tls_gotno
)
4529 estimate
+= arg
->global_count
;
4531 estimate
+= from
->global_gotno
+ to
->global_gotno
;
4533 /* Bail out if the combined GOT might be too big. */
4534 if (estimate
> arg
->max_count
)
4537 /* Transfer the bfd's got information from FROM to TO. */
4538 tga
.info
= arg
->info
;
4540 htab_traverse (from
->got_entries
, mips_elf_add_got_entry
, &tga
);
4544 htab_traverse (from
->got_page_entries
, mips_elf_add_got_page_entry
, &tga
);
4548 mips_elf_replace_bfd_got (abfd
, to
);
4552 /* Attempt to merge GOT G, which belongs to ABFD. Try to use as much
4553 as possible of the primary got, since it doesn't require explicit
4554 dynamic relocations, but don't use bfds that would reference global
4555 symbols out of the addressable range. Failing the primary got,
4556 attempt to merge with the current got, or finish the current got
4557 and then make make the new got current. */
4560 mips_elf_merge_got (bfd
*abfd
, struct mips_got_info
*g
,
4561 struct mips_elf_got_per_bfd_arg
*arg
)
4563 unsigned int estimate
;
4566 if (!mips_elf_resolve_final_got_entries (arg
->info
, g
))
4569 /* Work out the number of page, local and TLS entries. */
4570 estimate
= arg
->max_pages
;
4571 if (estimate
> g
->page_gotno
)
4572 estimate
= g
->page_gotno
;
4573 estimate
+= g
->local_gotno
+ g
->tls_gotno
;
4575 /* We place TLS GOT entries after both locals and globals. The globals
4576 for the primary GOT may overflow the normal GOT size limit, so be
4577 sure not to merge a GOT which requires TLS with the primary GOT in that
4578 case. This doesn't affect non-primary GOTs. */
4579 estimate
+= (g
->tls_gotno
> 0 ? arg
->global_count
: g
->global_gotno
);
4581 if (estimate
<= arg
->max_count
)
4583 /* If we don't have a primary GOT, use it as
4584 a starting point for the primary GOT. */
4591 /* Try merging with the primary GOT. */
4592 result
= mips_elf_merge_got_with (abfd
, g
, arg
->primary
, arg
);
4597 /* If we can merge with the last-created got, do it. */
4600 result
= mips_elf_merge_got_with (abfd
, g
, arg
->current
, arg
);
4605 /* Well, we couldn't merge, so create a new GOT. Don't check if it
4606 fits; if it turns out that it doesn't, we'll get relocation
4607 overflows anyway. */
4608 g
->next
= arg
->current
;
4614 /* ENTRYP is a hash table entry for a mips_got_entry. Set its gotidx
4615 to GOTIDX, duplicating the entry if it has already been assigned
4616 an index in a different GOT. */
4619 mips_elf_set_gotidx (void **entryp
, long gotidx
)
4621 struct mips_got_entry
*entry
;
4623 entry
= (struct mips_got_entry
*) *entryp
;
4624 if (entry
->gotidx
> 0)
4626 struct mips_got_entry
*new_entry
;
4628 new_entry
= bfd_alloc (entry
->abfd
, sizeof (*entry
));
4632 *new_entry
= *entry
;
4633 *entryp
= new_entry
;
4636 entry
->gotidx
= gotidx
;
4640 /* Set the TLS GOT index for the GOT entry in ENTRYP. DATA points to a
4641 mips_elf_traverse_got_arg in which DATA->value is the size of one
4642 GOT entry. Set DATA->g to null on failure. */
4645 mips_elf_initialize_tls_index (void **entryp
, void *data
)
4647 struct mips_got_entry
*entry
;
4648 struct mips_elf_traverse_got_arg
*arg
;
4650 /* We're only interested in TLS symbols. */
4651 entry
= (struct mips_got_entry
*) *entryp
;
4652 if (entry
->tls_type
== GOT_TLS_NONE
)
4655 arg
= (struct mips_elf_traverse_got_arg
*) data
;
4656 if (!mips_elf_set_gotidx (entryp
, arg
->value
* arg
->g
->tls_assigned_gotno
))
4662 /* Account for the entries we've just allocated. */
4663 arg
->g
->tls_assigned_gotno
+= mips_tls_got_entries (entry
->tls_type
);
4667 /* A htab_traverse callback for GOT entries, where DATA points to a
4668 mips_elf_traverse_got_arg. Set the global_got_area of each global
4669 symbol to DATA->value. */
4672 mips_elf_set_global_got_area (void **entryp
, void *data
)
4674 struct mips_got_entry
*entry
;
4675 struct mips_elf_traverse_got_arg
*arg
;
4677 entry
= (struct mips_got_entry
*) *entryp
;
4678 arg
= (struct mips_elf_traverse_got_arg
*) data
;
4679 if (entry
->abfd
!= NULL
4680 && entry
->symndx
== -1
4681 && entry
->d
.h
->global_got_area
!= GGA_NONE
)
4682 entry
->d
.h
->global_got_area
= arg
->value
;
4686 /* A htab_traverse callback for secondary GOT entries, where DATA points
4687 to a mips_elf_traverse_got_arg. Assign GOT indices to global entries
4688 and record the number of relocations they require. DATA->value is
4689 the size of one GOT entry. Set DATA->g to null on failure. */
4692 mips_elf_set_global_gotidx (void **entryp
, void *data
)
4694 struct mips_got_entry
*entry
;
4695 struct mips_elf_traverse_got_arg
*arg
;
4697 entry
= (struct mips_got_entry
*) *entryp
;
4698 arg
= (struct mips_elf_traverse_got_arg
*) data
;
4699 if (entry
->abfd
!= NULL
4700 && entry
->symndx
== -1
4701 && entry
->d
.h
->global_got_area
!= GGA_NONE
)
4703 if (!mips_elf_set_gotidx (entryp
, arg
->value
* arg
->g
->assigned_low_gotno
))
4708 arg
->g
->assigned_low_gotno
+= 1;
4710 if (bfd_link_pic (arg
->info
)
4711 || (elf_hash_table (arg
->info
)->dynamic_sections_created
4712 && entry
->d
.h
->root
.def_dynamic
4713 && !entry
->d
.h
->root
.def_regular
))
4714 arg
->g
->relocs
+= 1;
4720 /* A htab_traverse callback for GOT entries for which DATA is the
4721 bfd_link_info. Forbid any global symbols from having traditional
4722 lazy-binding stubs. */
4725 mips_elf_forbid_lazy_stubs (void **entryp
, void *data
)
4727 struct bfd_link_info
*info
;
4728 struct mips_elf_link_hash_table
*htab
;
4729 struct mips_got_entry
*entry
;
4731 entry
= (struct mips_got_entry
*) *entryp
;
4732 info
= (struct bfd_link_info
*) data
;
4733 htab
= mips_elf_hash_table (info
);
4734 BFD_ASSERT (htab
!= NULL
);
4736 if (entry
->abfd
!= NULL
4737 && entry
->symndx
== -1
4738 && entry
->d
.h
->needs_lazy_stub
)
4740 entry
->d
.h
->needs_lazy_stub
= FALSE
;
4741 htab
->lazy_stub_count
--;
4747 /* Return the offset of an input bfd IBFD's GOT from the beginning of
4750 mips_elf_adjust_gp (bfd
*abfd
, struct mips_got_info
*g
, bfd
*ibfd
)
4755 g
= mips_elf_bfd_got (ibfd
, FALSE
);
4759 BFD_ASSERT (g
->next
);
4763 return (g
->local_gotno
+ g
->global_gotno
+ g
->tls_gotno
)
4764 * MIPS_ELF_GOT_SIZE (abfd
);
4767 /* Turn a single GOT that is too big for 16-bit addressing into
4768 a sequence of GOTs, each one 16-bit addressable. */
4771 mips_elf_multi_got (bfd
*abfd
, struct bfd_link_info
*info
,
4772 asection
*got
, bfd_size_type pages
)
4774 struct mips_elf_link_hash_table
*htab
;
4775 struct mips_elf_got_per_bfd_arg got_per_bfd_arg
;
4776 struct mips_elf_traverse_got_arg tga
;
4777 struct mips_got_info
*g
, *gg
;
4778 unsigned int assign
, needed_relocs
;
4781 dynobj
= elf_hash_table (info
)->dynobj
;
4782 htab
= mips_elf_hash_table (info
);
4783 BFD_ASSERT (htab
!= NULL
);
4787 got_per_bfd_arg
.obfd
= abfd
;
4788 got_per_bfd_arg
.info
= info
;
4789 got_per_bfd_arg
.current
= NULL
;
4790 got_per_bfd_arg
.primary
= NULL
;
4791 got_per_bfd_arg
.max_count
= ((MIPS_ELF_GOT_MAX_SIZE (info
)
4792 / MIPS_ELF_GOT_SIZE (abfd
))
4793 - htab
->reserved_gotno
);
4794 got_per_bfd_arg
.max_pages
= pages
;
4795 /* The number of globals that will be included in the primary GOT.
4796 See the calls to mips_elf_set_global_got_area below for more
4798 got_per_bfd_arg
.global_count
= g
->global_gotno
;
4800 /* Try to merge the GOTs of input bfds together, as long as they
4801 don't seem to exceed the maximum GOT size, choosing one of them
4802 to be the primary GOT. */
4803 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
4805 gg
= mips_elf_bfd_got (ibfd
, FALSE
);
4806 if (gg
&& !mips_elf_merge_got (ibfd
, gg
, &got_per_bfd_arg
))
4810 /* If we do not find any suitable primary GOT, create an empty one. */
4811 if (got_per_bfd_arg
.primary
== NULL
)
4812 g
->next
= mips_elf_create_got_info (abfd
);
4814 g
->next
= got_per_bfd_arg
.primary
;
4815 g
->next
->next
= got_per_bfd_arg
.current
;
4817 /* GG is now the master GOT, and G is the primary GOT. */
4821 /* Map the output bfd to the primary got. That's what we're going
4822 to use for bfds that use GOT16 or GOT_PAGE relocations that we
4823 didn't mark in check_relocs, and we want a quick way to find it.
4824 We can't just use gg->next because we're going to reverse the
4826 mips_elf_replace_bfd_got (abfd
, g
);
4828 /* Every symbol that is referenced in a dynamic relocation must be
4829 present in the primary GOT, so arrange for them to appear after
4830 those that are actually referenced. */
4831 gg
->reloc_only_gotno
= gg
->global_gotno
- g
->global_gotno
;
4832 g
->global_gotno
= gg
->global_gotno
;
4835 tga
.value
= GGA_RELOC_ONLY
;
4836 htab_traverse (gg
->got_entries
, mips_elf_set_global_got_area
, &tga
);
4837 tga
.value
= GGA_NORMAL
;
4838 htab_traverse (g
->got_entries
, mips_elf_set_global_got_area
, &tga
);
4840 /* Now go through the GOTs assigning them offset ranges.
4841 [assigned_low_gotno, local_gotno[ will be set to the range of local
4842 entries in each GOT. We can then compute the end of a GOT by
4843 adding local_gotno to global_gotno. We reverse the list and make
4844 it circular since then we'll be able to quickly compute the
4845 beginning of a GOT, by computing the end of its predecessor. To
4846 avoid special cases for the primary GOT, while still preserving
4847 assertions that are valid for both single- and multi-got links,
4848 we arrange for the main got struct to have the right number of
4849 global entries, but set its local_gotno such that the initial
4850 offset of the primary GOT is zero. Remember that the primary GOT
4851 will become the last item in the circular linked list, so it
4852 points back to the master GOT. */
4853 gg
->local_gotno
= -g
->global_gotno
;
4854 gg
->global_gotno
= g
->global_gotno
;
4861 struct mips_got_info
*gn
;
4863 assign
+= htab
->reserved_gotno
;
4864 g
->assigned_low_gotno
= assign
;
4865 g
->local_gotno
+= assign
;
4866 g
->local_gotno
+= (pages
< g
->page_gotno
? pages
: g
->page_gotno
);
4867 g
->assigned_high_gotno
= g
->local_gotno
- 1;
4868 assign
= g
->local_gotno
+ g
->global_gotno
+ g
->tls_gotno
;
4870 /* Take g out of the direct list, and push it onto the reversed
4871 list that gg points to. g->next is guaranteed to be nonnull after
4872 this operation, as required by mips_elf_initialize_tls_index. */
4877 /* Set up any TLS entries. We always place the TLS entries after
4878 all non-TLS entries. */
4879 g
->tls_assigned_gotno
= g
->local_gotno
+ g
->global_gotno
;
4881 tga
.value
= MIPS_ELF_GOT_SIZE (abfd
);
4882 htab_traverse (g
->got_entries
, mips_elf_initialize_tls_index
, &tga
);
4885 BFD_ASSERT (g
->tls_assigned_gotno
== assign
);
4887 /* Move onto the next GOT. It will be a secondary GOT if nonull. */
4890 /* Forbid global symbols in every non-primary GOT from having
4891 lazy-binding stubs. */
4893 htab_traverse (g
->got_entries
, mips_elf_forbid_lazy_stubs
, info
);
4897 got
->size
= assign
* MIPS_ELF_GOT_SIZE (abfd
);
4900 for (g
= gg
->next
; g
&& g
->next
!= gg
; g
= g
->next
)
4902 unsigned int save_assign
;
4904 /* Assign offsets to global GOT entries and count how many
4905 relocations they need. */
4906 save_assign
= g
->assigned_low_gotno
;
4907 g
->assigned_low_gotno
= g
->local_gotno
;
4909 tga
.value
= MIPS_ELF_GOT_SIZE (abfd
);
4911 htab_traverse (g
->got_entries
, mips_elf_set_global_gotidx
, &tga
);
4914 BFD_ASSERT (g
->assigned_low_gotno
== g
->local_gotno
+ g
->global_gotno
);
4915 g
->assigned_low_gotno
= save_assign
;
4917 if (bfd_link_pic (info
))
4919 g
->relocs
+= g
->local_gotno
- g
->assigned_low_gotno
;
4920 BFD_ASSERT (g
->assigned_low_gotno
== g
->next
->local_gotno
4921 + g
->next
->global_gotno
4922 + g
->next
->tls_gotno
4923 + htab
->reserved_gotno
);
4925 needed_relocs
+= g
->relocs
;
4927 needed_relocs
+= g
->relocs
;
4930 mips_elf_allocate_dynamic_relocations (dynobj
, info
,
4937 /* Returns the first relocation of type r_type found, beginning with
4938 RELOCATION. RELEND is one-past-the-end of the relocation table. */
4940 static const Elf_Internal_Rela
*
4941 mips_elf_next_relocation (bfd
*abfd ATTRIBUTE_UNUSED
, unsigned int r_type
,
4942 const Elf_Internal_Rela
*relocation
,
4943 const Elf_Internal_Rela
*relend
)
4945 unsigned long r_symndx
= ELF_R_SYM (abfd
, relocation
->r_info
);
4947 while (relocation
< relend
)
4949 if (ELF_R_TYPE (abfd
, relocation
->r_info
) == r_type
4950 && ELF_R_SYM (abfd
, relocation
->r_info
) == r_symndx
)
4956 /* We didn't find it. */
4960 /* Return whether an input relocation is against a local symbol. */
4963 mips_elf_local_relocation_p (bfd
*input_bfd
,
4964 const Elf_Internal_Rela
*relocation
,
4965 asection
**local_sections
)
4967 unsigned long r_symndx
;
4968 Elf_Internal_Shdr
*symtab_hdr
;
4971 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
4972 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
4973 extsymoff
= (elf_bad_symtab (input_bfd
)) ? 0 : symtab_hdr
->sh_info
;
4975 if (r_symndx
< extsymoff
)
4977 if (elf_bad_symtab (input_bfd
) && local_sections
[r_symndx
] != NULL
)
4983 /* Sign-extend VALUE, which has the indicated number of BITS. */
4986 _bfd_mips_elf_sign_extend (bfd_vma value
, int bits
)
4988 if (value
& ((bfd_vma
) 1 << (bits
- 1)))
4989 /* VALUE is negative. */
4990 value
|= ((bfd_vma
) - 1) << bits
;
4995 /* Return non-zero if the indicated VALUE has overflowed the maximum
4996 range expressible by a signed number with the indicated number of
5000 mips_elf_overflow_p (bfd_vma value
, int bits
)
5002 bfd_signed_vma svalue
= (bfd_signed_vma
) value
;
5004 if (svalue
> (1 << (bits
- 1)) - 1)
5005 /* The value is too big. */
5007 else if (svalue
< -(1 << (bits
- 1)))
5008 /* The value is too small. */
5015 /* Calculate the %high function. */
5018 mips_elf_high (bfd_vma value
)
5020 return ((value
+ (bfd_vma
) 0x8000) >> 16) & 0xffff;
5023 /* Calculate the %higher function. */
5026 mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED
)
5029 return ((value
+ (bfd_vma
) 0x80008000) >> 32) & 0xffff;
5036 /* Calculate the %highest function. */
5039 mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED
)
5042 return ((value
+ (((bfd_vma
) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
5049 /* Create the .compact_rel section. */
5052 mips_elf_create_compact_rel_section
5053 (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
5056 register asection
*s
;
5058 if (bfd_get_linker_section (abfd
, ".compact_rel") == NULL
)
5060 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
5063 s
= bfd_make_section_anyway_with_flags (abfd
, ".compact_rel", flags
);
5065 || ! bfd_set_section_alignment (abfd
, s
,
5066 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
5069 s
->size
= sizeof (Elf32_External_compact_rel
);
5075 /* Create the .got section to hold the global offset table. */
5078 mips_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
5081 register asection
*s
;
5082 struct elf_link_hash_entry
*h
;
5083 struct bfd_link_hash_entry
*bh
;
5084 struct mips_elf_link_hash_table
*htab
;
5086 htab
= mips_elf_hash_table (info
);
5087 BFD_ASSERT (htab
!= NULL
);
5089 /* This function may be called more than once. */
5093 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
5094 | SEC_LINKER_CREATED
);
5096 /* We have to use an alignment of 2**4 here because this is hardcoded
5097 in the function stub generation and in the linker script. */
5098 s
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
5100 || ! bfd_set_section_alignment (abfd
, s
, 4))
5104 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
5105 linker script because we don't want to define the symbol if we
5106 are not creating a global offset table. */
5108 if (! (_bfd_generic_link_add_one_symbol
5109 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
5110 0, NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
5113 h
= (struct elf_link_hash_entry
*) bh
;
5116 h
->type
= STT_OBJECT
;
5117 h
->other
= (h
->other
& ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN
;
5118 elf_hash_table (info
)->hgot
= h
;
5120 if (bfd_link_pic (info
)
5121 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
5124 htab
->got_info
= mips_elf_create_got_info (abfd
);
5125 mips_elf_section_data (s
)->elf
.this_hdr
.sh_flags
5126 |= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
5128 /* We also need a .got.plt section when generating PLTs. */
5129 s
= bfd_make_section_anyway_with_flags (abfd
, ".got.plt",
5130 SEC_ALLOC
| SEC_LOAD
5133 | SEC_LINKER_CREATED
);
5141 /* Return true if H refers to the special VxWorks __GOTT_BASE__ or
5142 __GOTT_INDEX__ symbols. These symbols are only special for
5143 shared objects; they are not used in executables. */
5146 is_gott_symbol (struct bfd_link_info
*info
, struct elf_link_hash_entry
*h
)
5148 return (mips_elf_hash_table (info
)->is_vxworks
5149 && bfd_link_pic (info
)
5150 && (strcmp (h
->root
.root
.string
, "__GOTT_BASE__") == 0
5151 || strcmp (h
->root
.root
.string
, "__GOTT_INDEX__") == 0));
5154 /* Return TRUE if a relocation of type R_TYPE from INPUT_BFD might
5155 require an la25 stub. See also mips_elf_local_pic_function_p,
5156 which determines whether the destination function ever requires a
5160 mips_elf_relocation_needs_la25_stub (bfd
*input_bfd
, int r_type
,
5161 bfd_boolean target_is_16_bit_code_p
)
5163 /* We specifically ignore branches and jumps from EF_PIC objects,
5164 where the onus is on the compiler or programmer to perform any
5165 necessary initialization of $25. Sometimes such initialization
5166 is unnecessary; for example, -mno-shared functions do not use
5167 the incoming value of $25, and may therefore be called directly. */
5168 if (PIC_OBJECT_P (input_bfd
))
5175 case R_MIPS_PC21_S2
:
5176 case R_MIPS_PC26_S2
:
5177 case R_MICROMIPS_26_S1
:
5178 case R_MICROMIPS_PC7_S1
:
5179 case R_MICROMIPS_PC10_S1
:
5180 case R_MICROMIPS_PC16_S1
:
5181 case R_MICROMIPS_PC23_S2
:
5185 return !target_is_16_bit_code_p
;
5192 /* Calculate the value produced by the RELOCATION (which comes from
5193 the INPUT_BFD). The ADDEND is the addend to use for this
5194 RELOCATION; RELOCATION->R_ADDEND is ignored.
5196 The result of the relocation calculation is stored in VALUEP.
5197 On exit, set *CROSS_MODE_JUMP_P to true if the relocation field
5198 is a MIPS16 or microMIPS jump to standard MIPS code, or vice versa.
5200 This function returns bfd_reloc_continue if the caller need take no
5201 further action regarding this relocation, bfd_reloc_notsupported if
5202 something goes dramatically wrong, bfd_reloc_overflow if an
5203 overflow occurs, and bfd_reloc_ok to indicate success. */
5205 static bfd_reloc_status_type
5206 mips_elf_calculate_relocation (bfd
*abfd
, bfd
*input_bfd
,
5207 asection
*input_section
,
5208 struct bfd_link_info
*info
,
5209 const Elf_Internal_Rela
*relocation
,
5210 bfd_vma addend
, reloc_howto_type
*howto
,
5211 Elf_Internal_Sym
*local_syms
,
5212 asection
**local_sections
, bfd_vma
*valuep
,
5214 bfd_boolean
*cross_mode_jump_p
,
5215 bfd_boolean save_addend
)
5217 /* The eventual value we will return. */
5219 /* The address of the symbol against which the relocation is
5222 /* The final GP value to be used for the relocatable, executable, or
5223 shared object file being produced. */
5225 /* The place (section offset or address) of the storage unit being
5228 /* The value of GP used to create the relocatable object. */
5230 /* The offset into the global offset table at which the address of
5231 the relocation entry symbol, adjusted by the addend, resides
5232 during execution. */
5233 bfd_vma g
= MINUS_ONE
;
5234 /* The section in which the symbol referenced by the relocation is
5236 asection
*sec
= NULL
;
5237 struct mips_elf_link_hash_entry
*h
= NULL
;
5238 /* TRUE if the symbol referred to by this relocation is a local
5240 bfd_boolean local_p
, was_local_p
;
5241 /* TRUE if the symbol referred to by this relocation is "_gp_disp". */
5242 bfd_boolean gp_disp_p
= FALSE
;
5243 /* TRUE if the symbol referred to by this relocation is
5244 "__gnu_local_gp". */
5245 bfd_boolean gnu_local_gp_p
= FALSE
;
5246 Elf_Internal_Shdr
*symtab_hdr
;
5248 unsigned long r_symndx
;
5250 /* TRUE if overflow occurred during the calculation of the
5251 relocation value. */
5252 bfd_boolean overflowed_p
;
5253 /* TRUE if this relocation refers to a MIPS16 function. */
5254 bfd_boolean target_is_16_bit_code_p
= FALSE
;
5255 bfd_boolean target_is_micromips_code_p
= FALSE
;
5256 struct mips_elf_link_hash_table
*htab
;
5259 dynobj
= elf_hash_table (info
)->dynobj
;
5260 htab
= mips_elf_hash_table (info
);
5261 BFD_ASSERT (htab
!= NULL
);
5263 /* Parse the relocation. */
5264 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
5265 r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
5266 p
= (input_section
->output_section
->vma
5267 + input_section
->output_offset
5268 + relocation
->r_offset
);
5270 /* Assume that there will be no overflow. */
5271 overflowed_p
= FALSE
;
5273 /* Figure out whether or not the symbol is local, and get the offset
5274 used in the array of hash table entries. */
5275 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
5276 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
5278 was_local_p
= local_p
;
5279 if (! elf_bad_symtab (input_bfd
))
5280 extsymoff
= symtab_hdr
->sh_info
;
5283 /* The symbol table does not follow the rule that local symbols
5284 must come before globals. */
5288 /* Figure out the value of the symbol. */
5291 Elf_Internal_Sym
*sym
;
5293 sym
= local_syms
+ r_symndx
;
5294 sec
= local_sections
[r_symndx
];
5296 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
5297 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
5298 || (sec
->flags
& SEC_MERGE
))
5299 symbol
+= sym
->st_value
;
5300 if ((sec
->flags
& SEC_MERGE
)
5301 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
5303 addend
= _bfd_elf_rel_local_sym (abfd
, sym
, &sec
, addend
);
5305 addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
5308 /* MIPS16/microMIPS text labels should be treated as odd. */
5309 if (ELF_ST_IS_COMPRESSED (sym
->st_other
))
5312 /* Record the name of this symbol, for our caller. */
5313 *namep
= bfd_elf_string_from_elf_section (input_bfd
,
5314 symtab_hdr
->sh_link
,
5317 *namep
= bfd_section_name (input_bfd
, sec
);
5319 target_is_16_bit_code_p
= ELF_ST_IS_MIPS16 (sym
->st_other
);
5320 target_is_micromips_code_p
= ELF_ST_IS_MICROMIPS (sym
->st_other
);
5324 /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ? */
5326 /* For global symbols we look up the symbol in the hash-table. */
5327 h
= ((struct mips_elf_link_hash_entry
*)
5328 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
]);
5329 /* Find the real hash-table entry for this symbol. */
5330 while (h
->root
.root
.type
== bfd_link_hash_indirect
5331 || h
->root
.root
.type
== bfd_link_hash_warning
)
5332 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
5334 /* Record the name of this symbol, for our caller. */
5335 *namep
= h
->root
.root
.root
.string
;
5337 /* See if this is the special _gp_disp symbol. Note that such a
5338 symbol must always be a global symbol. */
5339 if (strcmp (*namep
, "_gp_disp") == 0
5340 && ! NEWABI_P (input_bfd
))
5342 /* Relocations against _gp_disp are permitted only with
5343 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
5344 if (!hi16_reloc_p (r_type
) && !lo16_reloc_p (r_type
))
5345 return bfd_reloc_notsupported
;
5349 /* See if this is the special _gp symbol. Note that such a
5350 symbol must always be a global symbol. */
5351 else if (strcmp (*namep
, "__gnu_local_gp") == 0)
5352 gnu_local_gp_p
= TRUE
;
5355 /* If this symbol is defined, calculate its address. Note that
5356 _gp_disp is a magic symbol, always implicitly defined by the
5357 linker, so it's inappropriate to check to see whether or not
5359 else if ((h
->root
.root
.type
== bfd_link_hash_defined
5360 || h
->root
.root
.type
== bfd_link_hash_defweak
)
5361 && h
->root
.root
.u
.def
.section
)
5363 sec
= h
->root
.root
.u
.def
.section
;
5364 if (sec
->output_section
)
5365 symbol
= (h
->root
.root
.u
.def
.value
5366 + sec
->output_section
->vma
5367 + sec
->output_offset
);
5369 symbol
= h
->root
.root
.u
.def
.value
;
5371 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
5372 /* We allow relocations against undefined weak symbols, giving
5373 it the value zero, so that you can undefined weak functions
5374 and check to see if they exist by looking at their
5377 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
5378 && ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
5380 else if (strcmp (*namep
, SGI_COMPAT (input_bfd
)
5381 ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING") == 0)
5383 /* If this is a dynamic link, we should have created a
5384 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
5385 in in _bfd_mips_elf_create_dynamic_sections.
5386 Otherwise, we should define the symbol with a value of 0.
5387 FIXME: It should probably get into the symbol table
5389 BFD_ASSERT (! bfd_link_pic (info
));
5390 BFD_ASSERT (bfd_get_section_by_name (abfd
, ".dynamic") == NULL
);
5393 else if (ELF_MIPS_IS_OPTIONAL (h
->root
.other
))
5395 /* This is an optional symbol - an Irix specific extension to the
5396 ELF spec. Ignore it for now.
5397 XXX - FIXME - there is more to the spec for OPTIONAL symbols
5398 than simply ignoring them, but we do not handle this for now.
5399 For information see the "64-bit ELF Object File Specification"
5400 which is available from here:
5401 http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf */
5404 else if ((*info
->callbacks
->undefined_symbol
)
5405 (info
, h
->root
.root
.root
.string
, input_bfd
,
5406 input_section
, relocation
->r_offset
,
5407 (info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
)
5408 || ELF_ST_VISIBILITY (h
->root
.other
)))
5410 return bfd_reloc_undefined
;
5414 return bfd_reloc_notsupported
;
5417 target_is_16_bit_code_p
= ELF_ST_IS_MIPS16 (h
->root
.other
);
5418 target_is_micromips_code_p
= ELF_ST_IS_MICROMIPS (h
->root
.other
);
5421 /* If this is a reference to a 16-bit function with a stub, we need
5422 to redirect the relocation to the stub unless:
5424 (a) the relocation is for a MIPS16 JAL;
5426 (b) the relocation is for a MIPS16 PIC call, and there are no
5427 non-MIPS16 uses of the GOT slot; or
5429 (c) the section allows direct references to MIPS16 functions. */
5430 if (r_type
!= R_MIPS16_26
5431 && !bfd_link_relocatable (info
)
5433 && h
->fn_stub
!= NULL
5434 && (r_type
!= R_MIPS16_CALL16
|| h
->need_fn_stub
))
5436 && mips_elf_tdata (input_bfd
)->local_stubs
!= NULL
5437 && mips_elf_tdata (input_bfd
)->local_stubs
[r_symndx
] != NULL
))
5438 && !section_allows_mips16_refs_p (input_section
))
5440 /* This is a 32- or 64-bit call to a 16-bit function. We should
5441 have already noticed that we were going to need the
5445 sec
= mips_elf_tdata (input_bfd
)->local_stubs
[r_symndx
];
5450 BFD_ASSERT (h
->need_fn_stub
);
5453 /* If a LA25 header for the stub itself exists, point to the
5454 prepended LUI/ADDIU sequence. */
5455 sec
= h
->la25_stub
->stub_section
;
5456 value
= h
->la25_stub
->offset
;
5465 symbol
= sec
->output_section
->vma
+ sec
->output_offset
+ value
;
5466 /* The target is 16-bit, but the stub isn't. */
5467 target_is_16_bit_code_p
= FALSE
;
5469 /* If this is a MIPS16 call with a stub, that is made through the PLT or
5470 to a standard MIPS function, we need to redirect the call to the stub.
5471 Note that we specifically exclude R_MIPS16_CALL16 from this behavior;
5472 indirect calls should use an indirect stub instead. */
5473 else if (r_type
== R_MIPS16_26
&& !bfd_link_relocatable (info
)
5474 && ((h
!= NULL
&& (h
->call_stub
!= NULL
|| h
->call_fp_stub
!= NULL
))
5476 && mips_elf_tdata (input_bfd
)->local_call_stubs
!= NULL
5477 && mips_elf_tdata (input_bfd
)->local_call_stubs
[r_symndx
] != NULL
))
5478 && ((h
!= NULL
&& h
->use_plt_entry
) || !target_is_16_bit_code_p
))
5481 sec
= mips_elf_tdata (input_bfd
)->local_call_stubs
[r_symndx
];
5484 /* If both call_stub and call_fp_stub are defined, we can figure
5485 out which one to use by checking which one appears in the input
5487 if (h
->call_stub
!= NULL
&& h
->call_fp_stub
!= NULL
)
5492 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
5494 if (CALL_FP_STUB_P (bfd_get_section_name (input_bfd
, o
)))
5496 sec
= h
->call_fp_stub
;
5503 else if (h
->call_stub
!= NULL
)
5506 sec
= h
->call_fp_stub
;
5509 BFD_ASSERT (sec
->size
> 0);
5510 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
5512 /* If this is a direct call to a PIC function, redirect to the
5514 else if (h
!= NULL
&& h
->la25_stub
5515 && mips_elf_relocation_needs_la25_stub (input_bfd
, r_type
,
5516 target_is_16_bit_code_p
))
5517 symbol
= (h
->la25_stub
->stub_section
->output_section
->vma
5518 + h
->la25_stub
->stub_section
->output_offset
5519 + h
->la25_stub
->offset
);
5520 /* For direct MIPS16 and microMIPS calls make sure the compressed PLT
5521 entry is used if a standard PLT entry has also been made. In this
5522 case the symbol will have been set by mips_elf_set_plt_sym_value
5523 to point to the standard PLT entry, so redirect to the compressed
5525 else if ((r_type
== R_MIPS16_26
|| r_type
== R_MICROMIPS_26_S1
)
5526 && !bfd_link_relocatable (info
)
5529 && h
->root
.plt
.plist
->comp_offset
!= MINUS_ONE
5530 && h
->root
.plt
.plist
->mips_offset
!= MINUS_ONE
)
5532 bfd_boolean micromips_p
= MICROMIPS_P (abfd
);
5535 symbol
= (sec
->output_section
->vma
5536 + sec
->output_offset
5537 + htab
->plt_header_size
5538 + htab
->plt_mips_offset
5539 + h
->root
.plt
.plist
->comp_offset
5542 target_is_16_bit_code_p
= !micromips_p
;
5543 target_is_micromips_code_p
= micromips_p
;
5546 /* Make sure MIPS16 and microMIPS are not used together. */
5547 if ((r_type
== R_MIPS16_26
&& target_is_micromips_code_p
)
5548 || (micromips_branch_reloc_p (r_type
) && target_is_16_bit_code_p
))
5550 (*_bfd_error_handler
)
5551 (_("MIPS16 and microMIPS functions cannot call each other"));
5552 return bfd_reloc_notsupported
;
5555 /* Calls from 16-bit code to 32-bit code and vice versa require the
5556 mode change. However, we can ignore calls to undefined weak symbols,
5557 which should never be executed at runtime. This exception is important
5558 because the assembly writer may have "known" that any definition of the
5559 symbol would be 16-bit code, and that direct jumps were therefore
5561 *cross_mode_jump_p
= (!bfd_link_relocatable (info
)
5562 && !(h
&& h
->root
.root
.type
== bfd_link_hash_undefweak
)
5563 && ((r_type
== R_MIPS16_26
&& !target_is_16_bit_code_p
)
5564 || (r_type
== R_MICROMIPS_26_S1
5565 && !target_is_micromips_code_p
)
5566 || ((r_type
== R_MIPS_26
|| r_type
== R_MIPS_JALR
)
5567 && (target_is_16_bit_code_p
5568 || target_is_micromips_code_p
))));
5570 local_p
= (h
== NULL
|| mips_use_local_got_p (info
, h
));
5572 gp0
= _bfd_get_gp_value (input_bfd
);
5573 gp
= _bfd_get_gp_value (abfd
);
5575 gp
+= mips_elf_adjust_gp (abfd
, htab
->got_info
, input_bfd
);
5580 /* Global R_MIPS_GOT_PAGE/R_MICROMIPS_GOT_PAGE relocations are equivalent
5581 to R_MIPS_GOT_DISP/R_MICROMIPS_GOT_DISP. The addend is applied by the
5582 corresponding R_MIPS_GOT_OFST/R_MICROMIPS_GOT_OFST. */
5583 if (got_page_reloc_p (r_type
) && !local_p
)
5585 r_type
= (micromips_reloc_p (r_type
)
5586 ? R_MICROMIPS_GOT_DISP
: R_MIPS_GOT_DISP
);
5590 /* If we haven't already determined the GOT offset, and we're going
5591 to need it, get it now. */
5594 case R_MIPS16_CALL16
:
5595 case R_MIPS16_GOT16
:
5598 case R_MIPS_GOT_DISP
:
5599 case R_MIPS_GOT_HI16
:
5600 case R_MIPS_CALL_HI16
:
5601 case R_MIPS_GOT_LO16
:
5602 case R_MIPS_CALL_LO16
:
5603 case R_MICROMIPS_CALL16
:
5604 case R_MICROMIPS_GOT16
:
5605 case R_MICROMIPS_GOT_DISP
:
5606 case R_MICROMIPS_GOT_HI16
:
5607 case R_MICROMIPS_CALL_HI16
:
5608 case R_MICROMIPS_GOT_LO16
:
5609 case R_MICROMIPS_CALL_LO16
:
5611 case R_MIPS_TLS_GOTTPREL
:
5612 case R_MIPS_TLS_LDM
:
5613 case R_MIPS16_TLS_GD
:
5614 case R_MIPS16_TLS_GOTTPREL
:
5615 case R_MIPS16_TLS_LDM
:
5616 case R_MICROMIPS_TLS_GD
:
5617 case R_MICROMIPS_TLS_GOTTPREL
:
5618 case R_MICROMIPS_TLS_LDM
:
5619 /* Find the index into the GOT where this value is located. */
5620 if (tls_ldm_reloc_p (r_type
))
5622 g
= mips_elf_local_got_index (abfd
, input_bfd
, info
,
5623 0, 0, NULL
, r_type
);
5625 return bfd_reloc_outofrange
;
5629 /* On VxWorks, CALL relocations should refer to the .got.plt
5630 entry, which is initialized to point at the PLT stub. */
5631 if (htab
->is_vxworks
5632 && (call_hi16_reloc_p (r_type
)
5633 || call_lo16_reloc_p (r_type
)
5634 || call16_reloc_p (r_type
)))
5636 BFD_ASSERT (addend
== 0);
5637 BFD_ASSERT (h
->root
.needs_plt
);
5638 g
= mips_elf_gotplt_index (info
, &h
->root
);
5642 BFD_ASSERT (addend
== 0);
5643 g
= mips_elf_global_got_index (abfd
, info
, input_bfd
,
5645 if (!TLS_RELOC_P (r_type
)
5646 && !elf_hash_table (info
)->dynamic_sections_created
)
5647 /* This is a static link. We must initialize the GOT entry. */
5648 MIPS_ELF_PUT_WORD (dynobj
, symbol
, htab
->sgot
->contents
+ g
);
5651 else if (!htab
->is_vxworks
5652 && (call16_reloc_p (r_type
) || got16_reloc_p (r_type
)))
5653 /* The calculation below does not involve "g". */
5657 g
= mips_elf_local_got_index (abfd
, input_bfd
, info
,
5658 symbol
+ addend
, r_symndx
, h
, r_type
);
5660 return bfd_reloc_outofrange
;
5663 /* Convert GOT indices to actual offsets. */
5664 g
= mips_elf_got_offset_from_index (info
, abfd
, input_bfd
, g
);
5668 /* Relocations against the VxWorks __GOTT_BASE__ and __GOTT_INDEX__
5669 symbols are resolved by the loader. Add them to .rela.dyn. */
5670 if (h
!= NULL
&& is_gott_symbol (info
, &h
->root
))
5672 Elf_Internal_Rela outrel
;
5676 s
= mips_elf_rel_dyn_section (info
, FALSE
);
5677 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
5679 outrel
.r_offset
= (input_section
->output_section
->vma
5680 + input_section
->output_offset
5681 + relocation
->r_offset
);
5682 outrel
.r_info
= ELF32_R_INFO (h
->root
.dynindx
, r_type
);
5683 outrel
.r_addend
= addend
;
5684 bfd_elf32_swap_reloca_out (abfd
, &outrel
, loc
);
5686 /* If we've written this relocation for a readonly section,
5687 we need to set DF_TEXTREL again, so that we do not delete the
5689 if (MIPS_ELF_READONLY_SECTION (input_section
))
5690 info
->flags
|= DF_TEXTREL
;
5693 return bfd_reloc_ok
;
5696 /* Figure out what kind of relocation is being performed. */
5700 return bfd_reloc_continue
;
5703 if (howto
->partial_inplace
)
5704 addend
= _bfd_mips_elf_sign_extend (addend
, 16);
5705 value
= symbol
+ addend
;
5706 overflowed_p
= mips_elf_overflow_p (value
, 16);
5712 if ((bfd_link_pic (info
)
5713 || (htab
->root
.dynamic_sections_created
5715 && h
->root
.def_dynamic
5716 && !h
->root
.def_regular
5717 && !h
->has_static_relocs
))
5718 && r_symndx
!= STN_UNDEF
5720 || h
->root
.root
.type
!= bfd_link_hash_undefweak
5721 || ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
5722 && (input_section
->flags
& SEC_ALLOC
) != 0)
5724 /* If we're creating a shared library, then we can't know
5725 where the symbol will end up. So, we create a relocation
5726 record in the output, and leave the job up to the dynamic
5727 linker. We must do the same for executable references to
5728 shared library symbols, unless we've decided to use copy
5729 relocs or PLTs instead. */
5731 if (!mips_elf_create_dynamic_relocation (abfd
,
5739 return bfd_reloc_undefined
;
5743 if (r_type
!= R_MIPS_REL32
)
5744 value
= symbol
+ addend
;
5748 value
&= howto
->dst_mask
;
5752 value
= symbol
+ addend
- p
;
5753 value
&= howto
->dst_mask
;
5757 /* The calculation for R_MIPS16_26 is just the same as for an
5758 R_MIPS_26. It's only the storage of the relocated field into
5759 the output file that's different. That's handled in
5760 mips_elf_perform_relocation. So, we just fall through to the
5761 R_MIPS_26 case here. */
5763 case R_MICROMIPS_26_S1
:
5767 /* Make sure the target of JALX is word-aligned. Bit 0 must be
5768 the correct ISA mode selector and bit 1 must be 0. */
5769 if (*cross_mode_jump_p
&& (symbol
& 3) != (r_type
== R_MIPS_26
))
5770 return bfd_reloc_outofrange
;
5772 /* Shift is 2, unusually, for microMIPS JALX. */
5773 shift
= (!*cross_mode_jump_p
&& r_type
== R_MICROMIPS_26_S1
) ? 1 : 2;
5776 value
= addend
| ((p
+ 4) & (0xfc000000 << shift
));
5777 else if (howto
->partial_inplace
)
5778 value
= _bfd_mips_elf_sign_extend (addend
, 26 + shift
);
5781 value
= (value
+ symbol
) >> shift
;
5782 if (!was_local_p
&& h
->root
.root
.type
!= bfd_link_hash_undefweak
)
5783 overflowed_p
= (value
>> 26) != ((p
+ 4) >> (26 + shift
));
5784 value
&= howto
->dst_mask
;
5788 case R_MIPS_TLS_DTPREL_HI16
:
5789 case R_MIPS16_TLS_DTPREL_HI16
:
5790 case R_MICROMIPS_TLS_DTPREL_HI16
:
5791 value
= (mips_elf_high (addend
+ symbol
- dtprel_base (info
))
5795 case R_MIPS_TLS_DTPREL_LO16
:
5796 case R_MIPS_TLS_DTPREL32
:
5797 case R_MIPS_TLS_DTPREL64
:
5798 case R_MIPS16_TLS_DTPREL_LO16
:
5799 case R_MICROMIPS_TLS_DTPREL_LO16
:
5800 value
= (symbol
+ addend
- dtprel_base (info
)) & howto
->dst_mask
;
5803 case R_MIPS_TLS_TPREL_HI16
:
5804 case R_MIPS16_TLS_TPREL_HI16
:
5805 case R_MICROMIPS_TLS_TPREL_HI16
:
5806 value
= (mips_elf_high (addend
+ symbol
- tprel_base (info
))
5810 case R_MIPS_TLS_TPREL_LO16
:
5811 case R_MIPS_TLS_TPREL32
:
5812 case R_MIPS_TLS_TPREL64
:
5813 case R_MIPS16_TLS_TPREL_LO16
:
5814 case R_MICROMIPS_TLS_TPREL_LO16
:
5815 value
= (symbol
+ addend
- tprel_base (info
)) & howto
->dst_mask
;
5820 case R_MICROMIPS_HI16
:
5823 value
= mips_elf_high (addend
+ symbol
);
5824 value
&= howto
->dst_mask
;
5828 /* For MIPS16 ABI code we generate this sequence
5829 0: li $v0,%hi(_gp_disp)
5830 4: addiupc $v1,%lo(_gp_disp)
5834 So the offsets of hi and lo relocs are the same, but the
5835 base $pc is that used by the ADDIUPC instruction at $t9 + 4.
5836 ADDIUPC clears the low two bits of the instruction address,
5837 so the base is ($t9 + 4) & ~3. */
5838 if (r_type
== R_MIPS16_HI16
)
5839 value
= mips_elf_high (addend
+ gp
- ((p
+ 4) & ~(bfd_vma
) 0x3));
5840 /* The microMIPS .cpload sequence uses the same assembly
5841 instructions as the traditional psABI version, but the
5842 incoming $t9 has the low bit set. */
5843 else if (r_type
== R_MICROMIPS_HI16
)
5844 value
= mips_elf_high (addend
+ gp
- p
- 1);
5846 value
= mips_elf_high (addend
+ gp
- p
);
5847 overflowed_p
= mips_elf_overflow_p (value
, 16);
5853 case R_MICROMIPS_LO16
:
5854 case R_MICROMIPS_HI0_LO16
:
5856 value
= (symbol
+ addend
) & howto
->dst_mask
;
5859 /* See the comment for R_MIPS16_HI16 above for the reason
5860 for this conditional. */
5861 if (r_type
== R_MIPS16_LO16
)
5862 value
= addend
+ gp
- (p
& ~(bfd_vma
) 0x3);
5863 else if (r_type
== R_MICROMIPS_LO16
5864 || r_type
== R_MICROMIPS_HI0_LO16
)
5865 value
= addend
+ gp
- p
+ 3;
5867 value
= addend
+ gp
- p
+ 4;
5868 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
5869 for overflow. But, on, say, IRIX5, relocations against
5870 _gp_disp are normally generated from the .cpload
5871 pseudo-op. It generates code that normally looks like
5874 lui $gp,%hi(_gp_disp)
5875 addiu $gp,$gp,%lo(_gp_disp)
5878 Here $t9 holds the address of the function being called,
5879 as required by the MIPS ELF ABI. The R_MIPS_LO16
5880 relocation can easily overflow in this situation, but the
5881 R_MIPS_HI16 relocation will handle the overflow.
5882 Therefore, we consider this a bug in the MIPS ABI, and do
5883 not check for overflow here. */
5887 case R_MIPS_LITERAL
:
5888 case R_MICROMIPS_LITERAL
:
5889 /* Because we don't merge literal sections, we can handle this
5890 just like R_MIPS_GPREL16. In the long run, we should merge
5891 shared literals, and then we will need to additional work
5896 case R_MIPS16_GPREL
:
5897 /* The R_MIPS16_GPREL performs the same calculation as
5898 R_MIPS_GPREL16, but stores the relocated bits in a different
5899 order. We don't need to do anything special here; the
5900 differences are handled in mips_elf_perform_relocation. */
5901 case R_MIPS_GPREL16
:
5902 case R_MICROMIPS_GPREL7_S2
:
5903 case R_MICROMIPS_GPREL16
:
5904 /* Only sign-extend the addend if it was extracted from the
5905 instruction. If the addend was separate, leave it alone,
5906 otherwise we may lose significant bits. */
5907 if (howto
->partial_inplace
)
5908 addend
= _bfd_mips_elf_sign_extend (addend
, 16);
5909 value
= symbol
+ addend
- gp
;
5910 /* If the symbol was local, any earlier relocatable links will
5911 have adjusted its addend with the gp offset, so compensate
5912 for that now. Don't do it for symbols forced local in this
5913 link, though, since they won't have had the gp offset applied
5917 if (was_local_p
|| h
->root
.root
.type
!= bfd_link_hash_undefweak
)
5918 overflowed_p
= mips_elf_overflow_p (value
, 16);
5921 case R_MIPS16_GOT16
:
5922 case R_MIPS16_CALL16
:
5925 case R_MICROMIPS_GOT16
:
5926 case R_MICROMIPS_CALL16
:
5927 /* VxWorks does not have separate local and global semantics for
5928 R_MIPS*_GOT16; every relocation evaluates to "G". */
5929 if (!htab
->is_vxworks
&& local_p
)
5931 value
= mips_elf_got16_entry (abfd
, input_bfd
, info
,
5932 symbol
+ addend
, !was_local_p
);
5933 if (value
== MINUS_ONE
)
5934 return bfd_reloc_outofrange
;
5936 = mips_elf_got_offset_from_index (info
, abfd
, input_bfd
, value
);
5937 overflowed_p
= mips_elf_overflow_p (value
, 16);
5944 case R_MIPS_TLS_GOTTPREL
:
5945 case R_MIPS_TLS_LDM
:
5946 case R_MIPS_GOT_DISP
:
5947 case R_MIPS16_TLS_GD
:
5948 case R_MIPS16_TLS_GOTTPREL
:
5949 case R_MIPS16_TLS_LDM
:
5950 case R_MICROMIPS_TLS_GD
:
5951 case R_MICROMIPS_TLS_GOTTPREL
:
5952 case R_MICROMIPS_TLS_LDM
:
5953 case R_MICROMIPS_GOT_DISP
:
5955 overflowed_p
= mips_elf_overflow_p (value
, 16);
5958 case R_MIPS_GPREL32
:
5959 value
= (addend
+ symbol
+ gp0
- gp
);
5961 value
&= howto
->dst_mask
;
5965 case R_MIPS_GNU_REL16_S2
:
5966 if (howto
->partial_inplace
)
5967 addend
= _bfd_mips_elf_sign_extend (addend
, 18);
5969 if ((symbol
+ addend
) & 3)
5970 return bfd_reloc_outofrange
;
5972 value
= symbol
+ addend
- p
;
5973 if (was_local_p
|| h
->root
.root
.type
!= bfd_link_hash_undefweak
)
5974 overflowed_p
= mips_elf_overflow_p (value
, 18);
5975 value
>>= howto
->rightshift
;
5976 value
&= howto
->dst_mask
;
5979 case R_MIPS_PC21_S2
:
5980 if (howto
->partial_inplace
)
5981 addend
= _bfd_mips_elf_sign_extend (addend
, 23);
5983 if ((symbol
+ addend
) & 3)
5984 return bfd_reloc_outofrange
;
5986 value
= symbol
+ addend
- p
;
5987 if (was_local_p
|| h
->root
.root
.type
!= bfd_link_hash_undefweak
)
5988 overflowed_p
= mips_elf_overflow_p (value
, 23);
5989 value
>>= howto
->rightshift
;
5990 value
&= howto
->dst_mask
;
5993 case R_MIPS_PC26_S2
:
5994 if (howto
->partial_inplace
)
5995 addend
= _bfd_mips_elf_sign_extend (addend
, 28);
5997 if ((symbol
+ addend
) & 3)
5998 return bfd_reloc_outofrange
;
6000 value
= symbol
+ addend
- p
;
6001 if (was_local_p
|| h
->root
.root
.type
!= bfd_link_hash_undefweak
)
6002 overflowed_p
= mips_elf_overflow_p (value
, 28);
6003 value
>>= howto
->rightshift
;
6004 value
&= howto
->dst_mask
;
6007 case R_MIPS_PC18_S3
:
6008 if (howto
->partial_inplace
)
6009 addend
= _bfd_mips_elf_sign_extend (addend
, 21);
6011 if ((symbol
+ addend
) & 7)
6012 return bfd_reloc_outofrange
;
6014 value
= symbol
+ addend
- ((p
| 7) ^ 7);
6015 if (was_local_p
|| h
->root
.root
.type
!= bfd_link_hash_undefweak
)
6016 overflowed_p
= mips_elf_overflow_p (value
, 21);
6017 value
>>= howto
->rightshift
;
6018 value
&= howto
->dst_mask
;
6021 case R_MIPS_PC19_S2
:
6022 if (howto
->partial_inplace
)
6023 addend
= _bfd_mips_elf_sign_extend (addend
, 21);
6025 if ((symbol
+ addend
) & 3)
6026 return bfd_reloc_outofrange
;
6028 value
= symbol
+ addend
- p
;
6029 if (was_local_p
|| h
->root
.root
.type
!= bfd_link_hash_undefweak
)
6030 overflowed_p
= mips_elf_overflow_p (value
, 21);
6031 value
>>= howto
->rightshift
;
6032 value
&= howto
->dst_mask
;
6036 value
= mips_elf_high (symbol
+ addend
- p
);
6037 if (was_local_p
|| h
->root
.root
.type
!= bfd_link_hash_undefweak
)
6038 overflowed_p
= mips_elf_overflow_p (value
, 16);
6039 value
&= howto
->dst_mask
;
6043 if (howto
->partial_inplace
)
6044 addend
= _bfd_mips_elf_sign_extend (addend
, 16);
6045 value
= symbol
+ addend
- p
;
6046 value
&= howto
->dst_mask
;
6049 case R_MICROMIPS_PC7_S1
:
6050 if (howto
->partial_inplace
)
6051 addend
= _bfd_mips_elf_sign_extend (addend
, 8);
6052 value
= symbol
+ addend
- p
;
6053 if (was_local_p
|| h
->root
.root
.type
!= bfd_link_hash_undefweak
)
6054 overflowed_p
= mips_elf_overflow_p (value
, 8);
6055 value
>>= howto
->rightshift
;
6056 value
&= howto
->dst_mask
;
6059 case R_MICROMIPS_PC10_S1
:
6060 if (howto
->partial_inplace
)
6061 addend
= _bfd_mips_elf_sign_extend (addend
, 11);
6062 value
= symbol
+ addend
- p
;
6063 if (was_local_p
|| h
->root
.root
.type
!= bfd_link_hash_undefweak
)
6064 overflowed_p
= mips_elf_overflow_p (value
, 11);
6065 value
>>= howto
->rightshift
;
6066 value
&= howto
->dst_mask
;
6069 case R_MICROMIPS_PC16_S1
:
6070 if (howto
->partial_inplace
)
6071 addend
= _bfd_mips_elf_sign_extend (addend
, 17);
6072 value
= symbol
+ addend
- p
;
6073 if (was_local_p
|| h
->root
.root
.type
!= bfd_link_hash_undefweak
)
6074 overflowed_p
= mips_elf_overflow_p (value
, 17);
6075 value
>>= howto
->rightshift
;
6076 value
&= howto
->dst_mask
;
6079 case R_MICROMIPS_PC23_S2
:
6080 if (howto
->partial_inplace
)
6081 addend
= _bfd_mips_elf_sign_extend (addend
, 25);
6082 value
= symbol
+ addend
- ((p
| 3) ^ 3);
6083 if (was_local_p
|| h
->root
.root
.type
!= bfd_link_hash_undefweak
)
6084 overflowed_p
= mips_elf_overflow_p (value
, 25);
6085 value
>>= howto
->rightshift
;
6086 value
&= howto
->dst_mask
;
6089 case R_MIPS_GOT_HI16
:
6090 case R_MIPS_CALL_HI16
:
6091 case R_MICROMIPS_GOT_HI16
:
6092 case R_MICROMIPS_CALL_HI16
:
6093 /* We're allowed to handle these two relocations identically.
6094 The dynamic linker is allowed to handle the CALL relocations
6095 differently by creating a lazy evaluation stub. */
6097 value
= mips_elf_high (value
);
6098 value
&= howto
->dst_mask
;
6101 case R_MIPS_GOT_LO16
:
6102 case R_MIPS_CALL_LO16
:
6103 case R_MICROMIPS_GOT_LO16
:
6104 case R_MICROMIPS_CALL_LO16
:
6105 value
= g
& howto
->dst_mask
;
6108 case R_MIPS_GOT_PAGE
:
6109 case R_MICROMIPS_GOT_PAGE
:
6110 value
= mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, NULL
);
6111 if (value
== MINUS_ONE
)
6112 return bfd_reloc_outofrange
;
6113 value
= mips_elf_got_offset_from_index (info
, abfd
, input_bfd
, value
);
6114 overflowed_p
= mips_elf_overflow_p (value
, 16);
6117 case R_MIPS_GOT_OFST
:
6118 case R_MICROMIPS_GOT_OFST
:
6120 mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, &value
);
6123 overflowed_p
= mips_elf_overflow_p (value
, 16);
6127 case R_MICROMIPS_SUB
:
6128 value
= symbol
- addend
;
6129 value
&= howto
->dst_mask
;
6133 case R_MICROMIPS_HIGHER
:
6134 value
= mips_elf_higher (addend
+ symbol
);
6135 value
&= howto
->dst_mask
;
6138 case R_MIPS_HIGHEST
:
6139 case R_MICROMIPS_HIGHEST
:
6140 value
= mips_elf_highest (addend
+ symbol
);
6141 value
&= howto
->dst_mask
;
6144 case R_MIPS_SCN_DISP
:
6145 case R_MICROMIPS_SCN_DISP
:
6146 value
= symbol
+ addend
- sec
->output_offset
;
6147 value
&= howto
->dst_mask
;
6151 case R_MICROMIPS_JALR
:
6152 /* This relocation is only a hint. In some cases, we optimize
6153 it into a bal instruction. But we don't try to optimize
6154 when the symbol does not resolve locally. */
6155 if (h
!= NULL
&& !SYMBOL_CALLS_LOCAL (info
, &h
->root
))
6156 return bfd_reloc_continue
;
6157 value
= symbol
+ addend
;
6161 case R_MIPS_GNU_VTINHERIT
:
6162 case R_MIPS_GNU_VTENTRY
:
6163 /* We don't do anything with these at present. */
6164 return bfd_reloc_continue
;
6167 /* An unrecognized relocation type. */
6168 return bfd_reloc_notsupported
;
6171 /* Store the VALUE for our caller. */
6173 return overflowed_p
? bfd_reloc_overflow
: bfd_reloc_ok
;
6176 /* Obtain the field relocated by RELOCATION. */
6179 mips_elf_obtain_contents (reloc_howto_type
*howto
,
6180 const Elf_Internal_Rela
*relocation
,
6181 bfd
*input_bfd
, bfd_byte
*contents
)
6184 bfd_byte
*location
= contents
+ relocation
->r_offset
;
6185 unsigned int size
= bfd_get_reloc_size (howto
);
6187 /* Obtain the bytes. */
6189 x
= bfd_get (8 * size
, input_bfd
, location
);
6194 /* It has been determined that the result of the RELOCATION is the
6195 VALUE. Use HOWTO to place VALUE into the output file at the
6196 appropriate position. The SECTION is the section to which the
6198 CROSS_MODE_JUMP_P is true if the relocation field
6199 is a MIPS16 or microMIPS jump to standard MIPS code, or vice versa.
6201 Returns FALSE if anything goes wrong. */
6204 mips_elf_perform_relocation (struct bfd_link_info
*info
,
6205 reloc_howto_type
*howto
,
6206 const Elf_Internal_Rela
*relocation
,
6207 bfd_vma value
, bfd
*input_bfd
,
6208 asection
*input_section
, bfd_byte
*contents
,
6209 bfd_boolean cross_mode_jump_p
)
6213 int r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
6216 /* Figure out where the relocation is occurring. */
6217 location
= contents
+ relocation
->r_offset
;
6219 _bfd_mips_elf_reloc_unshuffle (input_bfd
, r_type
, FALSE
, location
);
6221 /* Obtain the current value. */
6222 x
= mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
);
6224 /* Clear the field we are setting. */
6225 x
&= ~howto
->dst_mask
;
6227 /* Set the field. */
6228 x
|= (value
& howto
->dst_mask
);
6230 /* If required, turn JAL into JALX. */
6231 if (cross_mode_jump_p
&& jal_reloc_p (r_type
))
6234 bfd_vma opcode
= x
>> 26;
6235 bfd_vma jalx_opcode
;
6237 /* Check to see if the opcode is already JAL or JALX. */
6238 if (r_type
== R_MIPS16_26
)
6240 ok
= ((opcode
== 0x6) || (opcode
== 0x7));
6243 else if (r_type
== R_MICROMIPS_26_S1
)
6245 ok
= ((opcode
== 0x3d) || (opcode
== 0x3c));
6250 ok
= ((opcode
== 0x3) || (opcode
== 0x1d));
6254 /* If the opcode is not JAL or JALX, there's a problem. We cannot
6255 convert J or JALS to JALX. */
6258 (*_bfd_error_handler
)
6259 (_("%B: %A+0x%lx: Unsupported jump between ISA modes; consider recompiling with interlinking enabled."),
6262 (unsigned long) relocation
->r_offset
);
6263 bfd_set_error (bfd_error_bad_value
);
6267 /* Make this the JALX opcode. */
6268 x
= (x
& ~(0x3f << 26)) | (jalx_opcode
<< 26);
6271 /* Try converting JAL to BAL and J(AL)R to B(AL), if the target is in
6273 if (!bfd_link_relocatable (info
)
6274 && !cross_mode_jump_p
6275 && ((JAL_TO_BAL_P (input_bfd
)
6276 && r_type
== R_MIPS_26
6277 && (x
>> 26) == 0x3) /* jal addr */
6278 || (JALR_TO_BAL_P (input_bfd
)
6279 && r_type
== R_MIPS_JALR
6280 && x
== 0x0320f809) /* jalr t9 */
6281 || (JR_TO_B_P (input_bfd
)
6282 && r_type
== R_MIPS_JALR
6283 && x
== 0x03200008))) /* jr t9 */
6289 addr
= (input_section
->output_section
->vma
6290 + input_section
->output_offset
6291 + relocation
->r_offset
6293 if (r_type
== R_MIPS_26
)
6294 dest
= (value
<< 2) | ((addr
>> 28) << 28);
6298 if (off
<= 0x1ffff && off
>= -0x20000)
6300 if (x
== 0x03200008) /* jr t9 */
6301 x
= 0x10000000 | (((bfd_vma
) off
>> 2) & 0xffff); /* b addr */
6303 x
= 0x04110000 | (((bfd_vma
) off
>> 2) & 0xffff); /* bal addr */
6307 /* Put the value into the output. */
6308 size
= bfd_get_reloc_size (howto
);
6310 bfd_put (8 * size
, input_bfd
, x
, location
);
6312 _bfd_mips_elf_reloc_shuffle (input_bfd
, r_type
, !bfd_link_relocatable (info
),
6318 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
6319 is the original relocation, which is now being transformed into a
6320 dynamic relocation. The ADDENDP is adjusted if necessary; the
6321 caller should store the result in place of the original addend. */
6324 mips_elf_create_dynamic_relocation (bfd
*output_bfd
,
6325 struct bfd_link_info
*info
,
6326 const Elf_Internal_Rela
*rel
,
6327 struct mips_elf_link_hash_entry
*h
,
6328 asection
*sec
, bfd_vma symbol
,
6329 bfd_vma
*addendp
, asection
*input_section
)
6331 Elf_Internal_Rela outrel
[3];
6336 bfd_boolean defined_p
;
6337 struct mips_elf_link_hash_table
*htab
;
6339 htab
= mips_elf_hash_table (info
);
6340 BFD_ASSERT (htab
!= NULL
);
6342 r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
6343 dynobj
= elf_hash_table (info
)->dynobj
;
6344 sreloc
= mips_elf_rel_dyn_section (info
, FALSE
);
6345 BFD_ASSERT (sreloc
!= NULL
);
6346 BFD_ASSERT (sreloc
->contents
!= NULL
);
6347 BFD_ASSERT (sreloc
->reloc_count
* MIPS_ELF_REL_SIZE (output_bfd
)
6350 outrel
[0].r_offset
=
6351 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[0].r_offset
);
6352 if (ABI_64_P (output_bfd
))
6354 outrel
[1].r_offset
=
6355 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[1].r_offset
);
6356 outrel
[2].r_offset
=
6357 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[2].r_offset
);
6360 if (outrel
[0].r_offset
== MINUS_ONE
)
6361 /* The relocation field has been deleted. */
6364 if (outrel
[0].r_offset
== MINUS_TWO
)
6366 /* The relocation field has been converted into a relative value of
6367 some sort. Functions like _bfd_elf_write_section_eh_frame expect
6368 the field to be fully relocated, so add in the symbol's value. */
6373 /* We must now calculate the dynamic symbol table index to use
6374 in the relocation. */
6375 if (h
!= NULL
&& ! SYMBOL_REFERENCES_LOCAL (info
, &h
->root
))
6377 BFD_ASSERT (htab
->is_vxworks
|| h
->global_got_area
!= GGA_NONE
);
6378 indx
= h
->root
.dynindx
;
6379 if (SGI_COMPAT (output_bfd
))
6380 defined_p
= h
->root
.def_regular
;
6382 /* ??? glibc's ld.so just adds the final GOT entry to the
6383 relocation field. It therefore treats relocs against
6384 defined symbols in the same way as relocs against
6385 undefined symbols. */
6390 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
6392 else if (sec
== NULL
|| sec
->owner
== NULL
)
6394 bfd_set_error (bfd_error_bad_value
);
6399 indx
= elf_section_data (sec
->output_section
)->dynindx
;
6402 asection
*osec
= htab
->root
.text_index_section
;
6403 indx
= elf_section_data (osec
)->dynindx
;
6409 /* Instead of generating a relocation using the section
6410 symbol, we may as well make it a fully relative
6411 relocation. We want to avoid generating relocations to
6412 local symbols because we used to generate them
6413 incorrectly, without adding the original symbol value,
6414 which is mandated by the ABI for section symbols. In
6415 order to give dynamic loaders and applications time to
6416 phase out the incorrect use, we refrain from emitting
6417 section-relative relocations. It's not like they're
6418 useful, after all. This should be a bit more efficient
6420 /* ??? Although this behavior is compatible with glibc's ld.so,
6421 the ABI says that relocations against STN_UNDEF should have
6422 a symbol value of 0. Irix rld honors this, so relocations
6423 against STN_UNDEF have no effect. */
6424 if (!SGI_COMPAT (output_bfd
))
6429 /* If the relocation was previously an absolute relocation and
6430 this symbol will not be referred to by the relocation, we must
6431 adjust it by the value we give it in the dynamic symbol table.
6432 Otherwise leave the job up to the dynamic linker. */
6433 if (defined_p
&& r_type
!= R_MIPS_REL32
)
6436 if (htab
->is_vxworks
)
6437 /* VxWorks uses non-relative relocations for this. */
6438 outrel
[0].r_info
= ELF32_R_INFO (indx
, R_MIPS_32
);
6440 /* The relocation is always an REL32 relocation because we don't
6441 know where the shared library will wind up at load-time. */
6442 outrel
[0].r_info
= ELF_R_INFO (output_bfd
, (unsigned long) indx
,
6445 /* For strict adherence to the ABI specification, we should
6446 generate a R_MIPS_64 relocation record by itself before the
6447 _REL32/_64 record as well, such that the addend is read in as
6448 a 64-bit value (REL32 is a 32-bit relocation, after all).
6449 However, since none of the existing ELF64 MIPS dynamic
6450 loaders seems to care, we don't waste space with these
6451 artificial relocations. If this turns out to not be true,
6452 mips_elf_allocate_dynamic_relocation() should be tweaked so
6453 as to make room for a pair of dynamic relocations per
6454 invocation if ABI_64_P, and here we should generate an
6455 additional relocation record with R_MIPS_64 by itself for a
6456 NULL symbol before this relocation record. */
6457 outrel
[1].r_info
= ELF_R_INFO (output_bfd
, 0,
6458 ABI_64_P (output_bfd
)
6461 outrel
[2].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_NONE
);
6463 /* Adjust the output offset of the relocation to reference the
6464 correct location in the output file. */
6465 outrel
[0].r_offset
+= (input_section
->output_section
->vma
6466 + input_section
->output_offset
);
6467 outrel
[1].r_offset
+= (input_section
->output_section
->vma
6468 + input_section
->output_offset
);
6469 outrel
[2].r_offset
+= (input_section
->output_section
->vma
6470 + input_section
->output_offset
);
6472 /* Put the relocation back out. We have to use the special
6473 relocation outputter in the 64-bit case since the 64-bit
6474 relocation format is non-standard. */
6475 if (ABI_64_P (output_bfd
))
6477 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
6478 (output_bfd
, &outrel
[0],
6480 + sreloc
->reloc_count
* sizeof (Elf64_Mips_External_Rel
)));
6482 else if (htab
->is_vxworks
)
6484 /* VxWorks uses RELA rather than REL dynamic relocations. */
6485 outrel
[0].r_addend
= *addendp
;
6486 bfd_elf32_swap_reloca_out
6487 (output_bfd
, &outrel
[0],
6489 + sreloc
->reloc_count
* sizeof (Elf32_External_Rela
)));
6492 bfd_elf32_swap_reloc_out
6493 (output_bfd
, &outrel
[0],
6494 (sreloc
->contents
+ sreloc
->reloc_count
* sizeof (Elf32_External_Rel
)));
6496 /* We've now added another relocation. */
6497 ++sreloc
->reloc_count
;
6499 /* Make sure the output section is writable. The dynamic linker
6500 will be writing to it. */
6501 elf_section_data (input_section
->output_section
)->this_hdr
.sh_flags
6504 /* On IRIX5, make an entry of compact relocation info. */
6505 if (IRIX_COMPAT (output_bfd
) == ict_irix5
)
6507 asection
*scpt
= bfd_get_linker_section (dynobj
, ".compact_rel");
6512 Elf32_crinfo cptrel
;
6514 mips_elf_set_cr_format (cptrel
, CRF_MIPS_LONG
);
6515 cptrel
.vaddr
= (rel
->r_offset
6516 + input_section
->output_section
->vma
6517 + input_section
->output_offset
);
6518 if (r_type
== R_MIPS_REL32
)
6519 mips_elf_set_cr_type (cptrel
, CRT_MIPS_REL32
);
6521 mips_elf_set_cr_type (cptrel
, CRT_MIPS_WORD
);
6522 mips_elf_set_cr_dist2to (cptrel
, 0);
6523 cptrel
.konst
= *addendp
;
6525 cr
= (scpt
->contents
6526 + sizeof (Elf32_External_compact_rel
));
6527 mips_elf_set_cr_relvaddr (cptrel
, 0);
6528 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
6529 ((Elf32_External_crinfo
*) cr
6530 + scpt
->reloc_count
));
6531 ++scpt
->reloc_count
;
6535 /* If we've written this relocation for a readonly section,
6536 we need to set DF_TEXTREL again, so that we do not delete the
6538 if (MIPS_ELF_READONLY_SECTION (input_section
))
6539 info
->flags
|= DF_TEXTREL
;
6544 /* Return the MACH for a MIPS e_flags value. */
6547 _bfd_elf_mips_mach (flagword flags
)
6549 switch (flags
& EF_MIPS_MACH
)
6551 case E_MIPS_MACH_3900
:
6552 return bfd_mach_mips3900
;
6554 case E_MIPS_MACH_4010
:
6555 return bfd_mach_mips4010
;
6557 case E_MIPS_MACH_4100
:
6558 return bfd_mach_mips4100
;
6560 case E_MIPS_MACH_4111
:
6561 return bfd_mach_mips4111
;
6563 case E_MIPS_MACH_4120
:
6564 return bfd_mach_mips4120
;
6566 case E_MIPS_MACH_4650
:
6567 return bfd_mach_mips4650
;
6569 case E_MIPS_MACH_5400
:
6570 return bfd_mach_mips5400
;
6572 case E_MIPS_MACH_5500
:
6573 return bfd_mach_mips5500
;
6575 case E_MIPS_MACH_5900
:
6576 return bfd_mach_mips5900
;
6578 case E_MIPS_MACH_9000
:
6579 return bfd_mach_mips9000
;
6581 case E_MIPS_MACH_SB1
:
6582 return bfd_mach_mips_sb1
;
6584 case E_MIPS_MACH_LS2E
:
6585 return bfd_mach_mips_loongson_2e
;
6587 case E_MIPS_MACH_LS2F
:
6588 return bfd_mach_mips_loongson_2f
;
6590 case E_MIPS_MACH_LS3A
:
6591 return bfd_mach_mips_loongson_3a
;
6593 case E_MIPS_MACH_OCTEON3
:
6594 return bfd_mach_mips_octeon3
;
6596 case E_MIPS_MACH_OCTEON2
:
6597 return bfd_mach_mips_octeon2
;
6599 case E_MIPS_MACH_OCTEON
:
6600 return bfd_mach_mips_octeon
;
6602 case E_MIPS_MACH_XLR
:
6603 return bfd_mach_mips_xlr
;
6606 switch (flags
& EF_MIPS_ARCH
)
6610 return bfd_mach_mips3000
;
6613 return bfd_mach_mips6000
;
6616 return bfd_mach_mips4000
;
6619 return bfd_mach_mips8000
;
6622 return bfd_mach_mips5
;
6624 case E_MIPS_ARCH_32
:
6625 return bfd_mach_mipsisa32
;
6627 case E_MIPS_ARCH_64
:
6628 return bfd_mach_mipsisa64
;
6630 case E_MIPS_ARCH_32R2
:
6631 return bfd_mach_mipsisa32r2
;
6633 case E_MIPS_ARCH_64R2
:
6634 return bfd_mach_mipsisa64r2
;
6636 case E_MIPS_ARCH_32R6
:
6637 return bfd_mach_mipsisa32r6
;
6639 case E_MIPS_ARCH_64R6
:
6640 return bfd_mach_mipsisa64r6
;
6647 /* Return printable name for ABI. */
6649 static INLINE
char *
6650 elf_mips_abi_name (bfd
*abfd
)
6654 flags
= elf_elfheader (abfd
)->e_flags
;
6655 switch (flags
& EF_MIPS_ABI
)
6658 if (ABI_N32_P (abfd
))
6660 else if (ABI_64_P (abfd
))
6664 case E_MIPS_ABI_O32
:
6666 case E_MIPS_ABI_O64
:
6668 case E_MIPS_ABI_EABI32
:
6670 case E_MIPS_ABI_EABI64
:
6673 return "unknown abi";
6677 /* MIPS ELF uses two common sections. One is the usual one, and the
6678 other is for small objects. All the small objects are kept
6679 together, and then referenced via the gp pointer, which yields
6680 faster assembler code. This is what we use for the small common
6681 section. This approach is copied from ecoff.c. */
6682 static asection mips_elf_scom_section
;
6683 static asymbol mips_elf_scom_symbol
;
6684 static asymbol
*mips_elf_scom_symbol_ptr
;
6686 /* MIPS ELF also uses an acommon section, which represents an
6687 allocated common symbol which may be overridden by a
6688 definition in a shared library. */
6689 static asection mips_elf_acom_section
;
6690 static asymbol mips_elf_acom_symbol
;
6691 static asymbol
*mips_elf_acom_symbol_ptr
;
6693 /* This is used for both the 32-bit and the 64-bit ABI. */
6696 _bfd_mips_elf_symbol_processing (bfd
*abfd
, asymbol
*asym
)
6698 elf_symbol_type
*elfsym
;
6700 /* Handle the special MIPS section numbers that a symbol may use. */
6701 elfsym
= (elf_symbol_type
*) asym
;
6702 switch (elfsym
->internal_elf_sym
.st_shndx
)
6704 case SHN_MIPS_ACOMMON
:
6705 /* This section is used in a dynamically linked executable file.
6706 It is an allocated common section. The dynamic linker can
6707 either resolve these symbols to something in a shared
6708 library, or it can just leave them here. For our purposes,
6709 we can consider these symbols to be in a new section. */
6710 if (mips_elf_acom_section
.name
== NULL
)
6712 /* Initialize the acommon section. */
6713 mips_elf_acom_section
.name
= ".acommon";
6714 mips_elf_acom_section
.flags
= SEC_ALLOC
;
6715 mips_elf_acom_section
.output_section
= &mips_elf_acom_section
;
6716 mips_elf_acom_section
.symbol
= &mips_elf_acom_symbol
;
6717 mips_elf_acom_section
.symbol_ptr_ptr
= &mips_elf_acom_symbol_ptr
;
6718 mips_elf_acom_symbol
.name
= ".acommon";
6719 mips_elf_acom_symbol
.flags
= BSF_SECTION_SYM
;
6720 mips_elf_acom_symbol
.section
= &mips_elf_acom_section
;
6721 mips_elf_acom_symbol_ptr
= &mips_elf_acom_symbol
;
6723 asym
->section
= &mips_elf_acom_section
;
6727 /* Common symbols less than the GP size are automatically
6728 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
6729 if (asym
->value
> elf_gp_size (abfd
)
6730 || ELF_ST_TYPE (elfsym
->internal_elf_sym
.st_info
) == STT_TLS
6731 || IRIX_COMPAT (abfd
) == ict_irix6
)
6734 case SHN_MIPS_SCOMMON
:
6735 if (mips_elf_scom_section
.name
== NULL
)
6737 /* Initialize the small common section. */
6738 mips_elf_scom_section
.name
= ".scommon";
6739 mips_elf_scom_section
.flags
= SEC_IS_COMMON
;
6740 mips_elf_scom_section
.output_section
= &mips_elf_scom_section
;
6741 mips_elf_scom_section
.symbol
= &mips_elf_scom_symbol
;
6742 mips_elf_scom_section
.symbol_ptr_ptr
= &mips_elf_scom_symbol_ptr
;
6743 mips_elf_scom_symbol
.name
= ".scommon";
6744 mips_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
6745 mips_elf_scom_symbol
.section
= &mips_elf_scom_section
;
6746 mips_elf_scom_symbol_ptr
= &mips_elf_scom_symbol
;
6748 asym
->section
= &mips_elf_scom_section
;
6749 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
6752 case SHN_MIPS_SUNDEFINED
:
6753 asym
->section
= bfd_und_section_ptr
;
6758 asection
*section
= bfd_get_section_by_name (abfd
, ".text");
6760 if (section
!= NULL
)
6762 asym
->section
= section
;
6763 /* MIPS_TEXT is a bit special, the address is not an offset
6764 to the base of the .text section. So substract the section
6765 base address to make it an offset. */
6766 asym
->value
-= section
->vma
;
6773 asection
*section
= bfd_get_section_by_name (abfd
, ".data");
6775 if (section
!= NULL
)
6777 asym
->section
= section
;
6778 /* MIPS_DATA is a bit special, the address is not an offset
6779 to the base of the .data section. So substract the section
6780 base address to make it an offset. */
6781 asym
->value
-= section
->vma
;
6787 /* If this is an odd-valued function symbol, assume it's a MIPS16
6788 or microMIPS one. */
6789 if (ELF_ST_TYPE (elfsym
->internal_elf_sym
.st_info
) == STT_FUNC
6790 && (asym
->value
& 1) != 0)
6793 if (MICROMIPS_P (abfd
))
6794 elfsym
->internal_elf_sym
.st_other
6795 = ELF_ST_SET_MICROMIPS (elfsym
->internal_elf_sym
.st_other
);
6797 elfsym
->internal_elf_sym
.st_other
6798 = ELF_ST_SET_MIPS16 (elfsym
->internal_elf_sym
.st_other
);
6802 /* Implement elf_backend_eh_frame_address_size. This differs from
6803 the default in the way it handles EABI64.
6805 EABI64 was originally specified as an LP64 ABI, and that is what
6806 -mabi=eabi normally gives on a 64-bit target. However, gcc has
6807 historically accepted the combination of -mabi=eabi and -mlong32,
6808 and this ILP32 variation has become semi-official over time.
6809 Both forms use elf32 and have pointer-sized FDE addresses.
6811 If an EABI object was generated by GCC 4.0 or above, it will have
6812 an empty .gcc_compiled_longXX section, where XX is the size of longs
6813 in bits. Unfortunately, ILP32 objects generated by earlier compilers
6814 have no special marking to distinguish them from LP64 objects.
6816 We don't want users of the official LP64 ABI to be punished for the
6817 existence of the ILP32 variant, but at the same time, we don't want
6818 to mistakenly interpret pre-4.0 ILP32 objects as being LP64 objects.
6819 We therefore take the following approach:
6821 - If ABFD contains a .gcc_compiled_longXX section, use it to
6822 determine the pointer size.
6824 - Otherwise check the type of the first relocation. Assume that
6825 the LP64 ABI is being used if the relocation is of type R_MIPS_64.
6829 The second check is enough to detect LP64 objects generated by pre-4.0
6830 compilers because, in the kind of output generated by those compilers,
6831 the first relocation will be associated with either a CIE personality
6832 routine or an FDE start address. Furthermore, the compilers never
6833 used a special (non-pointer) encoding for this ABI.
6835 Checking the relocation type should also be safe because there is no
6836 reason to use R_MIPS_64 in an ILP32 object. Pre-4.0 compilers never
6840 _bfd_mips_elf_eh_frame_address_size (bfd
*abfd
, asection
*sec
)
6842 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
6844 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
6846 bfd_boolean long32_p
, long64_p
;
6848 long32_p
= bfd_get_section_by_name (abfd
, ".gcc_compiled_long32") != 0;
6849 long64_p
= bfd_get_section_by_name (abfd
, ".gcc_compiled_long64") != 0;
6850 if (long32_p
&& long64_p
)
6857 if (sec
->reloc_count
> 0
6858 && elf_section_data (sec
)->relocs
!= NULL
6859 && (ELF32_R_TYPE (elf_section_data (sec
)->relocs
[0].r_info
)
6868 /* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
6869 relocations against two unnamed section symbols to resolve to the
6870 same address. For example, if we have code like:
6872 lw $4,%got_disp(.data)($gp)
6873 lw $25,%got_disp(.text)($gp)
6876 then the linker will resolve both relocations to .data and the program
6877 will jump there rather than to .text.
6879 We can work around this problem by giving names to local section symbols.
6880 This is also what the MIPSpro tools do. */
6883 _bfd_mips_elf_name_local_section_symbols (bfd
*abfd
)
6885 return SGI_COMPAT (abfd
);
6888 /* Work over a section just before writing it out. This routine is
6889 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
6890 sections that need the SHF_MIPS_GPREL flag by name; there has to be
6894 _bfd_mips_elf_section_processing (bfd
*abfd
, Elf_Internal_Shdr
*hdr
)
6896 if (hdr
->sh_type
== SHT_MIPS_REGINFO
6897 && hdr
->sh_size
> 0)
6901 BFD_ASSERT (hdr
->sh_size
== sizeof (Elf32_External_RegInfo
));
6902 BFD_ASSERT (hdr
->contents
== NULL
);
6905 hdr
->sh_offset
+ sizeof (Elf32_External_RegInfo
) - 4,
6908 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
6909 if (bfd_bwrite (buf
, 4, abfd
) != 4)
6913 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
6914 && hdr
->bfd_section
!= NULL
6915 && mips_elf_section_data (hdr
->bfd_section
) != NULL
6916 && mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
!= NULL
)
6918 bfd_byte
*contents
, *l
, *lend
;
6920 /* We stored the section contents in the tdata field in the
6921 set_section_contents routine. We save the section contents
6922 so that we don't have to read them again.
6923 At this point we know that elf_gp is set, so we can look
6924 through the section contents to see if there is an
6925 ODK_REGINFO structure. */
6927 contents
= mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
;
6929 lend
= contents
+ hdr
->sh_size
;
6930 while (l
+ sizeof (Elf_External_Options
) <= lend
)
6932 Elf_Internal_Options intopt
;
6934 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
6936 if (intopt
.size
< sizeof (Elf_External_Options
))
6938 (*_bfd_error_handler
)
6939 (_("%B: Warning: bad `%s' option size %u smaller than its header"),
6940 abfd
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
), intopt
.size
);
6943 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
6950 + sizeof (Elf_External_Options
)
6951 + (sizeof (Elf64_External_RegInfo
) - 8)),
6954 H_PUT_64 (abfd
, elf_gp (abfd
), buf
);
6955 if (bfd_bwrite (buf
, 8, abfd
) != 8)
6958 else if (intopt
.kind
== ODK_REGINFO
)
6965 + sizeof (Elf_External_Options
)
6966 + (sizeof (Elf32_External_RegInfo
) - 4)),
6969 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
6970 if (bfd_bwrite (buf
, 4, abfd
) != 4)
6977 if (hdr
->bfd_section
!= NULL
)
6979 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
6981 /* .sbss is not handled specially here because the GNU/Linux
6982 prelinker can convert .sbss from NOBITS to PROGBITS and
6983 changing it back to NOBITS breaks the binary. The entry in
6984 _bfd_mips_elf_special_sections will ensure the correct flags
6985 are set on .sbss if BFD creates it without reading it from an
6986 input file, and without special handling here the flags set
6987 on it in an input file will be followed. */
6988 if (strcmp (name
, ".sdata") == 0
6989 || strcmp (name
, ".lit8") == 0
6990 || strcmp (name
, ".lit4") == 0)
6991 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
6992 else if (strcmp (name
, ".srdata") == 0)
6993 hdr
->sh_flags
|= SHF_ALLOC
| SHF_MIPS_GPREL
;
6994 else if (strcmp (name
, ".compact_rel") == 0)
6996 else if (strcmp (name
, ".rtproc") == 0)
6998 if (hdr
->sh_addralign
!= 0 && hdr
->sh_entsize
== 0)
7000 unsigned int adjust
;
7002 adjust
= hdr
->sh_size
% hdr
->sh_addralign
;
7004 hdr
->sh_size
+= hdr
->sh_addralign
- adjust
;
7012 /* Handle a MIPS specific section when reading an object file. This
7013 is called when elfcode.h finds a section with an unknown type.
7014 This routine supports both the 32-bit and 64-bit ELF ABI.
7016 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
7020 _bfd_mips_elf_section_from_shdr (bfd
*abfd
,
7021 Elf_Internal_Shdr
*hdr
,
7027 /* There ought to be a place to keep ELF backend specific flags, but
7028 at the moment there isn't one. We just keep track of the
7029 sections by their name, instead. Fortunately, the ABI gives
7030 suggested names for all the MIPS specific sections, so we will
7031 probably get away with this. */
7032 switch (hdr
->sh_type
)
7034 case SHT_MIPS_LIBLIST
:
7035 if (strcmp (name
, ".liblist") != 0)
7039 if (strcmp (name
, ".msym") != 0)
7042 case SHT_MIPS_CONFLICT
:
7043 if (strcmp (name
, ".conflict") != 0)
7046 case SHT_MIPS_GPTAB
:
7047 if (! CONST_STRNEQ (name
, ".gptab."))
7050 case SHT_MIPS_UCODE
:
7051 if (strcmp (name
, ".ucode") != 0)
7054 case SHT_MIPS_DEBUG
:
7055 if (strcmp (name
, ".mdebug") != 0)
7057 flags
= SEC_DEBUGGING
;
7059 case SHT_MIPS_REGINFO
:
7060 if (strcmp (name
, ".reginfo") != 0
7061 || hdr
->sh_size
!= sizeof (Elf32_External_RegInfo
))
7063 flags
= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_SIZE
);
7065 case SHT_MIPS_IFACE
:
7066 if (strcmp (name
, ".MIPS.interfaces") != 0)
7069 case SHT_MIPS_CONTENT
:
7070 if (! CONST_STRNEQ (name
, ".MIPS.content"))
7073 case SHT_MIPS_OPTIONS
:
7074 if (!MIPS_ELF_OPTIONS_SECTION_NAME_P (name
))
7077 case SHT_MIPS_ABIFLAGS
:
7078 if (!MIPS_ELF_ABIFLAGS_SECTION_NAME_P (name
))
7080 flags
= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_SIZE
);
7082 case SHT_MIPS_DWARF
:
7083 if (! CONST_STRNEQ (name
, ".debug_")
7084 && ! CONST_STRNEQ (name
, ".zdebug_"))
7087 case SHT_MIPS_SYMBOL_LIB
:
7088 if (strcmp (name
, ".MIPS.symlib") != 0)
7091 case SHT_MIPS_EVENTS
:
7092 if (! CONST_STRNEQ (name
, ".MIPS.events")
7093 && ! CONST_STRNEQ (name
, ".MIPS.post_rel"))
7100 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
7105 if (! bfd_set_section_flags (abfd
, hdr
->bfd_section
,
7106 (bfd_get_section_flags (abfd
,
7112 if (hdr
->sh_type
== SHT_MIPS_ABIFLAGS
)
7114 Elf_External_ABIFlags_v0 ext
;
7116 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
,
7117 &ext
, 0, sizeof ext
))
7119 bfd_mips_elf_swap_abiflags_v0_in (abfd
, &ext
,
7120 &mips_elf_tdata (abfd
)->abiflags
);
7121 if (mips_elf_tdata (abfd
)->abiflags
.version
!= 0)
7123 mips_elf_tdata (abfd
)->abiflags_valid
= TRUE
;
7126 /* FIXME: We should record sh_info for a .gptab section. */
7128 /* For a .reginfo section, set the gp value in the tdata information
7129 from the contents of this section. We need the gp value while
7130 processing relocs, so we just get it now. The .reginfo section
7131 is not used in the 64-bit MIPS ELF ABI. */
7132 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
7134 Elf32_External_RegInfo ext
;
7137 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
,
7138 &ext
, 0, sizeof ext
))
7140 bfd_mips_elf32_swap_reginfo_in (abfd
, &ext
, &s
);
7141 elf_gp (abfd
) = s
.ri_gp_value
;
7144 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
7145 set the gp value based on what we find. We may see both
7146 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
7147 they should agree. */
7148 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
)
7150 bfd_byte
*contents
, *l
, *lend
;
7152 contents
= bfd_malloc (hdr
->sh_size
);
7153 if (contents
== NULL
)
7155 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
,
7162 lend
= contents
+ hdr
->sh_size
;
7163 while (l
+ sizeof (Elf_External_Options
) <= lend
)
7165 Elf_Internal_Options intopt
;
7167 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
7169 if (intopt
.size
< sizeof (Elf_External_Options
))
7171 (*_bfd_error_handler
)
7172 (_("%B: Warning: bad `%s' option size %u smaller than its header"),
7173 abfd
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
), intopt
.size
);
7176 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
7178 Elf64_Internal_RegInfo intreg
;
7180 bfd_mips_elf64_swap_reginfo_in
7182 ((Elf64_External_RegInfo
*)
7183 (l
+ sizeof (Elf_External_Options
))),
7185 elf_gp (abfd
) = intreg
.ri_gp_value
;
7187 else if (intopt
.kind
== ODK_REGINFO
)
7189 Elf32_RegInfo intreg
;
7191 bfd_mips_elf32_swap_reginfo_in
7193 ((Elf32_External_RegInfo
*)
7194 (l
+ sizeof (Elf_External_Options
))),
7196 elf_gp (abfd
) = intreg
.ri_gp_value
;
7206 /* Set the correct type for a MIPS ELF section. We do this by the
7207 section name, which is a hack, but ought to work. This routine is
7208 used by both the 32-bit and the 64-bit ABI. */
7211 _bfd_mips_elf_fake_sections (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*sec
)
7213 const char *name
= bfd_get_section_name (abfd
, sec
);
7215 if (strcmp (name
, ".liblist") == 0)
7217 hdr
->sh_type
= SHT_MIPS_LIBLIST
;
7218 hdr
->sh_info
= sec
->size
/ sizeof (Elf32_Lib
);
7219 /* The sh_link field is set in final_write_processing. */
7221 else if (strcmp (name
, ".conflict") == 0)
7222 hdr
->sh_type
= SHT_MIPS_CONFLICT
;
7223 else if (CONST_STRNEQ (name
, ".gptab."))
7225 hdr
->sh_type
= SHT_MIPS_GPTAB
;
7226 hdr
->sh_entsize
= sizeof (Elf32_External_gptab
);
7227 /* The sh_info field is set in final_write_processing. */
7229 else if (strcmp (name
, ".ucode") == 0)
7230 hdr
->sh_type
= SHT_MIPS_UCODE
;
7231 else if (strcmp (name
, ".mdebug") == 0)
7233 hdr
->sh_type
= SHT_MIPS_DEBUG
;
7234 /* In a shared object on IRIX 5.3, the .mdebug section has an
7235 entsize of 0. FIXME: Does this matter? */
7236 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
7237 hdr
->sh_entsize
= 0;
7239 hdr
->sh_entsize
= 1;
7241 else if (strcmp (name
, ".reginfo") == 0)
7243 hdr
->sh_type
= SHT_MIPS_REGINFO
;
7244 /* In a shared object on IRIX 5.3, the .reginfo section has an
7245 entsize of 0x18. FIXME: Does this matter? */
7246 if (SGI_COMPAT (abfd
))
7248 if ((abfd
->flags
& DYNAMIC
) != 0)
7249 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
7251 hdr
->sh_entsize
= 1;
7254 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
7256 else if (SGI_COMPAT (abfd
)
7257 && (strcmp (name
, ".hash") == 0
7258 || strcmp (name
, ".dynamic") == 0
7259 || strcmp (name
, ".dynstr") == 0))
7261 if (SGI_COMPAT (abfd
))
7262 hdr
->sh_entsize
= 0;
7264 /* This isn't how the IRIX6 linker behaves. */
7265 hdr
->sh_info
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
7268 else if (strcmp (name
, ".got") == 0
7269 || strcmp (name
, ".srdata") == 0
7270 || strcmp (name
, ".sdata") == 0
7271 || strcmp (name
, ".sbss") == 0
7272 || strcmp (name
, ".lit4") == 0
7273 || strcmp (name
, ".lit8") == 0)
7274 hdr
->sh_flags
|= SHF_MIPS_GPREL
;
7275 else if (strcmp (name
, ".MIPS.interfaces") == 0)
7277 hdr
->sh_type
= SHT_MIPS_IFACE
;
7278 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
7280 else if (CONST_STRNEQ (name
, ".MIPS.content"))
7282 hdr
->sh_type
= SHT_MIPS_CONTENT
;
7283 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
7284 /* The sh_info field is set in final_write_processing. */
7286 else if (MIPS_ELF_OPTIONS_SECTION_NAME_P (name
))
7288 hdr
->sh_type
= SHT_MIPS_OPTIONS
;
7289 hdr
->sh_entsize
= 1;
7290 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
7292 else if (CONST_STRNEQ (name
, ".MIPS.abiflags"))
7294 hdr
->sh_type
= SHT_MIPS_ABIFLAGS
;
7295 hdr
->sh_entsize
= sizeof (Elf_External_ABIFlags_v0
);
7297 else if (CONST_STRNEQ (name
, ".debug_")
7298 || CONST_STRNEQ (name
, ".zdebug_"))
7300 hdr
->sh_type
= SHT_MIPS_DWARF
;
7302 /* Irix facilities such as libexc expect a single .debug_frame
7303 per executable, the system ones have NOSTRIP set and the linker
7304 doesn't merge sections with different flags so ... */
7305 if (SGI_COMPAT (abfd
) && CONST_STRNEQ (name
, ".debug_frame"))
7306 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
7308 else if (strcmp (name
, ".MIPS.symlib") == 0)
7310 hdr
->sh_type
= SHT_MIPS_SYMBOL_LIB
;
7311 /* The sh_link and sh_info fields are set in
7312 final_write_processing. */
7314 else if (CONST_STRNEQ (name
, ".MIPS.events")
7315 || CONST_STRNEQ (name
, ".MIPS.post_rel"))
7317 hdr
->sh_type
= SHT_MIPS_EVENTS
;
7318 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
7319 /* The sh_link field is set in final_write_processing. */
7321 else if (strcmp (name
, ".msym") == 0)
7323 hdr
->sh_type
= SHT_MIPS_MSYM
;
7324 hdr
->sh_flags
|= SHF_ALLOC
;
7325 hdr
->sh_entsize
= 8;
7328 /* The generic elf_fake_sections will set up REL_HDR using the default
7329 kind of relocations. We used to set up a second header for the
7330 non-default kind of relocations here, but only NewABI would use
7331 these, and the IRIX ld doesn't like resulting empty RELA sections.
7332 Thus we create those header only on demand now. */
7337 /* Given a BFD section, try to locate the corresponding ELF section
7338 index. This is used by both the 32-bit and the 64-bit ABI.
7339 Actually, it's not clear to me that the 64-bit ABI supports these,
7340 but for non-PIC objects we will certainly want support for at least
7341 the .scommon section. */
7344 _bfd_mips_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
7345 asection
*sec
, int *retval
)
7347 if (strcmp (bfd_get_section_name (abfd
, sec
), ".scommon") == 0)
7349 *retval
= SHN_MIPS_SCOMMON
;
7352 if (strcmp (bfd_get_section_name (abfd
, sec
), ".acommon") == 0)
7354 *retval
= SHN_MIPS_ACOMMON
;
7360 /* Hook called by the linker routine which adds symbols from an object
7361 file. We must handle the special MIPS section numbers here. */
7364 _bfd_mips_elf_add_symbol_hook (bfd
*abfd
, struct bfd_link_info
*info
,
7365 Elf_Internal_Sym
*sym
, const char **namep
,
7366 flagword
*flagsp ATTRIBUTE_UNUSED
,
7367 asection
**secp
, bfd_vma
*valp
)
7369 if (SGI_COMPAT (abfd
)
7370 && (abfd
->flags
& DYNAMIC
) != 0
7371 && strcmp (*namep
, "_rld_new_interface") == 0)
7373 /* Skip IRIX5 rld entry name. */
7378 /* Shared objects may have a dynamic symbol '_gp_disp' defined as
7379 a SECTION *ABS*. This causes ld to think it can resolve _gp_disp
7380 by setting a DT_NEEDED for the shared object. Since _gp_disp is
7381 a magic symbol resolved by the linker, we ignore this bogus definition
7382 of _gp_disp. New ABI objects do not suffer from this problem so this
7383 is not done for them. */
7385 && (sym
->st_shndx
== SHN_ABS
)
7386 && (strcmp (*namep
, "_gp_disp") == 0))
7392 switch (sym
->st_shndx
)
7395 /* Common symbols less than the GP size are automatically
7396 treated as SHN_MIPS_SCOMMON symbols. */
7397 if (sym
->st_size
> elf_gp_size (abfd
)
7398 || ELF_ST_TYPE (sym
->st_info
) == STT_TLS
7399 || IRIX_COMPAT (abfd
) == ict_irix6
)
7402 case SHN_MIPS_SCOMMON
:
7403 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
7404 (*secp
)->flags
|= SEC_IS_COMMON
;
7405 *valp
= sym
->st_size
;
7409 /* This section is used in a shared object. */
7410 if (mips_elf_tdata (abfd
)->elf_text_section
== NULL
)
7412 asymbol
*elf_text_symbol
;
7413 asection
*elf_text_section
;
7414 bfd_size_type amt
= sizeof (asection
);
7416 elf_text_section
= bfd_zalloc (abfd
, amt
);
7417 if (elf_text_section
== NULL
)
7420 amt
= sizeof (asymbol
);
7421 elf_text_symbol
= bfd_zalloc (abfd
, amt
);
7422 if (elf_text_symbol
== NULL
)
7425 /* Initialize the section. */
7427 mips_elf_tdata (abfd
)->elf_text_section
= elf_text_section
;
7428 mips_elf_tdata (abfd
)->elf_text_symbol
= elf_text_symbol
;
7430 elf_text_section
->symbol
= elf_text_symbol
;
7431 elf_text_section
->symbol_ptr_ptr
= &mips_elf_tdata (abfd
)->elf_text_symbol
;
7433 elf_text_section
->name
= ".text";
7434 elf_text_section
->flags
= SEC_NO_FLAGS
;
7435 elf_text_section
->output_section
= NULL
;
7436 elf_text_section
->owner
= abfd
;
7437 elf_text_symbol
->name
= ".text";
7438 elf_text_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
7439 elf_text_symbol
->section
= elf_text_section
;
7441 /* This code used to do *secp = bfd_und_section_ptr if
7442 bfd_link_pic (info). I don't know why, and that doesn't make sense,
7443 so I took it out. */
7444 *secp
= mips_elf_tdata (abfd
)->elf_text_section
;
7447 case SHN_MIPS_ACOMMON
:
7448 /* Fall through. XXX Can we treat this as allocated data? */
7450 /* This section is used in a shared object. */
7451 if (mips_elf_tdata (abfd
)->elf_data_section
== NULL
)
7453 asymbol
*elf_data_symbol
;
7454 asection
*elf_data_section
;
7455 bfd_size_type amt
= sizeof (asection
);
7457 elf_data_section
= bfd_zalloc (abfd
, amt
);
7458 if (elf_data_section
== NULL
)
7461 amt
= sizeof (asymbol
);
7462 elf_data_symbol
= bfd_zalloc (abfd
, amt
);
7463 if (elf_data_symbol
== NULL
)
7466 /* Initialize the section. */
7468 mips_elf_tdata (abfd
)->elf_data_section
= elf_data_section
;
7469 mips_elf_tdata (abfd
)->elf_data_symbol
= elf_data_symbol
;
7471 elf_data_section
->symbol
= elf_data_symbol
;
7472 elf_data_section
->symbol_ptr_ptr
= &mips_elf_tdata (abfd
)->elf_data_symbol
;
7474 elf_data_section
->name
= ".data";
7475 elf_data_section
->flags
= SEC_NO_FLAGS
;
7476 elf_data_section
->output_section
= NULL
;
7477 elf_data_section
->owner
= abfd
;
7478 elf_data_symbol
->name
= ".data";
7479 elf_data_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
7480 elf_data_symbol
->section
= elf_data_section
;
7482 /* This code used to do *secp = bfd_und_section_ptr if
7483 bfd_link_pic (info). I don't know why, and that doesn't make sense,
7484 so I took it out. */
7485 *secp
= mips_elf_tdata (abfd
)->elf_data_section
;
7488 case SHN_MIPS_SUNDEFINED
:
7489 *secp
= bfd_und_section_ptr
;
7493 if (SGI_COMPAT (abfd
)
7494 && ! bfd_link_pic (info
)
7495 && info
->output_bfd
->xvec
== abfd
->xvec
7496 && strcmp (*namep
, "__rld_obj_head") == 0)
7498 struct elf_link_hash_entry
*h
;
7499 struct bfd_link_hash_entry
*bh
;
7501 /* Mark __rld_obj_head as dynamic. */
7503 if (! (_bfd_generic_link_add_one_symbol
7504 (info
, abfd
, *namep
, BSF_GLOBAL
, *secp
, *valp
, NULL
, FALSE
,
7505 get_elf_backend_data (abfd
)->collect
, &bh
)))
7508 h
= (struct elf_link_hash_entry
*) bh
;
7511 h
->type
= STT_OBJECT
;
7513 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
7516 mips_elf_hash_table (info
)->use_rld_obj_head
= TRUE
;
7517 mips_elf_hash_table (info
)->rld_symbol
= h
;
7520 /* If this is a mips16 text symbol, add 1 to the value to make it
7521 odd. This will cause something like .word SYM to come up with
7522 the right value when it is loaded into the PC. */
7523 if (ELF_ST_IS_COMPRESSED (sym
->st_other
))
7529 /* This hook function is called before the linker writes out a global
7530 symbol. We mark symbols as small common if appropriate. This is
7531 also where we undo the increment of the value for a mips16 symbol. */
7534 _bfd_mips_elf_link_output_symbol_hook
7535 (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
7536 const char *name ATTRIBUTE_UNUSED
, Elf_Internal_Sym
*sym
,
7537 asection
*input_sec
, struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
)
7539 /* If we see a common symbol, which implies a relocatable link, then
7540 if a symbol was small common in an input file, mark it as small
7541 common in the output file. */
7542 if (sym
->st_shndx
== SHN_COMMON
7543 && strcmp (input_sec
->name
, ".scommon") == 0)
7544 sym
->st_shndx
= SHN_MIPS_SCOMMON
;
7546 if (ELF_ST_IS_COMPRESSED (sym
->st_other
))
7547 sym
->st_value
&= ~1;
7552 /* Functions for the dynamic linker. */
7554 /* Create dynamic sections when linking against a dynamic object. */
7557 _bfd_mips_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
7559 struct elf_link_hash_entry
*h
;
7560 struct bfd_link_hash_entry
*bh
;
7562 register asection
*s
;
7563 const char * const *namep
;
7564 struct mips_elf_link_hash_table
*htab
;
7566 htab
= mips_elf_hash_table (info
);
7567 BFD_ASSERT (htab
!= NULL
);
7569 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
7570 | SEC_LINKER_CREATED
| SEC_READONLY
);
7572 /* The psABI requires a read-only .dynamic section, but the VxWorks
7574 if (!htab
->is_vxworks
)
7576 s
= bfd_get_linker_section (abfd
, ".dynamic");
7579 if (! bfd_set_section_flags (abfd
, s
, flags
))
7584 /* We need to create .got section. */
7585 if (!mips_elf_create_got_section (abfd
, info
))
7588 if (! mips_elf_rel_dyn_section (info
, TRUE
))
7591 /* Create .stub section. */
7592 s
= bfd_make_section_anyway_with_flags (abfd
,
7593 MIPS_ELF_STUB_SECTION_NAME (abfd
),
7596 || ! bfd_set_section_alignment (abfd
, s
,
7597 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
7601 if (!mips_elf_hash_table (info
)->use_rld_obj_head
7602 && bfd_link_executable (info
)
7603 && bfd_get_linker_section (abfd
, ".rld_map") == NULL
)
7605 s
= bfd_make_section_anyway_with_flags (abfd
, ".rld_map",
7606 flags
&~ (flagword
) SEC_READONLY
);
7608 || ! bfd_set_section_alignment (abfd
, s
,
7609 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
7613 /* On IRIX5, we adjust add some additional symbols and change the
7614 alignments of several sections. There is no ABI documentation
7615 indicating that this is necessary on IRIX6, nor any evidence that
7616 the linker takes such action. */
7617 if (IRIX_COMPAT (abfd
) == ict_irix5
)
7619 for (namep
= mips_elf_dynsym_rtproc_names
; *namep
!= NULL
; namep
++)
7622 if (! (_bfd_generic_link_add_one_symbol
7623 (info
, abfd
, *namep
, BSF_GLOBAL
, bfd_und_section_ptr
, 0,
7624 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
7627 h
= (struct elf_link_hash_entry
*) bh
;
7630 h
->type
= STT_SECTION
;
7632 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
7636 /* We need to create a .compact_rel section. */
7637 if (SGI_COMPAT (abfd
))
7639 if (!mips_elf_create_compact_rel_section (abfd
, info
))
7643 /* Change alignments of some sections. */
7644 s
= bfd_get_linker_section (abfd
, ".hash");
7646 (void) bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
7648 s
= bfd_get_linker_section (abfd
, ".dynsym");
7650 (void) bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
7652 s
= bfd_get_linker_section (abfd
, ".dynstr");
7654 (void) bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
7657 s
= bfd_get_section_by_name (abfd
, ".reginfo");
7659 (void) bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
7661 s
= bfd_get_linker_section (abfd
, ".dynamic");
7663 (void) bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
7666 if (bfd_link_executable (info
))
7670 name
= SGI_COMPAT (abfd
) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
7672 if (!(_bfd_generic_link_add_one_symbol
7673 (info
, abfd
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
, 0,
7674 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
7677 h
= (struct elf_link_hash_entry
*) bh
;
7680 h
->type
= STT_SECTION
;
7682 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
7685 if (! mips_elf_hash_table (info
)->use_rld_obj_head
)
7687 /* __rld_map is a four byte word located in the .data section
7688 and is filled in by the rtld to contain a pointer to
7689 the _r_debug structure. Its symbol value will be set in
7690 _bfd_mips_elf_finish_dynamic_symbol. */
7691 s
= bfd_get_linker_section (abfd
, ".rld_map");
7692 BFD_ASSERT (s
!= NULL
);
7694 name
= SGI_COMPAT (abfd
) ? "__rld_map" : "__RLD_MAP";
7696 if (!(_bfd_generic_link_add_one_symbol
7697 (info
, abfd
, name
, BSF_GLOBAL
, s
, 0, NULL
, FALSE
,
7698 get_elf_backend_data (abfd
)->collect
, &bh
)))
7701 h
= (struct elf_link_hash_entry
*) bh
;
7704 h
->type
= STT_OBJECT
;
7706 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
7708 mips_elf_hash_table (info
)->rld_symbol
= h
;
7712 /* Create the .plt, .rel(a).plt, .dynbss and .rel(a).bss sections.
7713 Also, on VxWorks, create the _PROCEDURE_LINKAGE_TABLE_ symbol. */
7714 if (!_bfd_elf_create_dynamic_sections (abfd
, info
))
7717 /* Cache the sections created above. */
7718 htab
->splt
= bfd_get_linker_section (abfd
, ".plt");
7719 htab
->sdynbss
= bfd_get_linker_section (abfd
, ".dynbss");
7720 if (htab
->is_vxworks
)
7722 htab
->srelbss
= bfd_get_linker_section (abfd
, ".rela.bss");
7723 htab
->srelplt
= bfd_get_linker_section (abfd
, ".rela.plt");
7726 htab
->srelplt
= bfd_get_linker_section (abfd
, ".rel.plt");
7728 || (htab
->is_vxworks
&& !htab
->srelbss
&& !bfd_link_pic (info
))
7733 /* Do the usual VxWorks handling. */
7734 if (htab
->is_vxworks
7735 && !elf_vxworks_create_dynamic_sections (abfd
, info
, &htab
->srelplt2
))
7741 /* Return true if relocation REL against section SEC is a REL rather than
7742 RELA relocation. RELOCS is the first relocation in the section and
7743 ABFD is the bfd that contains SEC. */
7746 mips_elf_rel_relocation_p (bfd
*abfd
, asection
*sec
,
7747 const Elf_Internal_Rela
*relocs
,
7748 const Elf_Internal_Rela
*rel
)
7750 Elf_Internal_Shdr
*rel_hdr
;
7751 const struct elf_backend_data
*bed
;
7753 /* To determine which flavor of relocation this is, we depend on the
7754 fact that the INPUT_SECTION's REL_HDR is read before RELA_HDR. */
7755 rel_hdr
= elf_section_data (sec
)->rel
.hdr
;
7756 if (rel_hdr
== NULL
)
7758 bed
= get_elf_backend_data (abfd
);
7759 return ((size_t) (rel
- relocs
)
7760 < NUM_SHDR_ENTRIES (rel_hdr
) * bed
->s
->int_rels_per_ext_rel
);
7763 /* Read the addend for REL relocation REL, which belongs to bfd ABFD.
7764 HOWTO is the relocation's howto and CONTENTS points to the contents
7765 of the section that REL is against. */
7768 mips_elf_read_rel_addend (bfd
*abfd
, const Elf_Internal_Rela
*rel
,
7769 reloc_howto_type
*howto
, bfd_byte
*contents
)
7772 unsigned int r_type
;
7775 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
7776 location
= contents
+ rel
->r_offset
;
7778 /* Get the addend, which is stored in the input file. */
7779 _bfd_mips_elf_reloc_unshuffle (abfd
, r_type
, FALSE
, location
);
7780 addend
= mips_elf_obtain_contents (howto
, rel
, abfd
, contents
);
7781 _bfd_mips_elf_reloc_shuffle (abfd
, r_type
, FALSE
, location
);
7783 return addend
& howto
->src_mask
;
7786 /* REL is a relocation in ABFD that needs a partnering LO16 relocation
7787 and *ADDEND is the addend for REL itself. Look for the LO16 relocation
7788 and update *ADDEND with the final addend. Return true on success
7789 or false if the LO16 could not be found. RELEND is the exclusive
7790 upper bound on the relocations for REL's section. */
7793 mips_elf_add_lo16_rel_addend (bfd
*abfd
,
7794 const Elf_Internal_Rela
*rel
,
7795 const Elf_Internal_Rela
*relend
,
7796 bfd_byte
*contents
, bfd_vma
*addend
)
7798 unsigned int r_type
, lo16_type
;
7799 const Elf_Internal_Rela
*lo16_relocation
;
7800 reloc_howto_type
*lo16_howto
;
7803 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
7804 if (mips16_reloc_p (r_type
))
7805 lo16_type
= R_MIPS16_LO16
;
7806 else if (micromips_reloc_p (r_type
))
7807 lo16_type
= R_MICROMIPS_LO16
;
7808 else if (r_type
== R_MIPS_PCHI16
)
7809 lo16_type
= R_MIPS_PCLO16
;
7811 lo16_type
= R_MIPS_LO16
;
7813 /* The combined value is the sum of the HI16 addend, left-shifted by
7814 sixteen bits, and the LO16 addend, sign extended. (Usually, the
7815 code does a `lui' of the HI16 value, and then an `addiu' of the
7818 Scan ahead to find a matching LO16 relocation.
7820 According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must
7821 be immediately following. However, for the IRIX6 ABI, the next
7822 relocation may be a composed relocation consisting of several
7823 relocations for the same address. In that case, the R_MIPS_LO16
7824 relocation may occur as one of these. We permit a similar
7825 extension in general, as that is useful for GCC.
7827 In some cases GCC dead code elimination removes the LO16 but keeps
7828 the corresponding HI16. This is strictly speaking a violation of
7829 the ABI but not immediately harmful. */
7830 lo16_relocation
= mips_elf_next_relocation (abfd
, lo16_type
, rel
, relend
);
7831 if (lo16_relocation
== NULL
)
7834 /* Obtain the addend kept there. */
7835 lo16_howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, lo16_type
, FALSE
);
7836 l
= mips_elf_read_rel_addend (abfd
, lo16_relocation
, lo16_howto
, contents
);
7838 l
<<= lo16_howto
->rightshift
;
7839 l
= _bfd_mips_elf_sign_extend (l
, 16);
7846 /* Try to read the contents of section SEC in bfd ABFD. Return true and
7847 store the contents in *CONTENTS on success. Assume that *CONTENTS
7848 already holds the contents if it is nonull on entry. */
7851 mips_elf_get_section_contents (bfd
*abfd
, asection
*sec
, bfd_byte
**contents
)
7856 /* Get cached copy if it exists. */
7857 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
7859 *contents
= elf_section_data (sec
)->this_hdr
.contents
;
7863 return bfd_malloc_and_get_section (abfd
, sec
, contents
);
7866 /* Make a new PLT record to keep internal data. */
7868 static struct plt_entry
*
7869 mips_elf_make_plt_record (bfd
*abfd
)
7871 struct plt_entry
*entry
;
7873 entry
= bfd_zalloc (abfd
, sizeof (*entry
));
7877 entry
->stub_offset
= MINUS_ONE
;
7878 entry
->mips_offset
= MINUS_ONE
;
7879 entry
->comp_offset
= MINUS_ONE
;
7880 entry
->gotplt_index
= MINUS_ONE
;
7884 /* Look through the relocs for a section during the first phase, and
7885 allocate space in the global offset table and record the need for
7886 standard MIPS and compressed procedure linkage table entries. */
7889 _bfd_mips_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
7890 asection
*sec
, const Elf_Internal_Rela
*relocs
)
7894 Elf_Internal_Shdr
*symtab_hdr
;
7895 struct elf_link_hash_entry
**sym_hashes
;
7897 const Elf_Internal_Rela
*rel
;
7898 const Elf_Internal_Rela
*rel_end
;
7900 const struct elf_backend_data
*bed
;
7901 struct mips_elf_link_hash_table
*htab
;
7904 reloc_howto_type
*howto
;
7906 if (bfd_link_relocatable (info
))
7909 htab
= mips_elf_hash_table (info
);
7910 BFD_ASSERT (htab
!= NULL
);
7912 dynobj
= elf_hash_table (info
)->dynobj
;
7913 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7914 sym_hashes
= elf_sym_hashes (abfd
);
7915 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
7917 bed
= get_elf_backend_data (abfd
);
7918 rel_end
= relocs
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
7920 /* Check for the mips16 stub sections. */
7922 name
= bfd_get_section_name (abfd
, sec
);
7923 if (FN_STUB_P (name
))
7925 unsigned long r_symndx
;
7927 /* Look at the relocation information to figure out which symbol
7930 r_symndx
= mips16_stub_symndx (bed
, sec
, relocs
, rel_end
);
7933 (*_bfd_error_handler
)
7934 (_("%B: Warning: cannot determine the target function for"
7935 " stub section `%s'"),
7937 bfd_set_error (bfd_error_bad_value
);
7941 if (r_symndx
< extsymoff
7942 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
7946 /* This stub is for a local symbol. This stub will only be
7947 needed if there is some relocation in this BFD, other
7948 than a 16 bit function call, which refers to this symbol. */
7949 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
7951 Elf_Internal_Rela
*sec_relocs
;
7952 const Elf_Internal_Rela
*r
, *rend
;
7954 /* We can ignore stub sections when looking for relocs. */
7955 if ((o
->flags
& SEC_RELOC
) == 0
7956 || o
->reloc_count
== 0
7957 || section_allows_mips16_refs_p (o
))
7961 = _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
7963 if (sec_relocs
== NULL
)
7966 rend
= sec_relocs
+ o
->reloc_count
;
7967 for (r
= sec_relocs
; r
< rend
; r
++)
7968 if (ELF_R_SYM (abfd
, r
->r_info
) == r_symndx
7969 && !mips16_call_reloc_p (ELF_R_TYPE (abfd
, r
->r_info
)))
7972 if (elf_section_data (o
)->relocs
!= sec_relocs
)
7981 /* There is no non-call reloc for this stub, so we do
7982 not need it. Since this function is called before
7983 the linker maps input sections to output sections, we
7984 can easily discard it by setting the SEC_EXCLUDE
7986 sec
->flags
|= SEC_EXCLUDE
;
7990 /* Record this stub in an array of local symbol stubs for
7992 if (mips_elf_tdata (abfd
)->local_stubs
== NULL
)
7994 unsigned long symcount
;
7998 if (elf_bad_symtab (abfd
))
7999 symcount
= NUM_SHDR_ENTRIES (symtab_hdr
);
8001 symcount
= symtab_hdr
->sh_info
;
8002 amt
= symcount
* sizeof (asection
*);
8003 n
= bfd_zalloc (abfd
, amt
);
8006 mips_elf_tdata (abfd
)->local_stubs
= n
;
8009 sec
->flags
|= SEC_KEEP
;
8010 mips_elf_tdata (abfd
)->local_stubs
[r_symndx
] = sec
;
8012 /* We don't need to set mips16_stubs_seen in this case.
8013 That flag is used to see whether we need to look through
8014 the global symbol table for stubs. We don't need to set
8015 it here, because we just have a local stub. */
8019 struct mips_elf_link_hash_entry
*h
;
8021 h
= ((struct mips_elf_link_hash_entry
*)
8022 sym_hashes
[r_symndx
- extsymoff
]);
8024 while (h
->root
.root
.type
== bfd_link_hash_indirect
8025 || h
->root
.root
.type
== bfd_link_hash_warning
)
8026 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
8028 /* H is the symbol this stub is for. */
8030 /* If we already have an appropriate stub for this function, we
8031 don't need another one, so we can discard this one. Since
8032 this function is called before the linker maps input sections
8033 to output sections, we can easily discard it by setting the
8034 SEC_EXCLUDE flag. */
8035 if (h
->fn_stub
!= NULL
)
8037 sec
->flags
|= SEC_EXCLUDE
;
8041 sec
->flags
|= SEC_KEEP
;
8043 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
8046 else if (CALL_STUB_P (name
) || CALL_FP_STUB_P (name
))
8048 unsigned long r_symndx
;
8049 struct mips_elf_link_hash_entry
*h
;
8052 /* Look at the relocation information to figure out which symbol
8055 r_symndx
= mips16_stub_symndx (bed
, sec
, relocs
, rel_end
);
8058 (*_bfd_error_handler
)
8059 (_("%B: Warning: cannot determine the target function for"
8060 " stub section `%s'"),
8062 bfd_set_error (bfd_error_bad_value
);
8066 if (r_symndx
< extsymoff
8067 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
8071 /* This stub is for a local symbol. This stub will only be
8072 needed if there is some relocation (R_MIPS16_26) in this BFD
8073 that refers to this symbol. */
8074 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
8076 Elf_Internal_Rela
*sec_relocs
;
8077 const Elf_Internal_Rela
*r
, *rend
;
8079 /* We can ignore stub sections when looking for relocs. */
8080 if ((o
->flags
& SEC_RELOC
) == 0
8081 || o
->reloc_count
== 0
8082 || section_allows_mips16_refs_p (o
))
8086 = _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
8088 if (sec_relocs
== NULL
)
8091 rend
= sec_relocs
+ o
->reloc_count
;
8092 for (r
= sec_relocs
; r
< rend
; r
++)
8093 if (ELF_R_SYM (abfd
, r
->r_info
) == r_symndx
8094 && ELF_R_TYPE (abfd
, r
->r_info
) == R_MIPS16_26
)
8097 if (elf_section_data (o
)->relocs
!= sec_relocs
)
8106 /* There is no non-call reloc for this stub, so we do
8107 not need it. Since this function is called before
8108 the linker maps input sections to output sections, we
8109 can easily discard it by setting the SEC_EXCLUDE
8111 sec
->flags
|= SEC_EXCLUDE
;
8115 /* Record this stub in an array of local symbol call_stubs for
8117 if (mips_elf_tdata (abfd
)->local_call_stubs
== NULL
)
8119 unsigned long symcount
;
8123 if (elf_bad_symtab (abfd
))
8124 symcount
= NUM_SHDR_ENTRIES (symtab_hdr
);
8126 symcount
= symtab_hdr
->sh_info
;
8127 amt
= symcount
* sizeof (asection
*);
8128 n
= bfd_zalloc (abfd
, amt
);
8131 mips_elf_tdata (abfd
)->local_call_stubs
= n
;
8134 sec
->flags
|= SEC_KEEP
;
8135 mips_elf_tdata (abfd
)->local_call_stubs
[r_symndx
] = sec
;
8137 /* We don't need to set mips16_stubs_seen in this case.
8138 That flag is used to see whether we need to look through
8139 the global symbol table for stubs. We don't need to set
8140 it here, because we just have a local stub. */
8144 h
= ((struct mips_elf_link_hash_entry
*)
8145 sym_hashes
[r_symndx
- extsymoff
]);
8147 /* H is the symbol this stub is for. */
8149 if (CALL_FP_STUB_P (name
))
8150 loc
= &h
->call_fp_stub
;
8152 loc
= &h
->call_stub
;
8154 /* If we already have an appropriate stub for this function, we
8155 don't need another one, so we can discard this one. Since
8156 this function is called before the linker maps input sections
8157 to output sections, we can easily discard it by setting the
8158 SEC_EXCLUDE flag. */
8161 sec
->flags
|= SEC_EXCLUDE
;
8165 sec
->flags
|= SEC_KEEP
;
8167 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
8173 for (rel
= relocs
; rel
< rel_end
; ++rel
)
8175 unsigned long r_symndx
;
8176 unsigned int r_type
;
8177 struct elf_link_hash_entry
*h
;
8178 bfd_boolean can_make_dynamic_p
;
8179 bfd_boolean call_reloc_p
;
8180 bfd_boolean constrain_symbol_p
;
8182 r_symndx
= ELF_R_SYM (abfd
, rel
->r_info
);
8183 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
8185 if (r_symndx
< extsymoff
)
8187 else if (r_symndx
>= extsymoff
+ NUM_SHDR_ENTRIES (symtab_hdr
))
8189 (*_bfd_error_handler
)
8190 (_("%B: Malformed reloc detected for section %s"),
8192 bfd_set_error (bfd_error_bad_value
);
8197 h
= sym_hashes
[r_symndx
- extsymoff
];
8200 while (h
->root
.type
== bfd_link_hash_indirect
8201 || h
->root
.type
== bfd_link_hash_warning
)
8202 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
8204 /* PR15323, ref flags aren't set for references in the
8206 h
->root
.non_ir_ref
= 1;
8210 /* Set CAN_MAKE_DYNAMIC_P to true if we can convert this
8211 relocation into a dynamic one. */
8212 can_make_dynamic_p
= FALSE
;
8214 /* Set CALL_RELOC_P to true if the relocation is for a call,
8215 and if pointer equality therefore doesn't matter. */
8216 call_reloc_p
= FALSE
;
8218 /* Set CONSTRAIN_SYMBOL_P if we need to take the relocation
8219 into account when deciding how to define the symbol.
8220 Relocations in nonallocatable sections such as .pdr and
8221 .debug* should have no effect. */
8222 constrain_symbol_p
= ((sec
->flags
& SEC_ALLOC
) != 0);
8227 case R_MIPS_CALL_HI16
:
8228 case R_MIPS_CALL_LO16
:
8229 case R_MIPS16_CALL16
:
8230 case R_MICROMIPS_CALL16
:
8231 case R_MICROMIPS_CALL_HI16
:
8232 case R_MICROMIPS_CALL_LO16
:
8233 call_reloc_p
= TRUE
;
8237 case R_MIPS_GOT_HI16
:
8238 case R_MIPS_GOT_LO16
:
8239 case R_MIPS_GOT_PAGE
:
8240 case R_MIPS_GOT_OFST
:
8241 case R_MIPS_GOT_DISP
:
8242 case R_MIPS_TLS_GOTTPREL
:
8244 case R_MIPS_TLS_LDM
:
8245 case R_MIPS16_GOT16
:
8246 case R_MIPS16_TLS_GOTTPREL
:
8247 case R_MIPS16_TLS_GD
:
8248 case R_MIPS16_TLS_LDM
:
8249 case R_MICROMIPS_GOT16
:
8250 case R_MICROMIPS_GOT_HI16
:
8251 case R_MICROMIPS_GOT_LO16
:
8252 case R_MICROMIPS_GOT_PAGE
:
8253 case R_MICROMIPS_GOT_OFST
:
8254 case R_MICROMIPS_GOT_DISP
:
8255 case R_MICROMIPS_TLS_GOTTPREL
:
8256 case R_MICROMIPS_TLS_GD
:
8257 case R_MICROMIPS_TLS_LDM
:
8259 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
8260 if (!mips_elf_create_got_section (dynobj
, info
))
8262 if (htab
->is_vxworks
&& !bfd_link_pic (info
))
8264 (*_bfd_error_handler
)
8265 (_("%B: GOT reloc at 0x%lx not expected in executables"),
8266 abfd
, (unsigned long) rel
->r_offset
);
8267 bfd_set_error (bfd_error_bad_value
);
8270 can_make_dynamic_p
= TRUE
;
8275 case R_MICROMIPS_JALR
:
8276 /* These relocations have empty fields and are purely there to
8277 provide link information. The symbol value doesn't matter. */
8278 constrain_symbol_p
= FALSE
;
8281 case R_MIPS_GPREL16
:
8282 case R_MIPS_GPREL32
:
8283 case R_MIPS16_GPREL
:
8284 case R_MICROMIPS_GPREL16
:
8285 /* GP-relative relocations always resolve to a definition in a
8286 regular input file, ignoring the one-definition rule. This is
8287 important for the GP setup sequence in NewABI code, which
8288 always resolves to a local function even if other relocations
8289 against the symbol wouldn't. */
8290 constrain_symbol_p
= FALSE
;
8296 /* In VxWorks executables, references to external symbols
8297 must be handled using copy relocs or PLT entries; it is not
8298 possible to convert this relocation into a dynamic one.
8300 For executables that use PLTs and copy-relocs, we have a
8301 choice between converting the relocation into a dynamic
8302 one or using copy relocations or PLT entries. It is
8303 usually better to do the former, unless the relocation is
8304 against a read-only section. */
8305 if ((bfd_link_pic (info
)
8307 && !htab
->is_vxworks
8308 && strcmp (h
->root
.root
.string
, "__gnu_local_gp") != 0
8309 && !(!info
->nocopyreloc
8310 && !PIC_OBJECT_P (abfd
)
8311 && MIPS_ELF_READONLY_SECTION (sec
))))
8312 && (sec
->flags
& SEC_ALLOC
) != 0)
8314 can_make_dynamic_p
= TRUE
;
8316 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
8322 case R_MIPS_PC21_S2
:
8323 case R_MIPS_PC26_S2
:
8325 case R_MICROMIPS_26_S1
:
8326 case R_MICROMIPS_PC7_S1
:
8327 case R_MICROMIPS_PC10_S1
:
8328 case R_MICROMIPS_PC16_S1
:
8329 case R_MICROMIPS_PC23_S2
:
8330 call_reloc_p
= TRUE
;
8336 if (constrain_symbol_p
)
8338 if (!can_make_dynamic_p
)
8339 ((struct mips_elf_link_hash_entry
*) h
)->has_static_relocs
= 1;
8342 h
->pointer_equality_needed
= 1;
8344 /* We must not create a stub for a symbol that has
8345 relocations related to taking the function's address.
8346 This doesn't apply to VxWorks, where CALL relocs refer
8347 to a .got.plt entry instead of a normal .got entry. */
8348 if (!htab
->is_vxworks
&& (!can_make_dynamic_p
|| !call_reloc_p
))
8349 ((struct mips_elf_link_hash_entry
*) h
)->no_fn_stub
= TRUE
;
8352 /* Relocations against the special VxWorks __GOTT_BASE__ and
8353 __GOTT_INDEX__ symbols must be left to the loader. Allocate
8354 room for them in .rela.dyn. */
8355 if (is_gott_symbol (info
, h
))
8359 sreloc
= mips_elf_rel_dyn_section (info
, TRUE
);
8363 mips_elf_allocate_dynamic_relocations (dynobj
, info
, 1);
8364 if (MIPS_ELF_READONLY_SECTION (sec
))
8365 /* We tell the dynamic linker that there are
8366 relocations against the text segment. */
8367 info
->flags
|= DF_TEXTREL
;
8370 else if (call_lo16_reloc_p (r_type
)
8371 || got_lo16_reloc_p (r_type
)
8372 || got_disp_reloc_p (r_type
)
8373 || (got16_reloc_p (r_type
) && htab
->is_vxworks
))
8375 /* We may need a local GOT entry for this relocation. We
8376 don't count R_MIPS_GOT_PAGE because we can estimate the
8377 maximum number of pages needed by looking at the size of
8378 the segment. Similar comments apply to R_MIPS*_GOT16 and
8379 R_MIPS*_CALL16, except on VxWorks, where GOT relocations
8380 always evaluate to "G". We don't count R_MIPS_GOT_HI16, or
8381 R_MIPS_CALL_HI16 because these are always followed by an
8382 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
8383 if (!mips_elf_record_local_got_symbol (abfd
, r_symndx
,
8384 rel
->r_addend
, info
, r_type
))
8389 && mips_elf_relocation_needs_la25_stub (abfd
, r_type
,
8390 ELF_ST_IS_MIPS16 (h
->other
)))
8391 ((struct mips_elf_link_hash_entry
*) h
)->has_nonpic_branches
= TRUE
;
8396 case R_MIPS16_CALL16
:
8397 case R_MICROMIPS_CALL16
:
8400 (*_bfd_error_handler
)
8401 (_("%B: CALL16 reloc at 0x%lx not against global symbol"),
8402 abfd
, (unsigned long) rel
->r_offset
);
8403 bfd_set_error (bfd_error_bad_value
);
8408 case R_MIPS_CALL_HI16
:
8409 case R_MIPS_CALL_LO16
:
8410 case R_MICROMIPS_CALL_HI16
:
8411 case R_MICROMIPS_CALL_LO16
:
8414 /* Make sure there is room in the regular GOT to hold the
8415 function's address. We may eliminate it in favour of
8416 a .got.plt entry later; see mips_elf_count_got_symbols. */
8417 if (!mips_elf_record_global_got_symbol (h
, abfd
, info
, TRUE
,
8421 /* We need a stub, not a plt entry for the undefined
8422 function. But we record it as if it needs plt. See
8423 _bfd_elf_adjust_dynamic_symbol. */
8429 case R_MIPS_GOT_PAGE
:
8430 case R_MICROMIPS_GOT_PAGE
:
8431 case R_MIPS16_GOT16
:
8433 case R_MIPS_GOT_HI16
:
8434 case R_MIPS_GOT_LO16
:
8435 case R_MICROMIPS_GOT16
:
8436 case R_MICROMIPS_GOT_HI16
:
8437 case R_MICROMIPS_GOT_LO16
:
8438 if (!h
|| got_page_reloc_p (r_type
))
8440 /* This relocation needs (or may need, if h != NULL) a
8441 page entry in the GOT. For R_MIPS_GOT_PAGE we do not
8442 know for sure until we know whether the symbol is
8444 if (mips_elf_rel_relocation_p (abfd
, sec
, relocs
, rel
))
8446 if (!mips_elf_get_section_contents (abfd
, sec
, &contents
))
8448 howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, r_type
, FALSE
);
8449 addend
= mips_elf_read_rel_addend (abfd
, rel
,
8451 if (got16_reloc_p (r_type
))
8452 mips_elf_add_lo16_rel_addend (abfd
, rel
, rel_end
,
8455 addend
<<= howto
->rightshift
;
8458 addend
= rel
->r_addend
;
8459 if (!mips_elf_record_got_page_ref (info
, abfd
, r_symndx
,
8465 struct mips_elf_link_hash_entry
*hmips
=
8466 (struct mips_elf_link_hash_entry
*) h
;
8468 /* This symbol is definitely not overridable. */
8469 if (hmips
->root
.def_regular
8470 && ! (bfd_link_pic (info
) && ! info
->symbolic
8471 && ! hmips
->root
.forced_local
))
8475 /* If this is a global, overridable symbol, GOT_PAGE will
8476 decay to GOT_DISP, so we'll need a GOT entry for it. */
8479 case R_MIPS_GOT_DISP
:
8480 case R_MICROMIPS_GOT_DISP
:
8481 if (h
&& !mips_elf_record_global_got_symbol (h
, abfd
, info
,
8486 case R_MIPS_TLS_GOTTPREL
:
8487 case R_MIPS16_TLS_GOTTPREL
:
8488 case R_MICROMIPS_TLS_GOTTPREL
:
8489 if (bfd_link_pic (info
))
8490 info
->flags
|= DF_STATIC_TLS
;
8493 case R_MIPS_TLS_LDM
:
8494 case R_MIPS16_TLS_LDM
:
8495 case R_MICROMIPS_TLS_LDM
:
8496 if (tls_ldm_reloc_p (r_type
))
8498 r_symndx
= STN_UNDEF
;
8504 case R_MIPS16_TLS_GD
:
8505 case R_MICROMIPS_TLS_GD
:
8506 /* This symbol requires a global offset table entry, or two
8507 for TLS GD relocations. */
8510 if (!mips_elf_record_global_got_symbol (h
, abfd
, info
,
8516 if (!mips_elf_record_local_got_symbol (abfd
, r_symndx
,
8526 /* In VxWorks executables, references to external symbols
8527 are handled using copy relocs or PLT stubs, so there's
8528 no need to add a .rela.dyn entry for this relocation. */
8529 if (can_make_dynamic_p
)
8533 sreloc
= mips_elf_rel_dyn_section (info
, TRUE
);
8537 if (bfd_link_pic (info
) && h
== NULL
)
8539 /* When creating a shared object, we must copy these
8540 reloc types into the output file as R_MIPS_REL32
8541 relocs. Make room for this reloc in .rel(a).dyn. */
8542 mips_elf_allocate_dynamic_relocations (dynobj
, info
, 1);
8543 if (MIPS_ELF_READONLY_SECTION (sec
))
8544 /* We tell the dynamic linker that there are
8545 relocations against the text segment. */
8546 info
->flags
|= DF_TEXTREL
;
8550 struct mips_elf_link_hash_entry
*hmips
;
8552 /* For a shared object, we must copy this relocation
8553 unless the symbol turns out to be undefined and
8554 weak with non-default visibility, in which case
8555 it will be left as zero.
8557 We could elide R_MIPS_REL32 for locally binding symbols
8558 in shared libraries, but do not yet do so.
8560 For an executable, we only need to copy this
8561 reloc if the symbol is defined in a dynamic
8563 hmips
= (struct mips_elf_link_hash_entry
*) h
;
8564 ++hmips
->possibly_dynamic_relocs
;
8565 if (MIPS_ELF_READONLY_SECTION (sec
))
8566 /* We need it to tell the dynamic linker if there
8567 are relocations against the text segment. */
8568 hmips
->readonly_reloc
= TRUE
;
8572 if (SGI_COMPAT (abfd
))
8573 mips_elf_hash_table (info
)->compact_rel_size
+=
8574 sizeof (Elf32_External_crinfo
);
8578 case R_MIPS_GPREL16
:
8579 case R_MIPS_LITERAL
:
8580 case R_MIPS_GPREL32
:
8581 case R_MICROMIPS_26_S1
:
8582 case R_MICROMIPS_GPREL16
:
8583 case R_MICROMIPS_LITERAL
:
8584 case R_MICROMIPS_GPREL7_S2
:
8585 if (SGI_COMPAT (abfd
))
8586 mips_elf_hash_table (info
)->compact_rel_size
+=
8587 sizeof (Elf32_External_crinfo
);
8590 /* This relocation describes the C++ object vtable hierarchy.
8591 Reconstruct it for later use during GC. */
8592 case R_MIPS_GNU_VTINHERIT
:
8593 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
8597 /* This relocation describes which C++ vtable entries are actually
8598 used. Record for later use during GC. */
8599 case R_MIPS_GNU_VTENTRY
:
8600 BFD_ASSERT (h
!= NULL
);
8602 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
8610 /* Record the need for a PLT entry. At this point we don't know
8611 yet if we are going to create a PLT in the first place, but
8612 we only record whether the relocation requires a standard MIPS
8613 or a compressed code entry anyway. If we don't make a PLT after
8614 all, then we'll just ignore these arrangements. Likewise if
8615 a PLT entry is not created because the symbol is satisfied
8618 && jal_reloc_p (r_type
)
8619 && !SYMBOL_CALLS_LOCAL (info
, h
))
8621 if (h
->plt
.plist
== NULL
)
8622 h
->plt
.plist
= mips_elf_make_plt_record (abfd
);
8623 if (h
->plt
.plist
== NULL
)
8626 if (r_type
== R_MIPS_26
)
8627 h
->plt
.plist
->need_mips
= TRUE
;
8629 h
->plt
.plist
->need_comp
= TRUE
;
8632 /* See if this reloc would need to refer to a MIPS16 hard-float stub,
8633 if there is one. We only need to handle global symbols here;
8634 we decide whether to keep or delete stubs for local symbols
8635 when processing the stub's relocations. */
8637 && !mips16_call_reloc_p (r_type
)
8638 && !section_allows_mips16_refs_p (sec
))
8640 struct mips_elf_link_hash_entry
*mh
;
8642 mh
= (struct mips_elf_link_hash_entry
*) h
;
8643 mh
->need_fn_stub
= TRUE
;
8646 /* Refuse some position-dependent relocations when creating a
8647 shared library. Do not refuse R_MIPS_32 / R_MIPS_64; they're
8648 not PIC, but we can create dynamic relocations and the result
8649 will be fine. Also do not refuse R_MIPS_LO16, which can be
8650 combined with R_MIPS_GOT16. */
8651 if (bfd_link_pic (info
))
8658 case R_MIPS_HIGHEST
:
8659 case R_MICROMIPS_HI16
:
8660 case R_MICROMIPS_HIGHER
:
8661 case R_MICROMIPS_HIGHEST
:
8662 /* Don't refuse a high part relocation if it's against
8663 no symbol (e.g. part of a compound relocation). */
8664 if (r_symndx
== STN_UNDEF
)
8667 /* R_MIPS_HI16 against _gp_disp is used for $gp setup,
8668 and has a special meaning. */
8669 if (!NEWABI_P (abfd
) && h
!= NULL
8670 && strcmp (h
->root
.root
.string
, "_gp_disp") == 0)
8673 /* Likewise __GOTT_BASE__ and __GOTT_INDEX__ on VxWorks. */
8674 if (is_gott_symbol (info
, h
))
8681 case R_MICROMIPS_26_S1
:
8682 howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, r_type
, FALSE
);
8683 (*_bfd_error_handler
)
8684 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
8686 (h
) ? h
->root
.root
.string
: "a local symbol");
8687 bfd_set_error (bfd_error_bad_value
);
8699 _bfd_mips_relax_section (bfd
*abfd
, asection
*sec
,
8700 struct bfd_link_info
*link_info
,
8703 Elf_Internal_Rela
*internal_relocs
;
8704 Elf_Internal_Rela
*irel
, *irelend
;
8705 Elf_Internal_Shdr
*symtab_hdr
;
8706 bfd_byte
*contents
= NULL
;
8708 bfd_boolean changed_contents
= FALSE
;
8709 bfd_vma sec_start
= sec
->output_section
->vma
+ sec
->output_offset
;
8710 Elf_Internal_Sym
*isymbuf
= NULL
;
8712 /* We are not currently changing any sizes, so only one pass. */
8715 if (bfd_link_relocatable (link_info
))
8718 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
8719 link_info
->keep_memory
);
8720 if (internal_relocs
== NULL
)
8723 irelend
= internal_relocs
+ sec
->reloc_count
8724 * get_elf_backend_data (abfd
)->s
->int_rels_per_ext_rel
;
8725 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
8726 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
8728 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
8731 bfd_signed_vma sym_offset
;
8732 unsigned int r_type
;
8733 unsigned long r_symndx
;
8735 unsigned long instruction
;
8737 /* Turn jalr into bgezal, and jr into beq, if they're marked
8738 with a JALR relocation, that indicate where they jump to.
8739 This saves some pipeline bubbles. */
8740 r_type
= ELF_R_TYPE (abfd
, irel
->r_info
);
8741 if (r_type
!= R_MIPS_JALR
)
8744 r_symndx
= ELF_R_SYM (abfd
, irel
->r_info
);
8745 /* Compute the address of the jump target. */
8746 if (r_symndx
>= extsymoff
)
8748 struct mips_elf_link_hash_entry
*h
8749 = ((struct mips_elf_link_hash_entry
*)
8750 elf_sym_hashes (abfd
) [r_symndx
- extsymoff
]);
8752 while (h
->root
.root
.type
== bfd_link_hash_indirect
8753 || h
->root
.root
.type
== bfd_link_hash_warning
)
8754 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
8756 /* If a symbol is undefined, or if it may be overridden,
8758 if (! ((h
->root
.root
.type
== bfd_link_hash_defined
8759 || h
->root
.root
.type
== bfd_link_hash_defweak
)
8760 && h
->root
.root
.u
.def
.section
)
8761 || (bfd_link_pic (link_info
) && ! link_info
->symbolic
8762 && !h
->root
.forced_local
))
8765 sym_sec
= h
->root
.root
.u
.def
.section
;
8766 if (sym_sec
->output_section
)
8767 symval
= (h
->root
.root
.u
.def
.value
8768 + sym_sec
->output_section
->vma
8769 + sym_sec
->output_offset
);
8771 symval
= h
->root
.root
.u
.def
.value
;
8775 Elf_Internal_Sym
*isym
;
8777 /* Read this BFD's symbols if we haven't done so already. */
8778 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
8780 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
8781 if (isymbuf
== NULL
)
8782 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
8783 symtab_hdr
->sh_info
, 0,
8785 if (isymbuf
== NULL
)
8789 isym
= isymbuf
+ r_symndx
;
8790 if (isym
->st_shndx
== SHN_UNDEF
)
8792 else if (isym
->st_shndx
== SHN_ABS
)
8793 sym_sec
= bfd_abs_section_ptr
;
8794 else if (isym
->st_shndx
== SHN_COMMON
)
8795 sym_sec
= bfd_com_section_ptr
;
8798 = bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
8799 symval
= isym
->st_value
8800 + sym_sec
->output_section
->vma
8801 + sym_sec
->output_offset
;
8804 /* Compute branch offset, from delay slot of the jump to the
8806 sym_offset
= (symval
+ irel
->r_addend
)
8807 - (sec_start
+ irel
->r_offset
+ 4);
8809 /* Branch offset must be properly aligned. */
8810 if ((sym_offset
& 3) != 0)
8815 /* Check that it's in range. */
8816 if (sym_offset
< -0x8000 || sym_offset
>= 0x8000)
8819 /* Get the section contents if we haven't done so already. */
8820 if (!mips_elf_get_section_contents (abfd
, sec
, &contents
))
8823 instruction
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
8825 /* If it was jalr <reg>, turn it into bgezal $zero, <target>. */
8826 if ((instruction
& 0xfc1fffff) == 0x0000f809)
8827 instruction
= 0x04110000;
8828 /* If it was jr <reg>, turn it into b <target>. */
8829 else if ((instruction
& 0xfc1fffff) == 0x00000008)
8830 instruction
= 0x10000000;
8834 instruction
|= (sym_offset
& 0xffff);
8835 bfd_put_32 (abfd
, instruction
, contents
+ irel
->r_offset
);
8836 changed_contents
= TRUE
;
8839 if (contents
!= NULL
8840 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
8842 if (!changed_contents
&& !link_info
->keep_memory
)
8846 /* Cache the section contents for elf_link_input_bfd. */
8847 elf_section_data (sec
)->this_hdr
.contents
= contents
;
8853 if (contents
!= NULL
8854 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
8859 /* Allocate space for global sym dynamic relocs. */
8862 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
8864 struct bfd_link_info
*info
= inf
;
8866 struct mips_elf_link_hash_entry
*hmips
;
8867 struct mips_elf_link_hash_table
*htab
;
8869 htab
= mips_elf_hash_table (info
);
8870 BFD_ASSERT (htab
!= NULL
);
8872 dynobj
= elf_hash_table (info
)->dynobj
;
8873 hmips
= (struct mips_elf_link_hash_entry
*) h
;
8875 /* VxWorks executables are handled elsewhere; we only need to
8876 allocate relocations in shared objects. */
8877 if (htab
->is_vxworks
&& !bfd_link_pic (info
))
8880 /* Ignore indirect symbols. All relocations against such symbols
8881 will be redirected to the target symbol. */
8882 if (h
->root
.type
== bfd_link_hash_indirect
)
8885 /* If this symbol is defined in a dynamic object, or we are creating
8886 a shared library, we will need to copy any R_MIPS_32 or
8887 R_MIPS_REL32 relocs against it into the output file. */
8888 if (! bfd_link_relocatable (info
)
8889 && hmips
->possibly_dynamic_relocs
!= 0
8890 && (h
->root
.type
== bfd_link_hash_defweak
8891 || (!h
->def_regular
&& !ELF_COMMON_DEF_P (h
))
8892 || bfd_link_pic (info
)))
8894 bfd_boolean do_copy
= TRUE
;
8896 if (h
->root
.type
== bfd_link_hash_undefweak
)
8898 /* Do not copy relocations for undefined weak symbols with
8899 non-default visibility. */
8900 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
8903 /* Make sure undefined weak symbols are output as a dynamic
8905 else if (h
->dynindx
== -1 && !h
->forced_local
)
8907 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
8914 /* Even though we don't directly need a GOT entry for this symbol,
8915 the SVR4 psABI requires it to have a dynamic symbol table
8916 index greater that DT_MIPS_GOTSYM if there are dynamic
8917 relocations against it.
8919 VxWorks does not enforce the same mapping between the GOT
8920 and the symbol table, so the same requirement does not
8922 if (!htab
->is_vxworks
)
8924 if (hmips
->global_got_area
> GGA_RELOC_ONLY
)
8925 hmips
->global_got_area
= GGA_RELOC_ONLY
;
8926 hmips
->got_only_for_calls
= FALSE
;
8929 mips_elf_allocate_dynamic_relocations
8930 (dynobj
, info
, hmips
->possibly_dynamic_relocs
);
8931 if (hmips
->readonly_reloc
)
8932 /* We tell the dynamic linker that there are relocations
8933 against the text segment. */
8934 info
->flags
|= DF_TEXTREL
;
8941 /* Adjust a symbol defined by a dynamic object and referenced by a
8942 regular object. The current definition is in some section of the
8943 dynamic object, but we're not including those sections. We have to
8944 change the definition to something the rest of the link can
8948 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
8949 struct elf_link_hash_entry
*h
)
8952 struct mips_elf_link_hash_entry
*hmips
;
8953 struct mips_elf_link_hash_table
*htab
;
8955 htab
= mips_elf_hash_table (info
);
8956 BFD_ASSERT (htab
!= NULL
);
8958 dynobj
= elf_hash_table (info
)->dynobj
;
8959 hmips
= (struct mips_elf_link_hash_entry
*) h
;
8961 /* Make sure we know what is going on here. */
8962 BFD_ASSERT (dynobj
!= NULL
8964 || h
->u
.weakdef
!= NULL
8967 && !h
->def_regular
)));
8969 hmips
= (struct mips_elf_link_hash_entry
*) h
;
8971 /* If there are call relocations against an externally-defined symbol,
8972 see whether we can create a MIPS lazy-binding stub for it. We can
8973 only do this if all references to the function are through call
8974 relocations, and in that case, the traditional lazy-binding stubs
8975 are much more efficient than PLT entries.
8977 Traditional stubs are only available on SVR4 psABI-based systems;
8978 VxWorks always uses PLTs instead. */
8979 if (!htab
->is_vxworks
&& h
->needs_plt
&& !hmips
->no_fn_stub
)
8981 if (! elf_hash_table (info
)->dynamic_sections_created
)
8984 /* If this symbol is not defined in a regular file, then set
8985 the symbol to the stub location. This is required to make
8986 function pointers compare as equal between the normal
8987 executable and the shared library. */
8988 if (!h
->def_regular
)
8990 hmips
->needs_lazy_stub
= TRUE
;
8991 htab
->lazy_stub_count
++;
8995 /* As above, VxWorks requires PLT entries for externally-defined
8996 functions that are only accessed through call relocations.
8998 Both VxWorks and non-VxWorks targets also need PLT entries if there
8999 are static-only relocations against an externally-defined function.
9000 This can technically occur for shared libraries if there are
9001 branches to the symbol, although it is unlikely that this will be
9002 used in practice due to the short ranges involved. It can occur
9003 for any relative or absolute relocation in executables; in that
9004 case, the PLT entry becomes the function's canonical address. */
9005 else if (((h
->needs_plt
&& !hmips
->no_fn_stub
)
9006 || (h
->type
== STT_FUNC
&& hmips
->has_static_relocs
))
9007 && htab
->use_plts_and_copy_relocs
9008 && !SYMBOL_CALLS_LOCAL (info
, h
)
9009 && !(ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
9010 && h
->root
.type
== bfd_link_hash_undefweak
))
9012 bfd_boolean micromips_p
= MICROMIPS_P (info
->output_bfd
);
9013 bfd_boolean newabi_p
= NEWABI_P (info
->output_bfd
);
9015 /* If this is the first symbol to need a PLT entry, then make some
9016 basic setup. Also work out PLT entry sizes. We'll need them
9017 for PLT offset calculations. */
9018 if (htab
->plt_mips_offset
+ htab
->plt_comp_offset
== 0)
9020 BFD_ASSERT (htab
->sgotplt
->size
== 0);
9021 BFD_ASSERT (htab
->plt_got_index
== 0);
9023 /* If we're using the PLT additions to the psABI, each PLT
9024 entry is 16 bytes and the PLT0 entry is 32 bytes.
9025 Encourage better cache usage by aligning. We do this
9026 lazily to avoid pessimizing traditional objects. */
9027 if (!htab
->is_vxworks
9028 && !bfd_set_section_alignment (dynobj
, htab
->splt
, 5))
9031 /* Make sure that .got.plt is word-aligned. We do this lazily
9032 for the same reason as above. */
9033 if (!bfd_set_section_alignment (dynobj
, htab
->sgotplt
,
9034 MIPS_ELF_LOG_FILE_ALIGN (dynobj
)))
9037 /* On non-VxWorks targets, the first two entries in .got.plt
9039 if (!htab
->is_vxworks
)
9041 += (get_elf_backend_data (dynobj
)->got_header_size
9042 / MIPS_ELF_GOT_SIZE (dynobj
));
9044 /* On VxWorks, also allocate room for the header's
9045 .rela.plt.unloaded entries. */
9046 if (htab
->is_vxworks
&& !bfd_link_pic (info
))
9047 htab
->srelplt2
->size
+= 2 * sizeof (Elf32_External_Rela
);
9049 /* Now work out the sizes of individual PLT entries. */
9050 if (htab
->is_vxworks
&& bfd_link_pic (info
))
9051 htab
->plt_mips_entry_size
9052 = 4 * ARRAY_SIZE (mips_vxworks_shared_plt_entry
);
9053 else if (htab
->is_vxworks
)
9054 htab
->plt_mips_entry_size
9055 = 4 * ARRAY_SIZE (mips_vxworks_exec_plt_entry
);
9057 htab
->plt_mips_entry_size
9058 = 4 * ARRAY_SIZE (mips_exec_plt_entry
);
9059 else if (!micromips_p
)
9061 htab
->plt_mips_entry_size
9062 = 4 * ARRAY_SIZE (mips_exec_plt_entry
);
9063 htab
->plt_comp_entry_size
9064 = 2 * ARRAY_SIZE (mips16_o32_exec_plt_entry
);
9066 else if (htab
->insn32
)
9068 htab
->plt_mips_entry_size
9069 = 4 * ARRAY_SIZE (mips_exec_plt_entry
);
9070 htab
->plt_comp_entry_size
9071 = 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt_entry
);
9075 htab
->plt_mips_entry_size
9076 = 4 * ARRAY_SIZE (mips_exec_plt_entry
);
9077 htab
->plt_comp_entry_size
9078 = 2 * ARRAY_SIZE (micromips_o32_exec_plt_entry
);
9082 if (h
->plt
.plist
== NULL
)
9083 h
->plt
.plist
= mips_elf_make_plt_record (dynobj
);
9084 if (h
->plt
.plist
== NULL
)
9087 /* There are no defined MIPS16 or microMIPS PLT entries for VxWorks,
9088 n32 or n64, so always use a standard entry there.
9090 If the symbol has a MIPS16 call stub and gets a PLT entry, then
9091 all MIPS16 calls will go via that stub, and there is no benefit
9092 to having a MIPS16 entry. And in the case of call_stub a
9093 standard entry actually has to be used as the stub ends with a J
9098 || hmips
->call_fp_stub
)
9100 h
->plt
.plist
->need_mips
= TRUE
;
9101 h
->plt
.plist
->need_comp
= FALSE
;
9104 /* Otherwise, if there are no direct calls to the function, we
9105 have a free choice of whether to use standard or compressed
9106 entries. Prefer microMIPS entries if the object is known to
9107 contain microMIPS code, so that it becomes possible to create
9108 pure microMIPS binaries. Prefer standard entries otherwise,
9109 because MIPS16 ones are no smaller and are usually slower. */
9110 if (!h
->plt
.plist
->need_mips
&& !h
->plt
.plist
->need_comp
)
9113 h
->plt
.plist
->need_comp
= TRUE
;
9115 h
->plt
.plist
->need_mips
= TRUE
;
9118 if (h
->plt
.plist
->need_mips
)
9120 h
->plt
.plist
->mips_offset
= htab
->plt_mips_offset
;
9121 htab
->plt_mips_offset
+= htab
->plt_mips_entry_size
;
9123 if (h
->plt
.plist
->need_comp
)
9125 h
->plt
.plist
->comp_offset
= htab
->plt_comp_offset
;
9126 htab
->plt_comp_offset
+= htab
->plt_comp_entry_size
;
9129 /* Reserve the corresponding .got.plt entry now too. */
9130 h
->plt
.plist
->gotplt_index
= htab
->plt_got_index
++;
9132 /* If the output file has no definition of the symbol, set the
9133 symbol's value to the address of the stub. */
9134 if (!bfd_link_pic (info
) && !h
->def_regular
)
9135 hmips
->use_plt_entry
= TRUE
;
9137 /* Make room for the R_MIPS_JUMP_SLOT relocation. */
9138 htab
->srelplt
->size
+= (htab
->is_vxworks
9139 ? MIPS_ELF_RELA_SIZE (dynobj
)
9140 : MIPS_ELF_REL_SIZE (dynobj
));
9142 /* Make room for the .rela.plt.unloaded relocations. */
9143 if (htab
->is_vxworks
&& !bfd_link_pic (info
))
9144 htab
->srelplt2
->size
+= 3 * sizeof (Elf32_External_Rela
);
9146 /* All relocations against this symbol that could have been made
9147 dynamic will now refer to the PLT entry instead. */
9148 hmips
->possibly_dynamic_relocs
= 0;
9153 /* If this is a weak symbol, and there is a real definition, the
9154 processor independent code will have arranged for us to see the
9155 real definition first, and we can just use the same value. */
9156 if (h
->u
.weakdef
!= NULL
)
9158 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
9159 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
9160 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
9161 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
9165 /* Otherwise, there is nothing further to do for symbols defined
9166 in regular objects. */
9170 /* There's also nothing more to do if we'll convert all relocations
9171 against this symbol into dynamic relocations. */
9172 if (!hmips
->has_static_relocs
)
9175 /* We're now relying on copy relocations. Complain if we have
9176 some that we can't convert. */
9177 if (!htab
->use_plts_and_copy_relocs
|| bfd_link_pic (info
))
9179 (*_bfd_error_handler
) (_("non-dynamic relocations refer to "
9180 "dynamic symbol %s"),
9181 h
->root
.root
.string
);
9182 bfd_set_error (bfd_error_bad_value
);
9186 /* We must allocate the symbol in our .dynbss section, which will
9187 become part of the .bss section of the executable. There will be
9188 an entry for this symbol in the .dynsym section. The dynamic
9189 object will contain position independent code, so all references
9190 from the dynamic object to this symbol will go through the global
9191 offset table. The dynamic linker will use the .dynsym entry to
9192 determine the address it must put in the global offset table, so
9193 both the dynamic object and the regular object will refer to the
9194 same memory location for the variable. */
9196 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
9198 if (htab
->is_vxworks
)
9199 htab
->srelbss
->size
+= sizeof (Elf32_External_Rela
);
9201 mips_elf_allocate_dynamic_relocations (dynobj
, info
, 1);
9205 /* All relocations against this symbol that could have been made
9206 dynamic will now refer to the local copy instead. */
9207 hmips
->possibly_dynamic_relocs
= 0;
9209 return _bfd_elf_adjust_dynamic_copy (info
, h
, htab
->sdynbss
);
9212 /* This function is called after all the input files have been read,
9213 and the input sections have been assigned to output sections. We
9214 check for any mips16 stub sections that we can discard. */
9217 _bfd_mips_elf_always_size_sections (bfd
*output_bfd
,
9218 struct bfd_link_info
*info
)
9221 struct mips_elf_link_hash_table
*htab
;
9222 struct mips_htab_traverse_info hti
;
9224 htab
= mips_elf_hash_table (info
);
9225 BFD_ASSERT (htab
!= NULL
);
9227 /* The .reginfo section has a fixed size. */
9228 sect
= bfd_get_section_by_name (output_bfd
, ".reginfo");
9230 bfd_set_section_size (output_bfd
, sect
, sizeof (Elf32_External_RegInfo
));
9232 /* The .MIPS.abiflags section has a fixed size. */
9233 sect
= bfd_get_section_by_name (output_bfd
, ".MIPS.abiflags");
9235 bfd_set_section_size (output_bfd
, sect
, sizeof (Elf_External_ABIFlags_v0
));
9238 hti
.output_bfd
= output_bfd
;
9240 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
9241 mips_elf_check_symbols
, &hti
);
9248 /* If the link uses a GOT, lay it out and work out its size. */
9251 mips_elf_lay_out_got (bfd
*output_bfd
, struct bfd_link_info
*info
)
9255 struct mips_got_info
*g
;
9256 bfd_size_type loadable_size
= 0;
9257 bfd_size_type page_gotno
;
9259 struct mips_elf_traverse_got_arg tga
;
9260 struct mips_elf_link_hash_table
*htab
;
9262 htab
= mips_elf_hash_table (info
);
9263 BFD_ASSERT (htab
!= NULL
);
9269 dynobj
= elf_hash_table (info
)->dynobj
;
9272 /* Allocate room for the reserved entries. VxWorks always reserves
9273 3 entries; other objects only reserve 2 entries. */
9274 BFD_ASSERT (g
->assigned_low_gotno
== 0);
9275 if (htab
->is_vxworks
)
9276 htab
->reserved_gotno
= 3;
9278 htab
->reserved_gotno
= 2;
9279 g
->local_gotno
+= htab
->reserved_gotno
;
9280 g
->assigned_low_gotno
= htab
->reserved_gotno
;
9282 /* Decide which symbols need to go in the global part of the GOT and
9283 count the number of reloc-only GOT symbols. */
9284 mips_elf_link_hash_traverse (htab
, mips_elf_count_got_symbols
, info
);
9286 if (!mips_elf_resolve_final_got_entries (info
, g
))
9289 /* Calculate the total loadable size of the output. That
9290 will give us the maximum number of GOT_PAGE entries
9292 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
9294 asection
*subsection
;
9296 for (subsection
= ibfd
->sections
;
9298 subsection
= subsection
->next
)
9300 if ((subsection
->flags
& SEC_ALLOC
) == 0)
9302 loadable_size
+= ((subsection
->size
+ 0xf)
9303 &~ (bfd_size_type
) 0xf);
9307 if (htab
->is_vxworks
)
9308 /* There's no need to allocate page entries for VxWorks; R_MIPS*_GOT16
9309 relocations against local symbols evaluate to "G", and the EABI does
9310 not include R_MIPS_GOT_PAGE. */
9313 /* Assume there are two loadable segments consisting of contiguous
9314 sections. Is 5 enough? */
9315 page_gotno
= (loadable_size
>> 16) + 5;
9317 /* Choose the smaller of the two page estimates; both are intended to be
9319 if (page_gotno
> g
->page_gotno
)
9320 page_gotno
= g
->page_gotno
;
9322 g
->local_gotno
+= page_gotno
;
9323 g
->assigned_high_gotno
= g
->local_gotno
- 1;
9325 s
->size
+= g
->local_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
9326 s
->size
+= g
->global_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
9327 s
->size
+= g
->tls_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
9329 /* VxWorks does not support multiple GOTs. It initializes $gp to
9330 __GOTT_BASE__[__GOTT_INDEX__], the value of which is set by the
9332 if (!htab
->is_vxworks
&& s
->size
> MIPS_ELF_GOT_MAX_SIZE (info
))
9334 if (!mips_elf_multi_got (output_bfd
, info
, s
, page_gotno
))
9339 /* Record that all bfds use G. This also has the effect of freeing
9340 the per-bfd GOTs, which we no longer need. */
9341 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
9342 if (mips_elf_bfd_got (ibfd
, FALSE
))
9343 mips_elf_replace_bfd_got (ibfd
, g
);
9344 mips_elf_replace_bfd_got (output_bfd
, g
);
9346 /* Set up TLS entries. */
9347 g
->tls_assigned_gotno
= g
->global_gotno
+ g
->local_gotno
;
9350 tga
.value
= MIPS_ELF_GOT_SIZE (output_bfd
);
9351 htab_traverse (g
->got_entries
, mips_elf_initialize_tls_index
, &tga
);
9354 BFD_ASSERT (g
->tls_assigned_gotno
9355 == g
->global_gotno
+ g
->local_gotno
+ g
->tls_gotno
);
9357 /* Each VxWorks GOT entry needs an explicit relocation. */
9358 if (htab
->is_vxworks
&& bfd_link_pic (info
))
9359 g
->relocs
+= g
->global_gotno
+ g
->local_gotno
- htab
->reserved_gotno
;
9361 /* Allocate room for the TLS relocations. */
9363 mips_elf_allocate_dynamic_relocations (dynobj
, info
, g
->relocs
);
9369 /* Estimate the size of the .MIPS.stubs section. */
9372 mips_elf_estimate_stub_size (bfd
*output_bfd
, struct bfd_link_info
*info
)
9374 struct mips_elf_link_hash_table
*htab
;
9375 bfd_size_type dynsymcount
;
9377 htab
= mips_elf_hash_table (info
);
9378 BFD_ASSERT (htab
!= NULL
);
9380 if (htab
->lazy_stub_count
== 0)
9383 /* IRIX rld assumes that a function stub isn't at the end of the .text
9384 section, so add a dummy entry to the end. */
9385 htab
->lazy_stub_count
++;
9387 /* Get a worst-case estimate of the number of dynamic symbols needed.
9388 At this point, dynsymcount does not account for section symbols
9389 and count_section_dynsyms may overestimate the number that will
9391 dynsymcount
= (elf_hash_table (info
)->dynsymcount
9392 + count_section_dynsyms (output_bfd
, info
));
9394 /* Determine the size of one stub entry. There's no disadvantage
9395 from using microMIPS code here, so for the sake of pure-microMIPS
9396 binaries we prefer it whenever there's any microMIPS code in
9397 output produced at all. This has a benefit of stubs being
9398 shorter by 4 bytes each too, unless in the insn32 mode. */
9399 if (!MICROMIPS_P (output_bfd
))
9400 htab
->function_stub_size
= (dynsymcount
> 0x10000
9401 ? MIPS_FUNCTION_STUB_BIG_SIZE
9402 : MIPS_FUNCTION_STUB_NORMAL_SIZE
);
9403 else if (htab
->insn32
)
9404 htab
->function_stub_size
= (dynsymcount
> 0x10000
9405 ? MICROMIPS_INSN32_FUNCTION_STUB_BIG_SIZE
9406 : MICROMIPS_INSN32_FUNCTION_STUB_NORMAL_SIZE
);
9408 htab
->function_stub_size
= (dynsymcount
> 0x10000
9409 ? MICROMIPS_FUNCTION_STUB_BIG_SIZE
9410 : MICROMIPS_FUNCTION_STUB_NORMAL_SIZE
);
9412 htab
->sstubs
->size
= htab
->lazy_stub_count
* htab
->function_stub_size
;
9415 /* A mips_elf_link_hash_traverse callback for which DATA points to a
9416 mips_htab_traverse_info. If H needs a traditional MIPS lazy-binding
9417 stub, allocate an entry in the stubs section. */
9420 mips_elf_allocate_lazy_stub (struct mips_elf_link_hash_entry
*h
, void *data
)
9422 struct mips_htab_traverse_info
*hti
= data
;
9423 struct mips_elf_link_hash_table
*htab
;
9424 struct bfd_link_info
*info
;
9428 output_bfd
= hti
->output_bfd
;
9429 htab
= mips_elf_hash_table (info
);
9430 BFD_ASSERT (htab
!= NULL
);
9432 if (h
->needs_lazy_stub
)
9434 bfd_boolean micromips_p
= MICROMIPS_P (output_bfd
);
9435 unsigned int other
= micromips_p
? STO_MICROMIPS
: 0;
9436 bfd_vma isa_bit
= micromips_p
;
9438 BFD_ASSERT (htab
->root
.dynobj
!= NULL
);
9439 if (h
->root
.plt
.plist
== NULL
)
9440 h
->root
.plt
.plist
= mips_elf_make_plt_record (htab
->sstubs
->owner
);
9441 if (h
->root
.plt
.plist
== NULL
)
9446 h
->root
.root
.u
.def
.section
= htab
->sstubs
;
9447 h
->root
.root
.u
.def
.value
= htab
->sstubs
->size
+ isa_bit
;
9448 h
->root
.plt
.plist
->stub_offset
= htab
->sstubs
->size
;
9449 h
->root
.other
= other
;
9450 htab
->sstubs
->size
+= htab
->function_stub_size
;
9455 /* Allocate offsets in the stubs section to each symbol that needs one.
9456 Set the final size of the .MIPS.stub section. */
9459 mips_elf_lay_out_lazy_stubs (struct bfd_link_info
*info
)
9461 bfd
*output_bfd
= info
->output_bfd
;
9462 bfd_boolean micromips_p
= MICROMIPS_P (output_bfd
);
9463 unsigned int other
= micromips_p
? STO_MICROMIPS
: 0;
9464 bfd_vma isa_bit
= micromips_p
;
9465 struct mips_elf_link_hash_table
*htab
;
9466 struct mips_htab_traverse_info hti
;
9467 struct elf_link_hash_entry
*h
;
9470 htab
= mips_elf_hash_table (info
);
9471 BFD_ASSERT (htab
!= NULL
);
9473 if (htab
->lazy_stub_count
== 0)
9476 htab
->sstubs
->size
= 0;
9478 hti
.output_bfd
= output_bfd
;
9480 mips_elf_link_hash_traverse (htab
, mips_elf_allocate_lazy_stub
, &hti
);
9483 htab
->sstubs
->size
+= htab
->function_stub_size
;
9484 BFD_ASSERT (htab
->sstubs
->size
9485 == htab
->lazy_stub_count
* htab
->function_stub_size
);
9487 dynobj
= elf_hash_table (info
)->dynobj
;
9488 BFD_ASSERT (dynobj
!= NULL
);
9489 h
= _bfd_elf_define_linkage_sym (dynobj
, info
, htab
->sstubs
, "_MIPS_STUBS_");
9492 h
->root
.u
.def
.value
= isa_bit
;
9499 /* A mips_elf_link_hash_traverse callback for which DATA points to a
9500 bfd_link_info. If H uses the address of a PLT entry as the value
9501 of the symbol, then set the entry in the symbol table now. Prefer
9502 a standard MIPS PLT entry. */
9505 mips_elf_set_plt_sym_value (struct mips_elf_link_hash_entry
*h
, void *data
)
9507 struct bfd_link_info
*info
= data
;
9508 bfd_boolean micromips_p
= MICROMIPS_P (info
->output_bfd
);
9509 struct mips_elf_link_hash_table
*htab
;
9514 htab
= mips_elf_hash_table (info
);
9515 BFD_ASSERT (htab
!= NULL
);
9517 if (h
->use_plt_entry
)
9519 BFD_ASSERT (h
->root
.plt
.plist
!= NULL
);
9520 BFD_ASSERT (h
->root
.plt
.plist
->mips_offset
!= MINUS_ONE
9521 || h
->root
.plt
.plist
->comp_offset
!= MINUS_ONE
);
9523 val
= htab
->plt_header_size
;
9524 if (h
->root
.plt
.plist
->mips_offset
!= MINUS_ONE
)
9527 val
+= h
->root
.plt
.plist
->mips_offset
;
9533 val
+= htab
->plt_mips_offset
+ h
->root
.plt
.plist
->comp_offset
;
9534 other
= micromips_p
? STO_MICROMIPS
: STO_MIPS16
;
9537 /* For VxWorks, point at the PLT load stub rather than the lazy
9538 resolution stub; this stub will become the canonical function
9540 if (htab
->is_vxworks
)
9543 h
->root
.root
.u
.def
.section
= htab
->splt
;
9544 h
->root
.root
.u
.def
.value
= val
;
9545 h
->root
.other
= other
;
9551 /* Set the sizes of the dynamic sections. */
9554 _bfd_mips_elf_size_dynamic_sections (bfd
*output_bfd
,
9555 struct bfd_link_info
*info
)
9558 asection
*s
, *sreldyn
;
9559 bfd_boolean reltext
;
9560 struct mips_elf_link_hash_table
*htab
;
9562 htab
= mips_elf_hash_table (info
);
9563 BFD_ASSERT (htab
!= NULL
);
9564 dynobj
= elf_hash_table (info
)->dynobj
;
9565 BFD_ASSERT (dynobj
!= NULL
);
9567 if (elf_hash_table (info
)->dynamic_sections_created
)
9569 /* Set the contents of the .interp section to the interpreter. */
9570 if (bfd_link_executable (info
) && !info
->nointerp
)
9572 s
= bfd_get_linker_section (dynobj
, ".interp");
9573 BFD_ASSERT (s
!= NULL
);
9575 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd
)) + 1;
9577 = (bfd_byte
*) ELF_DYNAMIC_INTERPRETER (output_bfd
);
9580 /* Figure out the size of the PLT header if we know that we
9581 are using it. For the sake of cache alignment always use
9582 a standard header whenever any standard entries are present
9583 even if microMIPS entries are present as well. This also
9584 lets the microMIPS header rely on the value of $v0 only set
9585 by microMIPS entries, for a small size reduction.
9587 Set symbol table entry values for symbols that use the
9588 address of their PLT entry now that we can calculate it.
9590 Also create the _PROCEDURE_LINKAGE_TABLE_ symbol if we
9591 haven't already in _bfd_elf_create_dynamic_sections. */
9592 if (htab
->splt
&& htab
->plt_mips_offset
+ htab
->plt_comp_offset
!= 0)
9594 bfd_boolean micromips_p
= (MICROMIPS_P (output_bfd
)
9595 && !htab
->plt_mips_offset
);
9596 unsigned int other
= micromips_p
? STO_MICROMIPS
: 0;
9597 bfd_vma isa_bit
= micromips_p
;
9598 struct elf_link_hash_entry
*h
;
9601 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
9602 BFD_ASSERT (htab
->sgotplt
->size
== 0);
9603 BFD_ASSERT (htab
->splt
->size
== 0);
9605 if (htab
->is_vxworks
&& bfd_link_pic (info
))
9606 size
= 4 * ARRAY_SIZE (mips_vxworks_shared_plt0_entry
);
9607 else if (htab
->is_vxworks
)
9608 size
= 4 * ARRAY_SIZE (mips_vxworks_exec_plt0_entry
);
9609 else if (ABI_64_P (output_bfd
))
9610 size
= 4 * ARRAY_SIZE (mips_n64_exec_plt0_entry
);
9611 else if (ABI_N32_P (output_bfd
))
9612 size
= 4 * ARRAY_SIZE (mips_n32_exec_plt0_entry
);
9613 else if (!micromips_p
)
9614 size
= 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry
);
9615 else if (htab
->insn32
)
9616 size
= 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt0_entry
);
9618 size
= 2 * ARRAY_SIZE (micromips_o32_exec_plt0_entry
);
9620 htab
->plt_header_is_comp
= micromips_p
;
9621 htab
->plt_header_size
= size
;
9622 htab
->splt
->size
= (size
9623 + htab
->plt_mips_offset
9624 + htab
->plt_comp_offset
);
9625 htab
->sgotplt
->size
= (htab
->plt_got_index
9626 * MIPS_ELF_GOT_SIZE (dynobj
));
9628 mips_elf_link_hash_traverse (htab
, mips_elf_set_plt_sym_value
, info
);
9630 if (htab
->root
.hplt
== NULL
)
9632 h
= _bfd_elf_define_linkage_sym (dynobj
, info
, htab
->splt
,
9633 "_PROCEDURE_LINKAGE_TABLE_");
9634 htab
->root
.hplt
= h
;
9639 h
= htab
->root
.hplt
;
9640 h
->root
.u
.def
.value
= isa_bit
;
9646 /* Allocate space for global sym dynamic relocs. */
9647 elf_link_hash_traverse (&htab
->root
, allocate_dynrelocs
, info
);
9649 mips_elf_estimate_stub_size (output_bfd
, info
);
9651 if (!mips_elf_lay_out_got (output_bfd
, info
))
9654 mips_elf_lay_out_lazy_stubs (info
);
9656 /* The check_relocs and adjust_dynamic_symbol entry points have
9657 determined the sizes of the various dynamic sections. Allocate
9660 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
9664 /* It's OK to base decisions on the section name, because none
9665 of the dynobj section names depend upon the input files. */
9666 name
= bfd_get_section_name (dynobj
, s
);
9668 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
9671 if (CONST_STRNEQ (name
, ".rel"))
9675 const char *outname
;
9678 /* If this relocation section applies to a read only
9679 section, then we probably need a DT_TEXTREL entry.
9680 If the relocation section is .rel(a).dyn, we always
9681 assert a DT_TEXTREL entry rather than testing whether
9682 there exists a relocation to a read only section or
9684 outname
= bfd_get_section_name (output_bfd
,
9686 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
9688 && (target
->flags
& SEC_READONLY
) != 0
9689 && (target
->flags
& SEC_ALLOC
) != 0)
9690 || strcmp (outname
, MIPS_ELF_REL_DYN_NAME (info
)) == 0)
9693 /* We use the reloc_count field as a counter if we need
9694 to copy relocs into the output file. */
9695 if (strcmp (name
, MIPS_ELF_REL_DYN_NAME (info
)) != 0)
9698 /* If combreloc is enabled, elf_link_sort_relocs() will
9699 sort relocations, but in a different way than we do,
9700 and before we're done creating relocations. Also, it
9701 will move them around between input sections'
9702 relocation's contents, so our sorting would be
9703 broken, so don't let it run. */
9704 info
->combreloc
= 0;
9707 else if (bfd_link_executable (info
)
9708 && ! mips_elf_hash_table (info
)->use_rld_obj_head
9709 && CONST_STRNEQ (name
, ".rld_map"))
9711 /* We add a room for __rld_map. It will be filled in by the
9712 rtld to contain a pointer to the _r_debug structure. */
9713 s
->size
+= MIPS_ELF_RLD_MAP_SIZE (output_bfd
);
9715 else if (SGI_COMPAT (output_bfd
)
9716 && CONST_STRNEQ (name
, ".compact_rel"))
9717 s
->size
+= mips_elf_hash_table (info
)->compact_rel_size
;
9718 else if (s
== htab
->splt
)
9720 /* If the last PLT entry has a branch delay slot, allocate
9721 room for an extra nop to fill the delay slot. This is
9722 for CPUs without load interlocking. */
9723 if (! LOAD_INTERLOCKS_P (output_bfd
)
9724 && ! htab
->is_vxworks
&& s
->size
> 0)
9727 else if (! CONST_STRNEQ (name
, ".init")
9729 && s
!= htab
->sgotplt
9730 && s
!= htab
->sstubs
9731 && s
!= htab
->sdynbss
)
9733 /* It's not one of our sections, so don't allocate space. */
9739 s
->flags
|= SEC_EXCLUDE
;
9743 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
9746 /* Allocate memory for the section contents. */
9747 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
9748 if (s
->contents
== NULL
)
9750 bfd_set_error (bfd_error_no_memory
);
9755 if (elf_hash_table (info
)->dynamic_sections_created
)
9757 /* Add some entries to the .dynamic section. We fill in the
9758 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
9759 must add the entries now so that we get the correct size for
9760 the .dynamic section. */
9762 /* SGI object has the equivalence of DT_DEBUG in the
9763 DT_MIPS_RLD_MAP entry. This must come first because glibc
9764 only fills in DT_MIPS_RLD_MAP (not DT_DEBUG) and some tools
9765 may only look at the first one they see. */
9766 if (!bfd_link_pic (info
)
9767 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_MAP
, 0))
9770 if (bfd_link_executable (info
)
9771 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_MAP_REL
, 0))
9774 /* The DT_DEBUG entry may be filled in by the dynamic linker and
9775 used by the debugger. */
9776 if (bfd_link_executable (info
)
9777 && !SGI_COMPAT (output_bfd
)
9778 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
9781 if (reltext
&& (SGI_COMPAT (output_bfd
) || htab
->is_vxworks
))
9782 info
->flags
|= DF_TEXTREL
;
9784 if ((info
->flags
& DF_TEXTREL
) != 0)
9786 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_TEXTREL
, 0))
9789 /* Clear the DF_TEXTREL flag. It will be set again if we
9790 write out an actual text relocation; we may not, because
9791 at this point we do not know whether e.g. any .eh_frame
9792 absolute relocations have been converted to PC-relative. */
9793 info
->flags
&= ~DF_TEXTREL
;
9796 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTGOT
, 0))
9799 sreldyn
= mips_elf_rel_dyn_section (info
, FALSE
);
9800 if (htab
->is_vxworks
)
9802 /* VxWorks uses .rela.dyn instead of .rel.dyn. It does not
9803 use any of the DT_MIPS_* tags. */
9804 if (sreldyn
&& sreldyn
->size
> 0)
9806 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELA
, 0))
9809 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELASZ
, 0))
9812 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELAENT
, 0))
9818 if (sreldyn
&& sreldyn
->size
> 0)
9820 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_REL
, 0))
9823 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELSZ
, 0))
9826 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELENT
, 0))
9830 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_VERSION
, 0))
9833 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_FLAGS
, 0))
9836 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_BASE_ADDRESS
, 0))
9839 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LOCAL_GOTNO
, 0))
9842 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_SYMTABNO
, 0))
9845 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_UNREFEXTNO
, 0))
9848 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_GOTSYM
, 0))
9851 if (IRIX_COMPAT (dynobj
) == ict_irix5
9852 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_HIPAGENO
, 0))
9855 if (IRIX_COMPAT (dynobj
) == ict_irix6
9856 && (bfd_get_section_by_name
9857 (output_bfd
, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj
)))
9858 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_OPTIONS
, 0))
9861 if (htab
->splt
->size
> 0)
9863 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTREL
, 0))
9866 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_JMPREL
, 0))
9869 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTRELSZ
, 0))
9872 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_PLTGOT
, 0))
9875 if (htab
->is_vxworks
9876 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
9883 /* REL is a relocation in INPUT_BFD that is being copied to OUTPUT_BFD.
9884 Adjust its R_ADDEND field so that it is correct for the output file.
9885 LOCAL_SYMS and LOCAL_SECTIONS are arrays of INPUT_BFD's local symbols
9886 and sections respectively; both use symbol indexes. */
9889 mips_elf_adjust_addend (bfd
*output_bfd
, struct bfd_link_info
*info
,
9890 bfd
*input_bfd
, Elf_Internal_Sym
*local_syms
,
9891 asection
**local_sections
, Elf_Internal_Rela
*rel
)
9893 unsigned int r_type
, r_symndx
;
9894 Elf_Internal_Sym
*sym
;
9897 if (mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
))
9899 r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
9900 if (gprel16_reloc_p (r_type
)
9901 || r_type
== R_MIPS_GPREL32
9902 || literal_reloc_p (r_type
))
9904 rel
->r_addend
+= _bfd_get_gp_value (input_bfd
);
9905 rel
->r_addend
-= _bfd_get_gp_value (output_bfd
);
9908 r_symndx
= ELF_R_SYM (output_bfd
, rel
->r_info
);
9909 sym
= local_syms
+ r_symndx
;
9911 /* Adjust REL's addend to account for section merging. */
9912 if (!bfd_link_relocatable (info
))
9914 sec
= local_sections
[r_symndx
];
9915 _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
9918 /* This would normally be done by the rela_normal code in elflink.c. */
9919 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
9920 rel
->r_addend
+= local_sections
[r_symndx
]->output_offset
;
9924 /* Handle relocations against symbols from removed linkonce sections,
9925 or sections discarded by a linker script. We use this wrapper around
9926 RELOC_AGAINST_DISCARDED_SECTION to handle triplets of compound relocs
9927 on 64-bit ELF targets. In this case for any relocation handled, which
9928 always be the first in a triplet, the remaining two have to be processed
9929 together with the first, even if they are R_MIPS_NONE. It is the symbol
9930 index referred by the first reloc that applies to all the three and the
9931 remaining two never refer to an object symbol. And it is the final
9932 relocation (the last non-null one) that determines the output field of
9933 the whole relocation so retrieve the corresponding howto structure for
9934 the relocatable field to be cleared by RELOC_AGAINST_DISCARDED_SECTION.
9936 Note that RELOC_AGAINST_DISCARDED_SECTION is a macro that uses "continue"
9937 and therefore requires to be pasted in a loop. It also defines a block
9938 and does not protect any of its arguments, hence the extra brackets. */
9941 mips_reloc_against_discarded_section (bfd
*output_bfd
,
9942 struct bfd_link_info
*info
,
9943 bfd
*input_bfd
, asection
*input_section
,
9944 Elf_Internal_Rela
**rel
,
9945 const Elf_Internal_Rela
**relend
,
9946 bfd_boolean rel_reloc
,
9947 reloc_howto_type
*howto
,
9950 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
9951 int count
= bed
->s
->int_rels_per_ext_rel
;
9952 unsigned int r_type
;
9955 for (i
= count
- 1; i
> 0; i
--)
9957 r_type
= ELF_R_TYPE (output_bfd
, (*rel
)[i
].r_info
);
9958 if (r_type
!= R_MIPS_NONE
)
9960 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, r_type
, !rel_reloc
);
9966 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
9967 (*rel
), count
, (*relend
),
9968 howto
, i
, contents
);
9973 /* Relocate a MIPS ELF section. */
9976 _bfd_mips_elf_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
9977 bfd
*input_bfd
, asection
*input_section
,
9978 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
9979 Elf_Internal_Sym
*local_syms
,
9980 asection
**local_sections
)
9982 Elf_Internal_Rela
*rel
;
9983 const Elf_Internal_Rela
*relend
;
9985 bfd_boolean use_saved_addend_p
= FALSE
;
9986 const struct elf_backend_data
*bed
;
9988 bed
= get_elf_backend_data (output_bfd
);
9989 relend
= relocs
+ input_section
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
9990 for (rel
= relocs
; rel
< relend
; ++rel
)
9994 reloc_howto_type
*howto
;
9995 bfd_boolean cross_mode_jump_p
= FALSE
;
9996 /* TRUE if the relocation is a RELA relocation, rather than a
9998 bfd_boolean rela_relocation_p
= TRUE
;
9999 unsigned int r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
10001 unsigned long r_symndx
;
10003 Elf_Internal_Shdr
*symtab_hdr
;
10004 struct elf_link_hash_entry
*h
;
10005 bfd_boolean rel_reloc
;
10007 rel_reloc
= (NEWABI_P (input_bfd
)
10008 && mips_elf_rel_relocation_p (input_bfd
, input_section
,
10010 /* Find the relocation howto for this relocation. */
10011 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, r_type
, !rel_reloc
);
10013 r_symndx
= ELF_R_SYM (input_bfd
, rel
->r_info
);
10014 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
10015 if (mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
))
10017 sec
= local_sections
[r_symndx
];
10022 unsigned long extsymoff
;
10025 if (!elf_bad_symtab (input_bfd
))
10026 extsymoff
= symtab_hdr
->sh_info
;
10027 h
= elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
];
10028 while (h
->root
.type
== bfd_link_hash_indirect
10029 || h
->root
.type
== bfd_link_hash_warning
)
10030 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
10033 if (h
->root
.type
== bfd_link_hash_defined
10034 || h
->root
.type
== bfd_link_hash_defweak
)
10035 sec
= h
->root
.u
.def
.section
;
10038 if (sec
!= NULL
&& discarded_section (sec
))
10040 mips_reloc_against_discarded_section (output_bfd
, info
, input_bfd
,
10041 input_section
, &rel
, &relend
,
10042 rel_reloc
, howto
, contents
);
10046 if (r_type
== R_MIPS_64
&& ! NEWABI_P (input_bfd
))
10048 /* Some 32-bit code uses R_MIPS_64. In particular, people use
10049 64-bit code, but make sure all their addresses are in the
10050 lowermost or uppermost 32-bit section of the 64-bit address
10051 space. Thus, when they use an R_MIPS_64 they mean what is
10052 usually meant by R_MIPS_32, with the exception that the
10053 stored value is sign-extended to 64 bits. */
10054 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, R_MIPS_32
, FALSE
);
10056 /* On big-endian systems, we need to lie about the position
10058 if (bfd_big_endian (input_bfd
))
10059 rel
->r_offset
+= 4;
10062 if (!use_saved_addend_p
)
10064 /* If these relocations were originally of the REL variety,
10065 we must pull the addend out of the field that will be
10066 relocated. Otherwise, we simply use the contents of the
10067 RELA relocation. */
10068 if (mips_elf_rel_relocation_p (input_bfd
, input_section
,
10071 rela_relocation_p
= FALSE
;
10072 addend
= mips_elf_read_rel_addend (input_bfd
, rel
,
10074 if (hi16_reloc_p (r_type
)
10075 || (got16_reloc_p (r_type
)
10076 && mips_elf_local_relocation_p (input_bfd
, rel
,
10079 if (!mips_elf_add_lo16_rel_addend (input_bfd
, rel
, relend
,
10080 contents
, &addend
))
10083 name
= h
->root
.root
.string
;
10085 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
10086 local_syms
+ r_symndx
,
10088 (*_bfd_error_handler
)
10089 (_("%B: Can't find matching LO16 reloc against `%s' for %s at 0x%lx in section `%A'"),
10090 input_bfd
, input_section
, name
, howto
->name
,
10095 addend
<<= howto
->rightshift
;
10098 addend
= rel
->r_addend
;
10099 mips_elf_adjust_addend (output_bfd
, info
, input_bfd
,
10100 local_syms
, local_sections
, rel
);
10103 if (bfd_link_relocatable (info
))
10105 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
)
10106 && bfd_big_endian (input_bfd
))
10107 rel
->r_offset
-= 4;
10109 if (!rela_relocation_p
&& rel
->r_addend
)
10111 addend
+= rel
->r_addend
;
10112 if (hi16_reloc_p (r_type
) || got16_reloc_p (r_type
))
10113 addend
= mips_elf_high (addend
);
10114 else if (r_type
== R_MIPS_HIGHER
)
10115 addend
= mips_elf_higher (addend
);
10116 else if (r_type
== R_MIPS_HIGHEST
)
10117 addend
= mips_elf_highest (addend
);
10119 addend
>>= howto
->rightshift
;
10121 /* We use the source mask, rather than the destination
10122 mask because the place to which we are writing will be
10123 source of the addend in the final link. */
10124 addend
&= howto
->src_mask
;
10126 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
10127 /* See the comment above about using R_MIPS_64 in the 32-bit
10128 ABI. Here, we need to update the addend. It would be
10129 possible to get away with just using the R_MIPS_32 reloc
10130 but for endianness. */
10136 if (addend
& ((bfd_vma
) 1 << 31))
10138 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
10145 /* If we don't know that we have a 64-bit type,
10146 do two separate stores. */
10147 if (bfd_big_endian (input_bfd
))
10149 /* Store the sign-bits (which are most significant)
10151 low_bits
= sign_bits
;
10152 high_bits
= addend
;
10157 high_bits
= sign_bits
;
10159 bfd_put_32 (input_bfd
, low_bits
,
10160 contents
+ rel
->r_offset
);
10161 bfd_put_32 (input_bfd
, high_bits
,
10162 contents
+ rel
->r_offset
+ 4);
10166 if (! mips_elf_perform_relocation (info
, howto
, rel
, addend
,
10167 input_bfd
, input_section
,
10172 /* Go on to the next relocation. */
10176 /* In the N32 and 64-bit ABIs there may be multiple consecutive
10177 relocations for the same offset. In that case we are
10178 supposed to treat the output of each relocation as the addend
10180 if (rel
+ 1 < relend
10181 && rel
->r_offset
== rel
[1].r_offset
10182 && ELF_R_TYPE (input_bfd
, rel
[1].r_info
) != R_MIPS_NONE
)
10183 use_saved_addend_p
= TRUE
;
10185 use_saved_addend_p
= FALSE
;
10187 /* Figure out what value we are supposed to relocate. */
10188 switch (mips_elf_calculate_relocation (output_bfd
, input_bfd
,
10189 input_section
, info
, rel
,
10190 addend
, howto
, local_syms
,
10191 local_sections
, &value
,
10192 &name
, &cross_mode_jump_p
,
10193 use_saved_addend_p
))
10195 case bfd_reloc_continue
:
10196 /* There's nothing to do. */
10199 case bfd_reloc_undefined
:
10200 /* mips_elf_calculate_relocation already called the
10201 undefined_symbol callback. There's no real point in
10202 trying to perform the relocation at this point, so we
10203 just skip ahead to the next relocation. */
10206 case bfd_reloc_notsupported
:
10207 msg
= _("internal error: unsupported relocation error");
10208 info
->callbacks
->warning
10209 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
10212 case bfd_reloc_overflow
:
10213 if (use_saved_addend_p
)
10214 /* Ignore overflow until we reach the last relocation for
10215 a given location. */
10219 struct mips_elf_link_hash_table
*htab
;
10221 htab
= mips_elf_hash_table (info
);
10222 BFD_ASSERT (htab
!= NULL
);
10223 BFD_ASSERT (name
!= NULL
);
10224 if (!htab
->small_data_overflow_reported
10225 && (gprel16_reloc_p (howto
->type
)
10226 || literal_reloc_p (howto
->type
)))
10228 msg
= _("small-data section exceeds 64KB;"
10229 " lower small-data size limit (see option -G)");
10231 htab
->small_data_overflow_reported
= TRUE
;
10232 (*info
->callbacks
->einfo
) ("%P: %s\n", msg
);
10234 if (! ((*info
->callbacks
->reloc_overflow
)
10235 (info
, NULL
, name
, howto
->name
, (bfd_vma
) 0,
10236 input_bfd
, input_section
, rel
->r_offset
)))
10244 case bfd_reloc_outofrange
:
10245 if (jal_reloc_p (howto
->type
))
10247 msg
= _("JALX to a non-word-aligned address");
10248 info
->callbacks
->warning
10249 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
10252 if (aligned_pcrel_reloc_p (howto
->type
))
10254 msg
= _("PC-relative load from unaligned address");
10255 info
->callbacks
->warning
10256 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
10259 /* Fall through. */
10266 /* If we've got another relocation for the address, keep going
10267 until we reach the last one. */
10268 if (use_saved_addend_p
)
10274 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
10275 /* See the comment above about using R_MIPS_64 in the 32-bit
10276 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
10277 that calculated the right value. Now, however, we
10278 sign-extend the 32-bit result to 64-bits, and store it as a
10279 64-bit value. We are especially generous here in that we
10280 go to extreme lengths to support this usage on systems with
10281 only a 32-bit VMA. */
10287 if (value
& ((bfd_vma
) 1 << 31))
10289 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
10296 /* If we don't know that we have a 64-bit type,
10297 do two separate stores. */
10298 if (bfd_big_endian (input_bfd
))
10300 /* Undo what we did above. */
10301 rel
->r_offset
-= 4;
10302 /* Store the sign-bits (which are most significant)
10304 low_bits
= sign_bits
;
10310 high_bits
= sign_bits
;
10312 bfd_put_32 (input_bfd
, low_bits
,
10313 contents
+ rel
->r_offset
);
10314 bfd_put_32 (input_bfd
, high_bits
,
10315 contents
+ rel
->r_offset
+ 4);
10319 /* Actually perform the relocation. */
10320 if (! mips_elf_perform_relocation (info
, howto
, rel
, value
,
10321 input_bfd
, input_section
,
10322 contents
, cross_mode_jump_p
))
10329 /* A function that iterates over each entry in la25_stubs and fills
10330 in the code for each one. DATA points to a mips_htab_traverse_info. */
10333 mips_elf_create_la25_stub (void **slot
, void *data
)
10335 struct mips_htab_traverse_info
*hti
;
10336 struct mips_elf_link_hash_table
*htab
;
10337 struct mips_elf_la25_stub
*stub
;
10340 bfd_vma offset
, target
, target_high
, target_low
;
10342 stub
= (struct mips_elf_la25_stub
*) *slot
;
10343 hti
= (struct mips_htab_traverse_info
*) data
;
10344 htab
= mips_elf_hash_table (hti
->info
);
10345 BFD_ASSERT (htab
!= NULL
);
10347 /* Create the section contents, if we haven't already. */
10348 s
= stub
->stub_section
;
10352 loc
= bfd_malloc (s
->size
);
10361 /* Work out where in the section this stub should go. */
10362 offset
= stub
->offset
;
10364 /* Work out the target address. */
10365 target
= mips_elf_get_la25_target (stub
, &s
);
10366 target
+= s
->output_section
->vma
+ s
->output_offset
;
10368 target_high
= ((target
+ 0x8000) >> 16) & 0xffff;
10369 target_low
= (target
& 0xffff);
10371 if (stub
->stub_section
!= htab
->strampoline
)
10373 /* This is a simple LUI/ADDIU stub. Zero out the beginning
10374 of the section and write the two instructions at the end. */
10375 memset (loc
, 0, offset
);
10377 if (ELF_ST_IS_MICROMIPS (stub
->h
->root
.other
))
10379 bfd_put_micromips_32 (hti
->output_bfd
,
10380 LA25_LUI_MICROMIPS (target_high
),
10382 bfd_put_micromips_32 (hti
->output_bfd
,
10383 LA25_ADDIU_MICROMIPS (target_low
),
10388 bfd_put_32 (hti
->output_bfd
, LA25_LUI (target_high
), loc
);
10389 bfd_put_32 (hti
->output_bfd
, LA25_ADDIU (target_low
), loc
+ 4);
10394 /* This is trampoline. */
10396 if (ELF_ST_IS_MICROMIPS (stub
->h
->root
.other
))
10398 bfd_put_micromips_32 (hti
->output_bfd
,
10399 LA25_LUI_MICROMIPS (target_high
), loc
);
10400 bfd_put_micromips_32 (hti
->output_bfd
,
10401 LA25_J_MICROMIPS (target
), loc
+ 4);
10402 bfd_put_micromips_32 (hti
->output_bfd
,
10403 LA25_ADDIU_MICROMIPS (target_low
), loc
+ 8);
10404 bfd_put_32 (hti
->output_bfd
, 0, loc
+ 12);
10408 bfd_put_32 (hti
->output_bfd
, LA25_LUI (target_high
), loc
);
10409 bfd_put_32 (hti
->output_bfd
, LA25_J (target
), loc
+ 4);
10410 bfd_put_32 (hti
->output_bfd
, LA25_ADDIU (target_low
), loc
+ 8);
10411 bfd_put_32 (hti
->output_bfd
, 0, loc
+ 12);
10417 /* If NAME is one of the special IRIX6 symbols defined by the linker,
10418 adjust it appropriately now. */
10421 mips_elf_irix6_finish_dynamic_symbol (bfd
*abfd ATTRIBUTE_UNUSED
,
10422 const char *name
, Elf_Internal_Sym
*sym
)
10424 /* The linker script takes care of providing names and values for
10425 these, but we must place them into the right sections. */
10426 static const char* const text_section_symbols
[] = {
10429 "__dso_displacement",
10431 "__program_header_table",
10435 static const char* const data_section_symbols
[] = {
10443 const char* const *p
;
10446 for (i
= 0; i
< 2; ++i
)
10447 for (p
= (i
== 0) ? text_section_symbols
: data_section_symbols
;
10450 if (strcmp (*p
, name
) == 0)
10452 /* All of these symbols are given type STT_SECTION by the
10454 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
10455 sym
->st_other
= STO_PROTECTED
;
10457 /* The IRIX linker puts these symbols in special sections. */
10459 sym
->st_shndx
= SHN_MIPS_TEXT
;
10461 sym
->st_shndx
= SHN_MIPS_DATA
;
10467 /* Finish up dynamic symbol handling. We set the contents of various
10468 dynamic sections here. */
10471 _bfd_mips_elf_finish_dynamic_symbol (bfd
*output_bfd
,
10472 struct bfd_link_info
*info
,
10473 struct elf_link_hash_entry
*h
,
10474 Elf_Internal_Sym
*sym
)
10478 struct mips_got_info
*g
, *gg
;
10481 struct mips_elf_link_hash_table
*htab
;
10482 struct mips_elf_link_hash_entry
*hmips
;
10484 htab
= mips_elf_hash_table (info
);
10485 BFD_ASSERT (htab
!= NULL
);
10486 dynobj
= elf_hash_table (info
)->dynobj
;
10487 hmips
= (struct mips_elf_link_hash_entry
*) h
;
10489 BFD_ASSERT (!htab
->is_vxworks
);
10491 if (h
->plt
.plist
!= NULL
10492 && (h
->plt
.plist
->mips_offset
!= MINUS_ONE
10493 || h
->plt
.plist
->comp_offset
!= MINUS_ONE
))
10495 /* We've decided to create a PLT entry for this symbol. */
10497 bfd_vma header_address
, got_address
;
10498 bfd_vma got_address_high
, got_address_low
, load
;
10502 got_index
= h
->plt
.plist
->gotplt_index
;
10504 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
10505 BFD_ASSERT (h
->dynindx
!= -1);
10506 BFD_ASSERT (htab
->splt
!= NULL
);
10507 BFD_ASSERT (got_index
!= MINUS_ONE
);
10508 BFD_ASSERT (!h
->def_regular
);
10510 /* Calculate the address of the PLT header. */
10511 isa_bit
= htab
->plt_header_is_comp
;
10512 header_address
= (htab
->splt
->output_section
->vma
10513 + htab
->splt
->output_offset
+ isa_bit
);
10515 /* Calculate the address of the .got.plt entry. */
10516 got_address
= (htab
->sgotplt
->output_section
->vma
10517 + htab
->sgotplt
->output_offset
10518 + got_index
* MIPS_ELF_GOT_SIZE (dynobj
));
10520 got_address_high
= ((got_address
+ 0x8000) >> 16) & 0xffff;
10521 got_address_low
= got_address
& 0xffff;
10523 /* Initially point the .got.plt entry at the PLT header. */
10524 loc
= (htab
->sgotplt
->contents
+ got_index
* MIPS_ELF_GOT_SIZE (dynobj
));
10525 if (ABI_64_P (output_bfd
))
10526 bfd_put_64 (output_bfd
, header_address
, loc
);
10528 bfd_put_32 (output_bfd
, header_address
, loc
);
10530 /* Now handle the PLT itself. First the standard entry (the order
10531 does not matter, we just have to pick one). */
10532 if (h
->plt
.plist
->mips_offset
!= MINUS_ONE
)
10534 const bfd_vma
*plt_entry
;
10535 bfd_vma plt_offset
;
10537 plt_offset
= htab
->plt_header_size
+ h
->plt
.plist
->mips_offset
;
10539 BFD_ASSERT (plt_offset
<= htab
->splt
->size
);
10541 /* Find out where the .plt entry should go. */
10542 loc
= htab
->splt
->contents
+ plt_offset
;
10544 /* Pick the load opcode. */
10545 load
= MIPS_ELF_LOAD_WORD (output_bfd
);
10547 /* Fill in the PLT entry itself. */
10549 if (MIPSR6_P (output_bfd
))
10550 plt_entry
= mipsr6_exec_plt_entry
;
10552 plt_entry
= mips_exec_plt_entry
;
10553 bfd_put_32 (output_bfd
, plt_entry
[0] | got_address_high
, loc
);
10554 bfd_put_32 (output_bfd
, plt_entry
[1] | got_address_low
| load
,
10557 if (! LOAD_INTERLOCKS_P (output_bfd
))
10559 bfd_put_32 (output_bfd
, plt_entry
[2] | got_address_low
, loc
+ 8);
10560 bfd_put_32 (output_bfd
, plt_entry
[3], loc
+ 12);
10564 bfd_put_32 (output_bfd
, plt_entry
[3], loc
+ 8);
10565 bfd_put_32 (output_bfd
, plt_entry
[2] | got_address_low
,
10570 /* Now the compressed entry. They come after any standard ones. */
10571 if (h
->plt
.plist
->comp_offset
!= MINUS_ONE
)
10573 bfd_vma plt_offset
;
10575 plt_offset
= (htab
->plt_header_size
+ htab
->plt_mips_offset
10576 + h
->plt
.plist
->comp_offset
);
10578 BFD_ASSERT (plt_offset
<= htab
->splt
->size
);
10580 /* Find out where the .plt entry should go. */
10581 loc
= htab
->splt
->contents
+ plt_offset
;
10583 /* Fill in the PLT entry itself. */
10584 if (!MICROMIPS_P (output_bfd
))
10586 const bfd_vma
*plt_entry
= mips16_o32_exec_plt_entry
;
10588 bfd_put_16 (output_bfd
, plt_entry
[0], loc
);
10589 bfd_put_16 (output_bfd
, plt_entry
[1], loc
+ 2);
10590 bfd_put_16 (output_bfd
, plt_entry
[2], loc
+ 4);
10591 bfd_put_16 (output_bfd
, plt_entry
[3], loc
+ 6);
10592 bfd_put_16 (output_bfd
, plt_entry
[4], loc
+ 8);
10593 bfd_put_16 (output_bfd
, plt_entry
[5], loc
+ 10);
10594 bfd_put_32 (output_bfd
, got_address
, loc
+ 12);
10596 else if (htab
->insn32
)
10598 const bfd_vma
*plt_entry
= micromips_insn32_o32_exec_plt_entry
;
10600 bfd_put_16 (output_bfd
, plt_entry
[0], loc
);
10601 bfd_put_16 (output_bfd
, got_address_high
, loc
+ 2);
10602 bfd_put_16 (output_bfd
, plt_entry
[2], loc
+ 4);
10603 bfd_put_16 (output_bfd
, got_address_low
, loc
+ 6);
10604 bfd_put_16 (output_bfd
, plt_entry
[4], loc
+ 8);
10605 bfd_put_16 (output_bfd
, plt_entry
[5], loc
+ 10);
10606 bfd_put_16 (output_bfd
, plt_entry
[6], loc
+ 12);
10607 bfd_put_16 (output_bfd
, got_address_low
, loc
+ 14);
10611 const bfd_vma
*plt_entry
= micromips_o32_exec_plt_entry
;
10612 bfd_signed_vma gotpc_offset
;
10613 bfd_vma loc_address
;
10615 BFD_ASSERT (got_address
% 4 == 0);
10617 loc_address
= (htab
->splt
->output_section
->vma
10618 + htab
->splt
->output_offset
+ plt_offset
);
10619 gotpc_offset
= got_address
- ((loc_address
| 3) ^ 3);
10621 /* ADDIUPC has a span of +/-16MB, check we're in range. */
10622 if (gotpc_offset
+ 0x1000000 >= 0x2000000)
10624 (*_bfd_error_handler
)
10625 (_("%B: `%A' offset of %ld from `%A' "
10626 "beyond the range of ADDIUPC"),
10628 htab
->sgotplt
->output_section
,
10629 htab
->splt
->output_section
,
10630 (long) gotpc_offset
);
10631 bfd_set_error (bfd_error_no_error
);
10634 bfd_put_16 (output_bfd
,
10635 plt_entry
[0] | ((gotpc_offset
>> 18) & 0x7f), loc
);
10636 bfd_put_16 (output_bfd
, (gotpc_offset
>> 2) & 0xffff, loc
+ 2);
10637 bfd_put_16 (output_bfd
, plt_entry
[2], loc
+ 4);
10638 bfd_put_16 (output_bfd
, plt_entry
[3], loc
+ 6);
10639 bfd_put_16 (output_bfd
, plt_entry
[4], loc
+ 8);
10640 bfd_put_16 (output_bfd
, plt_entry
[5], loc
+ 10);
10644 /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry. */
10645 mips_elf_output_dynamic_relocation (output_bfd
, htab
->srelplt
,
10646 got_index
- 2, h
->dynindx
,
10647 R_MIPS_JUMP_SLOT
, got_address
);
10649 /* We distinguish between PLT entries and lazy-binding stubs by
10650 giving the former an st_other value of STO_MIPS_PLT. Set the
10651 flag and leave the value if there are any relocations in the
10652 binary where pointer equality matters. */
10653 sym
->st_shndx
= SHN_UNDEF
;
10654 if (h
->pointer_equality_needed
)
10655 sym
->st_other
= ELF_ST_SET_MIPS_PLT (sym
->st_other
);
10663 if (h
->plt
.plist
!= NULL
&& h
->plt
.plist
->stub_offset
!= MINUS_ONE
)
10665 /* We've decided to create a lazy-binding stub. */
10666 bfd_boolean micromips_p
= MICROMIPS_P (output_bfd
);
10667 unsigned int other
= micromips_p
? STO_MICROMIPS
: 0;
10668 bfd_vma stub_size
= htab
->function_stub_size
;
10669 bfd_byte stub
[MIPS_FUNCTION_STUB_BIG_SIZE
];
10670 bfd_vma isa_bit
= micromips_p
;
10671 bfd_vma stub_big_size
;
10674 stub_big_size
= MIPS_FUNCTION_STUB_BIG_SIZE
;
10675 else if (htab
->insn32
)
10676 stub_big_size
= MICROMIPS_INSN32_FUNCTION_STUB_BIG_SIZE
;
10678 stub_big_size
= MICROMIPS_FUNCTION_STUB_BIG_SIZE
;
10680 /* This symbol has a stub. Set it up. */
10682 BFD_ASSERT (h
->dynindx
!= -1);
10684 BFD_ASSERT (stub_size
== stub_big_size
|| h
->dynindx
<= 0xffff);
10686 /* Values up to 2^31 - 1 are allowed. Larger values would cause
10687 sign extension at runtime in the stub, resulting in a negative
10689 if (h
->dynindx
& ~0x7fffffff)
10692 /* Fill the stub. */
10696 bfd_put_micromips_32 (output_bfd
, STUB_LW_MICROMIPS (output_bfd
),
10701 bfd_put_micromips_32 (output_bfd
,
10702 STUB_MOVE32_MICROMIPS
, stub
+ idx
);
10707 bfd_put_16 (output_bfd
, STUB_MOVE_MICROMIPS
, stub
+ idx
);
10710 if (stub_size
== stub_big_size
)
10712 long dynindx_hi
= (h
->dynindx
>> 16) & 0x7fff;
10714 bfd_put_micromips_32 (output_bfd
,
10715 STUB_LUI_MICROMIPS (dynindx_hi
),
10721 bfd_put_micromips_32 (output_bfd
, STUB_JALR32_MICROMIPS
,
10727 bfd_put_16 (output_bfd
, STUB_JALR_MICROMIPS
, stub
+ idx
);
10731 /* If a large stub is not required and sign extension is not a
10732 problem, then use legacy code in the stub. */
10733 if (stub_size
== stub_big_size
)
10734 bfd_put_micromips_32 (output_bfd
,
10735 STUB_ORI_MICROMIPS (h
->dynindx
& 0xffff),
10737 else if (h
->dynindx
& ~0x7fff)
10738 bfd_put_micromips_32 (output_bfd
,
10739 STUB_LI16U_MICROMIPS (h
->dynindx
& 0xffff),
10742 bfd_put_micromips_32 (output_bfd
,
10743 STUB_LI16S_MICROMIPS (output_bfd
,
10750 bfd_put_32 (output_bfd
, STUB_LW (output_bfd
), stub
+ idx
);
10752 bfd_put_32 (output_bfd
, STUB_MOVE
, stub
+ idx
);
10754 if (stub_size
== stub_big_size
)
10756 bfd_put_32 (output_bfd
, STUB_LUI ((h
->dynindx
>> 16) & 0x7fff),
10760 bfd_put_32 (output_bfd
, STUB_JALR
, stub
+ idx
);
10763 /* If a large stub is not required and sign extension is not a
10764 problem, then use legacy code in the stub. */
10765 if (stub_size
== stub_big_size
)
10766 bfd_put_32 (output_bfd
, STUB_ORI (h
->dynindx
& 0xffff),
10768 else if (h
->dynindx
& ~0x7fff)
10769 bfd_put_32 (output_bfd
, STUB_LI16U (h
->dynindx
& 0xffff),
10772 bfd_put_32 (output_bfd
, STUB_LI16S (output_bfd
, h
->dynindx
),
10776 BFD_ASSERT (h
->plt
.plist
->stub_offset
<= htab
->sstubs
->size
);
10777 memcpy (htab
->sstubs
->contents
+ h
->plt
.plist
->stub_offset
,
10780 /* Mark the symbol as undefined. stub_offset != -1 occurs
10781 only for the referenced symbol. */
10782 sym
->st_shndx
= SHN_UNDEF
;
10784 /* The run-time linker uses the st_value field of the symbol
10785 to reset the global offset table entry for this external
10786 to its stub address when unlinking a shared object. */
10787 sym
->st_value
= (htab
->sstubs
->output_section
->vma
10788 + htab
->sstubs
->output_offset
10789 + h
->plt
.plist
->stub_offset
10791 sym
->st_other
= other
;
10794 /* If we have a MIPS16 function with a stub, the dynamic symbol must
10795 refer to the stub, since only the stub uses the standard calling
10797 if (h
->dynindx
!= -1 && hmips
->fn_stub
!= NULL
)
10799 BFD_ASSERT (hmips
->need_fn_stub
);
10800 sym
->st_value
= (hmips
->fn_stub
->output_section
->vma
10801 + hmips
->fn_stub
->output_offset
);
10802 sym
->st_size
= hmips
->fn_stub
->size
;
10803 sym
->st_other
= ELF_ST_VISIBILITY (sym
->st_other
);
10806 BFD_ASSERT (h
->dynindx
!= -1
10807 || h
->forced_local
);
10810 g
= htab
->got_info
;
10811 BFD_ASSERT (g
!= NULL
);
10813 /* Run through the global symbol table, creating GOT entries for all
10814 the symbols that need them. */
10815 if (hmips
->global_got_area
!= GGA_NONE
)
10820 value
= sym
->st_value
;
10821 offset
= mips_elf_primary_global_got_index (output_bfd
, info
, h
);
10822 MIPS_ELF_PUT_WORD (output_bfd
, value
, sgot
->contents
+ offset
);
10825 if (hmips
->global_got_area
!= GGA_NONE
&& g
->next
)
10827 struct mips_got_entry e
, *p
;
10833 e
.abfd
= output_bfd
;
10836 e
.tls_type
= GOT_TLS_NONE
;
10838 for (g
= g
->next
; g
->next
!= gg
; g
= g
->next
)
10841 && (p
= (struct mips_got_entry
*) htab_find (g
->got_entries
,
10844 offset
= p
->gotidx
;
10845 BFD_ASSERT (offset
> 0 && offset
< htab
->sgot
->size
);
10846 if (bfd_link_pic (info
)
10847 || (elf_hash_table (info
)->dynamic_sections_created
10849 && p
->d
.h
->root
.def_dynamic
10850 && !p
->d
.h
->root
.def_regular
))
10852 /* Create an R_MIPS_REL32 relocation for this entry. Due to
10853 the various compatibility problems, it's easier to mock
10854 up an R_MIPS_32 or R_MIPS_64 relocation and leave
10855 mips_elf_create_dynamic_relocation to calculate the
10856 appropriate addend. */
10857 Elf_Internal_Rela rel
[3];
10859 memset (rel
, 0, sizeof (rel
));
10860 if (ABI_64_P (output_bfd
))
10861 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_64
);
10863 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_32
);
10864 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
10867 if (! (mips_elf_create_dynamic_relocation
10868 (output_bfd
, info
, rel
,
10869 e
.d
.h
, NULL
, sym
->st_value
, &entry
, sgot
)))
10873 entry
= sym
->st_value
;
10874 MIPS_ELF_PUT_WORD (output_bfd
, entry
, sgot
->contents
+ offset
);
10879 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
10880 name
= h
->root
.root
.string
;
10881 if (h
== elf_hash_table (info
)->hdynamic
10882 || h
== elf_hash_table (info
)->hgot
)
10883 sym
->st_shndx
= SHN_ABS
;
10884 else if (strcmp (name
, "_DYNAMIC_LINK") == 0
10885 || strcmp (name
, "_DYNAMIC_LINKING") == 0)
10887 sym
->st_shndx
= SHN_ABS
;
10888 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
10891 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (output_bfd
))
10893 sym
->st_shndx
= SHN_ABS
;
10894 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
10895 sym
->st_value
= elf_gp (output_bfd
);
10897 else if (SGI_COMPAT (output_bfd
))
10899 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
10900 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
10902 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
10903 sym
->st_other
= STO_PROTECTED
;
10905 sym
->st_shndx
= SHN_MIPS_DATA
;
10907 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
10909 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
10910 sym
->st_other
= STO_PROTECTED
;
10911 sym
->st_value
= mips_elf_hash_table (info
)->procedure_count
;
10912 sym
->st_shndx
= SHN_ABS
;
10914 else if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
!= SHN_ABS
)
10916 if (h
->type
== STT_FUNC
)
10917 sym
->st_shndx
= SHN_MIPS_TEXT
;
10918 else if (h
->type
== STT_OBJECT
)
10919 sym
->st_shndx
= SHN_MIPS_DATA
;
10923 /* Emit a copy reloc, if needed. */
10929 BFD_ASSERT (h
->dynindx
!= -1);
10930 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
10932 s
= mips_elf_rel_dyn_section (info
, FALSE
);
10933 symval
= (h
->root
.u
.def
.section
->output_section
->vma
10934 + h
->root
.u
.def
.section
->output_offset
10935 + h
->root
.u
.def
.value
);
10936 mips_elf_output_dynamic_relocation (output_bfd
, s
, s
->reloc_count
++,
10937 h
->dynindx
, R_MIPS_COPY
, symval
);
10940 /* Handle the IRIX6-specific symbols. */
10941 if (IRIX_COMPAT (output_bfd
) == ict_irix6
)
10942 mips_elf_irix6_finish_dynamic_symbol (output_bfd
, name
, sym
);
10944 /* Keep dynamic compressed symbols odd. This allows the dynamic linker
10945 to treat compressed symbols like any other. */
10946 if (ELF_ST_IS_MIPS16 (sym
->st_other
))
10948 BFD_ASSERT (sym
->st_value
& 1);
10949 sym
->st_other
-= STO_MIPS16
;
10951 else if (ELF_ST_IS_MICROMIPS (sym
->st_other
))
10953 BFD_ASSERT (sym
->st_value
& 1);
10954 sym
->st_other
-= STO_MICROMIPS
;
10960 /* Likewise, for VxWorks. */
10963 _bfd_mips_vxworks_finish_dynamic_symbol (bfd
*output_bfd
,
10964 struct bfd_link_info
*info
,
10965 struct elf_link_hash_entry
*h
,
10966 Elf_Internal_Sym
*sym
)
10970 struct mips_got_info
*g
;
10971 struct mips_elf_link_hash_table
*htab
;
10972 struct mips_elf_link_hash_entry
*hmips
;
10974 htab
= mips_elf_hash_table (info
);
10975 BFD_ASSERT (htab
!= NULL
);
10976 dynobj
= elf_hash_table (info
)->dynobj
;
10977 hmips
= (struct mips_elf_link_hash_entry
*) h
;
10979 if (h
->plt
.plist
!= NULL
&& h
->plt
.plist
->mips_offset
!= MINUS_ONE
)
10982 bfd_vma plt_address
, got_address
, got_offset
, branch_offset
;
10983 Elf_Internal_Rela rel
;
10984 static const bfd_vma
*plt_entry
;
10985 bfd_vma gotplt_index
;
10986 bfd_vma plt_offset
;
10988 plt_offset
= htab
->plt_header_size
+ h
->plt
.plist
->mips_offset
;
10989 gotplt_index
= h
->plt
.plist
->gotplt_index
;
10991 BFD_ASSERT (h
->dynindx
!= -1);
10992 BFD_ASSERT (htab
->splt
!= NULL
);
10993 BFD_ASSERT (gotplt_index
!= MINUS_ONE
);
10994 BFD_ASSERT (plt_offset
<= htab
->splt
->size
);
10996 /* Calculate the address of the .plt entry. */
10997 plt_address
= (htab
->splt
->output_section
->vma
10998 + htab
->splt
->output_offset
11001 /* Calculate the address of the .got.plt entry. */
11002 got_address
= (htab
->sgotplt
->output_section
->vma
11003 + htab
->sgotplt
->output_offset
11004 + gotplt_index
* MIPS_ELF_GOT_SIZE (output_bfd
));
11006 /* Calculate the offset of the .got.plt entry from
11007 _GLOBAL_OFFSET_TABLE_. */
11008 got_offset
= mips_elf_gotplt_index (info
, h
);
11010 /* Calculate the offset for the branch at the start of the PLT
11011 entry. The branch jumps to the beginning of .plt. */
11012 branch_offset
= -(plt_offset
/ 4 + 1) & 0xffff;
11014 /* Fill in the initial value of the .got.plt entry. */
11015 bfd_put_32 (output_bfd
, plt_address
,
11016 (htab
->sgotplt
->contents
11017 + gotplt_index
* MIPS_ELF_GOT_SIZE (output_bfd
)));
11019 /* Find out where the .plt entry should go. */
11020 loc
= htab
->splt
->contents
+ plt_offset
;
11022 if (bfd_link_pic (info
))
11024 plt_entry
= mips_vxworks_shared_plt_entry
;
11025 bfd_put_32 (output_bfd
, plt_entry
[0] | branch_offset
, loc
);
11026 bfd_put_32 (output_bfd
, plt_entry
[1] | gotplt_index
, loc
+ 4);
11030 bfd_vma got_address_high
, got_address_low
;
11032 plt_entry
= mips_vxworks_exec_plt_entry
;
11033 got_address_high
= ((got_address
+ 0x8000) >> 16) & 0xffff;
11034 got_address_low
= got_address
& 0xffff;
11036 bfd_put_32 (output_bfd
, plt_entry
[0] | branch_offset
, loc
);
11037 bfd_put_32 (output_bfd
, plt_entry
[1] | gotplt_index
, loc
+ 4);
11038 bfd_put_32 (output_bfd
, plt_entry
[2] | got_address_high
, loc
+ 8);
11039 bfd_put_32 (output_bfd
, plt_entry
[3] | got_address_low
, loc
+ 12);
11040 bfd_put_32 (output_bfd
, plt_entry
[4], loc
+ 16);
11041 bfd_put_32 (output_bfd
, plt_entry
[5], loc
+ 20);
11042 bfd_put_32 (output_bfd
, plt_entry
[6], loc
+ 24);
11043 bfd_put_32 (output_bfd
, plt_entry
[7], loc
+ 28);
11045 loc
= (htab
->srelplt2
->contents
11046 + (gotplt_index
* 3 + 2) * sizeof (Elf32_External_Rela
));
11048 /* Emit a relocation for the .got.plt entry. */
11049 rel
.r_offset
= got_address
;
11050 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
, R_MIPS_32
);
11051 rel
.r_addend
= plt_offset
;
11052 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
11054 /* Emit a relocation for the lui of %hi(<.got.plt slot>). */
11055 loc
+= sizeof (Elf32_External_Rela
);
11056 rel
.r_offset
= plt_address
+ 8;
11057 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_HI16
);
11058 rel
.r_addend
= got_offset
;
11059 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
11061 /* Emit a relocation for the addiu of %lo(<.got.plt slot>). */
11062 loc
+= sizeof (Elf32_External_Rela
);
11064 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_LO16
);
11065 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
11068 /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry. */
11069 loc
= (htab
->srelplt
->contents
11070 + gotplt_index
* sizeof (Elf32_External_Rela
));
11071 rel
.r_offset
= got_address
;
11072 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_JUMP_SLOT
);
11074 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
11076 if (!h
->def_regular
)
11077 sym
->st_shndx
= SHN_UNDEF
;
11080 BFD_ASSERT (h
->dynindx
!= -1 || h
->forced_local
);
11083 g
= htab
->got_info
;
11084 BFD_ASSERT (g
!= NULL
);
11086 /* See if this symbol has an entry in the GOT. */
11087 if (hmips
->global_got_area
!= GGA_NONE
)
11090 Elf_Internal_Rela outrel
;
11094 /* Install the symbol value in the GOT. */
11095 offset
= mips_elf_primary_global_got_index (output_bfd
, info
, h
);
11096 MIPS_ELF_PUT_WORD (output_bfd
, sym
->st_value
, sgot
->contents
+ offset
);
11098 /* Add a dynamic relocation for it. */
11099 s
= mips_elf_rel_dyn_section (info
, FALSE
);
11100 loc
= s
->contents
+ (s
->reloc_count
++ * sizeof (Elf32_External_Rela
));
11101 outrel
.r_offset
= (sgot
->output_section
->vma
11102 + sgot
->output_offset
11104 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_32
);
11105 outrel
.r_addend
= 0;
11106 bfd_elf32_swap_reloca_out (dynobj
, &outrel
, loc
);
11109 /* Emit a copy reloc, if needed. */
11112 Elf_Internal_Rela rel
;
11114 BFD_ASSERT (h
->dynindx
!= -1);
11116 rel
.r_offset
= (h
->root
.u
.def
.section
->output_section
->vma
11117 + h
->root
.u
.def
.section
->output_offset
11118 + h
->root
.u
.def
.value
);
11119 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_COPY
);
11121 bfd_elf32_swap_reloca_out (output_bfd
, &rel
,
11122 htab
->srelbss
->contents
11123 + (htab
->srelbss
->reloc_count
11124 * sizeof (Elf32_External_Rela
)));
11125 ++htab
->srelbss
->reloc_count
;
11128 /* If this is a mips16/microMIPS symbol, force the value to be even. */
11129 if (ELF_ST_IS_COMPRESSED (sym
->st_other
))
11130 sym
->st_value
&= ~1;
11135 /* Write out a plt0 entry to the beginning of .plt. */
11138 mips_finish_exec_plt (bfd
*output_bfd
, struct bfd_link_info
*info
)
11141 bfd_vma gotplt_value
, gotplt_value_high
, gotplt_value_low
;
11142 static const bfd_vma
*plt_entry
;
11143 struct mips_elf_link_hash_table
*htab
;
11145 htab
= mips_elf_hash_table (info
);
11146 BFD_ASSERT (htab
!= NULL
);
11148 if (ABI_64_P (output_bfd
))
11149 plt_entry
= mips_n64_exec_plt0_entry
;
11150 else if (ABI_N32_P (output_bfd
))
11151 plt_entry
= mips_n32_exec_plt0_entry
;
11152 else if (!htab
->plt_header_is_comp
)
11153 plt_entry
= mips_o32_exec_plt0_entry
;
11154 else if (htab
->insn32
)
11155 plt_entry
= micromips_insn32_o32_exec_plt0_entry
;
11157 plt_entry
= micromips_o32_exec_plt0_entry
;
11159 /* Calculate the value of .got.plt. */
11160 gotplt_value
= (htab
->sgotplt
->output_section
->vma
11161 + htab
->sgotplt
->output_offset
);
11162 gotplt_value_high
= ((gotplt_value
+ 0x8000) >> 16) & 0xffff;
11163 gotplt_value_low
= gotplt_value
& 0xffff;
11165 /* The PLT sequence is not safe for N64 if .got.plt's address can
11166 not be loaded in two instructions. */
11167 BFD_ASSERT ((gotplt_value
& ~(bfd_vma
) 0x7fffffff) == 0
11168 || ~(gotplt_value
| 0x7fffffff) == 0);
11170 /* Install the PLT header. */
11171 loc
= htab
->splt
->contents
;
11172 if (plt_entry
== micromips_o32_exec_plt0_entry
)
11174 bfd_vma gotpc_offset
;
11175 bfd_vma loc_address
;
11178 BFD_ASSERT (gotplt_value
% 4 == 0);
11180 loc_address
= (htab
->splt
->output_section
->vma
11181 + htab
->splt
->output_offset
);
11182 gotpc_offset
= gotplt_value
- ((loc_address
| 3) ^ 3);
11184 /* ADDIUPC has a span of +/-16MB, check we're in range. */
11185 if (gotpc_offset
+ 0x1000000 >= 0x2000000)
11187 (*_bfd_error_handler
)
11188 (_("%B: `%A' offset of %ld from `%A' beyond the range of ADDIUPC"),
11190 htab
->sgotplt
->output_section
,
11191 htab
->splt
->output_section
,
11192 (long) gotpc_offset
);
11193 bfd_set_error (bfd_error_no_error
);
11196 bfd_put_16 (output_bfd
,
11197 plt_entry
[0] | ((gotpc_offset
>> 18) & 0x7f), loc
);
11198 bfd_put_16 (output_bfd
, (gotpc_offset
>> 2) & 0xffff, loc
+ 2);
11199 for (i
= 2; i
< ARRAY_SIZE (micromips_o32_exec_plt0_entry
); i
++)
11200 bfd_put_16 (output_bfd
, plt_entry
[i
], loc
+ (i
* 2));
11202 else if (plt_entry
== micromips_insn32_o32_exec_plt0_entry
)
11206 bfd_put_16 (output_bfd
, plt_entry
[0], loc
);
11207 bfd_put_16 (output_bfd
, gotplt_value_high
, loc
+ 2);
11208 bfd_put_16 (output_bfd
, plt_entry
[2], loc
+ 4);
11209 bfd_put_16 (output_bfd
, gotplt_value_low
, loc
+ 6);
11210 bfd_put_16 (output_bfd
, plt_entry
[4], loc
+ 8);
11211 bfd_put_16 (output_bfd
, gotplt_value_low
, loc
+ 10);
11212 for (i
= 6; i
< ARRAY_SIZE (micromips_insn32_o32_exec_plt0_entry
); i
++)
11213 bfd_put_16 (output_bfd
, plt_entry
[i
], loc
+ (i
* 2));
11217 bfd_put_32 (output_bfd
, plt_entry
[0] | gotplt_value_high
, loc
);
11218 bfd_put_32 (output_bfd
, plt_entry
[1] | gotplt_value_low
, loc
+ 4);
11219 bfd_put_32 (output_bfd
, plt_entry
[2] | gotplt_value_low
, loc
+ 8);
11220 bfd_put_32 (output_bfd
, plt_entry
[3], loc
+ 12);
11221 bfd_put_32 (output_bfd
, plt_entry
[4], loc
+ 16);
11222 bfd_put_32 (output_bfd
, plt_entry
[5], loc
+ 20);
11223 bfd_put_32 (output_bfd
, plt_entry
[6], loc
+ 24);
11224 bfd_put_32 (output_bfd
, plt_entry
[7], loc
+ 28);
11230 /* Install the PLT header for a VxWorks executable and finalize the
11231 contents of .rela.plt.unloaded. */
11234 mips_vxworks_finish_exec_plt (bfd
*output_bfd
, struct bfd_link_info
*info
)
11236 Elf_Internal_Rela rela
;
11238 bfd_vma got_value
, got_value_high
, got_value_low
, plt_address
;
11239 static const bfd_vma
*plt_entry
;
11240 struct mips_elf_link_hash_table
*htab
;
11242 htab
= mips_elf_hash_table (info
);
11243 BFD_ASSERT (htab
!= NULL
);
11245 plt_entry
= mips_vxworks_exec_plt0_entry
;
11247 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */
11248 got_value
= (htab
->root
.hgot
->root
.u
.def
.section
->output_section
->vma
11249 + htab
->root
.hgot
->root
.u
.def
.section
->output_offset
11250 + htab
->root
.hgot
->root
.u
.def
.value
);
11252 got_value_high
= ((got_value
+ 0x8000) >> 16) & 0xffff;
11253 got_value_low
= got_value
& 0xffff;
11255 /* Calculate the address of the PLT header. */
11256 plt_address
= htab
->splt
->output_section
->vma
+ htab
->splt
->output_offset
;
11258 /* Install the PLT header. */
11259 loc
= htab
->splt
->contents
;
11260 bfd_put_32 (output_bfd
, plt_entry
[0] | got_value_high
, loc
);
11261 bfd_put_32 (output_bfd
, plt_entry
[1] | got_value_low
, loc
+ 4);
11262 bfd_put_32 (output_bfd
, plt_entry
[2], loc
+ 8);
11263 bfd_put_32 (output_bfd
, plt_entry
[3], loc
+ 12);
11264 bfd_put_32 (output_bfd
, plt_entry
[4], loc
+ 16);
11265 bfd_put_32 (output_bfd
, plt_entry
[5], loc
+ 20);
11267 /* Output the relocation for the lui of %hi(_GLOBAL_OFFSET_TABLE_). */
11268 loc
= htab
->srelplt2
->contents
;
11269 rela
.r_offset
= plt_address
;
11270 rela
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_HI16
);
11272 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
11273 loc
+= sizeof (Elf32_External_Rela
);
11275 /* Output the relocation for the following addiu of
11276 %lo(_GLOBAL_OFFSET_TABLE_). */
11277 rela
.r_offset
+= 4;
11278 rela
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_LO16
);
11279 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
11280 loc
+= sizeof (Elf32_External_Rela
);
11282 /* Fix up the remaining relocations. They may have the wrong
11283 symbol index for _G_O_T_ or _P_L_T_ depending on the order
11284 in which symbols were output. */
11285 while (loc
< htab
->srelplt2
->contents
+ htab
->srelplt2
->size
)
11287 Elf_Internal_Rela rel
;
11289 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &rel
);
11290 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
, R_MIPS_32
);
11291 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
11292 loc
+= sizeof (Elf32_External_Rela
);
11294 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &rel
);
11295 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_HI16
);
11296 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
11297 loc
+= sizeof (Elf32_External_Rela
);
11299 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &rel
);
11300 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_LO16
);
11301 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
11302 loc
+= sizeof (Elf32_External_Rela
);
11306 /* Install the PLT header for a VxWorks shared library. */
11309 mips_vxworks_finish_shared_plt (bfd
*output_bfd
, struct bfd_link_info
*info
)
11312 struct mips_elf_link_hash_table
*htab
;
11314 htab
= mips_elf_hash_table (info
);
11315 BFD_ASSERT (htab
!= NULL
);
11317 /* We just need to copy the entry byte-by-byte. */
11318 for (i
= 0; i
< ARRAY_SIZE (mips_vxworks_shared_plt0_entry
); i
++)
11319 bfd_put_32 (output_bfd
, mips_vxworks_shared_plt0_entry
[i
],
11320 htab
->splt
->contents
+ i
* 4);
11323 /* Finish up the dynamic sections. */
11326 _bfd_mips_elf_finish_dynamic_sections (bfd
*output_bfd
,
11327 struct bfd_link_info
*info
)
11332 struct mips_got_info
*gg
, *g
;
11333 struct mips_elf_link_hash_table
*htab
;
11335 htab
= mips_elf_hash_table (info
);
11336 BFD_ASSERT (htab
!= NULL
);
11338 dynobj
= elf_hash_table (info
)->dynobj
;
11340 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
11343 gg
= htab
->got_info
;
11345 if (elf_hash_table (info
)->dynamic_sections_created
)
11348 int dyn_to_skip
= 0, dyn_skipped
= 0;
11350 BFD_ASSERT (sdyn
!= NULL
);
11351 BFD_ASSERT (gg
!= NULL
);
11353 g
= mips_elf_bfd_got (output_bfd
, FALSE
);
11354 BFD_ASSERT (g
!= NULL
);
11356 for (b
= sdyn
->contents
;
11357 b
< sdyn
->contents
+ sdyn
->size
;
11358 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
11360 Elf_Internal_Dyn dyn
;
11364 bfd_boolean swap_out_p
;
11366 /* Read in the current dynamic entry. */
11367 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
11369 /* Assume that we're going to modify it and write it out. */
11375 dyn
.d_un
.d_val
= MIPS_ELF_REL_SIZE (dynobj
);
11379 BFD_ASSERT (htab
->is_vxworks
);
11380 dyn
.d_un
.d_val
= MIPS_ELF_RELA_SIZE (dynobj
);
11384 /* Rewrite DT_STRSZ. */
11386 _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
11391 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
11394 case DT_MIPS_PLTGOT
:
11396 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
11399 case DT_MIPS_RLD_VERSION
:
11400 dyn
.d_un
.d_val
= 1; /* XXX */
11403 case DT_MIPS_FLAGS
:
11404 dyn
.d_un
.d_val
= RHF_NOTPOT
; /* XXX */
11407 case DT_MIPS_TIME_STAMP
:
11411 dyn
.d_un
.d_val
= t
;
11415 case DT_MIPS_ICHECKSUM
:
11417 swap_out_p
= FALSE
;
11420 case DT_MIPS_IVERSION
:
11422 swap_out_p
= FALSE
;
11425 case DT_MIPS_BASE_ADDRESS
:
11426 s
= output_bfd
->sections
;
11427 BFD_ASSERT (s
!= NULL
);
11428 dyn
.d_un
.d_ptr
= s
->vma
& ~(bfd_vma
) 0xffff;
11431 case DT_MIPS_LOCAL_GOTNO
:
11432 dyn
.d_un
.d_val
= g
->local_gotno
;
11435 case DT_MIPS_UNREFEXTNO
:
11436 /* The index into the dynamic symbol table which is the
11437 entry of the first external symbol that is not
11438 referenced within the same object. */
11439 dyn
.d_un
.d_val
= bfd_count_sections (output_bfd
) + 1;
11442 case DT_MIPS_GOTSYM
:
11443 if (htab
->global_gotsym
)
11445 dyn
.d_un
.d_val
= htab
->global_gotsym
->dynindx
;
11448 /* In case if we don't have global got symbols we default
11449 to setting DT_MIPS_GOTSYM to the same value as
11450 DT_MIPS_SYMTABNO, so we just fall through. */
11452 case DT_MIPS_SYMTABNO
:
11454 elemsize
= MIPS_ELF_SYM_SIZE (output_bfd
);
11455 s
= bfd_get_section_by_name (output_bfd
, name
);
11458 dyn
.d_un
.d_val
= s
->size
/ elemsize
;
11460 dyn
.d_un
.d_val
= 0;
11463 case DT_MIPS_HIPAGENO
:
11464 dyn
.d_un
.d_val
= g
->local_gotno
- htab
->reserved_gotno
;
11467 case DT_MIPS_RLD_MAP
:
11469 struct elf_link_hash_entry
*h
;
11470 h
= mips_elf_hash_table (info
)->rld_symbol
;
11473 dyn_to_skip
= MIPS_ELF_DYN_SIZE (dynobj
);
11474 swap_out_p
= FALSE
;
11477 s
= h
->root
.u
.def
.section
;
11479 /* The MIPS_RLD_MAP tag stores the absolute address of the
11481 dyn
.d_un
.d_ptr
= (s
->output_section
->vma
+ s
->output_offset
11482 + h
->root
.u
.def
.value
);
11486 case DT_MIPS_RLD_MAP_REL
:
11488 struct elf_link_hash_entry
*h
;
11489 bfd_vma dt_addr
, rld_addr
;
11490 h
= mips_elf_hash_table (info
)->rld_symbol
;
11493 dyn_to_skip
= MIPS_ELF_DYN_SIZE (dynobj
);
11494 swap_out_p
= FALSE
;
11497 s
= h
->root
.u
.def
.section
;
11499 /* The MIPS_RLD_MAP_REL tag stores the offset to the debug
11500 pointer, relative to the address of the tag. */
11501 dt_addr
= (sdyn
->output_section
->vma
+ sdyn
->output_offset
11502 + (b
- sdyn
->contents
));
11503 rld_addr
= (s
->output_section
->vma
+ s
->output_offset
11504 + h
->root
.u
.def
.value
);
11505 dyn
.d_un
.d_ptr
= rld_addr
- dt_addr
;
11509 case DT_MIPS_OPTIONS
:
11510 s
= (bfd_get_section_by_name
11511 (output_bfd
, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd
)));
11512 dyn
.d_un
.d_ptr
= s
->vma
;
11516 BFD_ASSERT (htab
->is_vxworks
);
11517 /* The count does not include the JUMP_SLOT relocations. */
11519 dyn
.d_un
.d_val
-= htab
->srelplt
->size
;
11523 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
11524 if (htab
->is_vxworks
)
11525 dyn
.d_un
.d_val
= DT_RELA
;
11527 dyn
.d_un
.d_val
= DT_REL
;
11531 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
11532 dyn
.d_un
.d_val
= htab
->srelplt
->size
;
11536 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
11537 dyn
.d_un
.d_ptr
= (htab
->srelplt
->output_section
->vma
11538 + htab
->srelplt
->output_offset
);
11542 /* If we didn't need any text relocations after all, delete
11543 the dynamic tag. */
11544 if (!(info
->flags
& DF_TEXTREL
))
11546 dyn_to_skip
= MIPS_ELF_DYN_SIZE (dynobj
);
11547 swap_out_p
= FALSE
;
11552 /* If we didn't need any text relocations after all, clear
11553 DF_TEXTREL from DT_FLAGS. */
11554 if (!(info
->flags
& DF_TEXTREL
))
11555 dyn
.d_un
.d_val
&= ~DF_TEXTREL
;
11557 swap_out_p
= FALSE
;
11561 swap_out_p
= FALSE
;
11562 if (htab
->is_vxworks
11563 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
11568 if (swap_out_p
|| dyn_skipped
)
11569 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
11570 (dynobj
, &dyn
, b
- dyn_skipped
);
11574 dyn_skipped
+= dyn_to_skip
;
11579 /* Wipe out any trailing entries if we shifted down a dynamic tag. */
11580 if (dyn_skipped
> 0)
11581 memset (b
- dyn_skipped
, 0, dyn_skipped
);
11584 if (sgot
!= NULL
&& sgot
->size
> 0
11585 && !bfd_is_abs_section (sgot
->output_section
))
11587 if (htab
->is_vxworks
)
11589 /* The first entry of the global offset table points to the
11590 ".dynamic" section. The second is initialized by the
11591 loader and contains the shared library identifier.
11592 The third is also initialized by the loader and points
11593 to the lazy resolution stub. */
11594 MIPS_ELF_PUT_WORD (output_bfd
,
11595 sdyn
->output_offset
+ sdyn
->output_section
->vma
,
11597 MIPS_ELF_PUT_WORD (output_bfd
, 0,
11598 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
11599 MIPS_ELF_PUT_WORD (output_bfd
, 0,
11601 + 2 * MIPS_ELF_GOT_SIZE (output_bfd
));
11605 /* The first entry of the global offset table will be filled at
11606 runtime. The second entry will be used by some runtime loaders.
11607 This isn't the case of IRIX rld. */
11608 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
11609 MIPS_ELF_PUT_WORD (output_bfd
, MIPS_ELF_GNU_GOT1_MASK (output_bfd
),
11610 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
11613 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
11614 = MIPS_ELF_GOT_SIZE (output_bfd
);
11617 /* Generate dynamic relocations for the non-primary gots. */
11618 if (gg
!= NULL
&& gg
->next
)
11620 Elf_Internal_Rela rel
[3];
11621 bfd_vma addend
= 0;
11623 memset (rel
, 0, sizeof (rel
));
11624 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_REL32
);
11626 for (g
= gg
->next
; g
->next
!= gg
; g
= g
->next
)
11628 bfd_vma got_index
= g
->next
->local_gotno
+ g
->next
->global_gotno
11629 + g
->next
->tls_gotno
;
11631 MIPS_ELF_PUT_WORD (output_bfd
, 0, sgot
->contents
11632 + got_index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
11633 MIPS_ELF_PUT_WORD (output_bfd
, MIPS_ELF_GNU_GOT1_MASK (output_bfd
),
11635 + got_index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
11637 if (! bfd_link_pic (info
))
11640 for (; got_index
< g
->local_gotno
; got_index
++)
11642 if (got_index
>= g
->assigned_low_gotno
11643 && got_index
<= g
->assigned_high_gotno
)
11646 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
11647 = got_index
* MIPS_ELF_GOT_SIZE (output_bfd
);
11648 if (!(mips_elf_create_dynamic_relocation
11649 (output_bfd
, info
, rel
, NULL
,
11650 bfd_abs_section_ptr
,
11651 0, &addend
, sgot
)))
11653 BFD_ASSERT (addend
== 0);
11658 /* The generation of dynamic relocations for the non-primary gots
11659 adds more dynamic relocations. We cannot count them until
11662 if (elf_hash_table (info
)->dynamic_sections_created
)
11665 bfd_boolean swap_out_p
;
11667 BFD_ASSERT (sdyn
!= NULL
);
11669 for (b
= sdyn
->contents
;
11670 b
< sdyn
->contents
+ sdyn
->size
;
11671 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
11673 Elf_Internal_Dyn dyn
;
11676 /* Read in the current dynamic entry. */
11677 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
11679 /* Assume that we're going to modify it and write it out. */
11685 /* Reduce DT_RELSZ to account for any relocations we
11686 decided not to make. This is for the n64 irix rld,
11687 which doesn't seem to apply any relocations if there
11688 are trailing null entries. */
11689 s
= mips_elf_rel_dyn_section (info
, FALSE
);
11690 dyn
.d_un
.d_val
= (s
->reloc_count
11691 * (ABI_64_P (output_bfd
)
11692 ? sizeof (Elf64_Mips_External_Rel
)
11693 : sizeof (Elf32_External_Rel
)));
11694 /* Adjust the section size too. Tools like the prelinker
11695 can reasonably expect the values to the same. */
11696 elf_section_data (s
->output_section
)->this_hdr
.sh_size
11701 swap_out_p
= FALSE
;
11706 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
11713 Elf32_compact_rel cpt
;
11715 if (SGI_COMPAT (output_bfd
))
11717 /* Write .compact_rel section out. */
11718 s
= bfd_get_linker_section (dynobj
, ".compact_rel");
11722 cpt
.num
= s
->reloc_count
;
11724 cpt
.offset
= (s
->output_section
->filepos
11725 + sizeof (Elf32_External_compact_rel
));
11728 bfd_elf32_swap_compact_rel_out (output_bfd
, &cpt
,
11729 ((Elf32_External_compact_rel
*)
11732 /* Clean up a dummy stub function entry in .text. */
11733 if (htab
->sstubs
!= NULL
)
11735 file_ptr dummy_offset
;
11737 BFD_ASSERT (htab
->sstubs
->size
>= htab
->function_stub_size
);
11738 dummy_offset
= htab
->sstubs
->size
- htab
->function_stub_size
;
11739 memset (htab
->sstubs
->contents
+ dummy_offset
, 0,
11740 htab
->function_stub_size
);
11745 /* The psABI says that the dynamic relocations must be sorted in
11746 increasing order of r_symndx. The VxWorks EABI doesn't require
11747 this, and because the code below handles REL rather than RELA
11748 relocations, using it for VxWorks would be outright harmful. */
11749 if (!htab
->is_vxworks
)
11751 s
= mips_elf_rel_dyn_section (info
, FALSE
);
11753 && s
->size
> (bfd_vma
)2 * MIPS_ELF_REL_SIZE (output_bfd
))
11755 reldyn_sorting_bfd
= output_bfd
;
11757 if (ABI_64_P (output_bfd
))
11758 qsort ((Elf64_External_Rel
*) s
->contents
+ 1,
11759 s
->reloc_count
- 1, sizeof (Elf64_Mips_External_Rel
),
11760 sort_dynamic_relocs_64
);
11762 qsort ((Elf32_External_Rel
*) s
->contents
+ 1,
11763 s
->reloc_count
- 1, sizeof (Elf32_External_Rel
),
11764 sort_dynamic_relocs
);
11769 if (htab
->splt
&& htab
->splt
->size
> 0)
11771 if (htab
->is_vxworks
)
11773 if (bfd_link_pic (info
))
11774 mips_vxworks_finish_shared_plt (output_bfd
, info
);
11776 mips_vxworks_finish_exec_plt (output_bfd
, info
);
11780 BFD_ASSERT (!bfd_link_pic (info
));
11781 if (!mips_finish_exec_plt (output_bfd
, info
))
11789 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
11792 mips_set_isa_flags (bfd
*abfd
)
11796 switch (bfd_get_mach (abfd
))
11799 case bfd_mach_mips3000
:
11800 val
= E_MIPS_ARCH_1
;
11803 case bfd_mach_mips3900
:
11804 val
= E_MIPS_ARCH_1
| E_MIPS_MACH_3900
;
11807 case bfd_mach_mips6000
:
11808 val
= E_MIPS_ARCH_2
;
11811 case bfd_mach_mips4000
:
11812 case bfd_mach_mips4300
:
11813 case bfd_mach_mips4400
:
11814 case bfd_mach_mips4600
:
11815 val
= E_MIPS_ARCH_3
;
11818 case bfd_mach_mips4010
:
11819 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4010
;
11822 case bfd_mach_mips4100
:
11823 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4100
;
11826 case bfd_mach_mips4111
:
11827 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4111
;
11830 case bfd_mach_mips4120
:
11831 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4120
;
11834 case bfd_mach_mips4650
:
11835 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4650
;
11838 case bfd_mach_mips5400
:
11839 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5400
;
11842 case bfd_mach_mips5500
:
11843 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5500
;
11846 case bfd_mach_mips5900
:
11847 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_5900
;
11850 case bfd_mach_mips9000
:
11851 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_9000
;
11854 case bfd_mach_mips5000
:
11855 case bfd_mach_mips7000
:
11856 case bfd_mach_mips8000
:
11857 case bfd_mach_mips10000
:
11858 case bfd_mach_mips12000
:
11859 case bfd_mach_mips14000
:
11860 case bfd_mach_mips16000
:
11861 val
= E_MIPS_ARCH_4
;
11864 case bfd_mach_mips5
:
11865 val
= E_MIPS_ARCH_5
;
11868 case bfd_mach_mips_loongson_2e
:
11869 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_LS2E
;
11872 case bfd_mach_mips_loongson_2f
:
11873 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_LS2F
;
11876 case bfd_mach_mips_sb1
:
11877 val
= E_MIPS_ARCH_64
| E_MIPS_MACH_SB1
;
11880 case bfd_mach_mips_loongson_3a
:
11881 val
= E_MIPS_ARCH_64R2
| E_MIPS_MACH_LS3A
;
11884 case bfd_mach_mips_octeon
:
11885 case bfd_mach_mips_octeonp
:
11886 val
= E_MIPS_ARCH_64R2
| E_MIPS_MACH_OCTEON
;
11889 case bfd_mach_mips_octeon3
:
11890 val
= E_MIPS_ARCH_64R2
| E_MIPS_MACH_OCTEON3
;
11893 case bfd_mach_mips_xlr
:
11894 val
= E_MIPS_ARCH_64
| E_MIPS_MACH_XLR
;
11897 case bfd_mach_mips_octeon2
:
11898 val
= E_MIPS_ARCH_64R2
| E_MIPS_MACH_OCTEON2
;
11901 case bfd_mach_mipsisa32
:
11902 val
= E_MIPS_ARCH_32
;
11905 case bfd_mach_mipsisa64
:
11906 val
= E_MIPS_ARCH_64
;
11909 case bfd_mach_mipsisa32r2
:
11910 case bfd_mach_mipsisa32r3
:
11911 case bfd_mach_mipsisa32r5
:
11912 val
= E_MIPS_ARCH_32R2
;
11915 case bfd_mach_mipsisa64r2
:
11916 case bfd_mach_mipsisa64r3
:
11917 case bfd_mach_mipsisa64r5
:
11918 val
= E_MIPS_ARCH_64R2
;
11921 case bfd_mach_mipsisa32r6
:
11922 val
= E_MIPS_ARCH_32R6
;
11925 case bfd_mach_mipsisa64r6
:
11926 val
= E_MIPS_ARCH_64R6
;
11929 elf_elfheader (abfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
11930 elf_elfheader (abfd
)->e_flags
|= val
;
11935 /* Whether to sort relocs output by ld -r or ld --emit-relocs, by r_offset.
11936 Don't do so for code sections. We want to keep ordering of HI16/LO16
11937 as is. On the other hand, elf-eh-frame.c processing requires .eh_frame
11938 relocs to be sorted. */
11941 _bfd_mips_elf_sort_relocs_p (asection
*sec
)
11943 return (sec
->flags
& SEC_CODE
) == 0;
11947 /* The final processing done just before writing out a MIPS ELF object
11948 file. This gets the MIPS architecture right based on the machine
11949 number. This is used by both the 32-bit and the 64-bit ABI. */
11952 _bfd_mips_elf_final_write_processing (bfd
*abfd
,
11953 bfd_boolean linker ATTRIBUTE_UNUSED
)
11956 Elf_Internal_Shdr
**hdrpp
;
11960 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
11961 is nonzero. This is for compatibility with old objects, which used
11962 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
11963 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_MACH
) == 0)
11964 mips_set_isa_flags (abfd
);
11966 /* Set the sh_info field for .gptab sections and other appropriate
11967 info for each special section. */
11968 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
11969 i
< elf_numsections (abfd
);
11972 switch ((*hdrpp
)->sh_type
)
11974 case SHT_MIPS_MSYM
:
11975 case SHT_MIPS_LIBLIST
:
11976 sec
= bfd_get_section_by_name (abfd
, ".dynstr");
11978 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
11981 case SHT_MIPS_GPTAB
:
11982 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
11983 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
11984 BFD_ASSERT (name
!= NULL
11985 && CONST_STRNEQ (name
, ".gptab."));
11986 sec
= bfd_get_section_by_name (abfd
, name
+ sizeof ".gptab" - 1);
11987 BFD_ASSERT (sec
!= NULL
);
11988 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
11991 case SHT_MIPS_CONTENT
:
11992 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
11993 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
11994 BFD_ASSERT (name
!= NULL
11995 && CONST_STRNEQ (name
, ".MIPS.content"));
11996 sec
= bfd_get_section_by_name (abfd
,
11997 name
+ sizeof ".MIPS.content" - 1);
11998 BFD_ASSERT (sec
!= NULL
);
11999 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
12002 case SHT_MIPS_SYMBOL_LIB
:
12003 sec
= bfd_get_section_by_name (abfd
, ".dynsym");
12005 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
12006 sec
= bfd_get_section_by_name (abfd
, ".liblist");
12008 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
12011 case SHT_MIPS_EVENTS
:
12012 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
12013 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
12014 BFD_ASSERT (name
!= NULL
);
12015 if (CONST_STRNEQ (name
, ".MIPS.events"))
12016 sec
= bfd_get_section_by_name (abfd
,
12017 name
+ sizeof ".MIPS.events" - 1);
12020 BFD_ASSERT (CONST_STRNEQ (name
, ".MIPS.post_rel"));
12021 sec
= bfd_get_section_by_name (abfd
,
12023 + sizeof ".MIPS.post_rel" - 1));
12025 BFD_ASSERT (sec
!= NULL
);
12026 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
12033 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
12037 _bfd_mips_elf_additional_program_headers (bfd
*abfd
,
12038 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
12043 /* See if we need a PT_MIPS_REGINFO segment. */
12044 s
= bfd_get_section_by_name (abfd
, ".reginfo");
12045 if (s
&& (s
->flags
& SEC_LOAD
))
12048 /* See if we need a PT_MIPS_ABIFLAGS segment. */
12049 if (bfd_get_section_by_name (abfd
, ".MIPS.abiflags"))
12052 /* See if we need a PT_MIPS_OPTIONS segment. */
12053 if (IRIX_COMPAT (abfd
) == ict_irix6
12054 && bfd_get_section_by_name (abfd
,
12055 MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)))
12058 /* See if we need a PT_MIPS_RTPROC segment. */
12059 if (IRIX_COMPAT (abfd
) == ict_irix5
12060 && bfd_get_section_by_name (abfd
, ".dynamic")
12061 && bfd_get_section_by_name (abfd
, ".mdebug"))
12064 /* Allocate a PT_NULL header in dynamic objects. See
12065 _bfd_mips_elf_modify_segment_map for details. */
12066 if (!SGI_COMPAT (abfd
)
12067 && bfd_get_section_by_name (abfd
, ".dynamic"))
12073 /* Modify the segment map for an IRIX5 executable. */
12076 _bfd_mips_elf_modify_segment_map (bfd
*abfd
,
12077 struct bfd_link_info
*info
)
12080 struct elf_segment_map
*m
, **pm
;
12083 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
12085 s
= bfd_get_section_by_name (abfd
, ".reginfo");
12086 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
12088 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
12089 if (m
->p_type
== PT_MIPS_REGINFO
)
12094 m
= bfd_zalloc (abfd
, amt
);
12098 m
->p_type
= PT_MIPS_REGINFO
;
12100 m
->sections
[0] = s
;
12102 /* We want to put it after the PHDR and INTERP segments. */
12103 pm
= &elf_seg_map (abfd
);
12105 && ((*pm
)->p_type
== PT_PHDR
12106 || (*pm
)->p_type
== PT_INTERP
))
12114 /* If there is a .MIPS.abiflags section, we need a PT_MIPS_ABIFLAGS
12116 s
= bfd_get_section_by_name (abfd
, ".MIPS.abiflags");
12117 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
12119 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
12120 if (m
->p_type
== PT_MIPS_ABIFLAGS
)
12125 m
= bfd_zalloc (abfd
, amt
);
12129 m
->p_type
= PT_MIPS_ABIFLAGS
;
12131 m
->sections
[0] = s
;
12133 /* We want to put it after the PHDR and INTERP segments. */
12134 pm
= &elf_seg_map (abfd
);
12136 && ((*pm
)->p_type
== PT_PHDR
12137 || (*pm
)->p_type
== PT_INTERP
))
12145 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
12146 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
12147 PT_MIPS_OPTIONS segment immediately following the program header
12149 if (NEWABI_P (abfd
)
12150 /* On non-IRIX6 new abi, we'll have already created a segment
12151 for this section, so don't create another. I'm not sure this
12152 is not also the case for IRIX 6, but I can't test it right
12154 && IRIX_COMPAT (abfd
) == ict_irix6
)
12156 for (s
= abfd
->sections
; s
; s
= s
->next
)
12157 if (elf_section_data (s
)->this_hdr
.sh_type
== SHT_MIPS_OPTIONS
)
12162 struct elf_segment_map
*options_segment
;
12164 pm
= &elf_seg_map (abfd
);
12166 && ((*pm
)->p_type
== PT_PHDR
12167 || (*pm
)->p_type
== PT_INTERP
))
12170 if (*pm
== NULL
|| (*pm
)->p_type
!= PT_MIPS_OPTIONS
)
12172 amt
= sizeof (struct elf_segment_map
);
12173 options_segment
= bfd_zalloc (abfd
, amt
);
12174 options_segment
->next
= *pm
;
12175 options_segment
->p_type
= PT_MIPS_OPTIONS
;
12176 options_segment
->p_flags
= PF_R
;
12177 options_segment
->p_flags_valid
= TRUE
;
12178 options_segment
->count
= 1;
12179 options_segment
->sections
[0] = s
;
12180 *pm
= options_segment
;
12186 if (IRIX_COMPAT (abfd
) == ict_irix5
)
12188 /* If there are .dynamic and .mdebug sections, we make a room
12189 for the RTPROC header. FIXME: Rewrite without section names. */
12190 if (bfd_get_section_by_name (abfd
, ".interp") == NULL
12191 && bfd_get_section_by_name (abfd
, ".dynamic") != NULL
12192 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
12194 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
12195 if (m
->p_type
== PT_MIPS_RTPROC
)
12200 m
= bfd_zalloc (abfd
, amt
);
12204 m
->p_type
= PT_MIPS_RTPROC
;
12206 s
= bfd_get_section_by_name (abfd
, ".rtproc");
12211 m
->p_flags_valid
= 1;
12216 m
->sections
[0] = s
;
12219 /* We want to put it after the DYNAMIC segment. */
12220 pm
= &elf_seg_map (abfd
);
12221 while (*pm
!= NULL
&& (*pm
)->p_type
!= PT_DYNAMIC
)
12231 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
12232 .dynstr, .dynsym, and .hash sections, and everything in
12234 for (pm
= &elf_seg_map (abfd
); *pm
!= NULL
;
12236 if ((*pm
)->p_type
== PT_DYNAMIC
)
12239 /* GNU/Linux binaries do not need the extended PT_DYNAMIC section.
12240 glibc's dynamic linker has traditionally derived the number of
12241 tags from the p_filesz field, and sometimes allocates stack
12242 arrays of that size. An overly-big PT_DYNAMIC segment can
12243 be actively harmful in such cases. Making PT_DYNAMIC contain
12244 other sections can also make life hard for the prelinker,
12245 which might move one of the other sections to a different
12246 PT_LOAD segment. */
12247 if (SGI_COMPAT (abfd
)
12250 && strcmp (m
->sections
[0]->name
, ".dynamic") == 0)
12252 static const char *sec_names
[] =
12254 ".dynamic", ".dynstr", ".dynsym", ".hash"
12258 struct elf_segment_map
*n
;
12260 low
= ~(bfd_vma
) 0;
12262 for (i
= 0; i
< sizeof sec_names
/ sizeof sec_names
[0]; i
++)
12264 s
= bfd_get_section_by_name (abfd
, sec_names
[i
]);
12265 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
12272 if (high
< s
->vma
+ sz
)
12273 high
= s
->vma
+ sz
;
12278 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
12279 if ((s
->flags
& SEC_LOAD
) != 0
12281 && s
->vma
+ s
->size
<= high
)
12284 amt
= sizeof *n
+ (bfd_size_type
) (c
- 1) * sizeof (asection
*);
12285 n
= bfd_zalloc (abfd
, amt
);
12292 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
12294 if ((s
->flags
& SEC_LOAD
) != 0
12296 && s
->vma
+ s
->size
<= high
)
12298 n
->sections
[i
] = s
;
12307 /* Allocate a spare program header in dynamic objects so that tools
12308 like the prelinker can add an extra PT_LOAD entry.
12310 If the prelinker needs to make room for a new PT_LOAD entry, its
12311 standard procedure is to move the first (read-only) sections into
12312 the new (writable) segment. However, the MIPS ABI requires
12313 .dynamic to be in a read-only segment, and the section will often
12314 start within sizeof (ElfNN_Phdr) bytes of the last program header.
12316 Although the prelinker could in principle move .dynamic to a
12317 writable segment, it seems better to allocate a spare program
12318 header instead, and avoid the need to move any sections.
12319 There is a long tradition of allocating spare dynamic tags,
12320 so allocating a spare program header seems like a natural
12323 If INFO is NULL, we may be copying an already prelinked binary
12324 with objcopy or strip, so do not add this header. */
12326 && !SGI_COMPAT (abfd
)
12327 && bfd_get_section_by_name (abfd
, ".dynamic"))
12329 for (pm
= &elf_seg_map (abfd
); *pm
!= NULL
; pm
= &(*pm
)->next
)
12330 if ((*pm
)->p_type
== PT_NULL
)
12334 m
= bfd_zalloc (abfd
, sizeof (*m
));
12338 m
->p_type
= PT_NULL
;
12346 /* Return the section that should be marked against GC for a given
12350 _bfd_mips_elf_gc_mark_hook (asection
*sec
,
12351 struct bfd_link_info
*info
,
12352 Elf_Internal_Rela
*rel
,
12353 struct elf_link_hash_entry
*h
,
12354 Elf_Internal_Sym
*sym
)
12356 /* ??? Do mips16 stub sections need to be handled special? */
12359 switch (ELF_R_TYPE (sec
->owner
, rel
->r_info
))
12361 case R_MIPS_GNU_VTINHERIT
:
12362 case R_MIPS_GNU_VTENTRY
:
12366 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
12369 /* Update the got entry reference counts for the section being removed. */
12372 _bfd_mips_elf_gc_sweep_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
12373 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
12374 asection
*sec ATTRIBUTE_UNUSED
,
12375 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
)
12378 Elf_Internal_Shdr
*symtab_hdr
;
12379 struct elf_link_hash_entry
**sym_hashes
;
12380 bfd_signed_vma
*local_got_refcounts
;
12381 const Elf_Internal_Rela
*rel
, *relend
;
12382 unsigned long r_symndx
;
12383 struct elf_link_hash_entry
*h
;
12385 if (bfd_link_relocatable (info
))
12388 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
12389 sym_hashes
= elf_sym_hashes (abfd
);
12390 local_got_refcounts
= elf_local_got_refcounts (abfd
);
12392 relend
= relocs
+ sec
->reloc_count
;
12393 for (rel
= relocs
; rel
< relend
; rel
++)
12394 switch (ELF_R_TYPE (abfd
, rel
->r_info
))
12396 case R_MIPS16_GOT16
:
12397 case R_MIPS16_CALL16
:
12399 case R_MIPS_CALL16
:
12400 case R_MIPS_CALL_HI16
:
12401 case R_MIPS_CALL_LO16
:
12402 case R_MIPS_GOT_HI16
:
12403 case R_MIPS_GOT_LO16
:
12404 case R_MIPS_GOT_DISP
:
12405 case R_MIPS_GOT_PAGE
:
12406 case R_MIPS_GOT_OFST
:
12407 case R_MICROMIPS_GOT16
:
12408 case R_MICROMIPS_CALL16
:
12409 case R_MICROMIPS_CALL_HI16
:
12410 case R_MICROMIPS_CALL_LO16
:
12411 case R_MICROMIPS_GOT_HI16
:
12412 case R_MICROMIPS_GOT_LO16
:
12413 case R_MICROMIPS_GOT_DISP
:
12414 case R_MICROMIPS_GOT_PAGE
:
12415 case R_MICROMIPS_GOT_OFST
:
12416 /* ??? It would seem that the existing MIPS code does no sort
12417 of reference counting or whatnot on its GOT and PLT entries,
12418 so it is not possible to garbage collect them at this time. */
12429 /* Prevent .MIPS.abiflags from being discarded with --gc-sections. */
12432 _bfd_mips_elf_gc_mark_extra_sections (struct bfd_link_info
*info
,
12433 elf_gc_mark_hook_fn gc_mark_hook
)
12437 _bfd_elf_gc_mark_extra_sections (info
, gc_mark_hook
);
12439 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
12443 if (! is_mips_elf (sub
))
12446 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
12448 && MIPS_ELF_ABIFLAGS_SECTION_NAME_P
12449 (bfd_get_section_name (sub
, o
)))
12451 if (!_bfd_elf_gc_mark (info
, o
, gc_mark_hook
))
12459 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
12460 hiding the old indirect symbol. Process additional relocation
12461 information. Also called for weakdefs, in which case we just let
12462 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
12465 _bfd_mips_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
12466 struct elf_link_hash_entry
*dir
,
12467 struct elf_link_hash_entry
*ind
)
12469 struct mips_elf_link_hash_entry
*dirmips
, *indmips
;
12471 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
12473 dirmips
= (struct mips_elf_link_hash_entry
*) dir
;
12474 indmips
= (struct mips_elf_link_hash_entry
*) ind
;
12475 /* Any absolute non-dynamic relocations against an indirect or weak
12476 definition will be against the target symbol. */
12477 if (indmips
->has_static_relocs
)
12478 dirmips
->has_static_relocs
= TRUE
;
12480 if (ind
->root
.type
!= bfd_link_hash_indirect
)
12483 dirmips
->possibly_dynamic_relocs
+= indmips
->possibly_dynamic_relocs
;
12484 if (indmips
->readonly_reloc
)
12485 dirmips
->readonly_reloc
= TRUE
;
12486 if (indmips
->no_fn_stub
)
12487 dirmips
->no_fn_stub
= TRUE
;
12488 if (indmips
->fn_stub
)
12490 dirmips
->fn_stub
= indmips
->fn_stub
;
12491 indmips
->fn_stub
= NULL
;
12493 if (indmips
->need_fn_stub
)
12495 dirmips
->need_fn_stub
= TRUE
;
12496 indmips
->need_fn_stub
= FALSE
;
12498 if (indmips
->call_stub
)
12500 dirmips
->call_stub
= indmips
->call_stub
;
12501 indmips
->call_stub
= NULL
;
12503 if (indmips
->call_fp_stub
)
12505 dirmips
->call_fp_stub
= indmips
->call_fp_stub
;
12506 indmips
->call_fp_stub
= NULL
;
12508 if (indmips
->global_got_area
< dirmips
->global_got_area
)
12509 dirmips
->global_got_area
= indmips
->global_got_area
;
12510 if (indmips
->global_got_area
< GGA_NONE
)
12511 indmips
->global_got_area
= GGA_NONE
;
12512 if (indmips
->has_nonpic_branches
)
12513 dirmips
->has_nonpic_branches
= TRUE
;
12516 #define PDR_SIZE 32
12519 _bfd_mips_elf_discard_info (bfd
*abfd
, struct elf_reloc_cookie
*cookie
,
12520 struct bfd_link_info
*info
)
12523 bfd_boolean ret
= FALSE
;
12524 unsigned char *tdata
;
12527 o
= bfd_get_section_by_name (abfd
, ".pdr");
12532 if (o
->size
% PDR_SIZE
!= 0)
12534 if (o
->output_section
!= NULL
12535 && bfd_is_abs_section (o
->output_section
))
12538 tdata
= bfd_zmalloc (o
->size
/ PDR_SIZE
);
12542 cookie
->rels
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
12543 info
->keep_memory
);
12550 cookie
->rel
= cookie
->rels
;
12551 cookie
->relend
= cookie
->rels
+ o
->reloc_count
;
12553 for (i
= 0, skip
= 0; i
< o
->size
/ PDR_SIZE
; i
++)
12555 if (bfd_elf_reloc_symbol_deleted_p (i
* PDR_SIZE
, cookie
))
12564 mips_elf_section_data (o
)->u
.tdata
= tdata
;
12565 if (o
->rawsize
== 0)
12566 o
->rawsize
= o
->size
;
12567 o
->size
-= skip
* PDR_SIZE
;
12573 if (! info
->keep_memory
)
12574 free (cookie
->rels
);
12580 _bfd_mips_elf_ignore_discarded_relocs (asection
*sec
)
12582 if (strcmp (sec
->name
, ".pdr") == 0)
12588 _bfd_mips_elf_write_section (bfd
*output_bfd
,
12589 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
12590 asection
*sec
, bfd_byte
*contents
)
12592 bfd_byte
*to
, *from
, *end
;
12595 if (strcmp (sec
->name
, ".pdr") != 0)
12598 if (mips_elf_section_data (sec
)->u
.tdata
== NULL
)
12602 end
= contents
+ sec
->size
;
12603 for (from
= contents
, i
= 0;
12605 from
+= PDR_SIZE
, i
++)
12607 if ((mips_elf_section_data (sec
)->u
.tdata
)[i
] == 1)
12610 memcpy (to
, from
, PDR_SIZE
);
12613 bfd_set_section_contents (output_bfd
, sec
->output_section
, contents
,
12614 sec
->output_offset
, sec
->size
);
12618 /* microMIPS code retains local labels for linker relaxation. Omit them
12619 from output by default for clarity. */
12622 _bfd_mips_elf_is_target_special_symbol (bfd
*abfd
, asymbol
*sym
)
12624 return _bfd_elf_is_local_label_name (abfd
, sym
->name
);
12627 /* MIPS ELF uses a special find_nearest_line routine in order the
12628 handle the ECOFF debugging information. */
12630 struct mips_elf_find_line
12632 struct ecoff_debug_info d
;
12633 struct ecoff_find_line i
;
12637 _bfd_mips_elf_find_nearest_line (bfd
*abfd
, asymbol
**symbols
,
12638 asection
*section
, bfd_vma offset
,
12639 const char **filename_ptr
,
12640 const char **functionname_ptr
,
12641 unsigned int *line_ptr
,
12642 unsigned int *discriminator_ptr
)
12646 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
12647 filename_ptr
, functionname_ptr
,
12648 line_ptr
, discriminator_ptr
,
12649 dwarf_debug_sections
,
12650 ABI_64_P (abfd
) ? 8 : 0,
12651 &elf_tdata (abfd
)->dwarf2_find_line_info
))
12654 if (_bfd_dwarf1_find_nearest_line (abfd
, symbols
, section
, offset
,
12655 filename_ptr
, functionname_ptr
,
12659 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
12662 flagword origflags
;
12663 struct mips_elf_find_line
*fi
;
12664 const struct ecoff_debug_swap
* const swap
=
12665 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
12667 /* If we are called during a link, mips_elf_final_link may have
12668 cleared the SEC_HAS_CONTENTS field. We force it back on here
12669 if appropriate (which it normally will be). */
12670 origflags
= msec
->flags
;
12671 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
12672 msec
->flags
|= SEC_HAS_CONTENTS
;
12674 fi
= mips_elf_tdata (abfd
)->find_line_info
;
12677 bfd_size_type external_fdr_size
;
12680 struct fdr
*fdr_ptr
;
12681 bfd_size_type amt
= sizeof (struct mips_elf_find_line
);
12683 fi
= bfd_zalloc (abfd
, amt
);
12686 msec
->flags
= origflags
;
12690 if (! _bfd_mips_elf_read_ecoff_info (abfd
, msec
, &fi
->d
))
12692 msec
->flags
= origflags
;
12696 /* Swap in the FDR information. */
12697 amt
= fi
->d
.symbolic_header
.ifdMax
* sizeof (struct fdr
);
12698 fi
->d
.fdr
= bfd_alloc (abfd
, amt
);
12699 if (fi
->d
.fdr
== NULL
)
12701 msec
->flags
= origflags
;
12704 external_fdr_size
= swap
->external_fdr_size
;
12705 fdr_ptr
= fi
->d
.fdr
;
12706 fraw_src
= (char *) fi
->d
.external_fdr
;
12707 fraw_end
= (fraw_src
12708 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
12709 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
12710 (*swap
->swap_fdr_in
) (abfd
, fraw_src
, fdr_ptr
);
12712 mips_elf_tdata (abfd
)->find_line_info
= fi
;
12714 /* Note that we don't bother to ever free this information.
12715 find_nearest_line is either called all the time, as in
12716 objdump -l, so the information should be saved, or it is
12717 rarely called, as in ld error messages, so the memory
12718 wasted is unimportant. Still, it would probably be a
12719 good idea for free_cached_info to throw it away. */
12722 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
12723 &fi
->i
, filename_ptr
, functionname_ptr
,
12726 msec
->flags
= origflags
;
12730 msec
->flags
= origflags
;
12733 /* Fall back on the generic ELF find_nearest_line routine. */
12735 return _bfd_elf_find_nearest_line (abfd
, symbols
, section
, offset
,
12736 filename_ptr
, functionname_ptr
,
12737 line_ptr
, discriminator_ptr
);
12741 _bfd_mips_elf_find_inliner_info (bfd
*abfd
,
12742 const char **filename_ptr
,
12743 const char **functionname_ptr
,
12744 unsigned int *line_ptr
)
12747 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
12748 functionname_ptr
, line_ptr
,
12749 & elf_tdata (abfd
)->dwarf2_find_line_info
);
12754 /* When are writing out the .options or .MIPS.options section,
12755 remember the bytes we are writing out, so that we can install the
12756 GP value in the section_processing routine. */
12759 _bfd_mips_elf_set_section_contents (bfd
*abfd
, sec_ptr section
,
12760 const void *location
,
12761 file_ptr offset
, bfd_size_type count
)
12763 if (MIPS_ELF_OPTIONS_SECTION_NAME_P (section
->name
))
12767 if (elf_section_data (section
) == NULL
)
12769 bfd_size_type amt
= sizeof (struct bfd_elf_section_data
);
12770 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
12771 if (elf_section_data (section
) == NULL
)
12774 c
= mips_elf_section_data (section
)->u
.tdata
;
12777 c
= bfd_zalloc (abfd
, section
->size
);
12780 mips_elf_section_data (section
)->u
.tdata
= c
;
12783 memcpy (c
+ offset
, location
, count
);
12786 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
,
12790 /* This is almost identical to bfd_generic_get_... except that some
12791 MIPS relocations need to be handled specially. Sigh. */
12794 _bfd_elf_mips_get_relocated_section_contents
12796 struct bfd_link_info
*link_info
,
12797 struct bfd_link_order
*link_order
,
12799 bfd_boolean relocatable
,
12802 /* Get enough memory to hold the stuff */
12803 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
12804 asection
*input_section
= link_order
->u
.indirect
.section
;
12807 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
12808 arelent
**reloc_vector
= NULL
;
12811 if (reloc_size
< 0)
12814 reloc_vector
= bfd_malloc (reloc_size
);
12815 if (reloc_vector
== NULL
&& reloc_size
!= 0)
12818 /* read in the section */
12819 sz
= input_section
->rawsize
? input_section
->rawsize
: input_section
->size
;
12820 if (!bfd_get_section_contents (input_bfd
, input_section
, data
, 0, sz
))
12823 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
12827 if (reloc_count
< 0)
12830 if (reloc_count
> 0)
12835 bfd_vma gp
= 0x12345678; /* initialize just to shut gcc up */
12838 struct bfd_hash_entry
*h
;
12839 struct bfd_link_hash_entry
*lh
;
12840 /* Skip all this stuff if we aren't mixing formats. */
12841 if (abfd
&& input_bfd
12842 && abfd
->xvec
== input_bfd
->xvec
)
12846 h
= bfd_hash_lookup (&link_info
->hash
->table
, "_gp", FALSE
, FALSE
);
12847 lh
= (struct bfd_link_hash_entry
*) h
;
12854 case bfd_link_hash_undefined
:
12855 case bfd_link_hash_undefweak
:
12856 case bfd_link_hash_common
:
12859 case bfd_link_hash_defined
:
12860 case bfd_link_hash_defweak
:
12862 gp
= lh
->u
.def
.value
;
12864 case bfd_link_hash_indirect
:
12865 case bfd_link_hash_warning
:
12867 /* @@FIXME ignoring warning for now */
12869 case bfd_link_hash_new
:
12878 for (parent
= reloc_vector
; *parent
!= NULL
; parent
++)
12880 char *error_message
= NULL
;
12881 bfd_reloc_status_type r
;
12883 /* Specific to MIPS: Deal with relocation types that require
12884 knowing the gp of the output bfd. */
12885 asymbol
*sym
= *(*parent
)->sym_ptr_ptr
;
12887 /* If we've managed to find the gp and have a special
12888 function for the relocation then go ahead, else default
12889 to the generic handling. */
12891 && (*parent
)->howto
->special_function
12892 == _bfd_mips_elf32_gprel16_reloc
)
12893 r
= _bfd_mips_elf_gprel16_with_gp (input_bfd
, sym
, *parent
,
12894 input_section
, relocatable
,
12897 r
= bfd_perform_relocation (input_bfd
, *parent
, data
,
12899 relocatable
? abfd
: NULL
,
12904 asection
*os
= input_section
->output_section
;
12906 /* A partial link, so keep the relocs */
12907 os
->orelocation
[os
->reloc_count
] = *parent
;
12911 if (r
!= bfd_reloc_ok
)
12915 case bfd_reloc_undefined
:
12916 if (!((*link_info
->callbacks
->undefined_symbol
)
12917 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
12918 input_bfd
, input_section
, (*parent
)->address
, TRUE
)))
12921 case bfd_reloc_dangerous
:
12922 BFD_ASSERT (error_message
!= NULL
);
12923 if (!((*link_info
->callbacks
->reloc_dangerous
)
12924 (link_info
, error_message
, input_bfd
, input_section
,
12925 (*parent
)->address
)))
12928 case bfd_reloc_overflow
:
12929 if (!((*link_info
->callbacks
->reloc_overflow
)
12931 bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
12932 (*parent
)->howto
->name
, (*parent
)->addend
,
12933 input_bfd
, input_section
, (*parent
)->address
)))
12936 case bfd_reloc_outofrange
:
12945 if (reloc_vector
!= NULL
)
12946 free (reloc_vector
);
12950 if (reloc_vector
!= NULL
)
12951 free (reloc_vector
);
12956 mips_elf_relax_delete_bytes (bfd
*abfd
,
12957 asection
*sec
, bfd_vma addr
, int count
)
12959 Elf_Internal_Shdr
*symtab_hdr
;
12960 unsigned int sec_shndx
;
12961 bfd_byte
*contents
;
12962 Elf_Internal_Rela
*irel
, *irelend
;
12963 Elf_Internal_Sym
*isym
;
12964 Elf_Internal_Sym
*isymend
;
12965 struct elf_link_hash_entry
**sym_hashes
;
12966 struct elf_link_hash_entry
**end_hashes
;
12967 struct elf_link_hash_entry
**start_hashes
;
12968 unsigned int symcount
;
12970 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
12971 contents
= elf_section_data (sec
)->this_hdr
.contents
;
12973 irel
= elf_section_data (sec
)->relocs
;
12974 irelend
= irel
+ sec
->reloc_count
;
12976 /* Actually delete the bytes. */
12977 memmove (contents
+ addr
, contents
+ addr
+ count
,
12978 (size_t) (sec
->size
- addr
- count
));
12979 sec
->size
-= count
;
12981 /* Adjust all the relocs. */
12982 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
12984 /* Get the new reloc address. */
12985 if (irel
->r_offset
> addr
)
12986 irel
->r_offset
-= count
;
12989 BFD_ASSERT (addr
% 2 == 0);
12990 BFD_ASSERT (count
% 2 == 0);
12992 /* Adjust the local symbols defined in this section. */
12993 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
12994 isym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
12995 for (isymend
= isym
+ symtab_hdr
->sh_info
; isym
< isymend
; isym
++)
12996 if (isym
->st_shndx
== sec_shndx
&& isym
->st_value
> addr
)
12997 isym
->st_value
-= count
;
12999 /* Now adjust the global symbols defined in this section. */
13000 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
13001 - symtab_hdr
->sh_info
);
13002 sym_hashes
= start_hashes
= elf_sym_hashes (abfd
);
13003 end_hashes
= sym_hashes
+ symcount
;
13005 for (; sym_hashes
< end_hashes
; sym_hashes
++)
13007 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
13009 if ((sym_hash
->root
.type
== bfd_link_hash_defined
13010 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
13011 && sym_hash
->root
.u
.def
.section
== sec
)
13013 bfd_vma value
= sym_hash
->root
.u
.def
.value
;
13015 if (ELF_ST_IS_MICROMIPS (sym_hash
->other
))
13016 value
&= MINUS_TWO
;
13018 sym_hash
->root
.u
.def
.value
-= count
;
13026 /* Opcodes needed for microMIPS relaxation as found in
13027 opcodes/micromips-opc.c. */
13029 struct opcode_descriptor
{
13030 unsigned long match
;
13031 unsigned long mask
;
13034 /* The $ra register aka $31. */
13038 /* 32-bit instruction format register fields. */
13040 #define OP32_SREG(opcode) (((opcode) >> 16) & 0x1f)
13041 #define OP32_TREG(opcode) (((opcode) >> 21) & 0x1f)
13043 /* Check if a 5-bit register index can be abbreviated to 3 bits. */
13045 #define OP16_VALID_REG(r) \
13046 ((2 <= (r) && (r) <= 7) || (16 <= (r) && (r) <= 17))
13049 /* 32-bit and 16-bit branches. */
13051 static const struct opcode_descriptor b_insns_32
[] = {
13052 { /* "b", "p", */ 0x40400000, 0xffff0000 }, /* bgez 0 */
13053 { /* "b", "p", */ 0x94000000, 0xffff0000 }, /* beq 0, 0 */
13054 { 0, 0 } /* End marker for find_match(). */
13057 static const struct opcode_descriptor bc_insn_32
=
13058 { /* "bc(1|2)(ft)", "N,p", */ 0x42800000, 0xfec30000 };
13060 static const struct opcode_descriptor bz_insn_32
=
13061 { /* "b(g|l)(e|t)z", "s,p", */ 0x40000000, 0xff200000 };
13063 static const struct opcode_descriptor bzal_insn_32
=
13064 { /* "b(ge|lt)zal", "s,p", */ 0x40200000, 0xffa00000 };
13066 static const struct opcode_descriptor beq_insn_32
=
13067 { /* "b(eq|ne)", "s,t,p", */ 0x94000000, 0xdc000000 };
13069 static const struct opcode_descriptor b_insn_16
=
13070 { /* "b", "mD", */ 0xcc00, 0xfc00 };
13072 static const struct opcode_descriptor bz_insn_16
=
13073 { /* "b(eq|ne)z", "md,mE", */ 0x8c00, 0xdc00 };
13076 /* 32-bit and 16-bit branch EQ and NE zero. */
13078 /* NOTE: All opcode tables have BEQ/BNE in the same order: first the
13079 eq and second the ne. This convention is used when replacing a
13080 32-bit BEQ/BNE with the 16-bit version. */
13082 #define BZC32_REG_FIELD(r) (((r) & 0x1f) << 16)
13084 static const struct opcode_descriptor bz_rs_insns_32
[] = {
13085 { /* "beqz", "s,p", */ 0x94000000, 0xffe00000 },
13086 { /* "bnez", "s,p", */ 0xb4000000, 0xffe00000 },
13087 { 0, 0 } /* End marker for find_match(). */
13090 static const struct opcode_descriptor bz_rt_insns_32
[] = {
13091 { /* "beqz", "t,p", */ 0x94000000, 0xfc01f000 },
13092 { /* "bnez", "t,p", */ 0xb4000000, 0xfc01f000 },
13093 { 0, 0 } /* End marker for find_match(). */
13096 static const struct opcode_descriptor bzc_insns_32
[] = {
13097 { /* "beqzc", "s,p", */ 0x40e00000, 0xffe00000 },
13098 { /* "bnezc", "s,p", */ 0x40a00000, 0xffe00000 },
13099 { 0, 0 } /* End marker for find_match(). */
13102 static const struct opcode_descriptor bz_insns_16
[] = {
13103 { /* "beqz", "md,mE", */ 0x8c00, 0xfc00 },
13104 { /* "bnez", "md,mE", */ 0xac00, 0xfc00 },
13105 { 0, 0 } /* End marker for find_match(). */
13108 /* Switch between a 5-bit register index and its 3-bit shorthand. */
13110 #define BZ16_REG(opcode) ((((((opcode) >> 7) & 7) + 0x1e) & 0x17) + 2)
13111 #define BZ16_REG_FIELD(r) \
13112 (((2 <= (r) && (r) <= 7) ? (r) : ((r) - 16)) << 7)
13115 /* 32-bit instructions with a delay slot. */
13117 static const struct opcode_descriptor jal_insn_32_bd16
=
13118 { /* "jals", "a", */ 0x74000000, 0xfc000000 };
13120 static const struct opcode_descriptor jal_insn_32_bd32
=
13121 { /* "jal", "a", */ 0xf4000000, 0xfc000000 };
13123 static const struct opcode_descriptor jal_x_insn_32_bd32
=
13124 { /* "jal[x]", "a", */ 0xf0000000, 0xf8000000 };
13126 static const struct opcode_descriptor j_insn_32
=
13127 { /* "j", "a", */ 0xd4000000, 0xfc000000 };
13129 static const struct opcode_descriptor jalr_insn_32
=
13130 { /* "jalr[.hb]", "t,s", */ 0x00000f3c, 0xfc00efff };
13132 /* This table can be compacted, because no opcode replacement is made. */
13134 static const struct opcode_descriptor ds_insns_32_bd16
[] = {
13135 { /* "jals", "a", */ 0x74000000, 0xfc000000 },
13137 { /* "jalrs[.hb]", "t,s", */ 0x00004f3c, 0xfc00efff },
13138 { /* "b(ge|lt)zals", "s,p", */ 0x42200000, 0xffa00000 },
13140 { /* "b(g|l)(e|t)z", "s,p", */ 0x40000000, 0xff200000 },
13141 { /* "b(eq|ne)", "s,t,p", */ 0x94000000, 0xdc000000 },
13142 { /* "j", "a", */ 0xd4000000, 0xfc000000 },
13143 { 0, 0 } /* End marker for find_match(). */
13146 /* This table can be compacted, because no opcode replacement is made. */
13148 static const struct opcode_descriptor ds_insns_32_bd32
[] = {
13149 { /* "jal[x]", "a", */ 0xf0000000, 0xf8000000 },
13151 { /* "jalr[.hb]", "t,s", */ 0x00000f3c, 0xfc00efff },
13152 { /* "b(ge|lt)zal", "s,p", */ 0x40200000, 0xffa00000 },
13153 { 0, 0 } /* End marker for find_match(). */
13157 /* 16-bit instructions with a delay slot. */
13159 static const struct opcode_descriptor jalr_insn_16_bd16
=
13160 { /* "jalrs", "my,mj", */ 0x45e0, 0xffe0 };
13162 static const struct opcode_descriptor jalr_insn_16_bd32
=
13163 { /* "jalr", "my,mj", */ 0x45c0, 0xffe0 };
13165 static const struct opcode_descriptor jr_insn_16
=
13166 { /* "jr", "mj", */ 0x4580, 0xffe0 };
13168 #define JR16_REG(opcode) ((opcode) & 0x1f)
13170 /* This table can be compacted, because no opcode replacement is made. */
13172 static const struct opcode_descriptor ds_insns_16_bd16
[] = {
13173 { /* "jalrs", "my,mj", */ 0x45e0, 0xffe0 },
13175 { /* "b", "mD", */ 0xcc00, 0xfc00 },
13176 { /* "b(eq|ne)z", "md,mE", */ 0x8c00, 0xdc00 },
13177 { /* "jr", "mj", */ 0x4580, 0xffe0 },
13178 { 0, 0 } /* End marker for find_match(). */
13182 /* LUI instruction. */
13184 static const struct opcode_descriptor lui_insn
=
13185 { /* "lui", "s,u", */ 0x41a00000, 0xffe00000 };
13188 /* ADDIU instruction. */
13190 static const struct opcode_descriptor addiu_insn
=
13191 { /* "addiu", "t,r,j", */ 0x30000000, 0xfc000000 };
13193 static const struct opcode_descriptor addiupc_insn
=
13194 { /* "addiu", "mb,$pc,mQ", */ 0x78000000, 0xfc000000 };
13196 #define ADDIUPC_REG_FIELD(r) \
13197 (((2 <= (r) && (r) <= 7) ? (r) : ((r) - 16)) << 23)
13200 /* Relaxable instructions in a JAL delay slot: MOVE. */
13202 /* The 16-bit move has rd in 9:5 and rs in 4:0. The 32-bit moves
13203 (ADDU, OR) have rd in 15:11 and rs in 10:16. */
13204 #define MOVE32_RD(opcode) (((opcode) >> 11) & 0x1f)
13205 #define MOVE32_RS(opcode) (((opcode) >> 16) & 0x1f)
13207 #define MOVE16_RD_FIELD(r) (((r) & 0x1f) << 5)
13208 #define MOVE16_RS_FIELD(r) (((r) & 0x1f) )
13210 static const struct opcode_descriptor move_insns_32
[] = {
13211 { /* "move", "d,s", */ 0x00000290, 0xffe007ff }, /* or d,s,$0 */
13212 { /* "move", "d,s", */ 0x00000150, 0xffe007ff }, /* addu d,s,$0 */
13213 { 0, 0 } /* End marker for find_match(). */
13216 static const struct opcode_descriptor move_insn_16
=
13217 { /* "move", "mp,mj", */ 0x0c00, 0xfc00 };
13220 /* NOP instructions. */
13222 static const struct opcode_descriptor nop_insn_32
=
13223 { /* "nop", "", */ 0x00000000, 0xffffffff };
13225 static const struct opcode_descriptor nop_insn_16
=
13226 { /* "nop", "", */ 0x0c00, 0xffff };
13229 /* Instruction match support. */
13231 #define MATCH(opcode, insn) ((opcode & insn.mask) == insn.match)
13234 find_match (unsigned long opcode
, const struct opcode_descriptor insn
[])
13236 unsigned long indx
;
13238 for (indx
= 0; insn
[indx
].mask
!= 0; indx
++)
13239 if (MATCH (opcode
, insn
[indx
]))
13246 /* Branch and delay slot decoding support. */
13248 /* If PTR points to what *might* be a 16-bit branch or jump, then
13249 return the minimum length of its delay slot, otherwise return 0.
13250 Non-zero results are not definitive as we might be checking against
13251 the second half of another instruction. */
13254 check_br16_dslot (bfd
*abfd
, bfd_byte
*ptr
)
13256 unsigned long opcode
;
13259 opcode
= bfd_get_16 (abfd
, ptr
);
13260 if (MATCH (opcode
, jalr_insn_16_bd32
) != 0)
13261 /* 16-bit branch/jump with a 32-bit delay slot. */
13263 else if (MATCH (opcode
, jalr_insn_16_bd16
) != 0
13264 || find_match (opcode
, ds_insns_16_bd16
) >= 0)
13265 /* 16-bit branch/jump with a 16-bit delay slot. */
13268 /* No delay slot. */
13274 /* If PTR points to what *might* be a 32-bit branch or jump, then
13275 return the minimum length of its delay slot, otherwise return 0.
13276 Non-zero results are not definitive as we might be checking against
13277 the second half of another instruction. */
13280 check_br32_dslot (bfd
*abfd
, bfd_byte
*ptr
)
13282 unsigned long opcode
;
13285 opcode
= bfd_get_micromips_32 (abfd
, ptr
);
13286 if (find_match (opcode
, ds_insns_32_bd32
) >= 0)
13287 /* 32-bit branch/jump with a 32-bit delay slot. */
13289 else if (find_match (opcode
, ds_insns_32_bd16
) >= 0)
13290 /* 32-bit branch/jump with a 16-bit delay slot. */
13293 /* No delay slot. */
13299 /* If PTR points to a 16-bit branch or jump with a 32-bit delay slot
13300 that doesn't fiddle with REG, then return TRUE, otherwise FALSE. */
13303 check_br16 (bfd
*abfd
, bfd_byte
*ptr
, unsigned long reg
)
13305 unsigned long opcode
;
13307 opcode
= bfd_get_16 (abfd
, ptr
);
13308 if (MATCH (opcode
, b_insn_16
)
13310 || (MATCH (opcode
, jr_insn_16
) && reg
!= JR16_REG (opcode
))
13312 || (MATCH (opcode
, bz_insn_16
) && reg
!= BZ16_REG (opcode
))
13313 /* BEQZ16, BNEZ16 */
13314 || (MATCH (opcode
, jalr_insn_16_bd32
)
13316 && reg
!= JR16_REG (opcode
) && reg
!= RA
))
13322 /* If PTR points to a 32-bit branch or jump that doesn't fiddle with REG,
13323 then return TRUE, otherwise FALSE. */
13326 check_br32 (bfd
*abfd
, bfd_byte
*ptr
, unsigned long reg
)
13328 unsigned long opcode
;
13330 opcode
= bfd_get_micromips_32 (abfd
, ptr
);
13331 if (MATCH (opcode
, j_insn_32
)
13333 || MATCH (opcode
, bc_insn_32
)
13334 /* BC1F, BC1T, BC2F, BC2T */
13335 || (MATCH (opcode
, jal_x_insn_32_bd32
) && reg
!= RA
)
13337 || (MATCH (opcode
, bz_insn_32
) && reg
!= OP32_SREG (opcode
))
13338 /* BGEZ, BGTZ, BLEZ, BLTZ */
13339 || (MATCH (opcode
, bzal_insn_32
)
13340 /* BGEZAL, BLTZAL */
13341 && reg
!= OP32_SREG (opcode
) && reg
!= RA
)
13342 || ((MATCH (opcode
, jalr_insn_32
) || MATCH (opcode
, beq_insn_32
))
13343 /* JALR, JALR.HB, BEQ, BNE */
13344 && reg
!= OP32_SREG (opcode
) && reg
!= OP32_TREG (opcode
)))
13350 /* If the instruction encoding at PTR and relocations [INTERNAL_RELOCS,
13351 IRELEND) at OFFSET indicate that there must be a compact branch there,
13352 then return TRUE, otherwise FALSE. */
13355 check_relocated_bzc (bfd
*abfd
, const bfd_byte
*ptr
, bfd_vma offset
,
13356 const Elf_Internal_Rela
*internal_relocs
,
13357 const Elf_Internal_Rela
*irelend
)
13359 const Elf_Internal_Rela
*irel
;
13360 unsigned long opcode
;
13362 opcode
= bfd_get_micromips_32 (abfd
, ptr
);
13363 if (find_match (opcode
, bzc_insns_32
) < 0)
13366 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
13367 if (irel
->r_offset
== offset
13368 && ELF32_R_TYPE (irel
->r_info
) == R_MICROMIPS_PC16_S1
)
13374 /* Bitsize checking. */
13375 #define IS_BITSIZE(val, N) \
13376 (((((val) & ((1ULL << (N)) - 1)) ^ (1ULL << ((N) - 1))) \
13377 - (1ULL << ((N) - 1))) == (val))
13381 _bfd_mips_elf_relax_section (bfd
*abfd
, asection
*sec
,
13382 struct bfd_link_info
*link_info
,
13383 bfd_boolean
*again
)
13385 bfd_boolean insn32
= mips_elf_hash_table (link_info
)->insn32
;
13386 Elf_Internal_Shdr
*symtab_hdr
;
13387 Elf_Internal_Rela
*internal_relocs
;
13388 Elf_Internal_Rela
*irel
, *irelend
;
13389 bfd_byte
*contents
= NULL
;
13390 Elf_Internal_Sym
*isymbuf
= NULL
;
13392 /* Assume nothing changes. */
13395 /* We don't have to do anything for a relocatable link, if
13396 this section does not have relocs, or if this is not a
13399 if (bfd_link_relocatable (link_info
)
13400 || (sec
->flags
& SEC_RELOC
) == 0
13401 || sec
->reloc_count
== 0
13402 || (sec
->flags
& SEC_CODE
) == 0)
13405 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
13407 /* Get a copy of the native relocations. */
13408 internal_relocs
= (_bfd_elf_link_read_relocs
13409 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
13410 link_info
->keep_memory
));
13411 if (internal_relocs
== NULL
)
13414 /* Walk through them looking for relaxing opportunities. */
13415 irelend
= internal_relocs
+ sec
->reloc_count
;
13416 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
13418 unsigned long r_symndx
= ELF32_R_SYM (irel
->r_info
);
13419 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
13420 bfd_boolean target_is_micromips_code_p
;
13421 unsigned long opcode
;
13427 /* The number of bytes to delete for relaxation and from where
13428 to delete these bytes starting at irel->r_offset. */
13432 /* If this isn't something that can be relaxed, then ignore
13434 if (r_type
!= R_MICROMIPS_HI16
13435 && r_type
!= R_MICROMIPS_PC16_S1
13436 && r_type
!= R_MICROMIPS_26_S1
)
13439 /* Get the section contents if we haven't done so already. */
13440 if (contents
== NULL
)
13442 /* Get cached copy if it exists. */
13443 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
13444 contents
= elf_section_data (sec
)->this_hdr
.contents
;
13445 /* Go get them off disk. */
13446 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
13449 ptr
= contents
+ irel
->r_offset
;
13451 /* Read this BFD's local symbols if we haven't done so already. */
13452 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
13454 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
13455 if (isymbuf
== NULL
)
13456 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
13457 symtab_hdr
->sh_info
, 0,
13459 if (isymbuf
== NULL
)
13463 /* Get the value of the symbol referred to by the reloc. */
13464 if (r_symndx
< symtab_hdr
->sh_info
)
13466 /* A local symbol. */
13467 Elf_Internal_Sym
*isym
;
13470 isym
= isymbuf
+ r_symndx
;
13471 if (isym
->st_shndx
== SHN_UNDEF
)
13472 sym_sec
= bfd_und_section_ptr
;
13473 else if (isym
->st_shndx
== SHN_ABS
)
13474 sym_sec
= bfd_abs_section_ptr
;
13475 else if (isym
->st_shndx
== SHN_COMMON
)
13476 sym_sec
= bfd_com_section_ptr
;
13478 sym_sec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
13479 symval
= (isym
->st_value
13480 + sym_sec
->output_section
->vma
13481 + sym_sec
->output_offset
);
13482 target_is_micromips_code_p
= ELF_ST_IS_MICROMIPS (isym
->st_other
);
13486 unsigned long indx
;
13487 struct elf_link_hash_entry
*h
;
13489 /* An external symbol. */
13490 indx
= r_symndx
- symtab_hdr
->sh_info
;
13491 h
= elf_sym_hashes (abfd
)[indx
];
13492 BFD_ASSERT (h
!= NULL
);
13494 if (h
->root
.type
!= bfd_link_hash_defined
13495 && h
->root
.type
!= bfd_link_hash_defweak
)
13496 /* This appears to be a reference to an undefined
13497 symbol. Just ignore it -- it will be caught by the
13498 regular reloc processing. */
13501 symval
= (h
->root
.u
.def
.value
13502 + h
->root
.u
.def
.section
->output_section
->vma
13503 + h
->root
.u
.def
.section
->output_offset
);
13504 target_is_micromips_code_p
= (!h
->needs_plt
13505 && ELF_ST_IS_MICROMIPS (h
->other
));
13509 /* For simplicity of coding, we are going to modify the
13510 section contents, the section relocs, and the BFD symbol
13511 table. We must tell the rest of the code not to free up this
13512 information. It would be possible to instead create a table
13513 of changes which have to be made, as is done in coff-mips.c;
13514 that would be more work, but would require less memory when
13515 the linker is run. */
13517 /* Only 32-bit instructions relaxed. */
13518 if (irel
->r_offset
+ 4 > sec
->size
)
13521 opcode
= bfd_get_micromips_32 (abfd
, ptr
);
13523 /* This is the pc-relative distance from the instruction the
13524 relocation is applied to, to the symbol referred. */
13526 - (sec
->output_section
->vma
+ sec
->output_offset
)
13529 /* R_MICROMIPS_HI16 / LUI relaxation to nil, performing relaxation
13530 of corresponding R_MICROMIPS_LO16 to R_MICROMIPS_HI0_LO16 or
13531 R_MICROMIPS_PC23_S2. The R_MICROMIPS_PC23_S2 condition is
13533 (symval % 4 == 0 && IS_BITSIZE (pcrval, 25))
13535 where pcrval has first to be adjusted to apply against the LO16
13536 location (we make the adjustment later on, when we have figured
13537 out the offset). */
13538 if (r_type
== R_MICROMIPS_HI16
&& MATCH (opcode
, lui_insn
))
13540 bfd_boolean bzc
= FALSE
;
13541 unsigned long nextopc
;
13545 /* Give up if the previous reloc was a HI16 against this symbol
13547 if (irel
> internal_relocs
13548 && ELF32_R_TYPE (irel
[-1].r_info
) == R_MICROMIPS_HI16
13549 && ELF32_R_SYM (irel
[-1].r_info
) == r_symndx
)
13552 /* Or if the next reloc is not a LO16 against this symbol. */
13553 if (irel
+ 1 >= irelend
13554 || ELF32_R_TYPE (irel
[1].r_info
) != R_MICROMIPS_LO16
13555 || ELF32_R_SYM (irel
[1].r_info
) != r_symndx
)
13558 /* Or if the second next reloc is a LO16 against this symbol too. */
13559 if (irel
+ 2 >= irelend
13560 && ELF32_R_TYPE (irel
[2].r_info
) == R_MICROMIPS_LO16
13561 && ELF32_R_SYM (irel
[2].r_info
) == r_symndx
)
13564 /* See if the LUI instruction *might* be in a branch delay slot.
13565 We check whether what looks like a 16-bit branch or jump is
13566 actually an immediate argument to a compact branch, and let
13567 it through if so. */
13568 if (irel
->r_offset
>= 2
13569 && check_br16_dslot (abfd
, ptr
- 2)
13570 && !(irel
->r_offset
>= 4
13571 && (bzc
= check_relocated_bzc (abfd
,
13572 ptr
- 4, irel
->r_offset
- 4,
13573 internal_relocs
, irelend
))))
13575 if (irel
->r_offset
>= 4
13577 && check_br32_dslot (abfd
, ptr
- 4))
13580 reg
= OP32_SREG (opcode
);
13582 /* We only relax adjacent instructions or ones separated with
13583 a branch or jump that has a delay slot. The branch or jump
13584 must not fiddle with the register used to hold the address.
13585 Subtract 4 for the LUI itself. */
13586 offset
= irel
[1].r_offset
- irel
[0].r_offset
;
13587 switch (offset
- 4)
13592 if (check_br16 (abfd
, ptr
+ 4, reg
))
13596 if (check_br32 (abfd
, ptr
+ 4, reg
))
13603 nextopc
= bfd_get_micromips_32 (abfd
, contents
+ irel
[1].r_offset
);
13605 /* Give up unless the same register is used with both
13607 if (OP32_SREG (nextopc
) != reg
)
13610 /* Now adjust pcrval, subtracting the offset to the LO16 reloc
13611 and rounding up to take masking of the two LSBs into account. */
13612 pcrval
= ((pcrval
- offset
+ 3) | 3) ^ 3;
13614 /* R_MICROMIPS_LO16 relaxation to R_MICROMIPS_HI0_LO16. */
13615 if (IS_BITSIZE (symval
, 16))
13617 /* Fix the relocation's type. */
13618 irel
[1].r_info
= ELF32_R_INFO (r_symndx
, R_MICROMIPS_HI0_LO16
);
13620 /* Instructions using R_MICROMIPS_LO16 have the base or
13621 source register in bits 20:16. This register becomes $0
13622 (zero) as the result of the R_MICROMIPS_HI16 being 0. */
13623 nextopc
&= ~0x001f0000;
13624 bfd_put_16 (abfd
, (nextopc
>> 16) & 0xffff,
13625 contents
+ irel
[1].r_offset
);
13628 /* R_MICROMIPS_LO16 / ADDIU relaxation to R_MICROMIPS_PC23_S2.
13629 We add 4 to take LUI deletion into account while checking
13630 the PC-relative distance. */
13631 else if (symval
% 4 == 0
13632 && IS_BITSIZE (pcrval
+ 4, 25)
13633 && MATCH (nextopc
, addiu_insn
)
13634 && OP32_TREG (nextopc
) == OP32_SREG (nextopc
)
13635 && OP16_VALID_REG (OP32_TREG (nextopc
)))
13637 /* Fix the relocation's type. */
13638 irel
[1].r_info
= ELF32_R_INFO (r_symndx
, R_MICROMIPS_PC23_S2
);
13640 /* Replace ADDIU with the ADDIUPC version. */
13641 nextopc
= (addiupc_insn
.match
13642 | ADDIUPC_REG_FIELD (OP32_TREG (nextopc
)));
13644 bfd_put_micromips_32 (abfd
, nextopc
,
13645 contents
+ irel
[1].r_offset
);
13648 /* Can't do anything, give up, sigh... */
13652 /* Fix the relocation's type. */
13653 irel
->r_info
= ELF32_R_INFO (r_symndx
, R_MIPS_NONE
);
13655 /* Delete the LUI instruction: 4 bytes at irel->r_offset. */
13660 /* Compact branch relaxation -- due to the multitude of macros
13661 employed by the compiler/assembler, compact branches are not
13662 always generated. Obviously, this can/will be fixed elsewhere,
13663 but there is no drawback in double checking it here. */
13664 else if (r_type
== R_MICROMIPS_PC16_S1
13665 && irel
->r_offset
+ 5 < sec
->size
13666 && ((fndopc
= find_match (opcode
, bz_rs_insns_32
)) >= 0
13667 || (fndopc
= find_match (opcode
, bz_rt_insns_32
)) >= 0)
13669 && (delcnt
= MATCH (bfd_get_16 (abfd
, ptr
+ 4),
13670 nop_insn_16
) ? 2 : 0))
13671 || (irel
->r_offset
+ 7 < sec
->size
13672 && (delcnt
= MATCH (bfd_get_micromips_32 (abfd
,
13674 nop_insn_32
) ? 4 : 0))))
13678 reg
= OP32_SREG (opcode
) ? OP32_SREG (opcode
) : OP32_TREG (opcode
);
13680 /* Replace BEQZ/BNEZ with the compact version. */
13681 opcode
= (bzc_insns_32
[fndopc
].match
13682 | BZC32_REG_FIELD (reg
)
13683 | (opcode
& 0xffff)); /* Addend value. */
13685 bfd_put_micromips_32 (abfd
, opcode
, ptr
);
13687 /* Delete the delay slot NOP: two or four bytes from
13688 irel->offset + 4; delcnt has already been set above. */
13692 /* R_MICROMIPS_PC16_S1 relaxation to R_MICROMIPS_PC10_S1. We need
13693 to check the distance from the next instruction, so subtract 2. */
13695 && r_type
== R_MICROMIPS_PC16_S1
13696 && IS_BITSIZE (pcrval
- 2, 11)
13697 && find_match (opcode
, b_insns_32
) >= 0)
13699 /* Fix the relocation's type. */
13700 irel
->r_info
= ELF32_R_INFO (r_symndx
, R_MICROMIPS_PC10_S1
);
13702 /* Replace the 32-bit opcode with a 16-bit opcode. */
13705 | (opcode
& 0x3ff)), /* Addend value. */
13708 /* Delete 2 bytes from irel->r_offset + 2. */
13713 /* R_MICROMIPS_PC16_S1 relaxation to R_MICROMIPS_PC7_S1. We need
13714 to check the distance from the next instruction, so subtract 2. */
13716 && r_type
== R_MICROMIPS_PC16_S1
13717 && IS_BITSIZE (pcrval
- 2, 8)
13718 && (((fndopc
= find_match (opcode
, bz_rs_insns_32
)) >= 0
13719 && OP16_VALID_REG (OP32_SREG (opcode
)))
13720 || ((fndopc
= find_match (opcode
, bz_rt_insns_32
)) >= 0
13721 && OP16_VALID_REG (OP32_TREG (opcode
)))))
13725 reg
= OP32_SREG (opcode
) ? OP32_SREG (opcode
) : OP32_TREG (opcode
);
13727 /* Fix the relocation's type. */
13728 irel
->r_info
= ELF32_R_INFO (r_symndx
, R_MICROMIPS_PC7_S1
);
13730 /* Replace the 32-bit opcode with a 16-bit opcode. */
13732 (bz_insns_16
[fndopc
].match
13733 | BZ16_REG_FIELD (reg
)
13734 | (opcode
& 0x7f)), /* Addend value. */
13737 /* Delete 2 bytes from irel->r_offset + 2. */
13742 /* R_MICROMIPS_26_S1 -- JAL to JALS relaxation for microMIPS targets. */
13744 && r_type
== R_MICROMIPS_26_S1
13745 && target_is_micromips_code_p
13746 && irel
->r_offset
+ 7 < sec
->size
13747 && MATCH (opcode
, jal_insn_32_bd32
))
13749 unsigned long n32opc
;
13750 bfd_boolean relaxed
= FALSE
;
13752 n32opc
= bfd_get_micromips_32 (abfd
, ptr
+ 4);
13754 if (MATCH (n32opc
, nop_insn_32
))
13756 /* Replace delay slot 32-bit NOP with a 16-bit NOP. */
13757 bfd_put_16 (abfd
, nop_insn_16
.match
, ptr
+ 4);
13761 else if (find_match (n32opc
, move_insns_32
) >= 0)
13763 /* Replace delay slot 32-bit MOVE with 16-bit MOVE. */
13765 (move_insn_16
.match
13766 | MOVE16_RD_FIELD (MOVE32_RD (n32opc
))
13767 | MOVE16_RS_FIELD (MOVE32_RS (n32opc
))),
13772 /* Other 32-bit instructions relaxable to 16-bit
13773 instructions will be handled here later. */
13777 /* JAL with 32-bit delay slot that is changed to a JALS
13778 with 16-bit delay slot. */
13779 bfd_put_micromips_32 (abfd
, jal_insn_32_bd16
.match
, ptr
);
13781 /* Delete 2 bytes from irel->r_offset + 6. */
13789 /* Note that we've changed the relocs, section contents, etc. */
13790 elf_section_data (sec
)->relocs
= internal_relocs
;
13791 elf_section_data (sec
)->this_hdr
.contents
= contents
;
13792 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
13794 /* Delete bytes depending on the delcnt and deloff. */
13795 if (!mips_elf_relax_delete_bytes (abfd
, sec
,
13796 irel
->r_offset
+ deloff
, delcnt
))
13799 /* That will change things, so we should relax again.
13800 Note that this is not required, and it may be slow. */
13805 if (isymbuf
!= NULL
13806 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
13808 if (! link_info
->keep_memory
)
13812 /* Cache the symbols for elf_link_input_bfd. */
13813 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
13817 if (contents
!= NULL
13818 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
13820 if (! link_info
->keep_memory
)
13824 /* Cache the section contents for elf_link_input_bfd. */
13825 elf_section_data (sec
)->this_hdr
.contents
= contents
;
13829 if (internal_relocs
!= NULL
13830 && elf_section_data (sec
)->relocs
!= internal_relocs
)
13831 free (internal_relocs
);
13836 if (isymbuf
!= NULL
13837 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
13839 if (contents
!= NULL
13840 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
13842 if (internal_relocs
!= NULL
13843 && elf_section_data (sec
)->relocs
!= internal_relocs
)
13844 free (internal_relocs
);
13849 /* Create a MIPS ELF linker hash table. */
13851 struct bfd_link_hash_table
*
13852 _bfd_mips_elf_link_hash_table_create (bfd
*abfd
)
13854 struct mips_elf_link_hash_table
*ret
;
13855 bfd_size_type amt
= sizeof (struct mips_elf_link_hash_table
);
13857 ret
= bfd_zmalloc (amt
);
13861 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
13862 mips_elf_link_hash_newfunc
,
13863 sizeof (struct mips_elf_link_hash_entry
),
13869 ret
->root
.init_plt_refcount
.plist
= NULL
;
13870 ret
->root
.init_plt_offset
.plist
= NULL
;
13872 return &ret
->root
.root
;
13875 /* Likewise, but indicate that the target is VxWorks. */
13877 struct bfd_link_hash_table
*
13878 _bfd_mips_vxworks_link_hash_table_create (bfd
*abfd
)
13880 struct bfd_link_hash_table
*ret
;
13882 ret
= _bfd_mips_elf_link_hash_table_create (abfd
);
13885 struct mips_elf_link_hash_table
*htab
;
13887 htab
= (struct mips_elf_link_hash_table
*) ret
;
13888 htab
->use_plts_and_copy_relocs
= TRUE
;
13889 htab
->is_vxworks
= TRUE
;
13894 /* A function that the linker calls if we are allowed to use PLTs
13895 and copy relocs. */
13898 _bfd_mips_elf_use_plts_and_copy_relocs (struct bfd_link_info
*info
)
13900 mips_elf_hash_table (info
)->use_plts_and_copy_relocs
= TRUE
;
13903 /* A function that the linker calls to select between all or only
13904 32-bit microMIPS instructions. */
13907 _bfd_mips_elf_insn32 (struct bfd_link_info
*info
, bfd_boolean on
)
13909 mips_elf_hash_table (info
)->insn32
= on
;
13912 /* Structure for saying that BFD machine EXTENSION extends BASE. */
13914 struct mips_mach_extension
13916 unsigned long extension
, base
;
13920 /* An array describing how BFD machines relate to one another. The entries
13921 are ordered topologically with MIPS I extensions listed last. */
13923 static const struct mips_mach_extension mips_mach_extensions
[] =
13925 /* MIPS64r2 extensions. */
13926 { bfd_mach_mips_octeon3
, bfd_mach_mips_octeon2
},
13927 { bfd_mach_mips_octeon2
, bfd_mach_mips_octeonp
},
13928 { bfd_mach_mips_octeonp
, bfd_mach_mips_octeon
},
13929 { bfd_mach_mips_octeon
, bfd_mach_mipsisa64r2
},
13930 { bfd_mach_mips_loongson_3a
, bfd_mach_mipsisa64r2
},
13932 /* MIPS64 extensions. */
13933 { bfd_mach_mipsisa64r2
, bfd_mach_mipsisa64
},
13934 { bfd_mach_mips_sb1
, bfd_mach_mipsisa64
},
13935 { bfd_mach_mips_xlr
, bfd_mach_mipsisa64
},
13937 /* MIPS V extensions. */
13938 { bfd_mach_mipsisa64
, bfd_mach_mips5
},
13940 /* R10000 extensions. */
13941 { bfd_mach_mips12000
, bfd_mach_mips10000
},
13942 { bfd_mach_mips14000
, bfd_mach_mips10000
},
13943 { bfd_mach_mips16000
, bfd_mach_mips10000
},
13945 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
13946 vr5400 ISA, but doesn't include the multimedia stuff. It seems
13947 better to allow vr5400 and vr5500 code to be merged anyway, since
13948 many libraries will just use the core ISA. Perhaps we could add
13949 some sort of ASE flag if this ever proves a problem. */
13950 { bfd_mach_mips5500
, bfd_mach_mips5400
},
13951 { bfd_mach_mips5400
, bfd_mach_mips5000
},
13953 /* MIPS IV extensions. */
13954 { bfd_mach_mips5
, bfd_mach_mips8000
},
13955 { bfd_mach_mips10000
, bfd_mach_mips8000
},
13956 { bfd_mach_mips5000
, bfd_mach_mips8000
},
13957 { bfd_mach_mips7000
, bfd_mach_mips8000
},
13958 { bfd_mach_mips9000
, bfd_mach_mips8000
},
13960 /* VR4100 extensions. */
13961 { bfd_mach_mips4120
, bfd_mach_mips4100
},
13962 { bfd_mach_mips4111
, bfd_mach_mips4100
},
13964 /* MIPS III extensions. */
13965 { bfd_mach_mips_loongson_2e
, bfd_mach_mips4000
},
13966 { bfd_mach_mips_loongson_2f
, bfd_mach_mips4000
},
13967 { bfd_mach_mips8000
, bfd_mach_mips4000
},
13968 { bfd_mach_mips4650
, bfd_mach_mips4000
},
13969 { bfd_mach_mips4600
, bfd_mach_mips4000
},
13970 { bfd_mach_mips4400
, bfd_mach_mips4000
},
13971 { bfd_mach_mips4300
, bfd_mach_mips4000
},
13972 { bfd_mach_mips4100
, bfd_mach_mips4000
},
13973 { bfd_mach_mips4010
, bfd_mach_mips4000
},
13974 { bfd_mach_mips5900
, bfd_mach_mips4000
},
13976 /* MIPS32 extensions. */
13977 { bfd_mach_mipsisa32r2
, bfd_mach_mipsisa32
},
13979 /* MIPS II extensions. */
13980 { bfd_mach_mips4000
, bfd_mach_mips6000
},
13981 { bfd_mach_mipsisa32
, bfd_mach_mips6000
},
13983 /* MIPS I extensions. */
13984 { bfd_mach_mips6000
, bfd_mach_mips3000
},
13985 { bfd_mach_mips3900
, bfd_mach_mips3000
}
13988 /* Return true if bfd machine EXTENSION is an extension of machine BASE. */
13991 mips_mach_extends_p (unsigned long base
, unsigned long extension
)
13995 if (extension
== base
)
13998 if (base
== bfd_mach_mipsisa32
13999 && mips_mach_extends_p (bfd_mach_mipsisa64
, extension
))
14002 if (base
== bfd_mach_mipsisa32r2
14003 && mips_mach_extends_p (bfd_mach_mipsisa64r2
, extension
))
14006 for (i
= 0; i
< ARRAY_SIZE (mips_mach_extensions
); i
++)
14007 if (extension
== mips_mach_extensions
[i
].extension
)
14009 extension
= mips_mach_extensions
[i
].base
;
14010 if (extension
== base
)
14017 /* Return the BFD mach for each .MIPS.abiflags ISA Extension. */
14019 static unsigned long
14020 bfd_mips_isa_ext_mach (unsigned int isa_ext
)
14024 case AFL_EXT_3900
: return bfd_mach_mips3900
;
14025 case AFL_EXT_4010
: return bfd_mach_mips4010
;
14026 case AFL_EXT_4100
: return bfd_mach_mips4100
;
14027 case AFL_EXT_4111
: return bfd_mach_mips4111
;
14028 case AFL_EXT_4120
: return bfd_mach_mips4120
;
14029 case AFL_EXT_4650
: return bfd_mach_mips4650
;
14030 case AFL_EXT_5400
: return bfd_mach_mips5400
;
14031 case AFL_EXT_5500
: return bfd_mach_mips5500
;
14032 case AFL_EXT_5900
: return bfd_mach_mips5900
;
14033 case AFL_EXT_10000
: return bfd_mach_mips10000
;
14034 case AFL_EXT_LOONGSON_2E
: return bfd_mach_mips_loongson_2e
;
14035 case AFL_EXT_LOONGSON_2F
: return bfd_mach_mips_loongson_2f
;
14036 case AFL_EXT_LOONGSON_3A
: return bfd_mach_mips_loongson_3a
;
14037 case AFL_EXT_SB1
: return bfd_mach_mips_sb1
;
14038 case AFL_EXT_OCTEON
: return bfd_mach_mips_octeon
;
14039 case AFL_EXT_OCTEONP
: return bfd_mach_mips_octeonp
;
14040 case AFL_EXT_OCTEON2
: return bfd_mach_mips_octeon2
;
14041 case AFL_EXT_XLR
: return bfd_mach_mips_xlr
;
14042 default: return bfd_mach_mips3000
;
14046 /* Return the .MIPS.abiflags value representing each ISA Extension. */
14049 bfd_mips_isa_ext (bfd
*abfd
)
14051 switch (bfd_get_mach (abfd
))
14053 case bfd_mach_mips3900
: return AFL_EXT_3900
;
14054 case bfd_mach_mips4010
: return AFL_EXT_4010
;
14055 case bfd_mach_mips4100
: return AFL_EXT_4100
;
14056 case bfd_mach_mips4111
: return AFL_EXT_4111
;
14057 case bfd_mach_mips4120
: return AFL_EXT_4120
;
14058 case bfd_mach_mips4650
: return AFL_EXT_4650
;
14059 case bfd_mach_mips5400
: return AFL_EXT_5400
;
14060 case bfd_mach_mips5500
: return AFL_EXT_5500
;
14061 case bfd_mach_mips5900
: return AFL_EXT_5900
;
14062 case bfd_mach_mips10000
: return AFL_EXT_10000
;
14063 case bfd_mach_mips_loongson_2e
: return AFL_EXT_LOONGSON_2E
;
14064 case bfd_mach_mips_loongson_2f
: return AFL_EXT_LOONGSON_2F
;
14065 case bfd_mach_mips_loongson_3a
: return AFL_EXT_LOONGSON_3A
;
14066 case bfd_mach_mips_sb1
: return AFL_EXT_SB1
;
14067 case bfd_mach_mips_octeon
: return AFL_EXT_OCTEON
;
14068 case bfd_mach_mips_octeonp
: return AFL_EXT_OCTEONP
;
14069 case bfd_mach_mips_octeon3
: return AFL_EXT_OCTEON3
;
14070 case bfd_mach_mips_octeon2
: return AFL_EXT_OCTEON2
;
14071 case bfd_mach_mips_xlr
: return AFL_EXT_XLR
;
14076 /* Encode ISA level and revision as a single value. */
14077 #define LEVEL_REV(LEV,REV) ((LEV) << 3 | (REV))
14079 /* Decode a single value into level and revision. */
14080 #define ISA_LEVEL(LEVREV) ((LEVREV) >> 3)
14081 #define ISA_REV(LEVREV) ((LEVREV) & 0x7)
14083 /* Update the isa_level, isa_rev, isa_ext fields of abiflags. */
14086 update_mips_abiflags_isa (bfd
*abfd
, Elf_Internal_ABIFlags_v0
*abiflags
)
14089 switch (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
)
14091 case E_MIPS_ARCH_1
: new_isa
= LEVEL_REV (1, 0); break;
14092 case E_MIPS_ARCH_2
: new_isa
= LEVEL_REV (2, 0); break;
14093 case E_MIPS_ARCH_3
: new_isa
= LEVEL_REV (3, 0); break;
14094 case E_MIPS_ARCH_4
: new_isa
= LEVEL_REV (4, 0); break;
14095 case E_MIPS_ARCH_5
: new_isa
= LEVEL_REV (5, 0); break;
14096 case E_MIPS_ARCH_32
: new_isa
= LEVEL_REV (32, 1); break;
14097 case E_MIPS_ARCH_32R2
: new_isa
= LEVEL_REV (32, 2); break;
14098 case E_MIPS_ARCH_32R6
: new_isa
= LEVEL_REV (32, 6); break;
14099 case E_MIPS_ARCH_64
: new_isa
= LEVEL_REV (64, 1); break;
14100 case E_MIPS_ARCH_64R2
: new_isa
= LEVEL_REV (64, 2); break;
14101 case E_MIPS_ARCH_64R6
: new_isa
= LEVEL_REV (64, 6); break;
14103 (*_bfd_error_handler
)
14104 (_("%B: Unknown architecture %s"),
14105 abfd
, bfd_printable_name (abfd
));
14108 if (new_isa
> LEVEL_REV (abiflags
->isa_level
, abiflags
->isa_rev
))
14110 abiflags
->isa_level
= ISA_LEVEL (new_isa
);
14111 abiflags
->isa_rev
= ISA_REV (new_isa
);
14114 /* Update the isa_ext if ABFD describes a further extension. */
14115 if (mips_mach_extends_p (bfd_mips_isa_ext_mach (abiflags
->isa_ext
),
14116 bfd_get_mach (abfd
)))
14117 abiflags
->isa_ext
= bfd_mips_isa_ext (abfd
);
14120 /* Return true if the given ELF header flags describe a 32-bit binary. */
14123 mips_32bit_flags_p (flagword flags
)
14125 return ((flags
& EF_MIPS_32BITMODE
) != 0
14126 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
14127 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
14128 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
14129 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
14130 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
14131 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
14132 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R6
);
14135 /* Infer the content of the ABI flags based on the elf header. */
14138 infer_mips_abiflags (bfd
*abfd
, Elf_Internal_ABIFlags_v0
* abiflags
)
14140 obj_attribute
*in_attr
;
14142 memset (abiflags
, 0, sizeof (Elf_Internal_ABIFlags_v0
));
14143 update_mips_abiflags_isa (abfd
, abiflags
);
14145 if (mips_32bit_flags_p (elf_elfheader (abfd
)->e_flags
))
14146 abiflags
->gpr_size
= AFL_REG_32
;
14148 abiflags
->gpr_size
= AFL_REG_64
;
14150 abiflags
->cpr1_size
= AFL_REG_NONE
;
14152 in_attr
= elf_known_obj_attributes (abfd
)[OBJ_ATTR_GNU
];
14153 abiflags
->fp_abi
= in_attr
[Tag_GNU_MIPS_ABI_FP
].i
;
14155 if (abiflags
->fp_abi
== Val_GNU_MIPS_ABI_FP_SINGLE
14156 || abiflags
->fp_abi
== Val_GNU_MIPS_ABI_FP_XX
14157 || (abiflags
->fp_abi
== Val_GNU_MIPS_ABI_FP_DOUBLE
14158 && abiflags
->gpr_size
== AFL_REG_32
))
14159 abiflags
->cpr1_size
= AFL_REG_32
;
14160 else if (abiflags
->fp_abi
== Val_GNU_MIPS_ABI_FP_DOUBLE
14161 || abiflags
->fp_abi
== Val_GNU_MIPS_ABI_FP_64
14162 || abiflags
->fp_abi
== Val_GNU_MIPS_ABI_FP_64A
)
14163 abiflags
->cpr1_size
= AFL_REG_64
;
14165 abiflags
->cpr2_size
= AFL_REG_NONE
;
14167 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
14168 abiflags
->ases
|= AFL_ASE_MDMX
;
14169 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_M16
)
14170 abiflags
->ases
|= AFL_ASE_MIPS16
;
14171 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
14172 abiflags
->ases
|= AFL_ASE_MICROMIPS
;
14174 if (abiflags
->fp_abi
!= Val_GNU_MIPS_ABI_FP_ANY
14175 && abiflags
->fp_abi
!= Val_GNU_MIPS_ABI_FP_SOFT
14176 && abiflags
->fp_abi
!= Val_GNU_MIPS_ABI_FP_64A
14177 && abiflags
->isa_level
>= 32
14178 && abiflags
->isa_ext
!= AFL_EXT_LOONGSON_3A
)
14179 abiflags
->flags1
|= AFL_FLAGS1_ODDSPREG
;
14182 /* We need to use a special link routine to handle the .reginfo and
14183 the .mdebug sections. We need to merge all instances of these
14184 sections together, not write them all out sequentially. */
14187 _bfd_mips_elf_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
14190 struct bfd_link_order
*p
;
14191 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
14192 asection
*rtproc_sec
, *abiflags_sec
;
14193 Elf32_RegInfo reginfo
;
14194 struct ecoff_debug_info debug
;
14195 struct mips_htab_traverse_info hti
;
14196 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
14197 const struct ecoff_debug_swap
*swap
= bed
->elf_backend_ecoff_debug_swap
;
14198 HDRR
*symhdr
= &debug
.symbolic_header
;
14199 void *mdebug_handle
= NULL
;
14204 struct mips_elf_link_hash_table
*htab
;
14206 static const char * const secname
[] =
14208 ".text", ".init", ".fini", ".data",
14209 ".rodata", ".sdata", ".sbss", ".bss"
14211 static const int sc
[] =
14213 scText
, scInit
, scFini
, scData
,
14214 scRData
, scSData
, scSBss
, scBss
14217 /* Sort the dynamic symbols so that those with GOT entries come after
14219 htab
= mips_elf_hash_table (info
);
14220 BFD_ASSERT (htab
!= NULL
);
14222 if (!mips_elf_sort_hash_table (abfd
, info
))
14225 /* Create any scheduled LA25 stubs. */
14227 hti
.output_bfd
= abfd
;
14229 htab_traverse (htab
->la25_stubs
, mips_elf_create_la25_stub
, &hti
);
14233 /* Get a value for the GP register. */
14234 if (elf_gp (abfd
) == 0)
14236 struct bfd_link_hash_entry
*h
;
14238 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
14239 if (h
!= NULL
&& h
->type
== bfd_link_hash_defined
)
14240 elf_gp (abfd
) = (h
->u
.def
.value
14241 + h
->u
.def
.section
->output_section
->vma
14242 + h
->u
.def
.section
->output_offset
);
14243 else if (htab
->is_vxworks
14244 && (h
= bfd_link_hash_lookup (info
->hash
,
14245 "_GLOBAL_OFFSET_TABLE_",
14246 FALSE
, FALSE
, TRUE
))
14247 && h
->type
== bfd_link_hash_defined
)
14248 elf_gp (abfd
) = (h
->u
.def
.section
->output_section
->vma
14249 + h
->u
.def
.section
->output_offset
14251 else if (bfd_link_relocatable (info
))
14253 bfd_vma lo
= MINUS_ONE
;
14255 /* Find the GP-relative section with the lowest offset. */
14256 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
14258 && (elf_section_data (o
)->this_hdr
.sh_flags
& SHF_MIPS_GPREL
))
14261 /* And calculate GP relative to that. */
14262 elf_gp (abfd
) = lo
+ ELF_MIPS_GP_OFFSET (info
);
14266 /* If the relocate_section function needs to do a reloc
14267 involving the GP value, it should make a reloc_dangerous
14268 callback to warn that GP is not defined. */
14272 /* Go through the sections and collect the .reginfo and .mdebug
14274 abiflags_sec
= NULL
;
14275 reginfo_sec
= NULL
;
14277 gptab_data_sec
= NULL
;
14278 gptab_bss_sec
= NULL
;
14279 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
14281 if (strcmp (o
->name
, ".MIPS.abiflags") == 0)
14283 /* We have found the .MIPS.abiflags section in the output file.
14284 Look through all the link_orders comprising it and remove them.
14285 The data is merged in _bfd_mips_elf_merge_private_bfd_data. */
14286 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
14288 asection
*input_section
;
14290 if (p
->type
!= bfd_indirect_link_order
)
14292 if (p
->type
== bfd_data_link_order
)
14297 input_section
= p
->u
.indirect
.section
;
14299 /* Hack: reset the SEC_HAS_CONTENTS flag so that
14300 elf_link_input_bfd ignores this section. */
14301 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
14304 /* Size has been set in _bfd_mips_elf_always_size_sections. */
14305 BFD_ASSERT(o
->size
== sizeof (Elf_External_ABIFlags_v0
));
14307 /* Skip this section later on (I don't think this currently
14308 matters, but someday it might). */
14309 o
->map_head
.link_order
= NULL
;
14314 if (strcmp (o
->name
, ".reginfo") == 0)
14316 memset (®info
, 0, sizeof reginfo
);
14318 /* We have found the .reginfo section in the output file.
14319 Look through all the link_orders comprising it and merge
14320 the information together. */
14321 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
14323 asection
*input_section
;
14325 Elf32_External_RegInfo ext
;
14328 if (p
->type
!= bfd_indirect_link_order
)
14330 if (p
->type
== bfd_data_link_order
)
14335 input_section
= p
->u
.indirect
.section
;
14336 input_bfd
= input_section
->owner
;
14338 if (! bfd_get_section_contents (input_bfd
, input_section
,
14339 &ext
, 0, sizeof ext
))
14342 bfd_mips_elf32_swap_reginfo_in (input_bfd
, &ext
, &sub
);
14344 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
14345 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
14346 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
14347 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
14348 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
14350 /* ri_gp_value is set by the function
14351 mips_elf32_section_processing when the section is
14352 finally written out. */
14354 /* Hack: reset the SEC_HAS_CONTENTS flag so that
14355 elf_link_input_bfd ignores this section. */
14356 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
14359 /* Size has been set in _bfd_mips_elf_always_size_sections. */
14360 BFD_ASSERT(o
->size
== sizeof (Elf32_External_RegInfo
));
14362 /* Skip this section later on (I don't think this currently
14363 matters, but someday it might). */
14364 o
->map_head
.link_order
= NULL
;
14369 if (strcmp (o
->name
, ".mdebug") == 0)
14371 struct extsym_info einfo
;
14374 /* We have found the .mdebug section in the output file.
14375 Look through all the link_orders comprising it and merge
14376 the information together. */
14377 symhdr
->magic
= swap
->sym_magic
;
14378 /* FIXME: What should the version stamp be? */
14379 symhdr
->vstamp
= 0;
14380 symhdr
->ilineMax
= 0;
14381 symhdr
->cbLine
= 0;
14382 symhdr
->idnMax
= 0;
14383 symhdr
->ipdMax
= 0;
14384 symhdr
->isymMax
= 0;
14385 symhdr
->ioptMax
= 0;
14386 symhdr
->iauxMax
= 0;
14387 symhdr
->issMax
= 0;
14388 symhdr
->issExtMax
= 0;
14389 symhdr
->ifdMax
= 0;
14391 symhdr
->iextMax
= 0;
14393 /* We accumulate the debugging information itself in the
14394 debug_info structure. */
14396 debug
.external_dnr
= NULL
;
14397 debug
.external_pdr
= NULL
;
14398 debug
.external_sym
= NULL
;
14399 debug
.external_opt
= NULL
;
14400 debug
.external_aux
= NULL
;
14402 debug
.ssext
= debug
.ssext_end
= NULL
;
14403 debug
.external_fdr
= NULL
;
14404 debug
.external_rfd
= NULL
;
14405 debug
.external_ext
= debug
.external_ext_end
= NULL
;
14407 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
14408 if (mdebug_handle
== NULL
)
14412 esym
.cobol_main
= 0;
14416 esym
.asym
.iss
= issNil
;
14417 esym
.asym
.st
= stLocal
;
14418 esym
.asym
.reserved
= 0;
14419 esym
.asym
.index
= indexNil
;
14421 for (i
= 0; i
< sizeof (secname
) / sizeof (secname
[0]); i
++)
14423 esym
.asym
.sc
= sc
[i
];
14424 s
= bfd_get_section_by_name (abfd
, secname
[i
]);
14427 esym
.asym
.value
= s
->vma
;
14428 last
= s
->vma
+ s
->size
;
14431 esym
.asym
.value
= last
;
14432 if (!bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
14433 secname
[i
], &esym
))
14437 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
14439 asection
*input_section
;
14441 const struct ecoff_debug_swap
*input_swap
;
14442 struct ecoff_debug_info input_debug
;
14446 if (p
->type
!= bfd_indirect_link_order
)
14448 if (p
->type
== bfd_data_link_order
)
14453 input_section
= p
->u
.indirect
.section
;
14454 input_bfd
= input_section
->owner
;
14456 if (!is_mips_elf (input_bfd
))
14458 /* I don't know what a non MIPS ELF bfd would be
14459 doing with a .mdebug section, but I don't really
14460 want to deal with it. */
14464 input_swap
= (get_elf_backend_data (input_bfd
)
14465 ->elf_backend_ecoff_debug_swap
);
14467 BFD_ASSERT (p
->size
== input_section
->size
);
14469 /* The ECOFF linking code expects that we have already
14470 read in the debugging information and set up an
14471 ecoff_debug_info structure, so we do that now. */
14472 if (! _bfd_mips_elf_read_ecoff_info (input_bfd
, input_section
,
14476 if (! (bfd_ecoff_debug_accumulate
14477 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
14478 &input_debug
, input_swap
, info
)))
14481 /* Loop through the external symbols. For each one with
14482 interesting information, try to find the symbol in
14483 the linker global hash table and save the information
14484 for the output external symbols. */
14485 eraw_src
= input_debug
.external_ext
;
14486 eraw_end
= (eraw_src
14487 + (input_debug
.symbolic_header
.iextMax
14488 * input_swap
->external_ext_size
));
14490 eraw_src
< eraw_end
;
14491 eraw_src
+= input_swap
->external_ext_size
)
14495 struct mips_elf_link_hash_entry
*h
;
14497 (*input_swap
->swap_ext_in
) (input_bfd
, eraw_src
, &ext
);
14498 if (ext
.asym
.sc
== scNil
14499 || ext
.asym
.sc
== scUndefined
14500 || ext
.asym
.sc
== scSUndefined
)
14503 name
= input_debug
.ssext
+ ext
.asym
.iss
;
14504 h
= mips_elf_link_hash_lookup (mips_elf_hash_table (info
),
14505 name
, FALSE
, FALSE
, TRUE
);
14506 if (h
== NULL
|| h
->esym
.ifd
!= -2)
14511 BFD_ASSERT (ext
.ifd
14512 < input_debug
.symbolic_header
.ifdMax
);
14513 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
14519 /* Free up the information we just read. */
14520 free (input_debug
.line
);
14521 free (input_debug
.external_dnr
);
14522 free (input_debug
.external_pdr
);
14523 free (input_debug
.external_sym
);
14524 free (input_debug
.external_opt
);
14525 free (input_debug
.external_aux
);
14526 free (input_debug
.ss
);
14527 free (input_debug
.ssext
);
14528 free (input_debug
.external_fdr
);
14529 free (input_debug
.external_rfd
);
14530 free (input_debug
.external_ext
);
14532 /* Hack: reset the SEC_HAS_CONTENTS flag so that
14533 elf_link_input_bfd ignores this section. */
14534 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
14537 if (SGI_COMPAT (abfd
) && bfd_link_pic (info
))
14539 /* Create .rtproc section. */
14540 rtproc_sec
= bfd_get_linker_section (abfd
, ".rtproc");
14541 if (rtproc_sec
== NULL
)
14543 flagword flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
14544 | SEC_LINKER_CREATED
| SEC_READONLY
);
14546 rtproc_sec
= bfd_make_section_anyway_with_flags (abfd
,
14549 if (rtproc_sec
== NULL
14550 || ! bfd_set_section_alignment (abfd
, rtproc_sec
, 4))
14554 if (! mips_elf_create_procedure_table (mdebug_handle
, abfd
,
14560 /* Build the external symbol information. */
14563 einfo
.debug
= &debug
;
14565 einfo
.failed
= FALSE
;
14566 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
14567 mips_elf_output_extsym
, &einfo
);
14571 /* Set the size of the .mdebug section. */
14572 o
->size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
14574 /* Skip this section later on (I don't think this currently
14575 matters, but someday it might). */
14576 o
->map_head
.link_order
= NULL
;
14581 if (CONST_STRNEQ (o
->name
, ".gptab."))
14583 const char *subname
;
14586 Elf32_External_gptab
*ext_tab
;
14589 /* The .gptab.sdata and .gptab.sbss sections hold
14590 information describing how the small data area would
14591 change depending upon the -G switch. These sections
14592 not used in executables files. */
14593 if (! bfd_link_relocatable (info
))
14595 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
14597 asection
*input_section
;
14599 if (p
->type
!= bfd_indirect_link_order
)
14601 if (p
->type
== bfd_data_link_order
)
14606 input_section
= p
->u
.indirect
.section
;
14608 /* Hack: reset the SEC_HAS_CONTENTS flag so that
14609 elf_link_input_bfd ignores this section. */
14610 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
14613 /* Skip this section later on (I don't think this
14614 currently matters, but someday it might). */
14615 o
->map_head
.link_order
= NULL
;
14617 /* Really remove the section. */
14618 bfd_section_list_remove (abfd
, o
);
14619 --abfd
->section_count
;
14624 /* There is one gptab for initialized data, and one for
14625 uninitialized data. */
14626 if (strcmp (o
->name
, ".gptab.sdata") == 0)
14627 gptab_data_sec
= o
;
14628 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
14632 (*_bfd_error_handler
)
14633 (_("%s: illegal section name `%s'"),
14634 bfd_get_filename (abfd
), o
->name
);
14635 bfd_set_error (bfd_error_nonrepresentable_section
);
14639 /* The linker script always combines .gptab.data and
14640 .gptab.sdata into .gptab.sdata, and likewise for
14641 .gptab.bss and .gptab.sbss. It is possible that there is
14642 no .sdata or .sbss section in the output file, in which
14643 case we must change the name of the output section. */
14644 subname
= o
->name
+ sizeof ".gptab" - 1;
14645 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
14647 if (o
== gptab_data_sec
)
14648 o
->name
= ".gptab.data";
14650 o
->name
= ".gptab.bss";
14651 subname
= o
->name
+ sizeof ".gptab" - 1;
14652 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
14655 /* Set up the first entry. */
14657 amt
= c
* sizeof (Elf32_gptab
);
14658 tab
= bfd_malloc (amt
);
14661 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
14662 tab
[0].gt_header
.gt_unused
= 0;
14664 /* Combine the input sections. */
14665 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
14667 asection
*input_section
;
14669 bfd_size_type size
;
14670 unsigned long last
;
14671 bfd_size_type gpentry
;
14673 if (p
->type
!= bfd_indirect_link_order
)
14675 if (p
->type
== bfd_data_link_order
)
14680 input_section
= p
->u
.indirect
.section
;
14681 input_bfd
= input_section
->owner
;
14683 /* Combine the gptab entries for this input section one
14684 by one. We know that the input gptab entries are
14685 sorted by ascending -G value. */
14686 size
= input_section
->size
;
14688 for (gpentry
= sizeof (Elf32_External_gptab
);
14690 gpentry
+= sizeof (Elf32_External_gptab
))
14692 Elf32_External_gptab ext_gptab
;
14693 Elf32_gptab int_gptab
;
14699 if (! (bfd_get_section_contents
14700 (input_bfd
, input_section
, &ext_gptab
, gpentry
,
14701 sizeof (Elf32_External_gptab
))))
14707 bfd_mips_elf32_swap_gptab_in (input_bfd
, &ext_gptab
,
14709 val
= int_gptab
.gt_entry
.gt_g_value
;
14710 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
14713 for (look
= 1; look
< c
; look
++)
14715 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
14716 tab
[look
].gt_entry
.gt_bytes
+= add
;
14718 if (tab
[look
].gt_entry
.gt_g_value
== val
)
14724 Elf32_gptab
*new_tab
;
14727 /* We need a new table entry. */
14728 amt
= (bfd_size_type
) (c
+ 1) * sizeof (Elf32_gptab
);
14729 new_tab
= bfd_realloc (tab
, amt
);
14730 if (new_tab
== NULL
)
14736 tab
[c
].gt_entry
.gt_g_value
= val
;
14737 tab
[c
].gt_entry
.gt_bytes
= add
;
14739 /* Merge in the size for the next smallest -G
14740 value, since that will be implied by this new
14743 for (look
= 1; look
< c
; look
++)
14745 if (tab
[look
].gt_entry
.gt_g_value
< val
14747 || (tab
[look
].gt_entry
.gt_g_value
14748 > tab
[max
].gt_entry
.gt_g_value
)))
14752 tab
[c
].gt_entry
.gt_bytes
+=
14753 tab
[max
].gt_entry
.gt_bytes
;
14758 last
= int_gptab
.gt_entry
.gt_bytes
;
14761 /* Hack: reset the SEC_HAS_CONTENTS flag so that
14762 elf_link_input_bfd ignores this section. */
14763 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
14766 /* The table must be sorted by -G value. */
14768 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
14770 /* Swap out the table. */
14771 amt
= (bfd_size_type
) c
* sizeof (Elf32_External_gptab
);
14772 ext_tab
= bfd_alloc (abfd
, amt
);
14773 if (ext_tab
== NULL
)
14779 for (j
= 0; j
< c
; j
++)
14780 bfd_mips_elf32_swap_gptab_out (abfd
, tab
+ j
, ext_tab
+ j
);
14783 o
->size
= c
* sizeof (Elf32_External_gptab
);
14784 o
->contents
= (bfd_byte
*) ext_tab
;
14786 /* Skip this section later on (I don't think this currently
14787 matters, but someday it might). */
14788 o
->map_head
.link_order
= NULL
;
14792 /* Invoke the regular ELF backend linker to do all the work. */
14793 if (!bfd_elf_final_link (abfd
, info
))
14796 /* Now write out the computed sections. */
14798 if (abiflags_sec
!= NULL
)
14800 Elf_External_ABIFlags_v0 ext
;
14801 Elf_Internal_ABIFlags_v0
*abiflags
;
14803 abiflags
= &mips_elf_tdata (abfd
)->abiflags
;
14805 /* Set up the abiflags if no valid input sections were found. */
14806 if (!mips_elf_tdata (abfd
)->abiflags_valid
)
14808 infer_mips_abiflags (abfd
, abiflags
);
14809 mips_elf_tdata (abfd
)->abiflags_valid
= TRUE
;
14811 bfd_mips_elf_swap_abiflags_v0_out (abfd
, abiflags
, &ext
);
14812 if (! bfd_set_section_contents (abfd
, abiflags_sec
, &ext
, 0, sizeof ext
))
14816 if (reginfo_sec
!= NULL
)
14818 Elf32_External_RegInfo ext
;
14820 bfd_mips_elf32_swap_reginfo_out (abfd
, ®info
, &ext
);
14821 if (! bfd_set_section_contents (abfd
, reginfo_sec
, &ext
, 0, sizeof ext
))
14825 if (mdebug_sec
!= NULL
)
14827 BFD_ASSERT (abfd
->output_has_begun
);
14828 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
14830 mdebug_sec
->filepos
))
14833 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
14836 if (gptab_data_sec
!= NULL
)
14838 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
14839 gptab_data_sec
->contents
,
14840 0, gptab_data_sec
->size
))
14844 if (gptab_bss_sec
!= NULL
)
14846 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
14847 gptab_bss_sec
->contents
,
14848 0, gptab_bss_sec
->size
))
14852 if (SGI_COMPAT (abfd
))
14854 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
14855 if (rtproc_sec
!= NULL
)
14857 if (! bfd_set_section_contents (abfd
, rtproc_sec
,
14858 rtproc_sec
->contents
,
14859 0, rtproc_sec
->size
))
14867 /* Merge object attributes from IBFD into OBFD. Raise an error if
14868 there are conflicting attributes. */
14870 mips_elf_merge_obj_attributes (bfd
*ibfd
, bfd
*obfd
)
14872 obj_attribute
*in_attr
;
14873 obj_attribute
*out_attr
;
14877 abi_fp_bfd
= mips_elf_tdata (obfd
)->abi_fp_bfd
;
14878 in_attr
= elf_known_obj_attributes (ibfd
)[OBJ_ATTR_GNU
];
14879 if (!abi_fp_bfd
&& in_attr
[Tag_GNU_MIPS_ABI_FP
].i
!= Val_GNU_MIPS_ABI_FP_ANY
)
14880 mips_elf_tdata (obfd
)->abi_fp_bfd
= ibfd
;
14882 abi_msa_bfd
= mips_elf_tdata (obfd
)->abi_msa_bfd
;
14884 && in_attr
[Tag_GNU_MIPS_ABI_MSA
].i
!= Val_GNU_MIPS_ABI_MSA_ANY
)
14885 mips_elf_tdata (obfd
)->abi_msa_bfd
= ibfd
;
14887 if (!elf_known_obj_attributes_proc (obfd
)[0].i
)
14889 /* This is the first object. Copy the attributes. */
14890 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
14892 /* Use the Tag_null value to indicate the attributes have been
14894 elf_known_obj_attributes_proc (obfd
)[0].i
= 1;
14899 /* Check for conflicting Tag_GNU_MIPS_ABI_FP attributes and merge
14900 non-conflicting ones. */
14901 out_attr
= elf_known_obj_attributes (obfd
)[OBJ_ATTR_GNU
];
14902 if (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
!= out_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
14906 out_fp
= out_attr
[Tag_GNU_MIPS_ABI_FP
].i
;
14907 in_fp
= in_attr
[Tag_GNU_MIPS_ABI_FP
].i
;
14908 out_attr
[Tag_GNU_MIPS_ABI_FP
].type
= 1;
14909 if (out_fp
== Val_GNU_MIPS_ABI_FP_ANY
)
14910 out_attr
[Tag_GNU_MIPS_ABI_FP
].i
= in_fp
;
14911 else if (out_fp
== Val_GNU_MIPS_ABI_FP_XX
14912 && (in_fp
== Val_GNU_MIPS_ABI_FP_DOUBLE
14913 || in_fp
== Val_GNU_MIPS_ABI_FP_64
14914 || in_fp
== Val_GNU_MIPS_ABI_FP_64A
))
14916 mips_elf_tdata (obfd
)->abi_fp_bfd
= ibfd
;
14917 out_attr
[Tag_GNU_MIPS_ABI_FP
].i
= in_attr
[Tag_GNU_MIPS_ABI_FP
].i
;
14919 else if (in_fp
== Val_GNU_MIPS_ABI_FP_XX
14920 && (out_fp
== Val_GNU_MIPS_ABI_FP_DOUBLE
14921 || out_fp
== Val_GNU_MIPS_ABI_FP_64
14922 || out_fp
== Val_GNU_MIPS_ABI_FP_64A
))
14923 /* Keep the current setting. */;
14924 else if (out_fp
== Val_GNU_MIPS_ABI_FP_64A
14925 && in_fp
== Val_GNU_MIPS_ABI_FP_64
)
14927 mips_elf_tdata (obfd
)->abi_fp_bfd
= ibfd
;
14928 out_attr
[Tag_GNU_MIPS_ABI_FP
].i
= in_attr
[Tag_GNU_MIPS_ABI_FP
].i
;
14930 else if (in_fp
== Val_GNU_MIPS_ABI_FP_64A
14931 && out_fp
== Val_GNU_MIPS_ABI_FP_64
)
14932 /* Keep the current setting. */;
14933 else if (in_fp
!= Val_GNU_MIPS_ABI_FP_ANY
)
14935 const char *out_string
, *in_string
;
14937 out_string
= _bfd_mips_fp_abi_string (out_fp
);
14938 in_string
= _bfd_mips_fp_abi_string (in_fp
);
14939 /* First warn about cases involving unrecognised ABIs. */
14940 if (!out_string
&& !in_string
)
14942 (_("Warning: %B uses unknown floating point ABI %d "
14943 "(set by %B), %B uses unknown floating point ABI %d"),
14944 obfd
, abi_fp_bfd
, ibfd
, out_fp
, in_fp
);
14945 else if (!out_string
)
14947 (_("Warning: %B uses unknown floating point ABI %d "
14948 "(set by %B), %B uses %s"),
14949 obfd
, abi_fp_bfd
, ibfd
, out_fp
, in_string
);
14950 else if (!in_string
)
14952 (_("Warning: %B uses %s (set by %B), "
14953 "%B uses unknown floating point ABI %d"),
14954 obfd
, abi_fp_bfd
, ibfd
, out_string
, in_fp
);
14957 /* If one of the bfds is soft-float, the other must be
14958 hard-float. The exact choice of hard-float ABI isn't
14959 really relevant to the error message. */
14960 if (in_fp
== Val_GNU_MIPS_ABI_FP_SOFT
)
14961 out_string
= "-mhard-float";
14962 else if (out_fp
== Val_GNU_MIPS_ABI_FP_SOFT
)
14963 in_string
= "-mhard-float";
14965 (_("Warning: %B uses %s (set by %B), %B uses %s"),
14966 obfd
, abi_fp_bfd
, ibfd
, out_string
, in_string
);
14971 /* Check for conflicting Tag_GNU_MIPS_ABI_MSA attributes and merge
14972 non-conflicting ones. */
14973 if (in_attr
[Tag_GNU_MIPS_ABI_MSA
].i
!= out_attr
[Tag_GNU_MIPS_ABI_MSA
].i
)
14975 out_attr
[Tag_GNU_MIPS_ABI_MSA
].type
= 1;
14976 if (out_attr
[Tag_GNU_MIPS_ABI_MSA
].i
== Val_GNU_MIPS_ABI_MSA_ANY
)
14977 out_attr
[Tag_GNU_MIPS_ABI_MSA
].i
= in_attr
[Tag_GNU_MIPS_ABI_MSA
].i
;
14978 else if (in_attr
[Tag_GNU_MIPS_ABI_MSA
].i
!= Val_GNU_MIPS_ABI_MSA_ANY
)
14979 switch (out_attr
[Tag_GNU_MIPS_ABI_MSA
].i
)
14981 case Val_GNU_MIPS_ABI_MSA_128
:
14983 (_("Warning: %B uses %s (set by %B), "
14984 "%B uses unknown MSA ABI %d"),
14985 obfd
, abi_msa_bfd
, ibfd
,
14986 "-mmsa", in_attr
[Tag_GNU_MIPS_ABI_MSA
].i
);
14990 switch (in_attr
[Tag_GNU_MIPS_ABI_MSA
].i
)
14992 case Val_GNU_MIPS_ABI_MSA_128
:
14994 (_("Warning: %B uses unknown MSA ABI %d "
14995 "(set by %B), %B uses %s"),
14996 obfd
, abi_msa_bfd
, ibfd
,
14997 out_attr
[Tag_GNU_MIPS_ABI_MSA
].i
, "-mmsa");
15002 (_("Warning: %B uses unknown MSA ABI %d "
15003 "(set by %B), %B uses unknown MSA ABI %d"),
15004 obfd
, abi_msa_bfd
, ibfd
,
15005 out_attr
[Tag_GNU_MIPS_ABI_MSA
].i
,
15006 in_attr
[Tag_GNU_MIPS_ABI_MSA
].i
);
15012 /* Merge Tag_compatibility attributes and any common GNU ones. */
15013 _bfd_elf_merge_object_attributes (ibfd
, obfd
);
15018 /* Merge backend specific data from an object file to the output
15019 object file when linking. */
15022 _bfd_mips_elf_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
15024 flagword old_flags
;
15025 flagword new_flags
;
15027 bfd_boolean null_input_bfd
= TRUE
;
15029 obj_attribute
*out_attr
;
15031 /* Check if we have the same endianness. */
15032 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
15034 (*_bfd_error_handler
)
15035 (_("%B: endianness incompatible with that of the selected emulation"),
15040 if (!is_mips_elf (ibfd
) || !is_mips_elf (obfd
))
15043 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
15045 (*_bfd_error_handler
)
15046 (_("%B: ABI is incompatible with that of the selected emulation"),
15051 /* Set up the FP ABI attribute from the abiflags if it is not already
15053 if (mips_elf_tdata (ibfd
)->abiflags_valid
)
15055 obj_attribute
*in_attr
= elf_known_obj_attributes (ibfd
)[OBJ_ATTR_GNU
];
15056 if (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
== Val_GNU_MIPS_ABI_FP_ANY
)
15057 in_attr
[Tag_GNU_MIPS_ABI_FP
].i
=
15058 mips_elf_tdata (ibfd
)->abiflags
.fp_abi
;
15061 if (!mips_elf_merge_obj_attributes (ibfd
, obfd
))
15064 /* Check to see if the input BFD actually contains any sections.
15065 If not, its flags may not have been initialised either, but it cannot
15066 actually cause any incompatibility. */
15067 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
15069 /* Ignore synthetic sections and empty .text, .data and .bss sections
15070 which are automatically generated by gas. Also ignore fake
15071 (s)common sections, since merely defining a common symbol does
15072 not affect compatibility. */
15073 if ((sec
->flags
& SEC_IS_COMMON
) == 0
15074 && strcmp (sec
->name
, ".reginfo")
15075 && strcmp (sec
->name
, ".mdebug")
15077 || (strcmp (sec
->name
, ".text")
15078 && strcmp (sec
->name
, ".data")
15079 && strcmp (sec
->name
, ".bss"))))
15081 null_input_bfd
= FALSE
;
15085 if (null_input_bfd
)
15088 /* Populate abiflags using existing information. */
15089 if (!mips_elf_tdata (ibfd
)->abiflags_valid
)
15091 infer_mips_abiflags (ibfd
, &mips_elf_tdata (ibfd
)->abiflags
);
15092 mips_elf_tdata (ibfd
)->abiflags_valid
= TRUE
;
15096 Elf_Internal_ABIFlags_v0 abiflags
;
15097 Elf_Internal_ABIFlags_v0 in_abiflags
;
15098 infer_mips_abiflags (ibfd
, &abiflags
);
15099 in_abiflags
= mips_elf_tdata (ibfd
)->abiflags
;
15101 /* It is not possible to infer the correct ISA revision
15102 for R3 or R5 so drop down to R2 for the checks. */
15103 if (in_abiflags
.isa_rev
== 3 || in_abiflags
.isa_rev
== 5)
15104 in_abiflags
.isa_rev
= 2;
15106 if (LEVEL_REV (in_abiflags
.isa_level
, in_abiflags
.isa_rev
)
15107 < LEVEL_REV (abiflags
.isa_level
, abiflags
.isa_rev
))
15108 (*_bfd_error_handler
)
15109 (_("%B: warning: Inconsistent ISA between e_flags and "
15110 ".MIPS.abiflags"), ibfd
);
15111 if (abiflags
.fp_abi
!= Val_GNU_MIPS_ABI_FP_ANY
15112 && in_abiflags
.fp_abi
!= abiflags
.fp_abi
)
15113 (*_bfd_error_handler
)
15114 (_("%B: warning: Inconsistent FP ABI between e_flags and "
15115 ".MIPS.abiflags"), ibfd
);
15116 if ((in_abiflags
.ases
& abiflags
.ases
) != abiflags
.ases
)
15117 (*_bfd_error_handler
)
15118 (_("%B: warning: Inconsistent ASEs between e_flags and "
15119 ".MIPS.abiflags"), ibfd
);
15120 /* The isa_ext is allowed to be an extension of what can be inferred
15122 if (!mips_mach_extends_p (bfd_mips_isa_ext_mach (abiflags
.isa_ext
),
15123 bfd_mips_isa_ext_mach (in_abiflags
.isa_ext
)))
15124 (*_bfd_error_handler
)
15125 (_("%B: warning: Inconsistent ISA extensions between e_flags and "
15126 ".MIPS.abiflags"), ibfd
);
15127 if (in_abiflags
.flags2
!= 0)
15128 (*_bfd_error_handler
)
15129 (_("%B: warning: Unexpected flag in the flags2 field of "
15130 ".MIPS.abiflags (0x%lx)"), ibfd
,
15131 (unsigned long) in_abiflags
.flags2
);
15134 if (!mips_elf_tdata (obfd
)->abiflags_valid
)
15136 /* Copy input abiflags if output abiflags are not already valid. */
15137 mips_elf_tdata (obfd
)->abiflags
= mips_elf_tdata (ibfd
)->abiflags
;
15138 mips_elf_tdata (obfd
)->abiflags_valid
= TRUE
;
15141 if (! elf_flags_init (obfd
))
15143 elf_flags_init (obfd
) = TRUE
;
15144 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
15145 elf_elfheader (obfd
)->e_ident
[EI_CLASS
]
15146 = elf_elfheader (ibfd
)->e_ident
[EI_CLASS
];
15148 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
15149 && (bfd_get_arch_info (obfd
)->the_default
15150 || mips_mach_extends_p (bfd_get_mach (obfd
),
15151 bfd_get_mach (ibfd
))))
15153 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
15154 bfd_get_mach (ibfd
)))
15157 /* Update the ABI flags isa_level, isa_rev and isa_ext fields. */
15158 update_mips_abiflags_isa (obfd
, &mips_elf_tdata (obfd
)->abiflags
);
15164 /* Update the output abiflags fp_abi using the computed fp_abi. */
15165 out_attr
= elf_known_obj_attributes (obfd
)[OBJ_ATTR_GNU
];
15166 mips_elf_tdata (obfd
)->abiflags
.fp_abi
= out_attr
[Tag_GNU_MIPS_ABI_FP
].i
;
15168 #define max(a,b) ((a) > (b) ? (a) : (b))
15169 /* Merge abiflags. */
15170 mips_elf_tdata (obfd
)->abiflags
.isa_level
15171 = max (mips_elf_tdata (obfd
)->abiflags
.isa_level
,
15172 mips_elf_tdata (ibfd
)->abiflags
.isa_level
);
15173 mips_elf_tdata (obfd
)->abiflags
.isa_rev
15174 = max (mips_elf_tdata (obfd
)->abiflags
.isa_rev
,
15175 mips_elf_tdata (ibfd
)->abiflags
.isa_rev
);
15176 mips_elf_tdata (obfd
)->abiflags
.gpr_size
15177 = max (mips_elf_tdata (obfd
)->abiflags
.gpr_size
,
15178 mips_elf_tdata (ibfd
)->abiflags
.gpr_size
);
15179 mips_elf_tdata (obfd
)->abiflags
.cpr1_size
15180 = max (mips_elf_tdata (obfd
)->abiflags
.cpr1_size
,
15181 mips_elf_tdata (ibfd
)->abiflags
.cpr1_size
);
15182 mips_elf_tdata (obfd
)->abiflags
.cpr2_size
15183 = max (mips_elf_tdata (obfd
)->abiflags
.cpr2_size
,
15184 mips_elf_tdata (ibfd
)->abiflags
.cpr2_size
);
15186 mips_elf_tdata (obfd
)->abiflags
.ases
15187 |= mips_elf_tdata (ibfd
)->abiflags
.ases
;
15188 mips_elf_tdata (obfd
)->abiflags
.flags1
15189 |= mips_elf_tdata (ibfd
)->abiflags
.flags1
;
15191 new_flags
= elf_elfheader (ibfd
)->e_flags
;
15192 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_NOREORDER
;
15193 old_flags
= elf_elfheader (obfd
)->e_flags
;
15195 /* Check flag compatibility. */
15197 new_flags
&= ~EF_MIPS_NOREORDER
;
15198 old_flags
&= ~EF_MIPS_NOREORDER
;
15200 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
15201 doesn't seem to matter. */
15202 new_flags
&= ~EF_MIPS_XGOT
;
15203 old_flags
&= ~EF_MIPS_XGOT
;
15205 /* MIPSpro generates ucode info in n64 objects. Again, we should
15206 just be able to ignore this. */
15207 new_flags
&= ~EF_MIPS_UCODE
;
15208 old_flags
&= ~EF_MIPS_UCODE
;
15210 /* DSOs should only be linked with CPIC code. */
15211 if ((ibfd
->flags
& DYNAMIC
) != 0)
15212 new_flags
|= EF_MIPS_PIC
| EF_MIPS_CPIC
;
15214 if (new_flags
== old_flags
)
15219 if (((new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0)
15220 != ((old_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0))
15222 (*_bfd_error_handler
)
15223 (_("%B: warning: linking abicalls files with non-abicalls files"),
15228 if (new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
))
15229 elf_elfheader (obfd
)->e_flags
|= EF_MIPS_CPIC
;
15230 if (! (new_flags
& EF_MIPS_PIC
))
15231 elf_elfheader (obfd
)->e_flags
&= ~EF_MIPS_PIC
;
15233 new_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
15234 old_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
15236 /* Compare the ISAs. */
15237 if (mips_32bit_flags_p (old_flags
) != mips_32bit_flags_p (new_flags
))
15239 (*_bfd_error_handler
)
15240 (_("%B: linking 32-bit code with 64-bit code"),
15244 else if (!mips_mach_extends_p (bfd_get_mach (ibfd
), bfd_get_mach (obfd
)))
15246 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
15247 if (mips_mach_extends_p (bfd_get_mach (obfd
), bfd_get_mach (ibfd
)))
15249 /* Copy the architecture info from IBFD to OBFD. Also copy
15250 the 32-bit flag (if set) so that we continue to recognise
15251 OBFD as a 32-bit binary. */
15252 bfd_set_arch_info (obfd
, bfd_get_arch_info (ibfd
));
15253 elf_elfheader (obfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
15254 elf_elfheader (obfd
)->e_flags
15255 |= new_flags
& (EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
15257 /* Update the ABI flags isa_level, isa_rev, isa_ext fields. */
15258 update_mips_abiflags_isa (obfd
, &mips_elf_tdata (obfd
)->abiflags
);
15260 /* Copy across the ABI flags if OBFD doesn't use them
15261 and if that was what caused us to treat IBFD as 32-bit. */
15262 if ((old_flags
& EF_MIPS_ABI
) == 0
15263 && mips_32bit_flags_p (new_flags
)
15264 && !mips_32bit_flags_p (new_flags
& ~EF_MIPS_ABI
))
15265 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ABI
;
15269 /* The ISAs aren't compatible. */
15270 (*_bfd_error_handler
)
15271 (_("%B: linking %s module with previous %s modules"),
15273 bfd_printable_name (ibfd
),
15274 bfd_printable_name (obfd
));
15279 new_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
15280 old_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
15282 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
15283 does set EI_CLASS differently from any 32-bit ABI. */
15284 if ((new_flags
& EF_MIPS_ABI
) != (old_flags
& EF_MIPS_ABI
)
15285 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
15286 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
15288 /* Only error if both are set (to different values). */
15289 if (((new_flags
& EF_MIPS_ABI
) && (old_flags
& EF_MIPS_ABI
))
15290 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
15291 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
15293 (*_bfd_error_handler
)
15294 (_("%B: ABI mismatch: linking %s module with previous %s modules"),
15296 elf_mips_abi_name (ibfd
),
15297 elf_mips_abi_name (obfd
));
15300 new_flags
&= ~EF_MIPS_ABI
;
15301 old_flags
&= ~EF_MIPS_ABI
;
15304 /* Compare ASEs. Forbid linking MIPS16 and microMIPS ASE modules together
15305 and allow arbitrary mixing of the remaining ASEs (retain the union). */
15306 if ((new_flags
& EF_MIPS_ARCH_ASE
) != (old_flags
& EF_MIPS_ARCH_ASE
))
15308 int old_micro
= old_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
;
15309 int new_micro
= new_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
;
15310 int old_m16
= old_flags
& EF_MIPS_ARCH_ASE_M16
;
15311 int new_m16
= new_flags
& EF_MIPS_ARCH_ASE_M16
;
15312 int micro_mis
= old_m16
&& new_micro
;
15313 int m16_mis
= old_micro
&& new_m16
;
15315 if (m16_mis
|| micro_mis
)
15317 (*_bfd_error_handler
)
15318 (_("%B: ASE mismatch: linking %s module with previous %s modules"),
15320 m16_mis
? "MIPS16" : "microMIPS",
15321 m16_mis
? "microMIPS" : "MIPS16");
15325 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ARCH_ASE
;
15327 new_flags
&= ~ EF_MIPS_ARCH_ASE
;
15328 old_flags
&= ~ EF_MIPS_ARCH_ASE
;
15331 /* Compare NaN encodings. */
15332 if ((new_flags
& EF_MIPS_NAN2008
) != (old_flags
& EF_MIPS_NAN2008
))
15334 _bfd_error_handler (_("%B: linking %s module with previous %s modules"),
15336 (new_flags
& EF_MIPS_NAN2008
15337 ? "-mnan=2008" : "-mnan=legacy"),
15338 (old_flags
& EF_MIPS_NAN2008
15339 ? "-mnan=2008" : "-mnan=legacy"));
15341 new_flags
&= ~EF_MIPS_NAN2008
;
15342 old_flags
&= ~EF_MIPS_NAN2008
;
15345 /* Compare FP64 state. */
15346 if ((new_flags
& EF_MIPS_FP64
) != (old_flags
& EF_MIPS_FP64
))
15348 _bfd_error_handler (_("%B: linking %s module with previous %s modules"),
15350 (new_flags
& EF_MIPS_FP64
15351 ? "-mfp64" : "-mfp32"),
15352 (old_flags
& EF_MIPS_FP64
15353 ? "-mfp64" : "-mfp32"));
15355 new_flags
&= ~EF_MIPS_FP64
;
15356 old_flags
&= ~EF_MIPS_FP64
;
15359 /* Warn about any other mismatches */
15360 if (new_flags
!= old_flags
)
15362 (*_bfd_error_handler
)
15363 (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
15364 ibfd
, (unsigned long) new_flags
,
15365 (unsigned long) old_flags
);
15371 bfd_set_error (bfd_error_bad_value
);
15378 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
15381 _bfd_mips_elf_set_private_flags (bfd
*abfd
, flagword flags
)
15383 BFD_ASSERT (!elf_flags_init (abfd
)
15384 || elf_elfheader (abfd
)->e_flags
== flags
);
15386 elf_elfheader (abfd
)->e_flags
= flags
;
15387 elf_flags_init (abfd
) = TRUE
;
15392 _bfd_mips_elf_get_target_dtag (bfd_vma dtag
)
15396 default: return "";
15397 case DT_MIPS_RLD_VERSION
:
15398 return "MIPS_RLD_VERSION";
15399 case DT_MIPS_TIME_STAMP
:
15400 return "MIPS_TIME_STAMP";
15401 case DT_MIPS_ICHECKSUM
:
15402 return "MIPS_ICHECKSUM";
15403 case DT_MIPS_IVERSION
:
15404 return "MIPS_IVERSION";
15405 case DT_MIPS_FLAGS
:
15406 return "MIPS_FLAGS";
15407 case DT_MIPS_BASE_ADDRESS
:
15408 return "MIPS_BASE_ADDRESS";
15410 return "MIPS_MSYM";
15411 case DT_MIPS_CONFLICT
:
15412 return "MIPS_CONFLICT";
15413 case DT_MIPS_LIBLIST
:
15414 return "MIPS_LIBLIST";
15415 case DT_MIPS_LOCAL_GOTNO
:
15416 return "MIPS_LOCAL_GOTNO";
15417 case DT_MIPS_CONFLICTNO
:
15418 return "MIPS_CONFLICTNO";
15419 case DT_MIPS_LIBLISTNO
:
15420 return "MIPS_LIBLISTNO";
15421 case DT_MIPS_SYMTABNO
:
15422 return "MIPS_SYMTABNO";
15423 case DT_MIPS_UNREFEXTNO
:
15424 return "MIPS_UNREFEXTNO";
15425 case DT_MIPS_GOTSYM
:
15426 return "MIPS_GOTSYM";
15427 case DT_MIPS_HIPAGENO
:
15428 return "MIPS_HIPAGENO";
15429 case DT_MIPS_RLD_MAP
:
15430 return "MIPS_RLD_MAP";
15431 case DT_MIPS_RLD_MAP_REL
:
15432 return "MIPS_RLD_MAP_REL";
15433 case DT_MIPS_DELTA_CLASS
:
15434 return "MIPS_DELTA_CLASS";
15435 case DT_MIPS_DELTA_CLASS_NO
:
15436 return "MIPS_DELTA_CLASS_NO";
15437 case DT_MIPS_DELTA_INSTANCE
:
15438 return "MIPS_DELTA_INSTANCE";
15439 case DT_MIPS_DELTA_INSTANCE_NO
:
15440 return "MIPS_DELTA_INSTANCE_NO";
15441 case DT_MIPS_DELTA_RELOC
:
15442 return "MIPS_DELTA_RELOC";
15443 case DT_MIPS_DELTA_RELOC_NO
:
15444 return "MIPS_DELTA_RELOC_NO";
15445 case DT_MIPS_DELTA_SYM
:
15446 return "MIPS_DELTA_SYM";
15447 case DT_MIPS_DELTA_SYM_NO
:
15448 return "MIPS_DELTA_SYM_NO";
15449 case DT_MIPS_DELTA_CLASSSYM
:
15450 return "MIPS_DELTA_CLASSSYM";
15451 case DT_MIPS_DELTA_CLASSSYM_NO
:
15452 return "MIPS_DELTA_CLASSSYM_NO";
15453 case DT_MIPS_CXX_FLAGS
:
15454 return "MIPS_CXX_FLAGS";
15455 case DT_MIPS_PIXIE_INIT
:
15456 return "MIPS_PIXIE_INIT";
15457 case DT_MIPS_SYMBOL_LIB
:
15458 return "MIPS_SYMBOL_LIB";
15459 case DT_MIPS_LOCALPAGE_GOTIDX
:
15460 return "MIPS_LOCALPAGE_GOTIDX";
15461 case DT_MIPS_LOCAL_GOTIDX
:
15462 return "MIPS_LOCAL_GOTIDX";
15463 case DT_MIPS_HIDDEN_GOTIDX
:
15464 return "MIPS_HIDDEN_GOTIDX";
15465 case DT_MIPS_PROTECTED_GOTIDX
:
15466 return "MIPS_PROTECTED_GOT_IDX";
15467 case DT_MIPS_OPTIONS
:
15468 return "MIPS_OPTIONS";
15469 case DT_MIPS_INTERFACE
:
15470 return "MIPS_INTERFACE";
15471 case DT_MIPS_DYNSTR_ALIGN
:
15472 return "DT_MIPS_DYNSTR_ALIGN";
15473 case DT_MIPS_INTERFACE_SIZE
:
15474 return "DT_MIPS_INTERFACE_SIZE";
15475 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
:
15476 return "DT_MIPS_RLD_TEXT_RESOLVE_ADDR";
15477 case DT_MIPS_PERF_SUFFIX
:
15478 return "DT_MIPS_PERF_SUFFIX";
15479 case DT_MIPS_COMPACT_SIZE
:
15480 return "DT_MIPS_COMPACT_SIZE";
15481 case DT_MIPS_GP_VALUE
:
15482 return "DT_MIPS_GP_VALUE";
15483 case DT_MIPS_AUX_DYNAMIC
:
15484 return "DT_MIPS_AUX_DYNAMIC";
15485 case DT_MIPS_PLTGOT
:
15486 return "DT_MIPS_PLTGOT";
15487 case DT_MIPS_RWPLT
:
15488 return "DT_MIPS_RWPLT";
15492 /* Return the meaning of Tag_GNU_MIPS_ABI_FP value FP, or null if
15496 _bfd_mips_fp_abi_string (int fp
)
15500 /* These strings aren't translated because they're simply
15502 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15503 return "-mdouble-float";
15505 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15506 return "-msingle-float";
15508 case Val_GNU_MIPS_ABI_FP_SOFT
:
15509 return "-msoft-float";
15511 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15512 return _("-mips32r2 -mfp64 (12 callee-saved)");
15514 case Val_GNU_MIPS_ABI_FP_XX
:
15517 case Val_GNU_MIPS_ABI_FP_64
:
15518 return "-mgp32 -mfp64";
15520 case Val_GNU_MIPS_ABI_FP_64A
:
15521 return "-mgp32 -mfp64 -mno-odd-spreg";
15529 print_mips_ases (FILE *file
, unsigned int mask
)
15531 if (mask
& AFL_ASE_DSP
)
15532 fputs ("\n\tDSP ASE", file
);
15533 if (mask
& AFL_ASE_DSPR2
)
15534 fputs ("\n\tDSP R2 ASE", file
);
15535 if (mask
& AFL_ASE_EVA
)
15536 fputs ("\n\tEnhanced VA Scheme", file
);
15537 if (mask
& AFL_ASE_MCU
)
15538 fputs ("\n\tMCU (MicroController) ASE", file
);
15539 if (mask
& AFL_ASE_MDMX
)
15540 fputs ("\n\tMDMX ASE", file
);
15541 if (mask
& AFL_ASE_MIPS3D
)
15542 fputs ("\n\tMIPS-3D ASE", file
);
15543 if (mask
& AFL_ASE_MT
)
15544 fputs ("\n\tMT ASE", file
);
15545 if (mask
& AFL_ASE_SMARTMIPS
)
15546 fputs ("\n\tSmartMIPS ASE", file
);
15547 if (mask
& AFL_ASE_VIRT
)
15548 fputs ("\n\tVZ ASE", file
);
15549 if (mask
& AFL_ASE_MSA
)
15550 fputs ("\n\tMSA ASE", file
);
15551 if (mask
& AFL_ASE_MIPS16
)
15552 fputs ("\n\tMIPS16 ASE", file
);
15553 if (mask
& AFL_ASE_MICROMIPS
)
15554 fputs ("\n\tMICROMIPS ASE", file
);
15555 if (mask
& AFL_ASE_XPA
)
15556 fputs ("\n\tXPA ASE", file
);
15558 fprintf (file
, "\n\t%s", _("None"));
15559 else if ((mask
& ~AFL_ASE_MASK
) != 0)
15560 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
15564 print_mips_isa_ext (FILE *file
, unsigned int isa_ext
)
15569 fputs (_("None"), file
);
15572 fputs ("RMI XLR", file
);
15574 case AFL_EXT_OCTEON3
:
15575 fputs ("Cavium Networks Octeon3", file
);
15577 case AFL_EXT_OCTEON2
:
15578 fputs ("Cavium Networks Octeon2", file
);
15580 case AFL_EXT_OCTEONP
:
15581 fputs ("Cavium Networks OcteonP", file
);
15583 case AFL_EXT_LOONGSON_3A
:
15584 fputs ("Loongson 3A", file
);
15586 case AFL_EXT_OCTEON
:
15587 fputs ("Cavium Networks Octeon", file
);
15590 fputs ("Toshiba R5900", file
);
15593 fputs ("MIPS R4650", file
);
15596 fputs ("LSI R4010", file
);
15599 fputs ("NEC VR4100", file
);
15602 fputs ("Toshiba R3900", file
);
15604 case AFL_EXT_10000
:
15605 fputs ("MIPS R10000", file
);
15608 fputs ("Broadcom SB-1", file
);
15611 fputs ("NEC VR4111/VR4181", file
);
15614 fputs ("NEC VR4120", file
);
15617 fputs ("NEC VR5400", file
);
15620 fputs ("NEC VR5500", file
);
15622 case AFL_EXT_LOONGSON_2E
:
15623 fputs ("ST Microelectronics Loongson 2E", file
);
15625 case AFL_EXT_LOONGSON_2F
:
15626 fputs ("ST Microelectronics Loongson 2F", file
);
15629 fprintf (file
, "%s (%d)", _("Unknown"), isa_ext
);
15635 print_mips_fp_abi_value (FILE *file
, int val
)
15639 case Val_GNU_MIPS_ABI_FP_ANY
:
15640 fprintf (file
, _("Hard or soft float\n"));
15642 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15643 fprintf (file
, _("Hard float (double precision)\n"));
15645 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15646 fprintf (file
, _("Hard float (single precision)\n"));
15648 case Val_GNU_MIPS_ABI_FP_SOFT
:
15649 fprintf (file
, _("Soft float\n"));
15651 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15652 fprintf (file
, _("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15654 case Val_GNU_MIPS_ABI_FP_XX
:
15655 fprintf (file
, _("Hard float (32-bit CPU, Any FPU)\n"));
15657 case Val_GNU_MIPS_ABI_FP_64
:
15658 fprintf (file
, _("Hard float (32-bit CPU, 64-bit FPU)\n"));
15660 case Val_GNU_MIPS_ABI_FP_64A
:
15661 fprintf (file
, _("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15664 fprintf (file
, "??? (%d)\n", val
);
15670 get_mips_reg_size (int reg_size
)
15672 return (reg_size
== AFL_REG_NONE
) ? 0
15673 : (reg_size
== AFL_REG_32
) ? 32
15674 : (reg_size
== AFL_REG_64
) ? 64
15675 : (reg_size
== AFL_REG_128
) ? 128
15680 _bfd_mips_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
15684 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
15686 /* Print normal ELF private data. */
15687 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
15689 /* xgettext:c-format */
15690 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
15692 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
)
15693 fprintf (file
, _(" [abi=O32]"));
15694 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O64
)
15695 fprintf (file
, _(" [abi=O64]"));
15696 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
)
15697 fprintf (file
, _(" [abi=EABI32]"));
15698 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
15699 fprintf (file
, _(" [abi=EABI64]"));
15700 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
))
15701 fprintf (file
, _(" [abi unknown]"));
15702 else if (ABI_N32_P (abfd
))
15703 fprintf (file
, _(" [abi=N32]"));
15704 else if (ABI_64_P (abfd
))
15705 fprintf (file
, _(" [abi=64]"));
15707 fprintf (file
, _(" [no abi set]"));
15709 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
15710 fprintf (file
, " [mips1]");
15711 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
15712 fprintf (file
, " [mips2]");
15713 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
15714 fprintf (file
, " [mips3]");
15715 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
15716 fprintf (file
, " [mips4]");
15717 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_5
)
15718 fprintf (file
, " [mips5]");
15719 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
)
15720 fprintf (file
, " [mips32]");
15721 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64
)
15722 fprintf (file
, " [mips64]");
15723 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
)
15724 fprintf (file
, " [mips32r2]");
15725 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64R2
)
15726 fprintf (file
, " [mips64r2]");
15727 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R6
)
15728 fprintf (file
, " [mips32r6]");
15729 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64R6
)
15730 fprintf (file
, " [mips64r6]");
15732 fprintf (file
, _(" [unknown ISA]"));
15734 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
15735 fprintf (file
, " [mdmx]");
15737 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_M16
)
15738 fprintf (file
, " [mips16]");
15740 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
15741 fprintf (file
, " [micromips]");
15743 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_NAN2008
)
15744 fprintf (file
, " [nan2008]");
15746 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_FP64
)
15747 fprintf (file
, " [old fp64]");
15749 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_32BITMODE
)
15750 fprintf (file
, " [32bitmode]");
15752 fprintf (file
, _(" [not 32bitmode]"));
15754 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_NOREORDER
)
15755 fprintf (file
, " [noreorder]");
15757 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_PIC
)
15758 fprintf (file
, " [PIC]");
15760 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_CPIC
)
15761 fprintf (file
, " [CPIC]");
15763 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_XGOT
)
15764 fprintf (file
, " [XGOT]");
15766 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_UCODE
)
15767 fprintf (file
, " [UCODE]");
15769 fputc ('\n', file
);
15771 if (mips_elf_tdata (abfd
)->abiflags_valid
)
15773 Elf_Internal_ABIFlags_v0
*abiflags
= &mips_elf_tdata (abfd
)->abiflags
;
15774 fprintf (file
, "\nMIPS ABI Flags Version: %d\n", abiflags
->version
);
15775 fprintf (file
, "\nISA: MIPS%d", abiflags
->isa_level
);
15776 if (abiflags
->isa_rev
> 1)
15777 fprintf (file
, "r%d", abiflags
->isa_rev
);
15778 fprintf (file
, "\nGPR size: %d",
15779 get_mips_reg_size (abiflags
->gpr_size
));
15780 fprintf (file
, "\nCPR1 size: %d",
15781 get_mips_reg_size (abiflags
->cpr1_size
));
15782 fprintf (file
, "\nCPR2 size: %d",
15783 get_mips_reg_size (abiflags
->cpr2_size
));
15784 fputs ("\nFP ABI: ", file
);
15785 print_mips_fp_abi_value (file
, abiflags
->fp_abi
);
15786 fputs ("ISA Extension: ", file
);
15787 print_mips_isa_ext (file
, abiflags
->isa_ext
);
15788 fputs ("\nASEs:", file
);
15789 print_mips_ases (file
, abiflags
->ases
);
15790 fprintf (file
, "\nFLAGS 1: %8.8lx", abiflags
->flags1
);
15791 fprintf (file
, "\nFLAGS 2: %8.8lx", abiflags
->flags2
);
15792 fputc ('\n', file
);
15798 const struct bfd_elf_special_section _bfd_mips_elf_special_sections
[] =
15800 { STRING_COMMA_LEN (".lit4"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
15801 { STRING_COMMA_LEN (".lit8"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
15802 { STRING_COMMA_LEN (".mdebug"), 0, SHT_MIPS_DEBUG
, 0 },
15803 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
15804 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
15805 { STRING_COMMA_LEN (".ucode"), 0, SHT_MIPS_UCODE
, 0 },
15806 { NULL
, 0, 0, 0, 0 }
15809 /* Merge non visibility st_other attributes. Ensure that the
15810 STO_OPTIONAL flag is copied into h->other, even if this is not a
15811 definiton of the symbol. */
15813 _bfd_mips_elf_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
15814 const Elf_Internal_Sym
*isym
,
15815 bfd_boolean definition
,
15816 bfd_boolean dynamic ATTRIBUTE_UNUSED
)
15818 if ((isym
->st_other
& ~ELF_ST_VISIBILITY (-1)) != 0)
15820 unsigned char other
;
15822 other
= (definition
? isym
->st_other
: h
->other
);
15823 other
&= ~ELF_ST_VISIBILITY (-1);
15824 h
->other
= other
| ELF_ST_VISIBILITY (h
->other
);
15828 && ELF_MIPS_IS_OPTIONAL (isym
->st_other
))
15829 h
->other
|= STO_OPTIONAL
;
15832 /* Decide whether an undefined symbol is special and can be ignored.
15833 This is the case for OPTIONAL symbols on IRIX. */
15835 _bfd_mips_elf_ignore_undef_symbol (struct elf_link_hash_entry
*h
)
15837 return ELF_MIPS_IS_OPTIONAL (h
->other
) ? TRUE
: FALSE
;
15841 _bfd_mips_elf_common_definition (Elf_Internal_Sym
*sym
)
15843 return (sym
->st_shndx
== SHN_COMMON
15844 || sym
->st_shndx
== SHN_MIPS_ACOMMON
15845 || sym
->st_shndx
== SHN_MIPS_SCOMMON
);
15848 /* Return address for Ith PLT stub in section PLT, for relocation REL
15849 or (bfd_vma) -1 if it should not be included. */
15852 _bfd_mips_elf_plt_sym_val (bfd_vma i
, const asection
*plt
,
15853 const arelent
*rel ATTRIBUTE_UNUSED
)
15856 + 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry
)
15857 + i
* 4 * ARRAY_SIZE (mips_exec_plt_entry
));
15860 /* Build a table of synthetic symbols to represent the PLT. As with MIPS16
15861 and microMIPS PLT slots we may have a many-to-one mapping between .plt
15862 and .got.plt and also the slots may be of a different size each we walk
15863 the PLT manually fetching instructions and matching them against known
15864 patterns. To make things easier standard MIPS slots, if any, always come
15865 first. As we don't create proper ELF symbols we use the UDATA.I member
15866 of ASYMBOL to carry ISA annotation. The encoding used is the same as
15867 with the ST_OTHER member of the ELF symbol. */
15870 _bfd_mips_elf_get_synthetic_symtab (bfd
*abfd
,
15871 long symcount ATTRIBUTE_UNUSED
,
15872 asymbol
**syms ATTRIBUTE_UNUSED
,
15873 long dynsymcount
, asymbol
**dynsyms
,
15876 static const char pltname
[] = "_PROCEDURE_LINKAGE_TABLE_";
15877 static const char microsuffix
[] = "@micromipsplt";
15878 static const char m16suffix
[] = "@mips16plt";
15879 static const char mipssuffix
[] = "@plt";
15881 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
15882 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
15883 bfd_boolean micromips_p
= MICROMIPS_P (abfd
);
15884 Elf_Internal_Shdr
*hdr
;
15885 bfd_byte
*plt_data
;
15886 bfd_vma plt_offset
;
15887 unsigned int other
;
15888 bfd_vma entry_size
;
15907 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0 || dynsymcount
<= 0)
15910 relplt
= bfd_get_section_by_name (abfd
, ".rel.plt");
15911 if (relplt
== NULL
)
15914 hdr
= &elf_section_data (relplt
)->this_hdr
;
15915 if (hdr
->sh_link
!= elf_dynsymtab (abfd
) || hdr
->sh_type
!= SHT_REL
)
15918 plt
= bfd_get_section_by_name (abfd
, ".plt");
15922 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
15923 if (!(*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
15925 p
= relplt
->relocation
;
15927 /* Calculating the exact amount of space required for symbols would
15928 require two passes over the PLT, so just pessimise assuming two
15929 PLT slots per relocation. */
15930 count
= relplt
->size
/ hdr
->sh_entsize
;
15931 counti
= count
* bed
->s
->int_rels_per_ext_rel
;
15932 size
= 2 * count
* sizeof (asymbol
);
15933 size
+= count
* (sizeof (mipssuffix
) +
15934 (micromips_p
? sizeof (microsuffix
) : sizeof (m16suffix
)));
15935 for (pi
= 0; pi
< counti
; pi
+= bed
->s
->int_rels_per_ext_rel
)
15936 size
+= 2 * strlen ((*p
[pi
].sym_ptr_ptr
)->name
);
15938 /* Add the size of "_PROCEDURE_LINKAGE_TABLE_" too. */
15939 size
+= sizeof (asymbol
) + sizeof (pltname
);
15941 if (!bfd_malloc_and_get_section (abfd
, plt
, &plt_data
))
15944 if (plt
->size
< 16)
15947 s
= *ret
= bfd_malloc (size
);
15950 send
= s
+ 2 * count
+ 1;
15952 names
= (char *) send
;
15953 nend
= (char *) s
+ size
;
15956 opcode
= bfd_get_micromips_32 (abfd
, plt_data
+ 12);
15957 if (opcode
== 0x3302fffe)
15961 plt0_size
= 2 * ARRAY_SIZE (micromips_o32_exec_plt0_entry
);
15962 other
= STO_MICROMIPS
;
15964 else if (opcode
== 0x0398c1d0)
15968 plt0_size
= 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt0_entry
);
15969 other
= STO_MICROMIPS
;
15973 plt0_size
= 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry
);
15978 s
->flags
= BSF_SYNTHETIC
| BSF_FUNCTION
| BSF_LOCAL
;
15982 s
->udata
.i
= other
;
15983 memcpy (names
, pltname
, sizeof (pltname
));
15984 names
+= sizeof (pltname
);
15988 for (plt_offset
= plt0_size
;
15989 plt_offset
+ 8 <= plt
->size
&& s
< send
;
15990 plt_offset
+= entry_size
)
15992 bfd_vma gotplt_addr
;
15993 const char *suffix
;
15998 opcode
= bfd_get_micromips_32 (abfd
, plt_data
+ plt_offset
+ 4);
16000 /* Check if the second word matches the expected MIPS16 instruction. */
16001 if (opcode
== 0x651aeb00)
16005 /* Truncated table??? */
16006 if (plt_offset
+ 16 > plt
->size
)
16008 gotplt_addr
= bfd_get_32 (abfd
, plt_data
+ plt_offset
+ 12);
16009 entry_size
= 2 * ARRAY_SIZE (mips16_o32_exec_plt_entry
);
16010 suffixlen
= sizeof (m16suffix
);
16011 suffix
= m16suffix
;
16012 other
= STO_MIPS16
;
16014 /* Likewise the expected microMIPS instruction (no insn32 mode). */
16015 else if (opcode
== 0xff220000)
16019 gotplt_hi
= bfd_get_16 (abfd
, plt_data
+ plt_offset
) & 0x7f;
16020 gotplt_lo
= bfd_get_16 (abfd
, plt_data
+ plt_offset
+ 2) & 0xffff;
16021 gotplt_hi
= ((gotplt_hi
^ 0x40) - 0x40) << 18;
16023 gotplt_addr
= gotplt_hi
+ gotplt_lo
;
16024 gotplt_addr
+= ((plt
->vma
+ plt_offset
) | 3) ^ 3;
16025 entry_size
= 2 * ARRAY_SIZE (micromips_o32_exec_plt_entry
);
16026 suffixlen
= sizeof (microsuffix
);
16027 suffix
= microsuffix
;
16028 other
= STO_MICROMIPS
;
16030 /* Likewise the expected microMIPS instruction (insn32 mode). */
16031 else if ((opcode
& 0xffff0000) == 0xff2f0000)
16033 gotplt_hi
= bfd_get_16 (abfd
, plt_data
+ plt_offset
+ 2) & 0xffff;
16034 gotplt_lo
= bfd_get_16 (abfd
, plt_data
+ plt_offset
+ 6) & 0xffff;
16035 gotplt_hi
= ((gotplt_hi
^ 0x8000) - 0x8000) << 16;
16036 gotplt_lo
= (gotplt_lo
^ 0x8000) - 0x8000;
16037 gotplt_addr
= gotplt_hi
+ gotplt_lo
;
16038 entry_size
= 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt_entry
);
16039 suffixlen
= sizeof (microsuffix
);
16040 suffix
= microsuffix
;
16041 other
= STO_MICROMIPS
;
16043 /* Otherwise assume standard MIPS code. */
16046 gotplt_hi
= bfd_get_32 (abfd
, plt_data
+ plt_offset
) & 0xffff;
16047 gotplt_lo
= bfd_get_32 (abfd
, plt_data
+ plt_offset
+ 4) & 0xffff;
16048 gotplt_hi
= ((gotplt_hi
^ 0x8000) - 0x8000) << 16;
16049 gotplt_lo
= (gotplt_lo
^ 0x8000) - 0x8000;
16050 gotplt_addr
= gotplt_hi
+ gotplt_lo
;
16051 entry_size
= 4 * ARRAY_SIZE (mips_exec_plt_entry
);
16052 suffixlen
= sizeof (mipssuffix
);
16053 suffix
= mipssuffix
;
16056 /* Truncated table??? */
16057 if (plt_offset
+ entry_size
> plt
->size
)
16061 i
< count
&& p
[pi
].address
!= gotplt_addr
;
16062 i
++, pi
= (pi
+ bed
->s
->int_rels_per_ext_rel
) % counti
);
16069 *s
= **p
[pi
].sym_ptr_ptr
;
16070 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
16071 we are defining a symbol, ensure one of them is set. */
16072 if ((s
->flags
& BSF_LOCAL
) == 0)
16073 s
->flags
|= BSF_GLOBAL
;
16074 s
->flags
|= BSF_SYNTHETIC
;
16076 s
->value
= plt_offset
;
16078 s
->udata
.i
= other
;
16080 len
= strlen ((*p
[pi
].sym_ptr_ptr
)->name
);
16081 namelen
= len
+ suffixlen
;
16082 if (names
+ namelen
> nend
)
16085 memcpy (names
, (*p
[pi
].sym_ptr_ptr
)->name
, len
);
16087 memcpy (names
, suffix
, suffixlen
);
16088 names
+= suffixlen
;
16091 pi
= (pi
+ bed
->s
->int_rels_per_ext_rel
) % counti
;
16101 _bfd_mips_post_process_headers (bfd
*abfd
, struct bfd_link_info
*link_info
)
16103 struct mips_elf_link_hash_table
*htab
;
16104 Elf_Internal_Ehdr
*i_ehdrp
;
16106 i_ehdrp
= elf_elfheader (abfd
);
16109 htab
= mips_elf_hash_table (link_info
);
16110 BFD_ASSERT (htab
!= NULL
);
16112 if (htab
->use_plts_and_copy_relocs
&& !htab
->is_vxworks
)
16113 i_ehdrp
->e_ident
[EI_ABIVERSION
] = 1;
16116 _bfd_elf_post_process_headers (abfd
, link_info
);
16118 if (mips_elf_tdata (abfd
)->abiflags
.fp_abi
== Val_GNU_MIPS_ABI_FP_64
16119 || mips_elf_tdata (abfd
)->abiflags
.fp_abi
== Val_GNU_MIPS_ABI_FP_64A
)
16120 i_ehdrp
->e_ident
[EI_ABIVERSION
] = 3;
16124 _bfd_mips_elf_compact_eh_encoding (struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
)
16126 return DW_EH_PE_pcrel
| DW_EH_PE_sdata4
;
16129 /* Return the opcode for can't unwind. */
16132 _bfd_mips_elf_cant_unwind_opcode (struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
)
16134 return COMPACT_EH_CANT_UNWIND_OPCODE
;