1 /* MIPS-specific support for ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013
4 Free Software Foundation, Inc.
6 Most of the information added by Ian Lance Taylor, Cygnus Support,
8 N32/64 ABI support added by Mark Mitchell, CodeSourcery, LLC.
9 <mark@codesourcery.com>
10 Traditional MIPS targets support added by Koundinya.K, Dansk Data
11 Elektronik & Operations Research Group. <kk@ddeorg.soft.net>
13 This file is part of BFD, the Binary File Descriptor library.
15 This program is free software; you can redistribute it and/or modify
16 it under the terms of the GNU General Public License as published by
17 the Free Software Foundation; either version 3 of the License, or
18 (at your option) any later version.
20 This program is distributed in the hope that it will be useful,
21 but WITHOUT ANY WARRANTY; without even the implied warranty of
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 GNU General Public License for more details.
25 You should have received a copy of the GNU General Public License
26 along with this program; if not, write to the Free Software
27 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
28 MA 02110-1301, USA. */
31 /* This file handles functionality common to the different MIPS ABI's. */
36 #include "libiberty.h"
38 #include "elfxx-mips.h"
40 #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 /* This structure is used to hold information about one GOT entry.
51 There are three types of entry:
53 (1) absolute addresses
55 (2) SYMBOL + OFFSET addresses, where SYMBOL is local to an input bfd
56 (abfd != NULL, symndx >= 0)
57 (3) SYMBOL addresses, where SYMBOL is not local to an input bfd
58 (abfd != NULL, symndx == -1)
60 Type (3) entries are treated differently for different types of GOT.
61 In the "master" GOT -- i.e. the one that describes every GOT
62 reference needed in the link -- the mips_got_entry is keyed on both
63 the symbol and the input bfd that references it. If it turns out
64 that we need multiple GOTs, we can then use this information to
65 create separate GOTs for each input bfd.
67 However, we want each of these separate GOTs to have at most one
68 entry for a given symbol, so their type (3) entries are keyed only
69 on the symbol. The input bfd given by the "abfd" field is somewhat
70 arbitrary in this case.
72 This means that when there are multiple GOTs, each GOT has a unique
73 mips_got_entry for every symbol within it. We can therefore use the
74 mips_got_entry fields (tls_type and gotidx) to track the symbol's
77 However, if it turns out that we need only a single GOT, we continue
78 to use the master GOT to describe it. There may therefore be several
79 mips_got_entries for the same symbol, each with a different input bfd.
80 We want to make sure that each symbol gets a unique GOT entry, so when
81 there's a single GOT, we use the symbol's hash entry, not the
82 mips_got_entry fields, to track a symbol's GOT index. */
85 /* The input bfd in which the symbol is defined. */
87 /* The index of the symbol, as stored in the relocation r_info, if
88 we have a local symbol; -1 otherwise. */
92 /* If abfd == NULL, an address that must be stored in the got. */
94 /* If abfd != NULL && symndx != -1, the addend of the relocation
95 that should be added to the symbol value. */
97 /* If abfd != NULL && symndx == -1, the hash table entry
98 corresponding to symbol in the GOT. The symbol's entry
99 is in the local area if h->global_got_area is GGA_NONE,
100 otherwise it is in the global area. */
101 struct mips_elf_link_hash_entry
*h
;
104 /* The TLS type of this GOT entry: GOT_NORMAL, GOT_TLS_IE, GOT_TLS_GD
105 or GOT_TLS_LDM. An LDM GOT entry will be a local symbol entry with
107 unsigned char tls_type
;
109 /* The offset from the beginning of the .got section to the entry
110 corresponding to this symbol+addend. If it's a global symbol
111 whose offset is yet to be decided, it's going to be -1. */
115 /* This structure describes a range of addends: [MIN_ADDEND, MAX_ADDEND].
116 The structures form a non-overlapping list that is sorted by increasing
118 struct mips_got_page_range
120 struct mips_got_page_range
*next
;
121 bfd_signed_vma min_addend
;
122 bfd_signed_vma max_addend
;
125 /* This structure describes the range of addends that are applied to page
126 relocations against a given symbol. */
127 struct mips_got_page_entry
129 /* The input bfd in which the symbol is defined. */
131 /* The index of the symbol, as stored in the relocation r_info. */
133 /* The ranges for this page entry. */
134 struct mips_got_page_range
*ranges
;
135 /* The maximum number of page entries needed for RANGES. */
139 /* This structure is used to hold .got information when linking. */
143 /* The number of global .got entries. */
144 unsigned int global_gotno
;
145 /* The number of global .got entries that are in the GGA_RELOC_ONLY area. */
146 unsigned int reloc_only_gotno
;
147 /* The number of .got slots used for TLS. */
148 unsigned int tls_gotno
;
149 /* The first unused TLS .got entry. Used only during
150 mips_elf_initialize_tls_index. */
151 unsigned int tls_assigned_gotno
;
152 /* The number of local .got entries, eventually including page entries. */
153 unsigned int local_gotno
;
154 /* The maximum number of page entries needed. */
155 unsigned int page_gotno
;
156 /* The number of relocations needed for the GOT entries. */
158 /* The number of local .got entries we have used. */
159 unsigned int assigned_gotno
;
160 /* A hash table holding members of the got. */
161 struct htab
*got_entries
;
162 /* A hash table of mips_got_page_entry structures. */
163 struct htab
*got_page_entries
;
164 /* A hash table mapping input bfds to other mips_got_info. NULL
165 unless multi-got was necessary. */
166 struct htab
*bfd2got
;
167 /* In multi-got links, a pointer to the next got (err, rather, most
168 of the time, it points to the previous got). */
169 struct mips_got_info
*next
;
170 /* This is the GOT index of the TLS LDM entry for the GOT, MINUS_ONE
171 for none, or MINUS_TWO for not yet assigned. This is needed
172 because a single-GOT link may have multiple hash table entries
173 for the LDM. It does not get initialized in multi-GOT mode. */
174 bfd_vma tls_ldm_offset
;
177 /* Map an input bfd to a got in a multi-got link. */
179 struct mips_elf_bfd2got_hash
182 struct mips_got_info
*g
;
185 /* Structure passed when traversing the bfd2got hash table, used to
186 create and merge bfd's gots. */
188 struct mips_elf_got_per_bfd_arg
190 /* A hashtable that maps bfds to gots. */
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_ADDIU(VAL) (0x27390000 | (VAL)) /* addiu t9,t9,VAL */
297 #define LA25_LUI_MICROMIPS(VAL) \
298 (0x41b90000 | (VAL)) /* lui t9,VAL */
299 #define LA25_J_MICROMIPS(VAL) \
300 (0xd4000000 | (((VAL) >> 1) & 0x3ffffff)) /* j VAL */
301 #define LA25_ADDIU_MICROMIPS(VAL) \
302 (0x33390000 | (VAL)) /* addiu t9,t9,VAL */
304 /* This structure is passed to mips_elf_sort_hash_table_f when sorting
305 the dynamic symbols. */
307 struct mips_elf_hash_sort_data
309 /* The symbol in the global GOT with the lowest dynamic symbol table
311 struct elf_link_hash_entry
*low
;
312 /* The least dynamic symbol table index corresponding to a non-TLS
313 symbol with a GOT entry. */
314 long min_got_dynindx
;
315 /* The greatest dynamic symbol table index corresponding to a symbol
316 with a GOT entry that is not referenced (e.g., a dynamic symbol
317 with dynamic relocations pointing to it from non-primary GOTs). */
318 long max_unref_got_dynindx
;
319 /* The greatest dynamic symbol table index not corresponding to a
320 symbol without a GOT entry. */
321 long max_non_got_dynindx
;
324 /* The MIPS ELF linker needs additional information for each symbol in
325 the global hash table. */
327 struct mips_elf_link_hash_entry
329 struct elf_link_hash_entry root
;
331 /* External symbol information. */
334 /* The la25 stub we have created for ths symbol, if any. */
335 struct mips_elf_la25_stub
*la25_stub
;
337 /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
339 unsigned int possibly_dynamic_relocs
;
341 /* If there is a stub that 32 bit functions should use to call this
342 16 bit function, this points to the section containing the stub. */
345 /* If there is a stub that 16 bit functions should use to call this
346 32 bit function, this points to the section containing the stub. */
349 /* This is like the call_stub field, but it is used if the function
350 being called returns a floating point value. */
351 asection
*call_fp_stub
;
355 #define GOT_TLS_LDM 2
357 #define GOT_TLS_TYPE 7
358 #define GOT_TLS_OFFSET_DONE 0x40
359 #define GOT_TLS_DONE 0x80
360 unsigned char tls_ie_type
;
361 unsigned char tls_gd_type
;
363 /* These fields are only used in single-GOT mode; in multi-GOT mode there
364 is one mips_got_entry per GOT entry, so the offset is stored
365 there. In single-GOT mode there may be many mips_got_entry
366 structures all referring to the same GOT slot. */
367 bfd_vma tls_ie_got_offset
;
368 bfd_vma tls_gd_got_offset
;
370 /* The highest GGA_* value that satisfies all references to this symbol. */
371 unsigned int global_got_area
: 2;
373 /* True if all GOT relocations against this symbol are for calls. This is
374 a looser condition than no_fn_stub below, because there may be other
375 non-call non-GOT relocations against the symbol. */
376 unsigned int got_only_for_calls
: 1;
378 /* True if one of the relocations described by possibly_dynamic_relocs
379 is against a readonly section. */
380 unsigned int readonly_reloc
: 1;
382 /* True if there is a relocation against this symbol that must be
383 resolved by the static linker (in other words, if the relocation
384 cannot possibly be made dynamic). */
385 unsigned int has_static_relocs
: 1;
387 /* True if we must not create a .MIPS.stubs entry for this symbol.
388 This is set, for example, if there are relocations related to
389 taking the function's address, i.e. any but R_MIPS_CALL*16 ones.
390 See "MIPS ABI Supplement, 3rd Edition", p. 4-20. */
391 unsigned int no_fn_stub
: 1;
393 /* Whether we need the fn_stub; this is true if this symbol appears
394 in any relocs other than a 16 bit call. */
395 unsigned int need_fn_stub
: 1;
397 /* True if this symbol is referenced by branch relocations from
398 any non-PIC input file. This is used to determine whether an
399 la25 stub is required. */
400 unsigned int has_nonpic_branches
: 1;
402 /* Does this symbol need a traditional MIPS lazy-binding stub
403 (as opposed to a PLT entry)? */
404 unsigned int needs_lazy_stub
: 1;
407 /* MIPS ELF linker hash table. */
409 struct mips_elf_link_hash_table
411 struct elf_link_hash_table root
;
413 /* The number of .rtproc entries. */
414 bfd_size_type procedure_count
;
416 /* The size of the .compact_rel section (if SGI_COMPAT). */
417 bfd_size_type compact_rel_size
;
419 /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic entry
420 is set to the address of __rld_obj_head as in IRIX5 and IRIX6. */
421 bfd_boolean use_rld_obj_head
;
423 /* The __rld_map or __rld_obj_head symbol. */
424 struct elf_link_hash_entry
*rld_symbol
;
426 /* This is set if we see any mips16 stub sections. */
427 bfd_boolean mips16_stubs_seen
;
429 /* True if we can generate copy relocs and PLTs. */
430 bfd_boolean use_plts_and_copy_relocs
;
432 /* True if we're generating code for VxWorks. */
433 bfd_boolean is_vxworks
;
435 /* True if we already reported the small-data section overflow. */
436 bfd_boolean small_data_overflow_reported
;
438 /* Shortcuts to some dynamic sections, or NULL if they are not
449 /* The master GOT information. */
450 struct mips_got_info
*got_info
;
452 /* The global symbol in the GOT with the lowest index in the dynamic
454 struct elf_link_hash_entry
*global_gotsym
;
456 /* The size of the PLT header in bytes. */
457 bfd_vma plt_header_size
;
459 /* The size of a PLT entry in bytes. */
460 bfd_vma plt_entry_size
;
462 /* The number of functions that need a lazy-binding stub. */
463 bfd_vma lazy_stub_count
;
465 /* The size of a function stub entry in bytes. */
466 bfd_vma function_stub_size
;
468 /* The number of reserved entries at the beginning of the GOT. */
469 unsigned int reserved_gotno
;
471 /* The section used for mips_elf_la25_stub trampolines.
472 See the comment above that structure for details. */
473 asection
*strampoline
;
475 /* A table of mips_elf_la25_stubs, indexed by (input_section, offset)
479 /* A function FN (NAME, IS, OS) that creates a new input section
480 called NAME and links it to output section OS. If IS is nonnull,
481 the new section should go immediately before it, otherwise it
482 should go at the (current) beginning of OS.
484 The function returns the new section on success, otherwise it
486 asection
*(*add_stub_section
) (const char *, asection
*, asection
*);
489 /* Get the MIPS ELF linker hash table from a link_info structure. */
491 #define mips_elf_hash_table(p) \
492 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
493 == MIPS_ELF_DATA ? ((struct mips_elf_link_hash_table *) ((p)->hash)) : NULL)
495 /* A structure used to communicate with htab_traverse callbacks. */
496 struct mips_htab_traverse_info
498 /* The usual link-wide information. */
499 struct bfd_link_info
*info
;
502 /* Starts off FALSE and is set to TRUE if the link should be aborted. */
506 /* MIPS ELF private object data. */
508 struct mips_elf_obj_tdata
510 /* Generic ELF private object data. */
511 struct elf_obj_tdata root
;
513 /* Input BFD providing Tag_GNU_MIPS_ABI_FP attribute for output. */
517 /* Get MIPS ELF private object data from BFD's tdata. */
519 #define mips_elf_tdata(bfd) \
520 ((struct mips_elf_obj_tdata *) (bfd)->tdata.any)
522 #define TLS_RELOC_P(r_type) \
523 (r_type == R_MIPS_TLS_DTPMOD32 \
524 || r_type == R_MIPS_TLS_DTPMOD64 \
525 || r_type == R_MIPS_TLS_DTPREL32 \
526 || r_type == R_MIPS_TLS_DTPREL64 \
527 || r_type == R_MIPS_TLS_GD \
528 || r_type == R_MIPS_TLS_LDM \
529 || r_type == R_MIPS_TLS_DTPREL_HI16 \
530 || r_type == R_MIPS_TLS_DTPREL_LO16 \
531 || r_type == R_MIPS_TLS_GOTTPREL \
532 || r_type == R_MIPS_TLS_TPREL32 \
533 || r_type == R_MIPS_TLS_TPREL64 \
534 || r_type == R_MIPS_TLS_TPREL_HI16 \
535 || r_type == R_MIPS_TLS_TPREL_LO16 \
536 || r_type == R_MIPS16_TLS_GD \
537 || r_type == R_MIPS16_TLS_LDM \
538 || r_type == R_MIPS16_TLS_DTPREL_HI16 \
539 || r_type == R_MIPS16_TLS_DTPREL_LO16 \
540 || r_type == R_MIPS16_TLS_GOTTPREL \
541 || r_type == R_MIPS16_TLS_TPREL_HI16 \
542 || r_type == R_MIPS16_TLS_TPREL_LO16 \
543 || r_type == R_MICROMIPS_TLS_GD \
544 || r_type == R_MICROMIPS_TLS_LDM \
545 || r_type == R_MICROMIPS_TLS_DTPREL_HI16 \
546 || r_type == R_MICROMIPS_TLS_DTPREL_LO16 \
547 || r_type == R_MICROMIPS_TLS_GOTTPREL \
548 || r_type == R_MICROMIPS_TLS_TPREL_HI16 \
549 || r_type == R_MICROMIPS_TLS_TPREL_LO16)
551 /* Structure used to pass information to mips_elf_output_extsym. */
556 struct bfd_link_info
*info
;
557 struct ecoff_debug_info
*debug
;
558 const struct ecoff_debug_swap
*swap
;
562 /* The names of the runtime procedure table symbols used on IRIX5. */
564 static const char * const mips_elf_dynsym_rtproc_names
[] =
567 "_procedure_string_table",
568 "_procedure_table_size",
572 /* These structures are used to generate the .compact_rel section on
577 unsigned long id1
; /* Always one? */
578 unsigned long num
; /* Number of compact relocation entries. */
579 unsigned long id2
; /* Always two? */
580 unsigned long offset
; /* The file offset of the first relocation. */
581 unsigned long reserved0
; /* Zero? */
582 unsigned long reserved1
; /* Zero? */
591 bfd_byte reserved0
[4];
592 bfd_byte reserved1
[4];
593 } Elf32_External_compact_rel
;
597 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
598 unsigned int rtype
: 4; /* Relocation types. See below. */
599 unsigned int dist2to
: 8;
600 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
601 unsigned long konst
; /* KONST field. See below. */
602 unsigned long vaddr
; /* VADDR to be relocated. */
607 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
608 unsigned int rtype
: 4; /* Relocation types. See below. */
609 unsigned int dist2to
: 8;
610 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
611 unsigned long konst
; /* KONST field. See below. */
619 } Elf32_External_crinfo
;
625 } Elf32_External_crinfo2
;
627 /* These are the constants used to swap the bitfields in a crinfo. */
629 #define CRINFO_CTYPE (0x1)
630 #define CRINFO_CTYPE_SH (31)
631 #define CRINFO_RTYPE (0xf)
632 #define CRINFO_RTYPE_SH (27)
633 #define CRINFO_DIST2TO (0xff)
634 #define CRINFO_DIST2TO_SH (19)
635 #define CRINFO_RELVADDR (0x7ffff)
636 #define CRINFO_RELVADDR_SH (0)
638 /* A compact relocation info has long (3 words) or short (2 words)
639 formats. A short format doesn't have VADDR field and relvaddr
640 fields contains ((VADDR - vaddr of the previous entry) >> 2). */
641 #define CRF_MIPS_LONG 1
642 #define CRF_MIPS_SHORT 0
644 /* There are 4 types of compact relocation at least. The value KONST
645 has different meaning for each type:
648 CT_MIPS_REL32 Address in data
649 CT_MIPS_WORD Address in word (XXX)
650 CT_MIPS_GPHI_LO GP - vaddr
651 CT_MIPS_JMPAD Address to jump
654 #define CRT_MIPS_REL32 0xa
655 #define CRT_MIPS_WORD 0xb
656 #define CRT_MIPS_GPHI_LO 0xc
657 #define CRT_MIPS_JMPAD 0xd
659 #define mips_elf_set_cr_format(x,format) ((x).ctype = (format))
660 #define mips_elf_set_cr_type(x,type) ((x).rtype = (type))
661 #define mips_elf_set_cr_dist2to(x,v) ((x).dist2to = (v))
662 #define mips_elf_set_cr_relvaddr(x,d) ((x).relvaddr = (d)<<2)
664 /* The structure of the runtime procedure descriptor created by the
665 loader for use by the static exception system. */
667 typedef struct runtime_pdr
{
668 bfd_vma adr
; /* Memory address of start of procedure. */
669 long regmask
; /* Save register mask. */
670 long regoffset
; /* Save register offset. */
671 long fregmask
; /* Save floating point register mask. */
672 long fregoffset
; /* Save floating point register offset. */
673 long frameoffset
; /* Frame size. */
674 short framereg
; /* Frame pointer register. */
675 short pcreg
; /* Offset or reg of return pc. */
676 long irpss
; /* Index into the runtime string table. */
678 struct exception_info
*exception_info
;/* Pointer to exception array. */
680 #define cbRPDR sizeof (RPDR)
681 #define rpdNil ((pRPDR) 0)
683 static struct mips_got_entry
*mips_elf_create_local_got_entry
684 (bfd
*, struct bfd_link_info
*, bfd
*, bfd_vma
, unsigned long,
685 struct mips_elf_link_hash_entry
*, int);
686 static bfd_boolean mips_elf_sort_hash_table_f
687 (struct mips_elf_link_hash_entry
*, void *);
688 static bfd_vma mips_elf_high
690 static bfd_boolean mips_elf_create_dynamic_relocation
691 (bfd
*, struct bfd_link_info
*, const Elf_Internal_Rela
*,
692 struct mips_elf_link_hash_entry
*, asection
*, bfd_vma
,
693 bfd_vma
*, asection
*);
694 static bfd_vma mips_elf_adjust_gp
695 (bfd
*, struct mips_got_info
*, bfd
*);
696 static struct mips_got_info
*mips_elf_got_for_ibfd
697 (struct mips_got_info
*, bfd
*);
699 /* This will be used when we sort the dynamic relocation records. */
700 static bfd
*reldyn_sorting_bfd
;
702 /* True if ABFD is for CPUs with load interlocking that include
703 non-MIPS1 CPUs and R3900. */
704 #define LOAD_INTERLOCKS_P(abfd) \
705 ( ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) != E_MIPS_ARCH_1) \
706 || ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == E_MIPS_MACH_3900))
708 /* True if ABFD is for CPUs that are faster if JAL is converted to BAL.
709 This should be safe for all architectures. We enable this predicate
710 for RM9000 for now. */
711 #define JAL_TO_BAL_P(abfd) \
712 ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == E_MIPS_MACH_9000)
714 /* True if ABFD is for CPUs that are faster if JALR is converted to BAL.
715 This should be safe for all architectures. We enable this predicate for
717 #define JALR_TO_BAL_P(abfd) 1
719 /* True if ABFD is for CPUs that are faster if JR is converted to B.
720 This should be safe for all architectures. We enable this predicate for
722 #define JR_TO_B_P(abfd) 1
724 /* True if ABFD is a PIC object. */
725 #define PIC_OBJECT_P(abfd) \
726 ((elf_elfheader (abfd)->e_flags & EF_MIPS_PIC) != 0)
728 /* Nonzero if ABFD is using the N32 ABI. */
729 #define ABI_N32_P(abfd) \
730 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
732 /* Nonzero if ABFD is using the N64 ABI. */
733 #define ABI_64_P(abfd) \
734 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
736 /* Nonzero if ABFD is using NewABI conventions. */
737 #define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
739 /* The IRIX compatibility level we are striving for. */
740 #define IRIX_COMPAT(abfd) \
741 (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
743 /* Whether we are trying to be compatible with IRIX at all. */
744 #define SGI_COMPAT(abfd) \
745 (IRIX_COMPAT (abfd) != ict_none)
747 /* The name of the options section. */
748 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
749 (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
751 /* True if NAME is the recognized name of any SHT_MIPS_OPTIONS section.
752 Some IRIX system files do not use MIPS_ELF_OPTIONS_SECTION_NAME. */
753 #define MIPS_ELF_OPTIONS_SECTION_NAME_P(NAME) \
754 (strcmp (NAME, ".MIPS.options") == 0 || strcmp (NAME, ".options") == 0)
756 /* Whether the section is readonly. */
757 #define MIPS_ELF_READONLY_SECTION(sec) \
758 ((sec->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY)) \
759 == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
761 /* The name of the stub section. */
762 #define MIPS_ELF_STUB_SECTION_NAME(abfd) ".MIPS.stubs"
764 /* The size of an external REL relocation. */
765 #define MIPS_ELF_REL_SIZE(abfd) \
766 (get_elf_backend_data (abfd)->s->sizeof_rel)
768 /* The size of an external RELA relocation. */
769 #define MIPS_ELF_RELA_SIZE(abfd) \
770 (get_elf_backend_data (abfd)->s->sizeof_rela)
772 /* The size of an external dynamic table entry. */
773 #define MIPS_ELF_DYN_SIZE(abfd) \
774 (get_elf_backend_data (abfd)->s->sizeof_dyn)
776 /* The size of a GOT entry. */
777 #define MIPS_ELF_GOT_SIZE(abfd) \
778 (get_elf_backend_data (abfd)->s->arch_size / 8)
780 /* The size of the .rld_map section. */
781 #define MIPS_ELF_RLD_MAP_SIZE(abfd) \
782 (get_elf_backend_data (abfd)->s->arch_size / 8)
784 /* The size of a symbol-table entry. */
785 #define MIPS_ELF_SYM_SIZE(abfd) \
786 (get_elf_backend_data (abfd)->s->sizeof_sym)
788 /* The default alignment for sections, as a power of two. */
789 #define MIPS_ELF_LOG_FILE_ALIGN(abfd) \
790 (get_elf_backend_data (abfd)->s->log_file_align)
792 /* Get word-sized data. */
793 #define MIPS_ELF_GET_WORD(abfd, ptr) \
794 (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
796 /* Put out word-sized data. */
797 #define MIPS_ELF_PUT_WORD(abfd, val, ptr) \
799 ? bfd_put_64 (abfd, val, ptr) \
800 : bfd_put_32 (abfd, val, ptr))
802 /* The opcode for word-sized loads (LW or LD). */
803 #define MIPS_ELF_LOAD_WORD(abfd) \
804 (ABI_64_P (abfd) ? 0xdc000000 : 0x8c000000)
806 /* Add a dynamic symbol table-entry. */
807 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
808 _bfd_elf_add_dynamic_entry (info, tag, val)
810 #define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela) \
811 (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela))
813 /* The name of the dynamic relocation section. */
814 #define MIPS_ELF_REL_DYN_NAME(INFO) \
815 (mips_elf_hash_table (INFO)->is_vxworks ? ".rela.dyn" : ".rel.dyn")
817 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
818 from smaller values. Start with zero, widen, *then* decrement. */
819 #define MINUS_ONE (((bfd_vma)0) - 1)
820 #define MINUS_TWO (((bfd_vma)0) - 2)
822 /* The value to write into got[1] for SVR4 targets, to identify it is
823 a GNU object. The dynamic linker can then use got[1] to store the
825 #define MIPS_ELF_GNU_GOT1_MASK(abfd) \
826 ((bfd_vma) 1 << (ABI_64_P (abfd) ? 63 : 31))
828 /* The offset of $gp from the beginning of the .got section. */
829 #define ELF_MIPS_GP_OFFSET(INFO) \
830 (mips_elf_hash_table (INFO)->is_vxworks ? 0x0 : 0x7ff0)
832 /* The maximum size of the GOT for it to be addressable using 16-bit
834 #define MIPS_ELF_GOT_MAX_SIZE(INFO) (ELF_MIPS_GP_OFFSET (INFO) + 0x7fff)
836 /* Instructions which appear in a stub. */
837 #define STUB_LW(abfd) \
839 ? 0xdf998010 /* ld t9,0x8010(gp) */ \
840 : 0x8f998010)) /* lw t9,0x8010(gp) */
841 #define STUB_MOVE(abfd) \
843 ? 0x03e0782d /* daddu t7,ra */ \
844 : 0x03e07821)) /* addu t7,ra */
845 #define STUB_LUI(VAL) (0x3c180000 + (VAL)) /* lui t8,VAL */
846 #define STUB_JALR 0x0320f809 /* jalr t9,ra */
847 #define STUB_ORI(VAL) (0x37180000 + (VAL)) /* ori t8,t8,VAL */
848 #define STUB_LI16U(VAL) (0x34180000 + (VAL)) /* ori t8,zero,VAL unsigned */
849 #define STUB_LI16S(abfd, VAL) \
851 ? (0x64180000 + (VAL)) /* daddiu t8,zero,VAL sign extended */ \
852 : (0x24180000 + (VAL)))) /* addiu t8,zero,VAL sign extended */
854 #define MIPS_FUNCTION_STUB_NORMAL_SIZE 16
855 #define MIPS_FUNCTION_STUB_BIG_SIZE 20
857 /* The name of the dynamic interpreter. This is put in the .interp
860 #define ELF_DYNAMIC_INTERPRETER(abfd) \
861 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
862 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
863 : "/usr/lib/libc.so.1")
866 #define MNAME(bfd,pre,pos) \
867 (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
868 #define ELF_R_SYM(bfd, i) \
869 (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
870 #define ELF_R_TYPE(bfd, i) \
871 (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
872 #define ELF_R_INFO(bfd, s, t) \
873 (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
875 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
876 #define ELF_R_SYM(bfd, i) \
878 #define ELF_R_TYPE(bfd, i) \
880 #define ELF_R_INFO(bfd, s, t) \
881 (ELF32_R_INFO (s, t))
884 /* The mips16 compiler uses a couple of special sections to handle
885 floating point arguments.
887 Section names that look like .mips16.fn.FNNAME contain stubs that
888 copy floating point arguments from the fp regs to the gp regs and
889 then jump to FNNAME. If any 32 bit function calls FNNAME, the
890 call should be redirected to the stub instead. If no 32 bit
891 function calls FNNAME, the stub should be discarded. We need to
892 consider any reference to the function, not just a call, because
893 if the address of the function is taken we will need the stub,
894 since the address might be passed to a 32 bit function.
896 Section names that look like .mips16.call.FNNAME contain stubs
897 that copy floating point arguments from the gp regs to the fp
898 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
899 then any 16 bit function that calls FNNAME should be redirected
900 to the stub instead. If FNNAME is not a 32 bit function, the
901 stub should be discarded.
903 .mips16.call.fp.FNNAME sections are similar, but contain stubs
904 which call FNNAME and then copy the return value from the fp regs
905 to the gp regs. These stubs store the return value in $18 while
906 calling FNNAME; any function which might call one of these stubs
907 must arrange to save $18 around the call. (This case is not
908 needed for 32 bit functions that call 16 bit functions, because
909 16 bit functions always return floating point values in both
912 Note that in all cases FNNAME might be defined statically.
913 Therefore, FNNAME is not used literally. Instead, the relocation
914 information will indicate which symbol the section is for.
916 We record any stubs that we find in the symbol table. */
918 #define FN_STUB ".mips16.fn."
919 #define CALL_STUB ".mips16.call."
920 #define CALL_FP_STUB ".mips16.call.fp."
922 #define FN_STUB_P(name) CONST_STRNEQ (name, FN_STUB)
923 #define CALL_STUB_P(name) CONST_STRNEQ (name, CALL_STUB)
924 #define CALL_FP_STUB_P(name) CONST_STRNEQ (name, CALL_FP_STUB)
926 /* The format of the first PLT entry in an O32 executable. */
927 static const bfd_vma mips_o32_exec_plt0_entry
[] =
929 0x3c1c0000, /* lui $28, %hi(&GOTPLT[0]) */
930 0x8f990000, /* lw $25, %lo(&GOTPLT[0])($28) */
931 0x279c0000, /* addiu $28, $28, %lo(&GOTPLT[0]) */
932 0x031cc023, /* subu $24, $24, $28 */
933 0x03e07821, /* move $15, $31 # 32-bit move (addu) */
934 0x0018c082, /* srl $24, $24, 2 */
935 0x0320f809, /* jalr $25 */
936 0x2718fffe /* subu $24, $24, 2 */
939 /* The format of the first PLT entry in an N32 executable. Different
940 because gp ($28) is not available; we use t2 ($14) instead. */
941 static const bfd_vma mips_n32_exec_plt0_entry
[] =
943 0x3c0e0000, /* lui $14, %hi(&GOTPLT[0]) */
944 0x8dd90000, /* lw $25, %lo(&GOTPLT[0])($14) */
945 0x25ce0000, /* addiu $14, $14, %lo(&GOTPLT[0]) */
946 0x030ec023, /* subu $24, $24, $14 */
947 0x03e07821, /* move $15, $31 # 32-bit move (addu) */
948 0x0018c082, /* srl $24, $24, 2 */
949 0x0320f809, /* jalr $25 */
950 0x2718fffe /* subu $24, $24, 2 */
953 /* The format of the first PLT entry in an N64 executable. Different
954 from N32 because of the increased size of GOT entries. */
955 static const bfd_vma mips_n64_exec_plt0_entry
[] =
957 0x3c0e0000, /* lui $14, %hi(&GOTPLT[0]) */
958 0xddd90000, /* ld $25, %lo(&GOTPLT[0])($14) */
959 0x25ce0000, /* addiu $14, $14, %lo(&GOTPLT[0]) */
960 0x030ec023, /* subu $24, $24, $14 */
961 0x03e0782d, /* move $15, $31 # 64-bit move (daddu) */
962 0x0018c0c2, /* srl $24, $24, 3 */
963 0x0320f809, /* jalr $25 */
964 0x2718fffe /* subu $24, $24, 2 */
967 /* The format of subsequent PLT entries. */
968 static const bfd_vma mips_exec_plt_entry
[] =
970 0x3c0f0000, /* lui $15, %hi(.got.plt entry) */
971 0x01f90000, /* l[wd] $25, %lo(.got.plt entry)($15) */
972 0x25f80000, /* addiu $24, $15, %lo(.got.plt entry) */
973 0x03200008 /* jr $25 */
976 /* The format of the first PLT entry in a VxWorks executable. */
977 static const bfd_vma mips_vxworks_exec_plt0_entry
[] =
979 0x3c190000, /* lui t9, %hi(_GLOBAL_OFFSET_TABLE_) */
980 0x27390000, /* addiu t9, t9, %lo(_GLOBAL_OFFSET_TABLE_) */
981 0x8f390008, /* lw t9, 8(t9) */
982 0x00000000, /* nop */
983 0x03200008, /* jr t9 */
987 /* The format of subsequent PLT entries. */
988 static const bfd_vma mips_vxworks_exec_plt_entry
[] =
990 0x10000000, /* b .PLT_resolver */
991 0x24180000, /* li t8, <pltindex> */
992 0x3c190000, /* lui t9, %hi(<.got.plt slot>) */
993 0x27390000, /* addiu t9, t9, %lo(<.got.plt slot>) */
994 0x8f390000, /* lw t9, 0(t9) */
995 0x00000000, /* nop */
996 0x03200008, /* jr t9 */
1000 /* The format of the first PLT entry in a VxWorks shared object. */
1001 static const bfd_vma mips_vxworks_shared_plt0_entry
[] =
1003 0x8f990008, /* lw t9, 8(gp) */
1004 0x00000000, /* nop */
1005 0x03200008, /* jr t9 */
1006 0x00000000, /* nop */
1007 0x00000000, /* nop */
1008 0x00000000 /* nop */
1011 /* The format of subsequent PLT entries. */
1012 static const bfd_vma mips_vxworks_shared_plt_entry
[] =
1014 0x10000000, /* b .PLT_resolver */
1015 0x24180000 /* li t8, <pltindex> */
1018 /* microMIPS 32-bit opcode helper installer. */
1021 bfd_put_micromips_32 (const bfd
*abfd
, bfd_vma opcode
, bfd_byte
*ptr
)
1023 bfd_put_16 (abfd
, (opcode
>> 16) & 0xffff, ptr
);
1024 bfd_put_16 (abfd
, opcode
& 0xffff, ptr
+ 2);
1027 /* microMIPS 32-bit opcode helper retriever. */
1030 bfd_get_micromips_32 (const bfd
*abfd
, const bfd_byte
*ptr
)
1032 return (bfd_get_16 (abfd
, ptr
) << 16) | bfd_get_16 (abfd
, ptr
+ 2);
1035 /* Look up an entry in a MIPS ELF linker hash table. */
1037 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
1038 ((struct mips_elf_link_hash_entry *) \
1039 elf_link_hash_lookup (&(table)->root, (string), (create), \
1042 /* Traverse a MIPS ELF linker hash table. */
1044 #define mips_elf_link_hash_traverse(table, func, info) \
1045 (elf_link_hash_traverse \
1047 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
1050 /* Find the base offsets for thread-local storage in this object,
1051 for GD/LD and IE/LE respectively. */
1053 #define TP_OFFSET 0x7000
1054 #define DTP_OFFSET 0x8000
1057 dtprel_base (struct bfd_link_info
*info
)
1059 /* If tls_sec is NULL, we should have signalled an error already. */
1060 if (elf_hash_table (info
)->tls_sec
== NULL
)
1062 return elf_hash_table (info
)->tls_sec
->vma
+ DTP_OFFSET
;
1066 tprel_base (struct bfd_link_info
*info
)
1068 /* If tls_sec is NULL, we should have signalled an error already. */
1069 if (elf_hash_table (info
)->tls_sec
== NULL
)
1071 return elf_hash_table (info
)->tls_sec
->vma
+ TP_OFFSET
;
1074 /* Create an entry in a MIPS ELF linker hash table. */
1076 static struct bfd_hash_entry
*
1077 mips_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
1078 struct bfd_hash_table
*table
, const char *string
)
1080 struct mips_elf_link_hash_entry
*ret
=
1081 (struct mips_elf_link_hash_entry
*) entry
;
1083 /* Allocate the structure if it has not already been allocated by a
1086 ret
= bfd_hash_allocate (table
, sizeof (struct mips_elf_link_hash_entry
));
1088 return (struct bfd_hash_entry
*) ret
;
1090 /* Call the allocation method of the superclass. */
1091 ret
= ((struct mips_elf_link_hash_entry
*)
1092 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
1096 /* Set local fields. */
1097 memset (&ret
->esym
, 0, sizeof (EXTR
));
1098 /* We use -2 as a marker to indicate that the information has
1099 not been set. -1 means there is no associated ifd. */
1102 ret
->possibly_dynamic_relocs
= 0;
1103 ret
->fn_stub
= NULL
;
1104 ret
->call_stub
= NULL
;
1105 ret
->call_fp_stub
= NULL
;
1106 ret
->tls_ie_type
= GOT_NORMAL
;
1107 ret
->tls_gd_type
= GOT_NORMAL
;
1108 ret
->global_got_area
= GGA_NONE
;
1109 ret
->got_only_for_calls
= TRUE
;
1110 ret
->readonly_reloc
= FALSE
;
1111 ret
->has_static_relocs
= FALSE
;
1112 ret
->no_fn_stub
= FALSE
;
1113 ret
->need_fn_stub
= FALSE
;
1114 ret
->has_nonpic_branches
= FALSE
;
1115 ret
->needs_lazy_stub
= FALSE
;
1118 return (struct bfd_hash_entry
*) ret
;
1121 /* Allocate MIPS ELF private object data. */
1124 _bfd_mips_elf_mkobject (bfd
*abfd
)
1126 return bfd_elf_allocate_object (abfd
, sizeof (struct mips_elf_obj_tdata
),
1131 _bfd_mips_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
1133 if (!sec
->used_by_bfd
)
1135 struct _mips_elf_section_data
*sdata
;
1136 bfd_size_type amt
= sizeof (*sdata
);
1138 sdata
= bfd_zalloc (abfd
, amt
);
1141 sec
->used_by_bfd
= sdata
;
1144 return _bfd_elf_new_section_hook (abfd
, sec
);
1147 /* Read ECOFF debugging information from a .mdebug section into a
1148 ecoff_debug_info structure. */
1151 _bfd_mips_elf_read_ecoff_info (bfd
*abfd
, asection
*section
,
1152 struct ecoff_debug_info
*debug
)
1155 const struct ecoff_debug_swap
*swap
;
1158 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
1159 memset (debug
, 0, sizeof (*debug
));
1161 ext_hdr
= bfd_malloc (swap
->external_hdr_size
);
1162 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
1165 if (! bfd_get_section_contents (abfd
, section
, ext_hdr
, 0,
1166 swap
->external_hdr_size
))
1169 symhdr
= &debug
->symbolic_header
;
1170 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
1172 /* The symbolic header contains absolute file offsets and sizes to
1174 #define READ(ptr, offset, count, size, type) \
1175 if (symhdr->count == 0) \
1176 debug->ptr = NULL; \
1179 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
1180 debug->ptr = bfd_malloc (amt); \
1181 if (debug->ptr == NULL) \
1182 goto error_return; \
1183 if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0 \
1184 || bfd_bread (debug->ptr, amt, abfd) != amt) \
1185 goto error_return; \
1188 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
1189 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, void *);
1190 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, void *);
1191 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, void *);
1192 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, void *);
1193 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
1195 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
1196 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
1197 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, void *);
1198 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, void *);
1199 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, void *);
1207 if (ext_hdr
!= NULL
)
1209 if (debug
->line
!= NULL
)
1211 if (debug
->external_dnr
!= NULL
)
1212 free (debug
->external_dnr
);
1213 if (debug
->external_pdr
!= NULL
)
1214 free (debug
->external_pdr
);
1215 if (debug
->external_sym
!= NULL
)
1216 free (debug
->external_sym
);
1217 if (debug
->external_opt
!= NULL
)
1218 free (debug
->external_opt
);
1219 if (debug
->external_aux
!= NULL
)
1220 free (debug
->external_aux
);
1221 if (debug
->ss
!= NULL
)
1223 if (debug
->ssext
!= NULL
)
1224 free (debug
->ssext
);
1225 if (debug
->external_fdr
!= NULL
)
1226 free (debug
->external_fdr
);
1227 if (debug
->external_rfd
!= NULL
)
1228 free (debug
->external_rfd
);
1229 if (debug
->external_ext
!= NULL
)
1230 free (debug
->external_ext
);
1234 /* Swap RPDR (runtime procedure table entry) for output. */
1237 ecoff_swap_rpdr_out (bfd
*abfd
, const RPDR
*in
, struct rpdr_ext
*ex
)
1239 H_PUT_S32 (abfd
, in
->adr
, ex
->p_adr
);
1240 H_PUT_32 (abfd
, in
->regmask
, ex
->p_regmask
);
1241 H_PUT_32 (abfd
, in
->regoffset
, ex
->p_regoffset
);
1242 H_PUT_32 (abfd
, in
->fregmask
, ex
->p_fregmask
);
1243 H_PUT_32 (abfd
, in
->fregoffset
, ex
->p_fregoffset
);
1244 H_PUT_32 (abfd
, in
->frameoffset
, ex
->p_frameoffset
);
1246 H_PUT_16 (abfd
, in
->framereg
, ex
->p_framereg
);
1247 H_PUT_16 (abfd
, in
->pcreg
, ex
->p_pcreg
);
1249 H_PUT_32 (abfd
, in
->irpss
, ex
->p_irpss
);
1252 /* Create a runtime procedure table from the .mdebug section. */
1255 mips_elf_create_procedure_table (void *handle
, bfd
*abfd
,
1256 struct bfd_link_info
*info
, asection
*s
,
1257 struct ecoff_debug_info
*debug
)
1259 const struct ecoff_debug_swap
*swap
;
1260 HDRR
*hdr
= &debug
->symbolic_header
;
1262 struct rpdr_ext
*erp
;
1264 struct pdr_ext
*epdr
;
1265 struct sym_ext
*esym
;
1269 bfd_size_type count
;
1270 unsigned long sindex
;
1274 const char *no_name_func
= _("static procedure (no name)");
1282 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
1284 sindex
= strlen (no_name_func
) + 1;
1285 count
= hdr
->ipdMax
;
1288 size
= swap
->external_pdr_size
;
1290 epdr
= bfd_malloc (size
* count
);
1294 if (! _bfd_ecoff_get_accumulated_pdr (handle
, (bfd_byte
*) epdr
))
1297 size
= sizeof (RPDR
);
1298 rp
= rpdr
= bfd_malloc (size
* count
);
1302 size
= sizeof (char *);
1303 sv
= bfd_malloc (size
* count
);
1307 count
= hdr
->isymMax
;
1308 size
= swap
->external_sym_size
;
1309 esym
= bfd_malloc (size
* count
);
1313 if (! _bfd_ecoff_get_accumulated_sym (handle
, (bfd_byte
*) esym
))
1316 count
= hdr
->issMax
;
1317 ss
= bfd_malloc (count
);
1320 if (! _bfd_ecoff_get_accumulated_ss (handle
, (bfd_byte
*) ss
))
1323 count
= hdr
->ipdMax
;
1324 for (i
= 0; i
< (unsigned long) count
; i
++, rp
++)
1326 (*swap
->swap_pdr_in
) (abfd
, epdr
+ i
, &pdr
);
1327 (*swap
->swap_sym_in
) (abfd
, &esym
[pdr
.isym
], &sym
);
1328 rp
->adr
= sym
.value
;
1329 rp
->regmask
= pdr
.regmask
;
1330 rp
->regoffset
= pdr
.regoffset
;
1331 rp
->fregmask
= pdr
.fregmask
;
1332 rp
->fregoffset
= pdr
.fregoffset
;
1333 rp
->frameoffset
= pdr
.frameoffset
;
1334 rp
->framereg
= pdr
.framereg
;
1335 rp
->pcreg
= pdr
.pcreg
;
1337 sv
[i
] = ss
+ sym
.iss
;
1338 sindex
+= strlen (sv
[i
]) + 1;
1342 size
= sizeof (struct rpdr_ext
) * (count
+ 2) + sindex
;
1343 size
= BFD_ALIGN (size
, 16);
1344 rtproc
= bfd_alloc (abfd
, size
);
1347 mips_elf_hash_table (info
)->procedure_count
= 0;
1351 mips_elf_hash_table (info
)->procedure_count
= count
+ 2;
1354 memset (erp
, 0, sizeof (struct rpdr_ext
));
1356 str
= (char *) rtproc
+ sizeof (struct rpdr_ext
) * (count
+ 2);
1357 strcpy (str
, no_name_func
);
1358 str
+= strlen (no_name_func
) + 1;
1359 for (i
= 0; i
< count
; i
++)
1361 ecoff_swap_rpdr_out (abfd
, rpdr
+ i
, erp
+ i
);
1362 strcpy (str
, sv
[i
]);
1363 str
+= strlen (sv
[i
]) + 1;
1365 H_PUT_S32 (abfd
, -1, (erp
+ count
)->p_adr
);
1367 /* Set the size and contents of .rtproc section. */
1369 s
->contents
= rtproc
;
1371 /* Skip this section later on (I don't think this currently
1372 matters, but someday it might). */
1373 s
->map_head
.link_order
= NULL
;
1402 /* We're going to create a stub for H. Create a symbol for the stub's
1403 value and size, to help make the disassembly easier to read. */
1406 mips_elf_create_stub_symbol (struct bfd_link_info
*info
,
1407 struct mips_elf_link_hash_entry
*h
,
1408 const char *prefix
, asection
*s
, bfd_vma value
,
1411 struct bfd_link_hash_entry
*bh
;
1412 struct elf_link_hash_entry
*elfh
;
1415 if (ELF_ST_IS_MICROMIPS (h
->root
.other
))
1418 /* Create a new symbol. */
1419 name
= ACONCAT ((prefix
, h
->root
.root
.root
.string
, NULL
));
1421 if (!_bfd_generic_link_add_one_symbol (info
, s
->owner
, name
,
1422 BSF_LOCAL
, s
, value
, NULL
,
1426 /* Make it a local function. */
1427 elfh
= (struct elf_link_hash_entry
*) bh
;
1428 elfh
->type
= ELF_ST_INFO (STB_LOCAL
, STT_FUNC
);
1430 elfh
->forced_local
= 1;
1434 /* We're about to redefine H. Create a symbol to represent H's
1435 current value and size, to help make the disassembly easier
1439 mips_elf_create_shadow_symbol (struct bfd_link_info
*info
,
1440 struct mips_elf_link_hash_entry
*h
,
1443 struct bfd_link_hash_entry
*bh
;
1444 struct elf_link_hash_entry
*elfh
;
1449 /* Read the symbol's value. */
1450 BFD_ASSERT (h
->root
.root
.type
== bfd_link_hash_defined
1451 || h
->root
.root
.type
== bfd_link_hash_defweak
);
1452 s
= h
->root
.root
.u
.def
.section
;
1453 value
= h
->root
.root
.u
.def
.value
;
1455 /* Create a new symbol. */
1456 name
= ACONCAT ((prefix
, h
->root
.root
.root
.string
, NULL
));
1458 if (!_bfd_generic_link_add_one_symbol (info
, s
->owner
, name
,
1459 BSF_LOCAL
, s
, value
, NULL
,
1463 /* Make it local and copy the other attributes from H. */
1464 elfh
= (struct elf_link_hash_entry
*) bh
;
1465 elfh
->type
= ELF_ST_INFO (STB_LOCAL
, ELF_ST_TYPE (h
->root
.type
));
1466 elfh
->other
= h
->root
.other
;
1467 elfh
->size
= h
->root
.size
;
1468 elfh
->forced_local
= 1;
1472 /* Return TRUE if relocations in SECTION can refer directly to a MIPS16
1473 function rather than to a hard-float stub. */
1476 section_allows_mips16_refs_p (asection
*section
)
1480 name
= bfd_get_section_name (section
->owner
, section
);
1481 return (FN_STUB_P (name
)
1482 || CALL_STUB_P (name
)
1483 || CALL_FP_STUB_P (name
)
1484 || strcmp (name
, ".pdr") == 0);
1487 /* [RELOCS, RELEND) are the relocations against SEC, which is a MIPS16
1488 stub section of some kind. Return the R_SYMNDX of the target
1489 function, or 0 if we can't decide which function that is. */
1491 static unsigned long
1492 mips16_stub_symndx (const struct elf_backend_data
*bed
,
1493 asection
*sec ATTRIBUTE_UNUSED
,
1494 const Elf_Internal_Rela
*relocs
,
1495 const Elf_Internal_Rela
*relend
)
1497 int int_rels_per_ext_rel
= bed
->s
->int_rels_per_ext_rel
;
1498 const Elf_Internal_Rela
*rel
;
1500 /* Trust the first R_MIPS_NONE relocation, if any, but not a subsequent
1501 one in a compound relocation. */
1502 for (rel
= relocs
; rel
< relend
; rel
+= int_rels_per_ext_rel
)
1503 if (ELF_R_TYPE (sec
->owner
, rel
->r_info
) == R_MIPS_NONE
)
1504 return ELF_R_SYM (sec
->owner
, rel
->r_info
);
1506 /* Otherwise trust the first relocation, whatever its kind. This is
1507 the traditional behavior. */
1508 if (relocs
< relend
)
1509 return ELF_R_SYM (sec
->owner
, relocs
->r_info
);
1514 /* Check the mips16 stubs for a particular symbol, and see if we can
1518 mips_elf_check_mips16_stubs (struct bfd_link_info
*info
,
1519 struct mips_elf_link_hash_entry
*h
)
1521 /* Dynamic symbols must use the standard call interface, in case other
1522 objects try to call them. */
1523 if (h
->fn_stub
!= NULL
1524 && h
->root
.dynindx
!= -1)
1526 mips_elf_create_shadow_symbol (info
, h
, ".mips16.");
1527 h
->need_fn_stub
= TRUE
;
1530 if (h
->fn_stub
!= NULL
1531 && ! h
->need_fn_stub
)
1533 /* We don't need the fn_stub; the only references to this symbol
1534 are 16 bit calls. Clobber the size to 0 to prevent it from
1535 being included in the link. */
1536 h
->fn_stub
->size
= 0;
1537 h
->fn_stub
->flags
&= ~SEC_RELOC
;
1538 h
->fn_stub
->reloc_count
= 0;
1539 h
->fn_stub
->flags
|= SEC_EXCLUDE
;
1542 if (h
->call_stub
!= NULL
1543 && ELF_ST_IS_MIPS16 (h
->root
.other
))
1545 /* We don't need the call_stub; this is a 16 bit function, so
1546 calls from other 16 bit functions are OK. Clobber the size
1547 to 0 to prevent it from being included in the link. */
1548 h
->call_stub
->size
= 0;
1549 h
->call_stub
->flags
&= ~SEC_RELOC
;
1550 h
->call_stub
->reloc_count
= 0;
1551 h
->call_stub
->flags
|= SEC_EXCLUDE
;
1554 if (h
->call_fp_stub
!= NULL
1555 && ELF_ST_IS_MIPS16 (h
->root
.other
))
1557 /* We don't need the call_stub; this is a 16 bit function, so
1558 calls from other 16 bit functions are OK. Clobber the size
1559 to 0 to prevent it from being included in the link. */
1560 h
->call_fp_stub
->size
= 0;
1561 h
->call_fp_stub
->flags
&= ~SEC_RELOC
;
1562 h
->call_fp_stub
->reloc_count
= 0;
1563 h
->call_fp_stub
->flags
|= SEC_EXCLUDE
;
1567 /* Hashtable callbacks for mips_elf_la25_stubs. */
1570 mips_elf_la25_stub_hash (const void *entry_
)
1572 const struct mips_elf_la25_stub
*entry
;
1574 entry
= (struct mips_elf_la25_stub
*) entry_
;
1575 return entry
->h
->root
.root
.u
.def
.section
->id
1576 + entry
->h
->root
.root
.u
.def
.value
;
1580 mips_elf_la25_stub_eq (const void *entry1_
, const void *entry2_
)
1582 const struct mips_elf_la25_stub
*entry1
, *entry2
;
1584 entry1
= (struct mips_elf_la25_stub
*) entry1_
;
1585 entry2
= (struct mips_elf_la25_stub
*) entry2_
;
1586 return ((entry1
->h
->root
.root
.u
.def
.section
1587 == entry2
->h
->root
.root
.u
.def
.section
)
1588 && (entry1
->h
->root
.root
.u
.def
.value
1589 == entry2
->h
->root
.root
.u
.def
.value
));
1592 /* Called by the linker to set up the la25 stub-creation code. FN is
1593 the linker's implementation of add_stub_function. Return true on
1597 _bfd_mips_elf_init_stubs (struct bfd_link_info
*info
,
1598 asection
*(*fn
) (const char *, asection
*,
1601 struct mips_elf_link_hash_table
*htab
;
1603 htab
= mips_elf_hash_table (info
);
1607 htab
->add_stub_section
= fn
;
1608 htab
->la25_stubs
= htab_try_create (1, mips_elf_la25_stub_hash
,
1609 mips_elf_la25_stub_eq
, NULL
);
1610 if (htab
->la25_stubs
== NULL
)
1616 /* Return true if H is a locally-defined PIC function, in the sense
1617 that it or its fn_stub might need $25 to be valid on entry.
1618 Note that MIPS16 functions set up $gp using PC-relative instructions,
1619 so they themselves never need $25 to be valid. Only non-MIPS16
1620 entry points are of interest here. */
1623 mips_elf_local_pic_function_p (struct mips_elf_link_hash_entry
*h
)
1625 return ((h
->root
.root
.type
== bfd_link_hash_defined
1626 || h
->root
.root
.type
== bfd_link_hash_defweak
)
1627 && h
->root
.def_regular
1628 && !bfd_is_abs_section (h
->root
.root
.u
.def
.section
)
1629 && (!ELF_ST_IS_MIPS16 (h
->root
.other
)
1630 || (h
->fn_stub
&& h
->need_fn_stub
))
1631 && (PIC_OBJECT_P (h
->root
.root
.u
.def
.section
->owner
)
1632 || ELF_ST_IS_MIPS_PIC (h
->root
.other
)));
1635 /* Set *SEC to the input section that contains the target of STUB.
1636 Return the offset of the target from the start of that section. */
1639 mips_elf_get_la25_target (struct mips_elf_la25_stub
*stub
,
1642 if (ELF_ST_IS_MIPS16 (stub
->h
->root
.other
))
1644 BFD_ASSERT (stub
->h
->need_fn_stub
);
1645 *sec
= stub
->h
->fn_stub
;
1650 *sec
= stub
->h
->root
.root
.u
.def
.section
;
1651 return stub
->h
->root
.root
.u
.def
.value
;
1655 /* STUB describes an la25 stub that we have decided to implement
1656 by inserting an LUI/ADDIU pair before the target function.
1657 Create the section and redirect the function symbol to it. */
1660 mips_elf_add_la25_intro (struct mips_elf_la25_stub
*stub
,
1661 struct bfd_link_info
*info
)
1663 struct mips_elf_link_hash_table
*htab
;
1665 asection
*s
, *input_section
;
1668 htab
= mips_elf_hash_table (info
);
1672 /* Create a unique name for the new section. */
1673 name
= bfd_malloc (11 + sizeof (".text.stub."));
1676 sprintf (name
, ".text.stub.%d", (int) htab_elements (htab
->la25_stubs
));
1678 /* Create the section. */
1679 mips_elf_get_la25_target (stub
, &input_section
);
1680 s
= htab
->add_stub_section (name
, input_section
,
1681 input_section
->output_section
);
1685 /* Make sure that any padding goes before the stub. */
1686 align
= input_section
->alignment_power
;
1687 if (!bfd_set_section_alignment (s
->owner
, s
, align
))
1690 s
->size
= (1 << align
) - 8;
1692 /* Create a symbol for the stub. */
1693 mips_elf_create_stub_symbol (info
, stub
->h
, ".pic.", s
, s
->size
, 8);
1694 stub
->stub_section
= s
;
1695 stub
->offset
= s
->size
;
1697 /* Allocate room for it. */
1702 /* STUB describes an la25 stub that we have decided to implement
1703 with a separate trampoline. Allocate room for it and redirect
1704 the function symbol to it. */
1707 mips_elf_add_la25_trampoline (struct mips_elf_la25_stub
*stub
,
1708 struct bfd_link_info
*info
)
1710 struct mips_elf_link_hash_table
*htab
;
1713 htab
= mips_elf_hash_table (info
);
1717 /* Create a trampoline section, if we haven't already. */
1718 s
= htab
->strampoline
;
1721 asection
*input_section
= stub
->h
->root
.root
.u
.def
.section
;
1722 s
= htab
->add_stub_section (".text", NULL
,
1723 input_section
->output_section
);
1724 if (s
== NULL
|| !bfd_set_section_alignment (s
->owner
, s
, 4))
1726 htab
->strampoline
= s
;
1729 /* Create a symbol for the stub. */
1730 mips_elf_create_stub_symbol (info
, stub
->h
, ".pic.", s
, s
->size
, 16);
1731 stub
->stub_section
= s
;
1732 stub
->offset
= s
->size
;
1734 /* Allocate room for it. */
1739 /* H describes a symbol that needs an la25 stub. Make sure that an
1740 appropriate stub exists and point H at it. */
1743 mips_elf_add_la25_stub (struct bfd_link_info
*info
,
1744 struct mips_elf_link_hash_entry
*h
)
1746 struct mips_elf_link_hash_table
*htab
;
1747 struct mips_elf_la25_stub search
, *stub
;
1748 bfd_boolean use_trampoline_p
;
1753 /* Describe the stub we want. */
1754 search
.stub_section
= NULL
;
1758 /* See if we've already created an equivalent stub. */
1759 htab
= mips_elf_hash_table (info
);
1763 slot
= htab_find_slot (htab
->la25_stubs
, &search
, INSERT
);
1767 stub
= (struct mips_elf_la25_stub
*) *slot
;
1770 /* We can reuse the existing stub. */
1771 h
->la25_stub
= stub
;
1775 /* Create a permanent copy of ENTRY and add it to the hash table. */
1776 stub
= bfd_malloc (sizeof (search
));
1782 /* Prefer to use LUI/ADDIU stubs if the function is at the beginning
1783 of the section and if we would need no more than 2 nops. */
1784 value
= mips_elf_get_la25_target (stub
, &s
);
1785 use_trampoline_p
= (value
!= 0 || s
->alignment_power
> 4);
1787 h
->la25_stub
= stub
;
1788 return (use_trampoline_p
1789 ? mips_elf_add_la25_trampoline (stub
, info
)
1790 : mips_elf_add_la25_intro (stub
, info
));
1793 /* A mips_elf_link_hash_traverse callback that is called before sizing
1794 sections. DATA points to a mips_htab_traverse_info structure. */
1797 mips_elf_check_symbols (struct mips_elf_link_hash_entry
*h
, void *data
)
1799 struct mips_htab_traverse_info
*hti
;
1801 hti
= (struct mips_htab_traverse_info
*) data
;
1802 if (!hti
->info
->relocatable
)
1803 mips_elf_check_mips16_stubs (hti
->info
, h
);
1805 if (mips_elf_local_pic_function_p (h
))
1807 /* PR 12845: If H is in a section that has been garbage
1808 collected it will have its output section set to *ABS*. */
1809 if (bfd_is_abs_section (h
->root
.root
.u
.def
.section
->output_section
))
1812 /* H is a function that might need $25 to be valid on entry.
1813 If we're creating a non-PIC relocatable object, mark H as
1814 being PIC. If we're creating a non-relocatable object with
1815 non-PIC branches and jumps to H, make sure that H has an la25
1817 if (hti
->info
->relocatable
)
1819 if (!PIC_OBJECT_P (hti
->output_bfd
))
1820 h
->root
.other
= ELF_ST_SET_MIPS_PIC (h
->root
.other
);
1822 else if (h
->has_nonpic_branches
&& !mips_elf_add_la25_stub (hti
->info
, h
))
1831 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
1832 Most mips16 instructions are 16 bits, but these instructions
1835 The format of these instructions is:
1837 +--------------+--------------------------------+
1838 | JALX | X| Imm 20:16 | Imm 25:21 |
1839 +--------------+--------------------------------+
1841 +-----------------------------------------------+
1843 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
1844 Note that the immediate value in the first word is swapped.
1846 When producing a relocatable object file, R_MIPS16_26 is
1847 handled mostly like R_MIPS_26. In particular, the addend is
1848 stored as a straight 26-bit value in a 32-bit instruction.
1849 (gas makes life simpler for itself by never adjusting a
1850 R_MIPS16_26 reloc to be against a section, so the addend is
1851 always zero). However, the 32 bit instruction is stored as 2
1852 16-bit values, rather than a single 32-bit value. In a
1853 big-endian file, the result is the same; in a little-endian
1854 file, the two 16-bit halves of the 32 bit value are swapped.
1855 This is so that a disassembler can recognize the jal
1858 When doing a final link, R_MIPS16_26 is treated as a 32 bit
1859 instruction stored as two 16-bit values. The addend A is the
1860 contents of the targ26 field. The calculation is the same as
1861 R_MIPS_26. When storing the calculated value, reorder the
1862 immediate value as shown above, and don't forget to store the
1863 value as two 16-bit values.
1865 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
1869 +--------+----------------------+
1873 +--------+----------------------+
1876 +----------+------+-------------+
1880 +----------+--------------------+
1881 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
1882 ((sub1 << 16) | sub2)).
1884 When producing a relocatable object file, the calculation is
1885 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1886 When producing a fully linked file, the calculation is
1887 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1888 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)
1890 The table below lists the other MIPS16 instruction relocations.
1891 Each one is calculated in the same way as the non-MIPS16 relocation
1892 given on the right, but using the extended MIPS16 layout of 16-bit
1895 R_MIPS16_GPREL R_MIPS_GPREL16
1896 R_MIPS16_GOT16 R_MIPS_GOT16
1897 R_MIPS16_CALL16 R_MIPS_CALL16
1898 R_MIPS16_HI16 R_MIPS_HI16
1899 R_MIPS16_LO16 R_MIPS_LO16
1901 A typical instruction will have a format like this:
1903 +--------------+--------------------------------+
1904 | EXTEND | Imm 10:5 | Imm 15:11 |
1905 +--------------+--------------------------------+
1906 | Major | rx | ry | Imm 4:0 |
1907 +--------------+--------------------------------+
1909 EXTEND is the five bit value 11110. Major is the instruction
1912 All we need to do here is shuffle the bits appropriately.
1913 As above, the two 16-bit halves must be swapped on a
1914 little-endian system. */
1916 static inline bfd_boolean
1917 mips16_reloc_p (int r_type
)
1922 case R_MIPS16_GPREL
:
1923 case R_MIPS16_GOT16
:
1924 case R_MIPS16_CALL16
:
1927 case R_MIPS16_TLS_GD
:
1928 case R_MIPS16_TLS_LDM
:
1929 case R_MIPS16_TLS_DTPREL_HI16
:
1930 case R_MIPS16_TLS_DTPREL_LO16
:
1931 case R_MIPS16_TLS_GOTTPREL
:
1932 case R_MIPS16_TLS_TPREL_HI16
:
1933 case R_MIPS16_TLS_TPREL_LO16
:
1941 /* Check if a microMIPS reloc. */
1943 static inline bfd_boolean
1944 micromips_reloc_p (unsigned int r_type
)
1946 return r_type
>= R_MICROMIPS_min
&& r_type
< R_MICROMIPS_max
;
1949 /* Similar to MIPS16, the two 16-bit halves in microMIPS must be swapped
1950 on a little-endian system. This does not apply to R_MICROMIPS_PC7_S1
1951 and R_MICROMIPS_PC10_S1 relocs that apply to 16-bit instructions. */
1953 static inline bfd_boolean
1954 micromips_reloc_shuffle_p (unsigned int r_type
)
1956 return (micromips_reloc_p (r_type
)
1957 && r_type
!= R_MICROMIPS_PC7_S1
1958 && r_type
!= R_MICROMIPS_PC10_S1
);
1961 static inline bfd_boolean
1962 got16_reloc_p (int r_type
)
1964 return (r_type
== R_MIPS_GOT16
1965 || r_type
== R_MIPS16_GOT16
1966 || r_type
== R_MICROMIPS_GOT16
);
1969 static inline bfd_boolean
1970 call16_reloc_p (int r_type
)
1972 return (r_type
== R_MIPS_CALL16
1973 || r_type
== R_MIPS16_CALL16
1974 || r_type
== R_MICROMIPS_CALL16
);
1977 static inline bfd_boolean
1978 got_disp_reloc_p (unsigned int r_type
)
1980 return r_type
== R_MIPS_GOT_DISP
|| r_type
== R_MICROMIPS_GOT_DISP
;
1983 static inline bfd_boolean
1984 got_page_reloc_p (unsigned int r_type
)
1986 return r_type
== R_MIPS_GOT_PAGE
|| r_type
== R_MICROMIPS_GOT_PAGE
;
1989 static inline bfd_boolean
1990 got_ofst_reloc_p (unsigned int r_type
)
1992 return r_type
== R_MIPS_GOT_OFST
|| r_type
== R_MICROMIPS_GOT_OFST
;
1995 static inline bfd_boolean
1996 got_hi16_reloc_p (unsigned int r_type
)
1998 return r_type
== R_MIPS_GOT_HI16
|| r_type
== R_MICROMIPS_GOT_HI16
;
2001 static inline bfd_boolean
2002 got_lo16_reloc_p (unsigned int r_type
)
2004 return r_type
== R_MIPS_GOT_LO16
|| r_type
== R_MICROMIPS_GOT_LO16
;
2007 static inline bfd_boolean
2008 call_hi16_reloc_p (unsigned int r_type
)
2010 return r_type
== R_MIPS_CALL_HI16
|| r_type
== R_MICROMIPS_CALL_HI16
;
2013 static inline bfd_boolean
2014 call_lo16_reloc_p (unsigned int r_type
)
2016 return r_type
== R_MIPS_CALL_LO16
|| r_type
== R_MICROMIPS_CALL_LO16
;
2019 static inline bfd_boolean
2020 hi16_reloc_p (int r_type
)
2022 return (r_type
== R_MIPS_HI16
2023 || r_type
== R_MIPS16_HI16
2024 || r_type
== R_MICROMIPS_HI16
);
2027 static inline bfd_boolean
2028 lo16_reloc_p (int r_type
)
2030 return (r_type
== R_MIPS_LO16
2031 || r_type
== R_MIPS16_LO16
2032 || r_type
== R_MICROMIPS_LO16
);
2035 static inline bfd_boolean
2036 mips16_call_reloc_p (int r_type
)
2038 return r_type
== R_MIPS16_26
|| r_type
== R_MIPS16_CALL16
;
2041 static inline bfd_boolean
2042 jal_reloc_p (int r_type
)
2044 return (r_type
== R_MIPS_26
2045 || r_type
== R_MIPS16_26
2046 || r_type
== R_MICROMIPS_26_S1
);
2049 static inline bfd_boolean
2050 micromips_branch_reloc_p (int r_type
)
2052 return (r_type
== R_MICROMIPS_26_S1
2053 || r_type
== R_MICROMIPS_PC16_S1
2054 || r_type
== R_MICROMIPS_PC10_S1
2055 || r_type
== R_MICROMIPS_PC7_S1
);
2058 static inline bfd_boolean
2059 tls_gd_reloc_p (unsigned int r_type
)
2061 return (r_type
== R_MIPS_TLS_GD
2062 || r_type
== R_MIPS16_TLS_GD
2063 || r_type
== R_MICROMIPS_TLS_GD
);
2066 static inline bfd_boolean
2067 tls_ldm_reloc_p (unsigned int r_type
)
2069 return (r_type
== R_MIPS_TLS_LDM
2070 || r_type
== R_MIPS16_TLS_LDM
2071 || r_type
== R_MICROMIPS_TLS_LDM
);
2074 static inline bfd_boolean
2075 tls_gottprel_reloc_p (unsigned int r_type
)
2077 return (r_type
== R_MIPS_TLS_GOTTPREL
2078 || r_type
== R_MIPS16_TLS_GOTTPREL
2079 || r_type
== R_MICROMIPS_TLS_GOTTPREL
);
2083 _bfd_mips_elf_reloc_unshuffle (bfd
*abfd
, int r_type
,
2084 bfd_boolean jal_shuffle
, bfd_byte
*data
)
2086 bfd_vma first
, second
, val
;
2088 if (!mips16_reloc_p (r_type
) && !micromips_reloc_shuffle_p (r_type
))
2091 /* Pick up the first and second halfwords of the instruction. */
2092 first
= bfd_get_16 (abfd
, data
);
2093 second
= bfd_get_16 (abfd
, data
+ 2);
2094 if (micromips_reloc_p (r_type
) || (r_type
== R_MIPS16_26
&& !jal_shuffle
))
2095 val
= first
<< 16 | second
;
2096 else if (r_type
!= R_MIPS16_26
)
2097 val
= (((first
& 0xf800) << 16) | ((second
& 0xffe0) << 11)
2098 | ((first
& 0x1f) << 11) | (first
& 0x7e0) | (second
& 0x1f));
2100 val
= (((first
& 0xfc00) << 16) | ((first
& 0x3e0) << 11)
2101 | ((first
& 0x1f) << 21) | second
);
2102 bfd_put_32 (abfd
, val
, data
);
2106 _bfd_mips_elf_reloc_shuffle (bfd
*abfd
, int r_type
,
2107 bfd_boolean jal_shuffle
, bfd_byte
*data
)
2109 bfd_vma first
, second
, val
;
2111 if (!mips16_reloc_p (r_type
) && !micromips_reloc_shuffle_p (r_type
))
2114 val
= bfd_get_32 (abfd
, data
);
2115 if (micromips_reloc_p (r_type
) || (r_type
== R_MIPS16_26
&& !jal_shuffle
))
2117 second
= val
& 0xffff;
2120 else if (r_type
!= R_MIPS16_26
)
2122 second
= ((val
>> 11) & 0xffe0) | (val
& 0x1f);
2123 first
= ((val
>> 16) & 0xf800) | ((val
>> 11) & 0x1f) | (val
& 0x7e0);
2127 second
= val
& 0xffff;
2128 first
= ((val
>> 16) & 0xfc00) | ((val
>> 11) & 0x3e0)
2129 | ((val
>> 21) & 0x1f);
2131 bfd_put_16 (abfd
, second
, data
+ 2);
2132 bfd_put_16 (abfd
, first
, data
);
2135 bfd_reloc_status_type
2136 _bfd_mips_elf_gprel16_with_gp (bfd
*abfd
, asymbol
*symbol
,
2137 arelent
*reloc_entry
, asection
*input_section
,
2138 bfd_boolean relocatable
, void *data
, bfd_vma gp
)
2142 bfd_reloc_status_type status
;
2144 if (bfd_is_com_section (symbol
->section
))
2147 relocation
= symbol
->value
;
2149 relocation
+= symbol
->section
->output_section
->vma
;
2150 relocation
+= symbol
->section
->output_offset
;
2152 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
2153 return bfd_reloc_outofrange
;
2155 /* Set val to the offset into the section or symbol. */
2156 val
= reloc_entry
->addend
;
2158 _bfd_mips_elf_sign_extend (val
, 16);
2160 /* Adjust val for the final section location and GP value. If we
2161 are producing relocatable output, we don't want to do this for
2162 an external symbol. */
2164 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
2165 val
+= relocation
- gp
;
2167 if (reloc_entry
->howto
->partial_inplace
)
2169 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
2171 + reloc_entry
->address
);
2172 if (status
!= bfd_reloc_ok
)
2176 reloc_entry
->addend
= val
;
2179 reloc_entry
->address
+= input_section
->output_offset
;
2181 return bfd_reloc_ok
;
2184 /* Used to store a REL high-part relocation such as R_MIPS_HI16 or
2185 R_MIPS_GOT16. REL is the relocation, INPUT_SECTION is the section
2186 that contains the relocation field and DATA points to the start of
2191 struct mips_hi16
*next
;
2193 asection
*input_section
;
2197 /* FIXME: This should not be a static variable. */
2199 static struct mips_hi16
*mips_hi16_list
;
2201 /* A howto special_function for REL *HI16 relocations. We can only
2202 calculate the correct value once we've seen the partnering
2203 *LO16 relocation, so just save the information for later.
2205 The ABI requires that the *LO16 immediately follow the *HI16.
2206 However, as a GNU extension, we permit an arbitrary number of
2207 *HI16s to be associated with a single *LO16. This significantly
2208 simplies the relocation handling in gcc. */
2210 bfd_reloc_status_type
2211 _bfd_mips_elf_hi16_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
2212 asymbol
*symbol ATTRIBUTE_UNUSED
, void *data
,
2213 asection
*input_section
, bfd
*output_bfd
,
2214 char **error_message ATTRIBUTE_UNUSED
)
2216 struct mips_hi16
*n
;
2218 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
2219 return bfd_reloc_outofrange
;
2221 n
= bfd_malloc (sizeof *n
);
2223 return bfd_reloc_outofrange
;
2225 n
->next
= mips_hi16_list
;
2227 n
->input_section
= input_section
;
2228 n
->rel
= *reloc_entry
;
2231 if (output_bfd
!= NULL
)
2232 reloc_entry
->address
+= input_section
->output_offset
;
2234 return bfd_reloc_ok
;
2237 /* A howto special_function for REL R_MIPS*_GOT16 relocations. This is just
2238 like any other 16-bit relocation when applied to global symbols, but is
2239 treated in the same as R_MIPS_HI16 when applied to local symbols. */
2241 bfd_reloc_status_type
2242 _bfd_mips_elf_got16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
2243 void *data
, asection
*input_section
,
2244 bfd
*output_bfd
, char **error_message
)
2246 if ((symbol
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
2247 || bfd_is_und_section (bfd_get_section (symbol
))
2248 || bfd_is_com_section (bfd_get_section (symbol
)))
2249 /* The relocation is against a global symbol. */
2250 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
2251 input_section
, output_bfd
,
2254 return _bfd_mips_elf_hi16_reloc (abfd
, reloc_entry
, symbol
, data
,
2255 input_section
, output_bfd
, error_message
);
2258 /* A howto special_function for REL *LO16 relocations. The *LO16 itself
2259 is a straightforward 16 bit inplace relocation, but we must deal with
2260 any partnering high-part relocations as well. */
2262 bfd_reloc_status_type
2263 _bfd_mips_elf_lo16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
2264 void *data
, asection
*input_section
,
2265 bfd
*output_bfd
, char **error_message
)
2268 bfd_byte
*location
= (bfd_byte
*) data
+ reloc_entry
->address
;
2270 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
2271 return bfd_reloc_outofrange
;
2273 _bfd_mips_elf_reloc_unshuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
2275 vallo
= bfd_get_32 (abfd
, location
);
2276 _bfd_mips_elf_reloc_shuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
2279 while (mips_hi16_list
!= NULL
)
2281 bfd_reloc_status_type ret
;
2282 struct mips_hi16
*hi
;
2284 hi
= mips_hi16_list
;
2286 /* R_MIPS*_GOT16 relocations are something of a special case. We
2287 want to install the addend in the same way as for a R_MIPS*_HI16
2288 relocation (with a rightshift of 16). However, since GOT16
2289 relocations can also be used with global symbols, their howto
2290 has a rightshift of 0. */
2291 if (hi
->rel
.howto
->type
== R_MIPS_GOT16
)
2292 hi
->rel
.howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, R_MIPS_HI16
, FALSE
);
2293 else if (hi
->rel
.howto
->type
== R_MIPS16_GOT16
)
2294 hi
->rel
.howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, R_MIPS16_HI16
, FALSE
);
2295 else if (hi
->rel
.howto
->type
== R_MICROMIPS_GOT16
)
2296 hi
->rel
.howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, R_MICROMIPS_HI16
, FALSE
);
2298 /* VALLO is a signed 16-bit number. Bias it by 0x8000 so that any
2299 carry or borrow will induce a change of +1 or -1 in the high part. */
2300 hi
->rel
.addend
+= (vallo
+ 0x8000) & 0xffff;
2302 ret
= _bfd_mips_elf_generic_reloc (abfd
, &hi
->rel
, symbol
, hi
->data
,
2303 hi
->input_section
, output_bfd
,
2305 if (ret
!= bfd_reloc_ok
)
2308 mips_hi16_list
= hi
->next
;
2312 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
2313 input_section
, output_bfd
,
2317 /* A generic howto special_function. This calculates and installs the
2318 relocation itself, thus avoiding the oft-discussed problems in
2319 bfd_perform_relocation and bfd_install_relocation. */
2321 bfd_reloc_status_type
2322 _bfd_mips_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
2323 asymbol
*symbol
, void *data ATTRIBUTE_UNUSED
,
2324 asection
*input_section
, bfd
*output_bfd
,
2325 char **error_message ATTRIBUTE_UNUSED
)
2328 bfd_reloc_status_type status
;
2329 bfd_boolean relocatable
;
2331 relocatable
= (output_bfd
!= NULL
);
2333 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
2334 return bfd_reloc_outofrange
;
2336 /* Build up the field adjustment in VAL. */
2338 if (!relocatable
|| (symbol
->flags
& BSF_SECTION_SYM
) != 0)
2340 /* Either we're calculating the final field value or we have a
2341 relocation against a section symbol. Add in the section's
2342 offset or address. */
2343 val
+= symbol
->section
->output_section
->vma
;
2344 val
+= symbol
->section
->output_offset
;
2349 /* We're calculating the final field value. Add in the symbol's value
2350 and, if pc-relative, subtract the address of the field itself. */
2351 val
+= symbol
->value
;
2352 if (reloc_entry
->howto
->pc_relative
)
2354 val
-= input_section
->output_section
->vma
;
2355 val
-= input_section
->output_offset
;
2356 val
-= reloc_entry
->address
;
2360 /* VAL is now the final adjustment. If we're keeping this relocation
2361 in the output file, and if the relocation uses a separate addend,
2362 we just need to add VAL to that addend. Otherwise we need to add
2363 VAL to the relocation field itself. */
2364 if (relocatable
&& !reloc_entry
->howto
->partial_inplace
)
2365 reloc_entry
->addend
+= val
;
2368 bfd_byte
*location
= (bfd_byte
*) data
+ reloc_entry
->address
;
2370 /* Add in the separate addend, if any. */
2371 val
+= reloc_entry
->addend
;
2373 /* Add VAL to the relocation field. */
2374 _bfd_mips_elf_reloc_unshuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
2376 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
2378 _bfd_mips_elf_reloc_shuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
2381 if (status
!= bfd_reloc_ok
)
2386 reloc_entry
->address
+= input_section
->output_offset
;
2388 return bfd_reloc_ok
;
2391 /* Swap an entry in a .gptab section. Note that these routines rely
2392 on the equivalence of the two elements of the union. */
2395 bfd_mips_elf32_swap_gptab_in (bfd
*abfd
, const Elf32_External_gptab
*ex
,
2398 in
->gt_entry
.gt_g_value
= H_GET_32 (abfd
, ex
->gt_entry
.gt_g_value
);
2399 in
->gt_entry
.gt_bytes
= H_GET_32 (abfd
, ex
->gt_entry
.gt_bytes
);
2403 bfd_mips_elf32_swap_gptab_out (bfd
*abfd
, const Elf32_gptab
*in
,
2404 Elf32_External_gptab
*ex
)
2406 H_PUT_32 (abfd
, in
->gt_entry
.gt_g_value
, ex
->gt_entry
.gt_g_value
);
2407 H_PUT_32 (abfd
, in
->gt_entry
.gt_bytes
, ex
->gt_entry
.gt_bytes
);
2411 bfd_elf32_swap_compact_rel_out (bfd
*abfd
, const Elf32_compact_rel
*in
,
2412 Elf32_External_compact_rel
*ex
)
2414 H_PUT_32 (abfd
, in
->id1
, ex
->id1
);
2415 H_PUT_32 (abfd
, in
->num
, ex
->num
);
2416 H_PUT_32 (abfd
, in
->id2
, ex
->id2
);
2417 H_PUT_32 (abfd
, in
->offset
, ex
->offset
);
2418 H_PUT_32 (abfd
, in
->reserved0
, ex
->reserved0
);
2419 H_PUT_32 (abfd
, in
->reserved1
, ex
->reserved1
);
2423 bfd_elf32_swap_crinfo_out (bfd
*abfd
, const Elf32_crinfo
*in
,
2424 Elf32_External_crinfo
*ex
)
2428 l
= (((in
->ctype
& CRINFO_CTYPE
) << CRINFO_CTYPE_SH
)
2429 | ((in
->rtype
& CRINFO_RTYPE
) << CRINFO_RTYPE_SH
)
2430 | ((in
->dist2to
& CRINFO_DIST2TO
) << CRINFO_DIST2TO_SH
)
2431 | ((in
->relvaddr
& CRINFO_RELVADDR
) << CRINFO_RELVADDR_SH
));
2432 H_PUT_32 (abfd
, l
, ex
->info
);
2433 H_PUT_32 (abfd
, in
->konst
, ex
->konst
);
2434 H_PUT_32 (abfd
, in
->vaddr
, ex
->vaddr
);
2437 /* A .reginfo section holds a single Elf32_RegInfo structure. These
2438 routines swap this structure in and out. They are used outside of
2439 BFD, so they are globally visible. */
2442 bfd_mips_elf32_swap_reginfo_in (bfd
*abfd
, const Elf32_External_RegInfo
*ex
,
2445 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
2446 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
2447 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
2448 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
2449 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
2450 in
->ri_gp_value
= H_GET_32 (abfd
, ex
->ri_gp_value
);
2454 bfd_mips_elf32_swap_reginfo_out (bfd
*abfd
, const Elf32_RegInfo
*in
,
2455 Elf32_External_RegInfo
*ex
)
2457 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
2458 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
2459 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
2460 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
2461 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
2462 H_PUT_32 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
2465 /* In the 64 bit ABI, the .MIPS.options section holds register
2466 information in an Elf64_Reginfo structure. These routines swap
2467 them in and out. They are globally visible because they are used
2468 outside of BFD. These routines are here so that gas can call them
2469 without worrying about whether the 64 bit ABI has been included. */
2472 bfd_mips_elf64_swap_reginfo_in (bfd
*abfd
, const Elf64_External_RegInfo
*ex
,
2473 Elf64_Internal_RegInfo
*in
)
2475 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
2476 in
->ri_pad
= H_GET_32 (abfd
, ex
->ri_pad
);
2477 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
2478 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
2479 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
2480 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
2481 in
->ri_gp_value
= H_GET_64 (abfd
, ex
->ri_gp_value
);
2485 bfd_mips_elf64_swap_reginfo_out (bfd
*abfd
, const Elf64_Internal_RegInfo
*in
,
2486 Elf64_External_RegInfo
*ex
)
2488 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
2489 H_PUT_32 (abfd
, in
->ri_pad
, ex
->ri_pad
);
2490 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
2491 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
2492 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
2493 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
2494 H_PUT_64 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
2497 /* Swap in an options header. */
2500 bfd_mips_elf_swap_options_in (bfd
*abfd
, const Elf_External_Options
*ex
,
2501 Elf_Internal_Options
*in
)
2503 in
->kind
= H_GET_8 (abfd
, ex
->kind
);
2504 in
->size
= H_GET_8 (abfd
, ex
->size
);
2505 in
->section
= H_GET_16 (abfd
, ex
->section
);
2506 in
->info
= H_GET_32 (abfd
, ex
->info
);
2509 /* Swap out an options header. */
2512 bfd_mips_elf_swap_options_out (bfd
*abfd
, const Elf_Internal_Options
*in
,
2513 Elf_External_Options
*ex
)
2515 H_PUT_8 (abfd
, in
->kind
, ex
->kind
);
2516 H_PUT_8 (abfd
, in
->size
, ex
->size
);
2517 H_PUT_16 (abfd
, in
->section
, ex
->section
);
2518 H_PUT_32 (abfd
, in
->info
, ex
->info
);
2521 /* This function is called via qsort() to sort the dynamic relocation
2522 entries by increasing r_symndx value. */
2525 sort_dynamic_relocs (const void *arg1
, const void *arg2
)
2527 Elf_Internal_Rela int_reloc1
;
2528 Elf_Internal_Rela int_reloc2
;
2531 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg1
, &int_reloc1
);
2532 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg2
, &int_reloc2
);
2534 diff
= ELF32_R_SYM (int_reloc1
.r_info
) - ELF32_R_SYM (int_reloc2
.r_info
);
2538 if (int_reloc1
.r_offset
< int_reloc2
.r_offset
)
2540 if (int_reloc1
.r_offset
> int_reloc2
.r_offset
)
2545 /* Like sort_dynamic_relocs, but used for elf64 relocations. */
2548 sort_dynamic_relocs_64 (const void *arg1 ATTRIBUTE_UNUSED
,
2549 const void *arg2 ATTRIBUTE_UNUSED
)
2552 Elf_Internal_Rela int_reloc1
[3];
2553 Elf_Internal_Rela int_reloc2
[3];
2555 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
2556 (reldyn_sorting_bfd
, arg1
, int_reloc1
);
2557 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
2558 (reldyn_sorting_bfd
, arg2
, int_reloc2
);
2560 if (ELF64_R_SYM (int_reloc1
[0].r_info
) < ELF64_R_SYM (int_reloc2
[0].r_info
))
2562 if (ELF64_R_SYM (int_reloc1
[0].r_info
) > ELF64_R_SYM (int_reloc2
[0].r_info
))
2565 if (int_reloc1
[0].r_offset
< int_reloc2
[0].r_offset
)
2567 if (int_reloc1
[0].r_offset
> int_reloc2
[0].r_offset
)
2576 /* This routine is used to write out ECOFF debugging external symbol
2577 information. It is called via mips_elf_link_hash_traverse. The
2578 ECOFF external symbol information must match the ELF external
2579 symbol information. Unfortunately, at this point we don't know
2580 whether a symbol is required by reloc information, so the two
2581 tables may wind up being different. We must sort out the external
2582 symbol information before we can set the final size of the .mdebug
2583 section, and we must set the size of the .mdebug section before we
2584 can relocate any sections, and we can't know which symbols are
2585 required by relocation until we relocate the sections.
2586 Fortunately, it is relatively unlikely that any symbol will be
2587 stripped but required by a reloc. In particular, it can not happen
2588 when generating a final executable. */
2591 mips_elf_output_extsym (struct mips_elf_link_hash_entry
*h
, void *data
)
2593 struct extsym_info
*einfo
= data
;
2595 asection
*sec
, *output_section
;
2597 if (h
->root
.indx
== -2)
2599 else if ((h
->root
.def_dynamic
2600 || h
->root
.ref_dynamic
2601 || h
->root
.type
== bfd_link_hash_new
)
2602 && !h
->root
.def_regular
2603 && !h
->root
.ref_regular
)
2605 else if (einfo
->info
->strip
== strip_all
2606 || (einfo
->info
->strip
== strip_some
2607 && bfd_hash_lookup (einfo
->info
->keep_hash
,
2608 h
->root
.root
.root
.string
,
2609 FALSE
, FALSE
) == NULL
))
2617 if (h
->esym
.ifd
== -2)
2620 h
->esym
.cobol_main
= 0;
2621 h
->esym
.weakext
= 0;
2622 h
->esym
.reserved
= 0;
2623 h
->esym
.ifd
= ifdNil
;
2624 h
->esym
.asym
.value
= 0;
2625 h
->esym
.asym
.st
= stGlobal
;
2627 if (h
->root
.root
.type
== bfd_link_hash_undefined
2628 || h
->root
.root
.type
== bfd_link_hash_undefweak
)
2632 /* Use undefined class. Also, set class and type for some
2634 name
= h
->root
.root
.root
.string
;
2635 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
2636 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
2638 h
->esym
.asym
.sc
= scData
;
2639 h
->esym
.asym
.st
= stLabel
;
2640 h
->esym
.asym
.value
= 0;
2642 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
2644 h
->esym
.asym
.sc
= scAbs
;
2645 h
->esym
.asym
.st
= stLabel
;
2646 h
->esym
.asym
.value
=
2647 mips_elf_hash_table (einfo
->info
)->procedure_count
;
2649 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (einfo
->abfd
))
2651 h
->esym
.asym
.sc
= scAbs
;
2652 h
->esym
.asym
.st
= stLabel
;
2653 h
->esym
.asym
.value
= elf_gp (einfo
->abfd
);
2656 h
->esym
.asym
.sc
= scUndefined
;
2658 else if (h
->root
.root
.type
!= bfd_link_hash_defined
2659 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
2660 h
->esym
.asym
.sc
= scAbs
;
2665 sec
= h
->root
.root
.u
.def
.section
;
2666 output_section
= sec
->output_section
;
2668 /* When making a shared library and symbol h is the one from
2669 the another shared library, OUTPUT_SECTION may be null. */
2670 if (output_section
== NULL
)
2671 h
->esym
.asym
.sc
= scUndefined
;
2674 name
= bfd_section_name (output_section
->owner
, output_section
);
2676 if (strcmp (name
, ".text") == 0)
2677 h
->esym
.asym
.sc
= scText
;
2678 else if (strcmp (name
, ".data") == 0)
2679 h
->esym
.asym
.sc
= scData
;
2680 else if (strcmp (name
, ".sdata") == 0)
2681 h
->esym
.asym
.sc
= scSData
;
2682 else if (strcmp (name
, ".rodata") == 0
2683 || strcmp (name
, ".rdata") == 0)
2684 h
->esym
.asym
.sc
= scRData
;
2685 else if (strcmp (name
, ".bss") == 0)
2686 h
->esym
.asym
.sc
= scBss
;
2687 else if (strcmp (name
, ".sbss") == 0)
2688 h
->esym
.asym
.sc
= scSBss
;
2689 else if (strcmp (name
, ".init") == 0)
2690 h
->esym
.asym
.sc
= scInit
;
2691 else if (strcmp (name
, ".fini") == 0)
2692 h
->esym
.asym
.sc
= scFini
;
2694 h
->esym
.asym
.sc
= scAbs
;
2698 h
->esym
.asym
.reserved
= 0;
2699 h
->esym
.asym
.index
= indexNil
;
2702 if (h
->root
.root
.type
== bfd_link_hash_common
)
2703 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
2704 else if (h
->root
.root
.type
== bfd_link_hash_defined
2705 || h
->root
.root
.type
== bfd_link_hash_defweak
)
2707 if (h
->esym
.asym
.sc
== scCommon
)
2708 h
->esym
.asym
.sc
= scBss
;
2709 else if (h
->esym
.asym
.sc
== scSCommon
)
2710 h
->esym
.asym
.sc
= scSBss
;
2712 sec
= h
->root
.root
.u
.def
.section
;
2713 output_section
= sec
->output_section
;
2714 if (output_section
!= NULL
)
2715 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
2716 + sec
->output_offset
2717 + output_section
->vma
);
2719 h
->esym
.asym
.value
= 0;
2723 struct mips_elf_link_hash_entry
*hd
= h
;
2725 while (hd
->root
.root
.type
== bfd_link_hash_indirect
)
2726 hd
= (struct mips_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
2728 if (hd
->needs_lazy_stub
)
2730 /* Set type and value for a symbol with a function stub. */
2731 h
->esym
.asym
.st
= stProc
;
2732 sec
= hd
->root
.root
.u
.def
.section
;
2734 h
->esym
.asym
.value
= 0;
2737 output_section
= sec
->output_section
;
2738 if (output_section
!= NULL
)
2739 h
->esym
.asym
.value
= (hd
->root
.plt
.offset
2740 + sec
->output_offset
2741 + output_section
->vma
);
2743 h
->esym
.asym
.value
= 0;
2748 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
2749 h
->root
.root
.root
.string
,
2752 einfo
->failed
= TRUE
;
2759 /* A comparison routine used to sort .gptab entries. */
2762 gptab_compare (const void *p1
, const void *p2
)
2764 const Elf32_gptab
*a1
= p1
;
2765 const Elf32_gptab
*a2
= p2
;
2767 return a1
->gt_entry
.gt_g_value
- a2
->gt_entry
.gt_g_value
;
2770 /* Functions to manage the got entry hash table. */
2772 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
2775 static INLINE hashval_t
2776 mips_elf_hash_bfd_vma (bfd_vma addr
)
2779 return addr
+ (addr
>> 32);
2785 /* got_entries only match if they're identical, except for gotidx, so
2786 use all fields to compute the hash, and compare the appropriate
2790 mips_elf_got_entry_eq (const void *entry1
, const void *entry2
)
2792 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
2793 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
2795 return (e1
->abfd
== e2
->abfd
2796 && e1
->symndx
== e2
->symndx
2797 && (e1
->tls_type
& GOT_TLS_TYPE
) == (e2
->tls_type
& GOT_TLS_TYPE
)
2798 && (!e1
->abfd
? e1
->d
.address
== e2
->d
.address
2799 : e1
->symndx
>= 0 ? e1
->d
.addend
== e2
->d
.addend
2800 : e1
->d
.h
== e2
->d
.h
));
2803 /* multi_got_entries are still a match in the case of global objects,
2804 even if the input bfd in which they're referenced differs, so the
2805 hash computation and compare functions are adjusted
2809 mips_elf_got_entry_hash (const void *entry_
)
2811 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
2813 return (entry
->symndx
2814 + (((entry
->tls_type
& GOT_TLS_TYPE
) == GOT_TLS_LDM
) << 18)
2815 + ((entry
->tls_type
& GOT_TLS_TYPE
) == GOT_TLS_LDM
? 0
2816 : !entry
->abfd
? mips_elf_hash_bfd_vma (entry
->d
.address
)
2817 : entry
->symndx
>= 0 ? (entry
->abfd
->id
2818 + mips_elf_hash_bfd_vma (entry
->d
.addend
))
2819 : entry
->d
.h
->root
.root
.root
.hash
));
2823 mips_elf_multi_got_entry_eq (const void *entry1
, const void *entry2
)
2825 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
2826 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
2828 return (e1
->symndx
== e2
->symndx
2829 && (e1
->tls_type
& GOT_TLS_TYPE
) == (e2
->tls_type
& GOT_TLS_TYPE
)
2830 && ((e1
->tls_type
& GOT_TLS_TYPE
) == GOT_TLS_LDM
? TRUE
2831 : !e1
->abfd
? !e2
->abfd
&& e1
->d
.address
== e2
->d
.address
2832 : e1
->symndx
>= 0 ? (e1
->abfd
== e2
->abfd
2833 && e1
->d
.addend
== e2
->d
.addend
)
2834 : e2
->abfd
&& e1
->d
.h
== e2
->d
.h
));
2838 mips_got_page_entry_hash (const void *entry_
)
2840 const struct mips_got_page_entry
*entry
;
2842 entry
= (const struct mips_got_page_entry
*) entry_
;
2843 return entry
->abfd
->id
+ entry
->symndx
;
2847 mips_got_page_entry_eq (const void *entry1_
, const void *entry2_
)
2849 const struct mips_got_page_entry
*entry1
, *entry2
;
2851 entry1
= (const struct mips_got_page_entry
*) entry1_
;
2852 entry2
= (const struct mips_got_page_entry
*) entry2_
;
2853 return entry1
->abfd
== entry2
->abfd
&& entry1
->symndx
== entry2
->symndx
;
2856 /* Create and return a new mips_got_info structure. MASTER_GOT_P
2857 is true if this is the master GOT rather than a multigot. */
2859 static struct mips_got_info
*
2860 mips_elf_create_got_info (bfd
*abfd
, bfd_boolean master_got_p
)
2862 struct mips_got_info
*g
;
2864 g
= bfd_zalloc (abfd
, sizeof (struct mips_got_info
));
2868 g
->tls_ldm_offset
= MINUS_ONE
;
2870 g
->got_entries
= htab_try_create (1, mips_elf_got_entry_hash
,
2871 mips_elf_got_entry_eq
, NULL
);
2873 g
->got_entries
= htab_try_create (1, mips_elf_got_entry_hash
,
2874 mips_elf_multi_got_entry_eq
, NULL
);
2875 if (g
->got_entries
== NULL
)
2878 g
->got_page_entries
= htab_try_create (1, mips_got_page_entry_hash
,
2879 mips_got_page_entry_eq
, NULL
);
2880 if (g
->got_page_entries
== NULL
)
2886 /* Return the dynamic relocation section. If it doesn't exist, try to
2887 create a new it if CREATE_P, otherwise return NULL. Also return NULL
2888 if creation fails. */
2891 mips_elf_rel_dyn_section (struct bfd_link_info
*info
, bfd_boolean create_p
)
2897 dname
= MIPS_ELF_REL_DYN_NAME (info
);
2898 dynobj
= elf_hash_table (info
)->dynobj
;
2899 sreloc
= bfd_get_linker_section (dynobj
, dname
);
2900 if (sreloc
== NULL
&& create_p
)
2902 sreloc
= bfd_make_section_anyway_with_flags (dynobj
, dname
,
2907 | SEC_LINKER_CREATED
2910 || ! bfd_set_section_alignment (dynobj
, sreloc
,
2911 MIPS_ELF_LOG_FILE_ALIGN (dynobj
)))
2917 /* Return the GOT_TLS_* type required by relocation type R_TYPE. */
2920 mips_elf_reloc_tls_type (unsigned int r_type
)
2922 if (tls_gd_reloc_p (r_type
))
2925 if (tls_ldm_reloc_p (r_type
))
2928 if (tls_gottprel_reloc_p (r_type
))
2934 /* Return the number of GOT slots needed for GOT TLS type TYPE. */
2937 mips_tls_got_entries (unsigned int type
)
2954 /* Count the number of relocations needed for a TLS GOT entry, with
2955 access types from TLS_TYPE, and symbol H (or a local symbol if H
2959 mips_tls_got_relocs (struct bfd_link_info
*info
, unsigned char tls_type
,
2960 struct elf_link_hash_entry
*h
)
2963 bfd_boolean need_relocs
= FALSE
;
2964 bfd_boolean dyn
= elf_hash_table (info
)->dynamic_sections_created
;
2966 if (h
&& WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
2967 && (!info
->shared
|| !SYMBOL_REFERENCES_LOCAL (info
, h
)))
2970 if ((info
->shared
|| indx
!= 0)
2972 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2973 || h
->root
.type
!= bfd_link_hash_undefweak
))
2979 switch (tls_type
& GOT_TLS_TYPE
)
2982 return indx
!= 0 ? 2 : 1;
2988 return info
->shared
? 1 : 0;
2995 /* Add the number of GOT entries and TLS relocations required by ENTRY
2999 mips_elf_count_got_entry (struct bfd_link_info
*info
,
3000 struct mips_got_info
*g
,
3001 struct mips_got_entry
*entry
)
3003 unsigned char tls_type
;
3005 tls_type
= entry
->tls_type
& GOT_TLS_TYPE
;
3008 g
->tls_gotno
+= mips_tls_got_entries (tls_type
);
3009 g
->relocs
+= mips_tls_got_relocs (info
, tls_type
,
3011 ? &entry
->d
.h
->root
: NULL
);
3013 else if (entry
->symndx
>= 0 || entry
->d
.h
->global_got_area
== GGA_NONE
)
3014 g
->local_gotno
+= 1;
3016 g
->global_gotno
+= 1;
3019 /* A htab_traverse callback. If *SLOT describes a GOT entry for a local
3020 symbol, count the number of GOT entries and TLS relocations that it
3021 requires. DATA points to a mips_elf_traverse_got_arg structure. */
3024 mips_elf_count_local_got_entries (void **entryp
, void *data
)
3026 struct mips_got_entry
*entry
;
3027 struct mips_elf_traverse_got_arg
*arg
;
3029 entry
= (struct mips_got_entry
*) *entryp
;
3030 arg
= (struct mips_elf_traverse_got_arg
*) data
;
3031 if (entry
->abfd
!= NULL
&& entry
->symndx
!= -1)
3033 if ((entry
->tls_type
& GOT_TLS_TYPE
) == GOT_TLS_LDM
)
3035 if (arg
->g
->tls_ldm_offset
== MINUS_TWO
)
3037 arg
->g
->tls_ldm_offset
= MINUS_TWO
;
3039 mips_elf_count_got_entry (arg
->info
, arg
->g
, entry
);
3045 /* Count the number of TLS GOT entries and relocationss required for the
3046 global (or forced-local) symbol in ARG1. */
3049 mips_elf_count_global_tls_entries (void *entry
, void *data
)
3051 struct mips_elf_link_hash_entry
*hm
;
3052 struct mips_elf_traverse_got_arg
*arg
;
3054 hm
= (struct mips_elf_link_hash_entry
*) entry
;
3055 if (hm
->root
.root
.type
== bfd_link_hash_indirect
3056 || hm
->root
.root
.type
== bfd_link_hash_warning
)
3059 arg
= (struct mips_elf_traverse_got_arg
*) data
;
3060 if (hm
->tls_gd_type
)
3062 arg
->g
->tls_gotno
+= 2;
3063 arg
->g
->relocs
+= mips_tls_got_relocs (arg
->info
, hm
->tls_gd_type
,
3066 if (hm
->tls_ie_type
)
3068 arg
->g
->tls_gotno
+= 1;
3069 arg
->g
->relocs
+= mips_tls_got_relocs (arg
->info
, hm
->tls_ie_type
,
3076 /* Output a simple dynamic relocation into SRELOC. */
3079 mips_elf_output_dynamic_relocation (bfd
*output_bfd
,
3081 unsigned long reloc_index
,
3086 Elf_Internal_Rela rel
[3];
3088 memset (rel
, 0, sizeof (rel
));
3090 rel
[0].r_info
= ELF_R_INFO (output_bfd
, indx
, r_type
);
3091 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
3093 if (ABI_64_P (output_bfd
))
3095 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
3096 (output_bfd
, &rel
[0],
3098 + reloc_index
* sizeof (Elf64_Mips_External_Rel
)));
3101 bfd_elf32_swap_reloc_out
3102 (output_bfd
, &rel
[0],
3104 + reloc_index
* sizeof (Elf32_External_Rel
)));
3107 /* Initialize a set of TLS GOT entries for one symbol. */
3110 mips_elf_initialize_tls_slots (bfd
*abfd
, bfd_vma got_offset
,
3111 unsigned char *tls_type_p
,
3112 struct bfd_link_info
*info
,
3113 struct mips_elf_link_hash_entry
*h
,
3116 struct mips_elf_link_hash_table
*htab
;
3118 asection
*sreloc
, *sgot
;
3119 bfd_vma got_offset2
;
3120 bfd_boolean need_relocs
= FALSE
;
3122 htab
= mips_elf_hash_table (info
);
3131 bfd_boolean dyn
= elf_hash_table (info
)->dynamic_sections_created
;
3133 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, &h
->root
)
3134 && (!info
->shared
|| !SYMBOL_REFERENCES_LOCAL (info
, &h
->root
)))
3135 indx
= h
->root
.dynindx
;
3138 if (*tls_type_p
& GOT_TLS_DONE
)
3141 if ((info
->shared
|| indx
!= 0)
3143 || ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
3144 || h
->root
.type
!= bfd_link_hash_undefweak
))
3147 /* MINUS_ONE means the symbol is not defined in this object. It may not
3148 be defined at all; assume that the value doesn't matter in that
3149 case. Otherwise complain if we would use the value. */
3150 BFD_ASSERT (value
!= MINUS_ONE
|| (indx
!= 0 && need_relocs
)
3151 || h
->root
.root
.type
== bfd_link_hash_undefweak
);
3153 /* Emit necessary relocations. */
3154 sreloc
= mips_elf_rel_dyn_section (info
, FALSE
);
3156 switch (*tls_type_p
& GOT_TLS_TYPE
)
3159 /* General Dynamic. */
3160 got_offset2
= got_offset
+ MIPS_ELF_GOT_SIZE (abfd
);
3164 mips_elf_output_dynamic_relocation
3165 (abfd
, sreloc
, sreloc
->reloc_count
++, indx
,
3166 ABI_64_P (abfd
) ? R_MIPS_TLS_DTPMOD64
: R_MIPS_TLS_DTPMOD32
,
3167 sgot
->output_offset
+ sgot
->output_section
->vma
+ got_offset
);
3170 mips_elf_output_dynamic_relocation
3171 (abfd
, sreloc
, sreloc
->reloc_count
++, indx
,
3172 ABI_64_P (abfd
) ? R_MIPS_TLS_DTPREL64
: R_MIPS_TLS_DTPREL32
,
3173 sgot
->output_offset
+ sgot
->output_section
->vma
+ got_offset2
);
3175 MIPS_ELF_PUT_WORD (abfd
, value
- dtprel_base (info
),
3176 sgot
->contents
+ got_offset2
);
3180 MIPS_ELF_PUT_WORD (abfd
, 1,
3181 sgot
->contents
+ got_offset
);
3182 MIPS_ELF_PUT_WORD (abfd
, value
- dtprel_base (info
),
3183 sgot
->contents
+ got_offset2
);
3188 /* Initial Exec model. */
3192 MIPS_ELF_PUT_WORD (abfd
, value
- elf_hash_table (info
)->tls_sec
->vma
,
3193 sgot
->contents
+ got_offset
);
3195 MIPS_ELF_PUT_WORD (abfd
, 0,
3196 sgot
->contents
+ got_offset
);
3198 mips_elf_output_dynamic_relocation
3199 (abfd
, sreloc
, sreloc
->reloc_count
++, indx
,
3200 ABI_64_P (abfd
) ? R_MIPS_TLS_TPREL64
: R_MIPS_TLS_TPREL32
,
3201 sgot
->output_offset
+ sgot
->output_section
->vma
+ got_offset
);
3204 MIPS_ELF_PUT_WORD (abfd
, value
- tprel_base (info
),
3205 sgot
->contents
+ got_offset
);
3209 /* The initial offset is zero, and the LD offsets will include the
3210 bias by DTP_OFFSET. */
3211 MIPS_ELF_PUT_WORD (abfd
, 0,
3212 sgot
->contents
+ got_offset
3213 + MIPS_ELF_GOT_SIZE (abfd
));
3216 MIPS_ELF_PUT_WORD (abfd
, 1,
3217 sgot
->contents
+ got_offset
);
3219 mips_elf_output_dynamic_relocation
3220 (abfd
, sreloc
, sreloc
->reloc_count
++, indx
,
3221 ABI_64_P (abfd
) ? R_MIPS_TLS_DTPMOD64
: R_MIPS_TLS_DTPMOD32
,
3222 sgot
->output_offset
+ sgot
->output_section
->vma
+ got_offset
);
3229 *tls_type_p
|= GOT_TLS_DONE
;
3232 /* Return the GOT index to use for a relocation against H using the
3233 TLS model in *TLS_TYPE. The GOT entries for this symbol/model
3234 combination start at GOT_INDEX into ABFD's GOT. This function
3235 initializes the GOT entries and corresponding relocations. */
3238 mips_tls_got_index (bfd
*abfd
, bfd_vma got_index
, unsigned char *tls_type
,
3239 struct bfd_link_info
*info
,
3240 struct mips_elf_link_hash_entry
*h
, bfd_vma symbol
)
3242 mips_elf_initialize_tls_slots (abfd
, got_index
, tls_type
, info
, h
, symbol
);
3246 /* Return the GOT index to use for a relocation of type R_TYPE against H
3250 mips_tls_single_got_index (bfd
*abfd
, int r_type
, struct bfd_link_info
*info
,
3251 struct mips_elf_link_hash_entry
*h
, bfd_vma symbol
)
3253 if (tls_gottprel_reloc_p (r_type
))
3254 return mips_tls_got_index (abfd
, h
->tls_ie_got_offset
, &h
->tls_ie_type
,
3256 if (tls_gd_reloc_p (r_type
))
3257 return mips_tls_got_index (abfd
, h
->tls_gd_got_offset
, &h
->tls_gd_type
,
3262 /* Return the offset from _GLOBAL_OFFSET_TABLE_ of the .got.plt entry
3263 for global symbol H. .got.plt comes before the GOT, so the offset
3264 will be negative. */
3267 mips_elf_gotplt_index (struct bfd_link_info
*info
,
3268 struct elf_link_hash_entry
*h
)
3270 bfd_vma plt_index
, got_address
, got_value
;
3271 struct mips_elf_link_hash_table
*htab
;
3273 htab
= mips_elf_hash_table (info
);
3274 BFD_ASSERT (htab
!= NULL
);
3276 BFD_ASSERT (h
->plt
.offset
!= (bfd_vma
) -1);
3278 /* This function only works for VxWorks, because a non-VxWorks .got.plt
3279 section starts with reserved entries. */
3280 BFD_ASSERT (htab
->is_vxworks
);
3282 /* Calculate the index of the symbol's PLT entry. */
3283 plt_index
= (h
->plt
.offset
- htab
->plt_header_size
) / htab
->plt_entry_size
;
3285 /* Calculate the address of the associated .got.plt entry. */
3286 got_address
= (htab
->sgotplt
->output_section
->vma
3287 + htab
->sgotplt
->output_offset
3290 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */
3291 got_value
= (htab
->root
.hgot
->root
.u
.def
.section
->output_section
->vma
3292 + htab
->root
.hgot
->root
.u
.def
.section
->output_offset
3293 + htab
->root
.hgot
->root
.u
.def
.value
);
3295 return got_address
- got_value
;
3298 /* Return the GOT offset for address VALUE. If there is not yet a GOT
3299 entry for this value, create one. If R_SYMNDX refers to a TLS symbol,
3300 create a TLS GOT entry instead. Return -1 if no satisfactory GOT
3301 offset can be found. */
3304 mips_elf_local_got_index (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
3305 bfd_vma value
, unsigned long r_symndx
,
3306 struct mips_elf_link_hash_entry
*h
, int r_type
)
3308 struct mips_elf_link_hash_table
*htab
;
3309 struct mips_got_entry
*entry
;
3311 htab
= mips_elf_hash_table (info
);
3312 BFD_ASSERT (htab
!= NULL
);
3314 entry
= mips_elf_create_local_got_entry (abfd
, info
, ibfd
, value
,
3315 r_symndx
, h
, r_type
);
3319 if (entry
->tls_type
)
3321 if (entry
->symndx
== -1 && htab
->got_info
->next
== NULL
)
3322 /* A type (3) entry in the single-GOT case. We use the symbol's
3323 hash table entry to track the index. */
3324 return mips_tls_single_got_index (abfd
, r_type
, info
, h
, value
);
3326 return mips_tls_got_index (abfd
, entry
->gotidx
, &entry
->tls_type
,
3330 return entry
->gotidx
;
3333 /* Returns the GOT index for the global symbol indicated by H. */
3336 mips_elf_global_got_index (bfd
*abfd
, bfd
*ibfd
, struct elf_link_hash_entry
*h
,
3337 int r_type
, struct bfd_link_info
*info
)
3339 struct mips_elf_link_hash_table
*htab
;
3341 struct mips_got_info
*g
, *gg
;
3342 long global_got_dynindx
= 0;
3344 htab
= mips_elf_hash_table (info
);
3345 BFD_ASSERT (htab
!= NULL
);
3347 gg
= g
= htab
->got_info
;
3348 if (g
->bfd2got
&& ibfd
)
3350 struct mips_got_entry e
, *p
;
3352 BFD_ASSERT (h
->dynindx
>= 0);
3354 g
= mips_elf_got_for_ibfd (g
, ibfd
);
3355 if (g
->next
!= gg
|| TLS_RELOC_P (r_type
))
3359 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
3360 e
.tls_type
= mips_elf_reloc_tls_type (r_type
);
3362 p
= htab_find (g
->got_entries
, &e
);
3364 BFD_ASSERT (p
&& p
->gotidx
> 0);
3368 bfd_vma value
= MINUS_ONE
;
3369 if ((h
->root
.type
== bfd_link_hash_defined
3370 || h
->root
.type
== bfd_link_hash_defweak
)
3371 && h
->root
.u
.def
.section
->output_section
)
3372 value
= (h
->root
.u
.def
.value
3373 + h
->root
.u
.def
.section
->output_offset
3374 + h
->root
.u
.def
.section
->output_section
->vma
);
3376 return mips_tls_got_index (abfd
, p
->gotidx
, &p
->tls_type
,
3377 info
, e
.d
.h
, value
);
3384 if (htab
->global_gotsym
!= NULL
)
3385 global_got_dynindx
= htab
->global_gotsym
->dynindx
;
3387 if (TLS_RELOC_P (r_type
))
3389 struct mips_elf_link_hash_entry
*hm
3390 = (struct mips_elf_link_hash_entry
*) h
;
3391 bfd_vma value
= MINUS_ONE
;
3393 if ((h
->root
.type
== bfd_link_hash_defined
3394 || h
->root
.type
== bfd_link_hash_defweak
)
3395 && h
->root
.u
.def
.section
->output_section
)
3396 value
= (h
->root
.u
.def
.value
3397 + h
->root
.u
.def
.section
->output_offset
3398 + h
->root
.u
.def
.section
->output_section
->vma
);
3400 got_index
= mips_tls_single_got_index (abfd
, r_type
, info
, hm
, value
);
3404 /* Once we determine the global GOT entry with the lowest dynamic
3405 symbol table index, we must put all dynamic symbols with greater
3406 indices into the GOT. That makes it easy to calculate the GOT
3408 BFD_ASSERT (h
->dynindx
>= global_got_dynindx
);
3409 got_index
= ((h
->dynindx
- global_got_dynindx
+ g
->local_gotno
)
3410 * MIPS_ELF_GOT_SIZE (abfd
));
3412 BFD_ASSERT (got_index
< htab
->sgot
->size
);
3417 /* Find a GOT page entry that points to within 32KB of VALUE. These
3418 entries are supposed to be placed at small offsets in the GOT, i.e.,
3419 within 32KB of GP. Return the index of the GOT entry, or -1 if no
3420 entry could be created. If OFFSETP is nonnull, use it to return the
3421 offset of the GOT entry from VALUE. */
3424 mips_elf_got_page (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
3425 bfd_vma value
, bfd_vma
*offsetp
)
3427 bfd_vma page
, got_index
;
3428 struct mips_got_entry
*entry
;
3430 page
= (value
+ 0x8000) & ~(bfd_vma
) 0xffff;
3431 entry
= mips_elf_create_local_got_entry (abfd
, info
, ibfd
, page
, 0,
3432 NULL
, R_MIPS_GOT_PAGE
);
3437 got_index
= entry
->gotidx
;
3440 *offsetp
= value
- entry
->d
.address
;
3445 /* Find a local GOT entry for an R_MIPS*_GOT16 relocation against VALUE.
3446 EXTERNAL is true if the relocation was originally against a global
3447 symbol that binds locally. */
3450 mips_elf_got16_entry (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
3451 bfd_vma value
, bfd_boolean external
)
3453 struct mips_got_entry
*entry
;
3455 /* GOT16 relocations against local symbols are followed by a LO16
3456 relocation; those against global symbols are not. Thus if the
3457 symbol was originally local, the GOT16 relocation should load the
3458 equivalent of %hi(VALUE), otherwise it should load VALUE itself. */
3460 value
= mips_elf_high (value
) << 16;
3462 /* It doesn't matter whether the original relocation was R_MIPS_GOT16,
3463 R_MIPS16_GOT16, R_MIPS_CALL16, etc. The format of the entry is the
3464 same in all cases. */
3465 entry
= mips_elf_create_local_got_entry (abfd
, info
, ibfd
, value
, 0,
3466 NULL
, R_MIPS_GOT16
);
3468 return entry
->gotidx
;
3473 /* Returns the offset for the entry at the INDEXth position
3477 mips_elf_got_offset_from_index (struct bfd_link_info
*info
, bfd
*output_bfd
,
3478 bfd
*input_bfd
, bfd_vma got_index
)
3480 struct mips_elf_link_hash_table
*htab
;
3484 htab
= mips_elf_hash_table (info
);
3485 BFD_ASSERT (htab
!= NULL
);
3488 gp
= _bfd_get_gp_value (output_bfd
)
3489 + mips_elf_adjust_gp (output_bfd
, htab
->got_info
, input_bfd
);
3491 return sgot
->output_section
->vma
+ sgot
->output_offset
+ got_index
- gp
;
3494 /* Create and return a local GOT entry for VALUE, which was calculated
3495 from a symbol belonging to INPUT_SECTON. Return NULL if it could not
3496 be created. If R_SYMNDX refers to a TLS symbol, create a TLS entry
3499 static struct mips_got_entry
*
3500 mips_elf_create_local_got_entry (bfd
*abfd
, struct bfd_link_info
*info
,
3501 bfd
*ibfd
, bfd_vma value
,
3502 unsigned long r_symndx
,
3503 struct mips_elf_link_hash_entry
*h
,
3506 struct mips_got_entry entry
, **loc
;
3507 struct mips_got_info
*g
;
3508 struct mips_elf_link_hash_table
*htab
;
3510 htab
= mips_elf_hash_table (info
);
3511 BFD_ASSERT (htab
!= NULL
);
3515 entry
.d
.address
= value
;
3516 entry
.tls_type
= mips_elf_reloc_tls_type (r_type
);
3518 g
= mips_elf_got_for_ibfd (htab
->got_info
, ibfd
);
3521 g
= mips_elf_got_for_ibfd (htab
->got_info
, abfd
);
3522 BFD_ASSERT (g
!= NULL
);
3525 /* This function shouldn't be called for symbols that live in the global
3527 BFD_ASSERT (h
== NULL
|| h
->global_got_area
== GGA_NONE
);
3530 struct mips_got_entry
*p
;
3533 if (tls_ldm_reloc_p (r_type
))
3540 entry
.symndx
= r_symndx
;
3546 p
= (struct mips_got_entry
*)
3547 htab_find (g
->got_entries
, &entry
);
3553 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
3558 entry
.gotidx
= MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
++;
3560 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
3565 memcpy (*loc
, &entry
, sizeof entry
);
3567 if (g
->assigned_gotno
> g
->local_gotno
)
3569 (*loc
)->gotidx
= -1;
3570 /* We didn't allocate enough space in the GOT. */
3571 (*_bfd_error_handler
)
3572 (_("not enough GOT space for local GOT entries"));
3573 bfd_set_error (bfd_error_bad_value
);
3577 MIPS_ELF_PUT_WORD (abfd
, value
,
3578 (htab
->sgot
->contents
+ entry
.gotidx
));
3580 /* These GOT entries need a dynamic relocation on VxWorks. */
3581 if (htab
->is_vxworks
)
3583 Elf_Internal_Rela outrel
;
3586 bfd_vma got_address
;
3588 s
= mips_elf_rel_dyn_section (info
, FALSE
);
3589 got_address
= (htab
->sgot
->output_section
->vma
3590 + htab
->sgot
->output_offset
3593 rloc
= s
->contents
+ (s
->reloc_count
++ * sizeof (Elf32_External_Rela
));
3594 outrel
.r_offset
= got_address
;
3595 outrel
.r_info
= ELF32_R_INFO (STN_UNDEF
, R_MIPS_32
);
3596 outrel
.r_addend
= value
;
3597 bfd_elf32_swap_reloca_out (abfd
, &outrel
, rloc
);
3603 /* Return the number of dynamic section symbols required by OUTPUT_BFD.
3604 The number might be exact or a worst-case estimate, depending on how
3605 much information is available to elf_backend_omit_section_dynsym at
3606 the current linking stage. */
3608 static bfd_size_type
3609 count_section_dynsyms (bfd
*output_bfd
, struct bfd_link_info
*info
)
3611 bfd_size_type count
;
3614 if (info
->shared
|| elf_hash_table (info
)->is_relocatable_executable
)
3617 const struct elf_backend_data
*bed
;
3619 bed
= get_elf_backend_data (output_bfd
);
3620 for (p
= output_bfd
->sections
; p
; p
= p
->next
)
3621 if ((p
->flags
& SEC_EXCLUDE
) == 0
3622 && (p
->flags
& SEC_ALLOC
) != 0
3623 && !(*bed
->elf_backend_omit_section_dynsym
) (output_bfd
, info
, p
))
3629 /* Sort the dynamic symbol table so that symbols that need GOT entries
3630 appear towards the end. */
3633 mips_elf_sort_hash_table (bfd
*abfd
, struct bfd_link_info
*info
)
3635 struct mips_elf_link_hash_table
*htab
;
3636 struct mips_elf_hash_sort_data hsd
;
3637 struct mips_got_info
*g
;
3639 if (elf_hash_table (info
)->dynsymcount
== 0)
3642 htab
= mips_elf_hash_table (info
);
3643 BFD_ASSERT (htab
!= NULL
);
3650 hsd
.max_unref_got_dynindx
3651 = hsd
.min_got_dynindx
3652 = (elf_hash_table (info
)->dynsymcount
- g
->reloc_only_gotno
);
3653 hsd
.max_non_got_dynindx
= count_section_dynsyms (abfd
, info
) + 1;
3654 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table
*)
3655 elf_hash_table (info
)),
3656 mips_elf_sort_hash_table_f
,
3659 /* There should have been enough room in the symbol table to
3660 accommodate both the GOT and non-GOT symbols. */
3661 BFD_ASSERT (hsd
.max_non_got_dynindx
<= hsd
.min_got_dynindx
);
3662 BFD_ASSERT ((unsigned long) hsd
.max_unref_got_dynindx
3663 == elf_hash_table (info
)->dynsymcount
);
3664 BFD_ASSERT (elf_hash_table (info
)->dynsymcount
- hsd
.min_got_dynindx
3665 == g
->global_gotno
);
3667 /* Now we know which dynamic symbol has the lowest dynamic symbol
3668 table index in the GOT. */
3669 htab
->global_gotsym
= hsd
.low
;
3674 /* If H needs a GOT entry, assign it the highest available dynamic
3675 index. Otherwise, assign it the lowest available dynamic
3679 mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry
*h
, void *data
)
3681 struct mips_elf_hash_sort_data
*hsd
= data
;
3683 /* Symbols without dynamic symbol table entries aren't interesting
3685 if (h
->root
.dynindx
== -1)
3688 switch (h
->global_got_area
)
3691 h
->root
.dynindx
= hsd
->max_non_got_dynindx
++;
3695 h
->root
.dynindx
= --hsd
->min_got_dynindx
;
3696 hsd
->low
= (struct elf_link_hash_entry
*) h
;
3699 case GGA_RELOC_ONLY
:
3700 if (hsd
->max_unref_got_dynindx
== hsd
->min_got_dynindx
)
3701 hsd
->low
= (struct elf_link_hash_entry
*) h
;
3702 h
->root
.dynindx
= hsd
->max_unref_got_dynindx
++;
3709 /* ABFD has a GOT relocation of type R_TYPE against H. Reserve a GOT
3710 entry for it. FOR_CALL is true if the caller is only interested in
3711 using the GOT entry for calls. */
3714 mips_elf_record_global_got_symbol (struct elf_link_hash_entry
*h
,
3715 bfd
*abfd
, struct bfd_link_info
*info
,
3716 bfd_boolean for_call
, int r_type
)
3718 struct mips_elf_link_hash_table
*htab
;
3719 struct mips_elf_link_hash_entry
*hmips
;
3720 struct mips_got_entry entry
, **loc
;
3721 struct mips_got_info
*g
;
3723 htab
= mips_elf_hash_table (info
);
3724 BFD_ASSERT (htab
!= NULL
);
3726 hmips
= (struct mips_elf_link_hash_entry
*) h
;
3728 hmips
->got_only_for_calls
= FALSE
;
3730 /* A global symbol in the GOT must also be in the dynamic symbol
3732 if (h
->dynindx
== -1)
3734 switch (ELF_ST_VISIBILITY (h
->other
))
3738 _bfd_elf_link_hash_hide_symbol (info
, h
, TRUE
);
3741 if (!bfd_elf_link_record_dynamic_symbol (info
, h
))
3745 /* Make sure we have a GOT to put this entry into. */
3747 BFD_ASSERT (g
!= NULL
);
3751 entry
.d
.h
= (struct mips_elf_link_hash_entry
*) h
;
3752 entry
.tls_type
= mips_elf_reloc_tls_type (r_type
);
3754 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
3757 /* If we've already marked this entry as needing GOT space, we don't
3758 need to do it again. */
3762 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
3769 memcpy (*loc
, &entry
, sizeof entry
);
3771 if (entry
.tls_type
== GOT_NORMAL
)
3772 hmips
->global_got_area
= GGA_NORMAL
;
3773 else if (entry
.tls_type
== GOT_TLS_IE
)
3774 hmips
->tls_ie_type
= entry
.tls_type
;
3775 else if (entry
.tls_type
== GOT_TLS_GD
)
3776 hmips
->tls_gd_type
= entry
.tls_type
;
3781 /* ABFD has a GOT relocation of type R_TYPE against symbol SYMNDX + ADDEND,
3782 where SYMNDX is a local symbol. Reserve a GOT entry for it. */
3785 mips_elf_record_local_got_symbol (bfd
*abfd
, long symndx
, bfd_vma addend
,
3786 struct bfd_link_info
*info
, int r_type
)
3788 struct mips_elf_link_hash_table
*htab
;
3789 struct mips_got_info
*g
;
3790 struct mips_got_entry entry
, **loc
;
3792 htab
= mips_elf_hash_table (info
);
3793 BFD_ASSERT (htab
!= NULL
);
3796 BFD_ASSERT (g
!= NULL
);
3799 entry
.symndx
= symndx
;
3800 entry
.d
.addend
= addend
;
3801 entry
.tls_type
= mips_elf_reloc_tls_type (r_type
);
3802 loc
= (struct mips_got_entry
**)
3803 htab_find_slot (g
->got_entries
, &entry
, INSERT
);
3810 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
3815 memcpy (*loc
, &entry
, sizeof entry
);
3820 /* Return the maximum number of GOT page entries required for RANGE. */
3823 mips_elf_pages_for_range (const struct mips_got_page_range
*range
)
3825 return (range
->max_addend
- range
->min_addend
+ 0x1ffff) >> 16;
3828 /* Record that ABFD has a page relocation against symbol SYMNDX and
3829 that ADDEND is the addend for that relocation.
3831 This function creates an upper bound on the number of GOT slots
3832 required; no attempt is made to combine references to non-overridable
3833 global symbols across multiple input files. */
3836 mips_elf_record_got_page_entry (struct bfd_link_info
*info
, bfd
*abfd
,
3837 long symndx
, bfd_signed_vma addend
)
3839 struct mips_elf_link_hash_table
*htab
;
3840 struct mips_got_info
*g
;
3841 struct mips_got_page_entry lookup
, *entry
;
3842 struct mips_got_page_range
**range_ptr
, *range
;
3843 bfd_vma old_pages
, new_pages
;
3846 htab
= mips_elf_hash_table (info
);
3847 BFD_ASSERT (htab
!= NULL
);
3850 BFD_ASSERT (g
!= NULL
);
3852 /* Find the mips_got_page_entry hash table entry for this symbol. */
3854 lookup
.symndx
= symndx
;
3855 loc
= htab_find_slot (g
->got_page_entries
, &lookup
, INSERT
);
3859 /* Create a mips_got_page_entry if this is the first time we've
3861 entry
= (struct mips_got_page_entry
*) *loc
;
3864 entry
= bfd_alloc (abfd
, sizeof (*entry
));
3869 entry
->symndx
= symndx
;
3870 entry
->ranges
= NULL
;
3871 entry
->num_pages
= 0;
3875 /* Skip over ranges whose maximum extent cannot share a page entry
3877 range_ptr
= &entry
->ranges
;
3878 while (*range_ptr
&& addend
> (*range_ptr
)->max_addend
+ 0xffff)
3879 range_ptr
= &(*range_ptr
)->next
;
3881 /* If we scanned to the end of the list, or found a range whose
3882 minimum extent cannot share a page entry with ADDEND, create
3883 a new singleton range. */
3885 if (!range
|| addend
< range
->min_addend
- 0xffff)
3887 range
= bfd_alloc (abfd
, sizeof (*range
));
3891 range
->next
= *range_ptr
;
3892 range
->min_addend
= addend
;
3893 range
->max_addend
= addend
;
3901 /* Remember how many pages the old range contributed. */
3902 old_pages
= mips_elf_pages_for_range (range
);
3904 /* Update the ranges. */
3905 if (addend
< range
->min_addend
)
3906 range
->min_addend
= addend
;
3907 else if (addend
> range
->max_addend
)
3909 if (range
->next
&& addend
>= range
->next
->min_addend
- 0xffff)
3911 old_pages
+= mips_elf_pages_for_range (range
->next
);
3912 range
->max_addend
= range
->next
->max_addend
;
3913 range
->next
= range
->next
->next
;
3916 range
->max_addend
= addend
;
3919 /* Record any change in the total estimate. */
3920 new_pages
= mips_elf_pages_for_range (range
);
3921 if (old_pages
!= new_pages
)
3923 entry
->num_pages
+= new_pages
- old_pages
;
3924 g
->page_gotno
+= new_pages
- old_pages
;
3930 /* Add room for N relocations to the .rel(a).dyn section in ABFD. */
3933 mips_elf_allocate_dynamic_relocations (bfd
*abfd
, struct bfd_link_info
*info
,
3937 struct mips_elf_link_hash_table
*htab
;
3939 htab
= mips_elf_hash_table (info
);
3940 BFD_ASSERT (htab
!= NULL
);
3942 s
= mips_elf_rel_dyn_section (info
, FALSE
);
3943 BFD_ASSERT (s
!= NULL
);
3945 if (htab
->is_vxworks
)
3946 s
->size
+= n
* MIPS_ELF_RELA_SIZE (abfd
);
3951 /* Make room for a null element. */
3952 s
->size
+= MIPS_ELF_REL_SIZE (abfd
);
3955 s
->size
+= n
* MIPS_ELF_REL_SIZE (abfd
);
3959 /* A htab_traverse callback for GOT entries. Set boolean *DATA to true
3960 if the GOT entry is for an indirect or warning symbol. */
3963 mips_elf_check_recreate_got (void **entryp
, void *data
)
3965 struct mips_got_entry
*entry
;
3966 bfd_boolean
*must_recreate
;
3968 entry
= (struct mips_got_entry
*) *entryp
;
3969 must_recreate
= (bfd_boolean
*) data
;
3970 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1)
3972 struct mips_elf_link_hash_entry
*h
;
3975 if (h
->root
.root
.type
== bfd_link_hash_indirect
3976 || h
->root
.root
.type
== bfd_link_hash_warning
)
3978 *must_recreate
= TRUE
;
3985 /* A htab_traverse callback for GOT entries. Add all entries to
3986 hash table *DATA, converting entries for indirect and warning
3987 symbols into entries for the target symbol. Set *DATA to null
3991 mips_elf_recreate_got (void **entryp
, void *data
)
3994 struct mips_got_entry new_entry
, *entry
;
3997 new_got
= (htab_t
*) data
;
3998 entry
= (struct mips_got_entry
*) *entryp
;
3999 if (entry
->abfd
!= NULL
4000 && entry
->symndx
== -1
4001 && (entry
->d
.h
->root
.root
.type
== bfd_link_hash_indirect
4002 || entry
->d
.h
->root
.root
.type
== bfd_link_hash_warning
))
4004 struct mips_elf_link_hash_entry
*h
;
4011 BFD_ASSERT (h
->global_got_area
== GGA_NONE
);
4012 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
4014 while (h
->root
.root
.type
== bfd_link_hash_indirect
4015 || h
->root
.root
.type
== bfd_link_hash_warning
);
4018 slot
= htab_find_slot (*new_got
, entry
, INSERT
);
4026 if (entry
== &new_entry
)
4028 entry
= bfd_alloc (entry
->abfd
, sizeof (*entry
));
4041 /* If any entries in G->got_entries are for indirect or warning symbols,
4042 replace them with entries for the target symbol. */
4045 mips_elf_resolve_final_got_entries (struct mips_got_info
*g
)
4047 bfd_boolean must_recreate
;
4050 must_recreate
= FALSE
;
4051 htab_traverse (g
->got_entries
, mips_elf_check_recreate_got
, &must_recreate
);
4054 new_got
= htab_create (htab_size (g
->got_entries
),
4055 mips_elf_got_entry_hash
,
4056 mips_elf_got_entry_eq
, NULL
);
4057 htab_traverse (g
->got_entries
, mips_elf_recreate_got
, &new_got
);
4058 if (new_got
== NULL
)
4061 htab_delete (g
->got_entries
);
4062 g
->got_entries
= new_got
;
4067 /* A mips_elf_link_hash_traverse callback for which DATA points
4068 to the link_info structure. Count the number of type (3) entries
4069 in the master GOT. */
4072 mips_elf_count_got_symbols (struct mips_elf_link_hash_entry
*h
, void *data
)
4074 struct bfd_link_info
*info
;
4075 struct mips_elf_link_hash_table
*htab
;
4076 struct mips_got_info
*g
;
4078 info
= (struct bfd_link_info
*) data
;
4079 htab
= mips_elf_hash_table (info
);
4081 if (h
->global_got_area
!= GGA_NONE
)
4083 /* Make a final decision about whether the symbol belongs in the
4084 local or global GOT. Symbols that bind locally can (and in the
4085 case of forced-local symbols, must) live in the local GOT.
4086 Those that are aren't in the dynamic symbol table must also
4087 live in the local GOT.
4089 Note that the former condition does not always imply the
4090 latter: symbols do not bind locally if they are completely
4091 undefined. We'll report undefined symbols later if appropriate. */
4092 if (h
->root
.dynindx
== -1
4093 || (h
->got_only_for_calls
4094 ? SYMBOL_CALLS_LOCAL (info
, &h
->root
)
4095 : SYMBOL_REFERENCES_LOCAL (info
, &h
->root
)))
4097 /* The symbol belongs in the local GOT. We no longer need this
4098 entry if it was only used for relocations; those relocations
4099 will be against the null or section symbol instead of H. */
4100 if (h
->global_got_area
!= GGA_RELOC_ONLY
)
4102 h
->global_got_area
= GGA_NONE
;
4104 else if (htab
->is_vxworks
4105 && h
->got_only_for_calls
4106 && h
->root
.plt
.offset
!= MINUS_ONE
)
4107 /* On VxWorks, calls can refer directly to the .got.plt entry;
4108 they don't need entries in the regular GOT. .got.plt entries
4109 will be allocated by _bfd_mips_elf_adjust_dynamic_symbol. */
4110 h
->global_got_area
= GGA_NONE
;
4114 if (h
->global_got_area
== GGA_RELOC_ONLY
)
4115 g
->reloc_only_gotno
++;
4121 /* Compute the hash value of the bfd in a bfd2got hash entry. */
4124 mips_elf_bfd2got_entry_hash (const void *entry_
)
4126 const struct mips_elf_bfd2got_hash
*entry
4127 = (struct mips_elf_bfd2got_hash
*)entry_
;
4129 return entry
->bfd
->id
;
4132 /* Check whether two hash entries have the same bfd. */
4135 mips_elf_bfd2got_entry_eq (const void *entry1
, const void *entry2
)
4137 const struct mips_elf_bfd2got_hash
*e1
4138 = (const struct mips_elf_bfd2got_hash
*)entry1
;
4139 const struct mips_elf_bfd2got_hash
*e2
4140 = (const struct mips_elf_bfd2got_hash
*)entry2
;
4142 return e1
->bfd
== e2
->bfd
;
4145 /* In a multi-got link, determine the GOT to be used for IBFD. G must
4146 be the master GOT data. */
4148 static struct mips_got_info
*
4149 mips_elf_got_for_ibfd (struct mips_got_info
*g
, bfd
*ibfd
)
4151 struct mips_elf_bfd2got_hash e
, *p
;
4157 p
= htab_find (g
->bfd2got
, &e
);
4158 return p
? p
->g
: NULL
;
4161 /* Use BFD2GOT to find ABFD's got entry, creating one if none exists.
4162 Return NULL if an error occured. */
4164 static struct mips_got_info
*
4165 mips_elf_get_got_for_bfd (struct htab
*bfd2got
, bfd
*output_bfd
,
4168 struct mips_elf_bfd2got_hash bfdgot_entry
, *bfdgot
;
4171 bfdgot_entry
.bfd
= input_bfd
;
4172 bfdgotp
= htab_find_slot (bfd2got
, &bfdgot_entry
, INSERT
);
4173 bfdgot
= (struct mips_elf_bfd2got_hash
*) *bfdgotp
;
4177 bfdgot
= ((struct mips_elf_bfd2got_hash
*)
4178 bfd_alloc (output_bfd
, sizeof (struct mips_elf_bfd2got_hash
)));
4184 bfdgot
->bfd
= input_bfd
;
4185 bfdgot
->g
= mips_elf_create_got_info (input_bfd
, FALSE
);
4186 if (bfdgot
->g
== NULL
)
4193 /* A htab_traverse callback for the entries in the master got.
4194 Create one separate got for each bfd that has entries in the global
4195 got, such that we can tell how many local and global entries each
4199 mips_elf_make_got_per_bfd (void **entryp
, void *p
)
4201 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
4202 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
4203 struct mips_got_info
*g
;
4205 g
= mips_elf_get_got_for_bfd (arg
->bfd2got
, arg
->obfd
, entry
->abfd
);
4212 /* Insert the GOT entry in the bfd's got entry hash table. */
4213 entryp
= htab_find_slot (g
->got_entries
, entry
, INSERT
);
4214 if (*entryp
!= NULL
)
4218 mips_elf_count_got_entry (arg
->info
, g
, entry
);
4223 /* A htab_traverse callback for the page entries in the master got.
4224 Associate each page entry with the bfd's got. */
4227 mips_elf_make_got_pages_per_bfd (void **entryp
, void *p
)
4229 struct mips_got_page_entry
*entry
= (struct mips_got_page_entry
*) *entryp
;
4230 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*) p
;
4231 struct mips_got_info
*g
;
4233 g
= mips_elf_get_got_for_bfd (arg
->bfd2got
, arg
->obfd
, entry
->abfd
);
4240 /* Insert the GOT entry in the bfd's got entry hash table. */
4241 entryp
= htab_find_slot (g
->got_page_entries
, entry
, INSERT
);
4242 if (*entryp
!= NULL
)
4246 g
->page_gotno
+= entry
->num_pages
;
4250 /* Consider merging the got described by BFD2GOT with TO, using the
4251 information given by ARG. Return -1 if this would lead to overflow,
4252 1 if they were merged successfully, and 0 if a merge failed due to
4253 lack of memory. (These values are chosen so that nonnegative return
4254 values can be returned by a htab_traverse callback.) */
4257 mips_elf_merge_got_with (struct mips_elf_bfd2got_hash
*bfd2got
,
4258 struct mips_got_info
*to
,
4259 struct mips_elf_got_per_bfd_arg
*arg
)
4261 struct mips_got_info
*from
= bfd2got
->g
;
4262 unsigned int estimate
;
4264 /* Work out how many page entries we would need for the combined GOT. */
4265 estimate
= arg
->max_pages
;
4266 if (estimate
>= from
->page_gotno
+ to
->page_gotno
)
4267 estimate
= from
->page_gotno
+ to
->page_gotno
;
4269 /* And conservatively estimate how many local and TLS entries
4271 estimate
+= from
->local_gotno
+ to
->local_gotno
;
4272 estimate
+= from
->tls_gotno
+ to
->tls_gotno
;
4274 /* If we're merging with the primary got, any TLS relocations will
4275 come after the full set of global entries. Otherwise estimate those
4276 conservatively as well. */
4277 if (to
== arg
->primary
&& from
->tls_gotno
+ to
->tls_gotno
)
4278 estimate
+= arg
->global_count
;
4280 estimate
+= from
->global_gotno
+ to
->global_gotno
;
4282 /* Bail out if the combined GOT might be too big. */
4283 if (estimate
> arg
->max_count
)
4286 /* Commit to the merge. Record that TO is now the bfd for this got. */
4289 /* Transfer the bfd's got information from FROM to TO. */
4290 htab_traverse (from
->got_entries
, mips_elf_make_got_per_bfd
, arg
);
4291 if (arg
->obfd
== NULL
)
4294 htab_traverse (from
->got_page_entries
, mips_elf_make_got_pages_per_bfd
, arg
);
4295 if (arg
->obfd
== NULL
)
4298 /* We don't have to worry about releasing memory of the actual
4299 got entries, since they're all in the master got_entries hash
4301 htab_delete (from
->got_entries
);
4302 htab_delete (from
->got_page_entries
);
4306 /* Attempt to merge gots of different input bfds. Try to use as much
4307 as possible of the primary got, since it doesn't require explicit
4308 dynamic relocations, but don't use bfds that would reference global
4309 symbols out of the addressable range. Failing the primary got,
4310 attempt to merge with the current got, or finish the current got
4311 and then make make the new got current. */
4314 mips_elf_merge_gots (void **bfd2got_
, void *p
)
4316 struct mips_elf_bfd2got_hash
*bfd2got
4317 = (struct mips_elf_bfd2got_hash
*)*bfd2got_
;
4318 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
4319 struct mips_got_info
*g
;
4320 unsigned int estimate
;
4325 /* Work out the number of page, local and TLS entries. */
4326 estimate
= arg
->max_pages
;
4327 if (estimate
> g
->page_gotno
)
4328 estimate
= g
->page_gotno
;
4329 estimate
+= g
->local_gotno
+ g
->tls_gotno
;
4331 /* We place TLS GOT entries after both locals and globals. The globals
4332 for the primary GOT may overflow the normal GOT size limit, so be
4333 sure not to merge a GOT which requires TLS with the primary GOT in that
4334 case. This doesn't affect non-primary GOTs. */
4335 estimate
+= (g
->tls_gotno
> 0 ? arg
->global_count
: g
->global_gotno
);
4337 if (estimate
<= arg
->max_count
)
4339 /* If we don't have a primary GOT, use it as
4340 a starting point for the primary GOT. */
4343 arg
->primary
= bfd2got
->g
;
4347 /* Try merging with the primary GOT. */
4348 result
= mips_elf_merge_got_with (bfd2got
, arg
->primary
, arg
);
4353 /* If we can merge with the last-created got, do it. */
4356 result
= mips_elf_merge_got_with (bfd2got
, arg
->current
, arg
);
4361 /* Well, we couldn't merge, so create a new GOT. Don't check if it
4362 fits; if it turns out that it doesn't, we'll get relocation
4363 overflows anyway. */
4364 g
->next
= arg
->current
;
4370 /* ENTRYP is a hash table entry for a mips_got_entry. Set its gotidx
4371 to GOTIDX, duplicating the entry if it has already been assigned
4372 an index in a different GOT. */
4375 mips_elf_set_gotidx (void **entryp
, long gotidx
)
4377 struct mips_got_entry
*entry
;
4379 entry
= (struct mips_got_entry
*) *entryp
;
4380 if (entry
->gotidx
> 0)
4382 struct mips_got_entry
*new_entry
;
4384 new_entry
= bfd_alloc (entry
->abfd
, sizeof (*entry
));
4388 *new_entry
= *entry
;
4389 *entryp
= new_entry
;
4392 entry
->gotidx
= gotidx
;
4396 /* Set the TLS GOT index for the GOT entry in ENTRYP. DATA points to a
4397 mips_elf_traverse_got_arg in which DATA->value is the size of one
4398 GOT entry. Set DATA->g to null on failure. */
4401 mips_elf_initialize_tls_index (void **entryp
, void *data
)
4403 struct mips_got_entry
*entry
;
4404 struct mips_elf_traverse_got_arg
*arg
;
4405 struct mips_got_info
*g
;
4407 unsigned char tls_type
;
4409 /* We're only interested in TLS symbols. */
4410 entry
= (struct mips_got_entry
*) *entryp
;
4411 tls_type
= (entry
->tls_type
& GOT_TLS_TYPE
);
4415 arg
= (struct mips_elf_traverse_got_arg
*) data
;
4417 next_index
= arg
->value
* g
->tls_assigned_gotno
;
4419 if (entry
->symndx
== -1 && g
->next
== NULL
)
4421 /* A type (3) got entry in the single-GOT case. We use the symbol's
4422 hash table entry to track its index. */
4423 if (tls_type
== GOT_TLS_IE
)
4425 if (entry
->d
.h
->tls_ie_type
& GOT_TLS_OFFSET_DONE
)
4427 entry
->d
.h
->tls_ie_type
|= GOT_TLS_OFFSET_DONE
;
4428 entry
->d
.h
->tls_ie_got_offset
= next_index
;
4432 BFD_ASSERT (tls_type
== GOT_TLS_GD
);
4433 if (entry
->d
.h
->tls_gd_type
& GOT_TLS_OFFSET_DONE
)
4435 entry
->d
.h
->tls_gd_type
|= GOT_TLS_OFFSET_DONE
;
4436 entry
->d
.h
->tls_gd_got_offset
= next_index
;
4441 if (tls_type
== GOT_TLS_LDM
)
4443 /* There are separate mips_got_entry objects for each input bfd
4444 that requires an LDM entry. Make sure that all LDM entries in
4445 a GOT resolve to the same index. */
4446 if (g
->tls_ldm_offset
!= MINUS_TWO
&& g
->tls_ldm_offset
!= MINUS_ONE
)
4448 entry
->gotidx
= g
->tls_ldm_offset
;
4451 g
->tls_ldm_offset
= next_index
;
4453 if (!mips_elf_set_gotidx (entryp
, next_index
))
4460 /* Account for the entries we've just allocated. */
4461 g
->tls_assigned_gotno
+= mips_tls_got_entries (tls_type
);
4465 /* A htab_traverse callback for GOT entries, where DATA points to a
4466 mips_elf_traverse_got_arg. Set the global_got_area of each global
4467 symbol to DATA->value. */
4470 mips_elf_set_global_got_area (void **entryp
, void *data
)
4472 struct mips_got_entry
*entry
;
4473 struct mips_elf_traverse_got_arg
*arg
;
4475 entry
= (struct mips_got_entry
*) *entryp
;
4476 arg
= (struct mips_elf_traverse_got_arg
*) data
;
4477 if (entry
->abfd
!= NULL
4478 && entry
->symndx
== -1
4479 && entry
->d
.h
->global_got_area
!= GGA_NONE
)
4480 entry
->d
.h
->global_got_area
= arg
->value
;
4484 /* A htab_traverse callback for secondary GOT entries, where DATA points
4485 to a mips_elf_traverse_got_arg. Assign GOT indices to global entries
4486 and record the number of relocations they require. DATA->value is
4487 the size of one GOT entry. Set DATA->g to null on failure. */
4490 mips_elf_set_global_gotidx (void **entryp
, void *data
)
4492 struct mips_got_entry
*entry
;
4493 struct mips_elf_traverse_got_arg
*arg
;
4495 entry
= (struct mips_got_entry
*) *entryp
;
4496 arg
= (struct mips_elf_traverse_got_arg
*) data
;
4497 if (entry
->abfd
!= NULL
4498 && entry
->symndx
== -1
4499 && entry
->d
.h
->global_got_area
!= GGA_NONE
)
4501 if (!mips_elf_set_gotidx (entryp
, arg
->value
* arg
->g
->assigned_gotno
))
4506 arg
->g
->assigned_gotno
+= 1;
4508 if (arg
->info
->shared
4509 || (elf_hash_table (arg
->info
)->dynamic_sections_created
4510 && entry
->d
.h
->root
.def_dynamic
4511 && !entry
->d
.h
->root
.def_regular
))
4512 arg
->g
->relocs
+= 1;
4518 /* A htab_traverse callback for GOT entries for which DATA is the
4519 bfd_link_info. Forbid any global symbols from having traditional
4520 lazy-binding stubs. */
4523 mips_elf_forbid_lazy_stubs (void **entryp
, void *data
)
4525 struct bfd_link_info
*info
;
4526 struct mips_elf_link_hash_table
*htab
;
4527 struct mips_got_entry
*entry
;
4529 entry
= (struct mips_got_entry
*) *entryp
;
4530 info
= (struct bfd_link_info
*) data
;
4531 htab
= mips_elf_hash_table (info
);
4532 BFD_ASSERT (htab
!= NULL
);
4534 if (entry
->abfd
!= NULL
4535 && entry
->symndx
== -1
4536 && entry
->d
.h
->needs_lazy_stub
)
4538 entry
->d
.h
->needs_lazy_stub
= FALSE
;
4539 htab
->lazy_stub_count
--;
4545 /* Return the offset of an input bfd IBFD's GOT from the beginning of
4548 mips_elf_adjust_gp (bfd
*abfd
, struct mips_got_info
*g
, bfd
*ibfd
)
4550 if (g
->bfd2got
== NULL
)
4553 g
= mips_elf_got_for_ibfd (g
, ibfd
);
4557 BFD_ASSERT (g
->next
);
4561 return (g
->local_gotno
+ g
->global_gotno
+ g
->tls_gotno
)
4562 * MIPS_ELF_GOT_SIZE (abfd
);
4565 /* Turn a single GOT that is too big for 16-bit addressing into
4566 a sequence of GOTs, each one 16-bit addressable. */
4569 mips_elf_multi_got (bfd
*abfd
, struct bfd_link_info
*info
,
4570 asection
*got
, bfd_size_type pages
)
4572 struct mips_elf_link_hash_table
*htab
;
4573 struct mips_elf_got_per_bfd_arg got_per_bfd_arg
;
4574 struct mips_elf_traverse_got_arg tga
;
4575 struct mips_got_info
*g
, *gg
;
4576 unsigned int assign
, needed_relocs
;
4579 dynobj
= elf_hash_table (info
)->dynobj
;
4580 htab
= mips_elf_hash_table (info
);
4581 BFD_ASSERT (htab
!= NULL
);
4584 g
->bfd2got
= htab_try_create (1, mips_elf_bfd2got_entry_hash
,
4585 mips_elf_bfd2got_entry_eq
, NULL
);
4586 if (g
->bfd2got
== NULL
)
4589 got_per_bfd_arg
.bfd2got
= g
->bfd2got
;
4590 got_per_bfd_arg
.obfd
= abfd
;
4591 got_per_bfd_arg
.info
= info
;
4593 /* Count how many GOT entries each input bfd requires, creating a
4594 map from bfd to got info while at that. */
4595 htab_traverse (g
->got_entries
, mips_elf_make_got_per_bfd
, &got_per_bfd_arg
);
4596 if (got_per_bfd_arg
.obfd
== NULL
)
4599 /* Also count how many page entries each input bfd requires. */
4600 htab_traverse (g
->got_page_entries
, mips_elf_make_got_pages_per_bfd
,
4602 if (got_per_bfd_arg
.obfd
== NULL
)
4605 got_per_bfd_arg
.current
= NULL
;
4606 got_per_bfd_arg
.primary
= NULL
;
4607 got_per_bfd_arg
.max_count
= ((MIPS_ELF_GOT_MAX_SIZE (info
)
4608 / MIPS_ELF_GOT_SIZE (abfd
))
4609 - htab
->reserved_gotno
);
4610 got_per_bfd_arg
.max_pages
= pages
;
4611 /* The number of globals that will be included in the primary GOT.
4612 See the calls to mips_elf_set_global_got_area below for more
4614 got_per_bfd_arg
.global_count
= g
->global_gotno
;
4616 /* Try to merge the GOTs of input bfds together, as long as they
4617 don't seem to exceed the maximum GOT size, choosing one of them
4618 to be the primary GOT. */
4619 htab_traverse (g
->bfd2got
, mips_elf_merge_gots
, &got_per_bfd_arg
);
4620 if (got_per_bfd_arg
.obfd
== NULL
)
4623 /* If we do not find any suitable primary GOT, create an empty one. */
4624 if (got_per_bfd_arg
.primary
== NULL
)
4625 g
->next
= mips_elf_create_got_info (abfd
, FALSE
);
4627 g
->next
= got_per_bfd_arg
.primary
;
4628 g
->next
->next
= got_per_bfd_arg
.current
;
4630 /* GG is now the master GOT, and G is the primary GOT. */
4634 /* Map the output bfd to the primary got. That's what we're going
4635 to use for bfds that use GOT16 or GOT_PAGE relocations that we
4636 didn't mark in check_relocs, and we want a quick way to find it.
4637 We can't just use gg->next because we're going to reverse the
4640 struct mips_elf_bfd2got_hash
*bfdgot
;
4643 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
4644 (abfd
, sizeof (struct mips_elf_bfd2got_hash
));
4651 bfdgotp
= htab_find_slot (gg
->bfd2got
, bfdgot
, INSERT
);
4653 BFD_ASSERT (*bfdgotp
== NULL
);
4657 /* Every symbol that is referenced in a dynamic relocation must be
4658 present in the primary GOT, so arrange for them to appear after
4659 those that are actually referenced. */
4660 gg
->reloc_only_gotno
= gg
->global_gotno
- g
->global_gotno
;
4661 g
->global_gotno
= gg
->global_gotno
;
4664 tga
.value
= GGA_RELOC_ONLY
;
4665 htab_traverse (gg
->got_entries
, mips_elf_set_global_got_area
, &tga
);
4666 tga
.value
= GGA_NORMAL
;
4667 htab_traverse (g
->got_entries
, mips_elf_set_global_got_area
, &tga
);
4669 /* Now go through the GOTs assigning them offset ranges.
4670 [assigned_gotno, local_gotno[ will be set to the range of local
4671 entries in each GOT. We can then compute the end of a GOT by
4672 adding local_gotno to global_gotno. We reverse the list and make
4673 it circular since then we'll be able to quickly compute the
4674 beginning of a GOT, by computing the end of its predecessor. To
4675 avoid special cases for the primary GOT, while still preserving
4676 assertions that are valid for both single- and multi-got links,
4677 we arrange for the main got struct to have the right number of
4678 global entries, but set its local_gotno such that the initial
4679 offset of the primary GOT is zero. Remember that the primary GOT
4680 will become the last item in the circular linked list, so it
4681 points back to the master GOT. */
4682 gg
->local_gotno
= -g
->global_gotno
;
4683 gg
->global_gotno
= g
->global_gotno
;
4690 struct mips_got_info
*gn
;
4692 assign
+= htab
->reserved_gotno
;
4693 g
->assigned_gotno
= assign
;
4694 g
->local_gotno
+= assign
;
4695 g
->local_gotno
+= (pages
< g
->page_gotno
? pages
: g
->page_gotno
);
4696 assign
= g
->local_gotno
+ g
->global_gotno
+ g
->tls_gotno
;
4698 /* Take g out of the direct list, and push it onto the reversed
4699 list that gg points to. g->next is guaranteed to be nonnull after
4700 this operation, as required by mips_elf_initialize_tls_index. */
4705 /* Set up any TLS entries. We always place the TLS entries after
4706 all non-TLS entries. */
4707 g
->tls_assigned_gotno
= g
->local_gotno
+ g
->global_gotno
;
4709 tga
.value
= MIPS_ELF_GOT_SIZE (abfd
);
4710 htab_traverse (g
->got_entries
, mips_elf_initialize_tls_index
, &tga
);
4713 BFD_ASSERT (g
->tls_assigned_gotno
== assign
);
4715 /* Move onto the next GOT. It will be a secondary GOT if nonull. */
4718 /* Forbid global symbols in every non-primary GOT from having
4719 lazy-binding stubs. */
4721 htab_traverse (g
->got_entries
, mips_elf_forbid_lazy_stubs
, info
);
4725 got
->size
= assign
* MIPS_ELF_GOT_SIZE (abfd
);
4728 for (g
= gg
->next
; g
&& g
->next
!= gg
; g
= g
->next
)
4730 unsigned int save_assign
;
4732 /* Assign offsets to global GOT entries and count how many
4733 relocations they need. */
4734 save_assign
= g
->assigned_gotno
;
4735 g
->assigned_gotno
= g
->local_gotno
;
4737 tga
.value
= MIPS_ELF_GOT_SIZE (abfd
);
4739 htab_traverse (g
->got_entries
, mips_elf_set_global_gotidx
, &tga
);
4742 BFD_ASSERT (g
->assigned_gotno
== g
->local_gotno
+ g
->global_gotno
);
4743 g
->assigned_gotno
= save_assign
;
4747 g
->relocs
+= g
->local_gotno
- g
->assigned_gotno
;
4748 BFD_ASSERT (g
->assigned_gotno
== g
->next
->local_gotno
4749 + g
->next
->global_gotno
4750 + g
->next
->tls_gotno
4751 + htab
->reserved_gotno
);
4753 needed_relocs
+= g
->relocs
;
4755 needed_relocs
+= g
->relocs
;
4758 mips_elf_allocate_dynamic_relocations (dynobj
, info
,
4765 /* Returns the first relocation of type r_type found, beginning with
4766 RELOCATION. RELEND is one-past-the-end of the relocation table. */
4768 static const Elf_Internal_Rela
*
4769 mips_elf_next_relocation (bfd
*abfd ATTRIBUTE_UNUSED
, unsigned int r_type
,
4770 const Elf_Internal_Rela
*relocation
,
4771 const Elf_Internal_Rela
*relend
)
4773 unsigned long r_symndx
= ELF_R_SYM (abfd
, relocation
->r_info
);
4775 while (relocation
< relend
)
4777 if (ELF_R_TYPE (abfd
, relocation
->r_info
) == r_type
4778 && ELF_R_SYM (abfd
, relocation
->r_info
) == r_symndx
)
4784 /* We didn't find it. */
4788 /* Return whether an input relocation is against a local symbol. */
4791 mips_elf_local_relocation_p (bfd
*input_bfd
,
4792 const Elf_Internal_Rela
*relocation
,
4793 asection
**local_sections
)
4795 unsigned long r_symndx
;
4796 Elf_Internal_Shdr
*symtab_hdr
;
4799 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
4800 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
4801 extsymoff
= (elf_bad_symtab (input_bfd
)) ? 0 : symtab_hdr
->sh_info
;
4803 if (r_symndx
< extsymoff
)
4805 if (elf_bad_symtab (input_bfd
) && local_sections
[r_symndx
] != NULL
)
4811 /* Sign-extend VALUE, which has the indicated number of BITS. */
4814 _bfd_mips_elf_sign_extend (bfd_vma value
, int bits
)
4816 if (value
& ((bfd_vma
) 1 << (bits
- 1)))
4817 /* VALUE is negative. */
4818 value
|= ((bfd_vma
) - 1) << bits
;
4823 /* Return non-zero if the indicated VALUE has overflowed the maximum
4824 range expressible by a signed number with the indicated number of
4828 mips_elf_overflow_p (bfd_vma value
, int bits
)
4830 bfd_signed_vma svalue
= (bfd_signed_vma
) value
;
4832 if (svalue
> (1 << (bits
- 1)) - 1)
4833 /* The value is too big. */
4835 else if (svalue
< -(1 << (bits
- 1)))
4836 /* The value is too small. */
4843 /* Calculate the %high function. */
4846 mips_elf_high (bfd_vma value
)
4848 return ((value
+ (bfd_vma
) 0x8000) >> 16) & 0xffff;
4851 /* Calculate the %higher function. */
4854 mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED
)
4857 return ((value
+ (bfd_vma
) 0x80008000) >> 32) & 0xffff;
4864 /* Calculate the %highest function. */
4867 mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED
)
4870 return ((value
+ (((bfd_vma
) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
4877 /* Create the .compact_rel section. */
4880 mips_elf_create_compact_rel_section
4881 (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
4884 register asection
*s
;
4886 if (bfd_get_linker_section (abfd
, ".compact_rel") == NULL
)
4888 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
4891 s
= bfd_make_section_anyway_with_flags (abfd
, ".compact_rel", flags
);
4893 || ! bfd_set_section_alignment (abfd
, s
,
4894 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
4897 s
->size
= sizeof (Elf32_External_compact_rel
);
4903 /* Create the .got section to hold the global offset table. */
4906 mips_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
4909 register asection
*s
;
4910 struct elf_link_hash_entry
*h
;
4911 struct bfd_link_hash_entry
*bh
;
4912 struct mips_elf_link_hash_table
*htab
;
4914 htab
= mips_elf_hash_table (info
);
4915 BFD_ASSERT (htab
!= NULL
);
4917 /* This function may be called more than once. */
4921 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
4922 | SEC_LINKER_CREATED
);
4924 /* We have to use an alignment of 2**4 here because this is hardcoded
4925 in the function stub generation and in the linker script. */
4926 s
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
4928 || ! bfd_set_section_alignment (abfd
, s
, 4))
4932 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
4933 linker script because we don't want to define the symbol if we
4934 are not creating a global offset table. */
4936 if (! (_bfd_generic_link_add_one_symbol
4937 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
4938 0, NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
4941 h
= (struct elf_link_hash_entry
*) bh
;
4944 h
->type
= STT_OBJECT
;
4945 elf_hash_table (info
)->hgot
= h
;
4948 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
4951 htab
->got_info
= mips_elf_create_got_info (abfd
, TRUE
);
4952 mips_elf_section_data (s
)->elf
.this_hdr
.sh_flags
4953 |= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
4955 /* We also need a .got.plt section when generating PLTs. */
4956 s
= bfd_make_section_anyway_with_flags (abfd
, ".got.plt",
4957 SEC_ALLOC
| SEC_LOAD
4960 | SEC_LINKER_CREATED
);
4968 /* Return true if H refers to the special VxWorks __GOTT_BASE__ or
4969 __GOTT_INDEX__ symbols. These symbols are only special for
4970 shared objects; they are not used in executables. */
4973 is_gott_symbol (struct bfd_link_info
*info
, struct elf_link_hash_entry
*h
)
4975 return (mips_elf_hash_table (info
)->is_vxworks
4977 && (strcmp (h
->root
.root
.string
, "__GOTT_BASE__") == 0
4978 || strcmp (h
->root
.root
.string
, "__GOTT_INDEX__") == 0));
4981 /* Return TRUE if a relocation of type R_TYPE from INPUT_BFD might
4982 require an la25 stub. See also mips_elf_local_pic_function_p,
4983 which determines whether the destination function ever requires a
4987 mips_elf_relocation_needs_la25_stub (bfd
*input_bfd
, int r_type
,
4988 bfd_boolean target_is_16_bit_code_p
)
4990 /* We specifically ignore branches and jumps from EF_PIC objects,
4991 where the onus is on the compiler or programmer to perform any
4992 necessary initialization of $25. Sometimes such initialization
4993 is unnecessary; for example, -mno-shared functions do not use
4994 the incoming value of $25, and may therefore be called directly. */
4995 if (PIC_OBJECT_P (input_bfd
))
5002 case R_MICROMIPS_26_S1
:
5003 case R_MICROMIPS_PC7_S1
:
5004 case R_MICROMIPS_PC10_S1
:
5005 case R_MICROMIPS_PC16_S1
:
5006 case R_MICROMIPS_PC23_S2
:
5010 return !target_is_16_bit_code_p
;
5017 /* Calculate the value produced by the RELOCATION (which comes from
5018 the INPUT_BFD). The ADDEND is the addend to use for this
5019 RELOCATION; RELOCATION->R_ADDEND is ignored.
5021 The result of the relocation calculation is stored in VALUEP.
5022 On exit, set *CROSS_MODE_JUMP_P to true if the relocation field
5023 is a MIPS16 or microMIPS jump to standard MIPS code, or vice versa.
5025 This function returns bfd_reloc_continue if the caller need take no
5026 further action regarding this relocation, bfd_reloc_notsupported if
5027 something goes dramatically wrong, bfd_reloc_overflow if an
5028 overflow occurs, and bfd_reloc_ok to indicate success. */
5030 static bfd_reloc_status_type
5031 mips_elf_calculate_relocation (bfd
*abfd
, bfd
*input_bfd
,
5032 asection
*input_section
,
5033 struct bfd_link_info
*info
,
5034 const Elf_Internal_Rela
*relocation
,
5035 bfd_vma addend
, reloc_howto_type
*howto
,
5036 Elf_Internal_Sym
*local_syms
,
5037 asection
**local_sections
, bfd_vma
*valuep
,
5039 bfd_boolean
*cross_mode_jump_p
,
5040 bfd_boolean save_addend
)
5042 /* The eventual value we will return. */
5044 /* The address of the symbol against which the relocation is
5047 /* The final GP value to be used for the relocatable, executable, or
5048 shared object file being produced. */
5050 /* The place (section offset or address) of the storage unit being
5053 /* The value of GP used to create the relocatable object. */
5055 /* The offset into the global offset table at which the address of
5056 the relocation entry symbol, adjusted by the addend, resides
5057 during execution. */
5058 bfd_vma g
= MINUS_ONE
;
5059 /* The section in which the symbol referenced by the relocation is
5061 asection
*sec
= NULL
;
5062 struct mips_elf_link_hash_entry
*h
= NULL
;
5063 /* TRUE if the symbol referred to by this relocation is a local
5065 bfd_boolean local_p
, was_local_p
;
5066 /* TRUE if the symbol referred to by this relocation is "_gp_disp". */
5067 bfd_boolean gp_disp_p
= FALSE
;
5068 /* TRUE if the symbol referred to by this relocation is
5069 "__gnu_local_gp". */
5070 bfd_boolean gnu_local_gp_p
= FALSE
;
5071 Elf_Internal_Shdr
*symtab_hdr
;
5073 unsigned long r_symndx
;
5075 /* TRUE if overflow occurred during the calculation of the
5076 relocation value. */
5077 bfd_boolean overflowed_p
;
5078 /* TRUE if this relocation refers to a MIPS16 function. */
5079 bfd_boolean target_is_16_bit_code_p
= FALSE
;
5080 bfd_boolean target_is_micromips_code_p
= FALSE
;
5081 struct mips_elf_link_hash_table
*htab
;
5084 dynobj
= elf_hash_table (info
)->dynobj
;
5085 htab
= mips_elf_hash_table (info
);
5086 BFD_ASSERT (htab
!= NULL
);
5088 /* Parse the relocation. */
5089 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
5090 r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
5091 p
= (input_section
->output_section
->vma
5092 + input_section
->output_offset
5093 + relocation
->r_offset
);
5095 /* Assume that there will be no overflow. */
5096 overflowed_p
= FALSE
;
5098 /* Figure out whether or not the symbol is local, and get the offset
5099 used in the array of hash table entries. */
5100 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
5101 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
5103 was_local_p
= local_p
;
5104 if (! elf_bad_symtab (input_bfd
))
5105 extsymoff
= symtab_hdr
->sh_info
;
5108 /* The symbol table does not follow the rule that local symbols
5109 must come before globals. */
5113 /* Figure out the value of the symbol. */
5116 Elf_Internal_Sym
*sym
;
5118 sym
= local_syms
+ r_symndx
;
5119 sec
= local_sections
[r_symndx
];
5121 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
5122 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
5123 || (sec
->flags
& SEC_MERGE
))
5124 symbol
+= sym
->st_value
;
5125 if ((sec
->flags
& SEC_MERGE
)
5126 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
5128 addend
= _bfd_elf_rel_local_sym (abfd
, sym
, &sec
, addend
);
5130 addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
5133 /* MIPS16/microMIPS text labels should be treated as odd. */
5134 if (ELF_ST_IS_COMPRESSED (sym
->st_other
))
5137 /* Record the name of this symbol, for our caller. */
5138 *namep
= bfd_elf_string_from_elf_section (input_bfd
,
5139 symtab_hdr
->sh_link
,
5142 *namep
= bfd_section_name (input_bfd
, sec
);
5144 target_is_16_bit_code_p
= ELF_ST_IS_MIPS16 (sym
->st_other
);
5145 target_is_micromips_code_p
= ELF_ST_IS_MICROMIPS (sym
->st_other
);
5149 /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ? */
5151 /* For global symbols we look up the symbol in the hash-table. */
5152 h
= ((struct mips_elf_link_hash_entry
*)
5153 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
]);
5154 /* Find the real hash-table entry for this symbol. */
5155 while (h
->root
.root
.type
== bfd_link_hash_indirect
5156 || h
->root
.root
.type
== bfd_link_hash_warning
)
5157 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
5159 /* Record the name of this symbol, for our caller. */
5160 *namep
= h
->root
.root
.root
.string
;
5162 /* See if this is the special _gp_disp symbol. Note that such a
5163 symbol must always be a global symbol. */
5164 if (strcmp (*namep
, "_gp_disp") == 0
5165 && ! NEWABI_P (input_bfd
))
5167 /* Relocations against _gp_disp are permitted only with
5168 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
5169 if (!hi16_reloc_p (r_type
) && !lo16_reloc_p (r_type
))
5170 return bfd_reloc_notsupported
;
5174 /* See if this is the special _gp symbol. Note that such a
5175 symbol must always be a global symbol. */
5176 else if (strcmp (*namep
, "__gnu_local_gp") == 0)
5177 gnu_local_gp_p
= TRUE
;
5180 /* If this symbol is defined, calculate its address. Note that
5181 _gp_disp is a magic symbol, always implicitly defined by the
5182 linker, so it's inappropriate to check to see whether or not
5184 else if ((h
->root
.root
.type
== bfd_link_hash_defined
5185 || h
->root
.root
.type
== bfd_link_hash_defweak
)
5186 && h
->root
.root
.u
.def
.section
)
5188 sec
= h
->root
.root
.u
.def
.section
;
5189 if (sec
->output_section
)
5190 symbol
= (h
->root
.root
.u
.def
.value
5191 + sec
->output_section
->vma
5192 + sec
->output_offset
);
5194 symbol
= h
->root
.root
.u
.def
.value
;
5196 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
5197 /* We allow relocations against undefined weak symbols, giving
5198 it the value zero, so that you can undefined weak functions
5199 and check to see if they exist by looking at their
5202 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
5203 && ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
5205 else if (strcmp (*namep
, SGI_COMPAT (input_bfd
)
5206 ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING") == 0)
5208 /* If this is a dynamic link, we should have created a
5209 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
5210 in in _bfd_mips_elf_create_dynamic_sections.
5211 Otherwise, we should define the symbol with a value of 0.
5212 FIXME: It should probably get into the symbol table
5214 BFD_ASSERT (! info
->shared
);
5215 BFD_ASSERT (bfd_get_section_by_name (abfd
, ".dynamic") == NULL
);
5218 else if (ELF_MIPS_IS_OPTIONAL (h
->root
.other
))
5220 /* This is an optional symbol - an Irix specific extension to the
5221 ELF spec. Ignore it for now.
5222 XXX - FIXME - there is more to the spec for OPTIONAL symbols
5223 than simply ignoring them, but we do not handle this for now.
5224 For information see the "64-bit ELF Object File Specification"
5225 which is available from here:
5226 http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf */
5229 else if ((*info
->callbacks
->undefined_symbol
)
5230 (info
, h
->root
.root
.root
.string
, input_bfd
,
5231 input_section
, relocation
->r_offset
,
5232 (info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
)
5233 || ELF_ST_VISIBILITY (h
->root
.other
)))
5235 return bfd_reloc_undefined
;
5239 return bfd_reloc_notsupported
;
5242 target_is_16_bit_code_p
= ELF_ST_IS_MIPS16 (h
->root
.other
);
5243 /* If the output section is the PLT section,
5244 then the target is not microMIPS. */
5245 target_is_micromips_code_p
= (htab
->splt
!= sec
5246 && ELF_ST_IS_MICROMIPS (h
->root
.other
));
5249 /* If this is a reference to a 16-bit function with a stub, we need
5250 to redirect the relocation to the stub unless:
5252 (a) the relocation is for a MIPS16 JAL;
5254 (b) the relocation is for a MIPS16 PIC call, and there are no
5255 non-MIPS16 uses of the GOT slot; or
5257 (c) the section allows direct references to MIPS16 functions. */
5258 if (r_type
!= R_MIPS16_26
5259 && !info
->relocatable
5261 && h
->fn_stub
!= NULL
5262 && (r_type
!= R_MIPS16_CALL16
|| h
->need_fn_stub
))
5264 && elf_tdata (input_bfd
)->local_stubs
!= NULL
5265 && elf_tdata (input_bfd
)->local_stubs
[r_symndx
] != NULL
))
5266 && !section_allows_mips16_refs_p (input_section
))
5268 /* This is a 32- or 64-bit call to a 16-bit function. We should
5269 have already noticed that we were going to need the
5273 sec
= elf_tdata (input_bfd
)->local_stubs
[r_symndx
];
5278 BFD_ASSERT (h
->need_fn_stub
);
5281 /* If a LA25 header for the stub itself exists, point to the
5282 prepended LUI/ADDIU sequence. */
5283 sec
= h
->la25_stub
->stub_section
;
5284 value
= h
->la25_stub
->offset
;
5293 symbol
= sec
->output_section
->vma
+ sec
->output_offset
+ value
;
5294 /* The target is 16-bit, but the stub isn't. */
5295 target_is_16_bit_code_p
= FALSE
;
5297 /* If this is a 16-bit call to a 32- or 64-bit function with a stub, we
5298 need to redirect the call to the stub. Note that we specifically
5299 exclude R_MIPS16_CALL16 from this behavior; indirect calls should
5300 use an indirect stub instead. */
5301 else if (r_type
== R_MIPS16_26
&& !info
->relocatable
5302 && ((h
!= NULL
&& (h
->call_stub
!= NULL
|| h
->call_fp_stub
!= NULL
))
5304 && elf_tdata (input_bfd
)->local_call_stubs
!= NULL
5305 && elf_tdata (input_bfd
)->local_call_stubs
[r_symndx
] != NULL
))
5306 && !target_is_16_bit_code_p
)
5309 sec
= elf_tdata (input_bfd
)->local_call_stubs
[r_symndx
];
5312 /* If both call_stub and call_fp_stub are defined, we can figure
5313 out which one to use by checking which one appears in the input
5315 if (h
->call_stub
!= NULL
&& h
->call_fp_stub
!= NULL
)
5320 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
5322 if (CALL_FP_STUB_P (bfd_get_section_name (input_bfd
, o
)))
5324 sec
= h
->call_fp_stub
;
5331 else if (h
->call_stub
!= NULL
)
5334 sec
= h
->call_fp_stub
;
5337 BFD_ASSERT (sec
->size
> 0);
5338 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
5340 /* If this is a direct call to a PIC function, redirect to the
5342 else if (h
!= NULL
&& h
->la25_stub
5343 && mips_elf_relocation_needs_la25_stub (input_bfd
, r_type
,
5344 target_is_16_bit_code_p
))
5345 symbol
= (h
->la25_stub
->stub_section
->output_section
->vma
5346 + h
->la25_stub
->stub_section
->output_offset
5347 + h
->la25_stub
->offset
);
5349 /* Make sure MIPS16 and microMIPS are not used together. */
5350 if ((r_type
== R_MIPS16_26
&& target_is_micromips_code_p
)
5351 || (micromips_branch_reloc_p (r_type
) && target_is_16_bit_code_p
))
5353 (*_bfd_error_handler
)
5354 (_("MIPS16 and microMIPS functions cannot call each other"));
5355 return bfd_reloc_notsupported
;
5358 /* Calls from 16-bit code to 32-bit code and vice versa require the
5359 mode change. However, we can ignore calls to undefined weak symbols,
5360 which should never be executed at runtime. This exception is important
5361 because the assembly writer may have "known" that any definition of the
5362 symbol would be 16-bit code, and that direct jumps were therefore
5364 *cross_mode_jump_p
= (!info
->relocatable
5365 && !(h
&& h
->root
.root
.type
== bfd_link_hash_undefweak
)
5366 && ((r_type
== R_MIPS16_26
&& !target_is_16_bit_code_p
)
5367 || (r_type
== R_MICROMIPS_26_S1
5368 && !target_is_micromips_code_p
)
5369 || ((r_type
== R_MIPS_26
|| r_type
== R_MIPS_JALR
)
5370 && (target_is_16_bit_code_p
5371 || target_is_micromips_code_p
))));
5373 local_p
= (h
== NULL
5374 || (h
->got_only_for_calls
5375 ? SYMBOL_CALLS_LOCAL (info
, &h
->root
)
5376 : SYMBOL_REFERENCES_LOCAL (info
, &h
->root
)));
5378 gp0
= _bfd_get_gp_value (input_bfd
);
5379 gp
= _bfd_get_gp_value (abfd
);
5381 gp
+= mips_elf_adjust_gp (abfd
, htab
->got_info
, input_bfd
);
5386 /* Global R_MIPS_GOT_PAGE/R_MICROMIPS_GOT_PAGE relocations are equivalent
5387 to R_MIPS_GOT_DISP/R_MICROMIPS_GOT_DISP. The addend is applied by the
5388 corresponding R_MIPS_GOT_OFST/R_MICROMIPS_GOT_OFST. */
5389 if (got_page_reloc_p (r_type
) && !local_p
)
5391 r_type
= (micromips_reloc_p (r_type
)
5392 ? R_MICROMIPS_GOT_DISP
: R_MIPS_GOT_DISP
);
5396 /* If we haven't already determined the GOT offset, and we're going
5397 to need it, get it now. */
5400 case R_MIPS16_CALL16
:
5401 case R_MIPS16_GOT16
:
5404 case R_MIPS_GOT_DISP
:
5405 case R_MIPS_GOT_HI16
:
5406 case R_MIPS_CALL_HI16
:
5407 case R_MIPS_GOT_LO16
:
5408 case R_MIPS_CALL_LO16
:
5409 case R_MICROMIPS_CALL16
:
5410 case R_MICROMIPS_GOT16
:
5411 case R_MICROMIPS_GOT_DISP
:
5412 case R_MICROMIPS_GOT_HI16
:
5413 case R_MICROMIPS_CALL_HI16
:
5414 case R_MICROMIPS_GOT_LO16
:
5415 case R_MICROMIPS_CALL_LO16
:
5417 case R_MIPS_TLS_GOTTPREL
:
5418 case R_MIPS_TLS_LDM
:
5419 case R_MIPS16_TLS_GD
:
5420 case R_MIPS16_TLS_GOTTPREL
:
5421 case R_MIPS16_TLS_LDM
:
5422 case R_MICROMIPS_TLS_GD
:
5423 case R_MICROMIPS_TLS_GOTTPREL
:
5424 case R_MICROMIPS_TLS_LDM
:
5425 /* Find the index into the GOT where this value is located. */
5426 if (tls_ldm_reloc_p (r_type
))
5428 g
= mips_elf_local_got_index (abfd
, input_bfd
, info
,
5429 0, 0, NULL
, r_type
);
5431 return bfd_reloc_outofrange
;
5435 /* On VxWorks, CALL relocations should refer to the .got.plt
5436 entry, which is initialized to point at the PLT stub. */
5437 if (htab
->is_vxworks
5438 && (call_hi16_reloc_p (r_type
)
5439 || call_lo16_reloc_p (r_type
)
5440 || call16_reloc_p (r_type
)))
5442 BFD_ASSERT (addend
== 0);
5443 BFD_ASSERT (h
->root
.needs_plt
);
5444 g
= mips_elf_gotplt_index (info
, &h
->root
);
5448 BFD_ASSERT (addend
== 0);
5449 g
= mips_elf_global_got_index (dynobj
, input_bfd
,
5450 &h
->root
, r_type
, info
);
5451 if (!TLS_RELOC_P (r_type
)
5452 && !elf_hash_table (info
)->dynamic_sections_created
)
5453 /* This is a static link. We must initialize the GOT entry. */
5454 MIPS_ELF_PUT_WORD (dynobj
, symbol
, htab
->sgot
->contents
+ g
);
5457 else if (!htab
->is_vxworks
5458 && (call16_reloc_p (r_type
) || got16_reloc_p (r_type
)))
5459 /* The calculation below does not involve "g". */
5463 g
= mips_elf_local_got_index (abfd
, input_bfd
, info
,
5464 symbol
+ addend
, r_symndx
, h
, r_type
);
5466 return bfd_reloc_outofrange
;
5469 /* Convert GOT indices to actual offsets. */
5470 g
= mips_elf_got_offset_from_index (info
, abfd
, input_bfd
, g
);
5474 /* Relocations against the VxWorks __GOTT_BASE__ and __GOTT_INDEX__
5475 symbols are resolved by the loader. Add them to .rela.dyn. */
5476 if (h
!= NULL
&& is_gott_symbol (info
, &h
->root
))
5478 Elf_Internal_Rela outrel
;
5482 s
= mips_elf_rel_dyn_section (info
, FALSE
);
5483 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
5485 outrel
.r_offset
= (input_section
->output_section
->vma
5486 + input_section
->output_offset
5487 + relocation
->r_offset
);
5488 outrel
.r_info
= ELF32_R_INFO (h
->root
.dynindx
, r_type
);
5489 outrel
.r_addend
= addend
;
5490 bfd_elf32_swap_reloca_out (abfd
, &outrel
, loc
);
5492 /* If we've written this relocation for a readonly section,
5493 we need to set DF_TEXTREL again, so that we do not delete the
5495 if (MIPS_ELF_READONLY_SECTION (input_section
))
5496 info
->flags
|= DF_TEXTREL
;
5499 return bfd_reloc_ok
;
5502 /* Figure out what kind of relocation is being performed. */
5506 return bfd_reloc_continue
;
5509 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 16);
5510 overflowed_p
= mips_elf_overflow_p (value
, 16);
5517 || (htab
->root
.dynamic_sections_created
5519 && h
->root
.def_dynamic
5520 && !h
->root
.def_regular
5521 && !h
->has_static_relocs
))
5522 && r_symndx
!= STN_UNDEF
5524 || h
->root
.root
.type
!= bfd_link_hash_undefweak
5525 || ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
5526 && (input_section
->flags
& SEC_ALLOC
) != 0)
5528 /* If we're creating a shared library, then we can't know
5529 where the symbol will end up. So, we create a relocation
5530 record in the output, and leave the job up to the dynamic
5531 linker. We must do the same for executable references to
5532 shared library symbols, unless we've decided to use copy
5533 relocs or PLTs instead. */
5535 if (!mips_elf_create_dynamic_relocation (abfd
,
5543 return bfd_reloc_undefined
;
5547 if (r_type
!= R_MIPS_REL32
)
5548 value
= symbol
+ addend
;
5552 value
&= howto
->dst_mask
;
5556 value
= symbol
+ addend
- p
;
5557 value
&= howto
->dst_mask
;
5561 /* The calculation for R_MIPS16_26 is just the same as for an
5562 R_MIPS_26. It's only the storage of the relocated field into
5563 the output file that's different. That's handled in
5564 mips_elf_perform_relocation. So, we just fall through to the
5565 R_MIPS_26 case here. */
5567 case R_MICROMIPS_26_S1
:
5571 /* Make sure the target of JALX is word-aligned. Bit 0 must be
5572 the correct ISA mode selector and bit 1 must be 0. */
5573 if (*cross_mode_jump_p
&& (symbol
& 3) != (r_type
== R_MIPS_26
))
5574 return bfd_reloc_outofrange
;
5576 /* Shift is 2, unusually, for microMIPS JALX. */
5577 shift
= (!*cross_mode_jump_p
&& r_type
== R_MICROMIPS_26_S1
) ? 1 : 2;
5580 value
= addend
| ((p
+ 4) & (0xfc000000 << shift
));
5582 value
= _bfd_mips_elf_sign_extend (addend
, 26 + shift
);
5583 value
= (value
+ symbol
) >> shift
;
5584 if (!was_local_p
&& h
->root
.root
.type
!= bfd_link_hash_undefweak
)
5585 overflowed_p
= (value
>> 26) != ((p
+ 4) >> (26 + shift
));
5586 value
&= howto
->dst_mask
;
5590 case R_MIPS_TLS_DTPREL_HI16
:
5591 case R_MIPS16_TLS_DTPREL_HI16
:
5592 case R_MICROMIPS_TLS_DTPREL_HI16
:
5593 value
= (mips_elf_high (addend
+ symbol
- dtprel_base (info
))
5597 case R_MIPS_TLS_DTPREL_LO16
:
5598 case R_MIPS_TLS_DTPREL32
:
5599 case R_MIPS_TLS_DTPREL64
:
5600 case R_MIPS16_TLS_DTPREL_LO16
:
5601 case R_MICROMIPS_TLS_DTPREL_LO16
:
5602 value
= (symbol
+ addend
- dtprel_base (info
)) & howto
->dst_mask
;
5605 case R_MIPS_TLS_TPREL_HI16
:
5606 case R_MIPS16_TLS_TPREL_HI16
:
5607 case R_MICROMIPS_TLS_TPREL_HI16
:
5608 value
= (mips_elf_high (addend
+ symbol
- tprel_base (info
))
5612 case R_MIPS_TLS_TPREL_LO16
:
5613 case R_MIPS_TLS_TPREL32
:
5614 case R_MIPS_TLS_TPREL64
:
5615 case R_MIPS16_TLS_TPREL_LO16
:
5616 case R_MICROMIPS_TLS_TPREL_LO16
:
5617 value
= (symbol
+ addend
- tprel_base (info
)) & howto
->dst_mask
;
5622 case R_MICROMIPS_HI16
:
5625 value
= mips_elf_high (addend
+ symbol
);
5626 value
&= howto
->dst_mask
;
5630 /* For MIPS16 ABI code we generate this sequence
5631 0: li $v0,%hi(_gp_disp)
5632 4: addiupc $v1,%lo(_gp_disp)
5636 So the offsets of hi and lo relocs are the same, but the
5637 base $pc is that used by the ADDIUPC instruction at $t9 + 4.
5638 ADDIUPC clears the low two bits of the instruction address,
5639 so the base is ($t9 + 4) & ~3. */
5640 if (r_type
== R_MIPS16_HI16
)
5641 value
= mips_elf_high (addend
+ gp
- ((p
+ 4) & ~(bfd_vma
) 0x3));
5642 /* The microMIPS .cpload sequence uses the same assembly
5643 instructions as the traditional psABI version, but the
5644 incoming $t9 has the low bit set. */
5645 else if (r_type
== R_MICROMIPS_HI16
)
5646 value
= mips_elf_high (addend
+ gp
- p
- 1);
5648 value
= mips_elf_high (addend
+ gp
- p
);
5649 overflowed_p
= mips_elf_overflow_p (value
, 16);
5655 case R_MICROMIPS_LO16
:
5656 case R_MICROMIPS_HI0_LO16
:
5658 value
= (symbol
+ addend
) & howto
->dst_mask
;
5661 /* See the comment for R_MIPS16_HI16 above for the reason
5662 for this conditional. */
5663 if (r_type
== R_MIPS16_LO16
)
5664 value
= addend
+ gp
- (p
& ~(bfd_vma
) 0x3);
5665 else if (r_type
== R_MICROMIPS_LO16
5666 || r_type
== R_MICROMIPS_HI0_LO16
)
5667 value
= addend
+ gp
- p
+ 3;
5669 value
= addend
+ gp
- p
+ 4;
5670 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
5671 for overflow. But, on, say, IRIX5, relocations against
5672 _gp_disp are normally generated from the .cpload
5673 pseudo-op. It generates code that normally looks like
5676 lui $gp,%hi(_gp_disp)
5677 addiu $gp,$gp,%lo(_gp_disp)
5680 Here $t9 holds the address of the function being called,
5681 as required by the MIPS ELF ABI. The R_MIPS_LO16
5682 relocation can easily overflow in this situation, but the
5683 R_MIPS_HI16 relocation will handle the overflow.
5684 Therefore, we consider this a bug in the MIPS ABI, and do
5685 not check for overflow here. */
5689 case R_MIPS_LITERAL
:
5690 case R_MICROMIPS_LITERAL
:
5691 /* Because we don't merge literal sections, we can handle this
5692 just like R_MIPS_GPREL16. In the long run, we should merge
5693 shared literals, and then we will need to additional work
5698 case R_MIPS16_GPREL
:
5699 /* The R_MIPS16_GPREL performs the same calculation as
5700 R_MIPS_GPREL16, but stores the relocated bits in a different
5701 order. We don't need to do anything special here; the
5702 differences are handled in mips_elf_perform_relocation. */
5703 case R_MIPS_GPREL16
:
5704 case R_MICROMIPS_GPREL7_S2
:
5705 case R_MICROMIPS_GPREL16
:
5706 /* Only sign-extend the addend if it was extracted from the
5707 instruction. If the addend was separate, leave it alone,
5708 otherwise we may lose significant bits. */
5709 if (howto
->partial_inplace
)
5710 addend
= _bfd_mips_elf_sign_extend (addend
, 16);
5711 value
= symbol
+ addend
- gp
;
5712 /* If the symbol was local, any earlier relocatable links will
5713 have adjusted its addend with the gp offset, so compensate
5714 for that now. Don't do it for symbols forced local in this
5715 link, though, since they won't have had the gp offset applied
5719 overflowed_p
= mips_elf_overflow_p (value
, 16);
5722 case R_MIPS16_GOT16
:
5723 case R_MIPS16_CALL16
:
5726 case R_MICROMIPS_GOT16
:
5727 case R_MICROMIPS_CALL16
:
5728 /* VxWorks does not have separate local and global semantics for
5729 R_MIPS*_GOT16; every relocation evaluates to "G". */
5730 if (!htab
->is_vxworks
&& local_p
)
5732 value
= mips_elf_got16_entry (abfd
, input_bfd
, info
,
5733 symbol
+ addend
, !was_local_p
);
5734 if (value
== MINUS_ONE
)
5735 return bfd_reloc_outofrange
;
5737 = mips_elf_got_offset_from_index (info
, abfd
, input_bfd
, value
);
5738 overflowed_p
= mips_elf_overflow_p (value
, 16);
5745 case R_MIPS_TLS_GOTTPREL
:
5746 case R_MIPS_TLS_LDM
:
5747 case R_MIPS_GOT_DISP
:
5748 case R_MIPS16_TLS_GD
:
5749 case R_MIPS16_TLS_GOTTPREL
:
5750 case R_MIPS16_TLS_LDM
:
5751 case R_MICROMIPS_TLS_GD
:
5752 case R_MICROMIPS_TLS_GOTTPREL
:
5753 case R_MICROMIPS_TLS_LDM
:
5754 case R_MICROMIPS_GOT_DISP
:
5756 overflowed_p
= mips_elf_overflow_p (value
, 16);
5759 case R_MIPS_GPREL32
:
5760 value
= (addend
+ symbol
+ gp0
- gp
);
5762 value
&= howto
->dst_mask
;
5766 case R_MIPS_GNU_REL16_S2
:
5767 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 18) - p
;
5768 overflowed_p
= mips_elf_overflow_p (value
, 18);
5769 value
>>= howto
->rightshift
;
5770 value
&= howto
->dst_mask
;
5773 case R_MICROMIPS_PC7_S1
:
5774 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 8) - p
;
5775 overflowed_p
= mips_elf_overflow_p (value
, 8);
5776 value
>>= howto
->rightshift
;
5777 value
&= howto
->dst_mask
;
5780 case R_MICROMIPS_PC10_S1
:
5781 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 11) - p
;
5782 overflowed_p
= mips_elf_overflow_p (value
, 11);
5783 value
>>= howto
->rightshift
;
5784 value
&= howto
->dst_mask
;
5787 case R_MICROMIPS_PC16_S1
:
5788 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 17) - p
;
5789 overflowed_p
= mips_elf_overflow_p (value
, 17);
5790 value
>>= howto
->rightshift
;
5791 value
&= howto
->dst_mask
;
5794 case R_MICROMIPS_PC23_S2
:
5795 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 25) - ((p
| 3) ^ 3);
5796 overflowed_p
= mips_elf_overflow_p (value
, 25);
5797 value
>>= howto
->rightshift
;
5798 value
&= howto
->dst_mask
;
5801 case R_MIPS_GOT_HI16
:
5802 case R_MIPS_CALL_HI16
:
5803 case R_MICROMIPS_GOT_HI16
:
5804 case R_MICROMIPS_CALL_HI16
:
5805 /* We're allowed to handle these two relocations identically.
5806 The dynamic linker is allowed to handle the CALL relocations
5807 differently by creating a lazy evaluation stub. */
5809 value
= mips_elf_high (value
);
5810 value
&= howto
->dst_mask
;
5813 case R_MIPS_GOT_LO16
:
5814 case R_MIPS_CALL_LO16
:
5815 case R_MICROMIPS_GOT_LO16
:
5816 case R_MICROMIPS_CALL_LO16
:
5817 value
= g
& howto
->dst_mask
;
5820 case R_MIPS_GOT_PAGE
:
5821 case R_MICROMIPS_GOT_PAGE
:
5822 value
= mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, NULL
);
5823 if (value
== MINUS_ONE
)
5824 return bfd_reloc_outofrange
;
5825 value
= mips_elf_got_offset_from_index (info
, abfd
, input_bfd
, value
);
5826 overflowed_p
= mips_elf_overflow_p (value
, 16);
5829 case R_MIPS_GOT_OFST
:
5830 case R_MICROMIPS_GOT_OFST
:
5832 mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, &value
);
5835 overflowed_p
= mips_elf_overflow_p (value
, 16);
5839 case R_MICROMIPS_SUB
:
5840 value
= symbol
- addend
;
5841 value
&= howto
->dst_mask
;
5845 case R_MICROMIPS_HIGHER
:
5846 value
= mips_elf_higher (addend
+ symbol
);
5847 value
&= howto
->dst_mask
;
5850 case R_MIPS_HIGHEST
:
5851 case R_MICROMIPS_HIGHEST
:
5852 value
= mips_elf_highest (addend
+ symbol
);
5853 value
&= howto
->dst_mask
;
5856 case R_MIPS_SCN_DISP
:
5857 case R_MICROMIPS_SCN_DISP
:
5858 value
= symbol
+ addend
- sec
->output_offset
;
5859 value
&= howto
->dst_mask
;
5863 case R_MICROMIPS_JALR
:
5864 /* This relocation is only a hint. In some cases, we optimize
5865 it into a bal instruction. But we don't try to optimize
5866 when the symbol does not resolve locally. */
5867 if (h
!= NULL
&& !SYMBOL_CALLS_LOCAL (info
, &h
->root
))
5868 return bfd_reloc_continue
;
5869 value
= symbol
+ addend
;
5873 case R_MIPS_GNU_VTINHERIT
:
5874 case R_MIPS_GNU_VTENTRY
:
5875 /* We don't do anything with these at present. */
5876 return bfd_reloc_continue
;
5879 /* An unrecognized relocation type. */
5880 return bfd_reloc_notsupported
;
5883 /* Store the VALUE for our caller. */
5885 return overflowed_p
? bfd_reloc_overflow
: bfd_reloc_ok
;
5888 /* Obtain the field relocated by RELOCATION. */
5891 mips_elf_obtain_contents (reloc_howto_type
*howto
,
5892 const Elf_Internal_Rela
*relocation
,
5893 bfd
*input_bfd
, bfd_byte
*contents
)
5896 bfd_byte
*location
= contents
+ relocation
->r_offset
;
5898 /* Obtain the bytes. */
5899 x
= bfd_get ((8 * bfd_get_reloc_size (howto
)), input_bfd
, location
);
5904 /* It has been determined that the result of the RELOCATION is the
5905 VALUE. Use HOWTO to place VALUE into the output file at the
5906 appropriate position. The SECTION is the section to which the
5908 CROSS_MODE_JUMP_P is true if the relocation field
5909 is a MIPS16 or microMIPS jump to standard MIPS code, or vice versa.
5911 Returns FALSE if anything goes wrong. */
5914 mips_elf_perform_relocation (struct bfd_link_info
*info
,
5915 reloc_howto_type
*howto
,
5916 const Elf_Internal_Rela
*relocation
,
5917 bfd_vma value
, bfd
*input_bfd
,
5918 asection
*input_section
, bfd_byte
*contents
,
5919 bfd_boolean cross_mode_jump_p
)
5923 int r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
5925 /* Figure out where the relocation is occurring. */
5926 location
= contents
+ relocation
->r_offset
;
5928 _bfd_mips_elf_reloc_unshuffle (input_bfd
, r_type
, FALSE
, location
);
5930 /* Obtain the current value. */
5931 x
= mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
);
5933 /* Clear the field we are setting. */
5934 x
&= ~howto
->dst_mask
;
5936 /* Set the field. */
5937 x
|= (value
& howto
->dst_mask
);
5939 /* If required, turn JAL into JALX. */
5940 if (cross_mode_jump_p
&& jal_reloc_p (r_type
))
5943 bfd_vma opcode
= x
>> 26;
5944 bfd_vma jalx_opcode
;
5946 /* Check to see if the opcode is already JAL or JALX. */
5947 if (r_type
== R_MIPS16_26
)
5949 ok
= ((opcode
== 0x6) || (opcode
== 0x7));
5952 else if (r_type
== R_MICROMIPS_26_S1
)
5954 ok
= ((opcode
== 0x3d) || (opcode
== 0x3c));
5959 ok
= ((opcode
== 0x3) || (opcode
== 0x1d));
5963 /* If the opcode is not JAL or JALX, there's a problem. We cannot
5964 convert J or JALS to JALX. */
5967 (*_bfd_error_handler
)
5968 (_("%B: %A+0x%lx: Unsupported jump between ISA modes; consider recompiling with interlinking enabled."),
5971 (unsigned long) relocation
->r_offset
);
5972 bfd_set_error (bfd_error_bad_value
);
5976 /* Make this the JALX opcode. */
5977 x
= (x
& ~(0x3f << 26)) | (jalx_opcode
<< 26);
5980 /* Try converting JAL to BAL and J(AL)R to B(AL), if the target is in
5982 if (!info
->relocatable
5983 && !cross_mode_jump_p
5984 && ((JAL_TO_BAL_P (input_bfd
)
5985 && r_type
== R_MIPS_26
5986 && (x
>> 26) == 0x3) /* jal addr */
5987 || (JALR_TO_BAL_P (input_bfd
)
5988 && r_type
== R_MIPS_JALR
5989 && x
== 0x0320f809) /* jalr t9 */
5990 || (JR_TO_B_P (input_bfd
)
5991 && r_type
== R_MIPS_JALR
5992 && x
== 0x03200008))) /* jr t9 */
5998 addr
= (input_section
->output_section
->vma
5999 + input_section
->output_offset
6000 + relocation
->r_offset
6002 if (r_type
== R_MIPS_26
)
6003 dest
= (value
<< 2) | ((addr
>> 28) << 28);
6007 if (off
<= 0x1ffff && off
>= -0x20000)
6009 if (x
== 0x03200008) /* jr t9 */
6010 x
= 0x10000000 | (((bfd_vma
) off
>> 2) & 0xffff); /* b addr */
6012 x
= 0x04110000 | (((bfd_vma
) off
>> 2) & 0xffff); /* bal addr */
6016 /* Put the value into the output. */
6017 bfd_put (8 * bfd_get_reloc_size (howto
), input_bfd
, x
, location
);
6019 _bfd_mips_elf_reloc_shuffle (input_bfd
, r_type
, !info
->relocatable
,
6025 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
6026 is the original relocation, which is now being transformed into a
6027 dynamic relocation. The ADDENDP is adjusted if necessary; the
6028 caller should store the result in place of the original addend. */
6031 mips_elf_create_dynamic_relocation (bfd
*output_bfd
,
6032 struct bfd_link_info
*info
,
6033 const Elf_Internal_Rela
*rel
,
6034 struct mips_elf_link_hash_entry
*h
,
6035 asection
*sec
, bfd_vma symbol
,
6036 bfd_vma
*addendp
, asection
*input_section
)
6038 Elf_Internal_Rela outrel
[3];
6043 bfd_boolean defined_p
;
6044 struct mips_elf_link_hash_table
*htab
;
6046 htab
= mips_elf_hash_table (info
);
6047 BFD_ASSERT (htab
!= NULL
);
6049 r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
6050 dynobj
= elf_hash_table (info
)->dynobj
;
6051 sreloc
= mips_elf_rel_dyn_section (info
, FALSE
);
6052 BFD_ASSERT (sreloc
!= NULL
);
6053 BFD_ASSERT (sreloc
->contents
!= NULL
);
6054 BFD_ASSERT (sreloc
->reloc_count
* MIPS_ELF_REL_SIZE (output_bfd
)
6057 outrel
[0].r_offset
=
6058 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[0].r_offset
);
6059 if (ABI_64_P (output_bfd
))
6061 outrel
[1].r_offset
=
6062 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[1].r_offset
);
6063 outrel
[2].r_offset
=
6064 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[2].r_offset
);
6067 if (outrel
[0].r_offset
== MINUS_ONE
)
6068 /* The relocation field has been deleted. */
6071 if (outrel
[0].r_offset
== MINUS_TWO
)
6073 /* The relocation field has been converted into a relative value of
6074 some sort. Functions like _bfd_elf_write_section_eh_frame expect
6075 the field to be fully relocated, so add in the symbol's value. */
6080 /* We must now calculate the dynamic symbol table index to use
6081 in the relocation. */
6082 if (h
!= NULL
&& ! SYMBOL_REFERENCES_LOCAL (info
, &h
->root
))
6084 BFD_ASSERT (htab
->is_vxworks
|| h
->global_got_area
!= GGA_NONE
);
6085 indx
= h
->root
.dynindx
;
6086 if (SGI_COMPAT (output_bfd
))
6087 defined_p
= h
->root
.def_regular
;
6089 /* ??? glibc's ld.so just adds the final GOT entry to the
6090 relocation field. It therefore treats relocs against
6091 defined symbols in the same way as relocs against
6092 undefined symbols. */
6097 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
6099 else if (sec
== NULL
|| sec
->owner
== NULL
)
6101 bfd_set_error (bfd_error_bad_value
);
6106 indx
= elf_section_data (sec
->output_section
)->dynindx
;
6109 asection
*osec
= htab
->root
.text_index_section
;
6110 indx
= elf_section_data (osec
)->dynindx
;
6116 /* Instead of generating a relocation using the section
6117 symbol, we may as well make it a fully relative
6118 relocation. We want to avoid generating relocations to
6119 local symbols because we used to generate them
6120 incorrectly, without adding the original symbol value,
6121 which is mandated by the ABI for section symbols. In
6122 order to give dynamic loaders and applications time to
6123 phase out the incorrect use, we refrain from emitting
6124 section-relative relocations. It's not like they're
6125 useful, after all. This should be a bit more efficient
6127 /* ??? Although this behavior is compatible with glibc's ld.so,
6128 the ABI says that relocations against STN_UNDEF should have
6129 a symbol value of 0. Irix rld honors this, so relocations
6130 against STN_UNDEF have no effect. */
6131 if (!SGI_COMPAT (output_bfd
))
6136 /* If the relocation was previously an absolute relocation and
6137 this symbol will not be referred to by the relocation, we must
6138 adjust it by the value we give it in the dynamic symbol table.
6139 Otherwise leave the job up to the dynamic linker. */
6140 if (defined_p
&& r_type
!= R_MIPS_REL32
)
6143 if (htab
->is_vxworks
)
6144 /* VxWorks uses non-relative relocations for this. */
6145 outrel
[0].r_info
= ELF32_R_INFO (indx
, R_MIPS_32
);
6147 /* The relocation is always an REL32 relocation because we don't
6148 know where the shared library will wind up at load-time. */
6149 outrel
[0].r_info
= ELF_R_INFO (output_bfd
, (unsigned long) indx
,
6152 /* For strict adherence to the ABI specification, we should
6153 generate a R_MIPS_64 relocation record by itself before the
6154 _REL32/_64 record as well, such that the addend is read in as
6155 a 64-bit value (REL32 is a 32-bit relocation, after all).
6156 However, since none of the existing ELF64 MIPS dynamic
6157 loaders seems to care, we don't waste space with these
6158 artificial relocations. If this turns out to not be true,
6159 mips_elf_allocate_dynamic_relocation() should be tweaked so
6160 as to make room for a pair of dynamic relocations per
6161 invocation if ABI_64_P, and here we should generate an
6162 additional relocation record with R_MIPS_64 by itself for a
6163 NULL symbol before this relocation record. */
6164 outrel
[1].r_info
= ELF_R_INFO (output_bfd
, 0,
6165 ABI_64_P (output_bfd
)
6168 outrel
[2].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_NONE
);
6170 /* Adjust the output offset of the relocation to reference the
6171 correct location in the output file. */
6172 outrel
[0].r_offset
+= (input_section
->output_section
->vma
6173 + input_section
->output_offset
);
6174 outrel
[1].r_offset
+= (input_section
->output_section
->vma
6175 + input_section
->output_offset
);
6176 outrel
[2].r_offset
+= (input_section
->output_section
->vma
6177 + input_section
->output_offset
);
6179 /* Put the relocation back out. We have to use the special
6180 relocation outputter in the 64-bit case since the 64-bit
6181 relocation format is non-standard. */
6182 if (ABI_64_P (output_bfd
))
6184 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
6185 (output_bfd
, &outrel
[0],
6187 + sreloc
->reloc_count
* sizeof (Elf64_Mips_External_Rel
)));
6189 else if (htab
->is_vxworks
)
6191 /* VxWorks uses RELA rather than REL dynamic relocations. */
6192 outrel
[0].r_addend
= *addendp
;
6193 bfd_elf32_swap_reloca_out
6194 (output_bfd
, &outrel
[0],
6196 + sreloc
->reloc_count
* sizeof (Elf32_External_Rela
)));
6199 bfd_elf32_swap_reloc_out
6200 (output_bfd
, &outrel
[0],
6201 (sreloc
->contents
+ sreloc
->reloc_count
* sizeof (Elf32_External_Rel
)));
6203 /* We've now added another relocation. */
6204 ++sreloc
->reloc_count
;
6206 /* Make sure the output section is writable. The dynamic linker
6207 will be writing to it. */
6208 elf_section_data (input_section
->output_section
)->this_hdr
.sh_flags
6211 /* On IRIX5, make an entry of compact relocation info. */
6212 if (IRIX_COMPAT (output_bfd
) == ict_irix5
)
6214 asection
*scpt
= bfd_get_linker_section (dynobj
, ".compact_rel");
6219 Elf32_crinfo cptrel
;
6221 mips_elf_set_cr_format (cptrel
, CRF_MIPS_LONG
);
6222 cptrel
.vaddr
= (rel
->r_offset
6223 + input_section
->output_section
->vma
6224 + input_section
->output_offset
);
6225 if (r_type
== R_MIPS_REL32
)
6226 mips_elf_set_cr_type (cptrel
, CRT_MIPS_REL32
);
6228 mips_elf_set_cr_type (cptrel
, CRT_MIPS_WORD
);
6229 mips_elf_set_cr_dist2to (cptrel
, 0);
6230 cptrel
.konst
= *addendp
;
6232 cr
= (scpt
->contents
6233 + sizeof (Elf32_External_compact_rel
));
6234 mips_elf_set_cr_relvaddr (cptrel
, 0);
6235 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
6236 ((Elf32_External_crinfo
*) cr
6237 + scpt
->reloc_count
));
6238 ++scpt
->reloc_count
;
6242 /* If we've written this relocation for a readonly section,
6243 we need to set DF_TEXTREL again, so that we do not delete the
6245 if (MIPS_ELF_READONLY_SECTION (input_section
))
6246 info
->flags
|= DF_TEXTREL
;
6251 /* Return the MACH for a MIPS e_flags value. */
6254 _bfd_elf_mips_mach (flagword flags
)
6256 switch (flags
& EF_MIPS_MACH
)
6258 case E_MIPS_MACH_3900
:
6259 return bfd_mach_mips3900
;
6261 case E_MIPS_MACH_4010
:
6262 return bfd_mach_mips4010
;
6264 case E_MIPS_MACH_4100
:
6265 return bfd_mach_mips4100
;
6267 case E_MIPS_MACH_4111
:
6268 return bfd_mach_mips4111
;
6270 case E_MIPS_MACH_4120
:
6271 return bfd_mach_mips4120
;
6273 case E_MIPS_MACH_4650
:
6274 return bfd_mach_mips4650
;
6276 case E_MIPS_MACH_5400
:
6277 return bfd_mach_mips5400
;
6279 case E_MIPS_MACH_5500
:
6280 return bfd_mach_mips5500
;
6282 case E_MIPS_MACH_5900
:
6283 return bfd_mach_mips5900
;
6285 case E_MIPS_MACH_9000
:
6286 return bfd_mach_mips9000
;
6288 case E_MIPS_MACH_SB1
:
6289 return bfd_mach_mips_sb1
;
6291 case E_MIPS_MACH_LS2E
:
6292 return bfd_mach_mips_loongson_2e
;
6294 case E_MIPS_MACH_LS2F
:
6295 return bfd_mach_mips_loongson_2f
;
6297 case E_MIPS_MACH_LS3A
:
6298 return bfd_mach_mips_loongson_3a
;
6300 case E_MIPS_MACH_OCTEON2
:
6301 return bfd_mach_mips_octeon2
;
6303 case E_MIPS_MACH_OCTEON
:
6304 return bfd_mach_mips_octeon
;
6306 case E_MIPS_MACH_XLR
:
6307 return bfd_mach_mips_xlr
;
6310 switch (flags
& EF_MIPS_ARCH
)
6314 return bfd_mach_mips3000
;
6317 return bfd_mach_mips6000
;
6320 return bfd_mach_mips4000
;
6323 return bfd_mach_mips8000
;
6326 return bfd_mach_mips5
;
6328 case E_MIPS_ARCH_32
:
6329 return bfd_mach_mipsisa32
;
6331 case E_MIPS_ARCH_64
:
6332 return bfd_mach_mipsisa64
;
6334 case E_MIPS_ARCH_32R2
:
6335 return bfd_mach_mipsisa32r2
;
6337 case E_MIPS_ARCH_64R2
:
6338 return bfd_mach_mipsisa64r2
;
6345 /* Return printable name for ABI. */
6347 static INLINE
char *
6348 elf_mips_abi_name (bfd
*abfd
)
6352 flags
= elf_elfheader (abfd
)->e_flags
;
6353 switch (flags
& EF_MIPS_ABI
)
6356 if (ABI_N32_P (abfd
))
6358 else if (ABI_64_P (abfd
))
6362 case E_MIPS_ABI_O32
:
6364 case E_MIPS_ABI_O64
:
6366 case E_MIPS_ABI_EABI32
:
6368 case E_MIPS_ABI_EABI64
:
6371 return "unknown abi";
6375 /* MIPS ELF uses two common sections. One is the usual one, and the
6376 other is for small objects. All the small objects are kept
6377 together, and then referenced via the gp pointer, which yields
6378 faster assembler code. This is what we use for the small common
6379 section. This approach is copied from ecoff.c. */
6380 static asection mips_elf_scom_section
;
6381 static asymbol mips_elf_scom_symbol
;
6382 static asymbol
*mips_elf_scom_symbol_ptr
;
6384 /* MIPS ELF also uses an acommon section, which represents an
6385 allocated common symbol which may be overridden by a
6386 definition in a shared library. */
6387 static asection mips_elf_acom_section
;
6388 static asymbol mips_elf_acom_symbol
;
6389 static asymbol
*mips_elf_acom_symbol_ptr
;
6391 /* This is used for both the 32-bit and the 64-bit ABI. */
6394 _bfd_mips_elf_symbol_processing (bfd
*abfd
, asymbol
*asym
)
6396 elf_symbol_type
*elfsym
;
6398 /* Handle the special MIPS section numbers that a symbol may use. */
6399 elfsym
= (elf_symbol_type
*) asym
;
6400 switch (elfsym
->internal_elf_sym
.st_shndx
)
6402 case SHN_MIPS_ACOMMON
:
6403 /* This section is used in a dynamically linked executable file.
6404 It is an allocated common section. The dynamic linker can
6405 either resolve these symbols to something in a shared
6406 library, or it can just leave them here. For our purposes,
6407 we can consider these symbols to be in a new section. */
6408 if (mips_elf_acom_section
.name
== NULL
)
6410 /* Initialize the acommon section. */
6411 mips_elf_acom_section
.name
= ".acommon";
6412 mips_elf_acom_section
.flags
= SEC_ALLOC
;
6413 mips_elf_acom_section
.output_section
= &mips_elf_acom_section
;
6414 mips_elf_acom_section
.symbol
= &mips_elf_acom_symbol
;
6415 mips_elf_acom_section
.symbol_ptr_ptr
= &mips_elf_acom_symbol_ptr
;
6416 mips_elf_acom_symbol
.name
= ".acommon";
6417 mips_elf_acom_symbol
.flags
= BSF_SECTION_SYM
;
6418 mips_elf_acom_symbol
.section
= &mips_elf_acom_section
;
6419 mips_elf_acom_symbol_ptr
= &mips_elf_acom_symbol
;
6421 asym
->section
= &mips_elf_acom_section
;
6425 /* Common symbols less than the GP size are automatically
6426 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
6427 if (asym
->value
> elf_gp_size (abfd
)
6428 || ELF_ST_TYPE (elfsym
->internal_elf_sym
.st_info
) == STT_TLS
6429 || IRIX_COMPAT (abfd
) == ict_irix6
)
6432 case SHN_MIPS_SCOMMON
:
6433 if (mips_elf_scom_section
.name
== NULL
)
6435 /* Initialize the small common section. */
6436 mips_elf_scom_section
.name
= ".scommon";
6437 mips_elf_scom_section
.flags
= SEC_IS_COMMON
;
6438 mips_elf_scom_section
.output_section
= &mips_elf_scom_section
;
6439 mips_elf_scom_section
.symbol
= &mips_elf_scom_symbol
;
6440 mips_elf_scom_section
.symbol_ptr_ptr
= &mips_elf_scom_symbol_ptr
;
6441 mips_elf_scom_symbol
.name
= ".scommon";
6442 mips_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
6443 mips_elf_scom_symbol
.section
= &mips_elf_scom_section
;
6444 mips_elf_scom_symbol_ptr
= &mips_elf_scom_symbol
;
6446 asym
->section
= &mips_elf_scom_section
;
6447 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
6450 case SHN_MIPS_SUNDEFINED
:
6451 asym
->section
= bfd_und_section_ptr
;
6456 asection
*section
= bfd_get_section_by_name (abfd
, ".text");
6458 if (section
!= NULL
)
6460 asym
->section
= section
;
6461 /* MIPS_TEXT is a bit special, the address is not an offset
6462 to the base of the .text section. So substract the section
6463 base address to make it an offset. */
6464 asym
->value
-= section
->vma
;
6471 asection
*section
= bfd_get_section_by_name (abfd
, ".data");
6473 if (section
!= NULL
)
6475 asym
->section
= section
;
6476 /* MIPS_DATA is a bit special, the address is not an offset
6477 to the base of the .data section. So substract the section
6478 base address to make it an offset. */
6479 asym
->value
-= section
->vma
;
6485 /* If this is an odd-valued function symbol, assume it's a MIPS16
6486 or microMIPS one. */
6487 if (ELF_ST_TYPE (elfsym
->internal_elf_sym
.st_info
) == STT_FUNC
6488 && (asym
->value
& 1) != 0)
6491 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
6492 elfsym
->internal_elf_sym
.st_other
6493 = ELF_ST_SET_MICROMIPS (elfsym
->internal_elf_sym
.st_other
);
6495 elfsym
->internal_elf_sym
.st_other
6496 = ELF_ST_SET_MIPS16 (elfsym
->internal_elf_sym
.st_other
);
6500 /* Implement elf_backend_eh_frame_address_size. This differs from
6501 the default in the way it handles EABI64.
6503 EABI64 was originally specified as an LP64 ABI, and that is what
6504 -mabi=eabi normally gives on a 64-bit target. However, gcc has
6505 historically accepted the combination of -mabi=eabi and -mlong32,
6506 and this ILP32 variation has become semi-official over time.
6507 Both forms use elf32 and have pointer-sized FDE addresses.
6509 If an EABI object was generated by GCC 4.0 or above, it will have
6510 an empty .gcc_compiled_longXX section, where XX is the size of longs
6511 in bits. Unfortunately, ILP32 objects generated by earlier compilers
6512 have no special marking to distinguish them from LP64 objects.
6514 We don't want users of the official LP64 ABI to be punished for the
6515 existence of the ILP32 variant, but at the same time, we don't want
6516 to mistakenly interpret pre-4.0 ILP32 objects as being LP64 objects.
6517 We therefore take the following approach:
6519 - If ABFD contains a .gcc_compiled_longXX section, use it to
6520 determine the pointer size.
6522 - Otherwise check the type of the first relocation. Assume that
6523 the LP64 ABI is being used if the relocation is of type R_MIPS_64.
6527 The second check is enough to detect LP64 objects generated by pre-4.0
6528 compilers because, in the kind of output generated by those compilers,
6529 the first relocation will be associated with either a CIE personality
6530 routine or an FDE start address. Furthermore, the compilers never
6531 used a special (non-pointer) encoding for this ABI.
6533 Checking the relocation type should also be safe because there is no
6534 reason to use R_MIPS_64 in an ILP32 object. Pre-4.0 compilers never
6538 _bfd_mips_elf_eh_frame_address_size (bfd
*abfd
, asection
*sec
)
6540 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
6542 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
6544 bfd_boolean long32_p
, long64_p
;
6546 long32_p
= bfd_get_section_by_name (abfd
, ".gcc_compiled_long32") != 0;
6547 long64_p
= bfd_get_section_by_name (abfd
, ".gcc_compiled_long64") != 0;
6548 if (long32_p
&& long64_p
)
6555 if (sec
->reloc_count
> 0
6556 && elf_section_data (sec
)->relocs
!= NULL
6557 && (ELF32_R_TYPE (elf_section_data (sec
)->relocs
[0].r_info
)
6566 /* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
6567 relocations against two unnamed section symbols to resolve to the
6568 same address. For example, if we have code like:
6570 lw $4,%got_disp(.data)($gp)
6571 lw $25,%got_disp(.text)($gp)
6574 then the linker will resolve both relocations to .data and the program
6575 will jump there rather than to .text.
6577 We can work around this problem by giving names to local section symbols.
6578 This is also what the MIPSpro tools do. */
6581 _bfd_mips_elf_name_local_section_symbols (bfd
*abfd
)
6583 return SGI_COMPAT (abfd
);
6586 /* Work over a section just before writing it out. This routine is
6587 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
6588 sections that need the SHF_MIPS_GPREL flag by name; there has to be
6592 _bfd_mips_elf_section_processing (bfd
*abfd
, Elf_Internal_Shdr
*hdr
)
6594 if (hdr
->sh_type
== SHT_MIPS_REGINFO
6595 && hdr
->sh_size
> 0)
6599 BFD_ASSERT (hdr
->sh_size
== sizeof (Elf32_External_RegInfo
));
6600 BFD_ASSERT (hdr
->contents
== NULL
);
6603 hdr
->sh_offset
+ sizeof (Elf32_External_RegInfo
) - 4,
6606 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
6607 if (bfd_bwrite (buf
, 4, abfd
) != 4)
6611 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
6612 && hdr
->bfd_section
!= NULL
6613 && mips_elf_section_data (hdr
->bfd_section
) != NULL
6614 && mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
!= NULL
)
6616 bfd_byte
*contents
, *l
, *lend
;
6618 /* We stored the section contents in the tdata field in the
6619 set_section_contents routine. We save the section contents
6620 so that we don't have to read them again.
6621 At this point we know that elf_gp is set, so we can look
6622 through the section contents to see if there is an
6623 ODK_REGINFO structure. */
6625 contents
= mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
;
6627 lend
= contents
+ hdr
->sh_size
;
6628 while (l
+ sizeof (Elf_External_Options
) <= lend
)
6630 Elf_Internal_Options intopt
;
6632 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
6634 if (intopt
.size
< sizeof (Elf_External_Options
))
6636 (*_bfd_error_handler
)
6637 (_("%B: Warning: bad `%s' option size %u smaller than its header"),
6638 abfd
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
), intopt
.size
);
6641 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
6648 + sizeof (Elf_External_Options
)
6649 + (sizeof (Elf64_External_RegInfo
) - 8)),
6652 H_PUT_64 (abfd
, elf_gp (abfd
), buf
);
6653 if (bfd_bwrite (buf
, 8, abfd
) != 8)
6656 else if (intopt
.kind
== ODK_REGINFO
)
6663 + sizeof (Elf_External_Options
)
6664 + (sizeof (Elf32_External_RegInfo
) - 4)),
6667 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
6668 if (bfd_bwrite (buf
, 4, abfd
) != 4)
6675 if (hdr
->bfd_section
!= NULL
)
6677 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
6679 /* .sbss is not handled specially here because the GNU/Linux
6680 prelinker can convert .sbss from NOBITS to PROGBITS and
6681 changing it back to NOBITS breaks the binary. The entry in
6682 _bfd_mips_elf_special_sections will ensure the correct flags
6683 are set on .sbss if BFD creates it without reading it from an
6684 input file, and without special handling here the flags set
6685 on it in an input file will be followed. */
6686 if (strcmp (name
, ".sdata") == 0
6687 || strcmp (name
, ".lit8") == 0
6688 || strcmp (name
, ".lit4") == 0)
6690 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
6691 hdr
->sh_type
= SHT_PROGBITS
;
6693 else if (strcmp (name
, ".srdata") == 0)
6695 hdr
->sh_flags
|= SHF_ALLOC
| SHF_MIPS_GPREL
;
6696 hdr
->sh_type
= SHT_PROGBITS
;
6698 else if (strcmp (name
, ".compact_rel") == 0)
6701 hdr
->sh_type
= SHT_PROGBITS
;
6703 else if (strcmp (name
, ".rtproc") == 0)
6705 if (hdr
->sh_addralign
!= 0 && hdr
->sh_entsize
== 0)
6707 unsigned int adjust
;
6709 adjust
= hdr
->sh_size
% hdr
->sh_addralign
;
6711 hdr
->sh_size
+= hdr
->sh_addralign
- adjust
;
6719 /* Handle a MIPS specific section when reading an object file. This
6720 is called when elfcode.h finds a section with an unknown type.
6721 This routine supports both the 32-bit and 64-bit ELF ABI.
6723 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
6727 _bfd_mips_elf_section_from_shdr (bfd
*abfd
,
6728 Elf_Internal_Shdr
*hdr
,
6734 /* There ought to be a place to keep ELF backend specific flags, but
6735 at the moment there isn't one. We just keep track of the
6736 sections by their name, instead. Fortunately, the ABI gives
6737 suggested names for all the MIPS specific sections, so we will
6738 probably get away with this. */
6739 switch (hdr
->sh_type
)
6741 case SHT_MIPS_LIBLIST
:
6742 if (strcmp (name
, ".liblist") != 0)
6746 if (strcmp (name
, ".msym") != 0)
6749 case SHT_MIPS_CONFLICT
:
6750 if (strcmp (name
, ".conflict") != 0)
6753 case SHT_MIPS_GPTAB
:
6754 if (! CONST_STRNEQ (name
, ".gptab."))
6757 case SHT_MIPS_UCODE
:
6758 if (strcmp (name
, ".ucode") != 0)
6761 case SHT_MIPS_DEBUG
:
6762 if (strcmp (name
, ".mdebug") != 0)
6764 flags
= SEC_DEBUGGING
;
6766 case SHT_MIPS_REGINFO
:
6767 if (strcmp (name
, ".reginfo") != 0
6768 || hdr
->sh_size
!= sizeof (Elf32_External_RegInfo
))
6770 flags
= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_SIZE
);
6772 case SHT_MIPS_IFACE
:
6773 if (strcmp (name
, ".MIPS.interfaces") != 0)
6776 case SHT_MIPS_CONTENT
:
6777 if (! CONST_STRNEQ (name
, ".MIPS.content"))
6780 case SHT_MIPS_OPTIONS
:
6781 if (!MIPS_ELF_OPTIONS_SECTION_NAME_P (name
))
6784 case SHT_MIPS_DWARF
:
6785 if (! CONST_STRNEQ (name
, ".debug_")
6786 && ! CONST_STRNEQ (name
, ".zdebug_"))
6789 case SHT_MIPS_SYMBOL_LIB
:
6790 if (strcmp (name
, ".MIPS.symlib") != 0)
6793 case SHT_MIPS_EVENTS
:
6794 if (! CONST_STRNEQ (name
, ".MIPS.events")
6795 && ! CONST_STRNEQ (name
, ".MIPS.post_rel"))
6802 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
6807 if (! bfd_set_section_flags (abfd
, hdr
->bfd_section
,
6808 (bfd_get_section_flags (abfd
,
6814 /* FIXME: We should record sh_info for a .gptab section. */
6816 /* For a .reginfo section, set the gp value in the tdata information
6817 from the contents of this section. We need the gp value while
6818 processing relocs, so we just get it now. The .reginfo section
6819 is not used in the 64-bit MIPS ELF ABI. */
6820 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
6822 Elf32_External_RegInfo ext
;
6825 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
,
6826 &ext
, 0, sizeof ext
))
6828 bfd_mips_elf32_swap_reginfo_in (abfd
, &ext
, &s
);
6829 elf_gp (abfd
) = s
.ri_gp_value
;
6832 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
6833 set the gp value based on what we find. We may see both
6834 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
6835 they should agree. */
6836 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
)
6838 bfd_byte
*contents
, *l
, *lend
;
6840 contents
= bfd_malloc (hdr
->sh_size
);
6841 if (contents
== NULL
)
6843 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
,
6850 lend
= contents
+ hdr
->sh_size
;
6851 while (l
+ sizeof (Elf_External_Options
) <= lend
)
6853 Elf_Internal_Options intopt
;
6855 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
6857 if (intopt
.size
< sizeof (Elf_External_Options
))
6859 (*_bfd_error_handler
)
6860 (_("%B: Warning: bad `%s' option size %u smaller than its header"),
6861 abfd
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
), intopt
.size
);
6864 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
6866 Elf64_Internal_RegInfo intreg
;
6868 bfd_mips_elf64_swap_reginfo_in
6870 ((Elf64_External_RegInfo
*)
6871 (l
+ sizeof (Elf_External_Options
))),
6873 elf_gp (abfd
) = intreg
.ri_gp_value
;
6875 else if (intopt
.kind
== ODK_REGINFO
)
6877 Elf32_RegInfo intreg
;
6879 bfd_mips_elf32_swap_reginfo_in
6881 ((Elf32_External_RegInfo
*)
6882 (l
+ sizeof (Elf_External_Options
))),
6884 elf_gp (abfd
) = intreg
.ri_gp_value
;
6894 /* Set the correct type for a MIPS ELF section. We do this by the
6895 section name, which is a hack, but ought to work. This routine is
6896 used by both the 32-bit and the 64-bit ABI. */
6899 _bfd_mips_elf_fake_sections (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*sec
)
6901 const char *name
= bfd_get_section_name (abfd
, sec
);
6903 if (strcmp (name
, ".liblist") == 0)
6905 hdr
->sh_type
= SHT_MIPS_LIBLIST
;
6906 hdr
->sh_info
= sec
->size
/ sizeof (Elf32_Lib
);
6907 /* The sh_link field is set in final_write_processing. */
6909 else if (strcmp (name
, ".conflict") == 0)
6910 hdr
->sh_type
= SHT_MIPS_CONFLICT
;
6911 else if (CONST_STRNEQ (name
, ".gptab."))
6913 hdr
->sh_type
= SHT_MIPS_GPTAB
;
6914 hdr
->sh_entsize
= sizeof (Elf32_External_gptab
);
6915 /* The sh_info field is set in final_write_processing. */
6917 else if (strcmp (name
, ".ucode") == 0)
6918 hdr
->sh_type
= SHT_MIPS_UCODE
;
6919 else if (strcmp (name
, ".mdebug") == 0)
6921 hdr
->sh_type
= SHT_MIPS_DEBUG
;
6922 /* In a shared object on IRIX 5.3, the .mdebug section has an
6923 entsize of 0. FIXME: Does this matter? */
6924 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
6925 hdr
->sh_entsize
= 0;
6927 hdr
->sh_entsize
= 1;
6929 else if (strcmp (name
, ".reginfo") == 0)
6931 hdr
->sh_type
= SHT_MIPS_REGINFO
;
6932 /* In a shared object on IRIX 5.3, the .reginfo section has an
6933 entsize of 0x18. FIXME: Does this matter? */
6934 if (SGI_COMPAT (abfd
))
6936 if ((abfd
->flags
& DYNAMIC
) != 0)
6937 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
6939 hdr
->sh_entsize
= 1;
6942 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
6944 else if (SGI_COMPAT (abfd
)
6945 && (strcmp (name
, ".hash") == 0
6946 || strcmp (name
, ".dynamic") == 0
6947 || strcmp (name
, ".dynstr") == 0))
6949 if (SGI_COMPAT (abfd
))
6950 hdr
->sh_entsize
= 0;
6952 /* This isn't how the IRIX6 linker behaves. */
6953 hdr
->sh_info
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
6956 else if (strcmp (name
, ".got") == 0
6957 || strcmp (name
, ".srdata") == 0
6958 || strcmp (name
, ".sdata") == 0
6959 || strcmp (name
, ".sbss") == 0
6960 || strcmp (name
, ".lit4") == 0
6961 || strcmp (name
, ".lit8") == 0)
6962 hdr
->sh_flags
|= SHF_MIPS_GPREL
;
6963 else if (strcmp (name
, ".MIPS.interfaces") == 0)
6965 hdr
->sh_type
= SHT_MIPS_IFACE
;
6966 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
6968 else if (CONST_STRNEQ (name
, ".MIPS.content"))
6970 hdr
->sh_type
= SHT_MIPS_CONTENT
;
6971 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
6972 /* The sh_info field is set in final_write_processing. */
6974 else if (MIPS_ELF_OPTIONS_SECTION_NAME_P (name
))
6976 hdr
->sh_type
= SHT_MIPS_OPTIONS
;
6977 hdr
->sh_entsize
= 1;
6978 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
6980 else if (CONST_STRNEQ (name
, ".debug_")
6981 || CONST_STRNEQ (name
, ".zdebug_"))
6983 hdr
->sh_type
= SHT_MIPS_DWARF
;
6985 /* Irix facilities such as libexc expect a single .debug_frame
6986 per executable, the system ones have NOSTRIP set and the linker
6987 doesn't merge sections with different flags so ... */
6988 if (SGI_COMPAT (abfd
) && CONST_STRNEQ (name
, ".debug_frame"))
6989 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
6991 else if (strcmp (name
, ".MIPS.symlib") == 0)
6993 hdr
->sh_type
= SHT_MIPS_SYMBOL_LIB
;
6994 /* The sh_link and sh_info fields are set in
6995 final_write_processing. */
6997 else if (CONST_STRNEQ (name
, ".MIPS.events")
6998 || CONST_STRNEQ (name
, ".MIPS.post_rel"))
7000 hdr
->sh_type
= SHT_MIPS_EVENTS
;
7001 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
7002 /* The sh_link field is set in final_write_processing. */
7004 else if (strcmp (name
, ".msym") == 0)
7006 hdr
->sh_type
= SHT_MIPS_MSYM
;
7007 hdr
->sh_flags
|= SHF_ALLOC
;
7008 hdr
->sh_entsize
= 8;
7011 /* The generic elf_fake_sections will set up REL_HDR using the default
7012 kind of relocations. We used to set up a second header for the
7013 non-default kind of relocations here, but only NewABI would use
7014 these, and the IRIX ld doesn't like resulting empty RELA sections.
7015 Thus we create those header only on demand now. */
7020 /* Given a BFD section, try to locate the corresponding ELF section
7021 index. This is used by both the 32-bit and the 64-bit ABI.
7022 Actually, it's not clear to me that the 64-bit ABI supports these,
7023 but for non-PIC objects we will certainly want support for at least
7024 the .scommon section. */
7027 _bfd_mips_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
7028 asection
*sec
, int *retval
)
7030 if (strcmp (bfd_get_section_name (abfd
, sec
), ".scommon") == 0)
7032 *retval
= SHN_MIPS_SCOMMON
;
7035 if (strcmp (bfd_get_section_name (abfd
, sec
), ".acommon") == 0)
7037 *retval
= SHN_MIPS_ACOMMON
;
7043 /* Hook called by the linker routine which adds symbols from an object
7044 file. We must handle the special MIPS section numbers here. */
7047 _bfd_mips_elf_add_symbol_hook (bfd
*abfd
, struct bfd_link_info
*info
,
7048 Elf_Internal_Sym
*sym
, const char **namep
,
7049 flagword
*flagsp ATTRIBUTE_UNUSED
,
7050 asection
**secp
, bfd_vma
*valp
)
7052 if (SGI_COMPAT (abfd
)
7053 && (abfd
->flags
& DYNAMIC
) != 0
7054 && strcmp (*namep
, "_rld_new_interface") == 0)
7056 /* Skip IRIX5 rld entry name. */
7061 /* Shared objects may have a dynamic symbol '_gp_disp' defined as
7062 a SECTION *ABS*. This causes ld to think it can resolve _gp_disp
7063 by setting a DT_NEEDED for the shared object. Since _gp_disp is
7064 a magic symbol resolved by the linker, we ignore this bogus definition
7065 of _gp_disp. New ABI objects do not suffer from this problem so this
7066 is not done for them. */
7068 && (sym
->st_shndx
== SHN_ABS
)
7069 && (strcmp (*namep
, "_gp_disp") == 0))
7075 switch (sym
->st_shndx
)
7078 /* Common symbols less than the GP size are automatically
7079 treated as SHN_MIPS_SCOMMON symbols. */
7080 if (sym
->st_size
> elf_gp_size (abfd
)
7081 || ELF_ST_TYPE (sym
->st_info
) == STT_TLS
7082 || IRIX_COMPAT (abfd
) == ict_irix6
)
7085 case SHN_MIPS_SCOMMON
:
7086 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
7087 (*secp
)->flags
|= SEC_IS_COMMON
;
7088 *valp
= sym
->st_size
;
7092 /* This section is used in a shared object. */
7093 if (elf_tdata (abfd
)->elf_text_section
== NULL
)
7095 asymbol
*elf_text_symbol
;
7096 asection
*elf_text_section
;
7097 bfd_size_type amt
= sizeof (asection
);
7099 elf_text_section
= bfd_zalloc (abfd
, amt
);
7100 if (elf_text_section
== NULL
)
7103 amt
= sizeof (asymbol
);
7104 elf_text_symbol
= bfd_zalloc (abfd
, amt
);
7105 if (elf_text_symbol
== NULL
)
7108 /* Initialize the section. */
7110 elf_tdata (abfd
)->elf_text_section
= elf_text_section
;
7111 elf_tdata (abfd
)->elf_text_symbol
= elf_text_symbol
;
7113 elf_text_section
->symbol
= elf_text_symbol
;
7114 elf_text_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_text_symbol
;
7116 elf_text_section
->name
= ".text";
7117 elf_text_section
->flags
= SEC_NO_FLAGS
;
7118 elf_text_section
->output_section
= NULL
;
7119 elf_text_section
->owner
= abfd
;
7120 elf_text_symbol
->name
= ".text";
7121 elf_text_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
7122 elf_text_symbol
->section
= elf_text_section
;
7124 /* This code used to do *secp = bfd_und_section_ptr if
7125 info->shared. I don't know why, and that doesn't make sense,
7126 so I took it out. */
7127 *secp
= elf_tdata (abfd
)->elf_text_section
;
7130 case SHN_MIPS_ACOMMON
:
7131 /* Fall through. XXX Can we treat this as allocated data? */
7133 /* This section is used in a shared object. */
7134 if (elf_tdata (abfd
)->elf_data_section
== NULL
)
7136 asymbol
*elf_data_symbol
;
7137 asection
*elf_data_section
;
7138 bfd_size_type amt
= sizeof (asection
);
7140 elf_data_section
= bfd_zalloc (abfd
, amt
);
7141 if (elf_data_section
== NULL
)
7144 amt
= sizeof (asymbol
);
7145 elf_data_symbol
= bfd_zalloc (abfd
, amt
);
7146 if (elf_data_symbol
== NULL
)
7149 /* Initialize the section. */
7151 elf_tdata (abfd
)->elf_data_section
= elf_data_section
;
7152 elf_tdata (abfd
)->elf_data_symbol
= elf_data_symbol
;
7154 elf_data_section
->symbol
= elf_data_symbol
;
7155 elf_data_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_data_symbol
;
7157 elf_data_section
->name
= ".data";
7158 elf_data_section
->flags
= SEC_NO_FLAGS
;
7159 elf_data_section
->output_section
= NULL
;
7160 elf_data_section
->owner
= abfd
;
7161 elf_data_symbol
->name
= ".data";
7162 elf_data_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
7163 elf_data_symbol
->section
= elf_data_section
;
7165 /* This code used to do *secp = bfd_und_section_ptr if
7166 info->shared. I don't know why, and that doesn't make sense,
7167 so I took it out. */
7168 *secp
= elf_tdata (abfd
)->elf_data_section
;
7171 case SHN_MIPS_SUNDEFINED
:
7172 *secp
= bfd_und_section_ptr
;
7176 if (SGI_COMPAT (abfd
)
7178 && info
->output_bfd
->xvec
== abfd
->xvec
7179 && strcmp (*namep
, "__rld_obj_head") == 0)
7181 struct elf_link_hash_entry
*h
;
7182 struct bfd_link_hash_entry
*bh
;
7184 /* Mark __rld_obj_head as dynamic. */
7186 if (! (_bfd_generic_link_add_one_symbol
7187 (info
, abfd
, *namep
, BSF_GLOBAL
, *secp
, *valp
, NULL
, FALSE
,
7188 get_elf_backend_data (abfd
)->collect
, &bh
)))
7191 h
= (struct elf_link_hash_entry
*) bh
;
7194 h
->type
= STT_OBJECT
;
7196 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
7199 mips_elf_hash_table (info
)->use_rld_obj_head
= TRUE
;
7200 mips_elf_hash_table (info
)->rld_symbol
= h
;
7203 /* If this is a mips16 text symbol, add 1 to the value to make it
7204 odd. This will cause something like .word SYM to come up with
7205 the right value when it is loaded into the PC. */
7206 if (ELF_ST_IS_COMPRESSED (sym
->st_other
))
7212 /* This hook function is called before the linker writes out a global
7213 symbol. We mark symbols as small common if appropriate. This is
7214 also where we undo the increment of the value for a mips16 symbol. */
7217 _bfd_mips_elf_link_output_symbol_hook
7218 (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
7219 const char *name ATTRIBUTE_UNUSED
, Elf_Internal_Sym
*sym
,
7220 asection
*input_sec
, struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
)
7222 /* If we see a common symbol, which implies a relocatable link, then
7223 if a symbol was small common in an input file, mark it as small
7224 common in the output file. */
7225 if (sym
->st_shndx
== SHN_COMMON
7226 && strcmp (input_sec
->name
, ".scommon") == 0)
7227 sym
->st_shndx
= SHN_MIPS_SCOMMON
;
7229 if (ELF_ST_IS_COMPRESSED (sym
->st_other
))
7230 sym
->st_value
&= ~1;
7235 /* Functions for the dynamic linker. */
7237 /* Create dynamic sections when linking against a dynamic object. */
7240 _bfd_mips_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
7242 struct elf_link_hash_entry
*h
;
7243 struct bfd_link_hash_entry
*bh
;
7245 register asection
*s
;
7246 const char * const *namep
;
7247 struct mips_elf_link_hash_table
*htab
;
7249 htab
= mips_elf_hash_table (info
);
7250 BFD_ASSERT (htab
!= NULL
);
7252 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
7253 | SEC_LINKER_CREATED
| SEC_READONLY
);
7255 /* The psABI requires a read-only .dynamic section, but the VxWorks
7257 if (!htab
->is_vxworks
)
7259 s
= bfd_get_linker_section (abfd
, ".dynamic");
7262 if (! bfd_set_section_flags (abfd
, s
, flags
))
7267 /* We need to create .got section. */
7268 if (!mips_elf_create_got_section (abfd
, info
))
7271 if (! mips_elf_rel_dyn_section (info
, TRUE
))
7274 /* Create .stub section. */
7275 s
= bfd_make_section_anyway_with_flags (abfd
,
7276 MIPS_ELF_STUB_SECTION_NAME (abfd
),
7279 || ! bfd_set_section_alignment (abfd
, s
,
7280 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
7284 if (!mips_elf_hash_table (info
)->use_rld_obj_head
7286 && bfd_get_linker_section (abfd
, ".rld_map") == NULL
)
7288 s
= bfd_make_section_anyway_with_flags (abfd
, ".rld_map",
7289 flags
&~ (flagword
) SEC_READONLY
);
7291 || ! bfd_set_section_alignment (abfd
, s
,
7292 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
7296 /* On IRIX5, we adjust add some additional symbols and change the
7297 alignments of several sections. There is no ABI documentation
7298 indicating that this is necessary on IRIX6, nor any evidence that
7299 the linker takes such action. */
7300 if (IRIX_COMPAT (abfd
) == ict_irix5
)
7302 for (namep
= mips_elf_dynsym_rtproc_names
; *namep
!= NULL
; namep
++)
7305 if (! (_bfd_generic_link_add_one_symbol
7306 (info
, abfd
, *namep
, BSF_GLOBAL
, bfd_und_section_ptr
, 0,
7307 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
7310 h
= (struct elf_link_hash_entry
*) bh
;
7313 h
->type
= STT_SECTION
;
7315 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
7319 /* We need to create a .compact_rel section. */
7320 if (SGI_COMPAT (abfd
))
7322 if (!mips_elf_create_compact_rel_section (abfd
, info
))
7326 /* Change alignments of some sections. */
7327 s
= bfd_get_linker_section (abfd
, ".hash");
7329 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
7330 s
= bfd_get_linker_section (abfd
, ".dynsym");
7332 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
7333 s
= bfd_get_linker_section (abfd
, ".dynstr");
7335 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
7337 s
= bfd_get_section_by_name (abfd
, ".reginfo");
7339 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
7340 s
= bfd_get_linker_section (abfd
, ".dynamic");
7342 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
7349 name
= SGI_COMPAT (abfd
) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
7351 if (!(_bfd_generic_link_add_one_symbol
7352 (info
, abfd
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
, 0,
7353 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
7356 h
= (struct elf_link_hash_entry
*) bh
;
7359 h
->type
= STT_SECTION
;
7361 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
7364 if (! mips_elf_hash_table (info
)->use_rld_obj_head
)
7366 /* __rld_map is a four byte word located in the .data section
7367 and is filled in by the rtld to contain a pointer to
7368 the _r_debug structure. Its symbol value will be set in
7369 _bfd_mips_elf_finish_dynamic_symbol. */
7370 s
= bfd_get_linker_section (abfd
, ".rld_map");
7371 BFD_ASSERT (s
!= NULL
);
7373 name
= SGI_COMPAT (abfd
) ? "__rld_map" : "__RLD_MAP";
7375 if (!(_bfd_generic_link_add_one_symbol
7376 (info
, abfd
, name
, BSF_GLOBAL
, s
, 0, NULL
, FALSE
,
7377 get_elf_backend_data (abfd
)->collect
, &bh
)))
7380 h
= (struct elf_link_hash_entry
*) bh
;
7383 h
->type
= STT_OBJECT
;
7385 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
7387 mips_elf_hash_table (info
)->rld_symbol
= h
;
7391 /* Create the .plt, .rel(a).plt, .dynbss and .rel(a).bss sections.
7392 Also create the _PROCEDURE_LINKAGE_TABLE symbol. */
7393 if (!_bfd_elf_create_dynamic_sections (abfd
, info
))
7396 /* Cache the sections created above. */
7397 htab
->splt
= bfd_get_linker_section (abfd
, ".plt");
7398 htab
->sdynbss
= bfd_get_linker_section (abfd
, ".dynbss");
7399 if (htab
->is_vxworks
)
7401 htab
->srelbss
= bfd_get_linker_section (abfd
, ".rela.bss");
7402 htab
->srelplt
= bfd_get_linker_section (abfd
, ".rela.plt");
7405 htab
->srelplt
= bfd_get_linker_section (abfd
, ".rel.plt");
7407 || (htab
->is_vxworks
&& !htab
->srelbss
&& !info
->shared
)
7412 if (htab
->is_vxworks
)
7414 /* Do the usual VxWorks handling. */
7415 if (!elf_vxworks_create_dynamic_sections (abfd
, info
, &htab
->srelplt2
))
7418 /* Work out the PLT sizes. */
7421 htab
->plt_header_size
7422 = 4 * ARRAY_SIZE (mips_vxworks_shared_plt0_entry
);
7423 htab
->plt_entry_size
7424 = 4 * ARRAY_SIZE (mips_vxworks_shared_plt_entry
);
7428 htab
->plt_header_size
7429 = 4 * ARRAY_SIZE (mips_vxworks_exec_plt0_entry
);
7430 htab
->plt_entry_size
7431 = 4 * ARRAY_SIZE (mips_vxworks_exec_plt_entry
);
7434 else if (!info
->shared
)
7436 /* All variants of the plt0 entry are the same size. */
7437 htab
->plt_header_size
= 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry
);
7438 htab
->plt_entry_size
= 4 * ARRAY_SIZE (mips_exec_plt_entry
);
7444 /* Return true if relocation REL against section SEC is a REL rather than
7445 RELA relocation. RELOCS is the first relocation in the section and
7446 ABFD is the bfd that contains SEC. */
7449 mips_elf_rel_relocation_p (bfd
*abfd
, asection
*sec
,
7450 const Elf_Internal_Rela
*relocs
,
7451 const Elf_Internal_Rela
*rel
)
7453 Elf_Internal_Shdr
*rel_hdr
;
7454 const struct elf_backend_data
*bed
;
7456 /* To determine which flavor of relocation this is, we depend on the
7457 fact that the INPUT_SECTION's REL_HDR is read before RELA_HDR. */
7458 rel_hdr
= elf_section_data (sec
)->rel
.hdr
;
7459 if (rel_hdr
== NULL
)
7461 bed
= get_elf_backend_data (abfd
);
7462 return ((size_t) (rel
- relocs
)
7463 < NUM_SHDR_ENTRIES (rel_hdr
) * bed
->s
->int_rels_per_ext_rel
);
7466 /* Read the addend for REL relocation REL, which belongs to bfd ABFD.
7467 HOWTO is the relocation's howto and CONTENTS points to the contents
7468 of the section that REL is against. */
7471 mips_elf_read_rel_addend (bfd
*abfd
, const Elf_Internal_Rela
*rel
,
7472 reloc_howto_type
*howto
, bfd_byte
*contents
)
7475 unsigned int r_type
;
7478 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
7479 location
= contents
+ rel
->r_offset
;
7481 /* Get the addend, which is stored in the input file. */
7482 _bfd_mips_elf_reloc_unshuffle (abfd
, r_type
, FALSE
, location
);
7483 addend
= mips_elf_obtain_contents (howto
, rel
, abfd
, contents
);
7484 _bfd_mips_elf_reloc_shuffle (abfd
, r_type
, FALSE
, location
);
7486 return addend
& howto
->src_mask
;
7489 /* REL is a relocation in ABFD that needs a partnering LO16 relocation
7490 and *ADDEND is the addend for REL itself. Look for the LO16 relocation
7491 and update *ADDEND with the final addend. Return true on success
7492 or false if the LO16 could not be found. RELEND is the exclusive
7493 upper bound on the relocations for REL's section. */
7496 mips_elf_add_lo16_rel_addend (bfd
*abfd
,
7497 const Elf_Internal_Rela
*rel
,
7498 const Elf_Internal_Rela
*relend
,
7499 bfd_byte
*contents
, bfd_vma
*addend
)
7501 unsigned int r_type
, lo16_type
;
7502 const Elf_Internal_Rela
*lo16_relocation
;
7503 reloc_howto_type
*lo16_howto
;
7506 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
7507 if (mips16_reloc_p (r_type
))
7508 lo16_type
= R_MIPS16_LO16
;
7509 else if (micromips_reloc_p (r_type
))
7510 lo16_type
= R_MICROMIPS_LO16
;
7512 lo16_type
= R_MIPS_LO16
;
7514 /* The combined value is the sum of the HI16 addend, left-shifted by
7515 sixteen bits, and the LO16 addend, sign extended. (Usually, the
7516 code does a `lui' of the HI16 value, and then an `addiu' of the
7519 Scan ahead to find a matching LO16 relocation.
7521 According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must
7522 be immediately following. However, for the IRIX6 ABI, the next
7523 relocation may be a composed relocation consisting of several
7524 relocations for the same address. In that case, the R_MIPS_LO16
7525 relocation may occur as one of these. We permit a similar
7526 extension in general, as that is useful for GCC.
7528 In some cases GCC dead code elimination removes the LO16 but keeps
7529 the corresponding HI16. This is strictly speaking a violation of
7530 the ABI but not immediately harmful. */
7531 lo16_relocation
= mips_elf_next_relocation (abfd
, lo16_type
, rel
, relend
);
7532 if (lo16_relocation
== NULL
)
7535 /* Obtain the addend kept there. */
7536 lo16_howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, lo16_type
, FALSE
);
7537 l
= mips_elf_read_rel_addend (abfd
, lo16_relocation
, lo16_howto
, contents
);
7539 l
<<= lo16_howto
->rightshift
;
7540 l
= _bfd_mips_elf_sign_extend (l
, 16);
7547 /* Try to read the contents of section SEC in bfd ABFD. Return true and
7548 store the contents in *CONTENTS on success. Assume that *CONTENTS
7549 already holds the contents if it is nonull on entry. */
7552 mips_elf_get_section_contents (bfd
*abfd
, asection
*sec
, bfd_byte
**contents
)
7557 /* Get cached copy if it exists. */
7558 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
7560 *contents
= elf_section_data (sec
)->this_hdr
.contents
;
7564 return bfd_malloc_and_get_section (abfd
, sec
, contents
);
7567 /* Look through the relocs for a section during the first phase, and
7568 allocate space in the global offset table. */
7571 _bfd_mips_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
7572 asection
*sec
, const Elf_Internal_Rela
*relocs
)
7576 Elf_Internal_Shdr
*symtab_hdr
;
7577 struct elf_link_hash_entry
**sym_hashes
;
7579 const Elf_Internal_Rela
*rel
;
7580 const Elf_Internal_Rela
*rel_end
;
7582 const struct elf_backend_data
*bed
;
7583 struct mips_elf_link_hash_table
*htab
;
7586 reloc_howto_type
*howto
;
7588 if (info
->relocatable
)
7591 htab
= mips_elf_hash_table (info
);
7592 BFD_ASSERT (htab
!= NULL
);
7594 dynobj
= elf_hash_table (info
)->dynobj
;
7595 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7596 sym_hashes
= elf_sym_hashes (abfd
);
7597 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
7599 bed
= get_elf_backend_data (abfd
);
7600 rel_end
= relocs
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
7602 /* Check for the mips16 stub sections. */
7604 name
= bfd_get_section_name (abfd
, sec
);
7605 if (FN_STUB_P (name
))
7607 unsigned long r_symndx
;
7609 /* Look at the relocation information to figure out which symbol
7612 r_symndx
= mips16_stub_symndx (bed
, sec
, relocs
, rel_end
);
7615 (*_bfd_error_handler
)
7616 (_("%B: Warning: cannot determine the target function for"
7617 " stub section `%s'"),
7619 bfd_set_error (bfd_error_bad_value
);
7623 if (r_symndx
< extsymoff
7624 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
7628 /* This stub is for a local symbol. This stub will only be
7629 needed if there is some relocation in this BFD, other
7630 than a 16 bit function call, which refers to this symbol. */
7631 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
7633 Elf_Internal_Rela
*sec_relocs
;
7634 const Elf_Internal_Rela
*r
, *rend
;
7636 /* We can ignore stub sections when looking for relocs. */
7637 if ((o
->flags
& SEC_RELOC
) == 0
7638 || o
->reloc_count
== 0
7639 || section_allows_mips16_refs_p (o
))
7643 = _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
7645 if (sec_relocs
== NULL
)
7648 rend
= sec_relocs
+ o
->reloc_count
;
7649 for (r
= sec_relocs
; r
< rend
; r
++)
7650 if (ELF_R_SYM (abfd
, r
->r_info
) == r_symndx
7651 && !mips16_call_reloc_p (ELF_R_TYPE (abfd
, r
->r_info
)))
7654 if (elf_section_data (o
)->relocs
!= sec_relocs
)
7663 /* There is no non-call reloc for this stub, so we do
7664 not need it. Since this function is called before
7665 the linker maps input sections to output sections, we
7666 can easily discard it by setting the SEC_EXCLUDE
7668 sec
->flags
|= SEC_EXCLUDE
;
7672 /* Record this stub in an array of local symbol stubs for
7674 if (elf_tdata (abfd
)->local_stubs
== NULL
)
7676 unsigned long symcount
;
7680 if (elf_bad_symtab (abfd
))
7681 symcount
= NUM_SHDR_ENTRIES (symtab_hdr
);
7683 symcount
= symtab_hdr
->sh_info
;
7684 amt
= symcount
* sizeof (asection
*);
7685 n
= bfd_zalloc (abfd
, amt
);
7688 elf_tdata (abfd
)->local_stubs
= n
;
7691 sec
->flags
|= SEC_KEEP
;
7692 elf_tdata (abfd
)->local_stubs
[r_symndx
] = sec
;
7694 /* We don't need to set mips16_stubs_seen in this case.
7695 That flag is used to see whether we need to look through
7696 the global symbol table for stubs. We don't need to set
7697 it here, because we just have a local stub. */
7701 struct mips_elf_link_hash_entry
*h
;
7703 h
= ((struct mips_elf_link_hash_entry
*)
7704 sym_hashes
[r_symndx
- extsymoff
]);
7706 while (h
->root
.root
.type
== bfd_link_hash_indirect
7707 || h
->root
.root
.type
== bfd_link_hash_warning
)
7708 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
7710 /* H is the symbol this stub is for. */
7712 /* If we already have an appropriate stub for this function, we
7713 don't need another one, so we can discard this one. Since
7714 this function is called before the linker maps input sections
7715 to output sections, we can easily discard it by setting the
7716 SEC_EXCLUDE flag. */
7717 if (h
->fn_stub
!= NULL
)
7719 sec
->flags
|= SEC_EXCLUDE
;
7723 sec
->flags
|= SEC_KEEP
;
7725 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
7728 else if (CALL_STUB_P (name
) || CALL_FP_STUB_P (name
))
7730 unsigned long r_symndx
;
7731 struct mips_elf_link_hash_entry
*h
;
7734 /* Look at the relocation information to figure out which symbol
7737 r_symndx
= mips16_stub_symndx (bed
, sec
, relocs
, rel_end
);
7740 (*_bfd_error_handler
)
7741 (_("%B: Warning: cannot determine the target function for"
7742 " stub section `%s'"),
7744 bfd_set_error (bfd_error_bad_value
);
7748 if (r_symndx
< extsymoff
7749 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
7753 /* This stub is for a local symbol. This stub will only be
7754 needed if there is some relocation (R_MIPS16_26) in this BFD
7755 that refers to this symbol. */
7756 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
7758 Elf_Internal_Rela
*sec_relocs
;
7759 const Elf_Internal_Rela
*r
, *rend
;
7761 /* We can ignore stub sections when looking for relocs. */
7762 if ((o
->flags
& SEC_RELOC
) == 0
7763 || o
->reloc_count
== 0
7764 || section_allows_mips16_refs_p (o
))
7768 = _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
7770 if (sec_relocs
== NULL
)
7773 rend
= sec_relocs
+ o
->reloc_count
;
7774 for (r
= sec_relocs
; r
< rend
; r
++)
7775 if (ELF_R_SYM (abfd
, r
->r_info
) == r_symndx
7776 && ELF_R_TYPE (abfd
, r
->r_info
) == R_MIPS16_26
)
7779 if (elf_section_data (o
)->relocs
!= sec_relocs
)
7788 /* There is no non-call reloc for this stub, so we do
7789 not need it. Since this function is called before
7790 the linker maps input sections to output sections, we
7791 can easily discard it by setting the SEC_EXCLUDE
7793 sec
->flags
|= SEC_EXCLUDE
;
7797 /* Record this stub in an array of local symbol call_stubs for
7799 if (elf_tdata (abfd
)->local_call_stubs
== NULL
)
7801 unsigned long symcount
;
7805 if (elf_bad_symtab (abfd
))
7806 symcount
= NUM_SHDR_ENTRIES (symtab_hdr
);
7808 symcount
= symtab_hdr
->sh_info
;
7809 amt
= symcount
* sizeof (asection
*);
7810 n
= bfd_zalloc (abfd
, amt
);
7813 elf_tdata (abfd
)->local_call_stubs
= n
;
7816 sec
->flags
|= SEC_KEEP
;
7817 elf_tdata (abfd
)->local_call_stubs
[r_symndx
] = sec
;
7819 /* We don't need to set mips16_stubs_seen in this case.
7820 That flag is used to see whether we need to look through
7821 the global symbol table for stubs. We don't need to set
7822 it here, because we just have a local stub. */
7826 h
= ((struct mips_elf_link_hash_entry
*)
7827 sym_hashes
[r_symndx
- extsymoff
]);
7829 /* H is the symbol this stub is for. */
7831 if (CALL_FP_STUB_P (name
))
7832 loc
= &h
->call_fp_stub
;
7834 loc
= &h
->call_stub
;
7836 /* If we already have an appropriate stub for this function, we
7837 don't need another one, so we can discard this one. Since
7838 this function is called before the linker maps input sections
7839 to output sections, we can easily discard it by setting the
7840 SEC_EXCLUDE flag. */
7843 sec
->flags
|= SEC_EXCLUDE
;
7847 sec
->flags
|= SEC_KEEP
;
7849 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
7855 for (rel
= relocs
; rel
< rel_end
; ++rel
)
7857 unsigned long r_symndx
;
7858 unsigned int r_type
;
7859 struct elf_link_hash_entry
*h
;
7860 bfd_boolean can_make_dynamic_p
;
7862 r_symndx
= ELF_R_SYM (abfd
, rel
->r_info
);
7863 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
7865 if (r_symndx
< extsymoff
)
7867 else if (r_symndx
>= extsymoff
+ NUM_SHDR_ENTRIES (symtab_hdr
))
7869 (*_bfd_error_handler
)
7870 (_("%B: Malformed reloc detected for section %s"),
7872 bfd_set_error (bfd_error_bad_value
);
7877 h
= sym_hashes
[r_symndx
- extsymoff
];
7879 && (h
->root
.type
== bfd_link_hash_indirect
7880 || h
->root
.type
== bfd_link_hash_warning
))
7881 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
7884 /* Set CAN_MAKE_DYNAMIC_P to true if we can convert this
7885 relocation into a dynamic one. */
7886 can_make_dynamic_p
= FALSE
;
7891 case R_MIPS_CALL_HI16
:
7892 case R_MIPS_CALL_LO16
:
7893 case R_MIPS_GOT_HI16
:
7894 case R_MIPS_GOT_LO16
:
7895 case R_MIPS_GOT_PAGE
:
7896 case R_MIPS_GOT_OFST
:
7897 case R_MIPS_GOT_DISP
:
7898 case R_MIPS_TLS_GOTTPREL
:
7900 case R_MIPS_TLS_LDM
:
7901 case R_MIPS16_GOT16
:
7902 case R_MIPS16_CALL16
:
7903 case R_MIPS16_TLS_GOTTPREL
:
7904 case R_MIPS16_TLS_GD
:
7905 case R_MIPS16_TLS_LDM
:
7906 case R_MICROMIPS_GOT16
:
7907 case R_MICROMIPS_CALL16
:
7908 case R_MICROMIPS_CALL_HI16
:
7909 case R_MICROMIPS_CALL_LO16
:
7910 case R_MICROMIPS_GOT_HI16
:
7911 case R_MICROMIPS_GOT_LO16
:
7912 case R_MICROMIPS_GOT_PAGE
:
7913 case R_MICROMIPS_GOT_OFST
:
7914 case R_MICROMIPS_GOT_DISP
:
7915 case R_MICROMIPS_TLS_GOTTPREL
:
7916 case R_MICROMIPS_TLS_GD
:
7917 case R_MICROMIPS_TLS_LDM
:
7919 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
7920 if (!mips_elf_create_got_section (dynobj
, info
))
7922 if (htab
->is_vxworks
&& !info
->shared
)
7924 (*_bfd_error_handler
)
7925 (_("%B: GOT reloc at 0x%lx not expected in executables"),
7926 abfd
, (unsigned long) rel
->r_offset
);
7927 bfd_set_error (bfd_error_bad_value
);
7932 /* This is just a hint; it can safely be ignored. Don't set
7933 has_static_relocs for the corresponding symbol. */
7935 case R_MICROMIPS_JALR
:
7941 /* In VxWorks executables, references to external symbols
7942 must be handled using copy relocs or PLT entries; it is not
7943 possible to convert this relocation into a dynamic one.
7945 For executables that use PLTs and copy-relocs, we have a
7946 choice between converting the relocation into a dynamic
7947 one or using copy relocations or PLT entries. It is
7948 usually better to do the former, unless the relocation is
7949 against a read-only section. */
7952 && !htab
->is_vxworks
7953 && strcmp (h
->root
.root
.string
, "__gnu_local_gp") != 0
7954 && !(!info
->nocopyreloc
7955 && !PIC_OBJECT_P (abfd
)
7956 && MIPS_ELF_READONLY_SECTION (sec
))))
7957 && (sec
->flags
& SEC_ALLOC
) != 0)
7959 can_make_dynamic_p
= TRUE
;
7961 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
7964 /* For sections that are not SEC_ALLOC a copy reloc would be
7965 output if possible (implying questionable semantics for
7966 read-only data objects) or otherwise the final link would
7967 fail as ld.so will not process them and could not therefore
7968 handle any outstanding dynamic relocations.
7970 For such sections that are also SEC_DEBUGGING, we can avoid
7971 these problems by simply ignoring any relocs as these
7972 sections have a predefined use and we know it is safe to do
7975 This is needed in cases such as a global symbol definition
7976 in a shared library causing a common symbol from an object
7977 file to be converted to an undefined reference. If that
7978 happens, then all the relocations against this symbol from
7979 SEC_DEBUGGING sections in the object file will resolve to
7981 if ((sec
->flags
& SEC_DEBUGGING
) != 0)
7986 /* Most static relocations require pointer equality, except
7989 h
->pointer_equality_needed
= TRUE
;
7995 case R_MICROMIPS_26_S1
:
7996 case R_MICROMIPS_PC7_S1
:
7997 case R_MICROMIPS_PC10_S1
:
7998 case R_MICROMIPS_PC16_S1
:
7999 case R_MICROMIPS_PC23_S2
:
8001 ((struct mips_elf_link_hash_entry
*) h
)->has_static_relocs
= TRUE
;
8007 /* Relocations against the special VxWorks __GOTT_BASE__ and
8008 __GOTT_INDEX__ symbols must be left to the loader. Allocate
8009 room for them in .rela.dyn. */
8010 if (is_gott_symbol (info
, h
))
8014 sreloc
= mips_elf_rel_dyn_section (info
, TRUE
);
8018 mips_elf_allocate_dynamic_relocations (dynobj
, info
, 1);
8019 if (MIPS_ELF_READONLY_SECTION (sec
))
8020 /* We tell the dynamic linker that there are
8021 relocations against the text segment. */
8022 info
->flags
|= DF_TEXTREL
;
8025 else if (call_lo16_reloc_p (r_type
)
8026 || got_lo16_reloc_p (r_type
)
8027 || got_disp_reloc_p (r_type
)
8028 || (got16_reloc_p (r_type
) && htab
->is_vxworks
))
8030 /* We may need a local GOT entry for this relocation. We
8031 don't count R_MIPS_GOT_PAGE because we can estimate the
8032 maximum number of pages needed by looking at the size of
8033 the segment. Similar comments apply to R_MIPS*_GOT16 and
8034 R_MIPS*_CALL16, except on VxWorks, where GOT relocations
8035 always evaluate to "G". We don't count R_MIPS_GOT_HI16, or
8036 R_MIPS_CALL_HI16 because these are always followed by an
8037 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
8038 if (!mips_elf_record_local_got_symbol (abfd
, r_symndx
,
8039 rel
->r_addend
, info
, r_type
))
8044 && mips_elf_relocation_needs_la25_stub (abfd
, r_type
,
8045 ELF_ST_IS_MIPS16 (h
->other
)))
8046 ((struct mips_elf_link_hash_entry
*) h
)->has_nonpic_branches
= TRUE
;
8051 case R_MIPS16_CALL16
:
8052 case R_MICROMIPS_CALL16
:
8055 (*_bfd_error_handler
)
8056 (_("%B: CALL16 reloc at 0x%lx not against global symbol"),
8057 abfd
, (unsigned long) rel
->r_offset
);
8058 bfd_set_error (bfd_error_bad_value
);
8063 case R_MIPS_CALL_HI16
:
8064 case R_MIPS_CALL_LO16
:
8065 case R_MICROMIPS_CALL_HI16
:
8066 case R_MICROMIPS_CALL_LO16
:
8069 /* Make sure there is room in the regular GOT to hold the
8070 function's address. We may eliminate it in favour of
8071 a .got.plt entry later; see mips_elf_count_got_symbols. */
8072 if (!mips_elf_record_global_got_symbol (h
, abfd
, info
, TRUE
,
8076 /* We need a stub, not a plt entry for the undefined
8077 function. But we record it as if it needs plt. See
8078 _bfd_elf_adjust_dynamic_symbol. */
8084 case R_MIPS_GOT_PAGE
:
8085 case R_MICROMIPS_GOT_PAGE
:
8086 /* If this is a global, overridable symbol, GOT_PAGE will
8087 decay to GOT_DISP, so we'll need a GOT entry for it. */
8090 struct mips_elf_link_hash_entry
*hmips
=
8091 (struct mips_elf_link_hash_entry
*) h
;
8093 /* This symbol is definitely not overridable. */
8094 if (hmips
->root
.def_regular
8095 && ! (info
->shared
&& ! info
->symbolic
8096 && ! hmips
->root
.forced_local
))
8101 case R_MIPS16_GOT16
:
8103 case R_MIPS_GOT_HI16
:
8104 case R_MIPS_GOT_LO16
:
8105 case R_MICROMIPS_GOT16
:
8106 case R_MICROMIPS_GOT_HI16
:
8107 case R_MICROMIPS_GOT_LO16
:
8108 if (!h
|| got_page_reloc_p (r_type
))
8110 /* This relocation needs (or may need, if h != NULL) a
8111 page entry in the GOT. For R_MIPS_GOT_PAGE we do not
8112 know for sure until we know whether the symbol is
8114 if (mips_elf_rel_relocation_p (abfd
, sec
, relocs
, rel
))
8116 if (!mips_elf_get_section_contents (abfd
, sec
, &contents
))
8118 howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, r_type
, FALSE
);
8119 addend
= mips_elf_read_rel_addend (abfd
, rel
,
8121 if (got16_reloc_p (r_type
))
8122 mips_elf_add_lo16_rel_addend (abfd
, rel
, rel_end
,
8125 addend
<<= howto
->rightshift
;
8128 addend
= rel
->r_addend
;
8129 if (!mips_elf_record_got_page_entry (info
, abfd
, r_symndx
,
8135 case R_MIPS_GOT_DISP
:
8136 case R_MICROMIPS_GOT_DISP
:
8137 if (h
&& !mips_elf_record_global_got_symbol (h
, abfd
, info
,
8142 case R_MIPS_TLS_GOTTPREL
:
8143 case R_MIPS16_TLS_GOTTPREL
:
8144 case R_MICROMIPS_TLS_GOTTPREL
:
8146 info
->flags
|= DF_STATIC_TLS
;
8149 case R_MIPS_TLS_LDM
:
8150 case R_MIPS16_TLS_LDM
:
8151 case R_MICROMIPS_TLS_LDM
:
8152 if (tls_ldm_reloc_p (r_type
))
8154 r_symndx
= STN_UNDEF
;
8160 case R_MIPS16_TLS_GD
:
8161 case R_MICROMIPS_TLS_GD
:
8162 /* This symbol requires a global offset table entry, or two
8163 for TLS GD relocations. */
8166 if (!mips_elf_record_global_got_symbol (h
, abfd
, info
,
8172 if (!mips_elf_record_local_got_symbol (abfd
, r_symndx
,
8182 /* In VxWorks executables, references to external symbols
8183 are handled using copy relocs or PLT stubs, so there's
8184 no need to add a .rela.dyn entry for this relocation. */
8185 if (can_make_dynamic_p
)
8189 sreloc
= mips_elf_rel_dyn_section (info
, TRUE
);
8193 if (info
->shared
&& h
== NULL
)
8195 /* When creating a shared object, we must copy these
8196 reloc types into the output file as R_MIPS_REL32
8197 relocs. Make room for this reloc in .rel(a).dyn. */
8198 mips_elf_allocate_dynamic_relocations (dynobj
, info
, 1);
8199 if (MIPS_ELF_READONLY_SECTION (sec
))
8200 /* We tell the dynamic linker that there are
8201 relocations against the text segment. */
8202 info
->flags
|= DF_TEXTREL
;
8206 struct mips_elf_link_hash_entry
*hmips
;
8208 /* For a shared object, we must copy this relocation
8209 unless the symbol turns out to be undefined and
8210 weak with non-default visibility, in which case
8211 it will be left as zero.
8213 We could elide R_MIPS_REL32 for locally binding symbols
8214 in shared libraries, but do not yet do so.
8216 For an executable, we only need to copy this
8217 reloc if the symbol is defined in a dynamic
8219 hmips
= (struct mips_elf_link_hash_entry
*) h
;
8220 ++hmips
->possibly_dynamic_relocs
;
8221 if (MIPS_ELF_READONLY_SECTION (sec
))
8222 /* We need it to tell the dynamic linker if there
8223 are relocations against the text segment. */
8224 hmips
->readonly_reloc
= TRUE
;
8228 if (SGI_COMPAT (abfd
))
8229 mips_elf_hash_table (info
)->compact_rel_size
+=
8230 sizeof (Elf32_External_crinfo
);
8234 case R_MIPS_GPREL16
:
8235 case R_MIPS_LITERAL
:
8236 case R_MIPS_GPREL32
:
8237 case R_MICROMIPS_26_S1
:
8238 case R_MICROMIPS_GPREL16
:
8239 case R_MICROMIPS_LITERAL
:
8240 case R_MICROMIPS_GPREL7_S2
:
8241 if (SGI_COMPAT (abfd
))
8242 mips_elf_hash_table (info
)->compact_rel_size
+=
8243 sizeof (Elf32_External_crinfo
);
8246 /* This relocation describes the C++ object vtable hierarchy.
8247 Reconstruct it for later use during GC. */
8248 case R_MIPS_GNU_VTINHERIT
:
8249 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
8253 /* This relocation describes which C++ vtable entries are actually
8254 used. Record for later use during GC. */
8255 case R_MIPS_GNU_VTENTRY
:
8256 BFD_ASSERT (h
!= NULL
);
8258 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
8266 /* We must not create a stub for a symbol that has relocations
8267 related to taking the function's address. This doesn't apply to
8268 VxWorks, where CALL relocs refer to a .got.plt entry instead of
8269 a normal .got entry. */
8270 if (!htab
->is_vxworks
&& h
!= NULL
)
8274 ((struct mips_elf_link_hash_entry
*) h
)->no_fn_stub
= TRUE
;
8276 case R_MIPS16_CALL16
:
8278 case R_MIPS_CALL_HI16
:
8279 case R_MIPS_CALL_LO16
:
8281 case R_MICROMIPS_CALL16
:
8282 case R_MICROMIPS_CALL_HI16
:
8283 case R_MICROMIPS_CALL_LO16
:
8284 case R_MICROMIPS_JALR
:
8288 /* See if this reloc would need to refer to a MIPS16 hard-float stub,
8289 if there is one. We only need to handle global symbols here;
8290 we decide whether to keep or delete stubs for local symbols
8291 when processing the stub's relocations. */
8293 && !mips16_call_reloc_p (r_type
)
8294 && !section_allows_mips16_refs_p (sec
))
8296 struct mips_elf_link_hash_entry
*mh
;
8298 mh
= (struct mips_elf_link_hash_entry
*) h
;
8299 mh
->need_fn_stub
= TRUE
;
8302 /* Refuse some position-dependent relocations when creating a
8303 shared library. Do not refuse R_MIPS_32 / R_MIPS_64; they're
8304 not PIC, but we can create dynamic relocations and the result
8305 will be fine. Also do not refuse R_MIPS_LO16, which can be
8306 combined with R_MIPS_GOT16. */
8314 case R_MIPS_HIGHEST
:
8315 case R_MICROMIPS_HI16
:
8316 case R_MICROMIPS_HIGHER
:
8317 case R_MICROMIPS_HIGHEST
:
8318 /* Don't refuse a high part relocation if it's against
8319 no symbol (e.g. part of a compound relocation). */
8320 if (r_symndx
== STN_UNDEF
)
8323 /* R_MIPS_HI16 against _gp_disp is used for $gp setup,
8324 and has a special meaning. */
8325 if (!NEWABI_P (abfd
) && h
!= NULL
8326 && strcmp (h
->root
.root
.string
, "_gp_disp") == 0)
8329 /* Likewise __GOTT_BASE__ and __GOTT_INDEX__ on VxWorks. */
8330 if (is_gott_symbol (info
, h
))
8337 case R_MICROMIPS_26_S1
:
8338 howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, r_type
, FALSE
);
8339 (*_bfd_error_handler
)
8340 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
8342 (h
) ? h
->root
.root
.string
: "a local symbol");
8343 bfd_set_error (bfd_error_bad_value
);
8355 _bfd_mips_relax_section (bfd
*abfd
, asection
*sec
,
8356 struct bfd_link_info
*link_info
,
8359 Elf_Internal_Rela
*internal_relocs
;
8360 Elf_Internal_Rela
*irel
, *irelend
;
8361 Elf_Internal_Shdr
*symtab_hdr
;
8362 bfd_byte
*contents
= NULL
;
8364 bfd_boolean changed_contents
= FALSE
;
8365 bfd_vma sec_start
= sec
->output_section
->vma
+ sec
->output_offset
;
8366 Elf_Internal_Sym
*isymbuf
= NULL
;
8368 /* We are not currently changing any sizes, so only one pass. */
8371 if (link_info
->relocatable
)
8374 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
8375 link_info
->keep_memory
);
8376 if (internal_relocs
== NULL
)
8379 irelend
= internal_relocs
+ sec
->reloc_count
8380 * get_elf_backend_data (abfd
)->s
->int_rels_per_ext_rel
;
8381 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
8382 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
8384 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
8387 bfd_signed_vma sym_offset
;
8388 unsigned int r_type
;
8389 unsigned long r_symndx
;
8391 unsigned long instruction
;
8393 /* Turn jalr into bgezal, and jr into beq, if they're marked
8394 with a JALR relocation, that indicate where they jump to.
8395 This saves some pipeline bubbles. */
8396 r_type
= ELF_R_TYPE (abfd
, irel
->r_info
);
8397 if (r_type
!= R_MIPS_JALR
)
8400 r_symndx
= ELF_R_SYM (abfd
, irel
->r_info
);
8401 /* Compute the address of the jump target. */
8402 if (r_symndx
>= extsymoff
)
8404 struct mips_elf_link_hash_entry
*h
8405 = ((struct mips_elf_link_hash_entry
*)
8406 elf_sym_hashes (abfd
) [r_symndx
- extsymoff
]);
8408 while (h
->root
.root
.type
== bfd_link_hash_indirect
8409 || h
->root
.root
.type
== bfd_link_hash_warning
)
8410 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
8412 /* If a symbol is undefined, or if it may be overridden,
8414 if (! ((h
->root
.root
.type
== bfd_link_hash_defined
8415 || h
->root
.root
.type
== bfd_link_hash_defweak
)
8416 && h
->root
.root
.u
.def
.section
)
8417 || (link_info
->shared
&& ! link_info
->symbolic
8418 && !h
->root
.forced_local
))
8421 sym_sec
= h
->root
.root
.u
.def
.section
;
8422 if (sym_sec
->output_section
)
8423 symval
= (h
->root
.root
.u
.def
.value
8424 + sym_sec
->output_section
->vma
8425 + sym_sec
->output_offset
);
8427 symval
= h
->root
.root
.u
.def
.value
;
8431 Elf_Internal_Sym
*isym
;
8433 /* Read this BFD's symbols if we haven't done so already. */
8434 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
8436 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
8437 if (isymbuf
== NULL
)
8438 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
8439 symtab_hdr
->sh_info
, 0,
8441 if (isymbuf
== NULL
)
8445 isym
= isymbuf
+ r_symndx
;
8446 if (isym
->st_shndx
== SHN_UNDEF
)
8448 else if (isym
->st_shndx
== SHN_ABS
)
8449 sym_sec
= bfd_abs_section_ptr
;
8450 else if (isym
->st_shndx
== SHN_COMMON
)
8451 sym_sec
= bfd_com_section_ptr
;
8454 = bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
8455 symval
= isym
->st_value
8456 + sym_sec
->output_section
->vma
8457 + sym_sec
->output_offset
;
8460 /* Compute branch offset, from delay slot of the jump to the
8462 sym_offset
= (symval
+ irel
->r_addend
)
8463 - (sec_start
+ irel
->r_offset
+ 4);
8465 /* Branch offset must be properly aligned. */
8466 if ((sym_offset
& 3) != 0)
8471 /* Check that it's in range. */
8472 if (sym_offset
< -0x8000 || sym_offset
>= 0x8000)
8475 /* Get the section contents if we haven't done so already. */
8476 if (!mips_elf_get_section_contents (abfd
, sec
, &contents
))
8479 instruction
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
8481 /* If it was jalr <reg>, turn it into bgezal $zero, <target>. */
8482 if ((instruction
& 0xfc1fffff) == 0x0000f809)
8483 instruction
= 0x04110000;
8484 /* If it was jr <reg>, turn it into b <target>. */
8485 else if ((instruction
& 0xfc1fffff) == 0x00000008)
8486 instruction
= 0x10000000;
8490 instruction
|= (sym_offset
& 0xffff);
8491 bfd_put_32 (abfd
, instruction
, contents
+ irel
->r_offset
);
8492 changed_contents
= TRUE
;
8495 if (contents
!= NULL
8496 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
8498 if (!changed_contents
&& !link_info
->keep_memory
)
8502 /* Cache the section contents for elf_link_input_bfd. */
8503 elf_section_data (sec
)->this_hdr
.contents
= contents
;
8509 if (contents
!= NULL
8510 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
8515 /* Allocate space for global sym dynamic relocs. */
8518 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
8520 struct bfd_link_info
*info
= inf
;
8522 struct mips_elf_link_hash_entry
*hmips
;
8523 struct mips_elf_link_hash_table
*htab
;
8525 htab
= mips_elf_hash_table (info
);
8526 BFD_ASSERT (htab
!= NULL
);
8528 dynobj
= elf_hash_table (info
)->dynobj
;
8529 hmips
= (struct mips_elf_link_hash_entry
*) h
;
8531 /* VxWorks executables are handled elsewhere; we only need to
8532 allocate relocations in shared objects. */
8533 if (htab
->is_vxworks
&& !info
->shared
)
8536 /* Ignore indirect symbols. All relocations against such symbols
8537 will be redirected to the target symbol. */
8538 if (h
->root
.type
== bfd_link_hash_indirect
)
8541 /* If this symbol is defined in a dynamic object, or we are creating
8542 a shared library, we will need to copy any R_MIPS_32 or
8543 R_MIPS_REL32 relocs against it into the output file. */
8544 if (! info
->relocatable
8545 && hmips
->possibly_dynamic_relocs
!= 0
8546 && (h
->root
.type
== bfd_link_hash_defweak
8547 || (!h
->def_regular
&& !ELF_COMMON_DEF_P (h
))
8550 bfd_boolean do_copy
= TRUE
;
8552 if (h
->root
.type
== bfd_link_hash_undefweak
)
8554 /* Do not copy relocations for undefined weak symbols with
8555 non-default visibility. */
8556 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
8559 /* Make sure undefined weak symbols are output as a dynamic
8561 else if (h
->dynindx
== -1 && !h
->forced_local
)
8563 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
8570 /* Even though we don't directly need a GOT entry for this symbol,
8571 the SVR4 psABI requires it to have a dynamic symbol table
8572 index greater that DT_MIPS_GOTSYM if there are dynamic
8573 relocations against it.
8575 VxWorks does not enforce the same mapping between the GOT
8576 and the symbol table, so the same requirement does not
8578 if (!htab
->is_vxworks
)
8580 if (hmips
->global_got_area
> GGA_RELOC_ONLY
)
8581 hmips
->global_got_area
= GGA_RELOC_ONLY
;
8582 hmips
->got_only_for_calls
= FALSE
;
8585 mips_elf_allocate_dynamic_relocations
8586 (dynobj
, info
, hmips
->possibly_dynamic_relocs
);
8587 if (hmips
->readonly_reloc
)
8588 /* We tell the dynamic linker that there are relocations
8589 against the text segment. */
8590 info
->flags
|= DF_TEXTREL
;
8597 /* Adjust a symbol defined by a dynamic object and referenced by a
8598 regular object. The current definition is in some section of the
8599 dynamic object, but we're not including those sections. We have to
8600 change the definition to something the rest of the link can
8604 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
8605 struct elf_link_hash_entry
*h
)
8608 struct mips_elf_link_hash_entry
*hmips
;
8609 struct mips_elf_link_hash_table
*htab
;
8611 htab
= mips_elf_hash_table (info
);
8612 BFD_ASSERT (htab
!= NULL
);
8614 dynobj
= elf_hash_table (info
)->dynobj
;
8615 hmips
= (struct mips_elf_link_hash_entry
*) h
;
8617 /* Make sure we know what is going on here. */
8618 BFD_ASSERT (dynobj
!= NULL
8620 || h
->u
.weakdef
!= NULL
8623 && !h
->def_regular
)));
8625 hmips
= (struct mips_elf_link_hash_entry
*) h
;
8627 /* If there are call relocations against an externally-defined symbol,
8628 see whether we can create a MIPS lazy-binding stub for it. We can
8629 only do this if all references to the function are through call
8630 relocations, and in that case, the traditional lazy-binding stubs
8631 are much more efficient than PLT entries.
8633 Traditional stubs are only available on SVR4 psABI-based systems;
8634 VxWorks always uses PLTs instead. */
8635 if (!htab
->is_vxworks
&& h
->needs_plt
&& !hmips
->no_fn_stub
)
8637 if (! elf_hash_table (info
)->dynamic_sections_created
)
8640 /* If this symbol is not defined in a regular file, then set
8641 the symbol to the stub location. This is required to make
8642 function pointers compare as equal between the normal
8643 executable and the shared library. */
8644 if (!h
->def_regular
)
8646 hmips
->needs_lazy_stub
= TRUE
;
8647 htab
->lazy_stub_count
++;
8651 /* As above, VxWorks requires PLT entries for externally-defined
8652 functions that are only accessed through call relocations.
8654 Both VxWorks and non-VxWorks targets also need PLT entries if there
8655 are static-only relocations against an externally-defined function.
8656 This can technically occur for shared libraries if there are
8657 branches to the symbol, although it is unlikely that this will be
8658 used in practice due to the short ranges involved. It can occur
8659 for any relative or absolute relocation in executables; in that
8660 case, the PLT entry becomes the function's canonical address. */
8661 else if (((h
->needs_plt
&& !hmips
->no_fn_stub
)
8662 || (h
->type
== STT_FUNC
&& hmips
->has_static_relocs
))
8663 && htab
->use_plts_and_copy_relocs
8664 && !SYMBOL_CALLS_LOCAL (info
, h
)
8665 && !(ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
8666 && h
->root
.type
== bfd_link_hash_undefweak
))
8668 /* If this is the first symbol to need a PLT entry, allocate room
8670 if (htab
->splt
->size
== 0)
8672 BFD_ASSERT (htab
->sgotplt
->size
== 0);
8674 /* If we're using the PLT additions to the psABI, each PLT
8675 entry is 16 bytes and the PLT0 entry is 32 bytes.
8676 Encourage better cache usage by aligning. We do this
8677 lazily to avoid pessimizing traditional objects. */
8678 if (!htab
->is_vxworks
8679 && !bfd_set_section_alignment (dynobj
, htab
->splt
, 5))
8682 /* Make sure that .got.plt is word-aligned. We do this lazily
8683 for the same reason as above. */
8684 if (!bfd_set_section_alignment (dynobj
, htab
->sgotplt
,
8685 MIPS_ELF_LOG_FILE_ALIGN (dynobj
)))
8688 htab
->splt
->size
+= htab
->plt_header_size
;
8690 /* On non-VxWorks targets, the first two entries in .got.plt
8692 if (!htab
->is_vxworks
)
8694 += get_elf_backend_data (dynobj
)->got_header_size
;
8696 /* On VxWorks, also allocate room for the header's
8697 .rela.plt.unloaded entries. */
8698 if (htab
->is_vxworks
&& !info
->shared
)
8699 htab
->srelplt2
->size
+= 2 * sizeof (Elf32_External_Rela
);
8702 /* Assign the next .plt entry to this symbol. */
8703 h
->plt
.offset
= htab
->splt
->size
;
8704 htab
->splt
->size
+= htab
->plt_entry_size
;
8706 /* If the output file has no definition of the symbol, set the
8707 symbol's value to the address of the stub. */
8708 if (!info
->shared
&& !h
->def_regular
)
8710 h
->root
.u
.def
.section
= htab
->splt
;
8711 h
->root
.u
.def
.value
= h
->plt
.offset
;
8712 /* For VxWorks, point at the PLT load stub rather than the
8713 lazy resolution stub; this stub will become the canonical
8714 function address. */
8715 if (htab
->is_vxworks
)
8716 h
->root
.u
.def
.value
+= 8;
8719 /* Make room for the .got.plt entry and the R_MIPS_JUMP_SLOT
8721 htab
->sgotplt
->size
+= MIPS_ELF_GOT_SIZE (dynobj
);
8722 htab
->srelplt
->size
+= (htab
->is_vxworks
8723 ? MIPS_ELF_RELA_SIZE (dynobj
)
8724 : MIPS_ELF_REL_SIZE (dynobj
));
8726 /* Make room for the .rela.plt.unloaded relocations. */
8727 if (htab
->is_vxworks
&& !info
->shared
)
8728 htab
->srelplt2
->size
+= 3 * sizeof (Elf32_External_Rela
);
8730 /* All relocations against this symbol that could have been made
8731 dynamic will now refer to the PLT entry instead. */
8732 hmips
->possibly_dynamic_relocs
= 0;
8737 /* If this is a weak symbol, and there is a real definition, the
8738 processor independent code will have arranged for us to see the
8739 real definition first, and we can just use the same value. */
8740 if (h
->u
.weakdef
!= NULL
)
8742 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
8743 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
8744 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
8745 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
8749 /* Otherwise, there is nothing further to do for symbols defined
8750 in regular objects. */
8754 /* There's also nothing more to do if we'll convert all relocations
8755 against this symbol into dynamic relocations. */
8756 if (!hmips
->has_static_relocs
)
8759 /* We're now relying on copy relocations. Complain if we have
8760 some that we can't convert. */
8761 if (!htab
->use_plts_and_copy_relocs
|| info
->shared
)
8763 (*_bfd_error_handler
) (_("non-dynamic relocations refer to "
8764 "dynamic symbol %s"),
8765 h
->root
.root
.string
);
8766 bfd_set_error (bfd_error_bad_value
);
8770 /* We must allocate the symbol in our .dynbss section, which will
8771 become part of the .bss section of the executable. There will be
8772 an entry for this symbol in the .dynsym section. The dynamic
8773 object will contain position independent code, so all references
8774 from the dynamic object to this symbol will go through the global
8775 offset table. The dynamic linker will use the .dynsym entry to
8776 determine the address it must put in the global offset table, so
8777 both the dynamic object and the regular object will refer to the
8778 same memory location for the variable. */
8780 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
8782 if (htab
->is_vxworks
)
8783 htab
->srelbss
->size
+= sizeof (Elf32_External_Rela
);
8785 mips_elf_allocate_dynamic_relocations (dynobj
, info
, 1);
8789 /* All relocations against this symbol that could have been made
8790 dynamic will now refer to the local copy instead. */
8791 hmips
->possibly_dynamic_relocs
= 0;
8793 return _bfd_elf_adjust_dynamic_copy (h
, htab
->sdynbss
);
8796 /* This function is called after all the input files have been read,
8797 and the input sections have been assigned to output sections. We
8798 check for any mips16 stub sections that we can discard. */
8801 _bfd_mips_elf_always_size_sections (bfd
*output_bfd
,
8802 struct bfd_link_info
*info
)
8805 struct mips_elf_link_hash_table
*htab
;
8806 struct mips_htab_traverse_info hti
;
8808 htab
= mips_elf_hash_table (info
);
8809 BFD_ASSERT (htab
!= NULL
);
8811 /* The .reginfo section has a fixed size. */
8812 ri
= bfd_get_section_by_name (output_bfd
, ".reginfo");
8814 bfd_set_section_size (output_bfd
, ri
, sizeof (Elf32_External_RegInfo
));
8817 hti
.output_bfd
= output_bfd
;
8819 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
8820 mips_elf_check_symbols
, &hti
);
8827 /* If the link uses a GOT, lay it out and work out its size. */
8830 mips_elf_lay_out_got (bfd
*output_bfd
, struct bfd_link_info
*info
)
8834 struct mips_got_info
*g
;
8835 bfd_size_type loadable_size
= 0;
8836 bfd_size_type page_gotno
;
8838 struct mips_elf_traverse_got_arg tga
;
8839 struct mips_elf_link_hash_table
*htab
;
8841 htab
= mips_elf_hash_table (info
);
8842 BFD_ASSERT (htab
!= NULL
);
8848 dynobj
= elf_hash_table (info
)->dynobj
;
8851 /* Allocate room for the reserved entries. VxWorks always reserves
8852 3 entries; other objects only reserve 2 entries. */
8853 BFD_ASSERT (g
->assigned_gotno
== 0);
8854 if (htab
->is_vxworks
)
8855 htab
->reserved_gotno
= 3;
8857 htab
->reserved_gotno
= 2;
8858 g
->local_gotno
+= htab
->reserved_gotno
;
8859 g
->assigned_gotno
= htab
->reserved_gotno
;
8861 /* Replace entries for indirect and warning symbols with entries for
8862 the target symbol. */
8863 if (!mips_elf_resolve_final_got_entries (g
))
8866 /* Count the number of GOT symbols. */
8867 mips_elf_link_hash_traverse (htab
, mips_elf_count_got_symbols
, info
);
8869 /* Calculate the total loadable size of the output. That
8870 will give us the maximum number of GOT_PAGE entries
8872 for (sub
= info
->input_bfds
; sub
; sub
= sub
->link_next
)
8874 asection
*subsection
;
8876 for (subsection
= sub
->sections
;
8878 subsection
= subsection
->next
)
8880 if ((subsection
->flags
& SEC_ALLOC
) == 0)
8882 loadable_size
+= ((subsection
->size
+ 0xf)
8883 &~ (bfd_size_type
) 0xf);
8887 if (htab
->is_vxworks
)
8888 /* There's no need to allocate page entries for VxWorks; R_MIPS*_GOT16
8889 relocations against local symbols evaluate to "G", and the EABI does
8890 not include R_MIPS_GOT_PAGE. */
8893 /* Assume there are two loadable segments consisting of contiguous
8894 sections. Is 5 enough? */
8895 page_gotno
= (loadable_size
>> 16) + 5;
8897 /* Choose the smaller of the two estimates; both are intended to be
8899 if (page_gotno
> g
->page_gotno
)
8900 page_gotno
= g
->page_gotno
;
8902 g
->local_gotno
+= page_gotno
;
8904 /* Count the number of local GOT entries and TLS relocs. */
8907 htab_traverse (g
->got_entries
, mips_elf_count_local_got_entries
, &tga
);
8909 /* We need to calculate tls_gotno for global symbols at this point
8910 instead of building it up earlier, to avoid doublecounting
8911 entries for one global symbol from multiple input files. */
8912 elf_link_hash_traverse (elf_hash_table (info
),
8913 mips_elf_count_global_tls_entries
,
8916 s
->size
+= g
->local_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
8917 s
->size
+= g
->global_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
8918 s
->size
+= g
->tls_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
8920 /* VxWorks does not support multiple GOTs. It initializes $gp to
8921 __GOTT_BASE__[__GOTT_INDEX__], the value of which is set by the
8923 if (htab
->is_vxworks
)
8925 /* VxWorks executables do not need a GOT. */
8928 /* Each VxWorks GOT entry needs an explicit relocation. */
8931 count
= g
->global_gotno
+ g
->local_gotno
- htab
->reserved_gotno
;
8933 mips_elf_allocate_dynamic_relocations (dynobj
, info
, count
);
8936 else if (s
->size
> MIPS_ELF_GOT_MAX_SIZE (info
))
8938 if (!mips_elf_multi_got (output_bfd
, info
, s
, page_gotno
))
8943 /* Set up TLS entries. */
8944 g
->tls_assigned_gotno
= g
->global_gotno
+ g
->local_gotno
;
8947 tga
.value
= MIPS_ELF_GOT_SIZE (output_bfd
);
8948 htab_traverse (g
->got_entries
, mips_elf_initialize_tls_index
, &tga
);
8951 BFD_ASSERT (g
->tls_assigned_gotno
8952 == g
->global_gotno
+ g
->local_gotno
+ g
->tls_gotno
);
8954 /* Allocate room for the TLS relocations. */
8956 mips_elf_allocate_dynamic_relocations (dynobj
, info
, g
->relocs
);
8962 /* Estimate the size of the .MIPS.stubs section. */
8965 mips_elf_estimate_stub_size (bfd
*output_bfd
, struct bfd_link_info
*info
)
8967 struct mips_elf_link_hash_table
*htab
;
8968 bfd_size_type dynsymcount
;
8970 htab
= mips_elf_hash_table (info
);
8971 BFD_ASSERT (htab
!= NULL
);
8973 if (htab
->lazy_stub_count
== 0)
8976 /* IRIX rld assumes that a function stub isn't at the end of the .text
8977 section, so add a dummy entry to the end. */
8978 htab
->lazy_stub_count
++;
8980 /* Get a worst-case estimate of the number of dynamic symbols needed.
8981 At this point, dynsymcount does not account for section symbols
8982 and count_section_dynsyms may overestimate the number that will
8984 dynsymcount
= (elf_hash_table (info
)->dynsymcount
8985 + count_section_dynsyms (output_bfd
, info
));
8987 /* Determine the size of one stub entry. */
8988 htab
->function_stub_size
= (dynsymcount
> 0x10000
8989 ? MIPS_FUNCTION_STUB_BIG_SIZE
8990 : MIPS_FUNCTION_STUB_NORMAL_SIZE
);
8992 htab
->sstubs
->size
= htab
->lazy_stub_count
* htab
->function_stub_size
;
8995 /* A mips_elf_link_hash_traverse callback for which DATA points to the
8996 MIPS hash table. If H needs a traditional MIPS lazy-binding stub,
8997 allocate an entry in the stubs section. */
9000 mips_elf_allocate_lazy_stub (struct mips_elf_link_hash_entry
*h
, void **data
)
9002 struct mips_elf_link_hash_table
*htab
;
9004 htab
= (struct mips_elf_link_hash_table
*) data
;
9005 if (h
->needs_lazy_stub
)
9007 h
->root
.root
.u
.def
.section
= htab
->sstubs
;
9008 h
->root
.root
.u
.def
.value
= htab
->sstubs
->size
;
9009 h
->root
.plt
.offset
= htab
->sstubs
->size
;
9010 htab
->sstubs
->size
+= htab
->function_stub_size
;
9015 /* Allocate offsets in the stubs section to each symbol that needs one.
9016 Set the final size of the .MIPS.stub section. */
9019 mips_elf_lay_out_lazy_stubs (struct bfd_link_info
*info
)
9021 struct mips_elf_link_hash_table
*htab
;
9023 htab
= mips_elf_hash_table (info
);
9024 BFD_ASSERT (htab
!= NULL
);
9026 if (htab
->lazy_stub_count
== 0)
9029 htab
->sstubs
->size
= 0;
9030 mips_elf_link_hash_traverse (htab
, mips_elf_allocate_lazy_stub
, htab
);
9031 htab
->sstubs
->size
+= htab
->function_stub_size
;
9032 BFD_ASSERT (htab
->sstubs
->size
9033 == htab
->lazy_stub_count
* htab
->function_stub_size
);
9036 /* Set the sizes of the dynamic sections. */
9039 _bfd_mips_elf_size_dynamic_sections (bfd
*output_bfd
,
9040 struct bfd_link_info
*info
)
9043 asection
*s
, *sreldyn
;
9044 bfd_boolean reltext
;
9045 struct mips_elf_link_hash_table
*htab
;
9047 htab
= mips_elf_hash_table (info
);
9048 BFD_ASSERT (htab
!= NULL
);
9049 dynobj
= elf_hash_table (info
)->dynobj
;
9050 BFD_ASSERT (dynobj
!= NULL
);
9052 if (elf_hash_table (info
)->dynamic_sections_created
)
9054 /* Set the contents of the .interp section to the interpreter. */
9055 if (info
->executable
)
9057 s
= bfd_get_linker_section (dynobj
, ".interp");
9058 BFD_ASSERT (s
!= NULL
);
9060 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd
)) + 1;
9062 = (bfd_byte
*) ELF_DYNAMIC_INTERPRETER (output_bfd
);
9065 /* Create a symbol for the PLT, if we know that we are using it. */
9066 if (htab
->splt
&& htab
->splt
->size
> 0 && htab
->root
.hplt
== NULL
)
9068 struct elf_link_hash_entry
*h
;
9070 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
9072 h
= _bfd_elf_define_linkage_sym (dynobj
, info
, htab
->splt
,
9073 "_PROCEDURE_LINKAGE_TABLE_");
9074 htab
->root
.hplt
= h
;
9081 /* Allocate space for global sym dynamic relocs. */
9082 elf_link_hash_traverse (&htab
->root
, allocate_dynrelocs
, info
);
9084 mips_elf_estimate_stub_size (output_bfd
, info
);
9086 if (!mips_elf_lay_out_got (output_bfd
, info
))
9089 mips_elf_lay_out_lazy_stubs (info
);
9091 /* The check_relocs and adjust_dynamic_symbol entry points have
9092 determined the sizes of the various dynamic sections. Allocate
9095 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
9099 /* It's OK to base decisions on the section name, because none
9100 of the dynobj section names depend upon the input files. */
9101 name
= bfd_get_section_name (dynobj
, s
);
9103 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
9106 if (CONST_STRNEQ (name
, ".rel"))
9110 const char *outname
;
9113 /* If this relocation section applies to a read only
9114 section, then we probably need a DT_TEXTREL entry.
9115 If the relocation section is .rel(a).dyn, we always
9116 assert a DT_TEXTREL entry rather than testing whether
9117 there exists a relocation to a read only section or
9119 outname
= bfd_get_section_name (output_bfd
,
9121 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
9123 && (target
->flags
& SEC_READONLY
) != 0
9124 && (target
->flags
& SEC_ALLOC
) != 0)
9125 || strcmp (outname
, MIPS_ELF_REL_DYN_NAME (info
)) == 0)
9128 /* We use the reloc_count field as a counter if we need
9129 to copy relocs into the output file. */
9130 if (strcmp (name
, MIPS_ELF_REL_DYN_NAME (info
)) != 0)
9133 /* If combreloc is enabled, elf_link_sort_relocs() will
9134 sort relocations, but in a different way than we do,
9135 and before we're done creating relocations. Also, it
9136 will move them around between input sections'
9137 relocation's contents, so our sorting would be
9138 broken, so don't let it run. */
9139 info
->combreloc
= 0;
9142 else if (! info
->shared
9143 && ! mips_elf_hash_table (info
)->use_rld_obj_head
9144 && CONST_STRNEQ (name
, ".rld_map"))
9146 /* We add a room for __rld_map. It will be filled in by the
9147 rtld to contain a pointer to the _r_debug structure. */
9148 s
->size
+= MIPS_ELF_RLD_MAP_SIZE (output_bfd
);
9150 else if (SGI_COMPAT (output_bfd
)
9151 && CONST_STRNEQ (name
, ".compact_rel"))
9152 s
->size
+= mips_elf_hash_table (info
)->compact_rel_size
;
9153 else if (s
== htab
->splt
)
9155 /* If the last PLT entry has a branch delay slot, allocate
9156 room for an extra nop to fill the delay slot. This is
9157 for CPUs without load interlocking. */
9158 if (! LOAD_INTERLOCKS_P (output_bfd
)
9159 && ! htab
->is_vxworks
&& s
->size
> 0)
9162 else if (! CONST_STRNEQ (name
, ".init")
9164 && s
!= htab
->sgotplt
9165 && s
!= htab
->sstubs
9166 && s
!= htab
->sdynbss
)
9168 /* It's not one of our sections, so don't allocate space. */
9174 s
->flags
|= SEC_EXCLUDE
;
9178 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
9181 /* Allocate memory for the section contents. */
9182 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
9183 if (s
->contents
== NULL
)
9185 bfd_set_error (bfd_error_no_memory
);
9190 if (elf_hash_table (info
)->dynamic_sections_created
)
9192 /* Add some entries to the .dynamic section. We fill in the
9193 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
9194 must add the entries now so that we get the correct size for
9195 the .dynamic section. */
9197 /* SGI object has the equivalence of DT_DEBUG in the
9198 DT_MIPS_RLD_MAP entry. This must come first because glibc
9199 only fills in DT_MIPS_RLD_MAP (not DT_DEBUG) and some tools
9200 may only look at the first one they see. */
9202 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_MAP
, 0))
9205 /* The DT_DEBUG entry may be filled in by the dynamic linker and
9206 used by the debugger. */
9207 if (info
->executable
9208 && !SGI_COMPAT (output_bfd
)
9209 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
9212 if (reltext
&& (SGI_COMPAT (output_bfd
) || htab
->is_vxworks
))
9213 info
->flags
|= DF_TEXTREL
;
9215 if ((info
->flags
& DF_TEXTREL
) != 0)
9217 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_TEXTREL
, 0))
9220 /* Clear the DF_TEXTREL flag. It will be set again if we
9221 write out an actual text relocation; we may not, because
9222 at this point we do not know whether e.g. any .eh_frame
9223 absolute relocations have been converted to PC-relative. */
9224 info
->flags
&= ~DF_TEXTREL
;
9227 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTGOT
, 0))
9230 sreldyn
= mips_elf_rel_dyn_section (info
, FALSE
);
9231 if (htab
->is_vxworks
)
9233 /* VxWorks uses .rela.dyn instead of .rel.dyn. It does not
9234 use any of the DT_MIPS_* tags. */
9235 if (sreldyn
&& sreldyn
->size
> 0)
9237 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELA
, 0))
9240 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELASZ
, 0))
9243 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELAENT
, 0))
9249 if (sreldyn
&& sreldyn
->size
> 0)
9251 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_REL
, 0))
9254 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELSZ
, 0))
9257 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELENT
, 0))
9261 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_VERSION
, 0))
9264 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_FLAGS
, 0))
9267 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_BASE_ADDRESS
, 0))
9270 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LOCAL_GOTNO
, 0))
9273 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_SYMTABNO
, 0))
9276 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_UNREFEXTNO
, 0))
9279 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_GOTSYM
, 0))
9282 if (IRIX_COMPAT (dynobj
) == ict_irix5
9283 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_HIPAGENO
, 0))
9286 if (IRIX_COMPAT (dynobj
) == ict_irix6
9287 && (bfd_get_section_by_name
9288 (output_bfd
, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj
)))
9289 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_OPTIONS
, 0))
9292 if (htab
->splt
->size
> 0)
9294 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTREL
, 0))
9297 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_JMPREL
, 0))
9300 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTRELSZ
, 0))
9303 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_PLTGOT
, 0))
9306 if (htab
->is_vxworks
9307 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
9314 /* REL is a relocation in INPUT_BFD that is being copied to OUTPUT_BFD.
9315 Adjust its R_ADDEND field so that it is correct for the output file.
9316 LOCAL_SYMS and LOCAL_SECTIONS are arrays of INPUT_BFD's local symbols
9317 and sections respectively; both use symbol indexes. */
9320 mips_elf_adjust_addend (bfd
*output_bfd
, struct bfd_link_info
*info
,
9321 bfd
*input_bfd
, Elf_Internal_Sym
*local_syms
,
9322 asection
**local_sections
, Elf_Internal_Rela
*rel
)
9324 unsigned int r_type
, r_symndx
;
9325 Elf_Internal_Sym
*sym
;
9328 if (mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
))
9330 r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
9331 if (gprel16_reloc_p (r_type
)
9332 || r_type
== R_MIPS_GPREL32
9333 || literal_reloc_p (r_type
))
9335 rel
->r_addend
+= _bfd_get_gp_value (input_bfd
);
9336 rel
->r_addend
-= _bfd_get_gp_value (output_bfd
);
9339 r_symndx
= ELF_R_SYM (output_bfd
, rel
->r_info
);
9340 sym
= local_syms
+ r_symndx
;
9342 /* Adjust REL's addend to account for section merging. */
9343 if (!info
->relocatable
)
9345 sec
= local_sections
[r_symndx
];
9346 _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
9349 /* This would normally be done by the rela_normal code in elflink.c. */
9350 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
9351 rel
->r_addend
+= local_sections
[r_symndx
]->output_offset
;
9355 /* Handle relocations against symbols from removed linkonce sections,
9356 or sections discarded by a linker script. We use this wrapper around
9357 RELOC_AGAINST_DISCARDED_SECTION to handle triplets of compound relocs
9358 on 64-bit ELF targets. In this case for any relocation handled, which
9359 always be the first in a triplet, the remaining two have to be processed
9360 together with the first, even if they are R_MIPS_NONE. It is the symbol
9361 index referred by the first reloc that applies to all the three and the
9362 remaining two never refer to an object symbol. And it is the final
9363 relocation (the last non-null one) that determines the output field of
9364 the whole relocation so retrieve the corresponding howto structure for
9365 the relocatable field to be cleared by RELOC_AGAINST_DISCARDED_SECTION.
9367 Note that RELOC_AGAINST_DISCARDED_SECTION is a macro that uses "continue"
9368 and therefore requires to be pasted in a loop. It also defines a block
9369 and does not protect any of its arguments, hence the extra brackets. */
9372 mips_reloc_against_discarded_section (bfd
*output_bfd
,
9373 struct bfd_link_info
*info
,
9374 bfd
*input_bfd
, asection
*input_section
,
9375 Elf_Internal_Rela
**rel
,
9376 const Elf_Internal_Rela
**relend
,
9377 bfd_boolean rel_reloc
,
9378 reloc_howto_type
*howto
,
9381 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
9382 int count
= bed
->s
->int_rels_per_ext_rel
;
9383 unsigned int r_type
;
9386 for (i
= count
- 1; i
> 0; i
--)
9388 r_type
= ELF_R_TYPE (output_bfd
, (*rel
)[i
].r_info
);
9389 if (r_type
!= R_MIPS_NONE
)
9391 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, r_type
, !rel_reloc
);
9397 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
9398 (*rel
), count
, (*relend
),
9399 howto
, i
, contents
);
9404 /* Relocate a MIPS ELF section. */
9407 _bfd_mips_elf_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
9408 bfd
*input_bfd
, asection
*input_section
,
9409 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
9410 Elf_Internal_Sym
*local_syms
,
9411 asection
**local_sections
)
9413 Elf_Internal_Rela
*rel
;
9414 const Elf_Internal_Rela
*relend
;
9416 bfd_boolean use_saved_addend_p
= FALSE
;
9417 const struct elf_backend_data
*bed
;
9419 bed
= get_elf_backend_data (output_bfd
);
9420 relend
= relocs
+ input_section
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
9421 for (rel
= relocs
; rel
< relend
; ++rel
)
9425 reloc_howto_type
*howto
;
9426 bfd_boolean cross_mode_jump_p
;
9427 /* TRUE if the relocation is a RELA relocation, rather than a
9429 bfd_boolean rela_relocation_p
= TRUE
;
9430 unsigned int r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
9432 unsigned long r_symndx
;
9434 Elf_Internal_Shdr
*symtab_hdr
;
9435 struct elf_link_hash_entry
*h
;
9436 bfd_boolean rel_reloc
;
9438 rel_reloc
= (NEWABI_P (input_bfd
)
9439 && mips_elf_rel_relocation_p (input_bfd
, input_section
,
9441 /* Find the relocation howto for this relocation. */
9442 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, r_type
, !rel_reloc
);
9444 r_symndx
= ELF_R_SYM (input_bfd
, rel
->r_info
);
9445 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
9446 if (mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
))
9448 sec
= local_sections
[r_symndx
];
9453 unsigned long extsymoff
;
9456 if (!elf_bad_symtab (input_bfd
))
9457 extsymoff
= symtab_hdr
->sh_info
;
9458 h
= elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
];
9459 while (h
->root
.type
== bfd_link_hash_indirect
9460 || h
->root
.type
== bfd_link_hash_warning
)
9461 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
9464 if (h
->root
.type
== bfd_link_hash_defined
9465 || h
->root
.type
== bfd_link_hash_defweak
)
9466 sec
= h
->root
.u
.def
.section
;
9469 if (sec
!= NULL
&& discarded_section (sec
))
9471 mips_reloc_against_discarded_section (output_bfd
, info
, input_bfd
,
9472 input_section
, &rel
, &relend
,
9473 rel_reloc
, howto
, contents
);
9477 if (r_type
== R_MIPS_64
&& ! NEWABI_P (input_bfd
))
9479 /* Some 32-bit code uses R_MIPS_64. In particular, people use
9480 64-bit code, but make sure all their addresses are in the
9481 lowermost or uppermost 32-bit section of the 64-bit address
9482 space. Thus, when they use an R_MIPS_64 they mean what is
9483 usually meant by R_MIPS_32, with the exception that the
9484 stored value is sign-extended to 64 bits. */
9485 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, R_MIPS_32
, FALSE
);
9487 /* On big-endian systems, we need to lie about the position
9489 if (bfd_big_endian (input_bfd
))
9493 if (!use_saved_addend_p
)
9495 /* If these relocations were originally of the REL variety,
9496 we must pull the addend out of the field that will be
9497 relocated. Otherwise, we simply use the contents of the
9499 if (mips_elf_rel_relocation_p (input_bfd
, input_section
,
9502 rela_relocation_p
= FALSE
;
9503 addend
= mips_elf_read_rel_addend (input_bfd
, rel
,
9505 if (hi16_reloc_p (r_type
)
9506 || (got16_reloc_p (r_type
)
9507 && mips_elf_local_relocation_p (input_bfd
, rel
,
9510 if (!mips_elf_add_lo16_rel_addend (input_bfd
, rel
, relend
,
9514 name
= h
->root
.root
.string
;
9516 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
9517 local_syms
+ r_symndx
,
9519 (*_bfd_error_handler
)
9520 (_("%B: Can't find matching LO16 reloc against `%s' for %s at 0x%lx in section `%A'"),
9521 input_bfd
, input_section
, name
, howto
->name
,
9526 addend
<<= howto
->rightshift
;
9529 addend
= rel
->r_addend
;
9530 mips_elf_adjust_addend (output_bfd
, info
, input_bfd
,
9531 local_syms
, local_sections
, rel
);
9534 if (info
->relocatable
)
9536 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
)
9537 && bfd_big_endian (input_bfd
))
9540 if (!rela_relocation_p
&& rel
->r_addend
)
9542 addend
+= rel
->r_addend
;
9543 if (hi16_reloc_p (r_type
) || got16_reloc_p (r_type
))
9544 addend
= mips_elf_high (addend
);
9545 else if (r_type
== R_MIPS_HIGHER
)
9546 addend
= mips_elf_higher (addend
);
9547 else if (r_type
== R_MIPS_HIGHEST
)
9548 addend
= mips_elf_highest (addend
);
9550 addend
>>= howto
->rightshift
;
9552 /* We use the source mask, rather than the destination
9553 mask because the place to which we are writing will be
9554 source of the addend in the final link. */
9555 addend
&= howto
->src_mask
;
9557 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
9558 /* See the comment above about using R_MIPS_64 in the 32-bit
9559 ABI. Here, we need to update the addend. It would be
9560 possible to get away with just using the R_MIPS_32 reloc
9561 but for endianness. */
9567 if (addend
& ((bfd_vma
) 1 << 31))
9569 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
9576 /* If we don't know that we have a 64-bit type,
9577 do two separate stores. */
9578 if (bfd_big_endian (input_bfd
))
9580 /* Store the sign-bits (which are most significant)
9582 low_bits
= sign_bits
;
9588 high_bits
= sign_bits
;
9590 bfd_put_32 (input_bfd
, low_bits
,
9591 contents
+ rel
->r_offset
);
9592 bfd_put_32 (input_bfd
, high_bits
,
9593 contents
+ rel
->r_offset
+ 4);
9597 if (! mips_elf_perform_relocation (info
, howto
, rel
, addend
,
9598 input_bfd
, input_section
,
9603 /* Go on to the next relocation. */
9607 /* In the N32 and 64-bit ABIs there may be multiple consecutive
9608 relocations for the same offset. In that case we are
9609 supposed to treat the output of each relocation as the addend
9611 if (rel
+ 1 < relend
9612 && rel
->r_offset
== rel
[1].r_offset
9613 && ELF_R_TYPE (input_bfd
, rel
[1].r_info
) != R_MIPS_NONE
)
9614 use_saved_addend_p
= TRUE
;
9616 use_saved_addend_p
= FALSE
;
9618 /* Figure out what value we are supposed to relocate. */
9619 switch (mips_elf_calculate_relocation (output_bfd
, input_bfd
,
9620 input_section
, info
, rel
,
9621 addend
, howto
, local_syms
,
9622 local_sections
, &value
,
9623 &name
, &cross_mode_jump_p
,
9624 use_saved_addend_p
))
9626 case bfd_reloc_continue
:
9627 /* There's nothing to do. */
9630 case bfd_reloc_undefined
:
9631 /* mips_elf_calculate_relocation already called the
9632 undefined_symbol callback. There's no real point in
9633 trying to perform the relocation at this point, so we
9634 just skip ahead to the next relocation. */
9637 case bfd_reloc_notsupported
:
9638 msg
= _("internal error: unsupported relocation error");
9639 info
->callbacks
->warning
9640 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
9643 case bfd_reloc_overflow
:
9644 if (use_saved_addend_p
)
9645 /* Ignore overflow until we reach the last relocation for
9646 a given location. */
9650 struct mips_elf_link_hash_table
*htab
;
9652 htab
= mips_elf_hash_table (info
);
9653 BFD_ASSERT (htab
!= NULL
);
9654 BFD_ASSERT (name
!= NULL
);
9655 if (!htab
->small_data_overflow_reported
9656 && (gprel16_reloc_p (howto
->type
)
9657 || literal_reloc_p (howto
->type
)))
9659 msg
= _("small-data section exceeds 64KB;"
9660 " lower small-data size limit (see option -G)");
9662 htab
->small_data_overflow_reported
= TRUE
;
9663 (*info
->callbacks
->einfo
) ("%P: %s\n", msg
);
9665 if (! ((*info
->callbacks
->reloc_overflow
)
9666 (info
, NULL
, name
, howto
->name
, (bfd_vma
) 0,
9667 input_bfd
, input_section
, rel
->r_offset
)))
9675 case bfd_reloc_outofrange
:
9676 if (jal_reloc_p (howto
->type
))
9678 msg
= _("JALX to a non-word-aligned address");
9679 info
->callbacks
->warning
9680 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
9690 /* If we've got another relocation for the address, keep going
9691 until we reach the last one. */
9692 if (use_saved_addend_p
)
9698 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
9699 /* See the comment above about using R_MIPS_64 in the 32-bit
9700 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
9701 that calculated the right value. Now, however, we
9702 sign-extend the 32-bit result to 64-bits, and store it as a
9703 64-bit value. We are especially generous here in that we
9704 go to extreme lengths to support this usage on systems with
9705 only a 32-bit VMA. */
9711 if (value
& ((bfd_vma
) 1 << 31))
9713 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
9720 /* If we don't know that we have a 64-bit type,
9721 do two separate stores. */
9722 if (bfd_big_endian (input_bfd
))
9724 /* Undo what we did above. */
9726 /* Store the sign-bits (which are most significant)
9728 low_bits
= sign_bits
;
9734 high_bits
= sign_bits
;
9736 bfd_put_32 (input_bfd
, low_bits
,
9737 contents
+ rel
->r_offset
);
9738 bfd_put_32 (input_bfd
, high_bits
,
9739 contents
+ rel
->r_offset
+ 4);
9743 /* Actually perform the relocation. */
9744 if (! mips_elf_perform_relocation (info
, howto
, rel
, value
,
9745 input_bfd
, input_section
,
9746 contents
, cross_mode_jump_p
))
9753 /* A function that iterates over each entry in la25_stubs and fills
9754 in the code for each one. DATA points to a mips_htab_traverse_info. */
9757 mips_elf_create_la25_stub (void **slot
, void *data
)
9759 struct mips_htab_traverse_info
*hti
;
9760 struct mips_elf_link_hash_table
*htab
;
9761 struct mips_elf_la25_stub
*stub
;
9764 bfd_vma offset
, target
, target_high
, target_low
;
9766 stub
= (struct mips_elf_la25_stub
*) *slot
;
9767 hti
= (struct mips_htab_traverse_info
*) data
;
9768 htab
= mips_elf_hash_table (hti
->info
);
9769 BFD_ASSERT (htab
!= NULL
);
9771 /* Create the section contents, if we haven't already. */
9772 s
= stub
->stub_section
;
9776 loc
= bfd_malloc (s
->size
);
9785 /* Work out where in the section this stub should go. */
9786 offset
= stub
->offset
;
9788 /* Work out the target address. */
9789 target
= mips_elf_get_la25_target (stub
, &s
);
9790 target
+= s
->output_section
->vma
+ s
->output_offset
;
9792 target_high
= ((target
+ 0x8000) >> 16) & 0xffff;
9793 target_low
= (target
& 0xffff);
9795 if (stub
->stub_section
!= htab
->strampoline
)
9797 /* This is a simple LUI/ADDIU stub. Zero out the beginning
9798 of the section and write the two instructions at the end. */
9799 memset (loc
, 0, offset
);
9801 if (ELF_ST_IS_MICROMIPS (stub
->h
->root
.other
))
9803 bfd_put_micromips_32 (hti
->output_bfd
,
9804 LA25_LUI_MICROMIPS (target_high
),
9806 bfd_put_micromips_32 (hti
->output_bfd
,
9807 LA25_ADDIU_MICROMIPS (target_low
),
9812 bfd_put_32 (hti
->output_bfd
, LA25_LUI (target_high
), loc
);
9813 bfd_put_32 (hti
->output_bfd
, LA25_ADDIU (target_low
), loc
+ 4);
9818 /* This is trampoline. */
9820 if (ELF_ST_IS_MICROMIPS (stub
->h
->root
.other
))
9822 bfd_put_micromips_32 (hti
->output_bfd
,
9823 LA25_LUI_MICROMIPS (target_high
), loc
);
9824 bfd_put_micromips_32 (hti
->output_bfd
,
9825 LA25_J_MICROMIPS (target
), loc
+ 4);
9826 bfd_put_micromips_32 (hti
->output_bfd
,
9827 LA25_ADDIU_MICROMIPS (target_low
), loc
+ 8);
9828 bfd_put_32 (hti
->output_bfd
, 0, loc
+ 12);
9832 bfd_put_32 (hti
->output_bfd
, LA25_LUI (target_high
), loc
);
9833 bfd_put_32 (hti
->output_bfd
, LA25_J (target
), loc
+ 4);
9834 bfd_put_32 (hti
->output_bfd
, LA25_ADDIU (target_low
), loc
+ 8);
9835 bfd_put_32 (hti
->output_bfd
, 0, loc
+ 12);
9841 /* If NAME is one of the special IRIX6 symbols defined by the linker,
9842 adjust it appropriately now. */
9845 mips_elf_irix6_finish_dynamic_symbol (bfd
*abfd ATTRIBUTE_UNUSED
,
9846 const char *name
, Elf_Internal_Sym
*sym
)
9848 /* The linker script takes care of providing names and values for
9849 these, but we must place them into the right sections. */
9850 static const char* const text_section_symbols
[] = {
9853 "__dso_displacement",
9855 "__program_header_table",
9859 static const char* const data_section_symbols
[] = {
9867 const char* const *p
;
9870 for (i
= 0; i
< 2; ++i
)
9871 for (p
= (i
== 0) ? text_section_symbols
: data_section_symbols
;
9874 if (strcmp (*p
, name
) == 0)
9876 /* All of these symbols are given type STT_SECTION by the
9878 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
9879 sym
->st_other
= STO_PROTECTED
;
9881 /* The IRIX linker puts these symbols in special sections. */
9883 sym
->st_shndx
= SHN_MIPS_TEXT
;
9885 sym
->st_shndx
= SHN_MIPS_DATA
;
9891 /* Finish up dynamic symbol handling. We set the contents of various
9892 dynamic sections here. */
9895 _bfd_mips_elf_finish_dynamic_symbol (bfd
*output_bfd
,
9896 struct bfd_link_info
*info
,
9897 struct elf_link_hash_entry
*h
,
9898 Elf_Internal_Sym
*sym
)
9902 struct mips_got_info
*g
, *gg
;
9905 struct mips_elf_link_hash_table
*htab
;
9906 struct mips_elf_link_hash_entry
*hmips
;
9908 htab
= mips_elf_hash_table (info
);
9909 BFD_ASSERT (htab
!= NULL
);
9910 dynobj
= elf_hash_table (info
)->dynobj
;
9911 hmips
= (struct mips_elf_link_hash_entry
*) h
;
9913 BFD_ASSERT (!htab
->is_vxworks
);
9915 if (h
->plt
.offset
!= MINUS_ONE
&& hmips
->no_fn_stub
)
9917 /* We've decided to create a PLT entry for this symbol. */
9919 bfd_vma header_address
, plt_index
, got_address
;
9920 bfd_vma got_address_high
, got_address_low
, load
;
9921 const bfd_vma
*plt_entry
;
9923 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
9924 BFD_ASSERT (h
->dynindx
!= -1);
9925 BFD_ASSERT (htab
->splt
!= NULL
);
9926 BFD_ASSERT (h
->plt
.offset
<= htab
->splt
->size
);
9927 BFD_ASSERT (!h
->def_regular
);
9929 /* Calculate the address of the PLT header. */
9930 header_address
= (htab
->splt
->output_section
->vma
9931 + htab
->splt
->output_offset
);
9933 /* Calculate the index of the entry. */
9934 plt_index
= ((h
->plt
.offset
- htab
->plt_header_size
)
9935 / htab
->plt_entry_size
);
9937 /* Calculate the address of the .got.plt entry. */
9938 got_address
= (htab
->sgotplt
->output_section
->vma
9939 + htab
->sgotplt
->output_offset
9940 + (2 + plt_index
) * MIPS_ELF_GOT_SIZE (dynobj
));
9941 got_address_high
= ((got_address
+ 0x8000) >> 16) & 0xffff;
9942 got_address_low
= got_address
& 0xffff;
9944 /* Initially point the .got.plt entry at the PLT header. */
9945 loc
= (htab
->sgotplt
->contents
9946 + (2 + plt_index
) * MIPS_ELF_GOT_SIZE (dynobj
));
9947 if (ABI_64_P (output_bfd
))
9948 bfd_put_64 (output_bfd
, header_address
, loc
);
9950 bfd_put_32 (output_bfd
, header_address
, loc
);
9952 /* Find out where the .plt entry should go. */
9953 loc
= htab
->splt
->contents
+ h
->plt
.offset
;
9955 /* Pick the load opcode. */
9956 load
= MIPS_ELF_LOAD_WORD (output_bfd
);
9958 /* Fill in the PLT entry itself. */
9959 plt_entry
= mips_exec_plt_entry
;
9960 bfd_put_32 (output_bfd
, plt_entry
[0] | got_address_high
, loc
);
9961 bfd_put_32 (output_bfd
, plt_entry
[1] | got_address_low
| load
, loc
+ 4);
9963 if (! LOAD_INTERLOCKS_P (output_bfd
))
9965 bfd_put_32 (output_bfd
, plt_entry
[2] | got_address_low
, loc
+ 8);
9966 bfd_put_32 (output_bfd
, plt_entry
[3], loc
+ 12);
9970 bfd_put_32 (output_bfd
, plt_entry
[3], loc
+ 8);
9971 bfd_put_32 (output_bfd
, plt_entry
[2] | got_address_low
, loc
+ 12);
9974 /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry. */
9975 mips_elf_output_dynamic_relocation (output_bfd
, htab
->srelplt
,
9976 plt_index
, h
->dynindx
,
9977 R_MIPS_JUMP_SLOT
, got_address
);
9979 /* We distinguish between PLT entries and lazy-binding stubs by
9980 giving the former an st_other value of STO_MIPS_PLT. Set the
9981 flag and leave the value if there are any relocations in the
9982 binary where pointer equality matters. */
9983 sym
->st_shndx
= SHN_UNDEF
;
9984 if (h
->pointer_equality_needed
)
9985 sym
->st_other
= STO_MIPS_PLT
;
9989 else if (h
->plt
.offset
!= MINUS_ONE
)
9991 /* We've decided to create a lazy-binding stub. */
9992 bfd_byte stub
[MIPS_FUNCTION_STUB_BIG_SIZE
];
9994 /* This symbol has a stub. Set it up. */
9996 BFD_ASSERT (h
->dynindx
!= -1);
9998 BFD_ASSERT ((htab
->function_stub_size
== MIPS_FUNCTION_STUB_BIG_SIZE
)
9999 || (h
->dynindx
<= 0xffff));
10001 /* Values up to 2^31 - 1 are allowed. Larger values would cause
10002 sign extension at runtime in the stub, resulting in a negative
10004 if (h
->dynindx
& ~0x7fffffff)
10007 /* Fill the stub. */
10009 bfd_put_32 (output_bfd
, STUB_LW (output_bfd
), stub
+ idx
);
10011 bfd_put_32 (output_bfd
, STUB_MOVE (output_bfd
), stub
+ idx
);
10013 if (htab
->function_stub_size
== MIPS_FUNCTION_STUB_BIG_SIZE
)
10015 bfd_put_32 (output_bfd
, STUB_LUI ((h
->dynindx
>> 16) & 0x7fff),
10019 bfd_put_32 (output_bfd
, STUB_JALR
, stub
+ idx
);
10022 /* If a large stub is not required and sign extension is not a
10023 problem, then use legacy code in the stub. */
10024 if (htab
->function_stub_size
== MIPS_FUNCTION_STUB_BIG_SIZE
)
10025 bfd_put_32 (output_bfd
, STUB_ORI (h
->dynindx
& 0xffff), stub
+ idx
);
10026 else if (h
->dynindx
& ~0x7fff)
10027 bfd_put_32 (output_bfd
, STUB_LI16U (h
->dynindx
& 0xffff), stub
+ idx
);
10029 bfd_put_32 (output_bfd
, STUB_LI16S (output_bfd
, h
->dynindx
),
10032 BFD_ASSERT (h
->plt
.offset
<= htab
->sstubs
->size
);
10033 memcpy (htab
->sstubs
->contents
+ h
->plt
.offset
,
10034 stub
, htab
->function_stub_size
);
10036 /* Mark the symbol as undefined. plt.offset != -1 occurs
10037 only for the referenced symbol. */
10038 sym
->st_shndx
= SHN_UNDEF
;
10040 /* The run-time linker uses the st_value field of the symbol
10041 to reset the global offset table entry for this external
10042 to its stub address when unlinking a shared object. */
10043 sym
->st_value
= (htab
->sstubs
->output_section
->vma
10044 + htab
->sstubs
->output_offset
10048 /* If we have a MIPS16 function with a stub, the dynamic symbol must
10049 refer to the stub, since only the stub uses the standard calling
10051 if (h
->dynindx
!= -1 && hmips
->fn_stub
!= NULL
)
10053 BFD_ASSERT (hmips
->need_fn_stub
);
10054 sym
->st_value
= (hmips
->fn_stub
->output_section
->vma
10055 + hmips
->fn_stub
->output_offset
);
10056 sym
->st_size
= hmips
->fn_stub
->size
;
10057 sym
->st_other
= ELF_ST_VISIBILITY (sym
->st_other
);
10060 BFD_ASSERT (h
->dynindx
!= -1
10061 || h
->forced_local
);
10064 g
= htab
->got_info
;
10065 BFD_ASSERT (g
!= NULL
);
10067 /* Run through the global symbol table, creating GOT entries for all
10068 the symbols that need them. */
10069 if (hmips
->global_got_area
!= GGA_NONE
)
10074 value
= sym
->st_value
;
10075 offset
= mips_elf_global_got_index (dynobj
, output_bfd
, h
,
10076 R_MIPS_GOT16
, info
);
10077 MIPS_ELF_PUT_WORD (output_bfd
, value
, sgot
->contents
+ offset
);
10080 if (hmips
->global_got_area
!= GGA_NONE
&& g
->next
)
10082 struct mips_got_entry e
, *p
;
10088 e
.abfd
= output_bfd
;
10093 for (g
= g
->next
; g
->next
!= gg
; g
= g
->next
)
10096 && (p
= (struct mips_got_entry
*) htab_find (g
->got_entries
,
10099 offset
= p
->gotidx
;
10101 || (elf_hash_table (info
)->dynamic_sections_created
10103 && p
->d
.h
->root
.def_dynamic
10104 && !p
->d
.h
->root
.def_regular
))
10106 /* Create an R_MIPS_REL32 relocation for this entry. Due to
10107 the various compatibility problems, it's easier to mock
10108 up an R_MIPS_32 or R_MIPS_64 relocation and leave
10109 mips_elf_create_dynamic_relocation to calculate the
10110 appropriate addend. */
10111 Elf_Internal_Rela rel
[3];
10113 memset (rel
, 0, sizeof (rel
));
10114 if (ABI_64_P (output_bfd
))
10115 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_64
);
10117 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_32
);
10118 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
10121 if (! (mips_elf_create_dynamic_relocation
10122 (output_bfd
, info
, rel
,
10123 e
.d
.h
, NULL
, sym
->st_value
, &entry
, sgot
)))
10127 entry
= sym
->st_value
;
10128 MIPS_ELF_PUT_WORD (output_bfd
, entry
, sgot
->contents
+ offset
);
10133 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
10134 name
= h
->root
.root
.string
;
10135 if (h
== elf_hash_table (info
)->hdynamic
10136 || h
== elf_hash_table (info
)->hgot
)
10137 sym
->st_shndx
= SHN_ABS
;
10138 else if (strcmp (name
, "_DYNAMIC_LINK") == 0
10139 || strcmp (name
, "_DYNAMIC_LINKING") == 0)
10141 sym
->st_shndx
= SHN_ABS
;
10142 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
10145 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (output_bfd
))
10147 sym
->st_shndx
= SHN_ABS
;
10148 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
10149 sym
->st_value
= elf_gp (output_bfd
);
10151 else if (SGI_COMPAT (output_bfd
))
10153 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
10154 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
10156 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
10157 sym
->st_other
= STO_PROTECTED
;
10159 sym
->st_shndx
= SHN_MIPS_DATA
;
10161 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
10163 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
10164 sym
->st_other
= STO_PROTECTED
;
10165 sym
->st_value
= mips_elf_hash_table (info
)->procedure_count
;
10166 sym
->st_shndx
= SHN_ABS
;
10168 else if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
!= SHN_ABS
)
10170 if (h
->type
== STT_FUNC
)
10171 sym
->st_shndx
= SHN_MIPS_TEXT
;
10172 else if (h
->type
== STT_OBJECT
)
10173 sym
->st_shndx
= SHN_MIPS_DATA
;
10177 /* Emit a copy reloc, if needed. */
10183 BFD_ASSERT (h
->dynindx
!= -1);
10184 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
10186 s
= mips_elf_rel_dyn_section (info
, FALSE
);
10187 symval
= (h
->root
.u
.def
.section
->output_section
->vma
10188 + h
->root
.u
.def
.section
->output_offset
10189 + h
->root
.u
.def
.value
);
10190 mips_elf_output_dynamic_relocation (output_bfd
, s
, s
->reloc_count
++,
10191 h
->dynindx
, R_MIPS_COPY
, symval
);
10194 /* Handle the IRIX6-specific symbols. */
10195 if (IRIX_COMPAT (output_bfd
) == ict_irix6
)
10196 mips_elf_irix6_finish_dynamic_symbol (output_bfd
, name
, sym
);
10198 /* Keep dynamic MIPS16 symbols odd. This allows the dynamic linker to
10199 treat MIPS16 symbols like any other. */
10200 if (ELF_ST_IS_MIPS16 (sym
->st_other
))
10202 BFD_ASSERT (sym
->st_value
& 1);
10203 sym
->st_other
-= STO_MIPS16
;
10209 /* Likewise, for VxWorks. */
10212 _bfd_mips_vxworks_finish_dynamic_symbol (bfd
*output_bfd
,
10213 struct bfd_link_info
*info
,
10214 struct elf_link_hash_entry
*h
,
10215 Elf_Internal_Sym
*sym
)
10219 struct mips_got_info
*g
;
10220 struct mips_elf_link_hash_table
*htab
;
10221 struct mips_elf_link_hash_entry
*hmips
;
10223 htab
= mips_elf_hash_table (info
);
10224 BFD_ASSERT (htab
!= NULL
);
10225 dynobj
= elf_hash_table (info
)->dynobj
;
10226 hmips
= (struct mips_elf_link_hash_entry
*) h
;
10228 if (h
->plt
.offset
!= (bfd_vma
) -1)
10231 bfd_vma plt_address
, plt_index
, got_address
, got_offset
, branch_offset
;
10232 Elf_Internal_Rela rel
;
10233 static const bfd_vma
*plt_entry
;
10235 BFD_ASSERT (h
->dynindx
!= -1);
10236 BFD_ASSERT (htab
->splt
!= NULL
);
10237 BFD_ASSERT (h
->plt
.offset
<= htab
->splt
->size
);
10239 /* Calculate the address of the .plt entry. */
10240 plt_address
= (htab
->splt
->output_section
->vma
10241 + htab
->splt
->output_offset
10244 /* Calculate the index of the entry. */
10245 plt_index
= ((h
->plt
.offset
- htab
->plt_header_size
)
10246 / htab
->plt_entry_size
);
10248 /* Calculate the address of the .got.plt entry. */
10249 got_address
= (htab
->sgotplt
->output_section
->vma
10250 + htab
->sgotplt
->output_offset
10253 /* Calculate the offset of the .got.plt entry from
10254 _GLOBAL_OFFSET_TABLE_. */
10255 got_offset
= mips_elf_gotplt_index (info
, h
);
10257 /* Calculate the offset for the branch at the start of the PLT
10258 entry. The branch jumps to the beginning of .plt. */
10259 branch_offset
= -(h
->plt
.offset
/ 4 + 1) & 0xffff;
10261 /* Fill in the initial value of the .got.plt entry. */
10262 bfd_put_32 (output_bfd
, plt_address
,
10263 htab
->sgotplt
->contents
+ plt_index
* 4);
10265 /* Find out where the .plt entry should go. */
10266 loc
= htab
->splt
->contents
+ h
->plt
.offset
;
10270 plt_entry
= mips_vxworks_shared_plt_entry
;
10271 bfd_put_32 (output_bfd
, plt_entry
[0] | branch_offset
, loc
);
10272 bfd_put_32 (output_bfd
, plt_entry
[1] | plt_index
, loc
+ 4);
10276 bfd_vma got_address_high
, got_address_low
;
10278 plt_entry
= mips_vxworks_exec_plt_entry
;
10279 got_address_high
= ((got_address
+ 0x8000) >> 16) & 0xffff;
10280 got_address_low
= got_address
& 0xffff;
10282 bfd_put_32 (output_bfd
, plt_entry
[0] | branch_offset
, loc
);
10283 bfd_put_32 (output_bfd
, plt_entry
[1] | plt_index
, loc
+ 4);
10284 bfd_put_32 (output_bfd
, plt_entry
[2] | got_address_high
, loc
+ 8);
10285 bfd_put_32 (output_bfd
, plt_entry
[3] | got_address_low
, loc
+ 12);
10286 bfd_put_32 (output_bfd
, plt_entry
[4], loc
+ 16);
10287 bfd_put_32 (output_bfd
, plt_entry
[5], loc
+ 20);
10288 bfd_put_32 (output_bfd
, plt_entry
[6], loc
+ 24);
10289 bfd_put_32 (output_bfd
, plt_entry
[7], loc
+ 28);
10291 loc
= (htab
->srelplt2
->contents
10292 + (plt_index
* 3 + 2) * sizeof (Elf32_External_Rela
));
10294 /* Emit a relocation for the .got.plt entry. */
10295 rel
.r_offset
= got_address
;
10296 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
, R_MIPS_32
);
10297 rel
.r_addend
= h
->plt
.offset
;
10298 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
10300 /* Emit a relocation for the lui of %hi(<.got.plt slot>). */
10301 loc
+= sizeof (Elf32_External_Rela
);
10302 rel
.r_offset
= plt_address
+ 8;
10303 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_HI16
);
10304 rel
.r_addend
= got_offset
;
10305 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
10307 /* Emit a relocation for the addiu of %lo(<.got.plt slot>). */
10308 loc
+= sizeof (Elf32_External_Rela
);
10310 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_LO16
);
10311 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
10314 /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry. */
10315 loc
= htab
->srelplt
->contents
+ plt_index
* sizeof (Elf32_External_Rela
);
10316 rel
.r_offset
= got_address
;
10317 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_JUMP_SLOT
);
10319 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
10321 if (!h
->def_regular
)
10322 sym
->st_shndx
= SHN_UNDEF
;
10325 BFD_ASSERT (h
->dynindx
!= -1 || h
->forced_local
);
10328 g
= htab
->got_info
;
10329 BFD_ASSERT (g
!= NULL
);
10331 /* See if this symbol has an entry in the GOT. */
10332 if (hmips
->global_got_area
!= GGA_NONE
)
10335 Elf_Internal_Rela outrel
;
10339 /* Install the symbol value in the GOT. */
10340 offset
= mips_elf_global_got_index (dynobj
, output_bfd
, h
,
10341 R_MIPS_GOT16
, info
);
10342 MIPS_ELF_PUT_WORD (output_bfd
, sym
->st_value
, sgot
->contents
+ offset
);
10344 /* Add a dynamic relocation for it. */
10345 s
= mips_elf_rel_dyn_section (info
, FALSE
);
10346 loc
= s
->contents
+ (s
->reloc_count
++ * sizeof (Elf32_External_Rela
));
10347 outrel
.r_offset
= (sgot
->output_section
->vma
10348 + sgot
->output_offset
10350 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_32
);
10351 outrel
.r_addend
= 0;
10352 bfd_elf32_swap_reloca_out (dynobj
, &outrel
, loc
);
10355 /* Emit a copy reloc, if needed. */
10358 Elf_Internal_Rela rel
;
10360 BFD_ASSERT (h
->dynindx
!= -1);
10362 rel
.r_offset
= (h
->root
.u
.def
.section
->output_section
->vma
10363 + h
->root
.u
.def
.section
->output_offset
10364 + h
->root
.u
.def
.value
);
10365 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_COPY
);
10367 bfd_elf32_swap_reloca_out (output_bfd
, &rel
,
10368 htab
->srelbss
->contents
10369 + (htab
->srelbss
->reloc_count
10370 * sizeof (Elf32_External_Rela
)));
10371 ++htab
->srelbss
->reloc_count
;
10374 /* If this is a mips16/microMIPS symbol, force the value to be even. */
10375 if (ELF_ST_IS_COMPRESSED (sym
->st_other
))
10376 sym
->st_value
&= ~1;
10381 /* Write out a plt0 entry to the beginning of .plt. */
10384 mips_finish_exec_plt (bfd
*output_bfd
, struct bfd_link_info
*info
)
10387 bfd_vma gotplt_value
, gotplt_value_high
, gotplt_value_low
;
10388 static const bfd_vma
*plt_entry
;
10389 struct mips_elf_link_hash_table
*htab
;
10391 htab
= mips_elf_hash_table (info
);
10392 BFD_ASSERT (htab
!= NULL
);
10394 if (ABI_64_P (output_bfd
))
10395 plt_entry
= mips_n64_exec_plt0_entry
;
10396 else if (ABI_N32_P (output_bfd
))
10397 plt_entry
= mips_n32_exec_plt0_entry
;
10399 plt_entry
= mips_o32_exec_plt0_entry
;
10401 /* Calculate the value of .got.plt. */
10402 gotplt_value
= (htab
->sgotplt
->output_section
->vma
10403 + htab
->sgotplt
->output_offset
);
10404 gotplt_value_high
= ((gotplt_value
+ 0x8000) >> 16) & 0xffff;
10405 gotplt_value_low
= gotplt_value
& 0xffff;
10407 /* The PLT sequence is not safe for N64 if .got.plt's address can
10408 not be loaded in two instructions. */
10409 BFD_ASSERT ((gotplt_value
& ~(bfd_vma
) 0x7fffffff) == 0
10410 || ~(gotplt_value
| 0x7fffffff) == 0);
10412 /* Install the PLT header. */
10413 loc
= htab
->splt
->contents
;
10414 bfd_put_32 (output_bfd
, plt_entry
[0] | gotplt_value_high
, loc
);
10415 bfd_put_32 (output_bfd
, plt_entry
[1] | gotplt_value_low
, loc
+ 4);
10416 bfd_put_32 (output_bfd
, plt_entry
[2] | gotplt_value_low
, loc
+ 8);
10417 bfd_put_32 (output_bfd
, plt_entry
[3], loc
+ 12);
10418 bfd_put_32 (output_bfd
, plt_entry
[4], loc
+ 16);
10419 bfd_put_32 (output_bfd
, plt_entry
[5], loc
+ 20);
10420 bfd_put_32 (output_bfd
, plt_entry
[6], loc
+ 24);
10421 bfd_put_32 (output_bfd
, plt_entry
[7], loc
+ 28);
10424 /* Install the PLT header for a VxWorks executable and finalize the
10425 contents of .rela.plt.unloaded. */
10428 mips_vxworks_finish_exec_plt (bfd
*output_bfd
, struct bfd_link_info
*info
)
10430 Elf_Internal_Rela rela
;
10432 bfd_vma got_value
, got_value_high
, got_value_low
, plt_address
;
10433 static const bfd_vma
*plt_entry
;
10434 struct mips_elf_link_hash_table
*htab
;
10436 htab
= mips_elf_hash_table (info
);
10437 BFD_ASSERT (htab
!= NULL
);
10439 plt_entry
= mips_vxworks_exec_plt0_entry
;
10441 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */
10442 got_value
= (htab
->root
.hgot
->root
.u
.def
.section
->output_section
->vma
10443 + htab
->root
.hgot
->root
.u
.def
.section
->output_offset
10444 + htab
->root
.hgot
->root
.u
.def
.value
);
10446 got_value_high
= ((got_value
+ 0x8000) >> 16) & 0xffff;
10447 got_value_low
= got_value
& 0xffff;
10449 /* Calculate the address of the PLT header. */
10450 plt_address
= htab
->splt
->output_section
->vma
+ htab
->splt
->output_offset
;
10452 /* Install the PLT header. */
10453 loc
= htab
->splt
->contents
;
10454 bfd_put_32 (output_bfd
, plt_entry
[0] | got_value_high
, loc
);
10455 bfd_put_32 (output_bfd
, plt_entry
[1] | got_value_low
, loc
+ 4);
10456 bfd_put_32 (output_bfd
, plt_entry
[2], loc
+ 8);
10457 bfd_put_32 (output_bfd
, plt_entry
[3], loc
+ 12);
10458 bfd_put_32 (output_bfd
, plt_entry
[4], loc
+ 16);
10459 bfd_put_32 (output_bfd
, plt_entry
[5], loc
+ 20);
10461 /* Output the relocation for the lui of %hi(_GLOBAL_OFFSET_TABLE_). */
10462 loc
= htab
->srelplt2
->contents
;
10463 rela
.r_offset
= plt_address
;
10464 rela
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_HI16
);
10466 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
10467 loc
+= sizeof (Elf32_External_Rela
);
10469 /* Output the relocation for the following addiu of
10470 %lo(_GLOBAL_OFFSET_TABLE_). */
10471 rela
.r_offset
+= 4;
10472 rela
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_LO16
);
10473 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
10474 loc
+= sizeof (Elf32_External_Rela
);
10476 /* Fix up the remaining relocations. They may have the wrong
10477 symbol index for _G_O_T_ or _P_L_T_ depending on the order
10478 in which symbols were output. */
10479 while (loc
< htab
->srelplt2
->contents
+ htab
->srelplt2
->size
)
10481 Elf_Internal_Rela rel
;
10483 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &rel
);
10484 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
, R_MIPS_32
);
10485 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
10486 loc
+= sizeof (Elf32_External_Rela
);
10488 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &rel
);
10489 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_HI16
);
10490 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
10491 loc
+= sizeof (Elf32_External_Rela
);
10493 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &rel
);
10494 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_LO16
);
10495 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
10496 loc
+= sizeof (Elf32_External_Rela
);
10500 /* Install the PLT header for a VxWorks shared library. */
10503 mips_vxworks_finish_shared_plt (bfd
*output_bfd
, struct bfd_link_info
*info
)
10506 struct mips_elf_link_hash_table
*htab
;
10508 htab
= mips_elf_hash_table (info
);
10509 BFD_ASSERT (htab
!= NULL
);
10511 /* We just need to copy the entry byte-by-byte. */
10512 for (i
= 0; i
< ARRAY_SIZE (mips_vxworks_shared_plt0_entry
); i
++)
10513 bfd_put_32 (output_bfd
, mips_vxworks_shared_plt0_entry
[i
],
10514 htab
->splt
->contents
+ i
* 4);
10517 /* Finish up the dynamic sections. */
10520 _bfd_mips_elf_finish_dynamic_sections (bfd
*output_bfd
,
10521 struct bfd_link_info
*info
)
10526 struct mips_got_info
*gg
, *g
;
10527 struct mips_elf_link_hash_table
*htab
;
10529 htab
= mips_elf_hash_table (info
);
10530 BFD_ASSERT (htab
!= NULL
);
10532 dynobj
= elf_hash_table (info
)->dynobj
;
10534 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
10537 gg
= htab
->got_info
;
10539 if (elf_hash_table (info
)->dynamic_sections_created
)
10542 int dyn_to_skip
= 0, dyn_skipped
= 0;
10544 BFD_ASSERT (sdyn
!= NULL
);
10545 BFD_ASSERT (gg
!= NULL
);
10547 g
= mips_elf_got_for_ibfd (gg
, output_bfd
);
10548 BFD_ASSERT (g
!= NULL
);
10550 for (b
= sdyn
->contents
;
10551 b
< sdyn
->contents
+ sdyn
->size
;
10552 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
10554 Elf_Internal_Dyn dyn
;
10558 bfd_boolean swap_out_p
;
10560 /* Read in the current dynamic entry. */
10561 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
10563 /* Assume that we're going to modify it and write it out. */
10569 dyn
.d_un
.d_val
= MIPS_ELF_REL_SIZE (dynobj
);
10573 BFD_ASSERT (htab
->is_vxworks
);
10574 dyn
.d_un
.d_val
= MIPS_ELF_RELA_SIZE (dynobj
);
10578 /* Rewrite DT_STRSZ. */
10580 _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
10585 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
10588 case DT_MIPS_PLTGOT
:
10590 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
10593 case DT_MIPS_RLD_VERSION
:
10594 dyn
.d_un
.d_val
= 1; /* XXX */
10597 case DT_MIPS_FLAGS
:
10598 dyn
.d_un
.d_val
= RHF_NOTPOT
; /* XXX */
10601 case DT_MIPS_TIME_STAMP
:
10605 dyn
.d_un
.d_val
= t
;
10609 case DT_MIPS_ICHECKSUM
:
10611 swap_out_p
= FALSE
;
10614 case DT_MIPS_IVERSION
:
10616 swap_out_p
= FALSE
;
10619 case DT_MIPS_BASE_ADDRESS
:
10620 s
= output_bfd
->sections
;
10621 BFD_ASSERT (s
!= NULL
);
10622 dyn
.d_un
.d_ptr
= s
->vma
& ~(bfd_vma
) 0xffff;
10625 case DT_MIPS_LOCAL_GOTNO
:
10626 dyn
.d_un
.d_val
= g
->local_gotno
;
10629 case DT_MIPS_UNREFEXTNO
:
10630 /* The index into the dynamic symbol table which is the
10631 entry of the first external symbol that is not
10632 referenced within the same object. */
10633 dyn
.d_un
.d_val
= bfd_count_sections (output_bfd
) + 1;
10636 case DT_MIPS_GOTSYM
:
10637 if (htab
->global_gotsym
)
10639 dyn
.d_un
.d_val
= htab
->global_gotsym
->dynindx
;
10642 /* In case if we don't have global got symbols we default
10643 to setting DT_MIPS_GOTSYM to the same value as
10644 DT_MIPS_SYMTABNO, so we just fall through. */
10646 case DT_MIPS_SYMTABNO
:
10648 elemsize
= MIPS_ELF_SYM_SIZE (output_bfd
);
10649 s
= bfd_get_section_by_name (output_bfd
, name
);
10650 BFD_ASSERT (s
!= NULL
);
10652 dyn
.d_un
.d_val
= s
->size
/ elemsize
;
10655 case DT_MIPS_HIPAGENO
:
10656 dyn
.d_un
.d_val
= g
->local_gotno
- htab
->reserved_gotno
;
10659 case DT_MIPS_RLD_MAP
:
10661 struct elf_link_hash_entry
*h
;
10662 h
= mips_elf_hash_table (info
)->rld_symbol
;
10665 dyn_to_skip
= MIPS_ELF_DYN_SIZE (dynobj
);
10666 swap_out_p
= FALSE
;
10669 s
= h
->root
.u
.def
.section
;
10670 dyn
.d_un
.d_ptr
= (s
->output_section
->vma
+ s
->output_offset
10671 + h
->root
.u
.def
.value
);
10675 case DT_MIPS_OPTIONS
:
10676 s
= (bfd_get_section_by_name
10677 (output_bfd
, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd
)));
10678 dyn
.d_un
.d_ptr
= s
->vma
;
10682 BFD_ASSERT (htab
->is_vxworks
);
10683 /* The count does not include the JUMP_SLOT relocations. */
10685 dyn
.d_un
.d_val
-= htab
->srelplt
->size
;
10689 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
10690 if (htab
->is_vxworks
)
10691 dyn
.d_un
.d_val
= DT_RELA
;
10693 dyn
.d_un
.d_val
= DT_REL
;
10697 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
10698 dyn
.d_un
.d_val
= htab
->srelplt
->size
;
10702 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
10703 dyn
.d_un
.d_ptr
= (htab
->srelplt
->output_section
->vma
10704 + htab
->srelplt
->output_offset
);
10708 /* If we didn't need any text relocations after all, delete
10709 the dynamic tag. */
10710 if (!(info
->flags
& DF_TEXTREL
))
10712 dyn_to_skip
= MIPS_ELF_DYN_SIZE (dynobj
);
10713 swap_out_p
= FALSE
;
10718 /* If we didn't need any text relocations after all, clear
10719 DF_TEXTREL from DT_FLAGS. */
10720 if (!(info
->flags
& DF_TEXTREL
))
10721 dyn
.d_un
.d_val
&= ~DF_TEXTREL
;
10723 swap_out_p
= FALSE
;
10727 swap_out_p
= FALSE
;
10728 if (htab
->is_vxworks
10729 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
10734 if (swap_out_p
|| dyn_skipped
)
10735 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
10736 (dynobj
, &dyn
, b
- dyn_skipped
);
10740 dyn_skipped
+= dyn_to_skip
;
10745 /* Wipe out any trailing entries if we shifted down a dynamic tag. */
10746 if (dyn_skipped
> 0)
10747 memset (b
- dyn_skipped
, 0, dyn_skipped
);
10750 if (sgot
!= NULL
&& sgot
->size
> 0
10751 && !bfd_is_abs_section (sgot
->output_section
))
10753 if (htab
->is_vxworks
)
10755 /* The first entry of the global offset table points to the
10756 ".dynamic" section. The second is initialized by the
10757 loader and contains the shared library identifier.
10758 The third is also initialized by the loader and points
10759 to the lazy resolution stub. */
10760 MIPS_ELF_PUT_WORD (output_bfd
,
10761 sdyn
->output_offset
+ sdyn
->output_section
->vma
,
10763 MIPS_ELF_PUT_WORD (output_bfd
, 0,
10764 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
10765 MIPS_ELF_PUT_WORD (output_bfd
, 0,
10767 + 2 * MIPS_ELF_GOT_SIZE (output_bfd
));
10771 /* The first entry of the global offset table will be filled at
10772 runtime. The second entry will be used by some runtime loaders.
10773 This isn't the case of IRIX rld. */
10774 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
10775 MIPS_ELF_PUT_WORD (output_bfd
, MIPS_ELF_GNU_GOT1_MASK (output_bfd
),
10776 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
10779 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
10780 = MIPS_ELF_GOT_SIZE (output_bfd
);
10783 /* Generate dynamic relocations for the non-primary gots. */
10784 if (gg
!= NULL
&& gg
->next
)
10786 Elf_Internal_Rela rel
[3];
10787 bfd_vma addend
= 0;
10789 memset (rel
, 0, sizeof (rel
));
10790 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_REL32
);
10792 for (g
= gg
->next
; g
->next
!= gg
; g
= g
->next
)
10794 bfd_vma got_index
= g
->next
->local_gotno
+ g
->next
->global_gotno
10795 + g
->next
->tls_gotno
;
10797 MIPS_ELF_PUT_WORD (output_bfd
, 0, sgot
->contents
10798 + got_index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
10799 MIPS_ELF_PUT_WORD (output_bfd
, MIPS_ELF_GNU_GOT1_MASK (output_bfd
),
10801 + got_index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
10803 if (! info
->shared
)
10806 while (got_index
< g
->assigned_gotno
)
10808 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
10809 = got_index
++ * MIPS_ELF_GOT_SIZE (output_bfd
);
10810 if (!(mips_elf_create_dynamic_relocation
10811 (output_bfd
, info
, rel
, NULL
,
10812 bfd_abs_section_ptr
,
10813 0, &addend
, sgot
)))
10815 BFD_ASSERT (addend
== 0);
10820 /* The generation of dynamic relocations for the non-primary gots
10821 adds more dynamic relocations. We cannot count them until
10824 if (elf_hash_table (info
)->dynamic_sections_created
)
10827 bfd_boolean swap_out_p
;
10829 BFD_ASSERT (sdyn
!= NULL
);
10831 for (b
= sdyn
->contents
;
10832 b
< sdyn
->contents
+ sdyn
->size
;
10833 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
10835 Elf_Internal_Dyn dyn
;
10838 /* Read in the current dynamic entry. */
10839 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
10841 /* Assume that we're going to modify it and write it out. */
10847 /* Reduce DT_RELSZ to account for any relocations we
10848 decided not to make. This is for the n64 irix rld,
10849 which doesn't seem to apply any relocations if there
10850 are trailing null entries. */
10851 s
= mips_elf_rel_dyn_section (info
, FALSE
);
10852 dyn
.d_un
.d_val
= (s
->reloc_count
10853 * (ABI_64_P (output_bfd
)
10854 ? sizeof (Elf64_Mips_External_Rel
)
10855 : sizeof (Elf32_External_Rel
)));
10856 /* Adjust the section size too. Tools like the prelinker
10857 can reasonably expect the values to the same. */
10858 elf_section_data (s
->output_section
)->this_hdr
.sh_size
10863 swap_out_p
= FALSE
;
10868 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
10875 Elf32_compact_rel cpt
;
10877 if (SGI_COMPAT (output_bfd
))
10879 /* Write .compact_rel section out. */
10880 s
= bfd_get_linker_section (dynobj
, ".compact_rel");
10884 cpt
.num
= s
->reloc_count
;
10886 cpt
.offset
= (s
->output_section
->filepos
10887 + sizeof (Elf32_External_compact_rel
));
10890 bfd_elf32_swap_compact_rel_out (output_bfd
, &cpt
,
10891 ((Elf32_External_compact_rel
*)
10894 /* Clean up a dummy stub function entry in .text. */
10895 if (htab
->sstubs
!= NULL
)
10897 file_ptr dummy_offset
;
10899 BFD_ASSERT (htab
->sstubs
->size
>= htab
->function_stub_size
);
10900 dummy_offset
= htab
->sstubs
->size
- htab
->function_stub_size
;
10901 memset (htab
->sstubs
->contents
+ dummy_offset
, 0,
10902 htab
->function_stub_size
);
10907 /* The psABI says that the dynamic relocations must be sorted in
10908 increasing order of r_symndx. The VxWorks EABI doesn't require
10909 this, and because the code below handles REL rather than RELA
10910 relocations, using it for VxWorks would be outright harmful. */
10911 if (!htab
->is_vxworks
)
10913 s
= mips_elf_rel_dyn_section (info
, FALSE
);
10915 && s
->size
> (bfd_vma
)2 * MIPS_ELF_REL_SIZE (output_bfd
))
10917 reldyn_sorting_bfd
= output_bfd
;
10919 if (ABI_64_P (output_bfd
))
10920 qsort ((Elf64_External_Rel
*) s
->contents
+ 1,
10921 s
->reloc_count
- 1, sizeof (Elf64_Mips_External_Rel
),
10922 sort_dynamic_relocs_64
);
10924 qsort ((Elf32_External_Rel
*) s
->contents
+ 1,
10925 s
->reloc_count
- 1, sizeof (Elf32_External_Rel
),
10926 sort_dynamic_relocs
);
10931 if (htab
->splt
&& htab
->splt
->size
> 0)
10933 if (htab
->is_vxworks
)
10936 mips_vxworks_finish_shared_plt (output_bfd
, info
);
10938 mips_vxworks_finish_exec_plt (output_bfd
, info
);
10942 BFD_ASSERT (!info
->shared
);
10943 mips_finish_exec_plt (output_bfd
, info
);
10950 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
10953 mips_set_isa_flags (bfd
*abfd
)
10957 switch (bfd_get_mach (abfd
))
10960 case bfd_mach_mips3000
:
10961 val
= E_MIPS_ARCH_1
;
10964 case bfd_mach_mips3900
:
10965 val
= E_MIPS_ARCH_1
| E_MIPS_MACH_3900
;
10968 case bfd_mach_mips6000
:
10969 val
= E_MIPS_ARCH_2
;
10972 case bfd_mach_mips4000
:
10973 case bfd_mach_mips4300
:
10974 case bfd_mach_mips4400
:
10975 case bfd_mach_mips4600
:
10976 val
= E_MIPS_ARCH_3
;
10979 case bfd_mach_mips4010
:
10980 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4010
;
10983 case bfd_mach_mips4100
:
10984 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4100
;
10987 case bfd_mach_mips4111
:
10988 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4111
;
10991 case bfd_mach_mips4120
:
10992 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4120
;
10995 case bfd_mach_mips4650
:
10996 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4650
;
10999 case bfd_mach_mips5400
:
11000 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5400
;
11003 case bfd_mach_mips5500
:
11004 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5500
;
11007 case bfd_mach_mips5900
:
11008 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_5900
;
11011 case bfd_mach_mips9000
:
11012 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_9000
;
11015 case bfd_mach_mips5000
:
11016 case bfd_mach_mips7000
:
11017 case bfd_mach_mips8000
:
11018 case bfd_mach_mips10000
:
11019 case bfd_mach_mips12000
:
11020 case bfd_mach_mips14000
:
11021 case bfd_mach_mips16000
:
11022 val
= E_MIPS_ARCH_4
;
11025 case bfd_mach_mips5
:
11026 val
= E_MIPS_ARCH_5
;
11029 case bfd_mach_mips_loongson_2e
:
11030 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_LS2E
;
11033 case bfd_mach_mips_loongson_2f
:
11034 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_LS2F
;
11037 case bfd_mach_mips_sb1
:
11038 val
= E_MIPS_ARCH_64
| E_MIPS_MACH_SB1
;
11041 case bfd_mach_mips_loongson_3a
:
11042 val
= E_MIPS_ARCH_64
| E_MIPS_MACH_LS3A
;
11045 case bfd_mach_mips_octeon
:
11046 case bfd_mach_mips_octeonp
:
11047 val
= E_MIPS_ARCH_64R2
| E_MIPS_MACH_OCTEON
;
11050 case bfd_mach_mips_xlr
:
11051 val
= E_MIPS_ARCH_64
| E_MIPS_MACH_XLR
;
11054 case bfd_mach_mips_octeon2
:
11055 val
= E_MIPS_ARCH_64R2
| E_MIPS_MACH_OCTEON2
;
11058 case bfd_mach_mipsisa32
:
11059 val
= E_MIPS_ARCH_32
;
11062 case bfd_mach_mipsisa64
:
11063 val
= E_MIPS_ARCH_64
;
11066 case bfd_mach_mipsisa32r2
:
11067 val
= E_MIPS_ARCH_32R2
;
11070 case bfd_mach_mipsisa64r2
:
11071 val
= E_MIPS_ARCH_64R2
;
11074 elf_elfheader (abfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
11075 elf_elfheader (abfd
)->e_flags
|= val
;
11080 /* The final processing done just before writing out a MIPS ELF object
11081 file. This gets the MIPS architecture right based on the machine
11082 number. This is used by both the 32-bit and the 64-bit ABI. */
11085 _bfd_mips_elf_final_write_processing (bfd
*abfd
,
11086 bfd_boolean linker ATTRIBUTE_UNUSED
)
11089 Elf_Internal_Shdr
**hdrpp
;
11093 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
11094 is nonzero. This is for compatibility with old objects, which used
11095 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
11096 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_MACH
) == 0)
11097 mips_set_isa_flags (abfd
);
11099 /* Set the sh_info field for .gptab sections and other appropriate
11100 info for each special section. */
11101 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
11102 i
< elf_numsections (abfd
);
11105 switch ((*hdrpp
)->sh_type
)
11107 case SHT_MIPS_MSYM
:
11108 case SHT_MIPS_LIBLIST
:
11109 sec
= bfd_get_section_by_name (abfd
, ".dynstr");
11111 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
11114 case SHT_MIPS_GPTAB
:
11115 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
11116 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
11117 BFD_ASSERT (name
!= NULL
11118 && CONST_STRNEQ (name
, ".gptab."));
11119 sec
= bfd_get_section_by_name (abfd
, name
+ sizeof ".gptab" - 1);
11120 BFD_ASSERT (sec
!= NULL
);
11121 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
11124 case SHT_MIPS_CONTENT
:
11125 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
11126 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
11127 BFD_ASSERT (name
!= NULL
11128 && CONST_STRNEQ (name
, ".MIPS.content"));
11129 sec
= bfd_get_section_by_name (abfd
,
11130 name
+ sizeof ".MIPS.content" - 1);
11131 BFD_ASSERT (sec
!= NULL
);
11132 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
11135 case SHT_MIPS_SYMBOL_LIB
:
11136 sec
= bfd_get_section_by_name (abfd
, ".dynsym");
11138 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
11139 sec
= bfd_get_section_by_name (abfd
, ".liblist");
11141 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
11144 case SHT_MIPS_EVENTS
:
11145 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
11146 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
11147 BFD_ASSERT (name
!= NULL
);
11148 if (CONST_STRNEQ (name
, ".MIPS.events"))
11149 sec
= bfd_get_section_by_name (abfd
,
11150 name
+ sizeof ".MIPS.events" - 1);
11153 BFD_ASSERT (CONST_STRNEQ (name
, ".MIPS.post_rel"));
11154 sec
= bfd_get_section_by_name (abfd
,
11156 + sizeof ".MIPS.post_rel" - 1));
11158 BFD_ASSERT (sec
!= NULL
);
11159 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
11166 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
11170 _bfd_mips_elf_additional_program_headers (bfd
*abfd
,
11171 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
11176 /* See if we need a PT_MIPS_REGINFO segment. */
11177 s
= bfd_get_section_by_name (abfd
, ".reginfo");
11178 if (s
&& (s
->flags
& SEC_LOAD
))
11181 /* See if we need a PT_MIPS_OPTIONS segment. */
11182 if (IRIX_COMPAT (abfd
) == ict_irix6
11183 && bfd_get_section_by_name (abfd
,
11184 MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)))
11187 /* See if we need a PT_MIPS_RTPROC segment. */
11188 if (IRIX_COMPAT (abfd
) == ict_irix5
11189 && bfd_get_section_by_name (abfd
, ".dynamic")
11190 && bfd_get_section_by_name (abfd
, ".mdebug"))
11193 /* Allocate a PT_NULL header in dynamic objects. See
11194 _bfd_mips_elf_modify_segment_map for details. */
11195 if (!SGI_COMPAT (abfd
)
11196 && bfd_get_section_by_name (abfd
, ".dynamic"))
11202 /* Modify the segment map for an IRIX5 executable. */
11205 _bfd_mips_elf_modify_segment_map (bfd
*abfd
,
11206 struct bfd_link_info
*info
)
11209 struct elf_segment_map
*m
, **pm
;
11212 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
11214 s
= bfd_get_section_by_name (abfd
, ".reginfo");
11215 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
11217 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
11218 if (m
->p_type
== PT_MIPS_REGINFO
)
11223 m
= bfd_zalloc (abfd
, amt
);
11227 m
->p_type
= PT_MIPS_REGINFO
;
11229 m
->sections
[0] = s
;
11231 /* We want to put it after the PHDR and INTERP segments. */
11232 pm
= &elf_tdata (abfd
)->segment_map
;
11234 && ((*pm
)->p_type
== PT_PHDR
11235 || (*pm
)->p_type
== PT_INTERP
))
11243 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
11244 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
11245 PT_MIPS_OPTIONS segment immediately following the program header
11247 if (NEWABI_P (abfd
)
11248 /* On non-IRIX6 new abi, we'll have already created a segment
11249 for this section, so don't create another. I'm not sure this
11250 is not also the case for IRIX 6, but I can't test it right
11252 && IRIX_COMPAT (abfd
) == ict_irix6
)
11254 for (s
= abfd
->sections
; s
; s
= s
->next
)
11255 if (elf_section_data (s
)->this_hdr
.sh_type
== SHT_MIPS_OPTIONS
)
11260 struct elf_segment_map
*options_segment
;
11262 pm
= &elf_tdata (abfd
)->segment_map
;
11264 && ((*pm
)->p_type
== PT_PHDR
11265 || (*pm
)->p_type
== PT_INTERP
))
11268 if (*pm
== NULL
|| (*pm
)->p_type
!= PT_MIPS_OPTIONS
)
11270 amt
= sizeof (struct elf_segment_map
);
11271 options_segment
= bfd_zalloc (abfd
, amt
);
11272 options_segment
->next
= *pm
;
11273 options_segment
->p_type
= PT_MIPS_OPTIONS
;
11274 options_segment
->p_flags
= PF_R
;
11275 options_segment
->p_flags_valid
= TRUE
;
11276 options_segment
->count
= 1;
11277 options_segment
->sections
[0] = s
;
11278 *pm
= options_segment
;
11284 if (IRIX_COMPAT (abfd
) == ict_irix5
)
11286 /* If there are .dynamic and .mdebug sections, we make a room
11287 for the RTPROC header. FIXME: Rewrite without section names. */
11288 if (bfd_get_section_by_name (abfd
, ".interp") == NULL
11289 && bfd_get_section_by_name (abfd
, ".dynamic") != NULL
11290 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
11292 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
11293 if (m
->p_type
== PT_MIPS_RTPROC
)
11298 m
= bfd_zalloc (abfd
, amt
);
11302 m
->p_type
= PT_MIPS_RTPROC
;
11304 s
= bfd_get_section_by_name (abfd
, ".rtproc");
11309 m
->p_flags_valid
= 1;
11314 m
->sections
[0] = s
;
11317 /* We want to put it after the DYNAMIC segment. */
11318 pm
= &elf_tdata (abfd
)->segment_map
;
11319 while (*pm
!= NULL
&& (*pm
)->p_type
!= PT_DYNAMIC
)
11329 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
11330 .dynstr, .dynsym, and .hash sections, and everything in
11332 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
;
11334 if ((*pm
)->p_type
== PT_DYNAMIC
)
11337 if (m
!= NULL
&& IRIX_COMPAT (abfd
) == ict_none
)
11339 /* For a normal mips executable the permissions for the PT_DYNAMIC
11340 segment are read, write and execute. We do that here since
11341 the code in elf.c sets only the read permission. This matters
11342 sometimes for the dynamic linker. */
11343 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
11345 m
->p_flags
= PF_R
| PF_W
| PF_X
;
11346 m
->p_flags_valid
= 1;
11349 /* GNU/Linux binaries do not need the extended PT_DYNAMIC section.
11350 glibc's dynamic linker has traditionally derived the number of
11351 tags from the p_filesz field, and sometimes allocates stack
11352 arrays of that size. An overly-big PT_DYNAMIC segment can
11353 be actively harmful in such cases. Making PT_DYNAMIC contain
11354 other sections can also make life hard for the prelinker,
11355 which might move one of the other sections to a different
11356 PT_LOAD segment. */
11357 if (SGI_COMPAT (abfd
)
11360 && strcmp (m
->sections
[0]->name
, ".dynamic") == 0)
11362 static const char *sec_names
[] =
11364 ".dynamic", ".dynstr", ".dynsym", ".hash"
11368 struct elf_segment_map
*n
;
11370 low
= ~(bfd_vma
) 0;
11372 for (i
= 0; i
< sizeof sec_names
/ sizeof sec_names
[0]; i
++)
11374 s
= bfd_get_section_by_name (abfd
, sec_names
[i
]);
11375 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
11382 if (high
< s
->vma
+ sz
)
11383 high
= s
->vma
+ sz
;
11388 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
11389 if ((s
->flags
& SEC_LOAD
) != 0
11391 && s
->vma
+ s
->size
<= high
)
11394 amt
= sizeof *n
+ (bfd_size_type
) (c
- 1) * sizeof (asection
*);
11395 n
= bfd_zalloc (abfd
, amt
);
11402 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
11404 if ((s
->flags
& SEC_LOAD
) != 0
11406 && s
->vma
+ s
->size
<= high
)
11408 n
->sections
[i
] = s
;
11417 /* Allocate a spare program header in dynamic objects so that tools
11418 like the prelinker can add an extra PT_LOAD entry.
11420 If the prelinker needs to make room for a new PT_LOAD entry, its
11421 standard procedure is to move the first (read-only) sections into
11422 the new (writable) segment. However, the MIPS ABI requires
11423 .dynamic to be in a read-only segment, and the section will often
11424 start within sizeof (ElfNN_Phdr) bytes of the last program header.
11426 Although the prelinker could in principle move .dynamic to a
11427 writable segment, it seems better to allocate a spare program
11428 header instead, and avoid the need to move any sections.
11429 There is a long tradition of allocating spare dynamic tags,
11430 so allocating a spare program header seems like a natural
11433 If INFO is NULL, we may be copying an already prelinked binary
11434 with objcopy or strip, so do not add this header. */
11436 && !SGI_COMPAT (abfd
)
11437 && bfd_get_section_by_name (abfd
, ".dynamic"))
11439 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
; pm
= &(*pm
)->next
)
11440 if ((*pm
)->p_type
== PT_NULL
)
11444 m
= bfd_zalloc (abfd
, sizeof (*m
));
11448 m
->p_type
= PT_NULL
;
11456 /* Return the section that should be marked against GC for a given
11460 _bfd_mips_elf_gc_mark_hook (asection
*sec
,
11461 struct bfd_link_info
*info
,
11462 Elf_Internal_Rela
*rel
,
11463 struct elf_link_hash_entry
*h
,
11464 Elf_Internal_Sym
*sym
)
11466 /* ??? Do mips16 stub sections need to be handled special? */
11469 switch (ELF_R_TYPE (sec
->owner
, rel
->r_info
))
11471 case R_MIPS_GNU_VTINHERIT
:
11472 case R_MIPS_GNU_VTENTRY
:
11476 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
11479 /* Update the got entry reference counts for the section being removed. */
11482 _bfd_mips_elf_gc_sweep_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
11483 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
11484 asection
*sec ATTRIBUTE_UNUSED
,
11485 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
)
11488 Elf_Internal_Shdr
*symtab_hdr
;
11489 struct elf_link_hash_entry
**sym_hashes
;
11490 bfd_signed_vma
*local_got_refcounts
;
11491 const Elf_Internal_Rela
*rel
, *relend
;
11492 unsigned long r_symndx
;
11493 struct elf_link_hash_entry
*h
;
11495 if (info
->relocatable
)
11498 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11499 sym_hashes
= elf_sym_hashes (abfd
);
11500 local_got_refcounts
= elf_local_got_refcounts (abfd
);
11502 relend
= relocs
+ sec
->reloc_count
;
11503 for (rel
= relocs
; rel
< relend
; rel
++)
11504 switch (ELF_R_TYPE (abfd
, rel
->r_info
))
11506 case R_MIPS16_GOT16
:
11507 case R_MIPS16_CALL16
:
11509 case R_MIPS_CALL16
:
11510 case R_MIPS_CALL_HI16
:
11511 case R_MIPS_CALL_LO16
:
11512 case R_MIPS_GOT_HI16
:
11513 case R_MIPS_GOT_LO16
:
11514 case R_MIPS_GOT_DISP
:
11515 case R_MIPS_GOT_PAGE
:
11516 case R_MIPS_GOT_OFST
:
11517 case R_MICROMIPS_GOT16
:
11518 case R_MICROMIPS_CALL16
:
11519 case R_MICROMIPS_CALL_HI16
:
11520 case R_MICROMIPS_CALL_LO16
:
11521 case R_MICROMIPS_GOT_HI16
:
11522 case R_MICROMIPS_GOT_LO16
:
11523 case R_MICROMIPS_GOT_DISP
:
11524 case R_MICROMIPS_GOT_PAGE
:
11525 case R_MICROMIPS_GOT_OFST
:
11526 /* ??? It would seem that the existing MIPS code does no sort
11527 of reference counting or whatnot on its GOT and PLT entries,
11528 so it is not possible to garbage collect them at this time. */
11539 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
11540 hiding the old indirect symbol. Process additional relocation
11541 information. Also called for weakdefs, in which case we just let
11542 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
11545 _bfd_mips_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
11546 struct elf_link_hash_entry
*dir
,
11547 struct elf_link_hash_entry
*ind
)
11549 struct mips_elf_link_hash_entry
*dirmips
, *indmips
;
11551 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
11553 dirmips
= (struct mips_elf_link_hash_entry
*) dir
;
11554 indmips
= (struct mips_elf_link_hash_entry
*) ind
;
11555 /* Any absolute non-dynamic relocations against an indirect or weak
11556 definition will be against the target symbol. */
11557 if (indmips
->has_static_relocs
)
11558 dirmips
->has_static_relocs
= TRUE
;
11560 if (ind
->root
.type
!= bfd_link_hash_indirect
)
11563 dirmips
->possibly_dynamic_relocs
+= indmips
->possibly_dynamic_relocs
;
11564 if (indmips
->readonly_reloc
)
11565 dirmips
->readonly_reloc
= TRUE
;
11566 if (indmips
->no_fn_stub
)
11567 dirmips
->no_fn_stub
= TRUE
;
11568 if (indmips
->fn_stub
)
11570 dirmips
->fn_stub
= indmips
->fn_stub
;
11571 indmips
->fn_stub
= NULL
;
11573 if (indmips
->need_fn_stub
)
11575 dirmips
->need_fn_stub
= TRUE
;
11576 indmips
->need_fn_stub
= FALSE
;
11578 if (indmips
->call_stub
)
11580 dirmips
->call_stub
= indmips
->call_stub
;
11581 indmips
->call_stub
= NULL
;
11583 if (indmips
->call_fp_stub
)
11585 dirmips
->call_fp_stub
= indmips
->call_fp_stub
;
11586 indmips
->call_fp_stub
= NULL
;
11588 if (indmips
->global_got_area
< dirmips
->global_got_area
)
11589 dirmips
->global_got_area
= indmips
->global_got_area
;
11590 if (indmips
->global_got_area
< GGA_NONE
)
11591 indmips
->global_got_area
= GGA_NONE
;
11592 if (indmips
->has_nonpic_branches
)
11593 dirmips
->has_nonpic_branches
= TRUE
;
11595 if (dirmips
->tls_ie_type
== 0)
11596 dirmips
->tls_ie_type
= indmips
->tls_ie_type
;
11597 if (dirmips
->tls_gd_type
== 0)
11598 dirmips
->tls_gd_type
= indmips
->tls_gd_type
;
11601 #define PDR_SIZE 32
11604 _bfd_mips_elf_discard_info (bfd
*abfd
, struct elf_reloc_cookie
*cookie
,
11605 struct bfd_link_info
*info
)
11608 bfd_boolean ret
= FALSE
;
11609 unsigned char *tdata
;
11612 o
= bfd_get_section_by_name (abfd
, ".pdr");
11617 if (o
->size
% PDR_SIZE
!= 0)
11619 if (o
->output_section
!= NULL
11620 && bfd_is_abs_section (o
->output_section
))
11623 tdata
= bfd_zmalloc (o
->size
/ PDR_SIZE
);
11627 cookie
->rels
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
11628 info
->keep_memory
);
11635 cookie
->rel
= cookie
->rels
;
11636 cookie
->relend
= cookie
->rels
+ o
->reloc_count
;
11638 for (i
= 0, skip
= 0; i
< o
->size
/ PDR_SIZE
; i
++)
11640 if (bfd_elf_reloc_symbol_deleted_p (i
* PDR_SIZE
, cookie
))
11649 mips_elf_section_data (o
)->u
.tdata
= tdata
;
11650 o
->size
-= skip
* PDR_SIZE
;
11656 if (! info
->keep_memory
)
11657 free (cookie
->rels
);
11663 _bfd_mips_elf_ignore_discarded_relocs (asection
*sec
)
11665 if (strcmp (sec
->name
, ".pdr") == 0)
11671 _bfd_mips_elf_write_section (bfd
*output_bfd
,
11672 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
11673 asection
*sec
, bfd_byte
*contents
)
11675 bfd_byte
*to
, *from
, *end
;
11678 if (strcmp (sec
->name
, ".pdr") != 0)
11681 if (mips_elf_section_data (sec
)->u
.tdata
== NULL
)
11685 end
= contents
+ sec
->size
;
11686 for (from
= contents
, i
= 0;
11688 from
+= PDR_SIZE
, i
++)
11690 if ((mips_elf_section_data (sec
)->u
.tdata
)[i
] == 1)
11693 memcpy (to
, from
, PDR_SIZE
);
11696 bfd_set_section_contents (output_bfd
, sec
->output_section
, contents
,
11697 sec
->output_offset
, sec
->size
);
11701 /* microMIPS code retains local labels for linker relaxation. Omit them
11702 from output by default for clarity. */
11705 _bfd_mips_elf_is_target_special_symbol (bfd
*abfd
, asymbol
*sym
)
11707 return _bfd_elf_is_local_label_name (abfd
, sym
->name
);
11710 /* MIPS ELF uses a special find_nearest_line routine in order the
11711 handle the ECOFF debugging information. */
11713 struct mips_elf_find_line
11715 struct ecoff_debug_info d
;
11716 struct ecoff_find_line i
;
11720 _bfd_mips_elf_find_nearest_line (bfd
*abfd
, asection
*section
,
11721 asymbol
**symbols
, bfd_vma offset
,
11722 const char **filename_ptr
,
11723 const char **functionname_ptr
,
11724 unsigned int *line_ptr
)
11728 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
11729 filename_ptr
, functionname_ptr
,
11733 if (_bfd_dwarf2_find_nearest_line (abfd
, dwarf_debug_sections
,
11734 section
, symbols
, offset
,
11735 filename_ptr
, functionname_ptr
,
11736 line_ptr
, NULL
, ABI_64_P (abfd
) ? 8 : 0,
11737 &elf_tdata (abfd
)->dwarf2_find_line_info
))
11740 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
11743 flagword origflags
;
11744 struct mips_elf_find_line
*fi
;
11745 const struct ecoff_debug_swap
* const swap
=
11746 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
11748 /* If we are called during a link, mips_elf_final_link may have
11749 cleared the SEC_HAS_CONTENTS field. We force it back on here
11750 if appropriate (which it normally will be). */
11751 origflags
= msec
->flags
;
11752 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
11753 msec
->flags
|= SEC_HAS_CONTENTS
;
11755 fi
= elf_tdata (abfd
)->find_line_info
;
11758 bfd_size_type external_fdr_size
;
11761 struct fdr
*fdr_ptr
;
11762 bfd_size_type amt
= sizeof (struct mips_elf_find_line
);
11764 fi
= bfd_zalloc (abfd
, amt
);
11767 msec
->flags
= origflags
;
11771 if (! _bfd_mips_elf_read_ecoff_info (abfd
, msec
, &fi
->d
))
11773 msec
->flags
= origflags
;
11777 /* Swap in the FDR information. */
11778 amt
= fi
->d
.symbolic_header
.ifdMax
* sizeof (struct fdr
);
11779 fi
->d
.fdr
= bfd_alloc (abfd
, amt
);
11780 if (fi
->d
.fdr
== NULL
)
11782 msec
->flags
= origflags
;
11785 external_fdr_size
= swap
->external_fdr_size
;
11786 fdr_ptr
= fi
->d
.fdr
;
11787 fraw_src
= (char *) fi
->d
.external_fdr
;
11788 fraw_end
= (fraw_src
11789 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
11790 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
11791 (*swap
->swap_fdr_in
) (abfd
, fraw_src
, fdr_ptr
);
11793 elf_tdata (abfd
)->find_line_info
= fi
;
11795 /* Note that we don't bother to ever free this information.
11796 find_nearest_line is either called all the time, as in
11797 objdump -l, so the information should be saved, or it is
11798 rarely called, as in ld error messages, so the memory
11799 wasted is unimportant. Still, it would probably be a
11800 good idea for free_cached_info to throw it away. */
11803 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
11804 &fi
->i
, filename_ptr
, functionname_ptr
,
11807 msec
->flags
= origflags
;
11811 msec
->flags
= origflags
;
11814 /* Fall back on the generic ELF find_nearest_line routine. */
11816 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
11817 filename_ptr
, functionname_ptr
,
11822 _bfd_mips_elf_find_inliner_info (bfd
*abfd
,
11823 const char **filename_ptr
,
11824 const char **functionname_ptr
,
11825 unsigned int *line_ptr
)
11828 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
11829 functionname_ptr
, line_ptr
,
11830 & elf_tdata (abfd
)->dwarf2_find_line_info
);
11835 /* When are writing out the .options or .MIPS.options section,
11836 remember the bytes we are writing out, so that we can install the
11837 GP value in the section_processing routine. */
11840 _bfd_mips_elf_set_section_contents (bfd
*abfd
, sec_ptr section
,
11841 const void *location
,
11842 file_ptr offset
, bfd_size_type count
)
11844 if (MIPS_ELF_OPTIONS_SECTION_NAME_P (section
->name
))
11848 if (elf_section_data (section
) == NULL
)
11850 bfd_size_type amt
= sizeof (struct bfd_elf_section_data
);
11851 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
11852 if (elf_section_data (section
) == NULL
)
11855 c
= mips_elf_section_data (section
)->u
.tdata
;
11858 c
= bfd_zalloc (abfd
, section
->size
);
11861 mips_elf_section_data (section
)->u
.tdata
= c
;
11864 memcpy (c
+ offset
, location
, count
);
11867 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
,
11871 /* This is almost identical to bfd_generic_get_... except that some
11872 MIPS relocations need to be handled specially. Sigh. */
11875 _bfd_elf_mips_get_relocated_section_contents
11877 struct bfd_link_info
*link_info
,
11878 struct bfd_link_order
*link_order
,
11880 bfd_boolean relocatable
,
11883 /* Get enough memory to hold the stuff */
11884 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
11885 asection
*input_section
= link_order
->u
.indirect
.section
;
11888 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
11889 arelent
**reloc_vector
= NULL
;
11892 if (reloc_size
< 0)
11895 reloc_vector
= bfd_malloc (reloc_size
);
11896 if (reloc_vector
== NULL
&& reloc_size
!= 0)
11899 /* read in the section */
11900 sz
= input_section
->rawsize
? input_section
->rawsize
: input_section
->size
;
11901 if (!bfd_get_section_contents (input_bfd
, input_section
, data
, 0, sz
))
11904 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
11908 if (reloc_count
< 0)
11911 if (reloc_count
> 0)
11916 bfd_vma gp
= 0x12345678; /* initialize just to shut gcc up */
11919 struct bfd_hash_entry
*h
;
11920 struct bfd_link_hash_entry
*lh
;
11921 /* Skip all this stuff if we aren't mixing formats. */
11922 if (abfd
&& input_bfd
11923 && abfd
->xvec
== input_bfd
->xvec
)
11927 h
= bfd_hash_lookup (&link_info
->hash
->table
, "_gp", FALSE
, FALSE
);
11928 lh
= (struct bfd_link_hash_entry
*) h
;
11935 case bfd_link_hash_undefined
:
11936 case bfd_link_hash_undefweak
:
11937 case bfd_link_hash_common
:
11940 case bfd_link_hash_defined
:
11941 case bfd_link_hash_defweak
:
11943 gp
= lh
->u
.def
.value
;
11945 case bfd_link_hash_indirect
:
11946 case bfd_link_hash_warning
:
11948 /* @@FIXME ignoring warning for now */
11950 case bfd_link_hash_new
:
11959 for (parent
= reloc_vector
; *parent
!= NULL
; parent
++)
11961 char *error_message
= NULL
;
11962 bfd_reloc_status_type r
;
11964 /* Specific to MIPS: Deal with relocation types that require
11965 knowing the gp of the output bfd. */
11966 asymbol
*sym
= *(*parent
)->sym_ptr_ptr
;
11968 /* If we've managed to find the gp and have a special
11969 function for the relocation then go ahead, else default
11970 to the generic handling. */
11972 && (*parent
)->howto
->special_function
11973 == _bfd_mips_elf32_gprel16_reloc
)
11974 r
= _bfd_mips_elf_gprel16_with_gp (input_bfd
, sym
, *parent
,
11975 input_section
, relocatable
,
11978 r
= bfd_perform_relocation (input_bfd
, *parent
, data
,
11980 relocatable
? abfd
: NULL
,
11985 asection
*os
= input_section
->output_section
;
11987 /* A partial link, so keep the relocs */
11988 os
->orelocation
[os
->reloc_count
] = *parent
;
11992 if (r
!= bfd_reloc_ok
)
11996 case bfd_reloc_undefined
:
11997 if (!((*link_info
->callbacks
->undefined_symbol
)
11998 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
11999 input_bfd
, input_section
, (*parent
)->address
, TRUE
)))
12002 case bfd_reloc_dangerous
:
12003 BFD_ASSERT (error_message
!= NULL
);
12004 if (!((*link_info
->callbacks
->reloc_dangerous
)
12005 (link_info
, error_message
, input_bfd
, input_section
,
12006 (*parent
)->address
)))
12009 case bfd_reloc_overflow
:
12010 if (!((*link_info
->callbacks
->reloc_overflow
)
12012 bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
12013 (*parent
)->howto
->name
, (*parent
)->addend
,
12014 input_bfd
, input_section
, (*parent
)->address
)))
12017 case bfd_reloc_outofrange
:
12026 if (reloc_vector
!= NULL
)
12027 free (reloc_vector
);
12031 if (reloc_vector
!= NULL
)
12032 free (reloc_vector
);
12037 mips_elf_relax_delete_bytes (bfd
*abfd
,
12038 asection
*sec
, bfd_vma addr
, int count
)
12040 Elf_Internal_Shdr
*symtab_hdr
;
12041 unsigned int sec_shndx
;
12042 bfd_byte
*contents
;
12043 Elf_Internal_Rela
*irel
, *irelend
;
12044 Elf_Internal_Sym
*isym
;
12045 Elf_Internal_Sym
*isymend
;
12046 struct elf_link_hash_entry
**sym_hashes
;
12047 struct elf_link_hash_entry
**end_hashes
;
12048 struct elf_link_hash_entry
**start_hashes
;
12049 unsigned int symcount
;
12051 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
12052 contents
= elf_section_data (sec
)->this_hdr
.contents
;
12054 irel
= elf_section_data (sec
)->relocs
;
12055 irelend
= irel
+ sec
->reloc_count
;
12057 /* Actually delete the bytes. */
12058 memmove (contents
+ addr
, contents
+ addr
+ count
,
12059 (size_t) (sec
->size
- addr
- count
));
12060 sec
->size
-= count
;
12062 /* Adjust all the relocs. */
12063 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
12065 /* Get the new reloc address. */
12066 if (irel
->r_offset
> addr
)
12067 irel
->r_offset
-= count
;
12070 BFD_ASSERT (addr
% 2 == 0);
12071 BFD_ASSERT (count
% 2 == 0);
12073 /* Adjust the local symbols defined in this section. */
12074 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
12075 isym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
12076 for (isymend
= isym
+ symtab_hdr
->sh_info
; isym
< isymend
; isym
++)
12077 if (isym
->st_shndx
== sec_shndx
&& isym
->st_value
> addr
)
12078 isym
->st_value
-= count
;
12080 /* Now adjust the global symbols defined in this section. */
12081 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
12082 - symtab_hdr
->sh_info
);
12083 sym_hashes
= start_hashes
= elf_sym_hashes (abfd
);
12084 end_hashes
= sym_hashes
+ symcount
;
12086 for (; sym_hashes
< end_hashes
; sym_hashes
++)
12088 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
12090 if ((sym_hash
->root
.type
== bfd_link_hash_defined
12091 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
12092 && sym_hash
->root
.u
.def
.section
== sec
)
12094 bfd_vma value
= sym_hash
->root
.u
.def
.value
;
12096 if (ELF_ST_IS_MICROMIPS (sym_hash
->other
))
12097 value
&= MINUS_TWO
;
12099 sym_hash
->root
.u
.def
.value
-= count
;
12107 /* Opcodes needed for microMIPS relaxation as found in
12108 opcodes/micromips-opc.c. */
12110 struct opcode_descriptor
{
12111 unsigned long match
;
12112 unsigned long mask
;
12115 /* The $ra register aka $31. */
12119 /* 32-bit instruction format register fields. */
12121 #define OP32_SREG(opcode) (((opcode) >> 16) & 0x1f)
12122 #define OP32_TREG(opcode) (((opcode) >> 21) & 0x1f)
12124 /* Check if a 5-bit register index can be abbreviated to 3 bits. */
12126 #define OP16_VALID_REG(r) \
12127 ((2 <= (r) && (r) <= 7) || (16 <= (r) && (r) <= 17))
12130 /* 32-bit and 16-bit branches. */
12132 static const struct opcode_descriptor b_insns_32
[] = {
12133 { /* "b", "p", */ 0x40400000, 0xffff0000 }, /* bgez 0 */
12134 { /* "b", "p", */ 0x94000000, 0xffff0000 }, /* beq 0, 0 */
12135 { 0, 0 } /* End marker for find_match(). */
12138 static const struct opcode_descriptor bc_insn_32
=
12139 { /* "bc(1|2)(ft)", "N,p", */ 0x42800000, 0xfec30000 };
12141 static const struct opcode_descriptor bz_insn_32
=
12142 { /* "b(g|l)(e|t)z", "s,p", */ 0x40000000, 0xff200000 };
12144 static const struct opcode_descriptor bzal_insn_32
=
12145 { /* "b(ge|lt)zal", "s,p", */ 0x40200000, 0xffa00000 };
12147 static const struct opcode_descriptor beq_insn_32
=
12148 { /* "b(eq|ne)", "s,t,p", */ 0x94000000, 0xdc000000 };
12150 static const struct opcode_descriptor b_insn_16
=
12151 { /* "b", "mD", */ 0xcc00, 0xfc00 };
12153 static const struct opcode_descriptor bz_insn_16
=
12154 { /* "b(eq|ne)z", "md,mE", */ 0x8c00, 0xdc00 };
12157 /* 32-bit and 16-bit branch EQ and NE zero. */
12159 /* NOTE: All opcode tables have BEQ/BNE in the same order: first the
12160 eq and second the ne. This convention is used when replacing a
12161 32-bit BEQ/BNE with the 16-bit version. */
12163 #define BZC32_REG_FIELD(r) (((r) & 0x1f) << 16)
12165 static const struct opcode_descriptor bz_rs_insns_32
[] = {
12166 { /* "beqz", "s,p", */ 0x94000000, 0xffe00000 },
12167 { /* "bnez", "s,p", */ 0xb4000000, 0xffe00000 },
12168 { 0, 0 } /* End marker for find_match(). */
12171 static const struct opcode_descriptor bz_rt_insns_32
[] = {
12172 { /* "beqz", "t,p", */ 0x94000000, 0xfc01f000 },
12173 { /* "bnez", "t,p", */ 0xb4000000, 0xfc01f000 },
12174 { 0, 0 } /* End marker for find_match(). */
12177 static const struct opcode_descriptor bzc_insns_32
[] = {
12178 { /* "beqzc", "s,p", */ 0x40e00000, 0xffe00000 },
12179 { /* "bnezc", "s,p", */ 0x40a00000, 0xffe00000 },
12180 { 0, 0 } /* End marker for find_match(). */
12183 static const struct opcode_descriptor bz_insns_16
[] = {
12184 { /* "beqz", "md,mE", */ 0x8c00, 0xfc00 },
12185 { /* "bnez", "md,mE", */ 0xac00, 0xfc00 },
12186 { 0, 0 } /* End marker for find_match(). */
12189 /* Switch between a 5-bit register index and its 3-bit shorthand. */
12191 #define BZ16_REG(opcode) ((((((opcode) >> 7) & 7) + 0x1e) & 0x17) + 2)
12192 #define BZ16_REG_FIELD(r) \
12193 (((2 <= (r) && (r) <= 7) ? (r) : ((r) - 16)) << 7)
12196 /* 32-bit instructions with a delay slot. */
12198 static const struct opcode_descriptor jal_insn_32_bd16
=
12199 { /* "jals", "a", */ 0x74000000, 0xfc000000 };
12201 static const struct opcode_descriptor jal_insn_32_bd32
=
12202 { /* "jal", "a", */ 0xf4000000, 0xfc000000 };
12204 static const struct opcode_descriptor jal_x_insn_32_bd32
=
12205 { /* "jal[x]", "a", */ 0xf0000000, 0xf8000000 };
12207 static const struct opcode_descriptor j_insn_32
=
12208 { /* "j", "a", */ 0xd4000000, 0xfc000000 };
12210 static const struct opcode_descriptor jalr_insn_32
=
12211 { /* "jalr[.hb]", "t,s", */ 0x00000f3c, 0xfc00efff };
12213 /* This table can be compacted, because no opcode replacement is made. */
12215 static const struct opcode_descriptor ds_insns_32_bd16
[] = {
12216 { /* "jals", "a", */ 0x74000000, 0xfc000000 },
12218 { /* "jalrs[.hb]", "t,s", */ 0x00004f3c, 0xfc00efff },
12219 { /* "b(ge|lt)zals", "s,p", */ 0x42200000, 0xffa00000 },
12221 { /* "b(g|l)(e|t)z", "s,p", */ 0x40000000, 0xff200000 },
12222 { /* "b(eq|ne)", "s,t,p", */ 0x94000000, 0xdc000000 },
12223 { /* "j", "a", */ 0xd4000000, 0xfc000000 },
12224 { 0, 0 } /* End marker for find_match(). */
12227 /* This table can be compacted, because no opcode replacement is made. */
12229 static const struct opcode_descriptor ds_insns_32_bd32
[] = {
12230 { /* "jal[x]", "a", */ 0xf0000000, 0xf8000000 },
12232 { /* "jalr[.hb]", "t,s", */ 0x00000f3c, 0xfc00efff },
12233 { /* "b(ge|lt)zal", "s,p", */ 0x40200000, 0xffa00000 },
12234 { 0, 0 } /* End marker for find_match(). */
12238 /* 16-bit instructions with a delay slot. */
12240 static const struct opcode_descriptor jalr_insn_16_bd16
=
12241 { /* "jalrs", "my,mj", */ 0x45e0, 0xffe0 };
12243 static const struct opcode_descriptor jalr_insn_16_bd32
=
12244 { /* "jalr", "my,mj", */ 0x45c0, 0xffe0 };
12246 static const struct opcode_descriptor jr_insn_16
=
12247 { /* "jr", "mj", */ 0x4580, 0xffe0 };
12249 #define JR16_REG(opcode) ((opcode) & 0x1f)
12251 /* This table can be compacted, because no opcode replacement is made. */
12253 static const struct opcode_descriptor ds_insns_16_bd16
[] = {
12254 { /* "jalrs", "my,mj", */ 0x45e0, 0xffe0 },
12256 { /* "b", "mD", */ 0xcc00, 0xfc00 },
12257 { /* "b(eq|ne)z", "md,mE", */ 0x8c00, 0xdc00 },
12258 { /* "jr", "mj", */ 0x4580, 0xffe0 },
12259 { 0, 0 } /* End marker for find_match(). */
12263 /* LUI instruction. */
12265 static const struct opcode_descriptor lui_insn
=
12266 { /* "lui", "s,u", */ 0x41a00000, 0xffe00000 };
12269 /* ADDIU instruction. */
12271 static const struct opcode_descriptor addiu_insn
=
12272 { /* "addiu", "t,r,j", */ 0x30000000, 0xfc000000 };
12274 static const struct opcode_descriptor addiupc_insn
=
12275 { /* "addiu", "mb,$pc,mQ", */ 0x78000000, 0xfc000000 };
12277 #define ADDIUPC_REG_FIELD(r) \
12278 (((2 <= (r) && (r) <= 7) ? (r) : ((r) - 16)) << 23)
12281 /* Relaxable instructions in a JAL delay slot: MOVE. */
12283 /* The 16-bit move has rd in 9:5 and rs in 4:0. The 32-bit moves
12284 (ADDU, OR) have rd in 15:11 and rs in 10:16. */
12285 #define MOVE32_RD(opcode) (((opcode) >> 11) & 0x1f)
12286 #define MOVE32_RS(opcode) (((opcode) >> 16) & 0x1f)
12288 #define MOVE16_RD_FIELD(r) (((r) & 0x1f) << 5)
12289 #define MOVE16_RS_FIELD(r) (((r) & 0x1f) )
12291 static const struct opcode_descriptor move_insns_32
[] = {
12292 { /* "move", "d,s", */ 0x00000150, 0xffe007ff }, /* addu d,s,$0 */
12293 { /* "move", "d,s", */ 0x00000290, 0xffe007ff }, /* or d,s,$0 */
12294 { 0, 0 } /* End marker for find_match(). */
12297 static const struct opcode_descriptor move_insn_16
=
12298 { /* "move", "mp,mj", */ 0x0c00, 0xfc00 };
12301 /* NOP instructions. */
12303 static const struct opcode_descriptor nop_insn_32
=
12304 { /* "nop", "", */ 0x00000000, 0xffffffff };
12306 static const struct opcode_descriptor nop_insn_16
=
12307 { /* "nop", "", */ 0x0c00, 0xffff };
12310 /* Instruction match support. */
12312 #define MATCH(opcode, insn) ((opcode & insn.mask) == insn.match)
12315 find_match (unsigned long opcode
, const struct opcode_descriptor insn
[])
12317 unsigned long indx
;
12319 for (indx
= 0; insn
[indx
].mask
!= 0; indx
++)
12320 if (MATCH (opcode
, insn
[indx
]))
12327 /* Branch and delay slot decoding support. */
12329 /* If PTR points to what *might* be a 16-bit branch or jump, then
12330 return the minimum length of its delay slot, otherwise return 0.
12331 Non-zero results are not definitive as we might be checking against
12332 the second half of another instruction. */
12335 check_br16_dslot (bfd
*abfd
, bfd_byte
*ptr
)
12337 unsigned long opcode
;
12340 opcode
= bfd_get_16 (abfd
, ptr
);
12341 if (MATCH (opcode
, jalr_insn_16_bd32
) != 0)
12342 /* 16-bit branch/jump with a 32-bit delay slot. */
12344 else if (MATCH (opcode
, jalr_insn_16_bd16
) != 0
12345 || find_match (opcode
, ds_insns_16_bd16
) >= 0)
12346 /* 16-bit branch/jump with a 16-bit delay slot. */
12349 /* No delay slot. */
12355 /* If PTR points to what *might* be a 32-bit branch or jump, then
12356 return the minimum length of its delay slot, otherwise return 0.
12357 Non-zero results are not definitive as we might be checking against
12358 the second half of another instruction. */
12361 check_br32_dslot (bfd
*abfd
, bfd_byte
*ptr
)
12363 unsigned long opcode
;
12366 opcode
= bfd_get_micromips_32 (abfd
, ptr
);
12367 if (find_match (opcode
, ds_insns_32_bd32
) >= 0)
12368 /* 32-bit branch/jump with a 32-bit delay slot. */
12370 else if (find_match (opcode
, ds_insns_32_bd16
) >= 0)
12371 /* 32-bit branch/jump with a 16-bit delay slot. */
12374 /* No delay slot. */
12380 /* If PTR points to a 16-bit branch or jump with a 32-bit delay slot
12381 that doesn't fiddle with REG, then return TRUE, otherwise FALSE. */
12384 check_br16 (bfd
*abfd
, bfd_byte
*ptr
, unsigned long reg
)
12386 unsigned long opcode
;
12388 opcode
= bfd_get_16 (abfd
, ptr
);
12389 if (MATCH (opcode
, b_insn_16
)
12391 || (MATCH (opcode
, jr_insn_16
) && reg
!= JR16_REG (opcode
))
12393 || (MATCH (opcode
, bz_insn_16
) && reg
!= BZ16_REG (opcode
))
12394 /* BEQZ16, BNEZ16 */
12395 || (MATCH (opcode
, jalr_insn_16_bd32
)
12397 && reg
!= JR16_REG (opcode
) && reg
!= RA
))
12403 /* If PTR points to a 32-bit branch or jump that doesn't fiddle with REG,
12404 then return TRUE, otherwise FALSE. */
12407 check_br32 (bfd
*abfd
, bfd_byte
*ptr
, unsigned long reg
)
12409 unsigned long opcode
;
12411 opcode
= bfd_get_micromips_32 (abfd
, ptr
);
12412 if (MATCH (opcode
, j_insn_32
)
12414 || MATCH (opcode
, bc_insn_32
)
12415 /* BC1F, BC1T, BC2F, BC2T */
12416 || (MATCH (opcode
, jal_x_insn_32_bd32
) && reg
!= RA
)
12418 || (MATCH (opcode
, bz_insn_32
) && reg
!= OP32_SREG (opcode
))
12419 /* BGEZ, BGTZ, BLEZ, BLTZ */
12420 || (MATCH (opcode
, bzal_insn_32
)
12421 /* BGEZAL, BLTZAL */
12422 && reg
!= OP32_SREG (opcode
) && reg
!= RA
)
12423 || ((MATCH (opcode
, jalr_insn_32
) || MATCH (opcode
, beq_insn_32
))
12424 /* JALR, JALR.HB, BEQ, BNE */
12425 && reg
!= OP32_SREG (opcode
) && reg
!= OP32_TREG (opcode
)))
12431 /* If the instruction encoding at PTR and relocations [INTERNAL_RELOCS,
12432 IRELEND) at OFFSET indicate that there must be a compact branch there,
12433 then return TRUE, otherwise FALSE. */
12436 check_relocated_bzc (bfd
*abfd
, const bfd_byte
*ptr
, bfd_vma offset
,
12437 const Elf_Internal_Rela
*internal_relocs
,
12438 const Elf_Internal_Rela
*irelend
)
12440 const Elf_Internal_Rela
*irel
;
12441 unsigned long opcode
;
12443 opcode
= bfd_get_micromips_32 (abfd
, ptr
);
12444 if (find_match (opcode
, bzc_insns_32
) < 0)
12447 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
12448 if (irel
->r_offset
== offset
12449 && ELF32_R_TYPE (irel
->r_info
) == R_MICROMIPS_PC16_S1
)
12455 /* Bitsize checking. */
12456 #define IS_BITSIZE(val, N) \
12457 (((((val) & ((1ULL << (N)) - 1)) ^ (1ULL << ((N) - 1))) \
12458 - (1ULL << ((N) - 1))) == (val))
12462 _bfd_mips_elf_relax_section (bfd
*abfd
, asection
*sec
,
12463 struct bfd_link_info
*link_info
,
12464 bfd_boolean
*again
)
12466 Elf_Internal_Shdr
*symtab_hdr
;
12467 Elf_Internal_Rela
*internal_relocs
;
12468 Elf_Internal_Rela
*irel
, *irelend
;
12469 bfd_byte
*contents
= NULL
;
12470 Elf_Internal_Sym
*isymbuf
= NULL
;
12472 /* Assume nothing changes. */
12475 /* We don't have to do anything for a relocatable link, if
12476 this section does not have relocs, or if this is not a
12479 if (link_info
->relocatable
12480 || (sec
->flags
& SEC_RELOC
) == 0
12481 || sec
->reloc_count
== 0
12482 || (sec
->flags
& SEC_CODE
) == 0)
12485 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
12487 /* Get a copy of the native relocations. */
12488 internal_relocs
= (_bfd_elf_link_read_relocs
12489 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
12490 link_info
->keep_memory
));
12491 if (internal_relocs
== NULL
)
12494 /* Walk through them looking for relaxing opportunities. */
12495 irelend
= internal_relocs
+ sec
->reloc_count
;
12496 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
12498 unsigned long r_symndx
= ELF32_R_SYM (irel
->r_info
);
12499 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
12500 bfd_boolean target_is_micromips_code_p
;
12501 unsigned long opcode
;
12507 /* The number of bytes to delete for relaxation and from where
12508 to delete these bytes starting at irel->r_offset. */
12512 /* If this isn't something that can be relaxed, then ignore
12514 if (r_type
!= R_MICROMIPS_HI16
12515 && r_type
!= R_MICROMIPS_PC16_S1
12516 && r_type
!= R_MICROMIPS_26_S1
)
12519 /* Get the section contents if we haven't done so already. */
12520 if (contents
== NULL
)
12522 /* Get cached copy if it exists. */
12523 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
12524 contents
= elf_section_data (sec
)->this_hdr
.contents
;
12525 /* Go get them off disk. */
12526 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
12529 ptr
= contents
+ irel
->r_offset
;
12531 /* Read this BFD's local symbols if we haven't done so already. */
12532 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
12534 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
12535 if (isymbuf
== NULL
)
12536 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
12537 symtab_hdr
->sh_info
, 0,
12539 if (isymbuf
== NULL
)
12543 /* Get the value of the symbol referred to by the reloc. */
12544 if (r_symndx
< symtab_hdr
->sh_info
)
12546 /* A local symbol. */
12547 Elf_Internal_Sym
*isym
;
12550 isym
= isymbuf
+ r_symndx
;
12551 if (isym
->st_shndx
== SHN_UNDEF
)
12552 sym_sec
= bfd_und_section_ptr
;
12553 else if (isym
->st_shndx
== SHN_ABS
)
12554 sym_sec
= bfd_abs_section_ptr
;
12555 else if (isym
->st_shndx
== SHN_COMMON
)
12556 sym_sec
= bfd_com_section_ptr
;
12558 sym_sec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
12559 symval
= (isym
->st_value
12560 + sym_sec
->output_section
->vma
12561 + sym_sec
->output_offset
);
12562 target_is_micromips_code_p
= ELF_ST_IS_MICROMIPS (isym
->st_other
);
12566 unsigned long indx
;
12567 struct elf_link_hash_entry
*h
;
12569 /* An external symbol. */
12570 indx
= r_symndx
- symtab_hdr
->sh_info
;
12571 h
= elf_sym_hashes (abfd
)[indx
];
12572 BFD_ASSERT (h
!= NULL
);
12574 if (h
->root
.type
!= bfd_link_hash_defined
12575 && h
->root
.type
!= bfd_link_hash_defweak
)
12576 /* This appears to be a reference to an undefined
12577 symbol. Just ignore it -- it will be caught by the
12578 regular reloc processing. */
12581 symval
= (h
->root
.u
.def
.value
12582 + h
->root
.u
.def
.section
->output_section
->vma
12583 + h
->root
.u
.def
.section
->output_offset
);
12584 target_is_micromips_code_p
= (!h
->needs_plt
12585 && ELF_ST_IS_MICROMIPS (h
->other
));
12589 /* For simplicity of coding, we are going to modify the
12590 section contents, the section relocs, and the BFD symbol
12591 table. We must tell the rest of the code not to free up this
12592 information. It would be possible to instead create a table
12593 of changes which have to be made, as is done in coff-mips.c;
12594 that would be more work, but would require less memory when
12595 the linker is run. */
12597 /* Only 32-bit instructions relaxed. */
12598 if (irel
->r_offset
+ 4 > sec
->size
)
12601 opcode
= bfd_get_micromips_32 (abfd
, ptr
);
12603 /* This is the pc-relative distance from the instruction the
12604 relocation is applied to, to the symbol referred. */
12606 - (sec
->output_section
->vma
+ sec
->output_offset
)
12609 /* R_MICROMIPS_HI16 / LUI relaxation to nil, performing relaxation
12610 of corresponding R_MICROMIPS_LO16 to R_MICROMIPS_HI0_LO16 or
12611 R_MICROMIPS_PC23_S2. The R_MICROMIPS_PC23_S2 condition is
12613 (symval % 4 == 0 && IS_BITSIZE (pcrval, 25))
12615 where pcrval has first to be adjusted to apply against the LO16
12616 location (we make the adjustment later on, when we have figured
12617 out the offset). */
12618 if (r_type
== R_MICROMIPS_HI16
&& MATCH (opcode
, lui_insn
))
12620 bfd_boolean bzc
= FALSE
;
12621 unsigned long nextopc
;
12625 /* Give up if the previous reloc was a HI16 against this symbol
12627 if (irel
> internal_relocs
12628 && ELF32_R_TYPE (irel
[-1].r_info
) == R_MICROMIPS_HI16
12629 && ELF32_R_SYM (irel
[-1].r_info
) == r_symndx
)
12632 /* Or if the next reloc is not a LO16 against this symbol. */
12633 if (irel
+ 1 >= irelend
12634 || ELF32_R_TYPE (irel
[1].r_info
) != R_MICROMIPS_LO16
12635 || ELF32_R_SYM (irel
[1].r_info
) != r_symndx
)
12638 /* Or if the second next reloc is a LO16 against this symbol too. */
12639 if (irel
+ 2 >= irelend
12640 && ELF32_R_TYPE (irel
[2].r_info
) == R_MICROMIPS_LO16
12641 && ELF32_R_SYM (irel
[2].r_info
) == r_symndx
)
12644 /* See if the LUI instruction *might* be in a branch delay slot.
12645 We check whether what looks like a 16-bit branch or jump is
12646 actually an immediate argument to a compact branch, and let
12647 it through if so. */
12648 if (irel
->r_offset
>= 2
12649 && check_br16_dslot (abfd
, ptr
- 2)
12650 && !(irel
->r_offset
>= 4
12651 && (bzc
= check_relocated_bzc (abfd
,
12652 ptr
- 4, irel
->r_offset
- 4,
12653 internal_relocs
, irelend
))))
12655 if (irel
->r_offset
>= 4
12657 && check_br32_dslot (abfd
, ptr
- 4))
12660 reg
= OP32_SREG (opcode
);
12662 /* We only relax adjacent instructions or ones separated with
12663 a branch or jump that has a delay slot. The branch or jump
12664 must not fiddle with the register used to hold the address.
12665 Subtract 4 for the LUI itself. */
12666 offset
= irel
[1].r_offset
- irel
[0].r_offset
;
12667 switch (offset
- 4)
12672 if (check_br16 (abfd
, ptr
+ 4, reg
))
12676 if (check_br32 (abfd
, ptr
+ 4, reg
))
12683 nextopc
= bfd_get_micromips_32 (abfd
, contents
+ irel
[1].r_offset
);
12685 /* Give up unless the same register is used with both
12687 if (OP32_SREG (nextopc
) != reg
)
12690 /* Now adjust pcrval, subtracting the offset to the LO16 reloc
12691 and rounding up to take masking of the two LSBs into account. */
12692 pcrval
= ((pcrval
- offset
+ 3) | 3) ^ 3;
12694 /* R_MICROMIPS_LO16 relaxation to R_MICROMIPS_HI0_LO16. */
12695 if (IS_BITSIZE (symval
, 16))
12697 /* Fix the relocation's type. */
12698 irel
[1].r_info
= ELF32_R_INFO (r_symndx
, R_MICROMIPS_HI0_LO16
);
12700 /* Instructions using R_MICROMIPS_LO16 have the base or
12701 source register in bits 20:16. This register becomes $0
12702 (zero) as the result of the R_MICROMIPS_HI16 being 0. */
12703 nextopc
&= ~0x001f0000;
12704 bfd_put_16 (abfd
, (nextopc
>> 16) & 0xffff,
12705 contents
+ irel
[1].r_offset
);
12708 /* R_MICROMIPS_LO16 / ADDIU relaxation to R_MICROMIPS_PC23_S2.
12709 We add 4 to take LUI deletion into account while checking
12710 the PC-relative distance. */
12711 else if (symval
% 4 == 0
12712 && IS_BITSIZE (pcrval
+ 4, 25)
12713 && MATCH (nextopc
, addiu_insn
)
12714 && OP32_TREG (nextopc
) == OP32_SREG (nextopc
)
12715 && OP16_VALID_REG (OP32_TREG (nextopc
)))
12717 /* Fix the relocation's type. */
12718 irel
[1].r_info
= ELF32_R_INFO (r_symndx
, R_MICROMIPS_PC23_S2
);
12720 /* Replace ADDIU with the ADDIUPC version. */
12721 nextopc
= (addiupc_insn
.match
12722 | ADDIUPC_REG_FIELD (OP32_TREG (nextopc
)));
12724 bfd_put_micromips_32 (abfd
, nextopc
,
12725 contents
+ irel
[1].r_offset
);
12728 /* Can't do anything, give up, sigh... */
12732 /* Fix the relocation's type. */
12733 irel
->r_info
= ELF32_R_INFO (r_symndx
, R_MIPS_NONE
);
12735 /* Delete the LUI instruction: 4 bytes at irel->r_offset. */
12740 /* Compact branch relaxation -- due to the multitude of macros
12741 employed by the compiler/assembler, compact branches are not
12742 always generated. Obviously, this can/will be fixed elsewhere,
12743 but there is no drawback in double checking it here. */
12744 else if (r_type
== R_MICROMIPS_PC16_S1
12745 && irel
->r_offset
+ 5 < sec
->size
12746 && ((fndopc
= find_match (opcode
, bz_rs_insns_32
)) >= 0
12747 || (fndopc
= find_match (opcode
, bz_rt_insns_32
)) >= 0)
12748 && MATCH (bfd_get_16 (abfd
, ptr
+ 4), nop_insn_16
))
12752 reg
= OP32_SREG (opcode
) ? OP32_SREG (opcode
) : OP32_TREG (opcode
);
12754 /* Replace BEQZ/BNEZ with the compact version. */
12755 opcode
= (bzc_insns_32
[fndopc
].match
12756 | BZC32_REG_FIELD (reg
)
12757 | (opcode
& 0xffff)); /* Addend value. */
12759 bfd_put_micromips_32 (abfd
, opcode
, ptr
);
12761 /* Delete the 16-bit delay slot NOP: two bytes from
12762 irel->offset + 4. */
12767 /* R_MICROMIPS_PC16_S1 relaxation to R_MICROMIPS_PC10_S1. We need
12768 to check the distance from the next instruction, so subtract 2. */
12769 else if (r_type
== R_MICROMIPS_PC16_S1
12770 && IS_BITSIZE (pcrval
- 2, 11)
12771 && find_match (opcode
, b_insns_32
) >= 0)
12773 /* Fix the relocation's type. */
12774 irel
->r_info
= ELF32_R_INFO (r_symndx
, R_MICROMIPS_PC10_S1
);
12776 /* Replace the 32-bit opcode with a 16-bit opcode. */
12779 | (opcode
& 0x3ff)), /* Addend value. */
12782 /* Delete 2 bytes from irel->r_offset + 2. */
12787 /* R_MICROMIPS_PC16_S1 relaxation to R_MICROMIPS_PC7_S1. We need
12788 to check the distance from the next instruction, so subtract 2. */
12789 else if (r_type
== R_MICROMIPS_PC16_S1
12790 && IS_BITSIZE (pcrval
- 2, 8)
12791 && (((fndopc
= find_match (opcode
, bz_rs_insns_32
)) >= 0
12792 && OP16_VALID_REG (OP32_SREG (opcode
)))
12793 || ((fndopc
= find_match (opcode
, bz_rt_insns_32
)) >= 0
12794 && OP16_VALID_REG (OP32_TREG (opcode
)))))
12798 reg
= OP32_SREG (opcode
) ? OP32_SREG (opcode
) : OP32_TREG (opcode
);
12800 /* Fix the relocation's type. */
12801 irel
->r_info
= ELF32_R_INFO (r_symndx
, R_MICROMIPS_PC7_S1
);
12803 /* Replace the 32-bit opcode with a 16-bit opcode. */
12805 (bz_insns_16
[fndopc
].match
12806 | BZ16_REG_FIELD (reg
)
12807 | (opcode
& 0x7f)), /* Addend value. */
12810 /* Delete 2 bytes from irel->r_offset + 2. */
12815 /* R_MICROMIPS_26_S1 -- JAL to JALS relaxation for microMIPS targets. */
12816 else if (r_type
== R_MICROMIPS_26_S1
12817 && target_is_micromips_code_p
12818 && irel
->r_offset
+ 7 < sec
->size
12819 && MATCH (opcode
, jal_insn_32_bd32
))
12821 unsigned long n32opc
;
12822 bfd_boolean relaxed
= FALSE
;
12824 n32opc
= bfd_get_micromips_32 (abfd
, ptr
+ 4);
12826 if (MATCH (n32opc
, nop_insn_32
))
12828 /* Replace delay slot 32-bit NOP with a 16-bit NOP. */
12829 bfd_put_16 (abfd
, nop_insn_16
.match
, ptr
+ 4);
12833 else if (find_match (n32opc
, move_insns_32
) >= 0)
12835 /* Replace delay slot 32-bit MOVE with 16-bit MOVE. */
12837 (move_insn_16
.match
12838 | MOVE16_RD_FIELD (MOVE32_RD (n32opc
))
12839 | MOVE16_RS_FIELD (MOVE32_RS (n32opc
))),
12844 /* Other 32-bit instructions relaxable to 16-bit
12845 instructions will be handled here later. */
12849 /* JAL with 32-bit delay slot that is changed to a JALS
12850 with 16-bit delay slot. */
12851 bfd_put_micromips_32 (abfd
, jal_insn_32_bd16
.match
, ptr
);
12853 /* Delete 2 bytes from irel->r_offset + 6. */
12861 /* Note that we've changed the relocs, section contents, etc. */
12862 elf_section_data (sec
)->relocs
= internal_relocs
;
12863 elf_section_data (sec
)->this_hdr
.contents
= contents
;
12864 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
12866 /* Delete bytes depending on the delcnt and deloff. */
12867 if (!mips_elf_relax_delete_bytes (abfd
, sec
,
12868 irel
->r_offset
+ deloff
, delcnt
))
12871 /* That will change things, so we should relax again.
12872 Note that this is not required, and it may be slow. */
12877 if (isymbuf
!= NULL
12878 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
12880 if (! link_info
->keep_memory
)
12884 /* Cache the symbols for elf_link_input_bfd. */
12885 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
12889 if (contents
!= NULL
12890 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
12892 if (! link_info
->keep_memory
)
12896 /* Cache the section contents for elf_link_input_bfd. */
12897 elf_section_data (sec
)->this_hdr
.contents
= contents
;
12901 if (internal_relocs
!= NULL
12902 && elf_section_data (sec
)->relocs
!= internal_relocs
)
12903 free (internal_relocs
);
12908 if (isymbuf
!= NULL
12909 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
12911 if (contents
!= NULL
12912 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
12914 if (internal_relocs
!= NULL
12915 && elf_section_data (sec
)->relocs
!= internal_relocs
)
12916 free (internal_relocs
);
12921 /* Create a MIPS ELF linker hash table. */
12923 struct bfd_link_hash_table
*
12924 _bfd_mips_elf_link_hash_table_create (bfd
*abfd
)
12926 struct mips_elf_link_hash_table
*ret
;
12927 bfd_size_type amt
= sizeof (struct mips_elf_link_hash_table
);
12929 ret
= bfd_zmalloc (amt
);
12933 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
12934 mips_elf_link_hash_newfunc
,
12935 sizeof (struct mips_elf_link_hash_entry
),
12942 return &ret
->root
.root
;
12945 /* Likewise, but indicate that the target is VxWorks. */
12947 struct bfd_link_hash_table
*
12948 _bfd_mips_vxworks_link_hash_table_create (bfd
*abfd
)
12950 struct bfd_link_hash_table
*ret
;
12952 ret
= _bfd_mips_elf_link_hash_table_create (abfd
);
12955 struct mips_elf_link_hash_table
*htab
;
12957 htab
= (struct mips_elf_link_hash_table
*) ret
;
12958 htab
->use_plts_and_copy_relocs
= TRUE
;
12959 htab
->is_vxworks
= TRUE
;
12964 /* A function that the linker calls if we are allowed to use PLTs
12965 and copy relocs. */
12968 _bfd_mips_elf_use_plts_and_copy_relocs (struct bfd_link_info
*info
)
12970 mips_elf_hash_table (info
)->use_plts_and_copy_relocs
= TRUE
;
12973 /* We need to use a special link routine to handle the .reginfo and
12974 the .mdebug sections. We need to merge all instances of these
12975 sections together, not write them all out sequentially. */
12978 _bfd_mips_elf_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
12981 struct bfd_link_order
*p
;
12982 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
12983 asection
*rtproc_sec
;
12984 Elf32_RegInfo reginfo
;
12985 struct ecoff_debug_info debug
;
12986 struct mips_htab_traverse_info hti
;
12987 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12988 const struct ecoff_debug_swap
*swap
= bed
->elf_backend_ecoff_debug_swap
;
12989 HDRR
*symhdr
= &debug
.symbolic_header
;
12990 void *mdebug_handle
= NULL
;
12995 struct mips_elf_link_hash_table
*htab
;
12997 static const char * const secname
[] =
12999 ".text", ".init", ".fini", ".data",
13000 ".rodata", ".sdata", ".sbss", ".bss"
13002 static const int sc
[] =
13004 scText
, scInit
, scFini
, scData
,
13005 scRData
, scSData
, scSBss
, scBss
13008 /* Sort the dynamic symbols so that those with GOT entries come after
13010 htab
= mips_elf_hash_table (info
);
13011 BFD_ASSERT (htab
!= NULL
);
13013 if (!mips_elf_sort_hash_table (abfd
, info
))
13016 /* Create any scheduled LA25 stubs. */
13018 hti
.output_bfd
= abfd
;
13020 htab_traverse (htab
->la25_stubs
, mips_elf_create_la25_stub
, &hti
);
13024 /* Get a value for the GP register. */
13025 if (elf_gp (abfd
) == 0)
13027 struct bfd_link_hash_entry
*h
;
13029 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
13030 if (h
!= NULL
&& h
->type
== bfd_link_hash_defined
)
13031 elf_gp (abfd
) = (h
->u
.def
.value
13032 + h
->u
.def
.section
->output_section
->vma
13033 + h
->u
.def
.section
->output_offset
);
13034 else if (htab
->is_vxworks
13035 && (h
= bfd_link_hash_lookup (info
->hash
,
13036 "_GLOBAL_OFFSET_TABLE_",
13037 FALSE
, FALSE
, TRUE
))
13038 && h
->type
== bfd_link_hash_defined
)
13039 elf_gp (abfd
) = (h
->u
.def
.section
->output_section
->vma
13040 + h
->u
.def
.section
->output_offset
13042 else if (info
->relocatable
)
13044 bfd_vma lo
= MINUS_ONE
;
13046 /* Find the GP-relative section with the lowest offset. */
13047 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
13049 && (elf_section_data (o
)->this_hdr
.sh_flags
& SHF_MIPS_GPREL
))
13052 /* And calculate GP relative to that. */
13053 elf_gp (abfd
) = lo
+ ELF_MIPS_GP_OFFSET (info
);
13057 /* If the relocate_section function needs to do a reloc
13058 involving the GP value, it should make a reloc_dangerous
13059 callback to warn that GP is not defined. */
13063 /* Go through the sections and collect the .reginfo and .mdebug
13065 reginfo_sec
= NULL
;
13067 gptab_data_sec
= NULL
;
13068 gptab_bss_sec
= NULL
;
13069 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
13071 if (strcmp (o
->name
, ".reginfo") == 0)
13073 memset (®info
, 0, sizeof reginfo
);
13075 /* We have found the .reginfo section in the output file.
13076 Look through all the link_orders comprising it and merge
13077 the information together. */
13078 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
13080 asection
*input_section
;
13082 Elf32_External_RegInfo ext
;
13085 if (p
->type
!= bfd_indirect_link_order
)
13087 if (p
->type
== bfd_data_link_order
)
13092 input_section
= p
->u
.indirect
.section
;
13093 input_bfd
= input_section
->owner
;
13095 if (! bfd_get_section_contents (input_bfd
, input_section
,
13096 &ext
, 0, sizeof ext
))
13099 bfd_mips_elf32_swap_reginfo_in (input_bfd
, &ext
, &sub
);
13101 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
13102 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
13103 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
13104 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
13105 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
13107 /* ri_gp_value is set by the function
13108 mips_elf32_section_processing when the section is
13109 finally written out. */
13111 /* Hack: reset the SEC_HAS_CONTENTS flag so that
13112 elf_link_input_bfd ignores this section. */
13113 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
13116 /* Size has been set in _bfd_mips_elf_always_size_sections. */
13117 BFD_ASSERT(o
->size
== sizeof (Elf32_External_RegInfo
));
13119 /* Skip this section later on (I don't think this currently
13120 matters, but someday it might). */
13121 o
->map_head
.link_order
= NULL
;
13126 if (strcmp (o
->name
, ".mdebug") == 0)
13128 struct extsym_info einfo
;
13131 /* We have found the .mdebug section in the output file.
13132 Look through all the link_orders comprising it and merge
13133 the information together. */
13134 symhdr
->magic
= swap
->sym_magic
;
13135 /* FIXME: What should the version stamp be? */
13136 symhdr
->vstamp
= 0;
13137 symhdr
->ilineMax
= 0;
13138 symhdr
->cbLine
= 0;
13139 symhdr
->idnMax
= 0;
13140 symhdr
->ipdMax
= 0;
13141 symhdr
->isymMax
= 0;
13142 symhdr
->ioptMax
= 0;
13143 symhdr
->iauxMax
= 0;
13144 symhdr
->issMax
= 0;
13145 symhdr
->issExtMax
= 0;
13146 symhdr
->ifdMax
= 0;
13148 symhdr
->iextMax
= 0;
13150 /* We accumulate the debugging information itself in the
13151 debug_info structure. */
13153 debug
.external_dnr
= NULL
;
13154 debug
.external_pdr
= NULL
;
13155 debug
.external_sym
= NULL
;
13156 debug
.external_opt
= NULL
;
13157 debug
.external_aux
= NULL
;
13159 debug
.ssext
= debug
.ssext_end
= NULL
;
13160 debug
.external_fdr
= NULL
;
13161 debug
.external_rfd
= NULL
;
13162 debug
.external_ext
= debug
.external_ext_end
= NULL
;
13164 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
13165 if (mdebug_handle
== NULL
)
13169 esym
.cobol_main
= 0;
13173 esym
.asym
.iss
= issNil
;
13174 esym
.asym
.st
= stLocal
;
13175 esym
.asym
.reserved
= 0;
13176 esym
.asym
.index
= indexNil
;
13178 for (i
= 0; i
< sizeof (secname
) / sizeof (secname
[0]); i
++)
13180 esym
.asym
.sc
= sc
[i
];
13181 s
= bfd_get_section_by_name (abfd
, secname
[i
]);
13184 esym
.asym
.value
= s
->vma
;
13185 last
= s
->vma
+ s
->size
;
13188 esym
.asym
.value
= last
;
13189 if (!bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
13190 secname
[i
], &esym
))
13194 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
13196 asection
*input_section
;
13198 const struct ecoff_debug_swap
*input_swap
;
13199 struct ecoff_debug_info input_debug
;
13203 if (p
->type
!= bfd_indirect_link_order
)
13205 if (p
->type
== bfd_data_link_order
)
13210 input_section
= p
->u
.indirect
.section
;
13211 input_bfd
= input_section
->owner
;
13213 if (!is_mips_elf (input_bfd
))
13215 /* I don't know what a non MIPS ELF bfd would be
13216 doing with a .mdebug section, but I don't really
13217 want to deal with it. */
13221 input_swap
= (get_elf_backend_data (input_bfd
)
13222 ->elf_backend_ecoff_debug_swap
);
13224 BFD_ASSERT (p
->size
== input_section
->size
);
13226 /* The ECOFF linking code expects that we have already
13227 read in the debugging information and set up an
13228 ecoff_debug_info structure, so we do that now. */
13229 if (! _bfd_mips_elf_read_ecoff_info (input_bfd
, input_section
,
13233 if (! (bfd_ecoff_debug_accumulate
13234 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
13235 &input_debug
, input_swap
, info
)))
13238 /* Loop through the external symbols. For each one with
13239 interesting information, try to find the symbol in
13240 the linker global hash table and save the information
13241 for the output external symbols. */
13242 eraw_src
= input_debug
.external_ext
;
13243 eraw_end
= (eraw_src
13244 + (input_debug
.symbolic_header
.iextMax
13245 * input_swap
->external_ext_size
));
13247 eraw_src
< eraw_end
;
13248 eraw_src
+= input_swap
->external_ext_size
)
13252 struct mips_elf_link_hash_entry
*h
;
13254 (*input_swap
->swap_ext_in
) (input_bfd
, eraw_src
, &ext
);
13255 if (ext
.asym
.sc
== scNil
13256 || ext
.asym
.sc
== scUndefined
13257 || ext
.asym
.sc
== scSUndefined
)
13260 name
= input_debug
.ssext
+ ext
.asym
.iss
;
13261 h
= mips_elf_link_hash_lookup (mips_elf_hash_table (info
),
13262 name
, FALSE
, FALSE
, TRUE
);
13263 if (h
== NULL
|| h
->esym
.ifd
!= -2)
13268 BFD_ASSERT (ext
.ifd
13269 < input_debug
.symbolic_header
.ifdMax
);
13270 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
13276 /* Free up the information we just read. */
13277 free (input_debug
.line
);
13278 free (input_debug
.external_dnr
);
13279 free (input_debug
.external_pdr
);
13280 free (input_debug
.external_sym
);
13281 free (input_debug
.external_opt
);
13282 free (input_debug
.external_aux
);
13283 free (input_debug
.ss
);
13284 free (input_debug
.ssext
);
13285 free (input_debug
.external_fdr
);
13286 free (input_debug
.external_rfd
);
13287 free (input_debug
.external_ext
);
13289 /* Hack: reset the SEC_HAS_CONTENTS flag so that
13290 elf_link_input_bfd ignores this section. */
13291 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
13294 if (SGI_COMPAT (abfd
) && info
->shared
)
13296 /* Create .rtproc section. */
13297 rtproc_sec
= bfd_get_linker_section (abfd
, ".rtproc");
13298 if (rtproc_sec
== NULL
)
13300 flagword flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
13301 | SEC_LINKER_CREATED
| SEC_READONLY
);
13303 rtproc_sec
= bfd_make_section_anyway_with_flags (abfd
,
13306 if (rtproc_sec
== NULL
13307 || ! bfd_set_section_alignment (abfd
, rtproc_sec
, 4))
13311 if (! mips_elf_create_procedure_table (mdebug_handle
, abfd
,
13317 /* Build the external symbol information. */
13320 einfo
.debug
= &debug
;
13322 einfo
.failed
= FALSE
;
13323 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
13324 mips_elf_output_extsym
, &einfo
);
13328 /* Set the size of the .mdebug section. */
13329 o
->size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
13331 /* Skip this section later on (I don't think this currently
13332 matters, but someday it might). */
13333 o
->map_head
.link_order
= NULL
;
13338 if (CONST_STRNEQ (o
->name
, ".gptab."))
13340 const char *subname
;
13343 Elf32_External_gptab
*ext_tab
;
13346 /* The .gptab.sdata and .gptab.sbss sections hold
13347 information describing how the small data area would
13348 change depending upon the -G switch. These sections
13349 not used in executables files. */
13350 if (! info
->relocatable
)
13352 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
13354 asection
*input_section
;
13356 if (p
->type
!= bfd_indirect_link_order
)
13358 if (p
->type
== bfd_data_link_order
)
13363 input_section
= p
->u
.indirect
.section
;
13365 /* Hack: reset the SEC_HAS_CONTENTS flag so that
13366 elf_link_input_bfd ignores this section. */
13367 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
13370 /* Skip this section later on (I don't think this
13371 currently matters, but someday it might). */
13372 o
->map_head
.link_order
= NULL
;
13374 /* Really remove the section. */
13375 bfd_section_list_remove (abfd
, o
);
13376 --abfd
->section_count
;
13381 /* There is one gptab for initialized data, and one for
13382 uninitialized data. */
13383 if (strcmp (o
->name
, ".gptab.sdata") == 0)
13384 gptab_data_sec
= o
;
13385 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
13389 (*_bfd_error_handler
)
13390 (_("%s: illegal section name `%s'"),
13391 bfd_get_filename (abfd
), o
->name
);
13392 bfd_set_error (bfd_error_nonrepresentable_section
);
13396 /* The linker script always combines .gptab.data and
13397 .gptab.sdata into .gptab.sdata, and likewise for
13398 .gptab.bss and .gptab.sbss. It is possible that there is
13399 no .sdata or .sbss section in the output file, in which
13400 case we must change the name of the output section. */
13401 subname
= o
->name
+ sizeof ".gptab" - 1;
13402 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
13404 if (o
== gptab_data_sec
)
13405 o
->name
= ".gptab.data";
13407 o
->name
= ".gptab.bss";
13408 subname
= o
->name
+ sizeof ".gptab" - 1;
13409 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
13412 /* Set up the first entry. */
13414 amt
= c
* sizeof (Elf32_gptab
);
13415 tab
= bfd_malloc (amt
);
13418 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
13419 tab
[0].gt_header
.gt_unused
= 0;
13421 /* Combine the input sections. */
13422 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
13424 asection
*input_section
;
13426 bfd_size_type size
;
13427 unsigned long last
;
13428 bfd_size_type gpentry
;
13430 if (p
->type
!= bfd_indirect_link_order
)
13432 if (p
->type
== bfd_data_link_order
)
13437 input_section
= p
->u
.indirect
.section
;
13438 input_bfd
= input_section
->owner
;
13440 /* Combine the gptab entries for this input section one
13441 by one. We know that the input gptab entries are
13442 sorted by ascending -G value. */
13443 size
= input_section
->size
;
13445 for (gpentry
= sizeof (Elf32_External_gptab
);
13447 gpentry
+= sizeof (Elf32_External_gptab
))
13449 Elf32_External_gptab ext_gptab
;
13450 Elf32_gptab int_gptab
;
13456 if (! (bfd_get_section_contents
13457 (input_bfd
, input_section
, &ext_gptab
, gpentry
,
13458 sizeof (Elf32_External_gptab
))))
13464 bfd_mips_elf32_swap_gptab_in (input_bfd
, &ext_gptab
,
13466 val
= int_gptab
.gt_entry
.gt_g_value
;
13467 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
13470 for (look
= 1; look
< c
; look
++)
13472 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
13473 tab
[look
].gt_entry
.gt_bytes
+= add
;
13475 if (tab
[look
].gt_entry
.gt_g_value
== val
)
13481 Elf32_gptab
*new_tab
;
13484 /* We need a new table entry. */
13485 amt
= (bfd_size_type
) (c
+ 1) * sizeof (Elf32_gptab
);
13486 new_tab
= bfd_realloc (tab
, amt
);
13487 if (new_tab
== NULL
)
13493 tab
[c
].gt_entry
.gt_g_value
= val
;
13494 tab
[c
].gt_entry
.gt_bytes
= add
;
13496 /* Merge in the size for the next smallest -G
13497 value, since that will be implied by this new
13500 for (look
= 1; look
< c
; look
++)
13502 if (tab
[look
].gt_entry
.gt_g_value
< val
13504 || (tab
[look
].gt_entry
.gt_g_value
13505 > tab
[max
].gt_entry
.gt_g_value
)))
13509 tab
[c
].gt_entry
.gt_bytes
+=
13510 tab
[max
].gt_entry
.gt_bytes
;
13515 last
= int_gptab
.gt_entry
.gt_bytes
;
13518 /* Hack: reset the SEC_HAS_CONTENTS flag so that
13519 elf_link_input_bfd ignores this section. */
13520 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
13523 /* The table must be sorted by -G value. */
13525 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
13527 /* Swap out the table. */
13528 amt
= (bfd_size_type
) c
* sizeof (Elf32_External_gptab
);
13529 ext_tab
= bfd_alloc (abfd
, amt
);
13530 if (ext_tab
== NULL
)
13536 for (j
= 0; j
< c
; j
++)
13537 bfd_mips_elf32_swap_gptab_out (abfd
, tab
+ j
, ext_tab
+ j
);
13540 o
->size
= c
* sizeof (Elf32_External_gptab
);
13541 o
->contents
= (bfd_byte
*) ext_tab
;
13543 /* Skip this section later on (I don't think this currently
13544 matters, but someday it might). */
13545 o
->map_head
.link_order
= NULL
;
13549 /* Invoke the regular ELF backend linker to do all the work. */
13550 if (!bfd_elf_final_link (abfd
, info
))
13553 /* Now write out the computed sections. */
13555 if (reginfo_sec
!= NULL
)
13557 Elf32_External_RegInfo ext
;
13559 bfd_mips_elf32_swap_reginfo_out (abfd
, ®info
, &ext
);
13560 if (! bfd_set_section_contents (abfd
, reginfo_sec
, &ext
, 0, sizeof ext
))
13564 if (mdebug_sec
!= NULL
)
13566 BFD_ASSERT (abfd
->output_has_begun
);
13567 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
13569 mdebug_sec
->filepos
))
13572 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
13575 if (gptab_data_sec
!= NULL
)
13577 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
13578 gptab_data_sec
->contents
,
13579 0, gptab_data_sec
->size
))
13583 if (gptab_bss_sec
!= NULL
)
13585 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
13586 gptab_bss_sec
->contents
,
13587 0, gptab_bss_sec
->size
))
13591 if (SGI_COMPAT (abfd
))
13593 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
13594 if (rtproc_sec
!= NULL
)
13596 if (! bfd_set_section_contents (abfd
, rtproc_sec
,
13597 rtproc_sec
->contents
,
13598 0, rtproc_sec
->size
))
13606 /* Structure for saying that BFD machine EXTENSION extends BASE. */
13608 struct mips_mach_extension
{
13609 unsigned long extension
, base
;
13613 /* An array describing how BFD machines relate to one another. The entries
13614 are ordered topologically with MIPS I extensions listed last. */
13616 static const struct mips_mach_extension mips_mach_extensions
[] = {
13617 /* MIPS64r2 extensions. */
13618 { bfd_mach_mips_octeon2
, bfd_mach_mips_octeonp
},
13619 { bfd_mach_mips_octeonp
, bfd_mach_mips_octeon
},
13620 { bfd_mach_mips_octeon
, bfd_mach_mipsisa64r2
},
13622 /* MIPS64 extensions. */
13623 { bfd_mach_mipsisa64r2
, bfd_mach_mipsisa64
},
13624 { bfd_mach_mips_sb1
, bfd_mach_mipsisa64
},
13625 { bfd_mach_mips_xlr
, bfd_mach_mipsisa64
},
13626 { bfd_mach_mips_loongson_3a
, bfd_mach_mipsisa64
},
13628 /* MIPS V extensions. */
13629 { bfd_mach_mipsisa64
, bfd_mach_mips5
},
13631 /* R10000 extensions. */
13632 { bfd_mach_mips12000
, bfd_mach_mips10000
},
13633 { bfd_mach_mips14000
, bfd_mach_mips10000
},
13634 { bfd_mach_mips16000
, bfd_mach_mips10000
},
13636 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
13637 vr5400 ISA, but doesn't include the multimedia stuff. It seems
13638 better to allow vr5400 and vr5500 code to be merged anyway, since
13639 many libraries will just use the core ISA. Perhaps we could add
13640 some sort of ASE flag if this ever proves a problem. */
13641 { bfd_mach_mips5500
, bfd_mach_mips5400
},
13642 { bfd_mach_mips5400
, bfd_mach_mips5000
},
13644 /* MIPS IV extensions. */
13645 { bfd_mach_mips5
, bfd_mach_mips8000
},
13646 { bfd_mach_mips10000
, bfd_mach_mips8000
},
13647 { bfd_mach_mips5000
, bfd_mach_mips8000
},
13648 { bfd_mach_mips7000
, bfd_mach_mips8000
},
13649 { bfd_mach_mips9000
, bfd_mach_mips8000
},
13651 /* VR4100 extensions. */
13652 { bfd_mach_mips4120
, bfd_mach_mips4100
},
13653 { bfd_mach_mips4111
, bfd_mach_mips4100
},
13655 /* MIPS III extensions. */
13656 { bfd_mach_mips_loongson_2e
, bfd_mach_mips4000
},
13657 { bfd_mach_mips_loongson_2f
, bfd_mach_mips4000
},
13658 { bfd_mach_mips8000
, bfd_mach_mips4000
},
13659 { bfd_mach_mips4650
, bfd_mach_mips4000
},
13660 { bfd_mach_mips4600
, bfd_mach_mips4000
},
13661 { bfd_mach_mips4400
, bfd_mach_mips4000
},
13662 { bfd_mach_mips4300
, bfd_mach_mips4000
},
13663 { bfd_mach_mips4100
, bfd_mach_mips4000
},
13664 { bfd_mach_mips4010
, bfd_mach_mips4000
},
13665 { bfd_mach_mips5900
, bfd_mach_mips4000
},
13667 /* MIPS32 extensions. */
13668 { bfd_mach_mipsisa32r2
, bfd_mach_mipsisa32
},
13670 /* MIPS II extensions. */
13671 { bfd_mach_mips4000
, bfd_mach_mips6000
},
13672 { bfd_mach_mipsisa32
, bfd_mach_mips6000
},
13674 /* MIPS I extensions. */
13675 { bfd_mach_mips6000
, bfd_mach_mips3000
},
13676 { bfd_mach_mips3900
, bfd_mach_mips3000
}
13680 /* Return true if bfd machine EXTENSION is an extension of machine BASE. */
13683 mips_mach_extends_p (unsigned long base
, unsigned long extension
)
13687 if (extension
== base
)
13690 if (base
== bfd_mach_mipsisa32
13691 && mips_mach_extends_p (bfd_mach_mipsisa64
, extension
))
13694 if (base
== bfd_mach_mipsisa32r2
13695 && mips_mach_extends_p (bfd_mach_mipsisa64r2
, extension
))
13698 for (i
= 0; i
< ARRAY_SIZE (mips_mach_extensions
); i
++)
13699 if (extension
== mips_mach_extensions
[i
].extension
)
13701 extension
= mips_mach_extensions
[i
].base
;
13702 if (extension
== base
)
13710 /* Return true if the given ELF header flags describe a 32-bit binary. */
13713 mips_32bit_flags_p (flagword flags
)
13715 return ((flags
& EF_MIPS_32BITMODE
) != 0
13716 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
13717 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
13718 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
13719 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
13720 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
13721 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
);
13725 /* Merge object attributes from IBFD into OBFD. Raise an error if
13726 there are conflicting attributes. */
13728 mips_elf_merge_obj_attributes (bfd
*ibfd
, bfd
*obfd
)
13730 obj_attribute
*in_attr
;
13731 obj_attribute
*out_attr
;
13734 abi_fp_bfd
= mips_elf_tdata (obfd
)->abi_fp_bfd
;
13735 in_attr
= elf_known_obj_attributes (ibfd
)[OBJ_ATTR_GNU
];
13736 if (!abi_fp_bfd
&& in_attr
[Tag_GNU_MIPS_ABI_FP
].i
!= 0)
13737 mips_elf_tdata (obfd
)->abi_fp_bfd
= ibfd
;
13739 if (!elf_known_obj_attributes_proc (obfd
)[0].i
)
13741 /* This is the first object. Copy the attributes. */
13742 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
13744 /* Use the Tag_null value to indicate the attributes have been
13746 elf_known_obj_attributes_proc (obfd
)[0].i
= 1;
13751 /* Check for conflicting Tag_GNU_MIPS_ABI_FP attributes and merge
13752 non-conflicting ones. */
13753 out_attr
= elf_known_obj_attributes (obfd
)[OBJ_ATTR_GNU
];
13754 if (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
!= out_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
13756 out_attr
[Tag_GNU_MIPS_ABI_FP
].type
= 1;
13757 if (out_attr
[Tag_GNU_MIPS_ABI_FP
].i
== 0)
13758 out_attr
[Tag_GNU_MIPS_ABI_FP
].i
= in_attr
[Tag_GNU_MIPS_ABI_FP
].i
;
13759 else if (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
!= 0)
13760 switch (out_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
13763 switch (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
13767 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13768 obfd
, abi_fp_bfd
, ibfd
, "-mdouble-float", "-msingle-float");
13773 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13774 obfd
, abi_fp_bfd
, ibfd
, "-mhard-float", "-msoft-float");
13779 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13780 obfd
, abi_fp_bfd
, ibfd
,
13781 "-mdouble-float", "-mips32r2 -mfp64");
13786 (_("Warning: %B uses %s (set by %B), "
13787 "%B uses unknown floating point ABI %d"),
13788 obfd
, abi_fp_bfd
, ibfd
,
13789 "-mdouble-float", in_attr
[Tag_GNU_MIPS_ABI_FP
].i
);
13795 switch (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
13799 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13800 obfd
, abi_fp_bfd
, ibfd
, "-msingle-float", "-mdouble-float");
13805 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13806 obfd
, abi_fp_bfd
, ibfd
, "-mhard-float", "-msoft-float");
13811 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13812 obfd
, abi_fp_bfd
, ibfd
,
13813 "-msingle-float", "-mips32r2 -mfp64");
13818 (_("Warning: %B uses %s (set by %B), "
13819 "%B uses unknown floating point ABI %d"),
13820 obfd
, abi_fp_bfd
, ibfd
,
13821 "-msingle-float", in_attr
[Tag_GNU_MIPS_ABI_FP
].i
);
13827 switch (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
13833 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13834 obfd
, abi_fp_bfd
, ibfd
, "-msoft-float", "-mhard-float");
13839 (_("Warning: %B uses %s (set by %B), "
13840 "%B uses unknown floating point ABI %d"),
13841 obfd
, abi_fp_bfd
, ibfd
,
13842 "-msoft-float", in_attr
[Tag_GNU_MIPS_ABI_FP
].i
);
13848 switch (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
13852 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13853 obfd
, abi_fp_bfd
, ibfd
,
13854 "-mips32r2 -mfp64", "-mdouble-float");
13859 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13860 obfd
, abi_fp_bfd
, ibfd
,
13861 "-mips32r2 -mfp64", "-msingle-float");
13866 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13867 obfd
, abi_fp_bfd
, ibfd
, "-mhard-float", "-msoft-float");
13872 (_("Warning: %B uses %s (set by %B), "
13873 "%B uses unknown floating point ABI %d"),
13874 obfd
, abi_fp_bfd
, ibfd
,
13875 "-mips32r2 -mfp64", in_attr
[Tag_GNU_MIPS_ABI_FP
].i
);
13881 switch (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
13885 (_("Warning: %B uses unknown floating point ABI %d "
13886 "(set by %B), %B uses %s"),
13887 obfd
, abi_fp_bfd
, ibfd
,
13888 out_attr
[Tag_GNU_MIPS_ABI_FP
].i
, "-mdouble-float");
13893 (_("Warning: %B uses unknown floating point ABI %d "
13894 "(set by %B), %B uses %s"),
13895 obfd
, abi_fp_bfd
, ibfd
,
13896 out_attr
[Tag_GNU_MIPS_ABI_FP
].i
, "-msingle-float");
13901 (_("Warning: %B uses unknown floating point ABI %d "
13902 "(set by %B), %B uses %s"),
13903 obfd
, abi_fp_bfd
, ibfd
,
13904 out_attr
[Tag_GNU_MIPS_ABI_FP
].i
, "-msoft-float");
13909 (_("Warning: %B uses unknown floating point ABI %d "
13910 "(set by %B), %B uses %s"),
13911 obfd
, abi_fp_bfd
, ibfd
,
13912 out_attr
[Tag_GNU_MIPS_ABI_FP
].i
, "-mips32r2 -mfp64");
13917 (_("Warning: %B uses unknown floating point ABI %d "
13918 "(set by %B), %B uses unknown floating point ABI %d"),
13919 obfd
, abi_fp_bfd
, ibfd
,
13920 out_attr
[Tag_GNU_MIPS_ABI_FP
].i
,
13921 in_attr
[Tag_GNU_MIPS_ABI_FP
].i
);
13928 /* Merge Tag_compatibility attributes and any common GNU ones. */
13929 _bfd_elf_merge_object_attributes (ibfd
, obfd
);
13934 /* Merge backend specific data from an object file to the output
13935 object file when linking. */
13938 _bfd_mips_elf_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
13940 flagword old_flags
;
13941 flagword new_flags
;
13943 bfd_boolean null_input_bfd
= TRUE
;
13946 /* Check if we have the same endianness. */
13947 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
13949 (*_bfd_error_handler
)
13950 (_("%B: endianness incompatible with that of the selected emulation"),
13955 if (!is_mips_elf (ibfd
) || !is_mips_elf (obfd
))
13958 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
13960 (*_bfd_error_handler
)
13961 (_("%B: ABI is incompatible with that of the selected emulation"),
13966 if (!mips_elf_merge_obj_attributes (ibfd
, obfd
))
13969 new_flags
= elf_elfheader (ibfd
)->e_flags
;
13970 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_NOREORDER
;
13971 old_flags
= elf_elfheader (obfd
)->e_flags
;
13973 if (! elf_flags_init (obfd
))
13975 elf_flags_init (obfd
) = TRUE
;
13976 elf_elfheader (obfd
)->e_flags
= new_flags
;
13977 elf_elfheader (obfd
)->e_ident
[EI_CLASS
]
13978 = elf_elfheader (ibfd
)->e_ident
[EI_CLASS
];
13980 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
13981 && (bfd_get_arch_info (obfd
)->the_default
13982 || mips_mach_extends_p (bfd_get_mach (obfd
),
13983 bfd_get_mach (ibfd
))))
13985 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
13986 bfd_get_mach (ibfd
)))
13993 /* Check flag compatibility. */
13995 new_flags
&= ~EF_MIPS_NOREORDER
;
13996 old_flags
&= ~EF_MIPS_NOREORDER
;
13998 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
13999 doesn't seem to matter. */
14000 new_flags
&= ~EF_MIPS_XGOT
;
14001 old_flags
&= ~EF_MIPS_XGOT
;
14003 /* MIPSpro generates ucode info in n64 objects. Again, we should
14004 just be able to ignore this. */
14005 new_flags
&= ~EF_MIPS_UCODE
;
14006 old_flags
&= ~EF_MIPS_UCODE
;
14008 /* DSOs should only be linked with CPIC code. */
14009 if ((ibfd
->flags
& DYNAMIC
) != 0)
14010 new_flags
|= EF_MIPS_PIC
| EF_MIPS_CPIC
;
14012 if (new_flags
== old_flags
)
14015 /* Check to see if the input BFD actually contains any sections.
14016 If not, its flags may not have been initialised either, but it cannot
14017 actually cause any incompatibility. */
14018 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
14020 /* Ignore synthetic sections and empty .text, .data and .bss sections
14021 which are automatically generated by gas. Also ignore fake
14022 (s)common sections, since merely defining a common symbol does
14023 not affect compatibility. */
14024 if ((sec
->flags
& SEC_IS_COMMON
) == 0
14025 && strcmp (sec
->name
, ".reginfo")
14026 && strcmp (sec
->name
, ".mdebug")
14028 || (strcmp (sec
->name
, ".text")
14029 && strcmp (sec
->name
, ".data")
14030 && strcmp (sec
->name
, ".bss"))))
14032 null_input_bfd
= FALSE
;
14036 if (null_input_bfd
)
14041 if (((new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0)
14042 != ((old_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0))
14044 (*_bfd_error_handler
)
14045 (_("%B: warning: linking abicalls files with non-abicalls files"),
14050 if (new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
))
14051 elf_elfheader (obfd
)->e_flags
|= EF_MIPS_CPIC
;
14052 if (! (new_flags
& EF_MIPS_PIC
))
14053 elf_elfheader (obfd
)->e_flags
&= ~EF_MIPS_PIC
;
14055 new_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
14056 old_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
14058 /* Compare the ISAs. */
14059 if (mips_32bit_flags_p (old_flags
) != mips_32bit_flags_p (new_flags
))
14061 (*_bfd_error_handler
)
14062 (_("%B: linking 32-bit code with 64-bit code"),
14066 else if (!mips_mach_extends_p (bfd_get_mach (ibfd
), bfd_get_mach (obfd
)))
14068 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
14069 if (mips_mach_extends_p (bfd_get_mach (obfd
), bfd_get_mach (ibfd
)))
14071 /* Copy the architecture info from IBFD to OBFD. Also copy
14072 the 32-bit flag (if set) so that we continue to recognise
14073 OBFD as a 32-bit binary. */
14074 bfd_set_arch_info (obfd
, bfd_get_arch_info (ibfd
));
14075 elf_elfheader (obfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
14076 elf_elfheader (obfd
)->e_flags
14077 |= new_flags
& (EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
14079 /* Copy across the ABI flags if OBFD doesn't use them
14080 and if that was what caused us to treat IBFD as 32-bit. */
14081 if ((old_flags
& EF_MIPS_ABI
) == 0
14082 && mips_32bit_flags_p (new_flags
)
14083 && !mips_32bit_flags_p (new_flags
& ~EF_MIPS_ABI
))
14084 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ABI
;
14088 /* The ISAs aren't compatible. */
14089 (*_bfd_error_handler
)
14090 (_("%B: linking %s module with previous %s modules"),
14092 bfd_printable_name (ibfd
),
14093 bfd_printable_name (obfd
));
14098 new_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
14099 old_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
14101 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
14102 does set EI_CLASS differently from any 32-bit ABI. */
14103 if ((new_flags
& EF_MIPS_ABI
) != (old_flags
& EF_MIPS_ABI
)
14104 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
14105 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
14107 /* Only error if both are set (to different values). */
14108 if (((new_flags
& EF_MIPS_ABI
) && (old_flags
& EF_MIPS_ABI
))
14109 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
14110 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
14112 (*_bfd_error_handler
)
14113 (_("%B: ABI mismatch: linking %s module with previous %s modules"),
14115 elf_mips_abi_name (ibfd
),
14116 elf_mips_abi_name (obfd
));
14119 new_flags
&= ~EF_MIPS_ABI
;
14120 old_flags
&= ~EF_MIPS_ABI
;
14123 /* Compare ASEs. Forbid linking MIPS16 and microMIPS ASE modules together
14124 and allow arbitrary mixing of the remaining ASEs (retain the union). */
14125 if ((new_flags
& EF_MIPS_ARCH_ASE
) != (old_flags
& EF_MIPS_ARCH_ASE
))
14127 int old_micro
= old_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
;
14128 int new_micro
= new_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
;
14129 int old_m16
= old_flags
& EF_MIPS_ARCH_ASE_M16
;
14130 int new_m16
= new_flags
& EF_MIPS_ARCH_ASE_M16
;
14131 int micro_mis
= old_m16
&& new_micro
;
14132 int m16_mis
= old_micro
&& new_m16
;
14134 if (m16_mis
|| micro_mis
)
14136 (*_bfd_error_handler
)
14137 (_("%B: ASE mismatch: linking %s module with previous %s modules"),
14139 m16_mis
? "MIPS16" : "microMIPS",
14140 m16_mis
? "microMIPS" : "MIPS16");
14144 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ARCH_ASE
;
14146 new_flags
&= ~ EF_MIPS_ARCH_ASE
;
14147 old_flags
&= ~ EF_MIPS_ARCH_ASE
;
14150 /* Warn about any other mismatches */
14151 if (new_flags
!= old_flags
)
14153 (*_bfd_error_handler
)
14154 (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
14155 ibfd
, (unsigned long) new_flags
,
14156 (unsigned long) old_flags
);
14162 bfd_set_error (bfd_error_bad_value
);
14169 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
14172 _bfd_mips_elf_set_private_flags (bfd
*abfd
, flagword flags
)
14174 BFD_ASSERT (!elf_flags_init (abfd
)
14175 || elf_elfheader (abfd
)->e_flags
== flags
);
14177 elf_elfheader (abfd
)->e_flags
= flags
;
14178 elf_flags_init (abfd
) = TRUE
;
14183 _bfd_mips_elf_get_target_dtag (bfd_vma dtag
)
14187 default: return "";
14188 case DT_MIPS_RLD_VERSION
:
14189 return "MIPS_RLD_VERSION";
14190 case DT_MIPS_TIME_STAMP
:
14191 return "MIPS_TIME_STAMP";
14192 case DT_MIPS_ICHECKSUM
:
14193 return "MIPS_ICHECKSUM";
14194 case DT_MIPS_IVERSION
:
14195 return "MIPS_IVERSION";
14196 case DT_MIPS_FLAGS
:
14197 return "MIPS_FLAGS";
14198 case DT_MIPS_BASE_ADDRESS
:
14199 return "MIPS_BASE_ADDRESS";
14201 return "MIPS_MSYM";
14202 case DT_MIPS_CONFLICT
:
14203 return "MIPS_CONFLICT";
14204 case DT_MIPS_LIBLIST
:
14205 return "MIPS_LIBLIST";
14206 case DT_MIPS_LOCAL_GOTNO
:
14207 return "MIPS_LOCAL_GOTNO";
14208 case DT_MIPS_CONFLICTNO
:
14209 return "MIPS_CONFLICTNO";
14210 case DT_MIPS_LIBLISTNO
:
14211 return "MIPS_LIBLISTNO";
14212 case DT_MIPS_SYMTABNO
:
14213 return "MIPS_SYMTABNO";
14214 case DT_MIPS_UNREFEXTNO
:
14215 return "MIPS_UNREFEXTNO";
14216 case DT_MIPS_GOTSYM
:
14217 return "MIPS_GOTSYM";
14218 case DT_MIPS_HIPAGENO
:
14219 return "MIPS_HIPAGENO";
14220 case DT_MIPS_RLD_MAP
:
14221 return "MIPS_RLD_MAP";
14222 case DT_MIPS_DELTA_CLASS
:
14223 return "MIPS_DELTA_CLASS";
14224 case DT_MIPS_DELTA_CLASS_NO
:
14225 return "MIPS_DELTA_CLASS_NO";
14226 case DT_MIPS_DELTA_INSTANCE
:
14227 return "MIPS_DELTA_INSTANCE";
14228 case DT_MIPS_DELTA_INSTANCE_NO
:
14229 return "MIPS_DELTA_INSTANCE_NO";
14230 case DT_MIPS_DELTA_RELOC
:
14231 return "MIPS_DELTA_RELOC";
14232 case DT_MIPS_DELTA_RELOC_NO
:
14233 return "MIPS_DELTA_RELOC_NO";
14234 case DT_MIPS_DELTA_SYM
:
14235 return "MIPS_DELTA_SYM";
14236 case DT_MIPS_DELTA_SYM_NO
:
14237 return "MIPS_DELTA_SYM_NO";
14238 case DT_MIPS_DELTA_CLASSSYM
:
14239 return "MIPS_DELTA_CLASSSYM";
14240 case DT_MIPS_DELTA_CLASSSYM_NO
:
14241 return "MIPS_DELTA_CLASSSYM_NO";
14242 case DT_MIPS_CXX_FLAGS
:
14243 return "MIPS_CXX_FLAGS";
14244 case DT_MIPS_PIXIE_INIT
:
14245 return "MIPS_PIXIE_INIT";
14246 case DT_MIPS_SYMBOL_LIB
:
14247 return "MIPS_SYMBOL_LIB";
14248 case DT_MIPS_LOCALPAGE_GOTIDX
:
14249 return "MIPS_LOCALPAGE_GOTIDX";
14250 case DT_MIPS_LOCAL_GOTIDX
:
14251 return "MIPS_LOCAL_GOTIDX";
14252 case DT_MIPS_HIDDEN_GOTIDX
:
14253 return "MIPS_HIDDEN_GOTIDX";
14254 case DT_MIPS_PROTECTED_GOTIDX
:
14255 return "MIPS_PROTECTED_GOT_IDX";
14256 case DT_MIPS_OPTIONS
:
14257 return "MIPS_OPTIONS";
14258 case DT_MIPS_INTERFACE
:
14259 return "MIPS_INTERFACE";
14260 case DT_MIPS_DYNSTR_ALIGN
:
14261 return "DT_MIPS_DYNSTR_ALIGN";
14262 case DT_MIPS_INTERFACE_SIZE
:
14263 return "DT_MIPS_INTERFACE_SIZE";
14264 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
:
14265 return "DT_MIPS_RLD_TEXT_RESOLVE_ADDR";
14266 case DT_MIPS_PERF_SUFFIX
:
14267 return "DT_MIPS_PERF_SUFFIX";
14268 case DT_MIPS_COMPACT_SIZE
:
14269 return "DT_MIPS_COMPACT_SIZE";
14270 case DT_MIPS_GP_VALUE
:
14271 return "DT_MIPS_GP_VALUE";
14272 case DT_MIPS_AUX_DYNAMIC
:
14273 return "DT_MIPS_AUX_DYNAMIC";
14274 case DT_MIPS_PLTGOT
:
14275 return "DT_MIPS_PLTGOT";
14276 case DT_MIPS_RWPLT
:
14277 return "DT_MIPS_RWPLT";
14282 _bfd_mips_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
14286 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
14288 /* Print normal ELF private data. */
14289 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
14291 /* xgettext:c-format */
14292 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
14294 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
)
14295 fprintf (file
, _(" [abi=O32]"));
14296 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O64
)
14297 fprintf (file
, _(" [abi=O64]"));
14298 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
)
14299 fprintf (file
, _(" [abi=EABI32]"));
14300 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
14301 fprintf (file
, _(" [abi=EABI64]"));
14302 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
))
14303 fprintf (file
, _(" [abi unknown]"));
14304 else if (ABI_N32_P (abfd
))
14305 fprintf (file
, _(" [abi=N32]"));
14306 else if (ABI_64_P (abfd
))
14307 fprintf (file
, _(" [abi=64]"));
14309 fprintf (file
, _(" [no abi set]"));
14311 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
14312 fprintf (file
, " [mips1]");
14313 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
14314 fprintf (file
, " [mips2]");
14315 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
14316 fprintf (file
, " [mips3]");
14317 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
14318 fprintf (file
, " [mips4]");
14319 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_5
)
14320 fprintf (file
, " [mips5]");
14321 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
)
14322 fprintf (file
, " [mips32]");
14323 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64
)
14324 fprintf (file
, " [mips64]");
14325 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
)
14326 fprintf (file
, " [mips32r2]");
14327 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64R2
)
14328 fprintf (file
, " [mips64r2]");
14330 fprintf (file
, _(" [unknown ISA]"));
14332 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
14333 fprintf (file
, " [mdmx]");
14335 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_M16
)
14336 fprintf (file
, " [mips16]");
14338 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
14339 fprintf (file
, " [micromips]");
14341 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_32BITMODE
)
14342 fprintf (file
, " [32bitmode]");
14344 fprintf (file
, _(" [not 32bitmode]"));
14346 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_NOREORDER
)
14347 fprintf (file
, " [noreorder]");
14349 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_PIC
)
14350 fprintf (file
, " [PIC]");
14352 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_CPIC
)
14353 fprintf (file
, " [CPIC]");
14355 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_XGOT
)
14356 fprintf (file
, " [XGOT]");
14358 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_UCODE
)
14359 fprintf (file
, " [UCODE]");
14361 fputc ('\n', file
);
14366 const struct bfd_elf_special_section _bfd_mips_elf_special_sections
[] =
14368 { STRING_COMMA_LEN (".lit4"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
14369 { STRING_COMMA_LEN (".lit8"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
14370 { STRING_COMMA_LEN (".mdebug"), 0, SHT_MIPS_DEBUG
, 0 },
14371 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
14372 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
14373 { STRING_COMMA_LEN (".ucode"), 0, SHT_MIPS_UCODE
, 0 },
14374 { NULL
, 0, 0, 0, 0 }
14377 /* Merge non visibility st_other attributes. Ensure that the
14378 STO_OPTIONAL flag is copied into h->other, even if this is not a
14379 definiton of the symbol. */
14381 _bfd_mips_elf_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
14382 const Elf_Internal_Sym
*isym
,
14383 bfd_boolean definition
,
14384 bfd_boolean dynamic ATTRIBUTE_UNUSED
)
14386 if ((isym
->st_other
& ~ELF_ST_VISIBILITY (-1)) != 0)
14388 unsigned char other
;
14390 other
= (definition
? isym
->st_other
: h
->other
);
14391 other
&= ~ELF_ST_VISIBILITY (-1);
14392 h
->other
= other
| ELF_ST_VISIBILITY (h
->other
);
14396 && ELF_MIPS_IS_OPTIONAL (isym
->st_other
))
14397 h
->other
|= STO_OPTIONAL
;
14400 /* Decide whether an undefined symbol is special and can be ignored.
14401 This is the case for OPTIONAL symbols on IRIX. */
14403 _bfd_mips_elf_ignore_undef_symbol (struct elf_link_hash_entry
*h
)
14405 return ELF_MIPS_IS_OPTIONAL (h
->other
) ? TRUE
: FALSE
;
14409 _bfd_mips_elf_common_definition (Elf_Internal_Sym
*sym
)
14411 return (sym
->st_shndx
== SHN_COMMON
14412 || sym
->st_shndx
== SHN_MIPS_ACOMMON
14413 || sym
->st_shndx
== SHN_MIPS_SCOMMON
);
14416 /* Return address for Ith PLT stub in section PLT, for relocation REL
14417 or (bfd_vma) -1 if it should not be included. */
14420 _bfd_mips_elf_plt_sym_val (bfd_vma i
, const asection
*plt
,
14421 const arelent
*rel ATTRIBUTE_UNUSED
)
14424 + 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry
)
14425 + i
* 4 * ARRAY_SIZE (mips_exec_plt_entry
));
14429 _bfd_mips_post_process_headers (bfd
*abfd
, struct bfd_link_info
*link_info
)
14431 struct mips_elf_link_hash_table
*htab
;
14432 Elf_Internal_Ehdr
*i_ehdrp
;
14434 i_ehdrp
= elf_elfheader (abfd
);
14437 htab
= mips_elf_hash_table (link_info
);
14438 BFD_ASSERT (htab
!= NULL
);
14440 if (htab
->use_plts_and_copy_relocs
&& !htab
->is_vxworks
)
14441 i_ehdrp
->e_ident
[EI_ABIVERSION
] = 1;