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 Relocations in nonallocatable sections such as .pdr and
8659 .debug* should have no effect. */
8660 constrain_symbol_p
= ((sec
->flags
& SEC_ALLOC
) != 0);
8665 case R_MIPS_CALL_HI16
:
8666 case R_MIPS_CALL_LO16
:
8667 case R_MIPS16_CALL16
:
8668 case R_MICROMIPS_CALL16
:
8669 case R_MICROMIPS_CALL_HI16
:
8670 case R_MICROMIPS_CALL_LO16
:
8671 call_reloc_p
= TRUE
;
8675 case R_MIPS_GOT_LO16
:
8676 case R_MIPS_GOT_PAGE
:
8677 case R_MIPS_GOT_DISP
:
8678 case R_MIPS16_GOT16
:
8679 case R_MICROMIPS_GOT16
:
8680 case R_MICROMIPS_GOT_LO16
:
8681 case R_MICROMIPS_GOT_PAGE
:
8682 case R_MICROMIPS_GOT_DISP
:
8683 /* If we have a symbol that will resolve to zero at static link
8684 time and it is used by a GOT relocation applied to code we
8685 cannot relax to an immediate zero load, then we will be using
8686 the special `__gnu_absolute_zero' symbol whose value is zero
8687 at dynamic load time. We ignore HI16-type GOT relocations at
8688 this stage, because their handling will depend entirely on
8689 the corresponding LO16-type GOT relocation. */
8690 if (!call_hi16_reloc_p (r_type
)
8692 && bfd_link_pic (info
)
8693 && !htab
->use_absolute_zero
8694 && UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
8696 bfd_boolean rel_reloc
;
8698 if (!mips_elf_get_section_contents (abfd
, sec
, &contents
))
8701 rel_reloc
= mips_elf_rel_relocation_p (abfd
, sec
, relocs
, rel
);
8702 howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, r_type
, !rel_reloc
);
8704 if (!mips_elf_nullify_got_load (abfd
, contents
, rel
, howto
,
8706 if (!mips_elf_define_absolute_zero (abfd
, info
, htab
, r_type
))
8711 case R_MIPS_GOT_HI16
:
8712 case R_MIPS_GOT_OFST
:
8713 case R_MIPS_TLS_GOTTPREL
:
8715 case R_MIPS_TLS_LDM
:
8716 case R_MIPS16_TLS_GOTTPREL
:
8717 case R_MIPS16_TLS_GD
:
8718 case R_MIPS16_TLS_LDM
:
8719 case R_MICROMIPS_GOT_HI16
:
8720 case R_MICROMIPS_GOT_OFST
:
8721 case R_MICROMIPS_TLS_GOTTPREL
:
8722 case R_MICROMIPS_TLS_GD
:
8723 case R_MICROMIPS_TLS_LDM
:
8725 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
8726 if (!mips_elf_create_got_section (dynobj
, info
))
8728 if (htab
->is_vxworks
&& !bfd_link_pic (info
))
8731 /* xgettext:c-format */
8732 (_("%pB: GOT reloc at %#" PRIx64
" not expected in executables"),
8733 abfd
, (uint64_t) rel
->r_offset
);
8734 bfd_set_error (bfd_error_bad_value
);
8737 can_make_dynamic_p
= TRUE
;
8742 case R_MICROMIPS_JALR
:
8743 /* These relocations have empty fields and are purely there to
8744 provide link information. The symbol value doesn't matter. */
8745 constrain_symbol_p
= FALSE
;
8748 case R_MIPS_GPREL16
:
8749 case R_MIPS_GPREL32
:
8750 case R_MIPS16_GPREL
:
8751 case R_MICROMIPS_GPREL16
:
8752 /* GP-relative relocations always resolve to a definition in a
8753 regular input file, ignoring the one-definition rule. This is
8754 important for the GP setup sequence in NewABI code, which
8755 always resolves to a local function even if other relocations
8756 against the symbol wouldn't. */
8757 constrain_symbol_p
= FALSE
;
8763 /* In VxWorks executables, references to external symbols
8764 must be handled using copy relocs or PLT entries; it is not
8765 possible to convert this relocation into a dynamic one.
8767 For executables that use PLTs and copy-relocs, we have a
8768 choice between converting the relocation into a dynamic
8769 one or using copy relocations or PLT entries. It is
8770 usually better to do the former, unless the relocation is
8771 against a read-only section. */
8772 if ((bfd_link_pic (info
)
8774 && !htab
->is_vxworks
8775 && strcmp (h
->root
.root
.string
, "__gnu_local_gp") != 0
8776 && !(!info
->nocopyreloc
8777 && !PIC_OBJECT_P (abfd
)
8778 && MIPS_ELF_READONLY_SECTION (sec
))))
8779 && (sec
->flags
& SEC_ALLOC
) != 0)
8781 can_make_dynamic_p
= TRUE
;
8783 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
8789 case R_MIPS_PC21_S2
:
8790 case R_MIPS_PC26_S2
:
8792 case R_MIPS16_PC16_S1
:
8793 case R_MICROMIPS_26_S1
:
8794 case R_MICROMIPS_PC7_S1
:
8795 case R_MICROMIPS_PC10_S1
:
8796 case R_MICROMIPS_PC16_S1
:
8797 case R_MICROMIPS_PC23_S2
:
8798 call_reloc_p
= TRUE
;
8804 if (constrain_symbol_p
)
8806 if (!can_make_dynamic_p
)
8807 ((struct mips_elf_link_hash_entry
*) h
)->has_static_relocs
= 1;
8810 h
->pointer_equality_needed
= 1;
8812 /* We must not create a stub for a symbol that has
8813 relocations related to taking the function's address.
8814 This doesn't apply to VxWorks, where CALL relocs refer
8815 to a .got.plt entry instead of a normal .got entry. */
8816 if (!htab
->is_vxworks
&& (!can_make_dynamic_p
|| !call_reloc_p
))
8817 ((struct mips_elf_link_hash_entry
*) h
)->no_fn_stub
= TRUE
;
8820 /* Relocations against the special VxWorks __GOTT_BASE__ and
8821 __GOTT_INDEX__ symbols must be left to the loader. Allocate
8822 room for them in .rela.dyn. */
8823 if (is_gott_symbol (info
, h
))
8827 sreloc
= mips_elf_rel_dyn_section (info
, TRUE
);
8831 mips_elf_allocate_dynamic_relocations (dynobj
, info
, 1);
8832 if (MIPS_ELF_READONLY_SECTION (sec
))
8833 /* We tell the dynamic linker that there are
8834 relocations against the text segment. */
8835 info
->flags
|= DF_TEXTREL
;
8838 else if (call_lo16_reloc_p (r_type
)
8839 || got_lo16_reloc_p (r_type
)
8840 || got_disp_reloc_p (r_type
)
8841 || (got16_reloc_p (r_type
) && htab
->is_vxworks
))
8843 /* We may need a local GOT entry for this relocation. We
8844 don't count R_MIPS_GOT_PAGE because we can estimate the
8845 maximum number of pages needed by looking at the size of
8846 the segment. Similar comments apply to R_MIPS*_GOT16 and
8847 R_MIPS*_CALL16, except on VxWorks, where GOT relocations
8848 always evaluate to "G". We don't count R_MIPS_GOT_HI16, or
8849 R_MIPS_CALL_HI16 because these are always followed by an
8850 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
8851 if (!mips_elf_record_local_got_symbol (abfd
, r_symndx
,
8852 rel
->r_addend
, info
, r_type
))
8857 && mips_elf_relocation_needs_la25_stub (abfd
, r_type
,
8858 ELF_ST_IS_MIPS16 (h
->other
)))
8859 ((struct mips_elf_link_hash_entry
*) h
)->has_nonpic_branches
= TRUE
;
8864 case R_MIPS16_CALL16
:
8865 case R_MICROMIPS_CALL16
:
8869 /* xgettext:c-format */
8870 (_("%pB: CALL16 reloc at %#" PRIx64
" not against global symbol"),
8871 abfd
, (uint64_t) rel
->r_offset
);
8872 bfd_set_error (bfd_error_bad_value
);
8877 case R_MIPS_CALL_HI16
:
8878 case R_MIPS_CALL_LO16
:
8879 case R_MICROMIPS_CALL_HI16
:
8880 case R_MICROMIPS_CALL_LO16
:
8883 /* Make sure there is room in the regular GOT to hold the
8884 function's address. We may eliminate it in favour of
8885 a .got.plt entry later; see mips_elf_count_got_symbols. */
8886 if (!mips_elf_record_global_got_symbol (h
, abfd
, info
, TRUE
,
8890 /* We need a stub, not a plt entry for the undefined
8891 function. But we record it as if it needs plt. See
8892 _bfd_elf_adjust_dynamic_symbol. */
8898 case R_MIPS_GOT_PAGE
:
8899 case R_MICROMIPS_GOT_PAGE
:
8900 case R_MIPS16_GOT16
:
8902 case R_MIPS_GOT_HI16
:
8903 case R_MIPS_GOT_LO16
:
8904 case R_MICROMIPS_GOT16
:
8905 case R_MICROMIPS_GOT_HI16
:
8906 case R_MICROMIPS_GOT_LO16
:
8907 if (!h
|| got_page_reloc_p (r_type
))
8909 /* This relocation needs (or may need, if h != NULL) a
8910 page entry in the GOT. For R_MIPS_GOT_PAGE we do not
8911 know for sure until we know whether the symbol is
8913 if (mips_elf_rel_relocation_p (abfd
, sec
, relocs
, rel
))
8915 if (!mips_elf_get_section_contents (abfd
, sec
, &contents
))
8917 howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, r_type
, FALSE
);
8918 addend
= mips_elf_read_rel_addend (abfd
, rel
,
8920 if (got16_reloc_p (r_type
))
8921 mips_elf_add_lo16_rel_addend (abfd
, rel
, rel_end
,
8924 addend
<<= howto
->rightshift
;
8927 addend
= rel
->r_addend
;
8928 if (!mips_elf_record_got_page_ref (info
, abfd
, r_symndx
,
8934 struct mips_elf_link_hash_entry
*hmips
=
8935 (struct mips_elf_link_hash_entry
*) h
;
8937 /* This symbol is definitely not overridable. */
8938 if (hmips
->root
.def_regular
8939 && ! (bfd_link_pic (info
) && ! info
->symbolic
8940 && ! hmips
->root
.forced_local
))
8944 /* If this is a global, overridable symbol, GOT_PAGE will
8945 decay to GOT_DISP, so we'll need a GOT entry for it. */
8948 case R_MIPS_GOT_DISP
:
8949 case R_MICROMIPS_GOT_DISP
:
8950 if (h
&& !mips_elf_record_global_got_symbol (h
, abfd
, info
,
8955 case R_MIPS_TLS_GOTTPREL
:
8956 case R_MIPS16_TLS_GOTTPREL
:
8957 case R_MICROMIPS_TLS_GOTTPREL
:
8958 if (bfd_link_pic (info
))
8959 info
->flags
|= DF_STATIC_TLS
;
8962 case R_MIPS_TLS_LDM
:
8963 case R_MIPS16_TLS_LDM
:
8964 case R_MICROMIPS_TLS_LDM
:
8965 if (tls_ldm_reloc_p (r_type
))
8967 r_symndx
= STN_UNDEF
;
8973 case R_MIPS16_TLS_GD
:
8974 case R_MICROMIPS_TLS_GD
:
8975 /* This symbol requires a global offset table entry, or two
8976 for TLS GD relocations. */
8979 if (!mips_elf_record_global_got_symbol (h
, abfd
, info
,
8985 if (!mips_elf_record_local_got_symbol (abfd
, r_symndx
,
8995 /* In VxWorks executables, references to external symbols
8996 are handled using copy relocs or PLT stubs, so there's
8997 no need to add a .rela.dyn entry for this relocation. */
8998 if (can_make_dynamic_p
)
9002 sreloc
= mips_elf_rel_dyn_section (info
, TRUE
);
9006 if (bfd_link_pic (info
) && h
== NULL
)
9008 /* When creating a shared object, we must copy these
9009 reloc types into the output file as R_MIPS_REL32
9010 relocs. Make room for this reloc in .rel(a).dyn. */
9011 mips_elf_allocate_dynamic_relocations (dynobj
, info
, 1);
9012 if (MIPS_ELF_READONLY_SECTION (sec
))
9013 /* We tell the dynamic linker that there are
9014 relocations against the text segment. */
9015 info
->flags
|= DF_TEXTREL
;
9019 struct mips_elf_link_hash_entry
*hmips
;
9021 /* For a shared object, we must copy this relocation
9022 unless the symbol turns out to be undefined and
9023 weak with non-default visibility, in which case
9024 it will be left as zero.
9026 We could elide R_MIPS_REL32 for locally binding symbols
9027 in shared libraries, but do not yet do so.
9029 For an executable, we only need to copy this
9030 reloc if the symbol is defined in a dynamic
9032 hmips
= (struct mips_elf_link_hash_entry
*) h
;
9033 ++hmips
->possibly_dynamic_relocs
;
9034 if (MIPS_ELF_READONLY_SECTION (sec
))
9035 /* We need it to tell the dynamic linker if there
9036 are relocations against the text segment. */
9037 hmips
->readonly_reloc
= TRUE
;
9041 if (SGI_COMPAT (abfd
))
9042 mips_elf_hash_table (info
)->compact_rel_size
+=
9043 sizeof (Elf32_External_crinfo
);
9047 case R_MIPS_GPREL16
:
9048 case R_MIPS_LITERAL
:
9049 case R_MIPS_GPREL32
:
9050 case R_MICROMIPS_26_S1
:
9051 case R_MICROMIPS_GPREL16
:
9052 case R_MICROMIPS_LITERAL
:
9053 case R_MICROMIPS_GPREL7_S2
:
9054 if (SGI_COMPAT (abfd
))
9055 mips_elf_hash_table (info
)->compact_rel_size
+=
9056 sizeof (Elf32_External_crinfo
);
9059 /* This relocation describes the C++ object vtable hierarchy.
9060 Reconstruct it for later use during GC. */
9061 case R_MIPS_GNU_VTINHERIT
:
9062 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
9066 /* This relocation describes which C++ vtable entries are actually
9067 used. Record for later use during GC. */
9068 case R_MIPS_GNU_VTENTRY
:
9069 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
9077 /* Record the need for a PLT entry. At this point we don't know
9078 yet if we are going to create a PLT in the first place, but
9079 we only record whether the relocation requires a standard MIPS
9080 or a compressed code entry anyway. If we don't make a PLT after
9081 all, then we'll just ignore these arrangements. Likewise if
9082 a PLT entry is not created because the symbol is satisfied
9085 && (branch_reloc_p (r_type
)
9086 || mips16_branch_reloc_p (r_type
)
9087 || micromips_branch_reloc_p (r_type
))
9088 && !SYMBOL_CALLS_LOCAL (info
, h
))
9090 if (h
->plt
.plist
== NULL
)
9091 h
->plt
.plist
= mips_elf_make_plt_record (abfd
);
9092 if (h
->plt
.plist
== NULL
)
9095 if (branch_reloc_p (r_type
))
9096 h
->plt
.plist
->need_mips
= TRUE
;
9098 h
->plt
.plist
->need_comp
= TRUE
;
9101 /* See if this reloc would need to refer to a MIPS16 hard-float stub,
9102 if there is one. We only need to handle global symbols here;
9103 we decide whether to keep or delete stubs for local symbols
9104 when processing the stub's relocations. */
9106 && !mips16_call_reloc_p (r_type
)
9107 && !section_allows_mips16_refs_p (sec
))
9109 struct mips_elf_link_hash_entry
*mh
;
9111 mh
= (struct mips_elf_link_hash_entry
*) h
;
9112 mh
->need_fn_stub
= TRUE
;
9115 /* Refuse some position-dependent relocations when creating a
9116 shared library. Do not refuse R_MIPS_32 / R_MIPS_64; they're
9117 not PIC, but we can create dynamic relocations and the result
9118 will be fine. Also do not refuse R_MIPS_LO16, which can be
9119 combined with R_MIPS_GOT16. */
9120 if (bfd_link_pic (info
))
9124 case R_MIPS_TLS_TPREL_HI16
:
9125 case R_MIPS16_TLS_TPREL_HI16
:
9126 case R_MICROMIPS_TLS_TPREL_HI16
:
9127 case R_MIPS_TLS_TPREL_LO16
:
9128 case R_MIPS16_TLS_TPREL_LO16
:
9129 case R_MICROMIPS_TLS_TPREL_LO16
:
9130 /* These are okay in PIE, but not in a shared library. */
9131 if (bfd_link_executable (info
))
9139 case R_MIPS_HIGHEST
:
9140 case R_MICROMIPS_HI16
:
9141 case R_MICROMIPS_HIGHER
:
9142 case R_MICROMIPS_HIGHEST
:
9143 /* Don't refuse a high part relocation if it's against
9144 no symbol (e.g. part of a compound relocation). */
9145 if (r_symndx
== STN_UNDEF
)
9148 /* Likewise an absolute symbol. */
9149 if (h
!= NULL
&& bfd_is_abs_symbol (&h
->root
))
9152 /* R_MIPS_HI16 against _gp_disp is used for $gp setup,
9153 and has a special meaning. */
9154 if (!NEWABI_P (abfd
) && h
!= NULL
9155 && strcmp (h
->root
.root
.string
, "_gp_disp") == 0)
9158 /* Likewise __GOTT_BASE__ and __GOTT_INDEX__ on VxWorks. */
9159 if (is_gott_symbol (info
, h
))
9166 case R_MICROMIPS_26_S1
:
9167 howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, r_type
, NEWABI_P (abfd
));
9168 /* An error for unsupported relocations is raised as part
9169 of the above search, so we can skip the following. */
9171 info
->callbacks
->einfo
9172 /* xgettext:c-format */
9173 (_("%X%H: relocation %s against `%s' cannot be used"
9174 " when making a shared object; recompile with -fPIC\n"),
9175 abfd
, sec
, rel
->r_offset
, howto
->name
,
9176 (h
) ? h
->root
.root
.string
: "a local symbol");
9187 /* Allocate space for global sym dynamic relocs. */
9190 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
9192 struct bfd_link_info
*info
= inf
;
9194 struct mips_elf_link_hash_entry
*hmips
;
9195 struct mips_elf_link_hash_table
*htab
;
9197 htab
= mips_elf_hash_table (info
);
9198 BFD_ASSERT (htab
!= NULL
);
9200 dynobj
= elf_hash_table (info
)->dynobj
;
9201 hmips
= (struct mips_elf_link_hash_entry
*) h
;
9203 /* VxWorks executables are handled elsewhere; we only need to
9204 allocate relocations in shared objects. */
9205 if (htab
->is_vxworks
&& !bfd_link_pic (info
))
9208 /* Ignore indirect symbols. All relocations against such symbols
9209 will be redirected to the target symbol. */
9210 if (h
->root
.type
== bfd_link_hash_indirect
)
9213 /* If this symbol is defined in a dynamic object, or we are creating
9214 a shared library, we will need to copy any R_MIPS_32 or
9215 R_MIPS_REL32 relocs against it into the output file. */
9216 if (! bfd_link_relocatable (info
)
9217 && hmips
->possibly_dynamic_relocs
!= 0
9218 && (h
->root
.type
== bfd_link_hash_defweak
9219 || (!h
->def_regular
&& !ELF_COMMON_DEF_P (h
))
9220 || bfd_link_pic (info
)))
9222 bfd_boolean do_copy
= TRUE
;
9224 if (h
->root
.type
== bfd_link_hash_undefweak
)
9226 /* Do not copy relocations for undefined weak symbols that
9227 we are not going to export. */
9228 if (UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
9231 /* Make sure undefined weak symbols are output as a dynamic
9233 else if (h
->dynindx
== -1 && !h
->forced_local
)
9235 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
9242 /* Even though we don't directly need a GOT entry for this symbol,
9243 the SVR4 psABI requires it to have a dynamic symbol table
9244 index greater that DT_MIPS_GOTSYM if there are dynamic
9245 relocations against it.
9247 VxWorks does not enforce the same mapping between the GOT
9248 and the symbol table, so the same requirement does not
9250 if (!htab
->is_vxworks
)
9252 if (hmips
->global_got_area
> GGA_RELOC_ONLY
)
9253 hmips
->global_got_area
= GGA_RELOC_ONLY
;
9254 hmips
->got_only_for_calls
= FALSE
;
9257 mips_elf_allocate_dynamic_relocations
9258 (dynobj
, info
, hmips
->possibly_dynamic_relocs
);
9259 if (hmips
->readonly_reloc
)
9260 /* We tell the dynamic linker that there are relocations
9261 against the text segment. */
9262 info
->flags
|= DF_TEXTREL
;
9269 /* Adjust a symbol defined by a dynamic object and referenced by a
9270 regular object. The current definition is in some section of the
9271 dynamic object, but we're not including those sections. We have to
9272 change the definition to something the rest of the link can
9276 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
9277 struct elf_link_hash_entry
*h
)
9280 struct mips_elf_link_hash_entry
*hmips
;
9281 struct mips_elf_link_hash_table
*htab
;
9284 htab
= mips_elf_hash_table (info
);
9285 BFD_ASSERT (htab
!= NULL
);
9287 dynobj
= elf_hash_table (info
)->dynobj
;
9288 hmips
= (struct mips_elf_link_hash_entry
*) h
;
9290 /* Make sure we know what is going on here. */
9293 && ! h
->is_weakalias
9294 && (! h
->def_dynamic
9296 || h
->def_regular
)))
9298 if (h
->type
== STT_GNU_IFUNC
)
9299 _bfd_error_handler (_("IFUNC symbol %s in dynamic symbol table - IFUNCS are not supported"),
9300 h
->root
.root
.string
);
9302 _bfd_error_handler (_("non-dynamic symbol %s in dynamic symbol table"),
9303 h
->root
.root
.string
);
9307 hmips
= (struct mips_elf_link_hash_entry
*) h
;
9309 /* If there are call relocations against an externally-defined symbol,
9310 see whether we can create a MIPS lazy-binding stub for it. We can
9311 only do this if all references to the function are through call
9312 relocations, and in that case, the traditional lazy-binding stubs
9313 are much more efficient than PLT entries.
9315 Traditional stubs are only available on SVR4 psABI-based systems;
9316 VxWorks always uses PLTs instead. */
9317 if (!htab
->is_vxworks
&& h
->needs_plt
&& !hmips
->no_fn_stub
)
9319 if (! elf_hash_table (info
)->dynamic_sections_created
)
9322 /* If this symbol is not defined in a regular file, then set
9323 the symbol to the stub location. This is required to make
9324 function pointers compare as equal between the normal
9325 executable and the shared library. */
9327 && !bfd_is_abs_section (htab
->sstubs
->output_section
))
9329 hmips
->needs_lazy_stub
= TRUE
;
9330 htab
->lazy_stub_count
++;
9334 /* As above, VxWorks requires PLT entries for externally-defined
9335 functions that are only accessed through call relocations.
9337 Both VxWorks and non-VxWorks targets also need PLT entries if there
9338 are static-only relocations against an externally-defined function.
9339 This can technically occur for shared libraries if there are
9340 branches to the symbol, although it is unlikely that this will be
9341 used in practice due to the short ranges involved. It can occur
9342 for any relative or absolute relocation in executables; in that
9343 case, the PLT entry becomes the function's canonical address. */
9344 else if (((h
->needs_plt
&& !hmips
->no_fn_stub
)
9345 || (h
->type
== STT_FUNC
&& hmips
->has_static_relocs
))
9346 && htab
->use_plts_and_copy_relocs
9347 && !SYMBOL_CALLS_LOCAL (info
, h
)
9348 && !(ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
9349 && h
->root
.type
== bfd_link_hash_undefweak
))
9351 bfd_boolean micromips_p
= MICROMIPS_P (info
->output_bfd
);
9352 bfd_boolean newabi_p
= NEWABI_P (info
->output_bfd
);
9354 /* If this is the first symbol to need a PLT entry, then make some
9355 basic setup. Also work out PLT entry sizes. We'll need them
9356 for PLT offset calculations. */
9357 if (htab
->plt_mips_offset
+ htab
->plt_comp_offset
== 0)
9359 BFD_ASSERT (htab
->root
.sgotplt
->size
== 0);
9360 BFD_ASSERT (htab
->plt_got_index
== 0);
9362 /* If we're using the PLT additions to the psABI, each PLT
9363 entry is 16 bytes and the PLT0 entry is 32 bytes.
9364 Encourage better cache usage by aligning. We do this
9365 lazily to avoid pessimizing traditional objects. */
9366 if (!htab
->is_vxworks
9367 && !bfd_set_section_alignment (htab
->root
.splt
, 5))
9370 /* Make sure that .got.plt is word-aligned. We do this lazily
9371 for the same reason as above. */
9372 if (!bfd_set_section_alignment (htab
->root
.sgotplt
,
9373 MIPS_ELF_LOG_FILE_ALIGN (dynobj
)))
9376 /* On non-VxWorks targets, the first two entries in .got.plt
9378 if (!htab
->is_vxworks
)
9380 += (get_elf_backend_data (dynobj
)->got_header_size
9381 / MIPS_ELF_GOT_SIZE (dynobj
));
9383 /* On VxWorks, also allocate room for the header's
9384 .rela.plt.unloaded entries. */
9385 if (htab
->is_vxworks
&& !bfd_link_pic (info
))
9386 htab
->srelplt2
->size
+= 2 * sizeof (Elf32_External_Rela
);
9388 /* Now work out the sizes of individual PLT entries. */
9389 if (htab
->is_vxworks
&& bfd_link_pic (info
))
9390 htab
->plt_mips_entry_size
9391 = 4 * ARRAY_SIZE (mips_vxworks_shared_plt_entry
);
9392 else if (htab
->is_vxworks
)
9393 htab
->plt_mips_entry_size
9394 = 4 * ARRAY_SIZE (mips_vxworks_exec_plt_entry
);
9396 htab
->plt_mips_entry_size
9397 = 4 * ARRAY_SIZE (mips_exec_plt_entry
);
9398 else if (!micromips_p
)
9400 htab
->plt_mips_entry_size
9401 = 4 * ARRAY_SIZE (mips_exec_plt_entry
);
9402 htab
->plt_comp_entry_size
9403 = 2 * ARRAY_SIZE (mips16_o32_exec_plt_entry
);
9405 else if (htab
->insn32
)
9407 htab
->plt_mips_entry_size
9408 = 4 * ARRAY_SIZE (mips_exec_plt_entry
);
9409 htab
->plt_comp_entry_size
9410 = 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt_entry
);
9414 htab
->plt_mips_entry_size
9415 = 4 * ARRAY_SIZE (mips_exec_plt_entry
);
9416 htab
->plt_comp_entry_size
9417 = 2 * ARRAY_SIZE (micromips_o32_exec_plt_entry
);
9421 if (h
->plt
.plist
== NULL
)
9422 h
->plt
.plist
= mips_elf_make_plt_record (dynobj
);
9423 if (h
->plt
.plist
== NULL
)
9426 /* There are no defined MIPS16 or microMIPS PLT entries for VxWorks,
9427 n32 or n64, so always use a standard entry there.
9429 If the symbol has a MIPS16 call stub and gets a PLT entry, then
9430 all MIPS16 calls will go via that stub, and there is no benefit
9431 to having a MIPS16 entry. And in the case of call_stub a
9432 standard entry actually has to be used as the stub ends with a J
9437 || hmips
->call_fp_stub
)
9439 h
->plt
.plist
->need_mips
= TRUE
;
9440 h
->plt
.plist
->need_comp
= FALSE
;
9443 /* Otherwise, if there are no direct calls to the function, we
9444 have a free choice of whether to use standard or compressed
9445 entries. Prefer microMIPS entries if the object is known to
9446 contain microMIPS code, so that it becomes possible to create
9447 pure microMIPS binaries. Prefer standard entries otherwise,
9448 because MIPS16 ones are no smaller and are usually slower. */
9449 if (!h
->plt
.plist
->need_mips
&& !h
->plt
.plist
->need_comp
)
9452 h
->plt
.plist
->need_comp
= TRUE
;
9454 h
->plt
.plist
->need_mips
= TRUE
;
9457 if (h
->plt
.plist
->need_mips
)
9459 h
->plt
.plist
->mips_offset
= htab
->plt_mips_offset
;
9460 htab
->plt_mips_offset
+= htab
->plt_mips_entry_size
;
9462 if (h
->plt
.plist
->need_comp
)
9464 h
->plt
.plist
->comp_offset
= htab
->plt_comp_offset
;
9465 htab
->plt_comp_offset
+= htab
->plt_comp_entry_size
;
9468 /* Reserve the corresponding .got.plt entry now too. */
9469 h
->plt
.plist
->gotplt_index
= htab
->plt_got_index
++;
9471 /* If the output file has no definition of the symbol, set the
9472 symbol's value to the address of the stub. */
9473 if (!bfd_link_pic (info
) && !h
->def_regular
)
9474 hmips
->use_plt_entry
= TRUE
;
9476 /* Make room for the R_MIPS_JUMP_SLOT relocation. */
9477 htab
->root
.srelplt
->size
+= (htab
->is_vxworks
9478 ? MIPS_ELF_RELA_SIZE (dynobj
)
9479 : MIPS_ELF_REL_SIZE (dynobj
));
9481 /* Make room for the .rela.plt.unloaded relocations. */
9482 if (htab
->is_vxworks
&& !bfd_link_pic (info
))
9483 htab
->srelplt2
->size
+= 3 * sizeof (Elf32_External_Rela
);
9485 /* All relocations against this symbol that could have been made
9486 dynamic will now refer to the PLT entry instead. */
9487 hmips
->possibly_dynamic_relocs
= 0;
9492 /* If this is a weak symbol, and there is a real definition, the
9493 processor independent code will have arranged for us to see the
9494 real definition first, and we can just use the same value. */
9495 if (h
->is_weakalias
)
9497 struct elf_link_hash_entry
*def
= weakdef (h
);
9498 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
9499 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
9500 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
9504 /* Otherwise, there is nothing further to do for symbols defined
9505 in regular objects. */
9509 /* There's also nothing more to do if we'll convert all relocations
9510 against this symbol into dynamic relocations. */
9511 if (!hmips
->has_static_relocs
)
9514 /* We're now relying on copy relocations. Complain if we have
9515 some that we can't convert. */
9516 if (!htab
->use_plts_and_copy_relocs
|| bfd_link_pic (info
))
9518 _bfd_error_handler (_("non-dynamic relocations refer to "
9519 "dynamic symbol %s"),
9520 h
->root
.root
.string
);
9521 bfd_set_error (bfd_error_bad_value
);
9525 /* We must allocate the symbol in our .dynbss section, which will
9526 become part of the .bss section of the executable. There will be
9527 an entry for this symbol in the .dynsym section. The dynamic
9528 object will contain position independent code, so all references
9529 from the dynamic object to this symbol will go through the global
9530 offset table. The dynamic linker will use the .dynsym entry to
9531 determine the address it must put in the global offset table, so
9532 both the dynamic object and the regular object will refer to the
9533 same memory location for the variable. */
9535 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
9537 s
= htab
->root
.sdynrelro
;
9538 srel
= htab
->root
.sreldynrelro
;
9542 s
= htab
->root
.sdynbss
;
9543 srel
= htab
->root
.srelbss
;
9545 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
9547 if (htab
->is_vxworks
)
9548 srel
->size
+= sizeof (Elf32_External_Rela
);
9550 mips_elf_allocate_dynamic_relocations (dynobj
, info
, 1);
9554 /* All relocations against this symbol that could have been made
9555 dynamic will now refer to the local copy instead. */
9556 hmips
->possibly_dynamic_relocs
= 0;
9558 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
9561 /* This function is called after all the input files have been read,
9562 and the input sections have been assigned to output sections. We
9563 check for any mips16 stub sections that we can discard. */
9566 _bfd_mips_elf_always_size_sections (bfd
*output_bfd
,
9567 struct bfd_link_info
*info
)
9570 struct mips_elf_link_hash_table
*htab
;
9571 struct mips_htab_traverse_info hti
;
9573 htab
= mips_elf_hash_table (info
);
9574 BFD_ASSERT (htab
!= NULL
);
9576 /* The .reginfo section has a fixed size. */
9577 sect
= bfd_get_section_by_name (output_bfd
, ".reginfo");
9580 bfd_set_section_size (sect
, sizeof (Elf32_External_RegInfo
));
9581 sect
->flags
|= SEC_FIXED_SIZE
| SEC_HAS_CONTENTS
;
9584 /* The .MIPS.abiflags section has a fixed size. */
9585 sect
= bfd_get_section_by_name (output_bfd
, ".MIPS.abiflags");
9588 bfd_set_section_size (sect
, sizeof (Elf_External_ABIFlags_v0
));
9589 sect
->flags
|= SEC_FIXED_SIZE
| SEC_HAS_CONTENTS
;
9593 hti
.output_bfd
= output_bfd
;
9595 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
9596 mips_elf_check_symbols
, &hti
);
9603 /* If the link uses a GOT, lay it out and work out its size. */
9606 mips_elf_lay_out_got (bfd
*output_bfd
, struct bfd_link_info
*info
)
9610 struct mips_got_info
*g
;
9611 bfd_size_type loadable_size
= 0;
9612 bfd_size_type page_gotno
;
9614 struct mips_elf_traverse_got_arg tga
;
9615 struct mips_elf_link_hash_table
*htab
;
9617 htab
= mips_elf_hash_table (info
);
9618 BFD_ASSERT (htab
!= NULL
);
9620 s
= htab
->root
.sgot
;
9624 dynobj
= elf_hash_table (info
)->dynobj
;
9627 /* Allocate room for the reserved entries. VxWorks always reserves
9628 3 entries; other objects only reserve 2 entries. */
9629 BFD_ASSERT (g
->assigned_low_gotno
== 0);
9630 if (htab
->is_vxworks
)
9631 htab
->reserved_gotno
= 3;
9633 htab
->reserved_gotno
= 2;
9634 g
->local_gotno
+= htab
->reserved_gotno
;
9635 g
->assigned_low_gotno
= htab
->reserved_gotno
;
9637 /* Decide which symbols need to go in the global part of the GOT and
9638 count the number of reloc-only GOT symbols. */
9639 mips_elf_link_hash_traverse (htab
, mips_elf_count_got_symbols
, info
);
9641 if (!mips_elf_resolve_final_got_entries (info
, g
))
9644 /* Calculate the total loadable size of the output. That
9645 will give us the maximum number of GOT_PAGE entries
9647 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
9649 asection
*subsection
;
9651 for (subsection
= ibfd
->sections
;
9653 subsection
= subsection
->next
)
9655 if ((subsection
->flags
& SEC_ALLOC
) == 0)
9657 loadable_size
+= ((subsection
->size
+ 0xf)
9658 &~ (bfd_size_type
) 0xf);
9662 if (htab
->is_vxworks
)
9663 /* There's no need to allocate page entries for VxWorks; R_MIPS*_GOT16
9664 relocations against local symbols evaluate to "G", and the EABI does
9665 not include R_MIPS_GOT_PAGE. */
9668 /* Assume there are two loadable segments consisting of contiguous
9669 sections. Is 5 enough? */
9670 page_gotno
= (loadable_size
>> 16) + 5;
9672 /* Choose the smaller of the two page estimates; both are intended to be
9674 if (page_gotno
> g
->page_gotno
)
9675 page_gotno
= g
->page_gotno
;
9677 g
->local_gotno
+= page_gotno
;
9678 g
->assigned_high_gotno
= g
->local_gotno
- 1;
9680 s
->size
+= g
->local_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
9681 s
->size
+= g
->global_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
9682 s
->size
+= g
->tls_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
9684 /* VxWorks does not support multiple GOTs. It initializes $gp to
9685 __GOTT_BASE__[__GOTT_INDEX__], the value of which is set by the
9687 if (!htab
->is_vxworks
&& s
->size
> MIPS_ELF_GOT_MAX_SIZE (info
))
9689 if (!mips_elf_multi_got (output_bfd
, info
, s
, page_gotno
))
9694 /* Record that all bfds use G. This also has the effect of freeing
9695 the per-bfd GOTs, which we no longer need. */
9696 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
9697 if (mips_elf_bfd_got (ibfd
, FALSE
))
9698 mips_elf_replace_bfd_got (ibfd
, g
);
9699 mips_elf_replace_bfd_got (output_bfd
, g
);
9701 /* Set up TLS entries. */
9702 g
->tls_assigned_gotno
= g
->global_gotno
+ g
->local_gotno
;
9705 tga
.value
= MIPS_ELF_GOT_SIZE (output_bfd
);
9706 htab_traverse (g
->got_entries
, mips_elf_initialize_tls_index
, &tga
);
9709 BFD_ASSERT (g
->tls_assigned_gotno
9710 == g
->global_gotno
+ g
->local_gotno
+ g
->tls_gotno
);
9712 /* Each VxWorks GOT entry needs an explicit relocation. */
9713 if (htab
->is_vxworks
&& bfd_link_pic (info
))
9714 g
->relocs
+= g
->global_gotno
+ g
->local_gotno
- htab
->reserved_gotno
;
9716 /* Allocate room for the TLS relocations. */
9718 mips_elf_allocate_dynamic_relocations (dynobj
, info
, g
->relocs
);
9724 /* Estimate the size of the .MIPS.stubs section. */
9727 mips_elf_estimate_stub_size (bfd
*output_bfd
, struct bfd_link_info
*info
)
9729 struct mips_elf_link_hash_table
*htab
;
9730 bfd_size_type dynsymcount
;
9732 htab
= mips_elf_hash_table (info
);
9733 BFD_ASSERT (htab
!= NULL
);
9735 if (htab
->lazy_stub_count
== 0)
9738 /* IRIX rld assumes that a function stub isn't at the end of the .text
9739 section, so add a dummy entry to the end. */
9740 htab
->lazy_stub_count
++;
9742 /* Get a worst-case estimate of the number of dynamic symbols needed.
9743 At this point, dynsymcount does not account for section symbols
9744 and count_section_dynsyms may overestimate the number that will
9746 dynsymcount
= (elf_hash_table (info
)->dynsymcount
9747 + count_section_dynsyms (output_bfd
, info
));
9749 /* Determine the size of one stub entry. There's no disadvantage
9750 from using microMIPS code here, so for the sake of pure-microMIPS
9751 binaries we prefer it whenever there's any microMIPS code in
9752 output produced at all. This has a benefit of stubs being
9753 shorter by 4 bytes each too, unless in the insn32 mode. */
9754 if (!MICROMIPS_P (output_bfd
))
9755 htab
->function_stub_size
= (dynsymcount
> 0x10000
9756 ? MIPS_FUNCTION_STUB_BIG_SIZE
9757 : MIPS_FUNCTION_STUB_NORMAL_SIZE
);
9758 else if (htab
->insn32
)
9759 htab
->function_stub_size
= (dynsymcount
> 0x10000
9760 ? MICROMIPS_INSN32_FUNCTION_STUB_BIG_SIZE
9761 : MICROMIPS_INSN32_FUNCTION_STUB_NORMAL_SIZE
);
9763 htab
->function_stub_size
= (dynsymcount
> 0x10000
9764 ? MICROMIPS_FUNCTION_STUB_BIG_SIZE
9765 : MICROMIPS_FUNCTION_STUB_NORMAL_SIZE
);
9767 htab
->sstubs
->size
= htab
->lazy_stub_count
* htab
->function_stub_size
;
9770 /* A mips_elf_link_hash_traverse callback for which DATA points to a
9771 mips_htab_traverse_info. If H needs a traditional MIPS lazy-binding
9772 stub, allocate an entry in the stubs section. */
9775 mips_elf_allocate_lazy_stub (struct mips_elf_link_hash_entry
*h
, void *data
)
9777 struct mips_htab_traverse_info
*hti
= data
;
9778 struct mips_elf_link_hash_table
*htab
;
9779 struct bfd_link_info
*info
;
9783 output_bfd
= hti
->output_bfd
;
9784 htab
= mips_elf_hash_table (info
);
9785 BFD_ASSERT (htab
!= NULL
);
9787 if (h
->needs_lazy_stub
)
9789 bfd_boolean micromips_p
= MICROMIPS_P (output_bfd
);
9790 unsigned int other
= micromips_p
? STO_MICROMIPS
: 0;
9791 bfd_vma isa_bit
= micromips_p
;
9793 BFD_ASSERT (htab
->root
.dynobj
!= NULL
);
9794 if (h
->root
.plt
.plist
== NULL
)
9795 h
->root
.plt
.plist
= mips_elf_make_plt_record (htab
->sstubs
->owner
);
9796 if (h
->root
.plt
.plist
== NULL
)
9801 h
->root
.root
.u
.def
.section
= htab
->sstubs
;
9802 h
->root
.root
.u
.def
.value
= htab
->sstubs
->size
+ isa_bit
;
9803 h
->root
.plt
.plist
->stub_offset
= htab
->sstubs
->size
;
9804 h
->root
.other
= other
;
9805 htab
->sstubs
->size
+= htab
->function_stub_size
;
9810 /* Allocate offsets in the stubs section to each symbol that needs one.
9811 Set the final size of the .MIPS.stub section. */
9814 mips_elf_lay_out_lazy_stubs (struct bfd_link_info
*info
)
9816 bfd
*output_bfd
= info
->output_bfd
;
9817 bfd_boolean micromips_p
= MICROMIPS_P (output_bfd
);
9818 unsigned int other
= micromips_p
? STO_MICROMIPS
: 0;
9819 bfd_vma isa_bit
= micromips_p
;
9820 struct mips_elf_link_hash_table
*htab
;
9821 struct mips_htab_traverse_info hti
;
9822 struct elf_link_hash_entry
*h
;
9825 htab
= mips_elf_hash_table (info
);
9826 BFD_ASSERT (htab
!= NULL
);
9828 if (htab
->lazy_stub_count
== 0)
9831 htab
->sstubs
->size
= 0;
9833 hti
.output_bfd
= output_bfd
;
9835 mips_elf_link_hash_traverse (htab
, mips_elf_allocate_lazy_stub
, &hti
);
9838 htab
->sstubs
->size
+= htab
->function_stub_size
;
9839 BFD_ASSERT (htab
->sstubs
->size
9840 == htab
->lazy_stub_count
* htab
->function_stub_size
);
9842 dynobj
= elf_hash_table (info
)->dynobj
;
9843 BFD_ASSERT (dynobj
!= NULL
);
9844 h
= _bfd_elf_define_linkage_sym (dynobj
, info
, htab
->sstubs
, "_MIPS_STUBS_");
9847 h
->root
.u
.def
.value
= isa_bit
;
9854 /* A mips_elf_link_hash_traverse callback for which DATA points to a
9855 bfd_link_info. If H uses the address of a PLT entry as the value
9856 of the symbol, then set the entry in the symbol table now. Prefer
9857 a standard MIPS PLT entry. */
9860 mips_elf_set_plt_sym_value (struct mips_elf_link_hash_entry
*h
, void *data
)
9862 struct bfd_link_info
*info
= data
;
9863 bfd_boolean micromips_p
= MICROMIPS_P (info
->output_bfd
);
9864 struct mips_elf_link_hash_table
*htab
;
9869 htab
= mips_elf_hash_table (info
);
9870 BFD_ASSERT (htab
!= NULL
);
9872 if (h
->use_plt_entry
)
9874 BFD_ASSERT (h
->root
.plt
.plist
!= NULL
);
9875 BFD_ASSERT (h
->root
.plt
.plist
->mips_offset
!= MINUS_ONE
9876 || h
->root
.plt
.plist
->comp_offset
!= MINUS_ONE
);
9878 val
= htab
->plt_header_size
;
9879 if (h
->root
.plt
.plist
->mips_offset
!= MINUS_ONE
)
9882 val
+= h
->root
.plt
.plist
->mips_offset
;
9888 val
+= htab
->plt_mips_offset
+ h
->root
.plt
.plist
->comp_offset
;
9889 other
= micromips_p
? STO_MICROMIPS
: STO_MIPS16
;
9892 /* For VxWorks, point at the PLT load stub rather than the lazy
9893 resolution stub; this stub will become the canonical function
9895 if (htab
->is_vxworks
)
9898 h
->root
.root
.u
.def
.section
= htab
->root
.splt
;
9899 h
->root
.root
.u
.def
.value
= val
;
9900 h
->root
.other
= other
;
9906 /* Set the sizes of the dynamic sections. */
9909 _bfd_mips_elf_size_dynamic_sections (bfd
*output_bfd
,
9910 struct bfd_link_info
*info
)
9913 asection
*s
, *sreldyn
;
9914 bfd_boolean reltext
;
9915 struct mips_elf_link_hash_table
*htab
;
9917 htab
= mips_elf_hash_table (info
);
9918 BFD_ASSERT (htab
!= NULL
);
9919 dynobj
= elf_hash_table (info
)->dynobj
;
9920 BFD_ASSERT (dynobj
!= NULL
);
9922 if (elf_hash_table (info
)->dynamic_sections_created
)
9924 /* Set the contents of the .interp section to the interpreter. */
9925 if (bfd_link_executable (info
) && !info
->nointerp
)
9927 s
= bfd_get_linker_section (dynobj
, ".interp");
9928 BFD_ASSERT (s
!= NULL
);
9930 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd
)) + 1;
9932 = (bfd_byte
*) ELF_DYNAMIC_INTERPRETER (output_bfd
);
9935 /* Figure out the size of the PLT header if we know that we
9936 are using it. For the sake of cache alignment always use
9937 a standard header whenever any standard entries are present
9938 even if microMIPS entries are present as well. This also
9939 lets the microMIPS header rely on the value of $v0 only set
9940 by microMIPS entries, for a small size reduction.
9942 Set symbol table entry values for symbols that use the
9943 address of their PLT entry now that we can calculate it.
9945 Also create the _PROCEDURE_LINKAGE_TABLE_ symbol if we
9946 haven't already in _bfd_elf_create_dynamic_sections. */
9947 if (htab
->root
.splt
&& htab
->plt_mips_offset
+ htab
->plt_comp_offset
!= 0)
9949 bfd_boolean micromips_p
= (MICROMIPS_P (output_bfd
)
9950 && !htab
->plt_mips_offset
);
9951 unsigned int other
= micromips_p
? STO_MICROMIPS
: 0;
9952 bfd_vma isa_bit
= micromips_p
;
9953 struct elf_link_hash_entry
*h
;
9956 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
9957 BFD_ASSERT (htab
->root
.sgotplt
->size
== 0);
9958 BFD_ASSERT (htab
->root
.splt
->size
== 0);
9960 if (htab
->is_vxworks
&& bfd_link_pic (info
))
9961 size
= 4 * ARRAY_SIZE (mips_vxworks_shared_plt0_entry
);
9962 else if (htab
->is_vxworks
)
9963 size
= 4 * ARRAY_SIZE (mips_vxworks_exec_plt0_entry
);
9964 else if (ABI_64_P (output_bfd
))
9965 size
= 4 * ARRAY_SIZE (mips_n64_exec_plt0_entry
);
9966 else if (ABI_N32_P (output_bfd
))
9967 size
= 4 * ARRAY_SIZE (mips_n32_exec_plt0_entry
);
9968 else if (!micromips_p
)
9969 size
= 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry
);
9970 else if (htab
->insn32
)
9971 size
= 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt0_entry
);
9973 size
= 2 * ARRAY_SIZE (micromips_o32_exec_plt0_entry
);
9975 htab
->plt_header_is_comp
= micromips_p
;
9976 htab
->plt_header_size
= size
;
9977 htab
->root
.splt
->size
= (size
9978 + htab
->plt_mips_offset
9979 + htab
->plt_comp_offset
);
9980 htab
->root
.sgotplt
->size
= (htab
->plt_got_index
9981 * MIPS_ELF_GOT_SIZE (dynobj
));
9983 mips_elf_link_hash_traverse (htab
, mips_elf_set_plt_sym_value
, info
);
9985 if (htab
->root
.hplt
== NULL
)
9987 h
= _bfd_elf_define_linkage_sym (dynobj
, info
, htab
->root
.splt
,
9988 "_PROCEDURE_LINKAGE_TABLE_");
9989 htab
->root
.hplt
= h
;
9994 h
= htab
->root
.hplt
;
9995 h
->root
.u
.def
.value
= isa_bit
;
10001 /* Allocate space for global sym dynamic relocs. */
10002 elf_link_hash_traverse (&htab
->root
, allocate_dynrelocs
, info
);
10004 mips_elf_estimate_stub_size (output_bfd
, info
);
10006 if (!mips_elf_lay_out_got (output_bfd
, info
))
10009 mips_elf_lay_out_lazy_stubs (info
);
10011 /* The check_relocs and adjust_dynamic_symbol entry points have
10012 determined the sizes of the various dynamic sections. Allocate
10013 memory for them. */
10015 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
10019 /* It's OK to base decisions on the section name, because none
10020 of the dynobj section names depend upon the input files. */
10021 name
= bfd_section_name (s
);
10023 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
10026 if (CONST_STRNEQ (name
, ".rel"))
10030 const char *outname
;
10033 /* If this relocation section applies to a read only
10034 section, then we probably need a DT_TEXTREL entry.
10035 If the relocation section is .rel(a).dyn, we always
10036 assert a DT_TEXTREL entry rather than testing whether
10037 there exists a relocation to a read only section or
10039 outname
= bfd_section_name (s
->output_section
);
10040 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
10041 if ((target
!= NULL
10042 && (target
->flags
& SEC_READONLY
) != 0
10043 && (target
->flags
& SEC_ALLOC
) != 0)
10044 || strcmp (outname
, MIPS_ELF_REL_DYN_NAME (info
)) == 0)
10047 /* We use the reloc_count field as a counter if we need
10048 to copy relocs into the output file. */
10049 if (strcmp (name
, MIPS_ELF_REL_DYN_NAME (info
)) != 0)
10050 s
->reloc_count
= 0;
10052 /* If combreloc is enabled, elf_link_sort_relocs() will
10053 sort relocations, but in a different way than we do,
10054 and before we're done creating relocations. Also, it
10055 will move them around between input sections'
10056 relocation's contents, so our sorting would be
10057 broken, so don't let it run. */
10058 info
->combreloc
= 0;
10061 else if (bfd_link_executable (info
)
10062 && ! mips_elf_hash_table (info
)->use_rld_obj_head
10063 && CONST_STRNEQ (name
, ".rld_map"))
10065 /* We add a room for __rld_map. It will be filled in by the
10066 rtld to contain a pointer to the _r_debug structure. */
10067 s
->size
+= MIPS_ELF_RLD_MAP_SIZE (output_bfd
);
10069 else if (SGI_COMPAT (output_bfd
)
10070 && CONST_STRNEQ (name
, ".compact_rel"))
10071 s
->size
+= mips_elf_hash_table (info
)->compact_rel_size
;
10072 else if (s
== htab
->root
.splt
)
10074 /* If the last PLT entry has a branch delay slot, allocate
10075 room for an extra nop to fill the delay slot. This is
10076 for CPUs without load interlocking. */
10077 if (! LOAD_INTERLOCKS_P (output_bfd
)
10078 && ! htab
->is_vxworks
&& s
->size
> 0)
10081 else if (! CONST_STRNEQ (name
, ".init")
10082 && s
!= htab
->root
.sgot
10083 && s
!= htab
->root
.sgotplt
10084 && s
!= htab
->sstubs
10085 && s
!= htab
->root
.sdynbss
10086 && s
!= htab
->root
.sdynrelro
)
10088 /* It's not one of our sections, so don't allocate space. */
10094 s
->flags
|= SEC_EXCLUDE
;
10098 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
10101 /* Allocate memory for the section contents. */
10102 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
10103 if (s
->contents
== NULL
)
10105 bfd_set_error (bfd_error_no_memory
);
10110 if (elf_hash_table (info
)->dynamic_sections_created
)
10112 /* Add some entries to the .dynamic section. We fill in the
10113 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
10114 must add the entries now so that we get the correct size for
10115 the .dynamic section. */
10117 /* SGI object has the equivalence of DT_DEBUG in the
10118 DT_MIPS_RLD_MAP entry. This must come first because glibc
10119 only fills in DT_MIPS_RLD_MAP (not DT_DEBUG) and some tools
10120 may only look at the first one they see. */
10121 if (!bfd_link_pic (info
)
10122 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_MAP
, 0))
10125 if (bfd_link_executable (info
)
10126 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_MAP_REL
, 0))
10129 /* The DT_DEBUG entry may be filled in by the dynamic linker and
10130 used by the debugger. */
10131 if (bfd_link_executable (info
)
10132 && !SGI_COMPAT (output_bfd
)
10133 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
10136 if (reltext
&& (SGI_COMPAT (output_bfd
) || htab
->is_vxworks
))
10137 info
->flags
|= DF_TEXTREL
;
10139 if ((info
->flags
& DF_TEXTREL
) != 0)
10141 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_TEXTREL
, 0))
10144 /* Clear the DF_TEXTREL flag. It will be set again if we
10145 write out an actual text relocation; we may not, because
10146 at this point we do not know whether e.g. any .eh_frame
10147 absolute relocations have been converted to PC-relative. */
10148 info
->flags
&= ~DF_TEXTREL
;
10151 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTGOT
, 0))
10154 sreldyn
= mips_elf_rel_dyn_section (info
, FALSE
);
10155 if (htab
->is_vxworks
)
10157 /* VxWorks uses .rela.dyn instead of .rel.dyn. It does not
10158 use any of the DT_MIPS_* tags. */
10159 if (sreldyn
&& sreldyn
->size
> 0)
10161 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELA
, 0))
10164 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELASZ
, 0))
10167 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELAENT
, 0))
10173 if (sreldyn
&& sreldyn
->size
> 0
10174 && !bfd_is_abs_section (sreldyn
->output_section
))
10176 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_REL
, 0))
10179 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELSZ
, 0))
10182 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELENT
, 0))
10186 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_VERSION
, 0))
10189 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_FLAGS
, 0))
10192 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_BASE_ADDRESS
, 0))
10195 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LOCAL_GOTNO
, 0))
10198 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_SYMTABNO
, 0))
10201 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_UNREFEXTNO
, 0))
10204 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_GOTSYM
, 0))
10207 if (info
->emit_gnu_hash
10208 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_XHASH
, 0))
10211 if (IRIX_COMPAT (dynobj
) == ict_irix5
10212 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_HIPAGENO
, 0))
10215 if (IRIX_COMPAT (dynobj
) == ict_irix6
10216 && (bfd_get_section_by_name
10217 (output_bfd
, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj
)))
10218 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_OPTIONS
, 0))
10221 if (htab
->root
.splt
->size
> 0)
10223 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTREL
, 0))
10226 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_JMPREL
, 0))
10229 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTRELSZ
, 0))
10232 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_PLTGOT
, 0))
10235 if (htab
->is_vxworks
10236 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
10243 /* REL is a relocation in INPUT_BFD that is being copied to OUTPUT_BFD.
10244 Adjust its R_ADDEND field so that it is correct for the output file.
10245 LOCAL_SYMS and LOCAL_SECTIONS are arrays of INPUT_BFD's local symbols
10246 and sections respectively; both use symbol indexes. */
10249 mips_elf_adjust_addend (bfd
*output_bfd
, struct bfd_link_info
*info
,
10250 bfd
*input_bfd
, Elf_Internal_Sym
*local_syms
,
10251 asection
**local_sections
, Elf_Internal_Rela
*rel
)
10253 unsigned int r_type
, r_symndx
;
10254 Elf_Internal_Sym
*sym
;
10257 if (mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
))
10259 r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
10260 if (gprel16_reloc_p (r_type
)
10261 || r_type
== R_MIPS_GPREL32
10262 || literal_reloc_p (r_type
))
10264 rel
->r_addend
+= _bfd_get_gp_value (input_bfd
);
10265 rel
->r_addend
-= _bfd_get_gp_value (output_bfd
);
10268 r_symndx
= ELF_R_SYM (output_bfd
, rel
->r_info
);
10269 sym
= local_syms
+ r_symndx
;
10271 /* Adjust REL's addend to account for section merging. */
10272 if (!bfd_link_relocatable (info
))
10274 sec
= local_sections
[r_symndx
];
10275 _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
10278 /* This would normally be done by the rela_normal code in elflink.c. */
10279 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
10280 rel
->r_addend
+= local_sections
[r_symndx
]->output_offset
;
10284 /* Handle relocations against symbols from removed linkonce sections,
10285 or sections discarded by a linker script. We use this wrapper around
10286 RELOC_AGAINST_DISCARDED_SECTION to handle triplets of compound relocs
10287 on 64-bit ELF targets. In this case for any relocation handled, which
10288 always be the first in a triplet, the remaining two have to be processed
10289 together with the first, even if they are R_MIPS_NONE. It is the symbol
10290 index referred by the first reloc that applies to all the three and the
10291 remaining two never refer to an object symbol. And it is the final
10292 relocation (the last non-null one) that determines the output field of
10293 the whole relocation so retrieve the corresponding howto structure for
10294 the relocatable field to be cleared by RELOC_AGAINST_DISCARDED_SECTION.
10296 Note that RELOC_AGAINST_DISCARDED_SECTION is a macro that uses "continue"
10297 and therefore requires to be pasted in a loop. It also defines a block
10298 and does not protect any of its arguments, hence the extra brackets. */
10301 mips_reloc_against_discarded_section (bfd
*output_bfd
,
10302 struct bfd_link_info
*info
,
10303 bfd
*input_bfd
, asection
*input_section
,
10304 Elf_Internal_Rela
**rel
,
10305 const Elf_Internal_Rela
**relend
,
10306 bfd_boolean rel_reloc
,
10307 reloc_howto_type
*howto
,
10308 bfd_byte
*contents
)
10310 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
10311 int count
= bed
->s
->int_rels_per_ext_rel
;
10312 unsigned int r_type
;
10315 for (i
= count
- 1; i
> 0; i
--)
10317 r_type
= ELF_R_TYPE (output_bfd
, (*rel
)[i
].r_info
);
10318 if (r_type
!= R_MIPS_NONE
)
10320 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, r_type
, !rel_reloc
);
10326 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
10327 (*rel
), count
, (*relend
),
10328 howto
, i
, contents
);
10333 /* Relocate a MIPS ELF section. */
10336 _bfd_mips_elf_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
10337 bfd
*input_bfd
, asection
*input_section
,
10338 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
10339 Elf_Internal_Sym
*local_syms
,
10340 asection
**local_sections
)
10342 Elf_Internal_Rela
*rel
;
10343 const Elf_Internal_Rela
*relend
;
10344 bfd_vma addend
= 0;
10345 bfd_boolean use_saved_addend_p
= FALSE
;
10347 relend
= relocs
+ input_section
->reloc_count
;
10348 for (rel
= relocs
; rel
< relend
; ++rel
)
10352 reloc_howto_type
*howto
;
10353 bfd_boolean cross_mode_jump_p
= FALSE
;
10354 /* TRUE if the relocation is a RELA relocation, rather than a
10356 bfd_boolean rela_relocation_p
= TRUE
;
10357 unsigned int r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
10359 unsigned long r_symndx
;
10361 Elf_Internal_Shdr
*symtab_hdr
;
10362 struct elf_link_hash_entry
*h
;
10363 bfd_boolean rel_reloc
;
10365 rel_reloc
= (NEWABI_P (input_bfd
)
10366 && mips_elf_rel_relocation_p (input_bfd
, input_section
,
10368 /* Find the relocation howto for this relocation. */
10369 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, r_type
, !rel_reloc
);
10371 r_symndx
= ELF_R_SYM (input_bfd
, rel
->r_info
);
10372 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
10373 if (mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
))
10375 sec
= local_sections
[r_symndx
];
10380 unsigned long extsymoff
;
10383 if (!elf_bad_symtab (input_bfd
))
10384 extsymoff
= symtab_hdr
->sh_info
;
10385 h
= elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
];
10386 while (h
->root
.type
== bfd_link_hash_indirect
10387 || h
->root
.type
== bfd_link_hash_warning
)
10388 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
10391 if (h
->root
.type
== bfd_link_hash_defined
10392 || h
->root
.type
== bfd_link_hash_defweak
)
10393 sec
= h
->root
.u
.def
.section
;
10396 if (sec
!= NULL
&& discarded_section (sec
))
10398 mips_reloc_against_discarded_section (output_bfd
, info
, input_bfd
,
10399 input_section
, &rel
, &relend
,
10400 rel_reloc
, howto
, contents
);
10404 if (r_type
== R_MIPS_64
&& ! NEWABI_P (input_bfd
))
10406 /* Some 32-bit code uses R_MIPS_64. In particular, people use
10407 64-bit code, but make sure all their addresses are in the
10408 lowermost or uppermost 32-bit section of the 64-bit address
10409 space. Thus, when they use an R_MIPS_64 they mean what is
10410 usually meant by R_MIPS_32, with the exception that the
10411 stored value is sign-extended to 64 bits. */
10412 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, R_MIPS_32
, FALSE
);
10414 /* On big-endian systems, we need to lie about the position
10416 if (bfd_big_endian (input_bfd
))
10417 rel
->r_offset
+= 4;
10420 if (!use_saved_addend_p
)
10422 /* If these relocations were originally of the REL variety,
10423 we must pull the addend out of the field that will be
10424 relocated. Otherwise, we simply use the contents of the
10425 RELA relocation. */
10426 if (mips_elf_rel_relocation_p (input_bfd
, input_section
,
10429 rela_relocation_p
= FALSE
;
10430 addend
= mips_elf_read_rel_addend (input_bfd
, rel
,
10432 if (hi16_reloc_p (r_type
)
10433 || (got16_reloc_p (r_type
)
10434 && mips_elf_local_relocation_p (input_bfd
, rel
,
10437 if (!mips_elf_add_lo16_rel_addend (input_bfd
, rel
, relend
,
10438 contents
, &addend
))
10441 name
= h
->root
.root
.string
;
10443 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
10444 local_syms
+ r_symndx
,
10447 /* xgettext:c-format */
10448 (_("%pB: can't find matching LO16 reloc against `%s'"
10449 " for %s at %#" PRIx64
" in section `%pA'"),
10451 howto
->name
, (uint64_t) rel
->r_offset
, input_section
);
10455 addend
<<= howto
->rightshift
;
10458 addend
= rel
->r_addend
;
10459 mips_elf_adjust_addend (output_bfd
, info
, input_bfd
,
10460 local_syms
, local_sections
, rel
);
10463 if (bfd_link_relocatable (info
))
10465 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
)
10466 && bfd_big_endian (input_bfd
))
10467 rel
->r_offset
-= 4;
10469 if (!rela_relocation_p
&& rel
->r_addend
)
10471 addend
+= rel
->r_addend
;
10472 if (hi16_reloc_p (r_type
) || got16_reloc_p (r_type
))
10473 addend
= mips_elf_high (addend
);
10474 else if (r_type
== R_MIPS_HIGHER
)
10475 addend
= mips_elf_higher (addend
);
10476 else if (r_type
== R_MIPS_HIGHEST
)
10477 addend
= mips_elf_highest (addend
);
10479 addend
>>= howto
->rightshift
;
10481 /* We use the source mask, rather than the destination
10482 mask because the place to which we are writing will be
10483 source of the addend in the final link. */
10484 addend
&= howto
->src_mask
;
10486 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
10487 /* See the comment above about using R_MIPS_64 in the 32-bit
10488 ABI. Here, we need to update the addend. It would be
10489 possible to get away with just using the R_MIPS_32 reloc
10490 but for endianness. */
10496 if (addend
& ((bfd_vma
) 1 << 31))
10498 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
10505 /* If we don't know that we have a 64-bit type,
10506 do two separate stores. */
10507 if (bfd_big_endian (input_bfd
))
10509 /* Store the sign-bits (which are most significant)
10511 low_bits
= sign_bits
;
10512 high_bits
= addend
;
10517 high_bits
= sign_bits
;
10519 bfd_put_32 (input_bfd
, low_bits
,
10520 contents
+ rel
->r_offset
);
10521 bfd_put_32 (input_bfd
, high_bits
,
10522 contents
+ rel
->r_offset
+ 4);
10526 if (! mips_elf_perform_relocation (info
, howto
, rel
, addend
,
10527 input_bfd
, input_section
,
10532 /* Go on to the next relocation. */
10536 /* In the N32 and 64-bit ABIs there may be multiple consecutive
10537 relocations for the same offset. In that case we are
10538 supposed to treat the output of each relocation as the addend
10540 if (rel
+ 1 < relend
10541 && rel
->r_offset
== rel
[1].r_offset
10542 && ELF_R_TYPE (input_bfd
, rel
[1].r_info
) != R_MIPS_NONE
)
10543 use_saved_addend_p
= TRUE
;
10545 use_saved_addend_p
= FALSE
;
10547 /* Figure out what value we are supposed to relocate. */
10548 switch (mips_elf_calculate_relocation (output_bfd
, input_bfd
,
10549 input_section
, contents
,
10550 info
, rel
, addend
, howto
,
10551 local_syms
, local_sections
,
10552 &value
, &name
, &cross_mode_jump_p
,
10553 use_saved_addend_p
))
10555 case bfd_reloc_continue
:
10556 /* There's nothing to do. */
10559 case bfd_reloc_undefined
:
10560 /* mips_elf_calculate_relocation already called the
10561 undefined_symbol callback. There's no real point in
10562 trying to perform the relocation at this point, so we
10563 just skip ahead to the next relocation. */
10566 case bfd_reloc_notsupported
:
10567 msg
= _("internal error: unsupported relocation error");
10568 info
->callbacks
->warning
10569 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
10572 case bfd_reloc_overflow
:
10573 if (use_saved_addend_p
)
10574 /* Ignore overflow until we reach the last relocation for
10575 a given location. */
10579 struct mips_elf_link_hash_table
*htab
;
10581 htab
= mips_elf_hash_table (info
);
10582 BFD_ASSERT (htab
!= NULL
);
10583 BFD_ASSERT (name
!= NULL
);
10584 if (!htab
->small_data_overflow_reported
10585 && (gprel16_reloc_p (howto
->type
)
10586 || literal_reloc_p (howto
->type
)))
10588 msg
= _("small-data section exceeds 64KB;"
10589 " lower small-data size limit (see option -G)");
10591 htab
->small_data_overflow_reported
= TRUE
;
10592 (*info
->callbacks
->einfo
) ("%P: %s\n", msg
);
10594 (*info
->callbacks
->reloc_overflow
)
10595 (info
, NULL
, name
, howto
->name
, (bfd_vma
) 0,
10596 input_bfd
, input_section
, rel
->r_offset
);
10603 case bfd_reloc_outofrange
:
10605 if (jal_reloc_p (howto
->type
))
10606 msg
= (cross_mode_jump_p
10607 ? _("cannot convert a jump to JALX "
10608 "for a non-word-aligned address")
10609 : (howto
->type
== R_MIPS16_26
10610 ? _("jump to a non-word-aligned address")
10611 : _("jump to a non-instruction-aligned address")));
10612 else if (b_reloc_p (howto
->type
))
10613 msg
= (cross_mode_jump_p
10614 ? _("cannot convert a branch to JALX "
10615 "for a non-word-aligned address")
10616 : _("branch to a non-instruction-aligned address"));
10617 else if (aligned_pcrel_reloc_p (howto
->type
))
10618 msg
= _("PC-relative load from unaligned address");
10621 info
->callbacks
->einfo
10622 ("%X%H: %s\n", input_bfd
, input_section
, rel
->r_offset
, msg
);
10625 /* Fall through. */
10632 /* If we've got another relocation for the address, keep going
10633 until we reach the last one. */
10634 if (use_saved_addend_p
)
10640 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
10641 /* See the comment above about using R_MIPS_64 in the 32-bit
10642 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
10643 that calculated the right value. Now, however, we
10644 sign-extend the 32-bit result to 64-bits, and store it as a
10645 64-bit value. We are especially generous here in that we
10646 go to extreme lengths to support this usage on systems with
10647 only a 32-bit VMA. */
10653 if (value
& ((bfd_vma
) 1 << 31))
10655 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
10662 /* If we don't know that we have a 64-bit type,
10663 do two separate stores. */
10664 if (bfd_big_endian (input_bfd
))
10666 /* Undo what we did above. */
10667 rel
->r_offset
-= 4;
10668 /* Store the sign-bits (which are most significant)
10670 low_bits
= sign_bits
;
10676 high_bits
= sign_bits
;
10678 bfd_put_32 (input_bfd
, low_bits
,
10679 contents
+ rel
->r_offset
);
10680 bfd_put_32 (input_bfd
, high_bits
,
10681 contents
+ rel
->r_offset
+ 4);
10685 /* Actually perform the relocation. */
10686 if (! mips_elf_perform_relocation (info
, howto
, rel
, value
,
10687 input_bfd
, input_section
,
10688 contents
, cross_mode_jump_p
))
10695 /* A function that iterates over each entry in la25_stubs and fills
10696 in the code for each one. DATA points to a mips_htab_traverse_info. */
10699 mips_elf_create_la25_stub (void **slot
, void *data
)
10701 struct mips_htab_traverse_info
*hti
;
10702 struct mips_elf_link_hash_table
*htab
;
10703 struct mips_elf_la25_stub
*stub
;
10706 bfd_vma offset
, target
, target_high
, target_low
;
10708 bfd_signed_vma pcrel_offset
= 0;
10710 stub
= (struct mips_elf_la25_stub
*) *slot
;
10711 hti
= (struct mips_htab_traverse_info
*) data
;
10712 htab
= mips_elf_hash_table (hti
->info
);
10713 BFD_ASSERT (htab
!= NULL
);
10715 /* Create the section contents, if we haven't already. */
10716 s
= stub
->stub_section
;
10720 loc
= bfd_malloc (s
->size
);
10729 /* Work out where in the section this stub should go. */
10730 offset
= stub
->offset
;
10732 /* We add 8 here to account for the LUI/ADDIU instructions
10733 before the branch instruction. This cannot be moved down to
10734 where pcrel_offset is calculated as 's' is updated in
10735 mips_elf_get_la25_target. */
10736 branch_pc
= s
->output_section
->vma
+ s
->output_offset
+ offset
+ 8;
10738 /* Work out the target address. */
10739 target
= mips_elf_get_la25_target (stub
, &s
);
10740 target
+= s
->output_section
->vma
+ s
->output_offset
;
10742 target_high
= ((target
+ 0x8000) >> 16) & 0xffff;
10743 target_low
= (target
& 0xffff);
10745 /* Calculate the PC of the compact branch instruction (for the case where
10746 compact branches are used for either microMIPSR6 or MIPSR6 with
10747 compact branches. Add 4-bytes to account for BC using the PC of the
10748 next instruction as the base. */
10749 pcrel_offset
= target
- (branch_pc
+ 4);
10751 if (stub
->stub_section
!= htab
->strampoline
)
10753 /* This is a simple LUI/ADDIU stub. Zero out the beginning
10754 of the section and write the two instructions at the end. */
10755 memset (loc
, 0, offset
);
10757 if (ELF_ST_IS_MICROMIPS (stub
->h
->root
.other
))
10759 bfd_put_micromips_32 (hti
->output_bfd
,
10760 LA25_LUI_MICROMIPS (target_high
),
10762 bfd_put_micromips_32 (hti
->output_bfd
,
10763 LA25_ADDIU_MICROMIPS (target_low
),
10768 bfd_put_32 (hti
->output_bfd
, LA25_LUI (target_high
), loc
);
10769 bfd_put_32 (hti
->output_bfd
, LA25_ADDIU (target_low
), loc
+ 4);
10774 /* This is trampoline. */
10776 if (ELF_ST_IS_MICROMIPS (stub
->h
->root
.other
))
10778 bfd_put_micromips_32 (hti
->output_bfd
,
10779 LA25_LUI_MICROMIPS (target_high
), loc
);
10780 bfd_put_micromips_32 (hti
->output_bfd
,
10781 LA25_J_MICROMIPS (target
), loc
+ 4);
10782 bfd_put_micromips_32 (hti
->output_bfd
,
10783 LA25_ADDIU_MICROMIPS (target_low
), loc
+ 8);
10784 bfd_put_32 (hti
->output_bfd
, 0, loc
+ 12);
10788 bfd_put_32 (hti
->output_bfd
, LA25_LUI (target_high
), loc
);
10789 if (MIPSR6_P (hti
->output_bfd
) && htab
->compact_branches
)
10791 bfd_put_32 (hti
->output_bfd
, LA25_ADDIU (target_low
), loc
+ 4);
10792 bfd_put_32 (hti
->output_bfd
, LA25_BC (pcrel_offset
), loc
+ 8);
10796 bfd_put_32 (hti
->output_bfd
, LA25_J (target
), loc
+ 4);
10797 bfd_put_32 (hti
->output_bfd
, LA25_ADDIU (target_low
), loc
+ 8);
10799 bfd_put_32 (hti
->output_bfd
, 0, loc
+ 12);
10805 /* If NAME is one of the special IRIX6 symbols defined by the linker,
10806 adjust it appropriately now. */
10809 mips_elf_irix6_finish_dynamic_symbol (bfd
*abfd ATTRIBUTE_UNUSED
,
10810 const char *name
, Elf_Internal_Sym
*sym
)
10812 /* The linker script takes care of providing names and values for
10813 these, but we must place them into the right sections. */
10814 static const char* const text_section_symbols
[] = {
10817 "__dso_displacement",
10819 "__program_header_table",
10823 static const char* const data_section_symbols
[] = {
10831 const char* const *p
;
10834 for (i
= 0; i
< 2; ++i
)
10835 for (p
= (i
== 0) ? text_section_symbols
: data_section_symbols
;
10838 if (strcmp (*p
, name
) == 0)
10840 /* All of these symbols are given type STT_SECTION by the
10842 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
10843 sym
->st_other
= STO_PROTECTED
;
10845 /* The IRIX linker puts these symbols in special sections. */
10847 sym
->st_shndx
= SHN_MIPS_TEXT
;
10849 sym
->st_shndx
= SHN_MIPS_DATA
;
10855 /* Finish up dynamic symbol handling. We set the contents of various
10856 dynamic sections here. */
10859 _bfd_mips_elf_finish_dynamic_symbol (bfd
*output_bfd
,
10860 struct bfd_link_info
*info
,
10861 struct elf_link_hash_entry
*h
,
10862 Elf_Internal_Sym
*sym
)
10866 struct mips_got_info
*g
, *gg
;
10869 struct mips_elf_link_hash_table
*htab
;
10870 struct mips_elf_link_hash_entry
*hmips
;
10872 htab
= mips_elf_hash_table (info
);
10873 BFD_ASSERT (htab
!= NULL
);
10874 dynobj
= elf_hash_table (info
)->dynobj
;
10875 hmips
= (struct mips_elf_link_hash_entry
*) h
;
10877 BFD_ASSERT (!htab
->is_vxworks
);
10879 if (h
->plt
.plist
!= NULL
10880 && (h
->plt
.plist
->mips_offset
!= MINUS_ONE
10881 || h
->plt
.plist
->comp_offset
!= MINUS_ONE
))
10883 /* We've decided to create a PLT entry for this symbol. */
10885 bfd_vma header_address
, got_address
;
10886 bfd_vma got_address_high
, got_address_low
, load
;
10890 got_index
= h
->plt
.plist
->gotplt_index
;
10892 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
10893 BFD_ASSERT (h
->dynindx
!= -1);
10894 BFD_ASSERT (htab
->root
.splt
!= NULL
);
10895 BFD_ASSERT (got_index
!= MINUS_ONE
);
10896 BFD_ASSERT (!h
->def_regular
);
10898 /* Calculate the address of the PLT header. */
10899 isa_bit
= htab
->plt_header_is_comp
;
10900 header_address
= (htab
->root
.splt
->output_section
->vma
10901 + htab
->root
.splt
->output_offset
+ isa_bit
);
10903 /* Calculate the address of the .got.plt entry. */
10904 got_address
= (htab
->root
.sgotplt
->output_section
->vma
10905 + htab
->root
.sgotplt
->output_offset
10906 + got_index
* MIPS_ELF_GOT_SIZE (dynobj
));
10908 got_address_high
= ((got_address
+ 0x8000) >> 16) & 0xffff;
10909 got_address_low
= got_address
& 0xffff;
10911 /* The PLT sequence is not safe for N64 if .got.plt entry's address
10912 cannot be loaded in two instructions. */
10913 if (ABI_64_P (output_bfd
)
10914 && ((got_address
+ 0x80008000) & ~(bfd_vma
) 0xffffffff) != 0)
10917 /* xgettext:c-format */
10918 (_("%pB: `%pA' entry VMA of %#" PRIx64
" outside the 32-bit range "
10919 "supported; consider using `-Ttext-segment=...'"),
10921 htab
->root
.sgotplt
->output_section
,
10922 (int64_t) got_address
);
10923 bfd_set_error (bfd_error_no_error
);
10927 /* Initially point the .got.plt entry at the PLT header. */
10928 loc
= (htab
->root
.sgotplt
->contents
10929 + got_index
* MIPS_ELF_GOT_SIZE (dynobj
));
10930 if (ABI_64_P (output_bfd
))
10931 bfd_put_64 (output_bfd
, header_address
, loc
);
10933 bfd_put_32 (output_bfd
, header_address
, loc
);
10935 /* Now handle the PLT itself. First the standard entry (the order
10936 does not matter, we just have to pick one). */
10937 if (h
->plt
.plist
->mips_offset
!= MINUS_ONE
)
10939 const bfd_vma
*plt_entry
;
10940 bfd_vma plt_offset
;
10942 plt_offset
= htab
->plt_header_size
+ h
->plt
.plist
->mips_offset
;
10944 BFD_ASSERT (plt_offset
<= htab
->root
.splt
->size
);
10946 /* Find out where the .plt entry should go. */
10947 loc
= htab
->root
.splt
->contents
+ plt_offset
;
10949 /* Pick the load opcode. */
10950 load
= MIPS_ELF_LOAD_WORD (output_bfd
);
10952 /* Fill in the PLT entry itself. */
10954 if (MIPSR6_P (output_bfd
))
10955 plt_entry
= htab
->compact_branches
? mipsr6_exec_plt_entry_compact
10956 : mipsr6_exec_plt_entry
;
10958 plt_entry
= mips_exec_plt_entry
;
10959 bfd_put_32 (output_bfd
, plt_entry
[0] | got_address_high
, loc
);
10960 bfd_put_32 (output_bfd
, plt_entry
[1] | got_address_low
| load
,
10963 if (! LOAD_INTERLOCKS_P (output_bfd
)
10964 || (MIPSR6_P (output_bfd
) && htab
->compact_branches
))
10966 bfd_put_32 (output_bfd
, plt_entry
[2] | got_address_low
, loc
+ 8);
10967 bfd_put_32 (output_bfd
, plt_entry
[3], loc
+ 12);
10971 bfd_put_32 (output_bfd
, plt_entry
[3], loc
+ 8);
10972 bfd_put_32 (output_bfd
, plt_entry
[2] | got_address_low
,
10977 /* Now the compressed entry. They come after any standard ones. */
10978 if (h
->plt
.plist
->comp_offset
!= MINUS_ONE
)
10980 bfd_vma plt_offset
;
10982 plt_offset
= (htab
->plt_header_size
+ htab
->plt_mips_offset
10983 + h
->plt
.plist
->comp_offset
);
10985 BFD_ASSERT (plt_offset
<= htab
->root
.splt
->size
);
10987 /* Find out where the .plt entry should go. */
10988 loc
= htab
->root
.splt
->contents
+ plt_offset
;
10990 /* Fill in the PLT entry itself. */
10991 if (!MICROMIPS_P (output_bfd
))
10993 const bfd_vma
*plt_entry
= mips16_o32_exec_plt_entry
;
10995 bfd_put_16 (output_bfd
, plt_entry
[0], loc
);
10996 bfd_put_16 (output_bfd
, plt_entry
[1], loc
+ 2);
10997 bfd_put_16 (output_bfd
, plt_entry
[2], loc
+ 4);
10998 bfd_put_16 (output_bfd
, plt_entry
[3], loc
+ 6);
10999 bfd_put_16 (output_bfd
, plt_entry
[4], loc
+ 8);
11000 bfd_put_16 (output_bfd
, plt_entry
[5], loc
+ 10);
11001 bfd_put_32 (output_bfd
, got_address
, loc
+ 12);
11003 else if (htab
->insn32
)
11005 const bfd_vma
*plt_entry
= micromips_insn32_o32_exec_plt_entry
;
11007 bfd_put_16 (output_bfd
, plt_entry
[0], loc
);
11008 bfd_put_16 (output_bfd
, got_address_high
, loc
+ 2);
11009 bfd_put_16 (output_bfd
, plt_entry
[2], loc
+ 4);
11010 bfd_put_16 (output_bfd
, got_address_low
, loc
+ 6);
11011 bfd_put_16 (output_bfd
, plt_entry
[4], loc
+ 8);
11012 bfd_put_16 (output_bfd
, plt_entry
[5], loc
+ 10);
11013 bfd_put_16 (output_bfd
, plt_entry
[6], loc
+ 12);
11014 bfd_put_16 (output_bfd
, got_address_low
, loc
+ 14);
11018 const bfd_vma
*plt_entry
= micromips_o32_exec_plt_entry
;
11019 bfd_signed_vma gotpc_offset
;
11020 bfd_vma loc_address
;
11022 BFD_ASSERT (got_address
% 4 == 0);
11024 loc_address
= (htab
->root
.splt
->output_section
->vma
11025 + htab
->root
.splt
->output_offset
+ plt_offset
);
11026 gotpc_offset
= got_address
- ((loc_address
| 3) ^ 3);
11028 /* ADDIUPC has a span of +/-16MB, check we're in range. */
11029 if (gotpc_offset
+ 0x1000000 >= 0x2000000)
11032 /* xgettext:c-format */
11033 (_("%pB: `%pA' offset of %" PRId64
" from `%pA' "
11034 "beyond the range of ADDIUPC"),
11036 htab
->root
.sgotplt
->output_section
,
11037 (int64_t) gotpc_offset
,
11038 htab
->root
.splt
->output_section
);
11039 bfd_set_error (bfd_error_no_error
);
11042 bfd_put_16 (output_bfd
,
11043 plt_entry
[0] | ((gotpc_offset
>> 18) & 0x7f), loc
);
11044 bfd_put_16 (output_bfd
, (gotpc_offset
>> 2) & 0xffff, loc
+ 2);
11045 bfd_put_16 (output_bfd
, plt_entry
[2], loc
+ 4);
11046 bfd_put_16 (output_bfd
, plt_entry
[3], loc
+ 6);
11047 bfd_put_16 (output_bfd
, plt_entry
[4], loc
+ 8);
11048 bfd_put_16 (output_bfd
, plt_entry
[5], loc
+ 10);
11052 /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry. */
11053 mips_elf_output_dynamic_relocation (output_bfd
, htab
->root
.srelplt
,
11054 got_index
- 2, h
->dynindx
,
11055 R_MIPS_JUMP_SLOT
, got_address
);
11057 /* We distinguish between PLT entries and lazy-binding stubs by
11058 giving the former an st_other value of STO_MIPS_PLT. Set the
11059 flag and leave the value if there are any relocations in the
11060 binary where pointer equality matters. */
11061 sym
->st_shndx
= SHN_UNDEF
;
11062 if (h
->pointer_equality_needed
)
11063 sym
->st_other
= ELF_ST_SET_MIPS_PLT (sym
->st_other
);
11071 if (h
->plt
.plist
!= NULL
&& h
->plt
.plist
->stub_offset
!= MINUS_ONE
)
11073 /* We've decided to create a lazy-binding stub. */
11074 bfd_boolean micromips_p
= MICROMIPS_P (output_bfd
);
11075 unsigned int other
= micromips_p
? STO_MICROMIPS
: 0;
11076 bfd_vma stub_size
= htab
->function_stub_size
;
11077 bfd_byte stub
[MIPS_FUNCTION_STUB_BIG_SIZE
];
11078 bfd_vma isa_bit
= micromips_p
;
11079 bfd_vma stub_big_size
;
11082 stub_big_size
= MIPS_FUNCTION_STUB_BIG_SIZE
;
11083 else if (htab
->insn32
)
11084 stub_big_size
= MICROMIPS_INSN32_FUNCTION_STUB_BIG_SIZE
;
11086 stub_big_size
= MICROMIPS_FUNCTION_STUB_BIG_SIZE
;
11088 /* This symbol has a stub. Set it up. */
11090 BFD_ASSERT (h
->dynindx
!= -1);
11092 BFD_ASSERT (stub_size
== stub_big_size
|| h
->dynindx
<= 0xffff);
11094 /* Values up to 2^31 - 1 are allowed. Larger values would cause
11095 sign extension at runtime in the stub, resulting in a negative
11097 if (h
->dynindx
& ~0x7fffffff)
11100 /* Fill the stub. */
11104 bfd_put_micromips_32 (output_bfd
, STUB_LW_MICROMIPS (output_bfd
),
11109 bfd_put_micromips_32 (output_bfd
,
11110 STUB_MOVE32_MICROMIPS
, stub
+ idx
);
11115 bfd_put_16 (output_bfd
, STUB_MOVE_MICROMIPS
, stub
+ idx
);
11118 if (stub_size
== stub_big_size
)
11120 long dynindx_hi
= (h
->dynindx
>> 16) & 0x7fff;
11122 bfd_put_micromips_32 (output_bfd
,
11123 STUB_LUI_MICROMIPS (dynindx_hi
),
11129 bfd_put_micromips_32 (output_bfd
, STUB_JALR32_MICROMIPS
,
11135 bfd_put_16 (output_bfd
, STUB_JALR_MICROMIPS
, stub
+ idx
);
11139 /* If a large stub is not required and sign extension is not a
11140 problem, then use legacy code in the stub. */
11141 if (stub_size
== stub_big_size
)
11142 bfd_put_micromips_32 (output_bfd
,
11143 STUB_ORI_MICROMIPS (h
->dynindx
& 0xffff),
11145 else if (h
->dynindx
& ~0x7fff)
11146 bfd_put_micromips_32 (output_bfd
,
11147 STUB_LI16U_MICROMIPS (h
->dynindx
& 0xffff),
11150 bfd_put_micromips_32 (output_bfd
,
11151 STUB_LI16S_MICROMIPS (output_bfd
,
11158 bfd_put_32 (output_bfd
, STUB_LW (output_bfd
), stub
+ idx
);
11160 bfd_put_32 (output_bfd
, STUB_MOVE
, stub
+ idx
);
11162 if (stub_size
== stub_big_size
)
11164 bfd_put_32 (output_bfd
, STUB_LUI ((h
->dynindx
>> 16) & 0x7fff),
11169 if (!(MIPSR6_P (output_bfd
) && htab
->compact_branches
))
11171 bfd_put_32 (output_bfd
, STUB_JALR
, stub
+ idx
);
11175 /* If a large stub is not required and sign extension is not a
11176 problem, then use legacy code in the stub. */
11177 if (stub_size
== stub_big_size
)
11178 bfd_put_32 (output_bfd
, STUB_ORI (h
->dynindx
& 0xffff),
11180 else if (h
->dynindx
& ~0x7fff)
11181 bfd_put_32 (output_bfd
, STUB_LI16U (h
->dynindx
& 0xffff),
11184 bfd_put_32 (output_bfd
, STUB_LI16S (output_bfd
, h
->dynindx
),
11188 if (MIPSR6_P (output_bfd
) && htab
->compact_branches
)
11189 bfd_put_32 (output_bfd
, STUB_JALRC
, stub
+ idx
);
11192 BFD_ASSERT (h
->plt
.plist
->stub_offset
<= htab
->sstubs
->size
);
11193 memcpy (htab
->sstubs
->contents
+ h
->plt
.plist
->stub_offset
,
11196 /* Mark the symbol as undefined. stub_offset != -1 occurs
11197 only for the referenced symbol. */
11198 sym
->st_shndx
= SHN_UNDEF
;
11200 /* The run-time linker uses the st_value field of the symbol
11201 to reset the global offset table entry for this external
11202 to its stub address when unlinking a shared object. */
11203 sym
->st_value
= (htab
->sstubs
->output_section
->vma
11204 + htab
->sstubs
->output_offset
11205 + h
->plt
.plist
->stub_offset
11207 sym
->st_other
= other
;
11210 /* If we have a MIPS16 function with a stub, the dynamic symbol must
11211 refer to the stub, since only the stub uses the standard calling
11213 if (h
->dynindx
!= -1 && hmips
->fn_stub
!= NULL
)
11215 BFD_ASSERT (hmips
->need_fn_stub
);
11216 sym
->st_value
= (hmips
->fn_stub
->output_section
->vma
11217 + hmips
->fn_stub
->output_offset
);
11218 sym
->st_size
= hmips
->fn_stub
->size
;
11219 sym
->st_other
= ELF_ST_VISIBILITY (sym
->st_other
);
11222 BFD_ASSERT (h
->dynindx
!= -1
11223 || h
->forced_local
);
11225 sgot
= htab
->root
.sgot
;
11226 g
= htab
->got_info
;
11227 BFD_ASSERT (g
!= NULL
);
11229 /* Run through the global symbol table, creating GOT entries for all
11230 the symbols that need them. */
11231 if (hmips
->global_got_area
!= GGA_NONE
)
11236 value
= sym
->st_value
;
11237 offset
= mips_elf_primary_global_got_index (output_bfd
, info
, h
);
11238 MIPS_ELF_PUT_WORD (output_bfd
, value
, sgot
->contents
+ offset
);
11241 if (hmips
->global_got_area
!= GGA_NONE
&& g
->next
)
11243 struct mips_got_entry e
, *p
;
11249 e
.abfd
= output_bfd
;
11252 e
.tls_type
= GOT_TLS_NONE
;
11254 for (g
= g
->next
; g
->next
!= gg
; g
= g
->next
)
11257 && (p
= (struct mips_got_entry
*) htab_find (g
->got_entries
,
11260 offset
= p
->gotidx
;
11261 BFD_ASSERT (offset
> 0 && offset
< htab
->root
.sgot
->size
);
11262 if (bfd_link_pic (info
)
11263 || (elf_hash_table (info
)->dynamic_sections_created
11265 && p
->d
.h
->root
.def_dynamic
11266 && !p
->d
.h
->root
.def_regular
))
11268 /* Create an R_MIPS_REL32 relocation for this entry. Due to
11269 the various compatibility problems, it's easier to mock
11270 up an R_MIPS_32 or R_MIPS_64 relocation and leave
11271 mips_elf_create_dynamic_relocation to calculate the
11272 appropriate addend. */
11273 Elf_Internal_Rela rel
[3];
11275 memset (rel
, 0, sizeof (rel
));
11276 if (ABI_64_P (output_bfd
))
11277 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_64
);
11279 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_32
);
11280 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
11283 if (! (mips_elf_create_dynamic_relocation
11284 (output_bfd
, info
, rel
,
11285 e
.d
.h
, NULL
, sym
->st_value
, &entry
, sgot
)))
11289 entry
= sym
->st_value
;
11290 MIPS_ELF_PUT_WORD (output_bfd
, entry
, sgot
->contents
+ offset
);
11295 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
11296 name
= h
->root
.root
.string
;
11297 if (h
== elf_hash_table (info
)->hdynamic
11298 || h
== elf_hash_table (info
)->hgot
)
11299 sym
->st_shndx
= SHN_ABS
;
11300 else if (strcmp (name
, "_DYNAMIC_LINK") == 0
11301 || strcmp (name
, "_DYNAMIC_LINKING") == 0)
11303 sym
->st_shndx
= SHN_ABS
;
11304 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
11307 else if (SGI_COMPAT (output_bfd
))
11309 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
11310 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
11312 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
11313 sym
->st_other
= STO_PROTECTED
;
11315 sym
->st_shndx
= SHN_MIPS_DATA
;
11317 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
11319 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
11320 sym
->st_other
= STO_PROTECTED
;
11321 sym
->st_value
= mips_elf_hash_table (info
)->procedure_count
;
11322 sym
->st_shndx
= SHN_ABS
;
11324 else if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
!= SHN_ABS
)
11326 if (h
->type
== STT_FUNC
)
11327 sym
->st_shndx
= SHN_MIPS_TEXT
;
11328 else if (h
->type
== STT_OBJECT
)
11329 sym
->st_shndx
= SHN_MIPS_DATA
;
11333 /* Emit a copy reloc, if needed. */
11339 BFD_ASSERT (h
->dynindx
!= -1);
11340 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
11342 s
= mips_elf_rel_dyn_section (info
, FALSE
);
11343 symval
= (h
->root
.u
.def
.section
->output_section
->vma
11344 + h
->root
.u
.def
.section
->output_offset
11345 + h
->root
.u
.def
.value
);
11346 mips_elf_output_dynamic_relocation (output_bfd
, s
, s
->reloc_count
++,
11347 h
->dynindx
, R_MIPS_COPY
, symval
);
11350 /* Handle the IRIX6-specific symbols. */
11351 if (IRIX_COMPAT (output_bfd
) == ict_irix6
)
11352 mips_elf_irix6_finish_dynamic_symbol (output_bfd
, name
, sym
);
11354 /* Keep dynamic compressed symbols odd. This allows the dynamic linker
11355 to treat compressed symbols like any other. */
11356 if (ELF_ST_IS_MIPS16 (sym
->st_other
))
11358 BFD_ASSERT (sym
->st_value
& 1);
11359 sym
->st_other
-= STO_MIPS16
;
11361 else if (ELF_ST_IS_MICROMIPS (sym
->st_other
))
11363 BFD_ASSERT (sym
->st_value
& 1);
11364 sym
->st_other
-= STO_MICROMIPS
;
11370 /* Likewise, for VxWorks. */
11373 _bfd_mips_vxworks_finish_dynamic_symbol (bfd
*output_bfd
,
11374 struct bfd_link_info
*info
,
11375 struct elf_link_hash_entry
*h
,
11376 Elf_Internal_Sym
*sym
)
11380 struct mips_got_info
*g
;
11381 struct mips_elf_link_hash_table
*htab
;
11382 struct mips_elf_link_hash_entry
*hmips
;
11384 htab
= mips_elf_hash_table (info
);
11385 BFD_ASSERT (htab
!= NULL
);
11386 dynobj
= elf_hash_table (info
)->dynobj
;
11387 hmips
= (struct mips_elf_link_hash_entry
*) h
;
11389 if (h
->plt
.plist
!= NULL
&& h
->plt
.plist
->mips_offset
!= MINUS_ONE
)
11392 bfd_vma plt_address
, got_address
, got_offset
, branch_offset
;
11393 Elf_Internal_Rela rel
;
11394 static const bfd_vma
*plt_entry
;
11395 bfd_vma gotplt_index
;
11396 bfd_vma plt_offset
;
11398 plt_offset
= htab
->plt_header_size
+ h
->plt
.plist
->mips_offset
;
11399 gotplt_index
= h
->plt
.plist
->gotplt_index
;
11401 BFD_ASSERT (h
->dynindx
!= -1);
11402 BFD_ASSERT (htab
->root
.splt
!= NULL
);
11403 BFD_ASSERT (gotplt_index
!= MINUS_ONE
);
11404 BFD_ASSERT (plt_offset
<= htab
->root
.splt
->size
);
11406 /* Calculate the address of the .plt entry. */
11407 plt_address
= (htab
->root
.splt
->output_section
->vma
11408 + htab
->root
.splt
->output_offset
11411 /* Calculate the address of the .got.plt entry. */
11412 got_address
= (htab
->root
.sgotplt
->output_section
->vma
11413 + htab
->root
.sgotplt
->output_offset
11414 + gotplt_index
* MIPS_ELF_GOT_SIZE (output_bfd
));
11416 /* Calculate the offset of the .got.plt entry from
11417 _GLOBAL_OFFSET_TABLE_. */
11418 got_offset
= mips_elf_gotplt_index (info
, h
);
11420 /* Calculate the offset for the branch at the start of the PLT
11421 entry. The branch jumps to the beginning of .plt. */
11422 branch_offset
= -(plt_offset
/ 4 + 1) & 0xffff;
11424 /* Fill in the initial value of the .got.plt entry. */
11425 bfd_put_32 (output_bfd
, plt_address
,
11426 (htab
->root
.sgotplt
->contents
11427 + gotplt_index
* MIPS_ELF_GOT_SIZE (output_bfd
)));
11429 /* Find out where the .plt entry should go. */
11430 loc
= htab
->root
.splt
->contents
+ plt_offset
;
11432 if (bfd_link_pic (info
))
11434 plt_entry
= mips_vxworks_shared_plt_entry
;
11435 bfd_put_32 (output_bfd
, plt_entry
[0] | branch_offset
, loc
);
11436 bfd_put_32 (output_bfd
, plt_entry
[1] | gotplt_index
, loc
+ 4);
11440 bfd_vma got_address_high
, got_address_low
;
11442 plt_entry
= mips_vxworks_exec_plt_entry
;
11443 got_address_high
= ((got_address
+ 0x8000) >> 16) & 0xffff;
11444 got_address_low
= got_address
& 0xffff;
11446 bfd_put_32 (output_bfd
, plt_entry
[0] | branch_offset
, loc
);
11447 bfd_put_32 (output_bfd
, plt_entry
[1] | gotplt_index
, loc
+ 4);
11448 bfd_put_32 (output_bfd
, plt_entry
[2] | got_address_high
, loc
+ 8);
11449 bfd_put_32 (output_bfd
, plt_entry
[3] | got_address_low
, loc
+ 12);
11450 bfd_put_32 (output_bfd
, plt_entry
[4], loc
+ 16);
11451 bfd_put_32 (output_bfd
, plt_entry
[5], loc
+ 20);
11452 bfd_put_32 (output_bfd
, plt_entry
[6], loc
+ 24);
11453 bfd_put_32 (output_bfd
, plt_entry
[7], loc
+ 28);
11455 loc
= (htab
->srelplt2
->contents
11456 + (gotplt_index
* 3 + 2) * sizeof (Elf32_External_Rela
));
11458 /* Emit a relocation for the .got.plt entry. */
11459 rel
.r_offset
= got_address
;
11460 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
, R_MIPS_32
);
11461 rel
.r_addend
= plt_offset
;
11462 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
11464 /* Emit a relocation for the lui of %hi(<.got.plt slot>). */
11465 loc
+= sizeof (Elf32_External_Rela
);
11466 rel
.r_offset
= plt_address
+ 8;
11467 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_HI16
);
11468 rel
.r_addend
= got_offset
;
11469 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
11471 /* Emit a relocation for the addiu of %lo(<.got.plt slot>). */
11472 loc
+= sizeof (Elf32_External_Rela
);
11474 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_LO16
);
11475 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
11478 /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry. */
11479 loc
= (htab
->root
.srelplt
->contents
11480 + gotplt_index
* sizeof (Elf32_External_Rela
));
11481 rel
.r_offset
= got_address
;
11482 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_JUMP_SLOT
);
11484 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
11486 if (!h
->def_regular
)
11487 sym
->st_shndx
= SHN_UNDEF
;
11490 BFD_ASSERT (h
->dynindx
!= -1 || h
->forced_local
);
11492 sgot
= htab
->root
.sgot
;
11493 g
= htab
->got_info
;
11494 BFD_ASSERT (g
!= NULL
);
11496 /* See if this symbol has an entry in the GOT. */
11497 if (hmips
->global_got_area
!= GGA_NONE
)
11500 Elf_Internal_Rela outrel
;
11504 /* Install the symbol value in the GOT. */
11505 offset
= mips_elf_primary_global_got_index (output_bfd
, info
, h
);
11506 MIPS_ELF_PUT_WORD (output_bfd
, sym
->st_value
, sgot
->contents
+ offset
);
11508 /* Add a dynamic relocation for it. */
11509 s
= mips_elf_rel_dyn_section (info
, FALSE
);
11510 loc
= s
->contents
+ (s
->reloc_count
++ * sizeof (Elf32_External_Rela
));
11511 outrel
.r_offset
= (sgot
->output_section
->vma
11512 + sgot
->output_offset
11514 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_32
);
11515 outrel
.r_addend
= 0;
11516 bfd_elf32_swap_reloca_out (dynobj
, &outrel
, loc
);
11519 /* Emit a copy reloc, if needed. */
11522 Elf_Internal_Rela rel
;
11526 BFD_ASSERT (h
->dynindx
!= -1);
11528 rel
.r_offset
= (h
->root
.u
.def
.section
->output_section
->vma
11529 + h
->root
.u
.def
.section
->output_offset
11530 + h
->root
.u
.def
.value
);
11531 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_COPY
);
11533 if (h
->root
.u
.def
.section
== htab
->root
.sdynrelro
)
11534 srel
= htab
->root
.sreldynrelro
;
11536 srel
= htab
->root
.srelbss
;
11537 loc
= srel
->contents
+ srel
->reloc_count
* sizeof (Elf32_External_Rela
);
11538 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
11539 ++srel
->reloc_count
;
11542 /* If this is a mips16/microMIPS symbol, force the value to be even. */
11543 if (ELF_ST_IS_COMPRESSED (sym
->st_other
))
11544 sym
->st_value
&= ~1;
11549 /* Write out a plt0 entry to the beginning of .plt. */
11552 mips_finish_exec_plt (bfd
*output_bfd
, struct bfd_link_info
*info
)
11555 bfd_vma gotplt_value
, gotplt_value_high
, gotplt_value_low
;
11556 static const bfd_vma
*plt_entry
;
11557 struct mips_elf_link_hash_table
*htab
;
11559 htab
= mips_elf_hash_table (info
);
11560 BFD_ASSERT (htab
!= NULL
);
11562 if (ABI_64_P (output_bfd
))
11563 plt_entry
= (htab
->compact_branches
11564 ? mipsr6_n64_exec_plt0_entry_compact
11565 : mips_n64_exec_plt0_entry
);
11566 else if (ABI_N32_P (output_bfd
))
11567 plt_entry
= (htab
->compact_branches
11568 ? mipsr6_n32_exec_plt0_entry_compact
11569 : mips_n32_exec_plt0_entry
);
11570 else if (!htab
->plt_header_is_comp
)
11571 plt_entry
= (htab
->compact_branches
11572 ? mipsr6_o32_exec_plt0_entry_compact
11573 : mips_o32_exec_plt0_entry
);
11574 else if (htab
->insn32
)
11575 plt_entry
= micromips_insn32_o32_exec_plt0_entry
;
11577 plt_entry
= micromips_o32_exec_plt0_entry
;
11579 /* Calculate the value of .got.plt. */
11580 gotplt_value
= (htab
->root
.sgotplt
->output_section
->vma
11581 + htab
->root
.sgotplt
->output_offset
);
11582 gotplt_value_high
= ((gotplt_value
+ 0x8000) >> 16) & 0xffff;
11583 gotplt_value_low
= gotplt_value
& 0xffff;
11585 /* The PLT sequence is not safe for N64 if .got.plt's address can
11586 not be loaded in two instructions. */
11587 if (ABI_64_P (output_bfd
)
11588 && ((gotplt_value
+ 0x80008000) & ~(bfd_vma
) 0xffffffff) != 0)
11591 /* xgettext:c-format */
11592 (_("%pB: `%pA' start VMA of %#" PRIx64
" outside the 32-bit range "
11593 "supported; consider using `-Ttext-segment=...'"),
11595 htab
->root
.sgotplt
->output_section
,
11596 (int64_t) gotplt_value
);
11597 bfd_set_error (bfd_error_no_error
);
11601 /* Install the PLT header. */
11602 loc
= htab
->root
.splt
->contents
;
11603 if (plt_entry
== micromips_o32_exec_plt0_entry
)
11605 bfd_vma gotpc_offset
;
11606 bfd_vma loc_address
;
11609 BFD_ASSERT (gotplt_value
% 4 == 0);
11611 loc_address
= (htab
->root
.splt
->output_section
->vma
11612 + htab
->root
.splt
->output_offset
);
11613 gotpc_offset
= gotplt_value
- ((loc_address
| 3) ^ 3);
11615 /* ADDIUPC has a span of +/-16MB, check we're in range. */
11616 if (gotpc_offset
+ 0x1000000 >= 0x2000000)
11619 /* xgettext:c-format */
11620 (_("%pB: `%pA' offset of %" PRId64
" from `%pA' "
11621 "beyond the range of ADDIUPC"),
11623 htab
->root
.sgotplt
->output_section
,
11624 (int64_t) gotpc_offset
,
11625 htab
->root
.splt
->output_section
);
11626 bfd_set_error (bfd_error_no_error
);
11629 bfd_put_16 (output_bfd
,
11630 plt_entry
[0] | ((gotpc_offset
>> 18) & 0x7f), loc
);
11631 bfd_put_16 (output_bfd
, (gotpc_offset
>> 2) & 0xffff, loc
+ 2);
11632 for (i
= 2; i
< ARRAY_SIZE (micromips_o32_exec_plt0_entry
); i
++)
11633 bfd_put_16 (output_bfd
, plt_entry
[i
], loc
+ (i
* 2));
11635 else if (plt_entry
== micromips_insn32_o32_exec_plt0_entry
)
11639 bfd_put_16 (output_bfd
, plt_entry
[0], loc
);
11640 bfd_put_16 (output_bfd
, gotplt_value_high
, loc
+ 2);
11641 bfd_put_16 (output_bfd
, plt_entry
[2], loc
+ 4);
11642 bfd_put_16 (output_bfd
, gotplt_value_low
, loc
+ 6);
11643 bfd_put_16 (output_bfd
, plt_entry
[4], loc
+ 8);
11644 bfd_put_16 (output_bfd
, gotplt_value_low
, loc
+ 10);
11645 for (i
= 6; i
< ARRAY_SIZE (micromips_insn32_o32_exec_plt0_entry
); i
++)
11646 bfd_put_16 (output_bfd
, plt_entry
[i
], loc
+ (i
* 2));
11650 bfd_put_32 (output_bfd
, plt_entry
[0] | gotplt_value_high
, loc
);
11651 bfd_put_32 (output_bfd
, plt_entry
[1] | gotplt_value_low
, loc
+ 4);
11652 bfd_put_32 (output_bfd
, plt_entry
[2] | gotplt_value_low
, loc
+ 8);
11653 bfd_put_32 (output_bfd
, plt_entry
[3], loc
+ 12);
11654 bfd_put_32 (output_bfd
, plt_entry
[4], loc
+ 16);
11655 bfd_put_32 (output_bfd
, plt_entry
[5], loc
+ 20);
11656 bfd_put_32 (output_bfd
, plt_entry
[6], loc
+ 24);
11657 bfd_put_32 (output_bfd
, plt_entry
[7], loc
+ 28);
11663 /* Install the PLT header for a VxWorks executable and finalize the
11664 contents of .rela.plt.unloaded. */
11667 mips_vxworks_finish_exec_plt (bfd
*output_bfd
, struct bfd_link_info
*info
)
11669 Elf_Internal_Rela rela
;
11671 bfd_vma got_value
, got_value_high
, got_value_low
, plt_address
;
11672 static const bfd_vma
*plt_entry
;
11673 struct mips_elf_link_hash_table
*htab
;
11675 htab
= mips_elf_hash_table (info
);
11676 BFD_ASSERT (htab
!= NULL
);
11678 plt_entry
= mips_vxworks_exec_plt0_entry
;
11680 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */
11681 got_value
= (htab
->root
.hgot
->root
.u
.def
.section
->output_section
->vma
11682 + htab
->root
.hgot
->root
.u
.def
.section
->output_offset
11683 + htab
->root
.hgot
->root
.u
.def
.value
);
11685 got_value_high
= ((got_value
+ 0x8000) >> 16) & 0xffff;
11686 got_value_low
= got_value
& 0xffff;
11688 /* Calculate the address of the PLT header. */
11689 plt_address
= (htab
->root
.splt
->output_section
->vma
11690 + htab
->root
.splt
->output_offset
);
11692 /* Install the PLT header. */
11693 loc
= htab
->root
.splt
->contents
;
11694 bfd_put_32 (output_bfd
, plt_entry
[0] | got_value_high
, loc
);
11695 bfd_put_32 (output_bfd
, plt_entry
[1] | got_value_low
, loc
+ 4);
11696 bfd_put_32 (output_bfd
, plt_entry
[2], loc
+ 8);
11697 bfd_put_32 (output_bfd
, plt_entry
[3], loc
+ 12);
11698 bfd_put_32 (output_bfd
, plt_entry
[4], loc
+ 16);
11699 bfd_put_32 (output_bfd
, plt_entry
[5], loc
+ 20);
11701 /* Output the relocation for the lui of %hi(_GLOBAL_OFFSET_TABLE_). */
11702 loc
= htab
->srelplt2
->contents
;
11703 rela
.r_offset
= plt_address
;
11704 rela
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_HI16
);
11706 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
11707 loc
+= sizeof (Elf32_External_Rela
);
11709 /* Output the relocation for the following addiu of
11710 %lo(_GLOBAL_OFFSET_TABLE_). */
11711 rela
.r_offset
+= 4;
11712 rela
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_LO16
);
11713 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
11714 loc
+= sizeof (Elf32_External_Rela
);
11716 /* Fix up the remaining relocations. They may have the wrong
11717 symbol index for _G_O_T_ or _P_L_T_ depending on the order
11718 in which symbols were output. */
11719 while (loc
< htab
->srelplt2
->contents
+ htab
->srelplt2
->size
)
11721 Elf_Internal_Rela rel
;
11723 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &rel
);
11724 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
, R_MIPS_32
);
11725 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
11726 loc
+= sizeof (Elf32_External_Rela
);
11728 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &rel
);
11729 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_HI16
);
11730 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
11731 loc
+= sizeof (Elf32_External_Rela
);
11733 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &rel
);
11734 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_LO16
);
11735 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
11736 loc
+= sizeof (Elf32_External_Rela
);
11740 /* Install the PLT header for a VxWorks shared library. */
11743 mips_vxworks_finish_shared_plt (bfd
*output_bfd
, struct bfd_link_info
*info
)
11746 struct mips_elf_link_hash_table
*htab
;
11748 htab
= mips_elf_hash_table (info
);
11749 BFD_ASSERT (htab
!= NULL
);
11751 /* We just need to copy the entry byte-by-byte. */
11752 for (i
= 0; i
< ARRAY_SIZE (mips_vxworks_shared_plt0_entry
); i
++)
11753 bfd_put_32 (output_bfd
, mips_vxworks_shared_plt0_entry
[i
],
11754 htab
->root
.splt
->contents
+ i
* 4);
11757 /* Finish up the dynamic sections. */
11760 _bfd_mips_elf_finish_dynamic_sections (bfd
*output_bfd
,
11761 struct bfd_link_info
*info
)
11766 struct mips_got_info
*gg
, *g
;
11767 struct mips_elf_link_hash_table
*htab
;
11769 htab
= mips_elf_hash_table (info
);
11770 BFD_ASSERT (htab
!= NULL
);
11772 dynobj
= elf_hash_table (info
)->dynobj
;
11774 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
11776 sgot
= htab
->root
.sgot
;
11777 gg
= htab
->got_info
;
11779 if (elf_hash_table (info
)->dynamic_sections_created
)
11782 int dyn_to_skip
= 0, dyn_skipped
= 0;
11784 BFD_ASSERT (sdyn
!= NULL
);
11785 BFD_ASSERT (gg
!= NULL
);
11787 g
= mips_elf_bfd_got (output_bfd
, FALSE
);
11788 BFD_ASSERT (g
!= NULL
);
11790 for (b
= sdyn
->contents
;
11791 b
< sdyn
->contents
+ sdyn
->size
;
11792 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
11794 Elf_Internal_Dyn dyn
;
11798 bfd_boolean swap_out_p
;
11800 /* Read in the current dynamic entry. */
11801 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
11803 /* Assume that we're going to modify it and write it out. */
11809 dyn
.d_un
.d_val
= MIPS_ELF_REL_SIZE (dynobj
);
11813 BFD_ASSERT (htab
->is_vxworks
);
11814 dyn
.d_un
.d_val
= MIPS_ELF_RELA_SIZE (dynobj
);
11818 /* Rewrite DT_STRSZ. */
11820 _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
11824 s
= htab
->root
.sgot
;
11825 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
11828 case DT_MIPS_PLTGOT
:
11829 s
= htab
->root
.sgotplt
;
11830 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
11833 case DT_MIPS_RLD_VERSION
:
11834 dyn
.d_un
.d_val
= 1; /* XXX */
11837 case DT_MIPS_FLAGS
:
11838 dyn
.d_un
.d_val
= RHF_NOTPOT
; /* XXX */
11841 case DT_MIPS_TIME_STAMP
:
11845 dyn
.d_un
.d_val
= t
;
11849 case DT_MIPS_ICHECKSUM
:
11851 swap_out_p
= FALSE
;
11854 case DT_MIPS_IVERSION
:
11856 swap_out_p
= FALSE
;
11859 case DT_MIPS_BASE_ADDRESS
:
11860 s
= output_bfd
->sections
;
11861 BFD_ASSERT (s
!= NULL
);
11862 dyn
.d_un
.d_ptr
= s
->vma
& ~(bfd_vma
) 0xffff;
11865 case DT_MIPS_LOCAL_GOTNO
:
11866 dyn
.d_un
.d_val
= g
->local_gotno
;
11869 case DT_MIPS_UNREFEXTNO
:
11870 /* The index into the dynamic symbol table which is the
11871 entry of the first external symbol that is not
11872 referenced within the same object. */
11873 dyn
.d_un
.d_val
= bfd_count_sections (output_bfd
) + 1;
11876 case DT_MIPS_GOTSYM
:
11877 if (htab
->global_gotsym
)
11879 dyn
.d_un
.d_val
= htab
->global_gotsym
->dynindx
;
11882 /* In case if we don't have global got symbols we default
11883 to setting DT_MIPS_GOTSYM to the same value as
11884 DT_MIPS_SYMTABNO. */
11885 /* Fall through. */
11887 case DT_MIPS_SYMTABNO
:
11889 elemsize
= MIPS_ELF_SYM_SIZE (output_bfd
);
11890 s
= bfd_get_linker_section (dynobj
, name
);
11893 dyn
.d_un
.d_val
= s
->size
/ elemsize
;
11895 dyn
.d_un
.d_val
= 0;
11898 case DT_MIPS_HIPAGENO
:
11899 dyn
.d_un
.d_val
= g
->local_gotno
- htab
->reserved_gotno
;
11902 case DT_MIPS_RLD_MAP
:
11904 struct elf_link_hash_entry
*h
;
11905 h
= mips_elf_hash_table (info
)->rld_symbol
;
11908 dyn_to_skip
= MIPS_ELF_DYN_SIZE (dynobj
);
11909 swap_out_p
= FALSE
;
11912 s
= h
->root
.u
.def
.section
;
11914 /* The MIPS_RLD_MAP tag stores the absolute address of the
11916 dyn
.d_un
.d_ptr
= (s
->output_section
->vma
+ s
->output_offset
11917 + h
->root
.u
.def
.value
);
11921 case DT_MIPS_RLD_MAP_REL
:
11923 struct elf_link_hash_entry
*h
;
11924 bfd_vma dt_addr
, rld_addr
;
11925 h
= mips_elf_hash_table (info
)->rld_symbol
;
11928 dyn_to_skip
= MIPS_ELF_DYN_SIZE (dynobj
);
11929 swap_out_p
= FALSE
;
11932 s
= h
->root
.u
.def
.section
;
11934 /* The MIPS_RLD_MAP_REL tag stores the offset to the debug
11935 pointer, relative to the address of the tag. */
11936 dt_addr
= (sdyn
->output_section
->vma
+ sdyn
->output_offset
11937 + (b
- sdyn
->contents
));
11938 rld_addr
= (s
->output_section
->vma
+ s
->output_offset
11939 + h
->root
.u
.def
.value
);
11940 dyn
.d_un
.d_ptr
= rld_addr
- dt_addr
;
11944 case DT_MIPS_OPTIONS
:
11945 s
= (bfd_get_section_by_name
11946 (output_bfd
, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd
)));
11947 dyn
.d_un
.d_ptr
= s
->vma
;
11951 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
11952 if (htab
->is_vxworks
)
11953 dyn
.d_un
.d_val
= DT_RELA
;
11955 dyn
.d_un
.d_val
= DT_REL
;
11959 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
11960 dyn
.d_un
.d_val
= htab
->root
.srelplt
->size
;
11964 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
11965 dyn
.d_un
.d_ptr
= (htab
->root
.srelplt
->output_section
->vma
11966 + htab
->root
.srelplt
->output_offset
);
11970 /* If we didn't need any text relocations after all, delete
11971 the dynamic tag. */
11972 if (!(info
->flags
& DF_TEXTREL
))
11974 dyn_to_skip
= MIPS_ELF_DYN_SIZE (dynobj
);
11975 swap_out_p
= FALSE
;
11980 /* If we didn't need any text relocations after all, clear
11981 DF_TEXTREL from DT_FLAGS. */
11982 if (!(info
->flags
& DF_TEXTREL
))
11983 dyn
.d_un
.d_val
&= ~DF_TEXTREL
;
11985 swap_out_p
= FALSE
;
11988 case DT_MIPS_XHASH
:
11989 name
= ".MIPS.xhash";
11990 s
= bfd_get_linker_section (dynobj
, name
);
11991 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
11995 swap_out_p
= FALSE
;
11996 if (htab
->is_vxworks
11997 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
12002 if (swap_out_p
|| dyn_skipped
)
12003 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
12004 (dynobj
, &dyn
, b
- dyn_skipped
);
12008 dyn_skipped
+= dyn_to_skip
;
12013 /* Wipe out any trailing entries if we shifted down a dynamic tag. */
12014 if (dyn_skipped
> 0)
12015 memset (b
- dyn_skipped
, 0, dyn_skipped
);
12018 if (sgot
!= NULL
&& sgot
->size
> 0
12019 && !bfd_is_abs_section (sgot
->output_section
))
12021 if (htab
->is_vxworks
)
12023 /* The first entry of the global offset table points to the
12024 ".dynamic" section. The second is initialized by the
12025 loader and contains the shared library identifier.
12026 The third is also initialized by the loader and points
12027 to the lazy resolution stub. */
12028 MIPS_ELF_PUT_WORD (output_bfd
,
12029 sdyn
->output_offset
+ sdyn
->output_section
->vma
,
12031 MIPS_ELF_PUT_WORD (output_bfd
, 0,
12032 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
12033 MIPS_ELF_PUT_WORD (output_bfd
, 0,
12035 + 2 * MIPS_ELF_GOT_SIZE (output_bfd
));
12039 /* The first entry of the global offset table will be filled at
12040 runtime. The second entry will be used by some runtime loaders.
12041 This isn't the case of IRIX rld. */
12042 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
12043 MIPS_ELF_PUT_WORD (output_bfd
, MIPS_ELF_GNU_GOT1_MASK (output_bfd
),
12044 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
12047 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
12048 = MIPS_ELF_GOT_SIZE (output_bfd
);
12051 /* Generate dynamic relocations for the non-primary gots. */
12052 if (gg
!= NULL
&& gg
->next
)
12054 Elf_Internal_Rela rel
[3];
12055 bfd_vma addend
= 0;
12057 memset (rel
, 0, sizeof (rel
));
12058 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_REL32
);
12060 for (g
= gg
->next
; g
->next
!= gg
; g
= g
->next
)
12062 bfd_vma got_index
= g
->next
->local_gotno
+ g
->next
->global_gotno
12063 + g
->next
->tls_gotno
;
12065 MIPS_ELF_PUT_WORD (output_bfd
, 0, sgot
->contents
12066 + got_index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
12067 MIPS_ELF_PUT_WORD (output_bfd
, MIPS_ELF_GNU_GOT1_MASK (output_bfd
),
12069 + got_index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
12071 if (! bfd_link_pic (info
))
12074 for (; got_index
< g
->local_gotno
; got_index
++)
12076 if (got_index
>= g
->assigned_low_gotno
12077 && got_index
<= g
->assigned_high_gotno
)
12080 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
12081 = got_index
* MIPS_ELF_GOT_SIZE (output_bfd
);
12082 if (!(mips_elf_create_dynamic_relocation
12083 (output_bfd
, info
, rel
, NULL
,
12084 bfd_abs_section_ptr
,
12085 0, &addend
, sgot
)))
12087 BFD_ASSERT (addend
== 0);
12092 /* The generation of dynamic relocations for the non-primary gots
12093 adds more dynamic relocations. We cannot count them until
12096 if (elf_hash_table (info
)->dynamic_sections_created
)
12099 bfd_boolean swap_out_p
;
12101 BFD_ASSERT (sdyn
!= NULL
);
12103 for (b
= sdyn
->contents
;
12104 b
< sdyn
->contents
+ sdyn
->size
;
12105 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
12107 Elf_Internal_Dyn dyn
;
12110 /* Read in the current dynamic entry. */
12111 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
12113 /* Assume that we're going to modify it and write it out. */
12119 /* Reduce DT_RELSZ to account for any relocations we
12120 decided not to make. This is for the n64 irix rld,
12121 which doesn't seem to apply any relocations if there
12122 are trailing null entries. */
12123 s
= mips_elf_rel_dyn_section (info
, FALSE
);
12124 dyn
.d_un
.d_val
= (s
->reloc_count
12125 * (ABI_64_P (output_bfd
)
12126 ? sizeof (Elf64_Mips_External_Rel
)
12127 : sizeof (Elf32_External_Rel
)));
12128 /* Adjust the section size too. Tools like the prelinker
12129 can reasonably expect the values to the same. */
12130 BFD_ASSERT (!bfd_is_abs_section (s
->output_section
));
12131 elf_section_data (s
->output_section
)->this_hdr
.sh_size
12136 swap_out_p
= FALSE
;
12141 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
12148 Elf32_compact_rel cpt
;
12150 if (SGI_COMPAT (output_bfd
))
12152 /* Write .compact_rel section out. */
12153 s
= bfd_get_linker_section (dynobj
, ".compact_rel");
12157 cpt
.num
= s
->reloc_count
;
12159 cpt
.offset
= (s
->output_section
->filepos
12160 + sizeof (Elf32_External_compact_rel
));
12163 bfd_elf32_swap_compact_rel_out (output_bfd
, &cpt
,
12164 ((Elf32_External_compact_rel
*)
12167 /* Clean up a dummy stub function entry in .text. */
12168 if (htab
->sstubs
!= NULL
)
12170 file_ptr dummy_offset
;
12172 BFD_ASSERT (htab
->sstubs
->size
>= htab
->function_stub_size
);
12173 dummy_offset
= htab
->sstubs
->size
- htab
->function_stub_size
;
12174 memset (htab
->sstubs
->contents
+ dummy_offset
, 0,
12175 htab
->function_stub_size
);
12180 /* The psABI says that the dynamic relocations must be sorted in
12181 increasing order of r_symndx. The VxWorks EABI doesn't require
12182 this, and because the code below handles REL rather than RELA
12183 relocations, using it for VxWorks would be outright harmful. */
12184 if (!htab
->is_vxworks
)
12186 s
= mips_elf_rel_dyn_section (info
, FALSE
);
12188 && s
->size
> (bfd_vma
)2 * MIPS_ELF_REL_SIZE (output_bfd
))
12190 reldyn_sorting_bfd
= output_bfd
;
12192 if (ABI_64_P (output_bfd
))
12193 qsort ((Elf64_External_Rel
*) s
->contents
+ 1,
12194 s
->reloc_count
- 1, sizeof (Elf64_Mips_External_Rel
),
12195 sort_dynamic_relocs_64
);
12197 qsort ((Elf32_External_Rel
*) s
->contents
+ 1,
12198 s
->reloc_count
- 1, sizeof (Elf32_External_Rel
),
12199 sort_dynamic_relocs
);
12204 if (htab
->root
.splt
&& htab
->root
.splt
->size
> 0)
12206 if (htab
->is_vxworks
)
12208 if (bfd_link_pic (info
))
12209 mips_vxworks_finish_shared_plt (output_bfd
, info
);
12211 mips_vxworks_finish_exec_plt (output_bfd
, info
);
12215 BFD_ASSERT (!bfd_link_pic (info
));
12216 if (!mips_finish_exec_plt (output_bfd
, info
))
12224 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
12227 mips_set_isa_flags (bfd
*abfd
)
12231 switch (bfd_get_mach (abfd
))
12234 if (ABI_N32_P (abfd
) || ABI_64_P (abfd
))
12235 val
= E_MIPS_ARCH_3
;
12237 val
= E_MIPS_ARCH_1
;
12240 case bfd_mach_mips3000
:
12241 val
= E_MIPS_ARCH_1
;
12244 case bfd_mach_mips3900
:
12245 val
= E_MIPS_ARCH_1
| E_MIPS_MACH_3900
;
12248 case bfd_mach_mips6000
:
12249 val
= E_MIPS_ARCH_2
;
12252 case bfd_mach_mips4010
:
12253 val
= E_MIPS_ARCH_2
| E_MIPS_MACH_4010
;
12256 case bfd_mach_mips4000
:
12257 case bfd_mach_mips4300
:
12258 case bfd_mach_mips4400
:
12259 case bfd_mach_mips4600
:
12260 val
= E_MIPS_ARCH_3
;
12263 case bfd_mach_mips4100
:
12264 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4100
;
12267 case bfd_mach_mips4111
:
12268 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4111
;
12271 case bfd_mach_mips4120
:
12272 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4120
;
12275 case bfd_mach_mips4650
:
12276 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4650
;
12279 case bfd_mach_mips5400
:
12280 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5400
;
12283 case bfd_mach_mips5500
:
12284 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5500
;
12287 case bfd_mach_mips5900
:
12288 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_5900
;
12291 case bfd_mach_mips9000
:
12292 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_9000
;
12295 case bfd_mach_mips5000
:
12296 case bfd_mach_mips7000
:
12297 case bfd_mach_mips8000
:
12298 case bfd_mach_mips10000
:
12299 case bfd_mach_mips12000
:
12300 case bfd_mach_mips14000
:
12301 case bfd_mach_mips16000
:
12302 val
= E_MIPS_ARCH_4
;
12305 case bfd_mach_mips5
:
12306 val
= E_MIPS_ARCH_5
;
12309 case bfd_mach_mips_loongson_2e
:
12310 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_LS2E
;
12313 case bfd_mach_mips_loongson_2f
:
12314 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_LS2F
;
12317 case bfd_mach_mips_sb1
:
12318 val
= E_MIPS_ARCH_64
| E_MIPS_MACH_SB1
;
12321 case bfd_mach_mips_gs464
:
12322 val
= E_MIPS_ARCH_64R2
| E_MIPS_MACH_GS464
;
12325 case bfd_mach_mips_gs464e
:
12326 val
= E_MIPS_ARCH_64R2
| E_MIPS_MACH_GS464E
;
12329 case bfd_mach_mips_gs264e
:
12330 val
= E_MIPS_ARCH_64R2
| E_MIPS_MACH_GS264E
;
12333 case bfd_mach_mips_octeon
:
12334 case bfd_mach_mips_octeonp
:
12335 val
= E_MIPS_ARCH_64R2
| E_MIPS_MACH_OCTEON
;
12338 case bfd_mach_mips_octeon3
:
12339 val
= E_MIPS_ARCH_64R2
| E_MIPS_MACH_OCTEON3
;
12342 case bfd_mach_mips_xlr
:
12343 val
= E_MIPS_ARCH_64
| E_MIPS_MACH_XLR
;
12346 case bfd_mach_mips_octeon2
:
12347 val
= E_MIPS_ARCH_64R2
| E_MIPS_MACH_OCTEON2
;
12350 case bfd_mach_mipsisa32
:
12351 val
= E_MIPS_ARCH_32
;
12354 case bfd_mach_mipsisa64
:
12355 val
= E_MIPS_ARCH_64
;
12358 case bfd_mach_mipsisa32r2
:
12359 case bfd_mach_mipsisa32r3
:
12360 case bfd_mach_mipsisa32r5
:
12361 val
= E_MIPS_ARCH_32R2
;
12364 case bfd_mach_mips_interaptiv_mr2
:
12365 val
= E_MIPS_ARCH_32R2
| E_MIPS_MACH_IAMR2
;
12368 case bfd_mach_mipsisa64r2
:
12369 case bfd_mach_mipsisa64r3
:
12370 case bfd_mach_mipsisa64r5
:
12371 val
= E_MIPS_ARCH_64R2
;
12374 case bfd_mach_mipsisa32r6
:
12375 val
= E_MIPS_ARCH_32R6
;
12378 case bfd_mach_mipsisa64r6
:
12379 val
= E_MIPS_ARCH_64R6
;
12382 elf_elfheader (abfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
12383 elf_elfheader (abfd
)->e_flags
|= val
;
12388 /* Whether to sort relocs output by ld -r or ld --emit-relocs, by r_offset.
12389 Don't do so for code sections. We want to keep ordering of HI16/LO16
12390 as is. On the other hand, elf-eh-frame.c processing requires .eh_frame
12391 relocs to be sorted. */
12394 _bfd_mips_elf_sort_relocs_p (asection
*sec
)
12396 return (sec
->flags
& SEC_CODE
) == 0;
12400 /* The final processing done just before writing out a MIPS ELF object
12401 file. This gets the MIPS architecture right based on the machine
12402 number. This is used by both the 32-bit and the 64-bit ABI. */
12405 _bfd_mips_final_write_processing (bfd
*abfd
)
12408 Elf_Internal_Shdr
**hdrpp
;
12412 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
12413 is nonzero. This is for compatibility with old objects, which used
12414 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
12415 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_MACH
) == 0)
12416 mips_set_isa_flags (abfd
);
12418 /* Set the sh_info field for .gptab sections and other appropriate
12419 info for each special section. */
12420 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
12421 i
< elf_numsections (abfd
);
12424 switch ((*hdrpp
)->sh_type
)
12426 case SHT_MIPS_MSYM
:
12427 case SHT_MIPS_LIBLIST
:
12428 sec
= bfd_get_section_by_name (abfd
, ".dynstr");
12430 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
12433 case SHT_MIPS_GPTAB
:
12434 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
12435 name
= bfd_section_name ((*hdrpp
)->bfd_section
);
12436 BFD_ASSERT (name
!= NULL
12437 && CONST_STRNEQ (name
, ".gptab."));
12438 sec
= bfd_get_section_by_name (abfd
, name
+ sizeof ".gptab" - 1);
12439 BFD_ASSERT (sec
!= NULL
);
12440 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
12443 case SHT_MIPS_CONTENT
:
12444 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
12445 name
= bfd_section_name ((*hdrpp
)->bfd_section
);
12446 BFD_ASSERT (name
!= NULL
12447 && CONST_STRNEQ (name
, ".MIPS.content"));
12448 sec
= bfd_get_section_by_name (abfd
,
12449 name
+ sizeof ".MIPS.content" - 1);
12450 BFD_ASSERT (sec
!= NULL
);
12451 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
12454 case SHT_MIPS_SYMBOL_LIB
:
12455 sec
= bfd_get_section_by_name (abfd
, ".dynsym");
12457 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
12458 sec
= bfd_get_section_by_name (abfd
, ".liblist");
12460 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
12463 case SHT_MIPS_EVENTS
:
12464 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
12465 name
= bfd_section_name ((*hdrpp
)->bfd_section
);
12466 BFD_ASSERT (name
!= NULL
);
12467 if (CONST_STRNEQ (name
, ".MIPS.events"))
12468 sec
= bfd_get_section_by_name (abfd
,
12469 name
+ sizeof ".MIPS.events" - 1);
12472 BFD_ASSERT (CONST_STRNEQ (name
, ".MIPS.post_rel"));
12473 sec
= bfd_get_section_by_name (abfd
,
12475 + sizeof ".MIPS.post_rel" - 1));
12477 BFD_ASSERT (sec
!= NULL
);
12478 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
12481 case SHT_MIPS_XHASH
:
12482 sec
= bfd_get_section_by_name (abfd
, ".dynsym");
12484 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
12490 _bfd_mips_elf_final_write_processing (bfd
*abfd
)
12492 _bfd_mips_final_write_processing (abfd
);
12493 return _bfd_elf_final_write_processing (abfd
);
12496 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
12500 _bfd_mips_elf_additional_program_headers (bfd
*abfd
,
12501 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
12506 /* See if we need a PT_MIPS_REGINFO segment. */
12507 s
= bfd_get_section_by_name (abfd
, ".reginfo");
12508 if (s
&& (s
->flags
& SEC_LOAD
))
12511 /* See if we need a PT_MIPS_ABIFLAGS segment. */
12512 if (bfd_get_section_by_name (abfd
, ".MIPS.abiflags"))
12515 /* See if we need a PT_MIPS_OPTIONS segment. */
12516 if (IRIX_COMPAT (abfd
) == ict_irix6
12517 && bfd_get_section_by_name (abfd
,
12518 MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)))
12521 /* See if we need a PT_MIPS_RTPROC segment. */
12522 if (IRIX_COMPAT (abfd
) == ict_irix5
12523 && bfd_get_section_by_name (abfd
, ".dynamic")
12524 && bfd_get_section_by_name (abfd
, ".mdebug"))
12527 /* Allocate a PT_NULL header in dynamic objects. See
12528 _bfd_mips_elf_modify_segment_map for details. */
12529 if (!SGI_COMPAT (abfd
)
12530 && bfd_get_section_by_name (abfd
, ".dynamic"))
12536 /* Modify the segment map for an IRIX5 executable. */
12539 _bfd_mips_elf_modify_segment_map (bfd
*abfd
,
12540 struct bfd_link_info
*info
)
12543 struct elf_segment_map
*m
, **pm
;
12546 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
12548 s
= bfd_get_section_by_name (abfd
, ".reginfo");
12549 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
12551 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
12552 if (m
->p_type
== PT_MIPS_REGINFO
)
12557 m
= bfd_zalloc (abfd
, amt
);
12561 m
->p_type
= PT_MIPS_REGINFO
;
12563 m
->sections
[0] = s
;
12565 /* We want to put it after the PHDR and INTERP segments. */
12566 pm
= &elf_seg_map (abfd
);
12568 && ((*pm
)->p_type
== PT_PHDR
12569 || (*pm
)->p_type
== PT_INTERP
))
12577 /* If there is a .MIPS.abiflags section, we need a PT_MIPS_ABIFLAGS
12579 s
= bfd_get_section_by_name (abfd
, ".MIPS.abiflags");
12580 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
12582 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
12583 if (m
->p_type
== PT_MIPS_ABIFLAGS
)
12588 m
= bfd_zalloc (abfd
, amt
);
12592 m
->p_type
= PT_MIPS_ABIFLAGS
;
12594 m
->sections
[0] = s
;
12596 /* We want to put it after the PHDR and INTERP segments. */
12597 pm
= &elf_seg_map (abfd
);
12599 && ((*pm
)->p_type
== PT_PHDR
12600 || (*pm
)->p_type
== PT_INTERP
))
12608 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
12609 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
12610 PT_MIPS_OPTIONS segment immediately following the program header
12612 if (NEWABI_P (abfd
)
12613 /* On non-IRIX6 new abi, we'll have already created a segment
12614 for this section, so don't create another. I'm not sure this
12615 is not also the case for IRIX 6, but I can't test it right
12617 && IRIX_COMPAT (abfd
) == ict_irix6
)
12619 for (s
= abfd
->sections
; s
; s
= s
->next
)
12620 if (elf_section_data (s
)->this_hdr
.sh_type
== SHT_MIPS_OPTIONS
)
12625 struct elf_segment_map
*options_segment
;
12627 pm
= &elf_seg_map (abfd
);
12629 && ((*pm
)->p_type
== PT_PHDR
12630 || (*pm
)->p_type
== PT_INTERP
))
12633 if (*pm
== NULL
|| (*pm
)->p_type
!= PT_MIPS_OPTIONS
)
12635 amt
= sizeof (struct elf_segment_map
);
12636 options_segment
= bfd_zalloc (abfd
, amt
);
12637 options_segment
->next
= *pm
;
12638 options_segment
->p_type
= PT_MIPS_OPTIONS
;
12639 options_segment
->p_flags
= PF_R
;
12640 options_segment
->p_flags_valid
= TRUE
;
12641 options_segment
->count
= 1;
12642 options_segment
->sections
[0] = s
;
12643 *pm
= options_segment
;
12649 if (IRIX_COMPAT (abfd
) == ict_irix5
)
12651 /* If there are .dynamic and .mdebug sections, we make a room
12652 for the RTPROC header. FIXME: Rewrite without section names. */
12653 if (bfd_get_section_by_name (abfd
, ".interp") == NULL
12654 && bfd_get_section_by_name (abfd
, ".dynamic") != NULL
12655 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
12657 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
12658 if (m
->p_type
== PT_MIPS_RTPROC
)
12663 m
= bfd_zalloc (abfd
, amt
);
12667 m
->p_type
= PT_MIPS_RTPROC
;
12669 s
= bfd_get_section_by_name (abfd
, ".rtproc");
12674 m
->p_flags_valid
= 1;
12679 m
->sections
[0] = s
;
12682 /* We want to put it after the DYNAMIC segment. */
12683 pm
= &elf_seg_map (abfd
);
12684 while (*pm
!= NULL
&& (*pm
)->p_type
!= PT_DYNAMIC
)
12694 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
12695 .dynstr, .dynsym, and .hash sections, and everything in
12697 for (pm
= &elf_seg_map (abfd
); *pm
!= NULL
;
12699 if ((*pm
)->p_type
== PT_DYNAMIC
)
12702 /* GNU/Linux binaries do not need the extended PT_DYNAMIC section.
12703 glibc's dynamic linker has traditionally derived the number of
12704 tags from the p_filesz field, and sometimes allocates stack
12705 arrays of that size. An overly-big PT_DYNAMIC segment can
12706 be actively harmful in such cases. Making PT_DYNAMIC contain
12707 other sections can also make life hard for the prelinker,
12708 which might move one of the other sections to a different
12709 PT_LOAD segment. */
12710 if (SGI_COMPAT (abfd
)
12713 && strcmp (m
->sections
[0]->name
, ".dynamic") == 0)
12715 static const char *sec_names
[] =
12717 ".dynamic", ".dynstr", ".dynsym", ".hash"
12721 struct elf_segment_map
*n
;
12723 low
= ~(bfd_vma
) 0;
12725 for (i
= 0; i
< sizeof sec_names
/ sizeof sec_names
[0]; i
++)
12727 s
= bfd_get_section_by_name (abfd
, sec_names
[i
]);
12728 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
12735 if (high
< s
->vma
+ sz
)
12736 high
= s
->vma
+ sz
;
12741 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
12742 if ((s
->flags
& SEC_LOAD
) != 0
12744 && s
->vma
+ s
->size
<= high
)
12747 amt
= sizeof *n
- sizeof (asection
*) + c
* sizeof (asection
*);
12748 n
= bfd_zalloc (abfd
, amt
);
12755 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
12757 if ((s
->flags
& SEC_LOAD
) != 0
12759 && s
->vma
+ s
->size
<= high
)
12761 n
->sections
[i
] = s
;
12770 /* Allocate a spare program header in dynamic objects so that tools
12771 like the prelinker can add an extra PT_LOAD entry.
12773 If the prelinker needs to make room for a new PT_LOAD entry, its
12774 standard procedure is to move the first (read-only) sections into
12775 the new (writable) segment. However, the MIPS ABI requires
12776 .dynamic to be in a read-only segment, and the section will often
12777 start within sizeof (ElfNN_Phdr) bytes of the last program header.
12779 Although the prelinker could in principle move .dynamic to a
12780 writable segment, it seems better to allocate a spare program
12781 header instead, and avoid the need to move any sections.
12782 There is a long tradition of allocating spare dynamic tags,
12783 so allocating a spare program header seems like a natural
12786 If INFO is NULL, we may be copying an already prelinked binary
12787 with objcopy or strip, so do not add this header. */
12789 && !SGI_COMPAT (abfd
)
12790 && bfd_get_section_by_name (abfd
, ".dynamic"))
12792 for (pm
= &elf_seg_map (abfd
); *pm
!= NULL
; pm
= &(*pm
)->next
)
12793 if ((*pm
)->p_type
== PT_NULL
)
12797 m
= bfd_zalloc (abfd
, sizeof (*m
));
12801 m
->p_type
= PT_NULL
;
12809 /* Return the section that should be marked against GC for a given
12813 _bfd_mips_elf_gc_mark_hook (asection
*sec
,
12814 struct bfd_link_info
*info
,
12815 Elf_Internal_Rela
*rel
,
12816 struct elf_link_hash_entry
*h
,
12817 Elf_Internal_Sym
*sym
)
12819 /* ??? Do mips16 stub sections need to be handled special? */
12822 switch (ELF_R_TYPE (sec
->owner
, rel
->r_info
))
12824 case R_MIPS_GNU_VTINHERIT
:
12825 case R_MIPS_GNU_VTENTRY
:
12829 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
12832 /* Prevent .MIPS.abiflags from being discarded with --gc-sections. */
12835 _bfd_mips_elf_gc_mark_extra_sections (struct bfd_link_info
*info
,
12836 elf_gc_mark_hook_fn gc_mark_hook
)
12840 _bfd_elf_gc_mark_extra_sections (info
, gc_mark_hook
);
12842 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
12846 if (! is_mips_elf (sub
))
12849 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
12851 && MIPS_ELF_ABIFLAGS_SECTION_NAME_P (bfd_section_name (o
)))
12853 if (!_bfd_elf_gc_mark (info
, o
, gc_mark_hook
))
12861 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
12862 hiding the old indirect symbol. Process additional relocation
12863 information. Also called for weakdefs, in which case we just let
12864 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
12867 _bfd_mips_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
12868 struct elf_link_hash_entry
*dir
,
12869 struct elf_link_hash_entry
*ind
)
12871 struct mips_elf_link_hash_entry
*dirmips
, *indmips
;
12873 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
12875 dirmips
= (struct mips_elf_link_hash_entry
*) dir
;
12876 indmips
= (struct mips_elf_link_hash_entry
*) ind
;
12877 /* Any absolute non-dynamic relocations against an indirect or weak
12878 definition will be against the target symbol. */
12879 if (indmips
->has_static_relocs
)
12880 dirmips
->has_static_relocs
= TRUE
;
12882 if (ind
->root
.type
!= bfd_link_hash_indirect
)
12885 dirmips
->possibly_dynamic_relocs
+= indmips
->possibly_dynamic_relocs
;
12886 if (indmips
->readonly_reloc
)
12887 dirmips
->readonly_reloc
= TRUE
;
12888 if (indmips
->no_fn_stub
)
12889 dirmips
->no_fn_stub
= TRUE
;
12890 if (indmips
->fn_stub
)
12892 dirmips
->fn_stub
= indmips
->fn_stub
;
12893 indmips
->fn_stub
= NULL
;
12895 if (indmips
->need_fn_stub
)
12897 dirmips
->need_fn_stub
= TRUE
;
12898 indmips
->need_fn_stub
= FALSE
;
12900 if (indmips
->call_stub
)
12902 dirmips
->call_stub
= indmips
->call_stub
;
12903 indmips
->call_stub
= NULL
;
12905 if (indmips
->call_fp_stub
)
12907 dirmips
->call_fp_stub
= indmips
->call_fp_stub
;
12908 indmips
->call_fp_stub
= NULL
;
12910 if (indmips
->global_got_area
< dirmips
->global_got_area
)
12911 dirmips
->global_got_area
= indmips
->global_got_area
;
12912 if (indmips
->global_got_area
< GGA_NONE
)
12913 indmips
->global_got_area
= GGA_NONE
;
12914 if (indmips
->has_nonpic_branches
)
12915 dirmips
->has_nonpic_branches
= TRUE
;
12918 /* Take care of the special `__gnu_absolute_zero' symbol and ignore attempts
12919 to hide it. It has to remain global (it will also be protected) so as to
12920 be assigned a global GOT entry, which will then remain unchanged at load
12924 _bfd_mips_elf_hide_symbol (struct bfd_link_info
*info
,
12925 struct elf_link_hash_entry
*entry
,
12926 bfd_boolean force_local
)
12928 struct mips_elf_link_hash_table
*htab
;
12930 htab
= mips_elf_hash_table (info
);
12931 BFD_ASSERT (htab
!= NULL
);
12932 if (htab
->use_absolute_zero
12933 && strcmp (entry
->root
.root
.string
, "__gnu_absolute_zero") == 0)
12936 _bfd_elf_link_hash_hide_symbol (info
, entry
, force_local
);
12939 #define PDR_SIZE 32
12942 _bfd_mips_elf_discard_info (bfd
*abfd
, struct elf_reloc_cookie
*cookie
,
12943 struct bfd_link_info
*info
)
12946 bfd_boolean ret
= FALSE
;
12947 unsigned char *tdata
;
12950 o
= bfd_get_section_by_name (abfd
, ".pdr");
12955 if (o
->size
% PDR_SIZE
!= 0)
12957 if (o
->output_section
!= NULL
12958 && bfd_is_abs_section (o
->output_section
))
12961 tdata
= bfd_zmalloc (o
->size
/ PDR_SIZE
);
12965 cookie
->rels
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
12966 info
->keep_memory
);
12973 cookie
->rel
= cookie
->rels
;
12974 cookie
->relend
= cookie
->rels
+ o
->reloc_count
;
12976 for (i
= 0, skip
= 0; i
< o
->size
/ PDR_SIZE
; i
++)
12978 if (bfd_elf_reloc_symbol_deleted_p (i
* PDR_SIZE
, cookie
))
12987 mips_elf_section_data (o
)->u
.tdata
= tdata
;
12988 if (o
->rawsize
== 0)
12989 o
->rawsize
= o
->size
;
12990 o
->size
-= skip
* PDR_SIZE
;
12996 if (! info
->keep_memory
)
12997 free (cookie
->rels
);
13003 _bfd_mips_elf_ignore_discarded_relocs (asection
*sec
)
13005 if (strcmp (sec
->name
, ".pdr") == 0)
13011 _bfd_mips_elf_write_section (bfd
*output_bfd
,
13012 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
13013 asection
*sec
, bfd_byte
*contents
)
13015 bfd_byte
*to
, *from
, *end
;
13018 if (strcmp (sec
->name
, ".pdr") != 0)
13021 if (mips_elf_section_data (sec
)->u
.tdata
== NULL
)
13025 end
= contents
+ sec
->size
;
13026 for (from
= contents
, i
= 0;
13028 from
+= PDR_SIZE
, i
++)
13030 if ((mips_elf_section_data (sec
)->u
.tdata
)[i
] == 1)
13033 memcpy (to
, from
, PDR_SIZE
);
13036 bfd_set_section_contents (output_bfd
, sec
->output_section
, contents
,
13037 sec
->output_offset
, sec
->size
);
13041 /* microMIPS code retains local labels for linker relaxation. Omit them
13042 from output by default for clarity. */
13045 _bfd_mips_elf_is_target_special_symbol (bfd
*abfd
, asymbol
*sym
)
13047 return _bfd_elf_is_local_label_name (abfd
, sym
->name
);
13050 /* MIPS ELF uses a special find_nearest_line routine in order the
13051 handle the ECOFF debugging information. */
13053 struct mips_elf_find_line
13055 struct ecoff_debug_info d
;
13056 struct ecoff_find_line i
;
13060 _bfd_mips_elf_find_nearest_line (bfd
*abfd
, asymbol
**symbols
,
13061 asection
*section
, bfd_vma offset
,
13062 const char **filename_ptr
,
13063 const char **functionname_ptr
,
13064 unsigned int *line_ptr
,
13065 unsigned int *discriminator_ptr
)
13069 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
13070 filename_ptr
, functionname_ptr
,
13071 line_ptr
, discriminator_ptr
,
13072 dwarf_debug_sections
,
13073 &elf_tdata (abfd
)->dwarf2_find_line_info
)
13077 if (_bfd_dwarf1_find_nearest_line (abfd
, symbols
, section
, offset
,
13078 filename_ptr
, functionname_ptr
,
13081 if (!*functionname_ptr
)
13082 _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
13083 *filename_ptr
? NULL
: filename_ptr
,
13088 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
13091 flagword origflags
;
13092 struct mips_elf_find_line
*fi
;
13093 const struct ecoff_debug_swap
* const swap
=
13094 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
13096 /* If we are called during a link, mips_elf_final_link may have
13097 cleared the SEC_HAS_CONTENTS field. We force it back on here
13098 if appropriate (which it normally will be). */
13099 origflags
= msec
->flags
;
13100 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
13101 msec
->flags
|= SEC_HAS_CONTENTS
;
13103 fi
= mips_elf_tdata (abfd
)->find_line_info
;
13106 bfd_size_type external_fdr_size
;
13109 struct fdr
*fdr_ptr
;
13110 bfd_size_type amt
= sizeof (struct mips_elf_find_line
);
13112 fi
= bfd_zalloc (abfd
, amt
);
13115 msec
->flags
= origflags
;
13119 if (! _bfd_mips_elf_read_ecoff_info (abfd
, msec
, &fi
->d
))
13121 msec
->flags
= origflags
;
13125 /* Swap in the FDR information. */
13126 amt
= fi
->d
.symbolic_header
.ifdMax
* sizeof (struct fdr
);
13127 fi
->d
.fdr
= bfd_alloc (abfd
, amt
);
13128 if (fi
->d
.fdr
== NULL
)
13130 msec
->flags
= origflags
;
13133 external_fdr_size
= swap
->external_fdr_size
;
13134 fdr_ptr
= fi
->d
.fdr
;
13135 fraw_src
= (char *) fi
->d
.external_fdr
;
13136 fraw_end
= (fraw_src
13137 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
13138 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
13139 (*swap
->swap_fdr_in
) (abfd
, fraw_src
, fdr_ptr
);
13141 mips_elf_tdata (abfd
)->find_line_info
= fi
;
13143 /* Note that we don't bother to ever free this information.
13144 find_nearest_line is either called all the time, as in
13145 objdump -l, so the information should be saved, or it is
13146 rarely called, as in ld error messages, so the memory
13147 wasted is unimportant. Still, it would probably be a
13148 good idea for free_cached_info to throw it away. */
13151 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
13152 &fi
->i
, filename_ptr
, functionname_ptr
,
13155 msec
->flags
= origflags
;
13159 msec
->flags
= origflags
;
13162 /* Fall back on the generic ELF find_nearest_line routine. */
13164 return _bfd_elf_find_nearest_line (abfd
, symbols
, section
, offset
,
13165 filename_ptr
, functionname_ptr
,
13166 line_ptr
, discriminator_ptr
);
13170 _bfd_mips_elf_find_inliner_info (bfd
*abfd
,
13171 const char **filename_ptr
,
13172 const char **functionname_ptr
,
13173 unsigned int *line_ptr
)
13176 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
13177 functionname_ptr
, line_ptr
,
13178 & elf_tdata (abfd
)->dwarf2_find_line_info
);
13183 /* When are writing out the .options or .MIPS.options section,
13184 remember the bytes we are writing out, so that we can install the
13185 GP value in the section_processing routine. */
13188 _bfd_mips_elf_set_section_contents (bfd
*abfd
, sec_ptr section
,
13189 const void *location
,
13190 file_ptr offset
, bfd_size_type count
)
13192 if (MIPS_ELF_OPTIONS_SECTION_NAME_P (section
->name
))
13196 if (elf_section_data (section
) == NULL
)
13198 size_t amt
= sizeof (struct bfd_elf_section_data
);
13199 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
13200 if (elf_section_data (section
) == NULL
)
13203 c
= mips_elf_section_data (section
)->u
.tdata
;
13206 c
= bfd_zalloc (abfd
, section
->size
);
13209 mips_elf_section_data (section
)->u
.tdata
= c
;
13212 memcpy (c
+ offset
, location
, count
);
13215 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
,
13219 /* This is almost identical to bfd_generic_get_... except that some
13220 MIPS relocations need to be handled specially. Sigh. */
13223 _bfd_elf_mips_get_relocated_section_contents
13225 struct bfd_link_info
*link_info
,
13226 struct bfd_link_order
*link_order
,
13228 bfd_boolean relocatable
,
13231 /* Get enough memory to hold the stuff */
13232 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
13233 asection
*input_section
= link_order
->u
.indirect
.section
;
13236 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
13237 arelent
**reloc_vector
= NULL
;
13240 if (reloc_size
< 0)
13243 reloc_vector
= bfd_malloc (reloc_size
);
13244 if (reloc_vector
== NULL
&& reloc_size
!= 0)
13247 /* read in the section */
13248 sz
= input_section
->rawsize
? input_section
->rawsize
: input_section
->size
;
13249 if (!bfd_get_section_contents (input_bfd
, input_section
, data
, 0, sz
))
13252 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
13256 if (reloc_count
< 0)
13259 if (reloc_count
> 0)
13264 bfd_vma gp
= 0x12345678; /* initialize just to shut gcc up */
13267 struct bfd_hash_entry
*h
;
13268 struct bfd_link_hash_entry
*lh
;
13269 /* Skip all this stuff if we aren't mixing formats. */
13270 if (abfd
&& input_bfd
13271 && abfd
->xvec
== input_bfd
->xvec
)
13275 h
= bfd_hash_lookup (&link_info
->hash
->table
, "_gp", FALSE
, FALSE
);
13276 lh
= (struct bfd_link_hash_entry
*) h
;
13283 case bfd_link_hash_undefined
:
13284 case bfd_link_hash_undefweak
:
13285 case bfd_link_hash_common
:
13288 case bfd_link_hash_defined
:
13289 case bfd_link_hash_defweak
:
13291 gp
= lh
->u
.def
.value
;
13293 case bfd_link_hash_indirect
:
13294 case bfd_link_hash_warning
:
13296 /* @@FIXME ignoring warning for now */
13298 case bfd_link_hash_new
:
13307 for (parent
= reloc_vector
; *parent
!= NULL
; parent
++)
13309 char *error_message
= NULL
;
13310 bfd_reloc_status_type r
;
13312 /* Specific to MIPS: Deal with relocation types that require
13313 knowing the gp of the output bfd. */
13314 asymbol
*sym
= *(*parent
)->sym_ptr_ptr
;
13316 /* If we've managed to find the gp and have a special
13317 function for the relocation then go ahead, else default
13318 to the generic handling. */
13320 && (*parent
)->howto
->special_function
13321 == _bfd_mips_elf32_gprel16_reloc
)
13322 r
= _bfd_mips_elf_gprel16_with_gp (input_bfd
, sym
, *parent
,
13323 input_section
, relocatable
,
13326 r
= bfd_perform_relocation (input_bfd
, *parent
, data
,
13328 relocatable
? abfd
: NULL
,
13333 asection
*os
= input_section
->output_section
;
13335 /* A partial link, so keep the relocs */
13336 os
->orelocation
[os
->reloc_count
] = *parent
;
13340 if (r
!= bfd_reloc_ok
)
13344 case bfd_reloc_undefined
:
13345 (*link_info
->callbacks
->undefined_symbol
)
13346 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
13347 input_bfd
, input_section
, (*parent
)->address
, TRUE
);
13349 case bfd_reloc_dangerous
:
13350 BFD_ASSERT (error_message
!= NULL
);
13351 (*link_info
->callbacks
->reloc_dangerous
)
13352 (link_info
, error_message
,
13353 input_bfd
, input_section
, (*parent
)->address
);
13355 case bfd_reloc_overflow
:
13356 (*link_info
->callbacks
->reloc_overflow
)
13358 bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
13359 (*parent
)->howto
->name
, (*parent
)->addend
,
13360 input_bfd
, input_section
, (*parent
)->address
);
13362 case bfd_reloc_outofrange
:
13371 free (reloc_vector
);
13375 free (reloc_vector
);
13380 mips_elf_relax_delete_bytes (bfd
*abfd
,
13381 asection
*sec
, bfd_vma addr
, int count
)
13383 Elf_Internal_Shdr
*symtab_hdr
;
13384 unsigned int sec_shndx
;
13385 bfd_byte
*contents
;
13386 Elf_Internal_Rela
*irel
, *irelend
;
13387 Elf_Internal_Sym
*isym
;
13388 Elf_Internal_Sym
*isymend
;
13389 struct elf_link_hash_entry
**sym_hashes
;
13390 struct elf_link_hash_entry
**end_hashes
;
13391 struct elf_link_hash_entry
**start_hashes
;
13392 unsigned int symcount
;
13394 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
13395 contents
= elf_section_data (sec
)->this_hdr
.contents
;
13397 irel
= elf_section_data (sec
)->relocs
;
13398 irelend
= irel
+ sec
->reloc_count
;
13400 /* Actually delete the bytes. */
13401 memmove (contents
+ addr
, contents
+ addr
+ count
,
13402 (size_t) (sec
->size
- addr
- count
));
13403 sec
->size
-= count
;
13405 /* Adjust all the relocs. */
13406 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
13408 /* Get the new reloc address. */
13409 if (irel
->r_offset
> addr
)
13410 irel
->r_offset
-= count
;
13413 BFD_ASSERT (addr
% 2 == 0);
13414 BFD_ASSERT (count
% 2 == 0);
13416 /* Adjust the local symbols defined in this section. */
13417 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
13418 isym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
13419 for (isymend
= isym
+ symtab_hdr
->sh_info
; isym
< isymend
; isym
++)
13420 if (isym
->st_shndx
== sec_shndx
&& isym
->st_value
> addr
)
13421 isym
->st_value
-= count
;
13423 /* Now adjust the global symbols defined in this section. */
13424 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
13425 - symtab_hdr
->sh_info
);
13426 sym_hashes
= start_hashes
= elf_sym_hashes (abfd
);
13427 end_hashes
= sym_hashes
+ symcount
;
13429 for (; sym_hashes
< end_hashes
; sym_hashes
++)
13431 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
13433 if ((sym_hash
->root
.type
== bfd_link_hash_defined
13434 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
13435 && sym_hash
->root
.u
.def
.section
== sec
)
13437 bfd_vma value
= sym_hash
->root
.u
.def
.value
;
13439 if (ELF_ST_IS_MICROMIPS (sym_hash
->other
))
13440 value
&= MINUS_TWO
;
13442 sym_hash
->root
.u
.def
.value
-= count
;
13450 /* Opcodes needed for microMIPS relaxation as found in
13451 opcodes/micromips-opc.c. */
13453 struct opcode_descriptor
{
13454 unsigned long match
;
13455 unsigned long mask
;
13458 /* The $ra register aka $31. */
13462 /* 32-bit instruction format register fields. */
13464 #define OP32_SREG(opcode) (((opcode) >> 16) & 0x1f)
13465 #define OP32_TREG(opcode) (((opcode) >> 21) & 0x1f)
13467 /* Check if a 5-bit register index can be abbreviated to 3 bits. */
13469 #define OP16_VALID_REG(r) \
13470 ((2 <= (r) && (r) <= 7) || (16 <= (r) && (r) <= 17))
13473 /* 32-bit and 16-bit branches. */
13475 static const struct opcode_descriptor b_insns_32
[] = {
13476 { /* "b", "p", */ 0x40400000, 0xffff0000 }, /* bgez 0 */
13477 { /* "b", "p", */ 0x94000000, 0xffff0000 }, /* beq 0, 0 */
13478 { 0, 0 } /* End marker for find_match(). */
13481 static const struct opcode_descriptor bc_insn_32
=
13482 { /* "bc(1|2)(ft)", "N,p", */ 0x42800000, 0xfec30000 };
13484 static const struct opcode_descriptor bz_insn_32
=
13485 { /* "b(g|l)(e|t)z", "s,p", */ 0x40000000, 0xff200000 };
13487 static const struct opcode_descriptor bzal_insn_32
=
13488 { /* "b(ge|lt)zal", "s,p", */ 0x40200000, 0xffa00000 };
13490 static const struct opcode_descriptor beq_insn_32
=
13491 { /* "b(eq|ne)", "s,t,p", */ 0x94000000, 0xdc000000 };
13493 static const struct opcode_descriptor b_insn_16
=
13494 { /* "b", "mD", */ 0xcc00, 0xfc00 };
13496 static const struct opcode_descriptor bz_insn_16
=
13497 { /* "b(eq|ne)z", "md,mE", */ 0x8c00, 0xdc00 };
13500 /* 32-bit and 16-bit branch EQ and NE zero. */
13502 /* NOTE: All opcode tables have BEQ/BNE in the same order: first the
13503 eq and second the ne. This convention is used when replacing a
13504 32-bit BEQ/BNE with the 16-bit version. */
13506 #define BZC32_REG_FIELD(r) (((r) & 0x1f) << 16)
13508 static const struct opcode_descriptor bz_rs_insns_32
[] = {
13509 { /* "beqz", "s,p", */ 0x94000000, 0xffe00000 },
13510 { /* "bnez", "s,p", */ 0xb4000000, 0xffe00000 },
13511 { 0, 0 } /* End marker for find_match(). */
13514 static const struct opcode_descriptor bz_rt_insns_32
[] = {
13515 { /* "beqz", "t,p", */ 0x94000000, 0xfc01f000 },
13516 { /* "bnez", "t,p", */ 0xb4000000, 0xfc01f000 },
13517 { 0, 0 } /* End marker for find_match(). */
13520 static const struct opcode_descriptor bzc_insns_32
[] = {
13521 { /* "beqzc", "s,p", */ 0x40e00000, 0xffe00000 },
13522 { /* "bnezc", "s,p", */ 0x40a00000, 0xffe00000 },
13523 { 0, 0 } /* End marker for find_match(). */
13526 static const struct opcode_descriptor bz_insns_16
[] = {
13527 { /* "beqz", "md,mE", */ 0x8c00, 0xfc00 },
13528 { /* "bnez", "md,mE", */ 0xac00, 0xfc00 },
13529 { 0, 0 } /* End marker for find_match(). */
13532 /* Switch between a 5-bit register index and its 3-bit shorthand. */
13534 #define BZ16_REG(opcode) ((((((opcode) >> 7) & 7) + 0x1e) & 0xf) + 2)
13535 #define BZ16_REG_FIELD(r) (((r) & 7) << 7)
13538 /* 32-bit instructions with a delay slot. */
13540 static const struct opcode_descriptor jal_insn_32_bd16
=
13541 { /* "jals", "a", */ 0x74000000, 0xfc000000 };
13543 static const struct opcode_descriptor jal_insn_32_bd32
=
13544 { /* "jal", "a", */ 0xf4000000, 0xfc000000 };
13546 static const struct opcode_descriptor jal_x_insn_32_bd32
=
13547 { /* "jal[x]", "a", */ 0xf0000000, 0xf8000000 };
13549 static const struct opcode_descriptor j_insn_32
=
13550 { /* "j", "a", */ 0xd4000000, 0xfc000000 };
13552 static const struct opcode_descriptor jalr_insn_32
=
13553 { /* "jalr[.hb]", "t,s", */ 0x00000f3c, 0xfc00efff };
13555 /* This table can be compacted, because no opcode replacement is made. */
13557 static const struct opcode_descriptor ds_insns_32_bd16
[] = {
13558 { /* "jals", "a", */ 0x74000000, 0xfc000000 },
13560 { /* "jalrs[.hb]", "t,s", */ 0x00004f3c, 0xfc00efff },
13561 { /* "b(ge|lt)zals", "s,p", */ 0x42200000, 0xffa00000 },
13563 { /* "b(g|l)(e|t)z", "s,p", */ 0x40000000, 0xff200000 },
13564 { /* "b(eq|ne)", "s,t,p", */ 0x94000000, 0xdc000000 },
13565 { /* "j", "a", */ 0xd4000000, 0xfc000000 },
13566 { 0, 0 } /* End marker for find_match(). */
13569 /* This table can be compacted, because no opcode replacement is made. */
13571 static const struct opcode_descriptor ds_insns_32_bd32
[] = {
13572 { /* "jal[x]", "a", */ 0xf0000000, 0xf8000000 },
13574 { /* "jalr[.hb]", "t,s", */ 0x00000f3c, 0xfc00efff },
13575 { /* "b(ge|lt)zal", "s,p", */ 0x40200000, 0xffa00000 },
13576 { 0, 0 } /* End marker for find_match(). */
13580 /* 16-bit instructions with a delay slot. */
13582 static const struct opcode_descriptor jalr_insn_16_bd16
=
13583 { /* "jalrs", "my,mj", */ 0x45e0, 0xffe0 };
13585 static const struct opcode_descriptor jalr_insn_16_bd32
=
13586 { /* "jalr", "my,mj", */ 0x45c0, 0xffe0 };
13588 static const struct opcode_descriptor jr_insn_16
=
13589 { /* "jr", "mj", */ 0x4580, 0xffe0 };
13591 #define JR16_REG(opcode) ((opcode) & 0x1f)
13593 /* This table can be compacted, because no opcode replacement is made. */
13595 static const struct opcode_descriptor ds_insns_16_bd16
[] = {
13596 { /* "jalrs", "my,mj", */ 0x45e0, 0xffe0 },
13598 { /* "b", "mD", */ 0xcc00, 0xfc00 },
13599 { /* "b(eq|ne)z", "md,mE", */ 0x8c00, 0xdc00 },
13600 { /* "jr", "mj", */ 0x4580, 0xffe0 },
13601 { 0, 0 } /* End marker for find_match(). */
13605 /* LUI instruction. */
13607 static const struct opcode_descriptor lui_insn
=
13608 { /* "lui", "s,u", */ 0x41a00000, 0xffe00000 };
13611 /* ADDIU instruction. */
13613 static const struct opcode_descriptor addiu_insn
=
13614 { /* "addiu", "t,r,j", */ 0x30000000, 0xfc000000 };
13616 static const struct opcode_descriptor addiupc_insn
=
13617 { /* "addiu", "mb,$pc,mQ", */ 0x78000000, 0xfc000000 };
13619 #define ADDIUPC_REG_FIELD(r) \
13620 (((2 <= (r) && (r) <= 7) ? (r) : ((r) - 16)) << 23)
13623 /* Relaxable instructions in a JAL delay slot: MOVE. */
13625 /* The 16-bit move has rd in 9:5 and rs in 4:0. The 32-bit moves
13626 (ADDU, OR) have rd in 15:11 and rs in 10:16. */
13627 #define MOVE32_RD(opcode) (((opcode) >> 11) & 0x1f)
13628 #define MOVE32_RS(opcode) (((opcode) >> 16) & 0x1f)
13630 #define MOVE16_RD_FIELD(r) (((r) & 0x1f) << 5)
13631 #define MOVE16_RS_FIELD(r) (((r) & 0x1f) )
13633 static const struct opcode_descriptor move_insns_32
[] = {
13634 { /* "move", "d,s", */ 0x00000290, 0xffe007ff }, /* or d,s,$0 */
13635 { /* "move", "d,s", */ 0x00000150, 0xffe007ff }, /* addu d,s,$0 */
13636 { 0, 0 } /* End marker for find_match(). */
13639 static const struct opcode_descriptor move_insn_16
=
13640 { /* "move", "mp,mj", */ 0x0c00, 0xfc00 };
13643 /* NOP instructions. */
13645 static const struct opcode_descriptor nop_insn_32
=
13646 { /* "nop", "", */ 0x00000000, 0xffffffff };
13648 static const struct opcode_descriptor nop_insn_16
=
13649 { /* "nop", "", */ 0x0c00, 0xffff };
13652 /* Instruction match support. */
13654 #define MATCH(opcode, insn) ((opcode & insn.mask) == insn.match)
13657 find_match (unsigned long opcode
, const struct opcode_descriptor insn
[])
13659 unsigned long indx
;
13661 for (indx
= 0; insn
[indx
].mask
!= 0; indx
++)
13662 if (MATCH (opcode
, insn
[indx
]))
13669 /* Branch and delay slot decoding support. */
13671 /* If PTR points to what *might* be a 16-bit branch or jump, then
13672 return the minimum length of its delay slot, otherwise return 0.
13673 Non-zero results are not definitive as we might be checking against
13674 the second half of another instruction. */
13677 check_br16_dslot (bfd
*abfd
, bfd_byte
*ptr
)
13679 unsigned long opcode
;
13682 opcode
= bfd_get_16 (abfd
, ptr
);
13683 if (MATCH (opcode
, jalr_insn_16_bd32
) != 0)
13684 /* 16-bit branch/jump with a 32-bit delay slot. */
13686 else if (MATCH (opcode
, jalr_insn_16_bd16
) != 0
13687 || find_match (opcode
, ds_insns_16_bd16
) >= 0)
13688 /* 16-bit branch/jump with a 16-bit delay slot. */
13691 /* No delay slot. */
13697 /* If PTR points to what *might* be a 32-bit branch or jump, then
13698 return the minimum length of its delay slot, otherwise return 0.
13699 Non-zero results are not definitive as we might be checking against
13700 the second half of another instruction. */
13703 check_br32_dslot (bfd
*abfd
, bfd_byte
*ptr
)
13705 unsigned long opcode
;
13708 opcode
= bfd_get_micromips_32 (abfd
, ptr
);
13709 if (find_match (opcode
, ds_insns_32_bd32
) >= 0)
13710 /* 32-bit branch/jump with a 32-bit delay slot. */
13712 else if (find_match (opcode
, ds_insns_32_bd16
) >= 0)
13713 /* 32-bit branch/jump with a 16-bit delay slot. */
13716 /* No delay slot. */
13722 /* If PTR points to a 16-bit branch or jump with a 32-bit delay slot
13723 that doesn't fiddle with REG, then return TRUE, otherwise FALSE. */
13726 check_br16 (bfd
*abfd
, bfd_byte
*ptr
, unsigned long reg
)
13728 unsigned long opcode
;
13730 opcode
= bfd_get_16 (abfd
, ptr
);
13731 if (MATCH (opcode
, b_insn_16
)
13733 || (MATCH (opcode
, jr_insn_16
) && reg
!= JR16_REG (opcode
))
13735 || (MATCH (opcode
, bz_insn_16
) && reg
!= BZ16_REG (opcode
))
13736 /* BEQZ16, BNEZ16 */
13737 || (MATCH (opcode
, jalr_insn_16_bd32
)
13739 && reg
!= JR16_REG (opcode
) && reg
!= RA
))
13745 /* If PTR points to a 32-bit branch or jump that doesn't fiddle with REG,
13746 then return TRUE, otherwise FALSE. */
13749 check_br32 (bfd
*abfd
, bfd_byte
*ptr
, unsigned long reg
)
13751 unsigned long opcode
;
13753 opcode
= bfd_get_micromips_32 (abfd
, ptr
);
13754 if (MATCH (opcode
, j_insn_32
)
13756 || MATCH (opcode
, bc_insn_32
)
13757 /* BC1F, BC1T, BC2F, BC2T */
13758 || (MATCH (opcode
, jal_x_insn_32_bd32
) && reg
!= RA
)
13760 || (MATCH (opcode
, bz_insn_32
) && reg
!= OP32_SREG (opcode
))
13761 /* BGEZ, BGTZ, BLEZ, BLTZ */
13762 || (MATCH (opcode
, bzal_insn_32
)
13763 /* BGEZAL, BLTZAL */
13764 && reg
!= OP32_SREG (opcode
) && reg
!= RA
)
13765 || ((MATCH (opcode
, jalr_insn_32
) || MATCH (opcode
, beq_insn_32
))
13766 /* JALR, JALR.HB, BEQ, BNE */
13767 && reg
!= OP32_SREG (opcode
) && reg
!= OP32_TREG (opcode
)))
13773 /* If the instruction encoding at PTR and relocations [INTERNAL_RELOCS,
13774 IRELEND) at OFFSET indicate that there must be a compact branch there,
13775 then return TRUE, otherwise FALSE. */
13778 check_relocated_bzc (bfd
*abfd
, const bfd_byte
*ptr
, bfd_vma offset
,
13779 const Elf_Internal_Rela
*internal_relocs
,
13780 const Elf_Internal_Rela
*irelend
)
13782 const Elf_Internal_Rela
*irel
;
13783 unsigned long opcode
;
13785 opcode
= bfd_get_micromips_32 (abfd
, ptr
);
13786 if (find_match (opcode
, bzc_insns_32
) < 0)
13789 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
13790 if (irel
->r_offset
== offset
13791 && ELF32_R_TYPE (irel
->r_info
) == R_MICROMIPS_PC16_S1
)
13797 /* Bitsize checking. */
13798 #define IS_BITSIZE(val, N) \
13799 (((((val) & ((1ULL << (N)) - 1)) ^ (1ULL << ((N) - 1))) \
13800 - (1ULL << ((N) - 1))) == (val))
13804 _bfd_mips_elf_relax_section (bfd
*abfd
, asection
*sec
,
13805 struct bfd_link_info
*link_info
,
13806 bfd_boolean
*again
)
13808 bfd_boolean insn32
= mips_elf_hash_table (link_info
)->insn32
;
13809 Elf_Internal_Shdr
*symtab_hdr
;
13810 Elf_Internal_Rela
*internal_relocs
;
13811 Elf_Internal_Rela
*irel
, *irelend
;
13812 bfd_byte
*contents
= NULL
;
13813 Elf_Internal_Sym
*isymbuf
= NULL
;
13815 /* Assume nothing changes. */
13818 /* We don't have to do anything for a relocatable link, if
13819 this section does not have relocs, or if this is not a
13822 if (bfd_link_relocatable (link_info
)
13823 || (sec
->flags
& SEC_RELOC
) == 0
13824 || sec
->reloc_count
== 0
13825 || (sec
->flags
& SEC_CODE
) == 0)
13828 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
13830 /* Get a copy of the native relocations. */
13831 internal_relocs
= (_bfd_elf_link_read_relocs
13832 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
13833 link_info
->keep_memory
));
13834 if (internal_relocs
== NULL
)
13837 /* Walk through them looking for relaxing opportunities. */
13838 irelend
= internal_relocs
+ sec
->reloc_count
;
13839 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
13841 unsigned long r_symndx
= ELF32_R_SYM (irel
->r_info
);
13842 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
13843 bfd_boolean target_is_micromips_code_p
;
13844 unsigned long opcode
;
13850 /* The number of bytes to delete for relaxation and from where
13851 to delete these bytes starting at irel->r_offset. */
13855 /* If this isn't something that can be relaxed, then ignore
13857 if (r_type
!= R_MICROMIPS_HI16
13858 && r_type
!= R_MICROMIPS_PC16_S1
13859 && r_type
!= R_MICROMIPS_26_S1
)
13862 /* Get the section contents if we haven't done so already. */
13863 if (contents
== NULL
)
13865 /* Get cached copy if it exists. */
13866 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
13867 contents
= elf_section_data (sec
)->this_hdr
.contents
;
13868 /* Go get them off disk. */
13869 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
13872 ptr
= contents
+ irel
->r_offset
;
13874 /* Read this BFD's local symbols if we haven't done so already. */
13875 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
13877 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
13878 if (isymbuf
== NULL
)
13879 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
13880 symtab_hdr
->sh_info
, 0,
13882 if (isymbuf
== NULL
)
13886 /* Get the value of the symbol referred to by the reloc. */
13887 if (r_symndx
< symtab_hdr
->sh_info
)
13889 /* A local symbol. */
13890 Elf_Internal_Sym
*isym
;
13893 isym
= isymbuf
+ r_symndx
;
13894 if (isym
->st_shndx
== SHN_UNDEF
)
13895 sym_sec
= bfd_und_section_ptr
;
13896 else if (isym
->st_shndx
== SHN_ABS
)
13897 sym_sec
= bfd_abs_section_ptr
;
13898 else if (isym
->st_shndx
== SHN_COMMON
)
13899 sym_sec
= bfd_com_section_ptr
;
13901 sym_sec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
13902 symval
= (isym
->st_value
13903 + sym_sec
->output_section
->vma
13904 + sym_sec
->output_offset
);
13905 target_is_micromips_code_p
= ELF_ST_IS_MICROMIPS (isym
->st_other
);
13909 unsigned long indx
;
13910 struct elf_link_hash_entry
*h
;
13912 /* An external symbol. */
13913 indx
= r_symndx
- symtab_hdr
->sh_info
;
13914 h
= elf_sym_hashes (abfd
)[indx
];
13915 BFD_ASSERT (h
!= NULL
);
13917 if (h
->root
.type
!= bfd_link_hash_defined
13918 && h
->root
.type
!= bfd_link_hash_defweak
)
13919 /* This appears to be a reference to an undefined
13920 symbol. Just ignore it -- it will be caught by the
13921 regular reloc processing. */
13924 symval
= (h
->root
.u
.def
.value
13925 + h
->root
.u
.def
.section
->output_section
->vma
13926 + h
->root
.u
.def
.section
->output_offset
);
13927 target_is_micromips_code_p
= (!h
->needs_plt
13928 && ELF_ST_IS_MICROMIPS (h
->other
));
13932 /* For simplicity of coding, we are going to modify the
13933 section contents, the section relocs, and the BFD symbol
13934 table. We must tell the rest of the code not to free up this
13935 information. It would be possible to instead create a table
13936 of changes which have to be made, as is done in coff-mips.c;
13937 that would be more work, but would require less memory when
13938 the linker is run. */
13940 /* Only 32-bit instructions relaxed. */
13941 if (irel
->r_offset
+ 4 > sec
->size
)
13944 opcode
= bfd_get_micromips_32 (abfd
, ptr
);
13946 /* This is the pc-relative distance from the instruction the
13947 relocation is applied to, to the symbol referred. */
13949 - (sec
->output_section
->vma
+ sec
->output_offset
)
13952 /* R_MICROMIPS_HI16 / LUI relaxation to nil, performing relaxation
13953 of corresponding R_MICROMIPS_LO16 to R_MICROMIPS_HI0_LO16 or
13954 R_MICROMIPS_PC23_S2. The R_MICROMIPS_PC23_S2 condition is
13956 (symval % 4 == 0 && IS_BITSIZE (pcrval, 25))
13958 where pcrval has first to be adjusted to apply against the LO16
13959 location (we make the adjustment later on, when we have figured
13960 out the offset). */
13961 if (r_type
== R_MICROMIPS_HI16
&& MATCH (opcode
, lui_insn
))
13963 bfd_boolean bzc
= FALSE
;
13964 unsigned long nextopc
;
13968 /* Give up if the previous reloc was a HI16 against this symbol
13970 if (irel
> internal_relocs
13971 && ELF32_R_TYPE (irel
[-1].r_info
) == R_MICROMIPS_HI16
13972 && ELF32_R_SYM (irel
[-1].r_info
) == r_symndx
)
13975 /* Or if the next reloc is not a LO16 against this symbol. */
13976 if (irel
+ 1 >= irelend
13977 || ELF32_R_TYPE (irel
[1].r_info
) != R_MICROMIPS_LO16
13978 || ELF32_R_SYM (irel
[1].r_info
) != r_symndx
)
13981 /* Or if the second next reloc is a LO16 against this symbol too. */
13982 if (irel
+ 2 >= irelend
13983 && ELF32_R_TYPE (irel
[2].r_info
) == R_MICROMIPS_LO16
13984 && ELF32_R_SYM (irel
[2].r_info
) == r_symndx
)
13987 /* See if the LUI instruction *might* be in a branch delay slot.
13988 We check whether what looks like a 16-bit branch or jump is
13989 actually an immediate argument to a compact branch, and let
13990 it through if so. */
13991 if (irel
->r_offset
>= 2
13992 && check_br16_dslot (abfd
, ptr
- 2)
13993 && !(irel
->r_offset
>= 4
13994 && (bzc
= check_relocated_bzc (abfd
,
13995 ptr
- 4, irel
->r_offset
- 4,
13996 internal_relocs
, irelend
))))
13998 if (irel
->r_offset
>= 4
14000 && check_br32_dslot (abfd
, ptr
- 4))
14003 reg
= OP32_SREG (opcode
);
14005 /* We only relax adjacent instructions or ones separated with
14006 a branch or jump that has a delay slot. The branch or jump
14007 must not fiddle with the register used to hold the address.
14008 Subtract 4 for the LUI itself. */
14009 offset
= irel
[1].r_offset
- irel
[0].r_offset
;
14010 switch (offset
- 4)
14015 if (check_br16 (abfd
, ptr
+ 4, reg
))
14019 if (check_br32 (abfd
, ptr
+ 4, reg
))
14026 nextopc
= bfd_get_micromips_32 (abfd
, contents
+ irel
[1].r_offset
);
14028 /* Give up unless the same register is used with both
14030 if (OP32_SREG (nextopc
) != reg
)
14033 /* Now adjust pcrval, subtracting the offset to the LO16 reloc
14034 and rounding up to take masking of the two LSBs into account. */
14035 pcrval
= ((pcrval
- offset
+ 3) | 3) ^ 3;
14037 /* R_MICROMIPS_LO16 relaxation to R_MICROMIPS_HI0_LO16. */
14038 if (IS_BITSIZE (symval
, 16))
14040 /* Fix the relocation's type. */
14041 irel
[1].r_info
= ELF32_R_INFO (r_symndx
, R_MICROMIPS_HI0_LO16
);
14043 /* Instructions using R_MICROMIPS_LO16 have the base or
14044 source register in bits 20:16. This register becomes $0
14045 (zero) as the result of the R_MICROMIPS_HI16 being 0. */
14046 nextopc
&= ~0x001f0000;
14047 bfd_put_16 (abfd
, (nextopc
>> 16) & 0xffff,
14048 contents
+ irel
[1].r_offset
);
14051 /* R_MICROMIPS_LO16 / ADDIU relaxation to R_MICROMIPS_PC23_S2.
14052 We add 4 to take LUI deletion into account while checking
14053 the PC-relative distance. */
14054 else if (symval
% 4 == 0
14055 && IS_BITSIZE (pcrval
+ 4, 25)
14056 && MATCH (nextopc
, addiu_insn
)
14057 && OP32_TREG (nextopc
) == OP32_SREG (nextopc
)
14058 && OP16_VALID_REG (OP32_TREG (nextopc
)))
14060 /* Fix the relocation's type. */
14061 irel
[1].r_info
= ELF32_R_INFO (r_symndx
, R_MICROMIPS_PC23_S2
);
14063 /* Replace ADDIU with the ADDIUPC version. */
14064 nextopc
= (addiupc_insn
.match
14065 | ADDIUPC_REG_FIELD (OP32_TREG (nextopc
)));
14067 bfd_put_micromips_32 (abfd
, nextopc
,
14068 contents
+ irel
[1].r_offset
);
14071 /* Can't do anything, give up, sigh... */
14075 /* Fix the relocation's type. */
14076 irel
->r_info
= ELF32_R_INFO (r_symndx
, R_MIPS_NONE
);
14078 /* Delete the LUI instruction: 4 bytes at irel->r_offset. */
14083 /* Compact branch relaxation -- due to the multitude of macros
14084 employed by the compiler/assembler, compact branches are not
14085 always generated. Obviously, this can/will be fixed elsewhere,
14086 but there is no drawback in double checking it here. */
14087 else if (r_type
== R_MICROMIPS_PC16_S1
14088 && irel
->r_offset
+ 5 < sec
->size
14089 && ((fndopc
= find_match (opcode
, bz_rs_insns_32
)) >= 0
14090 || (fndopc
= find_match (opcode
, bz_rt_insns_32
)) >= 0)
14092 && (delcnt
= MATCH (bfd_get_16 (abfd
, ptr
+ 4),
14093 nop_insn_16
) ? 2 : 0))
14094 || (irel
->r_offset
+ 7 < sec
->size
14095 && (delcnt
= MATCH (bfd_get_micromips_32 (abfd
,
14097 nop_insn_32
) ? 4 : 0))))
14101 reg
= OP32_SREG (opcode
) ? OP32_SREG (opcode
) : OP32_TREG (opcode
);
14103 /* Replace BEQZ/BNEZ with the compact version. */
14104 opcode
= (bzc_insns_32
[fndopc
].match
14105 | BZC32_REG_FIELD (reg
)
14106 | (opcode
& 0xffff)); /* Addend value. */
14108 bfd_put_micromips_32 (abfd
, opcode
, ptr
);
14110 /* Delete the delay slot NOP: two or four bytes from
14111 irel->offset + 4; delcnt has already been set above. */
14115 /* R_MICROMIPS_PC16_S1 relaxation to R_MICROMIPS_PC10_S1. We need
14116 to check the distance from the next instruction, so subtract 2. */
14118 && r_type
== R_MICROMIPS_PC16_S1
14119 && IS_BITSIZE (pcrval
- 2, 11)
14120 && find_match (opcode
, b_insns_32
) >= 0)
14122 /* Fix the relocation's type. */
14123 irel
->r_info
= ELF32_R_INFO (r_symndx
, R_MICROMIPS_PC10_S1
);
14125 /* Replace the 32-bit opcode with a 16-bit opcode. */
14128 | (opcode
& 0x3ff)), /* Addend value. */
14131 /* Delete 2 bytes from irel->r_offset + 2. */
14136 /* R_MICROMIPS_PC16_S1 relaxation to R_MICROMIPS_PC7_S1. We need
14137 to check the distance from the next instruction, so subtract 2. */
14139 && r_type
== R_MICROMIPS_PC16_S1
14140 && IS_BITSIZE (pcrval
- 2, 8)
14141 && (((fndopc
= find_match (opcode
, bz_rs_insns_32
)) >= 0
14142 && OP16_VALID_REG (OP32_SREG (opcode
)))
14143 || ((fndopc
= find_match (opcode
, bz_rt_insns_32
)) >= 0
14144 && OP16_VALID_REG (OP32_TREG (opcode
)))))
14148 reg
= OP32_SREG (opcode
) ? OP32_SREG (opcode
) : OP32_TREG (opcode
);
14150 /* Fix the relocation's type. */
14151 irel
->r_info
= ELF32_R_INFO (r_symndx
, R_MICROMIPS_PC7_S1
);
14153 /* Replace the 32-bit opcode with a 16-bit opcode. */
14155 (bz_insns_16
[fndopc
].match
14156 | BZ16_REG_FIELD (reg
)
14157 | (opcode
& 0x7f)), /* Addend value. */
14160 /* Delete 2 bytes from irel->r_offset + 2. */
14165 /* R_MICROMIPS_26_S1 -- JAL to JALS relaxation for microMIPS targets. */
14167 && r_type
== R_MICROMIPS_26_S1
14168 && target_is_micromips_code_p
14169 && irel
->r_offset
+ 7 < sec
->size
14170 && MATCH (opcode
, jal_insn_32_bd32
))
14172 unsigned long n32opc
;
14173 bfd_boolean relaxed
= FALSE
;
14175 n32opc
= bfd_get_micromips_32 (abfd
, ptr
+ 4);
14177 if (MATCH (n32opc
, nop_insn_32
))
14179 /* Replace delay slot 32-bit NOP with a 16-bit NOP. */
14180 bfd_put_16 (abfd
, nop_insn_16
.match
, ptr
+ 4);
14184 else if (find_match (n32opc
, move_insns_32
) >= 0)
14186 /* Replace delay slot 32-bit MOVE with 16-bit MOVE. */
14188 (move_insn_16
.match
14189 | MOVE16_RD_FIELD (MOVE32_RD (n32opc
))
14190 | MOVE16_RS_FIELD (MOVE32_RS (n32opc
))),
14195 /* Other 32-bit instructions relaxable to 16-bit
14196 instructions will be handled here later. */
14200 /* JAL with 32-bit delay slot that is changed to a JALS
14201 with 16-bit delay slot. */
14202 bfd_put_micromips_32 (abfd
, jal_insn_32_bd16
.match
, ptr
);
14204 /* Delete 2 bytes from irel->r_offset + 6. */
14212 /* Note that we've changed the relocs, section contents, etc. */
14213 elf_section_data (sec
)->relocs
= internal_relocs
;
14214 elf_section_data (sec
)->this_hdr
.contents
= contents
;
14215 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
14217 /* Delete bytes depending on the delcnt and deloff. */
14218 if (!mips_elf_relax_delete_bytes (abfd
, sec
,
14219 irel
->r_offset
+ deloff
, delcnt
))
14222 /* That will change things, so we should relax again.
14223 Note that this is not required, and it may be slow. */
14228 if (isymbuf
!= NULL
14229 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
14231 if (! link_info
->keep_memory
)
14235 /* Cache the symbols for elf_link_input_bfd. */
14236 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
14240 if (contents
!= NULL
14241 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
14243 if (! link_info
->keep_memory
)
14247 /* Cache the section contents for elf_link_input_bfd. */
14248 elf_section_data (sec
)->this_hdr
.contents
= contents
;
14252 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
14253 free (internal_relocs
);
14258 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
14260 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
14262 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
14263 free (internal_relocs
);
14268 /* Create a MIPS ELF linker hash table. */
14270 struct bfd_link_hash_table
*
14271 _bfd_mips_elf_link_hash_table_create (bfd
*abfd
)
14273 struct mips_elf_link_hash_table
*ret
;
14274 size_t amt
= sizeof (struct mips_elf_link_hash_table
);
14276 ret
= bfd_zmalloc (amt
);
14280 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
14281 mips_elf_link_hash_newfunc
,
14282 sizeof (struct mips_elf_link_hash_entry
),
14288 ret
->root
.init_plt_refcount
.plist
= NULL
;
14289 ret
->root
.init_plt_offset
.plist
= NULL
;
14291 return &ret
->root
.root
;
14294 /* Likewise, but indicate that the target is VxWorks. */
14296 struct bfd_link_hash_table
*
14297 _bfd_mips_vxworks_link_hash_table_create (bfd
*abfd
)
14299 struct bfd_link_hash_table
*ret
;
14301 ret
= _bfd_mips_elf_link_hash_table_create (abfd
);
14304 struct mips_elf_link_hash_table
*htab
;
14306 htab
= (struct mips_elf_link_hash_table
*) ret
;
14307 htab
->use_plts_and_copy_relocs
= TRUE
;
14308 htab
->is_vxworks
= TRUE
;
14313 /* A function that the linker calls if we are allowed to use PLTs
14314 and copy relocs. */
14317 _bfd_mips_elf_use_plts_and_copy_relocs (struct bfd_link_info
*info
)
14319 mips_elf_hash_table (info
)->use_plts_and_copy_relocs
= TRUE
;
14322 /* A function that the linker calls to select between all or only
14323 32-bit microMIPS instructions, and between making or ignoring
14324 branch relocation checks for invalid transitions between ISA modes.
14325 Also record whether we have been configured for a GNU target. */
14328 _bfd_mips_elf_linker_flags (struct bfd_link_info
*info
, bfd_boolean insn32
,
14329 bfd_boolean ignore_branch_isa
,
14330 bfd_boolean gnu_target
)
14332 mips_elf_hash_table (info
)->insn32
= insn32
;
14333 mips_elf_hash_table (info
)->ignore_branch_isa
= ignore_branch_isa
;
14334 mips_elf_hash_table (info
)->gnu_target
= gnu_target
;
14337 /* A function that the linker calls to enable use of compact branches in
14338 linker generated code for MIPSR6. */
14341 _bfd_mips_elf_compact_branches (struct bfd_link_info
*info
, bfd_boolean on
)
14343 mips_elf_hash_table (info
)->compact_branches
= on
;
14347 /* Structure for saying that BFD machine EXTENSION extends BASE. */
14349 struct mips_mach_extension
14351 unsigned long extension
, base
;
14355 /* An array describing how BFD machines relate to one another. The entries
14356 are ordered topologically with MIPS I extensions listed last. */
14358 static const struct mips_mach_extension mips_mach_extensions
[] =
14360 /* MIPS64r2 extensions. */
14361 { bfd_mach_mips_octeon3
, bfd_mach_mips_octeon2
},
14362 { bfd_mach_mips_octeon2
, bfd_mach_mips_octeonp
},
14363 { bfd_mach_mips_octeonp
, bfd_mach_mips_octeon
},
14364 { bfd_mach_mips_octeon
, bfd_mach_mipsisa64r2
},
14365 { bfd_mach_mips_gs264e
, bfd_mach_mips_gs464e
},
14366 { bfd_mach_mips_gs464e
, bfd_mach_mips_gs464
},
14367 { bfd_mach_mips_gs464
, bfd_mach_mipsisa64r2
},
14369 /* MIPS64 extensions. */
14370 { bfd_mach_mipsisa64r2
, bfd_mach_mipsisa64
},
14371 { bfd_mach_mips_sb1
, bfd_mach_mipsisa64
},
14372 { bfd_mach_mips_xlr
, bfd_mach_mipsisa64
},
14374 /* MIPS V extensions. */
14375 { bfd_mach_mipsisa64
, bfd_mach_mips5
},
14377 /* R10000 extensions. */
14378 { bfd_mach_mips12000
, bfd_mach_mips10000
},
14379 { bfd_mach_mips14000
, bfd_mach_mips10000
},
14380 { bfd_mach_mips16000
, bfd_mach_mips10000
},
14382 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
14383 vr5400 ISA, but doesn't include the multimedia stuff. It seems
14384 better to allow vr5400 and vr5500 code to be merged anyway, since
14385 many libraries will just use the core ISA. Perhaps we could add
14386 some sort of ASE flag if this ever proves a problem. */
14387 { bfd_mach_mips5500
, bfd_mach_mips5400
},
14388 { bfd_mach_mips5400
, bfd_mach_mips5000
},
14390 /* MIPS IV extensions. */
14391 { bfd_mach_mips5
, bfd_mach_mips8000
},
14392 { bfd_mach_mips10000
, bfd_mach_mips8000
},
14393 { bfd_mach_mips5000
, bfd_mach_mips8000
},
14394 { bfd_mach_mips7000
, bfd_mach_mips8000
},
14395 { bfd_mach_mips9000
, bfd_mach_mips8000
},
14397 /* VR4100 extensions. */
14398 { bfd_mach_mips4120
, bfd_mach_mips4100
},
14399 { bfd_mach_mips4111
, bfd_mach_mips4100
},
14401 /* MIPS III extensions. */
14402 { bfd_mach_mips_loongson_2e
, bfd_mach_mips4000
},
14403 { bfd_mach_mips_loongson_2f
, bfd_mach_mips4000
},
14404 { bfd_mach_mips8000
, bfd_mach_mips4000
},
14405 { bfd_mach_mips4650
, bfd_mach_mips4000
},
14406 { bfd_mach_mips4600
, bfd_mach_mips4000
},
14407 { bfd_mach_mips4400
, bfd_mach_mips4000
},
14408 { bfd_mach_mips4300
, bfd_mach_mips4000
},
14409 { bfd_mach_mips4100
, bfd_mach_mips4000
},
14410 { bfd_mach_mips5900
, bfd_mach_mips4000
},
14412 /* MIPS32r3 extensions. */
14413 { bfd_mach_mips_interaptiv_mr2
, bfd_mach_mipsisa32r3
},
14415 /* MIPS32r2 extensions. */
14416 { bfd_mach_mipsisa32r3
, bfd_mach_mipsisa32r2
},
14418 /* MIPS32 extensions. */
14419 { bfd_mach_mipsisa32r2
, bfd_mach_mipsisa32
},
14421 /* MIPS II extensions. */
14422 { bfd_mach_mips4000
, bfd_mach_mips6000
},
14423 { bfd_mach_mipsisa32
, bfd_mach_mips6000
},
14424 { bfd_mach_mips4010
, bfd_mach_mips6000
},
14426 /* MIPS I extensions. */
14427 { bfd_mach_mips6000
, bfd_mach_mips3000
},
14428 { bfd_mach_mips3900
, bfd_mach_mips3000
}
14431 /* Return true if bfd machine EXTENSION is an extension of machine BASE. */
14434 mips_mach_extends_p (unsigned long base
, unsigned long extension
)
14438 if (extension
== base
)
14441 if (base
== bfd_mach_mipsisa32
14442 && mips_mach_extends_p (bfd_mach_mipsisa64
, extension
))
14445 if (base
== bfd_mach_mipsisa32r2
14446 && mips_mach_extends_p (bfd_mach_mipsisa64r2
, extension
))
14449 for (i
= 0; i
< ARRAY_SIZE (mips_mach_extensions
); i
++)
14450 if (extension
== mips_mach_extensions
[i
].extension
)
14452 extension
= mips_mach_extensions
[i
].base
;
14453 if (extension
== base
)
14460 /* Return the BFD mach for each .MIPS.abiflags ISA Extension. */
14462 static unsigned long
14463 bfd_mips_isa_ext_mach (unsigned int isa_ext
)
14467 case AFL_EXT_3900
: return bfd_mach_mips3900
;
14468 case AFL_EXT_4010
: return bfd_mach_mips4010
;
14469 case AFL_EXT_4100
: return bfd_mach_mips4100
;
14470 case AFL_EXT_4111
: return bfd_mach_mips4111
;
14471 case AFL_EXT_4120
: return bfd_mach_mips4120
;
14472 case AFL_EXT_4650
: return bfd_mach_mips4650
;
14473 case AFL_EXT_5400
: return bfd_mach_mips5400
;
14474 case AFL_EXT_5500
: return bfd_mach_mips5500
;
14475 case AFL_EXT_5900
: return bfd_mach_mips5900
;
14476 case AFL_EXT_10000
: return bfd_mach_mips10000
;
14477 case AFL_EXT_LOONGSON_2E
: return bfd_mach_mips_loongson_2e
;
14478 case AFL_EXT_LOONGSON_2F
: return bfd_mach_mips_loongson_2f
;
14479 case AFL_EXT_SB1
: return bfd_mach_mips_sb1
;
14480 case AFL_EXT_OCTEON
: return bfd_mach_mips_octeon
;
14481 case AFL_EXT_OCTEONP
: return bfd_mach_mips_octeonp
;
14482 case AFL_EXT_OCTEON2
: return bfd_mach_mips_octeon2
;
14483 case AFL_EXT_XLR
: return bfd_mach_mips_xlr
;
14484 default: return bfd_mach_mips3000
;
14488 /* Return the .MIPS.abiflags value representing each ISA Extension. */
14491 bfd_mips_isa_ext (bfd
*abfd
)
14493 switch (bfd_get_mach (abfd
))
14495 case bfd_mach_mips3900
: return AFL_EXT_3900
;
14496 case bfd_mach_mips4010
: return AFL_EXT_4010
;
14497 case bfd_mach_mips4100
: return AFL_EXT_4100
;
14498 case bfd_mach_mips4111
: return AFL_EXT_4111
;
14499 case bfd_mach_mips4120
: return AFL_EXT_4120
;
14500 case bfd_mach_mips4650
: return AFL_EXT_4650
;
14501 case bfd_mach_mips5400
: return AFL_EXT_5400
;
14502 case bfd_mach_mips5500
: return AFL_EXT_5500
;
14503 case bfd_mach_mips5900
: return AFL_EXT_5900
;
14504 case bfd_mach_mips10000
: return AFL_EXT_10000
;
14505 case bfd_mach_mips_loongson_2e
: return AFL_EXT_LOONGSON_2E
;
14506 case bfd_mach_mips_loongson_2f
: return AFL_EXT_LOONGSON_2F
;
14507 case bfd_mach_mips_sb1
: return AFL_EXT_SB1
;
14508 case bfd_mach_mips_octeon
: return AFL_EXT_OCTEON
;
14509 case bfd_mach_mips_octeonp
: return AFL_EXT_OCTEONP
;
14510 case bfd_mach_mips_octeon3
: return AFL_EXT_OCTEON3
;
14511 case bfd_mach_mips_octeon2
: return AFL_EXT_OCTEON2
;
14512 case bfd_mach_mips_xlr
: return AFL_EXT_XLR
;
14513 case bfd_mach_mips_interaptiv_mr2
:
14514 return AFL_EXT_INTERAPTIV_MR2
;
14519 /* Encode ISA level and revision as a single value. */
14520 #define LEVEL_REV(LEV,REV) ((LEV) << 3 | (REV))
14522 /* Decode a single value into level and revision. */
14523 #define ISA_LEVEL(LEVREV) ((LEVREV) >> 3)
14524 #define ISA_REV(LEVREV) ((LEVREV) & 0x7)
14526 /* Update the isa_level, isa_rev, isa_ext fields of abiflags. */
14529 update_mips_abiflags_isa (bfd
*abfd
, Elf_Internal_ABIFlags_v0
*abiflags
)
14532 switch (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
)
14534 case E_MIPS_ARCH_1
: new_isa
= LEVEL_REV (1, 0); break;
14535 case E_MIPS_ARCH_2
: new_isa
= LEVEL_REV (2, 0); break;
14536 case E_MIPS_ARCH_3
: new_isa
= LEVEL_REV (3, 0); break;
14537 case E_MIPS_ARCH_4
: new_isa
= LEVEL_REV (4, 0); break;
14538 case E_MIPS_ARCH_5
: new_isa
= LEVEL_REV (5, 0); break;
14539 case E_MIPS_ARCH_32
: new_isa
= LEVEL_REV (32, 1); break;
14540 case E_MIPS_ARCH_32R2
: new_isa
= LEVEL_REV (32, 2); break;
14541 case E_MIPS_ARCH_32R6
: new_isa
= LEVEL_REV (32, 6); break;
14542 case E_MIPS_ARCH_64
: new_isa
= LEVEL_REV (64, 1); break;
14543 case E_MIPS_ARCH_64R2
: new_isa
= LEVEL_REV (64, 2); break;
14544 case E_MIPS_ARCH_64R6
: new_isa
= LEVEL_REV (64, 6); break;
14547 /* xgettext:c-format */
14548 (_("%pB: unknown architecture %s"),
14549 abfd
, bfd_printable_name (abfd
));
14552 if (new_isa
> LEVEL_REV (abiflags
->isa_level
, abiflags
->isa_rev
))
14554 abiflags
->isa_level
= ISA_LEVEL (new_isa
);
14555 abiflags
->isa_rev
= ISA_REV (new_isa
);
14558 /* Update the isa_ext if ABFD describes a further extension. */
14559 if (mips_mach_extends_p (bfd_mips_isa_ext_mach (abiflags
->isa_ext
),
14560 bfd_get_mach (abfd
)))
14561 abiflags
->isa_ext
= bfd_mips_isa_ext (abfd
);
14564 /* Return true if the given ELF header flags describe a 32-bit binary. */
14567 mips_32bit_flags_p (flagword flags
)
14569 return ((flags
& EF_MIPS_32BITMODE
) != 0
14570 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
14571 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
14572 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
14573 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
14574 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
14575 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
14576 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R6
);
14579 /* Infer the content of the ABI flags based on the elf header. */
14582 infer_mips_abiflags (bfd
*abfd
, Elf_Internal_ABIFlags_v0
* abiflags
)
14584 obj_attribute
*in_attr
;
14586 memset (abiflags
, 0, sizeof (Elf_Internal_ABIFlags_v0
));
14587 update_mips_abiflags_isa (abfd
, abiflags
);
14589 if (mips_32bit_flags_p (elf_elfheader (abfd
)->e_flags
))
14590 abiflags
->gpr_size
= AFL_REG_32
;
14592 abiflags
->gpr_size
= AFL_REG_64
;
14594 abiflags
->cpr1_size
= AFL_REG_NONE
;
14596 in_attr
= elf_known_obj_attributes (abfd
)[OBJ_ATTR_GNU
];
14597 abiflags
->fp_abi
= in_attr
[Tag_GNU_MIPS_ABI_FP
].i
;
14599 if (abiflags
->fp_abi
== Val_GNU_MIPS_ABI_FP_SINGLE
14600 || abiflags
->fp_abi
== Val_GNU_MIPS_ABI_FP_XX
14601 || (abiflags
->fp_abi
== Val_GNU_MIPS_ABI_FP_DOUBLE
14602 && abiflags
->gpr_size
== AFL_REG_32
))
14603 abiflags
->cpr1_size
= AFL_REG_32
;
14604 else if (abiflags
->fp_abi
== Val_GNU_MIPS_ABI_FP_DOUBLE
14605 || abiflags
->fp_abi
== Val_GNU_MIPS_ABI_FP_64
14606 || abiflags
->fp_abi
== Val_GNU_MIPS_ABI_FP_64A
)
14607 abiflags
->cpr1_size
= AFL_REG_64
;
14609 abiflags
->cpr2_size
= AFL_REG_NONE
;
14611 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
14612 abiflags
->ases
|= AFL_ASE_MDMX
;
14613 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_M16
)
14614 abiflags
->ases
|= AFL_ASE_MIPS16
;
14615 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
14616 abiflags
->ases
|= AFL_ASE_MICROMIPS
;
14618 if (abiflags
->fp_abi
!= Val_GNU_MIPS_ABI_FP_ANY
14619 && abiflags
->fp_abi
!= Val_GNU_MIPS_ABI_FP_SOFT
14620 && abiflags
->fp_abi
!= Val_GNU_MIPS_ABI_FP_64A
14621 && abiflags
->isa_level
>= 32
14622 && abiflags
->ases
!= AFL_ASE_LOONGSON_EXT
)
14623 abiflags
->flags1
|= AFL_FLAGS1_ODDSPREG
;
14626 /* We need to use a special link routine to handle the .reginfo and
14627 the .mdebug sections. We need to merge all instances of these
14628 sections together, not write them all out sequentially. */
14631 _bfd_mips_elf_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
14634 struct bfd_link_order
*p
;
14635 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
14636 asection
*rtproc_sec
, *abiflags_sec
;
14637 Elf32_RegInfo reginfo
;
14638 struct ecoff_debug_info debug
;
14639 struct mips_htab_traverse_info hti
;
14640 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
14641 const struct ecoff_debug_swap
*swap
= bed
->elf_backend_ecoff_debug_swap
;
14642 HDRR
*symhdr
= &debug
.symbolic_header
;
14643 void *mdebug_handle
= NULL
;
14648 struct mips_elf_link_hash_table
*htab
;
14650 static const char * const secname
[] =
14652 ".text", ".init", ".fini", ".data",
14653 ".rodata", ".sdata", ".sbss", ".bss"
14655 static const int sc
[] =
14657 scText
, scInit
, scFini
, scData
,
14658 scRData
, scSData
, scSBss
, scBss
14661 htab
= mips_elf_hash_table (info
);
14662 BFD_ASSERT (htab
!= NULL
);
14664 /* Sort the dynamic symbols so that those with GOT entries come after
14666 if (!mips_elf_sort_hash_table (abfd
, info
))
14669 /* Create any scheduled LA25 stubs. */
14671 hti
.output_bfd
= abfd
;
14673 htab_traverse (htab
->la25_stubs
, mips_elf_create_la25_stub
, &hti
);
14677 /* Get a value for the GP register. */
14678 if (elf_gp (abfd
) == 0)
14680 struct bfd_link_hash_entry
*h
;
14682 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
14683 if (h
!= NULL
&& h
->type
== bfd_link_hash_defined
)
14684 elf_gp (abfd
) = (h
->u
.def
.value
14685 + h
->u
.def
.section
->output_section
->vma
14686 + h
->u
.def
.section
->output_offset
);
14687 else if (htab
->is_vxworks
14688 && (h
= bfd_link_hash_lookup (info
->hash
,
14689 "_GLOBAL_OFFSET_TABLE_",
14690 FALSE
, FALSE
, TRUE
))
14691 && h
->type
== bfd_link_hash_defined
)
14692 elf_gp (abfd
) = (h
->u
.def
.section
->output_section
->vma
14693 + h
->u
.def
.section
->output_offset
14695 else if (bfd_link_relocatable (info
))
14697 bfd_vma lo
= MINUS_ONE
;
14699 /* Find the GP-relative section with the lowest offset. */
14700 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
14702 && (elf_section_data (o
)->this_hdr
.sh_flags
& SHF_MIPS_GPREL
))
14705 /* And calculate GP relative to that. */
14706 elf_gp (abfd
) = lo
+ ELF_MIPS_GP_OFFSET (info
);
14710 /* If the relocate_section function needs to do a reloc
14711 involving the GP value, it should make a reloc_dangerous
14712 callback to warn that GP is not defined. */
14716 /* Go through the sections and collect the .reginfo and .mdebug
14718 abiflags_sec
= NULL
;
14719 reginfo_sec
= NULL
;
14721 gptab_data_sec
= NULL
;
14722 gptab_bss_sec
= NULL
;
14723 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
14725 if (strcmp (o
->name
, ".MIPS.abiflags") == 0)
14727 /* We have found the .MIPS.abiflags section in the output file.
14728 Look through all the link_orders comprising it and remove them.
14729 The data is merged in _bfd_mips_elf_merge_private_bfd_data. */
14730 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
14732 asection
*input_section
;
14734 if (p
->type
!= bfd_indirect_link_order
)
14736 if (p
->type
== bfd_data_link_order
)
14741 input_section
= p
->u
.indirect
.section
;
14743 /* Hack: reset the SEC_HAS_CONTENTS flag so that
14744 elf_link_input_bfd ignores this section. */
14745 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
14748 /* Size has been set in _bfd_mips_elf_always_size_sections. */
14749 BFD_ASSERT(o
->size
== sizeof (Elf_External_ABIFlags_v0
));
14751 /* Skip this section later on (I don't think this currently
14752 matters, but someday it might). */
14753 o
->map_head
.link_order
= NULL
;
14758 if (strcmp (o
->name
, ".reginfo") == 0)
14760 memset (®info
, 0, sizeof reginfo
);
14762 /* We have found the .reginfo section in the output file.
14763 Look through all the link_orders comprising it and merge
14764 the information together. */
14765 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
14767 asection
*input_section
;
14769 Elf32_External_RegInfo ext
;
14773 if (p
->type
!= bfd_indirect_link_order
)
14775 if (p
->type
== bfd_data_link_order
)
14780 input_section
= p
->u
.indirect
.section
;
14781 input_bfd
= input_section
->owner
;
14783 sz
= (input_section
->size
< sizeof (ext
)
14784 ? input_section
->size
: sizeof (ext
));
14785 memset (&ext
, 0, sizeof (ext
));
14786 if (! bfd_get_section_contents (input_bfd
, input_section
,
14790 bfd_mips_elf32_swap_reginfo_in (input_bfd
, &ext
, &sub
);
14792 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
14793 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
14794 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
14795 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
14796 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
14798 /* ri_gp_value is set by the function
14799 `_bfd_mips_elf_section_processing' when the section is
14800 finally written out. */
14802 /* Hack: reset the SEC_HAS_CONTENTS flag so that
14803 elf_link_input_bfd ignores this section. */
14804 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
14807 /* Size has been set in _bfd_mips_elf_always_size_sections. */
14808 BFD_ASSERT(o
->size
== sizeof (Elf32_External_RegInfo
));
14810 /* Skip this section later on (I don't think this currently
14811 matters, but someday it might). */
14812 o
->map_head
.link_order
= NULL
;
14817 if (strcmp (o
->name
, ".mdebug") == 0)
14819 struct extsym_info einfo
;
14822 /* We have found the .mdebug section in the output file.
14823 Look through all the link_orders comprising it and merge
14824 the information together. */
14825 symhdr
->magic
= swap
->sym_magic
;
14826 /* FIXME: What should the version stamp be? */
14827 symhdr
->vstamp
= 0;
14828 symhdr
->ilineMax
= 0;
14829 symhdr
->cbLine
= 0;
14830 symhdr
->idnMax
= 0;
14831 symhdr
->ipdMax
= 0;
14832 symhdr
->isymMax
= 0;
14833 symhdr
->ioptMax
= 0;
14834 symhdr
->iauxMax
= 0;
14835 symhdr
->issMax
= 0;
14836 symhdr
->issExtMax
= 0;
14837 symhdr
->ifdMax
= 0;
14839 symhdr
->iextMax
= 0;
14841 /* We accumulate the debugging information itself in the
14842 debug_info structure. */
14844 debug
.external_dnr
= NULL
;
14845 debug
.external_pdr
= NULL
;
14846 debug
.external_sym
= NULL
;
14847 debug
.external_opt
= NULL
;
14848 debug
.external_aux
= NULL
;
14850 debug
.ssext
= debug
.ssext_end
= NULL
;
14851 debug
.external_fdr
= NULL
;
14852 debug
.external_rfd
= NULL
;
14853 debug
.external_ext
= debug
.external_ext_end
= NULL
;
14855 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
14856 if (mdebug_handle
== NULL
)
14860 esym
.cobol_main
= 0;
14864 esym
.asym
.iss
= issNil
;
14865 esym
.asym
.st
= stLocal
;
14866 esym
.asym
.reserved
= 0;
14867 esym
.asym
.index
= indexNil
;
14869 for (i
= 0; i
< sizeof (secname
) / sizeof (secname
[0]); i
++)
14871 esym
.asym
.sc
= sc
[i
];
14872 s
= bfd_get_section_by_name (abfd
, secname
[i
]);
14875 esym
.asym
.value
= s
->vma
;
14876 last
= s
->vma
+ s
->size
;
14879 esym
.asym
.value
= last
;
14880 if (!bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
14881 secname
[i
], &esym
))
14885 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
14887 asection
*input_section
;
14889 const struct ecoff_debug_swap
*input_swap
;
14890 struct ecoff_debug_info input_debug
;
14894 if (p
->type
!= bfd_indirect_link_order
)
14896 if (p
->type
== bfd_data_link_order
)
14901 input_section
= p
->u
.indirect
.section
;
14902 input_bfd
= input_section
->owner
;
14904 if (!is_mips_elf (input_bfd
))
14906 /* I don't know what a non MIPS ELF bfd would be
14907 doing with a .mdebug section, but I don't really
14908 want to deal with it. */
14912 input_swap
= (get_elf_backend_data (input_bfd
)
14913 ->elf_backend_ecoff_debug_swap
);
14915 BFD_ASSERT (p
->size
== input_section
->size
);
14917 /* The ECOFF linking code expects that we have already
14918 read in the debugging information and set up an
14919 ecoff_debug_info structure, so we do that now. */
14920 if (! _bfd_mips_elf_read_ecoff_info (input_bfd
, input_section
,
14924 if (! (bfd_ecoff_debug_accumulate
14925 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
14926 &input_debug
, input_swap
, info
)))
14929 /* Loop through the external symbols. For each one with
14930 interesting information, try to find the symbol in
14931 the linker global hash table and save the information
14932 for the output external symbols. */
14933 eraw_src
= input_debug
.external_ext
;
14934 eraw_end
= (eraw_src
14935 + (input_debug
.symbolic_header
.iextMax
14936 * input_swap
->external_ext_size
));
14938 eraw_src
< eraw_end
;
14939 eraw_src
+= input_swap
->external_ext_size
)
14943 struct mips_elf_link_hash_entry
*h
;
14945 (*input_swap
->swap_ext_in
) (input_bfd
, eraw_src
, &ext
);
14946 if (ext
.asym
.sc
== scNil
14947 || ext
.asym
.sc
== scUndefined
14948 || ext
.asym
.sc
== scSUndefined
)
14951 name
= input_debug
.ssext
+ ext
.asym
.iss
;
14952 h
= mips_elf_link_hash_lookup (mips_elf_hash_table (info
),
14953 name
, FALSE
, FALSE
, TRUE
);
14954 if (h
== NULL
|| h
->esym
.ifd
!= -2)
14959 BFD_ASSERT (ext
.ifd
14960 < input_debug
.symbolic_header
.ifdMax
);
14961 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
14967 /* Free up the information we just read. */
14968 free (input_debug
.line
);
14969 free (input_debug
.external_dnr
);
14970 free (input_debug
.external_pdr
);
14971 free (input_debug
.external_sym
);
14972 free (input_debug
.external_opt
);
14973 free (input_debug
.external_aux
);
14974 free (input_debug
.ss
);
14975 free (input_debug
.ssext
);
14976 free (input_debug
.external_fdr
);
14977 free (input_debug
.external_rfd
);
14978 free (input_debug
.external_ext
);
14980 /* Hack: reset the SEC_HAS_CONTENTS flag so that
14981 elf_link_input_bfd ignores this section. */
14982 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
14985 if (SGI_COMPAT (abfd
) && bfd_link_pic (info
))
14987 /* Create .rtproc section. */
14988 rtproc_sec
= bfd_get_linker_section (abfd
, ".rtproc");
14989 if (rtproc_sec
== NULL
)
14991 flagword flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
14992 | SEC_LINKER_CREATED
| SEC_READONLY
);
14994 rtproc_sec
= bfd_make_section_anyway_with_flags (abfd
,
14997 if (rtproc_sec
== NULL
14998 || !bfd_set_section_alignment (rtproc_sec
, 4))
15002 if (! mips_elf_create_procedure_table (mdebug_handle
, abfd
,
15008 /* Build the external symbol information. */
15011 einfo
.debug
= &debug
;
15013 einfo
.failed
= FALSE
;
15014 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
15015 mips_elf_output_extsym
, &einfo
);
15019 /* Set the size of the .mdebug section. */
15020 o
->size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
15022 /* Skip this section later on (I don't think this currently
15023 matters, but someday it might). */
15024 o
->map_head
.link_order
= NULL
;
15029 if (CONST_STRNEQ (o
->name
, ".gptab."))
15031 const char *subname
;
15034 Elf32_External_gptab
*ext_tab
;
15037 /* The .gptab.sdata and .gptab.sbss sections hold
15038 information describing how the small data area would
15039 change depending upon the -G switch. These sections
15040 not used in executables files. */
15041 if (! bfd_link_relocatable (info
))
15043 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
15045 asection
*input_section
;
15047 if (p
->type
!= bfd_indirect_link_order
)
15049 if (p
->type
== bfd_data_link_order
)
15054 input_section
= p
->u
.indirect
.section
;
15056 /* Hack: reset the SEC_HAS_CONTENTS flag so that
15057 elf_link_input_bfd ignores this section. */
15058 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
15061 /* Skip this section later on (I don't think this
15062 currently matters, but someday it might). */
15063 o
->map_head
.link_order
= NULL
;
15065 /* Really remove the section. */
15066 bfd_section_list_remove (abfd
, o
);
15067 --abfd
->section_count
;
15072 /* There is one gptab for initialized data, and one for
15073 uninitialized data. */
15074 if (strcmp (o
->name
, ".gptab.sdata") == 0)
15075 gptab_data_sec
= o
;
15076 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
15081 /* xgettext:c-format */
15082 (_("%pB: illegal section name `%pA'"), abfd
, o
);
15083 bfd_set_error (bfd_error_nonrepresentable_section
);
15087 /* The linker script always combines .gptab.data and
15088 .gptab.sdata into .gptab.sdata, and likewise for
15089 .gptab.bss and .gptab.sbss. It is possible that there is
15090 no .sdata or .sbss section in the output file, in which
15091 case we must change the name of the output section. */
15092 subname
= o
->name
+ sizeof ".gptab" - 1;
15093 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
15095 if (o
== gptab_data_sec
)
15096 o
->name
= ".gptab.data";
15098 o
->name
= ".gptab.bss";
15099 subname
= o
->name
+ sizeof ".gptab" - 1;
15100 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
15103 /* Set up the first entry. */
15105 amt
= c
* sizeof (Elf32_gptab
);
15106 tab
= bfd_malloc (amt
);
15109 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
15110 tab
[0].gt_header
.gt_unused
= 0;
15112 /* Combine the input sections. */
15113 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
15115 asection
*input_section
;
15117 bfd_size_type size
;
15118 unsigned long last
;
15119 bfd_size_type gpentry
;
15121 if (p
->type
!= bfd_indirect_link_order
)
15123 if (p
->type
== bfd_data_link_order
)
15128 input_section
= p
->u
.indirect
.section
;
15129 input_bfd
= input_section
->owner
;
15131 /* Combine the gptab entries for this input section one
15132 by one. We know that the input gptab entries are
15133 sorted by ascending -G value. */
15134 size
= input_section
->size
;
15136 for (gpentry
= sizeof (Elf32_External_gptab
);
15138 gpentry
+= sizeof (Elf32_External_gptab
))
15140 Elf32_External_gptab ext_gptab
;
15141 Elf32_gptab int_gptab
;
15147 if (! (bfd_get_section_contents
15148 (input_bfd
, input_section
, &ext_gptab
, gpentry
,
15149 sizeof (Elf32_External_gptab
))))
15155 bfd_mips_elf32_swap_gptab_in (input_bfd
, &ext_gptab
,
15157 val
= int_gptab
.gt_entry
.gt_g_value
;
15158 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
15161 for (look
= 1; look
< c
; look
++)
15163 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
15164 tab
[look
].gt_entry
.gt_bytes
+= add
;
15166 if (tab
[look
].gt_entry
.gt_g_value
== val
)
15172 Elf32_gptab
*new_tab
;
15175 /* We need a new table entry. */
15176 amt
= (bfd_size_type
) (c
+ 1) * sizeof (Elf32_gptab
);
15177 new_tab
= bfd_realloc (tab
, amt
);
15178 if (new_tab
== NULL
)
15184 tab
[c
].gt_entry
.gt_g_value
= val
;
15185 tab
[c
].gt_entry
.gt_bytes
= add
;
15187 /* Merge in the size for the next smallest -G
15188 value, since that will be implied by this new
15191 for (look
= 1; look
< c
; look
++)
15193 if (tab
[look
].gt_entry
.gt_g_value
< val
15195 || (tab
[look
].gt_entry
.gt_g_value
15196 > tab
[max
].gt_entry
.gt_g_value
)))
15200 tab
[c
].gt_entry
.gt_bytes
+=
15201 tab
[max
].gt_entry
.gt_bytes
;
15206 last
= int_gptab
.gt_entry
.gt_bytes
;
15209 /* Hack: reset the SEC_HAS_CONTENTS flag so that
15210 elf_link_input_bfd ignores this section. */
15211 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
15214 /* The table must be sorted by -G value. */
15216 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
15218 /* Swap out the table. */
15219 amt
= (bfd_size_type
) c
* sizeof (Elf32_External_gptab
);
15220 ext_tab
= bfd_alloc (abfd
, amt
);
15221 if (ext_tab
== NULL
)
15227 for (j
= 0; j
< c
; j
++)
15228 bfd_mips_elf32_swap_gptab_out (abfd
, tab
+ j
, ext_tab
+ j
);
15231 o
->size
= c
* sizeof (Elf32_External_gptab
);
15232 o
->contents
= (bfd_byte
*) ext_tab
;
15234 /* Skip this section later on (I don't think this currently
15235 matters, but someday it might). */
15236 o
->map_head
.link_order
= NULL
;
15240 /* Invoke the regular ELF backend linker to do all the work. */
15241 if (!bfd_elf_final_link (abfd
, info
))
15244 /* Now write out the computed sections. */
15246 if (abiflags_sec
!= NULL
)
15248 Elf_External_ABIFlags_v0 ext
;
15249 Elf_Internal_ABIFlags_v0
*abiflags
;
15251 abiflags
= &mips_elf_tdata (abfd
)->abiflags
;
15253 /* Set up the abiflags if no valid input sections were found. */
15254 if (!mips_elf_tdata (abfd
)->abiflags_valid
)
15256 infer_mips_abiflags (abfd
, abiflags
);
15257 mips_elf_tdata (abfd
)->abiflags_valid
= TRUE
;
15259 bfd_mips_elf_swap_abiflags_v0_out (abfd
, abiflags
, &ext
);
15260 if (! bfd_set_section_contents (abfd
, abiflags_sec
, &ext
, 0, sizeof ext
))
15264 if (reginfo_sec
!= NULL
)
15266 Elf32_External_RegInfo ext
;
15268 bfd_mips_elf32_swap_reginfo_out (abfd
, ®info
, &ext
);
15269 if (! bfd_set_section_contents (abfd
, reginfo_sec
, &ext
, 0, sizeof ext
))
15273 if (mdebug_sec
!= NULL
)
15275 BFD_ASSERT (abfd
->output_has_begun
);
15276 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
15278 mdebug_sec
->filepos
))
15281 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
15284 if (gptab_data_sec
!= NULL
)
15286 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
15287 gptab_data_sec
->contents
,
15288 0, gptab_data_sec
->size
))
15292 if (gptab_bss_sec
!= NULL
)
15294 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
15295 gptab_bss_sec
->contents
,
15296 0, gptab_bss_sec
->size
))
15300 if (SGI_COMPAT (abfd
))
15302 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
15303 if (rtproc_sec
!= NULL
)
15305 if (! bfd_set_section_contents (abfd
, rtproc_sec
,
15306 rtproc_sec
->contents
,
15307 0, rtproc_sec
->size
))
15315 /* Merge object file header flags from IBFD into OBFD. Raise an error
15316 if there are conflicting settings. */
15319 mips_elf_merge_obj_e_flags (bfd
*ibfd
, struct bfd_link_info
*info
)
15321 bfd
*obfd
= info
->output_bfd
;
15322 struct mips_elf_obj_tdata
*out_tdata
= mips_elf_tdata (obfd
);
15323 flagword old_flags
;
15324 flagword new_flags
;
15327 new_flags
= elf_elfheader (ibfd
)->e_flags
;
15328 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_NOREORDER
;
15329 old_flags
= elf_elfheader (obfd
)->e_flags
;
15331 /* Check flag compatibility. */
15333 new_flags
&= ~EF_MIPS_NOREORDER
;
15334 old_flags
&= ~EF_MIPS_NOREORDER
;
15336 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
15337 doesn't seem to matter. */
15338 new_flags
&= ~EF_MIPS_XGOT
;
15339 old_flags
&= ~EF_MIPS_XGOT
;
15341 /* MIPSpro generates ucode info in n64 objects. Again, we should
15342 just be able to ignore this. */
15343 new_flags
&= ~EF_MIPS_UCODE
;
15344 old_flags
&= ~EF_MIPS_UCODE
;
15346 /* DSOs should only be linked with CPIC code. */
15347 if ((ibfd
->flags
& DYNAMIC
) != 0)
15348 new_flags
|= EF_MIPS_PIC
| EF_MIPS_CPIC
;
15350 if (new_flags
== old_flags
)
15355 if (((new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0)
15356 != ((old_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0))
15359 (_("%pB: warning: linking abicalls files with non-abicalls files"),
15364 if (new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
))
15365 elf_elfheader (obfd
)->e_flags
|= EF_MIPS_CPIC
;
15366 if (! (new_flags
& EF_MIPS_PIC
))
15367 elf_elfheader (obfd
)->e_flags
&= ~EF_MIPS_PIC
;
15369 new_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
15370 old_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
15372 /* Compare the ISAs. */
15373 if (mips_32bit_flags_p (old_flags
) != mips_32bit_flags_p (new_flags
))
15376 (_("%pB: linking 32-bit code with 64-bit code"),
15380 else if (!mips_mach_extends_p (bfd_get_mach (ibfd
), bfd_get_mach (obfd
)))
15382 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
15383 if (mips_mach_extends_p (bfd_get_mach (obfd
), bfd_get_mach (ibfd
)))
15385 /* Copy the architecture info from IBFD to OBFD. Also copy
15386 the 32-bit flag (if set) so that we continue to recognise
15387 OBFD as a 32-bit binary. */
15388 bfd_set_arch_info (obfd
, bfd_get_arch_info (ibfd
));
15389 elf_elfheader (obfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
15390 elf_elfheader (obfd
)->e_flags
15391 |= new_flags
& (EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
15393 /* Update the ABI flags isa_level, isa_rev, isa_ext fields. */
15394 update_mips_abiflags_isa (obfd
, &out_tdata
->abiflags
);
15396 /* Copy across the ABI flags if OBFD doesn't use them
15397 and if that was what caused us to treat IBFD as 32-bit. */
15398 if ((old_flags
& EF_MIPS_ABI
) == 0
15399 && mips_32bit_flags_p (new_flags
)
15400 && !mips_32bit_flags_p (new_flags
& ~EF_MIPS_ABI
))
15401 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ABI
;
15405 /* The ISAs aren't compatible. */
15407 /* xgettext:c-format */
15408 (_("%pB: linking %s module with previous %s modules"),
15410 bfd_printable_name (ibfd
),
15411 bfd_printable_name (obfd
));
15416 new_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
15417 old_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
15419 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
15420 does set EI_CLASS differently from any 32-bit ABI. */
15421 if ((new_flags
& EF_MIPS_ABI
) != (old_flags
& EF_MIPS_ABI
)
15422 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
15423 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
15425 /* Only error if both are set (to different values). */
15426 if (((new_flags
& EF_MIPS_ABI
) && (old_flags
& EF_MIPS_ABI
))
15427 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
15428 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
15431 /* xgettext:c-format */
15432 (_("%pB: ABI mismatch: linking %s module with previous %s modules"),
15434 elf_mips_abi_name (ibfd
),
15435 elf_mips_abi_name (obfd
));
15438 new_flags
&= ~EF_MIPS_ABI
;
15439 old_flags
&= ~EF_MIPS_ABI
;
15442 /* Compare ASEs. Forbid linking MIPS16 and microMIPS ASE modules together
15443 and allow arbitrary mixing of the remaining ASEs (retain the union). */
15444 if ((new_flags
& EF_MIPS_ARCH_ASE
) != (old_flags
& EF_MIPS_ARCH_ASE
))
15446 int old_micro
= old_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
;
15447 int new_micro
= new_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
;
15448 int old_m16
= old_flags
& EF_MIPS_ARCH_ASE_M16
;
15449 int new_m16
= new_flags
& EF_MIPS_ARCH_ASE_M16
;
15450 int micro_mis
= old_m16
&& new_micro
;
15451 int m16_mis
= old_micro
&& new_m16
;
15453 if (m16_mis
|| micro_mis
)
15456 /* xgettext:c-format */
15457 (_("%pB: ASE mismatch: linking %s module with previous %s modules"),
15459 m16_mis
? "MIPS16" : "microMIPS",
15460 m16_mis
? "microMIPS" : "MIPS16");
15464 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ARCH_ASE
;
15466 new_flags
&= ~ EF_MIPS_ARCH_ASE
;
15467 old_flags
&= ~ EF_MIPS_ARCH_ASE
;
15470 /* Compare NaN encodings. */
15471 if ((new_flags
& EF_MIPS_NAN2008
) != (old_flags
& EF_MIPS_NAN2008
))
15473 /* xgettext:c-format */
15474 _bfd_error_handler (_("%pB: linking %s module with previous %s modules"),
15476 (new_flags
& EF_MIPS_NAN2008
15477 ? "-mnan=2008" : "-mnan=legacy"),
15478 (old_flags
& EF_MIPS_NAN2008
15479 ? "-mnan=2008" : "-mnan=legacy"));
15481 new_flags
&= ~EF_MIPS_NAN2008
;
15482 old_flags
&= ~EF_MIPS_NAN2008
;
15485 /* Compare FP64 state. */
15486 if ((new_flags
& EF_MIPS_FP64
) != (old_flags
& EF_MIPS_FP64
))
15488 /* xgettext:c-format */
15489 _bfd_error_handler (_("%pB: linking %s module with previous %s modules"),
15491 (new_flags
& EF_MIPS_FP64
15492 ? "-mfp64" : "-mfp32"),
15493 (old_flags
& EF_MIPS_FP64
15494 ? "-mfp64" : "-mfp32"));
15496 new_flags
&= ~EF_MIPS_FP64
;
15497 old_flags
&= ~EF_MIPS_FP64
;
15500 /* Warn about any other mismatches */
15501 if (new_flags
!= old_flags
)
15503 /* xgettext:c-format */
15505 (_("%pB: uses different e_flags (%#x) fields than previous modules "
15507 ibfd
, new_flags
, old_flags
);
15514 /* Merge object attributes from IBFD into OBFD. Raise an error if
15515 there are conflicting attributes. */
15517 mips_elf_merge_obj_attributes (bfd
*ibfd
, struct bfd_link_info
*info
)
15519 bfd
*obfd
= info
->output_bfd
;
15520 obj_attribute
*in_attr
;
15521 obj_attribute
*out_attr
;
15525 abi_fp_bfd
= mips_elf_tdata (obfd
)->abi_fp_bfd
;
15526 in_attr
= elf_known_obj_attributes (ibfd
)[OBJ_ATTR_GNU
];
15527 if (!abi_fp_bfd
&& in_attr
[Tag_GNU_MIPS_ABI_FP
].i
!= Val_GNU_MIPS_ABI_FP_ANY
)
15528 mips_elf_tdata (obfd
)->abi_fp_bfd
= ibfd
;
15530 abi_msa_bfd
= mips_elf_tdata (obfd
)->abi_msa_bfd
;
15532 && in_attr
[Tag_GNU_MIPS_ABI_MSA
].i
!= Val_GNU_MIPS_ABI_MSA_ANY
)
15533 mips_elf_tdata (obfd
)->abi_msa_bfd
= ibfd
;
15535 if (!elf_known_obj_attributes_proc (obfd
)[0].i
)
15537 /* This is the first object. Copy the attributes. */
15538 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
15540 /* Use the Tag_null value to indicate the attributes have been
15542 elf_known_obj_attributes_proc (obfd
)[0].i
= 1;
15547 /* Check for conflicting Tag_GNU_MIPS_ABI_FP attributes and merge
15548 non-conflicting ones. */
15549 out_attr
= elf_known_obj_attributes (obfd
)[OBJ_ATTR_GNU
];
15550 if (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
!= out_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
15554 out_fp
= out_attr
[Tag_GNU_MIPS_ABI_FP
].i
;
15555 in_fp
= in_attr
[Tag_GNU_MIPS_ABI_FP
].i
;
15556 out_attr
[Tag_GNU_MIPS_ABI_FP
].type
= 1;
15557 if (out_fp
== Val_GNU_MIPS_ABI_FP_ANY
)
15558 out_attr
[Tag_GNU_MIPS_ABI_FP
].i
= in_fp
;
15559 else if (out_fp
== Val_GNU_MIPS_ABI_FP_XX
15560 && (in_fp
== Val_GNU_MIPS_ABI_FP_DOUBLE
15561 || in_fp
== Val_GNU_MIPS_ABI_FP_64
15562 || in_fp
== Val_GNU_MIPS_ABI_FP_64A
))
15564 mips_elf_tdata (obfd
)->abi_fp_bfd
= ibfd
;
15565 out_attr
[Tag_GNU_MIPS_ABI_FP
].i
= in_attr
[Tag_GNU_MIPS_ABI_FP
].i
;
15567 else if (in_fp
== Val_GNU_MIPS_ABI_FP_XX
15568 && (out_fp
== Val_GNU_MIPS_ABI_FP_DOUBLE
15569 || out_fp
== Val_GNU_MIPS_ABI_FP_64
15570 || out_fp
== Val_GNU_MIPS_ABI_FP_64A
))
15571 /* Keep the current setting. */;
15572 else if (out_fp
== Val_GNU_MIPS_ABI_FP_64A
15573 && in_fp
== Val_GNU_MIPS_ABI_FP_64
)
15575 mips_elf_tdata (obfd
)->abi_fp_bfd
= ibfd
;
15576 out_attr
[Tag_GNU_MIPS_ABI_FP
].i
= in_attr
[Tag_GNU_MIPS_ABI_FP
].i
;
15578 else if (in_fp
== Val_GNU_MIPS_ABI_FP_64A
15579 && out_fp
== Val_GNU_MIPS_ABI_FP_64
)
15580 /* Keep the current setting. */;
15581 else if (in_fp
!= Val_GNU_MIPS_ABI_FP_ANY
)
15583 const char *out_string
, *in_string
;
15585 out_string
= _bfd_mips_fp_abi_string (out_fp
);
15586 in_string
= _bfd_mips_fp_abi_string (in_fp
);
15587 /* First warn about cases involving unrecognised ABIs. */
15588 if (!out_string
&& !in_string
)
15589 /* xgettext:c-format */
15591 (_("warning: %pB uses unknown floating point ABI %d "
15592 "(set by %pB), %pB uses unknown floating point ABI %d"),
15593 obfd
, out_fp
, abi_fp_bfd
, ibfd
, in_fp
);
15594 else if (!out_string
)
15596 /* xgettext:c-format */
15597 (_("warning: %pB uses unknown floating point ABI %d "
15598 "(set by %pB), %pB uses %s"),
15599 obfd
, out_fp
, abi_fp_bfd
, ibfd
, in_string
);
15600 else if (!in_string
)
15602 /* xgettext:c-format */
15603 (_("warning: %pB uses %s (set by %pB), "
15604 "%pB uses unknown floating point ABI %d"),
15605 obfd
, out_string
, abi_fp_bfd
, ibfd
, in_fp
);
15608 /* If one of the bfds is soft-float, the other must be
15609 hard-float. The exact choice of hard-float ABI isn't
15610 really relevant to the error message. */
15611 if (in_fp
== Val_GNU_MIPS_ABI_FP_SOFT
)
15612 out_string
= "-mhard-float";
15613 else if (out_fp
== Val_GNU_MIPS_ABI_FP_SOFT
)
15614 in_string
= "-mhard-float";
15616 /* xgettext:c-format */
15617 (_("warning: %pB uses %s (set by %pB), %pB uses %s"),
15618 obfd
, out_string
, abi_fp_bfd
, ibfd
, in_string
);
15623 /* Check for conflicting Tag_GNU_MIPS_ABI_MSA attributes and merge
15624 non-conflicting ones. */
15625 if (in_attr
[Tag_GNU_MIPS_ABI_MSA
].i
!= out_attr
[Tag_GNU_MIPS_ABI_MSA
].i
)
15627 out_attr
[Tag_GNU_MIPS_ABI_MSA
].type
= 1;
15628 if (out_attr
[Tag_GNU_MIPS_ABI_MSA
].i
== Val_GNU_MIPS_ABI_MSA_ANY
)
15629 out_attr
[Tag_GNU_MIPS_ABI_MSA
].i
= in_attr
[Tag_GNU_MIPS_ABI_MSA
].i
;
15630 else if (in_attr
[Tag_GNU_MIPS_ABI_MSA
].i
!= Val_GNU_MIPS_ABI_MSA_ANY
)
15631 switch (out_attr
[Tag_GNU_MIPS_ABI_MSA
].i
)
15633 case Val_GNU_MIPS_ABI_MSA_128
:
15635 /* xgettext:c-format */
15636 (_("warning: %pB uses %s (set by %pB), "
15637 "%pB uses unknown MSA ABI %d"),
15638 obfd
, "-mmsa", abi_msa_bfd
,
15639 ibfd
, in_attr
[Tag_GNU_MIPS_ABI_MSA
].i
);
15643 switch (in_attr
[Tag_GNU_MIPS_ABI_MSA
].i
)
15645 case Val_GNU_MIPS_ABI_MSA_128
:
15647 /* xgettext:c-format */
15648 (_("warning: %pB uses unknown MSA ABI %d "
15649 "(set by %pB), %pB uses %s"),
15650 obfd
, out_attr
[Tag_GNU_MIPS_ABI_MSA
].i
,
15651 abi_msa_bfd
, ibfd
, "-mmsa");
15656 /* xgettext:c-format */
15657 (_("warning: %pB uses unknown MSA ABI %d "
15658 "(set by %pB), %pB uses unknown MSA ABI %d"),
15659 obfd
, out_attr
[Tag_GNU_MIPS_ABI_MSA
].i
,
15660 abi_msa_bfd
, ibfd
, in_attr
[Tag_GNU_MIPS_ABI_MSA
].i
);
15666 /* Merge Tag_compatibility attributes and any common GNU ones. */
15667 return _bfd_elf_merge_object_attributes (ibfd
, info
);
15670 /* Merge object ABI flags from IBFD into OBFD. Raise an error if
15671 there are conflicting settings. */
15674 mips_elf_merge_obj_abiflags (bfd
*ibfd
, bfd
*obfd
)
15676 obj_attribute
*out_attr
= elf_known_obj_attributes (obfd
)[OBJ_ATTR_GNU
];
15677 struct mips_elf_obj_tdata
*out_tdata
= mips_elf_tdata (obfd
);
15678 struct mips_elf_obj_tdata
*in_tdata
= mips_elf_tdata (ibfd
);
15680 /* Update the output abiflags fp_abi using the computed fp_abi. */
15681 out_tdata
->abiflags
.fp_abi
= out_attr
[Tag_GNU_MIPS_ABI_FP
].i
;
15683 #define max(a, b) ((a) > (b) ? (a) : (b))
15684 /* Merge abiflags. */
15685 out_tdata
->abiflags
.isa_level
= max (out_tdata
->abiflags
.isa_level
,
15686 in_tdata
->abiflags
.isa_level
);
15687 out_tdata
->abiflags
.isa_rev
= max (out_tdata
->abiflags
.isa_rev
,
15688 in_tdata
->abiflags
.isa_rev
);
15689 out_tdata
->abiflags
.gpr_size
= max (out_tdata
->abiflags
.gpr_size
,
15690 in_tdata
->abiflags
.gpr_size
);
15691 out_tdata
->abiflags
.cpr1_size
= max (out_tdata
->abiflags
.cpr1_size
,
15692 in_tdata
->abiflags
.cpr1_size
);
15693 out_tdata
->abiflags
.cpr2_size
= max (out_tdata
->abiflags
.cpr2_size
,
15694 in_tdata
->abiflags
.cpr2_size
);
15696 out_tdata
->abiflags
.ases
|= in_tdata
->abiflags
.ases
;
15697 out_tdata
->abiflags
.flags1
|= in_tdata
->abiflags
.flags1
;
15702 /* Merge backend specific data from an object file to the output
15703 object file when linking. */
15706 _bfd_mips_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
15708 bfd
*obfd
= info
->output_bfd
;
15709 struct mips_elf_obj_tdata
*out_tdata
;
15710 struct mips_elf_obj_tdata
*in_tdata
;
15711 bfd_boolean null_input_bfd
= TRUE
;
15715 /* Check if we have the same endianness. */
15716 if (! _bfd_generic_verify_endian_match (ibfd
, info
))
15719 (_("%pB: endianness incompatible with that of the selected emulation"),
15724 if (!is_mips_elf (ibfd
) || !is_mips_elf (obfd
))
15727 in_tdata
= mips_elf_tdata (ibfd
);
15728 out_tdata
= mips_elf_tdata (obfd
);
15730 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
15733 (_("%pB: ABI is incompatible with that of the selected emulation"),
15738 /* Check to see if the input BFD actually contains any sections. If not,
15739 then it has no attributes, and its flags may not have been initialized
15740 either, but it cannot actually cause any incompatibility. */
15741 /* FIXME: This excludes any input shared library from consideration. */
15742 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
15744 /* Ignore synthetic sections and empty .text, .data and .bss sections
15745 which are automatically generated by gas. Also ignore fake
15746 (s)common sections, since merely defining a common symbol does
15747 not affect compatibility. */
15748 if ((sec
->flags
& SEC_IS_COMMON
) == 0
15749 && strcmp (sec
->name
, ".reginfo")
15750 && strcmp (sec
->name
, ".mdebug")
15752 || (strcmp (sec
->name
, ".text")
15753 && strcmp (sec
->name
, ".data")
15754 && strcmp (sec
->name
, ".bss"))))
15756 null_input_bfd
= FALSE
;
15760 if (null_input_bfd
)
15763 /* Populate abiflags using existing information. */
15764 if (in_tdata
->abiflags_valid
)
15766 obj_attribute
*in_attr
= elf_known_obj_attributes (ibfd
)[OBJ_ATTR_GNU
];
15767 Elf_Internal_ABIFlags_v0 in_abiflags
;
15768 Elf_Internal_ABIFlags_v0 abiflags
;
15770 /* Set up the FP ABI attribute from the abiflags if it is not already
15772 if (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
== Val_GNU_MIPS_ABI_FP_ANY
)
15773 in_attr
[Tag_GNU_MIPS_ABI_FP
].i
= in_tdata
->abiflags
.fp_abi
;
15775 infer_mips_abiflags (ibfd
, &abiflags
);
15776 in_abiflags
= in_tdata
->abiflags
;
15778 /* It is not possible to infer the correct ISA revision
15779 for R3 or R5 so drop down to R2 for the checks. */
15780 if (in_abiflags
.isa_rev
== 3 || in_abiflags
.isa_rev
== 5)
15781 in_abiflags
.isa_rev
= 2;
15783 if (LEVEL_REV (in_abiflags
.isa_level
, in_abiflags
.isa_rev
)
15784 < LEVEL_REV (abiflags
.isa_level
, abiflags
.isa_rev
))
15786 (_("%pB: warning: inconsistent ISA between e_flags and "
15787 ".MIPS.abiflags"), ibfd
);
15788 if (abiflags
.fp_abi
!= Val_GNU_MIPS_ABI_FP_ANY
15789 && in_abiflags
.fp_abi
!= abiflags
.fp_abi
)
15791 (_("%pB: warning: inconsistent FP ABI between .gnu.attributes and "
15792 ".MIPS.abiflags"), ibfd
);
15793 if ((in_abiflags
.ases
& abiflags
.ases
) != abiflags
.ases
)
15795 (_("%pB: warning: inconsistent ASEs between e_flags and "
15796 ".MIPS.abiflags"), ibfd
);
15797 /* The isa_ext is allowed to be an extension of what can be inferred
15799 if (!mips_mach_extends_p (bfd_mips_isa_ext_mach (abiflags
.isa_ext
),
15800 bfd_mips_isa_ext_mach (in_abiflags
.isa_ext
)))
15802 (_("%pB: warning: inconsistent ISA extensions between e_flags and "
15803 ".MIPS.abiflags"), ibfd
);
15804 if (in_abiflags
.flags2
!= 0)
15806 (_("%pB: warning: unexpected flag in the flags2 field of "
15807 ".MIPS.abiflags (0x%lx)"), ibfd
,
15808 in_abiflags
.flags2
);
15812 infer_mips_abiflags (ibfd
, &in_tdata
->abiflags
);
15813 in_tdata
->abiflags_valid
= TRUE
;
15816 if (!out_tdata
->abiflags_valid
)
15818 /* Copy input abiflags if output abiflags are not already valid. */
15819 out_tdata
->abiflags
= in_tdata
->abiflags
;
15820 out_tdata
->abiflags_valid
= TRUE
;
15823 if (! elf_flags_init (obfd
))
15825 elf_flags_init (obfd
) = TRUE
;
15826 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
15827 elf_elfheader (obfd
)->e_ident
[EI_CLASS
]
15828 = elf_elfheader (ibfd
)->e_ident
[EI_CLASS
];
15830 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
15831 && (bfd_get_arch_info (obfd
)->the_default
15832 || mips_mach_extends_p (bfd_get_mach (obfd
),
15833 bfd_get_mach (ibfd
))))
15835 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
15836 bfd_get_mach (ibfd
)))
15839 /* Update the ABI flags isa_level, isa_rev and isa_ext fields. */
15840 update_mips_abiflags_isa (obfd
, &out_tdata
->abiflags
);
15846 ok
= mips_elf_merge_obj_e_flags (ibfd
, info
);
15848 ok
= mips_elf_merge_obj_attributes (ibfd
, info
) && ok
;
15850 ok
= mips_elf_merge_obj_abiflags (ibfd
, obfd
) && ok
;
15854 bfd_set_error (bfd_error_bad_value
);
15861 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
15864 _bfd_mips_elf_set_private_flags (bfd
*abfd
, flagword flags
)
15866 BFD_ASSERT (!elf_flags_init (abfd
)
15867 || elf_elfheader (abfd
)->e_flags
== flags
);
15869 elf_elfheader (abfd
)->e_flags
= flags
;
15870 elf_flags_init (abfd
) = TRUE
;
15875 _bfd_mips_elf_get_target_dtag (bfd_vma dtag
)
15879 default: return "";
15880 case DT_MIPS_RLD_VERSION
:
15881 return "MIPS_RLD_VERSION";
15882 case DT_MIPS_TIME_STAMP
:
15883 return "MIPS_TIME_STAMP";
15884 case DT_MIPS_ICHECKSUM
:
15885 return "MIPS_ICHECKSUM";
15886 case DT_MIPS_IVERSION
:
15887 return "MIPS_IVERSION";
15888 case DT_MIPS_FLAGS
:
15889 return "MIPS_FLAGS";
15890 case DT_MIPS_BASE_ADDRESS
:
15891 return "MIPS_BASE_ADDRESS";
15893 return "MIPS_MSYM";
15894 case DT_MIPS_CONFLICT
:
15895 return "MIPS_CONFLICT";
15896 case DT_MIPS_LIBLIST
:
15897 return "MIPS_LIBLIST";
15898 case DT_MIPS_LOCAL_GOTNO
:
15899 return "MIPS_LOCAL_GOTNO";
15900 case DT_MIPS_CONFLICTNO
:
15901 return "MIPS_CONFLICTNO";
15902 case DT_MIPS_LIBLISTNO
:
15903 return "MIPS_LIBLISTNO";
15904 case DT_MIPS_SYMTABNO
:
15905 return "MIPS_SYMTABNO";
15906 case DT_MIPS_UNREFEXTNO
:
15907 return "MIPS_UNREFEXTNO";
15908 case DT_MIPS_GOTSYM
:
15909 return "MIPS_GOTSYM";
15910 case DT_MIPS_HIPAGENO
:
15911 return "MIPS_HIPAGENO";
15912 case DT_MIPS_RLD_MAP
:
15913 return "MIPS_RLD_MAP";
15914 case DT_MIPS_RLD_MAP_REL
:
15915 return "MIPS_RLD_MAP_REL";
15916 case DT_MIPS_DELTA_CLASS
:
15917 return "MIPS_DELTA_CLASS";
15918 case DT_MIPS_DELTA_CLASS_NO
:
15919 return "MIPS_DELTA_CLASS_NO";
15920 case DT_MIPS_DELTA_INSTANCE
:
15921 return "MIPS_DELTA_INSTANCE";
15922 case DT_MIPS_DELTA_INSTANCE_NO
:
15923 return "MIPS_DELTA_INSTANCE_NO";
15924 case DT_MIPS_DELTA_RELOC
:
15925 return "MIPS_DELTA_RELOC";
15926 case DT_MIPS_DELTA_RELOC_NO
:
15927 return "MIPS_DELTA_RELOC_NO";
15928 case DT_MIPS_DELTA_SYM
:
15929 return "MIPS_DELTA_SYM";
15930 case DT_MIPS_DELTA_SYM_NO
:
15931 return "MIPS_DELTA_SYM_NO";
15932 case DT_MIPS_DELTA_CLASSSYM
:
15933 return "MIPS_DELTA_CLASSSYM";
15934 case DT_MIPS_DELTA_CLASSSYM_NO
:
15935 return "MIPS_DELTA_CLASSSYM_NO";
15936 case DT_MIPS_CXX_FLAGS
:
15937 return "MIPS_CXX_FLAGS";
15938 case DT_MIPS_PIXIE_INIT
:
15939 return "MIPS_PIXIE_INIT";
15940 case DT_MIPS_SYMBOL_LIB
:
15941 return "MIPS_SYMBOL_LIB";
15942 case DT_MIPS_LOCALPAGE_GOTIDX
:
15943 return "MIPS_LOCALPAGE_GOTIDX";
15944 case DT_MIPS_LOCAL_GOTIDX
:
15945 return "MIPS_LOCAL_GOTIDX";
15946 case DT_MIPS_HIDDEN_GOTIDX
:
15947 return "MIPS_HIDDEN_GOTIDX";
15948 case DT_MIPS_PROTECTED_GOTIDX
:
15949 return "MIPS_PROTECTED_GOT_IDX";
15950 case DT_MIPS_OPTIONS
:
15951 return "MIPS_OPTIONS";
15952 case DT_MIPS_INTERFACE
:
15953 return "MIPS_INTERFACE";
15954 case DT_MIPS_DYNSTR_ALIGN
:
15955 return "DT_MIPS_DYNSTR_ALIGN";
15956 case DT_MIPS_INTERFACE_SIZE
:
15957 return "DT_MIPS_INTERFACE_SIZE";
15958 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
:
15959 return "DT_MIPS_RLD_TEXT_RESOLVE_ADDR";
15960 case DT_MIPS_PERF_SUFFIX
:
15961 return "DT_MIPS_PERF_SUFFIX";
15962 case DT_MIPS_COMPACT_SIZE
:
15963 return "DT_MIPS_COMPACT_SIZE";
15964 case DT_MIPS_GP_VALUE
:
15965 return "DT_MIPS_GP_VALUE";
15966 case DT_MIPS_AUX_DYNAMIC
:
15967 return "DT_MIPS_AUX_DYNAMIC";
15968 case DT_MIPS_PLTGOT
:
15969 return "DT_MIPS_PLTGOT";
15970 case DT_MIPS_RWPLT
:
15971 return "DT_MIPS_RWPLT";
15972 case DT_MIPS_XHASH
:
15973 return "DT_MIPS_XHASH";
15977 /* Return the meaning of Tag_GNU_MIPS_ABI_FP value FP, or null if
15981 _bfd_mips_fp_abi_string (int fp
)
15985 /* These strings aren't translated because they're simply
15987 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15988 return "-mdouble-float";
15990 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15991 return "-msingle-float";
15993 case Val_GNU_MIPS_ABI_FP_SOFT
:
15994 return "-msoft-float";
15996 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15997 return _("-mips32r2 -mfp64 (12 callee-saved)");
15999 case Val_GNU_MIPS_ABI_FP_XX
:
16002 case Val_GNU_MIPS_ABI_FP_64
:
16003 return "-mgp32 -mfp64";
16005 case Val_GNU_MIPS_ABI_FP_64A
:
16006 return "-mgp32 -mfp64 -mno-odd-spreg";
16014 print_mips_ases (FILE *file
, unsigned int mask
)
16016 if (mask
& AFL_ASE_DSP
)
16017 fputs ("\n\tDSP ASE", file
);
16018 if (mask
& AFL_ASE_DSPR2
)
16019 fputs ("\n\tDSP R2 ASE", file
);
16020 if (mask
& AFL_ASE_DSPR3
)
16021 fputs ("\n\tDSP R3 ASE", file
);
16022 if (mask
& AFL_ASE_EVA
)
16023 fputs ("\n\tEnhanced VA Scheme", file
);
16024 if (mask
& AFL_ASE_MCU
)
16025 fputs ("\n\tMCU (MicroController) ASE", file
);
16026 if (mask
& AFL_ASE_MDMX
)
16027 fputs ("\n\tMDMX ASE", file
);
16028 if (mask
& AFL_ASE_MIPS3D
)
16029 fputs ("\n\tMIPS-3D ASE", file
);
16030 if (mask
& AFL_ASE_MT
)
16031 fputs ("\n\tMT ASE", file
);
16032 if (mask
& AFL_ASE_SMARTMIPS
)
16033 fputs ("\n\tSmartMIPS ASE", file
);
16034 if (mask
& AFL_ASE_VIRT
)
16035 fputs ("\n\tVZ ASE", file
);
16036 if (mask
& AFL_ASE_MSA
)
16037 fputs ("\n\tMSA ASE", file
);
16038 if (mask
& AFL_ASE_MIPS16
)
16039 fputs ("\n\tMIPS16 ASE", file
);
16040 if (mask
& AFL_ASE_MICROMIPS
)
16041 fputs ("\n\tMICROMIPS ASE", file
);
16042 if (mask
& AFL_ASE_XPA
)
16043 fputs ("\n\tXPA ASE", file
);
16044 if (mask
& AFL_ASE_MIPS16E2
)
16045 fputs ("\n\tMIPS16e2 ASE", file
);
16046 if (mask
& AFL_ASE_CRC
)
16047 fputs ("\n\tCRC ASE", file
);
16048 if (mask
& AFL_ASE_GINV
)
16049 fputs ("\n\tGINV ASE", file
);
16050 if (mask
& AFL_ASE_LOONGSON_MMI
)
16051 fputs ("\n\tLoongson MMI ASE", file
);
16052 if (mask
& AFL_ASE_LOONGSON_CAM
)
16053 fputs ("\n\tLoongson CAM ASE", file
);
16054 if (mask
& AFL_ASE_LOONGSON_EXT
)
16055 fputs ("\n\tLoongson EXT ASE", file
);
16056 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16057 fputs ("\n\tLoongson EXT2 ASE", file
);
16059 fprintf (file
, "\n\t%s", _("None"));
16060 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16061 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16065 print_mips_isa_ext (FILE *file
, unsigned int isa_ext
)
16070 fputs (_("None"), file
);
16073 fputs ("RMI XLR", file
);
16075 case AFL_EXT_OCTEON3
:
16076 fputs ("Cavium Networks Octeon3", file
);
16078 case AFL_EXT_OCTEON2
:
16079 fputs ("Cavium Networks Octeon2", file
);
16081 case AFL_EXT_OCTEONP
:
16082 fputs ("Cavium Networks OcteonP", file
);
16084 case AFL_EXT_OCTEON
:
16085 fputs ("Cavium Networks Octeon", file
);
16088 fputs ("Toshiba R5900", file
);
16091 fputs ("MIPS R4650", file
);
16094 fputs ("LSI R4010", file
);
16097 fputs ("NEC VR4100", file
);
16100 fputs ("Toshiba R3900", file
);
16102 case AFL_EXT_10000
:
16103 fputs ("MIPS R10000", file
);
16106 fputs ("Broadcom SB-1", file
);
16109 fputs ("NEC VR4111/VR4181", file
);
16112 fputs ("NEC VR4120", file
);
16115 fputs ("NEC VR5400", file
);
16118 fputs ("NEC VR5500", file
);
16120 case AFL_EXT_LOONGSON_2E
:
16121 fputs ("ST Microelectronics Loongson 2E", file
);
16123 case AFL_EXT_LOONGSON_2F
:
16124 fputs ("ST Microelectronics Loongson 2F", file
);
16126 case AFL_EXT_INTERAPTIV_MR2
:
16127 fputs ("Imagination interAptiv MR2", file
);
16130 fprintf (file
, "%s (%d)", _("Unknown"), isa_ext
);
16136 print_mips_fp_abi_value (FILE *file
, int val
)
16140 case Val_GNU_MIPS_ABI_FP_ANY
:
16141 fprintf (file
, _("Hard or soft float\n"));
16143 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
16144 fprintf (file
, _("Hard float (double precision)\n"));
16146 case Val_GNU_MIPS_ABI_FP_SINGLE
:
16147 fprintf (file
, _("Hard float (single precision)\n"));
16149 case Val_GNU_MIPS_ABI_FP_SOFT
:
16150 fprintf (file
, _("Soft float\n"));
16152 case Val_GNU_MIPS_ABI_FP_OLD_64
:
16153 fprintf (file
, _("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
16155 case Val_GNU_MIPS_ABI_FP_XX
:
16156 fprintf (file
, _("Hard float (32-bit CPU, Any FPU)\n"));
16158 case Val_GNU_MIPS_ABI_FP_64
:
16159 fprintf (file
, _("Hard float (32-bit CPU, 64-bit FPU)\n"));
16161 case Val_GNU_MIPS_ABI_FP_64A
:
16162 fprintf (file
, _("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
16165 fprintf (file
, "??? (%d)\n", val
);
16171 get_mips_reg_size (int reg_size
)
16173 return (reg_size
== AFL_REG_NONE
) ? 0
16174 : (reg_size
== AFL_REG_32
) ? 32
16175 : (reg_size
== AFL_REG_64
) ? 64
16176 : (reg_size
== AFL_REG_128
) ? 128
16181 _bfd_mips_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
16185 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
16187 /* Print normal ELF private data. */
16188 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
16190 /* xgettext:c-format */
16191 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
16193 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
)
16194 fprintf (file
, _(" [abi=O32]"));
16195 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O64
)
16196 fprintf (file
, _(" [abi=O64]"));
16197 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
)
16198 fprintf (file
, _(" [abi=EABI32]"));
16199 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
16200 fprintf (file
, _(" [abi=EABI64]"));
16201 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
))
16202 fprintf (file
, _(" [abi unknown]"));
16203 else if (ABI_N32_P (abfd
))
16204 fprintf (file
, _(" [abi=N32]"));
16205 else if (ABI_64_P (abfd
))
16206 fprintf (file
, _(" [abi=64]"));
16208 fprintf (file
, _(" [no abi set]"));
16210 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
16211 fprintf (file
, " [mips1]");
16212 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
16213 fprintf (file
, " [mips2]");
16214 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
16215 fprintf (file
, " [mips3]");
16216 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
16217 fprintf (file
, " [mips4]");
16218 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_5
)
16219 fprintf (file
, " [mips5]");
16220 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
)
16221 fprintf (file
, " [mips32]");
16222 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64
)
16223 fprintf (file
, " [mips64]");
16224 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
)
16225 fprintf (file
, " [mips32r2]");
16226 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64R2
)
16227 fprintf (file
, " [mips64r2]");
16228 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R6
)
16229 fprintf (file
, " [mips32r6]");
16230 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64R6
)
16231 fprintf (file
, " [mips64r6]");
16233 fprintf (file
, _(" [unknown ISA]"));
16235 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
16236 fprintf (file
, " [mdmx]");
16238 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_M16
)
16239 fprintf (file
, " [mips16]");
16241 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
16242 fprintf (file
, " [micromips]");
16244 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_NAN2008
)
16245 fprintf (file
, " [nan2008]");
16247 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_FP64
)
16248 fprintf (file
, " [old fp64]");
16250 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_32BITMODE
)
16251 fprintf (file
, " [32bitmode]");
16253 fprintf (file
, _(" [not 32bitmode]"));
16255 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_NOREORDER
)
16256 fprintf (file
, " [noreorder]");
16258 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_PIC
)
16259 fprintf (file
, " [PIC]");
16261 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_CPIC
)
16262 fprintf (file
, " [CPIC]");
16264 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_XGOT
)
16265 fprintf (file
, " [XGOT]");
16267 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_UCODE
)
16268 fprintf (file
, " [UCODE]");
16270 fputc ('\n', file
);
16272 if (mips_elf_tdata (abfd
)->abiflags_valid
)
16274 Elf_Internal_ABIFlags_v0
*abiflags
= &mips_elf_tdata (abfd
)->abiflags
;
16275 fprintf (file
, "\nMIPS ABI Flags Version: %d\n", abiflags
->version
);
16276 fprintf (file
, "\nISA: MIPS%d", abiflags
->isa_level
);
16277 if (abiflags
->isa_rev
> 1)
16278 fprintf (file
, "r%d", abiflags
->isa_rev
);
16279 fprintf (file
, "\nGPR size: %d",
16280 get_mips_reg_size (abiflags
->gpr_size
));
16281 fprintf (file
, "\nCPR1 size: %d",
16282 get_mips_reg_size (abiflags
->cpr1_size
));
16283 fprintf (file
, "\nCPR2 size: %d",
16284 get_mips_reg_size (abiflags
->cpr2_size
));
16285 fputs ("\nFP ABI: ", file
);
16286 print_mips_fp_abi_value (file
, abiflags
->fp_abi
);
16287 fputs ("ISA Extension: ", file
);
16288 print_mips_isa_ext (file
, abiflags
->isa_ext
);
16289 fputs ("\nASEs:", file
);
16290 print_mips_ases (file
, abiflags
->ases
);
16291 fprintf (file
, "\nFLAGS 1: %8.8lx", abiflags
->flags1
);
16292 fprintf (file
, "\nFLAGS 2: %8.8lx", abiflags
->flags2
);
16293 fputc ('\n', file
);
16299 const struct bfd_elf_special_section _bfd_mips_elf_special_sections
[] =
16301 { STRING_COMMA_LEN (".lit4"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
16302 { STRING_COMMA_LEN (".lit8"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
16303 { STRING_COMMA_LEN (".mdebug"), 0, SHT_MIPS_DEBUG
, 0 },
16304 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
16305 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
16306 { STRING_COMMA_LEN (".ucode"), 0, SHT_MIPS_UCODE
, 0 },
16307 { STRING_COMMA_LEN (".MIPS.xhash"), 0, SHT_MIPS_XHASH
, SHF_ALLOC
},
16308 { NULL
, 0, 0, 0, 0 }
16311 /* Merge non visibility st_other attributes. Ensure that the
16312 STO_OPTIONAL flag is copied into h->other, even if this is not a
16313 definiton of the symbol. */
16315 _bfd_mips_elf_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
16316 const Elf_Internal_Sym
*isym
,
16317 bfd_boolean definition
,
16318 bfd_boolean dynamic ATTRIBUTE_UNUSED
)
16320 if ((isym
->st_other
& ~ELF_ST_VISIBILITY (-1)) != 0)
16322 unsigned char other
;
16324 other
= (definition
? isym
->st_other
: h
->other
);
16325 other
&= ~ELF_ST_VISIBILITY (-1);
16326 h
->other
= other
| ELF_ST_VISIBILITY (h
->other
);
16330 && ELF_MIPS_IS_OPTIONAL (isym
->st_other
))
16331 h
->other
|= STO_OPTIONAL
;
16334 /* Decide whether an undefined symbol is special and can be ignored.
16335 This is the case for OPTIONAL symbols on IRIX. */
16337 _bfd_mips_elf_ignore_undef_symbol (struct elf_link_hash_entry
*h
)
16339 return ELF_MIPS_IS_OPTIONAL (h
->other
) ? TRUE
: FALSE
;
16343 _bfd_mips_elf_common_definition (Elf_Internal_Sym
*sym
)
16345 return (sym
->st_shndx
== SHN_COMMON
16346 || sym
->st_shndx
== SHN_MIPS_ACOMMON
16347 || sym
->st_shndx
== SHN_MIPS_SCOMMON
);
16350 /* Return address for Ith PLT stub in section PLT, for relocation REL
16351 or (bfd_vma) -1 if it should not be included. */
16354 _bfd_mips_elf_plt_sym_val (bfd_vma i
, const asection
*plt
,
16355 const arelent
*rel ATTRIBUTE_UNUSED
)
16358 + 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry
)
16359 + i
* 4 * ARRAY_SIZE (mips_exec_plt_entry
));
16362 /* Build a table of synthetic symbols to represent the PLT. As with MIPS16
16363 and microMIPS PLT slots we may have a many-to-one mapping between .plt
16364 and .got.plt and also the slots may be of a different size each we walk
16365 the PLT manually fetching instructions and matching them against known
16366 patterns. To make things easier standard MIPS slots, if any, always come
16367 first. As we don't create proper ELF symbols we use the UDATA.I member
16368 of ASYMBOL to carry ISA annotation. The encoding used is the same as
16369 with the ST_OTHER member of the ELF symbol. */
16372 _bfd_mips_elf_get_synthetic_symtab (bfd
*abfd
,
16373 long symcount ATTRIBUTE_UNUSED
,
16374 asymbol
**syms ATTRIBUTE_UNUSED
,
16375 long dynsymcount
, asymbol
**dynsyms
,
16378 static const char pltname
[] = "_PROCEDURE_LINKAGE_TABLE_";
16379 static const char microsuffix
[] = "@micromipsplt";
16380 static const char m16suffix
[] = "@mips16plt";
16381 static const char mipssuffix
[] = "@plt";
16383 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
16384 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
16385 bfd_boolean micromips_p
= MICROMIPS_P (abfd
);
16386 Elf_Internal_Shdr
*hdr
;
16387 bfd_byte
*plt_data
;
16388 bfd_vma plt_offset
;
16389 unsigned int other
;
16390 bfd_vma entry_size
;
16409 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0 || dynsymcount
<= 0)
16412 relplt
= bfd_get_section_by_name (abfd
, ".rel.plt");
16413 if (relplt
== NULL
)
16416 hdr
= &elf_section_data (relplt
)->this_hdr
;
16417 if (hdr
->sh_link
!= elf_dynsymtab (abfd
) || hdr
->sh_type
!= SHT_REL
)
16420 plt
= bfd_get_section_by_name (abfd
, ".plt");
16424 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
16425 if (!(*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
16427 p
= relplt
->relocation
;
16429 /* Calculating the exact amount of space required for symbols would
16430 require two passes over the PLT, so just pessimise assuming two
16431 PLT slots per relocation. */
16432 count
= relplt
->size
/ hdr
->sh_entsize
;
16433 counti
= count
* bed
->s
->int_rels_per_ext_rel
;
16434 size
= 2 * count
* sizeof (asymbol
);
16435 size
+= count
* (sizeof (mipssuffix
) +
16436 (micromips_p
? sizeof (microsuffix
) : sizeof (m16suffix
)));
16437 for (pi
= 0; pi
< counti
; pi
+= bed
->s
->int_rels_per_ext_rel
)
16438 size
+= 2 * strlen ((*p
[pi
].sym_ptr_ptr
)->name
);
16440 /* Add the size of "_PROCEDURE_LINKAGE_TABLE_" too. */
16441 size
+= sizeof (asymbol
) + sizeof (pltname
);
16443 if (!bfd_malloc_and_get_section (abfd
, plt
, &plt_data
))
16446 if (plt
->size
< 16)
16449 s
= *ret
= bfd_malloc (size
);
16452 send
= s
+ 2 * count
+ 1;
16454 names
= (char *) send
;
16455 nend
= (char *) s
+ size
;
16458 opcode
= bfd_get_micromips_32 (abfd
, plt_data
+ 12);
16459 if (opcode
== 0x3302fffe)
16463 plt0_size
= 2 * ARRAY_SIZE (micromips_o32_exec_plt0_entry
);
16464 other
= STO_MICROMIPS
;
16466 else if (opcode
== 0x0398c1d0)
16470 plt0_size
= 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt0_entry
);
16471 other
= STO_MICROMIPS
;
16475 plt0_size
= 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry
);
16480 s
->flags
= BSF_SYNTHETIC
| BSF_FUNCTION
| BSF_LOCAL
;
16484 s
->udata
.i
= other
;
16485 memcpy (names
, pltname
, sizeof (pltname
));
16486 names
+= sizeof (pltname
);
16490 for (plt_offset
= plt0_size
;
16491 plt_offset
+ 8 <= plt
->size
&& s
< send
;
16492 plt_offset
+= entry_size
)
16494 bfd_vma gotplt_addr
;
16495 const char *suffix
;
16500 opcode
= bfd_get_micromips_32 (abfd
, plt_data
+ plt_offset
+ 4);
16502 /* Check if the second word matches the expected MIPS16 instruction. */
16503 if (opcode
== 0x651aeb00)
16507 /* Truncated table??? */
16508 if (plt_offset
+ 16 > plt
->size
)
16510 gotplt_addr
= bfd_get_32 (abfd
, plt_data
+ plt_offset
+ 12);
16511 entry_size
= 2 * ARRAY_SIZE (mips16_o32_exec_plt_entry
);
16512 suffixlen
= sizeof (m16suffix
);
16513 suffix
= m16suffix
;
16514 other
= STO_MIPS16
;
16516 /* Likewise the expected microMIPS instruction (no insn32 mode). */
16517 else if (opcode
== 0xff220000)
16521 gotplt_hi
= bfd_get_16 (abfd
, plt_data
+ plt_offset
) & 0x7f;
16522 gotplt_lo
= bfd_get_16 (abfd
, plt_data
+ plt_offset
+ 2) & 0xffff;
16523 gotplt_hi
= ((gotplt_hi
^ 0x40) - 0x40) << 18;
16525 gotplt_addr
= gotplt_hi
+ gotplt_lo
;
16526 gotplt_addr
+= ((plt
->vma
+ plt_offset
) | 3) ^ 3;
16527 entry_size
= 2 * ARRAY_SIZE (micromips_o32_exec_plt_entry
);
16528 suffixlen
= sizeof (microsuffix
);
16529 suffix
= microsuffix
;
16530 other
= STO_MICROMIPS
;
16532 /* Likewise the expected microMIPS instruction (insn32 mode). */
16533 else if ((opcode
& 0xffff0000) == 0xff2f0000)
16535 gotplt_hi
= bfd_get_16 (abfd
, plt_data
+ plt_offset
+ 2) & 0xffff;
16536 gotplt_lo
= bfd_get_16 (abfd
, plt_data
+ plt_offset
+ 6) & 0xffff;
16537 gotplt_hi
= ((gotplt_hi
^ 0x8000) - 0x8000) << 16;
16538 gotplt_lo
= (gotplt_lo
^ 0x8000) - 0x8000;
16539 gotplt_addr
= gotplt_hi
+ gotplt_lo
;
16540 entry_size
= 2 * ARRAY_SIZE (micromips_insn32_o32_exec_plt_entry
);
16541 suffixlen
= sizeof (microsuffix
);
16542 suffix
= microsuffix
;
16543 other
= STO_MICROMIPS
;
16545 /* Otherwise assume standard MIPS code. */
16548 gotplt_hi
= bfd_get_32 (abfd
, plt_data
+ plt_offset
) & 0xffff;
16549 gotplt_lo
= bfd_get_32 (abfd
, plt_data
+ plt_offset
+ 4) & 0xffff;
16550 gotplt_hi
= ((gotplt_hi
^ 0x8000) - 0x8000) << 16;
16551 gotplt_lo
= (gotplt_lo
^ 0x8000) - 0x8000;
16552 gotplt_addr
= gotplt_hi
+ gotplt_lo
;
16553 entry_size
= 4 * ARRAY_SIZE (mips_exec_plt_entry
);
16554 suffixlen
= sizeof (mipssuffix
);
16555 suffix
= mipssuffix
;
16558 /* Truncated table??? */
16559 if (plt_offset
+ entry_size
> plt
->size
)
16563 i
< count
&& p
[pi
].address
!= gotplt_addr
;
16564 i
++, pi
= (pi
+ bed
->s
->int_rels_per_ext_rel
) % counti
);
16571 *s
= **p
[pi
].sym_ptr_ptr
;
16572 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
16573 we are defining a symbol, ensure one of them is set. */
16574 if ((s
->flags
& BSF_LOCAL
) == 0)
16575 s
->flags
|= BSF_GLOBAL
;
16576 s
->flags
|= BSF_SYNTHETIC
;
16578 s
->value
= plt_offset
;
16580 s
->udata
.i
= other
;
16582 len
= strlen ((*p
[pi
].sym_ptr_ptr
)->name
);
16583 namelen
= len
+ suffixlen
;
16584 if (names
+ namelen
> nend
)
16587 memcpy (names
, (*p
[pi
].sym_ptr_ptr
)->name
, len
);
16589 memcpy (names
, suffix
, suffixlen
);
16590 names
+= suffixlen
;
16593 pi
= (pi
+ bed
->s
->int_rels_per_ext_rel
) % counti
;
16602 /* Return the ABI flags associated with ABFD if available. */
16604 Elf_Internal_ABIFlags_v0
*
16605 bfd_mips_elf_get_abiflags (bfd
*abfd
)
16607 struct mips_elf_obj_tdata
*tdata
= mips_elf_tdata (abfd
);
16609 return tdata
->abiflags_valid
? &tdata
->abiflags
: NULL
;
16612 /* MIPS libc ABI versions, used with the EI_ABIVERSION ELF file header
16613 field. Taken from `libc-abis.h' generated at GNU libc build time.
16614 Using a MIPS_ prefix as other libc targets use different values. */
16617 MIPS_LIBC_ABI_DEFAULT
= 0,
16618 MIPS_LIBC_ABI_MIPS_PLT
,
16619 MIPS_LIBC_ABI_UNIQUE
,
16620 MIPS_LIBC_ABI_MIPS_O32_FP64
,
16621 MIPS_LIBC_ABI_ABSOLUTE
,
16622 MIPS_LIBC_ABI_XHASH
,
16627 _bfd_mips_init_file_header (bfd
*abfd
, struct bfd_link_info
*link_info
)
16629 struct mips_elf_link_hash_table
*htab
= NULL
;
16630 Elf_Internal_Ehdr
*i_ehdrp
;
16632 if (!_bfd_elf_init_file_header (abfd
, link_info
))
16635 i_ehdrp
= elf_elfheader (abfd
);
16638 htab
= mips_elf_hash_table (link_info
);
16639 BFD_ASSERT (htab
!= NULL
);
16642 if (htab
!= NULL
&& htab
->use_plts_and_copy_relocs
&& !htab
->is_vxworks
)
16643 i_ehdrp
->e_ident
[EI_ABIVERSION
] = MIPS_LIBC_ABI_MIPS_PLT
;
16645 if (mips_elf_tdata (abfd
)->abiflags
.fp_abi
== Val_GNU_MIPS_ABI_FP_64
16646 || mips_elf_tdata (abfd
)->abiflags
.fp_abi
== Val_GNU_MIPS_ABI_FP_64A
)
16647 i_ehdrp
->e_ident
[EI_ABIVERSION
] = MIPS_LIBC_ABI_MIPS_O32_FP64
;
16649 /* Mark that we need support for absolute symbols in the dynamic loader. */
16650 if (htab
!= NULL
&& htab
->use_absolute_zero
&& htab
->gnu_target
)
16651 i_ehdrp
->e_ident
[EI_ABIVERSION
] = MIPS_LIBC_ABI_ABSOLUTE
;
16653 /* Mark that we need support for .MIPS.xhash in the dynamic linker,
16654 if it is the only hash section that will be created. */
16655 if (link_info
&& link_info
->emit_gnu_hash
&& !link_info
->emit_hash
)
16656 i_ehdrp
->e_ident
[EI_ABIVERSION
] = MIPS_LIBC_ABI_XHASH
;
16661 _bfd_mips_elf_compact_eh_encoding
16662 (struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
)
16664 return DW_EH_PE_pcrel
| DW_EH_PE_sdata4
;
16667 /* Return the opcode for can't unwind. */
16670 _bfd_mips_elf_cant_unwind_opcode
16671 (struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
)
16673 return COMPACT_EH_CANT_UNWIND_OPCODE
;
16676 /* Record a position XLAT_LOC in the xlat translation table, associated with
16677 the hash entry H. The entry in the translation table will later be
16678 populated with the real symbol dynindx. */
16681 _bfd_mips_elf_record_xhash_symbol (struct elf_link_hash_entry
*h
,
16684 struct mips_elf_link_hash_entry
*hmips
;
16686 hmips
= (struct mips_elf_link_hash_entry
*) h
;
16687 hmips
->mipsxhash_loc
= xlat_loc
;