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
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 global symbol in the GOT with the lowest index in the dynamic
147 struct elf_link_hash_entry *global_gotsym;
148 /* The number of global .got entries. */
149 unsigned int global_gotno;
150 /* The number of global .got entries that are in the GGA_RELOC_ONLY area. */
151 unsigned int reloc_only_gotno;
152 /* The number of .got slots used for TLS. */
153 unsigned int tls_gotno;
154 /* The first unused TLS .got entry. Used only during
155 mips_elf_initialize_tls_index. */
156 unsigned int tls_assigned_gotno;
157 /* The number of local .got entries, eventually including page entries. */
158 unsigned int local_gotno;
159 /* The maximum number of page entries needed. */
160 unsigned int page_gotno;
161 /* The number of local .got entries we have used. */
162 unsigned int assigned_gotno;
163 /* A hash table holding members of the got. */
164 struct htab *got_entries;
165 /* A hash table of mips_got_page_entry structures. */
166 struct htab *got_page_entries;
167 /* A hash table mapping input bfds to other mips_got_info. NULL
168 unless multi-got was necessary. */
169 struct htab *bfd2got;
170 /* In multi-got links, a pointer to the next got (err, rather, most
171 of the time, it points to the previous got). */
172 struct mips_got_info *next;
173 /* This is the GOT index of the TLS LDM entry for the GOT, MINUS_ONE
174 for none, or MINUS_TWO for not yet assigned. This is needed
175 because a single-GOT link may have multiple hash table entries
176 for the LDM. It does not get initialized in multi-GOT mode. */
177 bfd_vma tls_ldm_offset;
180 /* Map an input bfd to a got in a multi-got link. */
182 struct mips_elf_bfd2got_hash
185 struct mips_got_info *g;
188 /* Structure passed when traversing the bfd2got hash table, used to
189 create and merge bfd's gots. */
191 struct mips_elf_got_per_bfd_arg
193 /* A hashtable that maps bfds to gots. */
195 /* The output bfd. */
197 /* The link information. */
198 struct bfd_link_info *info;
199 /* A pointer to the primary got, i.e., the one that's going to get
200 the implicit relocations from DT_MIPS_LOCAL_GOTNO and
202 struct mips_got_info *primary;
203 /* A non-primary got we're trying to merge with other input bfd's
205 struct mips_got_info *current;
206 /* The maximum number of got entries that can be addressed with a
208 unsigned int max_count;
209 /* The maximum number of page entries needed by each got. */
210 unsigned int max_pages;
211 /* The total number of global entries which will live in the
212 primary got and be automatically relocated. This includes
213 those not referenced by the primary GOT but included in
215 unsigned int global_count;
218 /* Another structure used to pass arguments for got entries traversal. */
220 struct mips_elf_set_global_got_offset_arg
222 struct mips_got_info *g;
224 unsigned int needed_relocs;
225 struct bfd_link_info *info;
228 /* A structure used to count TLS relocations or GOT entries, for GOT
229 entry or ELF symbol table traversal. */
231 struct mips_elf_count_tls_arg
233 struct bfd_link_info *info;
237 struct _mips_elf_section_data
239 struct bfd_elf_section_data elf;
246 #define mips_elf_section_data(sec) \
247 ((struct _mips_elf_section_data *) elf_section_data (sec))
249 #define is_mips_elf(bfd) \
250 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
251 && elf_tdata (bfd) != NULL \
252 && elf_object_id (bfd) == MIPS_ELF_DATA)
254 /* The ABI says that every symbol used by dynamic relocations must have
255 a global GOT entry. Among other things, this provides the dynamic
256 linker with a free, directly-indexed cache. The GOT can therefore
257 contain symbols that are not referenced by GOT relocations themselves
258 (in other words, it may have symbols that are not referenced by things
259 like R_MIPS_GOT16 and R_MIPS_GOT_PAGE).
261 GOT relocations are less likely to overflow if we put the associated
262 GOT entries towards the beginning. We therefore divide the global
263 GOT entries into two areas: "normal" and "reloc-only". Entries in
264 the first area can be used for both dynamic relocations and GP-relative
265 accesses, while those in the "reloc-only" area are for dynamic
268 These GGA_* ("Global GOT Area") values are organised so that lower
269 values are more general than higher values. Also, non-GGA_NONE
270 values are ordered by the position of the area in the GOT. */
272 #define GGA_RELOC_ONLY 1
275 /* Information about a non-PIC interface to a PIC function. There are
276 two ways of creating these interfaces. The first is to add:
279 addiu $25,$25,%lo(func)
281 immediately before a PIC function "func". The second is to add:
285 addiu $25,$25,%lo(func)
287 to a separate trampoline section.
289 Stubs of the first kind go in a new section immediately before the
290 target function. Stubs of the second kind go in a single section
291 pointed to by the hash table's "strampoline" field. */
292 struct mips_elf_la25_stub {
293 /* The generated section that contains this stub. */
294 asection *stub_section;
296 /* The offset of the stub from the start of STUB_SECTION. */
299 /* One symbol for the original function. Its location is available
300 in H->root.root.u.def. */
301 struct mips_elf_link_hash_entry *h;
304 /* Macros for populating a mips_elf_la25_stub. */
306 #define LA25_LUI(VAL) (0x3c190000 | (VAL)) /* lui t9,VAL */
307 #define LA25_J(VAL) (0x08000000 | (((VAL) >> 2) & 0x3ffffff)) /* j VAL */
308 #define LA25_ADDIU(VAL) (0x27390000 | (VAL)) /* addiu t9,t9,VAL */
309 #define LA25_LUI_MICROMIPS(VAL) \
310 (0x41b90000 | (VAL)) /* lui t9,VAL */
311 #define LA25_J_MICROMIPS(VAL) \
312 (0xd4000000 | (((VAL) >> 1) & 0x3ffffff)) /* j VAL */
313 #define LA25_ADDIU_MICROMIPS(VAL) \
314 (0x33390000 | (VAL)) /* addiu t9,t9,VAL */
316 /* This structure is passed to mips_elf_sort_hash_table_f when sorting
317 the dynamic symbols. */
319 struct mips_elf_hash_sort_data
321 /* The symbol in the global GOT with the lowest dynamic symbol table
323 struct elf_link_hash_entry *low;
324 /* The least dynamic symbol table index corresponding to a non-TLS
325 symbol with a GOT entry. */
326 long min_got_dynindx;
327 /* The greatest dynamic symbol table index corresponding to a symbol
328 with a GOT entry that is not referenced (e.g., a dynamic symbol
329 with dynamic relocations pointing to it from non-primary GOTs). */
330 long max_unref_got_dynindx;
331 /* The greatest dynamic symbol table index not corresponding to a
332 symbol without a GOT entry. */
333 long max_non_got_dynindx;
336 /* The MIPS ELF linker needs additional information for each symbol in
337 the global hash table. */
339 struct mips_elf_link_hash_entry
341 struct elf_link_hash_entry root;
343 /* External symbol information. */
346 /* The la25 stub we have created for ths symbol, if any. */
347 struct mips_elf_la25_stub *la25_stub;
349 /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
351 unsigned int possibly_dynamic_relocs;
353 /* If there is a stub that 32 bit functions should use to call this
354 16 bit function, this points to the section containing the stub. */
357 /* If there is a stub that 16 bit functions should use to call this
358 32 bit function, this points to the section containing the stub. */
361 /* This is like the call_stub field, but it is used if the function
362 being called returns a floating point value. */
363 asection *call_fp_stub;
367 #define GOT_TLS_LDM 2
369 #define GOT_TLS_OFFSET_DONE 0x40
370 #define GOT_TLS_DONE 0x80
371 unsigned char tls_type;
373 /* This is only used in single-GOT mode; in multi-GOT mode there
374 is one mips_got_entry per GOT entry, so the offset is stored
375 there. In single-GOT mode there may be many mips_got_entry
376 structures all referring to the same GOT slot. It might be
377 possible to use root.got.offset instead, but that field is
378 overloaded already. */
379 bfd_vma tls_got_offset;
381 /* The highest GGA_* value that satisfies all references to this symbol. */
382 unsigned int global_got_area : 2;
384 /* True if all GOT relocations against this symbol are for calls. This is
385 a looser condition than no_fn_stub below, because there may be other
386 non-call non-GOT relocations against the symbol. */
387 unsigned int got_only_for_calls : 1;
389 /* True if one of the relocations described by possibly_dynamic_relocs
390 is against a readonly section. */
391 unsigned int readonly_reloc : 1;
393 /* True if there is a relocation against this symbol that must be
394 resolved by the static linker (in other words, if the relocation
395 cannot possibly be made dynamic). */
396 unsigned int has_static_relocs : 1;
398 /* True if we must not create a .MIPS.stubs entry for this symbol.
399 This is set, for example, if there are relocations related to
400 taking the function's address, i.e. any but R_MIPS_CALL*16 ones.
401 See "MIPS ABI Supplement, 3rd Edition", p. 4-20. */
402 unsigned int no_fn_stub : 1;
404 /* Whether we need the fn_stub; this is true if this symbol appears
405 in any relocs other than a 16 bit call. */
406 unsigned int need_fn_stub : 1;
408 /* True if this symbol is referenced by branch relocations from
409 any non-PIC input file. This is used to determine whether an
410 la25 stub is required. */
411 unsigned int has_nonpic_branches : 1;
413 /* Does this symbol need a traditional MIPS lazy-binding stub
414 (as opposed to a PLT entry)? */
415 unsigned int needs_lazy_stub : 1;
418 /* MIPS ELF linker hash table. */
420 struct mips_elf_link_hash_table
422 struct elf_link_hash_table root;
424 /* We no longer use this. */
425 /* String section indices for the dynamic section symbols. */
426 bfd_size_type dynsym_sec_strindex[SIZEOF_MIPS_DYNSYM_SECNAMES];
429 /* The number of .rtproc entries. */
430 bfd_size_type procedure_count;
432 /* The size of the .compact_rel section (if SGI_COMPAT). */
433 bfd_size_type compact_rel_size;
435 /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic
436 entry is set to the address of __rld_obj_head as in IRIX5. */
437 bfd_boolean use_rld_obj_head;
439 /* The __rld_map or __rld_obj_head symbol. */
440 struct elf_link_hash_entry *rld_symbol;
442 /* This is set if we see any mips16 stub sections. */
443 bfd_boolean mips16_stubs_seen;
445 /* True if we can generate copy relocs and PLTs. */
446 bfd_boolean use_plts_and_copy_relocs;
448 /* True if we're generating code for VxWorks. */
449 bfd_boolean is_vxworks;
451 /* True if we already reported the small-data section overflow. */
452 bfd_boolean small_data_overflow_reported;
454 /* Shortcuts to some dynamic sections, or NULL if they are not
465 /* The master GOT information. */
466 struct mips_got_info *got_info;
468 /* The size of the PLT header in bytes. */
469 bfd_vma plt_header_size;
471 /* The size of a PLT entry in bytes. */
472 bfd_vma plt_entry_size;
474 /* The number of functions that need a lazy-binding stub. */
475 bfd_vma lazy_stub_count;
477 /* The size of a function stub entry in bytes. */
478 bfd_vma function_stub_size;
480 /* The number of reserved entries at the beginning of the GOT. */
481 unsigned int reserved_gotno;
483 /* The section used for mips_elf_la25_stub trampolines.
484 See the comment above that structure for details. */
485 asection *strampoline;
487 /* A table of mips_elf_la25_stubs, indexed by (input_section, offset)
491 /* A function FN (NAME, IS, OS) that creates a new input section
492 called NAME and links it to output section OS. If IS is nonnull,
493 the new section should go immediately before it, otherwise it
494 should go at the (current) beginning of OS.
496 The function returns the new section on success, otherwise it
498 asection *(*add_stub_section) (const char *, asection *, asection *);
501 /* Get the MIPS ELF linker hash table from a link_info structure. */
503 #define mips_elf_hash_table(p) \
504 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
505 == MIPS_ELF_DATA ? ((struct mips_elf_link_hash_table *) ((p)->hash)) : NULL)
507 /* A structure used to communicate with htab_traverse callbacks. */
508 struct mips_htab_traverse_info
510 /* The usual link-wide information. */
511 struct bfd_link_info *info;
514 /* Starts off FALSE and is set to TRUE if the link should be aborted. */
518 #define TLS_RELOC_P(r_type) \
519 (r_type == R_MIPS_TLS_DTPMOD32 \
520 || r_type == R_MIPS_TLS_DTPMOD64 \
521 || r_type == R_MIPS_TLS_DTPREL32 \
522 || r_type == R_MIPS_TLS_DTPREL64 \
523 || r_type == R_MIPS_TLS_GD \
524 || r_type == R_MIPS_TLS_LDM \
525 || r_type == R_MIPS_TLS_DTPREL_HI16 \
526 || r_type == R_MIPS_TLS_DTPREL_LO16 \
527 || r_type == R_MIPS_TLS_GOTTPREL \
528 || r_type == R_MIPS_TLS_TPREL32 \
529 || r_type == R_MIPS_TLS_TPREL64 \
530 || r_type == R_MIPS_TLS_TPREL_HI16 \
531 || r_type == R_MIPS_TLS_TPREL_LO16 \
532 || r_type == R_MIPS16_TLS_GD \
533 || r_type == R_MIPS16_TLS_LDM \
534 || r_type == R_MIPS16_TLS_DTPREL_HI16 \
535 || r_type == R_MIPS16_TLS_DTPREL_LO16 \
536 || r_type == R_MIPS16_TLS_GOTTPREL \
537 || r_type == R_MIPS16_TLS_TPREL_HI16 \
538 || r_type == R_MIPS16_TLS_TPREL_LO16 \
539 || r_type == R_MICROMIPS_TLS_GD \
540 || r_type == R_MICROMIPS_TLS_LDM \
541 || r_type == R_MICROMIPS_TLS_DTPREL_HI16 \
542 || r_type == R_MICROMIPS_TLS_DTPREL_LO16 \
543 || r_type == R_MICROMIPS_TLS_GOTTPREL \
544 || r_type == R_MICROMIPS_TLS_TPREL_HI16 \
545 || r_type == R_MICROMIPS_TLS_TPREL_LO16)
547 /* Structure used to pass information to mips_elf_output_extsym. */
552 struct bfd_link_info *info;
553 struct ecoff_debug_info *debug;
554 const struct ecoff_debug_swap *swap;
558 /* The names of the runtime procedure table symbols used on IRIX5. */
560 static const char * const mips_elf_dynsym_rtproc_names[] =
563 "_procedure_string_table",
564 "_procedure_table_size",
568 /* These structures are used to generate the .compact_rel section on
573 unsigned long id1; /* Always one? */
574 unsigned long num; /* Number of compact relocation entries. */
575 unsigned long id2; /* Always two? */
576 unsigned long offset; /* The file offset of the first relocation. */
577 unsigned long reserved0; /* Zero? */
578 unsigned long reserved1; /* Zero? */
587 bfd_byte reserved0[4];
588 bfd_byte reserved1[4];
589 } Elf32_External_compact_rel;
593 unsigned int ctype : 1; /* 1: long 0: short format. See below. */
594 unsigned int rtype : 4; /* Relocation types. See below. */
595 unsigned int dist2to : 8;
596 unsigned int relvaddr : 19; /* (VADDR - vaddr of the previous entry)/ 4 */
597 unsigned long konst; /* KONST field. See below. */
598 unsigned long vaddr; /* VADDR to be relocated. */
603 unsigned int ctype : 1; /* 1: long 0: short format. See below. */
604 unsigned int rtype : 4; /* Relocation types. See below. */
605 unsigned int dist2to : 8;
606 unsigned int relvaddr : 19; /* (VADDR - vaddr of the previous entry)/ 4 */
607 unsigned long konst; /* KONST field. See below. */
615 } Elf32_External_crinfo;
621 } Elf32_External_crinfo2;
623 /* These are the constants used to swap the bitfields in a crinfo. */
625 #define CRINFO_CTYPE (0x1)
626 #define CRINFO_CTYPE_SH (31)
627 #define CRINFO_RTYPE (0xf)
628 #define CRINFO_RTYPE_SH (27)
629 #define CRINFO_DIST2TO (0xff)
630 #define CRINFO_DIST2TO_SH (19)
631 #define CRINFO_RELVADDR (0x7ffff)
632 #define CRINFO_RELVADDR_SH (0)
634 /* A compact relocation info has long (3 words) or short (2 words)
635 formats. A short format doesn't have VADDR field and relvaddr
636 fields contains ((VADDR - vaddr of the previous entry) >> 2). */
637 #define CRF_MIPS_LONG 1
638 #define CRF_MIPS_SHORT 0
640 /* There are 4 types of compact relocation at least. The value KONST
641 has different meaning for each type:
644 CT_MIPS_REL32 Address in data
645 CT_MIPS_WORD Address in word (XXX)
646 CT_MIPS_GPHI_LO GP - vaddr
647 CT_MIPS_JMPAD Address to jump
650 #define CRT_MIPS_REL32 0xa
651 #define CRT_MIPS_WORD 0xb
652 #define CRT_MIPS_GPHI_LO 0xc
653 #define CRT_MIPS_JMPAD 0xd
655 #define mips_elf_set_cr_format(x,format) ((x).ctype = (format))
656 #define mips_elf_set_cr_type(x,type) ((x).rtype = (type))
657 #define mips_elf_set_cr_dist2to(x,v) ((x).dist2to = (v))
658 #define mips_elf_set_cr_relvaddr(x,d) ((x).relvaddr = (d)<<2)
660 /* The structure of the runtime procedure descriptor created by the
661 loader for use by the static exception system. */
663 typedef struct runtime_pdr {
664 bfd_vma adr; /* Memory address of start of procedure. */
665 long regmask; /* Save register mask. */
666 long regoffset; /* Save register offset. */
667 long fregmask; /* Save floating point register mask. */
668 long fregoffset; /* Save floating point register offset. */
669 long frameoffset; /* Frame size. */
670 short framereg; /* Frame pointer register. */
671 short pcreg; /* Offset or reg of return pc. */
672 long irpss; /* Index into the runtime string table. */
674 struct exception_info *exception_info;/* Pointer to exception array. */
676 #define cbRPDR sizeof (RPDR)
677 #define rpdNil ((pRPDR) 0)
679 static struct mips_got_entry *mips_elf_create_local_got_entry
680 (bfd *, struct bfd_link_info *, bfd *, bfd_vma, unsigned long,
681 struct mips_elf_link_hash_entry *, int);
682 static bfd_boolean mips_elf_sort_hash_table_f
683 (struct mips_elf_link_hash_entry *, void *);
684 static bfd_vma mips_elf_high
686 static bfd_boolean mips_elf_create_dynamic_relocation
687 (bfd *, struct bfd_link_info *, const Elf_Internal_Rela *,
688 struct mips_elf_link_hash_entry *, asection *, bfd_vma,
689 bfd_vma *, asection *);
690 static hashval_t mips_elf_got_entry_hash
692 static bfd_vma mips_elf_adjust_gp
693 (bfd *, struct mips_got_info *, bfd *);
694 static struct mips_got_info *mips_elf_got_for_ibfd
695 (struct mips_got_info *, bfd *);
697 /* This will be used when we sort the dynamic relocation records. */
698 static bfd *reldyn_sorting_bfd;
700 /* True if ABFD is for CPUs with load interlocking that include
701 non-MIPS1 CPUs and R3900. */
702 #define LOAD_INTERLOCKS_P(abfd) \
703 ( ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) != E_MIPS_ARCH_1) \
704 || ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == E_MIPS_MACH_3900))
706 /* True if ABFD is for CPUs that are faster if JAL is converted to BAL.
707 This should be safe for all architectures. We enable this predicate
708 for RM9000 for now. */
709 #define JAL_TO_BAL_P(abfd) \
710 ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == E_MIPS_MACH_9000)
712 /* True if ABFD is for CPUs that are faster if JALR is converted to BAL.
713 This should be safe for all architectures. We enable this predicate for
715 #define JALR_TO_BAL_P(abfd) 1
717 /* True if ABFD is for CPUs that are faster if JR is converted to B.
718 This should be safe for all architectures. We enable this predicate for
720 #define JR_TO_B_P(abfd) 1
722 /* True if ABFD is a PIC object. */
723 #define PIC_OBJECT_P(abfd) \
724 ((elf_elfheader (abfd)->e_flags & EF_MIPS_PIC) != 0)
726 /* Nonzero if ABFD is using the N32 ABI. */
727 #define ABI_N32_P(abfd) \
728 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
730 /* Nonzero if ABFD is using the N64 ABI. */
731 #define ABI_64_P(abfd) \
732 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
734 /* Nonzero if ABFD is using NewABI conventions. */
735 #define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
737 /* The IRIX compatibility level we are striving for. */
738 #define IRIX_COMPAT(abfd) \
739 (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
741 /* Whether we are trying to be compatible with IRIX at all. */
742 #define SGI_COMPAT(abfd) \
743 (IRIX_COMPAT (abfd) != ict_none)
745 /* The name of the options section. */
746 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
747 (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
749 /* True if NAME is the recognized name of any SHT_MIPS_OPTIONS section.
750 Some IRIX system files do not use MIPS_ELF_OPTIONS_SECTION_NAME. */
751 #define MIPS_ELF_OPTIONS_SECTION_NAME_P(NAME) \
752 (strcmp (NAME, ".MIPS.options") == 0 || strcmp (NAME, ".options") == 0)
754 /* Whether the section is readonly. */
755 #define MIPS_ELF_READONLY_SECTION(sec) \
756 ((sec->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY)) \
757 == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
759 /* The name of the stub section. */
760 #define MIPS_ELF_STUB_SECTION_NAME(abfd) ".MIPS.stubs"
762 /* The size of an external REL relocation. */
763 #define MIPS_ELF_REL_SIZE(abfd) \
764 (get_elf_backend_data (abfd)->s->sizeof_rel)
766 /* The size of an external RELA relocation. */
767 #define MIPS_ELF_RELA_SIZE(abfd) \
768 (get_elf_backend_data (abfd)->s->sizeof_rela)
770 /* The size of an external dynamic table entry. */
771 #define MIPS_ELF_DYN_SIZE(abfd) \
772 (get_elf_backend_data (abfd)->s->sizeof_dyn)
774 /* The size of a GOT entry. */
775 #define MIPS_ELF_GOT_SIZE(abfd) \
776 (get_elf_backend_data (abfd)->s->arch_size / 8)
778 /* The size of the .rld_map section. */
779 #define MIPS_ELF_RLD_MAP_SIZE(abfd) \
780 (get_elf_backend_data (abfd)->s->arch_size / 8)
782 /* The size of a symbol-table entry. */
783 #define MIPS_ELF_SYM_SIZE(abfd) \
784 (get_elf_backend_data (abfd)->s->sizeof_sym)
786 /* The default alignment for sections, as a power of two. */
787 #define MIPS_ELF_LOG_FILE_ALIGN(abfd) \
788 (get_elf_backend_data (abfd)->s->log_file_align)
790 /* Get word-sized data. */
791 #define MIPS_ELF_GET_WORD(abfd, ptr) \
792 (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
794 /* Put out word-sized data. */
795 #define MIPS_ELF_PUT_WORD(abfd, val, ptr) \
797 ? bfd_put_64 (abfd, val, ptr) \
798 : bfd_put_32 (abfd, val, ptr))
800 /* The opcode for word-sized loads (LW or LD). */
801 #define MIPS_ELF_LOAD_WORD(abfd) \
802 (ABI_64_P (abfd) ? 0xdc000000 : 0x8c000000)
804 /* Add a dynamic symbol table-entry. */
805 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
806 _bfd_elf_add_dynamic_entry (info, tag, val)
808 #define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela) \
809 (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela))
811 /* The name of the dynamic relocation section. */
812 #define MIPS_ELF_REL_DYN_NAME(INFO) \
813 (mips_elf_hash_table (INFO)->is_vxworks ? ".rela.dyn" : ".rel.dyn")
815 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
816 from smaller values. Start with zero, widen, *then* decrement. */
817 #define MINUS_ONE (((bfd_vma)0) - 1)
818 #define MINUS_TWO (((bfd_vma)0) - 2)
820 /* The value to write into got[1] for SVR4 targets, to identify it is
821 a GNU object. The dynamic linker can then use got[1] to store the
823 #define MIPS_ELF_GNU_GOT1_MASK(abfd) \
824 ((bfd_vma) 1 << (ABI_64_P (abfd) ? 63 : 31))
826 /* The offset of $gp from the beginning of the .got section. */
827 #define ELF_MIPS_GP_OFFSET(INFO) \
828 (mips_elf_hash_table (INFO)->is_vxworks ? 0x0 : 0x7ff0)
830 /* The maximum size of the GOT for it to be addressable using 16-bit
832 #define MIPS_ELF_GOT_MAX_SIZE(INFO) (ELF_MIPS_GP_OFFSET (INFO) + 0x7fff)
834 /* Instructions which appear in a stub. */
835 #define STUB_LW(abfd) \
837 ? 0xdf998010 /* ld t9,0x8010(gp) */ \
838 : 0x8f998010)) /* lw t9,0x8010(gp) */
839 #define STUB_MOVE(abfd) \
841 ? 0x03e0782d /* daddu t7,ra */ \
842 : 0x03e07821)) /* addu t7,ra */
843 #define STUB_LUI(VAL) (0x3c180000 + (VAL)) /* lui t8,VAL */
844 #define STUB_JALR 0x0320f809 /* jalr t9,ra */
845 #define STUB_ORI(VAL) (0x37180000 + (VAL)) /* ori t8,t8,VAL */
846 #define STUB_LI16U(VAL) (0x34180000 + (VAL)) /* ori t8,zero,VAL unsigned */
847 #define STUB_LI16S(abfd, VAL) \
849 ? (0x64180000 + (VAL)) /* daddiu t8,zero,VAL sign extended */ \
850 : (0x24180000 + (VAL)))) /* addiu t8,zero,VAL sign extended */
852 #define MIPS_FUNCTION_STUB_NORMAL_SIZE 16
853 #define MIPS_FUNCTION_STUB_BIG_SIZE 20
855 /* The name of the dynamic interpreter. This is put in the .interp
858 #define ELF_DYNAMIC_INTERPRETER(abfd) \
859 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
860 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
861 : "/usr/lib/libc.so.1")
864 #define MNAME(bfd,pre,pos) \
865 (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
866 #define ELF_R_SYM(bfd, i) \
867 (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
868 #define ELF_R_TYPE(bfd, i) \
869 (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
870 #define ELF_R_INFO(bfd, s, t) \
871 (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
873 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
874 #define ELF_R_SYM(bfd, i) \
876 #define ELF_R_TYPE(bfd, i) \
878 #define ELF_R_INFO(bfd, s, t) \
879 (ELF32_R_INFO (s, t))
882 /* The mips16 compiler uses a couple of special sections to handle
883 floating point arguments.
885 Section names that look like .mips16.fn.FNNAME contain stubs that
886 copy floating point arguments from the fp regs to the gp regs and
887 then jump to FNNAME. If any 32 bit function calls FNNAME, the
888 call should be redirected to the stub instead. If no 32 bit
889 function calls FNNAME, the stub should be discarded. We need to
890 consider any reference to the function, not just a call, because
891 if the address of the function is taken we will need the stub,
892 since the address might be passed to a 32 bit function.
894 Section names that look like .mips16.call.FNNAME contain stubs
895 that copy floating point arguments from the gp regs to the fp
896 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
897 then any 16 bit function that calls FNNAME should be redirected
898 to the stub instead. If FNNAME is not a 32 bit function, the
899 stub should be discarded.
901 .mips16.call.fp.FNNAME sections are similar, but contain stubs
902 which call FNNAME and then copy the return value from the fp regs
903 to the gp regs. These stubs store the return value in $18 while
904 calling FNNAME; any function which might call one of these stubs
905 must arrange to save $18 around the call. (This case is not
906 needed for 32 bit functions that call 16 bit functions, because
907 16 bit functions always return floating point values in both
910 Note that in all cases FNNAME might be defined statically.
911 Therefore, FNNAME is not used literally. Instead, the relocation
912 information will indicate which symbol the section is for.
914 We record any stubs that we find in the symbol table. */
916 #define FN_STUB ".mips16.fn."
917 #define CALL_STUB ".mips16.call."
918 #define CALL_FP_STUB ".mips16.call.fp."
920 #define FN_STUB_P(name) CONST_STRNEQ (name, FN_STUB)
921 #define CALL_STUB_P(name) CONST_STRNEQ (name, CALL_STUB)
922 #define CALL_FP_STUB_P(name) CONST_STRNEQ (name, CALL_FP_STUB)
924 /* The format of the first PLT entry in an O32 executable. */
925 static const bfd_vma mips_o32_exec_plt0_entry[] =
927 0x3c1c0000, /* lui $28, %hi(&GOTPLT[0]) */
928 0x8f990000, /* lw $25, %lo(&GOTPLT[0])($28) */
929 0x279c0000, /* addiu $28, $28, %lo(&GOTPLT[0]) */
930 0x031cc023, /* subu $24, $24, $28 */
931 0x03e07821, /* move $15, $31 # 32-bit move (addu) */
932 0x0018c082, /* srl $24, $24, 2 */
933 0x0320f809, /* jalr $25 */
934 0x2718fffe /* subu $24, $24, 2 */
937 /* The format of the first PLT entry in an N32 executable. Different
938 because gp ($28) is not available; we use t2 ($14) instead. */
939 static const bfd_vma mips_n32_exec_plt0_entry[] =
941 0x3c0e0000, /* lui $14, %hi(&GOTPLT[0]) */
942 0x8dd90000, /* lw $25, %lo(&GOTPLT[0])($14) */
943 0x25ce0000, /* addiu $14, $14, %lo(&GOTPLT[0]) */
944 0x030ec023, /* subu $24, $24, $14 */
945 0x03e07821, /* move $15, $31 # 32-bit move (addu) */
946 0x0018c082, /* srl $24, $24, 2 */
947 0x0320f809, /* jalr $25 */
948 0x2718fffe /* subu $24, $24, 2 */
951 /* The format of the first PLT entry in an N64 executable. Different
952 from N32 because of the increased size of GOT entries. */
953 static const bfd_vma mips_n64_exec_plt0_entry[] =
955 0x3c0e0000, /* lui $14, %hi(&GOTPLT[0]) */
956 0xddd90000, /* ld $25, %lo(&GOTPLT[0])($14) */
957 0x25ce0000, /* addiu $14, $14, %lo(&GOTPLT[0]) */
958 0x030ec023, /* subu $24, $24, $14 */
959 0x03e0782d, /* move $15, $31 # 64-bit move (daddu) */
960 0x0018c0c2, /* srl $24, $24, 3 */
961 0x0320f809, /* jalr $25 */
962 0x2718fffe /* subu $24, $24, 2 */
965 /* The format of subsequent PLT entries. */
966 static const bfd_vma mips_exec_plt_entry[] =
968 0x3c0f0000, /* lui $15, %hi(.got.plt entry) */
969 0x01f90000, /* l[wd] $25, %lo(.got.plt entry)($15) */
970 0x25f80000, /* addiu $24, $15, %lo(.got.plt entry) */
971 0x03200008 /* jr $25 */
974 /* The format of the first PLT entry in a VxWorks executable. */
975 static const bfd_vma mips_vxworks_exec_plt0_entry[] =
977 0x3c190000, /* lui t9, %hi(_GLOBAL_OFFSET_TABLE_) */
978 0x27390000, /* addiu t9, t9, %lo(_GLOBAL_OFFSET_TABLE_) */
979 0x8f390008, /* lw t9, 8(t9) */
980 0x00000000, /* nop */
981 0x03200008, /* jr t9 */
985 /* The format of subsequent PLT entries. */
986 static const bfd_vma mips_vxworks_exec_plt_entry[] =
988 0x10000000, /* b .PLT_resolver */
989 0x24180000, /* li t8, <pltindex> */
990 0x3c190000, /* lui t9, %hi(<.got.plt slot>) */
991 0x27390000, /* addiu t9, t9, %lo(<.got.plt slot>) */
992 0x8f390000, /* lw t9, 0(t9) */
993 0x00000000, /* nop */
994 0x03200008, /* jr t9 */
998 /* The format of the first PLT entry in a VxWorks shared object. */
999 static const bfd_vma mips_vxworks_shared_plt0_entry[] =
1001 0x8f990008, /* lw t9, 8(gp) */
1002 0x00000000, /* nop */
1003 0x03200008, /* jr t9 */
1004 0x00000000, /* nop */
1005 0x00000000, /* nop */
1006 0x00000000 /* nop */
1009 /* The format of subsequent PLT entries. */
1010 static const bfd_vma mips_vxworks_shared_plt_entry[] =
1012 0x10000000, /* b .PLT_resolver */
1013 0x24180000 /* li t8, <pltindex> */
1016 /* microMIPS 32-bit opcode helper installer. */
1019 bfd_put_micromips_32 (const bfd *abfd, bfd_vma opcode, bfd_byte *ptr)
1021 bfd_put_16 (abfd, (opcode >> 16) & 0xffff, ptr);
1022 bfd_put_16 (abfd, opcode & 0xffff, ptr + 2);
1025 /* microMIPS 32-bit opcode helper retriever. */
1028 bfd_get_micromips_32 (const bfd *abfd, const bfd_byte *ptr)
1030 return (bfd_get_16 (abfd, ptr) << 16) | bfd_get_16 (abfd, ptr + 2);
1033 /* Look up an entry in a MIPS ELF linker hash table. */
1035 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
1036 ((struct mips_elf_link_hash_entry *) \
1037 elf_link_hash_lookup (&(table)->root, (string), (create), \
1040 /* Traverse a MIPS ELF linker hash table. */
1042 #define mips_elf_link_hash_traverse(table, func, info) \
1043 (elf_link_hash_traverse \
1045 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
1048 /* Find the base offsets for thread-local storage in this object,
1049 for GD/LD and IE/LE respectively. */
1051 #define TP_OFFSET 0x7000
1052 #define DTP_OFFSET 0x8000
1055 dtprel_base (struct bfd_link_info *info)
1057 /* If tls_sec is NULL, we should have signalled an error already. */
1058 if (elf_hash_table (info)->tls_sec == NULL)
1060 return elf_hash_table (info)->tls_sec->vma + DTP_OFFSET;
1064 tprel_base (struct bfd_link_info *info)
1066 /* If tls_sec is NULL, we should have signalled an error already. */
1067 if (elf_hash_table (info)->tls_sec == NULL)
1069 return elf_hash_table (info)->tls_sec->vma + TP_OFFSET;
1072 /* Create an entry in a MIPS ELF linker hash table. */
1074 static struct bfd_hash_entry *
1075 mips_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
1076 struct bfd_hash_table *table, const char *string)
1078 struct mips_elf_link_hash_entry *ret =
1079 (struct mips_elf_link_hash_entry *) entry;
1081 /* Allocate the structure if it has not already been allocated by a
1084 ret = bfd_hash_allocate (table, sizeof (struct mips_elf_link_hash_entry));
1086 return (struct bfd_hash_entry *) ret;
1088 /* Call the allocation method of the superclass. */
1089 ret = ((struct mips_elf_link_hash_entry *)
1090 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1094 /* Set local fields. */
1095 memset (&ret->esym, 0, sizeof (EXTR));
1096 /* We use -2 as a marker to indicate that the information has
1097 not been set. -1 means there is no associated ifd. */
1100 ret->possibly_dynamic_relocs = 0;
1101 ret->fn_stub = NULL;
1102 ret->call_stub = NULL;
1103 ret->call_fp_stub = NULL;
1104 ret->tls_type = GOT_NORMAL;
1105 ret->global_got_area = GGA_NONE;
1106 ret->got_only_for_calls = TRUE;
1107 ret->readonly_reloc = FALSE;
1108 ret->has_static_relocs = FALSE;
1109 ret->no_fn_stub = FALSE;
1110 ret->need_fn_stub = FALSE;
1111 ret->has_nonpic_branches = FALSE;
1112 ret->needs_lazy_stub = FALSE;
1115 return (struct bfd_hash_entry *) ret;
1119 _bfd_mips_elf_new_section_hook (bfd *abfd, asection *sec)
1121 if (!sec->used_by_bfd)
1123 struct _mips_elf_section_data *sdata;
1124 bfd_size_type amt = sizeof (*sdata);
1126 sdata = bfd_zalloc (abfd, amt);
1129 sec->used_by_bfd = sdata;
1132 return _bfd_elf_new_section_hook (abfd, sec);
1135 /* Read ECOFF debugging information from a .mdebug section into a
1136 ecoff_debug_info structure. */
1139 _bfd_mips_elf_read_ecoff_info (bfd *abfd, asection *section,
1140 struct ecoff_debug_info *debug)
1143 const struct ecoff_debug_swap *swap;
1146 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1147 memset (debug, 0, sizeof (*debug));
1149 ext_hdr = bfd_malloc (swap->external_hdr_size);
1150 if (ext_hdr == NULL && swap->external_hdr_size != 0)
1153 if (! bfd_get_section_contents (abfd, section, ext_hdr, 0,
1154 swap->external_hdr_size))
1157 symhdr = &debug->symbolic_header;
1158 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
1160 /* The symbolic header contains absolute file offsets and sizes to
1162 #define READ(ptr, offset, count, size, type) \
1163 if (symhdr->count == 0) \
1164 debug->ptr = NULL; \
1167 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
1168 debug->ptr = bfd_malloc (amt); \
1169 if (debug->ptr == NULL) \
1170 goto error_return; \
1171 if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0 \
1172 || bfd_bread (debug->ptr, amt, abfd) != amt) \
1173 goto error_return; \
1176 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
1177 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *);
1178 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *);
1179 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *);
1180 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *);
1181 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
1183 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
1184 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
1185 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *);
1186 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *);
1187 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, void *);
1195 if (ext_hdr != NULL)
1197 if (debug->line != NULL)
1199 if (debug->external_dnr != NULL)
1200 free (debug->external_dnr);
1201 if (debug->external_pdr != NULL)
1202 free (debug->external_pdr);
1203 if (debug->external_sym != NULL)
1204 free (debug->external_sym);
1205 if (debug->external_opt != NULL)
1206 free (debug->external_opt);
1207 if (debug->external_aux != NULL)
1208 free (debug->external_aux);
1209 if (debug->ss != NULL)
1211 if (debug->ssext != NULL)
1212 free (debug->ssext);
1213 if (debug->external_fdr != NULL)
1214 free (debug->external_fdr);
1215 if (debug->external_rfd != NULL)
1216 free (debug->external_rfd);
1217 if (debug->external_ext != NULL)
1218 free (debug->external_ext);
1222 /* Swap RPDR (runtime procedure table entry) for output. */
1225 ecoff_swap_rpdr_out (bfd *abfd, const RPDR *in, struct rpdr_ext *ex)
1227 H_PUT_S32 (abfd, in->adr, ex->p_adr);
1228 H_PUT_32 (abfd, in->regmask, ex->p_regmask);
1229 H_PUT_32 (abfd, in->regoffset, ex->p_regoffset);
1230 H_PUT_32 (abfd, in->fregmask, ex->p_fregmask);
1231 H_PUT_32 (abfd, in->fregoffset, ex->p_fregoffset);
1232 H_PUT_32 (abfd, in->frameoffset, ex->p_frameoffset);
1234 H_PUT_16 (abfd, in->framereg, ex->p_framereg);
1235 H_PUT_16 (abfd, in->pcreg, ex->p_pcreg);
1237 H_PUT_32 (abfd, in->irpss, ex->p_irpss);
1240 /* Create a runtime procedure table from the .mdebug section. */
1243 mips_elf_create_procedure_table (void *handle, bfd *abfd,
1244 struct bfd_link_info *info, asection *s,
1245 struct ecoff_debug_info *debug)
1247 const struct ecoff_debug_swap *swap;
1248 HDRR *hdr = &debug->symbolic_header;
1250 struct rpdr_ext *erp;
1252 struct pdr_ext *epdr;
1253 struct sym_ext *esym;
1257 bfd_size_type count;
1258 unsigned long sindex;
1262 const char *no_name_func = _("static procedure (no name)");
1270 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1272 sindex = strlen (no_name_func) + 1;
1273 count = hdr->ipdMax;
1276 size = swap->external_pdr_size;
1278 epdr = bfd_malloc (size * count);
1282 if (! _bfd_ecoff_get_accumulated_pdr (handle, (bfd_byte *) epdr))
1285 size = sizeof (RPDR);
1286 rp = rpdr = bfd_malloc (size * count);
1290 size = sizeof (char *);
1291 sv = bfd_malloc (size * count);
1295 count = hdr->isymMax;
1296 size = swap->external_sym_size;
1297 esym = bfd_malloc (size * count);
1301 if (! _bfd_ecoff_get_accumulated_sym (handle, (bfd_byte *) esym))
1304 count = hdr->issMax;
1305 ss = bfd_malloc (count);
1308 if (! _bfd_ecoff_get_accumulated_ss (handle, (bfd_byte *) ss))
1311 count = hdr->ipdMax;
1312 for (i = 0; i < (unsigned long) count; i++, rp++)
1314 (*swap->swap_pdr_in) (abfd, epdr + i, &pdr);
1315 (*swap->swap_sym_in) (abfd, &esym[pdr.isym], &sym);
1316 rp->adr = sym.value;
1317 rp->regmask = pdr.regmask;
1318 rp->regoffset = pdr.regoffset;
1319 rp->fregmask = pdr.fregmask;
1320 rp->fregoffset = pdr.fregoffset;
1321 rp->frameoffset = pdr.frameoffset;
1322 rp->framereg = pdr.framereg;
1323 rp->pcreg = pdr.pcreg;
1325 sv[i] = ss + sym.iss;
1326 sindex += strlen (sv[i]) + 1;
1330 size = sizeof (struct rpdr_ext) * (count + 2) + sindex;
1331 size = BFD_ALIGN (size, 16);
1332 rtproc = bfd_alloc (abfd, size);
1335 mips_elf_hash_table (info)->procedure_count = 0;
1339 mips_elf_hash_table (info)->procedure_count = count + 2;
1342 memset (erp, 0, sizeof (struct rpdr_ext));
1344 str = (char *) rtproc + sizeof (struct rpdr_ext) * (count + 2);
1345 strcpy (str, no_name_func);
1346 str += strlen (no_name_func) + 1;
1347 for (i = 0; i < count; i++)
1349 ecoff_swap_rpdr_out (abfd, rpdr + i, erp + i);
1350 strcpy (str, sv[i]);
1351 str += strlen (sv[i]) + 1;
1353 H_PUT_S32 (abfd, -1, (erp + count)->p_adr);
1355 /* Set the size and contents of .rtproc section. */
1357 s->contents = rtproc;
1359 /* Skip this section later on (I don't think this currently
1360 matters, but someday it might). */
1361 s->map_head.link_order = NULL;
1390 /* We're going to create a stub for H. Create a symbol for the stub's
1391 value and size, to help make the disassembly easier to read. */
1394 mips_elf_create_stub_symbol (struct bfd_link_info *info,
1395 struct mips_elf_link_hash_entry *h,
1396 const char *prefix, asection *s, bfd_vma value,
1399 struct bfd_link_hash_entry *bh;
1400 struct elf_link_hash_entry *elfh;
1403 if (ELF_ST_IS_MICROMIPS (h->root.other))
1406 /* Create a new symbol. */
1407 name = ACONCAT ((prefix, h->root.root.root.string, NULL));
1409 if (!_bfd_generic_link_add_one_symbol (info, s->owner, name,
1410 BSF_LOCAL, s, value, NULL,
1414 /* Make it a local function. */
1415 elfh = (struct elf_link_hash_entry *) bh;
1416 elfh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
1418 elfh->forced_local = 1;
1422 /* We're about to redefine H. Create a symbol to represent H's
1423 current value and size, to help make the disassembly easier
1427 mips_elf_create_shadow_symbol (struct bfd_link_info *info,
1428 struct mips_elf_link_hash_entry *h,
1431 struct bfd_link_hash_entry *bh;
1432 struct elf_link_hash_entry *elfh;
1437 /* Read the symbol's value. */
1438 BFD_ASSERT (h->root.root.type == bfd_link_hash_defined
1439 || h->root.root.type == bfd_link_hash_defweak);
1440 s = h->root.root.u.def.section;
1441 value = h->root.root.u.def.value;
1443 /* Create a new symbol. */
1444 name = ACONCAT ((prefix, h->root.root.root.string, NULL));
1446 if (!_bfd_generic_link_add_one_symbol (info, s->owner, name,
1447 BSF_LOCAL, s, value, NULL,
1451 /* Make it local and copy the other attributes from H. */
1452 elfh = (struct elf_link_hash_entry *) bh;
1453 elfh->type = ELF_ST_INFO (STB_LOCAL, ELF_ST_TYPE (h->root.type));
1454 elfh->other = h->root.other;
1455 elfh->size = h->root.size;
1456 elfh->forced_local = 1;
1460 /* Return TRUE if relocations in SECTION can refer directly to a MIPS16
1461 function rather than to a hard-float stub. */
1464 section_allows_mips16_refs_p (asection *section)
1468 name = bfd_get_section_name (section->owner, section);
1469 return (FN_STUB_P (name)
1470 || CALL_STUB_P (name)
1471 || CALL_FP_STUB_P (name)
1472 || strcmp (name, ".pdr") == 0);
1475 /* [RELOCS, RELEND) are the relocations against SEC, which is a MIPS16
1476 stub section of some kind. Return the R_SYMNDX of the target
1477 function, or 0 if we can't decide which function that is. */
1479 static unsigned long
1480 mips16_stub_symndx (const struct elf_backend_data *bed,
1481 asection *sec ATTRIBUTE_UNUSED,
1482 const Elf_Internal_Rela *relocs,
1483 const Elf_Internal_Rela *relend)
1485 int int_rels_per_ext_rel = bed->s->int_rels_per_ext_rel;
1486 const Elf_Internal_Rela *rel;
1488 /* Trust the first R_MIPS_NONE relocation, if any, but not a subsequent
1489 one in a compound relocation. */
1490 for (rel = relocs; rel < relend; rel += int_rels_per_ext_rel)
1491 if (ELF_R_TYPE (sec->owner, rel->r_info) == R_MIPS_NONE)
1492 return ELF_R_SYM (sec->owner, rel->r_info);
1494 /* Otherwise trust the first relocation, whatever its kind. This is
1495 the traditional behavior. */
1496 if (relocs < relend)
1497 return ELF_R_SYM (sec->owner, relocs->r_info);
1502 /* Check the mips16 stubs for a particular symbol, and see if we can
1506 mips_elf_check_mips16_stubs (struct bfd_link_info *info,
1507 struct mips_elf_link_hash_entry *h)
1509 /* Dynamic symbols must use the standard call interface, in case other
1510 objects try to call them. */
1511 if (h->fn_stub != NULL
1512 && h->root.dynindx != -1)
1514 mips_elf_create_shadow_symbol (info, h, ".mips16.");
1515 h->need_fn_stub = TRUE;
1518 if (h->fn_stub != NULL
1519 && ! h->need_fn_stub)
1521 /* We don't need the fn_stub; the only references to this symbol
1522 are 16 bit calls. Clobber the size to 0 to prevent it from
1523 being included in the link. */
1524 h->fn_stub->size = 0;
1525 h->fn_stub->flags &= ~SEC_RELOC;
1526 h->fn_stub->reloc_count = 0;
1527 h->fn_stub->flags |= SEC_EXCLUDE;
1530 if (h->call_stub != NULL
1531 && ELF_ST_IS_MIPS16 (h->root.other))
1533 /* We don't need the call_stub; this is a 16 bit function, so
1534 calls from other 16 bit functions are OK. Clobber the size
1535 to 0 to prevent it from being included in the link. */
1536 h->call_stub->size = 0;
1537 h->call_stub->flags &= ~SEC_RELOC;
1538 h->call_stub->reloc_count = 0;
1539 h->call_stub->flags |= SEC_EXCLUDE;
1542 if (h->call_fp_stub != NULL
1543 && ELF_ST_IS_MIPS16 (h->root.other))
1545 /* We don't need the call_stub; this is a 16 bit function, so
1546 calls from other 16 bit functions are OK. Clobber the size
1547 to 0 to prevent it from being included in the link. */
1548 h->call_fp_stub->size = 0;
1549 h->call_fp_stub->flags &= ~SEC_RELOC;
1550 h->call_fp_stub->reloc_count = 0;
1551 h->call_fp_stub->flags |= SEC_EXCLUDE;
1555 /* Hashtable callbacks for mips_elf_la25_stubs. */
1558 mips_elf_la25_stub_hash (const void *entry_)
1560 const struct mips_elf_la25_stub *entry;
1562 entry = (struct mips_elf_la25_stub *) entry_;
1563 return entry->h->root.root.u.def.section->id
1564 + entry->h->root.root.u.def.value;
1568 mips_elf_la25_stub_eq (const void *entry1_, const void *entry2_)
1570 const struct mips_elf_la25_stub *entry1, *entry2;
1572 entry1 = (struct mips_elf_la25_stub *) entry1_;
1573 entry2 = (struct mips_elf_la25_stub *) entry2_;
1574 return ((entry1->h->root.root.u.def.section
1575 == entry2->h->root.root.u.def.section)
1576 && (entry1->h->root.root.u.def.value
1577 == entry2->h->root.root.u.def.value));
1580 /* Called by the linker to set up the la25 stub-creation code. FN is
1581 the linker's implementation of add_stub_function. Return true on
1585 _bfd_mips_elf_init_stubs (struct bfd_link_info *info,
1586 asection *(*fn) (const char *, asection *,
1589 struct mips_elf_link_hash_table *htab;
1591 htab = mips_elf_hash_table (info);
1595 htab->add_stub_section = fn;
1596 htab->la25_stubs = htab_try_create (1, mips_elf_la25_stub_hash,
1597 mips_elf_la25_stub_eq, NULL);
1598 if (htab->la25_stubs == NULL)
1604 /* Return true if H is a locally-defined PIC function, in the sense
1605 that it or its fn_stub might need $25 to be valid on entry.
1606 Note that MIPS16 functions set up $gp using PC-relative instructions,
1607 so they themselves never need $25 to be valid. Only non-MIPS16
1608 entry points are of interest here. */
1611 mips_elf_local_pic_function_p (struct mips_elf_link_hash_entry *h)
1613 return ((h->root.root.type == bfd_link_hash_defined
1614 || h->root.root.type == bfd_link_hash_defweak)
1615 && h->root.def_regular
1616 && !bfd_is_abs_section (h->root.root.u.def.section)
1617 && (!ELF_ST_IS_MIPS16 (h->root.other)
1618 || (h->fn_stub && h->need_fn_stub))
1619 && (PIC_OBJECT_P (h->root.root.u.def.section->owner)
1620 || ELF_ST_IS_MIPS_PIC (h->root.other)));
1623 /* Set *SEC to the input section that contains the target of STUB.
1624 Return the offset of the target from the start of that section. */
1627 mips_elf_get_la25_target (struct mips_elf_la25_stub *stub,
1630 if (ELF_ST_IS_MIPS16 (stub->h->root.other))
1632 BFD_ASSERT (stub->h->need_fn_stub);
1633 *sec = stub->h->fn_stub;
1638 *sec = stub->h->root.root.u.def.section;
1639 return stub->h->root.root.u.def.value;
1643 /* STUB describes an la25 stub that we have decided to implement
1644 by inserting an LUI/ADDIU pair before the target function.
1645 Create the section and redirect the function symbol to it. */
1648 mips_elf_add_la25_intro (struct mips_elf_la25_stub *stub,
1649 struct bfd_link_info *info)
1651 struct mips_elf_link_hash_table *htab;
1653 asection *s, *input_section;
1656 htab = mips_elf_hash_table (info);
1660 /* Create a unique name for the new section. */
1661 name = bfd_malloc (11 + sizeof (".text.stub."));
1664 sprintf (name, ".text.stub.%d", (int) htab_elements (htab->la25_stubs));
1666 /* Create the section. */
1667 mips_elf_get_la25_target (stub, &input_section);
1668 s = htab->add_stub_section (name, input_section,
1669 input_section->output_section);
1673 /* Make sure that any padding goes before the stub. */
1674 align = input_section->alignment_power;
1675 if (!bfd_set_section_alignment (s->owner, s, align))
1678 s->size = (1 << align) - 8;
1680 /* Create a symbol for the stub. */
1681 mips_elf_create_stub_symbol (info, stub->h, ".pic.", s, s->size, 8);
1682 stub->stub_section = s;
1683 stub->offset = s->size;
1685 /* Allocate room for it. */
1690 /* STUB describes an la25 stub that we have decided to implement
1691 with a separate trampoline. Allocate room for it and redirect
1692 the function symbol to it. */
1695 mips_elf_add_la25_trampoline (struct mips_elf_la25_stub *stub,
1696 struct bfd_link_info *info)
1698 struct mips_elf_link_hash_table *htab;
1701 htab = mips_elf_hash_table (info);
1705 /* Create a trampoline section, if we haven't already. */
1706 s = htab->strampoline;
1709 asection *input_section = stub->h->root.root.u.def.section;
1710 s = htab->add_stub_section (".text", NULL,
1711 input_section->output_section);
1712 if (s == NULL || !bfd_set_section_alignment (s->owner, s, 4))
1714 htab->strampoline = s;
1717 /* Create a symbol for the stub. */
1718 mips_elf_create_stub_symbol (info, stub->h, ".pic.", s, s->size, 16);
1719 stub->stub_section = s;
1720 stub->offset = s->size;
1722 /* Allocate room for it. */
1727 /* H describes a symbol that needs an la25 stub. Make sure that an
1728 appropriate stub exists and point H at it. */
1731 mips_elf_add_la25_stub (struct bfd_link_info *info,
1732 struct mips_elf_link_hash_entry *h)
1734 struct mips_elf_link_hash_table *htab;
1735 struct mips_elf_la25_stub search, *stub;
1736 bfd_boolean use_trampoline_p;
1741 /* Describe the stub we want. */
1742 search.stub_section = NULL;
1746 /* See if we've already created an equivalent stub. */
1747 htab = mips_elf_hash_table (info);
1751 slot = htab_find_slot (htab->la25_stubs, &search, INSERT);
1755 stub = (struct mips_elf_la25_stub *) *slot;
1758 /* We can reuse the existing stub. */
1759 h->la25_stub = stub;
1763 /* Create a permanent copy of ENTRY and add it to the hash table. */
1764 stub = bfd_malloc (sizeof (search));
1770 /* Prefer to use LUI/ADDIU stubs if the function is at the beginning
1771 of the section and if we would need no more than 2 nops. */
1772 value = mips_elf_get_la25_target (stub, &s);
1773 use_trampoline_p = (value != 0 || s->alignment_power > 4);
1775 h->la25_stub = stub;
1776 return (use_trampoline_p
1777 ? mips_elf_add_la25_trampoline (stub, info)
1778 : mips_elf_add_la25_intro (stub, info));
1781 /* A mips_elf_link_hash_traverse callback that is called before sizing
1782 sections. DATA points to a mips_htab_traverse_info structure. */
1785 mips_elf_check_symbols (struct mips_elf_link_hash_entry *h, void *data)
1787 struct mips_htab_traverse_info *hti;
1789 hti = (struct mips_htab_traverse_info *) data;
1790 if (!hti->info->relocatable)
1791 mips_elf_check_mips16_stubs (hti->info, h);
1793 if (mips_elf_local_pic_function_p (h))
1795 /* PR 12845: If H is in a section that has been garbage
1796 collected it will have its output section set to *ABS*. */
1797 if (bfd_is_abs_section (h->root.root.u.def.section->output_section))
1800 /* H is a function that might need $25 to be valid on entry.
1801 If we're creating a non-PIC relocatable object, mark H as
1802 being PIC. If we're creating a non-relocatable object with
1803 non-PIC branches and jumps to H, make sure that H has an la25
1805 if (hti->info->relocatable)
1807 if (!PIC_OBJECT_P (hti->output_bfd))
1808 h->root.other = ELF_ST_SET_MIPS_PIC (h->root.other);
1810 else if (h->has_nonpic_branches && !mips_elf_add_la25_stub (hti->info, h))
1819 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
1820 Most mips16 instructions are 16 bits, but these instructions
1823 The format of these instructions is:
1825 +--------------+--------------------------------+
1826 | JALX | X| Imm 20:16 | Imm 25:21 |
1827 +--------------+--------------------------------+
1829 +-----------------------------------------------+
1831 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
1832 Note that the immediate value in the first word is swapped.
1834 When producing a relocatable object file, R_MIPS16_26 is
1835 handled mostly like R_MIPS_26. In particular, the addend is
1836 stored as a straight 26-bit value in a 32-bit instruction.
1837 (gas makes life simpler for itself by never adjusting a
1838 R_MIPS16_26 reloc to be against a section, so the addend is
1839 always zero). However, the 32 bit instruction is stored as 2
1840 16-bit values, rather than a single 32-bit value. In a
1841 big-endian file, the result is the same; in a little-endian
1842 file, the two 16-bit halves of the 32 bit value are swapped.
1843 This is so that a disassembler can recognize the jal
1846 When doing a final link, R_MIPS16_26 is treated as a 32 bit
1847 instruction stored as two 16-bit values. The addend A is the
1848 contents of the targ26 field. The calculation is the same as
1849 R_MIPS_26. When storing the calculated value, reorder the
1850 immediate value as shown above, and don't forget to store the
1851 value as two 16-bit values.
1853 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
1857 +--------+----------------------+
1861 +--------+----------------------+
1864 +----------+------+-------------+
1868 +----------+--------------------+
1869 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
1870 ((sub1 << 16) | sub2)).
1872 When producing a relocatable object file, the calculation is
1873 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1874 When producing a fully linked file, the calculation is
1875 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1876 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)
1878 The table below lists the other MIPS16 instruction relocations.
1879 Each one is calculated in the same way as the non-MIPS16 relocation
1880 given on the right, but using the extended MIPS16 layout of 16-bit
1883 R_MIPS16_GPREL R_MIPS_GPREL16
1884 R_MIPS16_GOT16 R_MIPS_GOT16
1885 R_MIPS16_CALL16 R_MIPS_CALL16
1886 R_MIPS16_HI16 R_MIPS_HI16
1887 R_MIPS16_LO16 R_MIPS_LO16
1889 A typical instruction will have a format like this:
1891 +--------------+--------------------------------+
1892 | EXTEND | Imm 10:5 | Imm 15:11 |
1893 +--------------+--------------------------------+
1894 | Major | rx | ry | Imm 4:0 |
1895 +--------------+--------------------------------+
1897 EXTEND is the five bit value 11110. Major is the instruction
1900 All we need to do here is shuffle the bits appropriately.
1901 As above, the two 16-bit halves must be swapped on a
1902 little-endian system. */
1904 static inline bfd_boolean
1905 mips16_reloc_p (int r_type)
1910 case R_MIPS16_GPREL:
1911 case R_MIPS16_GOT16:
1912 case R_MIPS16_CALL16:
1915 case R_MIPS16_TLS_GD:
1916 case R_MIPS16_TLS_LDM:
1917 case R_MIPS16_TLS_DTPREL_HI16:
1918 case R_MIPS16_TLS_DTPREL_LO16:
1919 case R_MIPS16_TLS_GOTTPREL:
1920 case R_MIPS16_TLS_TPREL_HI16:
1921 case R_MIPS16_TLS_TPREL_LO16:
1929 /* Check if a microMIPS reloc. */
1931 static inline bfd_boolean
1932 micromips_reloc_p (unsigned int r_type)
1934 return r_type >= R_MICROMIPS_min && r_type < R_MICROMIPS_max;
1937 /* Similar to MIPS16, the two 16-bit halves in microMIPS must be swapped
1938 on a little-endian system. This does not apply to R_MICROMIPS_PC7_S1
1939 and R_MICROMIPS_PC10_S1 relocs that apply to 16-bit instructions. */
1941 static inline bfd_boolean
1942 micromips_reloc_shuffle_p (unsigned int r_type)
1944 return (micromips_reloc_p (r_type)
1945 && r_type != R_MICROMIPS_PC7_S1
1946 && r_type != R_MICROMIPS_PC10_S1);
1949 static inline bfd_boolean
1950 got16_reloc_p (int r_type)
1952 return (r_type == R_MIPS_GOT16
1953 || r_type == R_MIPS16_GOT16
1954 || r_type == R_MICROMIPS_GOT16);
1957 static inline bfd_boolean
1958 call16_reloc_p (int r_type)
1960 return (r_type == R_MIPS_CALL16
1961 || r_type == R_MIPS16_CALL16
1962 || r_type == R_MICROMIPS_CALL16);
1965 static inline bfd_boolean
1966 got_disp_reloc_p (unsigned int r_type)
1968 return r_type == R_MIPS_GOT_DISP || r_type == R_MICROMIPS_GOT_DISP;
1971 static inline bfd_boolean
1972 got_page_reloc_p (unsigned int r_type)
1974 return r_type == R_MIPS_GOT_PAGE || r_type == R_MICROMIPS_GOT_PAGE;
1977 static inline bfd_boolean
1978 got_ofst_reloc_p (unsigned int r_type)
1980 return r_type == R_MIPS_GOT_OFST || r_type == R_MICROMIPS_GOT_OFST;
1983 static inline bfd_boolean
1984 got_hi16_reloc_p (unsigned int r_type)
1986 return r_type == R_MIPS_GOT_HI16 || r_type == R_MICROMIPS_GOT_HI16;
1989 static inline bfd_boolean
1990 got_lo16_reloc_p (unsigned int r_type)
1992 return r_type == R_MIPS_GOT_LO16 || r_type == R_MICROMIPS_GOT_LO16;
1995 static inline bfd_boolean
1996 call_hi16_reloc_p (unsigned int r_type)
1998 return r_type == R_MIPS_CALL_HI16 || r_type == R_MICROMIPS_CALL_HI16;
2001 static inline bfd_boolean
2002 call_lo16_reloc_p (unsigned int r_type)
2004 return r_type == R_MIPS_CALL_LO16 || r_type == R_MICROMIPS_CALL_LO16;
2007 static inline bfd_boolean
2008 hi16_reloc_p (int r_type)
2010 return (r_type == R_MIPS_HI16
2011 || r_type == R_MIPS16_HI16
2012 || r_type == R_MICROMIPS_HI16);
2015 static inline bfd_boolean
2016 lo16_reloc_p (int r_type)
2018 return (r_type == R_MIPS_LO16
2019 || r_type == R_MIPS16_LO16
2020 || r_type == R_MICROMIPS_LO16);
2023 static inline bfd_boolean
2024 mips16_call_reloc_p (int r_type)
2026 return r_type == R_MIPS16_26 || r_type == R_MIPS16_CALL16;
2029 static inline bfd_boolean
2030 jal_reloc_p (int r_type)
2032 return (r_type == R_MIPS_26
2033 || r_type == R_MIPS16_26
2034 || r_type == R_MICROMIPS_26_S1);
2037 static inline bfd_boolean
2038 micromips_branch_reloc_p (int r_type)
2040 return (r_type == R_MICROMIPS_26_S1
2041 || r_type == R_MICROMIPS_PC16_S1
2042 || r_type == R_MICROMIPS_PC10_S1
2043 || r_type == R_MICROMIPS_PC7_S1);
2046 static inline bfd_boolean
2047 tls_gd_reloc_p (unsigned int r_type)
2049 return (r_type == R_MIPS_TLS_GD
2050 || r_type == R_MIPS16_TLS_GD
2051 || r_type == R_MICROMIPS_TLS_GD);
2054 static inline bfd_boolean
2055 tls_ldm_reloc_p (unsigned int r_type)
2057 return (r_type == R_MIPS_TLS_LDM
2058 || r_type == R_MIPS16_TLS_LDM
2059 || r_type == R_MICROMIPS_TLS_LDM);
2062 static inline bfd_boolean
2063 tls_gottprel_reloc_p (unsigned int r_type)
2065 return (r_type == R_MIPS_TLS_GOTTPREL
2066 || r_type == R_MIPS16_TLS_GOTTPREL
2067 || r_type == R_MICROMIPS_TLS_GOTTPREL);
2071 _bfd_mips_elf_reloc_unshuffle (bfd *abfd, int r_type,
2072 bfd_boolean jal_shuffle, bfd_byte *data)
2074 bfd_vma first, second, val;
2076 if (!mips16_reloc_p (r_type) && !micromips_reloc_shuffle_p (r_type))
2079 /* Pick up the first and second halfwords of the instruction. */
2080 first = bfd_get_16 (abfd, data);
2081 second = bfd_get_16 (abfd, data + 2);
2082 if (micromips_reloc_p (r_type) || (r_type == R_MIPS16_26 && !jal_shuffle))
2083 val = first << 16 | second;
2084 else if (r_type != R_MIPS16_26)
2085 val = (((first & 0xf800) << 16) | ((second & 0xffe0) << 11)
2086 | ((first & 0x1f) << 11) | (first & 0x7e0) | (second & 0x1f));
2088 val = (((first & 0xfc00) << 16) | ((first & 0x3e0) << 11)
2089 | ((first & 0x1f) << 21) | second);
2090 bfd_put_32 (abfd, val, data);
2094 _bfd_mips_elf_reloc_shuffle (bfd *abfd, int r_type,
2095 bfd_boolean jal_shuffle, bfd_byte *data)
2097 bfd_vma first, second, val;
2099 if (!mips16_reloc_p (r_type) && !micromips_reloc_shuffle_p (r_type))
2102 val = bfd_get_32 (abfd, data);
2103 if (micromips_reloc_p (r_type) || (r_type == R_MIPS16_26 && !jal_shuffle))
2105 second = val & 0xffff;
2108 else if (r_type != R_MIPS16_26)
2110 second = ((val >> 11) & 0xffe0) | (val & 0x1f);
2111 first = ((val >> 16) & 0xf800) | ((val >> 11) & 0x1f) | (val & 0x7e0);
2115 second = val & 0xffff;
2116 first = ((val >> 16) & 0xfc00) | ((val >> 11) & 0x3e0)
2117 | ((val >> 21) & 0x1f);
2119 bfd_put_16 (abfd, second, data + 2);
2120 bfd_put_16 (abfd, first, data);
2123 bfd_reloc_status_type
2124 _bfd_mips_elf_gprel16_with_gp (bfd *abfd, asymbol *symbol,
2125 arelent *reloc_entry, asection *input_section,
2126 bfd_boolean relocatable, void *data, bfd_vma gp)
2130 bfd_reloc_status_type status;
2132 if (bfd_is_com_section (symbol->section))
2135 relocation = symbol->value;
2137 relocation += symbol->section->output_section->vma;
2138 relocation += symbol->section->output_offset;
2140 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2141 return bfd_reloc_outofrange;
2143 /* Set val to the offset into the section or symbol. */
2144 val = reloc_entry->addend;
2146 _bfd_mips_elf_sign_extend (val, 16);
2148 /* Adjust val for the final section location and GP value. If we
2149 are producing relocatable output, we don't want to do this for
2150 an external symbol. */
2152 || (symbol->flags & BSF_SECTION_SYM) != 0)
2153 val += relocation - gp;
2155 if (reloc_entry->howto->partial_inplace)
2157 status = _bfd_relocate_contents (reloc_entry->howto, abfd, val,
2159 + reloc_entry->address);
2160 if (status != bfd_reloc_ok)
2164 reloc_entry->addend = val;
2167 reloc_entry->address += input_section->output_offset;
2169 return bfd_reloc_ok;
2172 /* Used to store a REL high-part relocation such as R_MIPS_HI16 or
2173 R_MIPS_GOT16. REL is the relocation, INPUT_SECTION is the section
2174 that contains the relocation field and DATA points to the start of
2179 struct mips_hi16 *next;
2181 asection *input_section;
2185 /* FIXME: This should not be a static variable. */
2187 static struct mips_hi16 *mips_hi16_list;
2189 /* A howto special_function for REL *HI16 relocations. We can only
2190 calculate the correct value once we've seen the partnering
2191 *LO16 relocation, so just save the information for later.
2193 The ABI requires that the *LO16 immediately follow the *HI16.
2194 However, as a GNU extension, we permit an arbitrary number of
2195 *HI16s to be associated with a single *LO16. This significantly
2196 simplies the relocation handling in gcc. */
2198 bfd_reloc_status_type
2199 _bfd_mips_elf_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2200 asymbol *symbol ATTRIBUTE_UNUSED, void *data,
2201 asection *input_section, bfd *output_bfd,
2202 char **error_message ATTRIBUTE_UNUSED)
2204 struct mips_hi16 *n;
2206 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2207 return bfd_reloc_outofrange;
2209 n = bfd_malloc (sizeof *n);
2211 return bfd_reloc_outofrange;
2213 n->next = mips_hi16_list;
2215 n->input_section = input_section;
2216 n->rel = *reloc_entry;
2219 if (output_bfd != NULL)
2220 reloc_entry->address += input_section->output_offset;
2222 return bfd_reloc_ok;
2225 /* A howto special_function for REL R_MIPS*_GOT16 relocations. This is just
2226 like any other 16-bit relocation when applied to global symbols, but is
2227 treated in the same as R_MIPS_HI16 when applied to local symbols. */
2229 bfd_reloc_status_type
2230 _bfd_mips_elf_got16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2231 void *data, asection *input_section,
2232 bfd *output_bfd, char **error_message)
2234 if ((symbol->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
2235 || bfd_is_und_section (bfd_get_section (symbol))
2236 || bfd_is_com_section (bfd_get_section (symbol)))
2237 /* The relocation is against a global symbol. */
2238 return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2239 input_section, output_bfd,
2242 return _bfd_mips_elf_hi16_reloc (abfd, reloc_entry, symbol, data,
2243 input_section, output_bfd, error_message);
2246 /* A howto special_function for REL *LO16 relocations. The *LO16 itself
2247 is a straightforward 16 bit inplace relocation, but we must deal with
2248 any partnering high-part relocations as well. */
2250 bfd_reloc_status_type
2251 _bfd_mips_elf_lo16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2252 void *data, asection *input_section,
2253 bfd *output_bfd, char **error_message)
2256 bfd_byte *location = (bfd_byte *) data + reloc_entry->address;
2258 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2259 return bfd_reloc_outofrange;
2261 _bfd_mips_elf_reloc_unshuffle (abfd, reloc_entry->howto->type, FALSE,
2263 vallo = bfd_get_32 (abfd, location);
2264 _bfd_mips_elf_reloc_shuffle (abfd, reloc_entry->howto->type, FALSE,
2267 while (mips_hi16_list != NULL)
2269 bfd_reloc_status_type ret;
2270 struct mips_hi16 *hi;
2272 hi = mips_hi16_list;
2274 /* R_MIPS*_GOT16 relocations are something of a special case. We
2275 want to install the addend in the same way as for a R_MIPS*_HI16
2276 relocation (with a rightshift of 16). However, since GOT16
2277 relocations can also be used with global symbols, their howto
2278 has a rightshift of 0. */
2279 if (hi->rel.howto->type == R_MIPS_GOT16)
2280 hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MIPS_HI16, FALSE);
2281 else if (hi->rel.howto->type == R_MIPS16_GOT16)
2282 hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MIPS16_HI16, FALSE);
2283 else if (hi->rel.howto->type == R_MICROMIPS_GOT16)
2284 hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MICROMIPS_HI16, FALSE);
2286 /* VALLO is a signed 16-bit number. Bias it by 0x8000 so that any
2287 carry or borrow will induce a change of +1 or -1 in the high part. */
2288 hi->rel.addend += (vallo + 0x8000) & 0xffff;
2290 ret = _bfd_mips_elf_generic_reloc (abfd, &hi->rel, symbol, hi->data,
2291 hi->input_section, output_bfd,
2293 if (ret != bfd_reloc_ok)
2296 mips_hi16_list = hi->next;
2300 return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2301 input_section, output_bfd,
2305 /* A generic howto special_function. This calculates and installs the
2306 relocation itself, thus avoiding the oft-discussed problems in
2307 bfd_perform_relocation and bfd_install_relocation. */
2309 bfd_reloc_status_type
2310 _bfd_mips_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2311 asymbol *symbol, void *data ATTRIBUTE_UNUSED,
2312 asection *input_section, bfd *output_bfd,
2313 char **error_message ATTRIBUTE_UNUSED)
2316 bfd_reloc_status_type status;
2317 bfd_boolean relocatable;
2319 relocatable = (output_bfd != NULL);
2321 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2322 return bfd_reloc_outofrange;
2324 /* Build up the field adjustment in VAL. */
2326 if (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0)
2328 /* Either we're calculating the final field value or we have a
2329 relocation against a section symbol. Add in the section's
2330 offset or address. */
2331 val += symbol->section->output_section->vma;
2332 val += symbol->section->output_offset;
2337 /* We're calculating the final field value. Add in the symbol's value
2338 and, if pc-relative, subtract the address of the field itself. */
2339 val += symbol->value;
2340 if (reloc_entry->howto->pc_relative)
2342 val -= input_section->output_section->vma;
2343 val -= input_section->output_offset;
2344 val -= reloc_entry->address;
2348 /* VAL is now the final adjustment. If we're keeping this relocation
2349 in the output file, and if the relocation uses a separate addend,
2350 we just need to add VAL to that addend. Otherwise we need to add
2351 VAL to the relocation field itself. */
2352 if (relocatable && !reloc_entry->howto->partial_inplace)
2353 reloc_entry->addend += val;
2356 bfd_byte *location = (bfd_byte *) data + reloc_entry->address;
2358 /* Add in the separate addend, if any. */
2359 val += reloc_entry->addend;
2361 /* Add VAL to the relocation field. */
2362 _bfd_mips_elf_reloc_unshuffle (abfd, reloc_entry->howto->type, FALSE,
2364 status = _bfd_relocate_contents (reloc_entry->howto, abfd, val,
2366 _bfd_mips_elf_reloc_shuffle (abfd, reloc_entry->howto->type, FALSE,
2369 if (status != bfd_reloc_ok)
2374 reloc_entry->address += input_section->output_offset;
2376 return bfd_reloc_ok;
2379 /* Swap an entry in a .gptab section. Note that these routines rely
2380 on the equivalence of the two elements of the union. */
2383 bfd_mips_elf32_swap_gptab_in (bfd *abfd, const Elf32_External_gptab *ex,
2386 in->gt_entry.gt_g_value = H_GET_32 (abfd, ex->gt_entry.gt_g_value);
2387 in->gt_entry.gt_bytes = H_GET_32 (abfd, ex->gt_entry.gt_bytes);
2391 bfd_mips_elf32_swap_gptab_out (bfd *abfd, const Elf32_gptab *in,
2392 Elf32_External_gptab *ex)
2394 H_PUT_32 (abfd, in->gt_entry.gt_g_value, ex->gt_entry.gt_g_value);
2395 H_PUT_32 (abfd, in->gt_entry.gt_bytes, ex->gt_entry.gt_bytes);
2399 bfd_elf32_swap_compact_rel_out (bfd *abfd, const Elf32_compact_rel *in,
2400 Elf32_External_compact_rel *ex)
2402 H_PUT_32 (abfd, in->id1, ex->id1);
2403 H_PUT_32 (abfd, in->num, ex->num);
2404 H_PUT_32 (abfd, in->id2, ex->id2);
2405 H_PUT_32 (abfd, in->offset, ex->offset);
2406 H_PUT_32 (abfd, in->reserved0, ex->reserved0);
2407 H_PUT_32 (abfd, in->reserved1, ex->reserved1);
2411 bfd_elf32_swap_crinfo_out (bfd *abfd, const Elf32_crinfo *in,
2412 Elf32_External_crinfo *ex)
2416 l = (((in->ctype & CRINFO_CTYPE) << CRINFO_CTYPE_SH)
2417 | ((in->rtype & CRINFO_RTYPE) << CRINFO_RTYPE_SH)
2418 | ((in->dist2to & CRINFO_DIST2TO) << CRINFO_DIST2TO_SH)
2419 | ((in->relvaddr & CRINFO_RELVADDR) << CRINFO_RELVADDR_SH));
2420 H_PUT_32 (abfd, l, ex->info);
2421 H_PUT_32 (abfd, in->konst, ex->konst);
2422 H_PUT_32 (abfd, in->vaddr, ex->vaddr);
2425 /* A .reginfo section holds a single Elf32_RegInfo structure. These
2426 routines swap this structure in and out. They are used outside of
2427 BFD, so they are globally visible. */
2430 bfd_mips_elf32_swap_reginfo_in (bfd *abfd, const Elf32_External_RegInfo *ex,
2433 in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask);
2434 in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]);
2435 in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]);
2436 in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]);
2437 in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]);
2438 in->ri_gp_value = H_GET_32 (abfd, ex->ri_gp_value);
2442 bfd_mips_elf32_swap_reginfo_out (bfd *abfd, const Elf32_RegInfo *in,
2443 Elf32_External_RegInfo *ex)
2445 H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask);
2446 H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]);
2447 H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]);
2448 H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]);
2449 H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]);
2450 H_PUT_32 (abfd, in->ri_gp_value, ex->ri_gp_value);
2453 /* In the 64 bit ABI, the .MIPS.options section holds register
2454 information in an Elf64_Reginfo structure. These routines swap
2455 them in and out. They are globally visible because they are used
2456 outside of BFD. These routines are here so that gas can call them
2457 without worrying about whether the 64 bit ABI has been included. */
2460 bfd_mips_elf64_swap_reginfo_in (bfd *abfd, const Elf64_External_RegInfo *ex,
2461 Elf64_Internal_RegInfo *in)
2463 in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask);
2464 in->ri_pad = H_GET_32 (abfd, ex->ri_pad);
2465 in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]);
2466 in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]);
2467 in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]);
2468 in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]);
2469 in->ri_gp_value = H_GET_64 (abfd, ex->ri_gp_value);
2473 bfd_mips_elf64_swap_reginfo_out (bfd *abfd, const Elf64_Internal_RegInfo *in,
2474 Elf64_External_RegInfo *ex)
2476 H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask);
2477 H_PUT_32 (abfd, in->ri_pad, ex->ri_pad);
2478 H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]);
2479 H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]);
2480 H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]);
2481 H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]);
2482 H_PUT_64 (abfd, in->ri_gp_value, ex->ri_gp_value);
2485 /* Swap in an options header. */
2488 bfd_mips_elf_swap_options_in (bfd *abfd, const Elf_External_Options *ex,
2489 Elf_Internal_Options *in)
2491 in->kind = H_GET_8 (abfd, ex->kind);
2492 in->size = H_GET_8 (abfd, ex->size);
2493 in->section = H_GET_16 (abfd, ex->section);
2494 in->info = H_GET_32 (abfd, ex->info);
2497 /* Swap out an options header. */
2500 bfd_mips_elf_swap_options_out (bfd *abfd, const Elf_Internal_Options *in,
2501 Elf_External_Options *ex)
2503 H_PUT_8 (abfd, in->kind, ex->kind);
2504 H_PUT_8 (abfd, in->size, ex->size);
2505 H_PUT_16 (abfd, in->section, ex->section);
2506 H_PUT_32 (abfd, in->info, ex->info);
2509 /* This function is called via qsort() to sort the dynamic relocation
2510 entries by increasing r_symndx value. */
2513 sort_dynamic_relocs (const void *arg1, const void *arg2)
2515 Elf_Internal_Rela int_reloc1;
2516 Elf_Internal_Rela int_reloc2;
2519 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg1, &int_reloc1);
2520 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg2, &int_reloc2);
2522 diff = ELF32_R_SYM (int_reloc1.r_info) - ELF32_R_SYM (int_reloc2.r_info);
2526 if (int_reloc1.r_offset < int_reloc2.r_offset)
2528 if (int_reloc1.r_offset > int_reloc2.r_offset)
2533 /* Like sort_dynamic_relocs, but used for elf64 relocations. */
2536 sort_dynamic_relocs_64 (const void *arg1 ATTRIBUTE_UNUSED,
2537 const void *arg2 ATTRIBUTE_UNUSED)
2540 Elf_Internal_Rela int_reloc1[3];
2541 Elf_Internal_Rela int_reloc2[3];
2543 (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in)
2544 (reldyn_sorting_bfd, arg1, int_reloc1);
2545 (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in)
2546 (reldyn_sorting_bfd, arg2, int_reloc2);
2548 if (ELF64_R_SYM (int_reloc1[0].r_info) < ELF64_R_SYM (int_reloc2[0].r_info))
2550 if (ELF64_R_SYM (int_reloc1[0].r_info) > ELF64_R_SYM (int_reloc2[0].r_info))
2553 if (int_reloc1[0].r_offset < int_reloc2[0].r_offset)
2555 if (int_reloc1[0].r_offset > int_reloc2[0].r_offset)
2564 /* This routine is used to write out ECOFF debugging external symbol
2565 information. It is called via mips_elf_link_hash_traverse. The
2566 ECOFF external symbol information must match the ELF external
2567 symbol information. Unfortunately, at this point we don't know
2568 whether a symbol is required by reloc information, so the two
2569 tables may wind up being different. We must sort out the external
2570 symbol information before we can set the final size of the .mdebug
2571 section, and we must set the size of the .mdebug section before we
2572 can relocate any sections, and we can't know which symbols are
2573 required by relocation until we relocate the sections.
2574 Fortunately, it is relatively unlikely that any symbol will be
2575 stripped but required by a reloc. In particular, it can not happen
2576 when generating a final executable. */
2579 mips_elf_output_extsym (struct mips_elf_link_hash_entry *h, void *data)
2581 struct extsym_info *einfo = data;
2583 asection *sec, *output_section;
2585 if (h->root.indx == -2)
2587 else if ((h->root.def_dynamic
2588 || h->root.ref_dynamic
2589 || h->root.type == bfd_link_hash_new)
2590 && !h->root.def_regular
2591 && !h->root.ref_regular)
2593 else if (einfo->info->strip == strip_all
2594 || (einfo->info->strip == strip_some
2595 && bfd_hash_lookup (einfo->info->keep_hash,
2596 h->root.root.root.string,
2597 FALSE, FALSE) == NULL))
2605 if (h->esym.ifd == -2)
2608 h->esym.cobol_main = 0;
2609 h->esym.weakext = 0;
2610 h->esym.reserved = 0;
2611 h->esym.ifd = ifdNil;
2612 h->esym.asym.value = 0;
2613 h->esym.asym.st = stGlobal;
2615 if (h->root.root.type == bfd_link_hash_undefined
2616 || h->root.root.type == bfd_link_hash_undefweak)
2620 /* Use undefined class. Also, set class and type for some
2622 name = h->root.root.root.string;
2623 if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
2624 || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
2626 h->esym.asym.sc = scData;
2627 h->esym.asym.st = stLabel;
2628 h->esym.asym.value = 0;
2630 else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
2632 h->esym.asym.sc = scAbs;
2633 h->esym.asym.st = stLabel;
2634 h->esym.asym.value =
2635 mips_elf_hash_table (einfo->info)->procedure_count;
2637 else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (einfo->abfd))
2639 h->esym.asym.sc = scAbs;
2640 h->esym.asym.st = stLabel;
2641 h->esym.asym.value = elf_gp (einfo->abfd);
2644 h->esym.asym.sc = scUndefined;
2646 else if (h->root.root.type != bfd_link_hash_defined
2647 && h->root.root.type != bfd_link_hash_defweak)
2648 h->esym.asym.sc = scAbs;
2653 sec = h->root.root.u.def.section;
2654 output_section = sec->output_section;
2656 /* When making a shared library and symbol h is the one from
2657 the another shared library, OUTPUT_SECTION may be null. */
2658 if (output_section == NULL)
2659 h->esym.asym.sc = scUndefined;
2662 name = bfd_section_name (output_section->owner, output_section);
2664 if (strcmp (name, ".text") == 0)
2665 h->esym.asym.sc = scText;
2666 else if (strcmp (name, ".data") == 0)
2667 h->esym.asym.sc = scData;
2668 else if (strcmp (name, ".sdata") == 0)
2669 h->esym.asym.sc = scSData;
2670 else if (strcmp (name, ".rodata") == 0
2671 || strcmp (name, ".rdata") == 0)
2672 h->esym.asym.sc = scRData;
2673 else if (strcmp (name, ".bss") == 0)
2674 h->esym.asym.sc = scBss;
2675 else if (strcmp (name, ".sbss") == 0)
2676 h->esym.asym.sc = scSBss;
2677 else if (strcmp (name, ".init") == 0)
2678 h->esym.asym.sc = scInit;
2679 else if (strcmp (name, ".fini") == 0)
2680 h->esym.asym.sc = scFini;
2682 h->esym.asym.sc = scAbs;
2686 h->esym.asym.reserved = 0;
2687 h->esym.asym.index = indexNil;
2690 if (h->root.root.type == bfd_link_hash_common)
2691 h->esym.asym.value = h->root.root.u.c.size;
2692 else if (h->root.root.type == bfd_link_hash_defined
2693 || h->root.root.type == bfd_link_hash_defweak)
2695 if (h->esym.asym.sc == scCommon)
2696 h->esym.asym.sc = scBss;
2697 else if (h->esym.asym.sc == scSCommon)
2698 h->esym.asym.sc = scSBss;
2700 sec = h->root.root.u.def.section;
2701 output_section = sec->output_section;
2702 if (output_section != NULL)
2703 h->esym.asym.value = (h->root.root.u.def.value
2704 + sec->output_offset
2705 + output_section->vma);
2707 h->esym.asym.value = 0;
2711 struct mips_elf_link_hash_entry *hd = h;
2713 while (hd->root.root.type == bfd_link_hash_indirect)
2714 hd = (struct mips_elf_link_hash_entry *)h->root.root.u.i.link;
2716 if (hd->needs_lazy_stub)
2718 /* Set type and value for a symbol with a function stub. */
2719 h->esym.asym.st = stProc;
2720 sec = hd->root.root.u.def.section;
2722 h->esym.asym.value = 0;
2725 output_section = sec->output_section;
2726 if (output_section != NULL)
2727 h->esym.asym.value = (hd->root.plt.offset
2728 + sec->output_offset
2729 + output_section->vma);
2731 h->esym.asym.value = 0;
2736 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
2737 h->root.root.root.string,
2740 einfo->failed = TRUE;
2747 /* A comparison routine used to sort .gptab entries. */
2750 gptab_compare (const void *p1, const void *p2)
2752 const Elf32_gptab *a1 = p1;
2753 const Elf32_gptab *a2 = p2;
2755 return a1->gt_entry.gt_g_value - a2->gt_entry.gt_g_value;
2758 /* Functions to manage the got entry hash table. */
2760 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
2763 static INLINE hashval_t
2764 mips_elf_hash_bfd_vma (bfd_vma addr)
2767 return addr + (addr >> 32);
2773 /* got_entries only match if they're identical, except for gotidx, so
2774 use all fields to compute the hash, and compare the appropriate
2778 mips_elf_got_entry_hash (const void *entry_)
2780 const struct mips_got_entry *entry = (struct mips_got_entry *)entry_;
2782 return entry->symndx
2783 + ((entry->tls_type & GOT_TLS_LDM) << 17)
2784 + (! entry->abfd ? mips_elf_hash_bfd_vma (entry->d.address)
2786 + (entry->symndx >= 0 ? mips_elf_hash_bfd_vma (entry->d.addend)
2787 : entry->d.h->root.root.root.hash));
2791 mips_elf_got_entry_eq (const void *entry1, const void *entry2)
2793 const struct mips_got_entry *e1 = (struct mips_got_entry *)entry1;
2794 const struct mips_got_entry *e2 = (struct mips_got_entry *)entry2;
2796 /* An LDM entry can only match another LDM entry. */
2797 if ((e1->tls_type ^ e2->tls_type) & GOT_TLS_LDM)
2800 return e1->abfd == e2->abfd && e1->symndx == e2->symndx
2801 && (! e1->abfd ? e1->d.address == e2->d.address
2802 : e1->symndx >= 0 ? e1->d.addend == e2->d.addend
2803 : e1->d.h == e2->d.h);
2806 /* multi_got_entries are still a match in the case of global objects,
2807 even if the input bfd in which they're referenced differs, so the
2808 hash computation and compare functions are adjusted
2812 mips_elf_multi_got_entry_hash (const void *entry_)
2814 const struct mips_got_entry *entry = (struct mips_got_entry *)entry_;
2816 return entry->symndx
2818 ? mips_elf_hash_bfd_vma (entry->d.address)
2819 : entry->symndx >= 0
2820 ? ((entry->tls_type & GOT_TLS_LDM)
2821 ? (GOT_TLS_LDM << 17)
2823 + mips_elf_hash_bfd_vma (entry->d.addend)))
2824 : entry->d.h->root.root.root.hash);
2828 mips_elf_multi_got_entry_eq (const void *entry1, const void *entry2)
2830 const struct mips_got_entry *e1 = (struct mips_got_entry *)entry1;
2831 const struct mips_got_entry *e2 = (struct mips_got_entry *)entry2;
2833 /* Any two LDM entries match. */
2834 if (e1->tls_type & e2->tls_type & GOT_TLS_LDM)
2837 /* Nothing else matches an LDM entry. */
2838 if ((e1->tls_type ^ e2->tls_type) & GOT_TLS_LDM)
2841 return e1->symndx == e2->symndx
2842 && (e1->symndx >= 0 ? e1->abfd == e2->abfd && e1->d.addend == e2->d.addend
2843 : e1->abfd == NULL || e2->abfd == NULL
2844 ? e1->abfd == e2->abfd && e1->d.address == e2->d.address
2845 : e1->d.h == e2->d.h);
2849 mips_got_page_entry_hash (const void *entry_)
2851 const struct mips_got_page_entry *entry;
2853 entry = (const struct mips_got_page_entry *) entry_;
2854 return entry->abfd->id + entry->symndx;
2858 mips_got_page_entry_eq (const void *entry1_, const void *entry2_)
2860 const struct mips_got_page_entry *entry1, *entry2;
2862 entry1 = (const struct mips_got_page_entry *) entry1_;
2863 entry2 = (const struct mips_got_page_entry *) entry2_;
2864 return entry1->abfd == entry2->abfd && entry1->symndx == entry2->symndx;
2867 /* Return the dynamic relocation section. If it doesn't exist, try to
2868 create a new it if CREATE_P, otherwise return NULL. Also return NULL
2869 if creation fails. */
2872 mips_elf_rel_dyn_section (struct bfd_link_info *info, bfd_boolean create_p)
2878 dname = MIPS_ELF_REL_DYN_NAME (info);
2879 dynobj = elf_hash_table (info)->dynobj;
2880 sreloc = bfd_get_linker_section (dynobj, dname);
2881 if (sreloc == NULL && create_p)
2883 sreloc = bfd_make_section_anyway_with_flags (dynobj, dname,
2888 | SEC_LINKER_CREATED
2891 || ! bfd_set_section_alignment (dynobj, sreloc,
2892 MIPS_ELF_LOG_FILE_ALIGN (dynobj)))
2898 /* Count the number of relocations needed for a TLS GOT entry, with
2899 access types from TLS_TYPE, and symbol H (or a local symbol if H
2903 mips_tls_got_relocs (struct bfd_link_info *info, unsigned char tls_type,
2904 struct elf_link_hash_entry *h)
2908 bfd_boolean need_relocs = FALSE;
2909 bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created;
2911 if (h && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2912 && (!info->shared || !SYMBOL_REFERENCES_LOCAL (info, h)))
2915 if ((info->shared || indx != 0)
2917 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2918 || h->root.type != bfd_link_hash_undefweak))
2924 if (tls_type & GOT_TLS_GD)
2931 if (tls_type & GOT_TLS_IE)
2934 if ((tls_type & GOT_TLS_LDM) && info->shared)
2940 /* Count the number of TLS relocations required for the GOT entry in
2941 ARG1, if it describes a local symbol. */
2944 mips_elf_count_local_tls_relocs (void **arg1, void *arg2)
2946 struct mips_got_entry *entry = * (struct mips_got_entry **) arg1;
2947 struct mips_elf_count_tls_arg *arg = arg2;
2949 if (entry->abfd != NULL && entry->symndx != -1)
2950 arg->needed += mips_tls_got_relocs (arg->info, entry->tls_type, NULL);
2955 /* Count the number of TLS GOT entries required for the global (or
2956 forced-local) symbol in ARG1. */
2959 mips_elf_count_global_tls_entries (void *arg1, void *arg2)
2961 struct mips_elf_link_hash_entry *hm
2962 = (struct mips_elf_link_hash_entry *) arg1;
2963 struct mips_elf_count_tls_arg *arg = arg2;
2965 if (hm->tls_type & GOT_TLS_GD)
2967 if (hm->tls_type & GOT_TLS_IE)
2973 /* Count the number of TLS relocations required for the global (or
2974 forced-local) symbol in ARG1. */
2977 mips_elf_count_global_tls_relocs (void *arg1, void *arg2)
2979 struct mips_elf_link_hash_entry *hm
2980 = (struct mips_elf_link_hash_entry *) arg1;
2981 struct mips_elf_count_tls_arg *arg = arg2;
2983 arg->needed += mips_tls_got_relocs (arg->info, hm->tls_type, &hm->root);
2988 /* Output a simple dynamic relocation into SRELOC. */
2991 mips_elf_output_dynamic_relocation (bfd *output_bfd,
2993 unsigned long reloc_index,
2998 Elf_Internal_Rela rel[3];
3000 memset (rel, 0, sizeof (rel));
3002 rel[0].r_info = ELF_R_INFO (output_bfd, indx, r_type);
3003 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
3005 if (ABI_64_P (output_bfd))
3007 (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
3008 (output_bfd, &rel[0],
3010 + reloc_index * sizeof (Elf64_Mips_External_Rel)));
3013 bfd_elf32_swap_reloc_out
3014 (output_bfd, &rel[0],
3016 + reloc_index * sizeof (Elf32_External_Rel)));
3019 /* Initialize a set of TLS GOT entries for one symbol. */
3022 mips_elf_initialize_tls_slots (bfd *abfd, bfd_vma got_offset,
3023 unsigned char *tls_type_p,
3024 struct bfd_link_info *info,
3025 struct mips_elf_link_hash_entry *h,
3028 struct mips_elf_link_hash_table *htab;
3030 asection *sreloc, *sgot;
3031 bfd_vma offset, offset2;
3032 bfd_boolean need_relocs = FALSE;
3034 htab = mips_elf_hash_table (info);
3043 bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created;
3045 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, &h->root)
3046 && (!info->shared || !SYMBOL_REFERENCES_LOCAL (info, &h->root)))
3047 indx = h->root.dynindx;
3050 if (*tls_type_p & GOT_TLS_DONE)
3053 if ((info->shared || indx != 0)
3055 || ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT
3056 || h->root.type != bfd_link_hash_undefweak))
3059 /* MINUS_ONE means the symbol is not defined in this object. It may not
3060 be defined at all; assume that the value doesn't matter in that
3061 case. Otherwise complain if we would use the value. */
3062 BFD_ASSERT (value != MINUS_ONE || (indx != 0 && need_relocs)
3063 || h->root.root.type == bfd_link_hash_undefweak);
3065 /* Emit necessary relocations. */
3066 sreloc = mips_elf_rel_dyn_section (info, FALSE);
3068 /* General Dynamic. */
3069 if (*tls_type_p & GOT_TLS_GD)
3071 offset = got_offset;
3072 offset2 = offset + MIPS_ELF_GOT_SIZE (abfd);
3076 mips_elf_output_dynamic_relocation
3077 (abfd, sreloc, sreloc->reloc_count++, indx,
3078 ABI_64_P (abfd) ? R_MIPS_TLS_DTPMOD64 : R_MIPS_TLS_DTPMOD32,
3079 sgot->output_offset + sgot->output_section->vma + offset);
3082 mips_elf_output_dynamic_relocation
3083 (abfd, sreloc, sreloc->reloc_count++, indx,
3084 ABI_64_P (abfd) ? R_MIPS_TLS_DTPREL64 : R_MIPS_TLS_DTPREL32,
3085 sgot->output_offset + sgot->output_section->vma + offset2);
3087 MIPS_ELF_PUT_WORD (abfd, value - dtprel_base (info),
3088 sgot->contents + offset2);
3092 MIPS_ELF_PUT_WORD (abfd, 1,
3093 sgot->contents + offset);
3094 MIPS_ELF_PUT_WORD (abfd, value - dtprel_base (info),
3095 sgot->contents + offset2);
3098 got_offset += 2 * MIPS_ELF_GOT_SIZE (abfd);
3101 /* Initial Exec model. */
3102 if (*tls_type_p & GOT_TLS_IE)
3104 offset = got_offset;
3109 MIPS_ELF_PUT_WORD (abfd, value - elf_hash_table (info)->tls_sec->vma,
3110 sgot->contents + offset);
3112 MIPS_ELF_PUT_WORD (abfd, 0,
3113 sgot->contents + offset);
3115 mips_elf_output_dynamic_relocation
3116 (abfd, sreloc, sreloc->reloc_count++, indx,
3117 ABI_64_P (abfd) ? R_MIPS_TLS_TPREL64 : R_MIPS_TLS_TPREL32,
3118 sgot->output_offset + sgot->output_section->vma + offset);
3121 MIPS_ELF_PUT_WORD (abfd, value - tprel_base (info),
3122 sgot->contents + offset);
3125 if (*tls_type_p & GOT_TLS_LDM)
3127 /* The initial offset is zero, and the LD offsets will include the
3128 bias by DTP_OFFSET. */
3129 MIPS_ELF_PUT_WORD (abfd, 0,
3130 sgot->contents + got_offset
3131 + MIPS_ELF_GOT_SIZE (abfd));
3134 MIPS_ELF_PUT_WORD (abfd, 1,
3135 sgot->contents + got_offset);
3137 mips_elf_output_dynamic_relocation
3138 (abfd, sreloc, sreloc->reloc_count++, indx,
3139 ABI_64_P (abfd) ? R_MIPS_TLS_DTPMOD64 : R_MIPS_TLS_DTPMOD32,
3140 sgot->output_offset + sgot->output_section->vma + got_offset);
3143 *tls_type_p |= GOT_TLS_DONE;
3146 /* Return the GOT index to use for a relocation of type R_TYPE against
3147 a symbol accessed using TLS_TYPE models. The GOT entries for this
3148 symbol in this GOT start at GOT_INDEX. This function initializes the
3149 GOT entries and corresponding relocations. */
3152 mips_tls_got_index (bfd *abfd, bfd_vma got_index, unsigned char *tls_type,
3153 int r_type, struct bfd_link_info *info,
3154 struct mips_elf_link_hash_entry *h, bfd_vma symbol)
3156 BFD_ASSERT (tls_gottprel_reloc_p (r_type)
3157 || tls_gd_reloc_p (r_type)
3158 || tls_ldm_reloc_p (r_type));
3160 mips_elf_initialize_tls_slots (abfd, got_index, tls_type, info, h, symbol);
3162 if (tls_gottprel_reloc_p (r_type))
3164 BFD_ASSERT (*tls_type & GOT_TLS_IE);
3165 if (*tls_type & GOT_TLS_GD)
3166 return got_index + 2 * MIPS_ELF_GOT_SIZE (abfd);
3171 if (tls_gd_reloc_p (r_type))
3173 BFD_ASSERT (*tls_type & GOT_TLS_GD);
3177 if (tls_ldm_reloc_p (r_type))
3179 BFD_ASSERT (*tls_type & GOT_TLS_LDM);
3186 /* Return the offset from _GLOBAL_OFFSET_TABLE_ of the .got.plt entry
3187 for global symbol H. .got.plt comes before the GOT, so the offset
3188 will be negative. */
3191 mips_elf_gotplt_index (struct bfd_link_info *info,
3192 struct elf_link_hash_entry *h)
3194 bfd_vma plt_index, got_address, got_value;
3195 struct mips_elf_link_hash_table *htab;
3197 htab = mips_elf_hash_table (info);
3198 BFD_ASSERT (htab != NULL);
3200 BFD_ASSERT (h->plt.offset != (bfd_vma) -1);
3202 /* This function only works for VxWorks, because a non-VxWorks .got.plt
3203 section starts with reserved entries. */
3204 BFD_ASSERT (htab->is_vxworks);
3206 /* Calculate the index of the symbol's PLT entry. */
3207 plt_index = (h->plt.offset - htab->plt_header_size) / htab->plt_entry_size;
3209 /* Calculate the address of the associated .got.plt entry. */
3210 got_address = (htab->sgotplt->output_section->vma
3211 + htab->sgotplt->output_offset
3214 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */
3215 got_value = (htab->root.hgot->root.u.def.section->output_section->vma
3216 + htab->root.hgot->root.u.def.section->output_offset
3217 + htab->root.hgot->root.u.def.value);
3219 return got_address - got_value;
3222 /* Return the GOT offset for address VALUE. If there is not yet a GOT
3223 entry for this value, create one. If R_SYMNDX refers to a TLS symbol,
3224 create a TLS GOT entry instead. Return -1 if no satisfactory GOT
3225 offset can be found. */
3228 mips_elf_local_got_index (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
3229 bfd_vma value, unsigned long r_symndx,
3230 struct mips_elf_link_hash_entry *h, int r_type)
3232 struct mips_elf_link_hash_table *htab;
3233 struct mips_got_entry *entry;
3235 htab = mips_elf_hash_table (info);
3236 BFD_ASSERT (htab != NULL);
3238 entry = mips_elf_create_local_got_entry (abfd, info, ibfd, value,
3239 r_symndx, h, r_type);
3243 if (TLS_RELOC_P (r_type))
3245 if (entry->symndx == -1 && htab->got_info->next == NULL)
3246 /* A type (3) entry in the single-GOT case. We use the symbol's
3247 hash table entry to track the index. */
3248 return mips_tls_got_index (abfd, h->tls_got_offset, &h->tls_type,
3249 r_type, info, h, value);
3251 return mips_tls_got_index (abfd, entry->gotidx, &entry->tls_type,
3252 r_type, info, h, value);
3255 return entry->gotidx;
3258 /* Returns the GOT index for the global symbol indicated by H. */
3261 mips_elf_global_got_index (bfd *abfd, bfd *ibfd, struct elf_link_hash_entry *h,
3262 int r_type, struct bfd_link_info *info)
3264 struct mips_elf_link_hash_table *htab;
3266 struct mips_got_info *g, *gg;
3267 long global_got_dynindx = 0;
3269 htab = mips_elf_hash_table (info);
3270 BFD_ASSERT (htab != NULL);
3272 gg = g = htab->got_info;
3273 if (g->bfd2got && ibfd)
3275 struct mips_got_entry e, *p;
3277 BFD_ASSERT (h->dynindx >= 0);
3279 g = mips_elf_got_for_ibfd (g, ibfd);
3280 if (g->next != gg || TLS_RELOC_P (r_type))
3284 e.d.h = (struct mips_elf_link_hash_entry *)h;
3287 p = htab_find (g->got_entries, &e);
3289 BFD_ASSERT (p->gotidx > 0);
3291 if (TLS_RELOC_P (r_type))
3293 bfd_vma value = MINUS_ONE;
3294 if ((h->root.type == bfd_link_hash_defined
3295 || h->root.type == bfd_link_hash_defweak)
3296 && h->root.u.def.section->output_section)
3297 value = (h->root.u.def.value
3298 + h->root.u.def.section->output_offset
3299 + h->root.u.def.section->output_section->vma);
3301 return mips_tls_got_index (abfd, p->gotidx, &p->tls_type, r_type,
3302 info, e.d.h, value);
3309 if (gg->global_gotsym != NULL)
3310 global_got_dynindx = gg->global_gotsym->dynindx;
3312 if (TLS_RELOC_P (r_type))
3314 struct mips_elf_link_hash_entry *hm
3315 = (struct mips_elf_link_hash_entry *) h;
3316 bfd_vma value = MINUS_ONE;
3318 if ((h->root.type == bfd_link_hash_defined
3319 || h->root.type == bfd_link_hash_defweak)
3320 && h->root.u.def.section->output_section)
3321 value = (h->root.u.def.value
3322 + h->root.u.def.section->output_offset
3323 + h->root.u.def.section->output_section->vma);
3325 got_index = mips_tls_got_index (abfd, hm->tls_got_offset, &hm->tls_type,
3326 r_type, info, hm, value);
3330 /* Once we determine the global GOT entry with the lowest dynamic
3331 symbol table index, we must put all dynamic symbols with greater
3332 indices into the GOT. That makes it easy to calculate the GOT
3334 BFD_ASSERT (h->dynindx >= global_got_dynindx);
3335 got_index = ((h->dynindx - global_got_dynindx + g->local_gotno)
3336 * MIPS_ELF_GOT_SIZE (abfd));
3338 BFD_ASSERT (got_index < htab->sgot->size);
3343 /* Find a GOT page entry that points to within 32KB of VALUE. These
3344 entries are supposed to be placed at small offsets in the GOT, i.e.,
3345 within 32KB of GP. Return the index of the GOT entry, or -1 if no
3346 entry could be created. If OFFSETP is nonnull, use it to return the
3347 offset of the GOT entry from VALUE. */
3350 mips_elf_got_page (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
3351 bfd_vma value, bfd_vma *offsetp)
3353 bfd_vma page, got_index;
3354 struct mips_got_entry *entry;
3356 page = (value + 0x8000) & ~(bfd_vma) 0xffff;
3357 entry = mips_elf_create_local_got_entry (abfd, info, ibfd, page, 0,
3358 NULL, R_MIPS_GOT_PAGE);
3363 got_index = entry->gotidx;
3366 *offsetp = value - entry->d.address;
3371 /* Find a local GOT entry for an R_MIPS*_GOT16 relocation against VALUE.
3372 EXTERNAL is true if the relocation was originally against a global
3373 symbol that binds locally. */
3376 mips_elf_got16_entry (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
3377 bfd_vma value, bfd_boolean external)
3379 struct mips_got_entry *entry;
3381 /* GOT16 relocations against local symbols are followed by a LO16
3382 relocation; those against global symbols are not. Thus if the
3383 symbol was originally local, the GOT16 relocation should load the
3384 equivalent of %hi(VALUE), otherwise it should load VALUE itself. */
3386 value = mips_elf_high (value) << 16;
3388 /* It doesn't matter whether the original relocation was R_MIPS_GOT16,
3389 R_MIPS16_GOT16, R_MIPS_CALL16, etc. The format of the entry is the
3390 same in all cases. */
3391 entry = mips_elf_create_local_got_entry (abfd, info, ibfd, value, 0,
3392 NULL, R_MIPS_GOT16);
3394 return entry->gotidx;
3399 /* Returns the offset for the entry at the INDEXth position
3403 mips_elf_got_offset_from_index (struct bfd_link_info *info, bfd *output_bfd,
3404 bfd *input_bfd, bfd_vma got_index)
3406 struct mips_elf_link_hash_table *htab;
3410 htab = mips_elf_hash_table (info);
3411 BFD_ASSERT (htab != NULL);
3414 gp = _bfd_get_gp_value (output_bfd)
3415 + mips_elf_adjust_gp (output_bfd, htab->got_info, input_bfd);
3417 return sgot->output_section->vma + sgot->output_offset + got_index - gp;
3420 /* Create and return a local GOT entry for VALUE, which was calculated
3421 from a symbol belonging to INPUT_SECTON. Return NULL if it could not
3422 be created. If R_SYMNDX refers to a TLS symbol, create a TLS entry
3425 static struct mips_got_entry *
3426 mips_elf_create_local_got_entry (bfd *abfd, struct bfd_link_info *info,
3427 bfd *ibfd, bfd_vma value,
3428 unsigned long r_symndx,
3429 struct mips_elf_link_hash_entry *h,
3432 struct mips_got_entry entry, **loc;
3433 struct mips_got_info *g;
3434 struct mips_elf_link_hash_table *htab;
3436 htab = mips_elf_hash_table (info);
3437 BFD_ASSERT (htab != NULL);
3441 entry.d.address = value;
3444 g = mips_elf_got_for_ibfd (htab->got_info, ibfd);
3447 g = mips_elf_got_for_ibfd (htab->got_info, abfd);
3448 BFD_ASSERT (g != NULL);
3451 /* This function shouldn't be called for symbols that live in the global
3453 BFD_ASSERT (h == NULL || h->global_got_area == GGA_NONE);
3454 if (TLS_RELOC_P (r_type))
3456 struct mips_got_entry *p;
3459 if (tls_ldm_reloc_p (r_type))
3461 entry.tls_type = GOT_TLS_LDM;
3467 entry.symndx = r_symndx;
3473 p = (struct mips_got_entry *)
3474 htab_find (g->got_entries, &entry);
3480 loc = (struct mips_got_entry **) htab_find_slot (g->got_entries, &entry,
3485 entry.gotidx = MIPS_ELF_GOT_SIZE (abfd) * g->assigned_gotno++;
3488 *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry);
3493 memcpy (*loc, &entry, sizeof entry);
3495 if (g->assigned_gotno > g->local_gotno)
3497 (*loc)->gotidx = -1;
3498 /* We didn't allocate enough space in the GOT. */
3499 (*_bfd_error_handler)
3500 (_("not enough GOT space for local GOT entries"));
3501 bfd_set_error (bfd_error_bad_value);
3505 MIPS_ELF_PUT_WORD (abfd, value,
3506 (htab->sgot->contents + entry.gotidx));
3508 /* These GOT entries need a dynamic relocation on VxWorks. */
3509 if (htab->is_vxworks)
3511 Elf_Internal_Rela outrel;
3514 bfd_vma got_address;
3516 s = mips_elf_rel_dyn_section (info, FALSE);
3517 got_address = (htab->sgot->output_section->vma
3518 + htab->sgot->output_offset
3521 rloc = s->contents + (s->reloc_count++ * sizeof (Elf32_External_Rela));
3522 outrel.r_offset = got_address;
3523 outrel.r_info = ELF32_R_INFO (STN_UNDEF, R_MIPS_32);
3524 outrel.r_addend = value;
3525 bfd_elf32_swap_reloca_out (abfd, &outrel, rloc);
3531 /* Return the number of dynamic section symbols required by OUTPUT_BFD.
3532 The number might be exact or a worst-case estimate, depending on how
3533 much information is available to elf_backend_omit_section_dynsym at
3534 the current linking stage. */
3536 static bfd_size_type
3537 count_section_dynsyms (bfd *output_bfd, struct bfd_link_info *info)
3539 bfd_size_type count;
3542 if (info->shared || elf_hash_table (info)->is_relocatable_executable)
3545 const struct elf_backend_data *bed;
3547 bed = get_elf_backend_data (output_bfd);
3548 for (p = output_bfd->sections; p ; p = p->next)
3549 if ((p->flags & SEC_EXCLUDE) == 0
3550 && (p->flags & SEC_ALLOC) != 0
3551 && !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p))
3557 /* Sort the dynamic symbol table so that symbols that need GOT entries
3558 appear towards the end. */
3561 mips_elf_sort_hash_table (bfd *abfd, struct bfd_link_info *info)
3563 struct mips_elf_link_hash_table *htab;
3564 struct mips_elf_hash_sort_data hsd;
3565 struct mips_got_info *g;
3567 if (elf_hash_table (info)->dynsymcount == 0)
3570 htab = mips_elf_hash_table (info);
3571 BFD_ASSERT (htab != NULL);
3578 hsd.max_unref_got_dynindx
3579 = hsd.min_got_dynindx
3580 = (elf_hash_table (info)->dynsymcount - g->reloc_only_gotno);
3581 hsd.max_non_got_dynindx = count_section_dynsyms (abfd, info) + 1;
3582 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table *)
3583 elf_hash_table (info)),
3584 mips_elf_sort_hash_table_f,
3587 /* There should have been enough room in the symbol table to
3588 accommodate both the GOT and non-GOT symbols. */
3589 BFD_ASSERT (hsd.max_non_got_dynindx <= hsd.min_got_dynindx);
3590 BFD_ASSERT ((unsigned long) hsd.max_unref_got_dynindx
3591 == elf_hash_table (info)->dynsymcount);
3592 BFD_ASSERT (elf_hash_table (info)->dynsymcount - hsd.min_got_dynindx
3593 == g->global_gotno);
3595 /* Now we know which dynamic symbol has the lowest dynamic symbol
3596 table index in the GOT. */
3597 g->global_gotsym = hsd.low;
3602 /* If H needs a GOT entry, assign it the highest available dynamic
3603 index. Otherwise, assign it the lowest available dynamic
3607 mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry *h, void *data)
3609 struct mips_elf_hash_sort_data *hsd = data;
3611 /* Symbols without dynamic symbol table entries aren't interesting
3613 if (h->root.dynindx == -1)
3616 switch (h->global_got_area)
3619 h->root.dynindx = hsd->max_non_got_dynindx++;
3623 BFD_ASSERT (h->tls_type == GOT_NORMAL);
3625 h->root.dynindx = --hsd->min_got_dynindx;
3626 hsd->low = (struct elf_link_hash_entry *) h;
3629 case GGA_RELOC_ONLY:
3630 BFD_ASSERT (h->tls_type == GOT_NORMAL);
3632 if (hsd->max_unref_got_dynindx == hsd->min_got_dynindx)
3633 hsd->low = (struct elf_link_hash_entry *) h;
3634 h->root.dynindx = hsd->max_unref_got_dynindx++;
3641 /* If H is a symbol that needs a global GOT entry, but has a dynamic
3642 symbol table index lower than any we've seen to date, record it for
3643 posterity. FOR_CALL is true if the caller is only interested in
3644 using the GOT entry for calls. */
3647 mips_elf_record_global_got_symbol (struct elf_link_hash_entry *h,
3648 bfd *abfd, struct bfd_link_info *info,
3649 bfd_boolean for_call,
3650 unsigned char tls_flag)
3652 struct mips_elf_link_hash_table *htab;
3653 struct mips_elf_link_hash_entry *hmips;
3654 struct mips_got_entry entry, **loc;
3655 struct mips_got_info *g;
3657 htab = mips_elf_hash_table (info);
3658 BFD_ASSERT (htab != NULL);
3660 hmips = (struct mips_elf_link_hash_entry *) h;
3662 hmips->got_only_for_calls = FALSE;
3664 /* A global symbol in the GOT must also be in the dynamic symbol
3666 if (h->dynindx == -1)
3668 switch (ELF_ST_VISIBILITY (h->other))
3672 _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
3675 if (!bfd_elf_link_record_dynamic_symbol (info, h))
3679 /* Make sure we have a GOT to put this entry into. */
3681 BFD_ASSERT (g != NULL);
3685 entry.d.h = (struct mips_elf_link_hash_entry *) h;
3688 loc = (struct mips_got_entry **) htab_find_slot (g->got_entries, &entry,
3691 /* If we've already marked this entry as needing GOT space, we don't
3692 need to do it again. */
3695 (*loc)->tls_type |= tls_flag;
3699 *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry);
3705 entry.tls_type = tls_flag;
3707 memcpy (*loc, &entry, sizeof entry);
3710 hmips->global_got_area = GGA_NORMAL;
3715 /* Reserve space in G for a GOT entry containing the value of symbol
3716 SYMNDX in input bfd ABDF, plus ADDEND. */
3719 mips_elf_record_local_got_symbol (bfd *abfd, long symndx, bfd_vma addend,
3720 struct bfd_link_info *info,
3721 unsigned char tls_flag)
3723 struct mips_elf_link_hash_table *htab;
3724 struct mips_got_info *g;
3725 struct mips_got_entry entry, **loc;
3727 htab = mips_elf_hash_table (info);
3728 BFD_ASSERT (htab != NULL);
3731 BFD_ASSERT (g != NULL);
3734 entry.symndx = symndx;
3735 entry.d.addend = addend;
3736 entry.tls_type = tls_flag;
3737 loc = (struct mips_got_entry **)
3738 htab_find_slot (g->got_entries, &entry, INSERT);
3742 if (tls_flag == GOT_TLS_GD && !((*loc)->tls_type & GOT_TLS_GD))
3745 (*loc)->tls_type |= tls_flag;
3747 else if (tls_flag == GOT_TLS_IE && !((*loc)->tls_type & GOT_TLS_IE))
3750 (*loc)->tls_type |= tls_flag;
3758 entry.tls_type = tls_flag;
3759 if (tls_flag == GOT_TLS_IE)
3761 else if (tls_flag == GOT_TLS_GD)
3763 else if (g->tls_ldm_offset == MINUS_ONE)
3765 g->tls_ldm_offset = MINUS_TWO;
3771 entry.gotidx = g->local_gotno++;
3775 *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry);
3780 memcpy (*loc, &entry, sizeof entry);
3785 /* Return the maximum number of GOT page entries required for RANGE. */
3788 mips_elf_pages_for_range (const struct mips_got_page_range *range)
3790 return (range->max_addend - range->min_addend + 0x1ffff) >> 16;
3793 /* Record that ABFD has a page relocation against symbol SYMNDX and
3794 that ADDEND is the addend for that relocation.
3796 This function creates an upper bound on the number of GOT slots
3797 required; no attempt is made to combine references to non-overridable
3798 global symbols across multiple input files. */
3801 mips_elf_record_got_page_entry (struct bfd_link_info *info, bfd *abfd,
3802 long symndx, bfd_signed_vma addend)
3804 struct mips_elf_link_hash_table *htab;
3805 struct mips_got_info *g;
3806 struct mips_got_page_entry lookup, *entry;
3807 struct mips_got_page_range **range_ptr, *range;
3808 bfd_vma old_pages, new_pages;
3811 htab = mips_elf_hash_table (info);
3812 BFD_ASSERT (htab != NULL);
3815 BFD_ASSERT (g != NULL);
3817 /* Find the mips_got_page_entry hash table entry for this symbol. */
3819 lookup.symndx = symndx;
3820 loc = htab_find_slot (g->got_page_entries, &lookup, INSERT);
3824 /* Create a mips_got_page_entry if this is the first time we've
3826 entry = (struct mips_got_page_entry *) *loc;
3829 entry = bfd_alloc (abfd, sizeof (*entry));
3834 entry->symndx = symndx;
3835 entry->ranges = NULL;
3836 entry->num_pages = 0;
3840 /* Skip over ranges whose maximum extent cannot share a page entry
3842 range_ptr = &entry->ranges;
3843 while (*range_ptr && addend > (*range_ptr)->max_addend + 0xffff)
3844 range_ptr = &(*range_ptr)->next;
3846 /* If we scanned to the end of the list, or found a range whose
3847 minimum extent cannot share a page entry with ADDEND, create
3848 a new singleton range. */
3850 if (!range || addend < range->min_addend - 0xffff)
3852 range = bfd_alloc (abfd, sizeof (*range));
3856 range->next = *range_ptr;
3857 range->min_addend = addend;
3858 range->max_addend = addend;
3866 /* Remember how many pages the old range contributed. */
3867 old_pages = mips_elf_pages_for_range (range);
3869 /* Update the ranges. */
3870 if (addend < range->min_addend)
3871 range->min_addend = addend;
3872 else if (addend > range->max_addend)
3874 if (range->next && addend >= range->next->min_addend - 0xffff)
3876 old_pages += mips_elf_pages_for_range (range->next);
3877 range->max_addend = range->next->max_addend;
3878 range->next = range->next->next;
3881 range->max_addend = addend;
3884 /* Record any change in the total estimate. */
3885 new_pages = mips_elf_pages_for_range (range);
3886 if (old_pages != new_pages)
3888 entry->num_pages += new_pages - old_pages;
3889 g->page_gotno += new_pages - old_pages;
3895 /* Add room for N relocations to the .rel(a).dyn section in ABFD. */
3898 mips_elf_allocate_dynamic_relocations (bfd *abfd, struct bfd_link_info *info,
3902 struct mips_elf_link_hash_table *htab;
3904 htab = mips_elf_hash_table (info);
3905 BFD_ASSERT (htab != NULL);
3907 s = mips_elf_rel_dyn_section (info, FALSE);
3908 BFD_ASSERT (s != NULL);
3910 if (htab->is_vxworks)
3911 s->size += n * MIPS_ELF_RELA_SIZE (abfd);
3916 /* Make room for a null element. */
3917 s->size += MIPS_ELF_REL_SIZE (abfd);
3920 s->size += n * MIPS_ELF_REL_SIZE (abfd);
3924 /* A htab_traverse callback for GOT entries. Set boolean *DATA to true
3925 if the GOT entry is for an indirect or warning symbol. */
3928 mips_elf_check_recreate_got (void **entryp, void *data)
3930 struct mips_got_entry *entry;
3931 bfd_boolean *must_recreate;
3933 entry = (struct mips_got_entry *) *entryp;
3934 must_recreate = (bfd_boolean *) data;
3935 if (entry->abfd != NULL && entry->symndx == -1)
3937 struct mips_elf_link_hash_entry *h;
3940 if (h->root.root.type == bfd_link_hash_indirect
3941 || h->root.root.type == bfd_link_hash_warning)
3943 *must_recreate = TRUE;
3950 /* A htab_traverse callback for GOT entries. Add all entries to
3951 hash table *DATA, converting entries for indirect and warning
3952 symbols into entries for the target symbol. Set *DATA to null
3956 mips_elf_recreate_got (void **entryp, void *data)
3959 struct mips_got_entry *entry;
3962 new_got = (htab_t *) data;
3963 entry = (struct mips_got_entry *) *entryp;
3964 if (entry->abfd != NULL && entry->symndx == -1)
3966 struct mips_elf_link_hash_entry *h;
3969 while (h->root.root.type == bfd_link_hash_indirect
3970 || h->root.root.type == bfd_link_hash_warning)
3972 BFD_ASSERT (h->global_got_area == GGA_NONE);
3973 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
3977 slot = htab_find_slot (*new_got, entry, INSERT);
3990 /* If any entries in G->got_entries are for indirect or warning symbols,
3991 replace them with entries for the target symbol. */
3994 mips_elf_resolve_final_got_entries (struct mips_got_info *g)
3996 bfd_boolean must_recreate;
3999 must_recreate = FALSE;
4000 htab_traverse (g->got_entries, mips_elf_check_recreate_got, &must_recreate);
4003 new_got = htab_create (htab_size (g->got_entries),
4004 mips_elf_got_entry_hash,
4005 mips_elf_got_entry_eq, NULL);
4006 htab_traverse (g->got_entries, mips_elf_recreate_got, &new_got);
4007 if (new_got == NULL)
4010 /* Each entry in g->got_entries has either been copied to new_got
4011 or freed. Now delete the hash table itself. */
4012 htab_delete (g->got_entries);
4013 g->got_entries = new_got;
4018 /* A mips_elf_link_hash_traverse callback for which DATA points
4019 to the link_info structure. Count the number of type (3) entries
4020 in the master GOT. */
4023 mips_elf_count_got_symbols (struct mips_elf_link_hash_entry *h, void *data)
4025 struct bfd_link_info *info;
4026 struct mips_elf_link_hash_table *htab;
4027 struct mips_got_info *g;
4029 info = (struct bfd_link_info *) data;
4030 htab = mips_elf_hash_table (info);
4032 if (h->global_got_area != GGA_NONE)
4034 /* Make a final decision about whether the symbol belongs in the
4035 local or global GOT. Symbols that bind locally can (and in the
4036 case of forced-local symbols, must) live in the local GOT.
4037 Those that are aren't in the dynamic symbol table must also
4038 live in the local GOT.
4040 Note that the former condition does not always imply the
4041 latter: symbols do not bind locally if they are completely
4042 undefined. We'll report undefined symbols later if appropriate. */
4043 if (h->root.dynindx == -1
4044 || (h->got_only_for_calls
4045 ? SYMBOL_CALLS_LOCAL (info, &h->root)
4046 : SYMBOL_REFERENCES_LOCAL (info, &h->root)))
4048 /* The symbol belongs in the local GOT. We no longer need this
4049 entry if it was only used for relocations; those relocations
4050 will be against the null or section symbol instead of H. */
4051 if (h->global_got_area != GGA_RELOC_ONLY)
4053 h->global_got_area = GGA_NONE;
4055 else if (htab->is_vxworks
4056 && h->got_only_for_calls
4057 && h->root.plt.offset != MINUS_ONE)
4058 /* On VxWorks, calls can refer directly to the .got.plt entry;
4059 they don't need entries in the regular GOT. .got.plt entries
4060 will be allocated by _bfd_mips_elf_adjust_dynamic_symbol. */
4061 h->global_got_area = GGA_NONE;
4065 if (h->global_got_area == GGA_RELOC_ONLY)
4066 g->reloc_only_gotno++;
4072 /* Compute the hash value of the bfd in a bfd2got hash entry. */
4075 mips_elf_bfd2got_entry_hash (const void *entry_)
4077 const struct mips_elf_bfd2got_hash *entry
4078 = (struct mips_elf_bfd2got_hash *)entry_;
4080 return entry->bfd->id;
4083 /* Check whether two hash entries have the same bfd. */
4086 mips_elf_bfd2got_entry_eq (const void *entry1, const void *entry2)
4088 const struct mips_elf_bfd2got_hash *e1
4089 = (const struct mips_elf_bfd2got_hash *)entry1;
4090 const struct mips_elf_bfd2got_hash *e2
4091 = (const struct mips_elf_bfd2got_hash *)entry2;
4093 return e1->bfd == e2->bfd;
4096 /* In a multi-got link, determine the GOT to be used for IBFD. G must
4097 be the master GOT data. */
4099 static struct mips_got_info *
4100 mips_elf_got_for_ibfd (struct mips_got_info *g, bfd *ibfd)
4102 struct mips_elf_bfd2got_hash e, *p;
4108 p = htab_find (g->bfd2got, &e);
4109 return p ? p->g : NULL;
4112 /* Use BFD2GOT to find ABFD's got entry, creating one if none exists.
4113 Return NULL if an error occured. */
4115 static struct mips_got_info *
4116 mips_elf_get_got_for_bfd (struct htab *bfd2got, bfd *output_bfd,
4119 struct mips_elf_bfd2got_hash bfdgot_entry, *bfdgot;
4120 struct mips_got_info *g;
4123 bfdgot_entry.bfd = input_bfd;
4124 bfdgotp = htab_find_slot (bfd2got, &bfdgot_entry, INSERT);
4125 bfdgot = (struct mips_elf_bfd2got_hash *) *bfdgotp;
4129 bfdgot = ((struct mips_elf_bfd2got_hash *)
4130 bfd_alloc (output_bfd, sizeof (struct mips_elf_bfd2got_hash)));
4136 g = ((struct mips_got_info *)
4137 bfd_alloc (output_bfd, sizeof (struct mips_got_info)));
4141 bfdgot->bfd = input_bfd;
4144 g->global_gotsym = NULL;
4145 g->global_gotno = 0;
4146 g->reloc_only_gotno = 0;
4149 g->assigned_gotno = -1;
4151 g->tls_assigned_gotno = 0;
4152 g->tls_ldm_offset = MINUS_ONE;
4153 g->got_entries = htab_try_create (1, mips_elf_multi_got_entry_hash,
4154 mips_elf_multi_got_entry_eq, NULL);
4155 if (g->got_entries == NULL)
4158 g->got_page_entries = htab_try_create (1, mips_got_page_entry_hash,
4159 mips_got_page_entry_eq, NULL);
4160 if (g->got_page_entries == NULL)
4170 /* A htab_traverse callback for the entries in the master got.
4171 Create one separate got for each bfd that has entries in the global
4172 got, such that we can tell how many local and global entries each
4176 mips_elf_make_got_per_bfd (void **entryp, void *p)
4178 struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
4179 struct mips_elf_got_per_bfd_arg *arg = (struct mips_elf_got_per_bfd_arg *)p;
4180 struct mips_got_info *g;
4182 g = mips_elf_get_got_for_bfd (arg->bfd2got, arg->obfd, entry->abfd);
4189 /* Insert the GOT entry in the bfd's got entry hash table. */
4190 entryp = htab_find_slot (g->got_entries, entry, INSERT);
4191 if (*entryp != NULL)
4196 if (entry->tls_type)
4198 if (entry->tls_type & (GOT_TLS_GD | GOT_TLS_LDM))
4200 if (entry->tls_type & GOT_TLS_IE)
4203 else if (entry->symndx >= 0 || entry->d.h->global_got_area == GGA_NONE)
4211 /* A htab_traverse callback for the page entries in the master got.
4212 Associate each page entry with the bfd's got. */
4215 mips_elf_make_got_pages_per_bfd (void **entryp, void *p)
4217 struct mips_got_page_entry *entry = (struct mips_got_page_entry *) *entryp;
4218 struct mips_elf_got_per_bfd_arg *arg = (struct mips_elf_got_per_bfd_arg *) p;
4219 struct mips_got_info *g;
4221 g = mips_elf_get_got_for_bfd (arg->bfd2got, arg->obfd, entry->abfd);
4228 /* Insert the GOT entry in the bfd's got entry hash table. */
4229 entryp = htab_find_slot (g->got_page_entries, entry, INSERT);
4230 if (*entryp != NULL)
4234 g->page_gotno += entry->num_pages;
4238 /* Consider merging the got described by BFD2GOT with TO, using the
4239 information given by ARG. Return -1 if this would lead to overflow,
4240 1 if they were merged successfully, and 0 if a merge failed due to
4241 lack of memory. (These values are chosen so that nonnegative return
4242 values can be returned by a htab_traverse callback.) */
4245 mips_elf_merge_got_with (struct mips_elf_bfd2got_hash *bfd2got,
4246 struct mips_got_info *to,
4247 struct mips_elf_got_per_bfd_arg *arg)
4249 struct mips_got_info *from = bfd2got->g;
4250 unsigned int estimate;
4252 /* Work out how many page entries we would need for the combined GOT. */
4253 estimate = arg->max_pages;
4254 if (estimate >= from->page_gotno + to->page_gotno)
4255 estimate = from->page_gotno + to->page_gotno;
4257 /* And conservatively estimate how many local and TLS entries
4259 estimate += from->local_gotno + to->local_gotno;
4260 estimate += from->tls_gotno + to->tls_gotno;
4262 /* If we're merging with the primary got, we will always have
4263 the full set of global entries. Otherwise estimate those
4264 conservatively as well. */
4265 if (to == arg->primary)
4266 estimate += arg->global_count;
4268 estimate += from->global_gotno + to->global_gotno;
4270 /* Bail out if the combined GOT might be too big. */
4271 if (estimate > arg->max_count)
4274 /* Commit to the merge. Record that TO is now the bfd for this got. */
4277 /* Transfer the bfd's got information from FROM to TO. */
4278 htab_traverse (from->got_entries, mips_elf_make_got_per_bfd, arg);
4279 if (arg->obfd == NULL)
4282 htab_traverse (from->got_page_entries, mips_elf_make_got_pages_per_bfd, arg);
4283 if (arg->obfd == NULL)
4286 /* We don't have to worry about releasing memory of the actual
4287 got entries, since they're all in the master got_entries hash
4289 htab_delete (from->got_entries);
4290 htab_delete (from->got_page_entries);
4294 /* Attempt to merge gots of different input bfds. Try to use as much
4295 as possible of the primary got, since it doesn't require explicit
4296 dynamic relocations, but don't use bfds that would reference global
4297 symbols out of the addressable range. Failing the primary got,
4298 attempt to merge with the current got, or finish the current got
4299 and then make make the new got current. */
4302 mips_elf_merge_gots (void **bfd2got_, void *p)
4304 struct mips_elf_bfd2got_hash *bfd2got
4305 = (struct mips_elf_bfd2got_hash *)*bfd2got_;
4306 struct mips_elf_got_per_bfd_arg *arg = (struct mips_elf_got_per_bfd_arg *)p;
4307 struct mips_got_info *g;
4308 unsigned int estimate;
4313 /* Work out the number of page, local and TLS entries. */
4314 estimate = arg->max_pages;
4315 if (estimate > g->page_gotno)
4316 estimate = g->page_gotno;
4317 estimate += g->local_gotno + g->tls_gotno;
4319 /* We place TLS GOT entries after both locals and globals. The globals
4320 for the primary GOT may overflow the normal GOT size limit, so be
4321 sure not to merge a GOT which requires TLS with the primary GOT in that
4322 case. This doesn't affect non-primary GOTs. */
4323 estimate += (g->tls_gotno > 0 ? arg->global_count : g->global_gotno);
4325 if (estimate <= arg->max_count)
4327 /* If we don't have a primary GOT, use it as
4328 a starting point for the primary GOT. */
4331 arg->primary = bfd2got->g;
4335 /* Try merging with the primary GOT. */
4336 result = mips_elf_merge_got_with (bfd2got, arg->primary, arg);
4341 /* If we can merge with the last-created got, do it. */
4344 result = mips_elf_merge_got_with (bfd2got, arg->current, arg);
4349 /* Well, we couldn't merge, so create a new GOT. Don't check if it
4350 fits; if it turns out that it doesn't, we'll get relocation
4351 overflows anyway. */
4352 g->next = arg->current;
4358 /* Set the TLS GOT index for the GOT entry in ENTRYP. ENTRYP's NEXT field
4359 is null iff there is just a single GOT. */
4362 mips_elf_initialize_tls_index (void **entryp, void *p)
4364 struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
4365 struct mips_got_info *g = p;
4367 unsigned char tls_type;
4369 /* We're only interested in TLS symbols. */
4370 if (entry->tls_type == 0)
4373 next_index = MIPS_ELF_GOT_SIZE (entry->abfd) * (long) g->tls_assigned_gotno;
4375 if (entry->symndx == -1 && g->next == NULL)
4377 /* A type (3) got entry in the single-GOT case. We use the symbol's
4378 hash table entry to track its index. */
4379 if (entry->d.h->tls_type & GOT_TLS_OFFSET_DONE)
4381 entry->d.h->tls_type |= GOT_TLS_OFFSET_DONE;
4382 entry->d.h->tls_got_offset = next_index;
4383 tls_type = entry->d.h->tls_type;
4387 if (entry->tls_type & GOT_TLS_LDM)
4389 /* There are separate mips_got_entry objects for each input bfd
4390 that requires an LDM entry. Make sure that all LDM entries in
4391 a GOT resolve to the same index. */
4392 if (g->tls_ldm_offset != MINUS_TWO && g->tls_ldm_offset != MINUS_ONE)
4394 entry->gotidx = g->tls_ldm_offset;
4397 g->tls_ldm_offset = next_index;
4399 entry->gotidx = next_index;
4400 tls_type = entry->tls_type;
4403 /* Account for the entries we've just allocated. */
4404 if (tls_type & (GOT_TLS_GD | GOT_TLS_LDM))
4405 g->tls_assigned_gotno += 2;
4406 if (tls_type & GOT_TLS_IE)
4407 g->tls_assigned_gotno += 1;
4412 /* If passed a NULL mips_got_info in the argument, set the marker used
4413 to tell whether a global symbol needs a got entry (in the primary
4414 got) to the given VALUE.
4416 If passed a pointer G to a mips_got_info in the argument (it must
4417 not be the primary GOT), compute the offset from the beginning of
4418 the (primary) GOT section to the entry in G corresponding to the
4419 global symbol. G's assigned_gotno must contain the index of the
4420 first available global GOT entry in G. VALUE must contain the size
4421 of a GOT entry in bytes. For each global GOT entry that requires a
4422 dynamic relocation, NEEDED_RELOCS is incremented, and the symbol is
4423 marked as not eligible for lazy resolution through a function
4426 mips_elf_set_global_got_offset (void **entryp, void *p)
4428 struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
4429 struct mips_elf_set_global_got_offset_arg *arg
4430 = (struct mips_elf_set_global_got_offset_arg *)p;
4431 struct mips_got_info *g = arg->g;
4433 if (g && entry->tls_type != GOT_NORMAL)
4434 arg->needed_relocs +=
4435 mips_tls_got_relocs (arg->info, entry->tls_type,
4436 entry->symndx == -1 ? &entry->d.h->root : NULL);
4438 if (entry->abfd != NULL
4439 && entry->symndx == -1
4440 && entry->d.h->global_got_area != GGA_NONE)
4444 BFD_ASSERT (g->global_gotsym == NULL);
4446 entry->gotidx = arg->value * (long) g->assigned_gotno++;
4447 if (arg->info->shared
4448 || (elf_hash_table (arg->info)->dynamic_sections_created
4449 && entry->d.h->root.def_dynamic
4450 && !entry->d.h->root.def_regular))
4451 ++arg->needed_relocs;
4454 entry->d.h->global_got_area = arg->value;
4460 /* A htab_traverse callback for GOT entries for which DATA is the
4461 bfd_link_info. Forbid any global symbols from having traditional
4462 lazy-binding stubs. */
4465 mips_elf_forbid_lazy_stubs (void **entryp, void *data)
4467 struct bfd_link_info *info;
4468 struct mips_elf_link_hash_table *htab;
4469 struct mips_got_entry *entry;
4471 entry = (struct mips_got_entry *) *entryp;
4472 info = (struct bfd_link_info *) data;
4473 htab = mips_elf_hash_table (info);
4474 BFD_ASSERT (htab != NULL);
4476 if (entry->abfd != NULL
4477 && entry->symndx == -1
4478 && entry->d.h->needs_lazy_stub)
4480 entry->d.h->needs_lazy_stub = FALSE;
4481 htab->lazy_stub_count--;
4487 /* Return the offset of an input bfd IBFD's GOT from the beginning of
4490 mips_elf_adjust_gp (bfd *abfd, struct mips_got_info *g, bfd *ibfd)
4492 if (g->bfd2got == NULL)
4495 g = mips_elf_got_for_ibfd (g, ibfd);
4499 BFD_ASSERT (g->next);
4503 return (g->local_gotno + g->global_gotno + g->tls_gotno)
4504 * MIPS_ELF_GOT_SIZE (abfd);
4507 /* Turn a single GOT that is too big for 16-bit addressing into
4508 a sequence of GOTs, each one 16-bit addressable. */
4511 mips_elf_multi_got (bfd *abfd, struct bfd_link_info *info,
4512 asection *got, bfd_size_type pages)
4514 struct mips_elf_link_hash_table *htab;
4515 struct mips_elf_got_per_bfd_arg got_per_bfd_arg;
4516 struct mips_elf_set_global_got_offset_arg set_got_offset_arg;
4517 struct mips_got_info *g, *gg;
4518 unsigned int assign, needed_relocs;
4521 dynobj = elf_hash_table (info)->dynobj;
4522 htab = mips_elf_hash_table (info);
4523 BFD_ASSERT (htab != NULL);
4526 g->bfd2got = htab_try_create (1, mips_elf_bfd2got_entry_hash,
4527 mips_elf_bfd2got_entry_eq, NULL);
4528 if (g->bfd2got == NULL)
4531 got_per_bfd_arg.bfd2got = g->bfd2got;
4532 got_per_bfd_arg.obfd = abfd;
4533 got_per_bfd_arg.info = info;
4535 /* Count how many GOT entries each input bfd requires, creating a
4536 map from bfd to got info while at that. */
4537 htab_traverse (g->got_entries, mips_elf_make_got_per_bfd, &got_per_bfd_arg);
4538 if (got_per_bfd_arg.obfd == NULL)
4541 /* Also count how many page entries each input bfd requires. */
4542 htab_traverse (g->got_page_entries, mips_elf_make_got_pages_per_bfd,
4544 if (got_per_bfd_arg.obfd == NULL)
4547 got_per_bfd_arg.current = NULL;
4548 got_per_bfd_arg.primary = NULL;
4549 got_per_bfd_arg.max_count = ((MIPS_ELF_GOT_MAX_SIZE (info)
4550 / MIPS_ELF_GOT_SIZE (abfd))
4551 - htab->reserved_gotno);
4552 got_per_bfd_arg.max_pages = pages;
4553 /* The number of globals that will be included in the primary GOT.
4554 See the calls to mips_elf_set_global_got_offset below for more
4556 got_per_bfd_arg.global_count = g->global_gotno;
4558 /* Try to merge the GOTs of input bfds together, as long as they
4559 don't seem to exceed the maximum GOT size, choosing one of them
4560 to be the primary GOT. */
4561 htab_traverse (g->bfd2got, mips_elf_merge_gots, &got_per_bfd_arg);
4562 if (got_per_bfd_arg.obfd == NULL)
4565 /* If we do not find any suitable primary GOT, create an empty one. */
4566 if (got_per_bfd_arg.primary == NULL)
4568 g->next = (struct mips_got_info *)
4569 bfd_alloc (abfd, sizeof (struct mips_got_info));
4570 if (g->next == NULL)
4573 g->next->global_gotsym = NULL;
4574 g->next->global_gotno = 0;
4575 g->next->reloc_only_gotno = 0;
4576 g->next->local_gotno = 0;
4577 g->next->page_gotno = 0;
4578 g->next->tls_gotno = 0;
4579 g->next->assigned_gotno = 0;
4580 g->next->tls_assigned_gotno = 0;
4581 g->next->tls_ldm_offset = MINUS_ONE;
4582 g->next->got_entries = htab_try_create (1, mips_elf_multi_got_entry_hash,
4583 mips_elf_multi_got_entry_eq,
4585 if (g->next->got_entries == NULL)
4587 g->next->got_page_entries = htab_try_create (1, mips_got_page_entry_hash,
4588 mips_got_page_entry_eq,
4590 if (g->next->got_page_entries == NULL)
4592 g->next->bfd2got = NULL;
4595 g->next = got_per_bfd_arg.primary;
4596 g->next->next = got_per_bfd_arg.current;
4598 /* GG is now the master GOT, and G is the primary GOT. */
4602 /* Map the output bfd to the primary got. That's what we're going
4603 to use for bfds that use GOT16 or GOT_PAGE relocations that we
4604 didn't mark in check_relocs, and we want a quick way to find it.
4605 We can't just use gg->next because we're going to reverse the
4608 struct mips_elf_bfd2got_hash *bfdgot;
4611 bfdgot = (struct mips_elf_bfd2got_hash *)bfd_alloc
4612 (abfd, sizeof (struct mips_elf_bfd2got_hash));
4619 bfdgotp = htab_find_slot (gg->bfd2got, bfdgot, INSERT);
4621 BFD_ASSERT (*bfdgotp == NULL);
4625 /* Every symbol that is referenced in a dynamic relocation must be
4626 present in the primary GOT, so arrange for them to appear after
4627 those that are actually referenced. */
4628 gg->reloc_only_gotno = gg->global_gotno - g->global_gotno;
4629 g->global_gotno = gg->global_gotno;
4631 set_got_offset_arg.g = NULL;
4632 set_got_offset_arg.value = GGA_RELOC_ONLY;
4633 htab_traverse (gg->got_entries, mips_elf_set_global_got_offset,
4634 &set_got_offset_arg);
4635 set_got_offset_arg.value = GGA_NORMAL;
4636 htab_traverse (g->got_entries, mips_elf_set_global_got_offset,
4637 &set_got_offset_arg);
4639 /* Now go through the GOTs assigning them offset ranges.
4640 [assigned_gotno, local_gotno[ will be set to the range of local
4641 entries in each GOT. We can then compute the end of a GOT by
4642 adding local_gotno to global_gotno. We reverse the list and make
4643 it circular since then we'll be able to quickly compute the
4644 beginning of a GOT, by computing the end of its predecessor. To
4645 avoid special cases for the primary GOT, while still preserving
4646 assertions that are valid for both single- and multi-got links,
4647 we arrange for the main got struct to have the right number of
4648 global entries, but set its local_gotno such that the initial
4649 offset of the primary GOT is zero. Remember that the primary GOT
4650 will become the last item in the circular linked list, so it
4651 points back to the master GOT. */
4652 gg->local_gotno = -g->global_gotno;
4653 gg->global_gotno = g->global_gotno;
4660 struct mips_got_info *gn;
4662 assign += htab->reserved_gotno;
4663 g->assigned_gotno = assign;
4664 g->local_gotno += assign;
4665 g->local_gotno += (pages < g->page_gotno ? pages : g->page_gotno);
4666 assign = g->local_gotno + g->global_gotno + g->tls_gotno;
4668 /* Take g out of the direct list, and push it onto the reversed
4669 list that gg points to. g->next is guaranteed to be nonnull after
4670 this operation, as required by mips_elf_initialize_tls_index. */
4675 /* Set up any TLS entries. We always place the TLS entries after
4676 all non-TLS entries. */
4677 g->tls_assigned_gotno = g->local_gotno + g->global_gotno;
4678 htab_traverse (g->got_entries, mips_elf_initialize_tls_index, g);
4680 /* Move onto the next GOT. It will be a secondary GOT if nonull. */
4683 /* Forbid global symbols in every non-primary GOT from having
4684 lazy-binding stubs. */
4686 htab_traverse (g->got_entries, mips_elf_forbid_lazy_stubs, info);
4690 got->size = (gg->next->local_gotno
4691 + gg->next->global_gotno
4692 + gg->next->tls_gotno) * MIPS_ELF_GOT_SIZE (abfd);
4695 set_got_offset_arg.value = MIPS_ELF_GOT_SIZE (abfd);
4696 set_got_offset_arg.info = info;
4697 for (g = gg->next; g && g->next != gg; g = g->next)
4699 unsigned int save_assign;
4701 /* Assign offsets to global GOT entries. */
4702 save_assign = g->assigned_gotno;
4703 g->assigned_gotno = g->local_gotno;
4704 set_got_offset_arg.g = g;
4705 set_got_offset_arg.needed_relocs = 0;
4706 htab_traverse (g->got_entries,
4707 mips_elf_set_global_got_offset,
4708 &set_got_offset_arg);
4709 needed_relocs += set_got_offset_arg.needed_relocs;
4710 BFD_ASSERT (g->assigned_gotno - g->local_gotno <= g->global_gotno);
4712 g->assigned_gotno = save_assign;
4715 needed_relocs += g->local_gotno - g->assigned_gotno;
4716 BFD_ASSERT (g->assigned_gotno == g->next->local_gotno
4717 + g->next->global_gotno
4718 + g->next->tls_gotno
4719 + htab->reserved_gotno);
4724 mips_elf_allocate_dynamic_relocations (dynobj, info,
4731 /* Returns the first relocation of type r_type found, beginning with
4732 RELOCATION. RELEND is one-past-the-end of the relocation table. */
4734 static const Elf_Internal_Rela *
4735 mips_elf_next_relocation (bfd *abfd ATTRIBUTE_UNUSED, unsigned int r_type,
4736 const Elf_Internal_Rela *relocation,
4737 const Elf_Internal_Rela *relend)
4739 unsigned long r_symndx = ELF_R_SYM (abfd, relocation->r_info);
4741 while (relocation < relend)
4743 if (ELF_R_TYPE (abfd, relocation->r_info) == r_type
4744 && ELF_R_SYM (abfd, relocation->r_info) == r_symndx)
4750 /* We didn't find it. */
4754 /* Return whether an input relocation is against a local symbol. */
4757 mips_elf_local_relocation_p (bfd *input_bfd,
4758 const Elf_Internal_Rela *relocation,
4759 asection **local_sections)
4761 unsigned long r_symndx;
4762 Elf_Internal_Shdr *symtab_hdr;
4765 r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
4766 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4767 extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
4769 if (r_symndx < extsymoff)
4771 if (elf_bad_symtab (input_bfd) && local_sections[r_symndx] != NULL)
4777 /* Sign-extend VALUE, which has the indicated number of BITS. */
4780 _bfd_mips_elf_sign_extend (bfd_vma value, int bits)
4782 if (value & ((bfd_vma) 1 << (bits - 1)))
4783 /* VALUE is negative. */
4784 value |= ((bfd_vma) - 1) << bits;
4789 /* Return non-zero if the indicated VALUE has overflowed the maximum
4790 range expressible by a signed number with the indicated number of
4794 mips_elf_overflow_p (bfd_vma value, int bits)
4796 bfd_signed_vma svalue = (bfd_signed_vma) value;
4798 if (svalue > (1 << (bits - 1)) - 1)
4799 /* The value is too big. */
4801 else if (svalue < -(1 << (bits - 1)))
4802 /* The value is too small. */
4809 /* Calculate the %high function. */
4812 mips_elf_high (bfd_vma value)
4814 return ((value + (bfd_vma) 0x8000) >> 16) & 0xffff;
4817 /* Calculate the %higher function. */
4820 mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED)
4823 return ((value + (bfd_vma) 0x80008000) >> 32) & 0xffff;
4830 /* Calculate the %highest function. */
4833 mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED)
4836 return ((value + (((bfd_vma) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
4843 /* Create the .compact_rel section. */
4846 mips_elf_create_compact_rel_section
4847 (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
4850 register asection *s;
4852 if (bfd_get_linker_section (abfd, ".compact_rel") == NULL)
4854 flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED
4857 s = bfd_make_section_anyway_with_flags (abfd, ".compact_rel", flags);
4859 || ! bfd_set_section_alignment (abfd, s,
4860 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
4863 s->size = sizeof (Elf32_External_compact_rel);
4869 /* Create the .got section to hold the global offset table. */
4872 mips_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
4875 register asection *s;
4876 struct elf_link_hash_entry *h;
4877 struct bfd_link_hash_entry *bh;
4878 struct mips_got_info *g;
4880 struct mips_elf_link_hash_table *htab;
4882 htab = mips_elf_hash_table (info);
4883 BFD_ASSERT (htab != NULL);
4885 /* This function may be called more than once. */
4889 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4890 | SEC_LINKER_CREATED);
4892 /* We have to use an alignment of 2**4 here because this is hardcoded
4893 in the function stub generation and in the linker script. */
4894 s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4896 || ! bfd_set_section_alignment (abfd, s, 4))
4900 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
4901 linker script because we don't want to define the symbol if we
4902 are not creating a global offset table. */
4904 if (! (_bfd_generic_link_add_one_symbol
4905 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
4906 0, NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
4909 h = (struct elf_link_hash_entry *) bh;
4912 h->type = STT_OBJECT;
4913 elf_hash_table (info)->hgot = h;
4916 && ! bfd_elf_link_record_dynamic_symbol (info, h))
4919 amt = sizeof (struct mips_got_info);
4920 g = bfd_alloc (abfd, amt);
4923 g->global_gotsym = NULL;
4924 g->global_gotno = 0;
4925 g->reloc_only_gotno = 0;
4929 g->assigned_gotno = 0;
4932 g->tls_ldm_offset = MINUS_ONE;
4933 g->got_entries = htab_try_create (1, mips_elf_got_entry_hash,
4934 mips_elf_got_entry_eq, NULL);
4935 if (g->got_entries == NULL)
4937 g->got_page_entries = htab_try_create (1, mips_got_page_entry_hash,
4938 mips_got_page_entry_eq, NULL);
4939 if (g->got_page_entries == NULL)
4942 mips_elf_section_data (s)->elf.this_hdr.sh_flags
4943 |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
4945 /* We also need a .got.plt section when generating PLTs. */
4946 s = bfd_make_section_anyway_with_flags (abfd, ".got.plt",
4947 SEC_ALLOC | SEC_LOAD
4950 | SEC_LINKER_CREATED);
4958 /* Return true if H refers to the special VxWorks __GOTT_BASE__ or
4959 __GOTT_INDEX__ symbols. These symbols are only special for
4960 shared objects; they are not used in executables. */
4963 is_gott_symbol (struct bfd_link_info *info, struct elf_link_hash_entry *h)
4965 return (mips_elf_hash_table (info)->is_vxworks
4967 && (strcmp (h->root.root.string, "__GOTT_BASE__") == 0
4968 || strcmp (h->root.root.string, "__GOTT_INDEX__") == 0));
4971 /* Return TRUE if a relocation of type R_TYPE from INPUT_BFD might
4972 require an la25 stub. See also mips_elf_local_pic_function_p,
4973 which determines whether the destination function ever requires a
4977 mips_elf_relocation_needs_la25_stub (bfd *input_bfd, int r_type,
4978 bfd_boolean target_is_16_bit_code_p)
4980 /* We specifically ignore branches and jumps from EF_PIC objects,
4981 where the onus is on the compiler or programmer to perform any
4982 necessary initialization of $25. Sometimes such initialization
4983 is unnecessary; for example, -mno-shared functions do not use
4984 the incoming value of $25, and may therefore be called directly. */
4985 if (PIC_OBJECT_P (input_bfd))
4992 case R_MICROMIPS_26_S1:
4993 case R_MICROMIPS_PC7_S1:
4994 case R_MICROMIPS_PC10_S1:
4995 case R_MICROMIPS_PC16_S1:
4996 case R_MICROMIPS_PC23_S2:
5000 return !target_is_16_bit_code_p;
5007 /* Calculate the value produced by the RELOCATION (which comes from
5008 the INPUT_BFD). The ADDEND is the addend to use for this
5009 RELOCATION; RELOCATION->R_ADDEND is ignored.
5011 The result of the relocation calculation is stored in VALUEP.
5012 On exit, set *CROSS_MODE_JUMP_P to true if the relocation field
5013 is a MIPS16 or microMIPS jump to standard MIPS code, or vice versa.
5015 This function returns bfd_reloc_continue if the caller need take no
5016 further action regarding this relocation, bfd_reloc_notsupported if
5017 something goes dramatically wrong, bfd_reloc_overflow if an
5018 overflow occurs, and bfd_reloc_ok to indicate success. */
5020 static bfd_reloc_status_type
5021 mips_elf_calculate_relocation (bfd *abfd, bfd *input_bfd,
5022 asection *input_section,
5023 struct bfd_link_info *info,
5024 const Elf_Internal_Rela *relocation,
5025 bfd_vma addend, reloc_howto_type *howto,
5026 Elf_Internal_Sym *local_syms,
5027 asection **local_sections, bfd_vma *valuep,
5029 bfd_boolean *cross_mode_jump_p,
5030 bfd_boolean save_addend)
5032 /* The eventual value we will return. */
5034 /* The address of the symbol against which the relocation is
5037 /* The final GP value to be used for the relocatable, executable, or
5038 shared object file being produced. */
5040 /* The place (section offset or address) of the storage unit being
5043 /* The value of GP used to create the relocatable object. */
5045 /* The offset into the global offset table at which the address of
5046 the relocation entry symbol, adjusted by the addend, resides
5047 during execution. */
5048 bfd_vma g = MINUS_ONE;
5049 /* The section in which the symbol referenced by the relocation is
5051 asection *sec = NULL;
5052 struct mips_elf_link_hash_entry *h = NULL;
5053 /* TRUE if the symbol referred to by this relocation is a local
5055 bfd_boolean local_p, was_local_p;
5056 /* TRUE if the symbol referred to by this relocation is "_gp_disp". */
5057 bfd_boolean gp_disp_p = FALSE;
5058 /* TRUE if the symbol referred to by this relocation is
5059 "__gnu_local_gp". */
5060 bfd_boolean gnu_local_gp_p = FALSE;
5061 Elf_Internal_Shdr *symtab_hdr;
5063 unsigned long r_symndx;
5065 /* TRUE if overflow occurred during the calculation of the
5066 relocation value. */
5067 bfd_boolean overflowed_p;
5068 /* TRUE if this relocation refers to a MIPS16 function. */
5069 bfd_boolean target_is_16_bit_code_p = FALSE;
5070 bfd_boolean target_is_micromips_code_p = FALSE;
5071 struct mips_elf_link_hash_table *htab;
5074 dynobj = elf_hash_table (info)->dynobj;
5075 htab = mips_elf_hash_table (info);
5076 BFD_ASSERT (htab != NULL);
5078 /* Parse the relocation. */
5079 r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
5080 r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
5081 p = (input_section->output_section->vma
5082 + input_section->output_offset
5083 + relocation->r_offset);
5085 /* Assume that there will be no overflow. */
5086 overflowed_p = FALSE;
5088 /* Figure out whether or not the symbol is local, and get the offset
5089 used in the array of hash table entries. */
5090 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5091 local_p = mips_elf_local_relocation_p (input_bfd, relocation,
5093 was_local_p = local_p;
5094 if (! elf_bad_symtab (input_bfd))
5095 extsymoff = symtab_hdr->sh_info;
5098 /* The symbol table does not follow the rule that local symbols
5099 must come before globals. */
5103 /* Figure out the value of the symbol. */
5106 Elf_Internal_Sym *sym;
5108 sym = local_syms + r_symndx;
5109 sec = local_sections[r_symndx];
5111 symbol = sec->output_section->vma + sec->output_offset;
5112 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION
5113 || (sec->flags & SEC_MERGE))
5114 symbol += sym->st_value;
5115 if ((sec->flags & SEC_MERGE)
5116 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5118 addend = _bfd_elf_rel_local_sym (abfd, sym, &sec, addend);
5120 addend += sec->output_section->vma + sec->output_offset;
5123 /* MIPS16/microMIPS text labels should be treated as odd. */
5124 if (ELF_ST_IS_COMPRESSED (sym->st_other))
5127 /* Record the name of this symbol, for our caller. */
5128 *namep = bfd_elf_string_from_elf_section (input_bfd,
5129 symtab_hdr->sh_link,
5132 *namep = bfd_section_name (input_bfd, sec);
5134 target_is_16_bit_code_p = ELF_ST_IS_MIPS16 (sym->st_other);
5135 target_is_micromips_code_p = ELF_ST_IS_MICROMIPS (sym->st_other);
5139 /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ? */
5141 /* For global symbols we look up the symbol in the hash-table. */
5142 h = ((struct mips_elf_link_hash_entry *)
5143 elf_sym_hashes (input_bfd) [r_symndx - extsymoff]);
5144 /* Find the real hash-table entry for this symbol. */
5145 while (h->root.root.type == bfd_link_hash_indirect
5146 || h->root.root.type == bfd_link_hash_warning)
5147 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
5149 /* Record the name of this symbol, for our caller. */
5150 *namep = h->root.root.root.string;
5152 /* See if this is the special _gp_disp symbol. Note that such a
5153 symbol must always be a global symbol. */
5154 if (strcmp (*namep, "_gp_disp") == 0
5155 && ! NEWABI_P (input_bfd))
5157 /* Relocations against _gp_disp are permitted only with
5158 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
5159 if (!hi16_reloc_p (r_type) && !lo16_reloc_p (r_type))
5160 return bfd_reloc_notsupported;
5164 /* See if this is the special _gp symbol. Note that such a
5165 symbol must always be a global symbol. */
5166 else if (strcmp (*namep, "__gnu_local_gp") == 0)
5167 gnu_local_gp_p = TRUE;
5170 /* If this symbol is defined, calculate its address. Note that
5171 _gp_disp is a magic symbol, always implicitly defined by the
5172 linker, so it's inappropriate to check to see whether or not
5174 else if ((h->root.root.type == bfd_link_hash_defined
5175 || h->root.root.type == bfd_link_hash_defweak)
5176 && h->root.root.u.def.section)
5178 sec = h->root.root.u.def.section;
5179 if (sec->output_section)
5180 symbol = (h->root.root.u.def.value
5181 + sec->output_section->vma
5182 + sec->output_offset);
5184 symbol = h->root.root.u.def.value;
5186 else if (h->root.root.type == bfd_link_hash_undefweak)
5187 /* We allow relocations against undefined weak symbols, giving
5188 it the value zero, so that you can undefined weak functions
5189 and check to see if they exist by looking at their
5192 else if (info->unresolved_syms_in_objects == RM_IGNORE
5193 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
5195 else if (strcmp (*namep, SGI_COMPAT (input_bfd)
5196 ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING") == 0)
5198 /* If this is a dynamic link, we should have created a
5199 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
5200 in in _bfd_mips_elf_create_dynamic_sections.
5201 Otherwise, we should define the symbol with a value of 0.
5202 FIXME: It should probably get into the symbol table
5204 BFD_ASSERT (! info->shared);
5205 BFD_ASSERT (bfd_get_section_by_name (abfd, ".dynamic") == NULL);
5208 else if (ELF_MIPS_IS_OPTIONAL (h->root.other))
5210 /* This is an optional symbol - an Irix specific extension to the
5211 ELF spec. Ignore it for now.
5212 XXX - FIXME - there is more to the spec for OPTIONAL symbols
5213 than simply ignoring them, but we do not handle this for now.
5214 For information see the "64-bit ELF Object File Specification"
5215 which is available from here:
5216 http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf */
5219 else if ((*info->callbacks->undefined_symbol)
5220 (info, h->root.root.root.string, input_bfd,
5221 input_section, relocation->r_offset,
5222 (info->unresolved_syms_in_objects == RM_GENERATE_ERROR)
5223 || ELF_ST_VISIBILITY (h->root.other)))
5225 return bfd_reloc_undefined;
5229 return bfd_reloc_notsupported;
5232 target_is_16_bit_code_p = ELF_ST_IS_MIPS16 (h->root.other);
5233 /* If the output section is the PLT section,
5234 then the target is not microMIPS. */
5235 target_is_micromips_code_p = (htab->splt != sec
5236 && ELF_ST_IS_MICROMIPS (h->root.other));
5239 /* If this is a reference to a 16-bit function with a stub, we need
5240 to redirect the relocation to the stub unless:
5242 (a) the relocation is for a MIPS16 JAL;
5244 (b) the relocation is for a MIPS16 PIC call, and there are no
5245 non-MIPS16 uses of the GOT slot; or
5247 (c) the section allows direct references to MIPS16 functions. */
5248 if (r_type != R_MIPS16_26
5249 && !info->relocatable
5251 && h->fn_stub != NULL
5252 && (r_type != R_MIPS16_CALL16 || h->need_fn_stub))
5254 && elf_tdata (input_bfd)->local_stubs != NULL
5255 && elf_tdata (input_bfd)->local_stubs[r_symndx] != NULL))
5256 && !section_allows_mips16_refs_p (input_section))
5258 /* This is a 32- or 64-bit call to a 16-bit function. We should
5259 have already noticed that we were going to need the
5263 sec = elf_tdata (input_bfd)->local_stubs[r_symndx];
5268 BFD_ASSERT (h->need_fn_stub);
5271 /* If a LA25 header for the stub itself exists, point to the
5272 prepended LUI/ADDIU sequence. */
5273 sec = h->la25_stub->stub_section;
5274 value = h->la25_stub->offset;
5283 symbol = sec->output_section->vma + sec->output_offset + value;
5284 /* The target is 16-bit, but the stub isn't. */
5285 target_is_16_bit_code_p = FALSE;
5287 /* If this is a 16-bit call to a 32- or 64-bit function with a stub, we
5288 need to redirect the call to the stub. Note that we specifically
5289 exclude R_MIPS16_CALL16 from this behavior; indirect calls should
5290 use an indirect stub instead. */
5291 else if (r_type == R_MIPS16_26 && !info->relocatable
5292 && ((h != NULL && (h->call_stub != NULL || h->call_fp_stub != NULL))
5294 && elf_tdata (input_bfd)->local_call_stubs != NULL
5295 && elf_tdata (input_bfd)->local_call_stubs[r_symndx] != NULL))
5296 && !target_is_16_bit_code_p)
5299 sec = elf_tdata (input_bfd)->local_call_stubs[r_symndx];
5302 /* If both call_stub and call_fp_stub are defined, we can figure
5303 out which one to use by checking which one appears in the input
5305 if (h->call_stub != NULL && h->call_fp_stub != NULL)
5310 for (o = input_bfd->sections; o != NULL; o = o->next)
5312 if (CALL_FP_STUB_P (bfd_get_section_name (input_bfd, o)))
5314 sec = h->call_fp_stub;
5321 else if (h->call_stub != NULL)
5324 sec = h->call_fp_stub;
5327 BFD_ASSERT (sec->size > 0);
5328 symbol = sec->output_section->vma + sec->output_offset;
5330 /* If this is a direct call to a PIC function, redirect to the
5332 else if (h != NULL && h->la25_stub
5333 && mips_elf_relocation_needs_la25_stub (input_bfd, r_type,
5334 target_is_16_bit_code_p))
5335 symbol = (h->la25_stub->stub_section->output_section->vma
5336 + h->la25_stub->stub_section->output_offset
5337 + h->la25_stub->offset);
5339 /* Make sure MIPS16 and microMIPS are not used together. */
5340 if ((r_type == R_MIPS16_26 && target_is_micromips_code_p)
5341 || (micromips_branch_reloc_p (r_type) && target_is_16_bit_code_p))
5343 (*_bfd_error_handler)
5344 (_("MIPS16 and microMIPS functions cannot call each other"));
5345 return bfd_reloc_notsupported;
5348 /* Calls from 16-bit code to 32-bit code and vice versa require the
5349 mode change. However, we can ignore calls to undefined weak symbols,
5350 which should never be executed at runtime. This exception is important
5351 because the assembly writer may have "known" that any definition of the
5352 symbol would be 16-bit code, and that direct jumps were therefore
5354 *cross_mode_jump_p = (!info->relocatable
5355 && !(h && h->root.root.type == bfd_link_hash_undefweak)
5356 && ((r_type == R_MIPS16_26 && !target_is_16_bit_code_p)
5357 || (r_type == R_MICROMIPS_26_S1
5358 && !target_is_micromips_code_p)
5359 || ((r_type == R_MIPS_26 || r_type == R_MIPS_JALR)
5360 && (target_is_16_bit_code_p
5361 || target_is_micromips_code_p))));
5363 local_p = h == NULL || SYMBOL_REFERENCES_LOCAL (info, &h->root);
5365 gp0 = _bfd_get_gp_value (input_bfd);
5366 gp = _bfd_get_gp_value (abfd);
5368 gp += mips_elf_adjust_gp (abfd, htab->got_info, input_bfd);
5373 /* Global R_MIPS_GOT_PAGE/R_MICROMIPS_GOT_PAGE relocations are equivalent
5374 to R_MIPS_GOT_DISP/R_MICROMIPS_GOT_DISP. The addend is applied by the
5375 corresponding R_MIPS_GOT_OFST/R_MICROMIPS_GOT_OFST. */
5376 if (got_page_reloc_p (r_type) && !local_p)
5378 r_type = (micromips_reloc_p (r_type)
5379 ? R_MICROMIPS_GOT_DISP : R_MIPS_GOT_DISP);
5383 /* If we haven't already determined the GOT offset, and we're going
5384 to need it, get it now. */
5387 case R_MIPS16_CALL16:
5388 case R_MIPS16_GOT16:
5391 case R_MIPS_GOT_DISP:
5392 case R_MIPS_GOT_HI16:
5393 case R_MIPS_CALL_HI16:
5394 case R_MIPS_GOT_LO16:
5395 case R_MIPS_CALL_LO16:
5396 case R_MICROMIPS_CALL16:
5397 case R_MICROMIPS_GOT16:
5398 case R_MICROMIPS_GOT_DISP:
5399 case R_MICROMIPS_GOT_HI16:
5400 case R_MICROMIPS_CALL_HI16:
5401 case R_MICROMIPS_GOT_LO16:
5402 case R_MICROMIPS_CALL_LO16:
5404 case R_MIPS_TLS_GOTTPREL:
5405 case R_MIPS_TLS_LDM:
5406 case R_MIPS16_TLS_GD:
5407 case R_MIPS16_TLS_GOTTPREL:
5408 case R_MIPS16_TLS_LDM:
5409 case R_MICROMIPS_TLS_GD:
5410 case R_MICROMIPS_TLS_GOTTPREL:
5411 case R_MICROMIPS_TLS_LDM:
5412 /* Find the index into the GOT where this value is located. */
5413 if (tls_ldm_reloc_p (r_type))
5415 g = mips_elf_local_got_index (abfd, input_bfd, info,
5416 0, 0, NULL, r_type);
5418 return bfd_reloc_outofrange;
5422 /* On VxWorks, CALL relocations should refer to the .got.plt
5423 entry, which is initialized to point at the PLT stub. */
5424 if (htab->is_vxworks
5425 && (call_hi16_reloc_p (r_type)
5426 || call_lo16_reloc_p (r_type)
5427 || call16_reloc_p (r_type)))
5429 BFD_ASSERT (addend == 0);
5430 BFD_ASSERT (h->root.needs_plt);
5431 g = mips_elf_gotplt_index (info, &h->root);
5435 BFD_ASSERT (addend == 0);
5436 g = mips_elf_global_got_index (dynobj, input_bfd,
5437 &h->root, r_type, info);
5438 if (h->tls_type == GOT_NORMAL
5439 && !elf_hash_table (info)->dynamic_sections_created)
5440 /* This is a static link. We must initialize the GOT entry. */
5441 MIPS_ELF_PUT_WORD (dynobj, symbol, htab->sgot->contents + g);
5444 else if (!htab->is_vxworks
5445 && (call16_reloc_p (r_type) || got16_reloc_p (r_type)))
5446 /* The calculation below does not involve "g". */
5450 g = mips_elf_local_got_index (abfd, input_bfd, info,
5451 symbol + addend, r_symndx, h, r_type);
5453 return bfd_reloc_outofrange;
5456 /* Convert GOT indices to actual offsets. */
5457 g = mips_elf_got_offset_from_index (info, abfd, input_bfd, g);
5461 /* Relocations against the VxWorks __GOTT_BASE__ and __GOTT_INDEX__
5462 symbols are resolved by the loader. Add them to .rela.dyn. */
5463 if (h != NULL && is_gott_symbol (info, &h->root))
5465 Elf_Internal_Rela outrel;
5469 s = mips_elf_rel_dyn_section (info, FALSE);
5470 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
5472 outrel.r_offset = (input_section->output_section->vma
5473 + input_section->output_offset
5474 + relocation->r_offset);
5475 outrel.r_info = ELF32_R_INFO (h->root.dynindx, r_type);
5476 outrel.r_addend = addend;
5477 bfd_elf32_swap_reloca_out (abfd, &outrel, loc);
5479 /* If we've written this relocation for a readonly section,
5480 we need to set DF_TEXTREL again, so that we do not delete the
5482 if (MIPS_ELF_READONLY_SECTION (input_section))
5483 info->flags |= DF_TEXTREL;
5486 return bfd_reloc_ok;
5489 /* Figure out what kind of relocation is being performed. */
5493 return bfd_reloc_continue;
5496 value = symbol + _bfd_mips_elf_sign_extend (addend, 16);
5497 overflowed_p = mips_elf_overflow_p (value, 16);
5504 || (htab->root.dynamic_sections_created
5506 && h->root.def_dynamic
5507 && !h->root.def_regular
5508 && !h->has_static_relocs))
5509 && r_symndx != STN_UNDEF
5511 || h->root.root.type != bfd_link_hash_undefweak
5512 || ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
5513 && (input_section->flags & SEC_ALLOC) != 0)
5515 /* If we're creating a shared library, then we can't know
5516 where the symbol will end up. So, we create a relocation
5517 record in the output, and leave the job up to the dynamic
5518 linker. We must do the same for executable references to
5519 shared library symbols, unless we've decided to use copy
5520 relocs or PLTs instead. */
5522 if (!mips_elf_create_dynamic_relocation (abfd,
5530 return bfd_reloc_undefined;
5534 if (r_type != R_MIPS_REL32)
5535 value = symbol + addend;
5539 value &= howto->dst_mask;
5543 value = symbol + addend - p;
5544 value &= howto->dst_mask;
5548 /* The calculation for R_MIPS16_26 is just the same as for an
5549 R_MIPS_26. It's only the storage of the relocated field into
5550 the output file that's different. That's handled in
5551 mips_elf_perform_relocation. So, we just fall through to the
5552 R_MIPS_26 case here. */
5554 case R_MICROMIPS_26_S1:
5558 /* Make sure the target of JALX is word-aligned. Bit 0 must be
5559 the correct ISA mode selector and bit 1 must be 0. */
5560 if (*cross_mode_jump_p && (symbol & 3) != (r_type == R_MIPS_26))
5561 return bfd_reloc_outofrange;
5563 /* Shift is 2, unusually, for microMIPS JALX. */
5564 shift = (!*cross_mode_jump_p && r_type == R_MICROMIPS_26_S1) ? 1 : 2;
5567 value = addend | ((p + 4) & (0xfc000000 << shift));
5569 value = _bfd_mips_elf_sign_extend (addend, 26 + shift);
5570 value = (value + symbol) >> shift;
5571 if (!was_local_p && h->root.root.type != bfd_link_hash_undefweak)
5572 overflowed_p = (value >> 26) != ((p + 4) >> (26 + shift));
5573 value &= howto->dst_mask;
5577 case R_MIPS_TLS_DTPREL_HI16:
5578 case R_MIPS16_TLS_DTPREL_HI16:
5579 case R_MICROMIPS_TLS_DTPREL_HI16:
5580 value = (mips_elf_high (addend + symbol - dtprel_base (info))
5584 case R_MIPS_TLS_DTPREL_LO16:
5585 case R_MIPS_TLS_DTPREL32:
5586 case R_MIPS_TLS_DTPREL64:
5587 case R_MIPS16_TLS_DTPREL_LO16:
5588 case R_MICROMIPS_TLS_DTPREL_LO16:
5589 value = (symbol + addend - dtprel_base (info)) & howto->dst_mask;
5592 case R_MIPS_TLS_TPREL_HI16:
5593 case R_MIPS16_TLS_TPREL_HI16:
5594 case R_MICROMIPS_TLS_TPREL_HI16:
5595 value = (mips_elf_high (addend + symbol - tprel_base (info))
5599 case R_MIPS_TLS_TPREL_LO16:
5600 case R_MIPS_TLS_TPREL32:
5601 case R_MIPS_TLS_TPREL64:
5602 case R_MIPS16_TLS_TPREL_LO16:
5603 case R_MICROMIPS_TLS_TPREL_LO16:
5604 value = (symbol + addend - tprel_base (info)) & howto->dst_mask;
5609 case R_MICROMIPS_HI16:
5612 value = mips_elf_high (addend + symbol);
5613 value &= howto->dst_mask;
5617 /* For MIPS16 ABI code we generate this sequence
5618 0: li $v0,%hi(_gp_disp)
5619 4: addiupc $v1,%lo(_gp_disp)
5623 So the offsets of hi and lo relocs are the same, but the
5624 base $pc is that used by the ADDIUPC instruction at $t9 + 4.
5625 ADDIUPC clears the low two bits of the instruction address,
5626 so the base is ($t9 + 4) & ~3. */
5627 if (r_type == R_MIPS16_HI16)
5628 value = mips_elf_high (addend + gp - ((p + 4) & ~(bfd_vma) 0x3));
5629 /* The microMIPS .cpload sequence uses the same assembly
5630 instructions as the traditional psABI version, but the
5631 incoming $t9 has the low bit set. */
5632 else if (r_type == R_MICROMIPS_HI16)
5633 value = mips_elf_high (addend + gp - p - 1);
5635 value = mips_elf_high (addend + gp - p);
5636 overflowed_p = mips_elf_overflow_p (value, 16);
5642 case R_MICROMIPS_LO16:
5643 case R_MICROMIPS_HI0_LO16:
5645 value = (symbol + addend) & howto->dst_mask;
5648 /* See the comment for R_MIPS16_HI16 above for the reason
5649 for this conditional. */
5650 if (r_type == R_MIPS16_LO16)
5651 value = addend + gp - (p & ~(bfd_vma) 0x3);
5652 else if (r_type == R_MICROMIPS_LO16
5653 || r_type == R_MICROMIPS_HI0_LO16)
5654 value = addend + gp - p + 3;
5656 value = addend + gp - p + 4;
5657 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
5658 for overflow. But, on, say, IRIX5, relocations against
5659 _gp_disp are normally generated from the .cpload
5660 pseudo-op. It generates code that normally looks like
5663 lui $gp,%hi(_gp_disp)
5664 addiu $gp,$gp,%lo(_gp_disp)
5667 Here $t9 holds the address of the function being called,
5668 as required by the MIPS ELF ABI. The R_MIPS_LO16
5669 relocation can easily overflow in this situation, but the
5670 R_MIPS_HI16 relocation will handle the overflow.
5671 Therefore, we consider this a bug in the MIPS ABI, and do
5672 not check for overflow here. */
5676 case R_MIPS_LITERAL:
5677 case R_MICROMIPS_LITERAL:
5678 /* Because we don't merge literal sections, we can handle this
5679 just like R_MIPS_GPREL16. In the long run, we should merge
5680 shared literals, and then we will need to additional work
5685 case R_MIPS16_GPREL:
5686 /* The R_MIPS16_GPREL performs the same calculation as
5687 R_MIPS_GPREL16, but stores the relocated bits in a different
5688 order. We don't need to do anything special here; the
5689 differences are handled in mips_elf_perform_relocation. */
5690 case R_MIPS_GPREL16:
5691 case R_MICROMIPS_GPREL7_S2:
5692 case R_MICROMIPS_GPREL16:
5693 /* Only sign-extend the addend if it was extracted from the
5694 instruction. If the addend was separate, leave it alone,
5695 otherwise we may lose significant bits. */
5696 if (howto->partial_inplace)
5697 addend = _bfd_mips_elf_sign_extend (addend, 16);
5698 value = symbol + addend - gp;
5699 /* If the symbol was local, any earlier relocatable links will
5700 have adjusted its addend with the gp offset, so compensate
5701 for that now. Don't do it for symbols forced local in this
5702 link, though, since they won't have had the gp offset applied
5706 overflowed_p = mips_elf_overflow_p (value, 16);
5709 case R_MIPS16_GOT16:
5710 case R_MIPS16_CALL16:
5713 case R_MICROMIPS_GOT16:
5714 case R_MICROMIPS_CALL16:
5715 /* VxWorks does not have separate local and global semantics for
5716 R_MIPS*_GOT16; every relocation evaluates to "G". */
5717 if (!htab->is_vxworks && local_p)
5719 value = mips_elf_got16_entry (abfd, input_bfd, info,
5720 symbol + addend, !was_local_p);
5721 if (value == MINUS_ONE)
5722 return bfd_reloc_outofrange;
5724 = mips_elf_got_offset_from_index (info, abfd, input_bfd, value);
5725 overflowed_p = mips_elf_overflow_p (value, 16);
5732 case R_MIPS_TLS_GOTTPREL:
5733 case R_MIPS_TLS_LDM:
5734 case R_MIPS_GOT_DISP:
5735 case R_MIPS16_TLS_GD:
5736 case R_MIPS16_TLS_GOTTPREL:
5737 case R_MIPS16_TLS_LDM:
5738 case R_MICROMIPS_TLS_GD:
5739 case R_MICROMIPS_TLS_GOTTPREL:
5740 case R_MICROMIPS_TLS_LDM:
5741 case R_MICROMIPS_GOT_DISP:
5743 overflowed_p = mips_elf_overflow_p (value, 16);
5746 case R_MIPS_GPREL32:
5747 value = (addend + symbol + gp0 - gp);
5749 value &= howto->dst_mask;
5753 case R_MIPS_GNU_REL16_S2:
5754 value = symbol + _bfd_mips_elf_sign_extend (addend, 18) - p;
5755 overflowed_p = mips_elf_overflow_p (value, 18);
5756 value >>= howto->rightshift;
5757 value &= howto->dst_mask;
5760 case R_MICROMIPS_PC7_S1:
5761 value = symbol + _bfd_mips_elf_sign_extend (addend, 8) - p;
5762 overflowed_p = mips_elf_overflow_p (value, 8);
5763 value >>= howto->rightshift;
5764 value &= howto->dst_mask;
5767 case R_MICROMIPS_PC10_S1:
5768 value = symbol + _bfd_mips_elf_sign_extend (addend, 11) - p;
5769 overflowed_p = mips_elf_overflow_p (value, 11);
5770 value >>= howto->rightshift;
5771 value &= howto->dst_mask;
5774 case R_MICROMIPS_PC16_S1:
5775 value = symbol + _bfd_mips_elf_sign_extend (addend, 17) - p;
5776 overflowed_p = mips_elf_overflow_p (value, 17);
5777 value >>= howto->rightshift;
5778 value &= howto->dst_mask;
5781 case R_MICROMIPS_PC23_S2:
5782 value = symbol + _bfd_mips_elf_sign_extend (addend, 25) - ((p | 3) ^ 3);
5783 overflowed_p = mips_elf_overflow_p (value, 25);
5784 value >>= howto->rightshift;
5785 value &= howto->dst_mask;
5788 case R_MIPS_GOT_HI16:
5789 case R_MIPS_CALL_HI16:
5790 case R_MICROMIPS_GOT_HI16:
5791 case R_MICROMIPS_CALL_HI16:
5792 /* We're allowed to handle these two relocations identically.
5793 The dynamic linker is allowed to handle the CALL relocations
5794 differently by creating a lazy evaluation stub. */
5796 value = mips_elf_high (value);
5797 value &= howto->dst_mask;
5800 case R_MIPS_GOT_LO16:
5801 case R_MIPS_CALL_LO16:
5802 case R_MICROMIPS_GOT_LO16:
5803 case R_MICROMIPS_CALL_LO16:
5804 value = g & howto->dst_mask;
5807 case R_MIPS_GOT_PAGE:
5808 case R_MICROMIPS_GOT_PAGE:
5809 value = mips_elf_got_page (abfd, input_bfd, info, symbol + addend, NULL);
5810 if (value == MINUS_ONE)
5811 return bfd_reloc_outofrange;
5812 value = mips_elf_got_offset_from_index (info, abfd, input_bfd, value);
5813 overflowed_p = mips_elf_overflow_p (value, 16);
5816 case R_MIPS_GOT_OFST:
5817 case R_MICROMIPS_GOT_OFST:
5819 mips_elf_got_page (abfd, input_bfd, info, symbol + addend, &value);
5822 overflowed_p = mips_elf_overflow_p (value, 16);
5826 case R_MICROMIPS_SUB:
5827 value = symbol - addend;
5828 value &= howto->dst_mask;
5832 case R_MICROMIPS_HIGHER:
5833 value = mips_elf_higher (addend + symbol);
5834 value &= howto->dst_mask;
5837 case R_MIPS_HIGHEST:
5838 case R_MICROMIPS_HIGHEST:
5839 value = mips_elf_highest (addend + symbol);
5840 value &= howto->dst_mask;
5843 case R_MIPS_SCN_DISP:
5844 case R_MICROMIPS_SCN_DISP:
5845 value = symbol + addend - sec->output_offset;
5846 value &= howto->dst_mask;
5850 case R_MICROMIPS_JALR:
5851 /* This relocation is only a hint. In some cases, we optimize
5852 it into a bal instruction. But we don't try to optimize
5853 when the symbol does not resolve locally. */
5854 if (h != NULL && !SYMBOL_CALLS_LOCAL (info, &h->root))
5855 return bfd_reloc_continue;
5856 value = symbol + addend;
5860 case R_MIPS_GNU_VTINHERIT:
5861 case R_MIPS_GNU_VTENTRY:
5862 /* We don't do anything with these at present. */
5863 return bfd_reloc_continue;
5866 /* An unrecognized relocation type. */
5867 return bfd_reloc_notsupported;
5870 /* Store the VALUE for our caller. */
5872 return overflowed_p ? bfd_reloc_overflow : bfd_reloc_ok;
5875 /* Obtain the field relocated by RELOCATION. */
5878 mips_elf_obtain_contents (reloc_howto_type *howto,
5879 const Elf_Internal_Rela *relocation,
5880 bfd *input_bfd, bfd_byte *contents)
5883 bfd_byte *location = contents + relocation->r_offset;
5885 /* Obtain the bytes. */
5886 x = bfd_get ((8 * bfd_get_reloc_size (howto)), input_bfd, location);
5891 /* It has been determined that the result of the RELOCATION is the
5892 VALUE. Use HOWTO to place VALUE into the output file at the
5893 appropriate position. The SECTION is the section to which the
5895 CROSS_MODE_JUMP_P is true if the relocation field
5896 is a MIPS16 or microMIPS jump to standard MIPS code, or vice versa.
5898 Returns FALSE if anything goes wrong. */
5901 mips_elf_perform_relocation (struct bfd_link_info *info,
5902 reloc_howto_type *howto,
5903 const Elf_Internal_Rela *relocation,
5904 bfd_vma value, bfd *input_bfd,
5905 asection *input_section, bfd_byte *contents,
5906 bfd_boolean cross_mode_jump_p)
5910 int r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
5912 /* Figure out where the relocation is occurring. */
5913 location = contents + relocation->r_offset;
5915 _bfd_mips_elf_reloc_unshuffle (input_bfd, r_type, FALSE, location);
5917 /* Obtain the current value. */
5918 x = mips_elf_obtain_contents (howto, relocation, input_bfd, contents);
5920 /* Clear the field we are setting. */
5921 x &= ~howto->dst_mask;
5923 /* Set the field. */
5924 x |= (value & howto->dst_mask);
5926 /* If required, turn JAL into JALX. */
5927 if (cross_mode_jump_p && jal_reloc_p (r_type))
5930 bfd_vma opcode = x >> 26;
5931 bfd_vma jalx_opcode;
5933 /* Check to see if the opcode is already JAL or JALX. */
5934 if (r_type == R_MIPS16_26)
5936 ok = ((opcode == 0x6) || (opcode == 0x7));
5939 else if (r_type == R_MICROMIPS_26_S1)
5941 ok = ((opcode == 0x3d) || (opcode == 0x3c));
5946 ok = ((opcode == 0x3) || (opcode == 0x1d));
5950 /* If the opcode is not JAL or JALX, there's a problem. We cannot
5951 convert J or JALS to JALX. */
5954 (*_bfd_error_handler)
5955 (_("%B: %A+0x%lx: Unsupported jump between ISA modes; consider recompiling with interlinking enabled."),
5958 (unsigned long) relocation->r_offset);
5959 bfd_set_error (bfd_error_bad_value);
5963 /* Make this the JALX opcode. */
5964 x = (x & ~(0x3f << 26)) | (jalx_opcode << 26);
5967 /* Try converting JAL to BAL and J(AL)R to B(AL), if the target is in
5969 if (!info->relocatable
5970 && !cross_mode_jump_p
5971 && ((JAL_TO_BAL_P (input_bfd)
5972 && r_type == R_MIPS_26
5973 && (x >> 26) == 0x3) /* jal addr */
5974 || (JALR_TO_BAL_P (input_bfd)
5975 && r_type == R_MIPS_JALR
5976 && x == 0x0320f809) /* jalr t9 */
5977 || (JR_TO_B_P (input_bfd)
5978 && r_type == R_MIPS_JALR
5979 && x == 0x03200008))) /* jr t9 */
5985 addr = (input_section->output_section->vma
5986 + input_section->output_offset
5987 + relocation->r_offset
5989 if (r_type == R_MIPS_26)
5990 dest = (value << 2) | ((addr >> 28) << 28);
5994 if (off <= 0x1ffff && off >= -0x20000)
5996 if (x == 0x03200008) /* jr t9 */
5997 x = 0x10000000 | (((bfd_vma) off >> 2) & 0xffff); /* b addr */
5999 x = 0x04110000 | (((bfd_vma) off >> 2) & 0xffff); /* bal addr */
6003 /* Put the value into the output. */
6004 bfd_put (8 * bfd_get_reloc_size (howto), input_bfd, x, location);
6006 _bfd_mips_elf_reloc_shuffle (input_bfd, r_type, !info->relocatable,
6012 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
6013 is the original relocation, which is now being transformed into a
6014 dynamic relocation. The ADDENDP is adjusted if necessary; the
6015 caller should store the result in place of the original addend. */
6018 mips_elf_create_dynamic_relocation (bfd *output_bfd,
6019 struct bfd_link_info *info,
6020 const Elf_Internal_Rela *rel,
6021 struct mips_elf_link_hash_entry *h,
6022 asection *sec, bfd_vma symbol,
6023 bfd_vma *addendp, asection *input_section)
6025 Elf_Internal_Rela outrel[3];
6030 bfd_boolean defined_p;
6031 struct mips_elf_link_hash_table *htab;
6033 htab = mips_elf_hash_table (info);
6034 BFD_ASSERT (htab != NULL);
6036 r_type = ELF_R_TYPE (output_bfd, rel->r_info);
6037 dynobj = elf_hash_table (info)->dynobj;
6038 sreloc = mips_elf_rel_dyn_section (info, FALSE);
6039 BFD_ASSERT (sreloc != NULL);
6040 BFD_ASSERT (sreloc->contents != NULL);
6041 BFD_ASSERT (sreloc->reloc_count * MIPS_ELF_REL_SIZE (output_bfd)
6044 outrel[0].r_offset =
6045 _bfd_elf_section_offset (output_bfd, info, input_section, rel[0].r_offset);
6046 if (ABI_64_P (output_bfd))
6048 outrel[1].r_offset =
6049 _bfd_elf_section_offset (output_bfd, info, input_section, rel[1].r_offset);
6050 outrel[2].r_offset =
6051 _bfd_elf_section_offset (output_bfd, info, input_section, rel[2].r_offset);
6054 if (outrel[0].r_offset == MINUS_ONE)
6055 /* The relocation field has been deleted. */
6058 if (outrel[0].r_offset == MINUS_TWO)
6060 /* The relocation field has been converted into a relative value of
6061 some sort. Functions like _bfd_elf_write_section_eh_frame expect
6062 the field to be fully relocated, so add in the symbol's value. */
6067 /* We must now calculate the dynamic symbol table index to use
6068 in the relocation. */
6069 if (h != NULL && ! SYMBOL_REFERENCES_LOCAL (info, &h->root))
6071 BFD_ASSERT (htab->is_vxworks || h->global_got_area != GGA_NONE);
6072 indx = h->root.dynindx;
6073 if (SGI_COMPAT (output_bfd))
6074 defined_p = h->root.def_regular;
6076 /* ??? glibc's ld.so just adds the final GOT entry to the
6077 relocation field. It therefore treats relocs against
6078 defined symbols in the same way as relocs against
6079 undefined symbols. */
6084 if (sec != NULL && bfd_is_abs_section (sec))
6086 else if (sec == NULL || sec->owner == NULL)
6088 bfd_set_error (bfd_error_bad_value);
6093 indx = elf_section_data (sec->output_section)->dynindx;
6096 asection *osec = htab->root.text_index_section;
6097 indx = elf_section_data (osec)->dynindx;
6103 /* Instead of generating a relocation using the section
6104 symbol, we may as well make it a fully relative
6105 relocation. We want to avoid generating relocations to
6106 local symbols because we used to generate them
6107 incorrectly, without adding the original symbol value,
6108 which is mandated by the ABI for section symbols. In
6109 order to give dynamic loaders and applications time to
6110 phase out the incorrect use, we refrain from emitting
6111 section-relative relocations. It's not like they're
6112 useful, after all. This should be a bit more efficient
6114 /* ??? Although this behavior is compatible with glibc's ld.so,
6115 the ABI says that relocations against STN_UNDEF should have
6116 a symbol value of 0. Irix rld honors this, so relocations
6117 against STN_UNDEF have no effect. */
6118 if (!SGI_COMPAT (output_bfd))
6123 /* If the relocation was previously an absolute relocation and
6124 this symbol will not be referred to by the relocation, we must
6125 adjust it by the value we give it in the dynamic symbol table.
6126 Otherwise leave the job up to the dynamic linker. */
6127 if (defined_p && r_type != R_MIPS_REL32)
6130 if (htab->is_vxworks)
6131 /* VxWorks uses non-relative relocations for this. */
6132 outrel[0].r_info = ELF32_R_INFO (indx, R_MIPS_32);
6134 /* The relocation is always an REL32 relocation because we don't
6135 know where the shared library will wind up at load-time. */
6136 outrel[0].r_info = ELF_R_INFO (output_bfd, (unsigned long) indx,
6139 /* For strict adherence to the ABI specification, we should
6140 generate a R_MIPS_64 relocation record by itself before the
6141 _REL32/_64 record as well, such that the addend is read in as
6142 a 64-bit value (REL32 is a 32-bit relocation, after all).
6143 However, since none of the existing ELF64 MIPS dynamic
6144 loaders seems to care, we don't waste space with these
6145 artificial relocations. If this turns out to not be true,
6146 mips_elf_allocate_dynamic_relocation() should be tweaked so
6147 as to make room for a pair of dynamic relocations per
6148 invocation if ABI_64_P, and here we should generate an
6149 additional relocation record with R_MIPS_64 by itself for a
6150 NULL symbol before this relocation record. */
6151 outrel[1].r_info = ELF_R_INFO (output_bfd, 0,
6152 ABI_64_P (output_bfd)
6155 outrel[2].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_NONE);
6157 /* Adjust the output offset of the relocation to reference the
6158 correct location in the output file. */
6159 outrel[0].r_offset += (input_section->output_section->vma
6160 + input_section->output_offset);
6161 outrel[1].r_offset += (input_section->output_section->vma
6162 + input_section->output_offset);
6163 outrel[2].r_offset += (input_section->output_section->vma
6164 + input_section->output_offset);
6166 /* Put the relocation back out. We have to use the special
6167 relocation outputter in the 64-bit case since the 64-bit
6168 relocation format is non-standard. */
6169 if (ABI_64_P (output_bfd))
6171 (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
6172 (output_bfd, &outrel[0],
6174 + sreloc->reloc_count * sizeof (Elf64_Mips_External_Rel)));
6176 else if (htab->is_vxworks)
6178 /* VxWorks uses RELA rather than REL dynamic relocations. */
6179 outrel[0].r_addend = *addendp;
6180 bfd_elf32_swap_reloca_out
6181 (output_bfd, &outrel[0],
6183 + sreloc->reloc_count * sizeof (Elf32_External_Rela)));
6186 bfd_elf32_swap_reloc_out
6187 (output_bfd, &outrel[0],
6188 (sreloc->contents + sreloc->reloc_count * sizeof (Elf32_External_Rel)));
6190 /* We've now added another relocation. */
6191 ++sreloc->reloc_count;
6193 /* Make sure the output section is writable. The dynamic linker
6194 will be writing to it. */
6195 elf_section_data (input_section->output_section)->this_hdr.sh_flags
6198 /* On IRIX5, make an entry of compact relocation info. */
6199 if (IRIX_COMPAT (output_bfd) == ict_irix5)
6201 asection *scpt = bfd_get_linker_section (dynobj, ".compact_rel");
6206 Elf32_crinfo cptrel;
6208 mips_elf_set_cr_format (cptrel, CRF_MIPS_LONG);
6209 cptrel.vaddr = (rel->r_offset
6210 + input_section->output_section->vma
6211 + input_section->output_offset);
6212 if (r_type == R_MIPS_REL32)
6213 mips_elf_set_cr_type (cptrel, CRT_MIPS_REL32);
6215 mips_elf_set_cr_type (cptrel, CRT_MIPS_WORD);
6216 mips_elf_set_cr_dist2to (cptrel, 0);
6217 cptrel.konst = *addendp;
6219 cr = (scpt->contents
6220 + sizeof (Elf32_External_compact_rel));
6221 mips_elf_set_cr_relvaddr (cptrel, 0);
6222 bfd_elf32_swap_crinfo_out (output_bfd, &cptrel,
6223 ((Elf32_External_crinfo *) cr
6224 + scpt->reloc_count));
6225 ++scpt->reloc_count;
6229 /* If we've written this relocation for a readonly section,
6230 we need to set DF_TEXTREL again, so that we do not delete the
6232 if (MIPS_ELF_READONLY_SECTION (input_section))
6233 info->flags |= DF_TEXTREL;
6238 /* Return the MACH for a MIPS e_flags value. */
6241 _bfd_elf_mips_mach (flagword flags)
6243 switch (flags & EF_MIPS_MACH)
6245 case E_MIPS_MACH_3900:
6246 return bfd_mach_mips3900;
6248 case E_MIPS_MACH_4010:
6249 return bfd_mach_mips4010;
6251 case E_MIPS_MACH_4100:
6252 return bfd_mach_mips4100;
6254 case E_MIPS_MACH_4111:
6255 return bfd_mach_mips4111;
6257 case E_MIPS_MACH_4120:
6258 return bfd_mach_mips4120;
6260 case E_MIPS_MACH_4650:
6261 return bfd_mach_mips4650;
6263 case E_MIPS_MACH_5400:
6264 return bfd_mach_mips5400;
6266 case E_MIPS_MACH_5500:
6267 return bfd_mach_mips5500;
6269 case E_MIPS_MACH_9000:
6270 return bfd_mach_mips9000;
6272 case E_MIPS_MACH_SB1:
6273 return bfd_mach_mips_sb1;
6275 case E_MIPS_MACH_LS2E:
6276 return bfd_mach_mips_loongson_2e;
6278 case E_MIPS_MACH_LS2F:
6279 return bfd_mach_mips_loongson_2f;
6281 case E_MIPS_MACH_LS3A:
6282 return bfd_mach_mips_loongson_3a;
6284 case E_MIPS_MACH_OCTEON2:
6285 return bfd_mach_mips_octeon2;
6287 case E_MIPS_MACH_OCTEON:
6288 return bfd_mach_mips_octeon;
6290 case E_MIPS_MACH_XLR:
6291 return bfd_mach_mips_xlr;
6294 switch (flags & EF_MIPS_ARCH)
6298 return bfd_mach_mips3000;
6301 return bfd_mach_mips6000;
6304 return bfd_mach_mips4000;
6307 return bfd_mach_mips8000;
6310 return bfd_mach_mips5;
6312 case E_MIPS_ARCH_32:
6313 return bfd_mach_mipsisa32;
6315 case E_MIPS_ARCH_64:
6316 return bfd_mach_mipsisa64;
6318 case E_MIPS_ARCH_32R2:
6319 return bfd_mach_mipsisa32r2;
6321 case E_MIPS_ARCH_64R2:
6322 return bfd_mach_mipsisa64r2;
6329 /* Return printable name for ABI. */
6331 static INLINE char *
6332 elf_mips_abi_name (bfd *abfd)
6336 flags = elf_elfheader (abfd)->e_flags;
6337 switch (flags & EF_MIPS_ABI)
6340 if (ABI_N32_P (abfd))
6342 else if (ABI_64_P (abfd))
6346 case E_MIPS_ABI_O32:
6348 case E_MIPS_ABI_O64:
6350 case E_MIPS_ABI_EABI32:
6352 case E_MIPS_ABI_EABI64:
6355 return "unknown abi";
6359 /* MIPS ELF uses two common sections. One is the usual one, and the
6360 other is for small objects. All the small objects are kept
6361 together, and then referenced via the gp pointer, which yields
6362 faster assembler code. This is what we use for the small common
6363 section. This approach is copied from ecoff.c. */
6364 static asection mips_elf_scom_section;
6365 static asymbol mips_elf_scom_symbol;
6366 static asymbol *mips_elf_scom_symbol_ptr;
6368 /* MIPS ELF also uses an acommon section, which represents an
6369 allocated common symbol which may be overridden by a
6370 definition in a shared library. */
6371 static asection mips_elf_acom_section;
6372 static asymbol mips_elf_acom_symbol;
6373 static asymbol *mips_elf_acom_symbol_ptr;
6375 /* This is used for both the 32-bit and the 64-bit ABI. */
6378 _bfd_mips_elf_symbol_processing (bfd *abfd, asymbol *asym)
6380 elf_symbol_type *elfsym;
6382 /* Handle the special MIPS section numbers that a symbol may use. */
6383 elfsym = (elf_symbol_type *) asym;
6384 switch (elfsym->internal_elf_sym.st_shndx)
6386 case SHN_MIPS_ACOMMON:
6387 /* This section is used in a dynamically linked executable file.
6388 It is an allocated common section. The dynamic linker can
6389 either resolve these symbols to something in a shared
6390 library, or it can just leave them here. For our purposes,
6391 we can consider these symbols to be in a new section. */
6392 if (mips_elf_acom_section.name == NULL)
6394 /* Initialize the acommon section. */
6395 mips_elf_acom_section.name = ".acommon";
6396 mips_elf_acom_section.flags = SEC_ALLOC;
6397 mips_elf_acom_section.output_section = &mips_elf_acom_section;
6398 mips_elf_acom_section.symbol = &mips_elf_acom_symbol;
6399 mips_elf_acom_section.symbol_ptr_ptr = &mips_elf_acom_symbol_ptr;
6400 mips_elf_acom_symbol.name = ".acommon";
6401 mips_elf_acom_symbol.flags = BSF_SECTION_SYM;
6402 mips_elf_acom_symbol.section = &mips_elf_acom_section;
6403 mips_elf_acom_symbol_ptr = &mips_elf_acom_symbol;
6405 asym->section = &mips_elf_acom_section;
6409 /* Common symbols less than the GP size are automatically
6410 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
6411 if (asym->value > elf_gp_size (abfd)
6412 || ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_TLS
6413 || IRIX_COMPAT (abfd) == ict_irix6)
6416 case SHN_MIPS_SCOMMON:
6417 if (mips_elf_scom_section.name == NULL)
6419 /* Initialize the small common section. */
6420 mips_elf_scom_section.name = ".scommon";
6421 mips_elf_scom_section.flags = SEC_IS_COMMON;
6422 mips_elf_scom_section.output_section = &mips_elf_scom_section;
6423 mips_elf_scom_section.symbol = &mips_elf_scom_symbol;
6424 mips_elf_scom_section.symbol_ptr_ptr = &mips_elf_scom_symbol_ptr;
6425 mips_elf_scom_symbol.name = ".scommon";
6426 mips_elf_scom_symbol.flags = BSF_SECTION_SYM;
6427 mips_elf_scom_symbol.section = &mips_elf_scom_section;
6428 mips_elf_scom_symbol_ptr = &mips_elf_scom_symbol;
6430 asym->section = &mips_elf_scom_section;
6431 asym->value = elfsym->internal_elf_sym.st_size;
6434 case SHN_MIPS_SUNDEFINED:
6435 asym->section = bfd_und_section_ptr;
6440 asection *section = bfd_get_section_by_name (abfd, ".text");
6442 if (section != NULL)
6444 asym->section = section;
6445 /* MIPS_TEXT is a bit special, the address is not an offset
6446 to the base of the .text section. So substract the section
6447 base address to make it an offset. */
6448 asym->value -= section->vma;
6455 asection *section = bfd_get_section_by_name (abfd, ".data");
6457 if (section != NULL)
6459 asym->section = section;
6460 /* MIPS_DATA is a bit special, the address is not an offset
6461 to the base of the .data section. So substract the section
6462 base address to make it an offset. */
6463 asym->value -= section->vma;
6469 /* If this is an odd-valued function symbol, assume it's a MIPS16
6470 or microMIPS one. */
6471 if (ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_FUNC
6472 && (asym->value & 1) != 0)
6475 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
6476 elfsym->internal_elf_sym.st_other
6477 = ELF_ST_SET_MICROMIPS (elfsym->internal_elf_sym.st_other);
6479 elfsym->internal_elf_sym.st_other
6480 = ELF_ST_SET_MIPS16 (elfsym->internal_elf_sym.st_other);
6484 /* Implement elf_backend_eh_frame_address_size. This differs from
6485 the default in the way it handles EABI64.
6487 EABI64 was originally specified as an LP64 ABI, and that is what
6488 -mabi=eabi normally gives on a 64-bit target. However, gcc has
6489 historically accepted the combination of -mabi=eabi and -mlong32,
6490 and this ILP32 variation has become semi-official over time.
6491 Both forms use elf32 and have pointer-sized FDE addresses.
6493 If an EABI object was generated by GCC 4.0 or above, it will have
6494 an empty .gcc_compiled_longXX section, where XX is the size of longs
6495 in bits. Unfortunately, ILP32 objects generated by earlier compilers
6496 have no special marking to distinguish them from LP64 objects.
6498 We don't want users of the official LP64 ABI to be punished for the
6499 existence of the ILP32 variant, but at the same time, we don't want
6500 to mistakenly interpret pre-4.0 ILP32 objects as being LP64 objects.
6501 We therefore take the following approach:
6503 - If ABFD contains a .gcc_compiled_longXX section, use it to
6504 determine the pointer size.
6506 - Otherwise check the type of the first relocation. Assume that
6507 the LP64 ABI is being used if the relocation is of type R_MIPS_64.
6511 The second check is enough to detect LP64 objects generated by pre-4.0
6512 compilers because, in the kind of output generated by those compilers,
6513 the first relocation will be associated with either a CIE personality
6514 routine or an FDE start address. Furthermore, the compilers never
6515 used a special (non-pointer) encoding for this ABI.
6517 Checking the relocation type should also be safe because there is no
6518 reason to use R_MIPS_64 in an ILP32 object. Pre-4.0 compilers never
6522 _bfd_mips_elf_eh_frame_address_size (bfd *abfd, asection *sec)
6524 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
6526 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
6528 bfd_boolean long32_p, long64_p;
6530 long32_p = bfd_get_section_by_name (abfd, ".gcc_compiled_long32") != 0;
6531 long64_p = bfd_get_section_by_name (abfd, ".gcc_compiled_long64") != 0;
6532 if (long32_p && long64_p)
6539 if (sec->reloc_count > 0
6540 && elf_section_data (sec)->relocs != NULL
6541 && (ELF32_R_TYPE (elf_section_data (sec)->relocs[0].r_info)
6550 /* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
6551 relocations against two unnamed section symbols to resolve to the
6552 same address. For example, if we have code like:
6554 lw $4,%got_disp(.data)($gp)
6555 lw $25,%got_disp(.text)($gp)
6558 then the linker will resolve both relocations to .data and the program
6559 will jump there rather than to .text.
6561 We can work around this problem by giving names to local section symbols.
6562 This is also what the MIPSpro tools do. */
6565 _bfd_mips_elf_name_local_section_symbols (bfd *abfd)
6567 return SGI_COMPAT (abfd);
6570 /* Work over a section just before writing it out. This routine is
6571 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
6572 sections that need the SHF_MIPS_GPREL flag by name; there has to be
6576 _bfd_mips_elf_section_processing (bfd *abfd, Elf_Internal_Shdr *hdr)
6578 if (hdr->sh_type == SHT_MIPS_REGINFO
6579 && hdr->sh_size > 0)
6583 BFD_ASSERT (hdr->sh_size == sizeof (Elf32_External_RegInfo));
6584 BFD_ASSERT (hdr->contents == NULL);
6587 hdr->sh_offset + sizeof (Elf32_External_RegInfo) - 4,
6590 H_PUT_32 (abfd, elf_gp (abfd), buf);
6591 if (bfd_bwrite (buf, 4, abfd) != 4)
6595 if (hdr->sh_type == SHT_MIPS_OPTIONS
6596 && hdr->bfd_section != NULL
6597 && mips_elf_section_data (hdr->bfd_section) != NULL
6598 && mips_elf_section_data (hdr->bfd_section)->u.tdata != NULL)
6600 bfd_byte *contents, *l, *lend;
6602 /* We stored the section contents in the tdata field in the
6603 set_section_contents routine. We save the section contents
6604 so that we don't have to read them again.
6605 At this point we know that elf_gp is set, so we can look
6606 through the section contents to see if there is an
6607 ODK_REGINFO structure. */
6609 contents = mips_elf_section_data (hdr->bfd_section)->u.tdata;
6611 lend = contents + hdr->sh_size;
6612 while (l + sizeof (Elf_External_Options) <= lend)
6614 Elf_Internal_Options intopt;
6616 bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
6618 if (intopt.size < sizeof (Elf_External_Options))
6620 (*_bfd_error_handler)
6621 (_("%B: Warning: bad `%s' option size %u smaller than its header"),
6622 abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size);
6625 if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
6632 + sizeof (Elf_External_Options)
6633 + (sizeof (Elf64_External_RegInfo) - 8)),
6636 H_PUT_64 (abfd, elf_gp (abfd), buf);
6637 if (bfd_bwrite (buf, 8, abfd) != 8)
6640 else if (intopt.kind == ODK_REGINFO)
6647 + sizeof (Elf_External_Options)
6648 + (sizeof (Elf32_External_RegInfo) - 4)),
6651 H_PUT_32 (abfd, elf_gp (abfd), buf);
6652 if (bfd_bwrite (buf, 4, abfd) != 4)
6659 if (hdr->bfd_section != NULL)
6661 const char *name = bfd_get_section_name (abfd, hdr->bfd_section);
6663 /* .sbss is not handled specially here because the GNU/Linux
6664 prelinker can convert .sbss from NOBITS to PROGBITS and
6665 changing it back to NOBITS breaks the binary. The entry in
6666 _bfd_mips_elf_special_sections will ensure the correct flags
6667 are set on .sbss if BFD creates it without reading it from an
6668 input file, and without special handling here the flags set
6669 on it in an input file will be followed. */
6670 if (strcmp (name, ".sdata") == 0
6671 || strcmp (name, ".lit8") == 0
6672 || strcmp (name, ".lit4") == 0)
6674 hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
6675 hdr->sh_type = SHT_PROGBITS;
6677 else if (strcmp (name, ".srdata") == 0)
6679 hdr->sh_flags |= SHF_ALLOC | SHF_MIPS_GPREL;
6680 hdr->sh_type = SHT_PROGBITS;
6682 else if (strcmp (name, ".compact_rel") == 0)
6685 hdr->sh_type = SHT_PROGBITS;
6687 else if (strcmp (name, ".rtproc") == 0)
6689 if (hdr->sh_addralign != 0 && hdr->sh_entsize == 0)
6691 unsigned int adjust;
6693 adjust = hdr->sh_size % hdr->sh_addralign;
6695 hdr->sh_size += hdr->sh_addralign - adjust;
6703 /* Handle a MIPS specific section when reading an object file. This
6704 is called when elfcode.h finds a section with an unknown type.
6705 This routine supports both the 32-bit and 64-bit ELF ABI.
6707 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
6711 _bfd_mips_elf_section_from_shdr (bfd *abfd,
6712 Elf_Internal_Shdr *hdr,
6718 /* There ought to be a place to keep ELF backend specific flags, but
6719 at the moment there isn't one. We just keep track of the
6720 sections by their name, instead. Fortunately, the ABI gives
6721 suggested names for all the MIPS specific sections, so we will
6722 probably get away with this. */
6723 switch (hdr->sh_type)
6725 case SHT_MIPS_LIBLIST:
6726 if (strcmp (name, ".liblist") != 0)
6730 if (strcmp (name, ".msym") != 0)
6733 case SHT_MIPS_CONFLICT:
6734 if (strcmp (name, ".conflict") != 0)
6737 case SHT_MIPS_GPTAB:
6738 if (! CONST_STRNEQ (name, ".gptab."))
6741 case SHT_MIPS_UCODE:
6742 if (strcmp (name, ".ucode") != 0)
6745 case SHT_MIPS_DEBUG:
6746 if (strcmp (name, ".mdebug") != 0)
6748 flags = SEC_DEBUGGING;
6750 case SHT_MIPS_REGINFO:
6751 if (strcmp (name, ".reginfo") != 0
6752 || hdr->sh_size != sizeof (Elf32_External_RegInfo))
6754 flags = (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_SIZE);
6756 case SHT_MIPS_IFACE:
6757 if (strcmp (name, ".MIPS.interfaces") != 0)
6760 case SHT_MIPS_CONTENT:
6761 if (! CONST_STRNEQ (name, ".MIPS.content"))
6764 case SHT_MIPS_OPTIONS:
6765 if (!MIPS_ELF_OPTIONS_SECTION_NAME_P (name))
6768 case SHT_MIPS_DWARF:
6769 if (! CONST_STRNEQ (name, ".debug_")
6770 && ! CONST_STRNEQ (name, ".zdebug_"))
6773 case SHT_MIPS_SYMBOL_LIB:
6774 if (strcmp (name, ".MIPS.symlib") != 0)
6777 case SHT_MIPS_EVENTS:
6778 if (! CONST_STRNEQ (name, ".MIPS.events")
6779 && ! CONST_STRNEQ (name, ".MIPS.post_rel"))
6786 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
6791 if (! bfd_set_section_flags (abfd, hdr->bfd_section,
6792 (bfd_get_section_flags (abfd,
6798 /* FIXME: We should record sh_info for a .gptab section. */
6800 /* For a .reginfo section, set the gp value in the tdata information
6801 from the contents of this section. We need the gp value while
6802 processing relocs, so we just get it now. The .reginfo section
6803 is not used in the 64-bit MIPS ELF ABI. */
6804 if (hdr->sh_type == SHT_MIPS_REGINFO)
6806 Elf32_External_RegInfo ext;
6809 if (! bfd_get_section_contents (abfd, hdr->bfd_section,
6810 &ext, 0, sizeof ext))
6812 bfd_mips_elf32_swap_reginfo_in (abfd, &ext, &s);
6813 elf_gp (abfd) = s.ri_gp_value;
6816 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
6817 set the gp value based on what we find. We may see both
6818 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
6819 they should agree. */
6820 if (hdr->sh_type == SHT_MIPS_OPTIONS)
6822 bfd_byte *contents, *l, *lend;
6824 contents = bfd_malloc (hdr->sh_size);
6825 if (contents == NULL)
6827 if (! bfd_get_section_contents (abfd, hdr->bfd_section, contents,
6834 lend = contents + hdr->sh_size;
6835 while (l + sizeof (Elf_External_Options) <= lend)
6837 Elf_Internal_Options intopt;
6839 bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
6841 if (intopt.size < sizeof (Elf_External_Options))
6843 (*_bfd_error_handler)
6844 (_("%B: Warning: bad `%s' option size %u smaller than its header"),
6845 abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size);
6848 if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
6850 Elf64_Internal_RegInfo intreg;
6852 bfd_mips_elf64_swap_reginfo_in
6854 ((Elf64_External_RegInfo *)
6855 (l + sizeof (Elf_External_Options))),
6857 elf_gp (abfd) = intreg.ri_gp_value;
6859 else if (intopt.kind == ODK_REGINFO)
6861 Elf32_RegInfo intreg;
6863 bfd_mips_elf32_swap_reginfo_in
6865 ((Elf32_External_RegInfo *)
6866 (l + sizeof (Elf_External_Options))),
6868 elf_gp (abfd) = intreg.ri_gp_value;
6878 /* Set the correct type for a MIPS ELF section. We do this by the
6879 section name, which is a hack, but ought to work. This routine is
6880 used by both the 32-bit and the 64-bit ABI. */
6883 _bfd_mips_elf_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec)
6885 const char *name = bfd_get_section_name (abfd, sec);
6887 if (strcmp (name, ".liblist") == 0)
6889 hdr->sh_type = SHT_MIPS_LIBLIST;
6890 hdr->sh_info = sec->size / sizeof (Elf32_Lib);
6891 /* The sh_link field is set in final_write_processing. */
6893 else if (strcmp (name, ".conflict") == 0)
6894 hdr->sh_type = SHT_MIPS_CONFLICT;
6895 else if (CONST_STRNEQ (name, ".gptab."))
6897 hdr->sh_type = SHT_MIPS_GPTAB;
6898 hdr->sh_entsize = sizeof (Elf32_External_gptab);
6899 /* The sh_info field is set in final_write_processing. */
6901 else if (strcmp (name, ".ucode") == 0)
6902 hdr->sh_type = SHT_MIPS_UCODE;
6903 else if (strcmp (name, ".mdebug") == 0)
6905 hdr->sh_type = SHT_MIPS_DEBUG;
6906 /* In a shared object on IRIX 5.3, the .mdebug section has an
6907 entsize of 0. FIXME: Does this matter? */
6908 if (SGI_COMPAT (abfd) && (abfd->flags & DYNAMIC) != 0)
6909 hdr->sh_entsize = 0;
6911 hdr->sh_entsize = 1;
6913 else if (strcmp (name, ".reginfo") == 0)
6915 hdr->sh_type = SHT_MIPS_REGINFO;
6916 /* In a shared object on IRIX 5.3, the .reginfo section has an
6917 entsize of 0x18. FIXME: Does this matter? */
6918 if (SGI_COMPAT (abfd))
6920 if ((abfd->flags & DYNAMIC) != 0)
6921 hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
6923 hdr->sh_entsize = 1;
6926 hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
6928 else if (SGI_COMPAT (abfd)
6929 && (strcmp (name, ".hash") == 0
6930 || strcmp (name, ".dynamic") == 0
6931 || strcmp (name, ".dynstr") == 0))
6933 if (SGI_COMPAT (abfd))
6934 hdr->sh_entsize = 0;
6936 /* This isn't how the IRIX6 linker behaves. */
6937 hdr->sh_info = SIZEOF_MIPS_DYNSYM_SECNAMES;
6940 else if (strcmp (name, ".got") == 0
6941 || strcmp (name, ".srdata") == 0
6942 || strcmp (name, ".sdata") == 0
6943 || strcmp (name, ".sbss") == 0
6944 || strcmp (name, ".lit4") == 0
6945 || strcmp (name, ".lit8") == 0)
6946 hdr->sh_flags |= SHF_MIPS_GPREL;
6947 else if (strcmp (name, ".MIPS.interfaces") == 0)
6949 hdr->sh_type = SHT_MIPS_IFACE;
6950 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
6952 else if (CONST_STRNEQ (name, ".MIPS.content"))
6954 hdr->sh_type = SHT_MIPS_CONTENT;
6955 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
6956 /* The sh_info field is set in final_write_processing. */
6958 else if (MIPS_ELF_OPTIONS_SECTION_NAME_P (name))
6960 hdr->sh_type = SHT_MIPS_OPTIONS;
6961 hdr->sh_entsize = 1;
6962 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
6964 else if (CONST_STRNEQ (name, ".debug_")
6965 || CONST_STRNEQ (name, ".zdebug_"))
6967 hdr->sh_type = SHT_MIPS_DWARF;
6969 /* Irix facilities such as libexc expect a single .debug_frame
6970 per executable, the system ones have NOSTRIP set and the linker
6971 doesn't merge sections with different flags so ... */
6972 if (SGI_COMPAT (abfd) && CONST_STRNEQ (name, ".debug_frame"))
6973 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
6975 else if (strcmp (name, ".MIPS.symlib") == 0)
6977 hdr->sh_type = SHT_MIPS_SYMBOL_LIB;
6978 /* The sh_link and sh_info fields are set in
6979 final_write_processing. */
6981 else if (CONST_STRNEQ (name, ".MIPS.events")
6982 || CONST_STRNEQ (name, ".MIPS.post_rel"))
6984 hdr->sh_type = SHT_MIPS_EVENTS;
6985 hdr->sh_flags |= SHF_MIPS_NOSTRIP;
6986 /* The sh_link field is set in final_write_processing. */
6988 else if (strcmp (name, ".msym") == 0)
6990 hdr->sh_type = SHT_MIPS_MSYM;
6991 hdr->sh_flags |= SHF_ALLOC;
6992 hdr->sh_entsize = 8;
6995 /* The generic elf_fake_sections will set up REL_HDR using the default
6996 kind of relocations. We used to set up a second header for the
6997 non-default kind of relocations here, but only NewABI would use
6998 these, and the IRIX ld doesn't like resulting empty RELA sections.
6999 Thus we create those header only on demand now. */
7004 /* Given a BFD section, try to locate the corresponding ELF section
7005 index. This is used by both the 32-bit and the 64-bit ABI.
7006 Actually, it's not clear to me that the 64-bit ABI supports these,
7007 but for non-PIC objects we will certainly want support for at least
7008 the .scommon section. */
7011 _bfd_mips_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
7012 asection *sec, int *retval)
7014 if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
7016 *retval = SHN_MIPS_SCOMMON;
7019 if (strcmp (bfd_get_section_name (abfd, sec), ".acommon") == 0)
7021 *retval = SHN_MIPS_ACOMMON;
7027 /* Hook called by the linker routine which adds symbols from an object
7028 file. We must handle the special MIPS section numbers here. */
7031 _bfd_mips_elf_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
7032 Elf_Internal_Sym *sym, const char **namep,
7033 flagword *flagsp ATTRIBUTE_UNUSED,
7034 asection **secp, bfd_vma *valp)
7036 if (SGI_COMPAT (abfd)
7037 && (abfd->flags & DYNAMIC) != 0
7038 && strcmp (*namep, "_rld_new_interface") == 0)
7040 /* Skip IRIX5 rld entry name. */
7045 /* Shared objects may have a dynamic symbol '_gp_disp' defined as
7046 a SECTION *ABS*. This causes ld to think it can resolve _gp_disp
7047 by setting a DT_NEEDED for the shared object. Since _gp_disp is
7048 a magic symbol resolved by the linker, we ignore this bogus definition
7049 of _gp_disp. New ABI objects do not suffer from this problem so this
7050 is not done for them. */
7052 && (sym->st_shndx == SHN_ABS)
7053 && (strcmp (*namep, "_gp_disp") == 0))
7059 switch (sym->st_shndx)
7062 /* Common symbols less than the GP size are automatically
7063 treated as SHN_MIPS_SCOMMON symbols. */
7064 if (sym->st_size > elf_gp_size (abfd)
7065 || ELF_ST_TYPE (sym->st_info) == STT_TLS
7066 || IRIX_COMPAT (abfd) == ict_irix6)
7069 case SHN_MIPS_SCOMMON:
7070 *secp = bfd_make_section_old_way (abfd, ".scommon");
7071 (*secp)->flags |= SEC_IS_COMMON;
7072 *valp = sym->st_size;
7076 /* This section is used in a shared object. */
7077 if (elf_tdata (abfd)->elf_text_section == NULL)
7079 asymbol *elf_text_symbol;
7080 asection *elf_text_section;
7081 bfd_size_type amt = sizeof (asection);
7083 elf_text_section = bfd_zalloc (abfd, amt);
7084 if (elf_text_section == NULL)
7087 amt = sizeof (asymbol);
7088 elf_text_symbol = bfd_zalloc (abfd, amt);
7089 if (elf_text_symbol == NULL)
7092 /* Initialize the section. */
7094 elf_tdata (abfd)->elf_text_section = elf_text_section;
7095 elf_tdata (abfd)->elf_text_symbol = elf_text_symbol;
7097 elf_text_section->symbol = elf_text_symbol;
7098 elf_text_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_text_symbol;
7100 elf_text_section->name = ".text";
7101 elf_text_section->flags = SEC_NO_FLAGS;
7102 elf_text_section->output_section = NULL;
7103 elf_text_section->owner = abfd;
7104 elf_text_symbol->name = ".text";
7105 elf_text_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
7106 elf_text_symbol->section = elf_text_section;
7108 /* This code used to do *secp = bfd_und_section_ptr if
7109 info->shared. I don't know why, and that doesn't make sense,
7110 so I took it out. */
7111 *secp = elf_tdata (abfd)->elf_text_section;
7114 case SHN_MIPS_ACOMMON:
7115 /* Fall through. XXX Can we treat this as allocated data? */
7117 /* This section is used in a shared object. */
7118 if (elf_tdata (abfd)->elf_data_section == NULL)
7120 asymbol *elf_data_symbol;
7121 asection *elf_data_section;
7122 bfd_size_type amt = sizeof (asection);
7124 elf_data_section = bfd_zalloc (abfd, amt);
7125 if (elf_data_section == NULL)
7128 amt = sizeof (asymbol);
7129 elf_data_symbol = bfd_zalloc (abfd, amt);
7130 if (elf_data_symbol == NULL)
7133 /* Initialize the section. */
7135 elf_tdata (abfd)->elf_data_section = elf_data_section;
7136 elf_tdata (abfd)->elf_data_symbol = elf_data_symbol;
7138 elf_data_section->symbol = elf_data_symbol;
7139 elf_data_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_data_symbol;
7141 elf_data_section->name = ".data";
7142 elf_data_section->flags = SEC_NO_FLAGS;
7143 elf_data_section->output_section = NULL;
7144 elf_data_section->owner = abfd;
7145 elf_data_symbol->name = ".data";
7146 elf_data_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
7147 elf_data_symbol->section = elf_data_section;
7149 /* This code used to do *secp = bfd_und_section_ptr if
7150 info->shared. I don't know why, and that doesn't make sense,
7151 so I took it out. */
7152 *secp = elf_tdata (abfd)->elf_data_section;
7155 case SHN_MIPS_SUNDEFINED:
7156 *secp = bfd_und_section_ptr;
7160 if (SGI_COMPAT (abfd)
7162 && info->output_bfd->xvec == abfd->xvec
7163 && strcmp (*namep, "__rld_obj_head") == 0)
7165 struct elf_link_hash_entry *h;
7166 struct bfd_link_hash_entry *bh;
7168 /* Mark __rld_obj_head as dynamic. */
7170 if (! (_bfd_generic_link_add_one_symbol
7171 (info, abfd, *namep, BSF_GLOBAL, *secp, *valp, NULL, FALSE,
7172 get_elf_backend_data (abfd)->collect, &bh)))
7175 h = (struct elf_link_hash_entry *) bh;
7178 h->type = STT_OBJECT;
7180 if (! bfd_elf_link_record_dynamic_symbol (info, h))
7183 mips_elf_hash_table (info)->use_rld_obj_head = TRUE;
7184 mips_elf_hash_table (info)->rld_symbol = h;
7187 /* If this is a mips16 text symbol, add 1 to the value to make it
7188 odd. This will cause something like .word SYM to come up with
7189 the right value when it is loaded into the PC. */
7190 if (ELF_ST_IS_COMPRESSED (sym->st_other))
7196 /* This hook function is called before the linker writes out a global
7197 symbol. We mark symbols as small common if appropriate. This is
7198 also where we undo the increment of the value for a mips16 symbol. */
7201 _bfd_mips_elf_link_output_symbol_hook
7202 (struct bfd_link_info *info ATTRIBUTE_UNUSED,
7203 const char *name ATTRIBUTE_UNUSED, Elf_Internal_Sym *sym,
7204 asection *input_sec, struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
7206 /* If we see a common symbol, which implies a relocatable link, then
7207 if a symbol was small common in an input file, mark it as small
7208 common in the output file. */
7209 if (sym->st_shndx == SHN_COMMON
7210 && strcmp (input_sec->name, ".scommon") == 0)
7211 sym->st_shndx = SHN_MIPS_SCOMMON;
7213 if (ELF_ST_IS_COMPRESSED (sym->st_other))
7214 sym->st_value &= ~1;
7219 /* Functions for the dynamic linker. */
7221 /* Create dynamic sections when linking against a dynamic object. */
7224 _bfd_mips_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
7226 struct elf_link_hash_entry *h;
7227 struct bfd_link_hash_entry *bh;
7229 register asection *s;
7230 const char * const *namep;
7231 struct mips_elf_link_hash_table *htab;
7233 htab = mips_elf_hash_table (info);
7234 BFD_ASSERT (htab != NULL);
7236 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
7237 | SEC_LINKER_CREATED | SEC_READONLY);
7239 /* The psABI requires a read-only .dynamic section, but the VxWorks
7241 if (!htab->is_vxworks)
7243 s = bfd_get_linker_section (abfd, ".dynamic");
7246 if (! bfd_set_section_flags (abfd, s, flags))
7251 /* We need to create .got section. */
7252 if (!mips_elf_create_got_section (abfd, info))
7255 if (! mips_elf_rel_dyn_section (info, TRUE))
7258 /* Create .stub section. */
7259 s = bfd_make_section_anyway_with_flags (abfd,
7260 MIPS_ELF_STUB_SECTION_NAME (abfd),
7263 || ! bfd_set_section_alignment (abfd, s,
7264 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
7268 if ((IRIX_COMPAT (abfd) == ict_irix5 || IRIX_COMPAT (abfd) == ict_none)
7270 && bfd_get_linker_section (abfd, ".rld_map") == NULL)
7272 s = bfd_make_section_anyway_with_flags (abfd, ".rld_map",
7273 flags &~ (flagword) SEC_READONLY);
7275 || ! bfd_set_section_alignment (abfd, s,
7276 MIPS_ELF_LOG_FILE_ALIGN (abfd)))
7280 /* On IRIX5, we adjust add some additional symbols and change the
7281 alignments of several sections. There is no ABI documentation
7282 indicating that this is necessary on IRIX6, nor any evidence that
7283 the linker takes such action. */
7284 if (IRIX_COMPAT (abfd) == ict_irix5)
7286 for (namep = mips_elf_dynsym_rtproc_names; *namep != NULL; namep++)
7289 if (! (_bfd_generic_link_add_one_symbol
7290 (info, abfd, *namep, BSF_GLOBAL, bfd_und_section_ptr, 0,
7291 NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
7294 h = (struct elf_link_hash_entry *) bh;
7297 h->type = STT_SECTION;
7299 if (! bfd_elf_link_record_dynamic_symbol (info, h))
7303 /* We need to create a .compact_rel section. */
7304 if (SGI_COMPAT (abfd))
7306 if (!mips_elf_create_compact_rel_section (abfd, info))
7310 /* Change alignments of some sections. */
7311 s = bfd_get_linker_section (abfd, ".hash");
7313 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7314 s = bfd_get_linker_section (abfd, ".dynsym");
7316 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7317 s = bfd_get_linker_section (abfd, ".dynstr");
7319 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7321 s = bfd_get_section_by_name (abfd, ".reginfo");
7323 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7324 s = bfd_get_linker_section (abfd, ".dynamic");
7326 bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
7333 name = SGI_COMPAT (abfd) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
7335 if (!(_bfd_generic_link_add_one_symbol
7336 (info, abfd, name, BSF_GLOBAL, bfd_abs_section_ptr, 0,
7337 NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
7340 h = (struct elf_link_hash_entry *) bh;
7343 h->type = STT_SECTION;
7345 if (! bfd_elf_link_record_dynamic_symbol (info, h))
7348 if (! mips_elf_hash_table (info)->use_rld_obj_head)
7350 /* __rld_map is a four byte word located in the .data section
7351 and is filled in by the rtld to contain a pointer to
7352 the _r_debug structure. Its symbol value will be set in
7353 _bfd_mips_elf_finish_dynamic_symbol. */
7354 s = bfd_get_linker_section (abfd, ".rld_map");
7355 BFD_ASSERT (s != NULL);
7357 name = SGI_COMPAT (abfd) ? "__rld_map" : "__RLD_MAP";
7359 if (!(_bfd_generic_link_add_one_symbol
7360 (info, abfd, name, BSF_GLOBAL, s, 0, NULL, FALSE,
7361 get_elf_backend_data (abfd)->collect, &bh)))
7364 h = (struct elf_link_hash_entry *) bh;
7367 h->type = STT_OBJECT;
7369 if (! bfd_elf_link_record_dynamic_symbol (info, h))
7371 mips_elf_hash_table (info)->rld_symbol = h;
7375 /* Create the .plt, .rel(a).plt, .dynbss and .rel(a).bss sections.
7376 Also create the _PROCEDURE_LINKAGE_TABLE symbol. */
7377 if (!_bfd_elf_create_dynamic_sections (abfd, info))
7380 /* Cache the sections created above. */
7381 htab->splt = bfd_get_linker_section (abfd, ".plt");
7382 htab->sdynbss = bfd_get_linker_section (abfd, ".dynbss");
7383 if (htab->is_vxworks)
7385 htab->srelbss = bfd_get_linker_section (abfd, ".rela.bss");
7386 htab->srelplt = bfd_get_linker_section (abfd, ".rela.plt");
7389 htab->srelplt = bfd_get_linker_section (abfd, ".rel.plt");
7391 || (htab->is_vxworks && !htab->srelbss && !info->shared)
7396 if (htab->is_vxworks)
7398 /* Do the usual VxWorks handling. */
7399 if (!elf_vxworks_create_dynamic_sections (abfd, info, &htab->srelplt2))
7402 /* Work out the PLT sizes. */
7405 htab->plt_header_size
7406 = 4 * ARRAY_SIZE (mips_vxworks_shared_plt0_entry);
7407 htab->plt_entry_size
7408 = 4 * ARRAY_SIZE (mips_vxworks_shared_plt_entry);
7412 htab->plt_header_size
7413 = 4 * ARRAY_SIZE (mips_vxworks_exec_plt0_entry);
7414 htab->plt_entry_size
7415 = 4 * ARRAY_SIZE (mips_vxworks_exec_plt_entry);
7418 else if (!info->shared)
7420 /* All variants of the plt0 entry are the same size. */
7421 htab->plt_header_size = 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry);
7422 htab->plt_entry_size = 4 * ARRAY_SIZE (mips_exec_plt_entry);
7428 /* Return true if relocation REL against section SEC is a REL rather than
7429 RELA relocation. RELOCS is the first relocation in the section and
7430 ABFD is the bfd that contains SEC. */
7433 mips_elf_rel_relocation_p (bfd *abfd, asection *sec,
7434 const Elf_Internal_Rela *relocs,
7435 const Elf_Internal_Rela *rel)
7437 Elf_Internal_Shdr *rel_hdr;
7438 const struct elf_backend_data *bed;
7440 /* To determine which flavor of relocation this is, we depend on the
7441 fact that the INPUT_SECTION's REL_HDR is read before RELA_HDR. */
7442 rel_hdr = elf_section_data (sec)->rel.hdr;
7443 if (rel_hdr == NULL)
7445 bed = get_elf_backend_data (abfd);
7446 return ((size_t) (rel - relocs)
7447 < NUM_SHDR_ENTRIES (rel_hdr) * bed->s->int_rels_per_ext_rel);
7450 /* Read the addend for REL relocation REL, which belongs to bfd ABFD.
7451 HOWTO is the relocation's howto and CONTENTS points to the contents
7452 of the section that REL is against. */
7455 mips_elf_read_rel_addend (bfd *abfd, const Elf_Internal_Rela *rel,
7456 reloc_howto_type *howto, bfd_byte *contents)
7459 unsigned int r_type;
7462 r_type = ELF_R_TYPE (abfd, rel->r_info);
7463 location = contents + rel->r_offset;
7465 /* Get the addend, which is stored in the input file. */
7466 _bfd_mips_elf_reloc_unshuffle (abfd, r_type, FALSE, location);
7467 addend = mips_elf_obtain_contents (howto, rel, abfd, contents);
7468 _bfd_mips_elf_reloc_shuffle (abfd, r_type, FALSE, location);
7470 return addend & howto->src_mask;
7473 /* REL is a relocation in ABFD that needs a partnering LO16 relocation
7474 and *ADDEND is the addend for REL itself. Look for the LO16 relocation
7475 and update *ADDEND with the final addend. Return true on success
7476 or false if the LO16 could not be found. RELEND is the exclusive
7477 upper bound on the relocations for REL's section. */
7480 mips_elf_add_lo16_rel_addend (bfd *abfd,
7481 const Elf_Internal_Rela *rel,
7482 const Elf_Internal_Rela *relend,
7483 bfd_byte *contents, bfd_vma *addend)
7485 unsigned int r_type, lo16_type;
7486 const Elf_Internal_Rela *lo16_relocation;
7487 reloc_howto_type *lo16_howto;
7490 r_type = ELF_R_TYPE (abfd, rel->r_info);
7491 if (mips16_reloc_p (r_type))
7492 lo16_type = R_MIPS16_LO16;
7493 else if (micromips_reloc_p (r_type))
7494 lo16_type = R_MICROMIPS_LO16;
7496 lo16_type = R_MIPS_LO16;
7498 /* The combined value is the sum of the HI16 addend, left-shifted by
7499 sixteen bits, and the LO16 addend, sign extended. (Usually, the
7500 code does a `lui' of the HI16 value, and then an `addiu' of the
7503 Scan ahead to find a matching LO16 relocation.
7505 According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must
7506 be immediately following. However, for the IRIX6 ABI, the next
7507 relocation may be a composed relocation consisting of several
7508 relocations for the same address. In that case, the R_MIPS_LO16
7509 relocation may occur as one of these. We permit a similar
7510 extension in general, as that is useful for GCC.
7512 In some cases GCC dead code elimination removes the LO16 but keeps
7513 the corresponding HI16. This is strictly speaking a violation of
7514 the ABI but not immediately harmful. */
7515 lo16_relocation = mips_elf_next_relocation (abfd, lo16_type, rel, relend);
7516 if (lo16_relocation == NULL)
7519 /* Obtain the addend kept there. */
7520 lo16_howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, lo16_type, FALSE);
7521 l = mips_elf_read_rel_addend (abfd, lo16_relocation, lo16_howto, contents);
7523 l <<= lo16_howto->rightshift;
7524 l = _bfd_mips_elf_sign_extend (l, 16);
7531 /* Try to read the contents of section SEC in bfd ABFD. Return true and
7532 store the contents in *CONTENTS on success. Assume that *CONTENTS
7533 already holds the contents if it is nonull on entry. */
7536 mips_elf_get_section_contents (bfd *abfd, asection *sec, bfd_byte **contents)
7541 /* Get cached copy if it exists. */
7542 if (elf_section_data (sec)->this_hdr.contents != NULL)
7544 *contents = elf_section_data (sec)->this_hdr.contents;
7548 return bfd_malloc_and_get_section (abfd, sec, contents);
7551 /* Look through the relocs for a section during the first phase, and
7552 allocate space in the global offset table. */
7555 _bfd_mips_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
7556 asection *sec, const Elf_Internal_Rela *relocs)
7560 Elf_Internal_Shdr *symtab_hdr;
7561 struct elf_link_hash_entry **sym_hashes;
7563 const Elf_Internal_Rela *rel;
7564 const Elf_Internal_Rela *rel_end;
7566 const struct elf_backend_data *bed;
7567 struct mips_elf_link_hash_table *htab;
7570 reloc_howto_type *howto;
7572 if (info->relocatable)
7575 htab = mips_elf_hash_table (info);
7576 BFD_ASSERT (htab != NULL);
7578 dynobj = elf_hash_table (info)->dynobj;
7579 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7580 sym_hashes = elf_sym_hashes (abfd);
7581 extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
7583 bed = get_elf_backend_data (abfd);
7584 rel_end = relocs + sec->reloc_count * bed->s->int_rels_per_ext_rel;
7586 /* Check for the mips16 stub sections. */
7588 name = bfd_get_section_name (abfd, sec);
7589 if (FN_STUB_P (name))
7591 unsigned long r_symndx;
7593 /* Look at the relocation information to figure out which symbol
7596 r_symndx = mips16_stub_symndx (bed, sec, relocs, rel_end);
7599 (*_bfd_error_handler)
7600 (_("%B: Warning: cannot determine the target function for"
7601 " stub section `%s'"),
7603 bfd_set_error (bfd_error_bad_value);
7607 if (r_symndx < extsymoff
7608 || sym_hashes[r_symndx - extsymoff] == NULL)
7612 /* This stub is for a local symbol. This stub will only be
7613 needed if there is some relocation in this BFD, other
7614 than a 16 bit function call, which refers to this symbol. */
7615 for (o = abfd->sections; o != NULL; o = o->next)
7617 Elf_Internal_Rela *sec_relocs;
7618 const Elf_Internal_Rela *r, *rend;
7620 /* We can ignore stub sections when looking for relocs. */
7621 if ((o->flags & SEC_RELOC) == 0
7622 || o->reloc_count == 0
7623 || section_allows_mips16_refs_p (o))
7627 = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
7629 if (sec_relocs == NULL)
7632 rend = sec_relocs + o->reloc_count;
7633 for (r = sec_relocs; r < rend; r++)
7634 if (ELF_R_SYM (abfd, r->r_info) == r_symndx
7635 && !mips16_call_reloc_p (ELF_R_TYPE (abfd, r->r_info)))
7638 if (elf_section_data (o)->relocs != sec_relocs)
7647 /* There is no non-call reloc for this stub, so we do
7648 not need it. Since this function is called before
7649 the linker maps input sections to output sections, we
7650 can easily discard it by setting the SEC_EXCLUDE
7652 sec->flags |= SEC_EXCLUDE;
7656 /* Record this stub in an array of local symbol stubs for
7658 if (elf_tdata (abfd)->local_stubs == NULL)
7660 unsigned long symcount;
7664 if (elf_bad_symtab (abfd))
7665 symcount = NUM_SHDR_ENTRIES (symtab_hdr);
7667 symcount = symtab_hdr->sh_info;
7668 amt = symcount * sizeof (asection *);
7669 n = bfd_zalloc (abfd, amt);
7672 elf_tdata (abfd)->local_stubs = n;
7675 sec->flags |= SEC_KEEP;
7676 elf_tdata (abfd)->local_stubs[r_symndx] = sec;
7678 /* We don't need to set mips16_stubs_seen in this case.
7679 That flag is used to see whether we need to look through
7680 the global symbol table for stubs. We don't need to set
7681 it here, because we just have a local stub. */
7685 struct mips_elf_link_hash_entry *h;
7687 h = ((struct mips_elf_link_hash_entry *)
7688 sym_hashes[r_symndx - extsymoff]);
7690 while (h->root.root.type == bfd_link_hash_indirect
7691 || h->root.root.type == bfd_link_hash_warning)
7692 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
7694 /* H is the symbol this stub is for. */
7696 /* If we already have an appropriate stub for this function, we
7697 don't need another one, so we can discard this one. Since
7698 this function is called before the linker maps input sections
7699 to output sections, we can easily discard it by setting the
7700 SEC_EXCLUDE flag. */
7701 if (h->fn_stub != NULL)
7703 sec->flags |= SEC_EXCLUDE;
7707 sec->flags |= SEC_KEEP;
7709 mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
7712 else if (CALL_STUB_P (name) || CALL_FP_STUB_P (name))
7714 unsigned long r_symndx;
7715 struct mips_elf_link_hash_entry *h;
7718 /* Look at the relocation information to figure out which symbol
7721 r_symndx = mips16_stub_symndx (bed, sec, relocs, rel_end);
7724 (*_bfd_error_handler)
7725 (_("%B: Warning: cannot determine the target function for"
7726 " stub section `%s'"),
7728 bfd_set_error (bfd_error_bad_value);
7732 if (r_symndx < extsymoff
7733 || sym_hashes[r_symndx - extsymoff] == NULL)
7737 /* This stub is for a local symbol. This stub will only be
7738 needed if there is some relocation (R_MIPS16_26) in this BFD
7739 that refers to this symbol. */
7740 for (o = abfd->sections; o != NULL; o = o->next)
7742 Elf_Internal_Rela *sec_relocs;
7743 const Elf_Internal_Rela *r, *rend;
7745 /* We can ignore stub sections when looking for relocs. */
7746 if ((o->flags & SEC_RELOC) == 0
7747 || o->reloc_count == 0
7748 || section_allows_mips16_refs_p (o))
7752 = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
7754 if (sec_relocs == NULL)
7757 rend = sec_relocs + o->reloc_count;
7758 for (r = sec_relocs; r < rend; r++)
7759 if (ELF_R_SYM (abfd, r->r_info) == r_symndx
7760 && ELF_R_TYPE (abfd, r->r_info) == R_MIPS16_26)
7763 if (elf_section_data (o)->relocs != sec_relocs)
7772 /* There is no non-call reloc for this stub, so we do
7773 not need it. Since this function is called before
7774 the linker maps input sections to output sections, we
7775 can easily discard it by setting the SEC_EXCLUDE
7777 sec->flags |= SEC_EXCLUDE;
7781 /* Record this stub in an array of local symbol call_stubs for
7783 if (elf_tdata (abfd)->local_call_stubs == NULL)
7785 unsigned long symcount;
7789 if (elf_bad_symtab (abfd))
7790 symcount = NUM_SHDR_ENTRIES (symtab_hdr);
7792 symcount = symtab_hdr->sh_info;
7793 amt = symcount * sizeof (asection *);
7794 n = bfd_zalloc (abfd, amt);
7797 elf_tdata (abfd)->local_call_stubs = n;
7800 sec->flags |= SEC_KEEP;
7801 elf_tdata (abfd)->local_call_stubs[r_symndx] = sec;
7803 /* We don't need to set mips16_stubs_seen in this case.
7804 That flag is used to see whether we need to look through
7805 the global symbol table for stubs. We don't need to set
7806 it here, because we just have a local stub. */
7810 h = ((struct mips_elf_link_hash_entry *)
7811 sym_hashes[r_symndx - extsymoff]);
7813 /* H is the symbol this stub is for. */
7815 if (CALL_FP_STUB_P (name))
7816 loc = &h->call_fp_stub;
7818 loc = &h->call_stub;
7820 /* If we already have an appropriate stub for this function, we
7821 don't need another one, so we can discard this one. Since
7822 this function is called before the linker maps input sections
7823 to output sections, we can easily discard it by setting the
7824 SEC_EXCLUDE flag. */
7827 sec->flags |= SEC_EXCLUDE;
7831 sec->flags |= SEC_KEEP;
7833 mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
7839 for (rel = relocs; rel < rel_end; ++rel)
7841 unsigned long r_symndx;
7842 unsigned int r_type;
7843 struct elf_link_hash_entry *h;
7844 bfd_boolean can_make_dynamic_p;
7846 r_symndx = ELF_R_SYM (abfd, rel->r_info);
7847 r_type = ELF_R_TYPE (abfd, rel->r_info);
7849 if (r_symndx < extsymoff)
7851 else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
7853 (*_bfd_error_handler)
7854 (_("%B: Malformed reloc detected for section %s"),
7856 bfd_set_error (bfd_error_bad_value);
7861 h = sym_hashes[r_symndx - extsymoff];
7863 && (h->root.type == bfd_link_hash_indirect
7864 || h->root.type == bfd_link_hash_warning))
7865 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7868 /* Set CAN_MAKE_DYNAMIC_P to true if we can convert this
7869 relocation into a dynamic one. */
7870 can_make_dynamic_p = FALSE;
7875 case R_MIPS_CALL_HI16:
7876 case R_MIPS_CALL_LO16:
7877 case R_MIPS_GOT_HI16:
7878 case R_MIPS_GOT_LO16:
7879 case R_MIPS_GOT_PAGE:
7880 case R_MIPS_GOT_OFST:
7881 case R_MIPS_GOT_DISP:
7882 case R_MIPS_TLS_GOTTPREL:
7884 case R_MIPS_TLS_LDM:
7885 case R_MIPS16_GOT16:
7886 case R_MIPS16_CALL16:
7887 case R_MIPS16_TLS_GOTTPREL:
7888 case R_MIPS16_TLS_GD:
7889 case R_MIPS16_TLS_LDM:
7890 case R_MICROMIPS_GOT16:
7891 case R_MICROMIPS_CALL16:
7892 case R_MICROMIPS_CALL_HI16:
7893 case R_MICROMIPS_CALL_LO16:
7894 case R_MICROMIPS_GOT_HI16:
7895 case R_MICROMIPS_GOT_LO16:
7896 case R_MICROMIPS_GOT_PAGE:
7897 case R_MICROMIPS_GOT_OFST:
7898 case R_MICROMIPS_GOT_DISP:
7899 case R_MICROMIPS_TLS_GOTTPREL:
7900 case R_MICROMIPS_TLS_GD:
7901 case R_MICROMIPS_TLS_LDM:
7903 elf_hash_table (info)->dynobj = dynobj = abfd;
7904 if (!mips_elf_create_got_section (dynobj, info))
7906 if (htab->is_vxworks && !info->shared)
7908 (*_bfd_error_handler)
7909 (_("%B: GOT reloc at 0x%lx not expected in executables"),
7910 abfd, (unsigned long) rel->r_offset);
7911 bfd_set_error (bfd_error_bad_value);
7916 /* This is just a hint; it can safely be ignored. Don't set
7917 has_static_relocs for the corresponding symbol. */
7919 case R_MICROMIPS_JALR:
7925 /* In VxWorks executables, references to external symbols
7926 must be handled using copy relocs or PLT entries; it is not
7927 possible to convert this relocation into a dynamic one.
7929 For executables that use PLTs and copy-relocs, we have a
7930 choice between converting the relocation into a dynamic
7931 one or using copy relocations or PLT entries. It is
7932 usually better to do the former, unless the relocation is
7933 against a read-only section. */
7936 && !htab->is_vxworks
7937 && strcmp (h->root.root.string, "__gnu_local_gp") != 0
7938 && !(!info->nocopyreloc
7939 && !PIC_OBJECT_P (abfd)
7940 && MIPS_ELF_READONLY_SECTION (sec))))
7941 && (sec->flags & SEC_ALLOC) != 0)
7943 can_make_dynamic_p = TRUE;
7945 elf_hash_table (info)->dynobj = dynobj = abfd;
7948 /* For sections that are not SEC_ALLOC a copy reloc would be
7949 output if possible (implying questionable semantics for
7950 read-only data objects) or otherwise the final link would
7951 fail as ld.so will not process them and could not therefore
7952 handle any outstanding dynamic relocations.
7954 For such sections that are also SEC_DEBUGGING, we can avoid
7955 these problems by simply ignoring any relocs as these
7956 sections have a predefined use and we know it is safe to do
7959 This is needed in cases such as a global symbol definition
7960 in a shared library causing a common symbol from an object
7961 file to be converted to an undefined reference. If that
7962 happens, then all the relocations against this symbol from
7963 SEC_DEBUGGING sections in the object file will resolve to
7965 if ((sec->flags & SEC_DEBUGGING) != 0)
7970 /* Most static relocations require pointer equality, except
7973 h->pointer_equality_needed = TRUE;
7979 case R_MICROMIPS_26_S1:
7980 case R_MICROMIPS_PC7_S1:
7981 case R_MICROMIPS_PC10_S1:
7982 case R_MICROMIPS_PC16_S1:
7983 case R_MICROMIPS_PC23_S2:
7985 ((struct mips_elf_link_hash_entry *) h)->has_static_relocs = TRUE;
7991 /* Relocations against the special VxWorks __GOTT_BASE__ and
7992 __GOTT_INDEX__ symbols must be left to the loader. Allocate
7993 room for them in .rela.dyn. */
7994 if (is_gott_symbol (info, h))
7998 sreloc = mips_elf_rel_dyn_section (info, TRUE);
8002 mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
8003 if (MIPS_ELF_READONLY_SECTION (sec))
8004 /* We tell the dynamic linker that there are
8005 relocations against the text segment. */
8006 info->flags |= DF_TEXTREL;
8009 else if (call_lo16_reloc_p (r_type)
8010 || got_lo16_reloc_p (r_type)
8011 || got_disp_reloc_p (r_type)
8012 || (got16_reloc_p (r_type) && htab->is_vxworks))
8014 /* We may need a local GOT entry for this relocation. We
8015 don't count R_MIPS_GOT_PAGE because we can estimate the
8016 maximum number of pages needed by looking at the size of
8017 the segment. Similar comments apply to R_MIPS*_GOT16 and
8018 R_MIPS*_CALL16, except on VxWorks, where GOT relocations
8019 always evaluate to "G". We don't count R_MIPS_GOT_HI16, or
8020 R_MIPS_CALL_HI16 because these are always followed by an
8021 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
8022 if (!mips_elf_record_local_got_symbol (abfd, r_symndx,
8023 rel->r_addend, info, 0))
8028 && mips_elf_relocation_needs_la25_stub (abfd, r_type,
8029 ELF_ST_IS_MIPS16 (h->other)))
8030 ((struct mips_elf_link_hash_entry *) h)->has_nonpic_branches = TRUE;
8035 case R_MIPS16_CALL16:
8036 case R_MICROMIPS_CALL16:
8039 (*_bfd_error_handler)
8040 (_("%B: CALL16 reloc at 0x%lx not against global symbol"),
8041 abfd, (unsigned long) rel->r_offset);
8042 bfd_set_error (bfd_error_bad_value);
8047 case R_MIPS_CALL_HI16:
8048 case R_MIPS_CALL_LO16:
8049 case R_MICROMIPS_CALL_HI16:
8050 case R_MICROMIPS_CALL_LO16:
8053 /* Make sure there is room in the regular GOT to hold the
8054 function's address. We may eliminate it in favour of
8055 a .got.plt entry later; see mips_elf_count_got_symbols. */
8056 if (!mips_elf_record_global_got_symbol (h, abfd, info, TRUE, 0))
8059 /* We need a stub, not a plt entry for the undefined
8060 function. But we record it as if it needs plt. See
8061 _bfd_elf_adjust_dynamic_symbol. */
8067 case R_MIPS_GOT_PAGE:
8068 case R_MICROMIPS_GOT_PAGE:
8069 /* If this is a global, overridable symbol, GOT_PAGE will
8070 decay to GOT_DISP, so we'll need a GOT entry for it. */
8073 struct mips_elf_link_hash_entry *hmips =
8074 (struct mips_elf_link_hash_entry *) h;
8076 /* This symbol is definitely not overridable. */
8077 if (hmips->root.def_regular
8078 && ! (info->shared && ! info->symbolic
8079 && ! hmips->root.forced_local))
8084 case R_MIPS16_GOT16:
8086 case R_MIPS_GOT_HI16:
8087 case R_MIPS_GOT_LO16:
8088 case R_MICROMIPS_GOT16:
8089 case R_MICROMIPS_GOT_HI16:
8090 case R_MICROMIPS_GOT_LO16:
8091 if (!h || got_page_reloc_p (r_type))
8093 /* This relocation needs (or may need, if h != NULL) a
8094 page entry in the GOT. For R_MIPS_GOT_PAGE we do not
8095 know for sure until we know whether the symbol is
8097 if (mips_elf_rel_relocation_p (abfd, sec, relocs, rel))
8099 if (!mips_elf_get_section_contents (abfd, sec, &contents))
8101 howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, r_type, FALSE);
8102 addend = mips_elf_read_rel_addend (abfd, rel,
8104 if (got16_reloc_p (r_type))
8105 mips_elf_add_lo16_rel_addend (abfd, rel, rel_end,
8108 addend <<= howto->rightshift;
8111 addend = rel->r_addend;
8112 if (!mips_elf_record_got_page_entry (info, abfd, r_symndx,
8118 case R_MIPS_GOT_DISP:
8119 case R_MICROMIPS_GOT_DISP:
8120 if (h && !mips_elf_record_global_got_symbol (h, abfd, info,
8125 case R_MIPS_TLS_GOTTPREL:
8126 case R_MIPS16_TLS_GOTTPREL:
8127 case R_MICROMIPS_TLS_GOTTPREL:
8129 info->flags |= DF_STATIC_TLS;
8132 case R_MIPS_TLS_LDM:
8133 case R_MIPS16_TLS_LDM:
8134 case R_MICROMIPS_TLS_LDM:
8135 if (tls_ldm_reloc_p (r_type))
8137 r_symndx = STN_UNDEF;
8143 case R_MIPS16_TLS_GD:
8144 case R_MICROMIPS_TLS_GD:
8145 /* This symbol requires a global offset table entry, or two
8146 for TLS GD relocations. */
8150 flag = (tls_gd_reloc_p (r_type)
8152 : tls_ldm_reloc_p (r_type) ? GOT_TLS_LDM : GOT_TLS_IE);
8155 struct mips_elf_link_hash_entry *hmips =
8156 (struct mips_elf_link_hash_entry *) h;
8157 hmips->tls_type |= flag;
8159 if (h && !mips_elf_record_global_got_symbol (h, abfd, info,
8165 BFD_ASSERT (flag == GOT_TLS_LDM || r_symndx != STN_UNDEF);
8167 if (!mips_elf_record_local_got_symbol (abfd, r_symndx,
8178 /* In VxWorks executables, references to external symbols
8179 are handled using copy relocs or PLT stubs, so there's
8180 no need to add a .rela.dyn entry for this relocation. */
8181 if (can_make_dynamic_p)
8185 sreloc = mips_elf_rel_dyn_section (info, TRUE);
8189 if (info->shared && h == NULL)
8191 /* When creating a shared object, we must copy these
8192 reloc types into the output file as R_MIPS_REL32
8193 relocs. Make room for this reloc in .rel(a).dyn. */
8194 mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
8195 if (MIPS_ELF_READONLY_SECTION (sec))
8196 /* We tell the dynamic linker that there are
8197 relocations against the text segment. */
8198 info->flags |= DF_TEXTREL;
8202 struct mips_elf_link_hash_entry *hmips;
8204 /* For a shared object, we must copy this relocation
8205 unless the symbol turns out to be undefined and
8206 weak with non-default visibility, in which case
8207 it will be left as zero.
8209 We could elide R_MIPS_REL32 for locally binding symbols
8210 in shared libraries, but do not yet do so.
8212 For an executable, we only need to copy this
8213 reloc if the symbol is defined in a dynamic
8215 hmips = (struct mips_elf_link_hash_entry *) h;
8216 ++hmips->possibly_dynamic_relocs;
8217 if (MIPS_ELF_READONLY_SECTION (sec))
8218 /* We need it to tell the dynamic linker if there
8219 are relocations against the text segment. */
8220 hmips->readonly_reloc = TRUE;
8224 if (SGI_COMPAT (abfd))
8225 mips_elf_hash_table (info)->compact_rel_size +=
8226 sizeof (Elf32_External_crinfo);
8230 case R_MIPS_GPREL16:
8231 case R_MIPS_LITERAL:
8232 case R_MIPS_GPREL32:
8233 case R_MICROMIPS_26_S1:
8234 case R_MICROMIPS_GPREL16:
8235 case R_MICROMIPS_LITERAL:
8236 case R_MICROMIPS_GPREL7_S2:
8237 if (SGI_COMPAT (abfd))
8238 mips_elf_hash_table (info)->compact_rel_size +=
8239 sizeof (Elf32_External_crinfo);
8242 /* This relocation describes the C++ object vtable hierarchy.
8243 Reconstruct it for later use during GC. */
8244 case R_MIPS_GNU_VTINHERIT:
8245 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
8249 /* This relocation describes which C++ vtable entries are actually
8250 used. Record for later use during GC. */
8251 case R_MIPS_GNU_VTENTRY:
8252 BFD_ASSERT (h != NULL);
8254 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
8262 /* We must not create a stub for a symbol that has relocations
8263 related to taking the function's address. This doesn't apply to
8264 VxWorks, where CALL relocs refer to a .got.plt entry instead of
8265 a normal .got entry. */
8266 if (!htab->is_vxworks && h != NULL)
8270 ((struct mips_elf_link_hash_entry *) h)->no_fn_stub = TRUE;
8272 case R_MIPS16_CALL16:
8274 case R_MIPS_CALL_HI16:
8275 case R_MIPS_CALL_LO16:
8277 case R_MICROMIPS_CALL16:
8278 case R_MICROMIPS_CALL_HI16:
8279 case R_MICROMIPS_CALL_LO16:
8280 case R_MICROMIPS_JALR:
8284 /* See if this reloc would need to refer to a MIPS16 hard-float stub,
8285 if there is one. We only need to handle global symbols here;
8286 we decide whether to keep or delete stubs for local symbols
8287 when processing the stub's relocations. */
8289 && !mips16_call_reloc_p (r_type)
8290 && !section_allows_mips16_refs_p (sec))
8292 struct mips_elf_link_hash_entry *mh;
8294 mh = (struct mips_elf_link_hash_entry *) h;
8295 mh->need_fn_stub = TRUE;
8298 /* Refuse some position-dependent relocations when creating a
8299 shared library. Do not refuse R_MIPS_32 / R_MIPS_64; they're
8300 not PIC, but we can create dynamic relocations and the result
8301 will be fine. Also do not refuse R_MIPS_LO16, which can be
8302 combined with R_MIPS_GOT16. */
8310 case R_MIPS_HIGHEST:
8311 case R_MICROMIPS_HI16:
8312 case R_MICROMIPS_HIGHER:
8313 case R_MICROMIPS_HIGHEST:
8314 /* Don't refuse a high part relocation if it's against
8315 no symbol (e.g. part of a compound relocation). */
8316 if (r_symndx == STN_UNDEF)
8319 /* R_MIPS_HI16 against _gp_disp is used for $gp setup,
8320 and has a special meaning. */
8321 if (!NEWABI_P (abfd) && h != NULL
8322 && strcmp (h->root.root.string, "_gp_disp") == 0)
8325 /* Likewise __GOTT_BASE__ and __GOTT_INDEX__ on VxWorks. */
8326 if (is_gott_symbol (info, h))
8333 case R_MICROMIPS_26_S1:
8334 howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, r_type, FALSE);
8335 (*_bfd_error_handler)
8336 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
8338 (h) ? h->root.root.string : "a local symbol");
8339 bfd_set_error (bfd_error_bad_value);
8351 _bfd_mips_relax_section (bfd *abfd, asection *sec,
8352 struct bfd_link_info *link_info,
8355 Elf_Internal_Rela *internal_relocs;
8356 Elf_Internal_Rela *irel, *irelend;
8357 Elf_Internal_Shdr *symtab_hdr;
8358 bfd_byte *contents = NULL;
8360 bfd_boolean changed_contents = FALSE;
8361 bfd_vma sec_start = sec->output_section->vma + sec->output_offset;
8362 Elf_Internal_Sym *isymbuf = NULL;
8364 /* We are not currently changing any sizes, so only one pass. */
8367 if (link_info->relocatable)
8370 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
8371 link_info->keep_memory);
8372 if (internal_relocs == NULL)
8375 irelend = internal_relocs + sec->reloc_count
8376 * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel;
8377 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8378 extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
8380 for (irel = internal_relocs; irel < irelend; irel++)
8383 bfd_signed_vma sym_offset;
8384 unsigned int r_type;
8385 unsigned long r_symndx;
8387 unsigned long instruction;
8389 /* Turn jalr into bgezal, and jr into beq, if they're marked
8390 with a JALR relocation, that indicate where they jump to.
8391 This saves some pipeline bubbles. */
8392 r_type = ELF_R_TYPE (abfd, irel->r_info);
8393 if (r_type != R_MIPS_JALR)
8396 r_symndx = ELF_R_SYM (abfd, irel->r_info);
8397 /* Compute the address of the jump target. */
8398 if (r_symndx >= extsymoff)
8400 struct mips_elf_link_hash_entry *h
8401 = ((struct mips_elf_link_hash_entry *)
8402 elf_sym_hashes (abfd) [r_symndx - extsymoff]);
8404 while (h->root.root.type == bfd_link_hash_indirect
8405 || h->root.root.type == bfd_link_hash_warning)
8406 h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
8408 /* If a symbol is undefined, or if it may be overridden,
8410 if (! ((h->root.root.type == bfd_link_hash_defined
8411 || h->root.root.type == bfd_link_hash_defweak)
8412 && h->root.root.u.def.section)
8413 || (link_info->shared && ! link_info->symbolic
8414 && !h->root.forced_local))
8417 sym_sec = h->root.root.u.def.section;
8418 if (sym_sec->output_section)
8419 symval = (h->root.root.u.def.value
8420 + sym_sec->output_section->vma
8421 + sym_sec->output_offset);
8423 symval = h->root.root.u.def.value;
8427 Elf_Internal_Sym *isym;
8429 /* Read this BFD's symbols if we haven't done so already. */
8430 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
8432 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
8433 if (isymbuf == NULL)
8434 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
8435 symtab_hdr->sh_info, 0,
8437 if (isymbuf == NULL)
8441 isym = isymbuf + r_symndx;
8442 if (isym->st_shndx == SHN_UNDEF)
8444 else if (isym->st_shndx == SHN_ABS)
8445 sym_sec = bfd_abs_section_ptr;
8446 else if (isym->st_shndx == SHN_COMMON)
8447 sym_sec = bfd_com_section_ptr;
8450 = bfd_section_from_elf_index (abfd, isym->st_shndx);
8451 symval = isym->st_value
8452 + sym_sec->output_section->vma
8453 + sym_sec->output_offset;
8456 /* Compute branch offset, from delay slot of the jump to the
8458 sym_offset = (symval + irel->r_addend)
8459 - (sec_start + irel->r_offset + 4);
8461 /* Branch offset must be properly aligned. */
8462 if ((sym_offset & 3) != 0)
8467 /* Check that it's in range. */
8468 if (sym_offset < -0x8000 || sym_offset >= 0x8000)
8471 /* Get the section contents if we haven't done so already. */
8472 if (!mips_elf_get_section_contents (abfd, sec, &contents))
8475 instruction = bfd_get_32 (abfd, contents + irel->r_offset);
8477 /* If it was jalr <reg>, turn it into bgezal $zero, <target>. */
8478 if ((instruction & 0xfc1fffff) == 0x0000f809)
8479 instruction = 0x04110000;
8480 /* If it was jr <reg>, turn it into b <target>. */
8481 else if ((instruction & 0xfc1fffff) == 0x00000008)
8482 instruction = 0x10000000;
8486 instruction |= (sym_offset & 0xffff);
8487 bfd_put_32 (abfd, instruction, contents + irel->r_offset);
8488 changed_contents = TRUE;
8491 if (contents != NULL
8492 && elf_section_data (sec)->this_hdr.contents != contents)
8494 if (!changed_contents && !link_info->keep_memory)
8498 /* Cache the section contents for elf_link_input_bfd. */
8499 elf_section_data (sec)->this_hdr.contents = contents;
8505 if (contents != NULL
8506 && elf_section_data (sec)->this_hdr.contents != contents)
8511 /* Allocate space for global sym dynamic relocs. */
8514 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8516 struct bfd_link_info *info = inf;
8518 struct mips_elf_link_hash_entry *hmips;
8519 struct mips_elf_link_hash_table *htab;
8521 htab = mips_elf_hash_table (info);
8522 BFD_ASSERT (htab != NULL);
8524 dynobj = elf_hash_table (info)->dynobj;
8525 hmips = (struct mips_elf_link_hash_entry *) h;
8527 /* VxWorks executables are handled elsewhere; we only need to
8528 allocate relocations in shared objects. */
8529 if (htab->is_vxworks && !info->shared)
8532 /* Ignore indirect symbols. All relocations against such symbols
8533 will be redirected to the target symbol. */
8534 if (h->root.type == bfd_link_hash_indirect)
8537 /* If this symbol is defined in a dynamic object, or we are creating
8538 a shared library, we will need to copy any R_MIPS_32 or
8539 R_MIPS_REL32 relocs against it into the output file. */
8540 if (! info->relocatable
8541 && hmips->possibly_dynamic_relocs != 0
8542 && (h->root.type == bfd_link_hash_defweak
8546 bfd_boolean do_copy = TRUE;
8548 if (h->root.type == bfd_link_hash_undefweak)
8550 /* Do not copy relocations for undefined weak symbols with
8551 non-default visibility. */
8552 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
8555 /* Make sure undefined weak symbols are output as a dynamic
8557 else if (h->dynindx == -1 && !h->forced_local)
8559 if (! bfd_elf_link_record_dynamic_symbol (info, h))
8566 /* Even though we don't directly need a GOT entry for this symbol,
8567 the SVR4 psABI requires it to have a dynamic symbol table
8568 index greater that DT_MIPS_GOTSYM if there are dynamic
8569 relocations against it.
8571 VxWorks does not enforce the same mapping between the GOT
8572 and the symbol table, so the same requirement does not
8574 if (!htab->is_vxworks)
8576 if (hmips->global_got_area > GGA_RELOC_ONLY)
8577 hmips->global_got_area = GGA_RELOC_ONLY;
8578 hmips->got_only_for_calls = FALSE;
8581 mips_elf_allocate_dynamic_relocations
8582 (dynobj, info, hmips->possibly_dynamic_relocs);
8583 if (hmips->readonly_reloc)
8584 /* We tell the dynamic linker that there are relocations
8585 against the text segment. */
8586 info->flags |= DF_TEXTREL;
8593 /* Adjust a symbol defined by a dynamic object and referenced by a
8594 regular object. The current definition is in some section of the
8595 dynamic object, but we're not including those sections. We have to
8596 change the definition to something the rest of the link can
8600 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
8601 struct elf_link_hash_entry *h)
8604 struct mips_elf_link_hash_entry *hmips;
8605 struct mips_elf_link_hash_table *htab;
8607 htab = mips_elf_hash_table (info);
8608 BFD_ASSERT (htab != NULL);
8610 dynobj = elf_hash_table (info)->dynobj;
8611 hmips = (struct mips_elf_link_hash_entry *) h;
8613 /* Make sure we know what is going on here. */
8614 BFD_ASSERT (dynobj != NULL
8616 || h->u.weakdef != NULL
8619 && !h->def_regular)));
8621 hmips = (struct mips_elf_link_hash_entry *) h;
8623 /* If there are call relocations against an externally-defined symbol,
8624 see whether we can create a MIPS lazy-binding stub for it. We can
8625 only do this if all references to the function are through call
8626 relocations, and in that case, the traditional lazy-binding stubs
8627 are much more efficient than PLT entries.
8629 Traditional stubs are only available on SVR4 psABI-based systems;
8630 VxWorks always uses PLTs instead. */
8631 if (!htab->is_vxworks && h->needs_plt && !hmips->no_fn_stub)
8633 if (! elf_hash_table (info)->dynamic_sections_created)
8636 /* If this symbol is not defined in a regular file, then set
8637 the symbol to the stub location. This is required to make
8638 function pointers compare as equal between the normal
8639 executable and the shared library. */
8640 if (!h->def_regular)
8642 hmips->needs_lazy_stub = TRUE;
8643 htab->lazy_stub_count++;
8647 /* As above, VxWorks requires PLT entries for externally-defined
8648 functions that are only accessed through call relocations.
8650 Both VxWorks and non-VxWorks targets also need PLT entries if there
8651 are static-only relocations against an externally-defined function.
8652 This can technically occur for shared libraries if there are
8653 branches to the symbol, although it is unlikely that this will be
8654 used in practice due to the short ranges involved. It can occur
8655 for any relative or absolute relocation in executables; in that
8656 case, the PLT entry becomes the function's canonical address. */
8657 else if (((h->needs_plt && !hmips->no_fn_stub)
8658 || (h->type == STT_FUNC && hmips->has_static_relocs))
8659 && htab->use_plts_and_copy_relocs
8660 && !SYMBOL_CALLS_LOCAL (info, h)
8661 && !(ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
8662 && h->root.type == bfd_link_hash_undefweak))
8664 /* If this is the first symbol to need a PLT entry, allocate room
8666 if (htab->splt->size == 0)
8668 BFD_ASSERT (htab->sgotplt->size == 0);
8670 /* If we're using the PLT additions to the psABI, each PLT
8671 entry is 16 bytes and the PLT0 entry is 32 bytes.
8672 Encourage better cache usage by aligning. We do this
8673 lazily to avoid pessimizing traditional objects. */
8674 if (!htab->is_vxworks
8675 && !bfd_set_section_alignment (dynobj, htab->splt, 5))
8678 /* Make sure that .got.plt is word-aligned. We do this lazily
8679 for the same reason as above. */
8680 if (!bfd_set_section_alignment (dynobj, htab->sgotplt,
8681 MIPS_ELF_LOG_FILE_ALIGN (dynobj)))
8684 htab->splt->size += htab->plt_header_size;
8686 /* On non-VxWorks targets, the first two entries in .got.plt
8688 if (!htab->is_vxworks)
8690 += get_elf_backend_data (dynobj)->got_header_size;
8692 /* On VxWorks, also allocate room for the header's
8693 .rela.plt.unloaded entries. */
8694 if (htab->is_vxworks && !info->shared)
8695 htab->srelplt2->size += 2 * sizeof (Elf32_External_Rela);
8698 /* Assign the next .plt entry to this symbol. */
8699 h->plt.offset = htab->splt->size;
8700 htab->splt->size += htab->plt_entry_size;
8702 /* If the output file has no definition of the symbol, set the
8703 symbol's value to the address of the stub. */
8704 if (!info->shared && !h->def_regular)
8706 h->root.u.def.section = htab->splt;
8707 h->root.u.def.value = h->plt.offset;
8708 /* For VxWorks, point at the PLT load stub rather than the
8709 lazy resolution stub; this stub will become the canonical
8710 function address. */
8711 if (htab->is_vxworks)
8712 h->root.u.def.value += 8;
8715 /* Make room for the .got.plt entry and the R_MIPS_JUMP_SLOT
8717 htab->sgotplt->size += MIPS_ELF_GOT_SIZE (dynobj);
8718 htab->srelplt->size += (htab->is_vxworks
8719 ? MIPS_ELF_RELA_SIZE (dynobj)
8720 : MIPS_ELF_REL_SIZE (dynobj));
8722 /* Make room for the .rela.plt.unloaded relocations. */
8723 if (htab->is_vxworks && !info->shared)
8724 htab->srelplt2->size += 3 * sizeof (Elf32_External_Rela);
8726 /* All relocations against this symbol that could have been made
8727 dynamic will now refer to the PLT entry instead. */
8728 hmips->possibly_dynamic_relocs = 0;
8733 /* If this is a weak symbol, and there is a real definition, the
8734 processor independent code will have arranged for us to see the
8735 real definition first, and we can just use the same value. */
8736 if (h->u.weakdef != NULL)
8738 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
8739 || h->u.weakdef->root.type == bfd_link_hash_defweak);
8740 h->root.u.def.section = h->u.weakdef->root.u.def.section;
8741 h->root.u.def.value = h->u.weakdef->root.u.def.value;
8745 /* Otherwise, there is nothing further to do for symbols defined
8746 in regular objects. */
8750 /* There's also nothing more to do if we'll convert all relocations
8751 against this symbol into dynamic relocations. */
8752 if (!hmips->has_static_relocs)
8755 /* We're now relying on copy relocations. Complain if we have
8756 some that we can't convert. */
8757 if (!htab->use_plts_and_copy_relocs || info->shared)
8759 (*_bfd_error_handler) (_("non-dynamic relocations refer to "
8760 "dynamic symbol %s"),
8761 h->root.root.string);
8762 bfd_set_error (bfd_error_bad_value);
8766 /* We must allocate the symbol in our .dynbss section, which will
8767 become part of the .bss section of the executable. There will be
8768 an entry for this symbol in the .dynsym section. The dynamic
8769 object will contain position independent code, so all references
8770 from the dynamic object to this symbol will go through the global
8771 offset table. The dynamic linker will use the .dynsym entry to
8772 determine the address it must put in the global offset table, so
8773 both the dynamic object and the regular object will refer to the
8774 same memory location for the variable. */
8776 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
8778 if (htab->is_vxworks)
8779 htab->srelbss->size += sizeof (Elf32_External_Rela);
8781 mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
8785 /* All relocations against this symbol that could have been made
8786 dynamic will now refer to the local copy instead. */
8787 hmips->possibly_dynamic_relocs = 0;
8789 return _bfd_elf_adjust_dynamic_copy (h, htab->sdynbss);
8792 /* This function is called after all the input files have been read,
8793 and the input sections have been assigned to output sections. We
8794 check for any mips16 stub sections that we can discard. */
8797 _bfd_mips_elf_always_size_sections (bfd *output_bfd,
8798 struct bfd_link_info *info)
8801 struct mips_elf_link_hash_table *htab;
8802 struct mips_htab_traverse_info hti;
8804 htab = mips_elf_hash_table (info);
8805 BFD_ASSERT (htab != NULL);
8807 /* The .reginfo section has a fixed size. */
8808 ri = bfd_get_section_by_name (output_bfd, ".reginfo");
8810 bfd_set_section_size (output_bfd, ri, sizeof (Elf32_External_RegInfo));
8813 hti.output_bfd = output_bfd;
8815 mips_elf_link_hash_traverse (mips_elf_hash_table (info),
8816 mips_elf_check_symbols, &hti);
8823 /* If the link uses a GOT, lay it out and work out its size. */
8826 mips_elf_lay_out_got (bfd *output_bfd, struct bfd_link_info *info)
8830 struct mips_got_info *g;
8831 bfd_size_type loadable_size = 0;
8832 bfd_size_type page_gotno;
8834 struct mips_elf_count_tls_arg count_tls_arg;
8835 struct mips_elf_link_hash_table *htab;
8837 htab = mips_elf_hash_table (info);
8838 BFD_ASSERT (htab != NULL);
8844 dynobj = elf_hash_table (info)->dynobj;
8847 /* Allocate room for the reserved entries. VxWorks always reserves
8848 3 entries; other objects only reserve 2 entries. */
8849 BFD_ASSERT (g->assigned_gotno == 0);
8850 if (htab->is_vxworks)
8851 htab->reserved_gotno = 3;
8853 htab->reserved_gotno = 2;
8854 g->local_gotno += htab->reserved_gotno;
8855 g->assigned_gotno = htab->reserved_gotno;
8857 /* Replace entries for indirect and warning symbols with entries for
8858 the target symbol. */
8859 if (!mips_elf_resolve_final_got_entries (g))
8862 /* Count the number of GOT symbols. */
8863 mips_elf_link_hash_traverse (htab, mips_elf_count_got_symbols, info);
8865 /* Calculate the total loadable size of the output. That
8866 will give us the maximum number of GOT_PAGE entries
8868 for (sub = info->input_bfds; sub; sub = sub->link_next)
8870 asection *subsection;
8872 for (subsection = sub->sections;
8874 subsection = subsection->next)
8876 if ((subsection->flags & SEC_ALLOC) == 0)
8878 loadable_size += ((subsection->size + 0xf)
8879 &~ (bfd_size_type) 0xf);
8883 if (htab->is_vxworks)
8884 /* There's no need to allocate page entries for VxWorks; R_MIPS*_GOT16
8885 relocations against local symbols evaluate to "G", and the EABI does
8886 not include R_MIPS_GOT_PAGE. */
8889 /* Assume there are two loadable segments consisting of contiguous
8890 sections. Is 5 enough? */
8891 page_gotno = (loadable_size >> 16) + 5;
8893 /* Choose the smaller of the two estimates; both are intended to be
8895 if (page_gotno > g->page_gotno)
8896 page_gotno = g->page_gotno;
8898 g->local_gotno += page_gotno;
8899 s->size += g->local_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
8900 s->size += g->global_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
8902 /* We need to calculate tls_gotno for global symbols at this point
8903 instead of building it up earlier, to avoid doublecounting
8904 entries for one global symbol from multiple input files. */
8905 count_tls_arg.info = info;
8906 count_tls_arg.needed = 0;
8907 elf_link_hash_traverse (elf_hash_table (info),
8908 mips_elf_count_global_tls_entries,
8910 g->tls_gotno += count_tls_arg.needed;
8911 s->size += g->tls_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
8913 /* VxWorks does not support multiple GOTs. It initializes $gp to
8914 __GOTT_BASE__[__GOTT_INDEX__], the value of which is set by the
8916 if (htab->is_vxworks)
8918 /* VxWorks executables do not need a GOT. */
8921 /* Each VxWorks GOT entry needs an explicit relocation. */
8924 count = g->global_gotno + g->local_gotno - htab->reserved_gotno;
8926 mips_elf_allocate_dynamic_relocations (dynobj, info, count);
8929 else if (s->size > MIPS_ELF_GOT_MAX_SIZE (info))
8931 if (!mips_elf_multi_got (output_bfd, info, s, page_gotno))
8936 struct mips_elf_count_tls_arg arg;
8938 /* Set up TLS entries. */
8939 g->tls_assigned_gotno = g->global_gotno + g->local_gotno;
8940 htab_traverse (g->got_entries, mips_elf_initialize_tls_index, g);
8942 /* Allocate room for the TLS relocations. */
8945 htab_traverse (g->got_entries, mips_elf_count_local_tls_relocs, &arg);
8946 elf_link_hash_traverse (elf_hash_table (info),
8947 mips_elf_count_global_tls_relocs,
8950 mips_elf_allocate_dynamic_relocations (dynobj, info, arg.needed);
8956 /* Estimate the size of the .MIPS.stubs section. */
8959 mips_elf_estimate_stub_size (bfd *output_bfd, struct bfd_link_info *info)
8961 struct mips_elf_link_hash_table *htab;
8962 bfd_size_type dynsymcount;
8964 htab = mips_elf_hash_table (info);
8965 BFD_ASSERT (htab != NULL);
8967 if (htab->lazy_stub_count == 0)
8970 /* IRIX rld assumes that a function stub isn't at the end of the .text
8971 section, so add a dummy entry to the end. */
8972 htab->lazy_stub_count++;
8974 /* Get a worst-case estimate of the number of dynamic symbols needed.
8975 At this point, dynsymcount does not account for section symbols
8976 and count_section_dynsyms may overestimate the number that will
8978 dynsymcount = (elf_hash_table (info)->dynsymcount
8979 + count_section_dynsyms (output_bfd, info));
8981 /* Determine the size of one stub entry. */
8982 htab->function_stub_size = (dynsymcount > 0x10000
8983 ? MIPS_FUNCTION_STUB_BIG_SIZE
8984 : MIPS_FUNCTION_STUB_NORMAL_SIZE);
8986 htab->sstubs->size = htab->lazy_stub_count * htab->function_stub_size;
8989 /* A mips_elf_link_hash_traverse callback for which DATA points to the
8990 MIPS hash table. If H needs a traditional MIPS lazy-binding stub,
8991 allocate an entry in the stubs section. */
8994 mips_elf_allocate_lazy_stub (struct mips_elf_link_hash_entry *h, void **data)
8996 struct mips_elf_link_hash_table *htab;
8998 htab = (struct mips_elf_link_hash_table *) data;
8999 if (h->needs_lazy_stub)
9001 h->root.root.u.def.section = htab->sstubs;
9002 h->root.root.u.def.value = htab->sstubs->size;
9003 h->root.plt.offset = htab->sstubs->size;
9004 htab->sstubs->size += htab->function_stub_size;
9009 /* Allocate offsets in the stubs section to each symbol that needs one.
9010 Set the final size of the .MIPS.stub section. */
9013 mips_elf_lay_out_lazy_stubs (struct bfd_link_info *info)
9015 struct mips_elf_link_hash_table *htab;
9017 htab = mips_elf_hash_table (info);
9018 BFD_ASSERT (htab != NULL);
9020 if (htab->lazy_stub_count == 0)
9023 htab->sstubs->size = 0;
9024 mips_elf_link_hash_traverse (htab, mips_elf_allocate_lazy_stub, htab);
9025 htab->sstubs->size += htab->function_stub_size;
9026 BFD_ASSERT (htab->sstubs->size
9027 == htab->lazy_stub_count * htab->function_stub_size);
9030 /* Set the sizes of the dynamic sections. */
9033 _bfd_mips_elf_size_dynamic_sections (bfd *output_bfd,
9034 struct bfd_link_info *info)
9037 asection *s, *sreldyn;
9038 bfd_boolean reltext;
9039 struct mips_elf_link_hash_table *htab;
9041 htab = mips_elf_hash_table (info);
9042 BFD_ASSERT (htab != NULL);
9043 dynobj = elf_hash_table (info)->dynobj;
9044 BFD_ASSERT (dynobj != NULL);
9046 if (elf_hash_table (info)->dynamic_sections_created)
9048 /* Set the contents of the .interp section to the interpreter. */
9049 if (info->executable)
9051 s = bfd_get_linker_section (dynobj, ".interp");
9052 BFD_ASSERT (s != NULL);
9054 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd)) + 1;
9056 = (bfd_byte *) ELF_DYNAMIC_INTERPRETER (output_bfd);
9059 /* Create a symbol for the PLT, if we know that we are using it. */
9060 if (htab->splt && htab->splt->size > 0 && htab->root.hplt == NULL)
9062 struct elf_link_hash_entry *h;
9064 BFD_ASSERT (htab->use_plts_and_copy_relocs);
9066 h = _bfd_elf_define_linkage_sym (dynobj, info, htab->splt,
9067 "_PROCEDURE_LINKAGE_TABLE_");
9068 htab->root.hplt = h;
9075 /* Allocate space for global sym dynamic relocs. */
9076 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
9078 mips_elf_estimate_stub_size (output_bfd, info);
9080 if (!mips_elf_lay_out_got (output_bfd, info))
9083 mips_elf_lay_out_lazy_stubs (info);
9085 /* The check_relocs and adjust_dynamic_symbol entry points have
9086 determined the sizes of the various dynamic sections. Allocate
9089 for (s = dynobj->sections; s != NULL; s = s->next)
9093 /* It's OK to base decisions on the section name, because none
9094 of the dynobj section names depend upon the input files. */
9095 name = bfd_get_section_name (dynobj, s);
9097 if ((s->flags & SEC_LINKER_CREATED) == 0)
9100 if (CONST_STRNEQ (name, ".rel"))
9104 const char *outname;
9107 /* If this relocation section applies to a read only
9108 section, then we probably need a DT_TEXTREL entry.
9109 If the relocation section is .rel(a).dyn, we always
9110 assert a DT_TEXTREL entry rather than testing whether
9111 there exists a relocation to a read only section or
9113 outname = bfd_get_section_name (output_bfd,
9115 target = bfd_get_section_by_name (output_bfd, outname + 4);
9117 && (target->flags & SEC_READONLY) != 0
9118 && (target->flags & SEC_ALLOC) != 0)
9119 || strcmp (outname, MIPS_ELF_REL_DYN_NAME (info)) == 0)
9122 /* We use the reloc_count field as a counter if we need
9123 to copy relocs into the output file. */
9124 if (strcmp (name, MIPS_ELF_REL_DYN_NAME (info)) != 0)
9127 /* If combreloc is enabled, elf_link_sort_relocs() will
9128 sort relocations, but in a different way than we do,
9129 and before we're done creating relocations. Also, it
9130 will move them around between input sections'
9131 relocation's contents, so our sorting would be
9132 broken, so don't let it run. */
9133 info->combreloc = 0;
9136 else if (! info->shared
9137 && ! mips_elf_hash_table (info)->use_rld_obj_head
9138 && CONST_STRNEQ (name, ".rld_map"))
9140 /* We add a room for __rld_map. It will be filled in by the
9141 rtld to contain a pointer to the _r_debug structure. */
9142 s->size += MIPS_ELF_RLD_MAP_SIZE (output_bfd);
9144 else if (SGI_COMPAT (output_bfd)
9145 && CONST_STRNEQ (name, ".compact_rel"))
9146 s->size += mips_elf_hash_table (info)->compact_rel_size;
9147 else if (s == htab->splt)
9149 /* If the last PLT entry has a branch delay slot, allocate
9150 room for an extra nop to fill the delay slot. This is
9151 for CPUs without load interlocking. */
9152 if (! LOAD_INTERLOCKS_P (output_bfd)
9153 && ! htab->is_vxworks && s->size > 0)
9156 else if (! CONST_STRNEQ (name, ".init")
9158 && s != htab->sgotplt
9159 && s != htab->sstubs
9160 && s != htab->sdynbss)
9162 /* It's not one of our sections, so don't allocate space. */
9168 s->flags |= SEC_EXCLUDE;
9172 if ((s->flags & SEC_HAS_CONTENTS) == 0)
9175 /* Allocate memory for the section contents. */
9176 s->contents = bfd_zalloc (dynobj, s->size);
9177 if (s->contents == NULL)
9179 bfd_set_error (bfd_error_no_memory);
9184 if (elf_hash_table (info)->dynamic_sections_created)
9186 /* Add some entries to the .dynamic section. We fill in the
9187 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
9188 must add the entries now so that we get the correct size for
9189 the .dynamic section. */
9191 /* SGI object has the equivalence of DT_DEBUG in the
9192 DT_MIPS_RLD_MAP entry. This must come first because glibc
9193 only fills in DT_MIPS_RLD_MAP (not DT_DEBUG) and some tools
9194 may only look at the first one they see. */
9196 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP, 0))
9199 /* The DT_DEBUG entry may be filled in by the dynamic linker and
9200 used by the debugger. */
9201 if (info->executable
9202 && !SGI_COMPAT (output_bfd)
9203 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
9206 if (reltext && (SGI_COMPAT (output_bfd) || htab->is_vxworks))
9207 info->flags |= DF_TEXTREL;
9209 if ((info->flags & DF_TEXTREL) != 0)
9211 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0))
9214 /* Clear the DF_TEXTREL flag. It will be set again if we
9215 write out an actual text relocation; we may not, because
9216 at this point we do not know whether e.g. any .eh_frame
9217 absolute relocations have been converted to PC-relative. */
9218 info->flags &= ~DF_TEXTREL;
9221 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0))
9224 sreldyn = mips_elf_rel_dyn_section (info, FALSE);
9225 if (htab->is_vxworks)
9227 /* VxWorks uses .rela.dyn instead of .rel.dyn. It does not
9228 use any of the DT_MIPS_* tags. */
9229 if (sreldyn && sreldyn->size > 0)
9231 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELA, 0))
9234 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELASZ, 0))
9237 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELAENT, 0))
9243 if (sreldyn && sreldyn->size > 0)
9245 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0))
9248 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0))
9251 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0))
9255 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_VERSION, 0))
9258 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_FLAGS, 0))
9261 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_BASE_ADDRESS, 0))
9264 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LOCAL_GOTNO, 0))
9267 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_SYMTABNO, 0))
9270 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_UNREFEXTNO, 0))
9273 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_GOTSYM, 0))
9276 if (IRIX_COMPAT (dynobj) == ict_irix5
9277 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_HIPAGENO, 0))
9280 if (IRIX_COMPAT (dynobj) == ict_irix6
9281 && (bfd_get_section_by_name
9282 (dynobj, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj)))
9283 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_OPTIONS, 0))
9286 if (htab->splt->size > 0)
9288 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTREL, 0))
9291 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_JMPREL, 0))
9294 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTRELSZ, 0))
9297 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_PLTGOT, 0))
9300 if (htab->is_vxworks
9301 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
9308 /* REL is a relocation in INPUT_BFD that is being copied to OUTPUT_BFD.
9309 Adjust its R_ADDEND field so that it is correct for the output file.
9310 LOCAL_SYMS and LOCAL_SECTIONS are arrays of INPUT_BFD's local symbols
9311 and sections respectively; both use symbol indexes. */
9314 mips_elf_adjust_addend (bfd *output_bfd, struct bfd_link_info *info,
9315 bfd *input_bfd, Elf_Internal_Sym *local_syms,
9316 asection **local_sections, Elf_Internal_Rela *rel)
9318 unsigned int r_type, r_symndx;
9319 Elf_Internal_Sym *sym;
9322 if (mips_elf_local_relocation_p (input_bfd, rel, local_sections))
9324 r_type = ELF_R_TYPE (output_bfd, rel->r_info);
9325 if (gprel16_reloc_p (r_type)
9326 || r_type == R_MIPS_GPREL32
9327 || literal_reloc_p (r_type))
9329 rel->r_addend += _bfd_get_gp_value (input_bfd);
9330 rel->r_addend -= _bfd_get_gp_value (output_bfd);
9333 r_symndx = ELF_R_SYM (output_bfd, rel->r_info);
9334 sym = local_syms + r_symndx;
9336 /* Adjust REL's addend to account for section merging. */
9337 if (!info->relocatable)
9339 sec = local_sections[r_symndx];
9340 _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
9343 /* This would normally be done by the rela_normal code in elflink.c. */
9344 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
9345 rel->r_addend += local_sections[r_symndx]->output_offset;
9349 /* Handle relocations against symbols from removed linkonce sections,
9350 or sections discarded by a linker script. We use this wrapper around
9351 RELOC_AGAINST_DISCARDED_SECTION to handle triplets of compound relocs
9352 on 64-bit ELF targets. In this case for any relocation handled, which
9353 always be the first in a triplet, the remaining two have to be processed
9354 together with the first, even if they are R_MIPS_NONE. It is the symbol
9355 index referred by the first reloc that applies to all the three and the
9356 remaining two never refer to an object symbol. And it is the final
9357 relocation (the last non-null one) that determines the output field of
9358 the whole relocation so retrieve the corresponding howto structure for
9359 the relocatable field to be cleared by RELOC_AGAINST_DISCARDED_SECTION.
9361 Note that RELOC_AGAINST_DISCARDED_SECTION is a macro that uses "continue"
9362 and therefore requires to be pasted in a loop. It also defines a block
9363 and does not protect any of its arguments, hence the extra brackets. */
9366 mips_reloc_against_discarded_section (bfd *output_bfd,
9367 struct bfd_link_info *info,
9368 bfd *input_bfd, asection *input_section,
9369 Elf_Internal_Rela **rel,
9370 const Elf_Internal_Rela **relend,
9371 bfd_boolean rel_reloc,
9372 reloc_howto_type *howto,
9375 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
9376 int count = bed->s->int_rels_per_ext_rel;
9377 unsigned int r_type;
9380 for (i = count - 1; i > 0; i--)
9382 r_type = ELF_R_TYPE (output_bfd, (*rel)[i].r_info);
9383 if (r_type != R_MIPS_NONE)
9385 howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type, !rel_reloc);
9391 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
9392 (*rel), count, (*relend),
9393 howto, i, contents);
9398 /* Relocate a MIPS ELF section. */
9401 _bfd_mips_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
9402 bfd *input_bfd, asection *input_section,
9403 bfd_byte *contents, Elf_Internal_Rela *relocs,
9404 Elf_Internal_Sym *local_syms,
9405 asection **local_sections)
9407 Elf_Internal_Rela *rel;
9408 const Elf_Internal_Rela *relend;
9410 bfd_boolean use_saved_addend_p = FALSE;
9411 const struct elf_backend_data *bed;
9413 bed = get_elf_backend_data (output_bfd);
9414 relend = relocs + input_section->reloc_count * bed->s->int_rels_per_ext_rel;
9415 for (rel = relocs; rel < relend; ++rel)
9419 reloc_howto_type *howto;
9420 bfd_boolean cross_mode_jump_p;
9421 /* TRUE if the relocation is a RELA relocation, rather than a
9423 bfd_boolean rela_relocation_p = TRUE;
9424 unsigned int r_type = ELF_R_TYPE (output_bfd, rel->r_info);
9426 unsigned long r_symndx;
9428 Elf_Internal_Shdr *symtab_hdr;
9429 struct elf_link_hash_entry *h;
9430 bfd_boolean rel_reloc;
9432 rel_reloc = (NEWABI_P (input_bfd)
9433 && mips_elf_rel_relocation_p (input_bfd, input_section,
9435 /* Find the relocation howto for this relocation. */
9436 howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type, !rel_reloc);
9438 r_symndx = ELF_R_SYM (input_bfd, rel->r_info);
9439 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
9440 if (mips_elf_local_relocation_p (input_bfd, rel, local_sections))
9442 sec = local_sections[r_symndx];
9447 unsigned long extsymoff;
9450 if (!elf_bad_symtab (input_bfd))
9451 extsymoff = symtab_hdr->sh_info;
9452 h = elf_sym_hashes (input_bfd) [r_symndx - extsymoff];
9453 while (h->root.type == bfd_link_hash_indirect
9454 || h->root.type == bfd_link_hash_warning)
9455 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9458 if (h->root.type == bfd_link_hash_defined
9459 || h->root.type == bfd_link_hash_defweak)
9460 sec = h->root.u.def.section;
9463 if (sec != NULL && discarded_section (sec))
9465 mips_reloc_against_discarded_section (output_bfd, info, input_bfd,
9466 input_section, &rel, &relend,
9467 rel_reloc, howto, contents);
9471 if (r_type == R_MIPS_64 && ! NEWABI_P (input_bfd))
9473 /* Some 32-bit code uses R_MIPS_64. In particular, people use
9474 64-bit code, but make sure all their addresses are in the
9475 lowermost or uppermost 32-bit section of the 64-bit address
9476 space. Thus, when they use an R_MIPS_64 they mean what is
9477 usually meant by R_MIPS_32, with the exception that the
9478 stored value is sign-extended to 64 bits. */
9479 howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, R_MIPS_32, FALSE);
9481 /* On big-endian systems, we need to lie about the position
9483 if (bfd_big_endian (input_bfd))
9487 if (!use_saved_addend_p)
9489 /* If these relocations were originally of the REL variety,
9490 we must pull the addend out of the field that will be
9491 relocated. Otherwise, we simply use the contents of the
9493 if (mips_elf_rel_relocation_p (input_bfd, input_section,
9496 rela_relocation_p = FALSE;
9497 addend = mips_elf_read_rel_addend (input_bfd, rel,
9499 if (hi16_reloc_p (r_type)
9500 || (got16_reloc_p (r_type)
9501 && mips_elf_local_relocation_p (input_bfd, rel,
9504 if (!mips_elf_add_lo16_rel_addend (input_bfd, rel, relend,
9508 name = h->root.root.string;
9510 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
9511 local_syms + r_symndx,
9513 (*_bfd_error_handler)
9514 (_("%B: Can't find matching LO16 reloc against `%s' for %s at 0x%lx in section `%A'"),
9515 input_bfd, input_section, name, howto->name,
9520 addend <<= howto->rightshift;
9523 addend = rel->r_addend;
9524 mips_elf_adjust_addend (output_bfd, info, input_bfd,
9525 local_syms, local_sections, rel);
9528 if (info->relocatable)
9530 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd)
9531 && bfd_big_endian (input_bfd))
9534 if (!rela_relocation_p && rel->r_addend)
9536 addend += rel->r_addend;
9537 if (hi16_reloc_p (r_type) || got16_reloc_p (r_type))
9538 addend = mips_elf_high (addend);
9539 else if (r_type == R_MIPS_HIGHER)
9540 addend = mips_elf_higher (addend);
9541 else if (r_type == R_MIPS_HIGHEST)
9542 addend = mips_elf_highest (addend);
9544 addend >>= howto->rightshift;
9546 /* We use the source mask, rather than the destination
9547 mask because the place to which we are writing will be
9548 source of the addend in the final link. */
9549 addend &= howto->src_mask;
9551 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
9552 /* See the comment above about using R_MIPS_64 in the 32-bit
9553 ABI. Here, we need to update the addend. It would be
9554 possible to get away with just using the R_MIPS_32 reloc
9555 but for endianness. */
9561 if (addend & ((bfd_vma) 1 << 31))
9563 sign_bits = ((bfd_vma) 1 << 32) - 1;
9570 /* If we don't know that we have a 64-bit type,
9571 do two separate stores. */
9572 if (bfd_big_endian (input_bfd))
9574 /* Store the sign-bits (which are most significant)
9576 low_bits = sign_bits;
9582 high_bits = sign_bits;
9584 bfd_put_32 (input_bfd, low_bits,
9585 contents + rel->r_offset);
9586 bfd_put_32 (input_bfd, high_bits,
9587 contents + rel->r_offset + 4);
9591 if (! mips_elf_perform_relocation (info, howto, rel, addend,
9592 input_bfd, input_section,
9597 /* Go on to the next relocation. */
9601 /* In the N32 and 64-bit ABIs there may be multiple consecutive
9602 relocations for the same offset. In that case we are
9603 supposed to treat the output of each relocation as the addend
9605 if (rel + 1 < relend
9606 && rel->r_offset == rel[1].r_offset
9607 && ELF_R_TYPE (input_bfd, rel[1].r_info) != R_MIPS_NONE)
9608 use_saved_addend_p = TRUE;
9610 use_saved_addend_p = FALSE;
9612 /* Figure out what value we are supposed to relocate. */
9613 switch (mips_elf_calculate_relocation (output_bfd, input_bfd,
9614 input_section, info, rel,
9615 addend, howto, local_syms,
9616 local_sections, &value,
9617 &name, &cross_mode_jump_p,
9618 use_saved_addend_p))
9620 case bfd_reloc_continue:
9621 /* There's nothing to do. */
9624 case bfd_reloc_undefined:
9625 /* mips_elf_calculate_relocation already called the
9626 undefined_symbol callback. There's no real point in
9627 trying to perform the relocation at this point, so we
9628 just skip ahead to the next relocation. */
9631 case bfd_reloc_notsupported:
9632 msg = _("internal error: unsupported relocation error");
9633 info->callbacks->warning
9634 (info, msg, name, input_bfd, input_section, rel->r_offset);
9637 case bfd_reloc_overflow:
9638 if (use_saved_addend_p)
9639 /* Ignore overflow until we reach the last relocation for
9640 a given location. */
9644 struct mips_elf_link_hash_table *htab;
9646 htab = mips_elf_hash_table (info);
9647 BFD_ASSERT (htab != NULL);
9648 BFD_ASSERT (name != NULL);
9649 if (!htab->small_data_overflow_reported
9650 && (gprel16_reloc_p (howto->type)
9651 || literal_reloc_p (howto->type)))
9653 msg = _("small-data section exceeds 64KB;"
9654 " lower small-data size limit (see option -G)");
9656 htab->small_data_overflow_reported = TRUE;
9657 (*info->callbacks->einfo) ("%P: %s\n", msg);
9659 if (! ((*info->callbacks->reloc_overflow)
9660 (info, NULL, name, howto->name, (bfd_vma) 0,
9661 input_bfd, input_section, rel->r_offset)))
9669 case bfd_reloc_outofrange:
9670 if (jal_reloc_p (howto->type))
9672 msg = _("JALX to a non-word-aligned address");
9673 info->callbacks->warning
9674 (info, msg, name, input_bfd, input_section, rel->r_offset);
9684 /* If we've got another relocation for the address, keep going
9685 until we reach the last one. */
9686 if (use_saved_addend_p)
9692 if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
9693 /* See the comment above about using R_MIPS_64 in the 32-bit
9694 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
9695 that calculated the right value. Now, however, we
9696 sign-extend the 32-bit result to 64-bits, and store it as a
9697 64-bit value. We are especially generous here in that we
9698 go to extreme lengths to support this usage on systems with
9699 only a 32-bit VMA. */
9705 if (value & ((bfd_vma) 1 << 31))
9707 sign_bits = ((bfd_vma) 1 << 32) - 1;
9714 /* If we don't know that we have a 64-bit type,
9715 do two separate stores. */
9716 if (bfd_big_endian (input_bfd))
9718 /* Undo what we did above. */
9720 /* Store the sign-bits (which are most significant)
9722 low_bits = sign_bits;
9728 high_bits = sign_bits;
9730 bfd_put_32 (input_bfd, low_bits,
9731 contents + rel->r_offset);
9732 bfd_put_32 (input_bfd, high_bits,
9733 contents + rel->r_offset + 4);
9737 /* Actually perform the relocation. */
9738 if (! mips_elf_perform_relocation (info, howto, rel, value,
9739 input_bfd, input_section,
9740 contents, cross_mode_jump_p))
9747 /* A function that iterates over each entry in la25_stubs and fills
9748 in the code for each one. DATA points to a mips_htab_traverse_info. */
9751 mips_elf_create_la25_stub (void **slot, void *data)
9753 struct mips_htab_traverse_info *hti;
9754 struct mips_elf_link_hash_table *htab;
9755 struct mips_elf_la25_stub *stub;
9758 bfd_vma offset, target, target_high, target_low;
9760 stub = (struct mips_elf_la25_stub *) *slot;
9761 hti = (struct mips_htab_traverse_info *) data;
9762 htab = mips_elf_hash_table (hti->info);
9763 BFD_ASSERT (htab != NULL);
9765 /* Create the section contents, if we haven't already. */
9766 s = stub->stub_section;
9770 loc = bfd_malloc (s->size);
9779 /* Work out where in the section this stub should go. */
9780 offset = stub->offset;
9782 /* Work out the target address. */
9783 target = mips_elf_get_la25_target (stub, &s);
9784 target += s->output_section->vma + s->output_offset;
9786 target_high = ((target + 0x8000) >> 16) & 0xffff;
9787 target_low = (target & 0xffff);
9789 if (stub->stub_section != htab->strampoline)
9791 /* This is a simple LUI/ADDIU stub. Zero out the beginning
9792 of the section and write the two instructions at the end. */
9793 memset (loc, 0, offset);
9795 if (ELF_ST_IS_MICROMIPS (stub->h->root.other))
9797 bfd_put_micromips_32 (hti->output_bfd,
9798 LA25_LUI_MICROMIPS (target_high),
9800 bfd_put_micromips_32 (hti->output_bfd,
9801 LA25_ADDIU_MICROMIPS (target_low),
9806 bfd_put_32 (hti->output_bfd, LA25_LUI (target_high), loc);
9807 bfd_put_32 (hti->output_bfd, LA25_ADDIU (target_low), loc + 4);
9812 /* This is trampoline. */
9814 if (ELF_ST_IS_MICROMIPS (stub->h->root.other))
9816 bfd_put_micromips_32 (hti->output_bfd,
9817 LA25_LUI_MICROMIPS (target_high), loc);
9818 bfd_put_micromips_32 (hti->output_bfd,
9819 LA25_J_MICROMIPS (target), loc + 4);
9820 bfd_put_micromips_32 (hti->output_bfd,
9821 LA25_ADDIU_MICROMIPS (target_low), loc + 8);
9822 bfd_put_32 (hti->output_bfd, 0, loc + 12);
9826 bfd_put_32 (hti->output_bfd, LA25_LUI (target_high), loc);
9827 bfd_put_32 (hti->output_bfd, LA25_J (target), loc + 4);
9828 bfd_put_32 (hti->output_bfd, LA25_ADDIU (target_low), loc + 8);
9829 bfd_put_32 (hti->output_bfd, 0, loc + 12);
9835 /* If NAME is one of the special IRIX6 symbols defined by the linker,
9836 adjust it appropriately now. */
9839 mips_elf_irix6_finish_dynamic_symbol (bfd *abfd ATTRIBUTE_UNUSED,
9840 const char *name, Elf_Internal_Sym *sym)
9842 /* The linker script takes care of providing names and values for
9843 these, but we must place them into the right sections. */
9844 static const char* const text_section_symbols[] = {
9847 "__dso_displacement",
9849 "__program_header_table",
9853 static const char* const data_section_symbols[] = {
9861 const char* const *p;
9864 for (i = 0; i < 2; ++i)
9865 for (p = (i == 0) ? text_section_symbols : data_section_symbols;
9868 if (strcmp (*p, name) == 0)
9870 /* All of these symbols are given type STT_SECTION by the
9872 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
9873 sym->st_other = STO_PROTECTED;
9875 /* The IRIX linker puts these symbols in special sections. */
9877 sym->st_shndx = SHN_MIPS_TEXT;
9879 sym->st_shndx = SHN_MIPS_DATA;
9885 /* Finish up dynamic symbol handling. We set the contents of various
9886 dynamic sections here. */
9889 _bfd_mips_elf_finish_dynamic_symbol (bfd *output_bfd,
9890 struct bfd_link_info *info,
9891 struct elf_link_hash_entry *h,
9892 Elf_Internal_Sym *sym)
9896 struct mips_got_info *g, *gg;
9899 struct mips_elf_link_hash_table *htab;
9900 struct mips_elf_link_hash_entry *hmips;
9902 htab = mips_elf_hash_table (info);
9903 BFD_ASSERT (htab != NULL);
9904 dynobj = elf_hash_table (info)->dynobj;
9905 hmips = (struct mips_elf_link_hash_entry *) h;
9907 BFD_ASSERT (!htab->is_vxworks);
9909 if (h->plt.offset != MINUS_ONE && hmips->no_fn_stub)
9911 /* We've decided to create a PLT entry for this symbol. */
9913 bfd_vma header_address, plt_index, got_address;
9914 bfd_vma got_address_high, got_address_low, load;
9915 const bfd_vma *plt_entry;
9917 BFD_ASSERT (htab->use_plts_and_copy_relocs);
9918 BFD_ASSERT (h->dynindx != -1);
9919 BFD_ASSERT (htab->splt != NULL);
9920 BFD_ASSERT (h->plt.offset <= htab->splt->size);
9921 BFD_ASSERT (!h->def_regular);
9923 /* Calculate the address of the PLT header. */
9924 header_address = (htab->splt->output_section->vma
9925 + htab->splt->output_offset);
9927 /* Calculate the index of the entry. */
9928 plt_index = ((h->plt.offset - htab->plt_header_size)
9929 / htab->plt_entry_size);
9931 /* Calculate the address of the .got.plt entry. */
9932 got_address = (htab->sgotplt->output_section->vma
9933 + htab->sgotplt->output_offset
9934 + (2 + plt_index) * MIPS_ELF_GOT_SIZE (dynobj));
9935 got_address_high = ((got_address + 0x8000) >> 16) & 0xffff;
9936 got_address_low = got_address & 0xffff;
9938 /* Initially point the .got.plt entry at the PLT header. */
9939 loc = (htab->sgotplt->contents
9940 + (2 + plt_index) * MIPS_ELF_GOT_SIZE (dynobj));
9941 if (ABI_64_P (output_bfd))
9942 bfd_put_64 (output_bfd, header_address, loc);
9944 bfd_put_32 (output_bfd, header_address, loc);
9946 /* Find out where the .plt entry should go. */
9947 loc = htab->splt->contents + h->plt.offset;
9949 /* Pick the load opcode. */
9950 load = MIPS_ELF_LOAD_WORD (output_bfd);
9952 /* Fill in the PLT entry itself. */
9953 plt_entry = mips_exec_plt_entry;
9954 bfd_put_32 (output_bfd, plt_entry[0] | got_address_high, loc);
9955 bfd_put_32 (output_bfd, plt_entry[1] | got_address_low | load, loc + 4);
9957 if (! LOAD_INTERLOCKS_P (output_bfd))
9959 bfd_put_32 (output_bfd, plt_entry[2] | got_address_low, loc + 8);
9960 bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
9964 bfd_put_32 (output_bfd, plt_entry[3], loc + 8);
9965 bfd_put_32 (output_bfd, plt_entry[2] | got_address_low, loc + 12);
9968 /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry. */
9969 mips_elf_output_dynamic_relocation (output_bfd, htab->srelplt,
9970 plt_index, h->dynindx,
9971 R_MIPS_JUMP_SLOT, got_address);
9973 /* We distinguish between PLT entries and lazy-binding stubs by
9974 giving the former an st_other value of STO_MIPS_PLT. Set the
9975 flag and leave the value if there are any relocations in the
9976 binary where pointer equality matters. */
9977 sym->st_shndx = SHN_UNDEF;
9978 if (h->pointer_equality_needed)
9979 sym->st_other = STO_MIPS_PLT;
9983 else if (h->plt.offset != MINUS_ONE)
9985 /* We've decided to create a lazy-binding stub. */
9986 bfd_byte stub[MIPS_FUNCTION_STUB_BIG_SIZE];
9988 /* This symbol has a stub. Set it up. */
9990 BFD_ASSERT (h->dynindx != -1);
9992 BFD_ASSERT ((htab->function_stub_size == MIPS_FUNCTION_STUB_BIG_SIZE)
9993 || (h->dynindx <= 0xffff));
9995 /* Values up to 2^31 - 1 are allowed. Larger values would cause
9996 sign extension at runtime in the stub, resulting in a negative
9998 if (h->dynindx & ~0x7fffffff)
10001 /* Fill the stub. */
10003 bfd_put_32 (output_bfd, STUB_LW (output_bfd), stub + idx);
10005 bfd_put_32 (output_bfd, STUB_MOVE (output_bfd), stub + idx);
10007 if (htab->function_stub_size == MIPS_FUNCTION_STUB_BIG_SIZE)
10009 bfd_put_32 (output_bfd, STUB_LUI ((h->dynindx >> 16) & 0x7fff),
10013 bfd_put_32 (output_bfd, STUB_JALR, stub + idx);
10016 /* If a large stub is not required and sign extension is not a
10017 problem, then use legacy code in the stub. */
10018 if (htab->function_stub_size == MIPS_FUNCTION_STUB_BIG_SIZE)
10019 bfd_put_32 (output_bfd, STUB_ORI (h->dynindx & 0xffff), stub + idx);
10020 else if (h->dynindx & ~0x7fff)
10021 bfd_put_32 (output_bfd, STUB_LI16U (h->dynindx & 0xffff), stub + idx);
10023 bfd_put_32 (output_bfd, STUB_LI16S (output_bfd, h->dynindx),
10026 BFD_ASSERT (h->plt.offset <= htab->sstubs->size);
10027 memcpy (htab->sstubs->contents + h->plt.offset,
10028 stub, htab->function_stub_size);
10030 /* Mark the symbol as undefined. plt.offset != -1 occurs
10031 only for the referenced symbol. */
10032 sym->st_shndx = SHN_UNDEF;
10034 /* The run-time linker uses the st_value field of the symbol
10035 to reset the global offset table entry for this external
10036 to its stub address when unlinking a shared object. */
10037 sym->st_value = (htab->sstubs->output_section->vma
10038 + htab->sstubs->output_offset
10042 /* If we have a MIPS16 function with a stub, the dynamic symbol must
10043 refer to the stub, since only the stub uses the standard calling
10045 if (h->dynindx != -1 && hmips->fn_stub != NULL)
10047 BFD_ASSERT (hmips->need_fn_stub);
10048 sym->st_value = (hmips->fn_stub->output_section->vma
10049 + hmips->fn_stub->output_offset);
10050 sym->st_size = hmips->fn_stub->size;
10051 sym->st_other = ELF_ST_VISIBILITY (sym->st_other);
10054 BFD_ASSERT (h->dynindx != -1
10055 || h->forced_local);
10058 g = htab->got_info;
10059 BFD_ASSERT (g != NULL);
10061 /* Run through the global symbol table, creating GOT entries for all
10062 the symbols that need them. */
10063 if (hmips->global_got_area != GGA_NONE)
10068 value = sym->st_value;
10069 offset = mips_elf_global_got_index (dynobj, output_bfd, h,
10070 R_MIPS_GOT16, info);
10071 MIPS_ELF_PUT_WORD (output_bfd, value, sgot->contents + offset);
10074 if (hmips->global_got_area != GGA_NONE && g->next && h->type != STT_TLS)
10076 struct mips_got_entry e, *p;
10082 e.abfd = output_bfd;
10087 for (g = g->next; g->next != gg; g = g->next)
10090 && (p = (struct mips_got_entry *) htab_find (g->got_entries,
10093 offset = p->gotidx;
10095 || (elf_hash_table (info)->dynamic_sections_created
10097 && p->d.h->root.def_dynamic
10098 && !p->d.h->root.def_regular))
10100 /* Create an R_MIPS_REL32 relocation for this entry. Due to
10101 the various compatibility problems, it's easier to mock
10102 up an R_MIPS_32 or R_MIPS_64 relocation and leave
10103 mips_elf_create_dynamic_relocation to calculate the
10104 appropriate addend. */
10105 Elf_Internal_Rela rel[3];
10107 memset (rel, 0, sizeof (rel));
10108 if (ABI_64_P (output_bfd))
10109 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_64);
10111 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_32);
10112 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
10115 if (! (mips_elf_create_dynamic_relocation
10116 (output_bfd, info, rel,
10117 e.d.h, NULL, sym->st_value, &entry, sgot)))
10121 entry = sym->st_value;
10122 MIPS_ELF_PUT_WORD (output_bfd, entry, sgot->contents + offset);
10127 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
10128 name = h->root.root.string;
10129 if (strcmp (name, "_DYNAMIC") == 0
10130 || h == elf_hash_table (info)->hgot)
10131 sym->st_shndx = SHN_ABS;
10132 else if (strcmp (name, "_DYNAMIC_LINK") == 0
10133 || strcmp (name, "_DYNAMIC_LINKING") == 0)
10135 sym->st_shndx = SHN_ABS;
10136 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
10139 else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (output_bfd))
10141 sym->st_shndx = SHN_ABS;
10142 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
10143 sym->st_value = elf_gp (output_bfd);
10145 else if (SGI_COMPAT (output_bfd))
10147 if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
10148 || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
10150 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
10151 sym->st_other = STO_PROTECTED;
10153 sym->st_shndx = SHN_MIPS_DATA;
10155 else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
10157 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
10158 sym->st_other = STO_PROTECTED;
10159 sym->st_value = mips_elf_hash_table (info)->procedure_count;
10160 sym->st_shndx = SHN_ABS;
10162 else if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS)
10164 if (h->type == STT_FUNC)
10165 sym->st_shndx = SHN_MIPS_TEXT;
10166 else if (h->type == STT_OBJECT)
10167 sym->st_shndx = SHN_MIPS_DATA;
10171 /* Emit a copy reloc, if needed. */
10177 BFD_ASSERT (h->dynindx != -1);
10178 BFD_ASSERT (htab->use_plts_and_copy_relocs);
10180 s = mips_elf_rel_dyn_section (info, FALSE);
10181 symval = (h->root.u.def.section->output_section->vma
10182 + h->root.u.def.section->output_offset
10183 + h->root.u.def.value);
10184 mips_elf_output_dynamic_relocation (output_bfd, s, s->reloc_count++,
10185 h->dynindx, R_MIPS_COPY, symval);
10188 /* Handle the IRIX6-specific symbols. */
10189 if (IRIX_COMPAT (output_bfd) == ict_irix6)
10190 mips_elf_irix6_finish_dynamic_symbol (output_bfd, name, sym);
10192 /* Keep dynamic MIPS16 symbols odd. This allows the dynamic linker to
10193 treat MIPS16 symbols like any other. */
10194 if (ELF_ST_IS_MIPS16 (sym->st_other))
10196 BFD_ASSERT (sym->st_value & 1);
10197 sym->st_other -= STO_MIPS16;
10203 /* Likewise, for VxWorks. */
10206 _bfd_mips_vxworks_finish_dynamic_symbol (bfd *output_bfd,
10207 struct bfd_link_info *info,
10208 struct elf_link_hash_entry *h,
10209 Elf_Internal_Sym *sym)
10213 struct mips_got_info *g;
10214 struct mips_elf_link_hash_table *htab;
10215 struct mips_elf_link_hash_entry *hmips;
10217 htab = mips_elf_hash_table (info);
10218 BFD_ASSERT (htab != NULL);
10219 dynobj = elf_hash_table (info)->dynobj;
10220 hmips = (struct mips_elf_link_hash_entry *) h;
10222 if (h->plt.offset != (bfd_vma) -1)
10225 bfd_vma plt_address, plt_index, got_address, got_offset, branch_offset;
10226 Elf_Internal_Rela rel;
10227 static const bfd_vma *plt_entry;
10229 BFD_ASSERT (h->dynindx != -1);
10230 BFD_ASSERT (htab->splt != NULL);
10231 BFD_ASSERT (h->plt.offset <= htab->splt->size);
10233 /* Calculate the address of the .plt entry. */
10234 plt_address = (htab->splt->output_section->vma
10235 + htab->splt->output_offset
10238 /* Calculate the index of the entry. */
10239 plt_index = ((h->plt.offset - htab->plt_header_size)
10240 / htab->plt_entry_size);
10242 /* Calculate the address of the .got.plt entry. */
10243 got_address = (htab->sgotplt->output_section->vma
10244 + htab->sgotplt->output_offset
10247 /* Calculate the offset of the .got.plt entry from
10248 _GLOBAL_OFFSET_TABLE_. */
10249 got_offset = mips_elf_gotplt_index (info, h);
10251 /* Calculate the offset for the branch at the start of the PLT
10252 entry. The branch jumps to the beginning of .plt. */
10253 branch_offset = -(h->plt.offset / 4 + 1) & 0xffff;
10255 /* Fill in the initial value of the .got.plt entry. */
10256 bfd_put_32 (output_bfd, plt_address,
10257 htab->sgotplt->contents + plt_index * 4);
10259 /* Find out where the .plt entry should go. */
10260 loc = htab->splt->contents + h->plt.offset;
10264 plt_entry = mips_vxworks_shared_plt_entry;
10265 bfd_put_32 (output_bfd, plt_entry[0] | branch_offset, loc);
10266 bfd_put_32 (output_bfd, plt_entry[1] | plt_index, loc + 4);
10270 bfd_vma got_address_high, got_address_low;
10272 plt_entry = mips_vxworks_exec_plt_entry;
10273 got_address_high = ((got_address + 0x8000) >> 16) & 0xffff;
10274 got_address_low = got_address & 0xffff;
10276 bfd_put_32 (output_bfd, plt_entry[0] | branch_offset, loc);
10277 bfd_put_32 (output_bfd, plt_entry[1] | plt_index, loc + 4);
10278 bfd_put_32 (output_bfd, plt_entry[2] | got_address_high, loc + 8);
10279 bfd_put_32 (output_bfd, plt_entry[3] | got_address_low, loc + 12);
10280 bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
10281 bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
10282 bfd_put_32 (output_bfd, plt_entry[6], loc + 24);
10283 bfd_put_32 (output_bfd, plt_entry[7], loc + 28);
10285 loc = (htab->srelplt2->contents
10286 + (plt_index * 3 + 2) * sizeof (Elf32_External_Rela));
10288 /* Emit a relocation for the .got.plt entry. */
10289 rel.r_offset = got_address;
10290 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_MIPS_32);
10291 rel.r_addend = h->plt.offset;
10292 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
10294 /* Emit a relocation for the lui of %hi(<.got.plt slot>). */
10295 loc += sizeof (Elf32_External_Rela);
10296 rel.r_offset = plt_address + 8;
10297 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
10298 rel.r_addend = got_offset;
10299 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
10301 /* Emit a relocation for the addiu of %lo(<.got.plt slot>). */
10302 loc += sizeof (Elf32_External_Rela);
10304 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
10305 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
10308 /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry. */
10309 loc = htab->srelplt->contents + plt_index * sizeof (Elf32_External_Rela);
10310 rel.r_offset = got_address;
10311 rel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_JUMP_SLOT);
10313 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
10315 if (!h->def_regular)
10316 sym->st_shndx = SHN_UNDEF;
10319 BFD_ASSERT (h->dynindx != -1 || h->forced_local);
10322 g = htab->got_info;
10323 BFD_ASSERT (g != NULL);
10325 /* See if this symbol has an entry in the GOT. */
10326 if (hmips->global_got_area != GGA_NONE)
10329 Elf_Internal_Rela outrel;
10333 /* Install the symbol value in the GOT. */
10334 offset = mips_elf_global_got_index (dynobj, output_bfd, h,
10335 R_MIPS_GOT16, info);
10336 MIPS_ELF_PUT_WORD (output_bfd, sym->st_value, sgot->contents + offset);
10338 /* Add a dynamic relocation for it. */
10339 s = mips_elf_rel_dyn_section (info, FALSE);
10340 loc = s->contents + (s->reloc_count++ * sizeof (Elf32_External_Rela));
10341 outrel.r_offset = (sgot->output_section->vma
10342 + sgot->output_offset
10344 outrel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_32);
10345 outrel.r_addend = 0;
10346 bfd_elf32_swap_reloca_out (dynobj, &outrel, loc);
10349 /* Emit a copy reloc, if needed. */
10352 Elf_Internal_Rela rel;
10354 BFD_ASSERT (h->dynindx != -1);
10356 rel.r_offset = (h->root.u.def.section->output_section->vma
10357 + h->root.u.def.section->output_offset
10358 + h->root.u.def.value);
10359 rel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_COPY);
10361 bfd_elf32_swap_reloca_out (output_bfd, &rel,
10362 htab->srelbss->contents
10363 + (htab->srelbss->reloc_count
10364 * sizeof (Elf32_External_Rela)));
10365 ++htab->srelbss->reloc_count;
10368 /* If this is a mips16/microMIPS symbol, force the value to be even. */
10369 if (ELF_ST_IS_COMPRESSED (sym->st_other))
10370 sym->st_value &= ~1;
10375 /* Write out a plt0 entry to the beginning of .plt. */
10378 mips_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
10381 bfd_vma gotplt_value, gotplt_value_high, gotplt_value_low;
10382 static const bfd_vma *plt_entry;
10383 struct mips_elf_link_hash_table *htab;
10385 htab = mips_elf_hash_table (info);
10386 BFD_ASSERT (htab != NULL);
10388 if (ABI_64_P (output_bfd))
10389 plt_entry = mips_n64_exec_plt0_entry;
10390 else if (ABI_N32_P (output_bfd))
10391 plt_entry = mips_n32_exec_plt0_entry;
10393 plt_entry = mips_o32_exec_plt0_entry;
10395 /* Calculate the value of .got.plt. */
10396 gotplt_value = (htab->sgotplt->output_section->vma
10397 + htab->sgotplt->output_offset);
10398 gotplt_value_high = ((gotplt_value + 0x8000) >> 16) & 0xffff;
10399 gotplt_value_low = gotplt_value & 0xffff;
10401 /* The PLT sequence is not safe for N64 if .got.plt's address can
10402 not be loaded in two instructions. */
10403 BFD_ASSERT ((gotplt_value & ~(bfd_vma) 0x7fffffff) == 0
10404 || ~(gotplt_value | 0x7fffffff) == 0);
10406 /* Install the PLT header. */
10407 loc = htab->splt->contents;
10408 bfd_put_32 (output_bfd, plt_entry[0] | gotplt_value_high, loc);
10409 bfd_put_32 (output_bfd, plt_entry[1] | gotplt_value_low, loc + 4);
10410 bfd_put_32 (output_bfd, plt_entry[2] | gotplt_value_low, loc + 8);
10411 bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
10412 bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
10413 bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
10414 bfd_put_32 (output_bfd, plt_entry[6], loc + 24);
10415 bfd_put_32 (output_bfd, plt_entry[7], loc + 28);
10418 /* Install the PLT header for a VxWorks executable and finalize the
10419 contents of .rela.plt.unloaded. */
10422 mips_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
10424 Elf_Internal_Rela rela;
10426 bfd_vma got_value, got_value_high, got_value_low, plt_address;
10427 static const bfd_vma *plt_entry;
10428 struct mips_elf_link_hash_table *htab;
10430 htab = mips_elf_hash_table (info);
10431 BFD_ASSERT (htab != NULL);
10433 plt_entry = mips_vxworks_exec_plt0_entry;
10435 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */
10436 got_value = (htab->root.hgot->root.u.def.section->output_section->vma
10437 + htab->root.hgot->root.u.def.section->output_offset
10438 + htab->root.hgot->root.u.def.value);
10440 got_value_high = ((got_value + 0x8000) >> 16) & 0xffff;
10441 got_value_low = got_value & 0xffff;
10443 /* Calculate the address of the PLT header. */
10444 plt_address = htab->splt->output_section->vma + htab->splt->output_offset;
10446 /* Install the PLT header. */
10447 loc = htab->splt->contents;
10448 bfd_put_32 (output_bfd, plt_entry[0] | got_value_high, loc);
10449 bfd_put_32 (output_bfd, plt_entry[1] | got_value_low, loc + 4);
10450 bfd_put_32 (output_bfd, plt_entry[2], loc + 8);
10451 bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
10452 bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
10453 bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
10455 /* Output the relocation for the lui of %hi(_GLOBAL_OFFSET_TABLE_). */
10456 loc = htab->srelplt2->contents;
10457 rela.r_offset = plt_address;
10458 rela.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
10460 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
10461 loc += sizeof (Elf32_External_Rela);
10463 /* Output the relocation for the following addiu of
10464 %lo(_GLOBAL_OFFSET_TABLE_). */
10465 rela.r_offset += 4;
10466 rela.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
10467 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
10468 loc += sizeof (Elf32_External_Rela);
10470 /* Fix up the remaining relocations. They may have the wrong
10471 symbol index for _G_O_T_ or _P_L_T_ depending on the order
10472 in which symbols were output. */
10473 while (loc < htab->srelplt2->contents + htab->srelplt2->size)
10475 Elf_Internal_Rela rel;
10477 bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
10478 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_MIPS_32);
10479 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
10480 loc += sizeof (Elf32_External_Rela);
10482 bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
10483 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
10484 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
10485 loc += sizeof (Elf32_External_Rela);
10487 bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
10488 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
10489 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
10490 loc += sizeof (Elf32_External_Rela);
10494 /* Install the PLT header for a VxWorks shared library. */
10497 mips_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
10500 struct mips_elf_link_hash_table *htab;
10502 htab = mips_elf_hash_table (info);
10503 BFD_ASSERT (htab != NULL);
10505 /* We just need to copy the entry byte-by-byte. */
10506 for (i = 0; i < ARRAY_SIZE (mips_vxworks_shared_plt0_entry); i++)
10507 bfd_put_32 (output_bfd, mips_vxworks_shared_plt0_entry[i],
10508 htab->splt->contents + i * 4);
10511 /* Finish up the dynamic sections. */
10514 _bfd_mips_elf_finish_dynamic_sections (bfd *output_bfd,
10515 struct bfd_link_info *info)
10520 struct mips_got_info *gg, *g;
10521 struct mips_elf_link_hash_table *htab;
10523 htab = mips_elf_hash_table (info);
10524 BFD_ASSERT (htab != NULL);
10526 dynobj = elf_hash_table (info)->dynobj;
10528 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
10531 gg = htab->got_info;
10533 if (elf_hash_table (info)->dynamic_sections_created)
10536 int dyn_to_skip = 0, dyn_skipped = 0;
10538 BFD_ASSERT (sdyn != NULL);
10539 BFD_ASSERT (gg != NULL);
10541 g = mips_elf_got_for_ibfd (gg, output_bfd);
10542 BFD_ASSERT (g != NULL);
10544 for (b = sdyn->contents;
10545 b < sdyn->contents + sdyn->size;
10546 b += MIPS_ELF_DYN_SIZE (dynobj))
10548 Elf_Internal_Dyn dyn;
10552 bfd_boolean swap_out_p;
10554 /* Read in the current dynamic entry. */
10555 (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
10557 /* Assume that we're going to modify it and write it out. */
10563 dyn.d_un.d_val = MIPS_ELF_REL_SIZE (dynobj);
10567 BFD_ASSERT (htab->is_vxworks);
10568 dyn.d_un.d_val = MIPS_ELF_RELA_SIZE (dynobj);
10572 /* Rewrite DT_STRSZ. */
10574 _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
10579 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
10582 case DT_MIPS_PLTGOT:
10584 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
10587 case DT_MIPS_RLD_VERSION:
10588 dyn.d_un.d_val = 1; /* XXX */
10591 case DT_MIPS_FLAGS:
10592 dyn.d_un.d_val = RHF_NOTPOT; /* XXX */
10595 case DT_MIPS_TIME_STAMP:
10599 dyn.d_un.d_val = t;
10603 case DT_MIPS_ICHECKSUM:
10605 swap_out_p = FALSE;
10608 case DT_MIPS_IVERSION:
10610 swap_out_p = FALSE;
10613 case DT_MIPS_BASE_ADDRESS:
10614 s = output_bfd->sections;
10615 BFD_ASSERT (s != NULL);
10616 dyn.d_un.d_ptr = s->vma & ~(bfd_vma) 0xffff;
10619 case DT_MIPS_LOCAL_GOTNO:
10620 dyn.d_un.d_val = g->local_gotno;
10623 case DT_MIPS_UNREFEXTNO:
10624 /* The index into the dynamic symbol table which is the
10625 entry of the first external symbol that is not
10626 referenced within the same object. */
10627 dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
10630 case DT_MIPS_GOTSYM:
10631 if (gg->global_gotsym)
10633 dyn.d_un.d_val = gg->global_gotsym->dynindx;
10636 /* In case if we don't have global got symbols we default
10637 to setting DT_MIPS_GOTSYM to the same value as
10638 DT_MIPS_SYMTABNO, so we just fall through. */
10640 case DT_MIPS_SYMTABNO:
10642 elemsize = MIPS_ELF_SYM_SIZE (output_bfd);
10643 s = bfd_get_section_by_name (output_bfd, name);
10644 BFD_ASSERT (s != NULL);
10646 dyn.d_un.d_val = s->size / elemsize;
10649 case DT_MIPS_HIPAGENO:
10650 dyn.d_un.d_val = g->local_gotno - htab->reserved_gotno;
10653 case DT_MIPS_RLD_MAP:
10655 struct elf_link_hash_entry *h;
10656 h = mips_elf_hash_table (info)->rld_symbol;
10659 dyn_to_skip = MIPS_ELF_DYN_SIZE (dynobj);
10660 swap_out_p = FALSE;
10663 s = h->root.u.def.section;
10664 dyn.d_un.d_ptr = (s->output_section->vma + s->output_offset
10665 + h->root.u.def.value);
10669 case DT_MIPS_OPTIONS:
10670 s = (bfd_get_section_by_name
10671 (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd)));
10672 dyn.d_un.d_ptr = s->vma;
10676 BFD_ASSERT (htab->is_vxworks);
10677 /* The count does not include the JUMP_SLOT relocations. */
10679 dyn.d_un.d_val -= htab->srelplt->size;
10683 BFD_ASSERT (htab->use_plts_and_copy_relocs);
10684 if (htab->is_vxworks)
10685 dyn.d_un.d_val = DT_RELA;
10687 dyn.d_un.d_val = DT_REL;
10691 BFD_ASSERT (htab->use_plts_and_copy_relocs);
10692 dyn.d_un.d_val = htab->srelplt->size;
10696 BFD_ASSERT (htab->use_plts_and_copy_relocs);
10697 dyn.d_un.d_ptr = (htab->srelplt->output_section->vma
10698 + htab->srelplt->output_offset);
10702 /* If we didn't need any text relocations after all, delete
10703 the dynamic tag. */
10704 if (!(info->flags & DF_TEXTREL))
10706 dyn_to_skip = MIPS_ELF_DYN_SIZE (dynobj);
10707 swap_out_p = FALSE;
10712 /* If we didn't need any text relocations after all, clear
10713 DF_TEXTREL from DT_FLAGS. */
10714 if (!(info->flags & DF_TEXTREL))
10715 dyn.d_un.d_val &= ~DF_TEXTREL;
10717 swap_out_p = FALSE;
10721 swap_out_p = FALSE;
10722 if (htab->is_vxworks
10723 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
10728 if (swap_out_p || dyn_skipped)
10729 (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
10730 (dynobj, &dyn, b - dyn_skipped);
10734 dyn_skipped += dyn_to_skip;
10739 /* Wipe out any trailing entries if we shifted down a dynamic tag. */
10740 if (dyn_skipped > 0)
10741 memset (b - dyn_skipped, 0, dyn_skipped);
10744 if (sgot != NULL && sgot->size > 0
10745 && !bfd_is_abs_section (sgot->output_section))
10747 if (htab->is_vxworks)
10749 /* The first entry of the global offset table points to the
10750 ".dynamic" section. The second is initialized by the
10751 loader and contains the shared library identifier.
10752 The third is also initialized by the loader and points
10753 to the lazy resolution stub. */
10754 MIPS_ELF_PUT_WORD (output_bfd,
10755 sdyn->output_offset + sdyn->output_section->vma,
10757 MIPS_ELF_PUT_WORD (output_bfd, 0,
10758 sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
10759 MIPS_ELF_PUT_WORD (output_bfd, 0,
10761 + 2 * MIPS_ELF_GOT_SIZE (output_bfd));
10765 /* The first entry of the global offset table will be filled at
10766 runtime. The second entry will be used by some runtime loaders.
10767 This isn't the case of IRIX rld. */
10768 MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0, sgot->contents);
10769 MIPS_ELF_PUT_WORD (output_bfd, MIPS_ELF_GNU_GOT1_MASK (output_bfd),
10770 sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
10773 elf_section_data (sgot->output_section)->this_hdr.sh_entsize
10774 = MIPS_ELF_GOT_SIZE (output_bfd);
10777 /* Generate dynamic relocations for the non-primary gots. */
10778 if (gg != NULL && gg->next)
10780 Elf_Internal_Rela rel[3];
10781 bfd_vma addend = 0;
10783 memset (rel, 0, sizeof (rel));
10784 rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_REL32);
10786 for (g = gg->next; g->next != gg; g = g->next)
10788 bfd_vma got_index = g->next->local_gotno + g->next->global_gotno
10789 + g->next->tls_gotno;
10791 MIPS_ELF_PUT_WORD (output_bfd, 0, sgot->contents
10792 + got_index++ * MIPS_ELF_GOT_SIZE (output_bfd));
10793 MIPS_ELF_PUT_WORD (output_bfd, MIPS_ELF_GNU_GOT1_MASK (output_bfd),
10795 + got_index++ * MIPS_ELF_GOT_SIZE (output_bfd));
10797 if (! info->shared)
10800 while (got_index < g->assigned_gotno)
10802 rel[0].r_offset = rel[1].r_offset = rel[2].r_offset
10803 = got_index++ * MIPS_ELF_GOT_SIZE (output_bfd);
10804 if (!(mips_elf_create_dynamic_relocation
10805 (output_bfd, info, rel, NULL,
10806 bfd_abs_section_ptr,
10807 0, &addend, sgot)))
10809 BFD_ASSERT (addend == 0);
10814 /* The generation of dynamic relocations for the non-primary gots
10815 adds more dynamic relocations. We cannot count them until
10818 if (elf_hash_table (info)->dynamic_sections_created)
10821 bfd_boolean swap_out_p;
10823 BFD_ASSERT (sdyn != NULL);
10825 for (b = sdyn->contents;
10826 b < sdyn->contents + sdyn->size;
10827 b += MIPS_ELF_DYN_SIZE (dynobj))
10829 Elf_Internal_Dyn dyn;
10832 /* Read in the current dynamic entry. */
10833 (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
10835 /* Assume that we're going to modify it and write it out. */
10841 /* Reduce DT_RELSZ to account for any relocations we
10842 decided not to make. This is for the n64 irix rld,
10843 which doesn't seem to apply any relocations if there
10844 are trailing null entries. */
10845 s = mips_elf_rel_dyn_section (info, FALSE);
10846 dyn.d_un.d_val = (s->reloc_count
10847 * (ABI_64_P (output_bfd)
10848 ? sizeof (Elf64_Mips_External_Rel)
10849 : sizeof (Elf32_External_Rel)));
10850 /* Adjust the section size too. Tools like the prelinker
10851 can reasonably expect the values to the same. */
10852 elf_section_data (s->output_section)->this_hdr.sh_size
10857 swap_out_p = FALSE;
10862 (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
10869 Elf32_compact_rel cpt;
10871 if (SGI_COMPAT (output_bfd))
10873 /* Write .compact_rel section out. */
10874 s = bfd_get_linker_section (dynobj, ".compact_rel");
10878 cpt.num = s->reloc_count;
10880 cpt.offset = (s->output_section->filepos
10881 + sizeof (Elf32_External_compact_rel));
10884 bfd_elf32_swap_compact_rel_out (output_bfd, &cpt,
10885 ((Elf32_External_compact_rel *)
10888 /* Clean up a dummy stub function entry in .text. */
10889 if (htab->sstubs != NULL)
10891 file_ptr dummy_offset;
10893 BFD_ASSERT (htab->sstubs->size >= htab->function_stub_size);
10894 dummy_offset = htab->sstubs->size - htab->function_stub_size;
10895 memset (htab->sstubs->contents + dummy_offset, 0,
10896 htab->function_stub_size);
10901 /* The psABI says that the dynamic relocations must be sorted in
10902 increasing order of r_symndx. The VxWorks EABI doesn't require
10903 this, and because the code below handles REL rather than RELA
10904 relocations, using it for VxWorks would be outright harmful. */
10905 if (!htab->is_vxworks)
10907 s = mips_elf_rel_dyn_section (info, FALSE);
10909 && s->size > (bfd_vma)2 * MIPS_ELF_REL_SIZE (output_bfd))
10911 reldyn_sorting_bfd = output_bfd;
10913 if (ABI_64_P (output_bfd))
10914 qsort ((Elf64_External_Rel *) s->contents + 1,
10915 s->reloc_count - 1, sizeof (Elf64_Mips_External_Rel),
10916 sort_dynamic_relocs_64);
10918 qsort ((Elf32_External_Rel *) s->contents + 1,
10919 s->reloc_count - 1, sizeof (Elf32_External_Rel),
10920 sort_dynamic_relocs);
10925 if (htab->splt && htab->splt->size > 0)
10927 if (htab->is_vxworks)
10930 mips_vxworks_finish_shared_plt (output_bfd, info);
10932 mips_vxworks_finish_exec_plt (output_bfd, info);
10936 BFD_ASSERT (!info->shared);
10937 mips_finish_exec_plt (output_bfd, info);
10944 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
10947 mips_set_isa_flags (bfd *abfd)
10951 switch (bfd_get_mach (abfd))
10954 case bfd_mach_mips3000:
10955 val = E_MIPS_ARCH_1;
10958 case bfd_mach_mips3900:
10959 val = E_MIPS_ARCH_1 | E_MIPS_MACH_3900;
10962 case bfd_mach_mips6000:
10963 val = E_MIPS_ARCH_2;
10966 case bfd_mach_mips4000:
10967 case bfd_mach_mips4300:
10968 case bfd_mach_mips4400:
10969 case bfd_mach_mips4600:
10970 val = E_MIPS_ARCH_3;
10973 case bfd_mach_mips4010:
10974 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4010;
10977 case bfd_mach_mips4100:
10978 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4100;
10981 case bfd_mach_mips4111:
10982 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4111;
10985 case bfd_mach_mips4120:
10986 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4120;
10989 case bfd_mach_mips4650:
10990 val = E_MIPS_ARCH_3 | E_MIPS_MACH_4650;
10993 case bfd_mach_mips5400:
10994 val = E_MIPS_ARCH_4 | E_MIPS_MACH_5400;
10997 case bfd_mach_mips5500:
10998 val = E_MIPS_ARCH_4 | E_MIPS_MACH_5500;
11001 case bfd_mach_mips9000:
11002 val = E_MIPS_ARCH_4 | E_MIPS_MACH_9000;
11005 case bfd_mach_mips5000:
11006 case bfd_mach_mips7000:
11007 case bfd_mach_mips8000:
11008 case bfd_mach_mips10000:
11009 case bfd_mach_mips12000:
11010 case bfd_mach_mips14000:
11011 case bfd_mach_mips16000:
11012 val = E_MIPS_ARCH_4;
11015 case bfd_mach_mips5:
11016 val = E_MIPS_ARCH_5;
11019 case bfd_mach_mips_loongson_2e:
11020 val = E_MIPS_ARCH_3 | E_MIPS_MACH_LS2E;
11023 case bfd_mach_mips_loongson_2f:
11024 val = E_MIPS_ARCH_3 | E_MIPS_MACH_LS2F;
11027 case bfd_mach_mips_sb1:
11028 val = E_MIPS_ARCH_64 | E_MIPS_MACH_SB1;
11031 case bfd_mach_mips_loongson_3a:
11032 val = E_MIPS_ARCH_64 | E_MIPS_MACH_LS3A;
11035 case bfd_mach_mips_octeon:
11036 case bfd_mach_mips_octeonp:
11037 val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_OCTEON;
11040 case bfd_mach_mips_xlr:
11041 val = E_MIPS_ARCH_64 | E_MIPS_MACH_XLR;
11044 case bfd_mach_mips_octeon2:
11045 val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_OCTEON2;
11048 case bfd_mach_mipsisa32:
11049 val = E_MIPS_ARCH_32;
11052 case bfd_mach_mipsisa64:
11053 val = E_MIPS_ARCH_64;
11056 case bfd_mach_mipsisa32r2:
11057 val = E_MIPS_ARCH_32R2;
11060 case bfd_mach_mipsisa64r2:
11061 val = E_MIPS_ARCH_64R2;
11064 elf_elfheader (abfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
11065 elf_elfheader (abfd)->e_flags |= val;
11070 /* The final processing done just before writing out a MIPS ELF object
11071 file. This gets the MIPS architecture right based on the machine
11072 number. This is used by both the 32-bit and the 64-bit ABI. */
11075 _bfd_mips_elf_final_write_processing (bfd *abfd,
11076 bfd_boolean linker ATTRIBUTE_UNUSED)
11079 Elf_Internal_Shdr **hdrpp;
11083 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
11084 is nonzero. This is for compatibility with old objects, which used
11085 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
11086 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == 0)
11087 mips_set_isa_flags (abfd);
11089 /* Set the sh_info field for .gptab sections and other appropriate
11090 info for each special section. */
11091 for (i = 1, hdrpp = elf_elfsections (abfd) + 1;
11092 i < elf_numsections (abfd);
11095 switch ((*hdrpp)->sh_type)
11097 case SHT_MIPS_MSYM:
11098 case SHT_MIPS_LIBLIST:
11099 sec = bfd_get_section_by_name (abfd, ".dynstr");
11101 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
11104 case SHT_MIPS_GPTAB:
11105 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
11106 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
11107 BFD_ASSERT (name != NULL
11108 && CONST_STRNEQ (name, ".gptab."));
11109 sec = bfd_get_section_by_name (abfd, name + sizeof ".gptab" - 1);
11110 BFD_ASSERT (sec != NULL);
11111 (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
11114 case SHT_MIPS_CONTENT:
11115 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
11116 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
11117 BFD_ASSERT (name != NULL
11118 && CONST_STRNEQ (name, ".MIPS.content"));
11119 sec = bfd_get_section_by_name (abfd,
11120 name + sizeof ".MIPS.content" - 1);
11121 BFD_ASSERT (sec != NULL);
11122 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
11125 case SHT_MIPS_SYMBOL_LIB:
11126 sec = bfd_get_section_by_name (abfd, ".dynsym");
11128 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
11129 sec = bfd_get_section_by_name (abfd, ".liblist");
11131 (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
11134 case SHT_MIPS_EVENTS:
11135 BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
11136 name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
11137 BFD_ASSERT (name != NULL);
11138 if (CONST_STRNEQ (name, ".MIPS.events"))
11139 sec = bfd_get_section_by_name (abfd,
11140 name + sizeof ".MIPS.events" - 1);
11143 BFD_ASSERT (CONST_STRNEQ (name, ".MIPS.post_rel"));
11144 sec = bfd_get_section_by_name (abfd,
11146 + sizeof ".MIPS.post_rel" - 1));
11148 BFD_ASSERT (sec != NULL);
11149 (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
11156 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
11160 _bfd_mips_elf_additional_program_headers (bfd *abfd,
11161 struct bfd_link_info *info ATTRIBUTE_UNUSED)
11166 /* See if we need a PT_MIPS_REGINFO segment. */
11167 s = bfd_get_section_by_name (abfd, ".reginfo");
11168 if (s && (s->flags & SEC_LOAD))
11171 /* See if we need a PT_MIPS_OPTIONS segment. */
11172 if (IRIX_COMPAT (abfd) == ict_irix6
11173 && bfd_get_section_by_name (abfd,
11174 MIPS_ELF_OPTIONS_SECTION_NAME (abfd)))
11177 /* See if we need a PT_MIPS_RTPROC segment. */
11178 if (IRIX_COMPAT (abfd) == ict_irix5
11179 && bfd_get_section_by_name (abfd, ".dynamic")
11180 && bfd_get_section_by_name (abfd, ".mdebug"))
11183 /* Allocate a PT_NULL header in dynamic objects. See
11184 _bfd_mips_elf_modify_segment_map for details. */
11185 if (!SGI_COMPAT (abfd)
11186 && bfd_get_section_by_name (abfd, ".dynamic"))
11192 /* Modify the segment map for an IRIX5 executable. */
11195 _bfd_mips_elf_modify_segment_map (bfd *abfd,
11196 struct bfd_link_info *info)
11199 struct elf_segment_map *m, **pm;
11202 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
11204 s = bfd_get_section_by_name (abfd, ".reginfo");
11205 if (s != NULL && (s->flags & SEC_LOAD) != 0)
11207 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
11208 if (m->p_type == PT_MIPS_REGINFO)
11213 m = bfd_zalloc (abfd, amt);
11217 m->p_type = PT_MIPS_REGINFO;
11219 m->sections[0] = s;
11221 /* We want to put it after the PHDR and INTERP segments. */
11222 pm = &elf_tdata (abfd)->segment_map;
11224 && ((*pm)->p_type == PT_PHDR
11225 || (*pm)->p_type == PT_INTERP))
11233 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
11234 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
11235 PT_MIPS_OPTIONS segment immediately following the program header
11237 if (NEWABI_P (abfd)
11238 /* On non-IRIX6 new abi, we'll have already created a segment
11239 for this section, so don't create another. I'm not sure this
11240 is not also the case for IRIX 6, but I can't test it right
11242 && IRIX_COMPAT (abfd) == ict_irix6)
11244 for (s = abfd->sections; s; s = s->next)
11245 if (elf_section_data (s)->this_hdr.sh_type == SHT_MIPS_OPTIONS)
11250 struct elf_segment_map *options_segment;
11252 pm = &elf_tdata (abfd)->segment_map;
11254 && ((*pm)->p_type == PT_PHDR
11255 || (*pm)->p_type == PT_INTERP))
11258 if (*pm == NULL || (*pm)->p_type != PT_MIPS_OPTIONS)
11260 amt = sizeof (struct elf_segment_map);
11261 options_segment = bfd_zalloc (abfd, amt);
11262 options_segment->next = *pm;
11263 options_segment->p_type = PT_MIPS_OPTIONS;
11264 options_segment->p_flags = PF_R;
11265 options_segment->p_flags_valid = TRUE;
11266 options_segment->count = 1;
11267 options_segment->sections[0] = s;
11268 *pm = options_segment;
11274 if (IRIX_COMPAT (abfd) == ict_irix5)
11276 /* If there are .dynamic and .mdebug sections, we make a room
11277 for the RTPROC header. FIXME: Rewrite without section names. */
11278 if (bfd_get_section_by_name (abfd, ".interp") == NULL
11279 && bfd_get_section_by_name (abfd, ".dynamic") != NULL
11280 && bfd_get_section_by_name (abfd, ".mdebug") != NULL)
11282 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
11283 if (m->p_type == PT_MIPS_RTPROC)
11288 m = bfd_zalloc (abfd, amt);
11292 m->p_type = PT_MIPS_RTPROC;
11294 s = bfd_get_section_by_name (abfd, ".rtproc");
11299 m->p_flags_valid = 1;
11304 m->sections[0] = s;
11307 /* We want to put it after the DYNAMIC segment. */
11308 pm = &elf_tdata (abfd)->segment_map;
11309 while (*pm != NULL && (*pm)->p_type != PT_DYNAMIC)
11319 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
11320 .dynstr, .dynsym, and .hash sections, and everything in
11322 for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL;
11324 if ((*pm)->p_type == PT_DYNAMIC)
11327 if (m != NULL && IRIX_COMPAT (abfd) == ict_none)
11329 /* For a normal mips executable the permissions for the PT_DYNAMIC
11330 segment are read, write and execute. We do that here since
11331 the code in elf.c sets only the read permission. This matters
11332 sometimes for the dynamic linker. */
11333 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
11335 m->p_flags = PF_R | PF_W | PF_X;
11336 m->p_flags_valid = 1;
11339 /* GNU/Linux binaries do not need the extended PT_DYNAMIC section.
11340 glibc's dynamic linker has traditionally derived the number of
11341 tags from the p_filesz field, and sometimes allocates stack
11342 arrays of that size. An overly-big PT_DYNAMIC segment can
11343 be actively harmful in such cases. Making PT_DYNAMIC contain
11344 other sections can also make life hard for the prelinker,
11345 which might move one of the other sections to a different
11346 PT_LOAD segment. */
11347 if (SGI_COMPAT (abfd)
11350 && strcmp (m->sections[0]->name, ".dynamic") == 0)
11352 static const char *sec_names[] =
11354 ".dynamic", ".dynstr", ".dynsym", ".hash"
11358 struct elf_segment_map *n;
11360 low = ~(bfd_vma) 0;
11362 for (i = 0; i < sizeof sec_names / sizeof sec_names[0]; i++)
11364 s = bfd_get_section_by_name (abfd, sec_names[i]);
11365 if (s != NULL && (s->flags & SEC_LOAD) != 0)
11372 if (high < s->vma + sz)
11373 high = s->vma + sz;
11378 for (s = abfd->sections; s != NULL; s = s->next)
11379 if ((s->flags & SEC_LOAD) != 0
11381 && s->vma + s->size <= high)
11384 amt = sizeof *n + (bfd_size_type) (c - 1) * sizeof (asection *);
11385 n = bfd_zalloc (abfd, amt);
11392 for (s = abfd->sections; s != NULL; s = s->next)
11394 if ((s->flags & SEC_LOAD) != 0
11396 && s->vma + s->size <= high)
11398 n->sections[i] = s;
11407 /* Allocate a spare program header in dynamic objects so that tools
11408 like the prelinker can add an extra PT_LOAD entry.
11410 If the prelinker needs to make room for a new PT_LOAD entry, its
11411 standard procedure is to move the first (read-only) sections into
11412 the new (writable) segment. However, the MIPS ABI requires
11413 .dynamic to be in a read-only segment, and the section will often
11414 start within sizeof (ElfNN_Phdr) bytes of the last program header.
11416 Although the prelinker could in principle move .dynamic to a
11417 writable segment, it seems better to allocate a spare program
11418 header instead, and avoid the need to move any sections.
11419 There is a long tradition of allocating spare dynamic tags,
11420 so allocating a spare program header seems like a natural
11423 If INFO is NULL, we may be copying an already prelinked binary
11424 with objcopy or strip, so do not add this header. */
11426 && !SGI_COMPAT (abfd)
11427 && bfd_get_section_by_name (abfd, ".dynamic"))
11429 for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL; pm = &(*pm)->next)
11430 if ((*pm)->p_type == PT_NULL)
11434 m = bfd_zalloc (abfd, sizeof (*m));
11438 m->p_type = PT_NULL;
11446 /* Return the section that should be marked against GC for a given
11450 _bfd_mips_elf_gc_mark_hook (asection *sec,
11451 struct bfd_link_info *info,
11452 Elf_Internal_Rela *rel,
11453 struct elf_link_hash_entry *h,
11454 Elf_Internal_Sym *sym)
11456 /* ??? Do mips16 stub sections need to be handled special? */
11459 switch (ELF_R_TYPE (sec->owner, rel->r_info))
11461 case R_MIPS_GNU_VTINHERIT:
11462 case R_MIPS_GNU_VTENTRY:
11466 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
11469 /* Update the got entry reference counts for the section being removed. */
11472 _bfd_mips_elf_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
11473 struct bfd_link_info *info ATTRIBUTE_UNUSED,
11474 asection *sec ATTRIBUTE_UNUSED,
11475 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
11478 Elf_Internal_Shdr *symtab_hdr;
11479 struct elf_link_hash_entry **sym_hashes;
11480 bfd_signed_vma *local_got_refcounts;
11481 const Elf_Internal_Rela *rel, *relend;
11482 unsigned long r_symndx;
11483 struct elf_link_hash_entry *h;
11485 if (info->relocatable)
11488 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
11489 sym_hashes = elf_sym_hashes (abfd);
11490 local_got_refcounts = elf_local_got_refcounts (abfd);
11492 relend = relocs + sec->reloc_count;
11493 for (rel = relocs; rel < relend; rel++)
11494 switch (ELF_R_TYPE (abfd, rel->r_info))
11496 case R_MIPS16_GOT16:
11497 case R_MIPS16_CALL16:
11499 case R_MIPS_CALL16:
11500 case R_MIPS_CALL_HI16:
11501 case R_MIPS_CALL_LO16:
11502 case R_MIPS_GOT_HI16:
11503 case R_MIPS_GOT_LO16:
11504 case R_MIPS_GOT_DISP:
11505 case R_MIPS_GOT_PAGE:
11506 case R_MIPS_GOT_OFST:
11507 case R_MICROMIPS_GOT16:
11508 case R_MICROMIPS_CALL16:
11509 case R_MICROMIPS_CALL_HI16:
11510 case R_MICROMIPS_CALL_LO16:
11511 case R_MICROMIPS_GOT_HI16:
11512 case R_MICROMIPS_GOT_LO16:
11513 case R_MICROMIPS_GOT_DISP:
11514 case R_MICROMIPS_GOT_PAGE:
11515 case R_MICROMIPS_GOT_OFST:
11516 /* ??? It would seem that the existing MIPS code does no sort
11517 of reference counting or whatnot on its GOT and PLT entries,
11518 so it is not possible to garbage collect them at this time. */
11529 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
11530 hiding the old indirect symbol. Process additional relocation
11531 information. Also called for weakdefs, in which case we just let
11532 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
11535 _bfd_mips_elf_copy_indirect_symbol (struct bfd_link_info *info,
11536 struct elf_link_hash_entry *dir,
11537 struct elf_link_hash_entry *ind)
11539 struct mips_elf_link_hash_entry *dirmips, *indmips;
11541 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
11543 dirmips = (struct mips_elf_link_hash_entry *) dir;
11544 indmips = (struct mips_elf_link_hash_entry *) ind;
11545 /* Any absolute non-dynamic relocations against an indirect or weak
11546 definition will be against the target symbol. */
11547 if (indmips->has_static_relocs)
11548 dirmips->has_static_relocs = TRUE;
11550 if (ind->root.type != bfd_link_hash_indirect)
11553 dirmips->possibly_dynamic_relocs += indmips->possibly_dynamic_relocs;
11554 if (indmips->readonly_reloc)
11555 dirmips->readonly_reloc = TRUE;
11556 if (indmips->no_fn_stub)
11557 dirmips->no_fn_stub = TRUE;
11558 if (indmips->fn_stub)
11560 dirmips->fn_stub = indmips->fn_stub;
11561 indmips->fn_stub = NULL;
11563 if (indmips->need_fn_stub)
11565 dirmips->need_fn_stub = TRUE;
11566 indmips->need_fn_stub = FALSE;
11568 if (indmips->call_stub)
11570 dirmips->call_stub = indmips->call_stub;
11571 indmips->call_stub = NULL;
11573 if (indmips->call_fp_stub)
11575 dirmips->call_fp_stub = indmips->call_fp_stub;
11576 indmips->call_fp_stub = NULL;
11578 if (indmips->global_got_area < dirmips->global_got_area)
11579 dirmips->global_got_area = indmips->global_got_area;
11580 if (indmips->global_got_area < GGA_NONE)
11581 indmips->global_got_area = GGA_NONE;
11582 if (indmips->has_nonpic_branches)
11583 dirmips->has_nonpic_branches = TRUE;
11585 if (dirmips->tls_type == 0)
11586 dirmips->tls_type = indmips->tls_type;
11589 #define PDR_SIZE 32
11592 _bfd_mips_elf_discard_info (bfd *abfd, struct elf_reloc_cookie *cookie,
11593 struct bfd_link_info *info)
11596 bfd_boolean ret = FALSE;
11597 unsigned char *tdata;
11600 o = bfd_get_section_by_name (abfd, ".pdr");
11605 if (o->size % PDR_SIZE != 0)
11607 if (o->output_section != NULL
11608 && bfd_is_abs_section (o->output_section))
11611 tdata = bfd_zmalloc (o->size / PDR_SIZE);
11615 cookie->rels = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
11616 info->keep_memory);
11623 cookie->rel = cookie->rels;
11624 cookie->relend = cookie->rels + o->reloc_count;
11626 for (i = 0, skip = 0; i < o->size / PDR_SIZE; i ++)
11628 if (bfd_elf_reloc_symbol_deleted_p (i * PDR_SIZE, cookie))
11637 mips_elf_section_data (o)->u.tdata = tdata;
11638 o->size -= skip * PDR_SIZE;
11644 if (! info->keep_memory)
11645 free (cookie->rels);
11651 _bfd_mips_elf_ignore_discarded_relocs (asection *sec)
11653 if (strcmp (sec->name, ".pdr") == 0)
11659 _bfd_mips_elf_write_section (bfd *output_bfd,
11660 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
11661 asection *sec, bfd_byte *contents)
11663 bfd_byte *to, *from, *end;
11666 if (strcmp (sec->name, ".pdr") != 0)
11669 if (mips_elf_section_data (sec)->u.tdata == NULL)
11673 end = contents + sec->size;
11674 for (from = contents, i = 0;
11676 from += PDR_SIZE, i++)
11678 if ((mips_elf_section_data (sec)->u.tdata)[i] == 1)
11681 memcpy (to, from, PDR_SIZE);
11684 bfd_set_section_contents (output_bfd, sec->output_section, contents,
11685 sec->output_offset, sec->size);
11689 /* microMIPS code retains local labels for linker relaxation. Omit them
11690 from output by default for clarity. */
11693 _bfd_mips_elf_is_target_special_symbol (bfd *abfd, asymbol *sym)
11695 return _bfd_elf_is_local_label_name (abfd, sym->name);
11698 /* MIPS ELF uses a special find_nearest_line routine in order the
11699 handle the ECOFF debugging information. */
11701 struct mips_elf_find_line
11703 struct ecoff_debug_info d;
11704 struct ecoff_find_line i;
11708 _bfd_mips_elf_find_nearest_line (bfd *abfd, asection *section,
11709 asymbol **symbols, bfd_vma offset,
11710 const char **filename_ptr,
11711 const char **functionname_ptr,
11712 unsigned int *line_ptr)
11716 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
11717 filename_ptr, functionname_ptr,
11721 if (_bfd_dwarf2_find_nearest_line (abfd, dwarf_debug_sections,
11722 section, symbols, offset,
11723 filename_ptr, functionname_ptr,
11724 line_ptr, NULL, ABI_64_P (abfd) ? 8 : 0,
11725 &elf_tdata (abfd)->dwarf2_find_line_info))
11728 msec = bfd_get_section_by_name (abfd, ".mdebug");
11731 flagword origflags;
11732 struct mips_elf_find_line *fi;
11733 const struct ecoff_debug_swap * const swap =
11734 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
11736 /* If we are called during a link, mips_elf_final_link may have
11737 cleared the SEC_HAS_CONTENTS field. We force it back on here
11738 if appropriate (which it normally will be). */
11739 origflags = msec->flags;
11740 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
11741 msec->flags |= SEC_HAS_CONTENTS;
11743 fi = elf_tdata (abfd)->find_line_info;
11746 bfd_size_type external_fdr_size;
11749 struct fdr *fdr_ptr;
11750 bfd_size_type amt = sizeof (struct mips_elf_find_line);
11752 fi = bfd_zalloc (abfd, amt);
11755 msec->flags = origflags;
11759 if (! _bfd_mips_elf_read_ecoff_info (abfd, msec, &fi->d))
11761 msec->flags = origflags;
11765 /* Swap in the FDR information. */
11766 amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
11767 fi->d.fdr = bfd_alloc (abfd, amt);
11768 if (fi->d.fdr == NULL)
11770 msec->flags = origflags;
11773 external_fdr_size = swap->external_fdr_size;
11774 fdr_ptr = fi->d.fdr;
11775 fraw_src = (char *) fi->d.external_fdr;
11776 fraw_end = (fraw_src
11777 + fi->d.symbolic_header.ifdMax * external_fdr_size);
11778 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
11779 (*swap->swap_fdr_in) (abfd, fraw_src, fdr_ptr);
11781 elf_tdata (abfd)->find_line_info = fi;
11783 /* Note that we don't bother to ever free this information.
11784 find_nearest_line is either called all the time, as in
11785 objdump -l, so the information should be saved, or it is
11786 rarely called, as in ld error messages, so the memory
11787 wasted is unimportant. Still, it would probably be a
11788 good idea for free_cached_info to throw it away. */
11791 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
11792 &fi->i, filename_ptr, functionname_ptr,
11795 msec->flags = origflags;
11799 msec->flags = origflags;
11802 /* Fall back on the generic ELF find_nearest_line routine. */
11804 return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
11805 filename_ptr, functionname_ptr,
11810 _bfd_mips_elf_find_inliner_info (bfd *abfd,
11811 const char **filename_ptr,
11812 const char **functionname_ptr,
11813 unsigned int *line_ptr)
11816 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
11817 functionname_ptr, line_ptr,
11818 & elf_tdata (abfd)->dwarf2_find_line_info);
11823 /* When are writing out the .options or .MIPS.options section,
11824 remember the bytes we are writing out, so that we can install the
11825 GP value in the section_processing routine. */
11828 _bfd_mips_elf_set_section_contents (bfd *abfd, sec_ptr section,
11829 const void *location,
11830 file_ptr offset, bfd_size_type count)
11832 if (MIPS_ELF_OPTIONS_SECTION_NAME_P (section->name))
11836 if (elf_section_data (section) == NULL)
11838 bfd_size_type amt = sizeof (struct bfd_elf_section_data);
11839 section->used_by_bfd = bfd_zalloc (abfd, amt);
11840 if (elf_section_data (section) == NULL)
11843 c = mips_elf_section_data (section)->u.tdata;
11846 c = bfd_zalloc (abfd, section->size);
11849 mips_elf_section_data (section)->u.tdata = c;
11852 memcpy (c + offset, location, count);
11855 return _bfd_elf_set_section_contents (abfd, section, location, offset,
11859 /* This is almost identical to bfd_generic_get_... except that some
11860 MIPS relocations need to be handled specially. Sigh. */
11863 _bfd_elf_mips_get_relocated_section_contents
11865 struct bfd_link_info *link_info,
11866 struct bfd_link_order *link_order,
11868 bfd_boolean relocatable,
11871 /* Get enough memory to hold the stuff */
11872 bfd *input_bfd = link_order->u.indirect.section->owner;
11873 asection *input_section = link_order->u.indirect.section;
11876 long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
11877 arelent **reloc_vector = NULL;
11880 if (reloc_size < 0)
11883 reloc_vector = bfd_malloc (reloc_size);
11884 if (reloc_vector == NULL && reloc_size != 0)
11887 /* read in the section */
11888 sz = input_section->rawsize ? input_section->rawsize : input_section->size;
11889 if (!bfd_get_section_contents (input_bfd, input_section, data, 0, sz))
11892 reloc_count = bfd_canonicalize_reloc (input_bfd,
11896 if (reloc_count < 0)
11899 if (reloc_count > 0)
11904 bfd_vma gp = 0x12345678; /* initialize just to shut gcc up */
11907 struct bfd_hash_entry *h;
11908 struct bfd_link_hash_entry *lh;
11909 /* Skip all this stuff if we aren't mixing formats. */
11910 if (abfd && input_bfd
11911 && abfd->xvec == input_bfd->xvec)
11915 h = bfd_hash_lookup (&link_info->hash->table, "_gp", FALSE, FALSE);
11916 lh = (struct bfd_link_hash_entry *) h;
11923 case bfd_link_hash_undefined:
11924 case bfd_link_hash_undefweak:
11925 case bfd_link_hash_common:
11928 case bfd_link_hash_defined:
11929 case bfd_link_hash_defweak:
11931 gp = lh->u.def.value;
11933 case bfd_link_hash_indirect:
11934 case bfd_link_hash_warning:
11936 /* @@FIXME ignoring warning for now */
11938 case bfd_link_hash_new:
11947 for (parent = reloc_vector; *parent != NULL; parent++)
11949 char *error_message = NULL;
11950 bfd_reloc_status_type r;
11952 /* Specific to MIPS: Deal with relocation types that require
11953 knowing the gp of the output bfd. */
11954 asymbol *sym = *(*parent)->sym_ptr_ptr;
11956 /* If we've managed to find the gp and have a special
11957 function for the relocation then go ahead, else default
11958 to the generic handling. */
11960 && (*parent)->howto->special_function
11961 == _bfd_mips_elf32_gprel16_reloc)
11962 r = _bfd_mips_elf_gprel16_with_gp (input_bfd, sym, *parent,
11963 input_section, relocatable,
11966 r = bfd_perform_relocation (input_bfd, *parent, data,
11968 relocatable ? abfd : NULL,
11973 asection *os = input_section->output_section;
11975 /* A partial link, so keep the relocs */
11976 os->orelocation[os->reloc_count] = *parent;
11980 if (r != bfd_reloc_ok)
11984 case bfd_reloc_undefined:
11985 if (!((*link_info->callbacks->undefined_symbol)
11986 (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
11987 input_bfd, input_section, (*parent)->address, TRUE)))
11990 case bfd_reloc_dangerous:
11991 BFD_ASSERT (error_message != NULL);
11992 if (!((*link_info->callbacks->reloc_dangerous)
11993 (link_info, error_message, input_bfd, input_section,
11994 (*parent)->address)))
11997 case bfd_reloc_overflow:
11998 if (!((*link_info->callbacks->reloc_overflow)
12000 bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
12001 (*parent)->howto->name, (*parent)->addend,
12002 input_bfd, input_section, (*parent)->address)))
12005 case bfd_reloc_outofrange:
12014 if (reloc_vector != NULL)
12015 free (reloc_vector);
12019 if (reloc_vector != NULL)
12020 free (reloc_vector);
12025 mips_elf_relax_delete_bytes (bfd *abfd,
12026 asection *sec, bfd_vma addr, int count)
12028 Elf_Internal_Shdr *symtab_hdr;
12029 unsigned int sec_shndx;
12030 bfd_byte *contents;
12031 Elf_Internal_Rela *irel, *irelend;
12032 Elf_Internal_Sym *isym;
12033 Elf_Internal_Sym *isymend;
12034 struct elf_link_hash_entry **sym_hashes;
12035 struct elf_link_hash_entry **end_hashes;
12036 struct elf_link_hash_entry **start_hashes;
12037 unsigned int symcount;
12039 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
12040 contents = elf_section_data (sec)->this_hdr.contents;
12042 irel = elf_section_data (sec)->relocs;
12043 irelend = irel + sec->reloc_count;
12045 /* Actually delete the bytes. */
12046 memmove (contents + addr, contents + addr + count,
12047 (size_t) (sec->size - addr - count));
12048 sec->size -= count;
12050 /* Adjust all the relocs. */
12051 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
12053 /* Get the new reloc address. */
12054 if (irel->r_offset > addr)
12055 irel->r_offset -= count;
12058 BFD_ASSERT (addr % 2 == 0);
12059 BFD_ASSERT (count % 2 == 0);
12061 /* Adjust the local symbols defined in this section. */
12062 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12063 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
12064 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
12065 if (isym->st_shndx == sec_shndx && isym->st_value > addr)
12066 isym->st_value -= count;
12068 /* Now adjust the global symbols defined in this section. */
12069 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
12070 - symtab_hdr->sh_info);
12071 sym_hashes = start_hashes = elf_sym_hashes (abfd);
12072 end_hashes = sym_hashes + symcount;
12074 for (; sym_hashes < end_hashes; sym_hashes++)
12076 struct elf_link_hash_entry *sym_hash = *sym_hashes;
12078 if ((sym_hash->root.type == bfd_link_hash_defined
12079 || sym_hash->root.type == bfd_link_hash_defweak)
12080 && sym_hash->root.u.def.section == sec)
12082 bfd_vma value = sym_hash->root.u.def.value;
12084 if (ELF_ST_IS_MICROMIPS (sym_hash->other))
12085 value &= MINUS_TWO;
12087 sym_hash->root.u.def.value -= count;
12095 /* Opcodes needed for microMIPS relaxation as found in
12096 opcodes/micromips-opc.c. */
12098 struct opcode_descriptor {
12099 unsigned long match;
12100 unsigned long mask;
12103 /* The $ra register aka $31. */
12107 /* 32-bit instruction format register fields. */
12109 #define OP32_SREG(opcode) (((opcode) >> 16) & 0x1f)
12110 #define OP32_TREG(opcode) (((opcode) >> 21) & 0x1f)
12112 /* Check if a 5-bit register index can be abbreviated to 3 bits. */
12114 #define OP16_VALID_REG(r) \
12115 ((2 <= (r) && (r) <= 7) || (16 <= (r) && (r) <= 17))
12118 /* 32-bit and 16-bit branches. */
12120 static const struct opcode_descriptor b_insns_32[] = {
12121 { /* "b", "p", */ 0x40400000, 0xffff0000 }, /* bgez 0 */
12122 { /* "b", "p", */ 0x94000000, 0xffff0000 }, /* beq 0, 0 */
12123 { 0, 0 } /* End marker for find_match(). */
12126 static const struct opcode_descriptor bc_insn_32 =
12127 { /* "bc(1|2)(ft)", "N,p", */ 0x42800000, 0xfec30000 };
12129 static const struct opcode_descriptor bz_insn_32 =
12130 { /* "b(g|l)(e|t)z", "s,p", */ 0x40000000, 0xff200000 };
12132 static const struct opcode_descriptor bzal_insn_32 =
12133 { /* "b(ge|lt)zal", "s,p", */ 0x40200000, 0xffa00000 };
12135 static const struct opcode_descriptor beq_insn_32 =
12136 { /* "b(eq|ne)", "s,t,p", */ 0x94000000, 0xdc000000 };
12138 static const struct opcode_descriptor b_insn_16 =
12139 { /* "b", "mD", */ 0xcc00, 0xfc00 };
12141 static const struct opcode_descriptor bz_insn_16 =
12142 { /* "b(eq|ne)z", "md,mE", */ 0x8c00, 0xdc00 };
12145 /* 32-bit and 16-bit branch EQ and NE zero. */
12147 /* NOTE: All opcode tables have BEQ/BNE in the same order: first the
12148 eq and second the ne. This convention is used when replacing a
12149 32-bit BEQ/BNE with the 16-bit version. */
12151 #define BZC32_REG_FIELD(r) (((r) & 0x1f) << 16)
12153 static const struct opcode_descriptor bz_rs_insns_32[] = {
12154 { /* "beqz", "s,p", */ 0x94000000, 0xffe00000 },
12155 { /* "bnez", "s,p", */ 0xb4000000, 0xffe00000 },
12156 { 0, 0 } /* End marker for find_match(). */
12159 static const struct opcode_descriptor bz_rt_insns_32[] = {
12160 { /* "beqz", "t,p", */ 0x94000000, 0xfc01f000 },
12161 { /* "bnez", "t,p", */ 0xb4000000, 0xfc01f000 },
12162 { 0, 0 } /* End marker for find_match(). */
12165 static const struct opcode_descriptor bzc_insns_32[] = {
12166 { /* "beqzc", "s,p", */ 0x40e00000, 0xffe00000 },
12167 { /* "bnezc", "s,p", */ 0x40a00000, 0xffe00000 },
12168 { 0, 0 } /* End marker for find_match(). */
12171 static const struct opcode_descriptor bz_insns_16[] = {
12172 { /* "beqz", "md,mE", */ 0x8c00, 0xfc00 },
12173 { /* "bnez", "md,mE", */ 0xac00, 0xfc00 },
12174 { 0, 0 } /* End marker for find_match(). */
12177 /* Switch between a 5-bit register index and its 3-bit shorthand. */
12179 #define BZ16_REG(opcode) ((((((opcode) >> 7) & 7) + 0x1e) & 0x17) + 2)
12180 #define BZ16_REG_FIELD(r) \
12181 (((2 <= (r) && (r) <= 7) ? (r) : ((r) - 16)) << 7)
12184 /* 32-bit instructions with a delay slot. */
12186 static const struct opcode_descriptor jal_insn_32_bd16 =
12187 { /* "jals", "a", */ 0x74000000, 0xfc000000 };
12189 static const struct opcode_descriptor jal_insn_32_bd32 =
12190 { /* "jal", "a", */ 0xf4000000, 0xfc000000 };
12192 static const struct opcode_descriptor jal_x_insn_32_bd32 =
12193 { /* "jal[x]", "a", */ 0xf0000000, 0xf8000000 };
12195 static const struct opcode_descriptor j_insn_32 =
12196 { /* "j", "a", */ 0xd4000000, 0xfc000000 };
12198 static const struct opcode_descriptor jalr_insn_32 =
12199 { /* "jalr[.hb]", "t,s", */ 0x00000f3c, 0xfc00efff };
12201 /* This table can be compacted, because no opcode replacement is made. */
12203 static const struct opcode_descriptor ds_insns_32_bd16[] = {
12204 { /* "jals", "a", */ 0x74000000, 0xfc000000 },
12206 { /* "jalrs[.hb]", "t,s", */ 0x00004f3c, 0xfc00efff },
12207 { /* "b(ge|lt)zals", "s,p", */ 0x42200000, 0xffa00000 },
12209 { /* "b(g|l)(e|t)z", "s,p", */ 0x40000000, 0xff200000 },
12210 { /* "b(eq|ne)", "s,t,p", */ 0x94000000, 0xdc000000 },
12211 { /* "j", "a", */ 0xd4000000, 0xfc000000 },
12212 { 0, 0 } /* End marker for find_match(). */
12215 /* This table can be compacted, because no opcode replacement is made. */
12217 static const struct opcode_descriptor ds_insns_32_bd32[] = {
12218 { /* "jal[x]", "a", */ 0xf0000000, 0xf8000000 },
12220 { /* "jalr[.hb]", "t,s", */ 0x00000f3c, 0xfc00efff },
12221 { /* "b(ge|lt)zal", "s,p", */ 0x40200000, 0xffa00000 },
12222 { 0, 0 } /* End marker for find_match(). */
12226 /* 16-bit instructions with a delay slot. */
12228 static const struct opcode_descriptor jalr_insn_16_bd16 =
12229 { /* "jalrs", "my,mj", */ 0x45e0, 0xffe0 };
12231 static const struct opcode_descriptor jalr_insn_16_bd32 =
12232 { /* "jalr", "my,mj", */ 0x45c0, 0xffe0 };
12234 static const struct opcode_descriptor jr_insn_16 =
12235 { /* "jr", "mj", */ 0x4580, 0xffe0 };
12237 #define JR16_REG(opcode) ((opcode) & 0x1f)
12239 /* This table can be compacted, because no opcode replacement is made. */
12241 static const struct opcode_descriptor ds_insns_16_bd16[] = {
12242 { /* "jalrs", "my,mj", */ 0x45e0, 0xffe0 },
12244 { /* "b", "mD", */ 0xcc00, 0xfc00 },
12245 { /* "b(eq|ne)z", "md,mE", */ 0x8c00, 0xdc00 },
12246 { /* "jr", "mj", */ 0x4580, 0xffe0 },
12247 { 0, 0 } /* End marker for find_match(). */
12251 /* LUI instruction. */
12253 static const struct opcode_descriptor lui_insn =
12254 { /* "lui", "s,u", */ 0x41a00000, 0xffe00000 };
12257 /* ADDIU instruction. */
12259 static const struct opcode_descriptor addiu_insn =
12260 { /* "addiu", "t,r,j", */ 0x30000000, 0xfc000000 };
12262 static const struct opcode_descriptor addiupc_insn =
12263 { /* "addiu", "mb,$pc,mQ", */ 0x78000000, 0xfc000000 };
12265 #define ADDIUPC_REG_FIELD(r) \
12266 (((2 <= (r) && (r) <= 7) ? (r) : ((r) - 16)) << 23)
12269 /* Relaxable instructions in a JAL delay slot: MOVE. */
12271 /* The 16-bit move has rd in 9:5 and rs in 4:0. The 32-bit moves
12272 (ADDU, OR) have rd in 15:11 and rs in 10:16. */
12273 #define MOVE32_RD(opcode) (((opcode) >> 11) & 0x1f)
12274 #define MOVE32_RS(opcode) (((opcode) >> 16) & 0x1f)
12276 #define MOVE16_RD_FIELD(r) (((r) & 0x1f) << 5)
12277 #define MOVE16_RS_FIELD(r) (((r) & 0x1f) )
12279 static const struct opcode_descriptor move_insns_32[] = {
12280 { /* "move", "d,s", */ 0x00000150, 0xffe007ff }, /* addu d,s,$0 */
12281 { /* "move", "d,s", */ 0x00000290, 0xffe007ff }, /* or d,s,$0 */
12282 { 0, 0 } /* End marker for find_match(). */
12285 static const struct opcode_descriptor move_insn_16 =
12286 { /* "move", "mp,mj", */ 0x0c00, 0xfc00 };
12289 /* NOP instructions. */
12291 static const struct opcode_descriptor nop_insn_32 =
12292 { /* "nop", "", */ 0x00000000, 0xffffffff };
12294 static const struct opcode_descriptor nop_insn_16 =
12295 { /* "nop", "", */ 0x0c00, 0xffff };
12298 /* Instruction match support. */
12300 #define MATCH(opcode, insn) ((opcode & insn.mask) == insn.match)
12303 find_match (unsigned long opcode, const struct opcode_descriptor insn[])
12305 unsigned long indx;
12307 for (indx = 0; insn[indx].mask != 0; indx++)
12308 if (MATCH (opcode, insn[indx]))
12315 /* Branch and delay slot decoding support. */
12317 /* If PTR points to what *might* be a 16-bit branch or jump, then
12318 return the minimum length of its delay slot, otherwise return 0.
12319 Non-zero results are not definitive as we might be checking against
12320 the second half of another instruction. */
12323 check_br16_dslot (bfd *abfd, bfd_byte *ptr)
12325 unsigned long opcode;
12328 opcode = bfd_get_16 (abfd, ptr);
12329 if (MATCH (opcode, jalr_insn_16_bd32) != 0)
12330 /* 16-bit branch/jump with a 32-bit delay slot. */
12332 else if (MATCH (opcode, jalr_insn_16_bd16) != 0
12333 || find_match (opcode, ds_insns_16_bd16) >= 0)
12334 /* 16-bit branch/jump with a 16-bit delay slot. */
12337 /* No delay slot. */
12343 /* If PTR points to what *might* be a 32-bit branch or jump, then
12344 return the minimum length of its delay slot, otherwise return 0.
12345 Non-zero results are not definitive as we might be checking against
12346 the second half of another instruction. */
12349 check_br32_dslot (bfd *abfd, bfd_byte *ptr)
12351 unsigned long opcode;
12354 opcode = bfd_get_micromips_32 (abfd, ptr);
12355 if (find_match (opcode, ds_insns_32_bd32) >= 0)
12356 /* 32-bit branch/jump with a 32-bit delay slot. */
12358 else if (find_match (opcode, ds_insns_32_bd16) >= 0)
12359 /* 32-bit branch/jump with a 16-bit delay slot. */
12362 /* No delay slot. */
12368 /* If PTR points to a 16-bit branch or jump with a 32-bit delay slot
12369 that doesn't fiddle with REG, then return TRUE, otherwise FALSE. */
12372 check_br16 (bfd *abfd, bfd_byte *ptr, unsigned long reg)
12374 unsigned long opcode;
12376 opcode = bfd_get_16 (abfd, ptr);
12377 if (MATCH (opcode, b_insn_16)
12379 || (MATCH (opcode, jr_insn_16) && reg != JR16_REG (opcode))
12381 || (MATCH (opcode, bz_insn_16) && reg != BZ16_REG (opcode))
12382 /* BEQZ16, BNEZ16 */
12383 || (MATCH (opcode, jalr_insn_16_bd32)
12385 && reg != JR16_REG (opcode) && reg != RA))
12391 /* If PTR points to a 32-bit branch or jump that doesn't fiddle with REG,
12392 then return TRUE, otherwise FALSE. */
12395 check_br32 (bfd *abfd, bfd_byte *ptr, unsigned long reg)
12397 unsigned long opcode;
12399 opcode = bfd_get_micromips_32 (abfd, ptr);
12400 if (MATCH (opcode, j_insn_32)
12402 || MATCH (opcode, bc_insn_32)
12403 /* BC1F, BC1T, BC2F, BC2T */
12404 || (MATCH (opcode, jal_x_insn_32_bd32) && reg != RA)
12406 || (MATCH (opcode, bz_insn_32) && reg != OP32_SREG (opcode))
12407 /* BGEZ, BGTZ, BLEZ, BLTZ */
12408 || (MATCH (opcode, bzal_insn_32)
12409 /* BGEZAL, BLTZAL */
12410 && reg != OP32_SREG (opcode) && reg != RA)
12411 || ((MATCH (opcode, jalr_insn_32) || MATCH (opcode, beq_insn_32))
12412 /* JALR, JALR.HB, BEQ, BNE */
12413 && reg != OP32_SREG (opcode) && reg != OP32_TREG (opcode)))
12419 /* If the instruction encoding at PTR and relocations [INTERNAL_RELOCS,
12420 IRELEND) at OFFSET indicate that there must be a compact branch there,
12421 then return TRUE, otherwise FALSE. */
12424 check_relocated_bzc (bfd *abfd, const bfd_byte *ptr, bfd_vma offset,
12425 const Elf_Internal_Rela *internal_relocs,
12426 const Elf_Internal_Rela *irelend)
12428 const Elf_Internal_Rela *irel;
12429 unsigned long opcode;
12431 opcode = bfd_get_micromips_32 (abfd, ptr);
12432 if (find_match (opcode, bzc_insns_32) < 0)
12435 for (irel = internal_relocs; irel < irelend; irel++)
12436 if (irel->r_offset == offset
12437 && ELF32_R_TYPE (irel->r_info) == R_MICROMIPS_PC16_S1)
12443 /* Bitsize checking. */
12444 #define IS_BITSIZE(val, N) \
12445 (((((val) & ((1ULL << (N)) - 1)) ^ (1ULL << ((N) - 1))) \
12446 - (1ULL << ((N) - 1))) == (val))
12450 _bfd_mips_elf_relax_section (bfd *abfd, asection *sec,
12451 struct bfd_link_info *link_info,
12452 bfd_boolean *again)
12454 Elf_Internal_Shdr *symtab_hdr;
12455 Elf_Internal_Rela *internal_relocs;
12456 Elf_Internal_Rela *irel, *irelend;
12457 bfd_byte *contents = NULL;
12458 Elf_Internal_Sym *isymbuf = NULL;
12460 /* Assume nothing changes. */
12463 /* We don't have to do anything for a relocatable link, if
12464 this section does not have relocs, or if this is not a
12467 if (link_info->relocatable
12468 || (sec->flags & SEC_RELOC) == 0
12469 || sec->reloc_count == 0
12470 || (sec->flags & SEC_CODE) == 0)
12473 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
12475 /* Get a copy of the native relocations. */
12476 internal_relocs = (_bfd_elf_link_read_relocs
12477 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
12478 link_info->keep_memory));
12479 if (internal_relocs == NULL)
12482 /* Walk through them looking for relaxing opportunities. */
12483 irelend = internal_relocs + sec->reloc_count;
12484 for (irel = internal_relocs; irel < irelend; irel++)
12486 unsigned long r_symndx = ELF32_R_SYM (irel->r_info);
12487 unsigned int r_type = ELF32_R_TYPE (irel->r_info);
12488 bfd_boolean target_is_micromips_code_p;
12489 unsigned long opcode;
12495 /* The number of bytes to delete for relaxation and from where
12496 to delete these bytes starting at irel->r_offset. */
12500 /* If this isn't something that can be relaxed, then ignore
12502 if (r_type != R_MICROMIPS_HI16
12503 && r_type != R_MICROMIPS_PC16_S1
12504 && r_type != R_MICROMIPS_26_S1)
12507 /* Get the section contents if we haven't done so already. */
12508 if (contents == NULL)
12510 /* Get cached copy if it exists. */
12511 if (elf_section_data (sec)->this_hdr.contents != NULL)
12512 contents = elf_section_data (sec)->this_hdr.contents;
12513 /* Go get them off disk. */
12514 else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
12517 ptr = contents + irel->r_offset;
12519 /* Read this BFD's local symbols if we haven't done so already. */
12520 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
12522 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
12523 if (isymbuf == NULL)
12524 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
12525 symtab_hdr->sh_info, 0,
12527 if (isymbuf == NULL)
12531 /* Get the value of the symbol referred to by the reloc. */
12532 if (r_symndx < symtab_hdr->sh_info)
12534 /* A local symbol. */
12535 Elf_Internal_Sym *isym;
12538 isym = isymbuf + r_symndx;
12539 if (isym->st_shndx == SHN_UNDEF)
12540 sym_sec = bfd_und_section_ptr;
12541 else if (isym->st_shndx == SHN_ABS)
12542 sym_sec = bfd_abs_section_ptr;
12543 else if (isym->st_shndx == SHN_COMMON)
12544 sym_sec = bfd_com_section_ptr;
12546 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
12547 symval = (isym->st_value
12548 + sym_sec->output_section->vma
12549 + sym_sec->output_offset);
12550 target_is_micromips_code_p = ELF_ST_IS_MICROMIPS (isym->st_other);
12554 unsigned long indx;
12555 struct elf_link_hash_entry *h;
12557 /* An external symbol. */
12558 indx = r_symndx - symtab_hdr->sh_info;
12559 h = elf_sym_hashes (abfd)[indx];
12560 BFD_ASSERT (h != NULL);
12562 if (h->root.type != bfd_link_hash_defined
12563 && h->root.type != bfd_link_hash_defweak)
12564 /* This appears to be a reference to an undefined
12565 symbol. Just ignore it -- it will be caught by the
12566 regular reloc processing. */
12569 symval = (h->root.u.def.value
12570 + h->root.u.def.section->output_section->vma
12571 + h->root.u.def.section->output_offset);
12572 target_is_micromips_code_p = (!h->needs_plt
12573 && ELF_ST_IS_MICROMIPS (h->other));
12577 /* For simplicity of coding, we are going to modify the
12578 section contents, the section relocs, and the BFD symbol
12579 table. We must tell the rest of the code not to free up this
12580 information. It would be possible to instead create a table
12581 of changes which have to be made, as is done in coff-mips.c;
12582 that would be more work, but would require less memory when
12583 the linker is run. */
12585 /* Only 32-bit instructions relaxed. */
12586 if (irel->r_offset + 4 > sec->size)
12589 opcode = bfd_get_micromips_32 (abfd, ptr);
12591 /* This is the pc-relative distance from the instruction the
12592 relocation is applied to, to the symbol referred. */
12594 - (sec->output_section->vma + sec->output_offset)
12597 /* R_MICROMIPS_HI16 / LUI relaxation to nil, performing relaxation
12598 of corresponding R_MICROMIPS_LO16 to R_MICROMIPS_HI0_LO16 or
12599 R_MICROMIPS_PC23_S2. The R_MICROMIPS_PC23_S2 condition is
12601 (symval % 4 == 0 && IS_BITSIZE (pcrval, 25))
12603 where pcrval has first to be adjusted to apply against the LO16
12604 location (we make the adjustment later on, when we have figured
12605 out the offset). */
12606 if (r_type == R_MICROMIPS_HI16 && MATCH (opcode, lui_insn))
12608 bfd_boolean bzc = FALSE;
12609 unsigned long nextopc;
12613 /* Give up if the previous reloc was a HI16 against this symbol
12615 if (irel > internal_relocs
12616 && ELF32_R_TYPE (irel[-1].r_info) == R_MICROMIPS_HI16
12617 && ELF32_R_SYM (irel[-1].r_info) == r_symndx)
12620 /* Or if the next reloc is not a LO16 against this symbol. */
12621 if (irel + 1 >= irelend
12622 || ELF32_R_TYPE (irel[1].r_info) != R_MICROMIPS_LO16
12623 || ELF32_R_SYM (irel[1].r_info) != r_symndx)
12626 /* Or if the second next reloc is a LO16 against this symbol too. */
12627 if (irel + 2 >= irelend
12628 && ELF32_R_TYPE (irel[2].r_info) == R_MICROMIPS_LO16
12629 && ELF32_R_SYM (irel[2].r_info) == r_symndx)
12632 /* See if the LUI instruction *might* be in a branch delay slot.
12633 We check whether what looks like a 16-bit branch or jump is
12634 actually an immediate argument to a compact branch, and let
12635 it through if so. */
12636 if (irel->r_offset >= 2
12637 && check_br16_dslot (abfd, ptr - 2)
12638 && !(irel->r_offset >= 4
12639 && (bzc = check_relocated_bzc (abfd,
12640 ptr - 4, irel->r_offset - 4,
12641 internal_relocs, irelend))))
12643 if (irel->r_offset >= 4
12645 && check_br32_dslot (abfd, ptr - 4))
12648 reg = OP32_SREG (opcode);
12650 /* We only relax adjacent instructions or ones separated with
12651 a branch or jump that has a delay slot. The branch or jump
12652 must not fiddle with the register used to hold the address.
12653 Subtract 4 for the LUI itself. */
12654 offset = irel[1].r_offset - irel[0].r_offset;
12655 switch (offset - 4)
12660 if (check_br16 (abfd, ptr + 4, reg))
12664 if (check_br32 (abfd, ptr + 4, reg))
12671 nextopc = bfd_get_micromips_32 (abfd, contents + irel[1].r_offset);
12673 /* Give up unless the same register is used with both
12675 if (OP32_SREG (nextopc) != reg)
12678 /* Now adjust pcrval, subtracting the offset to the LO16 reloc
12679 and rounding up to take masking of the two LSBs into account. */
12680 pcrval = ((pcrval - offset + 3) | 3) ^ 3;
12682 /* R_MICROMIPS_LO16 relaxation to R_MICROMIPS_HI0_LO16. */
12683 if (IS_BITSIZE (symval, 16))
12685 /* Fix the relocation's type. */
12686 irel[1].r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_HI0_LO16);
12688 /* Instructions using R_MICROMIPS_LO16 have the base or
12689 source register in bits 20:16. This register becomes $0
12690 (zero) as the result of the R_MICROMIPS_HI16 being 0. */
12691 nextopc &= ~0x001f0000;
12692 bfd_put_16 (abfd, (nextopc >> 16) & 0xffff,
12693 contents + irel[1].r_offset);
12696 /* R_MICROMIPS_LO16 / ADDIU relaxation to R_MICROMIPS_PC23_S2.
12697 We add 4 to take LUI deletion into account while checking
12698 the PC-relative distance. */
12699 else if (symval % 4 == 0
12700 && IS_BITSIZE (pcrval + 4, 25)
12701 && MATCH (nextopc, addiu_insn)
12702 && OP32_TREG (nextopc) == OP32_SREG (nextopc)
12703 && OP16_VALID_REG (OP32_TREG (nextopc)))
12705 /* Fix the relocation's type. */
12706 irel[1].r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC23_S2);
12708 /* Replace ADDIU with the ADDIUPC version. */
12709 nextopc = (addiupc_insn.match
12710 | ADDIUPC_REG_FIELD (OP32_TREG (nextopc)));
12712 bfd_put_micromips_32 (abfd, nextopc,
12713 contents + irel[1].r_offset);
12716 /* Can't do anything, give up, sigh... */
12720 /* Fix the relocation's type. */
12721 irel->r_info = ELF32_R_INFO (r_symndx, R_MIPS_NONE);
12723 /* Delete the LUI instruction: 4 bytes at irel->r_offset. */
12728 /* Compact branch relaxation -- due to the multitude of macros
12729 employed by the compiler/assembler, compact branches are not
12730 always generated. Obviously, this can/will be fixed elsewhere,
12731 but there is no drawback in double checking it here. */
12732 else if (r_type == R_MICROMIPS_PC16_S1
12733 && irel->r_offset + 5 < sec->size
12734 && ((fndopc = find_match (opcode, bz_rs_insns_32)) >= 0
12735 || (fndopc = find_match (opcode, bz_rt_insns_32)) >= 0)
12736 && MATCH (bfd_get_16 (abfd, ptr + 4), nop_insn_16))
12740 reg = OP32_SREG (opcode) ? OP32_SREG (opcode) : OP32_TREG (opcode);
12742 /* Replace BEQZ/BNEZ with the compact version. */
12743 opcode = (bzc_insns_32[fndopc].match
12744 | BZC32_REG_FIELD (reg)
12745 | (opcode & 0xffff)); /* Addend value. */
12747 bfd_put_micromips_32 (abfd, opcode, ptr);
12749 /* Delete the 16-bit delay slot NOP: two bytes from
12750 irel->offset + 4. */
12755 /* R_MICROMIPS_PC16_S1 relaxation to R_MICROMIPS_PC10_S1. We need
12756 to check the distance from the next instruction, so subtract 2. */
12757 else if (r_type == R_MICROMIPS_PC16_S1
12758 && IS_BITSIZE (pcrval - 2, 11)
12759 && find_match (opcode, b_insns_32) >= 0)
12761 /* Fix the relocation's type. */
12762 irel->r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC10_S1);
12764 /* Replace the the 32-bit opcode with a 16-bit opcode. */
12767 | (opcode & 0x3ff)), /* Addend value. */
12770 /* Delete 2 bytes from irel->r_offset + 2. */
12775 /* R_MICROMIPS_PC16_S1 relaxation to R_MICROMIPS_PC7_S1. We need
12776 to check the distance from the next instruction, so subtract 2. */
12777 else if (r_type == R_MICROMIPS_PC16_S1
12778 && IS_BITSIZE (pcrval - 2, 8)
12779 && (((fndopc = find_match (opcode, bz_rs_insns_32)) >= 0
12780 && OP16_VALID_REG (OP32_SREG (opcode)))
12781 || ((fndopc = find_match (opcode, bz_rt_insns_32)) >= 0
12782 && OP16_VALID_REG (OP32_TREG (opcode)))))
12786 reg = OP32_SREG (opcode) ? OP32_SREG (opcode) : OP32_TREG (opcode);
12788 /* Fix the relocation's type. */
12789 irel->r_info = ELF32_R_INFO (r_symndx, R_MICROMIPS_PC7_S1);
12791 /* Replace the the 32-bit opcode with a 16-bit opcode. */
12793 (bz_insns_16[fndopc].match
12794 | BZ16_REG_FIELD (reg)
12795 | (opcode & 0x7f)), /* Addend value. */
12798 /* Delete 2 bytes from irel->r_offset + 2. */
12803 /* R_MICROMIPS_26_S1 -- JAL to JALS relaxation for microMIPS targets. */
12804 else if (r_type == R_MICROMIPS_26_S1
12805 && target_is_micromips_code_p
12806 && irel->r_offset + 7 < sec->size
12807 && MATCH (opcode, jal_insn_32_bd32))
12809 unsigned long n32opc;
12810 bfd_boolean relaxed = FALSE;
12812 n32opc = bfd_get_micromips_32 (abfd, ptr + 4);
12814 if (MATCH (n32opc, nop_insn_32))
12816 /* Replace delay slot 32-bit NOP with a 16-bit NOP. */
12817 bfd_put_16 (abfd, nop_insn_16.match, ptr + 4);
12821 else if (find_match (n32opc, move_insns_32) >= 0)
12823 /* Replace delay slot 32-bit MOVE with 16-bit MOVE. */
12825 (move_insn_16.match
12826 | MOVE16_RD_FIELD (MOVE32_RD (n32opc))
12827 | MOVE16_RS_FIELD (MOVE32_RS (n32opc))),
12832 /* Other 32-bit instructions relaxable to 16-bit
12833 instructions will be handled here later. */
12837 /* JAL with 32-bit delay slot that is changed to a JALS
12838 with 16-bit delay slot. */
12839 bfd_put_micromips_32 (abfd, jal_insn_32_bd16.match, ptr);
12841 /* Delete 2 bytes from irel->r_offset + 6. */
12849 /* Note that we've changed the relocs, section contents, etc. */
12850 elf_section_data (sec)->relocs = internal_relocs;
12851 elf_section_data (sec)->this_hdr.contents = contents;
12852 symtab_hdr->contents = (unsigned char *) isymbuf;
12854 /* Delete bytes depending on the delcnt and deloff. */
12855 if (!mips_elf_relax_delete_bytes (abfd, sec,
12856 irel->r_offset + deloff, delcnt))
12859 /* That will change things, so we should relax again.
12860 Note that this is not required, and it may be slow. */
12865 if (isymbuf != NULL
12866 && symtab_hdr->contents != (unsigned char *) isymbuf)
12868 if (! link_info->keep_memory)
12872 /* Cache the symbols for elf_link_input_bfd. */
12873 symtab_hdr->contents = (unsigned char *) isymbuf;
12877 if (contents != NULL
12878 && elf_section_data (sec)->this_hdr.contents != contents)
12880 if (! link_info->keep_memory)
12884 /* Cache the section contents for elf_link_input_bfd. */
12885 elf_section_data (sec)->this_hdr.contents = contents;
12889 if (internal_relocs != NULL
12890 && elf_section_data (sec)->relocs != internal_relocs)
12891 free (internal_relocs);
12896 if (isymbuf != NULL
12897 && symtab_hdr->contents != (unsigned char *) isymbuf)
12899 if (contents != NULL
12900 && elf_section_data (sec)->this_hdr.contents != contents)
12902 if (internal_relocs != NULL
12903 && elf_section_data (sec)->relocs != internal_relocs)
12904 free (internal_relocs);
12909 /* Create a MIPS ELF linker hash table. */
12911 struct bfd_link_hash_table *
12912 _bfd_mips_elf_link_hash_table_create (bfd *abfd)
12914 struct mips_elf_link_hash_table *ret;
12915 bfd_size_type amt = sizeof (struct mips_elf_link_hash_table);
12917 ret = bfd_malloc (amt);
12921 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
12922 mips_elf_link_hash_newfunc,
12923 sizeof (struct mips_elf_link_hash_entry),
12931 /* We no longer use this. */
12932 for (i = 0; i < SIZEOF_MIPS_DYNSYM_SECNAMES; i++)
12933 ret->dynsym_sec_strindex[i] = (bfd_size_type) -1;
12935 ret->procedure_count = 0;
12936 ret->compact_rel_size = 0;
12937 ret->use_rld_obj_head = FALSE;
12938 ret->rld_symbol = NULL;
12939 ret->mips16_stubs_seen = FALSE;
12940 ret->use_plts_and_copy_relocs = FALSE;
12941 ret->is_vxworks = FALSE;
12942 ret->small_data_overflow_reported = FALSE;
12943 ret->srelbss = NULL;
12944 ret->sdynbss = NULL;
12945 ret->srelplt = NULL;
12946 ret->srelplt2 = NULL;
12947 ret->sgotplt = NULL;
12949 ret->sstubs = NULL;
12951 ret->got_info = NULL;
12952 ret->plt_header_size = 0;
12953 ret->plt_entry_size = 0;
12954 ret->lazy_stub_count = 0;
12955 ret->function_stub_size = 0;
12956 ret->strampoline = NULL;
12957 ret->la25_stubs = NULL;
12958 ret->add_stub_section = NULL;
12960 return &ret->root.root;
12963 /* Likewise, but indicate that the target is VxWorks. */
12965 struct bfd_link_hash_table *
12966 _bfd_mips_vxworks_link_hash_table_create (bfd *abfd)
12968 struct bfd_link_hash_table *ret;
12970 ret = _bfd_mips_elf_link_hash_table_create (abfd);
12973 struct mips_elf_link_hash_table *htab;
12975 htab = (struct mips_elf_link_hash_table *) ret;
12976 htab->use_plts_and_copy_relocs = TRUE;
12977 htab->is_vxworks = TRUE;
12982 /* A function that the linker calls if we are allowed to use PLTs
12983 and copy relocs. */
12986 _bfd_mips_elf_use_plts_and_copy_relocs (struct bfd_link_info *info)
12988 mips_elf_hash_table (info)->use_plts_and_copy_relocs = TRUE;
12991 /* We need to use a special link routine to handle the .reginfo and
12992 the .mdebug sections. We need to merge all instances of these
12993 sections together, not write them all out sequentially. */
12996 _bfd_mips_elf_final_link (bfd *abfd, struct bfd_link_info *info)
12999 struct bfd_link_order *p;
13000 asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
13001 asection *rtproc_sec;
13002 Elf32_RegInfo reginfo;
13003 struct ecoff_debug_info debug;
13004 struct mips_htab_traverse_info hti;
13005 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
13006 const struct ecoff_debug_swap *swap = bed->elf_backend_ecoff_debug_swap;
13007 HDRR *symhdr = &debug.symbolic_header;
13008 void *mdebug_handle = NULL;
13013 struct mips_elf_link_hash_table *htab;
13015 static const char * const secname[] =
13017 ".text", ".init", ".fini", ".data",
13018 ".rodata", ".sdata", ".sbss", ".bss"
13020 static const int sc[] =
13022 scText, scInit, scFini, scData,
13023 scRData, scSData, scSBss, scBss
13026 /* Sort the dynamic symbols so that those with GOT entries come after
13028 htab = mips_elf_hash_table (info);
13029 BFD_ASSERT (htab != NULL);
13031 if (!mips_elf_sort_hash_table (abfd, info))
13034 /* Create any scheduled LA25 stubs. */
13036 hti.output_bfd = abfd;
13038 htab_traverse (htab->la25_stubs, mips_elf_create_la25_stub, &hti);
13042 /* Get a value for the GP register. */
13043 if (elf_gp (abfd) == 0)
13045 struct bfd_link_hash_entry *h;
13047 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
13048 if (h != NULL && h->type == bfd_link_hash_defined)
13049 elf_gp (abfd) = (h->u.def.value
13050 + h->u.def.section->output_section->vma
13051 + h->u.def.section->output_offset);
13052 else if (htab->is_vxworks
13053 && (h = bfd_link_hash_lookup (info->hash,
13054 "_GLOBAL_OFFSET_TABLE_",
13055 FALSE, FALSE, TRUE))
13056 && h->type == bfd_link_hash_defined)
13057 elf_gp (abfd) = (h->u.def.section->output_section->vma
13058 + h->u.def.section->output_offset
13060 else if (info->relocatable)
13062 bfd_vma lo = MINUS_ONE;
13064 /* Find the GP-relative section with the lowest offset. */
13065 for (o = abfd->sections; o != NULL; o = o->next)
13067 && (elf_section_data (o)->this_hdr.sh_flags & SHF_MIPS_GPREL))
13070 /* And calculate GP relative to that. */
13071 elf_gp (abfd) = lo + ELF_MIPS_GP_OFFSET (info);
13075 /* If the relocate_section function needs to do a reloc
13076 involving the GP value, it should make a reloc_dangerous
13077 callback to warn that GP is not defined. */
13081 /* Go through the sections and collect the .reginfo and .mdebug
13083 reginfo_sec = NULL;
13085 gptab_data_sec = NULL;
13086 gptab_bss_sec = NULL;
13087 for (o = abfd->sections; o != NULL; o = o->next)
13089 if (strcmp (o->name, ".reginfo") == 0)
13091 memset (®info, 0, sizeof reginfo);
13093 /* We have found the .reginfo section in the output file.
13094 Look through all the link_orders comprising it and merge
13095 the information together. */
13096 for (p = o->map_head.link_order; p != NULL; p = p->next)
13098 asection *input_section;
13100 Elf32_External_RegInfo ext;
13103 if (p->type != bfd_indirect_link_order)
13105 if (p->type == bfd_data_link_order)
13110 input_section = p->u.indirect.section;
13111 input_bfd = input_section->owner;
13113 if (! bfd_get_section_contents (input_bfd, input_section,
13114 &ext, 0, sizeof ext))
13117 bfd_mips_elf32_swap_reginfo_in (input_bfd, &ext, &sub);
13119 reginfo.ri_gprmask |= sub.ri_gprmask;
13120 reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
13121 reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
13122 reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
13123 reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
13125 /* ri_gp_value is set by the function
13126 mips_elf32_section_processing when the section is
13127 finally written out. */
13129 /* Hack: reset the SEC_HAS_CONTENTS flag so that
13130 elf_link_input_bfd ignores this section. */
13131 input_section->flags &= ~SEC_HAS_CONTENTS;
13134 /* Size has been set in _bfd_mips_elf_always_size_sections. */
13135 BFD_ASSERT(o->size == sizeof (Elf32_External_RegInfo));
13137 /* Skip this section later on (I don't think this currently
13138 matters, but someday it might). */
13139 o->map_head.link_order = NULL;
13144 if (strcmp (o->name, ".mdebug") == 0)
13146 struct extsym_info einfo;
13149 /* We have found the .mdebug section in the output file.
13150 Look through all the link_orders comprising it and merge
13151 the information together. */
13152 symhdr->magic = swap->sym_magic;
13153 /* FIXME: What should the version stamp be? */
13154 symhdr->vstamp = 0;
13155 symhdr->ilineMax = 0;
13156 symhdr->cbLine = 0;
13157 symhdr->idnMax = 0;
13158 symhdr->ipdMax = 0;
13159 symhdr->isymMax = 0;
13160 symhdr->ioptMax = 0;
13161 symhdr->iauxMax = 0;
13162 symhdr->issMax = 0;
13163 symhdr->issExtMax = 0;
13164 symhdr->ifdMax = 0;
13166 symhdr->iextMax = 0;
13168 /* We accumulate the debugging information itself in the
13169 debug_info structure. */
13171 debug.external_dnr = NULL;
13172 debug.external_pdr = NULL;
13173 debug.external_sym = NULL;
13174 debug.external_opt = NULL;
13175 debug.external_aux = NULL;
13177 debug.ssext = debug.ssext_end = NULL;
13178 debug.external_fdr = NULL;
13179 debug.external_rfd = NULL;
13180 debug.external_ext = debug.external_ext_end = NULL;
13182 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
13183 if (mdebug_handle == NULL)
13187 esym.cobol_main = 0;
13191 esym.asym.iss = issNil;
13192 esym.asym.st = stLocal;
13193 esym.asym.reserved = 0;
13194 esym.asym.index = indexNil;
13196 for (i = 0; i < sizeof (secname) / sizeof (secname[0]); i++)
13198 esym.asym.sc = sc[i];
13199 s = bfd_get_section_by_name (abfd, secname[i]);
13202 esym.asym.value = s->vma;
13203 last = s->vma + s->size;
13206 esym.asym.value = last;
13207 if (!bfd_ecoff_debug_one_external (abfd, &debug, swap,
13208 secname[i], &esym))
13212 for (p = o->map_head.link_order; p != NULL; p = p->next)
13214 asection *input_section;
13216 const struct ecoff_debug_swap *input_swap;
13217 struct ecoff_debug_info input_debug;
13221 if (p->type != bfd_indirect_link_order)
13223 if (p->type == bfd_data_link_order)
13228 input_section = p->u.indirect.section;
13229 input_bfd = input_section->owner;
13231 if (!is_mips_elf (input_bfd))
13233 /* I don't know what a non MIPS ELF bfd would be
13234 doing with a .mdebug section, but I don't really
13235 want to deal with it. */
13239 input_swap = (get_elf_backend_data (input_bfd)
13240 ->elf_backend_ecoff_debug_swap);
13242 BFD_ASSERT (p->size == input_section->size);
13244 /* The ECOFF linking code expects that we have already
13245 read in the debugging information and set up an
13246 ecoff_debug_info structure, so we do that now. */
13247 if (! _bfd_mips_elf_read_ecoff_info (input_bfd, input_section,
13251 if (! (bfd_ecoff_debug_accumulate
13252 (mdebug_handle, abfd, &debug, swap, input_bfd,
13253 &input_debug, input_swap, info)))
13256 /* Loop through the external symbols. For each one with
13257 interesting information, try to find the symbol in
13258 the linker global hash table and save the information
13259 for the output external symbols. */
13260 eraw_src = input_debug.external_ext;
13261 eraw_end = (eraw_src
13262 + (input_debug.symbolic_header.iextMax
13263 * input_swap->external_ext_size));
13265 eraw_src < eraw_end;
13266 eraw_src += input_swap->external_ext_size)
13270 struct mips_elf_link_hash_entry *h;
13272 (*input_swap->swap_ext_in) (input_bfd, eraw_src, &ext);
13273 if (ext.asym.sc == scNil
13274 || ext.asym.sc == scUndefined
13275 || ext.asym.sc == scSUndefined)
13278 name = input_debug.ssext + ext.asym.iss;
13279 h = mips_elf_link_hash_lookup (mips_elf_hash_table (info),
13280 name, FALSE, FALSE, TRUE);
13281 if (h == NULL || h->esym.ifd != -2)
13286 BFD_ASSERT (ext.ifd
13287 < input_debug.symbolic_header.ifdMax);
13288 ext.ifd = input_debug.ifdmap[ext.ifd];
13294 /* Free up the information we just read. */
13295 free (input_debug.line);
13296 free (input_debug.external_dnr);
13297 free (input_debug.external_pdr);
13298 free (input_debug.external_sym);
13299 free (input_debug.external_opt);
13300 free (input_debug.external_aux);
13301 free (input_debug.ss);
13302 free (input_debug.ssext);
13303 free (input_debug.external_fdr);
13304 free (input_debug.external_rfd);
13305 free (input_debug.external_ext);
13307 /* Hack: reset the SEC_HAS_CONTENTS flag so that
13308 elf_link_input_bfd ignores this section. */
13309 input_section->flags &= ~SEC_HAS_CONTENTS;
13312 if (SGI_COMPAT (abfd) && info->shared)
13314 /* Create .rtproc section. */
13315 rtproc_sec = bfd_get_linker_section (abfd, ".rtproc");
13316 if (rtproc_sec == NULL)
13318 flagword flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
13319 | SEC_LINKER_CREATED | SEC_READONLY);
13321 rtproc_sec = bfd_make_section_anyway_with_flags (abfd,
13324 if (rtproc_sec == NULL
13325 || ! bfd_set_section_alignment (abfd, rtproc_sec, 4))
13329 if (! mips_elf_create_procedure_table (mdebug_handle, abfd,
13335 /* Build the external symbol information. */
13338 einfo.debug = &debug;
13340 einfo.failed = FALSE;
13341 mips_elf_link_hash_traverse (mips_elf_hash_table (info),
13342 mips_elf_output_extsym, &einfo);
13346 /* Set the size of the .mdebug section. */
13347 o->size = bfd_ecoff_debug_size (abfd, &debug, swap);
13349 /* Skip this section later on (I don't think this currently
13350 matters, but someday it might). */
13351 o->map_head.link_order = NULL;
13356 if (CONST_STRNEQ (o->name, ".gptab."))
13358 const char *subname;
13361 Elf32_External_gptab *ext_tab;
13364 /* The .gptab.sdata and .gptab.sbss sections hold
13365 information describing how the small data area would
13366 change depending upon the -G switch. These sections
13367 not used in executables files. */
13368 if (! info->relocatable)
13370 for (p = o->map_head.link_order; p != NULL; p = p->next)
13372 asection *input_section;
13374 if (p->type != bfd_indirect_link_order)
13376 if (p->type == bfd_data_link_order)
13381 input_section = p->u.indirect.section;
13383 /* Hack: reset the SEC_HAS_CONTENTS flag so that
13384 elf_link_input_bfd ignores this section. */
13385 input_section->flags &= ~SEC_HAS_CONTENTS;
13388 /* Skip this section later on (I don't think this
13389 currently matters, but someday it might). */
13390 o->map_head.link_order = NULL;
13392 /* Really remove the section. */
13393 bfd_section_list_remove (abfd, o);
13394 --abfd->section_count;
13399 /* There is one gptab for initialized data, and one for
13400 uninitialized data. */
13401 if (strcmp (o->name, ".gptab.sdata") == 0)
13402 gptab_data_sec = o;
13403 else if (strcmp (o->name, ".gptab.sbss") == 0)
13407 (*_bfd_error_handler)
13408 (_("%s: illegal section name `%s'"),
13409 bfd_get_filename (abfd), o->name);
13410 bfd_set_error (bfd_error_nonrepresentable_section);
13414 /* The linker script always combines .gptab.data and
13415 .gptab.sdata into .gptab.sdata, and likewise for
13416 .gptab.bss and .gptab.sbss. It is possible that there is
13417 no .sdata or .sbss section in the output file, in which
13418 case we must change the name of the output section. */
13419 subname = o->name + sizeof ".gptab" - 1;
13420 if (bfd_get_section_by_name (abfd, subname) == NULL)
13422 if (o == gptab_data_sec)
13423 o->name = ".gptab.data";
13425 o->name = ".gptab.bss";
13426 subname = o->name + sizeof ".gptab" - 1;
13427 BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
13430 /* Set up the first entry. */
13432 amt = c * sizeof (Elf32_gptab);
13433 tab = bfd_malloc (amt);
13436 tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
13437 tab[0].gt_header.gt_unused = 0;
13439 /* Combine the input sections. */
13440 for (p = o->map_head.link_order; p != NULL; p = p->next)
13442 asection *input_section;
13444 bfd_size_type size;
13445 unsigned long last;
13446 bfd_size_type gpentry;
13448 if (p->type != bfd_indirect_link_order)
13450 if (p->type == bfd_data_link_order)
13455 input_section = p->u.indirect.section;
13456 input_bfd = input_section->owner;
13458 /* Combine the gptab entries for this input section one
13459 by one. We know that the input gptab entries are
13460 sorted by ascending -G value. */
13461 size = input_section->size;
13463 for (gpentry = sizeof (Elf32_External_gptab);
13465 gpentry += sizeof (Elf32_External_gptab))
13467 Elf32_External_gptab ext_gptab;
13468 Elf32_gptab int_gptab;
13474 if (! (bfd_get_section_contents
13475 (input_bfd, input_section, &ext_gptab, gpentry,
13476 sizeof (Elf32_External_gptab))))
13482 bfd_mips_elf32_swap_gptab_in (input_bfd, &ext_gptab,
13484 val = int_gptab.gt_entry.gt_g_value;
13485 add = int_gptab.gt_entry.gt_bytes - last;
13488 for (look = 1; look < c; look++)
13490 if (tab[look].gt_entry.gt_g_value >= val)
13491 tab[look].gt_entry.gt_bytes += add;
13493 if (tab[look].gt_entry.gt_g_value == val)
13499 Elf32_gptab *new_tab;
13502 /* We need a new table entry. */
13503 amt = (bfd_size_type) (c + 1) * sizeof (Elf32_gptab);
13504 new_tab = bfd_realloc (tab, amt);
13505 if (new_tab == NULL)
13511 tab[c].gt_entry.gt_g_value = val;
13512 tab[c].gt_entry.gt_bytes = add;
13514 /* Merge in the size for the next smallest -G
13515 value, since that will be implied by this new
13518 for (look = 1; look < c; look++)
13520 if (tab[look].gt_entry.gt_g_value < val
13522 || (tab[look].gt_entry.gt_g_value
13523 > tab[max].gt_entry.gt_g_value)))
13527 tab[c].gt_entry.gt_bytes +=
13528 tab[max].gt_entry.gt_bytes;
13533 last = int_gptab.gt_entry.gt_bytes;
13536 /* Hack: reset the SEC_HAS_CONTENTS flag so that
13537 elf_link_input_bfd ignores this section. */
13538 input_section->flags &= ~SEC_HAS_CONTENTS;
13541 /* The table must be sorted by -G value. */
13543 qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
13545 /* Swap out the table. */
13546 amt = (bfd_size_type) c * sizeof (Elf32_External_gptab);
13547 ext_tab = bfd_alloc (abfd, amt);
13548 if (ext_tab == NULL)
13554 for (j = 0; j < c; j++)
13555 bfd_mips_elf32_swap_gptab_out (abfd, tab + j, ext_tab + j);
13558 o->size = c * sizeof (Elf32_External_gptab);
13559 o->contents = (bfd_byte *) ext_tab;
13561 /* Skip this section later on (I don't think this currently
13562 matters, but someday it might). */
13563 o->map_head.link_order = NULL;
13567 /* Invoke the regular ELF backend linker to do all the work. */
13568 if (!bfd_elf_final_link (abfd, info))
13571 /* Now write out the computed sections. */
13573 if (reginfo_sec != NULL)
13575 Elf32_External_RegInfo ext;
13577 bfd_mips_elf32_swap_reginfo_out (abfd, ®info, &ext);
13578 if (! bfd_set_section_contents (abfd, reginfo_sec, &ext, 0, sizeof ext))
13582 if (mdebug_sec != NULL)
13584 BFD_ASSERT (abfd->output_has_begun);
13585 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
13587 mdebug_sec->filepos))
13590 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
13593 if (gptab_data_sec != NULL)
13595 if (! bfd_set_section_contents (abfd, gptab_data_sec,
13596 gptab_data_sec->contents,
13597 0, gptab_data_sec->size))
13601 if (gptab_bss_sec != NULL)
13603 if (! bfd_set_section_contents (abfd, gptab_bss_sec,
13604 gptab_bss_sec->contents,
13605 0, gptab_bss_sec->size))
13609 if (SGI_COMPAT (abfd))
13611 rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
13612 if (rtproc_sec != NULL)
13614 if (! bfd_set_section_contents (abfd, rtproc_sec,
13615 rtproc_sec->contents,
13616 0, rtproc_sec->size))
13624 /* Structure for saying that BFD machine EXTENSION extends BASE. */
13626 struct mips_mach_extension {
13627 unsigned long extension, base;
13631 /* An array describing how BFD machines relate to one another. The entries
13632 are ordered topologically with MIPS I extensions listed last. */
13634 static const struct mips_mach_extension mips_mach_extensions[] = {
13635 /* MIPS64r2 extensions. */
13636 { bfd_mach_mips_octeon2, bfd_mach_mips_octeonp },
13637 { bfd_mach_mips_octeonp, bfd_mach_mips_octeon },
13638 { bfd_mach_mips_octeon, bfd_mach_mipsisa64r2 },
13640 /* MIPS64 extensions. */
13641 { bfd_mach_mipsisa64r2, bfd_mach_mipsisa64 },
13642 { bfd_mach_mips_sb1, bfd_mach_mipsisa64 },
13643 { bfd_mach_mips_xlr, bfd_mach_mipsisa64 },
13644 { bfd_mach_mips_loongson_3a, bfd_mach_mipsisa64 },
13646 /* MIPS V extensions. */
13647 { bfd_mach_mipsisa64, bfd_mach_mips5 },
13649 /* R10000 extensions. */
13650 { bfd_mach_mips12000, bfd_mach_mips10000 },
13651 { bfd_mach_mips14000, bfd_mach_mips10000 },
13652 { bfd_mach_mips16000, bfd_mach_mips10000 },
13654 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
13655 vr5400 ISA, but doesn't include the multimedia stuff. It seems
13656 better to allow vr5400 and vr5500 code to be merged anyway, since
13657 many libraries will just use the core ISA. Perhaps we could add
13658 some sort of ASE flag if this ever proves a problem. */
13659 { bfd_mach_mips5500, bfd_mach_mips5400 },
13660 { bfd_mach_mips5400, bfd_mach_mips5000 },
13662 /* MIPS IV extensions. */
13663 { bfd_mach_mips5, bfd_mach_mips8000 },
13664 { bfd_mach_mips10000, bfd_mach_mips8000 },
13665 { bfd_mach_mips5000, bfd_mach_mips8000 },
13666 { bfd_mach_mips7000, bfd_mach_mips8000 },
13667 { bfd_mach_mips9000, bfd_mach_mips8000 },
13669 /* VR4100 extensions. */
13670 { bfd_mach_mips4120, bfd_mach_mips4100 },
13671 { bfd_mach_mips4111, bfd_mach_mips4100 },
13673 /* MIPS III extensions. */
13674 { bfd_mach_mips_loongson_2e, bfd_mach_mips4000 },
13675 { bfd_mach_mips_loongson_2f, bfd_mach_mips4000 },
13676 { bfd_mach_mips8000, bfd_mach_mips4000 },
13677 { bfd_mach_mips4650, bfd_mach_mips4000 },
13678 { bfd_mach_mips4600, bfd_mach_mips4000 },
13679 { bfd_mach_mips4400, bfd_mach_mips4000 },
13680 { bfd_mach_mips4300, bfd_mach_mips4000 },
13681 { bfd_mach_mips4100, bfd_mach_mips4000 },
13682 { bfd_mach_mips4010, bfd_mach_mips4000 },
13684 /* MIPS32 extensions. */
13685 { bfd_mach_mipsisa32r2, bfd_mach_mipsisa32 },
13687 /* MIPS II extensions. */
13688 { bfd_mach_mips4000, bfd_mach_mips6000 },
13689 { bfd_mach_mipsisa32, bfd_mach_mips6000 },
13691 /* MIPS I extensions. */
13692 { bfd_mach_mips6000, bfd_mach_mips3000 },
13693 { bfd_mach_mips3900, bfd_mach_mips3000 }
13697 /* Return true if bfd machine EXTENSION is an extension of machine BASE. */
13700 mips_mach_extends_p (unsigned long base, unsigned long extension)
13704 if (extension == base)
13707 if (base == bfd_mach_mipsisa32
13708 && mips_mach_extends_p (bfd_mach_mipsisa64, extension))
13711 if (base == bfd_mach_mipsisa32r2
13712 && mips_mach_extends_p (bfd_mach_mipsisa64r2, extension))
13715 for (i = 0; i < ARRAY_SIZE (mips_mach_extensions); i++)
13716 if (extension == mips_mach_extensions[i].extension)
13718 extension = mips_mach_extensions[i].base;
13719 if (extension == base)
13727 /* Return true if the given ELF header flags describe a 32-bit binary. */
13730 mips_32bit_flags_p (flagword flags)
13732 return ((flags & EF_MIPS_32BITMODE) != 0
13733 || (flags & EF_MIPS_ABI) == E_MIPS_ABI_O32
13734 || (flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32
13735 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1
13736 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2
13737 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32
13738 || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2);
13742 /* Merge object attributes from IBFD into OBFD. Raise an error if
13743 there are conflicting attributes. */
13745 mips_elf_merge_obj_attributes (bfd *ibfd, bfd *obfd)
13747 obj_attribute *in_attr;
13748 obj_attribute *out_attr;
13750 if (!elf_known_obj_attributes_proc (obfd)[0].i)
13752 /* This is the first object. Copy the attributes. */
13753 _bfd_elf_copy_obj_attributes (ibfd, obfd);
13755 /* Use the Tag_null value to indicate the attributes have been
13757 elf_known_obj_attributes_proc (obfd)[0].i = 1;
13762 /* Check for conflicting Tag_GNU_MIPS_ABI_FP attributes and merge
13763 non-conflicting ones. */
13764 in_attr = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
13765 out_attr = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
13766 if (in_attr[Tag_GNU_MIPS_ABI_FP].i != out_attr[Tag_GNU_MIPS_ABI_FP].i)
13768 out_attr[Tag_GNU_MIPS_ABI_FP].type = 1;
13769 if (out_attr[Tag_GNU_MIPS_ABI_FP].i == 0)
13770 out_attr[Tag_GNU_MIPS_ABI_FP].i = in_attr[Tag_GNU_MIPS_ABI_FP].i;
13771 else if (in_attr[Tag_GNU_MIPS_ABI_FP].i == 0)
13773 else if (in_attr[Tag_GNU_MIPS_ABI_FP].i > 4)
13775 (_("Warning: %B uses unknown floating point ABI %d"), ibfd,
13776 in_attr[Tag_GNU_MIPS_ABI_FP].i);
13777 else if (out_attr[Tag_GNU_MIPS_ABI_FP].i > 4)
13779 (_("Warning: %B uses unknown floating point ABI %d"), obfd,
13780 out_attr[Tag_GNU_MIPS_ABI_FP].i);
13782 switch (out_attr[Tag_GNU_MIPS_ABI_FP].i)
13785 switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
13789 (_("Warning: %B uses -msingle-float, %B uses -mdouble-float"),
13795 (_("Warning: %B uses hard float, %B uses soft float"),
13801 (_("Warning: %B uses -msingle-float, %B uses -mips32r2 -mfp64"),
13811 switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
13815 (_("Warning: %B uses -msingle-float, %B uses -mdouble-float"),
13821 (_("Warning: %B uses hard float, %B uses soft float"),
13827 (_("Warning: %B uses -mdouble-float, %B uses -mips32r2 -mfp64"),
13837 switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
13843 (_("Warning: %B uses hard float, %B uses soft float"),
13853 switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
13857 (_("Warning: %B uses -msingle-float, %B uses -mips32r2 -mfp64"),
13863 (_("Warning: %B uses -mdouble-float, %B uses -mips32r2 -mfp64"),
13869 (_("Warning: %B uses hard float, %B uses soft float"),
13883 /* Merge Tag_compatibility attributes and any common GNU ones. */
13884 _bfd_elf_merge_object_attributes (ibfd, obfd);
13889 /* Merge backend specific data from an object file to the output
13890 object file when linking. */
13893 _bfd_mips_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
13895 flagword old_flags;
13896 flagword new_flags;
13898 bfd_boolean null_input_bfd = TRUE;
13901 /* Check if we have the same endianness. */
13902 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
13904 (*_bfd_error_handler)
13905 (_("%B: endianness incompatible with that of the selected emulation"),
13910 if (!is_mips_elf (ibfd) || !is_mips_elf (obfd))
13913 if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
13915 (*_bfd_error_handler)
13916 (_("%B: ABI is incompatible with that of the selected emulation"),
13921 if (!mips_elf_merge_obj_attributes (ibfd, obfd))
13924 new_flags = elf_elfheader (ibfd)->e_flags;
13925 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_NOREORDER;
13926 old_flags = elf_elfheader (obfd)->e_flags;
13928 if (! elf_flags_init (obfd))
13930 elf_flags_init (obfd) = TRUE;
13931 elf_elfheader (obfd)->e_flags = new_flags;
13932 elf_elfheader (obfd)->e_ident[EI_CLASS]
13933 = elf_elfheader (ibfd)->e_ident[EI_CLASS];
13935 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
13936 && (bfd_get_arch_info (obfd)->the_default
13937 || mips_mach_extends_p (bfd_get_mach (obfd),
13938 bfd_get_mach (ibfd))))
13940 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
13941 bfd_get_mach (ibfd)))
13948 /* Check flag compatibility. */
13950 new_flags &= ~EF_MIPS_NOREORDER;
13951 old_flags &= ~EF_MIPS_NOREORDER;
13953 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
13954 doesn't seem to matter. */
13955 new_flags &= ~EF_MIPS_XGOT;
13956 old_flags &= ~EF_MIPS_XGOT;
13958 /* MIPSpro generates ucode info in n64 objects. Again, we should
13959 just be able to ignore this. */
13960 new_flags &= ~EF_MIPS_UCODE;
13961 old_flags &= ~EF_MIPS_UCODE;
13963 /* DSOs should only be linked with CPIC code. */
13964 if ((ibfd->flags & DYNAMIC) != 0)
13965 new_flags |= EF_MIPS_PIC | EF_MIPS_CPIC;
13967 if (new_flags == old_flags)
13970 /* Check to see if the input BFD actually contains any sections.
13971 If not, its flags may not have been initialised either, but it cannot
13972 actually cause any incompatibility. */
13973 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
13975 /* Ignore synthetic sections and empty .text, .data and .bss sections
13976 which are automatically generated by gas. Also ignore fake
13977 (s)common sections, since merely defining a common symbol does
13978 not affect compatibility. */
13979 if ((sec->flags & SEC_IS_COMMON) == 0
13980 && strcmp (sec->name, ".reginfo")
13981 && strcmp (sec->name, ".mdebug")
13983 || (strcmp (sec->name, ".text")
13984 && strcmp (sec->name, ".data")
13985 && strcmp (sec->name, ".bss"))))
13987 null_input_bfd = FALSE;
13991 if (null_input_bfd)
13996 if (((new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0)
13997 != ((old_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0))
13999 (*_bfd_error_handler)
14000 (_("%B: warning: linking abicalls files with non-abicalls files"),
14005 if (new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC))
14006 elf_elfheader (obfd)->e_flags |= EF_MIPS_CPIC;
14007 if (! (new_flags & EF_MIPS_PIC))
14008 elf_elfheader (obfd)->e_flags &= ~EF_MIPS_PIC;
14010 new_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
14011 old_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
14013 /* Compare the ISAs. */
14014 if (mips_32bit_flags_p (old_flags) != mips_32bit_flags_p (new_flags))
14016 (*_bfd_error_handler)
14017 (_("%B: linking 32-bit code with 64-bit code"),
14021 else if (!mips_mach_extends_p (bfd_get_mach (ibfd), bfd_get_mach (obfd)))
14023 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
14024 if (mips_mach_extends_p (bfd_get_mach (obfd), bfd_get_mach (ibfd)))
14026 /* Copy the architecture info from IBFD to OBFD. Also copy
14027 the 32-bit flag (if set) so that we continue to recognise
14028 OBFD as a 32-bit binary. */
14029 bfd_set_arch_info (obfd, bfd_get_arch_info (ibfd));
14030 elf_elfheader (obfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
14031 elf_elfheader (obfd)->e_flags
14032 |= new_flags & (EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
14034 /* Copy across the ABI flags if OBFD doesn't use them
14035 and if that was what caused us to treat IBFD as 32-bit. */
14036 if ((old_flags & EF_MIPS_ABI) == 0
14037 && mips_32bit_flags_p (new_flags)
14038 && !mips_32bit_flags_p (new_flags & ~EF_MIPS_ABI))
14039 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ABI;
14043 /* The ISAs aren't compatible. */
14044 (*_bfd_error_handler)
14045 (_("%B: linking %s module with previous %s modules"),
14047 bfd_printable_name (ibfd),
14048 bfd_printable_name (obfd));
14053 new_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
14054 old_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
14056 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
14057 does set EI_CLASS differently from any 32-bit ABI. */
14058 if ((new_flags & EF_MIPS_ABI) != (old_flags & EF_MIPS_ABI)
14059 || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
14060 != elf_elfheader (obfd)->e_ident[EI_CLASS]))
14062 /* Only error if both are set (to different values). */
14063 if (((new_flags & EF_MIPS_ABI) && (old_flags & EF_MIPS_ABI))
14064 || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
14065 != elf_elfheader (obfd)->e_ident[EI_CLASS]))
14067 (*_bfd_error_handler)
14068 (_("%B: ABI mismatch: linking %s module with previous %s modules"),
14070 elf_mips_abi_name (ibfd),
14071 elf_mips_abi_name (obfd));
14074 new_flags &= ~EF_MIPS_ABI;
14075 old_flags &= ~EF_MIPS_ABI;
14078 /* Compare ASEs. Forbid linking MIPS16 and microMIPS ASE modules together
14079 and allow arbitrary mixing of the remaining ASEs (retain the union). */
14080 if ((new_flags & EF_MIPS_ARCH_ASE) != (old_flags & EF_MIPS_ARCH_ASE))
14082 int old_micro = old_flags & EF_MIPS_ARCH_ASE_MICROMIPS;
14083 int new_micro = new_flags & EF_MIPS_ARCH_ASE_MICROMIPS;
14084 int old_m16 = old_flags & EF_MIPS_ARCH_ASE_M16;
14085 int new_m16 = new_flags & EF_MIPS_ARCH_ASE_M16;
14086 int micro_mis = old_m16 && new_micro;
14087 int m16_mis = old_micro && new_m16;
14089 if (m16_mis || micro_mis)
14091 (*_bfd_error_handler)
14092 (_("%B: ASE mismatch: linking %s module with previous %s modules"),
14094 m16_mis ? "MIPS16" : "microMIPS",
14095 m16_mis ? "microMIPS" : "MIPS16");
14099 elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ARCH_ASE;
14101 new_flags &= ~ EF_MIPS_ARCH_ASE;
14102 old_flags &= ~ EF_MIPS_ARCH_ASE;
14105 /* Warn about any other mismatches */
14106 if (new_flags != old_flags)
14108 (*_bfd_error_handler)
14109 (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
14110 ibfd, (unsigned long) new_flags,
14111 (unsigned long) old_flags);
14117 bfd_set_error (bfd_error_bad_value);
14124 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
14127 _bfd_mips_elf_set_private_flags (bfd *abfd, flagword flags)
14129 BFD_ASSERT (!elf_flags_init (abfd)
14130 || elf_elfheader (abfd)->e_flags == flags);
14132 elf_elfheader (abfd)->e_flags = flags;
14133 elf_flags_init (abfd) = TRUE;
14138 _bfd_mips_elf_get_target_dtag (bfd_vma dtag)
14142 default: return "";
14143 case DT_MIPS_RLD_VERSION:
14144 return "MIPS_RLD_VERSION";
14145 case DT_MIPS_TIME_STAMP:
14146 return "MIPS_TIME_STAMP";
14147 case DT_MIPS_ICHECKSUM:
14148 return "MIPS_ICHECKSUM";
14149 case DT_MIPS_IVERSION:
14150 return "MIPS_IVERSION";
14151 case DT_MIPS_FLAGS:
14152 return "MIPS_FLAGS";
14153 case DT_MIPS_BASE_ADDRESS:
14154 return "MIPS_BASE_ADDRESS";
14156 return "MIPS_MSYM";
14157 case DT_MIPS_CONFLICT:
14158 return "MIPS_CONFLICT";
14159 case DT_MIPS_LIBLIST:
14160 return "MIPS_LIBLIST";
14161 case DT_MIPS_LOCAL_GOTNO:
14162 return "MIPS_LOCAL_GOTNO";
14163 case DT_MIPS_CONFLICTNO:
14164 return "MIPS_CONFLICTNO";
14165 case DT_MIPS_LIBLISTNO:
14166 return "MIPS_LIBLISTNO";
14167 case DT_MIPS_SYMTABNO:
14168 return "MIPS_SYMTABNO";
14169 case DT_MIPS_UNREFEXTNO:
14170 return "MIPS_UNREFEXTNO";
14171 case DT_MIPS_GOTSYM:
14172 return "MIPS_GOTSYM";
14173 case DT_MIPS_HIPAGENO:
14174 return "MIPS_HIPAGENO";
14175 case DT_MIPS_RLD_MAP:
14176 return "MIPS_RLD_MAP";
14177 case DT_MIPS_DELTA_CLASS:
14178 return "MIPS_DELTA_CLASS";
14179 case DT_MIPS_DELTA_CLASS_NO:
14180 return "MIPS_DELTA_CLASS_NO";
14181 case DT_MIPS_DELTA_INSTANCE:
14182 return "MIPS_DELTA_INSTANCE";
14183 case DT_MIPS_DELTA_INSTANCE_NO:
14184 return "MIPS_DELTA_INSTANCE_NO";
14185 case DT_MIPS_DELTA_RELOC:
14186 return "MIPS_DELTA_RELOC";
14187 case DT_MIPS_DELTA_RELOC_NO:
14188 return "MIPS_DELTA_RELOC_NO";
14189 case DT_MIPS_DELTA_SYM:
14190 return "MIPS_DELTA_SYM";
14191 case DT_MIPS_DELTA_SYM_NO:
14192 return "MIPS_DELTA_SYM_NO";
14193 case DT_MIPS_DELTA_CLASSSYM:
14194 return "MIPS_DELTA_CLASSSYM";
14195 case DT_MIPS_DELTA_CLASSSYM_NO:
14196 return "MIPS_DELTA_CLASSSYM_NO";
14197 case DT_MIPS_CXX_FLAGS:
14198 return "MIPS_CXX_FLAGS";
14199 case DT_MIPS_PIXIE_INIT:
14200 return "MIPS_PIXIE_INIT";
14201 case DT_MIPS_SYMBOL_LIB:
14202 return "MIPS_SYMBOL_LIB";
14203 case DT_MIPS_LOCALPAGE_GOTIDX:
14204 return "MIPS_LOCALPAGE_GOTIDX";
14205 case DT_MIPS_LOCAL_GOTIDX:
14206 return "MIPS_LOCAL_GOTIDX";
14207 case DT_MIPS_HIDDEN_GOTIDX:
14208 return "MIPS_HIDDEN_GOTIDX";
14209 case DT_MIPS_PROTECTED_GOTIDX:
14210 return "MIPS_PROTECTED_GOT_IDX";
14211 case DT_MIPS_OPTIONS:
14212 return "MIPS_OPTIONS";
14213 case DT_MIPS_INTERFACE:
14214 return "MIPS_INTERFACE";
14215 case DT_MIPS_DYNSTR_ALIGN:
14216 return "DT_MIPS_DYNSTR_ALIGN";
14217 case DT_MIPS_INTERFACE_SIZE:
14218 return "DT_MIPS_INTERFACE_SIZE";
14219 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR:
14220 return "DT_MIPS_RLD_TEXT_RESOLVE_ADDR";
14221 case DT_MIPS_PERF_SUFFIX:
14222 return "DT_MIPS_PERF_SUFFIX";
14223 case DT_MIPS_COMPACT_SIZE:
14224 return "DT_MIPS_COMPACT_SIZE";
14225 case DT_MIPS_GP_VALUE:
14226 return "DT_MIPS_GP_VALUE";
14227 case DT_MIPS_AUX_DYNAMIC:
14228 return "DT_MIPS_AUX_DYNAMIC";
14229 case DT_MIPS_PLTGOT:
14230 return "DT_MIPS_PLTGOT";
14231 case DT_MIPS_RWPLT:
14232 return "DT_MIPS_RWPLT";
14237 _bfd_mips_elf_print_private_bfd_data (bfd *abfd, void *ptr)
14241 BFD_ASSERT (abfd != NULL && ptr != NULL);
14243 /* Print normal ELF private data. */
14244 _bfd_elf_print_private_bfd_data (abfd, ptr);
14246 /* xgettext:c-format */
14247 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
14249 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32)
14250 fprintf (file, _(" [abi=O32]"));
14251 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O64)
14252 fprintf (file, _(" [abi=O64]"));
14253 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32)
14254 fprintf (file, _(" [abi=EABI32]"));
14255 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
14256 fprintf (file, _(" [abi=EABI64]"));
14257 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI))
14258 fprintf (file, _(" [abi unknown]"));
14259 else if (ABI_N32_P (abfd))
14260 fprintf (file, _(" [abi=N32]"));
14261 else if (ABI_64_P (abfd))
14262 fprintf (file, _(" [abi=64]"));
14264 fprintf (file, _(" [no abi set]"));
14266 if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
14267 fprintf (file, " [mips1]");
14268 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
14269 fprintf (file, " [mips2]");
14270 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
14271 fprintf (file, " [mips3]");
14272 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
14273 fprintf (file, " [mips4]");
14274 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5)
14275 fprintf (file, " [mips5]");
14276 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32)
14277 fprintf (file, " [mips32]");
14278 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64)
14279 fprintf (file, " [mips64]");
14280 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2)
14281 fprintf (file, " [mips32r2]");
14282 else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R2)
14283 fprintf (file, " [mips64r2]");
14285 fprintf (file, _(" [unknown ISA]"));
14287 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MDMX)
14288 fprintf (file, " [mdmx]");
14290 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_M16)
14291 fprintf (file, " [mips16]");
14293 if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
14294 fprintf (file, " [micromips]");
14296 if (elf_elfheader (abfd)->e_flags & EF_MIPS_32BITMODE)
14297 fprintf (file, " [32bitmode]");
14299 fprintf (file, _(" [not 32bitmode]"));
14301 if (elf_elfheader (abfd)->e_flags & EF_MIPS_NOREORDER)
14302 fprintf (file, " [noreorder]");
14304 if (elf_elfheader (abfd)->e_flags & EF_MIPS_PIC)
14305 fprintf (file, " [PIC]");
14307 if (elf_elfheader (abfd)->e_flags & EF_MIPS_CPIC)
14308 fprintf (file, " [CPIC]");
14310 if (elf_elfheader (abfd)->e_flags & EF_MIPS_XGOT)
14311 fprintf (file, " [XGOT]");
14313 if (elf_elfheader (abfd)->e_flags & EF_MIPS_UCODE)
14314 fprintf (file, " [UCODE]");
14316 fputc ('\n', file);
14321 const struct bfd_elf_special_section _bfd_mips_elf_special_sections[] =
14323 { STRING_COMMA_LEN (".lit4"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
14324 { STRING_COMMA_LEN (".lit8"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
14325 { STRING_COMMA_LEN (".mdebug"), 0, SHT_MIPS_DEBUG, 0 },
14326 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
14327 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
14328 { STRING_COMMA_LEN (".ucode"), 0, SHT_MIPS_UCODE, 0 },
14329 { NULL, 0, 0, 0, 0 }
14332 /* Merge non visibility st_other attributes. Ensure that the
14333 STO_OPTIONAL flag is copied into h->other, even if this is not a
14334 definiton of the symbol. */
14336 _bfd_mips_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
14337 const Elf_Internal_Sym *isym,
14338 bfd_boolean definition,
14339 bfd_boolean dynamic ATTRIBUTE_UNUSED)
14341 if ((isym->st_other & ~ELF_ST_VISIBILITY (-1)) != 0)
14343 unsigned char other;
14345 other = (definition ? isym->st_other : h->other);
14346 other &= ~ELF_ST_VISIBILITY (-1);
14347 h->other = other | ELF_ST_VISIBILITY (h->other);
14351 && ELF_MIPS_IS_OPTIONAL (isym->st_other))
14352 h->other |= STO_OPTIONAL;
14355 /* Decide whether an undefined symbol is special and can be ignored.
14356 This is the case for OPTIONAL symbols on IRIX. */
14358 _bfd_mips_elf_ignore_undef_symbol (struct elf_link_hash_entry *h)
14360 return ELF_MIPS_IS_OPTIONAL (h->other) ? TRUE : FALSE;
14364 _bfd_mips_elf_common_definition (Elf_Internal_Sym *sym)
14366 return (sym->st_shndx == SHN_COMMON
14367 || sym->st_shndx == SHN_MIPS_ACOMMON
14368 || sym->st_shndx == SHN_MIPS_SCOMMON);
14371 /* Return address for Ith PLT stub in section PLT, for relocation REL
14372 or (bfd_vma) -1 if it should not be included. */
14375 _bfd_mips_elf_plt_sym_val (bfd_vma i, const asection *plt,
14376 const arelent *rel ATTRIBUTE_UNUSED)
14379 + 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry)
14380 + i * 4 * ARRAY_SIZE (mips_exec_plt_entry));
14384 _bfd_mips_post_process_headers (bfd *abfd, struct bfd_link_info *link_info)
14386 struct mips_elf_link_hash_table *htab;
14387 Elf_Internal_Ehdr *i_ehdrp;
14389 i_ehdrp = elf_elfheader (abfd);
14392 htab = mips_elf_hash_table (link_info);
14393 BFD_ASSERT (htab != NULL);
14395 if (htab->use_plts_and_copy_relocs && !htab->is_vxworks)
14396 i_ehdrp->e_ident[EI_ABIVERSION] = 1;