1 /* MIPS-specific support for ELF
2 Copyright (C) 1993-2020 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 "ecoff-bfd.h"
37 #include "elfxx-mips.h"
39 #include "elf-vxworks.h"
42 /* Get the ECOFF swapping routines. */
44 #include "coff/symconst.h"
45 #include "coff/ecoff.h"
46 #include "coff/mips.h"
50 /* Types of TLS GOT entry. */
51 enum mips_got_tls_type
{
58 /* This structure is used to hold information about one GOT entry.
59 There are four types of entry:
61 (1) an absolute address
62 requires: abfd == NULL
65 (2) a SYMBOL + OFFSET address, where SYMBOL is local to an input bfd
66 requires: abfd != NULL, symndx >= 0, tls_type != GOT_TLS_LDM
67 fields: abfd, symndx, d.addend, tls_type
69 (3) a SYMBOL address, where SYMBOL is not local to an input bfd
70 requires: abfd != NULL, symndx == -1
74 requires: abfd != NULL, symndx == 0, tls_type == GOT_TLS_LDM
75 fields: none; there's only one of these per GOT. */
78 /* One input bfd that needs the GOT entry. */
80 /* The index of the symbol, as stored in the relocation r_info, if
81 we have a local symbol; -1 otherwise. */
85 /* If abfd == NULL, an address that must be stored in the got. */
87 /* If abfd != NULL && symndx != -1, the addend of the relocation
88 that should be added to the symbol value. */
90 /* If abfd != NULL && symndx == -1, the hash table entry
91 corresponding to a symbol in the GOT. The symbol's entry
92 is in the local area if h->global_got_area is GGA_NONE,
93 otherwise it is in the global area. */
94 struct mips_elf_link_hash_entry
*h
;
97 /* The TLS type of this GOT entry. An LDM GOT entry will be a local
98 symbol entry with r_symndx == 0. */
99 unsigned char tls_type
;
101 /* True if we have filled in the GOT contents for a TLS entry,
102 and created the associated relocations. */
103 unsigned char tls_initialized
;
105 /* The offset from the beginning of the .got section to the entry
106 corresponding to this symbol+addend. If it's a global symbol
107 whose offset is yet to be decided, it's going to be -1. */
111 /* This structure represents a GOT page reference from an input bfd.
112 Each instance represents a symbol + ADDEND, where the representation
113 of the symbol depends on whether it is local to the input bfd.
114 If it is, then SYMNDX >= 0, and the symbol has index SYMNDX in U.ABFD.
115 Otherwise, SYMNDX < 0 and U.H points to the symbol's hash table entry.
117 Page references with SYMNDX >= 0 always become page references
118 in the output. Page references with SYMNDX < 0 only become page
119 references if the symbol binds locally; in other cases, the page
120 reference decays to a global GOT reference. */
121 struct mips_got_page_ref
126 struct mips_elf_link_hash_entry
*h
;
132 /* This structure describes a range of addends: [MIN_ADDEND, MAX_ADDEND].
133 The structures form a non-overlapping list that is sorted by increasing
135 struct mips_got_page_range
137 struct mips_got_page_range
*next
;
138 bfd_signed_vma min_addend
;
139 bfd_signed_vma max_addend
;
142 /* This structure describes the range of addends that are applied to page
143 relocations against a given section. */
144 struct mips_got_page_entry
146 /* The section that these entries are based on. */
148 /* The ranges for this page entry. */
149 struct mips_got_page_range
*ranges
;
150 /* The maximum number of page entries needed for RANGES. */
154 /* This structure is used to hold .got information when linking. */
158 /* The number of global .got entries. */
159 unsigned int global_gotno
;
160 /* The number of global .got entries that are in the GGA_RELOC_ONLY area. */
161 unsigned int reloc_only_gotno
;
162 /* The number of .got slots used for TLS. */
163 unsigned int tls_gotno
;
164 /* The first unused TLS .got entry. Used only during
165 mips_elf_initialize_tls_index. */
166 unsigned int tls_assigned_gotno
;
167 /* The number of local .got entries, eventually including page entries. */
168 unsigned int local_gotno
;
169 /* The maximum number of page entries needed. */
170 unsigned int page_gotno
;
171 /* The number of relocations needed for the GOT entries. */
173 /* The first unused local .got entry. */
174 unsigned int assigned_low_gotno
;
175 /* The last unused local .got entry. */
176 unsigned int assigned_high_gotno
;
177 /* A hash table holding members of the got. */
178 struct htab
*got_entries
;
179 /* A hash table holding mips_got_page_ref structures. */
180 struct htab
*got_page_refs
;
181 /* A hash table of mips_got_page_entry structures. */
182 struct htab
*got_page_entries
;
183 /* In multi-got links, a pointer to the next got (err, rather, most
184 of the time, it points to the previous got). */
185 struct mips_got_info
*next
;
188 /* Structure passed when merging bfds' gots. */
190 struct mips_elf_got_per_bfd_arg
192 /* The output bfd. */
194 /* The link information. */
195 struct bfd_link_info
*info
;
196 /* A pointer to the primary got, i.e., the one that's going to get
197 the implicit relocations from DT_MIPS_LOCAL_GOTNO and
199 struct mips_got_info
*primary
;
200 /* A non-primary got we're trying to merge with other input bfd's
202 struct mips_got_info
*current
;
203 /* The maximum number of got entries that can be addressed with a
205 unsigned int max_count
;
206 /* The maximum number of page entries needed by each got. */
207 unsigned int max_pages
;
208 /* The total number of global entries which will live in the
209 primary got and be automatically relocated. This includes
210 those not referenced by the primary GOT but included in
212 unsigned int global_count
;
215 /* A structure used to pass information to htab_traverse callbacks
216 when laying out the GOT. */
218 struct mips_elf_traverse_got_arg
220 struct bfd_link_info
*info
;
221 struct mips_got_info
*g
;
225 struct _mips_elf_section_data
227 struct bfd_elf_section_data elf
;
234 #define mips_elf_section_data(sec) \
235 ((struct _mips_elf_section_data *) elf_section_data (sec))
237 #define is_mips_elf(bfd) \
238 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
239 && elf_tdata (bfd) != NULL \
240 && elf_object_id (bfd) == MIPS_ELF_DATA)
242 /* The ABI says that every symbol used by dynamic relocations must have
243 a global GOT entry. Among other things, this provides the dynamic
244 linker with a free, directly-indexed cache. The GOT can therefore
245 contain symbols that are not referenced by GOT relocations themselves
246 (in other words, it may have symbols that are not referenced by things
247 like R_MIPS_GOT16 and R_MIPS_GOT_PAGE).
249 GOT relocations are less likely to overflow if we put the associated
250 GOT entries towards the beginning. We therefore divide the global
251 GOT entries into two areas: "normal" and "reloc-only". Entries in
252 the first area can be used for both dynamic relocations and GP-relative
253 accesses, while those in the "reloc-only" area are for dynamic
256 These GGA_* ("Global GOT Area") values are organised so that lower
257 values are more general than higher values. Also, non-GGA_NONE
258 values are ordered by the position of the area in the GOT. */
260 #define GGA_RELOC_ONLY 1
263 /* Information about a non-PIC interface to a PIC function. There are
264 two ways of creating these interfaces. The first is to add:
267 addiu $25,$25,%lo(func)
269 immediately before a PIC function "func". The second is to add:
273 addiu $25,$25,%lo(func)
275 to a separate trampoline section.
277 Stubs of the first kind go in a new section immediately before the
278 target function. Stubs of the second kind go in a single section
279 pointed to by the hash table's "strampoline" field. */
280 struct mips_elf_la25_stub
{
281 /* The generated section that contains this stub. */
282 asection
*stub_section
;
284 /* The offset of the stub from the start of STUB_SECTION. */
287 /* One symbol for the original function. Its location is available
288 in H->root.root.u.def. */
289 struct mips_elf_link_hash_entry
*h
;
292 /* Macros for populating a mips_elf_la25_stub. */
294 #define LA25_LUI(VAL) (0x3c190000 | (VAL)) /* lui t9,VAL */
295 #define LA25_J(VAL) (0x08000000 | (((VAL) >> 2) & 0x3ffffff)) /* j VAL */
296 #define LA25_BC(VAL) (0xc8000000 | (((VAL) >> 2) & 0x3ffffff)) /* bc VAL */
297 #define LA25_ADDIU(VAL) (0x27390000 | (VAL)) /* addiu t9,t9,VAL */
298 #define LA25_LUI_MICROMIPS(VAL) \
299 (0x41b90000 | (VAL)) /* lui t9,VAL */
300 #define LA25_J_MICROMIPS(VAL) \
301 (0xd4000000 | (((VAL) >> 1) & 0x3ffffff)) /* j VAL */
302 #define LA25_ADDIU_MICROMIPS(VAL) \
303 (0x33390000 | (VAL)) /* addiu t9,t9,VAL */
305 /* This structure is passed to mips_elf_sort_hash_table_f when sorting
306 the dynamic symbols. */
308 struct mips_elf_hash_sort_data
310 /* The symbol in the global GOT with the lowest dynamic symbol table
312 struct elf_link_hash_entry
*low
;
313 /* The least dynamic symbol table index corresponding to a non-TLS
314 symbol with a GOT entry. */
315 bfd_size_type min_got_dynindx
;
316 /* The greatest dynamic symbol table index corresponding to a symbol
317 with a GOT entry that is not referenced (e.g., a dynamic symbol
318 with dynamic relocations pointing to it from non-primary GOTs). */
319 bfd_size_type max_unref_got_dynindx
;
320 /* The greatest dynamic symbol table index corresponding to a local
322 bfd_size_type max_local_dynindx
;
323 /* The greatest dynamic symbol table index corresponding to an external
324 symbol without a GOT entry. */
325 bfd_size_type max_non_got_dynindx
;
326 /* If non-NULL, output BFD for .MIPS.xhash finalization. */
328 /* If non-NULL, pointer to contents of .MIPS.xhash for filling in
329 real final dynindx. */
333 /* We make up to two PLT entries if needed, one for standard MIPS code
334 and one for compressed code, either a MIPS16 or microMIPS one. We
335 keep a separate record of traditional lazy-binding stubs, for easier
340 /* Traditional SVR4 stub offset, or -1 if none. */
343 /* Standard PLT entry offset, or -1 if none. */
346 /* Compressed PLT entry offset, or -1 if none. */
349 /* The corresponding .got.plt index, or -1 if none. */
350 bfd_vma gotplt_index
;
352 /* Whether we need a standard PLT entry. */
353 unsigned int need_mips
: 1;
355 /* Whether we need a compressed PLT entry. */
356 unsigned int need_comp
: 1;
359 /* The MIPS ELF linker needs additional information for each symbol in
360 the global hash table. */
362 struct mips_elf_link_hash_entry
364 struct elf_link_hash_entry root
;
366 /* External symbol information. */
369 /* The la25 stub we have created for ths symbol, if any. */
370 struct mips_elf_la25_stub
*la25_stub
;
372 /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
374 unsigned int possibly_dynamic_relocs
;
376 /* If there is a stub that 32 bit functions should use to call this
377 16 bit function, this points to the section containing the stub. */
380 /* If there is a stub that 16 bit functions should use to call this
381 32 bit function, this points to the section containing the stub. */
384 /* This is like the call_stub field, but it is used if the function
385 being called returns a floating point value. */
386 asection
*call_fp_stub
;
388 /* If non-zero, location in .MIPS.xhash to write real final dynindx. */
389 bfd_vma mipsxhash_loc
;
391 /* The highest GGA_* value that satisfies all references to this symbol. */
392 unsigned int global_got_area
: 2;
394 /* True if all GOT relocations against this symbol are for calls. This is
395 a looser condition than no_fn_stub below, because there may be other
396 non-call non-GOT relocations against the symbol. */
397 unsigned int got_only_for_calls
: 1;
399 /* True if one of the relocations described by possibly_dynamic_relocs
400 is against a readonly section. */
401 unsigned int readonly_reloc
: 1;
403 /* True if there is a relocation against this symbol that must be
404 resolved by the static linker (in other words, if the relocation
405 cannot possibly be made dynamic). */
406 unsigned int has_static_relocs
: 1;
408 /* True if we must not create a .MIPS.stubs entry for this symbol.
409 This is set, for example, if there are relocations related to
410 taking the function's address, i.e. any but R_MIPS_CALL*16 ones.
411 See "MIPS ABI Supplement, 3rd Edition", p. 4-20. */
412 unsigned int no_fn_stub
: 1;
414 /* Whether we need the fn_stub; this is true if this symbol appears
415 in any relocs other than a 16 bit call. */
416 unsigned int need_fn_stub
: 1;
418 /* True if this symbol is referenced by branch relocations from
419 any non-PIC input file. This is used to determine whether an
420 la25 stub is required. */
421 unsigned int has_nonpic_branches
: 1;
423 /* Does this symbol need a traditional MIPS lazy-binding stub
424 (as opposed to a PLT entry)? */
425 unsigned int needs_lazy_stub
: 1;
427 /* Does this symbol resolve to a PLT entry? */
428 unsigned int use_plt_entry
: 1;
431 /* MIPS ELF linker hash table. */
433 struct mips_elf_link_hash_table
435 struct elf_link_hash_table root
;
437 /* The number of .rtproc entries. */
438 bfd_size_type procedure_count
;
440 /* The size of the .compact_rel section (if SGI_COMPAT). */
441 bfd_size_type compact_rel_size
;
443 /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic entry
444 is set to the address of __rld_obj_head as in IRIX5 and IRIX6. */
445 bfd_boolean use_rld_obj_head
;
447 /* The __rld_map or __rld_obj_head symbol. */
448 struct elf_link_hash_entry
*rld_symbol
;
450 /* This is set if we see any mips16 stub sections. */
451 bfd_boolean mips16_stubs_seen
;
453 /* True if we can generate copy relocs and PLTs. */
454 bfd_boolean use_plts_and_copy_relocs
;
456 /* True if we can only use 32-bit microMIPS instructions. */
459 /* True if we suppress checks for invalid branches between ISA modes. */
460 bfd_boolean ignore_branch_isa
;
462 /* True if we are targetting R6 compact branches. */
463 bfd_boolean compact_branches
;
465 /* True if we're generating code for VxWorks. */
466 bfd_boolean is_vxworks
;
468 /* True if we already reported the small-data section overflow. */
469 bfd_boolean small_data_overflow_reported
;
471 /* True if we use the special `__gnu_absolute_zero' symbol. */
472 bfd_boolean use_absolute_zero
;
474 /* True if we have been configured for a GNU target. */
475 bfd_boolean gnu_target
;
477 /* Shortcuts to some dynamic sections, or NULL if they are not
482 /* The master GOT information. */
483 struct mips_got_info
*got_info
;
485 /* The global symbol in the GOT with the lowest index in the dynamic
487 struct elf_link_hash_entry
*global_gotsym
;
489 /* The size of the PLT header in bytes. */
490 bfd_vma plt_header_size
;
492 /* The size of a standard PLT entry in bytes. */
493 bfd_vma plt_mips_entry_size
;
495 /* The size of a compressed PLT entry in bytes. */
496 bfd_vma plt_comp_entry_size
;
498 /* The offset of the next standard PLT entry to create. */
499 bfd_vma plt_mips_offset
;
501 /* The offset of the next compressed PLT entry to create. */
502 bfd_vma plt_comp_offset
;
504 /* The index of the next .got.plt entry to create. */
505 bfd_vma plt_got_index
;
507 /* The number of functions that need a lazy-binding stub. */
508 bfd_vma lazy_stub_count
;
510 /* The size of a function stub entry in bytes. */
511 bfd_vma function_stub_size
;
513 /* The number of reserved entries at the beginning of the GOT. */
514 unsigned int reserved_gotno
;
516 /* The section used for mips_elf_la25_stub trampolines.
517 See the comment above that structure for details. */
518 asection
*strampoline
;
520 /* A table of mips_elf_la25_stubs, indexed by (input_section, offset)
524 /* A function FN (NAME, IS, OS) that creates a new input section
525 called NAME and links it to output section OS. If IS is nonnull,
526 the new section should go immediately before it, otherwise it
527 should go at the (current) beginning of OS.
529 The function returns the new section on success, otherwise it
531 asection
*(*add_stub_section
) (const char *, asection
*, asection
*);
533 /* Small local sym cache. */
534 struct sym_cache sym_cache
;
536 /* Is the PLT header compressed? */
537 unsigned int plt_header_is_comp
: 1;
540 /* Get the MIPS ELF linker hash table from a link_info structure. */
542 #define mips_elf_hash_table(p) \
543 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
544 == MIPS_ELF_DATA ? ((struct mips_elf_link_hash_table *) ((p)->hash)) : NULL)
546 /* A structure used to communicate with htab_traverse callbacks. */
547 struct mips_htab_traverse_info
549 /* The usual link-wide information. */
550 struct bfd_link_info
*info
;
553 /* Starts off FALSE and is set to TRUE if the link should be aborted. */
557 /* MIPS ELF private object data. */
559 struct mips_elf_obj_tdata
561 /* Generic ELF private object data. */
562 struct elf_obj_tdata root
;
564 /* Input BFD providing Tag_GNU_MIPS_ABI_FP attribute for output. */
567 /* Input BFD providing Tag_GNU_MIPS_ABI_MSA attribute for output. */
570 /* The abiflags for this object. */
571 Elf_Internal_ABIFlags_v0 abiflags
;
572 bfd_boolean abiflags_valid
;
574 /* The GOT requirements of input bfds. */
575 struct mips_got_info
*got
;
577 /* Used by _bfd_mips_elf_find_nearest_line. The structure could be
578 included directly in this one, but there's no point to wasting
579 the memory just for the infrequently called find_nearest_line. */
580 struct mips_elf_find_line
*find_line_info
;
582 /* An array of stub sections indexed by symbol number. */
583 asection
**local_stubs
;
584 asection
**local_call_stubs
;
586 /* The Irix 5 support uses two virtual sections, which represent
587 text/data symbols defined in dynamic objects. */
588 asymbol
*elf_data_symbol
;
589 asymbol
*elf_text_symbol
;
590 asection
*elf_data_section
;
591 asection
*elf_text_section
;
594 /* Get MIPS ELF private object data from BFD's tdata. */
596 #define mips_elf_tdata(bfd) \
597 ((struct mips_elf_obj_tdata *) (bfd)->tdata.any)
599 #define TLS_RELOC_P(r_type) \
600 (r_type == R_MIPS_TLS_DTPMOD32 \
601 || r_type == R_MIPS_TLS_DTPMOD64 \
602 || r_type == R_MIPS_TLS_DTPREL32 \
603 || r_type == R_MIPS_TLS_DTPREL64 \
604 || r_type == R_MIPS_TLS_GD \
605 || r_type == R_MIPS_TLS_LDM \
606 || r_type == R_MIPS_TLS_DTPREL_HI16 \
607 || r_type == R_MIPS_TLS_DTPREL_LO16 \
608 || r_type == R_MIPS_TLS_GOTTPREL \
609 || r_type == R_MIPS_TLS_TPREL32 \
610 || r_type == R_MIPS_TLS_TPREL64 \
611 || r_type == R_MIPS_TLS_TPREL_HI16 \
612 || r_type == R_MIPS_TLS_TPREL_LO16 \
613 || r_type == R_MIPS16_TLS_GD \
614 || r_type == R_MIPS16_TLS_LDM \
615 || r_type == R_MIPS16_TLS_DTPREL_HI16 \
616 || r_type == R_MIPS16_TLS_DTPREL_LO16 \
617 || r_type == R_MIPS16_TLS_GOTTPREL \
618 || r_type == R_MIPS16_TLS_TPREL_HI16 \
619 || r_type == R_MIPS16_TLS_TPREL_LO16 \
620 || r_type == R_MICROMIPS_TLS_GD \
621 || r_type == R_MICROMIPS_TLS_LDM \
622 || r_type == R_MICROMIPS_TLS_DTPREL_HI16 \
623 || r_type == R_MICROMIPS_TLS_DTPREL_LO16 \
624 || r_type == R_MICROMIPS_TLS_GOTTPREL \
625 || r_type == R_MICROMIPS_TLS_TPREL_HI16 \
626 || r_type == R_MICROMIPS_TLS_TPREL_LO16)
628 /* Structure used to pass information to mips_elf_output_extsym. */
633 struct bfd_link_info
*info
;
634 struct ecoff_debug_info
*debug
;
635 const struct ecoff_debug_swap
*swap
;
639 /* The names of the runtime procedure table symbols used on IRIX5. */
641 static const char * const mips_elf_dynsym_rtproc_names
[] =
644 "_procedure_string_table",
645 "_procedure_table_size",
649 /* These structures are used to generate the .compact_rel section on
654 unsigned long id1
; /* Always one? */
655 unsigned long num
; /* Number of compact relocation entries. */
656 unsigned long id2
; /* Always two? */
657 unsigned long offset
; /* The file offset of the first relocation. */
658 unsigned long reserved0
; /* Zero? */
659 unsigned long reserved1
; /* Zero? */
668 bfd_byte reserved0
[4];
669 bfd_byte reserved1
[4];
670 } Elf32_External_compact_rel
;
674 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
675 unsigned int rtype
: 4; /* Relocation types. See below. */
676 unsigned int dist2to
: 8;
677 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
678 unsigned long konst
; /* KONST field. See below. */
679 unsigned long vaddr
; /* VADDR to be relocated. */
684 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
685 unsigned int rtype
: 4; /* Relocation types. See below. */
686 unsigned int dist2to
: 8;
687 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
688 unsigned long konst
; /* KONST field. See below. */
696 } Elf32_External_crinfo
;
702 } Elf32_External_crinfo2
;
704 /* These are the constants used to swap the bitfields in a crinfo. */
706 #define CRINFO_CTYPE (0x1)
707 #define CRINFO_CTYPE_SH (31)
708 #define CRINFO_RTYPE (0xf)
709 #define CRINFO_RTYPE_SH (27)
710 #define CRINFO_DIST2TO (0xff)
711 #define CRINFO_DIST2TO_SH (19)
712 #define CRINFO_RELVADDR (0x7ffff)
713 #define CRINFO_RELVADDR_SH (0)
715 /* A compact relocation info has long (3 words) or short (2 words)
716 formats. A short format doesn't have VADDR field and relvaddr
717 fields contains ((VADDR - vaddr of the previous entry) >> 2). */
718 #define CRF_MIPS_LONG 1
719 #define CRF_MIPS_SHORT 0
721 /* There are 4 types of compact relocation at least. The value KONST
722 has different meaning for each type:
725 CT_MIPS_REL32 Address in data
726 CT_MIPS_WORD Address in word (XXX)
727 CT_MIPS_GPHI_LO GP - vaddr
728 CT_MIPS_JMPAD Address to jump
731 #define CRT_MIPS_REL32 0xa
732 #define CRT_MIPS_WORD 0xb
733 #define CRT_MIPS_GPHI_LO 0xc
734 #define CRT_MIPS_JMPAD 0xd
736 #define mips_elf_set_cr_format(x,format) ((x).ctype = (format))
737 #define mips_elf_set_cr_type(x,type) ((x).rtype = (type))
738 #define mips_elf_set_cr_dist2to(x,v) ((x).dist2to = (v))
739 #define mips_elf_set_cr_relvaddr(x,d) ((x).relvaddr = (d)<<2)
741 /* The structure of the runtime procedure descriptor created by the
742 loader for use by the static exception system. */
744 typedef struct runtime_pdr
{
745 bfd_vma adr
; /* Memory address of start of procedure. */
746 long regmask
; /* Save register mask. */
747 long regoffset
; /* Save register offset. */
748 long fregmask
; /* Save floating point register mask. */
749 long fregoffset
; /* Save floating point register offset. */
750 long frameoffset
; /* Frame size. */
751 short framereg
; /* Frame pointer register. */
752 short pcreg
; /* Offset or reg of return pc. */
753 long irpss
; /* Index into the runtime string table. */
755 struct exception_info
*exception_info
;/* Pointer to exception array. */
757 #define cbRPDR sizeof (RPDR)
758 #define rpdNil ((pRPDR) 0)
760 static struct mips_got_entry
*mips_elf_create_local_got_entry
761 (bfd
*, struct bfd_link_info
*, bfd
*, bfd_vma
, unsigned long,
762 struct mips_elf_link_hash_entry
*, int);
763 static bfd_boolean mips_elf_sort_hash_table_f
764 (struct mips_elf_link_hash_entry
*, void *);
765 static bfd_vma mips_elf_high
767 static bfd_boolean mips_elf_create_dynamic_relocation
768 (bfd
*, struct bfd_link_info
*, const Elf_Internal_Rela
*,
769 struct mips_elf_link_hash_entry
*, asection
*, bfd_vma
,
770 bfd_vma
*, asection
*);
771 static bfd_vma mips_elf_adjust_gp
772 (bfd
*, struct mips_got_info
*, bfd
*);
774 /* This will be used when we sort the dynamic relocation records. */
775 static bfd
*reldyn_sorting_bfd
;
777 /* True if ABFD is for CPUs with load interlocking that include
778 non-MIPS1 CPUs and R3900. */
779 #define LOAD_INTERLOCKS_P(abfd) \
780 ( ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) != E_MIPS_ARCH_1) \
781 || ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == E_MIPS_MACH_3900))
783 /* True if ABFD is for CPUs that are faster if JAL is converted to BAL.
784 This should be safe for all architectures. We enable this predicate
785 for RM9000 for now. */
786 #define JAL_TO_BAL_P(abfd) \
787 ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == E_MIPS_MACH_9000)
789 /* True if ABFD is for CPUs that are faster if JALR is converted to BAL.
790 This should be safe for all architectures. We enable this predicate for
792 #define JALR_TO_BAL_P(abfd) 1
794 /* True if ABFD is for CPUs that are faster if JR is converted to B.
795 This should be safe for all architectures. We enable this predicate for
797 #define JR_TO_B_P(abfd) 1
799 /* True if ABFD is a PIC object. */
800 #define PIC_OBJECT_P(abfd) \
801 ((elf_elfheader (abfd)->e_flags & EF_MIPS_PIC) != 0)
803 /* Nonzero if ABFD is using the O32 ABI. */
804 #define ABI_O32_P(abfd) \
805 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32)
807 /* Nonzero if ABFD is using the N32 ABI. */
808 #define ABI_N32_P(abfd) \
809 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
811 /* Nonzero if ABFD is using the N64 ABI. */
812 #define ABI_64_P(abfd) \
813 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
815 /* Nonzero if ABFD is using NewABI conventions. */
816 #define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
818 /* Nonzero if ABFD has microMIPS code. */
819 #define MICROMIPS_P(abfd) \
820 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS) != 0)
822 /* Nonzero if ABFD is MIPS R6. */
823 #define MIPSR6_P(abfd) \
824 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R6 \
825 || (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R6)
827 /* The IRIX compatibility level we are striving for. */
828 #define IRIX_COMPAT(abfd) \
829 (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
831 /* Whether we are trying to be compatible with IRIX at all. */
832 #define SGI_COMPAT(abfd) \
833 (IRIX_COMPAT (abfd) != ict_none)
835 /* The name of the options section. */
836 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
837 (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
839 /* True if NAME is the recognized name of any SHT_MIPS_OPTIONS section.
840 Some IRIX system files do not use MIPS_ELF_OPTIONS_SECTION_NAME. */
841 #define MIPS_ELF_OPTIONS_SECTION_NAME_P(NAME) \
842 (strcmp (NAME, ".MIPS.options") == 0 || strcmp (NAME, ".options") == 0)
844 /* True if NAME is the recognized name of any SHT_MIPS_ABIFLAGS section. */
845 #define MIPS_ELF_ABIFLAGS_SECTION_NAME_P(NAME) \
846 (strcmp (NAME, ".MIPS.abiflags") == 0)
848 /* Whether the section is readonly. */
849 #define MIPS_ELF_READONLY_SECTION(sec) \
850 ((sec->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY)) \
851 == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
853 /* The name of the stub section. */
854 #define MIPS_ELF_STUB_SECTION_NAME(abfd) ".MIPS.stubs"
856 /* The size of an external REL relocation. */
857 #define MIPS_ELF_REL_SIZE(abfd) \
858 (get_elf_backend_data (abfd)->s->sizeof_rel)
860 /* The size of an external RELA relocation. */
861 #define MIPS_ELF_RELA_SIZE(abfd) \
862 (get_elf_backend_data (abfd)->s->sizeof_rela)
864 /* The size of an external dynamic table entry. */
865 #define MIPS_ELF_DYN_SIZE(abfd) \
866 (get_elf_backend_data (abfd)->s->sizeof_dyn)
868 /* The size of a GOT entry. */
869 #define MIPS_ELF_GOT_SIZE(abfd) \
870 (get_elf_backend_data (abfd)->s->arch_size / 8)
872 /* The size of the .rld_map section. */
873 #define MIPS_ELF_RLD_MAP_SIZE(abfd) \
874 (get_elf_backend_data (abfd)->s->arch_size / 8)
876 /* The size of a symbol-table entry. */
877 #define MIPS_ELF_SYM_SIZE(abfd) \
878 (get_elf_backend_data (abfd)->s->sizeof_sym)
880 /* The default alignment for sections, as a power of two. */
881 #define MIPS_ELF_LOG_FILE_ALIGN(abfd) \
882 (get_elf_backend_data (abfd)->s->log_file_align)
884 /* Get word-sized data. */
885 #define MIPS_ELF_GET_WORD(abfd, ptr) \
886 (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
888 /* Put out word-sized data. */
889 #define MIPS_ELF_PUT_WORD(abfd, val, ptr) \
891 ? bfd_put_64 (abfd, val, ptr) \
892 : bfd_put_32 (abfd, val, ptr))
894 /* The opcode for word-sized loads (LW or LD). */
895 #define MIPS_ELF_LOAD_WORD(abfd) \
896 (ABI_64_P (abfd) ? 0xdc000000 : 0x8c000000)
898 /* Add a dynamic symbol table-entry. */
899 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
900 _bfd_elf_add_dynamic_entry (info, tag, val)
902 #define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela) \
903 (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (abfd, rtype, rela))
905 /* The name of the dynamic relocation section. */
906 #define MIPS_ELF_REL_DYN_NAME(INFO) \
907 (mips_elf_hash_table (INFO)->is_vxworks ? ".rela.dyn" : ".rel.dyn")
909 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
910 from smaller values. Start with zero, widen, *then* decrement. */
911 #define MINUS_ONE (((bfd_vma)0) - 1)
912 #define MINUS_TWO (((bfd_vma)0) - 2)
914 /* The value to write into got[1] for SVR4 targets, to identify it is
915 a GNU object. The dynamic linker can then use got[1] to store the
917 #define MIPS_ELF_GNU_GOT1_MASK(abfd) \
918 ((bfd_vma) 1 << (ABI_64_P (abfd) ? 63 : 31))
920 /* The offset of $gp from the beginning of the .got section. */
921 #define ELF_MIPS_GP_OFFSET(INFO) \
922 (mips_elf_hash_table (INFO)->is_vxworks ? 0x0 : 0x7ff0)
924 /* The maximum size of the GOT for it to be addressable using 16-bit
926 #define MIPS_ELF_GOT_MAX_SIZE(INFO) (ELF_MIPS_GP_OFFSET (INFO) + 0x7fff)
928 /* Instructions which appear in a stub. */
929 #define STUB_LW(abfd) \
931 ? 0xdf998010 /* ld t9,0x8010(gp) */ \
932 : 0x8f998010)) /* lw t9,0x8010(gp) */
933 #define STUB_MOVE 0x03e07825 /* or t7,ra,zero */
934 #define STUB_LUI(VAL) (0x3c180000 + (VAL)) /* lui t8,VAL */
935 #define STUB_JALR 0x0320f809 /* jalr ra,t9 */
936 #define STUB_JALRC 0xf8190000 /* jalrc ra,t9 */
937 #define STUB_ORI(VAL) (0x37180000 + (VAL)) /* ori t8,t8,VAL */
938 #define STUB_LI16U(VAL) (0x34180000 + (VAL)) /* ori t8,zero,VAL unsigned */
939 #define STUB_LI16S(abfd, VAL) \
941 ? (0x64180000 + (VAL)) /* daddiu t8,zero,VAL sign extended */ \
942 : (0x24180000 + (VAL)))) /* addiu t8,zero,VAL sign extended */
944 /* Likewise for the microMIPS ASE. */
945 #define STUB_LW_MICROMIPS(abfd) \
947 ? 0xdf3c8010 /* ld t9,0x8010(gp) */ \
948 : 0xff3c8010) /* lw t9,0x8010(gp) */
949 #define STUB_MOVE_MICROMIPS 0x0dff /* move t7,ra */
950 #define STUB_MOVE32_MICROMIPS 0x001f7a90 /* or t7,ra,zero */
951 #define STUB_LUI_MICROMIPS(VAL) \
952 (0x41b80000 + (VAL)) /* lui t8,VAL */
953 #define STUB_JALR_MICROMIPS 0x45d9 /* jalr t9 */
954 #define STUB_JALR32_MICROMIPS 0x03f90f3c /* jalr ra,t9 */
955 #define STUB_ORI_MICROMIPS(VAL) \
956 (0x53180000 + (VAL)) /* ori t8,t8,VAL */
957 #define STUB_LI16U_MICROMIPS(VAL) \
958 (0x53000000 + (VAL)) /* ori t8,zero,VAL unsigned */
959 #define STUB_LI16S_MICROMIPS(abfd, VAL) \
961 ? 0x5f000000 + (VAL) /* daddiu t8,zero,VAL sign extended */ \
962 : 0x33000000 + (VAL)) /* addiu t8,zero,VAL sign extended */
964 #define MIPS_FUNCTION_STUB_NORMAL_SIZE 16
965 #define MIPS_FUNCTION_STUB_BIG_SIZE 20
966 #define MICROMIPS_FUNCTION_STUB_NORMAL_SIZE 12
967 #define MICROMIPS_FUNCTION_STUB_BIG_SIZE 16
968 #define MICROMIPS_INSN32_FUNCTION_STUB_NORMAL_SIZE 16
969 #define MICROMIPS_INSN32_FUNCTION_STUB_BIG_SIZE 20
971 /* The name of the dynamic interpreter. This is put in the .interp
974 #define ELF_DYNAMIC_INTERPRETER(abfd) \
975 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
976 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
977 : "/usr/lib/libc.so.1")
980 #define MNAME(bfd,pre,pos) \
981 (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
982 #define ELF_R_SYM(bfd, i) \
983 (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
984 #define ELF_R_TYPE(bfd, i) \
985 (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
986 #define ELF_R_INFO(bfd, s, t) \
987 (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
989 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
990 #define ELF_R_SYM(bfd, i) \
992 #define ELF_R_TYPE(bfd, i) \
994 #define ELF_R_INFO(bfd, s, t) \
995 (ELF32_R_INFO (s, t))
998 /* The mips16 compiler uses a couple of special sections to handle
999 floating point arguments.
1001 Section names that look like .mips16.fn.FNNAME contain stubs that
1002 copy floating point arguments from the fp regs to the gp regs and
1003 then jump to FNNAME. If any 32 bit function calls FNNAME, the
1004 call should be redirected to the stub instead. If no 32 bit
1005 function calls FNNAME, the stub should be discarded. We need to
1006 consider any reference to the function, not just a call, because
1007 if the address of the function is taken we will need the stub,
1008 since the address might be passed to a 32 bit function.
1010 Section names that look like .mips16.call.FNNAME contain stubs
1011 that copy floating point arguments from the gp regs to the fp
1012 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
1013 then any 16 bit function that calls FNNAME should be redirected
1014 to the stub instead. If FNNAME is not a 32 bit function, the
1015 stub should be discarded.
1017 .mips16.call.fp.FNNAME sections are similar, but contain stubs
1018 which call FNNAME and then copy the return value from the fp regs
1019 to the gp regs. These stubs store the return value in $18 while
1020 calling FNNAME; any function which might call one of these stubs
1021 must arrange to save $18 around the call. (This case is not
1022 needed for 32 bit functions that call 16 bit functions, because
1023 16 bit functions always return floating point values in both
1026 Note that in all cases FNNAME might be defined statically.
1027 Therefore, FNNAME is not used literally. Instead, the relocation
1028 information will indicate which symbol the section is for.
1030 We record any stubs that we find in the symbol table. */
1032 #define FN_STUB ".mips16.fn."
1033 #define CALL_STUB ".mips16.call."
1034 #define CALL_FP_STUB ".mips16.call.fp."
1036 #define FN_STUB_P(name) CONST_STRNEQ (name, FN_STUB)
1037 #define CALL_STUB_P(name) CONST_STRNEQ (name, CALL_STUB)
1038 #define CALL_FP_STUB_P(name) CONST_STRNEQ (name, CALL_FP_STUB)
1040 /* The format of the first PLT entry in an O32 executable. */
1041 static const bfd_vma mips_o32_exec_plt0_entry
[] =
1043 0x3c1c0000, /* lui $28, %hi(&GOTPLT[0]) */
1044 0x8f990000, /* lw $25, %lo(&GOTPLT[0])($28) */
1045 0x279c0000, /* addiu $28, $28, %lo(&GOTPLT[0]) */
1046 0x031cc023, /* subu $24, $24, $28 */
1047 0x03e07825, /* or t7, ra, zero */
1048 0x0018c082, /* srl $24, $24, 2 */
1049 0x0320f809, /* jalr $25 */
1050 0x2718fffe /* subu $24, $24, 2 */
1053 /* The format of the first PLT entry in an O32 executable using compact
1055 static const bfd_vma mipsr6_o32_exec_plt0_entry_compact
[] =
1057 0x3c1c0000, /* lui $28, %hi(&GOTPLT[0]) */
1058 0x8f990000, /* lw $25, %lo(&GOTPLT[0])($28) */
1059 0x279c0000, /* addiu $28, $28, %lo(&GOTPLT[0]) */
1060 0x031cc023, /* subu $24, $24, $28 */
1061 0x03e07821, /* move $15, $31 # 32-bit move (addu) */
1062 0x0018c082, /* srl $24, $24, 2 */
1063 0x2718fffe, /* subu $24, $24, 2 */
1064 0xf8190000 /* jalrc $25 */
1067 /* The format of the first PLT entry in an N32 executable. Different
1068 because gp ($28) is not available; we use t2 ($14) instead. */
1069 static const bfd_vma mips_n32_exec_plt0_entry
[] =
1071 0x3c0e0000, /* lui $14, %hi(&GOTPLT[0]) */
1072 0x8dd90000, /* lw $25, %lo(&GOTPLT[0])($14) */
1073 0x25ce0000, /* addiu $14, $14, %lo(&GOTPLT[0]) */
1074 0x030ec023, /* subu $24, $24, $14 */
1075 0x03e07825, /* or t7, ra, zero */
1076 0x0018c082, /* srl $24, $24, 2 */
1077 0x0320f809, /* jalr $25 */
1078 0x2718fffe /* subu $24, $24, 2 */
1081 /* The format of the first PLT entry in an N32 executable using compact
1082 jumps. Different because gp ($28) is not available; we use t2 ($14)
1084 static const bfd_vma mipsr6_n32_exec_plt0_entry_compact
[] =
1086 0x3c0e0000, /* lui $14, %hi(&GOTPLT[0]) */
1087 0x8dd90000, /* lw $25, %lo(&GOTPLT[0])($14) */
1088 0x25ce0000, /* addiu $14, $14, %lo(&GOTPLT[0]) */
1089 0x030ec023, /* subu $24, $24, $14 */
1090 0x03e07821, /* move $15, $31 # 32-bit move (addu) */
1091 0x0018c082, /* srl $24, $24, 2 */
1092 0x2718fffe, /* subu $24, $24, 2 */
1093 0xf8190000 /* jalrc $25 */
1096 /* The format of the first PLT entry in an N64 executable. Different
1097 from N32 because of the increased size of GOT entries. */
1098 static const bfd_vma mips_n64_exec_plt0_entry
[] =
1100 0x3c0e0000, /* lui $14, %hi(&GOTPLT[0]) */
1101 0xddd90000, /* ld $25, %lo(&GOTPLT[0])($14) */
1102 0x25ce0000, /* addiu $14, $14, %lo(&GOTPLT[0]) */
1103 0x030ec023, /* subu $24, $24, $14 */
1104 0x03e07825, /* or t7, ra, zero */
1105 0x0018c0c2, /* srl $24, $24, 3 */
1106 0x0320f809, /* jalr $25 */
1107 0x2718fffe /* subu $24, $24, 2 */
1110 /* The format of the first PLT entry in an N64 executable using compact
1111 jumps. Different from N32 because of the increased size of GOT
1113 static const bfd_vma mipsr6_n64_exec_plt0_entry_compact
[] =
1115 0x3c0e0000, /* lui $14, %hi(&GOTPLT[0]) */
1116 0xddd90000, /* ld $25, %lo(&GOTPLT[0])($14) */
1117 0x25ce0000, /* addiu $14, $14, %lo(&GOTPLT[0]) */
1118 0x030ec023, /* subu $24, $24, $14 */
1119 0x03e0782d, /* move $15, $31 # 64-bit move (daddu) */
1120 0x0018c0c2, /* srl $24, $24, 3 */
1121 0x2718fffe, /* subu $24, $24, 2 */
1122 0xf8190000 /* jalrc $25 */
1126 /* The format of the microMIPS first PLT entry in an O32 executable.
1127 We rely on v0 ($2) rather than t8 ($24) to contain the address
1128 of the GOTPLT entry handled, so this stub may only be used when
1129 all the subsequent PLT entries are microMIPS code too.
1131 The trailing NOP is for alignment and correct disassembly only. */
1132 static const bfd_vma micromips_o32_exec_plt0_entry
[] =
1134 0x7980, 0x0000, /* addiupc $3, (&GOTPLT[0]) - . */
1135 0xff23, 0x0000, /* lw $25, 0($3) */
1136 0x0535, /* subu $2, $2, $3 */
1137 0x2525, /* srl $2, $2, 2 */
1138 0x3302, 0xfffe, /* subu $24, $2, 2 */
1139 0x0dff, /* move $15, $31 */
1140 0x45f9, /* jalrs $25 */
1141 0x0f83, /* move $28, $3 */
1145 /* The format of the microMIPS first PLT entry in an O32 executable
1146 in the insn32 mode. */
1147 static const bfd_vma micromips_insn32_o32_exec_plt0_entry
[] =
1149 0x41bc, 0x0000, /* lui $28, %hi(&GOTPLT[0]) */
1150 0xff3c, 0x0000, /* lw $25, %lo(&GOTPLT[0])($28) */
1151 0x339c, 0x0000, /* addiu $28, $28, %lo(&GOTPLT[0]) */
1152 0x0398, 0xc1d0, /* subu $24, $24, $28 */
1153 0x001f, 0x7a90, /* or $15, $31, zero */
1154 0x0318, 0x1040, /* srl $24, $24, 2 */
1155 0x03f9, 0x0f3c, /* jalr $25 */
1156 0x3318, 0xfffe /* subu $24, $24, 2 */
1159 /* The format of subsequent standard PLT entries. */
1160 static const bfd_vma mips_exec_plt_entry
[] =
1162 0x3c0f0000, /* lui $15, %hi(.got.plt entry) */
1163 0x01f90000, /* l[wd] $25, %lo(.got.plt entry)($15) */
1164 0x25f80000, /* addiu $24, $15, %lo(.got.plt entry) */
1165 0x03200008 /* jr $25 */
1168 static const bfd_vma mipsr6_exec_plt_entry
[] =
1170 0x3c0f0000, /* lui $15, %hi(.got.plt entry) */
1171 0x01f90000, /* l[wd] $25, %lo(.got.plt entry)($15) */
1172 0x25f80000, /* addiu $24, $15, %lo(.got.plt entry) */
1173 0x03200009 /* jr $25 */
1176 static const bfd_vma mipsr6_exec_plt_entry_compact
[] =
1178 0x3c0f0000, /* lui $15, %hi(.got.plt entry) */
1179 0x01f90000, /* l[wd] $25, %lo(.got.plt entry)($15) */
1180 0x25f80000, /* addiu $24, $15, %lo(.got.plt entry) */
1181 0xd8190000 /* jic $25, 0 */
1184 /* The format of subsequent MIPS16 o32 PLT entries. We use v0 ($2)
1185 and v1 ($3) as temporaries because t8 ($24) and t9 ($25) are not
1186 directly addressable. */
1187 static const bfd_vma mips16_o32_exec_plt_entry
[] =
1189 0xb203, /* lw $2, 12($pc) */
1190 0x9a60, /* lw $3, 0($2) */
1191 0x651a, /* move $24, $2 */
1193 0x653b, /* move $25, $3 */
1195 0x0000, 0x0000 /* .word (.got.plt entry) */
1198 /* The format of subsequent microMIPS o32 PLT entries. We use v0 ($2)
1199 as a temporary because t8 ($24) is not addressable with ADDIUPC. */
1200 static const bfd_vma micromips_o32_exec_plt_entry
[] =
1202 0x7900, 0x0000, /* addiupc $2, (.got.plt entry) - . */
1203 0xff22, 0x0000, /* lw $25, 0($2) */
1204 0x4599, /* jr $25 */
1205 0x0f02 /* move $24, $2 */
1208 /* The format of subsequent microMIPS o32 PLT entries in the insn32 mode. */
1209 static const bfd_vma micromips_insn32_o32_exec_plt_entry
[] =
1211 0x41af, 0x0000, /* lui $15, %hi(.got.plt entry) */
1212 0xff2f, 0x0000, /* lw $25, %lo(.got.plt entry)($15) */
1213 0x0019, 0x0f3c, /* jr $25 */
1214 0x330f, 0x0000 /* addiu $24, $15, %lo(.got.plt entry) */
1217 /* The format of the first PLT entry in a VxWorks executable. */
1218 static const bfd_vma mips_vxworks_exec_plt0_entry
[] =
1220 0x3c190000, /* lui t9, %hi(_GLOBAL_OFFSET_TABLE_) */
1221 0x27390000, /* addiu t9, t9, %lo(_GLOBAL_OFFSET_TABLE_) */
1222 0x8f390008, /* lw t9, 8(t9) */
1223 0x00000000, /* nop */
1224 0x03200008, /* jr t9 */
1225 0x00000000 /* nop */
1228 /* The format of subsequent PLT entries. */
1229 static const bfd_vma mips_vxworks_exec_plt_entry
[] =
1231 0x10000000, /* b .PLT_resolver */
1232 0x24180000, /* li t8, <pltindex> */
1233 0x3c190000, /* lui t9, %hi(<.got.plt slot>) */
1234 0x27390000, /* addiu t9, t9, %lo(<.got.plt slot>) */
1235 0x8f390000, /* lw t9, 0(t9) */
1236 0x00000000, /* nop */
1237 0x03200008, /* jr t9 */
1238 0x00000000 /* nop */
1241 /* The format of the first PLT entry in a VxWorks shared object. */
1242 static const bfd_vma mips_vxworks_shared_plt0_entry
[] =
1244 0x8f990008, /* lw t9, 8(gp) */
1245 0x00000000, /* nop */
1246 0x03200008, /* jr t9 */
1247 0x00000000, /* nop */
1248 0x00000000, /* nop */
1249 0x00000000 /* nop */
1252 /* The format of subsequent PLT entries. */
1253 static const bfd_vma mips_vxworks_shared_plt_entry
[] =
1255 0x10000000, /* b .PLT_resolver */
1256 0x24180000 /* li t8, <pltindex> */
1259 /* microMIPS 32-bit opcode helper installer. */
1262 bfd_put_micromips_32 (const bfd
*abfd
, bfd_vma opcode
, bfd_byte
*ptr
)
1264 bfd_put_16 (abfd
, (opcode
>> 16) & 0xffff, ptr
);
1265 bfd_put_16 (abfd
, opcode
& 0xffff, ptr
+ 2);
1268 /* microMIPS 32-bit opcode helper retriever. */
1271 bfd_get_micromips_32 (const bfd
*abfd
, const bfd_byte
*ptr
)
1273 return (bfd_get_16 (abfd
, ptr
) << 16) | bfd_get_16 (abfd
, ptr
+ 2);
1276 /* Look up an entry in a MIPS ELF linker hash table. */
1278 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
1279 ((struct mips_elf_link_hash_entry *) \
1280 elf_link_hash_lookup (&(table)->root, (string), (create), \
1283 /* Traverse a MIPS ELF linker hash table. */
1285 #define mips_elf_link_hash_traverse(table, func, info) \
1286 (elf_link_hash_traverse \
1288 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
1291 /* Find the base offsets for thread-local storage in this object,
1292 for GD/LD and IE/LE respectively. */
1294 #define TP_OFFSET 0x7000
1295 #define DTP_OFFSET 0x8000
1298 dtprel_base (struct bfd_link_info
*info
)
1300 /* If tls_sec is NULL, we should have signalled an error already. */
1301 if (elf_hash_table (info
)->tls_sec
== NULL
)
1303 return elf_hash_table (info
)->tls_sec
->vma
+ DTP_OFFSET
;
1307 tprel_base (struct bfd_link_info
*info
)
1309 /* If tls_sec is NULL, we should have signalled an error already. */
1310 if (elf_hash_table (info
)->tls_sec
== NULL
)
1312 return elf_hash_table (info
)->tls_sec
->vma
+ TP_OFFSET
;
1315 /* Create an entry in a MIPS ELF linker hash table. */
1317 static struct bfd_hash_entry
*
1318 mips_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
1319 struct bfd_hash_table
*table
, const char *string
)
1321 struct mips_elf_link_hash_entry
*ret
=
1322 (struct mips_elf_link_hash_entry
*) entry
;
1324 /* Allocate the structure if it has not already been allocated by a
1327 ret
= bfd_hash_allocate (table
, sizeof (struct mips_elf_link_hash_entry
));
1329 return (struct bfd_hash_entry
*) ret
;
1331 /* Call the allocation method of the superclass. */
1332 ret
= ((struct mips_elf_link_hash_entry
*)
1333 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
1337 /* Set local fields. */
1338 memset (&ret
->esym
, 0, sizeof (EXTR
));
1339 /* We use -2 as a marker to indicate that the information has
1340 not been set. -1 means there is no associated ifd. */
1343 ret
->possibly_dynamic_relocs
= 0;
1344 ret
->fn_stub
= NULL
;
1345 ret
->call_stub
= NULL
;
1346 ret
->call_fp_stub
= NULL
;
1347 ret
->mipsxhash_loc
= 0;
1348 ret
->global_got_area
= GGA_NONE
;
1349 ret
->got_only_for_calls
= TRUE
;
1350 ret
->readonly_reloc
= FALSE
;
1351 ret
->has_static_relocs
= FALSE
;
1352 ret
->no_fn_stub
= FALSE
;
1353 ret
->need_fn_stub
= FALSE
;
1354 ret
->has_nonpic_branches
= FALSE
;
1355 ret
->needs_lazy_stub
= FALSE
;
1356 ret
->use_plt_entry
= FALSE
;
1359 return (struct bfd_hash_entry
*) ret
;
1362 /* Allocate MIPS ELF private object data. */
1365 _bfd_mips_elf_mkobject (bfd
*abfd
)
1367 return bfd_elf_allocate_object (abfd
, sizeof (struct mips_elf_obj_tdata
),
1372 _bfd_mips_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
1374 if (!sec
->used_by_bfd
)
1376 struct _mips_elf_section_data
*sdata
;
1377 size_t amt
= sizeof (*sdata
);
1379 sdata
= bfd_zalloc (abfd
, amt
);
1382 sec
->used_by_bfd
= sdata
;
1385 return _bfd_elf_new_section_hook (abfd
, sec
);
1388 /* Read ECOFF debugging information from a .mdebug section into a
1389 ecoff_debug_info structure. */
1392 _bfd_mips_elf_read_ecoff_info (bfd
*abfd
, asection
*section
,
1393 struct ecoff_debug_info
*debug
)
1396 const struct ecoff_debug_swap
*swap
;
1399 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
1400 memset (debug
, 0, sizeof (*debug
));
1402 ext_hdr
= bfd_malloc (swap
->external_hdr_size
);
1403 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
1406 if (! bfd_get_section_contents (abfd
, section
, ext_hdr
, 0,
1407 swap
->external_hdr_size
))
1410 symhdr
= &debug
->symbolic_header
;
1411 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
1413 /* The symbolic header contains absolute file offsets and sizes to
1415 #define READ(ptr, offset, count, size, type) \
1419 debug->ptr = NULL; \
1420 if (symhdr->count == 0) \
1422 if (_bfd_mul_overflow (size, symhdr->count, &amt)) \
1424 bfd_set_error (bfd_error_file_too_big); \
1425 goto error_return; \
1427 if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0) \
1428 goto error_return; \
1429 debug->ptr = (type) _bfd_malloc_and_read (abfd, amt, amt); \
1430 if (debug->ptr == NULL) \
1431 goto error_return; \
1434 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
1435 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, void *);
1436 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, void *);
1437 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, void *);
1438 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, void *);
1439 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
1441 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
1442 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
1443 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, void *);
1444 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, void *);
1445 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, void *);
1455 free (debug
->external_dnr
);
1456 free (debug
->external_pdr
);
1457 free (debug
->external_sym
);
1458 free (debug
->external_opt
);
1459 free (debug
->external_aux
);
1461 free (debug
->ssext
);
1462 free (debug
->external_fdr
);
1463 free (debug
->external_rfd
);
1464 free (debug
->external_ext
);
1468 /* Swap RPDR (runtime procedure table entry) for output. */
1471 ecoff_swap_rpdr_out (bfd
*abfd
, const RPDR
*in
, struct rpdr_ext
*ex
)
1473 H_PUT_S32 (abfd
, in
->adr
, ex
->p_adr
);
1474 H_PUT_32 (abfd
, in
->regmask
, ex
->p_regmask
);
1475 H_PUT_32 (abfd
, in
->regoffset
, ex
->p_regoffset
);
1476 H_PUT_32 (abfd
, in
->fregmask
, ex
->p_fregmask
);
1477 H_PUT_32 (abfd
, in
->fregoffset
, ex
->p_fregoffset
);
1478 H_PUT_32 (abfd
, in
->frameoffset
, ex
->p_frameoffset
);
1480 H_PUT_16 (abfd
, in
->framereg
, ex
->p_framereg
);
1481 H_PUT_16 (abfd
, in
->pcreg
, ex
->p_pcreg
);
1483 H_PUT_32 (abfd
, in
->irpss
, ex
->p_irpss
);
1486 /* Create a runtime procedure table from the .mdebug section. */
1489 mips_elf_create_procedure_table (void *handle
, bfd
*abfd
,
1490 struct bfd_link_info
*info
, asection
*s
,
1491 struct ecoff_debug_info
*debug
)
1493 const struct ecoff_debug_swap
*swap
;
1494 HDRR
*hdr
= &debug
->symbolic_header
;
1496 struct rpdr_ext
*erp
;
1498 struct pdr_ext
*epdr
;
1499 struct sym_ext
*esym
;
1503 bfd_size_type count
;
1504 unsigned long sindex
;
1508 const char *no_name_func
= _("static procedure (no name)");
1516 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
1518 sindex
= strlen (no_name_func
) + 1;
1519 count
= hdr
->ipdMax
;
1522 size
= swap
->external_pdr_size
;
1524 epdr
= bfd_malloc (size
* count
);
1528 if (! _bfd_ecoff_get_accumulated_pdr (handle
, (bfd_byte
*) epdr
))
1531 size
= sizeof (RPDR
);
1532 rp
= rpdr
= bfd_malloc (size
* count
);
1536 size
= sizeof (char *);
1537 sv
= bfd_malloc (size
* count
);
1541 count
= hdr
->isymMax
;
1542 size
= swap
->external_sym_size
;
1543 esym
= bfd_malloc (size
* count
);
1547 if (! _bfd_ecoff_get_accumulated_sym (handle
, (bfd_byte
*) esym
))
1550 count
= hdr
->issMax
;
1551 ss
= bfd_malloc (count
);
1554 if (! _bfd_ecoff_get_accumulated_ss (handle
, (bfd_byte
*) ss
))
1557 count
= hdr
->ipdMax
;
1558 for (i
= 0; i
< (unsigned long) count
; i
++, rp
++)
1560 (*swap
->swap_pdr_in
) (abfd
, epdr
+ i
, &pdr
);
1561 (*swap
->swap_sym_in
) (abfd
, &esym
[pdr
.isym
], &sym
);
1562 rp
->adr
= sym
.value
;
1563 rp
->regmask
= pdr
.regmask
;
1564 rp
->regoffset
= pdr
.regoffset
;
1565 rp
->fregmask
= pdr
.fregmask
;
1566 rp
->fregoffset
= pdr
.fregoffset
;
1567 rp
->frameoffset
= pdr
.frameoffset
;
1568 rp
->framereg
= pdr
.framereg
;
1569 rp
->pcreg
= pdr
.pcreg
;
1571 sv
[i
] = ss
+ sym
.iss
;
1572 sindex
+= strlen (sv
[i
]) + 1;
1576 size
= sizeof (struct rpdr_ext
) * (count
+ 2) + sindex
;
1577 size
= BFD_ALIGN (size
, 16);
1578 rtproc
= bfd_alloc (abfd
, size
);
1581 mips_elf_hash_table (info
)->procedure_count
= 0;
1585 mips_elf_hash_table (info
)->procedure_count
= count
+ 2;
1588 memset (erp
, 0, sizeof (struct rpdr_ext
));
1590 str
= (char *) rtproc
+ sizeof (struct rpdr_ext
) * (count
+ 2);
1591 strcpy (str
, no_name_func
);
1592 str
+= strlen (no_name_func
) + 1;
1593 for (i
= 0; i
< count
; i
++)
1595 ecoff_swap_rpdr_out (abfd
, rpdr
+ i
, erp
+ i
);
1596 strcpy (str
, sv
[i
]);
1597 str
+= strlen (sv
[i
]) + 1;
1599 H_PUT_S32 (abfd
, -1, (erp
+ count
)->p_adr
);
1601 /* Set the size and contents of .rtproc section. */
1603 s
->contents
= rtproc
;
1605 /* Skip this section later on (I don't think this currently
1606 matters, but someday it might). */
1607 s
->map_head
.link_order
= NULL
;
1625 /* We're going to create a stub for H. Create a symbol for the stub's
1626 value and size, to help make the disassembly easier to read. */
1629 mips_elf_create_stub_symbol (struct bfd_link_info
*info
,
1630 struct mips_elf_link_hash_entry
*h
,
1631 const char *prefix
, asection
*s
, bfd_vma value
,
1634 bfd_boolean micromips_p
= ELF_ST_IS_MICROMIPS (h
->root
.other
);
1635 struct bfd_link_hash_entry
*bh
;
1636 struct elf_link_hash_entry
*elfh
;
1643 /* Create a new symbol. */
1644 name
= concat (prefix
, h
->root
.root
.root
.string
, NULL
);
1646 res
= _bfd_generic_link_add_one_symbol (info
, s
->owner
, name
,
1647 BSF_LOCAL
, s
, value
, NULL
,
1653 /* Make it a local function. */
1654 elfh
= (struct elf_link_hash_entry
*) bh
;
1655 elfh
->type
= ELF_ST_INFO (STB_LOCAL
, STT_FUNC
);
1657 elfh
->forced_local
= 1;
1659 elfh
->other
= ELF_ST_SET_MICROMIPS (elfh
->other
);
1663 /* We're about to redefine H. Create a symbol to represent H's
1664 current value and size, to help make the disassembly easier
1668 mips_elf_create_shadow_symbol (struct bfd_link_info
*info
,
1669 struct mips_elf_link_hash_entry
*h
,
1672 struct bfd_link_hash_entry
*bh
;
1673 struct elf_link_hash_entry
*elfh
;
1679 /* Read the symbol's value. */
1680 BFD_ASSERT (h
->root
.root
.type
== bfd_link_hash_defined
1681 || h
->root
.root
.type
== bfd_link_hash_defweak
);
1682 s
= h
->root
.root
.u
.def
.section
;
1683 value
= h
->root
.root
.u
.def
.value
;
1685 /* Create a new symbol. */
1686 name
= concat (prefix
, h
->root
.root
.root
.string
, NULL
);
1688 res
= _bfd_generic_link_add_one_symbol (info
, s
->owner
, name
,
1689 BSF_LOCAL
, s
, value
, NULL
,
1695 /* Make it local and copy the other attributes from H. */
1696 elfh
= (struct elf_link_hash_entry
*) bh
;
1697 elfh
->type
= ELF_ST_INFO (STB_LOCAL
, ELF_ST_TYPE (h
->root
.type
));
1698 elfh
->other
= h
->root
.other
;
1699 elfh
->size
= h
->root
.size
;
1700 elfh
->forced_local
= 1;
1704 /* Return TRUE if relocations in SECTION can refer directly to a MIPS16
1705 function rather than to a hard-float stub. */
1708 section_allows_mips16_refs_p (asection
*section
)
1712 name
= bfd_section_name (section
);
1713 return (FN_STUB_P (name
)
1714 || CALL_STUB_P (name
)
1715 || CALL_FP_STUB_P (name
)
1716 || strcmp (name
, ".pdr") == 0);
1719 /* [RELOCS, RELEND) are the relocations against SEC, which is a MIPS16
1720 stub section of some kind. Return the R_SYMNDX of the target
1721 function, or 0 if we can't decide which function that is. */
1723 static unsigned long
1724 mips16_stub_symndx (const struct elf_backend_data
*bed
,
1725 asection
*sec ATTRIBUTE_UNUSED
,
1726 const Elf_Internal_Rela
*relocs
,
1727 const Elf_Internal_Rela
*relend
)
1729 int int_rels_per_ext_rel
= bed
->s
->int_rels_per_ext_rel
;
1730 const Elf_Internal_Rela
*rel
;
1732 /* Trust the first R_MIPS_NONE relocation, if any, but not a subsequent
1733 one in a compound relocation. */
1734 for (rel
= relocs
; rel
< relend
; rel
+= int_rels_per_ext_rel
)
1735 if (ELF_R_TYPE (sec
->owner
, rel
->r_info
) == R_MIPS_NONE
)
1736 return ELF_R_SYM (sec
->owner
, rel
->r_info
);
1738 /* Otherwise trust the first relocation, whatever its kind. This is
1739 the traditional behavior. */
1740 if (relocs
< relend
)
1741 return ELF_R_SYM (sec
->owner
, relocs
->r_info
);
1746 /* Check the mips16 stubs for a particular symbol, and see if we can
1750 mips_elf_check_mips16_stubs (struct bfd_link_info
*info
,
1751 struct mips_elf_link_hash_entry
*h
)
1753 /* Dynamic symbols must use the standard call interface, in case other
1754 objects try to call them. */
1755 if (h
->fn_stub
!= NULL
1756 && h
->root
.dynindx
!= -1)
1758 mips_elf_create_shadow_symbol (info
, h
, ".mips16.");
1759 h
->need_fn_stub
= TRUE
;
1762 if (h
->fn_stub
!= NULL
1763 && ! h
->need_fn_stub
)
1765 /* We don't need the fn_stub; the only references to this symbol
1766 are 16 bit calls. Clobber the size to 0 to prevent it from
1767 being included in the link. */
1768 h
->fn_stub
->size
= 0;
1769 h
->fn_stub
->flags
&= ~SEC_RELOC
;
1770 h
->fn_stub
->reloc_count
= 0;
1771 h
->fn_stub
->flags
|= SEC_EXCLUDE
;
1772 h
->fn_stub
->output_section
= bfd_abs_section_ptr
;
1775 if (h
->call_stub
!= NULL
1776 && ELF_ST_IS_MIPS16 (h
->root
.other
))
1778 /* We don't need the call_stub; this is a 16 bit function, so
1779 calls from other 16 bit functions are OK. Clobber the size
1780 to 0 to prevent it from being included in the link. */
1781 h
->call_stub
->size
= 0;
1782 h
->call_stub
->flags
&= ~SEC_RELOC
;
1783 h
->call_stub
->reloc_count
= 0;
1784 h
->call_stub
->flags
|= SEC_EXCLUDE
;
1785 h
->call_stub
->output_section
= bfd_abs_section_ptr
;
1788 if (h
->call_fp_stub
!= NULL
1789 && ELF_ST_IS_MIPS16 (h
->root
.other
))
1791 /* We don't need the call_stub; this is a 16 bit function, so
1792 calls from other 16 bit functions are OK. Clobber the size
1793 to 0 to prevent it from being included in the link. */
1794 h
->call_fp_stub
->size
= 0;
1795 h
->call_fp_stub
->flags
&= ~SEC_RELOC
;
1796 h
->call_fp_stub
->reloc_count
= 0;
1797 h
->call_fp_stub
->flags
|= SEC_EXCLUDE
;
1798 h
->call_fp_stub
->output_section
= bfd_abs_section_ptr
;
1802 /* Hashtable callbacks for mips_elf_la25_stubs. */
1805 mips_elf_la25_stub_hash (const void *entry_
)
1807 const struct mips_elf_la25_stub
*entry
;
1809 entry
= (struct mips_elf_la25_stub
*) entry_
;
1810 return entry
->h
->root
.root
.u
.def
.section
->id
1811 + entry
->h
->root
.root
.u
.def
.value
;
1815 mips_elf_la25_stub_eq (const void *entry1_
, const void *entry2_
)
1817 const struct mips_elf_la25_stub
*entry1
, *entry2
;
1819 entry1
= (struct mips_elf_la25_stub
*) entry1_
;
1820 entry2
= (struct mips_elf_la25_stub
*) entry2_
;
1821 return ((entry1
->h
->root
.root
.u
.def
.section
1822 == entry2
->h
->root
.root
.u
.def
.section
)
1823 && (entry1
->h
->root
.root
.u
.def
.value
1824 == entry2
->h
->root
.root
.u
.def
.value
));
1827 /* Called by the linker to set up the la25 stub-creation code. FN is
1828 the linker's implementation of add_stub_function. Return true on
1832 _bfd_mips_elf_init_stubs (struct bfd_link_info
*info
,
1833 asection
*(*fn
) (const char *, asection
*,
1836 struct mips_elf_link_hash_table
*htab
;
1838 htab
= mips_elf_hash_table (info
);
1842 htab
->add_stub_section
= fn
;
1843 htab
->la25_stubs
= htab_try_create (1, mips_elf_la25_stub_hash
,
1844 mips_elf_la25_stub_eq
, NULL
);
1845 if (htab
->la25_stubs
== NULL
)
1851 /* Return true if H is a locally-defined PIC function, in the sense
1852 that it or its fn_stub might need $25 to be valid on entry.
1853 Note that MIPS16 functions set up $gp using PC-relative instructions,
1854 so they themselves never need $25 to be valid. Only non-MIPS16
1855 entry points are of interest here. */
1858 mips_elf_local_pic_function_p (struct mips_elf_link_hash_entry
*h
)
1860 return ((h
->root
.root
.type
== bfd_link_hash_defined
1861 || h
->root
.root
.type
== bfd_link_hash_defweak
)
1862 && h
->root
.def_regular
1863 && !bfd_is_abs_section (h
->root
.root
.u
.def
.section
)
1864 && !bfd_is_und_section (h
->root
.root
.u
.def
.section
)
1865 && (!ELF_ST_IS_MIPS16 (h
->root
.other
)
1866 || (h
->fn_stub
&& h
->need_fn_stub
))
1867 && (PIC_OBJECT_P (h
->root
.root
.u
.def
.section
->owner
)
1868 || ELF_ST_IS_MIPS_PIC (h
->root
.other
)));
1871 /* Set *SEC to the input section that contains the target of STUB.
1872 Return the offset of the target from the start of that section. */
1875 mips_elf_get_la25_target (struct mips_elf_la25_stub
*stub
,
1878 if (ELF_ST_IS_MIPS16 (stub
->h
->root
.other
))
1880 BFD_ASSERT (stub
->h
->need_fn_stub
);
1881 *sec
= stub
->h
->fn_stub
;
1886 *sec
= stub
->h
->root
.root
.u
.def
.section
;
1887 return stub
->h
->root
.root
.u
.def
.value
;
1891 /* STUB describes an la25 stub that we have decided to implement
1892 by inserting an LUI/ADDIU pair before the target function.
1893 Create the section and redirect the function symbol to it. */
1896 mips_elf_add_la25_intro (struct mips_elf_la25_stub
*stub
,
1897 struct bfd_link_info
*info
)
1899 struct mips_elf_link_hash_table
*htab
;
1901 asection
*s
, *input_section
;
1904 htab
= mips_elf_hash_table (info
);
1908 /* Create a unique name for the new section. */
1909 name
= bfd_malloc (11 + sizeof (".text.stub."));
1912 sprintf (name
, ".text.stub.%d", (int) htab_elements (htab
->la25_stubs
));
1914 /* Create the section. */
1915 mips_elf_get_la25_target (stub
, &input_section
);
1916 s
= htab
->add_stub_section (name
, input_section
,
1917 input_section
->output_section
);
1921 /* Make sure that any padding goes before the stub. */
1922 align
= input_section
->alignment_power
;
1923 if (!bfd_set_section_alignment (s
, align
))
1926 s
->size
= (1 << align
) - 8;
1928 /* Create a symbol for the stub. */
1929 mips_elf_create_stub_symbol (info
, stub
->h
, ".pic.", s
, s
->size
, 8);
1930 stub
->stub_section
= s
;
1931 stub
->offset
= s
->size
;
1933 /* Allocate room for it. */
1938 /* STUB describes an la25 stub that we have decided to implement
1939 with a separate trampoline. Allocate room for it and redirect
1940 the function symbol to it. */
1943 mips_elf_add_la25_trampoline (struct mips_elf_la25_stub
*stub
,
1944 struct bfd_link_info
*info
)
1946 struct mips_elf_link_hash_table
*htab
;
1949 htab
= mips_elf_hash_table (info
);
1953 /* Create a trampoline section, if we haven't already. */
1954 s
= htab
->strampoline
;
1957 asection
*input_section
= stub
->h
->root
.root
.u
.def
.section
;
1958 s
= htab
->add_stub_section (".text", NULL
,
1959 input_section
->output_section
);
1960 if (s
== NULL
|| !bfd_set_section_alignment (s
, 4))
1962 htab
->strampoline
= s
;
1965 /* Create a symbol for the stub. */
1966 mips_elf_create_stub_symbol (info
, stub
->h
, ".pic.", s
, s
->size
, 16);
1967 stub
->stub_section
= s
;
1968 stub
->offset
= s
->size
;
1970 /* Allocate room for it. */
1975 /* H describes a symbol that needs an la25 stub. Make sure that an
1976 appropriate stub exists and point H at it. */
1979 mips_elf_add_la25_stub (struct bfd_link_info
*info
,
1980 struct mips_elf_link_hash_entry
*h
)
1982 struct mips_elf_link_hash_table
*htab
;
1983 struct mips_elf_la25_stub search
, *stub
;
1984 bfd_boolean use_trampoline_p
;
1989 /* Describe the stub we want. */
1990 search
.stub_section
= NULL
;
1994 /* See if we've already created an equivalent stub. */
1995 htab
= mips_elf_hash_table (info
);
1999 slot
= htab_find_slot (htab
->la25_stubs
, &search
, INSERT
);
2003 stub
= (struct mips_elf_la25_stub
*) *slot
;
2006 /* We can reuse the existing stub. */
2007 h
->la25_stub
= stub
;
2011 /* Create a permanent copy of ENTRY and add it to the hash table. */
2012 stub
= bfd_malloc (sizeof (search
));
2018 /* Prefer to use LUI/ADDIU stubs if the function is at the beginning
2019 of the section and if we would need no more than 2 nops. */
2020 value
= mips_elf_get_la25_target (stub
, &s
);
2021 if (ELF_ST_IS_MICROMIPS (stub
->h
->root
.other
))
2023 use_trampoline_p
= (value
!= 0 || s
->alignment_power
> 4);
2025 h
->la25_stub
= stub
;
2026 return (use_trampoline_p
2027 ? mips_elf_add_la25_trampoline (stub
, info
)
2028 : mips_elf_add_la25_intro (stub
, info
));
2031 /* A mips_elf_link_hash_traverse callback that is called before sizing
2032 sections. DATA points to a mips_htab_traverse_info structure. */
2035 mips_elf_check_symbols (struct mips_elf_link_hash_entry
*h
, void *data
)
2037 struct mips_htab_traverse_info
*hti
;
2039 hti
= (struct mips_htab_traverse_info
*) data
;
2040 if (!bfd_link_relocatable (hti
->info
))
2041 mips_elf_check_mips16_stubs (hti
->info
, h
);
2043 if (mips_elf_local_pic_function_p (h
))
2045 /* PR 12845: If H is in a section that has been garbage
2046 collected it will have its output section set to *ABS*. */
2047 if (bfd_is_abs_section (h
->root
.root
.u
.def
.section
->output_section
))
2050 /* H is a function that might need $25 to be valid on entry.
2051 If we're creating a non-PIC relocatable object, mark H as
2052 being PIC. If we're creating a non-relocatable object with
2053 non-PIC branches and jumps to H, make sure that H has an la25
2055 if (bfd_link_relocatable (hti
->info
))
2057 if (!PIC_OBJECT_P (hti
->output_bfd
))
2058 h
->root
.other
= ELF_ST_SET_MIPS_PIC (h
->root
.other
);
2060 else if (h
->has_nonpic_branches
&& !mips_elf_add_la25_stub (hti
->info
, h
))
2069 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
2070 Most mips16 instructions are 16 bits, but these instructions
2073 The format of these instructions is:
2075 +--------------+--------------------------------+
2076 | JALX | X| Imm 20:16 | Imm 25:21 |
2077 +--------------+--------------------------------+
2079 +-----------------------------------------------+
2081 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
2082 Note that the immediate value in the first word is swapped.
2084 When producing a relocatable object file, R_MIPS16_26 is
2085 handled mostly like R_MIPS_26. In particular, the addend is
2086 stored as a straight 26-bit value in a 32-bit instruction.
2087 (gas makes life simpler for itself by never adjusting a
2088 R_MIPS16_26 reloc to be against a section, so the addend is
2089 always zero). However, the 32 bit instruction is stored as 2
2090 16-bit values, rather than a single 32-bit value. In a
2091 big-endian file, the result is the same; in a little-endian
2092 file, the two 16-bit halves of the 32 bit value are swapped.
2093 This is so that a disassembler can recognize the jal
2096 When doing a final link, R_MIPS16_26 is treated as a 32 bit
2097 instruction stored as two 16-bit values. The addend A is the
2098 contents of the targ26 field. The calculation is the same as
2099 R_MIPS_26. When storing the calculated value, reorder the
2100 immediate value as shown above, and don't forget to store the
2101 value as two 16-bit values.
2103 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
2107 +--------+----------------------+
2111 +--------+----------------------+
2114 +----------+------+-------------+
2118 +----------+--------------------+
2119 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
2120 ((sub1 << 16) | sub2)).
2122 When producing a relocatable object file, the calculation is
2123 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
2124 When producing a fully linked file, the calculation is
2125 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
2126 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)
2128 The table below lists the other MIPS16 instruction relocations.
2129 Each one is calculated in the same way as the non-MIPS16 relocation
2130 given on the right, but using the extended MIPS16 layout of 16-bit
2133 R_MIPS16_GPREL R_MIPS_GPREL16
2134 R_MIPS16_GOT16 R_MIPS_GOT16
2135 R_MIPS16_CALL16 R_MIPS_CALL16
2136 R_MIPS16_HI16 R_MIPS_HI16
2137 R_MIPS16_LO16 R_MIPS_LO16
2139 A typical instruction will have a format like this:
2141 +--------------+--------------------------------+
2142 | EXTEND | Imm 10:5 | Imm 15:11 |
2143 +--------------+--------------------------------+
2144 | Major | rx | ry | Imm 4:0 |
2145 +--------------+--------------------------------+
2147 EXTEND is the five bit value 11110. Major is the instruction
2150 All we need to do here is shuffle the bits appropriately.
2151 As above, the two 16-bit halves must be swapped on a
2152 little-endian system.
2154 Finally R_MIPS16_PC16_S1 corresponds to R_MIPS_PC16, however the
2155 relocatable field is shifted by 1 rather than 2 and the same bit
2156 shuffling is done as with the relocations above. */
2158 static inline bfd_boolean
2159 mips16_reloc_p (int r_type
)
2164 case R_MIPS16_GPREL
:
2165 case R_MIPS16_GOT16
:
2166 case R_MIPS16_CALL16
:
2169 case R_MIPS16_TLS_GD
:
2170 case R_MIPS16_TLS_LDM
:
2171 case R_MIPS16_TLS_DTPREL_HI16
:
2172 case R_MIPS16_TLS_DTPREL_LO16
:
2173 case R_MIPS16_TLS_GOTTPREL
:
2174 case R_MIPS16_TLS_TPREL_HI16
:
2175 case R_MIPS16_TLS_TPREL_LO16
:
2176 case R_MIPS16_PC16_S1
:
2184 /* Check if a microMIPS reloc. */
2186 static inline bfd_boolean
2187 micromips_reloc_p (unsigned int r_type
)
2189 return r_type
>= R_MICROMIPS_min
&& r_type
< R_MICROMIPS_max
;
2192 /* Similar to MIPS16, the two 16-bit halves in microMIPS must be swapped
2193 on a little-endian system. This does not apply to R_MICROMIPS_PC7_S1
2194 and R_MICROMIPS_PC10_S1 relocs that apply to 16-bit instructions. */
2196 static inline bfd_boolean
2197 micromips_reloc_shuffle_p (unsigned int r_type
)
2199 return (micromips_reloc_p (r_type
)
2200 && r_type
!= R_MICROMIPS_PC7_S1
2201 && r_type
!= R_MICROMIPS_PC10_S1
);
2204 static inline bfd_boolean
2205 got16_reloc_p (int r_type
)
2207 return (r_type
== R_MIPS_GOT16
2208 || r_type
== R_MIPS16_GOT16
2209 || r_type
== R_MICROMIPS_GOT16
);
2212 static inline bfd_boolean
2213 call16_reloc_p (int r_type
)
2215 return (r_type
== R_MIPS_CALL16
2216 || r_type
== R_MIPS16_CALL16
2217 || r_type
== R_MICROMIPS_CALL16
);
2220 static inline bfd_boolean
2221 got_disp_reloc_p (unsigned int r_type
)
2223 return r_type
== R_MIPS_GOT_DISP
|| r_type
== R_MICROMIPS_GOT_DISP
;
2226 static inline bfd_boolean
2227 got_page_reloc_p (unsigned int r_type
)
2229 return r_type
== R_MIPS_GOT_PAGE
|| r_type
== R_MICROMIPS_GOT_PAGE
;
2232 static inline bfd_boolean
2233 got_lo16_reloc_p (unsigned int r_type
)
2235 return r_type
== R_MIPS_GOT_LO16
|| r_type
== R_MICROMIPS_GOT_LO16
;
2238 static inline bfd_boolean
2239 call_hi16_reloc_p (unsigned int r_type
)
2241 return r_type
== R_MIPS_CALL_HI16
|| r_type
== R_MICROMIPS_CALL_HI16
;
2244 static inline bfd_boolean
2245 call_lo16_reloc_p (unsigned int r_type
)
2247 return r_type
== R_MIPS_CALL_LO16
|| r_type
== R_MICROMIPS_CALL_LO16
;
2250 static inline bfd_boolean
2251 hi16_reloc_p (int r_type
)
2253 return (r_type
== R_MIPS_HI16
2254 || r_type
== R_MIPS16_HI16
2255 || r_type
== R_MICROMIPS_HI16
2256 || r_type
== R_MIPS_PCHI16
);
2259 static inline bfd_boolean
2260 lo16_reloc_p (int r_type
)
2262 return (r_type
== R_MIPS_LO16
2263 || r_type
== R_MIPS16_LO16
2264 || r_type
== R_MICROMIPS_LO16
2265 || r_type
== R_MIPS_PCLO16
);
2268 static inline bfd_boolean
2269 mips16_call_reloc_p (int r_type
)
2271 return r_type
== R_MIPS16_26
|| r_type
== R_MIPS16_CALL16
;
2274 static inline bfd_boolean
2275 jal_reloc_p (int r_type
)
2277 return (r_type
== R_MIPS_26
2278 || r_type
== R_MIPS16_26
2279 || r_type
== R_MICROMIPS_26_S1
);
2282 static inline bfd_boolean
2283 b_reloc_p (int r_type
)
2285 return (r_type
== R_MIPS_PC26_S2
2286 || r_type
== R_MIPS_PC21_S2
2287 || r_type
== R_MIPS_PC16
2288 || r_type
== R_MIPS_GNU_REL16_S2
2289 || r_type
== R_MIPS16_PC16_S1
2290 || r_type
== R_MICROMIPS_PC16_S1
2291 || r_type
== R_MICROMIPS_PC10_S1
2292 || r_type
== R_MICROMIPS_PC7_S1
);
2295 static inline bfd_boolean
2296 aligned_pcrel_reloc_p (int r_type
)
2298 return (r_type
== R_MIPS_PC18_S3
2299 || r_type
== R_MIPS_PC19_S2
);
2302 static inline bfd_boolean
2303 branch_reloc_p (int r_type
)
2305 return (r_type
== R_MIPS_26
2306 || r_type
== R_MIPS_PC26_S2
2307 || r_type
== R_MIPS_PC21_S2
2308 || r_type
== R_MIPS_PC16
2309 || r_type
== R_MIPS_GNU_REL16_S2
);
2312 static inline bfd_boolean
2313 mips16_branch_reloc_p (int r_type
)
2315 return (r_type
== R_MIPS16_26
2316 || r_type
== R_MIPS16_PC16_S1
);
2319 static inline bfd_boolean
2320 micromips_branch_reloc_p (int r_type
)
2322 return (r_type
== R_MICROMIPS_26_S1
2323 || r_type
== R_MICROMIPS_PC16_S1
2324 || r_type
== R_MICROMIPS_PC10_S1
2325 || r_type
== R_MICROMIPS_PC7_S1
);
2328 static inline bfd_boolean
2329 tls_gd_reloc_p (unsigned int r_type
)
2331 return (r_type
== R_MIPS_TLS_GD
2332 || r_type
== R_MIPS16_TLS_GD
2333 || r_type
== R_MICROMIPS_TLS_GD
);
2336 static inline bfd_boolean
2337 tls_ldm_reloc_p (unsigned int r_type
)
2339 return (r_type
== R_MIPS_TLS_LDM
2340 || r_type
== R_MIPS16_TLS_LDM
2341 || r_type
== R_MICROMIPS_TLS_LDM
);
2344 static inline bfd_boolean
2345 tls_gottprel_reloc_p (unsigned int r_type
)
2347 return (r_type
== R_MIPS_TLS_GOTTPREL
2348 || r_type
== R_MIPS16_TLS_GOTTPREL
2349 || r_type
== R_MICROMIPS_TLS_GOTTPREL
);
2353 _bfd_mips_elf_reloc_unshuffle (bfd
*abfd
, int r_type
,
2354 bfd_boolean jal_shuffle
, bfd_byte
*data
)
2356 bfd_vma first
, second
, val
;
2358 if (!mips16_reloc_p (r_type
) && !micromips_reloc_shuffle_p (r_type
))
2361 /* Pick up the first and second halfwords of the instruction. */
2362 first
= bfd_get_16 (abfd
, data
);
2363 second
= bfd_get_16 (abfd
, data
+ 2);
2364 if (micromips_reloc_p (r_type
) || (r_type
== R_MIPS16_26
&& !jal_shuffle
))
2365 val
= first
<< 16 | second
;
2366 else if (r_type
!= R_MIPS16_26
)
2367 val
= (((first
& 0xf800) << 16) | ((second
& 0xffe0) << 11)
2368 | ((first
& 0x1f) << 11) | (first
& 0x7e0) | (second
& 0x1f));
2370 val
= (((first
& 0xfc00) << 16) | ((first
& 0x3e0) << 11)
2371 | ((first
& 0x1f) << 21) | second
);
2372 bfd_put_32 (abfd
, val
, data
);
2376 _bfd_mips_elf_reloc_shuffle (bfd
*abfd
, int r_type
,
2377 bfd_boolean jal_shuffle
, bfd_byte
*data
)
2379 bfd_vma first
, second
, val
;
2381 if (!mips16_reloc_p (r_type
) && !micromips_reloc_shuffle_p (r_type
))
2384 val
= bfd_get_32 (abfd
, data
);
2385 if (micromips_reloc_p (r_type
) || (r_type
== R_MIPS16_26
&& !jal_shuffle
))
2387 second
= val
& 0xffff;
2390 else if (r_type
!= R_MIPS16_26
)
2392 second
= ((val
>> 11) & 0xffe0) | (val
& 0x1f);
2393 first
= ((val
>> 16) & 0xf800) | ((val
>> 11) & 0x1f) | (val
& 0x7e0);
2397 second
= val
& 0xffff;
2398 first
= ((val
>> 16) & 0xfc00) | ((val
>> 11) & 0x3e0)
2399 | ((val
>> 21) & 0x1f);
2401 bfd_put_16 (abfd
, second
, data
+ 2);
2402 bfd_put_16 (abfd
, first
, data
);
2405 bfd_reloc_status_type
2406 _bfd_mips_elf_gprel16_with_gp (bfd
*abfd
, asymbol
*symbol
,
2407 arelent
*reloc_entry
, asection
*input_section
,
2408 bfd_boolean relocatable
, void *data
, bfd_vma gp
)
2412 bfd_reloc_status_type status
;
2414 if (bfd_is_com_section (symbol
->section
))
2417 relocation
= symbol
->value
;
2419 relocation
+= symbol
->section
->output_section
->vma
;
2420 relocation
+= symbol
->section
->output_offset
;
2422 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
2423 return bfd_reloc_outofrange
;
2425 /* Set val to the offset into the section or symbol. */
2426 val
= reloc_entry
->addend
;
2428 _bfd_mips_elf_sign_extend (val
, 16);
2430 /* Adjust val for the final section location and GP value. If we
2431 are producing relocatable output, we don't want to do this for
2432 an external symbol. */
2434 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
2435 val
+= relocation
- gp
;
2437 if (reloc_entry
->howto
->partial_inplace
)
2439 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
2441 + reloc_entry
->address
);
2442 if (status
!= bfd_reloc_ok
)
2446 reloc_entry
->addend
= val
;
2449 reloc_entry
->address
+= input_section
->output_offset
;
2451 return bfd_reloc_ok
;
2454 /* Used to store a REL high-part relocation such as R_MIPS_HI16 or
2455 R_MIPS_GOT16. REL is the relocation, INPUT_SECTION is the section
2456 that contains the relocation field and DATA points to the start of
2461 struct mips_hi16
*next
;
2463 asection
*input_section
;
2467 /* FIXME: This should not be a static variable. */
2469 static struct mips_hi16
*mips_hi16_list
;
2471 /* A howto special_function for REL *HI16 relocations. We can only
2472 calculate the correct value once we've seen the partnering
2473 *LO16 relocation, so just save the information for later.
2475 The ABI requires that the *LO16 immediately follow the *HI16.
2476 However, as a GNU extension, we permit an arbitrary number of
2477 *HI16s to be associated with a single *LO16. This significantly
2478 simplies the relocation handling in gcc. */
2480 bfd_reloc_status_type
2481 _bfd_mips_elf_hi16_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
2482 asymbol
*symbol ATTRIBUTE_UNUSED
, void *data
,
2483 asection
*input_section
, bfd
*output_bfd
,
2484 char **error_message ATTRIBUTE_UNUSED
)
2486 struct mips_hi16
*n
;
2488 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
2489 return bfd_reloc_outofrange
;
2491 n
= bfd_malloc (sizeof *n
);
2493 return bfd_reloc_outofrange
;
2495 n
->next
= mips_hi16_list
;
2497 n
->input_section
= input_section
;
2498 n
->rel
= *reloc_entry
;
2501 if (output_bfd
!= NULL
)
2502 reloc_entry
->address
+= input_section
->output_offset
;
2504 return bfd_reloc_ok
;
2507 /* A howto special_function for REL R_MIPS*_GOT16 relocations. This is just
2508 like any other 16-bit relocation when applied to global symbols, but is
2509 treated in the same as R_MIPS_HI16 when applied to local symbols. */
2511 bfd_reloc_status_type
2512 _bfd_mips_elf_got16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
2513 void *data
, asection
*input_section
,
2514 bfd
*output_bfd
, char **error_message
)
2516 if ((symbol
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
2517 || bfd_is_und_section (bfd_asymbol_section (symbol
))
2518 || bfd_is_com_section (bfd_asymbol_section (symbol
)))
2519 /* The relocation is against a global symbol. */
2520 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
2521 input_section
, output_bfd
,
2524 return _bfd_mips_elf_hi16_reloc (abfd
, reloc_entry
, symbol
, data
,
2525 input_section
, output_bfd
, error_message
);
2528 /* A howto special_function for REL *LO16 relocations. The *LO16 itself
2529 is a straightforward 16 bit inplace relocation, but we must deal with
2530 any partnering high-part relocations as well. */
2532 bfd_reloc_status_type
2533 _bfd_mips_elf_lo16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
2534 void *data
, asection
*input_section
,
2535 bfd
*output_bfd
, char **error_message
)
2538 bfd_byte
*location
= (bfd_byte
*) data
+ reloc_entry
->address
;
2540 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
2541 return bfd_reloc_outofrange
;
2543 _bfd_mips_elf_reloc_unshuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
2545 vallo
= bfd_get_32 (abfd
, location
);
2546 _bfd_mips_elf_reloc_shuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
2549 while (mips_hi16_list
!= NULL
)
2551 bfd_reloc_status_type ret
;
2552 struct mips_hi16
*hi
;
2554 hi
= mips_hi16_list
;
2556 /* R_MIPS*_GOT16 relocations are something of a special case. We
2557 want to install the addend in the same way as for a R_MIPS*_HI16
2558 relocation (with a rightshift of 16). However, since GOT16
2559 relocations can also be used with global symbols, their howto
2560 has a rightshift of 0. */
2561 if (hi
->rel
.howto
->type
== R_MIPS_GOT16
)
2562 hi
->rel
.howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, R_MIPS_HI16
, FALSE
);
2563 else if (hi
->rel
.howto
->type
== R_MIPS16_GOT16
)
2564 hi
->rel
.howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, R_MIPS16_HI16
, FALSE
);
2565 else if (hi
->rel
.howto
->type
== R_MICROMIPS_GOT16
)
2566 hi
->rel
.howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, R_MICROMIPS_HI16
, FALSE
);
2568 /* VALLO is a signed 16-bit number. Bias it by 0x8000 so that any
2569 carry or borrow will induce a change of +1 or -1 in the high part. */
2570 hi
->rel
.addend
+= (vallo
+ 0x8000) & 0xffff;
2572 ret
= _bfd_mips_elf_generic_reloc (abfd
, &hi
->rel
, symbol
, hi
->data
,
2573 hi
->input_section
, output_bfd
,
2575 if (ret
!= bfd_reloc_ok
)
2578 mips_hi16_list
= hi
->next
;
2582 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
2583 input_section
, output_bfd
,
2587 /* A generic howto special_function. This calculates and installs the
2588 relocation itself, thus avoiding the oft-discussed problems in
2589 bfd_perform_relocation and bfd_install_relocation. */
2591 bfd_reloc_status_type
2592 _bfd_mips_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
2593 asymbol
*symbol
, void *data ATTRIBUTE_UNUSED
,
2594 asection
*input_section
, bfd
*output_bfd
,
2595 char **error_message ATTRIBUTE_UNUSED
)
2598 bfd_reloc_status_type status
;
2599 bfd_boolean relocatable
;
2601 relocatable
= (output_bfd
!= NULL
);
2603 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
2604 return bfd_reloc_outofrange
;
2606 /* Build up the field adjustment in VAL. */
2608 if (!relocatable
|| (symbol
->flags
& BSF_SECTION_SYM
) != 0)
2610 /* Either we're calculating the final field value or we have a
2611 relocation against a section symbol. Add in the section's
2612 offset or address. */
2613 val
+= symbol
->section
->output_section
->vma
;
2614 val
+= symbol
->section
->output_offset
;
2619 /* We're calculating the final field value. Add in the symbol's value
2620 and, if pc-relative, subtract the address of the field itself. */
2621 val
+= symbol
->value
;
2622 if (reloc_entry
->howto
->pc_relative
)
2624 val
-= input_section
->output_section
->vma
;
2625 val
-= input_section
->output_offset
;
2626 val
-= reloc_entry
->address
;
2630 /* VAL is now the final adjustment. If we're keeping this relocation
2631 in the output file, and if the relocation uses a separate addend,
2632 we just need to add VAL to that addend. Otherwise we need to add
2633 VAL to the relocation field itself. */
2634 if (relocatable
&& !reloc_entry
->howto
->partial_inplace
)
2635 reloc_entry
->addend
+= val
;
2638 bfd_byte
*location
= (bfd_byte
*) data
+ reloc_entry
->address
;
2640 /* Add in the separate addend, if any. */
2641 val
+= reloc_entry
->addend
;
2643 /* Add VAL to the relocation field. */
2644 _bfd_mips_elf_reloc_unshuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
2646 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
2648 _bfd_mips_elf_reloc_shuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
2651 if (status
!= bfd_reloc_ok
)
2656 reloc_entry
->address
+= input_section
->output_offset
;
2658 return bfd_reloc_ok
;
2661 /* Swap an entry in a .gptab section. Note that these routines rely
2662 on the equivalence of the two elements of the union. */
2665 bfd_mips_elf32_swap_gptab_in (bfd
*abfd
, const Elf32_External_gptab
*ex
,
2668 in
->gt_entry
.gt_g_value
= H_GET_32 (abfd
, ex
->gt_entry
.gt_g_value
);
2669 in
->gt_entry
.gt_bytes
= H_GET_32 (abfd
, ex
->gt_entry
.gt_bytes
);
2673 bfd_mips_elf32_swap_gptab_out (bfd
*abfd
, const Elf32_gptab
*in
,
2674 Elf32_External_gptab
*ex
)
2676 H_PUT_32 (abfd
, in
->gt_entry
.gt_g_value
, ex
->gt_entry
.gt_g_value
);
2677 H_PUT_32 (abfd
, in
->gt_entry
.gt_bytes
, ex
->gt_entry
.gt_bytes
);
2681 bfd_elf32_swap_compact_rel_out (bfd
*abfd
, const Elf32_compact_rel
*in
,
2682 Elf32_External_compact_rel
*ex
)
2684 H_PUT_32 (abfd
, in
->id1
, ex
->id1
);
2685 H_PUT_32 (abfd
, in
->num
, ex
->num
);
2686 H_PUT_32 (abfd
, in
->id2
, ex
->id2
);
2687 H_PUT_32 (abfd
, in
->offset
, ex
->offset
);
2688 H_PUT_32 (abfd
, in
->reserved0
, ex
->reserved0
);
2689 H_PUT_32 (abfd
, in
->reserved1
, ex
->reserved1
);
2693 bfd_elf32_swap_crinfo_out (bfd
*abfd
, const Elf32_crinfo
*in
,
2694 Elf32_External_crinfo
*ex
)
2698 l
= (((in
->ctype
& CRINFO_CTYPE
) << CRINFO_CTYPE_SH
)
2699 | ((in
->rtype
& CRINFO_RTYPE
) << CRINFO_RTYPE_SH
)
2700 | ((in
->dist2to
& CRINFO_DIST2TO
) << CRINFO_DIST2TO_SH
)
2701 | ((in
->relvaddr
& CRINFO_RELVADDR
) << CRINFO_RELVADDR_SH
));
2702 H_PUT_32 (abfd
, l
, ex
->info
);
2703 H_PUT_32 (abfd
, in
->konst
, ex
->konst
);
2704 H_PUT_32 (abfd
, in
->vaddr
, ex
->vaddr
);
2707 /* A .reginfo section holds a single Elf32_RegInfo structure. These
2708 routines swap this structure in and out. They are used outside of
2709 BFD, so they are globally visible. */
2712 bfd_mips_elf32_swap_reginfo_in (bfd
*abfd
, const Elf32_External_RegInfo
*ex
,
2715 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
2716 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
2717 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
2718 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
2719 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
2720 in
->ri_gp_value
= H_GET_32 (abfd
, ex
->ri_gp_value
);
2724 bfd_mips_elf32_swap_reginfo_out (bfd
*abfd
, const Elf32_RegInfo
*in
,
2725 Elf32_External_RegInfo
*ex
)
2727 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
2728 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
2729 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
2730 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
2731 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
2732 H_PUT_32 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
2735 /* In the 64 bit ABI, the .MIPS.options section holds register
2736 information in an Elf64_Reginfo structure. These routines swap
2737 them in and out. They are globally visible because they are used
2738 outside of BFD. These routines are here so that gas can call them
2739 without worrying about whether the 64 bit ABI has been included. */
2742 bfd_mips_elf64_swap_reginfo_in (bfd
*abfd
, const Elf64_External_RegInfo
*ex
,
2743 Elf64_Internal_RegInfo
*in
)
2745 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
2746 in
->ri_pad
= H_GET_32 (abfd
, ex
->ri_pad
);
2747 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
2748 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
2749 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
2750 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
2751 in
->ri_gp_value
= H_GET_64 (abfd
, ex
->ri_gp_value
);
2755 bfd_mips_elf64_swap_reginfo_out (bfd
*abfd
, const Elf64_Internal_RegInfo
*in
,
2756 Elf64_External_RegInfo
*ex
)
2758 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
2759 H_PUT_32 (abfd
, in
->ri_pad
, ex
->ri_pad
);
2760 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
2761 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
2762 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
2763 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
2764 H_PUT_64 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
2767 /* Swap in an options header. */
2770 bfd_mips_elf_swap_options_in (bfd
*abfd
, const Elf_External_Options
*ex
,
2771 Elf_Internal_Options
*in
)
2773 in
->kind
= H_GET_8 (abfd
, ex
->kind
);
2774 in
->size
= H_GET_8 (abfd
, ex
->size
);
2775 in
->section
= H_GET_16 (abfd
, ex
->section
);
2776 in
->info
= H_GET_32 (abfd
, ex
->info
);
2779 /* Swap out an options header. */
2782 bfd_mips_elf_swap_options_out (bfd
*abfd
, const Elf_Internal_Options
*in
,
2783 Elf_External_Options
*ex
)
2785 H_PUT_8 (abfd
, in
->kind
, ex
->kind
);
2786 H_PUT_8 (abfd
, in
->size
, ex
->size
);
2787 H_PUT_16 (abfd
, in
->section
, ex
->section
);
2788 H_PUT_32 (abfd
, in
->info
, ex
->info
);
2791 /* Swap in an abiflags structure. */
2794 bfd_mips_elf_swap_abiflags_v0_in (bfd
*abfd
,
2795 const Elf_External_ABIFlags_v0
*ex
,
2796 Elf_Internal_ABIFlags_v0
*in
)
2798 in
->version
= H_GET_16 (abfd
, ex
->version
);
2799 in
->isa_level
= H_GET_8 (abfd
, ex
->isa_level
);
2800 in
->isa_rev
= H_GET_8 (abfd
, ex
->isa_rev
);
2801 in
->gpr_size
= H_GET_8 (abfd
, ex
->gpr_size
);
2802 in
->cpr1_size
= H_GET_8 (abfd
, ex
->cpr1_size
);
2803 in
->cpr2_size
= H_GET_8 (abfd
, ex
->cpr2_size
);
2804 in
->fp_abi
= H_GET_8 (abfd
, ex
->fp_abi
);
2805 in
->isa_ext
= H_GET_32 (abfd
, ex
->isa_ext
);
2806 in
->ases
= H_GET_32 (abfd
, ex
->ases
);
2807 in
->flags1
= H_GET_32 (abfd
, ex
->flags1
);
2808 in
->flags2
= H_GET_32 (abfd
, ex
->flags2
);
2811 /* Swap out an abiflags structure. */
2814 bfd_mips_elf_swap_abiflags_v0_out (bfd
*abfd
,
2815 const Elf_Internal_ABIFlags_v0
*in
,
2816 Elf_External_ABIFlags_v0
*ex
)
2818 H_PUT_16 (abfd
, in
->version
, ex
->version
);
2819 H_PUT_8 (abfd
, in
->isa_level
, ex
->isa_level
);
2820 H_PUT_8 (abfd
, in
->isa_rev
, ex
->isa_rev
);
2821 H_PUT_8 (abfd
, in
->gpr_size
, ex
->gpr_size
);
2822 H_PUT_8 (abfd
, in
->cpr1_size
, ex
->cpr1_size
);
2823 H_PUT_8 (abfd
, in
->cpr2_size
, ex
->cpr2_size
);
2824 H_PUT_8 (abfd
, in
->fp_abi
, ex
->fp_abi
);
2825 H_PUT_32 (abfd
, in
->isa_ext
, ex
->isa_ext
);
2826 H_PUT_32 (abfd
, in
->ases
, ex
->ases
);
2827 H_PUT_32 (abfd
, in
->flags1
, ex
->flags1
);
2828 H_PUT_32 (abfd
, in
->flags2
, ex
->flags2
);
2831 /* This function is called via qsort() to sort the dynamic relocation
2832 entries by increasing r_symndx value. */
2835 sort_dynamic_relocs (const void *arg1
, const void *arg2
)
2837 Elf_Internal_Rela int_reloc1
;
2838 Elf_Internal_Rela int_reloc2
;
2841 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg1
, &int_reloc1
);
2842 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg2
, &int_reloc2
);
2844 diff
= ELF32_R_SYM (int_reloc1
.r_info
) - ELF32_R_SYM (int_reloc2
.r_info
);
2848 if (int_reloc1
.r_offset
< int_reloc2
.r_offset
)
2850 if (int_reloc1
.r_offset
> int_reloc2
.r_offset
)
2855 /* Like sort_dynamic_relocs, but used for elf64 relocations. */
2858 sort_dynamic_relocs_64 (const void *arg1 ATTRIBUTE_UNUSED
,
2859 const void *arg2 ATTRIBUTE_UNUSED
)
2862 Elf_Internal_Rela int_reloc1
[3];
2863 Elf_Internal_Rela int_reloc2
[3];
2865 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
2866 (reldyn_sorting_bfd
, arg1
, int_reloc1
);
2867 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
2868 (reldyn_sorting_bfd
, arg2
, int_reloc2
);
2870 if (ELF64_R_SYM (int_reloc1
[0].r_info
) < ELF64_R_SYM (int_reloc2
[0].r_info
))
2872 if (ELF64_R_SYM (int_reloc1
[0].r_info
) > ELF64_R_SYM (int_reloc2
[0].r_info
))
2875 if (int_reloc1
[0].r_offset
< int_reloc2
[0].r_offset
)
2877 if (int_reloc1
[0].r_offset
> int_reloc2
[0].r_offset
)
2886 /* This routine is used to write out ECOFF debugging external symbol
2887 information. It is called via mips_elf_link_hash_traverse. The
2888 ECOFF external symbol information must match the ELF external
2889 symbol information. Unfortunately, at this point we don't know
2890 whether a symbol is required by reloc information, so the two
2891 tables may wind up being different. We must sort out the external
2892 symbol information before we can set the final size of the .mdebug
2893 section, and we must set the size of the .mdebug section before we
2894 can relocate any sections, and we can't know which symbols are
2895 required by relocation until we relocate the sections.
2896 Fortunately, it is relatively unlikely that any symbol will be
2897 stripped but required by a reloc. In particular, it can not happen
2898 when generating a final executable. */
2901 mips_elf_output_extsym (struct mips_elf_link_hash_entry
*h
, void *data
)
2903 struct extsym_info
*einfo
= data
;
2905 asection
*sec
, *output_section
;
2907 if (h
->root
.indx
== -2)
2909 else if ((h
->root
.def_dynamic
2910 || h
->root
.ref_dynamic
2911 || h
->root
.type
== bfd_link_hash_new
)
2912 && !h
->root
.def_regular
2913 && !h
->root
.ref_regular
)
2915 else if (einfo
->info
->strip
== strip_all
2916 || (einfo
->info
->strip
== strip_some
2917 && bfd_hash_lookup (einfo
->info
->keep_hash
,
2918 h
->root
.root
.root
.string
,
2919 FALSE
, FALSE
) == NULL
))
2927 if (h
->esym
.ifd
== -2)
2930 h
->esym
.cobol_main
= 0;
2931 h
->esym
.weakext
= 0;
2932 h
->esym
.reserved
= 0;
2933 h
->esym
.ifd
= ifdNil
;
2934 h
->esym
.asym
.value
= 0;
2935 h
->esym
.asym
.st
= stGlobal
;
2937 if (h
->root
.root
.type
== bfd_link_hash_undefined
2938 || h
->root
.root
.type
== bfd_link_hash_undefweak
)
2942 /* Use undefined class. Also, set class and type for some
2944 name
= h
->root
.root
.root
.string
;
2945 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
2946 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
2948 h
->esym
.asym
.sc
= scData
;
2949 h
->esym
.asym
.st
= stLabel
;
2950 h
->esym
.asym
.value
= 0;
2952 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
2954 h
->esym
.asym
.sc
= scAbs
;
2955 h
->esym
.asym
.st
= stLabel
;
2956 h
->esym
.asym
.value
=
2957 mips_elf_hash_table (einfo
->info
)->procedure_count
;
2960 h
->esym
.asym
.sc
= scUndefined
;
2962 else if (h
->root
.root
.type
!= bfd_link_hash_defined
2963 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
2964 h
->esym
.asym
.sc
= scAbs
;
2969 sec
= h
->root
.root
.u
.def
.section
;
2970 output_section
= sec
->output_section
;
2972 /* When making a shared library and symbol h is the one from
2973 the another shared library, OUTPUT_SECTION may be null. */
2974 if (output_section
== NULL
)
2975 h
->esym
.asym
.sc
= scUndefined
;
2978 name
= bfd_section_name (output_section
);
2980 if (strcmp (name
, ".text") == 0)
2981 h
->esym
.asym
.sc
= scText
;
2982 else if (strcmp (name
, ".data") == 0)
2983 h
->esym
.asym
.sc
= scData
;
2984 else if (strcmp (name
, ".sdata") == 0)
2985 h
->esym
.asym
.sc
= scSData
;
2986 else if (strcmp (name
, ".rodata") == 0
2987 || strcmp (name
, ".rdata") == 0)
2988 h
->esym
.asym
.sc
= scRData
;
2989 else if (strcmp (name
, ".bss") == 0)
2990 h
->esym
.asym
.sc
= scBss
;
2991 else if (strcmp (name
, ".sbss") == 0)
2992 h
->esym
.asym
.sc
= scSBss
;
2993 else if (strcmp (name
, ".init") == 0)
2994 h
->esym
.asym
.sc
= scInit
;
2995 else if (strcmp (name
, ".fini") == 0)
2996 h
->esym
.asym
.sc
= scFini
;
2998 h
->esym
.asym
.sc
= scAbs
;
3002 h
->esym
.asym
.reserved
= 0;
3003 h
->esym
.asym
.index
= indexNil
;
3006 if (h
->root
.root
.type
== bfd_link_hash_common
)
3007 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
3008 else if (h
->root
.root
.type
== bfd_link_hash_defined
3009 || h
->root
.root
.type
== bfd_link_hash_defweak
)
3011 if (h
->esym
.asym
.sc
== scCommon
)
3012 h
->esym
.asym
.sc
= scBss
;
3013 else if (h
->esym
.asym
.sc
== scSCommon
)
3014 h
->esym
.asym
.sc
= scSBss
;
3016 sec
= h
->root
.root
.u
.def
.section
;
3017 output_section
= sec
->output_section
;
3018 if (output_section
!= NULL
)
3019 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
3020 + sec
->output_offset
3021 + output_section
->vma
);
3023 h
->esym
.asym
.value
= 0;
3027 struct mips_elf_link_hash_entry
*hd
= h
;
3029 while (hd
->root
.root
.type
== bfd_link_hash_indirect
)
3030 hd
= (struct mips_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
3032 if (hd
->needs_lazy_stub
)
3034 BFD_ASSERT (hd
->root
.plt
.plist
!= NULL
);
3035 BFD_ASSERT (hd
->root
.plt
.plist
->stub_offset
!= MINUS_ONE
);
3036 /* Set type and value for a symbol with a function stub. */
3037 h
->esym
.asym
.st
= stProc
;
3038 sec
= hd
->root
.root
.u
.def
.section
;
3040 h
->esym
.asym
.value
= 0;
3043 output_section
= sec
->output_section
;
3044 if (output_section
!= NULL
)
3045 h
->esym
.asym
.value
= (hd
->root
.plt
.plist
->stub_offset
3046 + sec
->output_offset
3047 + output_section
->vma
);
3049 h
->esym
.asym
.value
= 0;
3054 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
3055 h
->root
.root
.root
.string
,
3058 einfo
->failed
= TRUE
;
3065 /* A comparison routine used to sort .gptab entries. */
3068 gptab_compare (const void *p1
, const void *p2
)
3070 const Elf32_gptab
*a1
= p1
;
3071 const Elf32_gptab
*a2
= p2
;
3073 return a1
->gt_entry
.gt_g_value
- a2
->gt_entry
.gt_g_value
;
3076 /* Functions to manage the got entry hash table. */
3078 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
3081 static INLINE hashval_t
3082 mips_elf_hash_bfd_vma (bfd_vma addr
)
3085 return addr
+ (addr
>> 32);
3092 mips_elf_got_entry_hash (const void *entry_
)
3094 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
3096 return (entry
->symndx
3097 + ((entry
->tls_type
== GOT_TLS_LDM
) << 18)
3098 + (entry
->tls_type
== GOT_TLS_LDM
? 0
3099 : !entry
->abfd
? mips_elf_hash_bfd_vma (entry
->d
.address
)
3100 : entry
->symndx
>= 0 ? (entry
->abfd
->id
3101 + mips_elf_hash_bfd_vma (entry
->d
.addend
))
3102 : entry
->d
.h
->root
.root
.root
.hash
));
3106 mips_elf_got_entry_eq (const void *entry1
, const void *entry2
)
3108 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
3109 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
3111 return (e1
->symndx
== e2
->symndx
3112 && e1
->tls_type
== e2
->tls_type
3113 && (e1
->tls_type
== GOT_TLS_LDM
? TRUE
3114 : !e1
->abfd
? !e2
->abfd
&& e1
->d
.address
== e2
->d
.address
3115 : e1
->symndx
>= 0 ? (e1
->abfd
== e2
->abfd
3116 && e1
->d
.addend
== e2
->d
.addend
)
3117 : e2
->abfd
&& e1
->d
.h
== e2
->d
.h
));
3121 mips_got_page_ref_hash (const void *ref_
)
3123 const struct mips_got_page_ref
*ref
;
3125 ref
= (const struct mips_got_page_ref
*) ref_
;
3126 return ((ref
->symndx
>= 0
3127 ? (hashval_t
) (ref
->u
.abfd
->id
+ ref
->symndx
)
3128 : ref
->u
.h
->root
.root
.root
.hash
)
3129 + mips_elf_hash_bfd_vma (ref
->addend
));
3133 mips_got_page_ref_eq (const void *ref1_
, const void *ref2_
)
3135 const struct mips_got_page_ref
*ref1
, *ref2
;
3137 ref1
= (const struct mips_got_page_ref
*) ref1_
;
3138 ref2
= (const struct mips_got_page_ref
*) ref2_
;
3139 return (ref1
->symndx
== ref2
->symndx
3140 && (ref1
->symndx
< 0
3141 ? ref1
->u
.h
== ref2
->u
.h
3142 : ref1
->u
.abfd
== ref2
->u
.abfd
)
3143 && ref1
->addend
== ref2
->addend
);
3147 mips_got_page_entry_hash (const void *entry_
)
3149 const struct mips_got_page_entry
*entry
;
3151 entry
= (const struct mips_got_page_entry
*) entry_
;
3152 return entry
->sec
->id
;
3156 mips_got_page_entry_eq (const void *entry1_
, const void *entry2_
)
3158 const struct mips_got_page_entry
*entry1
, *entry2
;
3160 entry1
= (const struct mips_got_page_entry
*) entry1_
;
3161 entry2
= (const struct mips_got_page_entry
*) entry2_
;
3162 return entry1
->sec
== entry2
->sec
;
3165 /* Create and return a new mips_got_info structure. */
3167 static struct mips_got_info
*
3168 mips_elf_create_got_info (bfd
*abfd
)
3170 struct mips_got_info
*g
;
3172 g
= bfd_zalloc (abfd
, sizeof (struct mips_got_info
));
3176 g
->got_entries
= htab_try_create (1, mips_elf_got_entry_hash
,
3177 mips_elf_got_entry_eq
, NULL
);
3178 if (g
->got_entries
== NULL
)
3181 g
->got_page_refs
= htab_try_create (1, mips_got_page_ref_hash
,
3182 mips_got_page_ref_eq
, NULL
);
3183 if (g
->got_page_refs
== NULL
)
3189 /* Return the GOT info for input bfd ABFD, trying to create a new one if
3190 CREATE_P and if ABFD doesn't already have a GOT. */
3192 static struct mips_got_info
*
3193 mips_elf_bfd_got (bfd
*abfd
, bfd_boolean create_p
)
3195 struct mips_elf_obj_tdata
*tdata
;
3197 if (!is_mips_elf (abfd
))
3200 tdata
= mips_elf_tdata (abfd
);
3201 if (!tdata
->got
&& create_p
)
3202 tdata
->got
= mips_elf_create_got_info (abfd
);
3206 /* Record that ABFD should use output GOT G. */
3209 mips_elf_replace_bfd_got (bfd
*abfd
, struct mips_got_info
*g
)
3211 struct mips_elf_obj_tdata
*tdata
;
3213 BFD_ASSERT (is_mips_elf (abfd
));
3214 tdata
= mips_elf_tdata (abfd
);
3217 /* The GOT structure itself and the hash table entries are
3218 allocated to a bfd, but the hash tables aren't. */
3219 htab_delete (tdata
->got
->got_entries
);
3220 htab_delete (tdata
->got
->got_page_refs
);
3221 if (tdata
->got
->got_page_entries
)
3222 htab_delete (tdata
->got
->got_page_entries
);
3227 /* Return the dynamic relocation section. If it doesn't exist, try to
3228 create a new it if CREATE_P, otherwise return NULL. Also return NULL
3229 if creation fails. */
3232 mips_elf_rel_dyn_section (struct bfd_link_info
*info
, bfd_boolean create_p
)
3238 dname
= MIPS_ELF_REL_DYN_NAME (info
);
3239 dynobj
= elf_hash_table (info
)->dynobj
;
3240 sreloc
= bfd_get_linker_section (dynobj
, dname
);
3241 if (sreloc
== NULL
&& create_p
)
3243 sreloc
= bfd_make_section_anyway_with_flags (dynobj
, dname
,
3248 | SEC_LINKER_CREATED
3251 || !bfd_set_section_alignment (sreloc
,
3252 MIPS_ELF_LOG_FILE_ALIGN (dynobj
)))
3258 /* Return the GOT_TLS_* type required by relocation type R_TYPE. */
3261 mips_elf_reloc_tls_type (unsigned int r_type
)
3263 if (tls_gd_reloc_p (r_type
))
3266 if (tls_ldm_reloc_p (r_type
))
3269 if (tls_gottprel_reloc_p (r_type
))
3272 return GOT_TLS_NONE
;
3275 /* Return the number of GOT slots needed for GOT TLS type TYPE. */
3278 mips_tls_got_entries (unsigned int type
)
3295 /* Count the number of relocations needed for a TLS GOT entry, with
3296 access types from TLS_TYPE, and symbol H (or a local symbol if H
3300 mips_tls_got_relocs (struct bfd_link_info
*info
, unsigned char tls_type
,
3301 struct elf_link_hash_entry
*h
)
3304 bfd_boolean need_relocs
= FALSE
;
3305 bfd_boolean dyn
= elf_hash_table (info
)->dynamic_sections_created
;
3309 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
3310 && (bfd_link_dll (info
) || !SYMBOL_REFERENCES_LOCAL (info
, h
)))
3313 if ((bfd_link_dll (info
) || indx
!= 0)
3315 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3316 || h
->root
.type
!= bfd_link_hash_undefweak
))
3325 return indx
!= 0 ? 2 : 1;
3331 return bfd_link_dll (info
) ? 1 : 0;
3338 /* Add the number of GOT entries and TLS relocations required by ENTRY
3342 mips_elf_count_got_entry (struct bfd_link_info
*info
,
3343 struct mips_got_info
*g
,
3344 struct mips_got_entry
*entry
)
3346 if (entry
->tls_type
)
3348 g
->tls_gotno
+= mips_tls_got_entries (entry
->tls_type
);
3349 g
->relocs
+= mips_tls_got_relocs (info
, entry
->tls_type
,
3351 ? &entry
->d
.h
->root
: NULL
);
3353 else if (entry
->symndx
>= 0 || entry
->d
.h
->global_got_area
== GGA_NONE
)
3354 g
->local_gotno
+= 1;
3356 g
->global_gotno
+= 1;
3359 /* Output a simple dynamic relocation into SRELOC. */
3362 mips_elf_output_dynamic_relocation (bfd
*output_bfd
,
3364 unsigned long reloc_index
,
3369 Elf_Internal_Rela rel
[3];
3371 memset (rel
, 0, sizeof (rel
));
3373 rel
[0].r_info
= ELF_R_INFO (output_bfd
, indx
, r_type
);
3374 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
3376 if (ABI_64_P (output_bfd
))
3378 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
3379 (output_bfd
, &rel
[0],
3381 + reloc_index
* sizeof (Elf64_Mips_External_Rel
)));
3384 bfd_elf32_swap_reloc_out
3385 (output_bfd
, &rel
[0],
3387 + reloc_index
* sizeof (Elf32_External_Rel
)));
3390 /* Initialize a set of TLS GOT entries for one symbol. */
3393 mips_elf_initialize_tls_slots (bfd
*abfd
, struct bfd_link_info
*info
,
3394 struct mips_got_entry
*entry
,
3395 struct mips_elf_link_hash_entry
*h
,
3398 bfd_boolean dyn
= elf_hash_table (info
)->dynamic_sections_created
;
3399 struct mips_elf_link_hash_table
*htab
;
3401 asection
*sreloc
, *sgot
;
3402 bfd_vma got_offset
, got_offset2
;
3403 bfd_boolean need_relocs
= FALSE
;
3405 htab
= mips_elf_hash_table (info
);
3409 sgot
= htab
->root
.sgot
;
3413 && h
->root
.dynindx
!= -1
3414 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), &h
->root
)
3415 && (bfd_link_dll (info
) || !SYMBOL_REFERENCES_LOCAL (info
, &h
->root
)))
3416 indx
= h
->root
.dynindx
;
3418 if (entry
->tls_initialized
)
3421 if ((bfd_link_dll (info
) || indx
!= 0)
3423 || ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
3424 || h
->root
.type
!= bfd_link_hash_undefweak
))
3427 /* MINUS_ONE means the symbol is not defined in this object. It may not
3428 be defined at all; assume that the value doesn't matter in that
3429 case. Otherwise complain if we would use the value. */
3430 BFD_ASSERT (value
!= MINUS_ONE
|| (indx
!= 0 && need_relocs
)
3431 || h
->root
.root
.type
== bfd_link_hash_undefweak
);
3433 /* Emit necessary relocations. */
3434 sreloc
= mips_elf_rel_dyn_section (info
, FALSE
);
3435 got_offset
= entry
->gotidx
;
3437 switch (entry
->tls_type
)
3440 /* General Dynamic. */
3441 got_offset2
= got_offset
+ MIPS_ELF_GOT_SIZE (abfd
);
3445 mips_elf_output_dynamic_relocation
3446 (abfd
, sreloc
, sreloc
->reloc_count
++, indx
,
3447 ABI_64_P (abfd
) ? R_MIPS_TLS_DTPMOD64
: R_MIPS_TLS_DTPMOD32
,
3448 sgot
->output_offset
+ sgot
->output_section
->vma
+ got_offset
);
3451 mips_elf_output_dynamic_relocation
3452 (abfd
, sreloc
, sreloc
->reloc_count
++, indx
,
3453 ABI_64_P (abfd
) ? R_MIPS_TLS_DTPREL64
: R_MIPS_TLS_DTPREL32
,
3454 sgot
->output_offset
+ sgot
->output_section
->vma
+ got_offset2
);
3456 MIPS_ELF_PUT_WORD (abfd
, value
- dtprel_base (info
),
3457 sgot
->contents
+ got_offset2
);
3461 MIPS_ELF_PUT_WORD (abfd
, 1,
3462 sgot
->contents
+ got_offset
);
3463 MIPS_ELF_PUT_WORD (abfd
, value
- dtprel_base (info
),
3464 sgot
->contents
+ got_offset2
);
3469 /* Initial Exec model. */
3473 MIPS_ELF_PUT_WORD (abfd
, value
- elf_hash_table (info
)->tls_sec
->vma
,
3474 sgot
->contents
+ got_offset
);
3476 MIPS_ELF_PUT_WORD (abfd
, 0,
3477 sgot
->contents
+ got_offset
);
3479 mips_elf_output_dynamic_relocation
3480 (abfd
, sreloc
, sreloc
->reloc_count
++, indx
,
3481 ABI_64_P (abfd
) ? R_MIPS_TLS_TPREL64
: R_MIPS_TLS_TPREL32
,
3482 sgot
->output_offset
+ sgot
->output_section
->vma
+ got_offset
);
3485 MIPS_ELF_PUT_WORD (abfd
, value
- tprel_base (info
),
3486 sgot
->contents
+ got_offset
);
3490 /* The initial offset is zero, and the LD offsets will include the
3491 bias by DTP_OFFSET. */
3492 MIPS_ELF_PUT_WORD (abfd
, 0,
3493 sgot
->contents
+ got_offset
3494 + MIPS_ELF_GOT_SIZE (abfd
));
3496 if (!bfd_link_dll (info
))
3497 MIPS_ELF_PUT_WORD (abfd
, 1,
3498 sgot
->contents
+ got_offset
);
3500 mips_elf_output_dynamic_relocation
3501 (abfd
, sreloc
, sreloc
->reloc_count
++, indx
,
3502 ABI_64_P (abfd
) ? R_MIPS_TLS_DTPMOD64
: R_MIPS_TLS_DTPMOD32
,
3503 sgot
->output_offset
+ sgot
->output_section
->vma
+ got_offset
);
3510 entry
->tls_initialized
= TRUE
;
3513 /* Return the offset from _GLOBAL_OFFSET_TABLE_ of the .got.plt entry
3514 for global symbol H. .got.plt comes before the GOT, so the offset
3515 will be negative. */
3518 mips_elf_gotplt_index (struct bfd_link_info
*info
,
3519 struct elf_link_hash_entry
*h
)
3521 bfd_vma got_address
, got_value
;
3522 struct mips_elf_link_hash_table
*htab
;
3524 htab
= mips_elf_hash_table (info
);
3525 BFD_ASSERT (htab
!= NULL
);
3527 BFD_ASSERT (h
->plt
.plist
!= NULL
);
3528 BFD_ASSERT (h
->plt
.plist
->gotplt_index
!= MINUS_ONE
);
3530 /* Calculate the address of the associated .got.plt entry. */
3531 got_address
= (htab
->root
.sgotplt
->output_section
->vma
3532 + htab
->root
.sgotplt
->output_offset
3533 + (h
->plt
.plist
->gotplt_index
3534 * MIPS_ELF_GOT_SIZE (info
->output_bfd
)));
3536 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */
3537 got_value
= (htab
->root
.hgot
->root
.u
.def
.section
->output_section
->vma
3538 + htab
->root
.hgot
->root
.u
.def
.section
->output_offset
3539 + htab
->root
.hgot
->root
.u
.def
.value
);
3541 return got_address
- got_value
;
3544 /* Return the GOT offset for address VALUE. If there is not yet a GOT
3545 entry for this value, create one. If R_SYMNDX refers to a TLS symbol,
3546 create a TLS GOT entry instead. Return -1 if no satisfactory GOT
3547 offset can be found. */
3550 mips_elf_local_got_index (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
3551 bfd_vma value
, unsigned long r_symndx
,
3552 struct mips_elf_link_hash_entry
*h
, int r_type
)
3554 struct mips_elf_link_hash_table
*htab
;
3555 struct mips_got_entry
*entry
;
3557 htab
= mips_elf_hash_table (info
);
3558 BFD_ASSERT (htab
!= NULL
);
3560 entry
= mips_elf_create_local_got_entry (abfd
, info
, ibfd
, value
,
3561 r_symndx
, h
, r_type
);
3565 if (entry
->tls_type
)
3566 mips_elf_initialize_tls_slots (abfd
, info
, entry
, h
, value
);
3567 return entry
->gotidx
;
3570 /* Return the GOT index of global symbol H in the primary GOT. */
3573 mips_elf_primary_global_got_index (bfd
*obfd
, struct bfd_link_info
*info
,
3574 struct elf_link_hash_entry
*h
)
3576 struct mips_elf_link_hash_table
*htab
;
3577 long global_got_dynindx
;
3578 struct mips_got_info
*g
;
3581 htab
= mips_elf_hash_table (info
);
3582 BFD_ASSERT (htab
!= NULL
);
3584 global_got_dynindx
= 0;
3585 if (htab
->global_gotsym
!= NULL
)
3586 global_got_dynindx
= htab
->global_gotsym
->dynindx
;
3588 /* Once we determine the global GOT entry with the lowest dynamic
3589 symbol table index, we must put all dynamic symbols with greater
3590 indices into the primary GOT. That makes it easy to calculate the
3592 BFD_ASSERT (h
->dynindx
>= global_got_dynindx
);
3593 g
= mips_elf_bfd_got (obfd
, FALSE
);
3594 got_index
= ((h
->dynindx
- global_got_dynindx
+ g
->local_gotno
)
3595 * MIPS_ELF_GOT_SIZE (obfd
));
3596 BFD_ASSERT (got_index
< htab
->root
.sgot
->size
);
3601 /* Return the GOT index for the global symbol indicated by H, which is
3602 referenced by a relocation of type R_TYPE in IBFD. */
3605 mips_elf_global_got_index (bfd
*obfd
, struct bfd_link_info
*info
, bfd
*ibfd
,
3606 struct elf_link_hash_entry
*h
, int r_type
)
3608 struct mips_elf_link_hash_table
*htab
;
3609 struct mips_got_info
*g
;
3610 struct mips_got_entry lookup
, *entry
;
3613 htab
= mips_elf_hash_table (info
);
3614 BFD_ASSERT (htab
!= NULL
);
3616 g
= mips_elf_bfd_got (ibfd
, FALSE
);
3619 lookup
.tls_type
= mips_elf_reloc_tls_type (r_type
);
3620 if (!lookup
.tls_type
&& g
== mips_elf_bfd_got (obfd
, FALSE
))
3621 return mips_elf_primary_global_got_index (obfd
, info
, h
);
3625 lookup
.d
.h
= (struct mips_elf_link_hash_entry
*) h
;
3626 entry
= htab_find (g
->got_entries
, &lookup
);
3629 gotidx
= entry
->gotidx
;
3630 BFD_ASSERT (gotidx
> 0 && gotidx
< htab
->root
.sgot
->size
);
3632 if (lookup
.tls_type
)
3634 bfd_vma value
= MINUS_ONE
;
3636 if ((h
->root
.type
== bfd_link_hash_defined
3637 || h
->root
.type
== bfd_link_hash_defweak
)
3638 && h
->root
.u
.def
.section
->output_section
)
3639 value
= (h
->root
.u
.def
.value
3640 + h
->root
.u
.def
.section
->output_offset
3641 + h
->root
.u
.def
.section
->output_section
->vma
);
3643 mips_elf_initialize_tls_slots (obfd
, info
, entry
, lookup
.d
.h
, value
);
3648 /* Find a GOT page entry that points to within 32KB of VALUE. These
3649 entries are supposed to be placed at small offsets in the GOT, i.e.,
3650 within 32KB of GP. Return the index of the GOT entry, or -1 if no
3651 entry could be created. If OFFSETP is nonnull, use it to return the
3652 offset of the GOT entry from VALUE. */
3655 mips_elf_got_page (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
3656 bfd_vma value
, bfd_vma
*offsetp
)
3658 bfd_vma page
, got_index
;
3659 struct mips_got_entry
*entry
;
3661 page
= (value
+ 0x8000) & ~(bfd_vma
) 0xffff;
3662 entry
= mips_elf_create_local_got_entry (abfd
, info
, ibfd
, page
, 0,
3663 NULL
, R_MIPS_GOT_PAGE
);
3668 got_index
= entry
->gotidx
;
3671 *offsetp
= value
- entry
->d
.address
;
3676 /* Find a local GOT entry for an R_MIPS*_GOT16 relocation against VALUE.
3677 EXTERNAL is true if the relocation was originally against a global
3678 symbol that binds locally. */
3681 mips_elf_got16_entry (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
3682 bfd_vma value
, bfd_boolean external
)
3684 struct mips_got_entry
*entry
;
3686 /* GOT16 relocations against local symbols are followed by a LO16
3687 relocation; those against global symbols are not. Thus if the
3688 symbol was originally local, the GOT16 relocation should load the
3689 equivalent of %hi(VALUE), otherwise it should load VALUE itself. */
3691 value
= mips_elf_high (value
) << 16;
3693 /* It doesn't matter whether the original relocation was R_MIPS_GOT16,
3694 R_MIPS16_GOT16, R_MIPS_CALL16, etc. The format of the entry is the
3695 same in all cases. */
3696 entry
= mips_elf_create_local_got_entry (abfd
, info
, ibfd
, value
, 0,
3697 NULL
, R_MIPS_GOT16
);
3699 return entry
->gotidx
;
3704 /* Returns the offset for the entry at the INDEXth position
3708 mips_elf_got_offset_from_index (struct bfd_link_info
*info
, bfd
*output_bfd
,
3709 bfd
*input_bfd
, bfd_vma got_index
)
3711 struct mips_elf_link_hash_table
*htab
;
3715 htab
= mips_elf_hash_table (info
);
3716 BFD_ASSERT (htab
!= NULL
);
3718 sgot
= htab
->root
.sgot
;
3719 gp
= _bfd_get_gp_value (output_bfd
)
3720 + mips_elf_adjust_gp (output_bfd
, htab
->got_info
, input_bfd
);
3722 return sgot
->output_section
->vma
+ sgot
->output_offset
+ got_index
- gp
;
3725 /* Create and return a local GOT entry for VALUE, which was calculated
3726 from a symbol belonging to INPUT_SECTON. Return NULL if it could not
3727 be created. If R_SYMNDX refers to a TLS symbol, create a TLS entry
3730 static struct mips_got_entry
*
3731 mips_elf_create_local_got_entry (bfd
*abfd
, struct bfd_link_info
*info
,
3732 bfd
*ibfd
, bfd_vma value
,
3733 unsigned long r_symndx
,
3734 struct mips_elf_link_hash_entry
*h
,
3737 struct mips_got_entry lookup
, *entry
;
3739 struct mips_got_info
*g
;
3740 struct mips_elf_link_hash_table
*htab
;
3743 htab
= mips_elf_hash_table (info
);
3744 BFD_ASSERT (htab
!= NULL
);
3746 g
= mips_elf_bfd_got (ibfd
, FALSE
);
3749 g
= mips_elf_bfd_got (abfd
, FALSE
);
3750 BFD_ASSERT (g
!= NULL
);
3753 /* This function shouldn't be called for symbols that live in the global
3755 BFD_ASSERT (h
== NULL
|| h
->global_got_area
== GGA_NONE
);
3757 lookup
.tls_type
= mips_elf_reloc_tls_type (r_type
);
3758 if (lookup
.tls_type
)
3761 if (tls_ldm_reloc_p (r_type
))
3764 lookup
.d
.addend
= 0;
3768 lookup
.symndx
= r_symndx
;
3769 lookup
.d
.addend
= 0;
3777 entry
= (struct mips_got_entry
*) htab_find (g
->got_entries
, &lookup
);
3780 gotidx
= entry
->gotidx
;
3781 BFD_ASSERT (gotidx
> 0 && gotidx
< htab
->root
.sgot
->size
);
3788 lookup
.d
.address
= value
;
3789 loc
= htab_find_slot (g
->got_entries
, &lookup
, INSERT
);
3793 entry
= (struct mips_got_entry
*) *loc
;
3797 if (g
->assigned_low_gotno
> g
->assigned_high_gotno
)
3799 /* We didn't allocate enough space in the GOT. */
3801 (_("not enough GOT space for local GOT entries"));
3802 bfd_set_error (bfd_error_bad_value
);
3806 entry
= (struct mips_got_entry
*) bfd_alloc (abfd
, sizeof (*entry
));
3810 if (got16_reloc_p (r_type
)
3811 || call16_reloc_p (r_type
)
3812 || got_page_reloc_p (r_type
)
3813 || got_disp_reloc_p (r_type
))
3814 lookup
.gotidx
= MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_low_gotno
++;
3816 lookup
.gotidx
= MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_high_gotno
--;
3821 MIPS_ELF_PUT_WORD (abfd
, value
, htab
->root
.sgot
->contents
+ entry
->gotidx
);
3823 /* These GOT entries need a dynamic relocation on VxWorks. */
3824 if (htab
->is_vxworks
)
3826 Elf_Internal_Rela outrel
;
3829 bfd_vma got_address
;
3831 s
= mips_elf_rel_dyn_section (info
, FALSE
);
3832 got_address
= (htab
->root
.sgot
->output_section
->vma
3833 + htab
->root
.sgot
->output_offset
3836 rloc
= s
->contents
+ (s
->reloc_count
++ * sizeof (Elf32_External_Rela
));
3837 outrel
.r_offset
= got_address
;
3838 outrel
.r_info
= ELF32_R_INFO (STN_UNDEF
, R_MIPS_32
);
3839 outrel
.r_addend
= value
;
3840 bfd_elf32_swap_reloca_out (abfd
, &outrel
, rloc
);
3846 /* Return the number of dynamic section symbols required by OUTPUT_BFD.
3847 The number might be exact or a worst-case estimate, depending on how
3848 much information is available to elf_backend_omit_section_dynsym at
3849 the current linking stage. */
3851 static bfd_size_type
3852 count_section_dynsyms (bfd
*output_bfd
, struct bfd_link_info
*info
)
3854 bfd_size_type count
;
3857 if (bfd_link_pic (info
)
3858 || elf_hash_table (info
)->is_relocatable_executable
)
3861 const struct elf_backend_data
*bed
;
3863 bed
= get_elf_backend_data (output_bfd
);
3864 for (p
= output_bfd
->sections
; p
; p
= p
->next
)
3865 if ((p
->flags
& SEC_EXCLUDE
) == 0
3866 && (p
->flags
& SEC_ALLOC
) != 0
3867 && elf_hash_table (info
)->dynamic_relocs
3868 && !(*bed
->elf_backend_omit_section_dynsym
) (output_bfd
, info
, p
))
3874 /* Sort the dynamic symbol table so that symbols that need GOT entries
3875 appear towards the end. */
3878 mips_elf_sort_hash_table (bfd
*abfd
, struct bfd_link_info
*info
)
3880 struct mips_elf_link_hash_table
*htab
;
3881 struct mips_elf_hash_sort_data hsd
;
3882 struct mips_got_info
*g
;
3884 htab
= mips_elf_hash_table (info
);
3885 BFD_ASSERT (htab
!= NULL
);
3887 if (htab
->root
.dynsymcount
== 0)
3895 hsd
.max_unref_got_dynindx
3896 = hsd
.min_got_dynindx
3897 = (htab
->root
.dynsymcount
- g
->reloc_only_gotno
);
3898 /* Add 1 to local symbol indices to account for the mandatory NULL entry
3899 at the head of the table; see `_bfd_elf_link_renumber_dynsyms'. */
3900 hsd
.max_local_dynindx
= count_section_dynsyms (abfd
, info
) + 1;
3901 hsd
.max_non_got_dynindx
= htab
->root
.local_dynsymcount
+ 1;
3902 hsd
.output_bfd
= abfd
;
3903 if (htab
->root
.dynobj
!= NULL
3904 && htab
->root
.dynamic_sections_created
3905 && info
->emit_gnu_hash
)
3907 asection
*s
= bfd_get_linker_section (htab
->root
.dynobj
, ".MIPS.xhash");
3908 BFD_ASSERT (s
!= NULL
);
3909 hsd
.mipsxhash
= s
->contents
;
3910 BFD_ASSERT (hsd
.mipsxhash
!= NULL
);
3913 hsd
.mipsxhash
= NULL
;
3914 mips_elf_link_hash_traverse (htab
, mips_elf_sort_hash_table_f
, &hsd
);
3916 /* There should have been enough room in the symbol table to
3917 accommodate both the GOT and non-GOT symbols. */
3918 BFD_ASSERT (hsd
.max_local_dynindx
<= htab
->root
.local_dynsymcount
+ 1);
3919 BFD_ASSERT (hsd
.max_non_got_dynindx
<= hsd
.min_got_dynindx
);
3920 BFD_ASSERT (hsd
.max_unref_got_dynindx
== htab
->root
.dynsymcount
);
3921 BFD_ASSERT (htab
->root
.dynsymcount
- hsd
.min_got_dynindx
== g
->global_gotno
);
3923 /* Now we know which dynamic symbol has the lowest dynamic symbol
3924 table index in the GOT. */
3925 htab
->global_gotsym
= hsd
.low
;
3930 /* If H needs a GOT entry, assign it the highest available dynamic
3931 index. Otherwise, assign it the lowest available dynamic
3935 mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry
*h
, void *data
)
3937 struct mips_elf_hash_sort_data
*hsd
= data
;
3939 /* Symbols without dynamic symbol table entries aren't interesting
3941 if (h
->root
.dynindx
== -1)
3944 switch (h
->global_got_area
)
3947 if (h
->root
.forced_local
)
3948 h
->root
.dynindx
= hsd
->max_local_dynindx
++;
3950 h
->root
.dynindx
= hsd
->max_non_got_dynindx
++;
3954 h
->root
.dynindx
= --hsd
->min_got_dynindx
;
3955 hsd
->low
= (struct elf_link_hash_entry
*) h
;
3958 case GGA_RELOC_ONLY
:
3959 if (hsd
->max_unref_got_dynindx
== hsd
->min_got_dynindx
)
3960 hsd
->low
= (struct elf_link_hash_entry
*) h
;
3961 h
->root
.dynindx
= hsd
->max_unref_got_dynindx
++;
3965 /* Populate the .MIPS.xhash translation table entry with
3966 the symbol dynindx. */
3967 if (h
->mipsxhash_loc
!= 0 && hsd
->mipsxhash
!= NULL
)
3968 bfd_put_32 (hsd
->output_bfd
, h
->root
.dynindx
,
3969 hsd
->mipsxhash
+ h
->mipsxhash_loc
);
3974 /* Record that input bfd ABFD requires a GOT entry like *LOOKUP
3975 (which is owned by the caller and shouldn't be added to the
3976 hash table directly). */
3979 mips_elf_record_got_entry (struct bfd_link_info
*info
, bfd
*abfd
,
3980 struct mips_got_entry
*lookup
)
3982 struct mips_elf_link_hash_table
*htab
;
3983 struct mips_got_entry
*entry
;
3984 struct mips_got_info
*g
;
3985 void **loc
, **bfd_loc
;
3987 /* Make sure there's a slot for this entry in the master GOT. */
3988 htab
= mips_elf_hash_table (info
);
3990 loc
= htab_find_slot (g
->got_entries
, lookup
, INSERT
);
3994 /* Populate the entry if it isn't already. */
3995 entry
= (struct mips_got_entry
*) *loc
;
3998 entry
= (struct mips_got_entry
*) bfd_alloc (abfd
, sizeof (*entry
));
4002 lookup
->tls_initialized
= FALSE
;
4003 lookup
->gotidx
= -1;
4008 /* Reuse the same GOT entry for the BFD's GOT. */
4009 g
= mips_elf_bfd_got (abfd
, TRUE
);
4013 bfd_loc
= htab_find_slot (g
->got_entries
, lookup
, INSERT
);
4022 /* ABFD has a GOT relocation of type R_TYPE against H. Reserve a GOT
4023 entry for it. FOR_CALL is true if the caller is only interested in
4024 using the GOT entry for calls. */
4027 mips_elf_record_global_got_symbol (struct elf_link_hash_entry
*h
,
4028 bfd
*abfd
, struct bfd_link_info
*info
,
4029 bfd_boolean for_call
, int r_type
)
4031 struct mips_elf_link_hash_table
*htab
;
4032 struct mips_elf_link_hash_entry
*hmips
;
4033 struct mips_got_entry entry
;
4034 unsigned char tls_type
;
4036 htab
= mips_elf_hash_table (info
);
4037 BFD_ASSERT (htab
!= NULL
);
4039 hmips
= (struct mips_elf_link_hash_entry
*) h
;
4041 hmips
->got_only_for_calls
= FALSE
;
4043 /* A global symbol in the GOT must also be in the dynamic symbol
4045 if (h
->dynindx
== -1)
4047 switch (ELF_ST_VISIBILITY (h
->other
))
4051 _bfd_mips_elf_hide_symbol (info
, h
, TRUE
);
4054 if (!bfd_elf_link_record_dynamic_symbol (info
, h
))
4058 tls_type
= mips_elf_reloc_tls_type (r_type
);
4059 if (tls_type
== GOT_TLS_NONE
&& hmips
->global_got_area
> GGA_NORMAL
)
4060 hmips
->global_got_area
= GGA_NORMAL
;
4064 entry
.d
.h
= (struct mips_elf_link_hash_entry
*) h
;
4065 entry
.tls_type
= tls_type
;
4066 return mips_elf_record_got_entry (info
, abfd
, &entry
);
4069 /* ABFD has a GOT relocation of type R_TYPE against symbol SYMNDX + ADDEND,
4070 where SYMNDX is a local symbol. Reserve a GOT entry for it. */
4073 mips_elf_record_local_got_symbol (bfd
*abfd
, long symndx
, bfd_vma addend
,
4074 struct bfd_link_info
*info
, int r_type
)
4076 struct mips_elf_link_hash_table
*htab
;
4077 struct mips_got_info
*g
;
4078 struct mips_got_entry entry
;
4080 htab
= mips_elf_hash_table (info
);
4081 BFD_ASSERT (htab
!= NULL
);
4084 BFD_ASSERT (g
!= NULL
);
4087 entry
.symndx
= symndx
;
4088 entry
.d
.addend
= addend
;
4089 entry
.tls_type
= mips_elf_reloc_tls_type (r_type
);
4090 return mips_elf_record_got_entry (info
, abfd
, &entry
);
4093 /* Record that ABFD has a page relocation against SYMNDX + ADDEND.
4094 H is the symbol's hash table entry, or null if SYMNDX is local
4098 mips_elf_record_got_page_ref (struct bfd_link_info
*info
, bfd
*abfd
,
4099 long symndx
, struct elf_link_hash_entry
*h
,
4100 bfd_signed_vma addend
)
4102 struct mips_elf_link_hash_table
*htab
;
4103 struct mips_got_info
*g1
, *g2
;
4104 struct mips_got_page_ref lookup
, *entry
;
4105 void **loc
, **bfd_loc
;
4107 htab
= mips_elf_hash_table (info
);
4108 BFD_ASSERT (htab
!= NULL
);
4110 g1
= htab
->got_info
;
4111 BFD_ASSERT (g1
!= NULL
);
4116 lookup
.u
.h
= (struct mips_elf_link_hash_entry
*) h
;
4120 lookup
.symndx
= symndx
;
4121 lookup
.u
.abfd
= abfd
;
4123 lookup
.addend
= addend
;
4124 loc
= htab_find_slot (g1
->got_page_refs
, &lookup
, INSERT
);
4128 entry
= (struct mips_got_page_ref
*) *loc
;
4131 entry
= bfd_alloc (abfd
, sizeof (*entry
));
4139 /* Add the same entry to the BFD's GOT. */
4140 g2
= mips_elf_bfd_got (abfd
, TRUE
);
4144 bfd_loc
= htab_find_slot (g2
->got_page_refs
, &lookup
, INSERT
);
4154 /* Add room for N relocations to the .rel(a).dyn section in ABFD. */
4157 mips_elf_allocate_dynamic_relocations (bfd
*abfd
, struct bfd_link_info
*info
,
4161 struct mips_elf_link_hash_table
*htab
;
4163 htab
= mips_elf_hash_table (info
);
4164 BFD_ASSERT (htab
!= NULL
);
4166 s
= mips_elf_rel_dyn_section (info
, FALSE
);
4167 BFD_ASSERT (s
!= NULL
);
4169 if (htab
->is_vxworks
)
4170 s
->size
+= n
* MIPS_ELF_RELA_SIZE (abfd
);
4175 /* Make room for a null element. */
4176 s
->size
+= MIPS_ELF_REL_SIZE (abfd
);
4179 s
->size
+= n
* MIPS_ELF_REL_SIZE (abfd
);
4183 /* A htab_traverse callback for GOT entries, with DATA pointing to a
4184 mips_elf_traverse_got_arg structure. Count the number of GOT
4185 entries and TLS relocs. Set DATA->value to true if we need
4186 to resolve indirect or warning symbols and then recreate the GOT. */
4189 mips_elf_check_recreate_got (void **entryp
, void *data
)
4191 struct mips_got_entry
*entry
;
4192 struct mips_elf_traverse_got_arg
*arg
;
4194 entry
= (struct mips_got_entry
*) *entryp
;
4195 arg
= (struct mips_elf_traverse_got_arg
*) data
;
4196 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1)
4198 struct mips_elf_link_hash_entry
*h
;
4201 if (h
->root
.root
.type
== bfd_link_hash_indirect
4202 || h
->root
.root
.type
== bfd_link_hash_warning
)
4208 mips_elf_count_got_entry (arg
->info
, arg
->g
, entry
);
4212 /* A htab_traverse callback for GOT entries, with DATA pointing to a
4213 mips_elf_traverse_got_arg structure. Add all entries to DATA->g,
4214 converting entries for indirect and warning symbols into entries
4215 for the target symbol. Set DATA->g to null on error. */
4218 mips_elf_recreate_got (void **entryp
, void *data
)
4220 struct mips_got_entry new_entry
, *entry
;
4221 struct mips_elf_traverse_got_arg
*arg
;
4224 entry
= (struct mips_got_entry
*) *entryp
;
4225 arg
= (struct mips_elf_traverse_got_arg
*) data
;
4226 if (entry
->abfd
!= NULL
4227 && entry
->symndx
== -1
4228 && (entry
->d
.h
->root
.root
.type
== bfd_link_hash_indirect
4229 || entry
->d
.h
->root
.root
.type
== bfd_link_hash_warning
))
4231 struct mips_elf_link_hash_entry
*h
;
4238 BFD_ASSERT (h
->global_got_area
== GGA_NONE
);
4239 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
4241 while (h
->root
.root
.type
== bfd_link_hash_indirect
4242 || h
->root
.root
.type
== bfd_link_hash_warning
);
4245 slot
= htab_find_slot (arg
->g
->got_entries
, entry
, INSERT
);
4253 if (entry
== &new_entry
)
4255 entry
= bfd_alloc (entry
->abfd
, sizeof (*entry
));
4264 mips_elf_count_got_entry (arg
->info
, arg
->g
, entry
);
4269 /* Return the maximum number of GOT page entries required for RANGE. */
4272 mips_elf_pages_for_range (const struct mips_got_page_range
*range
)
4274 return (range
->max_addend
- range
->min_addend
+ 0x1ffff) >> 16;
4277 /* Record that G requires a page entry that can reach SEC + ADDEND. */
4280 mips_elf_record_got_page_entry (struct mips_elf_traverse_got_arg
*arg
,
4281 asection
*sec
, bfd_signed_vma addend
)
4283 struct mips_got_info
*g
= arg
->g
;
4284 struct mips_got_page_entry lookup
, *entry
;
4285 struct mips_got_page_range
**range_ptr
, *range
;
4286 bfd_vma old_pages
, new_pages
;
4289 /* Find the mips_got_page_entry hash table entry for this section. */
4291 loc
= htab_find_slot (g
->got_page_entries
, &lookup
, INSERT
);
4295 /* Create a mips_got_page_entry if this is the first time we've
4296 seen the section. */
4297 entry
= (struct mips_got_page_entry
*) *loc
;
4300 entry
= bfd_zalloc (arg
->info
->output_bfd
, sizeof (*entry
));
4308 /* Skip over ranges whose maximum extent cannot share a page entry
4310 range_ptr
= &entry
->ranges
;
4311 while (*range_ptr
&& addend
> (*range_ptr
)->max_addend
+ 0xffff)
4312 range_ptr
= &(*range_ptr
)->next
;
4314 /* If we scanned to the end of the list, or found a range whose
4315 minimum extent cannot share a page entry with ADDEND, create
4316 a new singleton range. */
4318 if (!range
|| addend
< range
->min_addend
- 0xffff)
4320 range
= bfd_zalloc (arg
->info
->output_bfd
, sizeof (*range
));
4324 range
->next
= *range_ptr
;
4325 range
->min_addend
= addend
;
4326 range
->max_addend
= addend
;
4334 /* Remember how many pages the old range contributed. */
4335 old_pages
= mips_elf_pages_for_range (range
);
4337 /* Update the ranges. */
4338 if (addend
< range
->min_addend
)
4339 range
->min_addend
= addend
;
4340 else if (addend
> range
->max_addend
)
4342 if (range
->next
&& addend
>= range
->next
->min_addend
- 0xffff)
4344 old_pages
+= mips_elf_pages_for_range (range
->next
);
4345 range
->max_addend
= range
->next
->max_addend
;
4346 range
->next
= range
->next
->next
;
4349 range
->max_addend
= addend
;
4352 /* Record any change in the total estimate. */
4353 new_pages
= mips_elf_pages_for_range (range
);
4354 if (old_pages
!= new_pages
)
4356 entry
->num_pages
+= new_pages
- old_pages
;
4357 g
->page_gotno
+= new_pages
- old_pages
;
4363 /* A htab_traverse callback for which *REFP points to a mips_got_page_ref
4364 and for which DATA points to a mips_elf_traverse_got_arg. Work out
4365 whether the page reference described by *REFP needs a GOT page entry,
4366 and record that entry in DATA->g if so. Set DATA->g to null on failure. */
4369 mips_elf_resolve_got_page_ref (void **refp
, void *data
)
4371 struct mips_got_page_ref
*ref
;
4372 struct mips_elf_traverse_got_arg
*arg
;
4373 struct mips_elf_link_hash_table
*htab
;
4377 ref
= (struct mips_got_page_ref
*) *refp
;
4378 arg
= (struct mips_elf_traverse_got_arg
*) data
;
4379 htab
= mips_elf_hash_table (arg
->info
);
4381 if (ref
->symndx
< 0)
4383 struct mips_elf_link_hash_entry
*h
;
4385 /* Global GOT_PAGEs decay to GOT_DISP and so don't need page entries. */
4387 if (!SYMBOL_REFERENCES_LOCAL (arg
->info
, &h
->root
))
4390 /* Ignore undefined symbols; we'll issue an error later if
4392 if (!((h
->root
.root
.type
== bfd_link_hash_defined
4393 || h
->root
.root
.type
== bfd_link_hash_defweak
)
4394 && h
->root
.root
.u
.def
.section
))
4397 sec
= h
->root
.root
.u
.def
.section
;
4398 addend
= h
->root
.root
.u
.def
.value
+ ref
->addend
;
4402 Elf_Internal_Sym
*isym
;
4404 /* Read in the symbol. */
4405 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
, ref
->u
.abfd
,
4413 /* Get the associated input section. */
4414 sec
= bfd_section_from_elf_index (ref
->u
.abfd
, isym
->st_shndx
);
4421 /* If this is a mergable section, work out the section and offset
4422 of the merged data. For section symbols, the addend specifies
4423 of the offset _of_ the first byte in the data, otherwise it
4424 specifies the offset _from_ the first byte. */
4425 if (sec
->flags
& SEC_MERGE
)
4429 secinfo
= elf_section_data (sec
)->sec_info
;
4430 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
4431 addend
= _bfd_merged_section_offset (ref
->u
.abfd
, &sec
, secinfo
,
4432 isym
->st_value
+ ref
->addend
);
4434 addend
= _bfd_merged_section_offset (ref
->u
.abfd
, &sec
, secinfo
,
4435 isym
->st_value
) + ref
->addend
;
4438 addend
= isym
->st_value
+ ref
->addend
;
4440 if (!mips_elf_record_got_page_entry (arg
, sec
, addend
))
4448 /* If any entries in G->got_entries are for indirect or warning symbols,
4449 replace them with entries for the target symbol. Convert g->got_page_refs
4450 into got_page_entry structures and estimate the number of page entries
4451 that they require. */
4454 mips_elf_resolve_final_got_entries (struct bfd_link_info
*info
,
4455 struct mips_got_info
*g
)
4457 struct mips_elf_traverse_got_arg tga
;
4458 struct mips_got_info oldg
;
4465 htab_traverse (g
->got_entries
, mips_elf_check_recreate_got
, &tga
);
4469 g
->got_entries
= htab_create (htab_size (oldg
.got_entries
),
4470 mips_elf_got_entry_hash
,
4471 mips_elf_got_entry_eq
, NULL
);
4472 if (!g
->got_entries
)
4475 htab_traverse (oldg
.got_entries
, mips_elf_recreate_got
, &tga
);
4479 htab_delete (oldg
.got_entries
);
4482 g
->got_page_entries
= htab_try_create (1, mips_got_page_entry_hash
,
4483 mips_got_page_entry_eq
, NULL
);
4484 if (g
->got_page_entries
== NULL
)
4489 htab_traverse (g
->got_page_refs
, mips_elf_resolve_got_page_ref
, &tga
);
4494 /* Return true if a GOT entry for H should live in the local rather than
4498 mips_use_local_got_p (struct bfd_link_info
*info
,
4499 struct mips_elf_link_hash_entry
*h
)
4501 /* Symbols that aren't in the dynamic symbol table must live in the
4502 local GOT. This includes symbols that are completely undefined
4503 and which therefore don't bind locally. We'll report undefined
4504 symbols later if appropriate. */
4505 if (h
->root
.dynindx
== -1)
4508 /* Absolute symbols, if ever they need a GOT entry, cannot ever go
4509 to the local GOT, as they would be implicitly relocated by the
4510 base address by the dynamic loader. */
4511 if (bfd_is_abs_symbol (&h
->root
.root
))
4514 /* Symbols that bind locally can (and in the case of forced-local
4515 symbols, must) live in the local GOT. */
4516 if (h
->got_only_for_calls
4517 ? SYMBOL_CALLS_LOCAL (info
, &h
->root
)
4518 : SYMBOL_REFERENCES_LOCAL (info
, &h
->root
))
4521 /* If this is an executable that must provide a definition of the symbol,
4522 either though PLTs or copy relocations, then that address should go in
4523 the local rather than global GOT. */
4524 if (bfd_link_executable (info
) && h
->has_static_relocs
)
4530 /* A mips_elf_link_hash_traverse callback for which DATA points to the
4531 link_info structure. Decide whether the hash entry needs an entry in
4532 the global part of the primary GOT, setting global_got_area accordingly.
4533 Count the number of global symbols that are in the primary GOT only
4534 because they have relocations against them (reloc_only_gotno). */
4537 mips_elf_count_got_symbols (struct mips_elf_link_hash_entry
*h
, void *data
)
4539 struct bfd_link_info
*info
;
4540 struct mips_elf_link_hash_table
*htab
;
4541 struct mips_got_info
*g
;
4543 info
= (struct bfd_link_info
*) data
;
4544 htab
= mips_elf_hash_table (info
);
4546 if (h
->global_got_area
!= GGA_NONE
)
4548 /* Make a final decision about whether the symbol belongs in the
4549 local or global GOT. */
4550 if (mips_use_local_got_p (info
, h
))
4551 /* The symbol belongs in the local GOT. We no longer need this
4552 entry if it was only used for relocations; those relocations
4553 will be against the null or section symbol instead of H. */
4554 h
->global_got_area
= GGA_NONE
;
4555 else if (htab
->is_vxworks
4556 && h
->got_only_for_calls
4557 && h
->root
.plt
.plist
->mips_offset
!= MINUS_ONE
)
4558 /* On VxWorks, calls can refer directly to the .got.plt entry;
4559 they don't need entries in the regular GOT. .got.plt entries
4560 will be allocated by _bfd_mips_elf_adjust_dynamic_symbol. */
4561 h
->global_got_area
= GGA_NONE
;
4562 else if (h
->global_got_area
== GGA_RELOC_ONLY
)
4564 g
->reloc_only_gotno
++;
4571 /* A htab_traverse callback for GOT entries. Add each one to the GOT
4572 given in mips_elf_traverse_got_arg DATA. Clear DATA->G on error. */
4575 mips_elf_add_got_entry (void **entryp
, void *data
)
4577 struct mips_got_entry
*entry
;
4578 struct mips_elf_traverse_got_arg
*arg
;
4581 entry
= (struct mips_got_entry
*) *entryp
;
4582 arg
= (struct mips_elf_traverse_got_arg
*) data
;
4583 slot
= htab_find_slot (arg
->g
->got_entries
, entry
, INSERT
);
4592 mips_elf_count_got_entry (arg
->info
, arg
->g
, entry
);
4597 /* A htab_traverse callback for GOT page entries. Add each one to the GOT
4598 given in mips_elf_traverse_got_arg DATA. Clear DATA->G on error. */
4601 mips_elf_add_got_page_entry (void **entryp
, void *data
)
4603 struct mips_got_page_entry
*entry
;
4604 struct mips_elf_traverse_got_arg
*arg
;
4607 entry
= (struct mips_got_page_entry
*) *entryp
;
4608 arg
= (struct mips_elf_traverse_got_arg
*) data
;
4609 slot
= htab_find_slot (arg
->g
->got_page_entries
, entry
, INSERT
);
4618 arg
->g
->page_gotno
+= entry
->num_pages
;
4623 /* Consider merging FROM, which is ABFD's GOT, into TO. Return -1 if
4624 this would lead to overflow, 1 if they were merged successfully,
4625 and 0 if a merge failed due to lack of memory. (These values are chosen
4626 so that nonnegative return values can be returned by a htab_traverse
4630 mips_elf_merge_got_with (bfd
*abfd
, struct mips_got_info
*from
,
4631 struct mips_got_info
*to
,
4632 struct mips_elf_got_per_bfd_arg
*arg
)
4634 struct mips_elf_traverse_got_arg tga
;
4635 unsigned int estimate
;
4637 /* Work out how many page entries we would need for the combined GOT. */
4638 estimate
= arg
->max_pages
;
4639 if (estimate
>= from
->page_gotno
+ to
->page_gotno
)
4640 estimate
= from
->page_gotno
+ to
->page_gotno
;
4642 /* And conservatively estimate how many local and TLS entries
4644 estimate
+= from
->local_gotno
+ to
->local_gotno
;
4645 estimate
+= from
->tls_gotno
+ to
->tls_gotno
;
4647 /* If we're merging with the primary got, any TLS relocations will
4648 come after the full set of global entries. Otherwise estimate those
4649 conservatively as well. */
4650 if (to
== arg
->primary
&& from
->tls_gotno
+ to
->tls_gotno
)
4651 estimate
+= arg
->global_count
;
4653 estimate
+= from
->global_gotno
+ to
->global_gotno
;
4655 /* Bail out if the combined GOT might be too big. */
4656 if (estimate
> arg
->max_count
)
4659 /* Transfer the bfd's got information from FROM to TO. */
4660 tga
.info
= arg
->info
;
4662 htab_traverse (from
->got_entries
, mips_elf_add_got_entry
, &tga
);
4666 htab_traverse (from
->got_page_entries
, mips_elf_add_got_page_entry
, &tga
);
4670 mips_elf_replace_bfd_got (abfd
, to
);
4674 /* Attempt to merge GOT G, which belongs to ABFD. Try to use as much
4675 as possible of the primary got, since it doesn't require explicit
4676 dynamic relocations, but don't use bfds that would reference global
4677 symbols out of the addressable range. Failing the primary got,
4678 attempt to merge with the current got, or finish the current got
4679 and then make make the new got current. */
4682 mips_elf_merge_got (bfd
*abfd
, struct mips_got_info
*g
,
4683 struct mips_elf_got_per_bfd_arg
*arg
)
4685 unsigned int estimate
;
4688 if (!mips_elf_resolve_final_got_entries (arg
->info
, g
))
4691 /* Work out the number of page, local and TLS entries. */
4692 estimate
= arg
->max_pages
;
4693 if (estimate
> g
->page_gotno
)
4694 estimate
= g
->page_gotno
;
4695 estimate
+= g
->local_gotno
+ g
->tls_gotno
;
4697 /* We place TLS GOT entries after both locals and globals. The globals
4698 for the primary GOT may overflow the normal GOT size limit, so be
4699 sure not to merge a GOT which requires TLS with the primary GOT in that
4700 case. This doesn't affect non-primary GOTs. */
4701 estimate
+= (g
->tls_gotno
> 0 ? arg
->global_count
: g
->global_gotno
);
4703 if (estimate
<= arg
->max_count
)
4705 /* If we don't have a primary GOT, use it as
4706 a starting point for the primary GOT. */
4713 /* Try merging with the primary GOT. */
4714 result
= mips_elf_merge_got_with (abfd
, g
, arg
->primary
, arg
);
4719 /* If we can merge with the last-created got, do it. */
4722 result
= mips_elf_merge_got_with (abfd
, g
, arg
->current
, arg
);
4727 /* Well, we couldn't merge, so create a new GOT. Don't check if it
4728 fits; if it turns out that it doesn't, we'll get relocation
4729 overflows anyway. */
4730 g
->next
= arg
->current
;
4736 /* ENTRYP is a hash table entry for a mips_got_entry. Set its gotidx
4737 to GOTIDX, duplicating the entry if it has already been assigned
4738 an index in a different GOT. */
4741 mips_elf_set_gotidx (void **entryp
, long gotidx
)
4743 struct mips_got_entry
*entry
;
4745 entry
= (struct mips_got_entry
*) *entryp
;
4746 if (entry
->gotidx
> 0)
4748 struct mips_got_entry
*new_entry
;
4750 new_entry
= bfd_alloc (entry
->abfd
, sizeof (*entry
));
4754 *new_entry
= *entry
;
4755 *entryp
= new_entry
;
4758 entry
->gotidx
= gotidx
;
4762 /* Set the TLS GOT index for the GOT entry in ENTRYP. DATA points to a
4763 mips_elf_traverse_got_arg in which DATA->value is the size of one
4764 GOT entry. Set DATA->g to null on failure. */
4767 mips_elf_initialize_tls_index (void **entryp
, void *data
)
4769 struct mips_got_entry
*entry
;
4770 struct mips_elf_traverse_got_arg
*arg
;
4772 /* We're only interested in TLS symbols. */
4773 entry
= (struct mips_got_entry
*) *entryp
;
4774 if (entry
->tls_type
== GOT_TLS_NONE
)
4777 arg
= (struct mips_elf_traverse_got_arg
*) data
;
4778 if (!mips_elf_set_gotidx (entryp
, arg
->value
* arg
->g
->tls_assigned_gotno
))
4784 /* Account for the entries we've just allocated. */
4785 arg
->g
->tls_assigned_gotno
+= mips_tls_got_entries (entry
->tls_type
);
4789 /* A htab_traverse callback for GOT entries, where DATA points to a
4790 mips_elf_traverse_got_arg. Set the global_got_area of each global
4791 symbol to DATA->value. */
4794 mips_elf_set_global_got_area (void **entryp
, void *data
)
4796 struct mips_got_entry
*entry
;
4797 struct mips_elf_traverse_got_arg
*arg
;
4799 entry
= (struct mips_got_entry
*) *entryp
;
4800 arg
= (struct mips_elf_traverse_got_arg
*) data
;
4801 if (entry
->abfd
!= NULL
4802 && entry
->symndx
== -1
4803 && entry
->d
.h
->global_got_area
!= GGA_NONE
)
4804 entry
->d
.h
->global_got_area
= arg
->value
;
4808 /* A htab_traverse callback for secondary GOT entries, where DATA points
4809 to a mips_elf_traverse_got_arg. Assign GOT indices to global entries
4810 and record the number of relocations they require. DATA->value is
4811 the size of one GOT entry. Set DATA->g to null on failure. */
4814 mips_elf_set_global_gotidx (void **entryp
, void *data
)
4816 struct mips_got_entry
*entry
;
4817 struct mips_elf_traverse_got_arg
*arg
;
4819 entry
= (struct mips_got_entry
*) *entryp
;
4820 arg
= (struct mips_elf_traverse_got_arg
*) data
;
4821 if (entry
->abfd
!= NULL
4822 && entry
->symndx
== -1
4823 && entry
->d
.h
->global_got_area
!= GGA_NONE
)
4825 if (!mips_elf_set_gotidx (entryp
, arg
->value
* arg
->g
->assigned_low_gotno
))
4830 arg
->g
->assigned_low_gotno
+= 1;
4832 if (bfd_link_pic (arg
->info
)
4833 || (elf_hash_table (arg
->info
)->dynamic_sections_created
4834 && entry
->d
.h
->root
.def_dynamic
4835 && !entry
->d
.h
->root
.def_regular
))
4836 arg
->g
->relocs
+= 1;
4842 /* A htab_traverse callback for GOT entries for which DATA is the
4843 bfd_link_info. Forbid any global symbols from having traditional
4844 lazy-binding stubs. */
4847 mips_elf_forbid_lazy_stubs (void **entryp
, void *data
)
4849 struct bfd_link_info
*info
;
4850 struct mips_elf_link_hash_table
*htab
;
4851 struct mips_got_entry
*entry
;
4853 entry
= (struct mips_got_entry
*) *entryp
;
4854 info
= (struct bfd_link_info
*) data
;
4855 htab
= mips_elf_hash_table (info
);
4856 BFD_ASSERT (htab
!= NULL
);
4858 if (entry
->abfd
!= NULL
4859 && entry
->symndx
== -1
4860 && entry
->d
.h
->needs_lazy_stub
)
4862 entry
->d
.h
->needs_lazy_stub
= FALSE
;
4863 htab
->lazy_stub_count
--;
4869 /* Return the offset of an input bfd IBFD's GOT from the beginning of
4872 mips_elf_adjust_gp (bfd
*abfd
, struct mips_got_info
*g
, bfd
*ibfd
)
4877 g
= mips_elf_bfd_got (ibfd
, FALSE
);
4881 BFD_ASSERT (g
->next
);
4885 return (g
->local_gotno
+ g
->global_gotno
+ g
->tls_gotno
)
4886 * MIPS_ELF_GOT_SIZE (abfd
);
4889 /* Turn a single GOT that is too big for 16-bit addressing into
4890 a sequence of GOTs, each one 16-bit addressable. */
4893 mips_elf_multi_got (bfd
*abfd
, struct bfd_link_info
*info
,
4894 asection
*got
, bfd_size_type pages
)
4896 struct mips_elf_link_hash_table
*htab
;
4897 struct mips_elf_got_per_bfd_arg got_per_bfd_arg
;
4898 struct mips_elf_traverse_got_arg tga
;
4899 struct mips_got_info
*g
, *gg
;
4900 unsigned int assign
, needed_relocs
;
4903 dynobj
= elf_hash_table (info
)->dynobj
;
4904 htab
= mips_elf_hash_table (info
);
4905 BFD_ASSERT (htab
!= NULL
);
4909 got_per_bfd_arg
.obfd
= abfd
;
4910 got_per_bfd_arg
.info
= info
;
4911 got_per_bfd_arg
.current
= NULL
;
4912 got_per_bfd_arg
.primary
= NULL
;
4913 got_per_bfd_arg
.max_count
= ((MIPS_ELF_GOT_MAX_SIZE (info
)
4914 / MIPS_ELF_GOT_SIZE (abfd
))
4915 - htab
->reserved_gotno
);
4916 got_per_bfd_arg
.max_pages
= pages
;
4917 /* The number of globals that will be included in the primary GOT.
4918 See the calls to mips_elf_set_global_got_area below for more
4920 got_per_bfd_arg
.global_count
= g
->global_gotno
;
4922 /* Try to merge the GOTs of input bfds together, as long as they
4923 don't seem to exceed the maximum GOT size, choosing one of them
4924 to be the primary GOT. */
4925 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
4927 gg
= mips_elf_bfd_got (ibfd
, FALSE
);
4928 if (gg
&& !mips_elf_merge_got (ibfd
, gg
, &got_per_bfd_arg
))
4932 /* If we do not find any suitable primary GOT, create an empty one. */
4933 if (got_per_bfd_arg
.primary
== NULL
)
4934 g
->next
= mips_elf_create_got_info (abfd
);
4936 g
->next
= got_per_bfd_arg
.primary
;
4937 g
->next
->next
= got_per_bfd_arg
.current
;
4939 /* GG is now the master GOT, and G is the primary GOT. */
4943 /* Map the output bfd to the primary got. That's what we're going
4944 to use for bfds that use GOT16 or GOT_PAGE relocations that we
4945 didn't mark in check_relocs, and we want a quick way to find it.
4946 We can't just use gg->next because we're going to reverse the
4948 mips_elf_replace_bfd_got (abfd
, g
);
4950 /* Every symbol that is referenced in a dynamic relocation must be
4951 present in the primary GOT, so arrange for them to appear after
4952 those that are actually referenced. */
4953 gg
->reloc_only_gotno
= gg
->global_gotno
- g
->global_gotno
;
4954 g
->global_gotno
= gg
->global_gotno
;
4957 tga
.value
= GGA_RELOC_ONLY
;
4958 htab_traverse (gg
->got_entries
, mips_elf_set_global_got_area
, &tga
);
4959 tga
.value
= GGA_NORMAL
;
4960 htab_traverse (g
->got_entries
, mips_elf_set_global_got_area
, &tga
);
4962 /* Now go through the GOTs assigning them offset ranges.
4963 [assigned_low_gotno, local_gotno[ will be set to the range of local
4964 entries in each GOT. We can then compute the end of a GOT by
4965 adding local_gotno to global_gotno. We reverse the list and make
4966 it circular since then we'll be able to quickly compute the
4967 beginning of a GOT, by computing the end of its predecessor. To
4968 avoid special cases for the primary GOT, while still preserving
4969 assertions that are valid for both single- and multi-got links,
4970 we arrange for the main got struct to have the right number of
4971 global entries, but set its local_gotno such that the initial
4972 offset of the primary GOT is zero. Remember that the primary GOT
4973 will become the last item in the circular linked list, so it
4974 points back to the master GOT. */
4975 gg
->local_gotno
= -g
->global_gotno
;
4976 gg
->global_gotno
= g
->global_gotno
;
4983 struct mips_got_info
*gn
;
4985 assign
+= htab
->reserved_gotno
;
4986 g
->assigned_low_gotno
= assign
;
4987 g
->local_gotno
+= assign
;
4988 g
->local_gotno
+= (pages
< g
->page_gotno
? pages
: g
->page_gotno
);
4989 g
->assigned_high_gotno
= g
->local_gotno
- 1;
4990 assign
= g
->local_gotno
+ g
->global_gotno
+ g
->tls_gotno
;
4992 /* Take g out of the direct list, and push it onto the reversed
4993 list that gg points to. g->next is guaranteed to be nonnull after
4994 this operation, as required by mips_elf_initialize_tls_index. */
4999 /* Set up any TLS entries. We always place the TLS entries after
5000 all non-TLS entries. */
5001 g
->tls_assigned_gotno
= g
->local_gotno
+ g
->global_gotno
;
5003 tga
.value
= MIPS_ELF_GOT_SIZE (abfd
);
5004 htab_traverse (g
->got_entries
, mips_elf_initialize_tls_index
, &tga
);
5007 BFD_ASSERT (g
->tls_assigned_gotno
== assign
);
5009 /* Move onto the next GOT. It will be a secondary GOT if nonull. */
5012 /* Forbid global symbols in every non-primary GOT from having
5013 lazy-binding stubs. */
5015 htab_traverse (g
->got_entries
, mips_elf_forbid_lazy_stubs
, info
);
5019 got
->size
= assign
* MIPS_ELF_GOT_SIZE (abfd
);
5022 for (g
= gg
->next
; g
&& g
->next
!= gg
; g
= g
->next
)
5024 unsigned int save_assign
;
5026 /* Assign offsets to global GOT entries and count how many
5027 relocations they need. */
5028 save_assign
= g
->assigned_low_gotno
;
5029 g
->assigned_low_gotno
= g
->local_gotno
;
5031 tga
.value
= MIPS_ELF_GOT_SIZE (abfd
);
5033 htab_traverse (g
->got_entries
, mips_elf_set_global_gotidx
, &tga
);
5036 BFD_ASSERT (g
->assigned_low_gotno
== g
->local_gotno
+ g
->global_gotno
);
5037 g
->assigned_low_gotno
= save_assign
;
5039 if (bfd_link_pic (info
))
5041 g
->relocs
+= g
->local_gotno
- g
->assigned_low_gotno
;
5042 BFD_ASSERT (g
->assigned_low_gotno
== g
->next
->local_gotno
5043 + g
->next
->global_gotno
5044 + g
->next
->tls_gotno
5045 + htab
->reserved_gotno
);
5047 needed_relocs
+= g
->relocs
;
5049 needed_relocs
+= g
->relocs
;
5052 mips_elf_allocate_dynamic_relocations (dynobj
, info
,
5059 /* Returns the first relocation of type r_type found, beginning with
5060 RELOCATION. RELEND is one-past-the-end of the relocation table. */
5062 static const Elf_Internal_Rela
*
5063 mips_elf_next_relocation (bfd
*abfd ATTRIBUTE_UNUSED
, unsigned int r_type
,
5064 const Elf_Internal_Rela
*relocation
,
5065 const Elf_Internal_Rela
*relend
)
5067 unsigned long r_symndx
= ELF_R_SYM (abfd
, relocation
->r_info
);
5069 while (relocation
< relend
)
5071 if (ELF_R_TYPE (abfd
, relocation
->r_info
) == r_type
5072 && ELF_R_SYM (abfd
, relocation
->r_info
) == r_symndx
)
5078 /* We didn't find it. */
5082 /* Return whether an input relocation is against a local symbol. */
5085 mips_elf_local_relocation_p (bfd
*input_bfd
,
5086 const Elf_Internal_Rela
*relocation
,
5087 asection
**local_sections
)
5089 unsigned long r_symndx
;
5090 Elf_Internal_Shdr
*symtab_hdr
;
5093 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
5094 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
5095 extsymoff
= (elf_bad_symtab (input_bfd
)) ? 0 : symtab_hdr
->sh_info
;
5097 if (r_symndx
< extsymoff
)
5099 if (elf_bad_symtab (input_bfd
) && local_sections
[r_symndx
] != NULL
)
5105 /* Sign-extend VALUE, which has the indicated number of BITS. */
5108 _bfd_mips_elf_sign_extend (bfd_vma value
, int bits
)
5110 if (value
& ((bfd_vma
) 1 << (bits
- 1)))
5111 /* VALUE is negative. */
5112 value
|= ((bfd_vma
) - 1) << bits
;
5117 /* Return non-zero if the indicated VALUE has overflowed the maximum
5118 range expressible by a signed number with the indicated number of
5122 mips_elf_overflow_p (bfd_vma value
, int bits
)
5124 bfd_signed_vma svalue
= (bfd_signed_vma
) value
;
5126 if (svalue
> (1 << (bits
- 1)) - 1)
5127 /* The value is too big. */
5129 else if (svalue
< -(1 << (bits
- 1)))
5130 /* The value is too small. */
5137 /* Calculate the %high function. */
5140 mips_elf_high (bfd_vma value
)
5142 return ((value
+ (bfd_vma
) 0x8000) >> 16) & 0xffff;
5145 /* Calculate the %higher function. */
5148 mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED
)
5151 return ((value
+ (bfd_vma
) 0x80008000) >> 32) & 0xffff;
5158 /* Calculate the %highest function. */
5161 mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED
)
5164 return ((value
+ (((bfd_vma
) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
5171 /* Create the .compact_rel section. */
5174 mips_elf_create_compact_rel_section
5175 (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
5178 register asection
*s
;
5180 if (bfd_get_linker_section (abfd
, ".compact_rel") == NULL
)
5182 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
5185 s
= bfd_make_section_anyway_with_flags (abfd
, ".compact_rel", flags
);
5187 || !bfd_set_section_alignment (s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
5190 s
->size
= sizeof (Elf32_External_compact_rel
);
5196 /* Create the .got section to hold the global offset table. */
5199 mips_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
5202 register asection
*s
;
5203 struct elf_link_hash_entry
*h
;
5204 struct bfd_link_hash_entry
*bh
;
5205 struct mips_elf_link_hash_table
*htab
;
5207 htab
= mips_elf_hash_table (info
);
5208 BFD_ASSERT (htab
!= NULL
);
5210 /* This function may be called more than once. */
5211 if (htab
->root
.sgot
)
5214 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
5215 | SEC_LINKER_CREATED
);
5217 /* We have to use an alignment of 2**4 here because this is hardcoded
5218 in the function stub generation and in the linker script. */
5219 s
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
5221 || !bfd_set_section_alignment (s
, 4))
5223 htab
->root
.sgot
= s
;
5225 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
5226 linker script because we don't want to define the symbol if we
5227 are not creating a global offset table. */
5229 if (! (_bfd_generic_link_add_one_symbol
5230 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
5231 0, NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
5234 h
= (struct elf_link_hash_entry
*) bh
;
5237 h
->type
= STT_OBJECT
;
5238 h
->other
= (h
->other
& ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN
;
5239 elf_hash_table (info
)->hgot
= h
;
5241 if (bfd_link_pic (info
)
5242 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
5245 htab
->got_info
= mips_elf_create_got_info (abfd
);
5246 mips_elf_section_data (s
)->elf
.this_hdr
.sh_flags
5247 |= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
5249 /* We also need a .got.plt section when generating PLTs. */
5250 s
= bfd_make_section_anyway_with_flags (abfd
, ".got.plt",
5251 SEC_ALLOC
| SEC_LOAD
5254 | SEC_LINKER_CREATED
);
5257 htab
->root
.sgotplt
= s
;
5262 /* Return true if H refers to the special VxWorks __GOTT_BASE__ or
5263 __GOTT_INDEX__ symbols. These symbols are only special for
5264 shared objects; they are not used in executables. */
5267 is_gott_symbol (struct bfd_link_info
*info
, struct elf_link_hash_entry
*h
)
5269 return (mips_elf_hash_table (info
)->is_vxworks
5270 && bfd_link_pic (info
)
5271 && (strcmp (h
->root
.root
.string
, "__GOTT_BASE__") == 0
5272 || strcmp (h
->root
.root
.string
, "__GOTT_INDEX__") == 0));
5275 /* Return TRUE if a relocation of type R_TYPE from INPUT_BFD might
5276 require an la25 stub. See also mips_elf_local_pic_function_p,
5277 which determines whether the destination function ever requires a
5281 mips_elf_relocation_needs_la25_stub (bfd
*input_bfd
, int r_type
,
5282 bfd_boolean target_is_16_bit_code_p
)
5284 /* We specifically ignore branches and jumps from EF_PIC objects,
5285 where the onus is on the compiler or programmer to perform any
5286 necessary initialization of $25. Sometimes such initialization
5287 is unnecessary; for example, -mno-shared functions do not use
5288 the incoming value of $25, and may therefore be called directly. */
5289 if (PIC_OBJECT_P (input_bfd
))
5296 case R_MIPS_PC21_S2
:
5297 case R_MIPS_PC26_S2
:
5298 case R_MICROMIPS_26_S1
:
5299 case R_MICROMIPS_PC7_S1
:
5300 case R_MICROMIPS_PC10_S1
:
5301 case R_MICROMIPS_PC16_S1
:
5302 case R_MICROMIPS_PC23_S2
:
5306 return !target_is_16_bit_code_p
;
5313 /* Obtain the field relocated by RELOCATION. */
5316 mips_elf_obtain_contents (reloc_howto_type
*howto
,
5317 const Elf_Internal_Rela
*relocation
,
5318 bfd
*input_bfd
, bfd_byte
*contents
)
5321 bfd_byte
*location
= contents
+ relocation
->r_offset
;
5322 unsigned int size
= bfd_get_reloc_size (howto
);
5324 /* Obtain the bytes. */
5326 x
= bfd_get (8 * size
, input_bfd
, location
);
5331 /* Store the field relocated by RELOCATION. */
5334 mips_elf_store_contents (reloc_howto_type
*howto
,
5335 const Elf_Internal_Rela
*relocation
,
5336 bfd
*input_bfd
, bfd_byte
*contents
, bfd_vma x
)
5338 bfd_byte
*location
= contents
+ relocation
->r_offset
;
5339 unsigned int size
= bfd_get_reloc_size (howto
);
5341 /* Put the value into the output. */
5343 bfd_put (8 * size
, input_bfd
, x
, location
);
5346 /* Try to patch a load from GOT instruction in CONTENTS pointed to by
5347 RELOCATION described by HOWTO, with a move of 0 to the load target
5348 register, returning TRUE if that is successful and FALSE otherwise.
5349 If DOIT is FALSE, then only determine it patching is possible and
5350 return status without actually changing CONTENTS.
5354 mips_elf_nullify_got_load (bfd
*input_bfd
, bfd_byte
*contents
,
5355 const Elf_Internal_Rela
*relocation
,
5356 reloc_howto_type
*howto
, bfd_boolean doit
)
5358 int r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
5359 bfd_byte
*location
= contents
+ relocation
->r_offset
;
5360 bfd_boolean nullified
= TRUE
;
5363 _bfd_mips_elf_reloc_unshuffle (input_bfd
, r_type
, FALSE
, location
);
5365 /* Obtain the current value. */
5366 x
= mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
);
5368 /* Note that in the unshuffled MIPS16 encoding RX is at bits [21:19]
5369 while RY is at bits [18:16] of the combined 32-bit instruction word. */
5370 if (mips16_reloc_p (r_type
)
5371 && (((x
>> 22) & 0x3ff) == 0x3d3 /* LW */
5372 || ((x
>> 22) & 0x3ff) == 0x3c7)) /* LD */
5373 x
= (0x3cd << 22) | (x
& (7 << 16)) << 3; /* LI */
5374 else if (micromips_reloc_p (r_type
)
5375 && ((x
>> 26) & 0x37) == 0x37) /* LW/LD */
5376 x
= (0xc << 26) | (x
& (0x1f << 21)); /* ADDIU */
5377 else if (((x
>> 26) & 0x3f) == 0x23 /* LW */
5378 || ((x
>> 26) & 0x3f) == 0x37) /* LD */
5379 x
= (0x9 << 26) | (x
& (0x1f << 16)); /* ADDIU */
5383 /* Put the value into the output. */
5384 if (doit
&& nullified
)
5385 mips_elf_store_contents (howto
, relocation
, input_bfd
, contents
, x
);
5387 _bfd_mips_elf_reloc_shuffle (input_bfd
, r_type
, FALSE
, location
);
5392 /* Calculate the value produced by the RELOCATION (which comes from
5393 the INPUT_BFD). The ADDEND is the addend to use for this
5394 RELOCATION; RELOCATION->R_ADDEND is ignored.
5396 The result of the relocation calculation is stored in VALUEP.
5397 On exit, set *CROSS_MODE_JUMP_P to true if the relocation field
5398 is a MIPS16 or microMIPS jump to standard MIPS code, or vice versa.
5400 This function returns bfd_reloc_continue if the caller need take no
5401 further action regarding this relocation, bfd_reloc_notsupported if
5402 something goes dramatically wrong, bfd_reloc_overflow if an
5403 overflow occurs, and bfd_reloc_ok to indicate success. */
5405 static bfd_reloc_status_type
5406 mips_elf_calculate_relocation (bfd
*abfd
, bfd
*input_bfd
,
5407 asection
*input_section
, bfd_byte
*contents
,
5408 struct bfd_link_info
*info
,
5409 const Elf_Internal_Rela
*relocation
,
5410 bfd_vma addend
, reloc_howto_type
*howto
,
5411 Elf_Internal_Sym
*local_syms
,
5412 asection
**local_sections
, bfd_vma
*valuep
,
5414 bfd_boolean
*cross_mode_jump_p
,
5415 bfd_boolean save_addend
)
5417 /* The eventual value we will return. */
5419 /* The address of the symbol against which the relocation is
5422 /* The final GP value to be used for the relocatable, executable, or
5423 shared object file being produced. */
5425 /* The place (section offset or address) of the storage unit being
5428 /* The value of GP used to create the relocatable object. */
5430 /* The offset into the global offset table at which the address of
5431 the relocation entry symbol, adjusted by the addend, resides
5432 during execution. */
5433 bfd_vma g
= MINUS_ONE
;
5434 /* The section in which the symbol referenced by the relocation is
5436 asection
*sec
= NULL
;
5437 struct mips_elf_link_hash_entry
*h
= NULL
;
5438 /* TRUE if the symbol referred to by this relocation is a local
5440 bfd_boolean local_p
, was_local_p
;
5441 /* TRUE if the symbol referred to by this relocation is a section
5443 bfd_boolean section_p
= FALSE
;
5444 /* TRUE if the symbol referred to by this relocation is "_gp_disp". */
5445 bfd_boolean gp_disp_p
= FALSE
;
5446 /* TRUE if the symbol referred to by this relocation is
5447 "__gnu_local_gp". */
5448 bfd_boolean gnu_local_gp_p
= FALSE
;
5449 Elf_Internal_Shdr
*symtab_hdr
;
5451 unsigned long r_symndx
;
5453 /* TRUE if overflow occurred during the calculation of the
5454 relocation value. */
5455 bfd_boolean overflowed_p
;
5456 /* TRUE if this relocation refers to a MIPS16 function. */
5457 bfd_boolean target_is_16_bit_code_p
= FALSE
;
5458 bfd_boolean target_is_micromips_code_p
= FALSE
;
5459 struct mips_elf_link_hash_table
*htab
;
5461 bfd_boolean resolved_to_zero
;
5463 dynobj
= elf_hash_table (info
)->dynobj
;
5464 htab
= mips_elf_hash_table (info
);
5465 BFD_ASSERT (htab
!= NULL
);
5467 /* Parse the relocation. */
5468 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
5469 r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
5470 p
= (input_section
->output_section
->vma
5471 + input_section
->output_offset
5472 + relocation
->r_offset
);
5474 /* Assume that there will be no overflow. */
5475 overflowed_p
= FALSE
;
5477 /* Figure out whether or not the symbol is local, and get the offset
5478 used in the array of hash table entries. */
5479 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
5480 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
5482 was_local_p
= local_p
;
5483 if (! elf_bad_symtab (input_bfd
))
5484 extsymoff
= symtab_hdr
->sh_info
;
5487 /* The symbol table does not follow the rule that local symbols
5488 must come before globals. */
5492 /* Figure out the value of the symbol. */
5495 bfd_boolean micromips_p
= MICROMIPS_P (abfd
);
5496 Elf_Internal_Sym
*sym
;
5498 sym
= local_syms
+ r_symndx
;
5499 sec
= local_sections
[r_symndx
];
5501 section_p
= ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
;
5503 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
5504 if (!section_p
|| (sec
->flags
& SEC_MERGE
))
5505 symbol
+= sym
->st_value
;
5506 if ((sec
->flags
& SEC_MERGE
) && section_p
)
5508 addend
= _bfd_elf_rel_local_sym (abfd
, sym
, &sec
, addend
);
5510 addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
5513 /* MIPS16/microMIPS text labels should be treated as odd. */
5514 if (ELF_ST_IS_COMPRESSED (sym
->st_other
))
5517 /* Record the name of this symbol, for our caller. */
5518 *namep
= bfd_elf_string_from_elf_section (input_bfd
,
5519 symtab_hdr
->sh_link
,
5521 if (*namep
== NULL
|| **namep
== '\0')
5522 *namep
= bfd_section_name (sec
);
5524 /* For relocations against a section symbol and ones against no
5525 symbol (absolute relocations) infer the ISA mode from the addend. */
5526 if (section_p
|| r_symndx
== STN_UNDEF
)
5528 target_is_16_bit_code_p
= (addend
& 1) && !micromips_p
;
5529 target_is_micromips_code_p
= (addend
& 1) && micromips_p
;
5531 /* For relocations against an absolute symbol infer the ISA mode
5532 from the value of the symbol plus addend. */
5533 else if (bfd_is_abs_section (sec
))
5535 target_is_16_bit_code_p
= ((symbol
+ addend
) & 1) && !micromips_p
;
5536 target_is_micromips_code_p
= ((symbol
+ addend
) & 1) && micromips_p
;
5538 /* Otherwise just use the regular symbol annotation available. */
5541 target_is_16_bit_code_p
= ELF_ST_IS_MIPS16 (sym
->st_other
);
5542 target_is_micromips_code_p
= ELF_ST_IS_MICROMIPS (sym
->st_other
);
5547 /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ? */
5549 /* For global symbols we look up the symbol in the hash-table. */
5550 h
= ((struct mips_elf_link_hash_entry
*)
5551 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
]);
5552 /* Find the real hash-table entry for this symbol. */
5553 while (h
->root
.root
.type
== bfd_link_hash_indirect
5554 || h
->root
.root
.type
== bfd_link_hash_warning
)
5555 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
5557 /* Record the name of this symbol, for our caller. */
5558 *namep
= h
->root
.root
.root
.string
;
5560 /* See if this is the special _gp_disp symbol. Note that such a
5561 symbol must always be a global symbol. */
5562 if (strcmp (*namep
, "_gp_disp") == 0
5563 && ! NEWABI_P (input_bfd
))
5565 /* Relocations against _gp_disp are permitted only with
5566 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
5567 if (!hi16_reloc_p (r_type
) && !lo16_reloc_p (r_type
))
5568 return bfd_reloc_notsupported
;
5572 /* See if this is the special _gp symbol. Note that such a
5573 symbol must always be a global symbol. */
5574 else if (strcmp (*namep
, "__gnu_local_gp") == 0)
5575 gnu_local_gp_p
= TRUE
;
5578 /* If this symbol is defined, calculate its address. Note that
5579 _gp_disp is a magic symbol, always implicitly defined by the
5580 linker, so it's inappropriate to check to see whether or not
5582 else if ((h
->root
.root
.type
== bfd_link_hash_defined
5583 || h
->root
.root
.type
== bfd_link_hash_defweak
)
5584 && h
->root
.root
.u
.def
.section
)
5586 sec
= h
->root
.root
.u
.def
.section
;
5587 if (sec
->output_section
)
5588 symbol
= (h
->root
.root
.u
.def
.value
5589 + sec
->output_section
->vma
5590 + sec
->output_offset
);
5592 symbol
= h
->root
.root
.u
.def
.value
;
5594 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
5595 /* We allow relocations against undefined weak symbols, giving
5596 it the value zero, so that you can undefined weak functions
5597 and check to see if they exist by looking at their
5600 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
5601 && ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
5603 else if (strcmp (*namep
, SGI_COMPAT (input_bfd
)
5604 ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING") == 0)
5606 /* If this is a dynamic link, we should have created a
5607 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
5608 in _bfd_mips_elf_create_dynamic_sections.
5609 Otherwise, we should define the symbol with a value of 0.
5610 FIXME: It should probably get into the symbol table
5612 BFD_ASSERT (! bfd_link_pic (info
));
5613 BFD_ASSERT (bfd_get_section_by_name (abfd
, ".dynamic") == NULL
);
5616 else if (ELF_MIPS_IS_OPTIONAL (h
->root
.other
))
5618 /* This is an optional symbol - an Irix specific extension to the
5619 ELF spec. Ignore it for now.
5620 XXX - FIXME - there is more to the spec for OPTIONAL symbols
5621 than simply ignoring them, but we do not handle this for now.
5622 For information see the "64-bit ELF Object File Specification"
5623 which is available from here:
5624 http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf */
5629 bfd_boolean reject_undefined
5630 = (info
->unresolved_syms_in_objects
== RM_DIAGNOSE
5631 && !info
->warn_unresolved_syms
)
5632 || ELF_ST_VISIBILITY (h
->root
.other
) != STV_DEFAULT
;
5634 info
->callbacks
->undefined_symbol
5635 (info
, h
->root
.root
.root
.string
, input_bfd
,
5636 input_section
, relocation
->r_offset
, reject_undefined
);
5638 if (reject_undefined
)
5639 return bfd_reloc_undefined
;
5644 target_is_16_bit_code_p
= ELF_ST_IS_MIPS16 (h
->root
.other
);
5645 target_is_micromips_code_p
= ELF_ST_IS_MICROMIPS (h
->root
.other
);
5648 /* If this is a reference to a 16-bit function with a stub, we need
5649 to redirect the relocation to the stub unless:
5651 (a) the relocation is for a MIPS16 JAL;
5653 (b) the relocation is for a MIPS16 PIC call, and there are no
5654 non-MIPS16 uses of the GOT slot; or
5656 (c) the section allows direct references to MIPS16 functions. */
5657 if (r_type
!= R_MIPS16_26
5658 && !bfd_link_relocatable (info
)
5660 && h
->fn_stub
!= NULL
5661 && (r_type
!= R_MIPS16_CALL16
|| h
->need_fn_stub
))
5663 && mips_elf_tdata (input_bfd
)->local_stubs
!= NULL
5664 && mips_elf_tdata (input_bfd
)->local_stubs
[r_symndx
] != NULL
))
5665 && !section_allows_mips16_refs_p (input_section
))
5667 /* This is a 32- or 64-bit call to a 16-bit function. We should
5668 have already noticed that we were going to need the
5672 sec
= mips_elf_tdata (input_bfd
)->local_stubs
[r_symndx
];
5677 BFD_ASSERT (h
->need_fn_stub
);
5680 /* If a LA25 header for the stub itself exists, point to the
5681 prepended LUI/ADDIU sequence. */
5682 sec
= h
->la25_stub
->stub_section
;
5683 value
= h
->la25_stub
->offset
;
5692 symbol
= sec
->output_section
->vma
+ sec
->output_offset
+ value
;
5693 /* The target is 16-bit, but the stub isn't. */
5694 target_is_16_bit_code_p
= FALSE
;
5696 /* If this is a MIPS16 call with a stub, that is made through the PLT or
5697 to a standard MIPS function, we need to redirect the call to the stub.
5698 Note that we specifically exclude R_MIPS16_CALL16 from this behavior;
5699 indirect calls should use an indirect stub instead. */
5700 else if (r_type
== R_MIPS16_26
&& !bfd_link_relocatable (info
)
5701 && ((h
!= NULL
&& (h
->call_stub
!= NULL
|| h
->call_fp_stub
!= NULL
))
5703 && mips_elf_tdata (input_bfd
)->local_call_stubs
!= NULL
5704 && mips_elf_tdata (input_bfd
)->local_call_stubs
[r_symndx
] != NULL
))
5705 && ((h
!= NULL
&& h
->use_plt_entry
) || !target_is_16_bit_code_p
))
5708 sec
= mips_elf_tdata (input_bfd
)->local_call_stubs
[r_symndx
];
5711 /* If both call_stub and call_fp_stub are defined, we can figure
5712 out which one to use by checking which one appears in the input
5714 if (h
->call_stub
!= NULL
&& h
->call_fp_stub
!= NULL
)
5719 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
5721 if (CALL_FP_STUB_P (bfd_section_name (o
)))
5723 sec
= h
->call_fp_stub
;
5730 else if (h
->call_stub
!= NULL
)
5733 sec
= h
->call_fp_stub
;
5736 BFD_ASSERT (sec
->size
> 0);
5737 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
5739 /* If this is a direct call to a PIC function, redirect to the
5741 else if (h
!= NULL
&& h
->la25_stub
5742 && mips_elf_relocation_needs_la25_stub (input_bfd
, r_type
,
5743 target_is_16_bit_code_p
))
5745 symbol
= (h
->la25_stub
->stub_section
->output_section
->vma
5746 + h
->la25_stub
->stub_section
->output_offset
5747 + h
->la25_stub
->offset
);
5748 if (ELF_ST_IS_MICROMIPS (h
->root
.other
))
5751 /* For direct MIPS16 and microMIPS calls make sure the compressed PLT
5752 entry is used if a standard PLT entry has also been made. In this
5753 case the symbol will have been set by mips_elf_set_plt_sym_value
5754 to point to the standard PLT entry, so redirect to the compressed
5756 else if ((mips16_branch_reloc_p (r_type
)
5757 || micromips_branch_reloc_p (r_type
))
5758 && !bfd_link_relocatable (info
)
5761 && h
->root
.plt
.plist
->comp_offset
!= MINUS_ONE
5762 && h
->root
.plt
.plist
->mips_offset
!= MINUS_ONE
)
5764 bfd_boolean micromips_p
= MICROMIPS_P (abfd
);
5766 sec
= htab
->root
.splt
;
5767 symbol
= (sec
->output_section
->vma
5768 + sec
->output_offset
5769 + htab
->plt_header_size
5770 + htab
->plt_mips_offset
5771 + h
->root
.plt
.plist
->comp_offset
5774 target_is_16_bit_code_p
= !micromips_p
;
5775 target_is_micromips_code_p
= micromips_p
;
5778 /* Make sure MIPS16 and microMIPS are not used together. */
5779 if ((mips16_branch_reloc_p (r_type
) && target_is_micromips_code_p
)
5780 || (micromips_branch_reloc_p (r_type
) && target_is_16_bit_code_p
))
5783 (_("MIPS16 and microMIPS functions cannot call each other"));
5784 return bfd_reloc_notsupported
;
5787 /* Calls from 16-bit code to 32-bit code and vice versa require the
5788 mode change. However, we can ignore calls to undefined weak symbols,
5789 which should never be executed at runtime. This exception is important
5790 because the assembly writer may have "known" that any definition of the
5791 symbol would be 16-bit code, and that direct jumps were therefore
5793 *cross_mode_jump_p
= (!bfd_link_relocatable (info
)
5794 && !(h
&& h
->root
.root
.type
== bfd_link_hash_undefweak
)
5795 && ((mips16_branch_reloc_p (r_type
)
5796 && !target_is_16_bit_code_p
)
5797 || (micromips_branch_reloc_p (r_type
)
5798 && !target_is_micromips_code_p
)
5799 || ((branch_reloc_p (r_type
)
5800 || r_type
== R_MIPS_JALR
)
5801 && (target_is_16_bit_code_p
5802 || target_is_micromips_code_p
))));
5804 resolved_to_zero
= (h
!= NULL
5805 && UNDEFWEAK_NO_DYNAMIC_RELOC (info
, &h
->root
));
5809 case R_MIPS16_CALL16
:
5810 case R_MIPS16_GOT16
:
5813 case R_MIPS_GOT_PAGE
:
5814 case R_MIPS_GOT_DISP
:
5815 case R_MIPS_GOT_LO16
:
5816 case R_MIPS_CALL_LO16
:
5817 case R_MICROMIPS_CALL16
:
5818 case R_MICROMIPS_GOT16
:
5819 case R_MICROMIPS_GOT_PAGE
:
5820 case R_MICROMIPS_GOT_DISP
:
5821 case R_MICROMIPS_GOT_LO16
:
5822 case R_MICROMIPS_CALL_LO16
:
5823 if (resolved_to_zero
5824 && !bfd_link_relocatable (info
)
5825 && mips_elf_nullify_got_load (input_bfd
, contents
,
5826 relocation
, howto
, TRUE
))
5827 return bfd_reloc_continue
;
5830 case R_MIPS_GOT_HI16
:
5831 case R_MIPS_CALL_HI16
:
5832 case R_MICROMIPS_GOT_HI16
:
5833 case R_MICROMIPS_CALL_HI16
:
5834 if (resolved_to_zero
5835 && htab
->use_absolute_zero
5836 && bfd_link_pic (info
))
5838 /* Redirect to the special `__gnu_absolute_zero' symbol. */
5839 h
= mips_elf_link_hash_lookup (htab
, "__gnu_absolute_zero",
5840 FALSE
, FALSE
, FALSE
);
5841 BFD_ASSERT (h
!= NULL
);
5846 local_p
= (h
== NULL
|| mips_use_local_got_p (info
, h
));
5848 gp0
= _bfd_get_gp_value (input_bfd
);
5849 gp
= _bfd_get_gp_value (abfd
);
5851 gp
+= mips_elf_adjust_gp (abfd
, htab
->got_info
, input_bfd
);
5856 /* Global R_MIPS_GOT_PAGE/R_MICROMIPS_GOT_PAGE relocations are equivalent
5857 to R_MIPS_GOT_DISP/R_MICROMIPS_GOT_DISP. The addend is applied by the
5858 corresponding R_MIPS_GOT_OFST/R_MICROMIPS_GOT_OFST. */
5859 if (got_page_reloc_p (r_type
) && !local_p
)
5861 r_type
= (micromips_reloc_p (r_type
)
5862 ? R_MICROMIPS_GOT_DISP
: R_MIPS_GOT_DISP
);
5866 /* If we haven't already determined the GOT offset, and we're going
5867 to need it, get it now. */
5870 case R_MIPS16_CALL16
:
5871 case R_MIPS16_GOT16
:
5874 case R_MIPS_GOT_DISP
:
5875 case R_MIPS_GOT_HI16
:
5876 case R_MIPS_CALL_HI16
:
5877 case R_MIPS_GOT_LO16
:
5878 case R_MIPS_CALL_LO16
:
5879 case R_MICROMIPS_CALL16
:
5880 case R_MICROMIPS_GOT16
:
5881 case R_MICROMIPS_GOT_DISP
:
5882 case R_MICROMIPS_GOT_HI16
:
5883 case R_MICROMIPS_CALL_HI16
:
5884 case R_MICROMIPS_GOT_LO16
:
5885 case R_MICROMIPS_CALL_LO16
:
5887 case R_MIPS_TLS_GOTTPREL
:
5888 case R_MIPS_TLS_LDM
:
5889 case R_MIPS16_TLS_GD
:
5890 case R_MIPS16_TLS_GOTTPREL
:
5891 case R_MIPS16_TLS_LDM
:
5892 case R_MICROMIPS_TLS_GD
:
5893 case R_MICROMIPS_TLS_GOTTPREL
:
5894 case R_MICROMIPS_TLS_LDM
:
5895 /* Find the index into the GOT where this value is located. */
5896 if (tls_ldm_reloc_p (r_type
))
5898 g
= mips_elf_local_got_index (abfd
, input_bfd
, info
,
5899 0, 0, NULL
, r_type
);
5901 return bfd_reloc_outofrange
;
5905 /* On VxWorks, CALL relocations should refer to the .got.plt
5906 entry, which is initialized to point at the PLT stub. */
5907 if (htab
->is_vxworks
5908 && (call_hi16_reloc_p (r_type
)
5909 || call_lo16_reloc_p (r_type
)
5910 || call16_reloc_p (r_type
)))
5912 BFD_ASSERT (addend
== 0);
5913 BFD_ASSERT (h
->root
.needs_plt
);
5914 g
= mips_elf_gotplt_index (info
, &h
->root
);
5918 BFD_ASSERT (addend
== 0);
5919 g
= mips_elf_global_got_index (abfd
, info
, input_bfd
,
5921 if (!TLS_RELOC_P (r_type
)
5922 && !elf_hash_table (info
)->dynamic_sections_created
)
5923 /* This is a static link. We must initialize the GOT entry. */
5924 MIPS_ELF_PUT_WORD (dynobj
, symbol
, htab
->root
.sgot
->contents
+ g
);
5927 else if (!htab
->is_vxworks
5928 && (call16_reloc_p (r_type
) || got16_reloc_p (r_type
)))
5929 /* The calculation below does not involve "g". */
5933 g
= mips_elf_local_got_index (abfd
, input_bfd
, info
,
5934 symbol
+ addend
, r_symndx
, h
, r_type
);
5936 return bfd_reloc_outofrange
;
5939 /* Convert GOT indices to actual offsets. */
5940 g
= mips_elf_got_offset_from_index (info
, abfd
, input_bfd
, g
);
5944 /* Relocations against the VxWorks __GOTT_BASE__ and __GOTT_INDEX__
5945 symbols are resolved by the loader. Add them to .rela.dyn. */
5946 if (h
!= NULL
&& is_gott_symbol (info
, &h
->root
))
5948 Elf_Internal_Rela outrel
;
5952 s
= mips_elf_rel_dyn_section (info
, FALSE
);
5953 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
5955 outrel
.r_offset
= (input_section
->output_section
->vma
5956 + input_section
->output_offset
5957 + relocation
->r_offset
);
5958 outrel
.r_info
= ELF32_R_INFO (h
->root
.dynindx
, r_type
);
5959 outrel
.r_addend
= addend
;
5960 bfd_elf32_swap_reloca_out (abfd
, &outrel
, loc
);
5962 /* If we've written this relocation for a readonly section,
5963 we need to set DF_TEXTREL again, so that we do not delete the
5965 if (MIPS_ELF_READONLY_SECTION (input_section
))
5966 info
->flags
|= DF_TEXTREL
;
5969 return bfd_reloc_ok
;
5972 /* Figure out what kind of relocation is being performed. */
5976 return bfd_reloc_continue
;
5979 if (howto
->partial_inplace
)
5980 addend
= _bfd_mips_elf_sign_extend (addend
, 16);
5981 value
= symbol
+ addend
;
5982 overflowed_p
= mips_elf_overflow_p (value
, 16);
5988 if ((bfd_link_pic (info
)
5989 || (htab
->root
.dynamic_sections_created
5991 && h
->root
.def_dynamic
5992 && !h
->root
.def_regular
5993 && !h
->has_static_relocs
))
5994 && r_symndx
!= STN_UNDEF
5996 || h
->root
.root
.type
!= bfd_link_hash_undefweak
5997 || (ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
5998 && !resolved_to_zero
))
5999 && (input_section
->flags
& SEC_ALLOC
) != 0)
6001 /* If we're creating a shared library, then we can't know
6002 where the symbol will end up. So, we create a relocation
6003 record in the output, and leave the job up to the dynamic
6004 linker. We must do the same for executable references to
6005 shared library symbols, unless we've decided to use copy
6006 relocs or PLTs instead. */
6008 if (!mips_elf_create_dynamic_relocation (abfd
,
6016 return bfd_reloc_undefined
;
6020 if (r_type
!= R_MIPS_REL32
)
6021 value
= symbol
+ addend
;
6025 value
&= howto
->dst_mask
;
6029 value
= symbol
+ addend
- p
;
6030 value
&= howto
->dst_mask
;
6034 /* The calculation for R_MIPS16_26 is just the same as for an
6035 R_MIPS_26. It's only the storage of the relocated field into
6036 the output file that's different. That's handled in
6037 mips_elf_perform_relocation. So, we just fall through to the
6038 R_MIPS_26 case here. */
6040 case R_MICROMIPS_26_S1
:
6044 /* Shift is 2, unusually, for microMIPS JALX. */
6045 shift
= (!*cross_mode_jump_p
&& r_type
== R_MICROMIPS_26_S1
) ? 1 : 2;
6047 if (howto
->partial_inplace
&& !section_p
)
6048 value
= _bfd_mips_elf_sign_extend (addend
, 26 + shift
);
6053 /* Make sure the target of a jump is suitably aligned. Bit 0 must
6054 be the correct ISA mode selector except for weak undefined
6056 if ((was_local_p
|| h
->root
.root
.type
!= bfd_link_hash_undefweak
)
6057 && (*cross_mode_jump_p
6058 ? (value
& 3) != (r_type
== R_MIPS_26
)
6059 : (value
& ((1 << shift
) - 1)) != (r_type
!= R_MIPS_26
)))
6060 return bfd_reloc_outofrange
;
6063 if (was_local_p
|| h
->root
.root
.type
!= bfd_link_hash_undefweak
)
6064 overflowed_p
= (value
>> 26) != ((p
+ 4) >> (26 + shift
));
6065 value
&= howto
->dst_mask
;
6069 case R_MIPS_TLS_DTPREL_HI16
:
6070 case R_MIPS16_TLS_DTPREL_HI16
:
6071 case R_MICROMIPS_TLS_DTPREL_HI16
:
6072 value
= (mips_elf_high (addend
+ symbol
- dtprel_base (info
))
6076 case R_MIPS_TLS_DTPREL_LO16
:
6077 case R_MIPS_TLS_DTPREL32
:
6078 case R_MIPS_TLS_DTPREL64
:
6079 case R_MIPS16_TLS_DTPREL_LO16
:
6080 case R_MICROMIPS_TLS_DTPREL_LO16
:
6081 value
= (symbol
+ addend
- dtprel_base (info
)) & howto
->dst_mask
;
6084 case R_MIPS_TLS_TPREL_HI16
:
6085 case R_MIPS16_TLS_TPREL_HI16
:
6086 case R_MICROMIPS_TLS_TPREL_HI16
:
6087 value
= (mips_elf_high (addend
+ symbol
- tprel_base (info
))
6091 case R_MIPS_TLS_TPREL_LO16
:
6092 case R_MIPS_TLS_TPREL32
:
6093 case R_MIPS_TLS_TPREL64
:
6094 case R_MIPS16_TLS_TPREL_LO16
:
6095 case R_MICROMIPS_TLS_TPREL_LO16
:
6096 value
= (symbol
+ addend
- tprel_base (info
)) & howto
->dst_mask
;
6101 case R_MICROMIPS_HI16
:
6104 value
= mips_elf_high (addend
+ symbol
);
6105 value
&= howto
->dst_mask
;
6109 /* For MIPS16 ABI code we generate this sequence
6110 0: li $v0,%hi(_gp_disp)
6111 4: addiupc $v1,%lo(_gp_disp)
6115 So the offsets of hi and lo relocs are the same, but the
6116 base $pc is that used by the ADDIUPC instruction at $t9 + 4.
6117 ADDIUPC clears the low two bits of the instruction address,
6118 so the base is ($t9 + 4) & ~3. */
6119 if (r_type
== R_MIPS16_HI16
)
6120 value
= mips_elf_high (addend
+ gp
- ((p
+ 4) & ~(bfd_vma
) 0x3));
6121 /* The microMIPS .cpload sequence uses the same assembly
6122 instructions as the traditional psABI version, but the
6123 incoming $t9 has the low bit set. */
6124 else if (r_type
== R_MICROMIPS_HI16
)
6125 value
= mips_elf_high (addend
+ gp
- p
- 1);
6127 value
= mips_elf_high (addend
+ gp
- p
);
6133 case R_MICROMIPS_LO16
:
6134 case R_MICROMIPS_HI0_LO16
:
6136 value
= (symbol
+ addend
) & howto
->dst_mask
;
6139 /* See the comment for R_MIPS16_HI16 above for the reason
6140 for this conditional. */
6141 if (r_type
== R_MIPS16_LO16
)
6142 value
= addend
+ gp
- (p
& ~(bfd_vma
) 0x3);
6143 else if (r_type
== R_MICROMIPS_LO16
6144 || r_type
== R_MICROMIPS_HI0_LO16
)
6145 value
= addend
+ gp
- p
+ 3;
6147 value
= addend
+ gp
- p
+ 4;
6148 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
6149 for overflow. But, on, say, IRIX5, relocations against
6150 _gp_disp are normally generated from the .cpload
6151 pseudo-op. It generates code that normally looks like
6154 lui $gp,%hi(_gp_disp)
6155 addiu $gp,$gp,%lo(_gp_disp)
6158 Here $t9 holds the address of the function being called,
6159 as required by the MIPS ELF ABI. The R_MIPS_LO16
6160 relocation can easily overflow in this situation, but the
6161 R_MIPS_HI16 relocation will handle the overflow.
6162 Therefore, we consider this a bug in the MIPS ABI, and do
6163 not check for overflow here. */
6167 case R_MIPS_LITERAL
:
6168 case R_MICROMIPS_LITERAL
:
6169 /* Because we don't merge literal sections, we can handle this
6170 just like R_MIPS_GPREL16. In the long run, we should merge
6171 shared literals, and then we will need to additional work
6176 case R_MIPS16_GPREL
:
6177 /* The R_MIPS16_GPREL performs the same calculation as
6178 R_MIPS_GPREL16, but stores the relocated bits in a different
6179 order. We don't need to do anything special here; the
6180 differences are handled in mips_elf_perform_relocation. */
6181 case R_MIPS_GPREL16
:
6182 case R_MICROMIPS_GPREL7_S2
:
6183 case R_MICROMIPS_GPREL16
:
6184 /* Only sign-extend the addend if it was extracted from the
6185 instruction. If the addend was separate, leave it alone,
6186 otherwise we may lose significant bits. */
6187 if (howto
->partial_inplace
)
6188 addend
= _bfd_mips_elf_sign_extend (addend
, 16);
6189 value
= symbol
+ addend
- gp
;
6190 /* If the symbol was local, any earlier relocatable links will
6191 have adjusted its addend with the gp offset, so compensate
6192 for that now. Don't do it for symbols forced local in this
6193 link, though, since they won't have had the gp offset applied
6197 if (was_local_p
|| h
->root
.root
.type
!= bfd_link_hash_undefweak
)
6198 overflowed_p
= mips_elf_overflow_p (value
, 16);
6201 case R_MIPS16_GOT16
:
6202 case R_MIPS16_CALL16
:
6205 case R_MICROMIPS_GOT16
:
6206 case R_MICROMIPS_CALL16
:
6207 /* VxWorks does not have separate local and global semantics for
6208 R_MIPS*_GOT16; every relocation evaluates to "G". */
6209 if (!htab
->is_vxworks
&& local_p
)
6211 value
= mips_elf_got16_entry (abfd
, input_bfd
, info
,
6212 symbol
+ addend
, !was_local_p
);
6213 if (value
== MINUS_ONE
)
6214 return bfd_reloc_outofrange
;
6216 = mips_elf_got_offset_from_index (info
, abfd
, input_bfd
, value
);
6217 overflowed_p
= mips_elf_overflow_p (value
, 16);
6224 case R_MIPS_TLS_GOTTPREL
:
6225 case R_MIPS_TLS_LDM
:
6226 case R_MIPS_GOT_DISP
:
6227 case R_MIPS16_TLS_GD
:
6228 case R_MIPS16_TLS_GOTTPREL
:
6229 case R_MIPS16_TLS_LDM
:
6230 case R_MICROMIPS_TLS_GD
:
6231 case R_MICROMIPS_TLS_GOTTPREL
:
6232 case R_MICROMIPS_TLS_LDM
:
6233 case R_MICROMIPS_GOT_DISP
:
6235 overflowed_p
= mips_elf_overflow_p (value
, 16);
6238 case R_MIPS_GPREL32
:
6239 value
= (addend
+ symbol
+ gp0
- gp
);
6241 value
&= howto
->dst_mask
;
6245 case R_MIPS_GNU_REL16_S2
:
6246 if (howto
->partial_inplace
)
6247 addend
= _bfd_mips_elf_sign_extend (addend
, 18);
6249 /* No need to exclude weak undefined symbols here as they resolve
6250 to 0 and never set `*cross_mode_jump_p', so this alignment check
6251 will never trigger for them. */
6252 if (*cross_mode_jump_p
6253 ? ((symbol
+ addend
) & 3) != 1
6254 : ((symbol
+ addend
) & 3) != 0)
6255 return bfd_reloc_outofrange
;
6257 value
= symbol
+ addend
- p
;
6258 if (was_local_p
|| h
->root
.root
.type
!= bfd_link_hash_undefweak
)
6259 overflowed_p
= mips_elf_overflow_p (value
, 18);
6260 value
>>= howto
->rightshift
;
6261 value
&= howto
->dst_mask
;
6264 case R_MIPS16_PC16_S1
:
6265 if (howto
->partial_inplace
)
6266 addend
= _bfd_mips_elf_sign_extend (addend
, 17);
6268 if ((was_local_p
|| h
->root
.root
.type
!= bfd_link_hash_undefweak
)
6269 && (*cross_mode_jump_p
6270 ? ((symbol
+ addend
) & 3) != 0
6271 : ((symbol
+ addend
) & 1) == 0))
6272 return bfd_reloc_outofrange
;
6274 value
= symbol
+ addend
- p
;
6275 if (was_local_p
|| h
->root
.root
.type
!= bfd_link_hash_undefweak
)
6276 overflowed_p
= mips_elf_overflow_p (value
, 17);
6277 value
>>= howto
->rightshift
;
6278 value
&= howto
->dst_mask
;
6281 case R_MIPS_PC21_S2
:
6282 if (howto
->partial_inplace
)
6283 addend
= _bfd_mips_elf_sign_extend (addend
, 23);
6285 if ((symbol
+ addend
) & 3)
6286 return bfd_reloc_outofrange
;
6288 value
= symbol
+ addend
- p
;
6289 if (was_local_p
|| h
->root
.root
.type
!= bfd_link_hash_undefweak
)
6290 overflowed_p
= mips_elf_overflow_p (value
, 23);
6291 value
>>= howto
->rightshift
;
6292 value
&= howto
->dst_mask
;
6295 case R_MIPS_PC26_S2
:
6296 if (howto
->partial_inplace
)
6297 addend
= _bfd_mips_elf_sign_extend (addend
, 28);
6299 if ((symbol
+ addend
) & 3)
6300 return bfd_reloc_outofrange
;
6302 value
= symbol
+ addend
- p
;
6303 if (was_local_p
|| h
->root
.root
.type
!= bfd_link_hash_undefweak
)
6304 overflowed_p
= mips_elf_overflow_p (value
, 28);
6305 value
>>= howto
->rightshift
;
6306 value
&= howto
->dst_mask
;
6309 case R_MIPS_PC18_S3
:
6310 if (howto
->partial_inplace
)
6311 addend
= _bfd_mips_elf_sign_extend (addend
, 21);
6313 if ((symbol
+ addend
) & 7)
6314 return bfd_reloc_outofrange
;
6316 value
= symbol
+ addend
- ((p
| 7) ^ 7);
6317 if (was_local_p
|| h
->root
.root
.type
!= bfd_link_hash_undefweak
)
6318 overflowed_p
= mips_elf_overflow_p (value
, 21);
6319 value
>>= howto
->rightshift
;
6320 value
&= howto
->dst_mask
;
6323 case R_MIPS_PC19_S2
:
6324 if (howto
->partial_inplace
)
6325 addend
= _bfd_mips_elf_sign_extend (addend
, 21);
6327 if ((symbol
+ addend
) & 3)
6328 return bfd_reloc_outofrange
;
6330 value
= symbol
+ addend
- p
;
6331 if (was_local_p
|| h
->root
.root
.type
!= bfd_link_hash_undefweak
)
6332 overflowed_p
= mips_elf_overflow_p (value
, 21);
6333 value
>>= howto
->rightshift
;
6334 value
&= howto
->dst_mask
;
6338 value
= mips_elf_high (symbol
+ addend
- p
);
6339 value
&= howto
->dst_mask
;
6343 if (howto
->partial_inplace
)
6344 addend
= _bfd_mips_elf_sign_extend (addend
, 16);
6345 value
= symbol
+ addend
- p
;
6346 value
&= howto
->dst_mask
;
6349 case R_MICROMIPS_PC7_S1
:
6350 if (howto
->partial_inplace
)
6351 addend
= _bfd_mips_elf_sign_extend (addend
, 8);
6353 if ((was_local_p
|| h
->root
.root
.type
!= bfd_link_hash_undefweak
)
6354 && (*cross_mode_jump_p
6355 ? ((symbol
+ addend
+ 2) & 3) != 0
6356 : ((symbol
+ addend
+ 2) & 1) == 0))
6357 return bfd_reloc_outofrange
;
6359 value
= symbol
+ addend
- p
;
6360 if (was_local_p
|| h
->root
.root
.type
!= bfd_link_hash_undefweak
)
6361 overflowed_p
= mips_elf_overflow_p (value
, 8);
6362 value
>>= howto
->rightshift
;
6363 value
&= howto
->dst_mask
;
6366 case R_MICROMIPS_PC10_S1
:
6367 if (howto
->partial_inplace
)
6368 addend
= _bfd_mips_elf_sign_extend (addend
, 11);
6370 if ((was_local_p
|| h
->root
.root
.type
!= bfd_link_hash_undefweak
)
6371 && (*cross_mode_jump_p
6372 ? ((symbol
+ addend
+ 2) & 3) != 0
6373 : ((symbol
+ addend
+ 2) & 1) == 0))
6374 return bfd_reloc_outofrange
;
6376 value
= symbol
+ addend
- p
;
6377 if (was_local_p
|| h
->root
.root
.type
!= bfd_link_hash_undefweak
)
6378 overflowed_p
= mips_elf_overflow_p (value
, 11);
6379 value
>>= howto
->rightshift
;
6380 value
&= howto
->dst_mask
;
6383 case R_MICROMIPS_PC16_S1
:
6384 if (howto
->partial_inplace
)
6385 addend
= _bfd_mips_elf_sign_extend (addend
, 17);
6387 if ((was_local_p
|| h
->root
.root
.type
!= bfd_link_hash_undefweak
)
6388 && (*cross_mode_jump_p
6389 ? ((symbol
+ addend
) & 3) != 0
6390 : ((symbol
+ addend
) & 1) == 0))
6391 return bfd_reloc_outofrange
;
6393 value
= symbol
+ addend
- p
;
6394 if (was_local_p
|| h
->root
.root
.type
!= bfd_link_hash_undefweak
)
6395 overflowed_p
= mips_elf_overflow_p (value
, 17);
6396 value
>>= howto
->rightshift
;
6397 value
&= howto
->dst_mask
;
6400 case R_MICROMIPS_PC23_S2
:
6401 if (howto
->partial_inplace
)
6402 addend
= _bfd_mips_elf_sign_extend (addend
, 25);
6403 value
= symbol
+ addend
- ((p
| 3) ^ 3);
6404 if (was_local_p
|| h
->root
.root
.type
!= bfd_link_hash_undefweak
)
6405 overflowed_p
= mips_elf_overflow_p (value
, 25);
6406 value
>>= howto
->rightshift
;
6407 value
&= howto
->dst_mask
;
6410 case R_MIPS_GOT_HI16
:
6411 case R_MIPS_CALL_HI16
:
6412 case R_MICROMIPS_GOT_HI16
:
6413 case R_MICROMIPS_CALL_HI16
:
6414 /* We're allowed to handle these two relocations identically.
6415 The dynamic linker is allowed to handle the CALL relocations
6416 differently by creating a lazy evaluation stub. */
6418 value
= mips_elf_high (value
);
6419 value
&= howto
->dst_mask
;
6422 case R_MIPS_GOT_LO16
:
6423 case R_MIPS_CALL_LO16
:
6424 case R_MICROMIPS_GOT_LO16
:
6425 case R_MICROMIPS_CALL_LO16
:
6426 value
= g
& howto
->dst_mask
;
6429 case R_MIPS_GOT_PAGE
:
6430 case R_MICROMIPS_GOT_PAGE
:
6431 value
= mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, NULL
);
6432 if (value
== MINUS_ONE
)
6433 return bfd_reloc_outofrange
;
6434 value
= mips_elf_got_offset_from_index (info
, abfd
, input_bfd
, value
);
6435 overflowed_p
= mips_elf_overflow_p (value
, 16);
6438 case R_MIPS_GOT_OFST
:
6439 case R_MICROMIPS_GOT_OFST
:
6441 mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, &value
);
6444 overflowed_p
= mips_elf_overflow_p (value
, 16);
6448 case R_MICROMIPS_SUB
:
6449 value
= symbol
- addend
;
6450 value
&= howto
->dst_mask
;
6454 case R_MICROMIPS_HIGHER
:
6455 value
= mips_elf_higher (addend
+ symbol
);
6456 value
&= howto
->dst_mask
;
6459 case R_MIPS_HIGHEST
:
6460 case R_MICROMIPS_HIGHEST
:
6461 value
= mips_elf_highest (addend
+ symbol
);
6462 value
&= howto
->dst_mask
;
6465 case R_MIPS_SCN_DISP
:
6466 case R_MICROMIPS_SCN_DISP
:
6467 value
= symbol
+ addend
- sec
->output_offset
;
6468 value
&= howto
->dst_mask
;
6472 case R_MICROMIPS_JALR
:
6473 /* This relocation is only a hint. In some cases, we optimize
6474 it into a bal instruction. But we don't try to optimize
6475 when the symbol does not resolve locally. */
6476 if (h
!= NULL
&& !SYMBOL_CALLS_LOCAL (info
, &h
->root
))
6477 return bfd_reloc_continue
;
6478 /* We can't optimize cross-mode jumps either. */
6479 if (*cross_mode_jump_p
)
6480 return bfd_reloc_continue
;
6481 value
= symbol
+ addend
;
6482 /* Neither we can non-instruction-aligned targets. */
6483 if (r_type
== R_MIPS_JALR
? (value
& 3) != 0 : (value
& 1) == 0)
6484 return bfd_reloc_continue
;
6488 case R_MIPS_GNU_VTINHERIT
:
6489 case R_MIPS_GNU_VTENTRY
:
6490 /* We don't do anything with these at present. */
6491 return bfd_reloc_continue
;
6494 /* An unrecognized relocation type. */
6495 return bfd_reloc_notsupported
;
6498 /* Store the VALUE for our caller. */
6500 return overflowed_p
? bfd_reloc_overflow
: bfd_reloc_ok
;
6503 /* It has been determined that the result of the RELOCATION is the
6504 VALUE. Use HOWTO to place VALUE into the output file at the
6505 appropriate position. The SECTION is the section to which the
6507 CROSS_MODE_JUMP_P is true if the relocation field
6508 is a MIPS16 or microMIPS jump to standard MIPS code, or vice versa.
6510 Returns FALSE if anything goes wrong. */
6513 mips_elf_perform_relocation (struct bfd_link_info
*info
,
6514 reloc_howto_type
*howto
,
6515 const Elf_Internal_Rela
*relocation
,
6516 bfd_vma value
, bfd
*input_bfd
,
6517 asection
*input_section
, bfd_byte
*contents
,
6518 bfd_boolean cross_mode_jump_p
)
6522 int r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
6524 /* Figure out where the relocation is occurring. */
6525 location
= contents
+ relocation
->r_offset
;
6527 _bfd_mips_elf_reloc_unshuffle (input_bfd
, r_type
, FALSE
, location
);
6529 /* Obtain the current value. */
6530 x
= mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
);
6532 /* Clear the field we are setting. */
6533 x
&= ~howto
->dst_mask
;
6535 /* Set the field. */
6536 x
|= (value
& howto
->dst_mask
);
6538 /* Detect incorrect JALX usage. If required, turn JAL or BAL into JALX. */
6539 if (!cross_mode_jump_p
&& jal_reloc_p (r_type
))
6541 bfd_vma opcode
= x
>> 26;
6543 if (r_type
== R_MIPS16_26
? opcode
== 0x7
6544 : r_type
== R_MICROMIPS_26_S1
? opcode
== 0x3c
6547 info
->callbacks
->einfo
6548 (_("%X%H: unsupported JALX to the same ISA mode\n"),
6549 input_bfd
, input_section
, relocation
->r_offset
);
6553 if (cross_mode_jump_p
&& jal_reloc_p (r_type
))
6556 bfd_vma opcode
= x
>> 26;
6557 bfd_vma jalx_opcode
;
6559 /* Check to see if the opcode is already JAL or JALX. */
6560 if (r_type
== R_MIPS16_26
)
6562 ok
= ((opcode
== 0x6) || (opcode
== 0x7));
6565 else if (r_type
== R_MICROMIPS_26_S1
)
6567 ok
= ((opcode
== 0x3d) || (opcode
== 0x3c));
6572 ok
= ((opcode
== 0x3) || (opcode
== 0x1d));
6576 /* If the opcode is not JAL or JALX, there's a problem. We cannot
6577 convert J or JALS to JALX. */
6580 info
->callbacks
->einfo
6581 (_("%X%H: unsupported jump between ISA modes; "
6582 "consider recompiling with interlinking enabled\n"),
6583 input_bfd
, input_section
, relocation
->r_offset
);
6587 /* Make this the JALX opcode. */
6588 x
= (x
& ~(0x3fu
<< 26)) | (jalx_opcode
<< 26);
6590 else if (cross_mode_jump_p
&& b_reloc_p (r_type
))
6592 bfd_boolean ok
= FALSE
;
6593 bfd_vma opcode
= x
>> 16;
6594 bfd_vma jalx_opcode
= 0;
6595 bfd_vma sign_bit
= 0;
6599 if (r_type
== R_MICROMIPS_PC16_S1
)
6601 ok
= opcode
== 0x4060;
6606 else if (r_type
== R_MIPS_PC16
|| r_type
== R_MIPS_GNU_REL16_S2
)
6608 ok
= opcode
== 0x411;
6614 if (ok
&& !bfd_link_pic (info
))
6616 addr
= (input_section
->output_section
->vma
6617 + input_section
->output_offset
6618 + relocation
->r_offset
6621 + (((value
& ((sign_bit
<< 1) - 1)) ^ sign_bit
) - sign_bit
));
6623 if ((addr
>> 28) << 28 != (dest
>> 28) << 28)
6625 info
->callbacks
->einfo
6626 (_("%X%H: cannot convert branch between ISA modes "
6627 "to JALX: relocation out of range\n"),
6628 input_bfd
, input_section
, relocation
->r_offset
);
6632 /* Make this the JALX opcode. */
6633 x
= ((dest
>> 2) & 0x3ffffff) | jalx_opcode
<< 26;
6635 else if (!mips_elf_hash_table (info
)->ignore_branch_isa
)
6637 info
->callbacks
->einfo
6638 (_("%X%H: unsupported branch between ISA modes\n"),
6639 input_bfd
, input_section
, relocation
->r_offset
);
6644 /* Try converting JAL to BAL and J(AL)R to B(AL), if the target is in
6646 if (!bfd_link_relocatable (info
)
6647 && !cross_mode_jump_p
6648 && ((JAL_TO_BAL_P (input_bfd
)
6649 && r_type
== R_MIPS_26
6650 && (x
>> 26) == 0x3) /* jal addr */
6651 || (JALR_TO_BAL_P (input_bfd
)
6652 && r_type
== R_MIPS_JALR
6653 && x
== 0x0320f809) /* jalr t9 */
6654 || (JR_TO_B_P (input_bfd
)
6655 && r_type
== R_MIPS_JALR
6656 && (x
& ~1) == 0x03200008))) /* jr t9 / jalr zero, t9 */
6662 addr
= (input_section
->output_section
->vma
6663 + input_section
->output_offset
6664 + relocation
->r_offset
6666 if (r_type
== R_MIPS_26
)
6667 dest
= (value
<< 2) | ((addr
>> 28) << 28);
6671 if (off
<= 0x1ffff && off
>= -0x20000)
6673 if ((x
& ~1) == 0x03200008) /* jr t9 / jalr zero, t9 */
6674 x
= 0x10000000 | (((bfd_vma
) off
>> 2) & 0xffff); /* b addr */
6676 x
= 0x04110000 | (((bfd_vma
) off
>> 2) & 0xffff); /* bal addr */
6680 /* Put the value into the output. */
6681 mips_elf_store_contents (howto
, relocation
, input_bfd
, contents
, x
);
6683 _bfd_mips_elf_reloc_shuffle (input_bfd
, r_type
, !bfd_link_relocatable (info
),
6689 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
6690 is the original relocation, which is now being transformed into a
6691 dynamic relocation. The ADDENDP is adjusted if necessary; the
6692 caller should store the result in place of the original addend. */
6695 mips_elf_create_dynamic_relocation (bfd
*output_bfd
,
6696 struct bfd_link_info
*info
,
6697 const Elf_Internal_Rela
*rel
,
6698 struct mips_elf_link_hash_entry
*h
,
6699 asection
*sec
, bfd_vma symbol
,
6700 bfd_vma
*addendp
, asection
*input_section
)
6702 Elf_Internal_Rela outrel
[3];
6707 bfd_boolean defined_p
;
6708 struct mips_elf_link_hash_table
*htab
;
6710 htab
= mips_elf_hash_table (info
);
6711 BFD_ASSERT (htab
!= NULL
);
6713 r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
6714 dynobj
= elf_hash_table (info
)->dynobj
;
6715 sreloc
= mips_elf_rel_dyn_section (info
, FALSE
);
6716 BFD_ASSERT (sreloc
!= NULL
);
6717 BFD_ASSERT (sreloc
->contents
!= NULL
);
6718 BFD_ASSERT (sreloc
->reloc_count
* MIPS_ELF_REL_SIZE (output_bfd
)
6721 outrel
[0].r_offset
=
6722 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[0].r_offset
);
6723 if (ABI_64_P (output_bfd
))
6725 outrel
[1].r_offset
=
6726 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[1].r_offset
);
6727 outrel
[2].r_offset
=
6728 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[2].r_offset
);
6731 if (outrel
[0].r_offset
== MINUS_ONE
)
6732 /* The relocation field has been deleted. */
6735 if (outrel
[0].r_offset
== MINUS_TWO
)
6737 /* The relocation field has been converted into a relative value of
6738 some sort. Functions like _bfd_elf_write_section_eh_frame expect
6739 the field to be fully relocated, so add in the symbol's value. */
6744 /* We must now calculate the dynamic symbol table index to use
6745 in the relocation. */
6746 if (h
!= NULL
&& ! SYMBOL_REFERENCES_LOCAL (info
, &h
->root
))
6748 BFD_ASSERT (htab
->is_vxworks
|| h
->global_got_area
!= GGA_NONE
);
6749 indx
= h
->root
.dynindx
;
6750 if (SGI_COMPAT (output_bfd
))
6751 defined_p
= h
->root
.def_regular
;
6753 /* ??? glibc's ld.so just adds the final GOT entry to the
6754 relocation field. It therefore treats relocs against
6755 defined symbols in the same way as relocs against
6756 undefined symbols. */
6761 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
6763 else if (sec
== NULL
|| sec
->owner
== NULL
)
6765 bfd_set_error (bfd_error_bad_value
);
6770 indx
= elf_section_data (sec
->output_section
)->dynindx
;
6773 asection
*osec
= htab
->root
.text_index_section
;
6774 indx
= elf_section_data (osec
)->dynindx
;
6780 /* Instead of generating a relocation using the section
6781 symbol, we may as well make it a fully relative
6782 relocation. We want to avoid generating relocations to
6783 local symbols because we used to generate them
6784 incorrectly, without adding the original symbol value,
6785 which is mandated by the ABI for section symbols. In
6786 order to give dynamic loaders and applications time to
6787 phase out the incorrect use, we refrain from emitting
6788 section-relative relocations. It's not like they're
6789 useful, after all. This should be a bit more efficient
6791 /* ??? Although this behavior is compatible with glibc's ld.so,
6792 the ABI says that relocations against STN_UNDEF should have
6793 a symbol value of 0. Irix rld honors this, so relocations
6794 against STN_UNDEF have no effect. */
6795 if (!SGI_COMPAT (output_bfd
))
6800 /* If the relocation was previously an absolute relocation and
6801 this symbol will not be referred to by the relocation, we must
6802 adjust it by the value we give it in the dynamic symbol table.
6803 Otherwise leave the job up to the dynamic linker. */
6804 if (defined_p
&& r_type
!= R_MIPS_REL32
)
6807 if (htab
->is_vxworks
)
6808 /* VxWorks uses non-relative relocations for this. */
6809 outrel
[0].r_info
= ELF32_R_INFO (indx
, R_MIPS_32
);
6811 /* The relocation is always an REL32 relocation because we don't
6812 know where the shared library will wind up at load-time. */
6813 outrel
[0].r_info
= ELF_R_INFO (output_bfd
, (unsigned long) indx
,
6816 /* For strict adherence to the ABI specification, we should
6817 generate a R_MIPS_64 relocation record by itself before the
6818 _REL32/_64 record as well, such that the addend is read in as
6819 a 64-bit value (REL32 is a 32-bit relocation, after all).
6820 However, since none of the existing ELF64 MIPS dynamic
6821 loaders seems to care, we don't waste space with these
6822 artificial relocations. If this turns out to not be true,
6823 mips_elf_allocate_dynamic_relocation() should be tweaked so
6824 as to make room for a pair of dynamic relocations per
6825 invocation if ABI_64_P, and here we should generate an
6826 additional relocation record with R_MIPS_64 by itself for a
6827 NULL symbol before this relocation record. */
6828 outrel
[1].r_info
= ELF_R_INFO (output_bfd
, 0,
6829 ABI_64_P (output_bfd
)
6832 outrel
[2].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_NONE
);
6834 /* Adjust the output offset of the relocation to reference the
6835 correct location in the output file. */
6836 outrel
[0].r_offset
+= (input_section
->output_section
->vma
6837 + input_section
->output_offset
);
6838 outrel
[1].r_offset
+= (input_section
->output_section
->vma
6839 + input_section
->output_offset
);
6840 outrel
[2].r_offset
+= (input_section
->output_section
->vma
6841 + input_section
->output_offset
);
6843 /* Put the relocation back out. We have to use the special
6844 relocation outputter in the 64-bit case since the 64-bit
6845 relocation format is non-standard. */
6846 if (ABI_64_P (output_bfd
))
6848 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
6849 (output_bfd
, &outrel
[0],
6851 + sreloc
->reloc_count
* sizeof (Elf64_Mips_External_Rel
)));
6853 else if (htab
->is_vxworks
)
6855 /* VxWorks uses RELA rather than REL dynamic relocations. */
6856 outrel
[0].r_addend
= *addendp
;
6857 bfd_elf32_swap_reloca_out
6858 (output_bfd
, &outrel
[0],
6860 + sreloc
->reloc_count
* sizeof (Elf32_External_Rela
)));
6863 bfd_elf32_swap_reloc_out
6864 (output_bfd
, &outrel
[0],
6865 (sreloc
->contents
+ sreloc
->reloc_count
* sizeof (Elf32_External_Rel
)));
6867 /* We've now added another relocation. */
6868 ++sreloc
->reloc_count
;
6870 /* Make sure the output section is writable. The dynamic linker
6871 will be writing to it. */
6872 elf_section_data (input_section
->output_section
)->this_hdr
.sh_flags
6875 /* On IRIX5, make an entry of compact relocation info. */
6876 if (IRIX_COMPAT (output_bfd
) == ict_irix5
)
6878 asection
*scpt
= bfd_get_linker_section (dynobj
, ".compact_rel");
6883 Elf32_crinfo cptrel
;
6885 mips_elf_set_cr_format (cptrel
, CRF_MIPS_LONG
);
6886 cptrel
.vaddr
= (rel
->r_offset
6887 + input_section
->output_section
->vma
6888 + input_section
->output_offset
);
6889 if (r_type
== R_MIPS_REL32
)
6890 mips_elf_set_cr_type (cptrel
, CRT_MIPS_REL32
);
6892 mips_elf_set_cr_type (cptrel
, CRT_MIPS_WORD
);
6893 mips_elf_set_cr_dist2to (cptrel
, 0);
6894 cptrel
.konst
= *addendp
;
6896 cr
= (scpt
->contents
6897 + sizeof (Elf32_External_compact_rel
));
6898 mips_elf_set_cr_relvaddr (cptrel
, 0);
6899 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
6900 ((Elf32_External_crinfo
*) cr
6901 + scpt
->reloc_count
));
6902 ++scpt
->reloc_count
;
6906 /* If we've written this relocation for a readonly section,
6907 we need to set DF_TEXTREL again, so that we do not delete the
6909 if (MIPS_ELF_READONLY_SECTION (input_section
))
6910 info
->flags
|= DF_TEXTREL
;
6915 /* Return the MACH for a MIPS e_flags value. */
6918 _bfd_elf_mips_mach (flagword flags
)
6920 switch (flags
& EF_MIPS_MACH
)
6922 case E_MIPS_MACH_3900
:
6923 return bfd_mach_mips3900
;
6925 case E_MIPS_MACH_4010
:
6926 return bfd_mach_mips4010
;
6928 case E_MIPS_MACH_4100
:
6929 return bfd_mach_mips4100
;
6931 case E_MIPS_MACH_4111
:
6932 return bfd_mach_mips4111
;
6934 case E_MIPS_MACH_4120
:
6935 return bfd_mach_mips4120
;
6937 case E_MIPS_MACH_4650
:
6938 return bfd_mach_mips4650
;
6940 case E_MIPS_MACH_5400
:
6941 return bfd_mach_mips5400
;
6943 case E_MIPS_MACH_5500
:
6944 return bfd_mach_mips5500
;
6946 case E_MIPS_MACH_5900
:
6947 return bfd_mach_mips5900
;
6949 case E_MIPS_MACH_9000
:
6950 return bfd_mach_mips9000
;
6952 case E_MIPS_MACH_SB1
:
6953 return bfd_mach_mips_sb1
;
6955 case E_MIPS_MACH_LS2E
:
6956 return bfd_mach_mips_loongson_2e
;
6958 case E_MIPS_MACH_LS2F
:
6959 return bfd_mach_mips_loongson_2f
;
6961 case E_MIPS_MACH_GS464
:
6962 return bfd_mach_mips_gs464
;
6964 case E_MIPS_MACH_GS464E
:
6965 return bfd_mach_mips_gs464e
;
6967 case E_MIPS_MACH_GS264E
:
6968 return bfd_mach_mips_gs264e
;
6970 case E_MIPS_MACH_OCTEON3
:
6971 return bfd_mach_mips_octeon3
;
6973 case E_MIPS_MACH_OCTEON2
:
6974 return bfd_mach_mips_octeon2
;
6976 case E_MIPS_MACH_OCTEON
:
6977 return bfd_mach_mips_octeon
;
6979 case E_MIPS_MACH_XLR
:
6980 return bfd_mach_mips_xlr
;
6982 case E_MIPS_MACH_IAMR2
:
6983 return bfd_mach_mips_interaptiv_mr2
;
6986 switch (flags
& EF_MIPS_ARCH
)
6990 return bfd_mach_mips3000
;
6993 return bfd_mach_mips6000
;
6996 return bfd_mach_mips4000
;
6999 return bfd_mach_mips8000
;
7002 return bfd_mach_mips5
;
7004 case E_MIPS_ARCH_32
:
7005 return bfd_mach_mipsisa32
;
7007 case E_MIPS_ARCH_64
:
7008 return bfd_mach_mipsisa64
;
7010 case E_MIPS_ARCH_32R2
:
7011 return bfd_mach_mipsisa32r2
;
7013 case E_MIPS_ARCH_64R2
:
7014 return bfd_mach_mipsisa64r2
;
7016 case E_MIPS_ARCH_32R6
:
7017 return bfd_mach_mipsisa32r6
;
7019 case E_MIPS_ARCH_64R6
:
7020 return bfd_mach_mipsisa64r6
;
7027 /* Return printable name for ABI. */
7029 static INLINE
char *
7030 elf_mips_abi_name (bfd
*abfd
)
7034 flags
= elf_elfheader (abfd
)->e_flags
;
7035 switch (flags
& EF_MIPS_ABI
)
7038 if (ABI_N32_P (abfd
))
7040 else if (ABI_64_P (abfd
))
7044 case E_MIPS_ABI_O32
:
7046 case E_MIPS_ABI_O64
:
7048 case E_MIPS_ABI_EABI32
:
7050 case E_MIPS_ABI_EABI64
:
7053 return "unknown abi";
7057 /* MIPS ELF uses two common sections. One is the usual one, and the
7058 other is for small objects. All the small objects are kept
7059 together, and then referenced via the gp pointer, which yields
7060 faster assembler code. This is what we use for the small common
7061 section. This approach is copied from ecoff.c. */
7062 static asection mips_elf_scom_section
;
7063 static asymbol mips_elf_scom_symbol
;
7064 static asymbol
*mips_elf_scom_symbol_ptr
;
7066 /* MIPS ELF also uses an acommon section, which represents an
7067 allocated common symbol which may be overridden by a
7068 definition in a shared library. */
7069 static asection mips_elf_acom_section
;
7070 static asymbol mips_elf_acom_symbol
;
7071 static asymbol
*mips_elf_acom_symbol_ptr
;
7073 /* This is used for both the 32-bit and the 64-bit ABI. */
7076 _bfd_mips_elf_symbol_processing (bfd
*abfd
, asymbol
*asym
)
7078 elf_symbol_type
*elfsym
;
7080 /* Handle the special MIPS section numbers that a symbol may use. */
7081 elfsym
= (elf_symbol_type
*) asym
;
7082 switch (elfsym
->internal_elf_sym
.st_shndx
)
7084 case SHN_MIPS_ACOMMON
:
7085 /* This section is used in a dynamically linked executable file.
7086 It is an allocated common section. The dynamic linker can
7087 either resolve these symbols to something in a shared
7088 library, or it can just leave them here. For our purposes,
7089 we can consider these symbols to be in a new section. */
7090 if (mips_elf_acom_section
.name
== NULL
)
7092 /* Initialize the acommon section. */
7093 mips_elf_acom_section
.name
= ".acommon";
7094 mips_elf_acom_section
.flags
= SEC_ALLOC
;
7095 mips_elf_acom_section
.output_section
= &mips_elf_acom_section
;
7096 mips_elf_acom_section
.symbol
= &mips_elf_acom_symbol
;
7097 mips_elf_acom_section
.symbol_ptr_ptr
= &mips_elf_acom_symbol_ptr
;
7098 mips_elf_acom_symbol
.name
= ".acommon";
7099 mips_elf_acom_symbol
.flags
= BSF_SECTION_SYM
;
7100 mips_elf_acom_symbol
.section
= &mips_elf_acom_section
;
7101 mips_elf_acom_symbol_ptr
= &mips_elf_acom_symbol
;
7103 asym
->section
= &mips_elf_acom_section
;
7107 /* Common symbols less than the GP size are automatically
7108 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
7109 if (asym
->value
> elf_gp_size (abfd
)
7110 || ELF_ST_TYPE (elfsym
->internal_elf_sym
.st_info
) == STT_TLS
7111 || IRIX_COMPAT (abfd
) == ict_irix6
)
7114 case SHN_MIPS_SCOMMON
:
7115 if (mips_elf_scom_section
.name
== NULL
)
7117 /* Initialize the small common section. */
7118 mips_elf_scom_section
.name
= ".scommon";
7119 mips_elf_scom_section
.flags
= SEC_IS_COMMON
;
7120 mips_elf_scom_section
.output_section
= &mips_elf_scom_section
;
7121 mips_elf_scom_section
.symbol
= &mips_elf_scom_symbol
;
7122 mips_elf_scom_section
.symbol_ptr_ptr
= &mips_elf_scom_symbol_ptr
;
7123 mips_elf_scom_symbol
.name
= ".scommon";
7124 mips_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
7125 mips_elf_scom_symbol
.section
= &mips_elf_scom_section
;
7126 mips_elf_scom_symbol_ptr
= &mips_elf_scom_symbol
;
7128 asym
->section
= &mips_elf_scom_section
;
7129 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
7132 case SHN_MIPS_SUNDEFINED
:
7133 asym
->section
= bfd_und_section_ptr
;
7138 asection
*section
= bfd_get_section_by_name (abfd
, ".text");
7140 if (section
!= NULL
)
7142 asym
->section
= section
;
7143 /* MIPS_TEXT is a bit special, the address is not an offset
7144 to the base of the .text section. So subtract the section
7145 base address to make it an offset. */
7146 asym
->value
-= section
->vma
;
7153 asection
*section
= bfd_get_section_by_name (abfd
, ".data");
7155 if (section
!= NULL
)
7157 asym
->section
= section
;
7158 /* MIPS_DATA is a bit special, the address is not an offset
7159 to the base of the .data section. So subtract the section
7160 base address to make it an offset. */
7161 asym
->value
-= section
->vma
;
7167 /* If this is an odd-valued function symbol, assume it's a MIPS16
7168 or microMIPS one. */
7169 if (ELF_ST_TYPE (elfsym
->internal_elf_sym
.st_info
) == STT_FUNC
7170 && (asym
->value
& 1) != 0)
7173 if (MICROMIPS_P (abfd
))
7174 elfsym
->internal_elf_sym
.st_other
7175 = ELF_ST_SET_MICROMIPS (elfsym
->internal_elf_sym
.st_other
);
7177 elfsym
->internal_elf_sym
.st_other
7178 = ELF_ST_SET_MIPS16 (elfsym
->internal_elf_sym
.st_other
);
7182 /* Implement elf_backend_eh_frame_address_size. This differs from
7183 the default in the way it handles EABI64.
7185 EABI64 was originally specified as an LP64 ABI, and that is what
7186 -mabi=eabi normally gives on a 64-bit target. However, gcc has
7187 historically accepted the combination of -mabi=eabi and -mlong32,
7188 and this ILP32 variation has become semi-official over time.
7189 Both forms use elf32 and have pointer-sized FDE addresses.
7191 If an EABI object was generated by GCC 4.0 or above, it will have
7192 an empty .gcc_compiled_longXX section, where XX is the size of longs
7193 in bits. Unfortunately, ILP32 objects generated by earlier compilers
7194 have no special marking to distinguish them from LP64 objects.
7196 We don't want users of the official LP64 ABI to be punished for the
7197 existence of the ILP32 variant, but at the same time, we don't want
7198 to mistakenly interpret pre-4.0 ILP32 objects as being LP64 objects.
7199 We therefore take the following approach:
7201 - If ABFD contains a .gcc_compiled_longXX section, use it to
7202 determine the pointer size.
7204 - Otherwise check the type of the first relocation. Assume that
7205 the LP64 ABI is being used if the relocation is of type R_MIPS_64.
7209 The second check is enough to detect LP64 objects generated by pre-4.0
7210 compilers because, in the kind of output generated by those compilers,
7211 the first relocation will be associated with either a CIE personality
7212 routine or an FDE start address. Furthermore, the compilers never
7213 used a special (non-pointer) encoding for this ABI.
7215 Checking the relocation type should also be safe because there is no
7216 reason to use R_MIPS_64 in an ILP32 object. Pre-4.0 compilers never
7220 _bfd_mips_elf_eh_frame_address_size (bfd
*abfd
, const asection
*sec
)
7222 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
7224 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
7226 bfd_boolean long32_p
, long64_p
;
7228 long32_p
= bfd_get_section_by_name (abfd
, ".gcc_compiled_long32") != 0;
7229 long64_p
= bfd_get_section_by_name (abfd
, ".gcc_compiled_long64") != 0;
7230 if (long32_p
&& long64_p
)
7237 if (sec
->reloc_count
> 0
7238 && elf_section_data (sec
)->relocs
!= NULL
7239 && (ELF32_R_TYPE (elf_section_data (sec
)->relocs
[0].r_info
)
7248 /* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
7249 relocations against two unnamed section symbols to resolve to the
7250 same address. For example, if we have code like:
7252 lw $4,%got_disp(.data)($gp)
7253 lw $25,%got_disp(.text)($gp)
7256 then the linker will resolve both relocations to .data and the program
7257 will jump there rather than to .text.
7259 We can work around this problem by giving names to local section symbols.
7260 This is also what the MIPSpro tools do. */
7263 _bfd_mips_elf_name_local_section_symbols (bfd
*abfd
)
7265 return SGI_COMPAT (abfd
);
7268 /* Work over a section just before writing it out. This routine is
7269 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
7270 sections that need the SHF_MIPS_GPREL flag by name; there has to be
7274 _bfd_mips_elf_section_processing (bfd
*abfd
, Elf_Internal_Shdr
*hdr
)
7276 if (hdr
->sh_type
== SHT_MIPS_REGINFO
7277 && hdr
->sh_size
> 0)
7281 BFD_ASSERT (hdr
->contents
== NULL
);
7283 if (hdr
->sh_size
!= sizeof (Elf32_External_RegInfo
))
7286 (_("%pB: incorrect `.reginfo' section size; "
7287 "expected %" PRIu64
", got %" PRIu64
),
7288 abfd
, (uint64_t) sizeof (Elf32_External_RegInfo
),
7289 (uint64_t) hdr
->sh_size
);
7290 bfd_set_error (bfd_error_bad_value
);
7295 hdr
->sh_offset
+ sizeof (Elf32_External_RegInfo
) - 4,
7298 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
7299 if (bfd_bwrite (buf
, 4, abfd
) != 4)
7303 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
7304 && hdr
->bfd_section
!= NULL
7305 && mips_elf_section_data (hdr
->bfd_section
) != NULL
7306 && mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
!= NULL
)
7308 bfd_byte
*contents
, *l
, *lend
;
7310 /* We stored the section contents in the tdata field in the
7311 set_section_contents routine. We save the section contents
7312 so that we don't have to read them again.
7313 At this point we know that elf_gp is set, so we can look
7314 through the section contents to see if there is an
7315 ODK_REGINFO structure. */
7317 contents
= mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
;
7319 lend
= contents
+ hdr
->sh_size
;
7320 while (l
+ sizeof (Elf_External_Options
) <= lend
)
7322 Elf_Internal_Options intopt
;
7324 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
7326 if (intopt
.size
< sizeof (Elf_External_Options
))
7329 /* xgettext:c-format */
7330 (_("%pB: warning: bad `%s' option size %u smaller than"
7332 abfd
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
), intopt
.size
);
7335 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
7342 + sizeof (Elf_External_Options
)
7343 + (sizeof (Elf64_External_RegInfo
) - 8)),
7346 H_PUT_64 (abfd
, elf_gp (abfd
), buf
);
7347 if (bfd_bwrite (buf
, 8, abfd
) != 8)
7350 else if (intopt
.kind
== ODK_REGINFO
)
7357 + sizeof (Elf_External_Options
)
7358 + (sizeof (Elf32_External_RegInfo
) - 4)),
7361 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
7362 if (bfd_bwrite (buf
, 4, abfd
) != 4)
7369 if (hdr
->bfd_section
!= NULL
)
7371 const char *name
= bfd_section_name (hdr
->bfd_section
);
7373 /* .sbss is not handled specially here because the GNU/Linux
7374 prelinker can convert .sbss from NOBITS to PROGBITS and
7375 changing it back to NOBITS breaks the binary. The entry in
7376 _bfd_mips_elf_special_sections will ensure the correct flags
7377 are set on .sbss if BFD creates it without reading it from an
7378 input file, and without special handling here the flags set
7379 on it in an input file will be followed. */
7380 if (strcmp (name
, ".sdata") == 0
7381 || strcmp (name
, ".lit8") == 0
7382 || strcmp (name
, ".lit4") == 0)
7383 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
7384 else if (strcmp (name
, ".srdata") == 0)
7385 hdr
->sh_flags
|= SHF_ALLOC
| SHF_MIPS_GPREL
;
7386 else if (strcmp (name
, ".compact_rel") == 0)
7388 else if (strcmp (name
, ".rtproc") == 0)
7390 if (hdr
->sh_addralign
!= 0 && hdr
->sh_entsize
== 0)
7392 unsigned int adjust
;
7394 adjust
= hdr
->sh_size
% hdr
->sh_addralign
;
7396 hdr
->sh_size
+= hdr
->sh_addralign
- adjust
;
7404 /* Handle a MIPS specific section when reading an object file. This
7405 is called when elfcode.h finds a section with an unknown type.
7406 This routine supports both the 32-bit and 64-bit ELF ABI. */
7409 _bfd_mips_elf_section_from_shdr (bfd
*abfd
,
7410 Elf_Internal_Shdr
*hdr
,
7416 /* There ought to be a place to keep ELF backend specific flags, but
7417 at the moment there isn't one. We just keep track of the
7418 sections by their name, instead. Fortunately, the ABI gives
7419 suggested names for all the MIPS specific sections, so we will
7420 probably get away with this. */
7421 switch (hdr
->sh_type
)
7423 case SHT_MIPS_LIBLIST
:
7424 if (strcmp (name
, ".liblist") != 0)
7428 if (strcmp (name
, ".msym") != 0)
7431 case SHT_MIPS_CONFLICT
:
7432 if (strcmp (name
, ".conflict") != 0)
7435 case SHT_MIPS_GPTAB
:
7436 if (! CONST_STRNEQ (name
, ".gptab."))
7439 case SHT_MIPS_UCODE
:
7440 if (strcmp (name
, ".ucode") != 0)
7443 case SHT_MIPS_DEBUG
:
7444 if (strcmp (name
, ".mdebug") != 0)
7446 flags
= SEC_DEBUGGING
;
7448 case SHT_MIPS_REGINFO
:
7449 if (strcmp (name
, ".reginfo") != 0
7450 || hdr
->sh_size
!= sizeof (Elf32_External_RegInfo
))
7452 flags
= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_SIZE
);
7454 case SHT_MIPS_IFACE
:
7455 if (strcmp (name
, ".MIPS.interfaces") != 0)
7458 case SHT_MIPS_CONTENT
:
7459 if (! CONST_STRNEQ (name
, ".MIPS.content"))
7462 case SHT_MIPS_OPTIONS
:
7463 if (!MIPS_ELF_OPTIONS_SECTION_NAME_P (name
))
7466 case SHT_MIPS_ABIFLAGS
:
7467 if (!MIPS_ELF_ABIFLAGS_SECTION_NAME_P (name
))
7469 flags
= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_SIZE
);
7471 case SHT_MIPS_DWARF
:
7472 if (! CONST_STRNEQ (name
, ".debug_")
7473 && ! CONST_STRNEQ (name
, ".zdebug_"))
7476 case SHT_MIPS_SYMBOL_LIB
:
7477 if (strcmp (name
, ".MIPS.symlib") != 0)
7480 case SHT_MIPS_EVENTS
:
7481 if (! CONST_STRNEQ (name
, ".MIPS.events")
7482 && ! CONST_STRNEQ (name
, ".MIPS.post_rel"))
7485 case SHT_MIPS_XHASH
:
7486 if (strcmp (name
, ".MIPS.xhash") != 0)
7492 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
7495 if (hdr
->sh_flags
& SHF_MIPS_GPREL
)
7496 flags
|= SEC_SMALL_DATA
;
7500 if (!bfd_set_section_flags (hdr
->bfd_section
,
7501 (bfd_section_flags (hdr
->bfd_section
)
7506 if (hdr
->sh_type
== SHT_MIPS_ABIFLAGS
)
7508 Elf_External_ABIFlags_v0 ext
;
7510 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
,
7511 &ext
, 0, sizeof ext
))
7513 bfd_mips_elf_swap_abiflags_v0_in (abfd
, &ext
,
7514 &mips_elf_tdata (abfd
)->abiflags
);
7515 if (mips_elf_tdata (abfd
)->abiflags
.version
!= 0)
7517 mips_elf_tdata (abfd
)->abiflags_valid
= TRUE
;
7520 /* FIXME: We should record sh_info for a .gptab section. */
7522 /* For a .reginfo section, set the gp value in the tdata information
7523 from the contents of this section. We need the gp value while
7524 processing relocs, so we just get it now. The .reginfo section
7525 is not used in the 64-bit MIPS ELF ABI. */
7526 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
7528 Elf32_External_RegInfo ext
;
7531 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
,
7532 &ext
, 0, sizeof ext
))
7534 bfd_mips_elf32_swap_reginfo_in (abfd
, &ext
, &s
);
7535 elf_gp (abfd
) = s
.ri_gp_value
;
7538 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
7539 set the gp value based on what we find. We may see both
7540 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
7541 they should agree. */
7542 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
)
7544 bfd_byte
*contents
, *l
, *lend
;
7546 contents
= bfd_malloc (hdr
->sh_size
);
7547 if (contents
== NULL
)
7549 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
,
7556 lend
= contents
+ hdr
->sh_size
;
7557 while (l
+ sizeof (Elf_External_Options
) <= lend
)
7559 Elf_Internal_Options intopt
;
7561 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
7563 if (intopt
.size
< sizeof (Elf_External_Options
))
7566 /* xgettext:c-format */
7567 (_("%pB: warning: bad `%s' option size %u smaller than"
7569 abfd
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
), intopt
.size
);
7572 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
7574 Elf64_Internal_RegInfo intreg
;
7576 bfd_mips_elf64_swap_reginfo_in
7578 ((Elf64_External_RegInfo
*)
7579 (l
+ sizeof (Elf_External_Options
))),
7581 elf_gp (abfd
) = intreg
.ri_gp_value
;
7583 else if (intopt
.kind
== ODK_REGINFO
)
7585 Elf32_RegInfo intreg
;
7587 bfd_mips_elf32_swap_reginfo_in
7589 ((Elf32_External_RegInfo
*)
7590 (l
+ sizeof (Elf_External_Options
))),
7592 elf_gp (abfd
) = intreg
.ri_gp_value
;
7602 /* Set the correct type for a MIPS ELF section. We do this by the
7603 section name, which is a hack, but ought to work. This routine is
7604 used by both the 32-bit and the 64-bit ABI. */
7607 _bfd_mips_elf_fake_sections (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*sec
)
7609 const char *name
= bfd_section_name (sec
);
7611 if (strcmp (name
, ".liblist") == 0)
7613 hdr
->sh_type
= SHT_MIPS_LIBLIST
;
7614 hdr
->sh_info
= sec
->size
/ sizeof (Elf32_Lib
);
7615 /* The sh_link field is set in final_write_processing. */
7617 else if (strcmp (name
, ".conflict") == 0)
7618 hdr
->sh_type
= SHT_MIPS_CONFLICT
;
7619 else if (CONST_STRNEQ (name
, ".gptab."))
7621 hdr
->sh_type
= SHT_MIPS_GPTAB
;
7622 hdr
->sh_entsize
= sizeof (Elf32_External_gptab
);
7623 /* The sh_info field is set in final_write_processing. */
7625 else if (strcmp (name
, ".ucode") == 0)
7626 hdr
->sh_type
= SHT_MIPS_UCODE
;
7627 else if (strcmp (name
, ".mdebug") == 0)
7629 hdr
->sh_type
= SHT_MIPS_DEBUG
;
7630 /* In a shared object on IRIX 5.3, the .mdebug section has an
7631 entsize of 0. FIXME: Does this matter? */
7632 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
7633 hdr
->sh_entsize
= 0;
7635 hdr
->sh_entsize
= 1;
7637 else if (strcmp (name
, ".reginfo") == 0)
7639 hdr
->sh_type
= SHT_MIPS_REGINFO
;
7640 /* In a shared object on IRIX 5.3, the .reginfo section has an
7641 entsize of 0x18. FIXME: Does this matter? */
7642 if (SGI_COMPAT (abfd
))
7644 if ((abfd
->flags
& DYNAMIC
) != 0)
7645 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
7647 hdr
->sh_entsize
= 1;
7650 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
7652 else if (SGI_COMPAT (abfd
)
7653 && (strcmp (name
, ".hash") == 0
7654 || strcmp (name
, ".dynamic") == 0
7655 || strcmp (name
, ".dynstr") == 0))
7657 if (SGI_COMPAT (abfd
))
7658 hdr
->sh_entsize
= 0;
7660 /* This isn't how the IRIX6 linker behaves. */
7661 hdr
->sh_info
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
7664 else if (strcmp (name
, ".got") == 0
7665 || strcmp (name
, ".srdata") == 0
7666 || strcmp (name
, ".sdata") == 0
7667 || strcmp (name
, ".sbss") == 0
7668 || strcmp (name
, ".lit4") == 0
7669 || strcmp (name
, ".lit8") == 0)
7670 hdr
->sh_flags
|= SHF_MIPS_GPREL
;
7671 else if (strcmp (name
, ".MIPS.interfaces") == 0)
7673 hdr
->sh_type
= SHT_MIPS_IFACE
;
7674 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
7676 else if (CONST_STRNEQ (name
, ".MIPS.content"))
7678 hdr
->sh_type
= SHT_MIPS_CONTENT
;
7679 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
7680 /* The sh_info field is set in final_write_processing. */
7682 else if (MIPS_ELF_OPTIONS_SECTION_NAME_P (name
))
7684 hdr
->sh_type
= SHT_MIPS_OPTIONS
;
7685 hdr
->sh_entsize
= 1;
7686 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
7688 else if (CONST_STRNEQ (name
, ".MIPS.abiflags"))
7690 hdr
->sh_type
= SHT_MIPS_ABIFLAGS
;
7691 hdr
->sh_entsize
= sizeof (Elf_External_ABIFlags_v0
);
7693 else if (CONST_STRNEQ (name
, ".debug_")
7694 || CONST_STRNEQ (name
, ".zdebug_"))
7696 hdr
->sh_type
= SHT_MIPS_DWARF
;
7698 /* Irix facilities such as libexc expect a single .debug_frame
7699 per executable, the system ones have NOSTRIP set and the linker
7700 doesn't merge sections with different flags so ... */
7701 if (SGI_COMPAT (abfd
) && CONST_STRNEQ (name
, ".debug_frame"))
7702 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
7704 else if (strcmp (name
, ".MIPS.symlib") == 0)
7706 hdr
->sh_type
= SHT_MIPS_SYMBOL_LIB
;
7707 /* The sh_link and sh_info fields are set in
7708 final_write_processing. */
7710 else if (CONST_STRNEQ (name
, ".MIPS.events")
7711 || CONST_STRNEQ (name
, ".MIPS.post_rel"))
7713 hdr
->sh_type
= SHT_MIPS_EVENTS
;
7714 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
7715 /* The sh_link field is set in final_write_processing. */
7717 else if (strcmp (name
, ".msym") == 0)
7719 hdr
->sh_type
= SHT_MIPS_MSYM
;
7720 hdr
->sh_flags
|= SHF_ALLOC
;
7721 hdr
->sh_entsize
= 8;
7723 else if (strcmp (name
, ".MIPS.xhash") == 0)
7725 hdr
->sh_type
= SHT_MIPS_XHASH
;
7726 hdr
->sh_flags
|= SHF_ALLOC
;
7727 hdr
->sh_entsize
= get_elf_backend_data(abfd
)->s
->arch_size
== 64 ? 0 : 4;
7730 /* The generic elf_fake_sections will set up REL_HDR using the default
7731 kind of relocations. We used to set up a second header for the
7732 non-default kind of relocations here, but only NewABI would use
7733 these, and the IRIX ld doesn't like resulting empty RELA sections.
7734 Thus we create those header only on demand now. */
7739 /* Given a BFD section, try to locate the corresponding ELF section
7740 index. This is used by both the 32-bit and the 64-bit ABI.
7741 Actually, it's not clear to me that the 64-bit ABI supports these,
7742 but for non-PIC objects we will certainly want support for at least
7743 the .scommon section. */
7746 _bfd_mips_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
7747 asection
*sec
, int *retval
)
7749 if (strcmp (bfd_section_name (sec
), ".scommon") == 0)
7751 *retval
= SHN_MIPS_SCOMMON
;
7754 if (strcmp (bfd_section_name (sec
), ".acommon") == 0)
7756 *retval
= SHN_MIPS_ACOMMON
;
7762 /* Hook called by the linker routine which adds symbols from an object
7763 file. We must handle the special MIPS section numbers here. */
7766 _bfd_mips_elf_add_symbol_hook (bfd
*abfd
, struct bfd_link_info
*info
,
7767 Elf_Internal_Sym
*sym
, const char **namep
,
7768 flagword
*flagsp ATTRIBUTE_UNUSED
,
7769 asection
**secp
, bfd_vma
*valp
)
7771 if (SGI_COMPAT (abfd
)
7772 && (abfd
->flags
& DYNAMIC
) != 0
7773 && strcmp (*namep
, "_rld_new_interface") == 0)
7775 /* Skip IRIX5 rld entry name. */
7780 /* Shared objects may have a dynamic symbol '_gp_disp' defined as
7781 a SECTION *ABS*. This causes ld to think it can resolve _gp_disp
7782 by setting a DT_NEEDED for the shared object. Since _gp_disp is
7783 a magic symbol resolved by the linker, we ignore this bogus definition
7784 of _gp_disp. New ABI objects do not suffer from this problem so this
7785 is not done for them. */
7787 && (sym
->st_shndx
== SHN_ABS
)
7788 && (strcmp (*namep
, "_gp_disp") == 0))
7794 switch (sym
->st_shndx
)
7797 /* Common symbols less than the GP size are automatically
7798 treated as SHN_MIPS_SCOMMON symbols. */
7799 if (sym
->st_size
> elf_gp_size (abfd
)
7800 || ELF_ST_TYPE (sym
->st_info
) == STT_TLS
7801 || IRIX_COMPAT (abfd
) == ict_irix6
)
7804 case SHN_MIPS_SCOMMON
:
7805 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
7806 (*secp
)->flags
|= SEC_IS_COMMON
;
7807 *valp
= sym
->st_size
;
7811 /* This section is used in a shared object. */
7812 if (mips_elf_tdata (abfd
)->elf_text_section
== NULL
)
7814 asymbol
*elf_text_symbol
;
7815 asection
*elf_text_section
;
7816 size_t amt
= sizeof (asection
);
7818 elf_text_section
= bfd_zalloc (abfd
, amt
);
7819 if (elf_text_section
== NULL
)
7822 amt
= sizeof (asymbol
);
7823 elf_text_symbol
= bfd_zalloc (abfd
, amt
);
7824 if (elf_text_symbol
== NULL
)
7827 /* Initialize the section. */
7829 mips_elf_tdata (abfd
)->elf_text_section
= elf_text_section
;
7830 mips_elf_tdata (abfd
)->elf_text_symbol
= elf_text_symbol
;
7832 elf_text_section
->symbol
= elf_text_symbol
;
7833 elf_text_section
->symbol_ptr_ptr
= &mips_elf_tdata (abfd
)->elf_text_symbol
;
7835 elf_text_section
->name
= ".text";
7836 elf_text_section
->flags
= SEC_NO_FLAGS
;
7837 elf_text_section
->output_section
= NULL
;
7838 elf_text_section
->owner
= abfd
;
7839 elf_text_symbol
->name
= ".text";
7840 elf_text_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
7841 elf_text_symbol
->section
= elf_text_section
;
7843 /* This code used to do *secp = bfd_und_section_ptr if
7844 bfd_link_pic (info). I don't know why, and that doesn't make sense,
7845 so I took it out. */
7846 *secp
= mips_elf_tdata (abfd
)->elf_text_section
;
7849 case SHN_MIPS_ACOMMON
:
7850 /* Fall through. XXX Can we treat this as allocated data? */
7852 /* This section is used in a shared object. */
7853 if (mips_elf_tdata (abfd
)->elf_data_section
== NULL
)
7855 asymbol
*elf_data_symbol
;
7856 asection
*elf_data_section
;
7857 size_t amt
= sizeof (asection
);
7859 elf_data_section
= bfd_zalloc (abfd
, amt
);
7860 if (elf_data_section
== NULL
)
7863 amt
= sizeof (asymbol
);
7864 elf_data_symbol
= bfd_zalloc (abfd
, amt
);
7865 if (elf_data_symbol
== NULL
)
7868 /* Initialize the section. */
7870 mips_elf_tdata (abfd
)->elf_data_section
= elf_data_section
;
7871 mips_elf_tdata (abfd
)->elf_data_symbol
= elf_data_symbol
;
7873 elf_data_section
->symbol
= elf_data_symbol
;
7874 elf_data_section
->symbol_ptr_ptr
= &mips_elf_tdata (abfd
)->elf_data_symbol
;
7876 elf_data_section
->name
= ".data";
7877 elf_data_section
->flags
= SEC_NO_FLAGS
;
7878 elf_data_section
->output_section
= NULL
;
7879 elf_data_section
->owner
= abfd
;
7880 elf_data_symbol
->name
= ".data";
7881 elf_data_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
7882 elf_data_symbol
->section
= elf_data_section
;
7884 /* This code used to do *secp = bfd_und_section_ptr if
7885 bfd_link_pic (info). I don't know why, and that doesn't make sense,
7886 so I took it out. */
7887 *secp
= mips_elf_tdata (abfd
)->elf_data_section
;
7890 case SHN_MIPS_SUNDEFINED
:
7891 *secp
= bfd_und_section_ptr
;
7895 if (SGI_COMPAT (abfd
)
7896 && ! bfd_link_pic (info
)
7897 && info
->output_bfd
->xvec
== abfd
->xvec
7898 && strcmp (*namep
, "__rld_obj_head") == 0)
7900 struct elf_link_hash_entry
*h
;
7901 struct bfd_link_hash_entry
*bh
;
7903 /* Mark __rld_obj_head as dynamic. */
7905 if (! (_bfd_generic_link_add_one_symbol
7906 (info
, abfd
, *namep
, BSF_GLOBAL
, *secp
, *valp
, NULL
, FALSE
,
7907 get_elf_backend_data (abfd
)->collect
, &bh
)))
7910 h
= (struct elf_link_hash_entry
*) bh
;
7913 h
->type
= STT_OBJECT
;
7915 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
7918 mips_elf_hash_table (info
)->use_rld_obj_head
= TRUE
;
7919 mips_elf_hash_table (info
)->rld_symbol
= h
;
7922 /* If this is a mips16 text symbol, add 1 to the value to make it
7923 odd. This will cause something like .word SYM to come up with
7924 the right value when it is loaded into the PC. */
7925 if (ELF_ST_IS_COMPRESSED (sym
->st_other
))
7931 /* This hook function is called before the linker writes out a global
7932 symbol. We mark symbols as small common if appropriate. This is
7933 also where we undo the increment of the value for a mips16 symbol. */
7936 _bfd_mips_elf_link_output_symbol_hook
7937 (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
7938 const char *name ATTRIBUTE_UNUSED
, Elf_Internal_Sym
*sym
,
7939 asection
*input_sec
, struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
)
7941 /* If we see a common symbol, which implies a relocatable link, then
7942 if a symbol was small common in an input file, mark it as small
7943 common in the output file. */
7944 if (sym
->st_shndx
== SHN_COMMON
7945 && strcmp (input_sec
->name
, ".scommon") == 0)
7946 sym
->st_shndx
= SHN_MIPS_SCOMMON
;
7948 if (ELF_ST_IS_COMPRESSED (sym
->st_other
))
7949 sym
->st_value
&= ~1;
7954 /* Functions for the dynamic linker. */
7956 /* Create dynamic sections when linking against a dynamic object. */
7959 _bfd_mips_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
7961 struct elf_link_hash_entry
*h
;
7962 struct bfd_link_hash_entry
*bh
;
7964 register asection
*s
;
7965 const char * const *namep
;
7966 struct mips_elf_link_hash_table
*htab
;
7968 htab
= mips_elf_hash_table (info
);
7969 BFD_ASSERT (htab
!= NULL
);
7971 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
7972 | SEC_LINKER_CREATED
| SEC_READONLY
);
7974 /* The psABI requires a read-only .dynamic section, but the VxWorks
7976 if (!htab
->is_vxworks
)
7978 s
= bfd_get_linker_section (abfd
, ".dynamic");
7981 if (!bfd_set_section_flags (s
, flags
))
7986 /* We need to create .got section. */
7987 if (!mips_elf_create_got_section (abfd
, info
))
7990 if (! mips_elf_rel_dyn_section (info
, TRUE
))
7993 /* Create .stub section. */
7994 s
= bfd_make_section_anyway_with_flags (abfd
,
7995 MIPS_ELF_STUB_SECTION_NAME (abfd
),
7998 || !bfd_set_section_alignment (s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
8002 if (!mips_elf_hash_table (info
)->use_rld_obj_head
8003 && bfd_link_executable (info
)
8004 && bfd_get_linker_section (abfd
, ".rld_map") == NULL
)
8006 s
= bfd_make_section_anyway_with_flags (abfd
, ".rld_map",
8007 flags
&~ (flagword
) SEC_READONLY
);
8009 || !bfd_set_section_alignment (s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
8013 /* Create .MIPS.xhash section. */
8014 if (info
->emit_gnu_hash
)
8015 s
= bfd_make_section_anyway_with_flags (abfd
, ".MIPS.xhash",
8016 flags
| SEC_READONLY
);
8018 /* On IRIX5, we adjust add some additional symbols and change the
8019 alignments of several sections. There is no ABI documentation
8020 indicating that this is necessary on IRIX6, nor any evidence that
8021 the linker takes such action. */
8022 if (IRIX_COMPAT (abfd
) == ict_irix5
)
8024 for (namep
= mips_elf_dynsym_rtproc_names
; *namep
!= NULL
; namep
++)
8027 if (! (_bfd_generic_link_add_one_symbol
8028 (info
, abfd
, *namep
, BSF_GLOBAL
, bfd_und_section_ptr
, 0,
8029 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
8032 h
= (struct elf_link_hash_entry
*) bh
;
8036 h
->type
= STT_SECTION
;
8038 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
8042 /* We need to create a .compact_rel section. */
8043 if (SGI_COMPAT (abfd
))
8045 if (!mips_elf_create_compact_rel_section (abfd
, info
))
8049 /* Change alignments of some sections. */
8050 s
= bfd_get_linker_section (abfd
, ".hash");
8052 bfd_set_section_alignment (s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
8054 s
= bfd_get_linker_section (abfd
, ".dynsym");
8056 bfd_set_section_alignment (s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
8058 s
= bfd_get_linker_section (abfd
, ".dynstr");
8060 bfd_set_section_alignment (s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
8063 s
= bfd_get_section_by_name (abfd
, ".reginfo");
8065 bfd_set_section_alignment (s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
8067 s
= bfd_get_linker_section (abfd
, ".dynamic");
8069 bfd_set_section_alignment (s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
8072 if (bfd_link_executable (info
))
8076 name
= SGI_COMPAT (abfd
) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
8078 if (!(_bfd_generic_link_add_one_symbol
8079 (info
, abfd
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
, 0,
8080 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
8083 h
= (struct elf_link_hash_entry
*) bh
;
8086 h
->type
= STT_SECTION
;
8088 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
8091 if (! mips_elf_hash_table (info
)->use_rld_obj_head
)
8093 /* __rld_map is a four byte word located in the .data section
8094 and is filled in by the rtld to contain a pointer to
8095 the _r_debug structure. Its symbol value will be set in
8096 _bfd_mips_elf_finish_dynamic_symbol. */
8097 s
= bfd_get_linker_section (abfd
, ".rld_map");
8098 BFD_ASSERT (s
!= NULL
);
8100 name
= SGI_COMPAT (abfd
) ? "__rld_map" : "__RLD_MAP";
8102 if (!(_bfd_generic_link_add_one_symbol
8103 (info
, abfd
, name
, BSF_GLOBAL
, s
, 0, NULL
, FALSE
,
8104 get_elf_backend_data (abfd
)->collect
, &bh
)))
8107 h
= (struct elf_link_hash_entry
*) bh
;
8110 h
->type
= STT_OBJECT
;
8112 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
8114 mips_elf_hash_table (info
)->rld_symbol
= h
;
8118 /* Create the .plt, .rel(a).plt, .dynbss and .rel(a).bss sections.
8119 Also, on VxWorks, create the _PROCEDURE_LINKAGE_TABLE_ symbol. */
8120 if (!_bfd_elf_create_dynamic_sections (abfd
, info
))
8123 /* Do the usual VxWorks handling. */
8124 if (htab
->is_vxworks
8125 && !elf_vxworks_create_dynamic_sections (abfd
, info
, &htab
->srelplt2
))
8131 /* Return true if relocation REL against section SEC is a REL rather than
8132 RELA relocation. RELOCS is the first relocation in the section and
8133 ABFD is the bfd that contains SEC. */
8136 mips_elf_rel_relocation_p (bfd
*abfd
, asection
*sec
,
8137 const Elf_Internal_Rela
*relocs
,
8138 const Elf_Internal_Rela
*rel
)
8140 Elf_Internal_Shdr
*rel_hdr
;
8141 const struct elf_backend_data
*bed
;
8143 /* To determine which flavor of relocation this is, we depend on the
8144 fact that the INPUT_SECTION's REL_HDR is read before RELA_HDR. */
8145 rel_hdr
= elf_section_data (sec
)->rel
.hdr
;
8146 if (rel_hdr
== NULL
)
8148 bed
= get_elf_backend_data (abfd
);
8149 return ((size_t) (rel
- relocs
)
8150 < NUM_SHDR_ENTRIES (rel_hdr
) * bed
->s
->int_rels_per_ext_rel
);
8153 /* Read the addend for REL relocation REL, which belongs to bfd ABFD.
8154 HOWTO is the relocation's howto and CONTENTS points to the contents
8155 of the section that REL is against. */
8158 mips_elf_read_rel_addend (bfd
*abfd
, const Elf_Internal_Rela
*rel
,
8159 reloc_howto_type
*howto
, bfd_byte
*contents
)
8162 unsigned int r_type
;
8166 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
8167 location
= contents
+ rel
->r_offset
;
8169 /* Get the addend, which is stored in the input file. */
8170 _bfd_mips_elf_reloc_unshuffle (abfd
, r_type
, FALSE
, location
);
8171 bytes
= mips_elf_obtain_contents (howto
, rel
, abfd
, contents
);
8172 _bfd_mips_elf_reloc_shuffle (abfd
, r_type
, FALSE
, location
);
8174 addend
= bytes
& howto
->src_mask
;
8176 /* Shift is 2, unusually, for microMIPS JALX. Adjust the addend
8178 if (r_type
== R_MICROMIPS_26_S1
&& (bytes
>> 26) == 0x3c)
8184 /* REL is a relocation in ABFD that needs a partnering LO16 relocation
8185 and *ADDEND is the addend for REL itself. Look for the LO16 relocation
8186 and update *ADDEND with the final addend. Return true on success
8187 or false if the LO16 could not be found. RELEND is the exclusive
8188 upper bound on the relocations for REL's section. */
8191 mips_elf_add_lo16_rel_addend (bfd
*abfd
,
8192 const Elf_Internal_Rela
*rel
,
8193 const Elf_Internal_Rela
*relend
,
8194 bfd_byte
*contents
, bfd_vma
*addend
)
8196 unsigned int r_type
, lo16_type
;
8197 const Elf_Internal_Rela
*lo16_relocation
;
8198 reloc_howto_type
*lo16_howto
;
8201 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
8202 if (mips16_reloc_p (r_type
))
8203 lo16_type
= R_MIPS16_LO16
;
8204 else if (micromips_reloc_p (r_type
))
8205 lo16_type
= R_MICROMIPS_LO16
;
8206 else if (r_type
== R_MIPS_PCHI16
)
8207 lo16_type
= R_MIPS_PCLO16
;
8209 lo16_type
= R_MIPS_LO16
;
8211 /* The combined value is the sum of the HI16 addend, left-shifted by
8212 sixteen bits, and the LO16 addend, sign extended. (Usually, the
8213 code does a `lui' of the HI16 value, and then an `addiu' of the
8216 Scan ahead to find a matching LO16 relocation.
8218 According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must
8219 be immediately following. However, for the IRIX6 ABI, the next
8220 relocation may be a composed relocation consisting of several
8221 relocations for the same address. In that case, the R_MIPS_LO16
8222 relocation may occur as one of these. We permit a similar
8223 extension in general, as that is useful for GCC.
8225 In some cases GCC dead code elimination removes the LO16 but keeps
8226 the corresponding HI16. This is strictly speaking a violation of
8227 the ABI but not immediately harmful. */
8228 lo16_relocation
= mips_elf_next_relocation (abfd
, lo16_type
, rel
, relend
);
8229 if (lo16_relocation
== NULL
)
8232 /* Obtain the addend kept there. */
8233 lo16_howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, lo16_type
, FALSE
);
8234 l
= mips_elf_read_rel_addend (abfd
, lo16_relocation
, lo16_howto
, contents
);
8236 l
<<= lo16_howto
->rightshift
;
8237 l
= _bfd_mips_elf_sign_extend (l
, 16);
8244 /* Try to read the contents of section SEC in bfd ABFD. Return true and
8245 store the contents in *CONTENTS on success. Assume that *CONTENTS
8246 already holds the contents if it is nonull on entry. */
8249 mips_elf_get_section_contents (bfd
*abfd
, asection
*sec
, bfd_byte
**contents
)
8254 /* Get cached copy if it exists. */
8255 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
8257 *contents
= elf_section_data (sec
)->this_hdr
.contents
;
8261 return bfd_malloc_and_get_section (abfd
, sec
, contents
);
8264 /* Make a new PLT record to keep internal data. */
8266 static struct plt_entry
*
8267 mips_elf_make_plt_record (bfd
*abfd
)
8269 struct plt_entry
*entry
;
8271 entry
= bfd_zalloc (abfd
, sizeof (*entry
));
8275 entry
->stub_offset
= MINUS_ONE
;
8276 entry
->mips_offset
= MINUS_ONE
;
8277 entry
->comp_offset
= MINUS_ONE
;
8278 entry
->gotplt_index
= MINUS_ONE
;
8282 /* Define the special `__gnu_absolute_zero' symbol. We only need this
8283 for PIC code, as otherwise there is no load-time relocation involved
8284 and local GOT entries whose value is zero at static link time will
8285 retain their value at load time. */
8288 mips_elf_define_absolute_zero (bfd
*abfd
, struct bfd_link_info
*info
,
8289 struct mips_elf_link_hash_table
*htab
,
8290 unsigned int r_type
)
8294 struct elf_link_hash_entry
*eh
;
8295 struct bfd_link_hash_entry
*bh
;
8299 BFD_ASSERT (!htab
->use_absolute_zero
);
8300 BFD_ASSERT (bfd_link_pic (info
));
8303 if (!_bfd_generic_link_add_one_symbol (info
, abfd
, "__gnu_absolute_zero",
8304 BSF_GLOBAL
, bfd_abs_section_ptr
, 0,
8305 NULL
, FALSE
, FALSE
, &hzero
.bh
))
8308 BFD_ASSERT (hzero
.bh
!= NULL
);
8310 hzero
.eh
->type
= STT_NOTYPE
;
8311 hzero
.eh
->other
= STV_PROTECTED
;
8312 hzero
.eh
->def_regular
= 1;
8313 hzero
.eh
->non_elf
= 0;
8315 if (!mips_elf_record_global_got_symbol (hzero
.eh
, abfd
, info
, TRUE
, r_type
))
8318 htab
->use_absolute_zero
= TRUE
;
8323 /* Look through the relocs for a section during the first phase, and
8324 allocate space in the global offset table and record the need for
8325 standard MIPS and compressed procedure linkage table entries. */
8328 _bfd_mips_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
8329 asection
*sec
, const Elf_Internal_Rela
*relocs
)
8333 Elf_Internal_Shdr
*symtab_hdr
;
8334 struct elf_link_hash_entry
**sym_hashes
;
8336 const Elf_Internal_Rela
*rel
;
8337 const Elf_Internal_Rela
*rel_end
;
8339 const struct elf_backend_data
*bed
;
8340 struct mips_elf_link_hash_table
*htab
;
8343 reloc_howto_type
*howto
;
8345 if (bfd_link_relocatable (info
))
8348 htab
= mips_elf_hash_table (info
);
8349 BFD_ASSERT (htab
!= NULL
);
8351 dynobj
= elf_hash_table (info
)->dynobj
;
8352 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
8353 sym_hashes
= elf_sym_hashes (abfd
);
8354 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
8356 bed
= get_elf_backend_data (abfd
);
8357 rel_end
= relocs
+ sec
->reloc_count
;
8359 /* Check for the mips16 stub sections. */
8361 name
= bfd_section_name (sec
);
8362 if (FN_STUB_P (name
))
8364 unsigned long r_symndx
;
8366 /* Look at the relocation information to figure out which symbol
8369 r_symndx
= mips16_stub_symndx (bed
, sec
, relocs
, rel_end
);
8373 /* xgettext:c-format */
8374 (_("%pB: warning: cannot determine the target function for"
8375 " stub section `%s'"),
8377 bfd_set_error (bfd_error_bad_value
);
8381 if (r_symndx
< extsymoff
8382 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
8386 /* This stub is for a local symbol. This stub will only be
8387 needed if there is some relocation in this BFD, other
8388 than a 16 bit function call, which refers to this symbol. */
8389 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
8391 Elf_Internal_Rela
*sec_relocs
;
8392 const Elf_Internal_Rela
*r
, *rend
;
8394 /* We can ignore stub sections when looking for relocs. */
8395 if ((o
->flags
& SEC_RELOC
) == 0
8396 || o
->reloc_count
== 0
8397 || section_allows_mips16_refs_p (o
))
8401 = _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
8403 if (sec_relocs
== NULL
)
8406 rend
= sec_relocs
+ o
->reloc_count
;
8407 for (r
= sec_relocs
; r
< rend
; r
++)
8408 if (ELF_R_SYM (abfd
, r
->r_info
) == r_symndx
8409 && !mips16_call_reloc_p (ELF_R_TYPE (abfd
, r
->r_info
)))
8412 if (elf_section_data (o
)->relocs
!= sec_relocs
)
8421 /* There is no non-call reloc for this stub, so we do
8422 not need it. Since this function is called before
8423 the linker maps input sections to output sections, we
8424 can easily discard it by setting the SEC_EXCLUDE
8426 sec
->flags
|= SEC_EXCLUDE
;
8430 /* Record this stub in an array of local symbol stubs for
8432 if (mips_elf_tdata (abfd
)->local_stubs
== NULL
)
8434 unsigned long symcount
;
8438 if (elf_bad_symtab (abfd
))
8439 symcount
= NUM_SHDR_ENTRIES (symtab_hdr
);
8441 symcount
= symtab_hdr
->sh_info
;
8442 amt
= symcount
* sizeof (asection
*);
8443 n
= bfd_zalloc (abfd
, amt
);
8446 mips_elf_tdata (abfd
)->local_stubs
= n
;
8449 sec
->flags
|= SEC_KEEP
;
8450 mips_elf_tdata (abfd
)->local_stubs
[r_symndx
] = sec
;
8452 /* We don't need to set mips16_stubs_seen in this case.
8453 That flag is used to see whether we need to look through
8454 the global symbol table for stubs. We don't need to set
8455 it here, because we just have a local stub. */
8459 struct mips_elf_link_hash_entry
*h
;
8461 h
= ((struct mips_elf_link_hash_entry
*)
8462 sym_hashes
[r_symndx
- extsymoff
]);
8464 while (h
->root
.root
.type
== bfd_link_hash_indirect
8465 || h
->root
.root
.type
== bfd_link_hash_warning
)
8466 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
8468 /* H is the symbol this stub is for. */
8470 /* If we already have an appropriate stub for this function, we
8471 don't need another one, so we can discard this one. Since
8472 this function is called before the linker maps input sections
8473 to output sections, we can easily discard it by setting the
8474 SEC_EXCLUDE flag. */
8475 if (h
->fn_stub
!= NULL
)
8477 sec
->flags
|= SEC_EXCLUDE
;
8481 sec
->flags
|= SEC_KEEP
;
8483 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
8486 else if (CALL_STUB_P (name
) || CALL_FP_STUB_P (name
))
8488 unsigned long r_symndx
;
8489 struct mips_elf_link_hash_entry
*h
;
8492 /* Look at the relocation information to figure out which symbol
8495 r_symndx
= mips16_stub_symndx (bed
, sec
, relocs
, rel_end
);
8499 /* xgettext:c-format */
8500 (_("%pB: warning: cannot determine the target function for"
8501 " stub section `%s'"),
8503 bfd_set_error (bfd_error_bad_value
);
8507 if (r_symndx
< extsymoff
8508 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
8512 /* This stub is for a local symbol. This stub will only be
8513 needed if there is some relocation (R_MIPS16_26) in this BFD
8514 that refers to this symbol. */
8515 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
8517 Elf_Internal_Rela
*sec_relocs
;
8518 const Elf_Internal_Rela
*r
, *rend
;
8520 /* We can ignore stub sections when looking for relocs. */
8521 if ((o
->flags
& SEC_RELOC
) == 0
8522 || o
->reloc_count
== 0
8523 || section_allows_mips16_refs_p (o
))
8527 = _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
8529 if (sec_relocs
== NULL
)
8532 rend
= sec_relocs
+ o
->reloc_count
;
8533 for (r
= sec_relocs
; r
< rend
; r
++)
8534 if (ELF_R_SYM (abfd
, r
->r_info
) == r_symndx
8535 && ELF_R_TYPE (abfd
, r
->r_info
) == R_MIPS16_26
)
8538 if (elf_section_data (o
)->relocs
!= sec_relocs
)
8547 /* There is no non-call reloc for this stub, so we do
8548 not need it. Since this function is called before
8549 the linker maps input sections to output sections, we
8550 can easily discard it by setting the SEC_EXCLUDE
8552 sec
->flags
|= SEC_EXCLUDE
;
8556 /* Record this stub in an array of local symbol call_stubs for
8558 if (mips_elf_tdata (abfd
)->local_call_stubs
== NULL
)
8560 unsigned long symcount
;
8564 if (elf_bad_symtab (abfd
))
8565 symcount
= NUM_SHDR_ENTRIES (symtab_hdr
);
8567 symcount
= symtab_hdr
->sh_info
;
8568 amt
= symcount
* sizeof (asection
*);
8569 n
= bfd_zalloc (abfd
, amt
);
8572 mips_elf_tdata (abfd
)->local_call_stubs
= n
;
8575 sec
->flags
|= SEC_KEEP
;
8576 mips_elf_tdata (abfd
)->local_call_stubs
[r_symndx
] = sec
;
8578 /* We don't need to set mips16_stubs_seen in this case.
8579 That flag is used to see whether we need to look through
8580 the global symbol table for stubs. We don't need to set
8581 it here, because we just have a local stub. */
8585 h
= ((struct mips_elf_link_hash_entry
*)
8586 sym_hashes
[r_symndx
- extsymoff
]);
8588 /* H is the symbol this stub is for. */
8590 if (CALL_FP_STUB_P (name
))
8591 loc
= &h
->call_fp_stub
;
8593 loc
= &h
->call_stub
;
8595 /* If we already have an appropriate stub for this function, we
8596 don't need another one, so we can discard this one. Since
8597 this function is called before the linker maps input sections
8598 to output sections, we can easily discard it by setting the
8599 SEC_EXCLUDE flag. */
8602 sec
->flags
|= SEC_EXCLUDE
;
8606 sec
->flags
|= SEC_KEEP
;
8608 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
8614 for (rel
= relocs
; rel
< rel_end
; ++rel
)
8616 unsigned long r_symndx
;
8617 unsigned int r_type
;
8618 struct elf_link_hash_entry
*h
;
8619 bfd_boolean can_make_dynamic_p
;
8620 bfd_boolean call_reloc_p
;
8621 bfd_boolean constrain_symbol_p
;
8623 r_symndx
= ELF_R_SYM (abfd
, rel
->r_info
);
8624 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
8626 if (r_symndx
< extsymoff
)
8628 else if (r_symndx
>= extsymoff
+ NUM_SHDR_ENTRIES (symtab_hdr
))
8631 /* xgettext:c-format */
8632 (_("%pB: malformed reloc detected for section %s"),
8634 bfd_set_error (bfd_error_bad_value
);
8639 h
= sym_hashes
[r_symndx
- extsymoff
];
8642 while (h
->root
.type
== bfd_link_hash_indirect
8643 || h
->root
.type
== bfd_link_hash_warning
)
8644 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
8648 /* Set CAN_MAKE_DYNAMIC_P to true if we can convert this
8649 relocation into a dynamic one. */
8650 can_make_dynamic_p
= FALSE
;
8652 /* Set CALL_RELOC_P to true if the relocation is for a call,
8653 and if pointer equality therefore doesn't matter. */
8654 call_reloc_p
= FALSE
;
8656 /* Set CONSTRAIN_SYMBOL_P if we need to take the relocation
8657 into account when deciding how to define the symbol. */
8658 constrain_symbol_p
= TRUE
;
8663 case R_MIPS_CALL_HI16
:
8664 case R_MIPS_CALL_LO16
:
8665 case R_MIPS16_CALL16
:
8666 case R_MICROMIPS_CALL16
:
8667 case R_MICROMIPS_CALL_HI16
:
8668 case R_MICROMIPS_CALL_LO16
:
8669 call_reloc_p
= TRUE
;
8673 case R_MIPS_GOT_LO16
:
8674 case R_MIPS_GOT_PAGE
:
8675 case R_MIPS_GOT_DISP
:
8676 case R_MIPS16_GOT16
:
8677 case R_MICROMIPS_GOT16
:
8678 case R_MICROMIPS_GOT_LO16
:
8679 case R_MICROMIPS_GOT_PAGE
:
8680 case R_MICROMIPS_GOT_DISP
:
8681 /* If we have a symbol that will resolve to zero at static link
8682 time and it is used by a GOT relocation applied to code we
8683 cannot relax to an immediate zero load, then we will be using
8684 the special `__gnu_absolute_zero' symbol whose value is zero
8685 at dynamic load time. We ignore HI16-type GOT relocations at
8686 this stage, because their handling will depend entirely on
8687 the corresponding LO16-type GOT relocation. */
8688 if (!call_hi16_reloc_p (r_type
)
8690 && bfd_link_pic (info
)
8691 && !htab
->use_absolute_zero
8692 && UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
8694 bfd_boolean rel_reloc
;
8696 if (!mips_elf_get_section_contents (abfd
, sec
, &contents
))
8699 rel_reloc
= mips_elf_rel_relocation_p (abfd
, sec
, relocs
, rel
);
8700 howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, r_type
, !rel_reloc
);
8702 if (!mips_elf_nullify_got_load (abfd
, contents
, rel
, howto
,
8704 if (!mips_elf_define_absolute_zero (abfd
, info
, htab
, r_type
))
8709 case R_MIPS_GOT_HI16
:
8710 case R_MIPS_GOT_OFST
:
8711 case R_MIPS_TLS_GOTTPREL
:
8713 case R_MIPS_TLS_LDM
:
8714 case R_MIPS16_TLS_GOTTPREL
:
8715 case R_MIPS16_TLS_GD
:
8716 case R_MIPS16_TLS_LDM
:
8717 case R_MICROMIPS_GOT_HI16
:
8718 case R_MICROMIPS_GOT_OFST
:
8719 case R_MICROMIPS_TLS_GOTTPREL
:
8720 case R_MICROMIPS_TLS_GD
:
8721 case R_MICROMIPS_TLS_LDM
:
8723 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
8724 if (!mips_elf_create_got_section (dynobj
, info
))
8726 if (htab
->is_vxworks
&& !bfd_link_pic (info
))
8729 /* xgettext:c-format */
8730 (_("%pB: GOT reloc at %#" PRIx64
" not expected in executables"),
8731 abfd
, (uint64_t) rel
->r_offset
);
8732 bfd_set_error (bfd_error_bad_value
);
8735 can_make_dynamic_p
= TRUE
;
8740 case R_MICROMIPS_JALR
:
8741 /* These relocations have empty fields and are purely there to
8742 provide link information. The symbol value doesn't matter. */
8743 constrain_symbol_p
= FALSE
;
8746 case R_MIPS_GPREL16
:
8747 case R_MIPS_GPREL32
:
8748 case R_MIPS16_GPREL
:
8749 case R_MICROMIPS_GPREL16
:
8750 /* GP-relative relocations always resolve to a definition in a
8751 regular input file, ignoring the one-definition rule. This is
8752 important for the GP setup sequence in NewABI code, which
8753 always resolves to a local function even if other relocations
8754 against the symbol wouldn't. */
8755 constrain_symbol_p
= FALSE
;
8761 /* In VxWorks executables, references to external symbols
8762 must be handled using copy relocs or PLT entries; it is not
8763 possible to convert this relocation into a dynamic one.
8765 For executables that use PLTs and copy-relocs, we have a
8766 choice between converting the relocation into a dynamic
8767 one or using copy relocations or PLT entries. It is
8768 usually better to do the former, unless the relocation is
8769 against a read-only section. */
8770 if ((bfd_link_pic (info
)
8772 && !htab
->is_vxworks
8773 && strcmp (h
->root
.root
.string
, "__gnu_local_gp") != 0
8774 && !(!info
->nocopyreloc
8775 && !PIC_OBJECT_P (abfd
)
8776 && MIPS_ELF_READONLY_SECTION (sec
))))
8777 && (sec
->flags
& SEC_ALLOC
) != 0)
8779 can_make_dynamic_p
= TRUE
;
8781 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
8787 case R_MIPS_PC21_S2
:
8788 case R_MIPS_PC26_S2
:
8790 case R_MIPS16_PC16_S1
:
8791 case R_MICROMIPS_26_S1
:
8792 case R_MICROMIPS_PC7_S1
:
8793 case R_MICROMIPS_PC10_S1
:
8794 case R_MICROMIPS_PC16_S1
:
8795 case R_MICROMIPS_PC23_S2
:
8796 call_reloc_p
= TRUE
;
8802 if (constrain_symbol_p
)
8804 if (!can_make_dynamic_p
)
8805 ((struct mips_elf_link_hash_entry
*) h
)->has_static_relocs
= 1;
8808 h
->pointer_equality_needed
= 1;
8810 /* We must not create a stub for a symbol that has
8811 relocations related to taking the function's address.
8812 This doesn't apply to VxWorks, where CALL relocs refer
8813 to a .got.plt entry instead of a normal .got entry. */
8814 if (!htab
->is_vxworks
&& (!can_make_dynamic_p
|| !call_reloc_p
))
8815 ((struct mips_elf_link_hash_entry
*) h
)->no_fn_stub
= TRUE
;
8818 /* Relocations against the special VxWorks __GOTT_BASE__ and
8819 __GOTT_INDEX__ symbols must be left to the loader. Allocate
8820 room for them in .rela.dyn. */
8821 if (is_gott_symbol (info
, h
))
8825 sreloc
= mips_elf_rel_dyn_section (info
, TRUE
);
8829 mips_elf_allocate_dynamic_relocations (dynobj
, info
, 1);
8830 if (MIPS_ELF_READONLY_SECTION (sec
))
8831 /* We tell the dynamic linker that there are
8832 relocations against the text segment. */
8833 info
->flags
|= DF_TEXTREL
;
8836 else if (call_lo16_reloc_p (r_type
)
8837 || got_lo16_reloc_p (r_type
)
8838 || got_disp_reloc_p (r_type
)
8839 || (got16_reloc_p (r_type
) && htab
->is_vxworks
))
8841 /* We may need a local GOT entry for this relocation. We
8842 don't count R_MIPS_GOT_PAGE because we can estimate the
8843 maximum number of pages needed by looking at the size of
8844 the segment. Similar comments apply to R_MIPS*_GOT16 and
8845 R_MIPS*_CALL16, except on VxWorks, where GOT relocations
8846 always evaluate to "G". We don't count R_MIPS_GOT_HI16, or
8847 R_MIPS_CALL_HI16 because these are always followed by an
8848 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
8849 if (!mips_elf_record_local_got_symbol (abfd
, r_symndx
,
8850 rel
->r_addend
, info
, r_type
))
8855 && mips_elf_relocation_needs_la25_stub (abfd
, r_type
,
8856 ELF_ST_IS_MIPS16 (h
->other
)))
8857 ((struct mips_elf_link_hash_entry
*) h
)->has_nonpic_branches
= TRUE
;
8862 case R_MIPS16_CALL16
:
8863 case R_MICROMIPS_CALL16
:
8867 /* xgettext:c-format */
8868 (_("%pB: CALL16 reloc at %#" PRIx64
" not against global symbol"),
8869 abfd
, (uint64_t) rel
->r_offset
);
8870 bfd_set_error (bfd_error_bad_value
);
8875 case R_MIPS_CALL_HI16
:
8876 case R_MIPS_CALL_LO16
:
8877 case R_MICROMIPS_CALL_HI16
:
8878 case R_MICROMIPS_CALL_LO16
:
8881 /* Make sure there is room in the regular GOT to hold the
8882 function's address. We may eliminate it in favour of
8883 a .got.plt entry later; see mips_elf_count_got_symbols. */
8884 if (!mips_elf_record_global_got_symbol (h
, abfd
, info
, TRUE
,
8888 /* We need a stub, not a plt entry for the undefined
8889 function. But we record it as if it needs plt. See
8890 _bfd_elf_adjust_dynamic_symbol. */
8896 case R_MIPS_GOT_PAGE
:
8897 case R_MICROMIPS_GOT_PAGE
:
8898 case R_MIPS16_GOT16
:
8900 case R_MIPS_GOT_HI16
:
8901 case R_MIPS_GOT_LO16
:
8902 case R_MICROMIPS_GOT16
:
8903 case R_MICROMIPS_GOT_HI16
:
8904 case R_MICROMIPS_GOT_LO16
:
8905 if (!h
|| got_page_reloc_p (r_type
))
8907 /* This relocation needs (or may need, if h != NULL) a
8908 page entry in the GOT. For R_MIPS_GOT_PAGE we do not
8909 know for sure until we know whether the symbol is
8911 if (mips_elf_rel_relocation_p (abfd
, sec
, relocs
, rel
))
8913 if (!mips_elf_get_section_contents (abfd
, sec
, &contents
))
8915 howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, r_type
, FALSE
);
8916 addend
= mips_elf_read_rel_addend (abfd
, rel
,
8918 if (got16_reloc_p (r_type
))
8919 mips_elf_add_lo16_rel_addend (abfd
, rel
, rel_end
,
8922 addend
<<= howto
->rightshift
;
8925 addend
= rel
->r_addend
;
8926 if (!mips_elf_record_got_page_ref (info
, abfd
, r_symndx
,
8932 struct mips_elf_link_hash_entry
*hmips
=
8933 (struct mips_elf_link_hash_entry
*) h
;
8935 /* This symbol is definitely not overridable. */
8936 if (hmips
->root
.def_regular
8937 && ! (bfd_link_pic (info
) && ! info
->symbolic
8938 && ! hmips
->root
.forced_local
))
8942 /* If this is a global, overridable symbol, GOT_PAGE will
8943 decay to GOT_DISP, so we'll need a GOT entry for it. */
8946 case R_MIPS_GOT_DISP
:
8947 case R_MICROMIPS_GOT_DISP
:
8948 if (h
&& !mips_elf_record_global_got_symbol (h
, abfd
, info
,
8953 case R_MIPS_TLS_GOTTPREL
:
8954 case R_MIPS16_TLS_GOTTPREL
:
8955 case R_MICROMIPS_TLS_GOTTPREL
:
8956 if (bfd_link_pic (info
))
8957 info
->flags
|= DF_STATIC_TLS
;
8960 case R_MIPS_TLS_LDM
:
8961 case R_MIPS16_TLS_LDM
:
8962 case R_MICROMIPS_TLS_LDM
:
8963 if (tls_ldm_reloc_p (r_type
))
8965 r_symndx
= STN_UNDEF
;
8971 case R_MIPS16_TLS_GD
:
8972 case R_MICROMIPS_TLS_GD
:
8973 /* This symbol requires a global offset table entry, or two
8974 for TLS GD relocations. */
8977 if (!mips_elf_record_global_got_symbol (h
, abfd
, info
,
8983 if (!mips_elf_record_local_got_symbol (abfd
, r_symndx
,
8993 /* In VxWorks executables, references to external symbols
8994 are handled using copy relocs or PLT stubs, so there's
8995 no need to add a .rela.dyn entry for this relocation. */
8996 if (can_make_dynamic_p
)
9000 sreloc
= mips_elf_rel_dyn_section (info
, TRUE
);
9004 if (bfd_link_pic (info
) && h
== NULL
)
9006 /* When creating a shared object, we must copy these
9007 reloc types into the output file as R_MIPS_REL32
9008 relocs. Make room for this reloc in .rel(a).dyn. */
9009 mips_elf_allocate_dynamic_relocations (dynobj
, info
, 1);
9010 if (MIPS_ELF_READONLY_SECTION (sec
))
9011 /* We tell the dynamic linker that there are
9012 relocations against the text segment. */
9013 info
->flags
|= DF_TEXTREL
;
9017 struct mips_elf_link_hash_entry
*hmips
;
9019 /* For a shared object, we must copy this relocation
9020 unless the symbol turns out to be undefined and
9021 weak with non-default visibility, in which case
9022 it will be left as zero.
9024 We could elide R_MIPS_REL32 for locally binding symbols
9025 in shared libraries, but do not yet do so.
9027 For an executable, we only need to copy this
9028 reloc if the symbol is defined in a dynamic
9030 hmips
= (struct mips_elf_link_hash_entry
*) h
;
9031 ++hmips
->possibly_dynamic_relocs
;
9032 if (MIPS_ELF_READONLY_SECTION (sec
))
9033 /* We need it to tell the dynamic linker if there
9034 are relocations against the text segment. */
9035 hmips
->readonly_reloc
= TRUE
;
9039 if (SGI_COMPAT (abfd
))
9040 mips_elf_hash_table (info
)->compact_rel_size
+=
9041 sizeof (Elf32_External_crinfo
);
9045 case R_MIPS_GPREL16
:
9046 case R_MIPS_LITERAL
:
9047 case R_MIPS_GPREL32
:
9048 case R_MICROMIPS_26_S1
:
9049 case R_MICROMIPS_GPREL16
:
9050 case R_MICROMIPS_LITERAL
:
9051 case R_MICROMIPS_GPREL7_S2
:
9052 if (SGI_COMPAT (abfd
))
9053 mips_elf_hash_table (info
)->compact_rel_size
+=
9054 sizeof (Elf32_External_crinfo
);
9057 /* This relocation describes the C++ object vtable hierarchy.
9058 Reconstruct it for later use during GC. */
9059 case R_MIPS_GNU_VTINHERIT
:
9060 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
9064 /* This relocation describes which C++ vtable entries are actually
9065 used. Record for later use during GC. */
9066 case R_MIPS_GNU_VTENTRY
:
9067 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
9075 /* Record the need for a PLT entry. At this point we don't know
9076 yet if we are going to create a PLT in the first place, but
9077 we only record whether the relocation requires a standard MIPS
9078 or a compressed code entry anyway. If we don't make a PLT after
9079 all, then we'll just ignore these arrangements. Likewise if
9080 a PLT entry is not created because the symbol is satisfied
9083 && (branch_reloc_p (r_type
)
9084 || mips16_branch_reloc_p (r_type
)
9085 || micromips_branch_reloc_p (r_type
))
9086 && !SYMBOL_CALLS_LOCAL (info
, h
))
9088 if (h
->plt
.plist
== NULL
)
9089 h
->plt
.plist
= mips_elf_make_plt_record (abfd
);
9090 if (h
->plt
.plist
== NULL
)
9093 if (branch_reloc_p (r_type
))
9094 h
->plt
.plist
->need_mips
= TRUE
;
9096 h
->plt
.plist
->need_comp
= TRUE
;
9099 /* See if this reloc would need to refer to a MIPS16 hard-float stub,
9100 if there is one. We only need to handle global symbols here;
9101 we decide whether to keep or delete stubs for local symbols
9102 when processing the stub's relocations. */
9104 && !mips16_call_reloc_p (r_type
)
9105 && !section_allows_mips16_refs_p (sec
))
9107 struct mips_elf_link_hash_entry
*mh
;
9109 mh
= (struct mips_elf_link_hash_entry
*) h
;
9110 mh
->need_fn_stub
= TRUE
;
9113 /* Refuse some position-dependent relocations when creating a
9114 shared library. Do not refuse R_MIPS_32 / R_MIPS_64; they're
9115 not PIC, but we can create dynamic relocations and the result
9116 will be fine. Also do not refuse R_MIPS_LO16, which can be
9117 combined with R_MIPS_GOT16. */
9118 if (bfd_link_pic (info
))
9122 case R_MIPS_TLS_TPREL_HI16
:
9123 case R_MIPS16_TLS_TPREL_HI16
:
9124 case R_MICROMIPS_TLS_TPREL_HI16
:
9125 case R_MIPS_TLS_TPREL_LO16
:
9126 case R_MIPS16_TLS_TPREL_LO16
:
9127 case R_MICROMIPS_TLS_TPREL_LO16
:
9128 /* These are okay in PIE, but not in a shared library. */
9129 if (bfd_link_executable (info
))
9137 case R_MIPS_HIGHEST
:
9138 case R_MICROMIPS_HI16
:
9139 case R_MICROMIPS_HIGHER
:
9140 case R_MICROMIPS_HIGHEST
:
9141 /* Don't refuse a high part relocation if it's against
9142 no symbol (e.g. part of a compound relocation). */
9143 if (r_symndx
== STN_UNDEF
)
9146 /* Likewise an absolute symbol. */
9147 if (h
!= NULL
&& bfd_is_abs_symbol (&h
->root
))
9150 /* R_MIPS_HI16 against _gp_disp is used for $gp setup,
9151 and has a special meaning. */
9152 if (!NEWABI_P (abfd
) && h
!= NULL
9153 && strcmp (h
->root
.root
.string
, "_gp_disp") == 0)
9156 /* Likewise __GOTT_BASE__ and __GOTT_INDEX__ on VxWorks. */
9157 if (is_gott_symbol (info
, h
))
9164 case R_MICROMIPS_26_S1
:
9165 howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, r_type
, NEWABI_P (abfd
));
9166 /* An error for unsupported relocations is raised as part
9167 of the above search, so we can skip the following. */
9169 info
->callbacks
->einfo
9170 /* xgettext:c-format */
9171 (_("%X%H: relocation %s against `%s' cannot be used"
9172 " when making a shared object; recompile with -fPIC\n"),
9173 abfd
, sec
, rel
->r_offset
, howto
->name
,
9174 (h
) ? h
->root
.root
.string
: "a local symbol");
9185 /* Allocate space for global sym dynamic relocs. */
9188 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
9190 struct bfd_link_info
*info
= inf
;
9192 struct mips_elf_link_hash_entry
*hmips
;
9193 struct mips_elf_link_hash_table
*htab
;
9195 htab
= mips_elf_hash_table (info
);
9196 BFD_ASSERT (htab
!= NULL
);
9198 dynobj
= elf_hash_table (info
)->dynobj
;
9199 hmips
= (struct mips_elf_link_hash_entry
*) h
;
9201 /* VxWorks executables are handled elsewhere; we only need to
9202 allocate relocations in shared objects. */
9203 if (htab
->is_vxworks
&& !bfd_link_pic (info
))
9206 /* Ignore indirect symbols. All relocations against such symbols
9207 will be redirected to the target symbol. */
9208 if (h
->root
.type
== bfd_link_hash_indirect
)
9211 /* If this symbol is defined in a dynamic object, or we are creating
9212 a shared library, we will need to copy any R_MIPS_32 or
9213 R_MIPS_REL32 relocs against it into the output file. */
9214 if (! bfd_link_relocatable (info
)
9215 && hmips
->possibly_dynamic_relocs
!= 0
9216 && (h
->root
.type
== bfd_link_hash_defweak
9217 || (!h
->def_regular
&& !ELF_COMMON_DEF_P (h
))
9218 || bfd_link_pic (info
)))
9220 bfd_boolean do_copy
= TRUE
;
9222 if (h
->root
.type
== bfd_link_hash_undefweak
)
9224 /* Do not copy relocations for undefined weak symbols that
9225 we are not going to export. */
9226 if (UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
9229 /* Make sure undefined weak symbols are output as a dynamic
9231 else if (h
->dynindx
== -1 && !h
->forced_local
)
9233 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
9240 /* Even though we don't directly need a GOT entry for this symbol,
9241 the SVR4 psABI requires it to have a dynamic symbol table
9242 index greater that DT_MIPS_GOTSYM if there are dynamic
9243 relocations against it.
9245 VxWorks does not enforce the same mapping between the GOT
9246 and the symbol table, so the same requirement does not
9248 if (!htab
->is_vxworks
)
9250 if (hmips
->global_got_area
> GGA_RELOC_ONLY
)
9251 hmips
->global_got_area
= GGA_RELOC_ONLY
;
9252 hmips
->got_only_for_calls
= FALSE
;
9255 mips_elf_allocate_dynamic_relocations
9256 (dynobj
, info
, hmips
->possibly_dynamic_relocs
);
9257 if (hmips
->readonly_reloc
)
9258 /* We tell the dynamic linker that there are relocations
9259 against the text segment. */
9260 info
->flags
|= DF_TEXTREL
;
9267 /* Adjust a symbol defined by a dynamic object and referenced by a
9268 regular object. The current definition is in some section of the
9269 dynamic object, but we're not including those sections. We have to
9270 change the definition to something the rest of the link can
9274 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
9275 struct elf_link_hash_entry
*h
)
9278 struct mips_elf_link_hash_entry
*hmips
;
9279 struct mips_elf_link_hash_table
*htab
;
9282 htab
= mips_elf_hash_table (info
);
9283 BFD_ASSERT (htab
!= NULL
);
9285 dynobj
= elf_hash_table (info
)->dynobj
;
9286 hmips
= (struct mips_elf_link_hash_entry
*) h
;
9288 /* Make sure we know what is going on here. */
9291 && ! h
->is_weakalias
9292 && (! h
->def_dynamic
9294 || h
->def_regular
)))
9296 if (h
->type
== STT_GNU_IFUNC
)
9297 _bfd_error_handler (_("IFUNC symbol %s in dynamic symbol table - IFUNCS are not supported"),
9298 h
->root
.root
.string
);
9300 _bfd_error_handler (_("non-dynamic symbol %s in dynamic symbol table"),
9301 h
->root
.root
.string
);
9305 hmips
= (struct mips_elf_link_hash_entry
*) h
;
9307 /* If there are call relocations against an externally-defined symbol,
9308 see whether we can create a MIPS lazy-binding stub for it. We can
9309 only do this if all references to the function are through call
9310 relocations, and in that case, the traditional lazy-binding stubs
9311 are much more efficient than PLT entries.
9313 Traditional stubs are only available on SVR4 psABI-based systems;
9314 VxWorks always uses PLTs instead. */
9315 if (!htab
->is_vxworks
&& h
->needs_plt
&& !hmips
->no_fn_stub
)
9317 if (! elf_hash_table (info
)->dynamic_sections_created
)
9320 /* If this symbol is not defined in a regular file, then set
9321 the symbol to the stub location. This is required to make
9322 function pointers compare as equal between the normal
9323 executable and the shared library. */
9325 && !bfd_is_abs_section (htab
->sstubs
->output_section
))
9327 hmips
->needs_lazy_stub
= TRUE
;
9328 htab
->lazy_stub_count
++;
9332 /* As above, VxWorks requires PLT entries for externally-defined
9333 functions that are only accessed through call relocations.
9335 Both VxWorks and non-VxWorks targets also need PLT entries if there
9336 are static-only relocations against an externally-defined function.
9337 This can technically occur for shared libraries if there are
9338 branches to the symbol, although it is unlikely that this will be
9339 used in practice due to the short ranges involved. It can occur
9340 for any relative or absolute relocation in executables; in that
9341 case, the PLT entry becomes the function's canonical address. */
9342 else if (((h
->needs_plt
&& !hmips
->no_fn_stub
)
9343 || (h
->type
== STT_FUNC
&& hmips
->has_static_relocs
))
9344 && htab
->use_plts_and_copy_relocs
9345 && !SYMBOL_CALLS_LOCAL (info
, h
)
9346 && !(ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
9347 && h
->root
.type
== bfd_link_hash_undefweak
))
9349 bfd_boolean micromips_p
= MICROMIPS_P (info
->output_bfd
);
9350 bfd_boolean newabi_p
= NEWABI_P (info
->output_bfd
);
9352 /* If this is the first symbol to need a PLT entry, then make some
9353 basic setup. Also work out PLT entry sizes. We'll need them
9354 for PLT offset calculations. */
9355 if (htab
->plt_mips_offset
+ htab
->plt_comp_offset
== 0)
9357 BFD_ASSERT (htab
->root
.sgotplt
->size
== 0);
9358 BFD_ASSERT (htab
->plt_got_index
== 0);
9360 /* If we're using the PLT additions to the psABI, each PLT
9361 entry is 16 bytes and the PLT0 entry is 32 bytes.
9362 Encourage better cache usage by aligning. We do this
9363 lazily to avoid pessimizing traditional objects. */
9364 if (!htab
->is_vxworks
9365 && !bfd_set_section_alignment (htab
->root
.splt
, 5))
9368 /* Make sure that .got.plt is word-aligned. We do this lazily
9369 for the same reason as above. */
9370 if (!bfd_set_section_alignment (htab
->root
.sgotplt
,
9371 MIPS_ELF_LOG_FILE_ALIGN (dynobj
)))
9374 /* On non-VxWorks targets, the first two entries in .got.plt
9376 if (!htab
->is_vxworks
)
9378 += (get_elf_backend_data (dynobj
)->got_header_size
9379 / MIPS_ELF_GOT_SIZE (dynobj
));
9381 /* On VxWorks, also allocate room for the header's
9382 .rela.plt.unloaded entries. */
9383 if (htab
->is_vxworks
&& !bfd_link_pic (info
))
9384 htab
->srelplt2
->size
+= 2 * sizeof (Elf32_External_Rela
);
9386 /* Now work out the sizes of individual PLT entries. */
9387 if (htab
->is_vxworks
&& bfd_link_pic (info
))
9388 htab
->plt_mips_entry_size
9389 = 4 * ARRAY_SIZE (mips_vxworks_shared_plt_entry
);
9390 else if (htab
->is_vxworks
)
9391 htab
->plt_mips_entry_size
9392 = 4 * ARRAY_SIZE (mips_vxworks_exec_plt_entry
);
9394 htab
->plt_mips_entry_size
9395 = 4 * ARRAY_SIZE (mips_exec_plt_entry
);
9396 else if (!micromips_p
)
9398 htab
->plt_mips_entry_size
9399 = 4 * ARRAY_SIZE (mips_exec_plt_entry
);
9400 htab
->plt_comp_entry_size
9401 = 2 * ARRAY_SIZE (mips16_o32_exec_plt_entry
);
9403 else if (htab
->insn32
)
9405 htab
->plt_mips_entry_size
9406 = 4 * ARRAY_SIZE (mips_exec_plt_entry
);
9407 htab
->plt_comp_entry_size
9408 = 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt_entry
);
9412 htab
->plt_mips_entry_size
9413 = 4 * ARRAY_SIZE (mips_exec_plt_entry
);
9414 htab
->plt_comp_entry_size
9415 = 2 * ARRAY_SIZE (micromips_o32_exec_plt_entry
);
9419 if (h
->plt
.plist
== NULL
)
9420 h
->plt
.plist
= mips_elf_make_plt_record (dynobj
);
9421 if (h
->plt
.plist
== NULL
)
9424 /* There are no defined MIPS16 or microMIPS PLT entries for VxWorks,
9425 n32 or n64, so always use a standard entry there.
9427 If the symbol has a MIPS16 call stub and gets a PLT entry, then
9428 all MIPS16 calls will go via that stub, and there is no benefit
9429 to having a MIPS16 entry. And in the case of call_stub a
9430 standard entry actually has to be used as the stub ends with a J
9435 || hmips
->call_fp_stub
)
9437 h
->plt
.plist
->need_mips
= TRUE
;
9438 h
->plt
.plist
->need_comp
= FALSE
;
9441 /* Otherwise, if there are no direct calls to the function, we
9442 have a free choice of whether to use standard or compressed
9443 entries. Prefer microMIPS entries if the object is known to
9444 contain microMIPS code, so that it becomes possible to create
9445 pure microMIPS binaries. Prefer standard entries otherwise,
9446 because MIPS16 ones are no smaller and are usually slower. */
9447 if (!h
->plt
.plist
->need_mips
&& !h
->plt
.plist
->need_comp
)
9450 h
->plt
.plist
->need_comp
= TRUE
;
9452 h
->plt
.plist
->need_mips
= TRUE
;
9455 if (h
->plt
.plist
->need_mips
)
9457 h
->plt
.plist
->mips_offset
= htab
->plt_mips_offset
;
9458 htab
->plt_mips_offset
+= htab
->plt_mips_entry_size
;
9460 if (h
->plt
.plist
->need_comp
)
9462 h
->plt
.plist
->comp_offset
= htab
->plt_comp_offset
;
9463 htab
->plt_comp_offset
+= htab
->plt_comp_entry_size
;
9466 /* Reserve the corresponding .got.plt entry now too. */
9467 h
->plt
.plist
->gotplt_index
= htab
->plt_got_index
++;
9469 /* If the output file has no definition of the symbol, set the
9470 symbol's value to the address of the stub. */
9471 if (!bfd_link_pic (info
) && !h
->def_regular
)
9472 hmips
->use_plt_entry
= TRUE
;
9474 /* Make room for the R_MIPS_JUMP_SLOT relocation. */
9475 htab
->root
.srelplt
->size
+= (htab
->is_vxworks
9476 ? MIPS_ELF_RELA_SIZE (dynobj
)
9477 : MIPS_ELF_REL_SIZE (dynobj
));
9479 /* Make room for the .rela.plt.unloaded relocations. */
9480 if (htab
->is_vxworks
&& !bfd_link_pic (info
))
9481 htab
->srelplt2
->size
+= 3 * sizeof (Elf32_External_Rela
);
9483 /* All relocations against this symbol that could have been made
9484 dynamic will now refer to the PLT entry instead. */
9485 hmips
->possibly_dynamic_relocs
= 0;
9490 /* If this is a weak symbol, and there is a real definition, the
9491 processor independent code will have arranged for us to see the
9492 real definition first, and we can just use the same value. */
9493 if (h
->is_weakalias
)
9495 struct elf_link_hash_entry
*def
= weakdef (h
);
9496 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
9497 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
9498 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
9502 /* Otherwise, there is nothing further to do for symbols defined
9503 in regular objects. */
9507 /* There's also nothing more to do if we'll convert all relocations
9508 against this symbol into dynamic relocations. */
9509 if (!hmips
->has_static_relocs
)
9512 /* We're now relying on copy relocations. Complain if we have
9513 some that we can't convert. */
9514 if (!htab
->use_plts_and_copy_relocs
|| bfd_link_pic (info
))
9516 _bfd_error_handler (_("non-dynamic relocations refer to "
9517 "dynamic symbol %s"),
9518 h
->root
.root
.string
);
9519 bfd_set_error (bfd_error_bad_value
);
9523 /* We must allocate the symbol in our .dynbss section, which will
9524 become part of the .bss section of the executable. There will be
9525 an entry for this symbol in the .dynsym section. The dynamic
9526 object will contain position independent code, so all references
9527 from the dynamic object to this symbol will go through the global
9528 offset table. The dynamic linker will use the .dynsym entry to
9529 determine the address it must put in the global offset table, so
9530 both the dynamic object and the regular object will refer to the
9531 same memory location for the variable. */
9533 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
9535 s
= htab
->root
.sdynrelro
;
9536 srel
= htab
->root
.sreldynrelro
;
9540 s
= htab
->root
.sdynbss
;
9541 srel
= htab
->root
.srelbss
;
9543 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
9545 if (htab
->is_vxworks
)
9546 srel
->size
+= sizeof (Elf32_External_Rela
);
9548 mips_elf_allocate_dynamic_relocations (dynobj
, info
, 1);
9552 /* All relocations against this symbol that could have been made
9553 dynamic will now refer to the local copy instead. */
9554 hmips
->possibly_dynamic_relocs
= 0;
9556 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
9559 /* This function is called after all the input files have been read,
9560 and the input sections have been assigned to output sections. We
9561 check for any mips16 stub sections that we can discard. */
9564 _bfd_mips_elf_always_size_sections (bfd
*output_bfd
,
9565 struct bfd_link_info
*info
)
9568 struct mips_elf_link_hash_table
*htab
;
9569 struct mips_htab_traverse_info hti
;
9571 htab
= mips_elf_hash_table (info
);
9572 BFD_ASSERT (htab
!= NULL
);
9574 /* The .reginfo section has a fixed size. */
9575 sect
= bfd_get_section_by_name (output_bfd
, ".reginfo");
9578 bfd_set_section_size (sect
, sizeof (Elf32_External_RegInfo
));
9579 sect
->flags
|= SEC_FIXED_SIZE
| SEC_HAS_CONTENTS
;
9582 /* The .MIPS.abiflags section has a fixed size. */
9583 sect
= bfd_get_section_by_name (output_bfd
, ".MIPS.abiflags");
9586 bfd_set_section_size (sect
, sizeof (Elf_External_ABIFlags_v0
));
9587 sect
->flags
|= SEC_FIXED_SIZE
| SEC_HAS_CONTENTS
;
9591 hti
.output_bfd
= output_bfd
;
9593 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
9594 mips_elf_check_symbols
, &hti
);
9601 /* If the link uses a GOT, lay it out and work out its size. */
9604 mips_elf_lay_out_got (bfd
*output_bfd
, struct bfd_link_info
*info
)
9608 struct mips_got_info
*g
;
9609 bfd_size_type loadable_size
= 0;
9610 bfd_size_type page_gotno
;
9612 struct mips_elf_traverse_got_arg tga
;
9613 struct mips_elf_link_hash_table
*htab
;
9615 htab
= mips_elf_hash_table (info
);
9616 BFD_ASSERT (htab
!= NULL
);
9618 s
= htab
->root
.sgot
;
9622 dynobj
= elf_hash_table (info
)->dynobj
;
9625 /* Allocate room for the reserved entries. VxWorks always reserves
9626 3 entries; other objects only reserve 2 entries. */
9627 BFD_ASSERT (g
->assigned_low_gotno
== 0);
9628 if (htab
->is_vxworks
)
9629 htab
->reserved_gotno
= 3;
9631 htab
->reserved_gotno
= 2;
9632 g
->local_gotno
+= htab
->reserved_gotno
;
9633 g
->assigned_low_gotno
= htab
->reserved_gotno
;
9635 /* Decide which symbols need to go in the global part of the GOT and
9636 count the number of reloc-only GOT symbols. */
9637 mips_elf_link_hash_traverse (htab
, mips_elf_count_got_symbols
, info
);
9639 if (!mips_elf_resolve_final_got_entries (info
, g
))
9642 /* Calculate the total loadable size of the output. That
9643 will give us the maximum number of GOT_PAGE entries
9645 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
9647 asection
*subsection
;
9649 for (subsection
= ibfd
->sections
;
9651 subsection
= subsection
->next
)
9653 if ((subsection
->flags
& SEC_ALLOC
) == 0)
9655 loadable_size
+= ((subsection
->size
+ 0xf)
9656 &~ (bfd_size_type
) 0xf);
9660 if (htab
->is_vxworks
)
9661 /* There's no need to allocate page entries for VxWorks; R_MIPS*_GOT16
9662 relocations against local symbols evaluate to "G", and the EABI does
9663 not include R_MIPS_GOT_PAGE. */
9666 /* Assume there are two loadable segments consisting of contiguous
9667 sections. Is 5 enough? */
9668 page_gotno
= (loadable_size
>> 16) + 5;
9670 /* Choose the smaller of the two page estimates; both are intended to be
9672 if (page_gotno
> g
->page_gotno
)
9673 page_gotno
= g
->page_gotno
;
9675 g
->local_gotno
+= page_gotno
;
9676 g
->assigned_high_gotno
= g
->local_gotno
- 1;
9678 s
->size
+= g
->local_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
9679 s
->size
+= g
->global_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
9680 s
->size
+= g
->tls_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
9682 /* VxWorks does not support multiple GOTs. It initializes $gp to
9683 __GOTT_BASE__[__GOTT_INDEX__], the value of which is set by the
9685 if (!htab
->is_vxworks
&& s
->size
> MIPS_ELF_GOT_MAX_SIZE (info
))
9687 if (!mips_elf_multi_got (output_bfd
, info
, s
, page_gotno
))
9692 /* Record that all bfds use G. This also has the effect of freeing
9693 the per-bfd GOTs, which we no longer need. */
9694 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
9695 if (mips_elf_bfd_got (ibfd
, FALSE
))
9696 mips_elf_replace_bfd_got (ibfd
, g
);
9697 mips_elf_replace_bfd_got (output_bfd
, g
);
9699 /* Set up TLS entries. */
9700 g
->tls_assigned_gotno
= g
->global_gotno
+ g
->local_gotno
;
9703 tga
.value
= MIPS_ELF_GOT_SIZE (output_bfd
);
9704 htab_traverse (g
->got_entries
, mips_elf_initialize_tls_index
, &tga
);
9707 BFD_ASSERT (g
->tls_assigned_gotno
9708 == g
->global_gotno
+ g
->local_gotno
+ g
->tls_gotno
);
9710 /* Each VxWorks GOT entry needs an explicit relocation. */
9711 if (htab
->is_vxworks
&& bfd_link_pic (info
))
9712 g
->relocs
+= g
->global_gotno
+ g
->local_gotno
- htab
->reserved_gotno
;
9714 /* Allocate room for the TLS relocations. */
9716 mips_elf_allocate_dynamic_relocations (dynobj
, info
, g
->relocs
);
9722 /* Estimate the size of the .MIPS.stubs section. */
9725 mips_elf_estimate_stub_size (bfd
*output_bfd
, struct bfd_link_info
*info
)
9727 struct mips_elf_link_hash_table
*htab
;
9728 bfd_size_type dynsymcount
;
9730 htab
= mips_elf_hash_table (info
);
9731 BFD_ASSERT (htab
!= NULL
);
9733 if (htab
->lazy_stub_count
== 0)
9736 /* IRIX rld assumes that a function stub isn't at the end of the .text
9737 section, so add a dummy entry to the end. */
9738 htab
->lazy_stub_count
++;
9740 /* Get a worst-case estimate of the number of dynamic symbols needed.
9741 At this point, dynsymcount does not account for section symbols
9742 and count_section_dynsyms may overestimate the number that will
9744 dynsymcount
= (elf_hash_table (info
)->dynsymcount
9745 + count_section_dynsyms (output_bfd
, info
));
9747 /* Determine the size of one stub entry. There's no disadvantage
9748 from using microMIPS code here, so for the sake of pure-microMIPS
9749 binaries we prefer it whenever there's any microMIPS code in
9750 output produced at all. This has a benefit of stubs being
9751 shorter by 4 bytes each too, unless in the insn32 mode. */
9752 if (!MICROMIPS_P (output_bfd
))
9753 htab
->function_stub_size
= (dynsymcount
> 0x10000
9754 ? MIPS_FUNCTION_STUB_BIG_SIZE
9755 : MIPS_FUNCTION_STUB_NORMAL_SIZE
);
9756 else if (htab
->insn32
)
9757 htab
->function_stub_size
= (dynsymcount
> 0x10000
9758 ? MICROMIPS_INSN32_FUNCTION_STUB_BIG_SIZE
9759 : MICROMIPS_INSN32_FUNCTION_STUB_NORMAL_SIZE
);
9761 htab
->function_stub_size
= (dynsymcount
> 0x10000
9762 ? MICROMIPS_FUNCTION_STUB_BIG_SIZE
9763 : MICROMIPS_FUNCTION_STUB_NORMAL_SIZE
);
9765 htab
->sstubs
->size
= htab
->lazy_stub_count
* htab
->function_stub_size
;
9768 /* A mips_elf_link_hash_traverse callback for which DATA points to a
9769 mips_htab_traverse_info. If H needs a traditional MIPS lazy-binding
9770 stub, allocate an entry in the stubs section. */
9773 mips_elf_allocate_lazy_stub (struct mips_elf_link_hash_entry
*h
, void *data
)
9775 struct mips_htab_traverse_info
*hti
= data
;
9776 struct mips_elf_link_hash_table
*htab
;
9777 struct bfd_link_info
*info
;
9781 output_bfd
= hti
->output_bfd
;
9782 htab
= mips_elf_hash_table (info
);
9783 BFD_ASSERT (htab
!= NULL
);
9785 if (h
->needs_lazy_stub
)
9787 bfd_boolean micromips_p
= MICROMIPS_P (output_bfd
);
9788 unsigned int other
= micromips_p
? STO_MICROMIPS
: 0;
9789 bfd_vma isa_bit
= micromips_p
;
9791 BFD_ASSERT (htab
->root
.dynobj
!= NULL
);
9792 if (h
->root
.plt
.plist
== NULL
)
9793 h
->root
.plt
.plist
= mips_elf_make_plt_record (htab
->sstubs
->owner
);
9794 if (h
->root
.plt
.plist
== NULL
)
9799 h
->root
.root
.u
.def
.section
= htab
->sstubs
;
9800 h
->root
.root
.u
.def
.value
= htab
->sstubs
->size
+ isa_bit
;
9801 h
->root
.plt
.plist
->stub_offset
= htab
->sstubs
->size
;
9802 h
->root
.other
= other
;
9803 htab
->sstubs
->size
+= htab
->function_stub_size
;
9808 /* Allocate offsets in the stubs section to each symbol that needs one.
9809 Set the final size of the .MIPS.stub section. */
9812 mips_elf_lay_out_lazy_stubs (struct bfd_link_info
*info
)
9814 bfd
*output_bfd
= info
->output_bfd
;
9815 bfd_boolean micromips_p
= MICROMIPS_P (output_bfd
);
9816 unsigned int other
= micromips_p
? STO_MICROMIPS
: 0;
9817 bfd_vma isa_bit
= micromips_p
;
9818 struct mips_elf_link_hash_table
*htab
;
9819 struct mips_htab_traverse_info hti
;
9820 struct elf_link_hash_entry
*h
;
9823 htab
= mips_elf_hash_table (info
);
9824 BFD_ASSERT (htab
!= NULL
);
9826 if (htab
->lazy_stub_count
== 0)
9829 htab
->sstubs
->size
= 0;
9831 hti
.output_bfd
= output_bfd
;
9833 mips_elf_link_hash_traverse (htab
, mips_elf_allocate_lazy_stub
, &hti
);
9836 htab
->sstubs
->size
+= htab
->function_stub_size
;
9837 BFD_ASSERT (htab
->sstubs
->size
9838 == htab
->lazy_stub_count
* htab
->function_stub_size
);
9840 dynobj
= elf_hash_table (info
)->dynobj
;
9841 BFD_ASSERT (dynobj
!= NULL
);
9842 h
= _bfd_elf_define_linkage_sym (dynobj
, info
, htab
->sstubs
, "_MIPS_STUBS_");
9845 h
->root
.u
.def
.value
= isa_bit
;
9852 /* A mips_elf_link_hash_traverse callback for which DATA points to a
9853 bfd_link_info. If H uses the address of a PLT entry as the value
9854 of the symbol, then set the entry in the symbol table now. Prefer
9855 a standard MIPS PLT entry. */
9858 mips_elf_set_plt_sym_value (struct mips_elf_link_hash_entry
*h
, void *data
)
9860 struct bfd_link_info
*info
= data
;
9861 bfd_boolean micromips_p
= MICROMIPS_P (info
->output_bfd
);
9862 struct mips_elf_link_hash_table
*htab
;
9867 htab
= mips_elf_hash_table (info
);
9868 BFD_ASSERT (htab
!= NULL
);
9870 if (h
->use_plt_entry
)
9872 BFD_ASSERT (h
->root
.plt
.plist
!= NULL
);
9873 BFD_ASSERT (h
->root
.plt
.plist
->mips_offset
!= MINUS_ONE
9874 || h
->root
.plt
.plist
->comp_offset
!= MINUS_ONE
);
9876 val
= htab
->plt_header_size
;
9877 if (h
->root
.plt
.plist
->mips_offset
!= MINUS_ONE
)
9880 val
+= h
->root
.plt
.plist
->mips_offset
;
9886 val
+= htab
->plt_mips_offset
+ h
->root
.plt
.plist
->comp_offset
;
9887 other
= micromips_p
? STO_MICROMIPS
: STO_MIPS16
;
9890 /* For VxWorks, point at the PLT load stub rather than the lazy
9891 resolution stub; this stub will become the canonical function
9893 if (htab
->is_vxworks
)
9896 h
->root
.root
.u
.def
.section
= htab
->root
.splt
;
9897 h
->root
.root
.u
.def
.value
= val
;
9898 h
->root
.other
= other
;
9904 /* Set the sizes of the dynamic sections. */
9907 _bfd_mips_elf_size_dynamic_sections (bfd
*output_bfd
,
9908 struct bfd_link_info
*info
)
9911 asection
*s
, *sreldyn
;
9912 bfd_boolean reltext
;
9913 struct mips_elf_link_hash_table
*htab
;
9915 htab
= mips_elf_hash_table (info
);
9916 BFD_ASSERT (htab
!= NULL
);
9917 dynobj
= elf_hash_table (info
)->dynobj
;
9918 BFD_ASSERT (dynobj
!= NULL
);
9920 if (elf_hash_table (info
)->dynamic_sections_created
)
9922 /* Set the contents of the .interp section to the interpreter. */
9923 if (bfd_link_executable (info
) && !info
->nointerp
)
9925 s
= bfd_get_linker_section (dynobj
, ".interp");
9926 BFD_ASSERT (s
!= NULL
);
9928 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd
)) + 1;
9930 = (bfd_byte
*) ELF_DYNAMIC_INTERPRETER (output_bfd
);
9933 /* Figure out the size of the PLT header if we know that we
9934 are using it. For the sake of cache alignment always use
9935 a standard header whenever any standard entries are present
9936 even if microMIPS entries are present as well. This also
9937 lets the microMIPS header rely on the value of $v0 only set
9938 by microMIPS entries, for a small size reduction.
9940 Set symbol table entry values for symbols that use the
9941 address of their PLT entry now that we can calculate it.
9943 Also create the _PROCEDURE_LINKAGE_TABLE_ symbol if we
9944 haven't already in _bfd_elf_create_dynamic_sections. */
9945 if (htab
->root
.splt
&& htab
->plt_mips_offset
+ htab
->plt_comp_offset
!= 0)
9947 bfd_boolean micromips_p
= (MICROMIPS_P (output_bfd
)
9948 && !htab
->plt_mips_offset
);
9949 unsigned int other
= micromips_p
? STO_MICROMIPS
: 0;
9950 bfd_vma isa_bit
= micromips_p
;
9951 struct elf_link_hash_entry
*h
;
9954 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
9955 BFD_ASSERT (htab
->root
.sgotplt
->size
== 0);
9956 BFD_ASSERT (htab
->root
.splt
->size
== 0);
9958 if (htab
->is_vxworks
&& bfd_link_pic (info
))
9959 size
= 4 * ARRAY_SIZE (mips_vxworks_shared_plt0_entry
);
9960 else if (htab
->is_vxworks
)
9961 size
= 4 * ARRAY_SIZE (mips_vxworks_exec_plt0_entry
);
9962 else if (ABI_64_P (output_bfd
))
9963 size
= 4 * ARRAY_SIZE (mips_n64_exec_plt0_entry
);
9964 else if (ABI_N32_P (output_bfd
))
9965 size
= 4 * ARRAY_SIZE (mips_n32_exec_plt0_entry
);
9966 else if (!micromips_p
)
9967 size
= 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry
);
9968 else if (htab
->insn32
)
9969 size
= 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt0_entry
);
9971 size
= 2 * ARRAY_SIZE (micromips_o32_exec_plt0_entry
);
9973 htab
->plt_header_is_comp
= micromips_p
;
9974 htab
->plt_header_size
= size
;
9975 htab
->root
.splt
->size
= (size
9976 + htab
->plt_mips_offset
9977 + htab
->plt_comp_offset
);
9978 htab
->root
.sgotplt
->size
= (htab
->plt_got_index
9979 * MIPS_ELF_GOT_SIZE (dynobj
));
9981 mips_elf_link_hash_traverse (htab
, mips_elf_set_plt_sym_value
, info
);
9983 if (htab
->root
.hplt
== NULL
)
9985 h
= _bfd_elf_define_linkage_sym (dynobj
, info
, htab
->root
.splt
,
9986 "_PROCEDURE_LINKAGE_TABLE_");
9987 htab
->root
.hplt
= h
;
9992 h
= htab
->root
.hplt
;
9993 h
->root
.u
.def
.value
= isa_bit
;
9999 /* Allocate space for global sym dynamic relocs. */
10000 elf_link_hash_traverse (&htab
->root
, allocate_dynrelocs
, info
);
10002 mips_elf_estimate_stub_size (output_bfd
, info
);
10004 if (!mips_elf_lay_out_got (output_bfd
, info
))
10007 mips_elf_lay_out_lazy_stubs (info
);
10009 /* The check_relocs and adjust_dynamic_symbol entry points have
10010 determined the sizes of the various dynamic sections. Allocate
10011 memory for them. */
10013 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
10017 /* It's OK to base decisions on the section name, because none
10018 of the dynobj section names depend upon the input files. */
10019 name
= bfd_section_name (s
);
10021 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
10024 if (CONST_STRNEQ (name
, ".rel"))
10028 const char *outname
;
10031 /* If this relocation section applies to a read only
10032 section, then we probably need a DT_TEXTREL entry.
10033 If the relocation section is .rel(a).dyn, we always
10034 assert a DT_TEXTREL entry rather than testing whether
10035 there exists a relocation to a read only section or
10037 outname
= bfd_section_name (s
->output_section
);
10038 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
10039 if ((target
!= NULL
10040 && (target
->flags
& SEC_READONLY
) != 0
10041 && (target
->flags
& SEC_ALLOC
) != 0)
10042 || strcmp (outname
, MIPS_ELF_REL_DYN_NAME (info
)) == 0)
10045 /* We use the reloc_count field as a counter if we need
10046 to copy relocs into the output file. */
10047 if (strcmp (name
, MIPS_ELF_REL_DYN_NAME (info
)) != 0)
10048 s
->reloc_count
= 0;
10050 /* If combreloc is enabled, elf_link_sort_relocs() will
10051 sort relocations, but in a different way than we do,
10052 and before we're done creating relocations. Also, it
10053 will move them around between input sections'
10054 relocation's contents, so our sorting would be
10055 broken, so don't let it run. */
10056 info
->combreloc
= 0;
10059 else if (bfd_link_executable (info
)
10060 && ! mips_elf_hash_table (info
)->use_rld_obj_head
10061 && CONST_STRNEQ (name
, ".rld_map"))
10063 /* We add a room for __rld_map. It will be filled in by the
10064 rtld to contain a pointer to the _r_debug structure. */
10065 s
->size
+= MIPS_ELF_RLD_MAP_SIZE (output_bfd
);
10067 else if (SGI_COMPAT (output_bfd
)
10068 && CONST_STRNEQ (name
, ".compact_rel"))
10069 s
->size
+= mips_elf_hash_table (info
)->compact_rel_size
;
10070 else if (s
== htab
->root
.splt
)
10072 /* If the last PLT entry has a branch delay slot, allocate
10073 room for an extra nop to fill the delay slot. This is
10074 for CPUs without load interlocking. */
10075 if (! LOAD_INTERLOCKS_P (output_bfd
)
10076 && ! htab
->is_vxworks
&& s
->size
> 0)
10079 else if (! CONST_STRNEQ (name
, ".init")
10080 && s
!= htab
->root
.sgot
10081 && s
!= htab
->root
.sgotplt
10082 && s
!= htab
->sstubs
10083 && s
!= htab
->root
.sdynbss
10084 && s
!= htab
->root
.sdynrelro
)
10086 /* It's not one of our sections, so don't allocate space. */
10092 s
->flags
|= SEC_EXCLUDE
;
10096 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
10099 /* Allocate memory for the section contents. */
10100 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
10101 if (s
->contents
== NULL
)
10103 bfd_set_error (bfd_error_no_memory
);
10108 if (elf_hash_table (info
)->dynamic_sections_created
)
10110 /* Add some entries to the .dynamic section. We fill in the
10111 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
10112 must add the entries now so that we get the correct size for
10113 the .dynamic section. */
10115 /* SGI object has the equivalence of DT_DEBUG in the
10116 DT_MIPS_RLD_MAP entry. This must come first because glibc
10117 only fills in DT_MIPS_RLD_MAP (not DT_DEBUG) and some tools
10118 may only look at the first one they see. */
10119 if (!bfd_link_pic (info
)
10120 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_MAP
, 0))
10123 if (bfd_link_executable (info
)
10124 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_MAP_REL
, 0))
10127 /* The DT_DEBUG entry may be filled in by the dynamic linker and
10128 used by the debugger. */
10129 if (bfd_link_executable (info
)
10130 && !SGI_COMPAT (output_bfd
)
10131 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
10134 if (reltext
&& (SGI_COMPAT (output_bfd
) || htab
->is_vxworks
))
10135 info
->flags
|= DF_TEXTREL
;
10137 if ((info
->flags
& DF_TEXTREL
) != 0)
10139 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_TEXTREL
, 0))
10142 /* Clear the DF_TEXTREL flag. It will be set again if we
10143 write out an actual text relocation; we may not, because
10144 at this point we do not know whether e.g. any .eh_frame
10145 absolute relocations have been converted to PC-relative. */
10146 info
->flags
&= ~DF_TEXTREL
;
10149 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTGOT
, 0))
10152 sreldyn
= mips_elf_rel_dyn_section (info
, FALSE
);
10153 if (htab
->is_vxworks
)
10155 /* VxWorks uses .rela.dyn instead of .rel.dyn. It does not
10156 use any of the DT_MIPS_* tags. */
10157 if (sreldyn
&& sreldyn
->size
> 0)
10159 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELA
, 0))
10162 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELASZ
, 0))
10165 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELAENT
, 0))
10171 if (sreldyn
&& sreldyn
->size
> 0
10172 && !bfd_is_abs_section (sreldyn
->output_section
))
10174 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_REL
, 0))
10177 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELSZ
, 0))
10180 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELENT
, 0))
10184 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_VERSION
, 0))
10187 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_FLAGS
, 0))
10190 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_BASE_ADDRESS
, 0))
10193 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LOCAL_GOTNO
, 0))
10196 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_SYMTABNO
, 0))
10199 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_UNREFEXTNO
, 0))
10202 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_GOTSYM
, 0))
10205 if (info
->emit_gnu_hash
10206 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_XHASH
, 0))
10209 if (IRIX_COMPAT (dynobj
) == ict_irix5
10210 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_HIPAGENO
, 0))
10213 if (IRIX_COMPAT (dynobj
) == ict_irix6
10214 && (bfd_get_section_by_name
10215 (output_bfd
, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj
)))
10216 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_OPTIONS
, 0))
10219 if (htab
->root
.splt
->size
> 0)
10221 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTREL
, 0))
10224 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_JMPREL
, 0))
10227 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTRELSZ
, 0))
10230 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_PLTGOT
, 0))
10233 if (htab
->is_vxworks
10234 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
10241 /* REL is a relocation in INPUT_BFD that is being copied to OUTPUT_BFD.
10242 Adjust its R_ADDEND field so that it is correct for the output file.
10243 LOCAL_SYMS and LOCAL_SECTIONS are arrays of INPUT_BFD's local symbols
10244 and sections respectively; both use symbol indexes. */
10247 mips_elf_adjust_addend (bfd
*output_bfd
, struct bfd_link_info
*info
,
10248 bfd
*input_bfd
, Elf_Internal_Sym
*local_syms
,
10249 asection
**local_sections
, Elf_Internal_Rela
*rel
)
10251 unsigned int r_type
, r_symndx
;
10252 Elf_Internal_Sym
*sym
;
10255 if (mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
))
10257 r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
10258 if (gprel16_reloc_p (r_type
)
10259 || r_type
== R_MIPS_GPREL32
10260 || literal_reloc_p (r_type
))
10262 rel
->r_addend
+= _bfd_get_gp_value (input_bfd
);
10263 rel
->r_addend
-= _bfd_get_gp_value (output_bfd
);
10266 r_symndx
= ELF_R_SYM (output_bfd
, rel
->r_info
);
10267 sym
= local_syms
+ r_symndx
;
10269 /* Adjust REL's addend to account for section merging. */
10270 if (!bfd_link_relocatable (info
))
10272 sec
= local_sections
[r_symndx
];
10273 _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
10276 /* This would normally be done by the rela_normal code in elflink.c. */
10277 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
10278 rel
->r_addend
+= local_sections
[r_symndx
]->output_offset
;
10282 /* Handle relocations against symbols from removed linkonce sections,
10283 or sections discarded by a linker script. We use this wrapper around
10284 RELOC_AGAINST_DISCARDED_SECTION to handle triplets of compound relocs
10285 on 64-bit ELF targets. In this case for any relocation handled, which
10286 always be the first in a triplet, the remaining two have to be processed
10287 together with the first, even if they are R_MIPS_NONE. It is the symbol
10288 index referred by the first reloc that applies to all the three and the
10289 remaining two never refer to an object symbol. And it is the final
10290 relocation (the last non-null one) that determines the output field of
10291 the whole relocation so retrieve the corresponding howto structure for
10292 the relocatable field to be cleared by RELOC_AGAINST_DISCARDED_SECTION.
10294 Note that RELOC_AGAINST_DISCARDED_SECTION is a macro that uses "continue"
10295 and therefore requires to be pasted in a loop. It also defines a block
10296 and does not protect any of its arguments, hence the extra brackets. */
10299 mips_reloc_against_discarded_section (bfd
*output_bfd
,
10300 struct bfd_link_info
*info
,
10301 bfd
*input_bfd
, asection
*input_section
,
10302 Elf_Internal_Rela
**rel
,
10303 const Elf_Internal_Rela
**relend
,
10304 bfd_boolean rel_reloc
,
10305 reloc_howto_type
*howto
,
10306 bfd_byte
*contents
)
10308 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
10309 int count
= bed
->s
->int_rels_per_ext_rel
;
10310 unsigned int r_type
;
10313 for (i
= count
- 1; i
> 0; i
--)
10315 r_type
= ELF_R_TYPE (output_bfd
, (*rel
)[i
].r_info
);
10316 if (r_type
!= R_MIPS_NONE
)
10318 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, r_type
, !rel_reloc
);
10324 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
10325 (*rel
), count
, (*relend
),
10326 howto
, i
, contents
);
10331 /* Relocate a MIPS ELF section. */
10334 _bfd_mips_elf_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
10335 bfd
*input_bfd
, asection
*input_section
,
10336 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
10337 Elf_Internal_Sym
*local_syms
,
10338 asection
**local_sections
)
10340 Elf_Internal_Rela
*rel
;
10341 const Elf_Internal_Rela
*relend
;
10342 bfd_vma addend
= 0;
10343 bfd_boolean use_saved_addend_p
= FALSE
;
10345 relend
= relocs
+ input_section
->reloc_count
;
10346 for (rel
= relocs
; rel
< relend
; ++rel
)
10350 reloc_howto_type
*howto
;
10351 bfd_boolean cross_mode_jump_p
= FALSE
;
10352 /* TRUE if the relocation is a RELA relocation, rather than a
10354 bfd_boolean rela_relocation_p
= TRUE
;
10355 unsigned int r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
10357 unsigned long r_symndx
;
10359 Elf_Internal_Shdr
*symtab_hdr
;
10360 struct elf_link_hash_entry
*h
;
10361 bfd_boolean rel_reloc
;
10363 rel_reloc
= (NEWABI_P (input_bfd
)
10364 && mips_elf_rel_relocation_p (input_bfd
, input_section
,
10366 /* Find the relocation howto for this relocation. */
10367 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, r_type
, !rel_reloc
);
10369 r_symndx
= ELF_R_SYM (input_bfd
, rel
->r_info
);
10370 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
10371 if (mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
))
10373 sec
= local_sections
[r_symndx
];
10378 unsigned long extsymoff
;
10381 if (!elf_bad_symtab (input_bfd
))
10382 extsymoff
= symtab_hdr
->sh_info
;
10383 h
= elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
];
10384 while (h
->root
.type
== bfd_link_hash_indirect
10385 || h
->root
.type
== bfd_link_hash_warning
)
10386 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
10389 if (h
->root
.type
== bfd_link_hash_defined
10390 || h
->root
.type
== bfd_link_hash_defweak
)
10391 sec
= h
->root
.u
.def
.section
;
10394 if (sec
!= NULL
&& discarded_section (sec
))
10396 mips_reloc_against_discarded_section (output_bfd
, info
, input_bfd
,
10397 input_section
, &rel
, &relend
,
10398 rel_reloc
, howto
, contents
);
10402 if (r_type
== R_MIPS_64
&& ! NEWABI_P (input_bfd
))
10404 /* Some 32-bit code uses R_MIPS_64. In particular, people use
10405 64-bit code, but make sure all their addresses are in the
10406 lowermost or uppermost 32-bit section of the 64-bit address
10407 space. Thus, when they use an R_MIPS_64 they mean what is
10408 usually meant by R_MIPS_32, with the exception that the
10409 stored value is sign-extended to 64 bits. */
10410 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, R_MIPS_32
, FALSE
);
10412 /* On big-endian systems, we need to lie about the position
10414 if (bfd_big_endian (input_bfd
))
10415 rel
->r_offset
+= 4;
10418 if (!use_saved_addend_p
)
10420 /* If these relocations were originally of the REL variety,
10421 we must pull the addend out of the field that will be
10422 relocated. Otherwise, we simply use the contents of the
10423 RELA relocation. */
10424 if (mips_elf_rel_relocation_p (input_bfd
, input_section
,
10427 rela_relocation_p
= FALSE
;
10428 addend
= mips_elf_read_rel_addend (input_bfd
, rel
,
10430 if (hi16_reloc_p (r_type
)
10431 || (got16_reloc_p (r_type
)
10432 && mips_elf_local_relocation_p (input_bfd
, rel
,
10435 if (!mips_elf_add_lo16_rel_addend (input_bfd
, rel
, relend
,
10436 contents
, &addend
))
10439 name
= h
->root
.root
.string
;
10441 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
10442 local_syms
+ r_symndx
,
10445 /* xgettext:c-format */
10446 (_("%pB: can't find matching LO16 reloc against `%s'"
10447 " for %s at %#" PRIx64
" in section `%pA'"),
10449 howto
->name
, (uint64_t) rel
->r_offset
, input_section
);
10453 addend
<<= howto
->rightshift
;
10456 addend
= rel
->r_addend
;
10457 mips_elf_adjust_addend (output_bfd
, info
, input_bfd
,
10458 local_syms
, local_sections
, rel
);
10461 if (bfd_link_relocatable (info
))
10463 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
)
10464 && bfd_big_endian (input_bfd
))
10465 rel
->r_offset
-= 4;
10467 if (!rela_relocation_p
&& rel
->r_addend
)
10469 addend
+= rel
->r_addend
;
10470 if (hi16_reloc_p (r_type
) || got16_reloc_p (r_type
))
10471 addend
= mips_elf_high (addend
);
10472 else if (r_type
== R_MIPS_HIGHER
)
10473 addend
= mips_elf_higher (addend
);
10474 else if (r_type
== R_MIPS_HIGHEST
)
10475 addend
= mips_elf_highest (addend
);
10477 addend
>>= howto
->rightshift
;
10479 /* We use the source mask, rather than the destination
10480 mask because the place to which we are writing will be
10481 source of the addend in the final link. */
10482 addend
&= howto
->src_mask
;
10484 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
10485 /* See the comment above about using R_MIPS_64 in the 32-bit
10486 ABI. Here, we need to update the addend. It would be
10487 possible to get away with just using the R_MIPS_32 reloc
10488 but for endianness. */
10494 if (addend
& ((bfd_vma
) 1 << 31))
10496 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
10503 /* If we don't know that we have a 64-bit type,
10504 do two separate stores. */
10505 if (bfd_big_endian (input_bfd
))
10507 /* Store the sign-bits (which are most significant)
10509 low_bits
= sign_bits
;
10510 high_bits
= addend
;
10515 high_bits
= sign_bits
;
10517 bfd_put_32 (input_bfd
, low_bits
,
10518 contents
+ rel
->r_offset
);
10519 bfd_put_32 (input_bfd
, high_bits
,
10520 contents
+ rel
->r_offset
+ 4);
10524 if (! mips_elf_perform_relocation (info
, howto
, rel
, addend
,
10525 input_bfd
, input_section
,
10530 /* Go on to the next relocation. */
10534 /* In the N32 and 64-bit ABIs there may be multiple consecutive
10535 relocations for the same offset. In that case we are
10536 supposed to treat the output of each relocation as the addend
10538 if (rel
+ 1 < relend
10539 && rel
->r_offset
== rel
[1].r_offset
10540 && ELF_R_TYPE (input_bfd
, rel
[1].r_info
) != R_MIPS_NONE
)
10541 use_saved_addend_p
= TRUE
;
10543 use_saved_addend_p
= FALSE
;
10545 /* Figure out what value we are supposed to relocate. */
10546 switch (mips_elf_calculate_relocation (output_bfd
, input_bfd
,
10547 input_section
, contents
,
10548 info
, rel
, addend
, howto
,
10549 local_syms
, local_sections
,
10550 &value
, &name
, &cross_mode_jump_p
,
10551 use_saved_addend_p
))
10553 case bfd_reloc_continue
:
10554 /* There's nothing to do. */
10557 case bfd_reloc_undefined
:
10558 /* mips_elf_calculate_relocation already called the
10559 undefined_symbol callback. There's no real point in
10560 trying to perform the relocation at this point, so we
10561 just skip ahead to the next relocation. */
10564 case bfd_reloc_notsupported
:
10565 msg
= _("internal error: unsupported relocation error");
10566 info
->callbacks
->warning
10567 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
10570 case bfd_reloc_overflow
:
10571 if (use_saved_addend_p
)
10572 /* Ignore overflow until we reach the last relocation for
10573 a given location. */
10577 struct mips_elf_link_hash_table
*htab
;
10579 htab
= mips_elf_hash_table (info
);
10580 BFD_ASSERT (htab
!= NULL
);
10581 BFD_ASSERT (name
!= NULL
);
10582 if (!htab
->small_data_overflow_reported
10583 && (gprel16_reloc_p (howto
->type
)
10584 || literal_reloc_p (howto
->type
)))
10586 msg
= _("small-data section exceeds 64KB;"
10587 " lower small-data size limit (see option -G)");
10589 htab
->small_data_overflow_reported
= TRUE
;
10590 (*info
->callbacks
->einfo
) ("%P: %s\n", msg
);
10592 (*info
->callbacks
->reloc_overflow
)
10593 (info
, NULL
, name
, howto
->name
, (bfd_vma
) 0,
10594 input_bfd
, input_section
, rel
->r_offset
);
10601 case bfd_reloc_outofrange
:
10603 if (jal_reloc_p (howto
->type
))
10604 msg
= (cross_mode_jump_p
10605 ? _("cannot convert a jump to JALX "
10606 "for a non-word-aligned address")
10607 : (howto
->type
== R_MIPS16_26
10608 ? _("jump to a non-word-aligned address")
10609 : _("jump to a non-instruction-aligned address")));
10610 else if (b_reloc_p (howto
->type
))
10611 msg
= (cross_mode_jump_p
10612 ? _("cannot convert a branch to JALX "
10613 "for a non-word-aligned address")
10614 : _("branch to a non-instruction-aligned address"));
10615 else if (aligned_pcrel_reloc_p (howto
->type
))
10616 msg
= _("PC-relative load from unaligned address");
10619 info
->callbacks
->einfo
10620 ("%X%H: %s\n", input_bfd
, input_section
, rel
->r_offset
, msg
);
10623 /* Fall through. */
10630 /* If we've got another relocation for the address, keep going
10631 until we reach the last one. */
10632 if (use_saved_addend_p
)
10638 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
10639 /* See the comment above about using R_MIPS_64 in the 32-bit
10640 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
10641 that calculated the right value. Now, however, we
10642 sign-extend the 32-bit result to 64-bits, and store it as a
10643 64-bit value. We are especially generous here in that we
10644 go to extreme lengths to support this usage on systems with
10645 only a 32-bit VMA. */
10651 if (value
& ((bfd_vma
) 1 << 31))
10653 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
10660 /* If we don't know that we have a 64-bit type,
10661 do two separate stores. */
10662 if (bfd_big_endian (input_bfd
))
10664 /* Undo what we did above. */
10665 rel
->r_offset
-= 4;
10666 /* Store the sign-bits (which are most significant)
10668 low_bits
= sign_bits
;
10674 high_bits
= sign_bits
;
10676 bfd_put_32 (input_bfd
, low_bits
,
10677 contents
+ rel
->r_offset
);
10678 bfd_put_32 (input_bfd
, high_bits
,
10679 contents
+ rel
->r_offset
+ 4);
10683 /* Actually perform the relocation. */
10684 if (! mips_elf_perform_relocation (info
, howto
, rel
, value
,
10685 input_bfd
, input_section
,
10686 contents
, cross_mode_jump_p
))
10693 /* A function that iterates over each entry in la25_stubs and fills
10694 in the code for each one. DATA points to a mips_htab_traverse_info. */
10697 mips_elf_create_la25_stub (void **slot
, void *data
)
10699 struct mips_htab_traverse_info
*hti
;
10700 struct mips_elf_link_hash_table
*htab
;
10701 struct mips_elf_la25_stub
*stub
;
10704 bfd_vma offset
, target
, target_high
, target_low
;
10706 bfd_signed_vma pcrel_offset
= 0;
10708 stub
= (struct mips_elf_la25_stub
*) *slot
;
10709 hti
= (struct mips_htab_traverse_info
*) data
;
10710 htab
= mips_elf_hash_table (hti
->info
);
10711 BFD_ASSERT (htab
!= NULL
);
10713 /* Create the section contents, if we haven't already. */
10714 s
= stub
->stub_section
;
10718 loc
= bfd_malloc (s
->size
);
10727 /* Work out where in the section this stub should go. */
10728 offset
= stub
->offset
;
10730 /* We add 8 here to account for the LUI/ADDIU instructions
10731 before the branch instruction. This cannot be moved down to
10732 where pcrel_offset is calculated as 's' is updated in
10733 mips_elf_get_la25_target. */
10734 branch_pc
= s
->output_section
->vma
+ s
->output_offset
+ offset
+ 8;
10736 /* Work out the target address. */
10737 target
= mips_elf_get_la25_target (stub
, &s
);
10738 target
+= s
->output_section
->vma
+ s
->output_offset
;
10740 target_high
= ((target
+ 0x8000) >> 16) & 0xffff;
10741 target_low
= (target
& 0xffff);
10743 /* Calculate the PC of the compact branch instruction (for the case where
10744 compact branches are used for either microMIPSR6 or MIPSR6 with
10745 compact branches. Add 4-bytes to account for BC using the PC of the
10746 next instruction as the base. */
10747 pcrel_offset
= target
- (branch_pc
+ 4);
10749 if (stub
->stub_section
!= htab
->strampoline
)
10751 /* This is a simple LUI/ADDIU stub. Zero out the beginning
10752 of the section and write the two instructions at the end. */
10753 memset (loc
, 0, offset
);
10755 if (ELF_ST_IS_MICROMIPS (stub
->h
->root
.other
))
10757 bfd_put_micromips_32 (hti
->output_bfd
,
10758 LA25_LUI_MICROMIPS (target_high
),
10760 bfd_put_micromips_32 (hti
->output_bfd
,
10761 LA25_ADDIU_MICROMIPS (target_low
),
10766 bfd_put_32 (hti
->output_bfd
, LA25_LUI (target_high
), loc
);
10767 bfd_put_32 (hti
->output_bfd
, LA25_ADDIU (target_low
), loc
+ 4);
10772 /* This is trampoline. */
10774 if (ELF_ST_IS_MICROMIPS (stub
->h
->root
.other
))
10776 bfd_put_micromips_32 (hti
->output_bfd
,
10777 LA25_LUI_MICROMIPS (target_high
), loc
);
10778 bfd_put_micromips_32 (hti
->output_bfd
,
10779 LA25_J_MICROMIPS (target
), loc
+ 4);
10780 bfd_put_micromips_32 (hti
->output_bfd
,
10781 LA25_ADDIU_MICROMIPS (target_low
), loc
+ 8);
10782 bfd_put_32 (hti
->output_bfd
, 0, loc
+ 12);
10786 bfd_put_32 (hti
->output_bfd
, LA25_LUI (target_high
), loc
);
10787 if (MIPSR6_P (hti
->output_bfd
) && htab
->compact_branches
)
10789 bfd_put_32 (hti
->output_bfd
, LA25_ADDIU (target_low
), loc
+ 4);
10790 bfd_put_32 (hti
->output_bfd
, LA25_BC (pcrel_offset
), loc
+ 8);
10794 bfd_put_32 (hti
->output_bfd
, LA25_J (target
), loc
+ 4);
10795 bfd_put_32 (hti
->output_bfd
, LA25_ADDIU (target_low
), loc
+ 8);
10797 bfd_put_32 (hti
->output_bfd
, 0, loc
+ 12);
10803 /* If NAME is one of the special IRIX6 symbols defined by the linker,
10804 adjust it appropriately now. */
10807 mips_elf_irix6_finish_dynamic_symbol (bfd
*abfd ATTRIBUTE_UNUSED
,
10808 const char *name
, Elf_Internal_Sym
*sym
)
10810 /* The linker script takes care of providing names and values for
10811 these, but we must place them into the right sections. */
10812 static const char* const text_section_symbols
[] = {
10815 "__dso_displacement",
10817 "__program_header_table",
10821 static const char* const data_section_symbols
[] = {
10829 const char* const *p
;
10832 for (i
= 0; i
< 2; ++i
)
10833 for (p
= (i
== 0) ? text_section_symbols
: data_section_symbols
;
10836 if (strcmp (*p
, name
) == 0)
10838 /* All of these symbols are given type STT_SECTION by the
10840 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
10841 sym
->st_other
= STO_PROTECTED
;
10843 /* The IRIX linker puts these symbols in special sections. */
10845 sym
->st_shndx
= SHN_MIPS_TEXT
;
10847 sym
->st_shndx
= SHN_MIPS_DATA
;
10853 /* Finish up dynamic symbol handling. We set the contents of various
10854 dynamic sections here. */
10857 _bfd_mips_elf_finish_dynamic_symbol (bfd
*output_bfd
,
10858 struct bfd_link_info
*info
,
10859 struct elf_link_hash_entry
*h
,
10860 Elf_Internal_Sym
*sym
)
10864 struct mips_got_info
*g
, *gg
;
10867 struct mips_elf_link_hash_table
*htab
;
10868 struct mips_elf_link_hash_entry
*hmips
;
10870 htab
= mips_elf_hash_table (info
);
10871 BFD_ASSERT (htab
!= NULL
);
10872 dynobj
= elf_hash_table (info
)->dynobj
;
10873 hmips
= (struct mips_elf_link_hash_entry
*) h
;
10875 BFD_ASSERT (!htab
->is_vxworks
);
10877 if (h
->plt
.plist
!= NULL
10878 && (h
->plt
.plist
->mips_offset
!= MINUS_ONE
10879 || h
->plt
.plist
->comp_offset
!= MINUS_ONE
))
10881 /* We've decided to create a PLT entry for this symbol. */
10883 bfd_vma header_address
, got_address
;
10884 bfd_vma got_address_high
, got_address_low
, load
;
10888 got_index
= h
->plt
.plist
->gotplt_index
;
10890 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
10891 BFD_ASSERT (h
->dynindx
!= -1);
10892 BFD_ASSERT (htab
->root
.splt
!= NULL
);
10893 BFD_ASSERT (got_index
!= MINUS_ONE
);
10894 BFD_ASSERT (!h
->def_regular
);
10896 /* Calculate the address of the PLT header. */
10897 isa_bit
= htab
->plt_header_is_comp
;
10898 header_address
= (htab
->root
.splt
->output_section
->vma
10899 + htab
->root
.splt
->output_offset
+ isa_bit
);
10901 /* Calculate the address of the .got.plt entry. */
10902 got_address
= (htab
->root
.sgotplt
->output_section
->vma
10903 + htab
->root
.sgotplt
->output_offset
10904 + got_index
* MIPS_ELF_GOT_SIZE (dynobj
));
10906 got_address_high
= ((got_address
+ 0x8000) >> 16) & 0xffff;
10907 got_address_low
= got_address
& 0xffff;
10909 /* The PLT sequence is not safe for N64 if .got.plt entry's address
10910 cannot be loaded in two instructions. */
10911 if (ABI_64_P (output_bfd
)
10912 && ((got_address
+ 0x80008000) & ~(bfd_vma
) 0xffffffff) != 0)
10915 /* xgettext:c-format */
10916 (_("%pB: `%pA' entry VMA of %#" PRIx64
" outside the 32-bit range "
10917 "supported; consider using `-Ttext-segment=...'"),
10919 htab
->root
.sgotplt
->output_section
,
10920 (int64_t) got_address
);
10921 bfd_set_error (bfd_error_no_error
);
10925 /* Initially point the .got.plt entry at the PLT header. */
10926 loc
= (htab
->root
.sgotplt
->contents
10927 + got_index
* MIPS_ELF_GOT_SIZE (dynobj
));
10928 if (ABI_64_P (output_bfd
))
10929 bfd_put_64 (output_bfd
, header_address
, loc
);
10931 bfd_put_32 (output_bfd
, header_address
, loc
);
10933 /* Now handle the PLT itself. First the standard entry (the order
10934 does not matter, we just have to pick one). */
10935 if (h
->plt
.plist
->mips_offset
!= MINUS_ONE
)
10937 const bfd_vma
*plt_entry
;
10938 bfd_vma plt_offset
;
10940 plt_offset
= htab
->plt_header_size
+ h
->plt
.plist
->mips_offset
;
10942 BFD_ASSERT (plt_offset
<= htab
->root
.splt
->size
);
10944 /* Find out where the .plt entry should go. */
10945 loc
= htab
->root
.splt
->contents
+ plt_offset
;
10947 /* Pick the load opcode. */
10948 load
= MIPS_ELF_LOAD_WORD (output_bfd
);
10950 /* Fill in the PLT entry itself. */
10952 if (MIPSR6_P (output_bfd
))
10953 plt_entry
= htab
->compact_branches
? mipsr6_exec_plt_entry_compact
10954 : mipsr6_exec_plt_entry
;
10956 plt_entry
= mips_exec_plt_entry
;
10957 bfd_put_32 (output_bfd
, plt_entry
[0] | got_address_high
, loc
);
10958 bfd_put_32 (output_bfd
, plt_entry
[1] | got_address_low
| load
,
10961 if (! LOAD_INTERLOCKS_P (output_bfd
)
10962 || (MIPSR6_P (output_bfd
) && htab
->compact_branches
))
10964 bfd_put_32 (output_bfd
, plt_entry
[2] | got_address_low
, loc
+ 8);
10965 bfd_put_32 (output_bfd
, plt_entry
[3], loc
+ 12);
10969 bfd_put_32 (output_bfd
, plt_entry
[3], loc
+ 8);
10970 bfd_put_32 (output_bfd
, plt_entry
[2] | got_address_low
,
10975 /* Now the compressed entry. They come after any standard ones. */
10976 if (h
->plt
.plist
->comp_offset
!= MINUS_ONE
)
10978 bfd_vma plt_offset
;
10980 plt_offset
= (htab
->plt_header_size
+ htab
->plt_mips_offset
10981 + h
->plt
.plist
->comp_offset
);
10983 BFD_ASSERT (plt_offset
<= htab
->root
.splt
->size
);
10985 /* Find out where the .plt entry should go. */
10986 loc
= htab
->root
.splt
->contents
+ plt_offset
;
10988 /* Fill in the PLT entry itself. */
10989 if (!MICROMIPS_P (output_bfd
))
10991 const bfd_vma
*plt_entry
= mips16_o32_exec_plt_entry
;
10993 bfd_put_16 (output_bfd
, plt_entry
[0], loc
);
10994 bfd_put_16 (output_bfd
, plt_entry
[1], loc
+ 2);
10995 bfd_put_16 (output_bfd
, plt_entry
[2], loc
+ 4);
10996 bfd_put_16 (output_bfd
, plt_entry
[3], loc
+ 6);
10997 bfd_put_16 (output_bfd
, plt_entry
[4], loc
+ 8);
10998 bfd_put_16 (output_bfd
, plt_entry
[5], loc
+ 10);
10999 bfd_put_32 (output_bfd
, got_address
, loc
+ 12);
11001 else if (htab
->insn32
)
11003 const bfd_vma
*plt_entry
= micromips_insn32_o32_exec_plt_entry
;
11005 bfd_put_16 (output_bfd
, plt_entry
[0], loc
);
11006 bfd_put_16 (output_bfd
, got_address_high
, loc
+ 2);
11007 bfd_put_16 (output_bfd
, plt_entry
[2], loc
+ 4);
11008 bfd_put_16 (output_bfd
, got_address_low
, loc
+ 6);
11009 bfd_put_16 (output_bfd
, plt_entry
[4], loc
+ 8);
11010 bfd_put_16 (output_bfd
, plt_entry
[5], loc
+ 10);
11011 bfd_put_16 (output_bfd
, plt_entry
[6], loc
+ 12);
11012 bfd_put_16 (output_bfd
, got_address_low
, loc
+ 14);
11016 const bfd_vma
*plt_entry
= micromips_o32_exec_plt_entry
;
11017 bfd_signed_vma gotpc_offset
;
11018 bfd_vma loc_address
;
11020 BFD_ASSERT (got_address
% 4 == 0);
11022 loc_address
= (htab
->root
.splt
->output_section
->vma
11023 + htab
->root
.splt
->output_offset
+ plt_offset
);
11024 gotpc_offset
= got_address
- ((loc_address
| 3) ^ 3);
11026 /* ADDIUPC has a span of +/-16MB, check we're in range. */
11027 if (gotpc_offset
+ 0x1000000 >= 0x2000000)
11030 /* xgettext:c-format */
11031 (_("%pB: `%pA' offset of %" PRId64
" from `%pA' "
11032 "beyond the range of ADDIUPC"),
11034 htab
->root
.sgotplt
->output_section
,
11035 (int64_t) gotpc_offset
,
11036 htab
->root
.splt
->output_section
);
11037 bfd_set_error (bfd_error_no_error
);
11040 bfd_put_16 (output_bfd
,
11041 plt_entry
[0] | ((gotpc_offset
>> 18) & 0x7f), loc
);
11042 bfd_put_16 (output_bfd
, (gotpc_offset
>> 2) & 0xffff, loc
+ 2);
11043 bfd_put_16 (output_bfd
, plt_entry
[2], loc
+ 4);
11044 bfd_put_16 (output_bfd
, plt_entry
[3], loc
+ 6);
11045 bfd_put_16 (output_bfd
, plt_entry
[4], loc
+ 8);
11046 bfd_put_16 (output_bfd
, plt_entry
[5], loc
+ 10);
11050 /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry. */
11051 mips_elf_output_dynamic_relocation (output_bfd
, htab
->root
.srelplt
,
11052 got_index
- 2, h
->dynindx
,
11053 R_MIPS_JUMP_SLOT
, got_address
);
11055 /* We distinguish between PLT entries and lazy-binding stubs by
11056 giving the former an st_other value of STO_MIPS_PLT. Set the
11057 flag and leave the value if there are any relocations in the
11058 binary where pointer equality matters. */
11059 sym
->st_shndx
= SHN_UNDEF
;
11060 if (h
->pointer_equality_needed
)
11061 sym
->st_other
= ELF_ST_SET_MIPS_PLT (sym
->st_other
);
11069 if (h
->plt
.plist
!= NULL
&& h
->plt
.plist
->stub_offset
!= MINUS_ONE
)
11071 /* We've decided to create a lazy-binding stub. */
11072 bfd_boolean micromips_p
= MICROMIPS_P (output_bfd
);
11073 unsigned int other
= micromips_p
? STO_MICROMIPS
: 0;
11074 bfd_vma stub_size
= htab
->function_stub_size
;
11075 bfd_byte stub
[MIPS_FUNCTION_STUB_BIG_SIZE
];
11076 bfd_vma isa_bit
= micromips_p
;
11077 bfd_vma stub_big_size
;
11080 stub_big_size
= MIPS_FUNCTION_STUB_BIG_SIZE
;
11081 else if (htab
->insn32
)
11082 stub_big_size
= MICROMIPS_INSN32_FUNCTION_STUB_BIG_SIZE
;
11084 stub_big_size
= MICROMIPS_FUNCTION_STUB_BIG_SIZE
;
11086 /* This symbol has a stub. Set it up. */
11088 BFD_ASSERT (h
->dynindx
!= -1);
11090 BFD_ASSERT (stub_size
== stub_big_size
|| h
->dynindx
<= 0xffff);
11092 /* Values up to 2^31 - 1 are allowed. Larger values would cause
11093 sign extension at runtime in the stub, resulting in a negative
11095 if (h
->dynindx
& ~0x7fffffff)
11098 /* Fill the stub. */
11102 bfd_put_micromips_32 (output_bfd
, STUB_LW_MICROMIPS (output_bfd
),
11107 bfd_put_micromips_32 (output_bfd
,
11108 STUB_MOVE32_MICROMIPS
, stub
+ idx
);
11113 bfd_put_16 (output_bfd
, STUB_MOVE_MICROMIPS
, stub
+ idx
);
11116 if (stub_size
== stub_big_size
)
11118 long dynindx_hi
= (h
->dynindx
>> 16) & 0x7fff;
11120 bfd_put_micromips_32 (output_bfd
,
11121 STUB_LUI_MICROMIPS (dynindx_hi
),
11127 bfd_put_micromips_32 (output_bfd
, STUB_JALR32_MICROMIPS
,
11133 bfd_put_16 (output_bfd
, STUB_JALR_MICROMIPS
, stub
+ idx
);
11137 /* If a large stub is not required and sign extension is not a
11138 problem, then use legacy code in the stub. */
11139 if (stub_size
== stub_big_size
)
11140 bfd_put_micromips_32 (output_bfd
,
11141 STUB_ORI_MICROMIPS (h
->dynindx
& 0xffff),
11143 else if (h
->dynindx
& ~0x7fff)
11144 bfd_put_micromips_32 (output_bfd
,
11145 STUB_LI16U_MICROMIPS (h
->dynindx
& 0xffff),
11148 bfd_put_micromips_32 (output_bfd
,
11149 STUB_LI16S_MICROMIPS (output_bfd
,
11156 bfd_put_32 (output_bfd
, STUB_LW (output_bfd
), stub
+ idx
);
11158 bfd_put_32 (output_bfd
, STUB_MOVE
, stub
+ idx
);
11160 if (stub_size
== stub_big_size
)
11162 bfd_put_32 (output_bfd
, STUB_LUI ((h
->dynindx
>> 16) & 0x7fff),
11167 if (!(MIPSR6_P (output_bfd
) && htab
->compact_branches
))
11169 bfd_put_32 (output_bfd
, STUB_JALR
, stub
+ idx
);
11173 /* If a large stub is not required and sign extension is not a
11174 problem, then use legacy code in the stub. */
11175 if (stub_size
== stub_big_size
)
11176 bfd_put_32 (output_bfd
, STUB_ORI (h
->dynindx
& 0xffff),
11178 else if (h
->dynindx
& ~0x7fff)
11179 bfd_put_32 (output_bfd
, STUB_LI16U (h
->dynindx
& 0xffff),
11182 bfd_put_32 (output_bfd
, STUB_LI16S (output_bfd
, h
->dynindx
),
11186 if (MIPSR6_P (output_bfd
) && htab
->compact_branches
)
11187 bfd_put_32 (output_bfd
, STUB_JALRC
, stub
+ idx
);
11190 BFD_ASSERT (h
->plt
.plist
->stub_offset
<= htab
->sstubs
->size
);
11191 memcpy (htab
->sstubs
->contents
+ h
->plt
.plist
->stub_offset
,
11194 /* Mark the symbol as undefined. stub_offset != -1 occurs
11195 only for the referenced symbol. */
11196 sym
->st_shndx
= SHN_UNDEF
;
11198 /* The run-time linker uses the st_value field of the symbol
11199 to reset the global offset table entry for this external
11200 to its stub address when unlinking a shared object. */
11201 sym
->st_value
= (htab
->sstubs
->output_section
->vma
11202 + htab
->sstubs
->output_offset
11203 + h
->plt
.plist
->stub_offset
11205 sym
->st_other
= other
;
11208 /* If we have a MIPS16 function with a stub, the dynamic symbol must
11209 refer to the stub, since only the stub uses the standard calling
11211 if (h
->dynindx
!= -1 && hmips
->fn_stub
!= NULL
)
11213 BFD_ASSERT (hmips
->need_fn_stub
);
11214 sym
->st_value
= (hmips
->fn_stub
->output_section
->vma
11215 + hmips
->fn_stub
->output_offset
);
11216 sym
->st_size
= hmips
->fn_stub
->size
;
11217 sym
->st_other
= ELF_ST_VISIBILITY (sym
->st_other
);
11220 BFD_ASSERT (h
->dynindx
!= -1
11221 || h
->forced_local
);
11223 sgot
= htab
->root
.sgot
;
11224 g
= htab
->got_info
;
11225 BFD_ASSERT (g
!= NULL
);
11227 /* Run through the global symbol table, creating GOT entries for all
11228 the symbols that need them. */
11229 if (hmips
->global_got_area
!= GGA_NONE
)
11234 value
= sym
->st_value
;
11235 offset
= mips_elf_primary_global_got_index (output_bfd
, info
, h
);
11236 MIPS_ELF_PUT_WORD (output_bfd
, value
, sgot
->contents
+ offset
);
11239 if (hmips
->global_got_area
!= GGA_NONE
&& g
->next
)
11241 struct mips_got_entry e
, *p
;
11247 e
.abfd
= output_bfd
;
11250 e
.tls_type
= GOT_TLS_NONE
;
11252 for (g
= g
->next
; g
->next
!= gg
; g
= g
->next
)
11255 && (p
= (struct mips_got_entry
*) htab_find (g
->got_entries
,
11258 offset
= p
->gotidx
;
11259 BFD_ASSERT (offset
> 0 && offset
< htab
->root
.sgot
->size
);
11260 if (bfd_link_pic (info
)
11261 || (elf_hash_table (info
)->dynamic_sections_created
11263 && p
->d
.h
->root
.def_dynamic
11264 && !p
->d
.h
->root
.def_regular
))
11266 /* Create an R_MIPS_REL32 relocation for this entry. Due to
11267 the various compatibility problems, it's easier to mock
11268 up an R_MIPS_32 or R_MIPS_64 relocation and leave
11269 mips_elf_create_dynamic_relocation to calculate the
11270 appropriate addend. */
11271 Elf_Internal_Rela rel
[3];
11273 memset (rel
, 0, sizeof (rel
));
11274 if (ABI_64_P (output_bfd
))
11275 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_64
);
11277 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_32
);
11278 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
11281 if (! (mips_elf_create_dynamic_relocation
11282 (output_bfd
, info
, rel
,
11283 e
.d
.h
, NULL
, sym
->st_value
, &entry
, sgot
)))
11287 entry
= sym
->st_value
;
11288 MIPS_ELF_PUT_WORD (output_bfd
, entry
, sgot
->contents
+ offset
);
11293 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
11294 name
= h
->root
.root
.string
;
11295 if (h
== elf_hash_table (info
)->hdynamic
11296 || h
== elf_hash_table (info
)->hgot
)
11297 sym
->st_shndx
= SHN_ABS
;
11298 else if (strcmp (name
, "_DYNAMIC_LINK") == 0
11299 || strcmp (name
, "_DYNAMIC_LINKING") == 0)
11301 sym
->st_shndx
= SHN_ABS
;
11302 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
11305 else if (SGI_COMPAT (output_bfd
))
11307 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
11308 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
11310 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
11311 sym
->st_other
= STO_PROTECTED
;
11313 sym
->st_shndx
= SHN_MIPS_DATA
;
11315 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
11317 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
11318 sym
->st_other
= STO_PROTECTED
;
11319 sym
->st_value
= mips_elf_hash_table (info
)->procedure_count
;
11320 sym
->st_shndx
= SHN_ABS
;
11322 else if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
!= SHN_ABS
)
11324 if (h
->type
== STT_FUNC
)
11325 sym
->st_shndx
= SHN_MIPS_TEXT
;
11326 else if (h
->type
== STT_OBJECT
)
11327 sym
->st_shndx
= SHN_MIPS_DATA
;
11331 /* Emit a copy reloc, if needed. */
11337 BFD_ASSERT (h
->dynindx
!= -1);
11338 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
11340 s
= mips_elf_rel_dyn_section (info
, FALSE
);
11341 symval
= (h
->root
.u
.def
.section
->output_section
->vma
11342 + h
->root
.u
.def
.section
->output_offset
11343 + h
->root
.u
.def
.value
);
11344 mips_elf_output_dynamic_relocation (output_bfd
, s
, s
->reloc_count
++,
11345 h
->dynindx
, R_MIPS_COPY
, symval
);
11348 /* Handle the IRIX6-specific symbols. */
11349 if (IRIX_COMPAT (output_bfd
) == ict_irix6
)
11350 mips_elf_irix6_finish_dynamic_symbol (output_bfd
, name
, sym
);
11352 /* Keep dynamic compressed symbols odd. This allows the dynamic linker
11353 to treat compressed symbols like any other. */
11354 if (ELF_ST_IS_MIPS16 (sym
->st_other
))
11356 BFD_ASSERT (sym
->st_value
& 1);
11357 sym
->st_other
-= STO_MIPS16
;
11359 else if (ELF_ST_IS_MICROMIPS (sym
->st_other
))
11361 BFD_ASSERT (sym
->st_value
& 1);
11362 sym
->st_other
-= STO_MICROMIPS
;
11368 /* Likewise, for VxWorks. */
11371 _bfd_mips_vxworks_finish_dynamic_symbol (bfd
*output_bfd
,
11372 struct bfd_link_info
*info
,
11373 struct elf_link_hash_entry
*h
,
11374 Elf_Internal_Sym
*sym
)
11378 struct mips_got_info
*g
;
11379 struct mips_elf_link_hash_table
*htab
;
11380 struct mips_elf_link_hash_entry
*hmips
;
11382 htab
= mips_elf_hash_table (info
);
11383 BFD_ASSERT (htab
!= NULL
);
11384 dynobj
= elf_hash_table (info
)->dynobj
;
11385 hmips
= (struct mips_elf_link_hash_entry
*) h
;
11387 if (h
->plt
.plist
!= NULL
&& h
->plt
.plist
->mips_offset
!= MINUS_ONE
)
11390 bfd_vma plt_address
, got_address
, got_offset
, branch_offset
;
11391 Elf_Internal_Rela rel
;
11392 static const bfd_vma
*plt_entry
;
11393 bfd_vma gotplt_index
;
11394 bfd_vma plt_offset
;
11396 plt_offset
= htab
->plt_header_size
+ h
->plt
.plist
->mips_offset
;
11397 gotplt_index
= h
->plt
.plist
->gotplt_index
;
11399 BFD_ASSERT (h
->dynindx
!= -1);
11400 BFD_ASSERT (htab
->root
.splt
!= NULL
);
11401 BFD_ASSERT (gotplt_index
!= MINUS_ONE
);
11402 BFD_ASSERT (plt_offset
<= htab
->root
.splt
->size
);
11404 /* Calculate the address of the .plt entry. */
11405 plt_address
= (htab
->root
.splt
->output_section
->vma
11406 + htab
->root
.splt
->output_offset
11409 /* Calculate the address of the .got.plt entry. */
11410 got_address
= (htab
->root
.sgotplt
->output_section
->vma
11411 + htab
->root
.sgotplt
->output_offset
11412 + gotplt_index
* MIPS_ELF_GOT_SIZE (output_bfd
));
11414 /* Calculate the offset of the .got.plt entry from
11415 _GLOBAL_OFFSET_TABLE_. */
11416 got_offset
= mips_elf_gotplt_index (info
, h
);
11418 /* Calculate the offset for the branch at the start of the PLT
11419 entry. The branch jumps to the beginning of .plt. */
11420 branch_offset
= -(plt_offset
/ 4 + 1) & 0xffff;
11422 /* Fill in the initial value of the .got.plt entry. */
11423 bfd_put_32 (output_bfd
, plt_address
,
11424 (htab
->root
.sgotplt
->contents
11425 + gotplt_index
* MIPS_ELF_GOT_SIZE (output_bfd
)));
11427 /* Find out where the .plt entry should go. */
11428 loc
= htab
->root
.splt
->contents
+ plt_offset
;
11430 if (bfd_link_pic (info
))
11432 plt_entry
= mips_vxworks_shared_plt_entry
;
11433 bfd_put_32 (output_bfd
, plt_entry
[0] | branch_offset
, loc
);
11434 bfd_put_32 (output_bfd
, plt_entry
[1] | gotplt_index
, loc
+ 4);
11438 bfd_vma got_address_high
, got_address_low
;
11440 plt_entry
= mips_vxworks_exec_plt_entry
;
11441 got_address_high
= ((got_address
+ 0x8000) >> 16) & 0xffff;
11442 got_address_low
= got_address
& 0xffff;
11444 bfd_put_32 (output_bfd
, plt_entry
[0] | branch_offset
, loc
);
11445 bfd_put_32 (output_bfd
, plt_entry
[1] | gotplt_index
, loc
+ 4);
11446 bfd_put_32 (output_bfd
, plt_entry
[2] | got_address_high
, loc
+ 8);
11447 bfd_put_32 (output_bfd
, plt_entry
[3] | got_address_low
, loc
+ 12);
11448 bfd_put_32 (output_bfd
, plt_entry
[4], loc
+ 16);
11449 bfd_put_32 (output_bfd
, plt_entry
[5], loc
+ 20);
11450 bfd_put_32 (output_bfd
, plt_entry
[6], loc
+ 24);
11451 bfd_put_32 (output_bfd
, plt_entry
[7], loc
+ 28);
11453 loc
= (htab
->srelplt2
->contents
11454 + (gotplt_index
* 3 + 2) * sizeof (Elf32_External_Rela
));
11456 /* Emit a relocation for the .got.plt entry. */
11457 rel
.r_offset
= got_address
;
11458 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
, R_MIPS_32
);
11459 rel
.r_addend
= plt_offset
;
11460 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
11462 /* Emit a relocation for the lui of %hi(<.got.plt slot>). */
11463 loc
+= sizeof (Elf32_External_Rela
);
11464 rel
.r_offset
= plt_address
+ 8;
11465 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_HI16
);
11466 rel
.r_addend
= got_offset
;
11467 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
11469 /* Emit a relocation for the addiu of %lo(<.got.plt slot>). */
11470 loc
+= sizeof (Elf32_External_Rela
);
11472 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_LO16
);
11473 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
11476 /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry. */
11477 loc
= (htab
->root
.srelplt
->contents
11478 + gotplt_index
* sizeof (Elf32_External_Rela
));
11479 rel
.r_offset
= got_address
;
11480 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_JUMP_SLOT
);
11482 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
11484 if (!h
->def_regular
)
11485 sym
->st_shndx
= SHN_UNDEF
;
11488 BFD_ASSERT (h
->dynindx
!= -1 || h
->forced_local
);
11490 sgot
= htab
->root
.sgot
;
11491 g
= htab
->got_info
;
11492 BFD_ASSERT (g
!= NULL
);
11494 /* See if this symbol has an entry in the GOT. */
11495 if (hmips
->global_got_area
!= GGA_NONE
)
11498 Elf_Internal_Rela outrel
;
11502 /* Install the symbol value in the GOT. */
11503 offset
= mips_elf_primary_global_got_index (output_bfd
, info
, h
);
11504 MIPS_ELF_PUT_WORD (output_bfd
, sym
->st_value
, sgot
->contents
+ offset
);
11506 /* Add a dynamic relocation for it. */
11507 s
= mips_elf_rel_dyn_section (info
, FALSE
);
11508 loc
= s
->contents
+ (s
->reloc_count
++ * sizeof (Elf32_External_Rela
));
11509 outrel
.r_offset
= (sgot
->output_section
->vma
11510 + sgot
->output_offset
11512 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_32
);
11513 outrel
.r_addend
= 0;
11514 bfd_elf32_swap_reloca_out (dynobj
, &outrel
, loc
);
11517 /* Emit a copy reloc, if needed. */
11520 Elf_Internal_Rela rel
;
11524 BFD_ASSERT (h
->dynindx
!= -1);
11526 rel
.r_offset
= (h
->root
.u
.def
.section
->output_section
->vma
11527 + h
->root
.u
.def
.section
->output_offset
11528 + h
->root
.u
.def
.value
);
11529 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_COPY
);
11531 if (h
->root
.u
.def
.section
== htab
->root
.sdynrelro
)
11532 srel
= htab
->root
.sreldynrelro
;
11534 srel
= htab
->root
.srelbss
;
11535 loc
= srel
->contents
+ srel
->reloc_count
* sizeof (Elf32_External_Rela
);
11536 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
11537 ++srel
->reloc_count
;
11540 /* If this is a mips16/microMIPS symbol, force the value to be even. */
11541 if (ELF_ST_IS_COMPRESSED (sym
->st_other
))
11542 sym
->st_value
&= ~1;
11547 /* Write out a plt0 entry to the beginning of .plt. */
11550 mips_finish_exec_plt (bfd
*output_bfd
, struct bfd_link_info
*info
)
11553 bfd_vma gotplt_value
, gotplt_value_high
, gotplt_value_low
;
11554 static const bfd_vma
*plt_entry
;
11555 struct mips_elf_link_hash_table
*htab
;
11557 htab
= mips_elf_hash_table (info
);
11558 BFD_ASSERT (htab
!= NULL
);
11560 if (ABI_64_P (output_bfd
))
11561 plt_entry
= (htab
->compact_branches
11562 ? mipsr6_n64_exec_plt0_entry_compact
11563 : mips_n64_exec_plt0_entry
);
11564 else if (ABI_N32_P (output_bfd
))
11565 plt_entry
= (htab
->compact_branches
11566 ? mipsr6_n32_exec_plt0_entry_compact
11567 : mips_n32_exec_plt0_entry
);
11568 else if (!htab
->plt_header_is_comp
)
11569 plt_entry
= (htab
->compact_branches
11570 ? mipsr6_o32_exec_plt0_entry_compact
11571 : mips_o32_exec_plt0_entry
);
11572 else if (htab
->insn32
)
11573 plt_entry
= micromips_insn32_o32_exec_plt0_entry
;
11575 plt_entry
= micromips_o32_exec_plt0_entry
;
11577 /* Calculate the value of .got.plt. */
11578 gotplt_value
= (htab
->root
.sgotplt
->output_section
->vma
11579 + htab
->root
.sgotplt
->output_offset
);
11580 gotplt_value_high
= ((gotplt_value
+ 0x8000) >> 16) & 0xffff;
11581 gotplt_value_low
= gotplt_value
& 0xffff;
11583 /* The PLT sequence is not safe for N64 if .got.plt's address can
11584 not be loaded in two instructions. */
11585 if (ABI_64_P (output_bfd
)
11586 && ((gotplt_value
+ 0x80008000) & ~(bfd_vma
) 0xffffffff) != 0)
11589 /* xgettext:c-format */
11590 (_("%pB: `%pA' start VMA of %#" PRIx64
" outside the 32-bit range "
11591 "supported; consider using `-Ttext-segment=...'"),
11593 htab
->root
.sgotplt
->output_section
,
11594 (int64_t) gotplt_value
);
11595 bfd_set_error (bfd_error_no_error
);
11599 /* Install the PLT header. */
11600 loc
= htab
->root
.splt
->contents
;
11601 if (plt_entry
== micromips_o32_exec_plt0_entry
)
11603 bfd_vma gotpc_offset
;
11604 bfd_vma loc_address
;
11607 BFD_ASSERT (gotplt_value
% 4 == 0);
11609 loc_address
= (htab
->root
.splt
->output_section
->vma
11610 + htab
->root
.splt
->output_offset
);
11611 gotpc_offset
= gotplt_value
- ((loc_address
| 3) ^ 3);
11613 /* ADDIUPC has a span of +/-16MB, check we're in range. */
11614 if (gotpc_offset
+ 0x1000000 >= 0x2000000)
11617 /* xgettext:c-format */
11618 (_("%pB: `%pA' offset of %" PRId64
" from `%pA' "
11619 "beyond the range of ADDIUPC"),
11621 htab
->root
.sgotplt
->output_section
,
11622 (int64_t) gotpc_offset
,
11623 htab
->root
.splt
->output_section
);
11624 bfd_set_error (bfd_error_no_error
);
11627 bfd_put_16 (output_bfd
,
11628 plt_entry
[0] | ((gotpc_offset
>> 18) & 0x7f), loc
);
11629 bfd_put_16 (output_bfd
, (gotpc_offset
>> 2) & 0xffff, loc
+ 2);
11630 for (i
= 2; i
< ARRAY_SIZE (micromips_o32_exec_plt0_entry
); i
++)
11631 bfd_put_16 (output_bfd
, plt_entry
[i
], loc
+ (i
* 2));
11633 else if (plt_entry
== micromips_insn32_o32_exec_plt0_entry
)
11637 bfd_put_16 (output_bfd
, plt_entry
[0], loc
);
11638 bfd_put_16 (output_bfd
, gotplt_value_high
, loc
+ 2);
11639 bfd_put_16 (output_bfd
, plt_entry
[2], loc
+ 4);
11640 bfd_put_16 (output_bfd
, gotplt_value_low
, loc
+ 6);
11641 bfd_put_16 (output_bfd
, plt_entry
[4], loc
+ 8);
11642 bfd_put_16 (output_bfd
, gotplt_value_low
, loc
+ 10);
11643 for (i
= 6; i
< ARRAY_SIZE (micromips_insn32_o32_exec_plt0_entry
); i
++)
11644 bfd_put_16 (output_bfd
, plt_entry
[i
], loc
+ (i
* 2));
11648 bfd_put_32 (output_bfd
, plt_entry
[0] | gotplt_value_high
, loc
);
11649 bfd_put_32 (output_bfd
, plt_entry
[1] | gotplt_value_low
, loc
+ 4);
11650 bfd_put_32 (output_bfd
, plt_entry
[2] | gotplt_value_low
, loc
+ 8);
11651 bfd_put_32 (output_bfd
, plt_entry
[3], loc
+ 12);
11652 bfd_put_32 (output_bfd
, plt_entry
[4], loc
+ 16);
11653 bfd_put_32 (output_bfd
, plt_entry
[5], loc
+ 20);
11654 bfd_put_32 (output_bfd
, plt_entry
[6], loc
+ 24);
11655 bfd_put_32 (output_bfd
, plt_entry
[7], loc
+ 28);
11661 /* Install the PLT header for a VxWorks executable and finalize the
11662 contents of .rela.plt.unloaded. */
11665 mips_vxworks_finish_exec_plt (bfd
*output_bfd
, struct bfd_link_info
*info
)
11667 Elf_Internal_Rela rela
;
11669 bfd_vma got_value
, got_value_high
, got_value_low
, plt_address
;
11670 static const bfd_vma
*plt_entry
;
11671 struct mips_elf_link_hash_table
*htab
;
11673 htab
= mips_elf_hash_table (info
);
11674 BFD_ASSERT (htab
!= NULL
);
11676 plt_entry
= mips_vxworks_exec_plt0_entry
;
11678 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */
11679 got_value
= (htab
->root
.hgot
->root
.u
.def
.section
->output_section
->vma
11680 + htab
->root
.hgot
->root
.u
.def
.section
->output_offset
11681 + htab
->root
.hgot
->root
.u
.def
.value
);
11683 got_value_high
= ((got_value
+ 0x8000) >> 16) & 0xffff;
11684 got_value_low
= got_value
& 0xffff;
11686 /* Calculate the address of the PLT header. */
11687 plt_address
= (htab
->root
.splt
->output_section
->vma
11688 + htab
->root
.splt
->output_offset
);
11690 /* Install the PLT header. */
11691 loc
= htab
->root
.splt
->contents
;
11692 bfd_put_32 (output_bfd
, plt_entry
[0] | got_value_high
, loc
);
11693 bfd_put_32 (output_bfd
, plt_entry
[1] | got_value_low
, loc
+ 4);
11694 bfd_put_32 (output_bfd
, plt_entry
[2], loc
+ 8);
11695 bfd_put_32 (output_bfd
, plt_entry
[3], loc
+ 12);
11696 bfd_put_32 (output_bfd
, plt_entry
[4], loc
+ 16);
11697 bfd_put_32 (output_bfd
, plt_entry
[5], loc
+ 20);
11699 /* Output the relocation for the lui of %hi(_GLOBAL_OFFSET_TABLE_). */
11700 loc
= htab
->srelplt2
->contents
;
11701 rela
.r_offset
= plt_address
;
11702 rela
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_HI16
);
11704 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
11705 loc
+= sizeof (Elf32_External_Rela
);
11707 /* Output the relocation for the following addiu of
11708 %lo(_GLOBAL_OFFSET_TABLE_). */
11709 rela
.r_offset
+= 4;
11710 rela
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_LO16
);
11711 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
11712 loc
+= sizeof (Elf32_External_Rela
);
11714 /* Fix up the remaining relocations. They may have the wrong
11715 symbol index for _G_O_T_ or _P_L_T_ depending on the order
11716 in which symbols were output. */
11717 while (loc
< htab
->srelplt2
->contents
+ htab
->srelplt2
->size
)
11719 Elf_Internal_Rela rel
;
11721 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &rel
);
11722 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
, R_MIPS_32
);
11723 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
11724 loc
+= sizeof (Elf32_External_Rela
);
11726 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &rel
);
11727 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_HI16
);
11728 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
11729 loc
+= sizeof (Elf32_External_Rela
);
11731 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &rel
);
11732 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_LO16
);
11733 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
11734 loc
+= sizeof (Elf32_External_Rela
);
11738 /* Install the PLT header for a VxWorks shared library. */
11741 mips_vxworks_finish_shared_plt (bfd
*output_bfd
, struct bfd_link_info
*info
)
11744 struct mips_elf_link_hash_table
*htab
;
11746 htab
= mips_elf_hash_table (info
);
11747 BFD_ASSERT (htab
!= NULL
);
11749 /* We just need to copy the entry byte-by-byte. */
11750 for (i
= 0; i
< ARRAY_SIZE (mips_vxworks_shared_plt0_entry
); i
++)
11751 bfd_put_32 (output_bfd
, mips_vxworks_shared_plt0_entry
[i
],
11752 htab
->root
.splt
->contents
+ i
* 4);
11755 /* Finish up the dynamic sections. */
11758 _bfd_mips_elf_finish_dynamic_sections (bfd
*output_bfd
,
11759 struct bfd_link_info
*info
)
11764 struct mips_got_info
*gg
, *g
;
11765 struct mips_elf_link_hash_table
*htab
;
11767 htab
= mips_elf_hash_table (info
);
11768 BFD_ASSERT (htab
!= NULL
);
11770 dynobj
= elf_hash_table (info
)->dynobj
;
11772 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
11774 sgot
= htab
->root
.sgot
;
11775 gg
= htab
->got_info
;
11777 if (elf_hash_table (info
)->dynamic_sections_created
)
11780 int dyn_to_skip
= 0, dyn_skipped
= 0;
11782 BFD_ASSERT (sdyn
!= NULL
);
11783 BFD_ASSERT (gg
!= NULL
);
11785 g
= mips_elf_bfd_got (output_bfd
, FALSE
);
11786 BFD_ASSERT (g
!= NULL
);
11788 for (b
= sdyn
->contents
;
11789 b
< sdyn
->contents
+ sdyn
->size
;
11790 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
11792 Elf_Internal_Dyn dyn
;
11796 bfd_boolean swap_out_p
;
11798 /* Read in the current dynamic entry. */
11799 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
11801 /* Assume that we're going to modify it and write it out. */
11807 dyn
.d_un
.d_val
= MIPS_ELF_REL_SIZE (dynobj
);
11811 BFD_ASSERT (htab
->is_vxworks
);
11812 dyn
.d_un
.d_val
= MIPS_ELF_RELA_SIZE (dynobj
);
11816 /* Rewrite DT_STRSZ. */
11818 _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
11822 s
= htab
->root
.sgot
;
11823 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
11826 case DT_MIPS_PLTGOT
:
11827 s
= htab
->root
.sgotplt
;
11828 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
11831 case DT_MIPS_RLD_VERSION
:
11832 dyn
.d_un
.d_val
= 1; /* XXX */
11835 case DT_MIPS_FLAGS
:
11836 dyn
.d_un
.d_val
= RHF_NOTPOT
; /* XXX */
11839 case DT_MIPS_TIME_STAMP
:
11843 dyn
.d_un
.d_val
= t
;
11847 case DT_MIPS_ICHECKSUM
:
11849 swap_out_p
= FALSE
;
11852 case DT_MIPS_IVERSION
:
11854 swap_out_p
= FALSE
;
11857 case DT_MIPS_BASE_ADDRESS
:
11858 s
= output_bfd
->sections
;
11859 BFD_ASSERT (s
!= NULL
);
11860 dyn
.d_un
.d_ptr
= s
->vma
& ~(bfd_vma
) 0xffff;
11863 case DT_MIPS_LOCAL_GOTNO
:
11864 dyn
.d_un
.d_val
= g
->local_gotno
;
11867 case DT_MIPS_UNREFEXTNO
:
11868 /* The index into the dynamic symbol table which is the
11869 entry of the first external symbol that is not
11870 referenced within the same object. */
11871 dyn
.d_un
.d_val
= bfd_count_sections (output_bfd
) + 1;
11874 case DT_MIPS_GOTSYM
:
11875 if (htab
->global_gotsym
)
11877 dyn
.d_un
.d_val
= htab
->global_gotsym
->dynindx
;
11880 /* In case if we don't have global got symbols we default
11881 to setting DT_MIPS_GOTSYM to the same value as
11882 DT_MIPS_SYMTABNO. */
11883 /* Fall through. */
11885 case DT_MIPS_SYMTABNO
:
11887 elemsize
= MIPS_ELF_SYM_SIZE (output_bfd
);
11888 s
= bfd_get_linker_section (dynobj
, name
);
11891 dyn
.d_un
.d_val
= s
->size
/ elemsize
;
11893 dyn
.d_un
.d_val
= 0;
11896 case DT_MIPS_HIPAGENO
:
11897 dyn
.d_un
.d_val
= g
->local_gotno
- htab
->reserved_gotno
;
11900 case DT_MIPS_RLD_MAP
:
11902 struct elf_link_hash_entry
*h
;
11903 h
= mips_elf_hash_table (info
)->rld_symbol
;
11906 dyn_to_skip
= MIPS_ELF_DYN_SIZE (dynobj
);
11907 swap_out_p
= FALSE
;
11910 s
= h
->root
.u
.def
.section
;
11912 /* The MIPS_RLD_MAP tag stores the absolute address of the
11914 dyn
.d_un
.d_ptr
= (s
->output_section
->vma
+ s
->output_offset
11915 + h
->root
.u
.def
.value
);
11919 case DT_MIPS_RLD_MAP_REL
:
11921 struct elf_link_hash_entry
*h
;
11922 bfd_vma dt_addr
, rld_addr
;
11923 h
= mips_elf_hash_table (info
)->rld_symbol
;
11926 dyn_to_skip
= MIPS_ELF_DYN_SIZE (dynobj
);
11927 swap_out_p
= FALSE
;
11930 s
= h
->root
.u
.def
.section
;
11932 /* The MIPS_RLD_MAP_REL tag stores the offset to the debug
11933 pointer, relative to the address of the tag. */
11934 dt_addr
= (sdyn
->output_section
->vma
+ sdyn
->output_offset
11935 + (b
- sdyn
->contents
));
11936 rld_addr
= (s
->output_section
->vma
+ s
->output_offset
11937 + h
->root
.u
.def
.value
);
11938 dyn
.d_un
.d_ptr
= rld_addr
- dt_addr
;
11942 case DT_MIPS_OPTIONS
:
11943 s
= (bfd_get_section_by_name
11944 (output_bfd
, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd
)));
11945 dyn
.d_un
.d_ptr
= s
->vma
;
11949 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
11950 if (htab
->is_vxworks
)
11951 dyn
.d_un
.d_val
= DT_RELA
;
11953 dyn
.d_un
.d_val
= DT_REL
;
11957 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
11958 dyn
.d_un
.d_val
= htab
->root
.srelplt
->size
;
11962 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
11963 dyn
.d_un
.d_ptr
= (htab
->root
.srelplt
->output_section
->vma
11964 + htab
->root
.srelplt
->output_offset
);
11968 /* If we didn't need any text relocations after all, delete
11969 the dynamic tag. */
11970 if (!(info
->flags
& DF_TEXTREL
))
11972 dyn_to_skip
= MIPS_ELF_DYN_SIZE (dynobj
);
11973 swap_out_p
= FALSE
;
11978 /* If we didn't need any text relocations after all, clear
11979 DF_TEXTREL from DT_FLAGS. */
11980 if (!(info
->flags
& DF_TEXTREL
))
11981 dyn
.d_un
.d_val
&= ~DF_TEXTREL
;
11983 swap_out_p
= FALSE
;
11986 case DT_MIPS_XHASH
:
11987 name
= ".MIPS.xhash";
11988 s
= bfd_get_linker_section (dynobj
, name
);
11989 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
11993 swap_out_p
= FALSE
;
11994 if (htab
->is_vxworks
11995 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
12000 if (swap_out_p
|| dyn_skipped
)
12001 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
12002 (dynobj
, &dyn
, b
- dyn_skipped
);
12006 dyn_skipped
+= dyn_to_skip
;
12011 /* Wipe out any trailing entries if we shifted down a dynamic tag. */
12012 if (dyn_skipped
> 0)
12013 memset (b
- dyn_skipped
, 0, dyn_skipped
);
12016 if (sgot
!= NULL
&& sgot
->size
> 0
12017 && !bfd_is_abs_section (sgot
->output_section
))
12019 if (htab
->is_vxworks
)
12021 /* The first entry of the global offset table points to the
12022 ".dynamic" section. The second is initialized by the
12023 loader and contains the shared library identifier.
12024 The third is also initialized by the loader and points
12025 to the lazy resolution stub. */
12026 MIPS_ELF_PUT_WORD (output_bfd
,
12027 sdyn
->output_offset
+ sdyn
->output_section
->vma
,
12029 MIPS_ELF_PUT_WORD (output_bfd
, 0,
12030 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
12031 MIPS_ELF_PUT_WORD (output_bfd
, 0,
12033 + 2 * MIPS_ELF_GOT_SIZE (output_bfd
));
12037 /* The first entry of the global offset table will be filled at
12038 runtime. The second entry will be used by some runtime loaders.
12039 This isn't the case of IRIX rld. */
12040 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
12041 MIPS_ELF_PUT_WORD (output_bfd
, MIPS_ELF_GNU_GOT1_MASK (output_bfd
),
12042 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
12045 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
12046 = MIPS_ELF_GOT_SIZE (output_bfd
);
12049 /* Generate dynamic relocations for the non-primary gots. */
12050 if (gg
!= NULL
&& gg
->next
)
12052 Elf_Internal_Rela rel
[3];
12053 bfd_vma addend
= 0;
12055 memset (rel
, 0, sizeof (rel
));
12056 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_REL32
);
12058 for (g
= gg
->next
; g
->next
!= gg
; g
= g
->next
)
12060 bfd_vma got_index
= g
->next
->local_gotno
+ g
->next
->global_gotno
12061 + g
->next
->tls_gotno
;
12063 MIPS_ELF_PUT_WORD (output_bfd
, 0, sgot
->contents
12064 + got_index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
12065 MIPS_ELF_PUT_WORD (output_bfd
, MIPS_ELF_GNU_GOT1_MASK (output_bfd
),
12067 + got_index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
12069 if (! bfd_link_pic (info
))
12072 for (; got_index
< g
->local_gotno
; got_index
++)
12074 if (got_index
>= g
->assigned_low_gotno
12075 && got_index
<= g
->assigned_high_gotno
)
12078 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
12079 = got_index
* MIPS_ELF_GOT_SIZE (output_bfd
);
12080 if (!(mips_elf_create_dynamic_relocation
12081 (output_bfd
, info
, rel
, NULL
,
12082 bfd_abs_section_ptr
,
12083 0, &addend
, sgot
)))
12085 BFD_ASSERT (addend
== 0);
12090 /* The generation of dynamic relocations for the non-primary gots
12091 adds more dynamic relocations. We cannot count them until
12094 if (elf_hash_table (info
)->dynamic_sections_created
)
12097 bfd_boolean swap_out_p
;
12099 BFD_ASSERT (sdyn
!= NULL
);
12101 for (b
= sdyn
->contents
;
12102 b
< sdyn
->contents
+ sdyn
->size
;
12103 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
12105 Elf_Internal_Dyn dyn
;
12108 /* Read in the current dynamic entry. */
12109 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
12111 /* Assume that we're going to modify it and write it out. */
12117 /* Reduce DT_RELSZ to account for any relocations we
12118 decided not to make. This is for the n64 irix rld,
12119 which doesn't seem to apply any relocations if there
12120 are trailing null entries. */
12121 s
= mips_elf_rel_dyn_section (info
, FALSE
);
12122 dyn
.d_un
.d_val
= (s
->reloc_count
12123 * (ABI_64_P (output_bfd
)
12124 ? sizeof (Elf64_Mips_External_Rel
)
12125 : sizeof (Elf32_External_Rel
)));
12126 /* Adjust the section size too. Tools like the prelinker
12127 can reasonably expect the values to the same. */
12128 BFD_ASSERT (!bfd_is_abs_section (s
->output_section
));
12129 elf_section_data (s
->output_section
)->this_hdr
.sh_size
12134 swap_out_p
= FALSE
;
12139 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
12146 Elf32_compact_rel cpt
;
12148 if (SGI_COMPAT (output_bfd
))
12150 /* Write .compact_rel section out. */
12151 s
= bfd_get_linker_section (dynobj
, ".compact_rel");
12155 cpt
.num
= s
->reloc_count
;
12157 cpt
.offset
= (s
->output_section
->filepos
12158 + sizeof (Elf32_External_compact_rel
));
12161 bfd_elf32_swap_compact_rel_out (output_bfd
, &cpt
,
12162 ((Elf32_External_compact_rel
*)
12165 /* Clean up a dummy stub function entry in .text. */
12166 if (htab
->sstubs
!= NULL
)
12168 file_ptr dummy_offset
;
12170 BFD_ASSERT (htab
->sstubs
->size
>= htab
->function_stub_size
);
12171 dummy_offset
= htab
->sstubs
->size
- htab
->function_stub_size
;
12172 memset (htab
->sstubs
->contents
+ dummy_offset
, 0,
12173 htab
->function_stub_size
);
12178 /* The psABI says that the dynamic relocations must be sorted in
12179 increasing order of r_symndx. The VxWorks EABI doesn't require
12180 this, and because the code below handles REL rather than RELA
12181 relocations, using it for VxWorks would be outright harmful. */
12182 if (!htab
->is_vxworks
)
12184 s
= mips_elf_rel_dyn_section (info
, FALSE
);
12186 && s
->size
> (bfd_vma
)2 * MIPS_ELF_REL_SIZE (output_bfd
))
12188 reldyn_sorting_bfd
= output_bfd
;
12190 if (ABI_64_P (output_bfd
))
12191 qsort ((Elf64_External_Rel
*) s
->contents
+ 1,
12192 s
->reloc_count
- 1, sizeof (Elf64_Mips_External_Rel
),
12193 sort_dynamic_relocs_64
);
12195 qsort ((Elf32_External_Rel
*) s
->contents
+ 1,
12196 s
->reloc_count
- 1, sizeof (Elf32_External_Rel
),
12197 sort_dynamic_relocs
);
12202 if (htab
->root
.splt
&& htab
->root
.splt
->size
> 0)
12204 if (htab
->is_vxworks
)
12206 if (bfd_link_pic (info
))
12207 mips_vxworks_finish_shared_plt (output_bfd
, info
);
12209 mips_vxworks_finish_exec_plt (output_bfd
, info
);
12213 BFD_ASSERT (!bfd_link_pic (info
));
12214 if (!mips_finish_exec_plt (output_bfd
, info
))
12222 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
12225 mips_set_isa_flags (bfd
*abfd
)
12229 switch (bfd_get_mach (abfd
))
12232 if (ABI_N32_P (abfd
) || ABI_64_P (abfd
))
12233 val
= E_MIPS_ARCH_3
;
12235 val
= E_MIPS_ARCH_1
;
12238 case bfd_mach_mips3000
:
12239 val
= E_MIPS_ARCH_1
;
12242 case bfd_mach_mips3900
:
12243 val
= E_MIPS_ARCH_1
| E_MIPS_MACH_3900
;
12246 case bfd_mach_mips6000
:
12247 val
= E_MIPS_ARCH_2
;
12250 case bfd_mach_mips4010
:
12251 val
= E_MIPS_ARCH_2
| E_MIPS_MACH_4010
;
12254 case bfd_mach_mips4000
:
12255 case bfd_mach_mips4300
:
12256 case bfd_mach_mips4400
:
12257 case bfd_mach_mips4600
:
12258 val
= E_MIPS_ARCH_3
;
12261 case bfd_mach_mips4100
:
12262 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4100
;
12265 case bfd_mach_mips4111
:
12266 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4111
;
12269 case bfd_mach_mips4120
:
12270 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4120
;
12273 case bfd_mach_mips4650
:
12274 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4650
;
12277 case bfd_mach_mips5400
:
12278 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5400
;
12281 case bfd_mach_mips5500
:
12282 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5500
;
12285 case bfd_mach_mips5900
:
12286 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_5900
;
12289 case bfd_mach_mips9000
:
12290 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_9000
;
12293 case bfd_mach_mips5000
:
12294 case bfd_mach_mips7000
:
12295 case bfd_mach_mips8000
:
12296 case bfd_mach_mips10000
:
12297 case bfd_mach_mips12000
:
12298 case bfd_mach_mips14000
:
12299 case bfd_mach_mips16000
:
12300 val
= E_MIPS_ARCH_4
;
12303 case bfd_mach_mips5
:
12304 val
= E_MIPS_ARCH_5
;
12307 case bfd_mach_mips_loongson_2e
:
12308 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_LS2E
;
12311 case bfd_mach_mips_loongson_2f
:
12312 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_LS2F
;
12315 case bfd_mach_mips_sb1
:
12316 val
= E_MIPS_ARCH_64
| E_MIPS_MACH_SB1
;
12319 case bfd_mach_mips_gs464
:
12320 val
= E_MIPS_ARCH_64R2
| E_MIPS_MACH_GS464
;
12323 case bfd_mach_mips_gs464e
:
12324 val
= E_MIPS_ARCH_64R2
| E_MIPS_MACH_GS464E
;
12327 case bfd_mach_mips_gs264e
:
12328 val
= E_MIPS_ARCH_64R2
| E_MIPS_MACH_GS264E
;
12331 case bfd_mach_mips_octeon
:
12332 case bfd_mach_mips_octeonp
:
12333 val
= E_MIPS_ARCH_64R2
| E_MIPS_MACH_OCTEON
;
12336 case bfd_mach_mips_octeon3
:
12337 val
= E_MIPS_ARCH_64R2
| E_MIPS_MACH_OCTEON3
;
12340 case bfd_mach_mips_xlr
:
12341 val
= E_MIPS_ARCH_64
| E_MIPS_MACH_XLR
;
12344 case bfd_mach_mips_octeon2
:
12345 val
= E_MIPS_ARCH_64R2
| E_MIPS_MACH_OCTEON2
;
12348 case bfd_mach_mipsisa32
:
12349 val
= E_MIPS_ARCH_32
;
12352 case bfd_mach_mipsisa64
:
12353 val
= E_MIPS_ARCH_64
;
12356 case bfd_mach_mipsisa32r2
:
12357 case bfd_mach_mipsisa32r3
:
12358 case bfd_mach_mipsisa32r5
:
12359 val
= E_MIPS_ARCH_32R2
;
12362 case bfd_mach_mips_interaptiv_mr2
:
12363 val
= E_MIPS_ARCH_32R2
| E_MIPS_MACH_IAMR2
;
12366 case bfd_mach_mipsisa64r2
:
12367 case bfd_mach_mipsisa64r3
:
12368 case bfd_mach_mipsisa64r5
:
12369 val
= E_MIPS_ARCH_64R2
;
12372 case bfd_mach_mipsisa32r6
:
12373 val
= E_MIPS_ARCH_32R6
;
12376 case bfd_mach_mipsisa64r6
:
12377 val
= E_MIPS_ARCH_64R6
;
12380 elf_elfheader (abfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
12381 elf_elfheader (abfd
)->e_flags
|= val
;
12386 /* Whether to sort relocs output by ld -r or ld --emit-relocs, by r_offset.
12387 Don't do so for code sections. We want to keep ordering of HI16/LO16
12388 as is. On the other hand, elf-eh-frame.c processing requires .eh_frame
12389 relocs to be sorted. */
12392 _bfd_mips_elf_sort_relocs_p (asection
*sec
)
12394 return (sec
->flags
& SEC_CODE
) == 0;
12398 /* The final processing done just before writing out a MIPS ELF object
12399 file. This gets the MIPS architecture right based on the machine
12400 number. This is used by both the 32-bit and the 64-bit ABI. */
12403 _bfd_mips_final_write_processing (bfd
*abfd
)
12406 Elf_Internal_Shdr
**hdrpp
;
12410 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
12411 is nonzero. This is for compatibility with old objects, which used
12412 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
12413 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_MACH
) == 0)
12414 mips_set_isa_flags (abfd
);
12416 /* Set the sh_info field for .gptab sections and other appropriate
12417 info for each special section. */
12418 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
12419 i
< elf_numsections (abfd
);
12422 switch ((*hdrpp
)->sh_type
)
12424 case SHT_MIPS_MSYM
:
12425 case SHT_MIPS_LIBLIST
:
12426 sec
= bfd_get_section_by_name (abfd
, ".dynstr");
12428 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
12431 case SHT_MIPS_GPTAB
:
12432 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
12433 name
= bfd_section_name ((*hdrpp
)->bfd_section
);
12434 BFD_ASSERT (name
!= NULL
12435 && CONST_STRNEQ (name
, ".gptab."));
12436 sec
= bfd_get_section_by_name (abfd
, name
+ sizeof ".gptab" - 1);
12437 BFD_ASSERT (sec
!= NULL
);
12438 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
12441 case SHT_MIPS_CONTENT
:
12442 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
12443 name
= bfd_section_name ((*hdrpp
)->bfd_section
);
12444 BFD_ASSERT (name
!= NULL
12445 && CONST_STRNEQ (name
, ".MIPS.content"));
12446 sec
= bfd_get_section_by_name (abfd
,
12447 name
+ sizeof ".MIPS.content" - 1);
12448 BFD_ASSERT (sec
!= NULL
);
12449 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
12452 case SHT_MIPS_SYMBOL_LIB
:
12453 sec
= bfd_get_section_by_name (abfd
, ".dynsym");
12455 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
12456 sec
= bfd_get_section_by_name (abfd
, ".liblist");
12458 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
12461 case SHT_MIPS_EVENTS
:
12462 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
12463 name
= bfd_section_name ((*hdrpp
)->bfd_section
);
12464 BFD_ASSERT (name
!= NULL
);
12465 if (CONST_STRNEQ (name
, ".MIPS.events"))
12466 sec
= bfd_get_section_by_name (abfd
,
12467 name
+ sizeof ".MIPS.events" - 1);
12470 BFD_ASSERT (CONST_STRNEQ (name
, ".MIPS.post_rel"));
12471 sec
= bfd_get_section_by_name (abfd
,
12473 + sizeof ".MIPS.post_rel" - 1));
12475 BFD_ASSERT (sec
!= NULL
);
12476 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
12479 case SHT_MIPS_XHASH
:
12480 sec
= bfd_get_section_by_name (abfd
, ".dynsym");
12482 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
12488 _bfd_mips_elf_final_write_processing (bfd
*abfd
)
12490 _bfd_mips_final_write_processing (abfd
);
12491 return _bfd_elf_final_write_processing (abfd
);
12494 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
12498 _bfd_mips_elf_additional_program_headers (bfd
*abfd
,
12499 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
12504 /* See if we need a PT_MIPS_REGINFO segment. */
12505 s
= bfd_get_section_by_name (abfd
, ".reginfo");
12506 if (s
&& (s
->flags
& SEC_LOAD
))
12509 /* See if we need a PT_MIPS_ABIFLAGS segment. */
12510 if (bfd_get_section_by_name (abfd
, ".MIPS.abiflags"))
12513 /* See if we need a PT_MIPS_OPTIONS segment. */
12514 if (IRIX_COMPAT (abfd
) == ict_irix6
12515 && bfd_get_section_by_name (abfd
,
12516 MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)))
12519 /* See if we need a PT_MIPS_RTPROC segment. */
12520 if (IRIX_COMPAT (abfd
) == ict_irix5
12521 && bfd_get_section_by_name (abfd
, ".dynamic")
12522 && bfd_get_section_by_name (abfd
, ".mdebug"))
12525 /* Allocate a PT_NULL header in dynamic objects. See
12526 _bfd_mips_elf_modify_segment_map for details. */
12527 if (!SGI_COMPAT (abfd
)
12528 && bfd_get_section_by_name (abfd
, ".dynamic"))
12534 /* Modify the segment map for an IRIX5 executable. */
12537 _bfd_mips_elf_modify_segment_map (bfd
*abfd
,
12538 struct bfd_link_info
*info
)
12541 struct elf_segment_map
*m
, **pm
;
12544 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
12546 s
= bfd_get_section_by_name (abfd
, ".reginfo");
12547 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
12549 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
12550 if (m
->p_type
== PT_MIPS_REGINFO
)
12555 m
= bfd_zalloc (abfd
, amt
);
12559 m
->p_type
= PT_MIPS_REGINFO
;
12561 m
->sections
[0] = s
;
12563 /* We want to put it after the PHDR and INTERP segments. */
12564 pm
= &elf_seg_map (abfd
);
12566 && ((*pm
)->p_type
== PT_PHDR
12567 || (*pm
)->p_type
== PT_INTERP
))
12575 /* If there is a .MIPS.abiflags section, we need a PT_MIPS_ABIFLAGS
12577 s
= bfd_get_section_by_name (abfd
, ".MIPS.abiflags");
12578 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
12580 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
12581 if (m
->p_type
== PT_MIPS_ABIFLAGS
)
12586 m
= bfd_zalloc (abfd
, amt
);
12590 m
->p_type
= PT_MIPS_ABIFLAGS
;
12592 m
->sections
[0] = s
;
12594 /* We want to put it after the PHDR and INTERP segments. */
12595 pm
= &elf_seg_map (abfd
);
12597 && ((*pm
)->p_type
== PT_PHDR
12598 || (*pm
)->p_type
== PT_INTERP
))
12606 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
12607 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
12608 PT_MIPS_OPTIONS segment immediately following the program header
12610 if (NEWABI_P (abfd
)
12611 /* On non-IRIX6 new abi, we'll have already created a segment
12612 for this section, so don't create another. I'm not sure this
12613 is not also the case for IRIX 6, but I can't test it right
12615 && IRIX_COMPAT (abfd
) == ict_irix6
)
12617 for (s
= abfd
->sections
; s
; s
= s
->next
)
12618 if (elf_section_data (s
)->this_hdr
.sh_type
== SHT_MIPS_OPTIONS
)
12623 struct elf_segment_map
*options_segment
;
12625 pm
= &elf_seg_map (abfd
);
12627 && ((*pm
)->p_type
== PT_PHDR
12628 || (*pm
)->p_type
== PT_INTERP
))
12631 if (*pm
== NULL
|| (*pm
)->p_type
!= PT_MIPS_OPTIONS
)
12633 amt
= sizeof (struct elf_segment_map
);
12634 options_segment
= bfd_zalloc (abfd
, amt
);
12635 options_segment
->next
= *pm
;
12636 options_segment
->p_type
= PT_MIPS_OPTIONS
;
12637 options_segment
->p_flags
= PF_R
;
12638 options_segment
->p_flags_valid
= TRUE
;
12639 options_segment
->count
= 1;
12640 options_segment
->sections
[0] = s
;
12641 *pm
= options_segment
;
12647 if (IRIX_COMPAT (abfd
) == ict_irix5
)
12649 /* If there are .dynamic and .mdebug sections, we make a room
12650 for the RTPROC header. FIXME: Rewrite without section names. */
12651 if (bfd_get_section_by_name (abfd
, ".interp") == NULL
12652 && bfd_get_section_by_name (abfd
, ".dynamic") != NULL
12653 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
12655 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
12656 if (m
->p_type
== PT_MIPS_RTPROC
)
12661 m
= bfd_zalloc (abfd
, amt
);
12665 m
->p_type
= PT_MIPS_RTPROC
;
12667 s
= bfd_get_section_by_name (abfd
, ".rtproc");
12672 m
->p_flags_valid
= 1;
12677 m
->sections
[0] = s
;
12680 /* We want to put it after the DYNAMIC segment. */
12681 pm
= &elf_seg_map (abfd
);
12682 while (*pm
!= NULL
&& (*pm
)->p_type
!= PT_DYNAMIC
)
12692 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
12693 .dynstr, .dynsym, and .hash sections, and everything in
12695 for (pm
= &elf_seg_map (abfd
); *pm
!= NULL
;
12697 if ((*pm
)->p_type
== PT_DYNAMIC
)
12700 /* GNU/Linux binaries do not need the extended PT_DYNAMIC section.
12701 glibc's dynamic linker has traditionally derived the number of
12702 tags from the p_filesz field, and sometimes allocates stack
12703 arrays of that size. An overly-big PT_DYNAMIC segment can
12704 be actively harmful in such cases. Making PT_DYNAMIC contain
12705 other sections can also make life hard for the prelinker,
12706 which might move one of the other sections to a different
12707 PT_LOAD segment. */
12708 if (SGI_COMPAT (abfd
)
12711 && strcmp (m
->sections
[0]->name
, ".dynamic") == 0)
12713 static const char *sec_names
[] =
12715 ".dynamic", ".dynstr", ".dynsym", ".hash"
12719 struct elf_segment_map
*n
;
12721 low
= ~(bfd_vma
) 0;
12723 for (i
= 0; i
< sizeof sec_names
/ sizeof sec_names
[0]; i
++)
12725 s
= bfd_get_section_by_name (abfd
, sec_names
[i
]);
12726 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
12733 if (high
< s
->vma
+ sz
)
12734 high
= s
->vma
+ sz
;
12739 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
12740 if ((s
->flags
& SEC_LOAD
) != 0
12742 && s
->vma
+ s
->size
<= high
)
12745 amt
= sizeof *n
- sizeof (asection
*) + c
* sizeof (asection
*);
12746 n
= bfd_zalloc (abfd
, amt
);
12753 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
12755 if ((s
->flags
& SEC_LOAD
) != 0
12757 && s
->vma
+ s
->size
<= high
)
12759 n
->sections
[i
] = s
;
12768 /* Allocate a spare program header in dynamic objects so that tools
12769 like the prelinker can add an extra PT_LOAD entry.
12771 If the prelinker needs to make room for a new PT_LOAD entry, its
12772 standard procedure is to move the first (read-only) sections into
12773 the new (writable) segment. However, the MIPS ABI requires
12774 .dynamic to be in a read-only segment, and the section will often
12775 start within sizeof (ElfNN_Phdr) bytes of the last program header.
12777 Although the prelinker could in principle move .dynamic to a
12778 writable segment, it seems better to allocate a spare program
12779 header instead, and avoid the need to move any sections.
12780 There is a long tradition of allocating spare dynamic tags,
12781 so allocating a spare program header seems like a natural
12784 If INFO is NULL, we may be copying an already prelinked binary
12785 with objcopy or strip, so do not add this header. */
12787 && !SGI_COMPAT (abfd
)
12788 && bfd_get_section_by_name (abfd
, ".dynamic"))
12790 for (pm
= &elf_seg_map (abfd
); *pm
!= NULL
; pm
= &(*pm
)->next
)
12791 if ((*pm
)->p_type
== PT_NULL
)
12795 m
= bfd_zalloc (abfd
, sizeof (*m
));
12799 m
->p_type
= PT_NULL
;
12807 /* Return the section that should be marked against GC for a given
12811 _bfd_mips_elf_gc_mark_hook (asection
*sec
,
12812 struct bfd_link_info
*info
,
12813 Elf_Internal_Rela
*rel
,
12814 struct elf_link_hash_entry
*h
,
12815 Elf_Internal_Sym
*sym
)
12817 /* ??? Do mips16 stub sections need to be handled special? */
12820 switch (ELF_R_TYPE (sec
->owner
, rel
->r_info
))
12822 case R_MIPS_GNU_VTINHERIT
:
12823 case R_MIPS_GNU_VTENTRY
:
12827 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
12830 /* Prevent .MIPS.abiflags from being discarded with --gc-sections. */
12833 _bfd_mips_elf_gc_mark_extra_sections (struct bfd_link_info
*info
,
12834 elf_gc_mark_hook_fn gc_mark_hook
)
12838 _bfd_elf_gc_mark_extra_sections (info
, gc_mark_hook
);
12840 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
12844 if (! is_mips_elf (sub
))
12847 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
12849 && MIPS_ELF_ABIFLAGS_SECTION_NAME_P (bfd_section_name (o
)))
12851 if (!_bfd_elf_gc_mark (info
, o
, gc_mark_hook
))
12859 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
12860 hiding the old indirect symbol. Process additional relocation
12861 information. Also called for weakdefs, in which case we just let
12862 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
12865 _bfd_mips_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
12866 struct elf_link_hash_entry
*dir
,
12867 struct elf_link_hash_entry
*ind
)
12869 struct mips_elf_link_hash_entry
*dirmips
, *indmips
;
12871 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
12873 dirmips
= (struct mips_elf_link_hash_entry
*) dir
;
12874 indmips
= (struct mips_elf_link_hash_entry
*) ind
;
12875 /* Any absolute non-dynamic relocations against an indirect or weak
12876 definition will be against the target symbol. */
12877 if (indmips
->has_static_relocs
)
12878 dirmips
->has_static_relocs
= TRUE
;
12880 if (ind
->root
.type
!= bfd_link_hash_indirect
)
12883 dirmips
->possibly_dynamic_relocs
+= indmips
->possibly_dynamic_relocs
;
12884 if (indmips
->readonly_reloc
)
12885 dirmips
->readonly_reloc
= TRUE
;
12886 if (indmips
->no_fn_stub
)
12887 dirmips
->no_fn_stub
= TRUE
;
12888 if (indmips
->fn_stub
)
12890 dirmips
->fn_stub
= indmips
->fn_stub
;
12891 indmips
->fn_stub
= NULL
;
12893 if (indmips
->need_fn_stub
)
12895 dirmips
->need_fn_stub
= TRUE
;
12896 indmips
->need_fn_stub
= FALSE
;
12898 if (indmips
->call_stub
)
12900 dirmips
->call_stub
= indmips
->call_stub
;
12901 indmips
->call_stub
= NULL
;
12903 if (indmips
->call_fp_stub
)
12905 dirmips
->call_fp_stub
= indmips
->call_fp_stub
;
12906 indmips
->call_fp_stub
= NULL
;
12908 if (indmips
->global_got_area
< dirmips
->global_got_area
)
12909 dirmips
->global_got_area
= indmips
->global_got_area
;
12910 if (indmips
->global_got_area
< GGA_NONE
)
12911 indmips
->global_got_area
= GGA_NONE
;
12912 if (indmips
->has_nonpic_branches
)
12913 dirmips
->has_nonpic_branches
= TRUE
;
12916 /* Take care of the special `__gnu_absolute_zero' symbol and ignore attempts
12917 to hide it. It has to remain global (it will also be protected) so as to
12918 be assigned a global GOT entry, which will then remain unchanged at load
12922 _bfd_mips_elf_hide_symbol (struct bfd_link_info
*info
,
12923 struct elf_link_hash_entry
*entry
,
12924 bfd_boolean force_local
)
12926 struct mips_elf_link_hash_table
*htab
;
12928 htab
= mips_elf_hash_table (info
);
12929 BFD_ASSERT (htab
!= NULL
);
12930 if (htab
->use_absolute_zero
12931 && strcmp (entry
->root
.root
.string
, "__gnu_absolute_zero") == 0)
12934 _bfd_elf_link_hash_hide_symbol (info
, entry
, force_local
);
12937 #define PDR_SIZE 32
12940 _bfd_mips_elf_discard_info (bfd
*abfd
, struct elf_reloc_cookie
*cookie
,
12941 struct bfd_link_info
*info
)
12944 bfd_boolean ret
= FALSE
;
12945 unsigned char *tdata
;
12948 o
= bfd_get_section_by_name (abfd
, ".pdr");
12953 if (o
->size
% PDR_SIZE
!= 0)
12955 if (o
->output_section
!= NULL
12956 && bfd_is_abs_section (o
->output_section
))
12959 tdata
= bfd_zmalloc (o
->size
/ PDR_SIZE
);
12963 cookie
->rels
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
12964 info
->keep_memory
);
12971 cookie
->rel
= cookie
->rels
;
12972 cookie
->relend
= cookie
->rels
+ o
->reloc_count
;
12974 for (i
= 0, skip
= 0; i
< o
->size
/ PDR_SIZE
; i
++)
12976 if (bfd_elf_reloc_symbol_deleted_p (i
* PDR_SIZE
, cookie
))
12985 mips_elf_section_data (o
)->u
.tdata
= tdata
;
12986 if (o
->rawsize
== 0)
12987 o
->rawsize
= o
->size
;
12988 o
->size
-= skip
* PDR_SIZE
;
12994 if (! info
->keep_memory
)
12995 free (cookie
->rels
);
13001 _bfd_mips_elf_ignore_discarded_relocs (asection
*sec
)
13003 if (strcmp (sec
->name
, ".pdr") == 0)
13009 _bfd_mips_elf_write_section (bfd
*output_bfd
,
13010 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
13011 asection
*sec
, bfd_byte
*contents
)
13013 bfd_byte
*to
, *from
, *end
;
13016 if (strcmp (sec
->name
, ".pdr") != 0)
13019 if (mips_elf_section_data (sec
)->u
.tdata
== NULL
)
13023 end
= contents
+ sec
->size
;
13024 for (from
= contents
, i
= 0;
13026 from
+= PDR_SIZE
, i
++)
13028 if ((mips_elf_section_data (sec
)->u
.tdata
)[i
] == 1)
13031 memcpy (to
, from
, PDR_SIZE
);
13034 bfd_set_section_contents (output_bfd
, sec
->output_section
, contents
,
13035 sec
->output_offset
, sec
->size
);
13039 /* microMIPS code retains local labels for linker relaxation. Omit them
13040 from output by default for clarity. */
13043 _bfd_mips_elf_is_target_special_symbol (bfd
*abfd
, asymbol
*sym
)
13045 return _bfd_elf_is_local_label_name (abfd
, sym
->name
);
13048 /* MIPS ELF uses a special find_nearest_line routine in order the
13049 handle the ECOFF debugging information. */
13051 struct mips_elf_find_line
13053 struct ecoff_debug_info d
;
13054 struct ecoff_find_line i
;
13058 _bfd_mips_elf_find_nearest_line (bfd
*abfd
, asymbol
**symbols
,
13059 asection
*section
, bfd_vma offset
,
13060 const char **filename_ptr
,
13061 const char **functionname_ptr
,
13062 unsigned int *line_ptr
,
13063 unsigned int *discriminator_ptr
)
13067 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
13068 filename_ptr
, functionname_ptr
,
13069 line_ptr
, discriminator_ptr
,
13070 dwarf_debug_sections
,
13071 &elf_tdata (abfd
)->dwarf2_find_line_info
)
13075 if (_bfd_dwarf1_find_nearest_line (abfd
, symbols
, section
, offset
,
13076 filename_ptr
, functionname_ptr
,
13079 if (!*functionname_ptr
)
13080 _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
13081 *filename_ptr
? NULL
: filename_ptr
,
13086 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
13089 flagword origflags
;
13090 struct mips_elf_find_line
*fi
;
13091 const struct ecoff_debug_swap
* const swap
=
13092 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
13094 /* If we are called during a link, mips_elf_final_link may have
13095 cleared the SEC_HAS_CONTENTS field. We force it back on here
13096 if appropriate (which it normally will be). */
13097 origflags
= msec
->flags
;
13098 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
13099 msec
->flags
|= SEC_HAS_CONTENTS
;
13101 fi
= mips_elf_tdata (abfd
)->find_line_info
;
13104 bfd_size_type external_fdr_size
;
13107 struct fdr
*fdr_ptr
;
13108 bfd_size_type amt
= sizeof (struct mips_elf_find_line
);
13110 fi
= bfd_zalloc (abfd
, amt
);
13113 msec
->flags
= origflags
;
13117 if (! _bfd_mips_elf_read_ecoff_info (abfd
, msec
, &fi
->d
))
13119 msec
->flags
= origflags
;
13123 /* Swap in the FDR information. */
13124 amt
= fi
->d
.symbolic_header
.ifdMax
* sizeof (struct fdr
);
13125 fi
->d
.fdr
= bfd_alloc (abfd
, amt
);
13126 if (fi
->d
.fdr
== NULL
)
13128 msec
->flags
= origflags
;
13131 external_fdr_size
= swap
->external_fdr_size
;
13132 fdr_ptr
= fi
->d
.fdr
;
13133 fraw_src
= (char *) fi
->d
.external_fdr
;
13134 fraw_end
= (fraw_src
13135 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
13136 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
13137 (*swap
->swap_fdr_in
) (abfd
, fraw_src
, fdr_ptr
);
13139 mips_elf_tdata (abfd
)->find_line_info
= fi
;
13141 /* Note that we don't bother to ever free this information.
13142 find_nearest_line is either called all the time, as in
13143 objdump -l, so the information should be saved, or it is
13144 rarely called, as in ld error messages, so the memory
13145 wasted is unimportant. Still, it would probably be a
13146 good idea for free_cached_info to throw it away. */
13149 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
13150 &fi
->i
, filename_ptr
, functionname_ptr
,
13153 msec
->flags
= origflags
;
13157 msec
->flags
= origflags
;
13160 /* Fall back on the generic ELF find_nearest_line routine. */
13162 return _bfd_elf_find_nearest_line (abfd
, symbols
, section
, offset
,
13163 filename_ptr
, functionname_ptr
,
13164 line_ptr
, discriminator_ptr
);
13168 _bfd_mips_elf_find_inliner_info (bfd
*abfd
,
13169 const char **filename_ptr
,
13170 const char **functionname_ptr
,
13171 unsigned int *line_ptr
)
13174 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
13175 functionname_ptr
, line_ptr
,
13176 & elf_tdata (abfd
)->dwarf2_find_line_info
);
13181 /* When are writing out the .options or .MIPS.options section,
13182 remember the bytes we are writing out, so that we can install the
13183 GP value in the section_processing routine. */
13186 _bfd_mips_elf_set_section_contents (bfd
*abfd
, sec_ptr section
,
13187 const void *location
,
13188 file_ptr offset
, bfd_size_type count
)
13190 if (MIPS_ELF_OPTIONS_SECTION_NAME_P (section
->name
))
13194 if (elf_section_data (section
) == NULL
)
13196 size_t amt
= sizeof (struct bfd_elf_section_data
);
13197 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
13198 if (elf_section_data (section
) == NULL
)
13201 c
= mips_elf_section_data (section
)->u
.tdata
;
13204 c
= bfd_zalloc (abfd
, section
->size
);
13207 mips_elf_section_data (section
)->u
.tdata
= c
;
13210 memcpy (c
+ offset
, location
, count
);
13213 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
,
13217 /* This is almost identical to bfd_generic_get_... except that some
13218 MIPS relocations need to be handled specially. Sigh. */
13221 _bfd_elf_mips_get_relocated_section_contents
13223 struct bfd_link_info
*link_info
,
13224 struct bfd_link_order
*link_order
,
13226 bfd_boolean relocatable
,
13229 /* Get enough memory to hold the stuff */
13230 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
13231 asection
*input_section
= link_order
->u
.indirect
.section
;
13234 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
13235 arelent
**reloc_vector
= NULL
;
13238 if (reloc_size
< 0)
13241 reloc_vector
= bfd_malloc (reloc_size
);
13242 if (reloc_vector
== NULL
&& reloc_size
!= 0)
13245 /* read in the section */
13246 sz
= input_section
->rawsize
? input_section
->rawsize
: input_section
->size
;
13247 if (!bfd_get_section_contents (input_bfd
, input_section
, data
, 0, sz
))
13250 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
13254 if (reloc_count
< 0)
13257 if (reloc_count
> 0)
13262 bfd_vma gp
= 0x12345678; /* initialize just to shut gcc up */
13265 struct bfd_hash_entry
*h
;
13266 struct bfd_link_hash_entry
*lh
;
13267 /* Skip all this stuff if we aren't mixing formats. */
13268 if (abfd
&& input_bfd
13269 && abfd
->xvec
== input_bfd
->xvec
)
13273 h
= bfd_hash_lookup (&link_info
->hash
->table
, "_gp", FALSE
, FALSE
);
13274 lh
= (struct bfd_link_hash_entry
*) h
;
13281 case bfd_link_hash_undefined
:
13282 case bfd_link_hash_undefweak
:
13283 case bfd_link_hash_common
:
13286 case bfd_link_hash_defined
:
13287 case bfd_link_hash_defweak
:
13289 gp
= lh
->u
.def
.value
;
13291 case bfd_link_hash_indirect
:
13292 case bfd_link_hash_warning
:
13294 /* @@FIXME ignoring warning for now */
13296 case bfd_link_hash_new
:
13305 for (parent
= reloc_vector
; *parent
!= NULL
; parent
++)
13307 char *error_message
= NULL
;
13308 bfd_reloc_status_type r
;
13310 /* Specific to MIPS: Deal with relocation types that require
13311 knowing the gp of the output bfd. */
13312 asymbol
*sym
= *(*parent
)->sym_ptr_ptr
;
13314 /* If we've managed to find the gp and have a special
13315 function for the relocation then go ahead, else default
13316 to the generic handling. */
13318 && (*parent
)->howto
->special_function
13319 == _bfd_mips_elf32_gprel16_reloc
)
13320 r
= _bfd_mips_elf_gprel16_with_gp (input_bfd
, sym
, *parent
,
13321 input_section
, relocatable
,
13324 r
= bfd_perform_relocation (input_bfd
, *parent
, data
,
13326 relocatable
? abfd
: NULL
,
13331 asection
*os
= input_section
->output_section
;
13333 /* A partial link, so keep the relocs */
13334 os
->orelocation
[os
->reloc_count
] = *parent
;
13338 if (r
!= bfd_reloc_ok
)
13342 case bfd_reloc_undefined
:
13343 (*link_info
->callbacks
->undefined_symbol
)
13344 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
13345 input_bfd
, input_section
, (*parent
)->address
, TRUE
);
13347 case bfd_reloc_dangerous
:
13348 BFD_ASSERT (error_message
!= NULL
);
13349 (*link_info
->callbacks
->reloc_dangerous
)
13350 (link_info
, error_message
,
13351 input_bfd
, input_section
, (*parent
)->address
);
13353 case bfd_reloc_overflow
:
13354 (*link_info
->callbacks
->reloc_overflow
)
13356 bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
13357 (*parent
)->howto
->name
, (*parent
)->addend
,
13358 input_bfd
, input_section
, (*parent
)->address
);
13360 case bfd_reloc_outofrange
:
13369 free (reloc_vector
);
13373 free (reloc_vector
);
13378 mips_elf_relax_delete_bytes (bfd
*abfd
,
13379 asection
*sec
, bfd_vma addr
, int count
)
13381 Elf_Internal_Shdr
*symtab_hdr
;
13382 unsigned int sec_shndx
;
13383 bfd_byte
*contents
;
13384 Elf_Internal_Rela
*irel
, *irelend
;
13385 Elf_Internal_Sym
*isym
;
13386 Elf_Internal_Sym
*isymend
;
13387 struct elf_link_hash_entry
**sym_hashes
;
13388 struct elf_link_hash_entry
**end_hashes
;
13389 struct elf_link_hash_entry
**start_hashes
;
13390 unsigned int symcount
;
13392 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
13393 contents
= elf_section_data (sec
)->this_hdr
.contents
;
13395 irel
= elf_section_data (sec
)->relocs
;
13396 irelend
= irel
+ sec
->reloc_count
;
13398 /* Actually delete the bytes. */
13399 memmove (contents
+ addr
, contents
+ addr
+ count
,
13400 (size_t) (sec
->size
- addr
- count
));
13401 sec
->size
-= count
;
13403 /* Adjust all the relocs. */
13404 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
13406 /* Get the new reloc address. */
13407 if (irel
->r_offset
> addr
)
13408 irel
->r_offset
-= count
;
13411 BFD_ASSERT (addr
% 2 == 0);
13412 BFD_ASSERT (count
% 2 == 0);
13414 /* Adjust the local symbols defined in this section. */
13415 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
13416 isym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
13417 for (isymend
= isym
+ symtab_hdr
->sh_info
; isym
< isymend
; isym
++)
13418 if (isym
->st_shndx
== sec_shndx
&& isym
->st_value
> addr
)
13419 isym
->st_value
-= count
;
13421 /* Now adjust the global symbols defined in this section. */
13422 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
13423 - symtab_hdr
->sh_info
);
13424 sym_hashes
= start_hashes
= elf_sym_hashes (abfd
);
13425 end_hashes
= sym_hashes
+ symcount
;
13427 for (; sym_hashes
< end_hashes
; sym_hashes
++)
13429 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
13431 if ((sym_hash
->root
.type
== bfd_link_hash_defined
13432 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
13433 && sym_hash
->root
.u
.def
.section
== sec
)
13435 bfd_vma value
= sym_hash
->root
.u
.def
.value
;
13437 if (ELF_ST_IS_MICROMIPS (sym_hash
->other
))
13438 value
&= MINUS_TWO
;
13440 sym_hash
->root
.u
.def
.value
-= count
;
13448 /* Opcodes needed for microMIPS relaxation as found in
13449 opcodes/micromips-opc.c. */
13451 struct opcode_descriptor
{
13452 unsigned long match
;
13453 unsigned long mask
;
13456 /* The $ra register aka $31. */
13460 /* 32-bit instruction format register fields. */
13462 #define OP32_SREG(opcode) (((opcode) >> 16) & 0x1f)
13463 #define OP32_TREG(opcode) (((opcode) >> 21) & 0x1f)
13465 /* Check if a 5-bit register index can be abbreviated to 3 bits. */
13467 #define OP16_VALID_REG(r) \
13468 ((2 <= (r) && (r) <= 7) || (16 <= (r) && (r) <= 17))
13471 /* 32-bit and 16-bit branches. */
13473 static const struct opcode_descriptor b_insns_32
[] = {
13474 { /* "b", "p", */ 0x40400000, 0xffff0000 }, /* bgez 0 */
13475 { /* "b", "p", */ 0x94000000, 0xffff0000 }, /* beq 0, 0 */
13476 { 0, 0 } /* End marker for find_match(). */
13479 static const struct opcode_descriptor bc_insn_32
=
13480 { /* "bc(1|2)(ft)", "N,p", */ 0x42800000, 0xfec30000 };
13482 static const struct opcode_descriptor bz_insn_32
=
13483 { /* "b(g|l)(e|t)z", "s,p", */ 0x40000000, 0xff200000 };
13485 static const struct opcode_descriptor bzal_insn_32
=
13486 { /* "b(ge|lt)zal", "s,p", */ 0x40200000, 0xffa00000 };
13488 static const struct opcode_descriptor beq_insn_32
=
13489 { /* "b(eq|ne)", "s,t,p", */ 0x94000000, 0xdc000000 };
13491 static const struct opcode_descriptor b_insn_16
=
13492 { /* "b", "mD", */ 0xcc00, 0xfc00 };
13494 static const struct opcode_descriptor bz_insn_16
=
13495 { /* "b(eq|ne)z", "md,mE", */ 0x8c00, 0xdc00 };
13498 /* 32-bit and 16-bit branch EQ and NE zero. */
13500 /* NOTE: All opcode tables have BEQ/BNE in the same order: first the
13501 eq and second the ne. This convention is used when replacing a
13502 32-bit BEQ/BNE with the 16-bit version. */
13504 #define BZC32_REG_FIELD(r) (((r) & 0x1f) << 16)
13506 static const struct opcode_descriptor bz_rs_insns_32
[] = {
13507 { /* "beqz", "s,p", */ 0x94000000, 0xffe00000 },
13508 { /* "bnez", "s,p", */ 0xb4000000, 0xffe00000 },
13509 { 0, 0 } /* End marker for find_match(). */
13512 static const struct opcode_descriptor bz_rt_insns_32
[] = {
13513 { /* "beqz", "t,p", */ 0x94000000, 0xfc01f000 },
13514 { /* "bnez", "t,p", */ 0xb4000000, 0xfc01f000 },
13515 { 0, 0 } /* End marker for find_match(). */
13518 static const struct opcode_descriptor bzc_insns_32
[] = {
13519 { /* "beqzc", "s,p", */ 0x40e00000, 0xffe00000 },
13520 { /* "bnezc", "s,p", */ 0x40a00000, 0xffe00000 },
13521 { 0, 0 } /* End marker for find_match(). */
13524 static const struct opcode_descriptor bz_insns_16
[] = {
13525 { /* "beqz", "md,mE", */ 0x8c00, 0xfc00 },
13526 { /* "bnez", "md,mE", */ 0xac00, 0xfc00 },
13527 { 0, 0 } /* End marker for find_match(). */
13530 /* Switch between a 5-bit register index and its 3-bit shorthand. */
13532 #define BZ16_REG(opcode) ((((((opcode) >> 7) & 7) + 0x1e) & 0xf) + 2)
13533 #define BZ16_REG_FIELD(r) (((r) & 7) << 7)
13536 /* 32-bit instructions with a delay slot. */
13538 static const struct opcode_descriptor jal_insn_32_bd16
=
13539 { /* "jals", "a", */ 0x74000000, 0xfc000000 };
13541 static const struct opcode_descriptor jal_insn_32_bd32
=
13542 { /* "jal", "a", */ 0xf4000000, 0xfc000000 };
13544 static const struct opcode_descriptor jal_x_insn_32_bd32
=
13545 { /* "jal[x]", "a", */ 0xf0000000, 0xf8000000 };
13547 static const struct opcode_descriptor j_insn_32
=
13548 { /* "j", "a", */ 0xd4000000, 0xfc000000 };
13550 static const struct opcode_descriptor jalr_insn_32
=
13551 { /* "jalr[.hb]", "t,s", */ 0x00000f3c, 0xfc00efff };
13553 /* This table can be compacted, because no opcode replacement is made. */
13555 static const struct opcode_descriptor ds_insns_32_bd16
[] = {
13556 { /* "jals", "a", */ 0x74000000, 0xfc000000 },
13558 { /* "jalrs[.hb]", "t,s", */ 0x00004f3c, 0xfc00efff },
13559 { /* "b(ge|lt)zals", "s,p", */ 0x42200000, 0xffa00000 },
13561 { /* "b(g|l)(e|t)z", "s,p", */ 0x40000000, 0xff200000 },
13562 { /* "b(eq|ne)", "s,t,p", */ 0x94000000, 0xdc000000 },
13563 { /* "j", "a", */ 0xd4000000, 0xfc000000 },
13564 { 0, 0 } /* End marker for find_match(). */
13567 /* This table can be compacted, because no opcode replacement is made. */
13569 static const struct opcode_descriptor ds_insns_32_bd32
[] = {
13570 { /* "jal[x]", "a", */ 0xf0000000, 0xf8000000 },
13572 { /* "jalr[.hb]", "t,s", */ 0x00000f3c, 0xfc00efff },
13573 { /* "b(ge|lt)zal", "s,p", */ 0x40200000, 0xffa00000 },
13574 { 0, 0 } /* End marker for find_match(). */
13578 /* 16-bit instructions with a delay slot. */
13580 static const struct opcode_descriptor jalr_insn_16_bd16
=
13581 { /* "jalrs", "my,mj", */ 0x45e0, 0xffe0 };
13583 static const struct opcode_descriptor jalr_insn_16_bd32
=
13584 { /* "jalr", "my,mj", */ 0x45c0, 0xffe0 };
13586 static const struct opcode_descriptor jr_insn_16
=
13587 { /* "jr", "mj", */ 0x4580, 0xffe0 };
13589 #define JR16_REG(opcode) ((opcode) & 0x1f)
13591 /* This table can be compacted, because no opcode replacement is made. */
13593 static const struct opcode_descriptor ds_insns_16_bd16
[] = {
13594 { /* "jalrs", "my,mj", */ 0x45e0, 0xffe0 },
13596 { /* "b", "mD", */ 0xcc00, 0xfc00 },
13597 { /* "b(eq|ne)z", "md,mE", */ 0x8c00, 0xdc00 },
13598 { /* "jr", "mj", */ 0x4580, 0xffe0 },
13599 { 0, 0 } /* End marker for find_match(). */
13603 /* LUI instruction. */
13605 static const struct opcode_descriptor lui_insn
=
13606 { /* "lui", "s,u", */ 0x41a00000, 0xffe00000 };
13609 /* ADDIU instruction. */
13611 static const struct opcode_descriptor addiu_insn
=
13612 { /* "addiu", "t,r,j", */ 0x30000000, 0xfc000000 };
13614 static const struct opcode_descriptor addiupc_insn
=
13615 { /* "addiu", "mb,$pc,mQ", */ 0x78000000, 0xfc000000 };
13617 #define ADDIUPC_REG_FIELD(r) \
13618 (((2 <= (r) && (r) <= 7) ? (r) : ((r) - 16)) << 23)
13621 /* Relaxable instructions in a JAL delay slot: MOVE. */
13623 /* The 16-bit move has rd in 9:5 and rs in 4:0. The 32-bit moves
13624 (ADDU, OR) have rd in 15:11 and rs in 10:16. */
13625 #define MOVE32_RD(opcode) (((opcode) >> 11) & 0x1f)
13626 #define MOVE32_RS(opcode) (((opcode) >> 16) & 0x1f)
13628 #define MOVE16_RD_FIELD(r) (((r) & 0x1f) << 5)
13629 #define MOVE16_RS_FIELD(r) (((r) & 0x1f) )
13631 static const struct opcode_descriptor move_insns_32
[] = {
13632 { /* "move", "d,s", */ 0x00000290, 0xffe007ff }, /* or d,s,$0 */
13633 { /* "move", "d,s", */ 0x00000150, 0xffe007ff }, /* addu d,s,$0 */
13634 { 0, 0 } /* End marker for find_match(). */
13637 static const struct opcode_descriptor move_insn_16
=
13638 { /* "move", "mp,mj", */ 0x0c00, 0xfc00 };
13641 /* NOP instructions. */
13643 static const struct opcode_descriptor nop_insn_32
=
13644 { /* "nop", "", */ 0x00000000, 0xffffffff };
13646 static const struct opcode_descriptor nop_insn_16
=
13647 { /* "nop", "", */ 0x0c00, 0xffff };
13650 /* Instruction match support. */
13652 #define MATCH(opcode, insn) ((opcode & insn.mask) == insn.match)
13655 find_match (unsigned long opcode
, const struct opcode_descriptor insn
[])
13657 unsigned long indx
;
13659 for (indx
= 0; insn
[indx
].mask
!= 0; indx
++)
13660 if (MATCH (opcode
, insn
[indx
]))
13667 /* Branch and delay slot decoding support. */
13669 /* If PTR points to what *might* be a 16-bit branch or jump, then
13670 return the minimum length of its delay slot, otherwise return 0.
13671 Non-zero results are not definitive as we might be checking against
13672 the second half of another instruction. */
13675 check_br16_dslot (bfd
*abfd
, bfd_byte
*ptr
)
13677 unsigned long opcode
;
13680 opcode
= bfd_get_16 (abfd
, ptr
);
13681 if (MATCH (opcode
, jalr_insn_16_bd32
) != 0)
13682 /* 16-bit branch/jump with a 32-bit delay slot. */
13684 else if (MATCH (opcode
, jalr_insn_16_bd16
) != 0
13685 || find_match (opcode
, ds_insns_16_bd16
) >= 0)
13686 /* 16-bit branch/jump with a 16-bit delay slot. */
13689 /* No delay slot. */
13695 /* If PTR points to what *might* be a 32-bit branch or jump, then
13696 return the minimum length of its delay slot, otherwise return 0.
13697 Non-zero results are not definitive as we might be checking against
13698 the second half of another instruction. */
13701 check_br32_dslot (bfd
*abfd
, bfd_byte
*ptr
)
13703 unsigned long opcode
;
13706 opcode
= bfd_get_micromips_32 (abfd
, ptr
);
13707 if (find_match (opcode
, ds_insns_32_bd32
) >= 0)
13708 /* 32-bit branch/jump with a 32-bit delay slot. */
13710 else if (find_match (opcode
, ds_insns_32_bd16
) >= 0)
13711 /* 32-bit branch/jump with a 16-bit delay slot. */
13714 /* No delay slot. */
13720 /* If PTR points to a 16-bit branch or jump with a 32-bit delay slot
13721 that doesn't fiddle with REG, then return TRUE, otherwise FALSE. */
13724 check_br16 (bfd
*abfd
, bfd_byte
*ptr
, unsigned long reg
)
13726 unsigned long opcode
;
13728 opcode
= bfd_get_16 (abfd
, ptr
);
13729 if (MATCH (opcode
, b_insn_16
)
13731 || (MATCH (opcode
, jr_insn_16
) && reg
!= JR16_REG (opcode
))
13733 || (MATCH (opcode
, bz_insn_16
) && reg
!= BZ16_REG (opcode
))
13734 /* BEQZ16, BNEZ16 */
13735 || (MATCH (opcode
, jalr_insn_16_bd32
)
13737 && reg
!= JR16_REG (opcode
) && reg
!= RA
))
13743 /* If PTR points to a 32-bit branch or jump that doesn't fiddle with REG,
13744 then return TRUE, otherwise FALSE. */
13747 check_br32 (bfd
*abfd
, bfd_byte
*ptr
, unsigned long reg
)
13749 unsigned long opcode
;
13751 opcode
= bfd_get_micromips_32 (abfd
, ptr
);
13752 if (MATCH (opcode
, j_insn_32
)
13754 || MATCH (opcode
, bc_insn_32
)
13755 /* BC1F, BC1T, BC2F, BC2T */
13756 || (MATCH (opcode
, jal_x_insn_32_bd32
) && reg
!= RA
)
13758 || (MATCH (opcode
, bz_insn_32
) && reg
!= OP32_SREG (opcode
))
13759 /* BGEZ, BGTZ, BLEZ, BLTZ */
13760 || (MATCH (opcode
, bzal_insn_32
)
13761 /* BGEZAL, BLTZAL */
13762 && reg
!= OP32_SREG (opcode
) && reg
!= RA
)
13763 || ((MATCH (opcode
, jalr_insn_32
) || MATCH (opcode
, beq_insn_32
))
13764 /* JALR, JALR.HB, BEQ, BNE */
13765 && reg
!= OP32_SREG (opcode
) && reg
!= OP32_TREG (opcode
)))
13771 /* If the instruction encoding at PTR and relocations [INTERNAL_RELOCS,
13772 IRELEND) at OFFSET indicate that there must be a compact branch there,
13773 then return TRUE, otherwise FALSE. */
13776 check_relocated_bzc (bfd
*abfd
, const bfd_byte
*ptr
, bfd_vma offset
,
13777 const Elf_Internal_Rela
*internal_relocs
,
13778 const Elf_Internal_Rela
*irelend
)
13780 const Elf_Internal_Rela
*irel
;
13781 unsigned long opcode
;
13783 opcode
= bfd_get_micromips_32 (abfd
, ptr
);
13784 if (find_match (opcode
, bzc_insns_32
) < 0)
13787 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
13788 if (irel
->r_offset
== offset
13789 && ELF32_R_TYPE (irel
->r_info
) == R_MICROMIPS_PC16_S1
)
13795 /* Bitsize checking. */
13796 #define IS_BITSIZE(val, N) \
13797 (((((val) & ((1ULL << (N)) - 1)) ^ (1ULL << ((N) - 1))) \
13798 - (1ULL << ((N) - 1))) == (val))
13802 _bfd_mips_elf_relax_section (bfd
*abfd
, asection
*sec
,
13803 struct bfd_link_info
*link_info
,
13804 bfd_boolean
*again
)
13806 bfd_boolean insn32
= mips_elf_hash_table (link_info
)->insn32
;
13807 Elf_Internal_Shdr
*symtab_hdr
;
13808 Elf_Internal_Rela
*internal_relocs
;
13809 Elf_Internal_Rela
*irel
, *irelend
;
13810 bfd_byte
*contents
= NULL
;
13811 Elf_Internal_Sym
*isymbuf
= NULL
;
13813 /* Assume nothing changes. */
13816 /* We don't have to do anything for a relocatable link, if
13817 this section does not have relocs, or if this is not a
13820 if (bfd_link_relocatable (link_info
)
13821 || (sec
->flags
& SEC_RELOC
) == 0
13822 || sec
->reloc_count
== 0
13823 || (sec
->flags
& SEC_CODE
) == 0)
13826 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
13828 /* Get a copy of the native relocations. */
13829 internal_relocs
= (_bfd_elf_link_read_relocs
13830 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
13831 link_info
->keep_memory
));
13832 if (internal_relocs
== NULL
)
13835 /* Walk through them looking for relaxing opportunities. */
13836 irelend
= internal_relocs
+ sec
->reloc_count
;
13837 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
13839 unsigned long r_symndx
= ELF32_R_SYM (irel
->r_info
);
13840 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
13841 bfd_boolean target_is_micromips_code_p
;
13842 unsigned long opcode
;
13848 /* The number of bytes to delete for relaxation and from where
13849 to delete these bytes starting at irel->r_offset. */
13853 /* If this isn't something that can be relaxed, then ignore
13855 if (r_type
!= R_MICROMIPS_HI16
13856 && r_type
!= R_MICROMIPS_PC16_S1
13857 && r_type
!= R_MICROMIPS_26_S1
)
13860 /* Get the section contents if we haven't done so already. */
13861 if (contents
== NULL
)
13863 /* Get cached copy if it exists. */
13864 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
13865 contents
= elf_section_data (sec
)->this_hdr
.contents
;
13866 /* Go get them off disk. */
13867 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
13870 ptr
= contents
+ irel
->r_offset
;
13872 /* Read this BFD's local symbols if we haven't done so already. */
13873 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
13875 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
13876 if (isymbuf
== NULL
)
13877 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
13878 symtab_hdr
->sh_info
, 0,
13880 if (isymbuf
== NULL
)
13884 /* Get the value of the symbol referred to by the reloc. */
13885 if (r_symndx
< symtab_hdr
->sh_info
)
13887 /* A local symbol. */
13888 Elf_Internal_Sym
*isym
;
13891 isym
= isymbuf
+ r_symndx
;
13892 if (isym
->st_shndx
== SHN_UNDEF
)
13893 sym_sec
= bfd_und_section_ptr
;
13894 else if (isym
->st_shndx
== SHN_ABS
)
13895 sym_sec
= bfd_abs_section_ptr
;
13896 else if (isym
->st_shndx
== SHN_COMMON
)
13897 sym_sec
= bfd_com_section_ptr
;
13899 sym_sec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
13900 symval
= (isym
->st_value
13901 + sym_sec
->output_section
->vma
13902 + sym_sec
->output_offset
);
13903 target_is_micromips_code_p
= ELF_ST_IS_MICROMIPS (isym
->st_other
);
13907 unsigned long indx
;
13908 struct elf_link_hash_entry
*h
;
13910 /* An external symbol. */
13911 indx
= r_symndx
- symtab_hdr
->sh_info
;
13912 h
= elf_sym_hashes (abfd
)[indx
];
13913 BFD_ASSERT (h
!= NULL
);
13915 if (h
->root
.type
!= bfd_link_hash_defined
13916 && h
->root
.type
!= bfd_link_hash_defweak
)
13917 /* This appears to be a reference to an undefined
13918 symbol. Just ignore it -- it will be caught by the
13919 regular reloc processing. */
13922 symval
= (h
->root
.u
.def
.value
13923 + h
->root
.u
.def
.section
->output_section
->vma
13924 + h
->root
.u
.def
.section
->output_offset
);
13925 target_is_micromips_code_p
= (!h
->needs_plt
13926 && ELF_ST_IS_MICROMIPS (h
->other
));
13930 /* For simplicity of coding, we are going to modify the
13931 section contents, the section relocs, and the BFD symbol
13932 table. We must tell the rest of the code not to free up this
13933 information. It would be possible to instead create a table
13934 of changes which have to be made, as is done in coff-mips.c;
13935 that would be more work, but would require less memory when
13936 the linker is run. */
13938 /* Only 32-bit instructions relaxed. */
13939 if (irel
->r_offset
+ 4 > sec
->size
)
13942 opcode
= bfd_get_micromips_32 (abfd
, ptr
);
13944 /* This is the pc-relative distance from the instruction the
13945 relocation is applied to, to the symbol referred. */
13947 - (sec
->output_section
->vma
+ sec
->output_offset
)
13950 /* R_MICROMIPS_HI16 / LUI relaxation to nil, performing relaxation
13951 of corresponding R_MICROMIPS_LO16 to R_MICROMIPS_HI0_LO16 or
13952 R_MICROMIPS_PC23_S2. The R_MICROMIPS_PC23_S2 condition is
13954 (symval % 4 == 0 && IS_BITSIZE (pcrval, 25))
13956 where pcrval has first to be adjusted to apply against the LO16
13957 location (we make the adjustment later on, when we have figured
13958 out the offset). */
13959 if (r_type
== R_MICROMIPS_HI16
&& MATCH (opcode
, lui_insn
))
13961 bfd_boolean bzc
= FALSE
;
13962 unsigned long nextopc
;
13966 /* Give up if the previous reloc was a HI16 against this symbol
13968 if (irel
> internal_relocs
13969 && ELF32_R_TYPE (irel
[-1].r_info
) == R_MICROMIPS_HI16
13970 && ELF32_R_SYM (irel
[-1].r_info
) == r_symndx
)
13973 /* Or if the next reloc is not a LO16 against this symbol. */
13974 if (irel
+ 1 >= irelend
13975 || ELF32_R_TYPE (irel
[1].r_info
) != R_MICROMIPS_LO16
13976 || ELF32_R_SYM (irel
[1].r_info
) != r_symndx
)
13979 /* Or if the second next reloc is a LO16 against this symbol too. */
13980 if (irel
+ 2 >= irelend
13981 && ELF32_R_TYPE (irel
[2].r_info
) == R_MICROMIPS_LO16
13982 && ELF32_R_SYM (irel
[2].r_info
) == r_symndx
)
13985 /* See if the LUI instruction *might* be in a branch delay slot.
13986 We check whether what looks like a 16-bit branch or jump is
13987 actually an immediate argument to a compact branch, and let
13988 it through if so. */
13989 if (irel
->r_offset
>= 2
13990 && check_br16_dslot (abfd
, ptr
- 2)
13991 && !(irel
->r_offset
>= 4
13992 && (bzc
= check_relocated_bzc (abfd
,
13993 ptr
- 4, irel
->r_offset
- 4,
13994 internal_relocs
, irelend
))))
13996 if (irel
->r_offset
>= 4
13998 && check_br32_dslot (abfd
, ptr
- 4))
14001 reg
= OP32_SREG (opcode
);
14003 /* We only relax adjacent instructions or ones separated with
14004 a branch or jump that has a delay slot. The branch or jump
14005 must not fiddle with the register used to hold the address.
14006 Subtract 4 for the LUI itself. */
14007 offset
= irel
[1].r_offset
- irel
[0].r_offset
;
14008 switch (offset
- 4)
14013 if (check_br16 (abfd
, ptr
+ 4, reg
))
14017 if (check_br32 (abfd
, ptr
+ 4, reg
))
14024 nextopc
= bfd_get_micromips_32 (abfd
, contents
+ irel
[1].r_offset
);
14026 /* Give up unless the same register is used with both
14028 if (OP32_SREG (nextopc
) != reg
)
14031 /* Now adjust pcrval, subtracting the offset to the LO16 reloc
14032 and rounding up to take masking of the two LSBs into account. */
14033 pcrval
= ((pcrval
- offset
+ 3) | 3) ^ 3;
14035 /* R_MICROMIPS_LO16 relaxation to R_MICROMIPS_HI0_LO16. */
14036 if (IS_BITSIZE (symval
, 16))
14038 /* Fix the relocation's type. */
14039 irel
[1].r_info
= ELF32_R_INFO (r_symndx
, R_MICROMIPS_HI0_LO16
);
14041 /* Instructions using R_MICROMIPS_LO16 have the base or
14042 source register in bits 20:16. This register becomes $0
14043 (zero) as the result of the R_MICROMIPS_HI16 being 0. */
14044 nextopc
&= ~0x001f0000;
14045 bfd_put_16 (abfd
, (nextopc
>> 16) & 0xffff,
14046 contents
+ irel
[1].r_offset
);
14049 /* R_MICROMIPS_LO16 / ADDIU relaxation to R_MICROMIPS_PC23_S2.
14050 We add 4 to take LUI deletion into account while checking
14051 the PC-relative distance. */
14052 else if (symval
% 4 == 0
14053 && IS_BITSIZE (pcrval
+ 4, 25)
14054 && MATCH (nextopc
, addiu_insn
)
14055 && OP32_TREG (nextopc
) == OP32_SREG (nextopc
)
14056 && OP16_VALID_REG (OP32_TREG (nextopc
)))
14058 /* Fix the relocation's type. */
14059 irel
[1].r_info
= ELF32_R_INFO (r_symndx
, R_MICROMIPS_PC23_S2
);
14061 /* Replace ADDIU with the ADDIUPC version. */
14062 nextopc
= (addiupc_insn
.match
14063 | ADDIUPC_REG_FIELD (OP32_TREG (nextopc
)));
14065 bfd_put_micromips_32 (abfd
, nextopc
,
14066 contents
+ irel
[1].r_offset
);
14069 /* Can't do anything, give up, sigh... */
14073 /* Fix the relocation's type. */
14074 irel
->r_info
= ELF32_R_INFO (r_symndx
, R_MIPS_NONE
);
14076 /* Delete the LUI instruction: 4 bytes at irel->r_offset. */
14081 /* Compact branch relaxation -- due to the multitude of macros
14082 employed by the compiler/assembler, compact branches are not
14083 always generated. Obviously, this can/will be fixed elsewhere,
14084 but there is no drawback in double checking it here. */
14085 else if (r_type
== R_MICROMIPS_PC16_S1
14086 && irel
->r_offset
+ 5 < sec
->size
14087 && ((fndopc
= find_match (opcode
, bz_rs_insns_32
)) >= 0
14088 || (fndopc
= find_match (opcode
, bz_rt_insns_32
)) >= 0)
14090 && (delcnt
= MATCH (bfd_get_16 (abfd
, ptr
+ 4),
14091 nop_insn_16
) ? 2 : 0))
14092 || (irel
->r_offset
+ 7 < sec
->size
14093 && (delcnt
= MATCH (bfd_get_micromips_32 (abfd
,
14095 nop_insn_32
) ? 4 : 0))))
14099 reg
= OP32_SREG (opcode
) ? OP32_SREG (opcode
) : OP32_TREG (opcode
);
14101 /* Replace BEQZ/BNEZ with the compact version. */
14102 opcode
= (bzc_insns_32
[fndopc
].match
14103 | BZC32_REG_FIELD (reg
)
14104 | (opcode
& 0xffff)); /* Addend value. */
14106 bfd_put_micromips_32 (abfd
, opcode
, ptr
);
14108 /* Delete the delay slot NOP: two or four bytes from
14109 irel->offset + 4; delcnt has already been set above. */
14113 /* R_MICROMIPS_PC16_S1 relaxation to R_MICROMIPS_PC10_S1. We need
14114 to check the distance from the next instruction, so subtract 2. */
14116 && r_type
== R_MICROMIPS_PC16_S1
14117 && IS_BITSIZE (pcrval
- 2, 11)
14118 && find_match (opcode
, b_insns_32
) >= 0)
14120 /* Fix the relocation's type. */
14121 irel
->r_info
= ELF32_R_INFO (r_symndx
, R_MICROMIPS_PC10_S1
);
14123 /* Replace the 32-bit opcode with a 16-bit opcode. */
14126 | (opcode
& 0x3ff)), /* Addend value. */
14129 /* Delete 2 bytes from irel->r_offset + 2. */
14134 /* R_MICROMIPS_PC16_S1 relaxation to R_MICROMIPS_PC7_S1. We need
14135 to check the distance from the next instruction, so subtract 2. */
14137 && r_type
== R_MICROMIPS_PC16_S1
14138 && IS_BITSIZE (pcrval
- 2, 8)
14139 && (((fndopc
= find_match (opcode
, bz_rs_insns_32
)) >= 0
14140 && OP16_VALID_REG (OP32_SREG (opcode
)))
14141 || ((fndopc
= find_match (opcode
, bz_rt_insns_32
)) >= 0
14142 && OP16_VALID_REG (OP32_TREG (opcode
)))))
14146 reg
= OP32_SREG (opcode
) ? OP32_SREG (opcode
) : OP32_TREG (opcode
);
14148 /* Fix the relocation's type. */
14149 irel
->r_info
= ELF32_R_INFO (r_symndx
, R_MICROMIPS_PC7_S1
);
14151 /* Replace the 32-bit opcode with a 16-bit opcode. */
14153 (bz_insns_16
[fndopc
].match
14154 | BZ16_REG_FIELD (reg
)
14155 | (opcode
& 0x7f)), /* Addend value. */
14158 /* Delete 2 bytes from irel->r_offset + 2. */
14163 /* R_MICROMIPS_26_S1 -- JAL to JALS relaxation for microMIPS targets. */
14165 && r_type
== R_MICROMIPS_26_S1
14166 && target_is_micromips_code_p
14167 && irel
->r_offset
+ 7 < sec
->size
14168 && MATCH (opcode
, jal_insn_32_bd32
))
14170 unsigned long n32opc
;
14171 bfd_boolean relaxed
= FALSE
;
14173 n32opc
= bfd_get_micromips_32 (abfd
, ptr
+ 4);
14175 if (MATCH (n32opc
, nop_insn_32
))
14177 /* Replace delay slot 32-bit NOP with a 16-bit NOP. */
14178 bfd_put_16 (abfd
, nop_insn_16
.match
, ptr
+ 4);
14182 else if (find_match (n32opc
, move_insns_32
) >= 0)
14184 /* Replace delay slot 32-bit MOVE with 16-bit MOVE. */
14186 (move_insn_16
.match
14187 | MOVE16_RD_FIELD (MOVE32_RD (n32opc
))
14188 | MOVE16_RS_FIELD (MOVE32_RS (n32opc
))),
14193 /* Other 32-bit instructions relaxable to 16-bit
14194 instructions will be handled here later. */
14198 /* JAL with 32-bit delay slot that is changed to a JALS
14199 with 16-bit delay slot. */
14200 bfd_put_micromips_32 (abfd
, jal_insn_32_bd16
.match
, ptr
);
14202 /* Delete 2 bytes from irel->r_offset + 6. */
14210 /* Note that we've changed the relocs, section contents, etc. */
14211 elf_section_data (sec
)->relocs
= internal_relocs
;
14212 elf_section_data (sec
)->this_hdr
.contents
= contents
;
14213 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
14215 /* Delete bytes depending on the delcnt and deloff. */
14216 if (!mips_elf_relax_delete_bytes (abfd
, sec
,
14217 irel
->r_offset
+ deloff
, delcnt
))
14220 /* That will change things, so we should relax again.
14221 Note that this is not required, and it may be slow. */
14226 if (isymbuf
!= NULL
14227 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
14229 if (! link_info
->keep_memory
)
14233 /* Cache the symbols for elf_link_input_bfd. */
14234 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
14238 if (contents
!= NULL
14239 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
14241 if (! link_info
->keep_memory
)
14245 /* Cache the section contents for elf_link_input_bfd. */
14246 elf_section_data (sec
)->this_hdr
.contents
= contents
;
14250 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
14251 free (internal_relocs
);
14256 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
14258 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
14260 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
14261 free (internal_relocs
);
14266 /* Create a MIPS ELF linker hash table. */
14268 struct bfd_link_hash_table
*
14269 _bfd_mips_elf_link_hash_table_create (bfd
*abfd
)
14271 struct mips_elf_link_hash_table
*ret
;
14272 size_t amt
= sizeof (struct mips_elf_link_hash_table
);
14274 ret
= bfd_zmalloc (amt
);
14278 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
14279 mips_elf_link_hash_newfunc
,
14280 sizeof (struct mips_elf_link_hash_entry
),
14286 ret
->root
.init_plt_refcount
.plist
= NULL
;
14287 ret
->root
.init_plt_offset
.plist
= NULL
;
14289 return &ret
->root
.root
;
14292 /* Likewise, but indicate that the target is VxWorks. */
14294 struct bfd_link_hash_table
*
14295 _bfd_mips_vxworks_link_hash_table_create (bfd
*abfd
)
14297 struct bfd_link_hash_table
*ret
;
14299 ret
= _bfd_mips_elf_link_hash_table_create (abfd
);
14302 struct mips_elf_link_hash_table
*htab
;
14304 htab
= (struct mips_elf_link_hash_table
*) ret
;
14305 htab
->use_plts_and_copy_relocs
= TRUE
;
14306 htab
->is_vxworks
= TRUE
;
14311 /* A function that the linker calls if we are allowed to use PLTs
14312 and copy relocs. */
14315 _bfd_mips_elf_use_plts_and_copy_relocs (struct bfd_link_info
*info
)
14317 mips_elf_hash_table (info
)->use_plts_and_copy_relocs
= TRUE
;
14320 /* A function that the linker calls to select between all or only
14321 32-bit microMIPS instructions, and between making or ignoring
14322 branch relocation checks for invalid transitions between ISA modes.
14323 Also record whether we have been configured for a GNU target. */
14326 _bfd_mips_elf_linker_flags (struct bfd_link_info
*info
, bfd_boolean insn32
,
14327 bfd_boolean ignore_branch_isa
,
14328 bfd_boolean gnu_target
)
14330 mips_elf_hash_table (info
)->insn32
= insn32
;
14331 mips_elf_hash_table (info
)->ignore_branch_isa
= ignore_branch_isa
;
14332 mips_elf_hash_table (info
)->gnu_target
= gnu_target
;
14335 /* A function that the linker calls to enable use of compact branches in
14336 linker generated code for MIPSR6. */
14339 _bfd_mips_elf_compact_branches (struct bfd_link_info
*info
, bfd_boolean on
)
14341 mips_elf_hash_table (info
)->compact_branches
= on
;
14345 /* Structure for saying that BFD machine EXTENSION extends BASE. */
14347 struct mips_mach_extension
14349 unsigned long extension
, base
;
14353 /* An array describing how BFD machines relate to one another. The entries
14354 are ordered topologically with MIPS I extensions listed last. */
14356 static const struct mips_mach_extension mips_mach_extensions
[] =
14358 /* MIPS64r2 extensions. */
14359 { bfd_mach_mips_octeon3
, bfd_mach_mips_octeon2
},
14360 { bfd_mach_mips_octeon2
, bfd_mach_mips_octeonp
},
14361 { bfd_mach_mips_octeonp
, bfd_mach_mips_octeon
},
14362 { bfd_mach_mips_octeon
, bfd_mach_mipsisa64r2
},
14363 { bfd_mach_mips_gs264e
, bfd_mach_mips_gs464e
},
14364 { bfd_mach_mips_gs464e
, bfd_mach_mips_gs464
},
14365 { bfd_mach_mips_gs464
, bfd_mach_mipsisa64r2
},
14367 /* MIPS64 extensions. */
14368 { bfd_mach_mipsisa64r2
, bfd_mach_mipsisa64
},
14369 { bfd_mach_mips_sb1
, bfd_mach_mipsisa64
},
14370 { bfd_mach_mips_xlr
, bfd_mach_mipsisa64
},
14372 /* MIPS V extensions. */
14373 { bfd_mach_mipsisa64
, bfd_mach_mips5
},
14375 /* R10000 extensions. */
14376 { bfd_mach_mips12000
, bfd_mach_mips10000
},
14377 { bfd_mach_mips14000
, bfd_mach_mips10000
},
14378 { bfd_mach_mips16000
, bfd_mach_mips10000
},
14380 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
14381 vr5400 ISA, but doesn't include the multimedia stuff. It seems
14382 better to allow vr5400 and vr5500 code to be merged anyway, since
14383 many libraries will just use the core ISA. Perhaps we could add
14384 some sort of ASE flag if this ever proves a problem. */
14385 { bfd_mach_mips5500
, bfd_mach_mips5400
},
14386 { bfd_mach_mips5400
, bfd_mach_mips5000
},
14388 /* MIPS IV extensions. */
14389 { bfd_mach_mips5
, bfd_mach_mips8000
},
14390 { bfd_mach_mips10000
, bfd_mach_mips8000
},
14391 { bfd_mach_mips5000
, bfd_mach_mips8000
},
14392 { bfd_mach_mips7000
, bfd_mach_mips8000
},
14393 { bfd_mach_mips9000
, bfd_mach_mips8000
},
14395 /* VR4100 extensions. */
14396 { bfd_mach_mips4120
, bfd_mach_mips4100
},
14397 { bfd_mach_mips4111
, bfd_mach_mips4100
},
14399 /* MIPS III extensions. */
14400 { bfd_mach_mips_loongson_2e
, bfd_mach_mips4000
},
14401 { bfd_mach_mips_loongson_2f
, bfd_mach_mips4000
},
14402 { bfd_mach_mips8000
, bfd_mach_mips4000
},
14403 { bfd_mach_mips4650
, bfd_mach_mips4000
},
14404 { bfd_mach_mips4600
, bfd_mach_mips4000
},
14405 { bfd_mach_mips4400
, bfd_mach_mips4000
},
14406 { bfd_mach_mips4300
, bfd_mach_mips4000
},
14407 { bfd_mach_mips4100
, bfd_mach_mips4000
},
14408 { bfd_mach_mips5900
, bfd_mach_mips4000
},
14410 /* MIPS32r3 extensions. */
14411 { bfd_mach_mips_interaptiv_mr2
, bfd_mach_mipsisa32r3
},
14413 /* MIPS32r2 extensions. */
14414 { bfd_mach_mipsisa32r3
, bfd_mach_mipsisa32r2
},
14416 /* MIPS32 extensions. */
14417 { bfd_mach_mipsisa32r2
, bfd_mach_mipsisa32
},
14419 /* MIPS II extensions. */
14420 { bfd_mach_mips4000
, bfd_mach_mips6000
},
14421 { bfd_mach_mipsisa32
, bfd_mach_mips6000
},
14422 { bfd_mach_mips4010
, bfd_mach_mips6000
},
14424 /* MIPS I extensions. */
14425 { bfd_mach_mips6000
, bfd_mach_mips3000
},
14426 { bfd_mach_mips3900
, bfd_mach_mips3000
}
14429 /* Return true if bfd machine EXTENSION is an extension of machine BASE. */
14432 mips_mach_extends_p (unsigned long base
, unsigned long extension
)
14436 if (extension
== base
)
14439 if (base
== bfd_mach_mipsisa32
14440 && mips_mach_extends_p (bfd_mach_mipsisa64
, extension
))
14443 if (base
== bfd_mach_mipsisa32r2
14444 && mips_mach_extends_p (bfd_mach_mipsisa64r2
, extension
))
14447 for (i
= 0; i
< ARRAY_SIZE (mips_mach_extensions
); i
++)
14448 if (extension
== mips_mach_extensions
[i
].extension
)
14450 extension
= mips_mach_extensions
[i
].base
;
14451 if (extension
== base
)
14458 /* Return the BFD mach for each .MIPS.abiflags ISA Extension. */
14460 static unsigned long
14461 bfd_mips_isa_ext_mach (unsigned int isa_ext
)
14465 case AFL_EXT_3900
: return bfd_mach_mips3900
;
14466 case AFL_EXT_4010
: return bfd_mach_mips4010
;
14467 case AFL_EXT_4100
: return bfd_mach_mips4100
;
14468 case AFL_EXT_4111
: return bfd_mach_mips4111
;
14469 case AFL_EXT_4120
: return bfd_mach_mips4120
;
14470 case AFL_EXT_4650
: return bfd_mach_mips4650
;
14471 case AFL_EXT_5400
: return bfd_mach_mips5400
;
14472 case AFL_EXT_5500
: return bfd_mach_mips5500
;
14473 case AFL_EXT_5900
: return bfd_mach_mips5900
;
14474 case AFL_EXT_10000
: return bfd_mach_mips10000
;
14475 case AFL_EXT_LOONGSON_2E
: return bfd_mach_mips_loongson_2e
;
14476 case AFL_EXT_LOONGSON_2F
: return bfd_mach_mips_loongson_2f
;
14477 case AFL_EXT_SB1
: return bfd_mach_mips_sb1
;
14478 case AFL_EXT_OCTEON
: return bfd_mach_mips_octeon
;
14479 case AFL_EXT_OCTEONP
: return bfd_mach_mips_octeonp
;
14480 case AFL_EXT_OCTEON2
: return bfd_mach_mips_octeon2
;
14481 case AFL_EXT_XLR
: return bfd_mach_mips_xlr
;
14482 default: return bfd_mach_mips3000
;
14486 /* Return the .MIPS.abiflags value representing each ISA Extension. */
14489 bfd_mips_isa_ext (bfd
*abfd
)
14491 switch (bfd_get_mach (abfd
))
14493 case bfd_mach_mips3900
: return AFL_EXT_3900
;
14494 case bfd_mach_mips4010
: return AFL_EXT_4010
;
14495 case bfd_mach_mips4100
: return AFL_EXT_4100
;
14496 case bfd_mach_mips4111
: return AFL_EXT_4111
;
14497 case bfd_mach_mips4120
: return AFL_EXT_4120
;
14498 case bfd_mach_mips4650
: return AFL_EXT_4650
;
14499 case bfd_mach_mips5400
: return AFL_EXT_5400
;
14500 case bfd_mach_mips5500
: return AFL_EXT_5500
;
14501 case bfd_mach_mips5900
: return AFL_EXT_5900
;
14502 case bfd_mach_mips10000
: return AFL_EXT_10000
;
14503 case bfd_mach_mips_loongson_2e
: return AFL_EXT_LOONGSON_2E
;
14504 case bfd_mach_mips_loongson_2f
: return AFL_EXT_LOONGSON_2F
;
14505 case bfd_mach_mips_sb1
: return AFL_EXT_SB1
;
14506 case bfd_mach_mips_octeon
: return AFL_EXT_OCTEON
;
14507 case bfd_mach_mips_octeonp
: return AFL_EXT_OCTEONP
;
14508 case bfd_mach_mips_octeon3
: return AFL_EXT_OCTEON3
;
14509 case bfd_mach_mips_octeon2
: return AFL_EXT_OCTEON2
;
14510 case bfd_mach_mips_xlr
: return AFL_EXT_XLR
;
14511 case bfd_mach_mips_interaptiv_mr2
:
14512 return AFL_EXT_INTERAPTIV_MR2
;
14517 /* Encode ISA level and revision as a single value. */
14518 #define LEVEL_REV(LEV,REV) ((LEV) << 3 | (REV))
14520 /* Decode a single value into level and revision. */
14521 #define ISA_LEVEL(LEVREV) ((LEVREV) >> 3)
14522 #define ISA_REV(LEVREV) ((LEVREV) & 0x7)
14524 /* Update the isa_level, isa_rev, isa_ext fields of abiflags. */
14527 update_mips_abiflags_isa (bfd
*abfd
, Elf_Internal_ABIFlags_v0
*abiflags
)
14530 switch (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
)
14532 case E_MIPS_ARCH_1
: new_isa
= LEVEL_REV (1, 0); break;
14533 case E_MIPS_ARCH_2
: new_isa
= LEVEL_REV (2, 0); break;
14534 case E_MIPS_ARCH_3
: new_isa
= LEVEL_REV (3, 0); break;
14535 case E_MIPS_ARCH_4
: new_isa
= LEVEL_REV (4, 0); break;
14536 case E_MIPS_ARCH_5
: new_isa
= LEVEL_REV (5, 0); break;
14537 case E_MIPS_ARCH_32
: new_isa
= LEVEL_REV (32, 1); break;
14538 case E_MIPS_ARCH_32R2
: new_isa
= LEVEL_REV (32, 2); break;
14539 case E_MIPS_ARCH_32R6
: new_isa
= LEVEL_REV (32, 6); break;
14540 case E_MIPS_ARCH_64
: new_isa
= LEVEL_REV (64, 1); break;
14541 case E_MIPS_ARCH_64R2
: new_isa
= LEVEL_REV (64, 2); break;
14542 case E_MIPS_ARCH_64R6
: new_isa
= LEVEL_REV (64, 6); break;
14545 /* xgettext:c-format */
14546 (_("%pB: unknown architecture %s"),
14547 abfd
, bfd_printable_name (abfd
));
14550 if (new_isa
> LEVEL_REV (abiflags
->isa_level
, abiflags
->isa_rev
))
14552 abiflags
->isa_level
= ISA_LEVEL (new_isa
);
14553 abiflags
->isa_rev
= ISA_REV (new_isa
);
14556 /* Update the isa_ext if ABFD describes a further extension. */
14557 if (mips_mach_extends_p (bfd_mips_isa_ext_mach (abiflags
->isa_ext
),
14558 bfd_get_mach (abfd
)))
14559 abiflags
->isa_ext
= bfd_mips_isa_ext (abfd
);
14562 /* Return true if the given ELF header flags describe a 32-bit binary. */
14565 mips_32bit_flags_p (flagword flags
)
14567 return ((flags
& EF_MIPS_32BITMODE
) != 0
14568 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
14569 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
14570 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
14571 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
14572 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
14573 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
14574 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R6
);
14577 /* Infer the content of the ABI flags based on the elf header. */
14580 infer_mips_abiflags (bfd
*abfd
, Elf_Internal_ABIFlags_v0
* abiflags
)
14582 obj_attribute
*in_attr
;
14584 memset (abiflags
, 0, sizeof (Elf_Internal_ABIFlags_v0
));
14585 update_mips_abiflags_isa (abfd
, abiflags
);
14587 if (mips_32bit_flags_p (elf_elfheader (abfd
)->e_flags
))
14588 abiflags
->gpr_size
= AFL_REG_32
;
14590 abiflags
->gpr_size
= AFL_REG_64
;
14592 abiflags
->cpr1_size
= AFL_REG_NONE
;
14594 in_attr
= elf_known_obj_attributes (abfd
)[OBJ_ATTR_GNU
];
14595 abiflags
->fp_abi
= in_attr
[Tag_GNU_MIPS_ABI_FP
].i
;
14597 if (abiflags
->fp_abi
== Val_GNU_MIPS_ABI_FP_SINGLE
14598 || abiflags
->fp_abi
== Val_GNU_MIPS_ABI_FP_XX
14599 || (abiflags
->fp_abi
== Val_GNU_MIPS_ABI_FP_DOUBLE
14600 && abiflags
->gpr_size
== AFL_REG_32
))
14601 abiflags
->cpr1_size
= AFL_REG_32
;
14602 else if (abiflags
->fp_abi
== Val_GNU_MIPS_ABI_FP_DOUBLE
14603 || abiflags
->fp_abi
== Val_GNU_MIPS_ABI_FP_64
14604 || abiflags
->fp_abi
== Val_GNU_MIPS_ABI_FP_64A
)
14605 abiflags
->cpr1_size
= AFL_REG_64
;
14607 abiflags
->cpr2_size
= AFL_REG_NONE
;
14609 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
14610 abiflags
->ases
|= AFL_ASE_MDMX
;
14611 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_M16
)
14612 abiflags
->ases
|= AFL_ASE_MIPS16
;
14613 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
14614 abiflags
->ases
|= AFL_ASE_MICROMIPS
;
14616 if (abiflags
->fp_abi
!= Val_GNU_MIPS_ABI_FP_ANY
14617 && abiflags
->fp_abi
!= Val_GNU_MIPS_ABI_FP_SOFT
14618 && abiflags
->fp_abi
!= Val_GNU_MIPS_ABI_FP_64A
14619 && abiflags
->isa_level
>= 32
14620 && abiflags
->ases
!= AFL_ASE_LOONGSON_EXT
)
14621 abiflags
->flags1
|= AFL_FLAGS1_ODDSPREG
;
14624 /* We need to use a special link routine to handle the .reginfo and
14625 the .mdebug sections. We need to merge all instances of these
14626 sections together, not write them all out sequentially. */
14629 _bfd_mips_elf_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
14632 struct bfd_link_order
*p
;
14633 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
14634 asection
*rtproc_sec
, *abiflags_sec
;
14635 Elf32_RegInfo reginfo
;
14636 struct ecoff_debug_info debug
;
14637 struct mips_htab_traverse_info hti
;
14638 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
14639 const struct ecoff_debug_swap
*swap
= bed
->elf_backend_ecoff_debug_swap
;
14640 HDRR
*symhdr
= &debug
.symbolic_header
;
14641 void *mdebug_handle
= NULL
;
14646 struct mips_elf_link_hash_table
*htab
;
14648 static const char * const secname
[] =
14650 ".text", ".init", ".fini", ".data",
14651 ".rodata", ".sdata", ".sbss", ".bss"
14653 static const int sc
[] =
14655 scText
, scInit
, scFini
, scData
,
14656 scRData
, scSData
, scSBss
, scBss
14659 htab
= mips_elf_hash_table (info
);
14660 BFD_ASSERT (htab
!= NULL
);
14662 /* Sort the dynamic symbols so that those with GOT entries come after
14664 if (!mips_elf_sort_hash_table (abfd
, info
))
14667 /* Create any scheduled LA25 stubs. */
14669 hti
.output_bfd
= abfd
;
14671 htab_traverse (htab
->la25_stubs
, mips_elf_create_la25_stub
, &hti
);
14675 /* Get a value for the GP register. */
14676 if (elf_gp (abfd
) == 0)
14678 struct bfd_link_hash_entry
*h
;
14680 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
14681 if (h
!= NULL
&& h
->type
== bfd_link_hash_defined
)
14682 elf_gp (abfd
) = (h
->u
.def
.value
14683 + h
->u
.def
.section
->output_section
->vma
14684 + h
->u
.def
.section
->output_offset
);
14685 else if (htab
->is_vxworks
14686 && (h
= bfd_link_hash_lookup (info
->hash
,
14687 "_GLOBAL_OFFSET_TABLE_",
14688 FALSE
, FALSE
, TRUE
))
14689 && h
->type
== bfd_link_hash_defined
)
14690 elf_gp (abfd
) = (h
->u
.def
.section
->output_section
->vma
14691 + h
->u
.def
.section
->output_offset
14693 else if (bfd_link_relocatable (info
))
14695 bfd_vma lo
= MINUS_ONE
;
14697 /* Find the GP-relative section with the lowest offset. */
14698 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
14700 && (elf_section_data (o
)->this_hdr
.sh_flags
& SHF_MIPS_GPREL
))
14703 /* And calculate GP relative to that. */
14704 elf_gp (abfd
) = lo
+ ELF_MIPS_GP_OFFSET (info
);
14708 /* If the relocate_section function needs to do a reloc
14709 involving the GP value, it should make a reloc_dangerous
14710 callback to warn that GP is not defined. */
14714 /* Go through the sections and collect the .reginfo and .mdebug
14716 abiflags_sec
= NULL
;
14717 reginfo_sec
= NULL
;
14719 gptab_data_sec
= NULL
;
14720 gptab_bss_sec
= NULL
;
14721 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
14723 if (strcmp (o
->name
, ".MIPS.abiflags") == 0)
14725 /* We have found the .MIPS.abiflags section in the output file.
14726 Look through all the link_orders comprising it and remove them.
14727 The data is merged in _bfd_mips_elf_merge_private_bfd_data. */
14728 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
14730 asection
*input_section
;
14732 if (p
->type
!= bfd_indirect_link_order
)
14734 if (p
->type
== bfd_data_link_order
)
14739 input_section
= p
->u
.indirect
.section
;
14741 /* Hack: reset the SEC_HAS_CONTENTS flag so that
14742 elf_link_input_bfd ignores this section. */
14743 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
14746 /* Size has been set in _bfd_mips_elf_always_size_sections. */
14747 BFD_ASSERT(o
->size
== sizeof (Elf_External_ABIFlags_v0
));
14749 /* Skip this section later on (I don't think this currently
14750 matters, but someday it might). */
14751 o
->map_head
.link_order
= NULL
;
14756 if (strcmp (o
->name
, ".reginfo") == 0)
14758 memset (®info
, 0, sizeof reginfo
);
14760 /* We have found the .reginfo section in the output file.
14761 Look through all the link_orders comprising it and merge
14762 the information together. */
14763 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
14765 asection
*input_section
;
14767 Elf32_External_RegInfo ext
;
14771 if (p
->type
!= bfd_indirect_link_order
)
14773 if (p
->type
== bfd_data_link_order
)
14778 input_section
= p
->u
.indirect
.section
;
14779 input_bfd
= input_section
->owner
;
14781 sz
= (input_section
->size
< sizeof (ext
)
14782 ? input_section
->size
: sizeof (ext
));
14783 memset (&ext
, 0, sizeof (ext
));
14784 if (! bfd_get_section_contents (input_bfd
, input_section
,
14788 bfd_mips_elf32_swap_reginfo_in (input_bfd
, &ext
, &sub
);
14790 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
14791 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
14792 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
14793 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
14794 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
14796 /* ri_gp_value is set by the function
14797 `_bfd_mips_elf_section_processing' when the section is
14798 finally written out. */
14800 /* Hack: reset the SEC_HAS_CONTENTS flag so that
14801 elf_link_input_bfd ignores this section. */
14802 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
14805 /* Size has been set in _bfd_mips_elf_always_size_sections. */
14806 BFD_ASSERT(o
->size
== sizeof (Elf32_External_RegInfo
));
14808 /* Skip this section later on (I don't think this currently
14809 matters, but someday it might). */
14810 o
->map_head
.link_order
= NULL
;
14815 if (strcmp (o
->name
, ".mdebug") == 0)
14817 struct extsym_info einfo
;
14820 /* We have found the .mdebug section in the output file.
14821 Look through all the link_orders comprising it and merge
14822 the information together. */
14823 symhdr
->magic
= swap
->sym_magic
;
14824 /* FIXME: What should the version stamp be? */
14825 symhdr
->vstamp
= 0;
14826 symhdr
->ilineMax
= 0;
14827 symhdr
->cbLine
= 0;
14828 symhdr
->idnMax
= 0;
14829 symhdr
->ipdMax
= 0;
14830 symhdr
->isymMax
= 0;
14831 symhdr
->ioptMax
= 0;
14832 symhdr
->iauxMax
= 0;
14833 symhdr
->issMax
= 0;
14834 symhdr
->issExtMax
= 0;
14835 symhdr
->ifdMax
= 0;
14837 symhdr
->iextMax
= 0;
14839 /* We accumulate the debugging information itself in the
14840 debug_info structure. */
14842 debug
.external_dnr
= NULL
;
14843 debug
.external_pdr
= NULL
;
14844 debug
.external_sym
= NULL
;
14845 debug
.external_opt
= NULL
;
14846 debug
.external_aux
= NULL
;
14848 debug
.ssext
= debug
.ssext_end
= NULL
;
14849 debug
.external_fdr
= NULL
;
14850 debug
.external_rfd
= NULL
;
14851 debug
.external_ext
= debug
.external_ext_end
= NULL
;
14853 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
14854 if (mdebug_handle
== NULL
)
14858 esym
.cobol_main
= 0;
14862 esym
.asym
.iss
= issNil
;
14863 esym
.asym
.st
= stLocal
;
14864 esym
.asym
.reserved
= 0;
14865 esym
.asym
.index
= indexNil
;
14867 for (i
= 0; i
< sizeof (secname
) / sizeof (secname
[0]); i
++)
14869 esym
.asym
.sc
= sc
[i
];
14870 s
= bfd_get_section_by_name (abfd
, secname
[i
]);
14873 esym
.asym
.value
= s
->vma
;
14874 last
= s
->vma
+ s
->size
;
14877 esym
.asym
.value
= last
;
14878 if (!bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
14879 secname
[i
], &esym
))
14883 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
14885 asection
*input_section
;
14887 const struct ecoff_debug_swap
*input_swap
;
14888 struct ecoff_debug_info input_debug
;
14892 if (p
->type
!= bfd_indirect_link_order
)
14894 if (p
->type
== bfd_data_link_order
)
14899 input_section
= p
->u
.indirect
.section
;
14900 input_bfd
= input_section
->owner
;
14902 if (!is_mips_elf (input_bfd
))
14904 /* I don't know what a non MIPS ELF bfd would be
14905 doing with a .mdebug section, but I don't really
14906 want to deal with it. */
14910 input_swap
= (get_elf_backend_data (input_bfd
)
14911 ->elf_backend_ecoff_debug_swap
);
14913 BFD_ASSERT (p
->size
== input_section
->size
);
14915 /* The ECOFF linking code expects that we have already
14916 read in the debugging information and set up an
14917 ecoff_debug_info structure, so we do that now. */
14918 if (! _bfd_mips_elf_read_ecoff_info (input_bfd
, input_section
,
14922 if (! (bfd_ecoff_debug_accumulate
14923 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
14924 &input_debug
, input_swap
, info
)))
14927 /* Loop through the external symbols. For each one with
14928 interesting information, try to find the symbol in
14929 the linker global hash table and save the information
14930 for the output external symbols. */
14931 eraw_src
= input_debug
.external_ext
;
14932 eraw_end
= (eraw_src
14933 + (input_debug
.symbolic_header
.iextMax
14934 * input_swap
->external_ext_size
));
14936 eraw_src
< eraw_end
;
14937 eraw_src
+= input_swap
->external_ext_size
)
14941 struct mips_elf_link_hash_entry
*h
;
14943 (*input_swap
->swap_ext_in
) (input_bfd
, eraw_src
, &ext
);
14944 if (ext
.asym
.sc
== scNil
14945 || ext
.asym
.sc
== scUndefined
14946 || ext
.asym
.sc
== scSUndefined
)
14949 name
= input_debug
.ssext
+ ext
.asym
.iss
;
14950 h
= mips_elf_link_hash_lookup (mips_elf_hash_table (info
),
14951 name
, FALSE
, FALSE
, TRUE
);
14952 if (h
== NULL
|| h
->esym
.ifd
!= -2)
14957 BFD_ASSERT (ext
.ifd
14958 < input_debug
.symbolic_header
.ifdMax
);
14959 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
14965 /* Free up the information we just read. */
14966 free (input_debug
.line
);
14967 free (input_debug
.external_dnr
);
14968 free (input_debug
.external_pdr
);
14969 free (input_debug
.external_sym
);
14970 free (input_debug
.external_opt
);
14971 free (input_debug
.external_aux
);
14972 free (input_debug
.ss
);
14973 free (input_debug
.ssext
);
14974 free (input_debug
.external_fdr
);
14975 free (input_debug
.external_rfd
);
14976 free (input_debug
.external_ext
);
14978 /* Hack: reset the SEC_HAS_CONTENTS flag so that
14979 elf_link_input_bfd ignores this section. */
14980 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
14983 if (SGI_COMPAT (abfd
) && bfd_link_pic (info
))
14985 /* Create .rtproc section. */
14986 rtproc_sec
= bfd_get_linker_section (abfd
, ".rtproc");
14987 if (rtproc_sec
== NULL
)
14989 flagword flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
14990 | SEC_LINKER_CREATED
| SEC_READONLY
);
14992 rtproc_sec
= bfd_make_section_anyway_with_flags (abfd
,
14995 if (rtproc_sec
== NULL
14996 || !bfd_set_section_alignment (rtproc_sec
, 4))
15000 if (! mips_elf_create_procedure_table (mdebug_handle
, abfd
,
15006 /* Build the external symbol information. */
15009 einfo
.debug
= &debug
;
15011 einfo
.failed
= FALSE
;
15012 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
15013 mips_elf_output_extsym
, &einfo
);
15017 /* Set the size of the .mdebug section. */
15018 o
->size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
15020 /* Skip this section later on (I don't think this currently
15021 matters, but someday it might). */
15022 o
->map_head
.link_order
= NULL
;
15027 if (CONST_STRNEQ (o
->name
, ".gptab."))
15029 const char *subname
;
15032 Elf32_External_gptab
*ext_tab
;
15035 /* The .gptab.sdata and .gptab.sbss sections hold
15036 information describing how the small data area would
15037 change depending upon the -G switch. These sections
15038 not used in executables files. */
15039 if (! bfd_link_relocatable (info
))
15041 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
15043 asection
*input_section
;
15045 if (p
->type
!= bfd_indirect_link_order
)
15047 if (p
->type
== bfd_data_link_order
)
15052 input_section
= p
->u
.indirect
.section
;
15054 /* Hack: reset the SEC_HAS_CONTENTS flag so that
15055 elf_link_input_bfd ignores this section. */
15056 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
15059 /* Skip this section later on (I don't think this
15060 currently matters, but someday it might). */
15061 o
->map_head
.link_order
= NULL
;
15063 /* Really remove the section. */
15064 bfd_section_list_remove (abfd
, o
);
15065 --abfd
->section_count
;
15070 /* There is one gptab for initialized data, and one for
15071 uninitialized data. */
15072 if (strcmp (o
->name
, ".gptab.sdata") == 0)
15073 gptab_data_sec
= o
;
15074 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
15079 /* xgettext:c-format */
15080 (_("%pB: illegal section name `%pA'"), abfd
, o
);
15081 bfd_set_error (bfd_error_nonrepresentable_section
);
15085 /* The linker script always combines .gptab.data and
15086 .gptab.sdata into .gptab.sdata, and likewise for
15087 .gptab.bss and .gptab.sbss. It is possible that there is
15088 no .sdata or .sbss section in the output file, in which
15089 case we must change the name of the output section. */
15090 subname
= o
->name
+ sizeof ".gptab" - 1;
15091 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
15093 if (o
== gptab_data_sec
)
15094 o
->name
= ".gptab.data";
15096 o
->name
= ".gptab.bss";
15097 subname
= o
->name
+ sizeof ".gptab" - 1;
15098 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
15101 /* Set up the first entry. */
15103 amt
= c
* sizeof (Elf32_gptab
);
15104 tab
= bfd_malloc (amt
);
15107 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
15108 tab
[0].gt_header
.gt_unused
= 0;
15110 /* Combine the input sections. */
15111 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
15113 asection
*input_section
;
15115 bfd_size_type size
;
15116 unsigned long last
;
15117 bfd_size_type gpentry
;
15119 if (p
->type
!= bfd_indirect_link_order
)
15121 if (p
->type
== bfd_data_link_order
)
15126 input_section
= p
->u
.indirect
.section
;
15127 input_bfd
= input_section
->owner
;
15129 /* Combine the gptab entries for this input section one
15130 by one. We know that the input gptab entries are
15131 sorted by ascending -G value. */
15132 size
= input_section
->size
;
15134 for (gpentry
= sizeof (Elf32_External_gptab
);
15136 gpentry
+= sizeof (Elf32_External_gptab
))
15138 Elf32_External_gptab ext_gptab
;
15139 Elf32_gptab int_gptab
;
15145 if (! (bfd_get_section_contents
15146 (input_bfd
, input_section
, &ext_gptab
, gpentry
,
15147 sizeof (Elf32_External_gptab
))))
15153 bfd_mips_elf32_swap_gptab_in (input_bfd
, &ext_gptab
,
15155 val
= int_gptab
.gt_entry
.gt_g_value
;
15156 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
15159 for (look
= 1; look
< c
; look
++)
15161 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
15162 tab
[look
].gt_entry
.gt_bytes
+= add
;
15164 if (tab
[look
].gt_entry
.gt_g_value
== val
)
15170 Elf32_gptab
*new_tab
;
15173 /* We need a new table entry. */
15174 amt
= (bfd_size_type
) (c
+ 1) * sizeof (Elf32_gptab
);
15175 new_tab
= bfd_realloc (tab
, amt
);
15176 if (new_tab
== NULL
)
15182 tab
[c
].gt_entry
.gt_g_value
= val
;
15183 tab
[c
].gt_entry
.gt_bytes
= add
;
15185 /* Merge in the size for the next smallest -G
15186 value, since that will be implied by this new
15189 for (look
= 1; look
< c
; look
++)
15191 if (tab
[look
].gt_entry
.gt_g_value
< val
15193 || (tab
[look
].gt_entry
.gt_g_value
15194 > tab
[max
].gt_entry
.gt_g_value
)))
15198 tab
[c
].gt_entry
.gt_bytes
+=
15199 tab
[max
].gt_entry
.gt_bytes
;
15204 last
= int_gptab
.gt_entry
.gt_bytes
;
15207 /* Hack: reset the SEC_HAS_CONTENTS flag so that
15208 elf_link_input_bfd ignores this section. */
15209 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
15212 /* The table must be sorted by -G value. */
15214 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
15216 /* Swap out the table. */
15217 amt
= (bfd_size_type
) c
* sizeof (Elf32_External_gptab
);
15218 ext_tab
= bfd_alloc (abfd
, amt
);
15219 if (ext_tab
== NULL
)
15225 for (j
= 0; j
< c
; j
++)
15226 bfd_mips_elf32_swap_gptab_out (abfd
, tab
+ j
, ext_tab
+ j
);
15229 o
->size
= c
* sizeof (Elf32_External_gptab
);
15230 o
->contents
= (bfd_byte
*) ext_tab
;
15232 /* Skip this section later on (I don't think this currently
15233 matters, but someday it might). */
15234 o
->map_head
.link_order
= NULL
;
15238 /* Invoke the regular ELF backend linker to do all the work. */
15239 if (!bfd_elf_final_link (abfd
, info
))
15242 /* Now write out the computed sections. */
15244 if (abiflags_sec
!= NULL
)
15246 Elf_External_ABIFlags_v0 ext
;
15247 Elf_Internal_ABIFlags_v0
*abiflags
;
15249 abiflags
= &mips_elf_tdata (abfd
)->abiflags
;
15251 /* Set up the abiflags if no valid input sections were found. */
15252 if (!mips_elf_tdata (abfd
)->abiflags_valid
)
15254 infer_mips_abiflags (abfd
, abiflags
);
15255 mips_elf_tdata (abfd
)->abiflags_valid
= TRUE
;
15257 bfd_mips_elf_swap_abiflags_v0_out (abfd
, abiflags
, &ext
);
15258 if (! bfd_set_section_contents (abfd
, abiflags_sec
, &ext
, 0, sizeof ext
))
15262 if (reginfo_sec
!= NULL
)
15264 Elf32_External_RegInfo ext
;
15266 bfd_mips_elf32_swap_reginfo_out (abfd
, ®info
, &ext
);
15267 if (! bfd_set_section_contents (abfd
, reginfo_sec
, &ext
, 0, sizeof ext
))
15271 if (mdebug_sec
!= NULL
)
15273 BFD_ASSERT (abfd
->output_has_begun
);
15274 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
15276 mdebug_sec
->filepos
))
15279 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
15282 if (gptab_data_sec
!= NULL
)
15284 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
15285 gptab_data_sec
->contents
,
15286 0, gptab_data_sec
->size
))
15290 if (gptab_bss_sec
!= NULL
)
15292 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
15293 gptab_bss_sec
->contents
,
15294 0, gptab_bss_sec
->size
))
15298 if (SGI_COMPAT (abfd
))
15300 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
15301 if (rtproc_sec
!= NULL
)
15303 if (! bfd_set_section_contents (abfd
, rtproc_sec
,
15304 rtproc_sec
->contents
,
15305 0, rtproc_sec
->size
))
15313 /* Merge object file header flags from IBFD into OBFD. Raise an error
15314 if there are conflicting settings. */
15317 mips_elf_merge_obj_e_flags (bfd
*ibfd
, struct bfd_link_info
*info
)
15319 bfd
*obfd
= info
->output_bfd
;
15320 struct mips_elf_obj_tdata
*out_tdata
= mips_elf_tdata (obfd
);
15321 flagword old_flags
;
15322 flagword new_flags
;
15325 new_flags
= elf_elfheader (ibfd
)->e_flags
;
15326 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_NOREORDER
;
15327 old_flags
= elf_elfheader (obfd
)->e_flags
;
15329 /* Check flag compatibility. */
15331 new_flags
&= ~EF_MIPS_NOREORDER
;
15332 old_flags
&= ~EF_MIPS_NOREORDER
;
15334 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
15335 doesn't seem to matter. */
15336 new_flags
&= ~EF_MIPS_XGOT
;
15337 old_flags
&= ~EF_MIPS_XGOT
;
15339 /* MIPSpro generates ucode info in n64 objects. Again, we should
15340 just be able to ignore this. */
15341 new_flags
&= ~EF_MIPS_UCODE
;
15342 old_flags
&= ~EF_MIPS_UCODE
;
15344 /* DSOs should only be linked with CPIC code. */
15345 if ((ibfd
->flags
& DYNAMIC
) != 0)
15346 new_flags
|= EF_MIPS_PIC
| EF_MIPS_CPIC
;
15348 if (new_flags
== old_flags
)
15353 if (((new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0)
15354 != ((old_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0))
15357 (_("%pB: warning: linking abicalls files with non-abicalls files"),
15362 if (new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
))
15363 elf_elfheader (obfd
)->e_flags
|= EF_MIPS_CPIC
;
15364 if (! (new_flags
& EF_MIPS_PIC
))
15365 elf_elfheader (obfd
)->e_flags
&= ~EF_MIPS_PIC
;
15367 new_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
15368 old_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
15370 /* Compare the ISAs. */
15371 if (mips_32bit_flags_p (old_flags
) != mips_32bit_flags_p (new_flags
))
15374 (_("%pB: linking 32-bit code with 64-bit code"),
15378 else if (!mips_mach_extends_p (bfd_get_mach (ibfd
), bfd_get_mach (obfd
)))
15380 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
15381 if (mips_mach_extends_p (bfd_get_mach (obfd
), bfd_get_mach (ibfd
)))
15383 /* Copy the architecture info from IBFD to OBFD. Also copy
15384 the 32-bit flag (if set) so that we continue to recognise
15385 OBFD as a 32-bit binary. */
15386 bfd_set_arch_info (obfd
, bfd_get_arch_info (ibfd
));
15387 elf_elfheader (obfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
15388 elf_elfheader (obfd
)->e_flags
15389 |= new_flags
& (EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
15391 /* Update the ABI flags isa_level, isa_rev, isa_ext fields. */
15392 update_mips_abiflags_isa (obfd
, &out_tdata
->abiflags
);
15394 /* Copy across the ABI flags if OBFD doesn't use them
15395 and if that was what caused us to treat IBFD as 32-bit. */
15396 if ((old_flags
& EF_MIPS_ABI
) == 0
15397 && mips_32bit_flags_p (new_flags
)
15398 && !mips_32bit_flags_p (new_flags
& ~EF_MIPS_ABI
))
15399 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ABI
;
15403 /* The ISAs aren't compatible. */
15405 /* xgettext:c-format */
15406 (_("%pB: linking %s module with previous %s modules"),
15408 bfd_printable_name (ibfd
),
15409 bfd_printable_name (obfd
));
15414 new_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
15415 old_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
15417 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
15418 does set EI_CLASS differently from any 32-bit ABI. */
15419 if ((new_flags
& EF_MIPS_ABI
) != (old_flags
& EF_MIPS_ABI
)
15420 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
15421 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
15423 /* Only error if both are set (to different values). */
15424 if (((new_flags
& EF_MIPS_ABI
) && (old_flags
& EF_MIPS_ABI
))
15425 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
15426 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
15429 /* xgettext:c-format */
15430 (_("%pB: ABI mismatch: linking %s module with previous %s modules"),
15432 elf_mips_abi_name (ibfd
),
15433 elf_mips_abi_name (obfd
));
15436 new_flags
&= ~EF_MIPS_ABI
;
15437 old_flags
&= ~EF_MIPS_ABI
;
15440 /* Compare ASEs. Forbid linking MIPS16 and microMIPS ASE modules together
15441 and allow arbitrary mixing of the remaining ASEs (retain the union). */
15442 if ((new_flags
& EF_MIPS_ARCH_ASE
) != (old_flags
& EF_MIPS_ARCH_ASE
))
15444 int old_micro
= old_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
;
15445 int new_micro
= new_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
;
15446 int old_m16
= old_flags
& EF_MIPS_ARCH_ASE_M16
;
15447 int new_m16
= new_flags
& EF_MIPS_ARCH_ASE_M16
;
15448 int micro_mis
= old_m16
&& new_micro
;
15449 int m16_mis
= old_micro
&& new_m16
;
15451 if (m16_mis
|| micro_mis
)
15454 /* xgettext:c-format */
15455 (_("%pB: ASE mismatch: linking %s module with previous %s modules"),
15457 m16_mis
? "MIPS16" : "microMIPS",
15458 m16_mis
? "microMIPS" : "MIPS16");
15462 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ARCH_ASE
;
15464 new_flags
&= ~ EF_MIPS_ARCH_ASE
;
15465 old_flags
&= ~ EF_MIPS_ARCH_ASE
;
15468 /* Compare NaN encodings. */
15469 if ((new_flags
& EF_MIPS_NAN2008
) != (old_flags
& EF_MIPS_NAN2008
))
15471 /* xgettext:c-format */
15472 _bfd_error_handler (_("%pB: linking %s module with previous %s modules"),
15474 (new_flags
& EF_MIPS_NAN2008
15475 ? "-mnan=2008" : "-mnan=legacy"),
15476 (old_flags
& EF_MIPS_NAN2008
15477 ? "-mnan=2008" : "-mnan=legacy"));
15479 new_flags
&= ~EF_MIPS_NAN2008
;
15480 old_flags
&= ~EF_MIPS_NAN2008
;
15483 /* Compare FP64 state. */
15484 if ((new_flags
& EF_MIPS_FP64
) != (old_flags
& EF_MIPS_FP64
))
15486 /* xgettext:c-format */
15487 _bfd_error_handler (_("%pB: linking %s module with previous %s modules"),
15489 (new_flags
& EF_MIPS_FP64
15490 ? "-mfp64" : "-mfp32"),
15491 (old_flags
& EF_MIPS_FP64
15492 ? "-mfp64" : "-mfp32"));
15494 new_flags
&= ~EF_MIPS_FP64
;
15495 old_flags
&= ~EF_MIPS_FP64
;
15498 /* Warn about any other mismatches */
15499 if (new_flags
!= old_flags
)
15501 /* xgettext:c-format */
15503 (_("%pB: uses different e_flags (%#x) fields than previous modules "
15505 ibfd
, new_flags
, old_flags
);
15512 /* Merge object attributes from IBFD into OBFD. Raise an error if
15513 there are conflicting attributes. */
15515 mips_elf_merge_obj_attributes (bfd
*ibfd
, struct bfd_link_info
*info
)
15517 bfd
*obfd
= info
->output_bfd
;
15518 obj_attribute
*in_attr
;
15519 obj_attribute
*out_attr
;
15523 abi_fp_bfd
= mips_elf_tdata (obfd
)->abi_fp_bfd
;
15524 in_attr
= elf_known_obj_attributes (ibfd
)[OBJ_ATTR_GNU
];
15525 if (!abi_fp_bfd
&& in_attr
[Tag_GNU_MIPS_ABI_FP
].i
!= Val_GNU_MIPS_ABI_FP_ANY
)
15526 mips_elf_tdata (obfd
)->abi_fp_bfd
= ibfd
;
15528 abi_msa_bfd
= mips_elf_tdata (obfd
)->abi_msa_bfd
;
15530 && in_attr
[Tag_GNU_MIPS_ABI_MSA
].i
!= Val_GNU_MIPS_ABI_MSA_ANY
)
15531 mips_elf_tdata (obfd
)->abi_msa_bfd
= ibfd
;
15533 if (!elf_known_obj_attributes_proc (obfd
)[0].i
)
15535 /* This is the first object. Copy the attributes. */
15536 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
15538 /* Use the Tag_null value to indicate the attributes have been
15540 elf_known_obj_attributes_proc (obfd
)[0].i
= 1;
15545 /* Check for conflicting Tag_GNU_MIPS_ABI_FP attributes and merge
15546 non-conflicting ones. */
15547 out_attr
= elf_known_obj_attributes (obfd
)[OBJ_ATTR_GNU
];
15548 if (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
!= out_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
15552 out_fp
= out_attr
[Tag_GNU_MIPS_ABI_FP
].i
;
15553 in_fp
= in_attr
[Tag_GNU_MIPS_ABI_FP
].i
;
15554 out_attr
[Tag_GNU_MIPS_ABI_FP
].type
= 1;
15555 if (out_fp
== Val_GNU_MIPS_ABI_FP_ANY
)
15556 out_attr
[Tag_GNU_MIPS_ABI_FP
].i
= in_fp
;
15557 else if (out_fp
== Val_GNU_MIPS_ABI_FP_XX
15558 && (in_fp
== Val_GNU_MIPS_ABI_FP_DOUBLE
15559 || in_fp
== Val_GNU_MIPS_ABI_FP_64
15560 || in_fp
== Val_GNU_MIPS_ABI_FP_64A
))
15562 mips_elf_tdata (obfd
)->abi_fp_bfd
= ibfd
;
15563 out_attr
[Tag_GNU_MIPS_ABI_FP
].i
= in_attr
[Tag_GNU_MIPS_ABI_FP
].i
;
15565 else if (in_fp
== Val_GNU_MIPS_ABI_FP_XX
15566 && (out_fp
== Val_GNU_MIPS_ABI_FP_DOUBLE
15567 || out_fp
== Val_GNU_MIPS_ABI_FP_64
15568 || out_fp
== Val_GNU_MIPS_ABI_FP_64A
))
15569 /* Keep the current setting. */;
15570 else if (out_fp
== Val_GNU_MIPS_ABI_FP_64A
15571 && in_fp
== Val_GNU_MIPS_ABI_FP_64
)
15573 mips_elf_tdata (obfd
)->abi_fp_bfd
= ibfd
;
15574 out_attr
[Tag_GNU_MIPS_ABI_FP
].i
= in_attr
[Tag_GNU_MIPS_ABI_FP
].i
;
15576 else if (in_fp
== Val_GNU_MIPS_ABI_FP_64A
15577 && out_fp
== Val_GNU_MIPS_ABI_FP_64
)
15578 /* Keep the current setting. */;
15579 else if (in_fp
!= Val_GNU_MIPS_ABI_FP_ANY
)
15581 const char *out_string
, *in_string
;
15583 out_string
= _bfd_mips_fp_abi_string (out_fp
);
15584 in_string
= _bfd_mips_fp_abi_string (in_fp
);
15585 /* First warn about cases involving unrecognised ABIs. */
15586 if (!out_string
&& !in_string
)
15587 /* xgettext:c-format */
15589 (_("warning: %pB uses unknown floating point ABI %d "
15590 "(set by %pB), %pB uses unknown floating point ABI %d"),
15591 obfd
, out_fp
, abi_fp_bfd
, ibfd
, in_fp
);
15592 else if (!out_string
)
15594 /* xgettext:c-format */
15595 (_("warning: %pB uses unknown floating point ABI %d "
15596 "(set by %pB), %pB uses %s"),
15597 obfd
, out_fp
, abi_fp_bfd
, ibfd
, in_string
);
15598 else if (!in_string
)
15600 /* xgettext:c-format */
15601 (_("warning: %pB uses %s (set by %pB), "
15602 "%pB uses unknown floating point ABI %d"),
15603 obfd
, out_string
, abi_fp_bfd
, ibfd
, in_fp
);
15606 /* If one of the bfds is soft-float, the other must be
15607 hard-float. The exact choice of hard-float ABI isn't
15608 really relevant to the error message. */
15609 if (in_fp
== Val_GNU_MIPS_ABI_FP_SOFT
)
15610 out_string
= "-mhard-float";
15611 else if (out_fp
== Val_GNU_MIPS_ABI_FP_SOFT
)
15612 in_string
= "-mhard-float";
15614 /* xgettext:c-format */
15615 (_("warning: %pB uses %s (set by %pB), %pB uses %s"),
15616 obfd
, out_string
, abi_fp_bfd
, ibfd
, in_string
);
15621 /* Check for conflicting Tag_GNU_MIPS_ABI_MSA attributes and merge
15622 non-conflicting ones. */
15623 if (in_attr
[Tag_GNU_MIPS_ABI_MSA
].i
!= out_attr
[Tag_GNU_MIPS_ABI_MSA
].i
)
15625 out_attr
[Tag_GNU_MIPS_ABI_MSA
].type
= 1;
15626 if (out_attr
[Tag_GNU_MIPS_ABI_MSA
].i
== Val_GNU_MIPS_ABI_MSA_ANY
)
15627 out_attr
[Tag_GNU_MIPS_ABI_MSA
].i
= in_attr
[Tag_GNU_MIPS_ABI_MSA
].i
;
15628 else if (in_attr
[Tag_GNU_MIPS_ABI_MSA
].i
!= Val_GNU_MIPS_ABI_MSA_ANY
)
15629 switch (out_attr
[Tag_GNU_MIPS_ABI_MSA
].i
)
15631 case Val_GNU_MIPS_ABI_MSA_128
:
15633 /* xgettext:c-format */
15634 (_("warning: %pB uses %s (set by %pB), "
15635 "%pB uses unknown MSA ABI %d"),
15636 obfd
, "-mmsa", abi_msa_bfd
,
15637 ibfd
, in_attr
[Tag_GNU_MIPS_ABI_MSA
].i
);
15641 switch (in_attr
[Tag_GNU_MIPS_ABI_MSA
].i
)
15643 case Val_GNU_MIPS_ABI_MSA_128
:
15645 /* xgettext:c-format */
15646 (_("warning: %pB uses unknown MSA ABI %d "
15647 "(set by %pB), %pB uses %s"),
15648 obfd
, out_attr
[Tag_GNU_MIPS_ABI_MSA
].i
,
15649 abi_msa_bfd
, ibfd
, "-mmsa");
15654 /* xgettext:c-format */
15655 (_("warning: %pB uses unknown MSA ABI %d "
15656 "(set by %pB), %pB uses unknown MSA ABI %d"),
15657 obfd
, out_attr
[Tag_GNU_MIPS_ABI_MSA
].i
,
15658 abi_msa_bfd
, ibfd
, in_attr
[Tag_GNU_MIPS_ABI_MSA
].i
);
15664 /* Merge Tag_compatibility attributes and any common GNU ones. */
15665 return _bfd_elf_merge_object_attributes (ibfd
, info
);
15668 /* Merge object ABI flags from IBFD into OBFD. Raise an error if
15669 there are conflicting settings. */
15672 mips_elf_merge_obj_abiflags (bfd
*ibfd
, bfd
*obfd
)
15674 obj_attribute
*out_attr
= elf_known_obj_attributes (obfd
)[OBJ_ATTR_GNU
];
15675 struct mips_elf_obj_tdata
*out_tdata
= mips_elf_tdata (obfd
);
15676 struct mips_elf_obj_tdata
*in_tdata
= mips_elf_tdata (ibfd
);
15678 /* Update the output abiflags fp_abi using the computed fp_abi. */
15679 out_tdata
->abiflags
.fp_abi
= out_attr
[Tag_GNU_MIPS_ABI_FP
].i
;
15681 #define max(a, b) ((a) > (b) ? (a) : (b))
15682 /* Merge abiflags. */
15683 out_tdata
->abiflags
.isa_level
= max (out_tdata
->abiflags
.isa_level
,
15684 in_tdata
->abiflags
.isa_level
);
15685 out_tdata
->abiflags
.isa_rev
= max (out_tdata
->abiflags
.isa_rev
,
15686 in_tdata
->abiflags
.isa_rev
);
15687 out_tdata
->abiflags
.gpr_size
= max (out_tdata
->abiflags
.gpr_size
,
15688 in_tdata
->abiflags
.gpr_size
);
15689 out_tdata
->abiflags
.cpr1_size
= max (out_tdata
->abiflags
.cpr1_size
,
15690 in_tdata
->abiflags
.cpr1_size
);
15691 out_tdata
->abiflags
.cpr2_size
= max (out_tdata
->abiflags
.cpr2_size
,
15692 in_tdata
->abiflags
.cpr2_size
);
15694 out_tdata
->abiflags
.ases
|= in_tdata
->abiflags
.ases
;
15695 out_tdata
->abiflags
.flags1
|= in_tdata
->abiflags
.flags1
;
15700 /* Merge backend specific data from an object file to the output
15701 object file when linking. */
15704 _bfd_mips_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
15706 bfd
*obfd
= info
->output_bfd
;
15707 struct mips_elf_obj_tdata
*out_tdata
;
15708 struct mips_elf_obj_tdata
*in_tdata
;
15709 bfd_boolean null_input_bfd
= TRUE
;
15713 /* Check if we have the same endianness. */
15714 if (! _bfd_generic_verify_endian_match (ibfd
, info
))
15717 (_("%pB: endianness incompatible with that of the selected emulation"),
15722 if (!is_mips_elf (ibfd
) || !is_mips_elf (obfd
))
15725 in_tdata
= mips_elf_tdata (ibfd
);
15726 out_tdata
= mips_elf_tdata (obfd
);
15728 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
15731 (_("%pB: ABI is incompatible with that of the selected emulation"),
15736 /* Check to see if the input BFD actually contains any sections. If not,
15737 then it has no attributes, and its flags may not have been initialized
15738 either, but it cannot actually cause any incompatibility. */
15739 /* FIXME: This excludes any input shared library from consideration. */
15740 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
15742 /* Ignore synthetic sections and empty .text, .data and .bss sections
15743 which are automatically generated by gas. Also ignore fake
15744 (s)common sections, since merely defining a common symbol does
15745 not affect compatibility. */
15746 if ((sec
->flags
& SEC_IS_COMMON
) == 0
15747 && strcmp (sec
->name
, ".reginfo")
15748 && strcmp (sec
->name
, ".mdebug")
15750 || (strcmp (sec
->name
, ".text")
15751 && strcmp (sec
->name
, ".data")
15752 && strcmp (sec
->name
, ".bss"))))
15754 null_input_bfd
= FALSE
;
15758 if (null_input_bfd
)
15761 /* Populate abiflags using existing information. */
15762 if (in_tdata
->abiflags_valid
)
15764 obj_attribute
*in_attr
= elf_known_obj_attributes (ibfd
)[OBJ_ATTR_GNU
];
15765 Elf_Internal_ABIFlags_v0 in_abiflags
;
15766 Elf_Internal_ABIFlags_v0 abiflags
;
15768 /* Set up the FP ABI attribute from the abiflags if it is not already
15770 if (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
== Val_GNU_MIPS_ABI_FP_ANY
)
15771 in_attr
[Tag_GNU_MIPS_ABI_FP
].i
= in_tdata
->abiflags
.fp_abi
;
15773 infer_mips_abiflags (ibfd
, &abiflags
);
15774 in_abiflags
= in_tdata
->abiflags
;
15776 /* It is not possible to infer the correct ISA revision
15777 for R3 or R5 so drop down to R2 for the checks. */
15778 if (in_abiflags
.isa_rev
== 3 || in_abiflags
.isa_rev
== 5)
15779 in_abiflags
.isa_rev
= 2;
15781 if (LEVEL_REV (in_abiflags
.isa_level
, in_abiflags
.isa_rev
)
15782 < LEVEL_REV (abiflags
.isa_level
, abiflags
.isa_rev
))
15784 (_("%pB: warning: inconsistent ISA between e_flags and "
15785 ".MIPS.abiflags"), ibfd
);
15786 if (abiflags
.fp_abi
!= Val_GNU_MIPS_ABI_FP_ANY
15787 && in_abiflags
.fp_abi
!= abiflags
.fp_abi
)
15789 (_("%pB: warning: inconsistent FP ABI between .gnu.attributes and "
15790 ".MIPS.abiflags"), ibfd
);
15791 if ((in_abiflags
.ases
& abiflags
.ases
) != abiflags
.ases
)
15793 (_("%pB: warning: inconsistent ASEs between e_flags and "
15794 ".MIPS.abiflags"), ibfd
);
15795 /* The isa_ext is allowed to be an extension of what can be inferred
15797 if (!mips_mach_extends_p (bfd_mips_isa_ext_mach (abiflags
.isa_ext
),
15798 bfd_mips_isa_ext_mach (in_abiflags
.isa_ext
)))
15800 (_("%pB: warning: inconsistent ISA extensions between e_flags and "
15801 ".MIPS.abiflags"), ibfd
);
15802 if (in_abiflags
.flags2
!= 0)
15804 (_("%pB: warning: unexpected flag in the flags2 field of "
15805 ".MIPS.abiflags (0x%lx)"), ibfd
,
15806 in_abiflags
.flags2
);
15810 infer_mips_abiflags (ibfd
, &in_tdata
->abiflags
);
15811 in_tdata
->abiflags_valid
= TRUE
;
15814 if (!out_tdata
->abiflags_valid
)
15816 /* Copy input abiflags if output abiflags are not already valid. */
15817 out_tdata
->abiflags
= in_tdata
->abiflags
;
15818 out_tdata
->abiflags_valid
= TRUE
;
15821 if (! elf_flags_init (obfd
))
15823 elf_flags_init (obfd
) = TRUE
;
15824 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
15825 elf_elfheader (obfd
)->e_ident
[EI_CLASS
]
15826 = elf_elfheader (ibfd
)->e_ident
[EI_CLASS
];
15828 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
15829 && (bfd_get_arch_info (obfd
)->the_default
15830 || mips_mach_extends_p (bfd_get_mach (obfd
),
15831 bfd_get_mach (ibfd
))))
15833 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
15834 bfd_get_mach (ibfd
)))
15837 /* Update the ABI flags isa_level, isa_rev and isa_ext fields. */
15838 update_mips_abiflags_isa (obfd
, &out_tdata
->abiflags
);
15844 ok
= mips_elf_merge_obj_e_flags (ibfd
, info
);
15846 ok
= mips_elf_merge_obj_attributes (ibfd
, info
) && ok
;
15848 ok
= mips_elf_merge_obj_abiflags (ibfd
, obfd
) && ok
;
15852 bfd_set_error (bfd_error_bad_value
);
15859 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
15862 _bfd_mips_elf_set_private_flags (bfd
*abfd
, flagword flags
)
15864 BFD_ASSERT (!elf_flags_init (abfd
)
15865 || elf_elfheader (abfd
)->e_flags
== flags
);
15867 elf_elfheader (abfd
)->e_flags
= flags
;
15868 elf_flags_init (abfd
) = TRUE
;
15873 _bfd_mips_elf_get_target_dtag (bfd_vma dtag
)
15877 default: return "";
15878 case DT_MIPS_RLD_VERSION
:
15879 return "MIPS_RLD_VERSION";
15880 case DT_MIPS_TIME_STAMP
:
15881 return "MIPS_TIME_STAMP";
15882 case DT_MIPS_ICHECKSUM
:
15883 return "MIPS_ICHECKSUM";
15884 case DT_MIPS_IVERSION
:
15885 return "MIPS_IVERSION";
15886 case DT_MIPS_FLAGS
:
15887 return "MIPS_FLAGS";
15888 case DT_MIPS_BASE_ADDRESS
:
15889 return "MIPS_BASE_ADDRESS";
15891 return "MIPS_MSYM";
15892 case DT_MIPS_CONFLICT
:
15893 return "MIPS_CONFLICT";
15894 case DT_MIPS_LIBLIST
:
15895 return "MIPS_LIBLIST";
15896 case DT_MIPS_LOCAL_GOTNO
:
15897 return "MIPS_LOCAL_GOTNO";
15898 case DT_MIPS_CONFLICTNO
:
15899 return "MIPS_CONFLICTNO";
15900 case DT_MIPS_LIBLISTNO
:
15901 return "MIPS_LIBLISTNO";
15902 case DT_MIPS_SYMTABNO
:
15903 return "MIPS_SYMTABNO";
15904 case DT_MIPS_UNREFEXTNO
:
15905 return "MIPS_UNREFEXTNO";
15906 case DT_MIPS_GOTSYM
:
15907 return "MIPS_GOTSYM";
15908 case DT_MIPS_HIPAGENO
:
15909 return "MIPS_HIPAGENO";
15910 case DT_MIPS_RLD_MAP
:
15911 return "MIPS_RLD_MAP";
15912 case DT_MIPS_RLD_MAP_REL
:
15913 return "MIPS_RLD_MAP_REL";
15914 case DT_MIPS_DELTA_CLASS
:
15915 return "MIPS_DELTA_CLASS";
15916 case DT_MIPS_DELTA_CLASS_NO
:
15917 return "MIPS_DELTA_CLASS_NO";
15918 case DT_MIPS_DELTA_INSTANCE
:
15919 return "MIPS_DELTA_INSTANCE";
15920 case DT_MIPS_DELTA_INSTANCE_NO
:
15921 return "MIPS_DELTA_INSTANCE_NO";
15922 case DT_MIPS_DELTA_RELOC
:
15923 return "MIPS_DELTA_RELOC";
15924 case DT_MIPS_DELTA_RELOC_NO
:
15925 return "MIPS_DELTA_RELOC_NO";
15926 case DT_MIPS_DELTA_SYM
:
15927 return "MIPS_DELTA_SYM";
15928 case DT_MIPS_DELTA_SYM_NO
:
15929 return "MIPS_DELTA_SYM_NO";
15930 case DT_MIPS_DELTA_CLASSSYM
:
15931 return "MIPS_DELTA_CLASSSYM";
15932 case DT_MIPS_DELTA_CLASSSYM_NO
:
15933 return "MIPS_DELTA_CLASSSYM_NO";
15934 case DT_MIPS_CXX_FLAGS
:
15935 return "MIPS_CXX_FLAGS";
15936 case DT_MIPS_PIXIE_INIT
:
15937 return "MIPS_PIXIE_INIT";
15938 case DT_MIPS_SYMBOL_LIB
:
15939 return "MIPS_SYMBOL_LIB";
15940 case DT_MIPS_LOCALPAGE_GOTIDX
:
15941 return "MIPS_LOCALPAGE_GOTIDX";
15942 case DT_MIPS_LOCAL_GOTIDX
:
15943 return "MIPS_LOCAL_GOTIDX";
15944 case DT_MIPS_HIDDEN_GOTIDX
:
15945 return "MIPS_HIDDEN_GOTIDX";
15946 case DT_MIPS_PROTECTED_GOTIDX
:
15947 return "MIPS_PROTECTED_GOT_IDX";
15948 case DT_MIPS_OPTIONS
:
15949 return "MIPS_OPTIONS";
15950 case DT_MIPS_INTERFACE
:
15951 return "MIPS_INTERFACE";
15952 case DT_MIPS_DYNSTR_ALIGN
:
15953 return "DT_MIPS_DYNSTR_ALIGN";
15954 case DT_MIPS_INTERFACE_SIZE
:
15955 return "DT_MIPS_INTERFACE_SIZE";
15956 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
:
15957 return "DT_MIPS_RLD_TEXT_RESOLVE_ADDR";
15958 case DT_MIPS_PERF_SUFFIX
:
15959 return "DT_MIPS_PERF_SUFFIX";
15960 case DT_MIPS_COMPACT_SIZE
:
15961 return "DT_MIPS_COMPACT_SIZE";
15962 case DT_MIPS_GP_VALUE
:
15963 return "DT_MIPS_GP_VALUE";
15964 case DT_MIPS_AUX_DYNAMIC
:
15965 return "DT_MIPS_AUX_DYNAMIC";
15966 case DT_MIPS_PLTGOT
:
15967 return "DT_MIPS_PLTGOT";
15968 case DT_MIPS_RWPLT
:
15969 return "DT_MIPS_RWPLT";
15970 case DT_MIPS_XHASH
:
15971 return "DT_MIPS_XHASH";
15975 /* Return the meaning of Tag_GNU_MIPS_ABI_FP value FP, or null if
15979 _bfd_mips_fp_abi_string (int fp
)
15983 /* These strings aren't translated because they're simply
15985 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15986 return "-mdouble-float";
15988 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15989 return "-msingle-float";
15991 case Val_GNU_MIPS_ABI_FP_SOFT
:
15992 return "-msoft-float";
15994 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15995 return _("-mips32r2 -mfp64 (12 callee-saved)");
15997 case Val_GNU_MIPS_ABI_FP_XX
:
16000 case Val_GNU_MIPS_ABI_FP_64
:
16001 return "-mgp32 -mfp64";
16003 case Val_GNU_MIPS_ABI_FP_64A
:
16004 return "-mgp32 -mfp64 -mno-odd-spreg";
16012 print_mips_ases (FILE *file
, unsigned int mask
)
16014 if (mask
& AFL_ASE_DSP
)
16015 fputs ("\n\tDSP ASE", file
);
16016 if (mask
& AFL_ASE_DSPR2
)
16017 fputs ("\n\tDSP R2 ASE", file
);
16018 if (mask
& AFL_ASE_DSPR3
)
16019 fputs ("\n\tDSP R3 ASE", file
);
16020 if (mask
& AFL_ASE_EVA
)
16021 fputs ("\n\tEnhanced VA Scheme", file
);
16022 if (mask
& AFL_ASE_MCU
)
16023 fputs ("\n\tMCU (MicroController) ASE", file
);
16024 if (mask
& AFL_ASE_MDMX
)
16025 fputs ("\n\tMDMX ASE", file
);
16026 if (mask
& AFL_ASE_MIPS3D
)
16027 fputs ("\n\tMIPS-3D ASE", file
);
16028 if (mask
& AFL_ASE_MT
)
16029 fputs ("\n\tMT ASE", file
);
16030 if (mask
& AFL_ASE_SMARTMIPS
)
16031 fputs ("\n\tSmartMIPS ASE", file
);
16032 if (mask
& AFL_ASE_VIRT
)
16033 fputs ("\n\tVZ ASE", file
);
16034 if (mask
& AFL_ASE_MSA
)
16035 fputs ("\n\tMSA ASE", file
);
16036 if (mask
& AFL_ASE_MIPS16
)
16037 fputs ("\n\tMIPS16 ASE", file
);
16038 if (mask
& AFL_ASE_MICROMIPS
)
16039 fputs ("\n\tMICROMIPS ASE", file
);
16040 if (mask
& AFL_ASE_XPA
)
16041 fputs ("\n\tXPA ASE", file
);
16042 if (mask
& AFL_ASE_MIPS16E2
)
16043 fputs ("\n\tMIPS16e2 ASE", file
);
16044 if (mask
& AFL_ASE_CRC
)
16045 fputs ("\n\tCRC ASE", file
);
16046 if (mask
& AFL_ASE_GINV
)
16047 fputs ("\n\tGINV ASE", file
);
16048 if (mask
& AFL_ASE_LOONGSON_MMI
)
16049 fputs ("\n\tLoongson MMI ASE", file
);
16050 if (mask
& AFL_ASE_LOONGSON_CAM
)
16051 fputs ("\n\tLoongson CAM ASE", file
);
16052 if (mask
& AFL_ASE_LOONGSON_EXT
)
16053 fputs ("\n\tLoongson EXT ASE", file
);
16054 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16055 fputs ("\n\tLoongson EXT2 ASE", file
);
16057 fprintf (file
, "\n\t%s", _("None"));
16058 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16059 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16063 print_mips_isa_ext (FILE *file
, unsigned int isa_ext
)
16068 fputs (_("None"), file
);
16071 fputs ("RMI XLR", file
);
16073 case AFL_EXT_OCTEON3
:
16074 fputs ("Cavium Networks Octeon3", file
);
16076 case AFL_EXT_OCTEON2
:
16077 fputs ("Cavium Networks Octeon2", file
);
16079 case AFL_EXT_OCTEONP
:
16080 fputs ("Cavium Networks OcteonP", file
);
16082 case AFL_EXT_OCTEON
:
16083 fputs ("Cavium Networks Octeon", file
);
16086 fputs ("Toshiba R5900", file
);
16089 fputs ("MIPS R4650", file
);
16092 fputs ("LSI R4010", file
);
16095 fputs ("NEC VR4100", file
);
16098 fputs ("Toshiba R3900", file
);
16100 case AFL_EXT_10000
:
16101 fputs ("MIPS R10000", file
);
16104 fputs ("Broadcom SB-1", file
);
16107 fputs ("NEC VR4111/VR4181", file
);
16110 fputs ("NEC VR4120", file
);
16113 fputs ("NEC VR5400", file
);
16116 fputs ("NEC VR5500", file
);
16118 case AFL_EXT_LOONGSON_2E
:
16119 fputs ("ST Microelectronics Loongson 2E", file
);
16121 case AFL_EXT_LOONGSON_2F
:
16122 fputs ("ST Microelectronics Loongson 2F", file
);
16124 case AFL_EXT_INTERAPTIV_MR2
:
16125 fputs ("Imagination interAptiv MR2", file
);
16128 fprintf (file
, "%s (%d)", _("Unknown"), isa_ext
);
16134 print_mips_fp_abi_value (FILE *file
, int val
)
16138 case Val_GNU_MIPS_ABI_FP_ANY
:
16139 fprintf (file
, _("Hard or soft float\n"));
16141 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
16142 fprintf (file
, _("Hard float (double precision)\n"));
16144 case Val_GNU_MIPS_ABI_FP_SINGLE
:
16145 fprintf (file
, _("Hard float (single precision)\n"));
16147 case Val_GNU_MIPS_ABI_FP_SOFT
:
16148 fprintf (file
, _("Soft float\n"));
16150 case Val_GNU_MIPS_ABI_FP_OLD_64
:
16151 fprintf (file
, _("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
16153 case Val_GNU_MIPS_ABI_FP_XX
:
16154 fprintf (file
, _("Hard float (32-bit CPU, Any FPU)\n"));
16156 case Val_GNU_MIPS_ABI_FP_64
:
16157 fprintf (file
, _("Hard float (32-bit CPU, 64-bit FPU)\n"));
16159 case Val_GNU_MIPS_ABI_FP_64A
:
16160 fprintf (file
, _("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
16163 fprintf (file
, "??? (%d)\n", val
);
16169 get_mips_reg_size (int reg_size
)
16171 return (reg_size
== AFL_REG_NONE
) ? 0
16172 : (reg_size
== AFL_REG_32
) ? 32
16173 : (reg_size
== AFL_REG_64
) ? 64
16174 : (reg_size
== AFL_REG_128
) ? 128
16179 _bfd_mips_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
16183 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
16185 /* Print normal ELF private data. */
16186 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
16188 /* xgettext:c-format */
16189 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
16191 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
)
16192 fprintf (file
, _(" [abi=O32]"));
16193 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O64
)
16194 fprintf (file
, _(" [abi=O64]"));
16195 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
)
16196 fprintf (file
, _(" [abi=EABI32]"));
16197 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
16198 fprintf (file
, _(" [abi=EABI64]"));
16199 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
))
16200 fprintf (file
, _(" [abi unknown]"));
16201 else if (ABI_N32_P (abfd
))
16202 fprintf (file
, _(" [abi=N32]"));
16203 else if (ABI_64_P (abfd
))
16204 fprintf (file
, _(" [abi=64]"));
16206 fprintf (file
, _(" [no abi set]"));
16208 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
16209 fprintf (file
, " [mips1]");
16210 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
16211 fprintf (file
, " [mips2]");
16212 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
16213 fprintf (file
, " [mips3]");
16214 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
16215 fprintf (file
, " [mips4]");
16216 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_5
)
16217 fprintf (file
, " [mips5]");
16218 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
)
16219 fprintf (file
, " [mips32]");
16220 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64
)
16221 fprintf (file
, " [mips64]");
16222 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
)
16223 fprintf (file
, " [mips32r2]");
16224 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64R2
)
16225 fprintf (file
, " [mips64r2]");
16226 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R6
)
16227 fprintf (file
, " [mips32r6]");
16228 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64R6
)
16229 fprintf (file
, " [mips64r6]");
16231 fprintf (file
, _(" [unknown ISA]"));
16233 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
16234 fprintf (file
, " [mdmx]");
16236 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_M16
)
16237 fprintf (file
, " [mips16]");
16239 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
16240 fprintf (file
, " [micromips]");
16242 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_NAN2008
)
16243 fprintf (file
, " [nan2008]");
16245 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_FP64
)
16246 fprintf (file
, " [old fp64]");
16248 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_32BITMODE
)
16249 fprintf (file
, " [32bitmode]");
16251 fprintf (file
, _(" [not 32bitmode]"));
16253 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_NOREORDER
)
16254 fprintf (file
, " [noreorder]");
16256 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_PIC
)
16257 fprintf (file
, " [PIC]");
16259 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_CPIC
)
16260 fprintf (file
, " [CPIC]");
16262 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_XGOT
)
16263 fprintf (file
, " [XGOT]");
16265 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_UCODE
)
16266 fprintf (file
, " [UCODE]");
16268 fputc ('\n', file
);
16270 if (mips_elf_tdata (abfd
)->abiflags_valid
)
16272 Elf_Internal_ABIFlags_v0
*abiflags
= &mips_elf_tdata (abfd
)->abiflags
;
16273 fprintf (file
, "\nMIPS ABI Flags Version: %d\n", abiflags
->version
);
16274 fprintf (file
, "\nISA: MIPS%d", abiflags
->isa_level
);
16275 if (abiflags
->isa_rev
> 1)
16276 fprintf (file
, "r%d", abiflags
->isa_rev
);
16277 fprintf (file
, "\nGPR size: %d",
16278 get_mips_reg_size (abiflags
->gpr_size
));
16279 fprintf (file
, "\nCPR1 size: %d",
16280 get_mips_reg_size (abiflags
->cpr1_size
));
16281 fprintf (file
, "\nCPR2 size: %d",
16282 get_mips_reg_size (abiflags
->cpr2_size
));
16283 fputs ("\nFP ABI: ", file
);
16284 print_mips_fp_abi_value (file
, abiflags
->fp_abi
);
16285 fputs ("ISA Extension: ", file
);
16286 print_mips_isa_ext (file
, abiflags
->isa_ext
);
16287 fputs ("\nASEs:", file
);
16288 print_mips_ases (file
, abiflags
->ases
);
16289 fprintf (file
, "\nFLAGS 1: %8.8lx", abiflags
->flags1
);
16290 fprintf (file
, "\nFLAGS 2: %8.8lx", abiflags
->flags2
);
16291 fputc ('\n', file
);
16297 const struct bfd_elf_special_section _bfd_mips_elf_special_sections
[] =
16299 { STRING_COMMA_LEN (".lit4"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
16300 { STRING_COMMA_LEN (".lit8"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
16301 { STRING_COMMA_LEN (".mdebug"), 0, SHT_MIPS_DEBUG
, 0 },
16302 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
16303 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
16304 { STRING_COMMA_LEN (".ucode"), 0, SHT_MIPS_UCODE
, 0 },
16305 { STRING_COMMA_LEN (".MIPS.xhash"), 0, SHT_MIPS_XHASH
, SHF_ALLOC
},
16306 { NULL
, 0, 0, 0, 0 }
16309 /* Merge non visibility st_other attributes. Ensure that the
16310 STO_OPTIONAL flag is copied into h->other, even if this is not a
16311 definiton of the symbol. */
16313 _bfd_mips_elf_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
16314 const Elf_Internal_Sym
*isym
,
16315 bfd_boolean definition
,
16316 bfd_boolean dynamic ATTRIBUTE_UNUSED
)
16318 if ((isym
->st_other
& ~ELF_ST_VISIBILITY (-1)) != 0)
16320 unsigned char other
;
16322 other
= (definition
? isym
->st_other
: h
->other
);
16323 other
&= ~ELF_ST_VISIBILITY (-1);
16324 h
->other
= other
| ELF_ST_VISIBILITY (h
->other
);
16328 && ELF_MIPS_IS_OPTIONAL (isym
->st_other
))
16329 h
->other
|= STO_OPTIONAL
;
16332 /* Decide whether an undefined symbol is special and can be ignored.
16333 This is the case for OPTIONAL symbols on IRIX. */
16335 _bfd_mips_elf_ignore_undef_symbol (struct elf_link_hash_entry
*h
)
16337 return ELF_MIPS_IS_OPTIONAL (h
->other
) ? TRUE
: FALSE
;
16341 _bfd_mips_elf_common_definition (Elf_Internal_Sym
*sym
)
16343 return (sym
->st_shndx
== SHN_COMMON
16344 || sym
->st_shndx
== SHN_MIPS_ACOMMON
16345 || sym
->st_shndx
== SHN_MIPS_SCOMMON
);
16348 /* Return address for Ith PLT stub in section PLT, for relocation REL
16349 or (bfd_vma) -1 if it should not be included. */
16352 _bfd_mips_elf_plt_sym_val (bfd_vma i
, const asection
*plt
,
16353 const arelent
*rel ATTRIBUTE_UNUSED
)
16356 + 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry
)
16357 + i
* 4 * ARRAY_SIZE (mips_exec_plt_entry
));
16360 /* Build a table of synthetic symbols to represent the PLT. As with MIPS16
16361 and microMIPS PLT slots we may have a many-to-one mapping between .plt
16362 and .got.plt and also the slots may be of a different size each we walk
16363 the PLT manually fetching instructions and matching them against known
16364 patterns. To make things easier standard MIPS slots, if any, always come
16365 first. As we don't create proper ELF symbols we use the UDATA.I member
16366 of ASYMBOL to carry ISA annotation. The encoding used is the same as
16367 with the ST_OTHER member of the ELF symbol. */
16370 _bfd_mips_elf_get_synthetic_symtab (bfd
*abfd
,
16371 long symcount ATTRIBUTE_UNUSED
,
16372 asymbol
**syms ATTRIBUTE_UNUSED
,
16373 long dynsymcount
, asymbol
**dynsyms
,
16376 static const char pltname
[] = "_PROCEDURE_LINKAGE_TABLE_";
16377 static const char microsuffix
[] = "@micromipsplt";
16378 static const char m16suffix
[] = "@mips16plt";
16379 static const char mipssuffix
[] = "@plt";
16381 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
16382 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
16383 bfd_boolean micromips_p
= MICROMIPS_P (abfd
);
16384 Elf_Internal_Shdr
*hdr
;
16385 bfd_byte
*plt_data
;
16386 bfd_vma plt_offset
;
16387 unsigned int other
;
16388 bfd_vma entry_size
;
16407 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0 || dynsymcount
<= 0)
16410 relplt
= bfd_get_section_by_name (abfd
, ".rel.plt");
16411 if (relplt
== NULL
)
16414 hdr
= &elf_section_data (relplt
)->this_hdr
;
16415 if (hdr
->sh_link
!= elf_dynsymtab (abfd
) || hdr
->sh_type
!= SHT_REL
)
16418 plt
= bfd_get_section_by_name (abfd
, ".plt");
16422 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
16423 if (!(*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
16425 p
= relplt
->relocation
;
16427 /* Calculating the exact amount of space required for symbols would
16428 require two passes over the PLT, so just pessimise assuming two
16429 PLT slots per relocation. */
16430 count
= relplt
->size
/ hdr
->sh_entsize
;
16431 counti
= count
* bed
->s
->int_rels_per_ext_rel
;
16432 size
= 2 * count
* sizeof (asymbol
);
16433 size
+= count
* (sizeof (mipssuffix
) +
16434 (micromips_p
? sizeof (microsuffix
) : sizeof (m16suffix
)));
16435 for (pi
= 0; pi
< counti
; pi
+= bed
->s
->int_rels_per_ext_rel
)
16436 size
+= 2 * strlen ((*p
[pi
].sym_ptr_ptr
)->name
);
16438 /* Add the size of "_PROCEDURE_LINKAGE_TABLE_" too. */
16439 size
+= sizeof (asymbol
) + sizeof (pltname
);
16441 if (!bfd_malloc_and_get_section (abfd
, plt
, &plt_data
))
16444 if (plt
->size
< 16)
16447 s
= *ret
= bfd_malloc (size
);
16450 send
= s
+ 2 * count
+ 1;
16452 names
= (char *) send
;
16453 nend
= (char *) s
+ size
;
16456 opcode
= bfd_get_micromips_32 (abfd
, plt_data
+ 12);
16457 if (opcode
== 0x3302fffe)
16461 plt0_size
= 2 * ARRAY_SIZE (micromips_o32_exec_plt0_entry
);
16462 other
= STO_MICROMIPS
;
16464 else if (opcode
== 0x0398c1d0)
16468 plt0_size
= 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt0_entry
);
16469 other
= STO_MICROMIPS
;
16473 plt0_size
= 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry
);
16478 s
->flags
= BSF_SYNTHETIC
| BSF_FUNCTION
| BSF_LOCAL
;
16482 s
->udata
.i
= other
;
16483 memcpy (names
, pltname
, sizeof (pltname
));
16484 names
+= sizeof (pltname
);
16488 for (plt_offset
= plt0_size
;
16489 plt_offset
+ 8 <= plt
->size
&& s
< send
;
16490 plt_offset
+= entry_size
)
16492 bfd_vma gotplt_addr
;
16493 const char *suffix
;
16498 opcode
= bfd_get_micromips_32 (abfd
, plt_data
+ plt_offset
+ 4);
16500 /* Check if the second word matches the expected MIPS16 instruction. */
16501 if (opcode
== 0x651aeb00)
16505 /* Truncated table??? */
16506 if (plt_offset
+ 16 > plt
->size
)
16508 gotplt_addr
= bfd_get_32 (abfd
, plt_data
+ plt_offset
+ 12);
16509 entry_size
= 2 * ARRAY_SIZE (mips16_o32_exec_plt_entry
);
16510 suffixlen
= sizeof (m16suffix
);
16511 suffix
= m16suffix
;
16512 other
= STO_MIPS16
;
16514 /* Likewise the expected microMIPS instruction (no insn32 mode). */
16515 else if (opcode
== 0xff220000)
16519 gotplt_hi
= bfd_get_16 (abfd
, plt_data
+ plt_offset
) & 0x7f;
16520 gotplt_lo
= bfd_get_16 (abfd
, plt_data
+ plt_offset
+ 2) & 0xffff;
16521 gotplt_hi
= ((gotplt_hi
^ 0x40) - 0x40) << 18;
16523 gotplt_addr
= gotplt_hi
+ gotplt_lo
;
16524 gotplt_addr
+= ((plt
->vma
+ plt_offset
) | 3) ^ 3;
16525 entry_size
= 2 * ARRAY_SIZE (micromips_o32_exec_plt_entry
);
16526 suffixlen
= sizeof (microsuffix
);
16527 suffix
= microsuffix
;
16528 other
= STO_MICROMIPS
;
16530 /* Likewise the expected microMIPS instruction (insn32 mode). */
16531 else if ((opcode
& 0xffff0000) == 0xff2f0000)
16533 gotplt_hi
= bfd_get_16 (abfd
, plt_data
+ plt_offset
+ 2) & 0xffff;
16534 gotplt_lo
= bfd_get_16 (abfd
, plt_data
+ plt_offset
+ 6) & 0xffff;
16535 gotplt_hi
= ((gotplt_hi
^ 0x8000) - 0x8000) << 16;
16536 gotplt_lo
= (gotplt_lo
^ 0x8000) - 0x8000;
16537 gotplt_addr
= gotplt_hi
+ gotplt_lo
;
16538 entry_size
= 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt_entry
);
16539 suffixlen
= sizeof (microsuffix
);
16540 suffix
= microsuffix
;
16541 other
= STO_MICROMIPS
;
16543 /* Otherwise assume standard MIPS code. */
16546 gotplt_hi
= bfd_get_32 (abfd
, plt_data
+ plt_offset
) & 0xffff;
16547 gotplt_lo
= bfd_get_32 (abfd
, plt_data
+ plt_offset
+ 4) & 0xffff;
16548 gotplt_hi
= ((gotplt_hi
^ 0x8000) - 0x8000) << 16;
16549 gotplt_lo
= (gotplt_lo
^ 0x8000) - 0x8000;
16550 gotplt_addr
= gotplt_hi
+ gotplt_lo
;
16551 entry_size
= 4 * ARRAY_SIZE (mips_exec_plt_entry
);
16552 suffixlen
= sizeof (mipssuffix
);
16553 suffix
= mipssuffix
;
16556 /* Truncated table??? */
16557 if (plt_offset
+ entry_size
> plt
->size
)
16561 i
< count
&& p
[pi
].address
!= gotplt_addr
;
16562 i
++, pi
= (pi
+ bed
->s
->int_rels_per_ext_rel
) % counti
);
16569 *s
= **p
[pi
].sym_ptr_ptr
;
16570 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
16571 we are defining a symbol, ensure one of them is set. */
16572 if ((s
->flags
& BSF_LOCAL
) == 0)
16573 s
->flags
|= BSF_GLOBAL
;
16574 s
->flags
|= BSF_SYNTHETIC
;
16576 s
->value
= plt_offset
;
16578 s
->udata
.i
= other
;
16580 len
= strlen ((*p
[pi
].sym_ptr_ptr
)->name
);
16581 namelen
= len
+ suffixlen
;
16582 if (names
+ namelen
> nend
)
16585 memcpy (names
, (*p
[pi
].sym_ptr_ptr
)->name
, len
);
16587 memcpy (names
, suffix
, suffixlen
);
16588 names
+= suffixlen
;
16591 pi
= (pi
+ bed
->s
->int_rels_per_ext_rel
) % counti
;
16600 /* Return the ABI flags associated with ABFD if available. */
16602 Elf_Internal_ABIFlags_v0
*
16603 bfd_mips_elf_get_abiflags (bfd
*abfd
)
16605 struct mips_elf_obj_tdata
*tdata
= mips_elf_tdata (abfd
);
16607 return tdata
->abiflags_valid
? &tdata
->abiflags
: NULL
;
16610 /* MIPS libc ABI versions, used with the EI_ABIVERSION ELF file header
16611 field. Taken from `libc-abis.h' generated at GNU libc build time.
16612 Using a MIPS_ prefix as other libc targets use different values. */
16615 MIPS_LIBC_ABI_DEFAULT
= 0,
16616 MIPS_LIBC_ABI_MIPS_PLT
,
16617 MIPS_LIBC_ABI_UNIQUE
,
16618 MIPS_LIBC_ABI_MIPS_O32_FP64
,
16619 MIPS_LIBC_ABI_ABSOLUTE
,
16620 MIPS_LIBC_ABI_XHASH
,
16625 _bfd_mips_init_file_header (bfd
*abfd
, struct bfd_link_info
*link_info
)
16627 struct mips_elf_link_hash_table
*htab
= NULL
;
16628 Elf_Internal_Ehdr
*i_ehdrp
;
16630 if (!_bfd_elf_init_file_header (abfd
, link_info
))
16633 i_ehdrp
= elf_elfheader (abfd
);
16636 htab
= mips_elf_hash_table (link_info
);
16637 BFD_ASSERT (htab
!= NULL
);
16640 if (htab
!= NULL
&& htab
->use_plts_and_copy_relocs
&& !htab
->is_vxworks
)
16641 i_ehdrp
->e_ident
[EI_ABIVERSION
] = MIPS_LIBC_ABI_MIPS_PLT
;
16643 if (mips_elf_tdata (abfd
)->abiflags
.fp_abi
== Val_GNU_MIPS_ABI_FP_64
16644 || mips_elf_tdata (abfd
)->abiflags
.fp_abi
== Val_GNU_MIPS_ABI_FP_64A
)
16645 i_ehdrp
->e_ident
[EI_ABIVERSION
] = MIPS_LIBC_ABI_MIPS_O32_FP64
;
16647 /* Mark that we need support for absolute symbols in the dynamic loader. */
16648 if (htab
!= NULL
&& htab
->use_absolute_zero
&& htab
->gnu_target
)
16649 i_ehdrp
->e_ident
[EI_ABIVERSION
] = MIPS_LIBC_ABI_ABSOLUTE
;
16651 /* Mark that we need support for .MIPS.xhash in the dynamic linker,
16652 if it is the only hash section that will be created. */
16653 if (link_info
&& link_info
->emit_gnu_hash
&& !link_info
->emit_hash
)
16654 i_ehdrp
->e_ident
[EI_ABIVERSION
] = MIPS_LIBC_ABI_XHASH
;
16659 _bfd_mips_elf_compact_eh_encoding
16660 (struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
)
16662 return DW_EH_PE_pcrel
| DW_EH_PE_sdata4
;
16665 /* Return the opcode for can't unwind. */
16668 _bfd_mips_elf_cant_unwind_opcode
16669 (struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
)
16671 return COMPACT_EH_CANT_UNWIND_OPCODE
;
16674 /* Record a position XLAT_LOC in the xlat translation table, associated with
16675 the hash entry H. The entry in the translation table will later be
16676 populated with the real symbol dynindx. */
16679 _bfd_mips_elf_record_xhash_symbol (struct elf_link_hash_entry
*h
,
16682 struct mips_elf_link_hash_entry
*hmips
;
16684 hmips
= (struct mips_elf_link_hash_entry
*) h
;
16685 hmips
->mipsxhash_loc
= xlat_loc
;