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 Free Software Foundation, Inc.
5 Most of the information added by Ian Lance Taylor, Cygnus Support,
7 N32/64 ABI support added by Mark Mitchell, CodeSourcery, LLC.
8 <mark@codesourcery.com>
9 Traditional MIPS targets support added by Koundinya.K, Dansk Data
10 Elektronik & Operations Research Group. <kk@ddeorg.soft.net>
12 This file is part of BFD, the Binary File Descriptor library.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 3 of the License, or
17 (at your option) any later version.
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
27 MA 02110-1301, USA. */
30 /* This file handles functionality common to the different MIPS ABI's. */
35 #include "libiberty.h"
37 #include "elfxx-mips.h"
39 #include "elf-vxworks.h"
41 /* Get the ECOFF swapping routines. */
43 #include "coff/symconst.h"
44 #include "coff/ecoff.h"
45 #include "coff/mips.h"
49 /* This structure is used to hold information about one GOT entry.
50 There are three types of entry:
52 (1) absolute addresses
54 (2) SYMBOL + OFFSET addresses, where SYMBOL is local to an input bfd
55 (abfd != NULL, symndx >= 0)
56 (3) global and forced-local symbols
57 (abfd != NULL, symndx == -1)
59 Type (3) entries are treated differently for different types of GOT.
60 In the "master" GOT -- i.e. the one that describes every GOT
61 reference needed in the link -- the mips_got_entry is keyed on both
62 the symbol and the input bfd that references it. If it turns out
63 that we need multiple GOTs, we can then use this information to
64 create separate GOTs for each input bfd.
66 However, we want each of these separate GOTs to have at most one
67 entry for a given symbol, so their type (3) entries are keyed only
68 on the symbol. The input bfd given by the "abfd" field is somewhat
69 arbitrary in this case.
71 This means that when there are multiple GOTs, each GOT has a unique
72 mips_got_entry for every symbol within it. We can therefore use the
73 mips_got_entry fields (tls_type and gotidx) to track the symbol's
76 However, if it turns out that we need only a single GOT, we continue
77 to use the master GOT to describe it. There may therefore be several
78 mips_got_entries for the same symbol, each with a different input bfd.
79 We want to make sure that each symbol gets a unique GOT entry, so when
80 there's a single GOT, we use the symbol's hash entry, not the
81 mips_got_entry fields, to track a symbol's GOT index. */
84 /* The input bfd in which the symbol is defined. */
86 /* The index of the symbol, as stored in the relocation r_info, if
87 we have a local symbol; -1 otherwise. */
91 /* If abfd == NULL, an address that must be stored in the got. */
93 /* If abfd != NULL && symndx != -1, the addend of the relocation
94 that should be added to the symbol value. */
96 /* If abfd != NULL && symndx == -1, the hash table entry
97 corresponding to a global symbol in the got (or, local, if
99 struct mips_elf_link_hash_entry
*h
;
102 /* The TLS types included in this GOT entry (specifically, GD and
103 IE). The GD and IE flags can be added as we encounter new
104 relocations. LDM can also be set; it will always be alone, not
105 combined with any GD or IE flags. An LDM GOT entry will be
106 a local symbol entry with r_symndx == 0. */
107 unsigned char tls_type
;
109 /* The offset from the beginning of the .got section to the entry
110 corresponding to this symbol+addend. If it's a global symbol
111 whose offset is yet to be decided, it's going to be -1. */
115 /* This structure describes a range of addends: [MIN_ADDEND, MAX_ADDEND].
116 The structures form a non-overlapping list that is sorted by increasing
118 struct mips_got_page_range
120 struct mips_got_page_range
*next
;
121 bfd_signed_vma min_addend
;
122 bfd_signed_vma max_addend
;
125 /* This structure describes the range of addends that are applied to page
126 relocations against a given symbol. */
127 struct mips_got_page_entry
129 /* The input bfd in which the symbol is defined. */
131 /* The index of the symbol, as stored in the relocation r_info. */
133 /* The ranges for this page entry. */
134 struct mips_got_page_range
*ranges
;
135 /* The maximum number of page entries needed for RANGES. */
139 /* This structure is used to hold .got information when linking. */
143 /* The global symbol in the GOT with the lowest index in the dynamic
145 struct elf_link_hash_entry
*global_gotsym
;
146 /* The number of global .got entries. */
147 unsigned int global_gotno
;
148 /* The number of global .got entries that are in the GGA_RELOC_ONLY area. */
149 unsigned int reloc_only_gotno
;
150 /* The number of .got slots used for TLS. */
151 unsigned int tls_gotno
;
152 /* The first unused TLS .got entry. Used only during
153 mips_elf_initialize_tls_index. */
154 unsigned int tls_assigned_gotno
;
155 /* The number of local .got entries, eventually including page entries. */
156 unsigned int local_gotno
;
157 /* The maximum number of page entries needed. */
158 unsigned int page_gotno
;
159 /* The number of local .got entries we have used. */
160 unsigned int assigned_gotno
;
161 /* A hash table holding members of the got. */
162 struct htab
*got_entries
;
163 /* A hash table of mips_got_page_entry structures. */
164 struct htab
*got_page_entries
;
165 /* A hash table mapping input bfds to other mips_got_info. NULL
166 unless multi-got was necessary. */
167 struct htab
*bfd2got
;
168 /* In multi-got links, a pointer to the next got (err, rather, most
169 of the time, it points to the previous got). */
170 struct mips_got_info
*next
;
171 /* This is the GOT index of the TLS LDM entry for the GOT, MINUS_ONE
172 for none, or MINUS_TWO for not yet assigned. This is needed
173 because a single-GOT link may have multiple hash table entries
174 for the LDM. It does not get initialized in multi-GOT mode. */
175 bfd_vma tls_ldm_offset
;
178 /* Map an input bfd to a got in a multi-got link. */
180 struct mips_elf_bfd2got_hash
183 struct mips_got_info
*g
;
186 /* Structure passed when traversing the bfd2got hash table, used to
187 create and merge bfd's gots. */
189 struct mips_elf_got_per_bfd_arg
191 /* A hashtable that maps bfds to gots. */
193 /* The output bfd. */
195 /* The link information. */
196 struct bfd_link_info
*info
;
197 /* A pointer to the primary got, i.e., the one that's going to get
198 the implicit relocations from DT_MIPS_LOCAL_GOTNO and
200 struct mips_got_info
*primary
;
201 /* A non-primary got we're trying to merge with other input bfd's
203 struct mips_got_info
*current
;
204 /* The maximum number of got entries that can be addressed with a
206 unsigned int max_count
;
207 /* The maximum number of page entries needed by each got. */
208 unsigned int max_pages
;
209 /* The total number of global entries which will live in the
210 primary got and be automatically relocated. This includes
211 those not referenced by the primary GOT but included in
213 unsigned int global_count
;
216 /* Another structure used to pass arguments for got entries traversal. */
218 struct mips_elf_set_global_got_offset_arg
220 struct mips_got_info
*g
;
222 unsigned int needed_relocs
;
223 struct bfd_link_info
*info
;
226 /* A structure used to count TLS relocations or GOT entries, for GOT
227 entry or ELF symbol table traversal. */
229 struct mips_elf_count_tls_arg
231 struct bfd_link_info
*info
;
235 struct _mips_elf_section_data
237 struct bfd_elf_section_data elf
;
244 #define mips_elf_section_data(sec) \
245 ((struct _mips_elf_section_data *) elf_section_data (sec))
247 #define is_mips_elf(bfd) \
248 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
249 && elf_tdata (bfd) != NULL \
250 && elf_object_id (bfd) == MIPS_ELF_DATA)
252 /* The ABI says that every symbol used by dynamic relocations must have
253 a global GOT entry. Among other things, this provides the dynamic
254 linker with a free, directly-indexed cache. The GOT can therefore
255 contain symbols that are not referenced by GOT relocations themselves
256 (in other words, it may have symbols that are not referenced by things
257 like R_MIPS_GOT16 and R_MIPS_GOT_PAGE).
259 GOT relocations are less likely to overflow if we put the associated
260 GOT entries towards the beginning. We therefore divide the global
261 GOT entries into two areas: "normal" and "reloc-only". Entries in
262 the first area can be used for both dynamic relocations and GP-relative
263 accesses, while those in the "reloc-only" area are for dynamic
266 These GGA_* ("Global GOT Area") values are organised so that lower
267 values are more general than higher values. Also, non-GGA_NONE
268 values are ordered by the position of the area in the GOT. */
270 #define GGA_RELOC_ONLY 1
273 /* Information about a non-PIC interface to a PIC function. There are
274 two ways of creating these interfaces. The first is to add:
277 addiu $25,$25,%lo(func)
279 immediately before a PIC function "func". The second is to add:
283 addiu $25,$25,%lo(func)
285 to a separate trampoline section.
287 Stubs of the first kind go in a new section immediately before the
288 target function. Stubs of the second kind go in a single section
289 pointed to by the hash table's "strampoline" field. */
290 struct mips_elf_la25_stub
{
291 /* The generated section that contains this stub. */
292 asection
*stub_section
;
294 /* The offset of the stub from the start of STUB_SECTION. */
297 /* One symbol for the original function. Its location is available
298 in H->root.root.u.def. */
299 struct mips_elf_link_hash_entry
*h
;
302 /* Macros for populating a mips_elf_la25_stub. */
304 #define LA25_LUI(VAL) (0x3c190000 | (VAL)) /* lui t9,VAL */
305 #define LA25_J(VAL) (0x08000000 | (((VAL) >> 2) & 0x3ffffff)) /* j VAL */
306 #define LA25_ADDIU(VAL) (0x27390000 | (VAL)) /* addiu t9,t9,VAL */
308 /* This structure is passed to mips_elf_sort_hash_table_f when sorting
309 the dynamic symbols. */
311 struct mips_elf_hash_sort_data
313 /* The symbol in the global GOT with the lowest dynamic symbol table
315 struct elf_link_hash_entry
*low
;
316 /* The least dynamic symbol table index corresponding to a non-TLS
317 symbol with a GOT entry. */
318 long min_got_dynindx
;
319 /* The greatest dynamic symbol table index corresponding to a symbol
320 with a GOT entry that is not referenced (e.g., a dynamic symbol
321 with dynamic relocations pointing to it from non-primary GOTs). */
322 long max_unref_got_dynindx
;
323 /* The greatest dynamic symbol table index not corresponding to a
324 symbol without a GOT entry. */
325 long max_non_got_dynindx
;
328 /* The MIPS ELF linker needs additional information for each symbol in
329 the global hash table. */
331 struct mips_elf_link_hash_entry
333 struct elf_link_hash_entry root
;
335 /* External symbol information. */
338 /* The la25 stub we have created for ths symbol, if any. */
339 struct mips_elf_la25_stub
*la25_stub
;
341 /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
343 unsigned int possibly_dynamic_relocs
;
345 /* If there is a stub that 32 bit functions should use to call this
346 16 bit function, this points to the section containing the stub. */
349 /* If there is a stub that 16 bit functions should use to call this
350 32 bit function, this points to the section containing the stub. */
353 /* This is like the call_stub field, but it is used if the function
354 being called returns a floating point value. */
355 asection
*call_fp_stub
;
359 #define GOT_TLS_LDM 2
361 #define GOT_TLS_OFFSET_DONE 0x40
362 #define GOT_TLS_DONE 0x80
363 unsigned char tls_type
;
365 /* This is only used in single-GOT mode; in multi-GOT mode there
366 is one mips_got_entry per GOT entry, so the offset is stored
367 there. In single-GOT mode there may be many mips_got_entry
368 structures all referring to the same GOT slot. It might be
369 possible to use root.got.offset instead, but that field is
370 overloaded already. */
371 bfd_vma tls_got_offset
;
373 /* The highest GGA_* value that satisfies all references to this symbol. */
374 unsigned int global_got_area
: 2;
376 /* True if one of the relocations described by possibly_dynamic_relocs
377 is against a readonly section. */
378 unsigned int readonly_reloc
: 1;
380 /* True if there is a relocation against this symbol that must be
381 resolved by the static linker (in other words, if the relocation
382 cannot possibly be made dynamic). */
383 unsigned int has_static_relocs
: 1;
385 /* True if we must not create a .MIPS.stubs entry for this symbol.
386 This is set, for example, if there are relocations related to
387 taking the function's address, i.e. any but R_MIPS_CALL*16 ones.
388 See "MIPS ABI Supplement, 3rd Edition", p. 4-20. */
389 unsigned int no_fn_stub
: 1;
391 /* Whether we need the fn_stub; this is true if this symbol appears
392 in any relocs other than a 16 bit call. */
393 unsigned int need_fn_stub
: 1;
395 /* True if this symbol is referenced by branch relocations from
396 any non-PIC input file. This is used to determine whether an
397 la25 stub is required. */
398 unsigned int has_nonpic_branches
: 1;
400 /* Does this symbol need a traditional MIPS lazy-binding stub
401 (as opposed to a PLT entry)? */
402 unsigned int needs_lazy_stub
: 1;
405 /* MIPS ELF linker hash table. */
407 struct mips_elf_link_hash_table
409 struct elf_link_hash_table root
;
411 /* We no longer use this. */
412 /* String section indices for the dynamic section symbols. */
413 bfd_size_type dynsym_sec_strindex
[SIZEOF_MIPS_DYNSYM_SECNAMES
];
416 /* The number of .rtproc entries. */
417 bfd_size_type procedure_count
;
419 /* The size of the .compact_rel section (if SGI_COMPAT). */
420 bfd_size_type compact_rel_size
;
422 /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic
423 entry is set to the address of __rld_obj_head as in IRIX5. */
424 bfd_boolean use_rld_obj_head
;
426 /* This is the value of the __rld_map or __rld_obj_head symbol. */
429 /* This is set if we see any mips16 stub sections. */
430 bfd_boolean mips16_stubs_seen
;
432 /* True if we can generate copy relocs and PLTs. */
433 bfd_boolean use_plts_and_copy_relocs
;
435 /* True if we're generating code for VxWorks. */
436 bfd_boolean is_vxworks
;
438 /* True if we already reported the small-data section overflow. */
439 bfd_boolean small_data_overflow_reported
;
441 /* Shortcuts to some dynamic sections, or NULL if they are not
452 /* The master GOT information. */
453 struct mips_got_info
*got_info
;
455 /* The size of the PLT header in bytes. */
456 bfd_vma plt_header_size
;
458 /* The size of a PLT entry in bytes. */
459 bfd_vma plt_entry_size
;
461 /* The number of functions that need a lazy-binding stub. */
462 bfd_vma lazy_stub_count
;
464 /* The size of a function stub entry in bytes. */
465 bfd_vma function_stub_size
;
467 /* The number of reserved entries at the beginning of the GOT. */
468 unsigned int reserved_gotno
;
470 /* The section used for mips_elf_la25_stub trampolines.
471 See the comment above that structure for details. */
472 asection
*strampoline
;
474 /* A table of mips_elf_la25_stubs, indexed by (input_section, offset)
478 /* A function FN (NAME, IS, OS) that creates a new input section
479 called NAME and links it to output section OS. If IS is nonnull,
480 the new section should go immediately before it, otherwise it
481 should go at the (current) beginning of OS.
483 The function returns the new section on success, otherwise it
485 asection
*(*add_stub_section
) (const char *, asection
*, asection
*);
488 /* Get the MIPS ELF linker hash table from a link_info structure. */
490 #define mips_elf_hash_table(p) \
491 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
492 == MIPS_ELF_DATA ? ((struct mips_elf_link_hash_table *) ((p)->hash)) : NULL)
494 /* A structure used to communicate with htab_traverse callbacks. */
495 struct mips_htab_traverse_info
497 /* The usual link-wide information. */
498 struct bfd_link_info
*info
;
501 /* Starts off FALSE and is set to TRUE if the link should be aborted. */
505 #define TLS_RELOC_P(r_type) \
506 (r_type == R_MIPS_TLS_DTPMOD32 \
507 || r_type == R_MIPS_TLS_DTPMOD64 \
508 || r_type == R_MIPS_TLS_DTPREL32 \
509 || r_type == R_MIPS_TLS_DTPREL64 \
510 || r_type == R_MIPS_TLS_GD \
511 || r_type == R_MIPS_TLS_LDM \
512 || r_type == R_MIPS_TLS_DTPREL_HI16 \
513 || r_type == R_MIPS_TLS_DTPREL_LO16 \
514 || r_type == R_MIPS_TLS_GOTTPREL \
515 || r_type == R_MIPS_TLS_TPREL32 \
516 || r_type == R_MIPS_TLS_TPREL64 \
517 || r_type == R_MIPS_TLS_TPREL_HI16 \
518 || r_type == R_MIPS_TLS_TPREL_LO16)
520 /* Structure used to pass information to mips_elf_output_extsym. */
525 struct bfd_link_info
*info
;
526 struct ecoff_debug_info
*debug
;
527 const struct ecoff_debug_swap
*swap
;
531 /* The names of the runtime procedure table symbols used on IRIX5. */
533 static const char * const mips_elf_dynsym_rtproc_names
[] =
536 "_procedure_string_table",
537 "_procedure_table_size",
541 /* These structures are used to generate the .compact_rel section on
546 unsigned long id1
; /* Always one? */
547 unsigned long num
; /* Number of compact relocation entries. */
548 unsigned long id2
; /* Always two? */
549 unsigned long offset
; /* The file offset of the first relocation. */
550 unsigned long reserved0
; /* Zero? */
551 unsigned long reserved1
; /* Zero? */
560 bfd_byte reserved0
[4];
561 bfd_byte reserved1
[4];
562 } Elf32_External_compact_rel
;
566 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
567 unsigned int rtype
: 4; /* Relocation types. See below. */
568 unsigned int dist2to
: 8;
569 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
570 unsigned long konst
; /* KONST field. See below. */
571 unsigned long vaddr
; /* VADDR to be relocated. */
576 unsigned int ctype
: 1; /* 1: long 0: short format. See below. */
577 unsigned int rtype
: 4; /* Relocation types. See below. */
578 unsigned int dist2to
: 8;
579 unsigned int relvaddr
: 19; /* (VADDR - vaddr of the previous entry)/ 4 */
580 unsigned long konst
; /* KONST field. See below. */
588 } Elf32_External_crinfo
;
594 } Elf32_External_crinfo2
;
596 /* These are the constants used to swap the bitfields in a crinfo. */
598 #define CRINFO_CTYPE (0x1)
599 #define CRINFO_CTYPE_SH (31)
600 #define CRINFO_RTYPE (0xf)
601 #define CRINFO_RTYPE_SH (27)
602 #define CRINFO_DIST2TO (0xff)
603 #define CRINFO_DIST2TO_SH (19)
604 #define CRINFO_RELVADDR (0x7ffff)
605 #define CRINFO_RELVADDR_SH (0)
607 /* A compact relocation info has long (3 words) or short (2 words)
608 formats. A short format doesn't have VADDR field and relvaddr
609 fields contains ((VADDR - vaddr of the previous entry) >> 2). */
610 #define CRF_MIPS_LONG 1
611 #define CRF_MIPS_SHORT 0
613 /* There are 4 types of compact relocation at least. The value KONST
614 has different meaning for each type:
617 CT_MIPS_REL32 Address in data
618 CT_MIPS_WORD Address in word (XXX)
619 CT_MIPS_GPHI_LO GP - vaddr
620 CT_MIPS_JMPAD Address to jump
623 #define CRT_MIPS_REL32 0xa
624 #define CRT_MIPS_WORD 0xb
625 #define CRT_MIPS_GPHI_LO 0xc
626 #define CRT_MIPS_JMPAD 0xd
628 #define mips_elf_set_cr_format(x,format) ((x).ctype = (format))
629 #define mips_elf_set_cr_type(x,type) ((x).rtype = (type))
630 #define mips_elf_set_cr_dist2to(x,v) ((x).dist2to = (v))
631 #define mips_elf_set_cr_relvaddr(x,d) ((x).relvaddr = (d)<<2)
633 /* The structure of the runtime procedure descriptor created by the
634 loader for use by the static exception system. */
636 typedef struct runtime_pdr
{
637 bfd_vma adr
; /* Memory address of start of procedure. */
638 long regmask
; /* Save register mask. */
639 long regoffset
; /* Save register offset. */
640 long fregmask
; /* Save floating point register mask. */
641 long fregoffset
; /* Save floating point register offset. */
642 long frameoffset
; /* Frame size. */
643 short framereg
; /* Frame pointer register. */
644 short pcreg
; /* Offset or reg of return pc. */
645 long irpss
; /* Index into the runtime string table. */
647 struct exception_info
*exception_info
;/* Pointer to exception array. */
649 #define cbRPDR sizeof (RPDR)
650 #define rpdNil ((pRPDR) 0)
652 static struct mips_got_entry
*mips_elf_create_local_got_entry
653 (bfd
*, struct bfd_link_info
*, bfd
*, bfd_vma
, unsigned long,
654 struct mips_elf_link_hash_entry
*, int);
655 static bfd_boolean mips_elf_sort_hash_table_f
656 (struct mips_elf_link_hash_entry
*, void *);
657 static bfd_vma mips_elf_high
659 static bfd_boolean mips_elf_create_dynamic_relocation
660 (bfd
*, struct bfd_link_info
*, const Elf_Internal_Rela
*,
661 struct mips_elf_link_hash_entry
*, asection
*, bfd_vma
,
662 bfd_vma
*, asection
*);
663 static hashval_t mips_elf_got_entry_hash
665 static bfd_vma mips_elf_adjust_gp
666 (bfd
*, struct mips_got_info
*, bfd
*);
667 static struct mips_got_info
*mips_elf_got_for_ibfd
668 (struct mips_got_info
*, bfd
*);
670 /* This will be used when we sort the dynamic relocation records. */
671 static bfd
*reldyn_sorting_bfd
;
673 /* True if ABFD is for CPUs with load interlocking that include
674 non-MIPS1 CPUs and R3900. */
675 #define LOAD_INTERLOCKS_P(abfd) \
676 ( ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) != E_MIPS_ARCH_1) \
677 || ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == E_MIPS_MACH_3900))
679 /* True if ABFD is for CPUs that are faster if JAL is converted to BAL.
680 This should be safe for all architectures. We enable this predicate
681 for RM9000 for now. */
682 #define JAL_TO_BAL_P(abfd) \
683 ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == E_MIPS_MACH_9000)
685 /* True if ABFD is for CPUs that are faster if JALR is converted to BAL.
686 This should be safe for all architectures. We enable this predicate for
688 #define JALR_TO_BAL_P(abfd) 1
690 /* True if ABFD is for CPUs that are faster if JR is converted to B.
691 This should be safe for all architectures. We enable this predicate for
693 #define JR_TO_B_P(abfd) 1
695 /* True if ABFD is a PIC object. */
696 #define PIC_OBJECT_P(abfd) \
697 ((elf_elfheader (abfd)->e_flags & EF_MIPS_PIC) != 0)
699 /* Nonzero if ABFD is using the N32 ABI. */
700 #define ABI_N32_P(abfd) \
701 ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
703 /* Nonzero if ABFD is using the N64 ABI. */
704 #define ABI_64_P(abfd) \
705 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
707 /* Nonzero if ABFD is using NewABI conventions. */
708 #define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
710 /* The IRIX compatibility level we are striving for. */
711 #define IRIX_COMPAT(abfd) \
712 (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
714 /* Whether we are trying to be compatible with IRIX at all. */
715 #define SGI_COMPAT(abfd) \
716 (IRIX_COMPAT (abfd) != ict_none)
718 /* The name of the options section. */
719 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
720 (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
722 /* True if NAME is the recognized name of any SHT_MIPS_OPTIONS section.
723 Some IRIX system files do not use MIPS_ELF_OPTIONS_SECTION_NAME. */
724 #define MIPS_ELF_OPTIONS_SECTION_NAME_P(NAME) \
725 (strcmp (NAME, ".MIPS.options") == 0 || strcmp (NAME, ".options") == 0)
727 /* Whether the section is readonly. */
728 #define MIPS_ELF_READONLY_SECTION(sec) \
729 ((sec->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY)) \
730 == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
732 /* The name of the stub section. */
733 #define MIPS_ELF_STUB_SECTION_NAME(abfd) ".MIPS.stubs"
735 /* The size of an external REL relocation. */
736 #define MIPS_ELF_REL_SIZE(abfd) \
737 (get_elf_backend_data (abfd)->s->sizeof_rel)
739 /* The size of an external RELA relocation. */
740 #define MIPS_ELF_RELA_SIZE(abfd) \
741 (get_elf_backend_data (abfd)->s->sizeof_rela)
743 /* The size of an external dynamic table entry. */
744 #define MIPS_ELF_DYN_SIZE(abfd) \
745 (get_elf_backend_data (abfd)->s->sizeof_dyn)
747 /* The size of a GOT entry. */
748 #define MIPS_ELF_GOT_SIZE(abfd) \
749 (get_elf_backend_data (abfd)->s->arch_size / 8)
751 /* The size of a symbol-table entry. */
752 #define MIPS_ELF_SYM_SIZE(abfd) \
753 (get_elf_backend_data (abfd)->s->sizeof_sym)
755 /* The default alignment for sections, as a power of two. */
756 #define MIPS_ELF_LOG_FILE_ALIGN(abfd) \
757 (get_elf_backend_data (abfd)->s->log_file_align)
759 /* Get word-sized data. */
760 #define MIPS_ELF_GET_WORD(abfd, ptr) \
761 (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
763 /* Put out word-sized data. */
764 #define MIPS_ELF_PUT_WORD(abfd, val, ptr) \
766 ? bfd_put_64 (abfd, val, ptr) \
767 : bfd_put_32 (abfd, val, ptr))
769 /* The opcode for word-sized loads (LW or LD). */
770 #define MIPS_ELF_LOAD_WORD(abfd) \
771 (ABI_64_P (abfd) ? 0xdc000000 : 0x8c000000)
773 /* Add a dynamic symbol table-entry. */
774 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
775 _bfd_elf_add_dynamic_entry (info, tag, val)
777 #define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela) \
778 (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela))
780 /* Determine whether the internal relocation of index REL_IDX is REL
781 (zero) or RELA (non-zero). The assumption is that, if there are
782 two relocation sections for this section, one of them is REL and
783 the other is RELA. If the index of the relocation we're testing is
784 in range for the first relocation section, check that the external
785 relocation size is that for RELA. It is also assumed that, if
786 rel_idx is not in range for the first section, and this first
787 section contains REL relocs, then the relocation is in the second
788 section, that is RELA. */
789 #define MIPS_RELOC_RELA_P(abfd, sec, rel_idx) \
790 ((NUM_SHDR_ENTRIES (&elf_section_data (sec)->rel_hdr) \
791 * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel \
792 > (bfd_vma)(rel_idx)) \
793 == (elf_section_data (sec)->rel_hdr.sh_entsize \
794 == (ABI_64_P (abfd) ? sizeof (Elf64_External_Rela) \
795 : sizeof (Elf32_External_Rela))))
797 /* The name of the dynamic relocation section. */
798 #define MIPS_ELF_REL_DYN_NAME(INFO) \
799 (mips_elf_hash_table (INFO)->is_vxworks ? ".rela.dyn" : ".rel.dyn")
801 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
802 from smaller values. Start with zero, widen, *then* decrement. */
803 #define MINUS_ONE (((bfd_vma)0) - 1)
804 #define MINUS_TWO (((bfd_vma)0) - 2)
806 /* The value to write into got[1] for SVR4 targets, to identify it is
807 a GNU object. The dynamic linker can then use got[1] to store the
809 #define MIPS_ELF_GNU_GOT1_MASK(abfd) \
810 ((bfd_vma) 1 << (ABI_64_P (abfd) ? 63 : 31))
812 /* The offset of $gp from the beginning of the .got section. */
813 #define ELF_MIPS_GP_OFFSET(INFO) \
814 (mips_elf_hash_table (INFO)->is_vxworks ? 0x0 : 0x7ff0)
816 /* The maximum size of the GOT for it to be addressable using 16-bit
818 #define MIPS_ELF_GOT_MAX_SIZE(INFO) (ELF_MIPS_GP_OFFSET (INFO) + 0x7fff)
820 /* Instructions which appear in a stub. */
821 #define STUB_LW(abfd) \
823 ? 0xdf998010 /* ld t9,0x8010(gp) */ \
824 : 0x8f998010)) /* lw t9,0x8010(gp) */
825 #define STUB_MOVE(abfd) \
827 ? 0x03e0782d /* daddu t7,ra */ \
828 : 0x03e07821)) /* addu t7,ra */
829 #define STUB_LUI(VAL) (0x3c180000 + (VAL)) /* lui t8,VAL */
830 #define STUB_JALR 0x0320f809 /* jalr t9,ra */
831 #define STUB_ORI(VAL) (0x37180000 + (VAL)) /* ori t8,t8,VAL */
832 #define STUB_LI16U(VAL) (0x34180000 + (VAL)) /* ori t8,zero,VAL unsigned */
833 #define STUB_LI16S(abfd, VAL) \
835 ? (0x64180000 + (VAL)) /* daddiu t8,zero,VAL sign extended */ \
836 : (0x24180000 + (VAL)))) /* addiu t8,zero,VAL sign extended */
838 #define MIPS_FUNCTION_STUB_NORMAL_SIZE 16
839 #define MIPS_FUNCTION_STUB_BIG_SIZE 20
841 /* The name of the dynamic interpreter. This is put in the .interp
844 #define ELF_DYNAMIC_INTERPRETER(abfd) \
845 (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1" \
846 : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1" \
847 : "/usr/lib/libc.so.1")
850 #define MNAME(bfd,pre,pos) \
851 (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
852 #define ELF_R_SYM(bfd, i) \
853 (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
854 #define ELF_R_TYPE(bfd, i) \
855 (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
856 #define ELF_R_INFO(bfd, s, t) \
857 (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
859 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
860 #define ELF_R_SYM(bfd, i) \
862 #define ELF_R_TYPE(bfd, i) \
864 #define ELF_R_INFO(bfd, s, t) \
865 (ELF32_R_INFO (s, t))
868 /* The mips16 compiler uses a couple of special sections to handle
869 floating point arguments.
871 Section names that look like .mips16.fn.FNNAME contain stubs that
872 copy floating point arguments from the fp regs to the gp regs and
873 then jump to FNNAME. If any 32 bit function calls FNNAME, the
874 call should be redirected to the stub instead. If no 32 bit
875 function calls FNNAME, the stub should be discarded. We need to
876 consider any reference to the function, not just a call, because
877 if the address of the function is taken we will need the stub,
878 since the address might be passed to a 32 bit function.
880 Section names that look like .mips16.call.FNNAME contain stubs
881 that copy floating point arguments from the gp regs to the fp
882 regs and then jump to FNNAME. If FNNAME is a 32 bit function,
883 then any 16 bit function that calls FNNAME should be redirected
884 to the stub instead. If FNNAME is not a 32 bit function, the
885 stub should be discarded.
887 .mips16.call.fp.FNNAME sections are similar, but contain stubs
888 which call FNNAME and then copy the return value from the fp regs
889 to the gp regs. These stubs store the return value in $18 while
890 calling FNNAME; any function which might call one of these stubs
891 must arrange to save $18 around the call. (This case is not
892 needed for 32 bit functions that call 16 bit functions, because
893 16 bit functions always return floating point values in both
896 Note that in all cases FNNAME might be defined statically.
897 Therefore, FNNAME is not used literally. Instead, the relocation
898 information will indicate which symbol the section is for.
900 We record any stubs that we find in the symbol table. */
902 #define FN_STUB ".mips16.fn."
903 #define CALL_STUB ".mips16.call."
904 #define CALL_FP_STUB ".mips16.call.fp."
906 #define FN_STUB_P(name) CONST_STRNEQ (name, FN_STUB)
907 #define CALL_STUB_P(name) CONST_STRNEQ (name, CALL_STUB)
908 #define CALL_FP_STUB_P(name) CONST_STRNEQ (name, CALL_FP_STUB)
910 /* The format of the first PLT entry in an O32 executable. */
911 static const bfd_vma mips_o32_exec_plt0_entry
[] =
913 0x3c1c0000, /* lui $28, %hi(&GOTPLT[0]) */
914 0x8f990000, /* lw $25, %lo(&GOTPLT[0])($28) */
915 0x279c0000, /* addiu $28, $28, %lo(&GOTPLT[0]) */
916 0x031cc023, /* subu $24, $24, $28 */
917 0x03e07821, /* move $15, $31 */
918 0x0018c082, /* srl $24, $24, 2 */
919 0x0320f809, /* jalr $25 */
920 0x2718fffe /* subu $24, $24, 2 */
923 /* The format of the first PLT entry in an N32 executable. Different
924 because gp ($28) is not available; we use t2 ($14) instead. */
925 static const bfd_vma mips_n32_exec_plt0_entry
[] =
927 0x3c0e0000, /* lui $14, %hi(&GOTPLT[0]) */
928 0x8dd90000, /* lw $25, %lo(&GOTPLT[0])($14) */
929 0x25ce0000, /* addiu $14, $14, %lo(&GOTPLT[0]) */
930 0x030ec023, /* subu $24, $24, $14 */
931 0x03e07821, /* move $15, $31 */
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 N64 executable. Different
938 from N32 because of the increased size of GOT entries. */
939 static const bfd_vma mips_n64_exec_plt0_entry
[] =
941 0x3c0e0000, /* lui $14, %hi(&GOTPLT[0]) */
942 0xddd90000, /* ld $25, %lo(&GOTPLT[0])($14) */
943 0x25ce0000, /* addiu $14, $14, %lo(&GOTPLT[0]) */
944 0x030ec023, /* subu $24, $24, $14 */
945 0x03e07821, /* move $15, $31 */
946 0x0018c0c2, /* srl $24, $24, 3 */
947 0x0320f809, /* jalr $25 */
948 0x2718fffe /* subu $24, $24, 2 */
951 /* The format of subsequent PLT entries. */
952 static const bfd_vma mips_exec_plt_entry
[] =
954 0x3c0f0000, /* lui $15, %hi(.got.plt entry) */
955 0x01f90000, /* l[wd] $25, %lo(.got.plt entry)($15) */
956 0x25f80000, /* addiu $24, $15, %lo(.got.plt entry) */
957 0x03200008 /* jr $25 */
960 /* The format of the first PLT entry in a VxWorks executable. */
961 static const bfd_vma mips_vxworks_exec_plt0_entry
[] =
963 0x3c190000, /* lui t9, %hi(_GLOBAL_OFFSET_TABLE_) */
964 0x27390000, /* addiu t9, t9, %lo(_GLOBAL_OFFSET_TABLE_) */
965 0x8f390008, /* lw t9, 8(t9) */
966 0x00000000, /* nop */
967 0x03200008, /* jr t9 */
971 /* The format of subsequent PLT entries. */
972 static const bfd_vma mips_vxworks_exec_plt_entry
[] =
974 0x10000000, /* b .PLT_resolver */
975 0x24180000, /* li t8, <pltindex> */
976 0x3c190000, /* lui t9, %hi(<.got.plt slot>) */
977 0x27390000, /* addiu t9, t9, %lo(<.got.plt slot>) */
978 0x8f390000, /* lw t9, 0(t9) */
979 0x00000000, /* nop */
980 0x03200008, /* jr t9 */
984 /* The format of the first PLT entry in a VxWorks shared object. */
985 static const bfd_vma mips_vxworks_shared_plt0_entry
[] =
987 0x8f990008, /* lw t9, 8(gp) */
988 0x00000000, /* nop */
989 0x03200008, /* jr t9 */
990 0x00000000, /* nop */
991 0x00000000, /* nop */
995 /* The format of subsequent PLT entries. */
996 static const bfd_vma mips_vxworks_shared_plt_entry
[] =
998 0x10000000, /* b .PLT_resolver */
999 0x24180000 /* li t8, <pltindex> */
1002 /* Look up an entry in a MIPS ELF linker hash table. */
1004 #define mips_elf_link_hash_lookup(table, string, create, copy, follow) \
1005 ((struct mips_elf_link_hash_entry *) \
1006 elf_link_hash_lookup (&(table)->root, (string), (create), \
1009 /* Traverse a MIPS ELF linker hash table. */
1011 #define mips_elf_link_hash_traverse(table, func, info) \
1012 (elf_link_hash_traverse \
1014 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
1017 /* Find the base offsets for thread-local storage in this object,
1018 for GD/LD and IE/LE respectively. */
1020 #define TP_OFFSET 0x7000
1021 #define DTP_OFFSET 0x8000
1024 dtprel_base (struct bfd_link_info
*info
)
1026 /* If tls_sec is NULL, we should have signalled an error already. */
1027 if (elf_hash_table (info
)->tls_sec
== NULL
)
1029 return elf_hash_table (info
)->tls_sec
->vma
+ DTP_OFFSET
;
1033 tprel_base (struct bfd_link_info
*info
)
1035 /* If tls_sec is NULL, we should have signalled an error already. */
1036 if (elf_hash_table (info
)->tls_sec
== NULL
)
1038 return elf_hash_table (info
)->tls_sec
->vma
+ TP_OFFSET
;
1041 /* Create an entry in a MIPS ELF linker hash table. */
1043 static struct bfd_hash_entry
*
1044 mips_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
1045 struct bfd_hash_table
*table
, const char *string
)
1047 struct mips_elf_link_hash_entry
*ret
=
1048 (struct mips_elf_link_hash_entry
*) entry
;
1050 /* Allocate the structure if it has not already been allocated by a
1053 ret
= bfd_hash_allocate (table
, sizeof (struct mips_elf_link_hash_entry
));
1055 return (struct bfd_hash_entry
*) ret
;
1057 /* Call the allocation method of the superclass. */
1058 ret
= ((struct mips_elf_link_hash_entry
*)
1059 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
1063 /* Set local fields. */
1064 memset (&ret
->esym
, 0, sizeof (EXTR
));
1065 /* We use -2 as a marker to indicate that the information has
1066 not been set. -1 means there is no associated ifd. */
1069 ret
->possibly_dynamic_relocs
= 0;
1070 ret
->fn_stub
= NULL
;
1071 ret
->call_stub
= NULL
;
1072 ret
->call_fp_stub
= NULL
;
1073 ret
->tls_type
= GOT_NORMAL
;
1074 ret
->global_got_area
= GGA_NONE
;
1075 ret
->readonly_reloc
= FALSE
;
1076 ret
->has_static_relocs
= FALSE
;
1077 ret
->no_fn_stub
= FALSE
;
1078 ret
->need_fn_stub
= FALSE
;
1079 ret
->has_nonpic_branches
= FALSE
;
1080 ret
->needs_lazy_stub
= FALSE
;
1083 return (struct bfd_hash_entry
*) ret
;
1087 _bfd_mips_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
1089 if (!sec
->used_by_bfd
)
1091 struct _mips_elf_section_data
*sdata
;
1092 bfd_size_type amt
= sizeof (*sdata
);
1094 sdata
= bfd_zalloc (abfd
, amt
);
1097 sec
->used_by_bfd
= sdata
;
1100 return _bfd_elf_new_section_hook (abfd
, sec
);
1103 /* Read ECOFF debugging information from a .mdebug section into a
1104 ecoff_debug_info structure. */
1107 _bfd_mips_elf_read_ecoff_info (bfd
*abfd
, asection
*section
,
1108 struct ecoff_debug_info
*debug
)
1111 const struct ecoff_debug_swap
*swap
;
1114 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
1115 memset (debug
, 0, sizeof (*debug
));
1117 ext_hdr
= bfd_malloc (swap
->external_hdr_size
);
1118 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
1121 if (! bfd_get_section_contents (abfd
, section
, ext_hdr
, 0,
1122 swap
->external_hdr_size
))
1125 symhdr
= &debug
->symbolic_header
;
1126 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
1128 /* The symbolic header contains absolute file offsets and sizes to
1130 #define READ(ptr, offset, count, size, type) \
1131 if (symhdr->count == 0) \
1132 debug->ptr = NULL; \
1135 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
1136 debug->ptr = bfd_malloc (amt); \
1137 if (debug->ptr == NULL) \
1138 goto error_return; \
1139 if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0 \
1140 || bfd_bread (debug->ptr, amt, abfd) != amt) \
1141 goto error_return; \
1144 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
1145 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, void *);
1146 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, void *);
1147 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, void *);
1148 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, void *);
1149 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
1151 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
1152 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
1153 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, void *);
1154 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, void *);
1155 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, void *);
1163 if (ext_hdr
!= NULL
)
1165 if (debug
->line
!= NULL
)
1167 if (debug
->external_dnr
!= NULL
)
1168 free (debug
->external_dnr
);
1169 if (debug
->external_pdr
!= NULL
)
1170 free (debug
->external_pdr
);
1171 if (debug
->external_sym
!= NULL
)
1172 free (debug
->external_sym
);
1173 if (debug
->external_opt
!= NULL
)
1174 free (debug
->external_opt
);
1175 if (debug
->external_aux
!= NULL
)
1176 free (debug
->external_aux
);
1177 if (debug
->ss
!= NULL
)
1179 if (debug
->ssext
!= NULL
)
1180 free (debug
->ssext
);
1181 if (debug
->external_fdr
!= NULL
)
1182 free (debug
->external_fdr
);
1183 if (debug
->external_rfd
!= NULL
)
1184 free (debug
->external_rfd
);
1185 if (debug
->external_ext
!= NULL
)
1186 free (debug
->external_ext
);
1190 /* Swap RPDR (runtime procedure table entry) for output. */
1193 ecoff_swap_rpdr_out (bfd
*abfd
, const RPDR
*in
, struct rpdr_ext
*ex
)
1195 H_PUT_S32 (abfd
, in
->adr
, ex
->p_adr
);
1196 H_PUT_32 (abfd
, in
->regmask
, ex
->p_regmask
);
1197 H_PUT_32 (abfd
, in
->regoffset
, ex
->p_regoffset
);
1198 H_PUT_32 (abfd
, in
->fregmask
, ex
->p_fregmask
);
1199 H_PUT_32 (abfd
, in
->fregoffset
, ex
->p_fregoffset
);
1200 H_PUT_32 (abfd
, in
->frameoffset
, ex
->p_frameoffset
);
1202 H_PUT_16 (abfd
, in
->framereg
, ex
->p_framereg
);
1203 H_PUT_16 (abfd
, in
->pcreg
, ex
->p_pcreg
);
1205 H_PUT_32 (abfd
, in
->irpss
, ex
->p_irpss
);
1208 /* Create a runtime procedure table from the .mdebug section. */
1211 mips_elf_create_procedure_table (void *handle
, bfd
*abfd
,
1212 struct bfd_link_info
*info
, asection
*s
,
1213 struct ecoff_debug_info
*debug
)
1215 const struct ecoff_debug_swap
*swap
;
1216 HDRR
*hdr
= &debug
->symbolic_header
;
1218 struct rpdr_ext
*erp
;
1220 struct pdr_ext
*epdr
;
1221 struct sym_ext
*esym
;
1225 bfd_size_type count
;
1226 unsigned long sindex
;
1230 const char *no_name_func
= _("static procedure (no name)");
1238 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
1240 sindex
= strlen (no_name_func
) + 1;
1241 count
= hdr
->ipdMax
;
1244 size
= swap
->external_pdr_size
;
1246 epdr
= bfd_malloc (size
* count
);
1250 if (! _bfd_ecoff_get_accumulated_pdr (handle
, (bfd_byte
*) epdr
))
1253 size
= sizeof (RPDR
);
1254 rp
= rpdr
= bfd_malloc (size
* count
);
1258 size
= sizeof (char *);
1259 sv
= bfd_malloc (size
* count
);
1263 count
= hdr
->isymMax
;
1264 size
= swap
->external_sym_size
;
1265 esym
= bfd_malloc (size
* count
);
1269 if (! _bfd_ecoff_get_accumulated_sym (handle
, (bfd_byte
*) esym
))
1272 count
= hdr
->issMax
;
1273 ss
= bfd_malloc (count
);
1276 if (! _bfd_ecoff_get_accumulated_ss (handle
, (bfd_byte
*) ss
))
1279 count
= hdr
->ipdMax
;
1280 for (i
= 0; i
< (unsigned long) count
; i
++, rp
++)
1282 (*swap
->swap_pdr_in
) (abfd
, epdr
+ i
, &pdr
);
1283 (*swap
->swap_sym_in
) (abfd
, &esym
[pdr
.isym
], &sym
);
1284 rp
->adr
= sym
.value
;
1285 rp
->regmask
= pdr
.regmask
;
1286 rp
->regoffset
= pdr
.regoffset
;
1287 rp
->fregmask
= pdr
.fregmask
;
1288 rp
->fregoffset
= pdr
.fregoffset
;
1289 rp
->frameoffset
= pdr
.frameoffset
;
1290 rp
->framereg
= pdr
.framereg
;
1291 rp
->pcreg
= pdr
.pcreg
;
1293 sv
[i
] = ss
+ sym
.iss
;
1294 sindex
+= strlen (sv
[i
]) + 1;
1298 size
= sizeof (struct rpdr_ext
) * (count
+ 2) + sindex
;
1299 size
= BFD_ALIGN (size
, 16);
1300 rtproc
= bfd_alloc (abfd
, size
);
1303 mips_elf_hash_table (info
)->procedure_count
= 0;
1307 mips_elf_hash_table (info
)->procedure_count
= count
+ 2;
1310 memset (erp
, 0, sizeof (struct rpdr_ext
));
1312 str
= (char *) rtproc
+ sizeof (struct rpdr_ext
) * (count
+ 2);
1313 strcpy (str
, no_name_func
);
1314 str
+= strlen (no_name_func
) + 1;
1315 for (i
= 0; i
< count
; i
++)
1317 ecoff_swap_rpdr_out (abfd
, rpdr
+ i
, erp
+ i
);
1318 strcpy (str
, sv
[i
]);
1319 str
+= strlen (sv
[i
]) + 1;
1321 H_PUT_S32 (abfd
, -1, (erp
+ count
)->p_adr
);
1323 /* Set the size and contents of .rtproc section. */
1325 s
->contents
= rtproc
;
1327 /* Skip this section later on (I don't think this currently
1328 matters, but someday it might). */
1329 s
->map_head
.link_order
= NULL
;
1358 /* We're going to create a stub for H. Create a symbol for the stub's
1359 value and size, to help make the disassembly easier to read. */
1362 mips_elf_create_stub_symbol (struct bfd_link_info
*info
,
1363 struct mips_elf_link_hash_entry
*h
,
1364 const char *prefix
, asection
*s
, bfd_vma value
,
1367 struct bfd_link_hash_entry
*bh
;
1368 struct elf_link_hash_entry
*elfh
;
1371 /* Create a new symbol. */
1372 name
= ACONCAT ((prefix
, h
->root
.root
.root
.string
, NULL
));
1374 if (!_bfd_generic_link_add_one_symbol (info
, s
->owner
, name
,
1375 BSF_LOCAL
, s
, value
, NULL
,
1379 /* Make it a local function. */
1380 elfh
= (struct elf_link_hash_entry
*) bh
;
1381 elfh
->type
= ELF_ST_INFO (STB_LOCAL
, STT_FUNC
);
1383 elfh
->forced_local
= 1;
1387 /* We're about to redefine H. Create a symbol to represent H's
1388 current value and size, to help make the disassembly easier
1392 mips_elf_create_shadow_symbol (struct bfd_link_info
*info
,
1393 struct mips_elf_link_hash_entry
*h
,
1396 struct bfd_link_hash_entry
*bh
;
1397 struct elf_link_hash_entry
*elfh
;
1402 /* Read the symbol's value. */
1403 BFD_ASSERT (h
->root
.root
.type
== bfd_link_hash_defined
1404 || h
->root
.root
.type
== bfd_link_hash_defweak
);
1405 s
= h
->root
.root
.u
.def
.section
;
1406 value
= h
->root
.root
.u
.def
.value
;
1408 /* Create a new symbol. */
1409 name
= ACONCAT ((prefix
, h
->root
.root
.root
.string
, NULL
));
1411 if (!_bfd_generic_link_add_one_symbol (info
, s
->owner
, name
,
1412 BSF_LOCAL
, s
, value
, NULL
,
1416 /* Make it local and copy the other attributes from H. */
1417 elfh
= (struct elf_link_hash_entry
*) bh
;
1418 elfh
->type
= ELF_ST_INFO (STB_LOCAL
, ELF_ST_TYPE (h
->root
.type
));
1419 elfh
->other
= h
->root
.other
;
1420 elfh
->size
= h
->root
.size
;
1421 elfh
->forced_local
= 1;
1425 /* Return TRUE if relocations in SECTION can refer directly to a MIPS16
1426 function rather than to a hard-float stub. */
1429 section_allows_mips16_refs_p (asection
*section
)
1433 name
= bfd_get_section_name (section
->owner
, section
);
1434 return (FN_STUB_P (name
)
1435 || CALL_STUB_P (name
)
1436 || CALL_FP_STUB_P (name
)
1437 || strcmp (name
, ".pdr") == 0);
1440 /* [RELOCS, RELEND) are the relocations against SEC, which is a MIPS16
1441 stub section of some kind. Return the R_SYMNDX of the target
1442 function, or 0 if we can't decide which function that is. */
1444 static unsigned long
1445 mips16_stub_symndx (asection
*sec ATTRIBUTE_UNUSED
,
1446 const Elf_Internal_Rela
*relocs
,
1447 const Elf_Internal_Rela
*relend
)
1449 const Elf_Internal_Rela
*rel
;
1451 /* Trust the first R_MIPS_NONE relocation, if any. */
1452 for (rel
= relocs
; rel
< relend
; rel
++)
1453 if (ELF_R_TYPE (sec
->owner
, rel
->r_info
) == R_MIPS_NONE
)
1454 return ELF_R_SYM (sec
->owner
, rel
->r_info
);
1456 /* Otherwise trust the first relocation, whatever its kind. This is
1457 the traditional behavior. */
1458 if (relocs
< relend
)
1459 return ELF_R_SYM (sec
->owner
, relocs
->r_info
);
1464 /* Check the mips16 stubs for a particular symbol, and see if we can
1468 mips_elf_check_mips16_stubs (struct bfd_link_info
*info
,
1469 struct mips_elf_link_hash_entry
*h
)
1471 /* Dynamic symbols must use the standard call interface, in case other
1472 objects try to call them. */
1473 if (h
->fn_stub
!= NULL
1474 && h
->root
.dynindx
!= -1)
1476 mips_elf_create_shadow_symbol (info
, h
, ".mips16.");
1477 h
->need_fn_stub
= TRUE
;
1480 if (h
->fn_stub
!= NULL
1481 && ! h
->need_fn_stub
)
1483 /* We don't need the fn_stub; the only references to this symbol
1484 are 16 bit calls. Clobber the size to 0 to prevent it from
1485 being included in the link. */
1486 h
->fn_stub
->size
= 0;
1487 h
->fn_stub
->flags
&= ~SEC_RELOC
;
1488 h
->fn_stub
->reloc_count
= 0;
1489 h
->fn_stub
->flags
|= SEC_EXCLUDE
;
1492 if (h
->call_stub
!= NULL
1493 && ELF_ST_IS_MIPS16 (h
->root
.other
))
1495 /* We don't need the call_stub; this is a 16 bit function, so
1496 calls from other 16 bit functions are OK. Clobber the size
1497 to 0 to prevent it from being included in the link. */
1498 h
->call_stub
->size
= 0;
1499 h
->call_stub
->flags
&= ~SEC_RELOC
;
1500 h
->call_stub
->reloc_count
= 0;
1501 h
->call_stub
->flags
|= SEC_EXCLUDE
;
1504 if (h
->call_fp_stub
!= NULL
1505 && ELF_ST_IS_MIPS16 (h
->root
.other
))
1507 /* We don't need the call_stub; this is a 16 bit function, so
1508 calls from other 16 bit functions are OK. Clobber the size
1509 to 0 to prevent it from being included in the link. */
1510 h
->call_fp_stub
->size
= 0;
1511 h
->call_fp_stub
->flags
&= ~SEC_RELOC
;
1512 h
->call_fp_stub
->reloc_count
= 0;
1513 h
->call_fp_stub
->flags
|= SEC_EXCLUDE
;
1517 /* Hashtable callbacks for mips_elf_la25_stubs. */
1520 mips_elf_la25_stub_hash (const void *entry_
)
1522 const struct mips_elf_la25_stub
*entry
;
1524 entry
= (struct mips_elf_la25_stub
*) entry_
;
1525 return entry
->h
->root
.root
.u
.def
.section
->id
1526 + entry
->h
->root
.root
.u
.def
.value
;
1530 mips_elf_la25_stub_eq (const void *entry1_
, const void *entry2_
)
1532 const struct mips_elf_la25_stub
*entry1
, *entry2
;
1534 entry1
= (struct mips_elf_la25_stub
*) entry1_
;
1535 entry2
= (struct mips_elf_la25_stub
*) entry2_
;
1536 return ((entry1
->h
->root
.root
.u
.def
.section
1537 == entry2
->h
->root
.root
.u
.def
.section
)
1538 && (entry1
->h
->root
.root
.u
.def
.value
1539 == entry2
->h
->root
.root
.u
.def
.value
));
1542 /* Called by the linker to set up the la25 stub-creation code. FN is
1543 the linker's implementation of add_stub_function. Return true on
1547 _bfd_mips_elf_init_stubs (struct bfd_link_info
*info
,
1548 asection
*(*fn
) (const char *, asection
*,
1551 struct mips_elf_link_hash_table
*htab
;
1553 htab
= mips_elf_hash_table (info
);
1557 htab
->add_stub_section
= fn
;
1558 htab
->la25_stubs
= htab_try_create (1, mips_elf_la25_stub_hash
,
1559 mips_elf_la25_stub_eq
, NULL
);
1560 if (htab
->la25_stubs
== NULL
)
1566 /* Return true if H is a locally-defined PIC function, in the sense
1567 that it might need $25 to be valid on entry. Note that MIPS16
1568 functions never need $25 to be valid on entry; they set up $gp
1569 using PC-relative instructions instead. */
1572 mips_elf_local_pic_function_p (struct mips_elf_link_hash_entry
*h
)
1574 return ((h
->root
.root
.type
== bfd_link_hash_defined
1575 || h
->root
.root
.type
== bfd_link_hash_defweak
)
1576 && h
->root
.def_regular
1577 && !bfd_is_abs_section (h
->root
.root
.u
.def
.section
)
1578 && !ELF_ST_IS_MIPS16 (h
->root
.other
)
1579 && (PIC_OBJECT_P (h
->root
.root
.u
.def
.section
->owner
)
1580 || ELF_ST_IS_MIPS_PIC (h
->root
.other
)));
1583 /* STUB describes an la25 stub that we have decided to implement
1584 by inserting an LUI/ADDIU pair before the target function.
1585 Create the section and redirect the function symbol to it. */
1588 mips_elf_add_la25_intro (struct mips_elf_la25_stub
*stub
,
1589 struct bfd_link_info
*info
)
1591 struct mips_elf_link_hash_table
*htab
;
1593 asection
*s
, *input_section
;
1596 htab
= mips_elf_hash_table (info
);
1600 /* Create a unique name for the new section. */
1601 name
= bfd_malloc (11 + sizeof (".text.stub."));
1604 sprintf (name
, ".text.stub.%d", (int) htab_elements (htab
->la25_stubs
));
1606 /* Create the section. */
1607 input_section
= stub
->h
->root
.root
.u
.def
.section
;
1608 s
= htab
->add_stub_section (name
, input_section
,
1609 input_section
->output_section
);
1613 /* Make sure that any padding goes before the stub. */
1614 align
= input_section
->alignment_power
;
1615 if (!bfd_set_section_alignment (s
->owner
, s
, align
))
1618 s
->size
= (1 << align
) - 8;
1620 /* Create a symbol for the stub. */
1621 mips_elf_create_stub_symbol (info
, stub
->h
, ".pic.", s
, s
->size
, 8);
1622 stub
->stub_section
= s
;
1623 stub
->offset
= s
->size
;
1625 /* Allocate room for it. */
1630 /* STUB describes an la25 stub that we have decided to implement
1631 with a separate trampoline. Allocate room for it and redirect
1632 the function symbol to it. */
1635 mips_elf_add_la25_trampoline (struct mips_elf_la25_stub
*stub
,
1636 struct bfd_link_info
*info
)
1638 struct mips_elf_link_hash_table
*htab
;
1641 htab
= mips_elf_hash_table (info
);
1645 /* Create a trampoline section, if we haven't already. */
1646 s
= htab
->strampoline
;
1649 asection
*input_section
= stub
->h
->root
.root
.u
.def
.section
;
1650 s
= htab
->add_stub_section (".text", NULL
,
1651 input_section
->output_section
);
1652 if (s
== NULL
|| !bfd_set_section_alignment (s
->owner
, s
, 4))
1654 htab
->strampoline
= s
;
1657 /* Create a symbol for the stub. */
1658 mips_elf_create_stub_symbol (info
, stub
->h
, ".pic.", s
, s
->size
, 16);
1659 stub
->stub_section
= s
;
1660 stub
->offset
= s
->size
;
1662 /* Allocate room for it. */
1667 /* H describes a symbol that needs an la25 stub. Make sure that an
1668 appropriate stub exists and point H at it. */
1671 mips_elf_add_la25_stub (struct bfd_link_info
*info
,
1672 struct mips_elf_link_hash_entry
*h
)
1674 struct mips_elf_link_hash_table
*htab
;
1675 struct mips_elf_la25_stub search
, *stub
;
1676 bfd_boolean use_trampoline_p
;
1681 /* Prefer to use LUI/ADDIU stubs if the function is at the beginning
1682 of the section and if we would need no more than 2 nops. */
1683 s
= h
->root
.root
.u
.def
.section
;
1684 value
= h
->root
.root
.u
.def
.value
;
1685 use_trampoline_p
= (value
!= 0 || s
->alignment_power
> 4);
1687 /* Describe the stub we want. */
1688 search
.stub_section
= NULL
;
1692 /* See if we've already created an equivalent stub. */
1693 htab
= mips_elf_hash_table (info
);
1697 slot
= htab_find_slot (htab
->la25_stubs
, &search
, INSERT
);
1701 stub
= (struct mips_elf_la25_stub
*) *slot
;
1704 /* We can reuse the existing stub. */
1705 h
->la25_stub
= stub
;
1709 /* Create a permanent copy of ENTRY and add it to the hash table. */
1710 stub
= bfd_malloc (sizeof (search
));
1716 h
->la25_stub
= stub
;
1717 return (use_trampoline_p
1718 ? mips_elf_add_la25_trampoline (stub
, info
)
1719 : mips_elf_add_la25_intro (stub
, info
));
1722 /* A mips_elf_link_hash_traverse callback that is called before sizing
1723 sections. DATA points to a mips_htab_traverse_info structure. */
1726 mips_elf_check_symbols (struct mips_elf_link_hash_entry
*h
, void *data
)
1728 struct mips_htab_traverse_info
*hti
;
1730 hti
= (struct mips_htab_traverse_info
*) data
;
1731 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1732 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1734 if (!hti
->info
->relocatable
)
1735 mips_elf_check_mips16_stubs (hti
->info
, h
);
1737 if (mips_elf_local_pic_function_p (h
))
1739 /* H is a function that might need $25 to be valid on entry.
1740 If we're creating a non-PIC relocatable object, mark H as
1741 being PIC. If we're creating a non-relocatable object with
1742 non-PIC branches and jumps to H, make sure that H has an la25
1744 if (hti
->info
->relocatable
)
1746 if (!PIC_OBJECT_P (hti
->output_bfd
))
1747 h
->root
.other
= ELF_ST_SET_MIPS_PIC (h
->root
.other
);
1749 else if (h
->has_nonpic_branches
&& !mips_elf_add_la25_stub (hti
->info
, h
))
1758 /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
1759 Most mips16 instructions are 16 bits, but these instructions
1762 The format of these instructions is:
1764 +--------------+--------------------------------+
1765 | JALX | X| Imm 20:16 | Imm 25:21 |
1766 +--------------+--------------------------------+
1768 +-----------------------------------------------+
1770 JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
1771 Note that the immediate value in the first word is swapped.
1773 When producing a relocatable object file, R_MIPS16_26 is
1774 handled mostly like R_MIPS_26. In particular, the addend is
1775 stored as a straight 26-bit value in a 32-bit instruction.
1776 (gas makes life simpler for itself by never adjusting a
1777 R_MIPS16_26 reloc to be against a section, so the addend is
1778 always zero). However, the 32 bit instruction is stored as 2
1779 16-bit values, rather than a single 32-bit value. In a
1780 big-endian file, the result is the same; in a little-endian
1781 file, the two 16-bit halves of the 32 bit value are swapped.
1782 This is so that a disassembler can recognize the jal
1785 When doing a final link, R_MIPS16_26 is treated as a 32 bit
1786 instruction stored as two 16-bit values. The addend A is the
1787 contents of the targ26 field. The calculation is the same as
1788 R_MIPS_26. When storing the calculated value, reorder the
1789 immediate value as shown above, and don't forget to store the
1790 value as two 16-bit values.
1792 To put it in MIPS ABI terms, the relocation field is T-targ26-16,
1796 +--------+----------------------+
1800 +--------+----------------------+
1803 +----------+------+-------------+
1807 +----------+--------------------+
1808 where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
1809 ((sub1 << 16) | sub2)).
1811 When producing a relocatable object file, the calculation is
1812 (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1813 When producing a fully linked file, the calculation is
1814 let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1815 ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)
1817 The table below lists the other MIPS16 instruction relocations.
1818 Each one is calculated in the same way as the non-MIPS16 relocation
1819 given on the right, but using the extended MIPS16 layout of 16-bit
1822 R_MIPS16_GPREL R_MIPS_GPREL16
1823 R_MIPS16_GOT16 R_MIPS_GOT16
1824 R_MIPS16_CALL16 R_MIPS_CALL16
1825 R_MIPS16_HI16 R_MIPS_HI16
1826 R_MIPS16_LO16 R_MIPS_LO16
1828 A typical instruction will have a format like this:
1830 +--------------+--------------------------------+
1831 | EXTEND | Imm 10:5 | Imm 15:11 |
1832 +--------------+--------------------------------+
1833 | Major | rx | ry | Imm 4:0 |
1834 +--------------+--------------------------------+
1836 EXTEND is the five bit value 11110. Major is the instruction
1839 All we need to do here is shuffle the bits appropriately.
1840 As above, the two 16-bit halves must be swapped on a
1841 little-endian system. */
1843 static inline bfd_boolean
1844 mips16_reloc_p (int r_type
)
1849 case R_MIPS16_GPREL
:
1850 case R_MIPS16_GOT16
:
1851 case R_MIPS16_CALL16
:
1861 static inline bfd_boolean
1862 got16_reloc_p (int r_type
)
1864 return r_type
== R_MIPS_GOT16
|| r_type
== R_MIPS16_GOT16
;
1867 static inline bfd_boolean
1868 call16_reloc_p (int r_type
)
1870 return r_type
== R_MIPS_CALL16
|| r_type
== R_MIPS16_CALL16
;
1873 static inline bfd_boolean
1874 hi16_reloc_p (int r_type
)
1876 return r_type
== R_MIPS_HI16
|| r_type
== R_MIPS16_HI16
;
1879 static inline bfd_boolean
1880 lo16_reloc_p (int r_type
)
1882 return r_type
== R_MIPS_LO16
|| r_type
== R_MIPS16_LO16
;
1885 static inline bfd_boolean
1886 mips16_call_reloc_p (int r_type
)
1888 return r_type
== R_MIPS16_26
|| r_type
== R_MIPS16_CALL16
;
1891 static inline bfd_boolean
1892 jal_reloc_p (int r_type
)
1894 return r_type
== R_MIPS_26
|| r_type
== R_MIPS16_26
;
1898 _bfd_mips16_elf_reloc_unshuffle (bfd
*abfd
, int r_type
,
1899 bfd_boolean jal_shuffle
, bfd_byte
*data
)
1901 bfd_vma extend
, insn
, val
;
1903 if (!mips16_reloc_p (r_type
))
1906 /* Pick up the mips16 extend instruction and the real instruction. */
1907 extend
= bfd_get_16 (abfd
, data
);
1908 insn
= bfd_get_16 (abfd
, data
+ 2);
1909 if (r_type
== R_MIPS16_26
)
1912 val
= ((extend
& 0xfc00) << 16) | ((extend
& 0x3e0) << 11)
1913 | ((extend
& 0x1f) << 21) | insn
;
1915 val
= extend
<< 16 | insn
;
1918 val
= ((extend
& 0xf800) << 16) | ((insn
& 0xffe0) << 11)
1919 | ((extend
& 0x1f) << 11) | (extend
& 0x7e0) | (insn
& 0x1f);
1920 bfd_put_32 (abfd
, val
, data
);
1924 _bfd_mips16_elf_reloc_shuffle (bfd
*abfd
, int r_type
,
1925 bfd_boolean jal_shuffle
, bfd_byte
*data
)
1927 bfd_vma extend
, insn
, val
;
1929 if (!mips16_reloc_p (r_type
))
1932 val
= bfd_get_32 (abfd
, data
);
1933 if (r_type
== R_MIPS16_26
)
1937 insn
= val
& 0xffff;
1938 extend
= ((val
>> 16) & 0xfc00) | ((val
>> 11) & 0x3e0)
1939 | ((val
>> 21) & 0x1f);
1943 insn
= val
& 0xffff;
1949 insn
= ((val
>> 11) & 0xffe0) | (val
& 0x1f);
1950 extend
= ((val
>> 16) & 0xf800) | ((val
>> 11) & 0x1f) | (val
& 0x7e0);
1952 bfd_put_16 (abfd
, insn
, data
+ 2);
1953 bfd_put_16 (abfd
, extend
, data
);
1956 bfd_reloc_status_type
1957 _bfd_mips_elf_gprel16_with_gp (bfd
*abfd
, asymbol
*symbol
,
1958 arelent
*reloc_entry
, asection
*input_section
,
1959 bfd_boolean relocatable
, void *data
, bfd_vma gp
)
1963 bfd_reloc_status_type status
;
1965 if (bfd_is_com_section (symbol
->section
))
1968 relocation
= symbol
->value
;
1970 relocation
+= symbol
->section
->output_section
->vma
;
1971 relocation
+= symbol
->section
->output_offset
;
1973 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1974 return bfd_reloc_outofrange
;
1976 /* Set val to the offset into the section or symbol. */
1977 val
= reloc_entry
->addend
;
1979 _bfd_mips_elf_sign_extend (val
, 16);
1981 /* Adjust val for the final section location and GP value. If we
1982 are producing relocatable output, we don't want to do this for
1983 an external symbol. */
1985 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
1986 val
+= relocation
- gp
;
1988 if (reloc_entry
->howto
->partial_inplace
)
1990 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
1992 + reloc_entry
->address
);
1993 if (status
!= bfd_reloc_ok
)
1997 reloc_entry
->addend
= val
;
2000 reloc_entry
->address
+= input_section
->output_offset
;
2002 return bfd_reloc_ok
;
2005 /* Used to store a REL high-part relocation such as R_MIPS_HI16 or
2006 R_MIPS_GOT16. REL is the relocation, INPUT_SECTION is the section
2007 that contains the relocation field and DATA points to the start of
2012 struct mips_hi16
*next
;
2014 asection
*input_section
;
2018 /* FIXME: This should not be a static variable. */
2020 static struct mips_hi16
*mips_hi16_list
;
2022 /* A howto special_function for REL *HI16 relocations. We can only
2023 calculate the correct value once we've seen the partnering
2024 *LO16 relocation, so just save the information for later.
2026 The ABI requires that the *LO16 immediately follow the *HI16.
2027 However, as a GNU extension, we permit an arbitrary number of
2028 *HI16s to be associated with a single *LO16. This significantly
2029 simplies the relocation handling in gcc. */
2031 bfd_reloc_status_type
2032 _bfd_mips_elf_hi16_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
2033 asymbol
*symbol ATTRIBUTE_UNUSED
, void *data
,
2034 asection
*input_section
, bfd
*output_bfd
,
2035 char **error_message ATTRIBUTE_UNUSED
)
2037 struct mips_hi16
*n
;
2039 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
2040 return bfd_reloc_outofrange
;
2042 n
= bfd_malloc (sizeof *n
);
2044 return bfd_reloc_outofrange
;
2046 n
->next
= mips_hi16_list
;
2048 n
->input_section
= input_section
;
2049 n
->rel
= *reloc_entry
;
2052 if (output_bfd
!= NULL
)
2053 reloc_entry
->address
+= input_section
->output_offset
;
2055 return bfd_reloc_ok
;
2058 /* A howto special_function for REL R_MIPS*_GOT16 relocations. This is just
2059 like any other 16-bit relocation when applied to global symbols, but is
2060 treated in the same as R_MIPS_HI16 when applied to local symbols. */
2062 bfd_reloc_status_type
2063 _bfd_mips_elf_got16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
2064 void *data
, asection
*input_section
,
2065 bfd
*output_bfd
, char **error_message
)
2067 if ((symbol
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
2068 || bfd_is_und_section (bfd_get_section (symbol
))
2069 || bfd_is_com_section (bfd_get_section (symbol
)))
2070 /* The relocation is against a global symbol. */
2071 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
2072 input_section
, output_bfd
,
2075 return _bfd_mips_elf_hi16_reloc (abfd
, reloc_entry
, symbol
, data
,
2076 input_section
, output_bfd
, error_message
);
2079 /* A howto special_function for REL *LO16 relocations. The *LO16 itself
2080 is a straightforward 16 bit inplace relocation, but we must deal with
2081 any partnering high-part relocations as well. */
2083 bfd_reloc_status_type
2084 _bfd_mips_elf_lo16_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
2085 void *data
, asection
*input_section
,
2086 bfd
*output_bfd
, char **error_message
)
2089 bfd_byte
*location
= (bfd_byte
*) data
+ reloc_entry
->address
;
2091 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
2092 return bfd_reloc_outofrange
;
2094 _bfd_mips16_elf_reloc_unshuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
2096 vallo
= bfd_get_32 (abfd
, location
);
2097 _bfd_mips16_elf_reloc_shuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
2100 while (mips_hi16_list
!= NULL
)
2102 bfd_reloc_status_type ret
;
2103 struct mips_hi16
*hi
;
2105 hi
= mips_hi16_list
;
2107 /* R_MIPS*_GOT16 relocations are something of a special case. We
2108 want to install the addend in the same way as for a R_MIPS*_HI16
2109 relocation (with a rightshift of 16). However, since GOT16
2110 relocations can also be used with global symbols, their howto
2111 has a rightshift of 0. */
2112 if (hi
->rel
.howto
->type
== R_MIPS_GOT16
)
2113 hi
->rel
.howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, R_MIPS_HI16
, FALSE
);
2114 else if (hi
->rel
.howto
->type
== R_MIPS16_GOT16
)
2115 hi
->rel
.howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, R_MIPS16_HI16
, FALSE
);
2117 /* VALLO is a signed 16-bit number. Bias it by 0x8000 so that any
2118 carry or borrow will induce a change of +1 or -1 in the high part. */
2119 hi
->rel
.addend
+= (vallo
+ 0x8000) & 0xffff;
2121 ret
= _bfd_mips_elf_generic_reloc (abfd
, &hi
->rel
, symbol
, hi
->data
,
2122 hi
->input_section
, output_bfd
,
2124 if (ret
!= bfd_reloc_ok
)
2127 mips_hi16_list
= hi
->next
;
2131 return _bfd_mips_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
2132 input_section
, output_bfd
,
2136 /* A generic howto special_function. This calculates and installs the
2137 relocation itself, thus avoiding the oft-discussed problems in
2138 bfd_perform_relocation and bfd_install_relocation. */
2140 bfd_reloc_status_type
2141 _bfd_mips_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc_entry
,
2142 asymbol
*symbol
, void *data ATTRIBUTE_UNUSED
,
2143 asection
*input_section
, bfd
*output_bfd
,
2144 char **error_message ATTRIBUTE_UNUSED
)
2147 bfd_reloc_status_type status
;
2148 bfd_boolean relocatable
;
2150 relocatable
= (output_bfd
!= NULL
);
2152 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
2153 return bfd_reloc_outofrange
;
2155 /* Build up the field adjustment in VAL. */
2157 if (!relocatable
|| (symbol
->flags
& BSF_SECTION_SYM
) != 0)
2159 /* Either we're calculating the final field value or we have a
2160 relocation against a section symbol. Add in the section's
2161 offset or address. */
2162 val
+= symbol
->section
->output_section
->vma
;
2163 val
+= symbol
->section
->output_offset
;
2168 /* We're calculating the final field value. Add in the symbol's value
2169 and, if pc-relative, subtract the address of the field itself. */
2170 val
+= symbol
->value
;
2171 if (reloc_entry
->howto
->pc_relative
)
2173 val
-= input_section
->output_section
->vma
;
2174 val
-= input_section
->output_offset
;
2175 val
-= reloc_entry
->address
;
2179 /* VAL is now the final adjustment. If we're keeping this relocation
2180 in the output file, and if the relocation uses a separate addend,
2181 we just need to add VAL to that addend. Otherwise we need to add
2182 VAL to the relocation field itself. */
2183 if (relocatable
&& !reloc_entry
->howto
->partial_inplace
)
2184 reloc_entry
->addend
+= val
;
2187 bfd_byte
*location
= (bfd_byte
*) data
+ reloc_entry
->address
;
2189 /* Add in the separate addend, if any. */
2190 val
+= reloc_entry
->addend
;
2192 /* Add VAL to the relocation field. */
2193 _bfd_mips16_elf_reloc_unshuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
2195 status
= _bfd_relocate_contents (reloc_entry
->howto
, abfd
, val
,
2197 _bfd_mips16_elf_reloc_shuffle (abfd
, reloc_entry
->howto
->type
, FALSE
,
2200 if (status
!= bfd_reloc_ok
)
2205 reloc_entry
->address
+= input_section
->output_offset
;
2207 return bfd_reloc_ok
;
2210 /* Swap an entry in a .gptab section. Note that these routines rely
2211 on the equivalence of the two elements of the union. */
2214 bfd_mips_elf32_swap_gptab_in (bfd
*abfd
, const Elf32_External_gptab
*ex
,
2217 in
->gt_entry
.gt_g_value
= H_GET_32 (abfd
, ex
->gt_entry
.gt_g_value
);
2218 in
->gt_entry
.gt_bytes
= H_GET_32 (abfd
, ex
->gt_entry
.gt_bytes
);
2222 bfd_mips_elf32_swap_gptab_out (bfd
*abfd
, const Elf32_gptab
*in
,
2223 Elf32_External_gptab
*ex
)
2225 H_PUT_32 (abfd
, in
->gt_entry
.gt_g_value
, ex
->gt_entry
.gt_g_value
);
2226 H_PUT_32 (abfd
, in
->gt_entry
.gt_bytes
, ex
->gt_entry
.gt_bytes
);
2230 bfd_elf32_swap_compact_rel_out (bfd
*abfd
, const Elf32_compact_rel
*in
,
2231 Elf32_External_compact_rel
*ex
)
2233 H_PUT_32 (abfd
, in
->id1
, ex
->id1
);
2234 H_PUT_32 (abfd
, in
->num
, ex
->num
);
2235 H_PUT_32 (abfd
, in
->id2
, ex
->id2
);
2236 H_PUT_32 (abfd
, in
->offset
, ex
->offset
);
2237 H_PUT_32 (abfd
, in
->reserved0
, ex
->reserved0
);
2238 H_PUT_32 (abfd
, in
->reserved1
, ex
->reserved1
);
2242 bfd_elf32_swap_crinfo_out (bfd
*abfd
, const Elf32_crinfo
*in
,
2243 Elf32_External_crinfo
*ex
)
2247 l
= (((in
->ctype
& CRINFO_CTYPE
) << CRINFO_CTYPE_SH
)
2248 | ((in
->rtype
& CRINFO_RTYPE
) << CRINFO_RTYPE_SH
)
2249 | ((in
->dist2to
& CRINFO_DIST2TO
) << CRINFO_DIST2TO_SH
)
2250 | ((in
->relvaddr
& CRINFO_RELVADDR
) << CRINFO_RELVADDR_SH
));
2251 H_PUT_32 (abfd
, l
, ex
->info
);
2252 H_PUT_32 (abfd
, in
->konst
, ex
->konst
);
2253 H_PUT_32 (abfd
, in
->vaddr
, ex
->vaddr
);
2256 /* A .reginfo section holds a single Elf32_RegInfo structure. These
2257 routines swap this structure in and out. They are used outside of
2258 BFD, so they are globally visible. */
2261 bfd_mips_elf32_swap_reginfo_in (bfd
*abfd
, const Elf32_External_RegInfo
*ex
,
2264 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
2265 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
2266 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
2267 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
2268 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
2269 in
->ri_gp_value
= H_GET_32 (abfd
, ex
->ri_gp_value
);
2273 bfd_mips_elf32_swap_reginfo_out (bfd
*abfd
, const Elf32_RegInfo
*in
,
2274 Elf32_External_RegInfo
*ex
)
2276 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
2277 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
2278 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
2279 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
2280 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
2281 H_PUT_32 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
2284 /* In the 64 bit ABI, the .MIPS.options section holds register
2285 information in an Elf64_Reginfo structure. These routines swap
2286 them in and out. They are globally visible because they are used
2287 outside of BFD. These routines are here so that gas can call them
2288 without worrying about whether the 64 bit ABI has been included. */
2291 bfd_mips_elf64_swap_reginfo_in (bfd
*abfd
, const Elf64_External_RegInfo
*ex
,
2292 Elf64_Internal_RegInfo
*in
)
2294 in
->ri_gprmask
= H_GET_32 (abfd
, ex
->ri_gprmask
);
2295 in
->ri_pad
= H_GET_32 (abfd
, ex
->ri_pad
);
2296 in
->ri_cprmask
[0] = H_GET_32 (abfd
, ex
->ri_cprmask
[0]);
2297 in
->ri_cprmask
[1] = H_GET_32 (abfd
, ex
->ri_cprmask
[1]);
2298 in
->ri_cprmask
[2] = H_GET_32 (abfd
, ex
->ri_cprmask
[2]);
2299 in
->ri_cprmask
[3] = H_GET_32 (abfd
, ex
->ri_cprmask
[3]);
2300 in
->ri_gp_value
= H_GET_64 (abfd
, ex
->ri_gp_value
);
2304 bfd_mips_elf64_swap_reginfo_out (bfd
*abfd
, const Elf64_Internal_RegInfo
*in
,
2305 Elf64_External_RegInfo
*ex
)
2307 H_PUT_32 (abfd
, in
->ri_gprmask
, ex
->ri_gprmask
);
2308 H_PUT_32 (abfd
, in
->ri_pad
, ex
->ri_pad
);
2309 H_PUT_32 (abfd
, in
->ri_cprmask
[0], ex
->ri_cprmask
[0]);
2310 H_PUT_32 (abfd
, in
->ri_cprmask
[1], ex
->ri_cprmask
[1]);
2311 H_PUT_32 (abfd
, in
->ri_cprmask
[2], ex
->ri_cprmask
[2]);
2312 H_PUT_32 (abfd
, in
->ri_cprmask
[3], ex
->ri_cprmask
[3]);
2313 H_PUT_64 (abfd
, in
->ri_gp_value
, ex
->ri_gp_value
);
2316 /* Swap in an options header. */
2319 bfd_mips_elf_swap_options_in (bfd
*abfd
, const Elf_External_Options
*ex
,
2320 Elf_Internal_Options
*in
)
2322 in
->kind
= H_GET_8 (abfd
, ex
->kind
);
2323 in
->size
= H_GET_8 (abfd
, ex
->size
);
2324 in
->section
= H_GET_16 (abfd
, ex
->section
);
2325 in
->info
= H_GET_32 (abfd
, ex
->info
);
2328 /* Swap out an options header. */
2331 bfd_mips_elf_swap_options_out (bfd
*abfd
, const Elf_Internal_Options
*in
,
2332 Elf_External_Options
*ex
)
2334 H_PUT_8 (abfd
, in
->kind
, ex
->kind
);
2335 H_PUT_8 (abfd
, in
->size
, ex
->size
);
2336 H_PUT_16 (abfd
, in
->section
, ex
->section
);
2337 H_PUT_32 (abfd
, in
->info
, ex
->info
);
2340 /* This function is called via qsort() to sort the dynamic relocation
2341 entries by increasing r_symndx value. */
2344 sort_dynamic_relocs (const void *arg1
, const void *arg2
)
2346 Elf_Internal_Rela int_reloc1
;
2347 Elf_Internal_Rela int_reloc2
;
2350 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg1
, &int_reloc1
);
2351 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg2
, &int_reloc2
);
2353 diff
= ELF32_R_SYM (int_reloc1
.r_info
) - ELF32_R_SYM (int_reloc2
.r_info
);
2357 if (int_reloc1
.r_offset
< int_reloc2
.r_offset
)
2359 if (int_reloc1
.r_offset
> int_reloc2
.r_offset
)
2364 /* Like sort_dynamic_relocs, but used for elf64 relocations. */
2367 sort_dynamic_relocs_64 (const void *arg1 ATTRIBUTE_UNUSED
,
2368 const void *arg2 ATTRIBUTE_UNUSED
)
2371 Elf_Internal_Rela int_reloc1
[3];
2372 Elf_Internal_Rela int_reloc2
[3];
2374 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
2375 (reldyn_sorting_bfd
, arg1
, int_reloc1
);
2376 (*get_elf_backend_data (reldyn_sorting_bfd
)->s
->swap_reloc_in
)
2377 (reldyn_sorting_bfd
, arg2
, int_reloc2
);
2379 if (ELF64_R_SYM (int_reloc1
[0].r_info
) < ELF64_R_SYM (int_reloc2
[0].r_info
))
2381 if (ELF64_R_SYM (int_reloc1
[0].r_info
) > ELF64_R_SYM (int_reloc2
[0].r_info
))
2384 if (int_reloc1
[0].r_offset
< int_reloc2
[0].r_offset
)
2386 if (int_reloc1
[0].r_offset
> int_reloc2
[0].r_offset
)
2395 /* This routine is used to write out ECOFF debugging external symbol
2396 information. It is called via mips_elf_link_hash_traverse. The
2397 ECOFF external symbol information must match the ELF external
2398 symbol information. Unfortunately, at this point we don't know
2399 whether a symbol is required by reloc information, so the two
2400 tables may wind up being different. We must sort out the external
2401 symbol information before we can set the final size of the .mdebug
2402 section, and we must set the size of the .mdebug section before we
2403 can relocate any sections, and we can't know which symbols are
2404 required by relocation until we relocate the sections.
2405 Fortunately, it is relatively unlikely that any symbol will be
2406 stripped but required by a reloc. In particular, it can not happen
2407 when generating a final executable. */
2410 mips_elf_output_extsym (struct mips_elf_link_hash_entry
*h
, void *data
)
2412 struct extsym_info
*einfo
= data
;
2414 asection
*sec
, *output_section
;
2416 if (h
->root
.root
.type
== bfd_link_hash_warning
)
2417 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2419 if (h
->root
.indx
== -2)
2421 else if ((h
->root
.def_dynamic
2422 || h
->root
.ref_dynamic
2423 || h
->root
.type
== bfd_link_hash_new
)
2424 && !h
->root
.def_regular
2425 && !h
->root
.ref_regular
)
2427 else if (einfo
->info
->strip
== strip_all
2428 || (einfo
->info
->strip
== strip_some
2429 && bfd_hash_lookup (einfo
->info
->keep_hash
,
2430 h
->root
.root
.root
.string
,
2431 FALSE
, FALSE
) == NULL
))
2439 if (h
->esym
.ifd
== -2)
2442 h
->esym
.cobol_main
= 0;
2443 h
->esym
.weakext
= 0;
2444 h
->esym
.reserved
= 0;
2445 h
->esym
.ifd
= ifdNil
;
2446 h
->esym
.asym
.value
= 0;
2447 h
->esym
.asym
.st
= stGlobal
;
2449 if (h
->root
.root
.type
== bfd_link_hash_undefined
2450 || h
->root
.root
.type
== bfd_link_hash_undefweak
)
2454 /* Use undefined class. Also, set class and type for some
2456 name
= h
->root
.root
.root
.string
;
2457 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
2458 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
2460 h
->esym
.asym
.sc
= scData
;
2461 h
->esym
.asym
.st
= stLabel
;
2462 h
->esym
.asym
.value
= 0;
2464 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
2466 h
->esym
.asym
.sc
= scAbs
;
2467 h
->esym
.asym
.st
= stLabel
;
2468 h
->esym
.asym
.value
=
2469 mips_elf_hash_table (einfo
->info
)->procedure_count
;
2471 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (einfo
->abfd
))
2473 h
->esym
.asym
.sc
= scAbs
;
2474 h
->esym
.asym
.st
= stLabel
;
2475 h
->esym
.asym
.value
= elf_gp (einfo
->abfd
);
2478 h
->esym
.asym
.sc
= scUndefined
;
2480 else if (h
->root
.root
.type
!= bfd_link_hash_defined
2481 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
2482 h
->esym
.asym
.sc
= scAbs
;
2487 sec
= h
->root
.root
.u
.def
.section
;
2488 output_section
= sec
->output_section
;
2490 /* When making a shared library and symbol h is the one from
2491 the another shared library, OUTPUT_SECTION may be null. */
2492 if (output_section
== NULL
)
2493 h
->esym
.asym
.sc
= scUndefined
;
2496 name
= bfd_section_name (output_section
->owner
, output_section
);
2498 if (strcmp (name
, ".text") == 0)
2499 h
->esym
.asym
.sc
= scText
;
2500 else if (strcmp (name
, ".data") == 0)
2501 h
->esym
.asym
.sc
= scData
;
2502 else if (strcmp (name
, ".sdata") == 0)
2503 h
->esym
.asym
.sc
= scSData
;
2504 else if (strcmp (name
, ".rodata") == 0
2505 || strcmp (name
, ".rdata") == 0)
2506 h
->esym
.asym
.sc
= scRData
;
2507 else if (strcmp (name
, ".bss") == 0)
2508 h
->esym
.asym
.sc
= scBss
;
2509 else if (strcmp (name
, ".sbss") == 0)
2510 h
->esym
.asym
.sc
= scSBss
;
2511 else if (strcmp (name
, ".init") == 0)
2512 h
->esym
.asym
.sc
= scInit
;
2513 else if (strcmp (name
, ".fini") == 0)
2514 h
->esym
.asym
.sc
= scFini
;
2516 h
->esym
.asym
.sc
= scAbs
;
2520 h
->esym
.asym
.reserved
= 0;
2521 h
->esym
.asym
.index
= indexNil
;
2524 if (h
->root
.root
.type
== bfd_link_hash_common
)
2525 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
2526 else if (h
->root
.root
.type
== bfd_link_hash_defined
2527 || h
->root
.root
.type
== bfd_link_hash_defweak
)
2529 if (h
->esym
.asym
.sc
== scCommon
)
2530 h
->esym
.asym
.sc
= scBss
;
2531 else if (h
->esym
.asym
.sc
== scSCommon
)
2532 h
->esym
.asym
.sc
= scSBss
;
2534 sec
= h
->root
.root
.u
.def
.section
;
2535 output_section
= sec
->output_section
;
2536 if (output_section
!= NULL
)
2537 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
2538 + sec
->output_offset
2539 + output_section
->vma
);
2541 h
->esym
.asym
.value
= 0;
2545 struct mips_elf_link_hash_entry
*hd
= h
;
2547 while (hd
->root
.root
.type
== bfd_link_hash_indirect
)
2548 hd
= (struct mips_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
2550 if (hd
->needs_lazy_stub
)
2552 /* Set type and value for a symbol with a function stub. */
2553 h
->esym
.asym
.st
= stProc
;
2554 sec
= hd
->root
.root
.u
.def
.section
;
2556 h
->esym
.asym
.value
= 0;
2559 output_section
= sec
->output_section
;
2560 if (output_section
!= NULL
)
2561 h
->esym
.asym
.value
= (hd
->root
.plt
.offset
2562 + sec
->output_offset
2563 + output_section
->vma
);
2565 h
->esym
.asym
.value
= 0;
2570 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
2571 h
->root
.root
.root
.string
,
2574 einfo
->failed
= TRUE
;
2581 /* A comparison routine used to sort .gptab entries. */
2584 gptab_compare (const void *p1
, const void *p2
)
2586 const Elf32_gptab
*a1
= p1
;
2587 const Elf32_gptab
*a2
= p2
;
2589 return a1
->gt_entry
.gt_g_value
- a2
->gt_entry
.gt_g_value
;
2592 /* Functions to manage the got entry hash table. */
2594 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
2597 static INLINE hashval_t
2598 mips_elf_hash_bfd_vma (bfd_vma addr
)
2601 return addr
+ (addr
>> 32);
2607 /* got_entries only match if they're identical, except for gotidx, so
2608 use all fields to compute the hash, and compare the appropriate
2612 mips_elf_got_entry_hash (const void *entry_
)
2614 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
2616 return entry
->symndx
2617 + ((entry
->tls_type
& GOT_TLS_LDM
) << 17)
2618 + (! entry
->abfd
? mips_elf_hash_bfd_vma (entry
->d
.address
)
2620 + (entry
->symndx
>= 0 ? mips_elf_hash_bfd_vma (entry
->d
.addend
)
2621 : entry
->d
.h
->root
.root
.root
.hash
));
2625 mips_elf_got_entry_eq (const void *entry1
, const void *entry2
)
2627 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
2628 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
2630 /* An LDM entry can only match another LDM entry. */
2631 if ((e1
->tls_type
^ e2
->tls_type
) & GOT_TLS_LDM
)
2634 return e1
->abfd
== e2
->abfd
&& e1
->symndx
== e2
->symndx
2635 && (! e1
->abfd
? e1
->d
.address
== e2
->d
.address
2636 : e1
->symndx
>= 0 ? e1
->d
.addend
== e2
->d
.addend
2637 : e1
->d
.h
== e2
->d
.h
);
2640 /* multi_got_entries are still a match in the case of global objects,
2641 even if the input bfd in which they're referenced differs, so the
2642 hash computation and compare functions are adjusted
2646 mips_elf_multi_got_entry_hash (const void *entry_
)
2648 const struct mips_got_entry
*entry
= (struct mips_got_entry
*)entry_
;
2650 return entry
->symndx
2652 ? mips_elf_hash_bfd_vma (entry
->d
.address
)
2653 : entry
->symndx
>= 0
2654 ? ((entry
->tls_type
& GOT_TLS_LDM
)
2655 ? (GOT_TLS_LDM
<< 17)
2657 + mips_elf_hash_bfd_vma (entry
->d
.addend
)))
2658 : entry
->d
.h
->root
.root
.root
.hash
);
2662 mips_elf_multi_got_entry_eq (const void *entry1
, const void *entry2
)
2664 const struct mips_got_entry
*e1
= (struct mips_got_entry
*)entry1
;
2665 const struct mips_got_entry
*e2
= (struct mips_got_entry
*)entry2
;
2667 /* Any two LDM entries match. */
2668 if (e1
->tls_type
& e2
->tls_type
& GOT_TLS_LDM
)
2671 /* Nothing else matches an LDM entry. */
2672 if ((e1
->tls_type
^ e2
->tls_type
) & GOT_TLS_LDM
)
2675 return e1
->symndx
== e2
->symndx
2676 && (e1
->symndx
>= 0 ? e1
->abfd
== e2
->abfd
&& e1
->d
.addend
== e2
->d
.addend
2677 : e1
->abfd
== NULL
|| e2
->abfd
== NULL
2678 ? e1
->abfd
== e2
->abfd
&& e1
->d
.address
== e2
->d
.address
2679 : e1
->d
.h
== e2
->d
.h
);
2683 mips_got_page_entry_hash (const void *entry_
)
2685 const struct mips_got_page_entry
*entry
;
2687 entry
= (const struct mips_got_page_entry
*) entry_
;
2688 return entry
->abfd
->id
+ entry
->symndx
;
2692 mips_got_page_entry_eq (const void *entry1_
, const void *entry2_
)
2694 const struct mips_got_page_entry
*entry1
, *entry2
;
2696 entry1
= (const struct mips_got_page_entry
*) entry1_
;
2697 entry2
= (const struct mips_got_page_entry
*) entry2_
;
2698 return entry1
->abfd
== entry2
->abfd
&& entry1
->symndx
== entry2
->symndx
;
2701 /* Return the dynamic relocation section. If it doesn't exist, try to
2702 create a new it if CREATE_P, otherwise return NULL. Also return NULL
2703 if creation fails. */
2706 mips_elf_rel_dyn_section (struct bfd_link_info
*info
, bfd_boolean create_p
)
2712 dname
= MIPS_ELF_REL_DYN_NAME (info
);
2713 dynobj
= elf_hash_table (info
)->dynobj
;
2714 sreloc
= bfd_get_section_by_name (dynobj
, dname
);
2715 if (sreloc
== NULL
&& create_p
)
2717 sreloc
= bfd_make_section_with_flags (dynobj
, dname
,
2722 | SEC_LINKER_CREATED
2725 || ! bfd_set_section_alignment (dynobj
, sreloc
,
2726 MIPS_ELF_LOG_FILE_ALIGN (dynobj
)))
2732 /* Count the number of relocations needed for a TLS GOT entry, with
2733 access types from TLS_TYPE, and symbol H (or a local symbol if H
2737 mips_tls_got_relocs (struct bfd_link_info
*info
, unsigned char tls_type
,
2738 struct elf_link_hash_entry
*h
)
2742 bfd_boolean need_relocs
= FALSE
;
2743 bfd_boolean dyn
= elf_hash_table (info
)->dynamic_sections_created
;
2745 if (h
&& WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
2746 && (!info
->shared
|| !SYMBOL_REFERENCES_LOCAL (info
, h
)))
2749 if ((info
->shared
|| indx
!= 0)
2751 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2752 || h
->root
.type
!= bfd_link_hash_undefweak
))
2758 if (tls_type
& GOT_TLS_GD
)
2765 if (tls_type
& GOT_TLS_IE
)
2768 if ((tls_type
& GOT_TLS_LDM
) && info
->shared
)
2774 /* Count the number of TLS relocations required for the GOT entry in
2775 ARG1, if it describes a local symbol. */
2778 mips_elf_count_local_tls_relocs (void **arg1
, void *arg2
)
2780 struct mips_got_entry
*entry
= * (struct mips_got_entry
**) arg1
;
2781 struct mips_elf_count_tls_arg
*arg
= arg2
;
2783 if (entry
->abfd
!= NULL
&& entry
->symndx
!= -1)
2784 arg
->needed
+= mips_tls_got_relocs (arg
->info
, entry
->tls_type
, NULL
);
2789 /* Count the number of TLS GOT entries required for the global (or
2790 forced-local) symbol in ARG1. */
2793 mips_elf_count_global_tls_entries (void *arg1
, void *arg2
)
2795 struct mips_elf_link_hash_entry
*hm
2796 = (struct mips_elf_link_hash_entry
*) arg1
;
2797 struct mips_elf_count_tls_arg
*arg
= arg2
;
2799 if (hm
->tls_type
& GOT_TLS_GD
)
2801 if (hm
->tls_type
& GOT_TLS_IE
)
2807 /* Count the number of TLS relocations required for the global (or
2808 forced-local) symbol in ARG1. */
2811 mips_elf_count_global_tls_relocs (void *arg1
, void *arg2
)
2813 struct mips_elf_link_hash_entry
*hm
2814 = (struct mips_elf_link_hash_entry
*) arg1
;
2815 struct mips_elf_count_tls_arg
*arg
= arg2
;
2817 arg
->needed
+= mips_tls_got_relocs (arg
->info
, hm
->tls_type
, &hm
->root
);
2822 /* Output a simple dynamic relocation into SRELOC. */
2825 mips_elf_output_dynamic_relocation (bfd
*output_bfd
,
2827 unsigned long reloc_index
,
2832 Elf_Internal_Rela rel
[3];
2834 memset (rel
, 0, sizeof (rel
));
2836 rel
[0].r_info
= ELF_R_INFO (output_bfd
, indx
, r_type
);
2837 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
2839 if (ABI_64_P (output_bfd
))
2841 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
2842 (output_bfd
, &rel
[0],
2844 + reloc_index
* sizeof (Elf64_Mips_External_Rel
)));
2847 bfd_elf32_swap_reloc_out
2848 (output_bfd
, &rel
[0],
2850 + reloc_index
* sizeof (Elf32_External_Rel
)));
2853 /* Initialize a set of TLS GOT entries for one symbol. */
2856 mips_elf_initialize_tls_slots (bfd
*abfd
, bfd_vma got_offset
,
2857 unsigned char *tls_type_p
,
2858 struct bfd_link_info
*info
,
2859 struct mips_elf_link_hash_entry
*h
,
2862 struct mips_elf_link_hash_table
*htab
;
2864 asection
*sreloc
, *sgot
;
2865 bfd_vma offset
, offset2
;
2866 bfd_boolean need_relocs
= FALSE
;
2868 htab
= mips_elf_hash_table (info
);
2877 bfd_boolean dyn
= elf_hash_table (info
)->dynamic_sections_created
;
2879 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, &h
->root
)
2880 && (!info
->shared
|| !SYMBOL_REFERENCES_LOCAL (info
, &h
->root
)))
2881 indx
= h
->root
.dynindx
;
2884 if (*tls_type_p
& GOT_TLS_DONE
)
2887 if ((info
->shared
|| indx
!= 0)
2889 || ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
2890 || h
->root
.type
!= bfd_link_hash_undefweak
))
2893 /* MINUS_ONE means the symbol is not defined in this object. It may not
2894 be defined at all; assume that the value doesn't matter in that
2895 case. Otherwise complain if we would use the value. */
2896 BFD_ASSERT (value
!= MINUS_ONE
|| (indx
!= 0 && need_relocs
)
2897 || h
->root
.root
.type
== bfd_link_hash_undefweak
);
2899 /* Emit necessary relocations. */
2900 sreloc
= mips_elf_rel_dyn_section (info
, FALSE
);
2902 /* General Dynamic. */
2903 if (*tls_type_p
& GOT_TLS_GD
)
2905 offset
= got_offset
;
2906 offset2
= offset
+ MIPS_ELF_GOT_SIZE (abfd
);
2910 mips_elf_output_dynamic_relocation
2911 (abfd
, sreloc
, sreloc
->reloc_count
++, indx
,
2912 ABI_64_P (abfd
) ? R_MIPS_TLS_DTPMOD64
: R_MIPS_TLS_DTPMOD32
,
2913 sgot
->output_offset
+ sgot
->output_section
->vma
+ offset
);
2916 mips_elf_output_dynamic_relocation
2917 (abfd
, sreloc
, sreloc
->reloc_count
++, indx
,
2918 ABI_64_P (abfd
) ? R_MIPS_TLS_DTPREL64
: R_MIPS_TLS_DTPREL32
,
2919 sgot
->output_offset
+ sgot
->output_section
->vma
+ offset2
);
2921 MIPS_ELF_PUT_WORD (abfd
, value
- dtprel_base (info
),
2922 sgot
->contents
+ offset2
);
2926 MIPS_ELF_PUT_WORD (abfd
, 1,
2927 sgot
->contents
+ offset
);
2928 MIPS_ELF_PUT_WORD (abfd
, value
- dtprel_base (info
),
2929 sgot
->contents
+ offset2
);
2932 got_offset
+= 2 * MIPS_ELF_GOT_SIZE (abfd
);
2935 /* Initial Exec model. */
2936 if (*tls_type_p
& GOT_TLS_IE
)
2938 offset
= got_offset
;
2943 MIPS_ELF_PUT_WORD (abfd
, value
- elf_hash_table (info
)->tls_sec
->vma
,
2944 sgot
->contents
+ offset
);
2946 MIPS_ELF_PUT_WORD (abfd
, 0,
2947 sgot
->contents
+ offset
);
2949 mips_elf_output_dynamic_relocation
2950 (abfd
, sreloc
, sreloc
->reloc_count
++, indx
,
2951 ABI_64_P (abfd
) ? R_MIPS_TLS_TPREL64
: R_MIPS_TLS_TPREL32
,
2952 sgot
->output_offset
+ sgot
->output_section
->vma
+ offset
);
2955 MIPS_ELF_PUT_WORD (abfd
, value
- tprel_base (info
),
2956 sgot
->contents
+ offset
);
2959 if (*tls_type_p
& GOT_TLS_LDM
)
2961 /* The initial offset is zero, and the LD offsets will include the
2962 bias by DTP_OFFSET. */
2963 MIPS_ELF_PUT_WORD (abfd
, 0,
2964 sgot
->contents
+ got_offset
2965 + MIPS_ELF_GOT_SIZE (abfd
));
2968 MIPS_ELF_PUT_WORD (abfd
, 1,
2969 sgot
->contents
+ got_offset
);
2971 mips_elf_output_dynamic_relocation
2972 (abfd
, sreloc
, sreloc
->reloc_count
++, indx
,
2973 ABI_64_P (abfd
) ? R_MIPS_TLS_DTPMOD64
: R_MIPS_TLS_DTPMOD32
,
2974 sgot
->output_offset
+ sgot
->output_section
->vma
+ got_offset
);
2977 *tls_type_p
|= GOT_TLS_DONE
;
2980 /* Return the GOT index to use for a relocation of type R_TYPE against
2981 a symbol accessed using TLS_TYPE models. The GOT entries for this
2982 symbol in this GOT start at GOT_INDEX. This function initializes the
2983 GOT entries and corresponding relocations. */
2986 mips_tls_got_index (bfd
*abfd
, bfd_vma got_index
, unsigned char *tls_type
,
2987 int r_type
, struct bfd_link_info
*info
,
2988 struct mips_elf_link_hash_entry
*h
, bfd_vma symbol
)
2990 BFD_ASSERT (r_type
== R_MIPS_TLS_GOTTPREL
|| r_type
== R_MIPS_TLS_GD
2991 || r_type
== R_MIPS_TLS_LDM
);
2993 mips_elf_initialize_tls_slots (abfd
, got_index
, tls_type
, info
, h
, symbol
);
2995 if (r_type
== R_MIPS_TLS_GOTTPREL
)
2997 BFD_ASSERT (*tls_type
& GOT_TLS_IE
);
2998 if (*tls_type
& GOT_TLS_GD
)
2999 return got_index
+ 2 * MIPS_ELF_GOT_SIZE (abfd
);
3004 if (r_type
== R_MIPS_TLS_GD
)
3006 BFD_ASSERT (*tls_type
& GOT_TLS_GD
);
3010 if (r_type
== R_MIPS_TLS_LDM
)
3012 BFD_ASSERT (*tls_type
& GOT_TLS_LDM
);
3019 /* Return the offset from _GLOBAL_OFFSET_TABLE_ of the .got.plt entry
3020 for global symbol H. .got.plt comes before the GOT, so the offset
3021 will be negative. */
3024 mips_elf_gotplt_index (struct bfd_link_info
*info
,
3025 struct elf_link_hash_entry
*h
)
3027 bfd_vma plt_index
, got_address
, got_value
;
3028 struct mips_elf_link_hash_table
*htab
;
3030 htab
= mips_elf_hash_table (info
);
3031 BFD_ASSERT (htab
!= NULL
);
3033 BFD_ASSERT (h
->plt
.offset
!= (bfd_vma
) -1);
3035 /* This function only works for VxWorks, because a non-VxWorks .got.plt
3036 section starts with reserved entries. */
3037 BFD_ASSERT (htab
->is_vxworks
);
3039 /* Calculate the index of the symbol's PLT entry. */
3040 plt_index
= (h
->plt
.offset
- htab
->plt_header_size
) / htab
->plt_entry_size
;
3042 /* Calculate the address of the associated .got.plt entry. */
3043 got_address
= (htab
->sgotplt
->output_section
->vma
3044 + htab
->sgotplt
->output_offset
3047 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */
3048 got_value
= (htab
->root
.hgot
->root
.u
.def
.section
->output_section
->vma
3049 + htab
->root
.hgot
->root
.u
.def
.section
->output_offset
3050 + htab
->root
.hgot
->root
.u
.def
.value
);
3052 return got_address
- got_value
;
3055 /* Return the GOT offset for address VALUE. If there is not yet a GOT
3056 entry for this value, create one. If R_SYMNDX refers to a TLS symbol,
3057 create a TLS GOT entry instead. Return -1 if no satisfactory GOT
3058 offset can be found. */
3061 mips_elf_local_got_index (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
3062 bfd_vma value
, unsigned long r_symndx
,
3063 struct mips_elf_link_hash_entry
*h
, int r_type
)
3065 struct mips_elf_link_hash_table
*htab
;
3066 struct mips_got_entry
*entry
;
3068 htab
= mips_elf_hash_table (info
);
3069 BFD_ASSERT (htab
!= NULL
);
3071 entry
= mips_elf_create_local_got_entry (abfd
, info
, ibfd
, value
,
3072 r_symndx
, h
, r_type
);
3076 if (TLS_RELOC_P (r_type
))
3078 if (entry
->symndx
== -1 && htab
->got_info
->next
== NULL
)
3079 /* A type (3) entry in the single-GOT case. We use the symbol's
3080 hash table entry to track the index. */
3081 return mips_tls_got_index (abfd
, h
->tls_got_offset
, &h
->tls_type
,
3082 r_type
, info
, h
, value
);
3084 return mips_tls_got_index (abfd
, entry
->gotidx
, &entry
->tls_type
,
3085 r_type
, info
, h
, value
);
3088 return entry
->gotidx
;
3091 /* Returns the GOT index for the global symbol indicated by H. */
3094 mips_elf_global_got_index (bfd
*abfd
, bfd
*ibfd
, struct elf_link_hash_entry
*h
,
3095 int r_type
, struct bfd_link_info
*info
)
3097 struct mips_elf_link_hash_table
*htab
;
3099 struct mips_got_info
*g
, *gg
;
3100 long global_got_dynindx
= 0;
3102 htab
= mips_elf_hash_table (info
);
3103 BFD_ASSERT (htab
!= NULL
);
3105 gg
= g
= htab
->got_info
;
3106 if (g
->bfd2got
&& ibfd
)
3108 struct mips_got_entry e
, *p
;
3110 BFD_ASSERT (h
->dynindx
>= 0);
3112 g
= mips_elf_got_for_ibfd (g
, ibfd
);
3113 if (g
->next
!= gg
|| TLS_RELOC_P (r_type
))
3117 e
.d
.h
= (struct mips_elf_link_hash_entry
*)h
;
3120 p
= htab_find (g
->got_entries
, &e
);
3122 BFD_ASSERT (p
->gotidx
> 0);
3124 if (TLS_RELOC_P (r_type
))
3126 bfd_vma value
= MINUS_ONE
;
3127 if ((h
->root
.type
== bfd_link_hash_defined
3128 || h
->root
.type
== bfd_link_hash_defweak
)
3129 && h
->root
.u
.def
.section
->output_section
)
3130 value
= (h
->root
.u
.def
.value
3131 + h
->root
.u
.def
.section
->output_offset
3132 + h
->root
.u
.def
.section
->output_section
->vma
);
3134 return mips_tls_got_index (abfd
, p
->gotidx
, &p
->tls_type
, r_type
,
3135 info
, e
.d
.h
, value
);
3142 if (gg
->global_gotsym
!= NULL
)
3143 global_got_dynindx
= gg
->global_gotsym
->dynindx
;
3145 if (TLS_RELOC_P (r_type
))
3147 struct mips_elf_link_hash_entry
*hm
3148 = (struct mips_elf_link_hash_entry
*) h
;
3149 bfd_vma value
= MINUS_ONE
;
3151 if ((h
->root
.type
== bfd_link_hash_defined
3152 || h
->root
.type
== bfd_link_hash_defweak
)
3153 && h
->root
.u
.def
.section
->output_section
)
3154 value
= (h
->root
.u
.def
.value
3155 + h
->root
.u
.def
.section
->output_offset
3156 + h
->root
.u
.def
.section
->output_section
->vma
);
3158 got_index
= mips_tls_got_index (abfd
, hm
->tls_got_offset
, &hm
->tls_type
,
3159 r_type
, info
, hm
, value
);
3163 /* Once we determine the global GOT entry with the lowest dynamic
3164 symbol table index, we must put all dynamic symbols with greater
3165 indices into the GOT. That makes it easy to calculate the GOT
3167 BFD_ASSERT (h
->dynindx
>= global_got_dynindx
);
3168 got_index
= ((h
->dynindx
- global_got_dynindx
+ g
->local_gotno
)
3169 * MIPS_ELF_GOT_SIZE (abfd
));
3171 BFD_ASSERT (got_index
< htab
->sgot
->size
);
3176 /* Find a GOT page entry that points to within 32KB of VALUE. These
3177 entries are supposed to be placed at small offsets in the GOT, i.e.,
3178 within 32KB of GP. Return the index of the GOT entry, or -1 if no
3179 entry could be created. If OFFSETP is nonnull, use it to return the
3180 offset of the GOT entry from VALUE. */
3183 mips_elf_got_page (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
3184 bfd_vma value
, bfd_vma
*offsetp
)
3186 bfd_vma page
, got_index
;
3187 struct mips_got_entry
*entry
;
3189 page
= (value
+ 0x8000) & ~(bfd_vma
) 0xffff;
3190 entry
= mips_elf_create_local_got_entry (abfd
, info
, ibfd
, page
, 0,
3191 NULL
, R_MIPS_GOT_PAGE
);
3196 got_index
= entry
->gotidx
;
3199 *offsetp
= value
- entry
->d
.address
;
3204 /* Find a local GOT entry for an R_MIPS*_GOT16 relocation against VALUE.
3205 EXTERNAL is true if the relocation was against a global symbol
3206 that has been forced local. */
3209 mips_elf_got16_entry (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
3210 bfd_vma value
, bfd_boolean external
)
3212 struct mips_got_entry
*entry
;
3214 /* GOT16 relocations against local symbols are followed by a LO16
3215 relocation; those against global symbols are not. Thus if the
3216 symbol was originally local, the GOT16 relocation should load the
3217 equivalent of %hi(VALUE), otherwise it should load VALUE itself. */
3219 value
= mips_elf_high (value
) << 16;
3221 /* It doesn't matter whether the original relocation was R_MIPS_GOT16,
3222 R_MIPS16_GOT16, R_MIPS_CALL16, etc. The format of the entry is the
3223 same in all cases. */
3224 entry
= mips_elf_create_local_got_entry (abfd
, info
, ibfd
, value
, 0,
3225 NULL
, R_MIPS_GOT16
);
3227 return entry
->gotidx
;
3232 /* Returns the offset for the entry at the INDEXth position
3236 mips_elf_got_offset_from_index (struct bfd_link_info
*info
, bfd
*output_bfd
,
3237 bfd
*input_bfd
, bfd_vma got_index
)
3239 struct mips_elf_link_hash_table
*htab
;
3243 htab
= mips_elf_hash_table (info
);
3244 BFD_ASSERT (htab
!= NULL
);
3247 gp
= _bfd_get_gp_value (output_bfd
)
3248 + mips_elf_adjust_gp (output_bfd
, htab
->got_info
, input_bfd
);
3250 return sgot
->output_section
->vma
+ sgot
->output_offset
+ got_index
- gp
;
3253 /* Create and return a local GOT entry for VALUE, which was calculated
3254 from a symbol belonging to INPUT_SECTON. Return NULL if it could not
3255 be created. If R_SYMNDX refers to a TLS symbol, create a TLS entry
3258 static struct mips_got_entry
*
3259 mips_elf_create_local_got_entry (bfd
*abfd
, struct bfd_link_info
*info
,
3260 bfd
*ibfd
, bfd_vma value
,
3261 unsigned long r_symndx
,
3262 struct mips_elf_link_hash_entry
*h
,
3265 struct mips_got_entry entry
, **loc
;
3266 struct mips_got_info
*g
;
3267 struct mips_elf_link_hash_table
*htab
;
3269 htab
= mips_elf_hash_table (info
);
3270 BFD_ASSERT (htab
!= NULL
);
3274 entry
.d
.address
= value
;
3277 g
= mips_elf_got_for_ibfd (htab
->got_info
, ibfd
);
3280 g
= mips_elf_got_for_ibfd (htab
->got_info
, abfd
);
3281 BFD_ASSERT (g
!= NULL
);
3284 /* We might have a symbol, H, if it has been forced local. Use the
3285 global entry then. It doesn't matter whether an entry is local
3286 or global for TLS, since the dynamic linker does not
3287 automatically relocate TLS GOT entries. */
3288 BFD_ASSERT (h
== NULL
|| h
->root
.forced_local
);
3289 if (TLS_RELOC_P (r_type
))
3291 struct mips_got_entry
*p
;
3294 if (r_type
== R_MIPS_TLS_LDM
)
3296 entry
.tls_type
= GOT_TLS_LDM
;
3302 entry
.symndx
= r_symndx
;
3308 p
= (struct mips_got_entry
*)
3309 htab_find (g
->got_entries
, &entry
);
3315 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
3320 entry
.gotidx
= MIPS_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
++;
3323 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
3328 memcpy (*loc
, &entry
, sizeof entry
);
3330 if (g
->assigned_gotno
> g
->local_gotno
)
3332 (*loc
)->gotidx
= -1;
3333 /* We didn't allocate enough space in the GOT. */
3334 (*_bfd_error_handler
)
3335 (_("not enough GOT space for local GOT entries"));
3336 bfd_set_error (bfd_error_bad_value
);
3340 MIPS_ELF_PUT_WORD (abfd
, value
,
3341 (htab
->sgot
->contents
+ entry
.gotidx
));
3343 /* These GOT entries need a dynamic relocation on VxWorks. */
3344 if (htab
->is_vxworks
)
3346 Elf_Internal_Rela outrel
;
3349 bfd_vma got_address
;
3351 s
= mips_elf_rel_dyn_section (info
, FALSE
);
3352 got_address
= (htab
->sgot
->output_section
->vma
3353 + htab
->sgot
->output_offset
3356 rloc
= s
->contents
+ (s
->reloc_count
++ * sizeof (Elf32_External_Rela
));
3357 outrel
.r_offset
= got_address
;
3358 outrel
.r_info
= ELF32_R_INFO (STN_UNDEF
, R_MIPS_32
);
3359 outrel
.r_addend
= value
;
3360 bfd_elf32_swap_reloca_out (abfd
, &outrel
, rloc
);
3366 /* Return the number of dynamic section symbols required by OUTPUT_BFD.
3367 The number might be exact or a worst-case estimate, depending on how
3368 much information is available to elf_backend_omit_section_dynsym at
3369 the current linking stage. */
3371 static bfd_size_type
3372 count_section_dynsyms (bfd
*output_bfd
, struct bfd_link_info
*info
)
3374 bfd_size_type count
;
3377 if (info
->shared
|| elf_hash_table (info
)->is_relocatable_executable
)
3380 const struct elf_backend_data
*bed
;
3382 bed
= get_elf_backend_data (output_bfd
);
3383 for (p
= output_bfd
->sections
; p
; p
= p
->next
)
3384 if ((p
->flags
& SEC_EXCLUDE
) == 0
3385 && (p
->flags
& SEC_ALLOC
) != 0
3386 && !(*bed
->elf_backend_omit_section_dynsym
) (output_bfd
, info
, p
))
3392 /* Sort the dynamic symbol table so that symbols that need GOT entries
3393 appear towards the end. */
3396 mips_elf_sort_hash_table (bfd
*abfd
, struct bfd_link_info
*info
)
3398 struct mips_elf_link_hash_table
*htab
;
3399 struct mips_elf_hash_sort_data hsd
;
3400 struct mips_got_info
*g
;
3402 if (elf_hash_table (info
)->dynsymcount
== 0)
3405 htab
= mips_elf_hash_table (info
);
3406 BFD_ASSERT (htab
!= NULL
);
3413 hsd
.max_unref_got_dynindx
3414 = hsd
.min_got_dynindx
3415 = (elf_hash_table (info
)->dynsymcount
- g
->reloc_only_gotno
);
3416 hsd
.max_non_got_dynindx
= count_section_dynsyms (abfd
, info
) + 1;
3417 mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table
*)
3418 elf_hash_table (info
)),
3419 mips_elf_sort_hash_table_f
,
3422 /* There should have been enough room in the symbol table to
3423 accommodate both the GOT and non-GOT symbols. */
3424 BFD_ASSERT (hsd
.max_non_got_dynindx
<= hsd
.min_got_dynindx
);
3425 BFD_ASSERT ((unsigned long) hsd
.max_unref_got_dynindx
3426 == elf_hash_table (info
)->dynsymcount
);
3427 BFD_ASSERT (elf_hash_table (info
)->dynsymcount
- hsd
.min_got_dynindx
3428 == g
->global_gotno
);
3430 /* Now we know which dynamic symbol has the lowest dynamic symbol
3431 table index in the GOT. */
3432 g
->global_gotsym
= hsd
.low
;
3437 /* If H needs a GOT entry, assign it the highest available dynamic
3438 index. Otherwise, assign it the lowest available dynamic
3442 mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry
*h
, void *data
)
3444 struct mips_elf_hash_sort_data
*hsd
= data
;
3446 if (h
->root
.root
.type
== bfd_link_hash_warning
)
3447 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3449 /* Symbols without dynamic symbol table entries aren't interesting
3451 if (h
->root
.dynindx
== -1)
3454 switch (h
->global_got_area
)
3457 h
->root
.dynindx
= hsd
->max_non_got_dynindx
++;
3461 BFD_ASSERT (h
->tls_type
== GOT_NORMAL
);
3463 h
->root
.dynindx
= --hsd
->min_got_dynindx
;
3464 hsd
->low
= (struct elf_link_hash_entry
*) h
;
3467 case GGA_RELOC_ONLY
:
3468 BFD_ASSERT (h
->tls_type
== GOT_NORMAL
);
3470 if (hsd
->max_unref_got_dynindx
== hsd
->min_got_dynindx
)
3471 hsd
->low
= (struct elf_link_hash_entry
*) h
;
3472 h
->root
.dynindx
= hsd
->max_unref_got_dynindx
++;
3479 /* If H is a symbol that needs a global GOT entry, but has a dynamic
3480 symbol table index lower than any we've seen to date, record it for
3484 mips_elf_record_global_got_symbol (struct elf_link_hash_entry
*h
,
3485 bfd
*abfd
, struct bfd_link_info
*info
,
3486 unsigned char tls_flag
)
3488 struct mips_elf_link_hash_table
*htab
;
3489 struct mips_elf_link_hash_entry
*hmips
;
3490 struct mips_got_entry entry
, **loc
;
3491 struct mips_got_info
*g
;
3493 htab
= mips_elf_hash_table (info
);
3494 BFD_ASSERT (htab
!= NULL
);
3496 hmips
= (struct mips_elf_link_hash_entry
*) h
;
3498 /* A global symbol in the GOT must also be in the dynamic symbol
3500 if (h
->dynindx
== -1)
3502 switch (ELF_ST_VISIBILITY (h
->other
))
3506 _bfd_elf_link_hash_hide_symbol (info
, h
, TRUE
);
3509 if (!bfd_elf_link_record_dynamic_symbol (info
, h
))
3513 /* Make sure we have a GOT to put this entry into. */
3515 BFD_ASSERT (g
!= NULL
);
3519 entry
.d
.h
= (struct mips_elf_link_hash_entry
*) h
;
3522 loc
= (struct mips_got_entry
**) htab_find_slot (g
->got_entries
, &entry
,
3525 /* If we've already marked this entry as needing GOT space, we don't
3526 need to do it again. */
3529 (*loc
)->tls_type
|= tls_flag
;
3533 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
3539 entry
.tls_type
= tls_flag
;
3541 memcpy (*loc
, &entry
, sizeof entry
);
3544 hmips
->global_got_area
= GGA_NORMAL
;
3549 /* Reserve space in G for a GOT entry containing the value of symbol
3550 SYMNDX in input bfd ABDF, plus ADDEND. */
3553 mips_elf_record_local_got_symbol (bfd
*abfd
, long symndx
, bfd_vma addend
,
3554 struct bfd_link_info
*info
,
3555 unsigned char tls_flag
)
3557 struct mips_elf_link_hash_table
*htab
;
3558 struct mips_got_info
*g
;
3559 struct mips_got_entry entry
, **loc
;
3561 htab
= mips_elf_hash_table (info
);
3562 BFD_ASSERT (htab
!= NULL
);
3565 BFD_ASSERT (g
!= NULL
);
3568 entry
.symndx
= symndx
;
3569 entry
.d
.addend
= addend
;
3570 entry
.tls_type
= tls_flag
;
3571 loc
= (struct mips_got_entry
**)
3572 htab_find_slot (g
->got_entries
, &entry
, INSERT
);
3576 if (tls_flag
== GOT_TLS_GD
&& !((*loc
)->tls_type
& GOT_TLS_GD
))
3579 (*loc
)->tls_type
|= tls_flag
;
3581 else if (tls_flag
== GOT_TLS_IE
&& !((*loc
)->tls_type
& GOT_TLS_IE
))
3584 (*loc
)->tls_type
|= tls_flag
;
3592 entry
.tls_type
= tls_flag
;
3593 if (tls_flag
== GOT_TLS_IE
)
3595 else if (tls_flag
== GOT_TLS_GD
)
3597 else if (g
->tls_ldm_offset
== MINUS_ONE
)
3599 g
->tls_ldm_offset
= MINUS_TWO
;
3605 entry
.gotidx
= g
->local_gotno
++;
3609 *loc
= (struct mips_got_entry
*)bfd_alloc (abfd
, sizeof entry
);
3614 memcpy (*loc
, &entry
, sizeof entry
);
3619 /* Return the maximum number of GOT page entries required for RANGE. */
3622 mips_elf_pages_for_range (const struct mips_got_page_range
*range
)
3624 return (range
->max_addend
- range
->min_addend
+ 0x1ffff) >> 16;
3627 /* Record that ABFD has a page relocation against symbol SYMNDX and
3628 that ADDEND is the addend for that relocation.
3630 This function creates an upper bound on the number of GOT slots
3631 required; no attempt is made to combine references to non-overridable
3632 global symbols across multiple input files. */
3635 mips_elf_record_got_page_entry (struct bfd_link_info
*info
, bfd
*abfd
,
3636 long symndx
, bfd_signed_vma addend
)
3638 struct mips_elf_link_hash_table
*htab
;
3639 struct mips_got_info
*g
;
3640 struct mips_got_page_entry lookup
, *entry
;
3641 struct mips_got_page_range
**range_ptr
, *range
;
3642 bfd_vma old_pages
, new_pages
;
3645 htab
= mips_elf_hash_table (info
);
3646 BFD_ASSERT (htab
!= NULL
);
3649 BFD_ASSERT (g
!= NULL
);
3651 /* Find the mips_got_page_entry hash table entry for this symbol. */
3653 lookup
.symndx
= symndx
;
3654 loc
= htab_find_slot (g
->got_page_entries
, &lookup
, INSERT
);
3658 /* Create a mips_got_page_entry if this is the first time we've
3660 entry
= (struct mips_got_page_entry
*) *loc
;
3663 entry
= bfd_alloc (abfd
, sizeof (*entry
));
3668 entry
->symndx
= symndx
;
3669 entry
->ranges
= NULL
;
3670 entry
->num_pages
= 0;
3674 /* Skip over ranges whose maximum extent cannot share a page entry
3676 range_ptr
= &entry
->ranges
;
3677 while (*range_ptr
&& addend
> (*range_ptr
)->max_addend
+ 0xffff)
3678 range_ptr
= &(*range_ptr
)->next
;
3680 /* If we scanned to the end of the list, or found a range whose
3681 minimum extent cannot share a page entry with ADDEND, create
3682 a new singleton range. */
3684 if (!range
|| addend
< range
->min_addend
- 0xffff)
3686 range
= bfd_alloc (abfd
, sizeof (*range
));
3690 range
->next
= *range_ptr
;
3691 range
->min_addend
= addend
;
3692 range
->max_addend
= addend
;
3700 /* Remember how many pages the old range contributed. */
3701 old_pages
= mips_elf_pages_for_range (range
);
3703 /* Update the ranges. */
3704 if (addend
< range
->min_addend
)
3705 range
->min_addend
= addend
;
3706 else if (addend
> range
->max_addend
)
3708 if (range
->next
&& addend
>= range
->next
->min_addend
- 0xffff)
3710 old_pages
+= mips_elf_pages_for_range (range
->next
);
3711 range
->max_addend
= range
->next
->max_addend
;
3712 range
->next
= range
->next
->next
;
3715 range
->max_addend
= addend
;
3718 /* Record any change in the total estimate. */
3719 new_pages
= mips_elf_pages_for_range (range
);
3720 if (old_pages
!= new_pages
)
3722 entry
->num_pages
+= new_pages
- old_pages
;
3723 g
->page_gotno
+= new_pages
- old_pages
;
3729 /* Add room for N relocations to the .rel(a).dyn section in ABFD. */
3732 mips_elf_allocate_dynamic_relocations (bfd
*abfd
, struct bfd_link_info
*info
,
3736 struct mips_elf_link_hash_table
*htab
;
3738 htab
= mips_elf_hash_table (info
);
3739 BFD_ASSERT (htab
!= NULL
);
3741 s
= mips_elf_rel_dyn_section (info
, FALSE
);
3742 BFD_ASSERT (s
!= NULL
);
3744 if (htab
->is_vxworks
)
3745 s
->size
+= n
* MIPS_ELF_RELA_SIZE (abfd
);
3750 /* Make room for a null element. */
3751 s
->size
+= MIPS_ELF_REL_SIZE (abfd
);
3754 s
->size
+= n
* MIPS_ELF_REL_SIZE (abfd
);
3758 /* A htab_traverse callback for GOT entries. Set boolean *DATA to true
3759 if the GOT entry is for an indirect or warning symbol. */
3762 mips_elf_check_recreate_got (void **entryp
, void *data
)
3764 struct mips_got_entry
*entry
;
3765 bfd_boolean
*must_recreate
;
3767 entry
= (struct mips_got_entry
*) *entryp
;
3768 must_recreate
= (bfd_boolean
*) data
;
3769 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1)
3771 struct mips_elf_link_hash_entry
*h
;
3774 if (h
->root
.root
.type
== bfd_link_hash_indirect
3775 || h
->root
.root
.type
== bfd_link_hash_warning
)
3777 *must_recreate
= TRUE
;
3784 /* A htab_traverse callback for GOT entries. Add all entries to
3785 hash table *DATA, converting entries for indirect and warning
3786 symbols into entries for the target symbol. Set *DATA to null
3790 mips_elf_recreate_got (void **entryp
, void *data
)
3793 struct mips_got_entry
*entry
;
3796 new_got
= (htab_t
*) data
;
3797 entry
= (struct mips_got_entry
*) *entryp
;
3798 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1)
3800 struct mips_elf_link_hash_entry
*h
;
3803 while (h
->root
.root
.type
== bfd_link_hash_indirect
3804 || h
->root
.root
.type
== bfd_link_hash_warning
)
3806 BFD_ASSERT (h
->global_got_area
== GGA_NONE
);
3807 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3811 slot
= htab_find_slot (*new_got
, entry
, INSERT
);
3824 /* If any entries in G->got_entries are for indirect or warning symbols,
3825 replace them with entries for the target symbol. */
3828 mips_elf_resolve_final_got_entries (struct mips_got_info
*g
)
3830 bfd_boolean must_recreate
;
3833 must_recreate
= FALSE
;
3834 htab_traverse (g
->got_entries
, mips_elf_check_recreate_got
, &must_recreate
);
3837 new_got
= htab_create (htab_size (g
->got_entries
),
3838 mips_elf_got_entry_hash
,
3839 mips_elf_got_entry_eq
, NULL
);
3840 htab_traverse (g
->got_entries
, mips_elf_recreate_got
, &new_got
);
3841 if (new_got
== NULL
)
3844 /* Each entry in g->got_entries has either been copied to new_got
3845 or freed. Now delete the hash table itself. */
3846 htab_delete (g
->got_entries
);
3847 g
->got_entries
= new_got
;
3852 /* A mips_elf_link_hash_traverse callback for which DATA points
3853 to a mips_got_info. Count the number of type (3) entries. */
3856 mips_elf_count_got_symbols (struct mips_elf_link_hash_entry
*h
, void *data
)
3858 struct mips_got_info
*g
;
3860 g
= (struct mips_got_info
*) data
;
3861 if (h
->global_got_area
!= GGA_NONE
)
3863 if (h
->root
.forced_local
|| h
->root
.dynindx
== -1)
3865 /* We no longer need this entry if it was only used for
3866 relocations; those relocations will be against the
3867 null or section symbol instead of H. */
3868 if (h
->global_got_area
!= GGA_RELOC_ONLY
)
3870 h
->global_got_area
= GGA_NONE
;
3875 if (h
->global_got_area
== GGA_RELOC_ONLY
)
3876 g
->reloc_only_gotno
++;
3882 /* Compute the hash value of the bfd in a bfd2got hash entry. */
3885 mips_elf_bfd2got_entry_hash (const void *entry_
)
3887 const struct mips_elf_bfd2got_hash
*entry
3888 = (struct mips_elf_bfd2got_hash
*)entry_
;
3890 return entry
->bfd
->id
;
3893 /* Check whether two hash entries have the same bfd. */
3896 mips_elf_bfd2got_entry_eq (const void *entry1
, const void *entry2
)
3898 const struct mips_elf_bfd2got_hash
*e1
3899 = (const struct mips_elf_bfd2got_hash
*)entry1
;
3900 const struct mips_elf_bfd2got_hash
*e2
3901 = (const struct mips_elf_bfd2got_hash
*)entry2
;
3903 return e1
->bfd
== e2
->bfd
;
3906 /* In a multi-got link, determine the GOT to be used for IBFD. G must
3907 be the master GOT data. */
3909 static struct mips_got_info
*
3910 mips_elf_got_for_ibfd (struct mips_got_info
*g
, bfd
*ibfd
)
3912 struct mips_elf_bfd2got_hash e
, *p
;
3918 p
= htab_find (g
->bfd2got
, &e
);
3919 return p
? p
->g
: NULL
;
3922 /* Use BFD2GOT to find ABFD's got entry, creating one if none exists.
3923 Return NULL if an error occured. */
3925 static struct mips_got_info
*
3926 mips_elf_get_got_for_bfd (struct htab
*bfd2got
, bfd
*output_bfd
,
3929 struct mips_elf_bfd2got_hash bfdgot_entry
, *bfdgot
;
3930 struct mips_got_info
*g
;
3933 bfdgot_entry
.bfd
= input_bfd
;
3934 bfdgotp
= htab_find_slot (bfd2got
, &bfdgot_entry
, INSERT
);
3935 bfdgot
= (struct mips_elf_bfd2got_hash
*) *bfdgotp
;
3939 bfdgot
= ((struct mips_elf_bfd2got_hash
*)
3940 bfd_alloc (output_bfd
, sizeof (struct mips_elf_bfd2got_hash
)));
3946 g
= ((struct mips_got_info
*)
3947 bfd_alloc (output_bfd
, sizeof (struct mips_got_info
)));
3951 bfdgot
->bfd
= input_bfd
;
3954 g
->global_gotsym
= NULL
;
3955 g
->global_gotno
= 0;
3956 g
->reloc_only_gotno
= 0;
3959 g
->assigned_gotno
= -1;
3961 g
->tls_assigned_gotno
= 0;
3962 g
->tls_ldm_offset
= MINUS_ONE
;
3963 g
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
3964 mips_elf_multi_got_entry_eq
, NULL
);
3965 if (g
->got_entries
== NULL
)
3968 g
->got_page_entries
= htab_try_create (1, mips_got_page_entry_hash
,
3969 mips_got_page_entry_eq
, NULL
);
3970 if (g
->got_page_entries
== NULL
)
3980 /* A htab_traverse callback for the entries in the master got.
3981 Create one separate got for each bfd that has entries in the global
3982 got, such that we can tell how many local and global entries each
3986 mips_elf_make_got_per_bfd (void **entryp
, void *p
)
3988 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
3989 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
3990 struct mips_got_info
*g
;
3992 g
= mips_elf_get_got_for_bfd (arg
->bfd2got
, arg
->obfd
, entry
->abfd
);
3999 /* Insert the GOT entry in the bfd's got entry hash table. */
4000 entryp
= htab_find_slot (g
->got_entries
, entry
, INSERT
);
4001 if (*entryp
!= NULL
)
4006 if (entry
->tls_type
)
4008 if (entry
->tls_type
& (GOT_TLS_GD
| GOT_TLS_LDM
))
4010 if (entry
->tls_type
& GOT_TLS_IE
)
4013 else if (entry
->symndx
>= 0 || entry
->d
.h
->root
.forced_local
)
4021 /* A htab_traverse callback for the page entries in the master got.
4022 Associate each page entry with the bfd's got. */
4025 mips_elf_make_got_pages_per_bfd (void **entryp
, void *p
)
4027 struct mips_got_page_entry
*entry
= (struct mips_got_page_entry
*) *entryp
;
4028 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*) p
;
4029 struct mips_got_info
*g
;
4031 g
= mips_elf_get_got_for_bfd (arg
->bfd2got
, arg
->obfd
, entry
->abfd
);
4038 /* Insert the GOT entry in the bfd's got entry hash table. */
4039 entryp
= htab_find_slot (g
->got_page_entries
, entry
, INSERT
);
4040 if (*entryp
!= NULL
)
4044 g
->page_gotno
+= entry
->num_pages
;
4048 /* Consider merging the got described by BFD2GOT with TO, using the
4049 information given by ARG. Return -1 if this would lead to overflow,
4050 1 if they were merged successfully, and 0 if a merge failed due to
4051 lack of memory. (These values are chosen so that nonnegative return
4052 values can be returned by a htab_traverse callback.) */
4055 mips_elf_merge_got_with (struct mips_elf_bfd2got_hash
*bfd2got
,
4056 struct mips_got_info
*to
,
4057 struct mips_elf_got_per_bfd_arg
*arg
)
4059 struct mips_got_info
*from
= bfd2got
->g
;
4060 unsigned int estimate
;
4062 /* Work out how many page entries we would need for the combined GOT. */
4063 estimate
= arg
->max_pages
;
4064 if (estimate
>= from
->page_gotno
+ to
->page_gotno
)
4065 estimate
= from
->page_gotno
+ to
->page_gotno
;
4067 /* And conservatively estimate how many local, global and TLS entries
4069 estimate
+= (from
->local_gotno
4070 + from
->global_gotno
4076 /* Bail out if the combined GOT might be too big. */
4077 if (estimate
> arg
->max_count
)
4080 /* Commit to the merge. Record that TO is now the bfd for this got. */
4083 /* Transfer the bfd's got information from FROM to TO. */
4084 htab_traverse (from
->got_entries
, mips_elf_make_got_per_bfd
, arg
);
4085 if (arg
->obfd
== NULL
)
4088 htab_traverse (from
->got_page_entries
, mips_elf_make_got_pages_per_bfd
, arg
);
4089 if (arg
->obfd
== NULL
)
4092 /* We don't have to worry about releasing memory of the actual
4093 got entries, since they're all in the master got_entries hash
4095 htab_delete (from
->got_entries
);
4096 htab_delete (from
->got_page_entries
);
4100 /* Attempt to merge gots of different input bfds. Try to use as much
4101 as possible of the primary got, since it doesn't require explicit
4102 dynamic relocations, but don't use bfds that would reference global
4103 symbols out of the addressable range. Failing the primary got,
4104 attempt to merge with the current got, or finish the current got
4105 and then make make the new got current. */
4108 mips_elf_merge_gots (void **bfd2got_
, void *p
)
4110 struct mips_elf_bfd2got_hash
*bfd2got
4111 = (struct mips_elf_bfd2got_hash
*)*bfd2got_
;
4112 struct mips_elf_got_per_bfd_arg
*arg
= (struct mips_elf_got_per_bfd_arg
*)p
;
4113 struct mips_got_info
*g
;
4114 unsigned int estimate
;
4119 /* Work out the number of page, local and TLS entries. */
4120 estimate
= arg
->max_pages
;
4121 if (estimate
> g
->page_gotno
)
4122 estimate
= g
->page_gotno
;
4123 estimate
+= g
->local_gotno
+ g
->tls_gotno
;
4125 /* We place TLS GOT entries after both locals and globals. The globals
4126 for the primary GOT may overflow the normal GOT size limit, so be
4127 sure not to merge a GOT which requires TLS with the primary GOT in that
4128 case. This doesn't affect non-primary GOTs. */
4129 estimate
+= (g
->tls_gotno
> 0 ? arg
->global_count
: g
->global_gotno
);
4131 if (estimate
<= arg
->max_count
)
4133 /* If we don't have a primary GOT, use it as
4134 a starting point for the primary GOT. */
4137 arg
->primary
= bfd2got
->g
;
4141 /* Try merging with the primary GOT. */
4142 result
= mips_elf_merge_got_with (bfd2got
, arg
->primary
, arg
);
4147 /* If we can merge with the last-created got, do it. */
4150 result
= mips_elf_merge_got_with (bfd2got
, arg
->current
, arg
);
4155 /* Well, we couldn't merge, so create a new GOT. Don't check if it
4156 fits; if it turns out that it doesn't, we'll get relocation
4157 overflows anyway. */
4158 g
->next
= arg
->current
;
4164 /* Set the TLS GOT index for the GOT entry in ENTRYP. ENTRYP's NEXT field
4165 is null iff there is just a single GOT. */
4168 mips_elf_initialize_tls_index (void **entryp
, void *p
)
4170 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
4171 struct mips_got_info
*g
= p
;
4173 unsigned char tls_type
;
4175 /* We're only interested in TLS symbols. */
4176 if (entry
->tls_type
== 0)
4179 next_index
= MIPS_ELF_GOT_SIZE (entry
->abfd
) * (long) g
->tls_assigned_gotno
;
4181 if (entry
->symndx
== -1 && g
->next
== NULL
)
4183 /* A type (3) got entry in the single-GOT case. We use the symbol's
4184 hash table entry to track its index. */
4185 if (entry
->d
.h
->tls_type
& GOT_TLS_OFFSET_DONE
)
4187 entry
->d
.h
->tls_type
|= GOT_TLS_OFFSET_DONE
;
4188 entry
->d
.h
->tls_got_offset
= next_index
;
4189 tls_type
= entry
->d
.h
->tls_type
;
4193 if (entry
->tls_type
& GOT_TLS_LDM
)
4195 /* There are separate mips_got_entry objects for each input bfd
4196 that requires an LDM entry. Make sure that all LDM entries in
4197 a GOT resolve to the same index. */
4198 if (g
->tls_ldm_offset
!= MINUS_TWO
&& g
->tls_ldm_offset
!= MINUS_ONE
)
4200 entry
->gotidx
= g
->tls_ldm_offset
;
4203 g
->tls_ldm_offset
= next_index
;
4205 entry
->gotidx
= next_index
;
4206 tls_type
= entry
->tls_type
;
4209 /* Account for the entries we've just allocated. */
4210 if (tls_type
& (GOT_TLS_GD
| GOT_TLS_LDM
))
4211 g
->tls_assigned_gotno
+= 2;
4212 if (tls_type
& GOT_TLS_IE
)
4213 g
->tls_assigned_gotno
+= 1;
4218 /* If passed a NULL mips_got_info in the argument, set the marker used
4219 to tell whether a global symbol needs a got entry (in the primary
4220 got) to the given VALUE.
4222 If passed a pointer G to a mips_got_info in the argument (it must
4223 not be the primary GOT), compute the offset from the beginning of
4224 the (primary) GOT section to the entry in G corresponding to the
4225 global symbol. G's assigned_gotno must contain the index of the
4226 first available global GOT entry in G. VALUE must contain the size
4227 of a GOT entry in bytes. For each global GOT entry that requires a
4228 dynamic relocation, NEEDED_RELOCS is incremented, and the symbol is
4229 marked as not eligible for lazy resolution through a function
4232 mips_elf_set_global_got_offset (void **entryp
, void *p
)
4234 struct mips_got_entry
*entry
= (struct mips_got_entry
*)*entryp
;
4235 struct mips_elf_set_global_got_offset_arg
*arg
4236 = (struct mips_elf_set_global_got_offset_arg
*)p
;
4237 struct mips_got_info
*g
= arg
->g
;
4239 if (g
&& entry
->tls_type
!= GOT_NORMAL
)
4240 arg
->needed_relocs
+=
4241 mips_tls_got_relocs (arg
->info
, entry
->tls_type
,
4242 entry
->symndx
== -1 ? &entry
->d
.h
->root
: NULL
);
4244 if (entry
->abfd
!= NULL
4245 && entry
->symndx
== -1
4246 && entry
->d
.h
->global_got_area
!= GGA_NONE
)
4250 BFD_ASSERT (g
->global_gotsym
== NULL
);
4252 entry
->gotidx
= arg
->value
* (long) g
->assigned_gotno
++;
4253 if (arg
->info
->shared
4254 || (elf_hash_table (arg
->info
)->dynamic_sections_created
4255 && entry
->d
.h
->root
.def_dynamic
4256 && !entry
->d
.h
->root
.def_regular
))
4257 ++arg
->needed_relocs
;
4260 entry
->d
.h
->global_got_area
= arg
->value
;
4266 /* A htab_traverse callback for GOT entries for which DATA is the
4267 bfd_link_info. Forbid any global symbols from having traditional
4268 lazy-binding stubs. */
4271 mips_elf_forbid_lazy_stubs (void **entryp
, void *data
)
4273 struct bfd_link_info
*info
;
4274 struct mips_elf_link_hash_table
*htab
;
4275 struct mips_got_entry
*entry
;
4277 entry
= (struct mips_got_entry
*) *entryp
;
4278 info
= (struct bfd_link_info
*) data
;
4279 htab
= mips_elf_hash_table (info
);
4280 BFD_ASSERT (htab
!= NULL
);
4282 if (entry
->abfd
!= NULL
4283 && entry
->symndx
== -1
4284 && entry
->d
.h
->needs_lazy_stub
)
4286 entry
->d
.h
->needs_lazy_stub
= FALSE
;
4287 htab
->lazy_stub_count
--;
4293 /* Return the offset of an input bfd IBFD's GOT from the beginning of
4296 mips_elf_adjust_gp (bfd
*abfd
, struct mips_got_info
*g
, bfd
*ibfd
)
4298 if (g
->bfd2got
== NULL
)
4301 g
= mips_elf_got_for_ibfd (g
, ibfd
);
4305 BFD_ASSERT (g
->next
);
4309 return (g
->local_gotno
+ g
->global_gotno
+ g
->tls_gotno
)
4310 * MIPS_ELF_GOT_SIZE (abfd
);
4313 /* Turn a single GOT that is too big for 16-bit addressing into
4314 a sequence of GOTs, each one 16-bit addressable. */
4317 mips_elf_multi_got (bfd
*abfd
, struct bfd_link_info
*info
,
4318 asection
*got
, bfd_size_type pages
)
4320 struct mips_elf_link_hash_table
*htab
;
4321 struct mips_elf_got_per_bfd_arg got_per_bfd_arg
;
4322 struct mips_elf_set_global_got_offset_arg set_got_offset_arg
;
4323 struct mips_got_info
*g
, *gg
;
4324 unsigned int assign
, needed_relocs
;
4327 dynobj
= elf_hash_table (info
)->dynobj
;
4328 htab
= mips_elf_hash_table (info
);
4329 BFD_ASSERT (htab
!= NULL
);
4332 g
->bfd2got
= htab_try_create (1, mips_elf_bfd2got_entry_hash
,
4333 mips_elf_bfd2got_entry_eq
, NULL
);
4334 if (g
->bfd2got
== NULL
)
4337 got_per_bfd_arg
.bfd2got
= g
->bfd2got
;
4338 got_per_bfd_arg
.obfd
= abfd
;
4339 got_per_bfd_arg
.info
= info
;
4341 /* Count how many GOT entries each input bfd requires, creating a
4342 map from bfd to got info while at that. */
4343 htab_traverse (g
->got_entries
, mips_elf_make_got_per_bfd
, &got_per_bfd_arg
);
4344 if (got_per_bfd_arg
.obfd
== NULL
)
4347 /* Also count how many page entries each input bfd requires. */
4348 htab_traverse (g
->got_page_entries
, mips_elf_make_got_pages_per_bfd
,
4350 if (got_per_bfd_arg
.obfd
== NULL
)
4353 got_per_bfd_arg
.current
= NULL
;
4354 got_per_bfd_arg
.primary
= NULL
;
4355 got_per_bfd_arg
.max_count
= ((MIPS_ELF_GOT_MAX_SIZE (info
)
4356 / MIPS_ELF_GOT_SIZE (abfd
))
4357 - htab
->reserved_gotno
);
4358 got_per_bfd_arg
.max_pages
= pages
;
4359 /* The number of globals that will be included in the primary GOT.
4360 See the calls to mips_elf_set_global_got_offset below for more
4362 got_per_bfd_arg
.global_count
= g
->global_gotno
;
4364 /* Try to merge the GOTs of input bfds together, as long as they
4365 don't seem to exceed the maximum GOT size, choosing one of them
4366 to be the primary GOT. */
4367 htab_traverse (g
->bfd2got
, mips_elf_merge_gots
, &got_per_bfd_arg
);
4368 if (got_per_bfd_arg
.obfd
== NULL
)
4371 /* If we do not find any suitable primary GOT, create an empty one. */
4372 if (got_per_bfd_arg
.primary
== NULL
)
4374 g
->next
= (struct mips_got_info
*)
4375 bfd_alloc (abfd
, sizeof (struct mips_got_info
));
4376 if (g
->next
== NULL
)
4379 g
->next
->global_gotsym
= NULL
;
4380 g
->next
->global_gotno
= 0;
4381 g
->next
->reloc_only_gotno
= 0;
4382 g
->next
->local_gotno
= 0;
4383 g
->next
->page_gotno
= 0;
4384 g
->next
->tls_gotno
= 0;
4385 g
->next
->assigned_gotno
= 0;
4386 g
->next
->tls_assigned_gotno
= 0;
4387 g
->next
->tls_ldm_offset
= MINUS_ONE
;
4388 g
->next
->got_entries
= htab_try_create (1, mips_elf_multi_got_entry_hash
,
4389 mips_elf_multi_got_entry_eq
,
4391 if (g
->next
->got_entries
== NULL
)
4393 g
->next
->got_page_entries
= htab_try_create (1, mips_got_page_entry_hash
,
4394 mips_got_page_entry_eq
,
4396 if (g
->next
->got_page_entries
== NULL
)
4398 g
->next
->bfd2got
= NULL
;
4401 g
->next
= got_per_bfd_arg
.primary
;
4402 g
->next
->next
= got_per_bfd_arg
.current
;
4404 /* GG is now the master GOT, and G is the primary GOT. */
4408 /* Map the output bfd to the primary got. That's what we're going
4409 to use for bfds that use GOT16 or GOT_PAGE relocations that we
4410 didn't mark in check_relocs, and we want a quick way to find it.
4411 We can't just use gg->next because we're going to reverse the
4414 struct mips_elf_bfd2got_hash
*bfdgot
;
4417 bfdgot
= (struct mips_elf_bfd2got_hash
*)bfd_alloc
4418 (abfd
, sizeof (struct mips_elf_bfd2got_hash
));
4425 bfdgotp
= htab_find_slot (gg
->bfd2got
, bfdgot
, INSERT
);
4427 BFD_ASSERT (*bfdgotp
== NULL
);
4431 /* Every symbol that is referenced in a dynamic relocation must be
4432 present in the primary GOT, so arrange for them to appear after
4433 those that are actually referenced. */
4434 gg
->reloc_only_gotno
= gg
->global_gotno
- g
->global_gotno
;
4435 g
->global_gotno
= gg
->global_gotno
;
4437 set_got_offset_arg
.g
= NULL
;
4438 set_got_offset_arg
.value
= GGA_RELOC_ONLY
;
4439 htab_traverse (gg
->got_entries
, mips_elf_set_global_got_offset
,
4440 &set_got_offset_arg
);
4441 set_got_offset_arg
.value
= GGA_NORMAL
;
4442 htab_traverse (g
->got_entries
, mips_elf_set_global_got_offset
,
4443 &set_got_offset_arg
);
4445 /* Now go through the GOTs assigning them offset ranges.
4446 [assigned_gotno, local_gotno[ will be set to the range of local
4447 entries in each GOT. We can then compute the end of a GOT by
4448 adding local_gotno to global_gotno. We reverse the list and make
4449 it circular since then we'll be able to quickly compute the
4450 beginning of a GOT, by computing the end of its predecessor. To
4451 avoid special cases for the primary GOT, while still preserving
4452 assertions that are valid for both single- and multi-got links,
4453 we arrange for the main got struct to have the right number of
4454 global entries, but set its local_gotno such that the initial
4455 offset of the primary GOT is zero. Remember that the primary GOT
4456 will become the last item in the circular linked list, so it
4457 points back to the master GOT. */
4458 gg
->local_gotno
= -g
->global_gotno
;
4459 gg
->global_gotno
= g
->global_gotno
;
4466 struct mips_got_info
*gn
;
4468 assign
+= htab
->reserved_gotno
;
4469 g
->assigned_gotno
= assign
;
4470 g
->local_gotno
+= assign
;
4471 g
->local_gotno
+= (pages
< g
->page_gotno
? pages
: g
->page_gotno
);
4472 assign
= g
->local_gotno
+ g
->global_gotno
+ g
->tls_gotno
;
4474 /* Take g out of the direct list, and push it onto the reversed
4475 list that gg points to. g->next is guaranteed to be nonnull after
4476 this operation, as required by mips_elf_initialize_tls_index. */
4481 /* Set up any TLS entries. We always place the TLS entries after
4482 all non-TLS entries. */
4483 g
->tls_assigned_gotno
= g
->local_gotno
+ g
->global_gotno
;
4484 htab_traverse (g
->got_entries
, mips_elf_initialize_tls_index
, g
);
4486 /* Move onto the next GOT. It will be a secondary GOT if nonull. */
4489 /* Forbid global symbols in every non-primary GOT from having
4490 lazy-binding stubs. */
4492 htab_traverse (g
->got_entries
, mips_elf_forbid_lazy_stubs
, info
);
4496 got
->size
= (gg
->next
->local_gotno
4497 + gg
->next
->global_gotno
4498 + gg
->next
->tls_gotno
) * MIPS_ELF_GOT_SIZE (abfd
);
4501 set_got_offset_arg
.value
= MIPS_ELF_GOT_SIZE (abfd
);
4502 set_got_offset_arg
.info
= info
;
4503 for (g
= gg
->next
; g
&& g
->next
!= gg
; g
= g
->next
)
4505 unsigned int save_assign
;
4507 /* Assign offsets to global GOT entries. */
4508 save_assign
= g
->assigned_gotno
;
4509 g
->assigned_gotno
= g
->local_gotno
;
4510 set_got_offset_arg
.g
= g
;
4511 set_got_offset_arg
.needed_relocs
= 0;
4512 htab_traverse (g
->got_entries
,
4513 mips_elf_set_global_got_offset
,
4514 &set_got_offset_arg
);
4515 needed_relocs
+= set_got_offset_arg
.needed_relocs
;
4516 BFD_ASSERT (g
->assigned_gotno
- g
->local_gotno
<= g
->global_gotno
);
4518 g
->assigned_gotno
= save_assign
;
4521 needed_relocs
+= g
->local_gotno
- g
->assigned_gotno
;
4522 BFD_ASSERT (g
->assigned_gotno
== g
->next
->local_gotno
4523 + g
->next
->global_gotno
4524 + g
->next
->tls_gotno
4525 + htab
->reserved_gotno
);
4530 mips_elf_allocate_dynamic_relocations (dynobj
, info
,
4537 /* Returns the first relocation of type r_type found, beginning with
4538 RELOCATION. RELEND is one-past-the-end of the relocation table. */
4540 static const Elf_Internal_Rela
*
4541 mips_elf_next_relocation (bfd
*abfd ATTRIBUTE_UNUSED
, unsigned int r_type
,
4542 const Elf_Internal_Rela
*relocation
,
4543 const Elf_Internal_Rela
*relend
)
4545 unsigned long r_symndx
= ELF_R_SYM (abfd
, relocation
->r_info
);
4547 while (relocation
< relend
)
4549 if (ELF_R_TYPE (abfd
, relocation
->r_info
) == r_type
4550 && ELF_R_SYM (abfd
, relocation
->r_info
) == r_symndx
)
4556 /* We didn't find it. */
4560 /* Return whether a relocation is against a local symbol. */
4563 mips_elf_local_relocation_p (bfd
*input_bfd
,
4564 const Elf_Internal_Rela
*relocation
,
4565 asection
**local_sections
,
4566 bfd_boolean check_forced
)
4568 unsigned long r_symndx
;
4569 Elf_Internal_Shdr
*symtab_hdr
;
4570 struct mips_elf_link_hash_entry
*h
;
4573 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
4574 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
4575 extsymoff
= (elf_bad_symtab (input_bfd
)) ? 0 : symtab_hdr
->sh_info
;
4577 if (r_symndx
< extsymoff
)
4579 if (elf_bad_symtab (input_bfd
) && local_sections
[r_symndx
] != NULL
)
4584 /* Look up the hash table to check whether the symbol
4585 was forced local. */
4586 h
= (struct mips_elf_link_hash_entry
*)
4587 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
];
4588 /* Find the real hash-table entry for this symbol. */
4589 while (h
->root
.root
.type
== bfd_link_hash_indirect
4590 || h
->root
.root
.type
== bfd_link_hash_warning
)
4591 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
4592 if (h
->root
.forced_local
)
4599 /* Sign-extend VALUE, which has the indicated number of BITS. */
4602 _bfd_mips_elf_sign_extend (bfd_vma value
, int bits
)
4604 if (value
& ((bfd_vma
) 1 << (bits
- 1)))
4605 /* VALUE is negative. */
4606 value
|= ((bfd_vma
) - 1) << bits
;
4611 /* Return non-zero if the indicated VALUE has overflowed the maximum
4612 range expressible by a signed number with the indicated number of
4616 mips_elf_overflow_p (bfd_vma value
, int bits
)
4618 bfd_signed_vma svalue
= (bfd_signed_vma
) value
;
4620 if (svalue
> (1 << (bits
- 1)) - 1)
4621 /* The value is too big. */
4623 else if (svalue
< -(1 << (bits
- 1)))
4624 /* The value is too small. */
4631 /* Calculate the %high function. */
4634 mips_elf_high (bfd_vma value
)
4636 return ((value
+ (bfd_vma
) 0x8000) >> 16) & 0xffff;
4639 /* Calculate the %higher function. */
4642 mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED
)
4645 return ((value
+ (bfd_vma
) 0x80008000) >> 32) & 0xffff;
4652 /* Calculate the %highest function. */
4655 mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED
)
4658 return ((value
+ (((bfd_vma
) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
4665 /* Create the .compact_rel section. */
4668 mips_elf_create_compact_rel_section
4669 (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
4672 register asection
*s
;
4674 if (bfd_get_section_by_name (abfd
, ".compact_rel") == NULL
)
4676 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
4679 s
= bfd_make_section_with_flags (abfd
, ".compact_rel", flags
);
4681 || ! bfd_set_section_alignment (abfd
, s
,
4682 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
4685 s
->size
= sizeof (Elf32_External_compact_rel
);
4691 /* Create the .got section to hold the global offset table. */
4694 mips_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
4697 register asection
*s
;
4698 struct elf_link_hash_entry
*h
;
4699 struct bfd_link_hash_entry
*bh
;
4700 struct mips_got_info
*g
;
4702 struct mips_elf_link_hash_table
*htab
;
4704 htab
= mips_elf_hash_table (info
);
4705 BFD_ASSERT (htab
!= NULL
);
4707 /* This function may be called more than once. */
4711 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
4712 | SEC_LINKER_CREATED
);
4714 /* We have to use an alignment of 2**4 here because this is hardcoded
4715 in the function stub generation and in the linker script. */
4716 s
= bfd_make_section_with_flags (abfd
, ".got", flags
);
4718 || ! bfd_set_section_alignment (abfd
, s
, 4))
4722 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
4723 linker script because we don't want to define the symbol if we
4724 are not creating a global offset table. */
4726 if (! (_bfd_generic_link_add_one_symbol
4727 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
4728 0, NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
4731 h
= (struct elf_link_hash_entry
*) bh
;
4734 h
->type
= STT_OBJECT
;
4735 elf_hash_table (info
)->hgot
= h
;
4738 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
4741 amt
= sizeof (struct mips_got_info
);
4742 g
= bfd_alloc (abfd
, amt
);
4745 g
->global_gotsym
= NULL
;
4746 g
->global_gotno
= 0;
4747 g
->reloc_only_gotno
= 0;
4751 g
->assigned_gotno
= 0;
4754 g
->tls_ldm_offset
= MINUS_ONE
;
4755 g
->got_entries
= htab_try_create (1, mips_elf_got_entry_hash
,
4756 mips_elf_got_entry_eq
, NULL
);
4757 if (g
->got_entries
== NULL
)
4759 g
->got_page_entries
= htab_try_create (1, mips_got_page_entry_hash
,
4760 mips_got_page_entry_eq
, NULL
);
4761 if (g
->got_page_entries
== NULL
)
4764 mips_elf_section_data (s
)->elf
.this_hdr
.sh_flags
4765 |= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
4767 /* We also need a .got.plt section when generating PLTs. */
4768 s
= bfd_make_section_with_flags (abfd
, ".got.plt",
4769 SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
4770 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
4778 /* Return true if H refers to the special VxWorks __GOTT_BASE__ or
4779 __GOTT_INDEX__ symbols. These symbols are only special for
4780 shared objects; they are not used in executables. */
4783 is_gott_symbol (struct bfd_link_info
*info
, struct elf_link_hash_entry
*h
)
4785 return (mips_elf_hash_table (info
)->is_vxworks
4787 && (strcmp (h
->root
.root
.string
, "__GOTT_BASE__") == 0
4788 || strcmp (h
->root
.root
.string
, "__GOTT_INDEX__") == 0));
4791 /* Return TRUE if a relocation of type R_TYPE from INPUT_BFD might
4792 require an la25 stub. See also mips_elf_local_pic_function_p,
4793 which determines whether the destination function ever requires a
4797 mips_elf_relocation_needs_la25_stub (bfd
*input_bfd
, int r_type
)
4799 /* We specifically ignore branches and jumps from EF_PIC objects,
4800 where the onus is on the compiler or programmer to perform any
4801 necessary initialization of $25. Sometimes such initialization
4802 is unnecessary; for example, -mno-shared functions do not use
4803 the incoming value of $25, and may therefore be called directly. */
4804 if (PIC_OBJECT_P (input_bfd
))
4819 /* Calculate the value produced by the RELOCATION (which comes from
4820 the INPUT_BFD). The ADDEND is the addend to use for this
4821 RELOCATION; RELOCATION->R_ADDEND is ignored.
4823 The result of the relocation calculation is stored in VALUEP.
4824 On exit, set *CROSS_MODE_JUMP_P to true if the relocation field
4825 is a MIPS16 jump to non-MIPS16 code, or vice versa.
4827 This function returns bfd_reloc_continue if the caller need take no
4828 further action regarding this relocation, bfd_reloc_notsupported if
4829 something goes dramatically wrong, bfd_reloc_overflow if an
4830 overflow occurs, and bfd_reloc_ok to indicate success. */
4832 static bfd_reloc_status_type
4833 mips_elf_calculate_relocation (bfd
*abfd
, bfd
*input_bfd
,
4834 asection
*input_section
,
4835 struct bfd_link_info
*info
,
4836 const Elf_Internal_Rela
*relocation
,
4837 bfd_vma addend
, reloc_howto_type
*howto
,
4838 Elf_Internal_Sym
*local_syms
,
4839 asection
**local_sections
, bfd_vma
*valuep
,
4841 bfd_boolean
*cross_mode_jump_p
,
4842 bfd_boolean save_addend
)
4844 /* The eventual value we will return. */
4846 /* The address of the symbol against which the relocation is
4849 /* The final GP value to be used for the relocatable, executable, or
4850 shared object file being produced. */
4852 /* The place (section offset or address) of the storage unit being
4855 /* The value of GP used to create the relocatable object. */
4857 /* The offset into the global offset table at which the address of
4858 the relocation entry symbol, adjusted by the addend, resides
4859 during execution. */
4860 bfd_vma g
= MINUS_ONE
;
4861 /* The section in which the symbol referenced by the relocation is
4863 asection
*sec
= NULL
;
4864 struct mips_elf_link_hash_entry
*h
= NULL
;
4865 /* TRUE if the symbol referred to by this relocation is a local
4867 bfd_boolean local_p
, was_local_p
;
4868 /* TRUE if the symbol referred to by this relocation is "_gp_disp". */
4869 bfd_boolean gp_disp_p
= FALSE
;
4870 /* TRUE if the symbol referred to by this relocation is
4871 "__gnu_local_gp". */
4872 bfd_boolean gnu_local_gp_p
= FALSE
;
4873 Elf_Internal_Shdr
*symtab_hdr
;
4875 unsigned long r_symndx
;
4877 /* TRUE if overflow occurred during the calculation of the
4878 relocation value. */
4879 bfd_boolean overflowed_p
;
4880 /* TRUE if this relocation refers to a MIPS16 function. */
4881 bfd_boolean target_is_16_bit_code_p
= FALSE
;
4882 struct mips_elf_link_hash_table
*htab
;
4885 dynobj
= elf_hash_table (info
)->dynobj
;
4886 htab
= mips_elf_hash_table (info
);
4887 BFD_ASSERT (htab
!= NULL
);
4889 /* Parse the relocation. */
4890 r_symndx
= ELF_R_SYM (input_bfd
, relocation
->r_info
);
4891 r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
4892 p
= (input_section
->output_section
->vma
4893 + input_section
->output_offset
4894 + relocation
->r_offset
);
4896 /* Assume that there will be no overflow. */
4897 overflowed_p
= FALSE
;
4899 /* Figure out whether or not the symbol is local, and get the offset
4900 used in the array of hash table entries. */
4901 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
4902 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
4903 local_sections
, FALSE
);
4904 was_local_p
= local_p
;
4905 if (! elf_bad_symtab (input_bfd
))
4906 extsymoff
= symtab_hdr
->sh_info
;
4909 /* The symbol table does not follow the rule that local symbols
4910 must come before globals. */
4914 /* Figure out the value of the symbol. */
4917 Elf_Internal_Sym
*sym
;
4919 sym
= local_syms
+ r_symndx
;
4920 sec
= local_sections
[r_symndx
];
4922 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
4923 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
4924 || (sec
->flags
& SEC_MERGE
))
4925 symbol
+= sym
->st_value
;
4926 if ((sec
->flags
& SEC_MERGE
)
4927 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4929 addend
= _bfd_elf_rel_local_sym (abfd
, sym
, &sec
, addend
);
4931 addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
4934 /* MIPS16 text labels should be treated as odd. */
4935 if (ELF_ST_IS_MIPS16 (sym
->st_other
))
4938 /* Record the name of this symbol, for our caller. */
4939 *namep
= bfd_elf_string_from_elf_section (input_bfd
,
4940 symtab_hdr
->sh_link
,
4943 *namep
= bfd_section_name (input_bfd
, sec
);
4945 target_is_16_bit_code_p
= ELF_ST_IS_MIPS16 (sym
->st_other
);
4949 /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ? */
4951 /* For global symbols we look up the symbol in the hash-table. */
4952 h
= ((struct mips_elf_link_hash_entry
*)
4953 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
]);
4954 /* Find the real hash-table entry for this symbol. */
4955 while (h
->root
.root
.type
== bfd_link_hash_indirect
4956 || h
->root
.root
.type
== bfd_link_hash_warning
)
4957 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
4959 /* Record the name of this symbol, for our caller. */
4960 *namep
= h
->root
.root
.root
.string
;
4962 /* See if this is the special _gp_disp symbol. Note that such a
4963 symbol must always be a global symbol. */
4964 if (strcmp (*namep
, "_gp_disp") == 0
4965 && ! NEWABI_P (input_bfd
))
4967 /* Relocations against _gp_disp are permitted only with
4968 R_MIPS_HI16 and R_MIPS_LO16 relocations. */
4969 if (!hi16_reloc_p (r_type
) && !lo16_reloc_p (r_type
))
4970 return bfd_reloc_notsupported
;
4974 /* See if this is the special _gp symbol. Note that such a
4975 symbol must always be a global symbol. */
4976 else if (strcmp (*namep
, "__gnu_local_gp") == 0)
4977 gnu_local_gp_p
= TRUE
;
4980 /* If this symbol is defined, calculate its address. Note that
4981 _gp_disp is a magic symbol, always implicitly defined by the
4982 linker, so it's inappropriate to check to see whether or not
4984 else if ((h
->root
.root
.type
== bfd_link_hash_defined
4985 || h
->root
.root
.type
== bfd_link_hash_defweak
)
4986 && h
->root
.root
.u
.def
.section
)
4988 sec
= h
->root
.root
.u
.def
.section
;
4989 if (sec
->output_section
)
4990 symbol
= (h
->root
.root
.u
.def
.value
4991 + sec
->output_section
->vma
4992 + sec
->output_offset
);
4994 symbol
= h
->root
.root
.u
.def
.value
;
4996 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
4997 /* We allow relocations against undefined weak symbols, giving
4998 it the value zero, so that you can undefined weak functions
4999 and check to see if they exist by looking at their
5002 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
5003 && ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
5005 else if (strcmp (*namep
, SGI_COMPAT (input_bfd
)
5006 ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING") == 0)
5008 /* If this is a dynamic link, we should have created a
5009 _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
5010 in in _bfd_mips_elf_create_dynamic_sections.
5011 Otherwise, we should define the symbol with a value of 0.
5012 FIXME: It should probably get into the symbol table
5014 BFD_ASSERT (! info
->shared
);
5015 BFD_ASSERT (bfd_get_section_by_name (abfd
, ".dynamic") == NULL
);
5018 else if (ELF_MIPS_IS_OPTIONAL (h
->root
.other
))
5020 /* This is an optional symbol - an Irix specific extension to the
5021 ELF spec. Ignore it for now.
5022 XXX - FIXME - there is more to the spec for OPTIONAL symbols
5023 than simply ignoring them, but we do not handle this for now.
5024 For information see the "64-bit ELF Object File Specification"
5025 which is available from here:
5026 http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf */
5029 else if ((*info
->callbacks
->undefined_symbol
)
5030 (info
, h
->root
.root
.root
.string
, input_bfd
,
5031 input_section
, relocation
->r_offset
,
5032 (info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
)
5033 || ELF_ST_VISIBILITY (h
->root
.other
)))
5035 return bfd_reloc_undefined
;
5039 return bfd_reloc_notsupported
;
5042 target_is_16_bit_code_p
= ELF_ST_IS_MIPS16 (h
->root
.other
);
5045 /* If this is a reference to a 16-bit function with a stub, we need
5046 to redirect the relocation to the stub unless:
5048 (a) the relocation is for a MIPS16 JAL;
5050 (b) the relocation is for a MIPS16 PIC call, and there are no
5051 non-MIPS16 uses of the GOT slot; or
5053 (c) the section allows direct references to MIPS16 functions. */
5054 if (r_type
!= R_MIPS16_26
5055 && !info
->relocatable
5057 && h
->fn_stub
!= NULL
5058 && (r_type
!= R_MIPS16_CALL16
|| h
->need_fn_stub
))
5060 && elf_tdata (input_bfd
)->local_stubs
!= NULL
5061 && elf_tdata (input_bfd
)->local_stubs
[r_symndx
] != NULL
))
5062 && !section_allows_mips16_refs_p (input_section
))
5064 /* This is a 32- or 64-bit call to a 16-bit function. We should
5065 have already noticed that we were going to need the
5068 sec
= elf_tdata (input_bfd
)->local_stubs
[r_symndx
];
5071 BFD_ASSERT (h
->need_fn_stub
);
5075 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
5076 /* The target is 16-bit, but the stub isn't. */
5077 target_is_16_bit_code_p
= FALSE
;
5079 /* If this is a 16-bit call to a 32- or 64-bit function with a stub, we
5080 need to redirect the call to the stub. Note that we specifically
5081 exclude R_MIPS16_CALL16 from this behavior; indirect calls should
5082 use an indirect stub instead. */
5083 else if (r_type
== R_MIPS16_26
&& !info
->relocatable
5084 && ((h
!= NULL
&& (h
->call_stub
!= NULL
|| h
->call_fp_stub
!= NULL
))
5086 && elf_tdata (input_bfd
)->local_call_stubs
!= NULL
5087 && elf_tdata (input_bfd
)->local_call_stubs
[r_symndx
] != NULL
))
5088 && !target_is_16_bit_code_p
)
5091 sec
= elf_tdata (input_bfd
)->local_call_stubs
[r_symndx
];
5094 /* If both call_stub and call_fp_stub are defined, we can figure
5095 out which one to use by checking which one appears in the input
5097 if (h
->call_stub
!= NULL
&& h
->call_fp_stub
!= NULL
)
5102 for (o
= input_bfd
->sections
; o
!= NULL
; o
= o
->next
)
5104 if (CALL_FP_STUB_P (bfd_get_section_name (input_bfd
, o
)))
5106 sec
= h
->call_fp_stub
;
5113 else if (h
->call_stub
!= NULL
)
5116 sec
= h
->call_fp_stub
;
5119 BFD_ASSERT (sec
->size
> 0);
5120 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
5122 /* If this is a direct call to a PIC function, redirect to the
5124 else if (h
!= NULL
&& h
->la25_stub
5125 && mips_elf_relocation_needs_la25_stub (input_bfd
, r_type
))
5126 symbol
= (h
->la25_stub
->stub_section
->output_section
->vma
5127 + h
->la25_stub
->stub_section
->output_offset
5128 + h
->la25_stub
->offset
);
5130 /* Calls from 16-bit code to 32-bit code and vice versa require the
5132 *cross_mode_jump_p
= !info
->relocatable
5133 && ((r_type
== R_MIPS16_26
&& !target_is_16_bit_code_p
)
5134 || ((r_type
== R_MIPS_26
|| r_type
== R_MIPS_JALR
)
5135 && target_is_16_bit_code_p
));
5137 local_p
= mips_elf_local_relocation_p (input_bfd
, relocation
,
5138 local_sections
, TRUE
);
5140 gp0
= _bfd_get_gp_value (input_bfd
);
5141 gp
= _bfd_get_gp_value (abfd
);
5143 gp
+= mips_elf_adjust_gp (abfd
, htab
->got_info
, input_bfd
);
5148 /* If we haven't already determined the GOT offset, oand we're going
5149 to need it, get it now. */
5152 case R_MIPS_GOT_PAGE
:
5153 case R_MIPS_GOT_OFST
:
5154 /* We need to decay to GOT_DISP/addend if the symbol doesn't
5156 local_p
= local_p
|| _bfd_elf_symbol_refs_local_p (&h
->root
, info
, 1);
5157 if (local_p
|| r_type
== R_MIPS_GOT_OFST
)
5161 case R_MIPS16_CALL16
:
5162 case R_MIPS16_GOT16
:
5165 case R_MIPS_GOT_DISP
:
5166 case R_MIPS_GOT_HI16
:
5167 case R_MIPS_CALL_HI16
:
5168 case R_MIPS_GOT_LO16
:
5169 case R_MIPS_CALL_LO16
:
5171 case R_MIPS_TLS_GOTTPREL
:
5172 case R_MIPS_TLS_LDM
:
5173 /* Find the index into the GOT where this value is located. */
5174 if (r_type
== R_MIPS_TLS_LDM
)
5176 g
= mips_elf_local_got_index (abfd
, input_bfd
, info
,
5177 0, 0, NULL
, r_type
);
5179 return bfd_reloc_outofrange
;
5183 /* On VxWorks, CALL relocations should refer to the .got.plt
5184 entry, which is initialized to point at the PLT stub. */
5185 if (htab
->is_vxworks
5186 && (r_type
== R_MIPS_CALL_HI16
5187 || r_type
== R_MIPS_CALL_LO16
5188 || call16_reloc_p (r_type
)))
5190 BFD_ASSERT (addend
== 0);
5191 BFD_ASSERT (h
->root
.needs_plt
);
5192 g
= mips_elf_gotplt_index (info
, &h
->root
);
5196 /* GOT_PAGE may take a non-zero addend, that is ignored in a
5197 GOT_PAGE relocation that decays to GOT_DISP because the
5198 symbol turns out to be global. The addend is then added
5200 BFD_ASSERT (addend
== 0 || r_type
== R_MIPS_GOT_PAGE
);
5201 g
= mips_elf_global_got_index (dynobj
, input_bfd
,
5202 &h
->root
, r_type
, info
);
5203 if (h
->tls_type
== GOT_NORMAL
5204 && (! elf_hash_table(info
)->dynamic_sections_created
5206 && (info
->symbolic
|| h
->root
.forced_local
)
5207 && h
->root
.def_regular
)))
5208 /* This is a static link or a -Bsymbolic link. The
5209 symbol is defined locally, or was forced to be local.
5210 We must initialize this entry in the GOT. */
5211 MIPS_ELF_PUT_WORD (dynobj
, symbol
, htab
->sgot
->contents
+ g
);
5214 else if (!htab
->is_vxworks
5215 && (call16_reloc_p (r_type
) || got16_reloc_p (r_type
)))
5216 /* The calculation below does not involve "g". */
5220 g
= mips_elf_local_got_index (abfd
, input_bfd
, info
,
5221 symbol
+ addend
, r_symndx
, h
, r_type
);
5223 return bfd_reloc_outofrange
;
5226 /* Convert GOT indices to actual offsets. */
5227 g
= mips_elf_got_offset_from_index (info
, abfd
, input_bfd
, g
);
5231 /* Relocations against the VxWorks __GOTT_BASE__ and __GOTT_INDEX__
5232 symbols are resolved by the loader. Add them to .rela.dyn. */
5233 if (h
!= NULL
&& is_gott_symbol (info
, &h
->root
))
5235 Elf_Internal_Rela outrel
;
5239 s
= mips_elf_rel_dyn_section (info
, FALSE
);
5240 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
5242 outrel
.r_offset
= (input_section
->output_section
->vma
5243 + input_section
->output_offset
5244 + relocation
->r_offset
);
5245 outrel
.r_info
= ELF32_R_INFO (h
->root
.dynindx
, r_type
);
5246 outrel
.r_addend
= addend
;
5247 bfd_elf32_swap_reloca_out (abfd
, &outrel
, loc
);
5249 /* If we've written this relocation for a readonly section,
5250 we need to set DF_TEXTREL again, so that we do not delete the
5252 if (MIPS_ELF_READONLY_SECTION (input_section
))
5253 info
->flags
|= DF_TEXTREL
;
5256 return bfd_reloc_ok
;
5259 /* Figure out what kind of relocation is being performed. */
5263 return bfd_reloc_continue
;
5266 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 16);
5267 overflowed_p
= mips_elf_overflow_p (value
, 16);
5274 || (htab
->root
.dynamic_sections_created
5276 && h
->root
.def_dynamic
5277 && !h
->root
.def_regular
5278 && !h
->has_static_relocs
))
5281 || h
->root
.root
.type
!= bfd_link_hash_undefweak
5282 || ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
5283 && (input_section
->flags
& SEC_ALLOC
) != 0)
5285 /* If we're creating a shared library, then we can't know
5286 where the symbol will end up. So, we create a relocation
5287 record in the output, and leave the job up to the dynamic
5288 linker. We must do the same for executable references to
5289 shared library symbols, unless we've decided to use copy
5290 relocs or PLTs instead. */
5292 if (!mips_elf_create_dynamic_relocation (abfd
,
5300 return bfd_reloc_undefined
;
5304 if (r_type
!= R_MIPS_REL32
)
5305 value
= symbol
+ addend
;
5309 value
&= howto
->dst_mask
;
5313 value
= symbol
+ addend
- p
;
5314 value
&= howto
->dst_mask
;
5318 /* The calculation for R_MIPS16_26 is just the same as for an
5319 R_MIPS_26. It's only the storage of the relocated field into
5320 the output file that's different. That's handled in
5321 mips_elf_perform_relocation. So, we just fall through to the
5322 R_MIPS_26 case here. */
5325 value
= ((addend
| ((p
+ 4) & 0xf0000000)) + symbol
) >> 2;
5328 value
= (_bfd_mips_elf_sign_extend (addend
, 28) + symbol
) >> 2;
5329 if (h
->root
.root
.type
!= bfd_link_hash_undefweak
)
5330 overflowed_p
= (value
>> 26) != ((p
+ 4) >> 28);
5332 value
&= howto
->dst_mask
;
5335 case R_MIPS_TLS_DTPREL_HI16
:
5336 value
= (mips_elf_high (addend
+ symbol
- dtprel_base (info
))
5340 case R_MIPS_TLS_DTPREL_LO16
:
5341 case R_MIPS_TLS_DTPREL32
:
5342 case R_MIPS_TLS_DTPREL64
:
5343 value
= (symbol
+ addend
- dtprel_base (info
)) & howto
->dst_mask
;
5346 case R_MIPS_TLS_TPREL_HI16
:
5347 value
= (mips_elf_high (addend
+ symbol
- tprel_base (info
))
5351 case R_MIPS_TLS_TPREL_LO16
:
5352 value
= (symbol
+ addend
- tprel_base (info
)) & howto
->dst_mask
;
5359 value
= mips_elf_high (addend
+ symbol
);
5360 value
&= howto
->dst_mask
;
5364 /* For MIPS16 ABI code we generate this sequence
5365 0: li $v0,%hi(_gp_disp)
5366 4: addiupc $v1,%lo(_gp_disp)
5370 So the offsets of hi and lo relocs are the same, but the
5371 $pc is four higher than $t9 would be, so reduce
5372 both reloc addends by 4. */
5373 if (r_type
== R_MIPS16_HI16
)
5374 value
= mips_elf_high (addend
+ gp
- p
- 4);
5376 value
= mips_elf_high (addend
+ gp
- p
);
5377 overflowed_p
= mips_elf_overflow_p (value
, 16);
5384 value
= (symbol
+ addend
) & howto
->dst_mask
;
5387 /* See the comment for R_MIPS16_HI16 above for the reason
5388 for this conditional. */
5389 if (r_type
== R_MIPS16_LO16
)
5390 value
= addend
+ gp
- p
;
5392 value
= addend
+ gp
- p
+ 4;
5393 /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
5394 for overflow. But, on, say, IRIX5, relocations against
5395 _gp_disp are normally generated from the .cpload
5396 pseudo-op. It generates code that normally looks like
5399 lui $gp,%hi(_gp_disp)
5400 addiu $gp,$gp,%lo(_gp_disp)
5403 Here $t9 holds the address of the function being called,
5404 as required by the MIPS ELF ABI. The R_MIPS_LO16
5405 relocation can easily overflow in this situation, but the
5406 R_MIPS_HI16 relocation will handle the overflow.
5407 Therefore, we consider this a bug in the MIPS ABI, and do
5408 not check for overflow here. */
5412 case R_MIPS_LITERAL
:
5413 /* Because we don't merge literal sections, we can handle this
5414 just like R_MIPS_GPREL16. In the long run, we should merge
5415 shared literals, and then we will need to additional work
5420 case R_MIPS16_GPREL
:
5421 /* The R_MIPS16_GPREL performs the same calculation as
5422 R_MIPS_GPREL16, but stores the relocated bits in a different
5423 order. We don't need to do anything special here; the
5424 differences are handled in mips_elf_perform_relocation. */
5425 case R_MIPS_GPREL16
:
5426 /* Only sign-extend the addend if it was extracted from the
5427 instruction. If the addend was separate, leave it alone,
5428 otherwise we may lose significant bits. */
5429 if (howto
->partial_inplace
)
5430 addend
= _bfd_mips_elf_sign_extend (addend
, 16);
5431 value
= symbol
+ addend
- gp
;
5432 /* If the symbol was local, any earlier relocatable links will
5433 have adjusted its addend with the gp offset, so compensate
5434 for that now. Don't do it for symbols forced local in this
5435 link, though, since they won't have had the gp offset applied
5439 overflowed_p
= mips_elf_overflow_p (value
, 16);
5442 case R_MIPS16_GOT16
:
5443 case R_MIPS16_CALL16
:
5446 /* VxWorks does not have separate local and global semantics for
5447 R_MIPS*_GOT16; every relocation evaluates to "G". */
5448 if (!htab
->is_vxworks
&& local_p
)
5452 forced
= ! mips_elf_local_relocation_p (input_bfd
, relocation
,
5453 local_sections
, FALSE
);
5454 value
= mips_elf_got16_entry (abfd
, input_bfd
, info
,
5455 symbol
+ addend
, forced
);
5456 if (value
== MINUS_ONE
)
5457 return bfd_reloc_outofrange
;
5459 = mips_elf_got_offset_from_index (info
, abfd
, input_bfd
, value
);
5460 overflowed_p
= mips_elf_overflow_p (value
, 16);
5467 case R_MIPS_TLS_GOTTPREL
:
5468 case R_MIPS_TLS_LDM
:
5469 case R_MIPS_GOT_DISP
:
5472 overflowed_p
= mips_elf_overflow_p (value
, 16);
5475 case R_MIPS_GPREL32
:
5476 value
= (addend
+ symbol
+ gp0
- gp
);
5478 value
&= howto
->dst_mask
;
5482 case R_MIPS_GNU_REL16_S2
:
5483 value
= symbol
+ _bfd_mips_elf_sign_extend (addend
, 18) - p
;
5484 overflowed_p
= mips_elf_overflow_p (value
, 18);
5485 value
>>= howto
->rightshift
;
5486 value
&= howto
->dst_mask
;
5489 case R_MIPS_GOT_HI16
:
5490 case R_MIPS_CALL_HI16
:
5491 /* We're allowed to handle these two relocations identically.
5492 The dynamic linker is allowed to handle the CALL relocations
5493 differently by creating a lazy evaluation stub. */
5495 value
= mips_elf_high (value
);
5496 value
&= howto
->dst_mask
;
5499 case R_MIPS_GOT_LO16
:
5500 case R_MIPS_CALL_LO16
:
5501 value
= g
& howto
->dst_mask
;
5504 case R_MIPS_GOT_PAGE
:
5505 /* GOT_PAGE relocations that reference non-local symbols decay
5506 to GOT_DISP. The corresponding GOT_OFST relocation decays to
5510 value
= mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, NULL
);
5511 if (value
== MINUS_ONE
)
5512 return bfd_reloc_outofrange
;
5513 value
= mips_elf_got_offset_from_index (info
, abfd
, input_bfd
, value
);
5514 overflowed_p
= mips_elf_overflow_p (value
, 16);
5517 case R_MIPS_GOT_OFST
:
5519 mips_elf_got_page (abfd
, input_bfd
, info
, symbol
+ addend
, &value
);
5522 overflowed_p
= mips_elf_overflow_p (value
, 16);
5526 value
= symbol
- addend
;
5527 value
&= howto
->dst_mask
;
5531 value
= mips_elf_higher (addend
+ symbol
);
5532 value
&= howto
->dst_mask
;
5535 case R_MIPS_HIGHEST
:
5536 value
= mips_elf_highest (addend
+ symbol
);
5537 value
&= howto
->dst_mask
;
5540 case R_MIPS_SCN_DISP
:
5541 value
= symbol
+ addend
- sec
->output_offset
;
5542 value
&= howto
->dst_mask
;
5546 /* This relocation is only a hint. In some cases, we optimize
5547 it into a bal instruction. But we don't try to optimize
5548 when the symbol does not resolve locally. */
5549 if (h
!= NULL
&& !SYMBOL_CALLS_LOCAL (info
, &h
->root
))
5550 return bfd_reloc_continue
;
5551 value
= symbol
+ addend
;
5555 case R_MIPS_GNU_VTINHERIT
:
5556 case R_MIPS_GNU_VTENTRY
:
5557 /* We don't do anything with these at present. */
5558 return bfd_reloc_continue
;
5561 /* An unrecognized relocation type. */
5562 return bfd_reloc_notsupported
;
5565 /* Store the VALUE for our caller. */
5567 return overflowed_p
? bfd_reloc_overflow
: bfd_reloc_ok
;
5570 /* Obtain the field relocated by RELOCATION. */
5573 mips_elf_obtain_contents (reloc_howto_type
*howto
,
5574 const Elf_Internal_Rela
*relocation
,
5575 bfd
*input_bfd
, bfd_byte
*contents
)
5578 bfd_byte
*location
= contents
+ relocation
->r_offset
;
5580 /* Obtain the bytes. */
5581 x
= bfd_get ((8 * bfd_get_reloc_size (howto
)), input_bfd
, location
);
5586 /* It has been determined that the result of the RELOCATION is the
5587 VALUE. Use HOWTO to place VALUE into the output file at the
5588 appropriate position. The SECTION is the section to which the
5590 CROSS_MODE_JUMP_P is true if the relocation field
5591 is a MIPS16 jump to non-MIPS16 code, or vice versa.
5593 Returns FALSE if anything goes wrong. */
5596 mips_elf_perform_relocation (struct bfd_link_info
*info
,
5597 reloc_howto_type
*howto
,
5598 const Elf_Internal_Rela
*relocation
,
5599 bfd_vma value
, bfd
*input_bfd
,
5600 asection
*input_section
, bfd_byte
*contents
,
5601 bfd_boolean cross_mode_jump_p
)
5605 int r_type
= ELF_R_TYPE (input_bfd
, relocation
->r_info
);
5607 /* Figure out where the relocation is occurring. */
5608 location
= contents
+ relocation
->r_offset
;
5610 _bfd_mips16_elf_reloc_unshuffle (input_bfd
, r_type
, FALSE
, location
);
5612 /* Obtain the current value. */
5613 x
= mips_elf_obtain_contents (howto
, relocation
, input_bfd
, contents
);
5615 /* Clear the field we are setting. */
5616 x
&= ~howto
->dst_mask
;
5618 /* Set the field. */
5619 x
|= (value
& howto
->dst_mask
);
5621 /* If required, turn JAL into JALX. */
5622 if (cross_mode_jump_p
&& jal_reloc_p (r_type
))
5625 bfd_vma opcode
= x
>> 26;
5626 bfd_vma jalx_opcode
;
5628 /* Check to see if the opcode is already JAL or JALX. */
5629 if (r_type
== R_MIPS16_26
)
5631 ok
= ((opcode
== 0x6) || (opcode
== 0x7));
5636 ok
= ((opcode
== 0x3) || (opcode
== 0x1d));
5640 /* If the opcode is not JAL or JALX, there's a problem. */
5643 (*_bfd_error_handler
)
5644 (_("%B: %A+0x%lx: jump to stub routine which is not jal"),
5647 (unsigned long) relocation
->r_offset
);
5648 bfd_set_error (bfd_error_bad_value
);
5652 /* Make this the JALX opcode. */
5653 x
= (x
& ~(0x3f << 26)) | (jalx_opcode
<< 26);
5656 /* Try converting JAL to BAL and J(AL)R to B(AL), if the target is in
5658 if (!info
->relocatable
5659 && !cross_mode_jump_p
5660 && ((JAL_TO_BAL_P (input_bfd
)
5661 && r_type
== R_MIPS_26
5662 && (x
>> 26) == 0x3) /* jal addr */
5663 || (JALR_TO_BAL_P (input_bfd
)
5664 && r_type
== R_MIPS_JALR
5665 && x
== 0x0320f809) /* jalr t9 */
5666 || (JR_TO_B_P (input_bfd
)
5667 && r_type
== R_MIPS_JALR
5668 && x
== 0x03200008))) /* jr t9 */
5674 addr
= (input_section
->output_section
->vma
5675 + input_section
->output_offset
5676 + relocation
->r_offset
5678 if (r_type
== R_MIPS_26
)
5679 dest
= (value
<< 2) | ((addr
>> 28) << 28);
5683 if (off
<= 0x1ffff && off
>= -0x20000)
5685 if (x
== 0x03200008) /* jr t9 */
5686 x
= 0x10000000 | (((bfd_vma
) off
>> 2) & 0xffff); /* b addr */
5688 x
= 0x04110000 | (((bfd_vma
) off
>> 2) & 0xffff); /* bal addr */
5692 /* Put the value into the output. */
5693 bfd_put (8 * bfd_get_reloc_size (howto
), input_bfd
, x
, location
);
5695 _bfd_mips16_elf_reloc_shuffle(input_bfd
, r_type
, !info
->relocatable
,
5701 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
5702 is the original relocation, which is now being transformed into a
5703 dynamic relocation. The ADDENDP is adjusted if necessary; the
5704 caller should store the result in place of the original addend. */
5707 mips_elf_create_dynamic_relocation (bfd
*output_bfd
,
5708 struct bfd_link_info
*info
,
5709 const Elf_Internal_Rela
*rel
,
5710 struct mips_elf_link_hash_entry
*h
,
5711 asection
*sec
, bfd_vma symbol
,
5712 bfd_vma
*addendp
, asection
*input_section
)
5714 Elf_Internal_Rela outrel
[3];
5719 bfd_boolean defined_p
;
5720 struct mips_elf_link_hash_table
*htab
;
5722 htab
= mips_elf_hash_table (info
);
5723 BFD_ASSERT (htab
!= NULL
);
5725 r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
5726 dynobj
= elf_hash_table (info
)->dynobj
;
5727 sreloc
= mips_elf_rel_dyn_section (info
, FALSE
);
5728 BFD_ASSERT (sreloc
!= NULL
);
5729 BFD_ASSERT (sreloc
->contents
!= NULL
);
5730 BFD_ASSERT (sreloc
->reloc_count
* MIPS_ELF_REL_SIZE (output_bfd
)
5733 outrel
[0].r_offset
=
5734 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[0].r_offset
);
5735 if (ABI_64_P (output_bfd
))
5737 outrel
[1].r_offset
=
5738 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[1].r_offset
);
5739 outrel
[2].r_offset
=
5740 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[2].r_offset
);
5743 if (outrel
[0].r_offset
== MINUS_ONE
)
5744 /* The relocation field has been deleted. */
5747 if (outrel
[0].r_offset
== MINUS_TWO
)
5749 /* The relocation field has been converted into a relative value of
5750 some sort. Functions like _bfd_elf_write_section_eh_frame expect
5751 the field to be fully relocated, so add in the symbol's value. */
5756 /* We must now calculate the dynamic symbol table index to use
5757 in the relocation. */
5759 && (!h
->root
.def_regular
5760 || (info
->shared
&& !info
->symbolic
&& !h
->root
.forced_local
)))
5762 indx
= h
->root
.dynindx
;
5763 if (SGI_COMPAT (output_bfd
))
5764 defined_p
= h
->root
.def_regular
;
5766 /* ??? glibc's ld.so just adds the final GOT entry to the
5767 relocation field. It therefore treats relocs against
5768 defined symbols in the same way as relocs against
5769 undefined symbols. */
5774 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
5776 else if (sec
== NULL
|| sec
->owner
== NULL
)
5778 bfd_set_error (bfd_error_bad_value
);
5783 indx
= elf_section_data (sec
->output_section
)->dynindx
;
5786 asection
*osec
= htab
->root
.text_index_section
;
5787 indx
= elf_section_data (osec
)->dynindx
;
5793 /* Instead of generating a relocation using the section
5794 symbol, we may as well make it a fully relative
5795 relocation. We want to avoid generating relocations to
5796 local symbols because we used to generate them
5797 incorrectly, without adding the original symbol value,
5798 which is mandated by the ABI for section symbols. In
5799 order to give dynamic loaders and applications time to
5800 phase out the incorrect use, we refrain from emitting
5801 section-relative relocations. It's not like they're
5802 useful, after all. This should be a bit more efficient
5804 /* ??? Although this behavior is compatible with glibc's ld.so,
5805 the ABI says that relocations against STN_UNDEF should have
5806 a symbol value of 0. Irix rld honors this, so relocations
5807 against STN_UNDEF have no effect. */
5808 if (!SGI_COMPAT (output_bfd
))
5813 /* If the relocation was previously an absolute relocation and
5814 this symbol will not be referred to by the relocation, we must
5815 adjust it by the value we give it in the dynamic symbol table.
5816 Otherwise leave the job up to the dynamic linker. */
5817 if (defined_p
&& r_type
!= R_MIPS_REL32
)
5820 if (htab
->is_vxworks
)
5821 /* VxWorks uses non-relative relocations for this. */
5822 outrel
[0].r_info
= ELF32_R_INFO (indx
, R_MIPS_32
);
5824 /* The relocation is always an REL32 relocation because we don't
5825 know where the shared library will wind up at load-time. */
5826 outrel
[0].r_info
= ELF_R_INFO (output_bfd
, (unsigned long) indx
,
5829 /* For strict adherence to the ABI specification, we should
5830 generate a R_MIPS_64 relocation record by itself before the
5831 _REL32/_64 record as well, such that the addend is read in as
5832 a 64-bit value (REL32 is a 32-bit relocation, after all).
5833 However, since none of the existing ELF64 MIPS dynamic
5834 loaders seems to care, we don't waste space with these
5835 artificial relocations. If this turns out to not be true,
5836 mips_elf_allocate_dynamic_relocation() should be tweaked so
5837 as to make room for a pair of dynamic relocations per
5838 invocation if ABI_64_P, and here we should generate an
5839 additional relocation record with R_MIPS_64 by itself for a
5840 NULL symbol before this relocation record. */
5841 outrel
[1].r_info
= ELF_R_INFO (output_bfd
, 0,
5842 ABI_64_P (output_bfd
)
5845 outrel
[2].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_NONE
);
5847 /* Adjust the output offset of the relocation to reference the
5848 correct location in the output file. */
5849 outrel
[0].r_offset
+= (input_section
->output_section
->vma
5850 + input_section
->output_offset
);
5851 outrel
[1].r_offset
+= (input_section
->output_section
->vma
5852 + input_section
->output_offset
);
5853 outrel
[2].r_offset
+= (input_section
->output_section
->vma
5854 + input_section
->output_offset
);
5856 /* Put the relocation back out. We have to use the special
5857 relocation outputter in the 64-bit case since the 64-bit
5858 relocation format is non-standard. */
5859 if (ABI_64_P (output_bfd
))
5861 (*get_elf_backend_data (output_bfd
)->s
->swap_reloc_out
)
5862 (output_bfd
, &outrel
[0],
5864 + sreloc
->reloc_count
* sizeof (Elf64_Mips_External_Rel
)));
5866 else if (htab
->is_vxworks
)
5868 /* VxWorks uses RELA rather than REL dynamic relocations. */
5869 outrel
[0].r_addend
= *addendp
;
5870 bfd_elf32_swap_reloca_out
5871 (output_bfd
, &outrel
[0],
5873 + sreloc
->reloc_count
* sizeof (Elf32_External_Rela
)));
5876 bfd_elf32_swap_reloc_out
5877 (output_bfd
, &outrel
[0],
5878 (sreloc
->contents
+ sreloc
->reloc_count
* sizeof (Elf32_External_Rel
)));
5880 /* We've now added another relocation. */
5881 ++sreloc
->reloc_count
;
5883 /* Make sure the output section is writable. The dynamic linker
5884 will be writing to it. */
5885 elf_section_data (input_section
->output_section
)->this_hdr
.sh_flags
5888 /* On IRIX5, make an entry of compact relocation info. */
5889 if (IRIX_COMPAT (output_bfd
) == ict_irix5
)
5891 asection
*scpt
= bfd_get_section_by_name (dynobj
, ".compact_rel");
5896 Elf32_crinfo cptrel
;
5898 mips_elf_set_cr_format (cptrel
, CRF_MIPS_LONG
);
5899 cptrel
.vaddr
= (rel
->r_offset
5900 + input_section
->output_section
->vma
5901 + input_section
->output_offset
);
5902 if (r_type
== R_MIPS_REL32
)
5903 mips_elf_set_cr_type (cptrel
, CRT_MIPS_REL32
);
5905 mips_elf_set_cr_type (cptrel
, CRT_MIPS_WORD
);
5906 mips_elf_set_cr_dist2to (cptrel
, 0);
5907 cptrel
.konst
= *addendp
;
5909 cr
= (scpt
->contents
5910 + sizeof (Elf32_External_compact_rel
));
5911 mips_elf_set_cr_relvaddr (cptrel
, 0);
5912 bfd_elf32_swap_crinfo_out (output_bfd
, &cptrel
,
5913 ((Elf32_External_crinfo
*) cr
5914 + scpt
->reloc_count
));
5915 ++scpt
->reloc_count
;
5919 /* If we've written this relocation for a readonly section,
5920 we need to set DF_TEXTREL again, so that we do not delete the
5922 if (MIPS_ELF_READONLY_SECTION (input_section
))
5923 info
->flags
|= DF_TEXTREL
;
5928 /* Return the MACH for a MIPS e_flags value. */
5931 _bfd_elf_mips_mach (flagword flags
)
5933 switch (flags
& EF_MIPS_MACH
)
5935 case E_MIPS_MACH_3900
:
5936 return bfd_mach_mips3900
;
5938 case E_MIPS_MACH_4010
:
5939 return bfd_mach_mips4010
;
5941 case E_MIPS_MACH_4100
:
5942 return bfd_mach_mips4100
;
5944 case E_MIPS_MACH_4111
:
5945 return bfd_mach_mips4111
;
5947 case E_MIPS_MACH_4120
:
5948 return bfd_mach_mips4120
;
5950 case E_MIPS_MACH_4650
:
5951 return bfd_mach_mips4650
;
5953 case E_MIPS_MACH_5400
:
5954 return bfd_mach_mips5400
;
5956 case E_MIPS_MACH_5500
:
5957 return bfd_mach_mips5500
;
5959 case E_MIPS_MACH_9000
:
5960 return bfd_mach_mips9000
;
5962 case E_MIPS_MACH_SB1
:
5963 return bfd_mach_mips_sb1
;
5965 case E_MIPS_MACH_LS2E
:
5966 return bfd_mach_mips_loongson_2e
;
5968 case E_MIPS_MACH_LS2F
:
5969 return bfd_mach_mips_loongson_2f
;
5971 case E_MIPS_MACH_OCTEON
:
5972 return bfd_mach_mips_octeon
;
5974 case E_MIPS_MACH_XLR
:
5975 return bfd_mach_mips_xlr
;
5978 switch (flags
& EF_MIPS_ARCH
)
5982 return bfd_mach_mips3000
;
5985 return bfd_mach_mips6000
;
5988 return bfd_mach_mips4000
;
5991 return bfd_mach_mips8000
;
5994 return bfd_mach_mips5
;
5996 case E_MIPS_ARCH_32
:
5997 return bfd_mach_mipsisa32
;
5999 case E_MIPS_ARCH_64
:
6000 return bfd_mach_mipsisa64
;
6002 case E_MIPS_ARCH_32R2
:
6003 return bfd_mach_mipsisa32r2
;
6005 case E_MIPS_ARCH_64R2
:
6006 return bfd_mach_mipsisa64r2
;
6013 /* Return printable name for ABI. */
6015 static INLINE
char *
6016 elf_mips_abi_name (bfd
*abfd
)
6020 flags
= elf_elfheader (abfd
)->e_flags
;
6021 switch (flags
& EF_MIPS_ABI
)
6024 if (ABI_N32_P (abfd
))
6026 else if (ABI_64_P (abfd
))
6030 case E_MIPS_ABI_O32
:
6032 case E_MIPS_ABI_O64
:
6034 case E_MIPS_ABI_EABI32
:
6036 case E_MIPS_ABI_EABI64
:
6039 return "unknown abi";
6043 /* MIPS ELF uses two common sections. One is the usual one, and the
6044 other is for small objects. All the small objects are kept
6045 together, and then referenced via the gp pointer, which yields
6046 faster assembler code. This is what we use for the small common
6047 section. This approach is copied from ecoff.c. */
6048 static asection mips_elf_scom_section
;
6049 static asymbol mips_elf_scom_symbol
;
6050 static asymbol
*mips_elf_scom_symbol_ptr
;
6052 /* MIPS ELF also uses an acommon section, which represents an
6053 allocated common symbol which may be overridden by a
6054 definition in a shared library. */
6055 static asection mips_elf_acom_section
;
6056 static asymbol mips_elf_acom_symbol
;
6057 static asymbol
*mips_elf_acom_symbol_ptr
;
6059 /* This is used for both the 32-bit and the 64-bit ABI. */
6062 _bfd_mips_elf_symbol_processing (bfd
*abfd
, asymbol
*asym
)
6064 elf_symbol_type
*elfsym
;
6066 /* Handle the special MIPS section numbers that a symbol may use. */
6067 elfsym
= (elf_symbol_type
*) asym
;
6068 switch (elfsym
->internal_elf_sym
.st_shndx
)
6070 case SHN_MIPS_ACOMMON
:
6071 /* This section is used in a dynamically linked executable file.
6072 It is an allocated common section. The dynamic linker can
6073 either resolve these symbols to something in a shared
6074 library, or it can just leave them here. For our purposes,
6075 we can consider these symbols to be in a new section. */
6076 if (mips_elf_acom_section
.name
== NULL
)
6078 /* Initialize the acommon section. */
6079 mips_elf_acom_section
.name
= ".acommon";
6080 mips_elf_acom_section
.flags
= SEC_ALLOC
;
6081 mips_elf_acom_section
.output_section
= &mips_elf_acom_section
;
6082 mips_elf_acom_section
.symbol
= &mips_elf_acom_symbol
;
6083 mips_elf_acom_section
.symbol_ptr_ptr
= &mips_elf_acom_symbol_ptr
;
6084 mips_elf_acom_symbol
.name
= ".acommon";
6085 mips_elf_acom_symbol
.flags
= BSF_SECTION_SYM
;
6086 mips_elf_acom_symbol
.section
= &mips_elf_acom_section
;
6087 mips_elf_acom_symbol_ptr
= &mips_elf_acom_symbol
;
6089 asym
->section
= &mips_elf_acom_section
;
6093 /* Common symbols less than the GP size are automatically
6094 treated as SHN_MIPS_SCOMMON symbols on IRIX5. */
6095 if (asym
->value
> elf_gp_size (abfd
)
6096 || ELF_ST_TYPE (elfsym
->internal_elf_sym
.st_info
) == STT_TLS
6097 || IRIX_COMPAT (abfd
) == ict_irix6
)
6100 case SHN_MIPS_SCOMMON
:
6101 if (mips_elf_scom_section
.name
== NULL
)
6103 /* Initialize the small common section. */
6104 mips_elf_scom_section
.name
= ".scommon";
6105 mips_elf_scom_section
.flags
= SEC_IS_COMMON
;
6106 mips_elf_scom_section
.output_section
= &mips_elf_scom_section
;
6107 mips_elf_scom_section
.symbol
= &mips_elf_scom_symbol
;
6108 mips_elf_scom_section
.symbol_ptr_ptr
= &mips_elf_scom_symbol_ptr
;
6109 mips_elf_scom_symbol
.name
= ".scommon";
6110 mips_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
6111 mips_elf_scom_symbol
.section
= &mips_elf_scom_section
;
6112 mips_elf_scom_symbol_ptr
= &mips_elf_scom_symbol
;
6114 asym
->section
= &mips_elf_scom_section
;
6115 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
6118 case SHN_MIPS_SUNDEFINED
:
6119 asym
->section
= bfd_und_section_ptr
;
6124 asection
*section
= bfd_get_section_by_name (abfd
, ".text");
6126 BFD_ASSERT (SGI_COMPAT (abfd
));
6127 if (section
!= NULL
)
6129 asym
->section
= section
;
6130 /* MIPS_TEXT is a bit special, the address is not an offset
6131 to the base of the .text section. So substract the section
6132 base address to make it an offset. */
6133 asym
->value
-= section
->vma
;
6140 asection
*section
= bfd_get_section_by_name (abfd
, ".data");
6142 BFD_ASSERT (SGI_COMPAT (abfd
));
6143 if (section
!= NULL
)
6145 asym
->section
= section
;
6146 /* MIPS_DATA is a bit special, the address is not an offset
6147 to the base of the .data section. So substract the section
6148 base address to make it an offset. */
6149 asym
->value
-= section
->vma
;
6155 /* If this is an odd-valued function symbol, assume it's a MIPS16 one. */
6156 if (ELF_ST_TYPE (elfsym
->internal_elf_sym
.st_info
) == STT_FUNC
6157 && (asym
->value
& 1) != 0)
6160 elfsym
->internal_elf_sym
.st_other
6161 = ELF_ST_SET_MIPS16 (elfsym
->internal_elf_sym
.st_other
);
6165 /* Implement elf_backend_eh_frame_address_size. This differs from
6166 the default in the way it handles EABI64.
6168 EABI64 was originally specified as an LP64 ABI, and that is what
6169 -mabi=eabi normally gives on a 64-bit target. However, gcc has
6170 historically accepted the combination of -mabi=eabi and -mlong32,
6171 and this ILP32 variation has become semi-official over time.
6172 Both forms use elf32 and have pointer-sized FDE addresses.
6174 If an EABI object was generated by GCC 4.0 or above, it will have
6175 an empty .gcc_compiled_longXX section, where XX is the size of longs
6176 in bits. Unfortunately, ILP32 objects generated by earlier compilers
6177 have no special marking to distinguish them from LP64 objects.
6179 We don't want users of the official LP64 ABI to be punished for the
6180 existence of the ILP32 variant, but at the same time, we don't want
6181 to mistakenly interpret pre-4.0 ILP32 objects as being LP64 objects.
6182 We therefore take the following approach:
6184 - If ABFD contains a .gcc_compiled_longXX section, use it to
6185 determine the pointer size.
6187 - Otherwise check the type of the first relocation. Assume that
6188 the LP64 ABI is being used if the relocation is of type R_MIPS_64.
6192 The second check is enough to detect LP64 objects generated by pre-4.0
6193 compilers because, in the kind of output generated by those compilers,
6194 the first relocation will be associated with either a CIE personality
6195 routine or an FDE start address. Furthermore, the compilers never
6196 used a special (non-pointer) encoding for this ABI.
6198 Checking the relocation type should also be safe because there is no
6199 reason to use R_MIPS_64 in an ILP32 object. Pre-4.0 compilers never
6203 _bfd_mips_elf_eh_frame_address_size (bfd
*abfd
, asection
*sec
)
6205 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
6207 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
6209 bfd_boolean long32_p
, long64_p
;
6211 long32_p
= bfd_get_section_by_name (abfd
, ".gcc_compiled_long32") != 0;
6212 long64_p
= bfd_get_section_by_name (abfd
, ".gcc_compiled_long64") != 0;
6213 if (long32_p
&& long64_p
)
6220 if (sec
->reloc_count
> 0
6221 && elf_section_data (sec
)->relocs
!= NULL
6222 && (ELF32_R_TYPE (elf_section_data (sec
)->relocs
[0].r_info
)
6231 /* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
6232 relocations against two unnamed section symbols to resolve to the
6233 same address. For example, if we have code like:
6235 lw $4,%got_disp(.data)($gp)
6236 lw $25,%got_disp(.text)($gp)
6239 then the linker will resolve both relocations to .data and the program
6240 will jump there rather than to .text.
6242 We can work around this problem by giving names to local section symbols.
6243 This is also what the MIPSpro tools do. */
6246 _bfd_mips_elf_name_local_section_symbols (bfd
*abfd
)
6248 return SGI_COMPAT (abfd
);
6251 /* Work over a section just before writing it out. This routine is
6252 used by both the 32-bit and the 64-bit ABI. FIXME: We recognize
6253 sections that need the SHF_MIPS_GPREL flag by name; there has to be
6257 _bfd_mips_elf_section_processing (bfd
*abfd
, Elf_Internal_Shdr
*hdr
)
6259 if (hdr
->sh_type
== SHT_MIPS_REGINFO
6260 && hdr
->sh_size
> 0)
6264 BFD_ASSERT (hdr
->sh_size
== sizeof (Elf32_External_RegInfo
));
6265 BFD_ASSERT (hdr
->contents
== NULL
);
6268 hdr
->sh_offset
+ sizeof (Elf32_External_RegInfo
) - 4,
6271 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
6272 if (bfd_bwrite (buf
, 4, abfd
) != 4)
6276 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
6277 && hdr
->bfd_section
!= NULL
6278 && mips_elf_section_data (hdr
->bfd_section
) != NULL
6279 && mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
!= NULL
)
6281 bfd_byte
*contents
, *l
, *lend
;
6283 /* We stored the section contents in the tdata field in the
6284 set_section_contents routine. We save the section contents
6285 so that we don't have to read them again.
6286 At this point we know that elf_gp is set, so we can look
6287 through the section contents to see if there is an
6288 ODK_REGINFO structure. */
6290 contents
= mips_elf_section_data (hdr
->bfd_section
)->u
.tdata
;
6292 lend
= contents
+ hdr
->sh_size
;
6293 while (l
+ sizeof (Elf_External_Options
) <= lend
)
6295 Elf_Internal_Options intopt
;
6297 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
6299 if (intopt
.size
< sizeof (Elf_External_Options
))
6301 (*_bfd_error_handler
)
6302 (_("%B: Warning: bad `%s' option size %u smaller than its header"),
6303 abfd
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
), intopt
.size
);
6306 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
6313 + sizeof (Elf_External_Options
)
6314 + (sizeof (Elf64_External_RegInfo
) - 8)),
6317 H_PUT_64 (abfd
, elf_gp (abfd
), buf
);
6318 if (bfd_bwrite (buf
, 8, abfd
) != 8)
6321 else if (intopt
.kind
== ODK_REGINFO
)
6328 + sizeof (Elf_External_Options
)
6329 + (sizeof (Elf32_External_RegInfo
) - 4)),
6332 H_PUT_32 (abfd
, elf_gp (abfd
), buf
);
6333 if (bfd_bwrite (buf
, 4, abfd
) != 4)
6340 if (hdr
->bfd_section
!= NULL
)
6342 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
6344 /* .sbss is not handled specially here because the GNU/Linux
6345 prelinker can convert .sbss from NOBITS to PROGBITS and
6346 changing it back to NOBITS breaks the binary. The entry in
6347 _bfd_mips_elf_special_sections will ensure the correct flags
6348 are set on .sbss if BFD creates it without reading it from an
6349 input file, and without special handling here the flags set
6350 on it in an input file will be followed. */
6351 if (strcmp (name
, ".sdata") == 0
6352 || strcmp (name
, ".lit8") == 0
6353 || strcmp (name
, ".lit4") == 0)
6355 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_MIPS_GPREL
;
6356 hdr
->sh_type
= SHT_PROGBITS
;
6358 else if (strcmp (name
, ".srdata") == 0)
6360 hdr
->sh_flags
|= SHF_ALLOC
| SHF_MIPS_GPREL
;
6361 hdr
->sh_type
= SHT_PROGBITS
;
6363 else if (strcmp (name
, ".compact_rel") == 0)
6366 hdr
->sh_type
= SHT_PROGBITS
;
6368 else if (strcmp (name
, ".rtproc") == 0)
6370 if (hdr
->sh_addralign
!= 0 && hdr
->sh_entsize
== 0)
6372 unsigned int adjust
;
6374 adjust
= hdr
->sh_size
% hdr
->sh_addralign
;
6376 hdr
->sh_size
+= hdr
->sh_addralign
- adjust
;
6384 /* Handle a MIPS specific section when reading an object file. This
6385 is called when elfcode.h finds a section with an unknown type.
6386 This routine supports both the 32-bit and 64-bit ELF ABI.
6388 FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
6392 _bfd_mips_elf_section_from_shdr (bfd
*abfd
,
6393 Elf_Internal_Shdr
*hdr
,
6399 /* There ought to be a place to keep ELF backend specific flags, but
6400 at the moment there isn't one. We just keep track of the
6401 sections by their name, instead. Fortunately, the ABI gives
6402 suggested names for all the MIPS specific sections, so we will
6403 probably get away with this. */
6404 switch (hdr
->sh_type
)
6406 case SHT_MIPS_LIBLIST
:
6407 if (strcmp (name
, ".liblist") != 0)
6411 if (strcmp (name
, ".msym") != 0)
6414 case SHT_MIPS_CONFLICT
:
6415 if (strcmp (name
, ".conflict") != 0)
6418 case SHT_MIPS_GPTAB
:
6419 if (! CONST_STRNEQ (name
, ".gptab."))
6422 case SHT_MIPS_UCODE
:
6423 if (strcmp (name
, ".ucode") != 0)
6426 case SHT_MIPS_DEBUG
:
6427 if (strcmp (name
, ".mdebug") != 0)
6429 flags
= SEC_DEBUGGING
;
6431 case SHT_MIPS_REGINFO
:
6432 if (strcmp (name
, ".reginfo") != 0
6433 || hdr
->sh_size
!= sizeof (Elf32_External_RegInfo
))
6435 flags
= (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_SAME_SIZE
);
6437 case SHT_MIPS_IFACE
:
6438 if (strcmp (name
, ".MIPS.interfaces") != 0)
6441 case SHT_MIPS_CONTENT
:
6442 if (! CONST_STRNEQ (name
, ".MIPS.content"))
6445 case SHT_MIPS_OPTIONS
:
6446 if (!MIPS_ELF_OPTIONS_SECTION_NAME_P (name
))
6449 case SHT_MIPS_DWARF
:
6450 if (! CONST_STRNEQ (name
, ".debug_")
6451 && ! CONST_STRNEQ (name
, ".zdebug_"))
6454 case SHT_MIPS_SYMBOL_LIB
:
6455 if (strcmp (name
, ".MIPS.symlib") != 0)
6458 case SHT_MIPS_EVENTS
:
6459 if (! CONST_STRNEQ (name
, ".MIPS.events")
6460 && ! CONST_STRNEQ (name
, ".MIPS.post_rel"))
6467 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
6472 if (! bfd_set_section_flags (abfd
, hdr
->bfd_section
,
6473 (bfd_get_section_flags (abfd
,
6479 /* FIXME: We should record sh_info for a .gptab section. */
6481 /* For a .reginfo section, set the gp value in the tdata information
6482 from the contents of this section. We need the gp value while
6483 processing relocs, so we just get it now. The .reginfo section
6484 is not used in the 64-bit MIPS ELF ABI. */
6485 if (hdr
->sh_type
== SHT_MIPS_REGINFO
)
6487 Elf32_External_RegInfo ext
;
6490 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
,
6491 &ext
, 0, sizeof ext
))
6493 bfd_mips_elf32_swap_reginfo_in (abfd
, &ext
, &s
);
6494 elf_gp (abfd
) = s
.ri_gp_value
;
6497 /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
6498 set the gp value based on what we find. We may see both
6499 SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
6500 they should agree. */
6501 if (hdr
->sh_type
== SHT_MIPS_OPTIONS
)
6503 bfd_byte
*contents
, *l
, *lend
;
6505 contents
= bfd_malloc (hdr
->sh_size
);
6506 if (contents
== NULL
)
6508 if (! bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
,
6515 lend
= contents
+ hdr
->sh_size
;
6516 while (l
+ sizeof (Elf_External_Options
) <= lend
)
6518 Elf_Internal_Options intopt
;
6520 bfd_mips_elf_swap_options_in (abfd
, (Elf_External_Options
*) l
,
6522 if (intopt
.size
< sizeof (Elf_External_Options
))
6524 (*_bfd_error_handler
)
6525 (_("%B: Warning: bad `%s' option size %u smaller than its header"),
6526 abfd
, MIPS_ELF_OPTIONS_SECTION_NAME (abfd
), intopt
.size
);
6529 if (ABI_64_P (abfd
) && intopt
.kind
== ODK_REGINFO
)
6531 Elf64_Internal_RegInfo intreg
;
6533 bfd_mips_elf64_swap_reginfo_in
6535 ((Elf64_External_RegInfo
*)
6536 (l
+ sizeof (Elf_External_Options
))),
6538 elf_gp (abfd
) = intreg
.ri_gp_value
;
6540 else if (intopt
.kind
== ODK_REGINFO
)
6542 Elf32_RegInfo intreg
;
6544 bfd_mips_elf32_swap_reginfo_in
6546 ((Elf32_External_RegInfo
*)
6547 (l
+ sizeof (Elf_External_Options
))),
6549 elf_gp (abfd
) = intreg
.ri_gp_value
;
6559 /* Set the correct type for a MIPS ELF section. We do this by the
6560 section name, which is a hack, but ought to work. This routine is
6561 used by both the 32-bit and the 64-bit ABI. */
6564 _bfd_mips_elf_fake_sections (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*sec
)
6566 const char *name
= bfd_get_section_name (abfd
, sec
);
6568 if (strcmp (name
, ".liblist") == 0)
6570 hdr
->sh_type
= SHT_MIPS_LIBLIST
;
6571 hdr
->sh_info
= sec
->size
/ sizeof (Elf32_Lib
);
6572 /* The sh_link field is set in final_write_processing. */
6574 else if (strcmp (name
, ".conflict") == 0)
6575 hdr
->sh_type
= SHT_MIPS_CONFLICT
;
6576 else if (CONST_STRNEQ (name
, ".gptab."))
6578 hdr
->sh_type
= SHT_MIPS_GPTAB
;
6579 hdr
->sh_entsize
= sizeof (Elf32_External_gptab
);
6580 /* The sh_info field is set in final_write_processing. */
6582 else if (strcmp (name
, ".ucode") == 0)
6583 hdr
->sh_type
= SHT_MIPS_UCODE
;
6584 else if (strcmp (name
, ".mdebug") == 0)
6586 hdr
->sh_type
= SHT_MIPS_DEBUG
;
6587 /* In a shared object on IRIX 5.3, the .mdebug section has an
6588 entsize of 0. FIXME: Does this matter? */
6589 if (SGI_COMPAT (abfd
) && (abfd
->flags
& DYNAMIC
) != 0)
6590 hdr
->sh_entsize
= 0;
6592 hdr
->sh_entsize
= 1;
6594 else if (strcmp (name
, ".reginfo") == 0)
6596 hdr
->sh_type
= SHT_MIPS_REGINFO
;
6597 /* In a shared object on IRIX 5.3, the .reginfo section has an
6598 entsize of 0x18. FIXME: Does this matter? */
6599 if (SGI_COMPAT (abfd
))
6601 if ((abfd
->flags
& DYNAMIC
) != 0)
6602 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
6604 hdr
->sh_entsize
= 1;
6607 hdr
->sh_entsize
= sizeof (Elf32_External_RegInfo
);
6609 else if (SGI_COMPAT (abfd
)
6610 && (strcmp (name
, ".hash") == 0
6611 || strcmp (name
, ".dynamic") == 0
6612 || strcmp (name
, ".dynstr") == 0))
6614 if (SGI_COMPAT (abfd
))
6615 hdr
->sh_entsize
= 0;
6617 /* This isn't how the IRIX6 linker behaves. */
6618 hdr
->sh_info
= SIZEOF_MIPS_DYNSYM_SECNAMES
;
6621 else if (strcmp (name
, ".got") == 0
6622 || strcmp (name
, ".srdata") == 0
6623 || strcmp (name
, ".sdata") == 0
6624 || strcmp (name
, ".sbss") == 0
6625 || strcmp (name
, ".lit4") == 0
6626 || strcmp (name
, ".lit8") == 0)
6627 hdr
->sh_flags
|= SHF_MIPS_GPREL
;
6628 else if (strcmp (name
, ".MIPS.interfaces") == 0)
6630 hdr
->sh_type
= SHT_MIPS_IFACE
;
6631 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
6633 else if (CONST_STRNEQ (name
, ".MIPS.content"))
6635 hdr
->sh_type
= SHT_MIPS_CONTENT
;
6636 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
6637 /* The sh_info field is set in final_write_processing. */
6639 else if (MIPS_ELF_OPTIONS_SECTION_NAME_P (name
))
6641 hdr
->sh_type
= SHT_MIPS_OPTIONS
;
6642 hdr
->sh_entsize
= 1;
6643 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
6645 else if (CONST_STRNEQ (name
, ".debug_")
6646 || CONST_STRNEQ (name
, ".zdebug_"))
6648 hdr
->sh_type
= SHT_MIPS_DWARF
;
6650 /* Irix facilities such as libexc expect a single .debug_frame
6651 per executable, the system ones have NOSTRIP set and the linker
6652 doesn't merge sections with different flags so ... */
6653 if (SGI_COMPAT (abfd
) && CONST_STRNEQ (name
, ".debug_frame"))
6654 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
6656 else if (strcmp (name
, ".MIPS.symlib") == 0)
6658 hdr
->sh_type
= SHT_MIPS_SYMBOL_LIB
;
6659 /* The sh_link and sh_info fields are set in
6660 final_write_processing. */
6662 else if (CONST_STRNEQ (name
, ".MIPS.events")
6663 || CONST_STRNEQ (name
, ".MIPS.post_rel"))
6665 hdr
->sh_type
= SHT_MIPS_EVENTS
;
6666 hdr
->sh_flags
|= SHF_MIPS_NOSTRIP
;
6667 /* The sh_link field is set in final_write_processing. */
6669 else if (strcmp (name
, ".msym") == 0)
6671 hdr
->sh_type
= SHT_MIPS_MSYM
;
6672 hdr
->sh_flags
|= SHF_ALLOC
;
6673 hdr
->sh_entsize
= 8;
6676 /* The generic elf_fake_sections will set up REL_HDR using the default
6677 kind of relocations. We used to set up a second header for the
6678 non-default kind of relocations here, but only NewABI would use
6679 these, and the IRIX ld doesn't like resulting empty RELA sections.
6680 Thus we create those header only on demand now. */
6685 /* Given a BFD section, try to locate the corresponding ELF section
6686 index. This is used by both the 32-bit and the 64-bit ABI.
6687 Actually, it's not clear to me that the 64-bit ABI supports these,
6688 but for non-PIC objects we will certainly want support for at least
6689 the .scommon section. */
6692 _bfd_mips_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
6693 asection
*sec
, int *retval
)
6695 if (strcmp (bfd_get_section_name (abfd
, sec
), ".scommon") == 0)
6697 *retval
= SHN_MIPS_SCOMMON
;
6700 if (strcmp (bfd_get_section_name (abfd
, sec
), ".acommon") == 0)
6702 *retval
= SHN_MIPS_ACOMMON
;
6708 /* Hook called by the linker routine which adds symbols from an object
6709 file. We must handle the special MIPS section numbers here. */
6712 _bfd_mips_elf_add_symbol_hook (bfd
*abfd
, struct bfd_link_info
*info
,
6713 Elf_Internal_Sym
*sym
, const char **namep
,
6714 flagword
*flagsp ATTRIBUTE_UNUSED
,
6715 asection
**secp
, bfd_vma
*valp
)
6717 if (SGI_COMPAT (abfd
)
6718 && (abfd
->flags
& DYNAMIC
) != 0
6719 && strcmp (*namep
, "_rld_new_interface") == 0)
6721 /* Skip IRIX5 rld entry name. */
6726 /* Shared objects may have a dynamic symbol '_gp_disp' defined as
6727 a SECTION *ABS*. This causes ld to think it can resolve _gp_disp
6728 by setting a DT_NEEDED for the shared object. Since _gp_disp is
6729 a magic symbol resolved by the linker, we ignore this bogus definition
6730 of _gp_disp. New ABI objects do not suffer from this problem so this
6731 is not done for them. */
6733 && (sym
->st_shndx
== SHN_ABS
)
6734 && (strcmp (*namep
, "_gp_disp") == 0))
6740 switch (sym
->st_shndx
)
6743 /* Common symbols less than the GP size are automatically
6744 treated as SHN_MIPS_SCOMMON symbols. */
6745 if (sym
->st_size
> elf_gp_size (abfd
)
6746 || ELF_ST_TYPE (sym
->st_info
) == STT_TLS
6747 || IRIX_COMPAT (abfd
) == ict_irix6
)
6750 case SHN_MIPS_SCOMMON
:
6751 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
6752 (*secp
)->flags
|= SEC_IS_COMMON
;
6753 *valp
= sym
->st_size
;
6757 /* This section is used in a shared object. */
6758 if (elf_tdata (abfd
)->elf_text_section
== NULL
)
6760 asymbol
*elf_text_symbol
;
6761 asection
*elf_text_section
;
6762 bfd_size_type amt
= sizeof (asection
);
6764 elf_text_section
= bfd_zalloc (abfd
, amt
);
6765 if (elf_text_section
== NULL
)
6768 amt
= sizeof (asymbol
);
6769 elf_text_symbol
= bfd_zalloc (abfd
, amt
);
6770 if (elf_text_symbol
== NULL
)
6773 /* Initialize the section. */
6775 elf_tdata (abfd
)->elf_text_section
= elf_text_section
;
6776 elf_tdata (abfd
)->elf_text_symbol
= elf_text_symbol
;
6778 elf_text_section
->symbol
= elf_text_symbol
;
6779 elf_text_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_text_symbol
;
6781 elf_text_section
->name
= ".text";
6782 elf_text_section
->flags
= SEC_NO_FLAGS
;
6783 elf_text_section
->output_section
= NULL
;
6784 elf_text_section
->owner
= abfd
;
6785 elf_text_symbol
->name
= ".text";
6786 elf_text_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
6787 elf_text_symbol
->section
= elf_text_section
;
6789 /* This code used to do *secp = bfd_und_section_ptr if
6790 info->shared. I don't know why, and that doesn't make sense,
6791 so I took it out. */
6792 *secp
= elf_tdata (abfd
)->elf_text_section
;
6795 case SHN_MIPS_ACOMMON
:
6796 /* Fall through. XXX Can we treat this as allocated data? */
6798 /* This section is used in a shared object. */
6799 if (elf_tdata (abfd
)->elf_data_section
== NULL
)
6801 asymbol
*elf_data_symbol
;
6802 asection
*elf_data_section
;
6803 bfd_size_type amt
= sizeof (asection
);
6805 elf_data_section
= bfd_zalloc (abfd
, amt
);
6806 if (elf_data_section
== NULL
)
6809 amt
= sizeof (asymbol
);
6810 elf_data_symbol
= bfd_zalloc (abfd
, amt
);
6811 if (elf_data_symbol
== NULL
)
6814 /* Initialize the section. */
6816 elf_tdata (abfd
)->elf_data_section
= elf_data_section
;
6817 elf_tdata (abfd
)->elf_data_symbol
= elf_data_symbol
;
6819 elf_data_section
->symbol
= elf_data_symbol
;
6820 elf_data_section
->symbol_ptr_ptr
= &elf_tdata (abfd
)->elf_data_symbol
;
6822 elf_data_section
->name
= ".data";
6823 elf_data_section
->flags
= SEC_NO_FLAGS
;
6824 elf_data_section
->output_section
= NULL
;
6825 elf_data_section
->owner
= abfd
;
6826 elf_data_symbol
->name
= ".data";
6827 elf_data_symbol
->flags
= BSF_SECTION_SYM
| BSF_DYNAMIC
;
6828 elf_data_symbol
->section
= elf_data_section
;
6830 /* This code used to do *secp = bfd_und_section_ptr if
6831 info->shared. I don't know why, and that doesn't make sense,
6832 so I took it out. */
6833 *secp
= elf_tdata (abfd
)->elf_data_section
;
6836 case SHN_MIPS_SUNDEFINED
:
6837 *secp
= bfd_und_section_ptr
;
6841 if (SGI_COMPAT (abfd
)
6843 && info
->output_bfd
->xvec
== abfd
->xvec
6844 && strcmp (*namep
, "__rld_obj_head") == 0)
6846 struct elf_link_hash_entry
*h
;
6847 struct bfd_link_hash_entry
*bh
;
6849 /* Mark __rld_obj_head as dynamic. */
6851 if (! (_bfd_generic_link_add_one_symbol
6852 (info
, abfd
, *namep
, BSF_GLOBAL
, *secp
, *valp
, NULL
, FALSE
,
6853 get_elf_backend_data (abfd
)->collect
, &bh
)))
6856 h
= (struct elf_link_hash_entry
*) bh
;
6859 h
->type
= STT_OBJECT
;
6861 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
6864 mips_elf_hash_table (info
)->use_rld_obj_head
= TRUE
;
6867 /* If this is a mips16 text symbol, add 1 to the value to make it
6868 odd. This will cause something like .word SYM to come up with
6869 the right value when it is loaded into the PC. */
6870 if (ELF_ST_IS_MIPS16 (sym
->st_other
))
6876 /* This hook function is called before the linker writes out a global
6877 symbol. We mark symbols as small common if appropriate. This is
6878 also where we undo the increment of the value for a mips16 symbol. */
6881 _bfd_mips_elf_link_output_symbol_hook
6882 (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6883 const char *name ATTRIBUTE_UNUSED
, Elf_Internal_Sym
*sym
,
6884 asection
*input_sec
, struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
)
6886 /* If we see a common symbol, which implies a relocatable link, then
6887 if a symbol was small common in an input file, mark it as small
6888 common in the output file. */
6889 if (sym
->st_shndx
== SHN_COMMON
6890 && strcmp (input_sec
->name
, ".scommon") == 0)
6891 sym
->st_shndx
= SHN_MIPS_SCOMMON
;
6893 if (ELF_ST_IS_MIPS16 (sym
->st_other
))
6894 sym
->st_value
&= ~1;
6899 /* Functions for the dynamic linker. */
6901 /* Create dynamic sections when linking against a dynamic object. */
6904 _bfd_mips_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
6906 struct elf_link_hash_entry
*h
;
6907 struct bfd_link_hash_entry
*bh
;
6909 register asection
*s
;
6910 const char * const *namep
;
6911 struct mips_elf_link_hash_table
*htab
;
6913 htab
= mips_elf_hash_table (info
);
6914 BFD_ASSERT (htab
!= NULL
);
6916 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
6917 | SEC_LINKER_CREATED
| SEC_READONLY
);
6919 /* The psABI requires a read-only .dynamic section, but the VxWorks
6921 if (!htab
->is_vxworks
)
6923 s
= bfd_get_section_by_name (abfd
, ".dynamic");
6926 if (! bfd_set_section_flags (abfd
, s
, flags
))
6931 /* We need to create .got section. */
6932 if (!mips_elf_create_got_section (abfd
, info
))
6935 if (! mips_elf_rel_dyn_section (info
, TRUE
))
6938 /* Create .stub section. */
6939 s
= bfd_make_section_with_flags (abfd
,
6940 MIPS_ELF_STUB_SECTION_NAME (abfd
),
6943 || ! bfd_set_section_alignment (abfd
, s
,
6944 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
6948 if ((IRIX_COMPAT (abfd
) == ict_irix5
|| IRIX_COMPAT (abfd
) == ict_none
)
6950 && bfd_get_section_by_name (abfd
, ".rld_map") == NULL
)
6952 s
= bfd_make_section_with_flags (abfd
, ".rld_map",
6953 flags
&~ (flagword
) SEC_READONLY
);
6955 || ! bfd_set_section_alignment (abfd
, s
,
6956 MIPS_ELF_LOG_FILE_ALIGN (abfd
)))
6960 /* On IRIX5, we adjust add some additional symbols and change the
6961 alignments of several sections. There is no ABI documentation
6962 indicating that this is necessary on IRIX6, nor any evidence that
6963 the linker takes such action. */
6964 if (IRIX_COMPAT (abfd
) == ict_irix5
)
6966 for (namep
= mips_elf_dynsym_rtproc_names
; *namep
!= NULL
; namep
++)
6969 if (! (_bfd_generic_link_add_one_symbol
6970 (info
, abfd
, *namep
, BSF_GLOBAL
, bfd_und_section_ptr
, 0,
6971 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
6974 h
= (struct elf_link_hash_entry
*) bh
;
6977 h
->type
= STT_SECTION
;
6979 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
6983 /* We need to create a .compact_rel section. */
6984 if (SGI_COMPAT (abfd
))
6986 if (!mips_elf_create_compact_rel_section (abfd
, info
))
6990 /* Change alignments of some sections. */
6991 s
= bfd_get_section_by_name (abfd
, ".hash");
6993 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
6994 s
= bfd_get_section_by_name (abfd
, ".dynsym");
6996 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
6997 s
= bfd_get_section_by_name (abfd
, ".dynstr");
6999 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
7000 s
= bfd_get_section_by_name (abfd
, ".reginfo");
7002 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
7003 s
= bfd_get_section_by_name (abfd
, ".dynamic");
7005 bfd_set_section_alignment (abfd
, s
, MIPS_ELF_LOG_FILE_ALIGN (abfd
));
7012 name
= SGI_COMPAT (abfd
) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
7014 if (!(_bfd_generic_link_add_one_symbol
7015 (info
, abfd
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
, 0,
7016 NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
7019 h
= (struct elf_link_hash_entry
*) bh
;
7022 h
->type
= STT_SECTION
;
7024 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
7027 if (! mips_elf_hash_table (info
)->use_rld_obj_head
)
7029 /* __rld_map is a four byte word located in the .data section
7030 and is filled in by the rtld to contain a pointer to
7031 the _r_debug structure. Its symbol value will be set in
7032 _bfd_mips_elf_finish_dynamic_symbol. */
7033 s
= bfd_get_section_by_name (abfd
, ".rld_map");
7034 BFD_ASSERT (s
!= NULL
);
7036 name
= SGI_COMPAT (abfd
) ? "__rld_map" : "__RLD_MAP";
7038 if (!(_bfd_generic_link_add_one_symbol
7039 (info
, abfd
, name
, BSF_GLOBAL
, s
, 0, NULL
, FALSE
,
7040 get_elf_backend_data (abfd
)->collect
, &bh
)))
7043 h
= (struct elf_link_hash_entry
*) bh
;
7046 h
->type
= STT_OBJECT
;
7048 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
7053 /* Create the .plt, .rel(a).plt, .dynbss and .rel(a).bss sections.
7054 Also create the _PROCEDURE_LINKAGE_TABLE symbol. */
7055 if (!_bfd_elf_create_dynamic_sections (abfd
, info
))
7058 /* Cache the sections created above. */
7059 htab
->splt
= bfd_get_section_by_name (abfd
, ".plt");
7060 htab
->sdynbss
= bfd_get_section_by_name (abfd
, ".dynbss");
7061 if (htab
->is_vxworks
)
7063 htab
->srelbss
= bfd_get_section_by_name (abfd
, ".rela.bss");
7064 htab
->srelplt
= bfd_get_section_by_name (abfd
, ".rela.plt");
7067 htab
->srelplt
= bfd_get_section_by_name (abfd
, ".rel.plt");
7069 || (htab
->is_vxworks
&& !htab
->srelbss
&& !info
->shared
)
7074 if (htab
->is_vxworks
)
7076 /* Do the usual VxWorks handling. */
7077 if (!elf_vxworks_create_dynamic_sections (abfd
, info
, &htab
->srelplt2
))
7080 /* Work out the PLT sizes. */
7083 htab
->plt_header_size
7084 = 4 * ARRAY_SIZE (mips_vxworks_shared_plt0_entry
);
7085 htab
->plt_entry_size
7086 = 4 * ARRAY_SIZE (mips_vxworks_shared_plt_entry
);
7090 htab
->plt_header_size
7091 = 4 * ARRAY_SIZE (mips_vxworks_exec_plt0_entry
);
7092 htab
->plt_entry_size
7093 = 4 * ARRAY_SIZE (mips_vxworks_exec_plt_entry
);
7096 else if (!info
->shared
)
7098 /* All variants of the plt0 entry are the same size. */
7099 htab
->plt_header_size
= 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry
);
7100 htab
->plt_entry_size
= 4 * ARRAY_SIZE (mips_exec_plt_entry
);
7106 /* Return true if relocation REL against section SEC is a REL rather than
7107 RELA relocation. RELOCS is the first relocation in the section and
7108 ABFD is the bfd that contains SEC. */
7111 mips_elf_rel_relocation_p (bfd
*abfd
, asection
*sec
,
7112 const Elf_Internal_Rela
*relocs
,
7113 const Elf_Internal_Rela
*rel
)
7115 Elf_Internal_Shdr
*rel_hdr
;
7116 const struct elf_backend_data
*bed
;
7118 /* To determine which flavor or relocation this is, we depend on the
7119 fact that the INPUT_SECTION's REL_HDR is read before its REL_HDR2. */
7120 rel_hdr
= &elf_section_data (sec
)->rel_hdr
;
7121 bed
= get_elf_backend_data (abfd
);
7122 if ((size_t) (rel
- relocs
)
7123 >= (NUM_SHDR_ENTRIES (rel_hdr
) * bed
->s
->int_rels_per_ext_rel
))
7124 rel_hdr
= elf_section_data (sec
)->rel_hdr2
;
7125 return rel_hdr
->sh_entsize
== MIPS_ELF_REL_SIZE (abfd
);
7128 /* Read the addend for REL relocation REL, which belongs to bfd ABFD.
7129 HOWTO is the relocation's howto and CONTENTS points to the contents
7130 of the section that REL is against. */
7133 mips_elf_read_rel_addend (bfd
*abfd
, const Elf_Internal_Rela
*rel
,
7134 reloc_howto_type
*howto
, bfd_byte
*contents
)
7137 unsigned int r_type
;
7140 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
7141 location
= contents
+ rel
->r_offset
;
7143 /* Get the addend, which is stored in the input file. */
7144 _bfd_mips16_elf_reloc_unshuffle (abfd
, r_type
, FALSE
, location
);
7145 addend
= mips_elf_obtain_contents (howto
, rel
, abfd
, contents
);
7146 _bfd_mips16_elf_reloc_shuffle (abfd
, r_type
, FALSE
, location
);
7148 return addend
& howto
->src_mask
;
7151 /* REL is a relocation in ABFD that needs a partnering LO16 relocation
7152 and *ADDEND is the addend for REL itself. Look for the LO16 relocation
7153 and update *ADDEND with the final addend. Return true on success
7154 or false if the LO16 could not be found. RELEND is the exclusive
7155 upper bound on the relocations for REL's section. */
7158 mips_elf_add_lo16_rel_addend (bfd
*abfd
,
7159 const Elf_Internal_Rela
*rel
,
7160 const Elf_Internal_Rela
*relend
,
7161 bfd_byte
*contents
, bfd_vma
*addend
)
7163 unsigned int r_type
, lo16_type
;
7164 const Elf_Internal_Rela
*lo16_relocation
;
7165 reloc_howto_type
*lo16_howto
;
7168 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
7169 if (mips16_reloc_p (r_type
))
7170 lo16_type
= R_MIPS16_LO16
;
7172 lo16_type
= R_MIPS_LO16
;
7174 /* The combined value is the sum of the HI16 addend, left-shifted by
7175 sixteen bits, and the LO16 addend, sign extended. (Usually, the
7176 code does a `lui' of the HI16 value, and then an `addiu' of the
7179 Scan ahead to find a matching LO16 relocation.
7181 According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must
7182 be immediately following. However, for the IRIX6 ABI, the next
7183 relocation may be a composed relocation consisting of several
7184 relocations for the same address. In that case, the R_MIPS_LO16
7185 relocation may occur as one of these. We permit a similar
7186 extension in general, as that is useful for GCC.
7188 In some cases GCC dead code elimination removes the LO16 but keeps
7189 the corresponding HI16. This is strictly speaking a violation of
7190 the ABI but not immediately harmful. */
7191 lo16_relocation
= mips_elf_next_relocation (abfd
, lo16_type
, rel
, relend
);
7192 if (lo16_relocation
== NULL
)
7195 /* Obtain the addend kept there. */
7196 lo16_howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, lo16_type
, FALSE
);
7197 l
= mips_elf_read_rel_addend (abfd
, lo16_relocation
, lo16_howto
, contents
);
7199 l
<<= lo16_howto
->rightshift
;
7200 l
= _bfd_mips_elf_sign_extend (l
, 16);
7207 /* Try to read the contents of section SEC in bfd ABFD. Return true and
7208 store the contents in *CONTENTS on success. Assume that *CONTENTS
7209 already holds the contents if it is nonull on entry. */
7212 mips_elf_get_section_contents (bfd
*abfd
, asection
*sec
, bfd_byte
**contents
)
7217 /* Get cached copy if it exists. */
7218 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
7220 *contents
= elf_section_data (sec
)->this_hdr
.contents
;
7224 return bfd_malloc_and_get_section (abfd
, sec
, contents
);
7227 /* Look through the relocs for a section during the first phase, and
7228 allocate space in the global offset table. */
7231 _bfd_mips_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
7232 asection
*sec
, const Elf_Internal_Rela
*relocs
)
7236 Elf_Internal_Shdr
*symtab_hdr
;
7237 struct elf_link_hash_entry
**sym_hashes
;
7239 const Elf_Internal_Rela
*rel
;
7240 const Elf_Internal_Rela
*rel_end
;
7242 const struct elf_backend_data
*bed
;
7243 struct mips_elf_link_hash_table
*htab
;
7246 reloc_howto_type
*howto
;
7248 if (info
->relocatable
)
7251 htab
= mips_elf_hash_table (info
);
7252 BFD_ASSERT (htab
!= NULL
);
7254 dynobj
= elf_hash_table (info
)->dynobj
;
7255 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7256 sym_hashes
= elf_sym_hashes (abfd
);
7257 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
7259 bed
= get_elf_backend_data (abfd
);
7260 rel_end
= relocs
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
7262 /* Check for the mips16 stub sections. */
7264 name
= bfd_get_section_name (abfd
, sec
);
7265 if (FN_STUB_P (name
))
7267 unsigned long r_symndx
;
7269 /* Look at the relocation information to figure out which symbol
7272 r_symndx
= mips16_stub_symndx (sec
, relocs
, rel_end
);
7275 (*_bfd_error_handler
)
7276 (_("%B: Warning: cannot determine the target function for"
7277 " stub section `%s'"),
7279 bfd_set_error (bfd_error_bad_value
);
7283 if (r_symndx
< extsymoff
7284 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
7288 /* This stub is for a local symbol. This stub will only be
7289 needed if there is some relocation in this BFD, other
7290 than a 16 bit function call, which refers to this symbol. */
7291 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
7293 Elf_Internal_Rela
*sec_relocs
;
7294 const Elf_Internal_Rela
*r
, *rend
;
7296 /* We can ignore stub sections when looking for relocs. */
7297 if ((o
->flags
& SEC_RELOC
) == 0
7298 || o
->reloc_count
== 0
7299 || section_allows_mips16_refs_p (o
))
7303 = _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
7305 if (sec_relocs
== NULL
)
7308 rend
= sec_relocs
+ o
->reloc_count
;
7309 for (r
= sec_relocs
; r
< rend
; r
++)
7310 if (ELF_R_SYM (abfd
, r
->r_info
) == r_symndx
7311 && !mips16_call_reloc_p (ELF_R_TYPE (abfd
, r
->r_info
)))
7314 if (elf_section_data (o
)->relocs
!= sec_relocs
)
7323 /* There is no non-call reloc for this stub, so we do
7324 not need it. Since this function is called before
7325 the linker maps input sections to output sections, we
7326 can easily discard it by setting the SEC_EXCLUDE
7328 sec
->flags
|= SEC_EXCLUDE
;
7332 /* Record this stub in an array of local symbol stubs for
7334 if (elf_tdata (abfd
)->local_stubs
== NULL
)
7336 unsigned long symcount
;
7340 if (elf_bad_symtab (abfd
))
7341 symcount
= NUM_SHDR_ENTRIES (symtab_hdr
);
7343 symcount
= symtab_hdr
->sh_info
;
7344 amt
= symcount
* sizeof (asection
*);
7345 n
= bfd_zalloc (abfd
, amt
);
7348 elf_tdata (abfd
)->local_stubs
= n
;
7351 sec
->flags
|= SEC_KEEP
;
7352 elf_tdata (abfd
)->local_stubs
[r_symndx
] = sec
;
7354 /* We don't need to set mips16_stubs_seen in this case.
7355 That flag is used to see whether we need to look through
7356 the global symbol table for stubs. We don't need to set
7357 it here, because we just have a local stub. */
7361 struct mips_elf_link_hash_entry
*h
;
7363 h
= ((struct mips_elf_link_hash_entry
*)
7364 sym_hashes
[r_symndx
- extsymoff
]);
7366 while (h
->root
.root
.type
== bfd_link_hash_indirect
7367 || h
->root
.root
.type
== bfd_link_hash_warning
)
7368 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
7370 /* H is the symbol this stub is for. */
7372 /* If we already have an appropriate stub for this function, we
7373 don't need another one, so we can discard this one. Since
7374 this function is called before the linker maps input sections
7375 to output sections, we can easily discard it by setting the
7376 SEC_EXCLUDE flag. */
7377 if (h
->fn_stub
!= NULL
)
7379 sec
->flags
|= SEC_EXCLUDE
;
7383 sec
->flags
|= SEC_KEEP
;
7385 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
7388 else if (CALL_STUB_P (name
) || CALL_FP_STUB_P (name
))
7390 unsigned long r_symndx
;
7391 struct mips_elf_link_hash_entry
*h
;
7394 /* Look at the relocation information to figure out which symbol
7397 r_symndx
= mips16_stub_symndx (sec
, relocs
, rel_end
);
7400 (*_bfd_error_handler
)
7401 (_("%B: Warning: cannot determine the target function for"
7402 " stub section `%s'"),
7404 bfd_set_error (bfd_error_bad_value
);
7408 if (r_symndx
< extsymoff
7409 || sym_hashes
[r_symndx
- extsymoff
] == NULL
)
7413 /* This stub is for a local symbol. This stub will only be
7414 needed if there is some relocation (R_MIPS16_26) in this BFD
7415 that refers to this symbol. */
7416 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
7418 Elf_Internal_Rela
*sec_relocs
;
7419 const Elf_Internal_Rela
*r
, *rend
;
7421 /* We can ignore stub sections when looking for relocs. */
7422 if ((o
->flags
& SEC_RELOC
) == 0
7423 || o
->reloc_count
== 0
7424 || section_allows_mips16_refs_p (o
))
7428 = _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
7430 if (sec_relocs
== NULL
)
7433 rend
= sec_relocs
+ o
->reloc_count
;
7434 for (r
= sec_relocs
; r
< rend
; r
++)
7435 if (ELF_R_SYM (abfd
, r
->r_info
) == r_symndx
7436 && ELF_R_TYPE (abfd
, r
->r_info
) == R_MIPS16_26
)
7439 if (elf_section_data (o
)->relocs
!= sec_relocs
)
7448 /* There is no non-call reloc for this stub, so we do
7449 not need it. Since this function is called before
7450 the linker maps input sections to output sections, we
7451 can easily discard it by setting the SEC_EXCLUDE
7453 sec
->flags
|= SEC_EXCLUDE
;
7457 /* Record this stub in an array of local symbol call_stubs for
7459 if (elf_tdata (abfd
)->local_call_stubs
== NULL
)
7461 unsigned long symcount
;
7465 if (elf_bad_symtab (abfd
))
7466 symcount
= NUM_SHDR_ENTRIES (symtab_hdr
);
7468 symcount
= symtab_hdr
->sh_info
;
7469 amt
= symcount
* sizeof (asection
*);
7470 n
= bfd_zalloc (abfd
, amt
);
7473 elf_tdata (abfd
)->local_call_stubs
= n
;
7476 sec
->flags
|= SEC_KEEP
;
7477 elf_tdata (abfd
)->local_call_stubs
[r_symndx
] = sec
;
7479 /* We don't need to set mips16_stubs_seen in this case.
7480 That flag is used to see whether we need to look through
7481 the global symbol table for stubs. We don't need to set
7482 it here, because we just have a local stub. */
7486 h
= ((struct mips_elf_link_hash_entry
*)
7487 sym_hashes
[r_symndx
- extsymoff
]);
7489 /* H is the symbol this stub is for. */
7491 if (CALL_FP_STUB_P (name
))
7492 loc
= &h
->call_fp_stub
;
7494 loc
= &h
->call_stub
;
7496 /* If we already have an appropriate stub for this function, we
7497 don't need another one, so we can discard this one. Since
7498 this function is called before the linker maps input sections
7499 to output sections, we can easily discard it by setting the
7500 SEC_EXCLUDE flag. */
7503 sec
->flags
|= SEC_EXCLUDE
;
7507 sec
->flags
|= SEC_KEEP
;
7509 mips_elf_hash_table (info
)->mips16_stubs_seen
= TRUE
;
7515 for (rel
= relocs
; rel
< rel_end
; ++rel
)
7517 unsigned long r_symndx
;
7518 unsigned int r_type
;
7519 struct elf_link_hash_entry
*h
;
7520 bfd_boolean can_make_dynamic_p
;
7522 r_symndx
= ELF_R_SYM (abfd
, rel
->r_info
);
7523 r_type
= ELF_R_TYPE (abfd
, rel
->r_info
);
7525 if (r_symndx
< extsymoff
)
7527 else if (r_symndx
>= extsymoff
+ NUM_SHDR_ENTRIES (symtab_hdr
))
7529 (*_bfd_error_handler
)
7530 (_("%B: Malformed reloc detected for section %s"),
7532 bfd_set_error (bfd_error_bad_value
);
7537 h
= sym_hashes
[r_symndx
- extsymoff
];
7539 && (h
->root
.type
== bfd_link_hash_indirect
7540 || h
->root
.type
== bfd_link_hash_warning
))
7541 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
7544 /* Set CAN_MAKE_DYNAMIC_P to true if we can convert this
7545 relocation into a dynamic one. */
7546 can_make_dynamic_p
= FALSE
;
7549 case R_MIPS16_GOT16
:
7550 case R_MIPS16_CALL16
:
7553 case R_MIPS_CALL_HI16
:
7554 case R_MIPS_CALL_LO16
:
7555 case R_MIPS_GOT_HI16
:
7556 case R_MIPS_GOT_LO16
:
7557 case R_MIPS_GOT_PAGE
:
7558 case R_MIPS_GOT_OFST
:
7559 case R_MIPS_GOT_DISP
:
7560 case R_MIPS_TLS_GOTTPREL
:
7562 case R_MIPS_TLS_LDM
:
7564 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
7565 if (!mips_elf_create_got_section (dynobj
, info
))
7567 if (htab
->is_vxworks
&& !info
->shared
)
7569 (*_bfd_error_handler
)
7570 (_("%B: GOT reloc at 0x%lx not expected in executables"),
7571 abfd
, (unsigned long) rel
->r_offset
);
7572 bfd_set_error (bfd_error_bad_value
);
7577 /* This is just a hint; it can safely be ignored. Don't set
7578 has_static_relocs for the corresponding symbol. */
7585 /* In VxWorks executables, references to external symbols
7586 must be handled using copy relocs or PLT entries; it is not
7587 possible to convert this relocation into a dynamic one.
7589 For executables that use PLTs and copy-relocs, we have a
7590 choice between converting the relocation into a dynamic
7591 one or using copy relocations or PLT entries. It is
7592 usually better to do the former, unless the relocation is
7593 against a read-only section. */
7596 && !htab
->is_vxworks
7597 && strcmp (h
->root
.root
.string
, "__gnu_local_gp") != 0
7598 && !(!info
->nocopyreloc
7599 && !PIC_OBJECT_P (abfd
)
7600 && MIPS_ELF_READONLY_SECTION (sec
))))
7601 && (sec
->flags
& SEC_ALLOC
) != 0)
7603 can_make_dynamic_p
= TRUE
;
7605 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
7611 /* Most static relocations require pointer equality, except
7614 h
->pointer_equality_needed
= TRUE
;
7621 ((struct mips_elf_link_hash_entry
*) h
)->has_static_relocs
= TRUE
;
7627 /* Relocations against the special VxWorks __GOTT_BASE__ and
7628 __GOTT_INDEX__ symbols must be left to the loader. Allocate
7629 room for them in .rela.dyn. */
7630 if (is_gott_symbol (info
, h
))
7634 sreloc
= mips_elf_rel_dyn_section (info
, TRUE
);
7638 mips_elf_allocate_dynamic_relocations (dynobj
, info
, 1);
7639 if (MIPS_ELF_READONLY_SECTION (sec
))
7640 /* We tell the dynamic linker that there are
7641 relocations against the text segment. */
7642 info
->flags
|= DF_TEXTREL
;
7645 else if (r_type
== R_MIPS_CALL_LO16
7646 || r_type
== R_MIPS_GOT_LO16
7647 || r_type
== R_MIPS_GOT_DISP
7648 || (got16_reloc_p (r_type
) && htab
->is_vxworks
))
7650 /* We may need a local GOT entry for this relocation. We
7651 don't count R_MIPS_GOT_PAGE because we can estimate the
7652 maximum number of pages needed by looking at the size of
7653 the segment. Similar comments apply to R_MIPS*_GOT16 and
7654 R_MIPS*_CALL16, except on VxWorks, where GOT relocations
7655 always evaluate to "G". We don't count R_MIPS_GOT_HI16, or
7656 R_MIPS_CALL_HI16 because these are always followed by an
7657 R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16. */
7658 if (!mips_elf_record_local_got_symbol (abfd
, r_symndx
,
7659 rel
->r_addend
, info
, 0))
7663 if (h
!= NULL
&& mips_elf_relocation_needs_la25_stub (abfd
, r_type
))
7664 ((struct mips_elf_link_hash_entry
*) h
)->has_nonpic_branches
= TRUE
;
7669 case R_MIPS16_CALL16
:
7672 (*_bfd_error_handler
)
7673 (_("%B: CALL16 reloc at 0x%lx not against global symbol"),
7674 abfd
, (unsigned long) rel
->r_offset
);
7675 bfd_set_error (bfd_error_bad_value
);
7680 case R_MIPS_CALL_HI16
:
7681 case R_MIPS_CALL_LO16
:
7684 /* VxWorks call relocations point at the function's .got.plt
7685 entry, which will be allocated by adjust_dynamic_symbol.
7686 Otherwise, this symbol requires a global GOT entry. */
7687 if ((!htab
->is_vxworks
|| h
->forced_local
)
7688 && !mips_elf_record_global_got_symbol (h
, abfd
, info
, 0))
7691 /* We need a stub, not a plt entry for the undefined
7692 function. But we record it as if it needs plt. See
7693 _bfd_elf_adjust_dynamic_symbol. */
7699 case R_MIPS_GOT_PAGE
:
7700 /* If this is a global, overridable symbol, GOT_PAGE will
7701 decay to GOT_DISP, so we'll need a GOT entry for it. */
7704 struct mips_elf_link_hash_entry
*hmips
=
7705 (struct mips_elf_link_hash_entry
*) h
;
7707 /* This symbol is definitely not overridable. */
7708 if (hmips
->root
.def_regular
7709 && ! (info
->shared
&& ! info
->symbolic
7710 && ! hmips
->root
.forced_local
))
7715 case R_MIPS16_GOT16
:
7717 case R_MIPS_GOT_HI16
:
7718 case R_MIPS_GOT_LO16
:
7719 if (!h
|| r_type
== R_MIPS_GOT_PAGE
)
7721 /* This relocation needs (or may need, if h != NULL) a
7722 page entry in the GOT. For R_MIPS_GOT_PAGE we do not
7723 know for sure until we know whether the symbol is
7725 if (mips_elf_rel_relocation_p (abfd
, sec
, relocs
, rel
))
7727 if (!mips_elf_get_section_contents (abfd
, sec
, &contents
))
7729 howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, r_type
, FALSE
);
7730 addend
= mips_elf_read_rel_addend (abfd
, rel
,
7732 if (r_type
== R_MIPS_GOT16
)
7733 mips_elf_add_lo16_rel_addend (abfd
, rel
, rel_end
,
7736 addend
<<= howto
->rightshift
;
7739 addend
= rel
->r_addend
;
7740 if (!mips_elf_record_got_page_entry (info
, abfd
, r_symndx
,
7747 case R_MIPS_GOT_DISP
:
7748 if (h
&& !mips_elf_record_global_got_symbol (h
, abfd
, info
, 0))
7752 case R_MIPS_TLS_GOTTPREL
:
7754 info
->flags
|= DF_STATIC_TLS
;
7757 case R_MIPS_TLS_LDM
:
7758 if (r_type
== R_MIPS_TLS_LDM
)
7766 /* This symbol requires a global offset table entry, or two
7767 for TLS GD relocations. */
7769 unsigned char flag
= (r_type
== R_MIPS_TLS_GD
7771 : r_type
== R_MIPS_TLS_LDM
7776 struct mips_elf_link_hash_entry
*hmips
=
7777 (struct mips_elf_link_hash_entry
*) h
;
7778 hmips
->tls_type
|= flag
;
7780 if (h
&& !mips_elf_record_global_got_symbol (h
, abfd
,
7786 BFD_ASSERT (flag
== GOT_TLS_LDM
|| r_symndx
!= 0);
7788 if (!mips_elf_record_local_got_symbol (abfd
, r_symndx
,
7799 /* In VxWorks executables, references to external symbols
7800 are handled using copy relocs or PLT stubs, so there's
7801 no need to add a .rela.dyn entry for this relocation. */
7802 if (can_make_dynamic_p
)
7806 sreloc
= mips_elf_rel_dyn_section (info
, TRUE
);
7810 if (info
->shared
&& h
== NULL
)
7812 /* When creating a shared object, we must copy these
7813 reloc types into the output file as R_MIPS_REL32
7814 relocs. Make room for this reloc in .rel(a).dyn. */
7815 mips_elf_allocate_dynamic_relocations (dynobj
, info
, 1);
7816 if (MIPS_ELF_READONLY_SECTION (sec
))
7817 /* We tell the dynamic linker that there are
7818 relocations against the text segment. */
7819 info
->flags
|= DF_TEXTREL
;
7823 struct mips_elf_link_hash_entry
*hmips
;
7825 /* For a shared object, we must copy this relocation
7826 unless the symbol turns out to be undefined and
7827 weak with non-default visibility, in which case
7828 it will be left as zero.
7830 We could elide R_MIPS_REL32 for locally binding symbols
7831 in shared libraries, but do not yet do so.
7833 For an executable, we only need to copy this
7834 reloc if the symbol is defined in a dynamic
7836 hmips
= (struct mips_elf_link_hash_entry
*) h
;
7837 ++hmips
->possibly_dynamic_relocs
;
7838 if (MIPS_ELF_READONLY_SECTION (sec
))
7839 /* We need it to tell the dynamic linker if there
7840 are relocations against the text segment. */
7841 hmips
->readonly_reloc
= TRUE
;
7845 if (SGI_COMPAT (abfd
))
7846 mips_elf_hash_table (info
)->compact_rel_size
+=
7847 sizeof (Elf32_External_crinfo
);
7851 case R_MIPS_GPREL16
:
7852 case R_MIPS_LITERAL
:
7853 case R_MIPS_GPREL32
:
7854 if (SGI_COMPAT (abfd
))
7855 mips_elf_hash_table (info
)->compact_rel_size
+=
7856 sizeof (Elf32_External_crinfo
);
7859 /* This relocation describes the C++ object vtable hierarchy.
7860 Reconstruct it for later use during GC. */
7861 case R_MIPS_GNU_VTINHERIT
:
7862 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
7866 /* This relocation describes which C++ vtable entries are actually
7867 used. Record for later use during GC. */
7868 case R_MIPS_GNU_VTENTRY
:
7869 BFD_ASSERT (h
!= NULL
);
7871 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
7879 /* We must not create a stub for a symbol that has relocations
7880 related to taking the function's address. This doesn't apply to
7881 VxWorks, where CALL relocs refer to a .got.plt entry instead of
7882 a normal .got entry. */
7883 if (!htab
->is_vxworks
&& h
!= NULL
)
7887 ((struct mips_elf_link_hash_entry
*) h
)->no_fn_stub
= TRUE
;
7889 case R_MIPS16_CALL16
:
7891 case R_MIPS_CALL_HI16
:
7892 case R_MIPS_CALL_LO16
:
7897 /* See if this reloc would need to refer to a MIPS16 hard-float stub,
7898 if there is one. We only need to handle global symbols here;
7899 we decide whether to keep or delete stubs for local symbols
7900 when processing the stub's relocations. */
7902 && !mips16_call_reloc_p (r_type
)
7903 && !section_allows_mips16_refs_p (sec
))
7905 struct mips_elf_link_hash_entry
*mh
;
7907 mh
= (struct mips_elf_link_hash_entry
*) h
;
7908 mh
->need_fn_stub
= TRUE
;
7911 /* Refuse some position-dependent relocations when creating a
7912 shared library. Do not refuse R_MIPS_32 / R_MIPS_64; they're
7913 not PIC, but we can create dynamic relocations and the result
7914 will be fine. Also do not refuse R_MIPS_LO16, which can be
7915 combined with R_MIPS_GOT16. */
7923 case R_MIPS_HIGHEST
:
7924 /* Don't refuse a high part relocation if it's against
7925 no symbol (e.g. part of a compound relocation). */
7929 /* R_MIPS_HI16 against _gp_disp is used for $gp setup,
7930 and has a special meaning. */
7931 if (!NEWABI_P (abfd
) && h
!= NULL
7932 && strcmp (h
->root
.root
.string
, "_gp_disp") == 0)
7939 howto
= MIPS_ELF_RTYPE_TO_HOWTO (abfd
, r_type
, FALSE
);
7940 (*_bfd_error_handler
)
7941 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
7943 (h
) ? h
->root
.root
.string
: "a local symbol");
7944 bfd_set_error (bfd_error_bad_value
);
7956 _bfd_mips_relax_section (bfd
*abfd
, asection
*sec
,
7957 struct bfd_link_info
*link_info
,
7960 Elf_Internal_Rela
*internal_relocs
;
7961 Elf_Internal_Rela
*irel
, *irelend
;
7962 Elf_Internal_Shdr
*symtab_hdr
;
7963 bfd_byte
*contents
= NULL
;
7965 bfd_boolean changed_contents
= FALSE
;
7966 bfd_vma sec_start
= sec
->output_section
->vma
+ sec
->output_offset
;
7967 Elf_Internal_Sym
*isymbuf
= NULL
;
7969 /* We are not currently changing any sizes, so only one pass. */
7972 if (link_info
->relocatable
)
7975 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
7976 link_info
->keep_memory
);
7977 if (internal_relocs
== NULL
)
7980 irelend
= internal_relocs
+ sec
->reloc_count
7981 * get_elf_backend_data (abfd
)->s
->int_rels_per_ext_rel
;
7982 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7983 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
7985 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
7988 bfd_signed_vma sym_offset
;
7989 unsigned int r_type
;
7990 unsigned long r_symndx
;
7992 unsigned long instruction
;
7994 /* Turn jalr into bgezal, and jr into beq, if they're marked
7995 with a JALR relocation, that indicate where they jump to.
7996 This saves some pipeline bubbles. */
7997 r_type
= ELF_R_TYPE (abfd
, irel
->r_info
);
7998 if (r_type
!= R_MIPS_JALR
)
8001 r_symndx
= ELF_R_SYM (abfd
, irel
->r_info
);
8002 /* Compute the address of the jump target. */
8003 if (r_symndx
>= extsymoff
)
8005 struct mips_elf_link_hash_entry
*h
8006 = ((struct mips_elf_link_hash_entry
*)
8007 elf_sym_hashes (abfd
) [r_symndx
- extsymoff
]);
8009 while (h
->root
.root
.type
== bfd_link_hash_indirect
8010 || h
->root
.root
.type
== bfd_link_hash_warning
)
8011 h
= (struct mips_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
8013 /* If a symbol is undefined, or if it may be overridden,
8015 if (! ((h
->root
.root
.type
== bfd_link_hash_defined
8016 || h
->root
.root
.type
== bfd_link_hash_defweak
)
8017 && h
->root
.root
.u
.def
.section
)
8018 || (link_info
->shared
&& ! link_info
->symbolic
8019 && !h
->root
.forced_local
))
8022 sym_sec
= h
->root
.root
.u
.def
.section
;
8023 if (sym_sec
->output_section
)
8024 symval
= (h
->root
.root
.u
.def
.value
8025 + sym_sec
->output_section
->vma
8026 + sym_sec
->output_offset
);
8028 symval
= h
->root
.root
.u
.def
.value
;
8032 Elf_Internal_Sym
*isym
;
8034 /* Read this BFD's symbols if we haven't done so already. */
8035 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
8037 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
8038 if (isymbuf
== NULL
)
8039 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
8040 symtab_hdr
->sh_info
, 0,
8042 if (isymbuf
== NULL
)
8046 isym
= isymbuf
+ r_symndx
;
8047 if (isym
->st_shndx
== SHN_UNDEF
)
8049 else if (isym
->st_shndx
== SHN_ABS
)
8050 sym_sec
= bfd_abs_section_ptr
;
8051 else if (isym
->st_shndx
== SHN_COMMON
)
8052 sym_sec
= bfd_com_section_ptr
;
8055 = bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
8056 symval
= isym
->st_value
8057 + sym_sec
->output_section
->vma
8058 + sym_sec
->output_offset
;
8061 /* Compute branch offset, from delay slot of the jump to the
8063 sym_offset
= (symval
+ irel
->r_addend
)
8064 - (sec_start
+ irel
->r_offset
+ 4);
8066 /* Branch offset must be properly aligned. */
8067 if ((sym_offset
& 3) != 0)
8072 /* Check that it's in range. */
8073 if (sym_offset
< -0x8000 || sym_offset
>= 0x8000)
8076 /* Get the section contents if we haven't done so already. */
8077 if (!mips_elf_get_section_contents (abfd
, sec
, &contents
))
8080 instruction
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
8082 /* If it was jalr <reg>, turn it into bgezal $zero, <target>. */
8083 if ((instruction
& 0xfc1fffff) == 0x0000f809)
8084 instruction
= 0x04110000;
8085 /* If it was jr <reg>, turn it into b <target>. */
8086 else if ((instruction
& 0xfc1fffff) == 0x00000008)
8087 instruction
= 0x10000000;
8091 instruction
|= (sym_offset
& 0xffff);
8092 bfd_put_32 (abfd
, instruction
, contents
+ irel
->r_offset
);
8093 changed_contents
= TRUE
;
8096 if (contents
!= NULL
8097 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
8099 if (!changed_contents
&& !link_info
->keep_memory
)
8103 /* Cache the section contents for elf_link_input_bfd. */
8104 elf_section_data (sec
)->this_hdr
.contents
= contents
;
8110 if (contents
!= NULL
8111 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
8116 /* Allocate space for global sym dynamic relocs. */
8119 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
8121 struct bfd_link_info
*info
= inf
;
8123 struct mips_elf_link_hash_entry
*hmips
;
8124 struct mips_elf_link_hash_table
*htab
;
8126 htab
= mips_elf_hash_table (info
);
8127 BFD_ASSERT (htab
!= NULL
);
8129 dynobj
= elf_hash_table (info
)->dynobj
;
8130 hmips
= (struct mips_elf_link_hash_entry
*) h
;
8132 /* VxWorks executables are handled elsewhere; we only need to
8133 allocate relocations in shared objects. */
8134 if (htab
->is_vxworks
&& !info
->shared
)
8137 /* Ignore indirect and warning symbols. All relocations against
8138 such symbols will be redirected to the target symbol. */
8139 if (h
->root
.type
== bfd_link_hash_indirect
8140 || h
->root
.type
== bfd_link_hash_warning
)
8143 /* If this symbol is defined in a dynamic object, or we are creating
8144 a shared library, we will need to copy any R_MIPS_32 or
8145 R_MIPS_REL32 relocs against it into the output file. */
8146 if (! info
->relocatable
8147 && hmips
->possibly_dynamic_relocs
!= 0
8148 && (h
->root
.type
== bfd_link_hash_defweak
8152 bfd_boolean do_copy
= TRUE
;
8154 if (h
->root
.type
== bfd_link_hash_undefweak
)
8156 /* Do not copy relocations for undefined weak symbols with
8157 non-default visibility. */
8158 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
8161 /* Make sure undefined weak symbols are output as a dynamic
8163 else if (h
->dynindx
== -1 && !h
->forced_local
)
8165 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
8172 /* Even though we don't directly need a GOT entry for this symbol,
8173 a symbol must have a dynamic symbol table index greater that
8174 DT_MIPS_GOTSYM if there are dynamic relocations against it. */
8175 if (hmips
->global_got_area
> GGA_RELOC_ONLY
)
8176 hmips
->global_got_area
= GGA_RELOC_ONLY
;
8178 mips_elf_allocate_dynamic_relocations
8179 (dynobj
, info
, hmips
->possibly_dynamic_relocs
);
8180 if (hmips
->readonly_reloc
)
8181 /* We tell the dynamic linker that there are relocations
8182 against the text segment. */
8183 info
->flags
|= DF_TEXTREL
;
8190 /* Adjust a symbol defined by a dynamic object and referenced by a
8191 regular object. The current definition is in some section of the
8192 dynamic object, but we're not including those sections. We have to
8193 change the definition to something the rest of the link can
8197 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
8198 struct elf_link_hash_entry
*h
)
8201 struct mips_elf_link_hash_entry
*hmips
;
8202 struct mips_elf_link_hash_table
*htab
;
8204 htab
= mips_elf_hash_table (info
);
8205 BFD_ASSERT (htab
!= NULL
);
8207 dynobj
= elf_hash_table (info
)->dynobj
;
8208 hmips
= (struct mips_elf_link_hash_entry
*) h
;
8210 /* Make sure we know what is going on here. */
8211 BFD_ASSERT (dynobj
!= NULL
8213 || h
->u
.weakdef
!= NULL
8216 && !h
->def_regular
)));
8218 hmips
= (struct mips_elf_link_hash_entry
*) h
;
8220 /* If there are call relocations against an externally-defined symbol,
8221 see whether we can create a MIPS lazy-binding stub for it. We can
8222 only do this if all references to the function are through call
8223 relocations, and in that case, the traditional lazy-binding stubs
8224 are much more efficient than PLT entries.
8226 Traditional stubs are only available on SVR4 psABI-based systems;
8227 VxWorks always uses PLTs instead. */
8228 if (!htab
->is_vxworks
&& h
->needs_plt
&& !hmips
->no_fn_stub
)
8230 if (! elf_hash_table (info
)->dynamic_sections_created
)
8233 /* If this symbol is not defined in a regular file, then set
8234 the symbol to the stub location. This is required to make
8235 function pointers compare as equal between the normal
8236 executable and the shared library. */
8237 if (!h
->def_regular
)
8239 hmips
->needs_lazy_stub
= TRUE
;
8240 htab
->lazy_stub_count
++;
8244 /* As above, VxWorks requires PLT entries for externally-defined
8245 functions that are only accessed through call relocations.
8247 Both VxWorks and non-VxWorks targets also need PLT entries if there
8248 are static-only relocations against an externally-defined function.
8249 This can technically occur for shared libraries if there are
8250 branches to the symbol, although it is unlikely that this will be
8251 used in practice due to the short ranges involved. It can occur
8252 for any relative or absolute relocation in executables; in that
8253 case, the PLT entry becomes the function's canonical address. */
8254 else if (((h
->needs_plt
&& !hmips
->no_fn_stub
)
8255 || (h
->type
== STT_FUNC
&& hmips
->has_static_relocs
))
8256 && htab
->use_plts_and_copy_relocs
8257 && !SYMBOL_CALLS_LOCAL (info
, h
)
8258 && !(ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
8259 && h
->root
.type
== bfd_link_hash_undefweak
))
8261 /* If this is the first symbol to need a PLT entry, allocate room
8263 if (htab
->splt
->size
== 0)
8265 BFD_ASSERT (htab
->sgotplt
->size
== 0);
8267 /* If we're using the PLT additions to the psABI, each PLT
8268 entry is 16 bytes and the PLT0 entry is 32 bytes.
8269 Encourage better cache usage by aligning. We do this
8270 lazily to avoid pessimizing traditional objects. */
8271 if (!htab
->is_vxworks
8272 && !bfd_set_section_alignment (dynobj
, htab
->splt
, 5))
8275 /* Make sure that .got.plt is word-aligned. We do this lazily
8276 for the same reason as above. */
8277 if (!bfd_set_section_alignment (dynobj
, htab
->sgotplt
,
8278 MIPS_ELF_LOG_FILE_ALIGN (dynobj
)))
8281 htab
->splt
->size
+= htab
->plt_header_size
;
8283 /* On non-VxWorks targets, the first two entries in .got.plt
8285 if (!htab
->is_vxworks
)
8286 htab
->sgotplt
->size
+= 2 * MIPS_ELF_GOT_SIZE (dynobj
);
8288 /* On VxWorks, also allocate room for the header's
8289 .rela.plt.unloaded entries. */
8290 if (htab
->is_vxworks
&& !info
->shared
)
8291 htab
->srelplt2
->size
+= 2 * sizeof (Elf32_External_Rela
);
8294 /* Assign the next .plt entry to this symbol. */
8295 h
->plt
.offset
= htab
->splt
->size
;
8296 htab
->splt
->size
+= htab
->plt_entry_size
;
8298 /* If the output file has no definition of the symbol, set the
8299 symbol's value to the address of the stub. */
8300 if (!info
->shared
&& !h
->def_regular
)
8302 h
->root
.u
.def
.section
= htab
->splt
;
8303 h
->root
.u
.def
.value
= h
->plt
.offset
;
8304 /* For VxWorks, point at the PLT load stub rather than the
8305 lazy resolution stub; this stub will become the canonical
8306 function address. */
8307 if (htab
->is_vxworks
)
8308 h
->root
.u
.def
.value
+= 8;
8311 /* Make room for the .got.plt entry and the R_MIPS_JUMP_SLOT
8313 htab
->sgotplt
->size
+= MIPS_ELF_GOT_SIZE (dynobj
);
8314 htab
->srelplt
->size
+= (htab
->is_vxworks
8315 ? MIPS_ELF_RELA_SIZE (dynobj
)
8316 : MIPS_ELF_REL_SIZE (dynobj
));
8318 /* Make room for the .rela.plt.unloaded relocations. */
8319 if (htab
->is_vxworks
&& !info
->shared
)
8320 htab
->srelplt2
->size
+= 3 * sizeof (Elf32_External_Rela
);
8322 /* All relocations against this symbol that could have been made
8323 dynamic will now refer to the PLT entry instead. */
8324 hmips
->possibly_dynamic_relocs
= 0;
8329 /* If this is a weak symbol, and there is a real definition, the
8330 processor independent code will have arranged for us to see the
8331 real definition first, and we can just use the same value. */
8332 if (h
->u
.weakdef
!= NULL
)
8334 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
8335 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
8336 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
8337 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
8341 /* Otherwise, there is nothing further to do for symbols defined
8342 in regular objects. */
8346 /* There's also nothing more to do if we'll convert all relocations
8347 against this symbol into dynamic relocations. */
8348 if (!hmips
->has_static_relocs
)
8351 /* We're now relying on copy relocations. Complain if we have
8352 some that we can't convert. */
8353 if (!htab
->use_plts_and_copy_relocs
|| info
->shared
)
8355 (*_bfd_error_handler
) (_("non-dynamic relocations refer to "
8356 "dynamic symbol %s"),
8357 h
->root
.root
.string
);
8358 bfd_set_error (bfd_error_bad_value
);
8362 /* We must allocate the symbol in our .dynbss section, which will
8363 become part of the .bss section of the executable. There will be
8364 an entry for this symbol in the .dynsym section. The dynamic
8365 object will contain position independent code, so all references
8366 from the dynamic object to this symbol will go through the global
8367 offset table. The dynamic linker will use the .dynsym entry to
8368 determine the address it must put in the global offset table, so
8369 both the dynamic object and the regular object will refer to the
8370 same memory location for the variable. */
8372 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
8374 if (htab
->is_vxworks
)
8375 htab
->srelbss
->size
+= sizeof (Elf32_External_Rela
);
8377 mips_elf_allocate_dynamic_relocations (dynobj
, info
, 1);
8381 /* All relocations against this symbol that could have been made
8382 dynamic will now refer to the local copy instead. */
8383 hmips
->possibly_dynamic_relocs
= 0;
8385 return _bfd_elf_adjust_dynamic_copy (h
, htab
->sdynbss
);
8388 /* This function is called after all the input files have been read,
8389 and the input sections have been assigned to output sections. We
8390 check for any mips16 stub sections that we can discard. */
8393 _bfd_mips_elf_always_size_sections (bfd
*output_bfd
,
8394 struct bfd_link_info
*info
)
8397 struct mips_elf_link_hash_table
*htab
;
8398 struct mips_htab_traverse_info hti
;
8400 htab
= mips_elf_hash_table (info
);
8401 BFD_ASSERT (htab
!= NULL
);
8403 /* The .reginfo section has a fixed size. */
8404 ri
= bfd_get_section_by_name (output_bfd
, ".reginfo");
8406 bfd_set_section_size (output_bfd
, ri
, sizeof (Elf32_External_RegInfo
));
8409 hti
.output_bfd
= output_bfd
;
8411 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
8412 mips_elf_check_symbols
, &hti
);
8419 /* If the link uses a GOT, lay it out and work out its size. */
8422 mips_elf_lay_out_got (bfd
*output_bfd
, struct bfd_link_info
*info
)
8426 struct mips_got_info
*g
;
8427 bfd_size_type loadable_size
= 0;
8428 bfd_size_type page_gotno
;
8430 struct mips_elf_count_tls_arg count_tls_arg
;
8431 struct mips_elf_link_hash_table
*htab
;
8433 htab
= mips_elf_hash_table (info
);
8434 BFD_ASSERT (htab
!= NULL
);
8440 dynobj
= elf_hash_table (info
)->dynobj
;
8443 /* Allocate room for the reserved entries. VxWorks always reserves
8444 3 entries; other objects only reserve 2 entries. */
8445 BFD_ASSERT (g
->assigned_gotno
== 0);
8446 if (htab
->is_vxworks
)
8447 htab
->reserved_gotno
= 3;
8449 htab
->reserved_gotno
= 2;
8450 g
->local_gotno
+= htab
->reserved_gotno
;
8451 g
->assigned_gotno
= htab
->reserved_gotno
;
8453 /* Replace entries for indirect and warning symbols with entries for
8454 the target symbol. */
8455 if (!mips_elf_resolve_final_got_entries (g
))
8458 /* Count the number of GOT symbols. */
8459 mips_elf_link_hash_traverse (htab
, mips_elf_count_got_symbols
, g
);
8461 /* Calculate the total loadable size of the output. That
8462 will give us the maximum number of GOT_PAGE entries
8464 for (sub
= info
->input_bfds
; sub
; sub
= sub
->link_next
)
8466 asection
*subsection
;
8468 for (subsection
= sub
->sections
;
8470 subsection
= subsection
->next
)
8472 if ((subsection
->flags
& SEC_ALLOC
) == 0)
8474 loadable_size
+= ((subsection
->size
+ 0xf)
8475 &~ (bfd_size_type
) 0xf);
8479 if (htab
->is_vxworks
)
8480 /* There's no need to allocate page entries for VxWorks; R_MIPS*_GOT16
8481 relocations against local symbols evaluate to "G", and the EABI does
8482 not include R_MIPS_GOT_PAGE. */
8485 /* Assume there are two loadable segments consisting of contiguous
8486 sections. Is 5 enough? */
8487 page_gotno
= (loadable_size
>> 16) + 5;
8489 /* Choose the smaller of the two estimates; both are intended to be
8491 if (page_gotno
> g
->page_gotno
)
8492 page_gotno
= g
->page_gotno
;
8494 g
->local_gotno
+= page_gotno
;
8495 s
->size
+= g
->local_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
8496 s
->size
+= g
->global_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
8498 /* We need to calculate tls_gotno for global symbols at this point
8499 instead of building it up earlier, to avoid doublecounting
8500 entries for one global symbol from multiple input files. */
8501 count_tls_arg
.info
= info
;
8502 count_tls_arg
.needed
= 0;
8503 elf_link_hash_traverse (elf_hash_table (info
),
8504 mips_elf_count_global_tls_entries
,
8506 g
->tls_gotno
+= count_tls_arg
.needed
;
8507 s
->size
+= g
->tls_gotno
* MIPS_ELF_GOT_SIZE (output_bfd
);
8509 /* VxWorks does not support multiple GOTs. It initializes $gp to
8510 __GOTT_BASE__[__GOTT_INDEX__], the value of which is set by the
8512 if (htab
->is_vxworks
)
8514 /* VxWorks executables do not need a GOT. */
8517 /* Each VxWorks GOT entry needs an explicit relocation. */
8520 count
= g
->global_gotno
+ g
->local_gotno
- htab
->reserved_gotno
;
8522 mips_elf_allocate_dynamic_relocations (dynobj
, info
, count
);
8525 else if (s
->size
> MIPS_ELF_GOT_MAX_SIZE (info
))
8527 if (!mips_elf_multi_got (output_bfd
, info
, s
, page_gotno
))
8532 struct mips_elf_count_tls_arg arg
;
8534 /* Set up TLS entries. */
8535 g
->tls_assigned_gotno
= g
->global_gotno
+ g
->local_gotno
;
8536 htab_traverse (g
->got_entries
, mips_elf_initialize_tls_index
, g
);
8538 /* Allocate room for the TLS relocations. */
8541 htab_traverse (g
->got_entries
, mips_elf_count_local_tls_relocs
, &arg
);
8542 elf_link_hash_traverse (elf_hash_table (info
),
8543 mips_elf_count_global_tls_relocs
,
8546 mips_elf_allocate_dynamic_relocations (dynobj
, info
, arg
.needed
);
8552 /* Estimate the size of the .MIPS.stubs section. */
8555 mips_elf_estimate_stub_size (bfd
*output_bfd
, struct bfd_link_info
*info
)
8557 struct mips_elf_link_hash_table
*htab
;
8558 bfd_size_type dynsymcount
;
8560 htab
= mips_elf_hash_table (info
);
8561 BFD_ASSERT (htab
!= NULL
);
8563 if (htab
->lazy_stub_count
== 0)
8566 /* IRIX rld assumes that a function stub isn't at the end of the .text
8567 section, so add a dummy entry to the end. */
8568 htab
->lazy_stub_count
++;
8570 /* Get a worst-case estimate of the number of dynamic symbols needed.
8571 At this point, dynsymcount does not account for section symbols
8572 and count_section_dynsyms may overestimate the number that will
8574 dynsymcount
= (elf_hash_table (info
)->dynsymcount
8575 + count_section_dynsyms (output_bfd
, info
));
8577 /* Determine the size of one stub entry. */
8578 htab
->function_stub_size
= (dynsymcount
> 0x10000
8579 ? MIPS_FUNCTION_STUB_BIG_SIZE
8580 : MIPS_FUNCTION_STUB_NORMAL_SIZE
);
8582 htab
->sstubs
->size
= htab
->lazy_stub_count
* htab
->function_stub_size
;
8585 /* A mips_elf_link_hash_traverse callback for which DATA points to the
8586 MIPS hash table. If H needs a traditional MIPS lazy-binding stub,
8587 allocate an entry in the stubs section. */
8590 mips_elf_allocate_lazy_stub (struct mips_elf_link_hash_entry
*h
, void **data
)
8592 struct mips_elf_link_hash_table
*htab
;
8594 htab
= (struct mips_elf_link_hash_table
*) data
;
8595 if (h
->needs_lazy_stub
)
8597 h
->root
.root
.u
.def
.section
= htab
->sstubs
;
8598 h
->root
.root
.u
.def
.value
= htab
->sstubs
->size
;
8599 h
->root
.plt
.offset
= htab
->sstubs
->size
;
8600 htab
->sstubs
->size
+= htab
->function_stub_size
;
8605 /* Allocate offsets in the stubs section to each symbol that needs one.
8606 Set the final size of the .MIPS.stub section. */
8609 mips_elf_lay_out_lazy_stubs (struct bfd_link_info
*info
)
8611 struct mips_elf_link_hash_table
*htab
;
8613 htab
= mips_elf_hash_table (info
);
8614 BFD_ASSERT (htab
!= NULL
);
8616 if (htab
->lazy_stub_count
== 0)
8619 htab
->sstubs
->size
= 0;
8620 mips_elf_link_hash_traverse (htab
, mips_elf_allocate_lazy_stub
, htab
);
8621 htab
->sstubs
->size
+= htab
->function_stub_size
;
8622 BFD_ASSERT (htab
->sstubs
->size
8623 == htab
->lazy_stub_count
* htab
->function_stub_size
);
8626 /* Set the sizes of the dynamic sections. */
8629 _bfd_mips_elf_size_dynamic_sections (bfd
*output_bfd
,
8630 struct bfd_link_info
*info
)
8633 asection
*s
, *sreldyn
;
8634 bfd_boolean reltext
;
8635 struct mips_elf_link_hash_table
*htab
;
8637 htab
= mips_elf_hash_table (info
);
8638 BFD_ASSERT (htab
!= NULL
);
8639 dynobj
= elf_hash_table (info
)->dynobj
;
8640 BFD_ASSERT (dynobj
!= NULL
);
8642 if (elf_hash_table (info
)->dynamic_sections_created
)
8644 /* Set the contents of the .interp section to the interpreter. */
8645 if (info
->executable
)
8647 s
= bfd_get_section_by_name (dynobj
, ".interp");
8648 BFD_ASSERT (s
!= NULL
);
8650 = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd
)) + 1;
8652 = (bfd_byte
*) ELF_DYNAMIC_INTERPRETER (output_bfd
);
8655 /* Create a symbol for the PLT, if we know that we are using it. */
8656 if (htab
->splt
&& htab
->splt
->size
> 0 && htab
->root
.hplt
== NULL
)
8658 struct elf_link_hash_entry
*h
;
8660 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
8662 h
= _bfd_elf_define_linkage_sym (dynobj
, info
, htab
->splt
,
8663 "_PROCEDURE_LINKAGE_TABLE_");
8664 htab
->root
.hplt
= h
;
8671 /* Allocate space for global sym dynamic relocs. */
8672 elf_link_hash_traverse (&htab
->root
, allocate_dynrelocs
, (PTR
) info
);
8674 mips_elf_estimate_stub_size (output_bfd
, info
);
8676 if (!mips_elf_lay_out_got (output_bfd
, info
))
8679 mips_elf_lay_out_lazy_stubs (info
);
8681 /* The check_relocs and adjust_dynamic_symbol entry points have
8682 determined the sizes of the various dynamic sections. Allocate
8685 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
8689 /* It's OK to base decisions on the section name, because none
8690 of the dynobj section names depend upon the input files. */
8691 name
= bfd_get_section_name (dynobj
, s
);
8693 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
8696 if (CONST_STRNEQ (name
, ".rel"))
8700 const char *outname
;
8703 /* If this relocation section applies to a read only
8704 section, then we probably need a DT_TEXTREL entry.
8705 If the relocation section is .rel(a).dyn, we always
8706 assert a DT_TEXTREL entry rather than testing whether
8707 there exists a relocation to a read only section or
8709 outname
= bfd_get_section_name (output_bfd
,
8711 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
8713 && (target
->flags
& SEC_READONLY
) != 0
8714 && (target
->flags
& SEC_ALLOC
) != 0)
8715 || strcmp (outname
, MIPS_ELF_REL_DYN_NAME (info
)) == 0)
8718 /* We use the reloc_count field as a counter if we need
8719 to copy relocs into the output file. */
8720 if (strcmp (name
, MIPS_ELF_REL_DYN_NAME (info
)) != 0)
8723 /* If combreloc is enabled, elf_link_sort_relocs() will
8724 sort relocations, but in a different way than we do,
8725 and before we're done creating relocations. Also, it
8726 will move them around between input sections'
8727 relocation's contents, so our sorting would be
8728 broken, so don't let it run. */
8729 info
->combreloc
= 0;
8732 else if (! info
->shared
8733 && ! mips_elf_hash_table (info
)->use_rld_obj_head
8734 && CONST_STRNEQ (name
, ".rld_map"))
8736 /* We add a room for __rld_map. It will be filled in by the
8737 rtld to contain a pointer to the _r_debug structure. */
8740 else if (SGI_COMPAT (output_bfd
)
8741 && CONST_STRNEQ (name
, ".compact_rel"))
8742 s
->size
+= mips_elf_hash_table (info
)->compact_rel_size
;
8743 else if (s
== htab
->splt
)
8745 /* If the last PLT entry has a branch delay slot, allocate
8746 room for an extra nop to fill the delay slot. This is
8747 for CPUs without load interlocking. */
8748 if (! LOAD_INTERLOCKS_P (output_bfd
)
8749 && ! htab
->is_vxworks
&& s
->size
> 0)
8752 else if (! CONST_STRNEQ (name
, ".init")
8754 && s
!= htab
->sgotplt
8755 && s
!= htab
->sstubs
8756 && s
!= htab
->sdynbss
)
8758 /* It's not one of our sections, so don't allocate space. */
8764 s
->flags
|= SEC_EXCLUDE
;
8768 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
8771 /* Allocate memory for the section contents. */
8772 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
8773 if (s
->contents
== NULL
)
8775 bfd_set_error (bfd_error_no_memory
);
8780 if (elf_hash_table (info
)->dynamic_sections_created
)
8782 /* Add some entries to the .dynamic section. We fill in the
8783 values later, in _bfd_mips_elf_finish_dynamic_sections, but we
8784 must add the entries now so that we get the correct size for
8785 the .dynamic section. */
8787 /* SGI object has the equivalence of DT_DEBUG in the
8788 DT_MIPS_RLD_MAP entry. This must come first because glibc
8789 only fills in DT_MIPS_RLD_MAP (not DT_DEBUG) and GDB only
8790 looks at the first one it sees. */
8792 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_MAP
, 0))
8795 /* The DT_DEBUG entry may be filled in by the dynamic linker and
8796 used by the debugger. */
8797 if (info
->executable
8798 && !SGI_COMPAT (output_bfd
)
8799 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
8802 if (reltext
&& (SGI_COMPAT (output_bfd
) || htab
->is_vxworks
))
8803 info
->flags
|= DF_TEXTREL
;
8805 if ((info
->flags
& DF_TEXTREL
) != 0)
8807 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_TEXTREL
, 0))
8810 /* Clear the DF_TEXTREL flag. It will be set again if we
8811 write out an actual text relocation; we may not, because
8812 at this point we do not know whether e.g. any .eh_frame
8813 absolute relocations have been converted to PC-relative. */
8814 info
->flags
&= ~DF_TEXTREL
;
8817 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTGOT
, 0))
8820 sreldyn
= mips_elf_rel_dyn_section (info
, FALSE
);
8821 if (htab
->is_vxworks
)
8823 /* VxWorks uses .rela.dyn instead of .rel.dyn. It does not
8824 use any of the DT_MIPS_* tags. */
8825 if (sreldyn
&& sreldyn
->size
> 0)
8827 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELA
, 0))
8830 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELASZ
, 0))
8833 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELAENT
, 0))
8839 if (sreldyn
&& sreldyn
->size
> 0)
8841 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_REL
, 0))
8844 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELSZ
, 0))
8847 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELENT
, 0))
8851 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_RLD_VERSION
, 0))
8854 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_FLAGS
, 0))
8857 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_BASE_ADDRESS
, 0))
8860 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_LOCAL_GOTNO
, 0))
8863 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_SYMTABNO
, 0))
8866 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_UNREFEXTNO
, 0))
8869 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_GOTSYM
, 0))
8872 if (IRIX_COMPAT (dynobj
) == ict_irix5
8873 && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_HIPAGENO
, 0))
8876 if (IRIX_COMPAT (dynobj
) == ict_irix6
8877 && (bfd_get_section_by_name
8878 (dynobj
, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj
)))
8879 && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_OPTIONS
, 0))
8882 if (htab
->splt
->size
> 0)
8884 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTREL
, 0))
8887 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_JMPREL
, 0))
8890 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTRELSZ
, 0))
8893 if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info
, DT_MIPS_PLTGOT
, 0))
8896 if (htab
->is_vxworks
8897 && !elf_vxworks_add_dynamic_entries (output_bfd
, info
))
8904 /* REL is a relocation in INPUT_BFD that is being copied to OUTPUT_BFD.
8905 Adjust its R_ADDEND field so that it is correct for the output file.
8906 LOCAL_SYMS and LOCAL_SECTIONS are arrays of INPUT_BFD's local symbols
8907 and sections respectively; both use symbol indexes. */
8910 mips_elf_adjust_addend (bfd
*output_bfd
, struct bfd_link_info
*info
,
8911 bfd
*input_bfd
, Elf_Internal_Sym
*local_syms
,
8912 asection
**local_sections
, Elf_Internal_Rela
*rel
)
8914 unsigned int r_type
, r_symndx
;
8915 Elf_Internal_Sym
*sym
;
8918 if (mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
, FALSE
))
8920 r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
8921 if (r_type
== R_MIPS16_GPREL
8922 || r_type
== R_MIPS_GPREL16
8923 || r_type
== R_MIPS_GPREL32
8924 || r_type
== R_MIPS_LITERAL
)
8926 rel
->r_addend
+= _bfd_get_gp_value (input_bfd
);
8927 rel
->r_addend
-= _bfd_get_gp_value (output_bfd
);
8930 r_symndx
= ELF_R_SYM (output_bfd
, rel
->r_info
);
8931 sym
= local_syms
+ r_symndx
;
8933 /* Adjust REL's addend to account for section merging. */
8934 if (!info
->relocatable
)
8936 sec
= local_sections
[r_symndx
];
8937 _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
8940 /* This would normally be done by the rela_normal code in elflink.c. */
8941 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
8942 rel
->r_addend
+= local_sections
[r_symndx
]->output_offset
;
8946 /* Relocate a MIPS ELF section. */
8949 _bfd_mips_elf_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
8950 bfd
*input_bfd
, asection
*input_section
,
8951 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
8952 Elf_Internal_Sym
*local_syms
,
8953 asection
**local_sections
)
8955 Elf_Internal_Rela
*rel
;
8956 const Elf_Internal_Rela
*relend
;
8958 bfd_boolean use_saved_addend_p
= FALSE
;
8959 const struct elf_backend_data
*bed
;
8961 bed
= get_elf_backend_data (output_bfd
);
8962 relend
= relocs
+ input_section
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
8963 for (rel
= relocs
; rel
< relend
; ++rel
)
8967 reloc_howto_type
*howto
;
8968 bfd_boolean cross_mode_jump_p
;
8969 /* TRUE if the relocation is a RELA relocation, rather than a
8971 bfd_boolean rela_relocation_p
= TRUE
;
8972 unsigned int r_type
= ELF_R_TYPE (output_bfd
, rel
->r_info
);
8974 unsigned long r_symndx
;
8976 Elf_Internal_Shdr
*symtab_hdr
;
8977 struct elf_link_hash_entry
*h
;
8979 /* Find the relocation howto for this relocation. */
8980 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, r_type
,
8981 NEWABI_P (input_bfd
)
8982 && (MIPS_RELOC_RELA_P
8983 (input_bfd
, input_section
,
8986 r_symndx
= ELF_R_SYM (input_bfd
, rel
->r_info
);
8987 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
8988 if (mips_elf_local_relocation_p (input_bfd
, rel
, local_sections
, FALSE
))
8990 sec
= local_sections
[r_symndx
];
8995 unsigned long extsymoff
;
8998 if (!elf_bad_symtab (input_bfd
))
8999 extsymoff
= symtab_hdr
->sh_info
;
9000 h
= elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
];
9001 while (h
->root
.type
== bfd_link_hash_indirect
9002 || h
->root
.type
== bfd_link_hash_warning
)
9003 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
9006 if (h
->root
.type
== bfd_link_hash_defined
9007 || h
->root
.type
== bfd_link_hash_defweak
)
9008 sec
= h
->root
.u
.def
.section
;
9011 if (sec
!= NULL
&& elf_discarded_section (sec
))
9013 /* For relocs against symbols from removed linkonce sections,
9014 or sections discarded by a linker script, we just want the
9015 section contents zeroed. Avoid any special processing. */
9016 _bfd_clear_contents (howto
, input_bfd
, contents
+ rel
->r_offset
);
9022 if (r_type
== R_MIPS_64
&& ! NEWABI_P (input_bfd
))
9024 /* Some 32-bit code uses R_MIPS_64. In particular, people use
9025 64-bit code, but make sure all their addresses are in the
9026 lowermost or uppermost 32-bit section of the 64-bit address
9027 space. Thus, when they use an R_MIPS_64 they mean what is
9028 usually meant by R_MIPS_32, with the exception that the
9029 stored value is sign-extended to 64 bits. */
9030 howto
= MIPS_ELF_RTYPE_TO_HOWTO (input_bfd
, R_MIPS_32
, FALSE
);
9032 /* On big-endian systems, we need to lie about the position
9034 if (bfd_big_endian (input_bfd
))
9038 if (!use_saved_addend_p
)
9040 /* If these relocations were originally of the REL variety,
9041 we must pull the addend out of the field that will be
9042 relocated. Otherwise, we simply use the contents of the
9044 if (mips_elf_rel_relocation_p (input_bfd
, input_section
,
9047 rela_relocation_p
= FALSE
;
9048 addend
= mips_elf_read_rel_addend (input_bfd
, rel
,
9050 if (hi16_reloc_p (r_type
)
9051 || (got16_reloc_p (r_type
)
9052 && mips_elf_local_relocation_p (input_bfd
, rel
,
9053 local_sections
, FALSE
)))
9055 if (!mips_elf_add_lo16_rel_addend (input_bfd
, rel
, relend
,
9059 name
= h
->root
.root
.string
;
9061 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
9062 local_syms
+ r_symndx
,
9064 (*_bfd_error_handler
)
9065 (_("%B: Can't find matching LO16 reloc against `%s' for %s at 0x%lx in section `%A'"),
9066 input_bfd
, input_section
, name
, howto
->name
,
9071 addend
<<= howto
->rightshift
;
9074 addend
= rel
->r_addend
;
9075 mips_elf_adjust_addend (output_bfd
, info
, input_bfd
,
9076 local_syms
, local_sections
, rel
);
9079 if (info
->relocatable
)
9081 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
)
9082 && bfd_big_endian (input_bfd
))
9085 if (!rela_relocation_p
&& rel
->r_addend
)
9087 addend
+= rel
->r_addend
;
9088 if (hi16_reloc_p (r_type
) || got16_reloc_p (r_type
))
9089 addend
= mips_elf_high (addend
);
9090 else if (r_type
== R_MIPS_HIGHER
)
9091 addend
= mips_elf_higher (addend
);
9092 else if (r_type
== R_MIPS_HIGHEST
)
9093 addend
= mips_elf_highest (addend
);
9095 addend
>>= howto
->rightshift
;
9097 /* We use the source mask, rather than the destination
9098 mask because the place to which we are writing will be
9099 source of the addend in the final link. */
9100 addend
&= howto
->src_mask
;
9102 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
9103 /* See the comment above about using R_MIPS_64 in the 32-bit
9104 ABI. Here, we need to update the addend. It would be
9105 possible to get away with just using the R_MIPS_32 reloc
9106 but for endianness. */
9112 if (addend
& ((bfd_vma
) 1 << 31))
9114 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
9121 /* If we don't know that we have a 64-bit type,
9122 do two separate stores. */
9123 if (bfd_big_endian (input_bfd
))
9125 /* Store the sign-bits (which are most significant)
9127 low_bits
= sign_bits
;
9133 high_bits
= sign_bits
;
9135 bfd_put_32 (input_bfd
, low_bits
,
9136 contents
+ rel
->r_offset
);
9137 bfd_put_32 (input_bfd
, high_bits
,
9138 contents
+ rel
->r_offset
+ 4);
9142 if (! mips_elf_perform_relocation (info
, howto
, rel
, addend
,
9143 input_bfd
, input_section
,
9148 /* Go on to the next relocation. */
9152 /* In the N32 and 64-bit ABIs there may be multiple consecutive
9153 relocations for the same offset. In that case we are
9154 supposed to treat the output of each relocation as the addend
9156 if (rel
+ 1 < relend
9157 && rel
->r_offset
== rel
[1].r_offset
9158 && ELF_R_TYPE (input_bfd
, rel
[1].r_info
) != R_MIPS_NONE
)
9159 use_saved_addend_p
= TRUE
;
9161 use_saved_addend_p
= FALSE
;
9163 /* Figure out what value we are supposed to relocate. */
9164 switch (mips_elf_calculate_relocation (output_bfd
, input_bfd
,
9165 input_section
, info
, rel
,
9166 addend
, howto
, local_syms
,
9167 local_sections
, &value
,
9168 &name
, &cross_mode_jump_p
,
9169 use_saved_addend_p
))
9171 case bfd_reloc_continue
:
9172 /* There's nothing to do. */
9175 case bfd_reloc_undefined
:
9176 /* mips_elf_calculate_relocation already called the
9177 undefined_symbol callback. There's no real point in
9178 trying to perform the relocation at this point, so we
9179 just skip ahead to the next relocation. */
9182 case bfd_reloc_notsupported
:
9183 msg
= _("internal error: unsupported relocation error");
9184 info
->callbacks
->warning
9185 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
9188 case bfd_reloc_overflow
:
9189 if (use_saved_addend_p
)
9190 /* Ignore overflow until we reach the last relocation for
9191 a given location. */
9195 struct mips_elf_link_hash_table
*htab
;
9197 htab
= mips_elf_hash_table (info
);
9198 BFD_ASSERT (htab
!= NULL
);
9199 BFD_ASSERT (name
!= NULL
);
9200 if (!htab
->small_data_overflow_reported
9201 && (howto
->type
== R_MIPS_GPREL16
9202 || howto
->type
== R_MIPS_LITERAL
))
9204 msg
= _("small-data section exceeds 64KB;"
9205 " lower small-data size limit (see option -G)");
9207 htab
->small_data_overflow_reported
= TRUE
;
9208 (*info
->callbacks
->einfo
) ("%P: %s\n", msg
);
9210 if (! ((*info
->callbacks
->reloc_overflow
)
9211 (info
, NULL
, name
, howto
->name
, (bfd_vma
) 0,
9212 input_bfd
, input_section
, rel
->r_offset
)))
9225 /* If we've got another relocation for the address, keep going
9226 until we reach the last one. */
9227 if (use_saved_addend_p
)
9233 if (r_type
== R_MIPS_64
&& ! NEWABI_P (output_bfd
))
9234 /* See the comment above about using R_MIPS_64 in the 32-bit
9235 ABI. Until now, we've been using the HOWTO for R_MIPS_32;
9236 that calculated the right value. Now, however, we
9237 sign-extend the 32-bit result to 64-bits, and store it as a
9238 64-bit value. We are especially generous here in that we
9239 go to extreme lengths to support this usage on systems with
9240 only a 32-bit VMA. */
9246 if (value
& ((bfd_vma
) 1 << 31))
9248 sign_bits
= ((bfd_vma
) 1 << 32) - 1;
9255 /* If we don't know that we have a 64-bit type,
9256 do two separate stores. */
9257 if (bfd_big_endian (input_bfd
))
9259 /* Undo what we did above. */
9261 /* Store the sign-bits (which are most significant)
9263 low_bits
= sign_bits
;
9269 high_bits
= sign_bits
;
9271 bfd_put_32 (input_bfd
, low_bits
,
9272 contents
+ rel
->r_offset
);
9273 bfd_put_32 (input_bfd
, high_bits
,
9274 contents
+ rel
->r_offset
+ 4);
9278 /* Actually perform the relocation. */
9279 if (! mips_elf_perform_relocation (info
, howto
, rel
, value
,
9280 input_bfd
, input_section
,
9281 contents
, cross_mode_jump_p
))
9288 /* A function that iterates over each entry in la25_stubs and fills
9289 in the code for each one. DATA points to a mips_htab_traverse_info. */
9292 mips_elf_create_la25_stub (void **slot
, void *data
)
9294 struct mips_htab_traverse_info
*hti
;
9295 struct mips_elf_link_hash_table
*htab
;
9296 struct mips_elf_la25_stub
*stub
;
9299 bfd_vma offset
, target
, target_high
, target_low
;
9301 stub
= (struct mips_elf_la25_stub
*) *slot
;
9302 hti
= (struct mips_htab_traverse_info
*) data
;
9303 htab
= mips_elf_hash_table (hti
->info
);
9304 BFD_ASSERT (htab
!= NULL
);
9306 /* Create the section contents, if we haven't already. */
9307 s
= stub
->stub_section
;
9311 loc
= bfd_malloc (s
->size
);
9320 /* Work out where in the section this stub should go. */
9321 offset
= stub
->offset
;
9323 /* Work out the target address. */
9324 target
= (stub
->h
->root
.root
.u
.def
.section
->output_section
->vma
9325 + stub
->h
->root
.root
.u
.def
.section
->output_offset
9326 + stub
->h
->root
.root
.u
.def
.value
);
9327 target_high
= ((target
+ 0x8000) >> 16) & 0xffff;
9328 target_low
= (target
& 0xffff);
9330 if (stub
->stub_section
!= htab
->strampoline
)
9332 /* This is a simple LUI/ADIDU stub. Zero out the beginning
9333 of the section and write the two instructions at the end. */
9334 memset (loc
, 0, offset
);
9336 bfd_put_32 (hti
->output_bfd
, LA25_LUI (target_high
), loc
);
9337 bfd_put_32 (hti
->output_bfd
, LA25_ADDIU (target_low
), loc
+ 4);
9341 /* This is trampoline. */
9343 bfd_put_32 (hti
->output_bfd
, LA25_LUI (target_high
), loc
);
9344 bfd_put_32 (hti
->output_bfd
, LA25_J (target
), loc
+ 4);
9345 bfd_put_32 (hti
->output_bfd
, LA25_ADDIU (target_low
), loc
+ 8);
9346 bfd_put_32 (hti
->output_bfd
, 0, loc
+ 12);
9351 /* If NAME is one of the special IRIX6 symbols defined by the linker,
9352 adjust it appropriately now. */
9355 mips_elf_irix6_finish_dynamic_symbol (bfd
*abfd ATTRIBUTE_UNUSED
,
9356 const char *name
, Elf_Internal_Sym
*sym
)
9358 /* The linker script takes care of providing names and values for
9359 these, but we must place them into the right sections. */
9360 static const char* const text_section_symbols
[] = {
9363 "__dso_displacement",
9365 "__program_header_table",
9369 static const char* const data_section_symbols
[] = {
9377 const char* const *p
;
9380 for (i
= 0; i
< 2; ++i
)
9381 for (p
= (i
== 0) ? text_section_symbols
: data_section_symbols
;
9384 if (strcmp (*p
, name
) == 0)
9386 /* All of these symbols are given type STT_SECTION by the
9388 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
9389 sym
->st_other
= STO_PROTECTED
;
9391 /* The IRIX linker puts these symbols in special sections. */
9393 sym
->st_shndx
= SHN_MIPS_TEXT
;
9395 sym
->st_shndx
= SHN_MIPS_DATA
;
9401 /* Finish up dynamic symbol handling. We set the contents of various
9402 dynamic sections here. */
9405 _bfd_mips_elf_finish_dynamic_symbol (bfd
*output_bfd
,
9406 struct bfd_link_info
*info
,
9407 struct elf_link_hash_entry
*h
,
9408 Elf_Internal_Sym
*sym
)
9412 struct mips_got_info
*g
, *gg
;
9415 struct mips_elf_link_hash_table
*htab
;
9416 struct mips_elf_link_hash_entry
*hmips
;
9418 htab
= mips_elf_hash_table (info
);
9419 BFD_ASSERT (htab
!= NULL
);
9420 dynobj
= elf_hash_table (info
)->dynobj
;
9421 hmips
= (struct mips_elf_link_hash_entry
*) h
;
9423 BFD_ASSERT (!htab
->is_vxworks
);
9425 if (h
->plt
.offset
!= MINUS_ONE
&& hmips
->no_fn_stub
)
9427 /* We've decided to create a PLT entry for this symbol. */
9429 bfd_vma header_address
, plt_index
, got_address
;
9430 bfd_vma got_address_high
, got_address_low
, load
;
9431 const bfd_vma
*plt_entry
;
9433 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
9434 BFD_ASSERT (h
->dynindx
!= -1);
9435 BFD_ASSERT (htab
->splt
!= NULL
);
9436 BFD_ASSERT (h
->plt
.offset
<= htab
->splt
->size
);
9437 BFD_ASSERT (!h
->def_regular
);
9439 /* Calculate the address of the PLT header. */
9440 header_address
= (htab
->splt
->output_section
->vma
9441 + htab
->splt
->output_offset
);
9443 /* Calculate the index of the entry. */
9444 plt_index
= ((h
->plt
.offset
- htab
->plt_header_size
)
9445 / htab
->plt_entry_size
);
9447 /* Calculate the address of the .got.plt entry. */
9448 got_address
= (htab
->sgotplt
->output_section
->vma
9449 + htab
->sgotplt
->output_offset
9450 + (2 + plt_index
) * MIPS_ELF_GOT_SIZE (dynobj
));
9451 got_address_high
= ((got_address
+ 0x8000) >> 16) & 0xffff;
9452 got_address_low
= got_address
& 0xffff;
9454 /* Initially point the .got.plt entry at the PLT header. */
9455 loc
= (htab
->sgotplt
->contents
9456 + (2 + plt_index
) * MIPS_ELF_GOT_SIZE (dynobj
));
9457 if (ABI_64_P (output_bfd
))
9458 bfd_put_64 (output_bfd
, header_address
, loc
);
9460 bfd_put_32 (output_bfd
, header_address
, loc
);
9462 /* Find out where the .plt entry should go. */
9463 loc
= htab
->splt
->contents
+ h
->plt
.offset
;
9465 /* Pick the load opcode. */
9466 load
= MIPS_ELF_LOAD_WORD (output_bfd
);
9468 /* Fill in the PLT entry itself. */
9469 plt_entry
= mips_exec_plt_entry
;
9470 bfd_put_32 (output_bfd
, plt_entry
[0] | got_address_high
, loc
);
9471 bfd_put_32 (output_bfd
, plt_entry
[1] | got_address_low
| load
, loc
+ 4);
9473 if (! LOAD_INTERLOCKS_P (output_bfd
))
9475 bfd_put_32 (output_bfd
, plt_entry
[2] | got_address_low
, loc
+ 8);
9476 bfd_put_32 (output_bfd
, plt_entry
[3], loc
+ 12);
9480 bfd_put_32 (output_bfd
, plt_entry
[3], loc
+ 8);
9481 bfd_put_32 (output_bfd
, plt_entry
[2] | got_address_low
, loc
+ 12);
9484 /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry. */
9485 mips_elf_output_dynamic_relocation (output_bfd
, htab
->srelplt
,
9486 plt_index
, h
->dynindx
,
9487 R_MIPS_JUMP_SLOT
, got_address
);
9489 /* We distinguish between PLT entries and lazy-binding stubs by
9490 giving the former an st_other value of STO_MIPS_PLT. Set the
9491 flag and leave the value if there are any relocations in the
9492 binary where pointer equality matters. */
9493 sym
->st_shndx
= SHN_UNDEF
;
9494 if (h
->pointer_equality_needed
)
9495 sym
->st_other
= STO_MIPS_PLT
;
9499 else if (h
->plt
.offset
!= MINUS_ONE
)
9501 /* We've decided to create a lazy-binding stub. */
9502 bfd_byte stub
[MIPS_FUNCTION_STUB_BIG_SIZE
];
9504 /* This symbol has a stub. Set it up. */
9506 BFD_ASSERT (h
->dynindx
!= -1);
9508 BFD_ASSERT ((htab
->function_stub_size
== MIPS_FUNCTION_STUB_BIG_SIZE
)
9509 || (h
->dynindx
<= 0xffff));
9511 /* Values up to 2^31 - 1 are allowed. Larger values would cause
9512 sign extension at runtime in the stub, resulting in a negative
9514 if (h
->dynindx
& ~0x7fffffff)
9517 /* Fill the stub. */
9519 bfd_put_32 (output_bfd
, STUB_LW (output_bfd
), stub
+ idx
);
9521 bfd_put_32 (output_bfd
, STUB_MOVE (output_bfd
), stub
+ idx
);
9523 if (htab
->function_stub_size
== MIPS_FUNCTION_STUB_BIG_SIZE
)
9525 bfd_put_32 (output_bfd
, STUB_LUI ((h
->dynindx
>> 16) & 0x7fff),
9529 bfd_put_32 (output_bfd
, STUB_JALR
, stub
+ idx
);
9532 /* If a large stub is not required and sign extension is not a
9533 problem, then use legacy code in the stub. */
9534 if (htab
->function_stub_size
== MIPS_FUNCTION_STUB_BIG_SIZE
)
9535 bfd_put_32 (output_bfd
, STUB_ORI (h
->dynindx
& 0xffff), stub
+ idx
);
9536 else if (h
->dynindx
& ~0x7fff)
9537 bfd_put_32 (output_bfd
, STUB_LI16U (h
->dynindx
& 0xffff), stub
+ idx
);
9539 bfd_put_32 (output_bfd
, STUB_LI16S (output_bfd
, h
->dynindx
),
9542 BFD_ASSERT (h
->plt
.offset
<= htab
->sstubs
->size
);
9543 memcpy (htab
->sstubs
->contents
+ h
->plt
.offset
,
9544 stub
, htab
->function_stub_size
);
9546 /* Mark the symbol as undefined. plt.offset != -1 occurs
9547 only for the referenced symbol. */
9548 sym
->st_shndx
= SHN_UNDEF
;
9550 /* The run-time linker uses the st_value field of the symbol
9551 to reset the global offset table entry for this external
9552 to its stub address when unlinking a shared object. */
9553 sym
->st_value
= (htab
->sstubs
->output_section
->vma
9554 + htab
->sstubs
->output_offset
9558 /* If we have a MIPS16 function with a stub, the dynamic symbol must
9559 refer to the stub, since only the stub uses the standard calling
9561 if (h
->dynindx
!= -1 && hmips
->fn_stub
!= NULL
)
9563 BFD_ASSERT (hmips
->need_fn_stub
);
9564 sym
->st_value
= (hmips
->fn_stub
->output_section
->vma
9565 + hmips
->fn_stub
->output_offset
);
9566 sym
->st_size
= hmips
->fn_stub
->size
;
9567 sym
->st_other
= ELF_ST_VISIBILITY (sym
->st_other
);
9570 BFD_ASSERT (h
->dynindx
!= -1
9571 || h
->forced_local
);
9575 BFD_ASSERT (g
!= NULL
);
9577 /* Run through the global symbol table, creating GOT entries for all
9578 the symbols that need them. */
9579 if (g
->global_gotsym
!= NULL
9580 && h
->dynindx
>= g
->global_gotsym
->dynindx
)
9585 value
= sym
->st_value
;
9586 offset
= mips_elf_global_got_index (dynobj
, output_bfd
, h
,
9587 R_MIPS_GOT16
, info
);
9588 MIPS_ELF_PUT_WORD (output_bfd
, value
, sgot
->contents
+ offset
);
9591 if (g
->next
&& h
->dynindx
!= -1 && h
->type
!= STT_TLS
)
9593 struct mips_got_entry e
, *p
;
9599 e
.abfd
= output_bfd
;
9604 for (g
= g
->next
; g
->next
!= gg
; g
= g
->next
)
9607 && (p
= (struct mips_got_entry
*) htab_find (g
->got_entries
,
9612 || (elf_hash_table (info
)->dynamic_sections_created
9614 && p
->d
.h
->root
.def_dynamic
9615 && !p
->d
.h
->root
.def_regular
))
9617 /* Create an R_MIPS_REL32 relocation for this entry. Due to
9618 the various compatibility problems, it's easier to mock
9619 up an R_MIPS_32 or R_MIPS_64 relocation and leave
9620 mips_elf_create_dynamic_relocation to calculate the
9621 appropriate addend. */
9622 Elf_Internal_Rela rel
[3];
9624 memset (rel
, 0, sizeof (rel
));
9625 if (ABI_64_P (output_bfd
))
9626 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_64
);
9628 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_32
);
9629 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
= offset
;
9632 if (! (mips_elf_create_dynamic_relocation
9633 (output_bfd
, info
, rel
,
9634 e
.d
.h
, NULL
, sym
->st_value
, &entry
, sgot
)))
9638 entry
= sym
->st_value
;
9639 MIPS_ELF_PUT_WORD (output_bfd
, entry
, sgot
->contents
+ offset
);
9644 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
9645 name
= h
->root
.root
.string
;
9646 if (strcmp (name
, "_DYNAMIC") == 0
9647 || h
== elf_hash_table (info
)->hgot
)
9648 sym
->st_shndx
= SHN_ABS
;
9649 else if (strcmp (name
, "_DYNAMIC_LINK") == 0
9650 || strcmp (name
, "_DYNAMIC_LINKING") == 0)
9652 sym
->st_shndx
= SHN_ABS
;
9653 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
9656 else if (strcmp (name
, "_gp_disp") == 0 && ! NEWABI_P (output_bfd
))
9658 sym
->st_shndx
= SHN_ABS
;
9659 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
9660 sym
->st_value
= elf_gp (output_bfd
);
9662 else if (SGI_COMPAT (output_bfd
))
9664 if (strcmp (name
, mips_elf_dynsym_rtproc_names
[0]) == 0
9665 || strcmp (name
, mips_elf_dynsym_rtproc_names
[1]) == 0)
9667 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
9668 sym
->st_other
= STO_PROTECTED
;
9670 sym
->st_shndx
= SHN_MIPS_DATA
;
9672 else if (strcmp (name
, mips_elf_dynsym_rtproc_names
[2]) == 0)
9674 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
9675 sym
->st_other
= STO_PROTECTED
;
9676 sym
->st_value
= mips_elf_hash_table (info
)->procedure_count
;
9677 sym
->st_shndx
= SHN_ABS
;
9679 else if (sym
->st_shndx
!= SHN_UNDEF
&& sym
->st_shndx
!= SHN_ABS
)
9681 if (h
->type
== STT_FUNC
)
9682 sym
->st_shndx
= SHN_MIPS_TEXT
;
9683 else if (h
->type
== STT_OBJECT
)
9684 sym
->st_shndx
= SHN_MIPS_DATA
;
9688 /* Emit a copy reloc, if needed. */
9694 BFD_ASSERT (h
->dynindx
!= -1);
9695 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
9697 s
= mips_elf_rel_dyn_section (info
, FALSE
);
9698 symval
= (h
->root
.u
.def
.section
->output_section
->vma
9699 + h
->root
.u
.def
.section
->output_offset
9700 + h
->root
.u
.def
.value
);
9701 mips_elf_output_dynamic_relocation (output_bfd
, s
, s
->reloc_count
++,
9702 h
->dynindx
, R_MIPS_COPY
, symval
);
9705 /* Handle the IRIX6-specific symbols. */
9706 if (IRIX_COMPAT (output_bfd
) == ict_irix6
)
9707 mips_elf_irix6_finish_dynamic_symbol (output_bfd
, name
, sym
);
9711 if (! mips_elf_hash_table (info
)->use_rld_obj_head
9712 && (strcmp (name
, "__rld_map") == 0
9713 || strcmp (name
, "__RLD_MAP") == 0))
9715 asection
*s
= bfd_get_section_by_name (dynobj
, ".rld_map");
9716 BFD_ASSERT (s
!= NULL
);
9717 sym
->st_value
= s
->output_section
->vma
+ s
->output_offset
;
9718 bfd_put_32 (output_bfd
, 0, s
->contents
);
9719 if (mips_elf_hash_table (info
)->rld_value
== 0)
9720 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
9722 else if (mips_elf_hash_table (info
)->use_rld_obj_head
9723 && strcmp (name
, "__rld_obj_head") == 0)
9725 /* IRIX6 does not use a .rld_map section. */
9726 if (IRIX_COMPAT (output_bfd
) == ict_irix5
9727 || IRIX_COMPAT (output_bfd
) == ict_none
)
9728 BFD_ASSERT (bfd_get_section_by_name (dynobj
, ".rld_map")
9730 mips_elf_hash_table (info
)->rld_value
= sym
->st_value
;
9734 /* Keep dynamic MIPS16 symbols odd. This allows the dynamic linker to
9735 treat MIPS16 symbols like any other. */
9736 if (ELF_ST_IS_MIPS16 (sym
->st_other
))
9738 BFD_ASSERT (sym
->st_value
& 1);
9739 sym
->st_other
-= STO_MIPS16
;
9745 /* Likewise, for VxWorks. */
9748 _bfd_mips_vxworks_finish_dynamic_symbol (bfd
*output_bfd
,
9749 struct bfd_link_info
*info
,
9750 struct elf_link_hash_entry
*h
,
9751 Elf_Internal_Sym
*sym
)
9755 struct mips_got_info
*g
;
9756 struct mips_elf_link_hash_table
*htab
;
9758 htab
= mips_elf_hash_table (info
);
9759 BFD_ASSERT (htab
!= NULL
);
9760 dynobj
= elf_hash_table (info
)->dynobj
;
9762 if (h
->plt
.offset
!= (bfd_vma
) -1)
9765 bfd_vma plt_address
, plt_index
, got_address
, got_offset
, branch_offset
;
9766 Elf_Internal_Rela rel
;
9767 static const bfd_vma
*plt_entry
;
9769 BFD_ASSERT (h
->dynindx
!= -1);
9770 BFD_ASSERT (htab
->splt
!= NULL
);
9771 BFD_ASSERT (h
->plt
.offset
<= htab
->splt
->size
);
9773 /* Calculate the address of the .plt entry. */
9774 plt_address
= (htab
->splt
->output_section
->vma
9775 + htab
->splt
->output_offset
9778 /* Calculate the index of the entry. */
9779 plt_index
= ((h
->plt
.offset
- htab
->plt_header_size
)
9780 / htab
->plt_entry_size
);
9782 /* Calculate the address of the .got.plt entry. */
9783 got_address
= (htab
->sgotplt
->output_section
->vma
9784 + htab
->sgotplt
->output_offset
9787 /* Calculate the offset of the .got.plt entry from
9788 _GLOBAL_OFFSET_TABLE_. */
9789 got_offset
= mips_elf_gotplt_index (info
, h
);
9791 /* Calculate the offset for the branch at the start of the PLT
9792 entry. The branch jumps to the beginning of .plt. */
9793 branch_offset
= -(h
->plt
.offset
/ 4 + 1) & 0xffff;
9795 /* Fill in the initial value of the .got.plt entry. */
9796 bfd_put_32 (output_bfd
, plt_address
,
9797 htab
->sgotplt
->contents
+ plt_index
* 4);
9799 /* Find out where the .plt entry should go. */
9800 loc
= htab
->splt
->contents
+ h
->plt
.offset
;
9804 plt_entry
= mips_vxworks_shared_plt_entry
;
9805 bfd_put_32 (output_bfd
, plt_entry
[0] | branch_offset
, loc
);
9806 bfd_put_32 (output_bfd
, plt_entry
[1] | plt_index
, loc
+ 4);
9810 bfd_vma got_address_high
, got_address_low
;
9812 plt_entry
= mips_vxworks_exec_plt_entry
;
9813 got_address_high
= ((got_address
+ 0x8000) >> 16) & 0xffff;
9814 got_address_low
= got_address
& 0xffff;
9816 bfd_put_32 (output_bfd
, plt_entry
[0] | branch_offset
, loc
);
9817 bfd_put_32 (output_bfd
, plt_entry
[1] | plt_index
, loc
+ 4);
9818 bfd_put_32 (output_bfd
, plt_entry
[2] | got_address_high
, loc
+ 8);
9819 bfd_put_32 (output_bfd
, plt_entry
[3] | got_address_low
, loc
+ 12);
9820 bfd_put_32 (output_bfd
, plt_entry
[4], loc
+ 16);
9821 bfd_put_32 (output_bfd
, plt_entry
[5], loc
+ 20);
9822 bfd_put_32 (output_bfd
, plt_entry
[6], loc
+ 24);
9823 bfd_put_32 (output_bfd
, plt_entry
[7], loc
+ 28);
9825 loc
= (htab
->srelplt2
->contents
9826 + (plt_index
* 3 + 2) * sizeof (Elf32_External_Rela
));
9828 /* Emit a relocation for the .got.plt entry. */
9829 rel
.r_offset
= got_address
;
9830 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
, R_MIPS_32
);
9831 rel
.r_addend
= h
->plt
.offset
;
9832 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
9834 /* Emit a relocation for the lui of %hi(<.got.plt slot>). */
9835 loc
+= sizeof (Elf32_External_Rela
);
9836 rel
.r_offset
= plt_address
+ 8;
9837 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_HI16
);
9838 rel
.r_addend
= got_offset
;
9839 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
9841 /* Emit a relocation for the addiu of %lo(<.got.plt slot>). */
9842 loc
+= sizeof (Elf32_External_Rela
);
9844 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_LO16
);
9845 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
9848 /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry. */
9849 loc
= htab
->srelplt
->contents
+ plt_index
* sizeof (Elf32_External_Rela
);
9850 rel
.r_offset
= got_address
;
9851 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_JUMP_SLOT
);
9853 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
9855 if (!h
->def_regular
)
9856 sym
->st_shndx
= SHN_UNDEF
;
9859 BFD_ASSERT (h
->dynindx
!= -1 || h
->forced_local
);
9863 BFD_ASSERT (g
!= NULL
);
9865 /* See if this symbol has an entry in the GOT. */
9866 if (g
->global_gotsym
!= NULL
9867 && h
->dynindx
>= g
->global_gotsym
->dynindx
)
9870 Elf_Internal_Rela outrel
;
9874 /* Install the symbol value in the GOT. */
9875 offset
= mips_elf_global_got_index (dynobj
, output_bfd
, h
,
9876 R_MIPS_GOT16
, info
);
9877 MIPS_ELF_PUT_WORD (output_bfd
, sym
->st_value
, sgot
->contents
+ offset
);
9879 /* Add a dynamic relocation for it. */
9880 s
= mips_elf_rel_dyn_section (info
, FALSE
);
9881 loc
= s
->contents
+ (s
->reloc_count
++ * sizeof (Elf32_External_Rela
));
9882 outrel
.r_offset
= (sgot
->output_section
->vma
9883 + sgot
->output_offset
9885 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_32
);
9886 outrel
.r_addend
= 0;
9887 bfd_elf32_swap_reloca_out (dynobj
, &outrel
, loc
);
9890 /* Emit a copy reloc, if needed. */
9893 Elf_Internal_Rela rel
;
9895 BFD_ASSERT (h
->dynindx
!= -1);
9897 rel
.r_offset
= (h
->root
.u
.def
.section
->output_section
->vma
9898 + h
->root
.u
.def
.section
->output_offset
9899 + h
->root
.u
.def
.value
);
9900 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MIPS_COPY
);
9902 bfd_elf32_swap_reloca_out (output_bfd
, &rel
,
9903 htab
->srelbss
->contents
9904 + (htab
->srelbss
->reloc_count
9905 * sizeof (Elf32_External_Rela
)));
9906 ++htab
->srelbss
->reloc_count
;
9909 /* If this is a mips16 symbol, force the value to be even. */
9910 if (ELF_ST_IS_MIPS16 (sym
->st_other
))
9911 sym
->st_value
&= ~1;
9916 /* Write out a plt0 entry to the beginning of .plt. */
9919 mips_finish_exec_plt (bfd
*output_bfd
, struct bfd_link_info
*info
)
9922 bfd_vma gotplt_value
, gotplt_value_high
, gotplt_value_low
;
9923 static const bfd_vma
*plt_entry
;
9924 struct mips_elf_link_hash_table
*htab
;
9926 htab
= mips_elf_hash_table (info
);
9927 BFD_ASSERT (htab
!= NULL
);
9929 if (ABI_64_P (output_bfd
))
9930 plt_entry
= mips_n64_exec_plt0_entry
;
9931 else if (ABI_N32_P (output_bfd
))
9932 plt_entry
= mips_n32_exec_plt0_entry
;
9934 plt_entry
= mips_o32_exec_plt0_entry
;
9936 /* Calculate the value of .got.plt. */
9937 gotplt_value
= (htab
->sgotplt
->output_section
->vma
9938 + htab
->sgotplt
->output_offset
);
9939 gotplt_value_high
= ((gotplt_value
+ 0x8000) >> 16) & 0xffff;
9940 gotplt_value_low
= gotplt_value
& 0xffff;
9942 /* The PLT sequence is not safe for N64 if .got.plt's address can
9943 not be loaded in two instructions. */
9944 BFD_ASSERT ((gotplt_value
& ~(bfd_vma
) 0x7fffffff) == 0
9945 || ~(gotplt_value
| 0x7fffffff) == 0);
9947 /* Install the PLT header. */
9948 loc
= htab
->splt
->contents
;
9949 bfd_put_32 (output_bfd
, plt_entry
[0] | gotplt_value_high
, loc
);
9950 bfd_put_32 (output_bfd
, plt_entry
[1] | gotplt_value_low
, loc
+ 4);
9951 bfd_put_32 (output_bfd
, plt_entry
[2] | gotplt_value_low
, loc
+ 8);
9952 bfd_put_32 (output_bfd
, plt_entry
[3], loc
+ 12);
9953 bfd_put_32 (output_bfd
, plt_entry
[4], loc
+ 16);
9954 bfd_put_32 (output_bfd
, plt_entry
[5], loc
+ 20);
9955 bfd_put_32 (output_bfd
, plt_entry
[6], loc
+ 24);
9956 bfd_put_32 (output_bfd
, plt_entry
[7], loc
+ 28);
9959 /* Install the PLT header for a VxWorks executable and finalize the
9960 contents of .rela.plt.unloaded. */
9963 mips_vxworks_finish_exec_plt (bfd
*output_bfd
, struct bfd_link_info
*info
)
9965 Elf_Internal_Rela rela
;
9967 bfd_vma got_value
, got_value_high
, got_value_low
, plt_address
;
9968 static const bfd_vma
*plt_entry
;
9969 struct mips_elf_link_hash_table
*htab
;
9971 htab
= mips_elf_hash_table (info
);
9972 BFD_ASSERT (htab
!= NULL
);
9974 plt_entry
= mips_vxworks_exec_plt0_entry
;
9976 /* Calculate the value of _GLOBAL_OFFSET_TABLE_. */
9977 got_value
= (htab
->root
.hgot
->root
.u
.def
.section
->output_section
->vma
9978 + htab
->root
.hgot
->root
.u
.def
.section
->output_offset
9979 + htab
->root
.hgot
->root
.u
.def
.value
);
9981 got_value_high
= ((got_value
+ 0x8000) >> 16) & 0xffff;
9982 got_value_low
= got_value
& 0xffff;
9984 /* Calculate the address of the PLT header. */
9985 plt_address
= htab
->splt
->output_section
->vma
+ htab
->splt
->output_offset
;
9987 /* Install the PLT header. */
9988 loc
= htab
->splt
->contents
;
9989 bfd_put_32 (output_bfd
, plt_entry
[0] | got_value_high
, loc
);
9990 bfd_put_32 (output_bfd
, plt_entry
[1] | got_value_low
, loc
+ 4);
9991 bfd_put_32 (output_bfd
, plt_entry
[2], loc
+ 8);
9992 bfd_put_32 (output_bfd
, plt_entry
[3], loc
+ 12);
9993 bfd_put_32 (output_bfd
, plt_entry
[4], loc
+ 16);
9994 bfd_put_32 (output_bfd
, plt_entry
[5], loc
+ 20);
9996 /* Output the relocation for the lui of %hi(_GLOBAL_OFFSET_TABLE_). */
9997 loc
= htab
->srelplt2
->contents
;
9998 rela
.r_offset
= plt_address
;
9999 rela
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_HI16
);
10001 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
10002 loc
+= sizeof (Elf32_External_Rela
);
10004 /* Output the relocation for the following addiu of
10005 %lo(_GLOBAL_OFFSET_TABLE_). */
10006 rela
.r_offset
+= 4;
10007 rela
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_LO16
);
10008 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
10009 loc
+= sizeof (Elf32_External_Rela
);
10011 /* Fix up the remaining relocations. They may have the wrong
10012 symbol index for _G_O_T_ or _P_L_T_ depending on the order
10013 in which symbols were output. */
10014 while (loc
< htab
->srelplt2
->contents
+ htab
->srelplt2
->size
)
10016 Elf_Internal_Rela rel
;
10018 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &rel
);
10019 rel
.r_info
= ELF32_R_INFO (htab
->root
.hplt
->indx
, R_MIPS_32
);
10020 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
10021 loc
+= sizeof (Elf32_External_Rela
);
10023 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &rel
);
10024 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_HI16
);
10025 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
10026 loc
+= sizeof (Elf32_External_Rela
);
10028 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &rel
);
10029 rel
.r_info
= ELF32_R_INFO (htab
->root
.hgot
->indx
, R_MIPS_LO16
);
10030 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
10031 loc
+= sizeof (Elf32_External_Rela
);
10035 /* Install the PLT header for a VxWorks shared library. */
10038 mips_vxworks_finish_shared_plt (bfd
*output_bfd
, struct bfd_link_info
*info
)
10041 struct mips_elf_link_hash_table
*htab
;
10043 htab
= mips_elf_hash_table (info
);
10044 BFD_ASSERT (htab
!= NULL
);
10046 /* We just need to copy the entry byte-by-byte. */
10047 for (i
= 0; i
< ARRAY_SIZE (mips_vxworks_shared_plt0_entry
); i
++)
10048 bfd_put_32 (output_bfd
, mips_vxworks_shared_plt0_entry
[i
],
10049 htab
->splt
->contents
+ i
* 4);
10052 /* Finish up the dynamic sections. */
10055 _bfd_mips_elf_finish_dynamic_sections (bfd
*output_bfd
,
10056 struct bfd_link_info
*info
)
10061 struct mips_got_info
*gg
, *g
;
10062 struct mips_elf_link_hash_table
*htab
;
10064 htab
= mips_elf_hash_table (info
);
10065 BFD_ASSERT (htab
!= NULL
);
10067 dynobj
= elf_hash_table (info
)->dynobj
;
10069 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
10072 gg
= htab
->got_info
;
10074 if (elf_hash_table (info
)->dynamic_sections_created
)
10077 int dyn_to_skip
= 0, dyn_skipped
= 0;
10079 BFD_ASSERT (sdyn
!= NULL
);
10080 BFD_ASSERT (gg
!= NULL
);
10082 g
= mips_elf_got_for_ibfd (gg
, output_bfd
);
10083 BFD_ASSERT (g
!= NULL
);
10085 for (b
= sdyn
->contents
;
10086 b
< sdyn
->contents
+ sdyn
->size
;
10087 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
10089 Elf_Internal_Dyn dyn
;
10093 bfd_boolean swap_out_p
;
10095 /* Read in the current dynamic entry. */
10096 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
10098 /* Assume that we're going to modify it and write it out. */
10104 dyn
.d_un
.d_val
= MIPS_ELF_REL_SIZE (dynobj
);
10108 BFD_ASSERT (htab
->is_vxworks
);
10109 dyn
.d_un
.d_val
= MIPS_ELF_RELA_SIZE (dynobj
);
10113 /* Rewrite DT_STRSZ. */
10115 _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
10120 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
10123 case DT_MIPS_PLTGOT
:
10125 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
10128 case DT_MIPS_RLD_VERSION
:
10129 dyn
.d_un
.d_val
= 1; /* XXX */
10132 case DT_MIPS_FLAGS
:
10133 dyn
.d_un
.d_val
= RHF_NOTPOT
; /* XXX */
10136 case DT_MIPS_TIME_STAMP
:
10140 dyn
.d_un
.d_val
= t
;
10144 case DT_MIPS_ICHECKSUM
:
10146 swap_out_p
= FALSE
;
10149 case DT_MIPS_IVERSION
:
10151 swap_out_p
= FALSE
;
10154 case DT_MIPS_BASE_ADDRESS
:
10155 s
= output_bfd
->sections
;
10156 BFD_ASSERT (s
!= NULL
);
10157 dyn
.d_un
.d_ptr
= s
->vma
& ~(bfd_vma
) 0xffff;
10160 case DT_MIPS_LOCAL_GOTNO
:
10161 dyn
.d_un
.d_val
= g
->local_gotno
;
10164 case DT_MIPS_UNREFEXTNO
:
10165 /* The index into the dynamic symbol table which is the
10166 entry of the first external symbol that is not
10167 referenced within the same object. */
10168 dyn
.d_un
.d_val
= bfd_count_sections (output_bfd
) + 1;
10171 case DT_MIPS_GOTSYM
:
10172 if (gg
->global_gotsym
)
10174 dyn
.d_un
.d_val
= gg
->global_gotsym
->dynindx
;
10177 /* In case if we don't have global got symbols we default
10178 to setting DT_MIPS_GOTSYM to the same value as
10179 DT_MIPS_SYMTABNO, so we just fall through. */
10181 case DT_MIPS_SYMTABNO
:
10183 elemsize
= MIPS_ELF_SYM_SIZE (output_bfd
);
10184 s
= bfd_get_section_by_name (output_bfd
, name
);
10185 BFD_ASSERT (s
!= NULL
);
10187 dyn
.d_un
.d_val
= s
->size
/ elemsize
;
10190 case DT_MIPS_HIPAGENO
:
10191 dyn
.d_un
.d_val
= g
->local_gotno
- htab
->reserved_gotno
;
10194 case DT_MIPS_RLD_MAP
:
10195 dyn
.d_un
.d_ptr
= mips_elf_hash_table (info
)->rld_value
;
10198 case DT_MIPS_OPTIONS
:
10199 s
= (bfd_get_section_by_name
10200 (output_bfd
, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd
)));
10201 dyn
.d_un
.d_ptr
= s
->vma
;
10205 BFD_ASSERT (htab
->is_vxworks
);
10206 /* The count does not include the JUMP_SLOT relocations. */
10208 dyn
.d_un
.d_val
-= htab
->srelplt
->size
;
10212 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
10213 if (htab
->is_vxworks
)
10214 dyn
.d_un
.d_val
= DT_RELA
;
10216 dyn
.d_un
.d_val
= DT_REL
;
10220 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
10221 dyn
.d_un
.d_val
= htab
->srelplt
->size
;
10225 BFD_ASSERT (htab
->use_plts_and_copy_relocs
);
10226 dyn
.d_un
.d_ptr
= (htab
->srelplt
->output_section
->vma
10227 + htab
->srelplt
->output_offset
);
10231 /* If we didn't need any text relocations after all, delete
10232 the dynamic tag. */
10233 if (!(info
->flags
& DF_TEXTREL
))
10235 dyn_to_skip
= MIPS_ELF_DYN_SIZE (dynobj
);
10236 swap_out_p
= FALSE
;
10241 /* If we didn't need any text relocations after all, clear
10242 DF_TEXTREL from DT_FLAGS. */
10243 if (!(info
->flags
& DF_TEXTREL
))
10244 dyn
.d_un
.d_val
&= ~DF_TEXTREL
;
10246 swap_out_p
= FALSE
;
10250 swap_out_p
= FALSE
;
10251 if (htab
->is_vxworks
10252 && elf_vxworks_finish_dynamic_entry (output_bfd
, &dyn
))
10257 if (swap_out_p
|| dyn_skipped
)
10258 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
10259 (dynobj
, &dyn
, b
- dyn_skipped
);
10263 dyn_skipped
+= dyn_to_skip
;
10268 /* Wipe out any trailing entries if we shifted down a dynamic tag. */
10269 if (dyn_skipped
> 0)
10270 memset (b
- dyn_skipped
, 0, dyn_skipped
);
10273 if (sgot
!= NULL
&& sgot
->size
> 0
10274 && !bfd_is_abs_section (sgot
->output_section
))
10276 if (htab
->is_vxworks
)
10278 /* The first entry of the global offset table points to the
10279 ".dynamic" section. The second is initialized by the
10280 loader and contains the shared library identifier.
10281 The third is also initialized by the loader and points
10282 to the lazy resolution stub. */
10283 MIPS_ELF_PUT_WORD (output_bfd
,
10284 sdyn
->output_offset
+ sdyn
->output_section
->vma
,
10286 MIPS_ELF_PUT_WORD (output_bfd
, 0,
10287 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
10288 MIPS_ELF_PUT_WORD (output_bfd
, 0,
10290 + 2 * MIPS_ELF_GOT_SIZE (output_bfd
));
10294 /* The first entry of the global offset table will be filled at
10295 runtime. The second entry will be used by some runtime loaders.
10296 This isn't the case of IRIX rld. */
10297 MIPS_ELF_PUT_WORD (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
10298 MIPS_ELF_PUT_WORD (output_bfd
, MIPS_ELF_GNU_GOT1_MASK (output_bfd
),
10299 sgot
->contents
+ MIPS_ELF_GOT_SIZE (output_bfd
));
10302 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
10303 = MIPS_ELF_GOT_SIZE (output_bfd
);
10306 /* Generate dynamic relocations for the non-primary gots. */
10307 if (gg
!= NULL
&& gg
->next
)
10309 Elf_Internal_Rela rel
[3];
10310 bfd_vma addend
= 0;
10312 memset (rel
, 0, sizeof (rel
));
10313 rel
[0].r_info
= ELF_R_INFO (output_bfd
, 0, R_MIPS_REL32
);
10315 for (g
= gg
->next
; g
->next
!= gg
; g
= g
->next
)
10317 bfd_vma got_index
= g
->next
->local_gotno
+ g
->next
->global_gotno
10318 + g
->next
->tls_gotno
;
10320 MIPS_ELF_PUT_WORD (output_bfd
, 0, sgot
->contents
10321 + got_index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
10322 MIPS_ELF_PUT_WORD (output_bfd
, MIPS_ELF_GNU_GOT1_MASK (output_bfd
),
10324 + got_index
++ * MIPS_ELF_GOT_SIZE (output_bfd
));
10326 if (! info
->shared
)
10329 while (got_index
< g
->assigned_gotno
)
10331 rel
[0].r_offset
= rel
[1].r_offset
= rel
[2].r_offset
10332 = got_index
++ * MIPS_ELF_GOT_SIZE (output_bfd
);
10333 if (!(mips_elf_create_dynamic_relocation
10334 (output_bfd
, info
, rel
, NULL
,
10335 bfd_abs_section_ptr
,
10336 0, &addend
, sgot
)))
10338 BFD_ASSERT (addend
== 0);
10343 /* The generation of dynamic relocations for the non-primary gots
10344 adds more dynamic relocations. We cannot count them until
10347 if (elf_hash_table (info
)->dynamic_sections_created
)
10350 bfd_boolean swap_out_p
;
10352 BFD_ASSERT (sdyn
!= NULL
);
10354 for (b
= sdyn
->contents
;
10355 b
< sdyn
->contents
+ sdyn
->size
;
10356 b
+= MIPS_ELF_DYN_SIZE (dynobj
))
10358 Elf_Internal_Dyn dyn
;
10361 /* Read in the current dynamic entry. */
10362 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
10364 /* Assume that we're going to modify it and write it out. */
10370 /* Reduce DT_RELSZ to account for any relocations we
10371 decided not to make. This is for the n64 irix rld,
10372 which doesn't seem to apply any relocations if there
10373 are trailing null entries. */
10374 s
= mips_elf_rel_dyn_section (info
, FALSE
);
10375 dyn
.d_un
.d_val
= (s
->reloc_count
10376 * (ABI_64_P (output_bfd
)
10377 ? sizeof (Elf64_Mips_External_Rel
)
10378 : sizeof (Elf32_External_Rel
)));
10379 /* Adjust the section size too. Tools like the prelinker
10380 can reasonably expect the values to the same. */
10381 elf_section_data (s
->output_section
)->this_hdr
.sh_size
10386 swap_out_p
= FALSE
;
10391 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
)
10398 Elf32_compact_rel cpt
;
10400 if (SGI_COMPAT (output_bfd
))
10402 /* Write .compact_rel section out. */
10403 s
= bfd_get_section_by_name (dynobj
, ".compact_rel");
10407 cpt
.num
= s
->reloc_count
;
10409 cpt
.offset
= (s
->output_section
->filepos
10410 + sizeof (Elf32_External_compact_rel
));
10413 bfd_elf32_swap_compact_rel_out (output_bfd
, &cpt
,
10414 ((Elf32_External_compact_rel
*)
10417 /* Clean up a dummy stub function entry in .text. */
10418 if (htab
->sstubs
!= NULL
)
10420 file_ptr dummy_offset
;
10422 BFD_ASSERT (htab
->sstubs
->size
>= htab
->function_stub_size
);
10423 dummy_offset
= htab
->sstubs
->size
- htab
->function_stub_size
;
10424 memset (htab
->sstubs
->contents
+ dummy_offset
, 0,
10425 htab
->function_stub_size
);
10430 /* The psABI says that the dynamic relocations must be sorted in
10431 increasing order of r_symndx. The VxWorks EABI doesn't require
10432 this, and because the code below handles REL rather than RELA
10433 relocations, using it for VxWorks would be outright harmful. */
10434 if (!htab
->is_vxworks
)
10436 s
= mips_elf_rel_dyn_section (info
, FALSE
);
10438 && s
->size
> (bfd_vma
)2 * MIPS_ELF_REL_SIZE (output_bfd
))
10440 reldyn_sorting_bfd
= output_bfd
;
10442 if (ABI_64_P (output_bfd
))
10443 qsort ((Elf64_External_Rel
*) s
->contents
+ 1,
10444 s
->reloc_count
- 1, sizeof (Elf64_Mips_External_Rel
),
10445 sort_dynamic_relocs_64
);
10447 qsort ((Elf32_External_Rel
*) s
->contents
+ 1,
10448 s
->reloc_count
- 1, sizeof (Elf32_External_Rel
),
10449 sort_dynamic_relocs
);
10454 if (htab
->splt
&& htab
->splt
->size
> 0)
10456 if (htab
->is_vxworks
)
10459 mips_vxworks_finish_shared_plt (output_bfd
, info
);
10461 mips_vxworks_finish_exec_plt (output_bfd
, info
);
10465 BFD_ASSERT (!info
->shared
);
10466 mips_finish_exec_plt (output_bfd
, info
);
10473 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags. */
10476 mips_set_isa_flags (bfd
*abfd
)
10480 switch (bfd_get_mach (abfd
))
10483 case bfd_mach_mips3000
:
10484 val
= E_MIPS_ARCH_1
;
10487 case bfd_mach_mips3900
:
10488 val
= E_MIPS_ARCH_1
| E_MIPS_MACH_3900
;
10491 case bfd_mach_mips6000
:
10492 val
= E_MIPS_ARCH_2
;
10495 case bfd_mach_mips4000
:
10496 case bfd_mach_mips4300
:
10497 case bfd_mach_mips4400
:
10498 case bfd_mach_mips4600
:
10499 val
= E_MIPS_ARCH_3
;
10502 case bfd_mach_mips4010
:
10503 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4010
;
10506 case bfd_mach_mips4100
:
10507 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4100
;
10510 case bfd_mach_mips4111
:
10511 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4111
;
10514 case bfd_mach_mips4120
:
10515 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4120
;
10518 case bfd_mach_mips4650
:
10519 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_4650
;
10522 case bfd_mach_mips5400
:
10523 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5400
;
10526 case bfd_mach_mips5500
:
10527 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_5500
;
10530 case bfd_mach_mips9000
:
10531 val
= E_MIPS_ARCH_4
| E_MIPS_MACH_9000
;
10534 case bfd_mach_mips5000
:
10535 case bfd_mach_mips7000
:
10536 case bfd_mach_mips8000
:
10537 case bfd_mach_mips10000
:
10538 case bfd_mach_mips12000
:
10539 case bfd_mach_mips14000
:
10540 case bfd_mach_mips16000
:
10541 val
= E_MIPS_ARCH_4
;
10544 case bfd_mach_mips5
:
10545 val
= E_MIPS_ARCH_5
;
10548 case bfd_mach_mips_loongson_2e
:
10549 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_LS2E
;
10552 case bfd_mach_mips_loongson_2f
:
10553 val
= E_MIPS_ARCH_3
| E_MIPS_MACH_LS2F
;
10556 case bfd_mach_mips_sb1
:
10557 val
= E_MIPS_ARCH_64
| E_MIPS_MACH_SB1
;
10560 case bfd_mach_mips_octeon
:
10561 val
= E_MIPS_ARCH_64R2
| E_MIPS_MACH_OCTEON
;
10564 case bfd_mach_mips_xlr
:
10565 val
= E_MIPS_ARCH_64
| E_MIPS_MACH_XLR
;
10568 case bfd_mach_mipsisa32
:
10569 val
= E_MIPS_ARCH_32
;
10572 case bfd_mach_mipsisa64
:
10573 val
= E_MIPS_ARCH_64
;
10576 case bfd_mach_mipsisa32r2
:
10577 val
= E_MIPS_ARCH_32R2
;
10580 case bfd_mach_mipsisa64r2
:
10581 val
= E_MIPS_ARCH_64R2
;
10584 elf_elfheader (abfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
10585 elf_elfheader (abfd
)->e_flags
|= val
;
10590 /* The final processing done just before writing out a MIPS ELF object
10591 file. This gets the MIPS architecture right based on the machine
10592 number. This is used by both the 32-bit and the 64-bit ABI. */
10595 _bfd_mips_elf_final_write_processing (bfd
*abfd
,
10596 bfd_boolean linker ATTRIBUTE_UNUSED
)
10599 Elf_Internal_Shdr
**hdrpp
;
10603 /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
10604 is nonzero. This is for compatibility with old objects, which used
10605 a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH. */
10606 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_MACH
) == 0)
10607 mips_set_isa_flags (abfd
);
10609 /* Set the sh_info field for .gptab sections and other appropriate
10610 info for each special section. */
10611 for (i
= 1, hdrpp
= elf_elfsections (abfd
) + 1;
10612 i
< elf_numsections (abfd
);
10615 switch ((*hdrpp
)->sh_type
)
10617 case SHT_MIPS_MSYM
:
10618 case SHT_MIPS_LIBLIST
:
10619 sec
= bfd_get_section_by_name (abfd
, ".dynstr");
10621 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
10624 case SHT_MIPS_GPTAB
:
10625 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
10626 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
10627 BFD_ASSERT (name
!= NULL
10628 && CONST_STRNEQ (name
, ".gptab."));
10629 sec
= bfd_get_section_by_name (abfd
, name
+ sizeof ".gptab" - 1);
10630 BFD_ASSERT (sec
!= NULL
);
10631 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
10634 case SHT_MIPS_CONTENT
:
10635 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
10636 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
10637 BFD_ASSERT (name
!= NULL
10638 && CONST_STRNEQ (name
, ".MIPS.content"));
10639 sec
= bfd_get_section_by_name (abfd
,
10640 name
+ sizeof ".MIPS.content" - 1);
10641 BFD_ASSERT (sec
!= NULL
);
10642 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
10645 case SHT_MIPS_SYMBOL_LIB
:
10646 sec
= bfd_get_section_by_name (abfd
, ".dynsym");
10648 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
10649 sec
= bfd_get_section_by_name (abfd
, ".liblist");
10651 (*hdrpp
)->sh_info
= elf_section_data (sec
)->this_idx
;
10654 case SHT_MIPS_EVENTS
:
10655 BFD_ASSERT ((*hdrpp
)->bfd_section
!= NULL
);
10656 name
= bfd_get_section_name (abfd
, (*hdrpp
)->bfd_section
);
10657 BFD_ASSERT (name
!= NULL
);
10658 if (CONST_STRNEQ (name
, ".MIPS.events"))
10659 sec
= bfd_get_section_by_name (abfd
,
10660 name
+ sizeof ".MIPS.events" - 1);
10663 BFD_ASSERT (CONST_STRNEQ (name
, ".MIPS.post_rel"));
10664 sec
= bfd_get_section_by_name (abfd
,
10666 + sizeof ".MIPS.post_rel" - 1));
10668 BFD_ASSERT (sec
!= NULL
);
10669 (*hdrpp
)->sh_link
= elf_section_data (sec
)->this_idx
;
10676 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
10680 _bfd_mips_elf_additional_program_headers (bfd
*abfd
,
10681 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
10686 /* See if we need a PT_MIPS_REGINFO segment. */
10687 s
= bfd_get_section_by_name (abfd
, ".reginfo");
10688 if (s
&& (s
->flags
& SEC_LOAD
))
10691 /* See if we need a PT_MIPS_OPTIONS segment. */
10692 if (IRIX_COMPAT (abfd
) == ict_irix6
10693 && bfd_get_section_by_name (abfd
,
10694 MIPS_ELF_OPTIONS_SECTION_NAME (abfd
)))
10697 /* See if we need a PT_MIPS_RTPROC segment. */
10698 if (IRIX_COMPAT (abfd
) == ict_irix5
10699 && bfd_get_section_by_name (abfd
, ".dynamic")
10700 && bfd_get_section_by_name (abfd
, ".mdebug"))
10703 /* Allocate a PT_NULL header in dynamic objects. See
10704 _bfd_mips_elf_modify_segment_map for details. */
10705 if (!SGI_COMPAT (abfd
)
10706 && bfd_get_section_by_name (abfd
, ".dynamic"))
10712 /* Modify the segment map for an IRIX5 executable. */
10715 _bfd_mips_elf_modify_segment_map (bfd
*abfd
,
10716 struct bfd_link_info
*info
)
10719 struct elf_segment_map
*m
, **pm
;
10722 /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
10724 s
= bfd_get_section_by_name (abfd
, ".reginfo");
10725 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
10727 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
10728 if (m
->p_type
== PT_MIPS_REGINFO
)
10733 m
= bfd_zalloc (abfd
, amt
);
10737 m
->p_type
= PT_MIPS_REGINFO
;
10739 m
->sections
[0] = s
;
10741 /* We want to put it after the PHDR and INTERP segments. */
10742 pm
= &elf_tdata (abfd
)->segment_map
;
10744 && ((*pm
)->p_type
== PT_PHDR
10745 || (*pm
)->p_type
== PT_INTERP
))
10753 /* For IRIX 6, we don't have .mdebug sections, nor does anything but
10754 .dynamic end up in PT_DYNAMIC. However, we do have to insert a
10755 PT_MIPS_OPTIONS segment immediately following the program header
10757 if (NEWABI_P (abfd
)
10758 /* On non-IRIX6 new abi, we'll have already created a segment
10759 for this section, so don't create another. I'm not sure this
10760 is not also the case for IRIX 6, but I can't test it right
10762 && IRIX_COMPAT (abfd
) == ict_irix6
)
10764 for (s
= abfd
->sections
; s
; s
= s
->next
)
10765 if (elf_section_data (s
)->this_hdr
.sh_type
== SHT_MIPS_OPTIONS
)
10770 struct elf_segment_map
*options_segment
;
10772 pm
= &elf_tdata (abfd
)->segment_map
;
10774 && ((*pm
)->p_type
== PT_PHDR
10775 || (*pm
)->p_type
== PT_INTERP
))
10778 if (*pm
== NULL
|| (*pm
)->p_type
!= PT_MIPS_OPTIONS
)
10780 amt
= sizeof (struct elf_segment_map
);
10781 options_segment
= bfd_zalloc (abfd
, amt
);
10782 options_segment
->next
= *pm
;
10783 options_segment
->p_type
= PT_MIPS_OPTIONS
;
10784 options_segment
->p_flags
= PF_R
;
10785 options_segment
->p_flags_valid
= TRUE
;
10786 options_segment
->count
= 1;
10787 options_segment
->sections
[0] = s
;
10788 *pm
= options_segment
;
10794 if (IRIX_COMPAT (abfd
) == ict_irix5
)
10796 /* If there are .dynamic and .mdebug sections, we make a room
10797 for the RTPROC header. FIXME: Rewrite without section names. */
10798 if (bfd_get_section_by_name (abfd
, ".interp") == NULL
10799 && bfd_get_section_by_name (abfd
, ".dynamic") != NULL
10800 && bfd_get_section_by_name (abfd
, ".mdebug") != NULL
)
10802 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
10803 if (m
->p_type
== PT_MIPS_RTPROC
)
10808 m
= bfd_zalloc (abfd
, amt
);
10812 m
->p_type
= PT_MIPS_RTPROC
;
10814 s
= bfd_get_section_by_name (abfd
, ".rtproc");
10819 m
->p_flags_valid
= 1;
10824 m
->sections
[0] = s
;
10827 /* We want to put it after the DYNAMIC segment. */
10828 pm
= &elf_tdata (abfd
)->segment_map
;
10829 while (*pm
!= NULL
&& (*pm
)->p_type
!= PT_DYNAMIC
)
10839 /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
10840 .dynstr, .dynsym, and .hash sections, and everything in
10842 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
;
10844 if ((*pm
)->p_type
== PT_DYNAMIC
)
10847 if (m
!= NULL
&& IRIX_COMPAT (abfd
) == ict_none
)
10849 /* For a normal mips executable the permissions for the PT_DYNAMIC
10850 segment are read, write and execute. We do that here since
10851 the code in elf.c sets only the read permission. This matters
10852 sometimes for the dynamic linker. */
10853 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
10855 m
->p_flags
= PF_R
| PF_W
| PF_X
;
10856 m
->p_flags_valid
= 1;
10859 /* GNU/Linux binaries do not need the extended PT_DYNAMIC section.
10860 glibc's dynamic linker has traditionally derived the number of
10861 tags from the p_filesz field, and sometimes allocates stack
10862 arrays of that size. An overly-big PT_DYNAMIC segment can
10863 be actively harmful in such cases. Making PT_DYNAMIC contain
10864 other sections can also make life hard for the prelinker,
10865 which might move one of the other sections to a different
10866 PT_LOAD segment. */
10867 if (SGI_COMPAT (abfd
)
10870 && strcmp (m
->sections
[0]->name
, ".dynamic") == 0)
10872 static const char *sec_names
[] =
10874 ".dynamic", ".dynstr", ".dynsym", ".hash"
10878 struct elf_segment_map
*n
;
10880 low
= ~(bfd_vma
) 0;
10882 for (i
= 0; i
< sizeof sec_names
/ sizeof sec_names
[0]; i
++)
10884 s
= bfd_get_section_by_name (abfd
, sec_names
[i
]);
10885 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
10892 if (high
< s
->vma
+ sz
)
10893 high
= s
->vma
+ sz
;
10898 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
10899 if ((s
->flags
& SEC_LOAD
) != 0
10901 && s
->vma
+ s
->size
<= high
)
10904 amt
= sizeof *n
+ (bfd_size_type
) (c
- 1) * sizeof (asection
*);
10905 n
= bfd_zalloc (abfd
, amt
);
10912 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
10914 if ((s
->flags
& SEC_LOAD
) != 0
10916 && s
->vma
+ s
->size
<= high
)
10918 n
->sections
[i
] = s
;
10927 /* Allocate a spare program header in dynamic objects so that tools
10928 like the prelinker can add an extra PT_LOAD entry.
10930 If the prelinker needs to make room for a new PT_LOAD entry, its
10931 standard procedure is to move the first (read-only) sections into
10932 the new (writable) segment. However, the MIPS ABI requires
10933 .dynamic to be in a read-only segment, and the section will often
10934 start within sizeof (ElfNN_Phdr) bytes of the last program header.
10936 Although the prelinker could in principle move .dynamic to a
10937 writable segment, it seems better to allocate a spare program
10938 header instead, and avoid the need to move any sections.
10939 There is a long tradition of allocating spare dynamic tags,
10940 so allocating a spare program header seems like a natural
10943 If INFO is NULL, we may be copying an already prelinked binary
10944 with objcopy or strip, so do not add this header. */
10946 && !SGI_COMPAT (abfd
)
10947 && bfd_get_section_by_name (abfd
, ".dynamic"))
10949 for (pm
= &elf_tdata (abfd
)->segment_map
; *pm
!= NULL
; pm
= &(*pm
)->next
)
10950 if ((*pm
)->p_type
== PT_NULL
)
10954 m
= bfd_zalloc (abfd
, sizeof (*m
));
10958 m
->p_type
= PT_NULL
;
10966 /* Return the section that should be marked against GC for a given
10970 _bfd_mips_elf_gc_mark_hook (asection
*sec
,
10971 struct bfd_link_info
*info
,
10972 Elf_Internal_Rela
*rel
,
10973 struct elf_link_hash_entry
*h
,
10974 Elf_Internal_Sym
*sym
)
10976 /* ??? Do mips16 stub sections need to be handled special? */
10979 switch (ELF_R_TYPE (sec
->owner
, rel
->r_info
))
10981 case R_MIPS_GNU_VTINHERIT
:
10982 case R_MIPS_GNU_VTENTRY
:
10986 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
10989 /* Update the got entry reference counts for the section being removed. */
10992 _bfd_mips_elf_gc_sweep_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
10993 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
10994 asection
*sec ATTRIBUTE_UNUSED
,
10995 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
)
10998 Elf_Internal_Shdr
*symtab_hdr
;
10999 struct elf_link_hash_entry
**sym_hashes
;
11000 bfd_signed_vma
*local_got_refcounts
;
11001 const Elf_Internal_Rela
*rel
, *relend
;
11002 unsigned long r_symndx
;
11003 struct elf_link_hash_entry
*h
;
11005 if (info
->relocatable
)
11008 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11009 sym_hashes
= elf_sym_hashes (abfd
);
11010 local_got_refcounts
= elf_local_got_refcounts (abfd
);
11012 relend
= relocs
+ sec
->reloc_count
;
11013 for (rel
= relocs
; rel
< relend
; rel
++)
11014 switch (ELF_R_TYPE (abfd
, rel
->r_info
))
11016 case R_MIPS16_GOT16
:
11017 case R_MIPS16_CALL16
:
11019 case R_MIPS_CALL16
:
11020 case R_MIPS_CALL_HI16
:
11021 case R_MIPS_CALL_LO16
:
11022 case R_MIPS_GOT_HI16
:
11023 case R_MIPS_GOT_LO16
:
11024 case R_MIPS_GOT_DISP
:
11025 case R_MIPS_GOT_PAGE
:
11026 case R_MIPS_GOT_OFST
:
11027 /* ??? It would seem that the existing MIPS code does no sort
11028 of reference counting or whatnot on its GOT and PLT entries,
11029 so it is not possible to garbage collect them at this time. */
11040 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
11041 hiding the old indirect symbol. Process additional relocation
11042 information. Also called for weakdefs, in which case we just let
11043 _bfd_elf_link_hash_copy_indirect copy the flags for us. */
11046 _bfd_mips_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
11047 struct elf_link_hash_entry
*dir
,
11048 struct elf_link_hash_entry
*ind
)
11050 struct mips_elf_link_hash_entry
*dirmips
, *indmips
;
11052 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
11054 dirmips
= (struct mips_elf_link_hash_entry
*) dir
;
11055 indmips
= (struct mips_elf_link_hash_entry
*) ind
;
11056 /* Any absolute non-dynamic relocations against an indirect or weak
11057 definition will be against the target symbol. */
11058 if (indmips
->has_static_relocs
)
11059 dirmips
->has_static_relocs
= TRUE
;
11061 if (ind
->root
.type
!= bfd_link_hash_indirect
)
11064 dirmips
->possibly_dynamic_relocs
+= indmips
->possibly_dynamic_relocs
;
11065 if (indmips
->readonly_reloc
)
11066 dirmips
->readonly_reloc
= TRUE
;
11067 if (indmips
->no_fn_stub
)
11068 dirmips
->no_fn_stub
= TRUE
;
11069 if (indmips
->fn_stub
)
11071 dirmips
->fn_stub
= indmips
->fn_stub
;
11072 indmips
->fn_stub
= NULL
;
11074 if (indmips
->need_fn_stub
)
11076 dirmips
->need_fn_stub
= TRUE
;
11077 indmips
->need_fn_stub
= FALSE
;
11079 if (indmips
->call_stub
)
11081 dirmips
->call_stub
= indmips
->call_stub
;
11082 indmips
->call_stub
= NULL
;
11084 if (indmips
->call_fp_stub
)
11086 dirmips
->call_fp_stub
= indmips
->call_fp_stub
;
11087 indmips
->call_fp_stub
= NULL
;
11089 if (indmips
->global_got_area
< dirmips
->global_got_area
)
11090 dirmips
->global_got_area
= indmips
->global_got_area
;
11091 if (indmips
->global_got_area
< GGA_NONE
)
11092 indmips
->global_got_area
= GGA_NONE
;
11093 if (indmips
->has_nonpic_branches
)
11094 dirmips
->has_nonpic_branches
= TRUE
;
11096 if (dirmips
->tls_type
== 0)
11097 dirmips
->tls_type
= indmips
->tls_type
;
11100 #define PDR_SIZE 32
11103 _bfd_mips_elf_discard_info (bfd
*abfd
, struct elf_reloc_cookie
*cookie
,
11104 struct bfd_link_info
*info
)
11107 bfd_boolean ret
= FALSE
;
11108 unsigned char *tdata
;
11111 o
= bfd_get_section_by_name (abfd
, ".pdr");
11116 if (o
->size
% PDR_SIZE
!= 0)
11118 if (o
->output_section
!= NULL
11119 && bfd_is_abs_section (o
->output_section
))
11122 tdata
= bfd_zmalloc (o
->size
/ PDR_SIZE
);
11126 cookie
->rels
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
11127 info
->keep_memory
);
11134 cookie
->rel
= cookie
->rels
;
11135 cookie
->relend
= cookie
->rels
+ o
->reloc_count
;
11137 for (i
= 0, skip
= 0; i
< o
->size
/ PDR_SIZE
; i
++)
11139 if (bfd_elf_reloc_symbol_deleted_p (i
* PDR_SIZE
, cookie
))
11148 mips_elf_section_data (o
)->u
.tdata
= tdata
;
11149 o
->size
-= skip
* PDR_SIZE
;
11155 if (! info
->keep_memory
)
11156 free (cookie
->rels
);
11162 _bfd_mips_elf_ignore_discarded_relocs (asection
*sec
)
11164 if (strcmp (sec
->name
, ".pdr") == 0)
11170 _bfd_mips_elf_write_section (bfd
*output_bfd
,
11171 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
11172 asection
*sec
, bfd_byte
*contents
)
11174 bfd_byte
*to
, *from
, *end
;
11177 if (strcmp (sec
->name
, ".pdr") != 0)
11180 if (mips_elf_section_data (sec
)->u
.tdata
== NULL
)
11184 end
= contents
+ sec
->size
;
11185 for (from
= contents
, i
= 0;
11187 from
+= PDR_SIZE
, i
++)
11189 if ((mips_elf_section_data (sec
)->u
.tdata
)[i
] == 1)
11192 memcpy (to
, from
, PDR_SIZE
);
11195 bfd_set_section_contents (output_bfd
, sec
->output_section
, contents
,
11196 sec
->output_offset
, sec
->size
);
11200 /* MIPS ELF uses a special find_nearest_line routine in order the
11201 handle the ECOFF debugging information. */
11203 struct mips_elf_find_line
11205 struct ecoff_debug_info d
;
11206 struct ecoff_find_line i
;
11210 _bfd_mips_elf_find_nearest_line (bfd
*abfd
, asection
*section
,
11211 asymbol
**symbols
, bfd_vma offset
,
11212 const char **filename_ptr
,
11213 const char **functionname_ptr
,
11214 unsigned int *line_ptr
)
11218 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
11219 filename_ptr
, functionname_ptr
,
11223 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
11224 filename_ptr
, functionname_ptr
,
11225 line_ptr
, ABI_64_P (abfd
) ? 8 : 0,
11226 &elf_tdata (abfd
)->dwarf2_find_line_info
))
11229 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
11232 flagword origflags
;
11233 struct mips_elf_find_line
*fi
;
11234 const struct ecoff_debug_swap
* const swap
=
11235 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
11237 /* If we are called during a link, mips_elf_final_link may have
11238 cleared the SEC_HAS_CONTENTS field. We force it back on here
11239 if appropriate (which it normally will be). */
11240 origflags
= msec
->flags
;
11241 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
11242 msec
->flags
|= SEC_HAS_CONTENTS
;
11244 fi
= elf_tdata (abfd
)->find_line_info
;
11247 bfd_size_type external_fdr_size
;
11250 struct fdr
*fdr_ptr
;
11251 bfd_size_type amt
= sizeof (struct mips_elf_find_line
);
11253 fi
= bfd_zalloc (abfd
, amt
);
11256 msec
->flags
= origflags
;
11260 if (! _bfd_mips_elf_read_ecoff_info (abfd
, msec
, &fi
->d
))
11262 msec
->flags
= origflags
;
11266 /* Swap in the FDR information. */
11267 amt
= fi
->d
.symbolic_header
.ifdMax
* sizeof (struct fdr
);
11268 fi
->d
.fdr
= bfd_alloc (abfd
, amt
);
11269 if (fi
->d
.fdr
== NULL
)
11271 msec
->flags
= origflags
;
11274 external_fdr_size
= swap
->external_fdr_size
;
11275 fdr_ptr
= fi
->d
.fdr
;
11276 fraw_src
= (char *) fi
->d
.external_fdr
;
11277 fraw_end
= (fraw_src
11278 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
11279 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
11280 (*swap
->swap_fdr_in
) (abfd
, fraw_src
, fdr_ptr
);
11282 elf_tdata (abfd
)->find_line_info
= fi
;
11284 /* Note that we don't bother to ever free this information.
11285 find_nearest_line is either called all the time, as in
11286 objdump -l, so the information should be saved, or it is
11287 rarely called, as in ld error messages, so the memory
11288 wasted is unimportant. Still, it would probably be a
11289 good idea for free_cached_info to throw it away. */
11292 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
11293 &fi
->i
, filename_ptr
, functionname_ptr
,
11296 msec
->flags
= origflags
;
11300 msec
->flags
= origflags
;
11303 /* Fall back on the generic ELF find_nearest_line routine. */
11305 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
11306 filename_ptr
, functionname_ptr
,
11311 _bfd_mips_elf_find_inliner_info (bfd
*abfd
,
11312 const char **filename_ptr
,
11313 const char **functionname_ptr
,
11314 unsigned int *line_ptr
)
11317 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
11318 functionname_ptr
, line_ptr
,
11319 & elf_tdata (abfd
)->dwarf2_find_line_info
);
11324 /* When are writing out the .options or .MIPS.options section,
11325 remember the bytes we are writing out, so that we can install the
11326 GP value in the section_processing routine. */
11329 _bfd_mips_elf_set_section_contents (bfd
*abfd
, sec_ptr section
,
11330 const void *location
,
11331 file_ptr offset
, bfd_size_type count
)
11333 if (MIPS_ELF_OPTIONS_SECTION_NAME_P (section
->name
))
11337 if (elf_section_data (section
) == NULL
)
11339 bfd_size_type amt
= sizeof (struct bfd_elf_section_data
);
11340 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
11341 if (elf_section_data (section
) == NULL
)
11344 c
= mips_elf_section_data (section
)->u
.tdata
;
11347 c
= bfd_zalloc (abfd
, section
->size
);
11350 mips_elf_section_data (section
)->u
.tdata
= c
;
11353 memcpy (c
+ offset
, location
, count
);
11356 return _bfd_elf_set_section_contents (abfd
, section
, location
, offset
,
11360 /* This is almost identical to bfd_generic_get_... except that some
11361 MIPS relocations need to be handled specially. Sigh. */
11364 _bfd_elf_mips_get_relocated_section_contents
11366 struct bfd_link_info
*link_info
,
11367 struct bfd_link_order
*link_order
,
11369 bfd_boolean relocatable
,
11372 /* Get enough memory to hold the stuff */
11373 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
11374 asection
*input_section
= link_order
->u
.indirect
.section
;
11377 long reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
11378 arelent
**reloc_vector
= NULL
;
11381 if (reloc_size
< 0)
11384 reloc_vector
= bfd_malloc (reloc_size
);
11385 if (reloc_vector
== NULL
&& reloc_size
!= 0)
11388 /* read in the section */
11389 sz
= input_section
->rawsize
? input_section
->rawsize
: input_section
->size
;
11390 if (!bfd_get_section_contents (input_bfd
, input_section
, data
, 0, sz
))
11393 reloc_count
= bfd_canonicalize_reloc (input_bfd
,
11397 if (reloc_count
< 0)
11400 if (reloc_count
> 0)
11405 bfd_vma gp
= 0x12345678; /* initialize just to shut gcc up */
11408 struct bfd_hash_entry
*h
;
11409 struct bfd_link_hash_entry
*lh
;
11410 /* Skip all this stuff if we aren't mixing formats. */
11411 if (abfd
&& input_bfd
11412 && abfd
->xvec
== input_bfd
->xvec
)
11416 h
= bfd_hash_lookup (&link_info
->hash
->table
, "_gp", FALSE
, FALSE
);
11417 lh
= (struct bfd_link_hash_entry
*) h
;
11424 case bfd_link_hash_undefined
:
11425 case bfd_link_hash_undefweak
:
11426 case bfd_link_hash_common
:
11429 case bfd_link_hash_defined
:
11430 case bfd_link_hash_defweak
:
11432 gp
= lh
->u
.def
.value
;
11434 case bfd_link_hash_indirect
:
11435 case bfd_link_hash_warning
:
11437 /* @@FIXME ignoring warning for now */
11439 case bfd_link_hash_new
:
11448 for (parent
= reloc_vector
; *parent
!= NULL
; parent
++)
11450 char *error_message
= NULL
;
11451 bfd_reloc_status_type r
;
11453 /* Specific to MIPS: Deal with relocation types that require
11454 knowing the gp of the output bfd. */
11455 asymbol
*sym
= *(*parent
)->sym_ptr_ptr
;
11457 /* If we've managed to find the gp and have a special
11458 function for the relocation then go ahead, else default
11459 to the generic handling. */
11461 && (*parent
)->howto
->special_function
11462 == _bfd_mips_elf32_gprel16_reloc
)
11463 r
= _bfd_mips_elf_gprel16_with_gp (input_bfd
, sym
, *parent
,
11464 input_section
, relocatable
,
11467 r
= bfd_perform_relocation (input_bfd
, *parent
, data
,
11469 relocatable
? abfd
: NULL
,
11474 asection
*os
= input_section
->output_section
;
11476 /* A partial link, so keep the relocs */
11477 os
->orelocation
[os
->reloc_count
] = *parent
;
11481 if (r
!= bfd_reloc_ok
)
11485 case bfd_reloc_undefined
:
11486 if (!((*link_info
->callbacks
->undefined_symbol
)
11487 (link_info
, bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
11488 input_bfd
, input_section
, (*parent
)->address
, TRUE
)))
11491 case bfd_reloc_dangerous
:
11492 BFD_ASSERT (error_message
!= NULL
);
11493 if (!((*link_info
->callbacks
->reloc_dangerous
)
11494 (link_info
, error_message
, input_bfd
, input_section
,
11495 (*parent
)->address
)))
11498 case bfd_reloc_overflow
:
11499 if (!((*link_info
->callbacks
->reloc_overflow
)
11501 bfd_asymbol_name (*(*parent
)->sym_ptr_ptr
),
11502 (*parent
)->howto
->name
, (*parent
)->addend
,
11503 input_bfd
, input_section
, (*parent
)->address
)))
11506 case bfd_reloc_outofrange
:
11515 if (reloc_vector
!= NULL
)
11516 free (reloc_vector
);
11520 if (reloc_vector
!= NULL
)
11521 free (reloc_vector
);
11525 /* Allocate ABFD's target-dependent data. */
11528 _bfd_mips_elf_mkobject (bfd
*abfd
)
11530 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_obj_tdata
),
11534 /* Create a MIPS ELF linker hash table. */
11536 struct bfd_link_hash_table
*
11537 _bfd_mips_elf_link_hash_table_create (bfd
*abfd
)
11539 struct mips_elf_link_hash_table
*ret
;
11540 bfd_size_type amt
= sizeof (struct mips_elf_link_hash_table
);
11542 ret
= bfd_malloc (amt
);
11546 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
11547 mips_elf_link_hash_newfunc
,
11548 sizeof (struct mips_elf_link_hash_entry
),
11556 /* We no longer use this. */
11557 for (i
= 0; i
< SIZEOF_MIPS_DYNSYM_SECNAMES
; i
++)
11558 ret
->dynsym_sec_strindex
[i
] = (bfd_size_type
) -1;
11560 ret
->procedure_count
= 0;
11561 ret
->compact_rel_size
= 0;
11562 ret
->use_rld_obj_head
= FALSE
;
11563 ret
->rld_value
= 0;
11564 ret
->mips16_stubs_seen
= FALSE
;
11565 ret
->use_plts_and_copy_relocs
= FALSE
;
11566 ret
->is_vxworks
= FALSE
;
11567 ret
->small_data_overflow_reported
= FALSE
;
11568 ret
->srelbss
= NULL
;
11569 ret
->sdynbss
= NULL
;
11570 ret
->srelplt
= NULL
;
11571 ret
->srelplt2
= NULL
;
11572 ret
->sgotplt
= NULL
;
11574 ret
->sstubs
= NULL
;
11576 ret
->got_info
= NULL
;
11577 ret
->plt_header_size
= 0;
11578 ret
->plt_entry_size
= 0;
11579 ret
->lazy_stub_count
= 0;
11580 ret
->function_stub_size
= 0;
11581 ret
->strampoline
= NULL
;
11582 ret
->la25_stubs
= NULL
;
11583 ret
->add_stub_section
= NULL
;
11585 return &ret
->root
.root
;
11588 /* Likewise, but indicate that the target is VxWorks. */
11590 struct bfd_link_hash_table
*
11591 _bfd_mips_vxworks_link_hash_table_create (bfd
*abfd
)
11593 struct bfd_link_hash_table
*ret
;
11595 ret
= _bfd_mips_elf_link_hash_table_create (abfd
);
11598 struct mips_elf_link_hash_table
*htab
;
11600 htab
= (struct mips_elf_link_hash_table
*) ret
;
11601 htab
->use_plts_and_copy_relocs
= TRUE
;
11602 htab
->is_vxworks
= TRUE
;
11607 /* A function that the linker calls if we are allowed to use PLTs
11608 and copy relocs. */
11611 _bfd_mips_elf_use_plts_and_copy_relocs (struct bfd_link_info
*info
)
11613 mips_elf_hash_table (info
)->use_plts_and_copy_relocs
= TRUE
;
11616 /* We need to use a special link routine to handle the .reginfo and
11617 the .mdebug sections. We need to merge all instances of these
11618 sections together, not write them all out sequentially. */
11621 _bfd_mips_elf_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
11624 struct bfd_link_order
*p
;
11625 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
11626 asection
*rtproc_sec
;
11627 Elf32_RegInfo reginfo
;
11628 struct ecoff_debug_info debug
;
11629 struct mips_htab_traverse_info hti
;
11630 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11631 const struct ecoff_debug_swap
*swap
= bed
->elf_backend_ecoff_debug_swap
;
11632 HDRR
*symhdr
= &debug
.symbolic_header
;
11633 void *mdebug_handle
= NULL
;
11638 struct mips_elf_link_hash_table
*htab
;
11640 static const char * const secname
[] =
11642 ".text", ".init", ".fini", ".data",
11643 ".rodata", ".sdata", ".sbss", ".bss"
11645 static const int sc
[] =
11647 scText
, scInit
, scFini
, scData
,
11648 scRData
, scSData
, scSBss
, scBss
11651 /* Sort the dynamic symbols so that those with GOT entries come after
11653 htab
= mips_elf_hash_table (info
);
11654 BFD_ASSERT (htab
!= NULL
);
11656 if (!mips_elf_sort_hash_table (abfd
, info
))
11659 /* Create any scheduled LA25 stubs. */
11661 hti
.output_bfd
= abfd
;
11663 htab_traverse (htab
->la25_stubs
, mips_elf_create_la25_stub
, &hti
);
11667 /* Get a value for the GP register. */
11668 if (elf_gp (abfd
) == 0)
11670 struct bfd_link_hash_entry
*h
;
11672 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
11673 if (h
!= NULL
&& h
->type
== bfd_link_hash_defined
)
11674 elf_gp (abfd
) = (h
->u
.def
.value
11675 + h
->u
.def
.section
->output_section
->vma
11676 + h
->u
.def
.section
->output_offset
);
11677 else if (htab
->is_vxworks
11678 && (h
= bfd_link_hash_lookup (info
->hash
,
11679 "_GLOBAL_OFFSET_TABLE_",
11680 FALSE
, FALSE
, TRUE
))
11681 && h
->type
== bfd_link_hash_defined
)
11682 elf_gp (abfd
) = (h
->u
.def
.section
->output_section
->vma
11683 + h
->u
.def
.section
->output_offset
11685 else if (info
->relocatable
)
11687 bfd_vma lo
= MINUS_ONE
;
11689 /* Find the GP-relative section with the lowest offset. */
11690 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
11692 && (elf_section_data (o
)->this_hdr
.sh_flags
& SHF_MIPS_GPREL
))
11695 /* And calculate GP relative to that. */
11696 elf_gp (abfd
) = lo
+ ELF_MIPS_GP_OFFSET (info
);
11700 /* If the relocate_section function needs to do a reloc
11701 involving the GP value, it should make a reloc_dangerous
11702 callback to warn that GP is not defined. */
11706 /* Go through the sections and collect the .reginfo and .mdebug
11708 reginfo_sec
= NULL
;
11710 gptab_data_sec
= NULL
;
11711 gptab_bss_sec
= NULL
;
11712 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
11714 if (strcmp (o
->name
, ".reginfo") == 0)
11716 memset (®info
, 0, sizeof reginfo
);
11718 /* We have found the .reginfo section in the output file.
11719 Look through all the link_orders comprising it and merge
11720 the information together. */
11721 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
11723 asection
*input_section
;
11725 Elf32_External_RegInfo ext
;
11728 if (p
->type
!= bfd_indirect_link_order
)
11730 if (p
->type
== bfd_data_link_order
)
11735 input_section
= p
->u
.indirect
.section
;
11736 input_bfd
= input_section
->owner
;
11738 if (! bfd_get_section_contents (input_bfd
, input_section
,
11739 &ext
, 0, sizeof ext
))
11742 bfd_mips_elf32_swap_reginfo_in (input_bfd
, &ext
, &sub
);
11744 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
11745 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
11746 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
11747 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
11748 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
11750 /* ri_gp_value is set by the function
11751 mips_elf32_section_processing when the section is
11752 finally written out. */
11754 /* Hack: reset the SEC_HAS_CONTENTS flag so that
11755 elf_link_input_bfd ignores this section. */
11756 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
11759 /* Size has been set in _bfd_mips_elf_always_size_sections. */
11760 BFD_ASSERT(o
->size
== sizeof (Elf32_External_RegInfo
));
11762 /* Skip this section later on (I don't think this currently
11763 matters, but someday it might). */
11764 o
->map_head
.link_order
= NULL
;
11769 if (strcmp (o
->name
, ".mdebug") == 0)
11771 struct extsym_info einfo
;
11774 /* We have found the .mdebug section in the output file.
11775 Look through all the link_orders comprising it and merge
11776 the information together. */
11777 symhdr
->magic
= swap
->sym_magic
;
11778 /* FIXME: What should the version stamp be? */
11779 symhdr
->vstamp
= 0;
11780 symhdr
->ilineMax
= 0;
11781 symhdr
->cbLine
= 0;
11782 symhdr
->idnMax
= 0;
11783 symhdr
->ipdMax
= 0;
11784 symhdr
->isymMax
= 0;
11785 symhdr
->ioptMax
= 0;
11786 symhdr
->iauxMax
= 0;
11787 symhdr
->issMax
= 0;
11788 symhdr
->issExtMax
= 0;
11789 symhdr
->ifdMax
= 0;
11791 symhdr
->iextMax
= 0;
11793 /* We accumulate the debugging information itself in the
11794 debug_info structure. */
11796 debug
.external_dnr
= NULL
;
11797 debug
.external_pdr
= NULL
;
11798 debug
.external_sym
= NULL
;
11799 debug
.external_opt
= NULL
;
11800 debug
.external_aux
= NULL
;
11802 debug
.ssext
= debug
.ssext_end
= NULL
;
11803 debug
.external_fdr
= NULL
;
11804 debug
.external_rfd
= NULL
;
11805 debug
.external_ext
= debug
.external_ext_end
= NULL
;
11807 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
11808 if (mdebug_handle
== NULL
)
11812 esym
.cobol_main
= 0;
11816 esym
.asym
.iss
= issNil
;
11817 esym
.asym
.st
= stLocal
;
11818 esym
.asym
.reserved
= 0;
11819 esym
.asym
.index
= indexNil
;
11821 for (i
= 0; i
< sizeof (secname
) / sizeof (secname
[0]); i
++)
11823 esym
.asym
.sc
= sc
[i
];
11824 s
= bfd_get_section_by_name (abfd
, secname
[i
]);
11827 esym
.asym
.value
= s
->vma
;
11828 last
= s
->vma
+ s
->size
;
11831 esym
.asym
.value
= last
;
11832 if (!bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
11833 secname
[i
], &esym
))
11837 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
11839 asection
*input_section
;
11841 const struct ecoff_debug_swap
*input_swap
;
11842 struct ecoff_debug_info input_debug
;
11846 if (p
->type
!= bfd_indirect_link_order
)
11848 if (p
->type
== bfd_data_link_order
)
11853 input_section
= p
->u
.indirect
.section
;
11854 input_bfd
= input_section
->owner
;
11856 if (!is_mips_elf (input_bfd
))
11858 /* I don't know what a non MIPS ELF bfd would be
11859 doing with a .mdebug section, but I don't really
11860 want to deal with it. */
11864 input_swap
= (get_elf_backend_data (input_bfd
)
11865 ->elf_backend_ecoff_debug_swap
);
11867 BFD_ASSERT (p
->size
== input_section
->size
);
11869 /* The ECOFF linking code expects that we have already
11870 read in the debugging information and set up an
11871 ecoff_debug_info structure, so we do that now. */
11872 if (! _bfd_mips_elf_read_ecoff_info (input_bfd
, input_section
,
11876 if (! (bfd_ecoff_debug_accumulate
11877 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
11878 &input_debug
, input_swap
, info
)))
11881 /* Loop through the external symbols. For each one with
11882 interesting information, try to find the symbol in
11883 the linker global hash table and save the information
11884 for the output external symbols. */
11885 eraw_src
= input_debug
.external_ext
;
11886 eraw_end
= (eraw_src
11887 + (input_debug
.symbolic_header
.iextMax
11888 * input_swap
->external_ext_size
));
11890 eraw_src
< eraw_end
;
11891 eraw_src
+= input_swap
->external_ext_size
)
11895 struct mips_elf_link_hash_entry
*h
;
11897 (*input_swap
->swap_ext_in
) (input_bfd
, eraw_src
, &ext
);
11898 if (ext
.asym
.sc
== scNil
11899 || ext
.asym
.sc
== scUndefined
11900 || ext
.asym
.sc
== scSUndefined
)
11903 name
= input_debug
.ssext
+ ext
.asym
.iss
;
11904 h
= mips_elf_link_hash_lookup (mips_elf_hash_table (info
),
11905 name
, FALSE
, FALSE
, TRUE
);
11906 if (h
== NULL
|| h
->esym
.ifd
!= -2)
11911 BFD_ASSERT (ext
.ifd
11912 < input_debug
.symbolic_header
.ifdMax
);
11913 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
11919 /* Free up the information we just read. */
11920 free (input_debug
.line
);
11921 free (input_debug
.external_dnr
);
11922 free (input_debug
.external_pdr
);
11923 free (input_debug
.external_sym
);
11924 free (input_debug
.external_opt
);
11925 free (input_debug
.external_aux
);
11926 free (input_debug
.ss
);
11927 free (input_debug
.ssext
);
11928 free (input_debug
.external_fdr
);
11929 free (input_debug
.external_rfd
);
11930 free (input_debug
.external_ext
);
11932 /* Hack: reset the SEC_HAS_CONTENTS flag so that
11933 elf_link_input_bfd ignores this section. */
11934 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
11937 if (SGI_COMPAT (abfd
) && info
->shared
)
11939 /* Create .rtproc section. */
11940 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
11941 if (rtproc_sec
== NULL
)
11943 flagword flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
11944 | SEC_LINKER_CREATED
| SEC_READONLY
);
11946 rtproc_sec
= bfd_make_section_with_flags (abfd
,
11949 if (rtproc_sec
== NULL
11950 || ! bfd_set_section_alignment (abfd
, rtproc_sec
, 4))
11954 if (! mips_elf_create_procedure_table (mdebug_handle
, abfd
,
11960 /* Build the external symbol information. */
11963 einfo
.debug
= &debug
;
11965 einfo
.failed
= FALSE
;
11966 mips_elf_link_hash_traverse (mips_elf_hash_table (info
),
11967 mips_elf_output_extsym
, &einfo
);
11971 /* Set the size of the .mdebug section. */
11972 o
->size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
11974 /* Skip this section later on (I don't think this currently
11975 matters, but someday it might). */
11976 o
->map_head
.link_order
= NULL
;
11981 if (CONST_STRNEQ (o
->name
, ".gptab."))
11983 const char *subname
;
11986 Elf32_External_gptab
*ext_tab
;
11989 /* The .gptab.sdata and .gptab.sbss sections hold
11990 information describing how the small data area would
11991 change depending upon the -G switch. These sections
11992 not used in executables files. */
11993 if (! info
->relocatable
)
11995 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
11997 asection
*input_section
;
11999 if (p
->type
!= bfd_indirect_link_order
)
12001 if (p
->type
== bfd_data_link_order
)
12006 input_section
= p
->u
.indirect
.section
;
12008 /* Hack: reset the SEC_HAS_CONTENTS flag so that
12009 elf_link_input_bfd ignores this section. */
12010 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
12013 /* Skip this section later on (I don't think this
12014 currently matters, but someday it might). */
12015 o
->map_head
.link_order
= NULL
;
12017 /* Really remove the section. */
12018 bfd_section_list_remove (abfd
, o
);
12019 --abfd
->section_count
;
12024 /* There is one gptab for initialized data, and one for
12025 uninitialized data. */
12026 if (strcmp (o
->name
, ".gptab.sdata") == 0)
12027 gptab_data_sec
= o
;
12028 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
12032 (*_bfd_error_handler
)
12033 (_("%s: illegal section name `%s'"),
12034 bfd_get_filename (abfd
), o
->name
);
12035 bfd_set_error (bfd_error_nonrepresentable_section
);
12039 /* The linker script always combines .gptab.data and
12040 .gptab.sdata into .gptab.sdata, and likewise for
12041 .gptab.bss and .gptab.sbss. It is possible that there is
12042 no .sdata or .sbss section in the output file, in which
12043 case we must change the name of the output section. */
12044 subname
= o
->name
+ sizeof ".gptab" - 1;
12045 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
12047 if (o
== gptab_data_sec
)
12048 o
->name
= ".gptab.data";
12050 o
->name
= ".gptab.bss";
12051 subname
= o
->name
+ sizeof ".gptab" - 1;
12052 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
12055 /* Set up the first entry. */
12057 amt
= c
* sizeof (Elf32_gptab
);
12058 tab
= bfd_malloc (amt
);
12061 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
12062 tab
[0].gt_header
.gt_unused
= 0;
12064 /* Combine the input sections. */
12065 for (p
= o
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
12067 asection
*input_section
;
12069 bfd_size_type size
;
12070 unsigned long last
;
12071 bfd_size_type gpentry
;
12073 if (p
->type
!= bfd_indirect_link_order
)
12075 if (p
->type
== bfd_data_link_order
)
12080 input_section
= p
->u
.indirect
.section
;
12081 input_bfd
= input_section
->owner
;
12083 /* Combine the gptab entries for this input section one
12084 by one. We know that the input gptab entries are
12085 sorted by ascending -G value. */
12086 size
= input_section
->size
;
12088 for (gpentry
= sizeof (Elf32_External_gptab
);
12090 gpentry
+= sizeof (Elf32_External_gptab
))
12092 Elf32_External_gptab ext_gptab
;
12093 Elf32_gptab int_gptab
;
12099 if (! (bfd_get_section_contents
12100 (input_bfd
, input_section
, &ext_gptab
, gpentry
,
12101 sizeof (Elf32_External_gptab
))))
12107 bfd_mips_elf32_swap_gptab_in (input_bfd
, &ext_gptab
,
12109 val
= int_gptab
.gt_entry
.gt_g_value
;
12110 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
12113 for (look
= 1; look
< c
; look
++)
12115 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
12116 tab
[look
].gt_entry
.gt_bytes
+= add
;
12118 if (tab
[look
].gt_entry
.gt_g_value
== val
)
12124 Elf32_gptab
*new_tab
;
12127 /* We need a new table entry. */
12128 amt
= (bfd_size_type
) (c
+ 1) * sizeof (Elf32_gptab
);
12129 new_tab
= bfd_realloc (tab
, amt
);
12130 if (new_tab
== NULL
)
12136 tab
[c
].gt_entry
.gt_g_value
= val
;
12137 tab
[c
].gt_entry
.gt_bytes
= add
;
12139 /* Merge in the size for the next smallest -G
12140 value, since that will be implied by this new
12143 for (look
= 1; look
< c
; look
++)
12145 if (tab
[look
].gt_entry
.gt_g_value
< val
12147 || (tab
[look
].gt_entry
.gt_g_value
12148 > tab
[max
].gt_entry
.gt_g_value
)))
12152 tab
[c
].gt_entry
.gt_bytes
+=
12153 tab
[max
].gt_entry
.gt_bytes
;
12158 last
= int_gptab
.gt_entry
.gt_bytes
;
12161 /* Hack: reset the SEC_HAS_CONTENTS flag so that
12162 elf_link_input_bfd ignores this section. */
12163 input_section
->flags
&= ~SEC_HAS_CONTENTS
;
12166 /* The table must be sorted by -G value. */
12168 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
12170 /* Swap out the table. */
12171 amt
= (bfd_size_type
) c
* sizeof (Elf32_External_gptab
);
12172 ext_tab
= bfd_alloc (abfd
, amt
);
12173 if (ext_tab
== NULL
)
12179 for (j
= 0; j
< c
; j
++)
12180 bfd_mips_elf32_swap_gptab_out (abfd
, tab
+ j
, ext_tab
+ j
);
12183 o
->size
= c
* sizeof (Elf32_External_gptab
);
12184 o
->contents
= (bfd_byte
*) ext_tab
;
12186 /* Skip this section later on (I don't think this currently
12187 matters, but someday it might). */
12188 o
->map_head
.link_order
= NULL
;
12192 /* Invoke the regular ELF backend linker to do all the work. */
12193 if (!bfd_elf_final_link (abfd
, info
))
12196 /* Now write out the computed sections. */
12198 if (reginfo_sec
!= NULL
)
12200 Elf32_External_RegInfo ext
;
12202 bfd_mips_elf32_swap_reginfo_out (abfd
, ®info
, &ext
);
12203 if (! bfd_set_section_contents (abfd
, reginfo_sec
, &ext
, 0, sizeof ext
))
12207 if (mdebug_sec
!= NULL
)
12209 BFD_ASSERT (abfd
->output_has_begun
);
12210 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
12212 mdebug_sec
->filepos
))
12215 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
12218 if (gptab_data_sec
!= NULL
)
12220 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
12221 gptab_data_sec
->contents
,
12222 0, gptab_data_sec
->size
))
12226 if (gptab_bss_sec
!= NULL
)
12228 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
12229 gptab_bss_sec
->contents
,
12230 0, gptab_bss_sec
->size
))
12234 if (SGI_COMPAT (abfd
))
12236 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
12237 if (rtproc_sec
!= NULL
)
12239 if (! bfd_set_section_contents (abfd
, rtproc_sec
,
12240 rtproc_sec
->contents
,
12241 0, rtproc_sec
->size
))
12249 /* Structure for saying that BFD machine EXTENSION extends BASE. */
12251 struct mips_mach_extension
{
12252 unsigned long extension
, base
;
12256 /* An array describing how BFD machines relate to one another. The entries
12257 are ordered topologically with MIPS I extensions listed last. */
12259 static const struct mips_mach_extension mips_mach_extensions
[] = {
12260 /* MIPS64r2 extensions. */
12261 { bfd_mach_mips_octeon
, bfd_mach_mipsisa64r2
},
12263 /* MIPS64 extensions. */
12264 { bfd_mach_mipsisa64r2
, bfd_mach_mipsisa64
},
12265 { bfd_mach_mips_sb1
, bfd_mach_mipsisa64
},
12266 { bfd_mach_mips_xlr
, bfd_mach_mipsisa64
},
12268 /* MIPS V extensions. */
12269 { bfd_mach_mipsisa64
, bfd_mach_mips5
},
12271 /* R10000 extensions. */
12272 { bfd_mach_mips12000
, bfd_mach_mips10000
},
12273 { bfd_mach_mips14000
, bfd_mach_mips10000
},
12274 { bfd_mach_mips16000
, bfd_mach_mips10000
},
12276 /* R5000 extensions. Note: the vr5500 ISA is an extension of the core
12277 vr5400 ISA, but doesn't include the multimedia stuff. It seems
12278 better to allow vr5400 and vr5500 code to be merged anyway, since
12279 many libraries will just use the core ISA. Perhaps we could add
12280 some sort of ASE flag if this ever proves a problem. */
12281 { bfd_mach_mips5500
, bfd_mach_mips5400
},
12282 { bfd_mach_mips5400
, bfd_mach_mips5000
},
12284 /* MIPS IV extensions. */
12285 { bfd_mach_mips5
, bfd_mach_mips8000
},
12286 { bfd_mach_mips10000
, bfd_mach_mips8000
},
12287 { bfd_mach_mips5000
, bfd_mach_mips8000
},
12288 { bfd_mach_mips7000
, bfd_mach_mips8000
},
12289 { bfd_mach_mips9000
, bfd_mach_mips8000
},
12291 /* VR4100 extensions. */
12292 { bfd_mach_mips4120
, bfd_mach_mips4100
},
12293 { bfd_mach_mips4111
, bfd_mach_mips4100
},
12295 /* MIPS III extensions. */
12296 { bfd_mach_mips_loongson_2e
, bfd_mach_mips4000
},
12297 { bfd_mach_mips_loongson_2f
, bfd_mach_mips4000
},
12298 { bfd_mach_mips8000
, bfd_mach_mips4000
},
12299 { bfd_mach_mips4650
, bfd_mach_mips4000
},
12300 { bfd_mach_mips4600
, bfd_mach_mips4000
},
12301 { bfd_mach_mips4400
, bfd_mach_mips4000
},
12302 { bfd_mach_mips4300
, bfd_mach_mips4000
},
12303 { bfd_mach_mips4100
, bfd_mach_mips4000
},
12304 { bfd_mach_mips4010
, bfd_mach_mips4000
},
12306 /* MIPS32 extensions. */
12307 { bfd_mach_mipsisa32r2
, bfd_mach_mipsisa32
},
12309 /* MIPS II extensions. */
12310 { bfd_mach_mips4000
, bfd_mach_mips6000
},
12311 { bfd_mach_mipsisa32
, bfd_mach_mips6000
},
12313 /* MIPS I extensions. */
12314 { bfd_mach_mips6000
, bfd_mach_mips3000
},
12315 { bfd_mach_mips3900
, bfd_mach_mips3000
}
12319 /* Return true if bfd machine EXTENSION is an extension of machine BASE. */
12322 mips_mach_extends_p (unsigned long base
, unsigned long extension
)
12326 if (extension
== base
)
12329 if (base
== bfd_mach_mipsisa32
12330 && mips_mach_extends_p (bfd_mach_mipsisa64
, extension
))
12333 if (base
== bfd_mach_mipsisa32r2
12334 && mips_mach_extends_p (bfd_mach_mipsisa64r2
, extension
))
12337 for (i
= 0; i
< ARRAY_SIZE (mips_mach_extensions
); i
++)
12338 if (extension
== mips_mach_extensions
[i
].extension
)
12340 extension
= mips_mach_extensions
[i
].base
;
12341 if (extension
== base
)
12349 /* Return true if the given ELF header flags describe a 32-bit binary. */
12352 mips_32bit_flags_p (flagword flags
)
12354 return ((flags
& EF_MIPS_32BITMODE
) != 0
12355 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
12356 || (flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
12357 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
12358 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
12359 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
12360 || (flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
);
12364 /* Merge object attributes from IBFD into OBFD. Raise an error if
12365 there are conflicting attributes. */
12367 mips_elf_merge_obj_attributes (bfd
*ibfd
, bfd
*obfd
)
12369 obj_attribute
*in_attr
;
12370 obj_attribute
*out_attr
;
12372 if (!elf_known_obj_attributes_proc (obfd
)[0].i
)
12374 /* This is the first object. Copy the attributes. */
12375 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
12377 /* Use the Tag_null value to indicate the attributes have been
12379 elf_known_obj_attributes_proc (obfd
)[0].i
= 1;
12384 /* Check for conflicting Tag_GNU_MIPS_ABI_FP attributes and merge
12385 non-conflicting ones. */
12386 in_attr
= elf_known_obj_attributes (ibfd
)[OBJ_ATTR_GNU
];
12387 out_attr
= elf_known_obj_attributes (obfd
)[OBJ_ATTR_GNU
];
12388 if (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
!= out_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
12390 out_attr
[Tag_GNU_MIPS_ABI_FP
].type
= 1;
12391 if (out_attr
[Tag_GNU_MIPS_ABI_FP
].i
== 0)
12392 out_attr
[Tag_GNU_MIPS_ABI_FP
].i
= in_attr
[Tag_GNU_MIPS_ABI_FP
].i
;
12393 else if (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
== 0)
12395 else if (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
> 4)
12397 (_("Warning: %B uses unknown floating point ABI %d"), ibfd
,
12398 in_attr
[Tag_GNU_MIPS_ABI_FP
].i
);
12399 else if (out_attr
[Tag_GNU_MIPS_ABI_FP
].i
> 4)
12401 (_("Warning: %B uses unknown floating point ABI %d"), obfd
,
12402 out_attr
[Tag_GNU_MIPS_ABI_FP
].i
);
12404 switch (out_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
12407 switch (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
12411 (_("Warning: %B uses -msingle-float, %B uses -mdouble-float"),
12417 (_("Warning: %B uses hard float, %B uses soft float"),
12423 (_("Warning: %B uses -msingle-float, %B uses -mips32r2 -mfp64"),
12433 switch (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
12437 (_("Warning: %B uses -msingle-float, %B uses -mdouble-float"),
12443 (_("Warning: %B uses hard float, %B uses soft float"),
12449 (_("Warning: %B uses -mdouble-float, %B uses -mips32r2 -mfp64"),
12459 switch (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
12465 (_("Warning: %B uses hard float, %B uses soft float"),
12475 switch (in_attr
[Tag_GNU_MIPS_ABI_FP
].i
)
12479 (_("Warning: %B uses -msingle-float, %B uses -mips32r2 -mfp64"),
12485 (_("Warning: %B uses -mdouble-float, %B uses -mips32r2 -mfp64"),
12491 (_("Warning: %B uses hard float, %B uses soft float"),
12505 /* Merge Tag_compatibility attributes and any common GNU ones. */
12506 _bfd_elf_merge_object_attributes (ibfd
, obfd
);
12511 /* Merge backend specific data from an object file to the output
12512 object file when linking. */
12515 _bfd_mips_elf_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
12517 flagword old_flags
;
12518 flagword new_flags
;
12520 bfd_boolean null_input_bfd
= TRUE
;
12523 /* Check if we have the same endianess */
12524 if (! _bfd_generic_verify_endian_match (ibfd
, obfd
))
12526 (*_bfd_error_handler
)
12527 (_("%B: endianness incompatible with that of the selected emulation"),
12532 if (!is_mips_elf (ibfd
) || !is_mips_elf (obfd
))
12535 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
12537 (*_bfd_error_handler
)
12538 (_("%B: ABI is incompatible with that of the selected emulation"),
12543 if (!mips_elf_merge_obj_attributes (ibfd
, obfd
))
12546 new_flags
= elf_elfheader (ibfd
)->e_flags
;
12547 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_NOREORDER
;
12548 old_flags
= elf_elfheader (obfd
)->e_flags
;
12550 if (! elf_flags_init (obfd
))
12552 elf_flags_init (obfd
) = TRUE
;
12553 elf_elfheader (obfd
)->e_flags
= new_flags
;
12554 elf_elfheader (obfd
)->e_ident
[EI_CLASS
]
12555 = elf_elfheader (ibfd
)->e_ident
[EI_CLASS
];
12557 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
12558 && (bfd_get_arch_info (obfd
)->the_default
12559 || mips_mach_extends_p (bfd_get_mach (obfd
),
12560 bfd_get_mach (ibfd
))))
12562 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
12563 bfd_get_mach (ibfd
)))
12570 /* Check flag compatibility. */
12572 new_flags
&= ~EF_MIPS_NOREORDER
;
12573 old_flags
&= ~EF_MIPS_NOREORDER
;
12575 /* Some IRIX 6 BSD-compatibility objects have this bit set. It
12576 doesn't seem to matter. */
12577 new_flags
&= ~EF_MIPS_XGOT
;
12578 old_flags
&= ~EF_MIPS_XGOT
;
12580 /* MIPSpro generates ucode info in n64 objects. Again, we should
12581 just be able to ignore this. */
12582 new_flags
&= ~EF_MIPS_UCODE
;
12583 old_flags
&= ~EF_MIPS_UCODE
;
12585 /* DSOs should only be linked with CPIC code. */
12586 if ((ibfd
->flags
& DYNAMIC
) != 0)
12587 new_flags
|= EF_MIPS_PIC
| EF_MIPS_CPIC
;
12589 if (new_flags
== old_flags
)
12592 /* Check to see if the input BFD actually contains any sections.
12593 If not, its flags may not have been initialised either, but it cannot
12594 actually cause any incompatibility. */
12595 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
12597 /* Ignore synthetic sections and empty .text, .data and .bss sections
12598 which are automatically generated by gas. */
12599 if (strcmp (sec
->name
, ".reginfo")
12600 && strcmp (sec
->name
, ".mdebug")
12602 || (strcmp (sec
->name
, ".text")
12603 && strcmp (sec
->name
, ".data")
12604 && strcmp (sec
->name
, ".bss"))))
12606 null_input_bfd
= FALSE
;
12610 if (null_input_bfd
)
12615 if (((new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0)
12616 != ((old_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
)) != 0))
12618 (*_bfd_error_handler
)
12619 (_("%B: warning: linking abicalls files with non-abicalls files"),
12624 if (new_flags
& (EF_MIPS_PIC
| EF_MIPS_CPIC
))
12625 elf_elfheader (obfd
)->e_flags
|= EF_MIPS_CPIC
;
12626 if (! (new_flags
& EF_MIPS_PIC
))
12627 elf_elfheader (obfd
)->e_flags
&= ~EF_MIPS_PIC
;
12629 new_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
12630 old_flags
&= ~ (EF_MIPS_PIC
| EF_MIPS_CPIC
);
12632 /* Compare the ISAs. */
12633 if (mips_32bit_flags_p (old_flags
) != mips_32bit_flags_p (new_flags
))
12635 (*_bfd_error_handler
)
12636 (_("%B: linking 32-bit code with 64-bit code"),
12640 else if (!mips_mach_extends_p (bfd_get_mach (ibfd
), bfd_get_mach (obfd
)))
12642 /* OBFD's ISA isn't the same as, or an extension of, IBFD's. */
12643 if (mips_mach_extends_p (bfd_get_mach (obfd
), bfd_get_mach (ibfd
)))
12645 /* Copy the architecture info from IBFD to OBFD. Also copy
12646 the 32-bit flag (if set) so that we continue to recognise
12647 OBFD as a 32-bit binary. */
12648 bfd_set_arch_info (obfd
, bfd_get_arch_info (ibfd
));
12649 elf_elfheader (obfd
)->e_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
);
12650 elf_elfheader (obfd
)->e_flags
12651 |= new_flags
& (EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
12653 /* Copy across the ABI flags if OBFD doesn't use them
12654 and if that was what caused us to treat IBFD as 32-bit. */
12655 if ((old_flags
& EF_MIPS_ABI
) == 0
12656 && mips_32bit_flags_p (new_flags
)
12657 && !mips_32bit_flags_p (new_flags
& ~EF_MIPS_ABI
))
12658 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ABI
;
12662 /* The ISAs aren't compatible. */
12663 (*_bfd_error_handler
)
12664 (_("%B: linking %s module with previous %s modules"),
12666 bfd_printable_name (ibfd
),
12667 bfd_printable_name (obfd
));
12672 new_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
12673 old_flags
&= ~(EF_MIPS_ARCH
| EF_MIPS_MACH
| EF_MIPS_32BITMODE
);
12675 /* Compare ABIs. The 64-bit ABI does not use EF_MIPS_ABI. But, it
12676 does set EI_CLASS differently from any 32-bit ABI. */
12677 if ((new_flags
& EF_MIPS_ABI
) != (old_flags
& EF_MIPS_ABI
)
12678 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
12679 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
12681 /* Only error if both are set (to different values). */
12682 if (((new_flags
& EF_MIPS_ABI
) && (old_flags
& EF_MIPS_ABI
))
12683 || (elf_elfheader (ibfd
)->e_ident
[EI_CLASS
]
12684 != elf_elfheader (obfd
)->e_ident
[EI_CLASS
]))
12686 (*_bfd_error_handler
)
12687 (_("%B: ABI mismatch: linking %s module with previous %s modules"),
12689 elf_mips_abi_name (ibfd
),
12690 elf_mips_abi_name (obfd
));
12693 new_flags
&= ~EF_MIPS_ABI
;
12694 old_flags
&= ~EF_MIPS_ABI
;
12697 /* For now, allow arbitrary mixing of ASEs (retain the union). */
12698 if ((new_flags
& EF_MIPS_ARCH_ASE
) != (old_flags
& EF_MIPS_ARCH_ASE
))
12700 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_MIPS_ARCH_ASE
;
12702 new_flags
&= ~ EF_MIPS_ARCH_ASE
;
12703 old_flags
&= ~ EF_MIPS_ARCH_ASE
;
12706 /* Warn about any other mismatches */
12707 if (new_flags
!= old_flags
)
12709 (*_bfd_error_handler
)
12710 (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
12711 ibfd
, (unsigned long) new_flags
,
12712 (unsigned long) old_flags
);
12718 bfd_set_error (bfd_error_bad_value
);
12725 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC. */
12728 _bfd_mips_elf_set_private_flags (bfd
*abfd
, flagword flags
)
12730 BFD_ASSERT (!elf_flags_init (abfd
)
12731 || elf_elfheader (abfd
)->e_flags
== flags
);
12733 elf_elfheader (abfd
)->e_flags
= flags
;
12734 elf_flags_init (abfd
) = TRUE
;
12739 _bfd_mips_elf_get_target_dtag (bfd_vma dtag
)
12743 default: return "";
12744 case DT_MIPS_RLD_VERSION
:
12745 return "MIPS_RLD_VERSION";
12746 case DT_MIPS_TIME_STAMP
:
12747 return "MIPS_TIME_STAMP";
12748 case DT_MIPS_ICHECKSUM
:
12749 return "MIPS_ICHECKSUM";
12750 case DT_MIPS_IVERSION
:
12751 return "MIPS_IVERSION";
12752 case DT_MIPS_FLAGS
:
12753 return "MIPS_FLAGS";
12754 case DT_MIPS_BASE_ADDRESS
:
12755 return "MIPS_BASE_ADDRESS";
12757 return "MIPS_MSYM";
12758 case DT_MIPS_CONFLICT
:
12759 return "MIPS_CONFLICT";
12760 case DT_MIPS_LIBLIST
:
12761 return "MIPS_LIBLIST";
12762 case DT_MIPS_LOCAL_GOTNO
:
12763 return "MIPS_LOCAL_GOTNO";
12764 case DT_MIPS_CONFLICTNO
:
12765 return "MIPS_CONFLICTNO";
12766 case DT_MIPS_LIBLISTNO
:
12767 return "MIPS_LIBLISTNO";
12768 case DT_MIPS_SYMTABNO
:
12769 return "MIPS_SYMTABNO";
12770 case DT_MIPS_UNREFEXTNO
:
12771 return "MIPS_UNREFEXTNO";
12772 case DT_MIPS_GOTSYM
:
12773 return "MIPS_GOTSYM";
12774 case DT_MIPS_HIPAGENO
:
12775 return "MIPS_HIPAGENO";
12776 case DT_MIPS_RLD_MAP
:
12777 return "MIPS_RLD_MAP";
12778 case DT_MIPS_DELTA_CLASS
:
12779 return "MIPS_DELTA_CLASS";
12780 case DT_MIPS_DELTA_CLASS_NO
:
12781 return "MIPS_DELTA_CLASS_NO";
12782 case DT_MIPS_DELTA_INSTANCE
:
12783 return "MIPS_DELTA_INSTANCE";
12784 case DT_MIPS_DELTA_INSTANCE_NO
:
12785 return "MIPS_DELTA_INSTANCE_NO";
12786 case DT_MIPS_DELTA_RELOC
:
12787 return "MIPS_DELTA_RELOC";
12788 case DT_MIPS_DELTA_RELOC_NO
:
12789 return "MIPS_DELTA_RELOC_NO";
12790 case DT_MIPS_DELTA_SYM
:
12791 return "MIPS_DELTA_SYM";
12792 case DT_MIPS_DELTA_SYM_NO
:
12793 return "MIPS_DELTA_SYM_NO";
12794 case DT_MIPS_DELTA_CLASSSYM
:
12795 return "MIPS_DELTA_CLASSSYM";
12796 case DT_MIPS_DELTA_CLASSSYM_NO
:
12797 return "MIPS_DELTA_CLASSSYM_NO";
12798 case DT_MIPS_CXX_FLAGS
:
12799 return "MIPS_CXX_FLAGS";
12800 case DT_MIPS_PIXIE_INIT
:
12801 return "MIPS_PIXIE_INIT";
12802 case DT_MIPS_SYMBOL_LIB
:
12803 return "MIPS_SYMBOL_LIB";
12804 case DT_MIPS_LOCALPAGE_GOTIDX
:
12805 return "MIPS_LOCALPAGE_GOTIDX";
12806 case DT_MIPS_LOCAL_GOTIDX
:
12807 return "MIPS_LOCAL_GOTIDX";
12808 case DT_MIPS_HIDDEN_GOTIDX
:
12809 return "MIPS_HIDDEN_GOTIDX";
12810 case DT_MIPS_PROTECTED_GOTIDX
:
12811 return "MIPS_PROTECTED_GOT_IDX";
12812 case DT_MIPS_OPTIONS
:
12813 return "MIPS_OPTIONS";
12814 case DT_MIPS_INTERFACE
:
12815 return "MIPS_INTERFACE";
12816 case DT_MIPS_DYNSTR_ALIGN
:
12817 return "DT_MIPS_DYNSTR_ALIGN";
12818 case DT_MIPS_INTERFACE_SIZE
:
12819 return "DT_MIPS_INTERFACE_SIZE";
12820 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
:
12821 return "DT_MIPS_RLD_TEXT_RESOLVE_ADDR";
12822 case DT_MIPS_PERF_SUFFIX
:
12823 return "DT_MIPS_PERF_SUFFIX";
12824 case DT_MIPS_COMPACT_SIZE
:
12825 return "DT_MIPS_COMPACT_SIZE";
12826 case DT_MIPS_GP_VALUE
:
12827 return "DT_MIPS_GP_VALUE";
12828 case DT_MIPS_AUX_DYNAMIC
:
12829 return "DT_MIPS_AUX_DYNAMIC";
12830 case DT_MIPS_PLTGOT
:
12831 return "DT_MIPS_PLTGOT";
12832 case DT_MIPS_RWPLT
:
12833 return "DT_MIPS_RWPLT";
12838 _bfd_mips_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
12842 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
12844 /* Print normal ELF private data. */
12845 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
12847 /* xgettext:c-format */
12848 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
12850 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O32
)
12851 fprintf (file
, _(" [abi=O32]"));
12852 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_O64
)
12853 fprintf (file
, _(" [abi=O64]"));
12854 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI32
)
12855 fprintf (file
, _(" [abi=EABI32]"));
12856 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
)
12857 fprintf (file
, _(" [abi=EABI64]"));
12858 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ABI
))
12859 fprintf (file
, _(" [abi unknown]"));
12860 else if (ABI_N32_P (abfd
))
12861 fprintf (file
, _(" [abi=N32]"));
12862 else if (ABI_64_P (abfd
))
12863 fprintf (file
, _(" [abi=64]"));
12865 fprintf (file
, _(" [no abi set]"));
12867 if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
12868 fprintf (file
, " [mips1]");
12869 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
12870 fprintf (file
, " [mips2]");
12871 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
12872 fprintf (file
, " [mips3]");
12873 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
12874 fprintf (file
, " [mips4]");
12875 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_5
)
12876 fprintf (file
, " [mips5]");
12877 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
)
12878 fprintf (file
, " [mips32]");
12879 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64
)
12880 fprintf (file
, " [mips64]");
12881 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32R2
)
12882 fprintf (file
, " [mips32r2]");
12883 else if ((elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64R2
)
12884 fprintf (file
, " [mips64r2]");
12886 fprintf (file
, _(" [unknown ISA]"));
12888 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
12889 fprintf (file
, " [mdmx]");
12891 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_ARCH_ASE_M16
)
12892 fprintf (file
, " [mips16]");
12894 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_32BITMODE
)
12895 fprintf (file
, " [32bitmode]");
12897 fprintf (file
, _(" [not 32bitmode]"));
12899 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_NOREORDER
)
12900 fprintf (file
, " [noreorder]");
12902 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_PIC
)
12903 fprintf (file
, " [PIC]");
12905 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_CPIC
)
12906 fprintf (file
, " [CPIC]");
12908 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_XGOT
)
12909 fprintf (file
, " [XGOT]");
12911 if (elf_elfheader (abfd
)->e_flags
& EF_MIPS_UCODE
)
12912 fprintf (file
, " [UCODE]");
12914 fputc ('\n', file
);
12919 const struct bfd_elf_special_section _bfd_mips_elf_special_sections
[] =
12921 { STRING_COMMA_LEN (".lit4"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
12922 { STRING_COMMA_LEN (".lit8"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
12923 { STRING_COMMA_LEN (".mdebug"), 0, SHT_MIPS_DEBUG
, 0 },
12924 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
12925 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_MIPS_GPREL
},
12926 { STRING_COMMA_LEN (".ucode"), 0, SHT_MIPS_UCODE
, 0 },
12927 { NULL
, 0, 0, 0, 0 }
12930 /* Merge non visibility st_other attributes. Ensure that the
12931 STO_OPTIONAL flag is copied into h->other, even if this is not a
12932 definiton of the symbol. */
12934 _bfd_mips_elf_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
12935 const Elf_Internal_Sym
*isym
,
12936 bfd_boolean definition
,
12937 bfd_boolean dynamic ATTRIBUTE_UNUSED
)
12939 if ((isym
->st_other
& ~ELF_ST_VISIBILITY (-1)) != 0)
12941 unsigned char other
;
12943 other
= (definition
? isym
->st_other
: h
->other
);
12944 other
&= ~ELF_ST_VISIBILITY (-1);
12945 h
->other
= other
| ELF_ST_VISIBILITY (h
->other
);
12949 && ELF_MIPS_IS_OPTIONAL (isym
->st_other
))
12950 h
->other
|= STO_OPTIONAL
;
12953 /* Decide whether an undefined symbol is special and can be ignored.
12954 This is the case for OPTIONAL symbols on IRIX. */
12956 _bfd_mips_elf_ignore_undef_symbol (struct elf_link_hash_entry
*h
)
12958 return ELF_MIPS_IS_OPTIONAL (h
->other
) ? TRUE
: FALSE
;
12962 _bfd_mips_elf_common_definition (Elf_Internal_Sym
*sym
)
12964 return (sym
->st_shndx
== SHN_COMMON
12965 || sym
->st_shndx
== SHN_MIPS_ACOMMON
12966 || sym
->st_shndx
== SHN_MIPS_SCOMMON
);
12969 /* Return address for Ith PLT stub in section PLT, for relocation REL
12970 or (bfd_vma) -1 if it should not be included. */
12973 _bfd_mips_elf_plt_sym_val (bfd_vma i
, const asection
*plt
,
12974 const arelent
*rel ATTRIBUTE_UNUSED
)
12977 + 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry
)
12978 + i
* 4 * ARRAY_SIZE (mips_exec_plt_entry
));
12982 _bfd_mips_post_process_headers (bfd
*abfd
, struct bfd_link_info
*link_info
)
12984 struct mips_elf_link_hash_table
*htab
;
12985 Elf_Internal_Ehdr
*i_ehdrp
;
12987 i_ehdrp
= elf_elfheader (abfd
);
12990 htab
= mips_elf_hash_table (link_info
);
12991 BFD_ASSERT (htab
!= NULL
);
12993 if (htab
->use_plts_and_copy_relocs
&& !htab
->is_vxworks
)
12994 i_ehdrp
->e_ident
[EI_ABIVERSION
] = 1;