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 types included in this GOT entry (specifically, GD and
105 IE). The GD and IE flags can be added as we encounter new
106 relocations. LDM can also be set; it will always be alone, not
107 combined with any GD or IE flags. An LDM GOT entry will be
108 a local symbol entry with r_symndx == 0. */
109 unsigned char tls_type;
111 /* The offset from the beginning of the .got section to the entry
112 corresponding to this symbol+addend. If it's a global symbol
113 whose offset is yet to be decided, it's going to be -1. */
117 /* This structure describes a range of addends: [MIN_ADDEND, MAX_ADDEND].
118 The structures form a non-overlapping list that is sorted by increasing
120 struct mips_got_page_range
122 struct mips_got_page_range *next;
123 bfd_signed_vma min_addend;
124 bfd_signed_vma max_addend;
127 /* This structure describes the range of addends that are applied to page
128 relocations against a given symbol. */
129 struct mips_got_page_entry
131 /* The input bfd in which the symbol is defined. */
133 /* The index of the symbol, as stored in the relocation r_info. */
135 /* The ranges for this page entry. */
136 struct mips_got_page_range *ranges;
137 /* The maximum number of page entries needed for RANGES. */
141 /* This structure is used to hold .got information when linking. */
145 /* The number of global .got entries. */
146 unsigned int global_gotno;
147 /* The number of global .got entries that are in the GGA_RELOC_ONLY area. */
148 unsigned int reloc_only_gotno;
149 /* The number of .got slots used for TLS. */
150 unsigned int tls_gotno;
151 /* The first unused TLS .got entry. Used only during
152 mips_elf_initialize_tls_index. */
153 unsigned int tls_assigned_gotno;
154 /* The number of local .got entries, eventually including page entries. */
155 unsigned int local_gotno;
156 /* The maximum number of page entries needed. */
157 unsigned int page_gotno;
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 /* Another structure used to pass arguments for got entries traversal. */
217 struct mips_elf_set_global_got_offset_arg
219 struct mips_got_info *g;
221 unsigned int needed_relocs;
222 struct bfd_link_info *info;
225 /* A structure used to count TLS relocations or GOT entries, for GOT
226 entry or ELF symbol table traversal. */
228 struct mips_elf_count_tls_arg
230 struct bfd_link_info *info;
234 struct _mips_elf_section_data
236 struct bfd_elf_section_data elf;
243 #define mips_elf_section_data(sec) \
244 ((struct _mips_elf_section_data *) elf_section_data (sec))
246 #define is_mips_elf(bfd) \
247 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
248 && elf_tdata (bfd) != NULL \
249 && elf_object_id (bfd) == MIPS_ELF_DATA)
251 /* The ABI says that every symbol used by dynamic relocations must have
252 a global GOT entry. Among other things, this provides the dynamic
253 linker with a free, directly-indexed cache. The GOT can therefore
254 contain symbols that are not referenced by GOT relocations themselves
255 (in other words, it may have symbols that are not referenced by things
256 like R_MIPS_GOT16 and R_MIPS_GOT_PAGE).
258 GOT relocations are less likely to overflow if we put the associated
259 GOT entries towards the beginning. We therefore divide the global
260 GOT entries into two areas: "normal" and "reloc-only". Entries in
261 the first area can be used for both dynamic relocations and GP-relative
262 accesses, while those in the "reloc-only" area are for dynamic
265 These GGA_* ("Global GOT Area") values are organised so that lower
266 values are more general than higher values. Also, non-GGA_NONE
267 values are ordered by the position of the area in the GOT. */
269 #define GGA_RELOC_ONLY 1
272 /* Information about a non-PIC interface to a PIC function. There are
273 two ways of creating these interfaces. The first is to add:
276 addiu $25,$25,%lo(func)
278 immediately before a PIC function "func". The second is to add:
282 addiu $25,$25,%lo(func)
284 to a separate trampoline section.
286 Stubs of the first kind go in a new section immediately before the
287 target function. Stubs of the second kind go in a single section
288 pointed to by the hash table's "strampoline" field. */
289 struct mips_elf_la25_stub {
290 /* The generated section that contains this stub. */
291 asection *stub_section;
293 /* The offset of the stub from the start of STUB_SECTION. */
296 /* One symbol for the original function. Its location is available
297 in H->root.root.u.def. */
298 struct mips_elf_link_hash_entry *h;
301 /* Macros for populating a mips_elf_la25_stub. */
303 #define LA25_LUI(VAL) (0x3c190000 | (VAL)) /* lui t9,VAL */
304 #define LA25_J(VAL) (0x08000000 | (((VAL) >> 2) & 0x3ffffff)) /* j VAL */
305 #define LA25_ADDIU(VAL) (0x27390000 | (VAL)) /* addiu t9,t9,VAL */
306 #define LA25_LUI_MICROMIPS(VAL) \
307 (0x41b90000 | (VAL)) /* lui t9,VAL */
308 #define LA25_J_MICROMIPS(VAL) \
309 (0xd4000000 | (((VAL) >> 1) & 0x3ffffff)) /* j VAL */
310 #define LA25_ADDIU_MICROMIPS(VAL) \
311 (0x33390000 | (VAL)) /* addiu t9,t9,VAL */
313 /* This structure is passed to mips_elf_sort_hash_table_f when sorting
314 the dynamic symbols. */
316 struct mips_elf_hash_sort_data
318 /* The symbol in the global GOT with the lowest dynamic symbol table
320 struct elf_link_hash_entry *low;
321 /* The least dynamic symbol table index corresponding to a non-TLS
322 symbol with a GOT entry. */
323 long min_got_dynindx;
324 /* The greatest dynamic symbol table index corresponding to a symbol
325 with a GOT entry that is not referenced (e.g., a dynamic symbol
326 with dynamic relocations pointing to it from non-primary GOTs). */
327 long max_unref_got_dynindx;
328 /* The greatest dynamic symbol table index not corresponding to a
329 symbol without a GOT entry. */
330 long max_non_got_dynindx;
333 /* The MIPS ELF linker needs additional information for each symbol in
334 the global hash table. */
336 struct mips_elf_link_hash_entry
338 struct elf_link_hash_entry root;
340 /* External symbol information. */
343 /* The la25 stub we have created for ths symbol, if any. */
344 struct mips_elf_la25_stub *la25_stub;
346 /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
348 unsigned int possibly_dynamic_relocs;
350 /* If there is a stub that 32 bit functions should use to call this
351 16 bit function, this points to the section containing the stub. */
354 /* If there is a stub that 16 bit functions should use to call this
355 32 bit function, this points to the section containing the stub. */
358 /* This is like the call_stub field, but it is used if the function
359 being called returns a floating point value. */
360 asection *call_fp_stub;
364 #define GOT_TLS_LDM 2
366 #define GOT_TLS_OFFSET_DONE 0x40
367 #define GOT_TLS_DONE 0x80
368 unsigned char tls_type;
370 /* This is only used in single-GOT mode; in multi-GOT mode there
371 is one mips_got_entry per GOT entry, so the offset is stored
372 there. In single-GOT mode there may be many mips_got_entry
373 structures all referring to the same GOT slot. It might be
374 possible to use root.got.offset instead, but that field is
375 overloaded already. */
376 bfd_vma tls_got_offset;
378 /* The highest GGA_* value that satisfies all references to this symbol. */
379 unsigned int global_got_area : 2;
381 /* True if all GOT relocations against this symbol are for calls. This is
382 a looser condition than no_fn_stub below, because there may be other
383 non-call non-GOT relocations against the symbol. */
384 unsigned int got_only_for_calls : 1;
386 /* True if one of the relocations described by possibly_dynamic_relocs
387 is against a readonly section. */
388 unsigned int readonly_reloc : 1;
390 /* True if there is a relocation against this symbol that must be
391 resolved by the static linker (in other words, if the relocation
392 cannot possibly be made dynamic). */
393 unsigned int has_static_relocs : 1;
395 /* True if we must not create a .MIPS.stubs entry for this symbol.
396 This is set, for example, if there are relocations related to
397 taking the function's address, i.e. any but R_MIPS_CALL*16 ones.
398 See "MIPS ABI Supplement, 3rd Edition", p. 4-20. */
399 unsigned int no_fn_stub : 1;
401 /* Whether we need the fn_stub; this is true if this symbol appears
402 in any relocs other than a 16 bit call. */
403 unsigned int need_fn_stub : 1;
405 /* True if this symbol is referenced by branch relocations from
406 any non-PIC input file. This is used to determine whether an
407 la25 stub is required. */
408 unsigned int has_nonpic_branches : 1;
410 /* Does this symbol need a traditional MIPS lazy-binding stub
411 (as opposed to a PLT entry)? */
412 unsigned int needs_lazy_stub : 1;
415 /* MIPS ELF linker hash table. */
417 struct mips_elf_link_hash_table
419 struct elf_link_hash_table root;
421 /* The number of .rtproc entries. */
422 bfd_size_type procedure_count;
424 /* The size of the .compact_rel section (if SGI_COMPAT). */
425 bfd_size_type compact_rel_size;
427 /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic entry
428 is set to the address of __rld_obj_head as in IRIX5 and IRIX6. */
429 bfd_boolean use_rld_obj_head;
431 /* The __rld_map or __rld_obj_head symbol. */
432 struct elf_link_hash_entry *rld_symbol;
434 /* This is set if we see any mips16 stub sections. */
435 bfd_boolean mips16_stubs_seen;
437 /* True if we can generate copy relocs and PLTs. */
438 bfd_boolean use_plts_and_copy_relocs;
440 /* True if we're generating code for VxWorks. */
441 bfd_boolean is_vxworks;
443 /* True if we already reported the small-data section overflow. */
444 bfd_boolean small_data_overflow_reported;
446 /* Shortcuts to some dynamic sections, or NULL if they are not
457 /* The master GOT information. */
458 struct mips_got_info *got_info;
460 /* The global symbol in the GOT with the lowest index in the dynamic
462 struct elf_link_hash_entry *global_gotsym;
464 /* The size of the PLT header in bytes. */
465 bfd_vma plt_header_size;
467 /* The size of a PLT entry in bytes. */
468 bfd_vma plt_entry_size;
470 /* The number of functions that need a lazy-binding stub. */
471 bfd_vma lazy_stub_count;
473 /* The size of a function stub entry in bytes. */
474 bfd_vma function_stub_size;
476 /* The number of reserved entries at the beginning of the GOT. */
477 unsigned int reserved_gotno;
479 /* The section used for mips_elf_la25_stub trampolines.
480 See the comment above that structure for details. */
481 asection *strampoline;
483 /* A table of mips_elf_la25_stubs, indexed by (input_section, offset)
487 /* A function FN (NAME, IS, OS) that creates a new input section
488 called NAME and links it to output section OS. If IS is nonnull,
489 the new section should go immediately before it, otherwise it
490 should go at the (current) beginning of OS.
492 The function returns the new section on success, otherwise it
494 asection *(*add_stub_section) (const char *, asection *, asection *);
497 /* Get the MIPS ELF linker hash table from a link_info structure. */
499 #define mips_elf_hash_table(p) \
500 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
501 == MIPS_ELF_DATA ? ((struct mips_elf_link_hash_table *) ((p)->hash)) : NULL)
503 /* A structure used to communicate with htab_traverse callbacks. */
504 struct mips_htab_traverse_info
506 /* The usual link-wide information. */
507 struct bfd_link_info *info;
510 /* Starts off FALSE and is set to TRUE if the link should be aborted. */
514 /* MIPS ELF private object data. */
516 struct mips_elf_obj_tdata
518 /* Generic ELF private object data. */
519 struct elf_obj_tdata root;
521 /* Input BFD providing Tag_GNU_MIPS_ABI_FP attribute for output. */
525 /* Get MIPS ELF private object data from BFD's tdata. */
527 #define mips_elf_tdata(bfd) \
528 ((struct mips_elf_obj_tdata *) (bfd)->tdata.any)
530 #define TLS_RELOC_P(r_type) \
531 (r_type == R_MIPS_TLS_DTPMOD32 \
532 || r_type == R_MIPS_TLS_DTPMOD64 \
533 || r_type == R_MIPS_TLS_DTPREL32 \
534 || r_type == R_MIPS_TLS_DTPREL64 \
535 || r_type == R_MIPS_TLS_GD \
536 || r_type == R_MIPS_TLS_LDM \
537 || r_type == R_MIPS_TLS_DTPREL_HI16 \
538 || r_type == R_MIPS_TLS_DTPREL_LO16 \
539 || r_type == R_MIPS_TLS_GOTTPREL \
540 || r_type == R_MIPS_TLS_TPREL32 \
541 || r_type == R_MIPS_TLS_TPREL64 \
542 || r_type == R_MIPS_TLS_TPREL_HI16 \
543 || r_type == R_MIPS_TLS_TPREL_LO16 \
544 || r_type == R_MIPS16_TLS_GD \
545 || r_type == R_MIPS16_TLS_LDM \
546 || r_type == R_MIPS16_TLS_DTPREL_HI16 \
547 || r_type == R_MIPS16_TLS_DTPREL_LO16 \
548 || r_type == R_MIPS16_TLS_GOTTPREL \
549 || r_type == R_MIPS16_TLS_TPREL_HI16 \
550 || r_type == R_MIPS16_TLS_TPREL_LO16 \
551 || r_type == R_MICROMIPS_TLS_GD \
552 || r_type == R_MICROMIPS_TLS_LDM \
553 || r_type == R_MICROMIPS_TLS_DTPREL_HI16 \
554 || r_type == R_MICROMIPS_TLS_DTPREL_LO16 \
555 || r_type == R_MICROMIPS_TLS_GOTTPREL \
556 || r_type == R_MICROMIPS_TLS_TPREL_HI16 \
557 || r_type == R_MICROMIPS_TLS_TPREL_LO16)
559 /* Structure used to pass information to mips_elf_output_extsym. */
564 struct bfd_link_info *info;
565 struct ecoff_debug_info *debug;
566 const struct ecoff_debug_swap *swap;
570 /* The names of the runtime procedure table symbols used on IRIX5. */
572 static const char * const mips_elf_dynsym_rtproc_names[] =
575 "_procedure_string_table",
576 "_procedure_table_size",
580 /* These structures are used to generate the .compact_rel section on
585 unsigned long id1; /* Always one? */
586 unsigned long num; /* Number of compact relocation entries. */
587 unsigned long id2; /* Always two? */
588 unsigned long offset; /* The file offset of the first relocation. */
589 unsigned long reserved0; /* Zero? */
590 unsigned long reserved1; /* Zero? */
599 bfd_byte reserved0[4];
600 bfd_byte reserved1[4];
601 } Elf32_External_compact_rel;
605 unsigned int ctype : 1; /* 1: long 0: short format. See below. */
606 unsigned int rtype : 4; /* Relocation types. See below. */
607 unsigned int dist2to : 8;
608 unsigned int relvaddr : 19; /* (VADDR - vaddr of the previous entry)/ 4 */
609 unsigned long konst; /* KONST field. See below. */
610 unsigned long vaddr; /* VADDR to be relocated. */
615 unsigned int ctype : 1; /* 1: long 0: short format. See below. */
616 unsigned int rtype : 4; /* Relocation types. See below. */
617 unsigned int dist2to : 8;
618 unsigned int relvaddr : 19; /* (VADDR - vaddr of the previous entry)/ 4 */
619 unsigned long konst; /* KONST field. See below. */
627 } Elf32_External_crinfo;
633 } Elf32_External_crinfo2;
635 /* These are the constants used to swap the bitfields in a crinfo. */
637 #define CRINFO_CTYPE (0x1)
638 #define CRINFO_CTYPE_SH (31)
639 #define CRINFO_RTYPE (0xf)
640 #define CRINFO_RTYPE_SH (27)
641 #define CRINFO_DIST2TO (0xff)
642 #define CRINFO_DIST2TO_SH (19)
643 #define CRINFO_RELVADDR (0x7ffff)
644 #define CRINFO_RELVADDR_SH (0)
646 /* A compact relocation info has long (3 words) or short (2 words)
647 formats. A short format doesn't have VADDR field and relvaddr
648 fields contains ((VADDR - vaddr of the previous entry) >> 2). */
649 #define CRF_MIPS_LONG 1
650 #define CRF_MIPS_SHORT 0
652 /* There are 4 types of compact relocation at least. The value KONST
653 has different meaning for each type:
656 CT_MIPS_REL32 Address in data
657 CT_MIPS_WORD Address in word (XXX)
658 CT_MIPS_GPHI_LO GP - vaddr
659 CT_MIPS_JMPAD Address to jump
662 #define CRT_MIPS_REL32 0xa
663 #define CRT_MIPS_WORD 0xb
664 #define CRT_MIPS_GPHI_LO 0xc
665 #define CRT_MIPS_JMPAD 0xd
667 #define mips_elf_set_cr_format(x,format) ((x).ctype = (format))
668 #define mips_elf_set_cr_type(x,type) ((x).rtype = (type))
669 #define mips_elf_set_cr_dist2to(x,v) ((x).dist2to = (v))
670 #define mips_elf_set_cr_relvaddr(x,d) ((x).relvaddr = (d)<<2)
672 /* The structure of the runtime procedure descriptor created by the
673 loader for use by the static exception system. */
675 typedef struct runtime_pdr {
676 bfd_vma adr; /* Memory address of start of procedure. */
677 long regmask; /* Save register mask. */
678 long regoffset; /* Save register offset. */
679 long fregmask; /* Save floating point register mask. */
680 long fregoffset; /* Save floating point register offset. */
681 long frameoffset; /* Frame size. */
682 short framereg; /* Frame pointer register. */
683 short pcreg; /* Offset or reg of return pc. */
684 long irpss; /* Index into the runtime string table. */
686 struct exception_info *exception_info;/* Pointer to exception array. */
688 #define cbRPDR sizeof (RPDR)
689 #define rpdNil ((pRPDR) 0)
691 static struct mips_got_entry *mips_elf_create_local_got_entry
692 (bfd *, struct bfd_link_info *, bfd *, bfd_vma, unsigned long,
693 struct mips_elf_link_hash_entry *, int);
694 static bfd_boolean mips_elf_sort_hash_table_f
695 (struct mips_elf_link_hash_entry *, void *);
696 static bfd_vma mips_elf_high
698 static bfd_boolean mips_elf_create_dynamic_relocation
699 (bfd *, struct bfd_link_info *, const Elf_Internal_Rela *,
700 struct mips_elf_link_hash_entry *, asection *, bfd_vma,
701 bfd_vma *, asection *);
702 static hashval_t mips_elf_got_entry_hash
704 static bfd_vma mips_elf_adjust_gp
705 (bfd *, struct mips_got_info *, bfd *);
706 static struct mips_got_info *mips_elf_got_for_ibfd
707 (struct mips_got_info *, bfd *);
709 /* This will be used when we sort the dynamic relocation records. */
710 static bfd *reldyn_sorting_bfd;
712 /* True if ABFD is for CPUs with load interlocking that include
713 non-MIPS1 CPUs and R3900. */
714 #define LOAD_INTERLOCKS_P(abfd) \
715 ( ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) != E_MIPS_ARCH_1) \
716 || ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == E_MIPS_MACH_3900))
718 /* True if ABFD is for CPUs that are faster if JAL is converted to BAL.
719 This should be safe for all architectures. We enable this predicate
720 for RM9000 for now. */
721 #define JAL_TO_BAL_P(abfd) \
722 ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == E_MIPS_MACH_9000)
724 /* True if ABFD is for CPUs that are faster if JALR is converted to BAL.
725 This should be safe for all architectures. We enable this predicate for
727 #define JALR_TO_BAL_P(abfd) 1
729 /* True if ABFD is for CPUs that are faster if JR is converted to B.
730 This should be safe for all architectures. We enable this predicate for
732 #define JR_TO_B_P(abfd) 1
734 /* True if ABFD is a PIC object. */
735 #define PIC_OBJECT_P(abfd) \
736 ((elf_elfheader (abfd)->e_flags & EF_MIPS_PIC) != 0)
738 /* Nonzero if ABFD is using the N32 ABI. */
739 #define ABI_N32_P(abfd) \
740 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
742 /* Nonzero if ABFD is using the N64 ABI. */
743 #define ABI_64_P(abfd) \
744 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
746 /* Nonzero if ABFD is using NewABI conventions. */
747 #define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
749 /* The IRIX compatibility level we are striving for. */
750 #define IRIX_COMPAT(abfd) \
751 (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
753 /* Whether we are trying to be compatible with IRIX at all. */
754 #define SGI_COMPAT(abfd) \
755 (IRIX_COMPAT (abfd) != ict_none)
757 /* The name of the options section. */
758 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
759 (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
761 /* True if NAME is the recognized name of any SHT_MIPS_OPTIONS section.
762 Some IRIX system files do not use MIPS_ELF_OPTIONS_SECTION_NAME. */
763 #define MIPS_ELF_OPTIONS_SECTION_NAME_P(NAME) \
764 (strcmp (NAME, ".MIPS.options") == 0 || strcmp (NAME, ".options") == 0)
766 /* Whether the section is readonly. */
767 #define MIPS_ELF_READONLY_SECTION(sec) \
768 ((sec->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY)) \
769 == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
771 /* The name of the stub section. */
772 #define MIPS_ELF_STUB_SECTION_NAME(abfd) ".MIPS.stubs"
774 /* The size of an external REL relocation. */
775 #define MIPS_ELF_REL_SIZE(abfd) \
776 (get_elf_backend_data (abfd)->s->sizeof_rel)
778 /* The size of an external RELA relocation. */
779 #define MIPS_ELF_RELA_SIZE(abfd) \
780 (get_elf_backend_data (abfd)->s->sizeof_rela)
782 /* The size of an external dynamic table entry. */
783 #define MIPS_ELF_DYN_SIZE(abfd) \
784 (get_elf_backend_data (abfd)->s->sizeof_dyn)
786 /* The size of a GOT entry. */
787 #define MIPS_ELF_GOT_SIZE(abfd) \
788 (get_elf_backend_data (abfd)->s->arch_size / 8)
790 /* The size of the .rld_map section. */
791 #define MIPS_ELF_RLD_MAP_SIZE(abfd) \
792 (get_elf_backend_data (abfd)->s->arch_size / 8)
794 /* The size of a symbol-table entry. */
795 #define MIPS_ELF_SYM_SIZE(abfd) \
796 (get_elf_backend_data (abfd)->s->sizeof_sym)
798 /* The default alignment for sections, as a power of two. */
799 #define MIPS_ELF_LOG_FILE_ALIGN(abfd) \
800 (get_elf_backend_data (abfd)->s->log_file_align)
802 /* Get word-sized data. */
803 #define MIPS_ELF_GET_WORD(abfd, ptr) \
804 (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
806 /* Put out word-sized data. */
807 #define MIPS_ELF_PUT_WORD(abfd, val, ptr) \
809 ? bfd_put_64 (abfd, val, ptr) \
810 : bfd_put_32 (abfd, val, ptr))
812 /* The opcode for word-sized loads (LW or LD). */
813 #define MIPS_ELF_LOAD_WORD(abfd) \
814 (ABI_64_P (abfd) ? 0xdc000000 : 0x8c000000)
816 /* Add a dynamic symbol table-entry. */
817 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
818 _bfd_elf_add_dynamic_entry (info, tag, val)
820 #define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela) \
821 (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela))
823 /* The name of the dynamic relocation section. */
824 #define MIPS_ELF_REL_DYN_NAME(INFO) \
825 (mips_elf_hash_table (INFO)->is_vxworks ? ".rela.dyn" : ".rel.dyn")
827 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
828 from smaller values. Start with zero, widen, *then* decrement. */
829 #define MINUS_ONE (((bfd_vma)0) - 1)
830 #define MINUS_TWO (((bfd_vma)0) - 2)
832 /* The value to write into got[1] for SVR4 targets, to identify it is
833 a GNU object. The dynamic linker can then use got[1] to store the
835 #define MIPS_ELF_GNU_GOT1_MASK(abfd) \
836 ((bfd_vma) 1 << (ABI_64_P (abfd) ? 63 : 31))
838 /* The offset of $gp from the beginning of the .got section. */
839 #define ELF_MIPS_GP_OFFSET(INFO) \
840 (mips_elf_hash_table (INFO)->is_vxworks ? 0x0 : 0x7ff0)
842 /* The maximum size of the GOT for it to be addressable using 16-bit
844 #define MIPS_ELF_GOT_MAX_SIZE(INFO) (ELF_MIPS_GP_OFFSET (INFO) + 0x7fff)
846 /* Instructions which appear in a stub. */
847 #define STUB_LW(abfd) \
849 ? 0xdf998010 /* ld t9,0x8010(gp) */ \
850 : 0x8f998010)) /* lw t9,0x8010(gp) */
851 #define STUB_MOVE(abfd) \
853 ? 0x03e0782d /* daddu t7,ra */ \
854 : 0x03e07821)) /* addu t7,ra */
855 #define STUB_LUI(VAL) (0x3c180000 + (VAL)) /* lui t8,VAL */
856 #define STUB_JALR 0x0320f809 /* jalr t9,ra */
857 #define STUB_ORI(VAL) (0x37180000 + (VAL)) /* ori t8,t8,VAL */
858 #define STUB_LI16U(VAL) (0x34180000 + (VAL)) /* ori t8,zero,VAL unsigned */
859 #define STUB_LI16S(abfd, VAL) \
861 ? (0x64180000 + (VAL)) /* daddiu t8,zero,VAL sign extended */ \
862 : (0x24180000 + (VAL)))) /* addiu t8,zero,VAL sign extended */
864 #define MIPS_FUNCTION_STUB_NORMAL_SIZE 16
865 #define MIPS_FUNCTION_STUB_BIG_SIZE 20
867 /* The name of the dynamic interpreter. This is put in the .interp
870 #define ELF_DYNAMIC_INTERPRETER(abfd) \
871 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
872 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
873 : "/usr/lib/libc.so.1")
876 #define MNAME(bfd,pre,pos) \
877 (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
878 #define ELF_R_SYM(bfd, i) \
879 (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
880 #define ELF_R_TYPE(bfd, i) \
881 (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
882 #define ELF_R_INFO(bfd, s, t) \
883 (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
885 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
886 #define ELF_R_SYM(bfd, i) \
888 #define ELF_R_TYPE(bfd, i) \
890 #define ELF_R_INFO(bfd, s, t) \
891 (ELF32_R_INFO (s, t))
894 /* The mips16 compiler uses a couple of special sections to handle
895 floating point arguments.
897 Section names that look like .mips16.fn.FNNAME contain stubs that
898 copy floating point arguments from the fp regs to the gp regs and
899 then jump to FNNAME. If any 32 bit function calls FNNAME, the
900 call should be redirected to the stub instead. If no 32 bit
901 function calls FNNAME, the stub should be discarded. We need to
902 consider any reference to the function, not just a call, because
903 if the address of the function is taken we will need the stub,
904 since the address might be passed to a 32 bit function.
906 Section names that look like .mips16.call.FNNAME contain stubs
907 that copy floating point arguments from the gp regs to the fp
908 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
909 then any 16 bit function that calls FNNAME should be redirected
910 to the stub instead. If FNNAME is not a 32 bit function, the
911 stub should be discarded.
913 .mips16.call.fp.FNNAME sections are similar, but contain stubs
914 which call FNNAME and then copy the return value from the fp regs
915 to the gp regs. These stubs store the return value in $18 while
916 calling FNNAME; any function which might call one of these stubs
917 must arrange to save $18 around the call. (This case is not
918 needed for 32 bit functions that call 16 bit functions, because
919 16 bit functions always return floating point values in both
922 Note that in all cases FNNAME might be defined statically.
923 Therefore, FNNAME is not used literally. Instead, the relocation
924 information will indicate which symbol the section is for.
926 We record any stubs that we find in the symbol table. */
928 #define FN_STUB ".mips16.fn."
929 #define CALL_STUB ".mips16.call."
930 #define CALL_FP_STUB ".mips16.call.fp."
932 #define FN_STUB_P(name) CONST_STRNEQ (name, FN_STUB)
933 #define CALL_STUB_P(name) CONST_STRNEQ (name, CALL_STUB)
934 #define CALL_FP_STUB_P(name) CONST_STRNEQ (name, CALL_FP_STUB)
936 /* The format of the first PLT entry in an O32 executable. */
937 static const bfd_vma mips_o32_exec_plt0_entry[] =
939 0x3c1c0000, /* lui $28, %hi(&GOTPLT[0]) */
940 0x8f990000, /* lw $25, %lo(&GOTPLT[0])($28) */
941 0x279c0000, /* addiu $28, $28, %lo(&GOTPLT[0]) */
942 0x031cc023, /* subu $24, $24, $28 */
943 0x03e07821, /* move $15, $31 # 32-bit move (addu) */
944 0x0018c082, /* srl $24, $24, 2 */
945 0x0320f809, /* jalr $25 */
946 0x2718fffe /* subu $24, $24, 2 */
949 /* The format of the first PLT entry in an N32 executable. Different
950 because gp ($28) is not available; we use t2 ($14) instead. */
951 static const bfd_vma mips_n32_exec_plt0_entry[] =
953 0x3c0e0000, /* lui $14, %hi(&GOTPLT[0]) */
954 0x8dd90000, /* lw $25, %lo(&GOTPLT[0])($14) */
955 0x25ce0000, /* addiu $14, $14, %lo(&GOTPLT[0]) */
956 0x030ec023, /* subu $24, $24, $14 */
957 0x03e07821, /* move $15, $31 # 32-bit move (addu) */
958 0x0018c082, /* srl $24, $24, 2 */
959 0x0320f809, /* jalr $25 */
960 0x2718fffe /* subu $24, $24, 2 */
963 /* The format of the first PLT entry in an N64 executable. Different
964 from N32 because of the increased size of GOT entries. */
965 static const bfd_vma mips_n64_exec_plt0_entry[] =
967 0x3c0e0000, /* lui $14, %hi(&GOTPLT[0]) */
968 0xddd90000, /* ld $25, %lo(&GOTPLT[0])($14) */
969 0x25ce0000, /* addiu $14, $14, %lo(&GOTPLT[0]) */
970 0x030ec023, /* subu $24, $24, $14 */
971 0x03e0782d, /* move $15, $31 # 64-bit move (daddu) */
972 0x0018c0c2, /* srl $24, $24, 3 */
973 0x0320f809, /* jalr $25 */
974 0x2718fffe /* subu $24, $24, 2 */
977 /* The format of subsequent PLT entries. */
978 static const bfd_vma mips_exec_plt_entry[] =
980 0x3c0f0000, /* lui $15, %hi(.got.plt entry) */
981 0x01f90000, /* l[wd] $25, %lo(.got.plt entry)($15) */
982 0x25f80000, /* addiu $24, $15, %lo(.got.plt entry) */
983 0x03200008 /* jr $25 */
986 /* The format of the first PLT entry in a VxWorks executable. */
987 static const bfd_vma mips_vxworks_exec_plt0_entry[] =
989 0x3c190000, /* lui t9, %hi(_GLOBAL_OFFSET_TABLE_) */
990 0x27390000, /* addiu t9, t9, %lo(_GLOBAL_OFFSET_TABLE_) */
991 0x8f390008, /* lw t9, 8(t9) */
992 0x00000000, /* nop */
993 0x03200008, /* jr t9 */
997 /* The format of subsequent PLT entries. */
998 static const bfd_vma mips_vxworks_exec_plt_entry[] =
1000 0x10000000, /* b .PLT_resolver */
1001 0x24180000, /* li t8, <pltindex> */
1002 0x3c190000, /* lui t9, %hi(<.got.plt slot>) */
1003 0x27390000, /* addiu t9, t9, %lo(<.got.plt slot>) */
1004 0x8f390000, /* lw t9, 0(t9) */
1005 0x00000000, /* nop */
1006 0x03200008, /* jr t9 */
1007 0x00000000 /* nop */
1010 /* The format of the first PLT entry in a VxWorks shared object. */
1011 static const bfd_vma mips_vxworks_shared_plt0_entry[] =
1013 0x8f990008, /* lw t9, 8(gp) */
1014 0x00000000, /* nop */
1015 0x03200008, /* jr t9 */
1016 0x00000000, /* nop */
1017 0x00000000, /* nop */
1018 0x00000000 /* nop */
1021 /* The format of subsequent PLT entries. */
1022 static const bfd_vma mips_vxworks_shared_plt_entry[] =
1024 0x10000000, /* b .PLT_resolver */
1025 0x24180000 /* li t8, <pltindex> */
1028 /* microMIPS 32-bit opcode helper installer. */
1031 bfd_put_micromips_32 (const bfd *abfd, bfd_vma opcode, bfd_byte *ptr)
1033 bfd_put_16 (abfd, (opcode >> 16) & 0xffff, ptr);
1034 bfd_put_16 (abfd, opcode & 0xffff, ptr + 2);
1037 /* microMIPS 32-bit opcode helper retriever. */
1040 bfd_get_micromips_32 (const bfd *abfd, const bfd_byte *ptr)
1042 return (bfd_get_16 (abfd, ptr) << 16) | bfd_get_16 (abfd, ptr + 2);
1045 /* Look up an entry in a MIPS ELF linker hash table. */
1047 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
1048 ((struct mips_elf_link_hash_entry *) \
1049 elf_link_hash_lookup (&(table)->root, (string), (create), \
1052 /* Traverse a MIPS ELF linker hash table. */
1054 #define mips_elf_link_hash_traverse(table, func, info) \
1055 (elf_link_hash_traverse \
1057 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
1060 /* Find the base offsets for thread-local storage in this object,
1061 for GD/LD and IE/LE respectively. */
1063 #define TP_OFFSET 0x7000
1064 #define DTP_OFFSET 0x8000
1067 dtprel_base (struct bfd_link_info *info)
1069 /* If tls_sec is NULL, we should have signalled an error already. */
1070 if (elf_hash_table (info)->tls_sec == NULL)
1072 return elf_hash_table (info)->tls_sec->vma + DTP_OFFSET;
1076 tprel_base (struct bfd_link_info *info)
1078 /* If tls_sec is NULL, we should have signalled an error already. */
1079 if (elf_hash_table (info)->tls_sec == NULL)
1081 return elf_hash_table (info)->tls_sec->vma + TP_OFFSET;
1084 /* Create an entry in a MIPS ELF linker hash table. */
1086 static struct bfd_hash_entry *
1087 mips_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
1088 struct bfd_hash_table *table, const char *string)
1090 struct mips_elf_link_hash_entry *ret =
1091 (struct mips_elf_link_hash_entry *) entry;
1093 /* Allocate the structure if it has not already been allocated by a
1096 ret = bfd_hash_allocate (table, sizeof (struct mips_elf_link_hash_entry));
1098 return (struct bfd_hash_entry *) ret;
1100 /* Call the allocation method of the superclass. */
1101 ret = ((struct mips_elf_link_hash_entry *)
1102 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1106 /* Set local fields. */
1107 memset (&ret->esym, 0, sizeof (EXTR));
1108 /* We use -2 as a marker to indicate that the information has
1109 not been set. -1 means there is no associated ifd. */
1112 ret->possibly_dynamic_relocs = 0;
1113 ret->fn_stub = NULL;
1114 ret->call_stub = NULL;
1115 ret->call_fp_stub = NULL;
1116 ret->tls_type = GOT_NORMAL;
1117 ret->global_got_area = GGA_NONE;
1118 ret->got_only_for_calls = TRUE;
1119 ret->readonly_reloc = FALSE;
1120 ret->has_static_relocs = FALSE;
1121 ret->no_fn_stub = FALSE;
1122 ret->need_fn_stub = FALSE;
1123 ret->has_nonpic_branches = FALSE;
1124 ret->needs_lazy_stub = FALSE;
1127 return (struct bfd_hash_entry *) ret;
1130 /* Allocate MIPS ELF private object data. */
1133 _bfd_mips_elf_mkobject (bfd *abfd)
1135 return bfd_elf_allocate_object (abfd, sizeof (struct mips_elf_obj_tdata),
1140 _bfd_mips_elf_new_section_hook (bfd *abfd, asection *sec)
1142 if (!sec->used_by_bfd)
1144 struct _mips_elf_section_data *sdata;
1145 bfd_size_type amt = sizeof (*sdata);
1147 sdata = bfd_zalloc (abfd, amt);
1150 sec->used_by_bfd = sdata;
1153 return _bfd_elf_new_section_hook (abfd, sec);
1156 /* Read ECOFF debugging information from a .mdebug section into a
1157 ecoff_debug_info structure. */
1160 _bfd_mips_elf_read_ecoff_info (bfd *abfd, asection *section,
1161 struct ecoff_debug_info *debug)
1164 const struct ecoff_debug_swap *swap;
1167 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1168 memset (debug, 0, sizeof (*debug));
1170 ext_hdr = bfd_malloc (swap->external_hdr_size);
1171 if (ext_hdr == NULL && swap->external_hdr_size != 0)
1174 if (! bfd_get_section_contents (abfd, section, ext_hdr, 0,
1175 swap->external_hdr_size))
1178 symhdr = &debug->symbolic_header;
1179 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
1181 /* The symbolic header contains absolute file offsets and sizes to
1183 #define READ(ptr, offset, count, size, type) \
1184 if (symhdr->count == 0) \
1185 debug->ptr = NULL; \
1188 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
1189 debug->ptr = bfd_malloc (amt); \
1190 if (debug->ptr == NULL) \
1191 goto error_return; \
1192 if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0 \
1193 || bfd_bread (debug->ptr, amt, abfd) != amt) \
1194 goto error_return; \
1197 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
1198 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *);
1199 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *);
1200 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *);
1201 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *);
1202 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
1204 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
1205 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
1206 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *);
1207 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *);
1208 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, void *);
1216 if (ext_hdr != NULL)
1218 if (debug->line != NULL)
1220 if (debug->external_dnr != NULL)
1221 free (debug->external_dnr);
1222 if (debug->external_pdr != NULL)
1223 free (debug->external_pdr);
1224 if (debug->external_sym != NULL)
1225 free (debug->external_sym);
1226 if (debug->external_opt != NULL)
1227 free (debug->external_opt);
1228 if (debug->external_aux != NULL)
1229 free (debug->external_aux);
1230 if (debug->ss != NULL)
1232 if (debug->ssext != NULL)
1233 free (debug->ssext);
1234 if (debug->external_fdr != NULL)
1235 free (debug->external_fdr);
1236 if (debug->external_rfd != NULL)
1237 free (debug->external_rfd);
1238 if (debug->external_ext != NULL)
1239 free (debug->external_ext);
1243 /* Swap RPDR (runtime procedure table entry) for output. */
1246 ecoff_swap_rpdr_out (bfd *abfd, const RPDR *in, struct rpdr_ext *ex)
1248 H_PUT_S32 (abfd, in->adr, ex->p_adr);
1249 H_PUT_32 (abfd, in->regmask, ex->p_regmask);
1250 H_PUT_32 (abfd, in->regoffset, ex->p_regoffset);
1251 H_PUT_32 (abfd, in->fregmask, ex->p_fregmask);
1252 H_PUT_32 (abfd, in->fregoffset, ex->p_fregoffset);
1253 H_PUT_32 (abfd, in->frameoffset, ex->p_frameoffset);
1255 H_PUT_16 (abfd, in->framereg, ex->p_framereg);
1256 H_PUT_16 (abfd, in->pcreg, ex->p_pcreg);
1258 H_PUT_32 (abfd, in->irpss, ex->p_irpss);
1261 /* Create a runtime procedure table from the .mdebug section. */
1264 mips_elf_create_procedure_table (void *handle, bfd *abfd,
1265 struct bfd_link_info *info, asection *s,
1266 struct ecoff_debug_info *debug)
1268 const struct ecoff_debug_swap *swap;
1269 HDRR *hdr = &debug->symbolic_header;
1271 struct rpdr_ext *erp;
1273 struct pdr_ext *epdr;
1274 struct sym_ext *esym;
1278 bfd_size_type count;
1279 unsigned long sindex;
1283 const char *no_name_func = _("static procedure (no name)");
1291 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1293 sindex = strlen (no_name_func) + 1;
1294 count = hdr->ipdMax;
1297 size = swap->external_pdr_size;
1299 epdr = bfd_malloc (size * count);
1303 if (! _bfd_ecoff_get_accumulated_pdr (handle, (bfd_byte *) epdr))
1306 size = sizeof (RPDR);
1307 rp = rpdr = bfd_malloc (size * count);
1311 size = sizeof (char *);
1312 sv = bfd_malloc (size * count);
1316 count = hdr->isymMax;
1317 size = swap->external_sym_size;
1318 esym = bfd_malloc (size * count);
1322 if (! _bfd_ecoff_get_accumulated_sym (handle, (bfd_byte *) esym))
1325 count = hdr->issMax;
1326 ss = bfd_malloc (count);
1329 if (! _bfd_ecoff_get_accumulated_ss (handle, (bfd_byte *) ss))
1332 count = hdr->ipdMax;
1333 for (i = 0; i < (unsigned long) count; i++, rp++)
1335 (*swap->swap_pdr_in) (abfd, epdr + i, &pdr);
1336 (*swap->swap_sym_in) (abfd, &esym[pdr.isym], &sym);
1337 rp->adr = sym.value;
1338 rp->regmask = pdr.regmask;
1339 rp->regoffset = pdr.regoffset;
1340 rp->fregmask = pdr.fregmask;
1341 rp->fregoffset = pdr.fregoffset;
1342 rp->frameoffset = pdr.frameoffset;
1343 rp->framereg = pdr.framereg;
1344 rp->pcreg = pdr.pcreg;
1346 sv[i] = ss + sym.iss;
1347 sindex += strlen (sv[i]) + 1;
1351 size = sizeof (struct rpdr_ext) * (count + 2) + sindex;
1352 size = BFD_ALIGN (size, 16);
1353 rtproc = bfd_alloc (abfd, size);
1356 mips_elf_hash_table (info)->procedure_count = 0;
1360 mips_elf_hash_table (info)->procedure_count = count + 2;
1363 memset (erp, 0, sizeof (struct rpdr_ext));
1365 str = (char *) rtproc + sizeof (struct rpdr_ext) * (count + 2);
1366 strcpy (str, no_name_func);
1367 str += strlen (no_name_func) + 1;
1368 for (i = 0; i < count; i++)
1370 ecoff_swap_rpdr_out (abfd, rpdr + i, erp + i);
1371 strcpy (str, sv[i]);
1372 str += strlen (sv[i]) + 1;
1374 H_PUT_S32 (abfd, -1, (erp + count)->p_adr);
1376 /* Set the size and contents of .rtproc section. */
1378 s->contents = rtproc;
1380 /* Skip this section later on (I don't think this currently
1381 matters, but someday it might). */
1382 s->map_head.link_order = NULL;
1411 /* We're going to create a stub for H. Create a symbol for the stub's
1412 value and size, to help make the disassembly easier to read. */
1415 mips_elf_create_stub_symbol (struct bfd_link_info *info,
1416 struct mips_elf_link_hash_entry *h,
1417 const char *prefix, asection *s, bfd_vma value,
1420 struct bfd_link_hash_entry *bh;
1421 struct elf_link_hash_entry *elfh;
1424 if (ELF_ST_IS_MICROMIPS (h->root.other))
1427 /* Create a new symbol. */
1428 name = ACONCAT ((prefix, h->root.root.root.string, NULL));
1430 if (!_bfd_generic_link_add_one_symbol (info, s->owner, name,
1431 BSF_LOCAL, s, value, NULL,
1435 /* Make it a local function. */
1436 elfh = (struct elf_link_hash_entry *) bh;
1437 elfh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
1439 elfh->forced_local = 1;
1443 /* We're about to redefine H. Create a symbol to represent H's
1444 current value and size, to help make the disassembly easier
1448 mips_elf_create_shadow_symbol (struct bfd_link_info *info,
1449 struct mips_elf_link_hash_entry *h,
1452 struct bfd_link_hash_entry *bh;
1453 struct elf_link_hash_entry *elfh;
1458 /* Read the symbol's value. */
1459 BFD_ASSERT (h->root.root.type == bfd_link_hash_defined
1460 || h->root.root.type == bfd_link_hash_defweak);
1461 s = h->root.root.u.def.section;
1462 value = h->root.root.u.def.value;
1464 /* Create a new symbol. */
1465 name = ACONCAT ((prefix, h->root.root.root.string, NULL));
1467 if (!_bfd_generic_link_add_one_symbol (info, s->owner, name,
1468 BSF_LOCAL, s, value, NULL,
1472 /* Make it local and copy the other attributes from H. */
1473 elfh = (struct elf_link_hash_entry *) bh;
1474 elfh->type = ELF_ST_INFO (STB_LOCAL, ELF_ST_TYPE (h->root.type));
1475 elfh->other = h->root.other;
1476 elfh->size = h->root.size;
1477 elfh->forced_local = 1;
1481 /* Return TRUE if relocations in SECTION can refer directly to a MIPS16
1482 function rather than to a hard-float stub. */
1485 section_allows_mips16_refs_p (asection *section)
1489 name = bfd_get_section_name (section->owner, section);
1490 return (FN_STUB_P (name)
1491 || CALL_STUB_P (name)
1492 || CALL_FP_STUB_P (name)
1493 || strcmp (name, ".pdr") == 0);
1496 /* [RELOCS, RELEND) are the relocations against SEC, which is a MIPS16
1497 stub section of some kind. Return the R_SYMNDX of the target
1498 function, or 0 if we can't decide which function that is. */
1500 static unsigned long
1501 mips16_stub_symndx (const struct elf_backend_data *bed,
1502 asection *sec ATTRIBUTE_UNUSED,
1503 const Elf_Internal_Rela *relocs,
1504 const Elf_Internal_Rela *relend)
1506 int int_rels_per_ext_rel = bed->s->int_rels_per_ext_rel;
1507 const Elf_Internal_Rela *rel;
1509 /* Trust the first R_MIPS_NONE relocation, if any, but not a subsequent
1510 one in a compound relocation. */
1511 for (rel = relocs; rel < relend; rel += int_rels_per_ext_rel)
1512 if (ELF_R_TYPE (sec->owner, rel->r_info) == R_MIPS_NONE)
1513 return ELF_R_SYM (sec->owner, rel->r_info);
1515 /* Otherwise trust the first relocation, whatever its kind. This is
1516 the traditional behavior. */
1517 if (relocs < relend)
1518 return ELF_R_SYM (sec->owner, relocs->r_info);
1523 /* Check the mips16 stubs for a particular symbol, and see if we can
1527 mips_elf_check_mips16_stubs (struct bfd_link_info *info,
1528 struct mips_elf_link_hash_entry *h)
1530 /* Dynamic symbols must use the standard call interface, in case other
1531 objects try to call them. */
1532 if (h->fn_stub != NULL
1533 && h->root.dynindx != -1)
1535 mips_elf_create_shadow_symbol (info, h, ".mips16.");
1536 h->need_fn_stub = TRUE;
1539 if (h->fn_stub != NULL
1540 && ! h->need_fn_stub)
1542 /* We don't need the fn_stub; the only references to this symbol
1543 are 16 bit calls. Clobber the size to 0 to prevent it from
1544 being included in the link. */
1545 h->fn_stub->size = 0;
1546 h->fn_stub->flags &= ~SEC_RELOC;
1547 h->fn_stub->reloc_count = 0;
1548 h->fn_stub->flags |= SEC_EXCLUDE;
1551 if (h->call_stub != NULL
1552 && ELF_ST_IS_MIPS16 (h->root.other))
1554 /* We don't need the call_stub; this is a 16 bit function, so
1555 calls from other 16 bit functions are OK. Clobber the size
1556 to 0 to prevent it from being included in the link. */
1557 h->call_stub->size = 0;
1558 h->call_stub->flags &= ~SEC_RELOC;
1559 h->call_stub->reloc_count = 0;
1560 h->call_stub->flags |= SEC_EXCLUDE;
1563 if (h->call_fp_stub != NULL
1564 && ELF_ST_IS_MIPS16 (h->root.other))
1566 /* We don't need the call_stub; this is a 16 bit function, so
1567 calls from other 16 bit functions are OK. Clobber the size
1568 to 0 to prevent it from being included in the link. */
1569 h->call_fp_stub->size = 0;
1570 h->call_fp_stub->flags &= ~SEC_RELOC;
1571 h->call_fp_stub->reloc_count = 0;
1572 h->call_fp_stub->flags |= SEC_EXCLUDE;
1576 /* Hashtable callbacks for mips_elf_la25_stubs. */
1579 mips_elf_la25_stub_hash (const void *entry_)
1581 const struct mips_elf_la25_stub *entry;
1583 entry = (struct mips_elf_la25_stub *) entry_;
1584 return entry->h->root.root.u.def.section->id
1585 + entry->h->root.root.u.def.value;
1589 mips_elf_la25_stub_eq (const void *entry1_, const void *entry2_)
1591 const struct mips_elf_la25_stub *entry1, *entry2;
1593 entry1 = (struct mips_elf_la25_stub *) entry1_;
1594 entry2 = (struct mips_elf_la25_stub *) entry2_;
1595 return ((entry1->h->root.root.u.def.section
1596 == entry2->h->root.root.u.def.section)
1597 && (entry1->h->root.root.u.def.value
1598 == entry2->h->root.root.u.def.value));
1601 /* Called by the linker to set up the la25 stub-creation code. FN is
1602 the linker's implementation of add_stub_function. Return true on
1606 _bfd_mips_elf_init_stubs (struct bfd_link_info *info,
1607 asection *(*fn) (const char *, asection *,
1610 struct mips_elf_link_hash_table *htab;
1612 htab = mips_elf_hash_table (info);
1616 htab->add_stub_section = fn;
1617 htab->la25_stubs = htab_try_create (1, mips_elf_la25_stub_hash,
1618 mips_elf_la25_stub_eq, NULL);
1619 if (htab->la25_stubs == NULL)
1625 /* Return true if H is a locally-defined PIC function, in the sense
1626 that it or its fn_stub might need $25 to be valid on entry.
1627 Note that MIPS16 functions set up $gp using PC-relative instructions,
1628 so they themselves never need $25 to be valid. Only non-MIPS16
1629 entry points are of interest here. */
1632 mips_elf_local_pic_function_p (struct mips_elf_link_hash_entry *h)
1634 return ((h->root.root.type == bfd_link_hash_defined
1635 || h->root.root.type == bfd_link_hash_defweak)
1636 && h->root.def_regular
1637 && !bfd_is_abs_section (h->root.root.u.def.section)
1638 && (!ELF_ST_IS_MIPS16 (h->root.other)
1639 || (h->fn_stub && h->need_fn_stub))
1640 && (PIC_OBJECT_P (h->root.root.u.def.section->owner)
1641 || ELF_ST_IS_MIPS_PIC (h->root.other)));
1644 /* Set *SEC to the input section that contains the target of STUB.
1645 Return the offset of the target from the start of that section. */
1648 mips_elf_get_la25_target (struct mips_elf_la25_stub *stub,
1651 if (ELF_ST_IS_MIPS16 (stub->h->root.other))
1653 BFD_ASSERT (stub->h->need_fn_stub);
1654 *sec = stub->h->fn_stub;
1659 *sec = stub->h->root.root.u.def.section;
1660 return stub->h->root.root.u.def.value;
1664 /* STUB describes an la25 stub that we have decided to implement
1665 by inserting an LUI/ADDIU pair before the target function.
1666 Create the section and redirect the function symbol to it. */
1669 mips_elf_add_la25_intro (struct mips_elf_la25_stub *stub,
1670 struct bfd_link_info *info)
1672 struct mips_elf_link_hash_table *htab;
1674 asection *s, *input_section;
1677 htab = mips_elf_hash_table (info);
1681 /* Create a unique name for the new section. */
1682 name = bfd_malloc (11 + sizeof (".text.stub."));
1685 sprintf (name, ".text.stub.%d", (int) htab_elements (htab->la25_stubs));
1687 /* Create the section. */
1688 mips_elf_get_la25_target (stub, &input_section);
1689 s = htab->add_stub_section (name, input_section,
1690 input_section->output_section);
1694 /* Make sure that any padding goes before the stub. */
1695 align = input_section->alignment_power;
1696 if (!bfd_set_section_alignment (s->owner, s, align))
1699 s->size = (1 << align) - 8;
1701 /* Create a symbol for the stub. */
1702 mips_elf_create_stub_symbol (info, stub->h, ".pic.", s, s->size, 8);
1703 stub->stub_section = s;
1704 stub->offset = s->size;
1706 /* Allocate room for it. */
1711 /* STUB describes an la25 stub that we have decided to implement
1712 with a separate trampoline. Allocate room for it and redirect
1713 the function symbol to it. */
1716 mips_elf_add_la25_trampoline (struct mips_elf_la25_stub *stub,
1717 struct bfd_link_info *info)
1719 struct mips_elf_link_hash_table *htab;
1722 htab = mips_elf_hash_table (info);
1726 /* Create a trampoline section, if we haven't already. */
1727 s = htab->strampoline;
1730 asection *input_section = stub->h->root.root.u.def.section;
1731 s = htab->add_stub_section (".text", NULL,
1732 input_section->output_section);
1733 if (s == NULL || !bfd_set_section_alignment (s->owner, s, 4))
1735 htab->strampoline = s;
1738 /* Create a symbol for the stub. */
1739 mips_elf_create_stub_symbol (info, stub->h, ".pic.", s, s->size, 16);
1740 stub->stub_section = s;
1741 stub->offset = s->size;
1743 /* Allocate room for it. */
1748 /* H describes a symbol that needs an la25 stub. Make sure that an
1749 appropriate stub exists and point H at it. */
1752 mips_elf_add_la25_stub (struct bfd_link_info *info,
1753 struct mips_elf_link_hash_entry *h)
1755 struct mips_elf_link_hash_table *htab;
1756 struct mips_elf_la25_stub search, *stub;
1757 bfd_boolean use_trampoline_p;
1762 /* Describe the stub we want. */
1763 search.stub_section = NULL;
1767 /* See if we've already created an equivalent stub. */
1768 htab = mips_elf_hash_table (info);
1772 slot = htab_find_slot (htab->la25_stubs, &search, INSERT);
1776 stub = (struct mips_elf_la25_stub *) *slot;
1779 /* We can reuse the existing stub. */
1780 h->la25_stub = stub;
1784 /* Create a permanent copy of ENTRY and add it to the hash table. */
1785 stub = bfd_malloc (sizeof (search));
1791 /* Prefer to use LUI/ADDIU stubs if the function is at the beginning
1792 of the section and if we would need no more than 2 nops. */
1793 value = mips_elf_get_la25_target (stub, &s);
1794 use_trampoline_p = (value != 0 || s->alignment_power > 4);
1796 h->la25_stub = stub;
1797 return (use_trampoline_p
1798 ? mips_elf_add_la25_trampoline (stub, info)
1799 : mips_elf_add_la25_intro (stub, info));
1802 /* A mips_elf_link_hash_traverse callback that is called before sizing
1803 sections. DATA points to a mips_htab_traverse_info structure. */
1806 mips_elf_check_symbols (struct mips_elf_link_hash_entry *h, void *data)
1808 struct mips_htab_traverse_info *hti;
1810 hti = (struct mips_htab_traverse_info *) data;
1811 if (!hti->info->relocatable)
1812 mips_elf_check_mips16_stubs (hti->info, h);
1814 if (mips_elf_local_pic_function_p (h))
1816 /* PR 12845: If H is in a section that has been garbage
1817 collected it will have its output section set to *ABS*. */
1818 if (bfd_is_abs_section (h->root.root.u.def.section->output_section))
1821 /* H is a function that might need $25 to be valid on entry.
1822 If we're creating a non-PIC relocatable object, mark H as
1823 being PIC. If we're creating a non-relocatable object with
1824 non-PIC branches and jumps to H, make sure that H has an la25
1826 if (hti->info->relocatable)
1828 if (!PIC_OBJECT_P (hti->output_bfd))
1829 h->root.other = ELF_ST_SET_MIPS_PIC (h->root.other);
1831 else if (h->has_nonpic_branches && !mips_elf_add_la25_stub (hti->info, h))
1840 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
1841 Most mips16 instructions are 16 bits, but these instructions
1844 The format of these instructions is:
1846 +--------------+--------------------------------+
1847 | JALX | X| Imm 20:16 | Imm 25:21 |
1848 +--------------+--------------------------------+
1850 +-----------------------------------------------+
1852 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
1853 Note that the immediate value in the first word is swapped.
1855 When producing a relocatable object file, R_MIPS16_26 is
1856 handled mostly like R_MIPS_26. In particular, the addend is
1857 stored as a straight 26-bit value in a 32-bit instruction.
1858 (gas makes life simpler for itself by never adjusting a
1859 R_MIPS16_26 reloc to be against a section, so the addend is
1860 always zero). However, the 32 bit instruction is stored as 2
1861 16-bit values, rather than a single 32-bit value. In a
1862 big-endian file, the result is the same; in a little-endian
1863 file, the two 16-bit halves of the 32 bit value are swapped.
1864 This is so that a disassembler can recognize the jal
1867 When doing a final link, R_MIPS16_26 is treated as a 32 bit
1868 instruction stored as two 16-bit values. The addend A is the
1869 contents of the targ26 field. The calculation is the same as
1870 R_MIPS_26. When storing the calculated value, reorder the
1871 immediate value as shown above, and don't forget to store the
1872 value as two 16-bit values.
1874 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
1878 +--------+----------------------+
1882 +--------+----------------------+
1885 +----------+------+-------------+
1889 +----------+--------------------+
1890 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
1891 ((sub1 << 16) | sub2)).
1893 When producing a relocatable object file, the calculation is
1894 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1895 When producing a fully linked file, the calculation is
1896 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1897 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)
1899 The table below lists the other MIPS16 instruction relocations.
1900 Each one is calculated in the same way as the non-MIPS16 relocation
1901 given on the right, but using the extended MIPS16 layout of 16-bit
1904 R_MIPS16_GPREL R_MIPS_GPREL16
1905 R_MIPS16_GOT16 R_MIPS_GOT16
1906 R_MIPS16_CALL16 R_MIPS_CALL16
1907 R_MIPS16_HI16 R_MIPS_HI16
1908 R_MIPS16_LO16 R_MIPS_LO16
1910 A typical instruction will have a format like this:
1912 +--------------+--------------------------------+
1913 | EXTEND | Imm 10:5 | Imm 15:11 |
1914 +--------------+--------------------------------+
1915 | Major | rx | ry | Imm 4:0 |
1916 +--------------+--------------------------------+
1918 EXTEND is the five bit value 11110. Major is the instruction
1921 All we need to do here is shuffle the bits appropriately.
1922 As above, the two 16-bit halves must be swapped on a
1923 little-endian system. */
1925 static inline bfd_boolean
1926 mips16_reloc_p (int r_type)
1931 case R_MIPS16_GPREL:
1932 case R_MIPS16_GOT16:
1933 case R_MIPS16_CALL16:
1936 case R_MIPS16_TLS_GD:
1937 case R_MIPS16_TLS_LDM:
1938 case R_MIPS16_TLS_DTPREL_HI16:
1939 case R_MIPS16_TLS_DTPREL_LO16:
1940 case R_MIPS16_TLS_GOTTPREL:
1941 case R_MIPS16_TLS_TPREL_HI16:
1942 case R_MIPS16_TLS_TPREL_LO16:
1950 /* Check if a microMIPS reloc. */
1952 static inline bfd_boolean
1953 micromips_reloc_p (unsigned int r_type)
1955 return r_type >= R_MICROMIPS_min && r_type < R_MICROMIPS_max;
1958 /* Similar to MIPS16, the two 16-bit halves in microMIPS must be swapped
1959 on a little-endian system. This does not apply to R_MICROMIPS_PC7_S1
1960 and R_MICROMIPS_PC10_S1 relocs that apply to 16-bit instructions. */
1962 static inline bfd_boolean
1963 micromips_reloc_shuffle_p (unsigned int r_type)
1965 return (micromips_reloc_p (r_type)
1966 && r_type != R_MICROMIPS_PC7_S1
1967 && r_type != R_MICROMIPS_PC10_S1);
1970 static inline bfd_boolean
1971 got16_reloc_p (int r_type)
1973 return (r_type == R_MIPS_GOT16
1974 || r_type == R_MIPS16_GOT16
1975 || r_type == R_MICROMIPS_GOT16);
1978 static inline bfd_boolean
1979 call16_reloc_p (int r_type)
1981 return (r_type == R_MIPS_CALL16
1982 || r_type == R_MIPS16_CALL16
1983 || r_type == R_MICROMIPS_CALL16);
1986 static inline bfd_boolean
1987 got_disp_reloc_p (unsigned int r_type)
1989 return r_type == R_MIPS_GOT_DISP || r_type == R_MICROMIPS_GOT_DISP;
1992 static inline bfd_boolean
1993 got_page_reloc_p (unsigned int r_type)
1995 return r_type == R_MIPS_GOT_PAGE || r_type == R_MICROMIPS_GOT_PAGE;
1998 static inline bfd_boolean
1999 got_ofst_reloc_p (unsigned int r_type)
2001 return r_type == R_MIPS_GOT_OFST || r_type == R_MICROMIPS_GOT_OFST;
2004 static inline bfd_boolean
2005 got_hi16_reloc_p (unsigned int r_type)
2007 return r_type == R_MIPS_GOT_HI16 || r_type == R_MICROMIPS_GOT_HI16;
2010 static inline bfd_boolean
2011 got_lo16_reloc_p (unsigned int r_type)
2013 return r_type == R_MIPS_GOT_LO16 || r_type == R_MICROMIPS_GOT_LO16;
2016 static inline bfd_boolean
2017 call_hi16_reloc_p (unsigned int r_type)
2019 return r_type == R_MIPS_CALL_HI16 || r_type == R_MICROMIPS_CALL_HI16;
2022 static inline bfd_boolean
2023 call_lo16_reloc_p (unsigned int r_type)
2025 return r_type == R_MIPS_CALL_LO16 || r_type == R_MICROMIPS_CALL_LO16;
2028 static inline bfd_boolean
2029 hi16_reloc_p (int r_type)
2031 return (r_type == R_MIPS_HI16
2032 || r_type == R_MIPS16_HI16
2033 || r_type == R_MICROMIPS_HI16);
2036 static inline bfd_boolean
2037 lo16_reloc_p (int r_type)
2039 return (r_type == R_MIPS_LO16
2040 || r_type == R_MIPS16_LO16
2041 || r_type == R_MICROMIPS_LO16);
2044 static inline bfd_boolean
2045 mips16_call_reloc_p (int r_type)
2047 return r_type == R_MIPS16_26 || r_type == R_MIPS16_CALL16;
2050 static inline bfd_boolean
2051 jal_reloc_p (int r_type)
2053 return (r_type == R_MIPS_26
2054 || r_type == R_MIPS16_26
2055 || r_type == R_MICROMIPS_26_S1);
2058 static inline bfd_boolean
2059 micromips_branch_reloc_p (int r_type)
2061 return (r_type == R_MICROMIPS_26_S1
2062 || r_type == R_MICROMIPS_PC16_S1
2063 || r_type == R_MICROMIPS_PC10_S1
2064 || r_type == R_MICROMIPS_PC7_S1);
2067 static inline bfd_boolean
2068 tls_gd_reloc_p (unsigned int r_type)
2070 return (r_type == R_MIPS_TLS_GD
2071 || r_type == R_MIPS16_TLS_GD
2072 || r_type == R_MICROMIPS_TLS_GD);
2075 static inline bfd_boolean
2076 tls_ldm_reloc_p (unsigned int r_type)
2078 return (r_type == R_MIPS_TLS_LDM
2079 || r_type == R_MIPS16_TLS_LDM
2080 || r_type == R_MICROMIPS_TLS_LDM);
2083 static inline bfd_boolean
2084 tls_gottprel_reloc_p (unsigned int r_type)
2086 return (r_type == R_MIPS_TLS_GOTTPREL
2087 || r_type == R_MIPS16_TLS_GOTTPREL
2088 || r_type == R_MICROMIPS_TLS_GOTTPREL);
2092 _bfd_mips_elf_reloc_unshuffle (bfd *abfd, int r_type,
2093 bfd_boolean jal_shuffle, bfd_byte *data)
2095 bfd_vma first, second, val;
2097 if (!mips16_reloc_p (r_type) && !micromips_reloc_shuffle_p (r_type))
2100 /* Pick up the first and second halfwords of the instruction. */
2101 first = bfd_get_16 (abfd, data);
2102 second = bfd_get_16 (abfd, data + 2);
2103 if (micromips_reloc_p (r_type) || (r_type == R_MIPS16_26 && !jal_shuffle))
2104 val = first << 16 | second;
2105 else if (r_type != R_MIPS16_26)
2106 val = (((first & 0xf800) << 16) | ((second & 0xffe0) << 11)
2107 | ((first & 0x1f) << 11) | (first & 0x7e0) | (second & 0x1f));
2109 val = (((first & 0xfc00) << 16) | ((first & 0x3e0) << 11)
2110 | ((first & 0x1f) << 21) | second);
2111 bfd_put_32 (abfd, val, data);
2115 _bfd_mips_elf_reloc_shuffle (bfd *abfd, int r_type,
2116 bfd_boolean jal_shuffle, bfd_byte *data)
2118 bfd_vma first, second, val;
2120 if (!mips16_reloc_p (r_type) && !micromips_reloc_shuffle_p (r_type))
2123 val = bfd_get_32 (abfd, data);
2124 if (micromips_reloc_p (r_type) || (r_type == R_MIPS16_26 && !jal_shuffle))
2126 second = val & 0xffff;
2129 else if (r_type != R_MIPS16_26)
2131 second = ((val >> 11) & 0xffe0) | (val & 0x1f);
2132 first = ((val >> 16) & 0xf800) | ((val >> 11) & 0x1f) | (val & 0x7e0);
2136 second = val & 0xffff;
2137 first = ((val >> 16) & 0xfc00) | ((val >> 11) & 0x3e0)
2138 | ((val >> 21) & 0x1f);
2140 bfd_put_16 (abfd, second, data + 2);
2141 bfd_put_16 (abfd, first, data);
2144 bfd_reloc_status_type
2145 _bfd_mips_elf_gprel16_with_gp (bfd *abfd, asymbol *symbol,
2146 arelent *reloc_entry, asection *input_section,
2147 bfd_boolean relocatable, void *data, bfd_vma gp)
2151 bfd_reloc_status_type status;
2153 if (bfd_is_com_section (symbol->section))
2156 relocation = symbol->value;
2158 relocation += symbol->section->output_section->vma;
2159 relocation += symbol->section->output_offset;
2161 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2162 return bfd_reloc_outofrange;
2164 /* Set val to the offset into the section or symbol. */
2165 val = reloc_entry->addend;
2167 _bfd_mips_elf_sign_extend (val, 16);
2169 /* Adjust val for the final section location and GP value. If we
2170 are producing relocatable output, we don't want to do this for
2171 an external symbol. */
2173 || (symbol->flags & BSF_SECTION_SYM) != 0)
2174 val += relocation - gp;
2176 if (reloc_entry->howto->partial_inplace)
2178 status = _bfd_relocate_contents (reloc_entry->howto, abfd, val,
2180 + reloc_entry->address);
2181 if (status != bfd_reloc_ok)
2185 reloc_entry->addend = val;
2188 reloc_entry->address += input_section->output_offset;
2190 return bfd_reloc_ok;
2193 /* Used to store a REL high-part relocation such as R_MIPS_HI16 or
2194 R_MIPS_GOT16. REL is the relocation, INPUT_SECTION is the section
2195 that contains the relocation field and DATA points to the start of
2200 struct mips_hi16 *next;
2202 asection *input_section;
2206 /* FIXME: This should not be a static variable. */
2208 static struct mips_hi16 *mips_hi16_list;
2210 /* A howto special_function for REL *HI16 relocations. We can only
2211 calculate the correct value once we've seen the partnering
2212 *LO16 relocation, so just save the information for later.
2214 The ABI requires that the *LO16 immediately follow the *HI16.
2215 However, as a GNU extension, we permit an arbitrary number of
2216 *HI16s to be associated with a single *LO16. This significantly
2217 simplies the relocation handling in gcc. */
2219 bfd_reloc_status_type
2220 _bfd_mips_elf_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2221 asymbol *symbol ATTRIBUTE_UNUSED, void *data,
2222 asection *input_section, bfd *output_bfd,
2223 char **error_message ATTRIBUTE_UNUSED)
2225 struct mips_hi16 *n;
2227 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2228 return bfd_reloc_outofrange;
2230 n = bfd_malloc (sizeof *n);
2232 return bfd_reloc_outofrange;
2234 n->next = mips_hi16_list;
2236 n->input_section = input_section;
2237 n->rel = *reloc_entry;
2240 if (output_bfd != NULL)
2241 reloc_entry->address += input_section->output_offset;
2243 return bfd_reloc_ok;
2246 /* A howto special_function for REL R_MIPS*_GOT16 relocations. This is just
2247 like any other 16-bit relocation when applied to global symbols, but is
2248 treated in the same as R_MIPS_HI16 when applied to local symbols. */
2250 bfd_reloc_status_type
2251 _bfd_mips_elf_got16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2252 void *data, asection *input_section,
2253 bfd *output_bfd, char **error_message)
2255 if ((symbol->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
2256 || bfd_is_und_section (bfd_get_section (symbol))
2257 || bfd_is_com_section (bfd_get_section (symbol)))
2258 /* The relocation is against a global symbol. */
2259 return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2260 input_section, output_bfd,
2263 return _bfd_mips_elf_hi16_reloc (abfd, reloc_entry, symbol, data,
2264 input_section, output_bfd, error_message);
2267 /* A howto special_function for REL *LO16 relocations. The *LO16 itself
2268 is a straightforward 16 bit inplace relocation, but we must deal with
2269 any partnering high-part relocations as well. */
2271 bfd_reloc_status_type
2272 _bfd_mips_elf_lo16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2273 void *data, asection *input_section,
2274 bfd *output_bfd, char **error_message)
2277 bfd_byte *location = (bfd_byte *) data + reloc_entry->address;
2279 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2280 return bfd_reloc_outofrange;
2282 _bfd_mips_elf_reloc_unshuffle (abfd, reloc_entry->howto->type, FALSE,
2284 vallo = bfd_get_32 (abfd, location);
2285 _bfd_mips_elf_reloc_shuffle (abfd, reloc_entry->howto->type, FALSE,
2288 while (mips_hi16_list != NULL)
2290 bfd_reloc_status_type ret;
2291 struct mips_hi16 *hi;
2293 hi = mips_hi16_list;
2295 /* R_MIPS*_GOT16 relocations are something of a special case. We
2296 want to install the addend in the same way as for a R_MIPS*_HI16
2297 relocation (with a rightshift of 16). However, since GOT16
2298 relocations can also be used with global symbols, their howto
2299 has a rightshift of 0. */
2300 if (hi->rel.howto->type == R_MIPS_GOT16)
2301 hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MIPS_HI16, FALSE);
2302 else if (hi->rel.howto->type == R_MIPS16_GOT16)
2303 hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MIPS16_HI16, FALSE);
2304 else if (hi->rel.howto->type == R_MICROMIPS_GOT16)
2305 hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MICROMIPS_HI16, FALSE);
2307 /* VALLO is a signed 16-bit number. Bias it by 0x8000 so that any
2308 carry or borrow will induce a change of +1 or -1 in the high part. */
2309 hi->rel.addend += (vallo + 0x8000) & 0xffff;
2311 ret = _bfd_mips_elf_generic_reloc (abfd, &hi->rel, symbol, hi->data,
2312 hi->input_section, output_bfd,
2314 if (ret != bfd_reloc_ok)
2317 mips_hi16_list = hi->next;
2321 return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2322 input_section, output_bfd,
2326 /* A generic howto special_function. This calculates and installs the
2327 relocation itself, thus avoiding the oft-discussed problems in
2328 bfd_perform_relocation and bfd_install_relocation. */
2330 bfd_reloc_status_type
2331 _bfd_mips_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2332 asymbol *symbol, void *data ATTRIBUTE_UNUSED,
2333 asection *input_section, bfd *output_bfd,
2334 char **error_message ATTRIBUTE_UNUSED)
2337 bfd_reloc_status_type status;
2338 bfd_boolean relocatable;
2340 relocatable = (output_bfd != NULL);
2342 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2343 return bfd_reloc_outofrange;
2345 /* Build up the field adjustment in VAL. */
2347 if (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0)
2349 /* Either we're calculating the final field value or we have a
2350 relocation against a section symbol. Add in the section's
2351 offset or address. */
2352 val += symbol->section->output_section->vma;
2353 val += symbol->section->output_offset;
2358 /* We're calculating the final field value. Add in the symbol's value
2359 and, if pc-relative, subtract the address of the field itself. */
2360 val += symbol->value;
2361 if (reloc_entry->howto->pc_relative)
2363 val -= input_section->output_section->vma;
2364 val -= input_section->output_offset;
2365 val -= reloc_entry->address;
2369 /* VAL is now the final adjustment. If we're keeping this relocation
2370 in the output file, and if the relocation uses a separate addend,
2371 we just need to add VAL to that addend. Otherwise we need to add
2372 VAL to the relocation field itself. */
2373 if (relocatable && !reloc_entry->howto->partial_inplace)
2374 reloc_entry->addend += val;
2377 bfd_byte *location = (bfd_byte *) data + reloc_entry->address;
2379 /* Add in the separate addend, if any. */
2380 val += reloc_entry->addend;
2382 /* Add VAL to the relocation field. */
2383 _bfd_mips_elf_reloc_unshuffle (abfd, reloc_entry->howto->type, FALSE,
2385 status = _bfd_relocate_contents (reloc_entry->howto, abfd, val,
2387 _bfd_mips_elf_reloc_shuffle (abfd, reloc_entry->howto->type, FALSE,
2390 if (status != bfd_reloc_ok)
2395 reloc_entry->address += input_section->output_offset;
2397 return bfd_reloc_ok;
2400 /* Swap an entry in a .gptab section. Note that these routines rely
2401 on the equivalence of the two elements of the union. */
2404 bfd_mips_elf32_swap_gptab_in (bfd *abfd, const Elf32_External_gptab *ex,
2407 in->gt_entry.gt_g_value = H_GET_32 (abfd, ex->gt_entry.gt_g_value);
2408 in->gt_entry.gt_bytes = H_GET_32 (abfd, ex->gt_entry.gt_bytes);
2412 bfd_mips_elf32_swap_gptab_out (bfd *abfd, const Elf32_gptab *in,
2413 Elf32_External_gptab *ex)
2415 H_PUT_32 (abfd, in->gt_entry.gt_g_value, ex->gt_entry.gt_g_value);
2416 H_PUT_32 (abfd, in->gt_entry.gt_bytes, ex->gt_entry.gt_bytes);
2420 bfd_elf32_swap_compact_rel_out (bfd *abfd, const Elf32_compact_rel *in,
2421 Elf32_External_compact_rel *ex)
2423 H_PUT_32 (abfd, in->id1, ex->id1);
2424 H_PUT_32 (abfd, in->num, ex->num);
2425 H_PUT_32 (abfd, in->id2, ex->id2);
2426 H_PUT_32 (abfd, in->offset, ex->offset);
2427 H_PUT_32 (abfd, in->reserved0, ex->reserved0);
2428 H_PUT_32 (abfd, in->reserved1, ex->reserved1);
2432 bfd_elf32_swap_crinfo_out (bfd *abfd, const Elf32_crinfo *in,
2433 Elf32_External_crinfo *ex)
2437 l = (((in->ctype & CRINFO_CTYPE) << CRINFO_CTYPE_SH)
2438 | ((in->rtype & CRINFO_RTYPE) << CRINFO_RTYPE_SH)
2439 | ((in->dist2to & CRINFO_DIST2TO) << CRINFO_DIST2TO_SH)
2440 | ((in->relvaddr & CRINFO_RELVADDR) << CRINFO_RELVADDR_SH));
2441 H_PUT_32 (abfd, l, ex->info);
2442 H_PUT_32 (abfd, in->konst, ex->konst);
2443 H_PUT_32 (abfd, in->vaddr, ex->vaddr);
2446 /* A .reginfo section holds a single Elf32_RegInfo structure. These
2447 routines swap this structure in and out. They are used outside of
2448 BFD, so they are globally visible. */
2451 bfd_mips_elf32_swap_reginfo_in (bfd *abfd, const Elf32_External_RegInfo *ex,
2454 in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask);
2455 in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]);
2456 in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]);
2457 in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]);
2458 in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]);
2459 in->ri_gp_value = H_GET_32 (abfd, ex->ri_gp_value);
2463 bfd_mips_elf32_swap_reginfo_out (bfd *abfd, const Elf32_RegInfo *in,
2464 Elf32_External_RegInfo *ex)
2466 H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask);
2467 H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]);
2468 H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]);
2469 H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]);
2470 H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]);
2471 H_PUT_32 (abfd, in->ri_gp_value, ex->ri_gp_value);
2474 /* In the 64 bit ABI, the .MIPS.options section holds register
2475 information in an Elf64_Reginfo structure. These routines swap
2476 them in and out. They are globally visible because they are used
2477 outside of BFD. These routines are here so that gas can call them
2478 without worrying about whether the 64 bit ABI has been included. */
2481 bfd_mips_elf64_swap_reginfo_in (bfd *abfd, const Elf64_External_RegInfo *ex,
2482 Elf64_Internal_RegInfo *in)
2484 in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask);
2485 in->ri_pad = H_GET_32 (abfd, ex->ri_pad);
2486 in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]);
2487 in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]);
2488 in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]);
2489 in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]);
2490 in->ri_gp_value = H_GET_64 (abfd, ex->ri_gp_value);
2494 bfd_mips_elf64_swap_reginfo_out (bfd *abfd, const Elf64_Internal_RegInfo *in,
2495 Elf64_External_RegInfo *ex)
2497 H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask);
2498 H_PUT_32 (abfd, in->ri_pad, ex->ri_pad);
2499 H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]);
2500 H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]);
2501 H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]);
2502 H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]);
2503 H_PUT_64 (abfd, in->ri_gp_value, ex->ri_gp_value);
2506 /* Swap in an options header. */
2509 bfd_mips_elf_swap_options_in (bfd *abfd, const Elf_External_Options *ex,
2510 Elf_Internal_Options *in)
2512 in->kind = H_GET_8 (abfd, ex->kind);
2513 in->size = H_GET_8 (abfd, ex->size);
2514 in->section = H_GET_16 (abfd, ex->section);
2515 in->info = H_GET_32 (abfd, ex->info);
2518 /* Swap out an options header. */
2521 bfd_mips_elf_swap_options_out (bfd *abfd, const Elf_Internal_Options *in,
2522 Elf_External_Options *ex)
2524 H_PUT_8 (abfd, in->kind, ex->kind);
2525 H_PUT_8 (abfd, in->size, ex->size);
2526 H_PUT_16 (abfd, in->section, ex->section);
2527 H_PUT_32 (abfd, in->info, ex->info);
2530 /* This function is called via qsort() to sort the dynamic relocation
2531 entries by increasing r_symndx value. */
2534 sort_dynamic_relocs (const void *arg1, const void *arg2)
2536 Elf_Internal_Rela int_reloc1;
2537 Elf_Internal_Rela int_reloc2;
2540 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg1, &int_reloc1);
2541 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg2, &int_reloc2);
2543 diff = ELF32_R_SYM (int_reloc1.r_info) - ELF32_R_SYM (int_reloc2.r_info);
2547 if (int_reloc1.r_offset < int_reloc2.r_offset)
2549 if (int_reloc1.r_offset > int_reloc2.r_offset)
2554 /* Like sort_dynamic_relocs, but used for elf64 relocations. */
2557 sort_dynamic_relocs_64 (const void *arg1 ATTRIBUTE_UNUSED,
2558 const void *arg2 ATTRIBUTE_UNUSED)
2561 Elf_Internal_Rela int_reloc1[3];
2562 Elf_Internal_Rela int_reloc2[3];
2564 (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in)
2565 (reldyn_sorting_bfd, arg1, int_reloc1);
2566 (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in)
2567 (reldyn_sorting_bfd, arg2, int_reloc2);
2569 if (ELF64_R_SYM (int_reloc1[0].r_info) < ELF64_R_SYM (int_reloc2[0].r_info))
2571 if (ELF64_R_SYM (int_reloc1[0].r_info) > ELF64_R_SYM (int_reloc2[0].r_info))
2574 if (int_reloc1[0].r_offset < int_reloc2[0].r_offset)
2576 if (int_reloc1[0].r_offset > int_reloc2[0].r_offset)
2585 /* This routine is used to write out ECOFF debugging external symbol
2586 information. It is called via mips_elf_link_hash_traverse. The
2587 ECOFF external symbol information must match the ELF external
2588 symbol information. Unfortunately, at this point we don't know
2589 whether a symbol is required by reloc information, so the two
2590 tables may wind up being different. We must sort out the external
2591 symbol information before we can set the final size of the .mdebug
2592 section, and we must set the size of the .mdebug section before we
2593 can relocate any sections, and we can't know which symbols are
2594 required by relocation until we relocate the sections.
2595 Fortunately, it is relatively unlikely that any symbol will be
2596 stripped but required by a reloc. In particular, it can not happen
2597 when generating a final executable. */
2600 mips_elf_output_extsym (struct mips_elf_link_hash_entry *h, void *data)
2602 struct extsym_info *einfo = data;
2604 asection *sec, *output_section;
2606 if (h->root.indx == -2)
2608 else if ((h->root.def_dynamic
2609 || h->root.ref_dynamic
2610 || h->root.type == bfd_link_hash_new)
2611 && !h->root.def_regular
2612 && !h->root.ref_regular)
2614 else if (einfo->info->strip == strip_all
2615 || (einfo->info->strip == strip_some
2616 && bfd_hash_lookup (einfo->info->keep_hash,
2617 h->root.root.root.string,
2618 FALSE, FALSE) == NULL))
2626 if (h->esym.ifd == -2)
2629 h->esym.cobol_main = 0;
2630 h->esym.weakext = 0;
2631 h->esym.reserved = 0;
2632 h->esym.ifd = ifdNil;
2633 h->esym.asym.value = 0;
2634 h->esym.asym.st = stGlobal;
2636 if (h->root.root.type == bfd_link_hash_undefined
2637 || h->root.root.type == bfd_link_hash_undefweak)
2641 /* Use undefined class. Also, set class and type for some
2643 name = h->root.root.root.string;
2644 if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
2645 || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
2647 h->esym.asym.sc = scData;
2648 h->esym.asym.st = stLabel;
2649 h->esym.asym.value = 0;
2651 else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
2653 h->esym.asym.sc = scAbs;
2654 h->esym.asym.st = stLabel;
2655 h->esym.asym.value =
2656 mips_elf_hash_table (einfo->info)->procedure_count;
2658 else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (einfo->abfd))
2660 h->esym.asym.sc = scAbs;
2661 h->esym.asym.st = stLabel;
2662 h->esym.asym.value = elf_gp (einfo->abfd);
2665 h->esym.asym.sc = scUndefined;
2667 else if (h->root.root.type != bfd_link_hash_defined
2668 && h->root.root.type != bfd_link_hash_defweak)
2669 h->esym.asym.sc = scAbs;
2674 sec = h->root.root.u.def.section;
2675 output_section = sec->output_section;
2677 /* When making a shared library and symbol h is the one from
2678 the another shared library, OUTPUT_SECTION may be null. */
2679 if (output_section == NULL)
2680 h->esym.asym.sc = scUndefined;
2683 name = bfd_section_name (output_section->owner, output_section);
2685 if (strcmp (name, ".text") == 0)
2686 h->esym.asym.sc = scText;
2687 else if (strcmp (name, ".data") == 0)
2688 h->esym.asym.sc = scData;
2689 else if (strcmp (name, ".sdata") == 0)
2690 h->esym.asym.sc = scSData;
2691 else if (strcmp (name, ".rodata") == 0
2692 || strcmp (name, ".rdata") == 0)
2693 h->esym.asym.sc = scRData;
2694 else if (strcmp (name, ".bss") == 0)
2695 h->esym.asym.sc = scBss;
2696 else if (strcmp (name, ".sbss") == 0)
2697 h->esym.asym.sc = scSBss;
2698 else if (strcmp (name, ".init") == 0)
2699 h->esym.asym.sc = scInit;
2700 else if (strcmp (name, ".fini") == 0)
2701 h->esym.asym.sc = scFini;
2703 h->esym.asym.sc = scAbs;
2707 h->esym.asym.reserved = 0;
2708 h->esym.asym.index = indexNil;
2711 if (h->root.root.type == bfd_link_hash_common)
2712 h->esym.asym.value = h->root.root.u.c.size;
2713 else if (h->root.root.type == bfd_link_hash_defined
2714 || h->root.root.type == bfd_link_hash_defweak)
2716 if (h->esym.asym.sc == scCommon)
2717 h->esym.asym.sc = scBss;
2718 else if (h->esym.asym.sc == scSCommon)
2719 h->esym.asym.sc = scSBss;
2721 sec = h->root.root.u.def.section;
2722 output_section = sec->output_section;
2723 if (output_section != NULL)
2724 h->esym.asym.value = (h->root.root.u.def.value
2725 + sec->output_offset
2726 + output_section->vma);
2728 h->esym.asym.value = 0;
2732 struct mips_elf_link_hash_entry *hd = h;
2734 while (hd->root.root.type == bfd_link_hash_indirect)
2735 hd = (struct mips_elf_link_hash_entry *)h->root.root.u.i.link;
2737 if (hd->needs_lazy_stub)
2739 /* Set type and value for a symbol with a function stub. */
2740 h->esym.asym.st = stProc;
2741 sec = hd->root.root.u.def.section;
2743 h->esym.asym.value = 0;
2746 output_section = sec->output_section;
2747 if (output_section != NULL)
2748 h->esym.asym.value = (hd->root.plt.offset
2749 + sec->output_offset
2750 + output_section->vma);
2752 h->esym.asym.value = 0;
2757 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
2758 h->root.root.root.string,
2761 einfo->failed = TRUE;
2768 /* A comparison routine used to sort .gptab entries. */
2771 gptab_compare (const void *p1, const void *p2)
2773 const Elf32_gptab *a1 = p1;
2774 const Elf32_gptab *a2 = p2;
2776 return a1->gt_entry.gt_g_value - a2->gt_entry.gt_g_value;
2779 /* Functions to manage the got entry hash table. */
2781 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
2784 static INLINE hashval_t
2785 mips_elf_hash_bfd_vma (bfd_vma addr)
2788 return addr + (addr >> 32);
2794 /* got_entries only match if they're identical, except for gotidx, so
2795 use all fields to compute the hash, and compare the appropriate
2799 mips_elf_got_entry_hash (const void *entry_)
2801 const struct mips_got_entry *entry = (struct mips_got_entry *)entry_;
2803 return entry->symndx
2804 + ((entry->tls_type & GOT_TLS_LDM) << 17)
2805 + (! entry->abfd ? mips_elf_hash_bfd_vma (entry->d.address)
2807 + (entry->symndx >= 0 ? mips_elf_hash_bfd_vma (entry->d.addend)
2808 : entry->d.h->root.root.root.hash));
2812 mips_elf_got_entry_eq (const void *entry1, const void *entry2)
2814 const struct mips_got_entry *e1 = (struct mips_got_entry *)entry1;
2815 const struct mips_got_entry *e2 = (struct mips_got_entry *)entry2;
2817 /* An LDM entry can only match another LDM entry. */
2818 if ((e1->tls_type ^ e2->tls_type) & GOT_TLS_LDM)
2821 return e1->abfd == e2->abfd && e1->symndx == e2->symndx
2822 && (! e1->abfd ? e1->d.address == e2->d.address
2823 : e1->symndx >= 0 ? e1->d.addend == e2->d.addend
2824 : e1->d.h == e2->d.h);
2827 /* multi_got_entries are still a match in the case of global objects,
2828 even if the input bfd in which they're referenced differs, so the
2829 hash computation and compare functions are adjusted
2833 mips_elf_multi_got_entry_hash (const void *entry_)
2835 const struct mips_got_entry *entry = (struct mips_got_entry *)entry_;
2837 return entry->symndx
2839 ? mips_elf_hash_bfd_vma (entry->d.address)
2840 : entry->symndx >= 0
2841 ? ((entry->tls_type & GOT_TLS_LDM)
2842 ? (GOT_TLS_LDM << 17)
2844 + mips_elf_hash_bfd_vma (entry->d.addend)))
2845 : entry->d.h->root.root.root.hash);
2849 mips_elf_multi_got_entry_eq (const void *entry1, const void *entry2)
2851 const struct mips_got_entry *e1 = (struct mips_got_entry *)entry1;
2852 const struct mips_got_entry *e2 = (struct mips_got_entry *)entry2;
2854 /* Any two LDM entries match. */
2855 if (e1->tls_type & e2->tls_type & GOT_TLS_LDM)
2858 /* Nothing else matches an LDM entry. */
2859 if ((e1->tls_type ^ e2->tls_type) & GOT_TLS_LDM)
2862 return e1->symndx == e2->symndx
2863 && (e1->symndx >= 0 ? e1->abfd == e2->abfd && e1->d.addend == e2->d.addend
2864 : e1->abfd == NULL || e2->abfd == NULL
2865 ? e1->abfd == e2->abfd && e1->d.address == e2->d.address
2866 : e1->d.h == e2->d.h);
2870 mips_got_page_entry_hash (const void *entry_)
2872 const struct mips_got_page_entry *entry;
2874 entry = (const struct mips_got_page_entry *) entry_;
2875 return entry->abfd->id + entry->symndx;
2879 mips_got_page_entry_eq (const void *entry1_, const void *entry2_)
2881 const struct mips_got_page_entry *entry1, *entry2;
2883 entry1 = (const struct mips_got_page_entry *) entry1_;
2884 entry2 = (const struct mips_got_page_entry *) entry2_;
2885 return entry1->abfd == entry2->abfd && entry1->symndx == entry2->symndx;
2888 /* Create and return a new mips_got_info structure. MASTER_GOT_P
2889 is true if this is the master GOT rather than a multigot. */
2891 static struct mips_got_info *
2892 mips_elf_create_got_info (bfd *abfd, bfd_boolean master_got_p)
2894 struct mips_got_info *g;
2896 g = bfd_zalloc (abfd, sizeof (struct mips_got_info));
2900 g->tls_ldm_offset = MINUS_ONE;
2902 g->got_entries = htab_try_create (1, mips_elf_got_entry_hash,
2903 mips_elf_got_entry_eq, NULL);
2905 g->got_entries = htab_try_create (1, mips_elf_multi_got_entry_hash,
2906 mips_elf_multi_got_entry_eq, NULL);
2907 if (g->got_entries == NULL)
2910 g->got_page_entries = htab_try_create (1, mips_got_page_entry_hash,
2911 mips_got_page_entry_eq, NULL);
2912 if (g->got_page_entries == NULL)
2918 /* Return the dynamic relocation section. If it doesn't exist, try to
2919 create a new it if CREATE_P, otherwise return NULL. Also return NULL
2920 if creation fails. */
2923 mips_elf_rel_dyn_section (struct bfd_link_info *info, bfd_boolean create_p)
2929 dname = MIPS_ELF_REL_DYN_NAME (info);
2930 dynobj = elf_hash_table (info)->dynobj;
2931 sreloc = bfd_get_linker_section (dynobj, dname);
2932 if (sreloc == NULL && create_p)
2934 sreloc = bfd_make_section_anyway_with_flags (dynobj, dname,
2939 | SEC_LINKER_CREATED
2942 || ! bfd_set_section_alignment (dynobj, sreloc,
2943 MIPS_ELF_LOG_FILE_ALIGN (dynobj)))
2949 /* Count the number of relocations needed for a TLS GOT entry, with
2950 access types from TLS_TYPE, and symbol H (or a local symbol if H
2954 mips_tls_got_relocs (struct bfd_link_info *info, unsigned char tls_type,
2955 struct elf_link_hash_entry *h)
2959 bfd_boolean need_relocs = FALSE;
2960 bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created;
2962 if (h && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2963 && (!info->shared || !SYMBOL_REFERENCES_LOCAL (info, h)))
2966 if ((info->shared || indx != 0)
2968 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2969 || h->root.type != bfd_link_hash_undefweak))
2975 if (tls_type & GOT_TLS_GD)
2982 if (tls_type & GOT_TLS_IE)
2985 if ((tls_type & GOT_TLS_LDM) && info->shared)
2991 /* Count the number of TLS relocations required for the GOT entry in
2992 ARG1, if it describes a local symbol. */
2995 mips_elf_count_local_tls_relocs (void **arg1, void *arg2)
2997 struct mips_got_entry *entry = * (struct mips_got_entry **) arg1;
2998 struct mips_elf_count_tls_arg *arg = arg2;
3000 if (entry->abfd != NULL && entry->symndx != -1)
3001 arg->needed += mips_tls_got_relocs (arg->info, entry->tls_type, NULL);
3006 /* Count the number of TLS GOT entries required for the global (or
3007 forced-local) symbol in ARG1. */
3010 mips_elf_count_global_tls_entries (void *arg1, void *arg2)
3012 struct mips_elf_link_hash_entry *hm
3013 = (struct mips_elf_link_hash_entry *) arg1;
3014 struct mips_elf_count_tls_arg *arg = arg2;
3016 if (hm->root.root.type == bfd_link_hash_indirect
3017 || hm->root.root.type == bfd_link_hash_warning)
3020 if (hm->tls_type & GOT_TLS_GD)
3022 if (hm->tls_type & GOT_TLS_IE)
3028 /* Count the number of TLS relocations required for the global (or
3029 forced-local) symbol in ARG1. */
3032 mips_elf_count_global_tls_relocs (void *arg1, void *arg2)
3034 struct mips_elf_link_hash_entry *hm
3035 = (struct mips_elf_link_hash_entry *) arg1;
3036 struct mips_elf_count_tls_arg *arg = arg2;
3038 if (hm->root.root.type == bfd_link_hash_indirect
3039 || hm->root.root.type == bfd_link_hash_warning)
3042 arg->needed += mips_tls_got_relocs (arg->info, hm->tls_type, &hm->root);
3047 /* Output a simple dynamic relocation into SRELOC. */
3050 mips_elf_output_dynamic_relocation (bfd *output_bfd,
3052 unsigned long reloc_index,
3057 Elf_Internal_Rela rel[3];
3059 memset (rel, 0, sizeof (rel));
3061 rel[0].r_info = ELF_R_INFO (output_bfd, indx, r_type);
3062 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
3064 if (ABI_64_P (output_bfd))
3066 (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
3067 (output_bfd, &rel[0],
3069 + reloc_index * sizeof (Elf64_Mips_External_Rel)));
3072 bfd_elf32_swap_reloc_out
3073 (output_bfd, &rel[0],
3075 + reloc_index * sizeof (Elf32_External_Rel)));
3078 /* Initialize a set of TLS GOT entries for one symbol. */
3081 mips_elf_initialize_tls_slots (bfd *abfd, bfd_vma got_offset,
3082 unsigned char *tls_type_p,
3083 struct bfd_link_info *info,
3084 struct mips_elf_link_hash_entry *h,
3087 struct mips_elf_link_hash_table *htab;
3089 asection *sreloc, *sgot;
3090 bfd_vma offset, offset2;
3091 bfd_boolean need_relocs = FALSE;
3093 htab = mips_elf_hash_table (info);
3102 bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created;
3104 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, &h->root)
3105 && (!info->shared || !SYMBOL_REFERENCES_LOCAL (info, &h->root)))
3106 indx = h->root.dynindx;
3109 if (*tls_type_p & GOT_TLS_DONE)
3112 if ((info->shared || indx != 0)
3114 || ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT
3115 || h->root.type != bfd_link_hash_undefweak))
3118 /* MINUS_ONE means the symbol is not defined in this object. It may not
3119 be defined at all; assume that the value doesn't matter in that
3120 case. Otherwise complain if we would use the value. */
3121 BFD_ASSERT (value != MINUS_ONE || (indx != 0 && need_relocs)
3122 || h->root.root.type == bfd_link_hash_undefweak);
3124 /* Emit necessary relocations. */
3125 sreloc = mips_elf_rel_dyn_section (info, FALSE);
3127 /* General Dynamic. */
3128 if (*tls_type_p & GOT_TLS_GD)
3130 offset = got_offset;
3131 offset2 = offset + MIPS_ELF_GOT_SIZE (abfd);
3135 mips_elf_output_dynamic_relocation
3136 (abfd, sreloc, sreloc->reloc_count++, indx,
3137 ABI_64_P (abfd) ? R_MIPS_TLS_DTPMOD64 : R_MIPS_TLS_DTPMOD32,
3138 sgot->output_offset + sgot->output_section->vma + offset);
3141 mips_elf_output_dynamic_relocation
3142 (abfd, sreloc, sreloc->reloc_count++, indx,
3143 ABI_64_P (abfd) ? R_MIPS_TLS_DTPREL64 : R_MIPS_TLS_DTPREL32,
3144 sgot->output_offset + sgot->output_section->vma + offset2);
3146 MIPS_ELF_PUT_WORD (abfd, value - dtprel_base (info),
3147 sgot->contents + offset2);
3151 MIPS_ELF_PUT_WORD (abfd, 1,
3152 sgot->contents + offset);
3153 MIPS_ELF_PUT_WORD (abfd, value - dtprel_base (info),
3154 sgot->contents + offset2);
3157 got_offset += 2 * MIPS_ELF_GOT_SIZE (abfd);
3160 /* Initial Exec model. */
3161 if (*tls_type_p & GOT_TLS_IE)
3163 offset = got_offset;
3168 MIPS_ELF_PUT_WORD (abfd, value - elf_hash_table (info)->tls_sec->vma,
3169 sgot->contents + offset);
3171 MIPS_ELF_PUT_WORD (abfd, 0,
3172 sgot->contents + offset);
3174 mips_elf_output_dynamic_relocation
3175 (abfd, sreloc, sreloc->reloc_count++, indx,
3176 ABI_64_P (abfd) ? R_MIPS_TLS_TPREL64 : R_MIPS_TLS_TPREL32,
3177 sgot->output_offset + sgot->output_section->vma + offset);
3180 MIPS_ELF_PUT_WORD (abfd, value - tprel_base (info),
3181 sgot->contents + offset);
3184 if (*tls_type_p & GOT_TLS_LDM)
3186 /* The initial offset is zero, and the LD offsets will include the
3187 bias by DTP_OFFSET. */
3188 MIPS_ELF_PUT_WORD (abfd, 0,
3189 sgot->contents + got_offset
3190 + MIPS_ELF_GOT_SIZE (abfd));
3193 MIPS_ELF_PUT_WORD (abfd, 1,
3194 sgot->contents + got_offset);
3196 mips_elf_output_dynamic_relocation
3197 (abfd, sreloc, sreloc->reloc_count++, indx,
3198 ABI_64_P (abfd) ? R_MIPS_TLS_DTPMOD64 : R_MIPS_TLS_DTPMOD32,
3199 sgot->output_offset + sgot->output_section->vma + got_offset);
3202 *tls_type_p |= GOT_TLS_DONE;
3205 /* Return the GOT index to use for a relocation of type R_TYPE against
3206 a symbol accessed using TLS_TYPE models. The GOT entries for this
3207 symbol in this GOT start at GOT_INDEX. This function initializes the
3208 GOT entries and corresponding relocations. */
3211 mips_tls_got_index (bfd *abfd, bfd_vma got_index, unsigned char *tls_type,
3212 int r_type, struct bfd_link_info *info,
3213 struct mips_elf_link_hash_entry *h, bfd_vma symbol)
3215 BFD_ASSERT (tls_gottprel_reloc_p (r_type)
3216 || tls_gd_reloc_p (r_type)
3217 || tls_ldm_reloc_p (r_type));
3219 mips_elf_initialize_tls_slots (abfd, got_index, tls_type, info, h, symbol);
3221 if (tls_gottprel_reloc_p (r_type))
3223 BFD_ASSERT (*tls_type & GOT_TLS_IE);
3224 if (*tls_type & GOT_TLS_GD)
3225 return got_index + 2 * MIPS_ELF_GOT_SIZE (abfd);
3230 if (tls_gd_reloc_p (r_type))
3232 BFD_ASSERT (*tls_type & GOT_TLS_GD);
3236 if (tls_ldm_reloc_p (r_type))
3238 BFD_ASSERT (*tls_type & GOT_TLS_LDM);
3245 /* Return the offset from _GLOBAL_OFFSET_TABLE_ of the .got.plt entry
3246 for global symbol H. .got.plt comes before the GOT, so the offset
3247 will be negative. */
3250 mips_elf_gotplt_index (struct bfd_link_info *info,
3251 struct elf_link_hash_entry *h)
3253 bfd_vma plt_index, got_address, got_value;
3254 struct mips_elf_link_hash_table *htab;
3256 htab = mips_elf_hash_table (info);
3257 BFD_ASSERT (htab != NULL);
3259 BFD_ASSERT (h->plt.offset != (bfd_vma) -1);
3261 /* This function only works for VxWorks, because a non-VxWorks .got.plt
3262 section starts with reserved entries. */
3263 BFD_ASSERT (htab->is_vxworks);
3265 /* Calculate the index of the symbol's PLT entry. */
3266 plt_index = (h->plt.offset - htab->plt_header_size) / htab->plt_entry_size;
3268 /* Calculate the address of the associated .got.plt entry. */
3269 got_address = (htab->sgotplt->output_section->vma
3270 + htab->sgotplt->output_offset
3273 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */
3274 got_value = (htab->root.hgot->root.u.def.section->output_section->vma
3275 + htab->root.hgot->root.u.def.section->output_offset
3276 + htab->root.hgot->root.u.def.value);
3278 return got_address - got_value;
3281 /* Return the GOT offset for address VALUE. If there is not yet a GOT
3282 entry for this value, create one. If R_SYMNDX refers to a TLS symbol,
3283 create a TLS GOT entry instead. Return -1 if no satisfactory GOT
3284 offset can be found. */
3287 mips_elf_local_got_index (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
3288 bfd_vma value, unsigned long r_symndx,
3289 struct mips_elf_link_hash_entry *h, int r_type)
3291 struct mips_elf_link_hash_table *htab;
3292 struct mips_got_entry *entry;
3294 htab = mips_elf_hash_table (info);
3295 BFD_ASSERT (htab != NULL);
3297 entry = mips_elf_create_local_got_entry (abfd, info, ibfd, value,
3298 r_symndx, h, r_type);
3302 if (TLS_RELOC_P (r_type))
3304 if (entry->symndx == -1 && htab->got_info->next == NULL)
3305 /* A type (3) entry in the single-GOT case. We use the symbol's
3306 hash table entry to track the index. */
3307 return mips_tls_got_index (abfd, h->tls_got_offset, &h->tls_type,
3308 r_type, info, h, value);
3310 return mips_tls_got_index (abfd, entry->gotidx, &entry->tls_type,
3311 r_type, info, h, value);
3314 return entry->gotidx;
3317 /* Returns the GOT index for the global symbol indicated by H. */
3320 mips_elf_global_got_index (bfd *abfd, bfd *ibfd, struct elf_link_hash_entry *h,
3321 int r_type, struct bfd_link_info *info)
3323 struct mips_elf_link_hash_table *htab;
3325 struct mips_got_info *g, *gg;
3326 long global_got_dynindx = 0;
3328 htab = mips_elf_hash_table (info);
3329 BFD_ASSERT (htab != NULL);
3331 gg = g = htab->got_info;
3332 if (g->bfd2got && ibfd)
3334 struct mips_got_entry e, *p;
3336 BFD_ASSERT (h->dynindx >= 0);
3338 g = mips_elf_got_for_ibfd (g, ibfd);
3339 if (g->next != gg || TLS_RELOC_P (r_type))
3343 e.d.h = (struct mips_elf_link_hash_entry *)h;
3346 p = htab_find (g->got_entries, &e);
3348 BFD_ASSERT (p->gotidx > 0);
3350 if (TLS_RELOC_P (r_type))
3352 bfd_vma value = MINUS_ONE;
3353 if ((h->root.type == bfd_link_hash_defined
3354 || h->root.type == bfd_link_hash_defweak)
3355 && h->root.u.def.section->output_section)
3356 value = (h->root.u.def.value
3357 + h->root.u.def.section->output_offset
3358 + h->root.u.def.section->output_section->vma);
3360 return mips_tls_got_index (abfd, p->gotidx, &p->tls_type, r_type,
3361 info, e.d.h, value);
3368 if (htab->global_gotsym != NULL)
3369 global_got_dynindx = htab->global_gotsym->dynindx;
3371 if (TLS_RELOC_P (r_type))
3373 struct mips_elf_link_hash_entry *hm
3374 = (struct mips_elf_link_hash_entry *) h;
3375 bfd_vma value = MINUS_ONE;
3377 if ((h->root.type == bfd_link_hash_defined
3378 || h->root.type == bfd_link_hash_defweak)
3379 && h->root.u.def.section->output_section)
3380 value = (h->root.u.def.value
3381 + h->root.u.def.section->output_offset
3382 + h->root.u.def.section->output_section->vma);
3384 got_index = mips_tls_got_index (abfd, hm->tls_got_offset, &hm->tls_type,
3385 r_type, info, hm, value);
3389 /* Once we determine the global GOT entry with the lowest dynamic
3390 symbol table index, we must put all dynamic symbols with greater
3391 indices into the GOT. That makes it easy to calculate the GOT
3393 BFD_ASSERT (h->dynindx >= global_got_dynindx);
3394 got_index = ((h->dynindx - global_got_dynindx + g->local_gotno)
3395 * MIPS_ELF_GOT_SIZE (abfd));
3397 BFD_ASSERT (got_index < htab->sgot->size);
3402 /* Find a GOT page entry that points to within 32KB of VALUE. These
3403 entries are supposed to be placed at small offsets in the GOT, i.e.,
3404 within 32KB of GP. Return the index of the GOT entry, or -1 if no
3405 entry could be created. If OFFSETP is nonnull, use it to return the
3406 offset of the GOT entry from VALUE. */
3409 mips_elf_got_page (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
3410 bfd_vma value, bfd_vma *offsetp)
3412 bfd_vma page, got_index;
3413 struct mips_got_entry *entry;
3415 page = (value + 0x8000) & ~(bfd_vma) 0xffff;
3416 entry = mips_elf_create_local_got_entry (abfd, info, ibfd, page, 0,
3417 NULL, R_MIPS_GOT_PAGE);
3422 got_index = entry->gotidx;
3425 *offsetp = value - entry->d.address;
3430 /* Find a local GOT entry for an R_MIPS*_GOT16 relocation against VALUE.
3431 EXTERNAL is true if the relocation was originally against a global
3432 symbol that binds locally. */
3435 mips_elf_got16_entry (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
3436 bfd_vma value, bfd_boolean external)
3438 struct mips_got_entry *entry;
3440 /* GOT16 relocations against local symbols are followed by a LO16
3441 relocation; those against global symbols are not. Thus if the
3442 symbol was originally local, the GOT16 relocation should load the
3443 equivalent of %hi(VALUE), otherwise it should load VALUE itself. */
3445 value = mips_elf_high (value) << 16;
3447 /* It doesn't matter whether the original relocation was R_MIPS_GOT16,
3448 R_MIPS16_GOT16, R_MIPS_CALL16, etc. The format of the entry is the
3449 same in all cases. */
3450 entry = mips_elf_create_local_got_entry (abfd, info, ibfd, value, 0,
3451 NULL, R_MIPS_GOT16);
3453 return entry->gotidx;
3458 /* Returns the offset for the entry at the INDEXth position
3462 mips_elf_got_offset_from_index (struct bfd_link_info *info, bfd *output_bfd,
3463 bfd *input_bfd, bfd_vma got_index)
3465 struct mips_elf_link_hash_table *htab;
3469 htab = mips_elf_hash_table (info);
3470 BFD_ASSERT (htab != NULL);
3473 gp = _bfd_get_gp_value (output_bfd)
3474 + mips_elf_adjust_gp (output_bfd, htab->got_info, input_bfd);
3476 return sgot->output_section->vma + sgot->output_offset + got_index - gp;
3479 /* Create and return a local GOT entry for VALUE, which was calculated
3480 from a symbol belonging to INPUT_SECTON. Return NULL if it could not
3481 be created. If R_SYMNDX refers to a TLS symbol, create a TLS entry
3484 static struct mips_got_entry *
3485 mips_elf_create_local_got_entry (bfd *abfd, struct bfd_link_info *info,
3486 bfd *ibfd, bfd_vma value,
3487 unsigned long r_symndx,
3488 struct mips_elf_link_hash_entry *h,
3491 struct mips_got_entry entry, **loc;
3492 struct mips_got_info *g;
3493 struct mips_elf_link_hash_table *htab;
3495 htab = mips_elf_hash_table (info);
3496 BFD_ASSERT (htab != NULL);
3500 entry.d.address = value;
3503 g = mips_elf_got_for_ibfd (htab->got_info, ibfd);
3506 g = mips_elf_got_for_ibfd (htab->got_info, abfd);
3507 BFD_ASSERT (g != NULL);
3510 /* This function shouldn't be called for symbols that live in the global
3512 BFD_ASSERT (h == NULL || h->global_got_area == GGA_NONE);
3513 if (TLS_RELOC_P (r_type))
3515 struct mips_got_entry *p;
3518 if (tls_ldm_reloc_p (r_type))
3520 entry.tls_type = GOT_TLS_LDM;
3526 entry.symndx = r_symndx;
3532 p = (struct mips_got_entry *)
3533 htab_find (g->got_entries, &entry);
3539 loc = (struct mips_got_entry **) htab_find_slot (g->got_entries, &entry,
3544 entry.gotidx = MIPS_ELF_GOT_SIZE (abfd) * g->assigned_gotno++;
3547 *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry);
3552 memcpy (*loc, &entry, sizeof entry);
3554 if (g->assigned_gotno > g->local_gotno)
3556 (*loc)->gotidx = -1;
3557 /* We didn't allocate enough space in the GOT. */
3558 (*_bfd_error_handler)
3559 (_("not enough GOT space for local GOT entries"));
3560 bfd_set_error (bfd_error_bad_value);
3564 MIPS_ELF_PUT_WORD (abfd, value,
3565 (htab->sgot->contents + entry.gotidx));
3567 /* These GOT entries need a dynamic relocation on VxWorks. */
3568 if (htab->is_vxworks)
3570 Elf_Internal_Rela outrel;
3573 bfd_vma got_address;
3575 s = mips_elf_rel_dyn_section (info, FALSE);
3576 got_address = (htab->sgot->output_section->vma
3577 + htab->sgot->output_offset
3580 rloc = s->contents + (s->reloc_count++ * sizeof (Elf32_External_Rela));
3581 outrel.r_offset = got_address;
3582 outrel.r_info = ELF32_R_INFO (STN_UNDEF, R_MIPS_32);
3583 outrel.r_addend = value;
3584 bfd_elf32_swap_reloca_out (abfd, &outrel, rloc);
3590 /* Return the number of dynamic section symbols required by OUTPUT_BFD.
3591 The number might be exact or a worst-case estimate, depending on how
3592 much information is available to elf_backend_omit_section_dynsym at
3593 the current linking stage. */
3595 static bfd_size_type
3596 count_section_dynsyms (bfd *output_bfd, struct bfd_link_info *info)
3598 bfd_size_type count;
3601 if (info->shared || elf_hash_table (info)->is_relocatable_executable)
3604 const struct elf_backend_data *bed;
3606 bed = get_elf_backend_data (output_bfd);
3607 for (p = output_bfd->sections; p ; p = p->next)
3608 if ((p->flags & SEC_EXCLUDE) == 0
3609 && (p->flags & SEC_ALLOC) != 0
3610 && !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p))
3616 /* Sort the dynamic symbol table so that symbols that need GOT entries
3617 appear towards the end. */
3620 mips_elf_sort_hash_table (bfd *abfd, struct bfd_link_info *info)
3622 struct mips_elf_link_hash_table *htab;
3623 struct mips_elf_hash_sort_data hsd;
3624 struct mips_got_info *g;
3626 if (elf_hash_table (info)->dynsymcount == 0)
3629 htab = mips_elf_hash_table (info);
3630 BFD_ASSERT (htab != NULL);
3637 hsd.max_unref_got_dynindx
3638 = hsd.min_got_dynindx
3639 = (elf_hash_table (info)->dynsymcount - g->reloc_only_gotno);
3640 hsd.max_non_got_dynindx = count_section_dynsyms (abfd, info) + 1;
3641 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table *)
3642 elf_hash_table (info)),
3643 mips_elf_sort_hash_table_f,
3646 /* There should have been enough room in the symbol table to
3647 accommodate both the GOT and non-GOT symbols. */
3648 BFD_ASSERT (hsd.max_non_got_dynindx <= hsd.min_got_dynindx);
3649 BFD_ASSERT ((unsigned long) hsd.max_unref_got_dynindx
3650 == elf_hash_table (info)->dynsymcount);
3651 BFD_ASSERT (elf_hash_table (info)->dynsymcount - hsd.min_got_dynindx
3652 == g->global_gotno);
3654 /* Now we know which dynamic symbol has the lowest dynamic symbol
3655 table index in the GOT. */
3656 htab->global_gotsym = hsd.low;
3661 /* If H needs a GOT entry, assign it the highest available dynamic
3662 index. Otherwise, assign it the lowest available dynamic
3666 mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry *h, void *data)
3668 struct mips_elf_hash_sort_data *hsd = data;
3670 /* Symbols without dynamic symbol table entries aren't interesting
3672 if (h->root.dynindx == -1)
3675 switch (h->global_got_area)
3678 h->root.dynindx = hsd->max_non_got_dynindx++;
3682 h->root.dynindx = --hsd->min_got_dynindx;
3683 hsd->low = (struct elf_link_hash_entry *) h;
3686 case GGA_RELOC_ONLY:
3687 if (hsd->max_unref_got_dynindx == hsd->min_got_dynindx)
3688 hsd->low = (struct elf_link_hash_entry *) h;
3689 h->root.dynindx = hsd->max_unref_got_dynindx++;
3696 /* If H is a symbol that needs a global GOT entry, but has a dynamic
3697 symbol table index lower than any we've seen to date, record it for
3698 posterity. FOR_CALL is true if the caller is only interested in
3699 using the GOT entry for calls. */
3702 mips_elf_record_global_got_symbol (struct elf_link_hash_entry *h,
3703 bfd *abfd, struct bfd_link_info *info,
3704 bfd_boolean for_call,
3705 unsigned char tls_flag)
3707 struct mips_elf_link_hash_table *htab;
3708 struct mips_elf_link_hash_entry *hmips;
3709 struct mips_got_entry entry, **loc;
3710 struct mips_got_info *g;
3712 htab = mips_elf_hash_table (info);
3713 BFD_ASSERT (htab != NULL);
3715 hmips = (struct mips_elf_link_hash_entry *) h;
3717 hmips->got_only_for_calls = FALSE;
3719 /* A global symbol in the GOT must also be in the dynamic symbol
3721 if (h->dynindx == -1)
3723 switch (ELF_ST_VISIBILITY (h->other))
3727 _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
3730 if (!bfd_elf_link_record_dynamic_symbol (info, h))
3734 /* Make sure we have a GOT to put this entry into. */
3736 BFD_ASSERT (g != NULL);
3740 entry.d.h = (struct mips_elf_link_hash_entry *) h;
3743 loc = (struct mips_got_entry **) htab_find_slot (g->got_entries, &entry,
3746 /* If we've already marked this entry as needing GOT space, we don't
3747 need to do it again. */
3750 (*loc)->tls_type |= tls_flag;
3754 *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry);
3760 entry.tls_type = tls_flag;
3762 memcpy (*loc, &entry, sizeof entry);
3765 hmips->global_got_area = GGA_NORMAL;
3770 /* Reserve space in G for a GOT entry containing the value of symbol
3771 SYMNDX in input bfd ABDF, plus ADDEND. */
3774 mips_elf_record_local_got_symbol (bfd *abfd, long symndx, bfd_vma addend,
3775 struct bfd_link_info *info,
3776 unsigned char tls_flag)
3778 struct mips_elf_link_hash_table *htab;
3779 struct mips_got_info *g;
3780 struct mips_got_entry entry, **loc;
3782 htab = mips_elf_hash_table (info);
3783 BFD_ASSERT (htab != NULL);
3786 BFD_ASSERT (g != NULL);
3789 entry.symndx = symndx;
3790 entry.d.addend = addend;
3791 entry.tls_type = tls_flag;
3792 loc = (struct mips_got_entry **)
3793 htab_find_slot (g->got_entries, &entry, INSERT);
3797 if (tls_flag == GOT_TLS_GD && !((*loc)->tls_type & GOT_TLS_GD))
3800 (*loc)->tls_type |= tls_flag;
3802 else if (tls_flag == GOT_TLS_IE && !((*loc)->tls_type & GOT_TLS_IE))
3805 (*loc)->tls_type |= tls_flag;
3813 entry.tls_type = tls_flag;
3814 if (tls_flag == GOT_TLS_IE)
3816 else if (tls_flag == GOT_TLS_GD)
3818 else if (g->tls_ldm_offset == MINUS_ONE)
3820 g->tls_ldm_offset = MINUS_TWO;
3826 g->local_gotno += 1;
3830 *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry);
3835 memcpy (*loc, &entry, sizeof entry);
3840 /* Return the maximum number of GOT page entries required for RANGE. */
3843 mips_elf_pages_for_range (const struct mips_got_page_range *range)
3845 return (range->max_addend - range->min_addend + 0x1ffff) >> 16;
3848 /* Record that ABFD has a page relocation against symbol SYMNDX and
3849 that ADDEND is the addend for that relocation.
3851 This function creates an upper bound on the number of GOT slots
3852 required; no attempt is made to combine references to non-overridable
3853 global symbols across multiple input files. */
3856 mips_elf_record_got_page_entry (struct bfd_link_info *info, bfd *abfd,
3857 long symndx, bfd_signed_vma addend)
3859 struct mips_elf_link_hash_table *htab;
3860 struct mips_got_info *g;
3861 struct mips_got_page_entry lookup, *entry;
3862 struct mips_got_page_range **range_ptr, *range;
3863 bfd_vma old_pages, new_pages;
3866 htab = mips_elf_hash_table (info);
3867 BFD_ASSERT (htab != NULL);
3870 BFD_ASSERT (g != NULL);
3872 /* Find the mips_got_page_entry hash table entry for this symbol. */
3874 lookup.symndx = symndx;
3875 loc = htab_find_slot (g->got_page_entries, &lookup, INSERT);
3879 /* Create a mips_got_page_entry if this is the first time we've
3881 entry = (struct mips_got_page_entry *) *loc;
3884 entry = bfd_alloc (abfd, sizeof (*entry));
3889 entry->symndx = symndx;
3890 entry->ranges = NULL;
3891 entry->num_pages = 0;
3895 /* Skip over ranges whose maximum extent cannot share a page entry
3897 range_ptr = &entry->ranges;
3898 while (*range_ptr && addend > (*range_ptr)->max_addend + 0xffff)
3899 range_ptr = &(*range_ptr)->next;
3901 /* If we scanned to the end of the list, or found a range whose
3902 minimum extent cannot share a page entry with ADDEND, create
3903 a new singleton range. */
3905 if (!range || addend < range->min_addend - 0xffff)
3907 range = bfd_alloc (abfd, sizeof (*range));
3911 range->next = *range_ptr;
3912 range->min_addend = addend;
3913 range->max_addend = addend;
3921 /* Remember how many pages the old range contributed. */
3922 old_pages = mips_elf_pages_for_range (range);
3924 /* Update the ranges. */
3925 if (addend < range->min_addend)
3926 range->min_addend = addend;
3927 else if (addend > range->max_addend)
3929 if (range->next && addend >= range->next->min_addend - 0xffff)
3931 old_pages += mips_elf_pages_for_range (range->next);
3932 range->max_addend = range->next->max_addend;
3933 range->next = range->next->next;
3936 range->max_addend = addend;
3939 /* Record any change in the total estimate. */
3940 new_pages = mips_elf_pages_for_range (range);
3941 if (old_pages != new_pages)
3943 entry->num_pages += new_pages - old_pages;
3944 g->page_gotno += new_pages - old_pages;
3950 /* Add room for N relocations to the .rel(a).dyn section in ABFD. */
3953 mips_elf_allocate_dynamic_relocations (bfd *abfd, struct bfd_link_info *info,
3957 struct mips_elf_link_hash_table *htab;
3959 htab = mips_elf_hash_table (info);
3960 BFD_ASSERT (htab != NULL);
3962 s = mips_elf_rel_dyn_section (info, FALSE);
3963 BFD_ASSERT (s != NULL);
3965 if (htab->is_vxworks)
3966 s->size += n * MIPS_ELF_RELA_SIZE (abfd);
3971 /* Make room for a null element. */
3972 s->size += MIPS_ELF_REL_SIZE (abfd);
3975 s->size += n * MIPS_ELF_REL_SIZE (abfd);
3979 /* A htab_traverse callback for GOT entries. Set boolean *DATA to true
3980 if the GOT entry is for an indirect or warning symbol. */
3983 mips_elf_check_recreate_got (void **entryp, void *data)
3985 struct mips_got_entry *entry;
3986 bfd_boolean *must_recreate;
3988 entry = (struct mips_got_entry *) *entryp;
3989 must_recreate = (bfd_boolean *) data;
3990 if (entry->abfd != NULL && entry->symndx == -1)
3992 struct mips_elf_link_hash_entry *h;
3995 if (h->root.root.type == bfd_link_hash_indirect
3996 || h->root.root.type == bfd_link_hash_warning)
3998 *must_recreate = TRUE;
4005 /* A htab_traverse callback for GOT entries. Add all entries to
4006 hash table *DATA, converting entries for indirect and warning
4007 symbols into entries for the target symbol. Set *DATA to null
4011 mips_elf_recreate_got (void **entryp, void *data)
4014 struct mips_got_entry *entry;
4017 new_got = (htab_t *) data;
4018 entry = (struct mips_got_entry *) *entryp;
4019 if (entry->abfd != NULL && entry->symndx == -1)
4021 struct mips_elf_link_hash_entry *h;
4024 while (h->root.root.type == bfd_link_hash_indirect
4025 || h->root.root.type == bfd_link_hash_warning)
4027 BFD_ASSERT (h->global_got_area == GGA_NONE);
4028 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
4032 slot = htab_find_slot (*new_got, entry, INSERT);
4043 /* If any entries in G->got_entries are for indirect or warning symbols,
4044 replace them with entries for the target symbol. */
4047 mips_elf_resolve_final_got_entries (struct mips_got_info *g)
4049 bfd_boolean must_recreate;
4052 must_recreate = FALSE;
4053 htab_traverse (g->got_entries, mips_elf_check_recreate_got, &must_recreate);
4056 new_got = htab_create (htab_size (g->got_entries),
4057 mips_elf_got_entry_hash,
4058 mips_elf_got_entry_eq, NULL);
4059 htab_traverse (g->got_entries, mips_elf_recreate_got, &new_got);
4060 if (new_got == NULL)
4063 htab_delete (g->got_entries);
4064 g->got_entries = new_got;
4069 /* A mips_elf_link_hash_traverse callback for which DATA points
4070 to the link_info structure. Count the number of type (3) entries
4071 in the master GOT. */
4074 mips_elf_count_got_symbols (struct mips_elf_link_hash_entry *h, void *data)
4076 struct bfd_link_info *info;
4077 struct mips_elf_link_hash_table *htab;
4078 struct mips_got_info *g;
4080 info = (struct bfd_link_info *) data;
4081 htab = mips_elf_hash_table (info);
4083 if (h->global_got_area != GGA_NONE)
4085 /* Make a final decision about whether the symbol belongs in the
4086 local or global GOT. Symbols that bind locally can (and in the
4087 case of forced-local symbols, must) live in the local GOT.
4088 Those that are aren't in the dynamic symbol table must also
4089 live in the local GOT.
4091 Note that the former condition does not always imply the
4092 latter: symbols do not bind locally if they are completely
4093 undefined. We'll report undefined symbols later if appropriate. */
4094 if (h->root.dynindx == -1
4095 || (h->got_only_for_calls
4096 ? SYMBOL_CALLS_LOCAL (info, &h->root)
4097 : SYMBOL_REFERENCES_LOCAL (info, &h->root)))
4099 /* The symbol belongs in the local GOT. We no longer need this
4100 entry if it was only used for relocations; those relocations
4101 will be against the null or section symbol instead of H. */
4102 if (h->global_got_area != GGA_RELOC_ONLY)
4104 h->global_got_area = GGA_NONE;
4106 else if (htab->is_vxworks
4107 && h->got_only_for_calls
4108 && h->root.plt.offset != MINUS_ONE)
4109 /* On VxWorks, calls can refer directly to the .got.plt entry;
4110 they don't need entries in the regular GOT. .got.plt entries
4111 will be allocated by _bfd_mips_elf_adjust_dynamic_symbol. */
4112 h->global_got_area = GGA_NONE;
4116 if (h->global_got_area == GGA_RELOC_ONLY)
4117 g->reloc_only_gotno++;
4123 /* Compute the hash value of the bfd in a bfd2got hash entry. */
4126 mips_elf_bfd2got_entry_hash (const void *entry_)
4128 const struct mips_elf_bfd2got_hash *entry
4129 = (struct mips_elf_bfd2got_hash *)entry_;
4131 return entry->bfd->id;
4134 /* Check whether two hash entries have the same bfd. */
4137 mips_elf_bfd2got_entry_eq (const void *entry1, const void *entry2)
4139 const struct mips_elf_bfd2got_hash *e1
4140 = (const struct mips_elf_bfd2got_hash *)entry1;
4141 const struct mips_elf_bfd2got_hash *e2
4142 = (const struct mips_elf_bfd2got_hash *)entry2;
4144 return e1->bfd == e2->bfd;
4147 /* In a multi-got link, determine the GOT to be used for IBFD. G must
4148 be the master GOT data. */
4150 static struct mips_got_info *
4151 mips_elf_got_for_ibfd (struct mips_got_info *g, bfd *ibfd)
4153 struct mips_elf_bfd2got_hash e, *p;
4159 p = htab_find (g->bfd2got, &e);
4160 return p ? p->g : NULL;
4163 /* Use BFD2GOT to find ABFD's got entry, creating one if none exists.
4164 Return NULL if an error occured. */
4166 static struct mips_got_info *
4167 mips_elf_get_got_for_bfd (struct htab *bfd2got, bfd *output_bfd,
4170 struct mips_elf_bfd2got_hash bfdgot_entry, *bfdgot;
4173 bfdgot_entry.bfd = input_bfd;
4174 bfdgotp = htab_find_slot (bfd2got, &bfdgot_entry, INSERT);
4175 bfdgot = (struct mips_elf_bfd2got_hash *) *bfdgotp;
4179 bfdgot = ((struct mips_elf_bfd2got_hash *)
4180 bfd_alloc (output_bfd, sizeof (struct mips_elf_bfd2got_hash)));
4186 bfdgot->bfd = input_bfd;
4187 bfdgot->g = mips_elf_create_got_info (input_bfd, FALSE);
4188 if (bfdgot->g == NULL)
4195 /* A htab_traverse callback for the entries in the master got.
4196 Create one separate got for each bfd that has entries in the global
4197 got, such that we can tell how many local and global entries each
4201 mips_elf_make_got_per_bfd (void **entryp, void *p)
4203 struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
4204 struct mips_elf_got_per_bfd_arg *arg = (struct mips_elf_got_per_bfd_arg *)p;
4205 struct mips_got_info *g;
4207 g = mips_elf_get_got_for_bfd (arg->bfd2got, arg->obfd, entry->abfd);
4214 /* Insert the GOT entry in the bfd's got entry hash table. */
4215 entryp = htab_find_slot (g->got_entries, entry, INSERT);
4216 if (*entryp != NULL)
4221 if (entry->tls_type)
4223 if (entry->tls_type & (GOT_TLS_GD | GOT_TLS_LDM))
4225 if (entry->tls_type & GOT_TLS_IE)
4228 else if (entry->symndx >= 0 || entry->d.h->global_got_area == GGA_NONE)
4236 /* A htab_traverse callback for the page entries in the master got.
4237 Associate each page entry with the bfd's got. */
4240 mips_elf_make_got_pages_per_bfd (void **entryp, void *p)
4242 struct mips_got_page_entry *entry = (struct mips_got_page_entry *) *entryp;
4243 struct mips_elf_got_per_bfd_arg *arg = (struct mips_elf_got_per_bfd_arg *) p;
4244 struct mips_got_info *g;
4246 g = mips_elf_get_got_for_bfd (arg->bfd2got, arg->obfd, entry->abfd);
4253 /* Insert the GOT entry in the bfd's got entry hash table. */
4254 entryp = htab_find_slot (g->got_page_entries, entry, INSERT);
4255 if (*entryp != NULL)
4259 g->page_gotno += entry->num_pages;
4263 /* Consider merging the got described by BFD2GOT with TO, using the
4264 information given by ARG. Return -1 if this would lead to overflow,
4265 1 if they were merged successfully, and 0 if a merge failed due to
4266 lack of memory. (These values are chosen so that nonnegative return
4267 values can be returned by a htab_traverse callback.) */
4270 mips_elf_merge_got_with (struct mips_elf_bfd2got_hash *bfd2got,
4271 struct mips_got_info *to,
4272 struct mips_elf_got_per_bfd_arg *arg)
4274 struct mips_got_info *from = bfd2got->g;
4275 unsigned int estimate;
4277 /* Work out how many page entries we would need for the combined GOT. */
4278 estimate = arg->max_pages;
4279 if (estimate >= from->page_gotno + to->page_gotno)
4280 estimate = from->page_gotno + to->page_gotno;
4282 /* And conservatively estimate how many local and TLS entries
4284 estimate += from->local_gotno + to->local_gotno;
4285 estimate += from->tls_gotno + to->tls_gotno;
4287 /* If we're merging with the primary got, any TLS relocations will
4288 come after the full set of global entries. Otherwise estimate those
4289 conservatively as well. */
4290 if (to == arg->primary && from->tls_gotno + to->tls_gotno)
4291 estimate += arg->global_count;
4293 estimate += from->global_gotno + to->global_gotno;
4295 /* Bail out if the combined GOT might be too big. */
4296 if (estimate > arg->max_count)
4299 /* Commit to the merge. Record that TO is now the bfd for this got. */
4302 /* Transfer the bfd's got information from FROM to TO. */
4303 htab_traverse (from->got_entries, mips_elf_make_got_per_bfd, arg);
4304 if (arg->obfd == NULL)
4307 htab_traverse (from->got_page_entries, mips_elf_make_got_pages_per_bfd, arg);
4308 if (arg->obfd == NULL)
4311 /* We don't have to worry about releasing memory of the actual
4312 got entries, since they're all in the master got_entries hash
4314 htab_delete (from->got_entries);
4315 htab_delete (from->got_page_entries);
4319 /* Attempt to merge gots of different input bfds. Try to use as much
4320 as possible of the primary got, since it doesn't require explicit
4321 dynamic relocations, but don't use bfds that would reference global
4322 symbols out of the addressable range. Failing the primary got,
4323 attempt to merge with the current got, or finish the current got
4324 and then make make the new got current. */
4327 mips_elf_merge_gots (void **bfd2got_, void *p)
4329 struct mips_elf_bfd2got_hash *bfd2got
4330 = (struct mips_elf_bfd2got_hash *)*bfd2got_;
4331 struct mips_elf_got_per_bfd_arg *arg = (struct mips_elf_got_per_bfd_arg *)p;
4332 struct mips_got_info *g;
4333 unsigned int estimate;
4338 /* Work out the number of page, local and TLS entries. */
4339 estimate = arg->max_pages;
4340 if (estimate > g->page_gotno)
4341 estimate = g->page_gotno;
4342 estimate += g->local_gotno + g->tls_gotno;
4344 /* We place TLS GOT entries after both locals and globals. The globals
4345 for the primary GOT may overflow the normal GOT size limit, so be
4346 sure not to merge a GOT which requires TLS with the primary GOT in that
4347 case. This doesn't affect non-primary GOTs. */
4348 estimate += (g->tls_gotno > 0 ? arg->global_count : g->global_gotno);
4350 if (estimate <= arg->max_count)
4352 /* If we don't have a primary GOT, use it as
4353 a starting point for the primary GOT. */
4356 arg->primary = bfd2got->g;
4360 /* Try merging with the primary GOT. */
4361 result = mips_elf_merge_got_with (bfd2got, arg->primary, arg);
4366 /* If we can merge with the last-created got, do it. */
4369 result = mips_elf_merge_got_with (bfd2got, arg->current, arg);
4374 /* Well, we couldn't merge, so create a new GOT. Don't check if it
4375 fits; if it turns out that it doesn't, we'll get relocation
4376 overflows anyway. */
4377 g->next = arg->current;
4383 /* Set the TLS GOT index for the GOT entry in ENTRYP. ENTRYP's NEXT field
4384 is null iff there is just a single GOT. */
4387 mips_elf_initialize_tls_index (void **entryp, void *p)
4389 struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
4390 struct mips_got_info *g = p;
4392 unsigned char tls_type;
4394 /* We're only interested in TLS symbols. */
4395 if (entry->tls_type == 0)
4398 next_index = MIPS_ELF_GOT_SIZE (entry->abfd) * (long) g->tls_assigned_gotno;
4400 if (entry->symndx == -1 && g->next == NULL)
4402 /* A type (3) got entry in the single-GOT case. We use the symbol's
4403 hash table entry to track its index. */
4404 if (entry->d.h->tls_type & GOT_TLS_OFFSET_DONE)
4406 entry->d.h->tls_type |= GOT_TLS_OFFSET_DONE;
4407 entry->d.h->tls_got_offset = next_index;
4408 tls_type = entry->d.h->tls_type;
4412 if (entry->tls_type & GOT_TLS_LDM)
4414 /* There are separate mips_got_entry objects for each input bfd
4415 that requires an LDM entry. Make sure that all LDM entries in
4416 a GOT resolve to the same index. */
4417 if (g->tls_ldm_offset != MINUS_TWO && g->tls_ldm_offset != MINUS_ONE)
4419 entry->gotidx = g->tls_ldm_offset;
4422 g->tls_ldm_offset = next_index;
4424 entry->gotidx = next_index;
4425 tls_type = entry->tls_type;
4428 /* Account for the entries we've just allocated. */
4429 if (tls_type & (GOT_TLS_GD | GOT_TLS_LDM))
4430 g->tls_assigned_gotno += 2;
4431 if (tls_type & GOT_TLS_IE)
4432 g->tls_assigned_gotno += 1;
4437 /* If passed a NULL mips_got_info in the argument, set the marker used
4438 to tell whether a global symbol needs a got entry (in the primary
4439 got) to the given VALUE.
4441 If passed a pointer G to a mips_got_info in the argument (it must
4442 not be the primary GOT), compute the offset from the beginning of
4443 the (primary) GOT section to the entry in G corresponding to the
4444 global symbol. G's assigned_gotno must contain the index of the
4445 first available global GOT entry in G. VALUE must contain the size
4446 of a GOT entry in bytes. For each global GOT entry that requires a
4447 dynamic relocation, NEEDED_RELOCS is incremented, and the symbol is
4448 marked as not eligible for lazy resolution through a function
4451 mips_elf_set_global_got_offset (void **entryp, void *p)
4453 struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
4454 struct mips_elf_set_global_got_offset_arg *arg
4455 = (struct mips_elf_set_global_got_offset_arg *)p;
4456 struct mips_got_info *g = arg->g;
4458 if (g && entry->tls_type != GOT_NORMAL)
4459 arg->needed_relocs +=
4460 mips_tls_got_relocs (arg->info, entry->tls_type,
4461 entry->symndx == -1 ? &entry->d.h->root : NULL);
4463 if (entry->abfd != NULL
4464 && entry->symndx == -1
4465 && entry->d.h->global_got_area != GGA_NONE)
4469 entry->gotidx = arg->value * (long) g->assigned_gotno++;
4470 if (arg->info->shared
4471 || (elf_hash_table (arg->info)->dynamic_sections_created
4472 && entry->d.h->root.def_dynamic
4473 && !entry->d.h->root.def_regular))
4474 ++arg->needed_relocs;
4477 entry->d.h->global_got_area = arg->value;
4483 /* A htab_traverse callback for GOT entries for which DATA is the
4484 bfd_link_info. Forbid any global symbols from having traditional
4485 lazy-binding stubs. */
4488 mips_elf_forbid_lazy_stubs (void **entryp, void *data)
4490 struct bfd_link_info *info;
4491 struct mips_elf_link_hash_table *htab;
4492 struct mips_got_entry *entry;
4494 entry = (struct mips_got_entry *) *entryp;
4495 info = (struct bfd_link_info *) data;
4496 htab = mips_elf_hash_table (info);
4497 BFD_ASSERT (htab != NULL);
4499 if (entry->abfd != NULL
4500 && entry->symndx == -1
4501 && entry->d.h->needs_lazy_stub)
4503 entry->d.h->needs_lazy_stub = FALSE;
4504 htab->lazy_stub_count--;
4510 /* Return the offset of an input bfd IBFD's GOT from the beginning of
4513 mips_elf_adjust_gp (bfd *abfd, struct mips_got_info *g, bfd *ibfd)
4515 if (g->bfd2got == NULL)
4518 g = mips_elf_got_for_ibfd (g, ibfd);
4522 BFD_ASSERT (g->next);
4526 return (g->local_gotno + g->global_gotno + g->tls_gotno)
4527 * MIPS_ELF_GOT_SIZE (abfd);
4530 /* Turn a single GOT that is too big for 16-bit addressing into
4531 a sequence of GOTs, each one 16-bit addressable. */
4534 mips_elf_multi_got (bfd *abfd, struct bfd_link_info *info,
4535 asection *got, bfd_size_type pages)
4537 struct mips_elf_link_hash_table *htab;
4538 struct mips_elf_got_per_bfd_arg got_per_bfd_arg;
4539 struct mips_elf_set_global_got_offset_arg set_got_offset_arg;
4540 struct mips_got_info *g, *gg;
4541 unsigned int assign, needed_relocs;
4544 dynobj = elf_hash_table (info)->dynobj;
4545 htab = mips_elf_hash_table (info);
4546 BFD_ASSERT (htab != NULL);
4549 g->bfd2got = htab_try_create (1, mips_elf_bfd2got_entry_hash,
4550 mips_elf_bfd2got_entry_eq, NULL);
4551 if (g->bfd2got == NULL)
4554 got_per_bfd_arg.bfd2got = g->bfd2got;
4555 got_per_bfd_arg.obfd = abfd;
4556 got_per_bfd_arg.info = info;
4558 /* Count how many GOT entries each input bfd requires, creating a
4559 map from bfd to got info while at that. */
4560 htab_traverse (g->got_entries, mips_elf_make_got_per_bfd, &got_per_bfd_arg);
4561 if (got_per_bfd_arg.obfd == NULL)
4564 /* Also count how many page entries each input bfd requires. */
4565 htab_traverse (g->got_page_entries, mips_elf_make_got_pages_per_bfd,
4567 if (got_per_bfd_arg.obfd == NULL)
4570 got_per_bfd_arg.current = NULL;
4571 got_per_bfd_arg.primary = NULL;
4572 got_per_bfd_arg.max_count = ((MIPS_ELF_GOT_MAX_SIZE (info)
4573 / MIPS_ELF_GOT_SIZE (abfd))
4574 - htab->reserved_gotno);
4575 got_per_bfd_arg.max_pages = pages;
4576 /* The number of globals that will be included in the primary GOT.
4577 See the calls to mips_elf_set_global_got_offset below for more
4579 got_per_bfd_arg.global_count = g->global_gotno;
4581 /* Try to merge the GOTs of input bfds together, as long as they
4582 don't seem to exceed the maximum GOT size, choosing one of them
4583 to be the primary GOT. */
4584 htab_traverse (g->bfd2got, mips_elf_merge_gots, &got_per_bfd_arg);
4585 if (got_per_bfd_arg.obfd == NULL)
4588 /* If we do not find any suitable primary GOT, create an empty one. */
4589 if (got_per_bfd_arg.primary == NULL)
4590 g->next = mips_elf_create_got_info (abfd, FALSE);
4592 g->next = got_per_bfd_arg.primary;
4593 g->next->next = got_per_bfd_arg.current;
4595 /* GG is now the master GOT, and G is the primary GOT. */
4599 /* Map the output bfd to the primary got. That's what we're going
4600 to use for bfds that use GOT16 or GOT_PAGE relocations that we
4601 didn't mark in check_relocs, and we want a quick way to find it.
4602 We can't just use gg->next because we're going to reverse the
4605 struct mips_elf_bfd2got_hash *bfdgot;
4608 bfdgot = (struct mips_elf_bfd2got_hash *)bfd_alloc
4609 (abfd, sizeof (struct mips_elf_bfd2got_hash));
4616 bfdgotp = htab_find_slot (gg->bfd2got, bfdgot, INSERT);
4618 BFD_ASSERT (*bfdgotp == NULL);
4622 /* Every symbol that is referenced in a dynamic relocation must be
4623 present in the primary GOT, so arrange for them to appear after
4624 those that are actually referenced. */
4625 gg->reloc_only_gotno = gg->global_gotno - g->global_gotno;
4626 g->global_gotno = gg->global_gotno;
4628 set_got_offset_arg.g = NULL;
4629 set_got_offset_arg.value = GGA_RELOC_ONLY;
4630 htab_traverse (gg->got_entries, mips_elf_set_global_got_offset,
4631 &set_got_offset_arg);
4632 set_got_offset_arg.value = GGA_NORMAL;
4633 htab_traverse (g->got_entries, mips_elf_set_global_got_offset,
4634 &set_got_offset_arg);
4636 /* Now go through the GOTs assigning them offset ranges.
4637 [assigned_gotno, local_gotno[ will be set to the range of local
4638 entries in each GOT. We can then compute the end of a GOT by
4639 adding local_gotno to global_gotno. We reverse the list and make
4640 it circular since then we'll be able to quickly compute the
4641 beginning of a GOT, by computing the end of its predecessor. To
4642 avoid special cases for the primary GOT, while still preserving
4643 assertions that are valid for both single- and multi-got links,
4644 we arrange for the main got struct to have the right number of
4645 global entries, but set its local_gotno such that the initial
4646 offset of the primary GOT is zero. Remember that the primary GOT
4647 will become the last item in the circular linked list, so it
4648 points back to the master GOT. */
4649 gg->local_gotno = -g->global_gotno;
4650 gg->global_gotno = g->global_gotno;
4657 struct mips_got_info *gn;
4659 assign += htab->reserved_gotno;
4660 g->assigned_gotno = assign;
4661 g->local_gotno += assign;
4662 g->local_gotno += (pages < g->page_gotno ? pages : g->page_gotno);
4663 assign = g->local_gotno + g->global_gotno + g->tls_gotno;
4665 /* Take g out of the direct list, and push it onto the reversed
4666 list that gg points to. g->next is guaranteed to be nonnull after
4667 this operation, as required by mips_elf_initialize_tls_index. */
4672 /* Set up any TLS entries. We always place the TLS entries after
4673 all non-TLS entries. */
4674 g->tls_assigned_gotno = g->local_gotno + g->global_gotno;
4675 htab_traverse (g->got_entries, mips_elf_initialize_tls_index, g);
4676 BFD_ASSERT (g->tls_assigned_gotno == assign);
4678 /* Move onto the next GOT. It will be a secondary GOT if nonull. */
4681 /* Forbid global symbols in every non-primary GOT from having
4682 lazy-binding stubs. */
4684 htab_traverse (g->got_entries, mips_elf_forbid_lazy_stubs, info);
4688 got->size = assign * MIPS_ELF_GOT_SIZE (abfd);
4691 set_got_offset_arg.value = MIPS_ELF_GOT_SIZE (abfd);
4692 set_got_offset_arg.info = info;
4693 for (g = gg->next; g && g->next != gg; g = g->next)
4695 unsigned int save_assign;
4697 /* Assign offsets to global GOT entries. */
4698 save_assign = g->assigned_gotno;
4699 g->assigned_gotno = g->local_gotno;
4700 set_got_offset_arg.g = g;
4701 set_got_offset_arg.needed_relocs = 0;
4702 htab_traverse (g->got_entries,
4703 mips_elf_set_global_got_offset,
4704 &set_got_offset_arg);
4705 needed_relocs += set_got_offset_arg.needed_relocs;
4706 BFD_ASSERT (g->assigned_gotno - g->local_gotno <= g->global_gotno);
4708 g->assigned_gotno = save_assign;
4711 needed_relocs += g->local_gotno - g->assigned_gotno;
4712 BFD_ASSERT (g->assigned_gotno == g->next->local_gotno
4713 + g->next->global_gotno
4714 + g->next->tls_gotno
4715 + htab->reserved_gotno);
4720 mips_elf_allocate_dynamic_relocations (dynobj, info,
4727 /* Returns the first relocation of type r_type found, beginning with
4728 RELOCATION. RELEND is one-past-the-end of the relocation table. */
4730 static const Elf_Internal_Rela *
4731 mips_elf_next_relocation (bfd *abfd ATTRIBUTE_UNUSED, unsigned int r_type,
4732 const Elf_Internal_Rela *relocation,
4733 const Elf_Internal_Rela *relend)
4735 unsigned long r_symndx = ELF_R_SYM (abfd, relocation->r_info);
4737 while (relocation < relend)
4739 if (ELF_R_TYPE (abfd, relocation->r_info) == r_type
4740 && ELF_R_SYM (abfd, relocation->r_info) == r_symndx)
4746 /* We didn't find it. */
4750 /* Return whether an input relocation is against a local symbol. */
4753 mips_elf_local_relocation_p (bfd *input_bfd,
4754 const Elf_Internal_Rela *relocation,
4755 asection **local_sections)
4757 unsigned long r_symndx;
4758 Elf_Internal_Shdr *symtab_hdr;
4761 r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
4762 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4763 extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
4765 if (r_symndx < extsymoff)
4767 if (elf_bad_symtab (input_bfd) && local_sections[r_symndx] != NULL)
4773 /* Sign-extend VALUE, which has the indicated number of BITS. */
4776 _bfd_mips_elf_sign_extend (bfd_vma value, int bits)
4778 if (value & ((bfd_vma) 1 << (bits - 1)))
4779 /* VALUE is negative. */
4780 value |= ((bfd_vma) - 1) << bits;
4785 /* Return non-zero if the indicated VALUE has overflowed the maximum
4786 range expressible by a signed number with the indicated number of
4790 mips_elf_overflow_p (bfd_vma value, int bits)
4792 bfd_signed_vma svalue = (bfd_signed_vma) value;
4794 if (svalue > (1 << (bits - 1)) - 1)
4795 /* The value is too big. */
4797 else if (svalue < -(1 << (bits - 1)))
4798 /* The value is too small. */
4805 /* Calculate the %high function. */
4808 mips_elf_high (bfd_vma value)
4810 return ((value + (bfd_vma) 0x8000) >> 16) & 0xffff;
4813 /* Calculate the %higher function. */
4816 mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED)
4819 return ((value + (bfd_vma) 0x80008000) >> 32) & 0xffff;
4826 /* Calculate the %highest function. */
4829 mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED)
4832 return ((value + (((bfd_vma) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
4839 /* Create the .compact_rel section. */
4842 mips_elf_create_compact_rel_section
4843 (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
4846 register asection *s;
4848 if (bfd_get_linker_section (abfd, ".compact_rel") == NULL)
4850 flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED
4853 s = bfd_make_section_anyway_with_flags (abfd, ".compact_rel", flags);
4855 || ! bfd_set_section_alignment (abfd, s,
4856 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
4859 s->size = sizeof (Elf32_External_compact_rel);
4865 /* Create the .got section to hold the global offset table. */
4868 mips_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
4871 register asection *s;
4872 struct elf_link_hash_entry *h;
4873 struct bfd_link_hash_entry *bh;
4874 struct mips_elf_link_hash_table *htab;
4876 htab = mips_elf_hash_table (info);
4877 BFD_ASSERT (htab != NULL);
4879 /* This function may be called more than once. */
4883 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4884 | SEC_LINKER_CREATED);
4886 /* We have to use an alignment of 2**4 here because this is hardcoded
4887 in the function stub generation and in the linker script. */
4888 s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4890 || ! bfd_set_section_alignment (abfd, s, 4))
4894 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
4895 linker script because we don't want to define the symbol if we
4896 are not creating a global offset table. */
4898 if (! (_bfd_generic_link_add_one_symbol
4899 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
4900 0, NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
4903 h = (struct elf_link_hash_entry *) bh;
4906 h->type = STT_OBJECT;
4907 elf_hash_table (info)->hgot = h;
4910 && ! bfd_elf_link_record_dynamic_symbol (info, h))
4913 htab->got_info = mips_elf_create_got_info (abfd, TRUE);
4914 mips_elf_section_data (s)->elf.this_hdr.sh_flags
4915 |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
4917 /* We also need a .got.plt section when generating PLTs. */
4918 s = bfd_make_section_anyway_with_flags (abfd, ".got.plt",
4919 SEC_ALLOC | SEC_LOAD
4922 | SEC_LINKER_CREATED);
4930 /* Return true if H refers to the special VxWorks __GOTT_BASE__ or
4931 __GOTT_INDEX__ symbols. These symbols are only special for
4932 shared objects; they are not used in executables. */
4935 is_gott_symbol (struct bfd_link_info *info, struct elf_link_hash_entry *h)
4937 return (mips_elf_hash_table (info)->is_vxworks
4939 && (strcmp (h->root.root.string, "__GOTT_BASE__") == 0
4940 || strcmp (h->root.root.string, "__GOTT_INDEX__") == 0));
4943 /* Return TRUE if a relocation of type R_TYPE from INPUT_BFD might
4944 require an la25 stub. See also mips_elf_local_pic_function_p,
4945 which determines whether the destination function ever requires a
4949 mips_elf_relocation_needs_la25_stub (bfd *input_bfd, int r_type,
4950 bfd_boolean target_is_16_bit_code_p)
4952 /* We specifically ignore branches and jumps from EF_PIC objects,
4953 where the onus is on the compiler or programmer to perform any
4954 necessary initialization of $25. Sometimes such initialization
4955 is unnecessary; for example, -mno-shared functions do not use
4956 the incoming value of $25, and may therefore be called directly. */
4957 if (PIC_OBJECT_P (input_bfd))
4964 case R_MICROMIPS_26_S1:
4965 case R_MICROMIPS_PC7_S1:
4966 case R_MICROMIPS_PC10_S1:
4967 case R_MICROMIPS_PC16_S1:
4968 case R_MICROMIPS_PC23_S2:
4972 return !target_is_16_bit_code_p;
4979 /* Calculate the value produced by the RELOCATION (which comes from
4980 the INPUT_BFD). The ADDEND is the addend to use for this
4981 RELOCATION; RELOCATION->R_ADDEND is ignored.
4983 The result of the relocation calculation is stored in VALUEP.
4984 On exit, set *CROSS_MODE_JUMP_P to true if the relocation field
4985 is a MIPS16 or microMIPS jump to standard MIPS code, or vice versa.
4987 This function returns bfd_reloc_continue if the caller need take no
4988 further action regarding this relocation, bfd_reloc_notsupported if
4989 something goes dramatically wrong, bfd_reloc_overflow if an
4990 overflow occurs, and bfd_reloc_ok to indicate success. */
4992 static bfd_reloc_status_type
4993 mips_elf_calculate_relocation (bfd *abfd, bfd *input_bfd,
4994 asection *input_section,
4995 struct bfd_link_info *info,
4996 const Elf_Internal_Rela *relocation,
4997 bfd_vma addend, reloc_howto_type *howto,
4998 Elf_Internal_Sym *local_syms,
4999 asection **local_sections, bfd_vma *valuep,
5001 bfd_boolean *cross_mode_jump_p,
5002 bfd_boolean save_addend)
5004 /* The eventual value we will return. */
5006 /* The address of the symbol against which the relocation is
5009 /* The final GP value to be used for the relocatable, executable, or
5010 shared object file being produced. */
5012 /* The place (section offset or address) of the storage unit being
5015 /* The value of GP used to create the relocatable object. */
5017 /* The offset into the global offset table at which the address of
5018 the relocation entry symbol, adjusted by the addend, resides
5019 during execution. */
5020 bfd_vma g = MINUS_ONE;
5021 /* The section in which the symbol referenced by the relocation is
5023 asection *sec = NULL;
5024 struct mips_elf_link_hash_entry *h = NULL;
5025 /* TRUE if the symbol referred to by this relocation is a local
5027 bfd_boolean local_p, was_local_p;
5028 /* TRUE if the symbol referred to by this relocation is "_gp_disp". */
5029 bfd_boolean gp_disp_p = FALSE;
5030 /* TRUE if the symbol referred to by this relocation is
5031 "__gnu_local_gp". */
5032 bfd_boolean gnu_local_gp_p = FALSE;
5033 Elf_Internal_Shdr *symtab_hdr;
5035 unsigned long r_symndx;
5037 /* TRUE if overflow occurred during the calculation of the
5038 relocation value. */
5039 bfd_boolean overflowed_p;
5040 /* TRUE if this relocation refers to a MIPS16 function. */
5041 bfd_boolean target_is_16_bit_code_p = FALSE;
5042 bfd_boolean target_is_micromips_code_p = FALSE;
5043 struct mips_elf_link_hash_table *htab;
5046 dynobj = elf_hash_table (info)->dynobj;
5047 htab = mips_elf_hash_table (info);
5048 BFD_ASSERT (htab != NULL);
5050 /* Parse the relocation. */
5051 r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
5052 r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
5053 p = (input_section->output_section->vma
5054 + input_section->output_offset
5055 + relocation->r_offset);
5057 /* Assume that there will be no overflow. */
5058 overflowed_p = FALSE;
5060 /* Figure out whether or not the symbol is local, and get the offset
5061 used in the array of hash table entries. */
5062 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5063 local_p = mips_elf_local_relocation_p (input_bfd, relocation,
5065 was_local_p = local_p;
5066 if (! elf_bad_symtab (input_bfd))
5067 extsymoff = symtab_hdr->sh_info;
5070 /* The symbol table does not follow the rule that local symbols
5071 must come before globals. */
5075 /* Figure out the value of the symbol. */
5078 Elf_Internal_Sym *sym;
5080 sym = local_syms + r_symndx;
5081 sec = local_sections[r_symndx];
5083 symbol = sec->output_section->vma + sec->output_offset;
5084 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION
5085 || (sec->flags & SEC_MERGE))
5086 symbol += sym->st_value;
5087 if ((sec->flags & SEC_MERGE)
5088 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5090 addend = _bfd_elf_rel_local_sym (abfd, sym, &sec, addend);
5092 addend += sec->output_section->vma + sec->output_offset;
5095 /* MIPS16/microMIPS text labels should be treated as odd. */
5096 if (ELF_ST_IS_COMPRESSED (sym->st_other))
5099 /* Record the name of this symbol, for our caller. */
5100 *namep = bfd_elf_string_from_elf_section (input_bfd,
5101 symtab_hdr->sh_link,
5104 *namep = bfd_section_name (input_bfd, sec);
5106 target_is_16_bit_code_p = ELF_ST_IS_MIPS16 (sym->st_other);
5107 target_is_micromips_code_p = ELF_ST_IS_MICROMIPS (sym->st_other);
5111 /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ? */
5113 /* For global symbols we look up the symbol in the hash-table. */
5114 h = ((struct mips_elf_link_hash_entry *)
5115 elf_sym_hashes (input_bfd) [r_symndx - extsymoff]);
5116 /* Find the real hash-table entry for this symbol. */
5117 while (h->root.root.type == bfd_link_hash_indirect
5118 || h->root.root.type == bfd_link_hash_warning)
5119 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
5121 /* Record the name of this symbol, for our caller. */
5122 *namep = h->root.root.root.string;
5124 /* See if this is the special _gp_disp symbol. Note that such a
5125 symbol must always be a global symbol. */
5126 if (strcmp (*namep, "_gp_disp") == 0
5127 && ! NEWABI_P (input_bfd))
5129 /* Relocations against _gp_disp are permitted only with
5130 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
5131 if (!hi16_reloc_p (r_type) && !lo16_reloc_p (r_type))
5132 return bfd_reloc_notsupported;
5136 /* See if this is the special _gp symbol. Note that such a
5137 symbol must always be a global symbol. */
5138 else if (strcmp (*namep, "__gnu_local_gp") == 0)
5139 gnu_local_gp_p = TRUE;
5142 /* If this symbol is defined, calculate its address. Note that
5143 _gp_disp is a magic symbol, always implicitly defined by the
5144 linker, so it's inappropriate to check to see whether or not
5146 else if ((h->root.root.type == bfd_link_hash_defined
5147 || h->root.root.type == bfd_link_hash_defweak)
5148 && h->root.root.u.def.section)
5150 sec = h->root.root.u.def.section;
5151 if (sec->output_section)
5152 symbol = (h->root.root.u.def.value
5153 + sec->output_section->vma
5154 + sec->output_offset);
5156 symbol = h->root.root.u.def.value;
5158 else if (h->root.root.type == bfd_link_hash_undefweak)
5159 /* We allow relocations against undefined weak symbols, giving
5160 it the value zero, so that you can undefined weak functions
5161 and check to see if they exist by looking at their
5164 else if (info->unresolved_syms_in_objects == RM_IGNORE
5165 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
5167 else if (strcmp (*namep, SGI_COMPAT (input_bfd)
5168 ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING") == 0)
5170 /* If this is a dynamic link, we should have created a
5171 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
5172 in in _bfd_mips_elf_create_dynamic_sections.
5173 Otherwise, we should define the symbol with a value of 0.
5174 FIXME: It should probably get into the symbol table
5176 BFD_ASSERT (! info->shared);
5177 BFD_ASSERT (bfd_get_section_by_name (abfd, ".dynamic") == NULL);
5180 else if (ELF_MIPS_IS_OPTIONAL (h->root.other))
5182 /* This is an optional symbol - an Irix specific extension to the
5183 ELF spec. Ignore it for now.
5184 XXX - FIXME - there is more to the spec for OPTIONAL symbols
5185 than simply ignoring them, but we do not handle this for now.
5186 For information see the "64-bit ELF Object File Specification"
5187 which is available from here:
5188 http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf */
5191 else if ((*info->callbacks->undefined_symbol)
5192 (info, h->root.root.root.string, input_bfd,
5193 input_section, relocation->r_offset,
5194 (info->unresolved_syms_in_objects == RM_GENERATE_ERROR)
5195 || ELF_ST_VISIBILITY (h->root.other)))
5197 return bfd_reloc_undefined;
5201 return bfd_reloc_notsupported;
5204 target_is_16_bit_code_p = ELF_ST_IS_MIPS16 (h->root.other);
5205 /* If the output section is the PLT section,
5206 then the target is not microMIPS. */
5207 target_is_micromips_code_p = (htab->splt != sec
5208 && ELF_ST_IS_MICROMIPS (h->root.other));
5211 /* If this is a reference to a 16-bit function with a stub, we need
5212 to redirect the relocation to the stub unless:
5214 (a) the relocation is for a MIPS16 JAL;
5216 (b) the relocation is for a MIPS16 PIC call, and there are no
5217 non-MIPS16 uses of the GOT slot; or
5219 (c) the section allows direct references to MIPS16 functions. */
5220 if (r_type != R_MIPS16_26
5221 && !info->relocatable
5223 && h->fn_stub != NULL
5224 && (r_type != R_MIPS16_CALL16 || h->need_fn_stub))
5226 && elf_tdata (input_bfd)->local_stubs != NULL
5227 && elf_tdata (input_bfd)->local_stubs[r_symndx] != NULL))
5228 && !section_allows_mips16_refs_p (input_section))
5230 /* This is a 32- or 64-bit call to a 16-bit function. We should
5231 have already noticed that we were going to need the
5235 sec = elf_tdata (input_bfd)->local_stubs[r_symndx];
5240 BFD_ASSERT (h->need_fn_stub);
5243 /* If a LA25 header for the stub itself exists, point to the
5244 prepended LUI/ADDIU sequence. */
5245 sec = h->la25_stub->stub_section;
5246 value = h->la25_stub->offset;
5255 symbol = sec->output_section->vma + sec->output_offset + value;
5256 /* The target is 16-bit, but the stub isn't. */
5257 target_is_16_bit_code_p = FALSE;
5259 /* If this is a 16-bit call to a 32- or 64-bit function with a stub, we
5260 need to redirect the call to the stub. Note that we specifically
5261 exclude R_MIPS16_CALL16 from this behavior; indirect calls should
5262 use an indirect stub instead. */
5263 else if (r_type == R_MIPS16_26 && !info->relocatable
5264 && ((h != NULL && (h->call_stub != NULL || h->call_fp_stub != NULL))
5266 && elf_tdata (input_bfd)->local_call_stubs != NULL
5267 && elf_tdata (input_bfd)->local_call_stubs[r_symndx] != NULL))
5268 && !target_is_16_bit_code_p)
5271 sec = elf_tdata (input_bfd)->local_call_stubs[r_symndx];
5274 /* If both call_stub and call_fp_stub are defined, we can figure
5275 out which one to use by checking which one appears in the input
5277 if (h->call_stub != NULL && h->call_fp_stub != NULL)
5282 for (o = input_bfd->sections; o != NULL; o = o->next)
5284 if (CALL_FP_STUB_P (bfd_get_section_name (input_bfd, o)))
5286 sec = h->call_fp_stub;
5293 else if (h->call_stub != NULL)
5296 sec = h->call_fp_stub;
5299 BFD_ASSERT (sec->size > 0);
5300 symbol = sec->output_section->vma + sec->output_offset;
5302 /* If this is a direct call to a PIC function, redirect to the
5304 else if (h != NULL && h->la25_stub
5305 && mips_elf_relocation_needs_la25_stub (input_bfd, r_type,
5306 target_is_16_bit_code_p))
5307 symbol = (h->la25_stub->stub_section->output_section->vma
5308 + h->la25_stub->stub_section->output_offset
5309 + h->la25_stub->offset);
5311 /* Make sure MIPS16 and microMIPS are not used together. */
5312 if ((r_type == R_MIPS16_26 && target_is_micromips_code_p)
5313 || (micromips_branch_reloc_p (r_type) && target_is_16_bit_code_p))
5315 (*_bfd_error_handler)
5316 (_("MIPS16 and microMIPS functions cannot call each other"));
5317 return bfd_reloc_notsupported;
5320 /* Calls from 16-bit code to 32-bit code and vice versa require the
5321 mode change. However, we can ignore calls to undefined weak symbols,
5322 which should never be executed at runtime. This exception is important
5323 because the assembly writer may have "known" that any definition of the
5324 symbol would be 16-bit code, and that direct jumps were therefore
5326 *cross_mode_jump_p = (!info->relocatable
5327 && !(h && h->root.root.type == bfd_link_hash_undefweak)
5328 && ((r_type == R_MIPS16_26 && !target_is_16_bit_code_p)
5329 || (r_type == R_MICROMIPS_26_S1
5330 && !target_is_micromips_code_p)
5331 || ((r_type == R_MIPS_26 || r_type == R_MIPS_JALR)
5332 && (target_is_16_bit_code_p
5333 || target_is_micromips_code_p))));
5335 local_p = (h == NULL
5336 || (h->got_only_for_calls
5337 ? SYMBOL_CALLS_LOCAL (info, &h->root)
5338 : SYMBOL_REFERENCES_LOCAL (info, &h->root)));
5340 gp0 = _bfd_get_gp_value (input_bfd);
5341 gp = _bfd_get_gp_value (abfd);
5343 gp += mips_elf_adjust_gp (abfd, htab->got_info, input_bfd);
5348 /* Global R_MIPS_GOT_PAGE/R_MICROMIPS_GOT_PAGE relocations are equivalent
5349 to R_MIPS_GOT_DISP/R_MICROMIPS_GOT_DISP. The addend is applied by the
5350 corresponding R_MIPS_GOT_OFST/R_MICROMIPS_GOT_OFST. */
5351 if (got_page_reloc_p (r_type) && !local_p)
5353 r_type = (micromips_reloc_p (r_type)
5354 ? R_MICROMIPS_GOT_DISP : R_MIPS_GOT_DISP);
5358 /* If we haven't already determined the GOT offset, and we're going
5359 to need it, get it now. */
5362 case R_MIPS16_CALL16:
5363 case R_MIPS16_GOT16:
5366 case R_MIPS_GOT_DISP:
5367 case R_MIPS_GOT_HI16:
5368 case R_MIPS_CALL_HI16:
5369 case R_MIPS_GOT_LO16:
5370 case R_MIPS_CALL_LO16:
5371 case R_MICROMIPS_CALL16:
5372 case R_MICROMIPS_GOT16:
5373 case R_MICROMIPS_GOT_DISP:
5374 case R_MICROMIPS_GOT_HI16:
5375 case R_MICROMIPS_CALL_HI16:
5376 case R_MICROMIPS_GOT_LO16:
5377 case R_MICROMIPS_CALL_LO16:
5379 case R_MIPS_TLS_GOTTPREL:
5380 case R_MIPS_TLS_LDM:
5381 case R_MIPS16_TLS_GD:
5382 case R_MIPS16_TLS_GOTTPREL:
5383 case R_MIPS16_TLS_LDM:
5384 case R_MICROMIPS_TLS_GD:
5385 case R_MICROMIPS_TLS_GOTTPREL:
5386 case R_MICROMIPS_TLS_LDM:
5387 /* Find the index into the GOT where this value is located. */
5388 if (tls_ldm_reloc_p (r_type))
5390 g = mips_elf_local_got_index (abfd, input_bfd, info,
5391 0, 0, NULL, r_type);
5393 return bfd_reloc_outofrange;
5397 /* On VxWorks, CALL relocations should refer to the .got.plt
5398 entry, which is initialized to point at the PLT stub. */
5399 if (htab->is_vxworks
5400 && (call_hi16_reloc_p (r_type)
5401 || call_lo16_reloc_p (r_type)
5402 || call16_reloc_p (r_type)))
5404 BFD_ASSERT (addend == 0);
5405 BFD_ASSERT (h->root.needs_plt);
5406 g = mips_elf_gotplt_index (info, &h->root);
5410 BFD_ASSERT (addend == 0);
5411 g = mips_elf_global_got_index (dynobj, input_bfd,
5412 &h->root, r_type, info);
5413 if (h->tls_type == GOT_NORMAL
5414 && !elf_hash_table (info)->dynamic_sections_created)
5415 /* This is a static link. We must initialize the GOT entry. */
5416 MIPS_ELF_PUT_WORD (dynobj, symbol, htab->sgot->contents + g);
5419 else if (!htab->is_vxworks
5420 && (call16_reloc_p (r_type) || got16_reloc_p (r_type)))
5421 /* The calculation below does not involve "g". */
5425 g = mips_elf_local_got_index (abfd, input_bfd, info,
5426 symbol + addend, r_symndx, h, r_type);
5428 return bfd_reloc_outofrange;
5431 /* Convert GOT indices to actual offsets. */
5432 g = mips_elf_got_offset_from_index (info, abfd, input_bfd, g);
5436 /* Relocations against the VxWorks __GOTT_BASE__ and __GOTT_INDEX__
5437 symbols are resolved by the loader. Add them to .rela.dyn. */
5438 if (h != NULL && is_gott_symbol (info, &h->root))
5440 Elf_Internal_Rela outrel;
5444 s = mips_elf_rel_dyn_section (info, FALSE);
5445 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
5447 outrel.r_offset = (input_section->output_section->vma
5448 + input_section->output_offset
5449 + relocation->r_offset);
5450 outrel.r_info = ELF32_R_INFO (h->root.dynindx, r_type);
5451 outrel.r_addend = addend;
5452 bfd_elf32_swap_reloca_out (abfd, &outrel, loc);
5454 /* If we've written this relocation for a readonly section,
5455 we need to set DF_TEXTREL again, so that we do not delete the
5457 if (MIPS_ELF_READONLY_SECTION (input_section))
5458 info->flags |= DF_TEXTREL;
5461 return bfd_reloc_ok;
5464 /* Figure out what kind of relocation is being performed. */
5468 return bfd_reloc_continue;
5471 value = symbol + _bfd_mips_elf_sign_extend (addend, 16);
5472 overflowed_p = mips_elf_overflow_p (value, 16);
5479 || (htab->root.dynamic_sections_created
5481 && h->root.def_dynamic
5482 && !h->root.def_regular
5483 && !h->has_static_relocs))
5484 && r_symndx != STN_UNDEF
5486 || h->root.root.type != bfd_link_hash_undefweak
5487 || ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
5488 && (input_section->flags & SEC_ALLOC) != 0)
5490 /* If we're creating a shared library, then we can't know
5491 where the symbol will end up. So, we create a relocation
5492 record in the output, and leave the job up to the dynamic
5493 linker. We must do the same for executable references to
5494 shared library symbols, unless we've decided to use copy
5495 relocs or PLTs instead. */
5497 if (!mips_elf_create_dynamic_relocation (abfd,
5505 return bfd_reloc_undefined;
5509 if (r_type != R_MIPS_REL32)
5510 value = symbol + addend;
5514 value &= howto->dst_mask;
5518 value = symbol + addend - p;
5519 value &= howto->dst_mask;
5523 /* The calculation for R_MIPS16_26 is just the same as for an
5524 R_MIPS_26. It's only the storage of the relocated field into
5525 the output file that's different. That's handled in
5526 mips_elf_perform_relocation. So, we just fall through to the
5527 R_MIPS_26 case here. */
5529 case R_MICROMIPS_26_S1:
5533 /* Make sure the target of JALX is word-aligned. Bit 0 must be
5534 the correct ISA mode selector and bit 1 must be 0. */
5535 if (*cross_mode_jump_p && (symbol & 3) != (r_type == R_MIPS_26))
5536 return bfd_reloc_outofrange;
5538 /* Shift is 2, unusually, for microMIPS JALX. */
5539 shift = (!*cross_mode_jump_p && r_type == R_MICROMIPS_26_S1) ? 1 : 2;
5542 value = addend | ((p + 4) & (0xfc000000 << shift));
5544 value = _bfd_mips_elf_sign_extend (addend, 26 + shift);
5545 value = (value + symbol) >> shift;
5546 if (!was_local_p && h->root.root.type != bfd_link_hash_undefweak)
5547 overflowed_p = (value >> 26) != ((p + 4) >> (26 + shift));
5548 value &= howto->dst_mask;
5552 case R_MIPS_TLS_DTPREL_HI16:
5553 case R_MIPS16_TLS_DTPREL_HI16:
5554 case R_MICROMIPS_TLS_DTPREL_HI16:
5555 value = (mips_elf_high (addend + symbol - dtprel_base (info))
5559 case R_MIPS_TLS_DTPREL_LO16:
5560 case R_MIPS_TLS_DTPREL32:
5561 case R_MIPS_TLS_DTPREL64:
5562 case R_MIPS16_TLS_DTPREL_LO16:
5563 case R_MICROMIPS_TLS_DTPREL_LO16:
5564 value = (symbol + addend - dtprel_base (info)) & howto->dst_mask;
5567 case R_MIPS_TLS_TPREL_HI16:
5568 case R_MIPS16_TLS_TPREL_HI16:
5569 case R_MICROMIPS_TLS_TPREL_HI16:
5570 value = (mips_elf_high (addend + symbol - tprel_base (info))
5574 case R_MIPS_TLS_TPREL_LO16:
5575 case R_MIPS_TLS_TPREL32:
5576 case R_MIPS_TLS_TPREL64:
5577 case R_MIPS16_TLS_TPREL_LO16:
5578 case R_MICROMIPS_TLS_TPREL_LO16:
5579 value = (symbol + addend - tprel_base (info)) & howto->dst_mask;
5584 case R_MICROMIPS_HI16:
5587 value = mips_elf_high (addend + symbol);
5588 value &= howto->dst_mask;
5592 /* For MIPS16 ABI code we generate this sequence
5593 0: li $v0,%hi(_gp_disp)
5594 4: addiupc $v1,%lo(_gp_disp)
5598 So the offsets of hi and lo relocs are the same, but the
5599 base $pc is that used by the ADDIUPC instruction at $t9 + 4.
5600 ADDIUPC clears the low two bits of the instruction address,
5601 so the base is ($t9 + 4) & ~3. */
5602 if (r_type == R_MIPS16_HI16)
5603 value = mips_elf_high (addend + gp - ((p + 4) & ~(bfd_vma) 0x3));
5604 /* The microMIPS .cpload sequence uses the same assembly
5605 instructions as the traditional psABI version, but the
5606 incoming $t9 has the low bit set. */
5607 else if (r_type == R_MICROMIPS_HI16)
5608 value = mips_elf_high (addend + gp - p - 1);
5610 value = mips_elf_high (addend + gp - p);
5611 overflowed_p = mips_elf_overflow_p (value, 16);
5617 case R_MICROMIPS_LO16:
5618 case R_MICROMIPS_HI0_LO16:
5620 value = (symbol + addend) & howto->dst_mask;
5623 /* See the comment for R_MIPS16_HI16 above for the reason
5624 for this conditional. */
5625 if (r_type == R_MIPS16_LO16)
5626 value = addend + gp - (p & ~(bfd_vma) 0x3);
5627 else if (r_type == R_MICROMIPS_LO16
5628 || r_type == R_MICROMIPS_HI0_LO16)
5629 value = addend + gp - p + 3;
5631 value = addend + gp - p + 4;
5632 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
5633 for overflow. But, on, say, IRIX5, relocations against
5634 _gp_disp are normally generated from the .cpload
5635 pseudo-op. It generates code that normally looks like
5638 lui $gp,%hi(_gp_disp)
5639 addiu $gp,$gp,%lo(_gp_disp)
5642 Here $t9 holds the address of the function being called,
5643 as required by the MIPS ELF ABI. The R_MIPS_LO16
5644 relocation can easily overflow in this situation, but the
5645 R_MIPS_HI16 relocation will handle the overflow.
5646 Therefore, we consider this a bug in the MIPS ABI, and do
5647 not check for overflow here. */
5651 case R_MIPS_LITERAL:
5652 case R_MICROMIPS_LITERAL:
5653 /* Because we don't merge literal sections, we can handle this
5654 just like R_MIPS_GPREL16. In the long run, we should merge
5655 shared literals, and then we will need to additional work
5660 case R_MIPS16_GPREL:
5661 /* The R_MIPS16_GPREL performs the same calculation as
5662 R_MIPS_GPREL16, but stores the relocated bits in a different
5663 order. We don't need to do anything special here; the
5664 differences are handled in mips_elf_perform_relocation. */
5665 case R_MIPS_GPREL16:
5666 case R_MICROMIPS_GPREL7_S2:
5667 case R_MICROMIPS_GPREL16:
5668 /* Only sign-extend the addend if it was extracted from the
5669 instruction. If the addend was separate, leave it alone,
5670 otherwise we may lose significant bits. */
5671 if (howto->partial_inplace)
5672 addend = _bfd_mips_elf_sign_extend (addend, 16);
5673 value = symbol + addend - gp;
5674 /* If the symbol was local, any earlier relocatable links will
5675 have adjusted its addend with the gp offset, so compensate
5676 for that now. Don't do it for symbols forced local in this
5677 link, though, since they won't have had the gp offset applied
5681 overflowed_p = mips_elf_overflow_p (value, 16);
5684 case R_MIPS16_GOT16:
5685 case R_MIPS16_CALL16:
5688 case R_MICROMIPS_GOT16:
5689 case R_MICROMIPS_CALL16:
5690 /* VxWorks does not have separate local and global semantics for
5691 R_MIPS*_GOT16; every relocation evaluates to "G". */
5692 if (!htab->is_vxworks && local_p)
5694 value = mips_elf_got16_entry (abfd, input_bfd, info,
5695 symbol + addend, !was_local_p);
5696 if (value == MINUS_ONE)
5697 return bfd_reloc_outofrange;
5699 = mips_elf_got_offset_from_index (info, abfd, input_bfd, value);
5700 overflowed_p = mips_elf_overflow_p (value, 16);
5707 case R_MIPS_TLS_GOTTPREL:
5708 case R_MIPS_TLS_LDM:
5709 case R_MIPS_GOT_DISP:
5710 case R_MIPS16_TLS_GD:
5711 case R_MIPS16_TLS_GOTTPREL:
5712 case R_MIPS16_TLS_LDM:
5713 case R_MICROMIPS_TLS_GD:
5714 case R_MICROMIPS_TLS_GOTTPREL:
5715 case R_MICROMIPS_TLS_LDM:
5716 case R_MICROMIPS_GOT_DISP:
5718 overflowed_p = mips_elf_overflow_p (value, 16);
5721 case R_MIPS_GPREL32:
5722 value = (addend + symbol + gp0 - gp);
5724 value &= howto->dst_mask;
5728 case R_MIPS_GNU_REL16_S2:
5729 value = symbol + _bfd_mips_elf_sign_extend (addend, 18) - p;
5730 overflowed_p = mips_elf_overflow_p (value, 18);
5731 value >>= howto->rightshift;
5732 value &= howto->dst_mask;
5735 case R_MICROMIPS_PC7_S1:
5736 value = symbol + _bfd_mips_elf_sign_extend (addend, 8) - p;
5737 overflowed_p = mips_elf_overflow_p (value, 8);
5738 value >>= howto->rightshift;
5739 value &= howto->dst_mask;
5742 case R_MICROMIPS_PC10_S1:
5743 value = symbol + _bfd_mips_elf_sign_extend (addend, 11) - p;
5744 overflowed_p = mips_elf_overflow_p (value, 11);
5745 value >>= howto->rightshift;
5746 value &= howto->dst_mask;
5749 case R_MICROMIPS_PC16_S1:
5750 value = symbol + _bfd_mips_elf_sign_extend (addend, 17) - p;
5751 overflowed_p = mips_elf_overflow_p (value, 17);
5752 value >>= howto->rightshift;
5753 value &= howto->dst_mask;
5756 case R_MICROMIPS_PC23_S2:
5757 value = symbol + _bfd_mips_elf_sign_extend (addend, 25) - ((p | 3) ^ 3);
5758 overflowed_p = mips_elf_overflow_p (value, 25);
5759 value >>= howto->rightshift;
5760 value &= howto->dst_mask;
5763 case R_MIPS_GOT_HI16:
5764 case R_MIPS_CALL_HI16:
5765 case R_MICROMIPS_GOT_HI16:
5766 case R_MICROMIPS_CALL_HI16:
5767 /* We're allowed to handle these two relocations identically.
5768 The dynamic linker is allowed to handle the CALL relocations
5769 differently by creating a lazy evaluation stub. */
5771 value = mips_elf_high (value);
5772 value &= howto->dst_mask;
5775 case R_MIPS_GOT_LO16:
5776 case R_MIPS_CALL_LO16:
5777 case R_MICROMIPS_GOT_LO16:
5778 case R_MICROMIPS_CALL_LO16:
5779 value = g & howto->dst_mask;
5782 case R_MIPS_GOT_PAGE:
5783 case R_MICROMIPS_GOT_PAGE:
5784 value = mips_elf_got_page (abfd, input_bfd, info, symbol + addend, NULL);
5785 if (value == MINUS_ONE)
5786 return bfd_reloc_outofrange;
5787 value = mips_elf_got_offset_from_index (info, abfd, input_bfd, value);
5788 overflowed_p = mips_elf_overflow_p (value, 16);
5791 case R_MIPS_GOT_OFST:
5792 case R_MICROMIPS_GOT_OFST:
5794 mips_elf_got_page (abfd, input_bfd, info, symbol + addend, &value);
5797 overflowed_p = mips_elf_overflow_p (value, 16);
5801 case R_MICROMIPS_SUB:
5802 value = symbol - addend;
5803 value &= howto->dst_mask;
5807 case R_MICROMIPS_HIGHER:
5808 value = mips_elf_higher (addend + symbol);
5809 value &= howto->dst_mask;
5812 case R_MIPS_HIGHEST:
5813 case R_MICROMIPS_HIGHEST:
5814 value = mips_elf_highest (addend + symbol);
5815 value &= howto->dst_mask;
5818 case R_MIPS_SCN_DISP:
5819 case R_MICROMIPS_SCN_DISP:
5820 value = symbol + addend - sec->output_offset;
5821 value &= howto->dst_mask;
5825 case R_MICROMIPS_JALR:
5826 /* This relocation is only a hint. In some cases, we optimize
5827 it into a bal instruction. But we don't try to optimize
5828 when the symbol does not resolve locally. */
5829 if (h != NULL && !SYMBOL_CALLS_LOCAL (info, &h->root))
5830 return bfd_reloc_continue;
5831 value = symbol + addend;
5835 case R_MIPS_GNU_VTINHERIT:
5836 case R_MIPS_GNU_VTENTRY:
5837 /* We don't do anything with these at present. */
5838 return bfd_reloc_continue;
5841 /* An unrecognized relocation type. */
5842 return bfd_reloc_notsupported;
5845 /* Store the VALUE for our caller. */
5847 return overflowed_p ? bfd_reloc_overflow : bfd_reloc_ok;
5850 /* Obtain the field relocated by RELOCATION. */
5853 mips_elf_obtain_contents (reloc_howto_type *howto,
5854 const Elf_Internal_Rela *relocation,
5855 bfd *input_bfd, bfd_byte *contents)
5858 bfd_byte *location = contents + relocation->r_offset;
5860 /* Obtain the bytes. */
5861 x = bfd_get ((8 * bfd_get_reloc_size (howto)), input_bfd, location);
5866 /* It has been determined that the result of the RELOCATION is the
5867 VALUE. Use HOWTO to place VALUE into the output file at the
5868 appropriate position. The SECTION is the section to which the
5870 CROSS_MODE_JUMP_P is true if the relocation field
5871 is a MIPS16 or microMIPS jump to standard MIPS code, or vice versa.
5873 Returns FALSE if anything goes wrong. */
5876 mips_elf_perform_relocation (struct bfd_link_info *info,
5877 reloc_howto_type *howto,
5878 const Elf_Internal_Rela *relocation,
5879 bfd_vma value, bfd *input_bfd,
5880 asection *input_section, bfd_byte *contents,
5881 bfd_boolean cross_mode_jump_p)
5885 int r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
5887 /* Figure out where the relocation is occurring. */
5888 location = contents + relocation->r_offset;
5890 _bfd_mips_elf_reloc_unshuffle (input_bfd, r_type, FALSE, location);
5892 /* Obtain the current value. */
5893 x = mips_elf_obtain_contents (howto, relocation, input_bfd, contents);
5895 /* Clear the field we are setting. */
5896 x &= ~howto->dst_mask;
5898 /* Set the field. */
5899 x |= (value & howto->dst_mask);
5901 /* If required, turn JAL into JALX. */
5902 if (cross_mode_jump_p && jal_reloc_p (r_type))
5905 bfd_vma opcode = x >> 26;
5906 bfd_vma jalx_opcode;
5908 /* Check to see if the opcode is already JAL or JALX. */
5909 if (r_type == R_MIPS16_26)
5911 ok = ((opcode == 0x6) || (opcode == 0x7));
5914 else if (r_type == R_MICROMIPS_26_S1)
5916 ok = ((opcode == 0x3d) || (opcode == 0x3c));
5921 ok = ((opcode == 0x3) || (opcode == 0x1d));
5925 /* If the opcode is not JAL or JALX, there's a problem. We cannot
5926 convert J or JALS to JALX. */
5929 (*_bfd_error_handler)
5930 (_("%B: %A+0x%lx: Unsupported jump between ISA modes; consider recompiling with interlinking enabled."),
5933 (unsigned long) relocation->r_offset);
5934 bfd_set_error (bfd_error_bad_value);
5938 /* Make this the JALX opcode. */
5939 x = (x & ~(0x3f << 26)) | (jalx_opcode << 26);
5942 /* Try converting JAL to BAL and J(AL)R to B(AL), if the target is in
5944 if (!info->relocatable
5945 && !cross_mode_jump_p
5946 && ((JAL_TO_BAL_P (input_bfd)
5947 && r_type == R_MIPS_26
5948 && (x >> 26) == 0x3) /* jal addr */
5949 || (JALR_TO_BAL_P (input_bfd)
5950 && r_type == R_MIPS_JALR
5951 && x == 0x0320f809) /* jalr t9 */
5952 || (JR_TO_B_P (input_bfd)
5953 && r_type == R_MIPS_JALR
5954 && x == 0x03200008))) /* jr t9 */
5960 addr = (input_section->output_section->vma
5961 + input_section->output_offset
5962 + relocation->r_offset
5964 if (r_type == R_MIPS_26)
5965 dest = (value << 2) | ((addr >> 28) << 28);
5969 if (off <= 0x1ffff && off >= -0x20000)
5971 if (x == 0x03200008) /* jr t9 */
5972 x = 0x10000000 | (((bfd_vma) off >> 2) & 0xffff); /* b addr */
5974 x = 0x04110000 | (((bfd_vma) off >> 2) & 0xffff); /* bal addr */
5978 /* Put the value into the output. */
5979 bfd_put (8 * bfd_get_reloc_size (howto), input_bfd, x, location);
5981 _bfd_mips_elf_reloc_shuffle (input_bfd, r_type, !info->relocatable,
5987 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
5988 is the original relocation, which is now being transformed into a
5989 dynamic relocation. The ADDENDP is adjusted if necessary; the
5990 caller should store the result in place of the original addend. */
5993 mips_elf_create_dynamic_relocation (bfd *output_bfd,
5994 struct bfd_link_info *info,
5995 const Elf_Internal_Rela *rel,
5996 struct mips_elf_link_hash_entry *h,
5997 asection *sec, bfd_vma symbol,
5998 bfd_vma *addendp, asection *input_section)
6000 Elf_Internal_Rela outrel[3];
6005 bfd_boolean defined_p;
6006 struct mips_elf_link_hash_table *htab;
6008 htab = mips_elf_hash_table (info);
6009 BFD_ASSERT (htab != NULL);
6011 r_type = ELF_R_TYPE (output_bfd, rel->r_info);
6012 dynobj = elf_hash_table (info)->dynobj;
6013 sreloc = mips_elf_rel_dyn_section (info, FALSE);
6014 BFD_ASSERT (sreloc != NULL);
6015 BFD_ASSERT (sreloc->contents != NULL);
6016 BFD_ASSERT (sreloc->reloc_count * MIPS_ELF_REL_SIZE (output_bfd)
6019 outrel[0].r_offset =
6020 _bfd_elf_section_offset (output_bfd, info, input_section, rel[0].r_offset);
6021 if (ABI_64_P (output_bfd))
6023 outrel[1].r_offset =
6024 _bfd_elf_section_offset (output_bfd, info, input_section, rel[1].r_offset);
6025 outrel[2].r_offset =
6026 _bfd_elf_section_offset (output_bfd, info, input_section, rel[2].r_offset);
6029 if (outrel[0].r_offset == MINUS_ONE)
6030 /* The relocation field has been deleted. */
6033 if (outrel[0].r_offset == MINUS_TWO)
6035 /* The relocation field has been converted into a relative value of
6036 some sort. Functions like _bfd_elf_write_section_eh_frame expect
6037 the field to be fully relocated, so add in the symbol's value. */
6042 /* We must now calculate the dynamic symbol table index to use
6043 in the relocation. */
6044 if (h != NULL && ! SYMBOL_REFERENCES_LOCAL (info, &h->root))
6046 BFD_ASSERT (htab->is_vxworks || h->global_got_area != GGA_NONE);
6047 indx = h->root.dynindx;
6048 if (SGI_COMPAT (output_bfd))
6049 defined_p = h->root.def_regular;
6051 /* ??? glibc's ld.so just adds the final GOT entry to the
6052 relocation field. It therefore treats relocs against
6053 defined symbols in the same way as relocs against
6054 undefined symbols. */
6059 if (sec != NULL && bfd_is_abs_section (sec))
6061 else if (sec == NULL || sec->owner == NULL)
6063 bfd_set_error (bfd_error_bad_value);
6068 indx = elf_section_data (sec->output_section)->dynindx;
6071 asection *osec = htab->root.text_index_section;
6072 indx = elf_section_data (osec)->dynindx;
6078 /* Instead of generating a relocation using the section
6079 symbol, we may as well make it a fully relative
6080 relocation. We want to avoid generating relocations to
6081 local symbols because we used to generate them
6082 incorrectly, without adding the original symbol value,
6083 which is mandated by the ABI for section symbols. In
6084 order to give dynamic loaders and applications time to
6085 phase out the incorrect use, we refrain from emitting
6086 section-relative relocations. It's not like they're
6087 useful, after all. This should be a bit more efficient
6089 /* ??? Although this behavior is compatible with glibc's ld.so,
6090 the ABI says that relocations against STN_UNDEF should have
6091 a symbol value of 0. Irix rld honors this, so relocations
6092 against STN_UNDEF have no effect. */
6093 if (!SGI_COMPAT (output_bfd))
6098 /* If the relocation was previously an absolute relocation and
6099 this symbol will not be referred to by the relocation, we must
6100 adjust it by the value we give it in the dynamic symbol table.
6101 Otherwise leave the job up to the dynamic linker. */
6102 if (defined_p && r_type != R_MIPS_REL32)
6105 if (htab->is_vxworks)
6106 /* VxWorks uses non-relative relocations for this. */
6107 outrel[0].r_info = ELF32_R_INFO (indx, R_MIPS_32);
6109 /* The relocation is always an REL32 relocation because we don't
6110 know where the shared library will wind up at load-time. */
6111 outrel[0].r_info = ELF_R_INFO (output_bfd, (unsigned long) indx,
6114 /* For strict adherence to the ABI specification, we should
6115 generate a R_MIPS_64 relocation record by itself before the
6116 _REL32/_64 record as well, such that the addend is read in as
6117 a 64-bit value (REL32 is a 32-bit relocation, after all).
6118 However, since none of the existing ELF64 MIPS dynamic
6119 loaders seems to care, we don't waste space with these
6120 artificial relocations. If this turns out to not be true,
6121 mips_elf_allocate_dynamic_relocation() should be tweaked so
6122 as to make room for a pair of dynamic relocations per
6123 invocation if ABI_64_P, and here we should generate an
6124 additional relocation record with R_MIPS_64 by itself for a
6125 NULL symbol before this relocation record. */
6126 outrel[1].r_info = ELF_R_INFO (output_bfd, 0,
6127 ABI_64_P (output_bfd)
6130 outrel[2].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_NONE);
6132 /* Adjust the output offset of the relocation to reference the
6133 correct location in the output file. */
6134 outrel[0].r_offset += (input_section->output_section->vma
6135 + input_section->output_offset);
6136 outrel[1].r_offset += (input_section->output_section->vma
6137 + input_section->output_offset);
6138 outrel[2].r_offset += (input_section->output_section->vma
6139 + input_section->output_offset);
6141 /* Put the relocation back out. We have to use the special
6142 relocation outputter in the 64-bit case since the 64-bit
6143 relocation format is non-standard. */
6144 if (ABI_64_P (output_bfd))
6146 (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
6147 (output_bfd, &outrel[0],
6149 + sreloc->reloc_count * sizeof (Elf64_Mips_External_Rel)));
6151 else if (htab->is_vxworks)
6153 /* VxWorks uses RELA rather than REL dynamic relocations. */
6154 outrel[0].r_addend = *addendp;
6155 bfd_elf32_swap_reloca_out
6156 (output_bfd, &outrel[0],
6158 + sreloc->reloc_count * sizeof (Elf32_External_Rela)));
6161 bfd_elf32_swap_reloc_out
6162 (output_bfd, &outrel[0],
6163 (sreloc->contents + sreloc->reloc_count * sizeof (Elf32_External_Rel)));
6165 /* We've now added another relocation. */
6166 ++sreloc->reloc_count;
6168 /* Make sure the output section is writable. The dynamic linker
6169 will be writing to it. */
6170 elf_section_data (input_section->output_section)->this_hdr.sh_flags
6173 /* On IRIX5, make an entry of compact relocation info. */
6174 if (IRIX_COMPAT (output_bfd) == ict_irix5)
6176 asection *scpt = bfd_get_linker_section (dynobj, ".compact_rel");
6181 Elf32_crinfo cptrel;
6183 mips_elf_set_cr_format (cptrel, CRF_MIPS_LONG);
6184 cptrel.vaddr = (rel->r_offset
6185 + input_section->output_section->vma
6186 + input_section->output_offset);
6187 if (r_type == R_MIPS_REL32)
6188 mips_elf_set_cr_type (cptrel, CRT_MIPS_REL32);
6190 mips_elf_set_cr_type (cptrel, CRT_MIPS_WORD);
6191 mips_elf_set_cr_dist2to (cptrel, 0);
6192 cptrel.konst = *addendp;
6194 cr = (scpt->contents
6195 + sizeof (Elf32_External_compact_rel));
6196 mips_elf_set_cr_relvaddr (cptrel, 0);
6197 bfd_elf32_swap_crinfo_out (output_bfd, &cptrel,
6198 ((Elf32_External_crinfo *) cr
6199 + scpt->reloc_count));
6200 ++scpt->reloc_count;
6204 /* If we've written this relocation for a readonly section,
6205 we need to set DF_TEXTREL again, so that we do not delete the
6207 if (MIPS_ELF_READONLY_SECTION (input_section))
6208 info->flags |= DF_TEXTREL;
6213 /* Return the MACH for a MIPS e_flags value. */
6216 _bfd_elf_mips_mach (flagword flags)
6218 switch (flags & EF_MIPS_MACH)
6220 case E_MIPS_MACH_3900:
6221 return bfd_mach_mips3900;
6223 case E_MIPS_MACH_4010:
6224 return bfd_mach_mips4010;
6226 case E_MIPS_MACH_4100:
6227 return bfd_mach_mips4100;
6229 case E_MIPS_MACH_4111:
6230 return bfd_mach_mips4111;
6232 case E_MIPS_MACH_4120:
6233 return bfd_mach_mips4120;
6235 case E_MIPS_MACH_4650:
6236 return bfd_mach_mips4650;
6238 case E_MIPS_MACH_5400:
6239 return bfd_mach_mips5400;
6241 case E_MIPS_MACH_5500:
6242 return bfd_mach_mips5500;
6244 case E_MIPS_MACH_5900:
6245 return bfd_mach_mips5900;
6247 case E_MIPS_MACH_9000:
6248 return bfd_mach_mips9000;
6250 case E_MIPS_MACH_SB1:
6251 return bfd_mach_mips_sb1;
6253 case E_MIPS_MACH_LS2E:
6254 return bfd_mach_mips_loongson_2e;
6256 case E_MIPS_MACH_LS2F:
6257 return bfd_mach_mips_loongson_2f;
6259 case E_MIPS_MACH_LS3A:
6260 return bfd_mach_mips_loongson_3a;
6262 case E_MIPS_MACH_OCTEON2:
6263 return bfd_mach_mips_octeon2;
6265 case E_MIPS_MACH_OCTEON:
6266 return bfd_mach_mips_octeon;
6268 case E_MIPS_MACH_XLR:
6269 return bfd_mach_mips_xlr;
6272 switch (flags & EF_MIPS_ARCH)
6276 return bfd_mach_mips3000;
6279 return bfd_mach_mips6000;
6282 return bfd_mach_mips4000;
6285 return bfd_mach_mips8000;
6288 return bfd_mach_mips5;
6290 case E_MIPS_ARCH_32:
6291 return bfd_mach_mipsisa32;
6293 case E_MIPS_ARCH_64:
6294 return bfd_mach_mipsisa64;
6296 case E_MIPS_ARCH_32R2:
6297 return bfd_mach_mipsisa32r2;
6299 case E_MIPS_ARCH_64R2:
6300 return bfd_mach_mipsisa64r2;
6307 /* Return printable name for ABI. */
6309 static INLINE char *
6310 elf_mips_abi_name (bfd *abfd)
6314 flags = elf_elfheader (abfd)->e_flags;
6315 switch (flags & EF_MIPS_ABI)
6318 if (ABI_N32_P (abfd))
6320 else if (ABI_64_P (abfd))
6324 case E_MIPS_ABI_O32:
6326 case E_MIPS_ABI_O64:
6328 case E_MIPS_ABI_EABI32:
6330 case E_MIPS_ABI_EABI64:
6333 return "unknown abi";
6337 /* MIPS ELF uses two common sections. One is the usual one, and the
6338 other is for small objects. All the small objects are kept
6339 together, and then referenced via the gp pointer, which yields
6340 faster assembler code. This is what we use for the small common
6341 section. This approach is copied from ecoff.c. */
6342 static asection mips_elf_scom_section;
6343 static asymbol mips_elf_scom_symbol;
6344 static asymbol *mips_elf_scom_symbol_ptr;
6346 /* MIPS ELF also uses an acommon section, which represents an
6347 allocated common symbol which may be overridden by a
6348 definition in a shared library. */
6349 static asection mips_elf_acom_section;
6350 static asymbol mips_elf_acom_symbol;
6351 static asymbol *mips_elf_acom_symbol_ptr;
6353 /* This is used for both the 32-bit and the 64-bit ABI. */
6356 _bfd_mips_elf_symbol_processing (bfd *abfd, asymbol *asym)
6358 elf_symbol_type *elfsym;
6360 /* Handle the special MIPS section numbers that a symbol may use. */
6361 elfsym = (elf_symbol_type *) asym;
6362 switch (elfsym->internal_elf_sym.st_shndx)
6364 case SHN_MIPS_ACOMMON:
6365 /* This section is used in a dynamically linked executable file.
6366 It is an allocated common section. The dynamic linker can
6367 either resolve these symbols to something in a shared
6368 library, or it can just leave them here. For our purposes,
6369 we can consider these symbols to be in a new section. */
6370 if (mips_elf_acom_section.name == NULL)
6372 /* Initialize the acommon section. */
6373 mips_elf_acom_section.name = ".acommon";
6374 mips_elf_acom_section.flags = SEC_ALLOC;
6375 mips_elf_acom_section.output_section = &mips_elf_acom_section;
6376 mips_elf_acom_section.symbol = &mips_elf_acom_symbol;
6377 mips_elf_acom_section.symbol_ptr_ptr = &mips_elf_acom_symbol_ptr;
6378 mips_elf_acom_symbol.name = ".acommon";
6379 mips_elf_acom_symbol.flags = BSF_SECTION_SYM;
6380 mips_elf_acom_symbol.section = &mips_elf_acom_section;
6381 mips_elf_acom_symbol_ptr = &mips_elf_acom_symbol;
6383 asym->section = &mips_elf_acom_section;
6387 /* Common symbols less than the GP size are automatically
6388 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
6389 if (asym->value > elf_gp_size (abfd)
6390 || ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_TLS
6391 || IRIX_COMPAT (abfd) == ict_irix6)
6394 case SHN_MIPS_SCOMMON:
6395 if (mips_elf_scom_section.name == NULL)
6397 /* Initialize the small common section. */
6398 mips_elf_scom_section.name = ".scommon";
6399 mips_elf_scom_section.flags = SEC_IS_COMMON;
6400 mips_elf_scom_section.output_section = &mips_elf_scom_section;
6401 mips_elf_scom_section.symbol = &mips_elf_scom_symbol;
6402 mips_elf_scom_section.symbol_ptr_ptr = &mips_elf_scom_symbol_ptr;
6403 mips_elf_scom_symbol.name = ".scommon";
6404 mips_elf_scom_symbol.flags = BSF_SECTION_SYM;
6405 mips_elf_scom_symbol.section = &mips_elf_scom_section;
6406 mips_elf_scom_symbol_ptr = &mips_elf_scom_symbol;
6408 asym->section = &mips_elf_scom_section;
6409 asym->value = elfsym->internal_elf_sym.st_size;
6412 case SHN_MIPS_SUNDEFINED:
6413 asym->section = bfd_und_section_ptr;
6418 asection *section = bfd_get_section_by_name (abfd, ".text");
6420 if (section != NULL)
6422 asym->section = section;
6423 /* MIPS_TEXT is a bit special, the address is not an offset
6424 to the base of the .text section. So substract the section
6425 base address to make it an offset. */
6426 asym->value -= section->vma;
6433 asection *section = bfd_get_section_by_name (abfd, ".data");
6435 if (section != NULL)
6437 asym->section = section;
6438 /* MIPS_DATA is a bit special, the address is not an offset
6439 to the base of the .data section. So substract the section
6440 base address to make it an offset. */
6441 asym->value -= section->vma;
6447 /* If this is an odd-valued function symbol, assume it's a MIPS16
6448 or microMIPS one. */
6449 if (ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_FUNC
6450 && (asym->value & 1) != 0)
6453 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
6454 elfsym->internal_elf_sym.st_other
6455 = ELF_ST_SET_MICROMIPS (elfsym->internal_elf_sym.st_other);
6457 elfsym->internal_elf_sym.st_other
6458 = ELF_ST_SET_MIPS16 (elfsym->internal_elf_sym.st_other);
6462 /* Implement elf_backend_eh_frame_address_size. This differs from
6463 the default in the way it handles EABI64.
6465 EABI64 was originally specified as an LP64 ABI, and that is what
6466 -mabi=eabi normally gives on a 64-bit target. However, gcc has
6467 historically accepted the combination of -mabi=eabi and -mlong32,
6468 and this ILP32 variation has become semi-official over time.
6469 Both forms use elf32 and have pointer-sized FDE addresses.
6471 If an EABI object was generated by GCC 4.0 or above, it will have
6472 an empty .gcc_compiled_longXX section, where XX is the size of longs
6473 in bits. Unfortunately, ILP32 objects generated by earlier compilers
6474 have no special marking to distinguish them from LP64 objects.
6476 We don't want users of the official LP64 ABI to be punished for the
6477 existence of the ILP32 variant, but at the same time, we don't want
6478 to mistakenly interpret pre-4.0 ILP32 objects as being LP64 objects.
6479 We therefore take the following approach:
6481 - If ABFD contains a .gcc_compiled_longXX section, use it to
6482 determine the pointer size.
6484 - Otherwise check the type of the first relocation. Assume that
6485 the LP64 ABI is being used if the relocation is of type R_MIPS_64.
6489 The second check is enough to detect LP64 objects generated by pre-4.0
6490 compilers because, in the kind of output generated by those compilers,
6491 the first relocation will be associated with either a CIE personality
6492 routine or an FDE start address. Furthermore, the compilers never
6493 used a special (non-pointer) encoding for this ABI.
6495 Checking the relocation type should also be safe because there is no
6496 reason to use R_MIPS_64 in an ILP32 object. Pre-4.0 compilers never
6500 _bfd_mips_elf_eh_frame_address_size (bfd *abfd, asection *sec)
6502 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
6504 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
6506 bfd_boolean long32_p, long64_p;
6508 long32_p = bfd_get_section_by_name (abfd, ".gcc_compiled_long32") != 0;
6509 long64_p = bfd_get_section_by_name (abfd, ".gcc_compiled_long64") != 0;
6510 if (long32_p && long64_p)
6517 if (sec->reloc_count > 0
6518 && elf_section_data (sec)->relocs != NULL
6519 && (ELF32_R_TYPE (elf_section_data (sec)->relocs[0].r_info)
6528 /* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
6529 relocations against two unnamed section symbols to resolve to the
6530 same address. For example, if we have code like:
6532 lw $4,%got_disp(.data)($gp)
6533 lw $25,%got_disp(.text)($gp)
6536 then the linker will resolve both relocations to .data and the program
6537 will jump there rather than to .text.
6539 We can work around this problem by giving names to local section symbols.
6540 This is also what the MIPSpro tools do. */
6543 _bfd_mips_elf_name_local_section_symbols (bfd *abfd)
6545 return SGI_COMPAT (abfd);
6548 /* Work over a section just before writing it out. This routine is
6549 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
6550 sections that need the SHF_MIPS_GPREL flag by name; there has to be
6554 _bfd_mips_elf_section_processing (bfd *abfd, Elf_Internal_Shdr *hdr)
6556 if (hdr->sh_type == SHT_MIPS_REGINFO
6557 && hdr->sh_size > 0)
6561 BFD_ASSERT (hdr->sh_size == sizeof (Elf32_External_RegInfo));
6562 BFD_ASSERT (hdr->contents == NULL);
6565 hdr->sh_offset + sizeof (Elf32_External_RegInfo) - 4,
6568 H_PUT_32 (abfd, elf_gp (abfd), buf);
6569 if (bfd_bwrite (buf, 4, abfd) != 4)
6573 if (hdr->sh_type == SHT_MIPS_OPTIONS
6574 && hdr->bfd_section != NULL
6575 && mips_elf_section_data (hdr->bfd_section) != NULL
6576 && mips_elf_section_data (hdr->bfd_section)->u.tdata != NULL)
6578 bfd_byte *contents, *l, *lend;
6580 /* We stored the section contents in the tdata field in the
6581 set_section_contents routine. We save the section contents
6582 so that we don't have to read them again.
6583 At this point we know that elf_gp is set, so we can look
6584 through the section contents to see if there is an
6585 ODK_REGINFO structure. */
6587 contents = mips_elf_section_data (hdr->bfd_section)->u.tdata;
6589 lend = contents + hdr->sh_size;
6590 while (l + sizeof (Elf_External_Options) <= lend)
6592 Elf_Internal_Options intopt;
6594 bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
6596 if (intopt.size < sizeof (Elf_External_Options))
6598 (*_bfd_error_handler)
6599 (_("%B: Warning: bad `%s' option size %u smaller than its header"),
6600 abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size);
6603 if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
6610 + sizeof (Elf_External_Options)
6611 + (sizeof (Elf64_External_RegInfo) - 8)),
6614 H_PUT_64 (abfd, elf_gp (abfd), buf);
6615 if (bfd_bwrite (buf, 8, abfd) != 8)
6618 else if (intopt.kind == ODK_REGINFO)
6625 + sizeof (Elf_External_Options)
6626 + (sizeof (Elf32_External_RegInfo) - 4)),
6629 H_PUT_32 (abfd, elf_gp (abfd), buf);
6630 if (bfd_bwrite (buf, 4, abfd) != 4)
6637 if (hdr->bfd_section != NULL)
6639 const char *name = bfd_get_section_name (abfd, hdr->bfd_section);
6641 /* .sbss is not handled specially here because the GNU/Linux
6642 prelinker can convert .sbss from NOBITS to PROGBITS and
6643 changing it back to NOBITS breaks the binary. The entry in
6644 _bfd_mips_elf_special_sections will ensure the correct flags
6645 are set on .sbss if BFD creates it without reading it from an
6646 input file, and without special handling here the flags set
6647 on it in an input file will be followed. */
6648 if (strcmp (name, ".sdata") == 0
6649 || strcmp (name, ".lit8") == 0
6650 || strcmp (name, ".lit4") == 0)
6652 hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
6653 hdr->sh_type = SHT_PROGBITS;
6655 else if (strcmp (name, ".srdata") == 0)
6657 hdr->sh_flags |= SHF_ALLOC | SHF_MIPS_GPREL;
6658 hdr->sh_type = SHT_PROGBITS;
6660 else if (strcmp (name, ".compact_rel") == 0)
6663 hdr->sh_type = SHT_PROGBITS;
6665 else if (strcmp (name, ".rtproc") == 0)
6667 if (hdr->sh_addralign != 0 && hdr->sh_entsize == 0)
6669 unsigned int adjust;
6671 adjust = hdr->sh_size % hdr->sh_addralign;
6673 hdr->sh_size += hdr->sh_addralign - adjust;
6681 /* Handle a MIPS specific section when reading an object file. This
6682 is called when elfcode.h finds a section with an unknown type.
6683 This routine supports both the 32-bit and 64-bit ELF ABI.
6685 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
6689 _bfd_mips_elf_section_from_shdr (bfd *abfd,
6690 Elf_Internal_Shdr *hdr,
6696 /* There ought to be a place to keep ELF backend specific flags, but
6697 at the moment there isn't one. We just keep track of the
6698 sections by their name, instead. Fortunately, the ABI gives
6699 suggested names for all the MIPS specific sections, so we will
6700 probably get away with this. */
6701 switch (hdr->sh_type)
6703 case SHT_MIPS_LIBLIST:
6704 if (strcmp (name, ".liblist") != 0)
6708 if (strcmp (name, ".msym") != 0)
6711 case SHT_MIPS_CONFLICT:
6712 if (strcmp (name, ".conflict") != 0)
6715 case SHT_MIPS_GPTAB:
6716 if (! CONST_STRNEQ (name, ".gptab."))
6719 case SHT_MIPS_UCODE:
6720 if (strcmp (name, ".ucode") != 0)
6723 case SHT_MIPS_DEBUG:
6724 if (strcmp (name, ".mdebug") != 0)
6726 flags = SEC_DEBUGGING;
6728 case SHT_MIPS_REGINFO:
6729 if (strcmp (name, ".reginfo") != 0
6730 || hdr->sh_size != sizeof (Elf32_External_RegInfo))
6732 flags = (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_SIZE);
6734 case SHT_MIPS_IFACE:
6735 if (strcmp (name, ".MIPS.interfaces") != 0)
6738 case SHT_MIPS_CONTENT:
6739 if (! CONST_STRNEQ (name, ".MIPS.content"))
6742 case SHT_MIPS_OPTIONS:
6743 if (!MIPS_ELF_OPTIONS_SECTION_NAME_P (name))
6746 case SHT_MIPS_DWARF:
6747 if (! CONST_STRNEQ (name, ".debug_")
6748 && ! CONST_STRNEQ (name, ".zdebug_"))
6751 case SHT_MIPS_SYMBOL_LIB:
6752 if (strcmp (name, ".MIPS.symlib") != 0)
6755 case SHT_MIPS_EVENTS:
6756 if (! CONST_STRNEQ (name, ".MIPS.events")
6757 && ! CONST_STRNEQ (name, ".MIPS.post_rel"))
6764 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
6769 if (! bfd_set_section_flags (abfd, hdr->bfd_section,
6770 (bfd_get_section_flags (abfd,
6776 /* FIXME: We should record sh_info for a .gptab section. */
6778 /* For a .reginfo section, set the gp value in the tdata information
6779 from the contents of this section. We need the gp value while
6780 processing relocs, so we just get it now. The .reginfo section
6781 is not used in the 64-bit MIPS ELF ABI. */
6782 if (hdr->sh_type == SHT_MIPS_REGINFO)
6784 Elf32_External_RegInfo ext;
6787 if (! bfd_get_section_contents (abfd, hdr->bfd_section,
6788 &ext, 0, sizeof ext))
6790 bfd_mips_elf32_swap_reginfo_in (abfd, &ext, &s);
6791 elf_gp (abfd) = s.ri_gp_value;
6794 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
6795 set the gp value based on what we find. We may see both
6796 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
6797 they should agree. */
6798 if (hdr->sh_type == SHT_MIPS_OPTIONS)
6800 bfd_byte *contents, *l, *lend;
6802 contents = bfd_malloc (hdr->sh_size);
6803 if (contents == NULL)
6805 if (! bfd_get_section_contents (abfd, hdr->bfd_section, contents,
6812 lend = contents + hdr->sh_size;
6813 while (l + sizeof (Elf_External_Options) <= lend)
6815 Elf_Internal_Options intopt;
6817 bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
6819 if (intopt.size < sizeof (Elf_External_Options))
6821 (*_bfd_error_handler)
6822 (_("%B: Warning: bad `%s' option size %u smaller than its header"),
6823 abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size);
6826 if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
6828 Elf64_Internal_RegInfo intreg;
6830 bfd_mips_elf64_swap_reginfo_in
6832 ((Elf64_External_RegInfo *)
6833 (l + sizeof (Elf_External_Options))),
6835 elf_gp (abfd) = intreg.ri_gp_value;
6837 else if (intopt.kind == ODK_REGINFO)
6839 Elf32_RegInfo intreg;
6841 bfd_mips_elf32_swap_reginfo_in
6843 ((Elf32_External_RegInfo *)
6844 (l + sizeof (Elf_External_Options))),
6846 elf_gp (abfd) = intreg.ri_gp_value;
6856 /* Set the correct type for a MIPS ELF section. We do this by the
6857 section name, which is a hack, but ought to work. This routine is
6858 used by both the 32-bit and the 64-bit ABI. */
6861 _bfd_mips_elf_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec)
6863 const char *name = bfd_get_section_name (abfd, sec);
6865 if (strcmp (name, ".liblist") == 0)
6867 hdr->sh_type = SHT_MIPS_LIBLIST;
6868 hdr->sh_info = sec->size / sizeof (Elf32_Lib);
6869 /* The sh_link field is set in final_write_processing. */
6871 else if (strcmp (name, ".conflict") == 0)
6872 hdr->sh_type = SHT_MIPS_CONFLICT;
6873 else if (CONST_STRNEQ (name, ".gptab."))
6875 hdr->sh_type = SHT_MIPS_GPTAB;
6876 hdr->sh_entsize = sizeof (Elf32_External_gptab);
6877 /* The sh_info field is set in final_write_processing. */
6879 else if (strcmp (name, ".ucode") == 0)
6880 hdr->sh_type = SHT_MIPS_UCODE;
6881 else if (strcmp (name, ".mdebug") == 0)
6883 hdr->sh_type = SHT_MIPS_DEBUG;
6884 /* In a shared object on IRIX 5.3, the .mdebug section has an
6885 entsize of 0. FIXME: Does this matter? */
6886 if (SGI_COMPAT (abfd) && (abfd->flags & DYNAMIC) != 0)
6887 hdr->sh_entsize = 0;
6889 hdr->sh_entsize = 1;
6891 else if (strcmp (name, ".reginfo") == 0)
6893 hdr->sh_type = SHT_MIPS_REGINFO;
6894 /* In a shared object on IRIX 5.3, the .reginfo section has an
6895 entsize of 0x18. FIXME: Does this matter? */
6896 if (SGI_COMPAT (abfd))
6898 if ((abfd->flags & DYNAMIC) != 0)
6899 hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
6901 hdr->sh_entsize = 1;
6904 hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
6906 else if (SGI_COMPAT (abfd)
6907 && (strcmp (name, ".hash") == 0
6908 || strcmp (name, ".dynamic") == 0
6909 || strcmp (name, ".dynstr") == 0))
6911 if (SGI_COMPAT (abfd))
6912 hdr->sh_entsize = 0;
6914 /* This isn't how the IRIX6 linker behaves. */
6915 hdr->sh_info = SIZEOF_MIPS_DYNSYM_SECNAMES;
6918 else if (strcmp (name, ".got") == 0
6919 || strcmp (name, ".srdata") == 0
6920 || strcmp (name, ".sdata") == 0
6921 || strcmp (name, ".sbss") == 0
6922 || strcmp (name, ".lit4") == 0
6923 || strcmp (name, ".lit8") == 0)
6924 hdr->sh_flags |= SHF_MIPS_GPREL;
6925 else if (strcmp (name, ".MIPS.interfaces") == 0)
6927 hdr->sh_type = SHT_MIPS_IFACE;
6928 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
6930 else if (CONST_STRNEQ (name, ".MIPS.content"))
6932 hdr->sh_type = SHT_MIPS_CONTENT;
6933 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
6934 /* The sh_info field is set in final_write_processing. */
6936 else if (MIPS_ELF_OPTIONS_SECTION_NAME_P (name))
6938 hdr->sh_type = SHT_MIPS_OPTIONS;
6939 hdr->sh_entsize = 1;
6940 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
6942 else if (CONST_STRNEQ (name, ".debug_")
6943 || CONST_STRNEQ (name, ".zdebug_"))
6945 hdr->sh_type = SHT_MIPS_DWARF;
6947 /* Irix facilities such as libexc expect a single .debug_frame
6948 per executable, the system ones have NOSTRIP set and the linker
6949 doesn't merge sections with different flags so ... */
6950 if (SGI_COMPAT (abfd) && CONST_STRNEQ (name, ".debug_frame"))
6951 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
6953 else if (strcmp (name, ".MIPS.symlib") == 0)
6955 hdr->sh_type = SHT_MIPS_SYMBOL_LIB;
6956 /* The sh_link and sh_info fields are set in
6957 final_write_processing. */
6959 else if (CONST_STRNEQ (name, ".MIPS.events")
6960 || CONST_STRNEQ (name, ".MIPS.post_rel"))
6962 hdr->sh_type = SHT_MIPS_EVENTS;
6963 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
6964 /* The sh_link field is set in final_write_processing. */
6966 else if (strcmp (name, ".msym") == 0)
6968 hdr->sh_type = SHT_MIPS_MSYM;
6969 hdr->sh_flags |= SHF_ALLOC;
6970 hdr->sh_entsize = 8;
6973 /* The generic elf_fake_sections will set up REL_HDR using the default
6974 kind of relocations. We used to set up a second header for the
6975 non-default kind of relocations here, but only NewABI would use
6976 these, and the IRIX ld doesn't like resulting empty RELA sections.
6977 Thus we create those header only on demand now. */
6982 /* Given a BFD section, try to locate the corresponding ELF section
6983 index. This is used by both the 32-bit and the 64-bit ABI.
6984 Actually, it's not clear to me that the 64-bit ABI supports these,
6985 but for non-PIC objects we will certainly want support for at least
6986 the .scommon section. */
6989 _bfd_mips_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
6990 asection *sec, int *retval)
6992 if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
6994 *retval = SHN_MIPS_SCOMMON;
6997 if (strcmp (bfd_get_section_name (abfd, sec), ".acommon") == 0)
6999 *retval = SHN_MIPS_ACOMMON;
7005 /* Hook called by the linker routine which adds symbols from an object
7006 file. We must handle the special MIPS section numbers here. */
7009 _bfd_mips_elf_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
7010 Elf_Internal_Sym *sym, const char **namep,
7011 flagword *flagsp ATTRIBUTE_UNUSED,
7012 asection **secp, bfd_vma *valp)
7014 if (SGI_COMPAT (abfd)
7015 && (abfd->flags & DYNAMIC) != 0
7016 && strcmp (*namep, "_rld_new_interface") == 0)
7018 /* Skip IRIX5 rld entry name. */
7023 /* Shared objects may have a dynamic symbol '_gp_disp' defined as
7024 a SECTION *ABS*. This causes ld to think it can resolve _gp_disp
7025 by setting a DT_NEEDED for the shared object. Since _gp_disp is
7026 a magic symbol resolved by the linker, we ignore this bogus definition
7027 of _gp_disp. New ABI objects do not suffer from this problem so this
7028 is not done for them. */
7030 && (sym->st_shndx == SHN_ABS)
7031 && (strcmp (*namep, "_gp_disp") == 0))
7037 switch (sym->st_shndx)
7040 /* Common symbols less than the GP size are automatically
7041 treated as SHN_MIPS_SCOMMON symbols. */
7042 if (sym->st_size > elf_gp_size (abfd)
7043 || ELF_ST_TYPE (sym->st_info) == STT_TLS
7044 || IRIX_COMPAT (abfd) == ict_irix6)
7047 case SHN_MIPS_SCOMMON:
7048 *secp = bfd_make_section_old_way (abfd, ".scommon");
7049 (*secp)->flags |= SEC_IS_COMMON;
7050 *valp = sym->st_size;
7054 /* This section is used in a shared object. */
7055 if (elf_tdata (abfd)->elf_text_section == NULL)
7057 asymbol *elf_text_symbol;
7058 asection *elf_text_section;
7059 bfd_size_type amt = sizeof (asection);
7061 elf_text_section = bfd_zalloc (abfd, amt);
7062 if (elf_text_section == NULL)
7065 amt = sizeof (asymbol);
7066 elf_text_symbol = bfd_zalloc (abfd, amt);
7067 if (elf_text_symbol == NULL)
7070 /* Initialize the section. */
7072 elf_tdata (abfd)->elf_text_section = elf_text_section;
7073 elf_tdata (abfd)->elf_text_symbol = elf_text_symbol;
7075 elf_text_section->symbol = elf_text_symbol;
7076 elf_text_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_text_symbol;
7078 elf_text_section->name = ".text";
7079 elf_text_section->flags = SEC_NO_FLAGS;
7080 elf_text_section->output_section = NULL;
7081 elf_text_section->owner = abfd;
7082 elf_text_symbol->name = ".text";
7083 elf_text_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
7084 elf_text_symbol->section = elf_text_section;
7086 /* This code used to do *secp = bfd_und_section_ptr if
7087 info->shared. I don't know why, and that doesn't make sense,
7088 so I took it out. */
7089 *secp = elf_tdata (abfd)->elf_text_section;
7092 case SHN_MIPS_ACOMMON:
7093 /* Fall through. XXX Can we treat this as allocated data? */
7095 /* This section is used in a shared object. */
7096 if (elf_tdata (abfd)->elf_data_section == NULL)
7098 asymbol *elf_data_symbol;
7099 asection *elf_data_section;
7100 bfd_size_type amt = sizeof (asection);
7102 elf_data_section = bfd_zalloc (abfd, amt);
7103 if (elf_data_section == NULL)
7106 amt = sizeof (asymbol);
7107 elf_data_symbol = bfd_zalloc (abfd, amt);
7108 if (elf_data_symbol == NULL)
7111 /* Initialize the section. */
7113 elf_tdata (abfd)->elf_data_section = elf_data_section;
7114 elf_tdata (abfd)->elf_data_symbol = elf_data_symbol;
7116 elf_data_section->symbol = elf_data_symbol;
7117 elf_data_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_data_symbol;
7119 elf_data_section->name = ".data";
7120 elf_data_section->flags = SEC_NO_FLAGS;
7121 elf_data_section->output_section = NULL;
7122 elf_data_section->owner = abfd;
7123 elf_data_symbol->name = ".data";
7124 elf_data_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
7125 elf_data_symbol->section = elf_data_section;
7127 /* This code used to do *secp = bfd_und_section_ptr if
7128 info->shared. I don't know why, and that doesn't make sense,
7129 so I took it out. */
7130 *secp = elf_tdata (abfd)->elf_data_section;
7133 case SHN_MIPS_SUNDEFINED:
7134 *secp = bfd_und_section_ptr;
7138 if (SGI_COMPAT (abfd)
7140 && info->output_bfd->xvec == abfd->xvec
7141 && strcmp (*namep, "__rld_obj_head") == 0)
7143 struct elf_link_hash_entry *h;
7144 struct bfd_link_hash_entry *bh;
7146 /* Mark __rld_obj_head as dynamic. */
7148 if (! (_bfd_generic_link_add_one_symbol
7149 (info, abfd, *namep, BSF_GLOBAL, *secp, *valp, NULL, FALSE,
7150 get_elf_backend_data (abfd)->collect, &bh)))
7153 h = (struct elf_link_hash_entry *) bh;
7156 h->type = STT_OBJECT;
7158 if (! bfd_elf_link_record_dynamic_symbol (info, h))
7161 mips_elf_hash_table (info)->use_rld_obj_head = TRUE;
7162 mips_elf_hash_table (info)->rld_symbol = h;
7165 /* If this is a mips16 text symbol, add 1 to the value to make it
7166 odd. This will cause something like .word SYM to come up with
7167 the right value when it is loaded into the PC. */
7168 if (ELF_ST_IS_COMPRESSED (sym->st_other))
7174 /* This hook function is called before the linker writes out a global
7175 symbol. We mark symbols as small common if appropriate. This is
7176 also where we undo the increment of the value for a mips16 symbol. */
7179 _bfd_mips_elf_link_output_symbol_hook
7180 (struct bfd_link_info *info ATTRIBUTE_UNUSED,
7181 const char *name ATTRIBUTE_UNUSED, Elf_Internal_Sym *sym,
7182 asection *input_sec, struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
7184 /* If we see a common symbol, which implies a relocatable link, then
7185 if a symbol was small common in an input file, mark it as small
7186 common in the output file. */
7187 if (sym->st_shndx == SHN_COMMON
7188 && strcmp (input_sec->name, ".scommon") == 0)
7189 sym->st_shndx = SHN_MIPS_SCOMMON;
7191 if (ELF_ST_IS_COMPRESSED (sym->st_other))
7192 sym->st_value &= ~1;
7197 /* Functions for the dynamic linker. */
7199 /* Create dynamic sections when linking against a dynamic object. */
7202 _bfd_mips_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
7204 struct elf_link_hash_entry *h;
7205 struct bfd_link_hash_entry *bh;
7207 register asection *s;
7208 const char * const *namep;
7209 struct mips_elf_link_hash_table *htab;
7211 htab = mips_elf_hash_table (info);
7212 BFD_ASSERT (htab != NULL);
7214 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
7215 | SEC_LINKER_CREATED | SEC_READONLY);
7217 /* The psABI requires a read-only .dynamic section, but the VxWorks
7219 if (!htab->is_vxworks)
7221 s = bfd_get_linker_section (abfd, ".dynamic");
7224 if (! bfd_set_section_flags (abfd, s, flags))
7229 /* We need to create .got section. */
7230 if (!mips_elf_create_got_section (abfd, info))
7233 if (! mips_elf_rel_dyn_section (info, TRUE))
7236 /* Create .stub section. */
7237 s = bfd_make_section_anyway_with_flags (abfd,
7238 MIPS_ELF_STUB_SECTION_NAME (abfd),
7241 || ! bfd_set_section_alignment (abfd, s,
7242 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
7246 if (!mips_elf_hash_table (info)->use_rld_obj_head
7248 && bfd_get_linker_section (abfd, ".rld_map") == NULL)
7250 s = bfd_make_section_anyway_with_flags (abfd, ".rld_map",
7251 flags &~ (flagword) SEC_READONLY);
7253 || ! bfd_set_section_alignment (abfd, s,
7254 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
7258 /* On IRIX5, we adjust add some additional symbols and change the
7259 alignments of several sections. There is no ABI documentation
7260 indicating that this is necessary on IRIX6, nor any evidence that
7261 the linker takes such action. */
7262 if (IRIX_COMPAT (abfd) == ict_irix5)
7264 for (namep = mips_elf_dynsym_rtproc_names; *namep != NULL; namep++)
7267 if (! (_bfd_generic_link_add_one_symbol
7268 (info, abfd, *namep, BSF_GLOBAL, bfd_und_section_ptr, 0,
7269 NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
7272 h = (struct elf_link_hash_entry *) bh;
7275 h->type = STT_SECTION;
7277 if (! bfd_elf_link_record_dynamic_symbol (info, h))
7281 /* We need to create a .compact_rel section. */
7282 if (SGI_COMPAT (abfd))
7284 if (!mips_elf_create_compact_rel_section (abfd, info))
7288 /* Change alignments of some sections. */
7289 s = bfd_get_linker_section (abfd, ".hash");
7291 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7292 s = bfd_get_linker_section (abfd, ".dynsym");
7294 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7295 s = bfd_get_linker_section (abfd, ".dynstr");
7297 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7299 s = bfd_get_section_by_name (abfd, ".reginfo");
7301 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7302 s = bfd_get_linker_section (abfd, ".dynamic");
7304 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7311 name = SGI_COMPAT (abfd) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
7313 if (!(_bfd_generic_link_add_one_symbol
7314 (info, abfd, name, BSF_GLOBAL, bfd_abs_section_ptr, 0,
7315 NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
7318 h = (struct elf_link_hash_entry *) bh;
7321 h->type = STT_SECTION;
7323 if (! bfd_elf_link_record_dynamic_symbol (info, h))
7326 if (! mips_elf_hash_table (info)->use_rld_obj_head)
7328 /* __rld_map is a four byte word located in the .data section
7329 and is filled in by the rtld to contain a pointer to
7330 the _r_debug structure. Its symbol value will be set in
7331 _bfd_mips_elf_finish_dynamic_symbol. */
7332 s = bfd_get_linker_section (abfd, ".rld_map");
7333 BFD_ASSERT (s != NULL);
7335 name = SGI_COMPAT (abfd) ? "__rld_map" : "__RLD_MAP";
7337 if (!(_bfd_generic_link_add_one_symbol
7338 (info, abfd, name, BSF_GLOBAL, s, 0, NULL, FALSE,
7339 get_elf_backend_data (abfd)->collect, &bh)))
7342 h = (struct elf_link_hash_entry *) bh;
7345 h->type = STT_OBJECT;
7347 if (! bfd_elf_link_record_dynamic_symbol (info, h))
7349 mips_elf_hash_table (info)->rld_symbol = h;
7353 /* Create the .plt, .rel(a).plt, .dynbss and .rel(a).bss sections.
7354 Also create the _PROCEDURE_LINKAGE_TABLE symbol. */
7355 if (!_bfd_elf_create_dynamic_sections (abfd, info))
7358 /* Cache the sections created above. */
7359 htab->splt = bfd_get_linker_section (abfd, ".plt");
7360 htab->sdynbss = bfd_get_linker_section (abfd, ".dynbss");
7361 if (htab->is_vxworks)
7363 htab->srelbss = bfd_get_linker_section (abfd, ".rela.bss");
7364 htab->srelplt = bfd_get_linker_section (abfd, ".rela.plt");
7367 htab->srelplt = bfd_get_linker_section (abfd, ".rel.plt");
7369 || (htab->is_vxworks && !htab->srelbss && !info->shared)
7374 if (htab->is_vxworks)
7376 /* Do the usual VxWorks handling. */
7377 if (!elf_vxworks_create_dynamic_sections (abfd, info, &htab->srelplt2))
7380 /* Work out the PLT sizes. */
7383 htab->plt_header_size
7384 = 4 * ARRAY_SIZE (mips_vxworks_shared_plt0_entry);
7385 htab->plt_entry_size
7386 = 4 * ARRAY_SIZE (mips_vxworks_shared_plt_entry);
7390 htab->plt_header_size
7391 = 4 * ARRAY_SIZE (mips_vxworks_exec_plt0_entry);
7392 htab->plt_entry_size
7393 = 4 * ARRAY_SIZE (mips_vxworks_exec_plt_entry);
7396 else if (!info->shared)
7398 /* All variants of the plt0 entry are the same size. */
7399 htab->plt_header_size = 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry);
7400 htab->plt_entry_size = 4 * ARRAY_SIZE (mips_exec_plt_entry);
7406 /* Return true if relocation REL against section SEC is a REL rather than
7407 RELA relocation. RELOCS is the first relocation in the section and
7408 ABFD is the bfd that contains SEC. */
7411 mips_elf_rel_relocation_p (bfd *abfd, asection *sec,
7412 const Elf_Internal_Rela *relocs,
7413 const Elf_Internal_Rela *rel)
7415 Elf_Internal_Shdr *rel_hdr;
7416 const struct elf_backend_data *bed;
7418 /* To determine which flavor of relocation this is, we depend on the
7419 fact that the INPUT_SECTION's REL_HDR is read before RELA_HDR. */
7420 rel_hdr = elf_section_data (sec)->rel.hdr;
7421 if (rel_hdr == NULL)
7423 bed = get_elf_backend_data (abfd);
7424 return ((size_t) (rel - relocs)
7425 < NUM_SHDR_ENTRIES (rel_hdr) * bed->s->int_rels_per_ext_rel);
7428 /* Read the addend for REL relocation REL, which belongs to bfd ABFD.
7429 HOWTO is the relocation's howto and CONTENTS points to the contents
7430 of the section that REL is against. */
7433 mips_elf_read_rel_addend (bfd *abfd, const Elf_Internal_Rela *rel,
7434 reloc_howto_type *howto, bfd_byte *contents)
7437 unsigned int r_type;
7440 r_type = ELF_R_TYPE (abfd, rel->r_info);
7441 location = contents + rel->r_offset;
7443 /* Get the addend, which is stored in the input file. */
7444 _bfd_mips_elf_reloc_unshuffle (abfd, r_type, FALSE, location);
7445 addend = mips_elf_obtain_contents (howto, rel, abfd, contents);
7446 _bfd_mips_elf_reloc_shuffle (abfd, r_type, FALSE, location);
7448 return addend & howto->src_mask;
7451 /* REL is a relocation in ABFD that needs a partnering LO16 relocation
7452 and *ADDEND is the addend for REL itself. Look for the LO16 relocation
7453 and update *ADDEND with the final addend. Return true on success
7454 or false if the LO16 could not be found. RELEND is the exclusive
7455 upper bound on the relocations for REL's section. */
7458 mips_elf_add_lo16_rel_addend (bfd *abfd,
7459 const Elf_Internal_Rela *rel,
7460 const Elf_Internal_Rela *relend,
7461 bfd_byte *contents, bfd_vma *addend)
7463 unsigned int r_type, lo16_type;
7464 const Elf_Internal_Rela *lo16_relocation;
7465 reloc_howto_type *lo16_howto;
7468 r_type = ELF_R_TYPE (abfd, rel->r_info);
7469 if (mips16_reloc_p (r_type))
7470 lo16_type = R_MIPS16_LO16;
7471 else if (micromips_reloc_p (r_type))
7472 lo16_type = R_MICROMIPS_LO16;
7474 lo16_type = R_MIPS_LO16;
7476 /* The combined value is the sum of the HI16 addend, left-shifted by
7477 sixteen bits, and the LO16 addend, sign extended. (Usually, the
7478 code does a `lui' of the HI16 value, and then an `addiu' of the
7481 Scan ahead to find a matching LO16 relocation.
7483 According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must
7484 be immediately following. However, for the IRIX6 ABI, the next
7485 relocation may be a composed relocation consisting of several
7486 relocations for the same address. In that case, the R_MIPS_LO16
7487 relocation may occur as one of these. We permit a similar
7488 extension in general, as that is useful for GCC.
7490 In some cases GCC dead code elimination removes the LO16 but keeps
7491 the corresponding HI16. This is strictly speaking a violation of
7492 the ABI but not immediately harmful. */
7493 lo16_relocation = mips_elf_next_relocation (abfd, lo16_type, rel, relend);
7494 if (lo16_relocation == NULL)
7497 /* Obtain the addend kept there. */
7498 lo16_howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, lo16_type, FALSE);
7499 l = mips_elf_read_rel_addend (abfd, lo16_relocation, lo16_howto, contents);
7501 l <<= lo16_howto->rightshift;
7502 l = _bfd_mips_elf_sign_extend (l, 16);
7509 /* Try to read the contents of section SEC in bfd ABFD. Return true and
7510 store the contents in *CONTENTS on success. Assume that *CONTENTS
7511 already holds the contents if it is nonull on entry. */
7514 mips_elf_get_section_contents (bfd *abfd, asection *sec, bfd_byte **contents)
7519 /* Get cached copy if it exists. */
7520 if (elf_section_data (sec)->this_hdr.contents != NULL)
7522 *contents = elf_section_data (sec)->this_hdr.contents;
7526 return bfd_malloc_and_get_section (abfd, sec, contents);
7529 /* Look through the relocs for a section during the first phase, and
7530 allocate space in the global offset table. */
7533 _bfd_mips_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
7534 asection *sec, const Elf_Internal_Rela *relocs)
7538 Elf_Internal_Shdr *symtab_hdr;
7539 struct elf_link_hash_entry **sym_hashes;
7541 const Elf_Internal_Rela *rel;
7542 const Elf_Internal_Rela *rel_end;
7544 const struct elf_backend_data *bed;
7545 struct mips_elf_link_hash_table *htab;
7548 reloc_howto_type *howto;
7550 if (info->relocatable)
7553 htab = mips_elf_hash_table (info);
7554 BFD_ASSERT (htab != NULL);
7556 dynobj = elf_hash_table (info)->dynobj;
7557 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7558 sym_hashes = elf_sym_hashes (abfd);
7559 extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
7561 bed = get_elf_backend_data (abfd);
7562 rel_end = relocs + sec->reloc_count * bed->s->int_rels_per_ext_rel;
7564 /* Check for the mips16 stub sections. */
7566 name = bfd_get_section_name (abfd, sec);
7567 if (FN_STUB_P (name))
7569 unsigned long r_symndx;
7571 /* Look at the relocation information to figure out which symbol
7574 r_symndx = mips16_stub_symndx (bed, sec, relocs, rel_end);
7577 (*_bfd_error_handler)
7578 (_("%B: Warning: cannot determine the target function for"
7579 " stub section `%s'"),
7581 bfd_set_error (bfd_error_bad_value);
7585 if (r_symndx < extsymoff
7586 || sym_hashes[r_symndx - extsymoff] == NULL)
7590 /* This stub is for a local symbol. This stub will only be
7591 needed if there is some relocation in this BFD, other
7592 than a 16 bit function call, which refers to this symbol. */
7593 for (o = abfd->sections; o != NULL; o = o->next)
7595 Elf_Internal_Rela *sec_relocs;
7596 const Elf_Internal_Rela *r, *rend;
7598 /* We can ignore stub sections when looking for relocs. */
7599 if ((o->flags & SEC_RELOC) == 0
7600 || o->reloc_count == 0
7601 || section_allows_mips16_refs_p (o))
7605 = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
7607 if (sec_relocs == NULL)
7610 rend = sec_relocs + o->reloc_count;
7611 for (r = sec_relocs; r < rend; r++)
7612 if (ELF_R_SYM (abfd, r->r_info) == r_symndx
7613 && !mips16_call_reloc_p (ELF_R_TYPE (abfd, r->r_info)))
7616 if (elf_section_data (o)->relocs != sec_relocs)
7625 /* There is no non-call reloc for this stub, so we do
7626 not need it. Since this function is called before
7627 the linker maps input sections to output sections, we
7628 can easily discard it by setting the SEC_EXCLUDE
7630 sec->flags |= SEC_EXCLUDE;
7634 /* Record this stub in an array of local symbol stubs for
7636 if (elf_tdata (abfd)->local_stubs == NULL)
7638 unsigned long symcount;
7642 if (elf_bad_symtab (abfd))
7643 symcount = NUM_SHDR_ENTRIES (symtab_hdr);
7645 symcount = symtab_hdr->sh_info;
7646 amt = symcount * sizeof (asection *);
7647 n = bfd_zalloc (abfd, amt);
7650 elf_tdata (abfd)->local_stubs = n;
7653 sec->flags |= SEC_KEEP;
7654 elf_tdata (abfd)->local_stubs[r_symndx] = sec;
7656 /* We don't need to set mips16_stubs_seen in this case.
7657 That flag is used to see whether we need to look through
7658 the global symbol table for stubs. We don't need to set
7659 it here, because we just have a local stub. */
7663 struct mips_elf_link_hash_entry *h;
7665 h = ((struct mips_elf_link_hash_entry *)
7666 sym_hashes[r_symndx - extsymoff]);
7668 while (h->root.root.type == bfd_link_hash_indirect
7669 || h->root.root.type == bfd_link_hash_warning)
7670 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
7672 /* H is the symbol this stub is for. */
7674 /* If we already have an appropriate stub for this function, we
7675 don't need another one, so we can discard this one. Since
7676 this function is called before the linker maps input sections
7677 to output sections, we can easily discard it by setting the
7678 SEC_EXCLUDE flag. */
7679 if (h->fn_stub != NULL)
7681 sec->flags |= SEC_EXCLUDE;
7685 sec->flags |= SEC_KEEP;
7687 mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
7690 else if (CALL_STUB_P (name) || CALL_FP_STUB_P (name))
7692 unsigned long r_symndx;
7693 struct mips_elf_link_hash_entry *h;
7696 /* Look at the relocation information to figure out which symbol
7699 r_symndx = mips16_stub_symndx (bed, sec, relocs, rel_end);
7702 (*_bfd_error_handler)
7703 (_("%B: Warning: cannot determine the target function for"
7704 " stub section `%s'"),
7706 bfd_set_error (bfd_error_bad_value);
7710 if (r_symndx < extsymoff
7711 || sym_hashes[r_symndx - extsymoff] == NULL)
7715 /* This stub is for a local symbol. This stub will only be
7716 needed if there is some relocation (R_MIPS16_26) in this BFD
7717 that refers to this symbol. */
7718 for (o = abfd->sections; o != NULL; o = o->next)
7720 Elf_Internal_Rela *sec_relocs;
7721 const Elf_Internal_Rela *r, *rend;
7723 /* We can ignore stub sections when looking for relocs. */
7724 if ((o->flags & SEC_RELOC) == 0
7725 || o->reloc_count == 0
7726 || section_allows_mips16_refs_p (o))
7730 = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
7732 if (sec_relocs == NULL)
7735 rend = sec_relocs + o->reloc_count;
7736 for (r = sec_relocs; r < rend; r++)
7737 if (ELF_R_SYM (abfd, r->r_info) == r_symndx
7738 && ELF_R_TYPE (abfd, r->r_info) == R_MIPS16_26)
7741 if (elf_section_data (o)->relocs != sec_relocs)
7750 /* There is no non-call reloc for this stub, so we do
7751 not need it. Since this function is called before
7752 the linker maps input sections to output sections, we
7753 can easily discard it by setting the SEC_EXCLUDE
7755 sec->flags |= SEC_EXCLUDE;
7759 /* Record this stub in an array of local symbol call_stubs for
7761 if (elf_tdata (abfd)->local_call_stubs == NULL)
7763 unsigned long symcount;
7767 if (elf_bad_symtab (abfd))
7768 symcount = NUM_SHDR_ENTRIES (symtab_hdr);
7770 symcount = symtab_hdr->sh_info;
7771 amt = symcount * sizeof (asection *);
7772 n = bfd_zalloc (abfd, amt);
7775 elf_tdata (abfd)->local_call_stubs = n;
7778 sec->flags |= SEC_KEEP;
7779 elf_tdata (abfd)->local_call_stubs[r_symndx] = sec;
7781 /* We don't need to set mips16_stubs_seen in this case.
7782 That flag is used to see whether we need to look through
7783 the global symbol table for stubs. We don't need to set
7784 it here, because we just have a local stub. */
7788 h = ((struct mips_elf_link_hash_entry *)
7789 sym_hashes[r_symndx - extsymoff]);
7791 /* H is the symbol this stub is for. */
7793 if (CALL_FP_STUB_P (name))
7794 loc = &h->call_fp_stub;
7796 loc = &h->call_stub;
7798 /* If we already have an appropriate stub for this function, we
7799 don't need another one, so we can discard this one. Since
7800 this function is called before the linker maps input sections
7801 to output sections, we can easily discard it by setting the
7802 SEC_EXCLUDE flag. */
7805 sec->flags |= SEC_EXCLUDE;
7809 sec->flags |= SEC_KEEP;
7811 mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
7817 for (rel = relocs; rel < rel_end; ++rel)
7819 unsigned long r_symndx;
7820 unsigned int r_type;
7821 struct elf_link_hash_entry *h;
7822 bfd_boolean can_make_dynamic_p;
7824 r_symndx = ELF_R_SYM (abfd, rel->r_info);
7825 r_type = ELF_R_TYPE (abfd, rel->r_info);
7827 if (r_symndx < extsymoff)
7829 else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
7831 (*_bfd_error_handler)
7832 (_("%B: Malformed reloc detected for section %s"),
7834 bfd_set_error (bfd_error_bad_value);
7839 h = sym_hashes[r_symndx - extsymoff];
7841 && (h->root.type == bfd_link_hash_indirect
7842 || h->root.type == bfd_link_hash_warning))
7843 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7846 /* Set CAN_MAKE_DYNAMIC_P to true if we can convert this
7847 relocation into a dynamic one. */
7848 can_make_dynamic_p = FALSE;
7853 case R_MIPS_CALL_HI16:
7854 case R_MIPS_CALL_LO16:
7855 case R_MIPS_GOT_HI16:
7856 case R_MIPS_GOT_LO16:
7857 case R_MIPS_GOT_PAGE:
7858 case R_MIPS_GOT_OFST:
7859 case R_MIPS_GOT_DISP:
7860 case R_MIPS_TLS_GOTTPREL:
7862 case R_MIPS_TLS_LDM:
7863 case R_MIPS16_GOT16:
7864 case R_MIPS16_CALL16:
7865 case R_MIPS16_TLS_GOTTPREL:
7866 case R_MIPS16_TLS_GD:
7867 case R_MIPS16_TLS_LDM:
7868 case R_MICROMIPS_GOT16:
7869 case R_MICROMIPS_CALL16:
7870 case R_MICROMIPS_CALL_HI16:
7871 case R_MICROMIPS_CALL_LO16:
7872 case R_MICROMIPS_GOT_HI16:
7873 case R_MICROMIPS_GOT_LO16:
7874 case R_MICROMIPS_GOT_PAGE:
7875 case R_MICROMIPS_GOT_OFST:
7876 case R_MICROMIPS_GOT_DISP:
7877 case R_MICROMIPS_TLS_GOTTPREL:
7878 case R_MICROMIPS_TLS_GD:
7879 case R_MICROMIPS_TLS_LDM:
7881 elf_hash_table (info)->dynobj = dynobj = abfd;
7882 if (!mips_elf_create_got_section (dynobj, info))
7884 if (htab->is_vxworks && !info->shared)
7886 (*_bfd_error_handler)
7887 (_("%B: GOT reloc at 0x%lx not expected in executables"),
7888 abfd, (unsigned long) rel->r_offset);
7889 bfd_set_error (bfd_error_bad_value);
7894 /* This is just a hint; it can safely be ignored. Don't set
7895 has_static_relocs for the corresponding symbol. */
7897 case R_MICROMIPS_JALR:
7903 /* In VxWorks executables, references to external symbols
7904 must be handled using copy relocs or PLT entries; it is not
7905 possible to convert this relocation into a dynamic one.
7907 For executables that use PLTs and copy-relocs, we have a
7908 choice between converting the relocation into a dynamic
7909 one or using copy relocations or PLT entries. It is
7910 usually better to do the former, unless the relocation is
7911 against a read-only section. */
7914 && !htab->is_vxworks
7915 && strcmp (h->root.root.string, "__gnu_local_gp") != 0
7916 && !(!info->nocopyreloc
7917 && !PIC_OBJECT_P (abfd)
7918 && MIPS_ELF_READONLY_SECTION (sec))))
7919 && (sec->flags & SEC_ALLOC) != 0)
7921 can_make_dynamic_p = TRUE;
7923 elf_hash_table (info)->dynobj = dynobj = abfd;
7926 /* For sections that are not SEC_ALLOC a copy reloc would be
7927 output if possible (implying questionable semantics for
7928 read-only data objects) or otherwise the final link would
7929 fail as ld.so will not process them and could not therefore
7930 handle any outstanding dynamic relocations.
7932 For such sections that are also SEC_DEBUGGING, we can avoid
7933 these problems by simply ignoring any relocs as these
7934 sections have a predefined use and we know it is safe to do
7937 This is needed in cases such as a global symbol definition
7938 in a shared library causing a common symbol from an object
7939 file to be converted to an undefined reference. If that
7940 happens, then all the relocations against this symbol from
7941 SEC_DEBUGGING sections in the object file will resolve to
7943 if ((sec->flags & SEC_DEBUGGING) != 0)
7948 /* Most static relocations require pointer equality, except
7951 h->pointer_equality_needed = TRUE;
7957 case R_MICROMIPS_26_S1:
7958 case R_MICROMIPS_PC7_S1:
7959 case R_MICROMIPS_PC10_S1:
7960 case R_MICROMIPS_PC16_S1:
7961 case R_MICROMIPS_PC23_S2:
7963 ((struct mips_elf_link_hash_entry *) h)->has_static_relocs = TRUE;
7969 /* Relocations against the special VxWorks __GOTT_BASE__ and
7970 __GOTT_INDEX__ symbols must be left to the loader. Allocate
7971 room for them in .rela.dyn. */
7972 if (is_gott_symbol (info, h))
7976 sreloc = mips_elf_rel_dyn_section (info, TRUE);
7980 mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
7981 if (MIPS_ELF_READONLY_SECTION (sec))
7982 /* We tell the dynamic linker that there are
7983 relocations against the text segment. */
7984 info->flags |= DF_TEXTREL;
7987 else if (call_lo16_reloc_p (r_type)
7988 || got_lo16_reloc_p (r_type)
7989 || got_disp_reloc_p (r_type)
7990 || (got16_reloc_p (r_type) && htab->is_vxworks))
7992 /* We may need a local GOT entry for this relocation. We
7993 don't count R_MIPS_GOT_PAGE because we can estimate the
7994 maximum number of pages needed by looking at the size of
7995 the segment. Similar comments apply to R_MIPS*_GOT16 and
7996 R_MIPS*_CALL16, except on VxWorks, where GOT relocations
7997 always evaluate to "G". We don't count R_MIPS_GOT_HI16, or
7998 R_MIPS_CALL_HI16 because these are always followed by an
7999 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
8000 if (!mips_elf_record_local_got_symbol (abfd, r_symndx,
8001 rel->r_addend, info, 0))
8006 && mips_elf_relocation_needs_la25_stub (abfd, r_type,
8007 ELF_ST_IS_MIPS16 (h->other)))
8008 ((struct mips_elf_link_hash_entry *) h)->has_nonpic_branches = TRUE;
8013 case R_MIPS16_CALL16:
8014 case R_MICROMIPS_CALL16:
8017 (*_bfd_error_handler)
8018 (_("%B: CALL16 reloc at 0x%lx not against global symbol"),
8019 abfd, (unsigned long) rel->r_offset);
8020 bfd_set_error (bfd_error_bad_value);
8025 case R_MIPS_CALL_HI16:
8026 case R_MIPS_CALL_LO16:
8027 case R_MICROMIPS_CALL_HI16:
8028 case R_MICROMIPS_CALL_LO16:
8031 /* Make sure there is room in the regular GOT to hold the
8032 function's address. We may eliminate it in favour of
8033 a .got.plt entry later; see mips_elf_count_got_symbols. */
8034 if (!mips_elf_record_global_got_symbol (h, abfd, info, TRUE, 0))
8037 /* We need a stub, not a plt entry for the undefined
8038 function. But we record it as if it needs plt. See
8039 _bfd_elf_adjust_dynamic_symbol. */
8045 case R_MIPS_GOT_PAGE:
8046 case R_MICROMIPS_GOT_PAGE:
8047 /* If this is a global, overridable symbol, GOT_PAGE will
8048 decay to GOT_DISP, so we'll need a GOT entry for it. */
8051 struct mips_elf_link_hash_entry *hmips =
8052 (struct mips_elf_link_hash_entry *) h;
8054 /* This symbol is definitely not overridable. */
8055 if (hmips->root.def_regular
8056 && ! (info->shared && ! info->symbolic
8057 && ! hmips->root.forced_local))
8062 case R_MIPS16_GOT16:
8064 case R_MIPS_GOT_HI16:
8065 case R_MIPS_GOT_LO16:
8066 case R_MICROMIPS_GOT16:
8067 case R_MICROMIPS_GOT_HI16:
8068 case R_MICROMIPS_GOT_LO16:
8069 if (!h || got_page_reloc_p (r_type))
8071 /* This relocation needs (or may need, if h != NULL) a
8072 page entry in the GOT. For R_MIPS_GOT_PAGE we do not
8073 know for sure until we know whether the symbol is
8075 if (mips_elf_rel_relocation_p (abfd, sec, relocs, rel))
8077 if (!mips_elf_get_section_contents (abfd, sec, &contents))
8079 howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, r_type, FALSE);
8080 addend = mips_elf_read_rel_addend (abfd, rel,
8082 if (got16_reloc_p (r_type))
8083 mips_elf_add_lo16_rel_addend (abfd, rel, rel_end,
8086 addend <<= howto->rightshift;
8089 addend = rel->r_addend;
8090 if (!mips_elf_record_got_page_entry (info, abfd, r_symndx,
8096 case R_MIPS_GOT_DISP:
8097 case R_MICROMIPS_GOT_DISP:
8098 if (h && !mips_elf_record_global_got_symbol (h, abfd, info,
8103 case R_MIPS_TLS_GOTTPREL:
8104 case R_MIPS16_TLS_GOTTPREL:
8105 case R_MICROMIPS_TLS_GOTTPREL:
8107 info->flags |= DF_STATIC_TLS;
8110 case R_MIPS_TLS_LDM:
8111 case R_MIPS16_TLS_LDM:
8112 case R_MICROMIPS_TLS_LDM:
8113 if (tls_ldm_reloc_p (r_type))
8115 r_symndx = STN_UNDEF;
8121 case R_MIPS16_TLS_GD:
8122 case R_MICROMIPS_TLS_GD:
8123 /* This symbol requires a global offset table entry, or two
8124 for TLS GD relocations. */
8128 flag = (tls_gd_reloc_p (r_type)
8130 : tls_ldm_reloc_p (r_type) ? GOT_TLS_LDM : GOT_TLS_IE);
8133 struct mips_elf_link_hash_entry *hmips =
8134 (struct mips_elf_link_hash_entry *) h;
8135 hmips->tls_type |= flag;
8137 if (h && !mips_elf_record_global_got_symbol (h, abfd, info,
8143 BFD_ASSERT (flag == GOT_TLS_LDM || r_symndx != STN_UNDEF);
8145 if (!mips_elf_record_local_got_symbol (abfd, r_symndx,
8156 /* In VxWorks executables, references to external symbols
8157 are handled using copy relocs or PLT stubs, so there's
8158 no need to add a .rela.dyn entry for this relocation. */
8159 if (can_make_dynamic_p)
8163 sreloc = mips_elf_rel_dyn_section (info, TRUE);
8167 if (info->shared && h == NULL)
8169 /* When creating a shared object, we must copy these
8170 reloc types into the output file as R_MIPS_REL32
8171 relocs. Make room for this reloc in .rel(a).dyn. */
8172 mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
8173 if (MIPS_ELF_READONLY_SECTION (sec))
8174 /* We tell the dynamic linker that there are
8175 relocations against the text segment. */
8176 info->flags |= DF_TEXTREL;
8180 struct mips_elf_link_hash_entry *hmips;
8182 /* For a shared object, we must copy this relocation
8183 unless the symbol turns out to be undefined and
8184 weak with non-default visibility, in which case
8185 it will be left as zero.
8187 We could elide R_MIPS_REL32 for locally binding symbols
8188 in shared libraries, but do not yet do so.
8190 For an executable, we only need to copy this
8191 reloc if the symbol is defined in a dynamic
8193 hmips = (struct mips_elf_link_hash_entry *) h;
8194 ++hmips->possibly_dynamic_relocs;
8195 if (MIPS_ELF_READONLY_SECTION (sec))
8196 /* We need it to tell the dynamic linker if there
8197 are relocations against the text segment. */
8198 hmips->readonly_reloc = TRUE;
8202 if (SGI_COMPAT (abfd))
8203 mips_elf_hash_table (info)->compact_rel_size +=
8204 sizeof (Elf32_External_crinfo);
8208 case R_MIPS_GPREL16:
8209 case R_MIPS_LITERAL:
8210 case R_MIPS_GPREL32:
8211 case R_MICROMIPS_26_S1:
8212 case R_MICROMIPS_GPREL16:
8213 case R_MICROMIPS_LITERAL:
8214 case R_MICROMIPS_GPREL7_S2:
8215 if (SGI_COMPAT (abfd))
8216 mips_elf_hash_table (info)->compact_rel_size +=
8217 sizeof (Elf32_External_crinfo);
8220 /* This relocation describes the C++ object vtable hierarchy.
8221 Reconstruct it for later use during GC. */
8222 case R_MIPS_GNU_VTINHERIT:
8223 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
8227 /* This relocation describes which C++ vtable entries are actually
8228 used. Record for later use during GC. */
8229 case R_MIPS_GNU_VTENTRY:
8230 BFD_ASSERT (h != NULL);
8232 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
8240 /* We must not create a stub for a symbol that has relocations
8241 related to taking the function's address. This doesn't apply to
8242 VxWorks, where CALL relocs refer to a .got.plt entry instead of
8243 a normal .got entry. */
8244 if (!htab->is_vxworks && h != NULL)
8248 ((struct mips_elf_link_hash_entry *) h)->no_fn_stub = TRUE;
8250 case R_MIPS16_CALL16:
8252 case R_MIPS_CALL_HI16:
8253 case R_MIPS_CALL_LO16:
8255 case R_MICROMIPS_CALL16:
8256 case R_MICROMIPS_CALL_HI16:
8257 case R_MICROMIPS_CALL_LO16:
8258 case R_MICROMIPS_JALR:
8262 /* See if this reloc would need to refer to a MIPS16 hard-float stub,
8263 if there is one. We only need to handle global symbols here;
8264 we decide whether to keep or delete stubs for local symbols
8265 when processing the stub's relocations. */
8267 && !mips16_call_reloc_p (r_type)
8268 && !section_allows_mips16_refs_p (sec))
8270 struct mips_elf_link_hash_entry *mh;
8272 mh = (struct mips_elf_link_hash_entry *) h;
8273 mh->need_fn_stub = TRUE;
8276 /* Refuse some position-dependent relocations when creating a
8277 shared library. Do not refuse R_MIPS_32 / R_MIPS_64; they're
8278 not PIC, but we can create dynamic relocations and the result
8279 will be fine. Also do not refuse R_MIPS_LO16, which can be
8280 combined with R_MIPS_GOT16. */
8288 case R_MIPS_HIGHEST:
8289 case R_MICROMIPS_HI16:
8290 case R_MICROMIPS_HIGHER:
8291 case R_MICROMIPS_HIGHEST:
8292 /* Don't refuse a high part relocation if it's against
8293 no symbol (e.g. part of a compound relocation). */
8294 if (r_symndx == STN_UNDEF)
8297 /* R_MIPS_HI16 against _gp_disp is used for $gp setup,
8298 and has a special meaning. */
8299 if (!NEWABI_P (abfd) && h != NULL
8300 && strcmp (h->root.root.string, "_gp_disp") == 0)
8303 /* Likewise __GOTT_BASE__ and __GOTT_INDEX__ on VxWorks. */
8304 if (is_gott_symbol (info, h))
8311 case R_MICROMIPS_26_S1:
8312 howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, r_type, FALSE);
8313 (*_bfd_error_handler)
8314 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
8316 (h) ? h->root.root.string : "a local symbol");
8317 bfd_set_error (bfd_error_bad_value);
8329 _bfd_mips_relax_section (bfd *abfd, asection *sec,
8330 struct bfd_link_info *link_info,
8333 Elf_Internal_Rela *internal_relocs;
8334 Elf_Internal_Rela *irel, *irelend;
8335 Elf_Internal_Shdr *symtab_hdr;
8336 bfd_byte *contents = NULL;
8338 bfd_boolean changed_contents = FALSE;
8339 bfd_vma sec_start = sec->output_section->vma + sec->output_offset;
8340 Elf_Internal_Sym *isymbuf = NULL;
8342 /* We are not currently changing any sizes, so only one pass. */
8345 if (link_info->relocatable)
8348 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
8349 link_info->keep_memory);
8350 if (internal_relocs == NULL)
8353 irelend = internal_relocs + sec->reloc_count
8354 * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel;
8355 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8356 extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
8358 for (irel = internal_relocs; irel < irelend; irel++)
8361 bfd_signed_vma sym_offset;
8362 unsigned int r_type;
8363 unsigned long r_symndx;
8365 unsigned long instruction;
8367 /* Turn jalr into bgezal, and jr into beq, if they're marked
8368 with a JALR relocation, that indicate where they jump to.
8369 This saves some pipeline bubbles. */
8370 r_type = ELF_R_TYPE (abfd, irel->r_info);
8371 if (r_type != R_MIPS_JALR)
8374 r_symndx = ELF_R_SYM (abfd, irel->r_info);
8375 /* Compute the address of the jump target. */
8376 if (r_symndx >= extsymoff)
8378 struct mips_elf_link_hash_entry *h
8379 = ((struct mips_elf_link_hash_entry *)
8380 elf_sym_hashes (abfd) [r_symndx - extsymoff]);
8382 while (h->root.root.type == bfd_link_hash_indirect
8383 || h->root.root.type == bfd_link_hash_warning)
8384 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
8386 /* If a symbol is undefined, or if it may be overridden,
8388 if (! ((h->root.root.type == bfd_link_hash_defined
8389 || h->root.root.type == bfd_link_hash_defweak)
8390 && h->root.root.u.def.section)
8391 || (link_info->shared && ! link_info->symbolic
8392 && !h->root.forced_local))
8395 sym_sec = h->root.root.u.def.section;
8396 if (sym_sec->output_section)
8397 symval = (h->root.root.u.def.value
8398 + sym_sec->output_section->vma
8399 + sym_sec->output_offset);
8401 symval = h->root.root.u.def.value;
8405 Elf_Internal_Sym *isym;
8407 /* Read this BFD's symbols if we haven't done so already. */
8408 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
8410 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
8411 if (isymbuf == NULL)
8412 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
8413 symtab_hdr->sh_info, 0,
8415 if (isymbuf == NULL)
8419 isym = isymbuf + r_symndx;
8420 if (isym->st_shndx == SHN_UNDEF)
8422 else if (isym->st_shndx == SHN_ABS)
8423 sym_sec = bfd_abs_section_ptr;
8424 else if (isym->st_shndx == SHN_COMMON)
8425 sym_sec = bfd_com_section_ptr;
8428 = bfd_section_from_elf_index (abfd, isym->st_shndx);
8429 symval = isym->st_value
8430 + sym_sec->output_section->vma
8431 + sym_sec->output_offset;
8434 /* Compute branch offset, from delay slot of the jump to the
8436 sym_offset = (symval + irel->r_addend)
8437 - (sec_start + irel->r_offset + 4);
8439 /* Branch offset must be properly aligned. */
8440 if ((sym_offset & 3) != 0)
8445 /* Check that it's in range. */
8446 if (sym_offset < -0x8000 || sym_offset >= 0x8000)
8449 /* Get the section contents if we haven't done so already. */
8450 if (!mips_elf_get_section_contents (abfd, sec, &contents))
8453 instruction = bfd_get_32 (abfd, contents + irel->r_offset);
8455 /* If it was jalr <reg>, turn it into bgezal $zero, <target>. */
8456 if ((instruction & 0xfc1fffff) == 0x0000f809)
8457 instruction = 0x04110000;
8458 /* If it was jr <reg>, turn it into b <target>. */
8459 else if ((instruction & 0xfc1fffff) == 0x00000008)
8460 instruction = 0x10000000;
8464 instruction |= (sym_offset & 0xffff);
8465 bfd_put_32 (abfd, instruction, contents + irel->r_offset);
8466 changed_contents = TRUE;
8469 if (contents != NULL
8470 && elf_section_data (sec)->this_hdr.contents != contents)
8472 if (!changed_contents && !link_info->keep_memory)
8476 /* Cache the section contents for elf_link_input_bfd. */
8477 elf_section_data (sec)->this_hdr.contents = contents;
8483 if (contents != NULL
8484 && elf_section_data (sec)->this_hdr.contents != contents)
8489 /* Allocate space for global sym dynamic relocs. */
8492 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8494 struct bfd_link_info *info = inf;
8496 struct mips_elf_link_hash_entry *hmips;
8497 struct mips_elf_link_hash_table *htab;
8499 htab = mips_elf_hash_table (info);
8500 BFD_ASSERT (htab != NULL);
8502 dynobj = elf_hash_table (info)->dynobj;
8503 hmips = (struct mips_elf_link_hash_entry *) h;
8505 /* VxWorks executables are handled elsewhere; we only need to
8506 allocate relocations in shared objects. */
8507 if (htab->is_vxworks && !info->shared)
8510 /* Ignore indirect symbols. All relocations against such symbols
8511 will be redirected to the target symbol. */
8512 if (h->root.type == bfd_link_hash_indirect)
8515 /* If this symbol is defined in a dynamic object, or we are creating
8516 a shared library, we will need to copy any R_MIPS_32 or
8517 R_MIPS_REL32 relocs against it into the output file. */
8518 if (! info->relocatable
8519 && hmips->possibly_dynamic_relocs != 0
8520 && (h->root.type == bfd_link_hash_defweak
8521 || (!h->def_regular && !ELF_COMMON_DEF_P (h))
8524 bfd_boolean do_copy = TRUE;
8526 if (h->root.type == bfd_link_hash_undefweak)
8528 /* Do not copy relocations for undefined weak symbols with
8529 non-default visibility. */
8530 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
8533 /* Make sure undefined weak symbols are output as a dynamic
8535 else if (h->dynindx == -1 && !h->forced_local)
8537 if (! bfd_elf_link_record_dynamic_symbol (info, h))
8544 /* Even though we don't directly need a GOT entry for this symbol,
8545 the SVR4 psABI requires it to have a dynamic symbol table
8546 index greater that DT_MIPS_GOTSYM if there are dynamic
8547 relocations against it.
8549 VxWorks does not enforce the same mapping between the GOT
8550 and the symbol table, so the same requirement does not
8552 if (!htab->is_vxworks)
8554 if (hmips->global_got_area > GGA_RELOC_ONLY)
8555 hmips->global_got_area = GGA_RELOC_ONLY;
8556 hmips->got_only_for_calls = FALSE;
8559 mips_elf_allocate_dynamic_relocations
8560 (dynobj, info, hmips->possibly_dynamic_relocs);
8561 if (hmips->readonly_reloc)
8562 /* We tell the dynamic linker that there are relocations
8563 against the text segment. */
8564 info->flags |= DF_TEXTREL;
8571 /* Adjust a symbol defined by a dynamic object and referenced by a
8572 regular object. The current definition is in some section of the
8573 dynamic object, but we're not including those sections. We have to
8574 change the definition to something the rest of the link can
8578 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
8579 struct elf_link_hash_entry *h)
8582 struct mips_elf_link_hash_entry *hmips;
8583 struct mips_elf_link_hash_table *htab;
8585 htab = mips_elf_hash_table (info);
8586 BFD_ASSERT (htab != NULL);
8588 dynobj = elf_hash_table (info)->dynobj;
8589 hmips = (struct mips_elf_link_hash_entry *) h;
8591 /* Make sure we know what is going on here. */
8592 BFD_ASSERT (dynobj != NULL
8594 || h->u.weakdef != NULL
8597 && !h->def_regular)));
8599 hmips = (struct mips_elf_link_hash_entry *) h;
8601 /* If there are call relocations against an externally-defined symbol,
8602 see whether we can create a MIPS lazy-binding stub for it. We can
8603 only do this if all references to the function are through call
8604 relocations, and in that case, the traditional lazy-binding stubs
8605 are much more efficient than PLT entries.
8607 Traditional stubs are only available on SVR4 psABI-based systems;
8608 VxWorks always uses PLTs instead. */
8609 if (!htab->is_vxworks && h->needs_plt && !hmips->no_fn_stub)
8611 if (! elf_hash_table (info)->dynamic_sections_created)
8614 /* If this symbol is not defined in a regular file, then set
8615 the symbol to the stub location. This is required to make
8616 function pointers compare as equal between the normal
8617 executable and the shared library. */
8618 if (!h->def_regular)
8620 hmips->needs_lazy_stub = TRUE;
8621 htab->lazy_stub_count++;
8625 /* As above, VxWorks requires PLT entries for externally-defined
8626 functions that are only accessed through call relocations.
8628 Both VxWorks and non-VxWorks targets also need PLT entries if there
8629 are static-only relocations against an externally-defined function.
8630 This can technically occur for shared libraries if there are
8631 branches to the symbol, although it is unlikely that this will be
8632 used in practice due to the short ranges involved. It can occur
8633 for any relative or absolute relocation in executables; in that
8634 case, the PLT entry becomes the function's canonical address. */
8635 else if (((h->needs_plt && !hmips->no_fn_stub)
8636 || (h->type == STT_FUNC && hmips->has_static_relocs))
8637 && htab->use_plts_and_copy_relocs
8638 && !SYMBOL_CALLS_LOCAL (info, h)
8639 && !(ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
8640 && h->root.type == bfd_link_hash_undefweak))
8642 /* If this is the first symbol to need a PLT entry, allocate room
8644 if (htab->splt->size == 0)
8646 BFD_ASSERT (htab->sgotplt->size == 0);
8648 /* If we're using the PLT additions to the psABI, each PLT
8649 entry is 16 bytes and the PLT0 entry is 32 bytes.
8650 Encourage better cache usage by aligning. We do this
8651 lazily to avoid pessimizing traditional objects. */
8652 if (!htab->is_vxworks
8653 && !bfd_set_section_alignment (dynobj, htab->splt, 5))
8656 /* Make sure that .got.plt is word-aligned. We do this lazily
8657 for the same reason as above. */
8658 if (!bfd_set_section_alignment (dynobj, htab->sgotplt,
8659 MIPS_ELF_LOG_FILE_ALIGN (dynobj)))
8662 htab->splt->size += htab->plt_header_size;
8664 /* On non-VxWorks targets, the first two entries in .got.plt
8666 if (!htab->is_vxworks)
8668 += get_elf_backend_data (dynobj)->got_header_size;
8670 /* On VxWorks, also allocate room for the header's
8671 .rela.plt.unloaded entries. */
8672 if (htab->is_vxworks && !info->shared)
8673 htab->srelplt2->size += 2 * sizeof (Elf32_External_Rela);
8676 /* Assign the next .plt entry to this symbol. */
8677 h->plt.offset = htab->splt->size;
8678 htab->splt->size += htab->plt_entry_size;
8680 /* If the output file has no definition of the symbol, set the
8681 symbol's value to the address of the stub. */
8682 if (!info->shared && !h->def_regular)
8684 h->root.u.def.section = htab->splt;
8685 h->root.u.def.value = h->plt.offset;
8686 /* For VxWorks, point at the PLT load stub rather than the
8687 lazy resolution stub; this stub will become the canonical
8688 function address. */
8689 if (htab->is_vxworks)
8690 h->root.u.def.value += 8;
8693 /* Make room for the .got.plt entry and the R_MIPS_JUMP_SLOT
8695 htab->sgotplt->size += MIPS_ELF_GOT_SIZE (dynobj);
8696 htab->srelplt->size += (htab->is_vxworks
8697 ? MIPS_ELF_RELA_SIZE (dynobj)
8698 : MIPS_ELF_REL_SIZE (dynobj));
8700 /* Make room for the .rela.plt.unloaded relocations. */
8701 if (htab->is_vxworks && !info->shared)
8702 htab->srelplt2->size += 3 * sizeof (Elf32_External_Rela);
8704 /* All relocations against this symbol that could have been made
8705 dynamic will now refer to the PLT entry instead. */
8706 hmips->possibly_dynamic_relocs = 0;
8711 /* If this is a weak symbol, and there is a real definition, the
8712 processor independent code will have arranged for us to see the
8713 real definition first, and we can just use the same value. */
8714 if (h->u.weakdef != NULL)
8716 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
8717 || h->u.weakdef->root.type == bfd_link_hash_defweak);
8718 h->root.u.def.section = h->u.weakdef->root.u.def.section;
8719 h->root.u.def.value = h->u.weakdef->root.u.def.value;
8723 /* Otherwise, there is nothing further to do for symbols defined
8724 in regular objects. */
8728 /* There's also nothing more to do if we'll convert all relocations
8729 against this symbol into dynamic relocations. */
8730 if (!hmips->has_static_relocs)
8733 /* We're now relying on copy relocations. Complain if we have
8734 some that we can't convert. */
8735 if (!htab->use_plts_and_copy_relocs || info->shared)
8737 (*_bfd_error_handler) (_("non-dynamic relocations refer to "
8738 "dynamic symbol %s"),
8739 h->root.root.string);
8740 bfd_set_error (bfd_error_bad_value);
8744 /* We must allocate the symbol in our .dynbss section, which will
8745 become part of the .bss section of the executable. There will be
8746 an entry for this symbol in the .dynsym section. The dynamic
8747 object will contain position independent code, so all references
8748 from the dynamic object to this symbol will go through the global
8749 offset table. The dynamic linker will use the .dynsym entry to
8750 determine the address it must put in the global offset table, so
8751 both the dynamic object and the regular object will refer to the
8752 same memory location for the variable. */
8754 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
8756 if (htab->is_vxworks)
8757 htab->srelbss->size += sizeof (Elf32_External_Rela);
8759 mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
8763 /* All relocations against this symbol that could have been made
8764 dynamic will now refer to the local copy instead. */
8765 hmips->possibly_dynamic_relocs = 0;
8767 return _bfd_elf_adjust_dynamic_copy (h, htab->sdynbss);
8770 /* This function is called after all the input files have been read,
8771 and the input sections have been assigned to output sections. We
8772 check for any mips16 stub sections that we can discard. */
8775 _bfd_mips_elf_always_size_sections (bfd *output_bfd,
8776 struct bfd_link_info *info)
8779 struct mips_elf_link_hash_table *htab;
8780 struct mips_htab_traverse_info hti;
8782 htab = mips_elf_hash_table (info);
8783 BFD_ASSERT (htab != NULL);
8785 /* The .reginfo section has a fixed size. */
8786 ri = bfd_get_section_by_name (output_bfd, ".reginfo");
8788 bfd_set_section_size (output_bfd, ri, sizeof (Elf32_External_RegInfo));
8791 hti.output_bfd = output_bfd;
8793 mips_elf_link_hash_traverse (mips_elf_hash_table (info),
8794 mips_elf_check_symbols, &hti);
8801 /* If the link uses a GOT, lay it out and work out its size. */
8804 mips_elf_lay_out_got (bfd *output_bfd, struct bfd_link_info *info)
8808 struct mips_got_info *g;
8809 bfd_size_type loadable_size = 0;
8810 bfd_size_type page_gotno;
8812 struct mips_elf_count_tls_arg count_tls_arg;
8813 struct mips_elf_link_hash_table *htab;
8815 htab = mips_elf_hash_table (info);
8816 BFD_ASSERT (htab != NULL);
8822 dynobj = elf_hash_table (info)->dynobj;
8825 /* Allocate room for the reserved entries. VxWorks always reserves
8826 3 entries; other objects only reserve 2 entries. */
8827 BFD_ASSERT (g->assigned_gotno == 0);
8828 if (htab->is_vxworks)
8829 htab->reserved_gotno = 3;
8831 htab->reserved_gotno = 2;
8832 g->local_gotno += htab->reserved_gotno;
8833 g->assigned_gotno = htab->reserved_gotno;
8835 /* Replace entries for indirect and warning symbols with entries for
8836 the target symbol. */
8837 if (!mips_elf_resolve_final_got_entries (g))
8840 /* Count the number of GOT symbols. */
8841 mips_elf_link_hash_traverse (htab, mips_elf_count_got_symbols, info);
8843 /* Calculate the total loadable size of the output. That
8844 will give us the maximum number of GOT_PAGE entries
8846 for (sub = info->input_bfds; sub; sub = sub->link_next)
8848 asection *subsection;
8850 for (subsection = sub->sections;
8852 subsection = subsection->next)
8854 if ((subsection->flags & SEC_ALLOC) == 0)
8856 loadable_size += ((subsection->size + 0xf)
8857 &~ (bfd_size_type) 0xf);
8861 if (htab->is_vxworks)
8862 /* There's no need to allocate page entries for VxWorks; R_MIPS*_GOT16
8863 relocations against local symbols evaluate to "G", and the EABI does
8864 not include R_MIPS_GOT_PAGE. */
8867 /* Assume there are two loadable segments consisting of contiguous
8868 sections. Is 5 enough? */
8869 page_gotno = (loadable_size >> 16) + 5;
8871 /* Choose the smaller of the two estimates; both are intended to be
8873 if (page_gotno > g->page_gotno)
8874 page_gotno = g->page_gotno;
8876 g->local_gotno += page_gotno;
8877 s->size += g->local_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
8878 s->size += g->global_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
8880 /* We need to calculate tls_gotno for global symbols at this point
8881 instead of building it up earlier, to avoid doublecounting
8882 entries for one global symbol from multiple input files. */
8883 count_tls_arg.info = info;
8884 count_tls_arg.needed = 0;
8885 elf_link_hash_traverse (elf_hash_table (info),
8886 mips_elf_count_global_tls_entries,
8888 g->tls_gotno += count_tls_arg.needed;
8889 s->size += g->tls_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
8891 /* VxWorks does not support multiple GOTs. It initializes $gp to
8892 __GOTT_BASE__[__GOTT_INDEX__], the value of which is set by the
8894 if (htab->is_vxworks)
8896 /* VxWorks executables do not need a GOT. */
8899 /* Each VxWorks GOT entry needs an explicit relocation. */
8902 count = g->global_gotno + g->local_gotno - htab->reserved_gotno;
8904 mips_elf_allocate_dynamic_relocations (dynobj, info, count);
8907 else if (s->size > MIPS_ELF_GOT_MAX_SIZE (info))
8909 if (!mips_elf_multi_got (output_bfd, info, s, page_gotno))
8914 struct mips_elf_count_tls_arg arg;
8916 /* Set up TLS entries. */
8917 g->tls_assigned_gotno = g->global_gotno + g->local_gotno;
8918 htab_traverse (g->got_entries, mips_elf_initialize_tls_index, g);
8919 BFD_ASSERT (g->tls_assigned_gotno
8920 == g->global_gotno + g->local_gotno + g->tls_gotno);
8922 /* Allocate room for the TLS relocations. */
8925 htab_traverse (g->got_entries, mips_elf_count_local_tls_relocs, &arg);
8926 elf_link_hash_traverse (elf_hash_table (info),
8927 mips_elf_count_global_tls_relocs,
8930 mips_elf_allocate_dynamic_relocations (dynobj, info, arg.needed);
8936 /* Estimate the size of the .MIPS.stubs section. */
8939 mips_elf_estimate_stub_size (bfd *output_bfd, struct bfd_link_info *info)
8941 struct mips_elf_link_hash_table *htab;
8942 bfd_size_type dynsymcount;
8944 htab = mips_elf_hash_table (info);
8945 BFD_ASSERT (htab != NULL);
8947 if (htab->lazy_stub_count == 0)
8950 /* IRIX rld assumes that a function stub isn't at the end of the .text
8951 section, so add a dummy entry to the end. */
8952 htab->lazy_stub_count++;
8954 /* Get a worst-case estimate of the number of dynamic symbols needed.
8955 At this point, dynsymcount does not account for section symbols
8956 and count_section_dynsyms may overestimate the number that will
8958 dynsymcount = (elf_hash_table (info)->dynsymcount
8959 + count_section_dynsyms (output_bfd, info));
8961 /* Determine the size of one stub entry. */
8962 htab->function_stub_size = (dynsymcount > 0x10000
8963 ? MIPS_FUNCTION_STUB_BIG_SIZE
8964 : MIPS_FUNCTION_STUB_NORMAL_SIZE);
8966 htab->sstubs->size = htab->lazy_stub_count * htab->function_stub_size;
8969 /* A mips_elf_link_hash_traverse callback for which DATA points to the
8970 MIPS hash table. If H needs a traditional MIPS lazy-binding stub,
8971 allocate an entry in the stubs section. */
8974 mips_elf_allocate_lazy_stub (struct mips_elf_link_hash_entry *h, void **data)
8976 struct mips_elf_link_hash_table *htab;
8978 htab = (struct mips_elf_link_hash_table *) data;
8979 if (h->needs_lazy_stub)
8981 h->root.root.u.def.section = htab->sstubs;
8982 h->root.root.u.def.value = htab->sstubs->size;
8983 h->root.plt.offset = htab->sstubs->size;
8984 htab->sstubs->size += htab->function_stub_size;
8989 /* Allocate offsets in the stubs section to each symbol that needs one.
8990 Set the final size of the .MIPS.stub section. */
8993 mips_elf_lay_out_lazy_stubs (struct bfd_link_info *info)
8995 struct mips_elf_link_hash_table *htab;
8997 htab = mips_elf_hash_table (info);
8998 BFD_ASSERT (htab != NULL);
9000 if (htab->lazy_stub_count == 0)
9003 htab->sstubs->size = 0;
9004 mips_elf_link_hash_traverse (htab, mips_elf_allocate_lazy_stub, htab);
9005 htab->sstubs->size += htab->function_stub_size;
9006 BFD_ASSERT (htab->sstubs->size
9007 == htab->lazy_stub_count * htab->function_stub_size);
9010 /* Set the sizes of the dynamic sections. */
9013 _bfd_mips_elf_size_dynamic_sections (bfd *output_bfd,
9014 struct bfd_link_info *info)
9017 asection *s, *sreldyn;
9018 bfd_boolean reltext;
9019 struct mips_elf_link_hash_table *htab;
9021 htab = mips_elf_hash_table (info);
9022 BFD_ASSERT (htab != NULL);
9023 dynobj = elf_hash_table (info)->dynobj;
9024 BFD_ASSERT (dynobj != NULL);
9026 if (elf_hash_table (info)->dynamic_sections_created)
9028 /* Set the contents of the .interp section to the interpreter. */
9029 if (info->executable)
9031 s = bfd_get_linker_section (dynobj, ".interp");
9032 BFD_ASSERT (s != NULL);
9034 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd)) + 1;
9036 = (bfd_byte *) ELF_DYNAMIC_INTERPRETER (output_bfd);
9039 /* Create a symbol for the PLT, if we know that we are using it. */
9040 if (htab->splt && htab->splt->size > 0 && htab->root.hplt == NULL)
9042 struct elf_link_hash_entry *h;
9044 BFD_ASSERT (htab->use_plts_and_copy_relocs);
9046 h = _bfd_elf_define_linkage_sym (dynobj, info, htab->splt,
9047 "_PROCEDURE_LINKAGE_TABLE_");
9048 htab->root.hplt = h;
9055 /* Allocate space for global sym dynamic relocs. */
9056 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
9058 mips_elf_estimate_stub_size (output_bfd, info);
9060 if (!mips_elf_lay_out_got (output_bfd, info))
9063 mips_elf_lay_out_lazy_stubs (info);
9065 /* The check_relocs and adjust_dynamic_symbol entry points have
9066 determined the sizes of the various dynamic sections. Allocate
9069 for (s = dynobj->sections; s != NULL; s = s->next)
9073 /* It's OK to base decisions on the section name, because none
9074 of the dynobj section names depend upon the input files. */
9075 name = bfd_get_section_name (dynobj, s);
9077 if ((s->flags & SEC_LINKER_CREATED) == 0)
9080 if (CONST_STRNEQ (name, ".rel"))
9084 const char *outname;
9087 /* If this relocation section applies to a read only
9088 section, then we probably need a DT_TEXTREL entry.
9089 If the relocation section is .rel(a).dyn, we always
9090 assert a DT_TEXTREL entry rather than testing whether
9091 there exists a relocation to a read only section or
9093 outname = bfd_get_section_name (output_bfd,
9095 target = bfd_get_section_by_name (output_bfd, outname + 4);
9097 && (target->flags & SEC_READONLY) != 0
9098 && (target->flags & SEC_ALLOC) != 0)
9099 || strcmp (outname, MIPS_ELF_REL_DYN_NAME (info)) == 0)
9102 /* We use the reloc_count field as a counter if we need
9103 to copy relocs into the output file. */
9104 if (strcmp (name, MIPS_ELF_REL_DYN_NAME (info)) != 0)
9107 /* If combreloc is enabled, elf_link_sort_relocs() will
9108 sort relocations, but in a different way than we do,
9109 and before we're done creating relocations. Also, it
9110 will move them around between input sections'
9111 relocation's contents, so our sorting would be
9112 broken, so don't let it run. */
9113 info->combreloc = 0;
9116 else if (! info->shared
9117 && ! mips_elf_hash_table (info)->use_rld_obj_head
9118 && CONST_STRNEQ (name, ".rld_map"))
9120 /* We add a room for __rld_map. It will be filled in by the
9121 rtld to contain a pointer to the _r_debug structure. */
9122 s->size += MIPS_ELF_RLD_MAP_SIZE (output_bfd);
9124 else if (SGI_COMPAT (output_bfd)
9125 && CONST_STRNEQ (name, ".compact_rel"))
9126 s->size += mips_elf_hash_table (info)->compact_rel_size;
9127 else if (s == htab->splt)
9129 /* If the last PLT entry has a branch delay slot, allocate
9130 room for an extra nop to fill the delay slot. This is
9131 for CPUs without load interlocking. */
9132 if (! LOAD_INTERLOCKS_P (output_bfd)
9133 && ! htab->is_vxworks && s->size > 0)
9136 else if (! CONST_STRNEQ (name, ".init")
9138 && s != htab->sgotplt
9139 && s != htab->sstubs
9140 && s != htab->sdynbss)
9142 /* It's not one of our sections, so don't allocate space. */
9148 s->flags |= SEC_EXCLUDE;
9152 if ((s->flags & SEC_HAS_CONTENTS) == 0)
9155 /* Allocate memory for the section contents. */
9156 s->contents = bfd_zalloc (dynobj, s->size);
9157 if (s->contents == NULL)
9159 bfd_set_error (bfd_error_no_memory);
9164 if (elf_hash_table (info)->dynamic_sections_created)
9166 /* Add some entries to the .dynamic section. We fill in the
9167 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
9168 must add the entries now so that we get the correct size for
9169 the .dynamic section. */
9171 /* SGI object has the equivalence of DT_DEBUG in the
9172 DT_MIPS_RLD_MAP entry. This must come first because glibc
9173 only fills in DT_MIPS_RLD_MAP (not DT_DEBUG) and some tools
9174 may only look at the first one they see. */
9176 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP, 0))
9179 /* The DT_DEBUG entry may be filled in by the dynamic linker and
9180 used by the debugger. */
9181 if (info->executable
9182 && !SGI_COMPAT (output_bfd)
9183 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
9186 if (reltext && (SGI_COMPAT (output_bfd) || htab->is_vxworks))
9187 info->flags |= DF_TEXTREL;
9189 if ((info->flags & DF_TEXTREL) != 0)
9191 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0))
9194 /* Clear the DF_TEXTREL flag. It will be set again if we
9195 write out an actual text relocation; we may not, because
9196 at this point we do not know whether e.g. any .eh_frame
9197 absolute relocations have been converted to PC-relative. */
9198 info->flags &= ~DF_TEXTREL;
9201 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0))
9204 sreldyn = mips_elf_rel_dyn_section (info, FALSE);
9205 if (htab->is_vxworks)
9207 /* VxWorks uses .rela.dyn instead of .rel.dyn. It does not
9208 use any of the DT_MIPS_* tags. */
9209 if (sreldyn && sreldyn->size > 0)
9211 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELA, 0))
9214 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELASZ, 0))
9217 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELAENT, 0))
9223 if (sreldyn && sreldyn->size > 0)
9225 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0))
9228 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0))
9231 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0))
9235 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_VERSION, 0))
9238 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_FLAGS, 0))
9241 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_BASE_ADDRESS, 0))
9244 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LOCAL_GOTNO, 0))
9247 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_SYMTABNO, 0))
9250 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_UNREFEXTNO, 0))
9253 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_GOTSYM, 0))
9256 if (IRIX_COMPAT (dynobj) == ict_irix5
9257 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_HIPAGENO, 0))
9260 if (IRIX_COMPAT (dynobj) == ict_irix6
9261 && (bfd_get_section_by_name
9262 (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj)))
9263 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_OPTIONS, 0))
9266 if (htab->splt->size > 0)
9268 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTREL, 0))
9271 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_JMPREL, 0))
9274 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTRELSZ, 0))
9277 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_PLTGOT, 0))
9280 if (htab->is_vxworks
9281 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
9288 /* REL is a relocation in INPUT_BFD that is being copied to OUTPUT_BFD.
9289 Adjust its R_ADDEND field so that it is correct for the output file.
9290 LOCAL_SYMS and LOCAL_SECTIONS are arrays of INPUT_BFD's local symbols
9291 and sections respectively; both use symbol indexes. */
9294 mips_elf_adjust_addend (bfd *output_bfd, struct bfd_link_info *info,
9295 bfd *input_bfd, Elf_Internal_Sym *local_syms,
9296 asection **local_sections, Elf_Internal_Rela *rel)
9298 unsigned int r_type, r_symndx;
9299 Elf_Internal_Sym *sym;
9302 if (mips_elf_local_relocation_p (input_bfd, rel, local_sections))
9304 r_type = ELF_R_TYPE (output_bfd, rel->r_info);
9305 if (gprel16_reloc_p (r_type)
9306 || r_type == R_MIPS_GPREL32
9307 || literal_reloc_p (r_type))
9309 rel->r_addend += _bfd_get_gp_value (input_bfd);
9310 rel->r_addend -= _bfd_get_gp_value (output_bfd);
9313 r_symndx = ELF_R_SYM (output_bfd, rel->r_info);
9314 sym = local_syms + r_symndx;
9316 /* Adjust REL's addend to account for section merging. */
9317 if (!info->relocatable)
9319 sec = local_sections[r_symndx];
9320 _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
9323 /* This would normally be done by the rela_normal code in elflink.c. */
9324 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
9325 rel->r_addend += local_sections[r_symndx]->output_offset;
9329 /* Handle relocations against symbols from removed linkonce sections,
9330 or sections discarded by a linker script. We use this wrapper around
9331 RELOC_AGAINST_DISCARDED_SECTION to handle triplets of compound relocs
9332 on 64-bit ELF targets. In this case for any relocation handled, which
9333 always be the first in a triplet, the remaining two have to be processed
9334 together with the first, even if they are R_MIPS_NONE. It is the symbol
9335 index referred by the first reloc that applies to all the three and the
9336 remaining two never refer to an object symbol. And it is the final
9337 relocation (the last non-null one) that determines the output field of
9338 the whole relocation so retrieve the corresponding howto structure for
9339 the relocatable field to be cleared by RELOC_AGAINST_DISCARDED_SECTION.
9341 Note that RELOC_AGAINST_DISCARDED_SECTION is a macro that uses "continue"
9342 and therefore requires to be pasted in a loop. It also defines a block
9343 and does not protect any of its arguments, hence the extra brackets. */
9346 mips_reloc_against_discarded_section (bfd *output_bfd,
9347 struct bfd_link_info *info,
9348 bfd *input_bfd, asection *input_section,
9349 Elf_Internal_Rela **rel,
9350 const Elf_Internal_Rela **relend,
9351 bfd_boolean rel_reloc,
9352 reloc_howto_type *howto,
9355 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
9356 int count = bed->s->int_rels_per_ext_rel;
9357 unsigned int r_type;
9360 for (i = count - 1; i > 0; i--)
9362 r_type = ELF_R_TYPE (output_bfd, (*rel)[i].r_info);
9363 if (r_type != R_MIPS_NONE)
9365 howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type, !rel_reloc);
9371 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
9372 (*rel), count, (*relend),
9373 howto, i, contents);
9378 /* Relocate a MIPS ELF section. */
9381 _bfd_mips_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
9382 bfd *input_bfd, asection *input_section,
9383 bfd_byte *contents, Elf_Internal_Rela *relocs,
9384 Elf_Internal_Sym *local_syms,
9385 asection **local_sections)
9387 Elf_Internal_Rela *rel;
9388 const Elf_Internal_Rela *relend;
9390 bfd_boolean use_saved_addend_p = FALSE;
9391 const struct elf_backend_data *bed;
9393 bed = get_elf_backend_data (output_bfd);
9394 relend = relocs + input_section->reloc_count * bed->s->int_rels_per_ext_rel;
9395 for (rel = relocs; rel < relend; ++rel)
9399 reloc_howto_type *howto;
9400 bfd_boolean cross_mode_jump_p;
9401 /* TRUE if the relocation is a RELA relocation, rather than a
9403 bfd_boolean rela_relocation_p = TRUE;
9404 unsigned int r_type = ELF_R_TYPE (output_bfd, rel->r_info);
9406 unsigned long r_symndx;
9408 Elf_Internal_Shdr *symtab_hdr;
9409 struct elf_link_hash_entry *h;
9410 bfd_boolean rel_reloc;
9412 rel_reloc = (NEWABI_P (input_bfd)
9413 && mips_elf_rel_relocation_p (input_bfd, input_section,
9415 /* Find the relocation howto for this relocation. */
9416 howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type, !rel_reloc);
9418 r_symndx = ELF_R_SYM (input_bfd, rel->r_info);
9419 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
9420 if (mips_elf_local_relocation_p (input_bfd, rel, local_sections))
9422 sec = local_sections[r_symndx];
9427 unsigned long extsymoff;
9430 if (!elf_bad_symtab (input_bfd))
9431 extsymoff = symtab_hdr->sh_info;
9432 h = elf_sym_hashes (input_bfd) [r_symndx - extsymoff];
9433 while (h->root.type == bfd_link_hash_indirect
9434 || h->root.type == bfd_link_hash_warning)
9435 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9438 if (h->root.type == bfd_link_hash_defined
9439 || h->root.type == bfd_link_hash_defweak)
9440 sec = h->root.u.def.section;
9443 if (sec != NULL && discarded_section (sec))
9445 mips_reloc_against_discarded_section (output_bfd, info, input_bfd,
9446 input_section, &rel, &relend,
9447 rel_reloc, howto, contents);
9451 if (r_type == R_MIPS_64 && ! NEWABI_P (input_bfd))
9453 /* Some 32-bit code uses R_MIPS_64. In particular, people use
9454 64-bit code, but make sure all their addresses are in the
9455 lowermost or uppermost 32-bit section of the 64-bit address
9456 space. Thus, when they use an R_MIPS_64 they mean what is
9457 usually meant by R_MIPS_32, with the exception that the
9458 stored value is sign-extended to 64 bits. */
9459 howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, R_MIPS_32, FALSE);
9461 /* On big-endian systems, we need to lie about the position
9463 if (bfd_big_endian (input_bfd))
9467 if (!use_saved_addend_p)
9469 /* If these relocations were originally of the REL variety,
9470 we must pull the addend out of the field that will be
9471 relocated. Otherwise, we simply use the contents of the
9473 if (mips_elf_rel_relocation_p (input_bfd, input_section,
9476 rela_relocation_p = FALSE;
9477 addend = mips_elf_read_rel_addend (input_bfd, rel,
9479 if (hi16_reloc_p (r_type)
9480 || (got16_reloc_p (r_type)
9481 && mips_elf_local_relocation_p (input_bfd, rel,
9484 if (!mips_elf_add_lo16_rel_addend (input_bfd, rel, relend,
9488 name = h->root.root.string;
9490 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
9491 local_syms + r_symndx,
9493 (*_bfd_error_handler)
9494 (_("%B: Can't find matching LO16 reloc against `%s' for %s at 0x%lx in section `%A'"),
9495 input_bfd, input_section, name, howto->name,
9500 addend <<= howto->rightshift;
9503 addend = rel->r_addend;
9504 mips_elf_adjust_addend (output_bfd, info, input_bfd,
9505 local_syms, local_sections, rel);
9508 if (info->relocatable)
9510 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd)
9511 && bfd_big_endian (input_bfd))
9514 if (!rela_relocation_p && rel->r_addend)
9516 addend += rel->r_addend;
9517 if (hi16_reloc_p (r_type) || got16_reloc_p (r_type))
9518 addend = mips_elf_high (addend);
9519 else if (r_type == R_MIPS_HIGHER)
9520 addend = mips_elf_higher (addend);
9521 else if (r_type == R_MIPS_HIGHEST)
9522 addend = mips_elf_highest (addend);
9524 addend >>= howto->rightshift;
9526 /* We use the source mask, rather than the destination
9527 mask because the place to which we are writing will be
9528 source of the addend in the final link. */
9529 addend &= howto->src_mask;
9531 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
9532 /* See the comment above about using R_MIPS_64 in the 32-bit
9533 ABI. Here, we need to update the addend. It would be
9534 possible to get away with just using the R_MIPS_32 reloc
9535 but for endianness. */
9541 if (addend & ((bfd_vma) 1 << 31))
9543 sign_bits = ((bfd_vma) 1 << 32) - 1;
9550 /* If we don't know that we have a 64-bit type,
9551 do two separate stores. */
9552 if (bfd_big_endian (input_bfd))
9554 /* Store the sign-bits (which are most significant)
9556 low_bits = sign_bits;
9562 high_bits = sign_bits;
9564 bfd_put_32 (input_bfd, low_bits,
9565 contents + rel->r_offset);
9566 bfd_put_32 (input_bfd, high_bits,
9567 contents + rel->r_offset + 4);
9571 if (! mips_elf_perform_relocation (info, howto, rel, addend,
9572 input_bfd, input_section,
9577 /* Go on to the next relocation. */
9581 /* In the N32 and 64-bit ABIs there may be multiple consecutive
9582 relocations for the same offset. In that case we are
9583 supposed to treat the output of each relocation as the addend
9585 if (rel + 1 < relend
9586 && rel->r_offset == rel[1].r_offset
9587 && ELF_R_TYPE (input_bfd, rel[1].r_info) != R_MIPS_NONE)
9588 use_saved_addend_p = TRUE;
9590 use_saved_addend_p = FALSE;
9592 /* Figure out what value we are supposed to relocate. */
9593 switch (mips_elf_calculate_relocation (output_bfd, input_bfd,
9594 input_section, info, rel,
9595 addend, howto, local_syms,
9596 local_sections, &value,
9597 &name, &cross_mode_jump_p,
9598 use_saved_addend_p))
9600 case bfd_reloc_continue:
9601 /* There's nothing to do. */
9604 case bfd_reloc_undefined:
9605 /* mips_elf_calculate_relocation already called the
9606 undefined_symbol callback. There's no real point in
9607 trying to perform the relocation at this point, so we
9608 just skip ahead to the next relocation. */
9611 case bfd_reloc_notsupported:
9612 msg = _("internal error: unsupported relocation error");
9613 info->callbacks->warning
9614 (info, msg, name, input_bfd, input_section, rel->r_offset);
9617 case bfd_reloc_overflow:
9618 if (use_saved_addend_p)
9619 /* Ignore overflow until we reach the last relocation for
9620 a given location. */
9624 struct mips_elf_link_hash_table *htab;
9626 htab = mips_elf_hash_table (info);
9627 BFD_ASSERT (htab != NULL);
9628 BFD_ASSERT (name != NULL);
9629 if (!htab->small_data_overflow_reported
9630 && (gprel16_reloc_p (howto->type)
9631 || literal_reloc_p (howto->type)))
9633 msg = _("small-data section exceeds 64KB;"
9634 " lower small-data size limit (see option -G)");
9636 htab->small_data_overflow_reported = TRUE;
9637 (*info->callbacks->einfo) ("%P: %s\n", msg);
9639 if (! ((*info->callbacks->reloc_overflow)
9640 (info, NULL, name, howto->name, (bfd_vma) 0,
9641 input_bfd, input_section, rel->r_offset)))
9649 case bfd_reloc_outofrange:
9650 if (jal_reloc_p (howto->type))
9652 msg = _("JALX to a non-word-aligned address");
9653 info->callbacks->warning
9654 (info, msg, name, input_bfd, input_section, rel->r_offset);
9664 /* If we've got another relocation for the address, keep going
9665 until we reach the last one. */
9666 if (use_saved_addend_p)
9672 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
9673 /* See the comment above about using R_MIPS_64 in the 32-bit
9674 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
9675 that calculated the right value. Now, however, we
9676 sign-extend the 32-bit result to 64-bits, and store it as a
9677 64-bit value. We are especially generous here in that we
9678 go to extreme lengths to support this usage on systems with
9679 only a 32-bit VMA. */
9685 if (value & ((bfd_vma) 1 << 31))
9687 sign_bits = ((bfd_vma) 1 << 32) - 1;
9694 /* If we don't know that we have a 64-bit type,
9695 do two separate stores. */
9696 if (bfd_big_endian (input_bfd))
9698 /* Undo what we did above. */
9700 /* Store the sign-bits (which are most significant)
9702 low_bits = sign_bits;
9708 high_bits = sign_bits;
9710 bfd_put_32 (input_bfd, low_bits,
9711 contents + rel->r_offset);
9712 bfd_put_32 (input_bfd, high_bits,
9713 contents + rel->r_offset + 4);
9717 /* Actually perform the relocation. */
9718 if (! mips_elf_perform_relocation (info, howto, rel, value,
9719 input_bfd, input_section,
9720 contents, cross_mode_jump_p))
9727 /* A function that iterates over each entry in la25_stubs and fills
9728 in the code for each one. DATA points to a mips_htab_traverse_info. */
9731 mips_elf_create_la25_stub (void **slot, void *data)
9733 struct mips_htab_traverse_info *hti;
9734 struct mips_elf_link_hash_table *htab;
9735 struct mips_elf_la25_stub *stub;
9738 bfd_vma offset, target, target_high, target_low;
9740 stub = (struct mips_elf_la25_stub *) *slot;
9741 hti = (struct mips_htab_traverse_info *) data;
9742 htab = mips_elf_hash_table (hti->info);
9743 BFD_ASSERT (htab != NULL);
9745 /* Create the section contents, if we haven't already. */
9746 s = stub->stub_section;
9750 loc = bfd_malloc (s->size);
9759 /* Work out where in the section this stub should go. */
9760 offset = stub->offset;
9762 /* Work out the target address. */
9763 target = mips_elf_get_la25_target (stub, &s);
9764 target += s->output_section->vma + s->output_offset;
9766 target_high = ((target + 0x8000) >> 16) & 0xffff;
9767 target_low = (target & 0xffff);
9769 if (stub->stub_section != htab->strampoline)
9771 /* This is a simple LUI/ADDIU stub. Zero out the beginning
9772 of the section and write the two instructions at the end. */
9773 memset (loc, 0, offset);
9775 if (ELF_ST_IS_MICROMIPS (stub->h->root.other))
9777 bfd_put_micromips_32 (hti->output_bfd,
9778 LA25_LUI_MICROMIPS (target_high),
9780 bfd_put_micromips_32 (hti->output_bfd,
9781 LA25_ADDIU_MICROMIPS (target_low),
9786 bfd_put_32 (hti->output_bfd, LA25_LUI (target_high), loc);
9787 bfd_put_32 (hti->output_bfd, LA25_ADDIU (target_low), loc + 4);
9792 /* This is trampoline. */
9794 if (ELF_ST_IS_MICROMIPS (stub->h->root.other))
9796 bfd_put_micromips_32 (hti->output_bfd,
9797 LA25_LUI_MICROMIPS (target_high), loc);
9798 bfd_put_micromips_32 (hti->output_bfd,
9799 LA25_J_MICROMIPS (target), loc + 4);
9800 bfd_put_micromips_32 (hti->output_bfd,
9801 LA25_ADDIU_MICROMIPS (target_low), loc + 8);
9802 bfd_put_32 (hti->output_bfd, 0, loc + 12);
9806 bfd_put_32 (hti->output_bfd, LA25_LUI (target_high), loc);
9807 bfd_put_32 (hti->output_bfd, LA25_J (target), loc + 4);
9808 bfd_put_32 (hti->output_bfd, LA25_ADDIU (target_low), loc + 8);
9809 bfd_put_32 (hti->output_bfd, 0, loc + 12);
9815 /* If NAME is one of the special IRIX6 symbols defined by the linker,
9816 adjust it appropriately now. */
9819 mips_elf_irix6_finish_dynamic_symbol (bfd *abfd ATTRIBUTE_UNUSED,
9820 const char *name, Elf_Internal_Sym *sym)
9822 /* The linker script takes care of providing names and values for
9823 these, but we must place them into the right sections. */
9824 static const char* const text_section_symbols[] = {
9827 "__dso_displacement",
9829 "__program_header_table",
9833 static const char* const data_section_symbols[] = {
9841 const char* const *p;
9844 for (i = 0; i < 2; ++i)
9845 for (p = (i == 0) ? text_section_symbols : data_section_symbols;
9848 if (strcmp (*p, name) == 0)
9850 /* All of these symbols are given type STT_SECTION by the
9852 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
9853 sym->st_other = STO_PROTECTED;
9855 /* The IRIX linker puts these symbols in special sections. */
9857 sym->st_shndx = SHN_MIPS_TEXT;
9859 sym->st_shndx = SHN_MIPS_DATA;
9865 /* Finish up dynamic symbol handling. We set the contents of various
9866 dynamic sections here. */
9869 _bfd_mips_elf_finish_dynamic_symbol (bfd *output_bfd,
9870 struct bfd_link_info *info,
9871 struct elf_link_hash_entry *h,
9872 Elf_Internal_Sym *sym)
9876 struct mips_got_info *g, *gg;
9879 struct mips_elf_link_hash_table *htab;
9880 struct mips_elf_link_hash_entry *hmips;
9882 htab = mips_elf_hash_table (info);
9883 BFD_ASSERT (htab != NULL);
9884 dynobj = elf_hash_table (info)->dynobj;
9885 hmips = (struct mips_elf_link_hash_entry *) h;
9887 BFD_ASSERT (!htab->is_vxworks);
9889 if (h->plt.offset != MINUS_ONE && hmips->no_fn_stub)
9891 /* We've decided to create a PLT entry for this symbol. */
9893 bfd_vma header_address, plt_index, got_address;
9894 bfd_vma got_address_high, got_address_low, load;
9895 const bfd_vma *plt_entry;
9897 BFD_ASSERT (htab->use_plts_and_copy_relocs);
9898 BFD_ASSERT (h->dynindx != -1);
9899 BFD_ASSERT (htab->splt != NULL);
9900 BFD_ASSERT (h->plt.offset <= htab->splt->size);
9901 BFD_ASSERT (!h->def_regular);
9903 /* Calculate the address of the PLT header. */
9904 header_address = (htab->splt->output_section->vma
9905 + htab->splt->output_offset);
9907 /* Calculate the index of the entry. */
9908 plt_index = ((h->plt.offset - htab->plt_header_size)
9909 / htab->plt_entry_size);
9911 /* Calculate the address of the .got.plt entry. */
9912 got_address = (htab->sgotplt->output_section->vma
9913 + htab->sgotplt->output_offset
9914 + (2 + plt_index) * MIPS_ELF_GOT_SIZE (dynobj));
9915 got_address_high = ((got_address + 0x8000) >> 16) & 0xffff;
9916 got_address_low = got_address & 0xffff;
9918 /* Initially point the .got.plt entry at the PLT header. */
9919 loc = (htab->sgotplt->contents
9920 + (2 + plt_index) * MIPS_ELF_GOT_SIZE (dynobj));
9921 if (ABI_64_P (output_bfd))
9922 bfd_put_64 (output_bfd, header_address, loc);
9924 bfd_put_32 (output_bfd, header_address, loc);
9926 /* Find out where the .plt entry should go. */
9927 loc = htab->splt->contents + h->plt.offset;
9929 /* Pick the load opcode. */
9930 load = MIPS_ELF_LOAD_WORD (output_bfd);
9932 /* Fill in the PLT entry itself. */
9933 plt_entry = mips_exec_plt_entry;
9934 bfd_put_32 (output_bfd, plt_entry[0] | got_address_high, loc);
9935 bfd_put_32 (output_bfd, plt_entry[1] | got_address_low | load, loc + 4);
9937 if (! LOAD_INTERLOCKS_P (output_bfd))
9939 bfd_put_32 (output_bfd, plt_entry[2] | got_address_low, loc + 8);
9940 bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
9944 bfd_put_32 (output_bfd, plt_entry[3], loc + 8);
9945 bfd_put_32 (output_bfd, plt_entry[2] | got_address_low, loc + 12);
9948 /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry. */
9949 mips_elf_output_dynamic_relocation (output_bfd, htab->srelplt,
9950 plt_index, h->dynindx,
9951 R_MIPS_JUMP_SLOT, got_address);
9953 /* We distinguish between PLT entries and lazy-binding stubs by
9954 giving the former an st_other value of STO_MIPS_PLT. Set the
9955 flag and leave the value if there are any relocations in the
9956 binary where pointer equality matters. */
9957 sym->st_shndx = SHN_UNDEF;
9958 if (h->pointer_equality_needed)
9959 sym->st_other = STO_MIPS_PLT;
9963 else if (h->plt.offset != MINUS_ONE)
9965 /* We've decided to create a lazy-binding stub. */
9966 bfd_byte stub[MIPS_FUNCTION_STUB_BIG_SIZE];
9968 /* This symbol has a stub. Set it up. */
9970 BFD_ASSERT (h->dynindx != -1);
9972 BFD_ASSERT ((htab->function_stub_size == MIPS_FUNCTION_STUB_BIG_SIZE)
9973 || (h->dynindx <= 0xffff));
9975 /* Values up to 2^31 - 1 are allowed. Larger values would cause
9976 sign extension at runtime in the stub, resulting in a negative
9978 if (h->dynindx & ~0x7fffffff)
9981 /* Fill the stub. */
9983 bfd_put_32 (output_bfd, STUB_LW (output_bfd), stub + idx);
9985 bfd_put_32 (output_bfd, STUB_MOVE (output_bfd), stub + idx);
9987 if (htab->function_stub_size == MIPS_FUNCTION_STUB_BIG_SIZE)
9989 bfd_put_32 (output_bfd, STUB_LUI ((h->dynindx >> 16) & 0x7fff),
9993 bfd_put_32 (output_bfd, STUB_JALR, stub + idx);
9996 /* If a large stub is not required and sign extension is not a
9997 problem, then use legacy code in the stub. */
9998 if (htab->function_stub_size == MIPS_FUNCTION_STUB_BIG_SIZE)
9999 bfd_put_32 (output_bfd, STUB_ORI (h->dynindx & 0xffff), stub + idx);
10000 else if (h->dynindx & ~0x7fff)
10001 bfd_put_32 (output_bfd, STUB_LI16U (h->dynindx & 0xffff), stub + idx);
10003 bfd_put_32 (output_bfd, STUB_LI16S (output_bfd, h->dynindx),
10006 BFD_ASSERT (h->plt.offset <= htab->sstubs->size);
10007 memcpy (htab->sstubs->contents + h->plt.offset,
10008 stub, htab->function_stub_size);
10010 /* Mark the symbol as undefined. plt.offset != -1 occurs
10011 only for the referenced symbol. */
10012 sym->st_shndx = SHN_UNDEF;
10014 /* The run-time linker uses the st_value field of the symbol
10015 to reset the global offset table entry for this external
10016 to its stub address when unlinking a shared object. */
10017 sym->st_value = (htab->sstubs->output_section->vma
10018 + htab->sstubs->output_offset
10022 /* If we have a MIPS16 function with a stub, the dynamic symbol must
10023 refer to the stub, since only the stub uses the standard calling
10025 if (h->dynindx != -1 && hmips->fn_stub != NULL)
10027 BFD_ASSERT (hmips->need_fn_stub);
10028 sym->st_value = (hmips->fn_stub->output_section->vma
10029 + hmips->fn_stub->output_offset);
10030 sym->st_size = hmips->fn_stub->size;
10031 sym->st_other = ELF_ST_VISIBILITY (sym->st_other);
10034 BFD_ASSERT (h->dynindx != -1
10035 || h->forced_local);
10038 g = htab->got_info;
10039 BFD_ASSERT (g != NULL);
10041 /* Run through the global symbol table, creating GOT entries for all
10042 the symbols that need them. */
10043 if (hmips->global_got_area != GGA_NONE)
10048 value = sym->st_value;
10049 offset = mips_elf_global_got_index (dynobj, output_bfd, h,
10050 R_MIPS_GOT16, info);
10051 MIPS_ELF_PUT_WORD (output_bfd, value, sgot->contents + offset);
10054 if (hmips->global_got_area != GGA_NONE && g->next && h->type != STT_TLS)
10056 struct mips_got_entry e, *p;
10062 e.abfd = output_bfd;
10067 for (g = g->next; g->next != gg; g = g->next)
10070 && (p = (struct mips_got_entry *) htab_find (g->got_entries,
10073 offset = p->gotidx;
10075 || (elf_hash_table (info)->dynamic_sections_created
10077 && p->d.h->root.def_dynamic
10078 && !p->d.h->root.def_regular))
10080 /* Create an R_MIPS_REL32 relocation for this entry. Due to
10081 the various compatibility problems, it's easier to mock
10082 up an R_MIPS_32 or R_MIPS_64 relocation and leave
10083 mips_elf_create_dynamic_relocation to calculate the
10084 appropriate addend. */
10085 Elf_Internal_Rela rel[3];
10087 memset (rel, 0, sizeof (rel));
10088 if (ABI_64_P (output_bfd))
10089 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_64);
10091 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_32);
10092 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
10095 if (! (mips_elf_create_dynamic_relocation
10096 (output_bfd, info, rel,
10097 e.d.h, NULL, sym->st_value, &entry, sgot)))
10101 entry = sym->st_value;
10102 MIPS_ELF_PUT_WORD (output_bfd, entry, sgot->contents + offset);
10107 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
10108 name = h->root.root.string;
10109 if (h == elf_hash_table (info)->hdynamic
10110 || h == elf_hash_table (info)->hgot)
10111 sym->st_shndx = SHN_ABS;
10112 else if (strcmp (name, "_DYNAMIC_LINK") == 0
10113 || strcmp (name, "_DYNAMIC_LINKING") == 0)
10115 sym->st_shndx = SHN_ABS;
10116 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
10119 else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (output_bfd))
10121 sym->st_shndx = SHN_ABS;
10122 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
10123 sym->st_value = elf_gp (output_bfd);
10125 else if (SGI_COMPAT (output_bfd))
10127 if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
10128 || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
10130 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
10131 sym->st_other = STO_PROTECTED;
10133 sym->st_shndx = SHN_MIPS_DATA;
10135 else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
10137 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
10138 sym->st_other = STO_PROTECTED;
10139 sym->st_value = mips_elf_hash_table (info)->procedure_count;
10140 sym->st_shndx = SHN_ABS;
10142 else if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS)
10144 if (h->type == STT_FUNC)
10145 sym->st_shndx = SHN_MIPS_TEXT;
10146 else if (h->type == STT_OBJECT)
10147 sym->st_shndx = SHN_MIPS_DATA;
10151 /* Emit a copy reloc, if needed. */
10157 BFD_ASSERT (h->dynindx != -1);
10158 BFD_ASSERT (htab->use_plts_and_copy_relocs);
10160 s = mips_elf_rel_dyn_section (info, FALSE);
10161 symval = (h->root.u.def.section->output_section->vma
10162 + h->root.u.def.section->output_offset
10163 + h->root.u.def.value);
10164 mips_elf_output_dynamic_relocation (output_bfd, s, s->reloc_count++,
10165 h->dynindx, R_MIPS_COPY, symval);
10168 /* Handle the IRIX6-specific symbols. */
10169 if (IRIX_COMPAT (output_bfd) == ict_irix6)
10170 mips_elf_irix6_finish_dynamic_symbol (output_bfd, name, sym);
10172 /* Keep dynamic MIPS16 symbols odd. This allows the dynamic linker to
10173 treat MIPS16 symbols like any other. */
10174 if (ELF_ST_IS_MIPS16 (sym->st_other))
10176 BFD_ASSERT (sym->st_value & 1);
10177 sym->st_other -= STO_MIPS16;
10183 /* Likewise, for VxWorks. */
10186 _bfd_mips_vxworks_finish_dynamic_symbol (bfd *output_bfd,
10187 struct bfd_link_info *info,
10188 struct elf_link_hash_entry *h,
10189 Elf_Internal_Sym *sym)
10193 struct mips_got_info *g;
10194 struct mips_elf_link_hash_table *htab;
10195 struct mips_elf_link_hash_entry *hmips;
10197 htab = mips_elf_hash_table (info);
10198 BFD_ASSERT (htab != NULL);
10199 dynobj = elf_hash_table (info)->dynobj;
10200 hmips = (struct mips_elf_link_hash_entry *) h;
10202 if (h->plt.offset != (bfd_vma) -1)
10205 bfd_vma plt_address, plt_index, got_address, got_offset, branch_offset;
10206 Elf_Internal_Rela rel;
10207 static const bfd_vma *plt_entry;
10209 BFD_ASSERT (h->dynindx != -1);
10210 BFD_ASSERT (htab->splt != NULL);
10211 BFD_ASSERT (h->plt.offset <= htab->splt->size);
10213 /* Calculate the address of the .plt entry. */
10214 plt_address = (htab->splt->output_section->vma
10215 + htab->splt->output_offset
10218 /* Calculate the index of the entry. */
10219 plt_index = ((h->plt.offset - htab->plt_header_size)
10220 / htab->plt_entry_size);
10222 /* Calculate the address of the .got.plt entry. */
10223 got_address = (htab->sgotplt->output_section->vma
10224 + htab->sgotplt->output_offset
10227 /* Calculate the offset of the .got.plt entry from
10228 _GLOBAL_OFFSET_TABLE_. */
10229 got_offset = mips_elf_gotplt_index (info, h);
10231 /* Calculate the offset for the branch at the start of the PLT
10232 entry. The branch jumps to the beginning of .plt. */
10233 branch_offset = -(h->plt.offset / 4 + 1) & 0xffff;
10235 /* Fill in the initial value of the .got.plt entry. */
10236 bfd_put_32 (output_bfd, plt_address,
10237 htab->sgotplt->contents + plt_index * 4);
10239 /* Find out where the .plt entry should go. */
10240 loc = htab->splt->contents + h->plt.offset;
10244 plt_entry = mips_vxworks_shared_plt_entry;
10245 bfd_put_32 (output_bfd, plt_entry[0] | branch_offset, loc);
10246 bfd_put_32 (output_bfd, plt_entry[1] | plt_index, loc + 4);
10250 bfd_vma got_address_high, got_address_low;
10252 plt_entry = mips_vxworks_exec_plt_entry;
10253 got_address_high = ((got_address + 0x8000) >> 16) & 0xffff;
10254 got_address_low = got_address & 0xffff;
10256 bfd_put_32 (output_bfd, plt_entry[0] | branch_offset, loc);
10257 bfd_put_32 (output_bfd, plt_entry[1] | plt_index, loc + 4);
10258 bfd_put_32 (output_bfd, plt_entry[2] | got_address_high, loc + 8);
10259 bfd_put_32 (output_bfd, plt_entry[3] | got_address_low, loc + 12);
10260 bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
10261 bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
10262 bfd_put_32 (output_bfd, plt_entry[6], loc + 24);
10263 bfd_put_32 (output_bfd, plt_entry[7], loc + 28);
10265 loc = (htab->srelplt2->contents
10266 + (plt_index * 3 + 2) * sizeof (Elf32_External_Rela));
10268 /* Emit a relocation for the .got.plt entry. */
10269 rel.r_offset = got_address;
10270 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_MIPS_32);
10271 rel.r_addend = h->plt.offset;
10272 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
10274 /* Emit a relocation for the lui of %hi(<.got.plt slot>). */
10275 loc += sizeof (Elf32_External_Rela);
10276 rel.r_offset = plt_address + 8;
10277 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
10278 rel.r_addend = got_offset;
10279 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
10281 /* Emit a relocation for the addiu of %lo(<.got.plt slot>). */
10282 loc += sizeof (Elf32_External_Rela);
10284 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
10285 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
10288 /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry. */
10289 loc = htab->srelplt->contents + plt_index * sizeof (Elf32_External_Rela);
10290 rel.r_offset = got_address;
10291 rel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_JUMP_SLOT);
10293 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
10295 if (!h->def_regular)
10296 sym->st_shndx = SHN_UNDEF;
10299 BFD_ASSERT (h->dynindx != -1 || h->forced_local);
10302 g = htab->got_info;
10303 BFD_ASSERT (g != NULL);
10305 /* See if this symbol has an entry in the GOT. */
10306 if (hmips->global_got_area != GGA_NONE)
10309 Elf_Internal_Rela outrel;
10313 /* Install the symbol value in the GOT. */
10314 offset = mips_elf_global_got_index (dynobj, output_bfd, h,
10315 R_MIPS_GOT16, info);
10316 MIPS_ELF_PUT_WORD (output_bfd, sym->st_value, sgot->contents + offset);
10318 /* Add a dynamic relocation for it. */
10319 s = mips_elf_rel_dyn_section (info, FALSE);
10320 loc = s->contents + (s->reloc_count++ * sizeof (Elf32_External_Rela));
10321 outrel.r_offset = (sgot->output_section->vma
10322 + sgot->output_offset
10324 outrel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_32);
10325 outrel.r_addend = 0;
10326 bfd_elf32_swap_reloca_out (dynobj, &outrel, loc);
10329 /* Emit a copy reloc, if needed. */
10332 Elf_Internal_Rela rel;
10334 BFD_ASSERT (h->dynindx != -1);
10336 rel.r_offset = (h->root.u.def.section->output_section->vma
10337 + h->root.u.def.section->output_offset
10338 + h->root.u.def.value);
10339 rel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_COPY);
10341 bfd_elf32_swap_reloca_out (output_bfd, &rel,
10342 htab->srelbss->contents
10343 + (htab->srelbss->reloc_count
10344 * sizeof (Elf32_External_Rela)));
10345 ++htab->srelbss->reloc_count;
10348 /* If this is a mips16/microMIPS symbol, force the value to be even. */
10349 if (ELF_ST_IS_COMPRESSED (sym->st_other))
10350 sym->st_value &= ~1;
10355 /* Write out a plt0 entry to the beginning of .plt. */
10358 mips_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
10361 bfd_vma gotplt_value, gotplt_value_high, gotplt_value_low;
10362 static const bfd_vma *plt_entry;
10363 struct mips_elf_link_hash_table *htab;
10365 htab = mips_elf_hash_table (info);
10366 BFD_ASSERT (htab != NULL);
10368 if (ABI_64_P (output_bfd))
10369 plt_entry = mips_n64_exec_plt0_entry;
10370 else if (ABI_N32_P (output_bfd))
10371 plt_entry = mips_n32_exec_plt0_entry;
10373 plt_entry = mips_o32_exec_plt0_entry;
10375 /* Calculate the value of .got.plt. */
10376 gotplt_value = (htab->sgotplt->output_section->vma
10377 + htab->sgotplt->output_offset);
10378 gotplt_value_high = ((gotplt_value + 0x8000) >> 16) & 0xffff;
10379 gotplt_value_low = gotplt_value & 0xffff;
10381 /* The PLT sequence is not safe for N64 if .got.plt's address can
10382 not be loaded in two instructions. */
10383 BFD_ASSERT ((gotplt_value & ~(bfd_vma) 0x7fffffff) == 0
10384 || ~(gotplt_value | 0x7fffffff) == 0);
10386 /* Install the PLT header. */
10387 loc = htab->splt->contents;
10388 bfd_put_32 (output_bfd, plt_entry[0] | gotplt_value_high, loc);
10389 bfd_put_32 (output_bfd, plt_entry[1] | gotplt_value_low, loc + 4);
10390 bfd_put_32 (output_bfd, plt_entry[2] | gotplt_value_low, loc + 8);
10391 bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
10392 bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
10393 bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
10394 bfd_put_32 (output_bfd, plt_entry[6], loc + 24);
10395 bfd_put_32 (output_bfd, plt_entry[7], loc + 28);
10398 /* Install the PLT header for a VxWorks executable and finalize the
10399 contents of .rela.plt.unloaded. */
10402 mips_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
10404 Elf_Internal_Rela rela;
10406 bfd_vma got_value, got_value_high, got_value_low, plt_address;
10407 static const bfd_vma *plt_entry;
10408 struct mips_elf_link_hash_table *htab;
10410 htab = mips_elf_hash_table (info);
10411 BFD_ASSERT (htab != NULL);
10413 plt_entry = mips_vxworks_exec_plt0_entry;
10415 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */
10416 got_value = (htab->root.hgot->root.u.def.section->output_section->vma
10417 + htab->root.hgot->root.u.def.section->output_offset
10418 + htab->root.hgot->root.u.def.value);
10420 got_value_high = ((got_value + 0x8000) >> 16) & 0xffff;
10421 got_value_low = got_value & 0xffff;
10423 /* Calculate the address of the PLT header. */
10424 plt_address = htab->splt->output_section->vma + htab->splt->output_offset;
10426 /* Install the PLT header. */
10427 loc = htab->splt->contents;
10428 bfd_put_32 (output_bfd, plt_entry[0] | got_value_high, loc);
10429 bfd_put_32 (output_bfd, plt_entry[1] | got_value_low, loc + 4);
10430 bfd_put_32 (output_bfd, plt_entry[2], loc + 8);
10431 bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
10432 bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
10433 bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
10435 /* Output the relocation for the lui of %hi(_GLOBAL_OFFSET_TABLE_). */
10436 loc = htab->srelplt2->contents;
10437 rela.r_offset = plt_address;
10438 rela.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
10440 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
10441 loc += sizeof (Elf32_External_Rela);
10443 /* Output the relocation for the following addiu of
10444 %lo(_GLOBAL_OFFSET_TABLE_). */
10445 rela.r_offset += 4;
10446 rela.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
10447 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
10448 loc += sizeof (Elf32_External_Rela);
10450 /* Fix up the remaining relocations. They may have the wrong
10451 symbol index for _G_O_T_ or _P_L_T_ depending on the order
10452 in which symbols were output. */
10453 while (loc < htab->srelplt2->contents + htab->srelplt2->size)
10455 Elf_Internal_Rela rel;
10457 bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
10458 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_MIPS_32);
10459 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
10460 loc += sizeof (Elf32_External_Rela);
10462 bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
10463 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
10464 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
10465 loc += sizeof (Elf32_External_Rela);
10467 bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
10468 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
10469 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
10470 loc += sizeof (Elf32_External_Rela);
10474 /* Install the PLT header for a VxWorks shared library. */
10477 mips_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
10480 struct mips_elf_link_hash_table *htab;
10482 htab = mips_elf_hash_table (info);
10483 BFD_ASSERT (htab != NULL);
10485 /* We just need to copy the entry byte-by-byte. */
10486 for (i = 0; i < ARRAY_SIZE (mips_vxworks_shared_plt0_entry); i++)
10487 bfd_put_32 (output_bfd, mips_vxworks_shared_plt0_entry[i],
10488 htab->splt->contents + i * 4);
10491 /* Finish up the dynamic sections. */
10494 _bfd_mips_elf_finish_dynamic_sections (bfd *output_bfd,
10495 struct bfd_link_info *info)
10500 struct mips_got_info *gg, *g;
10501 struct mips_elf_link_hash_table *htab;
10503 htab = mips_elf_hash_table (info);
10504 BFD_ASSERT (htab != NULL);
10506 dynobj = elf_hash_table (info)->dynobj;
10508 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
10511 gg = htab->got_info;
10513 if (elf_hash_table (info)->dynamic_sections_created)
10516 int dyn_to_skip = 0, dyn_skipped = 0;
10518 BFD_ASSERT (sdyn != NULL);
10519 BFD_ASSERT (gg != NULL);
10521 g = mips_elf_got_for_ibfd (gg, output_bfd);
10522 BFD_ASSERT (g != NULL);
10524 for (b = sdyn->contents;
10525 b < sdyn->contents + sdyn->size;
10526 b += MIPS_ELF_DYN_SIZE (dynobj))
10528 Elf_Internal_Dyn dyn;
10532 bfd_boolean swap_out_p;
10534 /* Read in the current dynamic entry. */
10535 (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
10537 /* Assume that we're going to modify it and write it out. */
10543 dyn.d_un.d_val = MIPS_ELF_REL_SIZE (dynobj);
10547 BFD_ASSERT (htab->is_vxworks);
10548 dyn.d_un.d_val = MIPS_ELF_RELA_SIZE (dynobj);
10552 /* Rewrite DT_STRSZ. */
10554 _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
10559 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
10562 case DT_MIPS_PLTGOT:
10564 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
10567 case DT_MIPS_RLD_VERSION:
10568 dyn.d_un.d_val = 1; /* XXX */
10571 case DT_MIPS_FLAGS:
10572 dyn.d_un.d_val = RHF_NOTPOT; /* XXX */
10575 case DT_MIPS_TIME_STAMP:
10579 dyn.d_un.d_val = t;
10583 case DT_MIPS_ICHECKSUM:
10585 swap_out_p = FALSE;
10588 case DT_MIPS_IVERSION:
10590 swap_out_p = FALSE;
10593 case DT_MIPS_BASE_ADDRESS:
10594 s = output_bfd->sections;
10595 BFD_ASSERT (s != NULL);
10596 dyn.d_un.d_ptr = s->vma & ~(bfd_vma) 0xffff;
10599 case DT_MIPS_LOCAL_GOTNO:
10600 dyn.d_un.d_val = g->local_gotno;
10603 case DT_MIPS_UNREFEXTNO:
10604 /* The index into the dynamic symbol table which is the
10605 entry of the first external symbol that is not
10606 referenced within the same object. */
10607 dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
10610 case DT_MIPS_GOTSYM:
10611 if (htab->global_gotsym)
10613 dyn.d_un.d_val = htab->global_gotsym->dynindx;
10616 /* In case if we don't have global got symbols we default
10617 to setting DT_MIPS_GOTSYM to the same value as
10618 DT_MIPS_SYMTABNO, so we just fall through. */
10620 case DT_MIPS_SYMTABNO:
10622 elemsize = MIPS_ELF_SYM_SIZE (output_bfd);
10623 s = bfd_get_section_by_name (output_bfd, name);
10624 BFD_ASSERT (s != NULL);
10626 dyn.d_un.d_val = s->size / elemsize;
10629 case DT_MIPS_HIPAGENO:
10630 dyn.d_un.d_val = g->local_gotno - htab->reserved_gotno;
10633 case DT_MIPS_RLD_MAP:
10635 struct elf_link_hash_entry *h;
10636 h = mips_elf_hash_table (info)->rld_symbol;
10639 dyn_to_skip = MIPS_ELF_DYN_SIZE (dynobj);
10640 swap_out_p = FALSE;
10643 s = h->root.u.def.section;
10644 dyn.d_un.d_ptr = (s->output_section->vma + s->output_offset
10645 + h->root.u.def.value);
10649 case DT_MIPS_OPTIONS:
10650 s = (bfd_get_section_by_name
10651 (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd)));
10652 dyn.d_un.d_ptr = s->vma;
10656 BFD_ASSERT (htab->is_vxworks);
10657 /* The count does not include the JUMP_SLOT relocations. */
10659 dyn.d_un.d_val -= htab->srelplt->size;
10663 BFD_ASSERT (htab->use_plts_and_copy_relocs);
10664 if (htab->is_vxworks)
10665 dyn.d_un.d_val = DT_RELA;
10667 dyn.d_un.d_val = DT_REL;
10671 BFD_ASSERT (htab->use_plts_and_copy_relocs);
10672 dyn.d_un.d_val = htab->srelplt->size;
10676 BFD_ASSERT (htab->use_plts_and_copy_relocs);
10677 dyn.d_un.d_ptr = (htab->srelplt->output_section->vma
10678 + htab->srelplt->output_offset);
10682 /* If we didn't need any text relocations after all, delete
10683 the dynamic tag. */
10684 if (!(info->flags & DF_TEXTREL))
10686 dyn_to_skip = MIPS_ELF_DYN_SIZE (dynobj);
10687 swap_out_p = FALSE;
10692 /* If we didn't need any text relocations after all, clear
10693 DF_TEXTREL from DT_FLAGS. */
10694 if (!(info->flags & DF_TEXTREL))
10695 dyn.d_un.d_val &= ~DF_TEXTREL;
10697 swap_out_p = FALSE;
10701 swap_out_p = FALSE;
10702 if (htab->is_vxworks
10703 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
10708 if (swap_out_p || dyn_skipped)
10709 (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
10710 (dynobj, &dyn, b - dyn_skipped);
10714 dyn_skipped += dyn_to_skip;
10719 /* Wipe out any trailing entries if we shifted down a dynamic tag. */
10720 if (dyn_skipped > 0)
10721 memset (b - dyn_skipped, 0, dyn_skipped);
10724 if (sgot != NULL && sgot->size > 0
10725 && !bfd_is_abs_section (sgot->output_section))
10727 if (htab->is_vxworks)
10729 /* The first entry of the global offset table points to the
10730 ".dynamic" section. The second is initialized by the
10731 loader and contains the shared library identifier.
10732 The third is also initialized by the loader and points
10733 to the lazy resolution stub. */
10734 MIPS_ELF_PUT_WORD (output_bfd,
10735 sdyn->output_offset + sdyn->output_section->vma,
10737 MIPS_ELF_PUT_WORD (output_bfd, 0,
10738 sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
10739 MIPS_ELF_PUT_WORD (output_bfd, 0,
10741 + 2 * MIPS_ELF_GOT_SIZE (output_bfd));
10745 /* The first entry of the global offset table will be filled at
10746 runtime. The second entry will be used by some runtime loaders.
10747 This isn't the case of IRIX rld. */
10748 MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0, sgot->contents);
10749 MIPS_ELF_PUT_WORD (output_bfd, MIPS_ELF_GNU_GOT1_MASK (output_bfd),
10750 sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
10753 elf_section_data (sgot->output_section)->this_hdr.sh_entsize
10754 = MIPS_ELF_GOT_SIZE (output_bfd);
10757 /* Generate dynamic relocations for the non-primary gots. */
10758 if (gg != NULL && gg->next)
10760 Elf_Internal_Rela rel[3];
10761 bfd_vma addend = 0;
10763 memset (rel, 0, sizeof (rel));
10764 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_REL32);
10766 for (g = gg->next; g->next != gg; g = g->next)
10768 bfd_vma got_index = g->next->local_gotno + g->next->global_gotno
10769 + g->next->tls_gotno;
10771 MIPS_ELF_PUT_WORD (output_bfd, 0, sgot->contents
10772 + got_index++ * MIPS_ELF_GOT_SIZE (output_bfd));
10773 MIPS_ELF_PUT_WORD (output_bfd, MIPS_ELF_GNU_GOT1_MASK (output_bfd),
10775 + got_index++ * MIPS_ELF_GOT_SIZE (output_bfd));
10777 if (! info->shared)
10780 while (got_index < g->assigned_gotno)
10782 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset
10783 = got_index++ * MIPS_ELF_GOT_SIZE (output_bfd);
10784 if (!(mips_elf_create_dynamic_relocation
10785 (output_bfd, info, rel, NULL,
10786 bfd_abs_section_ptr,
10787 0, &addend, sgot)))
10789 BFD_ASSERT (addend == 0);
10794 /* The generation of dynamic relocations for the non-primary gots
10795 adds more dynamic relocations. We cannot count them until
10798 if (elf_hash_table (info)->dynamic_sections_created)
10801 bfd_boolean swap_out_p;
10803 BFD_ASSERT (sdyn != NULL);
10805 for (b = sdyn->contents;
10806 b < sdyn->contents + sdyn->size;
10807 b += MIPS_ELF_DYN_SIZE (dynobj))
10809 Elf_Internal_Dyn dyn;
10812 /* Read in the current dynamic entry. */
10813 (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
10815 /* Assume that we're going to modify it and write it out. */
10821 /* Reduce DT_RELSZ to account for any relocations we
10822 decided not to make. This is for the n64 irix rld,
10823 which doesn't seem to apply any relocations if there
10824 are trailing null entries. */
10825 s = mips_elf_rel_dyn_section (info, FALSE);
10826 dyn.d_un.d_val = (s->reloc_count
10827 * (ABI_64_P (output_bfd)
10828 ? sizeof (Elf64_Mips_External_Rel)
10829 : sizeof (Elf32_External_Rel)));
10830 /* Adjust the section size too. Tools like the prelinker
10831 can reasonably expect the values to the same. */
10832 elf_section_data (s->output_section)->this_hdr.sh_size
10837 swap_out_p = FALSE;
10842 (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
10849 Elf32_compact_rel cpt;
10851 if (SGI_COMPAT (output_bfd))
10853 /* Write .compact_rel section out. */
10854 s = bfd_get_linker_section (dynobj, ".compact_rel");
10858 cpt.num = s->reloc_count;
10860 cpt.offset = (s->output_section->filepos
10861 + sizeof (Elf32_External_compact_rel));
10864 bfd_elf32_swap_compact_rel_out (output_bfd, &cpt,
10865 ((Elf32_External_compact_rel *)
10868 /* Clean up a dummy stub function entry in .text. */
10869 if (htab->sstubs != NULL)
10871 file_ptr dummy_offset;
10873 BFD_ASSERT (htab->sstubs->size >= htab->function_stub_size);
10874 dummy_offset = htab->sstubs->size - htab->function_stub_size;
10875 memset (htab->sstubs->contents + dummy_offset, 0,
10876 htab->function_stub_size);
10881 /* The psABI says that the dynamic relocations must be sorted in
10882 increasing order of r_symndx. The VxWorks EABI doesn't require
10883 this, and because the code below handles REL rather than RELA
10884 relocations, using it for VxWorks would be outright harmful. */
10885 if (!htab->is_vxworks)
10887 s = mips_elf_rel_dyn_section (info, FALSE);
10889 && s->size > (bfd_vma)2 * MIPS_ELF_REL_SIZE (output_bfd))
10891 reldyn_sorting_bfd = output_bfd;
10893 if (ABI_64_P (output_bfd))
10894 qsort ((Elf64_External_Rel *) s->contents + 1,
10895 s->reloc_count - 1, sizeof (Elf64_Mips_External_Rel),
10896 sort_dynamic_relocs_64);
10898 qsort ((Elf32_External_Rel *) s->contents + 1,
10899 s->reloc_count - 1, sizeof (Elf32_External_Rel),
10900 sort_dynamic_relocs);
10905 if (htab->splt && htab->splt->size > 0)
10907 if (htab->is_vxworks)
10910 mips_vxworks_finish_shared_plt (output_bfd, info);
10912 mips_vxworks_finish_exec_plt (output_bfd, info);
10916 BFD_ASSERT (!info->shared);
10917 mips_finish_exec_plt (output_bfd, info);
10924 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
10927 mips_set_isa_flags (bfd *abfd)
10931 switch (bfd_get_mach (abfd))
10934 case bfd_mach_mips3000:
10935 val = E_MIPS_ARCH_1;
10938 case bfd_mach_mips3900:
10939 val = E_MIPS_ARCH_1 | E_MIPS_MACH_3900;
10942 case bfd_mach_mips6000:
10943 val = E_MIPS_ARCH_2;
10946 case bfd_mach_mips4000:
10947 case bfd_mach_mips4300:
10948 case bfd_mach_mips4400:
10949 case bfd_mach_mips4600:
10950 val = E_MIPS_ARCH_3;
10953 case bfd_mach_mips4010:
10954 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4010;
10957 case bfd_mach_mips4100:
10958 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4100;
10961 case bfd_mach_mips4111:
10962 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4111;
10965 case bfd_mach_mips4120:
10966 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4120;
10969 case bfd_mach_mips4650:
10970 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4650;
10973 case bfd_mach_mips5400:
10974 val = E_MIPS_ARCH_4 | E_MIPS_MACH_5400;
10977 case bfd_mach_mips5500:
10978 val = E_MIPS_ARCH_4 | E_MIPS_MACH_5500;
10981 case bfd_mach_mips5900:
10982 val = E_MIPS_ARCH_3 | E_MIPS_MACH_5900;
10985 case bfd_mach_mips9000:
10986 val = E_MIPS_ARCH_4 | E_MIPS_MACH_9000;
10989 case bfd_mach_mips5000:
10990 case bfd_mach_mips7000:
10991 case bfd_mach_mips8000:
10992 case bfd_mach_mips10000:
10993 case bfd_mach_mips12000:
10994 case bfd_mach_mips14000:
10995 case bfd_mach_mips16000:
10996 val = E_MIPS_ARCH_4;
10999 case bfd_mach_mips5:
11000 val = E_MIPS_ARCH_5;
11003 case bfd_mach_mips_loongson_2e:
11004 val = E_MIPS_ARCH_3 | E_MIPS_MACH_LS2E;
11007 case bfd_mach_mips_loongson_2f:
11008 val = E_MIPS_ARCH_3 | E_MIPS_MACH_LS2F;
11011 case bfd_mach_mips_sb1:
11012 val = E_MIPS_ARCH_64 | E_MIPS_MACH_SB1;
11015 case bfd_mach_mips_loongson_3a:
11016 val = E_MIPS_ARCH_64 | E_MIPS_MACH_LS3A;
11019 case bfd_mach_mips_octeon:
11020 case bfd_mach_mips_octeonp:
11021 val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_OCTEON;
11024 case bfd_mach_mips_xlr:
11025 val = E_MIPS_ARCH_64 | E_MIPS_MACH_XLR;
11028 case bfd_mach_mips_octeon2:
11029 val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_OCTEON2;
11032 case bfd_mach_mipsisa32:
11033 val = E_MIPS_ARCH_32;
11036 case bfd_mach_mipsisa64:
11037 val = E_MIPS_ARCH_64;
11040 case bfd_mach_mipsisa32r2:
11041 val = E_MIPS_ARCH_32R2;
11044 case bfd_mach_mipsisa64r2:
11045 val = E_MIPS_ARCH_64R2;
11048 elf_elfheader (abfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
11049 elf_elfheader (abfd)->e_flags |= val;
11054 /* The final processing done just before writing out a MIPS ELF object
11055 file. This gets the MIPS architecture right based on the machine
11056 number. This is used by both the 32-bit and the 64-bit ABI. */
11059 _bfd_mips_elf_final_write_processing (bfd *abfd,
11060 bfd_boolean linker ATTRIBUTE_UNUSED)
11063 Elf_Internal_Shdr **hdrpp;
11067 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
11068 is nonzero. This is for compatibility with old objects, which used
11069 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
11070 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == 0)
11071 mips_set_isa_flags (abfd);
11073 /* Set the sh_info field for .gptab sections and other appropriate
11074 info for each special section. */
11075 for (i = 1, hdrpp = elf_elfsections (abfd) + 1;
11076 i < elf_numsections (abfd);
11079 switch ((*hdrpp)->sh_type)
11081 case SHT_MIPS_MSYM:
11082 case SHT_MIPS_LIBLIST:
11083 sec = bfd_get_section_by_name (abfd, ".dynstr");
11085 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
11088 case SHT_MIPS_GPTAB:
11089 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
11090 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
11091 BFD_ASSERT (name != NULL
11092 && CONST_STRNEQ (name, ".gptab."));
11093 sec = bfd_get_section_by_name (abfd, name + sizeof ".gptab" - 1);
11094 BFD_ASSERT (sec != NULL);
11095 (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
11098 case SHT_MIPS_CONTENT:
11099 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
11100 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
11101 BFD_ASSERT (name != NULL
11102 && CONST_STRNEQ (name, ".MIPS.content"));
11103 sec = bfd_get_section_by_name (abfd,
11104 name + sizeof ".MIPS.content" - 1);
11105 BFD_ASSERT (sec != NULL);
11106 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
11109 case SHT_MIPS_SYMBOL_LIB:
11110 sec = bfd_get_section_by_name (abfd, ".dynsym");
11112 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
11113 sec = bfd_get_section_by_name (abfd, ".liblist");
11115 (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
11118 case SHT_MIPS_EVENTS:
11119 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
11120 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
11121 BFD_ASSERT (name != NULL);
11122 if (CONST_STRNEQ (name, ".MIPS.events"))
11123 sec = bfd_get_section_by_name (abfd,
11124 name + sizeof ".MIPS.events" - 1);
11127 BFD_ASSERT (CONST_STRNEQ (name, ".MIPS.post_rel"));
11128 sec = bfd_get_section_by_name (abfd,
11130 + sizeof ".MIPS.post_rel" - 1));
11132 BFD_ASSERT (sec != NULL);
11133 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
11140 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
11144 _bfd_mips_elf_additional_program_headers (bfd *abfd,
11145 struct bfd_link_info *info ATTRIBUTE_UNUSED)
11150 /* See if we need a PT_MIPS_REGINFO segment. */
11151 s = bfd_get_section_by_name (abfd, ".reginfo");
11152 if (s && (s->flags & SEC_LOAD))
11155 /* See if we need a PT_MIPS_OPTIONS segment. */
11156 if (IRIX_COMPAT (abfd) == ict_irix6
11157 && bfd_get_section_by_name (abfd,
11158 MIPS_ELF_OPTIONS_SECTION_NAME (abfd)))
11161 /* See if we need a PT_MIPS_RTPROC segment. */
11162 if (IRIX_COMPAT (abfd) == ict_irix5
11163 && bfd_get_section_by_name (abfd, ".dynamic")
11164 && bfd_get_section_by_name (abfd, ".mdebug"))
11167 /* Allocate a PT_NULL header in dynamic objects. See
11168 _bfd_mips_elf_modify_segment_map for details. */
11169 if (!SGI_COMPAT (abfd)
11170 && bfd_get_section_by_name (abfd, ".dynamic"))
11176 /* Modify the segment map for an IRIX5 executable. */
11179 _bfd_mips_elf_modify_segment_map (bfd *abfd,
11180 struct bfd_link_info *info)
11183 struct elf_segment_map *m, **pm;
11186 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
11188 s = bfd_get_section_by_name (abfd, ".reginfo");
11189 if (s != NULL && (s->flags & SEC_LOAD) != 0)
11191 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
11192 if (m->p_type == PT_MIPS_REGINFO)
11197 m = bfd_zalloc (abfd, amt);
11201 m->p_type = PT_MIPS_REGINFO;
11203 m->sections[0] = s;
11205 /* We want to put it after the PHDR and INTERP segments. */
11206 pm = &elf_tdata (abfd)->segment_map;
11208 && ((*pm)->p_type == PT_PHDR
11209 || (*pm)->p_type == PT_INTERP))
11217 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
11218 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
11219 PT_MIPS_OPTIONS segment immediately following the program header
11221 if (NEWABI_P (abfd)
11222 /* On non-IRIX6 new abi, we'll have already created a segment
11223 for this section, so don't create another. I'm not sure this
11224 is not also the case for IRIX 6, but I can't test it right
11226 && IRIX_COMPAT (abfd) == ict_irix6)
11228 for (s = abfd->sections; s; s = s->next)
11229 if (elf_section_data (s)->this_hdr.sh_type == SHT_MIPS_OPTIONS)
11234 struct elf_segment_map *options_segment;
11236 pm = &elf_tdata (abfd)->segment_map;
11238 && ((*pm)->p_type == PT_PHDR
11239 || (*pm)->p_type == PT_INTERP))
11242 if (*pm == NULL || (*pm)->p_type != PT_MIPS_OPTIONS)
11244 amt = sizeof (struct elf_segment_map);
11245 options_segment = bfd_zalloc (abfd, amt);
11246 options_segment->next = *pm;
11247 options_segment->p_type = PT_MIPS_OPTIONS;
11248 options_segment->p_flags = PF_R;
11249 options_segment->p_flags_valid = TRUE;
11250 options_segment->count = 1;
11251 options_segment->sections[0] = s;
11252 *pm = options_segment;
11258 if (IRIX_COMPAT (abfd) == ict_irix5)
11260 /* If there are .dynamic and .mdebug sections, we make a room
11261 for the RTPROC header. FIXME: Rewrite without section names. */
11262 if (bfd_get_section_by_name (abfd, ".interp") == NULL
11263 && bfd_get_section_by_name (abfd, ".dynamic") != NULL
11264 && bfd_get_section_by_name (abfd, ".mdebug") != NULL)
11266 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
11267 if (m->p_type == PT_MIPS_RTPROC)
11272 m = bfd_zalloc (abfd, amt);
11276 m->p_type = PT_MIPS_RTPROC;
11278 s = bfd_get_section_by_name (abfd, ".rtproc");
11283 m->p_flags_valid = 1;
11288 m->sections[0] = s;
11291 /* We want to put it after the DYNAMIC segment. */
11292 pm = &elf_tdata (abfd)->segment_map;
11293 while (*pm != NULL && (*pm)->p_type != PT_DYNAMIC)
11303 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
11304 .dynstr, .dynsym, and .hash sections, and everything in
11306 for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL;
11308 if ((*pm)->p_type == PT_DYNAMIC)
11311 if (m != NULL && IRIX_COMPAT (abfd) == ict_none)
11313 /* For a normal mips executable the permissions for the PT_DYNAMIC
11314 segment are read, write and execute. We do that here since
11315 the code in elf.c sets only the read permission. This matters
11316 sometimes for the dynamic linker. */
11317 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
11319 m->p_flags = PF_R | PF_W | PF_X;
11320 m->p_flags_valid = 1;
11323 /* GNU/Linux binaries do not need the extended PT_DYNAMIC section.
11324 glibc's dynamic linker has traditionally derived the number of
11325 tags from the p_filesz field, and sometimes allocates stack
11326 arrays of that size. An overly-big PT_DYNAMIC segment can
11327 be actively harmful in such cases. Making PT_DYNAMIC contain
11328 other sections can also make life hard for the prelinker,
11329 which might move one of the other sections to a different
11330 PT_LOAD segment. */
11331 if (SGI_COMPAT (abfd)
11334 && strcmp (m->sections[0]->name, ".dynamic") == 0)
11336 static const char *sec_names[] =
11338 ".dynamic", ".dynstr", ".dynsym", ".hash"
11342 struct elf_segment_map *n;
11344 low = ~(bfd_vma) 0;
11346 for (i = 0; i < sizeof sec_names / sizeof sec_names[0]; i++)
11348 s = bfd_get_section_by_name (abfd, sec_names[i]);
11349 if (s != NULL && (s->flags & SEC_LOAD) != 0)
11356 if (high < s->vma + sz)
11357 high = s->vma + sz;
11362 for (s = abfd->sections; s != NULL; s = s->next)
11363 if ((s->flags & SEC_LOAD) != 0
11365 && s->vma + s->size <= high)
11368 amt = sizeof *n + (bfd_size_type) (c - 1) * sizeof (asection *);
11369 n = bfd_zalloc (abfd, amt);
11376 for (s = abfd->sections; s != NULL; s = s->next)
11378 if ((s->flags & SEC_LOAD) != 0
11380 && s->vma + s->size <= high)
11382 n->sections[i] = s;
11391 /* Allocate a spare program header in dynamic objects so that tools
11392 like the prelinker can add an extra PT_LOAD entry.
11394 If the prelinker needs to make room for a new PT_LOAD entry, its
11395 standard procedure is to move the first (read-only) sections into
11396 the new (writable) segment. However, the MIPS ABI requires
11397 .dynamic to be in a read-only segment, and the section will often
11398 start within sizeof (ElfNN_Phdr) bytes of the last program header.
11400 Although the prelinker could in principle move .dynamic to a
11401 writable segment, it seems better to allocate a spare program
11402 header instead, and avoid the need to move any sections.
11403 There is a long tradition of allocating spare dynamic tags,
11404 so allocating a spare program header seems like a natural
11407 If INFO is NULL, we may be copying an already prelinked binary
11408 with objcopy or strip, so do not add this header. */
11410 && !SGI_COMPAT (abfd)
11411 && bfd_get_section_by_name (abfd, ".dynamic"))
11413 for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL; pm = &(*pm)->next)
11414 if ((*pm)->p_type == PT_NULL)
11418 m = bfd_zalloc (abfd, sizeof (*m));
11422 m->p_type = PT_NULL;
11430 /* Return the section that should be marked against GC for a given
11434 _bfd_mips_elf_gc_mark_hook (asection *sec,
11435 struct bfd_link_info *info,
11436 Elf_Internal_Rela *rel,
11437 struct elf_link_hash_entry *h,
11438 Elf_Internal_Sym *sym)
11440 /* ??? Do mips16 stub sections need to be handled special? */
11443 switch (ELF_R_TYPE (sec->owner, rel->r_info))
11445 case R_MIPS_GNU_VTINHERIT:
11446 case R_MIPS_GNU_VTENTRY:
11450 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
11453 /* Update the got entry reference counts for the section being removed. */
11456 _bfd_mips_elf_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
11457 struct bfd_link_info *info ATTRIBUTE_UNUSED,
11458 asection *sec ATTRIBUTE_UNUSED,
11459 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
11462 Elf_Internal_Shdr *symtab_hdr;
11463 struct elf_link_hash_entry **sym_hashes;
11464 bfd_signed_vma *local_got_refcounts;
11465 const Elf_Internal_Rela *rel, *relend;
11466 unsigned long r_symndx;
11467 struct elf_link_hash_entry *h;
11469 if (info->relocatable)
11472 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
11473 sym_hashes = elf_sym_hashes (abfd);
11474 local_got_refcounts = elf_local_got_refcounts (abfd);
11476 relend = relocs + sec->reloc_count;
11477 for (rel = relocs; rel < relend; rel++)
11478 switch (ELF_R_TYPE (abfd, rel->r_info))
11480 case R_MIPS16_GOT16:
11481 case R_MIPS16_CALL16:
11483 case R_MIPS_CALL16:
11484 case R_MIPS_CALL_HI16:
11485 case R_MIPS_CALL_LO16:
11486 case R_MIPS_GOT_HI16:
11487 case R_MIPS_GOT_LO16:
11488 case R_MIPS_GOT_DISP:
11489 case R_MIPS_GOT_PAGE:
11490 case R_MIPS_GOT_OFST:
11491 case R_MICROMIPS_GOT16:
11492 case R_MICROMIPS_CALL16:
11493 case R_MICROMIPS_CALL_HI16:
11494 case R_MICROMIPS_CALL_LO16:
11495 case R_MICROMIPS_GOT_HI16:
11496 case R_MICROMIPS_GOT_LO16:
11497 case R_MICROMIPS_GOT_DISP:
11498 case R_MICROMIPS_GOT_PAGE:
11499 case R_MICROMIPS_GOT_OFST:
11500 /* ??? It would seem that the existing MIPS code does no sort
11501 of reference counting or whatnot on its GOT and PLT entries,
11502 so it is not possible to garbage collect them at this time. */
11513 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
11514 hiding the old indirect symbol. Process additional relocation
11515 information. Also called for weakdefs, in which case we just let
11516 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
11519 _bfd_mips_elf_copy_indirect_symbol (struct bfd_link_info *info,
11520 struct elf_link_hash_entry *dir,
11521 struct elf_link_hash_entry *ind)
11523 struct mips_elf_link_hash_entry *dirmips, *indmips;
11525 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
11527 dirmips = (struct mips_elf_link_hash_entry *) dir;
11528 indmips = (struct mips_elf_link_hash_entry *) ind;
11529 /* Any absolute non-dynamic relocations against an indirect or weak
11530 definition will be against the target symbol. */
11531 if (indmips->has_static_relocs)
11532 dirmips->has_static_relocs = TRUE;
11534 if (ind->root.type != bfd_link_hash_indirect)
11537 dirmips->possibly_dynamic_relocs += indmips->possibly_dynamic_relocs;
11538 if (indmips->readonly_reloc)
11539 dirmips->readonly_reloc = TRUE;
11540 if (indmips->no_fn_stub)
11541 dirmips->no_fn_stub = TRUE;
11542 if (indmips->fn_stub)
11544 dirmips->fn_stub = indmips->fn_stub;
11545 indmips->fn_stub = NULL;
11547 if (indmips->need_fn_stub)
11549 dirmips->need_fn_stub = TRUE;
11550 indmips->need_fn_stub = FALSE;
11552 if (indmips->call_stub)
11554 dirmips->call_stub = indmips->call_stub;
11555 indmips->call_stub = NULL;
11557 if (indmips->call_fp_stub)
11559 dirmips->call_fp_stub = indmips->call_fp_stub;
11560 indmips->call_fp_stub = NULL;
11562 if (indmips->global_got_area < dirmips->global_got_area)
11563 dirmips->global_got_area = indmips->global_got_area;
11564 if (indmips->global_got_area < GGA_NONE)
11565 indmips->global_got_area = GGA_NONE;
11566 if (indmips->has_nonpic_branches)
11567 dirmips->has_nonpic_branches = TRUE;
11569 if (dirmips->tls_type == 0)
11570 dirmips->tls_type = indmips->tls_type;
11573 #define PDR_SIZE 32
11576 _bfd_mips_elf_discard_info (bfd *abfd, struct elf_reloc_cookie *cookie,
11577 struct bfd_link_info *info)
11580 bfd_boolean ret = FALSE;
11581 unsigned char *tdata;
11584 o = bfd_get_section_by_name (abfd, ".pdr");
11589 if (o->size % PDR_SIZE != 0)
11591 if (o->output_section != NULL
11592 && bfd_is_abs_section (o->output_section))
11595 tdata = bfd_zmalloc (o->size / PDR_SIZE);
11599 cookie->rels = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
11600 info->keep_memory);
11607 cookie->rel = cookie->rels;
11608 cookie->relend = cookie->rels + o->reloc_count;
11610 for (i = 0, skip = 0; i < o->size / PDR_SIZE; i ++)
11612 if (bfd_elf_reloc_symbol_deleted_p (i * PDR_SIZE, cookie))
11621 mips_elf_section_data (o)->u.tdata = tdata;
11622 o->size -= skip * PDR_SIZE;
11628 if (! info->keep_memory)
11629 free (cookie->rels);
11635 _bfd_mips_elf_ignore_discarded_relocs (asection *sec)
11637 if (strcmp (sec->name, ".pdr") == 0)
11643 _bfd_mips_elf_write_section (bfd *output_bfd,
11644 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
11645 asection *sec, bfd_byte *contents)
11647 bfd_byte *to, *from, *end;
11650 if (strcmp (sec->name, ".pdr") != 0)
11653 if (mips_elf_section_data (sec)->u.tdata == NULL)
11657 end = contents + sec->size;
11658 for (from = contents, i = 0;
11660 from += PDR_SIZE, i++)
11662 if ((mips_elf_section_data (sec)->u.tdata)[i] == 1)
11665 memcpy (to, from, PDR_SIZE);
11668 bfd_set_section_contents (output_bfd, sec->output_section, contents,
11669 sec->output_offset, sec->size);
11673 /* microMIPS code retains local labels for linker relaxation. Omit them
11674 from output by default for clarity. */
11677 _bfd_mips_elf_is_target_special_symbol (bfd *abfd, asymbol *sym)
11679 return _bfd_elf_is_local_label_name (abfd, sym->name);
11682 /* MIPS ELF uses a special find_nearest_line routine in order the
11683 handle the ECOFF debugging information. */
11685 struct mips_elf_find_line
11687 struct ecoff_debug_info d;
11688 struct ecoff_find_line i;
11692 _bfd_mips_elf_find_nearest_line (bfd *abfd, asection *section,
11693 asymbol **symbols, bfd_vma offset,
11694 const char **filename_ptr,
11695 const char **functionname_ptr,
11696 unsigned int *line_ptr)
11700 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
11701 filename_ptr, functionname_ptr,
11705 if (_bfd_dwarf2_find_nearest_line (abfd, dwarf_debug_sections,
11706 section, symbols, offset,
11707 filename_ptr, functionname_ptr,
11708 line_ptr, NULL, ABI_64_P (abfd) ? 8 : 0,
11709 &elf_tdata (abfd)->dwarf2_find_line_info))
11712 msec = bfd_get_section_by_name (abfd, ".mdebug");
11715 flagword origflags;
11716 struct mips_elf_find_line *fi;
11717 const struct ecoff_debug_swap * const swap =
11718 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
11720 /* If we are called during a link, mips_elf_final_link may have
11721 cleared the SEC_HAS_CONTENTS field. We force it back on here
11722 if appropriate (which it normally will be). */
11723 origflags = msec->flags;
11724 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
11725 msec->flags |= SEC_HAS_CONTENTS;
11727 fi = elf_tdata (abfd)->find_line_info;
11730 bfd_size_type external_fdr_size;
11733 struct fdr *fdr_ptr;
11734 bfd_size_type amt = sizeof (struct mips_elf_find_line);
11736 fi = bfd_zalloc (abfd, amt);
11739 msec->flags = origflags;
11743 if (! _bfd_mips_elf_read_ecoff_info (abfd, msec, &fi->d))
11745 msec->flags = origflags;
11749 /* Swap in the FDR information. */
11750 amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
11751 fi->d.fdr = bfd_alloc (abfd, amt);
11752 if (fi->d.fdr == NULL)
11754 msec->flags = origflags;
11757 external_fdr_size = swap->external_fdr_size;
11758 fdr_ptr = fi->d.fdr;
11759 fraw_src = (char *) fi->d.external_fdr;
11760 fraw_end = (fraw_src
11761 + fi->d.symbolic_header.ifdMax * external_fdr_size);
11762 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
11763 (*swap->swap_fdr_in) (abfd, fraw_src, fdr_ptr);
11765 elf_tdata (abfd)->find_line_info = fi;
11767 /* Note that we don't bother to ever free this information.
11768 find_nearest_line is either called all the time, as in
11769 objdump -l, so the information should be saved, or it is
11770 rarely called, as in ld error messages, so the memory
11771 wasted is unimportant. Still, it would probably be a
11772 good idea for free_cached_info to throw it away. */
11775 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
11776 &fi->i, filename_ptr, functionname_ptr,
11779 msec->flags = origflags;
11783 msec->flags = origflags;
11786 /* Fall back on the generic ELF find_nearest_line routine. */
11788 return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
11789 filename_ptr, functionname_ptr,
11794 _bfd_mips_elf_find_inliner_info (bfd *abfd,
11795 const char **filename_ptr,
11796 const char **functionname_ptr,
11797 unsigned int *line_ptr)
11800 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
11801 functionname_ptr, line_ptr,
11802 & elf_tdata (abfd)->dwarf2_find_line_info);
11807 /* When are writing out the .options or .MIPS.options section,
11808 remember the bytes we are writing out, so that we can install the
11809 GP value in the section_processing routine. */
11812 _bfd_mips_elf_set_section_contents (bfd *abfd, sec_ptr section,
11813 const void *location,
11814 file_ptr offset, bfd_size_type count)
11816 if (MIPS_ELF_OPTIONS_SECTION_NAME_P (section->name))
11820 if (elf_section_data (section) == NULL)
11822 bfd_size_type amt = sizeof (struct bfd_elf_section_data);
11823 section->used_by_bfd = bfd_zalloc (abfd, amt);
11824 if (elf_section_data (section) == NULL)
11827 c = mips_elf_section_data (section)->u.tdata;
11830 c = bfd_zalloc (abfd, section->size);
11833 mips_elf_section_data (section)->u.tdata = c;
11836 memcpy (c + offset, location, count);
11839 return _bfd_elf_set_section_contents (abfd, section, location, offset,
11843 /* This is almost identical to bfd_generic_get_... except that some
11844 MIPS relocations need to be handled specially. Sigh. */
11847 _bfd_elf_mips_get_relocated_section_contents
11849 struct bfd_link_info *link_info,
11850 struct bfd_link_order *link_order,
11852 bfd_boolean relocatable,
11855 /* Get enough memory to hold the stuff */
11856 bfd *input_bfd = link_order->u.indirect.section->owner;
11857 asection *input_section = link_order->u.indirect.section;
11860 long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
11861 arelent **reloc_vector = NULL;
11864 if (reloc_size < 0)
11867 reloc_vector = bfd_malloc (reloc_size);
11868 if (reloc_vector == NULL && reloc_size != 0)
11871 /* read in the section */
11872 sz = input_section->rawsize ? input_section->rawsize : input_section->size;
11873 if (!bfd_get_section_contents (input_bfd, input_section, data, 0, sz))
11876 reloc_count = bfd_canonicalize_reloc (input_bfd,
11880 if (reloc_count < 0)
11883 if (reloc_count > 0)
11888 bfd_vma gp = 0x12345678; /* initialize just to shut gcc up */
11891 struct bfd_hash_entry *h;
11892 struct bfd_link_hash_entry *lh;
11893 /* Skip all this stuff if we aren't mixing formats. */
11894 if (abfd && input_bfd
11895 && abfd->xvec == input_bfd->xvec)
11899 h = bfd_hash_lookup (&link_info->hash->table, "_gp", FALSE, FALSE);
11900 lh = (struct bfd_link_hash_entry *) h;
11907 case bfd_link_hash_undefined:
11908 case bfd_link_hash_undefweak:
11909 case bfd_link_hash_common:
11912 case bfd_link_hash_defined:
11913 case bfd_link_hash_defweak:
11915 gp = lh->u.def.value;
11917 case bfd_link_hash_indirect:
11918 case bfd_link_hash_warning:
11920 /* @@FIXME ignoring warning for now */
11922 case bfd_link_hash_new:
11931 for (parent = reloc_vector; *parent != NULL; parent++)
11933 char *error_message = NULL;
11934 bfd_reloc_status_type r;
11936 /* Specific to MIPS: Deal with relocation types that require
11937 knowing the gp of the output bfd. */
11938 asymbol *sym = *(*parent)->sym_ptr_ptr;
11940 /* If we've managed to find the gp and have a special
11941 function for the relocation then go ahead, else default
11942 to the generic handling. */
11944 && (*parent)->howto->special_function
11945 == _bfd_mips_elf32_gprel16_reloc)
11946 r = _bfd_mips_elf_gprel16_with_gp (input_bfd, sym, *parent,
11947 input_section, relocatable,
11950 r = bfd_perform_relocation (input_bfd, *parent, data,
11952 relocatable ? abfd : NULL,
11957 asection *os = input_section->output_section;
11959 /* A partial link, so keep the relocs */
11960 os->orelocation[os->reloc_count] = *parent;
11964 if (r != bfd_reloc_ok)
11968 case bfd_reloc_undefined:
11969 if (!((*link_info->callbacks->undefined_symbol)
11970 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
11971 input_bfd, input_section, (*parent)->address, TRUE)))
11974 case bfd_reloc_dangerous:
11975 BFD_ASSERT (error_message != NULL);
11976 if (!((*link_info->callbacks->reloc_dangerous)
11977 (link_info, error_message, input_bfd, input_section,
11978 (*parent)->address)))
11981 case bfd_reloc_overflow:
11982 if (!((*link_info->callbacks->reloc_overflow)
11984 bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
11985 (*parent)->howto->name, (*parent)->addend,
11986 input_bfd, input_section, (*parent)->address)))
11989 case bfd_reloc_outofrange:
11998 if (reloc_vector != NULL)
11999 free (reloc_vector);
12003 if (reloc_vector != NULL)
12004 free (reloc_vector);
12009 mips_elf_relax_delete_bytes (bfd *abfd,
12010 asection *sec, bfd_vma addr, int count)
12012 Elf_Internal_Shdr *symtab_hdr;
12013 unsigned int sec_shndx;
12014 bfd_byte *contents;
12015 Elf_Internal_Rela *irel, *irelend;
12016 Elf_Internal_Sym *isym;
12017 Elf_Internal_Sym *isymend;
12018 struct elf_link_hash_entry **sym_hashes;
12019 struct elf_link_hash_entry **end_hashes;
12020 struct elf_link_hash_entry **start_hashes;
12021 unsigned int symcount;
12023 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
12024 contents = elf_section_data (sec)->this_hdr.contents;
12026 irel = elf_section_data (sec)->relocs;
12027 irelend = irel + sec->reloc_count;
12029 /* Actually delete the bytes. */
12030 memmove (contents + addr, contents + addr + count,
12031 (size_t) (sec->size - addr - count));
12032 sec->size -= count;
12034 /* Adjust all the relocs. */
12035 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
12037 /* Get the new reloc address. */
12038 if (irel->r_offset > addr)
12039 irel->r_offset -= count;
12042 BFD_ASSERT (addr % 2 == 0);
12043 BFD_ASSERT (count % 2 == 0);
12045 /* Adjust the local symbols defined in this section. */
12046 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12047 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
12048 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
12049 if (isym->st_shndx == sec_shndx && isym->st_value > addr)
12050 isym->st_value -= count;
12052 /* Now adjust the global symbols defined in this section. */
12053 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
12054 - symtab_hdr->sh_info);
12055 sym_hashes = start_hashes = elf_sym_hashes (abfd);
12056 end_hashes = sym_hashes + symcount;
12058 for (; sym_hashes < end_hashes; sym_hashes++)
12060 struct elf_link_hash_entry *sym_hash = *sym_hashes;
12062 if ((sym_hash->root.type == bfd_link_hash_defined
12063 || sym_hash->root.type == bfd_link_hash_defweak)
12064 && sym_hash->root.u.def.section == sec)
12066 bfd_vma value = sym_hash->root.u.def.value;
12068 if (ELF_ST_IS_MICROMIPS (sym_hash->other))
12069 value &= MINUS_TWO;
12071 sym_hash->root.u.def.value -= count;
12079 /* Opcodes needed for microMIPS relaxation as found in
12080 opcodes/micromips-opc.c. */
12082 struct opcode_descriptor {
12083 unsigned long match;
12084 unsigned long mask;
12087 /* The $ra register aka $31. */
12091 /* 32-bit instruction format register fields. */
12093 #define OP32_SREG(opcode) (((opcode) >> 16) & 0x1f)
12094 #define OP32_TREG(opcode) (((opcode) >> 21) & 0x1f)
12096 /* Check if a 5-bit register index can be abbreviated to 3 bits. */
12098 #define OP16_VALID_REG(r) \
12099 ((2 <= (r) && (r) <= 7) || (16 <= (r) && (r) <= 17))
12102 /* 32-bit and 16-bit branches. */
12104 static const struct opcode_descriptor b_insns_32[] = {
12105 { /* "b", "p", */ 0x40400000, 0xffff0000 }, /* bgez 0 */
12106 { /* "b", "p", */ 0x94000000, 0xffff0000 }, /* beq 0, 0 */
12107 { 0, 0 } /* End marker for find_match(). */
12110 static const struct opcode_descriptor bc_insn_32 =
12111 { /* "bc(1|2)(ft)", "N,p", */ 0x42800000, 0xfec30000 };
12113 static const struct opcode_descriptor bz_insn_32 =
12114 { /* "b(g|l)(e|t)z", "s,p", */ 0x40000000, 0xff200000 };
12116 static const struct opcode_descriptor bzal_insn_32 =
12117 { /* "b(ge|lt)zal", "s,p", */ 0x40200000, 0xffa00000 };
12119 static const struct opcode_descriptor beq_insn_32 =
12120 { /* "b(eq|ne)", "s,t,p", */ 0x94000000, 0xdc000000 };
12122 static const struct opcode_descriptor b_insn_16 =
12123 { /* "b", "mD", */ 0xcc00, 0xfc00 };
12125 static const struct opcode_descriptor bz_insn_16 =
12126 { /* "b(eq|ne)z", "md,mE", */ 0x8c00, 0xdc00 };
12129 /* 32-bit and 16-bit branch EQ and NE zero. */
12131 /* NOTE: All opcode tables have BEQ/BNE in the same order: first the
12132 eq and second the ne. This convention is used when replacing a
12133 32-bit BEQ/BNE with the 16-bit version. */
12135 #define BZC32_REG_FIELD(r) (((r) & 0x1f) << 16)
12137 static const struct opcode_descriptor bz_rs_insns_32[] = {
12138 { /* "beqz", "s,p", */ 0x94000000, 0xffe00000 },
12139 { /* "bnez", "s,p", */ 0xb4000000, 0xffe00000 },
12140 { 0, 0 } /* End marker for find_match(). */
12143 static const struct opcode_descriptor bz_rt_insns_32[] = {
12144 { /* "beqz", "t,p", */ 0x94000000, 0xfc01f000 },
12145 { /* "bnez", "t,p", */ 0xb4000000, 0xfc01f000 },
12146 { 0, 0 } /* End marker for find_match(). */
12149 static const struct opcode_descriptor bzc_insns_32[] = {
12150 { /* "beqzc", "s,p", */ 0x40e00000, 0xffe00000 },
12151 { /* "bnezc", "s,p", */ 0x40a00000, 0xffe00000 },
12152 { 0, 0 } /* End marker for find_match(). */
12155 static const struct opcode_descriptor bz_insns_16[] = {
12156 { /* "beqz", "md,mE", */ 0x8c00, 0xfc00 },
12157 { /* "bnez", "md,mE", */ 0xac00, 0xfc00 },
12158 { 0, 0 } /* End marker for find_match(). */
12161 /* Switch between a 5-bit register index and its 3-bit shorthand. */
12163 #define BZ16_REG(opcode) ((((((opcode) >> 7) & 7) + 0x1e) & 0x17) + 2)
12164 #define BZ16_REG_FIELD(r) \
12165 (((2 <= (r) && (r) <= 7) ? (r) : ((r) - 16)) << 7)
12168 /* 32-bit instructions with a delay slot. */
12170 static const struct opcode_descriptor jal_insn_32_bd16 =
12171 { /* "jals", "a", */ 0x74000000, 0xfc000000 };
12173 static const struct opcode_descriptor jal_insn_32_bd32 =
12174 { /* "jal", "a", */ 0xf4000000, 0xfc000000 };
12176 static const struct opcode_descriptor jal_x_insn_32_bd32 =
12177 { /* "jal[x]", "a", */ 0xf0000000, 0xf8000000 };
12179 static const struct opcode_descriptor j_insn_32 =
12180 { /* "j", "a", */ 0xd4000000, 0xfc000000 };
12182 static const struct opcode_descriptor jalr_insn_32 =
12183 { /* "jalr[.hb]", "t,s", */ 0x00000f3c, 0xfc00efff };
12185 /* This table can be compacted, because no opcode replacement is made. */
12187 static const struct opcode_descriptor ds_insns_32_bd16[] = {
12188 { /* "jals", "a", */ 0x74000000, 0xfc000000 },
12190 { /* "jalrs[.hb]", "t,s", */ 0x00004f3c, 0xfc00efff },
12191 { /* "b(ge|lt)zals", "s,p", */ 0x42200000, 0xffa00000 },
12193 { /* "b(g|l)(e|t)z", "s,p", */ 0x40000000, 0xff200000 },
12194 { /* "b(eq|ne)", "s,t,p", */ 0x94000000, 0xdc000000 },
12195 { /* "j", "a", */ 0xd4000000, 0xfc000000 },
12196 { 0, 0 } /* End marker for find_match(). */
12199 /* This table can be compacted, because no opcode replacement is made. */
12201 static const struct opcode_descriptor ds_insns_32_bd32[] = {
12202 { /* "jal[x]", "a", */ 0xf0000000, 0xf8000000 },
12204 { /* "jalr[.hb]", "t,s", */ 0x00000f3c, 0xfc00efff },
12205 { /* "b(ge|lt)zal", "s,p", */ 0x40200000, 0xffa00000 },
12206 { 0, 0 } /* End marker for find_match(). */
12210 /* 16-bit instructions with a delay slot. */
12212 static const struct opcode_descriptor jalr_insn_16_bd16 =
12213 { /* "jalrs", "my,mj", */ 0x45e0, 0xffe0 };
12215 static const struct opcode_descriptor jalr_insn_16_bd32 =
12216 { /* "jalr", "my,mj", */ 0x45c0, 0xffe0 };
12218 static const struct opcode_descriptor jr_insn_16 =
12219 { /* "jr", "mj", */ 0x4580, 0xffe0 };
12221 #define JR16_REG(opcode) ((opcode) & 0x1f)
12223 /* This table can be compacted, because no opcode replacement is made. */
12225 static const struct opcode_descriptor ds_insns_16_bd16[] = {
12226 { /* "jalrs", "my,mj", */ 0x45e0, 0xffe0 },
12228 { /* "b", "mD", */ 0xcc00, 0xfc00 },
12229 { /* "b(eq|ne)z", "md,mE", */ 0x8c00, 0xdc00 },
12230 { /* "jr", "mj", */ 0x4580, 0xffe0 },
12231 { 0, 0 } /* End marker for find_match(). */
12235 /* LUI instruction. */
12237 static const struct opcode_descriptor lui_insn =
12238 { /* "lui", "s,u", */ 0x41a00000, 0xffe00000 };
12241 /* ADDIU instruction. */
12243 static const struct opcode_descriptor addiu_insn =
12244 { /* "addiu", "t,r,j", */ 0x30000000, 0xfc000000 };
12246 static const struct opcode_descriptor addiupc_insn =
12247 { /* "addiu", "mb,$pc,mQ", */ 0x78000000, 0xfc000000 };
12249 #define ADDIUPC_REG_FIELD(r) \
12250 (((2 <= (r) && (r) <= 7) ? (r) : ((r) - 16)) << 23)
12253 /* Relaxable instructions in a JAL delay slot: MOVE. */
12255 /* The 16-bit move has rd in 9:5 and rs in 4:0. The 32-bit moves
12256 (ADDU, OR) have rd in 15:11 and rs in 10:16. */
12257 #define MOVE32_RD(opcode) (((opcode) >> 11) & 0x1f)
12258 #define MOVE32_RS(opcode) (((opcode) >> 16) & 0x1f)
12260 #define MOVE16_RD_FIELD(r) (((r) & 0x1f) << 5)
12261 #define MOVE16_RS_FIELD(r) (((r) & 0x1f) )
12263 static const struct opcode_descriptor move_insns_32[] = {
12264 { /* "move", "d,s", */ 0x00000150, 0xffe007ff }, /* addu d,s,$0 */
12265 { /* "move", "d,s", */ 0x00000290, 0xffe007ff }, /* or d,s,$0 */
12266 { 0, 0 } /* End marker for find_match(). */
12269 static const struct opcode_descriptor move_insn_16 =
12270 { /* "move", "mp,mj", */ 0x0c00, 0xfc00 };
12273 /* NOP instructions. */
12275 static const struct opcode_descriptor nop_insn_32 =
12276 { /* "nop", "", */ 0x00000000, 0xffffffff };
12278 static const struct opcode_descriptor nop_insn_16 =
12279 { /* "nop", "", */ 0x0c00, 0xffff };
12282 /* Instruction match support. */
12284 #define MATCH(opcode, insn) ((opcode & insn.mask) == insn.match)
12287 find_match (unsigned long opcode, const struct opcode_descriptor insn[])
12289 unsigned long indx;
12291 for (indx = 0; insn[indx].mask != 0; indx++)
12292 if (MATCH (opcode, insn[indx]))
12299 /* Branch and delay slot decoding support. */
12301 /* If PTR points to what *might* be a 16-bit branch or jump, then
12302 return the minimum length of its delay slot, otherwise return 0.
12303 Non-zero results are not definitive as we might be checking against
12304 the second half of another instruction. */
12307 check_br16_dslot (bfd *abfd, bfd_byte *ptr)
12309 unsigned long opcode;
12312 opcode = bfd_get_16 (abfd, ptr);
12313 if (MATCH (opcode, jalr_insn_16_bd32) != 0)
12314 /* 16-bit branch/jump with a 32-bit delay slot. */
12316 else if (MATCH (opcode, jalr_insn_16_bd16) != 0
12317 || find_match (opcode, ds_insns_16_bd16) >= 0)
12318 /* 16-bit branch/jump with a 16-bit delay slot. */
12321 /* No delay slot. */
12327 /* If PTR points to what *might* be a 32-bit branch or jump, then
12328 return the minimum length of its delay slot, otherwise return 0.
12329 Non-zero results are not definitive as we might be checking against
12330 the second half of another instruction. */
12333 check_br32_dslot (bfd *abfd, bfd_byte *ptr)
12335 unsigned long opcode;
12338 opcode = bfd_get_micromips_32 (abfd, ptr);
12339 if (find_match (opcode, ds_insns_32_bd32) >= 0)
12340 /* 32-bit branch/jump with a 32-bit delay slot. */
12342 else if (find_match (opcode, ds_insns_32_bd16) >= 0)
12343 /* 32-bit branch/jump with a 16-bit delay slot. */
12346 /* No delay slot. */
12352 /* If PTR points to a 16-bit branch or jump with a 32-bit delay slot
12353 that doesn't fiddle with REG, then return TRUE, otherwise FALSE. */
12356 check_br16 (bfd *abfd, bfd_byte *ptr, unsigned long reg)
12358 unsigned long opcode;
12360 opcode = bfd_get_16 (abfd, ptr);
12361 if (MATCH (opcode, b_insn_16)
12363 || (MATCH (opcode, jr_insn_16) && reg != JR16_REG (opcode))
12365 || (MATCH (opcode, bz_insn_16) && reg != BZ16_REG (opcode))
12366 /* BEQZ16, BNEZ16 */
12367 || (MATCH (opcode, jalr_insn_16_bd32)
12369 && reg != JR16_REG (opcode) && reg != RA))
12375 /* If PTR points to a 32-bit branch or jump that doesn't fiddle with REG,
12376 then return TRUE, otherwise FALSE. */
12379 check_br32 (bfd *abfd, bfd_byte *ptr, unsigned long reg)
12381 unsigned long opcode;
12383 opcode = bfd_get_micromips_32 (abfd, ptr);
12384 if (MATCH (opcode, j_insn_32)
12386 || MATCH (opcode, bc_insn_32)
12387 /* BC1F, BC1T, BC2F, BC2T */
12388 || (MATCH (opcode, jal_x_insn_32_bd32) && reg != RA)
12390 || (MATCH (opcode, bz_insn_32) && reg != OP32_SREG (opcode))
12391 /* BGEZ, BGTZ, BLEZ, BLTZ */
12392 || (MATCH (opcode, bzal_insn_32)
12393 /* BGEZAL, BLTZAL */
12394 && reg != OP32_SREG (opcode) && reg != RA)
12395 || ((MATCH (opcode, jalr_insn_32) || MATCH (opcode, beq_insn_32))
12396 /* JALR, JALR.HB, BEQ, BNE */
12397 && reg != OP32_SREG (opcode) && reg != OP32_TREG (opcode)))
12403 /* If the instruction encoding at PTR and relocations [INTERNAL_RELOCS,
12404 IRELEND) at OFFSET indicate that there must be a compact branch there,
12405 then return TRUE, otherwise FALSE. */
12408 check_relocated_bzc (bfd *abfd, const bfd_byte *ptr, bfd_vma offset,
12409 const Elf_Internal_Rela *internal_relocs,
12410 const Elf_Internal_Rela *irelend)
12412 const Elf_Internal_Rela *irel;
12413 unsigned long opcode;
12415 opcode = bfd_get_micromips_32 (abfd, ptr);
12416 if (find_match (opcode, bzc_insns_32) < 0)
12419 for (irel = internal_relocs; irel < irelend; irel++)
12420 if (irel->r_offset == offset
12421 && ELF32_R_TYPE (irel->r_info) == R_MICROMIPS_PC16_S1)
12427 /* Bitsize checking. */
12428 #define IS_BITSIZE(val, N) \
12429 (((((val) & ((1ULL << (N)) - 1)) ^ (1ULL << ((N) - 1))) \
12430 - (1ULL << ((N) - 1))) == (val))
12434 _bfd_mips_elf_relax_section (bfd *abfd, asection *sec,
12435 struct bfd_link_info *link_info,
12436 bfd_boolean *again)
12438 Elf_Internal_Shdr *symtab_hdr;
12439 Elf_Internal_Rela *internal_relocs;
12440 Elf_Internal_Rela *irel, *irelend;
12441 bfd_byte *contents = NULL;
12442 Elf_Internal_Sym *isymbuf = NULL;
12444 /* Assume nothing changes. */
12447 /* We don't have to do anything for a relocatable link, if
12448 this section does not have relocs, or if this is not a
12451 if (link_info->relocatable
12452 || (sec->flags & SEC_RELOC) == 0
12453 || sec->reloc_count == 0
12454 || (sec->flags & SEC_CODE) == 0)
12457 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12459 /* Get a copy of the native relocations. */
12460 internal_relocs = (_bfd_elf_link_read_relocs
12461 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
12462 link_info->keep_memory));
12463 if (internal_relocs == NULL)
12466 /* Walk through them looking for relaxing opportunities. */
12467 irelend = internal_relocs + sec->reloc_count;
12468 for (irel = internal_relocs; irel < irelend; irel++)
12470 unsigned long r_symndx = ELF32_R_SYM (irel->r_info);
12471 unsigned int r_type = ELF32_R_TYPE (irel->r_info);
12472 bfd_boolean target_is_micromips_code_p;
12473 unsigned long opcode;
12479 /* The number of bytes to delete for relaxation and from where
12480 to delete these bytes starting at irel->r_offset. */
12484 /* If this isn't something that can be relaxed, then ignore
12486 if (r_type != R_MICROMIPS_HI16
12487 && r_type != R_MICROMIPS_PC16_S1
12488 && r_type != R_MICROMIPS_26_S1)
12491 /* Get the section contents if we haven't done so already. */
12492 if (contents == NULL)
12494 /* Get cached copy if it exists. */
12495 if (elf_section_data (sec)->this_hdr.contents != NULL)
12496 contents = elf_section_data (sec)->this_hdr.contents;
12497 /* Go get them off disk. */
12498 else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
12501 ptr = contents + irel->r_offset;
12503 /* Read this BFD's local symbols if we haven't done so already. */
12504 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
12506 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
12507 if (isymbuf == NULL)
12508 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
12509 symtab_hdr->sh_info, 0,
12511 if (isymbuf == NULL)
12515 /* Get the value of the symbol referred to by the reloc. */
12516 if (r_symndx < symtab_hdr->sh_info)
12518 /* A local symbol. */
12519 Elf_Internal_Sym *isym;
12522 isym = isymbuf + r_symndx;
12523 if (isym->st_shndx == SHN_UNDEF)
12524 sym_sec = bfd_und_section_ptr;
12525 else if (isym->st_shndx == SHN_ABS)
12526 sym_sec = bfd_abs_section_ptr;
12527 else if (isym->st_shndx == SHN_COMMON)
12528 sym_sec = bfd_com_section_ptr;
12530 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
12531 symval = (isym->st_value
12532 + sym_sec->output_section->vma
12533 + sym_sec->output_offset);
12534 target_is_micromips_code_p = ELF_ST_IS_MICROMIPS (isym->st_other);
12538 unsigned long indx;
12539 struct elf_link_hash_entry *h;
12541 /* An external symbol. */
12542 indx = r_symndx - symtab_hdr->sh_info;
12543 h = elf_sym_hashes (abfd)[indx];
12544 BFD_ASSERT (h != NULL);
12546 if (h->root.type != bfd_link_hash_defined
12547 && h->root.type != bfd_link_hash_defweak)
12548 /* This appears to be a reference to an undefined
12549 symbol. Just ignore it -- it will be caught by the
12550 regular reloc processing. */
12553 symval = (h->root.u.def.value
12554 + h->root.u.def.section->output_section->vma
12555 + h->root.u.def.section->output_offset);
12556 target_is_micromips_code_p = (!h->needs_plt
12557 && ELF_ST_IS_MICROMIPS (h->other));
12561 /* For simplicity of coding, we are going to modify the
12562 section contents, the section relocs, and the BFD symbol
12563 table. We must tell the rest of the code not to free up this
12564 information. It would be possible to instead create a table
12565 of changes which have to be made, as is done in coff-mips.c;
12566 that would be more work, but would require less memory when
12567 the linker is run. */
12569 /* Only 32-bit instructions relaxed. */
12570 if (irel->r_offset + 4 > sec->size)
12573 opcode = bfd_get_micromips_32 (abfd, ptr);
12575 /* This is the pc-relative distance from the instruction the
12576 relocation is applied to, to the symbol referred. */
12578 - (sec->output_section->vma + sec->output_offset)
12581 /* R_MICROMIPS_HI16 / LUI relaxation to nil, performing relaxation
12582 of corresponding R_MICROMIPS_LO16 to R_MICROMIPS_HI0_LO16 or
12583 R_MICROMIPS_PC23_S2. The R_MICROMIPS_PC23_S2 condition is
12585 (symval % 4 == 0 && IS_BITSIZE (pcrval, 25))
12587 where pcrval has first to be adjusted to apply against the LO16
12588 location (we make the adjustment later on, when we have figured
12589 out the offset). */
12590 if (r_type == R_MICROMIPS_HI16 && MATCH (opcode, lui_insn))
12592 bfd_boolean bzc = FALSE;
12593 unsigned long nextopc;
12597 /* Give up if the previous reloc was a HI16 against this symbol
12599 if (irel > internal_relocs
12600 && ELF32_R_TYPE (irel[-1].r_info) == R_MICROMIPS_HI16
12601 && ELF32_R_SYM (irel[-1].r_info) == r_symndx)
12604 /* Or if the next reloc is not a LO16 against this symbol. */
12605 if (irel + 1 >= irelend
12606 || ELF32_R_TYPE (irel[1].r_info) != R_MICROMIPS_LO16
12607 || ELF32_R_SYM (irel[1].r_info) != r_symndx)
12610 /* Or if the second next reloc is a LO16 against this symbol too. */
12611 if (irel + 2 >= irelend
12612 && ELF32_R_TYPE (irel[2].r_info) == R_MICROMIPS_LO16
12613 && ELF32_R_SYM (irel[2].r_info) == r_symndx)
12616 /* See if the LUI instruction *might* be in a branch delay slot.
12617 We check whether what looks like a 16-bit branch or jump is
12618 actually an immediate argument to a compact branch, and let
12619 it through if so. */
12620 if (irel->r_offset >= 2
12621 && check_br16_dslot (abfd, ptr - 2)
12622 && !(irel->r_offset >= 4
12623 && (bzc = check_relocated_bzc (abfd,
12624 ptr - 4, irel->r_offset - 4,
12625 internal_relocs, irelend))))
12627 if (irel->r_offset >= 4
12629 && check_br32_dslot (abfd, ptr - 4))
12632 reg = OP32_SREG (opcode);
12634 /* We only relax adjacent instructions or ones separated with
12635 a branch or jump that has a delay slot. The branch or jump
12636 must not fiddle with the register used to hold the address.
12637 Subtract 4 for the LUI itself. */
12638 offset = irel[1].r_offset - irel[0].r_offset;
12639 switch (offset - 4)
12644 if (check_br16 (abfd, ptr + 4, reg))
12648 if (check_br32 (abfd, ptr + 4, reg))
12655 nextopc = bfd_get_micromips_32 (abfd, contents + irel[1].r_offset);
12657 /* Give up unless the same register is used with both
12659 if (OP32_SREG (nextopc) != reg)
12662 /* Now adjust pcrval, subtracting the offset to the LO16 reloc
12663 and rounding up to take masking of the two LSBs into account. */
12664 pcrval = ((pcrval - offset + 3) | 3) ^ 3;
12666 /* R_MICROMIPS_LO16 relaxation to R_MICROMIPS_HI0_LO16. */
12667 if (IS_BITSIZE (symval, 16))
12669 /* Fix the relocation's type. */
12670 irel[1].r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_HI0_LO16);
12672 /* Instructions using R_MICROMIPS_LO16 have the base or
12673 source register in bits 20:16. This register becomes $0
12674 (zero) as the result of the R_MICROMIPS_HI16 being 0. */
12675 nextopc &= ~0x001f0000;
12676 bfd_put_16 (abfd, (nextopc >> 16) & 0xffff,
12677 contents + irel[1].r_offset);
12680 /* R_MICROMIPS_LO16 / ADDIU relaxation to R_MICROMIPS_PC23_S2.
12681 We add 4 to take LUI deletion into account while checking
12682 the PC-relative distance. */
12683 else if (symval % 4 == 0
12684 && IS_BITSIZE (pcrval + 4, 25)
12685 && MATCH (nextopc, addiu_insn)
12686 && OP32_TREG (nextopc) == OP32_SREG (nextopc)
12687 && OP16_VALID_REG (OP32_TREG (nextopc)))
12689 /* Fix the relocation's type. */
12690 irel[1].r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC23_S2);
12692 /* Replace ADDIU with the ADDIUPC version. */
12693 nextopc = (addiupc_insn.match
12694 | ADDIUPC_REG_FIELD (OP32_TREG (nextopc)));
12696 bfd_put_micromips_32 (abfd, nextopc,
12697 contents + irel[1].r_offset);
12700 /* Can't do anything, give up, sigh... */
12704 /* Fix the relocation's type. */
12705 irel->r_info = ELF32_R_INFO (r_symndx, R_MIPS_NONE);
12707 /* Delete the LUI instruction: 4 bytes at irel->r_offset. */
12712 /* Compact branch relaxation -- due to the multitude of macros
12713 employed by the compiler/assembler, compact branches are not
12714 always generated. Obviously, this can/will be fixed elsewhere,
12715 but there is no drawback in double checking it here. */
12716 else if (r_type == R_MICROMIPS_PC16_S1
12717 && irel->r_offset + 5 < sec->size
12718 && ((fndopc = find_match (opcode, bz_rs_insns_32)) >= 0
12719 || (fndopc = find_match (opcode, bz_rt_insns_32)) >= 0)
12720 && MATCH (bfd_get_16 (abfd, ptr + 4), nop_insn_16))
12724 reg = OP32_SREG (opcode) ? OP32_SREG (opcode) : OP32_TREG (opcode);
12726 /* Replace BEQZ/BNEZ with the compact version. */
12727 opcode = (bzc_insns_32[fndopc].match
12728 | BZC32_REG_FIELD (reg)
12729 | (opcode & 0xffff)); /* Addend value. */
12731 bfd_put_micromips_32 (abfd, opcode, ptr);
12733 /* Delete the 16-bit delay slot NOP: two bytes from
12734 irel->offset + 4. */
12739 /* R_MICROMIPS_PC16_S1 relaxation to R_MICROMIPS_PC10_S1. We need
12740 to check the distance from the next instruction, so subtract 2. */
12741 else if (r_type == R_MICROMIPS_PC16_S1
12742 && IS_BITSIZE (pcrval - 2, 11)
12743 && find_match (opcode, b_insns_32) >= 0)
12745 /* Fix the relocation's type. */
12746 irel->r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC10_S1);
12748 /* Replace the 32-bit opcode with a 16-bit opcode. */
12751 | (opcode & 0x3ff)), /* Addend value. */
12754 /* Delete 2 bytes from irel->r_offset + 2. */
12759 /* R_MICROMIPS_PC16_S1 relaxation to R_MICROMIPS_PC7_S1. We need
12760 to check the distance from the next instruction, so subtract 2. */
12761 else if (r_type == R_MICROMIPS_PC16_S1
12762 && IS_BITSIZE (pcrval - 2, 8)
12763 && (((fndopc = find_match (opcode, bz_rs_insns_32)) >= 0
12764 && OP16_VALID_REG (OP32_SREG (opcode)))
12765 || ((fndopc = find_match (opcode, bz_rt_insns_32)) >= 0
12766 && OP16_VALID_REG (OP32_TREG (opcode)))))
12770 reg = OP32_SREG (opcode) ? OP32_SREG (opcode) : OP32_TREG (opcode);
12772 /* Fix the relocation's type. */
12773 irel->r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC7_S1);
12775 /* Replace the 32-bit opcode with a 16-bit opcode. */
12777 (bz_insns_16[fndopc].match
12778 | BZ16_REG_FIELD (reg)
12779 | (opcode & 0x7f)), /* Addend value. */
12782 /* Delete 2 bytes from irel->r_offset + 2. */
12787 /* R_MICROMIPS_26_S1 -- JAL to JALS relaxation for microMIPS targets. */
12788 else if (r_type == R_MICROMIPS_26_S1
12789 && target_is_micromips_code_p
12790 && irel->r_offset + 7 < sec->size
12791 && MATCH (opcode, jal_insn_32_bd32))
12793 unsigned long n32opc;
12794 bfd_boolean relaxed = FALSE;
12796 n32opc = bfd_get_micromips_32 (abfd, ptr + 4);
12798 if (MATCH (n32opc, nop_insn_32))
12800 /* Replace delay slot 32-bit NOP with a 16-bit NOP. */
12801 bfd_put_16 (abfd, nop_insn_16.match, ptr + 4);
12805 else if (find_match (n32opc, move_insns_32) >= 0)
12807 /* Replace delay slot 32-bit MOVE with 16-bit MOVE. */
12809 (move_insn_16.match
12810 | MOVE16_RD_FIELD (MOVE32_RD (n32opc))
12811 | MOVE16_RS_FIELD (MOVE32_RS (n32opc))),
12816 /* Other 32-bit instructions relaxable to 16-bit
12817 instructions will be handled here later. */
12821 /* JAL with 32-bit delay slot that is changed to a JALS
12822 with 16-bit delay slot. */
12823 bfd_put_micromips_32 (abfd, jal_insn_32_bd16.match, ptr);
12825 /* Delete 2 bytes from irel->r_offset + 6. */
12833 /* Note that we've changed the relocs, section contents, etc. */
12834 elf_section_data (sec)->relocs = internal_relocs;
12835 elf_section_data (sec)->this_hdr.contents = contents;
12836 symtab_hdr->contents = (unsigned char *) isymbuf;
12838 /* Delete bytes depending on the delcnt and deloff. */
12839 if (!mips_elf_relax_delete_bytes (abfd, sec,
12840 irel->r_offset + deloff, delcnt))
12843 /* That will change things, so we should relax again.
12844 Note that this is not required, and it may be slow. */
12849 if (isymbuf != NULL
12850 && symtab_hdr->contents != (unsigned char *) isymbuf)
12852 if (! link_info->keep_memory)
12856 /* Cache the symbols for elf_link_input_bfd. */
12857 symtab_hdr->contents = (unsigned char *) isymbuf;
12861 if (contents != NULL
12862 && elf_section_data (sec)->this_hdr.contents != contents)
12864 if (! link_info->keep_memory)
12868 /* Cache the section contents for elf_link_input_bfd. */
12869 elf_section_data (sec)->this_hdr.contents = contents;
12873 if (internal_relocs != NULL
12874 && elf_section_data (sec)->relocs != internal_relocs)
12875 free (internal_relocs);
12880 if (isymbuf != NULL
12881 && symtab_hdr->contents != (unsigned char *) isymbuf)
12883 if (contents != NULL
12884 && elf_section_data (sec)->this_hdr.contents != contents)
12886 if (internal_relocs != NULL
12887 && elf_section_data (sec)->relocs != internal_relocs)
12888 free (internal_relocs);
12893 /* Create a MIPS ELF linker hash table. */
12895 struct bfd_link_hash_table *
12896 _bfd_mips_elf_link_hash_table_create (bfd *abfd)
12898 struct mips_elf_link_hash_table *ret;
12899 bfd_size_type amt = sizeof (struct mips_elf_link_hash_table);
12901 ret = bfd_zmalloc (amt);
12905 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
12906 mips_elf_link_hash_newfunc,
12907 sizeof (struct mips_elf_link_hash_entry),
12914 return &ret->root.root;
12917 /* Likewise, but indicate that the target is VxWorks. */
12919 struct bfd_link_hash_table *
12920 _bfd_mips_vxworks_link_hash_table_create (bfd *abfd)
12922 struct bfd_link_hash_table *ret;
12924 ret = _bfd_mips_elf_link_hash_table_create (abfd);
12927 struct mips_elf_link_hash_table *htab;
12929 htab = (struct mips_elf_link_hash_table *) ret;
12930 htab->use_plts_and_copy_relocs = TRUE;
12931 htab->is_vxworks = TRUE;
12936 /* A function that the linker calls if we are allowed to use PLTs
12937 and copy relocs. */
12940 _bfd_mips_elf_use_plts_and_copy_relocs (struct bfd_link_info *info)
12942 mips_elf_hash_table (info)->use_plts_and_copy_relocs = TRUE;
12945 /* We need to use a special link routine to handle the .reginfo and
12946 the .mdebug sections. We need to merge all instances of these
12947 sections together, not write them all out sequentially. */
12950 _bfd_mips_elf_final_link (bfd *abfd, struct bfd_link_info *info)
12953 struct bfd_link_order *p;
12954 asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
12955 asection *rtproc_sec;
12956 Elf32_RegInfo reginfo;
12957 struct ecoff_debug_info debug;
12958 struct mips_htab_traverse_info hti;
12959 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
12960 const struct ecoff_debug_swap *swap = bed->elf_backend_ecoff_debug_swap;
12961 HDRR *symhdr = &debug.symbolic_header;
12962 void *mdebug_handle = NULL;
12967 struct mips_elf_link_hash_table *htab;
12969 static const char * const secname[] =
12971 ".text", ".init", ".fini", ".data",
12972 ".rodata", ".sdata", ".sbss", ".bss"
12974 static const int sc[] =
12976 scText, scInit, scFini, scData,
12977 scRData, scSData, scSBss, scBss
12980 /* Sort the dynamic symbols so that those with GOT entries come after
12982 htab = mips_elf_hash_table (info);
12983 BFD_ASSERT (htab != NULL);
12985 if (!mips_elf_sort_hash_table (abfd, info))
12988 /* Create any scheduled LA25 stubs. */
12990 hti.output_bfd = abfd;
12992 htab_traverse (htab->la25_stubs, mips_elf_create_la25_stub, &hti);
12996 /* Get a value for the GP register. */
12997 if (elf_gp (abfd) == 0)
12999 struct bfd_link_hash_entry *h;
13001 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
13002 if (h != NULL && h->type == bfd_link_hash_defined)
13003 elf_gp (abfd) = (h->u.def.value
13004 + h->u.def.section->output_section->vma
13005 + h->u.def.section->output_offset);
13006 else if (htab->is_vxworks
13007 && (h = bfd_link_hash_lookup (info->hash,
13008 "_GLOBAL_OFFSET_TABLE_",
13009 FALSE, FALSE, TRUE))
13010 && h->type == bfd_link_hash_defined)
13011 elf_gp (abfd) = (h->u.def.section->output_section->vma
13012 + h->u.def.section->output_offset
13014 else if (info->relocatable)
13016 bfd_vma lo = MINUS_ONE;
13018 /* Find the GP-relative section with the lowest offset. */
13019 for (o = abfd->sections; o != NULL; o = o->next)
13021 && (elf_section_data (o)->this_hdr.sh_flags & SHF_MIPS_GPREL))
13024 /* And calculate GP relative to that. */
13025 elf_gp (abfd) = lo + ELF_MIPS_GP_OFFSET (info);
13029 /* If the relocate_section function needs to do a reloc
13030 involving the GP value, it should make a reloc_dangerous
13031 callback to warn that GP is not defined. */
13035 /* Go through the sections and collect the .reginfo and .mdebug
13037 reginfo_sec = NULL;
13039 gptab_data_sec = NULL;
13040 gptab_bss_sec = NULL;
13041 for (o = abfd->sections; o != NULL; o = o->next)
13043 if (strcmp (o->name, ".reginfo") == 0)
13045 memset (®info, 0, sizeof reginfo);
13047 /* We have found the .reginfo section in the output file.
13048 Look through all the link_orders comprising it and merge
13049 the information together. */
13050 for (p = o->map_head.link_order; p != NULL; p = p->next)
13052 asection *input_section;
13054 Elf32_External_RegInfo ext;
13057 if (p->type != bfd_indirect_link_order)
13059 if (p->type == bfd_data_link_order)
13064 input_section = p->u.indirect.section;
13065 input_bfd = input_section->owner;
13067 if (! bfd_get_section_contents (input_bfd, input_section,
13068 &ext, 0, sizeof ext))
13071 bfd_mips_elf32_swap_reginfo_in (input_bfd, &ext, &sub);
13073 reginfo.ri_gprmask |= sub.ri_gprmask;
13074 reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
13075 reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
13076 reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
13077 reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
13079 /* ri_gp_value is set by the function
13080 mips_elf32_section_processing when the section is
13081 finally written out. */
13083 /* Hack: reset the SEC_HAS_CONTENTS flag so that
13084 elf_link_input_bfd ignores this section. */
13085 input_section->flags &= ~SEC_HAS_CONTENTS;
13088 /* Size has been set in _bfd_mips_elf_always_size_sections. */
13089 BFD_ASSERT(o->size == sizeof (Elf32_External_RegInfo));
13091 /* Skip this section later on (I don't think this currently
13092 matters, but someday it might). */
13093 o->map_head.link_order = NULL;
13098 if (strcmp (o->name, ".mdebug") == 0)
13100 struct extsym_info einfo;
13103 /* We have found the .mdebug section in the output file.
13104 Look through all the link_orders comprising it and merge
13105 the information together. */
13106 symhdr->magic = swap->sym_magic;
13107 /* FIXME: What should the version stamp be? */
13108 symhdr->vstamp = 0;
13109 symhdr->ilineMax = 0;
13110 symhdr->cbLine = 0;
13111 symhdr->idnMax = 0;
13112 symhdr->ipdMax = 0;
13113 symhdr->isymMax = 0;
13114 symhdr->ioptMax = 0;
13115 symhdr->iauxMax = 0;
13116 symhdr->issMax = 0;
13117 symhdr->issExtMax = 0;
13118 symhdr->ifdMax = 0;
13120 symhdr->iextMax = 0;
13122 /* We accumulate the debugging information itself in the
13123 debug_info structure. */
13125 debug.external_dnr = NULL;
13126 debug.external_pdr = NULL;
13127 debug.external_sym = NULL;
13128 debug.external_opt = NULL;
13129 debug.external_aux = NULL;
13131 debug.ssext = debug.ssext_end = NULL;
13132 debug.external_fdr = NULL;
13133 debug.external_rfd = NULL;
13134 debug.external_ext = debug.external_ext_end = NULL;
13136 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
13137 if (mdebug_handle == NULL)
13141 esym.cobol_main = 0;
13145 esym.asym.iss = issNil;
13146 esym.asym.st = stLocal;
13147 esym.asym.reserved = 0;
13148 esym.asym.index = indexNil;
13150 for (i = 0; i < sizeof (secname) / sizeof (secname[0]); i++)
13152 esym.asym.sc = sc[i];
13153 s = bfd_get_section_by_name (abfd, secname[i]);
13156 esym.asym.value = s->vma;
13157 last = s->vma + s->size;
13160 esym.asym.value = last;
13161 if (!bfd_ecoff_debug_one_external (abfd, &debug, swap,
13162 secname[i], &esym))
13166 for (p = o->map_head.link_order; p != NULL; p = p->next)
13168 asection *input_section;
13170 const struct ecoff_debug_swap *input_swap;
13171 struct ecoff_debug_info input_debug;
13175 if (p->type != bfd_indirect_link_order)
13177 if (p->type == bfd_data_link_order)
13182 input_section = p->u.indirect.section;
13183 input_bfd = input_section->owner;
13185 if (!is_mips_elf (input_bfd))
13187 /* I don't know what a non MIPS ELF bfd would be
13188 doing with a .mdebug section, but I don't really
13189 want to deal with it. */
13193 input_swap = (get_elf_backend_data (input_bfd)
13194 ->elf_backend_ecoff_debug_swap);
13196 BFD_ASSERT (p->size == input_section->size);
13198 /* The ECOFF linking code expects that we have already
13199 read in the debugging information and set up an
13200 ecoff_debug_info structure, so we do that now. */
13201 if (! _bfd_mips_elf_read_ecoff_info (input_bfd, input_section,
13205 if (! (bfd_ecoff_debug_accumulate
13206 (mdebug_handle, abfd, &debug, swap, input_bfd,
13207 &input_debug, input_swap, info)))
13210 /* Loop through the external symbols. For each one with
13211 interesting information, try to find the symbol in
13212 the linker global hash table and save the information
13213 for the output external symbols. */
13214 eraw_src = input_debug.external_ext;
13215 eraw_end = (eraw_src
13216 + (input_debug.symbolic_header.iextMax
13217 * input_swap->external_ext_size));
13219 eraw_src < eraw_end;
13220 eraw_src += input_swap->external_ext_size)
13224 struct mips_elf_link_hash_entry *h;
13226 (*input_swap->swap_ext_in) (input_bfd, eraw_src, &ext);
13227 if (ext.asym.sc == scNil
13228 || ext.asym.sc == scUndefined
13229 || ext.asym.sc == scSUndefined)
13232 name = input_debug.ssext + ext.asym.iss;
13233 h = mips_elf_link_hash_lookup (mips_elf_hash_table (info),
13234 name, FALSE, FALSE, TRUE);
13235 if (h == NULL || h->esym.ifd != -2)
13240 BFD_ASSERT (ext.ifd
13241 < input_debug.symbolic_header.ifdMax);
13242 ext.ifd = input_debug.ifdmap[ext.ifd];
13248 /* Free up the information we just read. */
13249 free (input_debug.line);
13250 free (input_debug.external_dnr);
13251 free (input_debug.external_pdr);
13252 free (input_debug.external_sym);
13253 free (input_debug.external_opt);
13254 free (input_debug.external_aux);
13255 free (input_debug.ss);
13256 free (input_debug.ssext);
13257 free (input_debug.external_fdr);
13258 free (input_debug.external_rfd);
13259 free (input_debug.external_ext);
13261 /* Hack: reset the SEC_HAS_CONTENTS flag so that
13262 elf_link_input_bfd ignores this section. */
13263 input_section->flags &= ~SEC_HAS_CONTENTS;
13266 if (SGI_COMPAT (abfd) && info->shared)
13268 /* Create .rtproc section. */
13269 rtproc_sec = bfd_get_linker_section (abfd, ".rtproc");
13270 if (rtproc_sec == NULL)
13272 flagword flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
13273 | SEC_LINKER_CREATED | SEC_READONLY);
13275 rtproc_sec = bfd_make_section_anyway_with_flags (abfd,
13278 if (rtproc_sec == NULL
13279 || ! bfd_set_section_alignment (abfd, rtproc_sec, 4))
13283 if (! mips_elf_create_procedure_table (mdebug_handle, abfd,
13289 /* Build the external symbol information. */
13292 einfo.debug = &debug;
13294 einfo.failed = FALSE;
13295 mips_elf_link_hash_traverse (mips_elf_hash_table (info),
13296 mips_elf_output_extsym, &einfo);
13300 /* Set the size of the .mdebug section. */
13301 o->size = bfd_ecoff_debug_size (abfd, &debug, swap);
13303 /* Skip this section later on (I don't think this currently
13304 matters, but someday it might). */
13305 o->map_head.link_order = NULL;
13310 if (CONST_STRNEQ (o->name, ".gptab."))
13312 const char *subname;
13315 Elf32_External_gptab *ext_tab;
13318 /* The .gptab.sdata and .gptab.sbss sections hold
13319 information describing how the small data area would
13320 change depending upon the -G switch. These sections
13321 not used in executables files. */
13322 if (! info->relocatable)
13324 for (p = o->map_head.link_order; p != NULL; p = p->next)
13326 asection *input_section;
13328 if (p->type != bfd_indirect_link_order)
13330 if (p->type == bfd_data_link_order)
13335 input_section = p->u.indirect.section;
13337 /* Hack: reset the SEC_HAS_CONTENTS flag so that
13338 elf_link_input_bfd ignores this section. */
13339 input_section->flags &= ~SEC_HAS_CONTENTS;
13342 /* Skip this section later on (I don't think this
13343 currently matters, but someday it might). */
13344 o->map_head.link_order = NULL;
13346 /* Really remove the section. */
13347 bfd_section_list_remove (abfd, o);
13348 --abfd->section_count;
13353 /* There is one gptab for initialized data, and one for
13354 uninitialized data. */
13355 if (strcmp (o->name, ".gptab.sdata") == 0)
13356 gptab_data_sec = o;
13357 else if (strcmp (o->name, ".gptab.sbss") == 0)
13361 (*_bfd_error_handler)
13362 (_("%s: illegal section name `%s'"),
13363 bfd_get_filename (abfd), o->name);
13364 bfd_set_error (bfd_error_nonrepresentable_section);
13368 /* The linker script always combines .gptab.data and
13369 .gptab.sdata into .gptab.sdata, and likewise for
13370 .gptab.bss and .gptab.sbss. It is possible that there is
13371 no .sdata or .sbss section in the output file, in which
13372 case we must change the name of the output section. */
13373 subname = o->name + sizeof ".gptab" - 1;
13374 if (bfd_get_section_by_name (abfd, subname) == NULL)
13376 if (o == gptab_data_sec)
13377 o->name = ".gptab.data";
13379 o->name = ".gptab.bss";
13380 subname = o->name + sizeof ".gptab" - 1;
13381 BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
13384 /* Set up the first entry. */
13386 amt = c * sizeof (Elf32_gptab);
13387 tab = bfd_malloc (amt);
13390 tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
13391 tab[0].gt_header.gt_unused = 0;
13393 /* Combine the input sections. */
13394 for (p = o->map_head.link_order; p != NULL; p = p->next)
13396 asection *input_section;
13398 bfd_size_type size;
13399 unsigned long last;
13400 bfd_size_type gpentry;
13402 if (p->type != bfd_indirect_link_order)
13404 if (p->type == bfd_data_link_order)
13409 input_section = p->u.indirect.section;
13410 input_bfd = input_section->owner;
13412 /* Combine the gptab entries for this input section one
13413 by one. We know that the input gptab entries are
13414 sorted by ascending -G value. */
13415 size = input_section->size;
13417 for (gpentry = sizeof (Elf32_External_gptab);
13419 gpentry += sizeof (Elf32_External_gptab))
13421 Elf32_External_gptab ext_gptab;
13422 Elf32_gptab int_gptab;
13428 if (! (bfd_get_section_contents
13429 (input_bfd, input_section, &ext_gptab, gpentry,
13430 sizeof (Elf32_External_gptab))))
13436 bfd_mips_elf32_swap_gptab_in (input_bfd, &ext_gptab,
13438 val = int_gptab.gt_entry.gt_g_value;
13439 add = int_gptab.gt_entry.gt_bytes - last;
13442 for (look = 1; look < c; look++)
13444 if (tab[look].gt_entry.gt_g_value >= val)
13445 tab[look].gt_entry.gt_bytes += add;
13447 if (tab[look].gt_entry.gt_g_value == val)
13453 Elf32_gptab *new_tab;
13456 /* We need a new table entry. */
13457 amt = (bfd_size_type) (c + 1) * sizeof (Elf32_gptab);
13458 new_tab = bfd_realloc (tab, amt);
13459 if (new_tab == NULL)
13465 tab[c].gt_entry.gt_g_value = val;
13466 tab[c].gt_entry.gt_bytes = add;
13468 /* Merge in the size for the next smallest -G
13469 value, since that will be implied by this new
13472 for (look = 1; look < c; look++)
13474 if (tab[look].gt_entry.gt_g_value < val
13476 || (tab[look].gt_entry.gt_g_value
13477 > tab[max].gt_entry.gt_g_value)))
13481 tab[c].gt_entry.gt_bytes +=
13482 tab[max].gt_entry.gt_bytes;
13487 last = int_gptab.gt_entry.gt_bytes;
13490 /* Hack: reset the SEC_HAS_CONTENTS flag so that
13491 elf_link_input_bfd ignores this section. */
13492 input_section->flags &= ~SEC_HAS_CONTENTS;
13495 /* The table must be sorted by -G value. */
13497 qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
13499 /* Swap out the table. */
13500 amt = (bfd_size_type) c * sizeof (Elf32_External_gptab);
13501 ext_tab = bfd_alloc (abfd, amt);
13502 if (ext_tab == NULL)
13508 for (j = 0; j < c; j++)
13509 bfd_mips_elf32_swap_gptab_out (abfd, tab + j, ext_tab + j);
13512 o->size = c * sizeof (Elf32_External_gptab);
13513 o->contents = (bfd_byte *) ext_tab;
13515 /* Skip this section later on (I don't think this currently
13516 matters, but someday it might). */
13517 o->map_head.link_order = NULL;
13521 /* Invoke the regular ELF backend linker to do all the work. */
13522 if (!bfd_elf_final_link (abfd, info))
13525 /* Now write out the computed sections. */
13527 if (reginfo_sec != NULL)
13529 Elf32_External_RegInfo ext;
13531 bfd_mips_elf32_swap_reginfo_out (abfd, ®info, &ext);
13532 if (! bfd_set_section_contents (abfd, reginfo_sec, &ext, 0, sizeof ext))
13536 if (mdebug_sec != NULL)
13538 BFD_ASSERT (abfd->output_has_begun);
13539 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
13541 mdebug_sec->filepos))
13544 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
13547 if (gptab_data_sec != NULL)
13549 if (! bfd_set_section_contents (abfd, gptab_data_sec,
13550 gptab_data_sec->contents,
13551 0, gptab_data_sec->size))
13555 if (gptab_bss_sec != NULL)
13557 if (! bfd_set_section_contents (abfd, gptab_bss_sec,
13558 gptab_bss_sec->contents,
13559 0, gptab_bss_sec->size))
13563 if (SGI_COMPAT (abfd))
13565 rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
13566 if (rtproc_sec != NULL)
13568 if (! bfd_set_section_contents (abfd, rtproc_sec,
13569 rtproc_sec->contents,
13570 0, rtproc_sec->size))
13578 /* Structure for saying that BFD machine EXTENSION extends BASE. */
13580 struct mips_mach_extension {
13581 unsigned long extension, base;
13585 /* An array describing how BFD machines relate to one another. The entries
13586 are ordered topologically with MIPS I extensions listed last. */
13588 static const struct mips_mach_extension mips_mach_extensions[] = {
13589 /* MIPS64r2 extensions. */
13590 { bfd_mach_mips_octeon2, bfd_mach_mips_octeonp },
13591 { bfd_mach_mips_octeonp, bfd_mach_mips_octeon },
13592 { bfd_mach_mips_octeon, bfd_mach_mipsisa64r2 },
13594 /* MIPS64 extensions. */
13595 { bfd_mach_mipsisa64r2, bfd_mach_mipsisa64 },
13596 { bfd_mach_mips_sb1, bfd_mach_mipsisa64 },
13597 { bfd_mach_mips_xlr, bfd_mach_mipsisa64 },
13598 { bfd_mach_mips_loongson_3a, bfd_mach_mipsisa64 },
13600 /* MIPS V extensions. */
13601 { bfd_mach_mipsisa64, bfd_mach_mips5 },
13603 /* R10000 extensions. */
13604 { bfd_mach_mips12000, bfd_mach_mips10000 },
13605 { bfd_mach_mips14000, bfd_mach_mips10000 },
13606 { bfd_mach_mips16000, bfd_mach_mips10000 },
13608 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
13609 vr5400 ISA, but doesn't include the multimedia stuff. It seems
13610 better to allow vr5400 and vr5500 code to be merged anyway, since
13611 many libraries will just use the core ISA. Perhaps we could add
13612 some sort of ASE flag if this ever proves a problem. */
13613 { bfd_mach_mips5500, bfd_mach_mips5400 },
13614 { bfd_mach_mips5400, bfd_mach_mips5000 },
13616 /* MIPS IV extensions. */
13617 { bfd_mach_mips5, bfd_mach_mips8000 },
13618 { bfd_mach_mips10000, bfd_mach_mips8000 },
13619 { bfd_mach_mips5000, bfd_mach_mips8000 },
13620 { bfd_mach_mips7000, bfd_mach_mips8000 },
13621 { bfd_mach_mips9000, bfd_mach_mips8000 },
13623 /* VR4100 extensions. */
13624 { bfd_mach_mips4120, bfd_mach_mips4100 },
13625 { bfd_mach_mips4111, bfd_mach_mips4100 },
13627 /* MIPS III extensions. */
13628 { bfd_mach_mips_loongson_2e, bfd_mach_mips4000 },
13629 { bfd_mach_mips_loongson_2f, bfd_mach_mips4000 },
13630 { bfd_mach_mips8000, bfd_mach_mips4000 },
13631 { bfd_mach_mips4650, bfd_mach_mips4000 },
13632 { bfd_mach_mips4600, bfd_mach_mips4000 },
13633 { bfd_mach_mips4400, bfd_mach_mips4000 },
13634 { bfd_mach_mips4300, bfd_mach_mips4000 },
13635 { bfd_mach_mips4100, bfd_mach_mips4000 },
13636 { bfd_mach_mips4010, bfd_mach_mips4000 },
13637 { bfd_mach_mips5900, bfd_mach_mips4000 },
13639 /* MIPS32 extensions. */
13640 { bfd_mach_mipsisa32r2, bfd_mach_mipsisa32 },
13642 /* MIPS II extensions. */
13643 { bfd_mach_mips4000, bfd_mach_mips6000 },
13644 { bfd_mach_mipsisa32, bfd_mach_mips6000 },
13646 /* MIPS I extensions. */
13647 { bfd_mach_mips6000, bfd_mach_mips3000 },
13648 { bfd_mach_mips3900, bfd_mach_mips3000 }
13652 /* Return true if bfd machine EXTENSION is an extension of machine BASE. */
13655 mips_mach_extends_p (unsigned long base, unsigned long extension)
13659 if (extension == base)
13662 if (base == bfd_mach_mipsisa32
13663 && mips_mach_extends_p (bfd_mach_mipsisa64, extension))
13666 if (base == bfd_mach_mipsisa32r2
13667 && mips_mach_extends_p (bfd_mach_mipsisa64r2, extension))
13670 for (i = 0; i < ARRAY_SIZE (mips_mach_extensions); i++)
13671 if (extension == mips_mach_extensions[i].extension)
13673 extension = mips_mach_extensions[i].base;
13674 if (extension == base)
13682 /* Return true if the given ELF header flags describe a 32-bit binary. */
13685 mips_32bit_flags_p (flagword flags)
13687 return ((flags & EF_MIPS_32BITMODE) != 0
13688 || (flags & EF_MIPS_ABI) == E_MIPS_ABI_O32
13689 || (flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32
13690 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1
13691 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2
13692 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32
13693 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2);
13697 /* Merge object attributes from IBFD into OBFD. Raise an error if
13698 there are conflicting attributes. */
13700 mips_elf_merge_obj_attributes (bfd *ibfd, bfd *obfd)
13702 obj_attribute *in_attr;
13703 obj_attribute *out_attr;
13706 abi_fp_bfd = mips_elf_tdata (obfd)->abi_fp_bfd;
13707 in_attr = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
13708 if (!abi_fp_bfd && in_attr[Tag_GNU_MIPS_ABI_FP].i != 0)
13709 mips_elf_tdata (obfd)->abi_fp_bfd = ibfd;
13711 if (!elf_known_obj_attributes_proc (obfd)[0].i)
13713 /* This is the first object. Copy the attributes. */
13714 _bfd_elf_copy_obj_attributes (ibfd, obfd);
13716 /* Use the Tag_null value to indicate the attributes have been
13718 elf_known_obj_attributes_proc (obfd)[0].i = 1;
13723 /* Check for conflicting Tag_GNU_MIPS_ABI_FP attributes and merge
13724 non-conflicting ones. */
13725 out_attr = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
13726 if (in_attr[Tag_GNU_MIPS_ABI_FP].i != out_attr[Tag_GNU_MIPS_ABI_FP].i)
13728 out_attr[Tag_GNU_MIPS_ABI_FP].type = 1;
13729 if (out_attr[Tag_GNU_MIPS_ABI_FP].i == 0)
13730 out_attr[Tag_GNU_MIPS_ABI_FP].i = in_attr[Tag_GNU_MIPS_ABI_FP].i;
13731 else if (in_attr[Tag_GNU_MIPS_ABI_FP].i != 0)
13732 switch (out_attr[Tag_GNU_MIPS_ABI_FP].i)
13735 switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
13739 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13740 obfd, abi_fp_bfd, ibfd, "-mdouble-float", "-msingle-float");
13745 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13746 obfd, abi_fp_bfd, ibfd, "-mhard-float", "-msoft-float");
13751 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13752 obfd, abi_fp_bfd, ibfd,
13753 "-mdouble-float", "-mips32r2 -mfp64");
13758 (_("Warning: %B uses %s (set by %B), "
13759 "%B uses unknown floating point ABI %d"),
13760 obfd, abi_fp_bfd, ibfd,
13761 "-mdouble-float", in_attr[Tag_GNU_MIPS_ABI_FP].i);
13767 switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
13771 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13772 obfd, abi_fp_bfd, ibfd, "-msingle-float", "-mdouble-float");
13777 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13778 obfd, abi_fp_bfd, ibfd, "-mhard-float", "-msoft-float");
13783 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13784 obfd, abi_fp_bfd, ibfd,
13785 "-msingle-float", "-mips32r2 -mfp64");
13790 (_("Warning: %B uses %s (set by %B), "
13791 "%B uses unknown floating point ABI %d"),
13792 obfd, abi_fp_bfd, ibfd,
13793 "-msingle-float", in_attr[Tag_GNU_MIPS_ABI_FP].i);
13799 switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
13805 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13806 obfd, abi_fp_bfd, ibfd, "-msoft-float", "-mhard-float");
13811 (_("Warning: %B uses %s (set by %B), "
13812 "%B uses unknown floating point ABI %d"),
13813 obfd, abi_fp_bfd, ibfd,
13814 "-msoft-float", in_attr[Tag_GNU_MIPS_ABI_FP].i);
13820 switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
13824 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13825 obfd, abi_fp_bfd, ibfd,
13826 "-mips32r2 -mfp64", "-mdouble-float");
13831 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13832 obfd, abi_fp_bfd, ibfd,
13833 "-mips32r2 -mfp64", "-msingle-float");
13838 (_("Warning: %B uses %s (set by %B), %B uses %s"),
13839 obfd, abi_fp_bfd, ibfd, "-mhard-float", "-msoft-float");
13844 (_("Warning: %B uses %s (set by %B), "
13845 "%B uses unknown floating point ABI %d"),
13846 obfd, abi_fp_bfd, ibfd,
13847 "-mips32r2 -mfp64", in_attr[Tag_GNU_MIPS_ABI_FP].i);
13853 switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
13857 (_("Warning: %B uses unknown floating point ABI %d "
13858 "(set by %B), %B uses %s"),
13859 obfd, abi_fp_bfd, ibfd,
13860 out_attr[Tag_GNU_MIPS_ABI_FP].i, "-mdouble-float");
13865 (_("Warning: %B uses unknown floating point ABI %d "
13866 "(set by %B), %B uses %s"),
13867 obfd, abi_fp_bfd, ibfd,
13868 out_attr[Tag_GNU_MIPS_ABI_FP].i, "-msingle-float");
13873 (_("Warning: %B uses unknown floating point ABI %d "
13874 "(set by %B), %B uses %s"),
13875 obfd, abi_fp_bfd, ibfd,
13876 out_attr[Tag_GNU_MIPS_ABI_FP].i, "-msoft-float");
13881 (_("Warning: %B uses unknown floating point ABI %d "
13882 "(set by %B), %B uses %s"),
13883 obfd, abi_fp_bfd, ibfd,
13884 out_attr[Tag_GNU_MIPS_ABI_FP].i, "-mips32r2 -mfp64");
13889 (_("Warning: %B uses unknown floating point ABI %d "
13890 "(set by %B), %B uses unknown floating point ABI %d"),
13891 obfd, abi_fp_bfd, ibfd,
13892 out_attr[Tag_GNU_MIPS_ABI_FP].i,
13893 in_attr[Tag_GNU_MIPS_ABI_FP].i);
13900 /* Merge Tag_compatibility attributes and any common GNU ones. */
13901 _bfd_elf_merge_object_attributes (ibfd, obfd);
13906 /* Merge backend specific data from an object file to the output
13907 object file when linking. */
13910 _bfd_mips_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
13912 flagword old_flags;
13913 flagword new_flags;
13915 bfd_boolean null_input_bfd = TRUE;
13918 /* Check if we have the same endianness. */
13919 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
13921 (*_bfd_error_handler)
13922 (_("%B: endianness incompatible with that of the selected emulation"),
13927 if (!is_mips_elf (ibfd) || !is_mips_elf (obfd))
13930 if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
13932 (*_bfd_error_handler)
13933 (_("%B: ABI is incompatible with that of the selected emulation"),
13938 if (!mips_elf_merge_obj_attributes (ibfd, obfd))
13941 new_flags = elf_elfheader (ibfd)->e_flags;
13942 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_NOREORDER;
13943 old_flags = elf_elfheader (obfd)->e_flags;
13945 if (! elf_flags_init (obfd))
13947 elf_flags_init (obfd) = TRUE;
13948 elf_elfheader (obfd)->e_flags = new_flags;
13949 elf_elfheader (obfd)->e_ident[EI_CLASS]
13950 = elf_elfheader (ibfd)->e_ident[EI_CLASS];
13952 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
13953 && (bfd_get_arch_info (obfd)->the_default
13954 || mips_mach_extends_p (bfd_get_mach (obfd),
13955 bfd_get_mach (ibfd))))
13957 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
13958 bfd_get_mach (ibfd)))
13965 /* Check flag compatibility. */
13967 new_flags &= ~EF_MIPS_NOREORDER;
13968 old_flags &= ~EF_MIPS_NOREORDER;
13970 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
13971 doesn't seem to matter. */
13972 new_flags &= ~EF_MIPS_XGOT;
13973 old_flags &= ~EF_MIPS_XGOT;
13975 /* MIPSpro generates ucode info in n64 objects. Again, we should
13976 just be able to ignore this. */
13977 new_flags &= ~EF_MIPS_UCODE;
13978 old_flags &= ~EF_MIPS_UCODE;
13980 /* DSOs should only be linked with CPIC code. */
13981 if ((ibfd->flags & DYNAMIC) != 0)
13982 new_flags |= EF_MIPS_PIC | EF_MIPS_CPIC;
13984 if (new_flags == old_flags)
13987 /* Check to see if the input BFD actually contains any sections.
13988 If not, its flags may not have been initialised either, but it cannot
13989 actually cause any incompatibility. */
13990 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
13992 /* Ignore synthetic sections and empty .text, .data and .bss sections
13993 which are automatically generated by gas. Also ignore fake
13994 (s)common sections, since merely defining a common symbol does
13995 not affect compatibility. */
13996 if ((sec->flags & SEC_IS_COMMON) == 0
13997 && strcmp (sec->name, ".reginfo")
13998 && strcmp (sec->name, ".mdebug")
14000 || (strcmp (sec->name, ".text")
14001 && strcmp (sec->name, ".data")
14002 && strcmp (sec->name, ".bss"))))
14004 null_input_bfd = FALSE;
14008 if (null_input_bfd)
14013 if (((new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0)
14014 != ((old_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0))
14016 (*_bfd_error_handler)
14017 (_("%B: warning: linking abicalls files with non-abicalls files"),
14022 if (new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC))
14023 elf_elfheader (obfd)->e_flags |= EF_MIPS_CPIC;
14024 if (! (new_flags & EF_MIPS_PIC))
14025 elf_elfheader (obfd)->e_flags &= ~EF_MIPS_PIC;
14027 new_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
14028 old_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
14030 /* Compare the ISAs. */
14031 if (mips_32bit_flags_p (old_flags) != mips_32bit_flags_p (new_flags))
14033 (*_bfd_error_handler)
14034 (_("%B: linking 32-bit code with 64-bit code"),
14038 else if (!mips_mach_extends_p (bfd_get_mach (ibfd), bfd_get_mach (obfd)))
14040 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
14041 if (mips_mach_extends_p (bfd_get_mach (obfd), bfd_get_mach (ibfd)))
14043 /* Copy the architecture info from IBFD to OBFD. Also copy
14044 the 32-bit flag (if set) so that we continue to recognise
14045 OBFD as a 32-bit binary. */
14046 bfd_set_arch_info (obfd, bfd_get_arch_info (ibfd));
14047 elf_elfheader (obfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
14048 elf_elfheader (obfd)->e_flags
14049 |= new_flags & (EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
14051 /* Copy across the ABI flags if OBFD doesn't use them
14052 and if that was what caused us to treat IBFD as 32-bit. */
14053 if ((old_flags & EF_MIPS_ABI) == 0
14054 && mips_32bit_flags_p (new_flags)
14055 && !mips_32bit_flags_p (new_flags & ~EF_MIPS_ABI))
14056 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ABI;
14060 /* The ISAs aren't compatible. */
14061 (*_bfd_error_handler)
14062 (_("%B: linking %s module with previous %s modules"),
14064 bfd_printable_name (ibfd),
14065 bfd_printable_name (obfd));
14070 new_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
14071 old_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
14073 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
14074 does set EI_CLASS differently from any 32-bit ABI. */
14075 if ((new_flags & EF_MIPS_ABI) != (old_flags & EF_MIPS_ABI)
14076 || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
14077 != elf_elfheader (obfd)->e_ident[EI_CLASS]))
14079 /* Only error if both are set (to different values). */
14080 if (((new_flags & EF_MIPS_ABI) && (old_flags & EF_MIPS_ABI))
14081 || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
14082 != elf_elfheader (obfd)->e_ident[EI_CLASS]))
14084 (*_bfd_error_handler)
14085 (_("%B: ABI mismatch: linking %s module with previous %s modules"),
14087 elf_mips_abi_name (ibfd),
14088 elf_mips_abi_name (obfd));
14091 new_flags &= ~EF_MIPS_ABI;
14092 old_flags &= ~EF_MIPS_ABI;
14095 /* Compare ASEs. Forbid linking MIPS16 and microMIPS ASE modules together
14096 and allow arbitrary mixing of the remaining ASEs (retain the union). */
14097 if ((new_flags & EF_MIPS_ARCH_ASE) != (old_flags & EF_MIPS_ARCH_ASE))
14099 int old_micro = old_flags & EF_MIPS_ARCH_ASE_MICROMIPS;
14100 int new_micro = new_flags & EF_MIPS_ARCH_ASE_MICROMIPS;
14101 int old_m16 = old_flags & EF_MIPS_ARCH_ASE_M16;
14102 int new_m16 = new_flags & EF_MIPS_ARCH_ASE_M16;
14103 int micro_mis = old_m16 && new_micro;
14104 int m16_mis = old_micro && new_m16;
14106 if (m16_mis || micro_mis)
14108 (*_bfd_error_handler)
14109 (_("%B: ASE mismatch: linking %s module with previous %s modules"),
14111 m16_mis ? "MIPS16" : "microMIPS",
14112 m16_mis ? "microMIPS" : "MIPS16");
14116 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ARCH_ASE;
14118 new_flags &= ~ EF_MIPS_ARCH_ASE;
14119 old_flags &= ~ EF_MIPS_ARCH_ASE;
14122 /* Warn about any other mismatches */
14123 if (new_flags != old_flags)
14125 (*_bfd_error_handler)
14126 (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
14127 ibfd, (unsigned long) new_flags,
14128 (unsigned long) old_flags);
14134 bfd_set_error (bfd_error_bad_value);
14141 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
14144 _bfd_mips_elf_set_private_flags (bfd *abfd, flagword flags)
14146 BFD_ASSERT (!elf_flags_init (abfd)
14147 || elf_elfheader (abfd)->e_flags == flags);
14149 elf_elfheader (abfd)->e_flags = flags;
14150 elf_flags_init (abfd) = TRUE;
14155 _bfd_mips_elf_get_target_dtag (bfd_vma dtag)
14159 default: return "";
14160 case DT_MIPS_RLD_VERSION:
14161 return "MIPS_RLD_VERSION";
14162 case DT_MIPS_TIME_STAMP:
14163 return "MIPS_TIME_STAMP";
14164 case DT_MIPS_ICHECKSUM:
14165 return "MIPS_ICHECKSUM";
14166 case DT_MIPS_IVERSION:
14167 return "MIPS_IVERSION";
14168 case DT_MIPS_FLAGS:
14169 return "MIPS_FLAGS";
14170 case DT_MIPS_BASE_ADDRESS:
14171 return "MIPS_BASE_ADDRESS";
14173 return "MIPS_MSYM";
14174 case DT_MIPS_CONFLICT:
14175 return "MIPS_CONFLICT";
14176 case DT_MIPS_LIBLIST:
14177 return "MIPS_LIBLIST";
14178 case DT_MIPS_LOCAL_GOTNO:
14179 return "MIPS_LOCAL_GOTNO";
14180 case DT_MIPS_CONFLICTNO:
14181 return "MIPS_CONFLICTNO";
14182 case DT_MIPS_LIBLISTNO:
14183 return "MIPS_LIBLISTNO";
14184 case DT_MIPS_SYMTABNO:
14185 return "MIPS_SYMTABNO";
14186 case DT_MIPS_UNREFEXTNO:
14187 return "MIPS_UNREFEXTNO";
14188 case DT_MIPS_GOTSYM:
14189 return "MIPS_GOTSYM";
14190 case DT_MIPS_HIPAGENO:
14191 return "MIPS_HIPAGENO";
14192 case DT_MIPS_RLD_MAP:
14193 return "MIPS_RLD_MAP";
14194 case DT_MIPS_DELTA_CLASS:
14195 return "MIPS_DELTA_CLASS";
14196 case DT_MIPS_DELTA_CLASS_NO:
14197 return "MIPS_DELTA_CLASS_NO";
14198 case DT_MIPS_DELTA_INSTANCE:
14199 return "MIPS_DELTA_INSTANCE";
14200 case DT_MIPS_DELTA_INSTANCE_NO:
14201 return "MIPS_DELTA_INSTANCE_NO";
14202 case DT_MIPS_DELTA_RELOC:
14203 return "MIPS_DELTA_RELOC";
14204 case DT_MIPS_DELTA_RELOC_NO:
14205 return "MIPS_DELTA_RELOC_NO";
14206 case DT_MIPS_DELTA_SYM:
14207 return "MIPS_DELTA_SYM";
14208 case DT_MIPS_DELTA_SYM_NO:
14209 return "MIPS_DELTA_SYM_NO";
14210 case DT_MIPS_DELTA_CLASSSYM:
14211 return "MIPS_DELTA_CLASSSYM";
14212 case DT_MIPS_DELTA_CLASSSYM_NO:
14213 return "MIPS_DELTA_CLASSSYM_NO";
14214 case DT_MIPS_CXX_FLAGS:
14215 return "MIPS_CXX_FLAGS";
14216 case DT_MIPS_PIXIE_INIT:
14217 return "MIPS_PIXIE_INIT";
14218 case DT_MIPS_SYMBOL_LIB:
14219 return "MIPS_SYMBOL_LIB";
14220 case DT_MIPS_LOCALPAGE_GOTIDX:
14221 return "MIPS_LOCALPAGE_GOTIDX";
14222 case DT_MIPS_LOCAL_GOTIDX:
14223 return "MIPS_LOCAL_GOTIDX";
14224 case DT_MIPS_HIDDEN_GOTIDX:
14225 return "MIPS_HIDDEN_GOTIDX";
14226 case DT_MIPS_PROTECTED_GOTIDX:
14227 return "MIPS_PROTECTED_GOT_IDX";
14228 case DT_MIPS_OPTIONS:
14229 return "MIPS_OPTIONS";
14230 case DT_MIPS_INTERFACE:
14231 return "MIPS_INTERFACE";
14232 case DT_MIPS_DYNSTR_ALIGN:
14233 return "DT_MIPS_DYNSTR_ALIGN";
14234 case DT_MIPS_INTERFACE_SIZE:
14235 return "DT_MIPS_INTERFACE_SIZE";
14236 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR:
14237 return "DT_MIPS_RLD_TEXT_RESOLVE_ADDR";
14238 case DT_MIPS_PERF_SUFFIX:
14239 return "DT_MIPS_PERF_SUFFIX";
14240 case DT_MIPS_COMPACT_SIZE:
14241 return "DT_MIPS_COMPACT_SIZE";
14242 case DT_MIPS_GP_VALUE:
14243 return "DT_MIPS_GP_VALUE";
14244 case DT_MIPS_AUX_DYNAMIC:
14245 return "DT_MIPS_AUX_DYNAMIC";
14246 case DT_MIPS_PLTGOT:
14247 return "DT_MIPS_PLTGOT";
14248 case DT_MIPS_RWPLT:
14249 return "DT_MIPS_RWPLT";
14254 _bfd_mips_elf_print_private_bfd_data (bfd *abfd, void *ptr)
14258 BFD_ASSERT (abfd != NULL && ptr != NULL);
14260 /* Print normal ELF private data. */
14261 _bfd_elf_print_private_bfd_data (abfd, ptr);
14263 /* xgettext:c-format */
14264 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
14266 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32)
14267 fprintf (file, _(" [abi=O32]"));
14268 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O64)
14269 fprintf (file, _(" [abi=O64]"));
14270 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32)
14271 fprintf (file, _(" [abi=EABI32]"));
14272 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
14273 fprintf (file, _(" [abi=EABI64]"));
14274 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI))
14275 fprintf (file, _(" [abi unknown]"));
14276 else if (ABI_N32_P (abfd))
14277 fprintf (file, _(" [abi=N32]"));
14278 else if (ABI_64_P (abfd))
14279 fprintf (file, _(" [abi=64]"));
14281 fprintf (file, _(" [no abi set]"));
14283 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
14284 fprintf (file, " [mips1]");
14285 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
14286 fprintf (file, " [mips2]");
14287 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
14288 fprintf (file, " [mips3]");
14289 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
14290 fprintf (file, " [mips4]");
14291 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5)
14292 fprintf (file, " [mips5]");
14293 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32)
14294 fprintf (file, " [mips32]");
14295 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64)
14296 fprintf (file, " [mips64]");
14297 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2)
14298 fprintf (file, " [mips32r2]");
14299 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R2)
14300 fprintf (file, " [mips64r2]");
14302 fprintf (file, _(" [unknown ISA]"));
14304 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MDMX)
14305 fprintf (file, " [mdmx]");
14307 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_M16)
14308 fprintf (file, " [mips16]");
14310 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
14311 fprintf (file, " [micromips]");
14313 if (elf_elfheader (abfd)->e_flags & EF_MIPS_32BITMODE)
14314 fprintf (file, " [32bitmode]");
14316 fprintf (file, _(" [not 32bitmode]"));
14318 if (elf_elfheader (abfd)->e_flags & EF_MIPS_NOREORDER)
14319 fprintf (file, " [noreorder]");
14321 if (elf_elfheader (abfd)->e_flags & EF_MIPS_PIC)
14322 fprintf (file, " [PIC]");
14324 if (elf_elfheader (abfd)->e_flags & EF_MIPS_CPIC)
14325 fprintf (file, " [CPIC]");
14327 if (elf_elfheader (abfd)->e_flags & EF_MIPS_XGOT)
14328 fprintf (file, " [XGOT]");
14330 if (elf_elfheader (abfd)->e_flags & EF_MIPS_UCODE)
14331 fprintf (file, " [UCODE]");
14333 fputc ('\n', file);
14338 const struct bfd_elf_special_section _bfd_mips_elf_special_sections[] =
14340 { STRING_COMMA_LEN (".lit4"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
14341 { STRING_COMMA_LEN (".lit8"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
14342 { STRING_COMMA_LEN (".mdebug"), 0, SHT_MIPS_DEBUG, 0 },
14343 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
14344 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
14345 { STRING_COMMA_LEN (".ucode"), 0, SHT_MIPS_UCODE, 0 },
14346 { NULL, 0, 0, 0, 0 }
14349 /* Merge non visibility st_other attributes. Ensure that the
14350 STO_OPTIONAL flag is copied into h->other, even if this is not a
14351 definiton of the symbol. */
14353 _bfd_mips_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
14354 const Elf_Internal_Sym *isym,
14355 bfd_boolean definition,
14356 bfd_boolean dynamic ATTRIBUTE_UNUSED)
14358 if ((isym->st_other & ~ELF_ST_VISIBILITY (-1)) != 0)
14360 unsigned char other;
14362 other = (definition ? isym->st_other : h->other);
14363 other &= ~ELF_ST_VISIBILITY (-1);
14364 h->other = other | ELF_ST_VISIBILITY (h->other);
14368 && ELF_MIPS_IS_OPTIONAL (isym->st_other))
14369 h->other |= STO_OPTIONAL;
14372 /* Decide whether an undefined symbol is special and can be ignored.
14373 This is the case for OPTIONAL symbols on IRIX. */
14375 _bfd_mips_elf_ignore_undef_symbol (struct elf_link_hash_entry *h)
14377 return ELF_MIPS_IS_OPTIONAL (h->other) ? TRUE : FALSE;
14381 _bfd_mips_elf_common_definition (Elf_Internal_Sym *sym)
14383 return (sym->st_shndx == SHN_COMMON
14384 || sym->st_shndx == SHN_MIPS_ACOMMON
14385 || sym->st_shndx == SHN_MIPS_SCOMMON);
14388 /* Return address for Ith PLT stub in section PLT, for relocation REL
14389 or (bfd_vma) -1 if it should not be included. */
14392 _bfd_mips_elf_plt_sym_val (bfd_vma i, const asection *plt,
14393 const arelent *rel ATTRIBUTE_UNUSED)
14396 + 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry)
14397 + i * 4 * ARRAY_SIZE (mips_exec_plt_entry));
14401 _bfd_mips_post_process_headers (bfd *abfd, struct bfd_link_info *link_info)
14403 struct mips_elf_link_hash_table *htab;
14404 Elf_Internal_Ehdr *i_ehdrp;
14406 i_ehdrp = elf_elfheader (abfd);
14409 htab = mips_elf_hash_table (link_info);
14410 BFD_ASSERT (htab != NULL);
14412 if (htab->use_plts_and_copy_relocs && !htab->is_vxworks)
14413 i_ehdrp->e_ident[EI_ABIVERSION] = 1;