1 // mips.cc -- mips target support for gold.
3 // Copyright (C) 2011-2017 Free Software Foundation, Inc.
4 // Written by Sasa Stankovic <sasa.stankovic@imgtec.com>
5 // and Aleksandar Simeonov <aleksandar.simeonov@rt-rk.com>.
6 // This file contains borrowed and adapted code from bfd/elfxx-mips.c.
8 // This file is part of gold.
10 // This program is free software; you can redistribute it and/or modify
11 // it under the terms of the GNU General Public License as published by
12 // the Free Software Foundation; either version 3 of the License, or
13 // (at your option) any later version.
15 // This program is distributed in the hope that it will be useful,
16 // but WITHOUT ANY WARRANTY; without even the implied warranty of
17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 // GNU General Public License for more details.
20 // You should have received a copy of the GNU General Public License
21 // along with this program; if not, write to the Free Software
22 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
23 // MA 02110-1301, USA.
33 #include "parameters.h"
40 #include "copy-relocs.h"
42 #include "target-reloc.h"
43 #include "target-select.h"
47 #include "attributes.h"
54 template<int size
, bool big_endian
>
55 class Mips_output_data_plt
;
57 template<int size
, bool big_endian
>
58 class Mips_output_data_got
;
60 template<int size
, bool big_endian
>
63 template<int size
, bool big_endian
>
64 class Mips_output_section_reginfo
;
66 template<int size
, bool big_endian
>
67 class Mips_output_data_la25_stub
;
69 template<int size
, bool big_endian
>
70 class Mips_output_data_mips_stubs
;
75 template<int size
, bool big_endian
>
78 template<int size
, bool big_endian
>
81 class Mips16_stub_section_base
;
83 template<int size
, bool big_endian
>
84 class Mips16_stub_section
;
86 // The ABI says that every symbol used by dynamic relocations must have
87 // a global GOT entry. Among other things, this provides the dynamic
88 // linker with a free, directly-indexed cache. The GOT can therefore
89 // contain symbols that are not referenced by GOT relocations themselves
90 // (in other words, it may have symbols that are not referenced by things
91 // like R_MIPS_GOT16 and R_MIPS_GOT_PAGE).
93 // GOT relocations are less likely to overflow if we put the associated
94 // GOT entries towards the beginning. We therefore divide the global
95 // GOT entries into two areas: "normal" and "reloc-only". Entries in
96 // the first area can be used for both dynamic relocations and GP-relative
97 // accesses, while those in the "reloc-only" area are for dynamic
100 // These GGA_* ("Global GOT Area") values are organised so that lower
101 // values are more general than higher values. Also, non-GGA_NONE
102 // values are ordered by the position of the area in the GOT.
111 // The types of GOT entries needed for this platform.
112 // These values are exposed to the ABI in an incremental link.
113 // Do not renumber existing values without changing the version
114 // number of the .gnu_incremental_inputs section.
117 GOT_TYPE_STANDARD
= 0, // GOT entry for a regular symbol
118 GOT_TYPE_TLS_OFFSET
= 1, // GOT entry for TLS offset
119 GOT_TYPE_TLS_PAIR
= 2, // GOT entry for TLS module/offset pair
121 // GOT entries for multi-GOT. We support up to 1024 GOTs in multi-GOT links.
122 GOT_TYPE_STANDARD_MULTIGOT
= 3,
123 GOT_TYPE_TLS_OFFSET_MULTIGOT
= GOT_TYPE_STANDARD_MULTIGOT
+ 1024,
124 GOT_TYPE_TLS_PAIR_MULTIGOT
= GOT_TYPE_TLS_OFFSET_MULTIGOT
+ 1024
127 // TLS type of GOT entry.
136 // Values found in the r_ssym field of a relocation entry.
137 enum Special_relocation_symbol
139 RSS_UNDEF
= 0, // None - value is zero.
140 RSS_GP
= 1, // Value of GP.
141 RSS_GP0
= 2, // Value of GP in object being relocated.
142 RSS_LOC
= 3 // Address of location being relocated.
145 // Whether the section is readonly.
147 is_readonly_section(Output_section
* output_section
)
149 elfcpp::Elf_Xword section_flags
= output_section
->flags();
150 elfcpp::Elf_Word section_type
= output_section
->type();
152 if (section_type
== elfcpp::SHT_NOBITS
)
155 if (section_flags
& elfcpp::SHF_WRITE
)
161 // Return TRUE if a relocation of type R_TYPE from OBJECT might
162 // require an la25 stub. See also local_pic_function, which determines
163 // whether the destination function ever requires a stub.
164 template<int size
, bool big_endian
>
166 relocation_needs_la25_stub(Mips_relobj
<size
, big_endian
>* object
,
167 unsigned int r_type
, bool target_is_16_bit_code
)
169 // We specifically ignore branches and jumps from EF_PIC objects,
170 // where the onus is on the compiler or programmer to perform any
171 // necessary initialization of $25. Sometimes such initialization
172 // is unnecessary; for example, -mno-shared functions do not use
173 // the incoming value of $25, and may therefore be called directly.
174 if (object
->is_pic())
179 case elfcpp::R_MIPS_26
:
180 case elfcpp::R_MIPS_PC16
:
181 case elfcpp::R_MIPS_PC21_S2
:
182 case elfcpp::R_MIPS_PC26_S2
:
183 case elfcpp::R_MICROMIPS_26_S1
:
184 case elfcpp::R_MICROMIPS_PC7_S1
:
185 case elfcpp::R_MICROMIPS_PC10_S1
:
186 case elfcpp::R_MICROMIPS_PC16_S1
:
187 case elfcpp::R_MICROMIPS_PC23_S2
:
190 case elfcpp::R_MIPS16_26
:
191 return !target_is_16_bit_code
;
198 // Return true if SYM is a locally-defined PIC function, in the sense
199 // that it or its fn_stub might need $25 to be valid on entry.
200 // Note that MIPS16 functions set up $gp using PC-relative instructions,
201 // so they themselves never need $25 to be valid. Only non-MIPS16
202 // entry points are of interest here.
203 template<int size
, bool big_endian
>
205 local_pic_function(Mips_symbol
<size
>* sym
)
207 bool def_regular
= (sym
->source() == Symbol::FROM_OBJECT
208 && !sym
->object()->is_dynamic()
209 && !sym
->is_undefined());
211 if (sym
->is_defined() && def_regular
)
213 Mips_relobj
<size
, big_endian
>* object
=
214 static_cast<Mips_relobj
<size
, big_endian
>*>(sym
->object());
216 if ((object
->is_pic() || sym
->is_pic())
217 && (!sym
->is_mips16()
218 || (sym
->has_mips16_fn_stub() && sym
->need_fn_stub())))
225 hi16_reloc(int r_type
)
227 return (r_type
== elfcpp::R_MIPS_HI16
228 || r_type
== elfcpp::R_MIPS16_HI16
229 || r_type
== elfcpp::R_MICROMIPS_HI16
230 || r_type
== elfcpp::R_MIPS_PCHI16
);
234 lo16_reloc(int r_type
)
236 return (r_type
== elfcpp::R_MIPS_LO16
237 || r_type
== elfcpp::R_MIPS16_LO16
238 || r_type
== elfcpp::R_MICROMIPS_LO16
239 || r_type
== elfcpp::R_MIPS_PCLO16
);
243 got16_reloc(unsigned int r_type
)
245 return (r_type
== elfcpp::R_MIPS_GOT16
246 || r_type
== elfcpp::R_MIPS16_GOT16
247 || r_type
== elfcpp::R_MICROMIPS_GOT16
);
251 call_lo16_reloc(unsigned int r_type
)
253 return (r_type
== elfcpp::R_MIPS_CALL_LO16
254 || r_type
== elfcpp::R_MICROMIPS_CALL_LO16
);
258 got_lo16_reloc(unsigned int r_type
)
260 return (r_type
== elfcpp::R_MIPS_GOT_LO16
261 || r_type
== elfcpp::R_MICROMIPS_GOT_LO16
);
265 eh_reloc(unsigned int r_type
)
267 return (r_type
== elfcpp::R_MIPS_EH
);
271 got_disp_reloc(unsigned int r_type
)
273 return (r_type
== elfcpp::R_MIPS_GOT_DISP
274 || r_type
== elfcpp::R_MICROMIPS_GOT_DISP
);
278 got_page_reloc(unsigned int r_type
)
280 return (r_type
== elfcpp::R_MIPS_GOT_PAGE
281 || r_type
== elfcpp::R_MICROMIPS_GOT_PAGE
);
285 tls_gd_reloc(unsigned int r_type
)
287 return (r_type
== elfcpp::R_MIPS_TLS_GD
288 || r_type
== elfcpp::R_MIPS16_TLS_GD
289 || r_type
== elfcpp::R_MICROMIPS_TLS_GD
);
293 tls_gottprel_reloc(unsigned int r_type
)
295 return (r_type
== elfcpp::R_MIPS_TLS_GOTTPREL
296 || r_type
== elfcpp::R_MIPS16_TLS_GOTTPREL
297 || r_type
== elfcpp::R_MICROMIPS_TLS_GOTTPREL
);
301 tls_ldm_reloc(unsigned int r_type
)
303 return (r_type
== elfcpp::R_MIPS_TLS_LDM
304 || r_type
== elfcpp::R_MIPS16_TLS_LDM
305 || r_type
== elfcpp::R_MICROMIPS_TLS_LDM
);
309 mips16_call_reloc(unsigned int r_type
)
311 return (r_type
== elfcpp::R_MIPS16_26
312 || r_type
== elfcpp::R_MIPS16_CALL16
);
316 jal_reloc(unsigned int r_type
)
318 return (r_type
== elfcpp::R_MIPS_26
319 || r_type
== elfcpp::R_MIPS16_26
320 || r_type
== elfcpp::R_MICROMIPS_26_S1
);
324 micromips_branch_reloc(unsigned int r_type
)
326 return (r_type
== elfcpp::R_MICROMIPS_26_S1
327 || r_type
== elfcpp::R_MICROMIPS_PC16_S1
328 || r_type
== elfcpp::R_MICROMIPS_PC10_S1
329 || r_type
== elfcpp::R_MICROMIPS_PC7_S1
);
332 // Check if R_TYPE is a MIPS16 reloc.
334 mips16_reloc(unsigned int r_type
)
338 case elfcpp::R_MIPS16_26
:
339 case elfcpp::R_MIPS16_GPREL
:
340 case elfcpp::R_MIPS16_GOT16
:
341 case elfcpp::R_MIPS16_CALL16
:
342 case elfcpp::R_MIPS16_HI16
:
343 case elfcpp::R_MIPS16_LO16
:
344 case elfcpp::R_MIPS16_TLS_GD
:
345 case elfcpp::R_MIPS16_TLS_LDM
:
346 case elfcpp::R_MIPS16_TLS_DTPREL_HI16
:
347 case elfcpp::R_MIPS16_TLS_DTPREL_LO16
:
348 case elfcpp::R_MIPS16_TLS_GOTTPREL
:
349 case elfcpp::R_MIPS16_TLS_TPREL_HI16
:
350 case elfcpp::R_MIPS16_TLS_TPREL_LO16
:
358 // Check if R_TYPE is a microMIPS reloc.
360 micromips_reloc(unsigned int r_type
)
364 case elfcpp::R_MICROMIPS_26_S1
:
365 case elfcpp::R_MICROMIPS_HI16
:
366 case elfcpp::R_MICROMIPS_LO16
:
367 case elfcpp::R_MICROMIPS_GPREL16
:
368 case elfcpp::R_MICROMIPS_LITERAL
:
369 case elfcpp::R_MICROMIPS_GOT16
:
370 case elfcpp::R_MICROMIPS_PC7_S1
:
371 case elfcpp::R_MICROMIPS_PC10_S1
:
372 case elfcpp::R_MICROMIPS_PC16_S1
:
373 case elfcpp::R_MICROMIPS_CALL16
:
374 case elfcpp::R_MICROMIPS_GOT_DISP
:
375 case elfcpp::R_MICROMIPS_GOT_PAGE
:
376 case elfcpp::R_MICROMIPS_GOT_OFST
:
377 case elfcpp::R_MICROMIPS_GOT_HI16
:
378 case elfcpp::R_MICROMIPS_GOT_LO16
:
379 case elfcpp::R_MICROMIPS_SUB
:
380 case elfcpp::R_MICROMIPS_HIGHER
:
381 case elfcpp::R_MICROMIPS_HIGHEST
:
382 case elfcpp::R_MICROMIPS_CALL_HI16
:
383 case elfcpp::R_MICROMIPS_CALL_LO16
:
384 case elfcpp::R_MICROMIPS_SCN_DISP
:
385 case elfcpp::R_MICROMIPS_JALR
:
386 case elfcpp::R_MICROMIPS_HI0_LO16
:
387 case elfcpp::R_MICROMIPS_TLS_GD
:
388 case elfcpp::R_MICROMIPS_TLS_LDM
:
389 case elfcpp::R_MICROMIPS_TLS_DTPREL_HI16
:
390 case elfcpp::R_MICROMIPS_TLS_DTPREL_LO16
:
391 case elfcpp::R_MICROMIPS_TLS_GOTTPREL
:
392 case elfcpp::R_MICROMIPS_TLS_TPREL_HI16
:
393 case elfcpp::R_MICROMIPS_TLS_TPREL_LO16
:
394 case elfcpp::R_MICROMIPS_GPREL7_S2
:
395 case elfcpp::R_MICROMIPS_PC23_S2
:
404 is_matching_lo16_reloc(unsigned int high_reloc
, unsigned int lo16_reloc
)
408 case elfcpp::R_MIPS_HI16
:
409 case elfcpp::R_MIPS_GOT16
:
410 return lo16_reloc
== elfcpp::R_MIPS_LO16
;
411 case elfcpp::R_MIPS_PCHI16
:
412 return lo16_reloc
== elfcpp::R_MIPS_PCLO16
;
413 case elfcpp::R_MIPS16_HI16
:
414 case elfcpp::R_MIPS16_GOT16
:
415 return lo16_reloc
== elfcpp::R_MIPS16_LO16
;
416 case elfcpp::R_MICROMIPS_HI16
:
417 case elfcpp::R_MICROMIPS_GOT16
:
418 return lo16_reloc
== elfcpp::R_MICROMIPS_LO16
;
424 // This class is used to hold information about one GOT entry.
425 // There are three types of entry:
427 // (1) a SYMBOL + OFFSET address, where SYMBOL is local to an input object
428 // (object != NULL, symndx >= 0, tls_type != GOT_TLS_LDM)
429 // (2) a SYMBOL address, where SYMBOL is not local to an input object
430 // (sym != NULL, symndx == -1)
431 // (3) a TLS LDM slot (there's only one of these per GOT.)
432 // (object != NULL, symndx == 0, tls_type == GOT_TLS_LDM)
434 template<int size
, bool big_endian
>
437 typedef typename
elfcpp::Elf_types
<size
>::Elf_Addr Mips_address
;
440 Mips_got_entry(Mips_relobj
<size
, big_endian
>* object
, unsigned int symndx
,
441 Mips_address addend
, unsigned char tls_type
,
442 unsigned int shndx
, bool is_section_symbol
)
443 : addend_(addend
), symndx_(symndx
), tls_type_(tls_type
),
444 is_section_symbol_(is_section_symbol
), shndx_(shndx
)
445 { this->d
.object
= object
; }
447 Mips_got_entry(Mips_symbol
<size
>* sym
, unsigned char tls_type
)
448 : addend_(0), symndx_(-1U), tls_type_(tls_type
),
449 is_section_symbol_(false), shndx_(-1U)
450 { this->d
.sym
= sym
; }
452 // Return whether this entry is for a local symbol.
454 is_for_local_symbol() const
455 { return this->symndx_
!= -1U; }
457 // Return whether this entry is for a global symbol.
459 is_for_global_symbol() const
460 { return this->symndx_
== -1U; }
462 // Return the hash of this entry.
466 if (this->tls_type_
== GOT_TLS_LDM
)
467 return this->symndx_
+ (1 << 18);
469 size_t name_hash_value
= gold::string_hash
<char>(
470 (this->symndx_
!= -1U)
471 ? this->d
.object
->name().c_str()
472 : this->d
.sym
->name());
473 size_t addend
= this->addend_
;
474 return name_hash_value
^ this->symndx_
^ addend
;
477 // Return whether this entry is equal to OTHER.
479 equals(Mips_got_entry
<size
, big_endian
>* other
) const
481 if (this->tls_type_
== GOT_TLS_LDM
)
484 return ((this->tls_type_
== other
->tls_type_
)
485 && (this->symndx_
== other
->symndx_
)
486 && ((this->symndx_
!= -1U)
487 ? (this->d
.object
== other
->d
.object
)
488 : (this->d
.sym
== other
->d
.sym
))
489 && (this->addend_
== other
->addend_
));
492 // Return input object that needs this GOT entry.
493 Mips_relobj
<size
, big_endian
>*
496 gold_assert(this->symndx_
!= -1U);
497 return this->d
.object
;
500 // Return local symbol index for local GOT entries.
504 gold_assert(this->symndx_
!= -1U);
505 return this->symndx_
;
508 // Return the relocation addend for local GOT entries.
511 { return this->addend_
; }
513 // Return global symbol for global GOT entries.
517 gold_assert(this->symndx_
== -1U);
521 // Return whether this is a TLS GOT entry.
524 { return this->tls_type_
!= GOT_TLS_NONE
; }
526 // Return TLS type of this GOT entry.
529 { return this->tls_type_
; }
531 // Return section index of the local symbol for local GOT entries.
534 { return this->shndx_
; }
536 // Return whether this is a STT_SECTION symbol.
538 is_section_symbol() const
539 { return this->is_section_symbol_
; }
543 Mips_address addend_
;
545 // The index of the symbol if we have a local symbol; -1 otherwise.
546 unsigned int symndx_
;
550 // The input object for local symbols that needs the GOT entry.
551 Mips_relobj
<size
, big_endian
>* object
;
552 // If symndx == -1, the global symbol corresponding to this GOT entry. The
553 // symbol's entry is in the local area if mips_sym->global_got_area is
554 // GGA_NONE, otherwise it is in the global area.
555 Mips_symbol
<size
>* sym
;
558 // The TLS type of this GOT entry. An LDM GOT entry will be a local
559 // symbol entry with r_symndx == 0.
560 unsigned char tls_type_
;
562 // Whether this is a STT_SECTION symbol.
563 bool is_section_symbol_
;
565 // For local GOT entries, section index of the local symbol.
569 // Hash for Mips_got_entry.
571 template<int size
, bool big_endian
>
572 class Mips_got_entry_hash
576 operator()(Mips_got_entry
<size
, big_endian
>* entry
) const
577 { return entry
->hash(); }
580 // Equality for Mips_got_entry.
582 template<int size
, bool big_endian
>
583 class Mips_got_entry_eq
587 operator()(Mips_got_entry
<size
, big_endian
>* e1
,
588 Mips_got_entry
<size
, big_endian
>* e2
) const
589 { return e1
->equals(e2
); }
592 // Hash for Mips_symbol.
595 class Mips_symbol_hash
599 operator()(Mips_symbol
<size
>* sym
) const
600 { return sym
->hash(); }
603 // Got_page_range. This class describes a range of addends: [MIN_ADDEND,
604 // MAX_ADDEND]. The instances form a non-overlapping list that is sorted by
605 // increasing MIN_ADDEND.
607 struct Got_page_range
610 : next(NULL
), min_addend(0), max_addend(0)
613 Got_page_range
* next
;
617 // Return the maximum number of GOT page entries required.
620 { return (this->max_addend
- this->min_addend
+ 0x1ffff) >> 16; }
623 // Got_page_entry. This class describes the range of addends that are applied
624 // to page relocations against a given symbol.
626 struct Got_page_entry
629 : object(NULL
), symndx(-1U), ranges(NULL
), num_pages(0)
632 Got_page_entry(Object
* object_
, unsigned int symndx_
)
633 : object(object_
), symndx(symndx_
), ranges(NULL
), num_pages(0)
636 // The input object that needs the GOT page entry.
638 // The index of the symbol, as stored in the relocation r_info.
640 // The ranges for this page entry.
641 Got_page_range
* ranges
;
642 // The maximum number of page entries needed for RANGES.
643 unsigned int num_pages
;
646 // Hash for Got_page_entry.
648 struct Got_page_entry_hash
651 operator()(Got_page_entry
* entry
) const
652 { return reinterpret_cast<uintptr_t>(entry
->object
) + entry
->symndx
; }
655 // Equality for Got_page_entry.
657 struct Got_page_entry_eq
660 operator()(Got_page_entry
* entry1
, Got_page_entry
* entry2
) const
662 return entry1
->object
== entry2
->object
&& entry1
->symndx
== entry2
->symndx
;
666 // This class is used to hold .got information when linking.
668 template<int size
, bool big_endian
>
671 typedef typename
elfcpp::Elf_types
<size
>::Elf_Addr Mips_address
;
672 typedef Output_data_reloc
<elfcpp::SHT_REL
, true, size
, big_endian
>
674 typedef Unordered_map
<unsigned int, unsigned int> Got_page_offsets
;
676 // Unordered set of GOT entries.
677 typedef Unordered_set
<Mips_got_entry
<size
, big_endian
>*,
678 Mips_got_entry_hash
<size
, big_endian
>,
679 Mips_got_entry_eq
<size
, big_endian
> > Got_entry_set
;
681 // Unordered set of GOT page entries.
682 typedef Unordered_set
<Got_page_entry
*,
683 Got_page_entry_hash
, Got_page_entry_eq
> Got_page_entry_set
;
685 // Unordered set of global GOT entries.
686 typedef Unordered_set
<Mips_symbol
<size
>*, Mips_symbol_hash
<size
> >
687 Global_got_entry_set
;
691 : local_gotno_(0), page_gotno_(0), global_gotno_(0), reloc_only_gotno_(0),
692 tls_gotno_(0), tls_ldm_offset_(-1U), global_got_symbols_(),
693 got_entries_(), got_page_entries_(), got_page_offset_start_(0),
694 got_page_offset_next_(0), got_page_offsets_(), next_(NULL
), index_(-1U),
698 // Reserve GOT entry for a GOT relocation of type R_TYPE against symbol
699 // SYMNDX + ADDEND, where SYMNDX is a local symbol in section SHNDX in OBJECT.
701 record_local_got_symbol(Mips_relobj
<size
, big_endian
>* object
,
702 unsigned int symndx
, Mips_address addend
,
703 unsigned int r_type
, unsigned int shndx
,
704 bool is_section_symbol
);
706 // Reserve GOT entry for a GOT relocation of type R_TYPE against MIPS_SYM,
707 // in OBJECT. FOR_CALL is true if the caller is only interested in
708 // using the GOT entry for calls. DYN_RELOC is true if R_TYPE is a dynamic
711 record_global_got_symbol(Mips_symbol
<size
>* mips_sym
,
712 Mips_relobj
<size
, big_endian
>* object
,
713 unsigned int r_type
, bool dyn_reloc
, bool for_call
);
715 // Add ENTRY to master GOT and to OBJECT's GOT.
717 record_got_entry(Mips_got_entry
<size
, big_endian
>* entry
,
718 Mips_relobj
<size
, big_endian
>* object
);
720 // Record that OBJECT has a page relocation against symbol SYMNDX and
721 // that ADDEND is the addend for that relocation.
723 record_got_page_entry(Mips_relobj
<size
, big_endian
>* object
,
724 unsigned int symndx
, int addend
);
726 // Create all entries that should be in the local part of the GOT.
728 add_local_entries(Target_mips
<size
, big_endian
>* target
, Layout
* layout
);
730 // Create GOT page entries.
732 add_page_entries(Target_mips
<size
, big_endian
>* target
, Layout
* layout
);
734 // Create global GOT entries, both GGA_NORMAL and GGA_RELOC_ONLY.
736 add_global_entries(Target_mips
<size
, big_endian
>* target
, Layout
* layout
,
737 unsigned int non_reloc_only_global_gotno
);
739 // Create global GOT entries that should be in the GGA_RELOC_ONLY area.
741 add_reloc_only_entries(Mips_output_data_got
<size
, big_endian
>* got
);
743 // Create TLS GOT entries.
745 add_tls_entries(Target_mips
<size
, big_endian
>* target
, Layout
* layout
);
747 // Decide whether the symbol needs an entry in the global part of the primary
748 // GOT, setting global_got_area accordingly. Count the number of global
749 // symbols that are in the primary GOT only because they have dynamic
750 // relocations R_MIPS_REL32 against them (reloc_only_gotno).
752 count_got_symbols(Symbol_table
* symtab
);
754 // Return the offset of GOT page entry for VALUE.
756 get_got_page_offset(Mips_address value
,
757 Mips_output_data_got
<size
, big_endian
>* got
);
759 // Count the number of GOT entries required.
763 // Count the number of GOT entries required by ENTRY. Accumulate the result.
765 count_got_entry(Mips_got_entry
<size
, big_endian
>* entry
);
767 // Add FROM's GOT entries.
769 add_got_entries(Mips_got_info
<size
, big_endian
>* from
);
771 // Add FROM's GOT page entries.
773 add_got_page_entries(Mips_got_info
<size
, big_endian
>* from
);
778 { return ((2 + this->local_gotno_
+ this->page_gotno_
+ this->global_gotno_
779 + this->tls_gotno_
) * size
/8);
782 // Return the number of local GOT entries.
785 { return this->local_gotno_
; }
787 // Return the maximum number of page GOT entries needed.
790 { return this->page_gotno_
; }
792 // Return the number of global GOT entries.
795 { return this->global_gotno_
; }
797 // Set the number of global GOT entries.
799 set_global_gotno(unsigned int global_gotno
)
800 { this->global_gotno_
= global_gotno
; }
802 // Return the number of GGA_RELOC_ONLY global GOT entries.
804 reloc_only_gotno() const
805 { return this->reloc_only_gotno_
; }
807 // Return the number of TLS GOT entries.
810 { return this->tls_gotno_
; }
812 // Return the GOT type for this GOT. Used for multi-GOT links only.
814 multigot_got_type(unsigned int got_type
) const
818 case GOT_TYPE_STANDARD
:
819 return GOT_TYPE_STANDARD_MULTIGOT
+ this->index_
;
820 case GOT_TYPE_TLS_OFFSET
:
821 return GOT_TYPE_TLS_OFFSET_MULTIGOT
+ this->index_
;
822 case GOT_TYPE_TLS_PAIR
:
823 return GOT_TYPE_TLS_PAIR_MULTIGOT
+ this->index_
;
829 // Remove lazy-binding stubs for global symbols in this GOT.
831 remove_lazy_stubs(Target_mips
<size
, big_endian
>* target
);
833 // Return offset of this GOT from the start of .got section.
836 { return this->offset_
; }
838 // Set offset of this GOT from the start of .got section.
840 set_offset(unsigned int offset
)
841 { this->offset_
= offset
; }
843 // Set index of this GOT in multi-GOT links.
845 set_index(unsigned int index
)
846 { this->index_
= index
; }
848 // Return next GOT in multi-GOT links.
849 Mips_got_info
<size
, big_endian
>*
851 { return this->next_
; }
853 // Set next GOT in multi-GOT links.
855 set_next(Mips_got_info
<size
, big_endian
>* next
)
856 { this->next_
= next
; }
858 // Return the offset of TLS LDM entry for this GOT.
860 tls_ldm_offset() const
861 { return this->tls_ldm_offset_
; }
863 // Set the offset of TLS LDM entry for this GOT.
865 set_tls_ldm_offset(unsigned int tls_ldm_offset
)
866 { this->tls_ldm_offset_
= tls_ldm_offset
; }
868 Global_got_entry_set
&
870 { return this->global_got_symbols_
; }
872 // Return the GOT_TLS_* type required by relocation type R_TYPE.
874 mips_elf_reloc_tls_type(unsigned int r_type
)
876 if (tls_gd_reloc(r_type
))
879 if (tls_ldm_reloc(r_type
))
882 if (tls_gottprel_reloc(r_type
))
888 // Return the number of GOT slots needed for GOT TLS type TYPE.
890 mips_tls_got_entries(unsigned int type
)
910 // The number of local GOT entries.
911 unsigned int local_gotno_
;
912 // The maximum number of page GOT entries needed.
913 unsigned int page_gotno_
;
914 // The number of global GOT entries.
915 unsigned int global_gotno_
;
916 // The number of global GOT entries that are in the GGA_RELOC_ONLY area.
917 unsigned int reloc_only_gotno_
;
918 // The number of TLS GOT entries.
919 unsigned int tls_gotno_
;
920 // The offset of TLS LDM entry for this GOT.
921 unsigned int tls_ldm_offset_
;
922 // All symbols that have global GOT entry.
923 Global_got_entry_set global_got_symbols_
;
924 // A hash table holding GOT entries.
925 Got_entry_set got_entries_
;
926 // A hash table of GOT page entries.
927 Got_page_entry_set got_page_entries_
;
928 // The offset of first GOT page entry for this GOT.
929 unsigned int got_page_offset_start_
;
930 // The offset of next available GOT page entry for this GOT.
931 unsigned int got_page_offset_next_
;
932 // A hash table that maps GOT page entry value to the GOT offset where
933 // the entry is located.
934 Got_page_offsets got_page_offsets_
;
935 // In multi-GOT links, a pointer to the next GOT.
936 Mips_got_info
<size
, big_endian
>* next_
;
937 // Index of this GOT in multi-GOT links.
939 // The offset of this GOT in multi-GOT links.
940 unsigned int offset_
;
943 // This is a helper class used during relocation scan. It records GOT16 addend.
945 template<int size
, bool big_endian
>
948 typedef typename
elfcpp::Elf_types
<size
>::Elf_Addr Mips_address
;
950 got16_addend(const Sized_relobj_file
<size
, big_endian
>* _object
,
951 unsigned int _shndx
, unsigned int _r_type
, unsigned int _r_sym
,
952 Mips_address _addend
)
953 : object(_object
), shndx(_shndx
), r_type(_r_type
), r_sym(_r_sym
),
957 const Sized_relobj_file
<size
, big_endian
>* object
;
964 // .MIPS.abiflags section content
966 template<bool big_endian
>
969 typedef typename
elfcpp::Swap
<8, big_endian
>::Valtype Valtype8
;
970 typedef typename
elfcpp::Swap
<16, big_endian
>::Valtype Valtype16
;
971 typedef typename
elfcpp::Swap
<32, big_endian
>::Valtype Valtype32
;
974 : version(0), isa_level(0), isa_rev(0), gpr_size(0), cpr1_size(0),
975 cpr2_size(0), fp_abi(0), isa_ext(0), ases(0), flags1(0), flags2(0)
978 // Version of flags structure.
980 // The level of the ISA: 1-5, 32, 64.
982 // The revision of ISA: 0 for MIPS V and below, 1-n otherwise.
984 // The size of general purpose registers.
986 // The size of co-processor 1 registers.
988 // The size of co-processor 2 registers.
990 // The floating-point ABI.
992 // Processor-specific extension.
994 // Mask of ASEs used.
996 // Mask of general flags.
1001 // Mips_symbol class. Holds additional symbol information needed for Mips.
1004 class Mips_symbol
: public Sized_symbol
<size
>
1008 : need_fn_stub_(false), has_nonpic_branches_(false), la25_stub_offset_(-1U),
1009 has_static_relocs_(false), no_lazy_stub_(false), lazy_stub_offset_(0),
1010 pointer_equality_needed_(false), global_got_area_(GGA_NONE
),
1011 global_gotoffset_(-1U), got_only_for_calls_(true), has_lazy_stub_(false),
1012 needs_mips_plt_(false), needs_comp_plt_(false), mips_plt_offset_(-1U),
1013 comp_plt_offset_(-1U), mips16_fn_stub_(NULL
), mips16_call_stub_(NULL
),
1014 mips16_call_fp_stub_(NULL
), applied_secondary_got_fixup_(false)
1017 // Return whether this is a MIPS16 symbol.
1021 // (st_other & STO_MIPS16) == STO_MIPS16
1022 return ((this->nonvis() & (elfcpp::STO_MIPS16
>> 2))
1023 == elfcpp::STO_MIPS16
>> 2);
1026 // Return whether this is a microMIPS symbol.
1028 is_micromips() const
1030 // (st_other & STO_MIPS_ISA) == STO_MICROMIPS
1031 return ((this->nonvis() & (elfcpp::STO_MIPS_ISA
>> 2))
1032 == elfcpp::STO_MICROMIPS
>> 2);
1035 // Return whether the symbol needs MIPS16 fn_stub.
1037 need_fn_stub() const
1038 { return this->need_fn_stub_
; }
1040 // Set that the symbol needs MIPS16 fn_stub.
1043 { this->need_fn_stub_
= true; }
1045 // Return whether this symbol is referenced by branch relocations from
1046 // any non-PIC input file.
1048 has_nonpic_branches() const
1049 { return this->has_nonpic_branches_
; }
1051 // Set that this symbol is referenced by branch relocations from
1052 // any non-PIC input file.
1054 set_has_nonpic_branches()
1055 { this->has_nonpic_branches_
= true; }
1057 // Return the offset of the la25 stub for this symbol from the start of the
1058 // la25 stub section.
1060 la25_stub_offset() const
1061 { return this->la25_stub_offset_
; }
1063 // Set the offset of the la25 stub for this symbol from the start of the
1064 // la25 stub section.
1066 set_la25_stub_offset(unsigned int offset
)
1067 { this->la25_stub_offset_
= offset
; }
1069 // Return whether the symbol has la25 stub. This is true if this symbol is
1070 // for a PIC function, and there are non-PIC branches and jumps to it.
1072 has_la25_stub() const
1073 { return this->la25_stub_offset_
!= -1U; }
1075 // Return whether there is a relocation against this symbol that must be
1076 // resolved by the static linker (that is, the relocation cannot possibly
1077 // be made dynamic).
1079 has_static_relocs() const
1080 { return this->has_static_relocs_
; }
1082 // Set that there is a relocation against this symbol that must be resolved
1083 // by the static linker (that is, the relocation cannot possibly be made
1086 set_has_static_relocs()
1087 { this->has_static_relocs_
= true; }
1089 // Return whether we must not create a lazy-binding stub for this symbol.
1091 no_lazy_stub() const
1092 { return this->no_lazy_stub_
; }
1094 // Set that we must not create a lazy-binding stub for this symbol.
1097 { this->no_lazy_stub_
= true; }
1099 // Return the offset of the lazy-binding stub for this symbol from the start
1100 // of .MIPS.stubs section.
1102 lazy_stub_offset() const
1103 { return this->lazy_stub_offset_
; }
1105 // Set the offset of the lazy-binding stub for this symbol from the start
1106 // of .MIPS.stubs section.
1108 set_lazy_stub_offset(unsigned int offset
)
1109 { this->lazy_stub_offset_
= offset
; }
1111 // Return whether there are any relocations for this symbol where
1112 // pointer equality matters.
1114 pointer_equality_needed() const
1115 { return this->pointer_equality_needed_
; }
1117 // Set that there are relocations for this symbol where pointer equality
1120 set_pointer_equality_needed()
1121 { this->pointer_equality_needed_
= true; }
1123 // Return global GOT area where this symbol in located.
1125 global_got_area() const
1126 { return this->global_got_area_
; }
1128 // Set global GOT area where this symbol in located.
1130 set_global_got_area(Global_got_area global_got_area
)
1131 { this->global_got_area_
= global_got_area
; }
1133 // Return the global GOT offset for this symbol. For multi-GOT links, this
1134 // returns the offset from the start of .got section to the first GOT entry
1135 // for the symbol. Note that in multi-GOT links the symbol can have entry
1136 // in more than one GOT.
1138 global_gotoffset() const
1139 { return this->global_gotoffset_
; }
1141 // Set the global GOT offset for this symbol. Note that in multi-GOT links
1142 // the symbol can have entry in more than one GOT. This method will set
1143 // the offset only if it is less than current offset.
1145 set_global_gotoffset(unsigned int offset
)
1147 if (this->global_gotoffset_
== -1U || offset
< this->global_gotoffset_
)
1148 this->global_gotoffset_
= offset
;
1151 // Return whether all GOT relocations for this symbol are for calls.
1153 got_only_for_calls() const
1154 { return this->got_only_for_calls_
; }
1156 // Set that there is a GOT relocation for this symbol that is not for call.
1158 set_got_not_only_for_calls()
1159 { this->got_only_for_calls_
= false; }
1161 // Return whether this is a PIC symbol.
1165 // (st_other & STO_MIPS_FLAGS) == STO_MIPS_PIC
1166 return ((this->nonvis() & (elfcpp::STO_MIPS_FLAGS
>> 2))
1167 == (elfcpp::STO_MIPS_PIC
>> 2));
1170 // Set the flag in st_other field that marks this symbol as PIC.
1174 if (this->is_mips16())
1175 // (st_other & ~(STO_MIPS16 | STO_MIPS_FLAGS)) | STO_MIPS_PIC
1176 this->set_nonvis((this->nonvis()
1177 & ~((elfcpp::STO_MIPS16
>> 2)
1178 | (elfcpp::STO_MIPS_FLAGS
>> 2)))
1179 | (elfcpp::STO_MIPS_PIC
>> 2));
1181 // (other & ~STO_MIPS_FLAGS) | STO_MIPS_PIC
1182 this->set_nonvis((this->nonvis() & ~(elfcpp::STO_MIPS_FLAGS
>> 2))
1183 | (elfcpp::STO_MIPS_PIC
>> 2));
1186 // Set the flag in st_other field that marks this symbol as PLT.
1190 if (this->is_mips16())
1191 // (st_other & (STO_MIPS16 | ~STO_MIPS_FLAGS)) | STO_MIPS_PLT
1192 this->set_nonvis((this->nonvis()
1193 & ((elfcpp::STO_MIPS16
>> 2)
1194 | ~(elfcpp::STO_MIPS_FLAGS
>> 2)))
1195 | (elfcpp::STO_MIPS_PLT
>> 2));
1198 // (st_other & ~STO_MIPS_FLAGS) | STO_MIPS_PLT
1199 this->set_nonvis((this->nonvis() & ~(elfcpp::STO_MIPS_FLAGS
>> 2))
1200 | (elfcpp::STO_MIPS_PLT
>> 2));
1203 // Downcast a base pointer to a Mips_symbol pointer.
1204 static Mips_symbol
<size
>*
1205 as_mips_sym(Symbol
* sym
)
1206 { return static_cast<Mips_symbol
<size
>*>(sym
); }
1208 // Downcast a base pointer to a Mips_symbol pointer.
1209 static const Mips_symbol
<size
>*
1210 as_mips_sym(const Symbol
* sym
)
1211 { return static_cast<const Mips_symbol
<size
>*>(sym
); }
1213 // Return whether the symbol has lazy-binding stub.
1215 has_lazy_stub() const
1216 { return this->has_lazy_stub_
; }
1218 // Set whether the symbol has lazy-binding stub.
1220 set_has_lazy_stub(bool has_lazy_stub
)
1221 { this->has_lazy_stub_
= has_lazy_stub
; }
1223 // Return whether the symbol needs a standard PLT entry.
1225 needs_mips_plt() const
1226 { return this->needs_mips_plt_
; }
1228 // Set whether the symbol needs a standard PLT entry.
1230 set_needs_mips_plt(bool needs_mips_plt
)
1231 { this->needs_mips_plt_
= needs_mips_plt
; }
1233 // Return whether the symbol needs a compressed (MIPS16 or microMIPS) PLT
1236 needs_comp_plt() const
1237 { return this->needs_comp_plt_
; }
1239 // Set whether the symbol needs a compressed (MIPS16 or microMIPS) PLT entry.
1241 set_needs_comp_plt(bool needs_comp_plt
)
1242 { this->needs_comp_plt_
= needs_comp_plt
; }
1244 // Return standard PLT entry offset, or -1 if none.
1246 mips_plt_offset() const
1247 { return this->mips_plt_offset_
; }
1249 // Set standard PLT entry offset.
1251 set_mips_plt_offset(unsigned int mips_plt_offset
)
1252 { this->mips_plt_offset_
= mips_plt_offset
; }
1254 // Return whether the symbol has standard PLT entry.
1256 has_mips_plt_offset() const
1257 { return this->mips_plt_offset_
!= -1U; }
1259 // Return compressed (MIPS16 or microMIPS) PLT entry offset, or -1 if none.
1261 comp_plt_offset() const
1262 { return this->comp_plt_offset_
; }
1264 // Set compressed (MIPS16 or microMIPS) PLT entry offset.
1266 set_comp_plt_offset(unsigned int comp_plt_offset
)
1267 { this->comp_plt_offset_
= comp_plt_offset
; }
1269 // Return whether the symbol has compressed (MIPS16 or microMIPS) PLT entry.
1271 has_comp_plt_offset() const
1272 { return this->comp_plt_offset_
!= -1U; }
1274 // Return MIPS16 fn stub for a symbol.
1275 template<bool big_endian
>
1276 Mips16_stub_section
<size
, big_endian
>*
1277 get_mips16_fn_stub() const
1279 return static_cast<Mips16_stub_section
<size
, big_endian
>*>(mips16_fn_stub_
);
1282 // Set MIPS16 fn stub for a symbol.
1284 set_mips16_fn_stub(Mips16_stub_section_base
* stub
)
1285 { this->mips16_fn_stub_
= stub
; }
1287 // Return whether symbol has MIPS16 fn stub.
1289 has_mips16_fn_stub() const
1290 { return this->mips16_fn_stub_
!= NULL
; }
1292 // Return MIPS16 call stub for a symbol.
1293 template<bool big_endian
>
1294 Mips16_stub_section
<size
, big_endian
>*
1295 get_mips16_call_stub() const
1297 return static_cast<Mips16_stub_section
<size
, big_endian
>*>(
1301 // Set MIPS16 call stub for a symbol.
1303 set_mips16_call_stub(Mips16_stub_section_base
* stub
)
1304 { this->mips16_call_stub_
= stub
; }
1306 // Return whether symbol has MIPS16 call stub.
1308 has_mips16_call_stub() const
1309 { return this->mips16_call_stub_
!= NULL
; }
1311 // Return MIPS16 call_fp stub for a symbol.
1312 template<bool big_endian
>
1313 Mips16_stub_section
<size
, big_endian
>*
1314 get_mips16_call_fp_stub() const
1316 return static_cast<Mips16_stub_section
<size
, big_endian
>*>(
1317 mips16_call_fp_stub_
);
1320 // Set MIPS16 call_fp stub for a symbol.
1322 set_mips16_call_fp_stub(Mips16_stub_section_base
* stub
)
1323 { this->mips16_call_fp_stub_
= stub
; }
1325 // Return whether symbol has MIPS16 call_fp stub.
1327 has_mips16_call_fp_stub() const
1328 { return this->mips16_call_fp_stub_
!= NULL
; }
1331 get_applied_secondary_got_fixup() const
1332 { return applied_secondary_got_fixup_
; }
1335 set_applied_secondary_got_fixup()
1336 { this->applied_secondary_got_fixup_
= true; }
1338 // Return the hash of this symbol.
1342 return gold::string_hash
<char>(this->name());
1346 // Whether the symbol needs MIPS16 fn_stub. This is true if this symbol
1347 // appears in any relocs other than a 16 bit call.
1350 // True if this symbol is referenced by branch relocations from
1351 // any non-PIC input file. This is used to determine whether an
1352 // la25 stub is required.
1353 bool has_nonpic_branches_
;
1355 // The offset of the la25 stub for this symbol from the start of the
1356 // la25 stub section.
1357 unsigned int la25_stub_offset_
;
1359 // True if there is a relocation against this symbol that must be
1360 // resolved by the static linker (that is, the relocation cannot
1361 // possibly be made dynamic).
1362 bool has_static_relocs_
;
1364 // Whether we must not create a lazy-binding stub for this symbol.
1365 // This is true if the symbol has relocations related to taking the
1366 // function's address.
1369 // The offset of the lazy-binding stub for this symbol from the start of
1370 // .MIPS.stubs section.
1371 unsigned int lazy_stub_offset_
;
1373 // True if there are any relocations for this symbol where pointer equality
1375 bool pointer_equality_needed_
;
1377 // Global GOT area where this symbol in located, or GGA_NONE if symbol is not
1378 // in the global part of the GOT.
1379 Global_got_area global_got_area_
;
1381 // The global GOT offset for this symbol. For multi-GOT links, this is offset
1382 // from the start of .got section to the first GOT entry for the symbol.
1383 // Note that in multi-GOT links the symbol can have entry in more than one GOT.
1384 unsigned int global_gotoffset_
;
1386 // Whether all GOT relocations for this symbol are for calls.
1387 bool got_only_for_calls_
;
1388 // Whether the symbol has lazy-binding stub.
1389 bool has_lazy_stub_
;
1390 // Whether the symbol needs a standard PLT entry.
1391 bool needs_mips_plt_
;
1392 // Whether the symbol needs a compressed (MIPS16 or microMIPS) PLT entry.
1393 bool needs_comp_plt_
;
1394 // Standard PLT entry offset, or -1 if none.
1395 unsigned int mips_plt_offset_
;
1396 // Compressed (MIPS16 or microMIPS) PLT entry offset, or -1 if none.
1397 unsigned int comp_plt_offset_
;
1398 // MIPS16 fn stub for a symbol.
1399 Mips16_stub_section_base
* mips16_fn_stub_
;
1400 // MIPS16 call stub for a symbol.
1401 Mips16_stub_section_base
* mips16_call_stub_
;
1402 // MIPS16 call_fp stub for a symbol.
1403 Mips16_stub_section_base
* mips16_call_fp_stub_
;
1405 bool applied_secondary_got_fixup_
;
1408 // Mips16_stub_section class.
1410 // The mips16 compiler uses a couple of special sections to handle
1411 // floating point arguments.
1413 // Section names that look like .mips16.fn.FNNAME contain stubs that
1414 // copy floating point arguments from the fp regs to the gp regs and
1415 // then jump to FNNAME. If any 32 bit function calls FNNAME, the
1416 // call should be redirected to the stub instead. If no 32 bit
1417 // function calls FNNAME, the stub should be discarded. We need to
1418 // consider any reference to the function, not just a call, because
1419 // if the address of the function is taken we will need the stub,
1420 // since the address might be passed to a 32 bit function.
1422 // Section names that look like .mips16.call.FNNAME contain stubs
1423 // that copy floating point arguments from the gp regs to the fp
1424 // regs and then jump to FNNAME. If FNNAME is a 32 bit function,
1425 // then any 16 bit function that calls FNNAME should be redirected
1426 // to the stub instead. If FNNAME is not a 32 bit function, the
1427 // stub should be discarded.
1429 // .mips16.call.fp.FNNAME sections are similar, but contain stubs
1430 // which call FNNAME and then copy the return value from the fp regs
1431 // to the gp regs. These stubs store the return address in $18 while
1432 // calling FNNAME; any function which might call one of these stubs
1433 // must arrange to save $18 around the call. (This case is not
1434 // needed for 32 bit functions that call 16 bit functions, because
1435 // 16 bit functions always return floating point values in both
1436 // $f0/$f1 and $2/$3.)
1438 // Note that in all cases FNNAME might be defined statically.
1439 // Therefore, FNNAME is not used literally. Instead, the relocation
1440 // information will indicate which symbol the section is for.
1442 // We record any stubs that we find in the symbol table.
1444 // TODO(sasa): All mips16 stub sections should be emitted in the .text section.
1446 class Mips16_stub_section_base
{ };
1448 template<int size
, bool big_endian
>
1449 class Mips16_stub_section
: public Mips16_stub_section_base
1451 typedef typename
elfcpp::Elf_types
<size
>::Elf_Addr Mips_address
;
1454 Mips16_stub_section(Mips_relobj
<size
, big_endian
>* object
, unsigned int shndx
)
1455 : object_(object
), shndx_(shndx
), r_sym_(0), gsym_(NULL
),
1456 found_r_mips_none_(false)
1458 gold_assert(object
->is_mips16_fn_stub_section(shndx
)
1459 || object
->is_mips16_call_stub_section(shndx
)
1460 || object
->is_mips16_call_fp_stub_section(shndx
));
1463 // Return the object of this stub section.
1464 Mips_relobj
<size
, big_endian
>*
1466 { return this->object_
; }
1468 // Return the size of a section.
1470 section_size() const
1471 { return this->object_
->section_size(this->shndx_
); }
1473 // Return section index of this stub section.
1476 { return this->shndx_
; }
1478 // Return symbol index, if stub is for a local function.
1481 { return this->r_sym_
; }
1483 // Return symbol, if stub is for a global function.
1486 { return this->gsym_
; }
1488 // Return whether stub is for a local function.
1490 is_for_local_function() const
1491 { return this->gsym_
== NULL
; }
1493 // This method is called when a new relocation R_TYPE for local symbol R_SYM
1494 // is found in the stub section. Try to find stub target.
1496 new_local_reloc_found(unsigned int r_type
, unsigned int r_sym
)
1498 // To find target symbol for this stub, trust the first R_MIPS_NONE
1499 // relocation, if any. Otherwise trust the first relocation, whatever
1501 if (this->found_r_mips_none_
)
1503 if (r_type
== elfcpp::R_MIPS_NONE
)
1505 this->r_sym_
= r_sym
;
1507 this->found_r_mips_none_
= true;
1509 else if (!is_target_found())
1510 this->r_sym_
= r_sym
;
1513 // This method is called when a new relocation R_TYPE for global symbol GSYM
1514 // is found in the stub section. Try to find stub target.
1516 new_global_reloc_found(unsigned int r_type
, Mips_symbol
<size
>* gsym
)
1518 // To find target symbol for this stub, trust the first R_MIPS_NONE
1519 // relocation, if any. Otherwise trust the first relocation, whatever
1521 if (this->found_r_mips_none_
)
1523 if (r_type
== elfcpp::R_MIPS_NONE
)
1527 this->found_r_mips_none_
= true;
1529 else if (!is_target_found())
1533 // Return whether we found the stub target.
1535 is_target_found() const
1536 { return this->r_sym_
!= 0 || this->gsym_
!= NULL
; }
1538 // Return whether this is a fn stub.
1541 { return this->object_
->is_mips16_fn_stub_section(this->shndx_
); }
1543 // Return whether this is a call stub.
1545 is_call_stub() const
1546 { return this->object_
->is_mips16_call_stub_section(this->shndx_
); }
1548 // Return whether this is a call_fp stub.
1550 is_call_fp_stub() const
1551 { return this->object_
->is_mips16_call_fp_stub_section(this->shndx_
); }
1553 // Return the output address.
1555 output_address() const
1557 return (this->object_
->output_section(this->shndx_
)->address()
1558 + this->object_
->output_section_offset(this->shndx_
));
1562 // The object of this stub section.
1563 Mips_relobj
<size
, big_endian
>* object_
;
1564 // The section index of this stub section.
1565 unsigned int shndx_
;
1566 // The symbol index, if stub is for a local function.
1567 unsigned int r_sym_
;
1568 // The symbol, if stub is for a global function.
1569 Mips_symbol
<size
>* gsym_
;
1570 // True if we found R_MIPS_NONE relocation in this stub.
1571 bool found_r_mips_none_
;
1574 // Mips_relobj class.
1576 template<int size
, bool big_endian
>
1577 class Mips_relobj
: public Sized_relobj_file
<size
, big_endian
>
1579 typedef typename
elfcpp::Elf_types
<size
>::Elf_Addr Mips_address
;
1580 typedef std::map
<unsigned int, Mips16_stub_section
<size
, big_endian
>*>
1581 Mips16_stubs_int_map
;
1582 typedef typename
elfcpp::Swap
<size
, big_endian
>::Valtype Valtype
;
1585 Mips_relobj(const std::string
& name
, Input_file
* input_file
, off_t offset
,
1586 const typename
elfcpp::Ehdr
<size
, big_endian
>& ehdr
)
1587 : Sized_relobj_file
<size
, big_endian
>(name
, input_file
, offset
, ehdr
),
1588 processor_specific_flags_(0), local_symbol_is_mips16_(),
1589 local_symbol_is_micromips_(), mips16_stub_sections_(),
1590 local_non_16bit_calls_(), local_16bit_calls_(), local_mips16_fn_stubs_(),
1591 local_mips16_call_stubs_(), gp_(0), has_reginfo_section_(false),
1592 got_info_(NULL
), section_is_mips16_fn_stub_(),
1593 section_is_mips16_call_stub_(), section_is_mips16_call_fp_stub_(),
1594 pdr_shndx_(-1U), attributes_section_data_(NULL
), abiflags_(NULL
),
1595 gprmask_(0), cprmask1_(0), cprmask2_(0), cprmask3_(0), cprmask4_(0)
1597 this->is_pic_
= (ehdr
.get_e_flags() & elfcpp::EF_MIPS_PIC
) != 0;
1598 this->is_n32_
= elfcpp::abi_n32(ehdr
.get_e_flags());
1602 { delete this->attributes_section_data_
; }
1604 // Downcast a base pointer to a Mips_relobj pointer. This is
1605 // not type-safe but we only use Mips_relobj not the base class.
1606 static Mips_relobj
<size
, big_endian
>*
1607 as_mips_relobj(Relobj
* relobj
)
1608 { return static_cast<Mips_relobj
<size
, big_endian
>*>(relobj
); }
1610 // Downcast a base pointer to a Mips_relobj pointer. This is
1611 // not type-safe but we only use Mips_relobj not the base class.
1612 static const Mips_relobj
<size
, big_endian
>*
1613 as_mips_relobj(const Relobj
* relobj
)
1614 { return static_cast<const Mips_relobj
<size
, big_endian
>*>(relobj
); }
1616 // Processor-specific flags in ELF file header. This is valid only after
1619 processor_specific_flags() const
1620 { return this->processor_specific_flags_
; }
1622 // Whether a local symbol is MIPS16 symbol. R_SYM is the symbol table
1623 // index. This is only valid after do_count_local_symbol is called.
1625 local_symbol_is_mips16(unsigned int r_sym
) const
1627 gold_assert(r_sym
< this->local_symbol_is_mips16_
.size());
1628 return this->local_symbol_is_mips16_
[r_sym
];
1631 // Whether a local symbol is microMIPS symbol. R_SYM is the symbol table
1632 // index. This is only valid after do_count_local_symbol is called.
1634 local_symbol_is_micromips(unsigned int r_sym
) const
1636 gold_assert(r_sym
< this->local_symbol_is_micromips_
.size());
1637 return this->local_symbol_is_micromips_
[r_sym
];
1640 // Get or create MIPS16 stub section.
1641 Mips16_stub_section
<size
, big_endian
>*
1642 get_mips16_stub_section(unsigned int shndx
)
1644 typename
Mips16_stubs_int_map::const_iterator it
=
1645 this->mips16_stub_sections_
.find(shndx
);
1646 if (it
!= this->mips16_stub_sections_
.end())
1647 return (*it
).second
;
1649 Mips16_stub_section
<size
, big_endian
>* stub_section
=
1650 new Mips16_stub_section
<size
, big_endian
>(this, shndx
);
1651 this->mips16_stub_sections_
.insert(
1652 std::pair
<unsigned int, Mips16_stub_section
<size
, big_endian
>*>(
1653 stub_section
->shndx(), stub_section
));
1654 return stub_section
;
1657 // Return MIPS16 fn stub section for local symbol R_SYM, or NULL if this
1658 // object doesn't have fn stub for R_SYM.
1659 Mips16_stub_section
<size
, big_endian
>*
1660 get_local_mips16_fn_stub(unsigned int r_sym
) const
1662 typename
Mips16_stubs_int_map::const_iterator it
=
1663 this->local_mips16_fn_stubs_
.find(r_sym
);
1664 if (it
!= this->local_mips16_fn_stubs_
.end())
1665 return (*it
).second
;
1669 // Record that this object has MIPS16 fn stub for local symbol. This method
1670 // is only called if we decided not to discard the stub.
1672 add_local_mips16_fn_stub(Mips16_stub_section
<size
, big_endian
>* stub
)
1674 gold_assert(stub
->is_for_local_function());
1675 unsigned int r_sym
= stub
->r_sym();
1676 this->local_mips16_fn_stubs_
.insert(
1677 std::pair
<unsigned int, Mips16_stub_section
<size
, big_endian
>*>(
1681 // Return MIPS16 call stub section for local symbol R_SYM, or NULL if this
1682 // object doesn't have call stub for R_SYM.
1683 Mips16_stub_section
<size
, big_endian
>*
1684 get_local_mips16_call_stub(unsigned int r_sym
) const
1686 typename
Mips16_stubs_int_map::const_iterator it
=
1687 this->local_mips16_call_stubs_
.find(r_sym
);
1688 if (it
!= this->local_mips16_call_stubs_
.end())
1689 return (*it
).second
;
1693 // Record that this object has MIPS16 call stub for local symbol. This method
1694 // is only called if we decided not to discard the stub.
1696 add_local_mips16_call_stub(Mips16_stub_section
<size
, big_endian
>* stub
)
1698 gold_assert(stub
->is_for_local_function());
1699 unsigned int r_sym
= stub
->r_sym();
1700 this->local_mips16_call_stubs_
.insert(
1701 std::pair
<unsigned int, Mips16_stub_section
<size
, big_endian
>*>(
1705 // Record that we found "non 16-bit" call relocation against local symbol
1706 // SYMNDX. This reloc would need to refer to a MIPS16 fn stub, if there
1709 add_local_non_16bit_call(unsigned int symndx
)
1710 { this->local_non_16bit_calls_
.insert(symndx
); }
1712 // Return true if there is any "non 16-bit" call relocation against local
1713 // symbol SYMNDX in this object.
1715 has_local_non_16bit_call_relocs(unsigned int symndx
)
1717 return (this->local_non_16bit_calls_
.find(symndx
)
1718 != this->local_non_16bit_calls_
.end());
1721 // Record that we found 16-bit call relocation R_MIPS16_26 against local
1722 // symbol SYMNDX. Local MIPS16 call or call_fp stubs will only be needed
1723 // if there is some R_MIPS16_26 relocation that refers to the stub symbol.
1725 add_local_16bit_call(unsigned int symndx
)
1726 { this->local_16bit_calls_
.insert(symndx
); }
1728 // Return true if there is any 16-bit call relocation R_MIPS16_26 against local
1729 // symbol SYMNDX in this object.
1731 has_local_16bit_call_relocs(unsigned int symndx
)
1733 return (this->local_16bit_calls_
.find(symndx
)
1734 != this->local_16bit_calls_
.end());
1737 // Get gp value that was used to create this object.
1740 { return this->gp_
; }
1742 // Return whether the object is a PIC object.
1745 { return this->is_pic_
; }
1747 // Return whether the object uses N32 ABI.
1750 { return this->is_n32_
; }
1752 // Return whether the object uses N64 ABI.
1755 { return size
== 64; }
1757 // Return whether the object uses NewABI conventions.
1760 { return this->is_n32() || this->is_n64(); }
1762 // Return Mips_got_info for this object.
1763 Mips_got_info
<size
, big_endian
>*
1764 get_got_info() const
1765 { return this->got_info_
; }
1767 // Return Mips_got_info for this object. Create new info if it doesn't exist.
1768 Mips_got_info
<size
, big_endian
>*
1769 get_or_create_got_info()
1771 if (!this->got_info_
)
1772 this->got_info_
= new Mips_got_info
<size
, big_endian
>();
1773 return this->got_info_
;
1776 // Set Mips_got_info for this object.
1778 set_got_info(Mips_got_info
<size
, big_endian
>* got_info
)
1779 { this->got_info_
= got_info
; }
1781 // Whether a section SHDNX is a MIPS16 stub section. This is only valid
1782 // after do_read_symbols is called.
1784 is_mips16_stub_section(unsigned int shndx
)
1786 return (is_mips16_fn_stub_section(shndx
)
1787 || is_mips16_call_stub_section(shndx
)
1788 || is_mips16_call_fp_stub_section(shndx
));
1791 // Return TRUE if relocations in section SHNDX can refer directly to a
1792 // MIPS16 function rather than to a hard-float stub. This is only valid
1793 // after do_read_symbols is called.
1795 section_allows_mips16_refs(unsigned int shndx
)
1797 return (this->is_mips16_stub_section(shndx
) || shndx
== this->pdr_shndx_
);
1800 // Whether a section SHDNX is a MIPS16 fn stub section. This is only valid
1801 // after do_read_symbols is called.
1803 is_mips16_fn_stub_section(unsigned int shndx
)
1805 gold_assert(shndx
< this->section_is_mips16_fn_stub_
.size());
1806 return this->section_is_mips16_fn_stub_
[shndx
];
1809 // Whether a section SHDNX is a MIPS16 call stub section. This is only valid
1810 // after do_read_symbols is called.
1812 is_mips16_call_stub_section(unsigned int shndx
)
1814 gold_assert(shndx
< this->section_is_mips16_call_stub_
.size());
1815 return this->section_is_mips16_call_stub_
[shndx
];
1818 // Whether a section SHDNX is a MIPS16 call_fp stub section. This is only
1819 // valid after do_read_symbols is called.
1821 is_mips16_call_fp_stub_section(unsigned int shndx
)
1823 gold_assert(shndx
< this->section_is_mips16_call_fp_stub_
.size());
1824 return this->section_is_mips16_call_fp_stub_
[shndx
];
1827 // Discard MIPS16 stub secions that are not needed.
1829 discard_mips16_stub_sections(Symbol_table
* symtab
);
1831 // Return whether there is a .reginfo section.
1833 has_reginfo_section() const
1834 { return this->has_reginfo_section_
; }
1836 // Return gprmask from the .reginfo section of this object.
1839 { return this->gprmask_
; }
1841 // Return cprmask1 from the .reginfo section of this object.
1844 { return this->cprmask1_
; }
1846 // Return cprmask2 from the .reginfo section of this object.
1849 { return this->cprmask2_
; }
1851 // Return cprmask3 from the .reginfo section of this object.
1854 { return this->cprmask3_
; }
1856 // Return cprmask4 from the .reginfo section of this object.
1859 { return this->cprmask4_
; }
1861 // This is the contents of the .MIPS.abiflags section if there is one.
1862 Mips_abiflags
<big_endian
>*
1864 { return this->abiflags_
; }
1866 // This is the contents of the .gnu.attribute section if there is one.
1867 const Attributes_section_data
*
1868 attributes_section_data() const
1869 { return this->attributes_section_data_
; }
1872 // Count the local symbols.
1874 do_count_local_symbols(Stringpool_template
<char>*,
1875 Stringpool_template
<char>*);
1877 // Read the symbol information.
1879 do_read_symbols(Read_symbols_data
* sd
);
1882 // The name of the options section.
1883 const char* mips_elf_options_section_name()
1884 { return this->is_newabi() ? ".MIPS.options" : ".options"; }
1886 // processor-specific flags in ELF file header.
1887 elfcpp::Elf_Word processor_specific_flags_
;
1889 // Bit vector to tell if a local symbol is a MIPS16 symbol or not.
1890 // This is only valid after do_count_local_symbol is called.
1891 std::vector
<bool> local_symbol_is_mips16_
;
1893 // Bit vector to tell if a local symbol is a microMIPS symbol or not.
1894 // This is only valid after do_count_local_symbol is called.
1895 std::vector
<bool> local_symbol_is_micromips_
;
1897 // Map from section index to the MIPS16 stub for that section. This contains
1898 // all stubs found in this object.
1899 Mips16_stubs_int_map mips16_stub_sections_
;
1901 // Local symbols that have "non 16-bit" call relocation. This relocation
1902 // would need to refer to a MIPS16 fn stub, if there is one.
1903 std::set
<unsigned int> local_non_16bit_calls_
;
1905 // Local symbols that have 16-bit call relocation R_MIPS16_26. Local MIPS16
1906 // call or call_fp stubs will only be needed if there is some R_MIPS16_26
1907 // relocation that refers to the stub symbol.
1908 std::set
<unsigned int> local_16bit_calls_
;
1910 // Map from local symbol index to the MIPS16 fn stub for that symbol.
1911 // This contains only the stubs that we decided not to discard.
1912 Mips16_stubs_int_map local_mips16_fn_stubs_
;
1914 // Map from local symbol index to the MIPS16 call stub for that symbol.
1915 // This contains only the stubs that we decided not to discard.
1916 Mips16_stubs_int_map local_mips16_call_stubs_
;
1918 // gp value that was used to create this object.
1920 // Whether the object is a PIC object.
1922 // Whether the object uses N32 ABI.
1924 // Whether the object contains a .reginfo section.
1925 bool has_reginfo_section_
: 1;
1926 // The Mips_got_info for this object.
1927 Mips_got_info
<size
, big_endian
>* got_info_
;
1929 // Bit vector to tell if a section is a MIPS16 fn stub section or not.
1930 // This is only valid after do_read_symbols is called.
1931 std::vector
<bool> section_is_mips16_fn_stub_
;
1933 // Bit vector to tell if a section is a MIPS16 call stub section or not.
1934 // This is only valid after do_read_symbols is called.
1935 std::vector
<bool> section_is_mips16_call_stub_
;
1937 // Bit vector to tell if a section is a MIPS16 call_fp stub section or not.
1938 // This is only valid after do_read_symbols is called.
1939 std::vector
<bool> section_is_mips16_call_fp_stub_
;
1941 // .pdr section index.
1942 unsigned int pdr_shndx_
;
1944 // Object attributes if there is a .gnu.attributes section or NULL.
1945 Attributes_section_data
* attributes_section_data_
;
1947 // Object abiflags if there is a .MIPS.abiflags section or NULL.
1948 Mips_abiflags
<big_endian
>* abiflags_
;
1950 // gprmask from the .reginfo section of this object.
1952 // cprmask1 from the .reginfo section of this object.
1954 // cprmask2 from the .reginfo section of this object.
1956 // cprmask3 from the .reginfo section of this object.
1958 // cprmask4 from the .reginfo section of this object.
1962 // Mips_output_data_got class.
1964 template<int size
, bool big_endian
>
1965 class Mips_output_data_got
: public Output_data_got
<size
, big_endian
>
1967 typedef typename
elfcpp::Elf_types
<size
>::Elf_Addr Mips_address
;
1968 typedef Output_data_reloc
<elfcpp::SHT_REL
, true, size
, big_endian
>
1970 typedef typename
elfcpp::Swap
<size
, big_endian
>::Valtype Valtype
;
1973 Mips_output_data_got(Target_mips
<size
, big_endian
>* target
,
1974 Symbol_table
* symtab
, Layout
* layout
)
1975 : Output_data_got
<size
, big_endian
>(), target_(target
),
1976 symbol_table_(symtab
), layout_(layout
), static_relocs_(), got_view_(NULL
),
1977 first_global_got_dynsym_index_(-1U), primary_got_(NULL
),
1978 secondary_got_relocs_()
1980 this->master_got_info_
= new Mips_got_info
<size
, big_endian
>();
1981 this->set_addralign(16);
1984 // Reserve GOT entry for a GOT relocation of type R_TYPE against symbol
1985 // SYMNDX + ADDEND, where SYMNDX is a local symbol in section SHNDX in OBJECT.
1987 record_local_got_symbol(Mips_relobj
<size
, big_endian
>* object
,
1988 unsigned int symndx
, Mips_address addend
,
1989 unsigned int r_type
, unsigned int shndx
,
1990 bool is_section_symbol
)
1992 this->master_got_info_
->record_local_got_symbol(object
, symndx
, addend
,
1997 // Reserve GOT entry for a GOT relocation of type R_TYPE against MIPS_SYM,
1998 // in OBJECT. FOR_CALL is true if the caller is only interested in
1999 // using the GOT entry for calls. DYN_RELOC is true if R_TYPE is a dynamic
2002 record_global_got_symbol(Mips_symbol
<size
>* mips_sym
,
2003 Mips_relobj
<size
, big_endian
>* object
,
2004 unsigned int r_type
, bool dyn_reloc
, bool for_call
)
2006 this->master_got_info_
->record_global_got_symbol(mips_sym
, object
, r_type
,
2007 dyn_reloc
, for_call
);
2010 // Record that OBJECT has a page relocation against symbol SYMNDX and
2011 // that ADDEND is the addend for that relocation.
2013 record_got_page_entry(Mips_relobj
<size
, big_endian
>* object
,
2014 unsigned int symndx
, int addend
)
2015 { this->master_got_info_
->record_got_page_entry(object
, symndx
, addend
); }
2017 // Add a static entry for the GOT entry at OFFSET. GSYM is a global
2018 // symbol and R_TYPE is the code of a dynamic relocation that needs to be
2019 // applied in a static link.
2021 add_static_reloc(unsigned int got_offset
, unsigned int r_type
,
2022 Mips_symbol
<size
>* gsym
)
2023 { this->static_relocs_
.push_back(Static_reloc(got_offset
, r_type
, gsym
)); }
2025 // Add a static reloc for the GOT entry at OFFSET. RELOBJ is an object
2026 // defining a local symbol with INDEX. R_TYPE is the code of a dynamic
2027 // relocation that needs to be applied in a static link.
2029 add_static_reloc(unsigned int got_offset
, unsigned int r_type
,
2030 Sized_relobj_file
<size
, big_endian
>* relobj
,
2033 this->static_relocs_
.push_back(Static_reloc(got_offset
, r_type
, relobj
,
2037 // Record that global symbol GSYM has R_TYPE dynamic relocation in the
2038 // secondary GOT at OFFSET.
2040 add_secondary_got_reloc(unsigned int got_offset
, unsigned int r_type
,
2041 Mips_symbol
<size
>* gsym
)
2043 this->secondary_got_relocs_
.push_back(Static_reloc(got_offset
,
2047 // Update GOT entry at OFFSET with VALUE.
2049 update_got_entry(unsigned int offset
, Mips_address value
)
2051 elfcpp::Swap
<size
, big_endian
>::writeval(this->got_view_
+ offset
, value
);
2054 // Return the number of entries in local part of the GOT. This includes
2055 // local entries, page entries and 2 reserved entries.
2057 get_local_gotno() const
2059 if (!this->multi_got())
2061 return (2 + this->master_got_info_
->local_gotno()
2062 + this->master_got_info_
->page_gotno());
2065 return 2 + this->primary_got_
->local_gotno() + this->primary_got_
->page_gotno();
2068 // Return dynamic symbol table index of the first symbol with global GOT
2071 first_global_got_dynsym_index() const
2072 { return this->first_global_got_dynsym_index_
; }
2074 // Set dynamic symbol table index of the first symbol with global GOT entry.
2076 set_first_global_got_dynsym_index(unsigned int index
)
2077 { this->first_global_got_dynsym_index_
= index
; }
2079 // Lay out the GOT. Add local, global and TLS entries. If GOT is
2080 // larger than 64K, create multi-GOT.
2082 lay_out_got(Layout
* layout
, Symbol_table
* symtab
,
2083 const Input_objects
* input_objects
);
2085 // Create multi-GOT. For every GOT, add local, global and TLS entries.
2087 lay_out_multi_got(Layout
* layout
, const Input_objects
* input_objects
);
2089 // Attempt to merge GOTs of different input objects.
2091 merge_gots(const Input_objects
* input_objects
);
2093 // Consider merging FROM, which is OBJECT's GOT, into TO. Return false if
2094 // this would lead to overflow, true if they were merged successfully.
2096 merge_got_with(Mips_got_info
<size
, big_endian
>* from
,
2097 Mips_relobj
<size
, big_endian
>* object
,
2098 Mips_got_info
<size
, big_endian
>* to
);
2100 // Return the offset of GOT page entry for VALUE. For multi-GOT links,
2101 // use OBJECT's GOT.
2103 get_got_page_offset(Mips_address value
,
2104 const Mips_relobj
<size
, big_endian
>* object
)
2106 Mips_got_info
<size
, big_endian
>* g
= (!this->multi_got()
2107 ? this->master_got_info_
2108 : object
->get_got_info());
2109 gold_assert(g
!= NULL
);
2110 return g
->get_got_page_offset(value
, this);
2113 // Return the GOT offset of type GOT_TYPE of the global symbol
2114 // GSYM. For multi-GOT links, use OBJECT's GOT.
2115 unsigned int got_offset(const Symbol
* gsym
, unsigned int got_type
,
2116 Mips_relobj
<size
, big_endian
>* object
) const
2118 if (!this->multi_got())
2119 return gsym
->got_offset(got_type
);
2122 Mips_got_info
<size
, big_endian
>* g
= object
->get_got_info();
2123 gold_assert(g
!= NULL
);
2124 return gsym
->got_offset(g
->multigot_got_type(got_type
));
2128 // Return the GOT offset of type GOT_TYPE of the local symbol
2131 got_offset(unsigned int symndx
, unsigned int got_type
,
2132 Sized_relobj_file
<size
, big_endian
>* object
,
2133 uint64_t addend
) const
2134 { return object
->local_got_offset(symndx
, got_type
, addend
); }
2136 // Return the offset of TLS LDM entry. For multi-GOT links, use OBJECT's GOT.
2138 tls_ldm_offset(Mips_relobj
<size
, big_endian
>* object
) const
2140 Mips_got_info
<size
, big_endian
>* g
= (!this->multi_got()
2141 ? this->master_got_info_
2142 : object
->get_got_info());
2143 gold_assert(g
!= NULL
);
2144 return g
->tls_ldm_offset();
2147 // Set the offset of TLS LDM entry. For multi-GOT links, use OBJECT's GOT.
2149 set_tls_ldm_offset(unsigned int tls_ldm_offset
,
2150 Mips_relobj
<size
, big_endian
>* object
)
2152 Mips_got_info
<size
, big_endian
>* g
= (!this->multi_got()
2153 ? this->master_got_info_
2154 : object
->get_got_info());
2155 gold_assert(g
!= NULL
);
2156 g
->set_tls_ldm_offset(tls_ldm_offset
);
2159 // Return true for multi-GOT links.
2162 { return this->primary_got_
!= NULL
; }
2164 // Return the offset of OBJECT's GOT from the start of .got section.
2166 get_got_offset(const Mips_relobj
<size
, big_endian
>* object
)
2168 if (!this->multi_got())
2172 Mips_got_info
<size
, big_endian
>* g
= object
->get_got_info();
2173 return g
!= NULL
? g
->offset() : 0;
2177 // Create global GOT entries that should be in the GGA_RELOC_ONLY area.
2179 add_reloc_only_entries()
2180 { this->master_got_info_
->add_reloc_only_entries(this); }
2182 // Return offset of the primary GOT's entry for global symbol.
2184 get_primary_got_offset(const Mips_symbol
<size
>* sym
) const
2186 gold_assert(sym
->global_got_area() != GGA_NONE
);
2187 return (this->get_local_gotno() + sym
->dynsym_index()
2188 - this->first_global_got_dynsym_index()) * size
/8;
2191 // For the entry at offset GOT_OFFSET, return its offset from the gp.
2192 // Input argument GOT_OFFSET is always global offset from the start of
2193 // .got section, for both single and multi-GOT links.
2194 // For single GOT links, this returns GOT_OFFSET - 0x7FF0. For multi-GOT
2195 // links, the return value is object_got_offset - 0x7FF0, where
2196 // object_got_offset is offset in the OBJECT's GOT.
2198 gp_offset(unsigned int got_offset
,
2199 const Mips_relobj
<size
, big_endian
>* object
) const
2201 return (this->address() + got_offset
2202 - this->target_
->adjusted_gp_value(object
));
2206 // Write out the GOT table.
2208 do_write(Output_file
*);
2212 // This class represent dynamic relocations that need to be applied by
2213 // gold because we are using TLS relocations in a static link.
2217 Static_reloc(unsigned int got_offset
, unsigned int r_type
,
2218 Mips_symbol
<size
>* gsym
)
2219 : got_offset_(got_offset
), r_type_(r_type
), symbol_is_global_(true)
2220 { this->u_
.global
.symbol
= gsym
; }
2222 Static_reloc(unsigned int got_offset
, unsigned int r_type
,
2223 Sized_relobj_file
<size
, big_endian
>* relobj
, unsigned int index
)
2224 : got_offset_(got_offset
), r_type_(r_type
), symbol_is_global_(false)
2226 this->u_
.local
.relobj
= relobj
;
2227 this->u_
.local
.index
= index
;
2230 // Return the GOT offset.
2233 { return this->got_offset_
; }
2238 { return this->r_type_
; }
2240 // Whether the symbol is global or not.
2242 symbol_is_global() const
2243 { return this->symbol_is_global_
; }
2245 // For a relocation against a global symbol, the global symbol.
2249 gold_assert(this->symbol_is_global_
);
2250 return this->u_
.global
.symbol
;
2253 // For a relocation against a local symbol, the defining object.
2254 Sized_relobj_file
<size
, big_endian
>*
2257 gold_assert(!this->symbol_is_global_
);
2258 return this->u_
.local
.relobj
;
2261 // For a relocation against a local symbol, the local symbol index.
2265 gold_assert(!this->symbol_is_global_
);
2266 return this->u_
.local
.index
;
2270 // GOT offset of the entry to which this relocation is applied.
2271 unsigned int got_offset_
;
2272 // Type of relocation.
2273 unsigned int r_type_
;
2274 // Whether this relocation is against a global symbol.
2275 bool symbol_is_global_
;
2276 // A global or local symbol.
2281 // For a global symbol, the symbol itself.
2282 Mips_symbol
<size
>* symbol
;
2286 // For a local symbol, the object defining object.
2287 Sized_relobj_file
<size
, big_endian
>* relobj
;
2288 // For a local symbol, the symbol index.
2295 Target_mips
<size
, big_endian
>* target_
;
2296 // The symbol table.
2297 Symbol_table
* symbol_table_
;
2300 // Static relocs to be applied to the GOT.
2301 std::vector
<Static_reloc
> static_relocs_
;
2302 // .got section view.
2303 unsigned char* got_view_
;
2304 // The dynamic symbol table index of the first symbol with global GOT entry.
2305 unsigned int first_global_got_dynsym_index_
;
2306 // The master GOT information.
2307 Mips_got_info
<size
, big_endian
>* master_got_info_
;
2308 // The primary GOT information.
2309 Mips_got_info
<size
, big_endian
>* primary_got_
;
2310 // Secondary GOT fixups.
2311 std::vector
<Static_reloc
> secondary_got_relocs_
;
2314 // A class to handle LA25 stubs - non-PIC interface to a PIC function. There are
2315 // two ways of creating these interfaces. The first is to add:
2317 // lui $25,%hi(func)
2319 // addiu $25,$25,%lo(func)
2321 // to a separate trampoline section. The second is to add:
2323 // lui $25,%hi(func)
2324 // addiu $25,$25,%lo(func)
2326 // immediately before a PIC function "func", but only if a function is at the
2327 // beginning of the section, and the section is not too heavily aligned (i.e we
2328 // would need to add no more than 2 nops before the stub.)
2330 // We only create stubs of the first type.
2332 template<int size
, bool big_endian
>
2333 class Mips_output_data_la25_stub
: public Output_section_data
2335 typedef typename
elfcpp::Elf_types
<size
>::Elf_Addr Mips_address
;
2338 Mips_output_data_la25_stub()
2339 : Output_section_data(size
== 32 ? 4 : 8), symbols_()
2342 // Create LA25 stub for a symbol.
2344 create_la25_stub(Symbol_table
* symtab
, Target_mips
<size
, big_endian
>* target
,
2345 Mips_symbol
<size
>* gsym
);
2347 // Return output address of a stub.
2349 stub_address(const Mips_symbol
<size
>* sym
) const
2351 gold_assert(sym
->has_la25_stub());
2352 return this->address() + sym
->la25_stub_offset();
2357 do_adjust_output_section(Output_section
* os
)
2358 { os
->set_entsize(0); }
2361 // Template for standard LA25 stub.
2362 static const uint32_t la25_stub_entry
[];
2363 // Template for microMIPS LA25 stub.
2364 static const uint32_t la25_stub_micromips_entry
[];
2366 // Set the final size.
2368 set_final_data_size()
2369 { this->set_data_size(this->symbols_
.size() * 16); }
2371 // Create a symbol for SYM stub's value and size, to help make the
2372 // disassembly easier to read.
2374 create_stub_symbol(Mips_symbol
<size
>* sym
, Symbol_table
* symtab
,
2375 Target_mips
<size
, big_endian
>* target
, uint64_t symsize
);
2377 // Write to a map file.
2379 do_print_to_mapfile(Mapfile
* mapfile
) const
2380 { mapfile
->print_output_data(this, _(".LA25.stubs")); }
2382 // Write out the LA25 stub section.
2384 do_write(Output_file
*);
2386 // Symbols that have LA25 stubs.
2387 std::vector
<Mips_symbol
<size
>*> symbols_
;
2390 // MIPS-specific relocation writer.
2392 template<int sh_type
, bool dynamic
, int size
, bool big_endian
>
2393 struct Mips_output_reloc_writer
;
2395 template<int sh_type
, bool dynamic
, bool big_endian
>
2396 struct Mips_output_reloc_writer
<sh_type
, dynamic
, 32, big_endian
>
2398 typedef Output_reloc
<sh_type
, dynamic
, 32, big_endian
> Output_reloc_type
;
2399 typedef std::vector
<Output_reloc_type
> Relocs
;
2402 write(typename
Relocs::const_iterator p
, unsigned char* pov
)
2406 template<int sh_type
, bool dynamic
, bool big_endian
>
2407 struct Mips_output_reloc_writer
<sh_type
, dynamic
, 64, big_endian
>
2409 typedef Output_reloc
<sh_type
, dynamic
, 64, big_endian
> Output_reloc_type
;
2410 typedef std::vector
<Output_reloc_type
> Relocs
;
2413 write(typename
Relocs::const_iterator p
, unsigned char* pov
)
2415 elfcpp::Mips64_rel_write
<big_endian
> orel(pov
);
2416 orel
.put_r_offset(p
->get_address());
2417 orel
.put_r_sym(p
->get_symbol_index());
2418 orel
.put_r_ssym(RSS_UNDEF
);
2419 orel
.put_r_type(p
->type());
2420 if (p
->type() == elfcpp::R_MIPS_REL32
)
2421 orel
.put_r_type2(elfcpp::R_MIPS_64
);
2423 orel
.put_r_type2(elfcpp::R_MIPS_NONE
);
2424 orel
.put_r_type3(elfcpp::R_MIPS_NONE
);
2428 template<int sh_type
, bool dynamic
, int size
, bool big_endian
>
2429 class Mips_output_data_reloc
: public Output_data_reloc
<sh_type
, dynamic
,
2433 Mips_output_data_reloc(bool sort_relocs
)
2434 : Output_data_reloc
<sh_type
, dynamic
, size
, big_endian
>(sort_relocs
)
2438 // Write out the data.
2440 do_write(Output_file
* of
)
2442 typedef Mips_output_reloc_writer
<sh_type
, dynamic
, size
,
2444 this->template do_write_generic
<Writer
>(of
);
2449 // A class to handle the PLT data.
2451 template<int size
, bool big_endian
>
2452 class Mips_output_data_plt
: public Output_section_data
2454 typedef typename
elfcpp::Elf_types
<size
>::Elf_Addr Mips_address
;
2455 typedef Mips_output_data_reloc
<elfcpp::SHT_REL
, true,
2456 size
, big_endian
> Reloc_section
;
2459 // Create the PLT section. The ordinary .got section is an argument,
2460 // since we need to refer to the start.
2461 Mips_output_data_plt(Layout
* layout
, Output_data_space
* got_plt
,
2462 Target_mips
<size
, big_endian
>* target
)
2463 : Output_section_data(size
== 32 ? 4 : 8), got_plt_(got_plt
), symbols_(),
2464 plt_mips_offset_(0), plt_comp_offset_(0), plt_header_size_(0),
2467 this->rel_
= new Reloc_section(false);
2468 layout
->add_output_section_data(".rel.plt", elfcpp::SHT_REL
,
2469 elfcpp::SHF_ALLOC
, this->rel_
,
2470 ORDER_DYNAMIC_PLT_RELOCS
, false);
2473 // Add an entry to the PLT for a symbol referenced by r_type relocation.
2475 add_entry(Mips_symbol
<size
>* gsym
, unsigned int r_type
);
2477 // Return the .rel.plt section data.
2480 { return this->rel_
; }
2482 // Return the number of PLT entries.
2485 { return this->symbols_
.size(); }
2487 // Return the offset of the first non-reserved PLT entry.
2489 first_plt_entry_offset() const
2490 { return sizeof(plt0_entry_o32
); }
2492 // Return the size of a PLT entry.
2494 plt_entry_size() const
2495 { return sizeof(plt_entry
); }
2497 // Set final PLT offsets. For each symbol, determine whether standard or
2498 // compressed (MIPS16 or microMIPS) PLT entry is used.
2502 // Return the offset of the first standard PLT entry.
2504 first_mips_plt_offset() const
2505 { return this->plt_header_size_
; }
2507 // Return the offset of the first compressed PLT entry.
2509 first_comp_plt_offset() const
2510 { return this->plt_header_size_
+ this->plt_mips_offset_
; }
2512 // Return whether there are any standard PLT entries.
2514 has_standard_entries() const
2515 { return this->plt_mips_offset_
> 0; }
2517 // Return the output address of standard PLT entry.
2519 mips_entry_address(const Mips_symbol
<size
>* sym
) const
2521 gold_assert (sym
->has_mips_plt_offset());
2522 return (this->address() + this->first_mips_plt_offset()
2523 + sym
->mips_plt_offset());
2526 // Return the output address of compressed (MIPS16 or microMIPS) PLT entry.
2528 comp_entry_address(const Mips_symbol
<size
>* sym
) const
2530 gold_assert (sym
->has_comp_plt_offset());
2531 return (this->address() + this->first_comp_plt_offset()
2532 + sym
->comp_plt_offset());
2537 do_adjust_output_section(Output_section
* os
)
2538 { os
->set_entsize(0); }
2540 // Write to a map file.
2542 do_print_to_mapfile(Mapfile
* mapfile
) const
2543 { mapfile
->print_output_data(this, _(".plt")); }
2546 // Template for the first PLT entry.
2547 static const uint32_t plt0_entry_o32
[];
2548 static const uint32_t plt0_entry_n32
[];
2549 static const uint32_t plt0_entry_n64
[];
2550 static const uint32_t plt0_entry_micromips_o32
[];
2551 static const uint32_t plt0_entry_micromips32_o32
[];
2553 // Template for subsequent PLT entries.
2554 static const uint32_t plt_entry
[];
2555 static const uint32_t plt_entry_r6
[];
2556 static const uint32_t plt_entry_mips16_o32
[];
2557 static const uint32_t plt_entry_micromips_o32
[];
2558 static const uint32_t plt_entry_micromips32_o32
[];
2560 // Set the final size.
2562 set_final_data_size()
2564 this->set_data_size(this->plt_header_size_
+ this->plt_mips_offset_
2565 + this->plt_comp_offset_
);
2568 // Write out the PLT data.
2570 do_write(Output_file
*);
2572 // Return whether the plt header contains microMIPS code. For the sake of
2573 // cache alignment always use a standard header whenever any standard entries
2574 // are present even if microMIPS entries are present as well. This also lets
2575 // the microMIPS header rely on the value of $v0 only set by microMIPS
2576 // entries, for a small size reduction.
2578 is_plt_header_compressed() const
2580 gold_assert(this->plt_mips_offset_
+ this->plt_comp_offset_
!= 0);
2581 return this->target_
->is_output_micromips() && this->plt_mips_offset_
== 0;
2584 // Return the size of the PLT header.
2586 get_plt_header_size() const
2588 if (this->target_
->is_output_n64())
2589 return 4 * sizeof(plt0_entry_n64
) / sizeof(plt0_entry_n64
[0]);
2590 else if (this->target_
->is_output_n32())
2591 return 4 * sizeof(plt0_entry_n32
) / sizeof(plt0_entry_n32
[0]);
2592 else if (!this->is_plt_header_compressed())
2593 return 4 * sizeof(plt0_entry_o32
) / sizeof(plt0_entry_o32
[0]);
2594 else if (this->target_
->use_32bit_micromips_instructions())
2595 return (2 * sizeof(plt0_entry_micromips32_o32
)
2596 / sizeof(plt0_entry_micromips32_o32
[0]));
2598 return (2 * sizeof(plt0_entry_micromips_o32
)
2599 / sizeof(plt0_entry_micromips_o32
[0]));
2602 // Return the PLT header entry.
2604 get_plt_header_entry() const
2606 if (this->target_
->is_output_n64())
2607 return plt0_entry_n64
;
2608 else if (this->target_
->is_output_n32())
2609 return plt0_entry_n32
;
2610 else if (!this->is_plt_header_compressed())
2611 return plt0_entry_o32
;
2612 else if (this->target_
->use_32bit_micromips_instructions())
2613 return plt0_entry_micromips32_o32
;
2615 return plt0_entry_micromips_o32
;
2618 // Return the size of the standard PLT entry.
2620 standard_plt_entry_size() const
2621 { return 4 * sizeof(plt_entry
) / sizeof(plt_entry
[0]); }
2623 // Return the size of the compressed PLT entry.
2625 compressed_plt_entry_size() const
2627 gold_assert(!this->target_
->is_output_newabi());
2629 if (!this->target_
->is_output_micromips())
2630 return (2 * sizeof(plt_entry_mips16_o32
)
2631 / sizeof(plt_entry_mips16_o32
[0]));
2632 else if (this->target_
->use_32bit_micromips_instructions())
2633 return (2 * sizeof(plt_entry_micromips32_o32
)
2634 / sizeof(plt_entry_micromips32_o32
[0]));
2636 return (2 * sizeof(plt_entry_micromips_o32
)
2637 / sizeof(plt_entry_micromips_o32
[0]));
2640 // The reloc section.
2641 Reloc_section
* rel_
;
2642 // The .got.plt section.
2643 Output_data_space
* got_plt_
;
2644 // Symbols that have PLT entry.
2645 std::vector
<Mips_symbol
<size
>*> symbols_
;
2646 // The offset of the next standard PLT entry to create.
2647 unsigned int plt_mips_offset_
;
2648 // The offset of the next compressed PLT entry to create.
2649 unsigned int plt_comp_offset_
;
2650 // The size of the PLT header in bytes.
2651 unsigned int plt_header_size_
;
2653 Target_mips
<size
, big_endian
>* target_
;
2656 // A class to handle the .MIPS.stubs data.
2658 template<int size
, bool big_endian
>
2659 class Mips_output_data_mips_stubs
: public Output_section_data
2661 typedef typename
elfcpp::Elf_types
<size
>::Elf_Addr Mips_address
;
2663 // Unordered set of .MIPS.stubs entries.
2664 typedef Unordered_set
<Mips_symbol
<size
>*, Mips_symbol_hash
<size
> >
2665 Mips_stubs_entry_set
;
2668 Mips_output_data_mips_stubs(Target_mips
<size
, big_endian
>* target
)
2669 : Output_section_data(size
== 32 ? 4 : 8), symbols_(), dynsym_count_(-1U),
2670 stub_offsets_are_set_(false), target_(target
)
2673 // Create entry for a symbol.
2675 make_entry(Mips_symbol
<size
>*);
2677 // Remove entry for a symbol.
2679 remove_entry(Mips_symbol
<size
>* gsym
);
2681 // Set stub offsets for symbols. This method expects that the number of
2682 // entries in dynamic symbol table is set.
2684 set_lazy_stub_offsets();
2687 set_needs_dynsym_value();
2689 // Set the number of entries in dynamic symbol table.
2691 set_dynsym_count(unsigned int dynsym_count
)
2692 { this->dynsym_count_
= dynsym_count
; }
2694 // Return maximum size of the stub, ie. the stub size if the dynamic symbol
2695 // count is greater than 0x10000. If the dynamic symbol count is less than
2696 // 0x10000, the stub will be 4 bytes smaller.
2697 // There's no disadvantage from using microMIPS code here, so for the sake of
2698 // pure-microMIPS binaries we prefer it whenever there's any microMIPS code in
2699 // output produced at all. This has a benefit of stubs being shorter by
2700 // 4 bytes each too, unless in the insn32 mode.
2702 stub_max_size() const
2704 if (!this->target_
->is_output_micromips()
2705 || this->target_
->use_32bit_micromips_instructions())
2711 // Return the size of the stub. This method expects that the final dynsym
2716 gold_assert(this->dynsym_count_
!= -1U);
2717 if (this->dynsym_count_
> 0x10000)
2718 return this->stub_max_size();
2720 return this->stub_max_size() - 4;
2723 // Return output address of a stub.
2725 stub_address(const Mips_symbol
<size
>* sym
) const
2727 gold_assert(sym
->has_lazy_stub());
2728 return this->address() + sym
->lazy_stub_offset();
2733 do_adjust_output_section(Output_section
* os
)
2734 { os
->set_entsize(0); }
2736 // Write to a map file.
2738 do_print_to_mapfile(Mapfile
* mapfile
) const
2739 { mapfile
->print_output_data(this, _(".MIPS.stubs")); }
2742 static const uint32_t lazy_stub_normal_1
[];
2743 static const uint32_t lazy_stub_normal_1_n64
[];
2744 static const uint32_t lazy_stub_normal_2
[];
2745 static const uint32_t lazy_stub_normal_2_n64
[];
2746 static const uint32_t lazy_stub_big
[];
2747 static const uint32_t lazy_stub_big_n64
[];
2749 static const uint32_t lazy_stub_micromips_normal_1
[];
2750 static const uint32_t lazy_stub_micromips_normal_1_n64
[];
2751 static const uint32_t lazy_stub_micromips_normal_2
[];
2752 static const uint32_t lazy_stub_micromips_normal_2_n64
[];
2753 static const uint32_t lazy_stub_micromips_big
[];
2754 static const uint32_t lazy_stub_micromips_big_n64
[];
2756 static const uint32_t lazy_stub_micromips32_normal_1
[];
2757 static const uint32_t lazy_stub_micromips32_normal_1_n64
[];
2758 static const uint32_t lazy_stub_micromips32_normal_2
[];
2759 static const uint32_t lazy_stub_micromips32_normal_2_n64
[];
2760 static const uint32_t lazy_stub_micromips32_big
[];
2761 static const uint32_t lazy_stub_micromips32_big_n64
[];
2763 // Set the final size.
2765 set_final_data_size()
2766 { this->set_data_size(this->symbols_
.size() * this->stub_max_size()); }
2768 // Write out the .MIPS.stubs data.
2770 do_write(Output_file
*);
2772 // .MIPS.stubs symbols
2773 Mips_stubs_entry_set symbols_
;
2774 // Number of entries in dynamic symbol table.
2775 unsigned int dynsym_count_
;
2776 // Whether the stub offsets are set.
2777 bool stub_offsets_are_set_
;
2779 Target_mips
<size
, big_endian
>* target_
;
2782 // This class handles Mips .reginfo output section.
2784 template<int size
, bool big_endian
>
2785 class Mips_output_section_reginfo
: public Output_section_data
2787 typedef typename
elfcpp::Swap
<size
, big_endian
>::Valtype Valtype
;
2790 Mips_output_section_reginfo(Target_mips
<size
, big_endian
>* target
,
2791 Valtype gprmask
, Valtype cprmask1
,
2792 Valtype cprmask2
, Valtype cprmask3
,
2794 : Output_section_data(24, 4, true), target_(target
),
2795 gprmask_(gprmask
), cprmask1_(cprmask1
), cprmask2_(cprmask2
),
2796 cprmask3_(cprmask3
), cprmask4_(cprmask4
)
2800 // Write to a map file.
2802 do_print_to_mapfile(Mapfile
* mapfile
) const
2803 { mapfile
->print_output_data(this, _(".reginfo")); }
2805 // Write out reginfo section.
2807 do_write(Output_file
* of
);
2810 Target_mips
<size
, big_endian
>* target_
;
2812 // gprmask of the output .reginfo section.
2814 // cprmask1 of the output .reginfo section.
2816 // cprmask2 of the output .reginfo section.
2818 // cprmask3 of the output .reginfo section.
2820 // cprmask4 of the output .reginfo section.
2824 // This class handles .MIPS.abiflags output section.
2826 template<int size
, bool big_endian
>
2827 class Mips_output_section_abiflags
: public Output_section_data
2830 Mips_output_section_abiflags(const Mips_abiflags
<big_endian
>& abiflags
)
2831 : Output_section_data(24, 8, true), abiflags_(abiflags
)
2835 // Write to a map file.
2837 do_print_to_mapfile(Mapfile
* mapfile
) const
2838 { mapfile
->print_output_data(this, _(".MIPS.abiflags")); }
2841 do_write(Output_file
* of
);
2844 const Mips_abiflags
<big_endian
>& abiflags_
;
2847 // The MIPS target has relocation types which default handling of relocatable
2848 // relocation cannot process. So we have to extend the default code.
2850 template<bool big_endian
, typename Classify_reloc
>
2851 class Mips_scan_relocatable_relocs
:
2852 public Default_scan_relocatable_relocs
<Classify_reloc
>
2855 // Return the strategy to use for a local symbol which is a section
2856 // symbol, given the relocation type.
2857 inline Relocatable_relocs::Reloc_strategy
2858 local_section_strategy(unsigned int r_type
, Relobj
* object
)
2860 if (Classify_reloc::sh_type
== elfcpp::SHT_RELA
)
2861 return Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_RELA
;
2866 case elfcpp::R_MIPS_26
:
2867 return Relocatable_relocs::RELOC_SPECIAL
;
2870 return Default_scan_relocatable_relocs
<Classify_reloc
>::
2871 local_section_strategy(r_type
, object
);
2877 // Mips_copy_relocs class. The only difference from the base class is the
2878 // method emit_mips, which should be called instead of Copy_reloc_entry::emit.
2879 // Mips cannot convert all relocation types to dynamic relocs. If a reloc
2880 // cannot be made dynamic, a COPY reloc is emitted.
2882 template<int sh_type
, int size
, bool big_endian
>
2883 class Mips_copy_relocs
: public Copy_relocs
<sh_type
, size
, big_endian
>
2887 : Copy_relocs
<sh_type
, size
, big_endian
>(elfcpp::R_MIPS_COPY
)
2890 // Emit any saved relocations which turn out to be needed. This is
2891 // called after all the relocs have been scanned.
2893 emit_mips(Output_data_reloc
<sh_type
, true, size
, big_endian
>*,
2894 Symbol_table
*, Layout
*, Target_mips
<size
, big_endian
>*);
2897 typedef typename Copy_relocs
<sh_type
, size
, big_endian
>::Copy_reloc_entry
2900 // Emit this reloc if appropriate. This is called after we have
2901 // scanned all the relocations, so we know whether we emitted a
2902 // COPY relocation for SYM_.
2904 emit_entry(Copy_reloc_entry
& entry
,
2905 Output_data_reloc
<sh_type
, true, size
, big_endian
>* reloc_section
,
2906 Symbol_table
* symtab
, Layout
* layout
,
2907 Target_mips
<size
, big_endian
>* target
);
2911 // Return true if the symbol SYM should be considered to resolve local
2912 // to the current module, and false otherwise. The logic is taken from
2913 // GNU ld's method _bfd_elf_symbol_refs_local_p.
2915 symbol_refs_local(const Symbol
* sym
, bool has_dynsym_entry
,
2916 bool local_protected
)
2918 // If it's a local sym, of course we resolve locally.
2922 // STV_HIDDEN or STV_INTERNAL ones must be local.
2923 if (sym
->visibility() == elfcpp::STV_HIDDEN
2924 || sym
->visibility() == elfcpp::STV_INTERNAL
)
2927 // If we don't have a definition in a regular file, then we can't
2928 // resolve locally. The sym is either undefined or dynamic.
2929 if (sym
->source() != Symbol::FROM_OBJECT
|| sym
->object()->is_dynamic()
2930 || sym
->is_undefined())
2933 // Forced local symbols resolve locally.
2934 if (sym
->is_forced_local())
2937 // As do non-dynamic symbols.
2938 if (!has_dynsym_entry
)
2941 // At this point, we know the symbol is defined and dynamic. In an
2942 // executable it must resolve locally, likewise when building symbolic
2943 // shared libraries.
2944 if (parameters
->options().output_is_executable()
2945 || parameters
->options().Bsymbolic())
2948 // Now deal with defined dynamic symbols in shared libraries. Ones
2949 // with default visibility might not resolve locally.
2950 if (sym
->visibility() == elfcpp::STV_DEFAULT
)
2953 // STV_PROTECTED non-function symbols are local.
2954 if (sym
->type() != elfcpp::STT_FUNC
)
2957 // Function pointer equality tests may require that STV_PROTECTED
2958 // symbols be treated as dynamic symbols. If the address of a
2959 // function not defined in an executable is set to that function's
2960 // plt entry in the executable, then the address of the function in
2961 // a shared library must also be the plt entry in the executable.
2962 return local_protected
;
2965 // Return TRUE if references to this symbol always reference the symbol in this
2968 symbol_references_local(const Symbol
* sym
, bool has_dynsym_entry
)
2970 return symbol_refs_local(sym
, has_dynsym_entry
, false);
2973 // Return TRUE if calls to this symbol always call the version in this object.
2975 symbol_calls_local(const Symbol
* sym
, bool has_dynsym_entry
)
2977 return symbol_refs_local(sym
, has_dynsym_entry
, true);
2980 // Compare GOT offsets of two symbols.
2982 template<int size
, bool big_endian
>
2984 got_offset_compare(Symbol
* sym1
, Symbol
* sym2
)
2986 Mips_symbol
<size
>* mips_sym1
= Mips_symbol
<size
>::as_mips_sym(sym1
);
2987 Mips_symbol
<size
>* mips_sym2
= Mips_symbol
<size
>::as_mips_sym(sym2
);
2988 unsigned int area1
= mips_sym1
->global_got_area();
2989 unsigned int area2
= mips_sym2
->global_got_area();
2990 gold_assert(area1
!= GGA_NONE
&& area1
!= GGA_NONE
);
2992 // GGA_NORMAL entries always come before GGA_RELOC_ONLY.
2994 return area1
< area2
;
2996 return mips_sym1
->global_gotoffset() < mips_sym2
->global_gotoffset();
2999 // This method divides dynamic symbols into symbols that have GOT entry, and
3000 // symbols that don't have GOT entry. It also sorts symbols with the GOT entry.
3001 // Mips ABI requires that symbols with the GOT entry must be at the end of
3002 // dynamic symbol table, and the order in dynamic symbol table must match the
3005 template<int size
, bool big_endian
>
3007 reorder_dyn_symbols(std::vector
<Symbol
*>* dyn_symbols
,
3008 std::vector
<Symbol
*>* non_got_symbols
,
3009 std::vector
<Symbol
*>* got_symbols
)
3011 for (std::vector
<Symbol
*>::iterator p
= dyn_symbols
->begin();
3012 p
!= dyn_symbols
->end();
3015 Mips_symbol
<size
>* mips_sym
= Mips_symbol
<size
>::as_mips_sym(*p
);
3016 if (mips_sym
->global_got_area() == GGA_NORMAL
3017 || mips_sym
->global_got_area() == GGA_RELOC_ONLY
)
3018 got_symbols
->push_back(mips_sym
);
3020 non_got_symbols
->push_back(mips_sym
);
3023 std::sort(got_symbols
->begin(), got_symbols
->end(),
3024 got_offset_compare
<size
, big_endian
>);
3027 // Functor class for processing the global symbol table.
3029 template<int size
, bool big_endian
>
3030 class Symbol_visitor_check_symbols
3033 Symbol_visitor_check_symbols(Target_mips
<size
, big_endian
>* target
,
3034 Layout
* layout
, Symbol_table
* symtab
)
3035 : target_(target
), layout_(layout
), symtab_(symtab
)
3039 operator()(Sized_symbol
<size
>* sym
)
3041 Mips_symbol
<size
>* mips_sym
= Mips_symbol
<size
>::as_mips_sym(sym
);
3042 if (local_pic_function
<size
, big_endian
>(mips_sym
))
3044 // SYM is a function that might need $25 to be valid on entry.
3045 // If we're creating a non-PIC relocatable object, mark SYM as
3046 // being PIC. If we're creating a non-relocatable object with
3047 // non-PIC branches and jumps to SYM, make sure that SYM has an la25
3049 if (parameters
->options().relocatable())
3051 if (!parameters
->options().output_is_position_independent())
3052 mips_sym
->set_pic();
3054 else if (mips_sym
->has_nonpic_branches())
3056 this->target_
->la25_stub_section(layout_
)
3057 ->create_la25_stub(this->symtab_
, this->target_
, mips_sym
);
3063 Target_mips
<size
, big_endian
>* target_
;
3065 Symbol_table
* symtab_
;
3068 // Relocation types, parameterized by SHT_REL vs. SHT_RELA, size,
3069 // and endianness. The relocation format for MIPS-64 is non-standard.
3071 template<int sh_type
, int size
, bool big_endian
>
3072 struct Mips_reloc_types
;
3074 template<bool big_endian
>
3075 struct Mips_reloc_types
<elfcpp::SHT_REL
, 32, big_endian
>
3077 typedef typename
elfcpp::Rel
<32, big_endian
> Reloc
;
3078 typedef typename
elfcpp::Rel_write
<32, big_endian
> Reloc_write
;
3080 static typename
elfcpp::Elf_types
<32>::Elf_Swxword
3081 get_r_addend(const Reloc
*)
3085 set_reloc_addend(Reloc_write
*,
3086 typename
elfcpp::Elf_types
<32>::Elf_Swxword
)
3087 { gold_unreachable(); }
3090 template<bool big_endian
>
3091 struct Mips_reloc_types
<elfcpp::SHT_RELA
, 32, big_endian
>
3093 typedef typename
elfcpp::Rela
<32, big_endian
> Reloc
;
3094 typedef typename
elfcpp::Rela_write
<32, big_endian
> Reloc_write
;
3096 static typename
elfcpp::Elf_types
<32>::Elf_Swxword
3097 get_r_addend(const Reloc
* reloc
)
3098 { return reloc
->get_r_addend(); }
3101 set_reloc_addend(Reloc_write
* p
,
3102 typename
elfcpp::Elf_types
<32>::Elf_Swxword val
)
3103 { p
->put_r_addend(val
); }
3106 template<bool big_endian
>
3107 struct Mips_reloc_types
<elfcpp::SHT_REL
, 64, big_endian
>
3109 typedef typename
elfcpp::Mips64_rel
<big_endian
> Reloc
;
3110 typedef typename
elfcpp::Mips64_rel_write
<big_endian
> Reloc_write
;
3112 static typename
elfcpp::Elf_types
<64>::Elf_Swxword
3113 get_r_addend(const Reloc
*)
3117 set_reloc_addend(Reloc_write
*,
3118 typename
elfcpp::Elf_types
<64>::Elf_Swxword
)
3119 { gold_unreachable(); }
3122 template<bool big_endian
>
3123 struct Mips_reloc_types
<elfcpp::SHT_RELA
, 64, big_endian
>
3125 typedef typename
elfcpp::Mips64_rela
<big_endian
> Reloc
;
3126 typedef typename
elfcpp::Mips64_rela_write
<big_endian
> Reloc_write
;
3128 static typename
elfcpp::Elf_types
<64>::Elf_Swxword
3129 get_r_addend(const Reloc
* reloc
)
3130 { return reloc
->get_r_addend(); }
3133 set_reloc_addend(Reloc_write
* p
,
3134 typename
elfcpp::Elf_types
<64>::Elf_Swxword val
)
3135 { p
->put_r_addend(val
); }
3138 // Forward declaration.
3140 mips_get_size_for_reloc(unsigned int, Relobj
*);
3142 // A class for inquiring about properties of a relocation,
3143 // used while scanning relocs during a relocatable link and
3144 // garbage collection.
3146 template<int sh_type_
, int size
, bool big_endian
>
3147 class Mips_classify_reloc
;
3149 template<int sh_type_
, bool big_endian
>
3150 class Mips_classify_reloc
<sh_type_
, 32, big_endian
> :
3151 public gold::Default_classify_reloc
<sh_type_
, 32, big_endian
>
3154 typedef typename Mips_reloc_types
<sh_type_
, 32, big_endian
>::Reloc
3156 typedef typename Mips_reloc_types
<sh_type_
, 32, big_endian
>::Reloc_write
3159 // Return the symbol referred to by the relocation.
3160 static inline unsigned int
3161 get_r_sym(const Reltype
* reloc
)
3162 { return elfcpp::elf_r_sym
<32>(reloc
->get_r_info()); }
3164 // Return the type of the relocation.
3165 static inline unsigned int
3166 get_r_type(const Reltype
* reloc
)
3167 { return elfcpp::elf_r_type
<32>(reloc
->get_r_info()); }
3169 static inline unsigned int
3170 get_r_type2(const Reltype
*)
3173 static inline unsigned int
3174 get_r_type3(const Reltype
*)
3177 static inline unsigned int
3178 get_r_ssym(const Reltype
*)
3181 // Return the explicit addend of the relocation (return 0 for SHT_REL).
3182 static inline unsigned int
3183 get_r_addend(const Reltype
* reloc
)
3185 if (sh_type_
== elfcpp::SHT_REL
)
3187 return Mips_reloc_types
<sh_type_
, 32, big_endian
>::get_r_addend(reloc
);
3190 // Write the r_info field to a new reloc, using the r_info field from
3191 // the original reloc, replacing the r_sym field with R_SYM.
3193 put_r_info(Reltype_write
* new_reloc
, Reltype
* reloc
, unsigned int r_sym
)
3195 unsigned int r_type
= elfcpp::elf_r_type
<32>(reloc
->get_r_info());
3196 new_reloc
->put_r_info(elfcpp::elf_r_info
<32>(r_sym
, r_type
));
3199 // Write the r_addend field to a new reloc.
3201 put_r_addend(Reltype_write
* to
,
3202 typename
elfcpp::Elf_types
<32>::Elf_Swxword addend
)
3203 { Mips_reloc_types
<sh_type_
, 32, big_endian
>::set_reloc_addend(to
, addend
); }
3205 // Return the size of the addend of the relocation (only used for SHT_REL).
3207 get_size_for_reloc(unsigned int r_type
, Relobj
* obj
)
3208 { return mips_get_size_for_reloc(r_type
, obj
); }
3211 template<int sh_type_
, bool big_endian
>
3212 class Mips_classify_reloc
<sh_type_
, 64, big_endian
> :
3213 public gold::Default_classify_reloc
<sh_type_
, 64, big_endian
>
3216 typedef typename Mips_reloc_types
<sh_type_
, 64, big_endian
>::Reloc
3218 typedef typename Mips_reloc_types
<sh_type_
, 64, big_endian
>::Reloc_write
3221 // Return the symbol referred to by the relocation.
3222 static inline unsigned int
3223 get_r_sym(const Reltype
* reloc
)
3224 { return reloc
->get_r_sym(); }
3226 // Return the r_type of the relocation.
3227 static inline unsigned int
3228 get_r_type(const Reltype
* reloc
)
3229 { return reloc
->get_r_type(); }
3231 // Return the r_type2 of the relocation.
3232 static inline unsigned int
3233 get_r_type2(const Reltype
* reloc
)
3234 { return reloc
->get_r_type2(); }
3236 // Return the r_type3 of the relocation.
3237 static inline unsigned int
3238 get_r_type3(const Reltype
* reloc
)
3239 { return reloc
->get_r_type3(); }
3241 // Return the special symbol of the relocation.
3242 static inline unsigned int
3243 get_r_ssym(const Reltype
* reloc
)
3244 { return reloc
->get_r_ssym(); }
3246 // Return the explicit addend of the relocation (return 0 for SHT_REL).
3247 static inline typename
elfcpp::Elf_types
<64>::Elf_Swxword
3248 get_r_addend(const Reltype
* reloc
)
3250 if (sh_type_
== elfcpp::SHT_REL
)
3252 return Mips_reloc_types
<sh_type_
, 64, big_endian
>::get_r_addend(reloc
);
3255 // Write the r_info field to a new reloc, using the r_info field from
3256 // the original reloc, replacing the r_sym field with R_SYM.
3258 put_r_info(Reltype_write
* new_reloc
, Reltype
* reloc
, unsigned int r_sym
)
3260 new_reloc
->put_r_sym(r_sym
);
3261 new_reloc
->put_r_ssym(reloc
->get_r_ssym());
3262 new_reloc
->put_r_type3(reloc
->get_r_type3());
3263 new_reloc
->put_r_type2(reloc
->get_r_type2());
3264 new_reloc
->put_r_type(reloc
->get_r_type());
3267 // Write the r_addend field to a new reloc.
3269 put_r_addend(Reltype_write
* to
,
3270 typename
elfcpp::Elf_types
<64>::Elf_Swxword addend
)
3271 { Mips_reloc_types
<sh_type_
, 64, big_endian
>::set_reloc_addend(to
, addend
); }
3273 // Return the size of the addend of the relocation (only used for SHT_REL).
3275 get_size_for_reloc(unsigned int r_type
, Relobj
* obj
)
3276 { return mips_get_size_for_reloc(r_type
, obj
); }
3279 template<int size
, bool big_endian
>
3280 class Target_mips
: public Sized_target
<size
, big_endian
>
3282 typedef typename
elfcpp::Elf_types
<size
>::Elf_Addr Mips_address
;
3283 typedef Mips_output_data_reloc
<elfcpp::SHT_REL
, true, size
, big_endian
>
3285 typedef typename
elfcpp::Swap
<32, big_endian
>::Valtype Valtype32
;
3286 typedef typename
elfcpp::Swap
<size
, big_endian
>::Valtype Valtype
;
3287 typedef typename Mips_reloc_types
<elfcpp::SHT_REL
, size
, big_endian
>::Reloc
3289 typedef typename Mips_reloc_types
<elfcpp::SHT_RELA
, size
, big_endian
>::Reloc
3293 Target_mips(const Target::Target_info
* info
= &mips_info
)
3294 : Sized_target
<size
, big_endian
>(info
), got_(NULL
), gp_(NULL
), plt_(NULL
),
3295 got_plt_(NULL
), rel_dyn_(NULL
), rld_map_(NULL
), copy_relocs_(),
3296 dyn_relocs_(), la25_stub_(NULL
), mips_mach_extensions_(),
3297 mips_stubs_(NULL
), attributes_section_data_(NULL
), abiflags_(NULL
),
3298 mach_(0), layout_(NULL
), got16_addends_(), has_abiflags_section_(false),
3299 entry_symbol_is_compressed_(false), insn32_(false)
3301 this->add_machine_extensions();
3304 // The offset of $gp from the beginning of the .got section.
3305 static const unsigned int MIPS_GP_OFFSET
= 0x7ff0;
3307 // The maximum size of the GOT for it to be addressable using 16-bit
3308 // offsets from $gp.
3309 static const unsigned int MIPS_GOT_MAX_SIZE
= MIPS_GP_OFFSET
+ 0x7fff;
3311 // Make a new symbol table entry for the Mips target.
3313 make_symbol(const char*, elfcpp::STT
, Object
*, unsigned int, uint64_t)
3314 { return new Mips_symbol
<size
>(); }
3316 // Process the relocations to determine unreferenced sections for
3317 // garbage collection.
3319 gc_process_relocs(Symbol_table
* symtab
,
3321 Sized_relobj_file
<size
, big_endian
>* object
,
3322 unsigned int data_shndx
,
3323 unsigned int sh_type
,
3324 const unsigned char* prelocs
,
3326 Output_section
* output_section
,
3327 bool needs_special_offset_handling
,
3328 size_t local_symbol_count
,
3329 const unsigned char* plocal_symbols
);
3331 // Scan the relocations to look for symbol adjustments.
3333 scan_relocs(Symbol_table
* symtab
,
3335 Sized_relobj_file
<size
, big_endian
>* object
,
3336 unsigned int data_shndx
,
3337 unsigned int sh_type
,
3338 const unsigned char* prelocs
,
3340 Output_section
* output_section
,
3341 bool needs_special_offset_handling
,
3342 size_t local_symbol_count
,
3343 const unsigned char* plocal_symbols
);
3345 // Finalize the sections.
3347 do_finalize_sections(Layout
*, const Input_objects
*, Symbol_table
*);
3349 // Relocate a section.
3351 relocate_section(const Relocate_info
<size
, big_endian
>*,
3352 unsigned int sh_type
,
3353 const unsigned char* prelocs
,
3355 Output_section
* output_section
,
3356 bool needs_special_offset_handling
,
3357 unsigned char* view
,
3358 Mips_address view_address
,
3359 section_size_type view_size
,
3360 const Reloc_symbol_changes
*);
3362 // Scan the relocs during a relocatable link.
3364 scan_relocatable_relocs(Symbol_table
* symtab
,
3366 Sized_relobj_file
<size
, big_endian
>* object
,
3367 unsigned int data_shndx
,
3368 unsigned int sh_type
,
3369 const unsigned char* prelocs
,
3371 Output_section
* output_section
,
3372 bool needs_special_offset_handling
,
3373 size_t local_symbol_count
,
3374 const unsigned char* plocal_symbols
,
3375 Relocatable_relocs
*);
3377 // Scan the relocs for --emit-relocs.
3379 emit_relocs_scan(Symbol_table
* symtab
,
3381 Sized_relobj_file
<size
, big_endian
>* object
,
3382 unsigned int data_shndx
,
3383 unsigned int sh_type
,
3384 const unsigned char* prelocs
,
3386 Output_section
* output_section
,
3387 bool needs_special_offset_handling
,
3388 size_t local_symbol_count
,
3389 const unsigned char* plocal_syms
,
3390 Relocatable_relocs
* rr
);
3392 // Emit relocations for a section.
3394 relocate_relocs(const Relocate_info
<size
, big_endian
>*,
3395 unsigned int sh_type
,
3396 const unsigned char* prelocs
,
3398 Output_section
* output_section
,
3399 typename
elfcpp::Elf_types
<size
>::Elf_Off
3400 offset_in_output_section
,
3401 unsigned char* view
,
3402 Mips_address view_address
,
3403 section_size_type view_size
,
3404 unsigned char* reloc_view
,
3405 section_size_type reloc_view_size
);
3407 // Perform target-specific processing in a relocatable link. This is
3408 // only used if we use the relocation strategy RELOC_SPECIAL.
3410 relocate_special_relocatable(const Relocate_info
<size
, big_endian
>* relinfo
,
3411 unsigned int sh_type
,
3412 const unsigned char* preloc_in
,
3414 Output_section
* output_section
,
3415 typename
elfcpp::Elf_types
<size
>::Elf_Off
3416 offset_in_output_section
,
3417 unsigned char* view
,
3418 Mips_address view_address
,
3419 section_size_type view_size
,
3420 unsigned char* preloc_out
);
3422 // Return whether SYM is defined by the ABI.
3424 do_is_defined_by_abi(const Symbol
* sym
) const
3426 return ((strcmp(sym
->name(), "__gnu_local_gp") == 0)
3427 || (strcmp(sym
->name(), "_gp_disp") == 0)
3428 || (strcmp(sym
->name(), "___tls_get_addr") == 0));
3431 // Return the number of entries in the GOT.
3433 got_entry_count() const
3435 if (!this->has_got_section())
3437 return this->got_size() / (size
/8);
3440 // Return the number of entries in the PLT.
3442 plt_entry_count() const
3444 if (this->plt_
== NULL
)
3446 return this->plt_
->entry_count();
3449 // Return the offset of the first non-reserved PLT entry.
3451 first_plt_entry_offset() const
3452 { return this->plt_
->first_plt_entry_offset(); }
3454 // Return the size of each PLT entry.
3456 plt_entry_size() const
3457 { return this->plt_
->plt_entry_size(); }
3459 // Get the GOT section, creating it if necessary.
3460 Mips_output_data_got
<size
, big_endian
>*
3461 got_section(Symbol_table
*, Layout
*);
3463 // Get the GOT section.
3464 Mips_output_data_got
<size
, big_endian
>*
3467 gold_assert(this->got_
!= NULL
);
3471 // Get the .MIPS.stubs section, creating it if necessary.
3472 Mips_output_data_mips_stubs
<size
, big_endian
>*
3473 mips_stubs_section(Layout
* layout
);
3475 // Get the .MIPS.stubs section.
3476 Mips_output_data_mips_stubs
<size
, big_endian
>*
3477 mips_stubs_section() const
3479 gold_assert(this->mips_stubs_
!= NULL
);
3480 return this->mips_stubs_
;
3483 // Get the LA25 stub section, creating it if necessary.
3484 Mips_output_data_la25_stub
<size
, big_endian
>*
3485 la25_stub_section(Layout
*);
3487 // Get the LA25 stub section.
3488 Mips_output_data_la25_stub
<size
, big_endian
>*
3491 gold_assert(this->la25_stub_
!= NULL
);
3492 return this->la25_stub_
;
3495 // Get gp value. It has the value of .got + 0x7FF0.
3499 if (this->gp_
!= NULL
)
3500 return this->gp_
->value();
3504 // Get gp value. It has the value of .got + 0x7FF0. Adjust it for
3505 // multi-GOT links so that OBJECT's GOT + 0x7FF0 is returned.
3507 adjusted_gp_value(const Mips_relobj
<size
, big_endian
>* object
)
3509 if (this->gp_
== NULL
)
3512 bool multi_got
= false;
3513 if (this->has_got_section())
3514 multi_got
= this->got_section()->multi_got();
3516 return this->gp_
->value();
3518 return this->gp_
->value() + this->got_section()->get_got_offset(object
);
3521 // Get the dynamic reloc section, creating it if necessary.
3523 rel_dyn_section(Layout
*);
3526 do_has_custom_set_dynsym_indexes() const
3529 // Don't emit input .reginfo/.MIPS.abiflags sections to
3530 // output .reginfo/.MIPS.abiflags.
3532 do_should_include_section(elfcpp::Elf_Word sh_type
) const
3534 return ((sh_type
!= elfcpp::SHT_MIPS_REGINFO
)
3535 && (sh_type
!= elfcpp::SHT_MIPS_ABIFLAGS
));
3538 // Set the dynamic symbol indexes. INDEX is the index of the first
3539 // global dynamic symbol. Pointers to the symbols are stored into the
3540 // vector SYMS. The names are added to DYNPOOL. This returns an
3541 // updated dynamic symbol index.
3543 do_set_dynsym_indexes(std::vector
<Symbol
*>* dyn_symbols
, unsigned int index
,
3544 std::vector
<Symbol
*>* syms
, Stringpool
* dynpool
,
3545 Versions
* versions
, Symbol_table
* symtab
) const;
3547 // Remove .MIPS.stubs entry for a symbol.
3549 remove_lazy_stub_entry(Mips_symbol
<size
>* sym
)
3551 if (this->mips_stubs_
!= NULL
)
3552 this->mips_stubs_
->remove_entry(sym
);
3555 // The value to write into got[1] for SVR4 targets, to identify it is
3556 // a GNU object. The dynamic linker can then use got[1] to store the
3559 mips_elf_gnu_got1_mask()
3561 if (this->is_output_n64())
3562 return (uint64_t)1 << 63;
3567 // Whether the output has microMIPS code. This is valid only after
3568 // merge_obj_e_flags() is called.
3570 is_output_micromips() const
3572 gold_assert(this->are_processor_specific_flags_set());
3573 return elfcpp::is_micromips(this->processor_specific_flags());
3576 // Whether the output uses N32 ABI. This is valid only after
3577 // merge_obj_e_flags() is called.
3579 is_output_n32() const
3581 gold_assert(this->are_processor_specific_flags_set());
3582 return elfcpp::abi_n32(this->processor_specific_flags());
3585 // Whether the output uses R6 ISA. This is valid only after
3586 // merge_obj_e_flags() is called.
3588 is_output_r6() const
3590 gold_assert(this->are_processor_specific_flags_set());
3591 return elfcpp::r6_isa(this->processor_specific_flags());
3594 // Whether the output uses N64 ABI.
3596 is_output_n64() const
3597 { return size
== 64; }
3599 // Whether the output uses NEWABI. This is valid only after
3600 // merge_obj_e_flags() is called.
3602 is_output_newabi() const
3603 { return this->is_output_n32() || this->is_output_n64(); }
3605 // Whether we can only use 32-bit microMIPS instructions.
3607 use_32bit_micromips_instructions() const
3608 { return this->insn32_
; }
3610 // Return the r_sym field from a relocation.
3612 get_r_sym(const unsigned char* preloc
) const
3614 // Since REL and RELA relocs share the same structure through
3615 // the r_info field, we can just use REL here.
3616 Reltype
rel(preloc
);
3617 return Mips_classify_reloc
<elfcpp::SHT_REL
, size
, big_endian
>::
3622 // Return the value to use for a dynamic symbol which requires special
3623 // treatment. This is how we support equality comparisons of function
3624 // pointers across shared library boundaries, as described in the
3625 // processor specific ABI supplement.
3627 do_dynsym_value(const Symbol
* gsym
) const;
3629 // Make an ELF object.
3631 do_make_elf_object(const std::string
&, Input_file
*, off_t
,
3632 const elfcpp::Ehdr
<size
, big_endian
>& ehdr
);
3635 do_make_elf_object(const std::string
&, Input_file
*, off_t
,
3636 const elfcpp::Ehdr
<size
, !big_endian
>&)
3637 { gold_unreachable(); }
3639 // Adjust ELF file header.
3641 do_adjust_elf_header(unsigned char* view
, int len
);
3643 // Get the custom dynamic tag value.
3645 do_dynamic_tag_custom_value(elfcpp::DT
) const;
3647 // Adjust the value written to the dynamic symbol table.
3649 do_adjust_dyn_symbol(const Symbol
* sym
, unsigned char* view
) const
3651 elfcpp::Sym
<size
, big_endian
> isym(view
);
3652 elfcpp::Sym_write
<size
, big_endian
> osym(view
);
3653 const Mips_symbol
<size
>* mips_sym
= Mips_symbol
<size
>::as_mips_sym(sym
);
3655 // Keep dynamic compressed symbols odd. This allows the dynamic linker
3656 // to treat compressed symbols like any other.
3657 Mips_address value
= isym
.get_st_value();
3658 if (mips_sym
->is_mips16() && value
!= 0)
3660 if (!mips_sym
->has_mips16_fn_stub())
3664 // If we have a MIPS16 function with a stub, the dynamic symbol
3665 // must refer to the stub, since only the stub uses the standard
3666 // calling conventions. Stub contains MIPS32 code, so don't add +1
3669 // There is a code which does this in the method
3670 // Target_mips::do_dynsym_value, but that code will only be
3671 // executed if the symbol is from dynobj.
3672 // TODO(sasa): GNU ld also changes the value in non-dynamic symbol
3675 Mips16_stub_section
<size
, big_endian
>* fn_stub
=
3676 mips_sym
->template get_mips16_fn_stub
<big_endian
>();
3677 value
= fn_stub
->output_address();
3678 osym
.put_st_size(fn_stub
->section_size());
3681 osym
.put_st_value(value
);
3682 osym
.put_st_other(elfcpp::elf_st_other(sym
->visibility(),
3683 mips_sym
->nonvis() - (elfcpp::STO_MIPS16
>> 2)));
3685 else if ((mips_sym
->is_micromips()
3686 // Stubs are always microMIPS if there is any microMIPS code in
3688 || (this->is_output_micromips() && mips_sym
->has_lazy_stub()))
3691 osym
.put_st_value(value
| 1);
3692 osym
.put_st_other(elfcpp::elf_st_other(sym
->visibility(),
3693 mips_sym
->nonvis() - (elfcpp::STO_MICROMIPS
>> 2)));
3698 // The class which scans relocations.
3706 get_reference_flags(unsigned int r_type
);
3709 local(Symbol_table
* symtab
, Layout
* layout
, Target_mips
* target
,
3710 Sized_relobj_file
<size
, big_endian
>* object
,
3711 unsigned int data_shndx
,
3712 Output_section
* output_section
,
3713 const Reltype
& reloc
, unsigned int r_type
,
3714 const elfcpp::Sym
<size
, big_endian
>& lsym
,
3718 local(Symbol_table
* symtab
, Layout
* layout
, Target_mips
* target
,
3719 Sized_relobj_file
<size
, big_endian
>* object
,
3720 unsigned int data_shndx
,
3721 Output_section
* output_section
,
3722 const Relatype
& reloc
, unsigned int r_type
,
3723 const elfcpp::Sym
<size
, big_endian
>& lsym
,
3727 local(Symbol_table
* symtab
, Layout
* layout
, Target_mips
* target
,
3728 Sized_relobj_file
<size
, big_endian
>* object
,
3729 unsigned int data_shndx
,
3730 Output_section
* output_section
,
3731 const Relatype
* rela
,
3733 unsigned int rel_type
,
3734 unsigned int r_type
,
3735 const elfcpp::Sym
<size
, big_endian
>& lsym
,
3739 global(Symbol_table
* symtab
, Layout
* layout
, Target_mips
* target
,
3740 Sized_relobj_file
<size
, big_endian
>* object
,
3741 unsigned int data_shndx
,
3742 Output_section
* output_section
,
3743 const Reltype
& reloc
, unsigned int r_type
,
3747 global(Symbol_table
* symtab
, Layout
* layout
, Target_mips
* target
,
3748 Sized_relobj_file
<size
, big_endian
>* object
,
3749 unsigned int data_shndx
,
3750 Output_section
* output_section
,
3751 const Relatype
& reloc
, unsigned int r_type
,
3755 global(Symbol_table
* symtab
, Layout
* layout
, Target_mips
* target
,
3756 Sized_relobj_file
<size
, big_endian
>* object
,
3757 unsigned int data_shndx
,
3758 Output_section
* output_section
,
3759 const Relatype
* rela
,
3761 unsigned int rel_type
,
3762 unsigned int r_type
,
3766 local_reloc_may_be_function_pointer(Symbol_table
* , Layout
*,
3768 Sized_relobj_file
<size
, big_endian
>*,
3773 const elfcpp::Sym
<size
, big_endian
>&)
3777 global_reloc_may_be_function_pointer(Symbol_table
*, Layout
*,
3779 Sized_relobj_file
<size
, big_endian
>*,
3783 unsigned int, Symbol
*)
3787 local_reloc_may_be_function_pointer(Symbol_table
*, Layout
*,
3789 Sized_relobj_file
<size
, big_endian
>*,
3794 const elfcpp::Sym
<size
, big_endian
>&)
3798 global_reloc_may_be_function_pointer(Symbol_table
*, Layout
*,
3800 Sized_relobj_file
<size
, big_endian
>*,
3804 unsigned int, Symbol
*)
3808 unsupported_reloc_local(Sized_relobj_file
<size
, big_endian
>*,
3809 unsigned int r_type
);
3812 unsupported_reloc_global(Sized_relobj_file
<size
, big_endian
>*,
3813 unsigned int r_type
, Symbol
*);
3816 // The class which implements relocation.
3826 // Return whether a R_MIPS_32/R_MIPS_64 relocation needs to be applied.
3828 should_apply_static_reloc(const Mips_symbol
<size
>* gsym
,
3829 unsigned int r_type
,
3830 Output_section
* output_section
,
3831 Target_mips
* target
);
3833 // Do a relocation. Return false if the caller should not issue
3834 // any warnings about this relocation.
3836 relocate(const Relocate_info
<size
, big_endian
>*, unsigned int,
3837 Target_mips
*, Output_section
*, size_t, const unsigned char*,
3838 const Sized_symbol
<size
>*, const Symbol_value
<size
>*,
3839 unsigned char*, Mips_address
, section_size_type
);
3842 // This POD class holds the dynamic relocations that should be emitted instead
3843 // of R_MIPS_32, R_MIPS_REL32 and R_MIPS_64 relocations. We will emit these
3844 // relocations if it turns out that the symbol does not have static
3849 Dyn_reloc(Mips_symbol
<size
>* sym
, unsigned int r_type
,
3850 Mips_relobj
<size
, big_endian
>* relobj
, unsigned int shndx
,
3851 Output_section
* output_section
, Mips_address r_offset
)
3852 : sym_(sym
), r_type_(r_type
), relobj_(relobj
),
3853 shndx_(shndx
), output_section_(output_section
),
3857 // Emit this reloc if appropriate. This is called after we have
3858 // scanned all the relocations, so we know whether the symbol has
3859 // static relocations.
3861 emit(Reloc_section
* rel_dyn
, Mips_output_data_got
<size
, big_endian
>* got
,
3862 Symbol_table
* symtab
)
3864 if (!this->sym_
->has_static_relocs())
3866 got
->record_global_got_symbol(this->sym_
, this->relobj_
,
3867 this->r_type_
, true, false);
3868 if (!symbol_references_local(this->sym_
,
3869 this->sym_
->should_add_dynsym_entry(symtab
)))
3870 rel_dyn
->add_global(this->sym_
, this->r_type_
,
3871 this->output_section_
, this->relobj_
,
3872 this->shndx_
, this->r_offset_
);
3874 rel_dyn
->add_symbolless_global_addend(this->sym_
, this->r_type_
,
3875 this->output_section_
, this->relobj_
,
3876 this->shndx_
, this->r_offset_
);
3881 Mips_symbol
<size
>* sym_
;
3882 unsigned int r_type_
;
3883 Mips_relobj
<size
, big_endian
>* relobj_
;
3884 unsigned int shndx_
;
3885 Output_section
* output_section_
;
3886 Mips_address r_offset_
;
3889 // Adjust TLS relocation type based on the options and whether this
3890 // is a local symbol.
3891 static tls::Tls_optimization
3892 optimize_tls_reloc(bool is_final
, int r_type
);
3894 // Return whether there is a GOT section.
3896 has_got_section() const
3897 { return this->got_
!= NULL
; }
3899 // Check whether the given ELF header flags describe a 32-bit binary.
3901 mips_32bit_flags(elfcpp::Elf_Word
);
3904 mach_mips3000
= 3000,
3905 mach_mips3900
= 3900,
3906 mach_mips4000
= 4000,
3907 mach_mips4010
= 4010,
3908 mach_mips4100
= 4100,
3909 mach_mips4111
= 4111,
3910 mach_mips4120
= 4120,
3911 mach_mips4300
= 4300,
3912 mach_mips4400
= 4400,
3913 mach_mips4600
= 4600,
3914 mach_mips4650
= 4650,
3915 mach_mips5000
= 5000,
3916 mach_mips5400
= 5400,
3917 mach_mips5500
= 5500,
3918 mach_mips5900
= 5900,
3919 mach_mips6000
= 6000,
3920 mach_mips7000
= 7000,
3921 mach_mips8000
= 8000,
3922 mach_mips9000
= 9000,
3923 mach_mips10000
= 10000,
3924 mach_mips12000
= 12000,
3925 mach_mips14000
= 14000,
3926 mach_mips16000
= 16000,
3929 mach_mips_loongson_2e
= 3001,
3930 mach_mips_loongson_2f
= 3002,
3931 mach_mips_loongson_3a
= 3003,
3932 mach_mips_sb1
= 12310201, // octal 'SB', 01
3933 mach_mips_octeon
= 6501,
3934 mach_mips_octeonp
= 6601,
3935 mach_mips_octeon2
= 6502,
3936 mach_mips_octeon3
= 6503,
3937 mach_mips_xlr
= 887682, // decimal 'XLR'
3938 mach_mipsisa32
= 32,
3939 mach_mipsisa32r2
= 33,
3940 mach_mipsisa32r3
= 34,
3941 mach_mipsisa32r5
= 36,
3942 mach_mipsisa32r6
= 37,
3943 mach_mipsisa64
= 64,
3944 mach_mipsisa64r2
= 65,
3945 mach_mipsisa64r3
= 66,
3946 mach_mipsisa64r5
= 68,
3947 mach_mipsisa64r6
= 69,
3948 mach_mips_micromips
= 96
3951 // Return the MACH for a MIPS e_flags value.
3953 elf_mips_mach(elfcpp::Elf_Word
);
3955 // Return the MACH for each .MIPS.abiflags ISA Extension.
3957 mips_isa_ext_mach(unsigned int);
3959 // Return the .MIPS.abiflags value representing each ISA Extension.
3961 mips_isa_ext(unsigned int);
3963 // Update the isa_level, isa_rev, isa_ext fields of abiflags.
3965 update_abiflags_isa(const std::string
&, elfcpp::Elf_Word
,
3966 Mips_abiflags
<big_endian
>*);
3968 // Infer the content of the ABI flags based on the elf header.
3970 infer_abiflags(Mips_relobj
<size
, big_endian
>*, Mips_abiflags
<big_endian
>*);
3972 // Create abiflags from elf header or from .MIPS.abiflags section.
3974 create_abiflags(Mips_relobj
<size
, big_endian
>*, Mips_abiflags
<big_endian
>*);
3976 // Return the meaning of fp_abi, or "unknown" if not known.
3982 select_fp_abi(const std::string
&, int, int);
3984 // Merge attributes from input object.
3986 merge_obj_attributes(const std::string
&, const Attributes_section_data
*);
3988 // Merge abiflags from input object.
3990 merge_obj_abiflags(const std::string
&, Mips_abiflags
<big_endian
>*);
3992 // Check whether machine EXTENSION is an extension of machine BASE.
3994 mips_mach_extends(unsigned int, unsigned int);
3996 // Merge file header flags from input object.
3998 merge_obj_e_flags(const std::string
&, elfcpp::Elf_Word
);
4000 // Encode ISA level and revision as a single value.
4002 level_rev(unsigned char isa_level
, unsigned char isa_rev
) const
4003 { return (isa_level
<< 3) | isa_rev
; }
4005 // True if we are linking for CPUs that are faster if JAL is converted to BAL.
4010 // True if we are linking for CPUs that are faster if JALR is converted to
4011 // BAL. This should be safe for all architectures. We enable this predicate
4017 // True if we are linking for CPUs that are faster if JR is converted to B.
4018 // This should be safe for all architectures. We enable this predicate for
4024 // Return the size of the GOT section.
4028 gold_assert(this->got_
!= NULL
);
4029 return this->got_
->data_size();
4032 // Create a PLT entry for a global symbol referenced by r_type relocation.
4034 make_plt_entry(Symbol_table
*, Layout
*, Mips_symbol
<size
>*,
4035 unsigned int r_type
);
4037 // Get the PLT section.
4038 Mips_output_data_plt
<size
, big_endian
>*
4041 gold_assert(this->plt_
!= NULL
);
4045 // Get the GOT PLT section.
4046 const Mips_output_data_plt
<size
, big_endian
>*
4047 got_plt_section() const
4049 gold_assert(this->got_plt_
!= NULL
);
4050 return this->got_plt_
;
4053 // Copy a relocation against a global symbol.
4055 copy_reloc(Symbol_table
* symtab
, Layout
* layout
,
4056 Sized_relobj_file
<size
, big_endian
>* object
,
4057 unsigned int shndx
, Output_section
* output_section
,
4058 Symbol
* sym
, unsigned int r_type
, Mips_address r_offset
)
4060 this->copy_relocs_
.copy_reloc(symtab
, layout
,
4061 symtab
->get_sized_symbol
<size
>(sym
),
4062 object
, shndx
, output_section
,
4063 r_type
, r_offset
, 0,
4064 this->rel_dyn_section(layout
));
4068 dynamic_reloc(Mips_symbol
<size
>* sym
, unsigned int r_type
,
4069 Mips_relobj
<size
, big_endian
>* relobj
,
4070 unsigned int shndx
, Output_section
* output_section
,
4071 Mips_address r_offset
)
4073 this->dyn_relocs_
.push_back(Dyn_reloc(sym
, r_type
, relobj
, shndx
,
4074 output_section
, r_offset
));
4077 // Calculate value of _gp symbol.
4079 set_gp(Layout
*, Symbol_table
*);
4082 elf_mips_abi_name(elfcpp::Elf_Word e_flags
);
4084 elf_mips_mach_name(elfcpp::Elf_Word e_flags
);
4086 // Adds entries that describe how machines relate to one another. The entries
4087 // are ordered topologically with MIPS I extensions listed last. First
4088 // element is extension, second element is base.
4090 add_machine_extensions()
4092 // MIPS64r2 extensions.
4093 this->add_extension(mach_mips_octeon3
, mach_mips_octeon2
);
4094 this->add_extension(mach_mips_octeon2
, mach_mips_octeonp
);
4095 this->add_extension(mach_mips_octeonp
, mach_mips_octeon
);
4096 this->add_extension(mach_mips_octeon
, mach_mipsisa64r2
);
4097 this->add_extension(mach_mips_loongson_3a
, mach_mipsisa64r2
);
4099 // MIPS64 extensions.
4100 this->add_extension(mach_mipsisa64r2
, mach_mipsisa64
);
4101 this->add_extension(mach_mips_sb1
, mach_mipsisa64
);
4102 this->add_extension(mach_mips_xlr
, mach_mipsisa64
);
4104 // MIPS V extensions.
4105 this->add_extension(mach_mipsisa64
, mach_mips5
);
4107 // R10000 extensions.
4108 this->add_extension(mach_mips12000
, mach_mips10000
);
4109 this->add_extension(mach_mips14000
, mach_mips10000
);
4110 this->add_extension(mach_mips16000
, mach_mips10000
);
4112 // R5000 extensions. Note: the vr5500 ISA is an extension of the core
4113 // vr5400 ISA, but doesn't include the multimedia stuff. It seems
4114 // better to allow vr5400 and vr5500 code to be merged anyway, since
4115 // many libraries will just use the core ISA. Perhaps we could add
4116 // some sort of ASE flag if this ever proves a problem.
4117 this->add_extension(mach_mips5500
, mach_mips5400
);
4118 this->add_extension(mach_mips5400
, mach_mips5000
);
4120 // MIPS IV extensions.
4121 this->add_extension(mach_mips5
, mach_mips8000
);
4122 this->add_extension(mach_mips10000
, mach_mips8000
);
4123 this->add_extension(mach_mips5000
, mach_mips8000
);
4124 this->add_extension(mach_mips7000
, mach_mips8000
);
4125 this->add_extension(mach_mips9000
, mach_mips8000
);
4127 // VR4100 extensions.
4128 this->add_extension(mach_mips4120
, mach_mips4100
);
4129 this->add_extension(mach_mips4111
, mach_mips4100
);
4131 // MIPS III extensions.
4132 this->add_extension(mach_mips_loongson_2e
, mach_mips4000
);
4133 this->add_extension(mach_mips_loongson_2f
, mach_mips4000
);
4134 this->add_extension(mach_mips8000
, mach_mips4000
);
4135 this->add_extension(mach_mips4650
, mach_mips4000
);
4136 this->add_extension(mach_mips4600
, mach_mips4000
);
4137 this->add_extension(mach_mips4400
, mach_mips4000
);
4138 this->add_extension(mach_mips4300
, mach_mips4000
);
4139 this->add_extension(mach_mips4100
, mach_mips4000
);
4140 this->add_extension(mach_mips4010
, mach_mips4000
);
4141 this->add_extension(mach_mips5900
, mach_mips4000
);
4143 // MIPS32 extensions.
4144 this->add_extension(mach_mipsisa32r2
, mach_mipsisa32
);
4146 // MIPS II extensions.
4147 this->add_extension(mach_mips4000
, mach_mips6000
);
4148 this->add_extension(mach_mipsisa32
, mach_mips6000
);
4150 // MIPS I extensions.
4151 this->add_extension(mach_mips6000
, mach_mips3000
);
4152 this->add_extension(mach_mips3900
, mach_mips3000
);
4155 // Add value to MIPS extenstions.
4157 add_extension(unsigned int base
, unsigned int extension
)
4159 std::pair
<unsigned int, unsigned int> ext(base
, extension
);
4160 this->mips_mach_extensions_
.push_back(ext
);
4163 // Return the number of entries in the .dynsym section.
4164 unsigned int get_dt_mips_symtabno() const
4166 return ((unsigned int)(this->layout_
->dynsym_section()->data_size()
4167 / elfcpp::Elf_sizes
<size
>::sym_size
));
4168 // TODO(sasa): Entry size is MIPS_ELF_SYM_SIZE.
4171 // Information about this specific target which we pass to the
4172 // general Target structure.
4173 static const Target::Target_info mips_info
;
4175 Mips_output_data_got
<size
, big_endian
>* got_
;
4176 // gp symbol. It has the value of .got + 0x7FF0.
4177 Sized_symbol
<size
>* gp_
;
4179 Mips_output_data_plt
<size
, big_endian
>* plt_
;
4180 // The GOT PLT section.
4181 Output_data_space
* got_plt_
;
4182 // The dynamic reloc section.
4183 Reloc_section
* rel_dyn_
;
4184 // The .rld_map section.
4185 Output_data_zero_fill
* rld_map_
;
4186 // Relocs saved to avoid a COPY reloc.
4187 Mips_copy_relocs
<elfcpp::SHT_REL
, size
, big_endian
> copy_relocs_
;
4189 // A list of dyn relocs to be saved.
4190 std::vector
<Dyn_reloc
> dyn_relocs_
;
4192 // The LA25 stub section.
4193 Mips_output_data_la25_stub
<size
, big_endian
>* la25_stub_
;
4194 // Architecture extensions.
4195 std::vector
<std::pair
<unsigned int, unsigned int> > mips_mach_extensions_
;
4197 Mips_output_data_mips_stubs
<size
, big_endian
>* mips_stubs_
;
4199 // Attributes section data in output.
4200 Attributes_section_data
* attributes_section_data_
;
4201 // .MIPS.abiflags section data in output.
4202 Mips_abiflags
<big_endian
>* abiflags_
;
4207 typename
std::list
<got16_addend
<size
, big_endian
> > got16_addends_
;
4209 // Whether there is an input .MIPS.abiflags section.
4210 bool has_abiflags_section_
;
4212 // Whether the entry symbol is mips16 or micromips.
4213 bool entry_symbol_is_compressed_
;
4215 // Whether we can use only 32-bit microMIPS instructions.
4216 // TODO(sasa): This should be a linker option.
4220 // Helper structure for R_MIPS*_HI16/LO16 and R_MIPS*_GOT16/LO16 relocations.
4221 // It records high part of the relocation pair.
4223 template<int size
, bool big_endian
>
4226 typedef typename
elfcpp::Elf_types
<size
>::Elf_Addr Mips_address
;
4228 reloc_high(unsigned char* _view
, const Mips_relobj
<size
, big_endian
>* _object
,
4229 const Symbol_value
<size
>* _psymval
, Mips_address _addend
,
4230 unsigned int _r_type
, unsigned int _r_sym
, bool _extract_addend
,
4231 Mips_address _address
= 0, bool _gp_disp
= false)
4232 : view(_view
), object(_object
), psymval(_psymval
), addend(_addend
),
4233 r_type(_r_type
), r_sym(_r_sym
), extract_addend(_extract_addend
),
4234 address(_address
), gp_disp(_gp_disp
)
4237 unsigned char* view
;
4238 const Mips_relobj
<size
, big_endian
>* object
;
4239 const Symbol_value
<size
>* psymval
;
4240 Mips_address addend
;
4241 unsigned int r_type
;
4243 bool extract_addend
;
4244 Mips_address address
;
4248 template<int size
, bool big_endian
>
4249 class Mips_relocate_functions
: public Relocate_functions
<size
, big_endian
>
4251 typedef typename
elfcpp::Elf_types
<size
>::Elf_Addr Mips_address
;
4252 typedef typename
elfcpp::Swap
<size
, big_endian
>::Valtype Valtype
;
4253 typedef typename
elfcpp::Swap
<16, big_endian
>::Valtype Valtype16
;
4254 typedef typename
elfcpp::Swap
<32, big_endian
>::Valtype Valtype32
;
4255 typedef typename
elfcpp::Swap
<64, big_endian
>::Valtype Valtype64
;
4260 STATUS_OKAY
, // No error during relocation.
4261 STATUS_OVERFLOW
, // Relocation overflow.
4262 STATUS_BAD_RELOC
, // Relocation cannot be applied.
4263 STATUS_PCREL_UNALIGNED
// Unaligned PC-relative relocation.
4267 typedef Relocate_functions
<size
, big_endian
> Base
;
4268 typedef Mips_relocate_functions
<size
, big_endian
> This
;
4270 static typename
std::list
<reloc_high
<size
, big_endian
> > hi16_relocs
;
4271 static typename
std::list
<reloc_high
<size
, big_endian
> > got16_relocs
;
4272 static typename
std::list
<reloc_high
<size
, big_endian
> > pchi16_relocs
;
4274 template<int valsize
>
4275 static inline typename
This::Status
4276 check_overflow(Valtype value
)
4279 return (Bits
<valsize
>::has_overflow32(value
)
4280 ? This::STATUS_OVERFLOW
4281 : This::STATUS_OKAY
);
4283 return (Bits
<valsize
>::has_overflow(value
)
4284 ? This::STATUS_OVERFLOW
4285 : This::STATUS_OKAY
);
4289 should_shuffle_micromips_reloc(unsigned int r_type
)
4291 return (micromips_reloc(r_type
)
4292 && r_type
!= elfcpp::R_MICROMIPS_PC7_S1
4293 && r_type
!= elfcpp::R_MICROMIPS_PC10_S1
);
4297 // R_MIPS16_26 is used for the mips16 jal and jalx instructions.
4298 // Most mips16 instructions are 16 bits, but these instructions
4301 // The format of these instructions is:
4303 // +--------------+--------------------------------+
4304 // | JALX | X| Imm 20:16 | Imm 25:21 |
4305 // +--------------+--------------------------------+
4306 // | Immediate 15:0 |
4307 // +-----------------------------------------------+
4309 // JALX is the 5-bit value 00011. X is 0 for jal, 1 for jalx.
4310 // Note that the immediate value in the first word is swapped.
4312 // When producing a relocatable object file, R_MIPS16_26 is
4313 // handled mostly like R_MIPS_26. In particular, the addend is
4314 // stored as a straight 26-bit value in a 32-bit instruction.
4315 // (gas makes life simpler for itself by never adjusting a
4316 // R_MIPS16_26 reloc to be against a section, so the addend is
4317 // always zero). However, the 32 bit instruction is stored as 2
4318 // 16-bit values, rather than a single 32-bit value. In a
4319 // big-endian file, the result is the same; in a little-endian
4320 // file, the two 16-bit halves of the 32 bit value are swapped.
4321 // This is so that a disassembler can recognize the jal
4324 // When doing a final link, R_MIPS16_26 is treated as a 32 bit
4325 // instruction stored as two 16-bit values. The addend A is the
4326 // contents of the targ26 field. The calculation is the same as
4327 // R_MIPS_26. When storing the calculated value, reorder the
4328 // immediate value as shown above, and don't forget to store the
4329 // value as two 16-bit values.
4331 // To put it in MIPS ABI terms, the relocation field is T-targ26-16,
4335 // +--------+----------------------+
4339 // +--------+----------------------+
4342 // +----------+------+-------------+
4344 // | sub1 | | sub2 |
4345 // |0 9|10 15|16 31|
4346 // +----------+--------------------+
4347 // where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
4348 // ((sub1 << 16) | sub2)).
4350 // When producing a relocatable object file, the calculation is
4351 // (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
4352 // When producing a fully linked file, the calculation is
4353 // let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
4354 // ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)
4356 // The table below lists the other MIPS16 instruction relocations.
4357 // Each one is calculated in the same way as the non-MIPS16 relocation
4358 // given on the right, but using the extended MIPS16 layout of 16-bit
4359 // immediate fields:
4361 // R_MIPS16_GPREL R_MIPS_GPREL16
4362 // R_MIPS16_GOT16 R_MIPS_GOT16
4363 // R_MIPS16_CALL16 R_MIPS_CALL16
4364 // R_MIPS16_HI16 R_MIPS_HI16
4365 // R_MIPS16_LO16 R_MIPS_LO16
4367 // A typical instruction will have a format like this:
4369 // +--------------+--------------------------------+
4370 // | EXTEND | Imm 10:5 | Imm 15:11 |
4371 // +--------------+--------------------------------+
4372 // | Major | rx | ry | Imm 4:0 |
4373 // +--------------+--------------------------------+
4375 // EXTEND is the five bit value 11110. Major is the instruction
4378 // All we need to do here is shuffle the bits appropriately.
4379 // As above, the two 16-bit halves must be swapped on a
4380 // little-endian system.
4382 // Similar to MIPS16, the two 16-bit halves in microMIPS must be swapped
4383 // on a little-endian system. This does not apply to R_MICROMIPS_PC7_S1
4384 // and R_MICROMIPS_PC10_S1 relocs that apply to 16-bit instructions.
4387 mips_reloc_unshuffle(unsigned char* view
, unsigned int r_type
,
4390 if (!mips16_reloc(r_type
)
4391 && !should_shuffle_micromips_reloc(r_type
))
4394 // Pick up the first and second halfwords of the instruction.
4395 Valtype16 first
= elfcpp::Swap
<16, big_endian
>::readval(view
);
4396 Valtype16 second
= elfcpp::Swap
<16, big_endian
>::readval(view
+ 2);
4399 if (micromips_reloc(r_type
)
4400 || (r_type
== elfcpp::R_MIPS16_26
&& !jal_shuffle
))
4401 val
= first
<< 16 | second
;
4402 else if (r_type
!= elfcpp::R_MIPS16_26
)
4403 val
= (((first
& 0xf800) << 16) | ((second
& 0xffe0) << 11)
4404 | ((first
& 0x1f) << 11) | (first
& 0x7e0) | (second
& 0x1f));
4406 val
= (((first
& 0xfc00) << 16) | ((first
& 0x3e0) << 11)
4407 | ((first
& 0x1f) << 21) | second
);
4409 elfcpp::Swap
<32, big_endian
>::writeval(view
, val
);
4413 mips_reloc_shuffle(unsigned char* view
, unsigned int r_type
, bool jal_shuffle
)
4415 if (!mips16_reloc(r_type
)
4416 && !should_shuffle_micromips_reloc(r_type
))
4419 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(view
);
4420 Valtype16 first
, second
;
4422 if (micromips_reloc(r_type
)
4423 || (r_type
== elfcpp::R_MIPS16_26
&& !jal_shuffle
))
4425 second
= val
& 0xffff;
4428 else if (r_type
!= elfcpp::R_MIPS16_26
)
4430 second
= ((val
>> 11) & 0xffe0) | (val
& 0x1f);
4431 first
= ((val
>> 16) & 0xf800) | ((val
>> 11) & 0x1f) | (val
& 0x7e0);
4435 second
= val
& 0xffff;
4436 first
= ((val
>> 16) & 0xfc00) | ((val
>> 11) & 0x3e0)
4437 | ((val
>> 21) & 0x1f);
4440 elfcpp::Swap
<16, big_endian
>::writeval(view
+ 2, second
);
4441 elfcpp::Swap
<16, big_endian
>::writeval(view
, first
);
4444 // R_MIPS_16: S + sign-extend(A)
4445 static inline typename
This::Status
4446 rel16(unsigned char* view
, const Mips_relobj
<size
, big_endian
>* object
,
4447 const Symbol_value
<size
>* psymval
, Mips_address addend_a
,
4448 bool extract_addend
, bool calculate_only
, Valtype
* calculated_value
)
4450 Valtype16
* wv
= reinterpret_cast<Valtype16
*>(view
);
4451 Valtype16 val
= elfcpp::Swap
<16, big_endian
>::readval(wv
);
4453 Valtype addend
= (extract_addend
? Bits
<16>::sign_extend32(val
)
4456 Valtype x
= psymval
->value(object
, addend
);
4457 val
= Bits
<16>::bit_select32(val
, x
, 0xffffU
);
4461 *calculated_value
= x
;
4462 return This::STATUS_OKAY
;
4465 elfcpp::Swap
<16, big_endian
>::writeval(wv
, val
);
4467 return check_overflow
<16>(x
);
4471 static inline typename
This::Status
4472 rel32(unsigned char* view
, const Mips_relobj
<size
, big_endian
>* object
,
4473 const Symbol_value
<size
>* psymval
, Mips_address addend_a
,
4474 bool extract_addend
, bool calculate_only
, Valtype
* calculated_value
)
4476 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
4477 Valtype addend
= (extract_addend
4478 ? elfcpp::Swap
<32, big_endian
>::readval(wv
)
4480 Valtype x
= psymval
->value(object
, addend
);
4483 *calculated_value
= x
;
4485 elfcpp::Swap
<32, big_endian
>::writeval(wv
, x
);
4487 return This::STATUS_OKAY
;
4490 // R_MIPS_JALR, R_MICROMIPS_JALR
4491 static inline typename
This::Status
4492 reljalr(unsigned char* view
, const Mips_relobj
<size
, big_endian
>* object
,
4493 const Symbol_value
<size
>* psymval
, Mips_address address
,
4494 Mips_address addend_a
, bool extract_addend
, bool cross_mode_jump
,
4495 unsigned int r_type
, bool jalr_to_bal
, bool jr_to_b
,
4496 bool calculate_only
, Valtype
* calculated_value
)
4498 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
4499 Valtype addend
= extract_addend
? 0 : addend_a
;
4500 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(wv
);
4502 // Try converting J(AL)R to B(AL), if the target is in range.
4503 if (!parameters
->options().relocatable()
4504 && r_type
== elfcpp::R_MIPS_JALR
4506 && ((jalr_to_bal
&& val
== 0x0320f809) // jalr t9
4507 || (jr_to_b
&& val
== 0x03200008))) // jr t9
4509 int offset
= psymval
->value(object
, addend
) - (address
+ 4);
4510 if (!Bits
<18>::has_overflow32(offset
))
4512 if (val
== 0x03200008) // jr t9
4513 val
= 0x10000000 | (((Valtype32
)offset
>> 2) & 0xffff); // b addr
4515 val
= 0x04110000 | (((Valtype32
)offset
>> 2) & 0xffff); //bal addr
4520 *calculated_value
= val
;
4522 elfcpp::Swap
<32, big_endian
>::writeval(wv
, val
);
4524 return This::STATUS_OKAY
;
4527 // R_MIPS_PC32: S + A - P
4528 static inline typename
This::Status
4529 relpc32(unsigned char* view
, const Mips_relobj
<size
, big_endian
>* object
,
4530 const Symbol_value
<size
>* psymval
, Mips_address address
,
4531 Mips_address addend_a
, bool extract_addend
, bool calculate_only
,
4532 Valtype
* calculated_value
)
4534 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
4535 Valtype addend
= (extract_addend
4536 ? elfcpp::Swap
<32, big_endian
>::readval(wv
)
4538 Valtype x
= psymval
->value(object
, addend
) - address
;
4541 *calculated_value
= x
;
4543 elfcpp::Swap
<32, big_endian
>::writeval(wv
, x
);
4545 return This::STATUS_OKAY
;
4548 // R_MIPS_26, R_MIPS16_26, R_MICROMIPS_26_S1
4549 static inline typename
This::Status
4550 rel26(unsigned char* view
, const Mips_relobj
<size
, big_endian
>* object
,
4551 const Symbol_value
<size
>* psymval
, Mips_address address
,
4552 bool local
, Mips_address addend_a
, bool extract_addend
,
4553 const Symbol
* gsym
, bool cross_mode_jump
, unsigned int r_type
,
4554 bool jal_to_bal
, bool calculate_only
, Valtype
* calculated_value
)
4556 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
4557 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(wv
);
4562 if (r_type
== elfcpp::R_MICROMIPS_26_S1
)
4563 addend
= (val
& 0x03ffffff) << 1;
4565 addend
= (val
& 0x03ffffff) << 2;
4570 // Make sure the target of JALX is word-aligned. Bit 0 must be
4571 // the correct ISA mode selector and bit 1 must be 0.
4572 if (!calculate_only
&& cross_mode_jump
4573 && (psymval
->value(object
, 0) & 3) != (r_type
== elfcpp::R_MIPS_26
))
4575 gold_warning(_("JALX to a non-word-aligned address"));
4576 return This::STATUS_BAD_RELOC
;
4579 // Shift is 2, unusually, for microMIPS JALX.
4580 unsigned int shift
=
4581 (!cross_mode_jump
&& r_type
== elfcpp::R_MICROMIPS_26_S1
) ? 1 : 2;
4585 x
= addend
| ((address
+ 4) & (0xfc000000 << shift
));
4589 x
= Bits
<27>::sign_extend32(addend
);
4591 x
= Bits
<28>::sign_extend32(addend
);
4593 x
= psymval
->value(object
, x
) >> shift
;
4595 if (!calculate_only
&& !local
&& !gsym
->is_weak_undefined())
4597 if ((x
>> 26) != ((address
+ 4) >> (26 + shift
)))
4599 gold_error(_("relocation truncated to fit: %u against '%s'"),
4600 r_type
, gsym
->name());
4601 return This::STATUS_OVERFLOW
;
4605 val
= Bits
<32>::bit_select32(val
, x
, 0x03ffffff);
4607 // If required, turn JAL into JALX.
4608 if (cross_mode_jump
)
4611 Valtype32 opcode
= val
>> 26;
4612 Valtype32 jalx_opcode
;
4614 // Check to see if the opcode is already JAL or JALX.
4615 if (r_type
== elfcpp::R_MIPS16_26
)
4617 ok
= (opcode
== 0x6) || (opcode
== 0x7);
4620 else if (r_type
== elfcpp::R_MICROMIPS_26_S1
)
4622 ok
= (opcode
== 0x3d) || (opcode
== 0x3c);
4627 ok
= (opcode
== 0x3) || (opcode
== 0x1d);
4631 // If the opcode is not JAL or JALX, there's a problem. We cannot
4632 // convert J or JALS to JALX.
4633 if (!calculate_only
&& !ok
)
4635 gold_error(_("Unsupported jump between ISA modes; consider "
4636 "recompiling with interlinking enabled."));
4637 return This::STATUS_BAD_RELOC
;
4640 // Make this the JALX opcode.
4641 val
= (val
& ~(0x3f << 26)) | (jalx_opcode
<< 26);
4644 // Try converting JAL to BAL, if the target is in range.
4645 if (!parameters
->options().relocatable()
4648 && r_type
== elfcpp::R_MIPS_26
4649 && (val
>> 26) == 0x3))) // jal addr
4651 Valtype32 dest
= (x
<< 2) | (((address
+ 4) >> 28) << 28);
4652 int offset
= dest
- (address
+ 4);
4653 if (!Bits
<18>::has_overflow32(offset
))
4655 if (val
== 0x03200008) // jr t9
4656 val
= 0x10000000 | (((Valtype32
)offset
>> 2) & 0xffff); // b addr
4658 val
= 0x04110000 | (((Valtype32
)offset
>> 2) & 0xffff); //bal addr
4663 *calculated_value
= val
;
4665 elfcpp::Swap
<32, big_endian
>::writeval(wv
, val
);
4667 return This::STATUS_OKAY
;
4671 static inline typename
This::Status
4672 relpc16(unsigned char* view
, const Mips_relobj
<size
, big_endian
>* object
,
4673 const Symbol_value
<size
>* psymval
, Mips_address address
,
4674 Mips_address addend_a
, bool extract_addend
, bool calculate_only
,
4675 Valtype
* calculated_value
)
4677 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
4678 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(wv
);
4680 Valtype addend
= (extract_addend
4681 ? Bits
<18>::sign_extend32((val
& 0xffff) << 2)
4684 Valtype x
= psymval
->value(object
, addend
) - address
;
4685 val
= Bits
<16>::bit_select32(val
, x
>> 2, 0xffff);
4689 *calculated_value
= x
>> 2;
4690 return This::STATUS_OKAY
;
4693 elfcpp::Swap
<32, big_endian
>::writeval(wv
, val
);
4695 if (psymval
->value(object
, addend
) & 3)
4696 return This::STATUS_PCREL_UNALIGNED
;
4698 return check_overflow
<18>(x
);
4702 static inline typename
This::Status
4703 relpc21(unsigned char* view
, const Mips_relobj
<size
, big_endian
>* object
,
4704 const Symbol_value
<size
>* psymval
, Mips_address address
,
4705 Mips_address addend_a
, bool extract_addend
, bool calculate_only
,
4706 Valtype
* calculated_value
)
4708 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
4709 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(wv
);
4711 Valtype addend
= (extract_addend
4712 ? Bits
<23>::sign_extend32((val
& 0x1fffff) << 2)
4715 Valtype x
= psymval
->value(object
, addend
) - address
;
4716 val
= Bits
<21>::bit_select32(val
, x
>> 2, 0x1fffff);
4720 *calculated_value
= x
>> 2;
4721 return This::STATUS_OKAY
;
4724 elfcpp::Swap
<32, big_endian
>::writeval(wv
, val
);
4726 if (psymval
->value(object
, addend
) & 3)
4727 return This::STATUS_PCREL_UNALIGNED
;
4729 return check_overflow
<23>(x
);
4733 static inline typename
This::Status
4734 relpc26(unsigned char* view
, const Mips_relobj
<size
, big_endian
>* object
,
4735 const Symbol_value
<size
>* psymval
, Mips_address address
,
4736 Mips_address addend_a
, bool extract_addend
, bool calculate_only
,
4737 Valtype
* calculated_value
)
4739 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
4740 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(wv
);
4742 Valtype addend
= (extract_addend
4743 ? Bits
<28>::sign_extend32((val
& 0x3ffffff) << 2)
4746 Valtype x
= psymval
->value(object
, addend
) - address
;
4747 val
= Bits
<26>::bit_select32(val
, x
>> 2, 0x3ffffff);
4751 *calculated_value
= x
>> 2;
4752 return This::STATUS_OKAY
;
4755 elfcpp::Swap
<32, big_endian
>::writeval(wv
, val
);
4757 if (psymval
->value(object
, addend
) & 3)
4758 return This::STATUS_PCREL_UNALIGNED
;
4760 return check_overflow
<28>(x
);
4764 static inline typename
This::Status
4765 relpc18(unsigned char* view
, const Mips_relobj
<size
, big_endian
>* object
,
4766 const Symbol_value
<size
>* psymval
, Mips_address address
,
4767 Mips_address addend_a
, bool extract_addend
, bool calculate_only
,
4768 Valtype
* calculated_value
)
4770 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
4771 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(wv
);
4773 Valtype addend
= (extract_addend
4774 ? Bits
<21>::sign_extend32((val
& 0x3ffff) << 3)
4777 Valtype x
= psymval
->value(object
, addend
) - ((address
| 7) ^ 7);
4778 val
= Bits
<18>::bit_select32(val
, x
>> 3, 0x3ffff);
4782 *calculated_value
= x
>> 3;
4783 return This::STATUS_OKAY
;
4786 elfcpp::Swap
<32, big_endian
>::writeval(wv
, val
);
4788 if (psymval
->value(object
, addend
) & 7)
4789 return This::STATUS_PCREL_UNALIGNED
;
4791 return check_overflow
<21>(x
);
4795 static inline typename
This::Status
4796 relpc19(unsigned char* view
, const Mips_relobj
<size
, big_endian
>* object
,
4797 const Symbol_value
<size
>* psymval
, Mips_address address
,
4798 Mips_address addend_a
, bool extract_addend
, bool calculate_only
,
4799 Valtype
* calculated_value
)
4801 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
4802 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(wv
);
4804 Valtype addend
= (extract_addend
4805 ? Bits
<21>::sign_extend32((val
& 0x7ffff) << 2)
4808 Valtype x
= psymval
->value(object
, addend
) - address
;
4809 val
= Bits
<19>::bit_select32(val
, x
>> 2, 0x7ffff);
4813 *calculated_value
= x
>> 2;
4814 return This::STATUS_OKAY
;
4817 elfcpp::Swap
<32, big_endian
>::writeval(wv
, val
);
4819 if (psymval
->value(object
, addend
) & 3)
4820 return This::STATUS_PCREL_UNALIGNED
;
4822 return check_overflow
<21>(x
);
4826 static inline typename
This::Status
4827 relpchi16(unsigned char* view
, const Mips_relobj
<size
, big_endian
>* object
,
4828 const Symbol_value
<size
>* psymval
, Mips_address addend
,
4829 Mips_address address
, unsigned int r_sym
, bool extract_addend
)
4831 // Record the relocation. It will be resolved when we find pclo16 part.
4832 pchi16_relocs
.push_back(reloc_high
<size
, big_endian
>(view
, object
, psymval
,
4833 addend
, 0, r_sym
, extract_addend
, address
));
4834 return This::STATUS_OKAY
;
4838 static inline typename
This::Status
4839 do_relpchi16(unsigned char* view
, const Mips_relobj
<size
, big_endian
>* object
,
4840 const Symbol_value
<size
>* psymval
, Mips_address addend_hi
,
4841 Mips_address address
, bool extract_addend
, Valtype32 addend_lo
,
4842 bool calculate_only
, Valtype
* calculated_value
)
4844 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
4845 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(wv
);
4847 Valtype addend
= (extract_addend
? ((val
& 0xffff) << 16) + addend_lo
4850 Valtype value
= psymval
->value(object
, addend
) - address
;
4851 Valtype x
= ((value
+ 0x8000) >> 16) & 0xffff;
4852 val
= Bits
<32>::bit_select32(val
, x
, 0xffff);
4855 *calculated_value
= x
;
4857 elfcpp::Swap
<32, big_endian
>::writeval(wv
, val
);
4859 return This::STATUS_OKAY
;
4863 static inline typename
This::Status
4864 relpclo16(unsigned char* view
, const Mips_relobj
<size
, big_endian
>* object
,
4865 const Symbol_value
<size
>* psymval
, Mips_address addend_a
,
4866 bool extract_addend
, Mips_address address
, unsigned int r_sym
,
4867 unsigned int rel_type
, bool calculate_only
,
4868 Valtype
* calculated_value
)
4870 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
4871 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(wv
);
4873 Valtype addend
= (extract_addend
? Bits
<16>::sign_extend32(val
& 0xffff)
4876 if (rel_type
== elfcpp::SHT_REL
)
4878 // Resolve pending R_MIPS_PCHI16 relocations.
4879 typename
std::list
<reloc_high
<size
, big_endian
> >::iterator it
=
4880 pchi16_relocs
.begin();
4881 while (it
!= pchi16_relocs
.end())
4883 reloc_high
<size
, big_endian
> pchi16
= *it
;
4884 if (pchi16
.r_sym
== r_sym
)
4886 do_relpchi16(pchi16
.view
, pchi16
.object
, pchi16
.psymval
,
4887 pchi16
.addend
, pchi16
.address
,
4888 pchi16
.extract_addend
, addend
, calculate_only
,
4890 it
= pchi16_relocs
.erase(it
);
4897 // Resolve R_MIPS_PCLO16 relocation.
4898 Valtype x
= psymval
->value(object
, addend
) - address
;
4899 val
= Bits
<32>::bit_select32(val
, x
, 0xffff);
4902 *calculated_value
= x
;
4904 elfcpp::Swap
<32, big_endian
>::writeval(wv
, val
);
4906 return This::STATUS_OKAY
;
4909 // R_MICROMIPS_PC7_S1
4910 static inline typename
This::Status
4911 relmicromips_pc7_s1(unsigned char* view
,
4912 const Mips_relobj
<size
, big_endian
>* object
,
4913 const Symbol_value
<size
>* psymval
, Mips_address address
,
4914 Mips_address addend_a
, bool extract_addend
,
4915 bool calculate_only
, Valtype
* calculated_value
)
4917 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
4918 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(wv
);
4920 Valtype addend
= extract_addend
? Bits
<8>::sign_extend32((val
& 0x7f) << 1)
4923 Valtype x
= psymval
->value(object
, addend
) - address
;
4924 val
= Bits
<16>::bit_select32(val
, x
>> 1, 0x7f);
4928 *calculated_value
= x
>> 1;
4929 return This::STATUS_OKAY
;
4932 elfcpp::Swap
<32, big_endian
>::writeval(wv
, val
);
4934 return check_overflow
<8>(x
);
4937 // R_MICROMIPS_PC10_S1
4938 static inline typename
This::Status
4939 relmicromips_pc10_s1(unsigned char* view
,
4940 const Mips_relobj
<size
, big_endian
>* object
,
4941 const Symbol_value
<size
>* psymval
, Mips_address address
,
4942 Mips_address addend_a
, bool extract_addend
,
4943 bool calculate_only
, Valtype
* calculated_value
)
4945 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
4946 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(wv
);
4948 Valtype addend
= (extract_addend
4949 ? Bits
<11>::sign_extend32((val
& 0x3ff) << 1)
4952 Valtype x
= psymval
->value(object
, addend
) - address
;
4953 val
= Bits
<16>::bit_select32(val
, x
>> 1, 0x3ff);
4957 *calculated_value
= x
>> 1;
4958 return This::STATUS_OKAY
;
4961 elfcpp::Swap
<32, big_endian
>::writeval(wv
, val
);
4963 return check_overflow
<11>(x
);
4966 // R_MICROMIPS_PC16_S1
4967 static inline typename
This::Status
4968 relmicromips_pc16_s1(unsigned char* view
,
4969 const Mips_relobj
<size
, big_endian
>* object
,
4970 const Symbol_value
<size
>* psymval
, Mips_address address
,
4971 Mips_address addend_a
, bool extract_addend
,
4972 bool calculate_only
, Valtype
* calculated_value
)
4974 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
4975 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(wv
);
4977 Valtype addend
= (extract_addend
4978 ? Bits
<17>::sign_extend32((val
& 0xffff) << 1)
4981 Valtype x
= psymval
->value(object
, addend
) - address
;
4982 val
= Bits
<16>::bit_select32(val
, x
>> 1, 0xffff);
4986 *calculated_value
= x
>> 1;
4987 return This::STATUS_OKAY
;
4990 elfcpp::Swap
<32, big_endian
>::writeval(wv
, val
);
4992 return check_overflow
<17>(x
);
4995 // R_MIPS_HI16, R_MIPS16_HI16, R_MICROMIPS_HI16,
4996 static inline typename
This::Status
4997 relhi16(unsigned char* view
, const Mips_relobj
<size
, big_endian
>* object
,
4998 const Symbol_value
<size
>* psymval
, Mips_address addend
,
4999 Mips_address address
, bool gp_disp
, unsigned int r_type
,
5000 unsigned int r_sym
, bool extract_addend
)
5002 // Record the relocation. It will be resolved when we find lo16 part.
5003 hi16_relocs
.push_back(reloc_high
<size
, big_endian
>(view
, object
, psymval
,
5004 addend
, r_type
, r_sym
, extract_addend
, address
,
5006 return This::STATUS_OKAY
;
5009 // R_MIPS_HI16, R_MIPS16_HI16, R_MICROMIPS_HI16,
5010 static inline typename
This::Status
5011 do_relhi16(unsigned char* view
, const Mips_relobj
<size
, big_endian
>* object
,
5012 const Symbol_value
<size
>* psymval
, Mips_address addend_hi
,
5013 Mips_address address
, bool is_gp_disp
, unsigned int r_type
,
5014 bool extract_addend
, Valtype32 addend_lo
,
5015 Target_mips
<size
, big_endian
>* target
, bool calculate_only
,
5016 Valtype
* calculated_value
)
5018 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
5019 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(wv
);
5021 Valtype addend
= (extract_addend
? ((val
& 0xffff) << 16) + addend_lo
5026 value
= psymval
->value(object
, addend
);
5029 // For MIPS16 ABI code we generate this sequence
5030 // 0: li $v0,%hi(_gp_disp)
5031 // 4: addiupc $v1,%lo(_gp_disp)
5035 // So the offsets of hi and lo relocs are the same, but the
5036 // base $pc is that used by the ADDIUPC instruction at $t9 + 4.
5037 // ADDIUPC clears the low two bits of the instruction address,
5038 // so the base is ($t9 + 4) & ~3.
5040 if (r_type
== elfcpp::R_MIPS16_HI16
)
5041 gp_disp
= (target
->adjusted_gp_value(object
)
5042 - ((address
+ 4) & ~0x3));
5043 // The microMIPS .cpload sequence uses the same assembly
5044 // instructions as the traditional psABI version, but the
5045 // incoming $t9 has the low bit set.
5046 else if (r_type
== elfcpp::R_MICROMIPS_HI16
)
5047 gp_disp
= target
->adjusted_gp_value(object
) - address
- 1;
5049 gp_disp
= target
->adjusted_gp_value(object
) - address
;
5050 value
= gp_disp
+ addend
;
5052 Valtype x
= ((value
+ 0x8000) >> 16) & 0xffff;
5053 val
= Bits
<32>::bit_select32(val
, x
, 0xffff);
5057 *calculated_value
= x
;
5058 return This::STATUS_OKAY
;
5061 elfcpp::Swap
<32, big_endian
>::writeval(wv
, val
);
5063 return (is_gp_disp
? check_overflow
<16>(x
)
5064 : This::STATUS_OKAY
);
5067 // R_MIPS_GOT16, R_MIPS16_GOT16, R_MICROMIPS_GOT16
5068 static inline typename
This::Status
5069 relgot16_local(unsigned char* view
,
5070 const Mips_relobj
<size
, big_endian
>* object
,
5071 const Symbol_value
<size
>* psymval
, Mips_address addend_a
,
5072 bool extract_addend
, unsigned int r_type
, unsigned int r_sym
)
5074 // Record the relocation. It will be resolved when we find lo16 part.
5075 got16_relocs
.push_back(reloc_high
<size
, big_endian
>(view
, object
, psymval
,
5076 addend_a
, r_type
, r_sym
, extract_addend
));
5077 return This::STATUS_OKAY
;
5080 // R_MIPS_GOT16, R_MIPS16_GOT16, R_MICROMIPS_GOT16
5081 static inline typename
This::Status
5082 do_relgot16_local(unsigned char* view
,
5083 const Mips_relobj
<size
, big_endian
>* object
,
5084 const Symbol_value
<size
>* psymval
, Mips_address addend_hi
,
5085 bool extract_addend
, Valtype32 addend_lo
,
5086 Target_mips
<size
, big_endian
>* target
, bool calculate_only
,
5087 Valtype
* calculated_value
)
5089 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
5090 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(wv
);
5092 Valtype addend
= (extract_addend
? ((val
& 0xffff) << 16) + addend_lo
5095 // Find GOT page entry.
5096 Mips_address value
= ((psymval
->value(object
, addend
) + 0x8000) >> 16)
5099 unsigned int got_offset
=
5100 target
->got_section()->get_got_page_offset(value
, object
);
5102 // Resolve the relocation.
5103 Valtype x
= target
->got_section()->gp_offset(got_offset
, object
);
5104 val
= Bits
<32>::bit_select32(val
, x
, 0xffff);
5108 *calculated_value
= x
;
5109 return This::STATUS_OKAY
;
5112 elfcpp::Swap
<32, big_endian
>::writeval(wv
, val
);
5114 return check_overflow
<16>(x
);
5117 // R_MIPS_LO16, R_MIPS16_LO16, R_MICROMIPS_LO16, R_MICROMIPS_HI0_LO16
5118 static inline typename
This::Status
5119 rello16(Target_mips
<size
, big_endian
>* target
, unsigned char* view
,
5120 const Mips_relobj
<size
, big_endian
>* object
,
5121 const Symbol_value
<size
>* psymval
, Mips_address addend_a
,
5122 bool extract_addend
, Mips_address address
, bool is_gp_disp
,
5123 unsigned int r_type
, unsigned int r_sym
, unsigned int rel_type
,
5124 bool calculate_only
, Valtype
* calculated_value
)
5126 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
5127 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(wv
);
5129 Valtype addend
= (extract_addend
? Bits
<16>::sign_extend32(val
& 0xffff)
5132 if (rel_type
== elfcpp::SHT_REL
)
5134 typename
This::Status reloc_status
= This::STATUS_OKAY
;
5135 // Resolve pending R_MIPS_HI16 relocations.
5136 typename
std::list
<reloc_high
<size
, big_endian
> >::iterator it
=
5137 hi16_relocs
.begin();
5138 while (it
!= hi16_relocs
.end())
5140 reloc_high
<size
, big_endian
> hi16
= *it
;
5141 if (hi16
.r_sym
== r_sym
5142 && is_matching_lo16_reloc(hi16
.r_type
, r_type
))
5144 mips_reloc_unshuffle(hi16
.view
, hi16
.r_type
, false);
5145 reloc_status
= do_relhi16(hi16
.view
, hi16
.object
, hi16
.psymval
,
5146 hi16
.addend
, hi16
.address
, hi16
.gp_disp
,
5147 hi16
.r_type
, hi16
.extract_addend
, addend
,
5148 target
, calculate_only
, calculated_value
);
5149 mips_reloc_shuffle(hi16
.view
, hi16
.r_type
, false);
5150 if (reloc_status
== This::STATUS_OVERFLOW
)
5151 return This::STATUS_OVERFLOW
;
5152 it
= hi16_relocs
.erase(it
);
5158 // Resolve pending local R_MIPS_GOT16 relocations.
5159 typename
std::list
<reloc_high
<size
, big_endian
> >::iterator it2
=
5160 got16_relocs
.begin();
5161 while (it2
!= got16_relocs
.end())
5163 reloc_high
<size
, big_endian
> got16
= *it2
;
5164 if (got16
.r_sym
== r_sym
5165 && is_matching_lo16_reloc(got16
.r_type
, r_type
))
5167 mips_reloc_unshuffle(got16
.view
, got16
.r_type
, false);
5169 reloc_status
= do_relgot16_local(got16
.view
, got16
.object
,
5170 got16
.psymval
, got16
.addend
,
5171 got16
.extract_addend
, addend
, target
,
5172 calculate_only
, calculated_value
);
5174 mips_reloc_shuffle(got16
.view
, got16
.r_type
, false);
5175 if (reloc_status
== This::STATUS_OVERFLOW
)
5176 return This::STATUS_OVERFLOW
;
5177 it2
= got16_relocs
.erase(it2
);
5184 // Resolve R_MIPS_LO16 relocation.
5187 x
= psymval
->value(object
, addend
);
5190 // See the comment for R_MIPS16_HI16 above for the reason
5191 // for this conditional.
5193 if (r_type
== elfcpp::R_MIPS16_LO16
)
5194 gp_disp
= target
->adjusted_gp_value(object
) - (address
& ~0x3);
5195 else if (r_type
== elfcpp::R_MICROMIPS_LO16
5196 || r_type
== elfcpp::R_MICROMIPS_HI0_LO16
)
5197 gp_disp
= target
->adjusted_gp_value(object
) - address
+ 3;
5199 gp_disp
= target
->adjusted_gp_value(object
) - address
+ 4;
5200 // The MIPS ABI requires checking the R_MIPS_LO16 relocation
5201 // for overflow. Relocations against _gp_disp are normally
5202 // generated from the .cpload pseudo-op. It generates code
5203 // that normally looks like this:
5205 // lui $gp,%hi(_gp_disp)
5206 // addiu $gp,$gp,%lo(_gp_disp)
5209 // Here $t9 holds the address of the function being called,
5210 // as required by the MIPS ELF ABI. The R_MIPS_LO16
5211 // relocation can easily overflow in this situation, but the
5212 // R_MIPS_HI16 relocation will handle the overflow.
5213 // Therefore, we consider this a bug in the MIPS ABI, and do
5214 // not check for overflow here.
5215 x
= gp_disp
+ addend
;
5217 val
= Bits
<32>::bit_select32(val
, x
, 0xffff);
5220 *calculated_value
= x
;
5222 elfcpp::Swap
<32, big_endian
>::writeval(wv
, val
);
5224 return This::STATUS_OKAY
;
5227 // R_MIPS_CALL16, R_MIPS16_CALL16, R_MICROMIPS_CALL16
5228 // R_MIPS_GOT16, R_MIPS16_GOT16, R_MICROMIPS_GOT16
5229 // R_MIPS_TLS_GD, R_MIPS16_TLS_GD, R_MICROMIPS_TLS_GD
5230 // R_MIPS_TLS_GOTTPREL, R_MIPS16_TLS_GOTTPREL, R_MICROMIPS_TLS_GOTTPREL
5231 // R_MIPS_TLS_LDM, R_MIPS16_TLS_LDM, R_MICROMIPS_TLS_LDM
5232 // R_MIPS_GOT_DISP, R_MICROMIPS_GOT_DISP
5233 static inline typename
This::Status
5234 relgot(unsigned char* view
, int gp_offset
, bool calculate_only
,
5235 Valtype
* calculated_value
)
5237 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
5238 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(wv
);
5239 Valtype x
= gp_offset
;
5240 val
= Bits
<32>::bit_select32(val
, x
, 0xffff);
5244 *calculated_value
= x
;
5245 return This::STATUS_OKAY
;
5248 elfcpp::Swap
<32, big_endian
>::writeval(wv
, val
);
5250 return check_overflow
<16>(x
);
5254 static inline typename
This::Status
5255 releh(unsigned char* view
, int gp_offset
, bool calculate_only
,
5256 Valtype
* calculated_value
)
5258 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
5259 Valtype x
= gp_offset
;
5263 *calculated_value
= x
;
5264 return This::STATUS_OKAY
;
5267 elfcpp::Swap
<32, big_endian
>::writeval(wv
, x
);
5269 return check_overflow
<32>(x
);
5272 // R_MIPS_GOT_PAGE, R_MICROMIPS_GOT_PAGE
5273 static inline typename
This::Status
5274 relgotpage(Target_mips
<size
, big_endian
>* target
, unsigned char* view
,
5275 const Mips_relobj
<size
, big_endian
>* object
,
5276 const Symbol_value
<size
>* psymval
, Mips_address addend_a
,
5277 bool extract_addend
, bool calculate_only
,
5278 Valtype
* calculated_value
)
5280 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
5281 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(view
);
5282 Valtype addend
= extract_addend
? val
& 0xffff : addend_a
;
5284 // Find a GOT page entry that points to within 32KB of symbol + addend.
5285 Mips_address value
= (psymval
->value(object
, addend
) + 0x8000) & ~0xffff;
5286 unsigned int got_offset
=
5287 target
->got_section()->get_got_page_offset(value
, object
);
5289 Valtype x
= target
->got_section()->gp_offset(got_offset
, object
);
5290 val
= Bits
<32>::bit_select32(val
, x
, 0xffff);
5294 *calculated_value
= x
;
5295 return This::STATUS_OKAY
;
5298 elfcpp::Swap
<32, big_endian
>::writeval(wv
, val
);
5300 return check_overflow
<16>(x
);
5303 // R_MIPS_GOT_OFST, R_MICROMIPS_GOT_OFST
5304 static inline typename
This::Status
5305 relgotofst(Target_mips
<size
, big_endian
>* target
, unsigned char* view
,
5306 const Mips_relobj
<size
, big_endian
>* object
,
5307 const Symbol_value
<size
>* psymval
, Mips_address addend_a
,
5308 bool extract_addend
, bool local
, bool calculate_only
,
5309 Valtype
* calculated_value
)
5311 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
5312 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(view
);
5313 Valtype addend
= extract_addend
? val
& 0xffff : addend_a
;
5315 // For a local symbol, find a GOT page entry that points to within 32KB of
5316 // symbol + addend. Relocation value is the offset of the GOT page entry's
5317 // value from symbol + addend.
5318 // For a global symbol, relocation value is addend.
5322 // Find GOT page entry.
5323 Mips_address value
= ((psymval
->value(object
, addend
) + 0x8000)
5325 target
->got_section()->get_got_page_offset(value
, object
);
5327 x
= psymval
->value(object
, addend
) - value
;
5331 val
= Bits
<32>::bit_select32(val
, x
, 0xffff);
5335 *calculated_value
= x
;
5336 return This::STATUS_OKAY
;
5339 elfcpp::Swap
<32, big_endian
>::writeval(wv
, val
);
5341 return check_overflow
<16>(x
);
5344 // R_MIPS_GOT_HI16, R_MIPS_CALL_HI16,
5345 // R_MICROMIPS_GOT_HI16, R_MICROMIPS_CALL_HI16
5346 static inline typename
This::Status
5347 relgot_hi16(unsigned char* view
, int gp_offset
, bool calculate_only
,
5348 Valtype
* calculated_value
)
5350 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
5351 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(wv
);
5352 Valtype x
= gp_offset
;
5353 x
= ((x
+ 0x8000) >> 16) & 0xffff;
5354 val
= Bits
<32>::bit_select32(val
, x
, 0xffff);
5357 *calculated_value
= x
;
5359 elfcpp::Swap
<32, big_endian
>::writeval(wv
, val
);
5361 return This::STATUS_OKAY
;
5364 // R_MIPS_GOT_LO16, R_MIPS_CALL_LO16,
5365 // R_MICROMIPS_GOT_LO16, R_MICROMIPS_CALL_LO16
5366 static inline typename
This::Status
5367 relgot_lo16(unsigned char* view
, int gp_offset
, bool calculate_only
,
5368 Valtype
* calculated_value
)
5370 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
5371 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(wv
);
5372 Valtype x
= gp_offset
;
5373 val
= Bits
<32>::bit_select32(val
, x
, 0xffff);
5376 *calculated_value
= x
;
5378 elfcpp::Swap
<32, big_endian
>::writeval(wv
, val
);
5380 return This::STATUS_OKAY
;
5383 // R_MIPS_GPREL16, R_MIPS16_GPREL, R_MIPS_LITERAL, R_MICROMIPS_LITERAL
5384 // R_MICROMIPS_GPREL7_S2, R_MICROMIPS_GPREL16
5385 static inline typename
This::Status
5386 relgprel(unsigned char* view
, const Mips_relobj
<size
, big_endian
>* object
,
5387 const Symbol_value
<size
>* psymval
, Mips_address gp
,
5388 Mips_address addend_a
, bool extract_addend
, bool local
,
5389 unsigned int r_type
, bool calculate_only
,
5390 Valtype
* calculated_value
)
5392 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
5393 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(wv
);
5398 if (r_type
== elfcpp::R_MICROMIPS_GPREL7_S2
)
5399 addend
= (val
& 0x7f) << 2;
5401 addend
= val
& 0xffff;
5402 // Only sign-extend the addend if it was extracted from the
5403 // instruction. If the addend was separate, leave it alone,
5404 // otherwise we may lose significant bits.
5405 addend
= Bits
<16>::sign_extend32(addend
);
5410 Valtype x
= psymval
->value(object
, addend
) - gp
;
5412 // If the symbol was local, any earlier relocatable links will
5413 // have adjusted its addend with the gp offset, so compensate
5414 // for that now. Don't do it for symbols forced local in this
5415 // link, though, since they won't have had the gp offset applied
5418 x
+= object
->gp_value();
5420 if (r_type
== elfcpp::R_MICROMIPS_GPREL7_S2
)
5421 val
= Bits
<32>::bit_select32(val
, x
, 0x7f);
5423 val
= Bits
<32>::bit_select32(val
, x
, 0xffff);
5427 *calculated_value
= x
;
5428 return This::STATUS_OKAY
;
5431 elfcpp::Swap
<32, big_endian
>::writeval(wv
, val
);
5433 if (check_overflow
<16>(x
) == This::STATUS_OVERFLOW
)
5435 gold_error(_("small-data section exceeds 64KB; lower small-data size "
5436 "limit (see option -G)"));
5437 return This::STATUS_OVERFLOW
;
5439 return This::STATUS_OKAY
;
5443 static inline typename
This::Status
5444 relgprel32(unsigned char* view
, const Mips_relobj
<size
, big_endian
>* object
,
5445 const Symbol_value
<size
>* psymval
, Mips_address gp
,
5446 Mips_address addend_a
, bool extract_addend
, bool calculate_only
,
5447 Valtype
* calculated_value
)
5449 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
5450 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(wv
);
5451 Valtype addend
= extract_addend
? val
: addend_a
;
5453 // R_MIPS_GPREL32 relocations are defined for local symbols only.
5454 Valtype x
= psymval
->value(object
, addend
) + object
->gp_value() - gp
;
5457 *calculated_value
= x
;
5459 elfcpp::Swap
<32, big_endian
>::writeval(wv
, x
);
5461 return This::STATUS_OKAY
;
5464 // R_MIPS_TLS_TPREL_HI16, R_MIPS16_TLS_TPREL_HI16, R_MICROMIPS_TLS_TPREL_HI16
5465 // R_MIPS_TLS_DTPREL_HI16, R_MIPS16_TLS_DTPREL_HI16,
5466 // R_MICROMIPS_TLS_DTPREL_HI16
5467 static inline typename
This::Status
5468 tlsrelhi16(unsigned char* view
, const Mips_relobj
<size
, big_endian
>* object
,
5469 const Symbol_value
<size
>* psymval
, Valtype32 tp_offset
,
5470 Mips_address addend_a
, bool extract_addend
, bool calculate_only
,
5471 Valtype
* calculated_value
)
5473 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
5474 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(wv
);
5475 Valtype addend
= extract_addend
? val
& 0xffff : addend_a
;
5477 // tls symbol values are relative to tls_segment()->vaddr()
5478 Valtype x
= ((psymval
->value(object
, addend
) - tp_offset
) + 0x8000) >> 16;
5479 val
= Bits
<32>::bit_select32(val
, x
, 0xffff);
5482 *calculated_value
= x
;
5484 elfcpp::Swap
<32, big_endian
>::writeval(wv
, val
);
5486 return This::STATUS_OKAY
;
5489 // R_MIPS_TLS_TPREL_LO16, R_MIPS16_TLS_TPREL_LO16, R_MICROMIPS_TLS_TPREL_LO16,
5490 // R_MIPS_TLS_DTPREL_LO16, R_MIPS16_TLS_DTPREL_LO16,
5491 // R_MICROMIPS_TLS_DTPREL_LO16,
5492 static inline typename
This::Status
5493 tlsrello16(unsigned char* view
, const Mips_relobj
<size
, big_endian
>* object
,
5494 const Symbol_value
<size
>* psymval
, Valtype32 tp_offset
,
5495 Mips_address addend_a
, bool extract_addend
, bool calculate_only
,
5496 Valtype
* calculated_value
)
5498 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
5499 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(wv
);
5500 Valtype addend
= extract_addend
? val
& 0xffff : addend_a
;
5502 // tls symbol values are relative to tls_segment()->vaddr()
5503 Valtype x
= psymval
->value(object
, addend
) - tp_offset
;
5504 val
= Bits
<32>::bit_select32(val
, x
, 0xffff);
5507 *calculated_value
= x
;
5509 elfcpp::Swap
<32, big_endian
>::writeval(wv
, val
);
5511 return This::STATUS_OKAY
;
5514 // R_MIPS_TLS_TPREL32, R_MIPS_TLS_TPREL64,
5515 // R_MIPS_TLS_DTPREL32, R_MIPS_TLS_DTPREL64
5516 static inline typename
This::Status
5517 tlsrel32(unsigned char* view
, const Mips_relobj
<size
, big_endian
>* object
,
5518 const Symbol_value
<size
>* psymval
, Valtype32 tp_offset
,
5519 Mips_address addend_a
, bool extract_addend
, bool calculate_only
,
5520 Valtype
* calculated_value
)
5522 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
5523 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(wv
);
5524 Valtype addend
= extract_addend
? val
: addend_a
;
5526 // tls symbol values are relative to tls_segment()->vaddr()
5527 Valtype x
= psymval
->value(object
, addend
) - tp_offset
;
5530 *calculated_value
= x
;
5532 elfcpp::Swap
<32, big_endian
>::writeval(wv
, x
);
5534 return This::STATUS_OKAY
;
5537 // R_MIPS_SUB, R_MICROMIPS_SUB
5538 static inline typename
This::Status
5539 relsub(unsigned char* view
, const Mips_relobj
<size
, big_endian
>* object
,
5540 const Symbol_value
<size
>* psymval
, Mips_address addend_a
,
5541 bool extract_addend
, bool calculate_only
, Valtype
* calculated_value
)
5543 Valtype64
* wv
= reinterpret_cast<Valtype64
*>(view
);
5544 Valtype64 addend
= (extract_addend
5545 ? elfcpp::Swap
<64, big_endian
>::readval(wv
)
5548 Valtype64 x
= psymval
->value(object
, -addend
);
5550 *calculated_value
= x
;
5552 elfcpp::Swap
<64, big_endian
>::writeval(wv
, x
);
5554 return This::STATUS_OKAY
;
5558 static inline typename
This::Status
5559 rel64(unsigned char* view
, const Mips_relobj
<size
, big_endian
>* object
,
5560 const Symbol_value
<size
>* psymval
, Mips_address addend_a
,
5561 bool extract_addend
, bool calculate_only
, Valtype
* calculated_value
,
5562 bool apply_addend_only
)
5564 Valtype64
* wv
= reinterpret_cast<Valtype64
*>(view
);
5565 Valtype64 addend
= (extract_addend
5566 ? elfcpp::Swap
<64, big_endian
>::readval(wv
)
5569 Valtype64 x
= psymval
->value(object
, addend
);
5571 *calculated_value
= x
;
5574 if (apply_addend_only
)
5576 elfcpp::Swap
<64, big_endian
>::writeval(wv
, x
);
5579 return This::STATUS_OKAY
;
5582 // R_MIPS_HIGHER, R_MICROMIPS_HIGHER
5583 static inline typename
This::Status
5584 relhigher(unsigned char* view
, const Mips_relobj
<size
, big_endian
>* object
,
5585 const Symbol_value
<size
>* psymval
, Mips_address addend_a
,
5586 bool extract_addend
, bool calculate_only
, Valtype
* calculated_value
)
5588 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
5589 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(wv
);
5590 Valtype addend
= (extract_addend
? Bits
<16>::sign_extend32(val
& 0xffff)
5593 Valtype x
= psymval
->value(object
, addend
);
5594 x
= ((x
+ (uint64_t) 0x80008000) >> 32) & 0xffff;
5595 val
= Bits
<32>::bit_select32(val
, x
, 0xffff);
5598 *calculated_value
= x
;
5600 elfcpp::Swap
<32, big_endian
>::writeval(wv
, val
);
5602 return This::STATUS_OKAY
;
5605 // R_MIPS_HIGHEST, R_MICROMIPS_HIGHEST
5606 static inline typename
This::Status
5607 relhighest(unsigned char* view
, const Mips_relobj
<size
, big_endian
>* object
,
5608 const Symbol_value
<size
>* psymval
, Mips_address addend_a
,
5609 bool extract_addend
, bool calculate_only
,
5610 Valtype
* calculated_value
)
5612 Valtype32
* wv
= reinterpret_cast<Valtype32
*>(view
);
5613 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(wv
);
5614 Valtype addend
= (extract_addend
? Bits
<16>::sign_extend32(val
& 0xffff)
5617 Valtype x
= psymval
->value(object
, addend
);
5618 x
= ((x
+ (uint64_t) 0x800080008000) >> 48) & 0xffff;
5619 val
= Bits
<32>::bit_select32(val
, x
, 0xffff);
5622 *calculated_value
= x
;
5624 elfcpp::Swap
<32, big_endian
>::writeval(wv
, val
);
5626 return This::STATUS_OKAY
;
5630 template<int size
, bool big_endian
>
5631 typename
std::list
<reloc_high
<size
, big_endian
> >
5632 Mips_relocate_functions
<size
, big_endian
>::hi16_relocs
;
5634 template<int size
, bool big_endian
>
5635 typename
std::list
<reloc_high
<size
, big_endian
> >
5636 Mips_relocate_functions
<size
, big_endian
>::got16_relocs
;
5638 template<int size
, bool big_endian
>
5639 typename
std::list
<reloc_high
<size
, big_endian
> >
5640 Mips_relocate_functions
<size
, big_endian
>::pchi16_relocs
;
5642 // Mips_got_info methods.
5644 // Reserve GOT entry for a GOT relocation of type R_TYPE against symbol
5645 // SYMNDX + ADDEND, where SYMNDX is a local symbol in section SHNDX in OBJECT.
5647 template<int size
, bool big_endian
>
5649 Mips_got_info
<size
, big_endian
>::record_local_got_symbol(
5650 Mips_relobj
<size
, big_endian
>* object
, unsigned int symndx
,
5651 Mips_address addend
, unsigned int r_type
, unsigned int shndx
,
5652 bool is_section_symbol
)
5654 Mips_got_entry
<size
, big_endian
>* entry
=
5655 new Mips_got_entry
<size
, big_endian
>(object
, symndx
, addend
,
5656 mips_elf_reloc_tls_type(r_type
),
5657 shndx
, is_section_symbol
);
5658 this->record_got_entry(entry
, object
);
5661 // Reserve GOT entry for a GOT relocation of type R_TYPE against MIPS_SYM,
5662 // in OBJECT. FOR_CALL is true if the caller is only interested in
5663 // using the GOT entry for calls. DYN_RELOC is true if R_TYPE is a dynamic
5666 template<int size
, bool big_endian
>
5668 Mips_got_info
<size
, big_endian
>::record_global_got_symbol(
5669 Mips_symbol
<size
>* mips_sym
, Mips_relobj
<size
, big_endian
>* object
,
5670 unsigned int r_type
, bool dyn_reloc
, bool for_call
)
5673 mips_sym
->set_got_not_only_for_calls();
5675 // A global symbol in the GOT must also be in the dynamic symbol table.
5676 if (!mips_sym
->needs_dynsym_entry() && !mips_sym
->is_forced_local())
5678 switch (mips_sym
->visibility())
5680 case elfcpp::STV_INTERNAL
:
5681 case elfcpp::STV_HIDDEN
:
5682 mips_sym
->set_is_forced_local();
5685 mips_sym
->set_needs_dynsym_entry();
5690 unsigned char tls_type
= mips_elf_reloc_tls_type(r_type
);
5691 if (tls_type
== GOT_TLS_NONE
)
5692 this->global_got_symbols_
.insert(mips_sym
);
5696 if (mips_sym
->global_got_area() == GGA_NONE
)
5697 mips_sym
->set_global_got_area(GGA_RELOC_ONLY
);
5701 Mips_got_entry
<size
, big_endian
>* entry
=
5702 new Mips_got_entry
<size
, big_endian
>(mips_sym
, tls_type
);
5704 this->record_got_entry(entry
, object
);
5707 // Add ENTRY to master GOT and to OBJECT's GOT.
5709 template<int size
, bool big_endian
>
5711 Mips_got_info
<size
, big_endian
>::record_got_entry(
5712 Mips_got_entry
<size
, big_endian
>* entry
,
5713 Mips_relobj
<size
, big_endian
>* object
)
5715 this->got_entries_
.insert(entry
);
5717 // Create the GOT entry for the OBJECT's GOT.
5718 Mips_got_info
<size
, big_endian
>* g
= object
->get_or_create_got_info();
5719 Mips_got_entry
<size
, big_endian
>* entry2
=
5720 new Mips_got_entry
<size
, big_endian
>(*entry
);
5722 g
->got_entries_
.insert(entry2
);
5725 // Record that OBJECT has a page relocation against symbol SYMNDX and
5726 // that ADDEND is the addend for that relocation.
5727 // This function creates an upper bound on the number of GOT slots
5728 // required; no attempt is made to combine references to non-overridable
5729 // global symbols across multiple input files.
5731 template<int size
, bool big_endian
>
5733 Mips_got_info
<size
, big_endian
>::record_got_page_entry(
5734 Mips_relobj
<size
, big_endian
>* object
, unsigned int symndx
, int addend
)
5736 struct Got_page_range
**range_ptr
, *range
;
5737 int old_pages
, new_pages
;
5739 // Find the Got_page_entry for this symbol.
5740 Got_page_entry
* entry
= new Got_page_entry(object
, symndx
);
5741 typename
Got_page_entry_set::iterator it
=
5742 this->got_page_entries_
.find(entry
);
5743 if (it
!= this->got_page_entries_
.end())
5746 this->got_page_entries_
.insert(entry
);
5748 // Add the same entry to the OBJECT's GOT.
5749 Got_page_entry
* entry2
= NULL
;
5750 Mips_got_info
<size
, big_endian
>* g2
= object
->get_or_create_got_info();
5751 if (g2
->got_page_entries_
.find(entry
) == g2
->got_page_entries_
.end())
5753 entry2
= new Got_page_entry(*entry
);
5754 g2
->got_page_entries_
.insert(entry2
);
5757 // Skip over ranges whose maximum extent cannot share a page entry
5759 range_ptr
= &entry
->ranges
;
5760 while (*range_ptr
&& addend
> (*range_ptr
)->max_addend
+ 0xffff)
5761 range_ptr
= &(*range_ptr
)->next
;
5763 // If we scanned to the end of the list, or found a range whose
5764 // minimum extent cannot share a page entry with ADDEND, create
5765 // a new singleton range.
5767 if (!range
|| addend
< range
->min_addend
- 0xffff)
5769 range
= new Got_page_range();
5770 range
->next
= *range_ptr
;
5771 range
->min_addend
= addend
;
5772 range
->max_addend
= addend
;
5777 ++entry2
->num_pages
;
5778 ++this->page_gotno_
;
5783 // Remember how many pages the old range contributed.
5784 old_pages
= range
->get_max_pages();
5786 // Update the ranges.
5787 if (addend
< range
->min_addend
)
5788 range
->min_addend
= addend
;
5789 else if (addend
> range
->max_addend
)
5791 if (range
->next
&& addend
>= range
->next
->min_addend
- 0xffff)
5793 old_pages
+= range
->next
->get_max_pages();
5794 range
->max_addend
= range
->next
->max_addend
;
5795 range
->next
= range
->next
->next
;
5798 range
->max_addend
= addend
;
5801 // Record any change in the total estimate.
5802 new_pages
= range
->get_max_pages();
5803 if (old_pages
!= new_pages
)
5805 entry
->num_pages
+= new_pages
- old_pages
;
5807 entry2
->num_pages
+= new_pages
- old_pages
;
5808 this->page_gotno_
+= new_pages
- old_pages
;
5809 g2
->page_gotno_
+= new_pages
- old_pages
;
5813 // Create all entries that should be in the local part of the GOT.
5815 template<int size
, bool big_endian
>
5817 Mips_got_info
<size
, big_endian
>::add_local_entries(
5818 Target_mips
<size
, big_endian
>* target
, Layout
* layout
)
5820 Mips_output_data_got
<size
, big_endian
>* got
= target
->got_section();
5821 // First two GOT entries are reserved. The first entry will be filled at
5822 // runtime. The second entry will be used by some runtime loaders.
5823 got
->add_constant(0);
5824 got
->add_constant(target
->mips_elf_gnu_got1_mask());
5826 for (typename
Got_entry_set::iterator
5827 p
= this->got_entries_
.begin();
5828 p
!= this->got_entries_
.end();
5831 Mips_got_entry
<size
, big_endian
>* entry
= *p
;
5832 if (entry
->is_for_local_symbol() && !entry
->is_tls_entry())
5834 got
->add_local(entry
->object(), entry
->symndx(),
5835 GOT_TYPE_STANDARD
, entry
->addend());
5836 unsigned int got_offset
= entry
->object()->local_got_offset(
5837 entry
->symndx(), GOT_TYPE_STANDARD
, entry
->addend());
5838 if (got
->multi_got() && this->index_
> 0
5839 && parameters
->options().output_is_position_independent())
5841 if (!entry
->is_section_symbol())
5842 target
->rel_dyn_section(layout
)->add_local(entry
->object(),
5843 entry
->symndx(), elfcpp::R_MIPS_REL32
, got
, got_offset
);
5845 target
->rel_dyn_section(layout
)->add_symbolless_local_addend(
5846 entry
->object(), entry
->symndx(), elfcpp::R_MIPS_REL32
,
5852 this->add_page_entries(target
, layout
);
5854 // Add global entries that should be in the local area.
5855 for (typename
Got_entry_set::iterator
5856 p
= this->got_entries_
.begin();
5857 p
!= this->got_entries_
.end();
5860 Mips_got_entry
<size
, big_endian
>* entry
= *p
;
5861 if (!entry
->is_for_global_symbol())
5864 Mips_symbol
<size
>* mips_sym
= entry
->sym();
5865 if (mips_sym
->global_got_area() == GGA_NONE
&& !entry
->is_tls_entry())
5867 unsigned int got_type
;
5868 if (!got
->multi_got())
5869 got_type
= GOT_TYPE_STANDARD
;
5871 got_type
= GOT_TYPE_STANDARD_MULTIGOT
+ this->index_
;
5872 if (got
->add_global(mips_sym
, got_type
))
5874 mips_sym
->set_global_gotoffset(mips_sym
->got_offset(got_type
));
5875 if (got
->multi_got() && this->index_
> 0
5876 && parameters
->options().output_is_position_independent())
5877 target
->rel_dyn_section(layout
)->add_symbolless_global_addend(
5878 mips_sym
, elfcpp::R_MIPS_REL32
, got
,
5879 mips_sym
->got_offset(got_type
));
5885 // Create GOT page entries.
5887 template<int size
, bool big_endian
>
5889 Mips_got_info
<size
, big_endian
>::add_page_entries(
5890 Target_mips
<size
, big_endian
>* target
, Layout
* layout
)
5892 if (this->page_gotno_
== 0)
5895 Mips_output_data_got
<size
, big_endian
>* got
= target
->got_section();
5896 this->got_page_offset_start_
= got
->add_constant(0);
5897 if (got
->multi_got() && this->index_
> 0
5898 && parameters
->options().output_is_position_independent())
5899 target
->rel_dyn_section(layout
)->add_absolute(elfcpp::R_MIPS_REL32
, got
,
5900 this->got_page_offset_start_
);
5901 int num_entries
= this->page_gotno_
;
5902 unsigned int prev_offset
= this->got_page_offset_start_
;
5903 while (--num_entries
> 0)
5905 unsigned int next_offset
= got
->add_constant(0);
5906 if (got
->multi_got() && this->index_
> 0
5907 && parameters
->options().output_is_position_independent())
5908 target
->rel_dyn_section(layout
)->add_absolute(elfcpp::R_MIPS_REL32
, got
,
5910 gold_assert(next_offset
== prev_offset
+ size
/8);
5911 prev_offset
= next_offset
;
5913 this->got_page_offset_next_
= this->got_page_offset_start_
;
5916 // Create global GOT entries, both GGA_NORMAL and GGA_RELOC_ONLY.
5918 template<int size
, bool big_endian
>
5920 Mips_got_info
<size
, big_endian
>::add_global_entries(
5921 Target_mips
<size
, big_endian
>* target
, Layout
* layout
,
5922 unsigned int non_reloc_only_global_gotno
)
5924 Mips_output_data_got
<size
, big_endian
>* got
= target
->got_section();
5925 // Add GGA_NORMAL entries.
5926 unsigned int count
= 0;
5927 for (typename
Got_entry_set::iterator
5928 p
= this->got_entries_
.begin();
5929 p
!= this->got_entries_
.end();
5932 Mips_got_entry
<size
, big_endian
>* entry
= *p
;
5933 if (!entry
->is_for_global_symbol())
5936 Mips_symbol
<size
>* mips_sym
= entry
->sym();
5937 if (mips_sym
->global_got_area() != GGA_NORMAL
)
5940 unsigned int got_type
;
5941 if (!got
->multi_got())
5942 got_type
= GOT_TYPE_STANDARD
;
5944 // In multi-GOT links, global symbol can be in both primary and
5945 // secondary GOT(s). By creating custom GOT type
5946 // (GOT_TYPE_STANDARD_MULTIGOT + got_index) we ensure that symbol
5947 // is added to secondary GOT(s).
5948 got_type
= GOT_TYPE_STANDARD_MULTIGOT
+ this->index_
;
5949 if (!got
->add_global(mips_sym
, got_type
))
5952 mips_sym
->set_global_gotoffset(mips_sym
->got_offset(got_type
));
5953 if (got
->multi_got() && this->index_
== 0)
5955 if (got
->multi_got() && this->index_
> 0)
5957 if (parameters
->options().output_is_position_independent()
5958 || (!parameters
->doing_static_link()
5959 && mips_sym
->is_from_dynobj() && !mips_sym
->is_undefined()))
5961 target
->rel_dyn_section(layout
)->add_global(
5962 mips_sym
, elfcpp::R_MIPS_REL32
, got
,
5963 mips_sym
->got_offset(got_type
));
5964 got
->add_secondary_got_reloc(mips_sym
->got_offset(got_type
),
5965 elfcpp::R_MIPS_REL32
, mips_sym
);
5970 if (!got
->multi_got() || this->index_
== 0)
5972 if (got
->multi_got())
5974 // We need to allocate space in the primary GOT for GGA_NORMAL entries
5975 // of secondary GOTs, to ensure that GOT offsets of GGA_RELOC_ONLY
5976 // entries correspond to dynamic symbol indexes.
5977 while (count
< non_reloc_only_global_gotno
)
5979 got
->add_constant(0);
5984 // Add GGA_RELOC_ONLY entries.
5985 got
->add_reloc_only_entries();
5989 // Create global GOT entries that should be in the GGA_RELOC_ONLY area.
5991 template<int size
, bool big_endian
>
5993 Mips_got_info
<size
, big_endian
>::add_reloc_only_entries(
5994 Mips_output_data_got
<size
, big_endian
>* got
)
5996 for (typename
Global_got_entry_set::iterator
5997 p
= this->global_got_symbols_
.begin();
5998 p
!= this->global_got_symbols_
.end();
6001 Mips_symbol
<size
>* mips_sym
= *p
;
6002 if (mips_sym
->global_got_area() == GGA_RELOC_ONLY
)
6004 unsigned int got_type
;
6005 if (!got
->multi_got())
6006 got_type
= GOT_TYPE_STANDARD
;
6008 got_type
= GOT_TYPE_STANDARD_MULTIGOT
;
6009 if (got
->add_global(mips_sym
, got_type
))
6010 mips_sym
->set_global_gotoffset(mips_sym
->got_offset(got_type
));
6015 // Create TLS GOT entries.
6017 template<int size
, bool big_endian
>
6019 Mips_got_info
<size
, big_endian
>::add_tls_entries(
6020 Target_mips
<size
, big_endian
>* target
, Layout
* layout
)
6022 Mips_output_data_got
<size
, big_endian
>* got
= target
->got_section();
6023 // Add local tls entries.
6024 for (typename
Got_entry_set::iterator
6025 p
= this->got_entries_
.begin();
6026 p
!= this->got_entries_
.end();
6029 Mips_got_entry
<size
, big_endian
>* entry
= *p
;
6030 if (!entry
->is_tls_entry() || !entry
->is_for_local_symbol())
6033 if (entry
->tls_type() == GOT_TLS_GD
)
6035 unsigned int got_type
= GOT_TYPE_TLS_PAIR
;
6036 unsigned int r_type1
= (size
== 32 ? elfcpp::R_MIPS_TLS_DTPMOD32
6037 : elfcpp::R_MIPS_TLS_DTPMOD64
);
6038 unsigned int r_type2
= (size
== 32 ? elfcpp::R_MIPS_TLS_DTPREL32
6039 : elfcpp::R_MIPS_TLS_DTPREL64
);
6041 if (!parameters
->doing_static_link())
6043 got
->add_local_pair_with_rel(entry
->object(), entry
->symndx(),
6044 entry
->shndx(), got_type
,
6045 target
->rel_dyn_section(layout
),
6046 r_type1
, entry
->addend());
6047 unsigned int got_offset
=
6048 entry
->object()->local_got_offset(entry
->symndx(), got_type
,
6050 got
->add_static_reloc(got_offset
+ size
/8, r_type2
,
6051 entry
->object(), entry
->symndx());
6055 // We are doing a static link. Mark it as belong to module 1,
6057 unsigned int got_offset
= got
->add_constant(1);
6058 entry
->object()->set_local_got_offset(entry
->symndx(), got_type
,
6061 got
->add_constant(0);
6062 got
->add_static_reloc(got_offset
+ size
/8, r_type2
,
6063 entry
->object(), entry
->symndx());
6066 else if (entry
->tls_type() == GOT_TLS_IE
)
6068 unsigned int got_type
= GOT_TYPE_TLS_OFFSET
;
6069 unsigned int r_type
= (size
== 32 ? elfcpp::R_MIPS_TLS_TPREL32
6070 : elfcpp::R_MIPS_TLS_TPREL64
);
6071 if (!parameters
->doing_static_link())
6072 got
->add_local_with_rel(entry
->object(), entry
->symndx(), got_type
,
6073 target
->rel_dyn_section(layout
), r_type
,
6077 got
->add_local(entry
->object(), entry
->symndx(), got_type
,
6079 unsigned int got_offset
=
6080 entry
->object()->local_got_offset(entry
->symndx(), got_type
,
6082 got
->add_static_reloc(got_offset
, r_type
, entry
->object(),
6086 else if (entry
->tls_type() == GOT_TLS_LDM
)
6088 unsigned int r_type
= (size
== 32 ? elfcpp::R_MIPS_TLS_DTPMOD32
6089 : elfcpp::R_MIPS_TLS_DTPMOD64
);
6090 unsigned int got_offset
;
6091 if (!parameters
->doing_static_link())
6093 got_offset
= got
->add_constant(0);
6094 target
->rel_dyn_section(layout
)->add_local(
6095 entry
->object(), 0, r_type
, got
, got_offset
);
6098 // We are doing a static link. Just mark it as belong to module 1,
6100 got_offset
= got
->add_constant(1);
6102 got
->add_constant(0);
6103 got
->set_tls_ldm_offset(got_offset
, entry
->object());
6109 // Add global tls entries.
6110 for (typename
Got_entry_set::iterator
6111 p
= this->got_entries_
.begin();
6112 p
!= this->got_entries_
.end();
6115 Mips_got_entry
<size
, big_endian
>* entry
= *p
;
6116 if (!entry
->is_tls_entry() || !entry
->is_for_global_symbol())
6119 Mips_symbol
<size
>* mips_sym
= entry
->sym();
6120 if (entry
->tls_type() == GOT_TLS_GD
)
6122 unsigned int got_type
;
6123 if (!got
->multi_got())
6124 got_type
= GOT_TYPE_TLS_PAIR
;
6126 got_type
= GOT_TYPE_TLS_PAIR_MULTIGOT
+ this->index_
;
6127 unsigned int r_type1
= (size
== 32 ? elfcpp::R_MIPS_TLS_DTPMOD32
6128 : elfcpp::R_MIPS_TLS_DTPMOD64
);
6129 unsigned int r_type2
= (size
== 32 ? elfcpp::R_MIPS_TLS_DTPREL32
6130 : elfcpp::R_MIPS_TLS_DTPREL64
);
6131 if (!parameters
->doing_static_link())
6132 got
->add_global_pair_with_rel(mips_sym
, got_type
,
6133 target
->rel_dyn_section(layout
), r_type1
, r_type2
);
6136 // Add a GOT pair for for R_MIPS_TLS_GD. The creates a pair of
6137 // GOT entries. The first one is initialized to be 1, which is the
6138 // module index for the main executable and the second one 0. A
6139 // reloc of the type R_MIPS_TLS_DTPREL32/64 will be created for
6140 // the second GOT entry and will be applied by gold.
6141 unsigned int got_offset
= got
->add_constant(1);
6142 mips_sym
->set_got_offset(got_type
, got_offset
);
6143 got
->add_constant(0);
6144 got
->add_static_reloc(got_offset
+ size
/8, r_type2
, mips_sym
);
6147 else if (entry
->tls_type() == GOT_TLS_IE
)
6149 unsigned int got_type
;
6150 if (!got
->multi_got())
6151 got_type
= GOT_TYPE_TLS_OFFSET
;
6153 got_type
= GOT_TYPE_TLS_OFFSET_MULTIGOT
+ this->index_
;
6154 unsigned int r_type
= (size
== 32 ? elfcpp::R_MIPS_TLS_TPREL32
6155 : elfcpp::R_MIPS_TLS_TPREL64
);
6156 if (!parameters
->doing_static_link())
6157 got
->add_global_with_rel(mips_sym
, got_type
,
6158 target
->rel_dyn_section(layout
), r_type
);
6161 got
->add_global(mips_sym
, got_type
);
6162 unsigned int got_offset
= mips_sym
->got_offset(got_type
);
6163 got
->add_static_reloc(got_offset
, r_type
, mips_sym
);
6171 // Decide whether the symbol needs an entry in the global part of the primary
6172 // GOT, setting global_got_area accordingly. Count the number of global
6173 // symbols that are in the primary GOT only because they have dynamic
6174 // relocations R_MIPS_REL32 against them (reloc_only_gotno).
6176 template<int size
, bool big_endian
>
6178 Mips_got_info
<size
, big_endian
>::count_got_symbols(Symbol_table
* symtab
)
6180 for (typename
Global_got_entry_set::iterator
6181 p
= this->global_got_symbols_
.begin();
6182 p
!= this->global_got_symbols_
.end();
6185 Mips_symbol
<size
>* sym
= *p
;
6186 // Make a final decision about whether the symbol belongs in the
6187 // local or global GOT. Symbols that bind locally can (and in the
6188 // case of forced-local symbols, must) live in the local GOT.
6189 // Those that are aren't in the dynamic symbol table must also
6190 // live in the local GOT.
6192 if (!sym
->should_add_dynsym_entry(symtab
)
6193 || (sym
->got_only_for_calls()
6194 ? symbol_calls_local(sym
, sym
->should_add_dynsym_entry(symtab
))
6195 : symbol_references_local(sym
,
6196 sym
->should_add_dynsym_entry(symtab
))))
6197 // The symbol belongs in the local GOT. We no longer need this
6198 // entry if it was only used for relocations; those relocations
6199 // will be against the null or section symbol instead.
6200 sym
->set_global_got_area(GGA_NONE
);
6201 else if (sym
->global_got_area() == GGA_RELOC_ONLY
)
6203 ++this->reloc_only_gotno_
;
6204 ++this->global_gotno_
;
6209 // Return the offset of GOT page entry for VALUE. Initialize the entry with
6210 // VALUE if it is not initialized.
6212 template<int size
, bool big_endian
>
6214 Mips_got_info
<size
, big_endian
>::get_got_page_offset(Mips_address value
,
6215 Mips_output_data_got
<size
, big_endian
>* got
)
6217 typename
Got_page_offsets::iterator it
= this->got_page_offsets_
.find(value
);
6218 if (it
!= this->got_page_offsets_
.end())
6221 gold_assert(this->got_page_offset_next_
< this->got_page_offset_start_
6222 + (size
/8) * this->page_gotno_
);
6224 unsigned int got_offset
= this->got_page_offset_next_
;
6225 this->got_page_offsets_
[value
] = got_offset
;
6226 this->got_page_offset_next_
+= size
/8;
6227 got
->update_got_entry(got_offset
, value
);
6231 // Remove lazy-binding stubs for global symbols in this GOT.
6233 template<int size
, bool big_endian
>
6235 Mips_got_info
<size
, big_endian
>::remove_lazy_stubs(
6236 Target_mips
<size
, big_endian
>* target
)
6238 for (typename
Got_entry_set::iterator
6239 p
= this->got_entries_
.begin();
6240 p
!= this->got_entries_
.end();
6243 Mips_got_entry
<size
, big_endian
>* entry
= *p
;
6244 if (entry
->is_for_global_symbol())
6245 target
->remove_lazy_stub_entry(entry
->sym());
6249 // Count the number of GOT entries required.
6251 template<int size
, bool big_endian
>
6253 Mips_got_info
<size
, big_endian
>::count_got_entries()
6255 for (typename
Got_entry_set::iterator
6256 p
= this->got_entries_
.begin();
6257 p
!= this->got_entries_
.end();
6260 this->count_got_entry(*p
);
6264 // Count the number of GOT entries required by ENTRY. Accumulate the result.
6266 template<int size
, bool big_endian
>
6268 Mips_got_info
<size
, big_endian
>::count_got_entry(
6269 Mips_got_entry
<size
, big_endian
>* entry
)
6271 if (entry
->is_tls_entry())
6272 this->tls_gotno_
+= mips_tls_got_entries(entry
->tls_type());
6273 else if (entry
->is_for_local_symbol()
6274 || entry
->sym()->global_got_area() == GGA_NONE
)
6275 ++this->local_gotno_
;
6277 ++this->global_gotno_
;
6280 // Add FROM's GOT entries.
6282 template<int size
, bool big_endian
>
6284 Mips_got_info
<size
, big_endian
>::add_got_entries(
6285 Mips_got_info
<size
, big_endian
>* from
)
6287 for (typename
Got_entry_set::iterator
6288 p
= from
->got_entries_
.begin();
6289 p
!= from
->got_entries_
.end();
6292 Mips_got_entry
<size
, big_endian
>* entry
= *p
;
6293 if (this->got_entries_
.find(entry
) == this->got_entries_
.end())
6295 Mips_got_entry
<size
, big_endian
>* entry2
=
6296 new Mips_got_entry
<size
, big_endian
>(*entry
);
6297 this->got_entries_
.insert(entry2
);
6298 this->count_got_entry(entry
);
6303 // Add FROM's GOT page entries.
6305 template<int size
, bool big_endian
>
6307 Mips_got_info
<size
, big_endian
>::add_got_page_entries(
6308 Mips_got_info
<size
, big_endian
>* from
)
6310 for (typename
Got_page_entry_set::iterator
6311 p
= from
->got_page_entries_
.begin();
6312 p
!= from
->got_page_entries_
.end();
6315 Got_page_entry
* entry
= *p
;
6316 if (this->got_page_entries_
.find(entry
) == this->got_page_entries_
.end())
6318 Got_page_entry
* entry2
= new Got_page_entry(*entry
);
6319 this->got_page_entries_
.insert(entry2
);
6320 this->page_gotno_
+= entry
->num_pages
;
6325 // Mips_output_data_got methods.
6327 // Lay out the GOT. Add local, global and TLS entries. If GOT is
6328 // larger than 64K, create multi-GOT.
6330 template<int size
, bool big_endian
>
6332 Mips_output_data_got
<size
, big_endian
>::lay_out_got(Layout
* layout
,
6333 Symbol_table
* symtab
, const Input_objects
* input_objects
)
6335 // Decide which symbols need to go in the global part of the GOT and
6336 // count the number of reloc-only GOT symbols.
6337 this->master_got_info_
->count_got_symbols(symtab
);
6339 // Count the number of GOT entries.
6340 this->master_got_info_
->count_got_entries();
6342 unsigned int got_size
= this->master_got_info_
->got_size();
6343 if (got_size
> Target_mips
<size
, big_endian
>::MIPS_GOT_MAX_SIZE
)
6344 this->lay_out_multi_got(layout
, input_objects
);
6347 // Record that all objects use single GOT.
6348 for (Input_objects::Relobj_iterator p
= input_objects
->relobj_begin();
6349 p
!= input_objects
->relobj_end();
6352 Mips_relobj
<size
, big_endian
>* object
=
6353 Mips_relobj
<size
, big_endian
>::as_mips_relobj(*p
);
6354 if (object
->get_got_info() != NULL
)
6355 object
->set_got_info(this->master_got_info_
);
6358 this->master_got_info_
->add_local_entries(this->target_
, layout
);
6359 this->master_got_info_
->add_global_entries(this->target_
, layout
,
6361 this->master_got_info_
->add_tls_entries(this->target_
, layout
);
6365 // Create multi-GOT. For every GOT, add local, global and TLS entries.
6367 template<int size
, bool big_endian
>
6369 Mips_output_data_got
<size
, big_endian
>::lay_out_multi_got(Layout
* layout
,
6370 const Input_objects
* input_objects
)
6372 // Try to merge the GOTs of input objects together, as long as they
6373 // don't seem to exceed the maximum GOT size, choosing one of them
6374 // to be the primary GOT.
6375 this->merge_gots(input_objects
);
6377 // Every symbol that is referenced in a dynamic relocation must be
6378 // present in the primary GOT.
6379 this->primary_got_
->set_global_gotno(this->master_got_info_
->global_gotno());
6383 unsigned int offset
= 0;
6384 Mips_got_info
<size
, big_endian
>* g
= this->primary_got_
;
6388 g
->set_offset(offset
);
6390 g
->add_local_entries(this->target_
, layout
);
6392 g
->add_global_entries(this->target_
, layout
,
6393 (this->master_got_info_
->global_gotno()
6394 - this->master_got_info_
->reloc_only_gotno()));
6396 g
->add_global_entries(this->target_
, layout
, /*not used*/-1U);
6397 g
->add_tls_entries(this->target_
, layout
);
6399 // Forbid global symbols in every non-primary GOT from having
6400 // lazy-binding stubs.
6402 g
->remove_lazy_stubs(this->target_
);
6405 offset
+= g
->got_size();
6411 // Attempt to merge GOTs of different input objects. Try to use as much as
6412 // possible of the primary GOT, since it doesn't require explicit dynamic
6413 // relocations, but don't use objects that would reference global symbols
6414 // out of the addressable range. Failing the primary GOT, attempt to merge
6415 // with the current GOT, or finish the current GOT and then make make the new
6418 template<int size
, bool big_endian
>
6420 Mips_output_data_got
<size
, big_endian
>::merge_gots(
6421 const Input_objects
* input_objects
)
6423 gold_assert(this->primary_got_
== NULL
);
6424 Mips_got_info
<size
, big_endian
>* current
= NULL
;
6426 for (Input_objects::Relobj_iterator p
= input_objects
->relobj_begin();
6427 p
!= input_objects
->relobj_end();
6430 Mips_relobj
<size
, big_endian
>* object
=
6431 Mips_relobj
<size
, big_endian
>::as_mips_relobj(*p
);
6433 Mips_got_info
<size
, big_endian
>* g
= object
->get_got_info();
6437 g
->count_got_entries();
6439 // Work out the number of page, local and TLS entries.
6440 unsigned int estimate
= this->master_got_info_
->page_gotno();
6441 if (estimate
> g
->page_gotno())
6442 estimate
= g
->page_gotno();
6443 estimate
+= g
->local_gotno() + g
->tls_gotno();
6445 // We place TLS GOT entries after both locals and globals. The globals
6446 // for the primary GOT may overflow the normal GOT size limit, so be
6447 // sure not to merge a GOT which requires TLS with the primary GOT in that
6448 // case. This doesn't affect non-primary GOTs.
6449 estimate
+= (g
->tls_gotno() > 0 ? this->master_got_info_
->global_gotno()
6450 : g
->global_gotno());
6452 unsigned int max_count
=
6453 Target_mips
<size
, big_endian
>::MIPS_GOT_MAX_SIZE
/ (size
/8) - 2;
6454 if (estimate
<= max_count
)
6456 // If we don't have a primary GOT, use it as
6457 // a starting point for the primary GOT.
6458 if (!this->primary_got_
)
6460 this->primary_got_
= g
;
6464 // Try merging with the primary GOT.
6465 if (this->merge_got_with(g
, object
, this->primary_got_
))
6469 // If we can merge with the last-created GOT, do it.
6470 if (current
&& this->merge_got_with(g
, object
, current
))
6473 // Well, we couldn't merge, so create a new GOT. Don't check if it
6474 // fits; if it turns out that it doesn't, we'll get relocation
6475 // overflows anyway.
6476 g
->set_next(current
);
6480 // If we do not find any suitable primary GOT, create an empty one.
6481 if (this->primary_got_
== NULL
)
6482 this->primary_got_
= new Mips_got_info
<size
, big_endian
>();
6484 // Link primary GOT with secondary GOTs.
6485 this->primary_got_
->set_next(current
);
6488 // Consider merging FROM, which is OBJECT's GOT, into TO. Return false if
6489 // this would lead to overflow, true if they were merged successfully.
6491 template<int size
, bool big_endian
>
6493 Mips_output_data_got
<size
, big_endian
>::merge_got_with(
6494 Mips_got_info
<size
, big_endian
>* from
,
6495 Mips_relobj
<size
, big_endian
>* object
,
6496 Mips_got_info
<size
, big_endian
>* to
)
6498 // Work out how many page entries we would need for the combined GOT.
6499 unsigned int estimate
= this->master_got_info_
->page_gotno();
6500 if (estimate
>= from
->page_gotno() + to
->page_gotno())
6501 estimate
= from
->page_gotno() + to
->page_gotno();
6503 // Conservatively estimate how many local and TLS entries would be needed.
6504 estimate
+= from
->local_gotno() + to
->local_gotno();
6505 estimate
+= from
->tls_gotno() + to
->tls_gotno();
6507 // If we're merging with the primary got, any TLS relocations will
6508 // come after the full set of global entries. Otherwise estimate those
6509 // conservatively as well.
6510 if (to
== this->primary_got_
&& (from
->tls_gotno() + to
->tls_gotno()) > 0)
6511 estimate
+= this->master_got_info_
->global_gotno();
6513 estimate
+= from
->global_gotno() + to
->global_gotno();
6515 // Bail out if the combined GOT might be too big.
6516 unsigned int max_count
=
6517 Target_mips
<size
, big_endian
>::MIPS_GOT_MAX_SIZE
/ (size
/8) - 2;
6518 if (estimate
> max_count
)
6521 // Transfer the object's GOT information from FROM to TO.
6522 to
->add_got_entries(from
);
6523 to
->add_got_page_entries(from
);
6525 // Record that OBJECT should use output GOT TO.
6526 object
->set_got_info(to
);
6531 // Write out the GOT.
6533 template<int size
, bool big_endian
>
6535 Mips_output_data_got
<size
, big_endian
>::do_write(Output_file
* of
)
6537 typedef Unordered_set
<Mips_symbol
<size
>*, Mips_symbol_hash
<size
> >
6538 Mips_stubs_entry_set
;
6540 // Call parent to write out GOT.
6541 Output_data_got
<size
, big_endian
>::do_write(of
);
6543 const off_t offset
= this->offset();
6544 const section_size_type oview_size
=
6545 convert_to_section_size_type(this->data_size());
6546 unsigned char* const oview
= of
->get_output_view(offset
, oview_size
);
6548 // Needed for fixing values of .got section.
6549 this->got_view_
= oview
;
6551 // Write lazy stub addresses.
6552 for (typename
Mips_stubs_entry_set::iterator
6553 p
= this->master_got_info_
->global_got_symbols().begin();
6554 p
!= this->master_got_info_
->global_got_symbols().end();
6557 Mips_symbol
<size
>* mips_sym
= *p
;
6558 if (mips_sym
->has_lazy_stub())
6560 Valtype
* wv
= reinterpret_cast<Valtype
*>(
6561 oview
+ this->get_primary_got_offset(mips_sym
));
6563 this->target_
->mips_stubs_section()->stub_address(mips_sym
);
6564 elfcpp::Swap
<size
, big_endian
>::writeval(wv
, value
);
6568 // Add +1 to GGA_NONE nonzero MIPS16 and microMIPS entries.
6569 for (typename
Mips_stubs_entry_set::iterator
6570 p
= this->master_got_info_
->global_got_symbols().begin();
6571 p
!= this->master_got_info_
->global_got_symbols().end();
6574 Mips_symbol
<size
>* mips_sym
= *p
;
6575 if (!this->multi_got()
6576 && (mips_sym
->is_mips16() || mips_sym
->is_micromips())
6577 && mips_sym
->global_got_area() == GGA_NONE
6578 && mips_sym
->has_got_offset(GOT_TYPE_STANDARD
))
6580 Valtype
* wv
= reinterpret_cast<Valtype
*>(
6581 oview
+ mips_sym
->got_offset(GOT_TYPE_STANDARD
));
6582 Valtype value
= elfcpp::Swap
<size
, big_endian
>::readval(wv
);
6586 elfcpp::Swap
<size
, big_endian
>::writeval(wv
, value
);
6591 if (!this->secondary_got_relocs_
.empty())
6593 // Fixup for the secondary GOT R_MIPS_REL32 relocs. For global
6594 // secondary GOT entries with non-zero initial value copy the value
6595 // to the corresponding primary GOT entry, and set the secondary GOT
6597 // TODO(sasa): This is workaround. It needs to be investigated further.
6599 for (size_t i
= 0; i
< this->secondary_got_relocs_
.size(); ++i
)
6601 Static_reloc
& reloc(this->secondary_got_relocs_
[i
]);
6602 if (reloc
.symbol_is_global())
6604 Mips_symbol
<size
>* gsym
= reloc
.symbol();
6605 gold_assert(gsym
!= NULL
);
6607 unsigned got_offset
= reloc
.got_offset();
6608 gold_assert(got_offset
< oview_size
);
6610 // Find primary GOT entry.
6611 Valtype
* wv_prim
= reinterpret_cast<Valtype
*>(
6612 oview
+ this->get_primary_got_offset(gsym
));
6614 // Find secondary GOT entry.
6615 Valtype
* wv_sec
= reinterpret_cast<Valtype
*>(oview
+ got_offset
);
6617 Valtype value
= elfcpp::Swap
<size
, big_endian
>::readval(wv_sec
);
6620 elfcpp::Swap
<size
, big_endian
>::writeval(wv_prim
, value
);
6621 elfcpp::Swap
<size
, big_endian
>::writeval(wv_sec
, 0);
6622 gsym
->set_applied_secondary_got_fixup();
6627 of
->write_output_view(offset
, oview_size
, oview
);
6630 // We are done if there is no fix up.
6631 if (this->static_relocs_
.empty())
6634 Output_segment
* tls_segment
= this->layout_
->tls_segment();
6635 gold_assert(tls_segment
!= NULL
);
6637 for (size_t i
= 0; i
< this->static_relocs_
.size(); ++i
)
6639 Static_reloc
& reloc(this->static_relocs_
[i
]);
6642 if (!reloc
.symbol_is_global())
6644 Sized_relobj_file
<size
, big_endian
>* object
= reloc
.relobj();
6645 const Symbol_value
<size
>* psymval
=
6646 object
->local_symbol(reloc
.index());
6648 // We are doing static linking. Issue an error and skip this
6649 // relocation if the symbol is undefined or in a discarded_section.
6651 unsigned int shndx
= psymval
->input_shndx(&is_ordinary
);
6652 if ((shndx
== elfcpp::SHN_UNDEF
)
6654 && shndx
!= elfcpp::SHN_UNDEF
6655 && !object
->is_section_included(shndx
)
6656 && !this->symbol_table_
->is_section_folded(object
, shndx
)))
6658 gold_error(_("undefined or discarded local symbol %u from "
6659 " object %s in GOT"),
6660 reloc
.index(), reloc
.relobj()->name().c_str());
6664 value
= psymval
->value(object
, 0);
6668 const Mips_symbol
<size
>* gsym
= reloc
.symbol();
6669 gold_assert(gsym
!= NULL
);
6671 // We are doing static linking. Issue an error and skip this
6672 // relocation if the symbol is undefined or in a discarded_section
6673 // unless it is a weakly_undefined symbol.
6674 if ((gsym
->is_defined_in_discarded_section() || gsym
->is_undefined())
6675 && !gsym
->is_weak_undefined())
6677 gold_error(_("undefined or discarded symbol %s in GOT"),
6682 if (!gsym
->is_weak_undefined())
6683 value
= gsym
->value();
6688 unsigned got_offset
= reloc
.got_offset();
6689 gold_assert(got_offset
< oview_size
);
6691 Valtype
* wv
= reinterpret_cast<Valtype
*>(oview
+ got_offset
);
6694 switch (reloc
.r_type())
6696 case elfcpp::R_MIPS_TLS_DTPMOD32
:
6697 case elfcpp::R_MIPS_TLS_DTPMOD64
:
6700 case elfcpp::R_MIPS_TLS_DTPREL32
:
6701 case elfcpp::R_MIPS_TLS_DTPREL64
:
6702 x
= value
- elfcpp::DTP_OFFSET
;
6704 case elfcpp::R_MIPS_TLS_TPREL32
:
6705 case elfcpp::R_MIPS_TLS_TPREL64
:
6706 x
= value
- elfcpp::TP_OFFSET
;
6713 elfcpp::Swap
<size
, big_endian
>::writeval(wv
, x
);
6716 of
->write_output_view(offset
, oview_size
, oview
);
6719 // Mips_relobj methods.
6721 // Count the local symbols. The Mips backend needs to know if a symbol
6722 // is a MIPS16 or microMIPS function or not. For global symbols, it is easy
6723 // because the Symbol object keeps the ELF symbol type and st_other field.
6724 // For local symbol it is harder because we cannot access this information.
6725 // So we override the do_count_local_symbol in parent and scan local symbols to
6726 // mark MIPS16 and microMIPS functions. This is not the most efficient way but
6727 // I do not want to slow down other ports by calling a per symbol target hook
6728 // inside Sized_relobj_file<size, big_endian>::do_count_local_symbols.
6730 template<int size
, bool big_endian
>
6732 Mips_relobj
<size
, big_endian
>::do_count_local_symbols(
6733 Stringpool_template
<char>* pool
,
6734 Stringpool_template
<char>* dynpool
)
6736 // Ask parent to count the local symbols.
6737 Sized_relobj_file
<size
, big_endian
>::do_count_local_symbols(pool
, dynpool
);
6738 const unsigned int loccount
= this->local_symbol_count();
6742 // Initialize the mips16 and micromips function bit-vector.
6743 this->local_symbol_is_mips16_
.resize(loccount
, false);
6744 this->local_symbol_is_micromips_
.resize(loccount
, false);
6746 // Read the symbol table section header.
6747 const unsigned int symtab_shndx
= this->symtab_shndx();
6748 elfcpp::Shdr
<size
, big_endian
>
6749 symtabshdr(this, this->elf_file()->section_header(symtab_shndx
));
6750 gold_assert(symtabshdr
.get_sh_type() == elfcpp::SHT_SYMTAB
);
6752 // Read the local symbols.
6753 const int sym_size
= elfcpp::Elf_sizes
<size
>::sym_size
;
6754 gold_assert(loccount
== symtabshdr
.get_sh_info());
6755 off_t locsize
= loccount
* sym_size
;
6756 const unsigned char* psyms
= this->get_view(symtabshdr
.get_sh_offset(),
6757 locsize
, true, true);
6759 // Loop over the local symbols and mark any MIPS16 or microMIPS local symbols.
6761 // Skip the first dummy symbol.
6763 for (unsigned int i
= 1; i
< loccount
; ++i
, psyms
+= sym_size
)
6765 elfcpp::Sym
<size
, big_endian
> sym(psyms
);
6766 unsigned char st_other
= sym
.get_st_other();
6767 this->local_symbol_is_mips16_
[i
] = elfcpp::elf_st_is_mips16(st_other
);
6768 this->local_symbol_is_micromips_
[i
] =
6769 elfcpp::elf_st_is_micromips(st_other
);
6773 // Read the symbol information.
6775 template<int size
, bool big_endian
>
6777 Mips_relobj
<size
, big_endian
>::do_read_symbols(Read_symbols_data
* sd
)
6779 // Call parent class to read symbol information.
6780 this->base_read_symbols(sd
);
6782 // Read processor-specific flags in ELF file header.
6783 const unsigned char* pehdr
= this->get_view(elfcpp::file_header_offset
,
6784 elfcpp::Elf_sizes
<size
>::ehdr_size
,
6786 elfcpp::Ehdr
<size
, big_endian
> ehdr(pehdr
);
6787 this->processor_specific_flags_
= ehdr
.get_e_flags();
6789 // Get the section names.
6790 const unsigned char* pnamesu
= sd
->section_names
->data();
6791 const char* pnames
= reinterpret_cast<const char*>(pnamesu
);
6793 // Initialize the mips16 stub section bit-vectors.
6794 this->section_is_mips16_fn_stub_
.resize(this->shnum(), false);
6795 this->section_is_mips16_call_stub_
.resize(this->shnum(), false);
6796 this->section_is_mips16_call_fp_stub_
.resize(this->shnum(), false);
6798 const size_t shdr_size
= elfcpp::Elf_sizes
<size
>::shdr_size
;
6799 const unsigned char* pshdrs
= sd
->section_headers
->data();
6800 const unsigned char* ps
= pshdrs
+ shdr_size
;
6801 for (unsigned int i
= 1; i
< this->shnum(); ++i
, ps
+= shdr_size
)
6803 elfcpp::Shdr
<size
, big_endian
> shdr(ps
);
6805 if (shdr
.get_sh_type() == elfcpp::SHT_MIPS_REGINFO
)
6807 this->has_reginfo_section_
= true;
6808 // Read the gp value that was used to create this object. We need the
6809 // gp value while processing relocs. The .reginfo section is not used
6810 // in the 64-bit MIPS ELF ABI.
6811 section_offset_type section_offset
= shdr
.get_sh_offset();
6812 section_size_type section_size
=
6813 convert_to_section_size_type(shdr
.get_sh_size());
6814 const unsigned char* view
=
6815 this->get_view(section_offset
, section_size
, true, false);
6817 this->gp_
= elfcpp::Swap
<size
, big_endian
>::readval(view
+ 20);
6819 // Read the rest of .reginfo.
6820 this->gprmask_
= elfcpp::Swap
<size
, big_endian
>::readval(view
);
6821 this->cprmask1_
= elfcpp::Swap
<size
, big_endian
>::readval(view
+ 4);
6822 this->cprmask2_
= elfcpp::Swap
<size
, big_endian
>::readval(view
+ 8);
6823 this->cprmask3_
= elfcpp::Swap
<size
, big_endian
>::readval(view
+ 12);
6824 this->cprmask4_
= elfcpp::Swap
<size
, big_endian
>::readval(view
+ 16);
6827 if (shdr
.get_sh_type() == elfcpp::SHT_GNU_ATTRIBUTES
)
6829 gold_assert(this->attributes_section_data_
== NULL
);
6830 section_offset_type section_offset
= shdr
.get_sh_offset();
6831 section_size_type section_size
=
6832 convert_to_section_size_type(shdr
.get_sh_size());
6833 const unsigned char* view
=
6834 this->get_view(section_offset
, section_size
, true, false);
6835 this->attributes_section_data_
=
6836 new Attributes_section_data(view
, section_size
);
6839 if (shdr
.get_sh_type() == elfcpp::SHT_MIPS_ABIFLAGS
)
6841 gold_assert(this->abiflags_
== NULL
);
6842 section_offset_type section_offset
= shdr
.get_sh_offset();
6843 section_size_type section_size
=
6844 convert_to_section_size_type(shdr
.get_sh_size());
6845 const unsigned char* view
=
6846 this->get_view(section_offset
, section_size
, true, false);
6847 this->abiflags_
= new Mips_abiflags
<big_endian
>();
6849 this->abiflags_
->version
=
6850 elfcpp::Swap
<16, big_endian
>::readval(view
);
6851 if (this->abiflags_
->version
!= 0)
6853 gold_error(_("%s: .MIPS.abiflags section has "
6854 "unsupported version %u"),
6855 this->name().c_str(),
6856 this->abiflags_
->version
);
6859 this->abiflags_
->isa_level
=
6860 elfcpp::Swap
<8, big_endian
>::readval(view
+ 2);
6861 this->abiflags_
->isa_rev
=
6862 elfcpp::Swap
<8, big_endian
>::readval(view
+ 3);
6863 this->abiflags_
->gpr_size
=
6864 elfcpp::Swap
<8, big_endian
>::readval(view
+ 4);
6865 this->abiflags_
->cpr1_size
=
6866 elfcpp::Swap
<8, big_endian
>::readval(view
+ 5);
6867 this->abiflags_
->cpr2_size
=
6868 elfcpp::Swap
<8, big_endian
>::readval(view
+ 6);
6869 this->abiflags_
->fp_abi
=
6870 elfcpp::Swap
<8, big_endian
>::readval(view
+ 7);
6871 this->abiflags_
->isa_ext
=
6872 elfcpp::Swap
<32, big_endian
>::readval(view
+ 8);
6873 this->abiflags_
->ases
=
6874 elfcpp::Swap
<32, big_endian
>::readval(view
+ 12);
6875 this->abiflags_
->flags1
=
6876 elfcpp::Swap
<32, big_endian
>::readval(view
+ 16);
6877 this->abiflags_
->flags2
=
6878 elfcpp::Swap
<32, big_endian
>::readval(view
+ 20);
6881 // In the 64-bit ABI, .MIPS.options section holds register information.
6882 // A SHT_MIPS_OPTIONS section contains a series of options, each of which
6883 // starts with this header:
6887 // // Type of option.
6888 // unsigned char kind[1];
6889 // // Size of option descriptor, including header.
6890 // unsigned char size[1];
6891 // // Section index of affected section, or 0 for global option.
6892 // unsigned char section[2];
6893 // // Information specific to this kind of option.
6894 // unsigned char info[4];
6897 // For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and set
6898 // the gp value based on what we find. We may see both SHT_MIPS_REGINFO
6899 // and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case, they should agree.
6901 if (shdr
.get_sh_type() == elfcpp::SHT_MIPS_OPTIONS
)
6903 section_offset_type section_offset
= shdr
.get_sh_offset();
6904 section_size_type section_size
=
6905 convert_to_section_size_type(shdr
.get_sh_size());
6906 const unsigned char* view
=
6907 this->get_view(section_offset
, section_size
, true, false);
6908 const unsigned char* end
= view
+ section_size
;
6910 while (view
+ 8 <= end
)
6912 unsigned char kind
= elfcpp::Swap
<8, big_endian
>::readval(view
);
6913 unsigned char sz
= elfcpp::Swap
<8, big_endian
>::readval(view
+ 1);
6916 gold_error(_("%s: Warning: bad `%s' option size %u smaller "
6918 this->name().c_str(),
6919 this->mips_elf_options_section_name(), sz
);
6923 if (this->is_n64() && kind
== elfcpp::ODK_REGINFO
)
6925 // In the 64 bit ABI, an ODK_REGINFO option is the following
6926 // structure. The info field of the options header is not
6931 // // Mask of general purpose registers used.
6932 // unsigned char ri_gprmask[4];
6934 // unsigned char ri_pad[4];
6935 // // Mask of co-processor registers used.
6936 // unsigned char ri_cprmask[4][4];
6937 // // GP register value for this object file.
6938 // unsigned char ri_gp_value[8];
6941 this->gp_
= elfcpp::Swap
<size
, big_endian
>::readval(view
6944 else if (kind
== elfcpp::ODK_REGINFO
)
6946 // In the 32 bit ABI, an ODK_REGINFO option is the following
6947 // structure. The info field of the options header is not
6948 // used. The same structure is used in .reginfo section.
6952 // unsigned char ri_gprmask[4];
6953 // unsigned char ri_cprmask[4][4];
6954 // unsigned char ri_gp_value[4];
6957 this->gp_
= elfcpp::Swap
<size
, big_endian
>::readval(view
6964 const char* name
= pnames
+ shdr
.get_sh_name();
6965 this->section_is_mips16_fn_stub_
[i
] = is_prefix_of(".mips16.fn", name
);
6966 this->section_is_mips16_call_stub_
[i
] =
6967 is_prefix_of(".mips16.call.", name
);
6968 this->section_is_mips16_call_fp_stub_
[i
] =
6969 is_prefix_of(".mips16.call.fp.", name
);
6971 if (strcmp(name
, ".pdr") == 0)
6973 gold_assert(this->pdr_shndx_
== -1U);
6974 this->pdr_shndx_
= i
;
6979 // Discard MIPS16 stub secions that are not needed.
6981 template<int size
, bool big_endian
>
6983 Mips_relobj
<size
, big_endian
>::discard_mips16_stub_sections(Symbol_table
* symtab
)
6985 for (typename
Mips16_stubs_int_map::const_iterator
6986 it
= this->mips16_stub_sections_
.begin();
6987 it
!= this->mips16_stub_sections_
.end(); ++it
)
6989 Mips16_stub_section
<size
, big_endian
>* stub_section
= it
->second
;
6990 if (!stub_section
->is_target_found())
6992 gold_error(_("no relocation found in mips16 stub section '%s'"),
6993 stub_section
->object()
6994 ->section_name(stub_section
->shndx()).c_str());
6997 bool discard
= false;
6998 if (stub_section
->is_for_local_function())
7000 if (stub_section
->is_fn_stub())
7002 // This stub is for a local symbol. This stub will only
7003 // be needed if there is some relocation in this object,
7004 // other than a 16 bit function call, which refers to this
7006 if (!this->has_local_non_16bit_call_relocs(stub_section
->r_sym()))
7009 this->add_local_mips16_fn_stub(stub_section
);
7013 // This stub is for a local symbol. This stub will only
7014 // be needed if there is some relocation (R_MIPS16_26) in
7015 // this object that refers to this symbol.
7016 gold_assert(stub_section
->is_call_stub()
7017 || stub_section
->is_call_fp_stub());
7018 if (!this->has_local_16bit_call_relocs(stub_section
->r_sym()))
7021 this->add_local_mips16_call_stub(stub_section
);
7026 Mips_symbol
<size
>* gsym
= stub_section
->gsym();
7027 if (stub_section
->is_fn_stub())
7029 if (gsym
->has_mips16_fn_stub())
7030 // We already have a stub for this function.
7034 gsym
->set_mips16_fn_stub(stub_section
);
7035 if (gsym
->should_add_dynsym_entry(symtab
))
7037 // If we have a MIPS16 function with a stub, the
7038 // dynamic symbol must refer to the stub, since only
7039 // the stub uses the standard calling conventions.
7040 gsym
->set_need_fn_stub();
7041 if (gsym
->is_from_dynobj())
7042 gsym
->set_needs_dynsym_value();
7045 if (!gsym
->need_fn_stub())
7048 else if (stub_section
->is_call_stub())
7050 if (gsym
->is_mips16())
7051 // We don't need the call_stub; this is a 16 bit
7052 // function, so calls from other 16 bit functions are
7055 else if (gsym
->has_mips16_call_stub())
7056 // We already have a stub for this function.
7059 gsym
->set_mips16_call_stub(stub_section
);
7063 gold_assert(stub_section
->is_call_fp_stub());
7064 if (gsym
->is_mips16())
7065 // We don't need the call_stub; this is a 16 bit
7066 // function, so calls from other 16 bit functions are
7069 else if (gsym
->has_mips16_call_fp_stub())
7070 // We already have a stub for this function.
7073 gsym
->set_mips16_call_fp_stub(stub_section
);
7077 this->set_output_section(stub_section
->shndx(), NULL
);
7081 // Mips_output_data_la25_stub methods.
7083 // Template for standard LA25 stub.
7084 template<int size
, bool big_endian
>
7086 Mips_output_data_la25_stub
<size
, big_endian
>::la25_stub_entry
[] =
7088 0x3c190000, // lui $25,%hi(func)
7089 0x08000000, // j func
7090 0x27390000, // add $25,$25,%lo(func)
7094 // Template for microMIPS LA25 stub.
7095 template<int size
, bool big_endian
>
7097 Mips_output_data_la25_stub
<size
, big_endian
>::la25_stub_micromips_entry
[] =
7099 0x41b9, 0x0000, // lui t9,%hi(func)
7100 0xd400, 0x0000, // j func
7101 0x3339, 0x0000, // addiu t9,t9,%lo(func)
7102 0x0000, 0x0000 // nop
7105 // Create la25 stub for a symbol.
7107 template<int size
, bool big_endian
>
7109 Mips_output_data_la25_stub
<size
, big_endian
>::create_la25_stub(
7110 Symbol_table
* symtab
, Target_mips
<size
, big_endian
>* target
,
7111 Mips_symbol
<size
>* gsym
)
7113 if (!gsym
->has_la25_stub())
7115 gsym
->set_la25_stub_offset(this->symbols_
.size() * 16);
7116 this->symbols_
.push_back(gsym
);
7117 this->create_stub_symbol(gsym
, symtab
, target
, 16);
7121 // Create a symbol for SYM stub's value and size, to help make the disassembly
7124 template<int size
, bool big_endian
>
7126 Mips_output_data_la25_stub
<size
, big_endian
>::create_stub_symbol(
7127 Mips_symbol
<size
>* sym
, Symbol_table
* symtab
,
7128 Target_mips
<size
, big_endian
>* target
, uint64_t symsize
)
7130 std::string
name(".pic.");
7131 name
+= sym
->name();
7133 unsigned int offset
= sym
->la25_stub_offset();
7134 if (sym
->is_micromips())
7137 // Make it a local function.
7138 Symbol
* new_sym
= symtab
->define_in_output_data(name
.c_str(), NULL
,
7139 Symbol_table::PREDEFINED
,
7140 target
->la25_stub_section(),
7141 offset
, symsize
, elfcpp::STT_FUNC
,
7143 elfcpp::STV_DEFAULT
, 0,
7145 new_sym
->set_is_forced_local();
7148 // Write out la25 stubs. This uses the hand-coded instructions above,
7149 // and adjusts them as needed.
7151 template<int size
, bool big_endian
>
7153 Mips_output_data_la25_stub
<size
, big_endian
>::do_write(Output_file
* of
)
7155 const off_t offset
= this->offset();
7156 const section_size_type oview_size
=
7157 convert_to_section_size_type(this->data_size());
7158 unsigned char* const oview
= of
->get_output_view(offset
, oview_size
);
7160 for (typename
std::vector
<Mips_symbol
<size
>*>::iterator
7161 p
= this->symbols_
.begin();
7162 p
!= this->symbols_
.end();
7165 Mips_symbol
<size
>* sym
= *p
;
7166 unsigned char* pov
= oview
+ sym
->la25_stub_offset();
7168 Mips_address target
= sym
->value();
7169 if (!sym
->is_micromips())
7171 elfcpp::Swap
<32, big_endian
>::writeval(pov
,
7172 la25_stub_entry
[0] | (((target
+ 0x8000) >> 16) & 0xffff));
7173 elfcpp::Swap
<32, big_endian
>::writeval(pov
+ 4,
7174 la25_stub_entry
[1] | ((target
>> 2) & 0x3ffffff));
7175 elfcpp::Swap
<32, big_endian
>::writeval(pov
+ 8,
7176 la25_stub_entry
[2] | (target
& 0xffff));
7177 elfcpp::Swap
<32, big_endian
>::writeval(pov
+ 12, la25_stub_entry
[3]);
7182 // First stub instruction. Paste high 16-bits of the target.
7183 elfcpp::Swap
<16, big_endian
>::writeval(pov
,
7184 la25_stub_micromips_entry
[0]);
7185 elfcpp::Swap
<16, big_endian
>::writeval(pov
+ 2,
7186 ((target
+ 0x8000) >> 16) & 0xffff);
7187 // Second stub instruction. Paste low 26-bits of the target, shifted
7189 elfcpp::Swap
<16, big_endian
>::writeval(pov
+ 4,
7190 la25_stub_micromips_entry
[2] | ((target
>> 17) & 0x3ff));
7191 elfcpp::Swap
<16, big_endian
>::writeval(pov
+ 6,
7192 la25_stub_micromips_entry
[3] | ((target
>> 1) & 0xffff));
7193 // Third stub instruction. Paste low 16-bits of the target.
7194 elfcpp::Swap
<16, big_endian
>::writeval(pov
+ 8,
7195 la25_stub_micromips_entry
[4]);
7196 elfcpp::Swap
<16, big_endian
>::writeval(pov
+ 10, target
& 0xffff);
7197 // Fourth stub instruction.
7198 elfcpp::Swap
<16, big_endian
>::writeval(pov
+ 12,
7199 la25_stub_micromips_entry
[6]);
7200 elfcpp::Swap
<16, big_endian
>::writeval(pov
+ 14,
7201 la25_stub_micromips_entry
[7]);
7205 of
->write_output_view(offset
, oview_size
, oview
);
7208 // Mips_output_data_plt methods.
7210 // The format of the first PLT entry in an O32 executable.
7211 template<int size
, bool big_endian
>
7212 const uint32_t Mips_output_data_plt
<size
, big_endian
>::plt0_entry_o32
[] =
7214 0x3c1c0000, // lui $28, %hi(&GOTPLT[0])
7215 0x8f990000, // lw $25, %lo(&GOTPLT[0])($28)
7216 0x279c0000, // addiu $28, $28, %lo(&GOTPLT[0])
7217 0x031cc023, // subu $24, $24, $28
7218 0x03e07825, // or $15, $31, zero
7219 0x0018c082, // srl $24, $24, 2
7220 0x0320f809, // jalr $25
7221 0x2718fffe // subu $24, $24, 2
7224 // The format of the first PLT entry in an N32 executable. Different
7225 // because gp ($28) is not available; we use t2 ($14) instead.
7226 template<int size
, bool big_endian
>
7227 const uint32_t Mips_output_data_plt
<size
, big_endian
>::plt0_entry_n32
[] =
7229 0x3c0e0000, // lui $14, %hi(&GOTPLT[0])
7230 0x8dd90000, // lw $25, %lo(&GOTPLT[0])($14)
7231 0x25ce0000, // addiu $14, $14, %lo(&GOTPLT[0])
7232 0x030ec023, // subu $24, $24, $14
7233 0x03e07825, // or $15, $31, zero
7234 0x0018c082, // srl $24, $24, 2
7235 0x0320f809, // jalr $25
7236 0x2718fffe // subu $24, $24, 2
7239 // The format of the first PLT entry in an N64 executable. Different
7240 // from N32 because of the increased size of GOT entries.
7241 template<int size
, bool big_endian
>
7242 const uint32_t Mips_output_data_plt
<size
, big_endian
>::plt0_entry_n64
[] =
7244 0x3c0e0000, // lui $14, %hi(&GOTPLT[0])
7245 0xddd90000, // ld $25, %lo(&GOTPLT[0])($14)
7246 0x25ce0000, // addiu $14, $14, %lo(&GOTPLT[0])
7247 0x030ec023, // subu $24, $24, $14
7248 0x03e07825, // or $15, $31, zero
7249 0x0018c0c2, // srl $24, $24, 3
7250 0x0320f809, // jalr $25
7251 0x2718fffe // subu $24, $24, 2
7254 // The format of the microMIPS first PLT entry in an O32 executable.
7255 // We rely on v0 ($2) rather than t8 ($24) to contain the address
7256 // of the GOTPLT entry handled, so this stub may only be used when
7257 // all the subsequent PLT entries are microMIPS code too.
7259 // The trailing NOP is for alignment and correct disassembly only.
7260 template<int size
, bool big_endian
>
7261 const uint32_t Mips_output_data_plt
<size
, big_endian
>::
7262 plt0_entry_micromips_o32
[] =
7264 0x7980, 0x0000, // addiupc $3, (&GOTPLT[0]) - .
7265 0xff23, 0x0000, // lw $25, 0($3)
7266 0x0535, // subu $2, $2, $3
7267 0x2525, // srl $2, $2, 2
7268 0x3302, 0xfffe, // subu $24, $2, 2
7269 0x0dff, // move $15, $31
7270 0x45f9, // jalrs $25
7271 0x0f83, // move $28, $3
7275 // The format of the microMIPS first PLT entry in an O32 executable
7276 // in the insn32 mode.
7277 template<int size
, bool big_endian
>
7278 const uint32_t Mips_output_data_plt
<size
, big_endian
>::
7279 plt0_entry_micromips32_o32
[] =
7281 0x41bc, 0x0000, // lui $28, %hi(&GOTPLT[0])
7282 0xff3c, 0x0000, // lw $25, %lo(&GOTPLT[0])($28)
7283 0x339c, 0x0000, // addiu $28, $28, %lo(&GOTPLT[0])
7284 0x0398, 0xc1d0, // subu $24, $24, $28
7285 0x001f, 0x7a90, // or $15, $31, zero
7286 0x0318, 0x1040, // srl $24, $24, 2
7287 0x03f9, 0x0f3c, // jalr $25
7288 0x3318, 0xfffe // subu $24, $24, 2
7291 // The format of subsequent standard entries in the PLT.
7292 template<int size
, bool big_endian
>
7293 const uint32_t Mips_output_data_plt
<size
, big_endian
>::plt_entry
[] =
7295 0x3c0f0000, // lui $15, %hi(.got.plt entry)
7296 0x01f90000, // l[wd] $25, %lo(.got.plt entry)($15)
7297 0x03200008, // jr $25
7298 0x25f80000 // addiu $24, $15, %lo(.got.plt entry)
7301 // The format of subsequent R6 PLT entries.
7302 template<int size
, bool big_endian
>
7303 const uint32_t Mips_output_data_plt
<size
, big_endian
>::plt_entry_r6
[] =
7305 0x3c0f0000, // lui $15, %hi(.got.plt entry)
7306 0x01f90000, // l[wd] $25, %lo(.got.plt entry)($15)
7307 0x03200009, // jr $25
7308 0x25f80000 // addiu $24, $15, %lo(.got.plt entry)
7311 // The format of subsequent MIPS16 o32 PLT entries. We use v1 ($3) as a
7312 // temporary because t8 ($24) and t9 ($25) are not directly addressable.
7313 // Note that this differs from the GNU ld which uses both v0 ($2) and v1 ($3).
7314 // We cannot use v0 because MIPS16 call stubs from the CS toolchain expect
7315 // target function address in register v0.
7316 template<int size
, bool big_endian
>
7317 const uint32_t Mips_output_data_plt
<size
, big_endian
>::plt_entry_mips16_o32
[] =
7319 0xb303, // lw $3, 12($pc)
7320 0x651b, // move $24, $3
7321 0x9b60, // lw $3, 0($3)
7323 0x653b, // move $25, $3
7325 0x0000, 0x0000 // .word (.got.plt entry)
7328 // The format of subsequent microMIPS o32 PLT entries. We use v0 ($2)
7329 // as a temporary because t8 ($24) is not addressable with ADDIUPC.
7330 template<int size
, bool big_endian
>
7331 const uint32_t Mips_output_data_plt
<size
, big_endian
>::
7332 plt_entry_micromips_o32
[] =
7334 0x7900, 0x0000, // addiupc $2, (.got.plt entry) - .
7335 0xff22, 0x0000, // lw $25, 0($2)
7337 0x0f02 // move $24, $2
7340 // The format of subsequent microMIPS o32 PLT entries in the insn32 mode.
7341 template<int size
, bool big_endian
>
7342 const uint32_t Mips_output_data_plt
<size
, big_endian
>::
7343 plt_entry_micromips32_o32
[] =
7345 0x41af, 0x0000, // lui $15, %hi(.got.plt entry)
7346 0xff2f, 0x0000, // lw $25, %lo(.got.plt entry)($15)
7347 0x0019, 0x0f3c, // jr $25
7348 0x330f, 0x0000 // addiu $24, $15, %lo(.got.plt entry)
7351 // Add an entry to the PLT for a symbol referenced by r_type relocation.
7353 template<int size
, bool big_endian
>
7355 Mips_output_data_plt
<size
, big_endian
>::add_entry(Mips_symbol
<size
>* gsym
,
7356 unsigned int r_type
)
7358 gold_assert(!gsym
->has_plt_offset());
7360 // Final PLT offset for a symbol will be set in method set_plt_offsets().
7361 gsym
->set_plt_offset(this->entry_count() * sizeof(plt_entry
)
7362 + sizeof(plt0_entry_o32
));
7363 this->symbols_
.push_back(gsym
);
7365 // Record whether the relocation requires a standard MIPS
7366 // or a compressed code entry.
7367 if (jal_reloc(r_type
))
7369 if (r_type
== elfcpp::R_MIPS_26
)
7370 gsym
->set_needs_mips_plt(true);
7372 gsym
->set_needs_comp_plt(true);
7375 section_offset_type got_offset
= this->got_plt_
->current_data_size();
7377 // Every PLT entry needs a GOT entry which points back to the PLT
7378 // entry (this will be changed by the dynamic linker, normally
7379 // lazily when the function is called).
7380 this->got_plt_
->set_current_data_size(got_offset
+ size
/8);
7382 gsym
->set_needs_dynsym_entry();
7383 this->rel_
->add_global(gsym
, elfcpp::R_MIPS_JUMP_SLOT
, this->got_plt_
,
7387 // Set final PLT offsets. For each symbol, determine whether standard or
7388 // compressed (MIPS16 or microMIPS) PLT entry is used.
7390 template<int size
, bool big_endian
>
7392 Mips_output_data_plt
<size
, big_endian
>::set_plt_offsets()
7394 // The sizes of individual PLT entries.
7395 unsigned int plt_mips_entry_size
= this->standard_plt_entry_size();
7396 unsigned int plt_comp_entry_size
= (!this->target_
->is_output_newabi()
7397 ? this->compressed_plt_entry_size() : 0);
7399 for (typename
std::vector
<Mips_symbol
<size
>*>::const_iterator
7400 p
= this->symbols_
.begin(); p
!= this->symbols_
.end(); ++p
)
7402 Mips_symbol
<size
>* mips_sym
= *p
;
7404 // There are no defined MIPS16 or microMIPS PLT entries for n32 or n64,
7405 // so always use a standard entry there.
7407 // If the symbol has a MIPS16 call stub and gets a PLT entry, then
7408 // all MIPS16 calls will go via that stub, and there is no benefit
7409 // to having a MIPS16 entry. And in the case of call_stub a
7410 // standard entry actually has to be used as the stub ends with a J
7412 if (this->target_
->is_output_newabi()
7413 || mips_sym
->has_mips16_call_stub()
7414 || mips_sym
->has_mips16_call_fp_stub())
7416 mips_sym
->set_needs_mips_plt(true);
7417 mips_sym
->set_needs_comp_plt(false);
7420 // Otherwise, if there are no direct calls to the function, we
7421 // have a free choice of whether to use standard or compressed
7422 // entries. Prefer microMIPS entries if the object is known to
7423 // contain microMIPS code, so that it becomes possible to create
7424 // pure microMIPS binaries. Prefer standard entries otherwise,
7425 // because MIPS16 ones are no smaller and are usually slower.
7426 if (!mips_sym
->needs_mips_plt() && !mips_sym
->needs_comp_plt())
7428 if (this->target_
->is_output_micromips())
7429 mips_sym
->set_needs_comp_plt(true);
7431 mips_sym
->set_needs_mips_plt(true);
7434 if (mips_sym
->needs_mips_plt())
7436 mips_sym
->set_mips_plt_offset(this->plt_mips_offset_
);
7437 this->plt_mips_offset_
+= plt_mips_entry_size
;
7439 if (mips_sym
->needs_comp_plt())
7441 mips_sym
->set_comp_plt_offset(this->plt_comp_offset_
);
7442 this->plt_comp_offset_
+= plt_comp_entry_size
;
7446 // Figure out the size of the PLT header if we know that we are using it.
7447 if (this->plt_mips_offset_
+ this->plt_comp_offset_
!= 0)
7448 this->plt_header_size_
= this->get_plt_header_size();
7451 // Write out the PLT. This uses the hand-coded instructions above,
7452 // and adjusts them as needed.
7454 template<int size
, bool big_endian
>
7456 Mips_output_data_plt
<size
, big_endian
>::do_write(Output_file
* of
)
7458 const off_t offset
= this->offset();
7459 const section_size_type oview_size
=
7460 convert_to_section_size_type(this->data_size());
7461 unsigned char* const oview
= of
->get_output_view(offset
, oview_size
);
7463 const off_t gotplt_file_offset
= this->got_plt_
->offset();
7464 const section_size_type gotplt_size
=
7465 convert_to_section_size_type(this->got_plt_
->data_size());
7466 unsigned char* const gotplt_view
= of
->get_output_view(gotplt_file_offset
,
7468 unsigned char* pov
= oview
;
7470 Mips_address plt_address
= this->address();
7472 // Calculate the address of .got.plt.
7473 Mips_address gotplt_addr
= this->got_plt_
->address();
7474 Mips_address gotplt_addr_high
= ((gotplt_addr
+ 0x8000) >> 16) & 0xffff;
7475 Mips_address gotplt_addr_low
= gotplt_addr
& 0xffff;
7477 // The PLT sequence is not safe for N64 if .got.plt's address can
7478 // not be loaded in two instructions.
7479 gold_assert((gotplt_addr
& ~(Mips_address
) 0x7fffffff) == 0
7480 || ~(gotplt_addr
| 0x7fffffff) == 0);
7482 // Write the PLT header.
7483 const uint32_t* plt0_entry
= this->get_plt_header_entry();
7484 if (plt0_entry
== plt0_entry_micromips_o32
)
7486 // Write microMIPS PLT header.
7487 gold_assert(gotplt_addr
% 4 == 0);
7489 Mips_address gotpc_offset
= gotplt_addr
- ((plt_address
| 3) ^ 3);
7491 // ADDIUPC has a span of +/-16MB, check we're in range.
7492 if (gotpc_offset
+ 0x1000000 >= 0x2000000)
7494 gold_error(_(".got.plt offset of %ld from .plt beyond the range of "
7495 "ADDIUPC"), (long)gotpc_offset
);
7499 elfcpp::Swap
<16, big_endian
>::writeval(pov
,
7500 plt0_entry
[0] | ((gotpc_offset
>> 18) & 0x7f));
7501 elfcpp::Swap
<16, big_endian
>::writeval(pov
+ 2,
7502 (gotpc_offset
>> 2) & 0xffff);
7504 for (unsigned int i
= 2;
7505 i
< (sizeof(plt0_entry_micromips_o32
)
7506 / sizeof(plt0_entry_micromips_o32
[0]));
7509 elfcpp::Swap
<16, big_endian
>::writeval(pov
, plt0_entry
[i
]);
7513 else if (plt0_entry
== plt0_entry_micromips32_o32
)
7515 // Write microMIPS PLT header in insn32 mode.
7516 elfcpp::Swap
<16, big_endian
>::writeval(pov
, plt0_entry
[0]);
7517 elfcpp::Swap
<16, big_endian
>::writeval(pov
+ 2, gotplt_addr_high
);
7518 elfcpp::Swap
<16, big_endian
>::writeval(pov
+ 4, plt0_entry
[2]);
7519 elfcpp::Swap
<16, big_endian
>::writeval(pov
+ 6, gotplt_addr_low
);
7520 elfcpp::Swap
<16, big_endian
>::writeval(pov
+ 8, plt0_entry
[4]);
7521 elfcpp::Swap
<16, big_endian
>::writeval(pov
+ 10, gotplt_addr_low
);
7523 for (unsigned int i
= 6;
7524 i
< (sizeof(plt0_entry_micromips32_o32
)
7525 / sizeof(plt0_entry_micromips32_o32
[0]));
7528 elfcpp::Swap
<16, big_endian
>::writeval(pov
, plt0_entry
[i
]);
7534 // Write standard PLT header.
7535 elfcpp::Swap
<32, big_endian
>::writeval(pov
,
7536 plt0_entry
[0] | gotplt_addr_high
);
7537 elfcpp::Swap
<32, big_endian
>::writeval(pov
+ 4,
7538 plt0_entry
[1] | gotplt_addr_low
);
7539 elfcpp::Swap
<32, big_endian
>::writeval(pov
+ 8,
7540 plt0_entry
[2] | gotplt_addr_low
);
7542 for (int i
= 3; i
< 8; i
++)
7544 elfcpp::Swap
<32, big_endian
>::writeval(pov
, plt0_entry
[i
]);
7550 unsigned char* gotplt_pov
= gotplt_view
;
7551 unsigned int got_entry_size
= size
/8; // TODO(sasa): MIPS_ELF_GOT_SIZE
7553 // The first two entries in .got.plt are reserved.
7554 elfcpp::Swap
<size
, big_endian
>::writeval(gotplt_pov
, 0);
7555 elfcpp::Swap
<size
, big_endian
>::writeval(gotplt_pov
+ got_entry_size
, 0);
7557 unsigned int gotplt_offset
= 2 * got_entry_size
;
7558 gotplt_pov
+= 2 * got_entry_size
;
7560 // Calculate the address of the PLT header.
7561 Mips_address header_address
= (plt_address
7562 + (this->is_plt_header_compressed() ? 1 : 0));
7564 // Initialize compressed PLT area view.
7565 unsigned char* pov2
= pov
+ this->plt_mips_offset_
;
7567 // Write the PLT entries.
7568 for (typename
std::vector
<Mips_symbol
<size
>*>::const_iterator
7569 p
= this->symbols_
.begin();
7570 p
!= this->symbols_
.end();
7571 ++p
, gotplt_pov
+= got_entry_size
, gotplt_offset
+= got_entry_size
)
7573 Mips_symbol
<size
>* mips_sym
= *p
;
7575 // Calculate the address of the .got.plt entry.
7576 uint32_t gotplt_entry_addr
= (gotplt_addr
+ gotplt_offset
);
7577 uint32_t gotplt_entry_addr_hi
= (((gotplt_entry_addr
+ 0x8000) >> 16)
7579 uint32_t gotplt_entry_addr_lo
= gotplt_entry_addr
& 0xffff;
7581 // Initially point the .got.plt entry at the PLT header.
7582 if (this->target_
->is_output_n64())
7583 elfcpp::Swap
<64, big_endian
>::writeval(gotplt_pov
, header_address
);
7585 elfcpp::Swap
<32, big_endian
>::writeval(gotplt_pov
, header_address
);
7587 // Now handle the PLT itself. First the standard entry.
7588 if (mips_sym
->has_mips_plt_offset())
7590 // Pick the load opcode (LW or LD).
7591 uint64_t load
= this->target_
->is_output_n64() ? 0xdc000000
7594 const uint32_t* entry
= this->target_
->is_output_r6() ? plt_entry_r6
7597 // Fill in the PLT entry itself.
7598 elfcpp::Swap
<32, big_endian
>::writeval(pov
,
7599 entry
[0] | gotplt_entry_addr_hi
);
7600 elfcpp::Swap
<32, big_endian
>::writeval(pov
+ 4,
7601 entry
[1] | gotplt_entry_addr_lo
| load
);
7602 elfcpp::Swap
<32, big_endian
>::writeval(pov
+ 8, entry
[2]);
7603 elfcpp::Swap
<32, big_endian
>::writeval(pov
+ 12,
7604 entry
[3] | gotplt_entry_addr_lo
);
7608 // Now the compressed entry. They come after any standard ones.
7609 if (mips_sym
->has_comp_plt_offset())
7611 if (!this->target_
->is_output_micromips())
7613 // Write MIPS16 PLT entry.
7614 const uint32_t* plt_entry
= plt_entry_mips16_o32
;
7616 elfcpp::Swap
<16, big_endian
>::writeval(pov2
, plt_entry
[0]);
7617 elfcpp::Swap
<16, big_endian
>::writeval(pov2
+ 2, plt_entry
[1]);
7618 elfcpp::Swap
<16, big_endian
>::writeval(pov2
+ 4, plt_entry
[2]);
7619 elfcpp::Swap
<16, big_endian
>::writeval(pov2
+ 6, plt_entry
[3]);
7620 elfcpp::Swap
<16, big_endian
>::writeval(pov2
+ 8, plt_entry
[4]);
7621 elfcpp::Swap
<16, big_endian
>::writeval(pov2
+ 10, plt_entry
[5]);
7622 elfcpp::Swap
<32, big_endian
>::writeval(pov2
+ 12,
7626 else if (this->target_
->use_32bit_micromips_instructions())
7628 // Write microMIPS PLT entry in insn32 mode.
7629 const uint32_t* plt_entry
= plt_entry_micromips32_o32
;
7631 elfcpp::Swap
<16, big_endian
>::writeval(pov2
, plt_entry
[0]);
7632 elfcpp::Swap
<16, big_endian
>::writeval(pov2
+ 2,
7633 gotplt_entry_addr_hi
);
7634 elfcpp::Swap
<16, big_endian
>::writeval(pov2
+ 4, plt_entry
[2]);
7635 elfcpp::Swap
<16, big_endian
>::writeval(pov2
+ 6,
7636 gotplt_entry_addr_lo
);
7637 elfcpp::Swap
<16, big_endian
>::writeval(pov2
+ 8, plt_entry
[4]);
7638 elfcpp::Swap
<16, big_endian
>::writeval(pov2
+ 10, plt_entry
[5]);
7639 elfcpp::Swap
<16, big_endian
>::writeval(pov2
+ 12, plt_entry
[6]);
7640 elfcpp::Swap
<16, big_endian
>::writeval(pov2
+ 14,
7641 gotplt_entry_addr_lo
);
7646 // Write microMIPS PLT entry.
7647 const uint32_t* plt_entry
= plt_entry_micromips_o32
;
7649 gold_assert(gotplt_entry_addr
% 4 == 0);
7651 Mips_address loc_address
= plt_address
+ pov2
- oview
;
7652 int gotpc_offset
= gotplt_entry_addr
- ((loc_address
| 3) ^ 3);
7654 // ADDIUPC has a span of +/-16MB, check we're in range.
7655 if (gotpc_offset
+ 0x1000000 >= 0x2000000)
7657 gold_error(_(".got.plt offset of %ld from .plt beyond the "
7658 "range of ADDIUPC"), (long)gotpc_offset
);
7662 elfcpp::Swap
<16, big_endian
>::writeval(pov2
,
7663 plt_entry
[0] | ((gotpc_offset
>> 18) & 0x7f));
7664 elfcpp::Swap
<16, big_endian
>::writeval(
7665 pov2
+ 2, (gotpc_offset
>> 2) & 0xffff);
7666 elfcpp::Swap
<16, big_endian
>::writeval(pov2
+ 4, plt_entry
[2]);
7667 elfcpp::Swap
<16, big_endian
>::writeval(pov2
+ 6, plt_entry
[3]);
7668 elfcpp::Swap
<16, big_endian
>::writeval(pov2
+ 8, plt_entry
[4]);
7669 elfcpp::Swap
<16, big_endian
>::writeval(pov2
+ 10, plt_entry
[5]);
7675 // Check the number of bytes written for standard entries.
7676 gold_assert(static_cast<section_size_type
>(
7677 pov
- oview
- this->plt_header_size_
) == this->plt_mips_offset_
);
7678 // Check the number of bytes written for compressed entries.
7679 gold_assert((static_cast<section_size_type
>(pov2
- pov
)
7680 == this->plt_comp_offset_
));
7681 // Check the total number of bytes written.
7682 gold_assert(static_cast<section_size_type
>(pov2
- oview
) == oview_size
);
7684 gold_assert(static_cast<section_size_type
>(gotplt_pov
- gotplt_view
)
7687 of
->write_output_view(offset
, oview_size
, oview
);
7688 of
->write_output_view(gotplt_file_offset
, gotplt_size
, gotplt_view
);
7691 // Mips_output_data_mips_stubs methods.
7693 // The format of the lazy binding stub when dynamic symbol count is less than
7694 // 64K, dynamic symbol index is less than 32K, and ABI is not N64.
7695 template<int size
, bool big_endian
>
7697 Mips_output_data_mips_stubs
<size
, big_endian
>::lazy_stub_normal_1
[4] =
7699 0x8f998010, // lw t9,0x8010(gp)
7700 0x03e07825, // or t7,ra,zero
7701 0x0320f809, // jalr t9,ra
7702 0x24180000 // addiu t8,zero,DYN_INDEX sign extended
7705 // The format of the lazy binding stub when dynamic symbol count is less than
7706 // 64K, dynamic symbol index is less than 32K, and ABI is N64.
7707 template<int size
, bool big_endian
>
7709 Mips_output_data_mips_stubs
<size
, big_endian
>::lazy_stub_normal_1_n64
[4] =
7711 0xdf998010, // ld t9,0x8010(gp)
7712 0x03e07825, // or t7,ra,zero
7713 0x0320f809, // jalr t9,ra
7714 0x64180000 // daddiu t8,zero,DYN_INDEX sign extended
7717 // The format of the lazy binding stub when dynamic symbol count is less than
7718 // 64K, dynamic symbol index is between 32K and 64K, and ABI is not N64.
7719 template<int size
, bool big_endian
>
7721 Mips_output_data_mips_stubs
<size
, big_endian
>::lazy_stub_normal_2
[4] =
7723 0x8f998010, // lw t9,0x8010(gp)
7724 0x03e07825, // or t7,ra,zero
7725 0x0320f809, // jalr t9,ra
7726 0x34180000 // ori t8,zero,DYN_INDEX unsigned
7729 // The format of the lazy binding stub when dynamic symbol count is less than
7730 // 64K, dynamic symbol index is between 32K and 64K, and ABI is N64.
7731 template<int size
, bool big_endian
>
7733 Mips_output_data_mips_stubs
<size
, big_endian
>::lazy_stub_normal_2_n64
[4] =
7735 0xdf998010, // ld t9,0x8010(gp)
7736 0x03e07825, // or t7,ra,zero
7737 0x0320f809, // jalr t9,ra
7738 0x34180000 // ori t8,zero,DYN_INDEX unsigned
7741 // The format of the lazy binding stub when dynamic symbol count is greater than
7742 // 64K, and ABI is not N64.
7743 template<int size
, bool big_endian
>
7744 const uint32_t Mips_output_data_mips_stubs
<size
, big_endian
>::lazy_stub_big
[5] =
7746 0x8f998010, // lw t9,0x8010(gp)
7747 0x03e07825, // or t7,ra,zero
7748 0x3c180000, // lui t8,DYN_INDEX
7749 0x0320f809, // jalr t9,ra
7750 0x37180000 // ori t8,t8,DYN_INDEX
7753 // The format of the lazy binding stub when dynamic symbol count is greater than
7754 // 64K, and ABI is N64.
7755 template<int size
, bool big_endian
>
7757 Mips_output_data_mips_stubs
<size
, big_endian
>::lazy_stub_big_n64
[5] =
7759 0xdf998010, // ld t9,0x8010(gp)
7760 0x03e07825, // or t7,ra,zero
7761 0x3c180000, // lui t8,DYN_INDEX
7762 0x0320f809, // jalr t9,ra
7763 0x37180000 // ori t8,t8,DYN_INDEX
7768 // The format of the microMIPS lazy binding stub when dynamic symbol count is
7769 // less than 64K, dynamic symbol index is less than 32K, and ABI is not N64.
7770 template<int size
, bool big_endian
>
7772 Mips_output_data_mips_stubs
<size
, big_endian
>::lazy_stub_micromips_normal_1
[] =
7774 0xff3c, 0x8010, // lw t9,0x8010(gp)
7775 0x0dff, // move t7,ra
7777 0x3300, 0x0000 // addiu t8,zero,DYN_INDEX sign extended
7780 // The format of the microMIPS lazy binding stub when dynamic symbol count is
7781 // less than 64K, dynamic symbol index is less than 32K, and ABI is N64.
7782 template<int size
, bool big_endian
>
7784 Mips_output_data_mips_stubs
<size
, big_endian
>::
7785 lazy_stub_micromips_normal_1_n64
[] =
7787 0xdf3c, 0x8010, // ld t9,0x8010(gp)
7788 0x0dff, // move t7,ra
7790 0x5f00, 0x0000 // daddiu t8,zero,DYN_INDEX sign extended
7793 // The format of the microMIPS lazy binding stub when dynamic symbol
7794 // count is less than 64K, dynamic symbol index is between 32K and 64K,
7795 // and ABI is not N64.
7796 template<int size
, bool big_endian
>
7798 Mips_output_data_mips_stubs
<size
, big_endian
>::lazy_stub_micromips_normal_2
[] =
7800 0xff3c, 0x8010, // lw t9,0x8010(gp)
7801 0x0dff, // move t7,ra
7803 0x5300, 0x0000 // ori t8,zero,DYN_INDEX unsigned
7806 // The format of the microMIPS lazy binding stub when dynamic symbol
7807 // count is less than 64K, dynamic symbol index is between 32K and 64K,
7809 template<int size
, bool big_endian
>
7811 Mips_output_data_mips_stubs
<size
, big_endian
>::
7812 lazy_stub_micromips_normal_2_n64
[] =
7814 0xdf3c, 0x8010, // ld t9,0x8010(gp)
7815 0x0dff, // move t7,ra
7817 0x5300, 0x0000 // ori t8,zero,DYN_INDEX unsigned
7820 // The format of the microMIPS lazy binding stub when dynamic symbol count is
7821 // greater than 64K, and ABI is not N64.
7822 template<int size
, bool big_endian
>
7824 Mips_output_data_mips_stubs
<size
, big_endian
>::lazy_stub_micromips_big
[] =
7826 0xff3c, 0x8010, // lw t9,0x8010(gp)
7827 0x0dff, // move t7,ra
7828 0x41b8, 0x0000, // lui t8,DYN_INDEX
7830 0x5318, 0x0000 // ori t8,t8,DYN_INDEX
7833 // The format of the microMIPS lazy binding stub when dynamic symbol count is
7834 // greater than 64K, and ABI is N64.
7835 template<int size
, bool big_endian
>
7837 Mips_output_data_mips_stubs
<size
, big_endian
>::lazy_stub_micromips_big_n64
[] =
7839 0xdf3c, 0x8010, // ld t9,0x8010(gp)
7840 0x0dff, // move t7,ra
7841 0x41b8, 0x0000, // lui t8,DYN_INDEX
7843 0x5318, 0x0000 // ori t8,t8,DYN_INDEX
7846 // 32-bit microMIPS stubs.
7848 // The format of the microMIPS lazy binding stub when dynamic symbol count is
7849 // less than 64K, dynamic symbol index is less than 32K, ABI is not N64, and we
7850 // can use only 32-bit instructions.
7851 template<int size
, bool big_endian
>
7853 Mips_output_data_mips_stubs
<size
, big_endian
>::
7854 lazy_stub_micromips32_normal_1
[] =
7856 0xff3c, 0x8010, // lw t9,0x8010(gp)
7857 0x001f, 0x7a90, // or t7,ra,zero
7858 0x03f9, 0x0f3c, // jalr ra,t9
7859 0x3300, 0x0000 // addiu t8,zero,DYN_INDEX sign extended
7862 // The format of the microMIPS lazy binding stub when dynamic symbol count is
7863 // less than 64K, dynamic symbol index is less than 32K, ABI is N64, and we can
7864 // use only 32-bit instructions.
7865 template<int size
, bool big_endian
>
7867 Mips_output_data_mips_stubs
<size
, big_endian
>::
7868 lazy_stub_micromips32_normal_1_n64
[] =
7870 0xdf3c, 0x8010, // ld t9,0x8010(gp)
7871 0x001f, 0x7a90, // or t7,ra,zero
7872 0x03f9, 0x0f3c, // jalr ra,t9
7873 0x5f00, 0x0000 // daddiu t8,zero,DYN_INDEX sign extended
7876 // The format of the microMIPS lazy binding stub when dynamic symbol
7877 // count is less than 64K, dynamic symbol index is between 32K and 64K,
7878 // ABI is not N64, and we can use only 32-bit instructions.
7879 template<int size
, bool big_endian
>
7881 Mips_output_data_mips_stubs
<size
, big_endian
>::
7882 lazy_stub_micromips32_normal_2
[] =
7884 0xff3c, 0x8010, // lw t9,0x8010(gp)
7885 0x001f, 0x7a90, // or t7,ra,zero
7886 0x03f9, 0x0f3c, // jalr ra,t9
7887 0x5300, 0x0000 // ori t8,zero,DYN_INDEX unsigned
7890 // The format of the microMIPS lazy binding stub when dynamic symbol
7891 // count is less than 64K, dynamic symbol index is between 32K and 64K,
7892 // ABI is N64, and we can use only 32-bit instructions.
7893 template<int size
, bool big_endian
>
7895 Mips_output_data_mips_stubs
<size
, big_endian
>::
7896 lazy_stub_micromips32_normal_2_n64
[] =
7898 0xdf3c, 0x8010, // ld t9,0x8010(gp)
7899 0x001f, 0x7a90, // or t7,ra,zero
7900 0x03f9, 0x0f3c, // jalr ra,t9
7901 0x5300, 0x0000 // ori t8,zero,DYN_INDEX unsigned
7904 // The format of the microMIPS lazy binding stub when dynamic symbol count is
7905 // greater than 64K, ABI is not N64, and we can use only 32-bit instructions.
7906 template<int size
, bool big_endian
>
7908 Mips_output_data_mips_stubs
<size
, big_endian
>::lazy_stub_micromips32_big
[] =
7910 0xff3c, 0x8010, // lw t9,0x8010(gp)
7911 0x001f, 0x7a90, // or t7,ra,zero
7912 0x41b8, 0x0000, // lui t8,DYN_INDEX
7913 0x03f9, 0x0f3c, // jalr ra,t9
7914 0x5318, 0x0000 // ori t8,t8,DYN_INDEX
7917 // The format of the microMIPS lazy binding stub when dynamic symbol count is
7918 // greater than 64K, ABI is N64, and we can use only 32-bit instructions.
7919 template<int size
, bool big_endian
>
7921 Mips_output_data_mips_stubs
<size
, big_endian
>::lazy_stub_micromips32_big_n64
[] =
7923 0xdf3c, 0x8010, // ld t9,0x8010(gp)
7924 0x001f, 0x7a90, // or t7,ra,zero
7925 0x41b8, 0x0000, // lui t8,DYN_INDEX
7926 0x03f9, 0x0f3c, // jalr ra,t9
7927 0x5318, 0x0000 // ori t8,t8,DYN_INDEX
7930 // Create entry for a symbol.
7932 template<int size
, bool big_endian
>
7934 Mips_output_data_mips_stubs
<size
, big_endian
>::make_entry(
7935 Mips_symbol
<size
>* gsym
)
7937 if (!gsym
->has_lazy_stub() && !gsym
->has_plt_offset())
7939 this->symbols_
.insert(gsym
);
7940 gsym
->set_has_lazy_stub(true);
7944 // Remove entry for a symbol.
7946 template<int size
, bool big_endian
>
7948 Mips_output_data_mips_stubs
<size
, big_endian
>::remove_entry(
7949 Mips_symbol
<size
>* gsym
)
7951 if (gsym
->has_lazy_stub())
7953 this->symbols_
.erase(gsym
);
7954 gsym
->set_has_lazy_stub(false);
7958 // Set stub offsets for symbols. This method expects that the number of
7959 // entries in dynamic symbol table is set.
7961 template<int size
, bool big_endian
>
7963 Mips_output_data_mips_stubs
<size
, big_endian
>::set_lazy_stub_offsets()
7965 gold_assert(this->dynsym_count_
!= -1U);
7967 if (this->stub_offsets_are_set_
)
7970 unsigned int stub_size
= this->stub_size();
7971 unsigned int offset
= 0;
7972 for (typename
Mips_stubs_entry_set::const_iterator
7973 p
= this->symbols_
.begin();
7974 p
!= this->symbols_
.end();
7975 ++p
, offset
+= stub_size
)
7977 Mips_symbol
<size
>* mips_sym
= *p
;
7978 mips_sym
->set_lazy_stub_offset(offset
);
7980 this->stub_offsets_are_set_
= true;
7983 template<int size
, bool big_endian
>
7985 Mips_output_data_mips_stubs
<size
, big_endian
>::set_needs_dynsym_value()
7987 for (typename
Mips_stubs_entry_set::const_iterator
7988 p
= this->symbols_
.begin(); p
!= this->symbols_
.end(); ++p
)
7990 Mips_symbol
<size
>* sym
= *p
;
7991 if (sym
->is_from_dynobj())
7992 sym
->set_needs_dynsym_value();
7996 // Write out the .MIPS.stubs. This uses the hand-coded instructions and
7997 // adjusts them as needed.
7999 template<int size
, bool big_endian
>
8001 Mips_output_data_mips_stubs
<size
, big_endian
>::do_write(Output_file
* of
)
8003 const off_t offset
= this->offset();
8004 const section_size_type oview_size
=
8005 convert_to_section_size_type(this->data_size());
8006 unsigned char* const oview
= of
->get_output_view(offset
, oview_size
);
8008 bool big_stub
= this->dynsym_count_
> 0x10000;
8010 unsigned char* pov
= oview
;
8011 for (typename
Mips_stubs_entry_set::const_iterator
8012 p
= this->symbols_
.begin(); p
!= this->symbols_
.end(); ++p
)
8014 Mips_symbol
<size
>* sym
= *p
;
8015 const uint32_t* lazy_stub
;
8016 bool n64
= this->target_
->is_output_n64();
8018 if (!this->target_
->is_output_micromips())
8020 // Write standard (non-microMIPS) stub.
8023 if (sym
->dynsym_index() & ~0x7fff)
8024 // Dynsym index is between 32K and 64K.
8025 lazy_stub
= n64
? lazy_stub_normal_2_n64
: lazy_stub_normal_2
;
8027 // Dynsym index is less than 32K.
8028 lazy_stub
= n64
? lazy_stub_normal_1_n64
: lazy_stub_normal_1
;
8031 lazy_stub
= n64
? lazy_stub_big_n64
: lazy_stub_big
;
8034 elfcpp::Swap
<32, big_endian
>::writeval(pov
, lazy_stub
[i
]);
8035 elfcpp::Swap
<32, big_endian
>::writeval(pov
+ 4, lazy_stub
[i
+ 1]);
8041 // LUI instruction of the big stub. Paste high 16 bits of the
8043 elfcpp::Swap
<32, big_endian
>::writeval(pov
,
8044 lazy_stub
[i
] | ((sym
->dynsym_index() >> 16) & 0x7fff));
8048 elfcpp::Swap
<32, big_endian
>::writeval(pov
, lazy_stub
[i
]);
8049 // Last stub instruction. Paste low 16 bits of the dynsym index.
8050 elfcpp::Swap
<32, big_endian
>::writeval(pov
+ 4,
8051 lazy_stub
[i
+ 1] | (sym
->dynsym_index() & 0xffff));
8054 else if (this->target_
->use_32bit_micromips_instructions())
8056 // Write microMIPS stub in insn32 mode.
8059 if (sym
->dynsym_index() & ~0x7fff)
8060 // Dynsym index is between 32K and 64K.
8061 lazy_stub
= n64
? lazy_stub_micromips32_normal_2_n64
8062 : lazy_stub_micromips32_normal_2
;
8064 // Dynsym index is less than 32K.
8065 lazy_stub
= n64
? lazy_stub_micromips32_normal_1_n64
8066 : lazy_stub_micromips32_normal_1
;
8069 lazy_stub
= n64
? lazy_stub_micromips32_big_n64
8070 : lazy_stub_micromips32_big
;
8073 // First stub instruction. We emit 32-bit microMIPS instructions by
8074 // emitting two 16-bit parts because on microMIPS the 16-bit part of
8075 // the instruction where the opcode is must always come first, for
8076 // both little and big endian.
8077 elfcpp::Swap
<16, big_endian
>::writeval(pov
, lazy_stub
[i
]);
8078 elfcpp::Swap
<16, big_endian
>::writeval(pov
+ 2, lazy_stub
[i
+ 1]);
8079 // Second stub instruction.
8080 elfcpp::Swap
<16, big_endian
>::writeval(pov
+ 4, lazy_stub
[i
+ 2]);
8081 elfcpp::Swap
<16, big_endian
>::writeval(pov
+ 6, lazy_stub
[i
+ 3]);
8086 // LUI instruction of the big stub. Paste high 16 bits of the
8088 elfcpp::Swap
<16, big_endian
>::writeval(pov
, lazy_stub
[i
]);
8089 elfcpp::Swap
<16, big_endian
>::writeval(pov
+ 2,
8090 (sym
->dynsym_index() >> 16) & 0x7fff);
8094 elfcpp::Swap
<16, big_endian
>::writeval(pov
, lazy_stub
[i
]);
8095 elfcpp::Swap
<16, big_endian
>::writeval(pov
+ 2, lazy_stub
[i
+ 1]);
8096 // Last stub instruction. Paste low 16 bits of the dynsym index.
8097 elfcpp::Swap
<16, big_endian
>::writeval(pov
+ 4, lazy_stub
[i
+ 2]);
8098 elfcpp::Swap
<16, big_endian
>::writeval(pov
+ 6,
8099 sym
->dynsym_index() & 0xffff);
8104 // Write microMIPS stub.
8107 if (sym
->dynsym_index() & ~0x7fff)
8108 // Dynsym index is between 32K and 64K.
8109 lazy_stub
= n64
? lazy_stub_micromips_normal_2_n64
8110 : lazy_stub_micromips_normal_2
;
8112 // Dynsym index is less than 32K.
8113 lazy_stub
= n64
? lazy_stub_micromips_normal_1_n64
8114 : lazy_stub_micromips_normal_1
;
8117 lazy_stub
= n64
? lazy_stub_micromips_big_n64
8118 : lazy_stub_micromips_big
;
8121 // First stub instruction. We emit 32-bit microMIPS instructions by
8122 // emitting two 16-bit parts because on microMIPS the 16-bit part of
8123 // the instruction where the opcode is must always come first, for
8124 // both little and big endian.
8125 elfcpp::Swap
<16, big_endian
>::writeval(pov
, lazy_stub
[i
]);
8126 elfcpp::Swap
<16, big_endian
>::writeval(pov
+ 2, lazy_stub
[i
+ 1]);
8127 // Second stub instruction.
8128 elfcpp::Swap
<16, big_endian
>::writeval(pov
+ 4, lazy_stub
[i
+ 2]);
8133 // LUI instruction of the big stub. Paste high 16 bits of the
8135 elfcpp::Swap
<16, big_endian
>::writeval(pov
, lazy_stub
[i
]);
8136 elfcpp::Swap
<16, big_endian
>::writeval(pov
+ 2,
8137 (sym
->dynsym_index() >> 16) & 0x7fff);
8141 elfcpp::Swap
<16, big_endian
>::writeval(pov
, lazy_stub
[i
]);
8142 // Last stub instruction. Paste low 16 bits of the dynsym index.
8143 elfcpp::Swap
<16, big_endian
>::writeval(pov
+ 2, lazy_stub
[i
+ 1]);
8144 elfcpp::Swap
<16, big_endian
>::writeval(pov
+ 4,
8145 sym
->dynsym_index() & 0xffff);
8150 // We always allocate 20 bytes for every stub, because final dynsym count is
8151 // not known in method do_finalize_sections. There are 4 unused bytes per
8152 // stub if final dynsym count is less than 0x10000.
8153 unsigned int used
= pov
- oview
;
8154 unsigned int unused
= big_stub
? 0 : this->symbols_
.size() * 4;
8155 gold_assert(static_cast<section_size_type
>(used
+ unused
) == oview_size
);
8157 // Fill the unused space with zeroes.
8158 // TODO(sasa): Can we strip unused bytes during the relaxation?
8160 memset(pov
, 0, unused
);
8162 of
->write_output_view(offset
, oview_size
, oview
);
8165 // Mips_output_section_reginfo methods.
8167 template<int size
, bool big_endian
>
8169 Mips_output_section_reginfo
<size
, big_endian
>::do_write(Output_file
* of
)
8171 off_t offset
= this->offset();
8172 off_t data_size
= this->data_size();
8174 unsigned char* view
= of
->get_output_view(offset
, data_size
);
8175 elfcpp::Swap
<size
, big_endian
>::writeval(view
, this->gprmask_
);
8176 elfcpp::Swap
<size
, big_endian
>::writeval(view
+ 4, this->cprmask1_
);
8177 elfcpp::Swap
<size
, big_endian
>::writeval(view
+ 8, this->cprmask2_
);
8178 elfcpp::Swap
<size
, big_endian
>::writeval(view
+ 12, this->cprmask3_
);
8179 elfcpp::Swap
<size
, big_endian
>::writeval(view
+ 16, this->cprmask4_
);
8180 // Write the gp value.
8181 elfcpp::Swap
<size
, big_endian
>::writeval(view
+ 20,
8182 this->target_
->gp_value());
8184 of
->write_output_view(offset
, data_size
, view
);
8187 // Mips_output_section_abiflags methods.
8189 template<int size
, bool big_endian
>
8191 Mips_output_section_abiflags
<size
, big_endian
>::do_write(Output_file
* of
)
8193 off_t offset
= this->offset();
8194 off_t data_size
= this->data_size();
8196 unsigned char* view
= of
->get_output_view(offset
, data_size
);
8197 elfcpp::Swap
<16, big_endian
>::writeval(view
, this->abiflags_
.version
);
8198 elfcpp::Swap
<8, big_endian
>::writeval(view
+ 2, this->abiflags_
.isa_level
);
8199 elfcpp::Swap
<8, big_endian
>::writeval(view
+ 3, this->abiflags_
.isa_rev
);
8200 elfcpp::Swap
<8, big_endian
>::writeval(view
+ 4, this->abiflags_
.gpr_size
);
8201 elfcpp::Swap
<8, big_endian
>::writeval(view
+ 5, this->abiflags_
.cpr1_size
);
8202 elfcpp::Swap
<8, big_endian
>::writeval(view
+ 6, this->abiflags_
.cpr2_size
);
8203 elfcpp::Swap
<8, big_endian
>::writeval(view
+ 7, this->abiflags_
.fp_abi
);
8204 elfcpp::Swap
<32, big_endian
>::writeval(view
+ 8, this->abiflags_
.isa_ext
);
8205 elfcpp::Swap
<32, big_endian
>::writeval(view
+ 12, this->abiflags_
.ases
);
8206 elfcpp::Swap
<32, big_endian
>::writeval(view
+ 16, this->abiflags_
.flags1
);
8207 elfcpp::Swap
<32, big_endian
>::writeval(view
+ 20, this->abiflags_
.flags2
);
8209 of
->write_output_view(offset
, data_size
, view
);
8212 // Mips_copy_relocs methods.
8214 // Emit any saved relocs.
8216 template<int sh_type
, int size
, bool big_endian
>
8218 Mips_copy_relocs
<sh_type
, size
, big_endian
>::emit_mips(
8219 Output_data_reloc
<sh_type
, true, size
, big_endian
>* reloc_section
,
8220 Symbol_table
* symtab
, Layout
* layout
, Target_mips
<size
, big_endian
>* target
)
8222 for (typename Copy_relocs
<sh_type
, size
, big_endian
>::
8223 Copy_reloc_entries::iterator p
= this->entries_
.begin();
8224 p
!= this->entries_
.end();
8226 emit_entry(*p
, reloc_section
, symtab
, layout
, target
);
8228 // We no longer need the saved information.
8229 this->entries_
.clear();
8232 // Emit the reloc if appropriate.
8234 template<int sh_type
, int size
, bool big_endian
>
8236 Mips_copy_relocs
<sh_type
, size
, big_endian
>::emit_entry(
8237 Copy_reloc_entry
& entry
,
8238 Output_data_reloc
<sh_type
, true, size
, big_endian
>* reloc_section
,
8239 Symbol_table
* symtab
, Layout
* layout
, Target_mips
<size
, big_endian
>* target
)
8241 // If the symbol is no longer defined in a dynamic object, then we
8242 // emitted a COPY relocation, and we do not want to emit this
8243 // dynamic relocation.
8244 if (!entry
.sym_
->is_from_dynobj())
8247 bool can_make_dynamic
= (entry
.reloc_type_
== elfcpp::R_MIPS_32
8248 || entry
.reloc_type_
== elfcpp::R_MIPS_REL32
8249 || entry
.reloc_type_
== elfcpp::R_MIPS_64
);
8251 Mips_symbol
<size
>* sym
= Mips_symbol
<size
>::as_mips_sym(entry
.sym_
);
8252 if (can_make_dynamic
&& !sym
->has_static_relocs())
8254 Mips_relobj
<size
, big_endian
>* object
=
8255 Mips_relobj
<size
, big_endian
>::as_mips_relobj(entry
.relobj_
);
8256 target
->got_section(symtab
, layout
)->record_global_got_symbol(
8257 sym
, object
, entry
.reloc_type_
, true, false);
8258 if (!symbol_references_local(sym
, sym
->should_add_dynsym_entry(symtab
)))
8259 target
->rel_dyn_section(layout
)->add_global(sym
, elfcpp::R_MIPS_REL32
,
8260 entry
.output_section_
, entry
.relobj_
, entry
.shndx_
, entry
.address_
);
8262 target
->rel_dyn_section(layout
)->add_symbolless_global_addend(
8263 sym
, elfcpp::R_MIPS_REL32
, entry
.output_section_
, entry
.relobj_
,
8264 entry
.shndx_
, entry
.address_
);
8267 this->make_copy_reloc(symtab
, layout
,
8268 static_cast<Sized_symbol
<size
>*>(entry
.sym_
),
8273 // Target_mips methods.
8275 // Return the value to use for a dynamic symbol which requires special
8276 // treatment. This is how we support equality comparisons of function
8277 // pointers across shared library boundaries, as described in the
8278 // processor specific ABI supplement.
8280 template<int size
, bool big_endian
>
8282 Target_mips
<size
, big_endian
>::do_dynsym_value(const Symbol
* gsym
) const
8285 const Mips_symbol
<size
>* mips_sym
= Mips_symbol
<size
>::as_mips_sym(gsym
);
8287 if (!mips_sym
->has_lazy_stub())
8289 if (mips_sym
->has_plt_offset())
8291 // We distinguish between PLT entries and lazy-binding stubs by
8292 // giving the former an st_other value of STO_MIPS_PLT. Set the
8293 // value to the stub address if there are any relocations in the
8294 // binary where pointer equality matters.
8295 if (mips_sym
->pointer_equality_needed())
8297 // Prefer a standard MIPS PLT entry.
8298 if (mips_sym
->has_mips_plt_offset())
8299 value
= this->plt_section()->mips_entry_address(mips_sym
);
8301 value
= this->plt_section()->comp_entry_address(mips_sym
) + 1;
8309 // First, set stub offsets for symbols. This method expects that the
8310 // number of entries in dynamic symbol table is set.
8311 this->mips_stubs_section()->set_lazy_stub_offsets();
8313 // The run-time linker uses the st_value field of the symbol
8314 // to reset the global offset table entry for this external
8315 // to its stub address when unlinking a shared object.
8316 value
= this->mips_stubs_section()->stub_address(mips_sym
);
8319 if (mips_sym
->has_mips16_fn_stub())
8321 // If we have a MIPS16 function with a stub, the dynamic symbol must
8322 // refer to the stub, since only the stub uses the standard calling
8324 value
= mips_sym
->template
8325 get_mips16_fn_stub
<big_endian
>()->output_address();
8331 // Get the dynamic reloc section, creating it if necessary. It's always
8332 // .rel.dyn, even for MIPS64.
8334 template<int size
, bool big_endian
>
8335 typename Target_mips
<size
, big_endian
>::Reloc_section
*
8336 Target_mips
<size
, big_endian
>::rel_dyn_section(Layout
* layout
)
8338 if (this->rel_dyn_
== NULL
)
8340 gold_assert(layout
!= NULL
);
8341 this->rel_dyn_
= new Reloc_section(parameters
->options().combreloc());
8342 layout
->add_output_section_data(".rel.dyn", elfcpp::SHT_REL
,
8343 elfcpp::SHF_ALLOC
, this->rel_dyn_
,
8344 ORDER_DYNAMIC_RELOCS
, false);
8346 // First entry in .rel.dyn has to be null.
8347 // This is hack - we define dummy output data and set its address to 0,
8348 // and define absolute R_MIPS_NONE relocation with offset 0 against it.
8349 // This ensures that the entry is null.
8350 Output_data
* od
= new Output_data_zero_fill(0, 0);
8352 this->rel_dyn_
->add_absolute(elfcpp::R_MIPS_NONE
, od
, 0);
8354 return this->rel_dyn_
;
8357 // Get the GOT section, creating it if necessary.
8359 template<int size
, bool big_endian
>
8360 Mips_output_data_got
<size
, big_endian
>*
8361 Target_mips
<size
, big_endian
>::got_section(Symbol_table
* symtab
,
8364 if (this->got_
== NULL
)
8366 gold_assert(symtab
!= NULL
&& layout
!= NULL
);
8368 this->got_
= new Mips_output_data_got
<size
, big_endian
>(this, symtab
,
8370 layout
->add_output_section_data(".got", elfcpp::SHT_PROGBITS
,
8371 (elfcpp::SHF_ALLOC
| elfcpp::SHF_WRITE
|
8372 elfcpp::SHF_MIPS_GPREL
),
8373 this->got_
, ORDER_DATA
, false);
8375 // Define _GLOBAL_OFFSET_TABLE_ at the start of the .got section.
8376 symtab
->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL
,
8377 Symbol_table::PREDEFINED
,
8379 0, 0, elfcpp::STT_OBJECT
,
8381 elfcpp::STV_DEFAULT
, 0,
8388 // Calculate value of _gp symbol.
8390 template<int size
, bool big_endian
>
8392 Target_mips
<size
, big_endian
>::set_gp(Layout
* layout
, Symbol_table
* symtab
)
8394 if (this->gp_
!= NULL
)
8397 Output_data
* section
= layout
->find_output_section(".got");
8398 if (section
== NULL
)
8400 // If there is no .got section, gp should be based on .sdata.
8401 // TODO(sasa): This is probably not needed. This was needed for older
8402 // MIPS architectures which accessed both GOT and .sdata section using
8403 // gp-relative addressing. Modern Mips Linux ELF architectures don't
8404 // access .sdata using gp-relative addressing.
8405 for (Layout::Section_list::const_iterator
8406 p
= layout
->section_list().begin();
8407 p
!= layout
->section_list().end();
8410 if (strcmp((*p
)->name(), ".sdata") == 0)
8418 Sized_symbol
<size
>* gp
=
8419 static_cast<Sized_symbol
<size
>*>(symtab
->lookup("_gp"));
8422 if (gp
->source() != Symbol::IS_CONSTANT
&& section
!= NULL
)
8423 gp
->init_output_data(gp
->name(), NULL
, section
, MIPS_GP_OFFSET
, 0,
8426 elfcpp::STV_DEFAULT
, 0,
8430 else if (section
!= NULL
)
8432 gp
= static_cast<Sized_symbol
<size
>*>(symtab
->define_in_output_data(
8433 "_gp", NULL
, Symbol_table::PREDEFINED
,
8434 section
, MIPS_GP_OFFSET
, 0,
8437 elfcpp::STV_DEFAULT
,
8443 // Set the dynamic symbol indexes. INDEX is the index of the first
8444 // global dynamic symbol. Pointers to the symbols are stored into the
8445 // vector SYMS. The names are added to DYNPOOL. This returns an
8446 // updated dynamic symbol index.
8448 template<int size
, bool big_endian
>
8450 Target_mips
<size
, big_endian
>::do_set_dynsym_indexes(
8451 std::vector
<Symbol
*>* dyn_symbols
, unsigned int index
,
8452 std::vector
<Symbol
*>* syms
, Stringpool
* dynpool
,
8453 Versions
* versions
, Symbol_table
* symtab
) const
8455 std::vector
<Symbol
*> non_got_symbols
;
8456 std::vector
<Symbol
*> got_symbols
;
8458 reorder_dyn_symbols
<size
, big_endian
>(dyn_symbols
, &non_got_symbols
,
8461 for (std::vector
<Symbol
*>::iterator p
= non_got_symbols
.begin();
8462 p
!= non_got_symbols
.end();
8467 // Note that SYM may already have a dynamic symbol index, since
8468 // some symbols appear more than once in the symbol table, with
8469 // and without a version.
8471 if (!sym
->has_dynsym_index())
8473 sym
->set_dynsym_index(index
);
8475 syms
->push_back(sym
);
8476 dynpool
->add(sym
->name(), false, NULL
);
8478 // Record any version information.
8479 if (sym
->version() != NULL
)
8480 versions
->record_version(symtab
, dynpool
, sym
);
8482 // If the symbol is defined in a dynamic object and is
8483 // referenced in a regular object, then mark the dynamic
8484 // object as needed. This is used to implement --as-needed.
8485 if (sym
->is_from_dynobj() && sym
->in_reg())
8486 sym
->object()->set_is_needed();
8490 for (std::vector
<Symbol
*>::iterator p
= got_symbols
.begin();
8491 p
!= got_symbols
.end();
8495 if (!sym
->has_dynsym_index())
8497 // Record any version information.
8498 if (sym
->version() != NULL
)
8499 versions
->record_version(symtab
, dynpool
, sym
);
8503 index
= versions
->finalize(symtab
, index
, syms
);
8505 int got_sym_count
= 0;
8506 for (std::vector
<Symbol
*>::iterator p
= got_symbols
.begin();
8507 p
!= got_symbols
.end();
8512 if (!sym
->has_dynsym_index())
8515 sym
->set_dynsym_index(index
);
8517 syms
->push_back(sym
);
8518 dynpool
->add(sym
->name(), false, NULL
);
8520 // If the symbol is defined in a dynamic object and is
8521 // referenced in a regular object, then mark the dynamic
8522 // object as needed. This is used to implement --as-needed.
8523 if (sym
->is_from_dynobj() && sym
->in_reg())
8524 sym
->object()->set_is_needed();
8528 // Set index of the first symbol that has .got entry.
8529 this->got_
->set_first_global_got_dynsym_index(
8530 got_sym_count
> 0 ? index
- got_sym_count
: -1U);
8532 if (this->mips_stubs_
!= NULL
)
8533 this->mips_stubs_
->set_dynsym_count(index
);
8538 // Create a PLT entry for a global symbol referenced by r_type relocation.
8540 template<int size
, bool big_endian
>
8542 Target_mips
<size
, big_endian
>::make_plt_entry(Symbol_table
* symtab
,
8544 Mips_symbol
<size
>* gsym
,
8545 unsigned int r_type
)
8547 if (gsym
->has_lazy_stub() || gsym
->has_plt_offset())
8550 if (this->plt_
== NULL
)
8552 // Create the GOT section first.
8553 this->got_section(symtab
, layout
);
8555 this->got_plt_
= new Output_data_space(4, "** GOT PLT");
8556 layout
->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS
,
8557 (elfcpp::SHF_ALLOC
| elfcpp::SHF_WRITE
),
8558 this->got_plt_
, ORDER_DATA
, false);
8560 // The first two entries are reserved.
8561 this->got_plt_
->set_current_data_size(2 * size
/8);
8563 this->plt_
= new Mips_output_data_plt
<size
, big_endian
>(layout
,
8566 layout
->add_output_section_data(".plt", elfcpp::SHT_PROGBITS
,
8568 | elfcpp::SHF_EXECINSTR
),
8569 this->plt_
, ORDER_PLT
, false);
8571 // Make the sh_info field of .rel.plt point to .plt.
8572 Output_section
* rel_plt_os
= this->plt_
->rel_plt()->output_section();
8573 rel_plt_os
->set_info_section(this->plt_
->output_section());
8576 this->plt_
->add_entry(gsym
, r_type
);
8580 // Get the .MIPS.stubs section, creating it if necessary.
8582 template<int size
, bool big_endian
>
8583 Mips_output_data_mips_stubs
<size
, big_endian
>*
8584 Target_mips
<size
, big_endian
>::mips_stubs_section(Layout
* layout
)
8586 if (this->mips_stubs_
== NULL
)
8589 new Mips_output_data_mips_stubs
<size
, big_endian
>(this);
8590 layout
->add_output_section_data(".MIPS.stubs", elfcpp::SHT_PROGBITS
,
8592 | elfcpp::SHF_EXECINSTR
),
8593 this->mips_stubs_
, ORDER_PLT
, false);
8595 return this->mips_stubs_
;
8598 // Get the LA25 stub section, creating it if necessary.
8600 template<int size
, bool big_endian
>
8601 Mips_output_data_la25_stub
<size
, big_endian
>*
8602 Target_mips
<size
, big_endian
>::la25_stub_section(Layout
* layout
)
8604 if (this->la25_stub_
== NULL
)
8606 this->la25_stub_
= new Mips_output_data_la25_stub
<size
, big_endian
>();
8607 layout
->add_output_section_data(".text", elfcpp::SHT_PROGBITS
,
8609 | elfcpp::SHF_EXECINSTR
),
8610 this->la25_stub_
, ORDER_TEXT
, false);
8612 return this->la25_stub_
;
8615 // Process the relocations to determine unreferenced sections for
8616 // garbage collection.
8618 template<int size
, bool big_endian
>
8620 Target_mips
<size
, big_endian
>::gc_process_relocs(
8621 Symbol_table
* symtab
,
8623 Sized_relobj_file
<size
, big_endian
>* object
,
8624 unsigned int data_shndx
,
8625 unsigned int sh_type
,
8626 const unsigned char* prelocs
,
8628 Output_section
* output_section
,
8629 bool needs_special_offset_handling
,
8630 size_t local_symbol_count
,
8631 const unsigned char* plocal_symbols
)
8633 typedef Target_mips
<size
, big_endian
> Mips
;
8635 if (sh_type
== elfcpp::SHT_REL
)
8637 typedef Mips_classify_reloc
<elfcpp::SHT_REL
, size
, big_endian
>
8640 gold::gc_process_relocs
<size
, big_endian
, Mips
, Scan
, Classify_reloc
>(
8649 needs_special_offset_handling
,
8653 else if (sh_type
== elfcpp::SHT_RELA
)
8655 typedef Mips_classify_reloc
<elfcpp::SHT_RELA
, size
, big_endian
>
8658 gold::gc_process_relocs
<size
, big_endian
, Mips
, Scan
, Classify_reloc
>(
8667 needs_special_offset_handling
,
8675 // Scan relocations for a section.
8677 template<int size
, bool big_endian
>
8679 Target_mips
<size
, big_endian
>::scan_relocs(
8680 Symbol_table
* symtab
,
8682 Sized_relobj_file
<size
, big_endian
>* object
,
8683 unsigned int data_shndx
,
8684 unsigned int sh_type
,
8685 const unsigned char* prelocs
,
8687 Output_section
* output_section
,
8688 bool needs_special_offset_handling
,
8689 size_t local_symbol_count
,
8690 const unsigned char* plocal_symbols
)
8692 typedef Target_mips
<size
, big_endian
> Mips
;
8694 if (sh_type
== elfcpp::SHT_REL
)
8696 typedef Mips_classify_reloc
<elfcpp::SHT_REL
, size
, big_endian
>
8699 gold::scan_relocs
<size
, big_endian
, Mips
, Scan
, Classify_reloc
>(
8708 needs_special_offset_handling
,
8712 else if (sh_type
== elfcpp::SHT_RELA
)
8714 typedef Mips_classify_reloc
<elfcpp::SHT_RELA
, size
, big_endian
>
8717 gold::scan_relocs
<size
, big_endian
, Mips
, Scan
, Classify_reloc
>(
8726 needs_special_offset_handling
,
8732 template<int size
, bool big_endian
>
8734 Target_mips
<size
, big_endian
>::mips_32bit_flags(elfcpp::Elf_Word flags
)
8736 return ((flags
& elfcpp::EF_MIPS_32BITMODE
) != 0
8737 || (flags
& elfcpp::EF_MIPS_ABI
) == elfcpp::E_MIPS_ABI_O32
8738 || (flags
& elfcpp::EF_MIPS_ABI
) == elfcpp::E_MIPS_ABI_EABI32
8739 || (flags
& elfcpp::EF_MIPS_ARCH
) == elfcpp::E_MIPS_ARCH_1
8740 || (flags
& elfcpp::EF_MIPS_ARCH
) == elfcpp::E_MIPS_ARCH_2
8741 || (flags
& elfcpp::EF_MIPS_ARCH
) == elfcpp::E_MIPS_ARCH_32
8742 || (flags
& elfcpp::EF_MIPS_ARCH
) == elfcpp::E_MIPS_ARCH_32R2
8743 || (flags
& elfcpp::EF_MIPS_ARCH
) == elfcpp::E_MIPS_ARCH_32R6
);
8746 // Return the MACH for a MIPS e_flags value.
8747 template<int size
, bool big_endian
>
8749 Target_mips
<size
, big_endian
>::elf_mips_mach(elfcpp::Elf_Word flags
)
8751 switch (flags
& elfcpp::EF_MIPS_MACH
)
8753 case elfcpp::E_MIPS_MACH_3900
:
8754 return mach_mips3900
;
8756 case elfcpp::E_MIPS_MACH_4010
:
8757 return mach_mips4010
;
8759 case elfcpp::E_MIPS_MACH_4100
:
8760 return mach_mips4100
;
8762 case elfcpp::E_MIPS_MACH_4111
:
8763 return mach_mips4111
;
8765 case elfcpp::E_MIPS_MACH_4120
:
8766 return mach_mips4120
;
8768 case elfcpp::E_MIPS_MACH_4650
:
8769 return mach_mips4650
;
8771 case elfcpp::E_MIPS_MACH_5400
:
8772 return mach_mips5400
;
8774 case elfcpp::E_MIPS_MACH_5500
:
8775 return mach_mips5500
;
8777 case elfcpp::E_MIPS_MACH_5900
:
8778 return mach_mips5900
;
8780 case elfcpp::E_MIPS_MACH_9000
:
8781 return mach_mips9000
;
8783 case elfcpp::E_MIPS_MACH_SB1
:
8784 return mach_mips_sb1
;
8786 case elfcpp::E_MIPS_MACH_LS2E
:
8787 return mach_mips_loongson_2e
;
8789 case elfcpp::E_MIPS_MACH_LS2F
:
8790 return mach_mips_loongson_2f
;
8792 case elfcpp::E_MIPS_MACH_LS3A
:
8793 return mach_mips_loongson_3a
;
8795 case elfcpp::E_MIPS_MACH_OCTEON3
:
8796 return mach_mips_octeon3
;
8798 case elfcpp::E_MIPS_MACH_OCTEON2
:
8799 return mach_mips_octeon2
;
8801 case elfcpp::E_MIPS_MACH_OCTEON
:
8802 return mach_mips_octeon
;
8804 case elfcpp::E_MIPS_MACH_XLR
:
8805 return mach_mips_xlr
;
8808 switch (flags
& elfcpp::EF_MIPS_ARCH
)
8811 case elfcpp::E_MIPS_ARCH_1
:
8812 return mach_mips3000
;
8814 case elfcpp::E_MIPS_ARCH_2
:
8815 return mach_mips6000
;
8817 case elfcpp::E_MIPS_ARCH_3
:
8818 return mach_mips4000
;
8820 case elfcpp::E_MIPS_ARCH_4
:
8821 return mach_mips8000
;
8823 case elfcpp::E_MIPS_ARCH_5
:
8826 case elfcpp::E_MIPS_ARCH_32
:
8827 return mach_mipsisa32
;
8829 case elfcpp::E_MIPS_ARCH_64
:
8830 return mach_mipsisa64
;
8832 case elfcpp::E_MIPS_ARCH_32R2
:
8833 return mach_mipsisa32r2
;
8835 case elfcpp::E_MIPS_ARCH_32R6
:
8836 return mach_mipsisa32r6
;
8838 case elfcpp::E_MIPS_ARCH_64R2
:
8839 return mach_mipsisa64r2
;
8841 case elfcpp::E_MIPS_ARCH_64R6
:
8842 return mach_mipsisa64r6
;
8849 // Return the MACH for each .MIPS.abiflags ISA Extension.
8851 template<int size
, bool big_endian
>
8853 Target_mips
<size
, big_endian
>::mips_isa_ext_mach(unsigned int isa_ext
)
8857 case elfcpp::AFL_EXT_3900
:
8858 return mach_mips3900
;
8860 case elfcpp::AFL_EXT_4010
:
8861 return mach_mips4010
;
8863 case elfcpp::AFL_EXT_4100
:
8864 return mach_mips4100
;
8866 case elfcpp::AFL_EXT_4111
:
8867 return mach_mips4111
;
8869 case elfcpp::AFL_EXT_4120
:
8870 return mach_mips4120
;
8872 case elfcpp::AFL_EXT_4650
:
8873 return mach_mips4650
;
8875 case elfcpp::AFL_EXT_5400
:
8876 return mach_mips5400
;
8878 case elfcpp::AFL_EXT_5500
:
8879 return mach_mips5500
;
8881 case elfcpp::AFL_EXT_5900
:
8882 return mach_mips5900
;
8884 case elfcpp::AFL_EXT_10000
:
8885 return mach_mips10000
;
8887 case elfcpp::AFL_EXT_LOONGSON_2E
:
8888 return mach_mips_loongson_2e
;
8890 case elfcpp::AFL_EXT_LOONGSON_2F
:
8891 return mach_mips_loongson_2f
;
8893 case elfcpp::AFL_EXT_LOONGSON_3A
:
8894 return mach_mips_loongson_3a
;
8896 case elfcpp::AFL_EXT_SB1
:
8897 return mach_mips_sb1
;
8899 case elfcpp::AFL_EXT_OCTEON
:
8900 return mach_mips_octeon
;
8902 case elfcpp::AFL_EXT_OCTEONP
:
8903 return mach_mips_octeonp
;
8905 case elfcpp::AFL_EXT_OCTEON2
:
8906 return mach_mips_octeon2
;
8908 case elfcpp::AFL_EXT_XLR
:
8909 return mach_mips_xlr
;
8912 return mach_mips3000
;
8916 // Return the .MIPS.abiflags value representing each ISA Extension.
8918 template<int size
, bool big_endian
>
8920 Target_mips
<size
, big_endian
>::mips_isa_ext(unsigned int mips_mach
)
8925 return elfcpp::AFL_EXT_3900
;
8928 return elfcpp::AFL_EXT_4010
;
8931 return elfcpp::AFL_EXT_4100
;
8934 return elfcpp::AFL_EXT_4111
;
8937 return elfcpp::AFL_EXT_4120
;
8940 return elfcpp::AFL_EXT_4650
;
8943 return elfcpp::AFL_EXT_5400
;
8946 return elfcpp::AFL_EXT_5500
;
8949 return elfcpp::AFL_EXT_5900
;
8951 case mach_mips10000
:
8952 return elfcpp::AFL_EXT_10000
;
8954 case mach_mips_loongson_2e
:
8955 return elfcpp::AFL_EXT_LOONGSON_2E
;
8957 case mach_mips_loongson_2f
:
8958 return elfcpp::AFL_EXT_LOONGSON_2F
;
8960 case mach_mips_loongson_3a
:
8961 return elfcpp::AFL_EXT_LOONGSON_3A
;
8964 return elfcpp::AFL_EXT_SB1
;
8966 case mach_mips_octeon
:
8967 return elfcpp::AFL_EXT_OCTEON
;
8969 case mach_mips_octeonp
:
8970 return elfcpp::AFL_EXT_OCTEONP
;
8972 case mach_mips_octeon3
:
8973 return elfcpp::AFL_EXT_OCTEON3
;
8975 case mach_mips_octeon2
:
8976 return elfcpp::AFL_EXT_OCTEON2
;
8979 return elfcpp::AFL_EXT_XLR
;
8986 // Update the isa_level, isa_rev, isa_ext fields of abiflags.
8988 template<int size
, bool big_endian
>
8990 Target_mips
<size
, big_endian
>::update_abiflags_isa(const std::string
& name
,
8991 elfcpp::Elf_Word e_flags
, Mips_abiflags
<big_endian
>* abiflags
)
8994 switch (e_flags
& elfcpp::EF_MIPS_ARCH
)
8996 case elfcpp::E_MIPS_ARCH_1
:
8997 new_isa
= this->level_rev(1, 0);
8999 case elfcpp::E_MIPS_ARCH_2
:
9000 new_isa
= this->level_rev(2, 0);
9002 case elfcpp::E_MIPS_ARCH_3
:
9003 new_isa
= this->level_rev(3, 0);
9005 case elfcpp::E_MIPS_ARCH_4
:
9006 new_isa
= this->level_rev(4, 0);
9008 case elfcpp::E_MIPS_ARCH_5
:
9009 new_isa
= this->level_rev(5, 0);
9011 case elfcpp::E_MIPS_ARCH_32
:
9012 new_isa
= this->level_rev(32, 1);
9014 case elfcpp::E_MIPS_ARCH_32R2
:
9015 new_isa
= this->level_rev(32, 2);
9017 case elfcpp::E_MIPS_ARCH_32R6
:
9018 new_isa
= this->level_rev(32, 6);
9020 case elfcpp::E_MIPS_ARCH_64
:
9021 new_isa
= this->level_rev(64, 1);
9023 case elfcpp::E_MIPS_ARCH_64R2
:
9024 new_isa
= this->level_rev(64, 2);
9026 case elfcpp::E_MIPS_ARCH_64R6
:
9027 new_isa
= this->level_rev(64, 6);
9030 gold_error(_("%s: Unknown architecture %s"), name
.c_str(),
9031 this->elf_mips_mach_name(e_flags
));
9034 if (new_isa
> this->level_rev(abiflags
->isa_level
, abiflags
->isa_rev
))
9036 // Decode a single value into level and revision.
9037 abiflags
->isa_level
= new_isa
>> 3;
9038 abiflags
->isa_rev
= new_isa
& 0x7;
9041 // Update the isa_ext if needed.
9042 if (this->mips_mach_extends(this->mips_isa_ext_mach(abiflags
->isa_ext
),
9043 this->elf_mips_mach(e_flags
)))
9044 abiflags
->isa_ext
= this->mips_isa_ext(this->elf_mips_mach(e_flags
));
9047 // Infer the content of the ABI flags based on the elf header.
9049 template<int size
, bool big_endian
>
9051 Target_mips
<size
, big_endian
>::infer_abiflags(
9052 Mips_relobj
<size
, big_endian
>* relobj
, Mips_abiflags
<big_endian
>* abiflags
)
9054 const Attributes_section_data
* pasd
= relobj
->attributes_section_data();
9055 int attr_fp_abi
= elfcpp::Val_GNU_MIPS_ABI_FP_ANY
;
9056 elfcpp::Elf_Word e_flags
= relobj
->processor_specific_flags();
9058 this->update_abiflags_isa(relobj
->name(), e_flags
, abiflags
);
9061 // Read fp_abi from the .gnu.attribute section.
9062 const Object_attribute
* attr
=
9063 pasd
->known_attributes(Object_attribute::OBJ_ATTR_GNU
);
9064 attr_fp_abi
= attr
[elfcpp::Tag_GNU_MIPS_ABI_FP
].int_value();
9067 abiflags
->fp_abi
= attr_fp_abi
;
9068 abiflags
->cpr1_size
= elfcpp::AFL_REG_NONE
;
9069 abiflags
->cpr2_size
= elfcpp::AFL_REG_NONE
;
9070 abiflags
->gpr_size
= this->mips_32bit_flags(e_flags
) ? elfcpp::AFL_REG_32
9071 : elfcpp::AFL_REG_64
;
9073 if (abiflags
->fp_abi
== elfcpp::Val_GNU_MIPS_ABI_FP_SINGLE
9074 || abiflags
->fp_abi
== elfcpp::Val_GNU_MIPS_ABI_FP_XX
9075 || (abiflags
->fp_abi
== elfcpp::Val_GNU_MIPS_ABI_FP_DOUBLE
9076 && abiflags
->gpr_size
== elfcpp::AFL_REG_32
))
9077 abiflags
->cpr1_size
= elfcpp::AFL_REG_32
;
9078 else if (abiflags
->fp_abi
== elfcpp::Val_GNU_MIPS_ABI_FP_DOUBLE
9079 || abiflags
->fp_abi
== elfcpp::Val_GNU_MIPS_ABI_FP_64
9080 || abiflags
->fp_abi
== elfcpp::Val_GNU_MIPS_ABI_FP_64A
)
9081 abiflags
->cpr1_size
= elfcpp::AFL_REG_64
;
9083 if (e_flags
& elfcpp::EF_MIPS_ARCH_ASE_MDMX
)
9084 abiflags
->ases
|= elfcpp::AFL_ASE_MDMX
;
9085 if (e_flags
& elfcpp::EF_MIPS_ARCH_ASE_M16
)
9086 abiflags
->ases
|= elfcpp::AFL_ASE_MIPS16
;
9087 if (e_flags
& elfcpp::EF_MIPS_ARCH_ASE_MICROMIPS
)
9088 abiflags
->ases
|= elfcpp::AFL_ASE_MICROMIPS
;
9090 if (abiflags
->fp_abi
!= elfcpp::Val_GNU_MIPS_ABI_FP_ANY
9091 && abiflags
->fp_abi
!= elfcpp::Val_GNU_MIPS_ABI_FP_SOFT
9092 && abiflags
->fp_abi
!= elfcpp::Val_GNU_MIPS_ABI_FP_64A
9093 && abiflags
->isa_level
>= 32
9094 && abiflags
->isa_ext
!= elfcpp::AFL_EXT_LOONGSON_3A
)
9095 abiflags
->flags1
|= elfcpp::AFL_FLAGS1_ODDSPREG
;
9098 // Create abiflags from elf header or from .MIPS.abiflags section.
9100 template<int size
, bool big_endian
>
9102 Target_mips
<size
, big_endian
>::create_abiflags(
9103 Mips_relobj
<size
, big_endian
>* relobj
,
9104 Mips_abiflags
<big_endian
>* abiflags
)
9106 Mips_abiflags
<big_endian
>* sec_abiflags
= relobj
->abiflags();
9107 Mips_abiflags
<big_endian
> header_abiflags
;
9109 this->infer_abiflags(relobj
, &header_abiflags
);
9111 if (sec_abiflags
== NULL
)
9113 // If there is no input .MIPS.abiflags section, use abiflags created
9115 *abiflags
= header_abiflags
;
9119 this->has_abiflags_section_
= true;
9121 // It is not possible to infer the correct ISA revision for R3 or R5
9122 // so drop down to R2 for the checks.
9123 unsigned char isa_rev
= sec_abiflags
->isa_rev
;
9124 if (isa_rev
== 3 || isa_rev
== 5)
9127 // Check compatibility between abiflags created from elf header
9128 // and abiflags from .MIPS.abiflags section in this object file.
9129 if (this->level_rev(sec_abiflags
->isa_level
, isa_rev
)
9130 < this->level_rev(header_abiflags
.isa_level
, header_abiflags
.isa_rev
))
9131 gold_warning(_("%s: Inconsistent ISA between e_flags and .MIPS.abiflags"),
9132 relobj
->name().c_str());
9133 if (header_abiflags
.fp_abi
!= elfcpp::Val_GNU_MIPS_ABI_FP_ANY
9134 && sec_abiflags
->fp_abi
!= header_abiflags
.fp_abi
)
9135 gold_warning(_("%s: Inconsistent FP ABI between .gnu.attributes and "
9136 ".MIPS.abiflags"), relobj
->name().c_str());
9137 if ((sec_abiflags
->ases
& header_abiflags
.ases
) != header_abiflags
.ases
)
9138 gold_warning(_("%s: Inconsistent ASEs between e_flags and .MIPS.abiflags"),
9139 relobj
->name().c_str());
9140 // The isa_ext is allowed to be an extension of what can be inferred
9142 if (!this->mips_mach_extends(this->mips_isa_ext_mach(header_abiflags
.isa_ext
),
9143 this->mips_isa_ext_mach(sec_abiflags
->isa_ext
)))
9144 gold_warning(_("%s: Inconsistent ISA extensions between e_flags and "
9145 ".MIPS.abiflags"), relobj
->name().c_str());
9146 if (sec_abiflags
->flags2
!= 0)
9147 gold_warning(_("%s: Unexpected flag in the flags2 field of "
9148 ".MIPS.abiflags (0x%x)"), relobj
->name().c_str(),
9149 sec_abiflags
->flags2
);
9150 // Use abiflags from .MIPS.abiflags section.
9151 *abiflags
= *sec_abiflags
;
9154 // Return the meaning of fp_abi, or "unknown" if not known.
9156 template<int size
, bool big_endian
>
9158 Target_mips
<size
, big_endian
>::fp_abi_string(int fp
)
9162 case elfcpp::Val_GNU_MIPS_ABI_FP_DOUBLE
:
9163 return "-mdouble-float";
9164 case elfcpp::Val_GNU_MIPS_ABI_FP_SINGLE
:
9165 return "-msingle-float";
9166 case elfcpp::Val_GNU_MIPS_ABI_FP_SOFT
:
9167 return "-msoft-float";
9168 case elfcpp::Val_GNU_MIPS_ABI_FP_OLD_64
:
9169 return _("-mips32r2 -mfp64 (12 callee-saved)");
9170 case elfcpp::Val_GNU_MIPS_ABI_FP_XX
:
9172 case elfcpp::Val_GNU_MIPS_ABI_FP_64
:
9173 return "-mgp32 -mfp64";
9174 case elfcpp::Val_GNU_MIPS_ABI_FP_64A
:
9175 return "-mgp32 -mfp64 -mno-odd-spreg";
9183 template<int size
, bool big_endian
>
9185 Target_mips
<size
, big_endian
>::select_fp_abi(const std::string
& name
, int in_fp
,
9188 if (in_fp
== out_fp
)
9191 if (out_fp
== elfcpp::Val_GNU_MIPS_ABI_FP_ANY
)
9193 else if (out_fp
== elfcpp::Val_GNU_MIPS_ABI_FP_XX
9194 && (in_fp
== elfcpp::Val_GNU_MIPS_ABI_FP_DOUBLE
9195 || in_fp
== elfcpp::Val_GNU_MIPS_ABI_FP_64
9196 || in_fp
== elfcpp::Val_GNU_MIPS_ABI_FP_64A
))
9198 else if (in_fp
== elfcpp::Val_GNU_MIPS_ABI_FP_XX
9199 && (out_fp
== elfcpp::Val_GNU_MIPS_ABI_FP_DOUBLE
9200 || out_fp
== elfcpp::Val_GNU_MIPS_ABI_FP_64
9201 || out_fp
== elfcpp::Val_GNU_MIPS_ABI_FP_64A
))
9202 return out_fp
; // Keep the current setting.
9203 else if (out_fp
== elfcpp::Val_GNU_MIPS_ABI_FP_64A
9204 && in_fp
== elfcpp::Val_GNU_MIPS_ABI_FP_64
)
9206 else if (in_fp
== elfcpp::Val_GNU_MIPS_ABI_FP_64A
9207 && out_fp
== elfcpp::Val_GNU_MIPS_ABI_FP_64
)
9208 return out_fp
; // Keep the current setting.
9209 else if (in_fp
!= elfcpp::Val_GNU_MIPS_ABI_FP_ANY
)
9210 gold_warning(_("%s: FP ABI %s is incompatible with %s"), name
.c_str(),
9211 fp_abi_string(in_fp
), fp_abi_string(out_fp
));
9215 // Merge attributes from input object.
9217 template<int size
, bool big_endian
>
9219 Target_mips
<size
, big_endian
>::merge_obj_attributes(const std::string
& name
,
9220 const Attributes_section_data
* pasd
)
9222 // Return if there is no attributes section data.
9226 // If output has no object attributes, just copy.
9227 if (this->attributes_section_data_
== NULL
)
9229 this->attributes_section_data_
= new Attributes_section_data(*pasd
);
9233 Object_attribute
* out_attr
= this->attributes_section_data_
->known_attributes(
9234 Object_attribute::OBJ_ATTR_GNU
);
9236 out_attr
[elfcpp::Tag_GNU_MIPS_ABI_FP
].set_type(1);
9237 out_attr
[elfcpp::Tag_GNU_MIPS_ABI_FP
].set_int_value(this->abiflags_
->fp_abi
);
9239 // Merge Tag_compatibility attributes and any common GNU ones.
9240 this->attributes_section_data_
->merge(name
.c_str(), pasd
);
9243 // Merge abiflags from input object.
9245 template<int size
, bool big_endian
>
9247 Target_mips
<size
, big_endian
>::merge_obj_abiflags(const std::string
& name
,
9248 Mips_abiflags
<big_endian
>* in_abiflags
)
9250 // If output has no abiflags, just copy.
9251 if (this->abiflags_
== NULL
)
9253 this->abiflags_
= new Mips_abiflags
<big_endian
>(*in_abiflags
);
9257 this->abiflags_
->fp_abi
= this->select_fp_abi(name
, in_abiflags
->fp_abi
,
9258 this->abiflags_
->fp_abi
);
9261 this->abiflags_
->isa_level
= std::max(this->abiflags_
->isa_level
,
9262 in_abiflags
->isa_level
);
9263 this->abiflags_
->isa_rev
= std::max(this->abiflags_
->isa_rev
,
9264 in_abiflags
->isa_rev
);
9265 this->abiflags_
->gpr_size
= std::max(this->abiflags_
->gpr_size
,
9266 in_abiflags
->gpr_size
);
9267 this->abiflags_
->cpr1_size
= std::max(this->abiflags_
->cpr1_size
,
9268 in_abiflags
->cpr1_size
);
9269 this->abiflags_
->cpr2_size
= std::max(this->abiflags_
->cpr2_size
,
9270 in_abiflags
->cpr2_size
);
9271 this->abiflags_
->ases
|= in_abiflags
->ases
;
9272 this->abiflags_
->flags1
|= in_abiflags
->flags1
;
9275 // Check whether machine EXTENSION is an extension of machine BASE.
9276 template<int size
, bool big_endian
>
9278 Target_mips
<size
, big_endian
>::mips_mach_extends(unsigned int base
,
9279 unsigned int extension
)
9281 if (extension
== base
)
9284 if ((base
== mach_mipsisa32
)
9285 && this->mips_mach_extends(mach_mipsisa64
, extension
))
9288 if ((base
== mach_mipsisa32r2
)
9289 && this->mips_mach_extends(mach_mipsisa64r2
, extension
))
9292 for (unsigned int i
= 0; i
< this->mips_mach_extensions_
.size(); ++i
)
9293 if (extension
== this->mips_mach_extensions_
[i
].first
)
9295 extension
= this->mips_mach_extensions_
[i
].second
;
9296 if (extension
== base
)
9303 // Merge file header flags from input object.
9305 template<int size
, bool big_endian
>
9307 Target_mips
<size
, big_endian
>::merge_obj_e_flags(const std::string
& name
,
9308 elfcpp::Elf_Word in_flags
)
9310 // If flags are not set yet, just copy them.
9311 if (!this->are_processor_specific_flags_set())
9313 this->set_processor_specific_flags(in_flags
);
9314 this->mach_
= this->elf_mips_mach(in_flags
);
9318 elfcpp::Elf_Word new_flags
= in_flags
;
9319 elfcpp::Elf_Word old_flags
= this->processor_specific_flags();
9320 elfcpp::Elf_Word merged_flags
= this->processor_specific_flags();
9321 merged_flags
|= new_flags
& elfcpp::EF_MIPS_NOREORDER
;
9323 // Check flag compatibility.
9324 new_flags
&= ~elfcpp::EF_MIPS_NOREORDER
;
9325 old_flags
&= ~elfcpp::EF_MIPS_NOREORDER
;
9327 // Some IRIX 6 BSD-compatibility objects have this bit set. It
9328 // doesn't seem to matter.
9329 new_flags
&= ~elfcpp::EF_MIPS_XGOT
;
9330 old_flags
&= ~elfcpp::EF_MIPS_XGOT
;
9332 // MIPSpro generates ucode info in n64 objects. Again, we should
9333 // just be able to ignore this.
9334 new_flags
&= ~elfcpp::EF_MIPS_UCODE
;
9335 old_flags
&= ~elfcpp::EF_MIPS_UCODE
;
9337 if (new_flags
== old_flags
)
9339 this->set_processor_specific_flags(merged_flags
);
9343 if (((new_flags
& (elfcpp::EF_MIPS_PIC
| elfcpp::EF_MIPS_CPIC
)) != 0)
9344 != ((old_flags
& (elfcpp::EF_MIPS_PIC
| elfcpp::EF_MIPS_CPIC
)) != 0))
9345 gold_warning(_("%s: linking abicalls files with non-abicalls files"),
9348 if (new_flags
& (elfcpp::EF_MIPS_PIC
| elfcpp::EF_MIPS_CPIC
))
9349 merged_flags
|= elfcpp::EF_MIPS_CPIC
;
9350 if (!(new_flags
& elfcpp::EF_MIPS_PIC
))
9351 merged_flags
&= ~elfcpp::EF_MIPS_PIC
;
9353 new_flags
&= ~(elfcpp::EF_MIPS_PIC
| elfcpp::EF_MIPS_CPIC
);
9354 old_flags
&= ~(elfcpp::EF_MIPS_PIC
| elfcpp::EF_MIPS_CPIC
);
9356 // Compare the ISAs.
9357 if (mips_32bit_flags(old_flags
) != mips_32bit_flags(new_flags
))
9358 gold_error(_("%s: linking 32-bit code with 64-bit code"), name
.c_str());
9359 else if (!this->mips_mach_extends(this->elf_mips_mach(in_flags
), this->mach_
))
9361 // Output ISA isn't the same as, or an extension of, input ISA.
9362 if (this->mips_mach_extends(this->mach_
, this->elf_mips_mach(in_flags
)))
9364 // Copy the architecture info from input object to output. Also copy
9365 // the 32-bit flag (if set) so that we continue to recognise
9366 // output as a 32-bit binary.
9367 this->mach_
= this->elf_mips_mach(in_flags
);
9368 merged_flags
&= ~(elfcpp::EF_MIPS_ARCH
| elfcpp::EF_MIPS_MACH
);
9369 merged_flags
|= (new_flags
& (elfcpp::EF_MIPS_ARCH
9370 | elfcpp::EF_MIPS_MACH
| elfcpp::EF_MIPS_32BITMODE
));
9372 // Update the ABI flags isa_level, isa_rev, isa_ext fields.
9373 this->update_abiflags_isa(name
, merged_flags
, this->abiflags_
);
9375 // Copy across the ABI flags if output doesn't use them
9376 // and if that was what caused us to treat input object as 32-bit.
9377 if ((old_flags
& elfcpp::EF_MIPS_ABI
) == 0
9378 && this->mips_32bit_flags(new_flags
)
9379 && !this->mips_32bit_flags(new_flags
& ~elfcpp::EF_MIPS_ABI
))
9380 merged_flags
|= new_flags
& elfcpp::EF_MIPS_ABI
;
9383 // The ISAs aren't compatible.
9384 gold_error(_("%s: linking %s module with previous %s modules"),
9385 name
.c_str(), this->elf_mips_mach_name(in_flags
),
9386 this->elf_mips_mach_name(merged_flags
));
9389 new_flags
&= (~(elfcpp::EF_MIPS_ARCH
| elfcpp::EF_MIPS_MACH
9390 | elfcpp::EF_MIPS_32BITMODE
));
9391 old_flags
&= (~(elfcpp::EF_MIPS_ARCH
| elfcpp::EF_MIPS_MACH
9392 | elfcpp::EF_MIPS_32BITMODE
));
9395 if ((new_flags
& elfcpp::EF_MIPS_ABI
) != (old_flags
& elfcpp::EF_MIPS_ABI
))
9397 // Only error if both are set (to different values).
9398 if ((new_flags
& elfcpp::EF_MIPS_ABI
)
9399 && (old_flags
& elfcpp::EF_MIPS_ABI
))
9400 gold_error(_("%s: ABI mismatch: linking %s module with "
9401 "previous %s modules"), name
.c_str(),
9402 this->elf_mips_abi_name(in_flags
),
9403 this->elf_mips_abi_name(merged_flags
));
9405 new_flags
&= ~elfcpp::EF_MIPS_ABI
;
9406 old_flags
&= ~elfcpp::EF_MIPS_ABI
;
9409 // Compare ASEs. Forbid linking MIPS16 and microMIPS ASE modules together
9410 // and allow arbitrary mixing of the remaining ASEs (retain the union).
9411 if ((new_flags
& elfcpp::EF_MIPS_ARCH_ASE
)
9412 != (old_flags
& elfcpp::EF_MIPS_ARCH_ASE
))
9414 int old_micro
= old_flags
& elfcpp::EF_MIPS_ARCH_ASE_MICROMIPS
;
9415 int new_micro
= new_flags
& elfcpp::EF_MIPS_ARCH_ASE_MICROMIPS
;
9416 int old_m16
= old_flags
& elfcpp::EF_MIPS_ARCH_ASE_M16
;
9417 int new_m16
= new_flags
& elfcpp::EF_MIPS_ARCH_ASE_M16
;
9418 int micro_mis
= old_m16
&& new_micro
;
9419 int m16_mis
= old_micro
&& new_m16
;
9421 if (m16_mis
|| micro_mis
)
9422 gold_error(_("%s: ASE mismatch: linking %s module with "
9423 "previous %s modules"), name
.c_str(),
9424 m16_mis
? "MIPS16" : "microMIPS",
9425 m16_mis
? "microMIPS" : "MIPS16");
9427 merged_flags
|= new_flags
& elfcpp::EF_MIPS_ARCH_ASE
;
9429 new_flags
&= ~ elfcpp::EF_MIPS_ARCH_ASE
;
9430 old_flags
&= ~ elfcpp::EF_MIPS_ARCH_ASE
;
9433 // Compare NaN encodings.
9434 if ((new_flags
& elfcpp::EF_MIPS_NAN2008
) != (old_flags
& elfcpp::EF_MIPS_NAN2008
))
9436 gold_error(_("%s: linking %s module with previous %s modules"),
9438 (new_flags
& elfcpp::EF_MIPS_NAN2008
9439 ? "-mnan=2008" : "-mnan=legacy"),
9440 (old_flags
& elfcpp::EF_MIPS_NAN2008
9441 ? "-mnan=2008" : "-mnan=legacy"));
9443 new_flags
&= ~elfcpp::EF_MIPS_NAN2008
;
9444 old_flags
&= ~elfcpp::EF_MIPS_NAN2008
;
9447 // Compare FP64 state.
9448 if ((new_flags
& elfcpp::EF_MIPS_FP64
) != (old_flags
& elfcpp::EF_MIPS_FP64
))
9450 gold_error(_("%s: linking %s module with previous %s modules"),
9452 (new_flags
& elfcpp::EF_MIPS_FP64
9453 ? "-mfp64" : "-mfp32"),
9454 (old_flags
& elfcpp::EF_MIPS_FP64
9455 ? "-mfp64" : "-mfp32"));
9457 new_flags
&= ~elfcpp::EF_MIPS_FP64
;
9458 old_flags
&= ~elfcpp::EF_MIPS_FP64
;
9461 // Warn about any other mismatches.
9462 if (new_flags
!= old_flags
)
9463 gold_error(_("%s: uses different e_flags (0x%x) fields than previous "
9464 "modules (0x%x)"), name
.c_str(), new_flags
, old_flags
);
9466 this->set_processor_specific_flags(merged_flags
);
9469 // Adjust ELF file header.
9471 template<int size
, bool big_endian
>
9473 Target_mips
<size
, big_endian
>::do_adjust_elf_header(
9474 unsigned char* view
,
9477 gold_assert(len
== elfcpp::Elf_sizes
<size
>::ehdr_size
);
9479 elfcpp::Ehdr
<size
, big_endian
> ehdr(view
);
9480 unsigned char e_ident
[elfcpp::EI_NIDENT
];
9481 elfcpp::Elf_Word flags
= this->processor_specific_flags();
9482 memcpy(e_ident
, ehdr
.get_e_ident(), elfcpp::EI_NIDENT
);
9484 unsigned char ei_abiversion
= 0;
9485 elfcpp::Elf_Half type
= ehdr
.get_e_type();
9486 if (type
== elfcpp::ET_EXEC
9487 && parameters
->options().copyreloc()
9488 && (flags
& (elfcpp::EF_MIPS_PIC
| elfcpp::EF_MIPS_CPIC
))
9489 == elfcpp::EF_MIPS_CPIC
)
9492 if (this->abiflags_
!= NULL
9493 && (this->abiflags_
->fp_abi
== elfcpp::Val_GNU_MIPS_ABI_FP_64
9494 || this->abiflags_
->fp_abi
== elfcpp::Val_GNU_MIPS_ABI_FP_64A
))
9497 e_ident
[elfcpp::EI_ABIVERSION
] = ei_abiversion
;
9498 elfcpp::Ehdr_write
<size
, big_endian
> oehdr(view
);
9499 oehdr
.put_e_ident(e_ident
);
9501 if (this->entry_symbol_is_compressed_
)
9502 oehdr
.put_e_entry(ehdr
.get_e_entry() + 1);
9505 // do_make_elf_object to override the same function in the base class.
9506 // We need to use a target-specific sub-class of
9507 // Sized_relobj_file<size, big_endian> to store Mips specific information.
9508 // Hence we need to have our own ELF object creation.
9510 template<int size
, bool big_endian
>
9512 Target_mips
<size
, big_endian
>::do_make_elf_object(
9513 const std::string
& name
,
9514 Input_file
* input_file
,
9515 off_t offset
, const elfcpp::Ehdr
<size
, big_endian
>& ehdr
)
9517 int et
= ehdr
.get_e_type();
9518 // ET_EXEC files are valid input for --just-symbols/-R,
9519 // and we treat them as relocatable objects.
9520 if (et
== elfcpp::ET_REL
9521 || (et
== elfcpp::ET_EXEC
&& input_file
->just_symbols()))
9523 Mips_relobj
<size
, big_endian
>* obj
=
9524 new Mips_relobj
<size
, big_endian
>(name
, input_file
, offset
, ehdr
);
9528 else if (et
== elfcpp::ET_DYN
)
9530 // TODO(sasa): Should we create Mips_dynobj?
9531 return Target::do_make_elf_object(name
, input_file
, offset
, ehdr
);
9535 gold_error(_("%s: unsupported ELF file type %d"),
9541 // Finalize the sections.
9543 template <int size
, bool big_endian
>
9545 Target_mips
<size
, big_endian
>::do_finalize_sections(Layout
* layout
,
9546 const Input_objects
* input_objects
,
9547 Symbol_table
* symtab
)
9549 // Add +1 to MIPS16 and microMIPS init_ and _fini symbols so that DT_INIT and
9550 // DT_FINI have correct values.
9551 Mips_symbol
<size
>* init
= static_cast<Mips_symbol
<size
>*>(
9552 symtab
->lookup(parameters
->options().init()));
9553 if (init
!= NULL
&& (init
->is_mips16() || init
->is_micromips()))
9554 init
->set_value(init
->value() | 1);
9555 Mips_symbol
<size
>* fini
= static_cast<Mips_symbol
<size
>*>(
9556 symtab
->lookup(parameters
->options().fini()));
9557 if (fini
!= NULL
&& (fini
->is_mips16() || fini
->is_micromips()))
9558 fini
->set_value(fini
->value() | 1);
9560 // Check whether the entry symbol is mips16 or micromips. This is needed to
9561 // adjust entry address in ELF header.
9562 Mips_symbol
<size
>* entry
=
9563 static_cast<Mips_symbol
<size
>*>(symtab
->lookup(this->entry_symbol_name()));
9564 this->entry_symbol_is_compressed_
= (entry
!= NULL
&& (entry
->is_mips16()
9565 || entry
->is_micromips()));
9567 if (!parameters
->doing_static_link()
9568 && (strcmp(parameters
->options().hash_style(), "gnu") == 0
9569 || strcmp(parameters
->options().hash_style(), "both") == 0))
9571 // .gnu.hash and the MIPS ABI require .dynsym to be sorted in different
9572 // ways. .gnu.hash needs symbols to be grouped by hash code whereas the
9573 // MIPS ABI requires a mapping between the GOT and the symbol table.
9574 gold_error(".gnu.hash is incompatible with the MIPS ABI");
9577 // Check whether the final section that was scanned has HI16 or GOT16
9578 // relocations without the corresponding LO16 part.
9579 if (this->got16_addends_
.size() > 0)
9580 gold_error("Can't find matching LO16 reloc");
9583 this->set_gp(layout
, symtab
);
9585 // Check for any mips16 stub sections that we can discard.
9586 if (!parameters
->options().relocatable())
9588 for (Input_objects::Relobj_iterator p
= input_objects
->relobj_begin();
9589 p
!= input_objects
->relobj_end();
9592 Mips_relobj
<size
, big_endian
>* object
=
9593 Mips_relobj
<size
, big_endian
>::as_mips_relobj(*p
);
9594 object
->discard_mips16_stub_sections(symtab
);
9598 Valtype gprmask
= 0;
9599 Valtype cprmask1
= 0;
9600 Valtype cprmask2
= 0;
9601 Valtype cprmask3
= 0;
9602 Valtype cprmask4
= 0;
9603 bool has_reginfo_section
= false;
9605 for (Input_objects::Relobj_iterator p
= input_objects
->relobj_begin();
9606 p
!= input_objects
->relobj_end();
9609 Mips_relobj
<size
, big_endian
>* relobj
=
9610 Mips_relobj
<size
, big_endian
>::as_mips_relobj(*p
);
9612 // Merge .reginfo contents of input objects.
9613 if (relobj
->has_reginfo_section())
9615 has_reginfo_section
= true;
9616 gprmask
|= relobj
->gprmask();
9617 cprmask1
|= relobj
->cprmask1();
9618 cprmask2
|= relobj
->cprmask2();
9619 cprmask3
|= relobj
->cprmask3();
9620 cprmask4
|= relobj
->cprmask4();
9623 Input_file::Format format
= relobj
->input_file()->format();
9624 if (format
!= Input_file::FORMAT_ELF
)
9627 // If all input sections will be discarded, don't use this object
9628 // file for merging processor specific flags.
9629 bool should_merge_processor_specific_flags
= false;
9631 for (unsigned int i
= 1; i
< relobj
->shnum(); ++i
)
9632 if (relobj
->output_section(i
) != NULL
)
9634 should_merge_processor_specific_flags
= true;
9638 if (!should_merge_processor_specific_flags
)
9641 // Merge processor specific flags.
9642 Mips_abiflags
<big_endian
> in_abiflags
;
9644 this->create_abiflags(relobj
, &in_abiflags
);
9645 this->merge_obj_e_flags(relobj
->name(),
9646 relobj
->processor_specific_flags());
9647 this->merge_obj_abiflags(relobj
->name(), &in_abiflags
);
9648 this->merge_obj_attributes(relobj
->name(),
9649 relobj
->attributes_section_data());
9652 // Create a .gnu.attributes section if we have merged any attributes
9654 if (this->attributes_section_data_
!= NULL
)
9656 Output_attributes_section_data
* attributes_section
=
9657 new Output_attributes_section_data(*this->attributes_section_data_
);
9658 layout
->add_output_section_data(".gnu.attributes",
9659 elfcpp::SHT_GNU_ATTRIBUTES
, 0,
9660 attributes_section
, ORDER_INVALID
, false);
9663 // Create .MIPS.abiflags output section if there is an input section.
9664 if (this->has_abiflags_section_
)
9666 Mips_output_section_abiflags
<size
, big_endian
>* abiflags_section
=
9667 new Mips_output_section_abiflags
<size
, big_endian
>(*this->abiflags_
);
9669 Output_section
* os
=
9670 layout
->add_output_section_data(".MIPS.abiflags",
9671 elfcpp::SHT_MIPS_ABIFLAGS
,
9673 abiflags_section
, ORDER_INVALID
, false);
9675 if (!parameters
->options().relocatable() && os
!= NULL
)
9677 Output_segment
* abiflags_segment
=
9678 layout
->make_output_segment(elfcpp::PT_MIPS_ABIFLAGS
, elfcpp::PF_R
);
9679 abiflags_segment
->add_output_section_to_nonload(os
, elfcpp::PF_R
);
9683 if (has_reginfo_section
&& !parameters
->options().gc_sections())
9685 // Create .reginfo output section.
9686 Mips_output_section_reginfo
<size
, big_endian
>* reginfo_section
=
9687 new Mips_output_section_reginfo
<size
, big_endian
>(this, gprmask
,
9689 cprmask3
, cprmask4
);
9691 Output_section
* os
=
9692 layout
->add_output_section_data(".reginfo", elfcpp::SHT_MIPS_REGINFO
,
9693 elfcpp::SHF_ALLOC
, reginfo_section
,
9694 ORDER_INVALID
, false);
9696 if (!parameters
->options().relocatable() && os
!= NULL
)
9698 Output_segment
* reginfo_segment
=
9699 layout
->make_output_segment(elfcpp::PT_MIPS_REGINFO
,
9701 reginfo_segment
->add_output_section_to_nonload(os
, elfcpp::PF_R
);
9705 if (this->plt_
!= NULL
)
9707 // Set final PLT offsets for symbols.
9708 this->plt_section()->set_plt_offsets();
9710 // Define _PROCEDURE_LINKAGE_TABLE_ at the start of the .plt section.
9711 // Set STO_MICROMIPS flag if the output has microMIPS code, but only if
9712 // there are no standard PLT entries present.
9713 unsigned char nonvis
= 0;
9714 if (this->is_output_micromips()
9715 && !this->plt_section()->has_standard_entries())
9716 nonvis
= elfcpp::STO_MICROMIPS
>> 2;
9717 symtab
->define_in_output_data("_PROCEDURE_LINKAGE_TABLE_", NULL
,
9718 Symbol_table::PREDEFINED
,
9720 0, 0, elfcpp::STT_FUNC
,
9722 elfcpp::STV_DEFAULT
, nonvis
,
9726 if (this->mips_stubs_
!= NULL
)
9728 // Define _MIPS_STUBS_ at the start of the .MIPS.stubs section.
9729 unsigned char nonvis
= 0;
9730 if (this->is_output_micromips())
9731 nonvis
= elfcpp::STO_MICROMIPS
>> 2;
9732 symtab
->define_in_output_data("_MIPS_STUBS_", NULL
,
9733 Symbol_table::PREDEFINED
,
9735 0, 0, elfcpp::STT_FUNC
,
9737 elfcpp::STV_DEFAULT
, nonvis
,
9741 if (!parameters
->options().relocatable() && !parameters
->doing_static_link())
9742 // In case there is no .got section, create one.
9743 this->got_section(symtab
, layout
);
9745 // Emit any relocs we saved in an attempt to avoid generating COPY
9747 if (this->copy_relocs_
.any_saved_relocs())
9748 this->copy_relocs_
.emit_mips(this->rel_dyn_section(layout
), symtab
, layout
,
9751 // Emit dynamic relocs.
9752 for (typename
std::vector
<Dyn_reloc
>::iterator p
= this->dyn_relocs_
.begin();
9753 p
!= this->dyn_relocs_
.end();
9755 p
->emit(this->rel_dyn_section(layout
), this->got_section(), symtab
);
9757 if (this->has_got_section())
9758 this->got_section()->lay_out_got(layout
, symtab
, input_objects
);
9760 if (this->mips_stubs_
!= NULL
)
9761 this->mips_stubs_
->set_needs_dynsym_value();
9763 // Check for functions that might need $25 to be valid on entry.
9764 // TODO(sasa): Can we do this without iterating over all symbols?
9765 typedef Symbol_visitor_check_symbols
<size
, big_endian
> Symbol_visitor
;
9766 symtab
->for_all_symbols
<size
, Symbol_visitor
>(Symbol_visitor(this, layout
,
9769 // Add NULL segment.
9770 if (!parameters
->options().relocatable())
9771 layout
->make_output_segment(elfcpp::PT_NULL
, 0);
9773 // Fill in some more dynamic tags.
9774 // TODO(sasa): Add more dynamic tags.
9775 const Reloc_section
* rel_plt
= (this->plt_
== NULL
9776 ? NULL
: this->plt_
->rel_plt());
9777 layout
->add_target_dynamic_tags(true, this->got_
, rel_plt
,
9778 this->rel_dyn_
, true, false);
9780 Output_data_dynamic
* const odyn
= layout
->dynamic_data();
9782 && !parameters
->options().relocatable()
9783 && !parameters
->doing_static_link())
9786 // This element holds a 32-bit version id for the Runtime
9787 // Linker Interface. This will start at integer value 1.
9789 odyn
->add_constant(elfcpp::DT_MIPS_RLD_VERSION
, d_val
);
9792 d_val
= elfcpp::RHF_NOTPOT
;
9793 odyn
->add_constant(elfcpp::DT_MIPS_FLAGS
, d_val
);
9795 // Save layout for using when emitting custom dynamic tags.
9796 this->layout_
= layout
;
9798 // This member holds the base address of the segment.
9799 odyn
->add_custom(elfcpp::DT_MIPS_BASE_ADDRESS
);
9801 // This member holds the number of entries in the .dynsym section.
9802 odyn
->add_custom(elfcpp::DT_MIPS_SYMTABNO
);
9804 // This member holds the index of the first dynamic symbol
9805 // table entry that corresponds to an entry in the global offset table.
9806 odyn
->add_custom(elfcpp::DT_MIPS_GOTSYM
);
9808 // This member holds the number of local GOT entries.
9809 odyn
->add_constant(elfcpp::DT_MIPS_LOCAL_GOTNO
,
9810 this->got_
->get_local_gotno());
9812 if (this->plt_
!= NULL
)
9813 // DT_MIPS_PLTGOT dynamic tag
9814 odyn
->add_section_address(elfcpp::DT_MIPS_PLTGOT
, this->got_plt_
);
9816 if (!parameters
->options().shared())
9818 this->rld_map_
= new Output_data_zero_fill(size
/ 8, size
/ 8);
9820 layout
->add_output_section_data(".rld_map", elfcpp::SHT_PROGBITS
,
9821 (elfcpp::SHF_ALLOC
| elfcpp::SHF_WRITE
),
9822 this->rld_map_
, ORDER_INVALID
, false);
9824 // __RLD_MAP will be filled in by the runtime loader to contain
9825 // a pointer to the _r_debug structure.
9826 Symbol
* rld_map
= symtab
->define_in_output_data("__RLD_MAP", NULL
,
9827 Symbol_table::PREDEFINED
,
9829 0, 0, elfcpp::STT_OBJECT
,
9831 elfcpp::STV_DEFAULT
, 0,
9834 if (!rld_map
->is_forced_local())
9835 rld_map
->set_needs_dynsym_entry();
9837 if (!parameters
->options().pie())
9838 // This member holds the absolute address of the debug pointer.
9839 odyn
->add_section_address(elfcpp::DT_MIPS_RLD_MAP
, this->rld_map_
);
9841 // This member holds the offset to the debug pointer,
9842 // relative to the address of the tag.
9843 odyn
->add_custom(elfcpp::DT_MIPS_RLD_MAP_REL
);
9848 // Get the custom dynamic tag value.
9849 template<int size
, bool big_endian
>
9851 Target_mips
<size
, big_endian
>::do_dynamic_tag_custom_value(elfcpp::DT tag
) const
9855 case elfcpp::DT_MIPS_BASE_ADDRESS
:
9857 // The base address of the segment.
9858 // At this point, the segment list has been sorted into final order,
9859 // so just return vaddr of the first readable PT_LOAD segment.
9860 Output_segment
* seg
=
9861 this->layout_
->find_output_segment(elfcpp::PT_LOAD
, elfcpp::PF_R
, 0);
9862 gold_assert(seg
!= NULL
);
9863 return seg
->vaddr();
9866 case elfcpp::DT_MIPS_SYMTABNO
:
9867 // The number of entries in the .dynsym section.
9868 return this->get_dt_mips_symtabno();
9870 case elfcpp::DT_MIPS_GOTSYM
:
9872 // The index of the first dynamic symbol table entry that corresponds
9873 // to an entry in the GOT.
9874 if (this->got_
->first_global_got_dynsym_index() != -1U)
9875 return this->got_
->first_global_got_dynsym_index();
9877 // In case if we don't have global GOT symbols we default to setting
9878 // DT_MIPS_GOTSYM to the same value as DT_MIPS_SYMTABNO.
9879 return this->get_dt_mips_symtabno();
9882 case elfcpp::DT_MIPS_RLD_MAP_REL
:
9884 // The MIPS_RLD_MAP_REL tag stores the offset to the debug pointer,
9885 // relative to the address of the tag.
9886 Output_data_dynamic
* const odyn
= this->layout_
->dynamic_data();
9887 unsigned int entry_offset
=
9888 odyn
->get_entry_offset(elfcpp::DT_MIPS_RLD_MAP_REL
);
9889 gold_assert(entry_offset
!= -1U);
9890 return this->rld_map_
->address() - (odyn
->address() + entry_offset
);
9893 gold_error(_("Unknown dynamic tag 0x%x"), (unsigned int)tag
);
9896 return (unsigned int)-1;
9899 // Relocate section data.
9901 template<int size
, bool big_endian
>
9903 Target_mips
<size
, big_endian
>::relocate_section(
9904 const Relocate_info
<size
, big_endian
>* relinfo
,
9905 unsigned int sh_type
,
9906 const unsigned char* prelocs
,
9908 Output_section
* output_section
,
9909 bool needs_special_offset_handling
,
9910 unsigned char* view
,
9911 Mips_address address
,
9912 section_size_type view_size
,
9913 const Reloc_symbol_changes
* reloc_symbol_changes
)
9915 typedef Target_mips
<size
, big_endian
> Mips
;
9916 typedef typename Target_mips
<size
, big_endian
>::Relocate Mips_relocate
;
9918 if (sh_type
== elfcpp::SHT_REL
)
9920 typedef Mips_classify_reloc
<elfcpp::SHT_REL
, size
, big_endian
>
9923 gold::relocate_section
<size
, big_endian
, Mips
, Mips_relocate
,
9924 gold::Default_comdat_behavior
, Classify_reloc
>(
9930 needs_special_offset_handling
,
9934 reloc_symbol_changes
);
9936 else if (sh_type
== elfcpp::SHT_RELA
)
9938 typedef Mips_classify_reloc
<elfcpp::SHT_RELA
, size
, big_endian
>
9941 gold::relocate_section
<size
, big_endian
, Mips
, Mips_relocate
,
9942 gold::Default_comdat_behavior
, Classify_reloc
>(
9948 needs_special_offset_handling
,
9952 reloc_symbol_changes
);
9956 // Return the size of a relocation while scanning during a relocatable
9960 mips_get_size_for_reloc(unsigned int r_type
, Relobj
* object
)
9964 case elfcpp::R_MIPS_NONE
:
9965 case elfcpp::R_MIPS_TLS_DTPMOD64
:
9966 case elfcpp::R_MIPS_TLS_DTPREL64
:
9967 case elfcpp::R_MIPS_TLS_TPREL64
:
9970 case elfcpp::R_MIPS_32
:
9971 case elfcpp::R_MIPS_TLS_DTPMOD32
:
9972 case elfcpp::R_MIPS_TLS_DTPREL32
:
9973 case elfcpp::R_MIPS_TLS_TPREL32
:
9974 case elfcpp::R_MIPS_REL32
:
9975 case elfcpp::R_MIPS_PC32
:
9976 case elfcpp::R_MIPS_GPREL32
:
9977 case elfcpp::R_MIPS_JALR
:
9978 case elfcpp::R_MIPS_EH
:
9981 case elfcpp::R_MIPS_16
:
9982 case elfcpp::R_MIPS_HI16
:
9983 case elfcpp::R_MIPS_LO16
:
9984 case elfcpp::R_MIPS_HIGHER
:
9985 case elfcpp::R_MIPS_HIGHEST
:
9986 case elfcpp::R_MIPS_GPREL16
:
9987 case elfcpp::R_MIPS16_HI16
:
9988 case elfcpp::R_MIPS16_LO16
:
9989 case elfcpp::R_MIPS_PC16
:
9990 case elfcpp::R_MIPS_PCHI16
:
9991 case elfcpp::R_MIPS_PCLO16
:
9992 case elfcpp::R_MIPS_GOT16
:
9993 case elfcpp::R_MIPS16_GOT16
:
9994 case elfcpp::R_MIPS_CALL16
:
9995 case elfcpp::R_MIPS16_CALL16
:
9996 case elfcpp::R_MIPS_GOT_HI16
:
9997 case elfcpp::R_MIPS_CALL_HI16
:
9998 case elfcpp::R_MIPS_GOT_LO16
:
9999 case elfcpp::R_MIPS_CALL_LO16
:
10000 case elfcpp::R_MIPS_TLS_DTPREL_HI16
:
10001 case elfcpp::R_MIPS_TLS_DTPREL_LO16
:
10002 case elfcpp::R_MIPS_TLS_TPREL_HI16
:
10003 case elfcpp::R_MIPS_TLS_TPREL_LO16
:
10004 case elfcpp::R_MIPS16_GPREL
:
10005 case elfcpp::R_MIPS_GOT_DISP
:
10006 case elfcpp::R_MIPS_LITERAL
:
10007 case elfcpp::R_MIPS_GOT_PAGE
:
10008 case elfcpp::R_MIPS_GOT_OFST
:
10009 case elfcpp::R_MIPS_TLS_GD
:
10010 case elfcpp::R_MIPS_TLS_LDM
:
10011 case elfcpp::R_MIPS_TLS_GOTTPREL
:
10014 // These relocations are not byte sized
10015 case elfcpp::R_MIPS_26
:
10016 case elfcpp::R_MIPS16_26
:
10017 case elfcpp::R_MIPS_PC21_S2
:
10018 case elfcpp::R_MIPS_PC26_S2
:
10019 case elfcpp::R_MIPS_PC18_S3
:
10020 case elfcpp::R_MIPS_PC19_S2
:
10023 case elfcpp::R_MIPS_COPY
:
10024 case elfcpp::R_MIPS_JUMP_SLOT
:
10025 object
->error(_("unexpected reloc %u in object file"), r_type
);
10029 object
->error(_("unsupported reloc %u in object file"), r_type
);
10034 // Scan the relocs during a relocatable link.
10036 template<int size
, bool big_endian
>
10038 Target_mips
<size
, big_endian
>::scan_relocatable_relocs(
10039 Symbol_table
* symtab
,
10041 Sized_relobj_file
<size
, big_endian
>* object
,
10042 unsigned int data_shndx
,
10043 unsigned int sh_type
,
10044 const unsigned char* prelocs
,
10045 size_t reloc_count
,
10046 Output_section
* output_section
,
10047 bool needs_special_offset_handling
,
10048 size_t local_symbol_count
,
10049 const unsigned char* plocal_symbols
,
10050 Relocatable_relocs
* rr
)
10052 if (sh_type
== elfcpp::SHT_REL
)
10054 typedef Mips_classify_reloc
<elfcpp::SHT_REL
, size
, big_endian
>
10056 typedef Mips_scan_relocatable_relocs
<big_endian
, Classify_reloc
>
10057 Scan_relocatable_relocs
;
10059 gold::scan_relocatable_relocs
<size
, big_endian
, Scan_relocatable_relocs
>(
10067 needs_special_offset_handling
,
10068 local_symbol_count
,
10072 else if (sh_type
== elfcpp::SHT_RELA
)
10074 typedef Mips_classify_reloc
<elfcpp::SHT_RELA
, size
, big_endian
>
10076 typedef Mips_scan_relocatable_relocs
<big_endian
, Classify_reloc
>
10077 Scan_relocatable_relocs
;
10079 gold::scan_relocatable_relocs
<size
, big_endian
, Scan_relocatable_relocs
>(
10087 needs_special_offset_handling
,
10088 local_symbol_count
,
10093 gold_unreachable();
10096 // Scan the relocs for --emit-relocs.
10098 template<int size
, bool big_endian
>
10100 Target_mips
<size
, big_endian
>::emit_relocs_scan(
10101 Symbol_table
* symtab
,
10103 Sized_relobj_file
<size
, big_endian
>* object
,
10104 unsigned int data_shndx
,
10105 unsigned int sh_type
,
10106 const unsigned char* prelocs
,
10107 size_t reloc_count
,
10108 Output_section
* output_section
,
10109 bool needs_special_offset_handling
,
10110 size_t local_symbol_count
,
10111 const unsigned char* plocal_syms
,
10112 Relocatable_relocs
* rr
)
10114 if (sh_type
== elfcpp::SHT_REL
)
10116 typedef Mips_classify_reloc
<elfcpp::SHT_REL
, size
, big_endian
>
10118 typedef gold::Default_emit_relocs_strategy
<Classify_reloc
>
10119 Emit_relocs_strategy
;
10121 gold::scan_relocatable_relocs
<size
, big_endian
, Emit_relocs_strategy
>(
10129 needs_special_offset_handling
,
10130 local_symbol_count
,
10134 else if (sh_type
== elfcpp::SHT_RELA
)
10136 typedef Mips_classify_reloc
<elfcpp::SHT_RELA
, size
, big_endian
>
10138 typedef gold::Default_emit_relocs_strategy
<Classify_reloc
>
10139 Emit_relocs_strategy
;
10141 gold::scan_relocatable_relocs
<size
, big_endian
, Emit_relocs_strategy
>(
10149 needs_special_offset_handling
,
10150 local_symbol_count
,
10155 gold_unreachable();
10158 // Emit relocations for a section.
10160 template<int size
, bool big_endian
>
10162 Target_mips
<size
, big_endian
>::relocate_relocs(
10163 const Relocate_info
<size
, big_endian
>* relinfo
,
10164 unsigned int sh_type
,
10165 const unsigned char* prelocs
,
10166 size_t reloc_count
,
10167 Output_section
* output_section
,
10168 typename
elfcpp::Elf_types
<size
>::Elf_Off
10169 offset_in_output_section
,
10170 unsigned char* view
,
10171 Mips_address view_address
,
10172 section_size_type view_size
,
10173 unsigned char* reloc_view
,
10174 section_size_type reloc_view_size
)
10176 if (sh_type
== elfcpp::SHT_REL
)
10178 typedef Mips_classify_reloc
<elfcpp::SHT_REL
, size
, big_endian
>
10181 gold::relocate_relocs
<size
, big_endian
, Classify_reloc
>(
10186 offset_in_output_section
,
10193 else if (sh_type
== elfcpp::SHT_RELA
)
10195 typedef Mips_classify_reloc
<elfcpp::SHT_RELA
, size
, big_endian
>
10198 gold::relocate_relocs
<size
, big_endian
, Classify_reloc
>(
10203 offset_in_output_section
,
10211 gold_unreachable();
10214 // Perform target-specific processing in a relocatable link. This is
10215 // only used if we use the relocation strategy RELOC_SPECIAL.
10217 template<int size
, bool big_endian
>
10219 Target_mips
<size
, big_endian
>::relocate_special_relocatable(
10220 const Relocate_info
<size
, big_endian
>* relinfo
,
10221 unsigned int sh_type
,
10222 const unsigned char* preloc_in
,
10224 Output_section
* output_section
,
10225 typename
elfcpp::Elf_types
<size
>::Elf_Off offset_in_output_section
,
10226 unsigned char* view
,
10227 Mips_address view_address
,
10229 unsigned char* preloc_out
)
10231 // We can only handle REL type relocation sections.
10232 gold_assert(sh_type
== elfcpp::SHT_REL
);
10234 typedef typename Reloc_types
<elfcpp::SHT_REL
, size
, big_endian
>::Reloc
10236 typedef typename Reloc_types
<elfcpp::SHT_REL
, size
, big_endian
>::Reloc_write
10239 typedef Mips_relocate_functions
<size
, big_endian
> Reloc_funcs
;
10241 const Mips_address invalid_address
= static_cast<Mips_address
>(0) - 1;
10243 Mips_relobj
<size
, big_endian
>* object
=
10244 Mips_relobj
<size
, big_endian
>::as_mips_relobj(relinfo
->object
);
10245 const unsigned int local_count
= object
->local_symbol_count();
10247 Reltype
reloc(preloc_in
);
10248 Reltype_write
reloc_write(preloc_out
);
10250 elfcpp::Elf_types
<32>::Elf_WXword r_info
= reloc
.get_r_info();
10251 const unsigned int r_sym
= elfcpp::elf_r_sym
<size
>(r_info
);
10252 const unsigned int r_type
= elfcpp::elf_r_type
<size
>(r_info
);
10254 // Get the new symbol index.
10255 // We only use RELOC_SPECIAL strategy in local relocations.
10256 gold_assert(r_sym
< local_count
);
10258 // We are adjusting a section symbol. We need to find
10259 // the symbol table index of the section symbol for
10260 // the output section corresponding to input section
10261 // in which this symbol is defined.
10263 unsigned int shndx
= object
->local_symbol_input_shndx(r_sym
, &is_ordinary
);
10264 gold_assert(is_ordinary
);
10265 Output_section
* os
= object
->output_section(shndx
);
10266 gold_assert(os
!= NULL
);
10267 gold_assert(os
->needs_symtab_index());
10268 unsigned int new_symndx
= os
->symtab_index();
10270 // Get the new offset--the location in the output section where
10271 // this relocation should be applied.
10273 Mips_address offset
= reloc
.get_r_offset();
10274 Mips_address new_offset
;
10275 if (offset_in_output_section
!= invalid_address
)
10276 new_offset
= offset
+ offset_in_output_section
;
10279 section_offset_type sot_offset
=
10280 convert_types
<section_offset_type
, Mips_address
>(offset
);
10281 section_offset_type new_sot_offset
=
10282 output_section
->output_offset(object
, relinfo
->data_shndx
,
10284 gold_assert(new_sot_offset
!= -1);
10285 new_offset
= new_sot_offset
;
10288 // In an object file, r_offset is an offset within the section.
10289 // In an executable or dynamic object, generated by
10290 // --emit-relocs, r_offset is an absolute address.
10291 if (!parameters
->options().relocatable())
10293 new_offset
+= view_address
;
10294 if (offset_in_output_section
!= invalid_address
)
10295 new_offset
-= offset_in_output_section
;
10298 reloc_write
.put_r_offset(new_offset
);
10299 reloc_write
.put_r_info(elfcpp::elf_r_info
<32>(new_symndx
, r_type
));
10301 // Handle the reloc addend.
10302 // The relocation uses a section symbol in the input file.
10303 // We are adjusting it to use a section symbol in the output
10304 // file. The input section symbol refers to some address in
10305 // the input section. We need the relocation in the output
10306 // file to refer to that same address. This adjustment to
10307 // the addend is the same calculation we use for a simple
10308 // absolute relocation for the input section symbol.
10309 Valtype calculated_value
= 0;
10310 const Symbol_value
<size
>* psymval
= object
->local_symbol(r_sym
);
10312 unsigned char* paddend
= view
+ offset
;
10313 typename
Reloc_funcs::Status reloc_status
= Reloc_funcs::STATUS_OKAY
;
10316 case elfcpp::R_MIPS_26
:
10317 reloc_status
= Reloc_funcs::rel26(paddend
, object
, psymval
,
10318 offset_in_output_section
, true, 0, sh_type
== elfcpp::SHT_REL
, NULL
,
10319 false /*TODO(sasa): cross mode jump*/, r_type
, this->jal_to_bal(),
10320 false, &calculated_value
);
10324 gold_unreachable();
10327 // Report any errors.
10328 switch (reloc_status
)
10330 case Reloc_funcs::STATUS_OKAY
:
10332 case Reloc_funcs::STATUS_OVERFLOW
:
10333 gold_error_at_location(relinfo
, relnum
, reloc
.get_r_offset(),
10334 _("relocation overflow"));
10336 case Reloc_funcs::STATUS_BAD_RELOC
:
10337 gold_error_at_location(relinfo
, relnum
, reloc
.get_r_offset(),
10338 _("unexpected opcode while processing relocation"));
10341 gold_unreachable();
10345 // Optimize the TLS relocation type based on what we know about the
10346 // symbol. IS_FINAL is true if the final address of this symbol is
10347 // known at link time.
10349 template<int size
, bool big_endian
>
10350 tls::Tls_optimization
10351 Target_mips
<size
, big_endian
>::optimize_tls_reloc(bool, int)
10353 // FIXME: Currently we do not do any TLS optimization.
10354 return tls::TLSOPT_NONE
;
10357 // Scan a relocation for a local symbol.
10359 template<int size
, bool big_endian
>
10361 Target_mips
<size
, big_endian
>::Scan::local(
10362 Symbol_table
* symtab
,
10364 Target_mips
<size
, big_endian
>* target
,
10365 Sized_relobj_file
<size
, big_endian
>* object
,
10366 unsigned int data_shndx
,
10367 Output_section
* output_section
,
10368 const Relatype
* rela
,
10369 const Reltype
* rel
,
10370 unsigned int rel_type
,
10371 unsigned int r_type
,
10372 const elfcpp::Sym
<size
, big_endian
>& lsym
,
10378 Mips_address r_offset
;
10379 unsigned int r_sym
;
10380 typename
elfcpp::Elf_types
<size
>::Elf_Swxword r_addend
;
10382 if (rel_type
== elfcpp::SHT_RELA
)
10384 r_offset
= rela
->get_r_offset();
10385 r_sym
= Mips_classify_reloc
<elfcpp::SHT_RELA
, size
, big_endian
>::
10387 r_addend
= rela
->get_r_addend();
10391 r_offset
= rel
->get_r_offset();
10392 r_sym
= Mips_classify_reloc
<elfcpp::SHT_REL
, size
, big_endian
>::
10397 Mips_relobj
<size
, big_endian
>* mips_obj
=
10398 Mips_relobj
<size
, big_endian
>::as_mips_relobj(object
);
10400 if (mips_obj
->is_mips16_stub_section(data_shndx
))
10402 mips_obj
->get_mips16_stub_section(data_shndx
)
10403 ->new_local_reloc_found(r_type
, r_sym
);
10406 if (r_type
== elfcpp::R_MIPS_NONE
)
10407 // R_MIPS_NONE is used in mips16 stub sections, to define the target of the
10411 if (!mips16_call_reloc(r_type
)
10412 && !mips_obj
->section_allows_mips16_refs(data_shndx
))
10413 // This reloc would need to refer to a MIPS16 hard-float stub, if
10414 // there is one. We ignore MIPS16 stub sections and .pdr section when
10415 // looking for relocs that would need to refer to MIPS16 stubs.
10416 mips_obj
->add_local_non_16bit_call(r_sym
);
10418 if (r_type
== elfcpp::R_MIPS16_26
10419 && !mips_obj
->section_allows_mips16_refs(data_shndx
))
10420 mips_obj
->add_local_16bit_call(r_sym
);
10424 case elfcpp::R_MIPS_GOT16
:
10425 case elfcpp::R_MIPS_CALL16
:
10426 case elfcpp::R_MIPS_CALL_HI16
:
10427 case elfcpp::R_MIPS_CALL_LO16
:
10428 case elfcpp::R_MIPS_GOT_HI16
:
10429 case elfcpp::R_MIPS_GOT_LO16
:
10430 case elfcpp::R_MIPS_GOT_PAGE
:
10431 case elfcpp::R_MIPS_GOT_OFST
:
10432 case elfcpp::R_MIPS_GOT_DISP
:
10433 case elfcpp::R_MIPS_TLS_GOTTPREL
:
10434 case elfcpp::R_MIPS_TLS_GD
:
10435 case elfcpp::R_MIPS_TLS_LDM
:
10436 case elfcpp::R_MIPS16_GOT16
:
10437 case elfcpp::R_MIPS16_CALL16
:
10438 case elfcpp::R_MIPS16_TLS_GOTTPREL
:
10439 case elfcpp::R_MIPS16_TLS_GD
:
10440 case elfcpp::R_MIPS16_TLS_LDM
:
10441 case elfcpp::R_MICROMIPS_GOT16
:
10442 case elfcpp::R_MICROMIPS_CALL16
:
10443 case elfcpp::R_MICROMIPS_CALL_HI16
:
10444 case elfcpp::R_MICROMIPS_CALL_LO16
:
10445 case elfcpp::R_MICROMIPS_GOT_HI16
:
10446 case elfcpp::R_MICROMIPS_GOT_LO16
:
10447 case elfcpp::R_MICROMIPS_GOT_PAGE
:
10448 case elfcpp::R_MICROMIPS_GOT_OFST
:
10449 case elfcpp::R_MICROMIPS_GOT_DISP
:
10450 case elfcpp::R_MICROMIPS_TLS_GOTTPREL
:
10451 case elfcpp::R_MICROMIPS_TLS_GD
:
10452 case elfcpp::R_MICROMIPS_TLS_LDM
:
10453 case elfcpp::R_MIPS_EH
:
10454 // We need a GOT section.
10455 target
->got_section(symtab
, layout
);
10462 if (call_lo16_reloc(r_type
)
10463 || got_lo16_reloc(r_type
)
10464 || got_disp_reloc(r_type
)
10465 || eh_reloc(r_type
))
10467 // We may need a local GOT entry for this relocation. We
10468 // don't count R_MIPS_GOT_PAGE because we can estimate the
10469 // maximum number of pages needed by looking at the size of
10470 // the segment. Similar comments apply to R_MIPS*_GOT16 and
10471 // R_MIPS*_CALL16. We don't count R_MIPS_GOT_HI16, or
10472 // R_MIPS_CALL_HI16 because these are always followed by an
10473 // R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16.
10474 Mips_output_data_got
<size
, big_endian
>* got
=
10475 target
->got_section(symtab
, layout
);
10476 bool is_section_symbol
= lsym
.get_st_type() == elfcpp::STT_SECTION
;
10477 got
->record_local_got_symbol(mips_obj
, r_sym
, r_addend
, r_type
, -1U,
10478 is_section_symbol
);
10483 case elfcpp::R_MIPS_CALL16
:
10484 case elfcpp::R_MIPS16_CALL16
:
10485 case elfcpp::R_MICROMIPS_CALL16
:
10486 gold_error(_("CALL16 reloc at 0x%lx not against global symbol "),
10487 (unsigned long)r_offset
);
10490 case elfcpp::R_MIPS_GOT_PAGE
:
10491 case elfcpp::R_MICROMIPS_GOT_PAGE
:
10492 case elfcpp::R_MIPS16_GOT16
:
10493 case elfcpp::R_MIPS_GOT16
:
10494 case elfcpp::R_MIPS_GOT_HI16
:
10495 case elfcpp::R_MIPS_GOT_LO16
:
10496 case elfcpp::R_MICROMIPS_GOT16
:
10497 case elfcpp::R_MICROMIPS_GOT_HI16
:
10498 case elfcpp::R_MICROMIPS_GOT_LO16
:
10500 // This relocation needs a page entry in the GOT.
10501 // Get the section contents.
10502 section_size_type view_size
= 0;
10503 const unsigned char* view
= object
->section_contents(data_shndx
,
10504 &view_size
, false);
10507 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(view
);
10508 Valtype32 addend
= (rel_type
== elfcpp::SHT_REL
? val
& 0xffff
10511 if (rel_type
== elfcpp::SHT_REL
&& got16_reloc(r_type
))
10512 target
->got16_addends_
.push_back(got16_addend
<size
, big_endian
>(
10513 object
, data_shndx
, r_type
, r_sym
, addend
));
10515 target
->got_section()->record_got_page_entry(mips_obj
, r_sym
, addend
);
10519 case elfcpp::R_MIPS_HI16
:
10520 case elfcpp::R_MIPS_PCHI16
:
10521 case elfcpp::R_MIPS16_HI16
:
10522 case elfcpp::R_MICROMIPS_HI16
:
10523 // Record the reloc so that we can check whether the corresponding LO16
10525 if (rel_type
== elfcpp::SHT_REL
)
10526 target
->got16_addends_
.push_back(got16_addend
<size
, big_endian
>(
10527 object
, data_shndx
, r_type
, r_sym
, 0));
10530 case elfcpp::R_MIPS_LO16
:
10531 case elfcpp::R_MIPS_PCLO16
:
10532 case elfcpp::R_MIPS16_LO16
:
10533 case elfcpp::R_MICROMIPS_LO16
:
10535 if (rel_type
!= elfcpp::SHT_REL
)
10538 // Find corresponding GOT16/HI16 relocation.
10540 // According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must
10541 // be immediately following. However, for the IRIX6 ABI, the next
10542 // relocation may be a composed relocation consisting of several
10543 // relocations for the same address. In that case, the R_MIPS_LO16
10544 // relocation may occur as one of these. We permit a similar
10545 // extension in general, as that is useful for GCC.
10547 // In some cases GCC dead code elimination removes the LO16 but
10548 // keeps the corresponding HI16. This is strictly speaking a
10549 // violation of the ABI but not immediately harmful.
10551 typename
std::list
<got16_addend
<size
, big_endian
> >::iterator it
=
10552 target
->got16_addends_
.begin();
10553 while (it
!= target
->got16_addends_
.end())
10555 got16_addend
<size
, big_endian
> _got16_addend
= *it
;
10557 // TODO(sasa): Split got16_addends_ list into two lists - one for
10558 // GOT16 relocs and the other for HI16 relocs.
10560 // Report an error if we find HI16 or GOT16 reloc from the
10561 // previous section without the matching LO16 part.
10562 if (_got16_addend
.object
!= object
10563 || _got16_addend
.shndx
!= data_shndx
)
10565 gold_error("Can't find matching LO16 reloc");
10569 if (_got16_addend
.r_sym
!= r_sym
10570 || !is_matching_lo16_reloc(_got16_addend
.r_type
, r_type
))
10576 // We found a matching HI16 or GOT16 reloc for this LO16 reloc.
10577 // For GOT16, we need to calculate combined addend and record GOT page
10579 if (got16_reloc(_got16_addend
.r_type
))
10582 section_size_type view_size
= 0;
10583 const unsigned char* view
= object
->section_contents(data_shndx
,
10588 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(view
);
10589 int32_t addend
= Bits
<16>::sign_extend32(val
& 0xffff);
10591 addend
= (_got16_addend
.addend
<< 16) + addend
;
10592 target
->got_section()->record_got_page_entry(mips_obj
, r_sym
,
10596 it
= target
->got16_addends_
.erase(it
);
10604 case elfcpp::R_MIPS_32
:
10605 case elfcpp::R_MIPS_REL32
:
10606 case elfcpp::R_MIPS_64
:
10608 if (parameters
->options().output_is_position_independent())
10610 // If building a shared library (or a position-independent
10611 // executable), we need to create a dynamic relocation for
10613 if (is_readonly_section(output_section
))
10615 Reloc_section
* rel_dyn
= target
->rel_dyn_section(layout
);
10616 rel_dyn
->add_symbolless_local_addend(object
, r_sym
,
10617 elfcpp::R_MIPS_REL32
,
10618 output_section
, data_shndx
,
10624 case elfcpp::R_MIPS_TLS_GOTTPREL
:
10625 case elfcpp::R_MIPS16_TLS_GOTTPREL
:
10626 case elfcpp::R_MICROMIPS_TLS_GOTTPREL
:
10627 case elfcpp::R_MIPS_TLS_LDM
:
10628 case elfcpp::R_MIPS16_TLS_LDM
:
10629 case elfcpp::R_MICROMIPS_TLS_LDM
:
10630 case elfcpp::R_MIPS_TLS_GD
:
10631 case elfcpp::R_MIPS16_TLS_GD
:
10632 case elfcpp::R_MICROMIPS_TLS_GD
:
10634 bool output_is_shared
= parameters
->options().shared();
10635 const tls::Tls_optimization optimized_type
10636 = Target_mips
<size
, big_endian
>::optimize_tls_reloc(
10637 !output_is_shared
, r_type
);
10640 case elfcpp::R_MIPS_TLS_GD
:
10641 case elfcpp::R_MIPS16_TLS_GD
:
10642 case elfcpp::R_MICROMIPS_TLS_GD
:
10643 if (optimized_type
== tls::TLSOPT_NONE
)
10645 // Create a pair of GOT entries for the module index and
10646 // dtv-relative offset.
10647 Mips_output_data_got
<size
, big_endian
>* got
=
10648 target
->got_section(symtab
, layout
);
10649 unsigned int shndx
= lsym
.get_st_shndx();
10651 shndx
= object
->adjust_sym_shndx(r_sym
, shndx
, &is_ordinary
);
10654 object
->error(_("local symbol %u has bad shndx %u"),
10658 got
->record_local_got_symbol(mips_obj
, r_sym
, r_addend
, r_type
,
10663 // FIXME: TLS optimization not supported yet.
10664 gold_unreachable();
10668 case elfcpp::R_MIPS_TLS_LDM
:
10669 case elfcpp::R_MIPS16_TLS_LDM
:
10670 case elfcpp::R_MICROMIPS_TLS_LDM
:
10671 if (optimized_type
== tls::TLSOPT_NONE
)
10673 // We always record LDM symbols as local with index 0.
10674 target
->got_section()->record_local_got_symbol(mips_obj
, 0,
10680 // FIXME: TLS optimization not supported yet.
10681 gold_unreachable();
10684 case elfcpp::R_MIPS_TLS_GOTTPREL
:
10685 case elfcpp::R_MIPS16_TLS_GOTTPREL
:
10686 case elfcpp::R_MICROMIPS_TLS_GOTTPREL
:
10687 layout
->set_has_static_tls();
10688 if (optimized_type
== tls::TLSOPT_NONE
)
10690 // Create a GOT entry for the tp-relative offset.
10691 Mips_output_data_got
<size
, big_endian
>* got
=
10692 target
->got_section(symtab
, layout
);
10693 got
->record_local_got_symbol(mips_obj
, r_sym
, r_addend
, r_type
,
10698 // FIXME: TLS optimization not supported yet.
10699 gold_unreachable();
10704 gold_unreachable();
10713 // Refuse some position-dependent relocations when creating a
10714 // shared library. Do not refuse R_MIPS_32 / R_MIPS_64; they're
10715 // not PIC, but we can create dynamic relocations and the result
10716 // will be fine. Also do not refuse R_MIPS_LO16, which can be
10717 // combined with R_MIPS_GOT16.
10718 if (parameters
->options().shared())
10722 case elfcpp::R_MIPS16_HI16
:
10723 case elfcpp::R_MIPS_HI16
:
10724 case elfcpp::R_MIPS_HIGHER
:
10725 case elfcpp::R_MIPS_HIGHEST
:
10726 case elfcpp::R_MICROMIPS_HI16
:
10727 case elfcpp::R_MICROMIPS_HIGHER
:
10728 case elfcpp::R_MICROMIPS_HIGHEST
:
10729 // Don't refuse a high part relocation if it's against
10730 // no symbol (e.g. part of a compound relocation).
10735 case elfcpp::R_MIPS16_26
:
10736 case elfcpp::R_MIPS_26
:
10737 case elfcpp::R_MICROMIPS_26_S1
:
10738 gold_error(_("%s: relocation %u against `%s' can not be used when "
10739 "making a shared object; recompile with -fPIC"),
10740 object
->name().c_str(), r_type
, "a local symbol");
10747 template<int size
, bool big_endian
>
10749 Target_mips
<size
, big_endian
>::Scan::local(
10750 Symbol_table
* symtab
,
10752 Target_mips
<size
, big_endian
>* target
,
10753 Sized_relobj_file
<size
, big_endian
>* object
,
10754 unsigned int data_shndx
,
10755 Output_section
* output_section
,
10756 const Reltype
& reloc
,
10757 unsigned int r_type
,
10758 const elfcpp::Sym
<size
, big_endian
>& lsym
,
10771 (const Relatype
*) NULL
,
10775 lsym
, is_discarded
);
10779 template<int size
, bool big_endian
>
10781 Target_mips
<size
, big_endian
>::Scan::local(
10782 Symbol_table
* symtab
,
10784 Target_mips
<size
, big_endian
>* target
,
10785 Sized_relobj_file
<size
, big_endian
>* object
,
10786 unsigned int data_shndx
,
10787 Output_section
* output_section
,
10788 const Relatype
& reloc
,
10789 unsigned int r_type
,
10790 const elfcpp::Sym
<size
, big_endian
>& lsym
,
10804 (const Reltype
*) NULL
,
10807 lsym
, is_discarded
);
10810 // Scan a relocation for a global symbol.
10812 template<int size
, bool big_endian
>
10814 Target_mips
<size
, big_endian
>::Scan::global(
10815 Symbol_table
* symtab
,
10817 Target_mips
<size
, big_endian
>* target
,
10818 Sized_relobj_file
<size
, big_endian
>* object
,
10819 unsigned int data_shndx
,
10820 Output_section
* output_section
,
10821 const Relatype
* rela
,
10822 const Reltype
* rel
,
10823 unsigned int rel_type
,
10824 unsigned int r_type
,
10827 Mips_address r_offset
;
10828 unsigned int r_sym
;
10829 typename
elfcpp::Elf_types
<size
>::Elf_Swxword r_addend
;
10831 if (rel_type
== elfcpp::SHT_RELA
)
10833 r_offset
= rela
->get_r_offset();
10834 r_sym
= Mips_classify_reloc
<elfcpp::SHT_RELA
, size
, big_endian
>::
10836 r_addend
= rela
->get_r_addend();
10840 r_offset
= rel
->get_r_offset();
10841 r_sym
= Mips_classify_reloc
<elfcpp::SHT_REL
, size
, big_endian
>::
10846 Mips_relobj
<size
, big_endian
>* mips_obj
=
10847 Mips_relobj
<size
, big_endian
>::as_mips_relobj(object
);
10848 Mips_symbol
<size
>* mips_sym
= Mips_symbol
<size
>::as_mips_sym(gsym
);
10850 if (mips_obj
->is_mips16_stub_section(data_shndx
))
10852 mips_obj
->get_mips16_stub_section(data_shndx
)
10853 ->new_global_reloc_found(r_type
, mips_sym
);
10856 if (r_type
== elfcpp::R_MIPS_NONE
)
10857 // R_MIPS_NONE is used in mips16 stub sections, to define the target of the
10861 if (!mips16_call_reloc(r_type
)
10862 && !mips_obj
->section_allows_mips16_refs(data_shndx
))
10863 // This reloc would need to refer to a MIPS16 hard-float stub, if
10864 // there is one. We ignore MIPS16 stub sections and .pdr section when
10865 // looking for relocs that would need to refer to MIPS16 stubs.
10866 mips_sym
->set_need_fn_stub();
10868 // A reference to _GLOBAL_OFFSET_TABLE_ implies that we need a got
10869 // section. We check here to avoid creating a dynamic reloc against
10870 // _GLOBAL_OFFSET_TABLE_.
10871 if (!target
->has_got_section()
10872 && strcmp(gsym
->name(), "_GLOBAL_OFFSET_TABLE_") == 0)
10873 target
->got_section(symtab
, layout
);
10875 // We need PLT entries if there are static-only relocations against
10876 // an externally-defined function. This can technically occur for
10877 // shared libraries if there are branches to the symbol, although it
10878 // is unlikely that this will be used in practice due to the short
10879 // ranges involved. It can occur for any relative or absolute relocation
10880 // in executables; in that case, the PLT entry becomes the function's
10881 // canonical address.
10882 bool static_reloc
= false;
10884 // Set CAN_MAKE_DYNAMIC to true if we can convert this
10885 // relocation into a dynamic one.
10886 bool can_make_dynamic
= false;
10889 case elfcpp::R_MIPS_GOT16
:
10890 case elfcpp::R_MIPS_CALL16
:
10891 case elfcpp::R_MIPS_CALL_HI16
:
10892 case elfcpp::R_MIPS_CALL_LO16
:
10893 case elfcpp::R_MIPS_GOT_HI16
:
10894 case elfcpp::R_MIPS_GOT_LO16
:
10895 case elfcpp::R_MIPS_GOT_PAGE
:
10896 case elfcpp::R_MIPS_GOT_OFST
:
10897 case elfcpp::R_MIPS_GOT_DISP
:
10898 case elfcpp::R_MIPS_TLS_GOTTPREL
:
10899 case elfcpp::R_MIPS_TLS_GD
:
10900 case elfcpp::R_MIPS_TLS_LDM
:
10901 case elfcpp::R_MIPS16_GOT16
:
10902 case elfcpp::R_MIPS16_CALL16
:
10903 case elfcpp::R_MIPS16_TLS_GOTTPREL
:
10904 case elfcpp::R_MIPS16_TLS_GD
:
10905 case elfcpp::R_MIPS16_TLS_LDM
:
10906 case elfcpp::R_MICROMIPS_GOT16
:
10907 case elfcpp::R_MICROMIPS_CALL16
:
10908 case elfcpp::R_MICROMIPS_CALL_HI16
:
10909 case elfcpp::R_MICROMIPS_CALL_LO16
:
10910 case elfcpp::R_MICROMIPS_GOT_HI16
:
10911 case elfcpp::R_MICROMIPS_GOT_LO16
:
10912 case elfcpp::R_MICROMIPS_GOT_PAGE
:
10913 case elfcpp::R_MICROMIPS_GOT_OFST
:
10914 case elfcpp::R_MICROMIPS_GOT_DISP
:
10915 case elfcpp::R_MICROMIPS_TLS_GOTTPREL
:
10916 case elfcpp::R_MICROMIPS_TLS_GD
:
10917 case elfcpp::R_MICROMIPS_TLS_LDM
:
10918 case elfcpp::R_MIPS_EH
:
10919 // We need a GOT section.
10920 target
->got_section(symtab
, layout
);
10923 // This is just a hint; it can safely be ignored. Don't set
10924 // has_static_relocs for the corresponding symbol.
10925 case elfcpp::R_MIPS_JALR
:
10926 case elfcpp::R_MICROMIPS_JALR
:
10929 case elfcpp::R_MIPS_GPREL16
:
10930 case elfcpp::R_MIPS_GPREL32
:
10931 case elfcpp::R_MIPS16_GPREL
:
10932 case elfcpp::R_MICROMIPS_GPREL16
:
10934 // GP-relative relocations always resolve to a definition in a
10935 // regular input file, ignoring the one-definition rule. This is
10936 // important for the GP setup sequence in NewABI code, which
10937 // always resolves to a local function even if other relocations
10938 // against the symbol wouldn't.
10939 //constrain_symbol_p = FALSE;
10942 case elfcpp::R_MIPS_32
:
10943 case elfcpp::R_MIPS_REL32
:
10944 case elfcpp::R_MIPS_64
:
10945 if ((parameters
->options().shared()
10946 || (strcmp(gsym
->name(), "__gnu_local_gp") != 0
10947 && (!is_readonly_section(output_section
)
10948 || mips_obj
->is_pic())))
10949 && (output_section
->flags() & elfcpp::SHF_ALLOC
) != 0)
10951 if (r_type
!= elfcpp::R_MIPS_REL32
)
10952 mips_sym
->set_pointer_equality_needed();
10953 can_make_dynamic
= true;
10959 // Most static relocations require pointer equality, except
10961 mips_sym
->set_pointer_equality_needed();
10964 case elfcpp::R_MIPS_26
:
10965 case elfcpp::R_MIPS_PC16
:
10966 case elfcpp::R_MIPS_PC21_S2
:
10967 case elfcpp::R_MIPS_PC26_S2
:
10968 case elfcpp::R_MIPS16_26
:
10969 case elfcpp::R_MICROMIPS_26_S1
:
10970 case elfcpp::R_MICROMIPS_PC7_S1
:
10971 case elfcpp::R_MICROMIPS_PC10_S1
:
10972 case elfcpp::R_MICROMIPS_PC16_S1
:
10973 case elfcpp::R_MICROMIPS_PC23_S2
:
10974 static_reloc
= true;
10975 mips_sym
->set_has_static_relocs();
10979 // If there are call relocations against an externally-defined symbol,
10980 // see whether we can create a MIPS lazy-binding stub for it. We can
10981 // only do this if all references to the function are through call
10982 // relocations, and in that case, the traditional lazy-binding stubs
10983 // are much more efficient than PLT entries.
10986 case elfcpp::R_MIPS16_CALL16
:
10987 case elfcpp::R_MIPS_CALL16
:
10988 case elfcpp::R_MIPS_CALL_HI16
:
10989 case elfcpp::R_MIPS_CALL_LO16
:
10990 case elfcpp::R_MIPS_JALR
:
10991 case elfcpp::R_MICROMIPS_CALL16
:
10992 case elfcpp::R_MICROMIPS_CALL_HI16
:
10993 case elfcpp::R_MICROMIPS_CALL_LO16
:
10994 case elfcpp::R_MICROMIPS_JALR
:
10995 if (!mips_sym
->no_lazy_stub())
10997 if ((mips_sym
->needs_plt_entry() && mips_sym
->is_from_dynobj())
10998 // Calls from shared objects to undefined symbols of type
10999 // STT_NOTYPE need lazy-binding stub.
11000 || (mips_sym
->is_undefined() && parameters
->options().shared()))
11001 target
->mips_stubs_section(layout
)->make_entry(mips_sym
);
11006 // We must not create a stub for a symbol that has relocations
11007 // related to taking the function's address.
11008 mips_sym
->set_no_lazy_stub();
11009 target
->remove_lazy_stub_entry(mips_sym
);
11014 if (relocation_needs_la25_stub
<size
, big_endian
>(mips_obj
, r_type
,
11015 mips_sym
->is_mips16()))
11016 mips_sym
->set_has_nonpic_branches();
11018 // R_MIPS_HI16 against _gp_disp is used for $gp setup,
11019 // and has a special meaning.
11020 bool gp_disp_against_hi16
= (!mips_obj
->is_newabi()
11021 && strcmp(gsym
->name(), "_gp_disp") == 0
11022 && (hi16_reloc(r_type
) || lo16_reloc(r_type
)));
11023 if (static_reloc
&& gsym
->needs_plt_entry())
11025 target
->make_plt_entry(symtab
, layout
, mips_sym
, r_type
);
11027 // Since this is not a PC-relative relocation, we may be
11028 // taking the address of a function. In that case we need to
11029 // set the entry in the dynamic symbol table to the address of
11031 if (gsym
->is_from_dynobj() && !parameters
->options().shared())
11033 gsym
->set_needs_dynsym_value();
11034 // We distinguish between PLT entries and lazy-binding stubs by
11035 // giving the former an st_other value of STO_MIPS_PLT. Set the
11036 // flag if there are any relocations in the binary where pointer
11037 // equality matters.
11038 if (mips_sym
->pointer_equality_needed())
11039 mips_sym
->set_mips_plt();
11042 if ((static_reloc
|| can_make_dynamic
) && !gp_disp_against_hi16
)
11044 // Absolute addressing relocations.
11045 // Make a dynamic relocation if necessary.
11046 if (gsym
->needs_dynamic_reloc(Scan::get_reference_flags(r_type
)))
11048 if (gsym
->may_need_copy_reloc())
11050 target
->copy_reloc(symtab
, layout
, object
, data_shndx
,
11051 output_section
, gsym
, r_type
, r_offset
);
11053 else if (can_make_dynamic
)
11055 // Create .rel.dyn section.
11056 target
->rel_dyn_section(layout
);
11057 target
->dynamic_reloc(mips_sym
, elfcpp::R_MIPS_REL32
, mips_obj
,
11058 data_shndx
, output_section
, r_offset
);
11061 gold_error(_("non-dynamic relocations refer to dynamic symbol %s"),
11066 bool for_call
= false;
11069 case elfcpp::R_MIPS_CALL16
:
11070 case elfcpp::R_MIPS16_CALL16
:
11071 case elfcpp::R_MICROMIPS_CALL16
:
11072 case elfcpp::R_MIPS_CALL_HI16
:
11073 case elfcpp::R_MIPS_CALL_LO16
:
11074 case elfcpp::R_MICROMIPS_CALL_HI16
:
11075 case elfcpp::R_MICROMIPS_CALL_LO16
:
11079 case elfcpp::R_MIPS16_GOT16
:
11080 case elfcpp::R_MIPS_GOT16
:
11081 case elfcpp::R_MIPS_GOT_HI16
:
11082 case elfcpp::R_MIPS_GOT_LO16
:
11083 case elfcpp::R_MICROMIPS_GOT16
:
11084 case elfcpp::R_MICROMIPS_GOT_HI16
:
11085 case elfcpp::R_MICROMIPS_GOT_LO16
:
11086 case elfcpp::R_MIPS_GOT_DISP
:
11087 case elfcpp::R_MICROMIPS_GOT_DISP
:
11088 case elfcpp::R_MIPS_EH
:
11090 // The symbol requires a GOT entry.
11091 Mips_output_data_got
<size
, big_endian
>* got
=
11092 target
->got_section(symtab
, layout
);
11093 got
->record_global_got_symbol(mips_sym
, mips_obj
, r_type
, false,
11095 mips_sym
->set_global_got_area(GGA_NORMAL
);
11099 case elfcpp::R_MIPS_GOT_PAGE
:
11100 case elfcpp::R_MICROMIPS_GOT_PAGE
:
11102 // This relocation needs a page entry in the GOT.
11103 // Get the section contents.
11104 section_size_type view_size
= 0;
11105 const unsigned char* view
=
11106 object
->section_contents(data_shndx
, &view_size
, false);
11109 Valtype32 val
= elfcpp::Swap
<32, big_endian
>::readval(view
);
11110 Valtype32 addend
= (rel_type
== elfcpp::SHT_REL
? val
& 0xffff
11112 Mips_output_data_got
<size
, big_endian
>* got
=
11113 target
->got_section(symtab
, layout
);
11114 got
->record_got_page_entry(mips_obj
, r_sym
, addend
);
11116 // If this is a global, overridable symbol, GOT_PAGE will
11117 // decay to GOT_DISP, so we'll need a GOT entry for it.
11118 bool def_regular
= (mips_sym
->source() == Symbol::FROM_OBJECT
11119 && !mips_sym
->object()->is_dynamic()
11120 && !mips_sym
->is_undefined());
11122 || (parameters
->options().output_is_position_independent()
11123 && !parameters
->options().Bsymbolic()
11124 && !mips_sym
->is_forced_local()))
11126 got
->record_global_got_symbol(mips_sym
, mips_obj
, r_type
, false,
11128 mips_sym
->set_global_got_area(GGA_NORMAL
);
11133 case elfcpp::R_MIPS_TLS_GOTTPREL
:
11134 case elfcpp::R_MIPS16_TLS_GOTTPREL
:
11135 case elfcpp::R_MICROMIPS_TLS_GOTTPREL
:
11136 case elfcpp::R_MIPS_TLS_LDM
:
11137 case elfcpp::R_MIPS16_TLS_LDM
:
11138 case elfcpp::R_MICROMIPS_TLS_LDM
:
11139 case elfcpp::R_MIPS_TLS_GD
:
11140 case elfcpp::R_MIPS16_TLS_GD
:
11141 case elfcpp::R_MICROMIPS_TLS_GD
:
11143 const bool is_final
= gsym
->final_value_is_known();
11144 const tls::Tls_optimization optimized_type
=
11145 Target_mips
<size
, big_endian
>::optimize_tls_reloc(is_final
, r_type
);
11149 case elfcpp::R_MIPS_TLS_GD
:
11150 case elfcpp::R_MIPS16_TLS_GD
:
11151 case elfcpp::R_MICROMIPS_TLS_GD
:
11152 if (optimized_type
== tls::TLSOPT_NONE
)
11154 // Create a pair of GOT entries for the module index and
11155 // dtv-relative offset.
11156 Mips_output_data_got
<size
, big_endian
>* got
=
11157 target
->got_section(symtab
, layout
);
11158 got
->record_global_got_symbol(mips_sym
, mips_obj
, r_type
, false,
11163 // FIXME: TLS optimization not supported yet.
11164 gold_unreachable();
11168 case elfcpp::R_MIPS_TLS_LDM
:
11169 case elfcpp::R_MIPS16_TLS_LDM
:
11170 case elfcpp::R_MICROMIPS_TLS_LDM
:
11171 if (optimized_type
== tls::TLSOPT_NONE
)
11173 // We always record LDM symbols as local with index 0.
11174 target
->got_section()->record_local_got_symbol(mips_obj
, 0,
11180 // FIXME: TLS optimization not supported yet.
11181 gold_unreachable();
11184 case elfcpp::R_MIPS_TLS_GOTTPREL
:
11185 case elfcpp::R_MIPS16_TLS_GOTTPREL
:
11186 case elfcpp::R_MICROMIPS_TLS_GOTTPREL
:
11187 layout
->set_has_static_tls();
11188 if (optimized_type
== tls::TLSOPT_NONE
)
11190 // Create a GOT entry for the tp-relative offset.
11191 Mips_output_data_got
<size
, big_endian
>* got
=
11192 target
->got_section(symtab
, layout
);
11193 got
->record_global_got_symbol(mips_sym
, mips_obj
, r_type
, false,
11198 // FIXME: TLS optimization not supported yet.
11199 gold_unreachable();
11204 gold_unreachable();
11208 case elfcpp::R_MIPS_COPY
:
11209 case elfcpp::R_MIPS_JUMP_SLOT
:
11210 // These are relocations which should only be seen by the
11211 // dynamic linker, and should never be seen here.
11212 gold_error(_("%s: unexpected reloc %u in object file"),
11213 object
->name().c_str(), r_type
);
11220 // Refuse some position-dependent relocations when creating a
11221 // shared library. Do not refuse R_MIPS_32 / R_MIPS_64; they're
11222 // not PIC, but we can create dynamic relocations and the result
11223 // will be fine. Also do not refuse R_MIPS_LO16, which can be
11224 // combined with R_MIPS_GOT16.
11225 if (parameters
->options().shared())
11229 case elfcpp::R_MIPS16_HI16
:
11230 case elfcpp::R_MIPS_HI16
:
11231 case elfcpp::R_MIPS_HIGHER
:
11232 case elfcpp::R_MIPS_HIGHEST
:
11233 case elfcpp::R_MICROMIPS_HI16
:
11234 case elfcpp::R_MICROMIPS_HIGHER
:
11235 case elfcpp::R_MICROMIPS_HIGHEST
:
11236 // Don't refuse a high part relocation if it's against
11237 // no symbol (e.g. part of a compound relocation).
11241 // R_MIPS_HI16 against _gp_disp is used for $gp setup,
11242 // and has a special meaning.
11243 if (!mips_obj
->is_newabi() && strcmp(gsym
->name(), "_gp_disp") == 0)
11247 case elfcpp::R_MIPS16_26
:
11248 case elfcpp::R_MIPS_26
:
11249 case elfcpp::R_MICROMIPS_26_S1
:
11250 gold_error(_("%s: relocation %u against `%s' can not be used when "
11251 "making a shared object; recompile with -fPIC"),
11252 object
->name().c_str(), r_type
, gsym
->name());
11259 template<int size
, bool big_endian
>
11261 Target_mips
<size
, big_endian
>::Scan::global(
11262 Symbol_table
* symtab
,
11264 Target_mips
<size
, big_endian
>* target
,
11265 Sized_relobj_file
<size
, big_endian
>* object
,
11266 unsigned int data_shndx
,
11267 Output_section
* output_section
,
11268 const Relatype
& reloc
,
11269 unsigned int r_type
,
11280 (const Reltype
*) NULL
,
11286 template<int size
, bool big_endian
>
11288 Target_mips
<size
, big_endian
>::Scan::global(
11289 Symbol_table
* symtab
,
11291 Target_mips
<size
, big_endian
>* target
,
11292 Sized_relobj_file
<size
, big_endian
>* object
,
11293 unsigned int data_shndx
,
11294 Output_section
* output_section
,
11295 const Reltype
& reloc
,
11296 unsigned int r_type
,
11306 (const Relatype
*) NULL
,
11313 // Return whether a R_MIPS_32/R_MIPS64 relocation needs to be applied.
11314 // In cases where Scan::local() or Scan::global() has created
11315 // a dynamic relocation, the addend of the relocation is carried
11316 // in the data, and we must not apply the static relocation.
11318 template<int size
, bool big_endian
>
11320 Target_mips
<size
, big_endian
>::Relocate::should_apply_static_reloc(
11321 const Mips_symbol
<size
>* gsym
,
11322 unsigned int r_type
,
11323 Output_section
* output_section
,
11324 Target_mips
* target
)
11326 // If the output section is not allocated, then we didn't call
11327 // scan_relocs, we didn't create a dynamic reloc, and we must apply
11329 if ((output_section
->flags() & elfcpp::SHF_ALLOC
) == 0)
11336 // For global symbols, we use the same helper routines used in the
11338 if (gsym
->needs_dynamic_reloc(Scan::get_reference_flags(r_type
))
11339 && !gsym
->may_need_copy_reloc())
11341 // We have generated dynamic reloc (R_MIPS_REL32).
11343 bool multi_got
= false;
11344 if (target
->has_got_section())
11345 multi_got
= target
->got_section()->multi_got();
11346 bool has_got_offset
;
11348 has_got_offset
= gsym
->has_got_offset(GOT_TYPE_STANDARD
);
11350 has_got_offset
= gsym
->global_gotoffset() != -1U;
11351 if (!has_got_offset
)
11354 // Apply the relocation only if the symbol is in the local got.
11355 // Do not apply the relocation if the symbol is in the global
11357 return symbol_references_local(gsym
, gsym
->has_dynsym_index());
11360 // We have not generated dynamic reloc.
11365 // Perform a relocation.
11367 template<int size
, bool big_endian
>
11369 Target_mips
<size
, big_endian
>::Relocate::relocate(
11370 const Relocate_info
<size
, big_endian
>* relinfo
,
11371 unsigned int rel_type
,
11372 Target_mips
* target
,
11373 Output_section
* output_section
,
11375 const unsigned char* preloc
,
11376 const Sized_symbol
<size
>* gsym
,
11377 const Symbol_value
<size
>* psymval
,
11378 unsigned char* view
,
11379 Mips_address address
,
11382 Mips_address r_offset
;
11383 unsigned int r_sym
;
11384 unsigned int r_type
;
11385 unsigned int r_type2
;
11386 unsigned int r_type3
;
11387 unsigned char r_ssym
;
11388 typename
elfcpp::Elf_types
<size
>::Elf_Swxword r_addend
;
11390 if (rel_type
== elfcpp::SHT_RELA
)
11392 const Relatype
rela(preloc
);
11393 r_offset
= rela
.get_r_offset();
11394 r_sym
= Mips_classify_reloc
<elfcpp::SHT_RELA
, size
, big_endian
>::
11396 r_type
= Mips_classify_reloc
<elfcpp::SHT_RELA
, size
, big_endian
>::
11398 r_type2
= Mips_classify_reloc
<elfcpp::SHT_RELA
, size
, big_endian
>::
11399 get_r_type2(&rela
);
11400 r_type3
= Mips_classify_reloc
<elfcpp::SHT_RELA
, size
, big_endian
>::
11401 get_r_type3(&rela
);
11402 r_ssym
= Mips_classify_reloc
<elfcpp::SHT_RELA
, size
, big_endian
>::
11404 r_addend
= rela
.get_r_addend();
11408 const Reltype
rel(preloc
);
11409 r_offset
= rel
.get_r_offset();
11410 r_sym
= Mips_classify_reloc
<elfcpp::SHT_REL
, size
, big_endian
>::
11412 r_type
= Mips_classify_reloc
<elfcpp::SHT_REL
, size
, big_endian
>::
11420 typedef Mips_relocate_functions
<size
, big_endian
> Reloc_funcs
;
11421 typename
Reloc_funcs::Status reloc_status
= Reloc_funcs::STATUS_OKAY
;
11423 Mips_relobj
<size
, big_endian
>* object
=
11424 Mips_relobj
<size
, big_endian
>::as_mips_relobj(relinfo
->object
);
11426 bool target_is_16_bit_code
= false;
11427 bool target_is_micromips_code
= false;
11428 bool cross_mode_jump
;
11430 Symbol_value
<size
> symval
;
11432 const Mips_symbol
<size
>* mips_sym
= Mips_symbol
<size
>::as_mips_sym(gsym
);
11434 bool changed_symbol_value
= false;
11437 target_is_16_bit_code
= object
->local_symbol_is_mips16(r_sym
);
11438 target_is_micromips_code
= object
->local_symbol_is_micromips(r_sym
);
11439 if (target_is_16_bit_code
|| target_is_micromips_code
)
11441 // MIPS16/microMIPS text labels should be treated as odd.
11442 symval
.set_output_value(psymval
->value(object
, 1));
11444 changed_symbol_value
= true;
11449 target_is_16_bit_code
= mips_sym
->is_mips16();
11450 target_is_micromips_code
= mips_sym
->is_micromips();
11452 // If this is a mips16/microMIPS text symbol, add 1 to the value to make
11453 // it odd. This will cause something like .word SYM to come up with
11454 // the right value when it is loaded into the PC.
11456 if ((mips_sym
->is_mips16() || mips_sym
->is_micromips())
11457 && psymval
->value(object
, 0) != 0)
11459 symval
.set_output_value(psymval
->value(object
, 0) | 1);
11461 changed_symbol_value
= true;
11464 // Pick the value to use for symbols defined in shared objects.
11465 if (mips_sym
->use_plt_offset(Scan::get_reference_flags(r_type
))
11466 || mips_sym
->has_lazy_stub())
11468 Mips_address value
;
11469 if (!mips_sym
->has_lazy_stub())
11471 // Prefer a standard MIPS PLT entry.
11472 if (mips_sym
->has_mips_plt_offset())
11474 value
= target
->plt_section()->mips_entry_address(mips_sym
);
11475 target_is_micromips_code
= false;
11476 target_is_16_bit_code
= false;
11480 value
= (target
->plt_section()->comp_entry_address(mips_sym
)
11482 if (target
->is_output_micromips())
11483 target_is_micromips_code
= true;
11485 target_is_16_bit_code
= true;
11489 value
= target
->mips_stubs_section()->stub_address(mips_sym
);
11491 symval
.set_output_value(value
);
11496 // TRUE if the symbol referred to by this relocation is "_gp_disp".
11497 // Note that such a symbol must always be a global symbol.
11498 bool gp_disp
= (gsym
!= NULL
&& (strcmp(gsym
->name(), "_gp_disp") == 0)
11499 && !object
->is_newabi());
11501 // TRUE if the symbol referred to by this relocation is "__gnu_local_gp".
11502 // Note that such a symbol must always be a global symbol.
11503 bool gnu_local_gp
= gsym
&& (strcmp(gsym
->name(), "__gnu_local_gp") == 0);
11508 if (!hi16_reloc(r_type
) && !lo16_reloc(r_type
))
11509 gold_error_at_location(relinfo
, relnum
, r_offset
,
11510 _("relocations against _gp_disp are permitted only"
11511 " with R_MIPS_HI16 and R_MIPS_LO16 relocations."));
11513 else if (gnu_local_gp
)
11515 // __gnu_local_gp is _gp symbol.
11516 symval
.set_output_value(target
->adjusted_gp_value(object
));
11520 // If this is a reference to a 16-bit function with a stub, we need
11521 // to redirect the relocation to the stub unless:
11523 // (a) the relocation is for a MIPS16 JAL;
11525 // (b) the relocation is for a MIPS16 PIC call, and there are no
11526 // non-MIPS16 uses of the GOT slot; or
11528 // (c) the section allows direct references to MIPS16 functions.
11529 if (r_type
!= elfcpp::R_MIPS16_26
11530 && !parameters
->options().relocatable()
11531 && ((mips_sym
!= NULL
11532 && mips_sym
->has_mips16_fn_stub()
11533 && (r_type
!= elfcpp::R_MIPS16_CALL16
|| mips_sym
->need_fn_stub()))
11534 || (mips_sym
== NULL
11535 && object
->get_local_mips16_fn_stub(r_sym
) != NULL
))
11536 && !object
->section_allows_mips16_refs(relinfo
->data_shndx
))
11538 // This is a 32- or 64-bit call to a 16-bit function. We should
11539 // have already noticed that we were going to need the
11541 Mips_address value
;
11542 if (mips_sym
== NULL
)
11543 value
= object
->get_local_mips16_fn_stub(r_sym
)->output_address();
11546 gold_assert(mips_sym
->need_fn_stub());
11547 if (mips_sym
->has_la25_stub())
11548 value
= target
->la25_stub_section()->stub_address(mips_sym
);
11551 value
= mips_sym
->template
11552 get_mips16_fn_stub
<big_endian
>()->output_address();
11555 symval
.set_output_value(value
);
11557 changed_symbol_value
= true;
11559 // The target is 16-bit, but the stub isn't.
11560 target_is_16_bit_code
= false;
11562 // If this is a MIPS16 call with a stub, that is made through the PLT or
11563 // to a standard MIPS function, we need to redirect the call to the stub.
11564 // Note that we specifically exclude R_MIPS16_CALL16 from this behavior;
11565 // indirect calls should use an indirect stub instead.
11566 else if (r_type
== elfcpp::R_MIPS16_26
&& !parameters
->options().relocatable()
11567 && ((mips_sym
!= NULL
11568 && (mips_sym
->has_mips16_call_stub()
11569 || mips_sym
->has_mips16_call_fp_stub()))
11570 || (mips_sym
== NULL
11571 && object
->get_local_mips16_call_stub(r_sym
) != NULL
))
11572 && ((mips_sym
!= NULL
&& mips_sym
->has_plt_offset())
11573 || !target_is_16_bit_code
))
11575 Mips16_stub_section
<size
, big_endian
>* call_stub
;
11576 if (mips_sym
== NULL
)
11577 call_stub
= object
->get_local_mips16_call_stub(r_sym
);
11580 // If both call_stub and call_fp_stub are defined, we can figure
11581 // out which one to use by checking which one appears in the input
11583 if (mips_sym
->has_mips16_call_stub()
11584 && mips_sym
->has_mips16_call_fp_stub())
11587 for (unsigned int i
= 1; i
< object
->shnum(); ++i
)
11589 if (object
->is_mips16_call_fp_stub_section(i
))
11591 call_stub
= mips_sym
->template
11592 get_mips16_call_fp_stub
<big_endian
>();
11597 if (call_stub
== NULL
)
11599 mips_sym
->template get_mips16_call_stub
<big_endian
>();
11601 else if (mips_sym
->has_mips16_call_stub())
11602 call_stub
= mips_sym
->template get_mips16_call_stub
<big_endian
>();
11604 call_stub
= mips_sym
->template get_mips16_call_fp_stub
<big_endian
>();
11607 symval
.set_output_value(call_stub
->output_address());
11609 changed_symbol_value
= true;
11611 // If this is a direct call to a PIC function, redirect to the
11613 else if (mips_sym
!= NULL
11614 && mips_sym
->has_la25_stub()
11615 && relocation_needs_la25_stub
<size
, big_endian
>(
11616 object
, r_type
, target_is_16_bit_code
))
11618 Mips_address value
= target
->la25_stub_section()->stub_address(mips_sym
);
11619 if (mips_sym
->is_micromips())
11621 symval
.set_output_value(value
);
11624 // For direct MIPS16 and microMIPS calls make sure the compressed PLT
11625 // entry is used if a standard PLT entry has also been made.
11626 else if ((r_type
== elfcpp::R_MIPS16_26
11627 || r_type
== elfcpp::R_MICROMIPS_26_S1
)
11628 && !parameters
->options().relocatable()
11629 && mips_sym
!= NULL
11630 && mips_sym
->has_plt_offset()
11631 && mips_sym
->has_comp_plt_offset()
11632 && mips_sym
->has_mips_plt_offset())
11634 Mips_address value
= (target
->plt_section()->comp_entry_address(mips_sym
)
11636 symval
.set_output_value(value
);
11639 target_is_16_bit_code
= !target
->is_output_micromips();
11640 target_is_micromips_code
= target
->is_output_micromips();
11643 // Make sure MIPS16 and microMIPS are not used together.
11644 if ((r_type
== elfcpp::R_MIPS16_26
&& target_is_micromips_code
)
11645 || (micromips_branch_reloc(r_type
) && target_is_16_bit_code
))
11647 gold_error(_("MIPS16 and microMIPS functions cannot call each other"));
11650 // Calls from 16-bit code to 32-bit code and vice versa require the
11651 // mode change. However, we can ignore calls to undefined weak symbols,
11652 // which should never be executed at runtime. This exception is important
11653 // because the assembly writer may have "known" that any definition of the
11654 // symbol would be 16-bit code, and that direct jumps were therefore
11657 (!parameters
->options().relocatable()
11658 && !(gsym
!= NULL
&& gsym
->is_weak_undefined())
11659 && ((r_type
== elfcpp::R_MIPS16_26
&& !target_is_16_bit_code
)
11660 || (r_type
== elfcpp::R_MICROMIPS_26_S1
&& !target_is_micromips_code
)
11661 || ((r_type
== elfcpp::R_MIPS_26
|| r_type
== elfcpp::R_MIPS_JALR
)
11662 && (target_is_16_bit_code
|| target_is_micromips_code
))));
11664 bool local
= (mips_sym
== NULL
11665 || (mips_sym
->got_only_for_calls()
11666 ? symbol_calls_local(mips_sym
, mips_sym
->has_dynsym_index())
11667 : symbol_references_local(mips_sym
,
11668 mips_sym
->has_dynsym_index())));
11670 // Global R_MIPS_GOT_PAGE/R_MICROMIPS_GOT_PAGE relocations are equivalent
11671 // to R_MIPS_GOT_DISP/R_MICROMIPS_GOT_DISP. The addend is applied by the
11672 // corresponding R_MIPS_GOT_OFST/R_MICROMIPS_GOT_OFST.
11673 if (got_page_reloc(r_type
) && !local
)
11674 r_type
= (micromips_reloc(r_type
) ? elfcpp::R_MICROMIPS_GOT_DISP
11675 : elfcpp::R_MIPS_GOT_DISP
);
11677 unsigned int got_offset
= 0;
11680 bool calculate_only
= false;
11681 Valtype calculated_value
= 0;
11682 bool extract_addend
= rel_type
== elfcpp::SHT_REL
;
11683 unsigned int r_types
[3] = { r_type
, r_type2
, r_type3
};
11685 Reloc_funcs::mips_reloc_unshuffle(view
, r_type
, false);
11687 // For Mips64 N64 ABI, there may be up to three operations specified per
11688 // record, by the fields r_type, r_type2, and r_type3. The first operation
11689 // takes its addend from the relocation record. Each subsequent operation
11690 // takes as its addend the result of the previous operation.
11691 // The first operation in a record which references a symbol uses the symbol
11692 // implied by r_sym. The next operation in a record which references a symbol
11693 // uses the special symbol value given by the r_ssym field. A third operation
11694 // in a record which references a symbol will assume a NULL symbol,
11695 // i.e. value zero.
11698 // Check if a record references to a symbol.
11699 for (unsigned int i
= 0; i
< 3; ++i
)
11701 if (r_types
[i
] == elfcpp::R_MIPS_NONE
)
11705 // Check if the next relocation is for the same instruction.
11706 calculate_only
= i
== 2 ? false
11707 : r_types
[i
+1] != elfcpp::R_MIPS_NONE
;
11709 if (object
->is_n64())
11713 // Handle special symbol for r_type2 relocation type.
11717 symval
.set_output_value(0);
11720 symval
.set_output_value(target
->gp_value());
11723 symval
.set_output_value(object
->gp_value());
11726 symval
.set_output_value(address
);
11729 gold_unreachable();
11735 // For r_type3 symbol value is 0.
11736 symval
.set_output_value(0);
11740 bool update_got_entry
= false;
11741 switch (r_types
[i
])
11743 case elfcpp::R_MIPS_NONE
:
11745 case elfcpp::R_MIPS_16
:
11746 reloc_status
= Reloc_funcs::rel16(view
, object
, psymval
, r_addend
,
11747 extract_addend
, calculate_only
,
11748 &calculated_value
);
11751 case elfcpp::R_MIPS_32
:
11752 if (should_apply_static_reloc(mips_sym
, r_types
[i
], output_section
,
11754 reloc_status
= Reloc_funcs::rel32(view
, object
, psymval
, r_addend
,
11755 extract_addend
, calculate_only
,
11756 &calculated_value
);
11757 if (mips_sym
!= NULL
11758 && (mips_sym
->is_mips16() || mips_sym
->is_micromips())
11759 && mips_sym
->global_got_area() == GGA_RELOC_ONLY
)
11761 // If mips_sym->has_mips16_fn_stub() is false, symbol value is
11762 // already updated by adding +1.
11763 if (mips_sym
->has_mips16_fn_stub())
11765 gold_assert(mips_sym
->need_fn_stub());
11766 Mips16_stub_section
<size
, big_endian
>* fn_stub
=
11767 mips_sym
->template get_mips16_fn_stub
<big_endian
>();
11769 symval
.set_output_value(fn_stub
->output_address());
11772 got_offset
= mips_sym
->global_gotoffset();
11773 update_got_entry
= true;
11777 case elfcpp::R_MIPS_64
:
11778 if (should_apply_static_reloc(mips_sym
, r_types
[i
], output_section
,
11780 reloc_status
= Reloc_funcs::rel64(view
, object
, psymval
, r_addend
,
11781 extract_addend
, calculate_only
,
11782 &calculated_value
, false);
11783 else if (target
->is_output_n64() && r_addend
!= 0)
11784 // Only apply the addend. The static relocation was RELA, but the
11785 // dynamic relocation is REL, so we need to apply the addend.
11786 reloc_status
= Reloc_funcs::rel64(view
, object
, psymval
, r_addend
,
11787 extract_addend
, calculate_only
,
11788 &calculated_value
, true);
11790 case elfcpp::R_MIPS_REL32
:
11791 gold_unreachable();
11793 case elfcpp::R_MIPS_PC32
:
11794 reloc_status
= Reloc_funcs::relpc32(view
, object
, psymval
, address
,
11795 r_addend
, extract_addend
,
11797 &calculated_value
);
11800 case elfcpp::R_MIPS16_26
:
11801 // The calculation for R_MIPS16_26 is just the same as for an
11802 // R_MIPS_26. It's only the storage of the relocated field into
11803 // the output file that's different. So, we just fall through to the
11804 // R_MIPS_26 case here.
11805 case elfcpp::R_MIPS_26
:
11806 case elfcpp::R_MICROMIPS_26_S1
:
11807 reloc_status
= Reloc_funcs::rel26(view
, object
, psymval
, address
,
11808 gsym
== NULL
, r_addend
, extract_addend
, gsym
, cross_mode_jump
,
11809 r_types
[i
], target
->jal_to_bal(), calculate_only
,
11810 &calculated_value
);
11813 case elfcpp::R_MIPS_HI16
:
11814 case elfcpp::R_MIPS16_HI16
:
11815 case elfcpp::R_MICROMIPS_HI16
:
11816 if (rel_type
== elfcpp::SHT_RELA
)
11817 reloc_status
= Reloc_funcs::do_relhi16(view
, object
, psymval
,
11819 gp_disp
, r_types
[i
],
11821 target
, calculate_only
,
11822 &calculated_value
);
11823 else if (rel_type
== elfcpp::SHT_REL
)
11824 reloc_status
= Reloc_funcs::relhi16(view
, object
, psymval
, r_addend
,
11825 address
, gp_disp
, r_types
[i
],
11826 r_sym
, extract_addend
);
11828 gold_unreachable();
11831 case elfcpp::R_MIPS_LO16
:
11832 case elfcpp::R_MIPS16_LO16
:
11833 case elfcpp::R_MICROMIPS_LO16
:
11834 case elfcpp::R_MICROMIPS_HI0_LO16
:
11835 reloc_status
= Reloc_funcs::rello16(target
, view
, object
, psymval
,
11836 r_addend
, extract_addend
, address
,
11837 gp_disp
, r_types
[i
], r_sym
,
11838 rel_type
, calculate_only
,
11839 &calculated_value
);
11842 case elfcpp::R_MIPS_LITERAL
:
11843 case elfcpp::R_MICROMIPS_LITERAL
:
11844 // Because we don't merge literal sections, we can handle this
11845 // just like R_MIPS_GPREL16. In the long run, we should merge
11846 // shared literals, and then we will need to additional work
11851 case elfcpp::R_MIPS_GPREL16
:
11852 case elfcpp::R_MIPS16_GPREL
:
11853 case elfcpp::R_MICROMIPS_GPREL7_S2
:
11854 case elfcpp::R_MICROMIPS_GPREL16
:
11855 reloc_status
= Reloc_funcs::relgprel(view
, object
, psymval
,
11856 target
->adjusted_gp_value(object
),
11857 r_addend
, extract_addend
,
11858 gsym
== NULL
, r_types
[i
],
11859 calculate_only
, &calculated_value
);
11862 case elfcpp::R_MIPS_PC16
:
11863 reloc_status
= Reloc_funcs::relpc16(view
, object
, psymval
, address
,
11864 r_addend
, extract_addend
,
11866 &calculated_value
);
11869 case elfcpp::R_MIPS_PC21_S2
:
11870 reloc_status
= Reloc_funcs::relpc21(view
, object
, psymval
, address
,
11871 r_addend
, extract_addend
,
11873 &calculated_value
);
11876 case elfcpp::R_MIPS_PC26_S2
:
11877 reloc_status
= Reloc_funcs::relpc26(view
, object
, psymval
, address
,
11878 r_addend
, extract_addend
,
11880 &calculated_value
);
11883 case elfcpp::R_MIPS_PC18_S3
:
11884 reloc_status
= Reloc_funcs::relpc18(view
, object
, psymval
, address
,
11885 r_addend
, extract_addend
,
11887 &calculated_value
);
11890 case elfcpp::R_MIPS_PC19_S2
:
11891 reloc_status
= Reloc_funcs::relpc19(view
, object
, psymval
, address
,
11892 r_addend
, extract_addend
,
11894 &calculated_value
);
11897 case elfcpp::R_MIPS_PCHI16
:
11898 if (rel_type
== elfcpp::SHT_RELA
)
11899 reloc_status
= Reloc_funcs::do_relpchi16(view
, object
, psymval
,
11903 &calculated_value
);
11904 else if (rel_type
== elfcpp::SHT_REL
)
11905 reloc_status
= Reloc_funcs::relpchi16(view
, object
, psymval
,
11906 r_addend
, address
, r_sym
,
11909 gold_unreachable();
11912 case elfcpp::R_MIPS_PCLO16
:
11913 reloc_status
= Reloc_funcs::relpclo16(view
, object
, psymval
, r_addend
,
11914 extract_addend
, address
, r_sym
,
11915 rel_type
, calculate_only
,
11916 &calculated_value
);
11918 case elfcpp::R_MICROMIPS_PC7_S1
:
11919 reloc_status
= Reloc_funcs::relmicromips_pc7_s1(view
, object
, psymval
,
11923 &calculated_value
);
11925 case elfcpp::R_MICROMIPS_PC10_S1
:
11926 reloc_status
= Reloc_funcs::relmicromips_pc10_s1(view
, object
,
11928 r_addend
, extract_addend
,
11930 &calculated_value
);
11932 case elfcpp::R_MICROMIPS_PC16_S1
:
11933 reloc_status
= Reloc_funcs::relmicromips_pc16_s1(view
, object
,
11935 r_addend
, extract_addend
,
11937 &calculated_value
);
11939 case elfcpp::R_MIPS_GPREL32
:
11940 reloc_status
= Reloc_funcs::relgprel32(view
, object
, psymval
,
11941 target
->adjusted_gp_value(object
),
11942 r_addend
, extract_addend
,
11944 &calculated_value
);
11946 case elfcpp::R_MIPS_GOT_HI16
:
11947 case elfcpp::R_MIPS_CALL_HI16
:
11948 case elfcpp::R_MICROMIPS_GOT_HI16
:
11949 case elfcpp::R_MICROMIPS_CALL_HI16
:
11951 got_offset
= target
->got_section()->got_offset(gsym
,
11955 got_offset
= target
->got_section()->got_offset(r_sym
,
11958 gp_offset
= target
->got_section()->gp_offset(got_offset
, object
);
11959 reloc_status
= Reloc_funcs::relgot_hi16(view
, gp_offset
,
11961 &calculated_value
);
11962 update_got_entry
= changed_symbol_value
;
11965 case elfcpp::R_MIPS_GOT_LO16
:
11966 case elfcpp::R_MIPS_CALL_LO16
:
11967 case elfcpp::R_MICROMIPS_GOT_LO16
:
11968 case elfcpp::R_MICROMIPS_CALL_LO16
:
11970 got_offset
= target
->got_section()->got_offset(gsym
,
11974 got_offset
= target
->got_section()->got_offset(r_sym
,
11977 gp_offset
= target
->got_section()->gp_offset(got_offset
, object
);
11978 reloc_status
= Reloc_funcs::relgot_lo16(view
, gp_offset
,
11980 &calculated_value
);
11981 update_got_entry
= changed_symbol_value
;
11984 case elfcpp::R_MIPS_GOT_DISP
:
11985 case elfcpp::R_MICROMIPS_GOT_DISP
:
11986 case elfcpp::R_MIPS_EH
:
11988 got_offset
= target
->got_section()->got_offset(gsym
,
11992 got_offset
= target
->got_section()->got_offset(r_sym
,
11995 gp_offset
= target
->got_section()->gp_offset(got_offset
, object
);
11996 if (eh_reloc(r_types
[i
]))
11997 reloc_status
= Reloc_funcs::releh(view
, gp_offset
,
11999 &calculated_value
);
12001 reloc_status
= Reloc_funcs::relgot(view
, gp_offset
,
12003 &calculated_value
);
12005 case elfcpp::R_MIPS_CALL16
:
12006 case elfcpp::R_MIPS16_CALL16
:
12007 case elfcpp::R_MICROMIPS_CALL16
:
12008 gold_assert(gsym
!= NULL
);
12009 got_offset
= target
->got_section()->got_offset(gsym
,
12012 gp_offset
= target
->got_section()->gp_offset(got_offset
, object
);
12013 reloc_status
= Reloc_funcs::relgot(view
, gp_offset
,
12014 calculate_only
, &calculated_value
);
12015 // TODO(sasa): We should also initialize update_got_entry
12016 // in other place swhere relgot is called.
12017 update_got_entry
= changed_symbol_value
;
12020 case elfcpp::R_MIPS_GOT16
:
12021 case elfcpp::R_MIPS16_GOT16
:
12022 case elfcpp::R_MICROMIPS_GOT16
:
12025 got_offset
= target
->got_section()->got_offset(gsym
,
12028 gp_offset
= target
->got_section()->gp_offset(got_offset
, object
);
12029 reloc_status
= Reloc_funcs::relgot(view
, gp_offset
,
12031 &calculated_value
);
12035 if (rel_type
== elfcpp::SHT_RELA
)
12036 reloc_status
= Reloc_funcs::do_relgot16_local(view
, object
,
12041 &calculated_value
);
12042 else if (rel_type
== elfcpp::SHT_REL
)
12043 reloc_status
= Reloc_funcs::relgot16_local(view
, object
,
12046 r_types
[i
], r_sym
);
12048 gold_unreachable();
12050 update_got_entry
= changed_symbol_value
;
12053 case elfcpp::R_MIPS_TLS_GD
:
12054 case elfcpp::R_MIPS16_TLS_GD
:
12055 case elfcpp::R_MICROMIPS_TLS_GD
:
12057 got_offset
= target
->got_section()->got_offset(gsym
,
12061 got_offset
= target
->got_section()->got_offset(r_sym
,
12064 gp_offset
= target
->got_section()->gp_offset(got_offset
, object
);
12065 reloc_status
= Reloc_funcs::relgot(view
, gp_offset
, calculate_only
,
12066 &calculated_value
);
12069 case elfcpp::R_MIPS_TLS_GOTTPREL
:
12070 case elfcpp::R_MIPS16_TLS_GOTTPREL
:
12071 case elfcpp::R_MICROMIPS_TLS_GOTTPREL
:
12073 got_offset
= target
->got_section()->got_offset(gsym
,
12074 GOT_TYPE_TLS_OFFSET
,
12077 got_offset
= target
->got_section()->got_offset(r_sym
,
12078 GOT_TYPE_TLS_OFFSET
,
12080 gp_offset
= target
->got_section()->gp_offset(got_offset
, object
);
12081 reloc_status
= Reloc_funcs::relgot(view
, gp_offset
, calculate_only
,
12082 &calculated_value
);
12085 case elfcpp::R_MIPS_TLS_LDM
:
12086 case elfcpp::R_MIPS16_TLS_LDM
:
12087 case elfcpp::R_MICROMIPS_TLS_LDM
:
12088 // Relocate the field with the offset of the GOT entry for
12089 // the module index.
12090 got_offset
= target
->got_section()->tls_ldm_offset(object
);
12091 gp_offset
= target
->got_section()->gp_offset(got_offset
, object
);
12092 reloc_status
= Reloc_funcs::relgot(view
, gp_offset
, calculate_only
,
12093 &calculated_value
);
12096 case elfcpp::R_MIPS_GOT_PAGE
:
12097 case elfcpp::R_MICROMIPS_GOT_PAGE
:
12098 reloc_status
= Reloc_funcs::relgotpage(target
, view
, object
, psymval
,
12099 r_addend
, extract_addend
,
12101 &calculated_value
);
12104 case elfcpp::R_MIPS_GOT_OFST
:
12105 case elfcpp::R_MICROMIPS_GOT_OFST
:
12106 reloc_status
= Reloc_funcs::relgotofst(target
, view
, object
, psymval
,
12107 r_addend
, extract_addend
,
12108 local
, calculate_only
,
12109 &calculated_value
);
12112 case elfcpp::R_MIPS_JALR
:
12113 case elfcpp::R_MICROMIPS_JALR
:
12114 // This relocation is only a hint. In some cases, we optimize
12115 // it into a bal instruction. But we don't try to optimize
12116 // when the symbol does not resolve locally.
12118 || symbol_calls_local(gsym
, gsym
->has_dynsym_index()))
12119 reloc_status
= Reloc_funcs::reljalr(view
, object
, psymval
, address
,
12120 r_addend
, extract_addend
,
12121 cross_mode_jump
, r_types
[i
],
12122 target
->jalr_to_bal(),
12125 &calculated_value
);
12128 case elfcpp::R_MIPS_TLS_DTPREL_HI16
:
12129 case elfcpp::R_MIPS16_TLS_DTPREL_HI16
:
12130 case elfcpp::R_MICROMIPS_TLS_DTPREL_HI16
:
12131 reloc_status
= Reloc_funcs::tlsrelhi16(view
, object
, psymval
,
12132 elfcpp::DTP_OFFSET
, r_addend
,
12133 extract_addend
, calculate_only
,
12134 &calculated_value
);
12136 case elfcpp::R_MIPS_TLS_DTPREL_LO16
:
12137 case elfcpp::R_MIPS16_TLS_DTPREL_LO16
:
12138 case elfcpp::R_MICROMIPS_TLS_DTPREL_LO16
:
12139 reloc_status
= Reloc_funcs::tlsrello16(view
, object
, psymval
,
12140 elfcpp::DTP_OFFSET
, r_addend
,
12141 extract_addend
, calculate_only
,
12142 &calculated_value
);
12144 case elfcpp::R_MIPS_TLS_DTPREL32
:
12145 case elfcpp::R_MIPS_TLS_DTPREL64
:
12146 reloc_status
= Reloc_funcs::tlsrel32(view
, object
, psymval
,
12147 elfcpp::DTP_OFFSET
, r_addend
,
12148 extract_addend
, calculate_only
,
12149 &calculated_value
);
12151 case elfcpp::R_MIPS_TLS_TPREL_HI16
:
12152 case elfcpp::R_MIPS16_TLS_TPREL_HI16
:
12153 case elfcpp::R_MICROMIPS_TLS_TPREL_HI16
:
12154 reloc_status
= Reloc_funcs::tlsrelhi16(view
, object
, psymval
,
12155 elfcpp::TP_OFFSET
, r_addend
,
12156 extract_addend
, calculate_only
,
12157 &calculated_value
);
12159 case elfcpp::R_MIPS_TLS_TPREL_LO16
:
12160 case elfcpp::R_MIPS16_TLS_TPREL_LO16
:
12161 case elfcpp::R_MICROMIPS_TLS_TPREL_LO16
:
12162 reloc_status
= Reloc_funcs::tlsrello16(view
, object
, psymval
,
12163 elfcpp::TP_OFFSET
, r_addend
,
12164 extract_addend
, calculate_only
,
12165 &calculated_value
);
12167 case elfcpp::R_MIPS_TLS_TPREL32
:
12168 case elfcpp::R_MIPS_TLS_TPREL64
:
12169 reloc_status
= Reloc_funcs::tlsrel32(view
, object
, psymval
,
12170 elfcpp::TP_OFFSET
, r_addend
,
12171 extract_addend
, calculate_only
,
12172 &calculated_value
);
12174 case elfcpp::R_MIPS_SUB
:
12175 case elfcpp::R_MICROMIPS_SUB
:
12176 reloc_status
= Reloc_funcs::relsub(view
, object
, psymval
, r_addend
,
12178 calculate_only
, &calculated_value
);
12180 case elfcpp::R_MIPS_HIGHER
:
12181 case elfcpp::R_MICROMIPS_HIGHER
:
12182 reloc_status
= Reloc_funcs::relhigher(view
, object
, psymval
, r_addend
,
12183 extract_addend
, calculate_only
,
12184 &calculated_value
);
12186 case elfcpp::R_MIPS_HIGHEST
:
12187 case elfcpp::R_MICROMIPS_HIGHEST
:
12188 reloc_status
= Reloc_funcs::relhighest(view
, object
, psymval
,
12189 r_addend
, extract_addend
,
12191 &calculated_value
);
12194 gold_error_at_location(relinfo
, relnum
, r_offset
,
12195 _("unsupported reloc %u"), r_types
[i
]);
12199 if (update_got_entry
)
12201 Mips_output_data_got
<size
, big_endian
>* got
= target
->got_section();
12202 if (mips_sym
!= NULL
&& mips_sym
->get_applied_secondary_got_fixup())
12203 got
->update_got_entry(got
->get_primary_got_offset(mips_sym
),
12204 psymval
->value(object
, 0));
12206 got
->update_got_entry(got_offset
, psymval
->value(object
, 0));
12209 r_addend
= calculated_value
;
12212 bool jal_shuffle
= jal_reloc(r_type
) ? !parameters
->options().relocatable()
12214 Reloc_funcs::mips_reloc_shuffle(view
, r_type
, jal_shuffle
);
12216 // Report any errors.
12217 switch (reloc_status
)
12219 case Reloc_funcs::STATUS_OKAY
:
12221 case Reloc_funcs::STATUS_OVERFLOW
:
12222 gold_error_at_location(relinfo
, relnum
, r_offset
,
12223 _("relocation overflow"));
12225 case Reloc_funcs::STATUS_BAD_RELOC
:
12226 gold_error_at_location(relinfo
, relnum
, r_offset
,
12227 _("unexpected opcode while processing relocation"));
12229 case Reloc_funcs::STATUS_PCREL_UNALIGNED
:
12230 gold_error_at_location(relinfo
, relnum
, r_offset
,
12231 _("unaligned PC-relative relocation"));
12234 gold_unreachable();
12240 // Get the Reference_flags for a particular relocation.
12242 template<int size
, bool big_endian
>
12244 Target_mips
<size
, big_endian
>::Scan::get_reference_flags(
12245 unsigned int r_type
)
12249 case elfcpp::R_MIPS_NONE
:
12250 // No symbol reference.
12253 case elfcpp::R_MIPS_16
:
12254 case elfcpp::R_MIPS_32
:
12255 case elfcpp::R_MIPS_64
:
12256 case elfcpp::R_MIPS_HI16
:
12257 case elfcpp::R_MIPS_LO16
:
12258 case elfcpp::R_MIPS_HIGHER
:
12259 case elfcpp::R_MIPS_HIGHEST
:
12260 case elfcpp::R_MIPS16_HI16
:
12261 case elfcpp::R_MIPS16_LO16
:
12262 case elfcpp::R_MICROMIPS_HI16
:
12263 case elfcpp::R_MICROMIPS_LO16
:
12264 case elfcpp::R_MICROMIPS_HIGHER
:
12265 case elfcpp::R_MICROMIPS_HIGHEST
:
12266 return Symbol::ABSOLUTE_REF
;
12268 case elfcpp::R_MIPS_26
:
12269 case elfcpp::R_MIPS16_26
:
12270 case elfcpp::R_MICROMIPS_26_S1
:
12271 return Symbol::FUNCTION_CALL
| Symbol::ABSOLUTE_REF
;
12273 case elfcpp::R_MIPS_PC18_S3
:
12274 case elfcpp::R_MIPS_PC19_S2
:
12275 case elfcpp::R_MIPS_PCHI16
:
12276 case elfcpp::R_MIPS_PCLO16
:
12277 case elfcpp::R_MIPS_GPREL32
:
12278 case elfcpp::R_MIPS_GPREL16
:
12279 case elfcpp::R_MIPS_REL32
:
12280 case elfcpp::R_MIPS16_GPREL
:
12281 return Symbol::RELATIVE_REF
;
12283 case elfcpp::R_MIPS_PC16
:
12284 case elfcpp::R_MIPS_PC32
:
12285 case elfcpp::R_MIPS_PC21_S2
:
12286 case elfcpp::R_MIPS_PC26_S2
:
12287 case elfcpp::R_MIPS_JALR
:
12288 case elfcpp::R_MICROMIPS_JALR
:
12289 return Symbol::FUNCTION_CALL
| Symbol::RELATIVE_REF
;
12291 case elfcpp::R_MIPS_GOT16
:
12292 case elfcpp::R_MIPS_CALL16
:
12293 case elfcpp::R_MIPS_GOT_DISP
:
12294 case elfcpp::R_MIPS_GOT_HI16
:
12295 case elfcpp::R_MIPS_GOT_LO16
:
12296 case elfcpp::R_MIPS_CALL_HI16
:
12297 case elfcpp::R_MIPS_CALL_LO16
:
12298 case elfcpp::R_MIPS_LITERAL
:
12299 case elfcpp::R_MIPS_GOT_PAGE
:
12300 case elfcpp::R_MIPS_GOT_OFST
:
12301 case elfcpp::R_MIPS16_GOT16
:
12302 case elfcpp::R_MIPS16_CALL16
:
12303 case elfcpp::R_MICROMIPS_GOT16
:
12304 case elfcpp::R_MICROMIPS_CALL16
:
12305 case elfcpp::R_MICROMIPS_GOT_HI16
:
12306 case elfcpp::R_MICROMIPS_GOT_LO16
:
12307 case elfcpp::R_MICROMIPS_CALL_HI16
:
12308 case elfcpp::R_MICROMIPS_CALL_LO16
:
12309 case elfcpp::R_MIPS_EH
:
12310 // Absolute in GOT.
12311 return Symbol::RELATIVE_REF
;
12313 case elfcpp::R_MIPS_TLS_DTPMOD32
:
12314 case elfcpp::R_MIPS_TLS_DTPREL32
:
12315 case elfcpp::R_MIPS_TLS_DTPMOD64
:
12316 case elfcpp::R_MIPS_TLS_DTPREL64
:
12317 case elfcpp::R_MIPS_TLS_GD
:
12318 case elfcpp::R_MIPS_TLS_LDM
:
12319 case elfcpp::R_MIPS_TLS_DTPREL_HI16
:
12320 case elfcpp::R_MIPS_TLS_DTPREL_LO16
:
12321 case elfcpp::R_MIPS_TLS_GOTTPREL
:
12322 case elfcpp::R_MIPS_TLS_TPREL32
:
12323 case elfcpp::R_MIPS_TLS_TPREL64
:
12324 case elfcpp::R_MIPS_TLS_TPREL_HI16
:
12325 case elfcpp::R_MIPS_TLS_TPREL_LO16
:
12326 case elfcpp::R_MIPS16_TLS_GD
:
12327 case elfcpp::R_MIPS16_TLS_GOTTPREL
:
12328 case elfcpp::R_MICROMIPS_TLS_GD
:
12329 case elfcpp::R_MICROMIPS_TLS_GOTTPREL
:
12330 case elfcpp::R_MICROMIPS_TLS_TPREL_HI16
:
12331 case elfcpp::R_MICROMIPS_TLS_TPREL_LO16
:
12332 return Symbol::TLS_REF
;
12334 case elfcpp::R_MIPS_COPY
:
12335 case elfcpp::R_MIPS_JUMP_SLOT
:
12337 gold_unreachable();
12338 // Not expected. We will give an error later.
12343 // Report an unsupported relocation against a local symbol.
12345 template<int size
, bool big_endian
>
12347 Target_mips
<size
, big_endian
>::Scan::unsupported_reloc_local(
12348 Sized_relobj_file
<size
, big_endian
>* object
,
12349 unsigned int r_type
)
12351 gold_error(_("%s: unsupported reloc %u against local symbol"),
12352 object
->name().c_str(), r_type
);
12355 // Report an unsupported relocation against a global symbol.
12357 template<int size
, bool big_endian
>
12359 Target_mips
<size
, big_endian
>::Scan::unsupported_reloc_global(
12360 Sized_relobj_file
<size
, big_endian
>* object
,
12361 unsigned int r_type
,
12364 gold_error(_("%s: unsupported reloc %u against global symbol %s"),
12365 object
->name().c_str(), r_type
, gsym
->demangled_name().c_str());
12368 // Return printable name for ABI.
12369 template<int size
, bool big_endian
>
12371 Target_mips
<size
, big_endian
>::elf_mips_abi_name(elfcpp::Elf_Word e_flags
)
12373 switch (e_flags
& elfcpp::EF_MIPS_ABI
)
12376 if ((e_flags
& elfcpp::EF_MIPS_ABI2
) != 0)
12378 else if (size
== 64)
12382 case elfcpp::E_MIPS_ABI_O32
:
12384 case elfcpp::E_MIPS_ABI_O64
:
12386 case elfcpp::E_MIPS_ABI_EABI32
:
12388 case elfcpp::E_MIPS_ABI_EABI64
:
12391 return "unknown abi";
12395 template<int size
, bool big_endian
>
12397 Target_mips
<size
, big_endian
>::elf_mips_mach_name(elfcpp::Elf_Word e_flags
)
12399 switch (e_flags
& elfcpp::EF_MIPS_MACH
)
12401 case elfcpp::E_MIPS_MACH_3900
:
12402 return "mips:3900";
12403 case elfcpp::E_MIPS_MACH_4010
:
12404 return "mips:4010";
12405 case elfcpp::E_MIPS_MACH_4100
:
12406 return "mips:4100";
12407 case elfcpp::E_MIPS_MACH_4111
:
12408 return "mips:4111";
12409 case elfcpp::E_MIPS_MACH_4120
:
12410 return "mips:4120";
12411 case elfcpp::E_MIPS_MACH_4650
:
12412 return "mips:4650";
12413 case elfcpp::E_MIPS_MACH_5400
:
12414 return "mips:5400";
12415 case elfcpp::E_MIPS_MACH_5500
:
12416 return "mips:5500";
12417 case elfcpp::E_MIPS_MACH_5900
:
12418 return "mips:5900";
12419 case elfcpp::E_MIPS_MACH_SB1
:
12421 case elfcpp::E_MIPS_MACH_9000
:
12422 return "mips:9000";
12423 case elfcpp::E_MIPS_MACH_LS2E
:
12424 return "mips:loongson_2e";
12425 case elfcpp::E_MIPS_MACH_LS2F
:
12426 return "mips:loongson_2f";
12427 case elfcpp::E_MIPS_MACH_LS3A
:
12428 return "mips:loongson_3a";
12429 case elfcpp::E_MIPS_MACH_OCTEON
:
12430 return "mips:octeon";
12431 case elfcpp::E_MIPS_MACH_OCTEON2
:
12432 return "mips:octeon2";
12433 case elfcpp::E_MIPS_MACH_OCTEON3
:
12434 return "mips:octeon3";
12435 case elfcpp::E_MIPS_MACH_XLR
:
12438 switch (e_flags
& elfcpp::EF_MIPS_ARCH
)
12441 case elfcpp::E_MIPS_ARCH_1
:
12442 return "mips:3000";
12444 case elfcpp::E_MIPS_ARCH_2
:
12445 return "mips:6000";
12447 case elfcpp::E_MIPS_ARCH_3
:
12448 return "mips:4000";
12450 case elfcpp::E_MIPS_ARCH_4
:
12451 return "mips:8000";
12453 case elfcpp::E_MIPS_ARCH_5
:
12454 return "mips:mips5";
12456 case elfcpp::E_MIPS_ARCH_32
:
12457 return "mips:isa32";
12459 case elfcpp::E_MIPS_ARCH_64
:
12460 return "mips:isa64";
12462 case elfcpp::E_MIPS_ARCH_32R2
:
12463 return "mips:isa32r2";
12465 case elfcpp::E_MIPS_ARCH_32R6
:
12466 return "mips:isa32r6";
12468 case elfcpp::E_MIPS_ARCH_64R2
:
12469 return "mips:isa64r2";
12471 case elfcpp::E_MIPS_ARCH_64R6
:
12472 return "mips:isa64r6";
12475 return "unknown CPU";
12478 template<int size
, bool big_endian
>
12479 const Target::Target_info Target_mips
<size
, big_endian
>::mips_info
=
12482 big_endian
, // is_big_endian
12483 elfcpp::EM_MIPS
, // machine_code
12484 true, // has_make_symbol
12485 false, // has_resolve
12486 false, // has_code_fill
12487 true, // is_default_stack_executable
12488 false, // can_icf_inline_merge_sections
12490 size
== 32 ? "/lib/ld.so.1" : "/lib64/ld.so.1", // dynamic_linker
12491 0x400000, // default_text_segment_address
12492 64 * 1024, // abi_pagesize (overridable by -z max-page-size)
12493 4 * 1024, // common_pagesize (overridable by -z common-page-size)
12494 false, // isolate_execinstr
12495 0, // rosegment_gap
12496 elfcpp::SHN_UNDEF
, // small_common_shndx
12497 elfcpp::SHN_UNDEF
, // large_common_shndx
12498 0, // small_common_section_flags
12499 0, // large_common_section_flags
12500 NULL
, // attributes_section
12501 NULL
, // attributes_vendor
12502 "__start", // entry_symbol_name
12503 32, // hash_entry_size
12506 template<int size
, bool big_endian
>
12507 class Target_mips_nacl
: public Target_mips
<size
, big_endian
>
12511 : Target_mips
<size
, big_endian
>(&mips_nacl_info
)
12515 static const Target::Target_info mips_nacl_info
;
12518 template<int size
, bool big_endian
>
12519 const Target::Target_info Target_mips_nacl
<size
, big_endian
>::mips_nacl_info
=
12522 big_endian
, // is_big_endian
12523 elfcpp::EM_MIPS
, // machine_code
12524 true, // has_make_symbol
12525 false, // has_resolve
12526 false, // has_code_fill
12527 true, // is_default_stack_executable
12528 false, // can_icf_inline_merge_sections
12530 "/lib/ld.so.1", // dynamic_linker
12531 0x20000, // default_text_segment_address
12532 0x10000, // abi_pagesize (overridable by -z max-page-size)
12533 0x10000, // common_pagesize (overridable by -z common-page-size)
12534 true, // isolate_execinstr
12535 0x10000000, // rosegment_gap
12536 elfcpp::SHN_UNDEF
, // small_common_shndx
12537 elfcpp::SHN_UNDEF
, // large_common_shndx
12538 0, // small_common_section_flags
12539 0, // large_common_section_flags
12540 NULL
, // attributes_section
12541 NULL
, // attributes_vendor
12542 "_start", // entry_symbol_name
12543 32, // hash_entry_size
12546 // Target selector for Mips. Note this is never instantiated directly.
12547 // It's only used in Target_selector_mips_nacl, below.
12549 template<int size
, bool big_endian
>
12550 class Target_selector_mips
: public Target_selector
12553 Target_selector_mips()
12554 : Target_selector(elfcpp::EM_MIPS
, size
, big_endian
,
12556 (big_endian
? "elf64-tradbigmips" : "elf64-tradlittlemips") :
12557 (big_endian
? "elf32-tradbigmips" : "elf32-tradlittlemips")),
12559 (big_endian
? "elf64btsmip" : "elf64ltsmip") :
12560 (big_endian
? "elf32btsmip" : "elf32ltsmip")))
12563 Target
* do_instantiate_target()
12564 { return new Target_mips
<size
, big_endian
>(); }
12567 template<int size
, bool big_endian
>
12568 class Target_selector_mips_nacl
12569 : public Target_selector_nacl
<Target_selector_mips
<size
, big_endian
>,
12570 Target_mips_nacl
<size
, big_endian
> >
12573 Target_selector_mips_nacl()
12574 : Target_selector_nacl
<Target_selector_mips
<size
, big_endian
>,
12575 Target_mips_nacl
<size
, big_endian
> >(
12576 // NaCl currently supports only MIPS32 little-endian.
12577 "mipsel", "elf32-tradlittlemips-nacl", "elf32-tradlittlemips-nacl")
12581 Target_selector_mips_nacl
<32, true> target_selector_mips32
;
12582 Target_selector_mips_nacl
<32, false> target_selector_mips32el
;
12583 Target_selector_mips_nacl
<64, true> target_selector_mips64
;
12584 Target_selector_mips_nacl
<64, false> target_selector_mips64el
;
12586 } // End anonymous namespace.