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 *entry;
3997 new_got = (htab_t *) data;
3998 entry = (struct mips_got_entry *) *entryp;
3999 if (entry->abfd != NULL && entry->symndx == -1)
4001 struct mips_elf_link_hash_entry *h;
4004 while (h->root.root.type == bfd_link_hash_indirect
4005 || h->root.root.type == bfd_link_hash_warning)
4007 BFD_ASSERT (h->global_got_area == GGA_NONE);
4008 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
4012 slot = htab_find_slot (*new_got, entry, INSERT);
4023 /* If any entries in G->got_entries are for indirect or warning symbols,
4024 replace them with entries for the target symbol. */
4027 mips_elf_resolve_final_got_entries (struct mips_got_info *g)
4029 bfd_boolean must_recreate;
4032 must_recreate = FALSE;
4033 htab_traverse (g->got_entries, mips_elf_check_recreate_got, &must_recreate);
4036 new_got = htab_create (htab_size (g->got_entries),
4037 mips_elf_got_entry_hash,
4038 mips_elf_got_entry_eq, NULL);
4039 htab_traverse (g->got_entries, mips_elf_recreate_got, &new_got);
4040 if (new_got == NULL)
4043 htab_delete (g->got_entries);
4044 g->got_entries = new_got;
4049 /* A mips_elf_link_hash_traverse callback for which DATA points
4050 to the link_info structure. Count the number of type (3) entries
4051 in the master GOT. */
4054 mips_elf_count_got_symbols (struct mips_elf_link_hash_entry *h, void *data)
4056 struct bfd_link_info *info;
4057 struct mips_elf_link_hash_table *htab;
4058 struct mips_got_info *g;
4060 info = (struct bfd_link_info *) data;
4061 htab = mips_elf_hash_table (info);
4063 if (h->global_got_area != GGA_NONE)
4065 /* Make a final decision about whether the symbol belongs in the
4066 local or global GOT. Symbols that bind locally can (and in the
4067 case of forced-local symbols, must) live in the local GOT.
4068 Those that are aren't in the dynamic symbol table must also
4069 live in the local GOT.
4071 Note that the former condition does not always imply the
4072 latter: symbols do not bind locally if they are completely
4073 undefined. We'll report undefined symbols later if appropriate. */
4074 if (h->root.dynindx == -1
4075 || (h->got_only_for_calls
4076 ? SYMBOL_CALLS_LOCAL (info, &h->root)
4077 : SYMBOL_REFERENCES_LOCAL (info, &h->root)))
4079 /* The symbol belongs in the local GOT. We no longer need this
4080 entry if it was only used for relocations; those relocations
4081 will be against the null or section symbol instead of H. */
4082 if (h->global_got_area != GGA_RELOC_ONLY)
4084 h->global_got_area = GGA_NONE;
4086 else if (htab->is_vxworks
4087 && h->got_only_for_calls
4088 && h->root.plt.offset != MINUS_ONE)
4089 /* On VxWorks, calls can refer directly to the .got.plt entry;
4090 they don't need entries in the regular GOT. .got.plt entries
4091 will be allocated by _bfd_mips_elf_adjust_dynamic_symbol. */
4092 h->global_got_area = GGA_NONE;
4096 if (h->global_got_area == GGA_RELOC_ONLY)
4097 g->reloc_only_gotno++;
4103 /* Compute the hash value of the bfd in a bfd2got hash entry. */
4106 mips_elf_bfd2got_entry_hash (const void *entry_)
4108 const struct mips_elf_bfd2got_hash *entry
4109 = (struct mips_elf_bfd2got_hash *)entry_;
4111 return entry->bfd->id;
4114 /* Check whether two hash entries have the same bfd. */
4117 mips_elf_bfd2got_entry_eq (const void *entry1, const void *entry2)
4119 const struct mips_elf_bfd2got_hash *e1
4120 = (const struct mips_elf_bfd2got_hash *)entry1;
4121 const struct mips_elf_bfd2got_hash *e2
4122 = (const struct mips_elf_bfd2got_hash *)entry2;
4124 return e1->bfd == e2->bfd;
4127 /* In a multi-got link, determine the GOT to be used for IBFD. G must
4128 be the master GOT data. */
4130 static struct mips_got_info *
4131 mips_elf_got_for_ibfd (struct mips_got_info *g, bfd *ibfd)
4133 struct mips_elf_bfd2got_hash e, *p;
4139 p = htab_find (g->bfd2got, &e);
4140 return p ? p->g : NULL;
4143 /* Use BFD2GOT to find ABFD's got entry, creating one if none exists.
4144 Return NULL if an error occured. */
4146 static struct mips_got_info *
4147 mips_elf_get_got_for_bfd (struct htab *bfd2got, bfd *output_bfd,
4150 struct mips_elf_bfd2got_hash bfdgot_entry, *bfdgot;
4153 bfdgot_entry.bfd = input_bfd;
4154 bfdgotp = htab_find_slot (bfd2got, &bfdgot_entry, INSERT);
4155 bfdgot = (struct mips_elf_bfd2got_hash *) *bfdgotp;
4159 bfdgot = ((struct mips_elf_bfd2got_hash *)
4160 bfd_alloc (output_bfd, sizeof (struct mips_elf_bfd2got_hash)));
4166 bfdgot->bfd = input_bfd;
4167 bfdgot->g = mips_elf_create_got_info (input_bfd, FALSE);
4168 if (bfdgot->g == NULL)
4175 /* A htab_traverse callback for the entries in the master got.
4176 Create one separate got for each bfd that has entries in the global
4177 got, such that we can tell how many local and global entries each
4181 mips_elf_make_got_per_bfd (void **entryp, void *p)
4183 struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
4184 struct mips_elf_got_per_bfd_arg *arg = (struct mips_elf_got_per_bfd_arg *)p;
4185 struct mips_got_info *g;
4187 g = mips_elf_get_got_for_bfd (arg->bfd2got, arg->obfd, entry->abfd);
4194 /* Insert the GOT entry in the bfd's got entry hash table. */
4195 entryp = htab_find_slot (g->got_entries, entry, INSERT);
4196 if (*entryp != NULL)
4200 mips_elf_count_got_entry (arg->info, g, entry);
4205 /* A htab_traverse callback for the page entries in the master got.
4206 Associate each page entry with the bfd's got. */
4209 mips_elf_make_got_pages_per_bfd (void **entryp, void *p)
4211 struct mips_got_page_entry *entry = (struct mips_got_page_entry *) *entryp;
4212 struct mips_elf_got_per_bfd_arg *arg = (struct mips_elf_got_per_bfd_arg *) p;
4213 struct mips_got_info *g;
4215 g = mips_elf_get_got_for_bfd (arg->bfd2got, arg->obfd, entry->abfd);
4222 /* Insert the GOT entry in the bfd's got entry hash table. */
4223 entryp = htab_find_slot (g->got_page_entries, entry, INSERT);
4224 if (*entryp != NULL)
4228 g->page_gotno += entry->num_pages;
4232 /* Consider merging the got described by BFD2GOT with TO, using the
4233 information given by ARG. Return -1 if this would lead to overflow,
4234 1 if they were merged successfully, and 0 if a merge failed due to
4235 lack of memory. (These values are chosen so that nonnegative return
4236 values can be returned by a htab_traverse callback.) */
4239 mips_elf_merge_got_with (struct mips_elf_bfd2got_hash *bfd2got,
4240 struct mips_got_info *to,
4241 struct mips_elf_got_per_bfd_arg *arg)
4243 struct mips_got_info *from = bfd2got->g;
4244 unsigned int estimate;
4246 /* Work out how many page entries we would need for the combined GOT. */
4247 estimate = arg->max_pages;
4248 if (estimate >= from->page_gotno + to->page_gotno)
4249 estimate = from->page_gotno + to->page_gotno;
4251 /* And conservatively estimate how many local and TLS entries
4253 estimate += from->local_gotno + to->local_gotno;
4254 estimate += from->tls_gotno + to->tls_gotno;
4256 /* If we're merging with the primary got, any TLS relocations will
4257 come after the full set of global entries. Otherwise estimate those
4258 conservatively as well. */
4259 if (to == arg->primary && from->tls_gotno + to->tls_gotno)
4260 estimate += arg->global_count;
4262 estimate += from->global_gotno + to->global_gotno;
4264 /* Bail out if the combined GOT might be too big. */
4265 if (estimate > arg->max_count)
4268 /* Commit to the merge. Record that TO is now the bfd for this got. */
4271 /* Transfer the bfd's got information from FROM to TO. */
4272 htab_traverse (from->got_entries, mips_elf_make_got_per_bfd, arg);
4273 if (arg->obfd == NULL)
4276 htab_traverse (from->got_page_entries, mips_elf_make_got_pages_per_bfd, arg);
4277 if (arg->obfd == NULL)
4280 /* We don't have to worry about releasing memory of the actual
4281 got entries, since they're all in the master got_entries hash
4283 htab_delete (from->got_entries);
4284 htab_delete (from->got_page_entries);
4288 /* Attempt to merge gots of different input bfds. Try to use as much
4289 as possible of the primary got, since it doesn't require explicit
4290 dynamic relocations, but don't use bfds that would reference global
4291 symbols out of the addressable range. Failing the primary got,
4292 attempt to merge with the current got, or finish the current got
4293 and then make make the new got current. */
4296 mips_elf_merge_gots (void **bfd2got_, void *p)
4298 struct mips_elf_bfd2got_hash *bfd2got
4299 = (struct mips_elf_bfd2got_hash *)*bfd2got_;
4300 struct mips_elf_got_per_bfd_arg *arg = (struct mips_elf_got_per_bfd_arg *)p;
4301 struct mips_got_info *g;
4302 unsigned int estimate;
4307 /* Work out the number of page, local and TLS entries. */
4308 estimate = arg->max_pages;
4309 if (estimate > g->page_gotno)
4310 estimate = g->page_gotno;
4311 estimate += g->local_gotno + g->tls_gotno;
4313 /* We place TLS GOT entries after both locals and globals. The globals
4314 for the primary GOT may overflow the normal GOT size limit, so be
4315 sure not to merge a GOT which requires TLS with the primary GOT in that
4316 case. This doesn't affect non-primary GOTs. */
4317 estimate += (g->tls_gotno > 0 ? arg->global_count : g->global_gotno);
4319 if (estimate <= arg->max_count)
4321 /* If we don't have a primary GOT, use it as
4322 a starting point for the primary GOT. */
4325 arg->primary = bfd2got->g;
4329 /* Try merging with the primary GOT. */
4330 result = mips_elf_merge_got_with (bfd2got, arg->primary, arg);
4335 /* If we can merge with the last-created got, do it. */
4338 result = mips_elf_merge_got_with (bfd2got, arg->current, arg);
4343 /* Well, we couldn't merge, so create a new GOT. Don't check if it
4344 fits; if it turns out that it doesn't, we'll get relocation
4345 overflows anyway. */
4346 g->next = arg->current;
4352 /* Set the TLS GOT index for the GOT entry in ENTRYP. ENTRYP's NEXT field
4353 is null iff there is just a single GOT. */
4356 mips_elf_initialize_tls_index (void **entryp, void *p)
4358 struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
4359 struct mips_got_info *g = p;
4361 unsigned char tls_type;
4363 /* We're only interested in TLS symbols. */
4364 tls_type = (entry->tls_type & GOT_TLS_TYPE);
4368 next_index = MIPS_ELF_GOT_SIZE (entry->abfd) * (long) g->tls_assigned_gotno;
4370 if (entry->symndx == -1 && g->next == NULL)
4372 /* A type (3) got entry in the single-GOT case. We use the symbol's
4373 hash table entry to track its index. */
4374 if (tls_type == GOT_TLS_IE)
4376 if (entry->d.h->tls_ie_type & GOT_TLS_OFFSET_DONE)
4378 entry->d.h->tls_ie_type |= GOT_TLS_OFFSET_DONE;
4379 entry->d.h->tls_ie_got_offset = next_index;
4383 BFD_ASSERT (tls_type == GOT_TLS_GD);
4384 if (entry->d.h->tls_gd_type & GOT_TLS_OFFSET_DONE)
4386 entry->d.h->tls_gd_type |= GOT_TLS_OFFSET_DONE;
4387 entry->d.h->tls_gd_got_offset = next_index;
4392 if (tls_type == GOT_TLS_LDM)
4394 /* There are separate mips_got_entry objects for each input bfd
4395 that requires an LDM entry. Make sure that all LDM entries in
4396 a GOT resolve to the same index. */
4397 if (g->tls_ldm_offset != MINUS_TWO && g->tls_ldm_offset != MINUS_ONE)
4399 entry->gotidx = g->tls_ldm_offset;
4402 g->tls_ldm_offset = next_index;
4404 entry->gotidx = next_index;
4407 /* Account for the entries we've just allocated. */
4408 g->tls_assigned_gotno += mips_tls_got_entries (tls_type);
4412 /* A htab_traverse callback for GOT entries, where DATA points to a
4413 mips_elf_traverse_got_arg. Set the global_got_area of each global
4414 symbol to DATA->value. */
4417 mips_elf_set_global_got_area (void **entryp, void *data)
4419 struct mips_got_entry *entry;
4420 struct mips_elf_traverse_got_arg *arg;
4422 entry = (struct mips_got_entry *) *entryp;
4423 arg = (struct mips_elf_traverse_got_arg *) data;
4424 if (entry->abfd != NULL
4425 && entry->symndx == -1
4426 && entry->d.h->global_got_area != GGA_NONE)
4427 entry->d.h->global_got_area = arg->value;
4431 /* A htab_traverse callback for secondary GOT entries, where DATA points
4432 to a mips_elf_traverse_got_arg. Assign GOT indices to global entries
4433 and record the number of relocations they require. DATA->value is
4434 the size of one GOT entry. */
4437 mips_elf_set_global_gotidx (void **entryp, void *data)
4439 struct mips_got_entry *entry;
4440 struct mips_elf_traverse_got_arg *arg;
4442 entry = (struct mips_got_entry *) *entryp;
4443 arg = (struct mips_elf_traverse_got_arg *) data;
4444 if (entry->abfd != NULL
4445 && entry->symndx == -1
4446 && entry->d.h->global_got_area != GGA_NONE)
4448 entry->gotidx = arg->value * (long) arg->g->assigned_gotno++;
4449 if (arg->info->shared
4450 || (elf_hash_table (arg->info)->dynamic_sections_created
4451 && entry->d.h->root.def_dynamic
4452 && !entry->d.h->root.def_regular))
4453 arg->g->relocs += 1;
4459 /* A htab_traverse callback for GOT entries for which DATA is the
4460 bfd_link_info. Forbid any global symbols from having traditional
4461 lazy-binding stubs. */
4464 mips_elf_forbid_lazy_stubs (void **entryp, void *data)
4466 struct bfd_link_info *info;
4467 struct mips_elf_link_hash_table *htab;
4468 struct mips_got_entry *entry;
4470 entry = (struct mips_got_entry *) *entryp;
4471 info = (struct bfd_link_info *) data;
4472 htab = mips_elf_hash_table (info);
4473 BFD_ASSERT (htab != NULL);
4475 if (entry->abfd != NULL
4476 && entry->symndx == -1
4477 && entry->d.h->needs_lazy_stub)
4479 entry->d.h->needs_lazy_stub = FALSE;
4480 htab->lazy_stub_count--;
4486 /* Return the offset of an input bfd IBFD's GOT from the beginning of
4489 mips_elf_adjust_gp (bfd *abfd, struct mips_got_info *g, bfd *ibfd)
4491 if (g->bfd2got == NULL)
4494 g = mips_elf_got_for_ibfd (g, ibfd);
4498 BFD_ASSERT (g->next);
4502 return (g->local_gotno + g->global_gotno + g->tls_gotno)
4503 * MIPS_ELF_GOT_SIZE (abfd);
4506 /* Turn a single GOT that is too big for 16-bit addressing into
4507 a sequence of GOTs, each one 16-bit addressable. */
4510 mips_elf_multi_got (bfd *abfd, struct bfd_link_info *info,
4511 asection *got, bfd_size_type pages)
4513 struct mips_elf_link_hash_table *htab;
4514 struct mips_elf_got_per_bfd_arg got_per_bfd_arg;
4515 struct mips_elf_traverse_got_arg tga;
4516 struct mips_got_info *g, *gg;
4517 unsigned int assign, needed_relocs;
4520 dynobj = elf_hash_table (info)->dynobj;
4521 htab = mips_elf_hash_table (info);
4522 BFD_ASSERT (htab != NULL);
4525 g->bfd2got = htab_try_create (1, mips_elf_bfd2got_entry_hash,
4526 mips_elf_bfd2got_entry_eq, NULL);
4527 if (g->bfd2got == NULL)
4530 got_per_bfd_arg.bfd2got = g->bfd2got;
4531 got_per_bfd_arg.obfd = abfd;
4532 got_per_bfd_arg.info = info;
4534 /* Count how many GOT entries each input bfd requires, creating a
4535 map from bfd to got info while at that. */
4536 htab_traverse (g->got_entries, mips_elf_make_got_per_bfd, &got_per_bfd_arg);
4537 if (got_per_bfd_arg.obfd == NULL)
4540 /* Also count how many page entries each input bfd requires. */
4541 htab_traverse (g->got_page_entries, mips_elf_make_got_pages_per_bfd,
4543 if (got_per_bfd_arg.obfd == NULL)
4546 got_per_bfd_arg.current = NULL;
4547 got_per_bfd_arg.primary = NULL;
4548 got_per_bfd_arg.max_count = ((MIPS_ELF_GOT_MAX_SIZE (info)
4549 / MIPS_ELF_GOT_SIZE (abfd))
4550 - htab->reserved_gotno);
4551 got_per_bfd_arg.max_pages = pages;
4552 /* The number of globals that will be included in the primary GOT.
4553 See the calls to mips_elf_set_global_got_area below for more
4555 got_per_bfd_arg.global_count = g->global_gotno;
4557 /* Try to merge the GOTs of input bfds together, as long as they
4558 don't seem to exceed the maximum GOT size, choosing one of them
4559 to be the primary GOT. */
4560 htab_traverse (g->bfd2got, mips_elf_merge_gots, &got_per_bfd_arg);
4561 if (got_per_bfd_arg.obfd == NULL)
4564 /* If we do not find any suitable primary GOT, create an empty one. */
4565 if (got_per_bfd_arg.primary == NULL)
4566 g->next = mips_elf_create_got_info (abfd, FALSE);
4568 g->next = got_per_bfd_arg.primary;
4569 g->next->next = got_per_bfd_arg.current;
4571 /* GG is now the master GOT, and G is the primary GOT. */
4575 /* Map the output bfd to the primary got. That's what we're going
4576 to use for bfds that use GOT16 or GOT_PAGE relocations that we
4577 didn't mark in check_relocs, and we want a quick way to find it.
4578 We can't just use gg->next because we're going to reverse the
4581 struct mips_elf_bfd2got_hash *bfdgot;
4584 bfdgot = (struct mips_elf_bfd2got_hash *)bfd_alloc
4585 (abfd, sizeof (struct mips_elf_bfd2got_hash));
4592 bfdgotp = htab_find_slot (gg->bfd2got, bfdgot, INSERT);
4594 BFD_ASSERT (*bfdgotp == NULL);
4598 /* Every symbol that is referenced in a dynamic relocation must be
4599 present in the primary GOT, so arrange for them to appear after
4600 those that are actually referenced. */
4601 gg->reloc_only_gotno = gg->global_gotno - g->global_gotno;
4602 g->global_gotno = gg->global_gotno;
4605 tga.value = GGA_RELOC_ONLY;
4606 htab_traverse (gg->got_entries, mips_elf_set_global_got_area, &tga);
4607 tga.value = GGA_NORMAL;
4608 htab_traverse (g->got_entries, mips_elf_set_global_got_area, &tga);
4610 /* Now go through the GOTs assigning them offset ranges.
4611 [assigned_gotno, local_gotno[ will be set to the range of local
4612 entries in each GOT. We can then compute the end of a GOT by
4613 adding local_gotno to global_gotno. We reverse the list and make
4614 it circular since then we'll be able to quickly compute the
4615 beginning of a GOT, by computing the end of its predecessor. To
4616 avoid special cases for the primary GOT, while still preserving
4617 assertions that are valid for both single- and multi-got links,
4618 we arrange for the main got struct to have the right number of
4619 global entries, but set its local_gotno such that the initial
4620 offset of the primary GOT is zero. Remember that the primary GOT
4621 will become the last item in the circular linked list, so it
4622 points back to the master GOT. */
4623 gg->local_gotno = -g->global_gotno;
4624 gg->global_gotno = g->global_gotno;
4631 struct mips_got_info *gn;
4633 assign += htab->reserved_gotno;
4634 g->assigned_gotno = assign;
4635 g->local_gotno += assign;
4636 g->local_gotno += (pages < g->page_gotno ? pages : g->page_gotno);
4637 assign = g->local_gotno + g->global_gotno + g->tls_gotno;
4639 /* Take g out of the direct list, and push it onto the reversed
4640 list that gg points to. g->next is guaranteed to be nonnull after
4641 this operation, as required by mips_elf_initialize_tls_index. */
4646 /* Set up any TLS entries. We always place the TLS entries after
4647 all non-TLS entries. */
4648 g->tls_assigned_gotno = g->local_gotno + g->global_gotno;
4649 htab_traverse (g->got_entries, mips_elf_initialize_tls_index, g);
4650 BFD_ASSERT (g->tls_assigned_gotno == assign);
4652 /* Move onto the next GOT. It will be a secondary GOT if nonull. */
4655 /* Forbid global symbols in every non-primary GOT from having
4656 lazy-binding stubs. */
4658 htab_traverse (g->got_entries, mips_elf_forbid_lazy_stubs, info);
4662 got->size = assign * MIPS_ELF_GOT_SIZE (abfd);
4665 for (g = gg->next; g && g->next != gg; g = g->next)
4667 unsigned int save_assign;
4669 /* Assign offsets to global GOT entries and count how many
4670 relocations they need. */
4671 save_assign = g->assigned_gotno;
4672 g->assigned_gotno = g->local_gotno;
4674 tga.value = MIPS_ELF_GOT_SIZE (abfd);
4676 htab_traverse (g->got_entries, mips_elf_set_global_gotidx, &tga);
4677 BFD_ASSERT (g->assigned_gotno - g->local_gotno <= g->global_gotno);
4679 g->assigned_gotno = save_assign;
4682 g->relocs += g->local_gotno - g->assigned_gotno;
4683 BFD_ASSERT (g->assigned_gotno == g->next->local_gotno
4684 + g->next->global_gotno
4685 + g->next->tls_gotno
4686 + htab->reserved_gotno);
4688 needed_relocs += g->relocs;
4690 needed_relocs += g->relocs;
4693 mips_elf_allocate_dynamic_relocations (dynobj, info,
4700 /* Returns the first relocation of type r_type found, beginning with
4701 RELOCATION. RELEND is one-past-the-end of the relocation table. */
4703 static const Elf_Internal_Rela *
4704 mips_elf_next_relocation (bfd *abfd ATTRIBUTE_UNUSED, unsigned int r_type,
4705 const Elf_Internal_Rela *relocation,
4706 const Elf_Internal_Rela *relend)
4708 unsigned long r_symndx = ELF_R_SYM (abfd, relocation->r_info);
4710 while (relocation < relend)
4712 if (ELF_R_TYPE (abfd, relocation->r_info) == r_type
4713 && ELF_R_SYM (abfd, relocation->r_info) == r_symndx)
4719 /* We didn't find it. */
4723 /* Return whether an input relocation is against a local symbol. */
4726 mips_elf_local_relocation_p (bfd *input_bfd,
4727 const Elf_Internal_Rela *relocation,
4728 asection **local_sections)
4730 unsigned long r_symndx;
4731 Elf_Internal_Shdr *symtab_hdr;
4734 r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
4735 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4736 extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
4738 if (r_symndx < extsymoff)
4740 if (elf_bad_symtab (input_bfd) && local_sections[r_symndx] != NULL)
4746 /* Sign-extend VALUE, which has the indicated number of BITS. */
4749 _bfd_mips_elf_sign_extend (bfd_vma value, int bits)
4751 if (value & ((bfd_vma) 1 << (bits - 1)))
4752 /* VALUE is negative. */
4753 value |= ((bfd_vma) - 1) << bits;
4758 /* Return non-zero if the indicated VALUE has overflowed the maximum
4759 range expressible by a signed number with the indicated number of
4763 mips_elf_overflow_p (bfd_vma value, int bits)
4765 bfd_signed_vma svalue = (bfd_signed_vma) value;
4767 if (svalue > (1 << (bits - 1)) - 1)
4768 /* The value is too big. */
4770 else if (svalue < -(1 << (bits - 1)))
4771 /* The value is too small. */
4778 /* Calculate the %high function. */
4781 mips_elf_high (bfd_vma value)
4783 return ((value + (bfd_vma) 0x8000) >> 16) & 0xffff;
4786 /* Calculate the %higher function. */
4789 mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED)
4792 return ((value + (bfd_vma) 0x80008000) >> 32) & 0xffff;
4799 /* Calculate the %highest function. */
4802 mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED)
4805 return ((value + (((bfd_vma) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
4812 /* Create the .compact_rel section. */
4815 mips_elf_create_compact_rel_section
4816 (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
4819 register asection *s;
4821 if (bfd_get_linker_section (abfd, ".compact_rel") == NULL)
4823 flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED
4826 s = bfd_make_section_anyway_with_flags (abfd, ".compact_rel", flags);
4828 || ! bfd_set_section_alignment (abfd, s,
4829 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
4832 s->size = sizeof (Elf32_External_compact_rel);
4838 /* Create the .got section to hold the global offset table. */
4841 mips_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
4844 register asection *s;
4845 struct elf_link_hash_entry *h;
4846 struct bfd_link_hash_entry *bh;
4847 struct mips_elf_link_hash_table *htab;
4849 htab = mips_elf_hash_table (info);
4850 BFD_ASSERT (htab != NULL);
4852 /* This function may be called more than once. */
4856 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4857 | SEC_LINKER_CREATED);
4859 /* We have to use an alignment of 2**4 here because this is hardcoded
4860 in the function stub generation and in the linker script. */
4861 s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4863 || ! bfd_set_section_alignment (abfd, s, 4))
4867 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
4868 linker script because we don't want to define the symbol if we
4869 are not creating a global offset table. */
4871 if (! (_bfd_generic_link_add_one_symbol
4872 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
4873 0, NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
4876 h = (struct elf_link_hash_entry *) bh;
4879 h->type = STT_OBJECT;
4880 elf_hash_table (info)->hgot = h;
4883 && ! bfd_elf_link_record_dynamic_symbol (info, h))
4886 htab->got_info = mips_elf_create_got_info (abfd, TRUE);
4887 mips_elf_section_data (s)->elf.this_hdr.sh_flags
4888 |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
4890 /* We also need a .got.plt section when generating PLTs. */
4891 s = bfd_make_section_anyway_with_flags (abfd, ".got.plt",
4892 SEC_ALLOC | SEC_LOAD
4895 | SEC_LINKER_CREATED);
4903 /* Return true if H refers to the special VxWorks __GOTT_BASE__ or
4904 __GOTT_INDEX__ symbols. These symbols are only special for
4905 shared objects; they are not used in executables. */
4908 is_gott_symbol (struct bfd_link_info *info, struct elf_link_hash_entry *h)
4910 return (mips_elf_hash_table (info)->is_vxworks
4912 && (strcmp (h->root.root.string, "__GOTT_BASE__") == 0
4913 || strcmp (h->root.root.string, "__GOTT_INDEX__") == 0));
4916 /* Return TRUE if a relocation of type R_TYPE from INPUT_BFD might
4917 require an la25 stub. See also mips_elf_local_pic_function_p,
4918 which determines whether the destination function ever requires a
4922 mips_elf_relocation_needs_la25_stub (bfd *input_bfd, int r_type,
4923 bfd_boolean target_is_16_bit_code_p)
4925 /* We specifically ignore branches and jumps from EF_PIC objects,
4926 where the onus is on the compiler or programmer to perform any
4927 necessary initialization of $25. Sometimes such initialization
4928 is unnecessary; for example, -mno-shared functions do not use
4929 the incoming value of $25, and may therefore be called directly. */
4930 if (PIC_OBJECT_P (input_bfd))
4937 case R_MICROMIPS_26_S1:
4938 case R_MICROMIPS_PC7_S1:
4939 case R_MICROMIPS_PC10_S1:
4940 case R_MICROMIPS_PC16_S1:
4941 case R_MICROMIPS_PC23_S2:
4945 return !target_is_16_bit_code_p;
4952 /* Calculate the value produced by the RELOCATION (which comes from
4953 the INPUT_BFD). The ADDEND is the addend to use for this
4954 RELOCATION; RELOCATION->R_ADDEND is ignored.
4956 The result of the relocation calculation is stored in VALUEP.
4957 On exit, set *CROSS_MODE_JUMP_P to true if the relocation field
4958 is a MIPS16 or microMIPS jump to standard MIPS code, or vice versa.
4960 This function returns bfd_reloc_continue if the caller need take no
4961 further action regarding this relocation, bfd_reloc_notsupported if
4962 something goes dramatically wrong, bfd_reloc_overflow if an
4963 overflow occurs, and bfd_reloc_ok to indicate success. */
4965 static bfd_reloc_status_type
4966 mips_elf_calculate_relocation (bfd *abfd, bfd *input_bfd,
4967 asection *input_section,
4968 struct bfd_link_info *info,
4969 const Elf_Internal_Rela *relocation,
4970 bfd_vma addend, reloc_howto_type *howto,
4971 Elf_Internal_Sym *local_syms,
4972 asection **local_sections, bfd_vma *valuep,
4974 bfd_boolean *cross_mode_jump_p,
4975 bfd_boolean save_addend)
4977 /* The eventual value we will return. */
4979 /* The address of the symbol against which the relocation is
4982 /* The final GP value to be used for the relocatable, executable, or
4983 shared object file being produced. */
4985 /* The place (section offset or address) of the storage unit being
4988 /* The value of GP used to create the relocatable object. */
4990 /* The offset into the global offset table at which the address of
4991 the relocation entry symbol, adjusted by the addend, resides
4992 during execution. */
4993 bfd_vma g = MINUS_ONE;
4994 /* The section in which the symbol referenced by the relocation is
4996 asection *sec = NULL;
4997 struct mips_elf_link_hash_entry *h = NULL;
4998 /* TRUE if the symbol referred to by this relocation is a local
5000 bfd_boolean local_p, was_local_p;
5001 /* TRUE if the symbol referred to by this relocation is "_gp_disp". */
5002 bfd_boolean gp_disp_p = FALSE;
5003 /* TRUE if the symbol referred to by this relocation is
5004 "__gnu_local_gp". */
5005 bfd_boolean gnu_local_gp_p = FALSE;
5006 Elf_Internal_Shdr *symtab_hdr;
5008 unsigned long r_symndx;
5010 /* TRUE if overflow occurred during the calculation of the
5011 relocation value. */
5012 bfd_boolean overflowed_p;
5013 /* TRUE if this relocation refers to a MIPS16 function. */
5014 bfd_boolean target_is_16_bit_code_p = FALSE;
5015 bfd_boolean target_is_micromips_code_p = FALSE;
5016 struct mips_elf_link_hash_table *htab;
5019 dynobj = elf_hash_table (info)->dynobj;
5020 htab = mips_elf_hash_table (info);
5021 BFD_ASSERT (htab != NULL);
5023 /* Parse the relocation. */
5024 r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
5025 r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
5026 p = (input_section->output_section->vma
5027 + input_section->output_offset
5028 + relocation->r_offset);
5030 /* Assume that there will be no overflow. */
5031 overflowed_p = FALSE;
5033 /* Figure out whether or not the symbol is local, and get the offset
5034 used in the array of hash table entries. */
5035 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5036 local_p = mips_elf_local_relocation_p (input_bfd, relocation,
5038 was_local_p = local_p;
5039 if (! elf_bad_symtab (input_bfd))
5040 extsymoff = symtab_hdr->sh_info;
5043 /* The symbol table does not follow the rule that local symbols
5044 must come before globals. */
5048 /* Figure out the value of the symbol. */
5051 Elf_Internal_Sym *sym;
5053 sym = local_syms + r_symndx;
5054 sec = local_sections[r_symndx];
5056 symbol = sec->output_section->vma + sec->output_offset;
5057 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION
5058 || (sec->flags & SEC_MERGE))
5059 symbol += sym->st_value;
5060 if ((sec->flags & SEC_MERGE)
5061 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5063 addend = _bfd_elf_rel_local_sym (abfd, sym, &sec, addend);
5065 addend += sec->output_section->vma + sec->output_offset;
5068 /* MIPS16/microMIPS text labels should be treated as odd. */
5069 if (ELF_ST_IS_COMPRESSED (sym->st_other))
5072 /* Record the name of this symbol, for our caller. */
5073 *namep = bfd_elf_string_from_elf_section (input_bfd,
5074 symtab_hdr->sh_link,
5077 *namep = bfd_section_name (input_bfd, sec);
5079 target_is_16_bit_code_p = ELF_ST_IS_MIPS16 (sym->st_other);
5080 target_is_micromips_code_p = ELF_ST_IS_MICROMIPS (sym->st_other);
5084 /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ? */
5086 /* For global symbols we look up the symbol in the hash-table. */
5087 h = ((struct mips_elf_link_hash_entry *)
5088 elf_sym_hashes (input_bfd) [r_symndx - extsymoff]);
5089 /* Find the real hash-table entry for this symbol. */
5090 while (h->root.root.type == bfd_link_hash_indirect
5091 || h->root.root.type == bfd_link_hash_warning)
5092 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
5094 /* Record the name of this symbol, for our caller. */
5095 *namep = h->root.root.root.string;
5097 /* See if this is the special _gp_disp symbol. Note that such a
5098 symbol must always be a global symbol. */
5099 if (strcmp (*namep, "_gp_disp") == 0
5100 && ! NEWABI_P (input_bfd))
5102 /* Relocations against _gp_disp are permitted only with
5103 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
5104 if (!hi16_reloc_p (r_type) && !lo16_reloc_p (r_type))
5105 return bfd_reloc_notsupported;
5109 /* See if this is the special _gp symbol. Note that such a
5110 symbol must always be a global symbol. */
5111 else if (strcmp (*namep, "__gnu_local_gp") == 0)
5112 gnu_local_gp_p = TRUE;
5115 /* If this symbol is defined, calculate its address. Note that
5116 _gp_disp is a magic symbol, always implicitly defined by the
5117 linker, so it's inappropriate to check to see whether or not
5119 else if ((h->root.root.type == bfd_link_hash_defined
5120 || h->root.root.type == bfd_link_hash_defweak)
5121 && h->root.root.u.def.section)
5123 sec = h->root.root.u.def.section;
5124 if (sec->output_section)
5125 symbol = (h->root.root.u.def.value
5126 + sec->output_section->vma
5127 + sec->output_offset);
5129 symbol = h->root.root.u.def.value;
5131 else if (h->root.root.type == bfd_link_hash_undefweak)
5132 /* We allow relocations against undefined weak symbols, giving
5133 it the value zero, so that you can undefined weak functions
5134 and check to see if they exist by looking at their
5137 else if (info->unresolved_syms_in_objects == RM_IGNORE
5138 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
5140 else if (strcmp (*namep, SGI_COMPAT (input_bfd)
5141 ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING") == 0)
5143 /* If this is a dynamic link, we should have created a
5144 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
5145 in in _bfd_mips_elf_create_dynamic_sections.
5146 Otherwise, we should define the symbol with a value of 0.
5147 FIXME: It should probably get into the symbol table
5149 BFD_ASSERT (! info->shared);
5150 BFD_ASSERT (bfd_get_section_by_name (abfd, ".dynamic") == NULL);
5153 else if (ELF_MIPS_IS_OPTIONAL (h->root.other))
5155 /* This is an optional symbol - an Irix specific extension to the
5156 ELF spec. Ignore it for now.
5157 XXX - FIXME - there is more to the spec for OPTIONAL symbols
5158 than simply ignoring them, but we do not handle this for now.
5159 For information see the "64-bit ELF Object File Specification"
5160 which is available from here:
5161 http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf */
5164 else if ((*info->callbacks->undefined_symbol)
5165 (info, h->root.root.root.string, input_bfd,
5166 input_section, relocation->r_offset,
5167 (info->unresolved_syms_in_objects == RM_GENERATE_ERROR)
5168 || ELF_ST_VISIBILITY (h->root.other)))
5170 return bfd_reloc_undefined;
5174 return bfd_reloc_notsupported;
5177 target_is_16_bit_code_p = ELF_ST_IS_MIPS16 (h->root.other);
5178 /* If the output section is the PLT section,
5179 then the target is not microMIPS. */
5180 target_is_micromips_code_p = (htab->splt != sec
5181 && ELF_ST_IS_MICROMIPS (h->root.other));
5184 /* If this is a reference to a 16-bit function with a stub, we need
5185 to redirect the relocation to the stub unless:
5187 (a) the relocation is for a MIPS16 JAL;
5189 (b) the relocation is for a MIPS16 PIC call, and there are no
5190 non-MIPS16 uses of the GOT slot; or
5192 (c) the section allows direct references to MIPS16 functions. */
5193 if (r_type != R_MIPS16_26
5194 && !info->relocatable
5196 && h->fn_stub != NULL
5197 && (r_type != R_MIPS16_CALL16 || h->need_fn_stub))
5199 && elf_tdata (input_bfd)->local_stubs != NULL
5200 && elf_tdata (input_bfd)->local_stubs[r_symndx] != NULL))
5201 && !section_allows_mips16_refs_p (input_section))
5203 /* This is a 32- or 64-bit call to a 16-bit function. We should
5204 have already noticed that we were going to need the
5208 sec = elf_tdata (input_bfd)->local_stubs[r_symndx];
5213 BFD_ASSERT (h->need_fn_stub);
5216 /* If a LA25 header for the stub itself exists, point to the
5217 prepended LUI/ADDIU sequence. */
5218 sec = h->la25_stub->stub_section;
5219 value = h->la25_stub->offset;
5228 symbol = sec->output_section->vma + sec->output_offset + value;
5229 /* The target is 16-bit, but the stub isn't. */
5230 target_is_16_bit_code_p = FALSE;
5232 /* If this is a 16-bit call to a 32- or 64-bit function with a stub, we
5233 need to redirect the call to the stub. Note that we specifically
5234 exclude R_MIPS16_CALL16 from this behavior; indirect calls should
5235 use an indirect stub instead. */
5236 else if (r_type == R_MIPS16_26 && !info->relocatable
5237 && ((h != NULL && (h->call_stub != NULL || h->call_fp_stub != NULL))
5239 && elf_tdata (input_bfd)->local_call_stubs != NULL
5240 && elf_tdata (input_bfd)->local_call_stubs[r_symndx] != NULL))
5241 && !target_is_16_bit_code_p)
5244 sec = elf_tdata (input_bfd)->local_call_stubs[r_symndx];
5247 /* If both call_stub and call_fp_stub are defined, we can figure
5248 out which one to use by checking which one appears in the input
5250 if (h->call_stub != NULL && h->call_fp_stub != NULL)
5255 for (o = input_bfd->sections; o != NULL; o = o->next)
5257 if (CALL_FP_STUB_P (bfd_get_section_name (input_bfd, o)))
5259 sec = h->call_fp_stub;
5266 else if (h->call_stub != NULL)
5269 sec = h->call_fp_stub;
5272 BFD_ASSERT (sec->size > 0);
5273 symbol = sec->output_section->vma + sec->output_offset;
5275 /* If this is a direct call to a PIC function, redirect to the
5277 else if (h != NULL && h->la25_stub
5278 && mips_elf_relocation_needs_la25_stub (input_bfd, r_type,
5279 target_is_16_bit_code_p))
5280 symbol = (h->la25_stub->stub_section->output_section->vma
5281 + h->la25_stub->stub_section->output_offset
5282 + h->la25_stub->offset);
5284 /* Make sure MIPS16 and microMIPS are not used together. */
5285 if ((r_type == R_MIPS16_26 && target_is_micromips_code_p)
5286 || (micromips_branch_reloc_p (r_type) && target_is_16_bit_code_p))
5288 (*_bfd_error_handler)
5289 (_("MIPS16 and microMIPS functions cannot call each other"));
5290 return bfd_reloc_notsupported;
5293 /* Calls from 16-bit code to 32-bit code and vice versa require the
5294 mode change. However, we can ignore calls to undefined weak symbols,
5295 which should never be executed at runtime. This exception is important
5296 because the assembly writer may have "known" that any definition of the
5297 symbol would be 16-bit code, and that direct jumps were therefore
5299 *cross_mode_jump_p = (!info->relocatable
5300 && !(h && h->root.root.type == bfd_link_hash_undefweak)
5301 && ((r_type == R_MIPS16_26 && !target_is_16_bit_code_p)
5302 || (r_type == R_MICROMIPS_26_S1
5303 && !target_is_micromips_code_p)
5304 || ((r_type == R_MIPS_26 || r_type == R_MIPS_JALR)
5305 && (target_is_16_bit_code_p
5306 || target_is_micromips_code_p))));
5308 local_p = (h == NULL
5309 || (h->got_only_for_calls
5310 ? SYMBOL_CALLS_LOCAL (info, &h->root)
5311 : SYMBOL_REFERENCES_LOCAL (info, &h->root)));
5313 gp0 = _bfd_get_gp_value (input_bfd);
5314 gp = _bfd_get_gp_value (abfd);
5316 gp += mips_elf_adjust_gp (abfd, htab->got_info, input_bfd);
5321 /* Global R_MIPS_GOT_PAGE/R_MICROMIPS_GOT_PAGE relocations are equivalent
5322 to R_MIPS_GOT_DISP/R_MICROMIPS_GOT_DISP. The addend is applied by the
5323 corresponding R_MIPS_GOT_OFST/R_MICROMIPS_GOT_OFST. */
5324 if (got_page_reloc_p (r_type) && !local_p)
5326 r_type = (micromips_reloc_p (r_type)
5327 ? R_MICROMIPS_GOT_DISP : R_MIPS_GOT_DISP);
5331 /* If we haven't already determined the GOT offset, and we're going
5332 to need it, get it now. */
5335 case R_MIPS16_CALL16:
5336 case R_MIPS16_GOT16:
5339 case R_MIPS_GOT_DISP:
5340 case R_MIPS_GOT_HI16:
5341 case R_MIPS_CALL_HI16:
5342 case R_MIPS_GOT_LO16:
5343 case R_MIPS_CALL_LO16:
5344 case R_MICROMIPS_CALL16:
5345 case R_MICROMIPS_GOT16:
5346 case R_MICROMIPS_GOT_DISP:
5347 case R_MICROMIPS_GOT_HI16:
5348 case R_MICROMIPS_CALL_HI16:
5349 case R_MICROMIPS_GOT_LO16:
5350 case R_MICROMIPS_CALL_LO16:
5352 case R_MIPS_TLS_GOTTPREL:
5353 case R_MIPS_TLS_LDM:
5354 case R_MIPS16_TLS_GD:
5355 case R_MIPS16_TLS_GOTTPREL:
5356 case R_MIPS16_TLS_LDM:
5357 case R_MICROMIPS_TLS_GD:
5358 case R_MICROMIPS_TLS_GOTTPREL:
5359 case R_MICROMIPS_TLS_LDM:
5360 /* Find the index into the GOT where this value is located. */
5361 if (tls_ldm_reloc_p (r_type))
5363 g = mips_elf_local_got_index (abfd, input_bfd, info,
5364 0, 0, NULL, r_type);
5366 return bfd_reloc_outofrange;
5370 /* On VxWorks, CALL relocations should refer to the .got.plt
5371 entry, which is initialized to point at the PLT stub. */
5372 if (htab->is_vxworks
5373 && (call_hi16_reloc_p (r_type)
5374 || call_lo16_reloc_p (r_type)
5375 || call16_reloc_p (r_type)))
5377 BFD_ASSERT (addend == 0);
5378 BFD_ASSERT (h->root.needs_plt);
5379 g = mips_elf_gotplt_index (info, &h->root);
5383 BFD_ASSERT (addend == 0);
5384 g = mips_elf_global_got_index (dynobj, input_bfd,
5385 &h->root, r_type, info);
5386 if (!TLS_RELOC_P (r_type)
5387 && !elf_hash_table (info)->dynamic_sections_created)
5388 /* This is a static link. We must initialize the GOT entry. */
5389 MIPS_ELF_PUT_WORD (dynobj, symbol, htab->sgot->contents + g);
5392 else if (!htab->is_vxworks
5393 && (call16_reloc_p (r_type) || got16_reloc_p (r_type)))
5394 /* The calculation below does not involve "g". */
5398 g = mips_elf_local_got_index (abfd, input_bfd, info,
5399 symbol + addend, r_symndx, h, r_type);
5401 return bfd_reloc_outofrange;
5404 /* Convert GOT indices to actual offsets. */
5405 g = mips_elf_got_offset_from_index (info, abfd, input_bfd, g);
5409 /* Relocations against the VxWorks __GOTT_BASE__ and __GOTT_INDEX__
5410 symbols are resolved by the loader. Add them to .rela.dyn. */
5411 if (h != NULL && is_gott_symbol (info, &h->root))
5413 Elf_Internal_Rela outrel;
5417 s = mips_elf_rel_dyn_section (info, FALSE);
5418 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
5420 outrel.r_offset = (input_section->output_section->vma
5421 + input_section->output_offset
5422 + relocation->r_offset);
5423 outrel.r_info = ELF32_R_INFO (h->root.dynindx, r_type);
5424 outrel.r_addend = addend;
5425 bfd_elf32_swap_reloca_out (abfd, &outrel, loc);
5427 /* If we've written this relocation for a readonly section,
5428 we need to set DF_TEXTREL again, so that we do not delete the
5430 if (MIPS_ELF_READONLY_SECTION (input_section))
5431 info->flags |= DF_TEXTREL;
5434 return bfd_reloc_ok;
5437 /* Figure out what kind of relocation is being performed. */
5441 return bfd_reloc_continue;
5444 value = symbol + _bfd_mips_elf_sign_extend (addend, 16);
5445 overflowed_p = mips_elf_overflow_p (value, 16);
5452 || (htab->root.dynamic_sections_created
5454 && h->root.def_dynamic
5455 && !h->root.def_regular
5456 && !h->has_static_relocs))
5457 && r_symndx != STN_UNDEF
5459 || h->root.root.type != bfd_link_hash_undefweak
5460 || ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
5461 && (input_section->flags & SEC_ALLOC) != 0)
5463 /* If we're creating a shared library, then we can't know
5464 where the symbol will end up. So, we create a relocation
5465 record in the output, and leave the job up to the dynamic
5466 linker. We must do the same for executable references to
5467 shared library symbols, unless we've decided to use copy
5468 relocs or PLTs instead. */
5470 if (!mips_elf_create_dynamic_relocation (abfd,
5478 return bfd_reloc_undefined;
5482 if (r_type != R_MIPS_REL32)
5483 value = symbol + addend;
5487 value &= howto->dst_mask;
5491 value = symbol + addend - p;
5492 value &= howto->dst_mask;
5496 /* The calculation for R_MIPS16_26 is just the same as for an
5497 R_MIPS_26. It's only the storage of the relocated field into
5498 the output file that's different. That's handled in
5499 mips_elf_perform_relocation. So, we just fall through to the
5500 R_MIPS_26 case here. */
5502 case R_MICROMIPS_26_S1:
5506 /* Make sure the target of JALX is word-aligned. Bit 0 must be
5507 the correct ISA mode selector and bit 1 must be 0. */
5508 if (*cross_mode_jump_p && (symbol & 3) != (r_type == R_MIPS_26))
5509 return bfd_reloc_outofrange;
5511 /* Shift is 2, unusually, for microMIPS JALX. */
5512 shift = (!*cross_mode_jump_p && r_type == R_MICROMIPS_26_S1) ? 1 : 2;
5515 value = addend | ((p + 4) & (0xfc000000 << shift));
5517 value = _bfd_mips_elf_sign_extend (addend, 26 + shift);
5518 value = (value + symbol) >> shift;
5519 if (!was_local_p && h->root.root.type != bfd_link_hash_undefweak)
5520 overflowed_p = (value >> 26) != ((p + 4) >> (26 + shift));
5521 value &= howto->dst_mask;
5525 case R_MIPS_TLS_DTPREL_HI16:
5526 case R_MIPS16_TLS_DTPREL_HI16:
5527 case R_MICROMIPS_TLS_DTPREL_HI16:
5528 value = (mips_elf_high (addend + symbol - dtprel_base (info))
5532 case R_MIPS_TLS_DTPREL_LO16:
5533 case R_MIPS_TLS_DTPREL32:
5534 case R_MIPS_TLS_DTPREL64:
5535 case R_MIPS16_TLS_DTPREL_LO16:
5536 case R_MICROMIPS_TLS_DTPREL_LO16:
5537 value = (symbol + addend - dtprel_base (info)) & howto->dst_mask;
5540 case R_MIPS_TLS_TPREL_HI16:
5541 case R_MIPS16_TLS_TPREL_HI16:
5542 case R_MICROMIPS_TLS_TPREL_HI16:
5543 value = (mips_elf_high (addend + symbol - tprel_base (info))
5547 case R_MIPS_TLS_TPREL_LO16:
5548 case R_MIPS_TLS_TPREL32:
5549 case R_MIPS_TLS_TPREL64:
5550 case R_MIPS16_TLS_TPREL_LO16:
5551 case R_MICROMIPS_TLS_TPREL_LO16:
5552 value = (symbol + addend - tprel_base (info)) & howto->dst_mask;
5557 case R_MICROMIPS_HI16:
5560 value = mips_elf_high (addend + symbol);
5561 value &= howto->dst_mask;
5565 /* For MIPS16 ABI code we generate this sequence
5566 0: li $v0,%hi(_gp_disp)
5567 4: addiupc $v1,%lo(_gp_disp)
5571 So the offsets of hi and lo relocs are the same, but the
5572 base $pc is that used by the ADDIUPC instruction at $t9 + 4.
5573 ADDIUPC clears the low two bits of the instruction address,
5574 so the base is ($t9 + 4) & ~3. */
5575 if (r_type == R_MIPS16_HI16)
5576 value = mips_elf_high (addend + gp - ((p + 4) & ~(bfd_vma) 0x3));
5577 /* The microMIPS .cpload sequence uses the same assembly
5578 instructions as the traditional psABI version, but the
5579 incoming $t9 has the low bit set. */
5580 else if (r_type == R_MICROMIPS_HI16)
5581 value = mips_elf_high (addend + gp - p - 1);
5583 value = mips_elf_high (addend + gp - p);
5584 overflowed_p = mips_elf_overflow_p (value, 16);
5590 case R_MICROMIPS_LO16:
5591 case R_MICROMIPS_HI0_LO16:
5593 value = (symbol + addend) & howto->dst_mask;
5596 /* See the comment for R_MIPS16_HI16 above for the reason
5597 for this conditional. */
5598 if (r_type == R_MIPS16_LO16)
5599 value = addend + gp - (p & ~(bfd_vma) 0x3);
5600 else if (r_type == R_MICROMIPS_LO16
5601 || r_type == R_MICROMIPS_HI0_LO16)
5602 value = addend + gp - p + 3;
5604 value = addend + gp - p + 4;
5605 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
5606 for overflow. But, on, say, IRIX5, relocations against
5607 _gp_disp are normally generated from the .cpload
5608 pseudo-op. It generates code that normally looks like
5611 lui $gp,%hi(_gp_disp)
5612 addiu $gp,$gp,%lo(_gp_disp)
5615 Here $t9 holds the address of the function being called,
5616 as required by the MIPS ELF ABI. The R_MIPS_LO16
5617 relocation can easily overflow in this situation, but the
5618 R_MIPS_HI16 relocation will handle the overflow.
5619 Therefore, we consider this a bug in the MIPS ABI, and do
5620 not check for overflow here. */
5624 case R_MIPS_LITERAL:
5625 case R_MICROMIPS_LITERAL:
5626 /* Because we don't merge literal sections, we can handle this
5627 just like R_MIPS_GPREL16. In the long run, we should merge
5628 shared literals, and then we will need to additional work
5633 case R_MIPS16_GPREL:
5634 /* The R_MIPS16_GPREL performs the same calculation as
5635 R_MIPS_GPREL16, but stores the relocated bits in a different
5636 order. We don't need to do anything special here; the
5637 differences are handled in mips_elf_perform_relocation. */
5638 case R_MIPS_GPREL16:
5639 case R_MICROMIPS_GPREL7_S2:
5640 case R_MICROMIPS_GPREL16:
5641 /* Only sign-extend the addend if it was extracted from the
5642 instruction. If the addend was separate, leave it alone,
5643 otherwise we may lose significant bits. */
5644 if (howto->partial_inplace)
5645 addend = _bfd_mips_elf_sign_extend (addend, 16);
5646 value = symbol + addend - gp;
5647 /* If the symbol was local, any earlier relocatable links will
5648 have adjusted its addend with the gp offset, so compensate
5649 for that now. Don't do it for symbols forced local in this
5650 link, though, since they won't have had the gp offset applied
5654 overflowed_p = mips_elf_overflow_p (value, 16);
5657 case R_MIPS16_GOT16:
5658 case R_MIPS16_CALL16:
5661 case R_MICROMIPS_GOT16:
5662 case R_MICROMIPS_CALL16:
5663 /* VxWorks does not have separate local and global semantics for
5664 R_MIPS*_GOT16; every relocation evaluates to "G". */
5665 if (!htab->is_vxworks && local_p)
5667 value = mips_elf_got16_entry (abfd, input_bfd, info,
5668 symbol + addend, !was_local_p);
5669 if (value == MINUS_ONE)
5670 return bfd_reloc_outofrange;
5672 = mips_elf_got_offset_from_index (info, abfd, input_bfd, value);
5673 overflowed_p = mips_elf_overflow_p (value, 16);
5680 case R_MIPS_TLS_GOTTPREL:
5681 case R_MIPS_TLS_LDM:
5682 case R_MIPS_GOT_DISP:
5683 case R_MIPS16_TLS_GD:
5684 case R_MIPS16_TLS_GOTTPREL:
5685 case R_MIPS16_TLS_LDM:
5686 case R_MICROMIPS_TLS_GD:
5687 case R_MICROMIPS_TLS_GOTTPREL:
5688 case R_MICROMIPS_TLS_LDM:
5689 case R_MICROMIPS_GOT_DISP:
5691 overflowed_p = mips_elf_overflow_p (value, 16);
5694 case R_MIPS_GPREL32:
5695 value = (addend + symbol + gp0 - gp);
5697 value &= howto->dst_mask;
5701 case R_MIPS_GNU_REL16_S2:
5702 value = symbol + _bfd_mips_elf_sign_extend (addend, 18) - p;
5703 overflowed_p = mips_elf_overflow_p (value, 18);
5704 value >>= howto->rightshift;
5705 value &= howto->dst_mask;
5708 case R_MICROMIPS_PC7_S1:
5709 value = symbol + _bfd_mips_elf_sign_extend (addend, 8) - p;
5710 overflowed_p = mips_elf_overflow_p (value, 8);
5711 value >>= howto->rightshift;
5712 value &= howto->dst_mask;
5715 case R_MICROMIPS_PC10_S1:
5716 value = symbol + _bfd_mips_elf_sign_extend (addend, 11) - p;
5717 overflowed_p = mips_elf_overflow_p (value, 11);
5718 value >>= howto->rightshift;
5719 value &= howto->dst_mask;
5722 case R_MICROMIPS_PC16_S1:
5723 value = symbol + _bfd_mips_elf_sign_extend (addend, 17) - p;
5724 overflowed_p = mips_elf_overflow_p (value, 17);
5725 value >>= howto->rightshift;
5726 value &= howto->dst_mask;
5729 case R_MICROMIPS_PC23_S2:
5730 value = symbol + _bfd_mips_elf_sign_extend (addend, 25) - ((p | 3) ^ 3);
5731 overflowed_p = mips_elf_overflow_p (value, 25);
5732 value >>= howto->rightshift;
5733 value &= howto->dst_mask;
5736 case R_MIPS_GOT_HI16:
5737 case R_MIPS_CALL_HI16:
5738 case R_MICROMIPS_GOT_HI16:
5739 case R_MICROMIPS_CALL_HI16:
5740 /* We're allowed to handle these two relocations identically.
5741 The dynamic linker is allowed to handle the CALL relocations
5742 differently by creating a lazy evaluation stub. */
5744 value = mips_elf_high (value);
5745 value &= howto->dst_mask;
5748 case R_MIPS_GOT_LO16:
5749 case R_MIPS_CALL_LO16:
5750 case R_MICROMIPS_GOT_LO16:
5751 case R_MICROMIPS_CALL_LO16:
5752 value = g & howto->dst_mask;
5755 case R_MIPS_GOT_PAGE:
5756 case R_MICROMIPS_GOT_PAGE:
5757 value = mips_elf_got_page (abfd, input_bfd, info, symbol + addend, NULL);
5758 if (value == MINUS_ONE)
5759 return bfd_reloc_outofrange;
5760 value = mips_elf_got_offset_from_index (info, abfd, input_bfd, value);
5761 overflowed_p = mips_elf_overflow_p (value, 16);
5764 case R_MIPS_GOT_OFST:
5765 case R_MICROMIPS_GOT_OFST:
5767 mips_elf_got_page (abfd, input_bfd, info, symbol + addend, &value);
5770 overflowed_p = mips_elf_overflow_p (value, 16);
5774 case R_MICROMIPS_SUB:
5775 value = symbol - addend;
5776 value &= howto->dst_mask;
5780 case R_MICROMIPS_HIGHER:
5781 value = mips_elf_higher (addend + symbol);
5782 value &= howto->dst_mask;
5785 case R_MIPS_HIGHEST:
5786 case R_MICROMIPS_HIGHEST:
5787 value = mips_elf_highest (addend + symbol);
5788 value &= howto->dst_mask;
5791 case R_MIPS_SCN_DISP:
5792 case R_MICROMIPS_SCN_DISP:
5793 value = symbol + addend - sec->output_offset;
5794 value &= howto->dst_mask;
5798 case R_MICROMIPS_JALR:
5799 /* This relocation is only a hint. In some cases, we optimize
5800 it into a bal instruction. But we don't try to optimize
5801 when the symbol does not resolve locally. */
5802 if (h != NULL && !SYMBOL_CALLS_LOCAL (info, &h->root))
5803 return bfd_reloc_continue;
5804 value = symbol + addend;
5808 case R_MIPS_GNU_VTINHERIT:
5809 case R_MIPS_GNU_VTENTRY:
5810 /* We don't do anything with these at present. */
5811 return bfd_reloc_continue;
5814 /* An unrecognized relocation type. */
5815 return bfd_reloc_notsupported;
5818 /* Store the VALUE for our caller. */
5820 return overflowed_p ? bfd_reloc_overflow : bfd_reloc_ok;
5823 /* Obtain the field relocated by RELOCATION. */
5826 mips_elf_obtain_contents (reloc_howto_type *howto,
5827 const Elf_Internal_Rela *relocation,
5828 bfd *input_bfd, bfd_byte *contents)
5831 bfd_byte *location = contents + relocation->r_offset;
5833 /* Obtain the bytes. */
5834 x = bfd_get ((8 * bfd_get_reloc_size (howto)), input_bfd, location);
5839 /* It has been determined that the result of the RELOCATION is the
5840 VALUE. Use HOWTO to place VALUE into the output file at the
5841 appropriate position. The SECTION is the section to which the
5843 CROSS_MODE_JUMP_P is true if the relocation field
5844 is a MIPS16 or microMIPS jump to standard MIPS code, or vice versa.
5846 Returns FALSE if anything goes wrong. */
5849 mips_elf_perform_relocation (struct bfd_link_info *info,
5850 reloc_howto_type *howto,
5851 const Elf_Internal_Rela *relocation,
5852 bfd_vma value, bfd *input_bfd,
5853 asection *input_section, bfd_byte *contents,
5854 bfd_boolean cross_mode_jump_p)
5858 int r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
5860 /* Figure out where the relocation is occurring. */
5861 location = contents + relocation->r_offset;
5863 _bfd_mips_elf_reloc_unshuffle (input_bfd, r_type, FALSE, location);
5865 /* Obtain the current value. */
5866 x = mips_elf_obtain_contents (howto, relocation, input_bfd, contents);
5868 /* Clear the field we are setting. */
5869 x &= ~howto->dst_mask;
5871 /* Set the field. */
5872 x |= (value & howto->dst_mask);
5874 /* If required, turn JAL into JALX. */
5875 if (cross_mode_jump_p && jal_reloc_p (r_type))
5878 bfd_vma opcode = x >> 26;
5879 bfd_vma jalx_opcode;
5881 /* Check to see if the opcode is already JAL or JALX. */
5882 if (r_type == R_MIPS16_26)
5884 ok = ((opcode == 0x6) || (opcode == 0x7));
5887 else if (r_type == R_MICROMIPS_26_S1)
5889 ok = ((opcode == 0x3d) || (opcode == 0x3c));
5894 ok = ((opcode == 0x3) || (opcode == 0x1d));
5898 /* If the opcode is not JAL or JALX, there's a problem. We cannot
5899 convert J or JALS to JALX. */
5902 (*_bfd_error_handler)
5903 (_("%B: %A+0x%lx: Unsupported jump between ISA modes; consider recompiling with interlinking enabled."),
5906 (unsigned long) relocation->r_offset);
5907 bfd_set_error (bfd_error_bad_value);
5911 /* Make this the JALX opcode. */
5912 x = (x & ~(0x3f << 26)) | (jalx_opcode << 26);
5915 /* Try converting JAL to BAL and J(AL)R to B(AL), if the target is in
5917 if (!info->relocatable
5918 && !cross_mode_jump_p
5919 && ((JAL_TO_BAL_P (input_bfd)
5920 && r_type == R_MIPS_26
5921 && (x >> 26) == 0x3) /* jal addr */
5922 || (JALR_TO_BAL_P (input_bfd)
5923 && r_type == R_MIPS_JALR
5924 && x == 0x0320f809) /* jalr t9 */
5925 || (JR_TO_B_P (input_bfd)
5926 && r_type == R_MIPS_JALR
5927 && x == 0x03200008))) /* jr t9 */
5933 addr = (input_section->output_section->vma
5934 + input_section->output_offset
5935 + relocation->r_offset
5937 if (r_type == R_MIPS_26)
5938 dest = (value << 2) | ((addr >> 28) << 28);
5942 if (off <= 0x1ffff && off >= -0x20000)
5944 if (x == 0x03200008) /* jr t9 */
5945 x = 0x10000000 | (((bfd_vma) off >> 2) & 0xffff); /* b addr */
5947 x = 0x04110000 | (((bfd_vma) off >> 2) & 0xffff); /* bal addr */
5951 /* Put the value into the output. */
5952 bfd_put (8 * bfd_get_reloc_size (howto), input_bfd, x, location);
5954 _bfd_mips_elf_reloc_shuffle (input_bfd, r_type, !info->relocatable,
5960 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
5961 is the original relocation, which is now being transformed into a
5962 dynamic relocation. The ADDENDP is adjusted if necessary; the
5963 caller should store the result in place of the original addend. */
5966 mips_elf_create_dynamic_relocation (bfd *output_bfd,
5967 struct bfd_link_info *info,
5968 const Elf_Internal_Rela *rel,
5969 struct mips_elf_link_hash_entry *h,
5970 asection *sec, bfd_vma symbol,
5971 bfd_vma *addendp, asection *input_section)
5973 Elf_Internal_Rela outrel[3];
5978 bfd_boolean defined_p;
5979 struct mips_elf_link_hash_table *htab;
5981 htab = mips_elf_hash_table (info);
5982 BFD_ASSERT (htab != NULL);
5984 r_type = ELF_R_TYPE (output_bfd, rel->r_info);
5985 dynobj = elf_hash_table (info)->dynobj;
5986 sreloc = mips_elf_rel_dyn_section (info, FALSE);
5987 BFD_ASSERT (sreloc != NULL);
5988 BFD_ASSERT (sreloc->contents != NULL);
5989 BFD_ASSERT (sreloc->reloc_count * MIPS_ELF_REL_SIZE (output_bfd)
5992 outrel[0].r_offset =
5993 _bfd_elf_section_offset (output_bfd, info, input_section, rel[0].r_offset);
5994 if (ABI_64_P (output_bfd))
5996 outrel[1].r_offset =
5997 _bfd_elf_section_offset (output_bfd, info, input_section, rel[1].r_offset);
5998 outrel[2].r_offset =
5999 _bfd_elf_section_offset (output_bfd, info, input_section, rel[2].r_offset);
6002 if (outrel[0].r_offset == MINUS_ONE)
6003 /* The relocation field has been deleted. */
6006 if (outrel[0].r_offset == MINUS_TWO)
6008 /* The relocation field has been converted into a relative value of
6009 some sort. Functions like _bfd_elf_write_section_eh_frame expect
6010 the field to be fully relocated, so add in the symbol's value. */
6015 /* We must now calculate the dynamic symbol table index to use
6016 in the relocation. */
6017 if (h != NULL && ! SYMBOL_REFERENCES_LOCAL (info, &h->root))
6019 BFD_ASSERT (htab->is_vxworks || h->global_got_area != GGA_NONE);
6020 indx = h->root.dynindx;
6021 if (SGI_COMPAT (output_bfd))
6022 defined_p = h->root.def_regular;
6024 /* ??? glibc's ld.so just adds the final GOT entry to the
6025 relocation field. It therefore treats relocs against
6026 defined symbols in the same way as relocs against
6027 undefined symbols. */
6032 if (sec != NULL && bfd_is_abs_section (sec))
6034 else if (sec == NULL || sec->owner == NULL)
6036 bfd_set_error (bfd_error_bad_value);
6041 indx = elf_section_data (sec->output_section)->dynindx;
6044 asection *osec = htab->root.text_index_section;
6045 indx = elf_section_data (osec)->dynindx;
6051 /* Instead of generating a relocation using the section
6052 symbol, we may as well make it a fully relative
6053 relocation. We want to avoid generating relocations to
6054 local symbols because we used to generate them
6055 incorrectly, without adding the original symbol value,
6056 which is mandated by the ABI for section symbols. In
6057 order to give dynamic loaders and applications time to
6058 phase out the incorrect use, we refrain from emitting
6059 section-relative relocations. It's not like they're
6060 useful, after all. This should be a bit more efficient
6062 /* ??? Although this behavior is compatible with glibc's ld.so,
6063 the ABI says that relocations against STN_UNDEF should have
6064 a symbol value of 0. Irix rld honors this, so relocations
6065 against STN_UNDEF have no effect. */
6066 if (!SGI_COMPAT (output_bfd))
6071 /* If the relocation was previously an absolute relocation and
6072 this symbol will not be referred to by the relocation, we must
6073 adjust it by the value we give it in the dynamic symbol table.
6074 Otherwise leave the job up to the dynamic linker. */
6075 if (defined_p && r_type != R_MIPS_REL32)
6078 if (htab->is_vxworks)
6079 /* VxWorks uses non-relative relocations for this. */
6080 outrel[0].r_info = ELF32_R_INFO (indx, R_MIPS_32);
6082 /* The relocation is always an REL32 relocation because we don't
6083 know where the shared library will wind up at load-time. */
6084 outrel[0].r_info = ELF_R_INFO (output_bfd, (unsigned long) indx,
6087 /* For strict adherence to the ABI specification, we should
6088 generate a R_MIPS_64 relocation record by itself before the
6089 _REL32/_64 record as well, such that the addend is read in as
6090 a 64-bit value (REL32 is a 32-bit relocation, after all).
6091 However, since none of the existing ELF64 MIPS dynamic
6092 loaders seems to care, we don't waste space with these
6093 artificial relocations. If this turns out to not be true,
6094 mips_elf_allocate_dynamic_relocation() should be tweaked so
6095 as to make room for a pair of dynamic relocations per
6096 invocation if ABI_64_P, and here we should generate an
6097 additional relocation record with R_MIPS_64 by itself for a
6098 NULL symbol before this relocation record. */
6099 outrel[1].r_info = ELF_R_INFO (output_bfd, 0,
6100 ABI_64_P (output_bfd)
6103 outrel[2].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_NONE);
6105 /* Adjust the output offset of the relocation to reference the
6106 correct location in the output file. */
6107 outrel[0].r_offset += (input_section->output_section->vma
6108 + input_section->output_offset);
6109 outrel[1].r_offset += (input_section->output_section->vma
6110 + input_section->output_offset);
6111 outrel[2].r_offset += (input_section->output_section->vma
6112 + input_section->output_offset);
6114 /* Put the relocation back out. We have to use the special
6115 relocation outputter in the 64-bit case since the 64-bit
6116 relocation format is non-standard. */
6117 if (ABI_64_P (output_bfd))
6119 (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
6120 (output_bfd, &outrel[0],
6122 + sreloc->reloc_count * sizeof (Elf64_Mips_External_Rel)));
6124 else if (htab->is_vxworks)
6126 /* VxWorks uses RELA rather than REL dynamic relocations. */
6127 outrel[0].r_addend = *addendp;
6128 bfd_elf32_swap_reloca_out
6129 (output_bfd, &outrel[0],
6131 + sreloc->reloc_count * sizeof (Elf32_External_Rela)));
6134 bfd_elf32_swap_reloc_out
6135 (output_bfd, &outrel[0],
6136 (sreloc->contents + sreloc->reloc_count * sizeof (Elf32_External_Rel)));
6138 /* We've now added another relocation. */
6139 ++sreloc->reloc_count;
6141 /* Make sure the output section is writable. The dynamic linker
6142 will be writing to it. */
6143 elf_section_data (input_section->output_section)->this_hdr.sh_flags
6146 /* On IRIX5, make an entry of compact relocation info. */
6147 if (IRIX_COMPAT (output_bfd) == ict_irix5)
6149 asection *scpt = bfd_get_linker_section (dynobj, ".compact_rel");
6154 Elf32_crinfo cptrel;
6156 mips_elf_set_cr_format (cptrel, CRF_MIPS_LONG);
6157 cptrel.vaddr = (rel->r_offset
6158 + input_section->output_section->vma
6159 + input_section->output_offset);
6160 if (r_type == R_MIPS_REL32)
6161 mips_elf_set_cr_type (cptrel, CRT_MIPS_REL32);
6163 mips_elf_set_cr_type (cptrel, CRT_MIPS_WORD);
6164 mips_elf_set_cr_dist2to (cptrel, 0);
6165 cptrel.konst = *addendp;
6167 cr = (scpt->contents
6168 + sizeof (Elf32_External_compact_rel));
6169 mips_elf_set_cr_relvaddr (cptrel, 0);
6170 bfd_elf32_swap_crinfo_out (output_bfd, &cptrel,
6171 ((Elf32_External_crinfo *) cr
6172 + scpt->reloc_count));
6173 ++scpt->reloc_count;
6177 /* If we've written this relocation for a readonly section,
6178 we need to set DF_TEXTREL again, so that we do not delete the
6180 if (MIPS_ELF_READONLY_SECTION (input_section))
6181 info->flags |= DF_TEXTREL;
6186 /* Return the MACH for a MIPS e_flags value. */
6189 _bfd_elf_mips_mach (flagword flags)
6191 switch (flags & EF_MIPS_MACH)
6193 case E_MIPS_MACH_3900:
6194 return bfd_mach_mips3900;
6196 case E_MIPS_MACH_4010:
6197 return bfd_mach_mips4010;
6199 case E_MIPS_MACH_4100:
6200 return bfd_mach_mips4100;
6202 case E_MIPS_MACH_4111:
6203 return bfd_mach_mips4111;
6205 case E_MIPS_MACH_4120:
6206 return bfd_mach_mips4120;
6208 case E_MIPS_MACH_4650:
6209 return bfd_mach_mips4650;
6211 case E_MIPS_MACH_5400:
6212 return bfd_mach_mips5400;
6214 case E_MIPS_MACH_5500:
6215 return bfd_mach_mips5500;
6217 case E_MIPS_MACH_5900:
6218 return bfd_mach_mips5900;
6220 case E_MIPS_MACH_9000:
6221 return bfd_mach_mips9000;
6223 case E_MIPS_MACH_SB1:
6224 return bfd_mach_mips_sb1;
6226 case E_MIPS_MACH_LS2E:
6227 return bfd_mach_mips_loongson_2e;
6229 case E_MIPS_MACH_LS2F:
6230 return bfd_mach_mips_loongson_2f;
6232 case E_MIPS_MACH_LS3A:
6233 return bfd_mach_mips_loongson_3a;
6235 case E_MIPS_MACH_OCTEON2:
6236 return bfd_mach_mips_octeon2;
6238 case E_MIPS_MACH_OCTEON:
6239 return bfd_mach_mips_octeon;
6241 case E_MIPS_MACH_XLR:
6242 return bfd_mach_mips_xlr;
6245 switch (flags & EF_MIPS_ARCH)
6249 return bfd_mach_mips3000;
6252 return bfd_mach_mips6000;
6255 return bfd_mach_mips4000;
6258 return bfd_mach_mips8000;
6261 return bfd_mach_mips5;
6263 case E_MIPS_ARCH_32:
6264 return bfd_mach_mipsisa32;
6266 case E_MIPS_ARCH_64:
6267 return bfd_mach_mipsisa64;
6269 case E_MIPS_ARCH_32R2:
6270 return bfd_mach_mipsisa32r2;
6272 case E_MIPS_ARCH_64R2:
6273 return bfd_mach_mipsisa64r2;
6280 /* Return printable name for ABI. */
6282 static INLINE char *
6283 elf_mips_abi_name (bfd *abfd)
6287 flags = elf_elfheader (abfd)->e_flags;
6288 switch (flags & EF_MIPS_ABI)
6291 if (ABI_N32_P (abfd))
6293 else if (ABI_64_P (abfd))
6297 case E_MIPS_ABI_O32:
6299 case E_MIPS_ABI_O64:
6301 case E_MIPS_ABI_EABI32:
6303 case E_MIPS_ABI_EABI64:
6306 return "unknown abi";
6310 /* MIPS ELF uses two common sections. One is the usual one, and the
6311 other is for small objects. All the small objects are kept
6312 together, and then referenced via the gp pointer, which yields
6313 faster assembler code. This is what we use for the small common
6314 section. This approach is copied from ecoff.c. */
6315 static asection mips_elf_scom_section;
6316 static asymbol mips_elf_scom_symbol;
6317 static asymbol *mips_elf_scom_symbol_ptr;
6319 /* MIPS ELF also uses an acommon section, which represents an
6320 allocated common symbol which may be overridden by a
6321 definition in a shared library. */
6322 static asection mips_elf_acom_section;
6323 static asymbol mips_elf_acom_symbol;
6324 static asymbol *mips_elf_acom_symbol_ptr;
6326 /* This is used for both the 32-bit and the 64-bit ABI. */
6329 _bfd_mips_elf_symbol_processing (bfd *abfd, asymbol *asym)
6331 elf_symbol_type *elfsym;
6333 /* Handle the special MIPS section numbers that a symbol may use. */
6334 elfsym = (elf_symbol_type *) asym;
6335 switch (elfsym->internal_elf_sym.st_shndx)
6337 case SHN_MIPS_ACOMMON:
6338 /* This section is used in a dynamically linked executable file.
6339 It is an allocated common section. The dynamic linker can
6340 either resolve these symbols to something in a shared
6341 library, or it can just leave them here. For our purposes,
6342 we can consider these symbols to be in a new section. */
6343 if (mips_elf_acom_section.name == NULL)
6345 /* Initialize the acommon section. */
6346 mips_elf_acom_section.name = ".acommon";
6347 mips_elf_acom_section.flags = SEC_ALLOC;
6348 mips_elf_acom_section.output_section = &mips_elf_acom_section;
6349 mips_elf_acom_section.symbol = &mips_elf_acom_symbol;
6350 mips_elf_acom_section.symbol_ptr_ptr = &mips_elf_acom_symbol_ptr;
6351 mips_elf_acom_symbol.name = ".acommon";
6352 mips_elf_acom_symbol.flags = BSF_SECTION_SYM;
6353 mips_elf_acom_symbol.section = &mips_elf_acom_section;
6354 mips_elf_acom_symbol_ptr = &mips_elf_acom_symbol;
6356 asym->section = &mips_elf_acom_section;
6360 /* Common symbols less than the GP size are automatically
6361 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
6362 if (asym->value > elf_gp_size (abfd)
6363 || ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_TLS
6364 || IRIX_COMPAT (abfd) == ict_irix6)
6367 case SHN_MIPS_SCOMMON:
6368 if (mips_elf_scom_section.name == NULL)
6370 /* Initialize the small common section. */
6371 mips_elf_scom_section.name = ".scommon";
6372 mips_elf_scom_section.flags = SEC_IS_COMMON;
6373 mips_elf_scom_section.output_section = &mips_elf_scom_section;
6374 mips_elf_scom_section.symbol = &mips_elf_scom_symbol;
6375 mips_elf_scom_section.symbol_ptr_ptr = &mips_elf_scom_symbol_ptr;
6376 mips_elf_scom_symbol.name = ".scommon";
6377 mips_elf_scom_symbol.flags = BSF_SECTION_SYM;
6378 mips_elf_scom_symbol.section = &mips_elf_scom_section;
6379 mips_elf_scom_symbol_ptr = &mips_elf_scom_symbol;
6381 asym->section = &mips_elf_scom_section;
6382 asym->value = elfsym->internal_elf_sym.st_size;
6385 case SHN_MIPS_SUNDEFINED:
6386 asym->section = bfd_und_section_ptr;
6391 asection *section = bfd_get_section_by_name (abfd, ".text");
6393 if (section != NULL)
6395 asym->section = section;
6396 /* MIPS_TEXT is a bit special, the address is not an offset
6397 to the base of the .text section. So substract the section
6398 base address to make it an offset. */
6399 asym->value -= section->vma;
6406 asection *section = bfd_get_section_by_name (abfd, ".data");
6408 if (section != NULL)
6410 asym->section = section;
6411 /* MIPS_DATA is a bit special, the address is not an offset
6412 to the base of the .data section. So substract the section
6413 base address to make it an offset. */
6414 asym->value -= section->vma;
6420 /* If this is an odd-valued function symbol, assume it's a MIPS16
6421 or microMIPS one. */
6422 if (ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_FUNC
6423 && (asym->value & 1) != 0)
6426 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
6427 elfsym->internal_elf_sym.st_other
6428 = ELF_ST_SET_MICROMIPS (elfsym->internal_elf_sym.st_other);
6430 elfsym->internal_elf_sym.st_other
6431 = ELF_ST_SET_MIPS16 (elfsym->internal_elf_sym.st_other);
6435 /* Implement elf_backend_eh_frame_address_size. This differs from
6436 the default in the way it handles EABI64.
6438 EABI64 was originally specified as an LP64 ABI, and that is what
6439 -mabi=eabi normally gives on a 64-bit target. However, gcc has
6440 historically accepted the combination of -mabi=eabi and -mlong32,
6441 and this ILP32 variation has become semi-official over time.
6442 Both forms use elf32 and have pointer-sized FDE addresses.
6444 If an EABI object was generated by GCC 4.0 or above, it will have
6445 an empty .gcc_compiled_longXX section, where XX is the size of longs
6446 in bits. Unfortunately, ILP32 objects generated by earlier compilers
6447 have no special marking to distinguish them from LP64 objects.
6449 We don't want users of the official LP64 ABI to be punished for the
6450 existence of the ILP32 variant, but at the same time, we don't want
6451 to mistakenly interpret pre-4.0 ILP32 objects as being LP64 objects.
6452 We therefore take the following approach:
6454 - If ABFD contains a .gcc_compiled_longXX section, use it to
6455 determine the pointer size.
6457 - Otherwise check the type of the first relocation. Assume that
6458 the LP64 ABI is being used if the relocation is of type R_MIPS_64.
6462 The second check is enough to detect LP64 objects generated by pre-4.0
6463 compilers because, in the kind of output generated by those compilers,
6464 the first relocation will be associated with either a CIE personality
6465 routine or an FDE start address. Furthermore, the compilers never
6466 used a special (non-pointer) encoding for this ABI.
6468 Checking the relocation type should also be safe because there is no
6469 reason to use R_MIPS_64 in an ILP32 object. Pre-4.0 compilers never
6473 _bfd_mips_elf_eh_frame_address_size (bfd *abfd, asection *sec)
6475 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
6477 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
6479 bfd_boolean long32_p, long64_p;
6481 long32_p = bfd_get_section_by_name (abfd, ".gcc_compiled_long32") != 0;
6482 long64_p = bfd_get_section_by_name (abfd, ".gcc_compiled_long64") != 0;
6483 if (long32_p && long64_p)
6490 if (sec->reloc_count > 0
6491 && elf_section_data (sec)->relocs != NULL
6492 && (ELF32_R_TYPE (elf_section_data (sec)->relocs[0].r_info)
6501 /* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
6502 relocations against two unnamed section symbols to resolve to the
6503 same address. For example, if we have code like:
6505 lw $4,%got_disp(.data)($gp)
6506 lw $25,%got_disp(.text)($gp)
6509 then the linker will resolve both relocations to .data and the program
6510 will jump there rather than to .text.
6512 We can work around this problem by giving names to local section symbols.
6513 This is also what the MIPSpro tools do. */
6516 _bfd_mips_elf_name_local_section_symbols (bfd *abfd)
6518 return SGI_COMPAT (abfd);
6521 /* Work over a section just before writing it out. This routine is
6522 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
6523 sections that need the SHF_MIPS_GPREL flag by name; there has to be
6527 _bfd_mips_elf_section_processing (bfd *abfd, Elf_Internal_Shdr *hdr)
6529 if (hdr->sh_type == SHT_MIPS_REGINFO
6530 && hdr->sh_size > 0)
6534 BFD_ASSERT (hdr->sh_size == sizeof (Elf32_External_RegInfo));
6535 BFD_ASSERT (hdr->contents == NULL);
6538 hdr->sh_offset + sizeof (Elf32_External_RegInfo) - 4,
6541 H_PUT_32 (abfd, elf_gp (abfd), buf);
6542 if (bfd_bwrite (buf, 4, abfd) != 4)
6546 if (hdr->sh_type == SHT_MIPS_OPTIONS
6547 && hdr->bfd_section != NULL
6548 && mips_elf_section_data (hdr->bfd_section) != NULL
6549 && mips_elf_section_data (hdr->bfd_section)->u.tdata != NULL)
6551 bfd_byte *contents, *l, *lend;
6553 /* We stored the section contents in the tdata field in the
6554 set_section_contents routine. We save the section contents
6555 so that we don't have to read them again.
6556 At this point we know that elf_gp is set, so we can look
6557 through the section contents to see if there is an
6558 ODK_REGINFO structure. */
6560 contents = mips_elf_section_data (hdr->bfd_section)->u.tdata;
6562 lend = contents + hdr->sh_size;
6563 while (l + sizeof (Elf_External_Options) <= lend)
6565 Elf_Internal_Options intopt;
6567 bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
6569 if (intopt.size < sizeof (Elf_External_Options))
6571 (*_bfd_error_handler)
6572 (_("%B: Warning: bad `%s' option size %u smaller than its header"),
6573 abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size);
6576 if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
6583 + sizeof (Elf_External_Options)
6584 + (sizeof (Elf64_External_RegInfo) - 8)),
6587 H_PUT_64 (abfd, elf_gp (abfd), buf);
6588 if (bfd_bwrite (buf, 8, abfd) != 8)
6591 else if (intopt.kind == ODK_REGINFO)
6598 + sizeof (Elf_External_Options)
6599 + (sizeof (Elf32_External_RegInfo) - 4)),
6602 H_PUT_32 (abfd, elf_gp (abfd), buf);
6603 if (bfd_bwrite (buf, 4, abfd) != 4)
6610 if (hdr->bfd_section != NULL)
6612 const char *name = bfd_get_section_name (abfd, hdr->bfd_section);
6614 /* .sbss is not handled specially here because the GNU/Linux
6615 prelinker can convert .sbss from NOBITS to PROGBITS and
6616 changing it back to NOBITS breaks the binary. The entry in
6617 _bfd_mips_elf_special_sections will ensure the correct flags
6618 are set on .sbss if BFD creates it without reading it from an
6619 input file, and without special handling here the flags set
6620 on it in an input file will be followed. */
6621 if (strcmp (name, ".sdata") == 0
6622 || strcmp (name, ".lit8") == 0
6623 || strcmp (name, ".lit4") == 0)
6625 hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
6626 hdr->sh_type = SHT_PROGBITS;
6628 else if (strcmp (name, ".srdata") == 0)
6630 hdr->sh_flags |= SHF_ALLOC | SHF_MIPS_GPREL;
6631 hdr->sh_type = SHT_PROGBITS;
6633 else if (strcmp (name, ".compact_rel") == 0)
6636 hdr->sh_type = SHT_PROGBITS;
6638 else if (strcmp (name, ".rtproc") == 0)
6640 if (hdr->sh_addralign != 0 && hdr->sh_entsize == 0)
6642 unsigned int adjust;
6644 adjust = hdr->sh_size % hdr->sh_addralign;
6646 hdr->sh_size += hdr->sh_addralign - adjust;
6654 /* Handle a MIPS specific section when reading an object file. This
6655 is called when elfcode.h finds a section with an unknown type.
6656 This routine supports both the 32-bit and 64-bit ELF ABI.
6658 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
6662 _bfd_mips_elf_section_from_shdr (bfd *abfd,
6663 Elf_Internal_Shdr *hdr,
6669 /* There ought to be a place to keep ELF backend specific flags, but
6670 at the moment there isn't one. We just keep track of the
6671 sections by their name, instead. Fortunately, the ABI gives
6672 suggested names for all the MIPS specific sections, so we will
6673 probably get away with this. */
6674 switch (hdr->sh_type)
6676 case SHT_MIPS_LIBLIST:
6677 if (strcmp (name, ".liblist") != 0)
6681 if (strcmp (name, ".msym") != 0)
6684 case SHT_MIPS_CONFLICT:
6685 if (strcmp (name, ".conflict") != 0)
6688 case SHT_MIPS_GPTAB:
6689 if (! CONST_STRNEQ (name, ".gptab."))
6692 case SHT_MIPS_UCODE:
6693 if (strcmp (name, ".ucode") != 0)
6696 case SHT_MIPS_DEBUG:
6697 if (strcmp (name, ".mdebug") != 0)
6699 flags = SEC_DEBUGGING;
6701 case SHT_MIPS_REGINFO:
6702 if (strcmp (name, ".reginfo") != 0
6703 || hdr->sh_size != sizeof (Elf32_External_RegInfo))
6705 flags = (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_SIZE);
6707 case SHT_MIPS_IFACE:
6708 if (strcmp (name, ".MIPS.interfaces") != 0)
6711 case SHT_MIPS_CONTENT:
6712 if (! CONST_STRNEQ (name, ".MIPS.content"))
6715 case SHT_MIPS_OPTIONS:
6716 if (!MIPS_ELF_OPTIONS_SECTION_NAME_P (name))
6719 case SHT_MIPS_DWARF:
6720 if (! CONST_STRNEQ (name, ".debug_")
6721 && ! CONST_STRNEQ (name, ".zdebug_"))
6724 case SHT_MIPS_SYMBOL_LIB:
6725 if (strcmp (name, ".MIPS.symlib") != 0)
6728 case SHT_MIPS_EVENTS:
6729 if (! CONST_STRNEQ (name, ".MIPS.events")
6730 && ! CONST_STRNEQ (name, ".MIPS.post_rel"))
6737 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
6742 if (! bfd_set_section_flags (abfd, hdr->bfd_section,
6743 (bfd_get_section_flags (abfd,
6749 /* FIXME: We should record sh_info for a .gptab section. */
6751 /* For a .reginfo section, set the gp value in the tdata information
6752 from the contents of this section. We need the gp value while
6753 processing relocs, so we just get it now. The .reginfo section
6754 is not used in the 64-bit MIPS ELF ABI. */
6755 if (hdr->sh_type == SHT_MIPS_REGINFO)
6757 Elf32_External_RegInfo ext;
6760 if (! bfd_get_section_contents (abfd, hdr->bfd_section,
6761 &ext, 0, sizeof ext))
6763 bfd_mips_elf32_swap_reginfo_in (abfd, &ext, &s);
6764 elf_gp (abfd) = s.ri_gp_value;
6767 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
6768 set the gp value based on what we find. We may see both
6769 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
6770 they should agree. */
6771 if (hdr->sh_type == SHT_MIPS_OPTIONS)
6773 bfd_byte *contents, *l, *lend;
6775 contents = bfd_malloc (hdr->sh_size);
6776 if (contents == NULL)
6778 if (! bfd_get_section_contents (abfd, hdr->bfd_section, contents,
6785 lend = contents + hdr->sh_size;
6786 while (l + sizeof (Elf_External_Options) <= lend)
6788 Elf_Internal_Options intopt;
6790 bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
6792 if (intopt.size < sizeof (Elf_External_Options))
6794 (*_bfd_error_handler)
6795 (_("%B: Warning: bad `%s' option size %u smaller than its header"),
6796 abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size);
6799 if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
6801 Elf64_Internal_RegInfo intreg;
6803 bfd_mips_elf64_swap_reginfo_in
6805 ((Elf64_External_RegInfo *)
6806 (l + sizeof (Elf_External_Options))),
6808 elf_gp (abfd) = intreg.ri_gp_value;
6810 else if (intopt.kind == ODK_REGINFO)
6812 Elf32_RegInfo intreg;
6814 bfd_mips_elf32_swap_reginfo_in
6816 ((Elf32_External_RegInfo *)
6817 (l + sizeof (Elf_External_Options))),
6819 elf_gp (abfd) = intreg.ri_gp_value;
6829 /* Set the correct type for a MIPS ELF section. We do this by the
6830 section name, which is a hack, but ought to work. This routine is
6831 used by both the 32-bit and the 64-bit ABI. */
6834 _bfd_mips_elf_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec)
6836 const char *name = bfd_get_section_name (abfd, sec);
6838 if (strcmp (name, ".liblist") == 0)
6840 hdr->sh_type = SHT_MIPS_LIBLIST;
6841 hdr->sh_info = sec->size / sizeof (Elf32_Lib);
6842 /* The sh_link field is set in final_write_processing. */
6844 else if (strcmp (name, ".conflict") == 0)
6845 hdr->sh_type = SHT_MIPS_CONFLICT;
6846 else if (CONST_STRNEQ (name, ".gptab."))
6848 hdr->sh_type = SHT_MIPS_GPTAB;
6849 hdr->sh_entsize = sizeof (Elf32_External_gptab);
6850 /* The sh_info field is set in final_write_processing. */
6852 else if (strcmp (name, ".ucode") == 0)
6853 hdr->sh_type = SHT_MIPS_UCODE;
6854 else if (strcmp (name, ".mdebug") == 0)
6856 hdr->sh_type = SHT_MIPS_DEBUG;
6857 /* In a shared object on IRIX 5.3, the .mdebug section has an
6858 entsize of 0. FIXME: Does this matter? */
6859 if (SGI_COMPAT (abfd) && (abfd->flags & DYNAMIC) != 0)
6860 hdr->sh_entsize = 0;
6862 hdr->sh_entsize = 1;
6864 else if (strcmp (name, ".reginfo") == 0)
6866 hdr->sh_type = SHT_MIPS_REGINFO;
6867 /* In a shared object on IRIX 5.3, the .reginfo section has an
6868 entsize of 0x18. FIXME: Does this matter? */
6869 if (SGI_COMPAT (abfd))
6871 if ((abfd->flags & DYNAMIC) != 0)
6872 hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
6874 hdr->sh_entsize = 1;
6877 hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
6879 else if (SGI_COMPAT (abfd)
6880 && (strcmp (name, ".hash") == 0
6881 || strcmp (name, ".dynamic") == 0
6882 || strcmp (name, ".dynstr") == 0))
6884 if (SGI_COMPAT (abfd))
6885 hdr->sh_entsize = 0;
6887 /* This isn't how the IRIX6 linker behaves. */
6888 hdr->sh_info = SIZEOF_MIPS_DYNSYM_SECNAMES;
6891 else if (strcmp (name, ".got") == 0
6892 || strcmp (name, ".srdata") == 0
6893 || strcmp (name, ".sdata") == 0
6894 || strcmp (name, ".sbss") == 0
6895 || strcmp (name, ".lit4") == 0
6896 || strcmp (name, ".lit8") == 0)
6897 hdr->sh_flags |= SHF_MIPS_GPREL;
6898 else if (strcmp (name, ".MIPS.interfaces") == 0)
6900 hdr->sh_type = SHT_MIPS_IFACE;
6901 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
6903 else if (CONST_STRNEQ (name, ".MIPS.content"))
6905 hdr->sh_type = SHT_MIPS_CONTENT;
6906 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
6907 /* The sh_info field is set in final_write_processing. */
6909 else if (MIPS_ELF_OPTIONS_SECTION_NAME_P (name))
6911 hdr->sh_type = SHT_MIPS_OPTIONS;
6912 hdr->sh_entsize = 1;
6913 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
6915 else if (CONST_STRNEQ (name, ".debug_")
6916 || CONST_STRNEQ (name, ".zdebug_"))
6918 hdr->sh_type = SHT_MIPS_DWARF;
6920 /* Irix facilities such as libexc expect a single .debug_frame
6921 per executable, the system ones have NOSTRIP set and the linker
6922 doesn't merge sections with different flags so ... */
6923 if (SGI_COMPAT (abfd) && CONST_STRNEQ (name, ".debug_frame"))
6924 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
6926 else if (strcmp (name, ".MIPS.symlib") == 0)
6928 hdr->sh_type = SHT_MIPS_SYMBOL_LIB;
6929 /* The sh_link and sh_info fields are set in
6930 final_write_processing. */
6932 else if (CONST_STRNEQ (name, ".MIPS.events")
6933 || CONST_STRNEQ (name, ".MIPS.post_rel"))
6935 hdr->sh_type = SHT_MIPS_EVENTS;
6936 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
6937 /* The sh_link field is set in final_write_processing. */
6939 else if (strcmp (name, ".msym") == 0)
6941 hdr->sh_type = SHT_MIPS_MSYM;
6942 hdr->sh_flags |= SHF_ALLOC;
6943 hdr->sh_entsize = 8;
6946 /* The generic elf_fake_sections will set up REL_HDR using the default
6947 kind of relocations. We used to set up a second header for the
6948 non-default kind of relocations here, but only NewABI would use
6949 these, and the IRIX ld doesn't like resulting empty RELA sections.
6950 Thus we create those header only on demand now. */
6955 /* Given a BFD section, try to locate the corresponding ELF section
6956 index. This is used by both the 32-bit and the 64-bit ABI.
6957 Actually, it's not clear to me that the 64-bit ABI supports these,
6958 but for non-PIC objects we will certainly want support for at least
6959 the .scommon section. */
6962 _bfd_mips_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
6963 asection *sec, int *retval)
6965 if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
6967 *retval = SHN_MIPS_SCOMMON;
6970 if (strcmp (bfd_get_section_name (abfd, sec), ".acommon") == 0)
6972 *retval = SHN_MIPS_ACOMMON;
6978 /* Hook called by the linker routine which adds symbols from an object
6979 file. We must handle the special MIPS section numbers here. */
6982 _bfd_mips_elf_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
6983 Elf_Internal_Sym *sym, const char **namep,
6984 flagword *flagsp ATTRIBUTE_UNUSED,
6985 asection **secp, bfd_vma *valp)
6987 if (SGI_COMPAT (abfd)
6988 && (abfd->flags & DYNAMIC) != 0
6989 && strcmp (*namep, "_rld_new_interface") == 0)
6991 /* Skip IRIX5 rld entry name. */
6996 /* Shared objects may have a dynamic symbol '_gp_disp' defined as
6997 a SECTION *ABS*. This causes ld to think it can resolve _gp_disp
6998 by setting a DT_NEEDED for the shared object. Since _gp_disp is
6999 a magic symbol resolved by the linker, we ignore this bogus definition
7000 of _gp_disp. New ABI objects do not suffer from this problem so this
7001 is not done for them. */
7003 && (sym->st_shndx == SHN_ABS)
7004 && (strcmp (*namep, "_gp_disp") == 0))
7010 switch (sym->st_shndx)
7013 /* Common symbols less than the GP size are automatically
7014 treated as SHN_MIPS_SCOMMON symbols. */
7015 if (sym->st_size > elf_gp_size (abfd)
7016 || ELF_ST_TYPE (sym->st_info) == STT_TLS
7017 || IRIX_COMPAT (abfd) == ict_irix6)
7020 case SHN_MIPS_SCOMMON:
7021 *secp = bfd_make_section_old_way (abfd, ".scommon");
7022 (*secp)->flags |= SEC_IS_COMMON;
7023 *valp = sym->st_size;
7027 /* This section is used in a shared object. */
7028 if (elf_tdata (abfd)->elf_text_section == NULL)
7030 asymbol *elf_text_symbol;
7031 asection *elf_text_section;
7032 bfd_size_type amt = sizeof (asection);
7034 elf_text_section = bfd_zalloc (abfd, amt);
7035 if (elf_text_section == NULL)
7038 amt = sizeof (asymbol);
7039 elf_text_symbol = bfd_zalloc (abfd, amt);
7040 if (elf_text_symbol == NULL)
7043 /* Initialize the section. */
7045 elf_tdata (abfd)->elf_text_section = elf_text_section;
7046 elf_tdata (abfd)->elf_text_symbol = elf_text_symbol;
7048 elf_text_section->symbol = elf_text_symbol;
7049 elf_text_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_text_symbol;
7051 elf_text_section->name = ".text";
7052 elf_text_section->flags = SEC_NO_FLAGS;
7053 elf_text_section->output_section = NULL;
7054 elf_text_section->owner = abfd;
7055 elf_text_symbol->name = ".text";
7056 elf_text_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
7057 elf_text_symbol->section = elf_text_section;
7059 /* This code used to do *secp = bfd_und_section_ptr if
7060 info->shared. I don't know why, and that doesn't make sense,
7061 so I took it out. */
7062 *secp = elf_tdata (abfd)->elf_text_section;
7065 case SHN_MIPS_ACOMMON:
7066 /* Fall through. XXX Can we treat this as allocated data? */
7068 /* This section is used in a shared object. */
7069 if (elf_tdata (abfd)->elf_data_section == NULL)
7071 asymbol *elf_data_symbol;
7072 asection *elf_data_section;
7073 bfd_size_type amt = sizeof (asection);
7075 elf_data_section = bfd_zalloc (abfd, amt);
7076 if (elf_data_section == NULL)
7079 amt = sizeof (asymbol);
7080 elf_data_symbol = bfd_zalloc (abfd, amt);
7081 if (elf_data_symbol == NULL)
7084 /* Initialize the section. */
7086 elf_tdata (abfd)->elf_data_section = elf_data_section;
7087 elf_tdata (abfd)->elf_data_symbol = elf_data_symbol;
7089 elf_data_section->symbol = elf_data_symbol;
7090 elf_data_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_data_symbol;
7092 elf_data_section->name = ".data";
7093 elf_data_section->flags = SEC_NO_FLAGS;
7094 elf_data_section->output_section = NULL;
7095 elf_data_section->owner = abfd;
7096 elf_data_symbol->name = ".data";
7097 elf_data_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
7098 elf_data_symbol->section = elf_data_section;
7100 /* This code used to do *secp = bfd_und_section_ptr if
7101 info->shared. I don't know why, and that doesn't make sense,
7102 so I took it out. */
7103 *secp = elf_tdata (abfd)->elf_data_section;
7106 case SHN_MIPS_SUNDEFINED:
7107 *secp = bfd_und_section_ptr;
7111 if (SGI_COMPAT (abfd)
7113 && info->output_bfd->xvec == abfd->xvec
7114 && strcmp (*namep, "__rld_obj_head") == 0)
7116 struct elf_link_hash_entry *h;
7117 struct bfd_link_hash_entry *bh;
7119 /* Mark __rld_obj_head as dynamic. */
7121 if (! (_bfd_generic_link_add_one_symbol
7122 (info, abfd, *namep, BSF_GLOBAL, *secp, *valp, NULL, FALSE,
7123 get_elf_backend_data (abfd)->collect, &bh)))
7126 h = (struct elf_link_hash_entry *) bh;
7129 h->type = STT_OBJECT;
7131 if (! bfd_elf_link_record_dynamic_symbol (info, h))
7134 mips_elf_hash_table (info)->use_rld_obj_head = TRUE;
7135 mips_elf_hash_table (info)->rld_symbol = h;
7138 /* If this is a mips16 text symbol, add 1 to the value to make it
7139 odd. This will cause something like .word SYM to come up with
7140 the right value when it is loaded into the PC. */
7141 if (ELF_ST_IS_COMPRESSED (sym->st_other))
7147 /* This hook function is called before the linker writes out a global
7148 symbol. We mark symbols as small common if appropriate. This is
7149 also where we undo the increment of the value for a mips16 symbol. */
7152 _bfd_mips_elf_link_output_symbol_hook
7153 (struct bfd_link_info *info ATTRIBUTE_UNUSED,
7154 const char *name ATTRIBUTE_UNUSED, Elf_Internal_Sym *sym,
7155 asection *input_sec, struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
7157 /* If we see a common symbol, which implies a relocatable link, then
7158 if a symbol was small common in an input file, mark it as small
7159 common in the output file. */
7160 if (sym->st_shndx == SHN_COMMON
7161 && strcmp (input_sec->name, ".scommon") == 0)
7162 sym->st_shndx = SHN_MIPS_SCOMMON;
7164 if (ELF_ST_IS_COMPRESSED (sym->st_other))
7165 sym->st_value &= ~1;
7170 /* Functions for the dynamic linker. */
7172 /* Create dynamic sections when linking against a dynamic object. */
7175 _bfd_mips_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
7177 struct elf_link_hash_entry *h;
7178 struct bfd_link_hash_entry *bh;
7180 register asection *s;
7181 const char * const *namep;
7182 struct mips_elf_link_hash_table *htab;
7184 htab = mips_elf_hash_table (info);
7185 BFD_ASSERT (htab != NULL);
7187 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
7188 | SEC_LINKER_CREATED | SEC_READONLY);
7190 /* The psABI requires a read-only .dynamic section, but the VxWorks
7192 if (!htab->is_vxworks)
7194 s = bfd_get_linker_section (abfd, ".dynamic");
7197 if (! bfd_set_section_flags (abfd, s, flags))
7202 /* We need to create .got section. */
7203 if (!mips_elf_create_got_section (abfd, info))
7206 if (! mips_elf_rel_dyn_section (info, TRUE))
7209 /* Create .stub section. */
7210 s = bfd_make_section_anyway_with_flags (abfd,
7211 MIPS_ELF_STUB_SECTION_NAME (abfd),
7214 || ! bfd_set_section_alignment (abfd, s,
7215 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
7219 if (!mips_elf_hash_table (info)->use_rld_obj_head
7221 && bfd_get_linker_section (abfd, ".rld_map") == NULL)
7223 s = bfd_make_section_anyway_with_flags (abfd, ".rld_map",
7224 flags &~ (flagword) SEC_READONLY);
7226 || ! bfd_set_section_alignment (abfd, s,
7227 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
7231 /* On IRIX5, we adjust add some additional symbols and change the
7232 alignments of several sections. There is no ABI documentation
7233 indicating that this is necessary on IRIX6, nor any evidence that
7234 the linker takes such action. */
7235 if (IRIX_COMPAT (abfd) == ict_irix5)
7237 for (namep = mips_elf_dynsym_rtproc_names; *namep != NULL; namep++)
7240 if (! (_bfd_generic_link_add_one_symbol
7241 (info, abfd, *namep, BSF_GLOBAL, bfd_und_section_ptr, 0,
7242 NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
7245 h = (struct elf_link_hash_entry *) bh;
7248 h->type = STT_SECTION;
7250 if (! bfd_elf_link_record_dynamic_symbol (info, h))
7254 /* We need to create a .compact_rel section. */
7255 if (SGI_COMPAT (abfd))
7257 if (!mips_elf_create_compact_rel_section (abfd, info))
7261 /* Change alignments of some sections. */
7262 s = bfd_get_linker_section (abfd, ".hash");
7264 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7265 s = bfd_get_linker_section (abfd, ".dynsym");
7267 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7268 s = bfd_get_linker_section (abfd, ".dynstr");
7270 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7272 s = bfd_get_section_by_name (abfd, ".reginfo");
7274 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7275 s = bfd_get_linker_section (abfd, ".dynamic");
7277 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7284 name = SGI_COMPAT (abfd) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
7286 if (!(_bfd_generic_link_add_one_symbol
7287 (info, abfd, name, BSF_GLOBAL, bfd_abs_section_ptr, 0,
7288 NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
7291 h = (struct elf_link_hash_entry *) bh;
7294 h->type = STT_SECTION;
7296 if (! bfd_elf_link_record_dynamic_symbol (info, h))
7299 if (! mips_elf_hash_table (info)->use_rld_obj_head)
7301 /* __rld_map is a four byte word located in the .data section
7302 and is filled in by the rtld to contain a pointer to
7303 the _r_debug structure. Its symbol value will be set in
7304 _bfd_mips_elf_finish_dynamic_symbol. */
7305 s = bfd_get_linker_section (abfd, ".rld_map");
7306 BFD_ASSERT (s != NULL);
7308 name = SGI_COMPAT (abfd) ? "__rld_map" : "__RLD_MAP";
7310 if (!(_bfd_generic_link_add_one_symbol
7311 (info, abfd, name, BSF_GLOBAL, s, 0, NULL, FALSE,
7312 get_elf_backend_data (abfd)->collect, &bh)))
7315 h = (struct elf_link_hash_entry *) bh;
7318 h->type = STT_OBJECT;
7320 if (! bfd_elf_link_record_dynamic_symbol (info, h))
7322 mips_elf_hash_table (info)->rld_symbol = h;
7326 /* Create the .plt, .rel(a).plt, .dynbss and .rel(a).bss sections.
7327 Also create the _PROCEDURE_LINKAGE_TABLE symbol. */
7328 if (!_bfd_elf_create_dynamic_sections (abfd, info))
7331 /* Cache the sections created above. */
7332 htab->splt = bfd_get_linker_section (abfd, ".plt");
7333 htab->sdynbss = bfd_get_linker_section (abfd, ".dynbss");
7334 if (htab->is_vxworks)
7336 htab->srelbss = bfd_get_linker_section (abfd, ".rela.bss");
7337 htab->srelplt = bfd_get_linker_section (abfd, ".rela.plt");
7340 htab->srelplt = bfd_get_linker_section (abfd, ".rel.plt");
7342 || (htab->is_vxworks && !htab->srelbss && !info->shared)
7347 if (htab->is_vxworks)
7349 /* Do the usual VxWorks handling. */
7350 if (!elf_vxworks_create_dynamic_sections (abfd, info, &htab->srelplt2))
7353 /* Work out the PLT sizes. */
7356 htab->plt_header_size
7357 = 4 * ARRAY_SIZE (mips_vxworks_shared_plt0_entry);
7358 htab->plt_entry_size
7359 = 4 * ARRAY_SIZE (mips_vxworks_shared_plt_entry);
7363 htab->plt_header_size
7364 = 4 * ARRAY_SIZE (mips_vxworks_exec_plt0_entry);
7365 htab->plt_entry_size
7366 = 4 * ARRAY_SIZE (mips_vxworks_exec_plt_entry);
7369 else if (!info->shared)
7371 /* All variants of the plt0 entry are the same size. */
7372 htab->plt_header_size = 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry);
7373 htab->plt_entry_size = 4 * ARRAY_SIZE (mips_exec_plt_entry);
7379 /* Return true if relocation REL against section SEC is a REL rather than
7380 RELA relocation. RELOCS is the first relocation in the section and
7381 ABFD is the bfd that contains SEC. */
7384 mips_elf_rel_relocation_p (bfd *abfd, asection *sec,
7385 const Elf_Internal_Rela *relocs,
7386 const Elf_Internal_Rela *rel)
7388 Elf_Internal_Shdr *rel_hdr;
7389 const struct elf_backend_data *bed;
7391 /* To determine which flavor of relocation this is, we depend on the
7392 fact that the INPUT_SECTION's REL_HDR is read before RELA_HDR. */
7393 rel_hdr = elf_section_data (sec)->rel.hdr;
7394 if (rel_hdr == NULL)
7396 bed = get_elf_backend_data (abfd);
7397 return ((size_t) (rel - relocs)
7398 < NUM_SHDR_ENTRIES (rel_hdr) * bed->s->int_rels_per_ext_rel);
7401 /* Read the addend for REL relocation REL, which belongs to bfd ABFD.
7402 HOWTO is the relocation's howto and CONTENTS points to the contents
7403 of the section that REL is against. */
7406 mips_elf_read_rel_addend (bfd *abfd, const Elf_Internal_Rela *rel,
7407 reloc_howto_type *howto, bfd_byte *contents)
7410 unsigned int r_type;
7413 r_type = ELF_R_TYPE (abfd, rel->r_info);
7414 location = contents + rel->r_offset;
7416 /* Get the addend, which is stored in the input file. */
7417 _bfd_mips_elf_reloc_unshuffle (abfd, r_type, FALSE, location);
7418 addend = mips_elf_obtain_contents (howto, rel, abfd, contents);
7419 _bfd_mips_elf_reloc_shuffle (abfd, r_type, FALSE, location);
7421 return addend & howto->src_mask;
7424 /* REL is a relocation in ABFD that needs a partnering LO16 relocation
7425 and *ADDEND is the addend for REL itself. Look for the LO16 relocation
7426 and update *ADDEND with the final addend. Return true on success
7427 or false if the LO16 could not be found. RELEND is the exclusive
7428 upper bound on the relocations for REL's section. */
7431 mips_elf_add_lo16_rel_addend (bfd *abfd,
7432 const Elf_Internal_Rela *rel,
7433 const Elf_Internal_Rela *relend,
7434 bfd_byte *contents, bfd_vma *addend)
7436 unsigned int r_type, lo16_type;
7437 const Elf_Internal_Rela *lo16_relocation;
7438 reloc_howto_type *lo16_howto;
7441 r_type = ELF_R_TYPE (abfd, rel->r_info);
7442 if (mips16_reloc_p (r_type))
7443 lo16_type = R_MIPS16_LO16;
7444 else if (micromips_reloc_p (r_type))
7445 lo16_type = R_MICROMIPS_LO16;
7447 lo16_type = R_MIPS_LO16;
7449 /* The combined value is the sum of the HI16 addend, left-shifted by
7450 sixteen bits, and the LO16 addend, sign extended. (Usually, the
7451 code does a `lui' of the HI16 value, and then an `addiu' of the
7454 Scan ahead to find a matching LO16 relocation.
7456 According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must
7457 be immediately following. However, for the IRIX6 ABI, the next
7458 relocation may be a composed relocation consisting of several
7459 relocations for the same address. In that case, the R_MIPS_LO16
7460 relocation may occur as one of these. We permit a similar
7461 extension in general, as that is useful for GCC.
7463 In some cases GCC dead code elimination removes the LO16 but keeps
7464 the corresponding HI16. This is strictly speaking a violation of
7465 the ABI but not immediately harmful. */
7466 lo16_relocation = mips_elf_next_relocation (abfd, lo16_type, rel, relend);
7467 if (lo16_relocation == NULL)
7470 /* Obtain the addend kept there. */
7471 lo16_howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, lo16_type, FALSE);
7472 l = mips_elf_read_rel_addend (abfd, lo16_relocation, lo16_howto, contents);
7474 l <<= lo16_howto->rightshift;
7475 l = _bfd_mips_elf_sign_extend (l, 16);
7482 /* Try to read the contents of section SEC in bfd ABFD. Return true and
7483 store the contents in *CONTENTS on success. Assume that *CONTENTS
7484 already holds the contents if it is nonull on entry. */
7487 mips_elf_get_section_contents (bfd *abfd, asection *sec, bfd_byte **contents)
7492 /* Get cached copy if it exists. */
7493 if (elf_section_data (sec)->this_hdr.contents != NULL)
7495 *contents = elf_section_data (sec)->this_hdr.contents;
7499 return bfd_malloc_and_get_section (abfd, sec, contents);
7502 /* Look through the relocs for a section during the first phase, and
7503 allocate space in the global offset table. */
7506 _bfd_mips_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
7507 asection *sec, const Elf_Internal_Rela *relocs)
7511 Elf_Internal_Shdr *symtab_hdr;
7512 struct elf_link_hash_entry **sym_hashes;
7514 const Elf_Internal_Rela *rel;
7515 const Elf_Internal_Rela *rel_end;
7517 const struct elf_backend_data *bed;
7518 struct mips_elf_link_hash_table *htab;
7521 reloc_howto_type *howto;
7523 if (info->relocatable)
7526 htab = mips_elf_hash_table (info);
7527 BFD_ASSERT (htab != NULL);
7529 dynobj = elf_hash_table (info)->dynobj;
7530 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7531 sym_hashes = elf_sym_hashes (abfd);
7532 extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
7534 bed = get_elf_backend_data (abfd);
7535 rel_end = relocs + sec->reloc_count * bed->s->int_rels_per_ext_rel;
7537 /* Check for the mips16 stub sections. */
7539 name = bfd_get_section_name (abfd, sec);
7540 if (FN_STUB_P (name))
7542 unsigned long r_symndx;
7544 /* Look at the relocation information to figure out which symbol
7547 r_symndx = mips16_stub_symndx (bed, sec, relocs, rel_end);
7550 (*_bfd_error_handler)
7551 (_("%B: Warning: cannot determine the target function for"
7552 " stub section `%s'"),
7554 bfd_set_error (bfd_error_bad_value);
7558 if (r_symndx < extsymoff
7559 || sym_hashes[r_symndx - extsymoff] == NULL)
7563 /* This stub is for a local symbol. This stub will only be
7564 needed if there is some relocation in this BFD, other
7565 than a 16 bit function call, which refers to this symbol. */
7566 for (o = abfd->sections; o != NULL; o = o->next)
7568 Elf_Internal_Rela *sec_relocs;
7569 const Elf_Internal_Rela *r, *rend;
7571 /* We can ignore stub sections when looking for relocs. */
7572 if ((o->flags & SEC_RELOC) == 0
7573 || o->reloc_count == 0
7574 || section_allows_mips16_refs_p (o))
7578 = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
7580 if (sec_relocs == NULL)
7583 rend = sec_relocs + o->reloc_count;
7584 for (r = sec_relocs; r < rend; r++)
7585 if (ELF_R_SYM (abfd, r->r_info) == r_symndx
7586 && !mips16_call_reloc_p (ELF_R_TYPE (abfd, r->r_info)))
7589 if (elf_section_data (o)->relocs != sec_relocs)
7598 /* There is no non-call reloc for this stub, so we do
7599 not need it. Since this function is called before
7600 the linker maps input sections to output sections, we
7601 can easily discard it by setting the SEC_EXCLUDE
7603 sec->flags |= SEC_EXCLUDE;
7607 /* Record this stub in an array of local symbol stubs for
7609 if (elf_tdata (abfd)->local_stubs == NULL)
7611 unsigned long symcount;
7615 if (elf_bad_symtab (abfd))
7616 symcount = NUM_SHDR_ENTRIES (symtab_hdr);
7618 symcount = symtab_hdr->sh_info;
7619 amt = symcount * sizeof (asection *);
7620 n = bfd_zalloc (abfd, amt);
7623 elf_tdata (abfd)->local_stubs = n;
7626 sec->flags |= SEC_KEEP;
7627 elf_tdata (abfd)->local_stubs[r_symndx] = sec;
7629 /* We don't need to set mips16_stubs_seen in this case.
7630 That flag is used to see whether we need to look through
7631 the global symbol table for stubs. We don't need to set
7632 it here, because we just have a local stub. */
7636 struct mips_elf_link_hash_entry *h;
7638 h = ((struct mips_elf_link_hash_entry *)
7639 sym_hashes[r_symndx - extsymoff]);
7641 while (h->root.root.type == bfd_link_hash_indirect
7642 || h->root.root.type == bfd_link_hash_warning)
7643 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
7645 /* H is the symbol this stub is for. */
7647 /* If we already have an appropriate stub for this function, we
7648 don't need another one, so we can discard this one. Since
7649 this function is called before the linker maps input sections
7650 to output sections, we can easily discard it by setting the
7651 SEC_EXCLUDE flag. */
7652 if (h->fn_stub != NULL)
7654 sec->flags |= SEC_EXCLUDE;
7658 sec->flags |= SEC_KEEP;
7660 mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
7663 else if (CALL_STUB_P (name) || CALL_FP_STUB_P (name))
7665 unsigned long r_symndx;
7666 struct mips_elf_link_hash_entry *h;
7669 /* Look at the relocation information to figure out which symbol
7672 r_symndx = mips16_stub_symndx (bed, sec, relocs, rel_end);
7675 (*_bfd_error_handler)
7676 (_("%B: Warning: cannot determine the target function for"
7677 " stub section `%s'"),
7679 bfd_set_error (bfd_error_bad_value);
7683 if (r_symndx < extsymoff
7684 || sym_hashes[r_symndx - extsymoff] == NULL)
7688 /* This stub is for a local symbol. This stub will only be
7689 needed if there is some relocation (R_MIPS16_26) in this BFD
7690 that refers to this symbol. */
7691 for (o = abfd->sections; o != NULL; o = o->next)
7693 Elf_Internal_Rela *sec_relocs;
7694 const Elf_Internal_Rela *r, *rend;
7696 /* We can ignore stub sections when looking for relocs. */
7697 if ((o->flags & SEC_RELOC) == 0
7698 || o->reloc_count == 0
7699 || section_allows_mips16_refs_p (o))
7703 = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
7705 if (sec_relocs == NULL)
7708 rend = sec_relocs + o->reloc_count;
7709 for (r = sec_relocs; r < rend; r++)
7710 if (ELF_R_SYM (abfd, r->r_info) == r_symndx
7711 && ELF_R_TYPE (abfd, r->r_info) == R_MIPS16_26)
7714 if (elf_section_data (o)->relocs != sec_relocs)
7723 /* There is no non-call reloc for this stub, so we do
7724 not need it. Since this function is called before
7725 the linker maps input sections to output sections, we
7726 can easily discard it by setting the SEC_EXCLUDE
7728 sec->flags |= SEC_EXCLUDE;
7732 /* Record this stub in an array of local symbol call_stubs for
7734 if (elf_tdata (abfd)->local_call_stubs == NULL)
7736 unsigned long symcount;
7740 if (elf_bad_symtab (abfd))
7741 symcount = NUM_SHDR_ENTRIES (symtab_hdr);
7743 symcount = symtab_hdr->sh_info;
7744 amt = symcount * sizeof (asection *);
7745 n = bfd_zalloc (abfd, amt);
7748 elf_tdata (abfd)->local_call_stubs = n;
7751 sec->flags |= SEC_KEEP;
7752 elf_tdata (abfd)->local_call_stubs[r_symndx] = sec;
7754 /* We don't need to set mips16_stubs_seen in this case.
7755 That flag is used to see whether we need to look through
7756 the global symbol table for stubs. We don't need to set
7757 it here, because we just have a local stub. */
7761 h = ((struct mips_elf_link_hash_entry *)
7762 sym_hashes[r_symndx - extsymoff]);
7764 /* H is the symbol this stub is for. */
7766 if (CALL_FP_STUB_P (name))
7767 loc = &h->call_fp_stub;
7769 loc = &h->call_stub;
7771 /* If we already have an appropriate stub for this function, we
7772 don't need another one, so we can discard this one. Since
7773 this function is called before the linker maps input sections
7774 to output sections, we can easily discard it by setting the
7775 SEC_EXCLUDE flag. */
7778 sec->flags |= SEC_EXCLUDE;
7782 sec->flags |= SEC_KEEP;
7784 mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
7790 for (rel = relocs; rel < rel_end; ++rel)
7792 unsigned long r_symndx;
7793 unsigned int r_type;
7794 struct elf_link_hash_entry *h;
7795 bfd_boolean can_make_dynamic_p;
7797 r_symndx = ELF_R_SYM (abfd, rel->r_info);
7798 r_type = ELF_R_TYPE (abfd, rel->r_info);
7800 if (r_symndx < extsymoff)
7802 else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
7804 (*_bfd_error_handler)
7805 (_("%B: Malformed reloc detected for section %s"),
7807 bfd_set_error (bfd_error_bad_value);
7812 h = sym_hashes[r_symndx - extsymoff];
7814 && (h->root.type == bfd_link_hash_indirect
7815 || h->root.type == bfd_link_hash_warning))
7816 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7819 /* Set CAN_MAKE_DYNAMIC_P to true if we can convert this
7820 relocation into a dynamic one. */
7821 can_make_dynamic_p = FALSE;
7826 case R_MIPS_CALL_HI16:
7827 case R_MIPS_CALL_LO16:
7828 case R_MIPS_GOT_HI16:
7829 case R_MIPS_GOT_LO16:
7830 case R_MIPS_GOT_PAGE:
7831 case R_MIPS_GOT_OFST:
7832 case R_MIPS_GOT_DISP:
7833 case R_MIPS_TLS_GOTTPREL:
7835 case R_MIPS_TLS_LDM:
7836 case R_MIPS16_GOT16:
7837 case R_MIPS16_CALL16:
7838 case R_MIPS16_TLS_GOTTPREL:
7839 case R_MIPS16_TLS_GD:
7840 case R_MIPS16_TLS_LDM:
7841 case R_MICROMIPS_GOT16:
7842 case R_MICROMIPS_CALL16:
7843 case R_MICROMIPS_CALL_HI16:
7844 case R_MICROMIPS_CALL_LO16:
7845 case R_MICROMIPS_GOT_HI16:
7846 case R_MICROMIPS_GOT_LO16:
7847 case R_MICROMIPS_GOT_PAGE:
7848 case R_MICROMIPS_GOT_OFST:
7849 case R_MICROMIPS_GOT_DISP:
7850 case R_MICROMIPS_TLS_GOTTPREL:
7851 case R_MICROMIPS_TLS_GD:
7852 case R_MICROMIPS_TLS_LDM:
7854 elf_hash_table (info)->dynobj = dynobj = abfd;
7855 if (!mips_elf_create_got_section (dynobj, info))
7857 if (htab->is_vxworks && !info->shared)
7859 (*_bfd_error_handler)
7860 (_("%B: GOT reloc at 0x%lx not expected in executables"),
7861 abfd, (unsigned long) rel->r_offset);
7862 bfd_set_error (bfd_error_bad_value);
7867 /* This is just a hint; it can safely be ignored. Don't set
7868 has_static_relocs for the corresponding symbol. */
7870 case R_MICROMIPS_JALR:
7876 /* In VxWorks executables, references to external symbols
7877 must be handled using copy relocs or PLT entries; it is not
7878 possible to convert this relocation into a dynamic one.
7880 For executables that use PLTs and copy-relocs, we have a
7881 choice between converting the relocation into a dynamic
7882 one or using copy relocations or PLT entries. It is
7883 usually better to do the former, unless the relocation is
7884 against a read-only section. */
7887 && !htab->is_vxworks
7888 && strcmp (h->root.root.string, "__gnu_local_gp") != 0
7889 && !(!info->nocopyreloc
7890 && !PIC_OBJECT_P (abfd)
7891 && MIPS_ELF_READONLY_SECTION (sec))))
7892 && (sec->flags & SEC_ALLOC) != 0)
7894 can_make_dynamic_p = TRUE;
7896 elf_hash_table (info)->dynobj = dynobj = abfd;
7899 /* For sections that are not SEC_ALLOC a copy reloc would be
7900 output if possible (implying questionable semantics for
7901 read-only data objects) or otherwise the final link would
7902 fail as ld.so will not process them and could not therefore
7903 handle any outstanding dynamic relocations.
7905 For such sections that are also SEC_DEBUGGING, we can avoid
7906 these problems by simply ignoring any relocs as these
7907 sections have a predefined use and we know it is safe to do
7910 This is needed in cases such as a global symbol definition
7911 in a shared library causing a common symbol from an object
7912 file to be converted to an undefined reference. If that
7913 happens, then all the relocations against this symbol from
7914 SEC_DEBUGGING sections in the object file will resolve to
7916 if ((sec->flags & SEC_DEBUGGING) != 0)
7921 /* Most static relocations require pointer equality, except
7924 h->pointer_equality_needed = TRUE;
7930 case R_MICROMIPS_26_S1:
7931 case R_MICROMIPS_PC7_S1:
7932 case R_MICROMIPS_PC10_S1:
7933 case R_MICROMIPS_PC16_S1:
7934 case R_MICROMIPS_PC23_S2:
7936 ((struct mips_elf_link_hash_entry *) h)->has_static_relocs = TRUE;
7942 /* Relocations against the special VxWorks __GOTT_BASE__ and
7943 __GOTT_INDEX__ symbols must be left to the loader. Allocate
7944 room for them in .rela.dyn. */
7945 if (is_gott_symbol (info, h))
7949 sreloc = mips_elf_rel_dyn_section (info, TRUE);
7953 mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
7954 if (MIPS_ELF_READONLY_SECTION (sec))
7955 /* We tell the dynamic linker that there are
7956 relocations against the text segment. */
7957 info->flags |= DF_TEXTREL;
7960 else if (call_lo16_reloc_p (r_type)
7961 || got_lo16_reloc_p (r_type)
7962 || got_disp_reloc_p (r_type)
7963 || (got16_reloc_p (r_type) && htab->is_vxworks))
7965 /* We may need a local GOT entry for this relocation. We
7966 don't count R_MIPS_GOT_PAGE because we can estimate the
7967 maximum number of pages needed by looking at the size of
7968 the segment. Similar comments apply to R_MIPS*_GOT16 and
7969 R_MIPS*_CALL16, except on VxWorks, where GOT relocations
7970 always evaluate to "G". We don't count R_MIPS_GOT_HI16, or
7971 R_MIPS_CALL_HI16 because these are always followed by an
7972 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
7973 if (!mips_elf_record_local_got_symbol (abfd, r_symndx,
7974 rel->r_addend, info, r_type))
7979 && mips_elf_relocation_needs_la25_stub (abfd, r_type,
7980 ELF_ST_IS_MIPS16 (h->other)))
7981 ((struct mips_elf_link_hash_entry *) h)->has_nonpic_branches = TRUE;
7986 case R_MIPS16_CALL16:
7987 case R_MICROMIPS_CALL16:
7990 (*_bfd_error_handler)
7991 (_("%B: CALL16 reloc at 0x%lx not against global symbol"),
7992 abfd, (unsigned long) rel->r_offset);
7993 bfd_set_error (bfd_error_bad_value);
7998 case R_MIPS_CALL_HI16:
7999 case R_MIPS_CALL_LO16:
8000 case R_MICROMIPS_CALL_HI16:
8001 case R_MICROMIPS_CALL_LO16:
8004 /* Make sure there is room in the regular GOT to hold the
8005 function's address. We may eliminate it in favour of
8006 a .got.plt entry later; see mips_elf_count_got_symbols. */
8007 if (!mips_elf_record_global_got_symbol (h, abfd, info, TRUE,
8011 /* We need a stub, not a plt entry for the undefined
8012 function. But we record it as if it needs plt. See
8013 _bfd_elf_adjust_dynamic_symbol. */
8019 case R_MIPS_GOT_PAGE:
8020 case R_MICROMIPS_GOT_PAGE:
8021 /* If this is a global, overridable symbol, GOT_PAGE will
8022 decay to GOT_DISP, so we'll need a GOT entry for it. */
8025 struct mips_elf_link_hash_entry *hmips =
8026 (struct mips_elf_link_hash_entry *) h;
8028 /* This symbol is definitely not overridable. */
8029 if (hmips->root.def_regular
8030 && ! (info->shared && ! info->symbolic
8031 && ! hmips->root.forced_local))
8036 case R_MIPS16_GOT16:
8038 case R_MIPS_GOT_HI16:
8039 case R_MIPS_GOT_LO16:
8040 case R_MICROMIPS_GOT16:
8041 case R_MICROMIPS_GOT_HI16:
8042 case R_MICROMIPS_GOT_LO16:
8043 if (!h || got_page_reloc_p (r_type))
8045 /* This relocation needs (or may need, if h != NULL) a
8046 page entry in the GOT. For R_MIPS_GOT_PAGE we do not
8047 know for sure until we know whether the symbol is
8049 if (mips_elf_rel_relocation_p (abfd, sec, relocs, rel))
8051 if (!mips_elf_get_section_contents (abfd, sec, &contents))
8053 howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, r_type, FALSE);
8054 addend = mips_elf_read_rel_addend (abfd, rel,
8056 if (got16_reloc_p (r_type))
8057 mips_elf_add_lo16_rel_addend (abfd, rel, rel_end,
8060 addend <<= howto->rightshift;
8063 addend = rel->r_addend;
8064 if (!mips_elf_record_got_page_entry (info, abfd, r_symndx,
8070 case R_MIPS_GOT_DISP:
8071 case R_MICROMIPS_GOT_DISP:
8072 if (h && !mips_elf_record_global_got_symbol (h, abfd, info,
8077 case R_MIPS_TLS_GOTTPREL:
8078 case R_MIPS16_TLS_GOTTPREL:
8079 case R_MICROMIPS_TLS_GOTTPREL:
8081 info->flags |= DF_STATIC_TLS;
8084 case R_MIPS_TLS_LDM:
8085 case R_MIPS16_TLS_LDM:
8086 case R_MICROMIPS_TLS_LDM:
8087 if (tls_ldm_reloc_p (r_type))
8089 r_symndx = STN_UNDEF;
8095 case R_MIPS16_TLS_GD:
8096 case R_MICROMIPS_TLS_GD:
8097 /* This symbol requires a global offset table entry, or two
8098 for TLS GD relocations. */
8101 if (!mips_elf_record_global_got_symbol (h, abfd, info,
8107 if (!mips_elf_record_local_got_symbol (abfd, r_symndx,
8117 /* In VxWorks executables, references to external symbols
8118 are handled using copy relocs or PLT stubs, so there's
8119 no need to add a .rela.dyn entry for this relocation. */
8120 if (can_make_dynamic_p)
8124 sreloc = mips_elf_rel_dyn_section (info, TRUE);
8128 if (info->shared && h == NULL)
8130 /* When creating a shared object, we must copy these
8131 reloc types into the output file as R_MIPS_REL32
8132 relocs. Make room for this reloc in .rel(a).dyn. */
8133 mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
8134 if (MIPS_ELF_READONLY_SECTION (sec))
8135 /* We tell the dynamic linker that there are
8136 relocations against the text segment. */
8137 info->flags |= DF_TEXTREL;
8141 struct mips_elf_link_hash_entry *hmips;
8143 /* For a shared object, we must copy this relocation
8144 unless the symbol turns out to be undefined and
8145 weak with non-default visibility, in which case
8146 it will be left as zero.
8148 We could elide R_MIPS_REL32 for locally binding symbols
8149 in shared libraries, but do not yet do so.
8151 For an executable, we only need to copy this
8152 reloc if the symbol is defined in a dynamic
8154 hmips = (struct mips_elf_link_hash_entry *) h;
8155 ++hmips->possibly_dynamic_relocs;
8156 if (MIPS_ELF_READONLY_SECTION (sec))
8157 /* We need it to tell the dynamic linker if there
8158 are relocations against the text segment. */
8159 hmips->readonly_reloc = TRUE;
8163 if (SGI_COMPAT (abfd))
8164 mips_elf_hash_table (info)->compact_rel_size +=
8165 sizeof (Elf32_External_crinfo);
8169 case R_MIPS_GPREL16:
8170 case R_MIPS_LITERAL:
8171 case R_MIPS_GPREL32:
8172 case R_MICROMIPS_26_S1:
8173 case R_MICROMIPS_GPREL16:
8174 case R_MICROMIPS_LITERAL:
8175 case R_MICROMIPS_GPREL7_S2:
8176 if (SGI_COMPAT (abfd))
8177 mips_elf_hash_table (info)->compact_rel_size +=
8178 sizeof (Elf32_External_crinfo);
8181 /* This relocation describes the C++ object vtable hierarchy.
8182 Reconstruct it for later use during GC. */
8183 case R_MIPS_GNU_VTINHERIT:
8184 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
8188 /* This relocation describes which C++ vtable entries are actually
8189 used. Record for later use during GC. */
8190 case R_MIPS_GNU_VTENTRY:
8191 BFD_ASSERT (h != NULL);
8193 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
8201 /* We must not create a stub for a symbol that has relocations
8202 related to taking the function's address. This doesn't apply to
8203 VxWorks, where CALL relocs refer to a .got.plt entry instead of
8204 a normal .got entry. */
8205 if (!htab->is_vxworks && h != NULL)
8209 ((struct mips_elf_link_hash_entry *) h)->no_fn_stub = TRUE;
8211 case R_MIPS16_CALL16:
8213 case R_MIPS_CALL_HI16:
8214 case R_MIPS_CALL_LO16:
8216 case R_MICROMIPS_CALL16:
8217 case R_MICROMIPS_CALL_HI16:
8218 case R_MICROMIPS_CALL_LO16:
8219 case R_MICROMIPS_JALR:
8223 /* See if this reloc would need to refer to a MIPS16 hard-float stub,
8224 if there is one. We only need to handle global symbols here;
8225 we decide whether to keep or delete stubs for local symbols
8226 when processing the stub's relocations. */
8228 && !mips16_call_reloc_p (r_type)
8229 && !section_allows_mips16_refs_p (sec))
8231 struct mips_elf_link_hash_entry *mh;
8233 mh = (struct mips_elf_link_hash_entry *) h;
8234 mh->need_fn_stub = TRUE;
8237 /* Refuse some position-dependent relocations when creating a
8238 shared library. Do not refuse R_MIPS_32 / R_MIPS_64; they're
8239 not PIC, but we can create dynamic relocations and the result
8240 will be fine. Also do not refuse R_MIPS_LO16, which can be
8241 combined with R_MIPS_GOT16. */
8249 case R_MIPS_HIGHEST:
8250 case R_MICROMIPS_HI16:
8251 case R_MICROMIPS_HIGHER:
8252 case R_MICROMIPS_HIGHEST:
8253 /* Don't refuse a high part relocation if it's against
8254 no symbol (e.g. part of a compound relocation). */
8255 if (r_symndx == STN_UNDEF)
8258 /* R_MIPS_HI16 against _gp_disp is used for $gp setup,
8259 and has a special meaning. */
8260 if (!NEWABI_P (abfd) && h != NULL
8261 && strcmp (h->root.root.string, "_gp_disp") == 0)
8264 /* Likewise __GOTT_BASE__ and __GOTT_INDEX__ on VxWorks. */
8265 if (is_gott_symbol (info, h))
8272 case R_MICROMIPS_26_S1:
8273 howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, r_type, FALSE);
8274 (*_bfd_error_handler)
8275 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
8277 (h) ? h->root.root.string : "a local symbol");
8278 bfd_set_error (bfd_error_bad_value);
8290 _bfd_mips_relax_section (bfd *abfd, asection *sec,
8291 struct bfd_link_info *link_info,
8294 Elf_Internal_Rela *internal_relocs;
8295 Elf_Internal_Rela *irel, *irelend;
8296 Elf_Internal_Shdr *symtab_hdr;
8297 bfd_byte *contents = NULL;
8299 bfd_boolean changed_contents = FALSE;
8300 bfd_vma sec_start = sec->output_section->vma + sec->output_offset;
8301 Elf_Internal_Sym *isymbuf = NULL;
8303 /* We are not currently changing any sizes, so only one pass. */
8306 if (link_info->relocatable)
8309 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
8310 link_info->keep_memory);
8311 if (internal_relocs == NULL)
8314 irelend = internal_relocs + sec->reloc_count
8315 * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel;
8316 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8317 extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
8319 for (irel = internal_relocs; irel < irelend; irel++)
8322 bfd_signed_vma sym_offset;
8323 unsigned int r_type;
8324 unsigned long r_symndx;
8326 unsigned long instruction;
8328 /* Turn jalr into bgezal, and jr into beq, if they're marked
8329 with a JALR relocation, that indicate where they jump to.
8330 This saves some pipeline bubbles. */
8331 r_type = ELF_R_TYPE (abfd, irel->r_info);
8332 if (r_type != R_MIPS_JALR)
8335 r_symndx = ELF_R_SYM (abfd, irel->r_info);
8336 /* Compute the address of the jump target. */
8337 if (r_symndx >= extsymoff)
8339 struct mips_elf_link_hash_entry *h
8340 = ((struct mips_elf_link_hash_entry *)
8341 elf_sym_hashes (abfd) [r_symndx - extsymoff]);
8343 while (h->root.root.type == bfd_link_hash_indirect
8344 || h->root.root.type == bfd_link_hash_warning)
8345 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
8347 /* If a symbol is undefined, or if it may be overridden,
8349 if (! ((h->root.root.type == bfd_link_hash_defined
8350 || h->root.root.type == bfd_link_hash_defweak)
8351 && h->root.root.u.def.section)
8352 || (link_info->shared && ! link_info->symbolic
8353 && !h->root.forced_local))
8356 sym_sec = h->root.root.u.def.section;
8357 if (sym_sec->output_section)
8358 symval = (h->root.root.u.def.value
8359 + sym_sec->output_section->vma
8360 + sym_sec->output_offset);
8362 symval = h->root.root.u.def.value;
8366 Elf_Internal_Sym *isym;
8368 /* Read this BFD's symbols if we haven't done so already. */
8369 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
8371 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
8372 if (isymbuf == NULL)
8373 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
8374 symtab_hdr->sh_info, 0,
8376 if (isymbuf == NULL)
8380 isym = isymbuf + r_symndx;
8381 if (isym->st_shndx == SHN_UNDEF)
8383 else if (isym->st_shndx == SHN_ABS)
8384 sym_sec = bfd_abs_section_ptr;
8385 else if (isym->st_shndx == SHN_COMMON)
8386 sym_sec = bfd_com_section_ptr;
8389 = bfd_section_from_elf_index (abfd, isym->st_shndx);
8390 symval = isym->st_value
8391 + sym_sec->output_section->vma
8392 + sym_sec->output_offset;
8395 /* Compute branch offset, from delay slot of the jump to the
8397 sym_offset = (symval + irel->r_addend)
8398 - (sec_start + irel->r_offset + 4);
8400 /* Branch offset must be properly aligned. */
8401 if ((sym_offset & 3) != 0)
8406 /* Check that it's in range. */
8407 if (sym_offset < -0x8000 || sym_offset >= 0x8000)
8410 /* Get the section contents if we haven't done so already. */
8411 if (!mips_elf_get_section_contents (abfd, sec, &contents))
8414 instruction = bfd_get_32 (abfd, contents + irel->r_offset);
8416 /* If it was jalr <reg>, turn it into bgezal $zero, <target>. */
8417 if ((instruction & 0xfc1fffff) == 0x0000f809)
8418 instruction = 0x04110000;
8419 /* If it was jr <reg>, turn it into b <target>. */
8420 else if ((instruction & 0xfc1fffff) == 0x00000008)
8421 instruction = 0x10000000;
8425 instruction |= (sym_offset & 0xffff);
8426 bfd_put_32 (abfd, instruction, contents + irel->r_offset);
8427 changed_contents = TRUE;
8430 if (contents != NULL
8431 && elf_section_data (sec)->this_hdr.contents != contents)
8433 if (!changed_contents && !link_info->keep_memory)
8437 /* Cache the section contents for elf_link_input_bfd. */
8438 elf_section_data (sec)->this_hdr.contents = contents;
8444 if (contents != NULL
8445 && elf_section_data (sec)->this_hdr.contents != contents)
8450 /* Allocate space for global sym dynamic relocs. */
8453 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8455 struct bfd_link_info *info = inf;
8457 struct mips_elf_link_hash_entry *hmips;
8458 struct mips_elf_link_hash_table *htab;
8460 htab = mips_elf_hash_table (info);
8461 BFD_ASSERT (htab != NULL);
8463 dynobj = elf_hash_table (info)->dynobj;
8464 hmips = (struct mips_elf_link_hash_entry *) h;
8466 /* VxWorks executables are handled elsewhere; we only need to
8467 allocate relocations in shared objects. */
8468 if (htab->is_vxworks && !info->shared)
8471 /* Ignore indirect symbols. All relocations against such symbols
8472 will be redirected to the target symbol. */
8473 if (h->root.type == bfd_link_hash_indirect)
8476 /* If this symbol is defined in a dynamic object, or we are creating
8477 a shared library, we will need to copy any R_MIPS_32 or
8478 R_MIPS_REL32 relocs against it into the output file. */
8479 if (! info->relocatable
8480 && hmips->possibly_dynamic_relocs != 0
8481 && (h->root.type == bfd_link_hash_defweak
8482 || (!h->def_regular && !ELF_COMMON_DEF_P (h))
8485 bfd_boolean do_copy = TRUE;
8487 if (h->root.type == bfd_link_hash_undefweak)
8489 /* Do not copy relocations for undefined weak symbols with
8490 non-default visibility. */
8491 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
8494 /* Make sure undefined weak symbols are output as a dynamic
8496 else if (h->dynindx == -1 && !h->forced_local)
8498 if (! bfd_elf_link_record_dynamic_symbol (info, h))
8505 /* Even though we don't directly need a GOT entry for this symbol,
8506 the SVR4 psABI requires it to have a dynamic symbol table
8507 index greater that DT_MIPS_GOTSYM if there are dynamic
8508 relocations against it.
8510 VxWorks does not enforce the same mapping between the GOT
8511 and the symbol table, so the same requirement does not
8513 if (!htab->is_vxworks)
8515 if (hmips->global_got_area > GGA_RELOC_ONLY)
8516 hmips->global_got_area = GGA_RELOC_ONLY;
8517 hmips->got_only_for_calls = FALSE;
8520 mips_elf_allocate_dynamic_relocations
8521 (dynobj, info, hmips->possibly_dynamic_relocs);
8522 if (hmips->readonly_reloc)
8523 /* We tell the dynamic linker that there are relocations
8524 against the text segment. */
8525 info->flags |= DF_TEXTREL;
8532 /* Adjust a symbol defined by a dynamic object and referenced by a
8533 regular object. The current definition is in some section of the
8534 dynamic object, but we're not including those sections. We have to
8535 change the definition to something the rest of the link can
8539 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
8540 struct elf_link_hash_entry *h)
8543 struct mips_elf_link_hash_entry *hmips;
8544 struct mips_elf_link_hash_table *htab;
8546 htab = mips_elf_hash_table (info);
8547 BFD_ASSERT (htab != NULL);
8549 dynobj = elf_hash_table (info)->dynobj;
8550 hmips = (struct mips_elf_link_hash_entry *) h;
8552 /* Make sure we know what is going on here. */
8553 BFD_ASSERT (dynobj != NULL
8555 || h->u.weakdef != NULL
8558 && !h->def_regular)));
8560 hmips = (struct mips_elf_link_hash_entry *) h;
8562 /* If there are call relocations against an externally-defined symbol,
8563 see whether we can create a MIPS lazy-binding stub for it. We can
8564 only do this if all references to the function are through call
8565 relocations, and in that case, the traditional lazy-binding stubs
8566 are much more efficient than PLT entries.
8568 Traditional stubs are only available on SVR4 psABI-based systems;
8569 VxWorks always uses PLTs instead. */
8570 if (!htab->is_vxworks && h->needs_plt && !hmips->no_fn_stub)
8572 if (! elf_hash_table (info)->dynamic_sections_created)
8575 /* If this symbol is not defined in a regular file, then set
8576 the symbol to the stub location. This is required to make
8577 function pointers compare as equal between the normal
8578 executable and the shared library. */
8579 if (!h->def_regular)
8581 hmips->needs_lazy_stub = TRUE;
8582 htab->lazy_stub_count++;
8586 /* As above, VxWorks requires PLT entries for externally-defined
8587 functions that are only accessed through call relocations.
8589 Both VxWorks and non-VxWorks targets also need PLT entries if there
8590 are static-only relocations against an externally-defined function.
8591 This can technically occur for shared libraries if there are
8592 branches to the symbol, although it is unlikely that this will be
8593 used in practice due to the short ranges involved. It can occur
8594 for any relative or absolute relocation in executables; in that
8595 case, the PLT entry becomes the function's canonical address. */
8596 else if (((h->needs_plt && !hmips->no_fn_stub)
8597 || (h->type == STT_FUNC && hmips->has_static_relocs))
8598 && htab->use_plts_and_copy_relocs
8599 && !SYMBOL_CALLS_LOCAL (info, h)
8600 && !(ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
8601 && h->root.type == bfd_link_hash_undefweak))
8603 /* If this is the first symbol to need a PLT entry, allocate room
8605 if (htab->splt->size == 0)
8607 BFD_ASSERT (htab->sgotplt->size == 0);
8609 /* If we're using the PLT additions to the psABI, each PLT
8610 entry is 16 bytes and the PLT0 entry is 32 bytes.
8611 Encourage better cache usage by aligning. We do this
8612 lazily to avoid pessimizing traditional objects. */
8613 if (!htab->is_vxworks
8614 && !bfd_set_section_alignment (dynobj, htab->splt, 5))
8617 /* Make sure that .got.plt is word-aligned. We do this lazily
8618 for the same reason as above. */
8619 if (!bfd_set_section_alignment (dynobj, htab->sgotplt,
8620 MIPS_ELF_LOG_FILE_ALIGN (dynobj)))
8623 htab->splt->size += htab->plt_header_size;
8625 /* On non-VxWorks targets, the first two entries in .got.plt
8627 if (!htab->is_vxworks)
8629 += get_elf_backend_data (dynobj)->got_header_size;
8631 /* On VxWorks, also allocate room for the header's
8632 .rela.plt.unloaded entries. */
8633 if (htab->is_vxworks && !info->shared)
8634 htab->srelplt2->size += 2 * sizeof (Elf32_External_Rela);
8637 /* Assign the next .plt entry to this symbol. */
8638 h->plt.offset = htab->splt->size;
8639 htab->splt->size += htab->plt_entry_size;
8641 /* If the output file has no definition of the symbol, set the
8642 symbol's value to the address of the stub. */
8643 if (!info->shared && !h->def_regular)
8645 h->root.u.def.section = htab->splt;
8646 h->root.u.def.value = h->plt.offset;
8647 /* For VxWorks, point at the PLT load stub rather than the
8648 lazy resolution stub; this stub will become the canonical
8649 function address. */
8650 if (htab->is_vxworks)
8651 h->root.u.def.value += 8;
8654 /* Make room for the .got.plt entry and the R_MIPS_JUMP_SLOT
8656 htab->sgotplt->size += MIPS_ELF_GOT_SIZE (dynobj);
8657 htab->srelplt->size += (htab->is_vxworks
8658 ? MIPS_ELF_RELA_SIZE (dynobj)
8659 : MIPS_ELF_REL_SIZE (dynobj));
8661 /* Make room for the .rela.plt.unloaded relocations. */
8662 if (htab->is_vxworks && !info->shared)
8663 htab->srelplt2->size += 3 * sizeof (Elf32_External_Rela);
8665 /* All relocations against this symbol that could have been made
8666 dynamic will now refer to the PLT entry instead. */
8667 hmips->possibly_dynamic_relocs = 0;
8672 /* If this is a weak symbol, and there is a real definition, the
8673 processor independent code will have arranged for us to see the
8674 real definition first, and we can just use the same value. */
8675 if (h->u.weakdef != NULL)
8677 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
8678 || h->u.weakdef->root.type == bfd_link_hash_defweak);
8679 h->root.u.def.section = h->u.weakdef->root.u.def.section;
8680 h->root.u.def.value = h->u.weakdef->root.u.def.value;
8684 /* Otherwise, there is nothing further to do for symbols defined
8685 in regular objects. */
8689 /* There's also nothing more to do if we'll convert all relocations
8690 against this symbol into dynamic relocations. */
8691 if (!hmips->has_static_relocs)
8694 /* We're now relying on copy relocations. Complain if we have
8695 some that we can't convert. */
8696 if (!htab->use_plts_and_copy_relocs || info->shared)
8698 (*_bfd_error_handler) (_("non-dynamic relocations refer to "
8699 "dynamic symbol %s"),
8700 h->root.root.string);
8701 bfd_set_error (bfd_error_bad_value);
8705 /* We must allocate the symbol in our .dynbss section, which will
8706 become part of the .bss section of the executable. There will be
8707 an entry for this symbol in the .dynsym section. The dynamic
8708 object will contain position independent code, so all references
8709 from the dynamic object to this symbol will go through the global
8710 offset table. The dynamic linker will use the .dynsym entry to
8711 determine the address it must put in the global offset table, so
8712 both the dynamic object and the regular object will refer to the
8713 same memory location for the variable. */
8715 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
8717 if (htab->is_vxworks)
8718 htab->srelbss->size += sizeof (Elf32_External_Rela);
8720 mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
8724 /* All relocations against this symbol that could have been made
8725 dynamic will now refer to the local copy instead. */
8726 hmips->possibly_dynamic_relocs = 0;
8728 return _bfd_elf_adjust_dynamic_copy (h, htab->sdynbss);
8731 /* This function is called after all the input files have been read,
8732 and the input sections have been assigned to output sections. We
8733 check for any mips16 stub sections that we can discard. */
8736 _bfd_mips_elf_always_size_sections (bfd *output_bfd,
8737 struct bfd_link_info *info)
8740 struct mips_elf_link_hash_table *htab;
8741 struct mips_htab_traverse_info hti;
8743 htab = mips_elf_hash_table (info);
8744 BFD_ASSERT (htab != NULL);
8746 /* The .reginfo section has a fixed size. */
8747 ri = bfd_get_section_by_name (output_bfd, ".reginfo");
8749 bfd_set_section_size (output_bfd, ri, sizeof (Elf32_External_RegInfo));
8752 hti.output_bfd = output_bfd;
8754 mips_elf_link_hash_traverse (mips_elf_hash_table (info),
8755 mips_elf_check_symbols, &hti);
8762 /* If the link uses a GOT, lay it out and work out its size. */
8765 mips_elf_lay_out_got (bfd *output_bfd, struct bfd_link_info *info)
8769 struct mips_got_info *g;
8770 bfd_size_type loadable_size = 0;
8771 bfd_size_type page_gotno;
8773 struct mips_elf_traverse_got_arg tga;
8774 struct mips_elf_link_hash_table *htab;
8776 htab = mips_elf_hash_table (info);
8777 BFD_ASSERT (htab != NULL);
8783 dynobj = elf_hash_table (info)->dynobj;
8786 /* Allocate room for the reserved entries. VxWorks always reserves
8787 3 entries; other objects only reserve 2 entries. */
8788 BFD_ASSERT (g->assigned_gotno == 0);
8789 if (htab->is_vxworks)
8790 htab->reserved_gotno = 3;
8792 htab->reserved_gotno = 2;
8793 g->local_gotno += htab->reserved_gotno;
8794 g->assigned_gotno = htab->reserved_gotno;
8796 /* Replace entries for indirect and warning symbols with entries for
8797 the target symbol. */
8798 if (!mips_elf_resolve_final_got_entries (g))
8801 /* Count the number of GOT symbols. */
8802 mips_elf_link_hash_traverse (htab, mips_elf_count_got_symbols, info);
8804 /* Calculate the total loadable size of the output. That
8805 will give us the maximum number of GOT_PAGE entries
8807 for (sub = info->input_bfds; sub; sub = sub->link_next)
8809 asection *subsection;
8811 for (subsection = sub->sections;
8813 subsection = subsection->next)
8815 if ((subsection->flags & SEC_ALLOC) == 0)
8817 loadable_size += ((subsection->size + 0xf)
8818 &~ (bfd_size_type) 0xf);
8822 if (htab->is_vxworks)
8823 /* There's no need to allocate page entries for VxWorks; R_MIPS*_GOT16
8824 relocations against local symbols evaluate to "G", and the EABI does
8825 not include R_MIPS_GOT_PAGE. */
8828 /* Assume there are two loadable segments consisting of contiguous
8829 sections. Is 5 enough? */
8830 page_gotno = (loadable_size >> 16) + 5;
8832 /* Choose the smaller of the two estimates; both are intended to be
8834 if (page_gotno > g->page_gotno)
8835 page_gotno = g->page_gotno;
8837 g->local_gotno += page_gotno;
8839 /* Count the number of local GOT entries and TLS relocs. */
8842 htab_traverse (g->got_entries, mips_elf_count_local_got_entries, &tga);
8844 /* We need to calculate tls_gotno for global symbols at this point
8845 instead of building it up earlier, to avoid doublecounting
8846 entries for one global symbol from multiple input files. */
8847 elf_link_hash_traverse (elf_hash_table (info),
8848 mips_elf_count_global_tls_entries,
8851 s->size += g->local_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
8852 s->size += g->global_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
8853 s->size += g->tls_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
8855 /* VxWorks does not support multiple GOTs. It initializes $gp to
8856 __GOTT_BASE__[__GOTT_INDEX__], the value of which is set by the
8858 if (htab->is_vxworks)
8860 /* VxWorks executables do not need a GOT. */
8863 /* Each VxWorks GOT entry needs an explicit relocation. */
8866 count = g->global_gotno + g->local_gotno - htab->reserved_gotno;
8868 mips_elf_allocate_dynamic_relocations (dynobj, info, count);
8871 else if (s->size > MIPS_ELF_GOT_MAX_SIZE (info))
8873 if (!mips_elf_multi_got (output_bfd, info, s, page_gotno))
8878 /* Set up TLS entries. */
8879 g->tls_assigned_gotno = g->global_gotno + g->local_gotno;
8880 htab_traverse (g->got_entries, mips_elf_initialize_tls_index, g);
8881 BFD_ASSERT (g->tls_assigned_gotno
8882 == g->global_gotno + g->local_gotno + g->tls_gotno);
8884 /* Allocate room for the TLS relocations. */
8886 mips_elf_allocate_dynamic_relocations (dynobj, info, g->relocs);
8892 /* Estimate the size of the .MIPS.stubs section. */
8895 mips_elf_estimate_stub_size (bfd *output_bfd, struct bfd_link_info *info)
8897 struct mips_elf_link_hash_table *htab;
8898 bfd_size_type dynsymcount;
8900 htab = mips_elf_hash_table (info);
8901 BFD_ASSERT (htab != NULL);
8903 if (htab->lazy_stub_count == 0)
8906 /* IRIX rld assumes that a function stub isn't at the end of the .text
8907 section, so add a dummy entry to the end. */
8908 htab->lazy_stub_count++;
8910 /* Get a worst-case estimate of the number of dynamic symbols needed.
8911 At this point, dynsymcount does not account for section symbols
8912 and count_section_dynsyms may overestimate the number that will
8914 dynsymcount = (elf_hash_table (info)->dynsymcount
8915 + count_section_dynsyms (output_bfd, info));
8917 /* Determine the size of one stub entry. */
8918 htab->function_stub_size = (dynsymcount > 0x10000
8919 ? MIPS_FUNCTION_STUB_BIG_SIZE
8920 : MIPS_FUNCTION_STUB_NORMAL_SIZE);
8922 htab->sstubs->size = htab->lazy_stub_count * htab->function_stub_size;
8925 /* A mips_elf_link_hash_traverse callback for which DATA points to the
8926 MIPS hash table. If H needs a traditional MIPS lazy-binding stub,
8927 allocate an entry in the stubs section. */
8930 mips_elf_allocate_lazy_stub (struct mips_elf_link_hash_entry *h, void **data)
8932 struct mips_elf_link_hash_table *htab;
8934 htab = (struct mips_elf_link_hash_table *) data;
8935 if (h->needs_lazy_stub)
8937 h->root.root.u.def.section = htab->sstubs;
8938 h->root.root.u.def.value = htab->sstubs->size;
8939 h->root.plt.offset = htab->sstubs->size;
8940 htab->sstubs->size += htab->function_stub_size;
8945 /* Allocate offsets in the stubs section to each symbol that needs one.
8946 Set the final size of the .MIPS.stub section. */
8949 mips_elf_lay_out_lazy_stubs (struct bfd_link_info *info)
8951 struct mips_elf_link_hash_table *htab;
8953 htab = mips_elf_hash_table (info);
8954 BFD_ASSERT (htab != NULL);
8956 if (htab->lazy_stub_count == 0)
8959 htab->sstubs->size = 0;
8960 mips_elf_link_hash_traverse (htab, mips_elf_allocate_lazy_stub, htab);
8961 htab->sstubs->size += htab->function_stub_size;
8962 BFD_ASSERT (htab->sstubs->size
8963 == htab->lazy_stub_count * htab->function_stub_size);
8966 /* Set the sizes of the dynamic sections. */
8969 _bfd_mips_elf_size_dynamic_sections (bfd *output_bfd,
8970 struct bfd_link_info *info)
8973 asection *s, *sreldyn;
8974 bfd_boolean reltext;
8975 struct mips_elf_link_hash_table *htab;
8977 htab = mips_elf_hash_table (info);
8978 BFD_ASSERT (htab != NULL);
8979 dynobj = elf_hash_table (info)->dynobj;
8980 BFD_ASSERT (dynobj != NULL);
8982 if (elf_hash_table (info)->dynamic_sections_created)
8984 /* Set the contents of the .interp section to the interpreter. */
8985 if (info->executable)
8987 s = bfd_get_linker_section (dynobj, ".interp");
8988 BFD_ASSERT (s != NULL);
8990 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd)) + 1;
8992 = (bfd_byte *) ELF_DYNAMIC_INTERPRETER (output_bfd);
8995 /* Create a symbol for the PLT, if we know that we are using it. */
8996 if (htab->splt && htab->splt->size > 0 && htab->root.hplt == NULL)
8998 struct elf_link_hash_entry *h;
9000 BFD_ASSERT (htab->use_plts_and_copy_relocs);
9002 h = _bfd_elf_define_linkage_sym (dynobj, info, htab->splt,
9003 "_PROCEDURE_LINKAGE_TABLE_");
9004 htab->root.hplt = h;
9011 /* Allocate space for global sym dynamic relocs. */
9012 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
9014 mips_elf_estimate_stub_size (output_bfd, info);
9016 if (!mips_elf_lay_out_got (output_bfd, info))
9019 mips_elf_lay_out_lazy_stubs (info);
9021 /* The check_relocs and adjust_dynamic_symbol entry points have
9022 determined the sizes of the various dynamic sections. Allocate
9025 for (s = dynobj->sections; s != NULL; s = s->next)
9029 /* It's OK to base decisions on the section name, because none
9030 of the dynobj section names depend upon the input files. */
9031 name = bfd_get_section_name (dynobj, s);
9033 if ((s->flags & SEC_LINKER_CREATED) == 0)
9036 if (CONST_STRNEQ (name, ".rel"))
9040 const char *outname;
9043 /* If this relocation section applies to a read only
9044 section, then we probably need a DT_TEXTREL entry.
9045 If the relocation section is .rel(a).dyn, we always
9046 assert a DT_TEXTREL entry rather than testing whether
9047 there exists a relocation to a read only section or
9049 outname = bfd_get_section_name (output_bfd,
9051 target = bfd_get_section_by_name (output_bfd, outname + 4);
9053 && (target->flags & SEC_READONLY) != 0
9054 && (target->flags & SEC_ALLOC) != 0)
9055 || strcmp (outname, MIPS_ELF_REL_DYN_NAME (info)) == 0)
9058 /* We use the reloc_count field as a counter if we need
9059 to copy relocs into the output file. */
9060 if (strcmp (name, MIPS_ELF_REL_DYN_NAME (info)) != 0)
9063 /* If combreloc is enabled, elf_link_sort_relocs() will
9064 sort relocations, but in a different way than we do,
9065 and before we're done creating relocations. Also, it
9066 will move them around between input sections'
9067 relocation's contents, so our sorting would be
9068 broken, so don't let it run. */
9069 info->combreloc = 0;
9072 else if (! info->shared
9073 && ! mips_elf_hash_table (info)->use_rld_obj_head
9074 && CONST_STRNEQ (name, ".rld_map"))
9076 /* We add a room for __rld_map. It will be filled in by the
9077 rtld to contain a pointer to the _r_debug structure. */
9078 s->size += MIPS_ELF_RLD_MAP_SIZE (output_bfd);
9080 else if (SGI_COMPAT (output_bfd)
9081 && CONST_STRNEQ (name, ".compact_rel"))
9082 s->size += mips_elf_hash_table (info)->compact_rel_size;
9083 else if (s == htab->splt)
9085 /* If the last PLT entry has a branch delay slot, allocate
9086 room for an extra nop to fill the delay slot. This is
9087 for CPUs without load interlocking. */
9088 if (! LOAD_INTERLOCKS_P (output_bfd)
9089 && ! htab->is_vxworks && s->size > 0)
9092 else if (! CONST_STRNEQ (name, ".init")
9094 && s != htab->sgotplt
9095 && s != htab->sstubs
9096 && s != htab->sdynbss)
9098 /* It's not one of our sections, so don't allocate space. */
9104 s->flags |= SEC_EXCLUDE;
9108 if ((s->flags & SEC_HAS_CONTENTS) == 0)
9111 /* Allocate memory for the section contents. */
9112 s->contents = bfd_zalloc (dynobj, s->size);
9113 if (s->contents == NULL)
9115 bfd_set_error (bfd_error_no_memory);
9120 if (elf_hash_table (info)->dynamic_sections_created)
9122 /* Add some entries to the .dynamic section. We fill in the
9123 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
9124 must add the entries now so that we get the correct size for
9125 the .dynamic section. */
9127 /* SGI object has the equivalence of DT_DEBUG in the
9128 DT_MIPS_RLD_MAP entry. This must come first because glibc
9129 only fills in DT_MIPS_RLD_MAP (not DT_DEBUG) and some tools
9130 may only look at the first one they see. */
9132 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP, 0))
9135 /* The DT_DEBUG entry may be filled in by the dynamic linker and
9136 used by the debugger. */
9137 if (info->executable
9138 && !SGI_COMPAT (output_bfd)
9139 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
9142 if (reltext && (SGI_COMPAT (output_bfd) || htab->is_vxworks))
9143 info->flags |= DF_TEXTREL;
9145 if ((info->flags & DF_TEXTREL) != 0)
9147 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0))
9150 /* Clear the DF_TEXTREL flag. It will be set again if we
9151 write out an actual text relocation; we may not, because
9152 at this point we do not know whether e.g. any .eh_frame
9153 absolute relocations have been converted to PC-relative. */
9154 info->flags &= ~DF_TEXTREL;
9157 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0))
9160 sreldyn = mips_elf_rel_dyn_section (info, FALSE);
9161 if (htab->is_vxworks)
9163 /* VxWorks uses .rela.dyn instead of .rel.dyn. It does not
9164 use any of the DT_MIPS_* tags. */
9165 if (sreldyn && sreldyn->size > 0)
9167 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELA, 0))
9170 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELASZ, 0))
9173 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELAENT, 0))
9179 if (sreldyn && sreldyn->size > 0)
9181 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0))
9184 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0))
9187 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0))
9191 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_VERSION, 0))
9194 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_FLAGS, 0))
9197 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_BASE_ADDRESS, 0))
9200 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LOCAL_GOTNO, 0))
9203 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_SYMTABNO, 0))
9206 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_UNREFEXTNO, 0))
9209 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_GOTSYM, 0))
9212 if (IRIX_COMPAT (dynobj) == ict_irix5
9213 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_HIPAGENO, 0))
9216 if (IRIX_COMPAT (dynobj) == ict_irix6
9217 && (bfd_get_section_by_name
9218 (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj)))
9219 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_OPTIONS, 0))
9222 if (htab->splt->size > 0)
9224 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTREL, 0))
9227 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_JMPREL, 0))
9230 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTRELSZ, 0))
9233 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_PLTGOT, 0))
9236 if (htab->is_vxworks
9237 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
9244 /* REL is a relocation in INPUT_BFD that is being copied to OUTPUT_BFD.
9245 Adjust its R_ADDEND field so that it is correct for the output file.
9246 LOCAL_SYMS and LOCAL_SECTIONS are arrays of INPUT_BFD's local symbols
9247 and sections respectively; both use symbol indexes. */
9250 mips_elf_adjust_addend (bfd *output_bfd, struct bfd_link_info *info,
9251 bfd *input_bfd, Elf_Internal_Sym *local_syms,
9252 asection **local_sections, Elf_Internal_Rela *rel)
9254 unsigned int r_type, r_symndx;
9255 Elf_Internal_Sym *sym;
9258 if (mips_elf_local_relocation_p (input_bfd, rel, local_sections))
9260 r_type = ELF_R_TYPE (output_bfd, rel->r_info);
9261 if (gprel16_reloc_p (r_type)
9262 || r_type == R_MIPS_GPREL32
9263 || literal_reloc_p (r_type))
9265 rel->r_addend += _bfd_get_gp_value (input_bfd);
9266 rel->r_addend -= _bfd_get_gp_value (output_bfd);
9269 r_symndx = ELF_R_SYM (output_bfd, rel->r_info);
9270 sym = local_syms + r_symndx;
9272 /* Adjust REL's addend to account for section merging. */
9273 if (!info->relocatable)
9275 sec = local_sections[r_symndx];
9276 _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
9279 /* This would normally be done by the rela_normal code in elflink.c. */
9280 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
9281 rel->r_addend += local_sections[r_symndx]->output_offset;
9285 /* Handle relocations against symbols from removed linkonce sections,
9286 or sections discarded by a linker script. We use this wrapper around
9287 RELOC_AGAINST_DISCARDED_SECTION to handle triplets of compound relocs
9288 on 64-bit ELF targets. In this case for any relocation handled, which
9289 always be the first in a triplet, the remaining two have to be processed
9290 together with the first, even if they are R_MIPS_NONE. It is the symbol
9291 index referred by the first reloc that applies to all the three and the
9292 remaining two never refer to an object symbol. And it is the final
9293 relocation (the last non-null one) that determines the output field of
9294 the whole relocation so retrieve the corresponding howto structure for
9295 the relocatable field to be cleared by RELOC_AGAINST_DISCARDED_SECTION.
9297 Note that RELOC_AGAINST_DISCARDED_SECTION is a macro that uses "continue"
9298 and therefore requires to be pasted in a loop. It also defines a block
9299 and does not protect any of its arguments, hence the extra brackets. */
9302 mips_reloc_against_discarded_section (bfd *output_bfd,
9303 struct bfd_link_info *info,
9304 bfd *input_bfd, asection *input_section,
9305 Elf_Internal_Rela **rel,
9306 const Elf_Internal_Rela **relend,
9307 bfd_boolean rel_reloc,
9308 reloc_howto_type *howto,
9311 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
9312 int count = bed->s->int_rels_per_ext_rel;
9313 unsigned int r_type;
9316 for (i = count - 1; i > 0; i--)
9318 r_type = ELF_R_TYPE (output_bfd, (*rel)[i].r_info);
9319 if (r_type != R_MIPS_NONE)
9321 howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type, !rel_reloc);
9327 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
9328 (*rel), count, (*relend),
9329 howto, i, contents);
9334 /* Relocate a MIPS ELF section. */
9337 _bfd_mips_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
9338 bfd *input_bfd, asection *input_section,
9339 bfd_byte *contents, Elf_Internal_Rela *relocs,
9340 Elf_Internal_Sym *local_syms,
9341 asection **local_sections)
9343 Elf_Internal_Rela *rel;
9344 const Elf_Internal_Rela *relend;
9346 bfd_boolean use_saved_addend_p = FALSE;
9347 const struct elf_backend_data *bed;
9349 bed = get_elf_backend_data (output_bfd);
9350 relend = relocs + input_section->reloc_count * bed->s->int_rels_per_ext_rel;
9351 for (rel = relocs; rel < relend; ++rel)
9355 reloc_howto_type *howto;
9356 bfd_boolean cross_mode_jump_p;
9357 /* TRUE if the relocation is a RELA relocation, rather than a
9359 bfd_boolean rela_relocation_p = TRUE;
9360 unsigned int r_type = ELF_R_TYPE (output_bfd, rel->r_info);
9362 unsigned long r_symndx;
9364 Elf_Internal_Shdr *symtab_hdr;
9365 struct elf_link_hash_entry *h;
9366 bfd_boolean rel_reloc;
9368 rel_reloc = (NEWABI_P (input_bfd)
9369 && mips_elf_rel_relocation_p (input_bfd, input_section,
9371 /* Find the relocation howto for this relocation. */
9372 howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type, !rel_reloc);
9374 r_symndx = ELF_R_SYM (input_bfd, rel->r_info);
9375 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
9376 if (mips_elf_local_relocation_p (input_bfd, rel, local_sections))
9378 sec = local_sections[r_symndx];
9383 unsigned long extsymoff;
9386 if (!elf_bad_symtab (input_bfd))
9387 extsymoff = symtab_hdr->sh_info;
9388 h = elf_sym_hashes (input_bfd) [r_symndx - extsymoff];
9389 while (h->root.type == bfd_link_hash_indirect
9390 || h->root.type == bfd_link_hash_warning)
9391 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9394 if (h->root.type == bfd_link_hash_defined
9395 || h->root.type == bfd_link_hash_defweak)
9396 sec = h->root.u.def.section;
9399 if (sec != NULL && discarded_section (sec))
9401 mips_reloc_against_discarded_section (output_bfd, info, input_bfd,
9402 input_section, &rel, &relend,
9403 rel_reloc, howto, contents);
9407 if (r_type == R_MIPS_64 && ! NEWABI_P (input_bfd))
9409 /* Some 32-bit code uses R_MIPS_64. In particular, people use
9410 64-bit code, but make sure all their addresses are in the
9411 lowermost or uppermost 32-bit section of the 64-bit address
9412 space. Thus, when they use an R_MIPS_64 they mean what is
9413 usually meant by R_MIPS_32, with the exception that the
9414 stored value is sign-extended to 64 bits. */
9415 howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, R_MIPS_32, FALSE);
9417 /* On big-endian systems, we need to lie about the position
9419 if (bfd_big_endian (input_bfd))
9423 if (!use_saved_addend_p)
9425 /* If these relocations were originally of the REL variety,
9426 we must pull the addend out of the field that will be
9427 relocated. Otherwise, we simply use the contents of the
9429 if (mips_elf_rel_relocation_p (input_bfd, input_section,
9432 rela_relocation_p = FALSE;
9433 addend = mips_elf_read_rel_addend (input_bfd, rel,
9435 if (hi16_reloc_p (r_type)
9436 || (got16_reloc_p (r_type)
9437 && mips_elf_local_relocation_p (input_bfd, rel,
9440 if (!mips_elf_add_lo16_rel_addend (input_bfd, rel, relend,
9444 name = h->root.root.string;
9446 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
9447 local_syms + r_symndx,
9449 (*_bfd_error_handler)
9450 (_("%B: Can't find matching LO16 reloc against `%s' for %s at 0x%lx in section `%A'"),
9451 input_bfd, input_section, name, howto->name,
9456 addend <<= howto->rightshift;
9459 addend = rel->r_addend;
9460 mips_elf_adjust_addend (output_bfd, info, input_bfd,
9461 local_syms, local_sections, rel);
9464 if (info->relocatable)
9466 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd)
9467 && bfd_big_endian (input_bfd))
9470 if (!rela_relocation_p && rel->r_addend)
9472 addend += rel->r_addend;
9473 if (hi16_reloc_p (r_type) || got16_reloc_p (r_type))
9474 addend = mips_elf_high (addend);
9475 else if (r_type == R_MIPS_HIGHER)
9476 addend = mips_elf_higher (addend);
9477 else if (r_type == R_MIPS_HIGHEST)
9478 addend = mips_elf_highest (addend);
9480 addend >>= howto->rightshift;
9482 /* We use the source mask, rather than the destination
9483 mask because the place to which we are writing will be
9484 source of the addend in the final link. */
9485 addend &= howto->src_mask;
9487 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
9488 /* See the comment above about using R_MIPS_64 in the 32-bit
9489 ABI. Here, we need to update the addend. It would be
9490 possible to get away with just using the R_MIPS_32 reloc
9491 but for endianness. */
9497 if (addend & ((bfd_vma) 1 << 31))
9499 sign_bits = ((bfd_vma) 1 << 32) - 1;
9506 /* If we don't know that we have a 64-bit type,
9507 do two separate stores. */
9508 if (bfd_big_endian (input_bfd))
9510 /* Store the sign-bits (which are most significant)
9512 low_bits = sign_bits;
9518 high_bits = sign_bits;
9520 bfd_put_32 (input_bfd, low_bits,
9521 contents + rel->r_offset);
9522 bfd_put_32 (input_bfd, high_bits,
9523 contents + rel->r_offset + 4);
9527 if (! mips_elf_perform_relocation (info, howto, rel, addend,
9528 input_bfd, input_section,
9533 /* Go on to the next relocation. */
9537 /* In the N32 and 64-bit ABIs there may be multiple consecutive
9538 relocations for the same offset. In that case we are
9539 supposed to treat the output of each relocation as the addend
9541 if (rel + 1 < relend
9542 && rel->r_offset == rel[1].r_offset
9543 && ELF_R_TYPE (input_bfd, rel[1].r_info) != R_MIPS_NONE)
9544 use_saved_addend_p = TRUE;
9546 use_saved_addend_p = FALSE;
9548 /* Figure out what value we are supposed to relocate. */
9549 switch (mips_elf_calculate_relocation (output_bfd, input_bfd,
9550 input_section, info, rel,
9551 addend, howto, local_syms,
9552 local_sections, &value,
9553 &name, &cross_mode_jump_p,
9554 use_saved_addend_p))
9556 case bfd_reloc_continue:
9557 /* There's nothing to do. */
9560 case bfd_reloc_undefined:
9561 /* mips_elf_calculate_relocation already called the
9562 undefined_symbol callback. There's no real point in
9563 trying to perform the relocation at this point, so we
9564 just skip ahead to the next relocation. */
9567 case bfd_reloc_notsupported:
9568 msg = _("internal error: unsupported relocation error");
9569 info->callbacks->warning
9570 (info, msg, name, input_bfd, input_section, rel->r_offset);
9573 case bfd_reloc_overflow:
9574 if (use_saved_addend_p)
9575 /* Ignore overflow until we reach the last relocation for
9576 a given location. */
9580 struct mips_elf_link_hash_table *htab;
9582 htab = mips_elf_hash_table (info);
9583 BFD_ASSERT (htab != NULL);
9584 BFD_ASSERT (name != NULL);
9585 if (!htab->small_data_overflow_reported
9586 && (gprel16_reloc_p (howto->type)
9587 || literal_reloc_p (howto->type)))
9589 msg = _("small-data section exceeds 64KB;"
9590 " lower small-data size limit (see option -G)");
9592 htab->small_data_overflow_reported = TRUE;
9593 (*info->callbacks->einfo) ("%P: %s\n", msg);
9595 if (! ((*info->callbacks->reloc_overflow)
9596 (info, NULL, name, howto->name, (bfd_vma) 0,
9597 input_bfd, input_section, rel->r_offset)))
9605 case bfd_reloc_outofrange:
9606 if (jal_reloc_p (howto->type))
9608 msg = _("JALX to a non-word-aligned address");
9609 info->callbacks->warning
9610 (info, msg, name, input_bfd, input_section, rel->r_offset);
9620 /* If we've got another relocation for the address, keep going
9621 until we reach the last one. */
9622 if (use_saved_addend_p)
9628 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
9629 /* See the comment above about using R_MIPS_64 in the 32-bit
9630 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
9631 that calculated the right value. Now, however, we
9632 sign-extend the 32-bit result to 64-bits, and store it as a
9633 64-bit value. We are especially generous here in that we
9634 go to extreme lengths to support this usage on systems with
9635 only a 32-bit VMA. */
9641 if (value & ((bfd_vma) 1 << 31))
9643 sign_bits = ((bfd_vma) 1 << 32) - 1;
9650 /* If we don't know that we have a 64-bit type,
9651 do two separate stores. */
9652 if (bfd_big_endian (input_bfd))
9654 /* Undo what we did above. */
9656 /* Store the sign-bits (which are most significant)
9658 low_bits = sign_bits;
9664 high_bits = sign_bits;
9666 bfd_put_32 (input_bfd, low_bits,
9667 contents + rel->r_offset);
9668 bfd_put_32 (input_bfd, high_bits,
9669 contents + rel->r_offset + 4);
9673 /* Actually perform the relocation. */
9674 if (! mips_elf_perform_relocation (info, howto, rel, value,
9675 input_bfd, input_section,
9676 contents, cross_mode_jump_p))
9683 /* A function that iterates over each entry in la25_stubs and fills
9684 in the code for each one. DATA points to a mips_htab_traverse_info. */
9687 mips_elf_create_la25_stub (void **slot, void *data)
9689 struct mips_htab_traverse_info *hti;
9690 struct mips_elf_link_hash_table *htab;
9691 struct mips_elf_la25_stub *stub;
9694 bfd_vma offset, target, target_high, target_low;
9696 stub = (struct mips_elf_la25_stub *) *slot;
9697 hti = (struct mips_htab_traverse_info *) data;
9698 htab = mips_elf_hash_table (hti->info);
9699 BFD_ASSERT (htab != NULL);
9701 /* Create the section contents, if we haven't already. */
9702 s = stub->stub_section;
9706 loc = bfd_malloc (s->size);
9715 /* Work out where in the section this stub should go. */
9716 offset = stub->offset;
9718 /* Work out the target address. */
9719 target = mips_elf_get_la25_target (stub, &s);
9720 target += s->output_section->vma + s->output_offset;
9722 target_high = ((target + 0x8000) >> 16) & 0xffff;
9723 target_low = (target & 0xffff);
9725 if (stub->stub_section != htab->strampoline)
9727 /* This is a simple LUI/ADDIU stub. Zero out the beginning
9728 of the section and write the two instructions at the end. */
9729 memset (loc, 0, offset);
9731 if (ELF_ST_IS_MICROMIPS (stub->h->root.other))
9733 bfd_put_micromips_32 (hti->output_bfd,
9734 LA25_LUI_MICROMIPS (target_high),
9736 bfd_put_micromips_32 (hti->output_bfd,
9737 LA25_ADDIU_MICROMIPS (target_low),
9742 bfd_put_32 (hti->output_bfd, LA25_LUI (target_high), loc);
9743 bfd_put_32 (hti->output_bfd, LA25_ADDIU (target_low), loc + 4);
9748 /* This is trampoline. */
9750 if (ELF_ST_IS_MICROMIPS (stub->h->root.other))
9752 bfd_put_micromips_32 (hti->output_bfd,
9753 LA25_LUI_MICROMIPS (target_high), loc);
9754 bfd_put_micromips_32 (hti->output_bfd,
9755 LA25_J_MICROMIPS (target), loc + 4);
9756 bfd_put_micromips_32 (hti->output_bfd,
9757 LA25_ADDIU_MICROMIPS (target_low), loc + 8);
9758 bfd_put_32 (hti->output_bfd, 0, loc + 12);
9762 bfd_put_32 (hti->output_bfd, LA25_LUI (target_high), loc);
9763 bfd_put_32 (hti->output_bfd, LA25_J (target), loc + 4);
9764 bfd_put_32 (hti->output_bfd, LA25_ADDIU (target_low), loc + 8);
9765 bfd_put_32 (hti->output_bfd, 0, loc + 12);
9771 /* If NAME is one of the special IRIX6 symbols defined by the linker,
9772 adjust it appropriately now. */
9775 mips_elf_irix6_finish_dynamic_symbol (bfd *abfd ATTRIBUTE_UNUSED,
9776 const char *name, Elf_Internal_Sym *sym)
9778 /* The linker script takes care of providing names and values for
9779 these, but we must place them into the right sections. */
9780 static const char* const text_section_symbols[] = {
9783 "__dso_displacement",
9785 "__program_header_table",
9789 static const char* const data_section_symbols[] = {
9797 const char* const *p;
9800 for (i = 0; i < 2; ++i)
9801 for (p = (i == 0) ? text_section_symbols : data_section_symbols;
9804 if (strcmp (*p, name) == 0)
9806 /* All of these symbols are given type STT_SECTION by the
9808 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
9809 sym->st_other = STO_PROTECTED;
9811 /* The IRIX linker puts these symbols in special sections. */
9813 sym->st_shndx = SHN_MIPS_TEXT;
9815 sym->st_shndx = SHN_MIPS_DATA;
9821 /* Finish up dynamic symbol handling. We set the contents of various
9822 dynamic sections here. */
9825 _bfd_mips_elf_finish_dynamic_symbol (bfd *output_bfd,
9826 struct bfd_link_info *info,
9827 struct elf_link_hash_entry *h,
9828 Elf_Internal_Sym *sym)
9832 struct mips_got_info *g, *gg;
9835 struct mips_elf_link_hash_table *htab;
9836 struct mips_elf_link_hash_entry *hmips;
9838 htab = mips_elf_hash_table (info);
9839 BFD_ASSERT (htab != NULL);
9840 dynobj = elf_hash_table (info)->dynobj;
9841 hmips = (struct mips_elf_link_hash_entry *) h;
9843 BFD_ASSERT (!htab->is_vxworks);
9845 if (h->plt.offset != MINUS_ONE && hmips->no_fn_stub)
9847 /* We've decided to create a PLT entry for this symbol. */
9849 bfd_vma header_address, plt_index, got_address;
9850 bfd_vma got_address_high, got_address_low, load;
9851 const bfd_vma *plt_entry;
9853 BFD_ASSERT (htab->use_plts_and_copy_relocs);
9854 BFD_ASSERT (h->dynindx != -1);
9855 BFD_ASSERT (htab->splt != NULL);
9856 BFD_ASSERT (h->plt.offset <= htab->splt->size);
9857 BFD_ASSERT (!h->def_regular);
9859 /* Calculate the address of the PLT header. */
9860 header_address = (htab->splt->output_section->vma
9861 + htab->splt->output_offset);
9863 /* Calculate the index of the entry. */
9864 plt_index = ((h->plt.offset - htab->plt_header_size)
9865 / htab->plt_entry_size);
9867 /* Calculate the address of the .got.plt entry. */
9868 got_address = (htab->sgotplt->output_section->vma
9869 + htab->sgotplt->output_offset
9870 + (2 + plt_index) * MIPS_ELF_GOT_SIZE (dynobj));
9871 got_address_high = ((got_address + 0x8000) >> 16) & 0xffff;
9872 got_address_low = got_address & 0xffff;
9874 /* Initially point the .got.plt entry at the PLT header. */
9875 loc = (htab->sgotplt->contents
9876 + (2 + plt_index) * MIPS_ELF_GOT_SIZE (dynobj));
9877 if (ABI_64_P (output_bfd))
9878 bfd_put_64 (output_bfd, header_address, loc);
9880 bfd_put_32 (output_bfd, header_address, loc);
9882 /* Find out where the .plt entry should go. */
9883 loc = htab->splt->contents + h->plt.offset;
9885 /* Pick the load opcode. */
9886 load = MIPS_ELF_LOAD_WORD (output_bfd);
9888 /* Fill in the PLT entry itself. */
9889 plt_entry = mips_exec_plt_entry;
9890 bfd_put_32 (output_bfd, plt_entry[0] | got_address_high, loc);
9891 bfd_put_32 (output_bfd, plt_entry[1] | got_address_low | load, loc + 4);
9893 if (! LOAD_INTERLOCKS_P (output_bfd))
9895 bfd_put_32 (output_bfd, plt_entry[2] | got_address_low, loc + 8);
9896 bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
9900 bfd_put_32 (output_bfd, plt_entry[3], loc + 8);
9901 bfd_put_32 (output_bfd, plt_entry[2] | got_address_low, loc + 12);
9904 /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry. */
9905 mips_elf_output_dynamic_relocation (output_bfd, htab->srelplt,
9906 plt_index, h->dynindx,
9907 R_MIPS_JUMP_SLOT, got_address);
9909 /* We distinguish between PLT entries and lazy-binding stubs by
9910 giving the former an st_other value of STO_MIPS_PLT. Set the
9911 flag and leave the value if there are any relocations in the
9912 binary where pointer equality matters. */
9913 sym->st_shndx = SHN_UNDEF;
9914 if (h->pointer_equality_needed)
9915 sym->st_other = STO_MIPS_PLT;
9919 else if (h->plt.offset != MINUS_ONE)
9921 /* We've decided to create a lazy-binding stub. */
9922 bfd_byte stub[MIPS_FUNCTION_STUB_BIG_SIZE];
9924 /* This symbol has a stub. Set it up. */
9926 BFD_ASSERT (h->dynindx != -1);
9928 BFD_ASSERT ((htab->function_stub_size == MIPS_FUNCTION_STUB_BIG_SIZE)
9929 || (h->dynindx <= 0xffff));
9931 /* Values up to 2^31 - 1 are allowed. Larger values would cause
9932 sign extension at runtime in the stub, resulting in a negative
9934 if (h->dynindx & ~0x7fffffff)
9937 /* Fill the stub. */
9939 bfd_put_32 (output_bfd, STUB_LW (output_bfd), stub + idx);
9941 bfd_put_32 (output_bfd, STUB_MOVE (output_bfd), stub + idx);
9943 if (htab->function_stub_size == MIPS_FUNCTION_STUB_BIG_SIZE)
9945 bfd_put_32 (output_bfd, STUB_LUI ((h->dynindx >> 16) & 0x7fff),
9949 bfd_put_32 (output_bfd, STUB_JALR, stub + idx);
9952 /* If a large stub is not required and sign extension is not a
9953 problem, then use legacy code in the stub. */
9954 if (htab->function_stub_size == MIPS_FUNCTION_STUB_BIG_SIZE)
9955 bfd_put_32 (output_bfd, STUB_ORI (h->dynindx & 0xffff), stub + idx);
9956 else if (h->dynindx & ~0x7fff)
9957 bfd_put_32 (output_bfd, STUB_LI16U (h->dynindx & 0xffff), stub + idx);
9959 bfd_put_32 (output_bfd, STUB_LI16S (output_bfd, h->dynindx),
9962 BFD_ASSERT (h->plt.offset <= htab->sstubs->size);
9963 memcpy (htab->sstubs->contents + h->plt.offset,
9964 stub, htab->function_stub_size);
9966 /* Mark the symbol as undefined. plt.offset != -1 occurs
9967 only for the referenced symbol. */
9968 sym->st_shndx = SHN_UNDEF;
9970 /* The run-time linker uses the st_value field of the symbol
9971 to reset the global offset table entry for this external
9972 to its stub address when unlinking a shared object. */
9973 sym->st_value = (htab->sstubs->output_section->vma
9974 + htab->sstubs->output_offset
9978 /* If we have a MIPS16 function with a stub, the dynamic symbol must
9979 refer to the stub, since only the stub uses the standard calling
9981 if (h->dynindx != -1 && hmips->fn_stub != NULL)
9983 BFD_ASSERT (hmips->need_fn_stub);
9984 sym->st_value = (hmips->fn_stub->output_section->vma
9985 + hmips->fn_stub->output_offset);
9986 sym->st_size = hmips->fn_stub->size;
9987 sym->st_other = ELF_ST_VISIBILITY (sym->st_other);
9990 BFD_ASSERT (h->dynindx != -1
9991 || h->forced_local);
9995 BFD_ASSERT (g != NULL);
9997 /* Run through the global symbol table, creating GOT entries for all
9998 the symbols that need them. */
9999 if (hmips->global_got_area != GGA_NONE)
10004 value = sym->st_value;
10005 offset = mips_elf_global_got_index (dynobj, output_bfd, h,
10006 R_MIPS_GOT16, info);
10007 MIPS_ELF_PUT_WORD (output_bfd, value, sgot->contents + offset);
10010 if (hmips->global_got_area != GGA_NONE && g->next)
10012 struct mips_got_entry e, *p;
10018 e.abfd = output_bfd;
10023 for (g = g->next; g->next != gg; g = g->next)
10026 && (p = (struct mips_got_entry *) htab_find (g->got_entries,
10029 offset = p->gotidx;
10031 || (elf_hash_table (info)->dynamic_sections_created
10033 && p->d.h->root.def_dynamic
10034 && !p->d.h->root.def_regular))
10036 /* Create an R_MIPS_REL32 relocation for this entry. Due to
10037 the various compatibility problems, it's easier to mock
10038 up an R_MIPS_32 or R_MIPS_64 relocation and leave
10039 mips_elf_create_dynamic_relocation to calculate the
10040 appropriate addend. */
10041 Elf_Internal_Rela rel[3];
10043 memset (rel, 0, sizeof (rel));
10044 if (ABI_64_P (output_bfd))
10045 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_64);
10047 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_32);
10048 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
10051 if (! (mips_elf_create_dynamic_relocation
10052 (output_bfd, info, rel,
10053 e.d.h, NULL, sym->st_value, &entry, sgot)))
10057 entry = sym->st_value;
10058 MIPS_ELF_PUT_WORD (output_bfd, entry, sgot->contents + offset);
10063 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
10064 name = h->root.root.string;
10065 if (h == elf_hash_table (info)->hdynamic
10066 || h == elf_hash_table (info)->hgot)
10067 sym->st_shndx = SHN_ABS;
10068 else if (strcmp (name, "_DYNAMIC_LINK") == 0
10069 || strcmp (name, "_DYNAMIC_LINKING") == 0)
10071 sym->st_shndx = SHN_ABS;
10072 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
10075 else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (output_bfd))
10077 sym->st_shndx = SHN_ABS;
10078 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
10079 sym->st_value = elf_gp (output_bfd);
10081 else if (SGI_COMPAT (output_bfd))
10083 if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
10084 || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
10086 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
10087 sym->st_other = STO_PROTECTED;
10089 sym->st_shndx = SHN_MIPS_DATA;
10091 else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
10093 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
10094 sym->st_other = STO_PROTECTED;
10095 sym->st_value = mips_elf_hash_table (info)->procedure_count;
10096 sym->st_shndx = SHN_ABS;
10098 else if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS)
10100 if (h->type == STT_FUNC)
10101 sym->st_shndx = SHN_MIPS_TEXT;
10102 else if (h->type == STT_OBJECT)
10103 sym->st_shndx = SHN_MIPS_DATA;
10107 /* Emit a copy reloc, if needed. */
10113 BFD_ASSERT (h->dynindx != -1);
10114 BFD_ASSERT (htab->use_plts_and_copy_relocs);
10116 s = mips_elf_rel_dyn_section (info, FALSE);
10117 symval = (h->root.u.def.section->output_section->vma
10118 + h->root.u.def.section->output_offset
10119 + h->root.u.def.value);
10120 mips_elf_output_dynamic_relocation (output_bfd, s, s->reloc_count++,
10121 h->dynindx, R_MIPS_COPY, symval);
10124 /* Handle the IRIX6-specific symbols. */
10125 if (IRIX_COMPAT (output_bfd) == ict_irix6)
10126 mips_elf_irix6_finish_dynamic_symbol (output_bfd, name, sym);
10128 /* Keep dynamic MIPS16 symbols odd. This allows the dynamic linker to
10129 treat MIPS16 symbols like any other. */
10130 if (ELF_ST_IS_MIPS16 (sym->st_other))
10132 BFD_ASSERT (sym->st_value & 1);
10133 sym->st_other -= STO_MIPS16;
10139 /* Likewise, for VxWorks. */
10142 _bfd_mips_vxworks_finish_dynamic_symbol (bfd *output_bfd,
10143 struct bfd_link_info *info,
10144 struct elf_link_hash_entry *h,
10145 Elf_Internal_Sym *sym)
10149 struct mips_got_info *g;
10150 struct mips_elf_link_hash_table *htab;
10151 struct mips_elf_link_hash_entry *hmips;
10153 htab = mips_elf_hash_table (info);
10154 BFD_ASSERT (htab != NULL);
10155 dynobj = elf_hash_table (info)->dynobj;
10156 hmips = (struct mips_elf_link_hash_entry *) h;
10158 if (h->plt.offset != (bfd_vma) -1)
10161 bfd_vma plt_address, plt_index, got_address, got_offset, branch_offset;
10162 Elf_Internal_Rela rel;
10163 static const bfd_vma *plt_entry;
10165 BFD_ASSERT (h->dynindx != -1);
10166 BFD_ASSERT (htab->splt != NULL);
10167 BFD_ASSERT (h->plt.offset <= htab->splt->size);
10169 /* Calculate the address of the .plt entry. */
10170 plt_address = (htab->splt->output_section->vma
10171 + htab->splt->output_offset
10174 /* Calculate the index of the entry. */
10175 plt_index = ((h->plt.offset - htab->plt_header_size)
10176 / htab->plt_entry_size);
10178 /* Calculate the address of the .got.plt entry. */
10179 got_address = (htab->sgotplt->output_section->vma
10180 + htab->sgotplt->output_offset
10183 /* Calculate the offset of the .got.plt entry from
10184 _GLOBAL_OFFSET_TABLE_. */
10185 got_offset = mips_elf_gotplt_index (info, h);
10187 /* Calculate the offset for the branch at the start of the PLT
10188 entry. The branch jumps to the beginning of .plt. */
10189 branch_offset = -(h->plt.offset / 4 + 1) & 0xffff;
10191 /* Fill in the initial value of the .got.plt entry. */
10192 bfd_put_32 (output_bfd, plt_address,
10193 htab->sgotplt->contents + plt_index * 4);
10195 /* Find out where the .plt entry should go. */
10196 loc = htab->splt->contents + h->plt.offset;
10200 plt_entry = mips_vxworks_shared_plt_entry;
10201 bfd_put_32 (output_bfd, plt_entry[0] | branch_offset, loc);
10202 bfd_put_32 (output_bfd, plt_entry[1] | plt_index, loc + 4);
10206 bfd_vma got_address_high, got_address_low;
10208 plt_entry = mips_vxworks_exec_plt_entry;
10209 got_address_high = ((got_address + 0x8000) >> 16) & 0xffff;
10210 got_address_low = got_address & 0xffff;
10212 bfd_put_32 (output_bfd, plt_entry[0] | branch_offset, loc);
10213 bfd_put_32 (output_bfd, plt_entry[1] | plt_index, loc + 4);
10214 bfd_put_32 (output_bfd, plt_entry[2] | got_address_high, loc + 8);
10215 bfd_put_32 (output_bfd, plt_entry[3] | got_address_low, loc + 12);
10216 bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
10217 bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
10218 bfd_put_32 (output_bfd, plt_entry[6], loc + 24);
10219 bfd_put_32 (output_bfd, plt_entry[7], loc + 28);
10221 loc = (htab->srelplt2->contents
10222 + (plt_index * 3 + 2) * sizeof (Elf32_External_Rela));
10224 /* Emit a relocation for the .got.plt entry. */
10225 rel.r_offset = got_address;
10226 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_MIPS_32);
10227 rel.r_addend = h->plt.offset;
10228 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
10230 /* Emit a relocation for the lui of %hi(<.got.plt slot>). */
10231 loc += sizeof (Elf32_External_Rela);
10232 rel.r_offset = plt_address + 8;
10233 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
10234 rel.r_addend = got_offset;
10235 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
10237 /* Emit a relocation for the addiu of %lo(<.got.plt slot>). */
10238 loc += sizeof (Elf32_External_Rela);
10240 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
10241 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
10244 /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry. */
10245 loc = htab->srelplt->contents + plt_index * sizeof (Elf32_External_Rela);
10246 rel.r_offset = got_address;
10247 rel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_JUMP_SLOT);
10249 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
10251 if (!h->def_regular)
10252 sym->st_shndx = SHN_UNDEF;
10255 BFD_ASSERT (h->dynindx != -1 || h->forced_local);
10258 g = htab->got_info;
10259 BFD_ASSERT (g != NULL);
10261 /* See if this symbol has an entry in the GOT. */
10262 if (hmips->global_got_area != GGA_NONE)
10265 Elf_Internal_Rela outrel;
10269 /* Install the symbol value in the GOT. */
10270 offset = mips_elf_global_got_index (dynobj, output_bfd, h,
10271 R_MIPS_GOT16, info);
10272 MIPS_ELF_PUT_WORD (output_bfd, sym->st_value, sgot->contents + offset);
10274 /* Add a dynamic relocation for it. */
10275 s = mips_elf_rel_dyn_section (info, FALSE);
10276 loc = s->contents + (s->reloc_count++ * sizeof (Elf32_External_Rela));
10277 outrel.r_offset = (sgot->output_section->vma
10278 + sgot->output_offset
10280 outrel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_32);
10281 outrel.r_addend = 0;
10282 bfd_elf32_swap_reloca_out (dynobj, &outrel, loc);
10285 /* Emit a copy reloc, if needed. */
10288 Elf_Internal_Rela rel;
10290 BFD_ASSERT (h->dynindx != -1);
10292 rel.r_offset = (h->root.u.def.section->output_section->vma
10293 + h->root.u.def.section->output_offset
10294 + h->root.u.def.value);
10295 rel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_COPY);
10297 bfd_elf32_swap_reloca_out (output_bfd, &rel,
10298 htab->srelbss->contents
10299 + (htab->srelbss->reloc_count
10300 * sizeof (Elf32_External_Rela)));
10301 ++htab->srelbss->reloc_count;
10304 /* If this is a mips16/microMIPS symbol, force the value to be even. */
10305 if (ELF_ST_IS_COMPRESSED (sym->st_other))
10306 sym->st_value &= ~1;
10311 /* Write out a plt0 entry to the beginning of .plt. */
10314 mips_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
10317 bfd_vma gotplt_value, gotplt_value_high, gotplt_value_low;
10318 static const bfd_vma *plt_entry;
10319 struct mips_elf_link_hash_table *htab;
10321 htab = mips_elf_hash_table (info);
10322 BFD_ASSERT (htab != NULL);
10324 if (ABI_64_P (output_bfd))
10325 plt_entry = mips_n64_exec_plt0_entry;
10326 else if (ABI_N32_P (output_bfd))
10327 plt_entry = mips_n32_exec_plt0_entry;
10329 plt_entry = mips_o32_exec_plt0_entry;
10331 /* Calculate the value of .got.plt. */
10332 gotplt_value = (htab->sgotplt->output_section->vma
10333 + htab->sgotplt->output_offset);
10334 gotplt_value_high = ((gotplt_value + 0x8000) >> 16) & 0xffff;
10335 gotplt_value_low = gotplt_value & 0xffff;
10337 /* The PLT sequence is not safe for N64 if .got.plt's address can
10338 not be loaded in two instructions. */
10339 BFD_ASSERT ((gotplt_value & ~(bfd_vma) 0x7fffffff) == 0
10340 || ~(gotplt_value | 0x7fffffff) == 0);
10342 /* Install the PLT header. */
10343 loc = htab->splt->contents;
10344 bfd_put_32 (output_bfd, plt_entry[0] | gotplt_value_high, loc);
10345 bfd_put_32 (output_bfd, plt_entry[1] | gotplt_value_low, loc + 4);
10346 bfd_put_32 (output_bfd, plt_entry[2] | gotplt_value_low, loc + 8);
10347 bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
10348 bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
10349 bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
10350 bfd_put_32 (output_bfd, plt_entry[6], loc + 24);
10351 bfd_put_32 (output_bfd, plt_entry[7], loc + 28);
10354 /* Install the PLT header for a VxWorks executable and finalize the
10355 contents of .rela.plt.unloaded. */
10358 mips_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
10360 Elf_Internal_Rela rela;
10362 bfd_vma got_value, got_value_high, got_value_low, plt_address;
10363 static const bfd_vma *plt_entry;
10364 struct mips_elf_link_hash_table *htab;
10366 htab = mips_elf_hash_table (info);
10367 BFD_ASSERT (htab != NULL);
10369 plt_entry = mips_vxworks_exec_plt0_entry;
10371 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */
10372 got_value = (htab->root.hgot->root.u.def.section->output_section->vma
10373 + htab->root.hgot->root.u.def.section->output_offset
10374 + htab->root.hgot->root.u.def.value);
10376 got_value_high = ((got_value + 0x8000) >> 16) & 0xffff;
10377 got_value_low = got_value & 0xffff;
10379 /* Calculate the address of the PLT header. */
10380 plt_address = htab->splt->output_section->vma + htab->splt->output_offset;
10382 /* Install the PLT header. */
10383 loc = htab->splt->contents;
10384 bfd_put_32 (output_bfd, plt_entry[0] | got_value_high, loc);
10385 bfd_put_32 (output_bfd, plt_entry[1] | got_value_low, loc + 4);
10386 bfd_put_32 (output_bfd, plt_entry[2], loc + 8);
10387 bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
10388 bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
10389 bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
10391 /* Output the relocation for the lui of %hi(_GLOBAL_OFFSET_TABLE_). */
10392 loc = htab->srelplt2->contents;
10393 rela.r_offset = plt_address;
10394 rela.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
10396 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
10397 loc += sizeof (Elf32_External_Rela);
10399 /* Output the relocation for the following addiu of
10400 %lo(_GLOBAL_OFFSET_TABLE_). */
10401 rela.r_offset += 4;
10402 rela.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
10403 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
10404 loc += sizeof (Elf32_External_Rela);
10406 /* Fix up the remaining relocations. They may have the wrong
10407 symbol index for _G_O_T_ or _P_L_T_ depending on the order
10408 in which symbols were output. */
10409 while (loc < htab->srelplt2->contents + htab->srelplt2->size)
10411 Elf_Internal_Rela rel;
10413 bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
10414 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_MIPS_32);
10415 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
10416 loc += sizeof (Elf32_External_Rela);
10418 bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
10419 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
10420 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
10421 loc += sizeof (Elf32_External_Rela);
10423 bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
10424 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
10425 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
10426 loc += sizeof (Elf32_External_Rela);
10430 /* Install the PLT header for a VxWorks shared library. */
10433 mips_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
10436 struct mips_elf_link_hash_table *htab;
10438 htab = mips_elf_hash_table (info);
10439 BFD_ASSERT (htab != NULL);
10441 /* We just need to copy the entry byte-by-byte. */
10442 for (i = 0; i < ARRAY_SIZE (mips_vxworks_shared_plt0_entry); i++)
10443 bfd_put_32 (output_bfd, mips_vxworks_shared_plt0_entry[i],
10444 htab->splt->contents + i * 4);
10447 /* Finish up the dynamic sections. */
10450 _bfd_mips_elf_finish_dynamic_sections (bfd *output_bfd,
10451 struct bfd_link_info *info)
10456 struct mips_got_info *gg, *g;
10457 struct mips_elf_link_hash_table *htab;
10459 htab = mips_elf_hash_table (info);
10460 BFD_ASSERT (htab != NULL);
10462 dynobj = elf_hash_table (info)->dynobj;
10464 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
10467 gg = htab->got_info;
10469 if (elf_hash_table (info)->dynamic_sections_created)
10472 int dyn_to_skip = 0, dyn_skipped = 0;
10474 BFD_ASSERT (sdyn != NULL);
10475 BFD_ASSERT (gg != NULL);
10477 g = mips_elf_got_for_ibfd (gg, output_bfd);
10478 BFD_ASSERT (g != NULL);
10480 for (b = sdyn->contents;
10481 b < sdyn->contents + sdyn->size;
10482 b += MIPS_ELF_DYN_SIZE (dynobj))
10484 Elf_Internal_Dyn dyn;
10488 bfd_boolean swap_out_p;
10490 /* Read in the current dynamic entry. */
10491 (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
10493 /* Assume that we're going to modify it and write it out. */
10499 dyn.d_un.d_val = MIPS_ELF_REL_SIZE (dynobj);
10503 BFD_ASSERT (htab->is_vxworks);
10504 dyn.d_un.d_val = MIPS_ELF_RELA_SIZE (dynobj);
10508 /* Rewrite DT_STRSZ. */
10510 _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
10515 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
10518 case DT_MIPS_PLTGOT:
10520 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
10523 case DT_MIPS_RLD_VERSION:
10524 dyn.d_un.d_val = 1; /* XXX */
10527 case DT_MIPS_FLAGS:
10528 dyn.d_un.d_val = RHF_NOTPOT; /* XXX */
10531 case DT_MIPS_TIME_STAMP:
10535 dyn.d_un.d_val = t;
10539 case DT_MIPS_ICHECKSUM:
10541 swap_out_p = FALSE;
10544 case DT_MIPS_IVERSION:
10546 swap_out_p = FALSE;
10549 case DT_MIPS_BASE_ADDRESS:
10550 s = output_bfd->sections;
10551 BFD_ASSERT (s != NULL);
10552 dyn.d_un.d_ptr = s->vma & ~(bfd_vma) 0xffff;
10555 case DT_MIPS_LOCAL_GOTNO:
10556 dyn.d_un.d_val = g->local_gotno;
10559 case DT_MIPS_UNREFEXTNO:
10560 /* The index into the dynamic symbol table which is the
10561 entry of the first external symbol that is not
10562 referenced within the same object. */
10563 dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
10566 case DT_MIPS_GOTSYM:
10567 if (htab->global_gotsym)
10569 dyn.d_un.d_val = htab->global_gotsym->dynindx;
10572 /* In case if we don't have global got symbols we default
10573 to setting DT_MIPS_GOTSYM to the same value as
10574 DT_MIPS_SYMTABNO, so we just fall through. */
10576 case DT_MIPS_SYMTABNO:
10578 elemsize = MIPS_ELF_SYM_SIZE (output_bfd);
10579 s = bfd_get_section_by_name (output_bfd, name);
10580 BFD_ASSERT (s != NULL);
10582 dyn.d_un.d_val = s->size / elemsize;
10585 case DT_MIPS_HIPAGENO:
10586 dyn.d_un.d_val = g->local_gotno - htab->reserved_gotno;
10589 case DT_MIPS_RLD_MAP:
10591 struct elf_link_hash_entry *h;
10592 h = mips_elf_hash_table (info)->rld_symbol;
10595 dyn_to_skip = MIPS_ELF_DYN_SIZE (dynobj);
10596 swap_out_p = FALSE;
10599 s = h->root.u.def.section;
10600 dyn.d_un.d_ptr = (s->output_section->vma + s->output_offset
10601 + h->root.u.def.value);
10605 case DT_MIPS_OPTIONS:
10606 s = (bfd_get_section_by_name
10607 (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd)));
10608 dyn.d_un.d_ptr = s->vma;
10612 BFD_ASSERT (htab->is_vxworks);
10613 /* The count does not include the JUMP_SLOT relocations. */
10615 dyn.d_un.d_val -= htab->srelplt->size;
10619 BFD_ASSERT (htab->use_plts_and_copy_relocs);
10620 if (htab->is_vxworks)
10621 dyn.d_un.d_val = DT_RELA;
10623 dyn.d_un.d_val = DT_REL;
10627 BFD_ASSERT (htab->use_plts_and_copy_relocs);
10628 dyn.d_un.d_val = htab->srelplt->size;
10632 BFD_ASSERT (htab->use_plts_and_copy_relocs);
10633 dyn.d_un.d_ptr = (htab->srelplt->output_section->vma
10634 + htab->srelplt->output_offset);
10638 /* If we didn't need any text relocations after all, delete
10639 the dynamic tag. */
10640 if (!(info->flags & DF_TEXTREL))
10642 dyn_to_skip = MIPS_ELF_DYN_SIZE (dynobj);
10643 swap_out_p = FALSE;
10648 /* If we didn't need any text relocations after all, clear
10649 DF_TEXTREL from DT_FLAGS. */
10650 if (!(info->flags & DF_TEXTREL))
10651 dyn.d_un.d_val &= ~DF_TEXTREL;
10653 swap_out_p = FALSE;
10657 swap_out_p = FALSE;
10658 if (htab->is_vxworks
10659 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
10664 if (swap_out_p || dyn_skipped)
10665 (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
10666 (dynobj, &dyn, b - dyn_skipped);
10670 dyn_skipped += dyn_to_skip;
10675 /* Wipe out any trailing entries if we shifted down a dynamic tag. */
10676 if (dyn_skipped > 0)
10677 memset (b - dyn_skipped, 0, dyn_skipped);
10680 if (sgot != NULL && sgot->size > 0
10681 && !bfd_is_abs_section (sgot->output_section))
10683 if (htab->is_vxworks)
10685 /* The first entry of the global offset table points to the
10686 ".dynamic" section. The second is initialized by the
10687 loader and contains the shared library identifier.
10688 The third is also initialized by the loader and points
10689 to the lazy resolution stub. */
10690 MIPS_ELF_PUT_WORD (output_bfd,
10691 sdyn->output_offset + sdyn->output_section->vma,
10693 MIPS_ELF_PUT_WORD (output_bfd, 0,
10694 sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
10695 MIPS_ELF_PUT_WORD (output_bfd, 0,
10697 + 2 * MIPS_ELF_GOT_SIZE (output_bfd));
10701 /* The first entry of the global offset table will be filled at
10702 runtime. The second entry will be used by some runtime loaders.
10703 This isn't the case of IRIX rld. */
10704 MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0, sgot->contents);
10705 MIPS_ELF_PUT_WORD (output_bfd, MIPS_ELF_GNU_GOT1_MASK (output_bfd),
10706 sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
10709 elf_section_data (sgot->output_section)->this_hdr.sh_entsize
10710 = MIPS_ELF_GOT_SIZE (output_bfd);
10713 /* Generate dynamic relocations for the non-primary gots. */
10714 if (gg != NULL && gg->next)
10716 Elf_Internal_Rela rel[3];
10717 bfd_vma addend = 0;
10719 memset (rel, 0, sizeof (rel));
10720 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_REL32);
10722 for (g = gg->next; g->next != gg; g = g->next)
10724 bfd_vma got_index = g->next->local_gotno + g->next->global_gotno
10725 + g->next->tls_gotno;
10727 MIPS_ELF_PUT_WORD (output_bfd, 0, sgot->contents
10728 + got_index++ * MIPS_ELF_GOT_SIZE (output_bfd));
10729 MIPS_ELF_PUT_WORD (output_bfd, MIPS_ELF_GNU_GOT1_MASK (output_bfd),
10731 + got_index++ * MIPS_ELF_GOT_SIZE (output_bfd));
10733 if (! info->shared)
10736 while (got_index < g->assigned_gotno)
10738 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset
10739 = got_index++ * MIPS_ELF_GOT_SIZE (output_bfd);
10740 if (!(mips_elf_create_dynamic_relocation
10741 (output_bfd, info, rel, NULL,
10742 bfd_abs_section_ptr,
10743 0, &addend, sgot)))
10745 BFD_ASSERT (addend == 0);
10750 /* The generation of dynamic relocations for the non-primary gots
10751 adds more dynamic relocations. We cannot count them until
10754 if (elf_hash_table (info)->dynamic_sections_created)
10757 bfd_boolean swap_out_p;
10759 BFD_ASSERT (sdyn != NULL);
10761 for (b = sdyn->contents;
10762 b < sdyn->contents + sdyn->size;
10763 b += MIPS_ELF_DYN_SIZE (dynobj))
10765 Elf_Internal_Dyn dyn;
10768 /* Read in the current dynamic entry. */
10769 (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
10771 /* Assume that we're going to modify it and write it out. */
10777 /* Reduce DT_RELSZ to account for any relocations we
10778 decided not to make. This is for the n64 irix rld,
10779 which doesn't seem to apply any relocations if there
10780 are trailing null entries. */
10781 s = mips_elf_rel_dyn_section (info, FALSE);
10782 dyn.d_un.d_val = (s->reloc_count
10783 * (ABI_64_P (output_bfd)
10784 ? sizeof (Elf64_Mips_External_Rel)
10785 : sizeof (Elf32_External_Rel)));
10786 /* Adjust the section size too. Tools like the prelinker
10787 can reasonably expect the values to the same. */
10788 elf_section_data (s->output_section)->this_hdr.sh_size
10793 swap_out_p = FALSE;
10798 (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
10805 Elf32_compact_rel cpt;
10807 if (SGI_COMPAT (output_bfd))
10809 /* Write .compact_rel section out. */
10810 s = bfd_get_linker_section (dynobj, ".compact_rel");
10814 cpt.num = s->reloc_count;
10816 cpt.offset = (s->output_section->filepos
10817 + sizeof (Elf32_External_compact_rel));
10820 bfd_elf32_swap_compact_rel_out (output_bfd, &cpt,
10821 ((Elf32_External_compact_rel *)
10824 /* Clean up a dummy stub function entry in .text. */
10825 if (htab->sstubs != NULL)
10827 file_ptr dummy_offset;
10829 BFD_ASSERT (htab->sstubs->size >= htab->function_stub_size);
10830 dummy_offset = htab->sstubs->size - htab->function_stub_size;
10831 memset (htab->sstubs->contents + dummy_offset, 0,
10832 htab->function_stub_size);
10837 /* The psABI says that the dynamic relocations must be sorted in
10838 increasing order of r_symndx. The VxWorks EABI doesn't require
10839 this, and because the code below handles REL rather than RELA
10840 relocations, using it for VxWorks would be outright harmful. */
10841 if (!htab->is_vxworks)
10843 s = mips_elf_rel_dyn_section (info, FALSE);
10845 && s->size > (bfd_vma)2 * MIPS_ELF_REL_SIZE (output_bfd))
10847 reldyn_sorting_bfd = output_bfd;
10849 if (ABI_64_P (output_bfd))
10850 qsort ((Elf64_External_Rel *) s->contents + 1,
10851 s->reloc_count - 1, sizeof (Elf64_Mips_External_Rel),
10852 sort_dynamic_relocs_64);
10854 qsort ((Elf32_External_Rel *) s->contents + 1,
10855 s->reloc_count - 1, sizeof (Elf32_External_Rel),
10856 sort_dynamic_relocs);
10861 if (htab->splt && htab->splt->size > 0)
10863 if (htab->is_vxworks)
10866 mips_vxworks_finish_shared_plt (output_bfd, info);
10868 mips_vxworks_finish_exec_plt (output_bfd, info);
10872 BFD_ASSERT (!info->shared);
10873 mips_finish_exec_plt (output_bfd, info);
10880 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
10883 mips_set_isa_flags (bfd *abfd)
10887 switch (bfd_get_mach (abfd))
10890 case bfd_mach_mips3000:
10891 val = E_MIPS_ARCH_1;
10894 case bfd_mach_mips3900:
10895 val = E_MIPS_ARCH_1 | E_MIPS_MACH_3900;
10898 case bfd_mach_mips6000:
10899 val = E_MIPS_ARCH_2;
10902 case bfd_mach_mips4000:
10903 case bfd_mach_mips4300:
10904 case bfd_mach_mips4400:
10905 case bfd_mach_mips4600:
10906 val = E_MIPS_ARCH_3;
10909 case bfd_mach_mips4010:
10910 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4010;
10913 case bfd_mach_mips4100:
10914 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4100;
10917 case bfd_mach_mips4111:
10918 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4111;
10921 case bfd_mach_mips4120:
10922 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4120;
10925 case bfd_mach_mips4650:
10926 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4650;
10929 case bfd_mach_mips5400:
10930 val = E_MIPS_ARCH_4 | E_MIPS_MACH_5400;
10933 case bfd_mach_mips5500:
10934 val = E_MIPS_ARCH_4 | E_MIPS_MACH_5500;
10937 case bfd_mach_mips5900:
10938 val = E_MIPS_ARCH_3 | E_MIPS_MACH_5900;
10941 case bfd_mach_mips9000:
10942 val = E_MIPS_ARCH_4 | E_MIPS_MACH_9000;
10945 case bfd_mach_mips5000:
10946 case bfd_mach_mips7000:
10947 case bfd_mach_mips8000:
10948 case bfd_mach_mips10000:
10949 case bfd_mach_mips12000:
10950 case bfd_mach_mips14000:
10951 case bfd_mach_mips16000:
10952 val = E_MIPS_ARCH_4;
10955 case bfd_mach_mips5:
10956 val = E_MIPS_ARCH_5;
10959 case bfd_mach_mips_loongson_2e:
10960 val = E_MIPS_ARCH_3 | E_MIPS_MACH_LS2E;
10963 case bfd_mach_mips_loongson_2f:
10964 val = E_MIPS_ARCH_3 | E_MIPS_MACH_LS2F;
10967 case bfd_mach_mips_sb1:
10968 val = E_MIPS_ARCH_64 | E_MIPS_MACH_SB1;
10971 case bfd_mach_mips_loongson_3a:
10972 val = E_MIPS_ARCH_64 | E_MIPS_MACH_LS3A;
10975 case bfd_mach_mips_octeon:
10976 case bfd_mach_mips_octeonp:
10977 val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_OCTEON;
10980 case bfd_mach_mips_xlr:
10981 val = E_MIPS_ARCH_64 | E_MIPS_MACH_XLR;
10984 case bfd_mach_mips_octeon2:
10985 val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_OCTEON2;
10988 case bfd_mach_mipsisa32:
10989 val = E_MIPS_ARCH_32;
10992 case bfd_mach_mipsisa64:
10993 val = E_MIPS_ARCH_64;
10996 case bfd_mach_mipsisa32r2:
10997 val = E_MIPS_ARCH_32R2;
11000 case bfd_mach_mipsisa64r2:
11001 val = E_MIPS_ARCH_64R2;
11004 elf_elfheader (abfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
11005 elf_elfheader (abfd)->e_flags |= val;
11010 /* The final processing done just before writing out a MIPS ELF object
11011 file. This gets the MIPS architecture right based on the machine
11012 number. This is used by both the 32-bit and the 64-bit ABI. */
11015 _bfd_mips_elf_final_write_processing (bfd *abfd,
11016 bfd_boolean linker ATTRIBUTE_UNUSED)
11019 Elf_Internal_Shdr **hdrpp;
11023 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
11024 is nonzero. This is for compatibility with old objects, which used
11025 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
11026 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == 0)
11027 mips_set_isa_flags (abfd);
11029 /* Set the sh_info field for .gptab sections and other appropriate
11030 info for each special section. */
11031 for (i = 1, hdrpp = elf_elfsections (abfd) + 1;
11032 i < elf_numsections (abfd);
11035 switch ((*hdrpp)->sh_type)
11037 case SHT_MIPS_MSYM:
11038 case SHT_MIPS_LIBLIST:
11039 sec = bfd_get_section_by_name (abfd, ".dynstr");
11041 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
11044 case SHT_MIPS_GPTAB:
11045 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
11046 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
11047 BFD_ASSERT (name != NULL
11048 && CONST_STRNEQ (name, ".gptab."));
11049 sec = bfd_get_section_by_name (abfd, name + sizeof ".gptab" - 1);
11050 BFD_ASSERT (sec != NULL);
11051 (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
11054 case SHT_MIPS_CONTENT:
11055 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
11056 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
11057 BFD_ASSERT (name != NULL
11058 && CONST_STRNEQ (name, ".MIPS.content"));
11059 sec = bfd_get_section_by_name (abfd,
11060 name + sizeof ".MIPS.content" - 1);
11061 BFD_ASSERT (sec != NULL);
11062 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
11065 case SHT_MIPS_SYMBOL_LIB:
11066 sec = bfd_get_section_by_name (abfd, ".dynsym");
11068 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
11069 sec = bfd_get_section_by_name (abfd, ".liblist");
11071 (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
11074 case SHT_MIPS_EVENTS:
11075 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
11076 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
11077 BFD_ASSERT (name != NULL);
11078 if (CONST_STRNEQ (name, ".MIPS.events"))
11079 sec = bfd_get_section_by_name (abfd,
11080 name + sizeof ".MIPS.events" - 1);
11083 BFD_ASSERT (CONST_STRNEQ (name, ".MIPS.post_rel"));
11084 sec = bfd_get_section_by_name (abfd,
11086 + sizeof ".MIPS.post_rel" - 1));
11088 BFD_ASSERT (sec != NULL);
11089 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
11096 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
11100 _bfd_mips_elf_additional_program_headers (bfd *abfd,
11101 struct bfd_link_info *info ATTRIBUTE_UNUSED)
11106 /* See if we need a PT_MIPS_REGINFO segment. */
11107 s = bfd_get_section_by_name (abfd, ".reginfo");
11108 if (s && (s->flags & SEC_LOAD))
11111 /* See if we need a PT_MIPS_OPTIONS segment. */
11112 if (IRIX_COMPAT (abfd) == ict_irix6
11113 && bfd_get_section_by_name (abfd,
11114 MIPS_ELF_OPTIONS_SECTION_NAME (abfd)))
11117 /* See if we need a PT_MIPS_RTPROC segment. */
11118 if (IRIX_COMPAT (abfd) == ict_irix5
11119 && bfd_get_section_by_name (abfd, ".dynamic")
11120 && bfd_get_section_by_name (abfd, ".mdebug"))
11123 /* Allocate a PT_NULL header in dynamic objects. See
11124 _bfd_mips_elf_modify_segment_map for details. */
11125 if (!SGI_COMPAT (abfd)
11126 && bfd_get_section_by_name (abfd, ".dynamic"))
11132 /* Modify the segment map for an IRIX5 executable. */
11135 _bfd_mips_elf_modify_segment_map (bfd *abfd,
11136 struct bfd_link_info *info)
11139 struct elf_segment_map *m, **pm;
11142 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
11144 s = bfd_get_section_by_name (abfd, ".reginfo");
11145 if (s != NULL && (s->flags & SEC_LOAD) != 0)
11147 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
11148 if (m->p_type == PT_MIPS_REGINFO)
11153 m = bfd_zalloc (abfd, amt);
11157 m->p_type = PT_MIPS_REGINFO;
11159 m->sections[0] = s;
11161 /* We want to put it after the PHDR and INTERP segments. */
11162 pm = &elf_tdata (abfd)->segment_map;
11164 && ((*pm)->p_type == PT_PHDR
11165 || (*pm)->p_type == PT_INTERP))
11173 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
11174 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
11175 PT_MIPS_OPTIONS segment immediately following the program header
11177 if (NEWABI_P (abfd)
11178 /* On non-IRIX6 new abi, we'll have already created a segment
11179 for this section, so don't create another. I'm not sure this
11180 is not also the case for IRIX 6, but I can't test it right
11182 && IRIX_COMPAT (abfd) == ict_irix6)
11184 for (s = abfd->sections; s; s = s->next)
11185 if (elf_section_data (s)->this_hdr.sh_type == SHT_MIPS_OPTIONS)
11190 struct elf_segment_map *options_segment;
11192 pm = &elf_tdata (abfd)->segment_map;
11194 && ((*pm)->p_type == PT_PHDR
11195 || (*pm)->p_type == PT_INTERP))
11198 if (*pm == NULL || (*pm)->p_type != PT_MIPS_OPTIONS)
11200 amt = sizeof (struct elf_segment_map);
11201 options_segment = bfd_zalloc (abfd, amt);
11202 options_segment->next = *pm;
11203 options_segment->p_type = PT_MIPS_OPTIONS;
11204 options_segment->p_flags = PF_R;
11205 options_segment->p_flags_valid = TRUE;
11206 options_segment->count = 1;
11207 options_segment->sections[0] = s;
11208 *pm = options_segment;
11214 if (IRIX_COMPAT (abfd) == ict_irix5)
11216 /* If there are .dynamic and .mdebug sections, we make a room
11217 for the RTPROC header. FIXME: Rewrite without section names. */
11218 if (bfd_get_section_by_name (abfd, ".interp") == NULL
11219 && bfd_get_section_by_name (abfd, ".dynamic") != NULL
11220 && bfd_get_section_by_name (abfd, ".mdebug") != NULL)
11222 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
11223 if (m->p_type == PT_MIPS_RTPROC)
11228 m = bfd_zalloc (abfd, amt);
11232 m->p_type = PT_MIPS_RTPROC;
11234 s = bfd_get_section_by_name (abfd, ".rtproc");
11239 m->p_flags_valid = 1;
11244 m->sections[0] = s;
11247 /* We want to put it after the DYNAMIC segment. */
11248 pm = &elf_tdata (abfd)->segment_map;
11249 while (*pm != NULL && (*pm)->p_type != PT_DYNAMIC)
11259 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
11260 .dynstr, .dynsym, and .hash sections, and everything in
11262 for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL;
11264 if ((*pm)->p_type == PT_DYNAMIC)
11267 if (m != NULL && IRIX_COMPAT (abfd) == ict_none)
11269 /* For a normal mips executable the permissions for the PT_DYNAMIC
11270 segment are read, write and execute. We do that here since
11271 the code in elf.c sets only the read permission. This matters
11272 sometimes for the dynamic linker. */
11273 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
11275 m->p_flags = PF_R | PF_W | PF_X;
11276 m->p_flags_valid = 1;
11279 /* GNU/Linux binaries do not need the extended PT_DYNAMIC section.
11280 glibc's dynamic linker has traditionally derived the number of
11281 tags from the p_filesz field, and sometimes allocates stack
11282 arrays of that size. An overly-big PT_DYNAMIC segment can
11283 be actively harmful in such cases. Making PT_DYNAMIC contain
11284 other sections can also make life hard for the prelinker,
11285 which might move one of the other sections to a different
11286 PT_LOAD segment. */
11287 if (SGI_COMPAT (abfd)
11290 && strcmp (m->sections[0]->name, ".dynamic") == 0)
11292 static const char *sec_names[] =
11294 ".dynamic", ".dynstr", ".dynsym", ".hash"
11298 struct elf_segment_map *n;
11300 low = ~(bfd_vma) 0;
11302 for (i = 0; i < sizeof sec_names / sizeof sec_names[0]; i++)
11304 s = bfd_get_section_by_name (abfd, sec_names[i]);
11305 if (s != NULL && (s->flags & SEC_LOAD) != 0)
11312 if (high < s->vma + sz)
11313 high = s->vma + sz;
11318 for (s = abfd->sections; s != NULL; s = s->next)
11319 if ((s->flags & SEC_LOAD) != 0
11321 && s->vma + s->size <= high)
11324 amt = sizeof *n + (bfd_size_type) (c - 1) * sizeof (asection *);
11325 n = bfd_zalloc (abfd, amt);
11332 for (s = abfd->sections; s != NULL; s = s->next)
11334 if ((s->flags & SEC_LOAD) != 0
11336 && s->vma + s->size <= high)
11338 n->sections[i] = s;
11347 /* Allocate a spare program header in dynamic objects so that tools
11348 like the prelinker can add an extra PT_LOAD entry.
11350 If the prelinker needs to make room for a new PT_LOAD entry, its
11351 standard procedure is to move the first (read-only) sections into
11352 the new (writable) segment. However, the MIPS ABI requires
11353 .dynamic to be in a read-only segment, and the section will often
11354 start within sizeof (ElfNN_Phdr) bytes of the last program header.
11356 Although the prelinker could in principle move .dynamic to a
11357 writable segment, it seems better to allocate a spare program
11358 header instead, and avoid the need to move any sections.
11359 There is a long tradition of allocating spare dynamic tags,
11360 so allocating a spare program header seems like a natural
11363 If INFO is NULL, we may be copying an already prelinked binary
11364 with objcopy or strip, so do not add this header. */
11366 && !SGI_COMPAT (abfd)
11367 && bfd_get_section_by_name (abfd, ".dynamic"))
11369 for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL; pm = &(*pm)->next)
11370 if ((*pm)->p_type == PT_NULL)
11374 m = bfd_zalloc (abfd, sizeof (*m));
11378 m->p_type = PT_NULL;
11386 /* Return the section that should be marked against GC for a given
11390 _bfd_mips_elf_gc_mark_hook (asection *sec,
11391 struct bfd_link_info *info,
11392 Elf_Internal_Rela *rel,
11393 struct elf_link_hash_entry *h,
11394 Elf_Internal_Sym *sym)
11396 /* ??? Do mips16 stub sections need to be handled special? */
11399 switch (ELF_R_TYPE (sec->owner, rel->r_info))
11401 case R_MIPS_GNU_VTINHERIT:
11402 case R_MIPS_GNU_VTENTRY:
11406 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
11409 /* Update the got entry reference counts for the section being removed. */
11412 _bfd_mips_elf_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
11413 struct bfd_link_info *info ATTRIBUTE_UNUSED,
11414 asection *sec ATTRIBUTE_UNUSED,
11415 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
11418 Elf_Internal_Shdr *symtab_hdr;
11419 struct elf_link_hash_entry **sym_hashes;
11420 bfd_signed_vma *local_got_refcounts;
11421 const Elf_Internal_Rela *rel, *relend;
11422 unsigned long r_symndx;
11423 struct elf_link_hash_entry *h;
11425 if (info->relocatable)
11428 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
11429 sym_hashes = elf_sym_hashes (abfd);
11430 local_got_refcounts = elf_local_got_refcounts (abfd);
11432 relend = relocs + sec->reloc_count;
11433 for (rel = relocs; rel < relend; rel++)
11434 switch (ELF_R_TYPE (abfd, rel->r_info))
11436 case R_MIPS16_GOT16:
11437 case R_MIPS16_CALL16:
11439 case R_MIPS_CALL16:
11440 case R_MIPS_CALL_HI16:
11441 case R_MIPS_CALL_LO16:
11442 case R_MIPS_GOT_HI16:
11443 case R_MIPS_GOT_LO16:
11444 case R_MIPS_GOT_DISP:
11445 case R_MIPS_GOT_PAGE:
11446 case R_MIPS_GOT_OFST:
11447 case R_MICROMIPS_GOT16:
11448 case R_MICROMIPS_CALL16:
11449 case R_MICROMIPS_CALL_HI16:
11450 case R_MICROMIPS_CALL_LO16:
11451 case R_MICROMIPS_GOT_HI16:
11452 case R_MICROMIPS_GOT_LO16:
11453 case R_MICROMIPS_GOT_DISP:
11454 case R_MICROMIPS_GOT_PAGE:
11455 case R_MICROMIPS_GOT_OFST:
11456 /* ??? It would seem that the existing MIPS code does no sort
11457 of reference counting or whatnot on its GOT and PLT entries,
11458 so it is not possible to garbage collect them at this time. */
11469 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
11470 hiding the old indirect symbol. Process additional relocation
11471 information. Also called for weakdefs, in which case we just let
11472 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
11475 _bfd_mips_elf_copy_indirect_symbol (struct bfd_link_info *info,
11476 struct elf_link_hash_entry *dir,
11477 struct elf_link_hash_entry *ind)
11479 struct mips_elf_link_hash_entry *dirmips, *indmips;
11481 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
11483 dirmips = (struct mips_elf_link_hash_entry *) dir;
11484 indmips = (struct mips_elf_link_hash_entry *) ind;
11485 /* Any absolute non-dynamic relocations against an indirect or weak
11486 definition will be against the target symbol. */
11487 if (indmips->has_static_relocs)
11488 dirmips->has_static_relocs = TRUE;
11490 if (ind->root.type != bfd_link_hash_indirect)
11493 dirmips->possibly_dynamic_relocs += indmips->possibly_dynamic_relocs;
11494 if (indmips->readonly_reloc)
11495 dirmips->readonly_reloc = TRUE;
11496 if (indmips->no_fn_stub)
11497 dirmips->no_fn_stub = TRUE;
11498 if (indmips->fn_stub)
11500 dirmips->fn_stub = indmips->fn_stub;
11501 indmips->fn_stub = NULL;
11503 if (indmips->need_fn_stub)
11505 dirmips->need_fn_stub = TRUE;
11506 indmips->need_fn_stub = FALSE;
11508 if (indmips->call_stub)
11510 dirmips->call_stub = indmips->call_stub;
11511 indmips->call_stub = NULL;
11513 if (indmips->call_fp_stub)
11515 dirmips->call_fp_stub = indmips->call_fp_stub;
11516 indmips->call_fp_stub = NULL;
11518 if (indmips->global_got_area < dirmips->global_got_area)
11519 dirmips->global_got_area = indmips->global_got_area;
11520 if (indmips->global_got_area < GGA_NONE)
11521 indmips->global_got_area = GGA_NONE;
11522 if (indmips->has_nonpic_branches)
11523 dirmips->has_nonpic_branches = TRUE;
11525 if (dirmips->tls_ie_type == 0)
11526 dirmips->tls_ie_type = indmips->tls_ie_type;
11527 if (dirmips->tls_gd_type == 0)
11528 dirmips->tls_gd_type = indmips->tls_gd_type;
11531 #define PDR_SIZE 32
11534 _bfd_mips_elf_discard_info (bfd *abfd, struct elf_reloc_cookie *cookie,
11535 struct bfd_link_info *info)
11538 bfd_boolean ret = FALSE;
11539 unsigned char *tdata;
11542 o = bfd_get_section_by_name (abfd, ".pdr");
11547 if (o->size % PDR_SIZE != 0)
11549 if (o->output_section != NULL
11550 && bfd_is_abs_section (o->output_section))
11553 tdata = bfd_zmalloc (o->size / PDR_SIZE);
11557 cookie->rels = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
11558 info->keep_memory);
11565 cookie->rel = cookie->rels;
11566 cookie->relend = cookie->rels + o->reloc_count;
11568 for (i = 0, skip = 0; i < o->size / PDR_SIZE; i ++)
11570 if (bfd_elf_reloc_symbol_deleted_p (i * PDR_SIZE, cookie))
11579 mips_elf_section_data (o)->u.tdata = tdata;
11580 o->size -= skip * PDR_SIZE;
11586 if (! info->keep_memory)
11587 free (cookie->rels);
11593 _bfd_mips_elf_ignore_discarded_relocs (asection *sec)
11595 if (strcmp (sec->name, ".pdr") == 0)
11601 _bfd_mips_elf_write_section (bfd *output_bfd,
11602 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
11603 asection *sec, bfd_byte *contents)
11605 bfd_byte *to, *from, *end;
11608 if (strcmp (sec->name, ".pdr") != 0)
11611 if (mips_elf_section_data (sec)->u.tdata == NULL)
11615 end = contents + sec->size;
11616 for (from = contents, i = 0;
11618 from += PDR_SIZE, i++)
11620 if ((mips_elf_section_data (sec)->u.tdata)[i] == 1)
11623 memcpy (to, from, PDR_SIZE);
11626 bfd_set_section_contents (output_bfd, sec->output_section, contents,
11627 sec->output_offset, sec->size);
11631 /* microMIPS code retains local labels for linker relaxation. Omit them
11632 from output by default for clarity. */
11635 _bfd_mips_elf_is_target_special_symbol (bfd *abfd, asymbol *sym)
11637 return _bfd_elf_is_local_label_name (abfd, sym->name);
11640 /* MIPS ELF uses a special find_nearest_line routine in order the
11641 handle the ECOFF debugging information. */
11643 struct mips_elf_find_line
11645 struct ecoff_debug_info d;
11646 struct ecoff_find_line i;
11650 _bfd_mips_elf_find_nearest_line (bfd *abfd, asection *section,
11651 asymbol **symbols, bfd_vma offset,
11652 const char **filename_ptr,
11653 const char **functionname_ptr,
11654 unsigned int *line_ptr)
11658 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
11659 filename_ptr, functionname_ptr,
11663 if (_bfd_dwarf2_find_nearest_line (abfd, dwarf_debug_sections,
11664 section, symbols, offset,
11665 filename_ptr, functionname_ptr,
11666 line_ptr, NULL, ABI_64_P (abfd) ? 8 : 0,
11667 &elf_tdata (abfd)->dwarf2_find_line_info))
11670 msec = bfd_get_section_by_name (abfd, ".mdebug");
11673 flagword origflags;
11674 struct mips_elf_find_line *fi;
11675 const struct ecoff_debug_swap * const swap =
11676 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
11678 /* If we are called during a link, mips_elf_final_link may have
11679 cleared the SEC_HAS_CONTENTS field. We force it back on here
11680 if appropriate (which it normally will be). */
11681 origflags = msec->flags;
11682 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
11683 msec->flags |= SEC_HAS_CONTENTS;
11685 fi = elf_tdata (abfd)->find_line_info;
11688 bfd_size_type external_fdr_size;
11691 struct fdr *fdr_ptr;
11692 bfd_size_type amt = sizeof (struct mips_elf_find_line);
11694 fi = bfd_zalloc (abfd, amt);
11697 msec->flags = origflags;
11701 if (! _bfd_mips_elf_read_ecoff_info (abfd, msec, &fi->d))
11703 msec->flags = origflags;
11707 /* Swap in the FDR information. */
11708 amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
11709 fi->d.fdr = bfd_alloc (abfd, amt);
11710 if (fi->d.fdr == NULL)
11712 msec->flags = origflags;
11715 external_fdr_size = swap->external_fdr_size;
11716 fdr_ptr = fi->d.fdr;
11717 fraw_src = (char *) fi->d.external_fdr;
11718 fraw_end = (fraw_src
11719 + fi->d.symbolic_header.ifdMax * external_fdr_size);
11720 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
11721 (*swap->swap_fdr_in) (abfd, fraw_src, fdr_ptr);
11723 elf_tdata (abfd)->find_line_info = fi;
11725 /* Note that we don't bother to ever free this information.
11726 find_nearest_line is either called all the time, as in
11727 objdump -l, so the information should be saved, or it is
11728 rarely called, as in ld error messages, so the memory
11729 wasted is unimportant. Still, it would probably be a
11730 good idea for free_cached_info to throw it away. */
11733 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
11734 &fi->i, filename_ptr, functionname_ptr,
11737 msec->flags = origflags;
11741 msec->flags = origflags;
11744 /* Fall back on the generic ELF find_nearest_line routine. */
11746 return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
11747 filename_ptr, functionname_ptr,
11752 _bfd_mips_elf_find_inliner_info (bfd *abfd,
11753 const char **filename_ptr,
11754 const char **functionname_ptr,
11755 unsigned int *line_ptr)
11758 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
11759 functionname_ptr, line_ptr,
11760 & elf_tdata (abfd)->dwarf2_find_line_info);
11765 /* When are writing out the .options or .MIPS.options section,
11766 remember the bytes we are writing out, so that we can install the
11767 GP value in the section_processing routine. */
11770 _bfd_mips_elf_set_section_contents (bfd *abfd, sec_ptr section,
11771 const void *location,
11772 file_ptr offset, bfd_size_type count)
11774 if (MIPS_ELF_OPTIONS_SECTION_NAME_P (section->name))
11778 if (elf_section_data (section) == NULL)
11780 bfd_size_type amt = sizeof (struct bfd_elf_section_data);
11781 section->used_by_bfd = bfd_zalloc (abfd, amt);
11782 if (elf_section_data (section) == NULL)
11785 c = mips_elf_section_data (section)->u.tdata;
11788 c = bfd_zalloc (abfd, section->size);
11791 mips_elf_section_data (section)->u.tdata = c;
11794 memcpy (c + offset, location, count);
11797 return _bfd_elf_set_section_contents (abfd, section, location, offset,
11801 /* This is almost identical to bfd_generic_get_... except that some
11802 MIPS relocations need to be handled specially. Sigh. */
11805 _bfd_elf_mips_get_relocated_section_contents
11807 struct bfd_link_info *link_info,
11808 struct bfd_link_order *link_order,
11810 bfd_boolean relocatable,
11813 /* Get enough memory to hold the stuff */
11814 bfd *input_bfd = link_order->u.indirect.section->owner;
11815 asection *input_section = link_order->u.indirect.section;
11818 long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
11819 arelent **reloc_vector = NULL;
11822 if (reloc_size < 0)
11825 reloc_vector = bfd_malloc (reloc_size);
11826 if (reloc_vector == NULL && reloc_size != 0)
11829 /* read in the section */
11830 sz = input_section->rawsize ? input_section->rawsize : input_section->size;
11831 if (!bfd_get_section_contents (input_bfd, input_section, data, 0, sz))
11834 reloc_count = bfd_canonicalize_reloc (input_bfd,
11838 if (reloc_count < 0)
11841 if (reloc_count > 0)
11846 bfd_vma gp = 0x12345678; /* initialize just to shut gcc up */
11849 struct bfd_hash_entry *h;
11850 struct bfd_link_hash_entry *lh;
11851 /* Skip all this stuff if we aren't mixing formats. */
11852 if (abfd && input_bfd
11853 && abfd->xvec == input_bfd->xvec)
11857 h = bfd_hash_lookup (&link_info->hash->table, "_gp", FALSE, FALSE);
11858 lh = (struct bfd_link_hash_entry *) h;
11865 case bfd_link_hash_undefined:
11866 case bfd_link_hash_undefweak:
11867 case bfd_link_hash_common:
11870 case bfd_link_hash_defined:
11871 case bfd_link_hash_defweak:
11873 gp = lh->u.def.value;
11875 case bfd_link_hash_indirect:
11876 case bfd_link_hash_warning:
11878 /* @@FIXME ignoring warning for now */
11880 case bfd_link_hash_new:
11889 for (parent = reloc_vector; *parent != NULL; parent++)
11891 char *error_message = NULL;
11892 bfd_reloc_status_type r;
11894 /* Specific to MIPS: Deal with relocation types that require
11895 knowing the gp of the output bfd. */
11896 asymbol *sym = *(*parent)->sym_ptr_ptr;
11898 /* If we've managed to find the gp and have a special
11899 function for the relocation then go ahead, else default
11900 to the generic handling. */
11902 && (*parent)->howto->special_function
11903 == _bfd_mips_elf32_gprel16_reloc)
11904 r = _bfd_mips_elf_gprel16_with_gp (input_bfd, sym, *parent,
11905 input_section, relocatable,
11908 r = bfd_perform_relocation (input_bfd, *parent, data,
11910 relocatable ? abfd : NULL,
11915 asection *os = input_section->output_section;
11917 /* A partial link, so keep the relocs */
11918 os->orelocation[os->reloc_count] = *parent;
11922 if (r != bfd_reloc_ok)
11926 case bfd_reloc_undefined:
11927 if (!((*link_info->callbacks->undefined_symbol)
11928 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
11929 input_bfd, input_section, (*parent)->address, TRUE)))
11932 case bfd_reloc_dangerous:
11933 BFD_ASSERT (error_message != NULL);
11934 if (!((*link_info->callbacks->reloc_dangerous)
11935 (link_info, error_message, input_bfd, input_section,
11936 (*parent)->address)))
11939 case bfd_reloc_overflow:
11940 if (!((*link_info->callbacks->reloc_overflow)
11942 bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
11943 (*parent)->howto->name, (*parent)->addend,
11944 input_bfd, input_section, (*parent)->address)))
11947 case bfd_reloc_outofrange:
11956 if (reloc_vector != NULL)
11957 free (reloc_vector);
11961 if (reloc_vector != NULL)
11962 free (reloc_vector);
11967 mips_elf_relax_delete_bytes (bfd *abfd,
11968 asection *sec, bfd_vma addr, int count)
11970 Elf_Internal_Shdr *symtab_hdr;
11971 unsigned int sec_shndx;
11972 bfd_byte *contents;
11973 Elf_Internal_Rela *irel, *irelend;
11974 Elf_Internal_Sym *isym;
11975 Elf_Internal_Sym *isymend;
11976 struct elf_link_hash_entry **sym_hashes;
11977 struct elf_link_hash_entry **end_hashes;
11978 struct elf_link_hash_entry **start_hashes;
11979 unsigned int symcount;
11981 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
11982 contents = elf_section_data (sec)->this_hdr.contents;
11984 irel = elf_section_data (sec)->relocs;
11985 irelend = irel + sec->reloc_count;
11987 /* Actually delete the bytes. */
11988 memmove (contents + addr, contents + addr + count,
11989 (size_t) (sec->size - addr - count));
11990 sec->size -= count;
11992 /* Adjust all the relocs. */
11993 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
11995 /* Get the new reloc address. */
11996 if (irel->r_offset > addr)
11997 irel->r_offset -= count;
12000 BFD_ASSERT (addr % 2 == 0);
12001 BFD_ASSERT (count % 2 == 0);
12003 /* Adjust the local symbols defined in this section. */
12004 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12005 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
12006 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
12007 if (isym->st_shndx == sec_shndx && isym->st_value > addr)
12008 isym->st_value -= count;
12010 /* Now adjust the global symbols defined in this section. */
12011 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
12012 - symtab_hdr->sh_info);
12013 sym_hashes = start_hashes = elf_sym_hashes (abfd);
12014 end_hashes = sym_hashes + symcount;
12016 for (; sym_hashes < end_hashes; sym_hashes++)
12018 struct elf_link_hash_entry *sym_hash = *sym_hashes;
12020 if ((sym_hash->root.type == bfd_link_hash_defined
12021 || sym_hash->root.type == bfd_link_hash_defweak)
12022 && sym_hash->root.u.def.section == sec)
12024 bfd_vma value = sym_hash->root.u.def.value;
12026 if (ELF_ST_IS_MICROMIPS (sym_hash->other))
12027 value &= MINUS_TWO;
12029 sym_hash->root.u.def.value -= count;
12037 /* Opcodes needed for microMIPS relaxation as found in
12038 opcodes/micromips-opc.c. */
12040 struct opcode_descriptor {
12041 unsigned long match;
12042 unsigned long mask;
12045 /* The $ra register aka $31. */
12049 /* 32-bit instruction format register fields. */
12051 #define OP32_SREG(opcode) (((opcode) >> 16) & 0x1f)
12052 #define OP32_TREG(opcode) (((opcode) >> 21) & 0x1f)
12054 /* Check if a 5-bit register index can be abbreviated to 3 bits. */
12056 #define OP16_VALID_REG(r) \
12057 ((2 <= (r) && (r) <= 7) || (16 <= (r) && (r) <= 17))
12060 /* 32-bit and 16-bit branches. */
12062 static const struct opcode_descriptor b_insns_32[] = {
12063 { /* "b", "p", */ 0x40400000, 0xffff0000 }, /* bgez 0 */
12064 { /* "b", "p", */ 0x94000000, 0xffff0000 }, /* beq 0, 0 */
12065 { 0, 0 } /* End marker for find_match(). */
12068 static const struct opcode_descriptor bc_insn_32 =
12069 { /* "bc(1|2)(ft)", "N,p", */ 0x42800000, 0xfec30000 };
12071 static const struct opcode_descriptor bz_insn_32 =
12072 { /* "b(g|l)(e|t)z", "s,p", */ 0x40000000, 0xff200000 };
12074 static const struct opcode_descriptor bzal_insn_32 =
12075 { /* "b(ge|lt)zal", "s,p", */ 0x40200000, 0xffa00000 };
12077 static const struct opcode_descriptor beq_insn_32 =
12078 { /* "b(eq|ne)", "s,t,p", */ 0x94000000, 0xdc000000 };
12080 static const struct opcode_descriptor b_insn_16 =
12081 { /* "b", "mD", */ 0xcc00, 0xfc00 };
12083 static const struct opcode_descriptor bz_insn_16 =
12084 { /* "b(eq|ne)z", "md,mE", */ 0x8c00, 0xdc00 };
12087 /* 32-bit and 16-bit branch EQ and NE zero. */
12089 /* NOTE: All opcode tables have BEQ/BNE in the same order: first the
12090 eq and second the ne. This convention is used when replacing a
12091 32-bit BEQ/BNE with the 16-bit version. */
12093 #define BZC32_REG_FIELD(r) (((r) & 0x1f) << 16)
12095 static const struct opcode_descriptor bz_rs_insns_32[] = {
12096 { /* "beqz", "s,p", */ 0x94000000, 0xffe00000 },
12097 { /* "bnez", "s,p", */ 0xb4000000, 0xffe00000 },
12098 { 0, 0 } /* End marker for find_match(). */
12101 static const struct opcode_descriptor bz_rt_insns_32[] = {
12102 { /* "beqz", "t,p", */ 0x94000000, 0xfc01f000 },
12103 { /* "bnez", "t,p", */ 0xb4000000, 0xfc01f000 },
12104 { 0, 0 } /* End marker for find_match(). */
12107 static const struct opcode_descriptor bzc_insns_32[] = {
12108 { /* "beqzc", "s,p", */ 0x40e00000, 0xffe00000 },
12109 { /* "bnezc", "s,p", */ 0x40a00000, 0xffe00000 },
12110 { 0, 0 } /* End marker for find_match(). */
12113 static const struct opcode_descriptor bz_insns_16[] = {
12114 { /* "beqz", "md,mE", */ 0x8c00, 0xfc00 },
12115 { /* "bnez", "md,mE", */ 0xac00, 0xfc00 },
12116 { 0, 0 } /* End marker for find_match(). */
12119 /* Switch between a 5-bit register index and its 3-bit shorthand. */
12121 #define BZ16_REG(opcode) ((((((opcode) >> 7) & 7) + 0x1e) & 0x17) + 2)
12122 #define BZ16_REG_FIELD(r) \
12123 (((2 <= (r) && (r) <= 7) ? (r) : ((r) - 16)) << 7)
12126 /* 32-bit instructions with a delay slot. */
12128 static const struct opcode_descriptor jal_insn_32_bd16 =
12129 { /* "jals", "a", */ 0x74000000, 0xfc000000 };
12131 static const struct opcode_descriptor jal_insn_32_bd32 =
12132 { /* "jal", "a", */ 0xf4000000, 0xfc000000 };
12134 static const struct opcode_descriptor jal_x_insn_32_bd32 =
12135 { /* "jal[x]", "a", */ 0xf0000000, 0xf8000000 };
12137 static const struct opcode_descriptor j_insn_32 =
12138 { /* "j", "a", */ 0xd4000000, 0xfc000000 };
12140 static const struct opcode_descriptor jalr_insn_32 =
12141 { /* "jalr[.hb]", "t,s", */ 0x00000f3c, 0xfc00efff };
12143 /* This table can be compacted, because no opcode replacement is made. */
12145 static const struct opcode_descriptor ds_insns_32_bd16[] = {
12146 { /* "jals", "a", */ 0x74000000, 0xfc000000 },
12148 { /* "jalrs[.hb]", "t,s", */ 0x00004f3c, 0xfc00efff },
12149 { /* "b(ge|lt)zals", "s,p", */ 0x42200000, 0xffa00000 },
12151 { /* "b(g|l)(e|t)z", "s,p", */ 0x40000000, 0xff200000 },
12152 { /* "b(eq|ne)", "s,t,p", */ 0x94000000, 0xdc000000 },
12153 { /* "j", "a", */ 0xd4000000, 0xfc000000 },
12154 { 0, 0 } /* End marker for find_match(). */
12157 /* This table can be compacted, because no opcode replacement is made. */
12159 static const struct opcode_descriptor ds_insns_32_bd32[] = {
12160 { /* "jal[x]", "a", */ 0xf0000000, 0xf8000000 },
12162 { /* "jalr[.hb]", "t,s", */ 0x00000f3c, 0xfc00efff },
12163 { /* "b(ge|lt)zal", "s,p", */ 0x40200000, 0xffa00000 },
12164 { 0, 0 } /* End marker for find_match(). */
12168 /* 16-bit instructions with a delay slot. */
12170 static const struct opcode_descriptor jalr_insn_16_bd16 =
12171 { /* "jalrs", "my,mj", */ 0x45e0, 0xffe0 };
12173 static const struct opcode_descriptor jalr_insn_16_bd32 =
12174 { /* "jalr", "my,mj", */ 0x45c0, 0xffe0 };
12176 static const struct opcode_descriptor jr_insn_16 =
12177 { /* "jr", "mj", */ 0x4580, 0xffe0 };
12179 #define JR16_REG(opcode) ((opcode) & 0x1f)
12181 /* This table can be compacted, because no opcode replacement is made. */
12183 static const struct opcode_descriptor ds_insns_16_bd16[] = {
12184 { /* "jalrs", "my,mj", */ 0x45e0, 0xffe0 },
12186 { /* "b", "mD", */ 0xcc00, 0xfc00 },
12187 { /* "b(eq|ne)z", "md,mE", */ 0x8c00, 0xdc00 },
12188 { /* "jr", "mj", */ 0x4580, 0xffe0 },
12189 { 0, 0 } /* End marker for find_match(). */
12193 /* LUI instruction. */
12195 static const struct opcode_descriptor lui_insn =
12196 { /* "lui", "s,u", */ 0x41a00000, 0xffe00000 };
12199 /* ADDIU instruction. */
12201 static const struct opcode_descriptor addiu_insn =
12202 { /* "addiu", "t,r,j", */ 0x30000000, 0xfc000000 };
12204 static const struct opcode_descriptor addiupc_insn =
12205 { /* "addiu", "mb,$pc,mQ", */ 0x78000000, 0xfc000000 };
12207 #define ADDIUPC_REG_FIELD(r) \
12208 (((2 <= (r) && (r) <= 7) ? (r) : ((r) - 16)) << 23)
12211 /* Relaxable instructions in a JAL delay slot: MOVE. */
12213 /* The 16-bit move has rd in 9:5 and rs in 4:0. The 32-bit moves
12214 (ADDU, OR) have rd in 15:11 and rs in 10:16. */
12215 #define MOVE32_RD(opcode) (((opcode) >> 11) & 0x1f)
12216 #define MOVE32_RS(opcode) (((opcode) >> 16) & 0x1f)
12218 #define MOVE16_RD_FIELD(r) (((r) & 0x1f) << 5)
12219 #define MOVE16_RS_FIELD(r) (((r) & 0x1f) )
12221 static const struct opcode_descriptor move_insns_32[] = {
12222 { /* "move", "d,s", */ 0x00000150, 0xffe007ff }, /* addu d,s,$0 */
12223 { /* "move", "d,s", */ 0x00000290, 0xffe007ff }, /* or d,s,$0 */
12224 { 0, 0 } /* End marker for find_match(). */
12227 static const struct opcode_descriptor move_insn_16 =
12228 { /* "move", "mp,mj", */ 0x0c00, 0xfc00 };
12231 /* NOP instructions. */
12233 static const struct opcode_descriptor nop_insn_32 =
12234 { /* "nop", "", */ 0x00000000, 0xffffffff };
12236 static const struct opcode_descriptor nop_insn_16 =
12237 { /* "nop", "", */ 0x0c00, 0xffff };
12240 /* Instruction match support. */
12242 #define MATCH(opcode, insn) ((opcode & insn.mask) == insn.match)
12245 find_match (unsigned long opcode, const struct opcode_descriptor insn[])
12247 unsigned long indx;
12249 for (indx = 0; insn[indx].mask != 0; indx++)
12250 if (MATCH (opcode, insn[indx]))
12257 /* Branch and delay slot decoding support. */
12259 /* If PTR points to what *might* be a 16-bit branch or jump, then
12260 return the minimum length of its delay slot, otherwise return 0.
12261 Non-zero results are not definitive as we might be checking against
12262 the second half of another instruction. */
12265 check_br16_dslot (bfd *abfd, bfd_byte *ptr)
12267 unsigned long opcode;
12270 opcode = bfd_get_16 (abfd, ptr);
12271 if (MATCH (opcode, jalr_insn_16_bd32) != 0)
12272 /* 16-bit branch/jump with a 32-bit delay slot. */
12274 else if (MATCH (opcode, jalr_insn_16_bd16) != 0
12275 || find_match (opcode, ds_insns_16_bd16) >= 0)
12276 /* 16-bit branch/jump with a 16-bit delay slot. */
12279 /* No delay slot. */
12285 /* If PTR points to what *might* be a 32-bit branch or jump, then
12286 return the minimum length of its delay slot, otherwise return 0.
12287 Non-zero results are not definitive as we might be checking against
12288 the second half of another instruction. */
12291 check_br32_dslot (bfd *abfd, bfd_byte *ptr)
12293 unsigned long opcode;
12296 opcode = bfd_get_micromips_32 (abfd, ptr);
12297 if (find_match (opcode, ds_insns_32_bd32) >= 0)
12298 /* 32-bit branch/jump with a 32-bit delay slot. */
12300 else if (find_match (opcode, ds_insns_32_bd16) >= 0)
12301 /* 32-bit branch/jump with a 16-bit delay slot. */
12304 /* No delay slot. */
12310 /* If PTR points to a 16-bit branch or jump with a 32-bit delay slot
12311 that doesn't fiddle with REG, then return TRUE, otherwise FALSE. */
12314 check_br16 (bfd *abfd, bfd_byte *ptr, unsigned long reg)
12316 unsigned long opcode;
12318 opcode = bfd_get_16 (abfd, ptr);
12319 if (MATCH (opcode, b_insn_16)
12321 || (MATCH (opcode, jr_insn_16) && reg != JR16_REG (opcode))
12323 || (MATCH (opcode, bz_insn_16) && reg != BZ16_REG (opcode))
12324 /* BEQZ16, BNEZ16 */
12325 || (MATCH (opcode, jalr_insn_16_bd32)
12327 && reg != JR16_REG (opcode) && reg != RA))
12333 /* If PTR points to a 32-bit branch or jump that doesn't fiddle with REG,
12334 then return TRUE, otherwise FALSE. */
12337 check_br32 (bfd *abfd, bfd_byte *ptr, unsigned long reg)
12339 unsigned long opcode;
12341 opcode = bfd_get_micromips_32 (abfd, ptr);
12342 if (MATCH (opcode, j_insn_32)
12344 || MATCH (opcode, bc_insn_32)
12345 /* BC1F, BC1T, BC2F, BC2T */
12346 || (MATCH (opcode, jal_x_insn_32_bd32) && reg != RA)
12348 || (MATCH (opcode, bz_insn_32) && reg != OP32_SREG (opcode))
12349 /* BGEZ, BGTZ, BLEZ, BLTZ */
12350 || (MATCH (opcode, bzal_insn_32)
12351 /* BGEZAL, BLTZAL */
12352 && reg != OP32_SREG (opcode) && reg != RA)
12353 || ((MATCH (opcode, jalr_insn_32) || MATCH (opcode, beq_insn_32))
12354 /* JALR, JALR.HB, BEQ, BNE */
12355 && reg != OP32_SREG (opcode) && reg != OP32_TREG (opcode)))
12361 /* If the instruction encoding at PTR and relocations [INTERNAL_RELOCS,
12362 IRELEND) at OFFSET indicate that there must be a compact branch there,
12363 then return TRUE, otherwise FALSE. */
12366 check_relocated_bzc (bfd *abfd, const bfd_byte *ptr, bfd_vma offset,
12367 const Elf_Internal_Rela *internal_relocs,
12368 const Elf_Internal_Rela *irelend)
12370 const Elf_Internal_Rela *irel;
12371 unsigned long opcode;
12373 opcode = bfd_get_micromips_32 (abfd, ptr);
12374 if (find_match (opcode, bzc_insns_32) < 0)
12377 for (irel = internal_relocs; irel < irelend; irel++)
12378 if (irel->r_offset == offset
12379 && ELF32_R_TYPE (irel->r_info) == R_MICROMIPS_PC16_S1)
12385 /* Bitsize checking. */
12386 #define IS_BITSIZE(val, N) \
12387 (((((val) & ((1ULL << (N)) - 1)) ^ (1ULL << ((N) - 1))) \
12388 - (1ULL << ((N) - 1))) == (val))
12392 _bfd_mips_elf_relax_section (bfd *abfd, asection *sec,
12393 struct bfd_link_info *link_info,
12394 bfd_boolean *again)
12396 Elf_Internal_Shdr *symtab_hdr;
12397 Elf_Internal_Rela *internal_relocs;
12398 Elf_Internal_Rela *irel, *irelend;
12399 bfd_byte *contents = NULL;
12400 Elf_Internal_Sym *isymbuf = NULL;
12402 /* Assume nothing changes. */
12405 /* We don't have to do anything for a relocatable link, if
12406 this section does not have relocs, or if this is not a
12409 if (link_info->relocatable
12410 || (sec->flags & SEC_RELOC) == 0
12411 || sec->reloc_count == 0
12412 || (sec->flags & SEC_CODE) == 0)
12415 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12417 /* Get a copy of the native relocations. */
12418 internal_relocs = (_bfd_elf_link_read_relocs
12419 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
12420 link_info->keep_memory));
12421 if (internal_relocs == NULL)
12424 /* Walk through them looking for relaxing opportunities. */
12425 irelend = internal_relocs + sec->reloc_count;
12426 for (irel = internal_relocs; irel < irelend; irel++)
12428 unsigned long r_symndx = ELF32_R_SYM (irel->r_info);
12429 unsigned int r_type = ELF32_R_TYPE (irel->r_info);
12430 bfd_boolean target_is_micromips_code_p;
12431 unsigned long opcode;
12437 /* The number of bytes to delete for relaxation and from where
12438 to delete these bytes starting at irel->r_offset. */
12442 /* If this isn't something that can be relaxed, then ignore
12444 if (r_type != R_MICROMIPS_HI16
12445 && r_type != R_MICROMIPS_PC16_S1
12446 && r_type != R_MICROMIPS_26_S1)
12449 /* Get the section contents if we haven't done so already. */
12450 if (contents == NULL)
12452 /* Get cached copy if it exists. */
12453 if (elf_section_data (sec)->this_hdr.contents != NULL)
12454 contents = elf_section_data (sec)->this_hdr.contents;
12455 /* Go get them off disk. */
12456 else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
12459 ptr = contents + irel->r_offset;
12461 /* Read this BFD's local symbols if we haven't done so already. */
12462 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
12464 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
12465 if (isymbuf == NULL)
12466 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
12467 symtab_hdr->sh_info, 0,
12469 if (isymbuf == NULL)
12473 /* Get the value of the symbol referred to by the reloc. */
12474 if (r_symndx < symtab_hdr->sh_info)
12476 /* A local symbol. */
12477 Elf_Internal_Sym *isym;
12480 isym = isymbuf + r_symndx;
12481 if (isym->st_shndx == SHN_UNDEF)
12482 sym_sec = bfd_und_section_ptr;
12483 else if (isym->st_shndx == SHN_ABS)
12484 sym_sec = bfd_abs_section_ptr;
12485 else if (isym->st_shndx == SHN_COMMON)
12486 sym_sec = bfd_com_section_ptr;
12488 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
12489 symval = (isym->st_value
12490 + sym_sec->output_section->vma
12491 + sym_sec->output_offset);
12492 target_is_micromips_code_p = ELF_ST_IS_MICROMIPS (isym->st_other);
12496 unsigned long indx;
12497 struct elf_link_hash_entry *h;
12499 /* An external symbol. */
12500 indx = r_symndx - symtab_hdr->sh_info;
12501 h = elf_sym_hashes (abfd)[indx];
12502 BFD_ASSERT (h != NULL);
12504 if (h->root.type != bfd_link_hash_defined
12505 && h->root.type != bfd_link_hash_defweak)
12506 /* This appears to be a reference to an undefined
12507 symbol. Just ignore it -- it will be caught by the
12508 regular reloc processing. */
12511 symval = (h->root.u.def.value
12512 + h->root.u.def.section->output_section->vma
12513 + h->root.u.def.section->output_offset);
12514 target_is_micromips_code_p = (!h->needs_plt
12515 && ELF_ST_IS_MICROMIPS (h->other));
12519 /* For simplicity of coding, we are going to modify the
12520 section contents, the section relocs, and the BFD symbol
12521 table. We must tell the rest of the code not to free up this
12522 information. It would be possible to instead create a table
12523 of changes which have to be made, as is done in coff-mips.c;
12524 that would be more work, but would require less memory when
12525 the linker is run. */
12527 /* Only 32-bit instructions relaxed. */
12528 if (irel->r_offset + 4 > sec->size)
12531 opcode = bfd_get_micromips_32 (abfd, ptr);
12533 /* This is the pc-relative distance from the instruction the
12534 relocation is applied to, to the symbol referred. */
12536 - (sec->output_section->vma + sec->output_offset)
12539 /* R_MICROMIPS_HI16 / LUI relaxation to nil, performing relaxation
12540 of corresponding R_MICROMIPS_LO16 to R_MICROMIPS_HI0_LO16 or
12541 R_MICROMIPS_PC23_S2. The R_MICROMIPS_PC23_S2 condition is
12543 (symval % 4 == 0 && IS_BITSIZE (pcrval, 25))
12545 where pcrval has first to be adjusted to apply against the LO16
12546 location (we make the adjustment later on, when we have figured
12547 out the offset). */
12548 if (r_type == R_MICROMIPS_HI16 && MATCH (opcode, lui_insn))
12550 bfd_boolean bzc = FALSE;
12551 unsigned long nextopc;
12555 /* Give up if the previous reloc was a HI16 against this symbol
12557 if (irel > internal_relocs
12558 && ELF32_R_TYPE (irel[-1].r_info) == R_MICROMIPS_HI16
12559 && ELF32_R_SYM (irel[-1].r_info) == r_symndx)
12562 /* Or if the next reloc is not a LO16 against this symbol. */
12563 if (irel + 1 >= irelend
12564 || ELF32_R_TYPE (irel[1].r_info) != R_MICROMIPS_LO16
12565 || ELF32_R_SYM (irel[1].r_info) != r_symndx)
12568 /* Or if the second next reloc is a LO16 against this symbol too. */
12569 if (irel + 2 >= irelend
12570 && ELF32_R_TYPE (irel[2].r_info) == R_MICROMIPS_LO16
12571 && ELF32_R_SYM (irel[2].r_info) == r_symndx)
12574 /* See if the LUI instruction *might* be in a branch delay slot.
12575 We check whether what looks like a 16-bit branch or jump is
12576 actually an immediate argument to a compact branch, and let
12577 it through if so. */
12578 if (irel->r_offset >= 2
12579 && check_br16_dslot (abfd, ptr - 2)
12580 && !(irel->r_offset >= 4
12581 && (bzc = check_relocated_bzc (abfd,
12582 ptr - 4, irel->r_offset - 4,
12583 internal_relocs, irelend))))
12585 if (irel->r_offset >= 4
12587 && check_br32_dslot (abfd, ptr - 4))
12590 reg = OP32_SREG (opcode);
12592 /* We only relax adjacent instructions or ones separated with
12593 a branch or jump that has a delay slot. The branch or jump
12594 must not fiddle with the register used to hold the address.
12595 Subtract 4 for the LUI itself. */
12596 offset = irel[1].r_offset - irel[0].r_offset;
12597 switch (offset - 4)
12602 if (check_br16 (abfd, ptr + 4, reg))
12606 if (check_br32 (abfd, ptr + 4, reg))
12613 nextopc = bfd_get_micromips_32 (abfd, contents + irel[1].r_offset);
12615 /* Give up unless the same register is used with both
12617 if (OP32_SREG (nextopc) != reg)
12620 /* Now adjust pcrval, subtracting the offset to the LO16 reloc
12621 and rounding up to take masking of the two LSBs into account. */
12622 pcrval = ((pcrval - offset + 3) | 3) ^ 3;
12624 /* R_MICROMIPS_LO16 relaxation to R_MICROMIPS_HI0_LO16. */
12625 if (IS_BITSIZE (symval, 16))
12627 /* Fix the relocation's type. */
12628 irel[1].r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_HI0_LO16);
12630 /* Instructions using R_MICROMIPS_LO16 have the base or
12631 source register in bits 20:16. This register becomes $0
12632 (zero) as the result of the R_MICROMIPS_HI16 being 0. */
12633 nextopc &= ~0x001f0000;
12634 bfd_put_16 (abfd, (nextopc >> 16) & 0xffff,
12635 contents + irel[1].r_offset);
12638 /* R_MICROMIPS_LO16 / ADDIU relaxation to R_MICROMIPS_PC23_S2.
12639 We add 4 to take LUI deletion into account while checking
12640 the PC-relative distance. */
12641 else if (symval % 4 == 0
12642 && IS_BITSIZE (pcrval + 4, 25)
12643 && MATCH (nextopc, addiu_insn)
12644 && OP32_TREG (nextopc) == OP32_SREG (nextopc)
12645 && OP16_VALID_REG (OP32_TREG (nextopc)))
12647 /* Fix the relocation's type. */
12648 irel[1].r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC23_S2);
12650 /* Replace ADDIU with the ADDIUPC version. */
12651 nextopc = (addiupc_insn.match
12652 | ADDIUPC_REG_FIELD (OP32_TREG (nextopc)));
12654 bfd_put_micromips_32 (abfd, nextopc,
12655 contents + irel[1].r_offset);
12658 /* Can't do anything, give up, sigh... */
12662 /* Fix the relocation's type. */
12663 irel->r_info = ELF32_R_INFO (r_symndx, R_MIPS_NONE);
12665 /* Delete the LUI instruction: 4 bytes at irel->r_offset. */
12670 /* Compact branch relaxation -- due to the multitude of macros
12671 employed by the compiler/assembler, compact branches are not
12672 always generated. Obviously, this can/will be fixed elsewhere,
12673 but there is no drawback in double checking it here. */
12674 else if (r_type == R_MICROMIPS_PC16_S1
12675 && irel->r_offset + 5 < sec->size
12676 && ((fndopc = find_match (opcode, bz_rs_insns_32)) >= 0
12677 || (fndopc = find_match (opcode, bz_rt_insns_32)) >= 0)
12678 && MATCH (bfd_get_16 (abfd, ptr + 4), nop_insn_16))
12682 reg = OP32_SREG (opcode) ? OP32_SREG (opcode) : OP32_TREG (opcode);
12684 /* Replace BEQZ/BNEZ with the compact version. */
12685 opcode = (bzc_insns_32[fndopc].match
12686 | BZC32_REG_FIELD (reg)
12687 | (opcode & 0xffff)); /* Addend value. */
12689 bfd_put_micromips_32 (abfd, opcode, ptr);
12691 /* Delete the 16-bit delay slot NOP: two bytes from
12692 irel->offset + 4. */
12697 /* R_MICROMIPS_PC16_S1 relaxation to R_MICROMIPS_PC10_S1. We need
12698 to check the distance from the next instruction, so subtract 2. */
12699 else if (r_type == R_MICROMIPS_PC16_S1
12700 && IS_BITSIZE (pcrval - 2, 11)
12701 && find_match (opcode, b_insns_32) >= 0)
12703 /* Fix the relocation's type. */
12704 irel->r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC10_S1);
12706 /* Replace the 32-bit opcode with a 16-bit opcode. */
12709 | (opcode & 0x3ff)), /* Addend value. */
12712 /* Delete 2 bytes from irel->r_offset + 2. */
12717 /* R_MICROMIPS_PC16_S1 relaxation to R_MICROMIPS_PC7_S1. We need
12718 to check the distance from the next instruction, so subtract 2. */
12719 else if (r_type == R_MICROMIPS_PC16_S1
12720 && IS_BITSIZE (pcrval - 2, 8)
12721 && (((fndopc = find_match (opcode, bz_rs_insns_32)) >= 0
12722 && OP16_VALID_REG (OP32_SREG (opcode)))
12723 || ((fndopc = find_match (opcode, bz_rt_insns_32)) >= 0
12724 && OP16_VALID_REG (OP32_TREG (opcode)))))
12728 reg = OP32_SREG (opcode) ? OP32_SREG (opcode) : OP32_TREG (opcode);
12730 /* Fix the relocation's type. */
12731 irel->r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC7_S1);
12733 /* Replace the 32-bit opcode with a 16-bit opcode. */
12735 (bz_insns_16[fndopc].match
12736 | BZ16_REG_FIELD (reg)
12737 | (opcode & 0x7f)), /* Addend value. */
12740 /* Delete 2 bytes from irel->r_offset + 2. */
12745 /* R_MICROMIPS_26_S1 -- JAL to JALS relaxation for microMIPS targets. */
12746 else if (r_type == R_MICROMIPS_26_S1
12747 && target_is_micromips_code_p
12748 && irel->r_offset + 7 < sec->size
12749 && MATCH (opcode, jal_insn_32_bd32))
12751 unsigned long n32opc;
12752 bfd_boolean relaxed = FALSE;
12754 n32opc = bfd_get_micromips_32 (abfd, ptr + 4);
12756 if (MATCH (n32opc, nop_insn_32))
12758 /* Replace delay slot 32-bit NOP with a 16-bit NOP. */
12759 bfd_put_16 (abfd, nop_insn_16.match, ptr + 4);
12763 else if (find_match (n32opc, move_insns_32) >= 0)
12765 /* Replace delay slot 32-bit MOVE with 16-bit MOVE. */
12767 (move_insn_16.match
12768 | MOVE16_RD_FIELD (MOVE32_RD (n32opc))
12769 | MOVE16_RS_FIELD (MOVE32_RS (n32opc))),
12774 /* Other 32-bit instructions relaxable to 16-bit
12775 instructions will be handled here later. */
12779 /* JAL with 32-bit delay slot that is changed to a JALS
12780 with 16-bit delay slot. */
12781 bfd_put_micromips_32 (abfd, jal_insn_32_bd16.match, ptr);
12783 /* Delete 2 bytes from irel->r_offset + 6. */
12791 /* Note that we've changed the relocs, section contents, etc. */
12792 elf_section_data (sec)->relocs = internal_relocs;
12793 elf_section_data (sec)->this_hdr.contents = contents;
12794 symtab_hdr->contents = (unsigned char *) isymbuf;
12796 /* Delete bytes depending on the delcnt and deloff. */
12797 if (!mips_elf_relax_delete_bytes (abfd, sec,
12798 irel->r_offset + deloff, delcnt))
12801 /* That will change things, so we should relax again.
12802 Note that this is not required, and it may be slow. */
12807 if (isymbuf != NULL
12808 && symtab_hdr->contents != (unsigned char *) isymbuf)
12810 if (! link_info->keep_memory)
12814 /* Cache the symbols for elf_link_input_bfd. */
12815 symtab_hdr->contents = (unsigned char *) isymbuf;
12819 if (contents != NULL
12820 && elf_section_data (sec)->this_hdr.contents != contents)
12822 if (! link_info->keep_memory)
12826 /* Cache the section contents for elf_link_input_bfd. */
12827 elf_section_data (sec)->this_hdr.contents = contents;
12831 if (internal_relocs != NULL
12832 && elf_section_data (sec)->relocs != internal_relocs)
12833 free (internal_relocs);
12838 if (isymbuf != NULL
12839 && symtab_hdr->contents != (unsigned char *) isymbuf)
12841 if (contents != NULL
12842 && elf_section_data (sec)->this_hdr.contents != contents)
12844 if (internal_relocs != NULL
12845 && elf_section_data (sec)->relocs != internal_relocs)
12846 free (internal_relocs);
12851 /* Create a MIPS ELF linker hash table. */
12853 struct bfd_link_hash_table *
12854 _bfd_mips_elf_link_hash_table_create (bfd *abfd)
12856 struct mips_elf_link_hash_table *ret;
12857 bfd_size_type amt = sizeof (struct mips_elf_link_hash_table);
12859 ret = bfd_zmalloc (amt);
12863 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
12864 mips_elf_link_hash_newfunc,
12865 sizeof (struct mips_elf_link_hash_entry),
12872 return &ret->root.root;
12875 /* Likewise, but indicate that the target is VxWorks. */
12877 struct bfd_link_hash_table *
12878 _bfd_mips_vxworks_link_hash_table_create (bfd *abfd)
12880 struct bfd_link_hash_table *ret;
12882 ret = _bfd_mips_elf_link_hash_table_create (abfd);
12885 struct mips_elf_link_hash_table *htab;
12887 htab = (struct mips_elf_link_hash_table *) ret;
12888 htab->use_plts_and_copy_relocs = TRUE;
12889 htab->is_vxworks = TRUE;
12894 /* A function that the linker calls if we are allowed to use PLTs
12895 and copy relocs. */
12898 _bfd_mips_elf_use_plts_and_copy_relocs (struct bfd_link_info *info)
12900 mips_elf_hash_table (info)->use_plts_and_copy_relocs = TRUE;
12903 /* We need to use a special link routine to handle the .reginfo and
12904 the .mdebug sections. We need to merge all instances of these
12905 sections together, not write them all out sequentially. */
12908 _bfd_mips_elf_final_link (bfd *abfd, struct bfd_link_info *info)
12911 struct bfd_link_order *p;
12912 asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
12913 asection *rtproc_sec;
12914 Elf32_RegInfo reginfo;
12915 struct ecoff_debug_info debug;
12916 struct mips_htab_traverse_info hti;
12917 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12918 const struct ecoff_debug_swap *swap = bed->elf_backend_ecoff_debug_swap;
12919 HDRR *symhdr = &debug.symbolic_header;
12920 void *mdebug_handle = NULL;
12925 struct mips_elf_link_hash_table *htab;
12927 static const char * const secname[] =
12929 ".text", ".init", ".fini", ".data",
12930 ".rodata", ".sdata", ".sbss", ".bss"
12932 static const int sc[] =
12934 scText, scInit, scFini, scData,
12935 scRData, scSData, scSBss, scBss
12938 /* Sort the dynamic symbols so that those with GOT entries come after
12940 htab = mips_elf_hash_table (info);
12941 BFD_ASSERT (htab != NULL);
12943 if (!mips_elf_sort_hash_table (abfd, info))
12946 /* Create any scheduled LA25 stubs. */
12948 hti.output_bfd = abfd;
12950 htab_traverse (htab->la25_stubs, mips_elf_create_la25_stub, &hti);
12954 /* Get a value for the GP register. */
12955 if (elf_gp (abfd) == 0)
12957 struct bfd_link_hash_entry *h;
12959 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
12960 if (h != NULL && h->type == bfd_link_hash_defined)
12961 elf_gp (abfd) = (h->u.def.value
12962 + h->u.def.section->output_section->vma
12963 + h->u.def.section->output_offset);
12964 else if (htab->is_vxworks
12965 && (h = bfd_link_hash_lookup (info->hash,
12966 "_GLOBAL_OFFSET_TABLE_",
12967 FALSE, FALSE, TRUE))
12968 && h->type == bfd_link_hash_defined)
12969 elf_gp (abfd) = (h->u.def.section->output_section->vma
12970 + h->u.def.section->output_offset
12972 else if (info->relocatable)
12974 bfd_vma lo = MINUS_ONE;
12976 /* Find the GP-relative section with the lowest offset. */
12977 for (o = abfd->sections; o != NULL; o = o->next)
12979 && (elf_section_data (o)->this_hdr.sh_flags & SHF_MIPS_GPREL))
12982 /* And calculate GP relative to that. */
12983 elf_gp (abfd) = lo + ELF_MIPS_GP_OFFSET (info);
12987 /* If the relocate_section function needs to do a reloc
12988 involving the GP value, it should make a reloc_dangerous
12989 callback to warn that GP is not defined. */
12993 /* Go through the sections and collect the .reginfo and .mdebug
12995 reginfo_sec = NULL;
12997 gptab_data_sec = NULL;
12998 gptab_bss_sec = NULL;
12999 for (o = abfd->sections; o != NULL; o = o->next)
13001 if (strcmp (o->name, ".reginfo") == 0)
13003 memset (®info, 0, sizeof reginfo);
13005 /* We have found the .reginfo section in the output file.
13006 Look through all the link_orders comprising it and merge
13007 the information together. */
13008 for (p = o->map_head.link_order; p != NULL; p = p->next)
13010 asection *input_section;
13012 Elf32_External_RegInfo ext;
13015 if (p->type != bfd_indirect_link_order)
13017 if (p->type == bfd_data_link_order)
13022 input_section = p->u.indirect.section;
13023 input_bfd = input_section->owner;
13025 if (! bfd_get_section_contents (input_bfd, input_section,
13026 &ext, 0, sizeof ext))
13029 bfd_mips_elf32_swap_reginfo_in (input_bfd, &ext, &sub);
13031 reginfo.ri_gprmask |= sub.ri_gprmask;
13032 reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
13033 reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
13034 reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
13035 reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
13037 /* ri_gp_value is set by the function
13038 mips_elf32_section_processing when the section is
13039 finally written out. */
13041 /* Hack: reset the SEC_HAS_CONTENTS flag so that
13042 elf_link_input_bfd ignores this section. */
13043 input_section->flags &= ~SEC_HAS_CONTENTS;
13046 /* Size has been set in _bfd_mips_elf_always_size_sections. */
13047 BFD_ASSERT(o->size == sizeof (Elf32_External_RegInfo));
13049 /* Skip this section later on (I don't think this currently
13050 matters, but someday it might). */
13051 o->map_head.link_order = NULL;
13056 if (strcmp (o->name, ".mdebug") == 0)
13058 struct extsym_info einfo;
13061 /* We have found the .mdebug section in the output file.
13062 Look through all the link_orders comprising it and merge
13063 the information together. */
13064 symhdr->magic = swap->sym_magic;
13065 /* FIXME: What should the version stamp be? */
13066 symhdr->vstamp = 0;
13067 symhdr->ilineMax = 0;
13068 symhdr->cbLine = 0;
13069 symhdr->idnMax = 0;
13070 symhdr->ipdMax = 0;
13071 symhdr->isymMax = 0;
13072 symhdr->ioptMax = 0;
13073 symhdr->iauxMax = 0;
13074 symhdr->issMax = 0;
13075 symhdr->issExtMax = 0;
13076 symhdr->ifdMax = 0;
13078 symhdr->iextMax = 0;
13080 /* We accumulate the debugging information itself in the
13081 debug_info structure. */
13083 debug.external_dnr = NULL;
13084 debug.external_pdr = NULL;
13085 debug.external_sym = NULL;
13086 debug.external_opt = NULL;
13087 debug.external_aux = NULL;
13089 debug.ssext = debug.ssext_end = NULL;
13090 debug.external_fdr = NULL;
13091 debug.external_rfd = NULL;
13092 debug.external_ext = debug.external_ext_end = NULL;
13094 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
13095 if (mdebug_handle == NULL)
13099 esym.cobol_main = 0;
13103 esym.asym.iss = issNil;
13104 esym.asym.st = stLocal;
13105 esym.asym.reserved = 0;
13106 esym.asym.index = indexNil;
13108 for (i = 0; i < sizeof (secname) / sizeof (secname[0]); i++)
13110 esym.asym.sc = sc[i];
13111 s = bfd_get_section_by_name (abfd, secname[i]);
13114 esym.asym.value = s->vma;
13115 last = s->vma + s->size;
13118 esym.asym.value = last;
13119 if (!bfd_ecoff_debug_one_external (abfd, &debug, swap,
13120 secname[i], &esym))
13124 for (p = o->map_head.link_order; p != NULL; p = p->next)
13126 asection *input_section;
13128 const struct ecoff_debug_swap *input_swap;
13129 struct ecoff_debug_info input_debug;
13133 if (p->type != bfd_indirect_link_order)
13135 if (p->type == bfd_data_link_order)
13140 input_section = p->u.indirect.section;
13141 input_bfd = input_section->owner;
13143 if (!is_mips_elf (input_bfd))
13145 /* I don't know what a non MIPS ELF bfd would be
13146 doing with a .mdebug section, but I don't really
13147 want to deal with it. */
13151 input_swap = (get_elf_backend_data (input_bfd)
13152 ->elf_backend_ecoff_debug_swap);
13154 BFD_ASSERT (p->size == input_section->size);
13156 /* The ECOFF linking code expects that we have already
13157 read in the debugging information and set up an
13158 ecoff_debug_info structure, so we do that now. */
13159 if (! _bfd_mips_elf_read_ecoff_info (input_bfd, input_section,
13163 if (! (bfd_ecoff_debug_accumulate
13164 (mdebug_handle, abfd, &debug, swap, input_bfd,
13165 &input_debug, input_swap, info)))
13168 /* Loop through the external symbols. For each one with
13169 interesting information, try to find the symbol in
13170 the linker global hash table and save the information
13171 for the output external symbols. */
13172 eraw_src = input_debug.external_ext;
13173 eraw_end = (eraw_src
13174 + (input_debug.symbolic_header.iextMax
13175 * input_swap->external_ext_size));
13177 eraw_src < eraw_end;
13178 eraw_src += input_swap->external_ext_size)
13182 struct mips_elf_link_hash_entry *h;
13184 (*input_swap->swap_ext_in) (input_bfd, eraw_src, &ext);
13185 if (ext.asym.sc == scNil
13186 || ext.asym.sc == scUndefined
13187 || ext.asym.sc == scSUndefined)
13190 name = input_debug.ssext + ext.asym.iss;
13191 h = mips_elf_link_hash_lookup (mips_elf_hash_table (info),
13192 name, FALSE, FALSE, TRUE);
13193 if (h == NULL || h->esym.ifd != -2)
13198 BFD_ASSERT (ext.ifd
13199 < input_debug.symbolic_header.ifdMax);
13200 ext.ifd = input_debug.ifdmap[ext.ifd];
13206 /* Free up the information we just read. */
13207 free (input_debug.line);
13208 free (input_debug.external_dnr);
13209 free (input_debug.external_pdr);
13210 free (input_debug.external_sym);
13211 free (input_debug.external_opt);
13212 free (input_debug.external_aux);
13213 free (input_debug.ss);
13214 free (input_debug.ssext);
13215 free (input_debug.external_fdr);
13216 free (input_debug.external_rfd);
13217 free (input_debug.external_ext);
13219 /* Hack: reset the SEC_HAS_CONTENTS flag so that
13220 elf_link_input_bfd ignores this section. */
13221 input_section->flags &= ~SEC_HAS_CONTENTS;
13224 if (SGI_COMPAT (abfd) && info->shared)
13226 /* Create .rtproc section. */
13227 rtproc_sec = bfd_get_linker_section (abfd, ".rtproc");
13228 if (rtproc_sec == NULL)
13230 flagword flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
13231 | SEC_LINKER_CREATED | SEC_READONLY);
13233 rtproc_sec = bfd_make_section_anyway_with_flags (abfd,
13236 if (rtproc_sec == NULL
13237 || ! bfd_set_section_alignment (abfd, rtproc_sec, 4))
13241 if (! mips_elf_create_procedure_table (mdebug_handle, abfd,
13247 /* Build the external symbol information. */
13250 einfo.debug = &debug;
13252 einfo.failed = FALSE;
13253 mips_elf_link_hash_traverse (mips_elf_hash_table (info),
13254 mips_elf_output_extsym, &einfo);
13258 /* Set the size of the .mdebug section. */
13259 o->size = bfd_ecoff_debug_size (abfd, &debug, swap);
13261 /* Skip this section later on (I don't think this currently
13262 matters, but someday it might). */
13263 o->map_head.link_order = NULL;
13268 if (CONST_STRNEQ (o->name, ".gptab."))
13270 const char *subname;
13273 Elf32_External_gptab *ext_tab;
13276 /* The .gptab.sdata and .gptab.sbss sections hold
13277 information describing how the small data area would
13278 change depending upon the -G switch. These sections
13279 not used in executables files. */
13280 if (! info->relocatable)
13282 for (p = o->map_head.link_order; p != NULL; p = p->next)
13284 asection *input_section;
13286 if (p->type != bfd_indirect_link_order)
13288 if (p->type == bfd_data_link_order)
13293 input_section = p->u.indirect.section;
13295 /* Hack: reset the SEC_HAS_CONTENTS flag so that
13296 elf_link_input_bfd ignores this section. */
13297 input_section->flags &= ~SEC_HAS_CONTENTS;
13300 /* Skip this section later on (I don't think this
13301 currently matters, but someday it might). */
13302 o->map_head.link_order = NULL;
13304 /* Really remove the section. */
13305 bfd_section_list_remove (abfd, o);
13306 --abfd->section_count;
13311 /* There is one gptab for initialized data, and one for
13312 uninitialized data. */
13313 if (strcmp (o->name, ".gptab.sdata") == 0)
13314 gptab_data_sec = o;
13315 else if (strcmp (o->name, ".gptab.sbss") == 0)
13319 (*_bfd_error_handler)
13320 (_("%s: illegal section name `%s'"),
13321 bfd_get_filename (abfd), o->name);
13322 bfd_set_error (bfd_error_nonrepresentable_section);
13326 /* The linker script always combines .gptab.data and
13327 .gptab.sdata into .gptab.sdata, and likewise for
13328 .gptab.bss and .gptab.sbss. It is possible that there is
13329 no .sdata or .sbss section in the output file, in which
13330 case we must change the name of the output section. */
13331 subname = o->name + sizeof ".gptab" - 1;
13332 if (bfd_get_section_by_name (abfd, subname) == NULL)
13334 if (o == gptab_data_sec)
13335 o->name = ".gptab.data";
13337 o->name = ".gptab.bss";
13338 subname = o->name + sizeof ".gptab" - 1;
13339 BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
13342 /* Set up the first entry. */
13344 amt = c * sizeof (Elf32_gptab);
13345 tab = bfd_malloc (amt);
13348 tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
13349 tab[0].gt_header.gt_unused = 0;
13351 /* Combine the input sections. */
13352 for (p = o->map_head.link_order; p != NULL; p = p->next)
13354 asection *input_section;
13356 bfd_size_type size;
13357 unsigned long last;
13358 bfd_size_type gpentry;
13360 if (p->type != bfd_indirect_link_order)
13362 if (p->type == bfd_data_link_order)
13367 input_section = p->u.indirect.section;
13368 input_bfd = input_section->owner;
13370 /* Combine the gptab entries for this input section one
13371 by one. We know that the input gptab entries are
13372 sorted by ascending -G value. */
13373 size = input_section->size;
13375 for (gpentry = sizeof (Elf32_External_gptab);
13377 gpentry += sizeof (Elf32_External_gptab))
13379 Elf32_External_gptab ext_gptab;
13380 Elf32_gptab int_gptab;
13386 if (! (bfd_get_section_contents
13387 (input_bfd, input_section, &ext_gptab, gpentry,
13388 sizeof (Elf32_External_gptab))))
13394 bfd_mips_elf32_swap_gptab_in (input_bfd, &ext_gptab,
13396 val = int_gptab.gt_entry.gt_g_value;
13397 add = int_gptab.gt_entry.gt_bytes - last;
13400 for (look = 1; look < c; look++)
13402 if (tab[look].gt_entry.gt_g_value >= val)
13403 tab[look].gt_entry.gt_bytes += add;
13405 if (tab[look].gt_entry.gt_g_value == val)
13411 Elf32_gptab *new_tab;
13414 /* We need a new table entry. */
13415 amt = (bfd_size_type) (c + 1) * sizeof (Elf32_gptab);
13416 new_tab = bfd_realloc (tab, amt);
13417 if (new_tab == NULL)
13423 tab[c].gt_entry.gt_g_value = val;
13424 tab[c].gt_entry.gt_bytes = add;
13426 /* Merge in the size for the next smallest -G
13427 value, since that will be implied by this new
13430 for (look = 1; look < c; look++)
13432 if (tab[look].gt_entry.gt_g_value < val
13434 || (tab[look].gt_entry.gt_g_value
13435 > tab[max].gt_entry.gt_g_value)))
13439 tab[c].gt_entry.gt_bytes +=
13440 tab[max].gt_entry.gt_bytes;
13445 last = int_gptab.gt_entry.gt_bytes;
13448 /* Hack: reset the SEC_HAS_CONTENTS flag so that
13449 elf_link_input_bfd ignores this section. */
13450 input_section->flags &= ~SEC_HAS_CONTENTS;
13453 /* The table must be sorted by -G value. */
13455 qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
13457 /* Swap out the table. */
13458 amt = (bfd_size_type) c * sizeof (Elf32_External_gptab);
13459 ext_tab = bfd_alloc (abfd, amt);
13460 if (ext_tab == NULL)
13466 for (j = 0; j < c; j++)
13467 bfd_mips_elf32_swap_gptab_out (abfd, tab + j, ext_tab + j);
13470 o->size = c * sizeof (Elf32_External_gptab);
13471 o->contents = (bfd_byte *) ext_tab;
13473 /* Skip this section later on (I don't think this currently
13474 matters, but someday it might). */
13475 o->map_head.link_order = NULL;
13479 /* Invoke the regular ELF backend linker to do all the work. */
13480 if (!bfd_elf_final_link (abfd, info))
13483 /* Now write out the computed sections. */
13485 if (reginfo_sec != NULL)
13487 Elf32_External_RegInfo ext;
13489 bfd_mips_elf32_swap_reginfo_out (abfd, ®info, &ext);
13490 if (! bfd_set_section_contents (abfd, reginfo_sec, &ext, 0, sizeof ext))
13494 if (mdebug_sec != NULL)
13496 BFD_ASSERT (abfd->output_has_begun);
13497 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
13499 mdebug_sec->filepos))
13502 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
13505 if (gptab_data_sec != NULL)
13507 if (! bfd_set_section_contents (abfd, gptab_data_sec,
13508 gptab_data_sec->contents,
13509 0, gptab_data_sec->size))
13513 if (gptab_bss_sec != NULL)
13515 if (! bfd_set_section_contents (abfd, gptab_bss_sec,
13516 gptab_bss_sec->contents,
13517 0, gptab_bss_sec->size))
13521 if (SGI_COMPAT (abfd))
13523 rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
13524 if (rtproc_sec != NULL)
13526 if (! bfd_set_section_contents (abfd, rtproc_sec,
13527 rtproc_sec->contents,
13528 0, rtproc_sec->size))
13536 /* Structure for saying that BFD machine EXTENSION extends BASE. */
13538 struct mips_mach_extension {
13539 unsigned long extension, base;
13543 /* An array describing how BFD machines relate to one another. The entries
13544 are ordered topologically with MIPS I extensions listed last. */
13546 static const struct mips_mach_extension mips_mach_extensions[] = {
13547 /* MIPS64r2 extensions. */
13548 { bfd_mach_mips_octeon2, bfd_mach_mips_octeonp },
13549 { bfd_mach_mips_octeonp, bfd_mach_mips_octeon },
13550 { bfd_mach_mips_octeon, bfd_mach_mipsisa64r2 },
13552 /* MIPS64 extensions. */
13553 { bfd_mach_mipsisa64r2, bfd_mach_mipsisa64 },
13554 { bfd_mach_mips_sb1, bfd_mach_mipsisa64 },
13555 { bfd_mach_mips_xlr, bfd_mach_mipsisa64 },
13556 { bfd_mach_mips_loongson_3a, bfd_mach_mipsisa64 },
13558 /* MIPS V extensions. */
13559 { bfd_mach_mipsisa64, bfd_mach_mips5 },
13561 /* R10000 extensions. */
13562 { bfd_mach_mips12000, bfd_mach_mips10000 },
13563 { bfd_mach_mips14000, bfd_mach_mips10000 },
13564 { bfd_mach_mips16000, bfd_mach_mips10000 },
13566 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
13567 vr5400 ISA, but doesn't include the multimedia stuff. It seems
13568 better to allow vr5400 and vr5500 code to be merged anyway, since
13569 many libraries will just use the core ISA. Perhaps we could add
13570 some sort of ASE flag if this ever proves a problem. */
13571 { bfd_mach_mips5500, bfd_mach_mips5400 },
13572 { bfd_mach_mips5400, bfd_mach_mips5000 },
13574 /* MIPS IV extensions. */
13575 { bfd_mach_mips5, bfd_mach_mips8000 },
13576 { bfd_mach_mips10000, bfd_mach_mips8000 },
13577 { bfd_mach_mips5000, bfd_mach_mips8000 },
13578 { bfd_mach_mips7000, bfd_mach_mips8000 },
13579 { bfd_mach_mips9000, bfd_mach_mips8000 },
13581 /* VR4100 extensions. */
13582 { bfd_mach_mips4120, bfd_mach_mips4100 },
13583 { bfd_mach_mips4111, bfd_mach_mips4100 },
13585 /* MIPS III extensions. */
13586 { bfd_mach_mips_loongson_2e, bfd_mach_mips4000 },
13587 { bfd_mach_mips_loongson_2f, bfd_mach_mips4000 },
13588 { bfd_mach_mips8000, bfd_mach_mips4000 },
13589 { bfd_mach_mips4650, bfd_mach_mips4000 },
13590 { bfd_mach_mips4600, bfd_mach_mips4000 },
13591 { bfd_mach_mips4400, bfd_mach_mips4000 },
13592 { bfd_mach_mips4300, bfd_mach_mips4000 },
13593 { bfd_mach_mips4100, bfd_mach_mips4000 },
13594 { bfd_mach_mips4010, bfd_mach_mips4000 },
13595 { bfd_mach_mips5900, bfd_mach_mips4000 },
13597 /* MIPS32 extensions. */
13598 { bfd_mach_mipsisa32r2, bfd_mach_mipsisa32 },
13600 /* MIPS II extensions. */
13601 { bfd_mach_mips4000, bfd_mach_mips6000 },
13602 { bfd_mach_mipsisa32, bfd_mach_mips6000 },
13604 /* MIPS I extensions. */
13605 { bfd_mach_mips6000, bfd_mach_mips3000 },
13606 { bfd_mach_mips3900, bfd_mach_mips3000 }
13610 /* Return true if bfd machine EXTENSION is an extension of machine BASE. */
13613 mips_mach_extends_p (unsigned long base, unsigned long extension)
13617 if (extension == base)
13620 if (base == bfd_mach_mipsisa32
13621 && mips_mach_extends_p (bfd_mach_mipsisa64, extension))
13624 if (base == bfd_mach_mipsisa32r2
13625 && mips_mach_extends_p (bfd_mach_mipsisa64r2, extension))
13628 for (i = 0; i < ARRAY_SIZE (mips_mach_extensions); i++)
13629 if (extension == mips_mach_extensions[i].extension)
13631 extension = mips_mach_extensions[i].base;
13632 if (extension == base)
13640 /* Return true if the given ELF header flags describe a 32-bit binary. */
13643 mips_32bit_flags_p (flagword flags)
13645 return ((flags & EF_MIPS_32BITMODE) != 0
13646 || (flags & EF_MIPS_ABI) == E_MIPS_ABI_O32
13647 || (flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32
13648 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1
13649 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2
13650 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32
13651 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2);
13655 /* Merge object attributes from IBFD into OBFD. Raise an error if
13656 there are conflicting attributes. */
13658 mips_elf_merge_obj_attributes (bfd *ibfd, bfd *obfd)
13660 obj_attribute *in_attr;
13661 obj_attribute *out_attr;
13664 abi_fp_bfd = mips_elf_tdata (obfd)->abi_fp_bfd;
13665 in_attr = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
13666 if (!abi_fp_bfd && in_attr[Tag_GNU_MIPS_ABI_FP].i != 0)
13667 mips_elf_tdata (obfd)->abi_fp_bfd = ibfd;
13669 if (!elf_known_obj_attributes_proc (obfd)[0].i)
13671 /* This is the first object. Copy the attributes. */
13672 _bfd_elf_copy_obj_attributes (ibfd, obfd);
13674 /* Use the Tag_null value to indicate the attributes have been
13676 elf_known_obj_attributes_proc (obfd)[0].i = 1;
13681 /* Check for conflicting Tag_GNU_MIPS_ABI_FP attributes and merge
13682 non-conflicting ones. */
13683 out_attr = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
13684 if (in_attr[Tag_GNU_MIPS_ABI_FP].i != out_attr[Tag_GNU_MIPS_ABI_FP].i)
13686 out_attr[Tag_GNU_MIPS_ABI_FP].type = 1;
13687 if (out_attr[Tag_GNU_MIPS_ABI_FP].i == 0)
13688 out_attr[Tag_GNU_MIPS_ABI_FP].i = in_attr[Tag_GNU_MIPS_ABI_FP].i;
13689 else if (in_attr[Tag_GNU_MIPS_ABI_FP].i != 0)
13690 switch (out_attr[Tag_GNU_MIPS_ABI_FP].i)
13693 switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
13697 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13698 obfd, abi_fp_bfd, ibfd, "-mdouble-float", "-msingle-float");
13703 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13704 obfd, abi_fp_bfd, ibfd, "-mhard-float", "-msoft-float");
13709 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13710 obfd, abi_fp_bfd, ibfd,
13711 "-mdouble-float", "-mips32r2 -mfp64");
13716 (_("Warning: %B uses %s (set by %B), "
13717 "%B uses unknown floating point ABI %d"),
13718 obfd, abi_fp_bfd, ibfd,
13719 "-mdouble-float", in_attr[Tag_GNU_MIPS_ABI_FP].i);
13725 switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
13729 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13730 obfd, abi_fp_bfd, ibfd, "-msingle-float", "-mdouble-float");
13735 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13736 obfd, abi_fp_bfd, ibfd, "-mhard-float", "-msoft-float");
13741 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13742 obfd, abi_fp_bfd, ibfd,
13743 "-msingle-float", "-mips32r2 -mfp64");
13748 (_("Warning: %B uses %s (set by %B), "
13749 "%B uses unknown floating point ABI %d"),
13750 obfd, abi_fp_bfd, ibfd,
13751 "-msingle-float", in_attr[Tag_GNU_MIPS_ABI_FP].i);
13757 switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
13763 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13764 obfd, abi_fp_bfd, ibfd, "-msoft-float", "-mhard-float");
13769 (_("Warning: %B uses %s (set by %B), "
13770 "%B uses unknown floating point ABI %d"),
13771 obfd, abi_fp_bfd, ibfd,
13772 "-msoft-float", in_attr[Tag_GNU_MIPS_ABI_FP].i);
13778 switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
13782 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13783 obfd, abi_fp_bfd, ibfd,
13784 "-mips32r2 -mfp64", "-mdouble-float");
13789 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13790 obfd, abi_fp_bfd, ibfd,
13791 "-mips32r2 -mfp64", "-msingle-float");
13796 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13797 obfd, abi_fp_bfd, ibfd, "-mhard-float", "-msoft-float");
13802 (_("Warning: %B uses %s (set by %B), "
13803 "%B uses unknown floating point ABI %d"),
13804 obfd, abi_fp_bfd, ibfd,
13805 "-mips32r2 -mfp64", in_attr[Tag_GNU_MIPS_ABI_FP].i);
13811 switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
13815 (_("Warning: %B uses unknown floating point ABI %d "
13816 "(set by %B), %B uses %s"),
13817 obfd, abi_fp_bfd, ibfd,
13818 out_attr[Tag_GNU_MIPS_ABI_FP].i, "-mdouble-float");
13823 (_("Warning: %B uses unknown floating point ABI %d "
13824 "(set by %B), %B uses %s"),
13825 obfd, abi_fp_bfd, ibfd,
13826 out_attr[Tag_GNU_MIPS_ABI_FP].i, "-msingle-float");
13831 (_("Warning: %B uses unknown floating point ABI %d "
13832 "(set by %B), %B uses %s"),
13833 obfd, abi_fp_bfd, ibfd,
13834 out_attr[Tag_GNU_MIPS_ABI_FP].i, "-msoft-float");
13839 (_("Warning: %B uses unknown floating point ABI %d "
13840 "(set by %B), %B uses %s"),
13841 obfd, abi_fp_bfd, ibfd,
13842 out_attr[Tag_GNU_MIPS_ABI_FP].i, "-mips32r2 -mfp64");
13847 (_("Warning: %B uses unknown floating point ABI %d "
13848 "(set by %B), %B uses unknown floating point ABI %d"),
13849 obfd, abi_fp_bfd, ibfd,
13850 out_attr[Tag_GNU_MIPS_ABI_FP].i,
13851 in_attr[Tag_GNU_MIPS_ABI_FP].i);
13858 /* Merge Tag_compatibility attributes and any common GNU ones. */
13859 _bfd_elf_merge_object_attributes (ibfd, obfd);
13864 /* Merge backend specific data from an object file to the output
13865 object file when linking. */
13868 _bfd_mips_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
13870 flagword old_flags;
13871 flagword new_flags;
13873 bfd_boolean null_input_bfd = TRUE;
13876 /* Check if we have the same endianness. */
13877 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
13879 (*_bfd_error_handler)
13880 (_("%B: endianness incompatible with that of the selected emulation"),
13885 if (!is_mips_elf (ibfd) || !is_mips_elf (obfd))
13888 if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
13890 (*_bfd_error_handler)
13891 (_("%B: ABI is incompatible with that of the selected emulation"),
13896 if (!mips_elf_merge_obj_attributes (ibfd, obfd))
13899 new_flags = elf_elfheader (ibfd)->e_flags;
13900 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_NOREORDER;
13901 old_flags = elf_elfheader (obfd)->e_flags;
13903 if (! elf_flags_init (obfd))
13905 elf_flags_init (obfd) = TRUE;
13906 elf_elfheader (obfd)->e_flags = new_flags;
13907 elf_elfheader (obfd)->e_ident[EI_CLASS]
13908 = elf_elfheader (ibfd)->e_ident[EI_CLASS];
13910 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
13911 && (bfd_get_arch_info (obfd)->the_default
13912 || mips_mach_extends_p (bfd_get_mach (obfd),
13913 bfd_get_mach (ibfd))))
13915 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
13916 bfd_get_mach (ibfd)))
13923 /* Check flag compatibility. */
13925 new_flags &= ~EF_MIPS_NOREORDER;
13926 old_flags &= ~EF_MIPS_NOREORDER;
13928 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
13929 doesn't seem to matter. */
13930 new_flags &= ~EF_MIPS_XGOT;
13931 old_flags &= ~EF_MIPS_XGOT;
13933 /* MIPSpro generates ucode info in n64 objects. Again, we should
13934 just be able to ignore this. */
13935 new_flags &= ~EF_MIPS_UCODE;
13936 old_flags &= ~EF_MIPS_UCODE;
13938 /* DSOs should only be linked with CPIC code. */
13939 if ((ibfd->flags & DYNAMIC) != 0)
13940 new_flags |= EF_MIPS_PIC | EF_MIPS_CPIC;
13942 if (new_flags == old_flags)
13945 /* Check to see if the input BFD actually contains any sections.
13946 If not, its flags may not have been initialised either, but it cannot
13947 actually cause any incompatibility. */
13948 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
13950 /* Ignore synthetic sections and empty .text, .data and .bss sections
13951 which are automatically generated by gas. Also ignore fake
13952 (s)common sections, since merely defining a common symbol does
13953 not affect compatibility. */
13954 if ((sec->flags & SEC_IS_COMMON) == 0
13955 && strcmp (sec->name, ".reginfo")
13956 && strcmp (sec->name, ".mdebug")
13958 || (strcmp (sec->name, ".text")
13959 && strcmp (sec->name, ".data")
13960 && strcmp (sec->name, ".bss"))))
13962 null_input_bfd = FALSE;
13966 if (null_input_bfd)
13971 if (((new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0)
13972 != ((old_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0))
13974 (*_bfd_error_handler)
13975 (_("%B: warning: linking abicalls files with non-abicalls files"),
13980 if (new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC))
13981 elf_elfheader (obfd)->e_flags |= EF_MIPS_CPIC;
13982 if (! (new_flags & EF_MIPS_PIC))
13983 elf_elfheader (obfd)->e_flags &= ~EF_MIPS_PIC;
13985 new_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
13986 old_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
13988 /* Compare the ISAs. */
13989 if (mips_32bit_flags_p (old_flags) != mips_32bit_flags_p (new_flags))
13991 (*_bfd_error_handler)
13992 (_("%B: linking 32-bit code with 64-bit code"),
13996 else if (!mips_mach_extends_p (bfd_get_mach (ibfd), bfd_get_mach (obfd)))
13998 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
13999 if (mips_mach_extends_p (bfd_get_mach (obfd), bfd_get_mach (ibfd)))
14001 /* Copy the architecture info from IBFD to OBFD. Also copy
14002 the 32-bit flag (if set) so that we continue to recognise
14003 OBFD as a 32-bit binary. */
14004 bfd_set_arch_info (obfd, bfd_get_arch_info (ibfd));
14005 elf_elfheader (obfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
14006 elf_elfheader (obfd)->e_flags
14007 |= new_flags & (EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
14009 /* Copy across the ABI flags if OBFD doesn't use them
14010 and if that was what caused us to treat IBFD as 32-bit. */
14011 if ((old_flags & EF_MIPS_ABI) == 0
14012 && mips_32bit_flags_p (new_flags)
14013 && !mips_32bit_flags_p (new_flags & ~EF_MIPS_ABI))
14014 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ABI;
14018 /* The ISAs aren't compatible. */
14019 (*_bfd_error_handler)
14020 (_("%B: linking %s module with previous %s modules"),
14022 bfd_printable_name (ibfd),
14023 bfd_printable_name (obfd));
14028 new_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
14029 old_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
14031 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
14032 does set EI_CLASS differently from any 32-bit ABI. */
14033 if ((new_flags & EF_MIPS_ABI) != (old_flags & EF_MIPS_ABI)
14034 || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
14035 != elf_elfheader (obfd)->e_ident[EI_CLASS]))
14037 /* Only error if both are set (to different values). */
14038 if (((new_flags & EF_MIPS_ABI) && (old_flags & EF_MIPS_ABI))
14039 || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
14040 != elf_elfheader (obfd)->e_ident[EI_CLASS]))
14042 (*_bfd_error_handler)
14043 (_("%B: ABI mismatch: linking %s module with previous %s modules"),
14045 elf_mips_abi_name (ibfd),
14046 elf_mips_abi_name (obfd));
14049 new_flags &= ~EF_MIPS_ABI;
14050 old_flags &= ~EF_MIPS_ABI;
14053 /* Compare ASEs. Forbid linking MIPS16 and microMIPS ASE modules together
14054 and allow arbitrary mixing of the remaining ASEs (retain the union). */
14055 if ((new_flags & EF_MIPS_ARCH_ASE) != (old_flags & EF_MIPS_ARCH_ASE))
14057 int old_micro = old_flags & EF_MIPS_ARCH_ASE_MICROMIPS;
14058 int new_micro = new_flags & EF_MIPS_ARCH_ASE_MICROMIPS;
14059 int old_m16 = old_flags & EF_MIPS_ARCH_ASE_M16;
14060 int new_m16 = new_flags & EF_MIPS_ARCH_ASE_M16;
14061 int micro_mis = old_m16 && new_micro;
14062 int m16_mis = old_micro && new_m16;
14064 if (m16_mis || micro_mis)
14066 (*_bfd_error_handler)
14067 (_("%B: ASE mismatch: linking %s module with previous %s modules"),
14069 m16_mis ? "MIPS16" : "microMIPS",
14070 m16_mis ? "microMIPS" : "MIPS16");
14074 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ARCH_ASE;
14076 new_flags &= ~ EF_MIPS_ARCH_ASE;
14077 old_flags &= ~ EF_MIPS_ARCH_ASE;
14080 /* Warn about any other mismatches */
14081 if (new_flags != old_flags)
14083 (*_bfd_error_handler)
14084 (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
14085 ibfd, (unsigned long) new_flags,
14086 (unsigned long) old_flags);
14092 bfd_set_error (bfd_error_bad_value);
14099 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
14102 _bfd_mips_elf_set_private_flags (bfd *abfd, flagword flags)
14104 BFD_ASSERT (!elf_flags_init (abfd)
14105 || elf_elfheader (abfd)->e_flags == flags);
14107 elf_elfheader (abfd)->e_flags = flags;
14108 elf_flags_init (abfd) = TRUE;
14113 _bfd_mips_elf_get_target_dtag (bfd_vma dtag)
14117 default: return "";
14118 case DT_MIPS_RLD_VERSION:
14119 return "MIPS_RLD_VERSION";
14120 case DT_MIPS_TIME_STAMP:
14121 return "MIPS_TIME_STAMP";
14122 case DT_MIPS_ICHECKSUM:
14123 return "MIPS_ICHECKSUM";
14124 case DT_MIPS_IVERSION:
14125 return "MIPS_IVERSION";
14126 case DT_MIPS_FLAGS:
14127 return "MIPS_FLAGS";
14128 case DT_MIPS_BASE_ADDRESS:
14129 return "MIPS_BASE_ADDRESS";
14131 return "MIPS_MSYM";
14132 case DT_MIPS_CONFLICT:
14133 return "MIPS_CONFLICT";
14134 case DT_MIPS_LIBLIST:
14135 return "MIPS_LIBLIST";
14136 case DT_MIPS_LOCAL_GOTNO:
14137 return "MIPS_LOCAL_GOTNO";
14138 case DT_MIPS_CONFLICTNO:
14139 return "MIPS_CONFLICTNO";
14140 case DT_MIPS_LIBLISTNO:
14141 return "MIPS_LIBLISTNO";
14142 case DT_MIPS_SYMTABNO:
14143 return "MIPS_SYMTABNO";
14144 case DT_MIPS_UNREFEXTNO:
14145 return "MIPS_UNREFEXTNO";
14146 case DT_MIPS_GOTSYM:
14147 return "MIPS_GOTSYM";
14148 case DT_MIPS_HIPAGENO:
14149 return "MIPS_HIPAGENO";
14150 case DT_MIPS_RLD_MAP:
14151 return "MIPS_RLD_MAP";
14152 case DT_MIPS_DELTA_CLASS:
14153 return "MIPS_DELTA_CLASS";
14154 case DT_MIPS_DELTA_CLASS_NO:
14155 return "MIPS_DELTA_CLASS_NO";
14156 case DT_MIPS_DELTA_INSTANCE:
14157 return "MIPS_DELTA_INSTANCE";
14158 case DT_MIPS_DELTA_INSTANCE_NO:
14159 return "MIPS_DELTA_INSTANCE_NO";
14160 case DT_MIPS_DELTA_RELOC:
14161 return "MIPS_DELTA_RELOC";
14162 case DT_MIPS_DELTA_RELOC_NO:
14163 return "MIPS_DELTA_RELOC_NO";
14164 case DT_MIPS_DELTA_SYM:
14165 return "MIPS_DELTA_SYM";
14166 case DT_MIPS_DELTA_SYM_NO:
14167 return "MIPS_DELTA_SYM_NO";
14168 case DT_MIPS_DELTA_CLASSSYM:
14169 return "MIPS_DELTA_CLASSSYM";
14170 case DT_MIPS_DELTA_CLASSSYM_NO:
14171 return "MIPS_DELTA_CLASSSYM_NO";
14172 case DT_MIPS_CXX_FLAGS:
14173 return "MIPS_CXX_FLAGS";
14174 case DT_MIPS_PIXIE_INIT:
14175 return "MIPS_PIXIE_INIT";
14176 case DT_MIPS_SYMBOL_LIB:
14177 return "MIPS_SYMBOL_LIB";
14178 case DT_MIPS_LOCALPAGE_GOTIDX:
14179 return "MIPS_LOCALPAGE_GOTIDX";
14180 case DT_MIPS_LOCAL_GOTIDX:
14181 return "MIPS_LOCAL_GOTIDX";
14182 case DT_MIPS_HIDDEN_GOTIDX:
14183 return "MIPS_HIDDEN_GOTIDX";
14184 case DT_MIPS_PROTECTED_GOTIDX:
14185 return "MIPS_PROTECTED_GOT_IDX";
14186 case DT_MIPS_OPTIONS:
14187 return "MIPS_OPTIONS";
14188 case DT_MIPS_INTERFACE:
14189 return "MIPS_INTERFACE";
14190 case DT_MIPS_DYNSTR_ALIGN:
14191 return "DT_MIPS_DYNSTR_ALIGN";
14192 case DT_MIPS_INTERFACE_SIZE:
14193 return "DT_MIPS_INTERFACE_SIZE";
14194 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR:
14195 return "DT_MIPS_RLD_TEXT_RESOLVE_ADDR";
14196 case DT_MIPS_PERF_SUFFIX:
14197 return "DT_MIPS_PERF_SUFFIX";
14198 case DT_MIPS_COMPACT_SIZE:
14199 return "DT_MIPS_COMPACT_SIZE";
14200 case DT_MIPS_GP_VALUE:
14201 return "DT_MIPS_GP_VALUE";
14202 case DT_MIPS_AUX_DYNAMIC:
14203 return "DT_MIPS_AUX_DYNAMIC";
14204 case DT_MIPS_PLTGOT:
14205 return "DT_MIPS_PLTGOT";
14206 case DT_MIPS_RWPLT:
14207 return "DT_MIPS_RWPLT";
14212 _bfd_mips_elf_print_private_bfd_data (bfd *abfd, void *ptr)
14216 BFD_ASSERT (abfd != NULL && ptr != NULL);
14218 /* Print normal ELF private data. */
14219 _bfd_elf_print_private_bfd_data (abfd, ptr);
14221 /* xgettext:c-format */
14222 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
14224 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32)
14225 fprintf (file, _(" [abi=O32]"));
14226 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O64)
14227 fprintf (file, _(" [abi=O64]"));
14228 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32)
14229 fprintf (file, _(" [abi=EABI32]"));
14230 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
14231 fprintf (file, _(" [abi=EABI64]"));
14232 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI))
14233 fprintf (file, _(" [abi unknown]"));
14234 else if (ABI_N32_P (abfd))
14235 fprintf (file, _(" [abi=N32]"));
14236 else if (ABI_64_P (abfd))
14237 fprintf (file, _(" [abi=64]"));
14239 fprintf (file, _(" [no abi set]"));
14241 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
14242 fprintf (file, " [mips1]");
14243 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
14244 fprintf (file, " [mips2]");
14245 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
14246 fprintf (file, " [mips3]");
14247 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
14248 fprintf (file, " [mips4]");
14249 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5)
14250 fprintf (file, " [mips5]");
14251 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32)
14252 fprintf (file, " [mips32]");
14253 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64)
14254 fprintf (file, " [mips64]");
14255 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2)
14256 fprintf (file, " [mips32r2]");
14257 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R2)
14258 fprintf (file, " [mips64r2]");
14260 fprintf (file, _(" [unknown ISA]"));
14262 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MDMX)
14263 fprintf (file, " [mdmx]");
14265 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_M16)
14266 fprintf (file, " [mips16]");
14268 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
14269 fprintf (file, " [micromips]");
14271 if (elf_elfheader (abfd)->e_flags & EF_MIPS_32BITMODE)
14272 fprintf (file, " [32bitmode]");
14274 fprintf (file, _(" [not 32bitmode]"));
14276 if (elf_elfheader (abfd)->e_flags & EF_MIPS_NOREORDER)
14277 fprintf (file, " [noreorder]");
14279 if (elf_elfheader (abfd)->e_flags & EF_MIPS_PIC)
14280 fprintf (file, " [PIC]");
14282 if (elf_elfheader (abfd)->e_flags & EF_MIPS_CPIC)
14283 fprintf (file, " [CPIC]");
14285 if (elf_elfheader (abfd)->e_flags & EF_MIPS_XGOT)
14286 fprintf (file, " [XGOT]");
14288 if (elf_elfheader (abfd)->e_flags & EF_MIPS_UCODE)
14289 fprintf (file, " [UCODE]");
14291 fputc ('\n', file);
14296 const struct bfd_elf_special_section _bfd_mips_elf_special_sections[] =
14298 { STRING_COMMA_LEN (".lit4"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
14299 { STRING_COMMA_LEN (".lit8"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
14300 { STRING_COMMA_LEN (".mdebug"), 0, SHT_MIPS_DEBUG, 0 },
14301 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
14302 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
14303 { STRING_COMMA_LEN (".ucode"), 0, SHT_MIPS_UCODE, 0 },
14304 { NULL, 0, 0, 0, 0 }
14307 /* Merge non visibility st_other attributes. Ensure that the
14308 STO_OPTIONAL flag is copied into h->other, even if this is not a
14309 definiton of the symbol. */
14311 _bfd_mips_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
14312 const Elf_Internal_Sym *isym,
14313 bfd_boolean definition,
14314 bfd_boolean dynamic ATTRIBUTE_UNUSED)
14316 if ((isym->st_other & ~ELF_ST_VISIBILITY (-1)) != 0)
14318 unsigned char other;
14320 other = (definition ? isym->st_other : h->other);
14321 other &= ~ELF_ST_VISIBILITY (-1);
14322 h->other = other | ELF_ST_VISIBILITY (h->other);
14326 && ELF_MIPS_IS_OPTIONAL (isym->st_other))
14327 h->other |= STO_OPTIONAL;
14330 /* Decide whether an undefined symbol is special and can be ignored.
14331 This is the case for OPTIONAL symbols on IRIX. */
14333 _bfd_mips_elf_ignore_undef_symbol (struct elf_link_hash_entry *h)
14335 return ELF_MIPS_IS_OPTIONAL (h->other) ? TRUE : FALSE;
14339 _bfd_mips_elf_common_definition (Elf_Internal_Sym *sym)
14341 return (sym->st_shndx == SHN_COMMON
14342 || sym->st_shndx == SHN_MIPS_ACOMMON
14343 || sym->st_shndx == SHN_MIPS_SCOMMON);
14346 /* Return address for Ith PLT stub in section PLT, for relocation REL
14347 or (bfd_vma) -1 if it should not be included. */
14350 _bfd_mips_elf_plt_sym_val (bfd_vma i, const asection *plt,
14351 const arelent *rel ATTRIBUTE_UNUSED)
14354 + 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry)
14355 + i * 4 * ARRAY_SIZE (mips_exec_plt_entry));
14359 _bfd_mips_post_process_headers (bfd *abfd, struct bfd_link_info *link_info)
14361 struct mips_elf_link_hash_table *htab;
14362 Elf_Internal_Ehdr *i_ehdrp;
14364 i_ehdrp = elf_elfheader (abfd);
14367 htab = mips_elf_hash_table (link_info);
14368 BFD_ASSERT (htab != NULL);
14370 if (htab->use_plts_and_copy_relocs && !htab->is_vxworks)
14371 i_ehdrp->e_ident[EI_ABIVERSION] = 1;